[dart2js] Simply is-test when type parameters not needed

Sometimes the type expression of a is-test can be widened to one that
does not use type variables:

```dart
void addAll(Iterable<E> items) {
  if (items is List<E>) {
    ... items[i] ...  // code specialized to lists
  }
  ...
}
```

Changing `is List<E>` to `is List` is more efficient, but not possible
at the source level since the explicit type parameter is needed for
type promotion.

This change uses a predicate provided by the Kernel package to widen
an interface type when generating the CFG instructions for the
is-test. This can lead to knock-on optimizations like compiling `is X`
to `instanceof`.



Bug: #54998
Change-Id: I956b9d9b8a31ae40aee86e31def475baa9ab5cfe
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/408124
Reviewed-by: Nate Biggs <[email protected]>
Commit-Queue: Stephen Adams <[email protected]>

Author: rakudrama

pkg/compiler/lib/src/ssa/builder.dart

@@ -7717,7 +7717,53 @@ class KernelSsaGraphBuilder extends ir.VisitorDefault<void>
   void visitIsExpression(ir.IsExpression node) {
     node.operand.accept(this);
     HInstruction expression = pop();
-    _pushIsTest(node.type, expression, _sourceInformationBuilder.buildIs(node));
+    _pushIsTest(
+      _widenCheckedTypeForOperand(node.type, node.operand),
+      expression,
+      _sourceInformationBuilder.buildIs(node),
+    );
+  }
+
+  /// Returns a type that is equivalent to `checkedType`, but possibly simpler.
+  /// For example, if operand has static type `Iterable<E>` and checkedType is
+  /// `List<E>`, returns `List<dynamic>` since that is an easier test that does
+  /// not reference any type variables.
+  ir.DartType _widenCheckedTypeForOperand(
+    ir.DartType checkedType,
+    ir.Expression operand,
+  ) {
+    if (checkedType is ir.InterfaceType) {
+      if (checkedType.typeArguments.isEmpty) return checkedType;
+      final operandType = operand.getStaticType(
+        _currentFrame!.staticTypeContext!,
+      );
+      final sufficiency = closedWorld.elementMap.typeEnvironment
+          .computeTypeShapeCheckSufficiency(
+            expressionStaticType: operandType,
+            // Add `?` in case operand is nullable:
+            checkTargetType: checkedType.withDeclaredNullability(
+              ir.Nullability.nullable,
+            ),
+            subtypeCheckMode: ir.SubtypeCheckMode.withNullabilities,
+          );
+
+      // If `true` the caller only needs to check nullabillity and the actual
+      // concrete class, no need to check [testedAgainstType] arguments.
+      if (sufficiency == ir.TypeShapeCheckSufficiency.interfaceShape) {
+        return ir.InterfaceType(
+          checkedType.classNode,
+          (operandType is ir.InterfaceType &&
+                  operandType.nullability == ir.Nullability.nonNullable)
+              ? ir.Nullability.nonNullable
+              : checkedType.nullability,
+          [
+            for (final parameter in checkedType.classNode.typeParameters)
+              parameter.defaultType,
+          ],
+        );
+      }
+    }
+    return checkedType;
   }
 
   void _pushIsTest(

pkg/compiler/test/codegen/data/is_test_weakening.dart

@@ -0,0 +1,103 @@
+// Copyright (c) 2025, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// `is` tests against some parameterized interface types are equivalent to a
+// weaker test for just the interace. The weaker test is usually more efficient,
+// sometimes being compiled to `instanceof`.
+
+class Base<T> {
+  /*member: Base.test1:function(other) {
+  if (other instanceof A.D1)
+    return other.foo$0();
+  return "other";
+}*/
+  @pragma('dart2js:parameter:trust')
+  String test1(Base<T> other) {
+    if (other is D1<T>) return other.foo();
+    return 'other';
+  }
+
+  /*member: Base.test1qn:function(other) {
+  if (other instanceof A.D1)
+    return other.foo$0();
+  return "other";
+}*/
+  @pragma('dart2js:parameter:trust')
+  String test1qn(Base<T>? other) {
+    if (other is D1<T>) return other.foo();
+    return 'other';
+  }
+
+  /*member: Base.test1nq:function(other) {
+  if (other instanceof A.D1)
+    return other.method$0();
+  return "other";
+}*/
+  @pragma('dart2js:parameter:trust')
+  String? test1nq(Base<T> other) {
+    if (other is D1<T>?) return other.method(); // No promotion, so can't foo().
+    return 'other';
+  }
+
+  /*member: Base.test1qq:function(other) {
+  var t1;
+  if (type$.nullable_D1_dynamic._is(other)) {
+    t1 = other.foo$0();
+    return t1;
+  }
+  return "other";
+}*/
+  @pragma('dart2js:parameter:trust')
+  String? test1qq(Base<T>? other) {
+    if (other is D1<T>?) return other?.foo();
+    return 'other';
+  }
+
+  /*member: Base.test2:function(other) {
+  if (other instanceof A.D2)
+    return other.bar$0();
+  return "other";
+}*/
+  @pragma('dart2js:parameter:trust')
+  String test2(Base<T> other) {
+    if (other is D2<T>) return other.bar();
+    return 'other';
+  }
+
+  @pragma('dart2js:never-inline')
+  /*member: Base.method:ignore*/
+  String method() => 'Base.method';
+}
+
+class D1<T> extends Base<T> {
+  @pragma('dart2js:never-inline')
+  /*member: D1.foo:ignore*/
+  String foo() => 'D1<$T>.foo';
+}
+
+class D2<T> extends D1<T> {
+  @pragma('dart2js:never-inline')
+  /*member: D2.bar:ignore*/
+  String bar() => 'D2.bar';
+}
+
+/*member: main:ignore*/
+main() {
+  final items = [Base<int>(), D1<int>(), D2<int>()];
+
+  for (final item in items) {
+    print(item.test1(items.first));
+    print(item.test1(item));
+
+    print(item.test1qn(items.first));
+    print(item.test1qn(item));
+    print(item.test1nq(items.first));
+    print(item.test1nq(item));
+    print(item.test1qq(items.first));
+    print(item.test1qq(item));
+
+    print(item.test2(items.first));
+    print(item.test2(item));
+  }
+}