Elements. Migrate InstanceMemberInferrer to use elements.

Change-Id: I596abe285a05fec4f201b95ee0e3315c9d01b34a
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/440260
Commit-Queue: Konstantin Shcheglov <[email protected]>
Reviewed-by: Samuel Rawlins <[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 = 507;
+  static const int DATA_VERSION = 508;
 
   /// 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

@@ -2973,6 +2973,11 @@ class FormalParameterElementImpl extends PromotableElementImpl
   @override
   late TypeImpl type;
 
+  /// Whether this formal parameter inherits from a covariant formal parameter.
+  /// This happens when it overrides a method in a supertype that has a
+  /// corresponding covariant formal parameter.
+  bool inheritsCovariant = false;
+
   FormalParameterElementImpl(this.wrappedElement) {
     FormalParameterFragmentImpl? fragment = wrappedElement;
     while (fragment != null) {
@@ -3033,8 +3038,12 @@ class FormalParameterElementImpl extends PromotableElementImpl
   bool get isConst => wrappedElement.isConst;
 
   @override
-  // TODO(augmentations): Implement the merge of formal parameters.
-  bool get isCovariant => wrappedElement.isCovariant;
+  bool get isCovariant {
+    if (firstFragment.isExplicitlyCovariant || inheritsCovariant) {
+      return true;
+    }
+    return false;
+  }
 
   @override
   // TODO(augmentations): Implement the merge of formal parameters.
@@ -3210,11 +3219,6 @@ class FormalParameterFragmentImpl extends VariableFragmentImpl
   /// Prefer using `isXyz` instead, e.g. [isRequiredNamed].
   final ParameterKind parameterKind;
 
-  /// True if this parameter inherits from a covariant parameter. This happens
-  /// when it overrides a method in a supertype that has a corresponding
-  /// covariant parameter.
-  bool inheritsCovariant = false;
-
   /// The element corresponding to this fragment.
   FormalParameterElementImpl? _element;
 
@@ -3277,15 +3281,6 @@ class FormalParameterFragmentImpl extends VariableFragmentImpl
   @override
   Fragment? get enclosingFragment => enclosingElement as Fragment?;
 
-  /// Whether the parameter is covariant, meaning it is allowed to have a
-  /// narrower type in an override.
-  bool get isCovariant {
-    if (isExplicitlyCovariant || inheritsCovariant) {
-      return true;
-    }
-    return false;
-  }
-
   /// Return true if this parameter is explicitly marked as being covariant.
   bool get isExplicitlyCovariant {
     return hasModifier(Modifier.COVARIANT);
@@ -4829,6 +4824,10 @@ abstract class InterfaceElementImpl extends InstanceElementImpl
 
   List<ConstructorElementImpl> _constructors = _Sentinel.constructorElement;
 
+  /// A flag indicating whether the types associated with the instance members
+  /// of this class have been inferred.
+  bool hasBeenInferred = false;
+
   @override
   List<InterfaceTypeImpl> get allSupertypes {
     return _allSupertypes ??= library.session.classHierarchy
@@ -5185,10 +5184,6 @@ abstract class InterfaceFragmentImpl extends InstanceFragmentImpl
 
   InterfaceTypeImpl? _supertype;
 
-  /// A flag indicating whether the types associated with the instance members
-  /// of this class have been inferred.
-  bool hasBeenInferred = false;
-
   List<ConstructorFragmentImpl> _constructors = _Sentinel.constructorFragment;
 
   /// Initialize a newly created class element to have the given [name] at the
@@ -7553,6 +7548,15 @@ class MethodElementImpl extends ExecutableElementImpl
   @override
   final MethodFragmentImpl firstFragment;
 
+  /// Is `true` if this method is `operator==`, and there is no explicit
+  /// type specified for its formal parameter, in this method or in any
+  /// overridden methods other than the one declared in `Object`.
+  bool isOperatorEqualWithParameterTypeFromObject = false;
+
+  /// The error reported during type inference for this variable, or `null` if
+  /// this variable is not a subject of type inference, or there was no error.
+  TopLevelInferenceError? typeInferenceError;
+
   MethodElementImpl({
     required this.name,
     required this.reference,
@@ -7645,15 +7649,6 @@ class MethodFragmentImpl extends ExecutableFragmentImpl
   @override
   MethodFragmentImpl? nextFragment;
 
-  /// Is `true` if this method is `operator==`, and there is no explicit
-  /// type specified for its formal parameter, in this method or in any
-  /// overridden methods other than the one declared in `Object`.
-  bool isOperatorEqualWithParameterTypeFromObject = false;
-
-  /// The error reported during type inference for this variable, or `null` if
-  /// this variable is not a subject of type inference, or there was no error.
-  TopLevelInferenceError? typeInferenceError;
-
   /// Initialize a newly created method element to have the given [name] at the
   /// given [offset].
   MethodFragmentImpl({required this.name, required super.firstTokenOffset});

pkg/analyzer/lib/src/error/inheritance_override.dart

@@ -937,7 +937,7 @@ class _ClassVerifier {
   bool _reportNoCombinedSuperSignature(MethodDeclarationImpl node) {
     var fragment = node.declaredFragment;
     if (fragment is MethodFragmentImpl) {
-      var inferenceError = fragment.typeInferenceError;
+      var inferenceError = fragment.element.typeInferenceError;
       if (inferenceError?.kind ==
           TopLevelInferenceErrorKind.overrideNoCombinedSuperSignature) {
         reporter.atToken(

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

@@ -1217,7 +1217,6 @@ class AstBinaryReader {
           AstBinaryFlags.isRequired(flags) ? Tokens.required_() : null,
     );
     var actualType = _reader.readRequiredType();
-    _reader.readByte(); // TODO(scheglov): inherits covariant
 
     var fragment = FormalParameterFragmentImpl(
       firstTokenOffset: null,

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

@@ -751,9 +751,6 @@ class AstBinaryWriter extends ThrowingAstVisitor<void> {
 
     _writeOptionalNode(node.type);
     _storeNormalFormalParameter(node, node.keyword);
-
-    var element = node.declaredFragment!;
-    _sink.writeByte(element.inheritsCovariant ? 1 : 0);
   }
 
   @override

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

@@ -746,6 +746,7 @@ class LibraryReader {
       parameter.metadata = reader._readMetadata(unitElement: unitElement);
       _readTypeParameters2(unitElement, reader, parameter.typeParameters);
       _readFormalParameters2(unitElement, reader, parameter.parameters);
+      parameter.element.inheritsCovariant = reader.readBool();
       var type = reader.readType() ?? InvalidTypeImpl.instance;
       parameter.element.type = type;
       parameter.constantInitializer = reader.readOptionalExpression();
@@ -916,6 +917,7 @@ class LibraryReader {
         reference: reference,
         firstFragment: fragments.first,
       );
+      element.typeInferenceError = _readTopLevelInferenceError();
 
       // TODO(scheglov): type parameters
       // TODO(scheglov): formal parameters
@@ -943,7 +945,6 @@ class LibraryReader {
           var fragment = MethodFragmentImpl(name: name, firstTokenOffset: null);
 
           fragment.readModifiers(_reader);
-          fragment.typeInferenceError = _readTopLevelInferenceError();
           fragment.typeParameters = _readTypeParameters();
           fragment.parameters = _readParameters();
           return fragment;

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

@@ -545,6 +545,7 @@ class BundleWriter {
     _sink.writeList(elements, (element) {
       _writeReference(element.reference);
       _sink.writeList(element.fragments, _writeFragmentId);
+      _sink._writeTopLevelInferenceError(element.typeInferenceError);
 
       _writeElementResolution(() {
         // TODO(scheglov): avoid cast
@@ -558,7 +559,6 @@ class BundleWriter {
 
   void _writeMethodFragment(MethodFragmentImpl fragment) {
     _writeTemplateFragment(fragment, () {
-      _sink._writeTopLevelInferenceError(fragment.typeInferenceError);
       _writeTypeParameters(fragment.typeParameters, () {
         _sink.writeList(fragment.formalParameters, _writeParameterElement);
         _resolutionSink._writeMetadata(fragment.metadata);
@@ -643,6 +643,7 @@ class BundleWriter {
 
     _writeTypeParameters(element.typeParameters, () {
       _writeList(element.parameters, _writeParameterElement);
+      _resolutionSink.writeBool(element.element.inheritsCovariant);
       _resolutionSink.writeType(element.element.type);
       _resolutionSink._writeOptionalNode(element.constantInitializer);
 

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

@@ -332,25 +332,22 @@ class MixinElementFlags {
 
 class ParameterElementFlags {
   static const int _hasImplicitType = 1 << 0;
-  static const int _inheritsCovariant = 1 << 1;
-  static const int _isExplicitlyCovariant = 1 << 2;
-  static const int _isFinal = 1 << 3;
+  static const int _isExplicitlyCovariant = 1 << 1;
+  static const int _isFinal = 1 << 2;
 
   static void read(
     SummaryDataReader reader,
     FormalParameterFragmentImpl element,
   ) {
     var byte = reader.readByte();
     element.hasImplicitType = (byte & _hasImplicitType) != 0;
-    element.inheritsCovariant = (byte & _inheritsCovariant) != 0;
     element.isExplicitlyCovariant = (byte & _isExplicitlyCovariant) != 0;
     element.isFinal = (byte & _isFinal) != 0;
   }
 
   static void write(BufferedSink sink, FormalParameterFragmentImpl element) {
     var result = 0;
     result |= element.hasImplicitType ? _hasImplicitType : 0;
-    result |= element.inheritsCovariant ? _inheritsCovariant : 0;
     result |= element.isExplicitlyCovariant ? _isExplicitlyCovariant : 0;
     result |= element.isFinal ? _isFinal : 0;
     sink.writeByte(result);