Reland "Eliminate singleton/static access to the constant system and expose its functionality at the top level."
This is a reland of 027b76ecbf92c2323b5c3f3236c2dd5f7513c173
Original change's description:
> Eliminate singleton/static access to the constant system and expose its
> functionality at the top level.
>
> Use sites have been updated to import the library with a prefix.
>
> Change-Id: I0f5e4e47bec089d2d0dc2fcd50caccfd98947cf5
> Reviewed-on: https://dart-review.googlesource.com/c/93842
> Reviewed-by: Sigmund Cherem <sigmund@google.com>
> Reviewed-by: Johnni Winther <johnniwinther@google.com>
Change-Id: Ib04a9d48c8dca51020258313256e0fb0df330d9b
Reviewed-on: https://dart-review.googlesource.com/c/94107
Reviewed-by: Sigmund Cherem <sigmund@google.com>
diff --git a/pkg/compiler/lib/src/common_elements.dart b/pkg/compiler/lib/src/common_elements.dart
index 744318e..ba4f731f 100644
--- a/pkg/compiler/lib/src/common_elements.dart
+++ b/pkg/compiler/lib/src/common_elements.dart
@@ -7,7 +7,7 @@
import 'common.dart';
import 'common/names.dart' show Identifiers, Uris;
-import 'constants/constant_system.dart';
+import 'constants/constant_system.dart' as constant_system;
import 'constants/expressions.dart' show ConstantExpression;
import 'constants/values.dart';
import 'elements/entities.dart';
@@ -1438,13 +1438,13 @@
ClassEntity get stackTraceHelperClass => _findHelperClass('_StackTrace');
ClassEntity get constantMapClass =>
- _findHelperClass(JavaScriptMapConstant.DART_CLASS);
+ _findHelperClass(constant_system.JavaScriptMapConstant.DART_CLASS);
ClassEntity get constantStringMapClass =>
- _findHelperClass(JavaScriptMapConstant.DART_STRING_CLASS);
+ _findHelperClass(constant_system.JavaScriptMapConstant.DART_STRING_CLASS);
ClassEntity get constantProtoMapClass =>
- _findHelperClass(JavaScriptMapConstant.DART_PROTO_CLASS);
- ClassEntity get generalConstantMapClass =>
- _findHelperClass(JavaScriptMapConstant.DART_GENERAL_CLASS);
+ _findHelperClass(constant_system.JavaScriptMapConstant.DART_PROTO_CLASS);
+ ClassEntity get generalConstantMapClass => _findHelperClass(
+ constant_system.JavaScriptMapConstant.DART_GENERAL_CLASS);
ClassEntity get annotationCreatesClass => _findHelperClass('Creates');
diff --git a/pkg/compiler/lib/src/compile_time_constants.dart b/pkg/compiler/lib/src/compile_time_constants.dart
index 9055af7..20e7219 100644
--- a/pkg/compiler/lib/src/compile_time_constants.dart
+++ b/pkg/compiler/lib/src/compile_time_constants.dart
@@ -5,15 +5,11 @@
library dart2js.compile_time_constant_evaluator;
import 'common/tasks.dart' show CompilerTask, Measurer;
-import 'constants/constant_system.dart';
import 'elements/entities.dart';
/// A [ConstantEnvironment] provides access for constants compiled for variable
/// initializers.
-abstract class ConstantEnvironment {
- /// The [ConstantSystem] used by this environment.
- ConstantSystem get constantSystem;
-}
+abstract class ConstantEnvironment {}
/// A [BackendConstantEnvironment] provides access to constants needed for
/// backend implementation.
diff --git a/pkg/compiler/lib/src/constants/constant_system.dart b/pkg/compiler/lib/src/constants/constant_system.dart
index 6c37cb8..5e2f563 100644
--- a/pkg/compiler/lib/src/constants/constant_system.dart
+++ b/pkg/compiler/lib/src/constants/constant_system.dart
@@ -2,6 +2,8 @@
// 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.
+/// Constant system following the semantics for Dart code that has been
+/// compiled to JavaScript.
library dart2js.constant_system;
import '../common_elements.dart' show CommonElements;
@@ -10,6 +12,243 @@
import '../elements/types.dart';
import 'values.dart';
+final _BITS32 = new BigInt.from(0xFFFFFFFF);
+
+const add = const JavaScriptAddOperation();
+const bitAnd = const JavaScriptBinaryBitOperation(const BitAndOperation());
+const bitNot = const BitNotOperation();
+const bitOr = const JavaScriptBinaryBitOperation(const BitOrOperation());
+const bitXor = const JavaScriptBinaryBitOperation(const BitXorOperation());
+const booleanAnd = const BooleanAndOperation();
+const booleanOr = const BooleanOrOperation();
+const divide =
+ const JavaScriptBinaryArithmeticOperation(const DivideOperation());
+const equal = const EqualsOperation();
+const greaterEqual = const GreaterEqualOperation();
+const greater = const GreaterOperation();
+const identity = const JavaScriptIdentityOperation();
+const ifNull = const IfNullOperation();
+const lessEqual = const LessEqualOperation();
+const less = const LessOperation();
+const modulo =
+ const JavaScriptBinaryArithmeticOperation(const ModuloOperation());
+const multiply =
+ const JavaScriptBinaryArithmeticOperation(const MultiplyOperation());
+const negate = const JavaScriptNegateOperation();
+const not = const NotOperation();
+const remainder = const JavaScriptRemainderOperation();
+const shiftLeft =
+ const JavaScriptBinaryBitOperation(const ShiftLeftOperation());
+const shiftRight = const JavaScriptShiftRightOperation();
+const subtract =
+ const JavaScriptBinaryArithmeticOperation(const SubtractOperation());
+const truncatingDivide = const JavaScriptBinaryArithmeticOperation(
+ const TruncatingDivideOperation());
+const codeUnitAt = const CodeUnitAtRuntimeOperation();
+const round = const JavaScriptRoundOperation();
+const abs = const UnfoldedUnaryOperation('abs');
+
+/// Returns true if [value] will turn into NaN or infinity
+/// at runtime.
+bool _integerBecomesNanOrInfinity(BigInt value) {
+ double doubleValue = value.toDouble();
+ return doubleValue.isNaN || doubleValue.isInfinite;
+}
+
+NumConstantValue _convertToJavaScriptConstant(NumConstantValue constant) {
+ if (constant.isInt) {
+ IntConstantValue intConstant = constant;
+ BigInt intValue = intConstant.intValue;
+ if (_integerBecomesNanOrInfinity(intValue)) {
+ return new DoubleConstantValue(intValue.toDouble());
+ }
+ // If the integer loses precision with JavaScript numbers, use
+ // the floored version JavaScript will use.
+ BigInt floorValue = new BigInt.from(intValue.toDouble());
+ if (floorValue != intValue) {
+ return new IntConstantValue(floorValue);
+ }
+ } else if (constant.isDouble) {
+ DoubleConstantValue doubleResult = constant;
+ double doubleValue = doubleResult.doubleValue;
+ if (!doubleValue.isInfinite &&
+ !doubleValue.isNaN &&
+ !constant.isMinusZero) {
+ double truncated = doubleValue.truncateToDouble();
+ if (truncated == doubleValue) {
+ return new IntConstantValue(new BigInt.from(truncated));
+ }
+ }
+ }
+ return constant;
+}
+
+NumConstantValue createInt(BigInt i) =>
+ _convertToJavaScriptConstant(new IntConstantValue(i));
+NumConstantValue createIntFromInt(int i) => createInt(new BigInt.from(i));
+NumConstantValue _createInt32(BigInt i) => new IntConstantValue(i & _BITS32);
+NumConstantValue createDouble(double d) =>
+ _convertToJavaScriptConstant(new DoubleConstantValue(d));
+StringConstantValue createString(String string) =>
+ new StringConstantValue(string);
+BoolConstantValue createBool(bool value) => new BoolConstantValue(value);
+NullConstantValue createNull() => new NullConstantValue();
+ListConstantValue createList(InterfaceType type, List<ConstantValue> values) =>
+ new ListConstantValue(type, values);
+
+ConstantValue createType(CommonElements commonElements, DartType type) {
+ InterfaceType instanceType = commonElements.typeLiteralType;
+ return new TypeConstantValue(type, instanceType);
+}
+
+/// Returns true if the [constant] is an integer at runtime.
+///
+/// Integer checks report true for -0.0, INFINITY, and -INFINITY. At
+/// runtime an 'X is int' check is implemented as:
+///
+/// typeof(X) === "number" && Math.floor(X) === X
+///
+/// We consistently match that runtime semantics at compile time as well.
+bool isInt(ConstantValue constant) =>
+ constant.isInt ||
+ constant.isMinusZero ||
+ constant.isPositiveInfinity ||
+ constant.isNegativeInfinity;
+
+/// Returns true if the [constant] is a double at runtime.
+bool isDouble(ConstantValue constant) =>
+ constant.isDouble && !constant.isMinusZero;
+
+/// Returns true if the [constant] is a string at runtime.
+bool isString(ConstantValue constant) => constant.isString;
+
+/// Returns true if the [constant] is a boolean at runtime.
+bool isBool(ConstantValue constant) => constant.isBool;
+
+/// Returns true if the [constant] is null at runtime.
+bool isNull(ConstantValue constant) => constant.isNull;
+
+bool isSubtype(DartTypes types, DartType s, DartType t) {
+ // At runtime, an integer is both an integer and a double: the
+ // integer type check is Math.floor, which will return true only
+ // for real integers, and our double type check is 'typeof number'
+ // which will return true for both integers and doubles.
+ if (s == types.commonElements.intType &&
+ t == types.commonElements.doubleType) {
+ return true;
+ }
+ return types.isSubtype(s, t);
+}
+
+SetConstantValue createSet(CommonElements commonElements,
+ InterfaceType sourceType, List<ConstantValue> values) {
+ InterfaceType type = commonElements.getConstantSetTypeFor(sourceType);
+ return new JavaScriptSetConstant(commonElements, type, values);
+}
+
+MapConstantValue createMap(
+ CommonElements commonElements,
+ InterfaceType sourceType,
+ List<ConstantValue> keys,
+ List<ConstantValue> values) {
+ bool onlyStringKeys = true;
+ ConstantValue protoValue = null;
+ for (int i = 0; i < keys.length; i++) {
+ dynamic key = keys[i];
+ if (key.isString) {
+ if (key.stringValue == JavaScriptMapConstant.PROTO_PROPERTY) {
+ protoValue = values[i];
+ }
+ } else {
+ onlyStringKeys = false;
+ // Don't handle __proto__ values specially in the general map case.
+ protoValue = null;
+ break;
+ }
+ }
+
+ bool hasProtoKey = (protoValue != null);
+ InterfaceType keysType;
+ if (sourceType.treatAsRaw) {
+ keysType = commonElements.listType();
+ } else {
+ keysType = commonElements.listType(sourceType.typeArguments.first);
+ }
+ ListConstantValue keysList = new ListConstantValue(keysType, keys);
+ InterfaceType type = commonElements.getConstantMapTypeFor(sourceType,
+ hasProtoKey: hasProtoKey, onlyStringKeys: onlyStringKeys);
+ return new JavaScriptMapConstant(
+ type, keysList, values, protoValue, onlyStringKeys);
+}
+
+ConstantValue createSymbol(CommonElements commonElements, String text) {
+ InterfaceType type = commonElements.symbolImplementationType;
+ FieldEntity field = commonElements.symbolField;
+ ConstantValue argument = createString(text);
+ // TODO(johnniwinther): Use type arguments when all uses no longer expect
+ // a [FieldElement].
+ var fields = <FieldEntity, ConstantValue>{field: argument};
+ return new ConstructedConstantValue(type, fields);
+}
+
+UnaryOperation lookupUnary(UnaryOperator operator) {
+ switch (operator.kind) {
+ case UnaryOperatorKind.COMPLEMENT:
+ return bitNot;
+ case UnaryOperatorKind.NEGATE:
+ return negate;
+ case UnaryOperatorKind.NOT:
+ return not;
+ default:
+ return null;
+ }
+}
+
+BinaryOperation lookupBinary(BinaryOperator operator) {
+ switch (operator.kind) {
+ case BinaryOperatorKind.ADD:
+ return add;
+ case BinaryOperatorKind.SUB:
+ return subtract;
+ case BinaryOperatorKind.MUL:
+ return multiply;
+ case BinaryOperatorKind.DIV:
+ return divide;
+ case BinaryOperatorKind.MOD:
+ return modulo;
+ case BinaryOperatorKind.IDIV:
+ return truncatingDivide;
+ case BinaryOperatorKind.OR:
+ return bitOr;
+ case BinaryOperatorKind.AND:
+ return bitAnd;
+ case BinaryOperatorKind.XOR:
+ return bitXor;
+ case BinaryOperatorKind.LOGICAL_OR:
+ return booleanOr;
+ case BinaryOperatorKind.LOGICAL_AND:
+ return booleanAnd;
+ case BinaryOperatorKind.SHL:
+ return shiftLeft;
+ case BinaryOperatorKind.SHR:
+ return shiftRight;
+ case BinaryOperatorKind.LT:
+ return less;
+ case BinaryOperatorKind.LTEQ:
+ return lessEqual;
+ case BinaryOperatorKind.GT:
+ return greater;
+ case BinaryOperatorKind.GTEQ:
+ return greaterEqual;
+ case BinaryOperatorKind.EQ:
+ return equal;
+ case BinaryOperatorKind.IF_NULL:
+ return ifNull;
+ default:
+ return null;
+ }
+}
+
abstract class Operation {
String get name;
}
@@ -30,14 +269,14 @@
const BitNotOperation();
ConstantValue fold(ConstantValue constant) {
- if (ConstantSystem.only.isInt(constant)) {
+ if (isInt(constant)) {
// In JavaScript we don't check for -0 and treat it as if it was zero.
if (constant.isMinusZero) {
- constant = ConstantSystem.only.createInt(BigInt.zero);
+ constant = createInt(BigInt.zero);
}
IntConstantValue intConstant = constant;
// We convert the result of bit-operations to 32 bit unsigned integers.
- return ConstantSystem.only.createInt32(~intConstant.intValue);
+ return _createInt32(~intConstant.intValue);
}
return null;
}
@@ -49,11 +288,11 @@
ConstantValue fold(ConstantValue constant) {
if (constant.isInt) {
IntConstantValue intConstant = constant;
- return ConstantSystem.only.createInt(-intConstant.intValue);
+ return createInt(-intConstant.intValue);
}
if (constant.isDouble) {
DoubleConstantValue doubleConstant = constant;
- return ConstantSystem.only.createDouble(-doubleConstant.doubleValue);
+ return createDouble(-doubleConstant.doubleValue);
}
return null;
}
@@ -70,7 +309,7 @@
if (constant.isInt) {
IntConstantValue intConstant = constant;
if (intConstant.intValue == BigInt.zero) {
- return ConstantSystem.only.createDouble(-0.0);
+ return createDouble(-0.0);
}
}
return dartNegateOperation.fold(constant);
@@ -83,7 +322,7 @@
ConstantValue fold(ConstantValue constant) {
if (constant.isBool) {
BoolConstantValue boolConstant = constant;
- return ConstantSystem.only.createBool(!boolConstant.boolValue);
+ return createBool(!boolConstant.boolValue);
}
return null;
}
@@ -98,7 +337,7 @@
IntConstantValue rightInt = right;
BigInt resultValue = foldInts(leftInt.intValue, rightInt.intValue);
if (resultValue == null) return null;
- return ConstantSystem.only.createInt(resultValue);
+ return createInt(resultValue);
}
return null;
}
@@ -118,15 +357,15 @@
ConstantValue fold(ConstantValue left, ConstantValue right) {
// In JavaScript we don't check for -0 and treat it as if it was zero.
if (left.isMinusZero) {
- left = ConstantSystem.only.createInt(BigInt.zero);
+ left = createInt(BigInt.zero);
}
if (right.isMinusZero) {
- right = ConstantSystem.only.createInt(BigInt.zero);
+ right = createInt(BigInt.zero);
}
IntConstantValue result = dartBitOperation.fold(left, right);
if (result != null) {
// We convert the result of bit-operations to 32 bit unsigned integers.
- return ConstantSystem.only.createInt32(result.intValue);
+ return _createInt32(result.intValue);
}
return result;
}
@@ -187,7 +426,7 @@
if (left.isInt) {
IntConstantValue intConstant = left;
BigInt value = intConstant.intValue;
- BigInt truncatedValue = value & ConstantSystem.only.BITS32;
+ BigInt truncatedValue = value & _BITS32;
if (value < BigInt.zero) {
// Sign-extend if the input was negative. The current semantics don't
// make much sense, since we only look at bit 31.
@@ -203,7 +442,7 @@
truncatedValue -= BigInt.two * (truncatedValue & SIGN_BIT);
}
if (value != truncatedValue) {
- left = ConstantSystem.only.createInt(truncatedValue);
+ left = createInt(truncatedValue);
}
}
return super.fold(left, right);
@@ -217,7 +456,7 @@
BoolConstantValue leftBool = left;
BoolConstantValue rightBool = right;
bool resultValue = foldBools(leftBool.boolValue, rightBool.boolValue);
- return ConstantSystem.only.createBool(resultValue);
+ return createBool(resultValue);
}
return null;
}
@@ -257,9 +496,9 @@
if (foldedValue == null) return null;
if (left.isInt && right.isInt && !isDivide() || isTruncatingDivide()) {
assert(foldedValue is BigInt);
- return ConstantSystem.only.createInt(foldedValue);
+ return createInt(foldedValue);
} else {
- return ConstantSystem.only.createDouble(foldedValue);
+ return createDouble(foldedValue);
}
}
return null;
@@ -281,7 +520,7 @@
ConstantValue fold(ConstantValue left, ConstantValue right) {
ConstantValue result = dartArithmeticOperation.fold(left, right);
if (result == null) return result;
- return ConstantSystem.only.convertToJavaScriptConstant(result);
+ return _convertToJavaScriptConstant(result);
}
apply(left, right) => dartArithmeticOperation.apply(left, right);
@@ -364,17 +603,17 @@
IntConstantValue leftInt = left;
IntConstantValue rightInt = right;
BigInt result = leftInt.intValue + rightInt.intValue;
- return ConstantSystem.only.createInt(result);
+ return createInt(result);
} else if (left.isNum && right.isNum) {
NumConstantValue leftNum = left;
NumConstantValue rightNum = right;
double result = leftNum.doubleValue + rightNum.doubleValue;
- return ConstantSystem.only.createDouble(result);
+ return createDouble(result);
} else if (left.isString && right.isString) {
StringConstantValue leftString = left;
StringConstantValue rightString = right;
String result = leftString.stringValue + rightString.stringValue;
- return ConstantSystem.only.createString(result);
+ return createString(result);
} else {
return null;
}
@@ -392,7 +631,7 @@
ConstantValue fold(ConstantValue left, ConstantValue right) {
ConstantValue result = _addOperation.fold(left, right);
if (result != null && result.isNum) {
- return ConstantSystem.only.convertToJavaScriptConstant(result);
+ return _convertToJavaScriptConstant(result);
}
return result;
}
@@ -415,7 +654,7 @@
foldedValue = foldNums(leftNum.doubleValue, rightNum.doubleValue);
}
assert(foldedValue != null);
- return ConstantSystem.only.createBool(foldedValue);
+ return createBool(foldedValue);
}
bool foldInts(BigInt left, BigInt right);
@@ -464,26 +703,26 @@
IntConstantValue leftInt = left;
IntConstantValue rightInt = right;
bool result = leftInt.intValue == rightInt.intValue;
- return ConstantSystem.only.createBool(result);
+ return createBool(result);
}
if (left.isNum && right.isNum) {
NumConstantValue leftNum = left;
NumConstantValue rightNum = right;
bool result = leftNum.doubleValue == rightNum.doubleValue;
- return ConstantSystem.only.createBool(result);
+ return createBool(result);
}
if (left.isConstructedObject) {
if (right.isNull) {
- return ConstantSystem.only.createBool(false);
+ return createBool(false);
}
// Unless we know that the user-defined object does not implement the
// equality operator we cannot fold here.
return null;
}
- return ConstantSystem.only.createBool(left == right);
+ return createBool(left == right);
}
apply(left, right) => left == right;
@@ -497,7 +736,7 @@
// constant fold NaN === NaN. Otherwise the output depends on inlined
// variables and other optimizations.
if (left.isNaN && right.isNaN) return null;
- return ConstantSystem.only.createBool(left == right);
+ return createBool(left == right);
}
apply(left, right) => identical(left, right);
@@ -561,7 +800,7 @@
int index = indexConstant.intValue.toInt();
if (index < 0 || index >= string.length) return null;
int value = string.codeUnitAt(index);
- return ConstantSystem.only.createIntFromInt(value);
+ return createIntFromInt(value);
}
return null;
}
@@ -569,7 +808,7 @@
class JavaScriptRoundOperation implements UnaryOperation {
const JavaScriptRoundOperation();
- String get name => ConstantSystem.only.round.name;
+ String get name => round.name;
ConstantValue fold(ConstantValue constant) {
// Be careful to round() only values that do not throw on either the host or
// target platform.
@@ -583,7 +822,7 @@
double rounded1 = (value * (1.0 + severalULP)).roundToDouble();
double rounded2 = (value * (1.0 - severalULP)).roundToDouble();
if (rounded != rounded1 || rounded != rounded2) return null;
- return ConstantSystem.only.convertToJavaScriptConstant(
+ return _convertToJavaScriptConstant(
new IntConstantValue(new BigInt.from(value.round())));
}
@@ -614,258 +853,12 @@
}
}
-/// Constant system following the semantics for Dart code that has been
-/// compiled to JavaScript.
-class ConstantSystem {
- final BITS32 = new BigInt.from(0xFFFFFFFF);
-
- final add = const JavaScriptAddOperation();
- final bitAnd = const JavaScriptBinaryBitOperation(const BitAndOperation());
- final bitNot = const BitNotOperation();
- final bitOr = const JavaScriptBinaryBitOperation(const BitOrOperation());
- final bitXor = const JavaScriptBinaryBitOperation(const BitXorOperation());
- final booleanAnd = const BooleanAndOperation();
- final booleanOr = const BooleanOrOperation();
- final divide =
- const JavaScriptBinaryArithmeticOperation(const DivideOperation());
- final equal = const EqualsOperation();
- final greaterEqual = const GreaterEqualOperation();
- final greater = const GreaterOperation();
- final identity = const JavaScriptIdentityOperation();
- final ifNull = const IfNullOperation();
- final lessEqual = const LessEqualOperation();
- final less = const LessOperation();
- final modulo =
- const JavaScriptBinaryArithmeticOperation(const ModuloOperation());
- final multiply =
- const JavaScriptBinaryArithmeticOperation(const MultiplyOperation());
- final negate = const JavaScriptNegateOperation();
- final not = const NotOperation();
- final remainder = const JavaScriptRemainderOperation();
- final shiftLeft =
- const JavaScriptBinaryBitOperation(const ShiftLeftOperation());
- final shiftRight = const JavaScriptShiftRightOperation();
- final subtract =
- const JavaScriptBinaryArithmeticOperation(const SubtractOperation());
- final truncatingDivide = const JavaScriptBinaryArithmeticOperation(
- const TruncatingDivideOperation());
- final codeUnitAt = const CodeUnitAtRuntimeOperation();
- final round = const JavaScriptRoundOperation();
- final abs = const UnfoldedUnaryOperation('abs');
-
- static final ConstantSystem only = new ConstantSystem._internal();
-
- ConstantSystem._internal();
-
- /// Returns true if [value] will turn into NaN or infinity
- /// at runtime.
- bool integerBecomesNanOrInfinity(BigInt value) {
- double doubleValue = value.toDouble();
- return doubleValue.isNaN || doubleValue.isInfinite;
- }
-
- NumConstantValue convertToJavaScriptConstant(NumConstantValue constant) {
- if (constant.isInt) {
- IntConstantValue intConstant = constant;
- BigInt intValue = intConstant.intValue;
- if (integerBecomesNanOrInfinity(intValue)) {
- return new DoubleConstantValue(intValue.toDouble());
- }
- // If the integer loses precision with JavaScript numbers, use
- // the floored version JavaScript will use.
- BigInt floorValue = new BigInt.from(intValue.toDouble());
- if (floorValue != intValue) {
- return new IntConstantValue(floorValue);
- }
- } else if (constant.isDouble) {
- DoubleConstantValue doubleResult = constant;
- double doubleValue = doubleResult.doubleValue;
- if (!doubleValue.isInfinite &&
- !doubleValue.isNaN &&
- !constant.isMinusZero) {
- double truncated = doubleValue.truncateToDouble();
- if (truncated == doubleValue) {
- return new IntConstantValue(new BigInt.from(truncated));
- }
- }
- }
- return constant;
- }
-
- NumConstantValue createInt(BigInt i) =>
- convertToJavaScriptConstant(new IntConstantValue(i));
- NumConstantValue createIntFromInt(int i) => createInt(new BigInt.from(i));
- NumConstantValue createInt32(BigInt i) => new IntConstantValue(i & BITS32);
- NumConstantValue createDouble(double d) =>
- convertToJavaScriptConstant(new DoubleConstantValue(d));
- StringConstantValue createString(String string) =>
- new StringConstantValue(string);
- BoolConstantValue createBool(bool value) => new BoolConstantValue(value);
- NullConstantValue createNull() => new NullConstantValue();
- ListConstantValue createList(
- InterfaceType type, List<ConstantValue> values) =>
- new ListConstantValue(type, values);
-
- ConstantValue createType(CommonElements commonElements, DartType type) {
- InterfaceType instanceType = commonElements.typeLiteralType;
- return new TypeConstantValue(type, instanceType);
- }
-
- /// Returns true if the [constant] is an integer at runtime.
- ///
- /// Integer checks report true for -0.0, INFINITY, and -INFINITY. At
- /// runtime an 'X is int' check is implemented as:
- ///
- /// typeof(X) === "number" && Math.floor(X) === X
- ///
- /// We consistently match that runtime semantics at compile time as well.
- bool isInt(ConstantValue constant) =>
- constant.isInt ||
- constant.isMinusZero ||
- constant.isPositiveInfinity ||
- constant.isNegativeInfinity;
-
- /// Returns true if the [constant] is a double at runtime.
- bool isDouble(ConstantValue constant) =>
- constant.isDouble && !constant.isMinusZero;
-
- /// Returns true if the [constant] is a string at runtime.
- bool isString(ConstantValue constant) => constant.isString;
-
- /// Returns true if the [constant] is a boolean at runtime.
- bool isBool(ConstantValue constant) => constant.isBool;
-
- /// Returns true if the [constant] is null at runtime.
- bool isNull(ConstantValue constant) => constant.isNull;
-
- bool isSubtype(DartTypes types, DartType s, DartType t) {
- // At runtime, an integer is both an integer and a double: the
- // integer type check is Math.floor, which will return true only
- // for real integers, and our double type check is 'typeof number'
- // which will return true for both integers and doubles.
- if (s == types.commonElements.intType &&
- t == types.commonElements.doubleType) {
- return true;
- }
- return types.isSubtype(s, t);
- }
-
- SetConstantValue createSet(CommonElements commonElements,
- InterfaceType sourceType, List<ConstantValue> values) {
- InterfaceType type = commonElements.getConstantSetTypeFor(sourceType);
- return new JavaScriptSetConstant(commonElements, type, values);
- }
-
- MapConstantValue createMap(
- CommonElements commonElements,
- InterfaceType sourceType,
- List<ConstantValue> keys,
- List<ConstantValue> values) {
- bool onlyStringKeys = true;
- ConstantValue protoValue = null;
- for (int i = 0; i < keys.length; i++) {
- dynamic key = keys[i];
- if (key.isString) {
- if (key.stringValue == JavaScriptMapConstant.PROTO_PROPERTY) {
- protoValue = values[i];
- }
- } else {
- onlyStringKeys = false;
- // Don't handle __proto__ values specially in the general map case.
- protoValue = null;
- break;
- }
- }
-
- bool hasProtoKey = (protoValue != null);
- InterfaceType keysType;
- if (sourceType.treatAsRaw) {
- keysType = commonElements.listType();
- } else {
- keysType = commonElements.listType(sourceType.typeArguments.first);
- }
- ListConstantValue keysList = new ListConstantValue(keysType, keys);
- InterfaceType type = commonElements.getConstantMapTypeFor(sourceType,
- hasProtoKey: hasProtoKey, onlyStringKeys: onlyStringKeys);
- return new JavaScriptMapConstant(
- type, keysList, values, protoValue, onlyStringKeys);
- }
-
- ConstantValue createSymbol(CommonElements commonElements, String text) {
- InterfaceType type = commonElements.symbolImplementationType;
- FieldEntity field = commonElements.symbolField;
- ConstantValue argument = createString(text);
- // TODO(johnniwinther): Use type arguments when all uses no longer expect
- // a [FieldElement].
- var fields = <FieldEntity, ConstantValue>{field: argument};
- return new ConstructedConstantValue(type, fields);
- }
-
- UnaryOperation lookupUnary(UnaryOperator operator) {
- switch (operator.kind) {
- case UnaryOperatorKind.COMPLEMENT:
- return bitNot;
- case UnaryOperatorKind.NEGATE:
- return negate;
- case UnaryOperatorKind.NOT:
- return not;
- default:
- return null;
- }
- }
-
- BinaryOperation lookupBinary(BinaryOperator operator) {
- switch (operator.kind) {
- case BinaryOperatorKind.ADD:
- return add;
- case BinaryOperatorKind.SUB:
- return subtract;
- case BinaryOperatorKind.MUL:
- return multiply;
- case BinaryOperatorKind.DIV:
- return divide;
- case BinaryOperatorKind.MOD:
- return modulo;
- case BinaryOperatorKind.IDIV:
- return truncatingDivide;
- case BinaryOperatorKind.OR:
- return bitOr;
- case BinaryOperatorKind.AND:
- return bitAnd;
- case BinaryOperatorKind.XOR:
- return bitXor;
- case BinaryOperatorKind.LOGICAL_OR:
- return booleanOr;
- case BinaryOperatorKind.LOGICAL_AND:
- return booleanAnd;
- case BinaryOperatorKind.SHL:
- return shiftLeft;
- case BinaryOperatorKind.SHR:
- return shiftRight;
- case BinaryOperatorKind.LT:
- return less;
- case BinaryOperatorKind.LTEQ:
- return lessEqual;
- case BinaryOperatorKind.GT:
- return greater;
- case BinaryOperatorKind.GTEQ:
- return greaterEqual;
- case BinaryOperatorKind.EQ:
- return equal;
- case BinaryOperatorKind.IF_NULL:
- return ifNull;
- default:
- return null;
- }
- }
-}
-
class JavaScriptSetConstant extends SetConstantValue {
final MapConstantValue entries;
JavaScriptSetConstant(CommonElements commonElements, InterfaceType type,
List<ConstantValue> values)
- : entries = ConstantSystem.only.createMap(
+ : entries = createMap(
commonElements,
commonElements.mapType(
type.typeArguments.first, commonElements.nullType),
diff --git a/pkg/compiler/lib/src/constants/expressions.dart b/pkg/compiler/lib/src/constants/expressions.dart
index 2e40a0c..d67fa7a 100644
--- a/pkg/compiler/lib/src/constants/expressions.dart
+++ b/pkg/compiler/lib/src/constants/expressions.dart
@@ -7,8 +7,8 @@
import 'dart:collection';
import '../common.dart';
-import '../constants/constant_system.dart';
import '../common_elements.dart';
+import '../constants/constant_system.dart' as constant_system;
import '../elements/entities.dart';
import '../elements/operators.dart';
import '../elements/types.dart';
@@ -73,10 +73,8 @@
/// Substitute free variables using arguments.
ConstantExpression apply(NormalizedArguments arguments) => this;
- /// Compute the [ConstantValue] for this expression using the [environment]
- /// and the [constantSystem].
- ConstantValue evaluate(
- EvaluationEnvironment environment, ConstantSystem constantSystem);
+ /// Compute the [ConstantValue] for this expression using the [environment].
+ ConstantValue evaluate(EvaluationEnvironment environment);
/// Returns the type of this constant expression, if it is independent of the
/// environment values.
@@ -145,8 +143,7 @@
}
@override
- ConstantValue evaluate(
- EvaluationEnvironment environment, ConstantSystem constantSystem) {
+ ConstantValue evaluate(EvaluationEnvironment environment) {
// TODO(johnniwinther): Use non-constant values for errors.
return new NonConstantValue();
}
@@ -181,9 +178,8 @@
}
@override
- ConstantValue evaluate(
- EvaluationEnvironment environment, ConstantSystem constantSystem) {
- return constantSystem.createBool(boolValue);
+ ConstantValue evaluate(EvaluationEnvironment environment) {
+ return constant_system.createBool(boolValue);
}
@override
@@ -217,9 +213,8 @@
}
@override
- ConstantValue evaluate(
- EvaluationEnvironment environment, ConstantSystem constantSystem) {
- return constantSystem.createInt(intValue);
+ ConstantValue evaluate(EvaluationEnvironment environment) {
+ return constant_system.createInt(intValue);
}
@override
@@ -253,9 +248,8 @@
}
@override
- ConstantValue evaluate(
- EvaluationEnvironment environment, ConstantSystem constantSystem) {
- return constantSystem.createDouble(doubleValue);
+ ConstantValue evaluate(EvaluationEnvironment environment) {
+ return constant_system.createDouble(doubleValue);
}
@override
@@ -289,9 +283,8 @@
}
@override
- ConstantValue evaluate(
- EvaluationEnvironment environment, ConstantSystem constantSystem) {
- return constantSystem.createString(stringValue);
+ ConstantValue evaluate(EvaluationEnvironment environment) {
+ return constant_system.createString(stringValue);
}
@override
@@ -323,9 +316,8 @@
}
@override
- ConstantValue evaluate(
- EvaluationEnvironment environment, ConstantSystem constantSystem) {
- return constantSystem.createNull();
+ ConstantValue evaluate(EvaluationEnvironment environment) {
+ return constant_system.createNull();
}
@override
@@ -365,10 +357,9 @@
}
@override
- ConstantValue evaluate(
- EvaluationEnvironment environment, ConstantSystem constantSystem) {
- return constantSystem.createList(type,
- values.map((v) => v.evaluate(environment, constantSystem)).toList());
+ ConstantValue evaluate(EvaluationEnvironment environment) {
+ return constant_system.createList(
+ type, values.map((v) => v.evaluate(environment)).toList());
}
ConstantExpression apply(NormalizedArguments arguments) {
@@ -426,19 +417,18 @@
type, values.map((v) => v.apply(arguments)).toList());
@override
- ConstantValue evaluate(
- EvaluationEnvironment environment, ConstantSystem constantSystem) {
+ ConstantValue evaluate(EvaluationEnvironment environment) {
// TODO(fishythefish): Delete once the CFE provides these error messages.
Set<ConstantValue> set = new LinkedHashSet<ConstantValue>();
for (int i = 0; i < values.length; i++) {
- ConstantValue value = values[i].evaluate(environment, constantSystem);
+ ConstantValue value = values[i].evaluate(environment);
if (!value.isConstant) return new NonConstantValue();
if (!set.add(value)) {
environment.reportError(values[i], MessageKind.EQUAL_SET_ENTRY, {});
}
}
- return constantSystem.createSet(
+ return constant_system.createSet(
environment.commonElements, type, set.toList());
}
@@ -506,18 +496,17 @@
}
@override
- ConstantValue evaluate(
- EvaluationEnvironment environment, ConstantSystem constantSystem) {
+ ConstantValue evaluate(EvaluationEnvironment environment) {
// TODO(sigmund): delete once the CFE provides these error messages.
bool isSetLiteral = environment.immediateUnderSetLiteral;
return environment.evaluateMapBody(() {
Map<ConstantValue, ConstantValue> map = <ConstantValue, ConstantValue>{};
for (int i = 0; i < keys.length; i++) {
- ConstantValue key = keys[i].evaluate(environment, constantSystem);
+ ConstantValue key = keys[i].evaluate(environment);
if (!key.isConstant) {
return new NonConstantValue();
}
- ConstantValue value = values[i].evaluate(environment, constantSystem);
+ ConstantValue value = values[i].evaluate(environment);
if (!value.isConstant) {
return new NonConstantValue();
}
@@ -531,7 +520,7 @@
}
map[key] = value;
}
- return constantSystem.createMap(environment.commonElements, type,
+ return constant_system.createMap(environment.commonElements, type,
map.keys.toList(), map.values.toList());
});
}
@@ -628,8 +617,7 @@
}
@override
- ConstantValue evaluate(
- EvaluationEnvironment environment, ConstantSystem constantSystem) {
+ ConstantValue evaluate(EvaluationEnvironment environment) {
InterfaceType instanceType = computeInstanceType(environment);
return environment.evaluateConstructor(target, instanceType, () {
InstanceData instanceData = computeInstanceData(environment);
@@ -641,7 +629,7 @@
<FieldEntity, ConstantValue>{};
instanceData.fieldMap
.forEach((FieldEntity field, ConstantExpression constant) {
- ConstantValue value = constant.evaluate(environment, constantSystem);
+ ConstantValue value = constant.evaluate(environment);
assert(
value != null,
failedAt(CURRENT_ELEMENT_SPANNABLE,
@@ -653,7 +641,7 @@
}
});
for (AssertConstantExpression assertion in instanceData.assertions) {
- if (!assertion.evaluate(environment, constantSystem).isConstant) {
+ if (!assertion.evaluate(environment).isConstant) {
isValidAsConstant = false;
}
}
@@ -725,12 +713,11 @@
}
@override
- ConstantValue evaluate(
- EvaluationEnvironment environment, ConstantSystem constantSystem) {
+ ConstantValue evaluate(EvaluationEnvironment environment) {
bool isValid = true;
StringBuffer sb = new StringBuffer();
for (ConstantExpression expression in expressions) {
- ConstantValue value = expression.evaluate(environment, constantSystem);
+ ConstantValue value = expression.evaluate(environment);
if (!value.isConstant) {
isValid = false;
// Use `continue` instead of `return` here to report all errors in the
@@ -762,7 +749,7 @@
}
}
if (isValid) {
- return constantSystem.createString(sb.toString());
+ return constant_system.createString(sb.toString());
}
return new NonConstantValue();
}
@@ -821,9 +808,8 @@
}
@override
- ConstantValue evaluate(
- EvaluationEnvironment environment, ConstantSystem constantSystem) {
- return constantSystem.createSymbol(environment.commonElements, name);
+ ConstantValue evaluate(EvaluationEnvironment environment) {
+ return constant_system.createSymbol(environment.commonElements, name);
}
@override
@@ -854,9 +840,8 @@
}
@override
- ConstantValue evaluate(
- EvaluationEnvironment environment, ConstantSystem constantSystem) {
- return constantSystem.createType(environment.commonElements, type);
+ ConstantValue evaluate(EvaluationEnvironment environment) {
+ return constant_system.createType(environment.commonElements, type);
}
@override
@@ -894,8 +879,7 @@
}
@override
- ConstantValue evaluate(
- EvaluationEnvironment environment, ConstantSystem constantSystem) {
+ ConstantValue evaluate(EvaluationEnvironment environment) {
// Running example for comments:
//
// class A<T> {
@@ -910,8 +894,7 @@
// We visit `t as A.T` while evaluating `const B<num>(0)`.
// The expression value is `0`.
- ConstantValue expressionValue =
- expression.evaluate(environment, constantSystem);
+ ConstantValue expressionValue = expression.evaluate(environment);
if (!environment.checkCasts) return expressionValue;
@@ -924,7 +907,7 @@
// Check that the expression type, `int`, is a subtype of the type in
// context, `num`.
- if (!constantSystem.isSubtype(
+ if (!constant_system.isSubtype(
environment.types, expressionType, typeInContext)) {
// TODO(sigmund): consider reporting different messages and error
// locations for implicit vs explicit casts.
@@ -971,11 +954,10 @@
}
@override
- ConstantValue evaluate(
- EvaluationEnvironment environment, ConstantSystem constantSystem) {
+ ConstantValue evaluate(EvaluationEnvironment environment) {
return environment.evaluateField(element, () {
ConstantExpression constant = environment.getFieldConstant(element);
- return constant.evaluate(environment, constantSystem);
+ return constant.evaluate(environment);
});
}
@@ -1006,10 +988,9 @@
}
@override
- ConstantValue evaluate(
- EvaluationEnvironment environment, ConstantSystem constantSystem) {
+ ConstantValue evaluate(EvaluationEnvironment environment) {
ConstantExpression constant = environment.getLocalConstant(element);
- return constant.evaluate(environment, constantSystem);
+ return constant.evaluate(environment);
}
@override
@@ -1040,8 +1021,7 @@
}
@override
- ConstantValue evaluate(
- EvaluationEnvironment environment, ConstantSystem constantSystem) {
+ ConstantValue evaluate(EvaluationEnvironment environment) {
return new FunctionConstantValue(element, type);
}
@@ -1088,10 +1068,9 @@
}
@override
- ConstantValue evaluate(
- EvaluationEnvironment environment, ConstantSystem constantSystem) {
- ConstantValue leftValue = left.evaluate(environment, constantSystem);
- ConstantValue rightValue = right.evaluate(environment, constantSystem);
+ ConstantValue evaluate(EvaluationEnvironment environment) {
+ ConstantValue leftValue = left.evaluate(environment);
+ ConstantValue rightValue = right.evaluate(environment);
if (!leftValue.isConstant || !rightValue.isConstant) {
return new NonConstantValue();
}
@@ -1293,11 +1272,12 @@
switch (operator.kind) {
case BinaryOperatorKind.NOT_EQ:
BoolConstantValue equals =
- constantSystem.equal.fold(leftValue, rightValue);
+ constant_system.equal.fold(leftValue, rightValue);
return equals.negate();
default:
- ConstantValue value =
- constantSystem.lookupBinary(operator).fold(leftValue, rightValue);
+ ConstantValue value = constant_system
+ .lookupBinary(operator)
+ .fold(leftValue, rightValue);
if (value != null) {
return value;
}
@@ -1432,12 +1412,11 @@
}
@override
- ConstantValue evaluate(
- EvaluationEnvironment environment, ConstantSystem constantSystem) {
- ConstantValue leftValue = left.evaluate(environment, constantSystem);
- ConstantValue rightValue = right.evaluate(environment, constantSystem);
+ ConstantValue evaluate(EvaluationEnvironment environment) {
+ ConstantValue leftValue = left.evaluate(environment);
+ ConstantValue rightValue = right.evaluate(environment);
if (leftValue.isConstant && rightValue.isConstant) {
- return constantSystem.identity.fold(leftValue, rightValue);
+ return constant_system.identity.fold(leftValue, rightValue);
}
return new NonConstantValue();
}
@@ -1492,10 +1471,8 @@
}
@override
- ConstantValue evaluate(
- EvaluationEnvironment environment, ConstantSystem constantSystem) {
- ConstantValue expressionValue =
- expression.evaluate(environment, constantSystem);
+ ConstantValue evaluate(EvaluationEnvironment environment) {
+ ConstantValue expressionValue = expression.evaluate(environment);
bool isValid = true;
switch (operator.kind) {
case UnaryOperatorKind.NOT:
@@ -1534,7 +1511,7 @@
}
if (isValid) {
ConstantValue value =
- constantSystem.lookupUnary(operator).fold(expressionValue);
+ constant_system.lookupUnary(operator).fold(expressionValue);
if (value != null) {
return value;
}
@@ -1595,9 +1572,8 @@
}
@override
- ConstantValue evaluate(
- EvaluationEnvironment environment, ConstantSystem constantSystem) {
- ConstantValue value = expression.evaluate(environment, constantSystem);
+ ConstantValue evaluate(EvaluationEnvironment environment) {
+ ConstantValue value = expression.evaluate(environment);
if (!value.isString) {
environment.reportError(
expression, MessageKind.INVALID_CONSTANT_STRING_LENGTH_TYPE, {
@@ -1607,7 +1583,7 @@
return new NonConstantValue();
} else {
StringConstantValue stringValue = value;
- return constantSystem
+ return constant_system
.createInt(new BigInt.from(stringValue.stringValue.length));
}
}
@@ -1685,12 +1661,10 @@
}
@override
- ConstantValue evaluate(
- EvaluationEnvironment environment, ConstantSystem constantSystem) {
- ConstantValue conditionValue =
- condition.evaluate(environment, constantSystem);
- ConstantValue trueValue = trueExp.evaluate(environment, constantSystem);
- ConstantValue falseValue = falseExp.evaluate(environment, constantSystem);
+ ConstantValue evaluate(EvaluationEnvironment environment) {
+ ConstantValue conditionValue = condition.evaluate(environment);
+ ConstantValue trueValue = trueExp.evaluate(environment);
+ ConstantValue falseValue = falseExp.evaluate(environment);
bool isValid = true;
if (!conditionValue.isBool) {
environment.reportError(
@@ -1756,8 +1730,7 @@
bool _equals(PositionalArgumentReference other) => index == other.index;
@override
- ConstantValue evaluate(
- EvaluationEnvironment environment, ConstantSystem constantSystem) {
+ ConstantValue evaluate(EvaluationEnvironment environment) {
return new NonConstantValue();
}
@@ -1795,8 +1768,7 @@
bool _equals(NamedArgumentReference other) => name == other.name;
@override
- ConstantValue evaluate(
- EvaluationEnvironment environment, ConstantSystem constantSystem) {
+ ConstantValue evaluate(EvaluationEnvironment environment) {
return new NonConstantValue();
}
@@ -1874,15 +1846,13 @@
}
@override
- ConstantValue evaluate(
- EvaluationEnvironment environment, ConstantSystem constantSystem) {
- ConstantValue nameConstantValue =
- name.evaluate(environment, constantSystem);
+ ConstantValue evaluate(EvaluationEnvironment environment) {
+ ConstantValue nameConstantValue = name.evaluate(environment);
ConstantValue defaultConstantValue;
if (defaultValue != null) {
- defaultConstantValue = defaultValue.evaluate(environment, constantSystem);
+ defaultConstantValue = defaultValue.evaluate(environment);
} else {
- defaultConstantValue = constantSystem.createBool(false);
+ defaultConstantValue = constant_system.createBool(false);
}
if (!nameConstantValue.isConstant || !defaultConstantValue.isConstant) {
return new NonConstantValue();
@@ -1904,9 +1874,9 @@
String text =
environment.readFromEnvironment(nameStringConstantValue.stringValue);
if (text == 'true') {
- return constantSystem.createBool(true);
+ return constant_system.createBool(true);
} else if (text == 'false') {
- return constantSystem.createBool(false);
+ return constant_system.createBool(false);
} else {
return defaultConstantValue;
}
@@ -1953,15 +1923,13 @@
}
@override
- ConstantValue evaluate(
- EvaluationEnvironment environment, ConstantSystem constantSystem) {
- ConstantValue nameConstantValue =
- name.evaluate(environment, constantSystem);
+ ConstantValue evaluate(EvaluationEnvironment environment) {
+ ConstantValue nameConstantValue = name.evaluate(environment);
ConstantValue defaultConstantValue;
if (defaultValue != null) {
- defaultConstantValue = defaultValue.evaluate(environment, constantSystem);
+ defaultConstantValue = defaultValue.evaluate(environment);
} else {
- defaultConstantValue = constantSystem.createNull();
+ defaultConstantValue = constant_system.createNull();
}
if (!nameConstantValue.isConstant || !defaultConstantValue.isConstant) {
return new NonConstantValue();
@@ -1989,7 +1957,7 @@
if (value == null) {
return defaultConstantValue;
} else {
- return constantSystem.createInt(value);
+ return constant_system.createInt(value);
}
}
return new NonConstantValue();
@@ -2034,15 +2002,13 @@
}
@override
- ConstantValue evaluate(
- EvaluationEnvironment environment, ConstantSystem constantSystem) {
- ConstantValue nameConstantValue =
- name.evaluate(environment, constantSystem);
+ ConstantValue evaluate(EvaluationEnvironment environment) {
+ ConstantValue nameConstantValue = name.evaluate(environment);
ConstantValue defaultConstantValue;
if (defaultValue != null) {
- defaultConstantValue = defaultValue.evaluate(environment, constantSystem);
+ defaultConstantValue = defaultValue.evaluate(environment);
} else {
- defaultConstantValue = constantSystem.createNull();
+ defaultConstantValue = constant_system.createNull();
}
if (!nameConstantValue.isConstant || !defaultConstantValue.isConstant) {
return new NonConstantValue();
@@ -2066,7 +2032,7 @@
if (text == null) {
return defaultConstantValue;
} else {
- return constantSystem.createString(text);
+ return constant_system.createString(text);
}
}
return new NonConstantValue();
@@ -2115,10 +2081,8 @@
}
@override
- ConstantValue evaluate(
- EvaluationEnvironment environment, ConstantSystem constantSystem) {
- ConstantValue conditionValue =
- condition.evaluate(environment, constantSystem);
+ ConstantValue evaluate(EvaluationEnvironment environment) {
+ ConstantValue conditionValue = condition.evaluate(environment);
bool validAssert;
if (environment.enableAssertions) {
// Boolean conversion:
@@ -2129,7 +2093,7 @@
}
if (!validAssert) {
if (message != null) {
- ConstantValue value = message.evaluate(environment, constantSystem);
+ ConstantValue value = message.evaluate(environment);
if (value is StringConstantValue) {
String text = '${value.stringValue}';
environment.reportError(this,
@@ -2177,12 +2141,11 @@
}
@override
- ConstantValue evaluate(
- EvaluationEnvironment environment, ConstantSystem constantSystem) {
+ ConstantValue evaluate(EvaluationEnvironment environment) {
List<DartType> typeArgumentsInContext =
typeArguments.map(environment.getTypeInContext).toList();
- return new InstantiationConstantValue(typeArgumentsInContext,
- expression.evaluate(environment, constantSystem));
+ return new InstantiationConstantValue(
+ typeArgumentsInContext, expression.evaluate(environment));
}
@override
diff --git a/pkg/compiler/lib/src/inferrer/builder_kernel.dart b/pkg/compiler/lib/src/inferrer/builder_kernel.dart
index dbe357f..518bf66 100644
--- a/pkg/compiler/lib/src/inferrer/builder_kernel.dart
+++ b/pkg/compiler/lib/src/inferrer/builder_kernel.dart
@@ -7,7 +7,7 @@
import '../closure.dart';
import '../common.dart';
import '../common/names.dart';
-import '../constants/constant_system.dart';
+import '../constants/constant_system.dart' as constant_system;
import '../constants/values.dart';
import '../elements/entities.dart';
import '../elements/jumps.dart';
@@ -681,24 +681,20 @@
}
@override
- TypeInformation visitIntLiteral(ir.IntLiteral node) {
- ConstantSystem constantSystem = _closedWorld.constantSystem;
- // The JavaScript backend may turn this literal into a double at
- // runtime.
- return _types.getConcreteTypeFor(_closedWorld.abstractValueDomain
- .computeAbstractValueForConstant(
- constantSystem.createIntFromInt(node.value)));
- }
+ TypeInformation visitIntLiteral(ir.IntLiteral node) =>
+ // The JavaScript backend may turn this literal into a double at
+ // runtime.
+ _types.getConcreteTypeFor(_closedWorld.abstractValueDomain
+ .computeAbstractValueForConstant(
+ constant_system.createIntFromInt(node.value)));
@override
- TypeInformation visitDoubleLiteral(ir.DoubleLiteral node) {
- ConstantSystem constantSystem = _closedWorld.constantSystem;
- // The JavaScript backend may turn this literal into an integer at
- // runtime.
- return _types.getConcreteTypeFor(_closedWorld.abstractValueDomain
- .computeAbstractValueForConstant(
- constantSystem.createDouble(node.value)));
- }
+ TypeInformation visitDoubleLiteral(ir.DoubleLiteral node) =>
+ // The JavaScript backend may turn this literal into an integer at
+ // runtime.
+ _types.getConcreteTypeFor(_closedWorld.abstractValueDomain
+ .computeAbstractValueForConstant(
+ constant_system.createDouble(node.value)));
@override
TypeInformation visitStringLiteral(ir.StringLiteral node) {
diff --git a/pkg/compiler/lib/src/inferrer/typemasks/constants.dart b/pkg/compiler/lib/src/inferrer/typemasks/constants.dart
index 5f2e7a9..9b5232f 100644
--- a/pkg/compiler/lib/src/inferrer/typemasks/constants.dart
+++ b/pkg/compiler/lib/src/inferrer/typemasks/constants.dart
@@ -5,6 +5,7 @@
library types.constants;
import '../../common.dart';
+import '../../constants/constant_system.dart' as constant_system;
import '../../constants/values.dart';
import '../../js_backend/js_backend.dart' show SyntheticConstantKind;
import '../../world.dart' show JClosedWorld;
@@ -37,7 +38,7 @@
@override
TypeMask visitDouble(DoubleConstantValue constant, JClosedWorld closedWorld) {
// We have to recognize double constants that are 'is int'.
- if (closedWorld.constantSystem.isInt(constant)) {
+ if (constant_system.isInt(constant)) {
if (constant.isMinusZero) {
return closedWorld.abstractValueDomain.uint31Type;
} else {
diff --git a/pkg/compiler/lib/src/js_backend/backend.dart b/pkg/compiler/lib/src/js_backend/backend.dart
index 067474c..5526dbf 100644
--- a/pkg/compiler/lib/src/js_backend/backend.dart
+++ b/pkg/compiler/lib/src/js_backend/backend.dart
@@ -12,7 +12,6 @@
import '../common_elements.dart'
show CommonElements, ElementEnvironment, JElementEnvironment;
import '../compiler.dart' show Compiler;
-import '../constants/constant_system.dart';
import '../deferred_load.dart' show DeferredLoadTask;
import '../dump_info.dart' show DumpInfoTask;
import '../elements/entities.dart';
@@ -400,10 +399,6 @@
this, compiler.measurer, sourceInformationStrategy);
}
- /// The [ConstantSystem] used to interpret compile-time constants for this
- /// backend.
- ConstantSystem get constantSystem => constants.constantSystem;
-
DiagnosticReporter get reporter => compiler.reporter;
ImpactCacheDeleter get impactCacheDeleter => compiler.impactCacheDeleter;
@@ -546,7 +541,6 @@
compiler.frontendStrategy.createNativeClassFinder(nativeBasicData));
_nativeDataBuilder = new NativeDataBuilderImpl(nativeBasicData);
_customElementsResolutionAnalysis = new CustomElementsResolutionAnalysis(
- constantSystem,
elementEnvironment,
commonElements,
nativeBasicData,
@@ -620,10 +614,7 @@
CommonElements commonElements = closedWorld.commonElements;
BackendImpacts impacts = new BackendImpacts(commonElements);
_customElementsCodegenAnalysis = new CustomElementsCodegenAnalysis(
- constantSystem,
- commonElements,
- elementEnvironment,
- closedWorld.nativeData);
+ commonElements, elementEnvironment, closedWorld.nativeData);
_nativeCodegenEnqueuer = new NativeCodegenEnqueuer(
compiler.options,
elementEnvironment,
diff --git a/pkg/compiler/lib/src/js_backend/constant_emitter.dart b/pkg/compiler/lib/src/js_backend/constant_emitter.dart
index 44fdb82..7a77ae5 100644
--- a/pkg/compiler/lib/src/js_backend/constant_emitter.dart
+++ b/pkg/compiler/lib/src/js_backend/constant_emitter.dart
@@ -4,7 +4,7 @@
import '../common.dart';
import '../common_elements.dart';
-import '../constants/constant_system.dart';
+import '../constants/constant_system.dart' as constant_system;
import '../constants/values.dart';
import '../elements/entities.dart';
import '../elements/types.dart';
@@ -184,7 +184,8 @@
}
@override
- jsAst.Expression visitSet(JavaScriptSetConstant constant, [_]) {
+ jsAst.Expression visitSet(constant_system.JavaScriptSetConstant constant,
+ [_]) {
InterfaceType sourceType = constant.type;
ClassEntity classElement = sourceType.element;
String className = classElement.name;
@@ -206,12 +207,14 @@
}
@override
- jsAst.Expression visitMap(JavaScriptMapConstant constant, [_]) {
+ jsAst.Expression visitMap(constant_system.JavaScriptMapConstant constant,
+ [_]) {
jsAst.Expression jsMap() {
List<jsAst.Property> properties = <jsAst.Property>[];
for (int i = 0; i < constant.length; i++) {
StringConstantValue key = constant.keys[i];
- if (key.stringValue == JavaScriptMapConstant.PROTO_PROPERTY) {
+ if (key.stringValue ==
+ constant_system.JavaScriptMapConstant.PROTO_PROPERTY) {
continue;
}
@@ -248,17 +251,21 @@
_worldBuilder.forEachInstanceField(classElement,
(ClassEntity enclosing, FieldEntity field, {bool isElided}) {
if (isElided) return;
- if (field.name == JavaScriptMapConstant.LENGTH_NAME) {
+ if (field.name == constant_system.JavaScriptMapConstant.LENGTH_NAME) {
arguments
.add(new jsAst.LiteralNumber('${constant.keyList.entries.length}'));
- } else if (field.name == JavaScriptMapConstant.JS_OBJECT_NAME) {
+ } else if (field.name ==
+ constant_system.JavaScriptMapConstant.JS_OBJECT_NAME) {
arguments.add(jsMap());
- } else if (field.name == JavaScriptMapConstant.KEYS_NAME) {
+ } else if (field.name ==
+ constant_system.JavaScriptMapConstant.KEYS_NAME) {
arguments.add(constantReferenceGenerator(constant.keyList));
- } else if (field.name == JavaScriptMapConstant.PROTO_VALUE) {
+ } else if (field.name ==
+ constant_system.JavaScriptMapConstant.PROTO_VALUE) {
assert(constant.protoValue != null);
arguments.add(constantReferenceGenerator(constant.protoValue));
- } else if (field.name == JavaScriptMapConstant.JS_DATA_NAME) {
+ } else if (field.name ==
+ constant_system.JavaScriptMapConstant.JS_DATA_NAME) {
arguments.add(jsGeneralMap());
} else {
failedAt(field,
@@ -266,11 +273,12 @@
}
emittedArgumentCount++;
});
- if ((className == JavaScriptMapConstant.DART_STRING_CLASS &&
+ if ((className == constant_system.JavaScriptMapConstant.DART_STRING_CLASS &&
emittedArgumentCount != 3) ||
- (className == JavaScriptMapConstant.DART_PROTO_CLASS &&
+ (className == constant_system.JavaScriptMapConstant.DART_PROTO_CLASS &&
emittedArgumentCount != 4) ||
- (className == JavaScriptMapConstant.DART_GENERAL_CLASS &&
+ (className ==
+ constant_system.JavaScriptMapConstant.DART_GENERAL_CLASS &&
emittedArgumentCount != 1)) {
failedAt(classElement,
"Compiler and ${className} disagree on number of fields.");
diff --git a/pkg/compiler/lib/src/js_backend/constant_handler_javascript.dart b/pkg/compiler/lib/src/js_backend/constant_handler_javascript.dart
index a9b473a..1335b2e 100644
--- a/pkg/compiler/lib/src/js_backend/constant_handler_javascript.dart
+++ b/pkg/compiler/lib/src/js_backend/constant_handler_javascript.dart
@@ -4,7 +4,6 @@
import '../compile_time_constants.dart';
import '../compiler.dart' show Compiler;
-import '../constants/constant_system.dart';
import '../elements/entities.dart';
/// [ConstantCompilerTask] for compilation of constants for the JavaScript
@@ -22,9 +21,6 @@
super(compiler.measurer);
String get name => 'ConstantHandler';
-
- @override
- ConstantSystem get constantSystem => ConstantSystem.only;
}
/// The [JavaScriptConstantCompiler] is used to keep track of compile-time
@@ -37,8 +33,6 @@
JavaScriptConstantCompiler();
- ConstantSystem get constantSystem => ConstantSystem.only;
-
@override
void registerLazyStatic(FieldEntity element) {
lazyStatics.add(element);
diff --git a/pkg/compiler/lib/src/js_backend/custom_elements_analysis.dart b/pkg/compiler/lib/src/js_backend/custom_elements_analysis.dart
index 79a4453..a3c61f7 100644
--- a/pkg/compiler/lib/src/js_backend/custom_elements_analysis.dart
+++ b/pkg/compiler/lib/src/js_backend/custom_elements_analysis.dart
@@ -3,7 +3,7 @@
// BSD-style license that can be found in the LICENSE file.
import '../common_elements.dart';
-import '../constants/constant_system.dart';
+import '../constants/constant_system.dart' as constant_system;
import '../constants/values.dart';
import '../elements/entities.dart';
import '../elements/types.dart';
@@ -84,13 +84,12 @@
final CustomElementsAnalysisJoin join;
CustomElementsResolutionAnalysis(
- ConstantSystem constantSystem,
ElementEnvironment elementEnvironment,
CommonElements commonElements,
NativeBasicData nativeData,
BackendUsageBuilder backendUsageBuilder)
: join = new CustomElementsAnalysisJoin(
- constantSystem, elementEnvironment, commonElements, nativeData,
+ elementEnvironment, commonElements, nativeData,
backendUsageBuilder: backendUsageBuilder),
super(elementEnvironment, commonElements, nativeData) {
// TODO(sra): Remove this work-around. We should mark allClassesSelected in
@@ -120,13 +119,10 @@
class CustomElementsCodegenAnalysis extends CustomElementsAnalysisBase {
final CustomElementsAnalysisJoin join;
- CustomElementsCodegenAnalysis(
- ConstantSystem constantSystem,
- CommonElements commonElements,
- ElementEnvironment elementEnvironment,
- NativeBasicData nativeData)
+ CustomElementsCodegenAnalysis(CommonElements commonElements,
+ ElementEnvironment elementEnvironment, NativeBasicData nativeData)
: join = new CustomElementsAnalysisJoin(
- constantSystem, elementEnvironment, commonElements, nativeData),
+ elementEnvironment, commonElements, nativeData),
super(elementEnvironment, commonElements, nativeData) {
// TODO(sra): Remove this work-around. We should mark allClassesSelected in
// both joins only when we see a construct generating an unknown [Type] but
@@ -149,7 +145,6 @@
}
class CustomElementsAnalysisJoin {
- final ConstantSystem _constantSystem;
final ElementEnvironment _elementEnvironment;
final CommonElements _commonElements;
final NativeBasicData _nativeData;
@@ -175,8 +170,8 @@
// ClassesOutput: classes requiring metadata.
final Set<ClassEntity> activeClasses = new Set<ClassEntity>();
- CustomElementsAnalysisJoin(this._constantSystem, this._elementEnvironment,
- this._commonElements, this._nativeData,
+ CustomElementsAnalysisJoin(
+ this._elementEnvironment, this._commonElements, this._nativeData,
{BackendUsageBuilder backendUsageBuilder})
: this._backendUsageBuilder = backendUsageBuilder,
this.forResolution = backendUsageBuilder != null;
@@ -217,7 +212,7 @@
TypeConstantValue _makeTypeConstant(ClassEntity cls) {
DartType type = _elementEnvironment.getRawType(cls);
- return _constantSystem.createType(_commonElements, type);
+ return constant_system.createType(_commonElements, type);
}
List<ConstructorEntity> computeEscapingConstructors(ClassEntity cls) {
diff --git a/pkg/compiler/lib/src/js_backend/namer.dart b/pkg/compiler/lib/src/js_backend/namer.dart
index c95a90e..3222b70 100644
--- a/pkg/compiler/lib/src/js_backend/namer.dart
+++ b/pkg/compiler/lib/src/js_backend/namer.dart
@@ -14,7 +14,7 @@
import '../closure.dart';
import '../common.dart';
import '../common/names.dart' show Identifiers, Names, Selectors;
-import '../constants/constant_system.dart';
+import '../constants/constant_system.dart' as constant_system;
import '../constants/values.dart';
import '../common_elements.dart' show CommonElements, ElementEnvironment;
import '../diagnostics/invariant.dart' show DEBUG_MODE;
@@ -1982,7 +1982,7 @@
}
@override
- void visitMap(covariant JavaScriptMapConstant constant, [_]) {
+ void visitMap(covariant constant_system.JavaScriptMapConstant constant, [_]) {
// TODO(9476): Incorporate type parameters into name.
addRoot('Map');
if (constant.length == 0) {
diff --git a/pkg/compiler/lib/src/js_model/element_map_impl.dart b/pkg/compiler/lib/src/js_model/element_map_impl.dart
index a451dea..62ab66b 100644
--- a/pkg/compiler/lib/src/js_model/element_map_impl.dart
+++ b/pkg/compiler/lib/src/js_model/element_map_impl.dart
@@ -16,7 +16,6 @@
import '../common/names.dart';
import '../common_elements.dart';
import '../compile_time_constants.dart';
-import '../constants/constant_system.dart';
import '../constants/constructors.dart';
import '../constants/evaluation.dart';
import '../constants/expressions.dart';
@@ -2490,17 +2489,13 @@
JsConstantEnvironment(this._elementMap, this._environment);
- @override
- ConstantSystem get constantSystem => ConstantSystem.only;
-
ConstantValue _getConstantValue(
Spannable spannable, ConstantExpression expression,
{bool constantRequired}) {
return _valueMap.putIfAbsent(expression, () {
- return expression.evaluate(
- new JsEvaluationEnvironment(_elementMap, _environment, spannable,
- constantRequired: constantRequired),
- constantSystem);
+ return expression.evaluate(new JsEvaluationEnvironment(
+ _elementMap, _environment, spannable,
+ constantRequired: constantRequired));
});
}
}
diff --git a/pkg/compiler/lib/src/js_model/js_world.dart b/pkg/compiler/lib/src/js_model/js_world.dart
index c8c2c85..024408f 100644
--- a/pkg/compiler/lib/src/js_model/js_world.dart
+++ b/pkg/compiler/lib/src/js_model/js_world.dart
@@ -9,7 +9,6 @@
import '../common.dart';
import '../common/names.dart';
import '../common_elements.dart' show JCommonElements, JElementEnvironment;
-import '../constants/constant_system.dart';
import '../deferred_load.dart';
import '../diagnostics/diagnostic_listener.dart';
import '../elements/entities.dart';
@@ -208,8 +207,6 @@
sink.end(tag);
}
- ConstantSystem get constantSystem => ConstantSystem.only;
-
JElementEnvironment get elementEnvironment => elementMap.elementEnvironment;
JCommonElements get commonElements => elementMap.commonElements;
diff --git a/pkg/compiler/lib/src/js_model/js_world_builder.dart b/pkg/compiler/lib/src/js_model/js_world_builder.dart
index dba2384..d3cf462 100644
--- a/pkg/compiler/lib/src/js_model/js_world_builder.dart
+++ b/pkg/compiler/lib/src/js_model/js_world_builder.dart
@@ -7,7 +7,7 @@
import '../closure.dart';
import '../common.dart';
import '../common_elements.dart';
-import '../constants/constant_system.dart';
+import '../constants/constant_system.dart' as constant_system;
import '../constants/values.dart';
import '../deferred_load.dart';
import '../elements/entities.dart';
@@ -860,7 +860,8 @@
return new SetConstantValue(type, values);
}
- ConstantValue visitMap(covariant JavaScriptMapConstant constant, _) {
+ ConstantValue visitMap(
+ covariant constant_system.JavaScriptMapConstant constant, _) {
DartType type = typeConverter.visit(constant.type, toBackendEntity);
ListConstantValue keys = constant.keyList.accept(this, null);
List<ConstantValue> values = _handleValues(constant.values);
@@ -871,7 +872,7 @@
protoValue == constant.protoValue) {
return constant;
}
- return new JavaScriptMapConstant(
+ return new constant_system.JavaScriptMapConstant(
type, keys, values, protoValue, constant.onlyStringKeys);
}
diff --git a/pkg/compiler/lib/src/kernel/element_map_impl.dart b/pkg/compiler/lib/src/kernel/element_map_impl.dart
index bf08bf0..48435a1 100644
--- a/pkg/compiler/lib/src/kernel/element_map_impl.dart
+++ b/pkg/compiler/lib/src/kernel/element_map_impl.dart
@@ -17,7 +17,6 @@
import '../common/resolution.dart';
import '../common_elements.dart';
import '../compile_time_constants.dart';
-import '../constants/constant_system.dart';
import '../constants/constructors.dart';
import '../constants/evaluation.dart';
import '../constants/expressions.dart';
@@ -1873,17 +1872,13 @@
KernelConstantEnvironment(this._elementMap, this._environment);
- @override
- ConstantSystem get constantSystem => ConstantSystem.only;
-
ConstantValue _getConstantValue(
Spannable spannable, ConstantExpression expression,
{bool constantRequired, bool checkCasts: true}) {
return _valueMap.putIfAbsent(expression, () {
- return expression.evaluate(
- new KernelEvaluationEnvironment(_elementMap, _environment, spannable,
- constantRequired: constantRequired, checkCasts: checkCasts),
- constantSystem);
+ return expression.evaluate(new KernelEvaluationEnvironment(
+ _elementMap, _environment, spannable,
+ constantRequired: constantRequired, checkCasts: checkCasts));
});
}
}
diff --git a/pkg/compiler/lib/src/serialization/abstract_sink.dart b/pkg/compiler/lib/src/serialization/abstract_sink.dart
index 07db268..64dd6d9 100644
--- a/pkg/compiler/lib/src/serialization/abstract_sink.dart
+++ b/pkg/compiler/lib/src/serialization/abstract_sink.dart
@@ -401,7 +401,7 @@
writeConstants(constant.values);
break;
case ConstantValueKind.MAP:
- JavaScriptMapConstant constant = value;
+ constant_system.JavaScriptMapConstant constant = value;
writeDartType(constant.type);
writeConstant(constant.keyList);
writeConstants(constant.values);
diff --git a/pkg/compiler/lib/src/serialization/abstract_source.dart b/pkg/compiler/lib/src/serialization/abstract_source.dart
index 4b6063b..f042e9b 100644
--- a/pkg/compiler/lib/src/serialization/abstract_source.dart
+++ b/pkg/compiler/lib/src/serialization/abstract_source.dart
@@ -467,7 +467,7 @@
List<ConstantValue> values = readConstants();
ConstantValue protoValue = readConstantOrNull();
bool onlyStringKeys = readBool();
- return new JavaScriptMapConstant(
+ return new constant_system.JavaScriptMapConstant(
type, keyList, values, protoValue, onlyStringKeys);
case ConstantValueKind.CONSTRUCTED:
InterfaceType type = readDartType();
diff --git a/pkg/compiler/lib/src/serialization/serialization.dart b/pkg/compiler/lib/src/serialization/serialization.dart
index ce9332e..b974951 100644
--- a/pkg/compiler/lib/src/serialization/serialization.dart
+++ b/pkg/compiler/lib/src/serialization/serialization.dart
@@ -9,7 +9,7 @@
import 'package:kernel/binary/ast_from_binary.dart' as ir;
import 'package:kernel/binary/ast_to_binary.dart' as ir;
import '../closure.dart';
-import '../constants/constant_system.dart';
+import '../constants/constant_system.dart' as constant_system;
import '../constants/values.dart';
import '../diagnostics/source_span.dart';
import '../elements/entities.dart';
diff --git a/pkg/compiler/lib/src/ssa/builder_kernel.dart b/pkg/compiler/lib/src/ssa/builder_kernel.dart
index 0805cef..0f8b45c 100644
--- a/pkg/compiler/lib/src/ssa/builder_kernel.dart
+++ b/pkg/compiler/lib/src/ssa/builder_kernel.dart
@@ -10,6 +10,7 @@
import '../common/names.dart';
import '../common_elements.dart';
import '../compiler.dart';
+import '../constants/constant_system.dart' as constant_system;
import '../constants/values.dart'
show
ConstantValue,
@@ -2555,7 +2556,7 @@
List<ConstantValue> getConstants(
ir.SwitchStatement parentSwitch, ir.SwitchCase switchCase) {
return <ConstantValue>[
- constantSystem.createIntFromInt(caseIndex[switchCase])
+ constant_system.createIntFromInt(caseIndex[switchCase])
];
}
@@ -3849,8 +3850,7 @@
}
HConstant nameConstant = graph.addConstant(
- closedWorld.constantSystem
- .createSymbol(closedWorld.commonElements, name),
+ constant_system.createSymbol(closedWorld.commonElements, name),
closedWorld);
List<HInstruction> arguments = <HInstruction>[];
@@ -3882,7 +3882,7 @@
for (String argumentName
in selector.callStructure.getOrderedNamedArguments()) {
ConstantValue argumentNameConstant =
- constantSystem.createString(argumentName);
+ constant_system.createString(argumentName);
argumentNames.add(graph.addConstant(argumentNameConstant, closedWorld));
}
HInstruction argumentNamesInstruction = buildLiteralList(argumentNames);
@@ -3894,7 +3894,7 @@
js.Name internalName = namer.invocationName(selector);
ConstantValue kindConstant =
- constantSystem.createIntFromInt(selector.invocationMirrorKind);
+ constant_system.createIntFromInt(selector.invocationMirrorKind);
_pushStaticInvocation(
_commonElements.createUnmangledInvocationMirror,
@@ -4676,7 +4676,7 @@
FunctionEntity noSuchMethod =
_elementMap.getSuperNoSuchMethod(containingClass);
- ConstantValue nameConstant = constantSystem.createString(publicName);
+ ConstantValue nameConstant = constant_system.createString(publicName);
js.Name internalName = namer.invocationName(selector);
@@ -4686,14 +4686,14 @@
var argumentNames = new List<HInstruction>();
for (String argumentName in selector.namedArguments) {
ConstantValue argumentNameConstant =
- constantSystem.createString(argumentName);
+ constant_system.createString(argumentName);
argumentNames.add(graph.addConstant(argumentNameConstant, closedWorld));
}
var argumentNamesInstruction = buildLiteralList(argumentNames);
add(argumentNamesInstruction);
ConstantValue kindConstant =
- constantSystem.createIntFromInt(selector.invocationMirrorKind);
+ constant_system.createIntFromInt(selector.invocationMirrorKind);
_pushStaticInvocation(
_commonElements.createInvocationMirror,
diff --git a/pkg/compiler/lib/src/ssa/codegen.dart b/pkg/compiler/lib/src/ssa/codegen.dart
index d0ca90a..ffccada 100644
--- a/pkg/compiler/lib/src/ssa/codegen.dart
+++ b/pkg/compiler/lib/src/ssa/codegen.dart
@@ -11,7 +11,7 @@
import '../common/names.dart';
import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
import '../common/tasks.dart' show CompilerTask;
-import '../constants/constant_system.dart';
+import '../constants/constant_system.dart' as constant_system;
import '../constants/values.dart';
import '../common_elements.dart' show JCommonElements;
import '../elements/entities.dart';
@@ -249,8 +249,6 @@
JCommonElements get _commonElements => _closedWorld.commonElements;
- ConstantSystem get _constantSystem => _closedWorld.constantSystem;
-
NativeData get _nativeData => _closedWorld.nativeData;
InterceptorData get _interceptorData => _closedWorld.interceptorData;
@@ -2337,7 +2335,7 @@
.withSourceInformation(sourceInformation));
} else if (canGenerateOptimizedComparison(input)) {
HRelational relational = input;
- BinaryOperation operation = relational.operation(_constantSystem);
+ constant_system.BinaryOperation operation = relational.operation();
String op = mapRelationalOperator(operation.name, true);
handleInvokeBinary(input, op, sourceInformation);
} else {
diff --git a/pkg/compiler/lib/src/ssa/graph_builder.dart b/pkg/compiler/lib/src/ssa/graph_builder.dart
index cf71ede..4b5d9cf 100644
--- a/pkg/compiler/lib/src/ssa/graph_builder.dart
+++ b/pkg/compiler/lib/src/ssa/graph_builder.dart
@@ -2,7 +2,6 @@
// 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.
-import '../constants/constant_system.dart';
import '../common/codegen.dart' show CodegenRegistry;
import '../common_elements.dart';
import '../compiler.dart';
@@ -79,8 +78,6 @@
JavaScriptConstantCompiler get constants => backend.constants;
- ConstantSystem get constantSystem => constants.constantSystem;
-
RuntimeTypesEncoder get rtiEncoder => backend.rtiEncoder;
InferredData get inferredData => globalInferenceResults.inferredData;
diff --git a/pkg/compiler/lib/src/ssa/invoke_dynamic_specializers.dart b/pkg/compiler/lib/src/ssa/invoke_dynamic_specializers.dart
index fb3df50..7e6e84c 100644
--- a/pkg/compiler/lib/src/ssa/invoke_dynamic_specializers.dart
+++ b/pkg/compiler/lib/src/ssa/invoke_dynamic_specializers.dart
@@ -3,7 +3,7 @@
// BSD-style license that can be found in the LICENSE file.
import '../common_elements.dart' show JCommonElements;
-import '../constants/constant_system.dart';
+import '../constants/constant_system.dart' as constant_system;
import '../constants/values.dart';
import '../elements/entities.dart';
import '../elements/names.dart';
@@ -57,7 +57,7 @@
new CallStructure(selector.argumentCount));
}
- Operation operation(ConstantSystem constantSystem) => null;
+ constant_system.Operation operation() => null;
static InvokeDynamicSpecializer lookupSpecializer(Selector selector) {
if (selector.isIndex) return const IndexSpecializer();
@@ -221,8 +221,8 @@
class BitNotSpecializer extends InvokeDynamicSpecializer {
const BitNotSpecializer();
- UnaryOperation operation(ConstantSystem constantSystem) {
- return constantSystem.bitNot;
+ constant_system.UnaryOperation operation() {
+ return constant_system.bitNot;
}
AbstractValue computeTypeFromInputTypes(
@@ -266,8 +266,8 @@
class UnaryNegateSpecializer extends InvokeDynamicSpecializer {
const UnaryNegateSpecializer();
- UnaryOperation operation(ConstantSystem constantSystem) {
- return constantSystem.negate;
+ constant_system.UnaryOperation operation() {
+ return constant_system.negate;
}
AbstractValue computeTypeFromInputTypes(
@@ -322,8 +322,8 @@
class AbsSpecializer extends InvokeDynamicSpecializer {
const AbsSpecializer();
- UnaryOperation operation(ConstantSystem constantSystem) {
- return constantSystem.abs;
+ constant_system.UnaryOperation operation() {
+ return constant_system.abs;
}
AbstractValue computeTypeFromInputTypes(
@@ -480,8 +480,8 @@
.computeTypeFromInputTypes(instruction, results, options, closedWorld);
}
- BinaryOperation operation(ConstantSystem constantSystem) {
- return constantSystem.add;
+ constant_system.BinaryOperation operation() {
+ return constant_system.add;
}
HInstruction newBuiltinVariant(
@@ -506,8 +506,8 @@
class DivideSpecializer extends BinaryArithmeticSpecializer {
const DivideSpecializer();
- BinaryOperation operation(ConstantSystem constantSystem) {
- return constantSystem.divide;
+ constant_system.BinaryOperation operation() {
+ return constant_system.divide;
}
AbstractValue computeTypeFromInputTypes(
@@ -554,8 +554,8 @@
.computeTypeFromInputTypes(instruction, results, options, closedWorld);
}
- BinaryOperation operation(ConstantSystem constantSystem) {
- return constantSystem.modulo;
+ constant_system.BinaryOperation operation() {
+ return constant_system.modulo;
}
HInstruction newBuiltinVariant(
@@ -646,8 +646,8 @@
.computeTypeFromInputTypes(instruction, results, options, closedWorld);
}
- BinaryOperation operation(ConstantSystem constantSystem) {
- return constantSystem.remainder;
+ constant_system.BinaryOperation operation() {
+ return constant_system.remainder;
}
HInstruction newBuiltinVariant(
@@ -672,8 +672,8 @@
class MultiplySpecializer extends BinaryArithmeticSpecializer {
const MultiplySpecializer();
- BinaryOperation operation(ConstantSystem constantSystem) {
- return constantSystem.multiply;
+ constant_system.BinaryOperation operation() {
+ return constant_system.multiply;
}
AbstractValue computeTypeFromInputTypes(
@@ -710,8 +710,8 @@
class SubtractSpecializer extends BinaryArithmeticSpecializer {
const SubtractSpecializer();
- BinaryOperation operation(ConstantSystem constantSystem) {
- return constantSystem.subtract;
+ constant_system.BinaryOperation operation() {
+ return constant_system.subtract;
}
HInstruction newBuiltinVariant(
@@ -736,8 +736,8 @@
class TruncatingDivideSpecializer extends BinaryArithmeticSpecializer {
const TruncatingDivideSpecializer();
- BinaryOperation operation(ConstantSystem constantSystem) {
- return constantSystem.truncatingDivide;
+ constant_system.BinaryOperation operation() {
+ return constant_system.truncatingDivide;
}
AbstractValue computeTypeFromInputTypes(
@@ -895,8 +895,8 @@
class ShiftLeftSpecializer extends BinaryBitOpSpecializer {
const ShiftLeftSpecializer();
- BinaryOperation operation(ConstantSystem constantSystem) {
- return constantSystem.shiftLeft;
+ constant_system.BinaryOperation operation() {
+ return constant_system.shiftLeft;
}
HInstruction tryConvertToBuiltin(
@@ -1027,8 +1027,8 @@
computeTypeFromInputTypes(instruction, results, options, closedWorld));
}
- BinaryOperation operation(ConstantSystem constantSystem) {
- return constantSystem.shiftRight;
+ constant_system.BinaryOperation operation() {
+ return constant_system.shiftRight;
}
@override
@@ -1041,8 +1041,8 @@
class BitOrSpecializer extends BinaryBitOpSpecializer {
const BitOrSpecializer();
- BinaryOperation operation(ConstantSystem constantSystem) {
- return constantSystem.bitOr;
+ constant_system.BinaryOperation operation() {
+ return constant_system.bitOr;
}
AbstractValue computeTypeFromInputTypes(
@@ -1081,8 +1081,8 @@
class BitAndSpecializer extends BinaryBitOpSpecializer {
const BitAndSpecializer();
- BinaryOperation operation(ConstantSystem constantSystem) {
- return constantSystem.bitAnd;
+ constant_system.BinaryOperation operation() {
+ return constant_system.bitAnd;
}
AbstractValue computeTypeFromInputTypes(
@@ -1124,8 +1124,8 @@
class BitXorSpecializer extends BinaryBitOpSpecializer {
const BitXorSpecializer();
- BinaryOperation operation(ConstantSystem constantSystem) {
- return constantSystem.bitXor;
+ constant_system.BinaryOperation operation() {
+ return constant_system.bitXor;
}
AbstractValue computeTypeFromInputTypes(
@@ -1250,8 +1250,8 @@
return null;
}
- BinaryOperation operation(ConstantSystem constantSystem) {
- return constantSystem.equal;
+ constant_system.BinaryOperation operation() {
+ return constant_system.equal;
}
HInstruction newBuiltinVariant(
@@ -1270,8 +1270,8 @@
class LessSpecializer extends RelationalSpecializer {
const LessSpecializer();
- BinaryOperation operation(ConstantSystem constantSystem) {
- return constantSystem.less;
+ constant_system.BinaryOperation operation() {
+ return constant_system.less;
}
HInstruction newBuiltinVariant(
@@ -1290,8 +1290,8 @@
class GreaterSpecializer extends RelationalSpecializer {
const GreaterSpecializer();
- BinaryOperation operation(ConstantSystem constantSystem) {
- return constantSystem.greater;
+ constant_system.BinaryOperation operation() {
+ return constant_system.greater;
}
HInstruction newBuiltinVariant(
@@ -1310,8 +1310,8 @@
class GreaterEqualSpecializer extends RelationalSpecializer {
const GreaterEqualSpecializer();
- BinaryOperation operation(ConstantSystem constantSystem) {
- return constantSystem.greaterEqual;
+ constant_system.BinaryOperation operation() {
+ return constant_system.greaterEqual;
}
HInstruction newBuiltinVariant(
@@ -1330,8 +1330,8 @@
class LessEqualSpecializer extends RelationalSpecializer {
const LessEqualSpecializer();
- BinaryOperation operation(ConstantSystem constantSystem) {
- return constantSystem.lessEqual;
+ constant_system.BinaryOperation operation() {
+ return constant_system.lessEqual;
}
HInstruction newBuiltinVariant(
@@ -1350,8 +1350,8 @@
class CodeUnitAtSpecializer extends InvokeDynamicSpecializer {
const CodeUnitAtSpecializer();
- BinaryOperation operation(ConstantSystem constantSystem) {
- return constantSystem.codeUnitAt;
+ constant_system.BinaryOperation operation() {
+ return constant_system.codeUnitAt;
}
HInstruction tryConvertToBuiltin(
@@ -1510,8 +1510,8 @@
class RoundSpecializer extends InvokeDynamicSpecializer {
const RoundSpecializer();
- UnaryOperation operation(ConstantSystem constantSystem) {
- return constantSystem.round;
+ constant_system.UnaryOperation operation() {
+ return constant_system.round;
}
HInstruction tryConvertToBuiltin(
diff --git a/pkg/compiler/lib/src/ssa/nodes.dart b/pkg/compiler/lib/src/ssa/nodes.dart
index 3095197..b97455d 100644
--- a/pkg/compiler/lib/src/ssa/nodes.dart
+++ b/pkg/compiler/lib/src/ssa/nodes.dart
@@ -7,7 +7,7 @@
import '../closure.dart';
import '../common.dart';
import '../compiler.dart' show Compiler;
-import '../constants/constant_system.dart';
+import '../constants/constant_system.dart' as constant_system;
import '../constants/values.dart';
import '../deferred_load.dart' show OutputUnit;
import '../elements/entities.dart';
@@ -298,23 +298,21 @@
}
HConstant addConstantInt(int i, JClosedWorld closedWorld) {
- return addConstant(
- closedWorld.constantSystem.createIntFromInt(i), closedWorld);
+ return addConstant(constant_system.createIntFromInt(i), closedWorld);
}
HConstant addConstantIntAsUnsigned(int i, JClosedWorld closedWorld) {
return addConstant(
- closedWorld.constantSystem.createInt(new BigInt.from(i).toUnsigned(64)),
+ constant_system.createInt(new BigInt.from(i).toUnsigned(64)),
closedWorld);
}
HConstant addConstantDouble(double d, JClosedWorld closedWorld) {
- return addConstant(closedWorld.constantSystem.createDouble(d), closedWorld);
+ return addConstant(constant_system.createDouble(d), closedWorld);
}
HConstant addConstantString(String str, JClosedWorld closedWorld) {
- return addConstant(
- closedWorld.constantSystem.createString(str), closedWorld);
+ return addConstant(constant_system.createString(str), closedWorld);
}
HConstant addConstantStringFromName(js.Name name, JClosedWorld closedWorld) {
@@ -325,12 +323,11 @@
}
HConstant addConstantBool(bool value, JClosedWorld closedWorld) {
- return addConstant(
- closedWorld.constantSystem.createBool(value), closedWorld);
+ return addConstant(constant_system.createBool(value), closedWorld);
}
HConstant addConstantNull(JClosedWorld closedWorld) {
- return addConstant(closedWorld.constantSystem.createNull(), closedWorld);
+ return addConstant(constant_system.createNull(), closedWorld);
}
HConstant addConstantUnreachable(JClosedWorld closedWorld) {
@@ -2141,14 +2138,14 @@
HInstruction get left => inputs[0];
HInstruction get right => inputs[1];
- BinaryOperation operation(ConstantSystem constantSystem);
+ constant_system.BinaryOperation operation();
}
abstract class HBinaryArithmetic extends HInvokeBinary {
HBinaryArithmetic(HInstruction left, HInstruction right, Selector selector,
AbstractValue type)
: super(left, right, selector, type);
- BinaryOperation operation(ConstantSystem constantSystem);
+ constant_system.BinaryOperation operation();
}
class HAdd extends HBinaryArithmetic {
@@ -2157,8 +2154,7 @@
: super(left, right, selector, type);
accept(HVisitor visitor) => visitor.visitAdd(this);
- BinaryOperation operation(ConstantSystem constantSystem) =>
- constantSystem.add;
+ constant_system.BinaryOperation operation() => constant_system.add;
int typeCode() => HInstruction.ADD_TYPECODE;
bool typeEquals(other) => other is HAdd;
bool dataEquals(HInstruction other) => true;
@@ -2170,8 +2166,7 @@
: super(left, right, selector, type);
accept(HVisitor visitor) => visitor.visitDivide(this);
- BinaryOperation operation(ConstantSystem constantSystem) =>
- constantSystem.divide;
+ constant_system.BinaryOperation operation() => constant_system.divide;
int typeCode() => HInstruction.DIVIDE_TYPECODE;
bool typeEquals(other) => other is HDivide;
bool dataEquals(HInstruction other) => true;
@@ -2183,7 +2178,7 @@
: super(left, right, selector, type);
accept(HVisitor visitor) => visitor.visitMultiply(this);
- BinaryOperation operation(ConstantSystem operations) => operations.multiply;
+ constant_system.BinaryOperation operation() => constant_system.multiply;
int typeCode() => HInstruction.MULTIPLY_TYPECODE;
bool typeEquals(other) => other is HMultiply;
bool dataEquals(HInstruction other) => true;
@@ -2195,8 +2190,7 @@
: super(left, right, selector, type);
accept(HVisitor visitor) => visitor.visitSubtract(this);
- BinaryOperation operation(ConstantSystem constantSystem) =>
- constantSystem.subtract;
+ constant_system.BinaryOperation operation() => constant_system.subtract;
int typeCode() => HInstruction.SUBTRACT_TYPECODE;
bool typeEquals(other) => other is HSubtract;
bool dataEquals(HInstruction other) => true;
@@ -2208,8 +2202,8 @@
: super(left, right, selector, type);
accept(HVisitor visitor) => visitor.visitTruncatingDivide(this);
- BinaryOperation operation(ConstantSystem constantSystem) =>
- constantSystem.truncatingDivide;
+ constant_system.BinaryOperation operation() =>
+ constant_system.truncatingDivide;
int typeCode() => HInstruction.TRUNCATING_DIVIDE_TYPECODE;
bool typeEquals(other) => other is HTruncatingDivide;
bool dataEquals(HInstruction other) => true;
@@ -2221,8 +2215,7 @@
: super(left, right, selector, type);
accept(HVisitor visitor) => visitor.visitRemainder(this);
- BinaryOperation operation(ConstantSystem constantSystem) =>
- constantSystem.remainder;
+ constant_system.BinaryOperation operation() => constant_system.remainder;
int typeCode() => HInstruction.REMAINDER_TYPECODE;
bool typeEquals(other) => other is HRemainder;
bool dataEquals(HInstruction other) => true;
@@ -2260,8 +2253,7 @@
: super(left, right, selector, type);
accept(HVisitor visitor) => visitor.visitShiftLeft(this);
- BinaryOperation operation(ConstantSystem constantSystem) =>
- constantSystem.shiftLeft;
+ constant_system.BinaryOperation operation() => constant_system.shiftLeft;
int typeCode() => HInstruction.SHIFT_LEFT_TYPECODE;
bool typeEquals(other) => other is HShiftLeft;
bool dataEquals(HInstruction other) => true;
@@ -2273,8 +2265,7 @@
: super(left, right, selector, type);
accept(HVisitor visitor) => visitor.visitShiftRight(this);
- BinaryOperation operation(ConstantSystem constantSystem) =>
- constantSystem.shiftRight;
+ constant_system.BinaryOperation operation() => constant_system.shiftRight;
int typeCode() => HInstruction.SHIFT_RIGHT_TYPECODE;
bool typeEquals(other) => other is HShiftRight;
bool dataEquals(HInstruction other) => true;
@@ -2286,8 +2277,7 @@
: super(left, right, selector, type);
accept(HVisitor visitor) => visitor.visitBitOr(this);
- BinaryOperation operation(ConstantSystem constantSystem) =>
- constantSystem.bitOr;
+ constant_system.BinaryOperation operation() => constant_system.bitOr;
int typeCode() => HInstruction.BIT_OR_TYPECODE;
bool typeEquals(other) => other is HBitOr;
bool dataEquals(HInstruction other) => true;
@@ -2299,8 +2289,7 @@
: super(left, right, selector, type);
accept(HVisitor visitor) => visitor.visitBitAnd(this);
- BinaryOperation operation(ConstantSystem constantSystem) =>
- constantSystem.bitAnd;
+ constant_system.BinaryOperation operation() => constant_system.bitAnd;
int typeCode() => HInstruction.BIT_AND_TYPECODE;
bool typeEquals(other) => other is HBitAnd;
bool dataEquals(HInstruction other) => true;
@@ -2312,8 +2301,7 @@
: super(left, right, selector, type);
accept(HVisitor visitor) => visitor.visitBitXor(this);
- BinaryOperation operation(ConstantSystem constantSystem) =>
- constantSystem.bitXor;
+ constant_system.BinaryOperation operation() => constant_system.bitXor;
int typeCode() => HInstruction.BIT_XOR_TYPECODE;
bool typeEquals(other) => other is HBitXor;
bool dataEquals(HInstruction other) => true;
@@ -2330,7 +2318,7 @@
HInstruction get operand => inputs[0];
- UnaryOperation operation(ConstantSystem constantSystem);
+ constant_system.UnaryOperation operation();
}
class HNegate extends HInvokeUnary {
@@ -2338,8 +2326,7 @@
: super(input, selector, type);
accept(HVisitor visitor) => visitor.visitNegate(this);
- UnaryOperation operation(ConstantSystem constantSystem) =>
- constantSystem.negate;
+ constant_system.UnaryOperation operation() => constant_system.negate;
int typeCode() => HInstruction.NEGATE_TYPECODE;
bool typeEquals(other) => other is HNegate;
bool dataEquals(HInstruction other) => true;
@@ -2350,7 +2337,7 @@
: super(input, selector, type);
accept(HVisitor visitor) => visitor.visitAbs(this);
- UnaryOperation operation(ConstantSystem constantSystem) => constantSystem.abs;
+ constant_system.UnaryOperation operation() => constant_system.abs;
int typeCode() => HInstruction.ABS_TYPECODE;
bool typeEquals(other) => other is HAbs;
bool dataEquals(HInstruction other) => true;
@@ -2361,8 +2348,7 @@
: super(input, selector, type);
accept(HVisitor visitor) => visitor.visitBitNot(this);
- UnaryOperation operation(ConstantSystem constantSystem) =>
- constantSystem.bitNot;
+ constant_system.UnaryOperation operation() => constant_system.bitNot;
int typeCode() => HInstruction.BIT_NOT_TYPECODE;
bool typeEquals(other) => other is HBitNot;
bool dataEquals(HInstruction other) => true;
@@ -2628,8 +2614,7 @@
HIdentity(left, right, selector, type) : super(left, right, selector, type);
accept(HVisitor visitor) => visitor.visitIdentity(this);
- BinaryOperation operation(ConstantSystem constantSystem) =>
- constantSystem.identity;
+ constant_system.BinaryOperation operation() => constant_system.identity;
int typeCode() => HInstruction.IDENTITY_TYPECODE;
bool typeEquals(other) => other is HIdentity;
bool dataEquals(HInstruction other) => true;
@@ -2639,8 +2624,7 @@
HGreater(left, right, selector, type) : super(left, right, selector, type);
accept(HVisitor visitor) => visitor.visitGreater(this);
- BinaryOperation operation(ConstantSystem constantSystem) =>
- constantSystem.greater;
+ constant_system.BinaryOperation operation() => constant_system.greater;
int typeCode() => HInstruction.GREATER_TYPECODE;
bool typeEquals(other) => other is HGreater;
bool dataEquals(HInstruction other) => true;
@@ -2651,8 +2635,7 @@
: super(left, right, selector, type);
accept(HVisitor visitor) => visitor.visitGreaterEqual(this);
- BinaryOperation operation(ConstantSystem constantSystem) =>
- constantSystem.greaterEqual;
+ constant_system.BinaryOperation operation() => constant_system.greaterEqual;
int typeCode() => HInstruction.GREATER_EQUAL_TYPECODE;
bool typeEquals(other) => other is HGreaterEqual;
bool dataEquals(HInstruction other) => true;
@@ -2662,8 +2645,7 @@
HLess(left, right, selector, type) : super(left, right, selector, type);
accept(HVisitor visitor) => visitor.visitLess(this);
- BinaryOperation operation(ConstantSystem constantSystem) =>
- constantSystem.less;
+ constant_system.BinaryOperation operation() => constant_system.less;
int typeCode() => HInstruction.LESS_TYPECODE;
bool typeEquals(other) => other is HLess;
bool dataEquals(HInstruction other) => true;
@@ -2673,8 +2655,7 @@
HLessEqual(left, right, selector, type) : super(left, right, selector, type);
accept(HVisitor visitor) => visitor.visitLessEqual(this);
- BinaryOperation operation(ConstantSystem constantSystem) =>
- constantSystem.lessEqual;
+ constant_system.BinaryOperation operation() => constant_system.lessEqual;
int typeCode() => HInstruction.LESS_EQUAL_TYPECODE;
bool typeEquals(other) => other is HLessEqual;
bool dataEquals(HInstruction other) => true;
diff --git a/pkg/compiler/lib/src/ssa/optimize.dart b/pkg/compiler/lib/src/ssa/optimize.dart
index f8416603..81f1848 100644
--- a/pkg/compiler/lib/src/ssa/optimize.dart
+++ b/pkg/compiler/lib/src/ssa/optimize.dart
@@ -7,7 +7,7 @@
import '../common/names.dart' show Selectors;
import '../common/tasks.dart' show CompilerTask;
import '../compiler.dart' show Compiler;
-import '../constants/constant_system.dart';
+import '../constants/constant_system.dart' as constant_system;
import '../constants/values.dart';
import '../common_elements.dart' show JCommonElements;
import '../elements/entities.dart';
@@ -204,8 +204,6 @@
JCommonElements get commonElements => _closedWorld.commonElements;
- ConstantSystem get constantSystem => _closedWorld.constantSystem;
-
AbstractValueDomain get _abstractValueDomain =>
_closedWorld.abstractValueDomain;
@@ -478,12 +476,12 @@
}
HInstruction visitInvokeUnary(HInvokeUnary node) {
- HInstruction folded =
- foldUnary(node.operation(constantSystem), node.operand);
+ HInstruction folded = foldUnary(node.operation(), node.operand);
return folded != null ? folded : node;
}
- HInstruction foldUnary(UnaryOperation operation, HInstruction operand) {
+ HInstruction foldUnary(
+ constant_system.UnaryOperation operation, HInstruction operand) {
if (operand is HConstant) {
HConstant receiver = operand;
ConstantValue folded = operation.fold(receiver.constant);
@@ -533,7 +531,7 @@
HInstruction handleInterceptedCall(HInvokeDynamic node) {
// Try constant folding the instruction.
- Operation operation = node.specializer.operation(constantSystem);
+ constant_system.Operation operation = node.specializer.operation();
if (operation != null) {
HInstruction instruction = node.inputs.length == 2
? foldUnary(operation, node.inputs[1])
@@ -857,7 +855,7 @@
if (index.isConstant()) {
HConstant constantInstruction = index;
assert(!constantInstruction.constant.isInt);
- if (!constantSystem.isInt(constantInstruction.constant)) {
+ if (!constant_system.isInt(constantInstruction.constant)) {
// -0.0 is a double but will pass the runtime integer check.
node.staticChecks = HBoundsCheck.ALWAYS_FALSE;
}
@@ -865,8 +863,8 @@
return node;
}
- HInstruction foldBinary(
- BinaryOperation operation, HInstruction left, HInstruction right) {
+ HInstruction foldBinary(constant_system.BinaryOperation operation,
+ HInstruction left, HInstruction right) {
if (left is HConstant && right is HConstant) {
HConstant op1 = left;
HConstant op2 = right;
@@ -903,7 +901,7 @@
HInstruction visitInvokeBinary(HInvokeBinary node) {
HInstruction left = node.left;
HInstruction right = node.right;
- BinaryOperation operation = node.operation(constantSystem);
+ constant_system.BinaryOperation operation = node.operation();
HConstant folded = foldBinary(operation, left, right);
if (folded != null) return folded;
return node;
@@ -1517,7 +1515,7 @@
}
HInstruction folded = _graph.addConstant(
- constantSystem
+ constant_system
.createString(leftString.stringValue + rightString.stringValue),
_closedWorld);
if (prefix == null) return folded;
@@ -1531,7 +1529,7 @@
}
HInstruction asString(String string) =>
- _graph.addConstant(constantSystem.createString(string), _closedWorld);
+ _graph.addConstant(constant_system.createString(string), _closedWorld);
HInstruction tryConstant() {
if (!input.isConstant()) return null;
diff --git a/pkg/compiler/lib/src/ssa/value_range_analyzer.dart b/pkg/compiler/lib/src/ssa/value_range_analyzer.dart
index 028bb17..639c727 100644
--- a/pkg/compiler/lib/src/ssa/value_range_analyzer.dart
+++ b/pkg/compiler/lib/src/ssa/value_range_analyzer.dart
@@ -2,19 +2,17 @@
// 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.
-import '../constants/constant_system.dart';
+import '../constants/constant_system.dart' as constant_system;
import '../constants/values.dart';
import '../world.dart' show JClosedWorld;
import 'nodes.dart';
import 'optimize.dart';
class ValueRangeInfo {
- final ConstantSystem constantSystem;
-
IntValue intZero;
IntValue intOne;
- ValueRangeInfo(this.constantSystem) {
+ ValueRangeInfo() {
intZero = newIntValue(BigInt.zero);
intOne = newIntValue(BigInt.one);
}
@@ -128,9 +126,9 @@
Value operator +(dynamic other) {
if (other.isZero) return this;
if (other is! IntValue) return other + this;
- ConstantSystem constantSystem = info.constantSystem;
- dynamic constant = constantSystem.add.fold(
- constantSystem.createInt(value), constantSystem.createInt(other.value));
+ dynamic constant = constant_system.add.fold(
+ constant_system.createInt(value),
+ constant_system.createInt(other.value));
if (!constant.isInt) return const UnknownValue();
return info.newIntValue(constant.intValue);
}
@@ -138,27 +136,26 @@
Value operator -(dynamic other) {
if (other.isZero) return this;
if (other is! IntValue) return -other + this;
- ConstantSystem constantSystem = info.constantSystem;
- dynamic constant = constantSystem.subtract.fold(
- constantSystem.createInt(value), constantSystem.createInt(other.value));
+ dynamic constant = constant_system.subtract.fold(
+ constant_system.createInt(value),
+ constant_system.createInt(other.value));
if (!constant.isInt) return const UnknownValue();
return info.newIntValue(constant.intValue);
}
Value operator -() {
if (isZero) return this;
- ConstantSystem constantSystem = info.constantSystem;
dynamic constant =
- constantSystem.negate.fold(constantSystem.createInt(value));
+ constant_system.negate.fold(constant_system.createInt(value));
if (!constant.isInt) return const UnknownValue();
return info.newIntValue(constant.intValue);
}
Value operator &(dynamic other) {
if (other is! IntValue) return const UnknownValue();
- ConstantSystem constantSystem = info.constantSystem;
- dynamic constant = constantSystem.bitAnd.fold(
- constantSystem.createInt(value), constantSystem.createInt(other.value));
+ dynamic constant = constant_system.bitAnd.fold(
+ constant_system.createInt(value),
+ constant_system.createInt(other.value));
return info.newIntValue(constant.intValue);
}
@@ -578,11 +575,9 @@
HGraph graph;
SsaValueRangeAnalyzer(JClosedWorld closedWorld, this.optimizer)
- : info = new ValueRangeInfo(closedWorld.constantSystem),
+ : info = new ValueRangeInfo(),
this.closedWorld = closedWorld;
- ConstantSystem get constantSystem => closedWorld.constantSystem;
-
void visitGraph(HGraph graph) {
this.graph = graph;
visitDominatorTree(graph);
@@ -775,7 +770,7 @@
if (right.isInteger(closedWorld.abstractValueDomain).isPotentiallyFalse) {
return info.newUnboundRange();
}
- BinaryOperation operation = relational.operation(constantSystem);
+ constant_system.BinaryOperation operation = relational.operation();
Range rightRange = ranges[relational.right];
Range leftRange = ranges[relational.left];
@@ -880,7 +875,7 @@
return info.newUnboundRange();
}
return instruction
- .operation(constantSystem)
+ .operation()
.apply(ranges[instruction.left], ranges[instruction.right]);
}
@@ -942,46 +937,48 @@
return newInstruction;
}
- static BinaryOperation negateOperation(BinaryOperation operation) {
- if (operation == const LessOperation()) {
- return const GreaterEqualOperation();
- } else if (operation == const LessEqualOperation()) {
- return const GreaterOperation();
- } else if (operation == const GreaterOperation()) {
- return const LessEqualOperation();
- } else if (operation == const GreaterEqualOperation()) {
- return const LessOperation();
+ static constant_system.BinaryOperation negateOperation(
+ constant_system.BinaryOperation operation) {
+ if (operation == const constant_system.LessOperation()) {
+ return const constant_system.GreaterEqualOperation();
+ } else if (operation == const constant_system.LessEqualOperation()) {
+ return const constant_system.GreaterOperation();
+ } else if (operation == const constant_system.GreaterOperation()) {
+ return const constant_system.LessEqualOperation();
+ } else if (operation == const constant_system.GreaterEqualOperation()) {
+ return const constant_system.LessOperation();
} else {
return null;
}
}
- static BinaryOperation flipOperation(BinaryOperation operation) {
- if (operation == const LessOperation()) {
- return const GreaterOperation();
- } else if (operation == const LessEqualOperation()) {
- return const GreaterEqualOperation();
- } else if (operation == const GreaterOperation()) {
- return const LessOperation();
- } else if (operation == const GreaterEqualOperation()) {
- return const LessEqualOperation();
+ static constant_system.BinaryOperation flipOperation(
+ constant_system.BinaryOperation operation) {
+ if (operation == const constant_system.LessOperation()) {
+ return const constant_system.GreaterOperation();
+ } else if (operation == const constant_system.LessEqualOperation()) {
+ return const constant_system.GreaterEqualOperation();
+ } else if (operation == const constant_system.GreaterOperation()) {
+ return const constant_system.LessOperation();
+ } else if (operation == const constant_system.GreaterEqualOperation()) {
+ return const constant_system.LessEqualOperation();
} else {
return null;
}
}
- Range computeConstrainedRange(
- BinaryOperation operation, Range leftRange, Range rightRange) {
+ Range computeConstrainedRange(constant_system.BinaryOperation operation,
+ Range leftRange, Range rightRange) {
Range range;
- if (operation == const LessOperation()) {
+ if (operation == const constant_system.LessOperation()) {
range = info.newNormalizedRange(
const MinIntValue(), rightRange.upper - info.intOne);
- } else if (operation == const LessEqualOperation()) {
+ } else if (operation == const constant_system.LessEqualOperation()) {
range = info.newNormalizedRange(const MinIntValue(), rightRange.upper);
- } else if (operation == const GreaterOperation()) {
+ } else if (operation == const constant_system.GreaterOperation()) {
range = info.newNormalizedRange(
rightRange.lower + info.intOne, const MaxIntValue());
- } else if (operation == const GreaterEqualOperation()) {
+ } else if (operation == const constant_system.GreaterEqualOperation()) {
range = info.newNormalizedRange(rightRange.lower, const MaxIntValue());
} else {
range = info.newUnboundRange();
@@ -1005,8 +1002,8 @@
Range rightRange = ranges[right];
Range leftRange = ranges[left];
- Operation operation = condition.operation(constantSystem);
- Operation mirrorOp = flipOperation(operation);
+ constant_system.Operation operation = condition.operation();
+ constant_system.Operation mirrorOp = flipOperation(operation);
// Only update the true branch if this block is the only
// predecessor.
if (branch.trueBranch.predecessors.length == 1) {
@@ -1032,8 +1029,8 @@
// predecessor.
if (branch.falseBranch.predecessors.length == 1) {
assert(branch.falseBranch.predecessors[0] == branch.block);
- Operation reverse = negateOperation(operation);
- Operation reversedMirror = flipOperation(reverse);
+ constant_system.Operation reverse = negateOperation(operation);
+ constant_system.Operation reversedMirror = flipOperation(reverse);
// Update the false branch to use narrower ranges for [left] and
// [right].
Range range = computeConstrainedRange(reverse, leftRange, rightRange);
@@ -1131,7 +1128,7 @@
Range leftRange = visit(instruction.left);
Range rightRange = visit(instruction.right);
if (leftRange == null || rightRange == null) return null;
- BinaryOperation operation = instruction.operation(info.constantSystem);
+ constant_system.BinaryOperation operation = instruction.operation();
return operation.apply(leftRange, rightRange);
}
}
diff --git a/pkg/compiler/lib/src/world.dart b/pkg/compiler/lib/src/world.dart
index 3d69a50..9b9e9e9 100644
--- a/pkg/compiler/lib/src/world.dart
+++ b/pkg/compiler/lib/src/world.dart
@@ -12,7 +12,6 @@
JElementEnvironment,
KCommonElements,
KElementEnvironment;
-import 'constants/constant_system.dart';
import 'deferred_load.dart';
import 'diagnostics/diagnostic_listener.dart';
import 'elements/entities.dart';
@@ -63,8 +62,6 @@
/// Returns the [AbstractValueDomain] used in the global type inference.
AbstractValueDomain get abstractValueDomain;
- ConstantSystem get constantSystem;
-
RuntimeTypesNeed get rtiNeed;
NoSuchMethodData get noSuchMethodData;
diff --git a/tests/compiler/dart2js/codegen/value_range2_test.dart b/tests/compiler/dart2js/codegen/value_range2_test.dart
index 5bc6578..d8738ea 100644
--- a/tests/compiler/dart2js/codegen/value_range2_test.dart
+++ b/tests/compiler/dart2js/codegen/value_range2_test.dart
@@ -3,12 +3,11 @@
// BSD-style license that can be found in the LICENSE file.
import "package:expect/expect.dart";
-import "package:compiler/src/constants/constant_system.dart";
import "package:compiler/src/inferrer/abstract_value_domain.dart";
import "package:compiler/src/ssa/nodes.dart";
import "package:compiler/src/ssa/value_range_analyzer.dart";
-ValueRangeInfo info = new ValueRangeInfo(ConstantSystem.only);
+ValueRangeInfo info = new ValueRangeInfo();
class AbstractValueDomainMock implements AbstractValueDomain {
const AbstractValueDomainMock();
diff --git a/tests/compiler/dart2js/model/constant_expression_evaluate_test.dart b/tests/compiler/dart2js/model/constant_expression_evaluate_test.dart
index 61ef76c..efecf36 100644
--- a/tests/compiler/dart2js/model/constant_expression_evaluate_test.dart
+++ b/tests/compiler/dart2js/model/constant_expression_evaluate_test.dart
@@ -10,7 +10,6 @@
import 'package:compiler/src/common.dart';
import 'package:compiler/src/common_elements.dart';
import 'package:compiler/src/compiler.dart';
-import 'package:compiler/src/constants/constant_system.dart';
import 'package:compiler/src/constants/constructors.dart';
import 'package:compiler/src/constants/evaluation.dart';
import 'package:compiler/src/constants/expressions.dart';
@@ -632,8 +631,7 @@
expectedResults.forEach((Map<String, String> env, String expectedText) {
MemoryEnvironment environment =
new MemoryEnvironment(getEnvironment(compiler, field), env);
- ConstantValue value =
- constant.evaluate(environment, ConstantSystem.only);
+ ConstantValue value = constant.evaluate(environment);
Expect.isNotNull(
value,
