Speed up testing.

lib/kernel.dart

 // Copyright (c) 2016, 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.md file.
 
 library rasta.kernel;
 
 import 'dart:async' show
     Future;
 
 import 'dart:collection' show
@@ skipping 35 matching lines @@
 import 'custom_compiler.dart' show
     CustomCompiler;
 
 import 'kernel_visitor.dart' show
     IrFunction,
     KernelVisitor;
 
 import 'package:compiler/src/constants/expressions.dart' show
     TypeConstantExpression;
 
-typedef void WorkAction(bool isTargeted);
+typedef void WorkAction();
 
 class WorkItem {
   final Element element;
   final WorkAction action;
 
   WorkItem(this.element, this.action);
 }
 
 class Kernel {
   final CustomCompiler compiler;
 
   final Map<LibraryElement, ir.Library> libraries =
       <LibraryElement, ir.Library>{};
 
   final Map<ClassElement, ir.Class> classes = <ClassElement, ir.Class>{};
 
   final Map<FunctionElement, ir.Member> functions =
       <FunctionElement, ir.Member>{};
 
   final Map<FieldElement, ir.Field> fields = <FieldElement, ir.Field>{};
 
   final Map<TypeVariableElement, ir.TypeParameter> typeParameters =
       <TypeVariableElement, ir.TypeParameter>{};
 
+  final Set<ir.TreeNode> checkedNodes = new Set<ir.TreeNode>();
+
   /// FIFO queue of work that needs to be completed before the returned AST
   /// nodes are correct.
   final Queue<WorkItem> workQueue = new Queue<WorkItem>();
 
-  LibraryElement targetLibrary;
-
   Kernel(this.compiler);
 
   bool hasMainMethod(Uri uri) {
     LibraryElement library = compiler.libraryLoader.lookupLibrary(uri);
     return library.localLookup("main") != null;
   }
 
-  bool isTargeted(Element element) {
-    if (targetLibrary == null) return true;
-    return element.library.declaration == targetLibrary;
-  }
-
   void addWork(Element element, WorkAction action) {
     workQueue.addLast(new WorkItem(element, action));
   }
 
   void checkMember(Element key, ir.TreeNode value) {
-    if (!isTargeted(key)) return;
+    if (!checkedNodes.add(value)) return;
     if (value.parent == null) {
       internalError(key, "Missing parent on IR node.");
     }
     try {
       CheckParentPointers.check(value);
     } catch (e, s) {
       internalError(key, "$e\n$s");
     }
   }
 
-  void processWorkQueue({Uri targetLibrary}) {
-    if (targetLibrary != null) {
-      this.targetLibrary = compiler.libraryLoader.lookupLibrary(targetLibrary);
-      assert(this.targetLibrary != null);
-    }
+  void checkLibrary(Element key, ir.Library library) {
+    if (!checkedNodes.add(library)) return;
+    CheckParentPointers.check(library);
+  }
+
+  void processWorkQueue() {
     while (workQueue.isNotEmpty) {
       WorkItem work = workQueue.removeFirst();
-      work.action(isTargeted(work.element));
+      work.action();
     }
     assert(() {
-      libraries.values.forEach(CheckParentPointers.check);
+      libraries.forEach(checkLibrary);
       classes.forEach(checkMember);
       functions.forEach(checkMember);
       fields.forEach(checkMember);
       return true;
     });
   }
 
   ir.Name irName(String name, Element element) {
     return new ir.Name(name, libraryToIr(element.library));
   }
@@ skipping 10 matching lines @@
     return libraryToIr(await compiler.libraryLoader.loadLibrary(uri));
   }
 
   ir.Library libraryToIr(LibraryElement library) {
     library = library.declaration;
     return libraries.putIfAbsent(library, () {
       String name = library.hasLibraryName ? library.libraryName : null;
       ir.Library libraryNode = new ir.Library(
           library.canonicalUri, name: name, classes: null, procedures: null,
           fields: null);
-      addWork(library, (bool isTargeted) {
+      addWork(library, () {
         Queue<ir.Class> classes = new Queue<ir.Class>();
         Queue<ir.Member> members = new Queue<ir.Member>();
         library.implementation.forEachLocalMember((Element e) {
           if (e.isClass) {
             classes.addFirst(classToIr(e));
           } else if (e.isFunction || e.isAccessor) {
             members.addFirst(functionToIr(e));
           } else if (e.isField) {
             members.addFirst(fieldToIr(e));
           } else if (e.isTypedef) {
@@ skipping 13 matching lines @@
 
   ir.Class classToIr(ClassElement cls) {
     if (cls.isMixinApplication) return mixinApplicationToIr(cls);
     cls = cls.declaration;
     return classes.putIfAbsent(cls, () {
       cls.ensureResolved(compiler.resolution);
       ir.NormalClass classNode = new ir.NormalClass(
           null, name: cls.name, isAbstract: cls.isAbstract,
           typeParameters: null, implementedClasses: null, constructors: null,
           procedures: null, fields: null);
-      addWork(cls, (bool isTargeted) {
+      addWork(cls, () {
         if (cls.supertype != null) {
           classNode.superType = interfaceTypeToIr(cls.supertype);
         }
         classNode.parent = libraryToIr(cls.library);
         if (cls.isUnnamedMixinApplication) {
           classNode.enclosingLibrary.addClass(classNode);
         }
         cls.implementation.forEachMember(
             (ClassElement enclosingClass, Element member) {
           if (member.enclosingClass.declaration != cls) {
@@ skipping 22 matching lines @@
       cls.ensureResolved(compiler.resolution);
       InterfaceType supertype = null; // Computed and set below.
       InterfaceType mixedInType = null; // Computed and set below.
       String name = cls.isUnnamedMixinApplication ? null : cls.name;
       ir.MixinClass classNode = new ir.MixinClass(
           supertype, mixedInType, name: name,
           isAbstract: cls.isAbstract,
           typeParameters: null,
           implementedClasses: null,
           constructors: null);
-      addWork(cls, (bool isTargeted) {
+      addWork(cls, () {
         classNode.parent = libraryToIr(cls.library);
         if (cls.isUnnamedMixinApplication) {
           classNode.enclosingLibrary.addClass(classNode);
         }
         if (cls.hasIncompleteHierarchy) {
           ir.InterfaceType objectType =
               interfaceTypeToIr(compiler.coreTypes.objectType);
           classNode.superType = objectType;
           classNode.mixedInType = objectType;
         } else {
@@ skipping 141 matching lines @@
             null, name: name, isConst: function.isConst,
             isExternal: function.isExternal, initializers: null);
       } else {
         member = procedure = new ir.Procedure(
             name, null, null, isAbstract: function.isAbstract,
             isStatic: function.isStatic || function.isTopLevel
                 || function.isFactoryConstructor,
             isExternal: function.isExternal,
             isConst: false); // TODO(ahe): When is this true?
       }
-      addWork(function, (bool isTargeted) {
+      addWork(function, () {
         setParent(member, function);
-        if (!isTargeted) return;
         KernelVisitor visitor =
             new KernelVisitor(function, function.treeElements, this);
         IrFunction irFunction = visitor.buildFunction();
         // TODO(ahe): Add addFunction/set function to [ir.Procedure].
         irFunction.node.parent = member;
         if (irFunction.isConstructor) {
           assert(irFunction.kind == null);
           constructor.function = irFunction.node;
           constructor.initializers = irFunction.initializers;
           // TODO(ahe): Add setInitializers to [ir.Constructor].
@@ skipping 19 matching lines @@
       internalError(field, "Synthetic error field: $field.");
     }
     field = field.declaration;
     return fields.putIfAbsent(field, () {
       compiler.analyzeElement(field);
       field = field.implementation;
       ir.Field fieldNode = new ir.Field(
           nameToIrName(field.memberName), type: typeToIr(field.type),
           initializer: null, isFinal: field.isFinal,
           isStatic: field.isStatic || field.isTopLevel, isConst: field.isConst);
-      addWork(field, (bool isTargeted) {
+      addWork(field, () {
         setParent(fieldNode, field);
-        if (!isTargeted) return;
         if (!field.isInstanceMember && field.initializer != null) {
           KernelVisitor visitor =
               new KernelVisitor(field, field.treeElements, this);
           fieldNode.initializer = visitor.buildInitializer()
               ..parent = fieldNode;
         }
       });
       return fieldNode;
     });
   }
 
   ir.TypeParameter typeVariableToIr(TypeVariableElement variable) {
     variable = variable.declaration;
     return typeParameters.putIfAbsent(variable, () {
       ir.TypeParameter parameter = new ir.TypeParameter(variable.name, null);
-      addWork(variable, (bool isTargeted) {
+      addWork(variable, () {
         // TODO(ahe): This assignment will probably not be correct when dart2js
         // supports generic methods.
         ClassElement cls = variable.typeDeclaration;
         cls.ensureResolved(compiler.resolution);
         parameter.parent = classToIr(cls);
         parameter.bound = typeToIr(variable.bound);
       });
       return parameter;
     });
   }
@@ skipping 87 matching lines @@
   /// method body that is [ir.InvalidStatement].
   bool isSyntheticError(Element element) {
     if (element.isAmbiguous) return true;
     if (element.isError) return true;
     if (element.isField && element is ErroneousFieldElementX) {
       return true;
     }
     return false;
   }
 }