Remove support for the DeferredLibrary annotation and remove tests of it

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
     Backend,
     Compiler,
     CompilerTask,
@@ skipping 220 matching lines @@
   void _addImportToOutputUnitOfConstant(Constant constant, Import import) {
     // Only one file should be loaded when the program starts, so make
     // 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) {
-    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(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
     // not deferred.
     if (imports.isEmpty) return false;
     // An element could potentially be loaded by several imports. If all of them
     // is explicitly deferred, we say the element is explicitly deferred.
     // TODO(sigurdm): We might want to give a warning if the imports do not
     // agree.
-    return imports.every(_isImportDeferred);
+    return imports.every((Import import) => import.isDeferred);
   }
 
   /// Returns a [Link] of every [Import] that imports [element] into [library].
   Link<Import> _getImports(Element element, LibraryElement library) {
     if (element.isClassMember) {
       element = element.enclosingClass;
     }
     if (element.isAccessor) {
       element = (element as FunctionElement).abstractField;
     }
@@ skipping 108 matching lines @@
     void traverseLibrary(LibraryElement library) {
       if (result.contains(library)) return;
       result.add(library);
 
       iterateTags(LibraryElement library) {
         // TODO(sigurdm): Make helper getLibraryDependencyTags when tags is
         // changed to be a List instead of a Link.
         for (LibraryTag tag in library.tags) {
           if (tag is! LibraryDependency) continue;
           LibraryDependency libraryDependency = tag;
-          if (!(libraryDependency is Import
-              && _isImportDeferred(libraryDependency))) {
+          if (!(libraryDependency is Import && libraryDependency.isDeferred)) {
             LibraryElement importedLibrary = library.getLibraryFromTag(tag);
             traverseLibrary(importedLibrary);
           }
         }
       }
 
       iterateTags(library);
       if (library.isPatched) {
         iterateTags(library.implementation);
       }
@@ skipping 291 matching lines @@
     Map<String, Import> prefixDeferredImport = new Map<String, Import>();
     for (LibraryElement library in compiler.libraryLoader.libraries) {
       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);
+
+          /// Give an error if the old annotation-based syntax has been used.
+          Link<MetadataAnnotation> metadataList = import.metadata;
+          if (metadataList != null) {
+            for (MetadataAnnotation metadata in metadataList) {
+              metadata.ensureResolved(compiler);
+              Element element = metadata.value.computeType(compiler).element;
+              if (element == deferredLibraryClass) {
+                 compiler.reportFatalError(import, MessageKind.DEFERRED_OLD_SYNTAX);

[floitsch, 2014/08/28 20:05:20]

long line.

Maybe just a warning? Talk to Johnni/Peter.

[sigurdm, 2014/09/02 11:23:18]

Giving a warning would entail keeping in all the functionality for handling the
old syntax.

+              }
+            }
+          }
+
           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 (import.isDeferred) {
+            _allDeferredImports[import] = library.getLibraryFromTag(import);
+
             if (prefix == null) {
               compiler.reportError(import,
                   MessageKind.DEFERRED_LIBRARY_WITHOUT_PREFIX);
             } else {
               prefixDeferredImport[prefix] = import;
             }
             splitProgram = true;
             lastDeferred = import;
           }
           if (prefix != null) {
             if (previousDeferredImport != null ||
-                (isDeferred && usedPrefixes.contains(prefix))) {
+                (import.isDeferred && usedPrefixes.contains(prefix))) {
               Import failingImport = (previousDeferredImport != null)
                   ? previousDeferredImport
                   : import;
               compiler.reportError(failingImport.prefix,
                   MessageKind.DEFERRED_LIBRARY_DUPLICATE_PREFIX);
             }
             usedPrefixes.add(prefix);
           }
         }
       });
@@ skipping 59 matching lines @@
     Element maybePrefix = elements[identifier];
     if (maybePrefix != null && maybePrefix.isPrefix) {
       PrefixElement prefixElement = maybePrefix;
       if (prefixElement.isDeferred) {
         return prefixElement;
       }
     }
     return null;
   }
 }