Elements. Keep effective modifiers in ClassElementImpl and MixinElementImpl.

Change-Id: I1ad6558219da1fc700341c18ba682eb12e4d04c7
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/440362
Reviewed-by: Samuel Rawlins <[email protected]>
Commit-Queue: Konstantin Shcheglov <[email protected]>

Author: scheglov

pkg/analyzer/lib/src/dart/analysis/driver.dart

@@ -109,7 +109,7 @@ testFineAfterLibraryAnalyzerHook;
 // TODO(scheglov): Clean up the list of implicitly analyzed files.
 class AnalysisDriver {
   /// The version of data format, should be incremented on every format change.
-  static const int DATA_VERSION = 505;
+  static const int DATA_VERSION = 507;
 
   /// The number of exception contexts allowed to write. Once this field is
   /// zero, we stop writing any new exception contexts in this process.

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

@@ -149,6 +149,13 @@ class ClassElementImpl extends InterfaceElementImpl implements ClassElement {
   ClassElementImpl(this.reference, this._firstFragment) {
     reference.element = this;
     firstFragment.element = this;
+
+    isAbstract = firstFragment.isAbstract;
+    isBase = firstFragment.isBase;
+    isFinal = firstFragment.isFinal;
+    isInterface = firstFragment.isInterface;
+    isMixinClass = firstFragment.isMixinClass;
+    isSealed = firstFragment.isSealed;
   }
 
   /// If we can find all possible subtypes of this class, return them.
@@ -269,11 +276,23 @@ class ClassElementImpl extends InterfaceElementImpl implements ClassElement {
 
   @override
   @trackedIncludedIntoId
-  bool get isAbstract => firstFragment.isAbstract;
+  bool get isAbstract {
+    return hasModifier(Modifier.ABSTRACT);
+  }
+
+  set isAbstract(bool isAbstract) {
+    setModifier(Modifier.ABSTRACT, isAbstract);
+  }
 
   @override
   @trackedIncludedIntoId
-  bool get isBase => firstFragment.isBase;
+  bool get isBase {
+    return hasModifier(Modifier.BASE);
+  }
+
+  set isBase(bool isBase) {
+    setModifier(Modifier.BASE, isBase);
+  }
 
   @override
   @trackedIncludedIntoId
@@ -335,23 +354,47 @@ class ClassElementImpl extends InterfaceElementImpl implements ClassElement {
 
   @override
   @trackedIncludedIntoId
-  bool get isFinal => firstFragment.isFinal;
+  bool get isFinal {
+    return hasModifier(Modifier.FINAL);
+  }
+
+  set isFinal(bool isFinal) {
+    setModifier(Modifier.FINAL, isFinal);
+  }
 
   @override
   @trackedIncludedIntoId
-  bool get isInterface => firstFragment.isInterface;
+  bool get isInterface {
+    return hasModifier(Modifier.INTERFACE);
+  }
+
+  set isInterface(bool isInterface) {
+    setModifier(Modifier.INTERFACE, isInterface);
+  }
 
   @override
   @trackedIncludedIntoId
   bool get isMixinApplication => firstFragment.isMixinApplication;
 
   @override
   @trackedIncludedIntoId
-  bool get isMixinClass => firstFragment.isMixinClass;
+  bool get isMixinClass {
+    return hasModifier(Modifier.MIXIN_CLASS);
+  }
+
+  set isMixinClass(bool isMixinClass) {
+    setModifier(Modifier.MIXIN_CLASS, isMixinClass);
+  }
 
   @override
   @trackedIncludedIntoId
-  bool get isSealed => firstFragment.isSealed;
+  bool get isSealed {
+    return hasModifier(Modifier.SEALED);
+  }
+
+  set isSealed(bool isSealed) {
+    setModifier(Modifier.SEALED, isSealed);
+  }
 
   @override
   @trackedIncludedIntoId
@@ -1899,6 +1942,10 @@ abstract class ElementImpl implements Element {
     return isAccessibleIn(library);
   }
 
+  void readModifiers(SummaryDataReader reader) {
+    _modifiers = EnumSet(reader.readInt64());
+  }
+
   /// Update [modifier] of this element to [value].
   void setModifier(Modifier modifier, bool value) {
     _modifiers = _modifiers.updated(modifier, value);
@@ -1957,6 +2004,10 @@ abstract class ElementImpl implements Element {
   void visitChildren2<T>(ElementVisitor2<T> visitor) {
     visitChildren(visitor);
   }
+
+  void writeModifiers(BufferedSink writer) {
+    _modifiers.write(writer);
+  }
 }
 
 class EnumElementImpl extends InterfaceElementImpl implements EnumElement {
@@ -3820,7 +3871,7 @@ class GenericFunctionTypeElementImpl extends FunctionTypedElementImpl
 
   @override
   List<FormalParameterElement> get formalParameters =>
-        _wrappedElement.formalParameters
+      _wrappedElement.formalParameters
           .map((fragment) => fragment.element)
           .toList();
 
@@ -7671,6 +7722,8 @@ class MixinElementImpl extends InterfaceElementImpl implements MixinElement {
   MixinElementImpl(this.reference, this.firstFragment) {
     reference.element = this;
     firstFragment.element = this;
+
+    isBase = firstFragment.isBase;
   }
 
   @override
@@ -7686,7 +7739,13 @@ class MixinElementImpl extends InterfaceElementImpl implements MixinElement {
   }
 
   @override
-  bool get isBase => firstFragment.isBase;
+  bool get isBase {
+    return hasModifier(Modifier.BASE);
+  }
+
+  set isBase(bool isBase) {
+    setModifier(Modifier.BASE, isBase);
+  }
 
   @override
   ElementKind get kind => ElementKind.MIXIN;

pkg/analyzer/lib/src/summary2/bundle_reader.dart

@@ -266,6 +266,7 @@ class LibraryReader {
       var fragments = _readFragmentsById<ClassFragmentImpl>();
       // TODO(scheglov): link fragments.
       var element = ClassElementImpl(reference, fragments.first);
+      element.readModifiers(_reader);
 
       // Configure for reading members lazily.
       _lazyRead((offset) {
@@ -974,6 +975,7 @@ class LibraryReader {
       var fragments = _readFragmentsById<MixinFragmentImpl>();
       // TODO(scheglov): link fragments.
       var element = MixinElementImpl(reference, fragments.first);
+      element.readModifiers(_reader);
 
       // TODO(scheglov): consider reading lazily
       for (var fragment in element.fragments) {

pkg/analyzer/lib/src/summary2/bundle_writer.dart

@@ -151,6 +151,7 @@ class BundleWriter {
       _sink.writeList(element.fragments, (fragment) {
         _writeFragmentId(fragment);
       });
+      element.writeModifiers(_sink);
 
       // We read members lazily.
       _writeForLazyRead(() {
@@ -571,6 +572,7 @@ class BundleWriter {
       _sink.writeList(element.fragments, (fragment) {
         _writeFragmentId(fragment);
       });
+      element.writeModifiers(_sink);
 
       // TODO(scheglov): consider reading lazily
       _resolutionSink.withTypeParameters(element.typeParameters, () {

pkg/analyzer/lib/src/summary2/instance_member_inferrer.dart

@@ -660,75 +660,71 @@ class InstanceMemberInferrer {
     var interfaces = classElement.interfaces;
     var mixins = classElement.mixins;
 
-    if (mixins.any((type) => type.elementImpl.isFinal)) {
+    if (mixins.any((type) => type.element.isFinal)) {
       // A sealed declaration is considered 'final' if it has a direct
       // superclass which is 'final'.
-      classElement.isFinal = true;
+      classElement.element.isFinal = true;
       return;
     }
 
     if (supertype != null) {
-      if (supertype.elementImpl.isFinal) {
+      if (supertype.element.isFinal) {
         // A sealed declaration is considered 'final' if it has a direct
         // superclass which is 'final'.
-        classElement.isFinal = true;
+        classElement.element.isFinal = true;
         return;
       }
-      if (supertype.elementImpl.isBase) {
+      if (supertype.element.isBase) {
         // A sealed declaration is considered 'final' if it has a
         // direct superclass which is 'interface' and it has a direct
         // superinterface which is 'base'.
-        if (mixins.any((type) => type.elementImpl.isInterface)) {
-          classElement.isFinal = true;
+        if (mixins.any((type) => type.element.isInterface)) {
+          classElement.element.isFinal = true;
           return;
         }
 
         // Otherwise, a sealed declaration is considered 'base' if it has a
         // direct superinterface which is 'base' or 'final'.
-        classElement.isBase = true;
+        classElement.element.isBase = true;
         return;
       }
-      if (supertype.elementImpl.isInterface) {
+      if (supertype.element.isInterface) {
         // A sealed declaration is considered 'final' if it has a
         // direct superclass which is 'interface' and it has a direct
         // superinterface which is 'base'.
-        if (interfaces.any((type) => type.elementImpl.isBase) ||
-            mixins.any((type) => type.elementImpl.isBase)) {
-          classElement.isFinal = true;
+        if (interfaces.any((type) => type.element.isBase) ||
+            mixins.any((type) => type.element.isBase)) {
+          classElement.element.isFinal = true;
           return;
         }
 
         // Otherwise, a sealed declaration is considered 'interface' if it has a
         // direct superclass which is 'interface'
-        classElement.isInterface = true;
+        classElement.element.isInterface = true;
         return;
       }
     }
 
-    if (interfaces.any(
-          (type) => type.elementImpl.isBase || type.elementImpl.isFinal,
-        ) ||
-        mixins.any(
-          (type) => type.elementImpl.isBase || type.elementImpl.isFinal,
-        )) {
+    if (interfaces.any((type) => type.element.isBase || type.element.isFinal) ||
+        mixins.any((type) => type.element.isBase || type.element.isFinal)) {
       // A sealed declaration is considered 'base' if it has a direct
       // superinterface which is 'base' or 'final'.
-      classElement.isBase = true;
+      classElement.element.isBase = true;
       return;
     }
 
-    if (mixins.any((type) => type.elementImpl.isInterface)) {
+    if (mixins.any((type) => type.element.isInterface)) {
       // A sealed declaration is considered 'final' if it has a
       // direct superclass which is 'interface' and it has a direct
       // superinterface which is 'base'.
-      if (interfaces.any((type) => type.elementImpl.isBase)) {
-        classElement.isFinal = true;
+      if (interfaces.any((type) => type.element.isBase)) {
+        classElement.element.isFinal = true;
         return;
       }
 
       // Otherwise, a sealed declaration is considered 'interface' if it has a
       // direct superclass which is 'interface'
-      classElement.isInterface = true;
+      classElement.element.isInterface = true;
       return;
     }
   }
@@ -789,12 +785,12 @@ class InstanceMemberInferrer {
 /// A class of exception that is not used anywhere else.
 class _CycleException implements Exception {}
 
-extension on InterfaceFragmentImpl {
+extension on InterfaceElementImpl {
   bool get isBase {
     switch (this) {
-      case ClassFragmentImpl self:
+      case ClassElementImpl self:
         return self.isBase;
-      case MixinFragmentImpl self:
+      case MixinElementImpl self:
         return self.isBase;
       default:
         return false;
@@ -803,7 +799,7 @@ extension on InterfaceFragmentImpl {
 
   bool get isFinal {
     switch (this) {
-      case ClassFragmentImpl self:
+      case ClassElementImpl self:
         return self.isFinal;
       default:
         return false;
@@ -812,7 +808,7 @@ extension on InterfaceFragmentImpl {
 
   bool get isInterface {
     switch (this) {
-      case ClassFragmentImpl self:
+      case ClassElementImpl self:
         return self.isInterface;
       default:
         return false;