Constrain type annotations with deferred types.

sdk/lib/_internal/compiler/implementation/deferred_load.dart

 // Copyright (c) 2014, 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 deferred_load;
 
 import 'dart2jslib.dart' show
     Compiler,
     CompilerTask,
     Constant,
     ConstructedConstant,
     MessageKind,
     StringConstant,
     invariant;
 
+import 'dart_backend/dart_backend.dart' show
+    DartBackend;
+
 import 'elements/elements.dart' show
     Element,
     ClassElement,
     ElementKind,
     Elements,
     FunctionElement,
     LibraryElement,
     MetadataAnnotation,
     ScopeContainerElement,
+    PrefixElement,
     ClosureContainer;
 
 import 'util/util.dart' show
     Link;
 
 import 'util/setlet.dart' show
     Setlet;
 
 import 'tree/tree.dart' show
     LibraryTag,
@@ skipping 144 matching lines @@
     // sure that only one OutputUnit is created for [fakeMainImport].
     if (import == _fakeMainImport) {
       _constantToOutputUnit[constant] = mainOutputUnit;
     }
     _constantToOutputUnit.putIfAbsent(constant, () => new OutputUnit())
         .imports.add(import);
   }
 
   /// Answers whether the [import] has a [DeferredLibrary] annotation.
   bool _isImportDeferred(Import import) {
-    Link<MetadataAnnotation> metadatalist = import.metadata;
-    if (metadatalist == null) return false;
-    for (MetadataAnnotation metadata in metadatalist) {
+    return _allDeferredImports.containsKey(import);
+  }
+
+  /// Checks whether the [import] has a [DeferredLibrary] annotation and stores
+  /// the information in [_allDeferredImports] and on the corresponding
+  /// prefixElement.
+  void _markIfDeferred(Import import, LibraryElement library) {
+    Link<MetadataAnnotation> metadataList = import.metadata;
+    if (metadataList == null) return;
+    for (MetadataAnnotation metadata in metadataList) {
       metadata.ensureResolved(compiler);
       Element element = metadata.value.computeType(compiler).element;
-      if (metadata.value.computeType(compiler).element
-          == deferredLibraryClass) {
-        return true;
+      if (element == deferredLibraryClass) {
+        _allDeferredImports[import] = library.getLibraryFromTag(import);
+        // On encountering a deferred library without a prefix we report an
+        // error, but continue the compilation to possibly give more
+        // information. Therefore it is neccessary to check if there is a prefix
+        // here.
+        Element maybePrefix = library.find(import.prefix.toString());
+        if (maybePrefix != null && maybePrefix.isPrefix()) {
+          PrefixElement prefix = maybePrefix;
+          prefix.markAsDeferred();
+        }
       }
     }
-    return false;
   }
 
   /// Answers whether [element] is explicitly deferred when referred to from
   /// [library].
   bool _isExplicitlyDeferred(Element element, LibraryElement library) {
     Link<Import> imports = _getImports(element, library);
     // If the element is not imported explicitly, it is implicitly imported
     // not deferred.
     if (imports.isEmpty) return false;
     // An element could potentially be loaded by several imports. If all of them
@@ skipping 435 matching lines @@
     // 2.
     // @DeferredLibrary("a") import "lib.dart" as a;
     // import "lib2.dart" as a;
     // 3.
     // import "lib.dart" as a;
     // @DeferredLibrary("a") import "lib2.dart" as a;
     // 4.
     // import "lib.dart" as a;
     // import "lib2.dart" as a;
     // We must be able to signal error for case 1, 2, 3, but accept case 4.
-    
+
     // The prefixes that have been used by any imports in this library.
     Setlet<String> usedPrefixes = new Setlet<String>();
     // The last deferred import we saw with a given prefix (if any).
     Map<String, Import> prefixDeferredImport = new Map<String, Import>();
     for (LibraryElement library in compiler.libraries.values) {
       compiler.withCurrentElement(library, () {
         prefixDeferredImport.clear();
         usedPrefixes.clear();
         // TODO(sigurdm): Make helper getLibraryImportTags when tags is a List
         // instead of a Link.
         for (LibraryTag tag in library.tags) {
           if (tag is! Import) continue;
           Import import = tag;
+          _markIfDeferred(import, library);
           String prefix = (import.prefix != null)
               ? import.prefix.toString()
               : null;
           // The last import we saw with the same prefix.
           Import previousDeferredImport = prefixDeferredImport[prefix];
           bool isDeferred = _isImportDeferred(import);
           if (isDeferred) {
             if (prefix == null) {
               compiler.reportError(import,
                   MessageKind.DEFERRED_LIBRARY_WITHOUT_PREFIX);
             } else {
               prefixDeferredImport[prefix] = import;
             }
             splitProgram = true;
-            _allDeferredImports[tag] = library.getLibraryFromTag(tag);
             lastDeferred = import.metadata.first;
             if (library == compiler.mainApp) {
               deferredUsedFromMain = true;
             }
           }
           if (prefix != null) {
             if (previousDeferredImport != null ||
                 (isDeferred && usedPrefixes.contains(prefix))) {
               Import failingImport = (previousDeferredImport != null)
                   ? previousDeferredImport
                   : import;
               compiler.reportError(failingImport.prefix,
                   MessageKind.DEFERRED_LIBRARY_DUPLICATE_PREFIX);
             }
             usedPrefixes.add(prefix);
           }
         }
       });
     }
+    if (splitProgram && compiler.backend is DartBackend) {
+      // TODO(sigurdm): Implement deferred loading for dart2dart.
+      splitProgram = false;
+      compiler.reportInfo(
+          lastDeferred,
+          MessageKind.DEFERRED_LIBRARY_DART_2_DART);
+    }
     if (splitProgram && !deferredUsedFromMain) {
       compiler.reportInfo(
           lastDeferred,
           MessageKind.DEFERRED_LIBRARY_NOT_FROM_MAIN);
       splitProgram = false;
     }
   }
 }