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

pkg/compiler/lib/src/constants/expressions.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 dart2js.constants.expressions;
 
 import '../dart2jslib.dart' show assertDebugMode;
 import '../dart_types.dart';
 import '../elements/elements.dart' show
     ConstructorElement,
     Element,
     FunctionElement,
+    PrefixElement,
     VariableElement;
 import '../resolution/operators.dart';
 import '../universe/universe.dart' show CallStructure;
 import 'values.dart';
 
 enum ConstantExpressionKind {
   BINARY,
   BOOL,
   CONCATENATE,
   CONDITIONAL,
   CONSTRUCTED,
+  DEFERRED,
   DOUBLE,
   ERRONEOUS,
   FUNCTION,
   IDENTICAL,
   INT,
   LIST,
   MAP,
   NULL,
   STRING,
   SYMBOL,
@@ skipping 565 matching lines @@
   }
 
   @override
   bool _equals(ConditionalConstantExpression other) {
     return condition == other.condition &&
            trueExp == other.trueExp &&
            falseExp == other.falseExp;
   }
 }
 
+/// A constant expression referenced with a deferred prefix.
+/// For example `lib.C`.
+class DeferredConstantExpression extends ConstantExpression {
+  final ConstantValue value;
+  final ConstantExpression expression;
+  final PrefixElement prefix;
+
+  DeferredConstantExpression(this.value, this.expression, this.prefix);
+
+  ConstantExpressionKind get kind => ConstantExpressionKind.DEFERRED;
+
+  @override
+  int _computeHashCode() {
+    return 13 * expression.hashCode;
+  }
+
+  @override
+  bool _equals(DeferredConstantExpression other) {
+    return expression == other.expression;
+  }
+
+  @override
+  accept(ConstantExpressionVisitor visitor, [context]) {
+    return visitor.visitDeferred(this, context);
+  }
+}
+
 abstract class ConstantExpressionVisitor<C, R> {
   const ConstantExpressionVisitor();
 
   R visit(ConstantExpression constant, C context) {
     return constant.accept(this, context);
   }
 
   R visitPrimitive(PrimitiveConstantExpression exp, C context);
   R visitList(ListConstantExpression exp, C context);
   R visitMap(MapConstantExpression exp, C context);
   R visitConstructed(ConstructedConstantExpression exp, C context);
   R visitConcatenate(ConcatenateConstantExpression exp, C context);
   R visitSymbol(SymbolConstantExpression exp, C context);
   R visitType(TypeConstantExpression exp, C context);
   R visitVariable(VariableConstantExpression exp, C context);
   R visitFunction(FunctionConstantExpression exp, C context);
   R visitBinary(BinaryConstantExpression exp, C context);
   R visitIdentical(IdenticalConstantExpression exp, C context);
   R visitUnary(UnaryConstantExpression exp, C context);
   R visitConditional(ConditionalConstantExpression exp, C context);
+  R visitDeferred(DeferredConstantExpression exp, C context);
 }
 
 /// Represents the declaration of a constant [element] with value [expression].
 // TODO(johnniwinther): Where does this class belong?
 class ConstDeclaration {
   final VariableElement element;
   final ConstantExpression expression;
 
   ConstDeclaration(this.element, this.expression);
 }
@@ skipping 162 matching lines @@
 
   @override
   void visitConditional(ConditionalConstantExpression exp, [_]) {
     write(exp, exp.condition, leftAssociative: false);
     sb.write(' ? ');
     write(exp, exp.trueExp);
     sb.write(' : ');
     write(exp, exp.falseExp);
   }
 
+  @override
+  visitDeferred(DeferredConstantExpression exp, context) {
+    sb.write(exp.prefix.deferredImport.prefix.source);
+    sb.write('.');
+    write(exp, exp.expression);
+  }
+
   String toString() => sb.toString();
 }