Allow use of deferred type-literals in non-constant contexts.

pkg/compiler/lib/src/resolution/members.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 resolution;
 
 abstract class TreeElements {
   AnalyzableElement get analyzedElement;
   Iterable<Node> get superUses;
 
@@ skipping 2850 matching lines @@
           // Potentially a 'dynamic' type literal.
           type = registry.getType(node.selector);
         }
         if (type == null) {
           type = target.computeType(compiler);
         }
         registry.registerTypeLiteral(node, type);
 
         // Don't try to make constants of calls to type literals.
         if (!node.isCall) {
-          analyzeConstantDeferred(node);
+          analyzeConstantDeferred(node, enforceConst: false);
         } else {
           // The node itself is not a constant but we register the selector (the
           // identifier that refers to the class/typedef) as a constant.
           if (node.receiver != null) {
             // This is a hack for the case of prefix.Type, we need to store
             // the element on the selector, so [analyzeConstant] can build
             // the type literal from the selector.
             registry.useElement(node.selector, target);
           }
-          analyzeConstantDeferred(node.selector);
+          analyzeConstantDeferred(node.selector, enforceConst: false);
         }
       }
       if (isPotentiallyMutableTarget(target)) {
         if (enclosingElement != target.enclosingElement) {
           for (Node scope in promotionScope) {
             registry.setAccessedByClosureIn(scope, target, node);
           }
         }
       }
     }
@@ skipping 542 matching lines @@
       if (cls == compiler.stringClass) continue;
       Element equals = cls.lookupMember('==');
       if (equals.enclosingClass != compiler.objectClass) {
         compiler.reportError(spannable,
                              MessageKind.CONST_MAP_KEY_OVERRIDES_EQUALS,
                              {'type': keyType});
       }
     }
   }
 
-  void analyzeConstant(Node node) {
+  void analyzeConstant(Node node, {enforceConst: true}) {
     ConstantExpression constant =
         compiler.resolver.constantCompiler.compileNode(
-            node, registry.mapping);
+            node, registry.mapping, enforceConst: enforceConst);
 
     if (constant == null) {
       assert(invariant(node, compiler.compilationFailed));
       return;
     }
 
     ConstantValue value = constant.value;
     if (value.isMap) {
       checkConstMapKeysDontOverrideEquals(node, value);
     }
@@ skipping 11 matching lines @@
           compiler.reportError(node,
               MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
         }
       } else {
         compiler.reportError(node,
             MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
       }
     }
   }
 
-  void analyzeConstantDeferred(Node node) {
+  void analyzeConstantDeferred(Node node, {bool enforceConst: true}) {
     addDeferredAction(enclosingElement, () {
-      analyzeConstant(node);
+      analyzeConstant(node, enforceConst: enforceConst);
     });
   }
 
   bool validateSymbol(Node node, String name, {bool reportError: true}) {
     if (name.isEmpty) return true;
     if (name.startsWith('_')) {
       if (reportError) {
         compiler.reportError(node, MessageKind.PRIVATE_IDENTIFIER,
                              {'value': name});
       }
@@ skipping 1656 matching lines @@
 }
 
 /// The result for the resolution of the `assert` method.
 class AssertResult implements ResolutionResult {
   const AssertResult();
 
   Element get element => null;
 
   String toString() => 'AssertResult()';
 }