Introduces the new syntax for deferred loading

sdk/lib/_internal/compiler/implementation/ssa/builder.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 ssa;
 
 /**
  * A special element for the extra parameter taken by intercepted
  * methods. We need to implement [TypedElement.type] because our
  * optimizers may look at its declared type.
@@ skipping 2908 matching lines @@
    */
   void generateInstanceGetterWithCompiledReceiver(ast.Send send,
                                                   Selector selector,
                                                   HInstruction receiver) {
     assert(Elements.isInstanceSend(send, elements));
     assert(selector.isGetter());
     pushInvokeDynamic(send, selector, [receiver]);
   }
 
   void generateGetter(ast.Send send, Element element) {
-    if (Elements.isStaticOrTopLevelField(element)) {
+    if (element != null && element.isForeign(compiler)) {
+      visitForeignGetter(send);
+    } else if (Elements.isStaticOrTopLevelField(element)) {
       Constant value;
       if (element.isField() && !element.isAssignable()) {
         // A static final or const. Get its constant value and inline it if
         // the value can be compiled eagerly.
         value = compiler.constantHandler.getConstantForVariable(element);
       }
       if (value != null) {
         HConstant instruction = graph.addConstant(value, compiler);
         stack.add(instruction);
         // The inferrer may have found a better type than the constant
@@ skipping 626 matching lines @@
       handleForeignJsGetName(node);
     } else if (name == 'JS_EFFECT') {
       stack.add(graph.addConstantNull(compiler));
     } else if (name == 'JS_INTERCEPTOR_CONSTANT') {
       handleJsInterceptorConstant(node);
     } else {
       throw "Unknown foreign: ${selector}";
     }
   }
 
+  visitForeignGetter(ast.Send node) {
+    Element element = elements[node];
+    // Until now we only handle these as getters.
+    invariant(node, element.isDeferredLoaderGetter());
+    FunctionElement deferredLoader = element;
+    Element loadFunction = compiler.loadLibraryFunction;
+    PrefixElement prefixElement = deferredLoader.enclosingElement;
+    String loadId = compiler.deferredLoadTask
+        .importDeferName[prefixElement.deferredImport];
+    var inputs = [graph.addConstantString(
+        new ast.DartString.literal(loadId), compiler)];
+    push(new HInvokeStatic(loadFunction, inputs, backend.nonNullType,
+                           targetCanThrow: false));
+  }
+
   generateSuperNoSuchMethodSend(ast.Send node,
                                 Selector selector,
                                 List<HInstruction> arguments) {
     String name = selector.name;
 
     ClassElement cls = currentNonClosureClass;
     Element element = cls.lookupSuperMember(Compiler.NO_SUCH_METHOD);
     if (compiler.enabledInvokeOn
         && element.enclosingElement.declaration != compiler.objectClass) {
       // Register the call as dynamic if [noSuchMethod] on the super
@@ skipping 486 matching lines @@
     if (!compiler.enableUserAssertions) {
       stack.add(graph.addConstantNull(compiler));
       return;
     }
     visitStaticSend(node);
   }
 
   visitStaticSend(ast.Send node) {
     Selector selector = elements.getSelector(node);
     Element element = elements[node];
-    if (element.isForeign(compiler)) {
+    if (element.isForeign(compiler) && element.isFunction()) {
       visitForeignSend(node);
       return;
     }
     if (element.isErroneous()) {
       // An erroneous element indicates that the funciton could not be resolved
       // (a warning has been issued).
       generateThrowNoSuchMethod(node,
                                 getTargetName(element),
                                 argumentNodes: node.arguments);
       return;
@@ skipping 2023 matching lines @@
     DartType unaliased = type.unalias(builder.compiler);
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     ClassElement cls = builder.compiler.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls)));
   }
 }