Issue 25404. 'Inline Method' should update implicit 'this' and class references.

pkg/analysis_server/lib/src/services/refactoring/inline_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.inline_method;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/protocol_server.dart' hide Element;
 import 'package:analysis_server/src/services/correction/source_range.dart';
@@ skipping 84 matching lines @@
       if (argumentPrecedence < occurrence.parentPrecedence) {
         occurrenceArgumentSource = "($argumentSource)";
       } else {
         occurrenceArgumentSource = argumentSource;
       }
       // do replace
       edits.add(newSourceEdit_range(range, occurrenceArgumentSource));
     }
   });
   // replace static field "qualifier" with invocation target
-  part._staticFieldOffsets.forEach((String className, List<int> offsets) {
+  part._implicitClassNameOffsets.forEach((String className, List<int> offsets) {
     for (int offset in offsets) {
 //      edits.add(newSourceEdit_range(range, className + '.'));
       edits.add(new SourceEdit(offset, 0, className + '.'));
     }
   });
   // replace "this" references with invocation target
   if (targetExpression != null) {
     String targetSource = utils.getNodeText(targetExpression);
     // explicit "this" references
     for (int offset in part._explicitThisOffsets) {
@@ skipping 559 matching lines @@
    * The offsets of explicit `this` expression references.
    */
   final List<int> _explicitThisOffsets = [];
 
   /**
    * The offsets of implicit `this` expression references.
    */
   final List<int> _implicitThisOffsets = [];
 
   /**
-   * The offsets of the implicit class references in static field references.
+   * The offsets of the implicit class references in static member references.
    */
-  final Map<String, List<int>> _staticFieldOffsets = {};
+  final Map<String, List<int>> _implicitClassNameOffsets = {};
 
   _SourcePart(this._base, this._source, this._prefix);
 
   void addExplicitThisOffset(int offset) {
     _explicitThisOffsets.add(offset - _base);
   }
 
+  void addImplicitClassNameOffset(String className, int offset) {
+    List<int> offsets = _implicitClassNameOffsets[className];
+    if (offsets == null) {
+      offsets = [];
+      _implicitClassNameOffsets[className] = offsets;
+    }
+    offsets.add(offset - _base);
+  }
+
   void addImplicitThisOffset(int offset) {
     _implicitThisOffsets.add(offset - _base);
   }
 
   void addParameterOccurrence(
       ParameterElement parameter, SourceRange range, int precedence) {
     if (parameter != null) {
       List<_ParameterOccurrence> occurrences = _parameters[parameter];
       if (occurrences == null) {
         occurrences = [];
         _parameters[parameter] = occurrences;
       }
       range = rangeFromBase(range, _base);
       occurrences.add(new _ParameterOccurrence(precedence, range));
     }
   }
 
-  void addStaticFieldOffset(String className, int offset) {
-    List<int> offsets = _staticFieldOffsets[className];
-    if (offsets == null) {
-      offsets = [];
-      _staticFieldOffsets[className] = offsets;
-    }
-    offsets.add(offset - _base);
-  }
-
   void addVariable(VariableElement element, SourceRange range) {
     List<SourceRange> ranges = _variables[element];
     if (ranges == null) {
       ranges = [];
       _variables[element] = ranges;
     }
     range = rangeFromBase(range, _base);
     ranges.add(range);
   }
 }
@@ skipping 27 matching lines @@
     if (!bodyRange.intersects(nodeRange)) {
       return null;
     }
     super.visitNode(node);
   }
 
   @override
   visitSimpleIdentifier(SimpleIdentifier node) {
     SourceRange nodeRange = rangeNode(node);
     if (bodyRange.covers(nodeRange)) {
-      _addInstanceFieldQualifier(node);
+      _addMemberQualifier(node);
       _addParameter(node);
       _addVariable(node);
     }
   }
 
   @override
   visitThisExpression(ThisExpression node) {
     int offset = node.offset;
     if (bodyRange.contains(offset)) {
       result.addExplicitThisOffset(offset);
     }
   }
 
-  void _addInstanceFieldQualifier(SimpleIdentifier node) {
-    PropertyAccessorElement accessor = getPropertyAccessorElement(node);
-    if (isFieldAccessorElement(accessor)) {
-      AstNode qualifier = getNodeQualifier(node);
-      if (qualifier == null) {
-        int offset = node.offset;
-        if (accessor.isStatic) {
-          String className = accessor.enclosingElement.displayName;
-          result.addStaticFieldOffset(className, offset);
-        } else {
-          result.addImplicitThisOffset(offset);
-        }
-      }
+  void _addMemberQualifier(SimpleIdentifier node) {
+    // should be unqualified
+    AstNode qualifier = getNodeQualifier(node);
+    if (qualifier != null) {
+      return;
+    }
+    // should be a method or field reference
+    Element element = node.staticElement;
+    if (!(element is MethodElement || element is PropertyAccessorElement)) {
+      return;
+    }
+    if (element.enclosingElement is! ClassElement) {
+      return;
+    }
+    // record the implicit static or instance reference
+    ExecutableElement member = element;
+    int offset = node.offset;
+    if (member.isStatic) {
+      String className = member.enclosingElement.displayName;
+      result.addImplicitClassNameOffset(className, offset);
+    } else {
+      result.addImplicitThisOffset(offset);
     }
   }
 
   void _addParameter(SimpleIdentifier node) {
     ParameterElement parameterElement = getParameterElement(node);
     // not a parameter
     if (parameterElement == null) {
       return;
     }
     // not a parameter of the function being inlined
     if (!methodElement.parameters.contains(parameterElement)) {
       return;
     }
     // OK, add occurrence
     SourceRange nodeRange = rangeNode(node);
     int parentPrecedence = getExpressionParentPrecedence(node);
     result.addParameterOccurrence(
         parameterElement, nodeRange, parentPrecedence);
   }
 
   void _addVariable(SimpleIdentifier node) {
     VariableElement variableElement = getLocalVariableElement(node);
     if (variableElement != null) {
       SourceRange nodeRange = rangeNode(node);
       result.addVariable(variableElement, nodeRange);
     }
   }
 }