dart2js kernel: do less enqueuing.

pkg/compiler/lib/src/kernel/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.
 
 import 'dart:async';
 import 'dart:collection' show Queue;
 
 import 'package:kernel/ast.dart' as ir;
 import 'package:kernel/verifier.dart' show CheckParentPointers;
 
@@ skipping 134 matching lines @@
     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, () {
         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));
+            ClassElement cls = e;
+            if (!cls.isResolved) return;
+            classes.addFirst(classToIr(cls));
           } else if (e.isFunction || e.isAccessor) {
+            if (!compiler.resolution.hasBeenResolved(e) && !e.isMalformed) {
+              return;
+            }
             members.addFirst(functionToIr(e));
           } else if (e.isField) {
+            if (!compiler.resolution.hasBeenResolved(e) && !e.isMalformed) {
+              return;
+            }
             members.addFirst(fieldToIr(e));
           } else if (e.isTypedef) {
             // Ignored, typedefs are unaliased on use.
           } else {
             internalError(e, "Unhandled library member: $e");
           }
         });
         // The elements were inserted in reverse order as forEachLocalMember
         // above gives them in reversed order.
         classes.forEach(libraryNode.addClass);
@@ skipping 12 matching lines @@
     Map<String, int> mixinApplicationNames = mixinApplicationNamesByLibrary
         .putIfAbsent(cls.library.implementation, () => <String, int>{});
     int count = mixinApplicationNames.putIfAbsent(name, () => 0);
     mixinApplicationNames[name] = count + 1;
     return "$name#$count";
   }
 
   ir.Class classToIr(ClassElement cls) {
     cls = cls.declaration;
     return classes.putIfAbsent(cls, () {
-      cls.ensureResolved(compiler.resolution);
-      compiler.enqueuer.resolution.emptyDeferredQueueForTesting();
+      assert(cls.isResolved);
       String name = computeName(cls);
       ir.Class classNode = new ir.Class(
           name: name,
           isAbstract: cls.isAbstract,
           typeParameters: null,
           implementedTypes: null,
           constructors: null,
           procedures: null,
           fields: null);
       addWork(cls, () {
         if (cls.supertype != null) {
           classNode.supertype = supertypeToIr(cls.supertype);
         }
         if (cls.isMixinApplication) {
           MixinApplicationElement mixinApplication = cls;
           classNode.mixedInType = supertypeToIr(mixinApplication.mixinType);
         }
         classNode.parent = libraryToIr(cls.library);
         if (cls.isUnnamedMixinApplication) {
           classNode.enclosingLibrary.addClass(classNode);
         }
         cls.implementation
             .forEachMember((ClassElement enclosingClass, Element member) {
+          if (!compiler.resolution.hasBeenResolved(member)
+              && !member.isMalformed) {
+            return;
+          }
           if (member.enclosingClass.declaration != cls) {
             // TODO(het): figure out why impact_test triggers this
             //internalError(cls, "`$member` isn't mine.");
           } else if (member.isConstructor) {
             ConstructorElement constructor = member;
             ir.Member memberNode = functionToIr(member);
             if (!constructor.isRedirectingFactory) {
               classNode.addMember(memberNode);
             }
           } else if (member.isFunction || member.isAccessor) {
@@ skipping 176 matching lines @@
       internalError(function, "Deferred loader.");
     }
     if (function.isLocal) {
       internalError(function, "Local function.");
     }
     if (isSyntheticError(function)) {
       internalError(function, "Synthetic error function: $function.");
     }
     function = function.declaration;
     return functions.putIfAbsent(function, () {
-      compiler.resolution.ensureResolved(function);
-      compiler.enqueuer.resolution.emptyDeferredQueueForTesting();
+      assert(compiler.resolution.hasBeenResolved(function) ||
+          function.isMalformed);
       function = function.implementation;
       ir.Member member;
       ir.Constructor constructor;
       ir.Procedure procedure;
       ir.Name name = irName(function.name, function);
       bool isNative = isNativeMethod(function);
       if (function.isGenerativeConstructor) {
         member = constructor = new ir.Constructor(null,
             name: name,
             isConst: function.isConst,
@@ skipping 78 matching lines @@
   void endFactoryScope(FunctionElement function) {
     factoryTypeParameters.clear();
   }
 
   ir.Field fieldToIr(FieldElement field) {
     if (isSyntheticError(field)) {
       internalError(field, "Synthetic error field: $field.");
     }
     field = field.declaration;
     return fields.putIfAbsent(field, () {
+      // TODO(sigmund): remove `ensureResolved` here.  It appears we hit this
+      // case only in metadata: when a constant has a field that is never read,
+      // but it is initialized in the constant constructor.
       compiler.resolution.ensureResolved(field);
       compiler.enqueuer.resolution.emptyDeferredQueueForTesting();
+      assert(compiler.resolution.hasBeenResolved(field) || field.isMalformed);
+
       field = field.implementation;
       ir.DartType type =
           field.isMalformed ? const ir.InvalidType() : typeToIr(field.type);
       ir.Field fieldNode = new ir.Field(irName(field.memberName.text, field),
           type: type,
           initializer: null,
           isFinal: field.isFinal,
           isStatic: field.isStatic || field.isTopLevel,
           isConst: field.isConst);
       addWork(field, () {
@@ skipping 21 matching lines @@
 
   ir.TypeParameter typeVariableToIr(TypeVariableElement variable) {
     variable = variable.declaration;
     ir.TypeParameter parameter = factoryTypeParameters[variable];
     if (parameter != null) return parameter;
     return typeParameters.putIfAbsent(variable, () {
       ir.TypeParameter parameter = new ir.TypeParameter(variable.name, null);
       addWork(variable, () {
         if (variable.typeDeclaration.isClass) {
           ClassElement cls = variable.typeDeclaration;
-          cls.ensureResolved(compiler.resolution);
+          assert(cls.isResolved);
           parameter.parent = classToIr(cls);
         } else {
           FunctionElement method = variable.typeDeclaration;
           parameter.parent = functionToIr(method).function;
         }
         parameter.bound = typeToIr(variable.bound);
       });
       return parameter;
     });
   }
@@ skipping 115 matching lines @@
       return true;
     }
     return false;
   }
 
   ir.Constructor getDartCoreConstructor(
       String className, String constructorName) {
     LibraryElement library =
         compiler.libraryLoader.lookupLibrary(Uris.dart_core);
     ClassElement cls = library.implementation.localLookup(className);
+    cls.ensureResolved(compiler.resolution);
     assert(invariant(CURRENT_ELEMENT_SPANNABLE, cls != null,
         message: 'dart:core class $className not found.'));
     ConstructorElement constructor = cls.lookupConstructor(constructorName);
     assert(invariant(CURRENT_ELEMENT_SPANNABLE, constructor != null,
         message: "Constructor '$constructorName' not found "
             "in class '$className'."));
+    compiler.resolution.ensureResolved(constructor);
     return functionToIr(constructor);
   }
 
   ir.Procedure getDartCoreMethod(String name) {
     LibraryElement library =
         compiler.libraryLoader.lookupLibrary(Uris.dart_core);
     Element function = library.implementation.localLookup(name);
     assert(invariant(CURRENT_ELEMENT_SPANNABLE, function != null,
         message: "dart:core method '$name' not found."));
+    compiler.resolution.ensureResolved(function);
     return functionToIr(function);
   }
 
   ir.Procedure getMalformedTypeErrorBuilder() {
     return getDartCoreMethod('_malformedTypeError');
   }
 
   ir.Procedure getUnresolvedConstructorBuilder() {
     return getDartCoreMethod('_unresolvedConstructorError');
   }
@@ skipping 44 matching lines @@
 }
 
 class ConstructorTarget {
   final ConstructorElement element;
   final DartType type;
 
   ConstructorTarget(this.element, this.type);
 
   String toString() => "ConstructorTarget($element, $type)";
 }