Elements. Fix for updating field/getter type when inferred setter value type.

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

Author: scheglov

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

@@ -216,17 +216,21 @@ class InstanceMemberInferrer {
         return;
       }
 
+      void setSetterValueType(TypeImpl valueType) {
+        valueFormalParameter.type = valueType;
+        var field = setter.variable as FieldElementImpl;
+        if (field.getter == null) {
+          field.type = valueType;
+        }
+      }
+
       // The return type of a getter, parameter type of a setter or type of a
       // field which overrides/implements only one or more getters is inferred
       // to be the return type of the combined member signature of said getter
       // in the direct superinterfaces.
       if (overriddenGetters.isNotEmpty && overriddenSetters.isEmpty) {
         var valueType = combinedGetterType();
-        valueFormalParameter.type = valueType;
-        var fieldElement = setter.variable as FieldElementImpl;
-        if (fieldElement.getter == null) {
-          fieldElement.type = valueType;
-        }
+        setSetterValueType(valueType);
         return;
       }
 
@@ -240,9 +244,7 @@ class InstanceMemberInferrer {
       // combined member signature of said setter in the direct superinterfaces.
       if (overriddenSetters.isNotEmpty) {
         var valueType = combinedSetterType();
-        valueFormalParameter.type = valueType;
-        var fieldElement = setter.variable as FieldElementImpl;
-        fieldElement.type = valueType;
+        setSetterValueType(valueType);
         return;
       }
 

pkg/analyzer/test/src/summary/top_level_inference_test.dart

@@ -8506,6 +8506,123 @@ library
 ''');
   }
 
+  test_instanceField_fromField_finalFieldTyped_setterNotTyped() async {
+    var library = await _encodeDecodeLibrary(r'''
+abstract class A {
+  int? foo;
+}
+class B implements A {
+  final int foo;
+  set foo(_) {}
+}
+''');
+    checkElementText(library, r'''
+library
+  reference: <testLibrary>
+  fragments
+    #F0 <testLibraryFragment>
+      element: <testLibrary>
+      classes
+        #F1 class A (nameOffset:15) (firstTokenOffset:0) (offset:15)
+          element: <testLibrary>::@class::A
+          fields
+            #F2 foo (nameOffset:26) (firstTokenOffset:26) (offset:26)
+              element: <testLibrary>::@class::A::@field::foo
+          constructors
+            #F3 synthetic new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:15)
+              element: <testLibrary>::@class::A::@constructor::new
+              typeName: A
+          getters
+            #F4 synthetic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:26)
+              element: <testLibrary>::@class::A::@getter::foo
+          setters
+            #F5 synthetic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:26)
+              element: <testLibrary>::@class::A::@setter::foo
+              formalParameters
+                #F6 value (nameOffset:<null>) (firstTokenOffset:<null>) (offset:26)
+                  element: <testLibrary>::@class::A::@setter::foo::@formalParameter::value
+        #F7 class B (nameOffset:39) (firstTokenOffset:33) (offset:39)
+          element: <testLibrary>::@class::B
+          fields
+            #F8 foo (nameOffset:68) (firstTokenOffset:68) (offset:68)
+              element: <testLibrary>::@class::B::@field::foo
+          constructors
+            #F9 synthetic new (nameOffset:<null>) (firstTokenOffset:<null>) (offset:39)
+              element: <testLibrary>::@class::B::@constructor::new
+              typeName: B
+          getters
+            #F10 synthetic foo (nameOffset:<null>) (firstTokenOffset:<null>) (offset:68)
+              element: <testLibrary>::@class::B::@getter::foo
+          setters
+            #F11 foo (nameOffset:79) (firstTokenOffset:75) (offset:79)
+              element: <testLibrary>::@class::B::@setter::foo
+              formalParameters
+                #F12 _ (nameOffset:83) (firstTokenOffset:83) (offset:83)
+                  element: <testLibrary>::@class::B::@setter::foo::@formalParameter::_
+  classes
+    abstract class A
+      reference: <testLibrary>::@class::A
+      firstFragment: #F1
+      fields
+        foo
+          reference: <testLibrary>::@class::A::@field::foo
+          firstFragment: #F2
+          type: int?
+          getter: <testLibrary>::@class::A::@getter::foo
+          setter: <testLibrary>::@class::A::@setter::foo
+      constructors
+        synthetic new
+          reference: <testLibrary>::@class::A::@constructor::new
+          firstFragment: #F3
+      getters
+        synthetic foo
+          reference: <testLibrary>::@class::A::@getter::foo
+          firstFragment: #F4
+          returnType: int?
+          variable: <testLibrary>::@class::A::@field::foo
+      setters
+        synthetic foo
+          reference: <testLibrary>::@class::A::@setter::foo
+          firstFragment: #F5
+          formalParameters
+            #E0 requiredPositional value
+              firstFragment: #F6
+              type: int?
+          returnType: void
+    class B
+      reference: <testLibrary>::@class::B
+      firstFragment: #F7
+      interfaces
+        A
+      fields
+        final foo
+          reference: <testLibrary>::@class::B::@field::foo
+          firstFragment: #F8
+          type: int
+          getter: <testLibrary>::@class::B::@getter::foo
+          setter: <testLibrary>::@class::B::@setter::foo
+      constructors
+        synthetic new
+          reference: <testLibrary>::@class::B::@constructor::new
+          firstFragment: #F9
+      getters
+        synthetic foo
+          reference: <testLibrary>::@class::B::@getter::foo
+          firstFragment: #F10
+          returnType: int
+          variable: <testLibrary>::@class::B::@field::foo
+      setters
+        foo
+          reference: <testLibrary>::@class::B::@setter::foo
+          firstFragment: #F11
+          formalParameters
+            #E1 requiredPositional hasImplicitType _
+              firstFragment: #F12
+              type: int?
+          returnType: void
+''');
+  }
+
   test_instanceField_fromField_generic() async {
     var library = await _encodeDecodeLibrary(r'''
 abstract class A<E> {