[dart2wasm] Utilize true/false singleton property in identical() implementation

We maintain two singleton boxed bool instances for representing `true`
and `false`. So the code for `identical()` no longer has to treat them
as value classes where it has to unbox and compare the WasmI32.

Filed [0] for CFE to improve precision of `ConstantExpression.getStaticType()`.

[0] #60368

Change-Id: I8c02191e974aae9e168b4a826db9a87362949516
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/416941
Commit-Queue: Martin Kustermann <[email protected]>
Reviewed-by: Ömer Ağacan <[email protected]>

Author: mkustermann

pkg/dart2wasm/lib/code_generator.dart

@@ -120,6 +120,11 @@ abstract class AstCodeGenerator
   }
 
   DartType dartTypeOf(Expression exp) {
+    if (exp is ConstantExpression) {
+      // For constant expressions `getStaticType` returns often `DynamicType`
+      // instead of a more precise type. See http://dartbug.com/60368
+      return exp.constant.getType(typeContext);
+    }
     return exp.getStaticType(typeContext);
   }
 

pkg/dart2wasm/lib/intrinsics.dart

@@ -4,6 +4,7 @@
 
 import 'package:kernel/ast.dart';
 import 'package:kernel/core_types.dart';
+import 'package:kernel/type_environment.dart';
 import 'package:wasm_builder/wasm_builder.dart' as w;
 
 import 'abi.dart' show kWasmAbiEnumIndex;
@@ -1023,29 +1024,58 @@ class Intrinsifier {
         return codeGen.voidMarker;
 
       case StaticIntrinsic.identical:
-        Expression first = node.arguments.positional[0];
-        Expression second = node.arguments.positional[1];
-        DartType boolType = translator.coreTypes.boolNonNullableRawType;
-        InterfaceType intType = translator.coreTypes.intNonNullableRawType;
-        DartType doubleType = translator.coreTypes.doubleNonNullableRawType;
-        List<DartType> types = [dartTypeOf(first), dartTypeOf(second)];
-        if (types.every((t) => t == intType)) {
+        // We can use reference equality for `identical()` except if one of the
+        // arguments can be a value type which would need to be compared by
+        // value instead of by reference.
+        //
+        // NOTE: Even though `bool` is a value type, it has only two singleton
+        // instances for `true` and `false` and we can therefore use reference
+        // equality for it. Other value types may have different objects
+        // containing the same value and need to be unboxed & compared by value.
+        //
+        // NOTE: We may get more value types in the future in Dart, for example
+        // for SIMD types, see: https://github.com/dart-lang/sdk/issues/43255
+
+        final first = node.arguments.positional[0];
+        final second = node.arguments.positional[1];
+
+        final firstType =
+            translator.toMostSpecificInterfaceType(dartTypeOf(first));
+        final secondType =
+            translator.toMostSpecificInterfaceType(dartTypeOf(second));
+
+        final intType = translator.boxedIntType;
+        if (firstType == intType && secondType == intType) {
           codeGen.translateExpression(first, w.NumType.i64);
           codeGen.translateExpression(second, w.NumType.i64);
           b.i64_eq();
           return w.NumType.i32;
         }
-        if (types.any((t) =>
-            t is InterfaceType &&
-            t != boolType &&
-            t != doubleType &&
-            !translator.hierarchy
-                .isSubInterfaceOf(intType.classNode, t.classNode))) {
-          codeGen.translateExpression(first, w.RefType.eq(nullable: true));
-          codeGen.translateExpression(second, w.RefType.eq(nullable: true));
+
+        final doubleType = translator.boxedDoubleType;
+        if (firstType == doubleType && secondType == doubleType) {
+          codeGen.translateExpression(first, w.NumType.f64);
+          b.i64_reinterpret_f64();
+          codeGen.translateExpression(second, w.NumType.f64);
+          b.i64_reinterpret_f64();
+          b.i64_eq();
+          return w.NumType.i32;
+        }
+
+        bool canBeValueType(DartType type) =>
+            translator.typeEnvironment.isSubtypeOf(
+                doubleType, type, SubtypeCheckMode.withNullabilities) ||
+            translator.typeEnvironment
+                .isSubtypeOf(intType, type, SubtypeCheckMode.withNullabilities);
+
+        if (!canBeValueType(firstType) || !canBeValueType(secondType)) {
+          final nullableEqRefType = w.RefType.eq(nullable: true);
+          codeGen.translateExpression(first, nullableEqRefType);
+          codeGen.translateExpression(second, nullableEqRefType);
           b.ref_eq();
           return w.NumType.i32;
         }
+
         return null;
       case StaticIntrinsic.isObjectClassId:
         final classId = node.arguments.positional.single;
@@ -1615,7 +1645,6 @@ class Intrinsifier {
       case MemberIntrinsic.identical:
         w.Local first = paramLocals[0];
         w.Local second = paramLocals[1];
-        ClassInfo boolInfo = translator.classInfo[translator.boxedBoolClass]!;
         ClassInfo intInfo = translator.classInfo[translator.boxedIntClass]!;
         ClassInfo doubleInfo =
             translator.classInfo[translator.boxedDoubleClass]!;
@@ -1643,20 +1672,9 @@ class Intrinsifier {
         b.i32_ne();
         b.br_if(fail);
 
-        // Both bool?
-        b.local_get(cid);
-        b.i32_const((boolInfo.classId as AbsoluteClassId).value);
-        b.i32_eq();
-        b.if_();
-        b.local_get(first);
-        b.ref_cast(boolInfo.nonNullableType);
-        b.struct_get(boolInfo.struct, FieldIndex.boxValue);
-        b.local_get(second);
-        b.ref_cast(boolInfo.nonNullableType);
-        b.struct_get(boolInfo.struct, FieldIndex.boxValue);
-        b.i32_eq();
-        b.return_();
-        b.end();
+        // Cannot be equal `bool`s as we have unique singleton objects for `true`
+        // and `false`. If they were equal bools we would have triggered the
+        // reference equality above.
 
         // Both int?
         b.local_get(cid);

pkg/dart2wasm/lib/translator.dart

@@ -248,6 +248,11 @@ class Translator with KernelNodes {
   late final w.RefType nullableObjectArrayTypeRef =
       w.RefType.def(nullableObjectArrayType, nullable: false);
 
+  late final boxedIntType =
+      boxedIntClass.getThisType(coreTypes, Nullability.nonNullable);
+  late final boxedDoubleType =
+      boxedDoubleClass.getThisType(coreTypes, Nullability.nonNullable);
+
   final Map<w.ModuleBuilder, PartialInstantiator> _partialInstantiators = {};
   PartialInstantiator getPartialInstantiatorForModule(w.ModuleBuilder module) {
     return _partialInstantiators[module] ??= PartialInstantiator(this, module);
@@ -605,11 +610,39 @@ class Translator with KernelNodes {
   }
 
   Class classForType(DartType type) {
-    return type is InterfaceType
-        ? type.classNode
-        : type is TypeParameterType
-            ? classForType(type.bound)
-            : coreTypes.objectClass;
+    return toMostSpecificInterfaceType(type).classNode;
+  }
+
+  InterfaceType toMostSpecificInterfaceType(DartType originalType) {
+    var type = originalType;
+    while (type is TypeParameterType) {
+      type = type.bound;
+    }
+    while (type is StructuralParameterType) {
+      type = type.bound;
+    }
+    final objectType = coreTypes.objectNonNullableRawType;
+    final nullability = originalType.isPotentiallyNullable
+        ? Nullability.nullable
+        : Nullability.nonNullable;
+    return (switch (type) {
+      InterfaceType() => type,
+      FunctionType() => coreTypes.functionNonNullableRawType,
+      RecordType() => coreTypes.recordNonNullableRawType,
+      IntersectionType() => toMostSpecificInterfaceType(type.right),
+      ExtensionType() => toMostSpecificInterfaceType(type.extensionTypeErasure),
+      DynamicType() || VoidType() => objectType,
+      NullType() => objectType,
+      NeverType() => objectType,
+      FutureOrType() => objectType,
+      StructuralParameterType() ||
+      TypeParameterType() =>
+        throw 'unreachable, handled above',
+      TypedefType() => throw 'unreachable, should be desugared by CFE',
+      InvalidType() => throw 'unreachable, should be compile-time error',
+      AuxiliaryType() => throw 'unreachable, unused by dart2wasm',
+    })
+        .withDeclaredNullability(nullability);
   }
 
   void pushModuleId(w.InstructionsBuilder b) {