WIP: Compute constant expressions in resolution.

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.
 
 library dart2js.resolution.members;
 
 import '../common.dart';
 import '../common/names.dart' show
     Selectors;
 import '../compiler.dart' show
     Compiler;
 import '../constants/constructors.dart' show
+    ErroneousConstantConstructor,
     RedirectingFactoryConstantConstructor;
+import '../constants/evaluation.dart' show
+    ConstantTypeChecker,
+    ConstantTypeInfo;
 import '../constants/expressions.dart';
 import '../constants/values.dart';
 import '../core_types.dart';
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../elements/modelx.dart' show
     ConstructorElementX,
     ErroneousElementX,
     FunctionElementX,
     JumpTargetX,
@@ skipping 36 matching lines @@
 import 'scope.dart' show
     BlockScope,
     MethodScope,
     Scope;
 import 'signatures.dart' show
     SignatureResolver;
 import 'variables.dart' show
     VariableDefinitionsVisitor;
 
 /// The state of constants in resolutions.
-enum ConstantState {
-  /// Expressions are not required to be constants.
-  NON_CONSTANT,
+abstract class ConstantState {
 
-  /// Expressions are required to be constants.
+  /// `true` if expressions are required to be constant.
+  bool get requiresConstant;
+
+  /// `true` if parameter references are considered constant. This is the case
+  /// in const constructor initializers.
+  bool get parameterReferenceIsConstant;
+
+  /// Returns the constant state corresponding to this state but where
+  /// expression are required to be constants.
+  ConstantState get requireConstant;
+
+  /// Constant state where expressions are not required to be constants.
+  static const ConstantState NON_CONSTANT = const _NoneConstantState();
+
+  /// Constant state where expressions are required to be constants.
   ///
   /// For instance the values of a constant list literal.
-  CONSTANT,
+  static const ConstantState CONSTANT = const _RequiredConstantState();
 
-  /// Expressions are required to be constants and parameter references are
-  /// also considered constant.
+  /// Constant state where expressions are required to be constants and
+  /// parameter references are also considered constant.
   ///
   /// This is used for resolving constructor initializers of constant
   /// constructors.
-  CONSTANT_INITIALIZER,
+  static const ConstantState CONSTANT_INITIALIZER =
+      const _ConstantInitializerState();
+}
+
+/// Constant state where expressions are not required to be constants.
+class _NoneConstantState implements ConstantState {
+  const _NoneConstantState();
+
+  @override
+  bool get requiresConstant => false;
+
+  @override
+  bool get parameterReferenceIsConstant => false;
+
+  @override
+  ConstantState get requireConstant => ConstantState.CONSTANT;
+}
+
+/// Constant state where expressions are required to be constants.
+///
+/// For instance the values of a constant list literal.
+class _RequiredConstantState implements ConstantState {
+  const _RequiredConstantState();
+
+  @override
+  bool get requiresConstant => true;
+
+  @override
+  bool get parameterReferenceIsConstant => false;
+
+  @override
+  ConstantState get requireConstant => this;
+}
+
+/// Constant state where expressions are required to be constants and parameter
+/// references are also considered constant.
+///
+/// This is used for resolving constructor initializers of constant
+/// constructors.
+class _ConstantInitializerState implements ConstantState {
+  const _ConstantInitializerState();
+
+  @override
+  bool get requiresConstant => true;
+
+  @override
+  bool get parameterReferenceIsConstant => true;
+
+  @override
+  ConstantState get requireConstant => this;
 }
 
 /**
  * Core implementation of resolution.
  *
  * Do not subclass or instantiate this class outside this library
  * except for testing.
  */
 class ResolverVisitor extends MappingVisitor<ResolutionResult> {
   /**
    * The current enclosing element for the visited AST nodes.
    *
    * This field is updated when nested closures are visited.
    */
   Element enclosingElement;
 
   /// Whether we are in a context where `this` is accessible (this will be false
   /// in static contexts, factory methods, and field initializers).
   bool inInstanceContext;
   bool inCheckContext;
   bool inCatchBlock;
   ConstantState constantState;
+  final ConstantNodeChecker constantExpressionChecker;
+  final ConstantNodeChecker constantExpressionValidator;
 
   Scope scope;
   ClassElement currentClass;
   ExpressionStatement currentExpressionStatement;
 
   /// `true` if a [Send] or [SendSet] is visited as the prefix of member access.
   /// For instance `Class` in `Class.staticField` or `prefix.Class` in
   /// `prefix.Class.staticMethod()`.
   bool sendIsMemberAccess = false;
 
@@ skipping 58 matching lines @@
           ? Scope.buildEnclosingScope(element) : element.buildScope(),
       // The type annotations on a typedef do not imply type checks.
       // TODO(karlklose): clean this up (dartbug.com/8870).
       inCheckContext = compiler.enableTypeAssertions &&
           !element.isLibrary &&
           !element.isTypedef &&
           !element.enclosingElement.isTypedef,
       inCatchBlock = false,
       constantState = element.isConst
           ? ConstantState.CONSTANT : ConstantState.NON_CONSTANT,
+      constantExpressionChecker = new ConstantNodeChecker(
+          compiler, constantIsRequired: true),
+      constantExpressionValidator = new ConstantNodeChecker(
+          compiler, constantIsRequired: false),
       super(compiler, registry);
 
   CoreTypes get coreTypes => compiler.coreTypes;
 
+  ConstantNodeChecker get constantChecker {
+    if (constantState.requiresConstant) {
+      return constantExpressionChecker;
+    } else {
+      return constantExpressionValidator;
+    }
+  }
+
   AsyncMarker get currentAsyncMarker {
     if (enclosingElement is FunctionElement) {
       FunctionElement function = enclosingElement;
       return function.asyncMarker;
     }
     return AsyncMarker.SYNC;
   }
 
   Element reportLookupErrorIfAny(Element result, Node node, String name) {
     if (!Elements.isUnresolved(result)) {
@@ skipping 58 matching lines @@
     return result;
   }
 
   ResolutionResult visitInStaticContext(Node node,
                                         {bool inConstantInitializer: false}) {
     return inStaticContext(
         () => visit(node),
         inConstantInitializer: inConstantInitializer);
   }
 
+  /// Execute [action] where the constant state is `ConstantState.NON_CONSTANT`.
+  inNonConstantContext(action()) {
+    ConstantState oldConstantState = constantState;
+    constantState = ConstantState.NON_CONSTANT;
+    var result = action();
+    constantState = oldConstantState;
+    return result;
+  }
+
   /// Execute [action] where the constant state is `ConstantState.CONSTANT` if
   /// not already `ConstantState.CONSTANT_INITIALIZER`.
   inConstantContext(action()) {
     ConstantState oldConstantState = constantState;
-    if (constantState != ConstantState.CONSTANT_INITIALIZER) {
-      constantState = ConstantState.CONSTANT;
-    }
+    constantState = constantState.requireConstant;
     var result = action();
     constantState = oldConstantState;
     return result;
   }
 
+  bool checkConstantInvariant(Node node, ResolutionResult result) {
+    return invariant(
+        node,
+        !constantState.requiresConstant || result.isConstant,
+        message: "No constant computed for expression.");
+  }
+
+
   /// Visit [node] where the constant state is `ConstantState.CONSTANT` if
   /// not already `ConstantState.CONSTANT_INITIALIZER`.
   ResolutionResult visitInConstantContext(Node node) {
     ResolutionResult result = inConstantContext(() => visit(node));
     assert(invariant(node, result != null,
         message: "No resolution result for $node."));
 
     return result;
   }
 
@@ skipping 167 matching lines @@
       // TODO(karlklose): should be a list of [FormalElement]s, but the actual
       // implementation uses [Element].
       List<Element> optionals = functionParameters.optionalParameters;
       if (!optionals.isEmpty && element == optionals.first) {
         NodeList nodes = parameterNodes.head;
         parameterNodes = nodes.nodes;
       }
       if (element.isOptional) {
         if (element.initializer != null) {
           ResolutionResult result = visitInConstantContext(element.initializer);
-          if (result.isConstant) {
-            element.constant = result.constant;
-          }
+          assert(invariant(element, result.isConstant,
+              message: "No default value computed for $element."));
+          element.constant = result.constant;
         } else {
           element.constant = new NullConstantExpression();
         }
       }
       VariableDefinitions variableDefinitions = parameterNodes.head;
       Node parameterNode = variableDefinitions.definitions.nodes.head;
       // Field parameters (this.x) are not visible inside the constructor. The
       // fields they reference are visible, but must be resolved independently.
       if (element.isInitializingFormal) {
         registry.useElement(parameterNode, element);
@@ skipping 146 matching lines @@
       addToScope(function);
     }
     Scope oldScope = scope; // The scope is modified by [setupFunction].
     setupFunction(node, function);
 
     Element previousEnclosingElement = enclosingElement;
     enclosingElement = function;
     // Run the body in a fresh statement scope.
     StatementScope oldStatementScope = statementScope;
     statementScope = new StatementScope();
-    visit(node.body);
+    inNonConstantContext(() => visit(node.body));
     statementScope = oldStatementScope;
 
     scope = oldScope;
     enclosingElement = previousEnclosingElement;
 
     registry.registerClosure(function);
     registry.registerInstantiatedClass(compiler.functionClass);
-    return const NoneResult();
+    return ensureConstantResult(node, const NoneResult());
+  }
+
+  ResolutionResult ensureConstantResult(Node node, ResolutionResult result) {
+    if (constantState.requiresConstant && !result.isConstant) {
+      reporter.reportErrorMessage(
+          node, MessageKind.NOT_A_COMPILE_TIME_CONSTANT);
+      return new ConstantResult(
+          node, new ErroneousConstantExpression(), element: result.element);
+    }
+    return result;
   }
 
   ResolutionResult visitIf(If node) {
     doInPromotionScope(node.condition.expression, () => visit(node.condition));
     doInPromotionScope(node.thenPart,
         () => visitIn(node.thenPart, new BlockScope(scope)));
     visitIn(node.elsePart, new BlockScope(scope));
     return const NoneResult();
   }
 
@@ skipping 80 matching lines @@
     bool isValidAsConstant = true;
     List<ResolutionResult> argumentResults = <ResolutionResult>[];
     bool oldSendIsMemberAccess = sendIsMemberAccess;
     sendIsMemberAccess = false;
     Map<String, Node> seenNamedArguments = new Map<String, Node>();
     int argumentCount = 0;
     List<String> namedArguments = <String>[];
     for (Link<Node> link = list.nodes; !link.isEmpty; link = link.tail) {
       Expression argument = link.head;
       ResolutionResult result = visit(argument);
+      assert(checkConstantInvariant(argument, result));
       if (!result.isConstant) {
         isValidAsConstant = false;
       }
       argumentResults.add(result);
 
       NamedArgument namedArgument = argument.asNamedArgument();
       if (namedArgument != null) {
         String source = namedArgument.name.source;
         namedArguments.add(source);
         if (seenNamedArguments.containsKey(source)) {
@@ skipping 466 matching lines @@
         // whether it is erroneous.
         if (semantics.kind == AccessKind.SUPER_METHOD) {
           registry.registerStaticUse(semantics.element.declaration);
         }
         // TODO(23998): Remove this when all information goes through
         // the [SendStructure].
         registry.useElement(node, semantics.element);
       }
     } else {
       ResolutionResult expressionResult = visitExpression(expression);
+      assert(checkConstantInvariant(expression, expressionResult));
       semantics = const DynamicAccess.expression();
       registry.registerDynamicInvocation(new UniverseSelector(selector, null));
 
+      ConstantExpression constant;
       if (expressionResult.isConstant) {
-        bool isValidConstant;
-        ConstantExpression expressionConstant = expressionResult.constant;
-        DartType knownExpressionType =
-            expressionConstant.getKnownType(coreTypes);
-        switch (operator.kind) {
-          case UnaryOperatorKind.COMPLEMENT:
-            isValidConstant =
-                knownExpressionType == coreTypes.intType;
-            break;
-          case UnaryOperatorKind.NEGATE:
-            isValidConstant =
-                knownExpressionType == coreTypes.intType ||
-                knownExpressionType == coreTypes.doubleType;
-            break;
-          case UnaryOperatorKind.NOT:
-            reporter.internalError(node,
-                "Unexpected user definable unary operator: $operator");
+        bool isValidAsConstant =
+            !expressionResult.constant.isErroneous &&
+            constantChecker.checkUnary(
+                operator,
+                constantChecker.createInfo(expressionResult));
+        if (isValidAsConstant) {
+          constant =
+              new UnaryConstantExpression(operator, expressionResult.constant);
         }
-        if (isValidConstant) {
-          // TODO(johnniwinther): Handle potentially invalid constant
-          // expressions.
-          ConstantExpression constant =
-              new UnaryConstantExpression(operator, expressionConstant);
-          registry.setConstant(node, constant);
-          result = new ConstantResult(node, constant);
-        }
+      }
+      if (constant == null && constantState.requiresConstant) {
+        constant = new ErroneousConstantExpression();
+      }
+      if (constant != null) {
+        registry.setConstant(node, constant);
+        result = new ConstantResult(node, constant);
       }
     }
     if (semantics != null) {
       registry.registerSendStructure(node,
           new UnaryStructure(semantics, operator));
     }
     return result;
   }
 
   /// Handle a not expression, like `!a`.
   ResolutionResult handleNot(Send node, UnaryOperator operator) {
     assert(invariant(node, operator.kind == UnaryOperatorKind.NOT));
 
     Node expression = node.receiver;
-    ResolutionResult result = visitExpression(expression);
+    ResolutionResult expressionResult = visitExpression(expression);
     registry.registerSendStructure(node, const NotStructure());
 
-    if (result.isConstant) {
-      ConstantExpression expressionConstant = result.constant;
-      if (expressionConstant.getKnownType(coreTypes) == coreTypes.boolType) {
-        // TODO(johnniwinther): Handle potentially invalid constant expressions.
-        ConstantExpression constant =
-            new UnaryConstantExpression(operator, expressionConstant);
-        registry.setConstant(node, constant);
-        return new ConstantResult(node, constant);
+    ConstantExpression constant;
+    if (expressionResult.isConstant) {
+      bool isValidAsConstant = constantChecker.checkUnary(
+          operator,
+          constantChecker.createInfo(expressionResult));
+      if (isValidAsConstant) {
+        constant =
+            new UnaryConstantExpression(operator, expressionResult.constant);
       }
     }
-
+    if (constant == null && constantState.requiresConstant) {
+      constant = new ErroneousConstantExpression();
+    }
+    if (constant != null) {
+      registry.setConstant(node, constant);
+      return new ConstantResult(node, constant);
+    }
     return const NoneResult();
   }
 
   /// Handle a logical and expression, like `a && b`.
   ResolutionResult handleLogicalAnd(Send node) {
     Node left = node.receiver;
     Node right = node.arguments.head;
     ResolutionResult leftResult =
         doInPromotionScope(left, () => visitExpression(left));
     ResolutionResult rightResult =
         doInPromotionScope(right, () => visitExpression(right));
     registry.registerSendStructure(node, const LogicalAndStructure());
 
+    ConstantExpression constant;
     if (leftResult.isConstant && rightResult.isConstant) {
-      ConstantExpression leftConstant = leftResult.constant;
-      ConstantExpression rightConstant = rightResult.constant;
-      if (leftConstant.getKnownType(coreTypes) == coreTypes.boolType &&
-          rightConstant.getKnownType(coreTypes) == coreTypes.boolType) {
-        // TODO(johnniwinther): Handle potentially invalid constant expressions.
-        ConstantExpression constant = new BinaryConstantExpression(
-            leftConstant,
+      bool isValidAsConstant = constantChecker.checkBinaryExpression(
+          node,
+          constantChecker.createInfo(leftResult),
+          BinaryOperator.LOGICAL_AND,
+          constantChecker.createInfo(rightResult));
+      if (isValidAsConstant) {
+        constant = new BinaryConstantExpression(
+            leftResult.constant,
             BinaryOperator.LOGICAL_AND,
-            rightConstant);
-        registry.setConstant(node, constant);
-        return new ConstantResult(node, constant);
+            rightResult.constant);
       }
     }
-
+    if (constant == null && constantState.requiresConstant) {
+      constant = new ErroneousConstantExpression();
+    }
+    if (constant != null) {
+      registry.setConstant(node, constant);
+      return new ConstantResult(node, constant);
+    }
     return const NoneResult();
   }
 
   /// Handle a logical or expression, like `a || b`.
   ResolutionResult handleLogicalOr(Send node) {
     Node left = node.receiver;
     Node right = node.arguments.head;
     ResolutionResult leftResult = visitExpression(left);
     ResolutionResult rightResult = visitExpression(right);
     registry.registerSendStructure(node, const LogicalOrStructure());
 
+    ConstantExpression constant;
     if (leftResult.isConstant && rightResult.isConstant) {
-      ConstantExpression leftConstant = leftResult.constant;
-      ConstantExpression rightConstant = rightResult.constant;
-      if (leftConstant.getKnownType(coreTypes) == coreTypes.boolType &&
-          rightConstant.getKnownType(coreTypes) == coreTypes.boolType) {
-        // TODO(johnniwinther): Handle potentially invalid constant expressions.
-        ConstantExpression constant = new BinaryConstantExpression(
-            leftConstant,
+      bool isValidAsConstant = constantChecker.checkBinaryExpression(
+          node,
+          constantChecker.createInfo(leftResult),
+          BinaryOperator.LOGICAL_OR,
+          constantChecker.createInfo(rightResult));
+      if (isValidAsConstant) {
+        constant = new BinaryConstantExpression(
+            leftResult.constant,
             BinaryOperator.LOGICAL_OR,
-            rightConstant);
-        registry.setConstant(node, constant);
-        return new ConstantResult(node, constant);
+            rightResult.constant);
       }
     }
+    if (constant == null && constantState.requiresConstant) {
+      constant = new ErroneousConstantExpression();
+    }
+    if (constant != null) {
+      registry.setConstant(node, constant);
+      return new ConstantResult(node, constant);
+    }
     return const NoneResult();
   }
 
   /// Handle an if-null expression, like `a ?? b`.
   ResolutionResult handleIfNull(Send node) {
     Node left = node.receiver;
     Node right = node.arguments.head;
     visitExpression(left);
     visitExpression(right);
     registry.registerSendStructure(node, const IfNullStructure());
-    return const NoneResult();
+    ResolutionResult result = const NoneResult();
+    if (constantState.requiresConstant) {
+      ConstantExpression constant = new ErroneousConstantExpression();
+      reporter.reportErrorMessage(node, MessageKind.INVALID_CONSTANT_IF_NULL);
+      registry.setConstant(node, constant);
+      result = new ConstantResult(node, constant);
+    }
+    return result;
   }
 
   /// Handle the binary expression of an unresolved binary operator [text], like
   /// the no longer supported `a === b`.
   ResolutionResult handleUnresolvedBinary(Send node, String text) {
     Node left = node.receiver;
     Node right = node.arguments.head;
     if (node.isSuperCall) {
       checkSuperAccess(node);
     } else {
@@ skipping 35 matching lines @@
         // the [SendStructure].
         registry.useElement(node, semantics.element);
       }
       visitExpression(right);
     } else {
       ResolutionResult leftResult = visitExpression(left);
       ResolutionResult rightResult = visitExpression(right);
       registry.registerDynamicInvocation(new UniverseSelector(selector, null));
       semantics = const DynamicAccess.expression();
 
+      ConstantExpression constant;
       if (leftResult.isConstant && rightResult.isConstant) {
-        bool isValidConstant;
-        ConstantExpression leftConstant = leftResult.constant;
-        ConstantExpression rightConstant = rightResult.constant;
-        DartType knownLeftType = leftConstant.getKnownType(coreTypes);
-        DartType knownRightType = rightConstant.getKnownType(coreTypes);
-        switch (operator.kind) {
-          case BinaryOperatorKind.EQ:
-          case BinaryOperatorKind.NOT_EQ:
-            isValidConstant =
-                (knownLeftType == coreTypes.intType ||
-                 knownLeftType == coreTypes.doubleType ||
-                 knownLeftType == coreTypes.stringType ||
-                 knownLeftType == coreTypes.boolType ||
-                 knownLeftType == coreTypes.nullType) &&
-                (knownRightType == coreTypes.intType ||
-                 knownRightType == coreTypes.doubleType ||
-                 knownRightType == coreTypes.stringType ||
-                 knownRightType == coreTypes.boolType ||
-                 knownRightType == coreTypes.nullType);
-            break;
-          case BinaryOperatorKind.ADD:
-            isValidConstant =
-                (knownLeftType == coreTypes.intType ||
-                 knownLeftType == coreTypes.doubleType ||
-                 knownLeftType == coreTypes.stringType) &&
-                (knownRightType == coreTypes.intType ||
-                 knownRightType == coreTypes.doubleType ||
-                 knownRightType == coreTypes.stringType);
-            break;
-          case BinaryOperatorKind.SUB:
-          case BinaryOperatorKind.MUL:
-          case BinaryOperatorKind.DIV:
-          case BinaryOperatorKind.IDIV:
-          case BinaryOperatorKind.MOD:
-          case BinaryOperatorKind.GTEQ:
-          case BinaryOperatorKind.GT:
-          case BinaryOperatorKind.LTEQ:
-          case BinaryOperatorKind.LT:
-            isValidConstant =
-                (knownLeftType == coreTypes.intType ||
-                 knownLeftType == coreTypes.doubleType) &&
-                (knownRightType == coreTypes.intType ||
-                 knownRightType == coreTypes.doubleType);
-            break;
-          case BinaryOperatorKind.SHL:
-          case BinaryOperatorKind.SHR:
-          case BinaryOperatorKind.AND:
-          case BinaryOperatorKind.OR:
-          case BinaryOperatorKind.XOR:
-            isValidConstant =
-                knownLeftType == coreTypes.intType &&
-                knownRightType == coreTypes.intType;
-            break;
-          case BinaryOperatorKind.INDEX:
-            isValidConstant = false;
-            break;
-          case BinaryOperatorKind.LOGICAL_AND:
-          case BinaryOperatorKind.LOGICAL_OR:
-          case BinaryOperatorKind.IF_NULL:
-            reporter.internalError(
-                node, "Unexpected binary operator '${operator}'.");
-            break;
-        }
-        if (isValidConstant) {
-          // TODO(johnniwinther): Handle potentially invalid constant
-          // expressions.
-          ConstantExpression constant = new BinaryConstantExpression(
+        //reportHere(compiler, node, 'left=${leftResult.constant.getText()},right=${rightResult.constant.getText()}');
+        bool isValidAsConstant = constantChecker.checkBinaryExpression(
+            node,
+            constantChecker.createInfo(leftResult),
+            operator,
+            constantChecker.createInfo(rightResult));
+        if (isValidAsConstant) {
+          constant = new BinaryConstantExpression(
               leftResult.constant,
               operator,
               rightResult.constant);
-          registry.setConstant(node, constant);
-          result = new ConstantResult(node, constant);
         }
       }
+      if (constant == null && constantState.requiresConstant) {
+        constant = new ErroneousConstantExpression();
+      }
+      if (constant != null) {
+        registry.setConstant(node, constant);
+        result = new ConstantResult(node, constant);
+      }
     }
 
     if (semantics != null) {
       // TODO(johnniwinther): Support invalid super access as an
       // [AccessSemantics].
       SendStructure sendStructure;
       switch (operator.kind) {
         case BinaryOperatorKind.EQ:
           sendStructure = new EqualsStructure(semantics);
           break;
@@ skipping 47 matching lines @@
     registry.registerDynamicInvocation(new UniverseSelector(selector, null));
     registry.registerSendStructure(node,
         new InvokeStructure(const DynamicAccess.expression(), selector));
     return const NoneResult();
   }
 
   /// Handle access of a property of [name] on `this`, like `this.name` and
   /// `this.name()`, or `name` and `name()` in instance context.
   ResolutionResult handleThisPropertyAccess(Send node, Name name) {
     AccessSemantics semantics = new DynamicAccess.thisProperty(name);
-    return handleDynamicAccessSemantics(node, name, semantics);
+    return handleDynamicAccessSemantics(
+        node, const NoneResult(), name, semantics);
   }
 
   /// Handle update of a property of [name] on `this`, like `this.name = b` and
   /// `this.name++`, or `name = b` and `name++` in instance context.
   ResolutionResult handleThisPropertyUpdate(
       SendSet node, Name name, Element element) {
     AccessSemantics semantics = new DynamicAccess.thisProperty(name);
     return handleDynamicUpdateSemantics(node, name, element, semantics);
   }
 
@@ skipping 492 matching lines @@
   // TODO(johnniwinther): Remove [element] when it is no longer needed for
   // evaluating constants.
   ResolutionResult handleConstantTypeLiteralUpdate(
       SendSet node,
       Name name,
       TypeDeclarationElement element,
       DartType type,
       ConstantAccess semantics) {
 
     // TODO(johnniwinther): Remove this when all constants are evaluated.
-    compiler.resolver.constantCompiler.evaluate(semantics.constant);
+    compiler.resolver.constantCompiler.evaluate(node, semantics.constant);
 
     ErroneousElement error;
     if (node.isIfNullAssignment) {
       error = reportAndCreateErroneousElement(
           node.selector, name.text,
           MessageKind.IF_NULL_ASSIGNING_TYPE, const {});
       // TODO(23998): Remove these when all information goes through
       // the [SendStructure].
       registry.setConstant(node.selector, semantics.constant);
       registry.useElement(node.selector, element);
@@ skipping 51 matching lines @@
         node, const PublicName('dynamic'), compiler.typeClass, type, semantics);
   }
 
   /// Handle update to a type literal of the type 'dynamic'. Like `dynamic++` or
   /// `dynamic = 0`.
   ResolutionResult handleDynamicTypeLiteralUpdate(SendSet node) {
     DartType type = const DynamicType();
     ConstantExpression constant =
         new TypeConstantExpression(const DynamicType());
     AccessSemantics semantics = new ConstantAccess.dynamicTypeLiteral(constant);
+    // TODO(johnniwinther): Remove this when all constants are evaluated.
+    compiler.resolver.constantCompiler.evaluate(node, constant);
     return handleConstantTypeLiteralUpdate(
         node, const PublicName('dynamic'), compiler.typeClass, type, semantics);
   }
 
   /// Handle access to a type literal of a class. Like `C` or
   /// `C()` where 'C' is class.
   ResolutionResult handleClassTypeLiteralAccess(
       Send node,
       Name name,
       ClassElement cls) {
@@ skipping 175 matching lines @@
       ResolutionResult result = handleStaticMemberUpdate(node, name, element);
       if (prefixResult.isDeferred) {
         result = handleDeferredAccess(node, prefixResult.prefix, result);
       }
       return result;
     }
   }
 
   /// Handle dynamic access of [semantics].
   ResolutionResult handleDynamicAccessSemantics(
-      Send node, Name name, AccessSemantics semantics) {
+      Send node,
+      ResolutionResult receiverResult,
+      Name name,
+      AccessSemantics semantics) {
+    ResolutionResult result = const NoneResult();
     SendStructure sendStructure;
     Selector selector;
     if (node.isCall) {
       CallStructure callStructure =
           resolveArguments(node.argumentsNode).callStructure;
       selector = new Selector.call(name, callStructure);
       registry.registerDynamicInvocation(
           new UniverseSelector(selector, null));
       sendStructure = new InvokeStructure(semantics, selector);
     } else {
       assert(invariant(node, node.isPropertyAccess));
       selector = new Selector.getter(name);
       registry.registerDynamicGetter(
           new UniverseSelector(selector, null));
+      if (receiverResult.isConstant && name == const PublicName("length")) {
+        if (constantChecker.isStringOrNull(
+                receiverResult.constant.getKnownType(coreTypes))) {
+          ConstantExpression constant =
+              new StringLengthConstantExpression(receiverResult.constant);
+          registry.setConstant(node, constant);
+          result = new ConstantResult(node, constant);
+        }
+      }
       sendStructure = new GetStructure(semantics);
     }
     registry.registerSendStructure(node, sendStructure);
     // TODO(23998): Remove this when all information goes through
     // the [SendStructure].
     registry.setSelector(node, selector);
-    return const NoneResult();
+    return result;
   }
 
   /// Handle dynamic update of [semantics].
   ResolutionResult handleDynamicUpdateSemantics(
       SendSet node, Name name, Element element, AccessSemantics semantics) {
     Selector getterSelector = new Selector.getter(name);
     Selector setterSelector = new Selector.setter(name.setter);
     registry.registerDynamicSetter(
         new UniverseSelector(setterSelector, null));
     if (node.isComplex) {
@@ skipping 50 matching lines @@
         // TODO(johnniwinther): Handle invalid this access as an
         // [AccessSemantics].
         return handleErroneousAccess(node, name, semantics);
       }
     }
     ResolutionResult result = visitExpressionPrefix(node.receiver);
     if (result.kind == ResultKind.PREFIX) {
       return handlePrefixSend(node, name, result);
     } else if (node.isConditional) {
       return handleDynamicAccessSemantics(
-          node, name, new DynamicAccess.ifNotNullProperty(name));
+          node, result,
+          name, new DynamicAccess.ifNotNullProperty(name));
     } else {
       // Handle dynamic property access, like `a.b` or `a.b()` where `a` is not
       // a prefix or class.
       // TODO(johnniwinther): Use the `element` of [result].
       return handleDynamicAccessSemantics(
-          node, name, new DynamicAccess.dynamicProperty(name));
+          node, result,
+          name, new DynamicAccess.dynamicProperty(name));
     }
   }
 
   /// Handle a qualified [SendSet], that is where the receiver is non-null, like
   /// `a.b = c`, `a.b++`, and `a.b += c`.
   ResolutionResult handleQualifiedSendSet(SendSet node) {
     Identifier selector = node.selector.asIdentifier();
     String text = selector.source;
     Name name = new Name(text, enclosingElement.library);
     if (text == 'this') {
@@ skipping 146 matching lines @@
               ? new IncompatibleInvokeStructure(semantics, selector)
               : new InvokeStructure(semantics, selector));
     } else {
       switch (semantics.kind) {
         case AccessKind.LOCAL_VARIABLE:
         case AccessKind.LOCAL_FUNCTION:
           result = new ElementResult(element);
           break;
         case AccessKind.PARAMETER:
         case AccessKind.FINAL_PARAMETER:
-          if (constantState == ConstantState.CONSTANT_INITIALIZER) {
+          if (constantState.parameterReferenceIsConstant) {
             ParameterElement parameter = element;
             if (parameter.isNamed) {
               result = new ConstantResult(
                   node,
                   new NamedArgumentReference(parameter.name),
                   element: element);
             } else {
               result = new ConstantResult(
                   node,
                   new PositionalArgumentReference(
@@ skipping 170 matching lines @@
       }
       registry.registerSendStructure(node,
           isIncompatibleInvoke
               ? new IncompatibleInvokeStructure(semantics, selector)
               : new InvokeStructure(semantics, selector));
     } else {
       selector = new Selector.getter(name);
       switch (semantics.kind) {
         case AccessKind.STATIC_METHOD:
         case AccessKind.TOPLEVEL_METHOD:
+          MethodElement method = member;
           // TODO(johnniwinther): Method this should be registered as a
           // closurization.
           registry.registerStaticUse(semantics.element);
           registry.registerGetOfStaticFunction(semantics.element);
+          result = new ConstantResult(
+              node,
+              new FunctionConstantExpression(method),
+              element: method);
           break;
         case AccessKind.STATIC_FIELD:
         case AccessKind.FINAL_STATIC_FIELD:
-        case AccessKind.STATIC_GETTER:
         case AccessKind.TOPLEVEL_FIELD:
         case AccessKind.FINAL_TOPLEVEL_FIELD:
+          FieldElement field = member;
+          if (field.isConst) {
+            result = new ConstantResult(
+                node, new VariableConstantExpression(field), element: field);
+          } else {
+            result = new ElementResult(field);
+          }
+          registry.registerStaticUse(semantics.element);
+          break;
+        case AccessKind.STATIC_GETTER:
         case AccessKind.TOPLEVEL_GETTER:
           registry.registerStaticUse(semantics.element);
+          result = new ElementResult(member);
           break;
         case AccessKind.STATIC_SETTER:
         case AccessKind.TOPLEVEL_SETTER:
         case AccessKind.UNRESOLVED:
           registry.registerThrowNoSuchMethod();
           member = reportAndCreateErroneousElement(
               node.selector, name.text,
               MessageKind.CANNOT_RESOLVE_GETTER, const {});
+          result = new ElementResult(member);
           break;
         default:
           reporter.internalError(node,
               "Unexpected statically resolved access $semantics.");
           break;
       }
       registry.registerSendStructure(node, new GetStructure(semantics));
       if (member.isConst) {
         FieldElement field = member;
         result = new ConstantResult(
             node, new VariableConstantExpression(field), element: field);
+      } else if (member.isFunction) {
+        MethodElement function = member;
+        result = new ConstantResult(
+            node, new FunctionConstantExpression(function), element: function);
       } else {
         result = new ElementResult(member);
       }
     }
 
     // TODO(23998): Remove these when all information goes through
     // the [SendStructure].
     registry.useElement(node, member);
     registry.setSelector(node, selector);
 
@@ skipping 235 matching lines @@
         // Create [ErroneousElement] for unresolved access.
         ErroneousElement error = reportCannotResolve(node, text);
         return handleUpdate(node, name, new StaticAccess.unresolved(error));
       }
     } else {
       return handleResolvedSendSet(node, name, element);
     }
   }
 
   ResolutionResult visitSend(Send node) {
+    ResolutionResult result;
     if (node.isOperator) {
       // `a && b`, `a + b`, `-a`, or `a is T`.
-      return handleOperatorSend(node);
+      result = handleOperatorSend(node);
     } else if (node.receiver != null) {
       // `a.b`.
-      return handleQualifiedSend(node);
+      result = handleQualifiedSend(node);
     } else {
       // `a`.
-      return handleUnqualifiedSend(node);
+      result = handleUnqualifiedSend(node);
     }
+    if (result.kind == ResultKind.PREFIX) {
+      return result;
+    }
+    return ensureConstantResult(node, result);
   }
 
   /// Register read access of [target] inside a closure.
   void registerPotentialAccessInClosure(Send node, Element target) {
     if (isPotentiallyMutableTarget(target)) {
       if (enclosingElement != target.enclosingElement) {
         for (Node scope in promotionScope) {
           registry.setAccessedByClosureIn(scope, target, node);
         }
       }
@@ skipping 531 matching lines @@
     Node constructorReference = node.constructorReference;
     if (constructorReference is Send) {
       constructor.redirectionDeferredPrefix =
           compiler.deferredLoadTask.deferredPrefixElement(constructorReference,
                                                           registry.mapping);
     }
 
     registry.setRedirectingTargetConstructor(node, redirectionTarget);
     if (Elements.isUnresolved(redirectionTarget)) {
       registry.registerThrowNoSuchMethod();
+      if (isConstConstructor) {
+        constructor.constantConstructor = const ErroneousConstantConstructor();
+      }
       return const NoneResult();
     } else {
       if (isConstConstructor &&
           !redirectionTarget.isConst) {
         reporter.reportErrorMessage(
             node, MessageKind.CONSTRUCTOR_IS_NOT_CONST);
         isValidAsConstant = false;
       }
       if (redirectionTarget == constructor) {
         reporter.reportErrorMessage(
@@ skipping 60 matching lines @@
       });
       CallStructure callStructure =
           new CallStructure(constructorSignature.parameterCount, names);
       constructor.constantConstructor =
           new RedirectingFactoryConstantConstructor(
               new ConstructedConstantExpression(
                   type,
                   redirectionTarget,
                   callStructure,
                   arguments));
+    } else if (isConstConstructor) {
+      constructor.constantConstructor = const ErroneousConstantConstructor();
     }
     return const NoneResult();
   }
 
   ResolutionResult visitThrow(Throw node) {
     registry.registerThrowExpression();
     visit(node.expression);
-    return const NoneResult();
+    return ensureConstantResult(node, const NoneResult());
   }
 
   ResolutionResult visitAwait(Await node) {
     compiler.futureClass.ensureResolved(resolution);
     visit(node.expression);
     return const NoneResult();
   }
 
   ResolutionResult visitVariableDefinitions(VariableDefinitions node) {
     DartType type;
@@ skipping 62 matching lines @@
     allowedCategory = oldCategory;
     sendIsMemberAccess = oldSendIsMemberAccess;
     if (result.kind == ResultKind.CONSTANT) {
       return result;
     }
     return const NoneResult();
   }
 
   ResolutionResult visitNewExpression(NewExpression node) {
     bool isValidAsConstant = true;
-    ConstructorElement constructor = resolveConstructor(node).element;
+    ConstructorResult result = resolveConstructor(node);
+    //reportHere(reporter, node, '$result');
+    ConstructorElement constructor = result.element;
     final bool isSymbolConstructor = constructor == compiler.symbolConstructor;
     final bool isMirrorsUsedConstant =
         node.isConst && (constructor == compiler.mirrorsUsedConstructor);
     Selector callSelector = resolveSelector(node.send, constructor);
     ArgumentsResult argumentsResult;
     if (node.isConst) {
       argumentsResult =
           inConstantContext(() => resolveArguments(node.send.argumentsNode));
     } else {
       argumentsResult = resolveArguments(node.send.argumentsNode);
     }
+
     registry.useElement(node.send, constructor);
     if (Elements.isUnresolved(constructor)) {
-      return new ResolutionResult.forElement(constructor);
+      if (node.isConst) {
+        ConstantExpression constant = new ErroneousConstantExpression();
+        registry.setConstant(node, constant);
+        return new ConstantResult(node, constant, element: constructor);
+      }
+      return ensureConstantResult(node,
+          new ResolutionResult.forElement(constructor));
     }
     constructor.computeType(resolution);
     if (!callSelector.applies(constructor, compiler.world)) {
       registry.registerThrowNoSuchMethod();
+      if (node.isConst) {
+        // TODO(johnniwinther): Provide a better message.
+        reporter.reportErrorMessage(
+            node, MessageKind.NOT_A_COMPILE_TIME_CONSTANT);
+      }
+      isValidAsConstant = false;
     }
 
     // [constructor] might be the implementation element
     // and only declaration elements may be registered.
     registry.registerStaticUse(constructor.declaration);
     ClassElement cls = constructor.enclosingClass;
     if (cls.isEnumClass && currentClass != cls) {
       reporter.reportErrorMessage(
           node,
           MessageKind.CANNOT_INSTANTIATE_ENUM,
@@ skipping 39 matching lines @@
         if (!compiler.mirrorUsageAnalyzerTask.hasMirrorUsage(
                 enclosingElement)) {
           reporter.reportHintMessage(
               node.newToken, MessageKind.NON_CONST_BLOAT,
               {'name': compiler.symbolClass.name});
         }
       }
     } else if (isMirrorsUsedConstant) {
       compiler.mirrorUsageAnalyzerTask.validate(node, registry.mapping);
     }
+
+    ConstantExpression constant;
     if (node.isConst) {
       analyzeConstantDeferred(node);
 
       // TODO(johnniwinther): Compute this in the [ConstructorResolver].
       // Check that the constructor is not deferred.
       Send send = node.send.selector.asSend();
       if (send != null) {
         // Of the form `const a.b(...)`.
         if (compiler.deferredLoadTask.deferredPrefixElement(
                 send, registry.mapping) != null) {
           // `a` is a deferred prefix.
           isValidAsConstant = false;
           // TODO(johnniwinther): Create an [ErroneousConstantExpression] here
           // when constants are only created during resolution.
         }
       }
 
       if (isValidAsConstant &&
           constructor.isConst &&
           argumentsResult.isValidAsConstant) {
         CallStructure callStructure = argumentsResult.callStructure;
-        List<ConstantExpression> arguments = argumentsResult.constantArguments;
-        ConstructedConstantExpression constant =
-            new ConstructedConstantExpression(
-                type,
-                constructor,
-                callStructure,
-                arguments);
-        return new ConstantResult(node, constant);
+        List<ConstantExpression> arguments =
+            argumentsResult.constantArguments;
+        if (constructor.isFromEnvironmentConstructor) {
+          ConstantResult nameResult = argumentsResult.argumentResults[0];
+          ConstantResult defaultValueResult;
+          ConstantExpression defaultValueConstant;
+          if (arguments.length > 1) {
+            defaultValueResult = argumentsResult.argumentResults[1];
+            defaultValueConstant = defaultValueResult.constant;
+          }
+          if (type == coreTypes.boolType) {
+            isValidAsConstant = constantChecker.checkBoolFromEnvironment(
+                constantChecker.createInfo(nameResult),
+                constantChecker.createInfo(defaultValueResult));
+            if (isValidAsConstant) {
+              constant = new BoolFromEnvironmentConstantExpression(
+                  nameResult.constant, defaultValueConstant);
+            }
+          } else if (type == coreTypes.intType) {
+            isValidAsConstant = constantChecker.checkIntFromEnvironment(
+                constantChecker.createInfo(nameResult),
+                constantChecker.createInfo(defaultValueResult));
+            if (isValidAsConstant) {
+              constant = new IntFromEnvironmentConstantExpression(
+                  nameResult.constant, defaultValueConstant);
+            }
+          } else {
+            assert(type == coreTypes.stringType);
+            isValidAsConstant = constantChecker.checkStringFromEnvironment(
+                constantChecker.createInfo(nameResult),
+                constantChecker.createInfo(defaultValueResult));
+            if (isValidAsConstant) {
+              constant = new StringFromEnvironmentConstantExpression(
+                  nameResult.constant, defaultValueConstant);
+            }
+          }
+        } else {
+          constant = new ConstructedConstantExpression(
+              type, constructor, callStructure, arguments);
+        }
+      }
+      if (constant == null) {
+        constant = new ErroneousConstantExpression();
       }
     }
-
-    return const NoneResult();
+    if (constant != null) {
+      registry.setConstant(node, constant);
+      return new ConstantResult(node, constant);
+    } else {
+      return ensureConstantResult(node, const NoneResult());
+    }
   }
 
   void checkConstMapKeysDontOverrideEquals(Spannable spannable,
                                            MapConstantValue map) {
     for (ConstantValue key in map.keys) {
       if (!key.isObject) continue;
       ObjectConstantValue objectConstant = key;
       DartType keyType = objectConstant.type;
       ClassElement cls = keyType.element;
       if (cls == compiler.stringClass) continue;
@@ skipping 124 matching lines @@
           ResolutionResult elementResult = visit(element);
           if (isValidAsConstant && elementResult.isConstant) {
             constantExpressions.add(elementResult.constant);
           } else {
             isValidAsConstant = false;
           }
         }
       });
       analyzeConstantDeferred(node);
       sendIsMemberAccess = false;
+      ConstantExpression constant;
       if (isValidAsConstant) {
-        ConstantExpression constant =
-            new ListConstantExpression(listType, constantExpressions);
-        registry.setConstant(node, constant);
-        return new ConstantResult(node, constant);
+        constant = new ListConstantExpression(listType, constantExpressions);
+      } else {
+        constant = new ErroneousConstantExpression();
       }
+      registry.setConstant(node, constant);
+      return new ConstantResult(node, constant);
     } else {
       visit(node.elements);
       sendIsMemberAccess = false;
     }
     return const NoneResult();
 
   }
 
   ResolutionResult visitConditional(Conditional node) {
     ResolutionResult conditionResult =
         doInPromotionScope(node.condition, () => visit(node.condition));
+    assert(checkConstantInvariant(node.condition, conditionResult));
+
     ResolutionResult thenResult =
-        doInPromotionScope(node.thenExpression, () => visit(node.thenExpression));
+        doInPromotionScope(node.thenExpression,
+            () => visit(node.thenExpression));
+    assert(checkConstantInvariant(node.thenExpression, thenResult));
+
     ResolutionResult elseResult = visit(node.elseExpression);
+    assert(checkConstantInvariant(node.elseExpression, elseResult));
+
+    ConstantExpression constant;
     if (conditionResult.isConstant &&
         thenResult.isConstant &&
         elseResult.isConstant) {
-      ConstantExpression constant = new ConditionalConstantExpression(
-          conditionResult.constant,
-          thenResult.constant,
-          elseResult.constant);
+      bool isValidAsConstant = constantChecker.checkConditional(
+          constantChecker.createInfo(conditionResult));
+      if (isValidAsConstant) {
+        constant = new ConditionalConstantExpression(
+            conditionResult.constant,
+            thenResult.constant,
+            elseResult.constant);
+      }
+    }
+    if (constant == null && constantState.requiresConstant) {
+      constant = new ErroneousConstantExpression();
+    }
+    if (constant != null) {
       registry.setConstant(node, constant);
       return new ConstantResult(node, constant);
     }
     return const NoneResult();
   }
 
   ResolutionResult visitStringInterpolation(StringInterpolation node) {
     registry.registerInstantiatedType(coreTypes.stringType);
     registry.registerStringInterpolation();
     registerImplicitInvocation(Selectors.toString_);
 
     bool isValidAsConstant = true;
     List<ConstantExpression> parts = <ConstantExpression>[];
 
+    ConstantExpression constant;
     void resolvePart(Node subnode) {
       ResolutionResult result = visit(subnode);
-      if (isValidAsConstant && result.isConstant) {
-        parts.add(result.constant);
-      } else {
-        isValidAsConstant = false;
+      if (result.isConstant) {
+        bool isPartTypeValid = constantChecker.checkConcatenate(
+            constantChecker.createInfo(result));
+        if (isPartTypeValid) {
+          parts.add(result.constant);
+        } else {
+          isValidAsConstant = false;
+        }
       }
     }
 
     resolvePart(node.string);
     for (StringInterpolationPart part in node.parts) {
       resolvePart(part.expression);
       resolvePart(part.string);
     }
-
     if (isValidAsConstant) {
-      ConstantExpression constant = new ConcatenateConstantExpression(parts);
+      constant = new ConcatenateConstantExpression(parts);
+    } else if (constantState.requiresConstant) {
+      constant = new ErroneousConstantExpression();
+    }
+    if (constant != null) {
       registry.setConstant(node, constant);
       return new ConstantResult(node, constant);
     }
     return const NoneResult();
   }
 
   ResolutionResult visitBreakStatement(BreakStatement node) {
     JumpTarget target;
     if (node.target == null) {
       target = statementScope.currentBreakTarget();
@@ skipping 239 matching lines @@
         isConstant: node.isConst,
         isEmpty: node.entries.isEmpty);
     registry.registerRequiredType(mapType, enclosingElement);
     if (node.isConst) {
 
       List<ConstantExpression> keyExpressions = <ConstantExpression>[];
       List<ConstantExpression> valueExpressions = <ConstantExpression>[];
       inConstantContext(() {
         for (LiteralMapEntry entry in node.entries) {
           ResolutionResult keyResult = visit(entry.key);
+          assert(checkConstantInvariant(entry.key, keyResult));
           ResolutionResult valueResult = visit(entry.value);
+          assert(checkConstantInvariant(entry.value, valueResult));
           if (isValidAsConstant &&
               keyResult.isConstant &&
               valueResult.isConstant) {
             keyExpressions.add(keyResult.constant);
             valueExpressions.add(valueResult.constant);
           } else {
             isValidAsConstant = false;
           }
         }
       });
       analyzeConstantDeferred(node);
       sendIsMemberAccess = false;
+      ConstantExpression constant;
       if (isValidAsConstant) {
-        ConstantExpression constant = new MapConstantExpression(
+        constant = new MapConstantExpression(
             mapType, keyExpressions, valueExpressions);
-        registry.setConstant(node, constant);
-        return new ConstantResult(node, constant);
+      } else {
+        constant = new ErroneousConstantExpression();
       }
+      registry.setConstant(node, constant);
+      return new ConstantResult(node, constant);
     } else {
       node.visitChildren(this);
       sendIsMemberAccess = false;
     }
     return const NoneResult();
   }
 
   ResolutionResult visitLiteralMapEntry(LiteralMapEntry node) {
     node.visitChildren(this);
     return const NoneResult();
@@ skipping 279 matching lines @@
     }
     return const NoneResult();
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(DiagnosticReporter reporter, Node node,
                       Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), reporter, node);
 }
+
+class ConstantNodeChecker extends ConstantTypeChecker<Spannable> {
+  final Compiler compiler;
+  final bool constantIsRequired;
+
+  ConstantNodeChecker(this.compiler, {this.constantIsRequired});
+
+  @override
+  bool get allowUnknown => constantIsRequired;
+
+  @override
+  CoreTypes get coreTypes => compiler.coreTypes;
+
+  @override
+  bool get isRequired => constantIsRequired;
+
+  @override
+  void reportError(Spannable position, MessageKind messageKind, Map arguments) {
+    if (constantIsRequired) {
+      compiler.reporter.reportErrorMessage(position, messageKind, arguments);
+    }
+  }
+
+  ConstantTypeInfo createInfo(ResolutionResult result) {
+    if (result == null) return null;
+    return new NodeConstantTypeInfo(
+        result.node, result.constant, result.constant.getKnownType(coreTypes));
+  }
+}
+
+class NodeConstantTypeInfo implements ConstantTypeInfo<Spannable> {
+  final Spannable position;
+  final ConstantExpression constant;
+  final DartType type;
+
+  NodeConstantTypeInfo(this.position, this.constant, this.type);
+
+  String toString() {
+    return 'NodeConstantTypeInfo['
+               'position=$position,constant=${constant.getText()},type=$type]';
+  }
+}