Introduces the new syntax for deferred loading

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

 // Copyright (c) 2013, 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.
 
 library elements.modelx;
 
 import 'elements.dart';
 import '../tree/tree.dart';
 import '../util/util.dart';
 import '../resolution/resolution.dart';
@@ skipping 58 matching lines @@
 
 
   bool isFunction() => identical(kind, ElementKind.FUNCTION);
   bool isConstructor() => isFactoryConstructor() || isGenerativeConstructor();
   bool isClosure() => false;
   bool isMember() {
     // Check that this element is defined in the scope of a Class.
     return enclosingElement != null && enclosingElement.isClass();
   }
   bool isInstanceMember() => false;
+  bool isDeferredLoaderFunction() => false;
 
   bool isFactoryConstructor() => modifiers.isFactory();
   bool isGenerativeConstructor() =>
       identical(kind, ElementKind.GENERATIVE_CONSTRUCTOR);
   bool isGenerativeConstructorBody() =>
       identical(kind, ElementKind.GENERATIVE_CONSTRUCTOR_BODY);
   bool isCompilationUnit() => identical(kind, ElementKind.COMPILATION_UNIT);
   bool isClass() => identical(kind, ElementKind.CLASS);
   bool isPrefix() => identical(kind, ElementKind.PREFIX);
   bool isVariable() => identical(kind, ElementKind.VARIABLE);
@@ skipping 931 matching lines @@
   accept(ElementVisitor visitor) => visitor.visitLibraryElement(this);
 }
 
 class PrefixElementX extends ElementX implements PrefixElement {
   Token firstPosition;
 
   final ImportScope importScope = new ImportScope();
 
   bool isDeferred = false;
 
+  // Only needed for deferred imports.
+  Import _import;

[floitsch, 2014/03/17 14:15:41]

I don't really like this.

Every prefix comes from imports. Having a field that only works in special
circumstances feels wrong.
Could we have a list of imports, and a `singleImport` that throws if there is
more than one?

[Johnni Winther, 2014/03/18 12:29:14]

Or rename to `deferredImport` ?

[sigurdm, 2014/03/19 12:46:30]

Done.

+  Import get import => _import;
+
   PrefixElementX(String prefix, Element enclosing, this.firstPosition)
       : super(prefix, ElementKind.PREFIX, enclosing);
 
   Element lookupLocalMember(String memberName) => importScope[memberName];
 
   DartType computeType(Compiler compiler) => compiler.types.dynamicType;
 
   Token position() => firstPosition;
 
   void addImport(Element element, Import import, DiagnosticListener listener) {
     importScope.addImport(this, element, import, listener);
   }
 
   accept(ElementVisitor visitor) => visitor.visitPrefixElement(this);
 
-  void markAsDeferred() {
+  void markAsDeferred(Import import) {
     isDeferred = true;
+    _import = import;
   }
 }
 
 class TypedefElementX extends ElementX
     with AnalyzableElement, TypeDeclarationElementX<TypedefType>
     implements TypedefElement {
   Typedef cachedNode;
 
   /**
    * The type annotation which defines this typedef.
@@ skipping 591 matching lines @@
 
   bool get isAbstract {
     return !modifiers.isExternal() &&
            (isFunction() || isAccessor()) &&
            _hasNoBody;
   }
 
   accept(ElementVisitor visitor) => visitor.visitFunctionElement(this);
 }
 
+class DeferredLoaderFunctionElementX extends FunctionElementX {

[karlklose, 2014/03/17 14:05:00]

This element should have source code information.

When, for example, calling it with too many arguments, we may print a hint and
then we would need the source code location to point to.

[sigurdm, 2014/03/19 12:46:30]

Done.

+  PrefixElement prefix;
+  DeferredLoaderFunctionElementX(prefix)

[karlklose, 2014/03/17 14:05:00]

`prefix` -> `this.prefix`.

[sigurdm, 2014/03/19 12:46:30]

Not fixed - we still need to pass on the prefix to super.

+      : prefix = prefix,
+        super("loadLibrary",
+              ElementKind.FUNCTION,
+              Modifiers.EMPTY,
+              prefix, true);
+
+  FunctionSignature computeSignature(Compiler compiler) {
+    if (functionSignature != null) return functionSignature;
+    compiler.withCurrentElement(this, () {
+      functionSignature = new FunctionSignatureX(const Link(),
+          const Link(), 0, 0, false, compiler.types.dynamicType);
+    });
+    return functionSignature;
+  }
+
+  bool isMember() => false;
+
+  bool get isSynthesized => true;
+
+  bool isForeign(Compiler compiler) => true;
+
+  bool isDeferredLoaderFunction() => true;
+}
+
 class ConstructorBodyElementX extends FunctionElementX
     implements ConstructorBodyElement {
   FunctionElement constructor;
 
   ConstructorBodyElementX(FunctionElement constructor)
       : this.constructor = constructor,
         super(constructor.name,
               ElementKind.GENERATIVE_CONSTRUCTOR_BODY,
               Modifiers.EMPTY,
               constructor.enclosingElement, false) {
@@ skipping 902 matching lines @@
 
   ParameterMetadataAnnotation(Metadata this.metadata);
 
   Node parseNode(DiagnosticListener listener) => metadata.expression;
 
   Token get beginToken => metadata.getBeginToken();
 
   Token get endToken => metadata.getEndToken();
 }