Issue 19800. Support for inlining getters/setters.

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.dart' hide Element;
 import 'package:analysis_server/src/services/correction/source_range.dart';
@@ skipping 161 matching lines @@
   final int offset;
   String file;
   CorrectionUtils utils;
   SourceChange change;
 
   bool isDeclaration = false;
   bool deleteSource = false;
   bool inlineAll = true;
 
   ExecutableElement _methodElement;
+  bool _isAccessor;
   String _methodFile;
   CompilationUnit _methodUnit;
   CorrectionUtils _methodUtils;
   AstNode _methodNode;
   FormalParameterList _methodParameters;
   FunctionBody _methodBody;
   Expression _methodExpression;
   _SourcePart _methodExpressionPart;
   _SourcePart _methodStatementsPart;
   List<_ReferenceProcessor> _referenceProcessors = [];
@@ skipping 102 matching lines @@
 
   /**
    * Initializes [_methodElement] and related fields.
    */
   RefactoringStatus _prepareMethod() {
     _methodElement = null;
     _methodParameters = null;
     _methodBody = null;
     deleteSource = false;
     inlineAll = false;
+    // prepare for failure
+    RefactoringStatus fatalStatus = new RefactoringStatus.fatal(
+        'Method declaration or reference must be selected to activate this refactoring.');
     // prepare selected SimpleIdentifier
-    AstNode selectedNode = new NodeLocator.con1(offset).searchWithin(unit);
-    if (selectedNode is! SimpleIdentifier) {
-      return new RefactoringStatus.fatal(
-          'Method declaration or reference must be selected to activate this refactoring.');
+    AstNode node = new NodeLocator.con1(offset).searchWithin(unit);
+    if (node is! SimpleIdentifier) {
+      return fatalStatus;
     }
-    SimpleIdentifier selectedIdentifier = selectedNode as SimpleIdentifier;
+    SimpleIdentifier identifier = node as SimpleIdentifier;
     // prepare selected ExecutableElement
-    Element selectedElement = selectedIdentifier.bestElement;
-    if (selectedElement is! ExecutableElement) {
-      return new RefactoringStatus.fatal(
-          'Method declaration or reference must be selected to activate this refactoring.');
+    Element element = identifier.bestElement;
+    if (element is! ExecutableElement) {
+      return fatalStatus;
     }
-    _methodElement = selectedElement as ExecutableElement;
+    _methodElement = element as ExecutableElement;
+    _isAccessor = element is PropertyAccessorElement;
     _methodFile = _methodElement.source.fullName;
-    _methodUnit = selectedElement.unit;
+    _methodUnit = element.unit;
     _methodUtils = new CorrectionUtils(_methodUnit);
-    if (selectedElement is MethodElement ||
-        selectedElement is PropertyAccessorElement) {
-      MethodDeclaration methodDeclaration =
-          _methodElement.node as MethodDeclaration;
+    // class member
+    bool isClassMember = element.enclosingElement is ClassElement;
+    if (element is MethodElement || _isAccessor && isClassMember) {
+      MethodDeclaration methodDeclaration = element.node;
       _methodNode = methodDeclaration;
       _methodParameters = methodDeclaration.parameters;
       _methodBody = methodDeclaration.body;
       // prepare mode
-      isDeclaration = selectedNode == methodDeclaration.name;
+      isDeclaration = node == methodDeclaration.name;
       deleteSource = isDeclaration;
       inlineAll = deleteSource;
+      return new RefactoringStatus();
     }
-    if (selectedElement is FunctionElement) {
-      FunctionDeclaration functionDeclaration =
-          _methodElement.node as FunctionDeclaration;
+    // unit member
+    bool isUnitMember = element.enclosingElement is CompilationUnitElement;
+    if (element is FunctionElement || _isAccessor && isUnitMember) {
+      FunctionDeclaration functionDeclaration = element.node;
       _methodNode = functionDeclaration;
       _methodParameters = functionDeclaration.functionExpression.parameters;
       _methodBody = functionDeclaration.functionExpression.body;
       // prepare mode
-      isDeclaration = selectedNode == functionDeclaration.name;
+      isDeclaration = node == functionDeclaration.name;
       deleteSource = isDeclaration;
       inlineAll = deleteSource;
+      return new RefactoringStatus();
     }
     // OK
-    return new RefactoringStatus();
+    return fatalStatus;
   }
 
   /**
    * Analyze [_methodBody] to fill [_methodExpressionPart] and
    * [_methodStatementsPart].
    */
   RefactoringStatus _prepareMethodParts() {
     RefactoringStatus result = new RefactoringStatus();
     if (_methodBody is ExpressionFunctionBody) {
       ExpressionFunctionBody body = _methodBody as ExpressionFunctionBody;
@@ skipping 102 matching lines @@
           AstNode parent3 = parent2.parent;
           return parent3 is VariableDeclarationStatement &&
               parent3.parent is Block;
         }
       }
     }
     // not in block, cannot inline body
     return false;
   }
 
-  void _inlineMethodInvocation(RefactoringStatus status, Expression methodUsage,
+  void _inlineMethodInvocation(RefactoringStatus status, Expression usage,
       bool cascaded, Expression target, List<Expression> arguments) {
     // we don't support cascade
     if (cascaded) {
       status.addError(
           'Cannot inline cascade invocation.',
-          new Location.fromNode(methodUsage));
+          new Location.fromNode(usage));
     }
     // can we inline method body into "methodUsage" block?
-    if (_canInlineBody(methodUsage)) {
+    if (_canInlineBody(usage)) {
       // insert non-return statements
       if (ref._methodStatementsPart != null) {
         // prepare statements source for invocation
         String source = _getMethodSourceForInvocation(
             ref._methodStatementsPart,
             _refUtils,
-            methodUsage,
+            usage,
             target,
             arguments);
         source = _refUtils.replaceSourceIndent(
             source,
             ref._methodStatementsPart._prefix,
             _refPrefix);
         // do insert
         SourceRange range = rangeStartLength(_refLineRange, 0);
         SourceEdit edit = new SourceEdit.range(range, source);
         ref.change.addEdit(_refFile, edit);
       }
       // replace invocation with return expression
       if (ref._methodExpressionPart != null) {
         // prepare expression source for invocation
         String source = _getMethodSourceForInvocation(
             ref._methodExpressionPart,
             _refUtils,
-            methodUsage,
+            usage,
             target,
             arguments);
         if (getExpressionPrecedence(ref._methodExpression) <
-            getExpressionParentPrecedence(methodUsage)) {
+            getExpressionParentPrecedence(usage)) {
           source = "(${source})";
         }
         // do replace
-        SourceRange methodUsageRange = rangeNode(methodUsage);
+        SourceRange methodUsageRange = rangeNode(usage);
         SourceEdit edit = new SourceEdit.range(methodUsageRange, source);
         ref.change.addEdit(_refFile, edit);
       } else {
         SourceEdit edit = new SourceEdit.range(_refLineRange, "");
         ref.change.addEdit(_refFile, edit);
       }
       return;
     }
     // inline as closure invocation
     String source;
@@ skipping 31 matching lines @@
     } else {
       // cannot inline reference to method: var v = new A().method;
       if (ref._methodElement is MethodElement) {
         status.addFatalError(
             'Cannot inline class method reference.',
             new Location.fromNode(_node));
         return;
       }
       // PropertyAccessorElement
       if (ref._methodElement is PropertyAccessorElement) {
+        Expression usage = _node;
         Expression target = null;
         bool cascade = false;
         if (nodeParent is PrefixedIdentifier) {
           PrefixedIdentifier propertyAccess = nodeParent;
+          usage = propertyAccess;
           target = propertyAccess.prefix;
           cascade = false;
         }
         if (nodeParent is PropertyAccess) {
           PropertyAccess propertyAccess = nodeParent;
+          usage = propertyAccess;
           target = propertyAccess.realTarget;
           cascade = propertyAccess.isCascaded;
         }
         // prepare arguments
         List<Expression> arguments = [];
         if ((_node as SimpleIdentifier).inSetterContext()) {
-          arguments.add(
-              (nodeParent.parent as AssignmentExpression).rightHandSide);
+          AssignmentExpression assignment;
+          if (nodeParent is AssignmentExpression) {
+            assignment = nodeParent;
+          } else {
+            assignment = nodeParent.parent;

[Brian Wilkerson, 2014/09/12 22:42:31]

Are two levels always enough? Consider using getAncestor instead.

[scheglov, 2014/09/14 03:17:39]

Ah, yes.
Thank you!

+          }
+          arguments.add(assignment.rightHandSide);
         }
         // inline body
-        _inlineMethodInvocation(
-            status,
-            nodeParent as Expression,
-            cascade,
-            target,
-            arguments);
+        _inlineMethodInvocation(status, usage, cascade, target, arguments);
         return;
       }
       // not invocation, just reference to function
       String source;
       {
         source = ref._methodUtils.getRangeText(
             rangeStartEnd(ref._methodParameters.leftParenthesis, ref._methodNode));
         String methodPrefix =
             ref._methodUtils.getLinePrefix(ref._methodNode.offset);
         source =
@@ skipping 198 matching lines @@
   }
 
   void _addVariable(SimpleIdentifier node) {
     VariableElement variableElement = getLocalVariableElement(node);
     if (variableElement != null) {
       SourceRange nodeRange = rangeNode(node);
       result.addVariable(variableElement, nodeRange);
     }
   }
 }