diff --git a/pkg/dev_compiler/lib/src/kernel/constants.dart b/pkg/dev_compiler/lib/src/kernel/constants.dart
index a59d0bd..7f550cb 100644
--- a/pkg/dev_compiler/lib/src/kernel/constants.dart
+++ b/pkg/dev_compiler/lib/src/kernel/constants.dart
@@ -170,5 +170,5 @@
 
   // Ignore reported errors.
   @override
-  report(context, message, node) => message;
+  reportMessage(Uri uri, int offset, String message) {}
 }
diff --git a/pkg/front_end/lib/src/api_unstable/vm.dart b/pkg/front_end/lib/src/api_unstable/vm.dart
index e3ef443..20ad6ad 100644
--- a/pkg/front_end/lib/src/api_unstable/vm.dart
+++ b/pkg/front_end/lib/src/api_unstable/vm.dart
@@ -34,25 +34,6 @@
 export '../fasta/fasta_codes.dart'
     show
         LocatedMessage,
-        Message,
-        messageConstEvalCircularity,
-        messageConstEvalContext,
-        messageConstEvalFailedAssertion,
-        noLength,
-        templateConstEvalFreeTypeParameter,
-        templateConstEvalDeferredLibrary,
-        templateConstEvalDuplicateKey,
-        templateConstEvalFailedAssertionWithMessage,
-        templateConstEvalInvalidBinaryOperandType,
-        templateConstEvalInvalidMethodInvocation,
-        templateConstEvalInvalidStaticInvocation,
-        templateConstEvalInvalidStringInterpolationOperand,
-        templateConstEvalInvalidSymbolName,
-        templateConstEvalInvalidType,
-        templateConstEvalNegativeShift,
-        templateConstEvalNonConstantLiteral,
-        templateConstEvalNonConstantVariableGet,
-        templateConstEvalZeroDivisor,
         templateFfiFieldAnnotation,
         templateFfiStructAnnotation,
         templateFfiNotStatic,
diff --git a/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart b/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart
index ac5cd3b..df58f84 100644
--- a/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart
@@ -32,6 +32,29 @@
 
 import 'package:kernel/target/targets.dart';
 
+import '../fasta_codes.dart'
+    show
+        LocatedMessage,
+        Message,
+        messageConstEvalCircularity,
+        messageConstEvalContext,
+        messageConstEvalFailedAssertion,
+        noLength,
+        templateConstEvalDeferredLibrary,
+        templateConstEvalDuplicateKey,
+        templateConstEvalFailedAssertionWithMessage,
+        templateConstEvalFreeTypeParameter,
+        templateConstEvalInvalidType,
+        templateConstEvalInvalidBinaryOperandType,
+        templateConstEvalInvalidMethodInvocation,
+        templateConstEvalInvalidStaticInvocation,
+        templateConstEvalInvalidStringInterpolationOperand,
+        templateConstEvalInvalidSymbolName,
+        templateConstEvalNegativeShift,
+        templateConstEvalNonConstantLiteral,
+        templateConstEvalNonConstantVariableGet,
+        templateConstEvalZeroDivisor;
+
 Component transformComponent(Component component, ConstantsBackend backend,
     Map<String, String> environmentDefines, ErrorReporter errorReporter,
     {bool keepFields: false,
@@ -411,6 +434,21 @@
         nodeCache = <Node, Constant>{},
         env = new EvaluationEnvironment();
 
+  Uri getFileUri(TreeNode node) {
+    while (node != null && node is! FileUriNode) {
+      node = node.parent;
+    }
+    return (node as FileUriNode)?.fileUri;
+  }
+
+  int getFileOffset(Uri uri, TreeNode node) {
+    if (uri == null) return TreeNode.noOffset;
+    while (node != null && node.fileOffset == TreeNode.noOffset) {
+      node = node.parent;
+    }
+    return node == null ? TreeNode.noOffset : node.fileOffset;
+  }
+
   /// Evaluate [node] and possibly cache the evaluation result.
   /// Returns UnevaluatedConstant if the constant could not be evaluated.
   /// If the expression in the UnevaluatedConstant is an InvalidExpression,
@@ -419,8 +457,24 @@
     evaluationRoot = node;
     try {
       return _evaluateSubexpression(node);
-    } on _AbortCurrentEvaluation catch (e) {
-      return new UnevaluatedConstant(new InvalidExpression(e.message));
+    } on _AbortDueToError catch (e) {
+      final Uri uri = getFileUri(e.node);
+      final int fileOffset = getFileOffset(uri, e.node);
+      final locatedMessage = e.message.withLocation(uri, fileOffset, noLength);
+
+      final contextMessages = <LocatedMessage>[];
+      if (e.context != null) contextMessages.addAll(e.context);
+      for (final TreeNode node in contextChain) {
+        final Uri uri = getFileUri(node);
+        final int fileOffset = getFileOffset(uri, node);
+        contextMessages.add(
+            messageConstEvalContext.withLocation(uri, fileOffset, noLength));
+      }
+      errorReporter.report(locatedMessage, contextMessages);
+      return new UnevaluatedConstant(new InvalidExpression(e.message.message));
+    } on _AbortDueToInvalidExpression catch (e) {
+      errorReporter.reportInvalidExpression(e.node);
+      return new UnevaluatedConstant(e.node);
     } finally {
       // Release collections used to keep track of unevaluated nodes.
       evaluationRoot = null;
@@ -429,6 +483,14 @@
     }
   }
 
+  Null report(TreeNode node, Message message, {List<LocatedMessage> context}) {
+    throw new _AbortDueToError(node, message, context: context);
+  }
+
+  Null reportInvalidExpression(InvalidExpression node) {
+    throw new _AbortDueToInvalidExpression(node);
+  }
+
   /// Produce an unevaluated constant node for an expression.
   /// Mark all ancestors (up to the root of the constant evaluation) to
   /// indicate that they should also be unevaluated.
@@ -463,18 +525,15 @@
   }
 
   /// Evaluate [node] and possibly cache the evaluation result.
-  /// @throws _AbortCurrentEvaluation if expression can't be evaluated.
+  /// @throws _AbortDueToError or _AbortDueToInvalidExpression if expression
+  /// can't be evaluated.
   Constant _evaluateSubexpression(Expression node) {
     if (node == null) return nullConstant;
     if (env.isEmpty) {
       // We only try to evaluate the same [node] *once* within an empty
       // environment.
       if (nodeCache.containsKey(node)) {
-        final Constant constant = nodeCache[node];
-        if (constant == null)
-          throw new _AbortCurrentEvaluation(
-              errorReporter.circularity(contextChain, node));
-        return constant;
+        return nodeCache[node] ?? report(node, messageConstEvalCircularity);
       }
 
       nodeCache[node] = null;
@@ -550,8 +609,8 @@
 
   visitListLiteral(ListLiteral node) {
     if (!node.isConst) {
-      throw new _AbortCurrentEvaluation(
-          errorReporter.nonConstLiteral(contextChain, node, 'List'));
+      return report(
+          node, templateConstEvalNonConstantLiteral.withArguments('List'));
     }
     final List<Constant> entries = new List<Constant>(node.expressions.length);
     for (int i = 0; i < node.expressions.length; ++i) {
@@ -574,8 +633,8 @@
 
   visitSetLiteral(SetLiteral node) {
     if (!node.isConst) {
-      throw new _AbortCurrentEvaluation(
-          errorReporter.nonConstLiteral(contextChain, node, 'Set'));
+      return report(
+          node, templateConstEvalNonConstantLiteral.withArguments('Set'));
     }
     final List<Constant> entries = new List<Constant>(node.expressions.length);
     for (int i = 0; i < node.expressions.length; ++i) {
@@ -598,8 +657,8 @@
 
   visitMapLiteral(MapLiteral node) {
     if (!node.isConst) {
-      throw new _AbortCurrentEvaluation(
-          errorReporter.nonConstLiteral(contextChain, node, 'Map'));
+      return report(
+          node, templateConstEvalNonConstantLiteral.withArguments('Map'));
     }
     final Set<Constant> usedKeys = new Set<Constant>();
     final List<ConstantMapEntry> entries =
@@ -611,8 +670,8 @@
         // TODO(kustermann): We should change the context handling from just
         // capturing the `TreeNode`s to a `(TreeNode, String message)` tuple and
         // report where the first key with the same value was.
-        throw new _AbortCurrentEvaluation(
-            errorReporter.duplicateKey(contextChain, node.entries[i], key));
+        return report(
+            node.entries[i], templateConstEvalDuplicateKey.withArguments(key));
       }
       entries[i] = new ConstantMapEntry(key, value);
     }
@@ -634,8 +693,8 @@
   }
 
   visitFunctionExpression(FunctionExpression node) {
-    throw new _AbortCurrentEvaluation(
-        errorReporter.nonConstLiteral(contextChain, node, 'Function'));
+    return report(
+        node, templateConstEvalNonConstantLiteral.withArguments('Function'));
   }
 
   visitConstructorInvocation(ConstructorInvocation node) {
@@ -699,8 +758,8 @@
               isValidSymbolName(nameValue.value)) {
             return canonicalize(new SymbolConstant(nameValue.value, null));
           }
-          throw new _AbortCurrentEvaluation(errorReporter.invalidSymbolName(
-              contextChain, node.arguments.positional.first, nameValue));
+          return report(node.arguments.positional.first,
+              templateConstEvalInvalidSymbolName.withArguments(nameValue));
         }
 
         return canonicalize(result);
@@ -900,30 +959,31 @@
               if (condition is BoolConstant) {
                 if (!condition.value) {
                   if (init.statement.message == null) {
-                    throw new _AbortCurrentEvaluation(
-                        errorReporter.failedAssertion(
-                            contextChain, init.statement.condition, null));
+                    return report(init.statement.condition,
+                        messageConstEvalFailedAssertion);
                   }
                   final Constant message =
                       _evaluateSubexpression(init.statement.message);
                   if (message is StringConstant) {
-                    throw new _AbortCurrentEvaluation(
-                        errorReporter.failedAssertion(contextChain,
-                            init.statement.condition, message.value));
+                    return report(
+                        init.statement.condition,
+                        templateConstEvalFailedAssertionWithMessage
+                            .withArguments(message.value));
                   }
-                  throw new _AbortCurrentEvaluation(
-                      errorReporter.invalidDartType(
-                          contextChain,
-                          init.statement.message,
+                  return report(
+                      init.statement.message,
+                      templateConstEvalInvalidType.withArguments(
                           message,
-                          typeEnvironment.stringType));
+                          typeEnvironment.stringType,
+                          message.getType(typeEnvironment)));
                 }
               } else {
-                throw new _AbortCurrentEvaluation(errorReporter.invalidDartType(
-                    contextChain,
+                return report(
                     init.statement.condition,
-                    condition,
-                    typeEnvironment.boolType));
+                    templateConstEvalInvalidType.withArguments(
+                        condition,
+                        typeEnvironment.boolType,
+                        condition.getType(typeEnvironment)));
               }
             }
           } else {
@@ -936,7 +996,7 @@
   }
 
   visitInvalidExpression(InvalidExpression node) {
-    throw new _AbortCurrentEvaluation(node.message);
+    return reportInvalidExpression(node);
   }
 
   visitMethodInvocation(MethodInvocation node) {
@@ -977,12 +1037,11 @@
               return canonicalize(
                   new StringConstant(receiver.value + other.value));
             }
-            throw new _AbortCurrentEvaluation(
-                errorReporter.invalidBinaryOperandType(
-                    contextChain,
-                    node,
-                    receiver,
+            return report(
+                node,
+                templateConstEvalInvalidBinaryOperandType.withArguments(
                     '+',
+                    receiver,
                     typeEnvironment.stringType,
                     other.getType(typeEnvironment)));
         }
@@ -1000,12 +1059,11 @@
         final op = node.name.name;
         if (other is IntConstant) {
           if ((op == '<<' || op == '>>') && other.value < 0) {
-            throw new _AbortCurrentEvaluation(errorReporter.negativeShift(
-                contextChain,
+            return report(
                 node.arguments.positional.first,
-                receiver,
-                op,
-                other));
+                // TODO(askesc): Change argument types in template to constants.
+                templateConstEvalNegativeShift.withArguments(
+                    op, '${receiver.value}', '${other.value}'));
           }
           switch (op) {
             case '|':
@@ -1028,8 +1086,11 @@
 
         if (other is IntConstant) {
           if (other.value == 0 && (op == '%' || op == '~/')) {
-            throw new _AbortCurrentEvaluation(errorReporter.zeroDivisor(
-                contextChain, node.arguments.positional.first, receiver, op));
+            return report(
+                node.arguments.positional.first,
+                // TODO(askesc): Change argument type in template to constant.
+                templateConstEvalZeroDivisor.withArguments(
+                    op, '${receiver.value}'));
           }
 
           return evaluateBinaryNumericOperation(
@@ -1038,12 +1099,11 @@
           return evaluateBinaryNumericOperation(
               node.name.name, receiver.value, other.value, node);
         }
-        throw new _AbortCurrentEvaluation(
-            errorReporter.invalidBinaryOperandType(
-                contextChain,
-                node,
+        return report(
+            node,
+            templateConstEvalInvalidBinaryOperandType.withArguments(
+                node.name.name,
                 receiver,
-                '${node.name.name}',
                 typeEnvironment.numType,
                 other.getType(typeEnvironment)));
       }
@@ -1063,18 +1123,19 @@
           return evaluateBinaryNumericOperation(
               node.name.name, receiver.value, value, node);
         }
-        throw new _AbortCurrentEvaluation(
-            errorReporter.invalidBinaryOperandType(
-                contextChain,
-                node,
+        return report(
+            node,
+            templateConstEvalInvalidBinaryOperandType.withArguments(
+                node.name.name,
                 receiver,
-                '${node.name.name}',
                 typeEnvironment.numType,
                 other.getType(typeEnvironment)));
       }
     }
-    throw new _AbortCurrentEvaluation(errorReporter.invalidMethodInvocation(
-        contextChain, node, receiver, node.name.name));
+    return report(
+        node,
+        templateConstEvalInvalidMethodInvocation.withArguments(
+            node.name.name, receiver));
   }
 
   visitLogicalExpression(LogicalExpression node) {
@@ -1095,17 +1156,18 @@
             return right;
           }
 
-          throw new _AbortCurrentEvaluation(
-              errorReporter.invalidBinaryOperandType(
-                  contextChain,
-                  node,
+          return report(
+              node,
+              templateConstEvalInvalidBinaryOperandType.withArguments(
+                  node.operator,
                   left,
-                  '${node.operator}',
                   typeEnvironment.boolType,
                   right.getType(typeEnvironment)));
         }
-        throw new _AbortCurrentEvaluation(errorReporter.invalidMethodInvocation(
-            contextChain, node, left, '${node.operator}'));
+        return report(
+            node,
+            templateConstEvalInvalidMethodInvocation.withArguments(
+                node.operator, left));
       case '&&':
         if (left is BoolConstant) {
           if (!left.value) return falseConstant;
@@ -1115,24 +1177,27 @@
             return right;
           }
 
-          throw new _AbortCurrentEvaluation(
-              errorReporter.invalidBinaryOperandType(
-                  contextChain,
-                  node,
+          return report(
+              node,
+              templateConstEvalInvalidBinaryOperandType.withArguments(
+                  node.operator,
                   left,
-                  '${node.operator}',
                   typeEnvironment.boolType,
                   right.getType(typeEnvironment)));
         }
-        throw new _AbortCurrentEvaluation(errorReporter.invalidMethodInvocation(
-            contextChain, node, left, '${node.operator}'));
+        return report(
+            node,
+            templateConstEvalInvalidMethodInvocation.withArguments(
+                node.operator, left));
       case '??':
         return (left is! NullConstant)
             ? left
             : _evaluateSubexpression(node.right);
       default:
-        throw new _AbortCurrentEvaluation(errorReporter.invalidMethodInvocation(
-            contextChain, node, left, '${node.operator}'));
+        return report(
+            node,
+            templateConstEvalInvalidMethodInvocation.withArguments(
+                node.operator, left));
     }
   }
 
@@ -1151,8 +1216,10 @@
               cloner.clone(node.otherwise),
               node.staticType));
     } else {
-      throw new _AbortCurrentEvaluation(errorReporter.invalidDartType(
-          contextChain, node, condition, typeEnvironment.boolType));
+      return report(
+          node,
+          templateConstEvalInvalidType.withArguments(condition,
+              typeEnvironment.boolType, condition.getType(typeEnvironment)));
     }
   }
 
@@ -1200,12 +1267,11 @@
     // variables might allow more than it should.
     final VariableDeclaration variable = node.variable;
     if (variable.parent is Let || _isFormalParameter(variable)) {
-      final Constant constant = env.lookupVariable(node.variable);
-      if (constant == null) {
-        throw new _AbortCurrentEvaluation(errorReporter.nonConstantVariableGet(
-            contextChain, node, variable.name));
-      }
-      return constant;
+      return env.lookupVariable(node.variable) ??
+          report(
+              node,
+              templateConstEvalNonConstantVariableGet
+                  .withArguments(variable.name));
     }
     if (variable.isConst) {
       return _evaluateSubexpression(variable.initializer);
@@ -1227,14 +1293,18 @@
             return _evaluateSubexpression(target.initializer);
           });
         }
-        throw new _AbortCurrentEvaluation(
-            errorReporter.invalidStaticInvocation(contextChain, node, target));
+        return report(
+            node,
+            templateConstEvalInvalidStaticInvocation
+                .withArguments(target.name.name));
       } else if (target is Procedure) {
         if (target.kind == ProcedureKind.Method) {
           return canonicalize(new TearOffConstant(target));
         }
-        throw new _AbortCurrentEvaluation(
-            errorReporter.invalidStaticInvocation(contextChain, node, target));
+        return report(
+            node,
+            templateConstEvalInvalidStaticInvocation
+                .withArguments(target.name.name));
       } else {
         throw new Exception(
             'No support for ${target.runtimeType} in a static-get.');
@@ -1257,8 +1327,10 @@
       } else if (constant is UnevaluatedConstant) {
         concatenated.add(constant);
       } else {
-        throw new _AbortCurrentEvaluation(errorReporter
-            .invalidStringInterpolationOperand(contextChain, node, constant));
+        return report(
+            node,
+            templateConstEvalInvalidStringInterpolationOperand
+                .withArguments(constant));
       }
     }
     if (concatenated.length > 1) {
@@ -1346,8 +1418,23 @@
         return identical(left, right) ? trueConstant : falseConstant;
       }
     }
-    throw new _AbortCurrentEvaluation(
-        errorReporter.invalidStaticInvocation(contextChain, node, target));
+
+    // TODO(kmillikin) For an invalid factory invocation we should adopt a
+    // better message.  This will show something like:
+    //
+    // "The invocation of 'List' is not allowed within a const context."
+    //
+    // Which is not quite right when the code was "new List()".
+    String name = target.name.name;
+    if (target is Procedure && target.isFactory) {
+      if (name.isEmpty) {
+        name = target.enclosingClass.name;
+      } else {
+        name = '${target.enclosingClass.name}.${name}';
+      }
+    }
+    return report(
+        node, templateConstEvalInvalidStaticInvocation.withArguments(name));
   }
 
   visitAsExpression(AsExpression node) {
@@ -1368,8 +1455,10 @@
     if (constant is UnevaluatedConstant) {
       return unevaluated(node, new Not(unique(constant.expression)));
     }
-    throw new _AbortCurrentEvaluation(errorReporter.invalidDartType(
-        contextChain, node, constant, typeEnvironment.boolType));
+    return report(
+        node,
+        templateConstEvalInvalidType.withArguments(constant,
+            typeEnvironment.boolType, constant.getType(typeEnvironment)));
   }
 
   visitSymbolLiteral(SymbolLiteral node) {
@@ -1401,8 +1490,8 @@
 
   @override
   visitCheckLibraryIsLoaded(CheckLibraryIsLoaded node) {
-    throw new _AbortCurrentEvaluation(
-        errorReporter.deferredLibrary(contextChain, node, node.import.name));
+    return report(
+        node, templateConstEvalDeferredLibrary.withArguments(node.import.name));
   }
 
   // Helper methods:
@@ -1423,8 +1512,10 @@
     DartType constantType = constant.getType(typeEnvironment);
 
     if (!typeEnvironment.isSubtypeOf(constantType, type)) {
-      throw new _AbortCurrentEvaluation(
-          errorReporter.invalidDartType(contextChain, node, constant, type));
+      return report(
+          node,
+          templateConstEvalInvalidType.withArguments(
+              constant, type, constant.getType(typeEnvironment)));
     }
   }
 
@@ -1447,8 +1538,8 @@
     final result = env.subsituteType(type);
 
     if (!isInstantiated(result)) {
-      throw new _AbortCurrentEvaluation(
-          errorReporter.freeTypeParameter(contextChain, node, type));
+      return report(
+          node, templateConstEvalFreeTypeParameter.withArguments(type));
     }
 
     return result;
@@ -1637,201 +1728,51 @@
 }
 
 // Used as control-flow to abort the current evaluation.
-class _AbortCurrentEvaluation {
-  final String message;
-  _AbortCurrentEvaluation(this.message);
+class _AbortDueToError {
+  final TreeNode node;
+  final Message message;
+  final List<LocatedMessage> context;
+
+  _AbortDueToError(this.node, this.message, {this.context});
+}
+
+class _AbortDueToInvalidExpression {
+  final InvalidExpression node;
+
+  _AbortDueToInvalidExpression(this.node);
 }
 
 abstract class ErrorReporter {
   const ErrorReporter();
 
-  Uri getFileUri(TreeNode node) {
-    while (node is! FileUriNode) {
-      node = node.parent;
-    }
-    return (node as FileUriNode).fileUri;
-  }
+  void report(LocatedMessage message, List<LocatedMessage> context);
 
-  int getFileOffset(TreeNode node) {
-    while (node.fileOffset == TreeNode.noOffset) {
-      node = node.parent;
-    }
-    return node == null ? TreeNode.noOffset : node.fileOffset;
-  }
-
-  String freeTypeParameter(
-      List<TreeNode> context, TreeNode node, DartType type);
-  String invalidDartType(List<TreeNode> context, TreeNode node,
-      Constant receiver, DartType expectedType);
-  String invalidBinaryOperandType(List<TreeNode> context, TreeNode node,
-      Constant receiver, String op, DartType expectedType, DartType actualType);
-  String invalidMethodInvocation(
-      List<TreeNode> context, TreeNode node, Constant receiver, String op);
-  String invalidStaticInvocation(
-      List<TreeNode> context, TreeNode node, Member target);
-  String invalidStringInterpolationOperand(
-      List<TreeNode> context, TreeNode node, Constant constant);
-  String invalidSymbolName(
-      List<TreeNode> context, TreeNode node, Constant constant);
-  String zeroDivisor(
-      List<TreeNode> context, TreeNode node, IntConstant receiver, String op);
-  String negativeShift(List<TreeNode> context, TreeNode node,
-      IntConstant receiver, String op, IntConstant argument);
-  String nonConstLiteral(List<TreeNode> context, TreeNode node, String klass);
-  String duplicateKey(List<TreeNode> context, TreeNode node, Constant key);
-  String failedAssertion(List<TreeNode> context, TreeNode node, String message);
-  String nonConstantVariableGet(
-      List<TreeNode> context, TreeNode node, String variableName);
-  String deferredLibrary(
-      List<TreeNode> context, TreeNode node, String importName);
-  String circularity(List<TreeNode> context, TreeNode node);
+  void reportInvalidExpression(InvalidExpression node);
 }
 
-class SimpleErrorReporter extends ErrorReporter {
+class SimpleErrorReporter implements ErrorReporter {
   const SimpleErrorReporter();
 
-  String report(List<TreeNode> context, String what, TreeNode node) {
+  @override
+  void report(LocatedMessage message, List<LocatedMessage> context) {
+    _report(message);
+    for (LocatedMessage contextMessage in context) {
+      _report(contextMessage);
+    }
+  }
+
+  @override
+  void reportInvalidExpression(InvalidExpression node) {
+    // Ignored
+  }
+
+  void _report(LocatedMessage message) {
+    reportMessage(message.uri, message.charOffset, message.message);
+  }
+
+  void reportMessage(Uri uri, int offset, String message) {
     io.exitCode = 42;
-    final Uri uri = getFileUri(node);
-    final int fileOffset = getFileOffset(node);
-    final String message = '$uri:$fileOffset Constant evaluation error: $what';
-    io.stderr.writeln(message);
-    return message;
-  }
-
-  @override
-  String freeTypeParameter(
-      List<TreeNode> context, TreeNode node, DartType type) {
-    return report(
-        context, 'Expected type to be instantiated but was ${type}', node);
-  }
-
-  @override
-  String invalidDartType(List<TreeNode> context, TreeNode node,
-      Constant receiver, DartType expectedType) {
-    return report(
-        context,
-        'Expected expression to evaluate to "$expectedType" but got "$receiver.',
-        node);
-  }
-
-  @override
-  String invalidBinaryOperandType(
-      List<TreeNode> context,
-      TreeNode node,
-      Constant receiver,
-      String op,
-      DartType expectedType,
-      DartType actualType) {
-    return report(
-        context,
-        'Calling "$op" on "$receiver" needs operand of type '
-        '"$expectedType" (but got "$actualType")',
-        node);
-  }
-
-  @override
-  String invalidMethodInvocation(
-      List<TreeNode> context, TreeNode node, Constant receiver, String op) {
-    return report(context,
-        'Cannot call "$op" on "$receiver" in constant expression', node);
-  }
-
-  @override
-  String invalidStaticInvocation(
-      List<TreeNode> context, TreeNode node, Member target) {
-    return report(
-        context, 'Cannot invoke "$target" inside a constant expression', node);
-  }
-
-  @override
-  String invalidStringInterpolationOperand(
-      List<TreeNode> context, TreeNode node, Constant constant) {
-    return report(
-        context,
-        'Only null/bool/int/double/String values are allowed as string '
-        'interpolation expressions during constant evaluation (was: "$constant").',
-        node);
-  }
-
-  @override
-  String invalidSymbolName(
-      List<TreeNode> context, TreeNode node, Constant constant) {
-    return report(
-        context,
-        'The symbol name must be a valid public Dart member name, public '
-        'constructor name, or library name, optionally qualified.',
-        node);
-  }
-
-  @override
-  String zeroDivisor(
-      List<TreeNode> context, TreeNode node, IntConstant receiver, String op) {
-    return report(
-        context,
-        "Binary operator '$op' on '${receiver.value}' requires non-zero "
-        "divisor, but divisor was '0'.",
-        node);
-  }
-
-  @override
-  String negativeShift(List<TreeNode> context, TreeNode node,
-      IntConstant receiver, String op, IntConstant argument) {
-    return report(
-        context,
-        "Binary operator '$op' on '${receiver.value}' requires non-negative "
-        "operand, but was '${argument.value}'.",
-        node);
-  }
-
-  @override
-  String nonConstLiteral(List<TreeNode> context, TreeNode node, String klass) {
-    return report(
-        context,
-        'Cannot have a non-constant $klass literal within a const context.',
-        node);
-  }
-
-  @override
-  String duplicateKey(List<TreeNode> context, TreeNode node, Constant key) {
-    return report(
-        context,
-        'Duplicate keys are not allowed in constant maps (found duplicate key "$key")',
-        node);
-  }
-
-  @override
-  String failedAssertion(
-      List<TreeNode> context, TreeNode node, String message) {
-    return report(
-        context,
-        'The assertion condition evaluated to "false" with message "$message"',
-        node);
-  }
-
-  @override
-  String nonConstantVariableGet(
-      List<TreeNode> context, TreeNode node, String variableName) {
-    return report(
-        context,
-        'The variable "$variableName" cannot be used inside a constant '
-        'expression.',
-        node);
-  }
-
-  @override
-  String deferredLibrary(
-      List<TreeNode> context, TreeNode node, String importName) {
-    return report(
-        context,
-        'Deferred "$importName" cannot be used inside a constant '
-        'expression',
-        node);
-  }
-
-  @override
-  String circularity(List<TreeNode> context, TreeNode node) {
-    return report(context, 'Constant expression depends on itself.', node);
+    io.stderr.writeln('$uri:$offset Constant evaluation error: $message');
   }
 }
 
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_constants.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_constants.dart
index 5b40187..5f8b4f5 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_constants.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_constants.dart
@@ -4,31 +4,9 @@
 
 library fasta.kernel_constants;
 
-import 'package:kernel/ast.dart'
-    show Constant, DartType, IntConstant, Library, Member, Procedure, TreeNode;
+import 'package:kernel/ast.dart' show InvalidExpression, Library;
 
-import 'package:kernel/type_environment.dart' show TypeEnvironment;
-
-import '../fasta_codes.dart'
-    show
-        Message,
-        noLength,
-        messageConstEvalCircularity,
-        messageConstEvalFailedAssertion,
-        templateConstEvalDeferredLibrary,
-        templateConstEvalDuplicateKey,
-        templateConstEvalFailedAssertionWithMessage,
-        templateConstEvalFreeTypeParameter,
-        templateConstEvalInvalidBinaryOperandType,
-        templateConstEvalInvalidMethodInvocation,
-        templateConstEvalInvalidStaticInvocation,
-        templateConstEvalInvalidStringInterpolationOperand,
-        templateConstEvalInvalidSymbolName,
-        templateConstEvalInvalidType,
-        templateConstEvalNegativeShift,
-        templateConstEvalNonConstantLiteral,
-        templateConstEvalNonConstantVariableGet,
-        templateConstEvalZeroDivisor;
+import '../fasta_codes.dart' show LocatedMessage;
 
 import '../loader.dart' show Loader;
 
@@ -36,145 +14,18 @@
 
 class KernelConstantErrorReporter extends ErrorReporter {
   final Loader<Library> loader;
-  final TypeEnvironment typeEnvironment;
 
-  KernelConstantErrorReporter(this.loader, this.typeEnvironment);
+  KernelConstantErrorReporter(this.loader);
 
-  String addProblem(TreeNode node, Message message) {
-    int offset = getFileOffset(node);
-    Uri uri = getFileUri(node);
-    loader.addProblem(message, offset, noLength, uri);
-    return loader.target.context.format(
-        message.withLocation(uri, offset, noLength), message.code.severity);
+  @override
+  void report(LocatedMessage message, List<LocatedMessage> context) {
+    loader.addProblem(
+        message.messageObject, message.charOffset, message.length, message.uri,
+        context: context);
   }
 
   @override
-  String freeTypeParameter(
-      List<TreeNode> context, TreeNode node, DartType type) {
-    return addProblem(
-        node, templateConstEvalFreeTypeParameter.withArguments(type));
-  }
-
-  @override
-  String duplicateKey(List<TreeNode> context, TreeNode node, Constant key) {
-    return addProblem(node, templateConstEvalDuplicateKey.withArguments(key));
-  }
-
-  @override
-  String invalidDartType(List<TreeNode> context, TreeNode node,
-      Constant receiver, DartType expectedType) {
-    return addProblem(
-        node,
-        templateConstEvalInvalidType.withArguments(
-            receiver, expectedType, receiver.getType(typeEnvironment)));
-  }
-
-  @override
-  String invalidBinaryOperandType(
-      List<TreeNode> context,
-      TreeNode node,
-      Constant receiver,
-      String op,
-      DartType expectedType,
-      DartType actualType) {
-    return addProblem(
-        node,
-        templateConstEvalInvalidBinaryOperandType.withArguments(
-            op, receiver, expectedType, actualType));
-  }
-
-  @override
-  String invalidMethodInvocation(
-      List<TreeNode> context, TreeNode node, Constant receiver, String op) {
-    return addProblem(node,
-        templateConstEvalInvalidMethodInvocation.withArguments(op, receiver));
-  }
-
-  @override
-  String invalidStaticInvocation(
-      List<TreeNode> context, TreeNode node, Member target) {
-    // TODO(kmillikin) For an invalid factory invocation we should adopt a
-    // better message.  This will show something like:
-    //
-    // "The invocation of 'List' is not allowed within a const context."
-    //
-    // Which is not quite right when the code was "new List()".
-    String name = target.name.toString();
-    if (target is Procedure && target.isFactory) {
-      if (name.isEmpty) {
-        name = target.enclosingClass.name;
-      } else {
-        name = '${target.enclosingClass.name}.${name}';
-      }
-    }
-    return addProblem(
-        node, templateConstEvalInvalidStaticInvocation.withArguments(name));
-  }
-
-  @override
-  String invalidStringInterpolationOperand(
-      List<TreeNode> context, TreeNode node, Constant constant) {
-    return addProblem(
-        node,
-        templateConstEvalInvalidStringInterpolationOperand
-            .withArguments(constant));
-  }
-
-  @override
-  String invalidSymbolName(
-      List<TreeNode> context, TreeNode node, Constant constant) {
-    return addProblem(
-        node, templateConstEvalInvalidSymbolName.withArguments(constant));
-  }
-
-  @override
-  String zeroDivisor(
-      List<TreeNode> context, TreeNode node, IntConstant receiver, String op) {
-    return addProblem(node,
-        templateConstEvalZeroDivisor.withArguments(op, '${receiver.value}'));
-  }
-
-  @override
-  String negativeShift(List<TreeNode> context, TreeNode node,
-      IntConstant receiver, String op, IntConstant argument) {
-    return addProblem(
-        node,
-        templateConstEvalNegativeShift.withArguments(
-            op, '${receiver.value}', '${argument.value}'));
-  }
-
-  @override
-  String nonConstLiteral(List<TreeNode> context, TreeNode node, String klass) {
-    return addProblem(
-        node, templateConstEvalNonConstantLiteral.withArguments(klass));
-  }
-
-  @override
-  String failedAssertion(List<TreeNode> context, TreeNode node, String string) {
-    return addProblem(
-        node,
-        (string == null)
-            ? messageConstEvalFailedAssertion
-            : templateConstEvalFailedAssertionWithMessage
-                .withArguments(string));
-  }
-
-  @override
-  String nonConstantVariableGet(
-      List<TreeNode> context, TreeNode node, String variableName) {
-    return addProblem(node,
-        templateConstEvalNonConstantVariableGet.withArguments(variableName));
-  }
-
-  @override
-  String deferredLibrary(
-      List<TreeNode> context, TreeNode node, String importName) {
-    return addProblem(
-        node, templateConstEvalDeferredLibrary.withArguments(importName));
-  }
-
-  @override
-  String circularity(List<TreeNode> context, TreeNode node) {
-    return addProblem(node, messageConstEvalCircularity);
+  void reportInvalidExpression(InvalidExpression node) {
+    // Assumed to be already reported.
   }
 }
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_target.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_target.dart
index a797830..5473197 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_target.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_target.dart
@@ -758,7 +758,7 @@
           backendTarget.constantsBackend(loader.coreTypes),
           environmentDefines,
           environment,
-          new KernelConstantErrorReporter(loader, environment),
+          new KernelConstantErrorReporter(loader),
           enableAsserts: enableAsserts);
       ticker.logMs("Evaluated constants");
     }
diff --git a/pkg/vm/lib/bytecode/gen_bytecode.dart b/pkg/vm/lib/bytecode/gen_bytecode.dart
index 0dbc532..3e69e5a 100644
--- a/pkg/vm/lib/bytecode/gen_bytecode.dart
+++ b/pkg/vm/lib/bytecode/gen_bytecode.dart
@@ -58,7 +58,7 @@
       onAmbiguousSupertypes: ignoreAmbiguousSupertypes);
   final typeEnvironment = new TypeEnvironment(coreTypes, hierarchy);
   final constantsBackend = new VmConstantsBackend(coreTypes);
-  final errorReporter = new ForwardConstantEvaluationErrors(typeEnvironment);
+  final errorReporter = new ForwardConstantEvaluationErrors();
   libraries ??= component.libraries;
   final bytecodeGenerator = new BytecodeGenerator(
       component,
diff --git a/pkg/vm/lib/constants_error_reporter.dart b/pkg/vm/lib/constants_error_reporter.dart
index 88eeeb6..724f5d8 100644
--- a/pkg/vm/lib/constants_error_reporter.dart
+++ b/pkg/vm/lib/constants_error_reporter.dart
@@ -10,162 +10,22 @@
     as constants;
 
 import 'package:front_end/src/api_unstable/vm.dart'
-    show CompilerContext, Severity;
+    show CompilerContext, LocatedMessage, Severity;
 
-import 'package:front_end/src/api_unstable/vm.dart' as codes;
+import 'package:kernel/ast.dart' show InvalidExpression;
 
-import 'package:kernel/ast.dart'
-    show Constant, DartType, IntConstant, Member, TreeNode;
-import 'package:kernel/type_environment.dart' show TypeEnvironment;
-
-class ForwardConstantEvaluationErrors extends constants.ErrorReporter {
+class ForwardConstantEvaluationErrors implements constants.ErrorReporter {
   // This will get the currently active [CompilerContext] from a zone variable.
   // If there is no active context, this will throw.
   final CompilerContext compilerContext = CompilerContext.current;
 
-  final TypeEnvironment typeEnvironment;
-
-  ForwardConstantEvaluationErrors(this.typeEnvironment);
-
   @override
-  String freeTypeParameter(
-      List<TreeNode> context, TreeNode node, DartType type) {
-    final message =
-        codes.templateConstEvalFreeTypeParameter.withArguments(type);
-    return reportIt(context, message, node);
+  void report(LocatedMessage message, List<LocatedMessage> context) {
+    compilerContext.options.report(message, Severity.error, context: context);
   }
 
   @override
-  String duplicateKey(List<TreeNode> context, TreeNode node, Constant key) {
-    final message = codes.templateConstEvalDuplicateKey.withArguments(key);
-    return reportIt(context, message, node);
-  }
-
-  @override
-  String invalidDartType(List<TreeNode> context, TreeNode node,
-      Constant receiver, DartType expectedType) {
-    final message = codes.templateConstEvalInvalidType.withArguments(
-        receiver, expectedType, receiver.getType(typeEnvironment));
-    return reportIt(context, message, node);
-  }
-
-  @override
-  String invalidBinaryOperandType(
-      List<TreeNode> context,
-      TreeNode node,
-      Constant receiver,
-      String op,
-      DartType expectedType,
-      DartType actualType) {
-    final message = codes.templateConstEvalInvalidBinaryOperandType
-        .withArguments(op, receiver, expectedType, actualType);
-    return reportIt(context, message, node);
-  }
-
-  @override
-  String invalidMethodInvocation(
-      List<TreeNode> context, TreeNode node, Constant receiver, String op) {
-    final message = codes.templateConstEvalInvalidMethodInvocation
-        .withArguments(op, receiver);
-    return reportIt(context, message, node);
-  }
-
-  @override
-  String invalidStaticInvocation(
-      List<TreeNode> context, TreeNode node, Member target) {
-    final message = codes.templateConstEvalInvalidStaticInvocation
-        .withArguments(target.name.toString());
-    return reportIt(context, message, node);
-  }
-
-  @override
-  String invalidStringInterpolationOperand(
-      List<TreeNode> context, TreeNode node, Constant constant) {
-    final message = codes.templateConstEvalInvalidStringInterpolationOperand
-        .withArguments(constant);
-    return reportIt(context, message, node);
-  }
-
-  @override
-  String invalidSymbolName(
-      List<TreeNode> context, TreeNode node, Constant constant) {
-    final message =
-        codes.templateConstEvalInvalidSymbolName.withArguments(constant);
-    return reportIt(context, message, node);
-  }
-
-  @override
-  String zeroDivisor(
-      List<TreeNode> context, TreeNode node, IntConstant receiver, String op) {
-    final message = codes.templateConstEvalZeroDivisor
-        .withArguments(op, '${receiver.value}');
-    return reportIt(context, message, node);
-  }
-
-  @override
-  String negativeShift(List<TreeNode> context, TreeNode node,
-      IntConstant receiver, String op, IntConstant argument) {
-    final message = codes.templateConstEvalNegativeShift
-        .withArguments(op, '${receiver.value}', '${argument.value}');
-    return reportIt(context, message, node);
-  }
-
-  @override
-  String nonConstLiteral(List<TreeNode> context, TreeNode node, String klass) {
-    final message =
-        codes.templateConstEvalNonConstantLiteral.withArguments(klass);
-    return reportIt(context, message, node);
-  }
-
-  @override
-  String failedAssertion(List<TreeNode> context, TreeNode node, String string) {
-    final message = string == null
-        ? codes.messageConstEvalFailedAssertion
-        : codes.templateConstEvalFailedAssertionWithMessage
-            .withArguments(string);
-    return reportIt(context, message, node);
-  }
-
-  @override
-  String nonConstantVariableGet(
-      List<TreeNode> context, TreeNode node, String variableName) {
-    final message = codes.templateConstEvalNonConstantVariableGet
-        .withArguments(variableName);
-    return reportIt(context, message, node);
-  }
-
-  @override
-  String deferredLibrary(
-      List<TreeNode> context, TreeNode node, String importName) {
-    final message =
-        codes.templateConstEvalDeferredLibrary.withArguments(importName);
-    return reportIt(context, message, node);
-  }
-
-  @override
-  String circularity(List<TreeNode> context, TreeNode node) {
-    final message = codes.messageConstEvalCircularity;
-    return reportIt(context, message, node);
-  }
-
-  String reportIt(
-      List<TreeNode> context, codes.Message message, TreeNode node) {
-    final Uri uri = getFileUri(node);
-    final int fileOffset = getFileOffset(node);
-
-    final contextMessages = <codes.LocatedMessage>[];
-    for (final TreeNode node in context) {
-      final Uri uri = getFileUri(node);
-      final int fileOffset = getFileOffset(node);
-      contextMessages.add(codes.messageConstEvalContext
-          .withLocation(uri, fileOffset, codes.noLength));
-    }
-
-    final locatedMessage =
-        message.withLocation(uri, fileOffset, codes.noLength);
-
-    compilerContext.options
-        .report(locatedMessage, Severity.error, context: contextMessages);
-    return locatedMessage.message;
+  void reportInvalidExpression(InvalidExpression node) {
+    // Assumed to be already reported.
   }
 }
diff --git a/pkg/vm/lib/kernel_front_end.dart b/pkg/vm/lib/kernel_front_end.dart
index 049e7bb..5b299d9 100644
--- a/pkg/vm/lib/kernel_front_end.dart
+++ b/pkg/vm/lib/kernel_front_end.dart
@@ -35,7 +35,6 @@
         parseExperimentalFlags,
         printDiagnosticMessage;
 
-import 'package:kernel/type_environment.dart' show TypeEnvironment;
 import 'package:kernel/class_hierarchy.dart' show ClassHierarchy;
 import 'package:kernel/ast.dart'
     show Component, Field, Library, Reference, StaticGet;
@@ -405,13 +404,10 @@
   final vmConstants = new vm_constants.VmConstantsBackend(coreTypes);
 
   await runWithFrontEndCompilerContext(source, compilerOptions, component, () {
-    final hierarchy = new ClassHierarchy(component);
-    final typeEnvironment = new TypeEnvironment(coreTypes, hierarchy);
-
     // TFA will remove constants fields which are unused (and respects the
     // vm/embedder entrypoints).
     constants.transformComponent(component, vmConstants, environmentDefines,
-        new ForwardConstantEvaluationErrors(typeEnvironment),
+        new ForwardConstantEvaluationErrors(),
         keepFields: true,
         evaluateAnnotations: true,
         enableAsserts: enableAsserts);