Add NativeEnqueuer to work with the Enqueuer.

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

Index: sdk/lib/_internal/compiler/implementation/compiler.dart
diff --git a/sdk/lib/_internal/compiler/implementation/compiler.dart b/sdk/lib/_internal/compiler/implementation/compiler.dart
index f97d3d9c8729085597dead1feeeafbfc71254cb1..e97097c7f6a316ee9ed8da137b37eac2fc5a574c 100644
--- a/sdk/lib/_internal/compiler/implementation/compiler.dart
+++ b/sdk/lib/_internal/compiler/implementation/compiler.dart
@@ -74,8 +74,14 @@ abstract class Backend {
 
   void enqueueHelpers(Enqueuer world);
   void codegen(WorkItem work);
-  void processNativeClasses(Enqueuer world,
-                            Collection<LibraryElement> libraries);
+
+  // The backend determines the native resolution enqueuer so tools like
+  // dart2dart can ignore the native classes.
+  native.NativeEnqueuer nativeResolutionEnqueuer(world, bool liveTypeAnalysis) =>

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

Long line.  As a matter of style, I prefer to avoid => syntax for functions that
doesn't fit on one line.  But we are not consistent about that in dart2js.

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

I don't think the option liveTypeAnalysis is necessary.  You are no using it,
and it can be obtained from compiler.

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

An undocumented property of the library native_handler.dart, is that we want to
get rid of it.  It is used to implement language extensions that we want to
replace by metadata.  So we would like to keep it at arms length, and so it
would be better if these types came from a different library (in which case you
can drop the "native" prefix").  We are using the word "native" to mean
deprecated stuff that should go away :-)

For simplicity, you could start by defining a new library which simply export
NativeEnqueuer?  This library would then represent stuff that we want to have
long term.

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

Line too long, and the style we used is not to use '=>' if the expression does
not fit in the same line as the method definition.

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

Almost all the functionality in here will be needed forever.

When we eliminate the 'native' keyword and replace it with an annotation, there
will still need to some code that tests to see if the annotation is present, and
to interpret the parameters to the annotation.  The call will move from the
parser to somewhere else.  This is a matter of changing one syntax for another,
one which allows the test to be deferred for a little bit.  Otherwise I don't
see what will change.

I am concerned that moving some things to attributes means that we need to
resolve the attributes to know if something is a special native thing.  For
example, we want to know which classes are native classes in order to add them
to a set prior to resolution.  But we need to resolve the attributes on all
classes now to know which ones are native classes, and to do that we need to
resolve the classes used by the annotations.

I'm sure it can be done, but special syntax is much more straightforward to
implement.
If you agree with my characterization, then it is reasonable to keep this
library as is?  We will switch the 10% of the library that is parser hooks for
other, annotation-based hooks.

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

Done.

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

Done.

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

I see plenty of examples.

+      new native.NativeEnqueuer();
+  native.NativeEnqueuer nativeCodegenEnqueuer(world, bool liveTypeAnalysis) =>
+      new native.NativeEnqueuer();
+
   void assembleProgram();
   List<CompilerTask> get tasks;
 
@@ -103,6 +109,7 @@ abstract class Compiler implements DiagnosticListener {
   final bool enableTypeAssertions;
   final bool enableUserAssertions;
   final bool enableConcreteTypeInference;
+  final bool enableNativeLiveTypeAnalysis;
 
   bool disableInlining = false;
 
@@ -210,6 +217,7 @@ abstract class Compiler implements DiagnosticListener {
             this.enableUserAssertions: false,
             this.enableConcreteTypeInference: false,
             this.enableMinification: false,
+            this.enableNativeLiveTypeAnalysis: false,
             bool emitJavaScript: true,
             bool generateSourceMap: true,
             bool disallowUnsafeEval: false,
@@ -515,11 +523,19 @@ abstract class Compiler implements DiagnosticListener {
       });
     }
 
+    enqueuer.resolution.nativeEnqueuer =
+        backend.nativeResolutionEnqueuer(enqueuer.resolution,
+                                         enableNativeLiveTypeAnalysis);
+    enqueuer.codegen.nativeEnqueuer =
+        backend.nativeCodegenEnqueuer(enqueuer.codegen,
+                                      enableNativeLiveTypeAnalysis);
+
     log('Resolving...');
     phase = PHASE_RESOLVING;
     backend.enqueueHelpers(enqueuer.resolution);
     processQueue(enqueuer.resolution, main);
     log('Resolved ${enqueuer.resolution.resolvedElements.length} elements.');
+    enqueuer.resolution.nativeEnqueuer.logSummary(log);

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

I like this approach.  How about merging these two lines to:

enqueuer.resolution.logSummary(log);

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

Done.

 
     if (compilationFailed) return;
 
@@ -534,6 +550,7 @@ abstract class Compiler implements DiagnosticListener {
     phase = PHASE_COMPILING;
     processQueue(enqueuer.codegen, main);
     log('Compiled ${codegenWorld.generatedCode.length} methods.');
+    enqueuer.codegen.nativeEnqueuer.logSummary(log);

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

Ditto.

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

Done.

 
     if (compilationFailed) return;
 
@@ -543,7 +560,7 @@ abstract class Compiler implements DiagnosticListener {
   }
 
   void processQueue(Enqueuer world, Element main) {
-    backend.processNativeClasses(world, libraries.values);
+    world.nativeEnqueuer.processNativeClasses(libraries.values);
     world.addToWorkList(main);
     progress.reset();
     world.forEach((WorkItem work) {
@@ -646,6 +663,7 @@ abstract class Compiler implements DiagnosticListener {
     TreeElements result = world.getCachedElements(element);
     if (result != null) return result;
     if (!identical(world, enqueuer.resolution)) {
+      throw 'Internal error: unresolved element: $element.';

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

Remove this.  FYI: you can often use --throw-on-error instead of inserting
debug-throws.

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

Remove debugging code.

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

Done.

       internalErrorOnElement(element,
                              'Internal error: unresolved element: $element.');
     }