WIP: Compute constant expressions in resolution.

pkg/compiler/lib/src/constants/expressions.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library dart2js.constants.expressions;
 
 import '../common.dart';
 import '../constants/constant_system.dart';
 import '../core_types.dart';
 import '../dart_types.dart';
@@ skipping 55 matching lines @@
   int _hashCode;
 
   ConstantExpressionKind get kind;
 
   // TODO(johnniwinther): Unify precedence handled between constants, front-end
   // and back-end.
   int get precedence => 16;
 
   accept(ConstantExpressionVisitor visitor, [context]);
 
+  /// `true` if this is an erroneous constant expression.
+  bool get isErroneous => false;
+
   /// Substitute free variables using arguments.
   ConstantExpression apply(NormalizedArguments arguments) => this;
 
   /// Compute the [ConstantValue] for this expression using the [environment]
   /// and the [constantSystem].
   ConstantValue evaluate(Environment environment,
                          ConstantSystem constantSystem);
 
   /// Returns the type of this constant expression, if it is independent of the
   /// environment values.
@@ skipping 44 matching lines @@
                          ConstantSystem constantSystem) {
     // TODO(johnniwinther): Use non-constant values for errors.
     return new NonConstantValue();
   }
 
   @override
   int _computeHashCode() => 13;
 
   @override
   bool _equals(ErroneousConstantExpression other) => true;
+
+  @override
+  bool get isErroneous => true;
 }
 
 // TODO(johnniwinther): Avoid the need for this class.
 class SyntheticConstantExpression extends ConstantExpression {
   final SyntheticConstantValue value;
 
   SyntheticConstantExpression(this.value);
 
   @override
   ConstantValue evaluate(Environment environment,
@@ skipping 230 matching lines @@
 
   ConstantExpressionKind get kind => ConstantExpressionKind.MAP;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitMap(this, context);
   }
 
   @override
   ConstantValue evaluate(Environment environment,
                          ConstantSystem constantSystem) {
-    return constantSystem.createMap(environment.compiler,
+    /*return constantSystem.createMap(environment.compiler,
         type,
         keys.map((k) => k.evaluate(environment, constantSystem)).toList(),
-        values.map((v) => v.evaluate(environment, constantSystem)).toList());
+        values.map((v) => v.evaluate(environment, constantSystem)).toList());*/
+    Map<ConstantValue, ConstantValue> map = <ConstantValue, ConstantValue>{};
+
+    for (int i = 0; i < keys.length; i++) {
+      ConstantValue key = keys[i].evaluate(environment, constantSystem);
+      if (!key.isConstant) {
+        return new NonConstantValue();
+      }
+      ConstantValue value = values[i].evaluate(environment, constantSystem);
+      if (!value.isConstant) {
+        return new NonConstantValue();
+      }
+      if (map.containsKey(key)) {
+        environment.reportWarning(keys[i], MessageKind.EQUAL_MAP_ENTRY_KEY, {});
+      }
+      map[key] = value;
+    }
+    return constantSystem.createMap(
+          environment.compiler, type, map.keys.toList(), map.values.toList());
   }
 
   ConstantExpression apply(NormalizedArguments arguments) {
     return new MapConstantExpression(
         type,
         keys.map((k) => k.apply(arguments)).toList(),
         values.map((v) => v.apply(arguments)).toList());
   }
 
   @override
@@ skipping 27 matching lines @@
   final CallStructure callStructure;
   final List<ConstantExpression> arguments;
 
   ConstructedConstantExpression(
       this.type,
       this.target,
       this.callStructure,
       this.arguments) {
     assert(type.element == target.enclosingClass);
     assert(!arguments.contains(null));
+    assert(invariant(NO_LOCATION_SPANNABLE, target.isConst,
+        message: "Referenced constructor $target is not constant."));
   }
 
   ConstantExpressionKind get kind => ConstantExpressionKind.CONSTRUCTED;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitConstructed(this, context);
   }
 
   Map<FieldElement, ConstantExpression> computeInstanceFields() {
+    assert(invariant(target, target.constantConstructor != null,
+        message: "Constant constructor has not been computed for $target."));
     return target.constantConstructor.computeInstanceFields(
         arguments, callStructure);
   }
 
   InterfaceType computeInstanceType() {
     return target.constantConstructor.computeInstanceType(type);
   }
 
   ConstructedConstantExpression apply(NormalizedArguments arguments) {
     return new ConstructedConstantExpression(
         type, target, callStructure,
         this.arguments.map((a) => a.apply(arguments)).toList());
   }
 
   @override
   ConstantValue evaluate(Environment environment,
                          ConstantSystem constantSystem) {
-    Map<FieldElement, ConstantValue> fieldValues =
-        <FieldElement, ConstantValue>{};
-    computeInstanceFields().forEach(
-        (FieldElement field, ConstantExpression constant) {
-      fieldValues[field] = constant.evaluate(environment, constantSystem);
+    return environment.evaluateConstructor(target, () {
+      Map<FieldElement, ConstantExpression> fieldMap =
+          computeInstanceFields();
+      if (fieldMap == null) {
+        // An erroneous constant constructor was encountered in the super-chain.
+        return new NonConstantValue();
+      }
+      bool isValidAsConstant = true;
+      Map<FieldElement, ConstantValue> fieldValues =
+          <FieldElement, ConstantValue>{};
+      fieldMap.forEach((FieldElement field, ConstantExpression constant) {
+        ConstantValue value = constant.evaluate(environment, constantSystem);
+        assert(invariant(CURRENT_ELEMENT_SPANNABLE, value != null,
+            message: "No value computed for ${constant.getText()}."));
+        if (value.isConstant) {
+          fieldValues[field] = value;
+        } else {
+          isValidAsConstant = false;
+        }
+      });
+      if (isValidAsConstant) {
+        return new ConstructedConstantValue(computeInstanceType(), fieldValues);
+      } else {
+        return new NonConstantValue();
+      }
     });
-    return new ConstructedConstantValue(computeInstanceType(), fieldValues);
   }
 
   @override
   int _computeHashCode() {
     int hashCode =
         13 * type.hashCode +
         17 * target.hashCode +
         19 * callStructure.hashCode;
     for (ConstantExpression value in arguments) {
       hashCode ^= 23 * value.hashCode;
@@ skipping 26 matching lines @@
   }
 
   ConstantExpression apply(NormalizedArguments arguments) {
     return new ConcatenateConstantExpression(
         expressions.map((a) => a.apply(arguments)).toList());
   }
 
   @override
   ConstantValue evaluate(Environment environment,
                          ConstantSystem constantSystem) {
+    bool isValidAsConstant = true;
     DartString accumulator;
     for (ConstantExpression expression in expressions) {
       ConstantValue value = expression.evaluate(environment, constantSystem);
       DartString valueString;
-      if (value.isNum || value.isBool) {
+      if (!value.isConstant) {
+        isValidAsConstant = false;
+        continue;
+      } else if (value.isNum || value.isBool) {
         PrimitiveConstantValue primitive = value;
         valueString =
             new DartString.literal(primitive.primitiveValue.toString());
       } else if (value.isString) {
         PrimitiveConstantValue primitive = value;
         valueString = primitive.primitiveValue;
       } else {
         // TODO(johnniwinther): Specialize message to indicated that the problem
         // is not constness but the types of the const expressions.
-        return new NonConstantValue();
+        environment.reportError(
+            expression,
+            MessageKind.INVALID_CONSTANT_INTERPOLATION_TYPE,
+            {'constant': expression,
+             'type': value.getType(environment.coreTypes)});
+        isValidAsConstant = false;
+        continue;
       }
       if (accumulator == null) {
         accumulator = valueString;
       } else {
         accumulator = new DartString.concat(accumulator, valueString);
       }
     }
-    return constantSystem.createString(accumulator);
+    if (isValidAsConstant) {
+      return constantSystem.createString(accumulator);
+    }
+    return new NonConstantValue();
   }
 
   @override
   int _computeHashCode() {
     int hashCode = 17 * expressions.length;
     for (ConstantExpression value in expressions) {
       hashCode ^= 19 * value.hashCode;
     }
     return hashCode;
   }
@@ skipping 27 matching lines @@
   int _computeHashCode() => 13 * name.hashCode;
 
   @override
   bool _equals(SymbolConstantExpression other) {
     return name == other.name;
   }
 
   @override
   ConstantValue evaluate(Environment environment,
                          ConstantSystem constantSystem) {
-    // TODO(johnniwinther): Implement this.
-    throw new UnsupportedError('SymbolConstantExpression.evaluate');
+    return constantSystem.createSymbol(environment.compiler, name);
   }
 
   @override
   DartType getKnownType(CoreTypes coreTypes) => coreTypes.symbolType;
 }
 
 /// Type literal.
 class TypeConstantExpression extends ConstantExpression {
   /// Either [DynamicType] or a raw [GenericType].
   final DartType type;
@@ skipping 23 matching lines @@
   }
 
   @override
   DartType getKnownType(CoreTypes coreTypes) => coreTypes.typeType;
 }
 
 /// Reference to a constant local, top-level, or static variable.
 class VariableConstantExpression extends ConstantExpression {
   final VariableElement element;
 
-  VariableConstantExpression(this.element);
+  VariableConstantExpression(this.element) {
+    /*assert(invariant(NO_LOCATION_SPANNABLE, element.isConst,
+        message: "Referenced variable $element is not constant."));*/
+  }
 
   ConstantExpressionKind get kind => ConstantExpressionKind.VARIABLE;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitVariable(this, context);
   }
 
   @override
   ConstantValue evaluate(Environment environment,
                          ConstantSystem constantSystem) {
-    return element.constant.evaluate(environment, constantSystem);
+    return environment.evaluateVariable(element, () {
+      return element.constant.evaluate(environment, constantSystem);
+    });
   }
 
   @override
   int _computeHashCode() => 13 * element.hashCode;
 
   @override
   bool _equals(VariableConstantExpression other) {
     return element == other.element;
   }
 }
@@ skipping 40 matching lines @@
 
   ConstantExpressionKind get kind => ConstantExpressionKind.BINARY;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitBinary(this, context);
   }
 
   @override
   ConstantValue evaluate(Environment environment,
                          ConstantSystem constantSystem) {
-    return constantSystem.lookupBinary(operator).fold(
-        left.evaluate(environment, constantSystem),
-        right.evaluate(environment, constantSystem));
+    ConstantValue leftValue = left.evaluate(environment, constantSystem);
+    ConstantValue rightValue = right.evaluate(environment, constantSystem);
+    if (!leftValue.isConstant ||
+        !rightValue.isConstant) {
+      return new NonConstantValue();
+    }
+    ConstantExpressionChecker checker =
+        new ConstantExpressionChecker(environment);
+    bool isValid = checker.checkBinaryExpression(
+        this,
+        checker.createInfo(left, leftValue),
+        operator,
+        checker.createInfo(right, rightValue));
+
+    BinaryOperation operation = constantSystem.lookupBinary(operator);
+    assert(invariant(NO_LOCATION_SPANNABLE, operation != null,
+        message: "No binary operation for $operator."));
+    ConstantValue value = operation.fold(leftValue, rightValue);
+    if (value != null) {
+      return value;
+    }
+    assert(!isValid);
+    return new NonConstantValue();
   }
 
   ConstantExpression apply(NormalizedArguments arguments) {
     return new BinaryConstantExpression(
         left.apply(arguments),
         operator,
         right.apply(arguments));
   }
 
   DartType getKnownType(CoreTypes coreTypes) {
     DartType knownLeftType = left.getKnownType(coreTypes);
     DartType knownRightType = right.getKnownType(coreTypes);
     switch (operator.kind) {
       case BinaryOperatorKind.EQ:
       case BinaryOperatorKind.NOT_EQ:
       case BinaryOperatorKind.LOGICAL_AND:
       case BinaryOperatorKind.LOGICAL_OR:
       case BinaryOperatorKind.GT:
       case BinaryOperatorKind.LT:
       case BinaryOperatorKind.GTEQ:
       case BinaryOperatorKind.LTEQ:
         return coreTypes.boolType;
       case BinaryOperatorKind.ADD:
-        if (knownLeftType == coreTypes.stringType) {
-          assert(knownRightType == coreTypes.stringType);
+        if (knownLeftType == coreTypes.stringType &&
+            knownRightType == coreTypes.stringType) {
           return coreTypes.stringType;
         } else if (knownLeftType == coreTypes.intType &&
                    knownRightType == coreTypes.intType) {
           return coreTypes.intType;
+        } else if ((knownLeftType == coreTypes.intType ||
+                    knownLeftType == coreTypes.doubleType) &&
+                   (knownRightType == coreTypes.intType ||
+                    knownRightType == coreTypes.doubleType)) {
+          return coreTypes.doubleType;
         }
-        assert(knownLeftType == coreTypes.doubleType ||
-               knownRightType == coreTypes.doubleType);
-        return coreTypes.doubleType;
+        return null;
       case BinaryOperatorKind.SUB:
       case BinaryOperatorKind.MUL:
       case BinaryOperatorKind.MOD:
         if (knownLeftType == coreTypes.intType &&
             knownRightType == coreTypes.intType) {
           return coreTypes.intType;
+        } else if ((knownLeftType == coreTypes.intType ||
+                    knownLeftType == coreTypes.doubleType) &&
+                   (knownRightType == coreTypes.intType ||
+                    knownRightType == coreTypes.doubleType)) {
+          return coreTypes.doubleType;
         }
-        assert(knownLeftType == coreTypes.doubleType ||
-               knownRightType == coreTypes.doubleType);
-        return coreTypes.doubleType;
+        return null;
       case BinaryOperatorKind.DIV:
         return coreTypes.doubleType;
       case BinaryOperatorKind.IDIV:
         return coreTypes.intType;
       case BinaryOperatorKind.AND:
       case BinaryOperatorKind.OR:
       case BinaryOperatorKind.XOR:
       case BinaryOperatorKind.SHR:
       case BinaryOperatorKind.SHL:
         return coreTypes.intType;
       case BinaryOperatorKind.IF_NULL:
       case BinaryOperatorKind.INDEX:
         throw new UnsupportedError(
             'Unexpected constant binary operator: $operator');
     }
   }
 
-
   int get precedence => PRECEDENCE_MAP[operator.kind];
 
   @override
   int _computeHashCode() {
     return 13 * operator.hashCode +
            17 * left.hashCode +
            19 * right.hashCode;
   }
 
   @override
@@ skipping 35 matching lines @@
 
   ConstantExpressionKind get kind => ConstantExpressionKind.IDENTICAL;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitIdentical(this, context);
   }
 
   @override
   ConstantValue evaluate(Environment environment,
                          ConstantSystem constantSystem) {
-    return constantSystem.identity.fold(
-        left.evaluate(environment, constantSystem),
-        right.evaluate(environment, constantSystem));
+    ConstantValue leftValue = left.evaluate(environment, constantSystem);
+    ConstantValue rightValue = right.evaluate(environment, constantSystem);
+    if (leftValue.isConstant && rightValue.isConstant) {
+      return constantSystem.identity.fold(leftValue, rightValue);
+    }
+    return new NonConstantValue();
   }
 
   ConstantExpression apply(NormalizedArguments arguments) {
     return new IdenticalConstantExpression(
         left.apply(arguments),
         right.apply(arguments));
   }
 
   int get precedence => 15;
 
@@ skipping 24 matching lines @@
 
   ConstantExpressionKind get kind => ConstantExpressionKind.UNARY;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitUnary(this, context);
   }
 
   @override
   ConstantValue evaluate(Environment environment,
                          ConstantSystem constantSystem) {
-    return constantSystem.lookupUnary(operator).fold(
-        expression.evaluate(environment, constantSystem));
+    ConstantValue expressionValue =
+        expression.evaluate(environment, constantSystem);
+    ConstantExpressionChecker checker =
+        new ConstantExpressionChecker(environment);
+    bool isValidAsConstant = checker.checkUnary(
+        operator, checker.createInfo(expression, expressionValue));
+    if (isValidAsConstant) {
+      return constantSystem.lookupUnary(operator).fold(expressionValue);
+    }
+    return new NonConstantValue();
   }
 
   ConstantExpression apply(NormalizedArguments arguments) {
     return new UnaryConstantExpression(
         operator,
         expression.apply(arguments));
   }
 
   int get precedence => PRECEDENCE_MAP[operator.kind];
 
@@ skipping 106 matching lines @@
 
   @override
   ConstantValue evaluate(Environment environment,
                          ConstantSystem constantSystem) {
     ConstantValue conditionValue =
         condition.evaluate(environment, constantSystem);
     ConstantValue trueValue =
         trueExp.evaluate(environment, constantSystem);
     ConstantValue falseValue =
         falseExp.evaluate(environment, constantSystem);
-    if (conditionValue.isTrue) {
+    ConstantExpressionChecker checker =
+        new ConstantExpressionChecker(environment);
+    bool isValidAsConstant = checker.checkConditional(
+        checker.createInfo(condition, conditionValue));
+    if (!isValidAsConstant) {
+      return new NonConstantValue();
+    } else if (conditionValue.isTrue) {
       return trueValue;
-    } else if (conditionValue.isFalse) {
+    } else {
+      assert(conditionValue.isFalse);
       return falseValue;
-    } else {
-      return new NonConstantValue();
     }
   }
 
   @override
   DartType getKnownType(CoreTypes coreTypes) {
     DartType trueType = trueExp.getKnownType(coreTypes);
     DartType falseType = falseExp.getKnownType(coreTypes);
     if (trueType == falseType) {
       return trueType;
     }
@@ skipping 104 matching lines @@
                          ConstantSystem constantSystem) {
     ConstantValue nameConstantValue =
         name.evaluate(environment, constantSystem);
     ConstantValue defaultConstantValue;
     if (defaultValue != null) {
       defaultConstantValue =
           defaultValue.evaluate(environment, constantSystem);
     } else {
       defaultConstantValue = constantSystem.createBool(false);
     }
-    if (!nameConstantValue.isString) {
+    ConstantExpressionChecker checker =
+        new ConstantExpressionChecker(environment);
+    bool isValidAsConstant = checker.checkBoolFromEnvironment(
+        checker.createInfo(name, nameConstantValue),
+        checker.createInfo(defaultValue, defaultConstantValue));
+    if (!isValidAsConstant) {
       return new NonConstantValue();
     }
     StringConstantValue nameStringConstantValue = nameConstantValue;
     String text = environment.readFromEnvironment(
         nameStringConstantValue.primitiveValue.slowToString());
     if (text == 'true') {
       return constantSystem.createBool(true);
     } else if (text == 'false') {
       return constantSystem.createBool(false);
     } else {
@@ skipping 33 matching lines @@
                          ConstantSystem constantSystem) {
     ConstantValue nameConstantValue =
         name.evaluate(environment, constantSystem);
     ConstantValue defaultConstantValue;
     if (defaultValue != null) {
       defaultConstantValue =
           defaultValue.evaluate(environment, constantSystem);
     } else {
       defaultConstantValue = constantSystem.createNull();
     }
-    if (!nameConstantValue.isString) {
+    ConstantExpressionChecker checker =
+        new ConstantExpressionChecker(environment);
+    bool isValidAsConstant = checker.checkIntFromEnvironment(
+        checker.createInfo(name, nameConstantValue),
+        checker.createInfo(defaultValue, defaultConstantValue));
+    if (!isValidAsConstant) {
       return new NonConstantValue();
     }
     StringConstantValue nameStringConstantValue = nameConstantValue;
     String text = environment.readFromEnvironment(
         nameStringConstantValue.primitiveValue.slowToString());
     int value;
     if (text != null) {
       value = int.parse(text, onError: (_) => null);
     }
     if (value == null) {
@@ skipping 35 matching lines @@
                          ConstantSystem constantSystem) {
     ConstantValue nameConstantValue =
         name.evaluate(environment, constantSystem);
     ConstantValue defaultConstantValue;
     if (defaultValue != null) {
       defaultConstantValue =
           defaultValue.evaluate(environment, constantSystem);
     } else {
       defaultConstantValue = constantSystem.createNull();
     }
-    if (!nameConstantValue.isString) {
+    ConstantExpressionChecker checker =
+        new ConstantExpressionChecker(environment);
+    bool isValidAsConstant = checker.checkStringFromEnvironment(
+        checker.createInfo(name, nameConstantValue),
+        checker.createInfo(defaultValue, defaultConstantValue));
+    if (!isValidAsConstant) {
       return new NonConstantValue();
     }
     StringConstantValue nameStringConstantValue = nameConstantValue;
     String text = environment.readFromEnvironment(
         nameStringConstantValue.primitiveValue.slowToString());
     if (text == null) {
       return defaultConstantValue;
     } else {
       return constantSystem.createString(new DartString.literal(text));
     }
@@ skipping 346 matching lines @@
     sb.write('const String.fromEnvironment(');
     visit(exp.name);
     if (exp.defaultValue != null) {
       sb.write(', defaultValue: ');
       visit(exp.defaultValue);
     }
     sb.write(')');
   }
 
   String toString() => sb.toString();
-}
+}