Fix for 'returnType' when extract a method with a single expression.

pkg/analysis_server/lib/src/services/refactoring/extract_method.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 services.src.refactoring.extract_method;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/protocol.dart' hide Element;
 import 'package:analysis_server/src/services/correction/name_suggestion.dart';
@@ skipping 88 matching lines @@
   bool get canCreateGetter {
     if (!parameters.isEmpty) {
       return false;
     }
     if (_selectionExpression != null) {
       if (_selectionExpression is AssignmentExpression) {
         return false;
       }
     }
     if (_selectionStatements != null) {
-      return returnType != null;
+      return returnType != 'void';
     }
     return true;
   }
 
   @override
   List<RefactoringMethodParameter> get parameters => _parameters;
 
   @override
   void set parameters(List<RefactoringMethodParameter> parameters) {
     _parameters = parameters.toList();
@@ skipping 99 matching lines @@
       if (!extractAll && !occurence.isSelection) {
         continue;
       }
       // prepare invocation source
       String invocationSource;
       if (_selectionFunctionExpression != null) {
         invocationSource = name;
       } else {
         StringBuffer sb = new StringBuffer();
         // may be returns value
-        if (returnType != null) {
+        if (_selectionStatements != null && returnType != 'void') {
           // single variable assignment / return statement
           if (_returnVariableName != null) {
             String occurrenceName =
                 occurence._parameterOldToOccurrenceName[_returnVariableName];
             // may be declare variable
             if (!_parametersMap.containsKey(_returnVariableName)) {
               if (returnType.isEmpty) {
                 sb.write('var ');
               } else {
                 sb.write(returnType);
@@ skipping 69 matching lines @@
               utils.getExpressionTypeSource(_selectionExpression);
           if (returnTypeName != null && returnTypeName != 'dynamic') {
             annotations += '${returnTypeName} ';
           }
           // just return expression
           declarationSource =
               '${annotations}${signature} => ${returnExpressionSource};';
         }
         // statements
         if (_selectionStatements != null) {
-          if (returnType != null) {
-            if (returnType.isNotEmpty) {
-              annotations += returnType + ' ';
-            }
-          } else {
-            annotations += 'void ';
+          if (returnType.isNotEmpty) {
+            annotations += returnType + ' ';
           }
           declarationSource = '${annotations}${signature} {${eol}';
           declarationSource += returnExpressionSource;
           if (_returnVariableName != null) {
             declarationSource +=
                 '${prefix}  return ${_returnVariableName};$eol';
           }
           declarationSource += '${prefix}}';
         }
       }
@@ skipping 230 matching lines @@
    * Prepares information about used variables, which should be turned into
    * parameters.
    */
   RefactoringStatus _initializeParameters() {
     _parameters.clear();
     _parametersMap.clear();
     _parameterReferencesMap.clear();
     RefactoringStatus result = new RefactoringStatus();
     List<VariableElement> assignedUsedVariables = [];
     unit.accept(new _InitializeParametersVisitor(this, assignedUsedVariables));
+    // single expression
+    if (_selectionExpression != null) {
+      _returnType = _selectionExpression.bestType;
+    }
     // may be ends with "return" statement
     if (_selectionStatements != null) {
       Statement lastStatement =
           _selectionStatements[_selectionStatements.length - 1];
       if (lastStatement is ReturnStatement) {
         Expression expression = lastStatement.expression;
         if (expression != null) {
           _returnType = expression.bestType;
         }
       }
@@ skipping 24 matching lines @@
               'Ambiguous return value: Selected block contains more than one '
                   'assignment to local variables. Affected variables are:\n\n{0}',
               sb.toString().trim()));
     }
     // done
     return result;
   }
 
   void _initializeReturnType() {
     if (_returnType == null) {
-      returnType = null;
+      returnType = 'void';
     } else {
       returnType = utils.getTypeSource(_returnType);
-      if (returnType == 'dynamic') {
-        returnType = '';
-      }
+    }
+    if (returnType == 'dynamic') {
+      returnType = '';
     }
   }
 
   /**
    * Checks if the given [VariableElement] is declared in [selectionRange].
    */
   bool _isDeclaredInSelection(VariableElement element) {
     return selectionRange.contains(element.nameOffset);
   }
 
@@ skipping 463 matching lines @@
 
 /**
  * Generalized version of some source, in which references to the specific
  * variables are replaced with pattern variables, with back mapping from the
  * pattern to the original variable names.
  */
 class _SourcePattern {
   String patternSource;
   Map<String, String> originalToPatternNames = {};
 }