| Index: pkg/analysis_services/lib/src/generated/util.dart
|
| diff --git a/pkg/analysis_services/lib/src/generated/util.dart b/pkg/analysis_services/lib/src/generated/util.dart
|
| deleted file mode 100644
|
| index fdfb01bf22d2ef7318a3fdf39c7333b189ad952f..0000000000000000000000000000000000000000
|
| --- a/pkg/analysis_services/lib/src/generated/util.dart
|
| +++ /dev/null
|
| @@ -1,2437 +0,0 @@
|
| -// 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.
|
| -
|
| -// This code was auto-generated, is not intended to be edited, and is subject to
|
| -// significant change. Please see the README file for more information.
|
| -
|
| -library services.util;
|
| -
|
| -import 'dart:collection';
|
| -import 'package:analyzer/src/generated/java_core.dart' hide StringUtils;
|
| -import 'package:analyzer/src/generated/ast.dart';
|
| -import 'package:analyzer/src/generated/element.dart';
|
| -import 'package:analyzer/src/generated/engine.dart';
|
| -import 'package:analyzer/src/generated/error.dart';
|
| -import 'package:analyzer/src/generated/resolver.dart';
|
| -import 'package:analyzer/src/generated/source.dart';
|
| -import 'package:analyzer/src/generated/scanner.dart';
|
| -import 'change.dart';
|
| -import 'proposal.dart';
|
| -import 'status.dart';
|
| -import 'stubs.dart';
|
| -
|
| -/**
|
| - * Context for which assistance should be provided.
|
| - */
|
| -class AssistContext {
|
| - final SearchEngine searchEngine;
|
| -
|
| - final AnalysisContext analysisContext;
|
| -
|
| - final String analysisContextId;
|
| -
|
| - final Source source;
|
| -
|
| - final CompilationUnit compilationUnit;
|
| -
|
| - final int selectionOffset;
|
| -
|
| - final int selectionLength;
|
| -
|
| - AstNode _coveredNode;
|
| -
|
| - AstNode _coveringNode;
|
| -
|
| - Element _coveredElement;
|
| -
|
| - bool _coveredElementFound = false;
|
| -
|
| - AssistContext.con1(this.searchEngine, this.analysisContext, this.analysisContextId, this.source, this.compilationUnit, this.selectionOffset, this.selectionLength);
|
| -
|
| - AssistContext.con2(SearchEngine searchEngine, AnalysisContext analysisContext, String analysisContextId, Source source, CompilationUnit compilationUnit, SourceRange selectionRange) : this.con1(searchEngine, analysisContext, analysisContextId, source, compilationUnit, selectionRange.offset, selectionRange.length);
|
| -
|
| - /**
|
| - * @return the resolved [CompilationUnitElement] of the [Source].
|
| - */
|
| - CompilationUnitElement get compilationUnitElement => compilationUnit.element;
|
| -
|
| - /**
|
| - * @return the [Element] of the [coveredNode], may be <code>null</code>.
|
| - */
|
| - Element get coveredElement {
|
| - if (!_coveredElementFound) {
|
| - _coveredElementFound = true;
|
| - AstNode coveredNode = this.coveredNode;
|
| - if (coveredNode == null) {
|
| - return null;
|
| - }
|
| - _coveredElement = ElementLocator.locateWithOffset(coveredNode, selectionOffset);
|
| - }
|
| - return _coveredElement;
|
| - }
|
| -
|
| - /**
|
| - * @return the [AstNode] that is covered by the selection.
|
| - */
|
| - AstNode get coveredNode {
|
| - if (_coveredNode == null) {
|
| - NodeLocator locator = new NodeLocator.con2(selectionOffset, selectionOffset);
|
| - _coveredNode = locator.searchWithin(compilationUnit);
|
| - }
|
| - return _coveredNode;
|
| - }
|
| -
|
| - /**
|
| - * @return the ASTNode that covers the selection.
|
| - */
|
| - AstNode get coveringNode {
|
| - if (_coveringNode == null) {
|
| - NodeLocator locator = new NodeLocator.con2(selectionOffset, selectionOffset + selectionLength);
|
| - _coveringNode = locator.searchWithin(compilationUnit);
|
| - }
|
| - return _coveringNode;
|
| - }
|
| -
|
| - /**
|
| - * @return the errors associated with the [Source].
|
| - */
|
| - List<AnalysisError> get errors {
|
| - Source source = this.source;
|
| - if (analysisContext == null || source == null) {
|
| - return AnalysisError.NO_ERRORS;
|
| - }
|
| - return analysisContext.getErrors(source).errors;
|
| - }
|
| -
|
| - /**
|
| - * @return the [SourceRange] of the selection.
|
| - */
|
| - SourceRange get selectionRange => new SourceRange(selectionOffset, selectionLength);
|
| -}
|
| -
|
| -/**
|
| - * Utilities for analyzing [CompilationUnit], its parts and source.
|
| - */
|
| -class CorrectionUtils {
|
| - /**
|
| - * If `true` then [addEdit] validates that
|
| - * [Edit] replaces correct part of the [Source].
|
| - */
|
| - static bool _DEBUG_VALIDATE_EDITS = true;
|
| -
|
| - static List<String> _KNOWN_METHOD_NAME_PREFIXES = ["get", "is", "to"];
|
| -
|
| - /**
|
| - * Validates that the [Edit] replaces the expected part of the [Source] and adds this
|
| - * [Edit] to the [SourceChange].
|
| - */
|
| - static void addEdit(AnalysisContext context, SourceChange change, String description, String expected, Edit edit) {
|
| - if (_DEBUG_VALIDATE_EDITS) {
|
| - Source source = change.source;
|
| - String sourceContent = getSourceContent(context, source);
|
| - // prepare range
|
| - int beginIndex = edit.offset;
|
| - int endIndex = beginIndex + edit.length;
|
| - int sourceLength = sourceContent.length;
|
| - if (beginIndex >= sourceLength || endIndex >= sourceLength) {
|
| - throw new IllegalStateException("${source} has ${sourceLength} characters but ${beginIndex} to ${endIndex} requested.\n\nTry to use Tools | Reanalyze Sources.");
|
| - }
|
| - // check that range has expected content
|
| - String rangeContent = sourceContent.substring(beginIndex, endIndex);
|
| - if (rangeContent != expected) {
|
| - throw new IllegalStateException("${source} expected |${expected}| at ${beginIndex} to ${endIndex} but |${rangeContent}| found.\n\nTry to use Tools | Reanalyze Sources.");
|
| - }
|
| - }
|
| - // do add the Edit
|
| - change.addEdit(edit, description);
|
| - }
|
| -
|
| - /**
|
| - * @return <code>true</code> if given [List]s are equals at given position.
|
| - */
|
| - static bool allListsEqual(List<List> lists, int position) {
|
| - Object element = lists[0][position];
|
| - for (List list in lists) {
|
| - if (!identical(list[position], element)) {
|
| - return false;
|
| - }
|
| - }
|
| - return true;
|
| - }
|
| -
|
| - /**
|
| - * @return the updated [String] with applied [Edit]s.
|
| - */
|
| - static String applyReplaceEdits(String s, List<Edit> edits) {
|
| - // sort edits
|
| - edits = [];
|
| - edits.sort((Edit o1, Edit o2) => o1.offset - o2.offset);
|
| - // apply edits
|
| - int delta = 0;
|
| - for (Edit edit in edits) {
|
| - int editOffset = edit.offset + delta;
|
| - String beforeEdit = s.substring(0, editOffset);
|
| - String afterEdit = s.substring(editOffset + edit.length);
|
| - s = "${beforeEdit}${edit.replacement}${afterEdit}";
|
| - delta += getDeltaOffset(edit);
|
| - }
|
| - // done
|
| - return s;
|
| - }
|
| -
|
| - /**
|
| - * @return <code>true</code> if given [SourceRange] covers given [AstNode].
|
| - */
|
| - static bool covers(SourceRange r, AstNode node) {
|
| - SourceRange nodeRange = SourceRangeFactory.rangeNode(node);
|
| - return r.covers(nodeRange);
|
| - }
|
| -
|
| - /**
|
| - * @return all direct children of the given [Element].
|
| - */
|
| - static List<Element> getChildren(Element parent) => getChildren2(parent, null);
|
| -
|
| - /**
|
| - * @param name the required name of children; may be <code>null</code> to get children with any
|
| - * name.
|
| - * @return all direct children of the given [Element], with given name.
|
| - */
|
| - static List<Element> getChildren2(Element parent, String name) {
|
| - List<Element> children = [];
|
| - parent.accept(new GeneralizingElementVisitor_CorrectionUtils_getChildren(parent, name, children));
|
| - return children;
|
| - }
|
| -
|
| - static String getDefaultValueCode(DartType type) {
|
| - if (type != null) {
|
| - String typeName = type.displayName;
|
| - if (typeName == "bool") {
|
| - return "false";
|
| - }
|
| - if (typeName == "int") {
|
| - return "0";
|
| - }
|
| - if (typeName == "double") {
|
| - return "0.0";
|
| - }
|
| - if (typeName == "String") {
|
| - return "''";
|
| - }
|
| - }
|
| - // no better guess
|
| - return "null";
|
| - }
|
| -
|
| - /**
|
| - * @return the number of characters this [Edit] will move offsets after its range.
|
| - */
|
| - static int getDeltaOffset(Edit edit) => edit.replacement.length - edit.length;
|
| -
|
| - /**
|
| - * @return the name of the [Element] kind.
|
| - */
|
| - static String getElementKindName(Element element) {
|
| - ElementKind kind = element.kind;
|
| - return getElementKindName2(kind);
|
| - }
|
| -
|
| - /**
|
| - * @return the display name of the [ElementKind].
|
| - */
|
| - static String getElementKindName2(ElementKind kind) => kind.displayName;
|
| -
|
| - /**
|
| - * @return the human name of the [Element].
|
| - */
|
| - static String getElementQualifiedName(Element element) {
|
| - ElementKind kind = element.kind;
|
| - while (true) {
|
| - if (kind == ElementKind.FIELD || kind == ElementKind.METHOD) {
|
| - return "${element.enclosingElement.displayName}.${element.displayName}";
|
| - } else {
|
| - return element.displayName;
|
| - }
|
| - break;
|
| - }
|
| - }
|
| -
|
| - /**
|
| - * @return the [ExecutableElement] of the enclosing executable [AstNode].
|
| - */
|
| - static 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].
|
| - */
|
| - static 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;
|
| - }
|
| -
|
| - /**
|
| - * @return [Element] exported from the given [LibraryElement].
|
| - */
|
| - static Element getExportedElement(LibraryElement library, String name) {
|
| - if (library == null) {
|
| - return null;
|
| - }
|
| - return getExportNamespace2(library)[name];
|
| - }
|
| -
|
| - /**
|
| - * TODO(scheglov) may be replace with some API for this
|
| - *
|
| - * @return the namespace of the given [ExportElement].
|
| - */
|
| - static Map<String, Element> getExportNamespace(ExportElement exp) {
|
| - Namespace namespace = new NamespaceBuilder().createExportNamespaceForDirective(exp);
|
| - return namespace.definedNames;
|
| - }
|
| -
|
| - /**
|
| - * TODO(scheglov) may be replace with some API for this
|
| - *
|
| - * @return the export namespace of the given [LibraryElement].
|
| - */
|
| - static Map<String, Element> getExportNamespace2(LibraryElement library) {
|
| - Namespace namespace = new NamespaceBuilder().createExportNamespaceForLibrary(library);
|
| - return namespace.definedNames;
|
| - }
|
| -
|
| - /**
|
| - * @return [getExpressionPrecedence] for parent node, or `0` if parent node
|
| - * is [ParenthesizedExpression]. The reason is that `(expr)` is always
|
| - * executed after `expr`.
|
| - */
|
| - static int getExpressionParentPrecedence(AstNode node) {
|
| - AstNode parent = node.parent;
|
| - if (parent is ParenthesizedExpression) {
|
| - return 0;
|
| - }
|
| - return getExpressionPrecedence(parent);
|
| - }
|
| -
|
| - /**
|
| - * @return the precedence of the given node - result of [Expression#getPrecedence] if an
|
| - * [Expression], negative otherwise.
|
| - */
|
| - static int getExpressionPrecedence(AstNode node) {
|
| - if (node is Expression) {
|
| - return node.precedence;
|
| - }
|
| - return -1000;
|
| - }
|
| -
|
| - /**
|
| - * TODO(scheglov) may be replace with some API for this
|
| - *
|
| - * @return the namespace of the given [ImportElement].
|
| - */
|
| - static Map<String, Element> getImportNamespace(ImportElement imp) {
|
| - Namespace namespace = new NamespaceBuilder().createImportNamespaceForDirective(imp);
|
| - return namespace.definedNames;
|
| - }
|
| -
|
| - /**
|
| - * @return all [CompilationUnitElement] the given [LibraryElement] consists of.
|
| - */
|
| - static List<CompilationUnitElement> getLibraryUnits(LibraryElement library) {
|
| - List<CompilationUnitElement> units = [];
|
| - units.add(library.definingCompilationUnit);
|
| - units.addAll(library.parts);
|
| - return units;
|
| - }
|
| -
|
| - /**
|
| - * @return the line prefix from the given source, i.e. basically just whitespace prefix of the
|
| - * given [String].
|
| - */
|
| - static String getLinesPrefix(String lines) {
|
| - int index = 0;
|
| - while (index < lines.length) {
|
| - int c = lines.codeUnitAt(index);
|
| - if (!Character.isWhitespace(c)) {
|
| - break;
|
| - }
|
| - index++;
|
| - }
|
| - return lines.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.
|
| - */
|
| - static 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.
|
| - */
|
| - static 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.
|
| - */
|
| - static 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 = 2147483647;
|
| - for (List<AstNode> parentList in parents) {
|
| - minLength = Math.min(minLength, parentList.length);
|
| - }
|
| - // find deepest parent
|
| - int i = 0;
|
| - for (; i < minLength; i++) {
|
| - if (!allListsEqual(parents, i)) {
|
| - break;
|
| - }
|
| - }
|
| - return parents[0][i - 1];
|
| - }
|
| -
|
| - /**
|
| - * @return the [Expression] qualified if given node is name part of a [PropertyAccess]
|
| - * or [PrefixedIdentifier]. May be <code>null</code>.
|
| - */
|
| - static Expression getNodeQualifier(SimpleIdentifier node) {
|
| - AstNode parent = node.parent;
|
| - if (parent is PropertyAccess) {
|
| - PropertyAccess propertyAccess = parent;
|
| - if (identical(propertyAccess.propertyName, node)) {
|
| - return propertyAccess.target;
|
| - }
|
| - }
|
| - if (parent is PrefixedIdentifier) {
|
| - PrefixedIdentifier prefixed = parent;
|
| - if (identical(prefixed.identifier, node)) {
|
| - return prefixed.prefix;
|
| - }
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - /**
|
| - * @return the [ParameterElement] if given [SimpleIdentifier] is the reference to
|
| - * parameter, or <code>null</code> in the other case.
|
| - */
|
| - static ParameterElement getParameterElement(SimpleIdentifier node) {
|
| - Element element = node.staticElement;
|
| - if (element is ParameterElement) {
|
| - return element;
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - /**
|
| - * @return the precedence of the given [Expression] parent. May be `-1` no operator.
|
| - * @see #getPrecedence(Expression)
|
| - */
|
| - static int getParentPrecedence(Expression expression) {
|
| - AstNode parent = expression.parent;
|
| - if (parent is Expression) {
|
| - return getPrecedence(parent);
|
| - }
|
| - return -1;
|
| - }
|
| -
|
| - /**
|
| - * @return parent [AstNode]s from [CompilationUnit] (at index "0") to the given one.
|
| - */
|
| - static List<AstNode> getParents(AstNode node) {
|
| - // prepare number of parents
|
| - int numParents = 0;
|
| - {
|
| - AstNode current = node.parent;
|
| - while (current != null) {
|
| - numParents++;
|
| - current = current.parent;
|
| - }
|
| - }
|
| - // fill array of parents
|
| - List<AstNode> parents = new List<AstNode>(numParents);
|
| - AstNode current = node.parent;
|
| - int index = numParents;
|
| - while (current != null) {
|
| - parents[--index] = current;
|
| - current = current.parent;
|
| - }
|
| - return JavaArrays.asList(parents);
|
| - }
|
| -
|
| - /**
|
| - * @return the precedence of the given [Expression] operator. May be
|
| - * `Integer#MAX_VALUE` if not an operator.
|
| - */
|
| - static int getPrecedence(Expression expression) {
|
| - if (expression is BinaryExpression) {
|
| - BinaryExpression binaryExpression = expression;
|
| - return binaryExpression.operator.type.precedence;
|
| - }
|
| - if (expression is PrefixExpression) {
|
| - PrefixExpression prefixExpression = expression;
|
| - return prefixExpression.operator.type.precedence;
|
| - }
|
| - if (expression is PostfixExpression) {
|
| - PostfixExpression postfixExpression = expression;
|
| - return postfixExpression.operator.type.precedence;
|
| - }
|
| - return 2147483647;
|
| - }
|
| -
|
| - /**
|
| - * @return the [PropertyAccessorElement] if given [SimpleIdentifier] is the reference
|
| - * to property, or <code>null</code> in the other case.
|
| - */
|
| - static 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`.
|
| - */
|
| - static Expression getQualifiedPropertyTarget(AstNode node) {
|
| - AstNode parent = node.parent;
|
| - if (parent is PrefixedIdentifier) {
|
| - PrefixedIdentifier prefixed = parent;
|
| - if (identical(prefixed.identifier, node)) {
|
| - return parent.prefix;
|
| - }
|
| - }
|
| - if (parent is PropertyAccess) {
|
| - PropertyAccess access = parent;
|
| - if (identical(access.propertyName, node)) {
|
| - return access.realTarget;
|
| - }
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - /**
|
| - * Returns the name of the file which corresponds to the name of the class according to the style
|
| - * guide. However class does not have to be in this file.
|
| - */
|
| - static String getRecommentedFileNameForClass(String className) {
|
| - int len = className.length;
|
| - JavaStringBuilder sb = new JavaStringBuilder();
|
| - bool prevWasUpper = false;
|
| - for (int i = 0; i < len; i++) {
|
| - int c = className.codeUnitAt(i);
|
| - if (Character.isUpperCase(c)) {
|
| - bool nextIsUpper = i < len - 1 && Character.isUpperCase(className.codeUnitAt(i + 1));
|
| - if (i == 0) {
|
| - } else if (prevWasUpper) {
|
| - // HTTPServer
|
| - // ^
|
| - if (!nextIsUpper) {
|
| - sb.appendChar(0x5F);
|
| - }
|
| - } else {
|
| - // HttpServer
|
| - // ^
|
| - sb.appendChar(0x5F);
|
| - }
|
| - prevWasUpper = true;
|
| - c = Character.toLowerCase(c);
|
| - } else {
|
| - prevWasUpper = false;
|
| - }
|
| - sb.appendChar(c);
|
| - }
|
| - sb.append(".dart");
|
| - String fileName = sb.toString();
|
| - return fileName;
|
| - }
|
| -
|
| - /**
|
| - * @return given [Statement] if not [Block], first child [Statement] if
|
| - * [Block], or <code>null</code> if more than one child.
|
| - */
|
| - static Statement getSingleStatement(Statement statement) {
|
| - if (statement is Block) {
|
| - List<Statement> blockStatements = statement.statements;
|
| - if (blockStatements.length != 1) {
|
| - return null;
|
| - }
|
| - return blockStatements[0];
|
| - }
|
| - return statement;
|
| - }
|
| -
|
| - /**
|
| - * @return the [String] content of the given [Source].
|
| - */
|
| - static String getSourceContent(AnalysisContext context, Source source) => context.getContents(source).data.toString();
|
| -
|
| - /**
|
| - * @return given [Statement] if not [Block], all children [Statement]s if
|
| - * [Block].
|
| - */
|
| - static List<Statement> getStatements(Statement statement) {
|
| - if (statement is Block) {
|
| - return statement.statements;
|
| - }
|
| - return [];
|
| - }
|
| -
|
| - /**
|
| - * @return all top-level elements declared in the given [LibraryElement].
|
| - */
|
| - static List<Element> getTopLevelElements(LibraryElement library) {
|
| - List<Element> elements = [];
|
| - List<CompilationUnitElement> units = getLibraryUnits(library);
|
| - for (CompilationUnitElement unit in units) {
|
| - elements.addAll(unit.functions);
|
| - elements.addAll(unit.functionTypeAliases);
|
| - elements.addAll(unit.types);
|
| - elements.addAll(unit.topLevelVariables);
|
| - }
|
| - return elements;
|
| - }
|
| -
|
| - /**
|
| - * @return the possible names for variable with initializer of the given [StringLiteral].
|
| - */
|
| - static List<String> getVariableNameSuggestions(String text, Set<String> excluded) {
|
| - // filter out everything except of letters and white spaces
|
| - {
|
| - JavaStringBuilder sb = new JavaStringBuilder();
|
| - for (int i = 0; i < text.length; i++) {
|
| - int c = text.codeUnitAt(i);
|
| - if (Character.isLetter(c) || Character.isWhitespace(c)) {
|
| - sb.appendChar(c);
|
| - }
|
| - }
|
| - text = sb.toString();
|
| - }
|
| - // make single camel-case text
|
| - {
|
| - List<String> words = StringUtils.split(text);
|
| - JavaStringBuilder sb = new JavaStringBuilder();
|
| - for (int i = 0; i < words.length; i++) {
|
| - String word = words[i];
|
| - if (i > 0) {
|
| - word = StringUtils.capitalize(word);
|
| - }
|
| - sb.append(word);
|
| - }
|
| - text = sb.toString();
|
| - }
|
| - // split camel-case into separate suggested names
|
| - Set<String> res = new LinkedHashSet();
|
| - _addAll(excluded, res, _getVariableNameSuggestions(text));
|
| - return new List.from(res);
|
| - }
|
| -
|
| - /**
|
| - * @return the possible names for variable with given expected type and expression.
|
| - */
|
| - static List<String> getVariableNameSuggestions2(DartType expectedType, Expression assignedExpression, Set<String> excluded) {
|
| - Set<String> res = new LinkedHashSet();
|
| - // use expression
|
| - if (assignedExpression != null) {
|
| - String nameFromExpression = _getBaseNameFromExpression(assignedExpression);
|
| - if (nameFromExpression != null) {
|
| - nameFromExpression = StringUtils.removeStart(nameFromExpression, "_");
|
| - _addAll(excluded, res, _getVariableNameSuggestions(nameFromExpression));
|
| - }
|
| - String nameFromParent = _getBaseNameFromLocationInParent(assignedExpression);
|
| - if (nameFromParent != null) {
|
| - _addAll(excluded, res, _getVariableNameSuggestions(nameFromParent));
|
| - }
|
| - }
|
| - // use type
|
| - if (expectedType != null && !expectedType.isDynamic) {
|
| - String typeName = expectedType.name;
|
| - if ("int" == typeName) {
|
| - _addSingleCharacterName(excluded, res, 0x69);
|
| - } else if ("double" == typeName) {
|
| - _addSingleCharacterName(excluded, res, 0x64);
|
| - } else if ("String" == typeName) {
|
| - _addSingleCharacterName(excluded, res, 0x73);
|
| - } else {
|
| - _addAll(excluded, res, _getVariableNameSuggestions(typeName));
|
| - }
|
| - res.remove(typeName);
|
| - }
|
| - // done
|
| - return new List.from(res);
|
| - }
|
| -
|
| - /**
|
| - * @return `true` if the given [Element#getDisplayName] equals to the given name.
|
| - */
|
| - static bool hasDisplayName(Element element, String name) {
|
| - if (element == null) {
|
| - return false;
|
| - }
|
| - String elementDisplayName = element.displayName;
|
| - return StringUtils.equals(elementDisplayName, name);
|
| - }
|
| -
|
| - /**
|
| - * @return `true` if the given [Element#getName] equals to the given name.
|
| - */
|
| - static bool hasName(Element element, String name) {
|
| - if (element == null) {
|
| - return false;
|
| - }
|
| - String elementName = element.name;
|
| - return StringUtils.equals(elementName, name);
|
| - }
|
| -
|
| - /**
|
| - * @return `true` if the given [SimpleIdentifier] is the name of the
|
| - * [NamedExpression].
|
| - */
|
| - static 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;
|
| - }
|
| -
|
| - /**
|
| - * Adds "toAdd" items which are not excluded.
|
| - */
|
| - static void _addAll(Set<String> excluded, Set<String> result, Iterable<String> toAdd) {
|
| - for (String item in toAdd) {
|
| - // add name based on "item", but not "excluded"
|
| - for (int suffix = 1;; suffix++) {
|
| - // prepare name, just "item" or "item2", "item3", etc
|
| - String name = item;
|
| - if (suffix > 1) {
|
| - name += suffix.toString();
|
| - }
|
| - // add once found not excluded
|
| - if (!excluded.contains(name)) {
|
| - result.add(name);
|
| - break;
|
| - }
|
| - }
|
| - }
|
| - }
|
| -
|
| - /**
|
| - * Add to "result" then given "c" or the first ASCII character after it.
|
| - */
|
| - static void _addSingleCharacterName(Set<String> excluded, Set<String> result, int c) {
|
| - while (c < 0x7A) {
|
| - String name = new String.fromCharCode(c);
|
| - // may be done
|
| - if (!excluded.contains(name)) {
|
| - result.add(name);
|
| - break;
|
| - }
|
| - // next character
|
| - c = (c + 1);
|
| - }
|
| - }
|
| -
|
| - static String _getBaseNameFromExpression(Expression expression) {
|
| - String name = null;
|
| - // e as Type
|
| - if (expression is AsExpression) {
|
| - AsExpression asExpression = expression as AsExpression;
|
| - expression = asExpression.expression;
|
| - }
|
| - // analyze expressions
|
| - if (expression is SimpleIdentifier) {
|
| - SimpleIdentifier node = expression;
|
| - return node.name;
|
| - } else if (expression is PrefixedIdentifier) {
|
| - PrefixedIdentifier node = expression;
|
| - return node.identifier.name;
|
| - } else if (expression is MethodInvocation) {
|
| - name = expression.methodName.name;
|
| - } else if (expression is InstanceCreationExpression) {
|
| - InstanceCreationExpression creation = expression;
|
| - ConstructorName constructorName = creation.constructorName;
|
| - TypeName typeName = constructorName.type;
|
| - if (typeName != null) {
|
| - Identifier typeNameIdentifier = typeName.name;
|
| - // new ClassName()
|
| - if (typeNameIdentifier is SimpleIdentifier) {
|
| - return typeNameIdentifier.name;
|
| - }
|
| - // new prefix.name();
|
| - if (typeNameIdentifier is PrefixedIdentifier) {
|
| - PrefixedIdentifier prefixed = typeNameIdentifier;
|
| - // new prefix.ClassName()
|
| - if (prefixed.prefix.staticElement is PrefixElement) {
|
| - return prefixed.identifier.name;
|
| - }
|
| - // new ClassName.constructorName()
|
| - return prefixed.prefix.name;
|
| - }
|
| - }
|
| - }
|
| - // strip known prefixes
|
| - if (name != null) {
|
| - for (int i = 0; i < _KNOWN_METHOD_NAME_PREFIXES.length; i++) {
|
| - String curr = _KNOWN_METHOD_NAME_PREFIXES[i];
|
| - if (name.startsWith(curr)) {
|
| - if (name == curr) {
|
| - return null;
|
| - } else if (Character.isUpperCase(name.codeUnitAt(curr.length))) {
|
| - return name.substring(curr.length);
|
| - }
|
| - }
|
| - }
|
| - }
|
| - // done
|
| - return name;
|
| - }
|
| -
|
| - static String _getBaseNameFromLocationInParent(Expression expression) {
|
| - // value in named expression
|
| - if (expression.parent is NamedExpression) {
|
| - NamedExpression namedExpression = expression.parent as NamedExpression;
|
| - if (identical(namedExpression.expression, expression)) {
|
| - return namedExpression.name.label.name;
|
| - }
|
| - }
|
| - // positional argument
|
| - {
|
| - ParameterElement parameter = expression.propagatedParameterElement;
|
| - if (parameter == null) {
|
| - parameter = expression.staticParameterElement;
|
| - }
|
| - if (parameter != null) {
|
| - return parameter.displayName;
|
| - }
|
| - }
|
| - // unknown
|
| - return null;
|
| - }
|
| -
|
| - /**
|
| - * @return [Expression]s from <code>operands</code> which are completely covered by given
|
| - * [SourceRange]. Range should start and end between given [Expression]s.
|
| - */
|
| - static List<Expression> _getOperandsForSourceRange(List<Expression> operands, SourceRange range) {
|
| - assert(!operands.isEmpty);
|
| - List<Expression> subOperands = [];
|
| - // track range enter/exit
|
| - bool entered = false;
|
| - bool exited = false;
|
| - // may be range starts before or on first operand
|
| - if (range.offset <= operands[0].offset) {
|
| - entered = true;
|
| - }
|
| - // iterate over gaps between operands
|
| - for (int i = 0; i < operands.length - 1; i++) {
|
| - Expression operand = operands[i];
|
| - Expression nextOperand = operands[i + 1];
|
| - SourceRange inclusiveGap = SourceRangeFactory.rangeEndStart(operand, nextOperand).getMoveEnd(1);
|
| - // add operand, if already entered range
|
| - if (entered) {
|
| - subOperands.add(operand);
|
| - // may be last operand in range
|
| - if (range.endsIn(inclusiveGap)) {
|
| - exited = true;
|
| - }
|
| - } else {
|
| - // may be first operand in range
|
| - if (range.startsIn(inclusiveGap)) {
|
| - entered = true;
|
| - }
|
| - }
|
| - }
|
| - // check if last operand is in range
|
| - Expression lastGroupMember = operands[operands.length - 1];
|
| - if (range.end == lastGroupMember.end) {
|
| - subOperands.add(lastGroupMember);
|
| - exited = true;
|
| - }
|
| - // we expect that range covers only given operands
|
| - if (!exited) {
|
| - return [];
|
| - }
|
| - // done
|
| - return subOperands;
|
| - }
|
| -
|
| - /**
|
| - * @return all operands of the given [BinaryExpression] and its children with the same
|
| - * operator.
|
| - */
|
| - static List<Expression> _getOperandsInOrderFor(BinaryExpression groupRoot) {
|
| - List<Expression> operands = [];
|
| - TokenType groupOperatorType = groupRoot.operator.type;
|
| - groupRoot.accept(new GeneralizingAstVisitor_CorrectionUtils_getOperandsInOrderFor(groupOperatorType, operands));
|
| - return operands;
|
| - }
|
| -
|
| - /**
|
| - * @return all variants of names by removing leading words by one.
|
| - */
|
| - static List<String> _getVariableNameSuggestions(String name) {
|
| - List<String> result = [];
|
| - List<String> parts = name.split("(?<!(^|[A-Z]))(?=[A-Z])|(?<!^)(?=[A-Z][a-z])");
|
| - for (int i = 0; i < parts.length; i++) {
|
| - String suggestion = "${parts[i].toLowerCase()}${StringUtils.join(parts, "", i + 1, parts.length)}";
|
| - result.add(suggestion);
|
| - }
|
| - return result;
|
| - }
|
| -
|
| - /**
|
| - * Adds enclosing parenthesis if the precedence of the [InvertedCondition] if less than the
|
| - * precedence of the expression we are going it to use in.
|
| - */
|
| - static String _parenthesizeIfRequired(CorrectionUtils_InvertedCondition expr, int newOperatorPrecedence) {
|
| - if (expr._precedence < newOperatorPrecedence) {
|
| - return "(${expr._source})";
|
| - }
|
| - return expr._source;
|
| - }
|
| -
|
| - final CompilationUnit unit;
|
| -
|
| - LibraryElement _library;
|
| -
|
| - String _buffer;
|
| -
|
| - String _endOfLine;
|
| -
|
| - CorrectionUtils(this.unit) {
|
| - CompilationUnitElement element = unit.element;
|
| - this._library = element.library;
|
| - this._buffer = getSourceContent(element.context, element.source);
|
| - }
|
| -
|
| - /**
|
| - * @return the source of the given [SourceRange] with indentation changed from "oldIndent"
|
| - * to "newIndent", keeping indentation of the lines relative to each other.
|
| - */
|
| - Edit createIndentEdit(SourceRange range, String oldIndent, String newIndent) {
|
| - String newSource = getIndentSource(range, oldIndent, newIndent);
|
| - return new Edit(range.offset, range.length, newSource);
|
| - }
|
| -
|
| - /**
|
| - * @return the [AstNode] that encloses the given offset.
|
| - */
|
| - AstNode findNode(int offset) => new NodeLocator.con1(offset).searchWithin(unit);
|
| -
|
| - /**
|
| - * TODO(scheglov) replace with nodes once there will be [CompilationUnit#getComments].
|
| - *
|
| - * @return the [SourceRange]s of all comments in [CompilationUnit].
|
| - */
|
| - List<SourceRange> get commentRanges {
|
| - List<SourceRange> ranges = [];
|
| - Token token = unit.beginToken;
|
| - while (token != null && token.type != TokenType.EOF) {
|
| - Token commentToken = token.precedingComments;
|
| - while (commentToken != null) {
|
| - ranges.add(SourceRangeFactory.rangeToken(commentToken));
|
| - commentToken = commentToken.next;
|
| - }
|
| - token = token.next;
|
| - }
|
| - return ranges;
|
| - }
|
| -
|
| - /**
|
| - * @return the EOL to use for this [CompilationUnit].
|
| - */
|
| - String get endOfLine {
|
| - if (_endOfLine == null) {
|
| - if (_buffer.contains("\r\n")) {
|
| - _endOfLine = "\r\n";
|
| - } else {
|
| - _endOfLine = "\n";
|
| - }
|
| - }
|
| - return _endOfLine;
|
| - }
|
| -
|
| - /**
|
| - * @return the default indentation with given level.
|
| - */
|
| - String getIndent(int level) => StringUtils.repeat(" ", level);
|
| -
|
| - /**
|
| - * @return the source of the given [SourceRange] with indentation changed from "oldIndent"
|
| - * to "newIndent", keeping indentation of the lines relative to each other.
|
| - */
|
| - String getIndentSource(SourceRange range, String oldIndent, String newIndent) {
|
| - String oldSource = getText3(range);
|
| - return getIndentSource3(oldSource, oldIndent, newIndent);
|
| - }
|
| -
|
| - /**
|
| - * Indents given source left or right.
|
| - *
|
| - * @return the source with changed indentation.
|
| - */
|
| - String getIndentSource2(String source, bool right) {
|
| - JavaStringBuilder sb = new JavaStringBuilder();
|
| - String indent = getIndent(1);
|
| - String eol = endOfLine;
|
| - List<String> lines = StringUtils.splitByWholeSeparatorPreserveAllTokens(source, eol);
|
| - for (int i = 0; i < lines.length; i++) {
|
| - String line = lines[i];
|
| - // last line, stop if empty
|
| - if (i == lines.length - 1 && StringUtils.isEmpty(line)) {
|
| - break;
|
| - }
|
| - // update line
|
| - if (right) {
|
| - line = "${indent}${line}";
|
| - } else {
|
| - line = StringUtils.removeStart(line, indent);
|
| - }
|
| - // append line
|
| - sb.append(line);
|
| - sb.append(eol);
|
| - }
|
| - return sb.toString();
|
| - }
|
| -
|
| - /**
|
| - * @return the source with indentation changed from "oldIndent" to "newIndent", keeping
|
| - * indentation of the lines relative to each other.
|
| - */
|
| - String getIndentSource3(String source, String oldIndent, String newIndent) {
|
| - // prepare STRING token ranges
|
| - List<SourceRange> lineRanges = [];
|
| - for (Token token in TokenUtils.getTokens(source)) {
|
| - if (token.type == TokenType.STRING) {
|
| - lineRanges.add(SourceRangeFactory.rangeToken(token));
|
| - }
|
| - }
|
| - // re-indent lines
|
| - JavaStringBuilder sb = new JavaStringBuilder();
|
| - String eol = endOfLine;
|
| - List<String> lines = StringUtils.splitByWholeSeparatorPreserveAllTokens(source, eol);
|
| - int lineOffset = 0;
|
| - for (int i = 0; i < lines.length; i++) {
|
| - String line = lines[i];
|
| - // last line, stop if empty
|
| - if (i == lines.length - 1 && StringUtils.isEmpty(line)) {
|
| - break;
|
| - }
|
| - // check if "offset" is in one of the String ranges
|
| - bool inString = false;
|
| - for (SourceRange lineRange in lineRanges) {
|
| - inString = javaBooleanOr(inString, lineOffset > lineRange.offset && lineOffset < lineRange.end);
|
| - if (lineOffset > lineRange.end) {
|
| - break;
|
| - }
|
| - }
|
| - lineOffset += line.length + eol.length;
|
| - // update line indent
|
| - if (!inString) {
|
| - line = "${newIndent}${StringUtils.removeStart(line, oldIndent)}";
|
| - }
|
| - // append line
|
| - sb.append(line);
|
| - sb.append(eol);
|
| - }
|
| - return sb.toString();
|
| - }
|
| -
|
| - /**
|
| - * @return [InsertDesc], description where to insert new library-related directive.
|
| - */
|
| - CorrectionUtils_InsertDesc get insertDescImport {
|
| - // analyze directives
|
| - Directive prevDirective = null;
|
| - for (Directive directive in unit.directives) {
|
| - if (directive is LibraryDirective || directive is ImportDirective || directive is ExportDirective) {
|
| - prevDirective = directive;
|
| - }
|
| - }
|
| - // insert after last library-related directive
|
| - if (prevDirective != null) {
|
| - CorrectionUtils_InsertDesc result = new CorrectionUtils_InsertDesc();
|
| - result.offset = prevDirective.end;
|
| - String eol = endOfLine;
|
| - if (prevDirective is LibraryDirective) {
|
| - result.prefix = "${eol}${eol}";
|
| - } else {
|
| - result.prefix = eol;
|
| - }
|
| - return result;
|
| - }
|
| - // no directives, use "top" location
|
| - return insertDescTop;
|
| - }
|
| -
|
| - /**
|
| - * @return [InsertDesc], description where to insert new 'part 'directive.
|
| - */
|
| - CorrectionUtils_InsertDesc get insertDescPart {
|
| - // analyze directives
|
| - Directive prevDirective = null;
|
| - for (Directive directive in unit.directives) {
|
| - prevDirective = directive;
|
| - }
|
| - // insert after last directive
|
| - if (prevDirective != null) {
|
| - CorrectionUtils_InsertDesc result = new CorrectionUtils_InsertDesc();
|
| - result.offset = prevDirective.end;
|
| - String eol = endOfLine;
|
| - if (prevDirective is PartDirective) {
|
| - result.prefix = eol;
|
| - } else {
|
| - result.prefix = "${eol}${eol}";
|
| - }
|
| - return result;
|
| - }
|
| - // no directives, use "top" location
|
| - return insertDescTop;
|
| - }
|
| -
|
| - /**
|
| - * @return [InsertDesc], description where to insert new directive or top-level declaration
|
| - * at the top of file.
|
| - */
|
| - CorrectionUtils_InsertDesc get insertDescTop {
|
| - // skip leading line comments
|
| - int offset = 0;
|
| - bool insertEmptyLineBefore = false;
|
| - bool insertEmptyLineAfter = false;
|
| - String source = text;
|
| - // skip hash-bang
|
| - if (offset < source.length - 2) {
|
| - String linePrefix = getText2(offset, 2);
|
| - if (linePrefix == "#!") {
|
| - insertEmptyLineBefore = true;
|
| - offset = getLineNext(offset);
|
| - // skip empty lines to first line comment
|
| - int emptyOffset = offset;
|
| - while (emptyOffset < source.length - 2) {
|
| - int nextLineOffset = getLineNext(emptyOffset);
|
| - String line = source.substring(emptyOffset, nextLineOffset);
|
| - if (line.trim().isEmpty) {
|
| - emptyOffset = nextLineOffset;
|
| - continue;
|
| - } else if (line.startsWith("//")) {
|
| - offset = emptyOffset;
|
| - break;
|
| - } else {
|
| - break;
|
| - }
|
| - }
|
| - }
|
| - }
|
| - // skip line comments
|
| - while (offset < source.length - 2) {
|
| - String linePrefix = getText2(offset, 2);
|
| - if (linePrefix == "//") {
|
| - insertEmptyLineBefore = true;
|
| - offset = getLineNext(offset);
|
| - } else {
|
| - break;
|
| - }
|
| - }
|
| - // determine if empty line is required after
|
| - int nextLineOffset = getLineNext(offset);
|
| - String insertLine = source.substring(offset, nextLineOffset);
|
| - if (!insertLine.trim().isEmpty) {
|
| - insertEmptyLineAfter = true;
|
| - }
|
| - // fill InsertDesc
|
| - CorrectionUtils_InsertDesc desc = new CorrectionUtils_InsertDesc();
|
| - desc.offset = offset;
|
| - if (insertEmptyLineBefore) {
|
| - desc.prefix = endOfLine;
|
| - }
|
| - if (insertEmptyLineAfter) {
|
| - desc.suffix = endOfLine;
|
| - }
|
| - return desc;
|
| - }
|
| -
|
| - /**
|
| - * Skips whitespace characters and single EOL on the right from the given position. If from
|
| - * statement or method end, then this is in the most cases start of the next line.
|
| - */
|
| - int getLineContentEnd(int index) {
|
| - int length = _buffer.length;
|
| - // skip whitespace characters
|
| - while (index < length) {
|
| - int c = _buffer.codeUnitAt(index);
|
| - if (!Character.isWhitespace(c) || c == 0xD || c == 0xA) {
|
| - break;
|
| - }
|
| - index++;
|
| - }
|
| - // skip single \r
|
| - if (index < length && _buffer.codeUnitAt(index) == 0xD) {
|
| - index++;
|
| - }
|
| - // skip single \n
|
| - if (index < length && _buffer.codeUnitAt(index) == 0xA) {
|
| - index++;
|
| - }
|
| - // done
|
| - return index;
|
| - }
|
| -
|
| - /**
|
| - * @return the index of the last space or tab on the left from the given one, if from statement or
|
| - * method start, then this is in most cases start of the line.
|
| - */
|
| - int getLineContentStart(int index) {
|
| - while (index > 0) {
|
| - int c = _buffer.codeUnitAt(index - 1);
|
| - if (c != 0x20 && c != 0x9) {
|
| - break;
|
| - }
|
| - index--;
|
| - }
|
| - return index;
|
| - }
|
| -
|
| - /**
|
| - * @return the start index of the next line after the line which contains given index.
|
| - */
|
| - int getLineNext(int index) {
|
| - int length = _buffer.length;
|
| - // skip to the end of the line
|
| - while (index < length) {
|
| - int c = _buffer.codeUnitAt(index);
|
| - if (c == 0xD || c == 0xA) {
|
| - break;
|
| - }
|
| - index++;
|
| - }
|
| - // skip single \r
|
| - if (index < length && _buffer.codeUnitAt(index) == 0xD) {
|
| - index++;
|
| - }
|
| - // skip single \n
|
| - if (index < length && _buffer.codeUnitAt(index) == 0xA) {
|
| - index++;
|
| - }
|
| - // done
|
| - return index;
|
| - }
|
| -
|
| - /**
|
| - * @return the whitespace prefix of the line which contains given offset.
|
| - */
|
| - String getLinePrefix(int index) {
|
| - int lineStart = getLineThis(index);
|
| - int length = _buffer.length;
|
| - int lineNonWhitespace = lineStart;
|
| - while (lineNonWhitespace < length) {
|
| - int c = _buffer.codeUnitAt(lineNonWhitespace);
|
| - if (c == 0xD || c == 0xA) {
|
| - break;
|
| - }
|
| - if (!Character.isWhitespace(c)) {
|
| - break;
|
| - }
|
| - lineNonWhitespace++;
|
| - }
|
| - return getText2(lineStart, lineNonWhitespace - lineStart);
|
| - }
|
| -
|
| - /**
|
| - * @return the [getLinesRange] for given [Statement]s.
|
| - */
|
| - SourceRange getLinesRange(List<Statement> statements) {
|
| - SourceRange range = SourceRangeFactory.rangeNodes(statements);
|
| - return getLinesRange2(range);
|
| - }
|
| -
|
| - /**
|
| - * @return the [SourceRange] which starts at the start of the line of "offset" and ends at
|
| - * the start of the next line after "end" of the given [SourceRange], i.e. basically
|
| - * complete lines of the source for given [SourceRange].
|
| - */
|
| - SourceRange getLinesRange2(SourceRange range) {
|
| - // start
|
| - int startOffset = range.offset;
|
| - int startLineOffset = getLineContentStart(startOffset);
|
| - // end
|
| - int endOffset = range.end;
|
| - int afterEndLineOffset = getLineContentEnd(endOffset);
|
| - // range
|
| - return SourceRangeFactory.rangeStartEnd(startLineOffset, afterEndLineOffset);
|
| - }
|
| -
|
| - /**
|
| - * @return the [getLinesRange] for given [Statement]s.
|
| - */
|
| - SourceRange getLinesRange3(List<Statement> statements) => getLinesRange([]);
|
| -
|
| - /**
|
| - * @return the start index of the line which contains given index.
|
| - */
|
| - int getLineThis(int index) {
|
| - while (index > 0) {
|
| - int c = _buffer.codeUnitAt(index - 1);
|
| - if (c == 0xD || c == 0xA) {
|
| - break;
|
| - }
|
| - index--;
|
| - }
|
| - return index;
|
| - }
|
| -
|
| - /**
|
| - * @return the line prefix consisting of spaces and tabs on the left from the given
|
| - * [AstNode].
|
| - */
|
| - String getNodePrefix(AstNode node) {
|
| - int offset = node.offset;
|
| - // function literal is special, it uses offset of enclosing line
|
| - if (node is FunctionExpression) {
|
| - return getLinePrefix(offset);
|
| - }
|
| - // use just prefix directly before node
|
| - return getPrefix(offset);
|
| - }
|
| -
|
| - /**
|
| - * @return the index of the first non-whitespace character after given index.
|
| - */
|
| - int getNonWhitespaceForward(int index) {
|
| - int length = _buffer.length;
|
| - // skip whitespace characters
|
| - while (index < length) {
|
| - int c = _buffer.codeUnitAt(index);
|
| - if (!Character.isWhitespace(c)) {
|
| - break;
|
| - }
|
| - index++;
|
| - }
|
| - // done
|
| - return index;
|
| - }
|
| -
|
| - /**
|
| - * @return the source for the parameter with the given type and name.
|
| - */
|
| - String getParameterSource(DartType type, String name) {
|
| - // no type
|
| - if (type == null || type.isDynamic) {
|
| - return name;
|
| - }
|
| - // function type
|
| - if (type is FunctionType) {
|
| - FunctionType functionType = type;
|
| - JavaStringBuilder sb = new JavaStringBuilder();
|
| - // return type
|
| - DartType returnType = functionType.returnType;
|
| - if (returnType != null && !returnType.isDynamic) {
|
| - sb.append(getTypeSource2(returnType));
|
| - sb.appendChar(0x20);
|
| - }
|
| - // parameter name
|
| - sb.append(name);
|
| - // parameters
|
| - sb.appendChar(0x28);
|
| - List<ParameterElement> fParameters = functionType.parameters;
|
| - for (int i = 0; i < fParameters.length; i++) {
|
| - ParameterElement fParameter = fParameters[i];
|
| - if (i != 0) {
|
| - sb.append(", ");
|
| - }
|
| - sb.append(getParameterSource(fParameter.type, fParameter.name));
|
| - }
|
| - sb.appendChar(0x29);
|
| - // done
|
| - return sb.toString();
|
| - }
|
| - // simple type
|
| - return "${getTypeSource2(type)} ${name}";
|
| - }
|
| -
|
| - /**
|
| - * @return the line prefix consisting of spaces and tabs on the left from the given offset.
|
| - */
|
| - String getPrefix(int endIndex) {
|
| - int startIndex = getLineContentStart(endIndex);
|
| - return _buffer.substring(startIndex, endIndex);
|
| - }
|
| -
|
| - /**
|
| - * @return the full text of unit.
|
| - */
|
| - String get text => _buffer;
|
| -
|
| - /**
|
| - * @return the given range of text from unit.
|
| - */
|
| - String getText(AstNode node) => getText2(node.offset, node.length);
|
| -
|
| - /**
|
| - * @return the given range of text from unit.
|
| - */
|
| - String getText2(int offset, int length) => _buffer.substring(offset, offset + length);
|
| -
|
| - /**
|
| - * @return the given range of text from unit.
|
| - */
|
| - String getText3(SourceRange range) => getText2(range.offset, range.length);
|
| -
|
| - /**
|
| - * @return the actual type source of the given [Expression], may be `null` if can not
|
| - * be resolved, should be treated as <code>Dynamic</code>.
|
| - */
|
| - String getTypeSource(Expression expression) {
|
| - if (expression == null) {
|
| - return null;
|
| - }
|
| - DartType type = expression.bestType;
|
| - String typeSource = getTypeSource2(type);
|
| - if ("dynamic" == typeSource) {
|
| - return null;
|
| - }
|
| - return typeSource;
|
| - }
|
| -
|
| - /**
|
| - * @return the source to reference the given [Type] in this [CompilationUnit].
|
| - */
|
| - String getTypeSource2(DartType type) {
|
| - JavaStringBuilder sb = new JavaStringBuilder();
|
| - // prepare element
|
| - Element element = type.element;
|
| - if (element == null) {
|
| - String source = type.toString();
|
| - source = StringUtils.remove(source, "<dynamic>");
|
| - source = StringUtils.remove(source, "<dynamic, dynamic>");
|
| - return source;
|
| - }
|
| - // append prefix
|
| - {
|
| - ImportElement imp = _getImportElement(element);
|
| - if (imp != null && imp.prefix != null) {
|
| - sb.append(imp.prefix.displayName);
|
| - sb.append(".");
|
| - }
|
| - }
|
| - // append simple name
|
| - String name = element.displayName;
|
| - sb.append(name);
|
| - // may be type arguments
|
| - if (type is InterfaceType) {
|
| - InterfaceType interfaceType = type;
|
| - List<DartType> arguments = interfaceType.typeArguments;
|
| - // check if has arguments
|
| - bool hasArguments = false;
|
| - for (DartType argument in arguments) {
|
| - if (!argument.isDynamic) {
|
| - hasArguments = true;
|
| - break;
|
| - }
|
| - }
|
| - // append type arguments
|
| - if (hasArguments) {
|
| - sb.append("<");
|
| - for (int i = 0; i < arguments.length; i++) {
|
| - DartType argument = arguments[i];
|
| - if (i != 0) {
|
| - sb.append(", ");
|
| - }
|
| - sb.append(getTypeSource2(argument));
|
| - }
|
| - sb.append(">");
|
| - }
|
| - }
|
| - // done
|
| - return sb.toString();
|
| - }
|
| -
|
| - /**
|
| - * @return the source of the inverted condition for the given logical expression.
|
| - */
|
| - String invertCondition(Expression expression) => _invertCondition0(expression)._source;
|
| -
|
| - /**
|
| - * @return <code>true</code> if selection range contains only whitespace.
|
| - */
|
| - bool isJustWhitespace(SourceRange range) => getText3(range).trim().length == 0;
|
| -
|
| - /**
|
| - * @return <code>true</code> if selection range contains only whitespace or comments
|
| - */
|
| - bool isJustWhitespaceOrComment(SourceRange range) {
|
| - String trimmedText = getText3(range).trim();
|
| - // may be whitespace
|
| - if (trimmedText.isEmpty) {
|
| - return true;
|
| - }
|
| - // may be comment
|
| - return TokenUtils.getTokens(trimmedText).isEmpty;
|
| - }
|
| -
|
| - /**
|
| - * @return <code>true</code> if "selection" covers "node" and there are any non-whitespace tokens
|
| - * between "selection" and "node" start/end.
|
| - */
|
| - bool selectionIncludesNonWhitespaceOutsideNode(SourceRange selection, AstNode node) => _selectionIncludesNonWhitespaceOutsideRange(selection, SourceRangeFactory.rangeNode(node));
|
| -
|
| - /**
|
| - * @return <code>true</code> if given range of [BinaryExpression] can be extracted.
|
| - */
|
| - bool validateBinaryExpressionRange(BinaryExpression binaryExpression, SourceRange range) {
|
| - // only parts of associative expression are safe to extract
|
| - if (!binaryExpression.operator.type.isAssociativeOperator) {
|
| - return false;
|
| - }
|
| - // prepare selected operands
|
| - List<Expression> operands = _getOperandsInOrderFor(binaryExpression);
|
| - List<Expression> subOperands = _getOperandsForSourceRange(operands, range);
|
| - // if empty, then something wrong with selection
|
| - if (subOperands.isEmpty) {
|
| - return false;
|
| - }
|
| - // may be some punctuation included into selection - operators, braces, etc
|
| - if (_selectionIncludesNonWhitespaceOutsideOperands(range, subOperands)) {
|
| - return false;
|
| - }
|
| - // OK
|
| - return true;
|
| - }
|
| -
|
| - /**
|
| - * @return the [ImportElement] used to import given [Element] into [library].
|
| - * May be `null` if was not imported, i.e. declared in the same library.
|
| - */
|
| - ImportElement _getImportElement(Element element) {
|
| - for (ImportElement imp in _library.imports) {
|
| - Map<String, Element> definedNames = getImportNamespace(imp);
|
| - if (definedNames.containsValue(element)) {
|
| - return imp;
|
| - }
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - /**
|
| - * @return the [InvertedCondition] for the given logical expression.
|
| - */
|
| - CorrectionUtils_InvertedCondition _invertCondition0(Expression expression) {
|
| - if (expression is BooleanLiteral) {
|
| - BooleanLiteral literal = expression;
|
| - if (literal.value) {
|
| - return CorrectionUtils_InvertedCondition._simple("false");
|
| - } else {
|
| - return CorrectionUtils_InvertedCondition._simple("true");
|
| - }
|
| - }
|
| - if (expression is BinaryExpression) {
|
| - BinaryExpression binary = expression;
|
| - TokenType operator = binary.operator.type;
|
| - Expression le = binary.leftOperand;
|
| - Expression re = binary.rightOperand;
|
| - CorrectionUtils_InvertedCondition ls = _invertCondition0(le);
|
| - CorrectionUtils_InvertedCondition rs = _invertCondition0(re);
|
| - if (operator == TokenType.LT) {
|
| - return CorrectionUtils_InvertedCondition._binary2(ls, " >= ", rs);
|
| - }
|
| - if (operator == TokenType.GT) {
|
| - return CorrectionUtils_InvertedCondition._binary2(ls, " <= ", rs);
|
| - }
|
| - if (operator == TokenType.LT_EQ) {
|
| - return CorrectionUtils_InvertedCondition._binary2(ls, " > ", rs);
|
| - }
|
| - if (operator == TokenType.GT_EQ) {
|
| - return CorrectionUtils_InvertedCondition._binary2(ls, " < ", rs);
|
| - }
|
| - if (operator == TokenType.EQ_EQ) {
|
| - return CorrectionUtils_InvertedCondition._binary2(ls, " != ", rs);
|
| - }
|
| - if (operator == TokenType.BANG_EQ) {
|
| - return CorrectionUtils_InvertedCondition._binary2(ls, " == ", rs);
|
| - }
|
| - if (operator == TokenType.AMPERSAND_AMPERSAND) {
|
| - int newPrecedence = TokenType.BAR_BAR.precedence;
|
| - return CorrectionUtils_InvertedCondition._binary(newPrecedence, ls, " || ", rs);
|
| - }
|
| - if (operator == TokenType.BAR_BAR) {
|
| - int newPrecedence = TokenType.AMPERSAND_AMPERSAND.precedence;
|
| - return CorrectionUtils_InvertedCondition._binary(newPrecedence, ls, " && ", rs);
|
| - }
|
| - }
|
| - if (expression is IsExpression) {
|
| - IsExpression isExpression = expression;
|
| - String expressionSource = getText(isExpression.expression);
|
| - String typeSource = getText(isExpression.type);
|
| - if (isExpression.notOperator == null) {
|
| - return CorrectionUtils_InvertedCondition._simple("${expressionSource} is! ${typeSource}");
|
| - } else {
|
| - return CorrectionUtils_InvertedCondition._simple("${expressionSource} is ${typeSource}");
|
| - }
|
| - }
|
| - if (expression is PrefixExpression) {
|
| - PrefixExpression prefixExpression = expression;
|
| - TokenType operator = prefixExpression.operator.type;
|
| - if (operator == TokenType.BANG) {
|
| - Expression operand = prefixExpression.operand;
|
| - while (operand is ParenthesizedExpression) {
|
| - ParenthesizedExpression pe = operand as ParenthesizedExpression;
|
| - operand = pe.expression;
|
| - }
|
| - return CorrectionUtils_InvertedCondition._simple(getText(operand));
|
| - }
|
| - }
|
| - if (expression is ParenthesizedExpression) {
|
| - ParenthesizedExpression pe = expression;
|
| - Expression innerExpresion = pe.expression;
|
| - while (innerExpresion is ParenthesizedExpression) {
|
| - innerExpresion = (innerExpresion as ParenthesizedExpression).expression;
|
| - }
|
| - return _invertCondition0(innerExpresion);
|
| - }
|
| - DartType type = expression.bestType;
|
| - if (type.displayName == "bool") {
|
| - return CorrectionUtils_InvertedCondition._simple("!${getText(expression)}");
|
| - }
|
| - return CorrectionUtils_InvertedCondition._simple(getText(expression));
|
| - }
|
| -
|
| - bool _selectionIncludesNonWhitespaceOutsideOperands(SourceRange selection, List<Expression> operands) => _selectionIncludesNonWhitespaceOutsideRange(selection, SourceRangeFactory.rangeNodes(operands));
|
| -
|
| - /**
|
| - * @return <code>true</code> if "selection" covers "range" and there are any non-whitespace tokens
|
| - * between "selection" and "range" start/end.
|
| - */
|
| - bool _selectionIncludesNonWhitespaceOutsideRange(SourceRange selection, SourceRange range) {
|
| - // selection should cover range
|
| - if (!selection.covers(range)) {
|
| - return false;
|
| - }
|
| - // non-whitespace between selection start and range start
|
| - if (!isJustWhitespaceOrComment(SourceRangeFactory.rangeStartStart(selection, range))) {
|
| - return true;
|
| - }
|
| - // non-whitespace after range
|
| - if (!isJustWhitespaceOrComment(SourceRangeFactory.rangeEndEnd(range, selection))) {
|
| - return true;
|
| - }
|
| - // only whitespace in selection around range
|
| - return false;
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * Describes where to insert new directive or top-level declaration.
|
| - */
|
| -class CorrectionUtils_InsertDesc {
|
| - int offset = 0;
|
| -
|
| - String prefix = "";
|
| -
|
| - String suffix = "";
|
| -}
|
| -
|
| -/**
|
| - * This class is used to hold the source and also its precedence during inverting logical
|
| - * expressions.
|
| - */
|
| -class CorrectionUtils_InvertedCondition {
|
| - static CorrectionUtils_InvertedCondition _binary(int precedence, CorrectionUtils_InvertedCondition left, String operation, CorrectionUtils_InvertedCondition right) => new CorrectionUtils_InvertedCondition(precedence, "${CorrectionUtils._parenthesizeIfRequired(left, precedence)}${operation}${CorrectionUtils._parenthesizeIfRequired(right, precedence)}");
|
| -
|
| - static CorrectionUtils_InvertedCondition _binary2(CorrectionUtils_InvertedCondition left, String operation, CorrectionUtils_InvertedCondition right) => new CorrectionUtils_InvertedCondition(2147483647, "${left._source}${operation}${right._source}");
|
| -
|
| - static CorrectionUtils_InvertedCondition _simple(String source) => new CorrectionUtils_InvertedCondition(2147483647, source);
|
| -
|
| - final int _precedence;
|
| -
|
| - final String _source;
|
| -
|
| - CorrectionUtils_InvertedCondition(this._precedence, this._source);
|
| -}
|
| -
|
| -class GeneralizingAstVisitor_CorrectionUtils_getOperandsInOrderFor extends GeneralizingAstVisitor<Object> {
|
| - TokenType groupOperatorType;
|
| -
|
| - List<Expression> operands;
|
| -
|
| - GeneralizingAstVisitor_CorrectionUtils_getOperandsInOrderFor(this.groupOperatorType, this.operands) : super();
|
| -
|
| - @override
|
| - Object visitExpression(Expression node) {
|
| - if (node is BinaryExpression && node.operator.type == groupOperatorType) {
|
| - return super.visitNode(node);
|
| - }
|
| - operands.add(node);
|
| - return null;
|
| - }
|
| -}
|
| -
|
| -class GeneralizingElementVisitor_CorrectionUtils_getChildren extends GeneralizingElementVisitor<Object> {
|
| - Element parent;
|
| -
|
| - String name;
|
| -
|
| - List<Element> children;
|
| -
|
| - GeneralizingElementVisitor_CorrectionUtils_getChildren(this.parent, this.name, this.children) : super();
|
| -
|
| - @override
|
| - Object visitElement(Element element) {
|
| - if (identical(element, parent)) {
|
| - super.visitElement(element);
|
| - } else if (name == null || CorrectionUtils.hasDisplayName(element, name)) {
|
| - children.add(element);
|
| - }
|
| - return null;
|
| - }
|
| -}
|
| -
|
| -class GeneralizingElementVisitor_HierarchyUtils_getDirectMembers extends GeneralizingElementVisitor<Object> {
|
| - ClassElement clazz;
|
| -
|
| - bool includeSynthetic = false;
|
| -
|
| - List<Element> members;
|
| -
|
| - GeneralizingElementVisitor_HierarchyUtils_getDirectMembers(this.clazz, this.includeSynthetic, this.members) : super();
|
| -
|
| - @override
|
| - Object visitElement(Element element) {
|
| - if (identical(element, clazz)) {
|
| - return super.visitElement(element);
|
| - }
|
| - if (!includeSynthetic && element.isSynthetic) {
|
| - return null;
|
| - }
|
| - if (element is ConstructorElement) {
|
| - return null;
|
| - }
|
| - if (element is ExecutableElement) {
|
| - members.add(element);
|
| - }
|
| - if (element is FieldElement) {
|
| - members.add(element);
|
| - }
|
| - return null;
|
| - }
|
| -}
|
| -
|
| -class NameOccurrencesFinder extends RecursiveAstVisitor<Object> {
|
| - static Iterable<AstNode> findIn(SimpleIdentifier ident, AstNode root) {
|
| - if (ident == null || ident.bestElement == null) {
|
| - return new Set<AstNode>();
|
| - }
|
| - NameOccurrencesFinder finder = new NameOccurrencesFinder(ident.bestElement);
|
| - root.accept(finder);
|
| - return finder.matches;
|
| - }
|
| -
|
| - Element _target;
|
| -
|
| - Element _target2;
|
| -
|
| - Element _target3;
|
| -
|
| - Element _target4;
|
| -
|
| - Set<AstNode> _matches;
|
| -
|
| - NameOccurrencesFinder(Element source) {
|
| - this._target = source;
|
| - while (true) {
|
| - if (source.kind == ElementKind.GETTER || source.kind == ElementKind.SETTER) {
|
| - PropertyAccessorElement accessorElem = source as PropertyAccessorElement;
|
| - this._target2 = accessorElem.variable;
|
| - if (source is Member) {
|
| - Member member = source;
|
| - this._target4 = member.baseElement;
|
| - }
|
| - if (this._target2 is Member) {
|
| - Member member = source as Member;
|
| - this._target3 = member.baseElement;
|
| - }
|
| - } else if (source.kind == ElementKind.FIELD || source.kind == ElementKind.TOP_LEVEL_VARIABLE) {
|
| - PropertyInducingElement propertyElem = source as PropertyInducingElement;
|
| - this._target2 = propertyElem.getter;
|
| - this._target3 = propertyElem.setter;
|
| - } else if (source.kind == ElementKind.METHOD) {
|
| - if (source is Member) {
|
| - Member member = source;
|
| - this._target4 = member.baseElement;
|
| - }
|
| - } else if (source.kind == ElementKind.PARAMETER) {
|
| - ParameterElement param = source as ParameterElement;
|
| - if (param.isInitializingFormal) {
|
| - FieldFormalParameterElement fieldInit = param as FieldFormalParameterElement;
|
| - this._target2 = fieldInit.field;
|
| - }
|
| - } else {
|
| - }
|
| - break;
|
| - }
|
| - if (_target2 == null) {
|
| - _target2 = _target;
|
| - }
|
| - if (_target3 == null) {
|
| - _target3 = _target;
|
| - }
|
| - if (_target4 == null) {
|
| - _target4 = _target;
|
| - }
|
| - this._matches = new Set<AstNode>();
|
| - }
|
| -
|
| - Iterable<AstNode> get matches => _matches;
|
| -
|
| - @override
|
| - Object visitSimpleIdentifier(SimpleIdentifier node) {
|
| - Element element = node.bestElement;
|
| - if (element == null) {
|
| - return null;
|
| - }
|
| - _match(element, node);
|
| - if (element is Member) {
|
| - Member member = element;
|
| - _match(member.baseElement, node);
|
| - }
|
| - while (true) {
|
| - if (element.kind == ElementKind.GETTER || element.kind == ElementKind.SETTER) {
|
| - PropertyAccessorElement accessorElem = element as PropertyAccessorElement;
|
| - _match(accessorElem.variable, node);
|
| - } else if (element.kind == ElementKind.FIELD || element.kind == ElementKind.TOP_LEVEL_VARIABLE) {
|
| - PropertyInducingElement propertyElem = element as PropertyInducingElement;
|
| - _match(propertyElem.getter, node);
|
| - _match(propertyElem.setter, node);
|
| - } else if (element.kind == ElementKind.PARAMETER) {
|
| - ParameterElement param = element as ParameterElement;
|
| - if (param.isInitializingFormal) {
|
| - FieldFormalParameterElement fieldInit = param as FieldFormalParameterElement;
|
| - _match(fieldInit.field, node);
|
| - }
|
| - } else {
|
| - }
|
| - break;
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - void _match(Element element, AstNode node) {
|
| - if (identical(_target, element) || identical(_target2, element) || identical(_target3, element) || identical(_target4, element)) {
|
| - _matches.add(node);
|
| - }
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * Abstract visitor for visiting [AstNode]s covered by the selection [SourceRange].
|
| - */
|
| -class SelectionAnalyzer extends GeneralizingAstVisitor<Object> {
|
| - SourceRange selection;
|
| -
|
| - AstNode _coveringNode;
|
| -
|
| - List<AstNode> _selectedNodes;
|
| -
|
| - SelectionAnalyzer(SourceRange selection) {
|
| - assert(selection != null);
|
| - this.selection = selection;
|
| - }
|
| -
|
| - /**
|
| - * @return the [AstNode] with the shortest length which completely covers the specified
|
| - * selection.
|
| - */
|
| - AstNode get coveringNode => _coveringNode;
|
| -
|
| - /**
|
| - * @return the first selected [AstNode], may be <code>null</code>.
|
| - */
|
| - AstNode get firstSelectedNode {
|
| - if (_selectedNodes == null || _selectedNodes.isEmpty) {
|
| - return null;
|
| - }
|
| - return _selectedNodes[0];
|
| - }
|
| -
|
| - /**
|
| - * @return the last selected [AstNode], may be <code>null</code>.
|
| - */
|
| - AstNode get lastSelectedNode {
|
| - if (_selectedNodes == null || _selectedNodes.isEmpty) {
|
| - return null;
|
| - }
|
| - return _selectedNodes[_selectedNodes.length - 1];
|
| - }
|
| -
|
| - /**
|
| - * @return the [SourceRange] which covers selected [AstNode]s, may be
|
| - * <code>null</code> if no [AstNode]s under selection.
|
| - */
|
| - SourceRange get selectedNodeRange {
|
| - if (_selectedNodes == null || _selectedNodes.isEmpty) {
|
| - return null;
|
| - }
|
| - AstNode firstNode = _selectedNodes[0];
|
| - AstNode lastNode = _selectedNodes[_selectedNodes.length - 1];
|
| - return SourceRangeFactory.rangeStartEnd(firstNode, lastNode);
|
| - }
|
| -
|
| - /**
|
| - * @return the [AstNode]s fully covered by the selection [SourceRange].
|
| - */
|
| - List<AstNode> get selectedNodes {
|
| - if (_selectedNodes == null || _selectedNodes.isEmpty) {
|
| - return [];
|
| - }
|
| - return _selectedNodes;
|
| - }
|
| -
|
| - /**
|
| - * @return <code>true</code> if there are [AstNode] fully covered by the selection
|
| - * [SourceRange].
|
| - */
|
| - bool get hasSelectedNodes => _selectedNodes != null && !_selectedNodes.isEmpty;
|
| -
|
| - @override
|
| - Object visitNode(AstNode node) {
|
| - SourceRange nodeRange = SourceRangeFactory.rangeNode(node);
|
| - if (selection.covers(nodeRange)) {
|
| - if (isFirstNode) {
|
| - handleFirstSelectedNode(node);
|
| - } else {
|
| - handleNextSelectedNode(node);
|
| - }
|
| - return null;
|
| - } else if (selection.coveredBy(nodeRange)) {
|
| - _coveringNode = node;
|
| - node.visitChildren(this);
|
| - return null;
|
| - } else if (selection.startsIn(nodeRange)) {
|
| - handleSelectionStartsIn(node);
|
| - node.visitChildren(this);
|
| - return null;
|
| - } else if (selection.endsIn(nodeRange)) {
|
| - handleSelectionEndsIn(node);
|
| - node.visitChildren(this);
|
| - return null;
|
| - }
|
| - // no intersection
|
| - return null;
|
| - }
|
| -
|
| - /**
|
| - * Adds first selected [AstNode].
|
| - */
|
| - void handleFirstSelectedNode(AstNode node) {
|
| - _selectedNodes = [];
|
| - _selectedNodes.add(node);
|
| - }
|
| -
|
| - /**
|
| - * Adds second or more selected [AstNode].
|
| - */
|
| - void handleNextSelectedNode(AstNode node) {
|
| - if (identical(firstSelectedNode.parent, node.parent)) {
|
| - _selectedNodes.add(node);
|
| - }
|
| - }
|
| -
|
| - /**
|
| - * Notifies that selection ends in given [AstNode].
|
| - */
|
| - void handleSelectionEndsIn(AstNode node) {
|
| - }
|
| -
|
| - /**
|
| - * Notifies that selection starts in given [AstNode].
|
| - */
|
| - void handleSelectionStartsIn(AstNode node) {
|
| - }
|
| -
|
| - /**
|
| - * Resets selected nodes.
|
| - */
|
| - void reset() {
|
| - _selectedNodes = null;
|
| - }
|
| -
|
| - /**
|
| - * @return <code>true</code> if there was no selected nodes yet.
|
| - */
|
| - bool get isFirstNode => _selectedNodes == null;
|
| -}
|
| -
|
| -/**
|
| - * Helper for building Dart source with tracked positions.
|
| - */
|
| -class SourceBuilder {
|
| - final int offset;
|
| -
|
| - JavaStringBuilder _buffer = new JavaStringBuilder();
|
| -
|
| - Map<String, List<SourceRange>> _linkedPositions = {};
|
| -
|
| - final Map<String, List<LinkedPositionProposal>> linkedProposals = {};
|
| -
|
| - String _currentPositionGroupId;
|
| -
|
| - int _currentPositionStart = 0;
|
| -
|
| - int _endPosition = -1;
|
| -
|
| - SourceBuilder.con1(this.offset);
|
| -
|
| - SourceBuilder.con2(SourceRange offsetRange) : this.con1(offsetRange.offset);
|
| -
|
| - /**
|
| - * Adds proposal for the current position, may be called after [startPosition].
|
| - */
|
| - void addProposal(CorrectionImage icon, String text) {
|
| - List<LinkedPositionProposal> proposals = linkedProposals[_currentPositionGroupId];
|
| - if (proposals == null) {
|
| - proposals = [];
|
| - linkedProposals[_currentPositionGroupId] = proposals;
|
| - }
|
| - proposals.add(new LinkedPositionProposal(icon, text));
|
| - }
|
| -
|
| - /**
|
| - * Appends source to the buffer.
|
| - */
|
| - SourceBuilder append(String s) {
|
| - _buffer.append(s);
|
| - return this;
|
| - }
|
| -
|
| - /**
|
| - * Ends position started using [startPosition].
|
| - */
|
| - void endPosition() {
|
| - assert(_currentPositionGroupId != null);
|
| - _addPosition();
|
| - _currentPositionGroupId = null;
|
| - }
|
| -
|
| - /**
|
| - * @return the "end position" for the [CorrectionProposal], may be <code>-1</code> if not
|
| - * set in this [SourceBuilder].
|
| - */
|
| - int get endPosition2 {
|
| - if (_endPosition == -1) {
|
| - return -1;
|
| - }
|
| - return offset + _endPosition;
|
| - }
|
| -
|
| - /**
|
| - * @return the [Map] or position IDs to their locations.
|
| - */
|
| - Map<String, List<SourceRange>> get linkedPositions => _linkedPositions;
|
| -
|
| - /**
|
| - * @return the length of the built source.
|
| - */
|
| - int length() => _buffer.length;
|
| -
|
| - /**
|
| - * Marks current position as "end position" of the [CorrectionProposal].
|
| - */
|
| - void setEndPosition() {
|
| - _endPosition = _buffer.length;
|
| - }
|
| -
|
| - /**
|
| - * Sets text-only proposals for the current position.
|
| - */
|
| - void set proposals(List<String> proposals) {
|
| - List<LinkedPositionProposal> proposalList = [];
|
| - for (String proposalText in proposals) {
|
| - proposalList.add(new LinkedPositionProposal(null, proposalText));
|
| - }
|
| - linkedProposals[_currentPositionGroupId] = proposalList;
|
| - }
|
| -
|
| - /**
|
| - * Starts linked position with given ID.
|
| - */
|
| - void startPosition(String groupId) {
|
| - assert(_currentPositionGroupId == null);
|
| - _currentPositionGroupId = groupId;
|
| - _currentPositionStart = _buffer.length;
|
| - }
|
| -
|
| - @override
|
| - String toString() => _buffer.toString();
|
| -
|
| - /**
|
| - * Adds position location [SourceRange] using current fields.
|
| - */
|
| - void _addPosition() {
|
| - List<SourceRange> locations = _linkedPositions[_currentPositionGroupId];
|
| - if (locations == null) {
|
| - locations = [];
|
| - _linkedPositions[_currentPositionGroupId] = locations;
|
| - }
|
| - int start = offset + _currentPositionStart;
|
| - int end = offset + _buffer.length;
|
| - locations.add(SourceRangeFactory.rangeStartEnd(start, end));
|
| - }
|
| -}
|
| -
|
| -/**
|
| - * Analyzer to check if a selection covers a valid set of statements of AST.
|
| - */
|
| -class StatementAnalyzer extends SelectionAnalyzer {
|
| - /**
|
| - * @return <code>true</code> if "nodes" contains "node".
|
| - */
|
| - static bool _contains(List<AstNode> nodes, AstNode node) => nodes.contains(node);
|
| -
|
| - /**
|
| - * @return <code>true</code> if "nodes" contains one of the "otherNodes".
|
| - */
|
| - static bool _contains2(List<AstNode> nodes, List<AstNode> otherNodes) {
|
| - for (AstNode otherNode in otherNodes) {
|
| - if (nodes.contains(otherNode)) {
|
| - return true;
|
| - }
|
| - }
|
| - return false;
|
| - }
|
| -
|
| - CorrectionUtils utils;
|
| -
|
| - RefactoringStatus _status = new RefactoringStatus();
|
| -
|
| - StatementAnalyzer.con1(CompilationUnit cunit, SourceRange selection) : this.con2(new CorrectionUtils(cunit), selection);
|
| -
|
| - StatementAnalyzer.con2(CorrectionUtils utils, SourceRange selection) : super(selection) {
|
| - this.utils = utils;
|
| - }
|
| -
|
| - /**
|
| - * @return the [RefactoringStatus] result of checking selection.
|
| - */
|
| - RefactoringStatus get status => _status;
|
| -
|
| - @override
|
| - Object visitCompilationUnit(CompilationUnit node) {
|
| - super.visitCompilationUnit(node);
|
| - if (!hasSelectedNodes) {
|
| - return null;
|
| - }
|
| - // check that selection does not begin/end in comment
|
| - {
|
| - int selectionStart = selection.offset;
|
| - int selectionEnd = selection.end;
|
| - List<SourceRange> commentRanges = utils.commentRanges;
|
| - for (SourceRange commentRange in commentRanges) {
|
| - if (commentRange.contains(selectionStart)) {
|
| - invalidSelection("Selection begins inside a comment.");
|
| - }
|
| - if (commentRange.containsExclusive(selectionEnd)) {
|
| - invalidSelection("Selection ends inside a comment.");
|
| - }
|
| - }
|
| - }
|
| - // more checks
|
| - if (!_status.hasFatalError) {
|
| - _checkSelectedNodes(node);
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitDoStatement(DoStatement node) {
|
| - super.visitDoStatement(node);
|
| - List<AstNode> selectedNodes = this.selectedNodes;
|
| - if (_contains(selectedNodes, node.body)) {
|
| - invalidSelection("Operation not applicable to a 'do' statement's body and expression.");
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitForStatement(ForStatement node) {
|
| - super.visitForStatement(node);
|
| - List<AstNode> selectedNodes = this.selectedNodes;
|
| - bool containsInit = _contains(selectedNodes, node.initialization) || _contains(selectedNodes, node.variables);
|
| - bool containsCondition = _contains(selectedNodes, node.condition);
|
| - bool containsUpdaters = _contains2(selectedNodes, node.updaters);
|
| - bool containsBody = _contains(selectedNodes, node.body);
|
| - if (containsInit && containsCondition) {
|
| - invalidSelection("Operation not applicable to a 'for' statement's initializer and condition.");
|
| - } else if (containsCondition && containsUpdaters) {
|
| - invalidSelection("Operation not applicable to a 'for' statement's condition and updaters.");
|
| - } else if (containsUpdaters && containsBody) {
|
| - invalidSelection("Operation not applicable to a 'for' statement's updaters and body.");
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitSwitchStatement(SwitchStatement node) {
|
| - super.visitSwitchStatement(node);
|
| - List<AstNode> selectedNodes = this.selectedNodes;
|
| - List<SwitchMember> switchMembers = node.members;
|
| - for (AstNode selectedNode in selectedNodes) {
|
| - if (switchMembers.contains(selectedNode)) {
|
| - invalidSelection("Selection must either cover whole switch statement or parts of a single case block.");
|
| - break;
|
| - }
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitTryStatement(TryStatement node) {
|
| - super.visitTryStatement(node);
|
| - AstNode firstSelectedNode = this.firstSelectedNode;
|
| - if (firstSelectedNode != null) {
|
| - if (identical(firstSelectedNode, node.body) || identical(firstSelectedNode, node.finallyBlock)) {
|
| - invalidSelection("Selection must either cover whole try statement or parts of try, catch, or finally block.");
|
| - } else {
|
| - List<CatchClause> catchClauses = node.catchClauses;
|
| - for (CatchClause catchClause in catchClauses) {
|
| - if (identical(firstSelectedNode, catchClause) || identical(firstSelectedNode, catchClause.body) || identical(firstSelectedNode, catchClause.exceptionParameter)) {
|
| - invalidSelection("Selection must either cover whole try statement or parts of try, catch, or finally block.");
|
| - }
|
| - }
|
| - }
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - @override
|
| - Object visitWhileStatement(WhileStatement node) {
|
| - super.visitWhileStatement(node);
|
| - List<AstNode> selectedNodes = this.selectedNodes;
|
| - if (_contains(selectedNodes, node.condition) && _contains(selectedNodes, node.body)) {
|
| - invalidSelection("Operation not applicable to a while statement's expression and body.");
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - /**
|
| - * Records fatal error with given message.
|
| - */
|
| - void invalidSelection(String message) {
|
| - invalidSelection2(message, null);
|
| - }
|
| -
|
| - /**
|
| - * Records fatal error with given message and [RefactoringStatusContext].
|
| - */
|
| - void invalidSelection2(String message, RefactoringStatusContext context) {
|
| - _status.addFatalError(message, context);
|
| - reset();
|
| - }
|
| -
|
| - /**
|
| - * Checks final selected [AstNode]s after processing [CompilationUnit].
|
| - */
|
| - void _checkSelectedNodes(CompilationUnit unit) {
|
| - List<AstNode> nodes = selectedNodes;
|
| - // some tokens before first selected node
|
| - {
|
| - AstNode firstNode = nodes[0];
|
| - SourceRange rangeBeforeFirstNode = SourceRangeFactory.rangeStartStart(selection, firstNode);
|
| - if (_hasTokens(rangeBeforeFirstNode)) {
|
| - invalidSelection2("The beginning of the selection contains characters that do not belong to a statement.", new RefactoringStatusContext.forUnit(unit, rangeBeforeFirstNode));
|
| - }
|
| - }
|
| - // some tokens after last selected node
|
| - {
|
| - AstNode lastNode = nodes.last;
|
| - SourceRange rangeAfterLastNode = SourceRangeFactory.rangeEndEnd(lastNode, selection);
|
| - if (_hasTokens(rangeAfterLastNode)) {
|
| - invalidSelection2("The end of the selection contains characters that do not belong to a statement.", new RefactoringStatusContext.forUnit(unit, rangeAfterLastNode));
|
| - }
|
| - }
|
| - }
|
| -
|
| - /**
|
| - * @return the [Token]s in given [SourceRange].
|
| - */
|
| - List<Token> _getTokens(SourceRange range) {
|
| - try {
|
| - String text = utils.getText3(range);
|
| - return TokenUtils.getTokens(text);
|
| - } catch (e) {
|
| - return [];
|
| - }
|
| - }
|
| -
|
| - /**
|
| - * @return <code>true</code> if there are [Token]s in the given [SourceRange].
|
| - */
|
| - bool _hasTokens(SourceRange range) => !_getTokens(range).isEmpty;
|
| -}
|
| -
|
| -/**
|
| - * Utilities to work with [Token]s.
|
| - */
|
| -class TokenUtils {
|
| - /**
|
| - * @return the first [KeywordToken] with given [Keyword], may be <code>null</code> if
|
| - * not found.
|
| - */
|
| - static KeywordToken findKeywordToken(List<Token> tokens, Keyword keyword) {
|
| - for (Token token in tokens) {
|
| - if (token is KeywordToken) {
|
| - KeywordToken keywordToken = token;
|
| - if (keywordToken.keyword == keyword) {
|
| - return keywordToken;
|
| - }
|
| - }
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - /**
|
| - * @return the first [Token] with given [TokenType], may be <code>null</code> if not
|
| - * found.
|
| - */
|
| - static Token findToken(List<Token> tokens, TokenType type) {
|
| - for (Token token in tokens) {
|
| - if (token.type == type) {
|
| - return token;
|
| - }
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - /**
|
| - * @return [Token]s of the given Dart source, not <code>null</code>, may be empty if no
|
| - * tokens or some exception happens.
|
| - */
|
| - static List<Token> getTokens(String s) {
|
| - try {
|
| - List<Token> tokens = [];
|
| - Scanner scanner = new Scanner(null, new CharSequenceReader(s), null);
|
| - Token token = scanner.tokenize();
|
| - while (token.type != TokenType.EOF) {
|
| - tokens.add(token);
|
| - token = token.next;
|
| - }
|
| - return tokens;
|
| - } catch (e) {
|
| - return [];
|
| - }
|
| - }
|
| -
|
| - /**
|
| - * @return <code>true</code> if given [Token]s contain only single [Token] with given
|
| - * [TokenType].
|
| - */
|
| - static bool hasOnly(List<Token> tokens, TokenType type) => tokens.length == 1 && tokens[0].type == type;
|
| -}
|
| -
|
| -class URIUtils {
|
| - /**
|
| - * Computes relative relative path to reference "target" from "base". Uses ".." if needed, in
|
| - * contrast to [URI#relativize].
|
| - */
|
| - static String computeRelativePath(String base, String target) {
|
| - // convert to URI separator
|
| - base = base.replaceAll("\\\\", "/");
|
| - target = target.replaceAll("\\\\", "/");
|
| - if (base.startsWith("/") && target.startsWith("/")) {
|
| - base = base.substring(1);
|
| - target = target.substring(1);
|
| - }
|
| - // equal paths - no relative
|
| - if (base == target) {
|
| - return null;
|
| - }
|
| - // split paths
|
| - List<String> baseParts = base.split("/");
|
| - List<String> targetParts = target.split("/");
|
| - // prepare maximum possible common root length
|
| - int length = baseParts.length < targetParts.length ? baseParts.length : targetParts.length;
|
| - // find common root
|
| - int lastCommonRoot = -1;
|
| - for (int i = 0; i < length; i++) {
|
| - if (baseParts[i] == targetParts[i]) {
|
| - lastCommonRoot = i;
|
| - } else {
|
| - break;
|
| - }
|
| - }
|
| - // append ..
|
| - JavaStringBuilder relativePath = new JavaStringBuilder();
|
| - for (int i = lastCommonRoot + 1; i < baseParts.length; i++) {
|
| - if (baseParts[i].length > 0) {
|
| - relativePath.append("../");
|
| - }
|
| - }
|
| - // append target folder names
|
| - for (int i = lastCommonRoot + 1; i < targetParts.length - 1; i++) {
|
| - String p = targetParts[i];
|
| - relativePath.append(p);
|
| - relativePath.append("/");
|
| - }
|
| - // append target file name
|
| - relativePath.append(targetParts[targetParts.length - 1]);
|
| - // done
|
| - return relativePath.toString();
|
| - }
|
| -}
|
|
|
Chromium Code Reviews
Issue 484733003:
Import analysis_services.dart into analysis_server.dart. (Closed)
Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart