[dart2js] Remove LegacyType.

Bug: #60327
Change-Id: Ia236d1674ba8030da3b91e88ac869e99fe5b8399
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/416024
Reviewed-by: Nate Biggs <[email protected]>

Author: fishythefish

pkg/compiler/lib/src/deferred_load/entity_data_info.dart

@@ -391,11 +391,6 @@ class TypeEntityDataVisitor implements DartTypeVisitor<void, Null> {
     types.forEach(visit);
   }
 
-  @override
-  void visitLegacyType(LegacyType type, Null argument) {
-    visit(type.baseType);
-  }
-
   @override
   void visitNullableType(NullableType type, Null argument) {
     visit(type.baseType);

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

@@ -6,7 +6,6 @@ import 'package:js_shared/variance.dart';
 
 import '../common/elements.dart' show CommonElements;
 import '../common/names.dart';
-import '../options.dart';
 import '../serialization/serialization.dart';
 import '../util/util.dart' show equalElements, equalSets, identicalElements;
 import '../universe/record_shape.dart';
@@ -72,8 +71,6 @@ abstract class DartType {
     switch (kind) {
       case DartTypeKind.none:
         return null;
-      case DartTypeKind.legacyType:
-        return LegacyType._readFromDataSource(source, functionTypeVariables);
       case DartTypeKind.nullableType:
         return NullableType._readFromDataSource(source, functionTypeVariables);
       case DartTypeKind.neverType:
@@ -112,8 +109,8 @@ abstract class DartType {
     List<FunctionTypeVariable> functionTypeVariables,
   );
 
-  /// Returns the base type if this is a [LegacyType] or [NullableType] and
-  /// returns this type otherwise.
+  /// Returns the base type if this is a [NullableType] and returns this type
+  /// otherwise.
   DartType get withoutNullability => this;
 
   /// Whether this type contains a type variable.
@@ -142,10 +139,10 @@ abstract class DartType {
   bool _equals(DartType other, _Assumptions? assumptions);
 
   @override
-  String toString() => toStructuredText(null, null);
+  String toString() => toStructuredText(null);
 
-  String toStructuredText(DartTypes? dartTypes, CompilerOptions? options) =>
-      _DartTypeToStringVisitor(dartTypes, options).run(this);
+  String toStructuredText(DartTypes? dartTypes) =>
+      _DartTypeToStringVisitor(dartTypes).run(this);
 }
 
 /// Pairs of [FunctionTypeVariable]s that are currently assumed to be
@@ -231,67 +228,6 @@ class _Assumptions {
   }
 }
 
-class LegacyType extends DartType {
-  final DartType baseType;
-
-  const LegacyType._(this.baseType);
-
-  factory LegacyType._readFromDataSource(
-    DataSourceReader source,
-    List<FunctionTypeVariable> functionTypeVariables,
-  ) {
-    DartType baseType = DartType.readFromDataSource(
-      source,
-      functionTypeVariables,
-    );
-    return LegacyType._(baseType);
-  }
-
-  @override
-  void writeToDataSink(
-    DataSinkWriter sink,
-    List<FunctionTypeVariable> functionTypeVariables,
-  ) {
-    sink.writeEnum(DartTypeKind.legacyType);
-    baseType.writeToDataSink(sink, functionTypeVariables);
-  }
-
-  @override
-  DartType get withoutNullability => baseType;
-
-  @override
-  bool get containsTypeVariables => baseType.containsTypeVariables;
-
-  @override
-  void forEachTypeVariable(void Function(TypeVariableType variable) f) {
-    baseType.forEachTypeVariable(f);
-  }
-
-  @override
-  R accept<R, A>(DartTypeVisitor<R, A> visitor, A argument) =>
-      visitor.visitLegacyType(this, argument);
-
-  @override
-  int get hashCode => baseType.hashCode * 31;
-
-  @override
-  bool operator ==(other) {
-    if (identical(this, other)) return true;
-    if (other is! LegacyType) return false;
-    return _equalsInternal(other, null);
-  }
-
-  @override
-  bool _equals(DartType other, _Assumptions? assumptions) {
-    if (identical(this, other)) return true;
-    if (other is! LegacyType) return false;
-    return _equalsInternal(other, assumptions);
-  }
-
-  bool _equalsInternal(LegacyType other, _Assumptions? assumptions) =>
-      baseType._equals(other.baseType, assumptions);
-}
-
 class NullableType extends DartType {
   final DartType baseType;
 
@@ -1091,8 +1027,6 @@ abstract class DartTypeVisitor<R, A> {
 
   R visit(covariant DartType type, A argument) => type.accept(this, argument);
 
-  R visitLegacyType(covariant LegacyType type, A argument);
-
   R visitNullableType(covariant NullableType type, A argument);
 
   R visitNeverType(covariant NeverType type, A argument);
@@ -1133,9 +1067,6 @@ class _LegacyErasureVisitor extends DartTypeVisitor<DartType, Null> {
   @override
   DartType visit(DartType type, Null _) => type.accept(this, null);
 
-  @override
-  DartType visitLegacyType(LegacyType type, Null _) => erase(type.baseType);
-
   @override
   DartType visitNullableType(NullableType type, Null _) {
     var baseType = erase(type.baseType);
@@ -1280,19 +1211,6 @@ abstract class DartTypeSubstitutionVisitor<A>
     bool freshReference,
   ) => type;
 
-  @override
-  DartType visitLegacyType(covariant LegacyType type, A argument) {
-    DartType? probe = _map[type];
-    if (probe != null) return probe;
-
-    DartType newBaseType = visit(type.baseType, argument);
-    // Create a new type only if necessary.
-    if (identical(type.baseType, newBaseType)) {
-      return _mapped(type, type);
-    }
-    return _mapped(type, dartTypes.legacyType(newBaseType));
-  }
-
   @override
   DartType visitNullableType(covariant NullableType type, A argument) {
     DartType? probe = _map[type];
@@ -1540,7 +1458,6 @@ abstract class DartTypeStructuralPredicateVisitor
 
   bool run(DartType type) => visit(type, null);
 
-  bool handleLegacyType(LegacyType type) => false;
   bool handleNullableType(NullableType type) => false;
   bool handleNeverType(NeverType type) => false;
   bool handleVoidType(VoidType type) => false;
@@ -1555,10 +1472,6 @@ abstract class DartTypeStructuralPredicateVisitor
   bool handleAnyType(AnyType type) => false;
   bool handleFutureOrType(FutureOrType type) => false;
 
-  @override
-  bool visitLegacyType(LegacyType type, List<FunctionTypeVariable>? bindings) =>
-      handleLegacyType(type) || visit(type.baseType, bindings);
-
   @override
   bool visitNullableType(
     NullableType type,
@@ -1727,14 +1640,13 @@ class _DeferredName {
 
 class _DartTypeToStringVisitor extends DartTypeVisitor<void, void> {
   final DartTypes? _dartTypes; // May be null.
-  final CompilerOptions? _options; // May be null.
   final List<Object> _fragments = []; // Strings and _DeferredNames
   bool _lastIsIdentifier = false;
   List<FunctionTypeVariable>? _boundVariables;
   Map<FunctionTypeVariable, _DeferredName>? _variableToName;
   Set<FunctionType>? _genericFunctions;
 
-  _DartTypeToStringVisitor(this._dartTypes, this._options);
+  _DartTypeToStringVisitor(this._dartTypes);
 
   String run(DartType type) {
     _visit(type);
@@ -1793,18 +1705,6 @@ class _DartTypeToStringVisitor extends DartTypeVisitor<void, void> {
     type.accept(this, null);
   }
 
-  @override
-  void visitLegacyType(covariant LegacyType type, _) {
-    _visit(type.baseType);
-    // We do not emit the '*' token for legacy types because this is a purely
-    // internal notion. The language specification does not define a '*' token
-    // in the type language, and no such token should be surfaced to users.
-    // For debugging, pass `--debug-print-legacy-stars` to emit the '*'.
-    if (_options == null || _options.printLegacyStars) {
-      _token('*');
-    }
-  }
-
   @override
   void visitNullableType(covariant NullableType type, _) {
     _visit(type.baseType);
@@ -1987,25 +1887,11 @@ abstract class DartTypes {
 
   bool get useLegacySubtyping;
 
-  DartType legacyType(DartType baseType) {
-    DartType result;
-    if (isStrongTopType(baseType) ||
-        baseType.isNull ||
-        baseType is LegacyType ||
-        baseType is NullableType) {
-      result = baseType;
-    } else {
-      result = LegacyType._(baseType);
-    }
-    return result;
-  }
-
   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 LegacyType && isNullable(t.baseType) ||
         t is FutureOrType && isNullable(t.typeArgument) ||
         isStrongTopType(t);
 
@@ -2017,16 +1903,6 @@ abstract class DartTypes {
       result = baseType;
     } else if (baseType is NeverType) {
       result = commonElements.nullType;
-    } else if (baseType is LegacyType) {
-      DartType legacyBaseType = baseType.baseType;
-      if (legacyBaseType is NeverType) {
-        result = commonElements.nullType;
-      } else if (legacyBaseType is FutureOrType &&
-          isNullable(legacyBaseType.typeArgument)) {
-        result = legacyBaseType;
-      } else {
-        result = nullableType(legacyBaseType);
-      }
     } else {
       result = NullableType._(baseType);
     }
@@ -2177,9 +2053,7 @@ abstract class DartTypes {
 
   /// Returns `true` if [t] is a top type, that is, a supertype of every type.
   bool isTopType(DartType t) =>
-      isStrongTopType(t) ||
-      t is LegacyType && t.baseType.isObject ||
-      useLegacySubtyping && t.isObject;
+      isStrongTopType(t) || useLegacySubtyping && t.isObject;
 
   bool isStrongTopType(DartType t) =>
       t is VoidType ||
@@ -2257,36 +2131,17 @@ abstract class DartTypes {
         if (t is FutureOrType) {
           return isSubtype(s, t.typeArgument, env);
         }
-        return t.isNull || t is LegacyType || t is NullableType;
+        return t.isNull || t is NullableType;
       }
 
       // Right Object:
       if (!useLegacySubtyping && t.isObject) {
         if (s is FutureOrType) {
           return isSubtype(s.typeArgument, t, env);
         }
-        if (s is LegacyType) {
-          return isSubtype(s.baseType, t, env);
-        }
         return s is! NullableType;
       }
 
-      // Left Legacy:
-      if (s is LegacyType) {
-        return isSubtype(s.baseType, t, env);
-      }
-
-      // Right Legacy:
-      if (t is LegacyType) {
-        // Note that to convert `T*` to `T?`, we can't just say `t._toNullable`.
-        // The resulting type `T?` may be normalizable (e.g. if `T` is `Never`).
-        return isSubtype(
-          s,
-          useLegacySubtyping ? t.baseType : nullableType(t),
-          env,
-        );
-      }
-
       // Left FutureOr:
       if (s is FutureOrType) {
         DartType typeArgument = s.typeArgument;
@@ -2620,9 +2475,6 @@ abstract class DartTypes {
       return false;
     }
     if (type is NullableType) return false;
-    if (type is LegacyType) {
-      return isNonNullableIfSound(type.baseType);
-    }
     if (type is InterfaceType) {
       if (type.isNull) return false;
       return true;
@@ -2640,7 +2492,6 @@ abstract class DartTypes {
   }
 
   DartType getUnionFreeType(DartType type) {
-    if (type is LegacyType) return getUnionFreeType(type.baseType);
     if (type is NullableType) return getUnionFreeType(type.baseType);
     if (type is FutureOrType) return getUnionFreeType(type.typeArgument);
     return type;

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

@@ -466,19 +466,6 @@ class PowersetBitsDomain {
       return _createFromStaticType(type.baseType, true);
     }
 
-    if (type is LegacyType) {
-      DartType baseType = type.baseType;
-      if (baseType is NeverType) {
-        // Never* is same as Null, for both 'is' and 'as'.
-        return nullMask;
-      }
-
-      // Object* is a top type for both 'is' and 'as'. This is handled in the
-      // 'cone of top type' case above.
-
-      return _createFromStaticType(baseType, nullable);
-    }
-
     if (dartTypes.useLegacySubtyping) {
       // In legacy and weak mode, `String` is nullable depending on context.
       return _createFromStaticType(type, nullable);

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

@@ -333,19 +333,6 @@ class CommonMasks with AbstractValueDomain {
       return _createFromStaticType(type.baseType, true);
     }
 
-    if (type is LegacyType) {
-      DartType baseType = type.baseType;
-      if (baseType is NeverType) {
-        // Never* is same as Null, for both 'is' and 'as'.
-        return AbstractValueWithPrecision(nullType, true);
-      }
-
-      // Object* is a top type for both 'is' and 'as'. This is handled in the
-      // 'cone of top type' case above.
-
-      return _createFromStaticType(baseType, nullable);
-    }
-
     if (dartTypes.useLegacySubtyping) {
       // In legacy and weak mode, `String` is nullable depending on context.
       return _createFromStaticType(type, nullable);

pkg/compiler/lib/src/ir/impact_data.dart

@@ -108,7 +108,7 @@ class ImpactBuilder extends ir.RecursiveVisitor implements ImpactRegistry {
   CompilerOptions get _options => _elementMap.options;
 
   String _typeToString(DartType type) =>
-      type.toStructuredText(_elementMap.types, _elementMap.options);
+      type.toStructuredText(_elementMap.types);
 
   /// Return the named arguments names as a list of strings.
   List<String> _getNamedArguments(ir.Arguments arguments) =>

pkg/compiler/lib/src/ir/visitors.dart

@@ -63,7 +63,9 @@ class DartTypeConverter extends ir.DartTypeVisitor<DartType> {
       case ir.Nullability.nullable:
         return _dartTypes.nullableType(baseType);
       case ir.Nullability.legacy:
-        return _dartTypes.legacyType(baseType);
+        throw UnsupportedError(
+          'Unexpected legacy nullability on $nullabilitySource',
+        );
       case ir.Nullability.undetermined:
         // Type parameters may have undetermined nullability since it is derived
         // from the intersection of the declared nullability with the

pkg/compiler/lib/src/js_backend/namer.dart

@@ -1166,10 +1166,6 @@ class _TypeConstantRepresentationVisitor extends DartTypeVisitor<String, Null> {
 
   String _represent(DartType type) => visit(type, null);
 
-  @override
-  String visitLegacyType(LegacyType type, _) =>
-      'legacy_${_represent(type.baseType)}';
-
   @override
   String visitNullableType(NullableType type, _) =>
       'nullable_${_represent(type.baseType)}';