Insert checks before deferred calls and accesses.

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

Index: sdk/lib/_internal/compiler/implementation/deferred_load.dart
diff --git a/sdk/lib/_internal/compiler/implementation/deferred_load.dart b/sdk/lib/_internal/compiler/implementation/deferred_load.dart
index 81fba7f2e24ee2b806c4a7e567914439852eaeaa..67e02917e58e63f87e33baf04035452c3a83521d 100644
--- a/sdk/lib/_internal/compiler/implementation/deferred_load.dart
+++ b/sdk/lib/_internal/compiler/implementation/deferred_load.dart
@@ -12,11 +12,15 @@ import 'dart2jslib.dart' show
     ConstructedConstant,
     MessageKind,
     StringConstant,
-    invariant;
+    invariant,
+    Backend;
 
 import 'dart_backend/dart_backend.dart' show
     DartBackend;
 
+import 'js_backend/js_backend.dart' show

[floitsch, 2014/04/14 12:04:08]

We should eventually split this file into a front-end and back-end specific
part. Different CL...

[sigurdm, 2014/04/22 11:22:48]

Good idea.

+    JavaScriptBackend;
+
 import 'elements/elements.dart' show
     Element,
     ClassElement,
@@ -43,6 +47,8 @@ import 'tree/tree.dart' show
     LiteralString,
     LiteralDartString;
 
+import 'tree/tree.dart' as ast;
+
 import 'resolution/resolution.dart' show
     TreeElements;
 
@@ -180,6 +186,11 @@ class DeferredLoadTask extends CompilerTask {
     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].
@@ -257,10 +268,12 @@ class DeferredLoadTask extends CompilerTask {
 
   /// 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);
   }
 
@@ -802,6 +815,10 @@ class DeferredLoadTask extends CompilerTask {
         }
       });
     }
+    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;
@@ -810,4 +827,37 @@ class DeferredLoadTask extends CompilerTask {
           MessageKind.DEFERRED_LIBRARY_DART_2_DART);
     }
   }
+
+  /// Returns the prefixElement associated with the first prefix of [send] in

[floitsch, 2014/04/14 13:14:39]

Please improve the documentation. Hard to understand what this really does.

[sigurdm, 2014/04/22 11:22:48]

You are right - it is not really describing the function well.
I have tried to make it more clear.

+  /// the context of [elements] if the prefix of the send resolves to a deferred
+  /// import. Otherwise returns null.
+  PrefixElement deferredPrefixElement(ast.Send send, TreeElements elements) {
+    Element element = elements[send];
+    if (element != null && element.isDeferredLoaderGetter()) return null;

[floitsch, 2014/04/14 12:04:08]

What happens if I write `lib.loadLibrary.toString()`
Does that return `null`? Should it?

[sigurdm, 2014/04/22 11:22:48]

I think it should return null: lib.loadLibrary is not deferred and therefore
lib.loadLibrary.toString() is not deferred.

+    ast.Node firstNode(ast.Node node) {

[floitsch, 2014/04/14 12:04:08]

New line before nested function.

[sigurdm, 2014/04/22 11:22:48]

Done.

+      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;
+  }
 }