Introduces the new syntax for deferred loading

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,
@@ skipping 96 matching lines @@
   /// program.
   final Set<OutputUnit> allOutputUnits = new Set<OutputUnit>();
 
   /// Will be `true` if the program contains deferred libraries.
   bool splitProgram = false;
 
   /// A mapping from the name of a [DeferredLibrary] annotation to all dependent
   /// output units.
   final Map<String, Set<OutputUnit>> hunksToLoad =
       new Map<String, Set<OutputUnit>>();
+  final Map<Import, String> importDeferName = new Map<Import, String>();
 
   /// A mapping from elements and constants to their output unit. Query this via
   /// [outputUnitForElement]
   final Map<Element, OutputUnit> _elementToOutputUnit =
       new Map<Element, OutputUnit>();
 
   /// A mapping from constants to their output unit. Query this via
   /// [outputUnitForConstant]
   final Map<Constant, OutputUnit> _constantToOutputUnit =
       new Map<Constant, OutputUnit>();
@@ skipping 63 matching lines @@
 
   /// Answers whether the [import] has a [DeferredLibrary] annotation.
   bool _isImportDeferred(Import import) {
     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) {
+    // Check if the import is deferred by a keyword.
+    if (import.isDeferred) {
+      _allDeferredImports[import] = library.getLibraryFromTag(import);
+      return;
+    }
+    // Check if the import is deferred by a metadata annotation.
     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 (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();
+          prefix.markAsDeferred(import);
         }
       }
     }
   }
 
   /// 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
@@ skipping 297 matching lines @@
       // unit of the constant, but we prefer separate instances.
       // Replace the imports of the constant to match the ones of the class.
       _replaceOutputUnitImports(constant, constantUnit, classImports);
     }
   }
 
   /// Computes a unique string for the name field for each outputUnit.
   ///
   /// Also sets up the [hunksToLoad] mapping.
   void _assignNamesToOutputUnits(Set<OutputUnit> allOutputUnits) {
-    Map<Import, String> deferNameCache = new Map<Import, String>();
+    Set<String> usedImportNames = new Set<String>();
+
+    // Returns suggestedName if it is not in usedNames. Otherwise concatenate

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

concatenates

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

Done.

+    // the smallest number that makes it not appear in usedNames.
+    // Adds the result to usedNames.
+    String makeUnique(String suggestedName, Set<String> usedNames) {
+      String result = suggestedName;
+      if (usedNames.contains(suggestedName)) {
+        int counter = 0;
+        while (usedNames.contains(result)) {
+          counter++;
+          result = "$suggestedName$counter";
+        }
+      }
+      usedNames.add(result);
+      return result;
+    }
+
     // Finds the first argument to the [DeferredLibrary] annotation
-    String importDeferName(Import import) {
-      if (deferNameCache.containsKey(import)) return deferNameCache[import];
-      if (import == _fakeMainImport) return "main";
-      Link<MetadataAnnotation> metadatas = import.metadata;
-      assert(metadatas != null);
+    void computeImportDeferName(Import import) {
       String result;
-      for (MetadataAnnotation metadata in metadatas) {
-        metadata.ensureResolved(compiler);
-        Element element = metadata.value.computeType(compiler).element;
-        if (metadata.value.computeType(compiler).element ==
-            deferredLibraryClass) {
-          ConstructedConstant constant = metadata.value;
-          StringConstant s = constant.fields[0];
-          result = s.value.slowToString();
-          break;
+      if (import == _fakeMainImport) {
+        result = "main";
+      } else if (import.isDeferred) {
+        result = import.prefix.toString();
+      } else {
+        Link<MetadataAnnotation> metadatas = import.metadata;
+        assert(metadatas != null);
+        for (MetadataAnnotation metadata in metadatas) {
+          metadata.ensureResolved(compiler);
+          Element element = metadata.value.computeType(compiler).element;
+          if (metadata.value.computeType(compiler).element ==
+              deferredLibraryClass) {
+            ConstructedConstant constant = metadata.value;
+            StringConstant s = constant.fields[0];
+            result = s.value.slowToString();
+            break;
+          }
         }
       }
       assert(result != null);
-      deferNameCache[import] = result;
-      return result;
+      importDeferName[import] = makeUnique(result, usedImportNames);;
     }
 
-    Set<String> usedNames = new Set<String>();
+    Set<String> usedOutputUnitNames = new Set<String>();
     Map<OutputUnit, String> generatedNames = new Map<OutputUnit, String>();
 
     void computeOutputUnitName(OutputUnit outputUnit) {
       if (generatedNames[outputUnit] != null) return;
       String suggestedName = outputUnit.imports.map((import) {
-        return importDeferName(import);
+        return importDeferName[import];
       }).join('_');
-      if (!usedNames.contains(suggestedName)) {
-        outputUnit.name = suggestedName;
-      } else {
-        int counter = 0;
-        while (usedNames.contains("$suggestedName$counter")) {
-          counter++;
-        }
-        outputUnit.name = "$suggestedName$counter";
-      }
+      outputUnit.name = makeUnique(suggestedName, usedOutputUnitNames);
       generatedNames[outputUnit] = outputUnit.name;
     }
 
+    for (Import import in _allDeferredImports.keys) {
+      computeImportDeferName(import);
+    }
+
     for (OutputUnit outputUnit in allOutputUnits) {
       computeOutputUnitName(outputUnit);
     }
 
     // For each deferred import we find out which outputUnits to load.
     for (Import import in _allDeferredImports.keys) {
       if (import == _fakeMainImport) continue;
-      hunksToLoad[importDeferName(import)] = new Set<OutputUnit>();
+      hunksToLoad[importDeferName[import]] = new Set<OutputUnit>();
       for (OutputUnit outputUnit in allOutputUnits) {
         if (outputUnit == mainOutputUnit) continue;
         if (outputUnit.imports.contains(import)) {
-          hunksToLoad[importDeferName(import)].add(outputUnit);
+          hunksToLoad[importDeferName[import]].add(outputUnit);
         }
       }
     }
   }
 
   void onResolutionComplete(FunctionElement main) {
     if (!splitProgram) {
       allOutputUnits.add(mainOutputUnit);
       return;
     }
@@ skipping 52 matching lines @@
       _assignNamesToOutputUnits(allOutputUnits);
     });
   }
 
   void ensureMetadataResolved(Compiler compiler) {
     _allDeferredImports[_fakeMainImport] = compiler.mainApp;
     var lastDeferred;
     // When detecting duplicate prefixes of deferred libraries there are 4
     // cases of duplicate prefixes:
     // 1.
-    // @DeferredLibrary("a") import "lib.dart" as a;
-    // @DeferredLibrary("b") import "lib2.dart" as a;
+    // import "lib.dart" deferred as a;
+    // import "lib2.dart" deferred as a;
     // 2.
-    // @DeferredLibrary("a") import "lib.dart" as a;
+    // import "lib.dart" deferred as a;
     // import "lib2.dart" as a;
     // 3.
     // import "lib.dart" as a;
-    // @DeferredLibrary("a") import "lib2.dart" as a;
+    // import "lib2.dart" deferred 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) {
@@ skipping 13 matching lines @@
           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;
-            lastDeferred = import.metadata.first;
+            lastDeferred = import;
           }
           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);
     }
   }
 }