Deferred (aka lazy) loading of static functions.

dart/sdk/lib/_internal/compiler/implementation/js_backend/emitter.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 js_backend;
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
@@ skipping 43 matching lines @@
 class CodeEmitterTask extends CompilerTask {
   bool needsInheritFunction = false;
   bool needsDefineClass = false;
   bool needsClosureClass = false;
   bool needsLazyInitializer = false;
   final Namer namer;
   ConstantEmitter constantEmitter;
   NativeEmitter nativeEmitter;
   CodeBuffer boundClosureBuffer;
   CodeBuffer mainBuffer;
+  final CodeBuffer deferredBuffer = new CodeBuffer();
   /** Shorter access to [isolatePropertiesName]. Both here in the code, as
       well as in the generated code. */
   String isolateProperties;
   String classesCollector;
   Set<ClassElement> neededClasses;
   // TODO(ngeoffray): remove this field.
   Set<ClassElement> instantiatedClasses;
 
   JavaScriptBackend get backend => compiler.backend;
 
@@ skipping 1631 matching lines @@
         Element member = element.lookupLocalMember(noSuchMethodName);
         if (member == null) continue;
         if (noSuchMethodSelector.applies(member, compiler)) {
           nativeEmitter.handleNoSuchMethod = true;
           break;
         }
       }
     }
 
     for (ClassElement element in sortedClasses) {
+      if (isDeferred(element)) {
+        warnNotImplemented(
+            element,
+            'Warning: deferred loading of classes is not implemented yet.');
+      }
       generateClass(element, buffer);
     }
 
     // The closure class could have become necessary because of the generation
     // of stubs.
     ClassElement closureClass = compiler.closureClass;
     if (needsClosureClass && !instantiatedClasses.contains(closureClass)) {
       generateClass(closureClass, buffer);
     }
   }
 
   void emitFinishClassesInvocationIfNecessary(CodeBuffer buffer) {
     if (needsDefineClass) {
       buffer.add("$finishClassesName($classesCollector)$N");
       // Reset the map.
       buffer.add("$classesCollector$_=$_{}$N");
     }
   }
 
   void emitStaticFunction(CodeBuffer buffer,
                           String name,
                           jsAst.Expression functionExpression) {
     jsAst.Expression assignment =
         js[isolateProperties][name].assign(functionExpression);
     buffer.add(jsAst.prettyPrint(assignment, compiler));
     buffer.add('$N$n');
   }
 
-  void emitStaticFunctions(CodeBuffer buffer) {
+  void emitStaticFunctions(CodeBuffer eagerBuffer) {
     bool isStaticFunction(Element element) =>
         !element.isInstanceMember() && !element.isField();
 
     Iterable<Element> elements =
         backend.generatedCode.keys.where(isStaticFunction);
     Set<Element> pendingElementsWithBailouts =
         backend.generatedBailoutCode.keys
             .where(isStaticFunction)
             .toSet();
 
     for (Element element in Elements.sortedByPosition(elements)) {
+      CodeBuffer buffer = isDeferred(element) ? deferredBuffer : eagerBuffer;
       jsAst.Expression code = backend.generatedCode[element];
       emitStaticFunction(buffer, namer.getName(element), code);
       jsAst.Expression bailoutCode = backend.generatedBailoutCode[element];
       if (bailoutCode != null) {
         pendingElementsWithBailouts.remove(element);
         emitStaticFunction(buffer, namer.getBailoutName(element), bailoutCode);
       }
     }
 
     // Is it possible the primary function was inlined but the bailout was not?
     for (Element element in
              Elements.sortedByPosition(pendingElementsWithBailouts)) {
+      CodeBuffer buffer = isDeferred(element) ? deferredBuffer : eagerBuffer;
       jsAst.Expression bailoutCode = backend.generatedBailoutCode[element];
       emitStaticFunction(buffer, namer.getBailoutName(element), bailoutCode);
     }
   }
 
   void emitStaticFunctionGetters(CodeBuffer buffer) {
     Set<FunctionElement> functionsNeedingGetter =
         compiler.codegenWorld.staticFunctionsNeedingGetter;
     for (FunctionElement element in
              Elements.sortedByPosition(functionsNeedingGetter)) {
+      // TODO(ahe): Defer loading of these getters.

[ngeoffray, 2013/02/19 10:04:57]

warnNotImplemented?

[ahe, 2013/02/19 11:10:36]

The overhead is small, and I can't give a location. So I thought it was better
to not warn. Remember the element is the function that needs a getter, I don't
know where that use is.

+
       // The static function does not have the correct name. Since
       // [addParameterStubs] use the name to create its stubs we simply
       // create a fake element with the correct name.
       // Note: the callElement will not have any enclosingElement.
       FunctionElement callElement =
           new ClosureInvocationElement(namer.closureInvocationSelectorName,
                                        element);
       String staticName = namer.getName(element);
       String invocationName = namer.instanceMethodName(callElement);
       String fieldAccess = '$isolateProperties.$staticName';
@@ skipping 821 matching lines @@
 
       emitFinishIsolateConstructorInvocation(mainBuffer);
       mainBuffer.add('var ${namer.CURRENT_ISOLATE}$_='
                      '${_}new ${namer.isolateName}()$N');
 
       nativeEmitter.assembleCode(mainBuffer);
       emitMain(mainBuffer);
       emitInitFunction(mainBuffer);
       compiler.assembledCode = mainBuffer.getText();
 
-      if (generateSourceMap) {
-        SourceFile compiledFile = new SourceFile(null, compiler.assembledCode);
-        String sourceMap = buildSourceMap(mainBuffer, compiledFile);
-        compiler.outputProvider('', 'js.map')
-            ..add(sourceMap)
+      if (!deferredBuffer.isEmpty) {
+        String code = deferredBuffer.getText();
+        compiler.outputProvider('part', 'js')
+            ..add(code)
             ..close();
+        outputSourceMap(deferredBuffer, compiler.assembledCode, 'part');
       }
+
+      outputSourceMap(mainBuffer, compiler.assembledCode, '');
     });
     return compiler.assembledCode;
   }
 
   String buildSourceMap(CodeBuffer buffer, SourceFile compiledFile) {
     SourceMapBuilder sourceMapBuilder = new SourceMapBuilder();
     buffer.forEachSourceLocation(sourceMapBuilder.addMapping);
     return sourceMapBuilder.build(compiledFile);
   }
+
+  void outputSourceMap(CodeBuffer buffer, String code, String name) {
+    if (!generateSourceMap) return;
+    SourceFile compiledFile = new SourceFile(null, compiler.assembledCode);
+    String sourceMap = buildSourceMap(mainBuffer, compiledFile);
+    compiler.outputProvider(name, 'js.map')
+        ..add(sourceMap)
+        ..close();
+  }
+
+  bool isDeferred(Element element) {
+    return compiler.deferredLoadTask.isDeferred(element);
+  }
+
+  // TODO(ahe): Remove this when deferred loading is fully implemented.
+  void warnNotImplemented(Element element, String message) {
+    compiler.reportMessage(compiler.spanFromSpannable(element),
+                           MessageKind.GENERIC.error({'text': message}),
+                           api.Diagnostic.WARNING);
+  }
 }
 
 const String GENERATED_BY = """
 // Generated by dart2js, the Dart to JavaScript compiler.
 """;
 const String HOOKS_API_USAGE = """
 // The code supports the following hooks:
 // dartPrint(message)   - if this function is defined it is called
 //                        instead of the Dart [print] method.
 // dartMainRunner(main) - if this function is defined, the Dart [main]
 //                        method will not be invoked directly.
 //                        Instead, a closure that will invoke [main] is
 //                        passed to [dartMainRunner].
 """;