Add NativeEnqueuer to work with the Enqueuer.

sdk/lib/_internal/compiler/implementation/native_handler.dart

 // Copyright (c) 2012, 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.
 
 library native;
 
 import 'dart:uri';
 import 'dart2jslib.dart' hide SourceString;
 import 'elements/elements.dart';
 import 'js_backend/js_backend.dart';
 import 'scanner/scannerlib.dart';
 import 'ssa/ssa.dart';
 import 'tree/tree.dart';
 import 'util/util.dart';
 
-void processNativeClasses(Enqueuer world,
-                          CodeEmitterTask emitter,
-                          Collection<LibraryElement> libraries) {
-  for (LibraryElement library in libraries) {
-    processNativeClassesInLibrary(world, emitter, library);
-  }
-}
-
-void addSubtypes(ClassElement cls,
-                 NativeEmitter emitter) {
-  for (DartType type in cls.allSupertypes) {
-    List<Element> subtypes = emitter.subtypes.putIfAbsent(
-        type.element,
+
+// This could be an abstract class but we use it as a stub for the dart_backend.
+class NativeEnqueuer {
+  void processNativeClasses(Collection<LibraryElement> libraries) {}
+
+
+  void registerElement(Element element) {}
+
+  // Method is a member of a native class.
+  void registerMethod(Element method) {}
+
+  // Field is a member of a native class.
+  void registerFieldLoad(Element field) {}
+  void registerFieldStore(Element field) {}
+
+  // JS-form code can be an instantiation point for types.
+  //
+  //   JS('_DOMWindowImpl', 'window');
+  //
+  // TODO(sra): Who calls this?
+  // TODO(sra): How do we parse the type?
+  // void registerJS(type) {}
+
+  void registerJSDartType(DartType type, Node locationNode) {}
+}
+
+
+class NativeEnqueuerBase implements NativeEnqueuer {

[ngeoffray, 2012/11/08 08:18:01]

A couple of high-level comments and alternatives about this class:

1) Could it be a subclass of the real Enqueuer, and override methods of
interest? For example, when a new Dart class is registered, this enqueuer would
check if it's native, do what it needs to do based on that information and then
call the super.

2) Alternatively, it could just contain top-level methods that are called by the
real enqueuer. In the case of dart2dart, it doesn't see these JS and native
thingies, so these methods would never be called.

[sra1, 2012/11/15 00:09:10]

Enqueuer already needs to be split into a resolution and codegen enqueuer.  Then
I would have to subclass two classes.  Composition is more flexible than
inhertitance.
I think I'm already doing (2), but with class NativeEnqueuer 

+
+  final Set<ClassElement> nativeClasses = new Set<ClassElement>();
+
+  // Each class is exactly one of these sets.
+  final Set<ClassElement> registeredClasses = new Set<ClassElement>();
+  final Set<ClassElement> unusedClasses = new Set<ClassElement>();
+  final Set<ClassElement> pendingClasses = new Set<ClassElement>();
+
+  final queue = new Queue();  // Classes in pendingClasse have thunks in queue.
+  bool flushing = false;
+
+  final Set<DartType> escapedTypes = new Set<DartType>();
+  final Set<DartType> capturedTypes = new Set<DartType>();
+
+
+  final Enqueuer world;
+  final Compiler compiler;
+
+  // constructed by backend.
+  NativeEnqueuerBase(this.world, this.compiler);
+
+  void processNativeClasses(Collection<LibraryElement> libraries) {
+    libraries.forEach(processNativeClassesInLibrary);
+
+    // nativeClasses.forEach(enqueueClass);  flushQueue();
+  }
+
+  void processNativeClassesInLibrary(LibraryElement library) {
+    // Use implementation to ensure the inclusion of injected members.
+    library.implementation.forEachLocalMember((Element element) {
+        if (element.kind == ElementKind.CLASS) {
+          ClassElement classElement = element;
+          if (classElement.isNative()) {
+            nativeClasses.add(classElement);
+            unusedClasses.add(classElement);
+
+            // Resolve class to ensure the class has valid inheritance info.
+            classElement.ensureResolved(compiler);
+          }
+        }
+      });
+  }
+
+  enqueueClass(ClassElement classElement, cause) {
+    assert(unusedClasses.contains(classElement));
+    compiler.log(
+        'Adding native class ${classElement.name.slowToString()},'
+        '  why: $cause');
+    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) {
+    assert(!registeredClasses.contains(classElement));
+
+    bool firstTime = registeredClasses.isEmpty;
+    pendingClasses.remove(classElement);
+    registeredClasses.add(classElement);
+
+    // print('processClass $classElement $cause');
+    world.registerInstantiatedClass(classElement);
+
+    // Also parse the node to know all its methods because
+    // otherwise it will only be parsed if there is a call to
+    // one of its constructors.
+    classElement.parseNode(compiler);
+
+    if (firstTime) {
+      queue.add(onFirstNativeClass);
+    }
+  }
+
+  registerElement(Element element) {
+    if (element.isFunction()) return registerMethod(element);
+  }
+
+  registerMethod(Element method) {
+    if (isNativeMethod(method)) {
+      // print('Native method call $method');
+      captureType(method.computeType(compiler), method);
+      flushQueue();
+    }
+  }
+
+  bool isNativeMethod(Element element) {
+    // Native method?
+    Node node = element.parseNode(compiler);
+    if (node is! FunctionExpression) return false;
+    node = node.body;
+    Token token = node.getBeginToken();
+    if (token.stringValue == 'native') return true;
+    return false;
+  }
+
+  registerFieldLoad(Element field) {
+    // print('Native load field $field');
+    captureType(field.computeType(compiler), field);
+    flushQueue();
+  }
+
+  registerFieldStore(Element field) {
+    // print('Native store field $field');
+    escapeType(field.computeType(compiler), field);
+    flushQueue();
+  }
+
+  void registerJSDartType(DartType type, Node locationNode) {
+    captureType(type, locationNode);
+    flushQueue();
+  }
+
+  escapeType(DartType type, cause) {
+    type = type.unalias(compiler);
+    if (escapedTypes.contains(type)) return;
+    escapedTypes.add(type);
+    // print('  escapeType  $type');
+
+    if (type is FunctionType) {
+      escapeType(type.returnType, cause);
+      // TODO: use FunctionSignature.
+      for (Link<DartType> parameters = type.parameterTypes;
+           !parameters.isEmpty;
+           parameters = parameters.tail) {
+        captureType(parameters.head, cause);
+      }
+    }
+  }
+
+  captureType(DartType type, cause) {
+    type = type.unalias(compiler);
+    if (capturedTypes.contains(type)) return;
+    capturedTypes.add(type);
+    // print('  capturedType  $type');
+
+    if (type is FunctionType) {
+      captureType(type.returnType, cause);
+      for (Link<DartType> parameters = type.parameterTypes;
+           !parameters.isEmpty;
+           parameters = parameters.tail) {
+        escapeType(parameters.head, cause);
+      }
+    } else {
+      bool allUsedBefore = unusedClasses.isEmpty;
+      enqueueUnusedClassesMatching(
+          (nativeClass) => compiler.types.isSubtype(nativeClass.type, type),
+          cause,
+          'subtypeof($type)');
+      if (unusedClasses.isEmpty && !allUsedBefore) {
+        if (cause is Node) {
+          throw 'Eugh $cause';
+          compiler.log('All native types marked as used due to $cause.');
+      } else if (cause.position() != null) {
+          //compiler.cancel('Eugh!', token: cause.position());
+          compiler.log('All native types marked used due to $cause.');
+        } else {
+          compiler.log('All native types marked used due to $type.');
+        }
+      }
+    }
+
+    // TODO(sra): Do we need to do something for capturing List<Node>?  For now,
+    // hope that NodeListImpl matches List, causing NodeListImpl.operator[] to
+    // match some invocation, leading to instantiating Node.
+
+    //  Required for:
+    //   typedef void MutationCallback(List<MutationRecord> mutations, MutationObserver observer);
+    //  No other code instantiates MutationRecord.
+    //  We can work-around by annotating the MutationObserver constructor with a list of 'also created' type.
+
+  }
+
+  enqueueUnusedClassesMatching(predicate, cause, [reason]) {
+    var matches = unusedClasses.filter(predicate);
+    // print('${matches.length} matches: $matches\n..   $reason  $world');
+    matches.forEach((c) => enqueueClass(c, cause));
+  }
+
+  onFirstNativeClass() {
+    staticUse(name) => world.registerStaticUse(compiler.findHelper(name));
+
+    staticUse(const SourceString('dynamicFunction'));
+    staticUse(const SourceString('dynamicSetMetadata'));
+    staticUse(const SourceString('defineProperty'));
+    staticUse(const SourceString('toStringForNativeObject'));
+    staticUse(const SourceString('hashCodeForNativeObject'));
+
+    addNativeExceptions();
+  }
+
+  addNativeExceptions() {
+    enqueueUnusedClassesMatching((classElement) {
+        // TODO(sra): Annotate exception classes in dart:html.
+        var name = classElement.name.slowToString();
+        if (name.contains('Exception')) return true;
+        if (name.contains('Error')) return true;
+        return false;
+      },
+      'native exception');
+  }
+}
+
+
+class NativeResolutionEnqueuer extends NativeEnqueuerBase {
+
+  NativeResolutionEnqueuer(Enqueuer world, Compiler compiler)
+      : super(world, compiler);
+}
+
+
+class NativeCodegenEnqueuer extends NativeEnqueuerBase {
+
+  final CodeEmitterTask emitter;
+
+  NativeCodegenEnqueuer(Enqueuer world, Compiler compiler, this.emitter)
+      : super(world, compiler);
+
+  void processNativeClasses(Collection<LibraryElement> libraries) {
+    super.processNativeClasses(libraries);
+
+    // HACK HACK - add all the resolved classes.
+    for (final classElement
+         in compiler.enqueuer.resolution.nativeEnqueuer.registeredClasses) {
+      if (unusedClasses.contains(classElement)) {
+        enqueueClass(classElement, 'was resolved');
+      }
+    }
+    flushQueue();
+  }
+
+  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 addSubtypes(ClassElement cls, NativeEmitter emitter) {
+    for (DartType type in cls.allSupertypes) {
+      List<Element> subtypes = emitter.subtypes.putIfAbsent(
+          type.element,
+          () => <ClassElement>[]);
+      subtypes.add(cls);
+    }
+
+    List<Element> directSubtypes = emitter.directSubtypes.putIfAbsent(
+        cls.superclass,
         () => <ClassElement>[]);
-    subtypes.add(cls);
-  }
-
-  List<Element> directSubtypes = emitter.directSubtypes.putIfAbsent(
-      cls.superclass,
-      () => <ClassElement>[]);
-  directSubtypes.add(cls);
-}
-
-void processNativeClassesInLibrary(Enqueuer world,
-                                   CodeEmitterTask emitter,
-                                   LibraryElement library) {
-  bool hasNativeClass = false;
-  final compiler = emitter.compiler;
-  // Use implementation to ensure the inclusion of injected members.
-  library.implementation.forEachLocalMember((Element element) {
-    if (element.kind == ElementKind.CLASS) {
-      ClassElement classElement = element;
-      if (classElement.isNative()) {
-        hasNativeClass = true;
-        world.registerInstantiatedClass(classElement);
-        // Also parse the node to know all its methods because
-        // otherwise it will only be parsed if there is a call to
-        // one of its constructor.
-        classElement.parseNode(compiler);
-        // Resolve to setup the inheritance.
-        classElement.ensureResolved(compiler);
-        // 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);
-      }
-    }
-  });
-  if (hasNativeClass) {
-    world.registerStaticUse(compiler.findHelper(
-        const SourceString('dynamicFunction')));
-    world.registerStaticUse(compiler.findHelper(
-        const SourceString('dynamicSetMetadata')));
-    world.registerStaticUse(compiler.findHelper(
-        const SourceString('defineProperty')));
-    world.registerStaticUse(compiler.findHelper(
-        const SourceString('toStringForNativeObject')));
-    world.registerStaticUse(compiler.findHelper(
-        const SourceString('hashCodeForNativeObject')));
-  }
+    directSubtypes.add(cls);
+  }
+
 }
 
 void maybeEnableNative(Compiler compiler,
                        LibraryElement library,
                        Uri uri) {
   String libraryName = uri.toString();
   if (library.entryCompilationUnit.script.name.contains(
           'dart/tests/compiler/dart2js_native')
       || libraryName == 'dart:isolate'
       || libraryName == 'dart:html') {
@@ skipping 245 matching lines @@
                                       String parameters) {
   buffer.add("  if (Object.getPrototypeOf(this).hasOwnProperty");
   buffer.add("('$methodName')) {\n");
   buffer.add("  $code");
   buffer.add("  } else {\n");
   buffer.add("    return Object.prototype.$methodName.call(this");
   buffer.add(parameters == '' ? '' : ', $parameters');
   buffer.add(");\n");
   buffer.add("  }\n");
 }