Remove most of the remaining references to AnalysisContext

pkg/analysis_server/lib/src/services/correction/util.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.
 
 import 'dart:math';
 
 import 'package:analysis_server/src/protocol_server.dart'
     show doSourceChange_addElementEdit;
 import 'package:analysis_server/src/services/correction/strings.dart';
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 108 matching lines @@
       if (i == uriList.length - 1) {
         importCode = importCode + desc.suffix;
       }
       doSourceChange_addElementEdit(
           change, targetLibrary, new SourceEdit(offset, 0, importCode));
     }
   }
 }
 
 /**
- * @return <code>true</code> if given [List]s are identical at given position.
- */
-bool allListsIdentical(List<List> lists, int position) {
-  Object element = lists[0][position];
-  for (List list in lists) {
-    if (list[position] != element) {
-      return false;
-    }
-  }
-  return true;
-}
-
-/**
  * Climbs up [PrefixedIdentifier] and [PropertyAccess] nodes that include [node].
  */
 Expression climbPropertyAccess(AstNode node) {
   while (true) {
     AstNode parent = node.parent;
     if (parent is PrefixedIdentifier && parent.identifier == node) {
       node = parent;
       continue;
     }
     if (parent is PropertyAccess && parent.propertyName == node) {
       node = parent;
       continue;
     }
     return node;
   }
 }
 
 /**
- * Returns the EOL to use for the given [code].
- */
-String getCodeEndOfLine(String code) {
-  if (code.contains('\r\n')) {
-    return '\r\n';
-  }
-  return '\n';
-}
-
-/**
  * TODO(scheglov) replace with nodes once there will be [CompilationUnit.getComments].
  *
  * Returns [SourceRange]s of all comments in [unit].
  */
 List<SourceRange> getCommentRanges(CompilationUnit unit) {
   List<SourceRange> ranges = <SourceRange>[];
   Token token = unit.beginToken;
   while (token != null && token.type != TokenType.EOF) {
     Token commentToken = token.precedingComments;
     while (commentToken != null) {
@@ skipping 92 matching lines @@
     if (node is CompilationUnit) {
       return member;
     }
     member = node;
     node = node.parent;
   }
   return null;
 }
 
 /**
- * @return the [ExecutableElement] of the enclosing executable [AstNode].
+ * Return the [ExecutableElement] of the enclosing executable [AstNode].
  */
 ExecutableElement getEnclosingExecutableElement(AstNode node) {
   while (node != null) {
     if (node is FunctionDeclaration) {
       return node.element;
     }
     if (node is ConstructorDeclaration) {
       return node.element;
     }
     if (node is MethodDeclaration) {
       return node.element;
     }
     node = node.parent;
   }
   return null;
 }
 
 /**
- * @return the enclosing executable [AstNode].
+ * Return the enclosing executable [AstNode].
  */
 AstNode getEnclosingExecutableNode(AstNode node) {
   while (node != null) {
     if (node is FunctionDeclaration) {
       return node;
     }
     if (node is ConstructorDeclaration) {
       return node;
     }
     if (node is MethodDeclaration) {
       return node;
     }
     node = node.parent;
   }
   return null;
 }
 
 /**
- * Returns [getExpressionPrecedence] for the parent of [node],
- * or `0` if the parent node is [ParenthesizedExpression].
+ * Returns [getExpressionPrecedence] for the parent of [node], or `0` if the
+ * parent node is a [ParenthesizedExpression].
  *
  * The reason is that `(expr)` is always executed after `expr`.
  */
 int getExpressionParentPrecedence(AstNode node) {
   AstNode parent = node.parent;
   if (parent is ParenthesizedExpression) {
     return 0;
   } else if (parent is IndexExpression && parent.index == node) {
     return 0;
   } else if (parent is AssignmentExpression &&
@@ skipping 55 matching lines @@
     int c = line.codeUnitAt(index);
     if (!isWhitespace(c)) {
       break;
     }
     index++;
   }
   return line.substring(0, index);
 }
 
 /**
- * @return the [LocalVariableElement] or [ParameterElement] if given
- *         [SimpleIdentifier] is the reference to local variable or parameter, or
- *         <code>null</code> in the other case.
- */
-VariableElement getLocalOrParameterVariableElement(SimpleIdentifier node) {
-  Element element = node.staticElement;
-  if (element is LocalVariableElement) {
-    return element;
-  }
-  if (element is ParameterElement) {
-    return element;
-  }
-  return null;
-}
-
-/**
- * @return the [LocalVariableElement] if given [SimpleIdentifier] is the reference to
- *         local variable, or <code>null</code> in the other case.
+ * Return the [LocalVariableElement] if given [node] is a reference to a local
+ * variable, or `null` in the other case.
  */
 LocalVariableElement getLocalVariableElement(SimpleIdentifier node) {
   Element element = node.staticElement;
   if (element is LocalVariableElement) {
     return element;
   }
   return null;
 }
 
 /**
- * @return the nearest common ancestor [AstNode] of the given [AstNode]s.
+ * Return the nearest common ancestor of the given [nodes].
  */
 AstNode getNearestCommonAncestor(List<AstNode> nodes) {
   // may be no nodes
   if (nodes.isEmpty) {
     return null;
   }
   // prepare parents
   List<List<AstNode>> parents = [];
   for (AstNode node in nodes) {
     parents.add(getParents(node));
   }
   // find min length
   int minLength = 1 << 20;
   for (List<AstNode> parentList in parents) {
     minLength = min(minLength, parentList.length);
   }
   // find deepest parent
   int i = 0;
   for (; i < minLength; i++) {
-    if (!allListsIdentical(parents, i)) {
+    if (!_allListsIdentical(parents, i)) {
       break;
     }
   }
   return parents[0][i - 1];
 }
 
 /**
- * Returns the [Expression] qualifier if given node is the name part of a
+ * Returns the [Expression] qualifier if given [node] is the name part of a
  * [PropertyAccess] or a [PrefixedIdentifier]. Maybe `null`.
  */
 Expression getNodeQualifier(SimpleIdentifier node) {
   AstNode parent = node.parent;
   if (parent is MethodInvocation && identical(parent.methodName, node)) {
     return parent.target;
   }
   if (parent is PropertyAccess && identical(parent.propertyName, node)) {
     return parent.target;
   }
   if (parent is PrefixedIdentifier && identical(parent.identifier, node)) {
     return parent.prefix;
   }
   return null;
 }
 
 /**
- * Returns the [ParameterElement] if the given [SimpleIdentifier] is a reference
- * to a parameter, or `null` in the other case.
+ * Returns the [ParameterElement] if the given [node] is a reference to a
+ * parameter, or `null` in the other case.
  */
 ParameterElement getParameterElement(SimpleIdentifier node) {
   Element element = node.staticElement;
   if (element is ParameterElement) {
     return element;
   }
   return null;
 }
 
 /**
- * @return parent [AstNode]s from [CompilationUnit] (at index "0") to the given one.
+ * Return parent [AstNode]s from compilation unit (at index "0") to the given
+ * [node].
  */
 List<AstNode> getParents(AstNode node) {
   // prepare number of parents
   int numParents = 0;
   {
     AstNode current = node.parent;
     while (current != null) {
       numParents++;
       current = current.parent;
     }
@@ skipping 37 matching lines @@
   AnalysisContext context = unitElement.context;
   Source source = unitElement.source;
   CompilationUnit unit = context.parseCompilationUnit(source);
   if (unit.element == null) {
     unit.element = unitElement;
   }
   return unit;
 }
 
 /**
- * Returns a [PropertyAccessorElement] if the given [SimpleIdentifier] is a
- * reference to a property, or `null` in the other case.
- */
-PropertyAccessorElement getPropertyAccessorElement(SimpleIdentifier node) {
-  Element element = node.staticElement;
-  if (element is PropertyAccessorElement) {
-    return element;
-  }
-  return null;
-}
-
-/**
- * If given [AstNode] is name of qualified property extraction, returns target from which
- * this property is extracted. Otherwise `null`.
+ * If given [node] is name of qualified property extraction, returns target from
+ * which this property is extracted, otherwise `null`.
  */
 Expression getQualifiedPropertyTarget(AstNode node) {
   AstNode parent = node.parent;
   if (parent is PrefixedIdentifier) {
     PrefixedIdentifier prefixed = parent;
     if (prefixed.identifier == node) {
       return parent.prefix;
     }
   }
   if (parent is PropertyAccess) {
     PropertyAccess access = parent;
     if (access.propertyName == node) {
       return access.realTarget;
     }
   }
   return null;
 }
 
 /**
- * Returns the given [Statement] if not a [Block], or the first child
- * [Statement] if a [Block], or `null` if more than one child.
+ * Returns the given [statement] if not a block, or the first child statement if
+ * a block, or `null` if more than one child.
  */
 Statement getSingleStatement(Statement statement) {
   if (statement is Block) {
     List<Statement> blockStatements = statement.statements;
     if (blockStatements.length != 1) {
       return null;
     }
     return blockStatements[0];
   }
   return statement;
 }
 
 /**
- * Returns the [String] content of the given [Source].
- */
-String getSourceContent(AnalysisContext context, Source source) {
-  return context.getContents(source).data;
-}
-
-/**
- * Returns the given [Statement] if not a [Block], or all the children
- * [Statement]s if a [Block].
+ * Returns the given [statement] if not a block, or all the children statements
+ * if a block.
  */
 List<Statement> getStatements(Statement statement) {
   if (statement is Block) {
     return statement.statements;
   }
   return [statement];
 }
 
 /**
- * Checks if the given [Element]'s display name equals to the given name.
+ * Checks if the given [element]'s display name equals to the given [name].
  */
 bool hasDisplayName(Element element, String name) {
   if (element == null) {
     return false;
   }
   return element.displayName == name;
 }
 
 /**
- * Checks if the given [PropertyAccessorElement] is an accessor of a
- * [FieldElement].
- */
-bool isFieldAccessorElement(PropertyAccessorElement accessor) {
-  return accessor != null && accessor.variable is FieldElement;
-}
-
-/**
  * Checks if given [DartNode] is the left hand side of an assignment, or a
  * declaration of a variable.
  */
 bool isLeftHandOfAssignment(SimpleIdentifier node) {
   if (node.inSetterContext()) {
     return true;
   }
   return node.parent is VariableDeclaration &&
       (node.parent as VariableDeclaration).name == node;
 }
 
 /**
- * @return `true` if the given [SimpleIdentifier] is the name of the
- *         [NamedExpression].
+ * Return `true` if the given [node] is the name of a [NamedExpression].
  */
 bool isNamedExpressionName(SimpleIdentifier node) {
   AstNode parent = node.parent;
   if (parent is Label) {
     Label label = parent;
     if (identical(label.label, node)) {
       AstNode parent2 = label.parent;
       if (parent2 is NamedExpression) {
         return identical(parent2.name, label);
       }
     }
   }
   return false;
 }
 
 /**
  * If the given [expression] is the `expression` property of a [NamedExpression]
- * then returns this [NamedExpression]. Otherwise returns [expression].
+ * then returns this [NamedExpression], otherwise returns [expression].
  */
 Expression stepUpNamedExpression(Expression expression) {
   if (expression != null) {
     AstNode parent = expression.parent;
     if (parent is NamedExpression && parent.expression == expression) {
       return parent;
     }
   }
   return expression;
 }
 
 /**
+ * Return `true` if the given [lists] are identical at the given [position].
+ */
+bool _allListsIdentical(List<List> lists, int position) {
+  Object element = lists[0][position];
+  for (List list in lists) {
+    if (list[position] != element) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/**
  * This exception is thrown to cancel the current correction operation,
  * such as quick assist or quick fix because an inconsistency was detected.
  * These inconsistencies may happen as a part of normal workflow, e.g. because
  * a resource was deleted, or an analysis result was invalidated.
  */
 class CancelCorrectionException {
   final Object exception;
   CancelCorrectionException({this.exception});
 }
 
@@ skipping 877 matching lines @@
   @override
   visitSimpleIdentifier(SimpleIdentifier node) {
     if (node.inDeclarationContext()) {
       Element element = node.staticElement;
       if (element is LocalElement) {
         elements.add(element);
       }
     }
   }
 }