dart2js cps: Speed up integrity checking some more.

pkg/compiler/lib/src/cps_ir/cps_ir_integrity.dart

 library dart2js.cps_ir_integrity;
 
 import 'cps_ir_nodes.dart';
 import 'cps_ir_nodes_sexpr.dart';
 import '../tracer.dart' as tracer;
 
 /// Dump S-expressions on error if the tracer is enabled.
 ///
 /// Technically this has nothing to do with the tracer, but if you want one
 /// enabled, you typically want the other as well, so we use the same flag.
@@ skipping 15 matching lines @@
 /// - Each definition object occurs only once in the IR (no redeclaring).
 /// - Each reference object occurs only once in the IR (no sharing).
 ///
 class CheckCpsIntegrity extends TrampolineRecursiveVisitor {
 
   FunctionDefinition topLevelNode;
   final Map<Definition, ScopeType> inScope = <Definition, ScopeType>{};
   final List<Definition> definitions = [];
   String previousPass;
 
-  void setScope(Iterable<Definition> defs, ScopeType scope) {
-    for (Definition def in defs) {
-      inScope[def] = scope;
-    }
-  }

[asgerf, 2015/10/15 10:13:29]

This is an unused function I left here by accident.

-
   void handleDeclaration(Definition def) {
     definitions.add(def);
     // Check the reference chain for cycles broken links.
     Reference anchor = null;
     int i = 0;
     for (Reference ref = def.firstRef; ref != null; ref = ref.next) {
       if (ref.definition != def) {
         error('Reference to ${ref.definition} found in '
               'reference chain for $def', def);
       }
@@ skipping 18 matching lines @@
   }
 
   void enterContinuation(Continuation cont) {
     inScope[cont] = ScopeType.InDefinition;
     pushAction(() {
       inScope[cont] = ScopeType.NotInScope;
     });
   }
 
   void check(FunctionDefinition node, String previousPass) {
-    topLevelNode = node;
+    // [check] will be called multiple times per instance to avoid reallocating
+    // the large [inScope] map. Reset the other fields.
+    this.topLevelNode = node;
     this.previousPass = previousPass;
+    this.definitions.clear();
     ParentChecker.checkParents(node, this);
     visit(node);
     // Check for broken reference chains. We check this last, so out-of-scope
     // references are not classified as a broken reference chain.
     definitions.forEach(checkReferenceChain);
   }
 
   @override
   Expression traverseLetCont(LetCont node) {
     node.continuations.forEach(handleDeclaration);
@@ skipping 156 matching lines @@
   }
 
   @override
   processReference(Reference node) {
     if (node.parent != _parent) {
       error('Parent pointer on $node is ${node.parent} but should be $_parent',
             node);
     }
   }
 }