Revert "Handle fields with initializers in constant constructors."

pkg/compiler/lib/src/compile_time_constants.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library dart2js.compile_time_constant_evaluator;
 
 import 'common.dart';
 import 'common/resolution.dart' show Resolution;
 import 'common/tasks.dart' show CompilerTask, Measurer;
 import 'compiler.dart' show Compiler;
@@ skipping 396 matching lines @@
       : this.isEvaluatingConstant = isConst;
 
   ConstantSystem get constantSystem => handler.constantSystem;
   Resolution get resolution => compiler.resolution;
   CoreTypes get coreTypes => compiler.coreTypes;
   DiagnosticReporter get reporter => compiler.reporter;
 
   AstConstant evaluate(Node node) {
     // TODO(johnniwinther): should there be a visitErrorNode?
     if (node is ErrorNode) return new ErroneousAstConstant(context, node);
-    AstConstant result = node.accept(this);
-    assert(invariant(node, !isEvaluatingConstant || result != null,
-        message: "No AstConstant computed for the node."));
-    return result;
+    return node.accept(this);
   }
 
   AstConstant evaluateConstant(Node node) {
     bool oldIsEvaluatingConstant = isEvaluatingConstant;
     isEvaluatingConstant = true;
     AstConstant result = node.accept(this);
     isEvaluatingConstant = oldIsEvaluatingConstant;
-    assert(invariant(node, result != null,
-        message: "No AstConstant computed for the node."));
+    assert(result != null);
     return result;
   }
 
   AstConstant visitNode(Node node) {
     return signalNotCompileTimeConstant(node);
   }
 
   AstConstant visitLiteralBool(LiteralBool node) {
     return new AstConstant(
         context,
@@ skipping 18 matching lines @@
   AstConstant visitLiteralList(LiteralList node) {
     if (!node.isConst) {
       return signalNotCompileTimeConstant(node);
     }
     List<ConstantExpression> argumentExpressions = <ConstantExpression>[];
     List<ConstantValue> argumentValues = <ConstantValue>[];
     for (Link<Node> link = node.elements.nodes;
         !link.isEmpty;
         link = link.tail) {
       AstConstant argument = evaluateConstant(link.head);
-      if (argument == null || argument.isError) {
-        return argument;
+      if (argument == null) {
+        return null;
       }
       argumentExpressions.add(argument.expression);
       argumentValues.add(argument.value);
     }
     DartType type = elements.getType(node);
     return new AstConstant(
         context,
         node,
         new ListConstantExpression(type, argumentExpressions),
         constantSystem.createList(type, argumentValues));
   }
 
   AstConstant visitLiteralMap(LiteralMap node) {
     if (!node.isConst) {
       return signalNotCompileTimeConstant(node);
     }
     List<ConstantExpression> keyExpressions = <ConstantExpression>[];
     List<ConstantExpression> valueExpressions = <ConstantExpression>[];
     List<ConstantValue> keyValues = <ConstantValue>[];
     Map<ConstantValue, ConstantValue> map = <ConstantValue, ConstantValue>{};
     for (Link<Node> link = node.entries.nodes;
         !link.isEmpty;
         link = link.tail) {
       LiteralMapEntry entry = link.head;
       AstConstant key = evaluateConstant(entry.key);
-      if (key == null || key.isError) {
-        return key;
+      if (key == null) {
+        return null;
       }
       AstConstant value = evaluateConstant(entry.value);
-      if (value == null || value.isError) {
-        return value;
+      if (value == null) {
+        return null;
       }
       if (!map.containsKey(key.value)) {
         keyValues.add(key.value);
       } else {
         reporter.reportWarningMessage(
             entry.key, MessageKind.EQUAL_MAP_ENTRY_KEY);
       }
       keyExpressions.add(key.expression);
       valueExpressions.add(value.expression);
       map[key.value] = value.value;
@@ skipping 16 matching lines @@
     return new AstConstant(
         context,
         node,
         new StringConstantExpression(node.dartString.slowToString()),
         constantSystem.createString(node.dartString));
   }
 
   AstConstant visitStringJuxtaposition(StringJuxtaposition node) {
     AstConstant left = evaluate(node.first);
     AstConstant right = evaluate(node.second);
-    if (left == null || left.isError) {
-      return left;
-    }
-    if (right == null || right.isError) {
-      return right;
-    }
+    if (left == null || right == null) return null;
     StringConstantValue leftValue = left.value;
     StringConstantValue rightValue = right.value;
     return new AstConstant(
         context,
         node,
         new ConcatenateConstantExpression([left.expression, right.expression]),
         constantSystem.createString(new DartString.concat(
             leftValue.primitiveValue, rightValue.primitiveValue)));
   }
 
   AstConstant visitStringInterpolation(StringInterpolation node) {
     List<ConstantExpression> subexpressions = <ConstantExpression>[];
     AstConstant initialString = evaluate(node.string);
-    if (initialString == null || initialString.isError) {
-      return initialString;
+    if (initialString == null) {
+      return null;
     }
     subexpressions.add(initialString.expression);
     StringConstantValue initialStringValue = initialString.value;
     DartString accumulator = initialStringValue.primitiveValue;
     for (StringInterpolationPart part in node.parts) {
       AstConstant subexpression = evaluate(part.expression);
-      if (subexpression == null || subexpression.isError) {
-        return subexpression;
+      if (subexpression == null) {
+        return null;
       }
       subexpressions.add(subexpression.expression);
       ConstantValue expression = subexpression.value;
       DartString expressionString;
       if (expression.isNum || expression.isBool || expression.isNull) {
         PrimitiveConstantValue primitive = expression;
         expressionString =
             new DartString.literal(primitive.primitiveValue.toString());
       } else if (expression.isString) {
         PrimitiveConstantValue primitive = expression;
         expressionString = primitive.primitiveValue;
       } else {
         // TODO(johnniwinther): Specialize message to indicated that the problem
         // is not constness but the types of the const expressions.
         return signalNotCompileTimeConstant(part.expression);
       }
       accumulator = new DartString.concat(accumulator, expressionString);
       AstConstant partString = evaluate(part.string);
       if (partString == null) return null;
       subexpressions.add(partString.expression);
       StringConstantValue partStringValue = partString.value;
       accumulator =
           new DartString.concat(accumulator, partStringValue.primitiveValue);
     }
+    ;
     return new AstConstant(
         context,
         node,
         new ConcatenateConstantExpression(subexpressions),
         constantSystem.createString(accumulator));
   }
 
   AstConstant visitLiteralSymbol(LiteralSymbol node) {
     InterfaceType type = coreTypes.symbolType;
     String text = node.slowNameString;
@@ skipping 126 matching lines @@
               send,
               new IdenticalConstantExpression(
                   left.expression, right.expression),
               result);
         }
       }
       return signalNotCompileTimeConstant(send);
     } else if (send.isPrefix) {
       assert(send.isOperator);
       AstConstant receiverConstant = evaluate(send.receiver);
-      if (receiverConstant == null || receiverConstant.isError) {
-        return receiverConstant;
+      if (receiverConstant == null) {
+        return null;
       }
       Operator node = send.selector;
       UnaryOperator operator = UnaryOperator.parse(node.source);
       UnaryOperation operation = constantSystem.lookupUnary(operator);
       if (operation == null) {
         reporter.internalError(send.selector, "Unexpected operator.");
       }
       ConstantValue folded = operation.fold(receiverConstant.value);
       if (folded == null) {
         return signalNotCompileTimeConstant(send);
       }
       return new AstConstant(
           context,
           send,
           new UnaryConstantExpression(operator, receiverConstant.expression),
           folded);
     } else if (send.isOperator && !send.isPostfix) {
       assert(send.argumentCount() == 1);
       AstConstant left = evaluate(send.receiver);
       AstConstant right = evaluate(send.argumentsNode.nodes.head);
-      if (left == null || left.isError) {
-        return left;
-      }
-      if (right == null || right.isError) {
-        return right;
+      if (left == null || right == null) {
+        return null;
       }
       ConstantValue leftValue = left.value;
       ConstantValue rightValue = right.value;
       Operator node = send.selector.asOperator();
       BinaryOperator operator = BinaryOperator.parse(node.source);
       ConstantValue folded = null;
       // operator is null when `node=="is"`
       if (operator != null) {
         switch (operator.kind) {
           case BinaryOperatorKind.EQ:
@@ skipping 27 matching lines @@
           send,
           new BinaryConstantExpression(
               left.expression, operator, right.expression),
           folded);
     }
     return signalNotCompileTimeConstant(send);
   }
 
   AstConstant visitConditional(Conditional node) {
     AstConstant condition = evaluate(node.condition);
-    if (condition == null || condition.isError) {
-      return condition;
+    if (condition == null) {
+      return null;
     } else if (!condition.value.isBool) {
       DartType conditionType = condition.value.getType(coreTypes);
       if (isEvaluatingConstant) {
         reporter.reportErrorMessage(node.condition, MessageKind.NOT_ASSIGNABLE,
             {'fromType': conditionType, 'toType': coreTypes.boolType});
         return new ErroneousAstConstant(context, node);
       }
       return null;
     }
     AstConstant thenExpression = evaluate(node.thenExpression);
     AstConstant elseExpression = evaluate(node.elseExpression);
-    if (thenExpression == null || thenExpression.isError) {
-      return thenExpression;
-    }
-    if (elseExpression == null || elseExpression.isError) {
-      return elseExpression;
+    if (thenExpression == null || elseExpression == null) {
+      return null;
     }
     BoolConstantValue boolCondition = condition.value;
     return new AstConstant(
         context,
         node,
         new ConditionalConstantExpression(condition.expression,
             thenExpression.expression, elseExpression.expression),
         boolCondition.primitiveValue
             ? thenExpression.value
             : elseExpression.value);
@@ skipping 147 matching lines @@
       Node node,
       InterfaceType type,
       ConstructorElement constructor,
       CallStructure callStructure,
       List<AstConstant> normalizedArguments,
       List<AstConstant> concreteArguments) {
     var firstArgument = normalizedArguments[0].value;
     ConstantValue defaultValue = normalizedArguments[1].value;
 
     if (firstArgument.isNull) {
-      return reportNotCompileTimeConstant(
+      reporter.reportErrorMessage(
           normalizedArguments[0].node, MessageKind.NULL_NOT_ALLOWED);
+      return null;
     }
 
     if (!firstArgument.isString) {
       DartType type = defaultValue.getType(coreTypes);
-      return reportNotCompileTimeConstant(
+      reporter.reportErrorMessage(
           normalizedArguments[0].node,
           MessageKind.NOT_ASSIGNABLE,
           {'fromType': type, 'toType': coreTypes.stringType});
+      return null;
     }
 
     if (constructor.isIntFromEnvironmentConstructor &&
         !(defaultValue.isNull || defaultValue.isInt)) {
       DartType type = defaultValue.getType(coreTypes);
-      return reportNotCompileTimeConstant(
+      reporter.reportErrorMessage(
           normalizedArguments[1].node,
           MessageKind.NOT_ASSIGNABLE,
           {'fromType': type, 'toType': coreTypes.intType});
+      return null;
     }
 
     if (constructor.isBoolFromEnvironmentConstructor &&
         !(defaultValue.isNull || defaultValue.isBool)) {
       DartType type = defaultValue.getType(coreTypes);
-      return reportNotCompileTimeConstant(
+      reporter.reportErrorMessage(
           normalizedArguments[1].node,
           MessageKind.NOT_ASSIGNABLE,
           {'fromType': type, 'toType': coreTypes.boolType});
+      return null;
     }
 
     if (constructor.isStringFromEnvironmentConstructor &&
         !(defaultValue.isNull || defaultValue.isString)) {
       DartType type = defaultValue.getType(coreTypes);
-      return reportNotCompileTimeConstant(
+      reporter.reportErrorMessage(
           normalizedArguments[1].node,
           MessageKind.NOT_ASSIGNABLE,
           {'fromType': type, 'toType': coreTypes.stringType});
+      return null;
     }
 
     String name = firstArgument.primitiveValue.slowToString();
     String value = compiler.fromEnvironment(name);
 
     AstConstant createEvaluatedConstant(ConstantValue value) {
       ConstantExpression expression;
       ConstantExpression name = concreteArguments[0].expression;
       ConstantExpression defaultValue;
       if (concreteArguments.length > 1) {
@@ skipping 63 matching lines @@
     ConstructorEvaluator evaluator =
         new ConstructorEvaluator(constructedType, target, handler, compiler);
     evaluator.evaluateConstructorFieldValues(normalizedArguments);
     Map<FieldElement, AstConstant> fieldConstants =
         evaluator.buildFieldConstants(target.enclosingClass);
     Map<FieldElement, ConstantValue> fieldValues =
         <FieldElement, ConstantValue>{};
     fieldConstants.forEach((FieldElement field, AstConstant astConstant) {
       fieldValues[field] = astConstant.value;
     });
-    for (AstConstant fieldValue in fieldConstants.values) {
-      if (fieldValue.isError) {
-        return fieldValue;
-      }
-    }
     return new AstConstant(
         context,
         node,
         new ConstructedConstantExpression(type, constructor, callStructure,
             concreteArguments.map((e) => e.expression).toList()),
         new ConstructedConstantValue(constructedType, fieldValues));
   }
 
   AstConstant visitParenthesizedExpression(ParenthesizedExpression node) {
     return node.expression.accept(this);
   }
 
-  AstConstant reportNotCompileTimeConstant(Node node, MessageKind message,
-      [Map arguments = const {}]) {
-    reporter.reportErrorMessage(node, message, arguments);
-    return new AstConstant(context, node, new ErroneousConstantExpression(),
-        new NullConstantValue());
-  }
+  AstConstant signalNotCompileTimeConstant(Node node,
+      {MessageKind message: MessageKind.NOT_A_COMPILE_TIME_CONSTANT}) {
+    if (isEvaluatingConstant) {
+      reporter.reportErrorMessage(node, message);
 
-  AstConstant signalNotCompileTimeConstant(Node node,
-      {MessageKind message: MessageKind.NOT_A_COMPILE_TIME_CONSTANT,
-      Map arguments: const {}}) {
-    if (isEvaluatingConstant) {
-      return reportNotCompileTimeConstant(node, message, arguments);
+      return new AstConstant(context, node, new ErroneousConstantExpression(),
+          new NullConstantValue());
     }
     // Else we don't need to do anything. The final handler is only
     // optimistically trying to compile constants. So it is normal that we
     // sometimes see non-compile time constants.
     // Simply return [:null:] which is used to propagate a failing
     // compile-time compilation.
     return null;
   }
 }
 
@@ skipping 230 matching lines @@
 
   factory AstConstant.fromDefaultValue(VariableElement element,
       ConstantExpression constant, ConstantValue value) {
     return new AstConstant(
         element,
         element.initializer != null ? element.initializer : element.node,
         constant,
         value);
   }
 
-  bool get isError => expression.kind == ConstantExpressionKind.ERRONEOUS;
-
   String toString() => expression.toString();
 }
 
 /// A synthetic constant used to recover from errors.
 class ErroneousAstConstant extends AstConstant {
   ErroneousAstConstant(Element element, Node node)
       : super(
             element,
             node,
             // TODO(johnniwinther): Return a [NonConstantValue] instead.
             new ErroneousConstantExpression(),
             new NullConstantValue());
 }
 
 class _CompilerEnvironment implements Environment {
   final Compiler compiler;
 
   _CompilerEnvironment(this.compiler);
 
   @override
   String readFromEnvironment(String name) {
     return compiler.fromEnvironment(name);
   }
 }