[dart2wasm] Improve -O0 code gen for inline unary ops

When inlining an unary operator, evaluate the the operator in compile
time when the arugment is a literal or constant.

This helps with debug mode code size, especially with large literals.
The test `co19/LibTest/core/List/sort_A01_t06.test.dart` becomes 492,496
lines of .wat, from 558,080.

Also removes the intrinsic `_toInt`, which is no longer used.

Example:

    void main() {
      print(~123);
      print(123.toDouble());
      print(12.34.floorToDouble());
      print(12.34.ceilToDouble());
      print(12.34.truncateToDouble());
    }

Diff of wat:

    --- before	2024-10-28 12:21:08.537971233 +0100
    +++ after	2024-10-28 12:17:01.965688861 +0100
    @@ -4,41 +4,35 @@
         (local $var2 f64)
         (local $var3 f64)
         (local $var4 f64)
    -    i64.const 123
    -    i64.const -1
    -    i64.xor
    +    i64.const -124
         local.set $var0
         i32.const 5
         local.get $var0
         struct.new $BoxedInt
         call $print
         drop
    -    i64.const 123
    -    f64.convert_i64_s
    +    f64.const 123
         local.set $var1
         i32.const 4
         local.get $var1
         struct.new $BoxedDouble
         call $print
         drop
    -    f64.const 12.34
    -    f64.floor
    +    f64.const 12
         local.set $var2
         i32.const 4
         local.get $var2
         struct.new $BoxedDouble
         call $print
         drop
    -    f64.const 12.34
    -    f64.ceil
    +    f64.const 13
         local.set $var3
         i32.const 4
         local.get $var3
         struct.new $BoxedDouble
         call $print
         drop
    -    f64.const 12.34
    -    f64.trunc
    +    f64.const 12
         local.set $var4
         i32.const 4
         local.get $var4

Change-Id: I318d977b6a54c4028668c3626121e3cd26a7eddc
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/392122
Reviewed-by: Slava Egorov <[email protected]>
Commit-Queue: Ömer Ağacan <[email protected]>

Author: osa1

pkg/dart2wasm/lib/intrinsics.dart

@@ -14,6 +14,9 @@ import 'types.dart';
 
 typedef CodeGenCallback = void Function(AstCodeGenerator);
 
+typedef InlineCodeGenCallback = void Function(
+    AstCodeGenerator, Expression receiver);
+
 /// Specialized code generation for external members.
 ///
 /// The code is generated either inlined at the call site, or as the body of
@@ -91,8 +94,78 @@ class Intrinsifier {
       'truncateToDouble': (c) {
         c.b.f64_trunc();
       },
-      '_toInt': (c) {
-        c.b.i64_trunc_sat_f64_s();
+    },
+  };
+
+  static final Map<w.ValueType, Map<String, InlineCodeGenCallback>>
+      _inlineUnaryOperatorMap = {
+    intType: {
+      'unary-': (c, receiver) {
+        final int? intValue = _extractIntValue(receiver);
+        if (intValue == null) {
+          c.translateExpression(receiver, intType);
+          c.b.i64_const(-1);
+          c.b.i64_mul();
+        } else {
+          c.b.i64_const(-intValue);
+        }
+      },
+      '~': (c, receiver) {
+        final int? intValue = _extractIntValue(receiver);
+        if (intValue == null) {
+          c.translateExpression(receiver, intType);
+          c.b.i64_const(-1);
+          c.b.i64_xor();
+        } else {
+          c.b.i64_const(~intValue);
+        }
+      },
+      'toDouble': (c, receiver) {
+        final int? intValue = _extractIntValue(receiver);
+        if (intValue == null) {
+          c.translateExpression(receiver, intType);
+          c.b.f64_convert_i64_s();
+        } else {
+          c.b.f64_const(intValue.toDouble());
+        }
+      },
+    },
+    doubleType: {
+      'unary-': (c, receiver) {
+        final double? doubleValue = _extractDoubleValue(receiver);
+        if (doubleValue == null) {
+          c.translateExpression(receiver, doubleType);
+          c.b.f64_neg();
+        } else {
+          c.b.f64_const(-doubleValue);
+        }
+      },
+      'floorToDouble': (c, receiver) {
+        final double? doubleValue = _extractDoubleValue(receiver);
+        if (doubleValue == null) {
+          c.translateExpression(receiver, doubleType);
+          c.b.f64_floor();
+        } else {
+          c.b.f64_const(doubleValue.floorToDouble());
+        }
+      },
+      'ceilToDouble': (c, receiver) {
+        final double? doubleValue = _extractDoubleValue(receiver);
+        if (doubleValue == null) {
+          c.translateExpression(receiver, doubleType);
+          c.b.f64_ceil();
+        } else {
+          c.b.f64_const(doubleValue.ceilToDouble());
+        }
+      },
+      'truncateToDouble': (c, receiver) {
+        final double? doubleValue = _extractDoubleValue(receiver);
+        if (doubleValue == null) {
+          c.translateExpression(receiver, doubleType);
+          c.b.f64_trunc();
+        } else {
+          c.b.f64_const(doubleValue.truncateToDouble());
+        }
       },
     },
   };
@@ -102,7 +175,6 @@ class Intrinsifier {
     'floorToDouble': w.NumType.f64,
     'ceilToDouble': w.NumType.f64,
     'truncateToDouble': w.NumType.f64,
-    '_toInt': w.NumType.i64,
   };
 
   Translator get translator => codeGen.translator;
@@ -430,12 +502,11 @@ class Intrinsifier {
     } else if (node.arguments.positional.isEmpty) {
       // Unary operator
       Expression operand = node.receiver;
-      w.ValueType opType = translator.translateType(receiverType);
-      var code = _unaryOperatorMap[opType]?[name];
+      w.ValueType operandType = translator.translateType(receiverType);
+      var code = _inlineUnaryOperatorMap[operandType]?[name];
       if (code != null) {
-        codeGen.translateExpression(operand, opType);
-        code(codeGen);
-        return _unaryResultMap[name] ?? opType;
+        code(codeGen, operand);
+        return _unaryResultMap[name] ?? operandType;
       }
     }
 
@@ -1762,3 +1833,33 @@ class Intrinsifier {
     return false;
   }
 }
+
+int? _extractIntValue(Expression expr) {
+  if (expr is IntLiteral) {
+    return expr.value;
+  }
+
+  if (expr is ConstantExpression) {
+    final constant = expr.constant;
+    if (constant is IntConstant) {
+      return constant.value;
+    }
+  }
+
+  return null;
+}
+
+double? _extractDoubleValue(Expression expr) {
+  if (expr is DoubleLiteral) {
+    return expr.value;
+  }
+
+  if (expr is ConstantExpression) {
+    final constant = expr.constant;
+    if (constant is DoubleConstant) {
+      return constant.value;
+    }
+  }
+
+  return null;
+}