fix #25280, treat setters as returning void in strong mode

pkg/analyzer/lib/src/generated/resolver.dart

 // Copyright (c) 2014, 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 analyzer.src.generated.resolver;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ skipping 11656 matching lines @@
    * The type representing typenames that can't be resolved.
    */
   DartType _undefinedType;
 
   /**
    * The flag specifying if currently visited class references 'super' expression.
    */
   bool _hasReferenceToSuper = false;
 
   /**
+   * True if we're analyzing in strong mode.
+   */
+  bool _strongMode;
+
+  /**
    * Initialize a newly created visitor to resolve the nodes in an AST node.
    *
    * [definingLibrary] is the element for the library containing the node being
    * visited.
    * [source] is the source representing the compilation unit containing the
    * node being visited.
    * [typeProvider] is the object used to access the types from the core
    * library.
    * [errorListener] is the error listener that will be informed of any errors
    * that are found during resolution.
    * [nameScope] is the scope used to resolve identifiers in the node that will
    * first be visited.  If `null` or unspecified, a new [LibraryScope] will be
    * created based on [definingLibrary] and [typeProvider].
    */
   TypeResolverVisitor(LibraryElement definingLibrary, Source source,
       TypeProvider typeProvider, AnalysisErrorListener errorListener,
       {Scope nameScope})
       : super(definingLibrary, source, typeProvider, errorListener,
             nameScope: nameScope) {
     _dynamicType = typeProvider.dynamicType;
     _undefinedType = typeProvider.undefinedType;
+    _strongMode = definingLibrary.context.analysisOptions.strongMode;
   }
 
   @override
   Object visitAnnotation(Annotation node) {
     //
     // Visit annotations, if the annotation is @proxy, on a class, and "proxy"
     // resolves to the proxy annotation in dart.core, then create create the
     // ElementAnnotationImpl and set it as the metadata on the enclosing class.
     //
     // Element resolution is done in the ElementResolver, and this work will be
@@ skipping 220 matching lines @@
       buffer.write("The element for the top-level function ");
       buffer.write(node.name);
       buffer.write(" in ");
       buffer.write(source.fullName);
       buffer.write(" was not set while trying to resolve types.");
       AnalysisEngine.instance.logger.logError(buffer.toString(),
           new CaughtException(new AnalysisException(), null));
     }
     element.returnType = _computeReturnType(node.returnType);
     element.type = new FunctionTypeImpl(element);
+    _inferSetterReturnType(element);
     return null;
   }
 
   @override
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
     FunctionTypeAliasElementImpl element =
         node.element as FunctionTypeAliasElementImpl;
     super.visitFunctionTypeAlias(node);
     element.returnType = _computeReturnType(node.returnType);
     return null;
@@ skipping 28 matching lines @@
         buffer.write(classNode.name.name);
       }
       buffer.write(" in ");
       buffer.write(source.fullName);
       buffer.write(" was not set while trying to resolve types.");
       AnalysisEngine.instance.logger.logError(buffer.toString(),
           new CaughtException(new AnalysisException(), null));
     }
     element.returnType = _computeReturnType(node.returnType);
     element.type = new FunctionTypeImpl(element);
+    _inferSetterReturnType(element);
     if (element is PropertyAccessorElement) {
       PropertyAccessorElement accessor = element as PropertyAccessorElement;
       PropertyInducingElementImpl variable =
           accessor.variable as PropertyInducingElementImpl;
       if (accessor.isGetter) {
         variable.type = element.returnType;
       } else if (variable.type == null) {
         List<ParameterElement> parameters = element.parameters;
         if (parameters != null && parameters.length > 0) {
           variable.type = parameters[0].type;
@@ skipping 508 matching lines @@
       if (element is ClassElement) {
         if (type != null) {
           return null;
         }
         type = element.type;
       }
     }
     return type;
   }
 
+  /**
+   * In strong mode we infer "void" as the setter return type (as void is the
+   * only legal return type for a setter). This allows us to give better
+   * errors later if an invalid type is returned.
+   */
+  void _inferSetterReturnType(ExecutableElementImpl element) {
+    if (_strongMode &&
+        element is PropertyAccessorElementImpl &&
+        element.isSetter &&
+        element.returnType.isDynamic) {

[Brian Wilkerson, 2015/12/17 17:57:59]

We should check that the type 'dynamic' was not explicitly declared (using
hasImplicitReturnType):

    dynamic set x(_) {}

It seems like it would be strange to override an explicit type.

[Jennifer Messerly, 2016/01/05 00:42:44]

Good catch! I thought it was okay because it's invalid to use explicit dynamic).
But yeah, as currently written it would have the effect of suppressing the
warning, so that's not good. Fixed and added test. After fix it should preserve
this warning behavior:


$ cat test.dart
dynamic set f(x) {}

$ dartanalyzer test.dart
Analyzing [test.dart]...
[warning] The return type of the setter must be 'void' (test.dart, line 1, col
1)

+      element.returnType = VoidTypeImpl.instance;
+    }
+  }
+
   DartType _instantiateType(DartType type, List<DartType> typeArguments) {
     if (type is InterfaceTypeImpl) {
       return type.substitute4(typeArguments);
     } else if (type is FunctionTypeImpl) {
       return type.instantiate(typeArguments);
     } else {
       // TODO(brianwilkerson) Report this internal error.
       return type;
     }
   }
@@ skipping 823 matching lines @@
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
 
   @override
   Object visitWithClause(WithClause node) => null;
 }