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 isDeferredLoaderGetter() => 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 600 matching lines @@
    * detection of ambiguous uses of imported names.
    */
   void addImport(Element enclosingElement,
                  Element element,
                  Import import,
                  DiagnosticListener listener) {
     LibraryElementX library = enclosingElement.getLibrary();
     Importers importers = library.importers;
 
     String name = element.name;
+
+    // The loadLibrary function always shadows existing bindings to that name.
+    if (element.isDeferredLoaderGetter()) {
+      importScope.remove(name);
+      // TODO(sigurdm): Print a hint.
+    }
     Element existing = importScope.putIfAbsent(name, () => element);
     importers.registerImport(element, import);
 
     void registerWarnOnUseElement(Import import,
                                   MessageKind messageKind,
                                   Element hidingElement,
                                   Element hiddenElement) {
       Uri hiddenUri = hiddenElement.getLibrary().canonicalUri;
       Uri hidingUri = hidingElement.getLibrary().canonicalUri;
       Element element = new WarnOnUseElementX(
@@ skipping 309 matching lines @@
   }
 
   accept(ElementVisitor visitor) => visitor.visitLibraryElement(this);
 }
 
 class PrefixElementX extends ElementX implements PrefixElement {
   Token firstPosition;
 
   final ImportScope importScope = new ImportScope();
 
-  bool isDeferred = false;
+  bool get isDeferred => _deferredImport != null;
+
+  // Only needed for deferred imports.
+  Import _deferredImport;
+  Import get deferredImport => _deferredImport;
 
   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() {
-    isDeferred = true;
+  void markAsDeferred(Import deferredImport) {
+    _deferredImport = deferredImport;
   }
 }
 
 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 DeferredLoaderGetterElementX extends FunctionElementX {
+
+  final PrefixElement prefix;
+
+  DeferredLoaderGetterElementX(PrefixElement prefix)
+      : this.prefix = prefix,
+        super("loadLibrary",
+              ElementKind.FUNCTION,
+              Modifiers.EMPTY,
+              prefix, true);
+
+  FunctionSignature computeSignature(Compiler compiler) {
+    if (functionSignature != null) return functionSignature;
+    compiler.withCurrentElement(this, () {
+      DartType inner = new FunctionType(this, compiler.types.dynamicType);
+      functionSignature = new FunctionSignatureX(const Link(),
+          const Link(), 0, 0, false, inner);
+    });
+    return functionSignature;
+  }
+
+  bool isMember() => false;
+
+  bool isForeign(Compiler compiler) => true;
+
+  bool get isSynthesized => true;
+
+  bool isFunction() => false;
+
+  bool isDeferredLoaderGetter() => true;
+
+  bool isGetter() => true;
+
+  // By having position null, the enclosing elements location is printed in
+  // error messages.
+  Token position() => null;
+}
+
 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();
 }