Issue 25616. Support for extracting methods with function-typed parameters.

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 13 matching lines @@
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/resolver.dart' show ExitDetector;
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/source.dart';
 
 const String _TOKEN_SEPARATOR = '\uFFFF';
 
+Element _getLocalElement(SimpleIdentifier node) {
+  Element element = node.staticElement;
+  if (element is LocalVariableElement ||
+      element is ParameterElement ||
+      element is FunctionElement && element.visibleRange != null) {
+    return element;
+  }
+  return null;
+}
+
 /**
  * Returns the "normalized" version of the given source, which is reconstructed
  * from tokens, so ignores all the comments and spaces.
  */
 String _getNormalizedSource(String src) {
   List<Token> selectionTokens = TokenUtils.getTokens(src);
   return StringUtils.join(selectionTokens, _TOKEN_SEPARATOR);
 }
 
 /**
@@ skipping 110 matching lines @@
         // type
         {
           String typeSource = parameter.type;
           if ('dynamic' != typeSource && '' != typeSource) {
             sb.write(typeSource);
             sb.write(' ');
           }
         }
         // name
         sb.write(parameter.name);
+        // optional function-typed parameter parameters
+        if (parameter.parameters != null) {
+          sb.write(parameter.parameters);
+        }
       }
       sb.write(')');
     }
     // done
     return sb.toString();
   }
 
   @override
   Future<RefactoringStatus> checkFinalConditions() async {
     RefactoringStatus result = new RefactoringStatus();
@@ skipping 481 matching lines @@
         if (_returnType.element != futureType.element) {
           returnType = _getTypeCode(futureType.substitute4([_returnType]));
         }
       } else {
         returnType = variableType;
       }
     }
   }
 
   /**
-   * Checks if the given [VariableElement] is declared in [selectionRange].
+   * Checks if the given [element] is declared in [selectionRange].
    */
-  bool _isDeclaredInSelection(VariableElement element) {
+  bool _isDeclaredInSelection(Element element) {
     return selectionRange.contains(element.nameOffset);
   }
 
   /**
    * Checks if it is OK to extract the node with the given [SourceRange].
    */
   bool _isExtractable(SourceRange range) {
     _ExtractMethodAnalyzer analyzer = new _ExtractMethodAnalyzer(unit, range);
     utils.unit.accept(analyzer);
     return analyzer.status.isOK;
@@ skipping 15 matching lines @@
     }
     if (_unqualifiedNames.contains(name)) {
       return true;
     }
     return false;
   }
 
   /**
    * Checks if [element] is referenced after [selectionRange].
    */
-  bool _isUsedAfterSelection(VariableElement element) {
+  bool _isUsedAfterSelection(Element element) {
     var visitor = new _IsUsedAfterSelectionVisitor(this, element);
     _parentMember.accept(visitor);
     return visitor.result;
   }
 
   /**
    * Prepare names that are used in the enclosing function, so should not be
    * proposed as names of the extracted method.
    */
   void _prepareExcludedNames() {
@@ skipping 186 matching lines @@
   final SourceRange partRange;
   final _SourcePattern pattern;
   final List<SourceEdit> replaceEdits;
 
   _GetSourcePatternVisitor(this.partRange, this.pattern, this.replaceEdits);
 
   @override
   visitSimpleIdentifier(SimpleIdentifier node) {
     SourceRange nodeRange = rangeNode(node);
     if (partRange.covers(nodeRange)) {
-      VariableElement variableElement =
-          getLocalOrParameterVariableElement(node);
-      if (variableElement != null) {
+      Element element = _getLocalElement(node);
+      if (element != null) {
         // name of a named expression
         if (isNamedExpressionName(node)) {
           return;
         }
         // continue
-        String originalName = variableElement.displayName;
+        String originalName = element.displayName;
         String patternName = pattern.originalToPatternNames[originalName];
         if (patternName == null) {
-          pattern.parameterTypes.add(variableElement.type);
+          DartType parameterType = _getElementType(element);
+          pattern.parameterTypes.add(parameterType);
           patternName = '__refVar${pattern.originalToPatternNames.length}';
           pattern.originalToPatternNames[originalName] = patternName;
         }
         replaceEdits.add(new SourceEdit(nodeRange.offset - partRange.offset,
             nodeRange.length, patternName));
       }
     }
   }
+
+  DartType _getElementType(Element element) {
+    if (element is VariableElement) {
+      return element.type;
+    }
+    if (element is FunctionElement) {
+      return element.type;
+    }
+    throw new StateError('Unknown element type: ${element?.runtimeType}');
+  }
 }
 
 class _HasAwaitVisitor extends GeneralizingAstVisitor {
   bool result = false;
 
   @override
   visitAwaitExpression(AwaitExpression node) {
     result = true;
   }
 
@@ skipping 130 matching lines @@
 
   _InitializeParametersVisitor(this.ref, this.assignedUsedVariables);
 
   @override
   void visitSimpleIdentifier(SimpleIdentifier node) {
     SourceRange nodeRange = rangeNode(node);
     if (!ref.selectionRange.covers(nodeRange)) {
       return;
     }
     String name = node.name;
-    // analyze local variable
-    VariableElement variableElement = getLocalOrParameterVariableElement(node);
-    if (variableElement != null) {
+    // analyze local element
+    Element element = _getLocalElement(node);
+    if (element != null) {
       // name of the named expression
       if (isNamedExpressionName(node)) {
         return;
       }
       // if declared outside, add parameter
-      if (!ref._isDeclaredInSelection(variableElement)) {
+      if (!ref._isDeclaredInSelection(element)) {
         // add parameter
         RefactoringMethodParameter parameter = ref._parametersMap[name];
         if (parameter == null) {
           DartType parameterType = node.bestType;
-          String parameterTypeCode = ref._getTypeCode(parameterType);
+          StringBuffer parametersBuffer = new StringBuffer();
+          String parameterTypeCode = ref.utils.getTypeSource(
+              parameterType, ref.librariesToImport,
+              parametersBuffer: parametersBuffer);
+          String parametersCode =
+              parametersBuffer.isNotEmpty ? parametersBuffer.toString() : null;
           parameter = new RefactoringMethodParameter(
               RefactoringMethodParameterKind.REQUIRED, parameterTypeCode, name,
-              id: name);
+              parameters: parametersCode, id: name);
           ref._parameters.add(parameter);
           ref._parametersMap[name] = parameter;
         }
         // add reference to parameter
         ref._addParameterReference(name, nodeRange);
       }
       // remember, if assigned and used after selection
-      if (isLeftHandOfAssignment(node) &&
-          ref._isUsedAfterSelection(variableElement)) {
-        if (!assignedUsedVariables.contains(variableElement)) {
-          assignedUsedVariables.add(variableElement);
+      if (isLeftHandOfAssignment(node) && ref._isUsedAfterSelection(element)) {
+        if (!assignedUsedVariables.contains(element)) {
+          assignedUsedVariables.add(element);
         }
       }
     }
     // remember information for conflicts checking
-    if (variableElement is LocalElement) {
+    if (element is LocalElement) {
       // declared local elements
-      LocalElement localElement = variableElement as LocalElement;
       if (node.inDeclarationContext()) {
         ref._localNames.putIfAbsent(name, () => <SourceRange>[]);
-        ref._localNames[name].add(localElement.visibleRange);
+        ref._localNames[name].add(element.visibleRange);
       }
     } else {
       // unqualified non-local names
       if (!node.isQualified) {
         ref._unqualifiedNames.add(name);
       }
     }
   }
 }
 
 class _IsUsedAfterSelectionVisitor extends GeneralizingAstVisitor {
   final ExtractMethodRefactoringImpl ref;
-  final VariableElement element;
+  final Element element;
   bool result = false;
 
   _IsUsedAfterSelectionVisitor(this.ref, this.element);
 
   @override
   visitSimpleIdentifier(SimpleIdentifier node) {
-    VariableElement nodeElement = getLocalVariableElement(node);
+    Element nodeElement = node.staticElement;
     if (identical(nodeElement, element)) {
       int nodeOffset = node.offset;
       if (nodeOffset > ref.selectionRange.end) {
         result = true;
       }
     }
   }
 }
 
 /**
@@ skipping 63 matching lines @@
       return false;
     }
     for (int i = 0; i < parameterTypes.length; i++) {
       if (other.parameterTypes[i] != parameterTypes[i]) {
         return false;
       }
     }
     return true;
   }
 }