Implement override-based type inference for instance methods.

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

 // Copyright (c) 2016, 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.
 
 library fasta.kernel_procedure_builder;
 
 import 'package:front_end/src/fasta/kernel/kernel_shadow_ast.dart'
     show KernelProcedure;
 
 import 'package:front_end/src/fasta/source/source_library_builder.dart'
@@ skipping 197 matching lines @@
       String name,
       List<TypeVariableBuilder> typeVariables,
       List<FormalParameterBuilder> formals,
       ProcedureKind kind,
       KernelLibraryBuilder compilationUnit,
       int charOffset,
       this.charOpenParenOffset,
       int charEndOffset,
       [String nativeMethodName,
       this.redirectionTarget])
-      : procedure = new KernelProcedure(null, kind, null,
+      : procedure = new KernelProcedure(null, kind, null, returnType == null,
             fileUri: compilationUnit?.relativeFileUri)
           ..fileOffset = charOffset
           ..fileEndOffset = charEndOffset,
         super(metadata, modifiers, returnType, name, typeVariables, formals,
             compilationUnit, charOffset, nativeMethodName);
 
   ProcedureKind get kind => procedure.kind;
 
   AsyncMarker get asyncModifier => actualAsyncModifier;
 
   Statement get body {
     if (actualBody == null &&
         redirectionTarget == null &&
         !isAbstract &&
         !isExternal) {
       actualBody = new EmptyStatement();
     }
     return actualBody;
   }
 
   void set asyncModifier(AsyncMarker newModifier) {
     actualAsyncModifier = newModifier;
     if (function != null) {
       // No parent, it's an enum.
       function.asyncMarker = actualAsyncModifier;
       function.dartAsyncMarker = actualAsyncModifier;
     }
   }
 
-  bool get isEligibleForGetterSetterInference {
+  bool get isEligibleForTopLevelInference {
     if (!isInstanceMember) return false;
-    if (isGetter) {
-      return returnType == null;
-    } else if (isSetter) {
-      return formals != null && formals.length > 0 && formals[0].type == null;
-    } else {
-      return false;
+    if (returnType == null) {
+      // For now, we skip inferred return types of setters.

[Siggi Cherem (dart-lang), 2017/06/21 20:19:08]

aren't they always void (otherwise it is an error)?

[Paul Berry, 2017/06/21 20:54:47]

Not quite.

In strong mode if no type is specified, the inferred type is `void`; if a type
is specified and it's not `void`, that's an error.

In spec mode if no type is specified, the inferred type is `dynamic`; if a type
is specified and it's not `void`, that's a static warning.

I plan to implement the proper strong mode rules in a follow-up CL, hopefully
later today.

+      // TODO(paulberry): fix this.
+      if (!isSetter) return true;
     }
+    if (formals != null) {
+      for (var formal in formals) {
+        if (formal.type == null) return true;
+      }
+    }
+    return false;
   }
 
   Procedure build(SourceLibraryBuilder library) {
     // TODO(ahe): I think we may call this twice on parts. Investigate.
     if (procedure.name == null) {
       procedure.function = buildFunction(library);
       procedure.function.parent = procedure;
       procedure.function.fileOffset = charOpenParenOffset;
       procedure.function.fileEndOffset = procedure.fileEndOffset;
       procedure.isAbstract = isAbstract;
       procedure.isStatic = isStatic;
       procedure.isExternal = isExternal;
       procedure.isConst = isConst;
       procedure.name = new Name(name, library.target);
     }
-    if (isEligibleForGetterSetterInference) {
+    if (isEligibleForTopLevelInference) {
       library.loader.typeInferenceEngine.recordMember(procedure);
     }
     return procedure;
   }
 
   Procedure get target => procedure;
 
   @override
   void prepareInitializerInference(
       SourceLibraryBuilder library, ClassBuilder currentClass) {
-    if (isEligibleForGetterSetterInference) {
+    if (isEligibleForTopLevelInference) {
       var typeInferenceEngine = library.loader.typeInferenceEngine;
       var listener = new TypeInferenceListener();
       typeInferenceEngine.createTopLevelTypeInferrer(
           listener, procedure.enclosingClass?.thisType, procedure);
     }
   }
 }
 
 // TODO(ahe): Move this to own file?
 class KernelConstructorBuilder extends KernelFunctionBuilder {
@@ skipping 112 matching lines @@
         }
       }
       initializers.add(initializer..parent = constructor);
       initializers.add(superInitializer);
       return;
     }
     initializers.add(initializer);
     initializer.parent = constructor;
   }
 }