Reland "[CFE] Move constant evaluation number semantics handling to front end."

This is a reland of c2b466b

Original change's description:
> [CFE] Move constant evaluation number semantics handling to front end.
> 
> JavaScript number semantics is currently implemented as the simplistic
> version previously present in DDC. This is a starting point for fully
> detailed JS number semantics.
> 
> Change-Id: Id728b3dacec892a5cbf7ece0d9faea51427f5f9b
> Reviewed-on: https://dart-review.googlesource.com/c/94746
> Commit-Queue: Aske Simon Christensen <askesc@google.com>
> Reviewed-by: Sigmund Cherem <sigmund@google.com>

Change-Id: I1a488ef41bda819d34cb45cd481fd8fd88bfb01e
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/95460
Reviewed-by: Johnni Winther <johnniwinther@google.com>
Commit-Queue: Aske Simon Christensen <askesc@google.com>

Author: askeksa

pkg/compiler/lib/src/kernel/dart2js_target.dart

@@ -146,7 +146,7 @@ class Dart2jsTarget extends Target {
   // TODO(askesc): Return specialized dart2js constants backend.
   @override
   ConstantsBackend constantsBackend(CoreTypes coreTypes) =>
-      new ConstantsBackend();
+      const ConstantsBackend();
 }
 
 // TODO(sigmund): this "extraRequiredLibraries" needs to be removed...

pkg/dev_compiler/lib/src/kernel/constants.dart

@@ -19,7 +19,7 @@ class DevCompilerConstants {
   DevCompilerConstants(
       TypeEnvironment types, Map<String, String> declaredVariables)
       : _visitor = _ConstantVisitor(types.coreTypes),
-        _evaluator = ConstantEvaluator(DevCompilerConstantsBackend(),
+        _evaluator = ConstantEvaluator(const DevCompilerConstantsBackend(),
             declaredVariables, types, false, const _ErrorReporter());
 
   /// Determines if an expression is constant.
@@ -170,26 +170,10 @@ class _ConstantVisitor extends ExpressionVisitor<bool> {
 
 /// Implement the class for compiler specific behavior.
 class DevCompilerConstantsBackend extends ConstantsBackend {
-  DevCompilerConstantsBackend();
+  const DevCompilerConstantsBackend();
 
   @override
-  Constant lowerConstant(Constant constant) {
-    // TODO(markzipan): Remove this lowering logic when we switch to
-    // front-end constant evaluation
-    if (constant is DoubleConstant) {
-      // Convert to an integer when possible (matching the runtime behavior
-      // of `is int`).
-      var d = constant.value;
-      if (d.isFinite) {
-        var i = d.toInt();
-        if (d == i.toDouble()) return IntConstant(i);
-      }
-    }
-    return constant;
-  }
-
-  // Use doubles to match JS number semantics.
-  num prepareNumericOperand(num operand) => operand.toDouble();
+  NumberSemantics get numberSemantics => NumberSemantics.js;
 }
 
 class _ErrorReporter extends SimpleErrorReporter {

pkg/dev_compiler/lib/src/kernel/target.dart

@@ -151,7 +151,7 @@ class DevCompilerTarget extends Target {
 
   @override
   ConstantsBackend constantsBackend(CoreTypes coreTypes) =>
-      new DevCompilerConstantsBackend();
+      const DevCompilerConstantsBackend();
 }
 
 /// Analyzes a component to determine if any covariance checks in private

pkg/kernel/lib/target/targets.dart

@@ -231,5 +231,5 @@ class NoneTarget extends Target {
 
   @override
   ConstantsBackend constantsBackend(CoreTypes coreTypes) =>
-      new ConstantsBackend();
+      const ConstantsBackend();
 }

pkg/kernel/lib/transformations/constants.dart

@@ -372,6 +372,7 @@ class ConstantsTransformer extends Transformer {
 
 class ConstantEvaluator extends RecursiveVisitor {
   final ConstantsBackend backend;
+  final NumberSemantics numberSemantics;
   Map<String, String> environmentDefines;
   final CoreTypes coreTypes;
   final TypeEnvironment typeEnvironment;
@@ -396,9 +397,12 @@ class ConstantEvaluator extends RecursiveVisitor {
   Set<TreeNode> unevaluatedNodes;
   Set<Expression> replacementNodes;
 
+  bool get targetingJavaScript => numberSemantics == NumberSemantics.js;
+
   ConstantEvaluator(this.backend, this.environmentDefines, this.typeEnvironment,
       this.enableAsserts, this.errorReporter)
-      : coreTypes = typeEnvironment.coreTypes,
+      : numberSemantics = backend.numberSemantics,
+        coreTypes = typeEnvironment.coreTypes,
         canonicalizationCache = <Constant, Constant>{},
         nodeCache = <Node, Constant>{},
         env = new EvaluationEnvironment();
@@ -517,7 +521,7 @@ class ConstantEvaluator extends RecursiveVisitor {
   }
 
   visitDoubleLiteral(DoubleLiteral node) {
-    return canonicalize(new DoubleConstant(node.value));
+    return canonicalize(makeDoubleConstant(node.value));
   }
 
   visitStringLiteral(StringLiteral node) {
@@ -557,7 +561,8 @@ class ConstantEvaluator extends RecursiveVisitor {
               typeArgument: node.typeArgument, isConst: true));
     }
     final DartType typeArgument = evaluateDartType(node, node.typeArgument);
-    return canonicalize(new ListConstant(typeArgument, entries));
+    return canonicalize(
+        backend.lowerListConstant(new ListConstant(typeArgument, entries)));
   }
 
   visitSetLiteral(SetLiteral node) {
@@ -580,7 +585,8 @@ class ConstantEvaluator extends RecursiveVisitor {
               typeArgument: node.typeArgument, isConst: true));
     }
     final DartType typeArgument = evaluateDartType(node, node.typeArgument);
-    return canonicalize(new SetConstant(typeArgument, entries));
+    return canonicalize(
+        backend.lowerSetConstant(new SetConstant(typeArgument, entries)));
   }
 
   visitMapLiteral(MapLiteral node) {
@@ -616,7 +622,8 @@ class ConstantEvaluator extends RecursiveVisitor {
     }
     final DartType keyType = evaluateDartType(node, node.keyType);
     final DartType valueType = evaluateDartType(node, node.valueType);
-    return canonicalize(new MapConstant(keyType, valueType, entries));
+    return canonicalize(
+        backend.lowerMapConstant(new MapConstant(keyType, valueType, entries)));
   }
 
   visitFunctionExpression(FunctionExpression node) {
@@ -1037,7 +1044,7 @@ class ConstantEvaluator extends RecursiveVisitor {
       if (arguments.length == 0) {
         switch (node.name.name) {
           case 'unary-':
-            return canonicalize(new DoubleConstant(-receiver.value));
+            return canonicalize(makeDoubleConstant(-receiver.value));
         }
       } else if (arguments.length == 1) {
         final Constant other = arguments[0];
@@ -1390,6 +1397,18 @@ class ConstantEvaluator extends RecursiveVisitor {
 
   // Helper methods:
 
+  Constant makeDoubleConstant(double value) {
+    if (targetingJavaScript) {
+      // Convert to an integer when possible (matching the runtime behavior
+      // of `is int`).
+      if (value.isFinite) {
+        var i = value.toInt();
+        if (value == i.toDouble()) return new IntConstant(i);
+      }
+    }
+    return new DoubleConstant(value);
+  }
+
   void ensureIsSubtype(Constant constant, DartType type, TreeNode node) {
     DartType constantType = constant.getType(typeEnvironment);
 
@@ -1456,7 +1475,6 @@ class ConstantEvaluator extends RecursiveVisitor {
   }
 
   Constant canonicalize(Constant constant) {
-    constant = backend.lowerConstant(constant);
     return canonicalizationCache.putIfAbsent(constant, () => constant);
   }
 
@@ -1482,8 +1500,10 @@ class ConstantEvaluator extends RecursiveVisitor {
 
   Constant evaluateBinaryNumericOperation(
       String op, num a, num b, TreeNode node) {
-    a = backend.prepareNumericOperand(a);
-    b = backend.prepareNumericOperand(b);
+    if (targetingJavaScript) {
+      a = a.toDouble();
+      b = b.toDouble();
+    }
     num result;
     switch (op) {
       case '+':
@@ -1506,10 +1526,11 @@ class ConstantEvaluator extends RecursiveVisitor {
         break;
     }
 
-    if (result != null) {
-      return canonicalize(result is int
-          ? new IntConstant(result.toSigned(64))
-          : new DoubleConstant(result as double));
+    if (result is int) {
+      return canonicalize(new IntConstant(result.toSigned(64)));
+    }
+    if (result is double) {
+      return canonicalize(makeDoubleConstant(result));
     }
 
     switch (op) {
@@ -1605,16 +1626,30 @@ class EvaluationEnvironment {
   }
 }
 
+/// The different kinds of number semantics supported by the constant evaluator.
+enum NumberSemantics {
+  /// Dart VM number semantics.
+  vm,
+
+  /// JavaScript (Dart2js and DDC) number semantics.
+  js,
+}
+
 // Backend specific constant evaluation behavior
 class ConstantsBackend {
-  /// Transformation of constants prior to canonicalization, e.g. to change the
-  /// representation of certain kinds of constants, or to implement specific
-  /// number semantics.
-  Constant lowerConstant(Constant constant) => constant;
-
-  /// Transformation of numeric operands prior to a binary operation,
-  /// e.g. to implement specific number semantics.
-  num prepareNumericOperand(num operand) => operand;
+  const ConstantsBackend();
+
+  /// Lowering of a list constant to a backend-specific representation.
+  Constant lowerListConstant(ListConstant constant) => constant;
+
+  /// Lowering of a set constant to a backend-specific representation.
+  Constant lowerSetConstant(SetConstant constant) => constant;
+
+  /// Lowering of a map constant to a backend-specific representation.
+  Constant lowerMapConstant(MapConstant constant) => constant;
+
+  /// Number semantics to use for this backend.
+  NumberSemantics get numberSemantics => NumberSemantics.vm;
 }
 
 // Used as control-flow to abort the current evaluation.

pkg/kernel/lib/vm/constants_native_effects.dart

@@ -26,30 +26,26 @@ class VmConstantsBackend extends ConstantsBackend {
   }
 
   @override
-  Constant lowerConstant(Constant constant) {
-    if (constant is MapConstant) {
-      // The _ImmutableMap class is implemented via one field pointing to a list
-      // of key/value pairs -- see runtime/lib/immutable_map.dart!
-      final List<Constant> kvListPairs =
-          new List<Constant>(2 * constant.entries.length);
-      for (int i = 0; i < constant.entries.length; i++) {
-        final ConstantMapEntry entry = constant.entries[i];
-        kvListPairs[2 * i] = entry.key;
-        kvListPairs[2 * i + 1] = entry.value;
-      }
-      // This is a bit fishy, since we merge the key and the value type by
-      // putting both into the same list.
-      final kvListConstant = new ListConstant(const DynamicType(), kvListPairs);
-      assert(immutableMapClass.fields.length == 1);
-      final Field kvPairListField = immutableMapClass.fields[0];
-      return new InstanceConstant(immutableMapClass.reference, <DartType>[
-        constant.keyType,
-        constant.valueType,
-      ], <Reference, Constant>{
-        kvPairListField.reference: kvListConstant,
-      });
+  Constant lowerMapConstant(MapConstant constant) {
+    // The _ImmutableMap class is implemented via one field pointing to a list
+    // of key/value pairs -- see runtime/lib/immutable_map.dart!
+    final List<Constant> kvListPairs =
+        new List<Constant>(2 * constant.entries.length);
+    for (int i = 0; i < constant.entries.length; i++) {
+      final ConstantMapEntry entry = constant.entries[i];
+      kvListPairs[2 * i] = entry.key;
+      kvListPairs[2 * i + 1] = entry.value;
     }
-
-    return constant;
+    // This is a bit fishy, since we merge the key and the value type by
+    // putting both into the same list.
+    final kvListConstant = new ListConstant(const DynamicType(), kvListPairs);
+    assert(immutableMapClass.fields.length == 1);
+    final Field kvPairListField = immutableMapClass.fields[0];
+    return new InstanceConstant(immutableMapClass.reference, <DartType>[
+      constant.keyType,
+      constant.valueType,
+    ], <Reference, Constant>{
+      kvPairListField.reference: kvListConstant,
+    });
   }
 }