Simplify rules for extracting getters.

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 161 matching lines @@
       return new Future.value(result);
     }
     // prepare parts
     result.addStatus(_initializeParameters());
     _initializeReturnType();
     // occurrences
     _initializeOccurrences();
     _prepareOffsetsLengths();
     // getter
     canCreateGetter = _computeCanCreateGetter();
-    _initializeCreateGetter();
+    createGetter =
+        canCreateGetter && _isExpressionForGetter(_selectionExpression);
     // names
     _prepareExcludedNames();
     _prepareNames();
     // closure cannot have parameters
     if (_selectionFunctionExpression != null && !_parameters.isEmpty) {
       String message = format(
           'Cannot extract closure as method, it references {0} external variable(s).',
           _parameters.length);
       RefactoringStatus result = new RefactoringStatus.fatal(message);
       return new Future.value(result);
@@ skipping 323 matching lines @@
     String source = SourceEdit.applySequence(originalSource, replaceEdits);
     pattern.normalizedSource = _getNormalizedSource(source);
     return pattern;
   }
 
   String _getTypeCode(DartType type) {
     return utils.getTypeSource(type, librariesToImport);
   }
 
   /**
-   * Initializes [createGetter] flag.
-   */
-  void _initializeCreateGetter() {
-    createGetter = false;
-    // maybe we cannot at all
-    if (!canCreateGetter) {
-      return;
-    }
-    // OK, just expression
-    if (_selectionExpression != null) {
-      createGetter = !_hasMethodInvocation(_selectionExpression);
-      return;
-    }
-    // allow code blocks without cycles
-    if (_selectionStatements != null) {
-      createGetter = true;
-      for (Statement statement in _selectionStatements) {
-        // method invocation is something heavy,
-        // so we don't want to extract it as a part of a getter
-        if (_hasMethodInvocation(statement)) {
-          createGetter = false;
-          return;
-        }
-        // don't allow cycles
-        statement.accept(new _ResetCanCreateGetterVisitor(this));
-      }
-    }
-  }
-
-  /**
    * Fills [_occurrences] field.
    */
   void _initializeOccurrences() {
     _occurrences.clear();
     // prepare selection
     _SourcePattern selectionPattern = _getSourcePattern(selectionRange);
     Map<String, String> patternToSelectionName =
         _inverseMap(selectionPattern.originalToPatternNames);
     // prepare an enclosing parent - class or unit
     AstNode enclosingMemberParent = _parentMember.parent;
@@ skipping 133 matching lines @@
   void _prepareOffsetsLengths() {
     offsets.clear();
     lengths.clear();
     for (_Occurrence occurrence in _occurrences) {
       offsets.add(occurrence.range.offset);
       lengths.add(occurrence.range.length);
     }
   }
 
   /**
-   * Checks if [node] has a [MethodInvocation].
+   * Checks if the given [expression] is reasonable to extract as a getter.
    */
-  static bool _hasMethodInvocation(AstNode node) {
-    var visitor = new _HasMethodInvocationVisitor();
-    node.accept(visitor);
-    return visitor.result;
+  static bool _isExpressionForGetter(Expression expression) {
+    if (expression is BinaryExpression) {
+      return _isExpressionForGetter(expression.leftOperand) &&
+          _isExpressionForGetter(expression.rightOperand);
+    }
+    if (expression is Literal) {
+      return true;
+    }
+    if (expression is PrefixExpression) {
+      return _isExpressionForGetter(expression.operand);
+    }
+    if (expression is PrefixedIdentifier) {
+      return _isExpressionForGetter(expression.prefix);
+    }
+    if (expression is PropertyAccess) {
+      return _isExpressionForGetter(expression.target);
+    }
+    if (expression is SimpleIdentifier) {
+      return true;
+    }
+    return false;
   }
 
   /**
    * Returns `true` if the given [statement] may end with a [ReturnStatement].
    */
   static bool _mayEndWithReturnStatement(Statement statement) {
     _HasReturnStatementVisitor visitor = new _HasReturnStatementVisitor();
     statement.accept(visitor);
     return visitor.hasReturn;
   }
@@ skipping 135 matching lines @@
           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 _HasReturnStatementVisitor extends RecursiveAstVisitor {
   bool hasReturn = false;
 
   @override
   visitBlockFunctionBody(BlockFunctionBody node) {}
 
   @override
   visitReturnStatement(ReturnStatement node) {
     hasReturn = true;
   }
@@ skipping 65 matching lines @@
       return false;
     }
     // prepare node source
     _SourcePattern nodePattern = ref._getSourcePattern(nodeRange);
     // if matches normalized node source, then add as occurrence
     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) {
+      nodePattern.originalToPatternNames
+          .forEach((String originalName, String patternName) {
         String selectionName = patternToSelectionName[patternName];
         occurrence._parameterOldToOccurrenceName[selectionName] = originalName;
       });
       // update static
       if (forceStatic) {
         ref._staticContext = true;
       }
       // we have match
       return true;
     }
@@ skipping 96 matching lines @@
  */
 class _Occurrence {
   final SourceRange range;
   final bool isSelection;
 
   Map<String, String> _parameterOldToOccurrenceName = <String, String>{};
 
   _Occurrence(this.range, this.isSelection);
 }
 
-class _ResetCanCreateGetterVisitor extends RecursiveAstVisitor {
-  final ExtractMethodRefactoringImpl ref;
-
-  _ResetCanCreateGetterVisitor(this.ref);
-
-  @override
-  visitDoStatement(DoStatement node) {
-    ref.createGetter = false;
-    super.visitDoStatement(node);
-  }
-
-  @override
-  visitForEachStatement(ForEachStatement node) {
-    ref.createGetter = false;
-    super.visitForEachStatement(node);
-  }
-
-  @override
-  visitForStatement(ForStatement node) {
-    ref.createGetter = false;
-    super.visitForStatement(node);
-  }
-
-  @override
-  visitWhileStatement(WhileStatement node) {
-    ref.createGetter = false;
-    super.visitWhileStatement(node);
-  }
-}
-
 class _ReturnTypeComputer extends RecursiveAstVisitor {
   DartType returnType;
 
   @override
   visitBlockFunctionBody(BlockFunctionBody node) {}
 
   @override
   visitReturnStatement(ReturnStatement node) {
     // prepare expression
     Expression expression = node.expression;
@@ skipping 36 matching lines @@
       return false;
     }
     for (int i = 0; i < parameterTypes.length; i++) {
       if (other.parameterTypes[i] != parameterTypes[i]) {
         return false;
       }
     }
     return true;
   }
 }