Issue 21612. Support for multiple returns in the 'Extract Method' refactoring.

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_server.dart' hide Element;
 import 'package:analysis_server/src/services/correction/name_suggestion.dart';
@@ skipping 558 matching lines @@
     _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;
-        }
-      }
+      _ReturnTypeComputer returnTypeComputer = new _ReturnTypeComputer();
+      _selectionStatements.forEach((statement) {
+        statement.accept(returnTypeComputer);
+      });
+      _returnType = returnTypeComputer.returnType;
     }
     // may be single variable to return
     if (assignedUsedVariables.length == 1) {
       // we cannot both return variable and have explicit return statement
       if (_returnType != null) {
         result.addFatalError(
             'Ambiguous return value: Selected block contains assignment(s) to '
                 'local variables and return statement.');
         return result;
       }
@@ skipping 497 matching lines @@
   }
 
   @override
   visitWhileStatement(WhileStatement node) {
     ref.createGetter = false;
     super.visitWhileStatement(node);
   }
 }
 
 
+class _ReturnTypeComputer extends RecursiveAstVisitor {
+  DartType returnType;
+
+  @override
+  visitBlockFunctionBody(BlockFunctionBody node) {
+  }
+
+  @override
+  visitReturnStatement(ReturnStatement node) {
+    Expression expression = node.expression;
+    if (expression != null) {
+      DartType type = expression.bestType;
+      if (returnType == null) {
+        returnType = type;
+      } else {
+        returnType = returnType.getLeastUpperBound(type);

[Brian Wilkerson, 2014/11/15 01:32:38]

I'm going to guess that this doesn't work very well in the same cases where the
conditional operator confuses people. Consider adding back the method
InterfaceTypeImpl.leastUpperBound or some variation of it (it was deleted from
the Dart code but still exists in the Java code).

[scheglov, 2014/11/15 02:26:16]

OK
https://codereview.chromium.org/730803003

+      }
+    }
+  }
+}
+
+
 /**
  * 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 = {};
 }