Insert checks before deferred calls and accesses.

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,
     Constant,
     ConstructedConstant,
     MessageKind,
     StringConstant,
-    invariant;
+    invariant,
+    Backend;
 
 import 'dart_backend/dart_backend.dart' show
     DartBackend;
 
+import 'js_backend/js_backend.dart' show
+    JavaScriptBackend;
+
 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,
     Node,
     NewExpression,
     Import,
     LiteralString,
     LiteralDartString;
 
+import 'tree/tree.dart' as ast;
+
 import 'resolution/resolution.dart' show
     TreeElements;
 
 import 'mirrors_used.dart' show
     MirrorUsageAnalyzer,
     MirrorUsageAnalyzerTask,
     MirrorUsage;
 
 /// A "hunk" of the program that will be loaded whenever one of its [imports]
 /// are loaded.
@@ skipping 117 matching lines @@
   OutputUnit outputUnitForConstant(Constant constant) {
     if (!splitProgram) return mainOutputUnit;
 
     return _constantToOutputUnit[constant];
   }
 
   bool isDeferred(Element element) {
     return outputUnitForElement(element) != mainOutputUnit;
   }
 
+  /// Returns true if e1 and e2 are in the same output unit.
+  bool inSameOutputUnit(Element e1, Element e2) {
+    return outputUnitForElement(e1) == outputUnitForElement(e2);
+  }
+
   /// Mark that [import] is part of the [OutputputUnit] for [element].
   ///
   /// [element] can be either a [Constant] or an [Element].
   void _addImportToOutputUnitOfElement(Element element, 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) {
       _elementToOutputUnit[element] = mainOutputUnit;
     }
     _elementToOutputUnit.putIfAbsent(element, () => new OutputUnit())
@@ skipping 57 matching lines @@
     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);
   }
 
   /// Returns a [Link] of every [Import] that imports [element] into [library].
   Link<Import> _getImports(Element element, LibraryElement library) {
-    if (!element.isTopLevel()) {
+    if (element.isMember()) {
       element = element.getEnclosingClass();
     }
-
+    if (element.isAccessor()) {
+      element = (element as FunctionElement).abstractField;
+    }
     return library.getImportsFor(element);
   }
 
   /// Replaces the imports of [outputUnit] with those in
   /// [replacementImports]. Because mainOutputUnit has a special handling we
   /// create a new outputUnit instead, and update the mapping from the
   /// dependency to its outputUnit.
   void _replaceOutputUnitImports(dynamic dependency,
                                  OutputUnit outputUnit,
                                  Iterable<Import> replacementImports) {
@@ skipping 521 matching lines @@
                   ? previousDeferredImport
                   : import;
               compiler.reportError(failingImport.prefix,
                   MessageKind.DEFERRED_LIBRARY_DUPLICATE_PREFIX);
             }
             usedPrefixes.add(prefix);
           }
         }
       });
     }
+    Backend backend = compiler.backend;
+    if (splitProgram && backend is JavaScriptBackend) {
+      backend.registerCheckDeferredIsLoaded(compiler.globalDependencies);
+    }
     if (splitProgram && backend is DartBackend) {
       // TODO(sigurdm): Implement deferred loading for dart2dart.
       splitProgram = false;
       compiler.reportInfo(
           lastDeferred,
           MessageKind.DEFERRED_LIBRARY_DART_2_DART);
     }
   }
+
+  /// If [send] is a static send with a deferred element, returns the
+  /// [PrefixElement] that the first prefix of the send resolves to.
+  /// Otherwise returns null.
+  /// Precondition: send must be static.

[floitsch, 2014/04/22 12:33:44]

New line before Precondition.

[sigurdm, 2014/04/23 14:01:46]

Done.

+  ///
+  /// Example:
+  ///
+  /// import "a.dart" deferred as a;
+  ///
+  /// main() {
+  ///   print(a.loadLibrary.toString());
+  ///   a.loadLibrary().then((_) {
+  ///     a.run();
+  ///     a.foo.method();
+  ///   });
+  /// }
+  ///
+  /// Returns null for a.loadLibrary() (the special
+  /// function loadLibrary is not deferred). And returns the PrefixElement for
+  /// a.run() and a.foo.
+  /// a.loadLibrary.toString() and a.foo.method() are dynamic sends - and
+  /// this functions should not be called on them.
+  PrefixElement deferredPrefixElement(ast.Send send, TreeElements elements) {
+    Element element = elements[send];
+    // The DeferredLoaderGetter is not deferred, therefore we do not return the
+    // prefix.
+    if (element != null && element.isDeferredLoaderGetter()) return null;
+
+    ast.Node firstNode(ast.Node node) {
+      if (node is! ast.Send) {
+        return node;
+      } else {
+        ast.Send send = node;
+        ast.Node receiver = send.receiver;
+        ast.Node receiverFirst = firstNode(receiver);
+        if (receiverFirst != null) {
+          return receiverFirst;
+        } else {
+          return firstNode(send.selector);
+        }
+      }
+    }
+    ast.Node first = firstNode(send);
+    ast.Node identifier = first.asIdentifier();
+    if (identifier == null) return null;
+    Element maybePrefix = elements[identifier];
+    if (maybePrefix != null && maybePrefix.isPrefix()) {
+      PrefixElement prefixElement = maybePrefix;
+      if (prefixElement.isDeferred) {
+        return prefixElement;
+      }
+    }
+    return null;
+  }
 }