Begin to 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 '../constants/constant_system.dart';
+import '../core_types.dart';
 import '../dart2jslib.dart' show assertDebugMode, Compiler;
 import '../dart_types.dart';
 import '../elements/elements.dart' show
     ConstructorElement,
     Element,
     FieldElement,
     FunctionElement,
     PrefixElement,
     VariableElement;
 import '../resolution/operators.dart';
@@ skipping 250 matching lines @@
   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);
 
+  /// Returns the type of this constant expression, if it is independent of the
+  /// environment values.
+  DartType getKnownType(CoreTypes coreTypes) => null;
+
   String getText() {
     ConstExpPrinter printer = new ConstExpPrinter();
     accept(printer);
     return printer.toString();
   }
 
   int _computeHashCode();
 
   int get hashCode {
     if (_hashCode == null) {
@@ skipping 65 matching lines @@
     return constantSystem.createBool(primitiveValue);
   }
 
   @override
   int _computeHashCode() => 13 * primitiveValue.hashCode;
 
   @override
   bool _equals(BoolConstantExpression other) {
     return primitiveValue == other.primitiveValue;
   }
+
+  @override
+  DartType getKnownType(CoreTypes coreTypes) => coreTypes.boolType;
 }
 
 /// Integer literal constant.
 class IntConstantExpression extends PrimitiveConstantExpression {
   final int primitiveValue;
 
   IntConstantExpression(this.primitiveValue);
 
   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;
   }
+
+  @override
+  DartType getKnownType(CoreTypes coreTypes) => coreTypes.intType;
 }
 
 /// Double literal constant.
 class DoubleConstantExpression extends PrimitiveConstantExpression {
   final double primitiveValue;
 
   DoubleConstantExpression(this.primitiveValue);
 
   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;
   }
+
+  @override
+  DartType getKnownType(CoreTypes coreTypes) => coreTypes.doubleType;
 }
 
 /// String literal constant.
 class StringConstantExpression extends PrimitiveConstantExpression {
   final String primitiveValue;
 
   StringConstantExpression(this.primitiveValue);
 
   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;
   }
+
+  @override
+  DartType getKnownType(CoreTypes coreTypes) => coreTypes.stringType;
 }
 
 /// Null literal constant.
 class NullConstantExpression extends PrimitiveConstantExpression {
   NullConstantExpression();
 
   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;
+
+  @override
+  DartType getKnownType(CoreTypes coreTypes) => coreTypes.nullType;
 }
 
 /// Literal list constant.
 class ListConstantExpression extends ConstantExpression {
   final InterfaceType type;
   final List<ConstantExpression> values;
 
   ListConstantExpression(this.type, this.values);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.LIST;
@@ skipping 25 matching lines @@
 
   @override
   bool _equals(ListConstantExpression other) {
     if (type != other.type) return false;
     if (values.length != other.values.length) return false;
     for (int i = 0; i < values.length; i++) {
       if (values[i] != other.values[i]) return false;
     }
     return true;
   }
+
+  @override
+  DartType getKnownType(CoreTypes coreTypes) => type;
 }
 
 /// Literal map constant.
 class MapConstantExpression extends ConstantExpression {
   final InterfaceType type;
   final List<ConstantExpression> keys;
   final List<ConstantExpression> values;
 
   MapConstantExpression(this.type, this.keys, this.values);
 
@@ skipping 31 matching lines @@
   @override
   bool _equals(MapConstantExpression other) {
     if (type != other.type) return false;
     if (values.length != other.values.length) return false;
     for (int i = 0; i < values.length; i++) {
       if (keys[i] != other.keys[i]) return false;
       if (values[i] != other.values[i]) return false;
     }
     return true;
   }
+
+  @override
+  DartType getKnownType(CoreTypes coreTypes) => type;
 }
 
 /// Invocation of a const constructor.
 class ConstructedConstantExpression extends ConstantExpression {
   final InterfaceType type;
   final ConstructorElement target;
   final CallStructure callStructure;
   final List<ConstantExpression> arguments;
 
   ConstructedConstantExpression(
@@ skipping 117 matching lines @@
   }
 
   @override
   bool _equals(ConcatenateConstantExpression other) {
     if (expressions.length != other.expressions.length) return false;
     for (int i = 0; i < expressions.length; i++) {
       if (expressions[i] != other.expressions[i]) return false;
     }
     return true;
   }
+
+  @override
+  DartType getKnownType(CoreTypes coreTypes) => coreTypes.stringType;
 }
 
 /// Symbol literal.
 class SymbolConstantExpression extends ConstantExpression {
   final String name;
 
   SymbolConstantExpression(this.name);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.SYMBOL;
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     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');
   }
+
+  @override
+  DartType getKnownType(CoreTypes coreTypes) => coreTypes.symbolType;
 }
 
 /// Type literal.
 class TypeConstantExpression extends ConstantExpression {
   /// Either [DynamicType] or a raw [GenericType].
   final DartType type;
 
   TypeConstantExpression(this.type) {
     assert(type is GenericType || type is DynamicType);
   }
@@ skipping 10 matching lines @@
     return constantSystem.createType(environment.compiler, type);
   }
 
   @override
   int _computeHashCode() => 13 * type.hashCode;
 
   @override
   bool _equals(TypeConstantExpression other) {
     return type == other.type;
   }
+
+  @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);
 
   ConstantExpressionKind get kind => ConstantExpressionKind.VARIABLE;
 
@@ skipping 34 matching lines @@
     return new FunctionConstantValue(element);
   }
 
   @override
   int _computeHashCode() => 13 * element.hashCode;
 
   @override
   bool _equals(FunctionConstantExpression other) {
     return element == other.element;
   }
+
+  @override
+  DartType getKnownType(CoreTypes coreTypes) => coreTypes.functionType;
 }
 
 /// A constant binary expression like `a * b`.
 class BinaryConstantExpression extends ConstantExpression {
   final ConstantExpression left;
   final BinaryOperator operator;
   final ConstantExpression right;
 
   BinaryConstantExpression(this.left, this.operator, this.right) {
     assert(PRECEDENCE_MAP[operator.kind] != null);
@@ skipping 13 matching lines @@
         right.evaluate(environment, constantSystem));
   }
 
   ConstantExpression apply(NormalizedArguments arguments) {
     return new BinaryConstantExpression(
         left.apply(arguments),
         operator,
         right.apply(arguments));
   }
 
+  DartType getKnownType(CoreTypes coreTypes) {
+    switch (operator.kind) {
+      case BinaryOperatorKind.EQ:
+      case BinaryOperatorKind.NOT_EQ:
+      case BinaryOperatorKind.LOGICAL_AND:
+      case BinaryOperatorKind.LOGICAL_OR:
+        return coreTypes.boolType;
+      case BinaryOperatorKind.XOR:
+      case BinaryOperatorKind.AND:
+      case BinaryOperatorKind.OR:
+      case BinaryOperatorKind.SHR:
+      case BinaryOperatorKind.SHL:
+      case BinaryOperatorKind.ADD:
+      case BinaryOperatorKind.SUB:
+      case BinaryOperatorKind.MUL:
+      case BinaryOperatorKind.DIV:
+      case BinaryOperatorKind.IDIV:
+      case BinaryOperatorKind.GT:
+      case BinaryOperatorKind.LT:
+      case BinaryOperatorKind.GTEQ:
+      case BinaryOperatorKind.LTEQ:
+      case BinaryOperatorKind.MOD:

[karlklose, 2015/06/08 09:25:24]

This is not true - at least for MOD.

[Johnni Winther, 2015/06/08 12:18:13]

Done.

+        // TODO(johnniwinther): Refine this when potentially invalid constant
+        // expressions are handled.
+        return left.getKnownType(coreTypes);
+      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 59 matching lines @@
   int _computeHashCode() {
     return 17 * left.hashCode +
            19 * right.hashCode;
   }
 
   @override
   bool _equals(IdenticalConstantExpression other) {
     return left == other.left &&
            right == other.right;
   }
+
+  @override
+  DartType getKnownType(CoreTypes coreTypes) => coreTypes.boolType;
 }
 
 /// A unary constant expression like `-a`.
 class UnaryConstantExpression extends ConstantExpression {
   final UnaryOperator operator;
   final ConstantExpression expression;
 
   UnaryConstantExpression(this.operator, this.expression) {
     assert(PRECEDENCE_MAP[operator.kind] != null);
   }
@@ skipping 24 matching lines @@
     return 13 * operator.hashCode +
            17 * expression.hashCode;
   }
 
   @override
   bool _equals(UnaryConstantExpression other) {
     return operator == other.operator &&
            expression == other.expression;
   }
 
+  @override
+  DartType getKnownType(CoreTypes coreTypes) {
+    return expression.getKnownType(coreTypes);
+  }
+
   static const Map<UnaryOperatorKind, int> PRECEDENCE_MAP = const {
     UnaryOperatorKind.NOT: 14,
     UnaryOperatorKind.COMPLEMENT: 14,
     UnaryOperatorKind.NEGATE: 14,
   };
 }
 
 
 /// A string length constant expression like `a.length`.
 class StringLengthConstantExpression extends ConstantExpression {
@@ skipping 26 matching lines @@
 
   @override
   int _computeHashCode() {
     return 23 * expression.hashCode;
   }
 
   @override
   bool _equals(StringLengthConstantExpression other) {
     return expression == other.expression;
   }
+
+  @override
+  DartType getKnownType(CoreTypes coreTypes) => coreTypes.intType;
 }
 
 /// A constant conditional expression like `a ? b : c`.
 class ConditionalConstantExpression extends ConstantExpression {
   final ConstantExpression condition;
   final ConstantExpression trueExp;
   final ConstantExpression falseExp;
 
   ConditionalConstantExpression(this.condition,
                                 this.trueExp,
@@ skipping 38 matching lines @@
     ConstantValue falseValue =
         falseExp.evaluate(environment, constantSystem);
     if (conditionValue.isTrue) {
       return trueValue;
     } else if (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;
+    }
+    return null;
+  }
 }
 
 /// A reference to a position parameter.
 class PositionalArgumentReference extends ConstantExpression {
   final int index;
 
   PositionalArgumentReference(this.index);
 
   ConstantExpressionKind get kind {
     return ConstantExpressionKind.POSITIONAL_REFERENCE;
@@ skipping 112 matching lines @@
     } else {
       return defaultConstantValue;
     }
   }
 
   ConstantExpression apply(NormalizedArguments arguments) {
     return new BoolFromEnvironmentConstantExpression(
         name.apply(arguments),
         defaultValue != null ? defaultValue.apply(arguments) : null);
   }
+
+  @override
+  DartType getKnownType(CoreTypes coreTypes) => coreTypes.boolType;
 }
 
 /// A `const int.fromEnvironment` constant.
 class IntFromEnvironmentConstantExpression
     extends FromEnvironmentConstantExpression {
 
   IntFromEnvironmentConstantExpression(
       ConstantExpression name,
       ConstantExpression defaultValue)
       : super(name, defaultValue);
@@ skipping 33 matching lines @@
     } else {
       return constantSystem.createInt(value);
     }
   }
 
   ConstantExpression apply(NormalizedArguments arguments) {
     return new IntFromEnvironmentConstantExpression(
         name.apply(arguments),
         defaultValue != null ? defaultValue.apply(arguments) : null);
   }
+
+  @override
+  DartType getKnownType(CoreTypes coreTypes) => coreTypes.intType;
 }
 
 /// A `const String.fromEnvironment` constant.
 class StringFromEnvironmentConstantExpression
     extends FromEnvironmentConstantExpression {
 
   StringFromEnvironmentConstantExpression(
       ConstantExpression name,
       ConstantExpression defaultValue)
       : super(name, defaultValue);
@@ skipping 29 matching lines @@
     } else {
       return constantSystem.createString(new DartString.literal(text));
     }
   }
 
   ConstantExpression apply(NormalizedArguments arguments) {
     return new StringFromEnvironmentConstantExpression(
         name.apply(arguments),
         defaultValue != null ? defaultValue.apply(arguments) : null);
   }
+
+  @override
+  DartType getKnownType(CoreTypes coreTypes) => coreTypes.stringType;
 }
 
 /// A constant expression referenced with a deferred prefix.
 /// For example `lib.C`.
 class DeferredConstantExpression extends ConstantExpression {
   final ConstantExpression expression;
   final PrefixElement prefix;
 
   DeferredConstantExpression(this.expression, this.prefix);
 
@@ skipping 336 matching lines @@
     visit(exp.name);
     if (exp.defaultValue != null) {
       sb.write(', defaultValue: ');
       visit(exp.defaultValue);
     }
     sb.write(')');
   }
 
   String toString() => sb.toString();
 }