Forget closure class maps.

dart/tests/try/poi/forget_element_test.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // Test of Compiler.forgetElement.
 library trydart.forget_element_test;
 
 import 'package:compiler/implementation/elements/elements.dart' show
     AstElement,
     Element,
@@ skipping 26 matching lines @@
   final int expectedClosureCount;
 
   final int expectedMetadataCount;
 
   final int expectedConstantCount;
 
   final int expectedInitialValueCount;
 
   final int expectedInitialDartValueCount;
 
+  final int additionalClosureClassMaps;
+
   ForgetElementTestCase(
       String source,
       {int closureCount: 0,
        int metadataCount: 0,
        int constantCount: 0,
        int initialValueCount: 0,
-       int initialDartValueCount: null})
+       int initialDartValueCount: null,
+       this.additionalClosureClassMaps: 0})
       : this.expectedClosureCount = closureCount,
         this.expectedMetadataCount = metadataCount,
         this.expectedConstantCount = constantCount,
         this.expectedInitialValueCount = initialValueCount,
         // Sometimes these numbers aren't the same. Appears to happen with
         // non-const fields, because those aren't compile-time constants in the
         // strict language specification sense.
         this.expectedInitialDartValueCount = (initialDartValueCount == null)
             ? initialValueCount : initialDartValueCount,
         super(source);
@@ skipping 22 matching lines @@
     // values.
     Expect.equals(
         expectedInitialValueCount,
         elementsWithJsInitialValuesIn(library).length,
         'number of fields with initial values (JS)');
     Expect.equals(
         expectedInitialDartValueCount,
         elementsWithDartInitialValuesIn(library).length,
         'number of fields with initial values (Dart)');
 
+    // Check that the compiler has recorded the expected number of closure
+    // class maps. There's always at least one, from main. Each top-level
+    // element also seems to induce one.
+    Expect.equals(
+        expectedClosureCount + additionalClosureClassMaps,
+        closureClassMapsIn(library).length - 1,
+        'closure class map count ${closureClassMapsIn(library)}');
+
+
     // Forget about all elements.
     library.forEachLocalMember(compiler.forgetElement);
 
     // Check that all the closures were forgotten.
     Expect.isTrue(closuresInLibrary(library).isEmpty, 'closures');
 
     // Check that the metadata annotations were forgotten.
     Expect.isTrue(metadataInLibrary(library).isEmpty, 'metadata');
 
     // Check that the constants were forgotten.
     Expect.isTrue(constantsIn(library).isEmpty, 'constants');
 
     // Check that initial values were forgotten.
     Expect.isTrue(
         elementsWithJsInitialValuesIn(library).isEmpty,
         'fields with initial values (JS)');
     Expect.isTrue(
         elementsWithDartInitialValuesIn(library).isEmpty,
         'fields with initial values (Dart)');
+
+    // Check that closure class maps were forgotten.
+    Expect.isTrue(closureClassMapsIn(library).isEmpty, 'closure class maps');
   });
 
   Iterable closuresInLibrary(LibraryElement library) {
     return compiler.enqueuer.resolution.universe.allClosures.where(
         (LocalFunctionElement closure) => closure.library == library);
   }
 
   Iterable metadataInLibrary(LibraryElement library) {
     JavaScriptBackend backend = compiler.backend;
     return backend.constants.metadataConstantMap.keys.where(
@@ skipping 39 matching lines @@
   }
 
   Iterable elementsWithDartInitialValuesIn(LibraryElement library) {
     JavaScriptBackend backend = compiler.backend;
     DartConstantCompiler dartConstants =
         backend.constantCompilerTask.dartConstantCompiler;
     return dartConstants.initialVariableValues.keys.where(
         (VariableElement element) => element.library == library);
   }
 
+  Iterable closureClassMapsIn(LibraryElement library) {
+    Map cache = compiler.closureToClassMapper.closureMappingCache;
+    return nodesIn(library).where((node) => cache[node] != null);
+  }
 }
 
 class NodeCollector extends tree.Visitor {
   final List<tree.Node> nodes = <tree.Node>[];
 
   void visitNode(tree.Node node) {
     nodes.add(node);
     node.visitChildren(this);
   }
 }
@@ skipping 85 matching lines @@
         'main() => (() => (() => const Constant())())(); $CONSTANT_CLASS',
         constantCount: 1,
         closureCount: 2),
 
     // Test that a constant in a top-level variable initializer is
     // discarded correctly.
     new ForgetElementTestCase(
         'main() => x; var x = const Constant(); $CONSTANT_CLASS',
         constantCount: 1,
         initialValueCount: 1,
-        initialDartValueCount: 0),
+        initialDartValueCount: 0,
+        additionalClosureClassMaps: 1),
 
     // Test that a constant in a parameter initializer is discarded
     // correctly.
     new ForgetElementTestCase(
         'main([x = const Constant()]) => x; $CONSTANT_CLASS',
         constantCount: 1,
         initialValueCount: 1),
 
     // Test that a constant in a parameter initializer is discarded
     // correctly (nested function).
     new ForgetElementTestCase(
         'main() => (([x = const Constant()]) => x)(); $CONSTANT_CLASS',
         closureCount: 1,
         constantCount: 1,
         initialValueCount: 1),
 
     // Test that a constant in a parameter initializer is discarded
     // correctly (deeply nested function).
     new ForgetElementTestCase(
         'main() => (() => (([x = const Constant()]) => x)())();'
         ' $CONSTANT_CLASS',
         closureCount: 2,
         constantCount: 1,
         initialValueCount: 1),
 
 ]..addAll(assertUnimplementedLocalMetadata());