[dart2js] Remove all uses of useLegacySubtyping.

Bug: #60327
Fixes: #41960
Change-Id: Idc766a1cccd008aa7262c79effe25daa240850bf
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/416180
Reviewed-by: Nate Biggs <[email protected]>
Commit-Queue: Mayank Patke <[email protected]>

Author: fishythefish

pkg/compiler/lib/src/elements/types.dart

@@ -1885,18 +1885,16 @@ abstract class DartTypes {
   /// The types defined in 'dart:core'.
   CommonElements get commonElements;
 
-  bool get useLegacySubtyping;
-
   DartType nullableType(DartType baseType) {
     bool isNullable(DartType t) =>
         // Note that we can assume null safety is enabled here.
         t.isNull ||
         t is NullableType ||
         t is FutureOrType && isNullable(t.typeArgument) ||
-        isStrongTopType(t);
+        isTopType(t);
 
     DartType result;
-    if (isStrongTopType(baseType) ||
+    if (isTopType(baseType) ||
         baseType.isNull ||
         baseType is NullableType ||
         baseType is FutureOrType && isNullable(baseType.typeArgument)) {
@@ -2048,14 +2046,10 @@ abstract class DartTypes {
   }
 
   /// Returns `true` if [t] is a bottom type, that is, a subtype of every type.
-  bool isBottomType(DartType t) =>
-      t is NeverType || (useLegacySubtyping && t.isNull);
+  bool isBottomType(DartType t) => t is NeverType;
 
   /// Returns `true` if [t] is a top type, that is, a supertype of every type.
   bool isTopType(DartType t) =>
-      isStrongTopType(t) || useLegacySubtyping && t.isObject;
-
-  bool isStrongTopType(DartType t) =>
       t is VoidType ||
       t is DynamicType ||
       t is ErasedType ||
@@ -2111,7 +2105,7 @@ abstract class DartTypes {
       if (isTopType(t)) return true;
 
       // Left Top:
-      if (isStrongTopType(s)) return false;
+      if (isTopType(s)) return false;
 
       // Left Bottom:
       if (isBottomType(s)) return true;
@@ -2127,15 +2121,15 @@ abstract class DartTypes {
       // Left Null:
       // Note: Interchanging the Left Null and Right Object rules allows us to
       // reduce casework.
-      if (!useLegacySubtyping && s.isNull) {
+      if (s.isNull) {
         if (t is FutureOrType) {
           return isSubtype(s, t.typeArgument, env);
         }
         return t.isNull || t is NullableType;
       }
 
       // Right Object:
-      if (!useLegacySubtyping && t.isObject) {
+      if (t.isObject) {
         if (s is FutureOrType) {
           return isSubtype(s.typeArgument, t, env);
         }
@@ -2151,8 +2145,7 @@ abstract class DartTypes {
 
       // Left Nullable:
       if (s is NullableType) {
-        return (useLegacySubtyping ||
-                isSubtype(commonElements.nullType, t, env)) &&
+        return (isSubtype(commonElements.nullType, t, env)) &&
             isSubtype(s.baseType, t, env);
       }
 
@@ -2172,8 +2165,7 @@ abstract class DartTypes {
 
       // Right Nullable:
       if (t is NullableType) {
-        return (!useLegacySubtyping &&
-                isSubtype(s, commonElements.nullType, env)) ||
+        return (isSubtype(s, commonElements.nullType, env)) ||
             isSubtype(s, t.baseType, env);
       }
 
@@ -2280,14 +2272,12 @@ abstract class DartTypes {
                 String sName = sNamed[sIndex++];
                 int comparison = sName.compareTo(tName);
                 if (comparison > 0) return false;
-                bool sIsRequired =
-                    !useLegacySubtyping && sRequiredNamed.contains(sName);
+                bool sIsRequired = sRequiredNamed.contains(sName);
                 if (comparison < 0) {
                   if (sIsRequired) return false;
                   continue;
                 }
-                bool tIsRequired =
-                    !useLegacySubtyping && tRequiredNamed.contains(tName);
+                bool tIsRequired = tRequiredNamed.contains(tName);
                 if (sIsRequired && !tIsRequired) return false;
                 if (!isSubtype(
                   tNamedTypes[tIndex],
@@ -2299,10 +2289,8 @@ abstract class DartTypes {
                 break;
               }
             }
-            if (!useLegacySubtyping) {
-              while (sIndex < sNamedLength) {
-                if (sRequiredNamed.contains(sNamed[sIndex++])) return false;
-              }
+            while (sIndex < sNamedLength) {
+              if (sRequiredNamed.contains(sNamed[sIndex++])) return false;
             }
             return true;
           } finally {

pkg/compiler/lib/src/inferrer/abstract_value_domain.dart

@@ -232,14 +232,7 @@ mixin AbstractValueDomain {
   /// the input's abstract type. The check can only be removed with additional
   /// reasoning, for example, that a dominating check uses the same type
   /// expression.
-  ///
-  /// [nullable] determines if the type in weak or legacy mode should be
-  /// interpreted as nullable. This is passed as `false` for is-tests and `true`
-  /// for as-checks and other contexts (e.g. parameter checks).
-  AbstractValueWithPrecision createFromStaticType(
-    DartType type, {
-    required bool nullable,
-  });
+  AbstractValueWithPrecision createFromStaticType(DartType type);
 
   /// Creates an [AbstractValue] for a non-null exact instance of [cls].
   AbstractValue createNonNullExact(ClassEntity cls);

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

@@ -1023,8 +1023,7 @@ class KernelTypeGraphBuilder extends ir.VisitorDefault<TypeInformation?>
     if (mask != null) return mask;
     // TODO(sigmund): ensure that this is only called once per node.
     DartType staticType = _getStaticType(receiver);
-    bool includeNull =
-        _dartTypes.useLegacySubtyping || staticType is NullableType;
+    bool includeNull = staticType is NullableType;
     staticType = staticType.withoutNullability;
     if (staticType is InterfaceType) {
       ClassEntity cls = staticType.element;

pkg/compiler/lib/src/inferrer/computable.dart

@@ -175,14 +175,8 @@ class ComputableAbstractValueDomain with AbstractValueDomain {
       ComputableAbstractValue(_wrappedDomain.asyncStarStreamType);
 
   @override
-  AbstractValueWithPrecision createFromStaticType(
-    DartType type, {
-    required bool nullable,
-  }) {
-    final unwrapped = _wrappedDomain.createFromStaticType(
-      type,
-      nullable: nullable,
-    );
+  AbstractValueWithPrecision createFromStaticType(DartType type) {
+    final unwrapped = _wrappedDomain.createFromStaticType(type);
     return AbstractValueWithPrecision(
       ComputableAbstractValue(unwrapped.abstractValue),
       unwrapped.isPrecise,

pkg/compiler/lib/src/inferrer/powersets/powerset_bits.dart

@@ -213,7 +213,7 @@ class PowersetBitsDomain {
     // ConstantValue
     // TODO(fishythefish): Naively calling `getType` on
     // [LateSentinelConstantValue] will produce Never.
-    return createFromStaticType(value.getType(commonElements), nullable: false);
+    return createFromStaticType(value.getType(commonElements));
   }
 
   AbstractBool areDisjoint(int a, int b) {
@@ -455,7 +455,7 @@ class PowersetBitsDomain {
     return classInfo.exactBits;
   }
 
-  int createFromStaticType(DartType type, {required bool nullable}) {
+  int createFromStaticType(DartType type) {
     if (dartTypes.isTopType(type)) {
       // A cone of a top type includes all values. This would be 'precise' if we
       // tracked that.
@@ -466,13 +466,7 @@ class PowersetBitsDomain {
       return _createFromStaticType(type.baseType, true);
     }
 
-    if (dartTypes.useLegacySubtyping) {
-      // In legacy and weak mode, `String` is nullable depending on context.
-      return _createFromStaticType(type, nullable);
-    } else {
-      // In strong mode nullability comes from explicit NullableType.
-      return _createFromStaticType(type, false);
-    }
+    return _createFromStaticType(type, false);
   }
 
   int _createFromStaticType(DartType type, bool nullable) {

pkg/compiler/lib/src/inferrer/powersets/powersets.dart

@@ -824,18 +824,9 @@ class PowersetDomain with AbstractValueDomain {
   }
 
   @override
-  AbstractValueWithPrecision createFromStaticType(
-    DartType type, {
-    required bool nullable,
-  }) {
-    int powersetBits = _powersetBitsDomain.createFromStaticType(
-      type,
-      nullable: nullable,
-    );
-    var unwrapped = _abstractValueDomain.createFromStaticType(
-      type,
-      nullable: nullable,
-    );
+  AbstractValueWithPrecision createFromStaticType(DartType type) {
+    int powersetBits = _powersetBitsDomain.createFromStaticType(type);
+    var unwrapped = _abstractValueDomain.createFromStaticType(type);
     return AbstractValueWithPrecision(
       PowersetValue(unwrapped.abstractValue, powersetBits),
       unwrapped.isPrecise,

pkg/compiler/lib/src/inferrer/trivial.dart

@@ -384,10 +384,7 @@ class TrivialAbstractValueDomain with AbstractValueDomain {
       const TrivialAbstractValue();
 
   @override
-  AbstractValueWithPrecision createFromStaticType(
-    DartType type, {
-    required bool nullable,
-  }) {
+  AbstractValueWithPrecision createFromStaticType(DartType type) {
     return const AbstractValueWithPrecision(TrivialAbstractValue(), false);
   }
 

pkg/compiler/lib/src/inferrer/type_graph_nodes.dart

@@ -599,10 +599,7 @@ class FieldTypeInformation extends MemberTypeInformation {
     AbstractValueDomain abstractValueDomain,
     this._member,
     DartType type,
-  ) : _type =
-          abstractValueDomain
-              .createFromStaticType(type, nullable: true)
-              .abstractValue,
+  ) : _type = abstractValueDomain.createFromStaticType(type).abstractValue,
       super._internal(abstractValueDomain, _member);
 
   @override
@@ -659,7 +656,7 @@ class GetterTypeInformation extends MemberTypeInformation {
     FunctionType type,
   ) : _type =
           abstractValueDomain
-              .createFromStaticType(type.returnType, nullable: true)
+              .createFromStaticType(type.returnType)
               .abstractValue,
       super._internal(abstractValueDomain, _member);
 
@@ -709,7 +706,7 @@ class MethodTypeInformation extends MemberTypeInformation {
     FunctionType type,
   ) : _type =
           abstractValueDomain
-              .createFromStaticType(type.returnType, nullable: true)
+              .createFromStaticType(type.returnType)
               .abstractValue,
       super._internal(abstractValueDomain, _member);
 
@@ -744,7 +741,7 @@ class FactoryConstructorTypeInformation extends MemberTypeInformation {
     FunctionType type,
   ) : _type =
           abstractValueDomain
-              .createFromStaticType(type.returnType, nullable: true)
+              .createFromStaticType(type.returnType)
               .abstractValue,
       super._internal(abstractValueDomain, _member);
 
@@ -842,10 +839,7 @@ class ParameterTypeInformation extends ElementTypeInformation {
     this._parameter,
     DartType type,
     this._method,
-  ) : _type =
-          abstractValueDomain
-              .createFromStaticType(type, nullable: true)
-              .abstractValue,
+  ) : _type = abstractValueDomain.createFromStaticType(type).abstractValue,
       _inputType = abstractValueDomain.uncomputedType,
       super._internal() {
     _flags = _flags.add(_Flag.isClosureParameter);
@@ -858,10 +852,7 @@ class ParameterTypeInformation extends ElementTypeInformation {
     DartType type,
     this._method, {
     bool isInitializingFormal = false,
-  }) : _type =
-           abstractValueDomain
-               .createFromStaticType(type, nullable: true)
-               .abstractValue,
+  }) : _type = abstractValueDomain.createFromStaticType(type).abstractValue,
        _inputType = abstractValueDomain.uncomputedType,
        super._internal() {
     _flags = _flags.update(_Flag.isInitializingFormal, isInitializingFormal);
@@ -891,8 +882,7 @@ class ParameterTypeInformation extends ElementTypeInformation {
     DartType type,
     FunctionEntity method,
   ) {
-    final staticType =
-        domain.createFromStaticType(type, nullable: true).abstractValue;
+    final staticType = domain.createFromStaticType(type).abstractValue;
     // We include null in the type of `==` because it usually does not already
     // include null. When we narrow the inferred type using this static type
     // we want to allow for null so that downstream we can know if null flows
@@ -2576,7 +2566,7 @@ class AwaitTypeInformation extends TypeInformation {
       ),
     );
     return inferrer.abstractValueDomain
-        .createFromStaticType(staticType, nullable: true)
+        .createFromStaticType(staticType)
         .abstractValue;
   }
 

pkg/compiler/lib/src/inferrer/type_system.dart

@@ -341,9 +341,7 @@ class TypeSystem {
     }
 
     AbstractValue narrowing =
-        _abstractValueDomain
-            .createFromStaticType(annotation, nullable: isCast)
-            .abstractValue;
+        _abstractValueDomain.createFromStaticType(annotation).abstractValue;
 
     if (excludeNull) {
       narrowing = _abstractValueDomain.excludeNull(narrowing);
@@ -616,17 +614,13 @@ class TypeSystem {
       _abstractValueDomain,
       currentMember,
       simplifiedKeyType,
-      _abstractValueDomain
-          .createFromStaticType(keyStaticType, nullable: false)
-          .abstractValue,
+      _abstractValueDomain.createFromStaticType(keyStaticType).abstractValue,
     );
     final valueTypeInfo = ValueInMapTypeInformation(
       _abstractValueDomain,
       currentMember,
       simplifiedValueType,
-      _abstractValueDomain
-          .createFromStaticType(valueStaticType, nullable: false)
-          .abstractValue,
+      _abstractValueDomain.createFromStaticType(valueStaticType).abstractValue,
     );
     allocatedTypes.add(keyTypeInfo);
     allocatedTypes.add(valueTypeInfo);

pkg/compiler/lib/src/inferrer/typemasks/masks.dart

@@ -320,10 +320,7 @@ class CommonMasks with AbstractValueDomain {
   }
 
   @override
-  AbstractValueWithPrecision createFromStaticType(
-    DartType type, {
-    required bool nullable,
-  }) {
+  AbstractValueWithPrecision createFromStaticType(DartType type) {
     if (dartTypes.isTopType(type)) {
       // A cone of a top type includes all values.
       return AbstractValueWithPrecision(dynamicType, true);
@@ -333,13 +330,7 @@ class CommonMasks with AbstractValueDomain {
       return _createFromStaticType(type.baseType, true);
     }
 
-    if (dartTypes.useLegacySubtyping) {
-      // In legacy and weak mode, `String` is nullable depending on context.
-      return _createFromStaticType(type, nullable);
-    } else {
-      // In strong mode nullability comes from explicit NullableType.
-      return _createFromStaticType(type, false);
-    }
+    return _createFromStaticType(type, false);
   }
 
   AbstractValueWithPrecision _createFromStaticType(
@@ -414,7 +405,7 @@ class CommonMasks with AbstractValueDomain {
       final shape = type.shape;
       final fields = type.fields;
       for (final field in fields) {
-        final fieldType = createFromStaticType(field, nullable: nullable);
+        final fieldType = createFromStaticType(field);
         types.add(fieldType.abstractValue as TypeMask);
         isPrecise &= fieldType.isPrecise;
       }