In strong mode, properly infer the return types of setters as `void`

pkg/front_end/lib/src/fasta/type_inference/type_inference_engine.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.md file.
 
 import 'package:front_end/src/base/instrumentation.dart';
 import 'package:front_end/src/dependency_walker.dart' as dependencyWalker;
 import 'package:front_end/src/fasta/errors.dart';
 import 'package:front_end/src/fasta/kernel/kernel_shadow_ast.dart';
 import 'package:front_end/src/fasta/type_inference/type_inference_listener.dart';
 import 'package:front_end/src/fasta/type_inference/type_inferrer.dart';
@@ skipping 35 matching lines @@
   ///
   /// Otherwise `null`.
   AccessorNode currentDependency;
 
   final overrides = <Member>[];
 
   final crossOverrides = <Member>[];
 
   AccessorNode(this._typeInferenceEngine, this.member);
 
-  get candidateOverrides => overrides.isNotEmpty ? overrides : crossOverrides;
+  List<Member> get candidateOverrides {
+    if (isTrivialSetter) {
+      return const [];
+    } else if (overrides.isNotEmpty) {
+      return overrides;
+    } else {
+      return crossOverrides;
+    }
+  }
 
   @override
   bool get isEvaluated => state == InferenceState.Inferred;
 
+  /// Indicates whether this accessor is a setter for which the only type we
+  /// have to infer is its return type.
+  bool get isTrivialSetter {
+    var member = this.member;
+    if (member is KernelProcedure &&
+        member.isSetter &&
+        member.function != null) {
+      var parameters = member.function.positionalParameters;
+      return parameters.length > 0 &&
+          !KernelVariableDeclaration.isImplicitlyTyped(parameters[0]);
+    }
+    return false;
+  }
+
   @override
   List<AccessorNode> computeDependencies() {
     return _typeInferenceEngine.computeAccessorDependencies(this);
   }
 
   @override
   String toString() => member.toString();
 }
 
 /// Enum tracking the type inference state of an accessor or method.
@@ skipping 206 matching lines @@
       return const DynamicType();
     }
   }
 
   /// Performs type inference on the given [accessorNode].
   void inferAccessor(AccessorNode accessorNode) {
     assert(accessorNode.state == InferenceState.NotInferredYet);
     accessorNode.state = InferenceState.Inferring;
     var member = accessorNode.member;
     if (strongMode) {
-      var inferredType = tryInferAccessorByInheritance(accessorNode);
       var typeInferrer = getMemberTypeInferrer(member);
-      if (inferredType == null) {
-        if (member is KernelField) {
-          typeInferrer.isImmediatelyEvident = true;
-          inferredType = accessorNode.isImmediatelyEvident
-              ? typeInferrer.inferDeclarationType(
-                  typeInferrer.inferFieldTopLevel(member, null, true))
-              : const DynamicType();
-          if (!typeInferrer.isImmediatelyEvident) {
+      if (member is KernelProcedure && member.isSetter) {
+        KernelProcedure.inferSetterReturnType(member, this, typeInferrer.uri);
+      }
+      if (!accessorNode.isTrivialSetter) {
+        var inferredType = tryInferAccessorByInheritance(accessorNode);
+        if (inferredType == null) {
+          if (member is KernelField) {
+            typeInferrer.isImmediatelyEvident = true;
+            inferredType = accessorNode.isImmediatelyEvident
+                ? typeInferrer.inferDeclarationType(
+                    typeInferrer.inferFieldTopLevel(member, null, true))
+                : const DynamicType();
+            if (!typeInferrer.isImmediatelyEvident) {
+              inferredType = const DynamicType();
+            }
+          } else {
             inferredType = const DynamicType();
           }
-        } else {
-          inferredType = const DynamicType();
         }
+        if (accessorNode.state == InferenceState.Inferred) {
+          // A circularity must have been detected; at the time it was detected,
+          // inference for this node was completed.
+          return;
+        }
+        member.setInferredType(this, typeInferrer.uri, inferredType);
       }
-      if (accessorNode.state == InferenceState.Inferred) {
-        // A circularity must have been detected; at the time it was detected,
-        // inference for this node was completed.
-        return;
-      }
-      member.setInferredType(this, typeInferrer.uri, inferredType);
     }
     accessorNode.state = InferenceState.Inferred;
     // TODO(paulberry): if type != null, then check that the type of the
     // initializer is assignable to it.
     // TODO(paulberry): the following is a hack so that outlines don't contain
     // initializers.  But it means that we rebuild the initializers when doing
     // a full compile.  There should be a better way.
     if (member is KernelField) {
       member.initializer = null;
     }
@@ skipping 282 matching lines @@
   }
 
   @override
   void evaluateScc(List<AccessorNode> scc) {
     // Mark every accessor as part of a circularity.
     for (var f in scc) {
       f._typeInferenceEngine.inferAccessorCircular(f);
     }
   }
 }