Implement type inference of getters/setters based on inheritance.

pkg/front_end/lib/src/fasta/kernel/kernel_shadow_ast.dart

 // Copyright (c) 2017, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /// This file declares a "shadow hierarchy" of concrete classes which extend
 /// the kernel class hierarchy, adding methods and fields needed by the
 /// BodyBuilder.
 ///
 /// Instances of these classes may be created using the factory methods in
 /// `ast_factory.dart`.
@@ skipping 642 matching lines @@
         fileOffset,
         _initialTarget.function.functionType,
         computeConstructorReturnType(_initialTarget),
         arguments);
     inferrer.listener.constructorInvocationExit(this, inferredType);
     return inferredType;
   }
 }
 
 /// Concrete shadow object representing a field in kernel form.
-class KernelField extends Field {
+class KernelField extends Field implements KernelMember {
+  @override
   FieldNode _fieldNode;
 
+  @override
   KernelTypeInferrer _typeInferrer;
 
   KernelField(Name name, {String fileUri}) : super(name, fileUri: fileUri) {}
 
-  static FieldNode getFieldNode(Field field) {
-    if (field is KernelField) return field._fieldNode;
-    return null;
-  }
-
-  static void recordOverride(
-      KernelField field, Member overriddenMember, bool isSetter) {
-    if (field._fieldNode != null) {
-      if (isSetter && overriddenMember is Field) {
-        // When overriding a field, we are called twice; once for the setter and
-        // once for the getter.  Ignore the setter.
-        return;
-      }
-      field._fieldNode.overrides.add(overriddenMember);
-    }
+  @override
+  void setInferredType(
+      TypeInferenceEngineImpl engine, String uri, DartType inferredType) {
+    engine.instrumentation?.record(Uri.parse(uri), fileOffset, 'topType',
+        new InstrumentationValueForType(inferredType));
+    type = inferredType;
   }
 }
 
 /// Concrete shadow object representing a for-in loop in kernel form.
 class KernelForInStatement extends ForInStatement implements KernelStatement {
   final bool _declaresVariable;
 
   KernelForInStatement(VariableDeclaration variable, Expression iterable,
       Statement body, this._declaresVariable,
       {bool isAsync: false})
@@ skipping 563 matching lines @@
       valueType = inferredValueType;
     }
     var inferredType = typeNeeded
         ? new InterfaceType(mapClass, [inferredKeyType, inferredValueType])
         : null;
     inferrer.listener.mapLiteralExit(this, inferredType);
     return inferredType;
   }
 }
 
+/// Abstract shadow object representing a field or procedure in kernel form.
+abstract class KernelMember implements Member {
+  String get fileUri;
+
+  FieldNode get _fieldNode;
+
+  void set _fieldNode(FieldNode value);
+
+  KernelTypeInferrer get _typeInferrer;
+
+  void set _typeInferrer(KernelTypeInferrer value);
+
+  void setInferredType(
+      TypeInferenceEngineImpl engine, String uri, DartType inferredType);
+
+  static FieldNode getFieldNode(Member member) {
+    if (member is KernelMember) return member._fieldNode;
+    return null;
+  }
+
+  static void recordOverride(KernelMember member, Member overriddenMember) {
+    if (member._fieldNode != null) {
+      member._fieldNode.overrides.add(overriddenMember);
+    }
+  }
+}
+
 /// Shadow object for [MethodInvocation].
 class KernelMethodInvocation extends MethodInvocation
     implements KernelExpression {
   /// Indicates whether this method invocation is a call to a `call` method
   /// resulting from the invocation of a function expression.
   final bool _isImplicitCall;
 
   KernelMethodInvocation(Expression receiver, Name name, Arguments arguments,
       {bool isImplicitCall: false, Member interfaceTarget})
       : _isImplicitCall = isImplicitCall,
@@ skipping 81 matching lines @@
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     typeNeeded =
         inferrer.listener.nullLiteralEnter(this, typeContext) || typeNeeded;
     var inferredType = typeNeeded ? inferrer.coreTypes.nullClass.rawType : null;
     inferrer.listener.nullLiteralExit(this, inferredType);
     return inferredType;
   }
 }
 
+/// Concrete shadow object representing a procedure in kernel form.
+class KernelProcedure extends Procedure implements KernelMember {
+  @override
+  FieldNode _fieldNode;
+
+  @override
+  KernelTypeInferrer _typeInferrer;
+
+  KernelProcedure(Name name, ProcedureKind kind, FunctionNode function,
+      {String fileUri})
+      : super(name, kind, function, fileUri: fileUri);
+
+  @override
+  void setInferredType(
+      TypeInferenceEngineImpl engine, String uri, DartType inferredType) {
+    if (isSetter) {
+      if (function.positionalParameters.length > 0) {
+        var parameter = function.positionalParameters[0];
+        engine.instrumentation?.record(Uri.parse(uri), parameter.fileOffset,
+            'topType', new InstrumentationValueForType(inferredType));
+        parameter.type = inferredType;
+      }
+    } else if (isGetter) {
+      engine.instrumentation?.record(Uri.parse(uri), fileOffset, 'topType',
+          new InstrumentationValueForType(inferredType));
+      function.returnType = inferredType;
+    } else {
+      internalError(
+          'setInferredType called on a procedure that is not an accessor');
+    }
+  }
+}
+
 /// Concrete shadow object representing an assignment to a property.
 class KernelPropertyAssign extends KernelComplexAssignmentWithReceiver {
   /// If this assignment uses null-aware access (`?.`), the conditional
   /// expression that guards the access; otherwise `null`.
   Expression nullAwareGuard;
 
   KernelPropertyAssign(Expression receiver, Expression rhs,
       {bool isSuper: false})
       : super(receiver, rhs, isSuper);
 
@@ skipping 427 matching lines @@
   }
 }
 
 /// Concrete implementation of [TypeInferenceEngine] specialized to work with
 /// kernel objects.
 class KernelTypeInferenceEngine extends TypeInferenceEngineImpl {
   KernelTypeInferenceEngine(Instrumentation instrumentation, bool strongMode)
       : super(instrumentation, strongMode);
 
   @override
-  void clearFieldInitializer(KernelField field) {
-    field.initializer = null;
-  }
-
-  @override
-  FieldNode createFieldNode(KernelField field) {
-    FieldNode fieldNode = new FieldNode(this, field);
-    field._fieldNode = fieldNode;
+  FieldNode createFieldNode(KernelMember member) {
+    FieldNode fieldNode = new FieldNode(this, member);
+    member._fieldNode = fieldNode;
     return fieldNode;
   }
 
   @override
   KernelTypeInferrer createLocalTypeInferrer(
       Uri uri, TypeInferenceListener listener, InterfaceType thisType) {
     return new KernelTypeInferrer._(
         this, uri.toString(), listener, false, thisType, null);
   }
 
   @override
   KernelTypeInferrer createTopLevelTypeInferrer(TypeInferenceListener listener,
-      InterfaceType thisType, KernelField field) {
-    return field._typeInferrer = new KernelTypeInferrer._(
-        this, field.fileUri, listener, true, thisType, field._fieldNode);
+      InterfaceType thisType, KernelMember member) {
+    return member._typeInferrer = new KernelTypeInferrer._(
+        this, member.fileUri, listener, true, thisType, member._fieldNode);
   }
 
   @override
-  int getFieldOffset(KernelField field) {
-    return field.fileOffset;
-  }
-
-  @override
-  KernelTypeInferrer getFieldTypeInferrer(KernelField field) {
-    return field._typeInferrer;
+  KernelTypeInferrer getFieldTypeInferrer(KernelMember member) {
+    return member._typeInferrer;
   }
 }
 
 /// Concrete implementation of [TypeInferrer] specialized to work with kernel
 /// objects.
 class KernelTypeInferrer extends TypeInferrerImpl {
   @override
   final typePromoter = new KernelTypePromoter();
 
   KernelTypeInferrer._(
@@ skipping 319 matching lines @@
   }
 
   transformChildren(v) {
     return internalError("Internal error: Unsupported operation.");
   }
 
   visitChildren(v) {
     return internalError("Internal error: Unsupported operation.");
   }
 }