Add ConstantExpression.evaluate.

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 '../dart2jslib.dart' show assertDebugMode;
+import '../constants/constant_system.dart';
+import '../dart2jslib.dart' show assertDebugMode, Compiler;
 import '../dart_types.dart';
 import '../elements/elements.dart' show
     ConstructorElement,
     Element,
     FieldElement,
     FunctionElement,
     VariableElement;
 import '../resolution/operators.dart';
+import '../tree/tree.dart' show DartString;
 import '../universe/universe.dart' show CallStructure;
 import 'values.dart';
 
 enum ConstantExpressionKind {
   BINARY,
   BOOL,
   BOOL_FROM_ENVIRONMENT,
   CONCATENATE,
   CONDITIONAL,
   CONSTRUCTED,
@@ skipping 10 matching lines @@
   STRING_FROM_ENVIRONMENT,
   SYMBOL,
   TYPE,
   UNARY,
   VARIABLE,
 
   POSITIONAL_REFERENCE,
   NAMED_REFERENCE,
 }
 
+/// Environment used for evaluating constant expressions.
+abstract class Environment {
+  // TODO(johnniwinther): Replace this with [CoreTypes] and maybe [Backend].
+  Compiler get compiler;
+
+  /// Read environments string passed in using the '-Dname=value' option.
+  String readFromEnvironment(String name);
+}
+
 /// The normalized arguments passed to a const constructor computed from the
 /// actual [arguments] and the [defaultValues] of the called construrctor.
 class Arguments {
   final Map<dynamic/*int|String*/, ConstantExpression> defaultValues;
   final CallStructure callStructure;
   final List<ConstantExpression> arguments;
 
   Arguments(this.defaultValues, this.callStructure, this.arguments);
 
   /// Returns the normalized named argument [name].
@@ skipping 187 matching lines @@
 
   // TODO(johnniwinther): Unify precedence handled between constants, front-end
   // and back-end.
   int get precedence => 16;
 
   accept(ConstantExpressionVisitor visitor, [context]);
 
   /// Substitute free variables using arguments.
   ConstantExpression apply(Arguments arguments) => this;
 
+  /// Compute the [ConstantValue] for this expression using the [environment]
+  /// and the [constantSystem].
+  ConstantValue evaluate(Environment environment,
+                         ConstantSystem constantSystem);
+
   String getText() {
     ConstExpPrinter printer = new ConstExpPrinter();
     accept(printer);
     return printer.toString();
   }
 
   int _computeHashCode();
 
   int get hashCode {
     if (_hashCode == null) {
@@ skipping 23 matching lines @@
 class ErroneousConstantExpression extends ConstantExpression {
   final PrimitiveConstantValue value = new NullConstantValue();
 
   ConstantExpressionKind get kind => ConstantExpressionKind.ERRONEOUS;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     // Do nothing. This is an error.
   }
 
   @override
+  ConstantValue evaluate(Environment environment,
+                         ConstantSystem constantSystem) {
+    // TODO(johnniwinther): Use non-constant values for errors.
+    return value;
+  }
+
+  @override
   int _computeHashCode() => 13;
 
   @override
   bool _equals(ErroneousConstantExpression other) => true;
 }
 
 /// A boolean, int, double, string, or null constant.
 abstract class PrimitiveConstantExpression extends ConstantExpression {
   final PrimitiveConstantValue value;
 
@@ skipping 10 matching lines @@
   BoolConstantExpression(this.primitiveValue,
                          PrimitiveConstantValue value) : super(value);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.BOOL;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitBool(this, context);
   }
 
   @override
+  ConstantValue evaluate(Environment environment,
+                         ConstantSystem constantSystem) {
+    return constantSystem.createBool(primitiveValue);
+  }
+
+  @override
   int _computeHashCode() => 13 * primitiveValue.hashCode;
 
   @override
   bool _equals(BoolConstantExpression other) {
     return primitiveValue == other.primitiveValue;
   }
 }
 
 /// Integer literal constant.
 class IntConstantExpression extends PrimitiveConstantExpression {
   final int primitiveValue;
 
   IntConstantExpression(this.primitiveValue,
                         PrimitiveConstantValue value) : super(value);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.INT;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitInt(this, context);
   }
 
   @override
+  ConstantValue evaluate(Environment environment,
+                         ConstantSystem constantSystem) {
+    return constantSystem.createInt(primitiveValue);
+  }
+
+  @override
   int _computeHashCode() => 17 * primitiveValue.hashCode;
 
   @override
   bool _equals(IntConstantExpression other) {
     return primitiveValue == other.primitiveValue;
   }
 }
 
 /// Double literal constant.
 class DoubleConstantExpression extends PrimitiveConstantExpression {
   final double primitiveValue;
 
   DoubleConstantExpression(this.primitiveValue,
                            PrimitiveConstantValue value) : super(value);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.DOUBLE;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitDouble(this, context);
   }
 
   @override
+  ConstantValue evaluate(Environment environment,
+                         ConstantSystem constantSystem) {
+    return constantSystem.createDouble(primitiveValue);
+  }
+
+  @override
   int _computeHashCode() => 19 * primitiveValue.hashCode;
 
   @override
   bool _equals(DoubleConstantExpression other) {
     return primitiveValue == other.primitiveValue;
   }
 }
 
 /// String literal constant.
 class StringConstantExpression extends PrimitiveConstantExpression {
   final String primitiveValue;
 
   StringConstantExpression(this.primitiveValue,
                            PrimitiveConstantValue value) : super(value);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.STRING;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitString(this, context);
   }
 
   @override
+  ConstantValue evaluate(Environment environment,
+                         ConstantSystem constantSystem) {
+    return constantSystem.createString(new DartString.literal(primitiveValue));
+  }
+
+  @override
   int _computeHashCode() => 23 * primitiveValue.hashCode;
 
   @override
   bool _equals(StringConstantExpression other) {
     return primitiveValue == other.primitiveValue;
   }
 }
 
 /// Null literal constant.
 class NullConstantExpression extends PrimitiveConstantExpression {
   NullConstantExpression(PrimitiveConstantValue value) : super(value);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.NULL;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitNull(this, context);
   }
 
+  @override
+  ConstantValue evaluate(Environment environment,
+                         ConstantSystem constantSystem) {
+    return constantSystem.createNull();
+  }
+
   get primitiveValue => null;
 
   @override
   int _computeHashCode() => 29;
 
   @override
   bool _equals(NullConstantExpression other) => true;
 }
 
 /// Literal list constant.
 class ListConstantExpression extends ConstantExpression {
   final ListConstantValue value;
   final InterfaceType type;
   final List<ConstantExpression> values;
 
   ListConstantExpression(this.value, this.type, this.values);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.LIST;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitList(this, context);
   }
 
   @override
+  ConstantValue evaluate(Environment environment,
+                         ConstantSystem constantSystem) {
+    return constantSystem.createList(type,
+        values.map((v) => v.evaluate(environment, constantSystem)).toList());
+  }
+
   ConstantExpression apply(Arguments arguments) {
     return new ListConstantExpression(null, type,
         values.map((v) => v.apply(arguments)).toList());
   }
 
+  @override
   int _computeHashCode() {
     int hashCode = 13 * type.hashCode + 17 * values.length;
     for (ConstantExpression value in values) {
       hashCode ^= 19 * value.hashCode;
     }
     return hashCode;
   }
 
   @override
   bool _equals(ListConstantExpression other) {
@@ skipping 15 matching lines @@
 
   MapConstantExpression(this.value, this.type, this.keys, this.values);
 
   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,
+        type,
+        keys.map((k) => k.evaluate(environment, constantSystem)).toList(),
+        values.map((v) => v.evaluate(environment, constantSystem)).toList());
+  }
+
   ConstantExpression apply(Arguments arguments) {
     return new MapConstantExpression(null, type,
         keys.map((k) => k.apply(arguments)).toList(),
         values.map((v) => v.apply(arguments)).toList());
   }
 
+  @override
   int _computeHashCode() {
     int hashCode = 13 * type.hashCode + 17 * values.length;
     for (ConstantExpression value in values) {
       hashCode ^= 19 * value.hashCode;
     }
     return hashCode;
   }
 
   @override
   bool _equals(MapConstantExpression other) {
@@ skipping 39 matching lines @@
   InterfaceType computeInstanceType() {
     return target.constantConstructor.computeInstanceType(type);
   }
 
   ConstructedConstantExpression apply(Arguments arguments) {
     return new ConstructedConstantExpression(null,
         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 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;
     }
     return hashCode;
   }
@@ skipping 22 matching lines @@
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitConcatenate(this, context);
   }
 
   ConstantExpression apply(Arguments arguments) {
     return new ConcatenateConstantExpression(null,
         expressions.map((a) => a.apply(arguments)).toList());
   }
 
   @override
+  ConstantValue evaluate(Environment environment,
+                         ConstantSystem constantSystem) {
+    DartString accumulator;
+    for (ConstantExpression expression in expressions) {
+      ConstantValue value = expression.evaluate(environment, constantSystem);
+      DartString valueString;
+      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();
+      }
+      if (accumulator == null) {
+        accumulator = valueString;
+      } else {
+        accumulator = new DartString.concat(accumulator, valueString);
+      }
+    }
+    return constantSystem.createString(accumulator);
+  }
+
+  @override
   int _computeHashCode() {
     int hashCode = 17 * expressions.length;
     for (ConstantExpression value in expressions) {
       hashCode ^= 19 * value.hashCode;
     }
     return hashCode;
   }
 
   @override
   bool _equals(ConcatenateConstantExpression other) {
@@ skipping 18 matching lines @@
     return visitor.visitSymbol(this, context);
   }
 
   @override
   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');
+  }
 }
 
 /// Type literal.
 class TypeConstantExpression extends ConstantExpression {
   final TypeConstantValue value;
   /// Either [DynamicType] or a raw [GenericType].
   final DartType type;
 
   TypeConstantExpression(this.value, this.type) {
     assert(type is GenericType || type is DynamicType);
   }
 
   ConstantExpressionKind get kind => ConstantExpressionKind.TYPE;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitType(this, context);
   }
 
   @override
+  ConstantValue evaluate(Environment environment,
+                         ConstantSystem constantSystem) {
+    return constantSystem.createType(environment.compiler, type);
+  }
+
+  @override
   int _computeHashCode() => 13 * type.hashCode;
 
   @override
   bool _equals(TypeConstantExpression other) {
     return type == other.type;
   }
 }
 
 /// Reference to a constant local, top-level, or static variable.
 class VariableConstantExpression extends ConstantExpression {
   final ConstantValue value;
   final VariableElement element;
 
   VariableConstantExpression(this.value, this.element);
 
   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);
+  }
+
+  @override
   int _computeHashCode() => 13 * element.hashCode;
 
   @override
   bool _equals(VariableConstantExpression other) {
     return element == other.element;
   }
 }
 
 /// Reference to a top-level or static function.
 class FunctionConstantExpression extends ConstantExpression {
   final FunctionConstantValue value;
   final FunctionElement element;
 
   FunctionConstantExpression(this.value, this.element);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.FUNCTION;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitFunction(this, context);
   }
 
   @override
+  ConstantValue evaluate(Environment environment,
+                         ConstantSystem constantSystem) {
+    return new FunctionConstantValue(element);
+  }
+
+  @override
   int _computeHashCode() => 13 * element.hashCode;
 
   @override
   bool _equals(FunctionConstantExpression other) {
     return element == other.element;
   }
 }
 
 /// A constant binary expression like `a * b`.
 class BinaryConstantExpression extends ConstantExpression {
   final ConstantValue value;
   final ConstantExpression left;
   final BinaryOperator operator;
   final ConstantExpression right;
 
   BinaryConstantExpression(this.value, this.left, this.operator, this.right) {
     assert(PRECEDENCE_MAP[operator.kind] != null);
   }
 
   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));
+  }
+
   ConstantExpression apply(Arguments arguments) {
     return new BinaryConstantExpression(
         value,
         left.apply(arguments),
         operator,
         right.apply(arguments));
   }
 
   int get precedence => PRECEDENCE_MAP[operator.kind];
 
@@ skipping 41 matching lines @@
   final ConstantExpression right;
 
   IdenticalConstantExpression(this.value, this.left, this.right);
 
   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));
+  }
+
   ConstantExpression apply(Arguments arguments) {
     return new IdenticalConstantExpression(
         value,
         left.apply(arguments),
         right.apply(arguments));
   }
 
   int get precedence => 15;
 
   @override
@@ skipping 18 matching lines @@
   UnaryConstantExpression(this.value, this.operator, this.expression) {
     assert(PRECEDENCE_MAP[operator.kind] != null);
   }
 
   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));
+  }
+
   ConstantExpression apply(Arguments arguments) {
     return new UnaryConstantExpression(
         value,
         operator,
         expression.apply(arguments));
   }
 
   int get precedence => PRECEDENCE_MAP[operator.kind];
 
   @override
@@ skipping 49 matching lines @@
            17 * trueExp.hashCode +
            19 * falseExp.hashCode;
   }
 
   @override
   bool _equals(ConditionalConstantExpression other) {
     return condition == other.condition &&
            trueExp == other.trueExp &&
            falseExp == other.falseExp;
   }
+
+  @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) {
+      return trueValue;
+    } else if (conditionValue.isFalse) {
+      return falseValue;
+    } else {
+      return new NonConstantValue();
+    }
+  }
 }
 
 /// A reference to a position parameter.
 class PositionalArgumentReference extends ConstantExpression {
   final int index;
 
   PositionalArgumentReference(this.index);
 
   ConstantExpressionKind get kind {
     return ConstantExpressionKind.POSITIONAL_REFERENCE;
   }
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitPositional(this, context);
   }
 
   ConstantValue get value {
     throw new UnsupportedError('PositionalArgumentReference.value');
   }
 
   ConstantExpression apply(Arguments arguments) {
     return arguments.getPositionalArgument(index);
   }
 
   @override
   int _computeHashCode() => 13 * index.hashCode;
 
   @override
   bool _equals(PositionalArgumentReference other) => index == other.index;
+
+  @override
+  ConstantValue evaluate(Environment environment,
+                         ConstantSystem constantSystem) {
+    throw new UnsupportedError('PositionalArgumentReference.evaluate');
+  }
 }
 
 /// A reference to a named parameter.
 class NamedArgumentReference extends ConstantExpression {
   final String name;
 
   NamedArgumentReference(this.name);
 
   ConstantExpressionKind get kind {
     return ConstantExpressionKind.NAMED_REFERENCE;
   }
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitNamed(this, context);
   }
 
   ConstantValue get value {
     throw new UnsupportedError('NamedArgumentReference.value');
   }
 
   ConstantExpression apply(Arguments arguments) {
     return arguments.getNamedArgument(name);
   }
 
   @override
   int _computeHashCode() => 13 * name.hashCode;
 
   @override
   bool _equals(NamedArgumentReference other) => name == other.name;
+
+  @override
+  ConstantValue evaluate(Environment environment,
+                         ConstantSystem constantSystem) {
+    throw new UnsupportedError('NamedArgumentReference.evaluate');
+  }
 }
 
 abstract class FromEnvironmentConstantExpression extends ConstantExpression {
   final ConstantValue value;
   final String name;
   final ConstantExpression defaultValue;
 
   FromEnvironmentConstantExpression(this.value, this.name, this.defaultValue);
 
   @override
@@ skipping 20 matching lines @@
       : super(value, name, defaultValue);
 
   ConstantExpressionKind get kind {
     return ConstantExpressionKind.BOOL_FROM_ENVIRONMENT;
   }
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitBoolFromEnvironment(this, context);
   }
 
+  @override
+  ConstantValue evaluate(Environment environment,
+                         ConstantSystem constantSystem) {
+    String text = environment.readFromEnvironment(name);
+    if (text == 'true') {
+      return constantSystem.createBool(true);
+    } else if (text == 'false') {
+      return constantSystem.createBool(false);
+    } else {
+      return defaultValue.evaluate(environment, constantSystem);
+    }
+  }
+
   ConstantExpression apply(Arguments arguments) {
     return new BoolFromEnvironmentConstantExpression(
         null, name, defaultValue.apply(arguments));
   }
 }
 
 /// A `const int.fromEnvironment` constant.
 class IntFromEnvironmentConstantExpression
     extends FromEnvironmentConstantExpression {
 
   IntFromEnvironmentConstantExpression(
       ConstantValue value,
       String name,
       ConstantExpression defaultValue)
       : super(value, name, defaultValue);
 
   ConstantExpressionKind get kind {
     return ConstantExpressionKind.INT_FROM_ENVIRONMENT;
   }
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitIntFromEnvironment(this, context);
   }
 
+  @override
+  ConstantValue evaluate(Environment environment,
+                         ConstantSystem constantSystem) {
+    int value;
+    String text = environment.readFromEnvironment(name);
+    if (text != null) {
+      value = int.parse(text, onError: (_) => null);
+    }
+    if (value == null) {
+      return defaultValue.evaluate(environment, constantSystem);
+    } else {
+      return constantSystem.createInt(value);
+    }
+  }
+
   ConstantExpression apply(Arguments arguments) {
     return new IntFromEnvironmentConstantExpression(
         null, name, defaultValue.apply(arguments));
   }
 }
 
 /// A `const String.fromEnvironment` constant.
 class StringFromEnvironmentConstantExpression
     extends FromEnvironmentConstantExpression {
 
   StringFromEnvironmentConstantExpression(
       ConstantValue value,
       String name,
       ConstantExpression defaultValue)
       : super(value, name, defaultValue);
 
   ConstantExpressionKind get kind {
     return ConstantExpressionKind.STRING_FROM_ENVIRONMENT;
   }
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitStringFromEnvironment(this, context);
   }
 
+  @override
+  ConstantValue evaluate(Environment environment,
+                         ConstantSystem constantSystem) {
+    String text = environment.readFromEnvironment(name);
+    if (text == null) {
+      return defaultValue.evaluate(environment, constantSystem);
+    } else {
+      return constantSystem.createString(new DartString.literal(text));
+    }
+  }
 
   ConstantExpression apply(Arguments arguments) {
     return new StringFromEnvironmentConstantExpression(
         null, name, defaultValue.apply(arguments));
   }
 }
 
 abstract class ConstantExpressionVisitor<R, A> {
   const ConstantExpressionVisitor();
 
@@ skipping 262 matching lines @@
     sb.write(')');
   }
 
   @override
   visitStringFromEnvironment(StringFromEnvironmentConstantExpression exp, [_]) {
     sb.write('const String.fromEnvironment("${exp.name}", defaultValue: ');
     visit(exp.defaultValue);
     sb.write(')');
   }
 }