Issue 21959. Check that type of parameters in 'Extract Method' occurrences are exactly the same.

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 485 matching lines @@
     // done
     return source;
   }
 
   _SourcePattern _getSourcePattern(SourceRange range) {
     String originalSource = utils.getText(range.offset, range.length);
     _SourcePattern pattern = new _SourcePattern();
     List<SourceEdit> replaceEdits = <SourceEdit>[];
     unit.accept(new _GetSourcePatternVisitor(range, pattern, replaceEdits));
     replaceEdits = replaceEdits.reversed.toList();
-    pattern.patternSource =
-        SourceEdit.applySequence(originalSource, replaceEdits);
+    String source = SourceEdit.applySequence(originalSource, replaceEdits);
+    pattern.normalizedSource = _getNormalizedSource(source);
     return pattern;
   }
 
   /**
    * Initializes [createGetter] flag.
    */
   void _initializeGetter() {
     createGetter = false;
     // maybe we cannot at all
     if (!canCreateGetter) {
@@ skipping 20 matching lines @@
     }
   }
 
   /**
    * Fills [_occurrences] field.
    */
   void _initializeOccurrences() {
     _occurrences.clear();
     // prepare selection
     _SourcePattern selectionPattern = _getSourcePattern(selectionRange);
-    String selectionSource =
-        _getNormalizedSource(selectionPattern.patternSource);
     Map<String, String> patternToSelectionName =
         _inverseMap(selectionPattern.originalToPatternNames);
     // prepare an enclosing parent - class or unit
     AstNode enclosingMemberParent = _parentMember.parent;
     // visit nodes which will able to access extracted method
     enclosingMemberParent.accept(
         new _InitializeOccurrencesVisitor(
             this,
-            selectionSource,
+            selectionPattern,
             patternToSelectionName));
   }
 
   /**
    * Prepares information about used variables, which should be turned into
    * parameters.
    */
   RefactoringStatus _initializeParameters() {
     _parameters.clear();
     _parametersMap.clear();
@@ skipping 265 matching lines @@
           getLocalOrParameterVariableElement(node);
       if (variableElement != null) {
         // name of a named expression
         if (isNamedExpressionName(node)) {
           return;
         }
         // continue
         String originalName = variableElement.displayName;
         String patternName = pattern.originalToPatternNames[originalName];
         if (patternName == null) {
+          pattern.parameterTypes.add(variableElement.type);
           patternName = '__refVar${pattern.originalToPatternNames.length}';
           pattern.originalToPatternNames[originalName] = patternName;
         }
         replaceEdits.add(
             new SourceEdit(
                 nodeRange.offset - partRange.offset,
                 nodeRange.length,
                 patternName));
       }
     }
   }
 }
 
 
 
 class _HasMethodInvocationVisitor extends RecursiveAstVisitor {
   bool result = false;
 
   @override
   visitMethodInvocation(MethodInvocation node) {
     result = true;
   }
 }
 
 
 class _InitializeOccurrencesVisitor extends GeneralizingAstVisitor<Object> {
   final ExtractMethodRefactoringImpl ref;
-  final String selectionSource;
+  final _SourcePattern selectionPattern;
   final Map<String, String> patternToSelectionName;
 
   bool forceStatic = false;
 
-  _InitializeOccurrencesVisitor(this.ref, this.selectionSource,
+  _InitializeOccurrencesVisitor(this.ref, this.selectionPattern,
       this.patternToSelectionName);
 
   @override
   Object visitBlock(Block node) {
     if (ref._selectionStatements != null) {
       _visitStatements(node.statements);
     }
     return super.visitBlock(node);
   }
 
@@ skipping 37 matching lines @@
   }
 
   /**
    * Checks if given [SourceRange] matched selection source and adds [_Occurrence].
    */
   bool _tryToFindOccurrence(SourceRange nodeRange) {
     // check if can be extracted
     if (!ref._isExtractable(nodeRange)) {
       return false;
     }
-    // prepare normalized node source
+    // prepare node source
     _SourcePattern nodePattern = ref._getSourcePattern(nodeRange);
-    String nodeSource = _getNormalizedSource(nodePattern.patternSource);
     // if matches normalized node source, then add as occurrence
-    if (nodeSource == selectionSource) {
+    if (selectionPattern.isCompatible(nodePattern)) {
       _Occurrence occurrence =
           new _Occurrence(nodeRange, ref.selectionRange.intersects(nodeRange));
       ref._occurrences.add(occurrence);
       // prepare mapping of parameter names to the occurrence variables
       nodePattern.originalToPatternNames.forEach(
           (String originalName, String patternName) {
         String selectionName = patternToSelectionName[patternName];
         occurrence._parameterOldToOccurrenceName[selectionName] = originalName;
       });
       // update static
@@ skipping 181 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;
+  final List<DartType> parameterTypes = <DartType>[];
+  String normalizedSource;
   Map<String, String> originalToPatternNames = {};
+
+  bool isCompatible(_SourcePattern other) {
+    if (other.normalizedSource != normalizedSource) {
+      return false;
+    }
+    if (other.parameterTypes.length != parameterTypes.length) {
+      return false;
+    }
+    for (int i = 0; i < parameterTypes.length; i++) {
+      if (other.parameterTypes[i] != parameterTypes[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
 }