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 3026 matching lines @@
           setter.parameters = holder.parameters;
           if (body.isAsynchronous) {
             setter.asynchronous = true;
           }
           if (body.isGenerator) {
             setter.generator = true;
           }
           setter.variable = variable;
           setter.setter = true;
           setter.static = true;
+          if (node.returnType == null) {
+            setter.hasImplicitReturnType = true;
+          }
           variable.setter = setter;
           variable.final2 = false;
           _currentHolder.addAccessor(setter);
           expression.element = setter;
           propertyNameNode.staticElement = setter;
         }
       }
       holder.validate();
     }
     return null;
@@ skipping 206 matching lines @@
           if (body.isAsynchronous) {
             setter.asynchronous = true;
           }
           if (body.isGenerator) {
             setter.generator = true;
           }
           setter.variable = field;
           setter.abstract = node.isAbstract;
           setter.setter = true;
           setter.static = isStatic;
+          if (node.returnType == null) {
+            setter.hasImplicitReturnType = true;
+          }
           field.setter = setter;
           field.final2 = false;
           _currentHolder.addAccessor(setter);
           propertyNameNode.staticElement = setter;
         }
       }
       holder.validate();
     } catch (exception, stackTrace) {
       if (node.name.staticElement == null) {
         ClassDeclaration classNode =
@@ skipping 8468 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.hasImplicitReturnType) {
+      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;
 }