Use EnumSet instead of BooleanArray for element modifiers.

Change-Id: I5db1104cc13cc61c39e4b4565c3bc3942848c7f3
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/354281
Reviewed-by: Phil Quitslund <[email protected]>
Reviewed-by: Brian Wilkerson <[email protected]>
Commit-Queue: Konstantin Shcheglov <[email protected]>

Author: scheglov

pkg/analyzer/lib/src/dart/element/element.dart

@@ -1909,8 +1909,8 @@ abstract class ElementImpl implements Element {
   /// declaration of this element.
   int _nameOffset = 0;
 
-  /// A bit-encoded form of the modifiers associated with this element.
-  int _modifiers = 0;
+  /// The modifiers associated with this element.
+  EnumSet<Modifier> _modifiers = EnumSet.empty();
 
   /// A list containing all of the metadata associated with this element.
   List<ElementAnnotationImpl> _metadata = const [];
@@ -2444,8 +2444,7 @@ abstract class ElementImpl implements Element {
   }
 
   /// Return `true` if this element has the given [modifier] associated with it.
-  bool hasModifier(Modifier modifier) =>
-      BooleanArray.get(_modifiers, modifier.index);
+  bool hasModifier(Modifier modifier) => _modifiers[modifier];
 
   @override
   bool isAccessibleIn(LibraryElement library) {
@@ -2468,7 +2467,7 @@ abstract class ElementImpl implements Element {
   /// Set whether the given [modifier] is associated with this element to
   /// correspond to the given [value].
   void setModifier(Modifier modifier, bool value) {
-    _modifiers = BooleanArray.set(_modifiers, modifier.index, value);
+    _modifiers = _modifiers.updated(modifier, value);
   }
 
   @override

pkg/analyzer/lib/src/generated/utilities_collection.dart

@@ -23,28 +23,33 @@ bool listsEqual(List a, List b) {
   return true;
 }
 
-/// Methods for operating on integers as if they were arrays of booleans. These
-/// arrays can be indexed by either integers or by enumeration constants.
-class BooleanArray {
-  /// Return the value of the element of the given [array] at the given [index].
-  static bool get(int array, int index) {
+/// The set of [Enum] values, backed by [int].
+extension type EnumSet<T extends Enum>(int _bits) {
+  EnumSet.empty() : this(0);
+
+  /// Whether [constant] is present.
+  bool operator [](T constant) {
+    var index = constant.index;
     _checkIndex(index);
-    return (array & (1 << index)) > 0;
+
+    var mask = 1 << index;
+    return (_bits & mask) != 0;
   }
 
-  /// Set the value of the element of the given [array] at the given [index] to
-  /// the given [value].
-  static int set(int array, int index, bool value) {
+  /// Returns a new set, with presence of [constant] updated.
+  EnumSet<T> updated(T constant, bool value) {
+    var index = constant.index;
     _checkIndex(index);
+
+    var mask = 1 << index;
     if (value) {
-      return array | (1 << index);
+      return EnumSet<T>(_bits | mask);
     } else {
-      return array & ~(1 << index);
+      return EnumSet<T>(_bits & ~mask);
     }
   }
 
-  /// Throw an exception if the index is not within the bounds allowed for an
-  /// integer-encoded array of boolean values.
+  /// Throws an exception if the [index] does not fit [int].
   static void _checkIndex(int index) {
     if (index < 0 || index > 60) {
       throw RangeError("Index not between 0 and 60: $index");

pkg/analyzer/test/generated/utilities_test.dart

@@ -16,70 +16,47 @@ import '../util/feature_sets.dart';
 
 main() {
   defineReflectiveSuite(() {
-    defineReflectiveTests(BooleanArrayTest);
+    defineReflectiveTests(EnumSetTest);
     defineReflectiveTests(LineInfoTest);
     defineReflectiveTests(NodeReplacerTest);
     defineReflectiveTests(SourceRangeTest);
   });
 }
 
 @reflectiveTest
-class BooleanArrayTest {
-  void test_get_negative() {
-    try {
-      BooleanArray.get(0, -1);
-      fail("Expected ");
-    } on RangeError {
-      // Expected
-    }
-  }
+class EnumSetTest {
+  void test_it() {
+    var enumSet = EnumSet<_MyEnum>.empty();
 
-  void test_get_tooBig() {
-    try {
-      BooleanArray.get(0, 61);
-      fail("Expected ");
-    } on RangeError {
-      // Expected
-    }
-  }
+    // Can set `foo`.
+    enumSet = enumSet.updated(_MyEnum.foo, true);
+    expect(enumSet[_MyEnum.foo], true);
+    expect(enumSet[_MyEnum.bar], false);
 
-  void test_get_valid() {
-    expect(BooleanArray.get(0, 0), false);
-    expect(BooleanArray.get(1, 0), true);
-    expect(BooleanArray.get(0, 30), false);
-    expect(BooleanArray.get(1 << 30, 30), true);
-  }
+    // Can set `bar`.
+    enumSet = enumSet.updated(_MyEnum.bar, true);
+    expect(enumSet[_MyEnum.foo], true);
+    expect(enumSet[_MyEnum.bar], true);
 
-  void test_set_negative() {
-    try {
-      BooleanArray.set(0, -1, true);
-      fail("Expected ");
-    } on RangeError {
-      // Expected
-    }
-  }
+    // Can set `foo` again.
+    enumSet = enumSet.updated(_MyEnum.foo, true);
+    expect(enumSet[_MyEnum.foo], true);
+    expect(enumSet[_MyEnum.bar], true);
 
-  void test_set_tooBig() {
-    try {
-      BooleanArray.set(0, 61, true);
-      fail("Expected ");
-    } on RangeError {
-      // Expected
-    }
-  }
+    // Can clear `foo`.
+    enumSet = enumSet.updated(_MyEnum.foo, false);
+    expect(enumSet[_MyEnum.foo], false);
+    expect(enumSet[_MyEnum.bar], true);
 
-  void test_set_valueChanging() {
-    expect(BooleanArray.set(0, 0, true), 1);
-    expect(BooleanArray.set(1, 0, false), 0);
-    expect(BooleanArray.set(0, 30, true), 1 << 30);
-    expect(BooleanArray.set(1 << 30, 30, false), 0);
-  }
+    // Can clear `foo` again.
+    enumSet = enumSet.updated(_MyEnum.foo, false);
+    expect(enumSet[_MyEnum.foo], false);
+    expect(enumSet[_MyEnum.bar], true);
 
-  void test_set_valuePreserving() {
-    expect(BooleanArray.set(0, 0, false), 0);
-    expect(BooleanArray.set(1, 0, true), 1);
-    expect(BooleanArray.set(0, 30, false), 0);
-    expect(BooleanArray.set(1 << 30, 30, true), 1 << 30);
+    // Can clear `bar`.
+    enumSet = enumSet.updated(_MyEnum.bar, false);
+    expect(enumSet[_MyEnum.foo], false);
+    expect(enumSet[_MyEnum.bar], false);
   }
 }
 
@@ -2193,3 +2170,5 @@ class SourceRangeTest {
     expect(r.toString(), "[offset=10, length=1]");
   }
 }
+
+enum _MyEnum { foo, bar }