Refactor enqueuers

pkg/compiler/lib/src/native/enqueue.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.
 
 import 'dart:collection' show Queue;
 
 import '../common.dart';
 import '../common/backend_api.dart' show ForeignResolver;
 import '../common/registry.dart' show Registry;
 import '../common/resolution.dart' show Resolution;
 import '../compiler.dart' show Compiler;
 import '../constants/values.dart';
 import '../core_types.dart' show CoreTypes;
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../elements/modelx.dart' show FunctionElementX;
 import '../enqueue.dart' show Enqueuer;
 import '../js_backend/backend_helpers.dart' show BackendHelpers;
 import '../js_backend/js_backend.dart';
 import '../js_emitter/js_emitter.dart' show CodeEmitterTask, NativeEmitter;
 import '../tokens/token.dart' show BeginGroupToken, Token;
 import '../tokens/token_constants.dart' as Tokens show EOF_TOKEN;
 import '../tree/tree.dart';
+import '../universe/use.dart' show StaticUse, TypeUse;
+import '../universe/world_impact.dart' show WorldImpactBuilder;
 import 'behavior.dart';
 
 /**
  * This could be an abstract class but we use it as a stub for the dart_backend.
  */
 class NativeEnqueuer {
+  /// Called when a [type] has been instantiated natively.
+  void onInstantiatedType(InterfaceType type) {}
+
   /// Initial entry point to native enqueuer.
-  void processNativeClasses(Iterable<LibraryElement> libraries) {}
+  void processNativeClasses(
+      WorldImpactBuilder impactBuilder, Iterable<LibraryElement> libraries) {}
 
   /// Registers the [nativeBehavior]. Adds the liveness of its instantiated
   /// types to the world.
-  void registerNativeBehavior(NativeBehavior nativeBehavior, cause) {}
+  void registerNativeBehavior(
+      WorldImpactBuilder impactBuilder, NativeBehavior nativeBehavior, cause) {}
 
   // TODO(johnniwinther): Move [handleFieldAnnotations] and
   // [handleMethodAnnotations] to [JavaScriptBackend] or [NativeData].
   // TODO(johnniwinther): Change the return type to 'bool' and rename them to
   // something like `computeNativeField`.
   /// Process the potentially native [field]. Adds information from metadata
   /// attributes.
   void handleFieldAnnotations(Element field) {}
 
   /// Process the potentially native [method]. Adds information from metadata
@@ skipping 33 matching lines @@
 
   final Map<ClassElement, Set<ClassElement>> nonNativeSubclasses =
       new Map<ClassElement, Set<ClassElement>>();
 
   /**
    * Records matched constraints ([SpecialType] or [DartType]).  Once a type
    * constraint has been matched, there is no need to match it again.
    */
   final Set matchedTypeConstraints = new Set();
 
-  /// Pending actions.  Classes in [pendingClasses] have action thunks in
-  /// [queue] to register the class.
-  final queue = new Queue();
-  bool flushing = false;
-
-  final Enqueuer world;
   final Compiler compiler;
   final bool enableLiveTypeAnalysis;
 
   ClassElement _annotationCreatesClass;
   ClassElement _annotationReturnsClass;
   ClassElement _annotationJsNameClass;
 
   /// Subclasses of [NativeEnqueuerBase] are constructed by the backend.
-  NativeEnqueuerBase(this.world, Compiler compiler, this.enableLiveTypeAnalysis)
+  NativeEnqueuerBase(Compiler compiler, this.enableLiveTypeAnalysis)
       : this.compiler = compiler,
         processedLibraries = compiler.cacheStrategy.newSet();
 
   JavaScriptBackend get backend => compiler.backend;
   BackendHelpers get helpers => backend.helpers;
   Resolution get resolution => compiler.resolution;
 
   DiagnosticReporter get reporter => compiler.reporter;
   CoreTypes get coreTypes => compiler.coreTypes;
 
-  void processNativeClasses(Iterable<LibraryElement> libraries) {
+  void onInstantiatedType(InterfaceType type) {
+    if (unusedClasses.remove(type.element)) {
+      registeredClasses.add(type.element);
+    }
+  }
+
+  void processNativeClasses(
+      WorldImpactBuilder impactBuilder, Iterable<LibraryElement> libraries) {
     if (compiler.options.hasIncrementalSupport) {
       // Since [Set.add] returns bool if an element was added, this restricts
       // [libraries] to ones that haven't already been processed. This saves
       // time during incremental compiles.
       libraries = libraries.where(processedLibraries.add);
     }
     libraries.forEach(processNativeClassesInLibrary);
     if (helpers.isolateHelperLibrary != null) {
       processNativeClassesInLibrary(helpers.isolateHelperLibrary);
     }
     processSubclassesOfNativeClasses(libraries);
     if (!enableLiveTypeAnalysis) {
-      nativeClasses.forEach((c) => enqueueClass(c, 'forced'));
-      flushQueue();
+      _registerTypeUses(impactBuilder, nativeClasses, 'forced');
     }
   }
 
   void processNativeClassesInLibrary(LibraryElement library) {
     // Use implementation to ensure the inclusion of injected members.
     library.implementation.forEachLocalMember((Element element) {
       if (element.isClass && backend.isNative(element)) {
         processNativeClass(element);
       }
     });
@@ skipping 187 matching lines @@
       if (name == null) {
         name = specString;
       } else {
         reporter.internalError(
             annotation, 'Too many JSName annotations: ${annotation}');
       }
     }
     return name;
   }
 
-  enqueueClass(ClassElement classElement, cause) {
-    assert(unusedClasses.contains(classElement));
-    unusedClasses.remove(classElement);
-    pendingClasses.add(classElement);
-    queue.add(() {
-      processClass(classElement, cause);
-    });
-  }
-
-  void flushQueue() {
-    if (flushing) return;
-    flushing = true;
-    while (!queue.isEmpty) {
-      (queue.removeFirst())();
-    }
-    flushing = false;
-  }
-
-  processClass(ClassElement classElement, cause) {
-    // TODO(ahe): Fix this assertion to work in incremental compilation.
-    assert(compiler.options.hasIncrementalSupport ||
-        !registeredClasses.contains(classElement));
-
-    bool firstTime = registeredClasses.isEmpty;
-    pendingClasses.remove(classElement);
-    registeredClasses.add(classElement);
-
-    // TODO(ahe): Is this really a global dependency?
-    classElement.ensureResolved(resolution);
-    compiler.backend.registerInstantiatedType(
-        classElement.rawType, world, compiler.globalDependencies);
-
-    if (firstTime) {
-      queue.add(onFirstNativeClass);
+  /// Register [classes] as natively instantiated in [impactBuilder].
+  void _registerTypeUses(
+      WorldImpactBuilder impactBuilder, Set<ClassElement> classes, cause) {
+    for (ClassElement cls in classes) {
+      if (!unusedClasses.contains(cls)) {
+        // No need to add [classElement] to [impactBuilder]: it has already been
+        // instantiated and we don't track origins of native instantiations
+        // precisely.
+        continue;
+      }
+      cls.ensureResolved(resolution);
+      impactBuilder
+          .registerTypeUse(new TypeUse.nativeInstantiation(cls.rawType));
     }
   }
 
   void handleFieldAnnotations(Element element) {
     if (compiler.serialization.isDeserialized(element)) {
       return;
     }
     if (backend.isNative(element.enclosingElement)) {
       // Exclude non-instance (static) fields - they not really native and are
       // compiled as isolate globals.  Access of a property of a constructor
@@ skipping 62 matching lines @@
       Node node = element.parseNode(resolution.parsingContext);
       if (node is! FunctionExpression) return false;
       FunctionExpression functionExpression = node;
       node = functionExpression.body;
       Token token = node.getBeginToken();
       if (identical(token.stringValue, 'native')) return true;
       return false;
     });
   }
 
-  void registerNativeBehavior(NativeBehavior nativeBehavior, cause) {
-    processNativeBehavior(nativeBehavior, cause);
-    flushQueue();
+  void registerNativeBehavior(
+      WorldImpactBuilder impactBuilder, NativeBehavior nativeBehavior, cause) {
+    _processNativeBehavior(impactBuilder, nativeBehavior, cause);
   }
 
-  processNativeBehavior(NativeBehavior behavior, cause) {
-    // TODO(ahe): Is this really a global dependency?
-    Registry registry = compiler.globalDependencies;
-    bool allUsedBefore = unusedClasses.isEmpty;
+  void _processNativeBehavior(
+      WorldImpactBuilder impactBuilder, NativeBehavior behavior, cause) {
+    void registerInstantiation(InterfaceType type) {
+      impactBuilder.registerTypeUse(new TypeUse.nativeInstantiation(type));
+    }
+
+    int unusedBefore = unusedClasses.length;
+    Set<ClassElement> matchingClasses = new Set<ClassElement>();
     for (var type in behavior.typesInstantiated) {
       if (matchedTypeConstraints.contains(type)) continue;
       matchedTypeConstraints.add(type);
       if (type is SpecialType) {
         if (type == SpecialType.JsObject) {
-          backend.registerInstantiatedType(
-              compiler.coreTypes.objectType, world, registry);
+          registerInstantiation(compiler.coreTypes.objectType);
         }
         continue;
       }
       if (type is InterfaceType) {
         if (type == coreTypes.intType) {
-          backend.registerInstantiatedType(type, world, registry);
+          registerInstantiation(type);
         } else if (type == coreTypes.doubleType) {
-          backend.registerInstantiatedType(type, world, registry);
+          registerInstantiation(type);
         } else if (type == coreTypes.numType) {
-          backend.registerInstantiatedType(
-              coreTypes.doubleType, world, registry);
-          backend.registerInstantiatedType(coreTypes.intType, world, registry);
+          registerInstantiation(coreTypes.doubleType);
+          registerInstantiation(coreTypes.intType);
         } else if (type == coreTypes.stringType) {
-          backend.registerInstantiatedType(type, world, registry);
+          registerInstantiation(type);
         } else if (type == coreTypes.nullType) {
-          backend.registerInstantiatedType(type, world, registry);
+          registerInstantiation(type);
         } else if (type == coreTypes.boolType) {
-          backend.registerInstantiatedType(type, world, registry);
+          registerInstantiation(type);
         } else if (compiler.types.isSubtype(
             type, backend.backendClasses.listImplementation.rawType)) {
-          backend.registerInstantiatedType(type, world, registry);
+          registerInstantiation(type);
         }
         // TODO(johnniwinther): Improve spec string precision to handle type
         // arguments and implements relations that preserve generics. Currently
         // we cannot distinguish between `List`, `List<dynamic>`, and
         // `List<int>` and take all to mean `List<E>`; in effect not including
         // any native subclasses of generic classes.
         // TODO(johnniwinther,sra): Find and replace uses of `List` with the
         // actual implementation classes such as `JSArray` et al.
-        enqueueUnusedClassesMatching((ClassElement nativeClass) {
+        matchingClasses
+            .addAll(_findUnusedClassesMatching((ClassElement nativeClass) {
           InterfaceType nativeType = nativeClass.thisType;
           InterfaceType specType = type.element.thisType;
           return compiler.types.isSubtype(nativeType, specType);
-        }, cause, 'subtypeof($type)');
+        }));
       } else if (type.isDynamic) {
-        enqueueUnusedClassesMatching((_) => true, cause, 'subtypeof($type)');
+        matchingClasses.addAll(unusedClasses);
       } else {
         assert(type is VoidType);
       }
     }
+    if (matchingClasses.isNotEmpty && registeredClasses.isEmpty) {
+      matchingClasses.addAll(_onFirstNativeClass(impactBuilder));
+    }
+    _registerTypeUses(impactBuilder, matchingClasses, cause);
 
     // Give an info so that library developers can compile with -v to find why
     // all the native classes are included.
-    if (unusedClasses.isEmpty && !allUsedBefore) {
+    if (unusedBefore == matchingClasses.length) {
       reporter.log('All native types marked as used due to $cause.');
     }
   }
 
-  enqueueUnusedClassesMatching(bool predicate(classElement), cause,
-      [String reason]) {
-    Iterable matches = unusedClasses.where(predicate);
-    matches.toList().forEach((c) => enqueueClass(c, cause));
+  Iterable<ClassElement> _findUnusedClassesMatching(
+      bool predicate(classElement)) {
+    return unusedClasses.where(predicate);
   }
 
-  onFirstNativeClass() {
-    staticUse(name) {
-      backend.enqueue(
-          world, helpers.findHelper(name), compiler.globalDependencies);
+  Iterable<ClassElement> _onFirstNativeClass(WorldImpactBuilder impactBuilder) {
+    void staticUse(name) {
+      Element element = helpers.findHelper(name);
+      impactBuilder.registerStaticUse(new StaticUse.foreignUse(element));
+      backend.registerBackendUse(element);
+      compiler.globalDependencies.registerDependency(element);
     }
 
     staticUse('defineProperty');
     staticUse('toStringForNativeObject');
     staticUse('hashCodeForNativeObject');
     staticUse('convertDartClosureToJS');
-    addNativeExceptions();
+    return _findNativeExceptions();
   }
 
-  addNativeExceptions() {
-    enqueueUnusedClassesMatching((classElement) {
+  Iterable<ClassElement> _findNativeExceptions() {
+    return _findUnusedClassesMatching((classElement) {
       // TODO(sra): Annotate exception classes in dart:html.
       String name = classElement.name;
       if (name.contains('Exception')) return true;
       if (name.contains('Error')) return true;
       return false;
-    }, 'native exception');
+    });
   }
 }
 
 class NativeResolutionEnqueuer extends NativeEnqueuerBase {
   Map<String, ClassElement> tagOwner = new Map<String, ClassElement>();
 
-  NativeResolutionEnqueuer(Enqueuer world, Compiler compiler)
-      : super(world, compiler, compiler.options.enableNativeLiveTypeAnalysis);
+  NativeResolutionEnqueuer(Compiler compiler)
+      : super(compiler, compiler.options.enableNativeLiveTypeAnalysis);
 
   void processNativeClass(ClassElement classElement) {
     super.processNativeClass(classElement);
 
     // Js Interop interfaces do not have tags.
     if (backend.isJsInterop(classElement)) return;
     // Since we map from dispatch tags to classes, a dispatch tag must be used
     // on only one native class.
     for (String tag in backend.nativeData.getNativeTagsOfClass(classElement)) {
       ClassElement owner = tagOwner[tag];
@@ skipping 55 matching lines @@
     return NativeBehavior.ofJsBuiltinCallSend(
         node, reporter, compiler.coreTypes, resolver);
   }
 }
 
 class NativeCodegenEnqueuer extends NativeEnqueuerBase {
   final CodeEmitterTask emitter;
 
   final Set<ClassElement> doneAddSubtypes = new Set<ClassElement>();
 
-  NativeCodegenEnqueuer(Enqueuer world, Compiler compiler, this.emitter)
-      : super(world, compiler, compiler.options.enableNativeLiveTypeAnalysis);
+  NativeCodegenEnqueuer(Compiler compiler, this.emitter)
+      : super(compiler, compiler.options.enableNativeLiveTypeAnalysis);
 
-  void processNativeClasses(Iterable<LibraryElement> libraries) {
-    super.processNativeClasses(libraries);
+  void processNativeClasses(
+      WorldImpactBuilder impactBuilder, Iterable<LibraryElement> libraries) {
+    super.processNativeClasses(impactBuilder, libraries);
 
     // HACK HACK - add all the resolved classes.
     NativeEnqueuerBase enqueuer = compiler.enqueuer.resolution.nativeEnqueuer;
+    Set<ClassElement> matchingClasses = new Set<ClassElement>();
     for (final classElement in enqueuer.registeredClasses) {
       if (unusedClasses.contains(classElement)) {
-        enqueueClass(classElement, 'was resolved');
+        matchingClasses.add(classElement);
       }
     }
-    flushQueue();
+    if (matchingClasses.isNotEmpty && registeredClasses.isEmpty) {
+      matchingClasses.addAll(_onFirstNativeClass(impactBuilder));
+    }
+    _registerTypeUses(impactBuilder, matchingClasses, 'was resolved');
   }
 
-  processClass(ClassElement classElement, cause) {
-    super.processClass(classElement, cause);
-    // Add the information that this class is a subtype of its supertypes.  The
-    // code emitter and the ssa builder use that information.
-    addSubtypes(classElement, emitter.nativeEmitter);
+  void _registerTypeUses(
+      WorldImpactBuilder impactBuilder, Set<ClassElement> classes, cause) {
+    super._registerTypeUses(impactBuilder, classes, cause);
+
+    for (ClassElement classElement in classes) {
+      // Add the information that this class is a subtype of its supertypes. The
+      // code emitter and the ssa builder use that information.
+      _addSubtypes(classElement, emitter.nativeEmitter);
+    }
   }
 
-  void addSubtypes(ClassElement cls, NativeEmitter emitter) {
+  void _addSubtypes(ClassElement cls, NativeEmitter emitter) {
     if (!backend.isNative(cls)) return;
     if (doneAddSubtypes.contains(cls)) return;
     doneAddSubtypes.add(cls);
 
     // Walk the superclass chain since classes on the superclass chain might not
     // be instantiated (abstract or simply unused).
-    addSubtypes(cls.superclass, emitter);
+    _addSubtypes(cls.superclass, emitter);
 
     for (DartType type in cls.allSupertypes) {
       List<Element> subtypes =
           emitter.subtypes.putIfAbsent(type.element, () => <ClassElement>[]);
       subtypes.add(cls);
     }
 
     // Skip through all the mixin applications in the super class
     // chain. That way, the direct subtypes set only contain the
     // natives classes.
     ClassElement superclass = cls.superclass;
     while (superclass != null && superclass.isMixinApplication) {
       assert(!backend.isNative(superclass));
       superclass = superclass.superclass;
     }
 
     List<Element> directSubtypes =
         emitter.directSubtypes.putIfAbsent(superclass, () => <ClassElement>[]);
     directSubtypes.add(cls);
   }
 
   void logSummary(log(message)) {
     log('Compiled ${registeredClasses.length} native classes, '
         '${unusedClasses.length} native classes omitted.');
   }
 }