[dart2js] Add indexable bits to powerset.

Change-Id: I5d4c0b4d15a05cfc30d87003785ca841c46b1a0f
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/426583
Reviewed-by: Stephen Adams <[email protected]>

Author: fishythefish

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

@@ -877,12 +877,22 @@ typedef _CachedPowersets = ({Bitset exact, Bitset subclass, Bitset subtype});
 class _PowersetCache {
   final JClosedWorld _closedWorld;
   final Set<ClassEntity> _interceptorCone;
+  final Set<ClassEntity> _indexableCone;
+  final Set<ClassEntity> _mutableIndexableCone;
   final Map<ClassEntity, _CachedPowersets> _cache = {};
 
   _PowersetCache(this._closedWorld)
     : _interceptorCone =
           _closedWorld.classHierarchy
               .subclassesOf(_closedWorld.commonElements.jsInterceptorClass)
+              .toSet(),
+      _indexableCone =
+          _closedWorld.classHierarchy
+              .subtypesOf(_closedWorld.commonElements.jsIndexableClass)
+              .toSet(),
+      _mutableIndexableCone =
+          _closedWorld.classHierarchy
+              .subtypesOf(_closedWorld.commonElements.jsMutableIndexableClass)
               .toSet();
 
   Bitset _computeExactPowerset(ClassEntity cls) {
@@ -915,6 +925,25 @@ class _PowersetCache {
       powerset = _arrayDomain.add(powerset, TypeMaskArrayProperty.other);
     }
 
+    // The order of these checks is important since `JSMutableIndexable` is a
+    // subclass of `JSIndexable`.
+    if (_mutableIndexableCone.contains(cls)) {
+      powerset = _indexableDomain.add(
+        powerset,
+        TypeMaskIndexableProperty.mutableIndexable,
+      );
+    } else if (_indexableCone.contains(cls)) {
+      powerset = _indexableDomain.add(
+        powerset,
+        TypeMaskIndexableProperty.indexable,
+      );
+    } else {
+      powerset = _indexableDomain.add(
+        powerset,
+        TypeMaskIndexableProperty.notIndexable,
+      );
+    }
+
     return powerset;
   }
 

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

@@ -233,11 +233,6 @@ class CommonMasks with AbstractValueDomain {
   @override
   TypeMask get emptyType => TypeMask.nonNullEmpty(this);
 
-  late final TypeMask indexablePrimitiveType = TypeMask.nonNullSubtype(
-    commonElements.jsIndexableClass,
-    this,
-  );
-
   late final TypeMask readableArrayType = TypeMask.nonNullSubclass(
     commonElements.jsArrayClass,
     this,
@@ -568,55 +563,69 @@ class CommonMasks with AbstractValueDomain {
 
   @override
   AbstractBool isIndexablePrimitive(TypeMask value) =>
-      AbstractBool.trueOrMaybe(_isIndexablePrimitive(value));
-
-  bool _isIndexablePrimitive(TypeMask value) {
-    return value.containsOnlyString(closedWorld) ||
-        _isInstanceOfOrNull(value, commonElements.jsIndexableClass);
-  }
+      AbstractBool.trueOrMaybe(value.containsOnlyString(closedWorld)) |
+      isJsIndexable(value);
 
   @override
   AbstractBool isMutableIndexable(TypeMask value) {
-    return AbstractBool.trueOrMaybe(
-      _isInstanceOfOrNull(value, commonElements.jsMutableIndexableClass),
-    );
+    final powerset = value.powerset;
+
+    if (_indexableDomain.containsSingle(
+      powerset,
+      TypeMaskIndexableProperty.mutableIndexable,
+    )) {
+      return AbstractBool.true_;
+    }
+
+    if (!_indexableDomain.contains(
+      powerset,
+      TypeMaskIndexableProperty.mutableIndexable,
+    )) {
+      return AbstractBool.false_;
+    }
+
+    return AbstractBool.maybe;
   }
 
   @override
   AbstractBool isModifiableArray(TypeMask value) {
     final powerset = value.powerset;
 
-    if (_arrayDomain.contains(powerset, TypeMaskArrayProperty.other)) {
-      return AbstractBool.maybe;
+    if (_arrayDomain.containsOnly(
+      powerset,
+      TypeMaskArrayProperty._modifiableEnumSet,
+    )) {
+      return AbstractBool.true_;
     }
 
-    if (!powerset.intersects(TypeMaskArrayProperty._modifiableMask)) {
+    if (_arrayDomain.containsOnly(
+      powerset,
+      TypeMaskArrayProperty._unmodifiableEnumSet,
+    )) {
       return AbstractBool.false_;
     }
 
-    if (!powerset.intersects(TypeMaskArrayProperty._unmodifiableMask)) {
-      return AbstractBool.true_;
-    }
-
     return AbstractBool.maybe;
   }
 
   @override
   AbstractBool isGrowableArray(TypeMask value) {
     final powerset = value.powerset;
 
-    if (_arrayDomain.contains(powerset, TypeMaskArrayProperty.other)) {
-      return AbstractBool.maybe;
+    if (_arrayDomain.containsOnly(
+      powerset,
+      TypeMaskArrayProperty._growableEnumSet,
+    )) {
+      return AbstractBool.true_;
     }
 
-    if (!powerset.intersects(TypeMaskArrayProperty._growableMask)) {
+    if (_arrayDomain.containsOnly(
+      powerset,
+      TypeMaskArrayProperty._fixedLengthEnumSet,
+    )) {
       return AbstractBool.false_;
     }
 
-    if (!powerset.intersects(TypeMaskArrayProperty._fixedLengthMask)) {
-      return AbstractBool.true_;
-    }
-
     return AbstractBool.maybe;
   }
 
@@ -747,12 +756,20 @@ class CommonMasks with AbstractValueDomain {
   AbstractBool isPrimitiveOrNull(TypeMask value) =>
       AbstractBool.trueOrMaybe(_isPrimitiveOrNull(value));
 
-  bool _isPrimitiveOrNull(TypeMask value) {
-    return _isIndexablePrimitive(value) ||
-        _isNumberOrNull(value) ||
-        _isBooleanOrNull(value) ||
-        value.isNull;
-  }
+  bool _isIndexable(TypeMask value) =>
+      !_indexableDomain.contains(
+        value.powerset,
+        TypeMaskIndexableProperty.notIndexable,
+      );
+
+  bool _isIndexablePrimitive(TypeMask value) =>
+      value.containsOnlyString(closedWorld) || _isIndexable(value);
+
+  bool _isPrimitiveOrNull(TypeMask value) =>
+      _isIndexablePrimitive(value) ||
+      _isNumberOrNull(value) ||
+      _isBooleanOrNull(value) ||
+      value.isNull;
 
   @override
   TypeMask union(TypeMask a, TypeMask b) => a.union(b, this);
@@ -883,18 +900,24 @@ class CommonMasks with AbstractValueDomain {
 
   @override
   AbstractBool isJsIndexable(TypeMask mask) {
-    return AbstractBool.trueOrMaybe(
-      mask.satisfies(closedWorld.commonElements.jsIndexableClass, closedWorld),
-    );
+    final powerset = mask.powerset;
+
+    if (_isIndexable(mask)) return AbstractBool.true_;
+
+    if (_indexableDomain.containsSingle(
+      powerset,
+      TypeMaskIndexableProperty.notIndexable,
+    )) {
+      return AbstractBool.false_;
+    }
+
+    return AbstractBool.maybe;
   }
 
   @override
   AbstractBool isJsIndexableAndIterable(covariant TypeMask mask) {
     return AbstractBool.trueOrMaybe(
-      mask.satisfies(
-            closedWorld.commonElements.jsIndexableClass,
-            closedWorld,
-          ) &&
+      _isIndexable(mask) &&
           // String is indexable but not iterable.
           !mask.satisfies(
             closedWorld.commonElements.jsStringClass,
@@ -910,9 +933,9 @@ class CommonMasks with AbstractValueDomain {
       return AbstractBool.true_;
     }
     // TODO(sra): Recognize any combination of fixed length indexables.
-    if (mask.containsOnly(closedWorld.commonElements.jsFixedArrayClass) ||
-        mask.containsOnly(
-          closedWorld.commonElements.jsUnmodifiableArrayClass,
+    if (_arrayDomain.containsOnly(
+          mask.powerset,
+          TypeMaskArrayProperty._fixedLengthEnumSet,
         ) ||
         mask.containsOnlyString(closedWorld) ||
         isTypedArray(mask).isDefinitelyTrue) {

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

@@ -41,6 +41,10 @@ class RecordTypeMask extends TypeMask {
       TypeMaskInterceptorProperty.notInterceptor,
     );
     powerset = _arrayDomain.add(powerset, TypeMaskArrayProperty.other);
+    powerset = _indexableDomain.add(
+      powerset,
+      TypeMaskIndexableProperty.notIndexable,
+    );
     return createRecordWithPowerset(domain, types, shape, powerset);
   }
 

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

@@ -187,10 +187,32 @@ enum TypeMaskArrayProperty {
   static const modifiableValues = [growable, fixedLength];
   static const unmodifiableValues = [unmodifiable];
 
-  static final _growableMask = _arrayDomain.fromValues(growableValues);
-  static final _fixedLengthMask = _arrayDomain.fromValues(fixedLengthValues);
-  static final _modifiableMask = _arrayDomain.fromValues(modifiableValues);
-  static final _unmodifiableMask = _arrayDomain.fromValues(unmodifiableValues);
+  static final _growableEnumSet = EnumSet.fromValues(growableValues);
+  static final _fixedLengthEnumSet = EnumSet.fromValues(fixedLengthValues);
+  static final _modifiableEnumSet = EnumSet.fromValues(modifiableValues);
+  static final _unmodifiableEnumSet = EnumSet.fromValues(unmodifiableValues);
+}
+
+/// This domain is similar to the [TypeMaskArrayProperty] domain. Since
+/// [JSMutableIndexable] is a subclass of [JSIndexable], every object that is
+/// mutable indexable (i.e. has `operator []=`) is also indexable (i.e. has
+/// `operator []`).
+///
+/// Therefore, the `mutableIndexable` bit corresponds to objects that have both
+/// operations, the `indexable` bit corresponds to objects that *only* have
+/// `operator []`, and the `notIndexable` bit corresponds to objects that have
+/// neither.
+enum TypeMaskIndexableProperty {
+  indexable('I'),
+  mutableIndexable('M'),
+  notIndexable('N');
+
+  final String _mnemonic;
+
+  const TypeMaskIndexableProperty(this._mnemonic);
+
+  @override
+  String toString() => _mnemonic;
 }
 
 // This domain is unique in that it tracks specific values which are not
@@ -224,10 +246,16 @@ final _arrayDomain = EnumSetDomain<TypeMaskArrayProperty>(
   TypeMaskArrayProperty.values,
 );
 
+final _indexableDomain = EnumSetDomain<TypeMaskIndexableProperty>(
+  _arrayDomain.nextOffset,
+  TypeMaskIndexableProperty.values,
+);
+
 final _powersetDomains = ComposedEnumSetDomains([
   _specialValueDomain,
   _interceptorDomain,
   _arrayDomain,
+  _indexableDomain,
 ]);
 
 Bitset _intersectPowersets(Bitset a, Bitset b) {

pkg/compiler/lib/src/util/enumset.dart

@@ -215,6 +215,14 @@ class EnumSetDomain<E extends Enum> {
   bool contains(Bitset bits, E enumValue) =>
       bits.intersects(fromValue(enumValue));
 
+  /// Returns `true` if [enumValue] is in [bits] and no other [E] is.
+  bool containsSingle(Bitset bits, E enumValue) =>
+      toEnumSet(bits) == enumValue.mask;
+
+  /// Returns `true` if the only [E] values in [bits] are in [enumValues].
+  bool containsOnly(Bitset bits, EnumSet<E> enumValues) =>
+      toEnumSet(bits).union(enumValues) == enumValues;
+
   /// Returns `true` if [bits] contains any [E].
   bool isNotEmpty(Bitset bits) => bits.intersects(allValues);