Add NativeEnqueuer to work with the Enqueuer.

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

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file

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

All my comments in this file are nitpicking.

 // 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;
 
 /**
  * If true, print a warning for each method that was resolved, but not
  * compiled.
  */
 const bool REPORT_EXCESS_RESOLUTION = false;
@@ skipping 55 matching lines @@
       : this.constantSystem = constantSystem;
 
   void enqueueAllTopLevelFunctions(LibraryElement lib, Enqueuer world) {
     lib.forEachExport((Element e) {
       if (e.isFunction()) world.addToWorkList(e);
     });
   }
 
   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;
 
   // TODO(ahe,karlklose): rename this?
   void dumpInferredTypes() {}
 
   ItemCompilationContext createItemCompilationContext() {
     return new ItemCompilationContext();
   }
 
   SourceString getCheckedModeHelper(DartType type) => null;
   void registerInstantiatedClass(ClassElement cls, Enqueuer enqueuer) {}
 
   Element getInterceptor(Selector selector);
 }
 
 abstract class Compiler implements DiagnosticListener {
   final Map<String, LibraryElement> libraries;
   int nextFreeClassId = 0;
   World world;
   String assembledCode;
   Types types;
 
   final bool enableMinification;
   final bool enableTypeAssertions;
   final bool enableUserAssertions;
   final bool enableConcreteTypeInference;
+  final bool enableNativeLiveTypeAnalysis;
 
   bool disableInlining = false;
 
   final Tracer tracer;
 
   CompilerTask measuredTask;
   Element _currentElement;
   LibraryElement coreLibrary;
   LibraryElement isolateLibrary;
   LibraryElement jsHelperLibrary;
@@ skipping 87 matching lines @@
 
   bool compilationFailed = false;
 
   bool hasCrashed = false;
 
   Compiler({this.tracer: const Tracer(),
             this.enableTypeAssertions: false,
             this.enableUserAssertions: false,
             this.enableConcreteTypeInference: false,
             this.enableMinification: false,
+            this.enableNativeLiveTypeAnalysis: false,
             bool emitJavaScript: true,
             bool generateSourceMap: true,
             bool disallowUnsafeEval: false,
             List<String> strips: const []})
       : libraries = new Map<String, LibraryElement>(),
         progress = new Stopwatch() {
     progress.start();
     world = new World(this);
     scanner = new ScannerTask(this);
     dietParser = new DietParserTask(this);
@@ skipping 285 matching lines @@
       reportFatalError('Could not find $MAIN', mainApp);
     } else {
       if (!main.isFunction()) reportFatalError('main is not a function', main);
       FunctionElement mainMethod = main;
       FunctionSignature parameters = mainMethod.computeSignature(this);
       parameters.forEachParameter((Element parameter) {
         reportFatalError('main cannot have parameters', parameter);
       });
     }
 
+    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;
 
     log('Inferring types...');
     typesTask.onResolutionComplete(main);
 
     // TODO(ahe): Remove this line. Eventually, enqueuer.resolution
     // should know this.
     world.populate();
 
     log('Compiling...');
     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;
 
     backend.assembleProgram();
 
     checkQueues();
   }
 
   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) {
       withCurrentElement(work.element, () => work.run(this, world));
     });
     world.queueIsClosed = true;
     if (compilationFailed) return;
     assert(world.checkNoEnqueuedInvokedInstanceMethods());
     if (DUMP_INFERRED_TYPES && phase == PHASE_COMPILING) {
       backend.dumpInferredTypes();
@@ skipping 82 matching lines @@
       if (phase == PHASE_RESOLVING) {
         log('Resolved ${enqueuer.resolution.resolvedElements.length} '
             'elements.');
         progress.reset();
       }
     }
     Element element = work.element;
     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.');
     }
     result = analyzeElement(element);
     assert(invariant(element, element.isDeclaration));
     enqueuer.resolution.resolvedElements[element] = result;
     return result;
   }
 
   void codegen(WorkItem work, Enqueuer world) {
@@ skipping 244 matching lines @@
   // TODO(johnniwinther): Use [spannable] and [message] to provide better
   // information on assertion errors.
   if (condition is Function){
     condition = condition();
   }
   if (spannable == null || !condition) {
     throw new SpannableAssertionFailure(spannable, message);
   }
   return true;
 }