Parameterize the native_handler with the world/enqueuer.

dart/lib/compiler/implementation/compiler.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.
 
 class WorkItem {
   final Element element;
   TreeElements resolutionTree;
   bool allowSpeculativeOptimization = true;
   List<HTypeGuard> guards = const <HTypeGuard>[];
 
@@ skipping 17 matching lines @@
     }
   }
 }
 
 class Backend {
   final Compiler compiler;
 
   Backend(this.compiler);
 
   abstract String codegen(WorkItem work);
-  abstract void processNativeClasses(libraries);
+  abstract void processNativeClasses(world, libraries);
   abstract void assembleProgram();
 }
 
 class JavaScriptBackend extends Backend {
   SsaBuilderTask builder;
   SsaOptimizerTask optimizer;
   SsaCodeGeneratorTask generator;
   CodeEmitterTask emitter;
 
   JavaScriptBackend(Compiler compiler)
@@ skipping 10 matching lines @@
     if (work.allowSpeculativeOptimization
         && optimizer.trySpeculativeOptimizations(work, graph)) {
       String code = generator.generateBailoutMethod(work, graph);
       compiler.codegenWorld.addBailoutCode(work, code);
       optimizer.prepareForSpeculativeOptimizations(work, graph);
       optimizer.optimize(work, graph);
     }
     return generator.generateMethod(work, graph);
   }
 
-  void processNativeClasses(libraries) {
-    native.processNativeClasses(emitter, libraries);
+  void processNativeClasses(world, libraries) {
+    native.processNativeClasses(world, emitter, libraries);
   }
 
   void assembleProgram() => emitter.assembleProgram();
 }
 
 class DartBackend extends Backend {
   DartBackend(Compiler compiler) : super(compiler);
 }
 
 class Compiler implements DiagnosticListener {
@@ skipping 105 matching lines @@
     cancel("${red('internal error:')} $message",
            node, token, instruction, element);
   }
 
   void internalErrorOnElement(Element element, String message) {
     internalError(message, element: element);
   }
 
   void unhandledExceptionOnElement(Element element) {
     reportDiagnostic(spanFromElement(element),
-                     MessageKind.COMPILER_CRASHED.error(),
+                     MessageKind.COMPILER_CRASHED.error().toString(),

[karlklose, 2012/05/23 14:03:36]

Why is this necessary?

[ahe, 2012/05/23 14:24:33]

Because reportDiagnostic takes a String.

                      false);
     // TODO(ahe): Obtain the build ID.
     var buildId = 'build number could not be determined';
-    print(MessageKind.PLEASE_REPORT_THE_CRASH.message([buildId]));
+    print(MessageKind.PLEASE_REPORT_THE_CRASH.message([buildId]).toString());

[ahe, 2012/05/23 14:24:33]

Not necessary, though.

   }
 
   void cancel([String reason, Node node, Token token,
                HInstruction instruction, Element element]) {
     SourceSpan span = const SourceSpan(null, null, null);
     if (node !== null) {
       span = spanFromNode(node);
     } else if (token !== null) {
       span = spanFromTokens(token, token);
     } else if (instruction !== null) {
@@ skipping 139 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);
       });
     }
     Collection<LibraryElement> libraries = libraries.getValues();
-    backend.processNativeClasses(libraries);
+    backend.processNativeClasses(enqueuer.codegen, libraries);
     world.populate(this, libraries);
     enqueuer.codegen.addToWorkList(main);
     codegenProgress.reset();
     while (!enqueuer.codegen.queue.isEmpty()) {
       WorkItem work = enqueuer.codegen.queue.removeLast();
       withCurrentElement(work.element, () => work.run(this));
     }
     enqueuer.codegen.queueIsClosed = true;
     assert(enqueuer.codegen.checkNoEnqueuedInvokedInstanceMethods());
     enqueuer.codegen.registerFieldClosureInvocations();
@@ skipping 197 matching lines @@
     // invariant that endOffset > beginOffset, but for EOF the
     // charoffset of the next token may be [beginOffset]. This can
     // also happen for synthetized tokens that are produced during
     // error handling.
     final endOffset =
       Math.max((end.next !== null) ? end.next.charOffset : 0, beginOffset + 1);
     assert(endOffset > beginOffset);
     return f(beginOffset, endOffset);
   }
 }