Constrain constant references from deferred libraries

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

 // Copyright (c) 2012, 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.
 
 part of dart2js;
 
 /**
  * The [ConstantHandler] keeps track of compile-time constants,
  * initializations of global and static fields, and default values of
  * optional parameters.
@@ skipping 393 matching lines @@
         node, type, compiler.symbolConstructor, createArguments);
   }
 
   Constant makeTypeConstant(Element element) {
     DartType elementType = element.computeType(compiler).asRaw();
     DartType constantType =
         compiler.backend.typeImplementation.computeType(compiler);
     return new TypeConstant(elementType, constantType);
   }
 
+  /// Returns true if the prefix of the send resolves to a deferred import
+  /// prefix.
+  bool isDeferredUse(Send send) {
+    // We handle:
+    // 1. Send(Send(Send(null, Prefix), className), staticName)
+    // 2. Send(Send(Prefix, Classname), staticName)
+    // 3. Send(Send(null, Prefix), staticName | className)
+    // 4. Send(Send(Prefix), staticName | className)
+    // Nodes of the forms 2,4 occur in metadata.
+    if (send == null) return false;
+    if (send.receiver is Send) {

[floitsch, 2014/03/12 16:48:13]

Can't you just do a loop here?
while (send.receiver is Send) {
  send = send.receiver;
}

This should basically cover all prefix cases.

+      send = send.receiver;
+      if (send.receiver is Send) {
+        send = send.receiver;
+      }
+    }
+    Identifier prefixNode;
+    if (send.receiver is Identifier) {
+      prefixNode = send.receiver;
+    } else if (send.receiver == null &&
+        send.selector is Identifier) {
+      prefixNode = send.selector;
+    }
+    if (prefixNode != null) {
+      Element maybePrefix = elements[prefixNode.asIdentifier()];
+      if (maybePrefix != null && maybePrefix.isPrefix() &&
+          (maybePrefix as PrefixElement).isDeferred) {
+        return true;
+      }
+    }
+    return false;
+  }
+
   // TODO(floitsch): provide better error-messages.
   Constant visitSend(Send send) {
     Element element = elements[send];
     if (send.isPropertyAccess) {
+      if (isDeferredUse(send)) {
+        return signalNotCompileTimeConstant(send,
+            message: MessageKind.DEFERRED_COMPILE_TIME_CONSTANT);
+      }
       if (Elements.isStaticOrTopLevelFunction(element)) {
         return new FunctionConstant(element);
       } else if (Elements.isStaticOrTopLevelField(element)) {
         Constant result;
         if (element.modifiers.isConst()) {
           result = handler.compileConstant(element);
         } else if (element.modifiers.isFinal() && !isEvaluatingConstant) {
           result = handler.compileVariable(element);
         }
         if (result != null) return result;
@@ skipping 195 matching lines @@
     }
 
     Send send = node.send;
     FunctionElement constructor = elements[send];
     if (Elements.isUnresolved(constructor)) {
       return signalNotCompileTimeConstant(node);
     }
 
     // Deferred types can not be used in const instance creation expressions.
     // Check if the constructor comes from a deferred library.
-    Send selectorSend = node.send.selector.asSend();
-    if (selectorSend != null) {
-      Identifier receiver = selectorSend.receiver.asIdentifier();
-      if (receiver != null) {
-        Element element = elements[receiver];
-        if (element.isPrefix() && (element as PrefixElement).isDeferred) {
-          return signalNotCompileTimeConstant(node,
-              message: MessageKind.DEFERRED_COMPILE_TIME_CONSTANT);
-        }
-      }
+    if (isDeferredUse(node.send.selector.asSend())) {
+      return signalNotCompileTimeConstant(node,
+          message: MessageKind.DEFERRED_COMPILE_TIME_CONSTANT_CONSTRUCTION);
     }
 
     // TODO(ahe): This is nasty: we must eagerly analyze the
     // constructor to ensure the redirectionTarget has been computed
     // correctly.  Find a way to avoid this.
     compiler.analyzeElement(constructor.declaration);
 
     InterfaceType type = elements.getType(node);
     List<Constant> evaluateArguments(FunctionElement constructor) {
       Selector selector = elements.getSelector(send);
@@ skipping 320 matching lines @@
           if (fieldValue == null) {
             // Use the default value.
             fieldValue = handler.compileConstant(field);
           }
           jsNewArguments.add(fieldValue);
         },
         includeSuperAndInjectedMembers: true);
     return jsNewArguments;
   }
 }