Handle more constants in Constantifier

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 '../common_elements.dart';
 import '../elements/types.dart';
@@ skipping 54 matching lines @@
   int get precedence => 16;
 
   accept(ConstantExpressionVisitor visitor, [context]);
 
   /// 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);
+      EvaluationEnvironment environment, ConstantSystem constantSystem);
 
   /// Returns the type of this constant expression, if it is independent of the
   /// environment values.
   DartType getKnownType(CommonElements commonElements) => null;
 
   /// Returns a text string resembling the Dart code creating this constant.
   String toDartText() {
     ConstExpPrinter printer = new ConstExpPrinter();
     accept(printer);
     return printer.toString();
@@ skipping 49 matching lines @@
 /// A synthetic constant used to recover from errors.
 class ErroneousConstantExpression extends ConstantExpression {
   ConstantExpressionKind get kind => ConstantExpressionKind.ERRONEOUS;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     // Do nothing. This is an error.
   }
 
   @override
   ConstantValue evaluate(
-      Environment environment, ConstantSystem constantSystem) {
+      EvaluationEnvironment environment, ConstantSystem constantSystem) {
     // TODO(johnniwinther): Use non-constant values for errors.
     return new NonConstantValue();
   }
 
   @override
   void _createStructuredText(StringBuffer sb) {
     sb.write('Erroneous()');
   }
 
   @override
   int _computeHashCode() => 13;
 
   @override
   bool _equals(ErroneousConstantExpression other) => true;
 }
 
 // TODO(johnniwinther): Avoid the need for this class.
 class SyntheticConstantExpression extends ConstantExpression {
   final SyntheticConstantValue value;
 
   SyntheticConstantExpression(this.value);
 
   @override
   ConstantValue evaluate(
-      Environment environment, ConstantSystem constantSystem) {
+      EvaluationEnvironment environment, ConstantSystem constantSystem) {
     return value;
   }
 
   @override
   void _createStructuredText(StringBuffer sb) {
     sb.write('Synthetic(value=${value.toStructuredText()})');
   }
 
   @override
   int _computeHashCode() => 13 * value.hashCode;
@@ skipping 31 matching lines @@
     return visitor.visitBool(this, context);
   }
 
   @override
   void _createStructuredText(StringBuffer sb) {
     sb.write('Bool(value=${primitiveValue})');
   }
 
   @override
   ConstantValue evaluate(
-      Environment environment, ConstantSystem constantSystem) {
+      EvaluationEnvironment environment, ConstantSystem constantSystem) {
     return constantSystem.createBool(primitiveValue);
   }
 
   @override
   int _computeHashCode() => 13 * primitiveValue.hashCode;
 
   @override
   bool _equals(BoolConstantExpression other) {
     return primitiveValue == other.primitiveValue;
   }
@@ skipping 15 matching lines @@
     return visitor.visitInt(this, context);
   }
 
   @override
   void _createStructuredText(StringBuffer sb) {
     sb.write('Int(value=${primitiveValue})');
   }
 
   @override
   ConstantValue evaluate(
-      Environment environment, ConstantSystem constantSystem) {
+      EvaluationEnvironment environment, ConstantSystem constantSystem) {
     return constantSystem.createInt(primitiveValue);
   }
 
   @override
   int _computeHashCode() => 17 * primitiveValue.hashCode;
 
   @override
   bool _equals(IntConstantExpression other) {
     return primitiveValue == other.primitiveValue;
   }
@@ skipping 15 matching lines @@
     return visitor.visitDouble(this, context);
   }
 
   @override
   void _createStructuredText(StringBuffer sb) {
     sb.write('Double(value=${primitiveValue})');
   }
 
   @override
   ConstantValue evaluate(
-      Environment environment, ConstantSystem constantSystem) {
+      EvaluationEnvironment environment, ConstantSystem constantSystem) {
     return constantSystem.createDouble(primitiveValue);
   }
 
   @override
   int _computeHashCode() => 19 * primitiveValue.hashCode;
 
   @override
   bool _equals(DoubleConstantExpression other) {
     return primitiveValue == other.primitiveValue;
   }
@@ skipping 15 matching lines @@
     return visitor.visitString(this, context);
   }
 
   @override
   void _createStructuredText(StringBuffer sb) {
     sb.write('String(value=${primitiveValue})');
   }
 
   @override
   ConstantValue evaluate(
-      Environment environment, ConstantSystem constantSystem) {
+      EvaluationEnvironment 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;
   }
@@ skipping 13 matching lines @@
     return visitor.visitNull(this, context);
   }
 
   @override
   void _createStructuredText(StringBuffer sb) {
     sb.write('Null()');
   }
 
   @override
   ConstantValue evaluate(
-      Environment environment, ConstantSystem constantSystem) {
+      EvaluationEnvironment environment, ConstantSystem constantSystem) {
     return constantSystem.createNull();
   }
 
   get primitiveValue => null;
 
   @override
   int _computeHashCode() => 29;
 
   @override
   bool _equals(NullConstantExpression other) => true;
@@ skipping 23 matching lines @@
     for (ConstantExpression value in values) {
       sb.write(delimiter);
       value._createStructuredText(sb);
       delimiter = ',';
     }
     sb.write('])');
   }
 
   @override
   ConstantValue evaluate(
-      Environment environment, ConstantSystem constantSystem) {
+      EvaluationEnvironment environment, ConstantSystem constantSystem) {
     return constantSystem.createList(type,
         values.map((v) => v.evaluate(environment, constantSystem)).toList());
   }
 
   ConstantExpression apply(NormalizedArguments arguments) {
     return new ListConstantExpression(
         type, values.map((v) => v.apply(arguments)).toList());
   }
 
   @override
@@ skipping 48 matching lines @@
       }
       keys[index]._createStructuredText(sb);
       sb.write('->');
       values[index]._createStructuredText(sb);
     }
     sb.write('])');
   }
 
   @override
   ConstantValue evaluate(
-      Environment environment, ConstantSystem constantSystem) {
+      EvaluationEnvironment environment, ConstantSystem constantSystem) {
     Map<ConstantValue, ConstantValue> valueMap =
         <ConstantValue, ConstantValue>{};
     for (int index = 0; index < keys.length; index++) {
       ConstantValue key = keys[index].evaluate(environment, constantSystem);
       ConstantValue value = values[index].evaluate(environment, constantSystem);
       valueMap[key] = value;
     }
     return constantSystem.createMap(environment.commonElements, type,
         valueMap.keys.toList(), valueMap.values.toList());
   }
@@ skipping 63 matching lines @@
     String delimiter = '';
     for (ConstantExpression value in arguments) {
       sb.write(delimiter);
       value._createStructuredText(sb);
       delimiter = ',';
     }
     sb.write('])');
   }
 
   Map<FieldEntity, ConstantExpression> computeInstanceFields(
-      Environment environment) {
+      EvaluationEnvironment environment) {
     ConstantConstructor constantConstructor =
         environment.getConstructorConstant(target);
     assert(invariant(target, constantConstructor != null,
         message: "No constant constructor computed for $target."));
     return constantConstructor.computeInstanceFields(
         environment, arguments, callStructure);
   }
 
-  InterfaceType computeInstanceType(Environment environment) {
+  InterfaceType computeInstanceType(EvaluationEnvironment environment) {
     return environment
         .getConstructorConstant(target)
         .computeInstanceType(environment, 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) {
+      EvaluationEnvironment environment, ConstantSystem constantSystem) {
     Map<FieldEntity, ConstantValue> fieldValues =
         <FieldEntity, ConstantValue>{};
     computeInstanceFields(environment)
         .forEach((FieldEntity field, ConstantExpression constant) {
       fieldValues[field] = constant.evaluate(environment, constantSystem);
     });
     return new ConstructedConstantValue(
         computeInstanceType(environment), fieldValues);
   }
 
@@ skipping 51 matching lines @@
     sb.write('])');
   }
 
   ConstantExpression apply(NormalizedArguments arguments) {
     return new ConcatenateConstantExpression(
         expressions.map((a) => a.apply(arguments)).toList());
   }
 
   @override
   ConstantValue evaluate(
-      Environment environment, ConstantSystem constantSystem) {
+      EvaluationEnvironment environment, ConstantSystem constantSystem) {
     DartString accumulator;
     for (ConstantExpression expression in expressions) {
       ConstantValue value = expression.evaluate(environment, constantSystem);
       DartString valueString;
       if (value.isNum || value.isBool || value.isNull) {
         PrimitiveConstantValue primitive = value;
         valueString =
             new DartString.literal(primitive.primitiveValue.toString());
       } else if (value.isString) {
         PrimitiveConstantValue primitive = value;
@@ skipping 60 matching lines @@
   @override
   int _computeHashCode() => 13 * name.hashCode;
 
   @override
   bool _equals(SymbolConstantExpression other) {
     return name == other.name;
   }
 
   @override
   ConstantValue evaluate(
-      Environment environment, ConstantSystem constantSystem) {
+      EvaluationEnvironment environment, ConstantSystem constantSystem) {
     return constantSystem.createSymbol(environment.commonElements, name);
   }
 
   @override
   InterfaceType getKnownType(CommonElements commonElements) =>
       commonElements.symbolType;
 }
 
 /// Type literal.
 class TypeConstantExpression extends ConstantExpression {
@@ skipping 14 matching lines @@
     return visitor.visitType(this, context);
   }
 
   @override
   void _createStructuredText(StringBuffer sb) {
     sb.write('Type(type=$type)');
   }
 
   @override
   ConstantValue evaluate(
-      Environment environment, ConstantSystem constantSystem) {
+      EvaluationEnvironment environment, ConstantSystem constantSystem) {
     return constantSystem.createType(environment.commonElements, type);
   }
 
   @override
   int _computeHashCode() => 13 * type.hashCode;
 
   @override
   bool _equals(TypeConstantExpression other) {
     return type == other.type;
   }
@@ skipping 15 matching lines @@
     return visitor.visitField(this, context);
   }
 
   @override
   void _createStructuredText(StringBuffer sb) {
     sb.write('Field(element=$element)');
   }
 
   @override
   ConstantValue evaluate(
-      Environment environment, ConstantSystem constantSystem) {
+      EvaluationEnvironment environment, ConstantSystem constantSystem) {
     ConstantExpression constant = environment.getFieldConstant(element);
     return constant.evaluate(environment, constantSystem);
   }
 
   @override
   int _computeHashCode() => 13 * element.hashCode;
 
   @override
   bool _equals(FieldConstantExpression other) {
     return element == other.element;
@@ skipping 12 matching lines @@
     return visitor.visitLocalVariable(this, context);
   }
 
   @override
   void _createStructuredText(StringBuffer sb) {
     sb.write('LocalVariable(element=$element)');
   }
 
   @override
   ConstantValue evaluate(
-      Environment environment, ConstantSystem constantSystem) {
+      EvaluationEnvironment environment, ConstantSystem constantSystem) {
     ConstantExpression constant = environment.getLocalConstant(element);
     return constant.evaluate(environment, constantSystem);
   }
 
   @override
   int _computeHashCode() => 13 * element.hashCode;
 
   @override
   bool _equals(LocalVariableConstantExpression other) {
     return element == other.element;
@@ skipping 13 matching lines @@
     return visitor.visitFunction(this, context);
   }
 
   @override
   void _createStructuredText(StringBuffer sb) {
     sb.write('Function(element=$element)');
   }
 
   @override
   ConstantValue evaluate(
-      Environment environment, ConstantSystem constantSystem) {
+      EvaluationEnvironment environment, ConstantSystem constantSystem) {
     return new FunctionConstantValue(element, type);
   }
 
   @override
   int _computeHashCode() => 13 * element.hashCode;
 
   @override
   bool _equals(FunctionConstantExpression other) {
     return element == other.element;
   }
@@ skipping 23 matching lines @@
   void _createStructuredText(StringBuffer sb) {
     sb.write('Binary(left=');
     left._createStructuredText(sb);
     sb.write(',op=$operator,right=');
     right._createStructuredText(sb);
     sb.write(')');
   }
 
   @override
   ConstantValue evaluate(
-      Environment environment, ConstantSystem constantSystem) {
+      EvaluationEnvironment environment, ConstantSystem constantSystem) {
     ConstantValue leftValue = left.evaluate(environment, constantSystem);
     ConstantValue rightValue = right.evaluate(environment, constantSystem);
     switch (operator.kind) {
       case BinaryOperatorKind.NOT_EQ:
         BoolConstantValue equals =
             constantSystem.equal.fold(leftValue, rightValue);
         return equals.negate();
       default:
         return constantSystem
             .lookupBinary(operator)
@@ skipping 118 matching lines @@
   void _createStructuredText(StringBuffer sb) {
     sb.write('Identical(left=');
     left._createStructuredText(sb);
     sb.write(',right=');
     right._createStructuredText(sb);
     sb.write(')');
   }
 
   @override
   ConstantValue evaluate(
-      Environment environment, ConstantSystem constantSystem) {
+      EvaluationEnvironment environment, ConstantSystem constantSystem) {
     return constantSystem.identity.fold(
         left.evaluate(environment, constantSystem),
         right.evaluate(environment, constantSystem));
   }
 
   ConstantExpression apply(NormalizedArguments arguments) {
     return new IdenticalConstantExpression(
         left.apply(arguments), right.apply(arguments));
   }
 
@@ skipping 36 matching lines @@
 
   @override
   void _createStructuredText(StringBuffer sb) {
     sb.write('Unary(op=$operator,expression=');
     expression._createStructuredText(sb);
     sb.write(')');
   }
 
   @override
   ConstantValue evaluate(
-      Environment environment, ConstantSystem constantSystem) {
+      EvaluationEnvironment environment, ConstantSystem constantSystem) {
     return constantSystem
         .lookupUnary(operator)
         .fold(expression.evaluate(environment, constantSystem));
   }
 
   ConstantExpression apply(NormalizedArguments arguments) {
     return new UnaryConstantExpression(operator, expression.apply(arguments));
   }
 
   int get precedence => PRECEDENCE_MAP[operator.kind];
@@ skipping 39 matching lines @@
 
   @override
   void _createStructuredText(StringBuffer sb) {
     sb.write('StringLength(expression=');
     expression._createStructuredText(sb);
     sb.write(')');
   }
 
   @override
   ConstantValue evaluate(
-      Environment environment, ConstantSystem constantSystem) {
+      EvaluationEnvironment environment, ConstantSystem constantSystem) {
     ConstantValue value = expression.evaluate(environment, constantSystem);
     if (value.isString) {
       StringConstantValue stringValue = value;
       return constantSystem.createInt(stringValue.primitiveValue.length);
     }
     return new NonConstantValue();
   }
 
   ConstantExpression apply(NormalizedArguments arguments) {
     return new StringLengthConstantExpression(expression.apply(arguments));
@@ skipping 62 matching lines @@
 
   @override
   bool _equals(ConditionalConstantExpression other) {
     return condition == other.condition &&
         trueExp == other.trueExp &&
         falseExp == other.falseExp;
   }
 
   @override
   ConstantValue evaluate(
-      Environment environment, ConstantSystem constantSystem) {
+      EvaluationEnvironment 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();
@@ skipping 40 matching lines @@
   }
 
   @override
   int _computeHashCode() => 13 * index.hashCode;
 
   @override
   bool _equals(PositionalArgumentReference other) => index == other.index;
 
   @override
   ConstantValue evaluate(
-      Environment environment, ConstantSystem constantSystem) {
+      EvaluationEnvironment environment, ConstantSystem constantSystem) {
     throw new UnsupportedError('PositionalArgumentReference.evaluate');
   }
 
   @override
   bool get isPotential => true;
 }
 
 /// A reference to a named parameter.
 class NamedArgumentReference extends ConstantExpression {
   final String name;
@@ skipping 18 matching lines @@
   }
 
   @override
   int _computeHashCode() => 13 * name.hashCode;
 
   @override
   bool _equals(NamedArgumentReference other) => name == other.name;
 
   @override
   ConstantValue evaluate(
-      Environment environment, ConstantSystem constantSystem) {
+      EvaluationEnvironment environment, ConstantSystem constantSystem) {
     throw new UnsupportedError('NamedArgumentReference.evaluate');
   }
 
   @override
   bool get isPotential => true;
 }
 
 abstract class FromEnvironmentConstantExpression extends ConstantExpression {
   final ConstantExpression name;
   final ConstantExpression defaultValue;
@@ skipping 45 matching lines @@
     if (defaultValue != null) {
       defaultValue._createStructuredText(sb);
     } else {
       sb.write('null');
     }
     sb.write(')');
   }
 
   @override
   ConstantValue evaluate(
-      Environment environment, ConstantSystem constantSystem) {
+      EvaluationEnvironment environment, 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) {
       return new NonConstantValue();
@@ skipping 43 matching lines @@
     if (defaultValue != null) {
       defaultValue._createStructuredText(sb);
     } else {
       sb.write('null');
     }
     sb.write(')');
   }
 
   @override
   ConstantValue evaluate(
-      Environment environment, ConstantSystem constantSystem) {
+      EvaluationEnvironment environment, 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) {
       return new NonConstantValue();
@@ skipping 45 matching lines @@
     if (defaultValue != null) {
       defaultValue._createStructuredText(sb);
     } else {
       sb.write('null');
     }
     sb.write(')');
   }
 
   @override
   ConstantValue evaluate(
-      Environment environment, ConstantSystem constantSystem) {
+      EvaluationEnvironment environment, 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) {
       return new NonConstantValue();
@@ skipping 30 matching lines @@
 
   @override
   void _createStructuredText(StringBuffer sb) {
     sb.write('Deferred(prefix=$prefix,expression=');
     expression._createStructuredText(sb);
     sb.write(')');
   }
 
   @override
   ConstantValue evaluate(
-      Environment environment, ConstantSystem constantSystem) {
+      EvaluationEnvironment environment, ConstantSystem constantSystem) {
     return new DeferredConstantValue(
         expression.evaluate(environment, constantSystem), prefix);
   }
 
   @override
   int _computeHashCode() {
     return 13 * expression.hashCode;
   }
 
   ConstantExpression apply(NormalizedArguments arguments) {
@@ skipping 321 matching lines @@
     visit(exp.name);
     if (exp.defaultValue != null) {
       sb.write(', defaultValue: ');
       visit(exp.defaultValue);
     }
     sb.write(')');
   }
 
   String toString() => sb.toString();
 }