Implement override-based type inference for instance methods.

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 1299 matching lines @@
       KernelMember member, Member overriddenMember) {
     if (member._accessorNode != null) {
       member._accessorNode.crossOverrides.add(overriddenMember);
     }
   }
 
   static void recordOverride(KernelMember member, Member overriddenMember) {
     if (member._accessorNode != null) {
       member._accessorNode.overrides.add(overriddenMember);
     }
+    if (member is KernelProcedure && member._methodNode != null) {
+      member._methodNode.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;
 
@@ skipping 138 matching lines @@
     inferrer.listener.nullLiteralExit(this, inferredType);
     return inferredType;
   }
 }
 
 /// Concrete shadow object representing a procedure in kernel form.
 class KernelProcedure extends Procedure implements KernelMember {
   @override
   AccessorNode _accessorNode;
 
+  MethodNode _methodNode;
+
   @override
   KernelTypeInferrer _typeInferrer;
 
+  final bool _hasImplicitReturnType;
+
   KernelProcedure(Name name, ProcedureKind kind, FunctionNode function,
+      this._hasImplicitReturnType,
       {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');
     }
   }
+
+  static MethodNode getMethodNode(Procedure procedure) {
+    if (procedure is KernelProcedure) return procedure._methodNode;
+    return null;
+  }
+
+  static bool hasImplicitReturnType(KernelProcedure procedure) {
+    return procedure._hasImplicitReturnType;
+  }
 }
 
 /// 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})
@@ skipping 418 matching lines @@
   }
 
   @override
   KernelTypeInferrer createLocalTypeInferrer(
       Uri uri, TypeInferenceListener listener, InterfaceType thisType) {
     return new KernelTypeInferrer._(
         this, uri.toString(), listener, false, thisType, null);
   }
 
   @override
+  MethodNode createMethodNode(KernelProcedure procedure) {
+    MethodNode methodNode = new MethodNode(procedure);
+    procedure._methodNode = methodNode;
+    return methodNode;
+  }
+
+  @override
   KernelTypeInferrer createTopLevelTypeInferrer(TypeInferenceListener listener,
       InterfaceType thisType, KernelMember member) {
     return member._typeInferrer = new KernelTypeInferrer._(
         this, member.fileUri, listener, true, thisType, member._accessorNode);
   }
 
   @override
   KernelTypeInferrer getMemberTypeInferrer(KernelMember member) {
     return member._typeInferrer;
   }
@@ skipping 328 matching lines @@
   }
 
   transformChildren(v) {
     return internalError("Internal error: Unsupported operation.");
   }
 
   visitChildren(v) {
     return internalError("Internal error: Unsupported operation.");
   }
 }