[dart2js] Add extension type to distinguish flags and powersets

Change-Id: I516cd7f0e6a03b680a399c483ef93d1e1d6cbeee
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/417911
Reviewed-by: Nate Biggs <[email protected]>
Commit-Queue: Mayank Patke <[email protected]>

Author: fishythefish

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

@@ -6,6 +6,12 @@ part of 'masks.dart';
 
 enum FlatTypeMaskKind { empty, exact, subclass, subtype }
 
+// The flags encode not only the powerset, but also the [FlatTypeMaskKind]. If
+// we type both flags and powersets as [Bitset]s, we risk accidentally passing
+// the wrong one when the other is expected. We can get type safety against this
+// by introducing this extension type.
+extension type _Flags(Bitset bitset) {}
+
 /// A flat type mask is a type mask that has been flattened to contain a
 /// base type.
 class FlatTypeMask extends TypeMask {
@@ -22,15 +28,22 @@ class FlatTypeMask extends TypeMask {
 
   final ClassEntity? base;
 
-  final Bitset flags;
+  final _Flags _flags;
+
+  static _Flags _computeFlags(FlatTypeMaskKind kind, Bitset powerset) =>
+      _Flags(Bitset(kind.index << _powersetDomains.bitWidth | powerset.bits));
+
+  static Bitset _powersetOfFlagsUnion(_Flags a, _Flags b) =>
+      _getPowerset(_Flags(a.bitset.union(b.bitset)));
 
-  static Bitset _computeFlags(FlatTypeMaskKind kind, Bitset powerset) =>
-      Bitset(kind.index << _powersetDomains.bitWidth | powerset.bits);
+  static Bitset _powersetOfFlagsIntersection(_Flags a, _Flags b) =>
+      _getPowerset(_Flags(a.bitset.intersection(b.bitset)));
 
-  static FlatTypeMaskKind _getKind(Bitset flags) =>
-      FlatTypeMaskKind.values[flags.bits >> _powersetDomains.bitWidth];
+  static FlatTypeMaskKind _getKind(_Flags flags) =>
+      FlatTypeMaskKind.values[flags.bitset.bits >> _powersetDomains.bitWidth];
 
-  static Bitset _getPowerset(Bitset flags) => _powersetDomains.restrict(flags);
+  static Bitset _getPowerset(_Flags flags) =>
+      _powersetDomains.restrict(flags.bitset);
 
   static EnumSet<TypeMaskSpecialValue> _composeSpecialValues({
     required bool isNullable,
@@ -166,13 +179,13 @@ class FlatTypeMask extends TypeMask {
     return FlatTypeMask._cached(base, _computeFlags(kind, powerset), domain);
   }
 
-  const FlatTypeMask._(this.base, this.flags);
+  const FlatTypeMask._(this.base, this._flags);
 
   factory FlatTypeMask._cached(
     ClassEntity? base,
-    Bitset flags,
+    _Flags flags,
     CommonMasks domain,
-  ) => domain.getCachedMask(base, flags, () {
+  ) => domain._getCachedMask(base, flags, () {
     final mask = FlatTypeMask._(base, flags);
     // Since this is the only place [FlatTypeMask]s are allocated, it is an
     // invariant that every [FlatTypeMask] is normalized.
@@ -220,7 +233,7 @@ class FlatTypeMask extends TypeMask {
   ) {
     source.begin(tag);
     final base = source.readClassOrNull();
-    final flags = Bitset(source.readInt());
+    final flags = _Flags(Bitset(source.readInt()));
     source.end(tag);
     return FlatTypeMask._cached(base, flags, domain);
   }
@@ -231,40 +244,44 @@ class FlatTypeMask extends TypeMask {
     sink.writeEnum(TypeMaskKind.flat);
     sink.begin(tag);
     sink.writeClassOrNull(base);
-    sink.writeInt(flags.bits);
+    sink.writeInt(_flags.bitset.bits);
     sink.end(tag);
   }
 
-  FlatTypeMaskKind get _kind => _getKind(flags);
+  FlatTypeMaskKind get _kind => _getKind(_flags);
 
   @override
-  Bitset get powerset => _getPowerset(flags);
+  Bitset get powerset => _getPowerset(_flags);
 
   ClassQuery get _classQuery =>
       isExact
           ? ClassQuery.exact
           : (isSubclass ? ClassQuery.subclass : ClassQuery.subtype);
 
   @override
-  bool get isEmpty => isEmptyOrSpecial && _specialValueDomain.isEmpty(flags);
+  bool get isEmpty =>
+      isEmptyOrSpecial && _specialValueDomain.isEmpty(_flags.bitset);
   @override
   bool get isNull =>
-      isEmptyOrSpecial && _specialValueDomain.restrict(flags) == _nullBit;
+      isEmptyOrSpecial &&
+      _specialValueDomain.restrict(_flags.bitset) == _nullBit;
   @override
   bool get isEmptyOrSpecial => _kind == FlatTypeMaskKind.empty;
   @override
   bool get isExact => _kind == FlatTypeMaskKind.exact;
   @override
   bool get isNullable =>
-      _specialValueDomain.contains(flags, TypeMaskSpecialValue.null_);
+      _specialValueDomain.contains(_flags.bitset, TypeMaskSpecialValue.null_);
   @override
-  bool get hasLateSentinel =>
-      _specialValueDomain.contains(flags, TypeMaskSpecialValue.lateSentinel);
+  bool get hasLateSentinel => _specialValueDomain.contains(
+    _flags.bitset,
+    TypeMaskSpecialValue.lateSentinel,
+  );
   @override
   AbstractBool get isLateSentinel {
     if (!hasLateSentinel) return AbstractBool.false_;
     if (isEmptyOrSpecial &&
-        _specialValueDomain.restrict(flags) == _lateSentinelBit) {
+        _specialValueDomain.restrict(_flags.bitset) == _lateSentinelBit) {
       return AbstractBool.true_;
     }
     return AbstractBool.maybe;
@@ -279,7 +296,7 @@ class FlatTypeMask extends TypeMask {
   @override
   FlatTypeMask withPowerset(Bitset powerset, CommonMasks domain) {
     final newFlags = _computeFlags(_kind, powerset);
-    if (newFlags == flags) return this;
+    if (newFlags == _flags) return this;
     return FlatTypeMask._cached(base, newFlags, domain);
   }
 
@@ -436,7 +453,7 @@ class FlatTypeMask extends TypeMask {
   TypeMask union(TypeMask other, CommonMasks domain) {
     JClosedWorld closedWorld = domain.closedWorld;
     if (other is! FlatTypeMask) return other.union(this, domain);
-    final powerset = this.powerset.union(other.powerset);
+    final powerset = _powersetOfFlagsUnion(_flags, other._flags);
     if (isEmptyOrSpecial) {
       return other.withPowerset(powerset, domain);
     } else if (other.isEmptyOrSpecial) {
@@ -464,13 +481,14 @@ class FlatTypeMask extends TypeMask {
     // The two masks share the base type, so we must chose the least
     // constraining kind (the highest) of the two. As both masks are normalized,
     // the result will be, too.
-    final combined =
-        (flags.bits > other.flags.bits)
-            ? flags.union(other.powerset)
-            : other.flags.union(powerset);
-    if (flags == combined) {
+    final combined = _Flags(
+      (_flags.bitset.bits > other._flags.bitset.bits)
+          ? _flags.bitset.union(other.powerset)
+          : other._flags.bitset.union(powerset),
+    );
+    if (_flags == combined) {
       return this;
-    } else if (other.flags == combined) {
+    } else if (other._flags == combined) {
       return other;
     } else {
       return FlatTypeMask._cached(base, combined, domain);
@@ -481,25 +499,21 @@ class FlatTypeMask extends TypeMask {
     assert(base != other.base);
     assert(domain.closedWorld.classHierarchy.isSubclassOf(other.base!, base!));
     final FlatTypeMaskKind combinedKind;
-    final Bitset combinedPowerset;
+    final Bitset combinedPowerset = _powersetOfFlagsUnion(_flags, other._flags);
     if ((isExact && other.isExact) ||
         base == domain.commonElements.objectClass) {
       // Since the other mask is a subclass of this mask, we need the
       // resulting union to be a subclass too.
       combinedKind = FlatTypeMaskKind.subclass;
-      combinedPowerset = powerset.union(other.powerset);
       if (combinedKind == _kind && combinedPowerset == powerset) {
         return this;
       }
     } else {
       // Both masks are at least subclass masks, so we pick the least
       // constraining kind (the highest) of the two.
-      final combined =
-          (flags.bits > other.flags.bits)
-              ? flags.union(other.powerset)
-              : other.flags.union(powerset);
-      combinedKind = _getKind(combined);
-      combinedPowerset = _getPowerset(combined);
+      combinedKind = _getKind(
+        _flags.bitset.bits > other._flags.bitset.bits ? _flags : other._flags,
+      );
     }
     // If we weaken the constraint on this type, we have to make sure that
     // the result is normalized.
@@ -518,7 +532,7 @@ class FlatTypeMask extends TypeMask {
     // Since the other mask is a subtype of this mask, we need the
     // resulting union to be a subtype too.
     final combinedKind = FlatTypeMaskKind.subtype;
-    final combinedPowerset = powerset.union(other.powerset);
+    final combinedPowerset = _powersetOfFlagsUnion(_flags, other._flags);
     return combinedKind == _kind && combinedPowerset == powerset
         ? this
         // If we weaken the constraint on this type, we have to make sure that
@@ -538,7 +552,7 @@ class FlatTypeMask extends TypeMask {
     if (other is! FlatTypeMask) return other.intersection(this, domain);
 
     final otherBase = other.base;
-    final powerset = this.powerset.intersection(other.powerset);
+    final powerset = _powersetOfFlagsIntersection(_flags, other._flags);
     final includeNull = _specialValueDomain.contains(
       powerset,
       TypeMaskSpecialValue.null_,
@@ -683,14 +697,19 @@ class FlatTypeMask extends TypeMask {
     // The two masks share the base type, so we must chose the most
     // constraining kind (the lowest) of the two. The result will be normalized,
     // as the two inputs are normalized, too.
-    final combined =
-        (flags.bits < other.flags.bits)
-            ? flags.intersection(other.flags.union(_powersetDomains.notMask))
-            : other.flags.intersection(flags.union(_powersetDomains.notMask));
+    final combined = _Flags(
+      (_flags.bitset.bits < other._flags.bitset.bits)
+          ? _flags.bitset.intersection(
+            other._flags.bitset.union(_powersetDomains.notMask),
+          )
+          : other._flags.bitset.intersection(
+            _flags.bitset.union(_powersetDomains.notMask),
+          ),
+    );
 
-    if (flags == combined) {
+    if (_flags == combined) {
       return this;
-    } else if (other.flags == combined) {
+    } else if (other._flags == combined) {
       return other;
     } else {
       return FlatTypeMask._cached(base, combined, domain);
@@ -706,10 +725,12 @@ class FlatTypeMask extends TypeMask {
     // Only the other mask puts constraints on the intersection mask,
     // so base the combined flags on the other mask. The result is guaranteed to
     // be normalized, as the other type was normalized.
-    final combined = other.flags.intersection(
-      flags.union(_powersetDomains.notMask),
+    final combined = _Flags(
+      other._flags.bitset.intersection(
+        _flags.bitset.union(_powersetDomains.notMask),
+      ),
     );
-    if (other.flags == combined) {
+    if (other._flags == combined) {
       return other;
     } else {
       return FlatTypeMask._cached(other.base, combined, domain);
@@ -868,12 +889,12 @@ class FlatTypeMask extends TypeMask {
     if (identical(this, other)) return true;
     if (other is! FlatTypeMask) return false;
     FlatTypeMask otherMask = other;
-    return (flags == otherMask.flags) && (base == otherMask.base);
+    return (_flags == otherMask._flags) && (base == otherMask.base);
   }
 
   @override
   int get hashCode {
-    return (base == null ? 0 : base.hashCode) + 31 * flags.hashCode;
+    return (base == null ? 0 : base.hashCode) + 31 * _flags.hashCode;
   }
 
   @override

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

@@ -46,20 +46,20 @@ part 'value_type_mask.dart';
 // TODO(60419): Go back to using a record as the key when it is no longer slower
 // than using a data class.
 final class _CanonicalizedTypeMaskKey {
-  final ClassEntity? base;
-  final Bitset flags;
+  final ClassEntity? _base;
+  final _Flags _flags;
 
-  const _CanonicalizedTypeMaskKey(this.base, this.flags);
+  const _CanonicalizedTypeMaskKey(this._base, this._flags);
 
   @override
-  int get hashCode => Object.hash(base, flags);
+  int get hashCode => Object.hash(_base, _flags);
 
   @override
   bool operator ==(Object other) =>
       identical(this, other) ||
       other is _CanonicalizedTypeMaskKey &&
-          base == other.base &&
-          flags == other.flags;
+          _base == other._base &&
+          _flags == other._flags;
 }
 
 class CommonMasks with AbstractValueDomain {
@@ -78,11 +78,11 @@ class CommonMasks with AbstractValueDomain {
   final Map<_CanonicalizedTypeMaskKey, FlatTypeMask> _canonicalizedTypeMasks =
       {};
 
-  /// Return the cached mask for [base] with the given special values, or
-  /// calls [createMask] to create the mask and cache it.
-  FlatTypeMask getCachedMask(
+  /// Return the cached mask for [base] with the given flags, or calls
+  /// [createMask] to create the mask and cache it.
+  FlatTypeMask _getCachedMask(
     ClassEntity? base,
-    Bitset flags,
+    _Flags flags,
     FlatTypeMask Function() createMask,
   ) => _canonicalizedTypeMasks.putIfAbsent(
     _CanonicalizedTypeMaskKey(base, flags),