Begin to 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.
 
 part of resolution;
 
 /**
  * Core implementation of resolution.
  *
  * Do not subclass or instantiate this class outside this library
@@ skipping 84 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,
       super(compiler, registry);
 
+  CoreTypes get coreTypes => compiler.coreTypes;
+
   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 44 matching lines @@
     return result;
   }
 
   doInPromotionScope(Node node, action()) {
     promotionScope = promotionScope.prepend(node);
     var result = action();
     promotionScope = promotionScope.tail;
     return result;
   }
 
-  visitInStaticContext(Node node) {
-    inStaticContext(() => visit(node));
+  ResolutionResult visitInStaticContext(Node node) {
+    return inStaticContext(() => visit(node));
   }
 
   ErroneousElement reportAndCreateErroneousElement(
       Node node,
       String name,
       MessageKind kind,
       Map arguments,
       {bool isError: false}) {
     if (isError) {
       compiler.reportError(node, kind, arguments);
@@ skipping 42 matching lines @@
     registry.registerThrowNoSuchMethod();
     return reportAndCreateErroneousElement(
         node, name, kind, arguments, isError: inInitializer);
   }
 
   ResolutionResult visitIdentifier(Identifier node) {
     if (node.isThis()) {
       if (!inInstanceContext) {
         error(node, MessageKind.NO_INSTANCE_AVAILABLE, {'name': node});
       }
-      return null;
+      return const NoneResult();
     } else if (node.isSuper()) {
       if (!inInstanceContext) {
         error(node, MessageKind.NO_SUPER_IN_STATIC);
       }
       if ((ElementCategory.SUPER & allowedCategory) == 0) {
         error(node, MessageKind.INVALID_USE_OF_SUPER);
       }
-      return null;
+      return const NoneResult();
     } else {
       String name = node.source;
       Element element = lookupInScope(compiler, node, scope, name);
       if (Elements.isUnresolved(element) && name == 'dynamic') {
         // TODO(johnniwinther): Remove this hack when we can return more complex
         // objects than [Element] from this method.
         element = compiler.typeClass;
         // Set the type to be `dynamic` to mark that this is a type literal.
         registry.setType(node, const DynamicType());
       }
@@ skipping 13 matching lines @@
         }
       }
       if (!Elements.isUnresolved(element) && element.isClass) {
         ClassElement classElement = element;
         classElement.ensureResolved(compiler);
       }
       return new ElementResult(registry.useElement(node, element));
     }
   }
 
-  ResolutionResult visitTypeAnnotation(TypeAnnotation node) {
+  TypeResult visitTypeAnnotation(TypeAnnotation node) {
     DartType type = resolveTypeAnnotation(node);
     if (inCheckContext) {
       registry.registerIsCheck(type);
     }
     return new TypeResult(type);
   }
 
   bool isNamedConstructor(Send node) => node.receiver != null;
 
   Selector getRedirectingThisOrSuperConstructorSelector(Send node) {
@@ skipping 65 matching lines @@
             compiler.resolver.constantCompiler.compileConstant(parameter);
       });
     });
     if (inCheckContext) {
       functionParameters.forEachParameter((ParameterElement element) {
         registry.registerIsCheck(element.type);
       });
     }
   }
 
-  visitCascade(Cascade node) {
+  ResolutionResult visitCascade(Cascade node) {
     visit(node.expression);
+    return const NoneResult();
   }
 
-  visitCascadeReceiver(CascadeReceiver node) {
+  ResolutionResult visitCascadeReceiver(CascadeReceiver node) {
     visit(node.expression);
+    return const NoneResult();
   }
 
-  visitClassNode(ClassNode node) {
-    internalError(node, "shouldn't be called");
-  }
-
-  visitIn(Node node, Scope nestedScope) {
+  ResolutionResult visitIn(Node node, Scope nestedScope) {
     Scope oldScope = scope;
     scope = nestedScope;
     ResolutionResult result = visit(node);
     scope = oldScope;
     return result;
   }
 
   /**
    * Introduces new default targets for break and continue
    * before visiting the body of the loop
    */
-  visitLoopBodyIn(Loop loop, Node body, Scope bodyScope) {
+  void visitLoopBodyIn(Loop loop, Node body, Scope bodyScope) {
     JumpTarget element = getOrDefineTarget(loop);
     statementScope.enterLoop(element);
     visitIn(body, bodyScope);
     statementScope.exitLoop();
     if (!element.isTarget) {
       registry.undefineTarget(loop);
     }
   }
 
-  visitBlock(Block node) {
+  ResolutionResult visitBlock(Block node) {
     visitIn(node.statements, new BlockScope(scope));
+    return const NoneResult();
   }
 
-  visitDoWhile(DoWhile node) {
+  ResolutionResult visitDoWhile(DoWhile node) {
     visitLoopBodyIn(node, node.body, new BlockScope(scope));
     visit(node.condition);
+    return const NoneResult();
   }
 
-  visitEmptyStatement(EmptyStatement node) { }
+  ResolutionResult visitEmptyStatement(EmptyStatement node) {
+    return const NoneResult();
+  }
 
-  visitExpressionStatement(ExpressionStatement node) {
+  ResolutionResult visitExpressionStatement(ExpressionStatement node) {
     ExpressionStatement oldExpressionStatement = currentExpressionStatement;
     currentExpressionStatement = node;
     visit(node.expression);
     currentExpressionStatement = oldExpressionStatement;
+    return const NoneResult();
   }
 
-  visitFor(For node) {
+  ResolutionResult visitFor(For node) {
     Scope blockScope = new BlockScope(scope);
     visitIn(node.initializer, blockScope);
     visitIn(node.condition, blockScope);
     visitIn(node.update, blockScope);
     visitLoopBodyIn(node, node.body, blockScope);
+    return const NoneResult();
   }
 
-  visitFunctionDeclaration(FunctionDeclaration node) {
+  ResolutionResult visitFunctionDeclaration(FunctionDeclaration node) {
     assert(node.function.name != null);
     visitFunctionExpression(node.function, inFunctionDeclaration: true);
+    return const NoneResult();
   }
 
 
   /// Process a local function declaration or an anonymous function expression.
   ///
   /// [inFunctionDeclaration] is `true` when the current node is the immediate
   /// child of a function declaration.
   ///
   /// This is used to distinguish local function declarations from anonymous
   /// function expressions.
-  visitFunctionExpression(FunctionExpression node,
-                          {bool inFunctionDeclaration: false}) {
+  ResolutionResult visitFunctionExpression(
+      FunctionExpression node,
+      {bool inFunctionDeclaration: false}) {
     bool doAddToScope = inFunctionDeclaration;
     if (!inFunctionDeclaration && node.name != null) {
       compiler.reportError(
           node.name,
           MessageKind.NAMED_FUNCTION_EXPRESSION,
           {'name': node.name});
     }
     visit(node.returnType);
     String name;
     if (node.name == null) {
@@ skipping 27 matching lines @@
     StatementScope oldStatementScope = statementScope;
     statementScope = new StatementScope();
     visit(node.body);
     statementScope = oldStatementScope;
 
     scope = oldScope;
     enclosingElement = previousEnclosingElement;
 
     registry.registerClosure(function);
     registry.registerInstantiatedClass(compiler.functionClass);
+    return const NoneResult();
   }
 
-  visitIf(If node) {
+  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();
   }
 
   ResolutionResult resolveSend(Send node) {
     Selector selector = resolveSelector(node, null);
     if (node.isSuperCall) registry.registerSuperUse(node);
 
     if (node.receiver == null) {
       // If this send is of the form "assert(expr);", then
       // this is an assertion.
       if (selector.isAssert) {
@@ skipping 26 matching lines @@
     }
 
     allowedCategory = oldCategory;
 
     Element target;
     String name = node.selector.asIdentifier().source;
     if (identical(name, 'this')) {
       // TODO(ahe): Why is this using GENERIC?
       error(node.selector, MessageKind.GENERIC,
             {'text': "expected an identifier"});
-      return null;
+      return const NoneResult();
     } else if (node.isSuperCall) {
       if (node.isOperator) {
         if (isUserDefinableOperator(name)) {
           name = selector.name;
         } else {
           error(node.selector, MessageKind.ILLEGAL_SUPER_SEND, {'name': name});
-          return null;
+          return const NoneResult();
         }
       }
       if (!inInstanceContext) {
         error(node.receiver, MessageKind.NO_INSTANCE_AVAILABLE, {'name': name});
-        return null;
+        return const NoneResult();
       }
       if (currentClass.supertype == null) {
         // This is just to guard against internal errors, so no need
         // for a real error message.
         error(node.receiver, MessageKind.GENERIC,
               {'text': "Object has no superclass"});
-        return null;
+        return const NoneResult();
       }
       // TODO(johnniwinther): Ensure correct behavior if currentClass is a
       // patch.
       target = currentClass.lookupSuperByName(selector.memberName);
       // [target] may be null which means invoking noSuchMethod on
       // super.
       if (target == null) {
         target = reportAndCreateErroneousElement(
             node, name, MessageKind.NO_SUCH_SUPER_MEMBER,
             {'className': currentClass.name, 'memberName': name});
         // We still need to register the invocation, because we might
         // call [:super.noSuchMethod:] which calls
         // [JSInvocationMirror._invokeOn].
         registry.registerDynamicInvocation(selector);
         registry.registerSuperNoSuchMethod();
       }
-    } else if (resolvedReceiver == null ||
-               Elements.isUnresolved(resolvedReceiver.element)) {
-      return null;
+    } else if (Elements.isUnresolved(resolvedReceiver.element)) {
+      return const NoneResult();
     } else if (resolvedReceiver.element.isClass) {
       ClassElement receiverClass = resolvedReceiver.element;
       receiverClass.ensureResolved(compiler);
       if (node.isOperator) {
         // When the resolved receiver is a class, we can have two cases:
         //  1) a static send: C.foo, or
         //  2) an operator send, where the receiver is a class literal: 'C + 1'.
         // The following code that looks up the selector on the resolved
         // receiver will treat the second as the invocation of a static operator
         // if the resolved receiver is not null.
-        return null;
+        return const NoneResult();
       }
       MembersCreator.computeClassMembersByName(
           compiler, receiverClass.declaration, name);
       target = receiverClass.lookupLocalMember(name);
       if (target == null || target.isInstanceMember) {
         registry.registerThrowNoSuchMethod();
         // TODO(johnniwinther): With the simplified [TreeElements] invariant,
         // try to resolve injected elements if [currentClass] is in the patch
         // library of [receiverClass].
 
@@ skipping 27 matching lines @@
         AmbiguousElement ambiguous = target;
         target = reportAndCreateErroneousElement(
             node, name, ambiguous.messageKind, ambiguous.messageArguments);
         ambiguous.diagnose(enclosingElement, compiler);
         return new ElementResult(target);
       } else if (target.kind == ElementKind.CLASS) {
         ClassElement classElement = target;
         classElement.ensureResolved(compiler);
       }
     }
-    return new ElementResult(target);
+    return new ResolutionResult.forElement(target);
   }
 
   static Selector computeSendSelector(Send node,
                                       LibraryElement library,
                                       Element element) {
     // First determine if this is part of an assignment.
     bool isSet = node.asSendSet() != null;
 
     if (node.isIndex) {
       return isSet ? new Selector.indexSet() : new Selector.index();
@@ skipping 246 matching lines @@
       type = resolveTypeAnnotation(typeNode);
       sendStructure = new IsNotStructure(type);
     } else {
       // `e is T`.
       Node typeNode = node.arguments.head;
       type = resolveTypeAnnotation(typeNode);
       sendStructure = new IsStructure(type);
     }
     registry.registerIsCheck(type);
     registry.registerSendStructure(node, sendStructure);
-    return null;
+    return const NoneResult();
   }
 
   /// Handle a type cast expression, like `a as T`.
   ResolutionResult handleAs(Send node) {
     Node expression = node.receiver;
     visitExpression(expression);
 
     Node typeNode = node.arguments.head;
     DartType type = resolveTypeAnnotation(typeNode);
     registry.registerAsCheck(type);
     registry.registerSendStructure(node, new AsStructure(type));
-    return null;
+    return const NoneResult();
   }
 
   /// Handle the unary expression of an unresolved unary operator [text], like
   /// the no longer supported `+a`.
   ResolutionResult handleUnresolvedUnary(Send node, String text) {
     Node expression = node.receiver;
     if (node.isSuperCall) {
       checkSuperAccess(node);
     } else {
       visitExpression(expression);
     }
 
     registry.registerSendStructure(node, const InvalidUnaryStructure());
-    return null;
+    return const NoneResult();
   }
 
   /// Handle the unary expression of a user definable unary [operator], like
   /// `-a`, and `-super`.
   ResolutionResult handleUserDefinableUnary(Send node, UnaryOperator operator) {
+    ResolutionResult result = const NoneResult();
     Node expression = node.receiver;
     Selector selector = operator.selector;
     // TODO(johnniwinther): Remove this when all information goes through the
     // [SendStructure].
     registry.setSelector(node, selector);
 
     AccessSemantics semantics;
     if (node.isSuperCall) {
       if (checkSuperAccess(node)) {
         semantics = computeSuperSemantics(node, selector);
         // TODO(johnniwinther): Add information to [AccessSemantics] about
         // whether it is erroneous.
         if (semantics.kind == AccessKind.SUPER_METHOD) {
           registry.registerStaticUse(semantics.element.declaration);
         }
         // TODO(johnniwinther): Remove this when all information goes through
         // the [SendStructure].
         registry.useElement(node, semantics.element);
       }
     } else {
-      visitExpression(expression);
+      ResolutionResult expressionResult = visitExpression(expression);
       semantics = new DynamicAccess.dynamicProperty(expression);
       registry.registerDynamicInvocation(selector);
+
+      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:
+            internalError(node,
+                "Unexpected user definable unary operator: $operator");
+        }
+        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 (semantics != null) {
       // TODO(johnniwinther): Support invalid super access as an
       // [AccessSemantics].
       registry.registerSendStructure(node,
           new UnaryStructure(semantics, operator));
     }
-    return null;
+    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;
-    visitExpression(expression);
+    ResolutionResult result = visitExpression(expression);
     registry.registerSendStructure(node,
         new NotStructure(new DynamicAccess.dynamicProperty(expression)));
-    return null;
+
+    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);
+      }
+    }
+
+    return const NoneResult();
   }
 
   /// Handle a logical and expression, like `a && b`.
   ResolutionResult handleLogicalAnd(Send node) {
     Node left = node.receiver;
     Node right = node.arguments.head;
-    doInPromotionScope(left, () => visitExpression(left));
-    doInPromotionScope(right, () => visitExpression(right));
+    ResolutionResult leftResult =
+        doInPromotionScope(left, () => visitExpression(left));
+    ResolutionResult rightResult =
+        doInPromotionScope(right, () => visitExpression(right));
     registry.registerSendStructure(node, const LogicalAndStructure());
-    return null;
+
+    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,
+            BinaryOperator.LOGICAL_AND,
+            rightConstant);
+        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;
-    visitExpression(left);
-    visitExpression(right);
+    ResolutionResult leftResult = visitExpression(left);
+    ResolutionResult rightResult = visitExpression(right);
     registry.registerSendStructure(node, const LogicalOrStructure());
-    return null;
+
+    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,
+            BinaryOperator.LOGICAL_OR,
+            rightConstant);
+        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 null;
+    return const NoneResult();
   }
 
   /// 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 {
       visitExpression(left);
     }
     visitExpression(right);
     registry.registerSendStructure(node, const InvalidBinaryStructure());
-    return null;
+    return const NoneResult();
   }
 
   /// Handle the binary expression of a user definable binary [operator], like
   /// `a + b`, `super + b`, `a == b` and `a != b`.
   ResolutionResult handleUserDefinableBinary(Send node,
                                              BinaryOperator operator) {
+    ResolutionResult result = const NoneResult();
     Node left = node.receiver;
     Node right = node.arguments.head;
     AccessSemantics semantics;
     Selector selector;
     if (operator.kind == BinaryOperatorKind.INDEX) {
       selector = new Selector.index();
     } else {
       selector = new Selector.binaryOperator(operator.selectorName);
     }
     // TODO(johnniwinther): Remove this when all information goes through the
     // [SendStructure].
     registry.setSelector(node, selector);
 
     if (node.isSuperCall) {
       if (checkSuperAccess(node)) {
         semantics = computeSuperSemantics(node, selector);
         // TODO(johnniwinther): Add information to [AccessSemantics] about
         // whether it is erroneous.
         if (semantics.kind == AccessKind.SUPER_METHOD) {
           registry.registerStaticUse(semantics.element.declaration);
         }
         // TODO(johnniwinther): Remove this when all information goes through
         // the [SendStructure].
         registry.useElement(node, semantics.element);
       }
+      visitExpression(right);
     } else {
-      visitExpression(left);
+      ResolutionResult leftResult = visitExpression(left);
+      ResolutionResult rightResult = visitExpression(right);
       registry.registerDynamicInvocation(selector);
       semantics = new DynamicAccess.dynamicProperty(left);
+
+      if (leftResult.isConstant && rightResult.isConstant) {
+        bool isValidConstant;
+        ConstantExpression leftConstant = leftResult.constant;
+        ConstantExpression rightConstant = leftResult.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:
+            internalError(node, "Unexpected binary operator '${operator}'.");
+            break;
+        }
+        if (isValidConstant) {
+          // TODO(johnniwinther): Handle potentially invalid constant
+          // expressions.
+          ConstantExpression constant = new BinaryConstantExpression(
+              leftResult.constant,
+              operator,
+              rightResult.constant);
+          registry.setConstant(node, constant);
+          result = new ConstantResult(node, constant);
+        }
+      }
     }
-    visitExpression(right);
 
     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;
         case BinaryOperatorKind.NOT_EQ:
@@ skipping 20 matching lines @@
           sendStructure = new BinaryStructure(semantics, operator);
           break;
         case BinaryOperatorKind.LOGICAL_AND:
         case BinaryOperatorKind.LOGICAL_OR:
         case BinaryOperatorKind.IF_NULL:
           internalError(node, "Unexpected binary operator '${operator}'.");
           break;
       }
       registry.registerSendStructure(node, sendStructure);
     }
-    return null;
+    return result;
   }
 
   /// Handle an invocation of an expression, like `(){}()` or `(foo)()`.
   ResolutionResult handleExpressionInvoke(Send node) {
     assert(invariant(node, node.isCall,
         message: "Unexpected expression: $node"));
     Node expression = node.selector;
     visitExpression(expression);
     CallStructure callStructure = resolveArguments(node.argumentsNode);
     Selector selector = callStructure.callSelector;
     // TODO(johnniwinther): Remove this when all information goes through the
     // [SendStructure].
     registry.setSelector(node, selector);
     registry.registerDynamicInvocation(selector);
     registry.registerSendStructure(node,
         new InvokeStructure(new AccessSemantics.expression(), selector));
-    return null;
+    return const NoneResult();
   }
 
   /// Handle a, possibly invalid, assertion, like `assert(cond)` or `assert()`.
   ResolutionResult handleAssert(Send node) {
     assert(invariant(node, node.isCall,
         message: "Unexpected assert: $node"));
     // If this send is of the form "assert(expr);", then
     // this is an assertion.
 
     CallStructure callStructure = resolveArguments(node.argumentsNode);
@@ skipping 31 matching lines @@
       assert(invariant(node, node.isPropertyAccess));
       selector = new Selector(
           SelectorKind.GETTER, name, CallStructure.NO_ARGS);
       registry.registerDynamicGetter(selector);
       sendStructure = new GetStructure(accessSemantics, selector);
     }
     registry.registerSendStructure(node, sendStructure);
     // TODO(johnniwinther): Remove this when all information goes through
     // the [SendStructure].
     registry.setSelector(node, selector);
-    return null;
+    return const NoneResult();
   }
 
   /// Handle access on `this`, like `this()` and `this` when it is parsed as a
   /// [Send] node.
   ResolutionResult handleThisAccess(Send node) {
     AccessSemantics accessSemantics = new AccessSemantics.thisAccess();
     if (node.isCall) {
       CallStructure callStructure = resolveArguments(node.argumentsNode);
       Selector selector = callStructure.callSelector;
       // TODO(johnniwinther): Handle invalid this access as an
       // [AccessSemantics].
       if (checkThisAccess(node)) {
         registry.registerDynamicInvocation(selector);
         registry.registerSendStructure(node,
             new InvokeStructure(accessSemantics, selector));
       }
       // TODO(johnniwinther): Remove this when all information goes through
       // the [SendStructure].
       registry.setSelector(node, selector);
     } else {
       // TODO(johnniwinther): Handle get of `this` when it is a [Send] node.
       internalError(node, "Unexpected node '$node'.");
     }
-    return null;
+    return const NoneResult();
   }
 
   /// Handle access of a super property, like `super.foo` and `super.foo()`.
   ResolutionResult handleSuperPropertyAccess(Send node, Name name) {
     Element target;
     Selector selector;
     CallStructure callStructure = CallStructure.NO_ARGS;
     if (node.isCall) {
       callStructure = resolveArguments(node.argumentsNode);
       selector = new Selector(SelectorKind.CALL, name, callStructure);
@@ skipping 58 matching lines @@
         registry.registerSendStructure(node,
             new GetStructure(semantics, selector));
       }
       target = semantics.element;
     }
 
     // TODO(johnniwinther): Remove these when all information goes through
     // the [SendStructure].
     registry.useElement(node, target);
     registry.setSelector(node, selector);
-    return null;
+    return const NoneResult();
   }
 
   /// Handle a [Send] whose selector is an [Operator], like `a && b`, `a is T`,
   /// `a + b`, and `~a`.
   ResolutionResult handleOperatorSend(Send node) {
     String operatorText = node.selector.asOperator().source;
     if (operatorText == 'is') {
       return handleIs(node);
     } else if (operatorText  == 'as') {
       return handleAs(node);
@@ skipping 55 matching lines @@
     Identifier selector = node.selector.asIdentifier();
     Name name = new Name(selector.source, enclosingElement.library);
     if (node.isSuperCall) {
       return handleSuperPropertyAccess(node, name);
     } else if (node.receiver.isThis()) {
       if (checkThisAccess(node)) {
         return handleThisPropertyAccess(node, name);
       }
       // TODO(johnniwinther): Handle invalid this access as an
       // [AccessSemantics].
-      return null;
+      return const NoneResult();
     }
     // TODO(johnniwinther): Handle remaining qualified sends.
     return oldVisitSend(node);
   }
 
   /// Handle access unresolved access to [name] in a non-instance context.
   ResolutionResult handleUnresolvedAccess(
         Send node, Name name, Element element) {
     // TODO(johnniwinther): Support unresolved top level access as an
     // [AccessSemantics].
@@ skipping 10 matching lines @@
       selector = new Selector(
           SelectorKind.GETTER, name, CallStructure.NO_ARGS);
       registry.registerDynamicGetter(selector);
       sendStructure = new GetStructure(accessSemantics, selector);
     }
     // TODO(johnniwinther): Remove this when all information goes through
     // the [SendStructure].
     registry.setSelector(node, selector);
     registry.useElement(node, element);
     registry.registerSendStructure(node, sendStructure);
-    return null;
+    return const NoneResult();
   }
 
   /// Handle an unqualified [Send], that is where the `node.receiver` is null,
   /// like `a`, `a()`, `this()`, `assert()`, and `(){}()`.
   ResolutionResult handleUnqualifiedSend(Send node) {
     Identifier selector = node.selector.asIdentifier();
     if (selector == null) {
       // `(){}()` and `(foo)()`.
       return handleExpressionInvoke(node);
     }
@@ skipping 36 matching lines @@
     return oldVisitSend(node);
   }
 
   ResolutionResult oldVisitSend(Send node) {
     bool oldSendIsMemberAccess = sendIsMemberAccess;
     sendIsMemberAccess = node.isPropertyAccess || node.isCall;
 
     ResolutionResult result = resolveSend(node);
     sendIsMemberAccess = oldSendIsMemberAccess;
 
-    Element target = result != null ? result.element : null;
+    Element target = result.element;
 
     if (target != null
         && target == compiler.mirrorSystemGetNameFunction
         && !compiler.mirrorUsageAnalyzerTask.hasMirrorUsage(enclosingElement)) {
       compiler.reportHint(
           node.selector, MessageKind.STATIC_FUNCTION_BLOAT,
           {'class': compiler.mirrorSystemClass.name,
            'name': compiler.mirrorSystemGetNameFunction.name});
     }
 
@@ skipping 32 matching lines @@
         }
       }
     }
 
     bool resolvedArguments = false;
     resolveArguments(node.argumentsNode);
 
     // If the selector is null, it means that we will not be generating
     // code for this as a send.
     Selector selector = registry.getSelector(node);
-    if (selector == null) return null;
+    if (selector == null) return const NoneResult();
 
     if (node.isCall) {
       if (Elements.isUnresolved(target) ||
           target.isGetter ||
           target.isField ||
           Elements.isClosureSend(node, target)) {
         // If we don't know what we're calling or if we are calling a getter,
         // we need to register that fact that we may be calling a closure
         // with the same arguments.
         Selector call = new Selector.callClosureFrom(selector);
@@ skipping 32 matching lines @@
           }
         }
       }
     }
 
     registry.useElement(node, target);
     registerSend(selector, target);
     if (node.isPropertyAccess && Elements.isStaticOrTopLevelFunction(target)) {
       registry.registerGetOfStaticFunction(target.declaration);
     }
-    return node.isPropertyAccess ? new ElementResult(target) : null;
+    return node.isPropertyAccess
+        ? new ResolutionResult.forElement(target) : const NoneResult();
   }
 
   /// Callback for native enqueuer to parse a type.  Returns [:null:] on error.
   DartType resolveTypeFromString(Node node, String typeName) {
     Element element = lookupInScope(compiler, node, scope, typeName);
     if (element == null) return null;
     if (element is! ClassElement) return null;
     ClassElement cls = element;
     cls.ensureResolved(compiler);
     return cls.computeType(compiler);
   }
 
   ResolutionResult visitSendSet(SendSet node) {
     bool oldSendIsMemberAccess = sendIsMemberAccess;
     sendIsMemberAccess = node.isPropertyAccess || node.isCall;
     ResolutionResult result = resolveSend(node);
     sendIsMemberAccess = oldSendIsMemberAccess;
-    Element target = result != null ? result.element : null;
+    Element target = result.element;
     Element setter = target;
     Element getter = target;
     String operatorName = node.assignmentOperator.source;
     String source = operatorName;
     bool isComplex = !identical(source, '=');
     if (!(result is AssertResult || Elements.isUnresolved(target))) {
       if (target.isAbstractField) {
         AbstractFieldElement field = target;
         setter = field.setter;
         getter = field.getter;
@@ skipping 103 matching lines @@
         registry.registerInstantiatedClass(compiler.intClass);
       } else if (identical(source, '--')) {
         registerBinaryOperator('-');
         registry.registerInstantiatedClass(compiler.intClass);
       } else if (source.endsWith('=')) {
         registerBinaryOperator(Elements.mapToUserOperator(operatorName));
       }
     }
 
     registerSend(selector, setter);
-    return new ElementResult(registry.useElement(node, setter));
+    return new ResolutionResult.forElement(registry.useElement(node, setter));
   }
 
   void registerSend(Selector selector, Element target) {
     if (target == null || target.isInstanceMember) {
       if (selector.isGetter) {
         registry.registerDynamicGetter(selector);
       } else if (selector.isSetter) {
         registry.registerDynamicSetter(selector);
       } else {
         registry.registerDynamicInvocation(selector);
       }
     } else if (Elements.isStaticOrTopLevel(target)) {
       // Avoid registration of type variables since they are not analyzable but
       // instead resolved through their enclosing type declaration.
       if (!target.isTypeVariable) {
         // [target] might be the implementation element and only declaration
         // elements may be registered.
         registry.registerStaticUse(target.declaration);
       }
     }
   }
 
-  visitLiteralInt(LiteralInt node) {
-    registry.registerInstantiatedClass(compiler.intClass);
+  ConstantResult visitLiteralInt(LiteralInt node) {
+    registry.registerInstantiatedType(coreTypes.intType);
+    ConstantExpression constant = new IntConstantExpression(node.value);
+    registry.setConstant(node, constant);
+    return new ConstantResult(node, constant);
   }
 
-  visitLiteralDouble(LiteralDouble node) {
-    registry.registerInstantiatedClass(compiler.doubleClass);
+  ConstantResult visitLiteralDouble(LiteralDouble node) {
+    registry.registerInstantiatedType(coreTypes.doubleType);
+    ConstantExpression constant = new DoubleConstantExpression(node.value);
+    registry.setConstant(node, constant);
+    return new ConstantResult(node, constant);
   }
 
-  visitLiteralBool(LiteralBool node) {
-    registry.registerInstantiatedClass(compiler.boolClass);
+  ConstantResult visitLiteralBool(LiteralBool node) {
+    registry.registerInstantiatedType(coreTypes.boolType);
+    ConstantExpression constant = new BoolConstantExpression(node.value);
+    registry.setConstant(node, constant);
+    return new ConstantResult(node, constant);
   }
 
-  visitLiteralString(LiteralString node) {
-    registry.registerInstantiatedClass(compiler.stringClass);
+  ResolutionResult visitLiteralString(LiteralString node) {
+    registry.registerInstantiatedType(coreTypes.stringType);
+    if (node.dartString != null) {
+      // [dartString] might be null on parser errors.
+      ConstantExpression constant =
+          new StringConstantExpression(node.dartString.slowToString());
+      registry.setConstant(node, constant);
+      return new ConstantResult(node, constant);
+    }
+    return const NoneResult();
   }
 
-  visitLiteralNull(LiteralNull node) {
-    registry.registerInstantiatedClass(compiler.nullClass);
+  ConstantResult visitLiteralNull(LiteralNull node) {
+    registry.registerInstantiatedType(coreTypes.nullType);
+    ConstantExpression constant = new NullConstantExpression();
+    registry.setConstant(node, constant);
+    return new ConstantResult(node, constant);
   }
 
-  visitLiteralSymbol(LiteralSymbol node) {
+  ConstantResult visitLiteralSymbol(LiteralSymbol node) {
     registry.registerInstantiatedClass(compiler.symbolClass);
     registry.registerStaticUse(compiler.symbolConstructor.declaration);
-    registry.registerConstSymbol(node.slowNameString);
-    if (!validateSymbol(node, node.slowNameString, reportError: false)) {
+    String name = node.slowNameString;
+    registry.registerConstSymbol(name);
+    if (!validateSymbol(node, name, reportError: false)) {
       compiler.reportError(node,
           MessageKind.UNSUPPORTED_LITERAL_SYMBOL,
-          {'value': node.slowNameString});
+          {'value': name});
     }
     analyzeConstantDeferred(node);
+    ConstantExpression constant = new SymbolConstantExpression(name);
+    registry.setConstant(node, constant);
+    return new ConstantResult(node, constant);
   }
 
-  visitStringJuxtaposition(StringJuxtaposition node) {
-    registry.registerInstantiatedClass(compiler.stringClass);
-    node.visitChildren(this);
+  ResolutionResult visitStringJuxtaposition(StringJuxtaposition node) {
+    registry.registerInstantiatedType(coreTypes.stringType);
+    ResolutionResult first = visit(node.first);
+    ResolutionResult second = visit(node.second);
+    if (first.isConstant && second.isConstant) {
+      ConstantExpression constant = new ConcatenateConstantExpression(
+          <ConstantExpression>[first.constant, second.constant]);
+      registry.setConstant(node, constant);
+      return new ConstantResult(node, constant);
+    }
+    return const NoneResult();
   }
 
-  visitNodeList(NodeList node) {
+  ResolutionResult visitNodeList(NodeList node) {
     for (Link<Node> link = node.nodes; !link.isEmpty; link = link.tail) {
       visit(link.head);
     }
+    return const NoneResult();
   }
 
-  visitOperator(Operator node) {
-    internalError(node, 'operator');
-  }
-
-  visitRethrow(Rethrow node) {
+  ResolutionResult visitRethrow(Rethrow node) {
     if (!inCatchBlock) {
       error(node, MessageKind.THROW_WITHOUT_EXPRESSION);
     }
+    return const NoneResult();
   }
 
-  visitReturn(Return node) {
+  ResolutionResult visitReturn(Return node) {
     Node expression = node.expression;
     if (expression != null) {
       if (enclosingElement.isGenerativeConstructor) {
         // It is a compile-time error if a return statement of the form
         // `return e;` appears in a generative constructor.  (Dart Language
         // Specification 13.12.)
         compiler.reportError(expression,
                              MessageKind.CANNOT_RETURN_FROM_CONSTRUCTOR);
       } else if (!node.isArrowBody && currentAsyncMarker.isYielding) {
         compiler.reportError(
             node,
             MessageKind.RETURN_IN_GENERATOR,
             {'modifier': currentAsyncMarker});
       }
     }
     visit(node.expression);
+    return const NoneResult();
   }
 
-  visitYield(Yield node) {
+  ResolutionResult visitYield(Yield node) {
     compiler.streamClass.ensureResolved(compiler);
     compiler.iterableClass.ensureResolved(compiler);
     visit(node.expression);
+    return const NoneResult();
   }
 
-  visitRedirectingFactoryBody(RedirectingFactoryBody node) {
+  ResolutionResult visitRedirectingFactoryBody(RedirectingFactoryBody node) {
     final isSymbolConstructor = enclosingElement == compiler.symbolConstructor;
     if (!enclosingElement.isFactoryConstructor) {
       compiler.reportError(
           node, MessageKind.FACTORY_REDIRECTION_IN_NON_FACTORY);
       compiler.reportHint(
           enclosingElement, MessageKind.MISSING_FACTORY_KEYWORD);
     }
     ConstructorElementX constructor = enclosingElement;
     bool isConstConstructor = constructor.isConst;
     ConstructorElement redirectionTarget = resolveRedirectingFactory(
         node, inConstContext: isConstConstructor);
     constructor.immediateRedirectionTarget = redirectionTarget;
 
     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();
-      return;
+      return const NoneResult();
     } else {
       if (isConstConstructor &&
           !redirectionTarget.isConst) {
         compiler.reportError(node, MessageKind.CONSTRUCTOR_IS_NOT_CONST);
       }
       if (redirectionTarget == constructor) {
         compiler.reportError(node, MessageKind.CYCLIC_REDIRECTING_FACTORY);
       }
     }
 
@@ skipping 25 matching lines @@
       compiler.resolver.resolveRedirectionChain(constructor, node);
     });
 
     registry.registerStaticUse(redirectionTarget);
     // TODO(johnniwinther): Register the effective target type instead.
     registry.registerInstantiatedClass(
         redirectionTarget.enclosingClass.declaration);
     if (isSymbolConstructor) {
       registry.registerSymbolConstructor();
     }
+    return const NoneResult();
   }
 
-  visitThrow(Throw node) {
+  ResolutionResult visitThrow(Throw node) {
     registry.registerThrowExpression();
     visit(node.expression);
+    return const NoneResult();
   }
 
-  visitAwait(Await node) {
+  ResolutionResult visitAwait(Await node) {
     compiler.futureClass.ensureResolved(compiler);
     visit(node.expression);
+    return const NoneResult();
   }
 
-  visitVariableDefinitions(VariableDefinitions node) {
+  ResolutionResult visitVariableDefinitions(VariableDefinitions node) {
     DartType type;
     if (node.type != null) {
       type = resolveTypeAnnotation(node.type);
     } else {
       type = const DynamicType();
     }
     VariableList variables = new VariableList.node(node, type);
     VariableDefinitionsVisitor visitor =
         new VariableDefinitionsVisitor(compiler, node, this, variables);
 
@@ skipping 24 matching lines @@
       }
       if (modifiers.isStatic) {
         reportExtraModifier('static');
       }
     }
     if (node.metadata != null) {
       variables.metadata =
           compiler.resolver.resolveMetadata(enclosingElement, node);
     }
     visitor.visit(node.definitions);
+    return const NoneResult();
   }
 
-  visitWhile(While node) {
+  ResolutionResult visitWhile(While node) {
     visit(node.condition);
     visitLoopBodyIn(node, node.body, new BlockScope(scope));
+    return const NoneResult();
   }
 
-  visitParenthesizedExpression(ParenthesizedExpression node) {
+  ResolutionResult visitParenthesizedExpression(ParenthesizedExpression node) {
     bool oldSendIsMemberAccess = sendIsMemberAccess;
     sendIsMemberAccess = false;
     var oldCategory = allowedCategory;
     allowedCategory = ElementCategory.VARIABLE | ElementCategory.FUNCTION
         | ElementCategory.IMPLIES_TYPE;
-    visit(node.expression);
+    ResolutionResult result = visit(node.expression);
     allowedCategory = oldCategory;
     sendIsMemberAccess = oldSendIsMemberAccess;
+    if (result.kind == ResultKind.CONSTANT) {
+      return result;
+    }
+    return const NoneResult();
   }
 
   ResolutionResult visitNewExpression(NewExpression node) {
     Node selector = node.send.selector;
     FunctionElement constructor = resolveConstructor(node);
     final bool isSymbolConstructor = constructor == compiler.symbolConstructor;
     final bool isMirrorsUsedConstant =
         node.isConst && (constructor == compiler.mirrorsUsedConstructor);
     Selector callSelector = resolveSelector(node.send, constructor);
     resolveArguments(node.send.argumentsNode);
     registry.useElement(node.send, constructor);
     if (Elements.isUnresolved(constructor)) {
-      return new ElementResult(constructor);
+      return new ResolutionResult.forElement(constructor);
     }
     constructor.computeSignature(compiler);
     if (!callSelector.applies(constructor, compiler.world)) {
       registry.registerThrowNoSuchMethod();
     }
 
     // [constructor] might be the implementation element
     // and only declaration elements may be registered.
     registry.registerStaticUse(constructor.declaration);
     ClassElement cls = constructor.enclosingClass;
@@ skipping 17 matching lines @@
     }
 
     if (isSymbolConstructor) {
       if (node.isConst) {
         Node argumentNode = node.send.arguments.head;
         ConstantExpression constant =
             compiler.resolver.constantCompiler.compileNode(
                 argumentNode, registry.mapping);
         ConstantValue name = compiler.constants.getConstantValue(constant);
         if (!name.isString) {
-          DartType type = name.getType(compiler.coreTypes);
+          DartType type = name.getType(coreTypes);
           compiler.reportError(argumentNode, MessageKind.STRING_EXPECTED,
                                    {'type': type});
         } else {
           StringConstantValue stringConstant = name;
           String nameString = stringConstant.toDartString().slowToString();
           if (validateSymbol(argumentNode, nameString)) {
             registry.registerConstSymbol(nameString);
           }
         }
       } else {
         if (!compiler.mirrorUsageAnalyzerTask.hasMirrorUsage(
                 enclosingElement)) {
           compiler.reportHint(
               node.newToken, MessageKind.NON_CONST_BLOAT,
               {'name': compiler.symbolClass.name});
         }
         registry.registerNewSymbol();
       }
     } else if (isMirrorsUsedConstant) {
       compiler.mirrorUsageAnalyzerTask.validate(node, registry.mapping);
     }
     if (node.isConst) {
       analyzeConstantDeferred(node);
     }
 
-    return null;
+    return 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 87 matching lines @@
     DartType type = typeResolver.resolveTypeAnnotation(
         this, node, malformedIsError: malformedIsError,
         deferredIsMalformed: deferredIsMalformed);
     if (inCheckContext) {
       registry.registerIsCheck(type);
       registry.registerRequiredType(type, enclosingElement);
     }
     return type;
   }
 
-  visitModifiers(Modifiers node) {
-    internalError(node, 'modifiers');
-  }
-
-  visitLiteralList(LiteralList node) {
-    bool oldSendIsMemberAccess = sendIsMemberAccess;
+  ResolutionResult visitLiteralList(LiteralList node) {
+    bool isValidAsConstant = true;
     sendIsMemberAccess = false;
 
     NodeList arguments = node.typeArguments;
     DartType typeArgument;
     if (arguments != null) {
       Link<Node> nodes = arguments.nodes;
       if (nodes.isEmpty) {
         // The syntax [: <>[] :] is not allowed.
         error(arguments, MessageKind.MISSING_TYPE_ARGUMENT);
+        isValidAsConstant = false;
       } else {
         typeArgument = resolveTypeAnnotation(nodes.head);
         for (nodes = nodes.tail; !nodes.isEmpty; nodes = nodes.tail) {
           warning(nodes.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT);
           resolveTypeAnnotation(nodes.head);
         }
       }
     }
     DartType listType;
     if (typeArgument != null) {
       if (node.isConst && typeArgument.containsTypeVariables) {
         compiler.reportError(arguments.nodes.head,
             MessageKind.TYPE_VARIABLE_IN_CONSTANT);
+        isValidAsConstant = false;
       }
-      listType = new InterfaceType(compiler.listClass, [typeArgument]);
+      listType = coreTypes.listType(typeArgument);
     } else {
-      compiler.listClass.computeType(compiler);
-      listType = compiler.listClass.rawType;
+      listType = coreTypes.listType();
     }
     registry.setType(node, listType);
     registry.registerInstantiatedType(listType);
     registry.registerRequiredType(listType, enclosingElement);
-    visit(node.elements);
     if (node.isConst) {
+      List<ConstantExpression> constantExpressions = <ConstantExpression>[];
+      for (Node element in node.elements) {
+        ResolutionResult elementResult = visit(element);
+        if (isValidAsConstant && elementResult.isConstant) {
+          constantExpressions.add(elementResult.constant);
+        } else {
+          isValidAsConstant = false;
+        }
+      }
       analyzeConstantDeferred(node);
+      sendIsMemberAccess = false;
+      if (isValidAsConstant) {
+        ConstantExpression constant =
+            new ListConstantExpression(listType, constantExpressions);
+        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));
+    ResolutionResult thenResult =
+        doInPromotionScope(node.thenExpression, () => visit(node.thenExpression));
+    ResolutionResult elseResult = visit(node.elseExpression);
+    if (conditionResult.isConstant &&
+        thenResult.isConstant &&
+        elseResult.isConstant) {
+      ConstantExpression constant = new ConditionalConstantExpression(
+          conditionResult.constant,
+          thenResult.constant,
+          elseResult.constant);
+      registry.setConstant(node, constant);
+      return new ConstantResult(node, constant);
+    }
+    return const NoneResult();
+  }
+
+  ResolutionResult visitStringInterpolation(StringInterpolation node) {
+    registry.registerInstantiatedType(coreTypes.stringType);
+    registry.registerStringInterpolation();
+    registerImplicitInvocation('toString', 0);
+
+    bool isValidAsConstant = true;
+    List<ConstantExpression> parts = <ConstantExpression>[];
+
+    void resolvePart(Node subnode) {
+      ResolutionResult result = visit(subnode);
+      if (isValidAsConstant && result.isConstant) {
+        parts.add(result.constant);
+      } else {
+        isValidAsConstant = false;
+      }
     }
 
-    sendIsMemberAccess = false;
+    resolvePart(node.string);
+    for (StringInterpolationPart part in node.parts) {
+      resolvePart(part.expression);
+      resolvePart(part.string);
+    }
+
+    if (isValidAsConstant) {
+      ConstantExpression constant = new ConcatenateConstantExpression(parts);
+      registry.setConstant(node, constant);
+      return new ConstantResult(node, constant);
+    }
+    return const NoneResult();
   }
 
-  visitConditional(Conditional node) {
-    doInPromotionScope(node.condition, () => visit(node.condition));
-    doInPromotionScope(node.thenExpression, () => visit(node.thenExpression));
-    visit(node.elseExpression);
-  }
-
-  visitStringInterpolation(StringInterpolation node) {
-    registry.registerInstantiatedClass(compiler.stringClass);
-    registry.registerStringInterpolation();
-    node.visitChildren(this);
-  }
-
-  visitStringInterpolationPart(StringInterpolationPart node) {
-    registerImplicitInvocation('toString', 0);
-    node.visitChildren(this);
-  }
-
-  visitBreakStatement(BreakStatement node) {
+  ResolutionResult visitBreakStatement(BreakStatement node) {
     JumpTarget target;
     if (node.target == null) {
       target = statementScope.currentBreakTarget();
       if (target == null) {
         error(node, MessageKind.NO_BREAK_TARGET);
-        return;
+        return const NoneResult();
       }
       target.isBreakTarget = true;
     } else {
       String labelName = node.target.source;
       LabelDefinition label = statementScope.lookupLabel(labelName);
       if (label == null) {
         error(node.target, MessageKind.UNBOUND_LABEL, {'labelName': labelName});
-        return;
+        return const NoneResult();
       }
       target = label.target;
       if (!target.statement.isValidBreakTarget()) {
         error(node.target, MessageKind.INVALID_BREAK);
-        return;
+        return const NoneResult();
       }
       label.setBreakTarget();
       registry.useLabel(node, label);
     }
     registry.registerTargetOf(node, target);
+    return const NoneResult();
   }
 
-  visitContinueStatement(ContinueStatement node) {
+  ResolutionResult visitContinueStatement(ContinueStatement node) {
     JumpTarget target;
     if (node.target == null) {
       target = statementScope.currentContinueTarget();
       if (target == null) {
         error(node, MessageKind.NO_CONTINUE_TARGET);
-        return;
+        return const NoneResult();
       }
       target.isContinueTarget = true;
     } else {
       String labelName = node.target.source;
       LabelDefinition label = statementScope.lookupLabel(labelName);
       if (label == null) {
         error(node.target, MessageKind.UNBOUND_LABEL, {'labelName': labelName});
-        return;
+        return const NoneResult();
       }
       target = label.target;
       if (!target.statement.isValidContinueTarget()) {
         error(node.target, MessageKind.INVALID_CONTINUE);
       }
       label.setContinueTarget();
       registry.useLabel(node, label);
     }
     registry.registerTargetOf(node, target);
+    return const NoneResult();
   }
 
   registerImplicitInvocation(String name, int arity) {
     Selector selector = new Selector.call(name, null, arity);
     registry.registerDynamicInvocation(selector);
   }
 
-  visitAsyncForIn(AsyncForIn node) {
+  ResolutionResult visitAsyncForIn(AsyncForIn node) {
     registry.registerAsyncForIn(node);
     registry.setCurrentSelector(node, compiler.currentSelector);
     registry.registerDynamicGetter(compiler.currentSelector);
     registry.setMoveNextSelector(node, compiler.moveNextSelector);
     registry.registerDynamicInvocation(compiler.moveNextSelector);
 
     visit(node.expression);
 
     Scope blockScope = new BlockScope(scope);
     visitForInDeclaredIdentifierIn(node.declaredIdentifier, node, blockScope);
     visitLoopBodyIn(node, node.body, blockScope);
+    return const NoneResult();
   }
 
-  visitSyncForIn(SyncForIn node) {
+  ResolutionResult visitSyncForIn(SyncForIn node) {
     registry.registerSyncForIn(node);
     registry.setIteratorSelector(node, compiler.iteratorSelector);
     registry.registerDynamicGetter(compiler.iteratorSelector);
     registry.setCurrentSelector(node, compiler.currentSelector);
     registry.registerDynamicGetter(compiler.currentSelector);
     registry.setMoveNextSelector(node, compiler.moveNextSelector);
     registry.registerDynamicInvocation(compiler.moveNextSelector);
 
     visit(node.expression);
 
     Scope blockScope = new BlockScope(scope);
     visitForInDeclaredIdentifierIn(node.declaredIdentifier, node, blockScope);
     visitLoopBodyIn(node, node.body, blockScope);
+    return const NoneResult();
   }
 
-  visitForInDeclaredIdentifierIn(Node declaration, ForIn node,
-                                 Scope blockScope) {
+  void visitForInDeclaredIdentifierIn(
+      Node declaration,
+      ForIn node,
+      Scope blockScope) {
     LibraryElement library = enclosingElement.library;
 
     bool oldAllowFinalWithoutInitializer = allowFinalWithoutInitializer;
     allowFinalWithoutInitializer = true;
     visitIn(declaration, blockScope);
     allowFinalWithoutInitializer = oldAllowFinalWithoutInitializer;
 
     Send send = declaration.asSend();
     VariableDefinitions variableDefinitions =
         declaration.asVariableDefinitions();
@@ skipping 36 matching lines @@
     if (loopVariable != null) {
       // loopVariable may be null if it could not be resolved.
       registry.setForInVariable(node, loopVariable);
     }
   }
 
   visitLabel(Label node) {
     // Labels are handled by their containing statements/cases.
   }
 
-  visitLabeledStatement(LabeledStatement node) {
+  ResolutionResult visitLabeledStatement(LabeledStatement node) {
     Statement body = node.statement;
     JumpTarget targetElement = getOrDefineTarget(body);
     Map<String, LabelDefinition> labelElements = <String, LabelDefinition>{};
     for (Label label in node.labels) {
       String labelName = label.labelName;
       if (labelElements.containsKey(labelName)) continue;
       LabelDefinition element = targetElement.addLabel(label, labelName);
       labelElements[labelName] = element;
     }
     statementScope.enterLabelScope(labelElements);
     visit(node.statement);
     statementScope.exitLabelScope();
     labelElements.forEach((String labelName, LabelDefinition element) {
       if (element.isTarget) {
         registry.defineLabel(element.label, element);
       } else {
         warning(element.label, MessageKind.UNUSED_LABEL,
                 {'labelName': labelName});
       }
     });
     if (!targetElement.isTarget) {
       registry.undefineTarget(body);
     }
+    return const NoneResult();
   }
 
-  visitLiteralMap(LiteralMap node) {
+  ResolutionResult visitLiteralMap(LiteralMap node) {
+    bool isValidAsConstant = true;
     sendIsMemberAccess = false;
 
     NodeList arguments = node.typeArguments;
     DartType keyTypeArgument;
     DartType valueTypeArgument;
     if (arguments != null) {
       Link<Node> nodes = arguments.nodes;
       if (nodes.isEmpty) {
         // The syntax [: <>{} :] is not allowed.
         error(arguments, MessageKind.MISSING_TYPE_ARGUMENT);
+        isValidAsConstant = false;
       } else {
         keyTypeArgument = resolveTypeAnnotation(nodes.head);
         nodes = nodes.tail;
         if (nodes.isEmpty) {
           warning(arguments, MessageKind.MISSING_TYPE_ARGUMENT);
         } else {
           valueTypeArgument = resolveTypeAnnotation(nodes.head);
           for (nodes = nodes.tail; !nodes.isEmpty; nodes = nodes.tail) {
             warning(nodes.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT);
             resolveTypeAnnotation(nodes.head);
           }
         }
       }
     }
     DartType mapType;
     if (valueTypeArgument != null) {
-      mapType = new InterfaceType(compiler.mapClass,
-          [keyTypeArgument, valueTypeArgument]);
+      mapType = coreTypes.mapType(keyTypeArgument, valueTypeArgument);
     } else {
-      compiler.mapClass.computeType(compiler);
-      mapType = compiler.mapClass.rawType;
+      mapType = coreTypes.mapType();
     }
     if (node.isConst && mapType.containsTypeVariables) {
       compiler.reportError(arguments,
           MessageKind.TYPE_VARIABLE_IN_CONSTANT);
+      isValidAsConstant = false;
     }
     registry.registerMapLiteral(node, mapType, node.isConst);
     registry.registerRequiredType(mapType, enclosingElement);
-    node.visitChildren(this);
     if (node.isConst) {
+      List<ConstantExpression> keyExpressions = <ConstantExpression>[];
+      List<ConstantExpression> valueExpressions = <ConstantExpression>[];
+      for (LiteralMapEntry entry in node.entries) {
+        ResolutionResult keyResult = visit(entry.key);
+        ResolutionResult valueResult = visit(entry.value);
+        if (isValidAsConstant &&
+            keyResult.isConstant &&
+            valueResult.isConstant) {
+          keyExpressions.add(keyResult.constant);
+          valueExpressions.add(valueResult.constant);
+        } else {
+          isValidAsConstant = false;
+        }
+      }
       analyzeConstantDeferred(node);
+      sendIsMemberAccess = false;
+      if (isValidAsConstant) {
+        ConstantExpression constant = new MapConstantExpression(
+            mapType, keyExpressions, valueExpressions);
+        registry.setConstant(node, constant);
+        return new ConstantResult(node, constant);
+      }
+    } else {
+      node.visitChildren(this);
+      sendIsMemberAccess = false;
     }
-
-    sendIsMemberAccess = false;
+    return const NoneResult();
   }
 
-  visitLiteralMapEntry(LiteralMapEntry node) {
+  ResolutionResult visitLiteralMapEntry(LiteralMapEntry node) {
     node.visitChildren(this);
+    return const NoneResult();
   }
 
-  visitNamedArgument(NamedArgument node) {
-    visit(node.expression);
+  ResolutionResult visitNamedArgument(NamedArgument node) {
+    return visit(node.expression);
   }
 
   DartType typeOfConstant(ConstantValue constant) {
     if (constant.isInt) return compiler.intClass.rawType;
     if (constant.isBool) return compiler.boolClass.rawType;
     if (constant.isDouble) return compiler.doubleClass.rawType;
     if (constant.isString) return compiler.stringClass.rawType;
     if (constant.isNull) return compiler.nullClass.rawType;
     if (constant.isFunction) return compiler.functionClass.rawType;
     assert(constant.isObject);
@@ skipping 64 matching lines @@
             compiler.reportInfo(
                 caseMatch.expression,
                 MessageKind.SWITCH_CASE_TYPES_NOT_EQUAL_CASE,
                 {'type': caseType});
           }
         }
       }
     }
   }
 
-  visitSwitchStatement(SwitchStatement node) {
+  ResolutionResult visitSwitchStatement(SwitchStatement node) {
     node.expression.accept(this);
 
     JumpTarget breakElement = getOrDefineTarget(node);
     Map<String, LabelDefinition> continueLabels = <String, LabelDefinition>{};
     Link<Node> cases = node.cases.nodes;
     while (!cases.isEmpty) {
       SwitchCase switchCase = cases.head;
       for (Node labelOrCase in switchCase.labelsAndCases) {
         CaseMatch caseMatch = labelOrCase.asCaseMatch();
         if (caseMatch != null) {
@@ skipping 50 matching lines @@
       if (!label.isContinueTarget) {
         JumpTarget targetElement = label.target;
         SwitchCase switchCase = targetElement.statement;
         registry.undefineTarget(switchCase);
         registry.undefineLabel(label.label);
       }
     });
     // TODO(15575): We should warn if we can detect a fall through
     // error.
     registry.registerFallThroughError();
+    return const NoneResult();
   }
 
-  visitSwitchCase(SwitchCase node) {
+  ResolutionResult visitSwitchCase(SwitchCase node) {
     node.labelsAndCases.accept(this);
     visitIn(node.statements, new BlockScope(scope));
+    return const NoneResult();
   }
 
-  visitCaseMatch(CaseMatch node) {
+  ResolutionResult visitCaseMatch(CaseMatch node) {
     visit(node.expression);
+    return const NoneResult();
   }
 
-  visitTryStatement(TryStatement node) {
+  ResolutionResult visitTryStatement(TryStatement node) {
     visit(node.tryBlock);
     if (node.catchBlocks.isEmpty && node.finallyBlock == null) {
       error(node.getEndToken().next, MessageKind.NO_CATCH_NOR_FINALLY);
     }
     visit(node.catchBlocks);
     visit(node.finallyBlock);
+    return const NoneResult();
   }
 
-  visitCatchBlock(CatchBlock node) {
+  ResolutionResult visitCatchBlock(CatchBlock node) {
     registry.registerCatchStatement();
     // Check that if catch part is present, then
     // it has one or two formal parameters.
     VariableDefinitions exceptionDefinition;
     VariableDefinitions stackTraceDefinition;
     if (node.formals != null) {
       Link<Node> formalsToProcess = node.formals.nodes;
       if (formalsToProcess.isEmpty) {
         error(node, MessageKind.EMPTY_CATCH_DECLARATION);
       } else {
@@ skipping 49 matching lines @@
           registry.getDefinition(exceptionVariable);
       exceptionElement.variables.type = exceptionType;
     }
     if (stackTraceDefinition != null) {
       Node stackTraceVariable = stackTraceDefinition.definitions.nodes.head;
       VariableElementX stackTraceElement =
           registry.getDefinition(stackTraceVariable);
       registry.registerInstantiatedClass(compiler.stackTraceClass);
       stackTraceElement.variables.type = compiler.stackTraceClass.rawType;
     }
-  }
-
-  visitTypedef(Typedef node) {
-    internalError(node, 'typedef');
+    return const NoneResult();
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(Compiler compiler, Node node,
                       Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), compiler, node);
 }