[Extract Method] When no selection, check for implicitly selected closure.

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.
 
 import 'dart:async';
 
 import 'package:analysis_server/src/protocol_server.dart' hide Element;
 import 'package:analysis_server/src/services/correction/name_suggestion.dart';
 import 'package:analysis_server/src/services/correction/selection_analyzer.dart';
 import 'package:analysis_server/src/services/correction/statement_analyzer.dart';
@@ skipping 305 matching lines @@
         if (_staticContext) {
           annotations = 'static ';
         }
       }
       // prepare declaration source
       String declarationSource = null;
       {
         String returnExpressionSource = _getMethodBodySource();
         // closure
         if (_selectionFunctionExpression != null) {
-          declarationSource = '$name$returnExpressionSource';
+          String returnTypeCode = _getExpectedClosureReturnTypeCode();
+          declarationSource = '$returnTypeCode$name$returnExpressionSource';
           if (_selectionFunctionExpression.body is ExpressionFunctionBody) {
             declarationSource += ';';
           }
         }
         // optional 'async' body modifier
         String asyncKeyword = _hasAwait ? ' async' : '';
         // expression
         if (_selectionExpression != null) {
           // add return type
           if (returnType.isNotEmpty) {
@@ skipping 84 matching lines @@
     }
     // OK
     return new Future<RefactoringStatus>.value(result);
   }
 
   /**
    * Checks if [selectionRange] selects [Expression] which can be extracted, and
    * location of this [DartExpression] in AST allows extracting.
    */
   RefactoringStatus _checkSelection() {
+    // Check for implicitly selected closure.
+    {
+      FunctionExpression function = _findFunctionExpression();
+      if (function != null) {
+        _selectionFunctionExpression = function;
+        selectionRange = range.node(function);
+        _parentMember = getEnclosingClassOrUnitMember(function);
+        return new RefactoringStatus();
+      }
+    }
+
     _ExtractMethodAnalyzer selectionAnalyzer =
         new _ExtractMethodAnalyzer(unit, selectionRange);
     unit.accept(selectionAnalyzer);
-    // may be fatal error
+    // May be a fatal error.
     {
       RefactoringStatus status = selectionAnalyzer.status;
       if (status.hasFatalError) {
         return status;
       }
     }
-    // check selected nodes
     List<AstNode> selectedNodes = selectionAnalyzer.selectedNodes;
+
+    // Check selected nodes.
     if (!selectedNodes.isEmpty) {
-      AstNode coveringNode = selectionAnalyzer.coveringNode;
-      _parentMember = getEnclosingClassOrUnitMember(coveringNode);
+      AstNode selectedNode = selectedNodes.first;
+      _parentMember = getEnclosingClassOrUnitMember(selectedNode);
       // single expression selected
-      if (selectedNodes.length == 1 &&
-          !utils.selectionIncludesNonWhitespaceOutsideNode(
-              selectionRange, selectionAnalyzer.firstSelectedNode)) {
-        AstNode selectedNode = selectionAnalyzer.firstSelectedNode;
-        if (selectedNode is Expression) {
-          _selectionExpression = selectedNode;
-          // additional check for closure
-          if (_selectionExpression is FunctionExpression) {
-            _selectionFunctionExpression =
-                _selectionExpression as FunctionExpression;
-            _selectionExpression = null;
+      if (selectedNodes.length == 1) {
+        if (!utils.selectionIncludesNonWhitespaceOutsideNode(
+            selectionRange, selectedNode)) {
+          if (selectedNode is Expression) {
+            _selectionExpression = selectedNode;
+            // additional check for closure
+            if (_selectionExpression is FunctionExpression) {
+              _selectionFunctionExpression =
+                  _selectionExpression as FunctionExpression;
+              _selectionExpression = null;
+            }
+            // OK
+            return new RefactoringStatus();
           }
-          // OK
-          return new RefactoringStatus();
         }
       }
       // statements selected
       {
         List<Statement> selectedStatements = [];
         for (AstNode selectedNode in selectedNodes) {
           if (selectedNode is Statement) {
             selectedStatements.add(selectedNode);
           }
         }
@@ skipping 28 matching lines @@
     }
     // doesn't return a value
     if (_selectionStatements != null) {
       return returnType != 'void';
     }
     // OK
     return true;
   }
 
   /**
+   * If the [selectionRange] is associated with a [FunctionExpression], return
+   * this [FunctionExpression].
+   */
+  FunctionExpression _findFunctionExpression() {
+    if (selectionRange.length != 0) {
+      return null;
+    }
+    int offset = selectionRange.offset;
+    AstNode node = new NodeLocator2(offset, offset).searchWithin(unit);
+
+    // Check for the parameter list of a FunctionExpression.
+    {
+      FunctionExpression function =
+          node?.getAncestor((n) => n is FunctionExpression);
+      if (function != null &&
+          function.parameters != null &&
+          range.node(function.parameters).contains(offset)) {
+        return function;
+      }
+    }
+
+    // Check for the name of the named argument with the closure expression.
+    if (node is SimpleIdentifier &&
+        node.parent is Label &&
+        node.parent.parent is NamedExpression) {
+      NamedExpression namedExpression = node.parent.parent;
+      Expression expression = namedExpression.expression;
+      if (expression is FunctionExpression) {
+        return expression;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * If the selected closure (i.e. [_selectionFunctionExpression]) is an
+   * argument for a function typed parameter (as it should be), and the
+   * function type has the return type specified, return this return type's
+   * code. Otherwise return the empty string.
+   */
+  String _getExpectedClosureReturnTypeCode() {
+    Expression argument = _selectionFunctionExpression;
+    if (argument.parent is NamedExpression) {
+      argument = argument.parent as NamedExpression;
+    }
+    ParameterElement parameter = argument.bestParameterElement;
+    if (parameter != null) {
+      DartType parameterType = parameter.type;
+      if (parameterType is FunctionType) {
+        String typeCode = _getTypeCode(parameterType.returnType);
+        if (typeCode != 'dynamic') {
+          return typeCode + ' ';
+        }
+      }
+    }
+    return '';
+  }
+
+  /**
    * Returns the selected [Expression] source, with applying new parameter
    * names.
    */
   String _getMethodBodySource() {
     String source = utils.getRangeText(selectionRange);
     // prepare operations to replace variables with parameters
     List<SourceEdit> replaceEdits = [];
     for (RefactoringMethodParameter parameter in _parameters) {
       List<SourceRange> ranges = _parameterReferencesMap[parameter.id];
       if (ranges != null) {
@@ skipping 731 matching lines @@
       return false;
     }
     for (int i = 0; i < parameterTypes.length; i++) {
       if (other.parameterTypes[i] != parameterTypes[i]) {
         return false;
       }
     }
     return true;
   }
 }