Add NativeEnqueuer to work with the Enqueuer.

sdk/lib/_internal/compiler/implementation/enqueue.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.
 
 part of dart2js;
 
 class EnqueueTask extends CompilerTask {
   final Enqueuer codegen;
   final Enqueuer resolution;
 
@@ skipping 23 matching lines @@
    * Map from declaration elements to the [TreeElements] object holding the
    * resolution mapping for the element implementation.
    *
    * Invariant: Key elements are declaration elements.
    */
   final Map<Element, TreeElements> resolvedElements;
 
   bool queueIsClosed = false;
   EnqueueTask task;
 
+  native.NativeEnqueuer nativeEnqueuer;  // Set by compiler.

[ngeoffray, 2012/11/14 21:17:39]

Why not by this class?

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

This class has two instances.
I can use isResolutionQueue here, or set it outside.

isResolutionQueue feels like a hack to me,  The enqueuer also does not have the
backend on hand, and getting it also feels like a hack.

+
   Enqueuer(this.name, this.compiler,
            ItemCompilationContext itemCompilationContextCreator())
     : this.itemCompilationContextCreator = itemCompilationContextCreator,
       instanceMembersByName = new Map<String, Link<Element>>(),
       seenClasses = new Set<ClassElement>(),
       universe = new Universe(),
       queue = new Queue<WorkItem>(),
       resolvedElements = new Map<Element, TreeElements>();
 
   bool get isResolutionQueue => identical(compiler.enqueuer.resolution, this);
@@ skipping 55 matching lines @@
       compiler.enabledInvokeOn = true;
     }
 
     // Enable isolate support if we start using something from the
     // isolate library.
     LibraryElement library = element.getLibrary();
     if (!compiler.hasIsolateSupport()
         && library.uri.toString() == 'dart:isolate') {
       compiler.enableIsolateSupport(library);
     }
+
+    nativeEnqueuer.registerElement(element);
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [element] must be a declaration element.
    */
   void eagerRecompile(Element element) {
     assert(invariant(element, element.isDeclaration));
     universe.generatedCode.remove(element);
@@ skipping 31 matching lines @@
     cls.implementation.forEachMember(processInstantiatedClassMember);
   }
 
   /**
    * Documentation wanted -- johnniwinther
    */
   void processInstantiatedClassMember(ClassElement cls, Element member) {
     assert(invariant(member, member.isDeclaration));
     if (universe.generatedCode.containsKey(member)) return;
     if (resolvedElements[member] != null) return;
     if (!member.isInstanceMember()) return;

[ngeoffray, 2012/11/14 21:17:39]

How about just doing nativeEnqueuer.processInstantiatedClassMember(cls, member),
and let that one deal with the isNative checks, field store and field load?

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

I think it will be too complicated.

Names need to be added to instanceMembersByName, so
processIntantiatedClassMembers would need to return a flag.

The logic for the cross product of selectors and members is all here, and I
think it will be confusing to move some of it elsewhere.

If I renamed NativeEnqueuer to NativeLivenessAnalysis, would that make it
clearer that this is the right place for the selector X member code?

-    if (member.isField()) return;
+    if (member.isField()) {
+      // Native fields need to go into instanceMembersByName as they are virtual
+      // instantiation points and escape points.
+      if (!member.enclosingElement.isNative()) return;
+    }
 
     String memberName = member.name.slowToString();
     Link<Element> members = instanceMembersByName.putIfAbsent(
         memberName, () => const Link<Element>());
     instanceMembersByName[memberName] = members.prepend(member);
 
     if (member.kind == ElementKind.FUNCTION) {
       if (member.name == Compiler.NO_SUCH_METHOD) {
         compiler.enableNoSuchMethod(member);
       }
@@ skipping 15 matching lines @@
       }
       // We don't know what selectors the returned closure accepts. If
       // the set contains any selector we have to assume that it matches.
       if (universe.hasInvocation(member, compiler)) {
         return addToWorkList(member);
       }
     } else if (identical(member.kind, ElementKind.SETTER)) {
       if (universe.hasInvokedSetter(member, compiler)) {
         return addToWorkList(member);
       }
+    } else if (identical(member.kind, ElementKind.FIELD)) {

[ahe, 2012/11/14 13:51:30]

I think we are slowly moving towards using == instead of identical for these
tests.

+      if (member.enclosingElement.isNative()) {

[ahe, 2012/11/14 13:51:30]

Assert the condition instead?

+        // print('process $member');
+        // print('   $memberName:  ${instanceMembersByName[memberName]}');

[ngeoffray, 2012/11/14 21:17:39]

Remove debugging code

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

Done.

+        if (universe.hasInvokedGetter(member, compiler) ||
+            universe.hasInvocation(member, compiler)) {
+          nativeEnqueuer.registerFieldLoad(member);
+        }
+        if (universe.hasInvokedSetter(member, compiler)) {
+          nativeEnqueuer.registerFieldStore(member);
+        }
+      }
     }
   }
 
   void onRegisterInstantiatedClass(ClassElement cls) {
     task.measure(() {
       // The class must be resolved to compute the set of all
       // supertypes.
       cls.ensureResolved(compiler);
 
       for (Link<DartType> supertypes = cls.allSupertypesAndSelf;
@@ skipping 68 matching lines @@
       LinkBuilder<Element> remaining = new LinkBuilder<Element>();
       for (; !members.isEmpty; members = members.tail) {
         if (!f(members.head)) remaining.addLast(members.head);
       }
       instanceMembersByName[memberName] = remaining.toLink();
     }
   }
 
   void handleUnseenSelector(SourceString methodName, Selector selector) {
     processInstanceMembers(methodName, (Element member) {
       if (selector.applies(member, compiler)) {

[ngeoffray, 2012/11/14 21:17:39]

Same comment, nativeEnqueuer.handleUnseenMember.

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

Same response - keep the cross-product as the responsibility of this class.

I would have put the field in the worklist, except we will eventually need to
distinguish loads from stores rather than treating them together.

-        addToWorkList(member);
+        // print('unseen $selector add $member   ${member.kind}');
+        if (member.isField() && member.enclosingElement.isNative()) {
+          if (selector.isGetter() || selector.isCall()) {
+            nativeEnqueuer.registerFieldLoad(member);

[ahe, 2012/11/14 13:51:30]

Does order matter here?

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

Added comments to answer the questions here.

+            nativeEnqueuer.registerFieldStore(member);

[ahe, 2012/11/14 13:51:30]

Why also store?

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

See new comments.

+          } else {
+            nativeEnqueuer.registerFieldStore(member);
+            nativeEnqueuer.registerFieldLoad(member);

[ahe, 2012/11/14 13:51:30]

Why load?

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

See new comments.

+          }
+        } else {
+          addToWorkList(member);
+        }
         return true;
       }
       return false;
     });
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [element] must be a declaration element.
@@ skipping 60 matching lines @@
 
   String toString() => 'Enqueuer($name)';
 
   registerUsedSelector(Selector selector) {
     Element interceptor = compiler.backend.getInterceptor(selector);
     if (interceptor != null) {
       registerStaticUse(interceptor);
     }
   }
 }