/*
* Copyright (c) 2013, the Dart project authors.
*
* Licensed under the Eclipse Public License v1.0 (the "License"); you may not use this file except
* in compliance with the License. You may obtain a copy of the License at
*
* http://www.eclipse.org/legal/epl-v10.html
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*/
package com.google.dart.engine.services.internal.correction;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import com.google.dart.engine.ast.AsExpression;
import com.google.dart.engine.ast.AstNode;
import com.google.dart.engine.ast.BinaryExpression;
import com.google.dart.engine.ast.Block;
import com.google.dart.engine.ast.BooleanLiteral;
import com.google.dart.engine.ast.ClassDeclaration;
import com.google.dart.engine.ast.CompilationUnit;
import com.google.dart.engine.ast.ConstructorDeclaration;
import com.google.dart.engine.ast.ConstructorName;
import com.google.dart.engine.ast.Directive;
import com.google.dart.engine.ast.ExportDirective;
import com.google.dart.engine.ast.Expression;
import com.google.dart.engine.ast.FunctionDeclaration;
import com.google.dart.engine.ast.FunctionExpression;
import com.google.dart.engine.ast.Identifier;
import com.google.dart.engine.ast.ImportDirective;
import com.google.dart.engine.ast.InstanceCreationExpression;
import com.google.dart.engine.ast.IsExpression;
import com.google.dart.engine.ast.Label;
import com.google.dart.engine.ast.LibraryDirective;
import com.google.dart.engine.ast.MethodDeclaration;
import com.google.dart.engine.ast.MethodInvocation;
import com.google.dart.engine.ast.NamedExpression;
import com.google.dart.engine.ast.ParenthesizedExpression;
import com.google.dart.engine.ast.PartDirective;
import com.google.dart.engine.ast.PostfixExpression;
import com.google.dart.engine.ast.PrefixExpression;
import com.google.dart.engine.ast.PrefixedIdentifier;
import com.google.dart.engine.ast.PropertyAccess;
import com.google.dart.engine.ast.SimpleIdentifier;
import com.google.dart.engine.ast.Statement;
import com.google.dart.engine.ast.StringLiteral;
import com.google.dart.engine.ast.TypeName;
import com.google.dart.engine.ast.visitor.GeneralizingAstVisitor;
import com.google.dart.engine.ast.visitor.NodeLocator;
import com.google.dart.engine.context.AnalysisContext;
import com.google.dart.engine.element.CompilationUnitElement;
import com.google.dart.engine.element.Element;
import com.google.dart.engine.element.ElementKind;
import com.google.dart.engine.element.ExecutableElement;
import com.google.dart.engine.element.ExportElement;
import com.google.dart.engine.element.ImportElement;
import com.google.dart.engine.element.LibraryElement;
import com.google.dart.engine.element.LocalVariableElement;
import com.google.dart.engine.element.ParameterElement;
import com.google.dart.engine.element.PrefixElement;
import com.google.dart.engine.element.PropertyAccessorElement;
import com.google.dart.engine.element.VariableElement;
import com.google.dart.engine.element.visitor.GeneralizingElementVisitor;
import com.google.dart.engine.internal.scope.Namespace;
import com.google.dart.engine.internal.scope.NamespaceBuilder;
import com.google.dart.engine.scanner.Token;
import com.google.dart.engine.scanner.TokenType;
import com.google.dart.engine.services.change.Edit;
import com.google.dart.engine.services.change.SourceChange;
import com.google.dart.engine.services.internal.util.TokenUtils;
import com.google.dart.engine.source.Source;
import com.google.dart.engine.type.FunctionType;
import com.google.dart.engine.type.InterfaceType;
import com.google.dart.engine.type.Type;
import com.google.dart.engine.utilities.source.SourceRange;
import com.google.dart.engine.utilities.source.SourceRangeFactory;
import static com.google.dart.engine.utilities.source.SourceRangeFactory.rangeEndEnd;
import static com.google.dart.engine.utilities.source.SourceRangeFactory.rangeEndStart;
import static com.google.dart.engine.utilities.source.SourceRangeFactory.rangeNode;
import static com.google.dart.engine.utilities.source.SourceRangeFactory.rangeNodes;
import static com.google.dart.engine.utilities.source.SourceRangeFactory.rangeStartEnd;
import static com.google.dart.engine.utilities.source.SourceRangeFactory.rangeStartStart;
import static com.google.dart.engine.utilities.source.SourceRangeFactory.rangeToken;
import org.apache.commons.lang3.StringUtils;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* Utilities for analyzing {@link CompilationUnit}, its parts and source.
*/
public class CorrectionUtils {
/**
* Describes where to insert new directive or top-level declaration.
*/
public class InsertDesc {
public int offset;
public String prefix = "";
public String suffix = "";
}
/**
* This class is used to hold the source and also its precedence during inverting logical
* expressions.
*/
private static class InvertedCondition {
static InvertedCondition binary(int precedence, InvertedCondition left, String operation,
InvertedCondition right) {
return new InvertedCondition(precedence, parenthesizeIfRequired(left, precedence) + operation
+ parenthesizeIfRequired(right, precedence));
}
static InvertedCondition binary(InvertedCondition left, String operation,
InvertedCondition right) {
return new InvertedCondition(Integer.MAX_VALUE, left.source + operation + right.source);
}
static InvertedCondition simple(String source) {
return new InvertedCondition(Integer.MAX_VALUE, source);
}
final int precedence;
final String source;
InvertedCondition(int precedence, String source) {
this.precedence = precedence;
this.source = source;
}
}
/**
* If {@code true} then {@link #addEdit(SourceChange, String, String, Edit)} validates that
* {@link Edit} replaces correct part of the {@link Source}.
*/
private static boolean DEBUG_VALIDATE_EDITS = true;
private static final String[] KNOWN_METHOD_NAME_PREFIXES = {"get", "is", "to"};
/**
* Validates that the {@link Edit} replaces the expected part of the {@link Source} and adds this
* {@link Edit} to the {@link SourceChange}.
*/
public static void addEdit(AnalysisContext context, SourceChange change, String description,
String expected, Edit edit) throws Exception {
if (DEBUG_VALIDATE_EDITS) {
Source source = change.getSource();
String sourceContent = getSourceContent(context, source);
// prepare range
int beginIndex = edit.getOffset();
int endIndex = beginIndex + edit.getLength();
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.equals(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 {@link List}s are equals at given position.
*/
public static <T> boolean allListsEqual(List<List<T>> lists, int position) {
T element = lists.get(0).get(position);
for (List<T> list : lists) {
if (list.get(position) != element) {
return false;
}
}
return true;
}
/**
* @return the updated {@link String} with applied {@link Edit}s.
*/
public static String applyReplaceEdits(String s, List<Edit> edits) {
// sort edits
edits = Lists.newArrayList(edits);
Collections.sort(edits, new Comparator<Edit>() {
@Override
public int compare(Edit o1, Edit o2) {
return o1.getOffset() - o2.getOffset();
}
});
// apply edits
int delta = 0;
for (Edit edit : edits) {
int editOffset = edit.getOffset() + delta;
String beforeEdit = s.substring(0, editOffset);
String afterEdit = s.substring(editOffset + edit.getLength());
s = beforeEdit + edit.getReplacement() + afterEdit;
delta += getDeltaOffset(edit);
}
// done
return s;
}
/**
* @return <code>true</code> if given {@link SourceRange} covers given {@link AstNode}.
*/
public static boolean covers(SourceRange r, AstNode node) {
SourceRange nodeRange = rangeNode(node);
return r.covers(nodeRange);
}
/**
* @return all direct children of the given {@link Element}.
*/
public static List<Element> getChildren(Element parent) {
return getChildren(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 {@link Element}, with given name.
*/
public static List<Element> getChildren(final Element parent, final String name) {
final List<Element> children = Lists.newArrayList();
parent.accept(new GeneralizingElementVisitor<Void>() {
@Override
public Void visitElement(Element element) {
if (element == parent) {
super.visitElement(element);
} else if (name == null || hasDisplayName(element, name)) {
children.add(element);
}
return null;
}
});
return children;
}
// TODO(scheglov) document and test
public static String getDefaultValueCode(Type type) {
if (type != null) {
String typeName = type.getDisplayName();
if (typeName.equals("bool")) {
return "false";
}
if (typeName.equals("int")) {
return "0";
}
if (typeName.equals("double")) {
return "0.0";
}
if (typeName.equals("String")) {
return "''";
}
}
// no better guess
return "null";
}
/**
* @return the number of characters this {@link Edit} will move offsets after its range.
*/
public static int getDeltaOffset(Edit edit) {
return edit.getReplacement().length() - edit.getLength();
}
/**
* @return the name of the {@link Element} kind.
*/
public static String getElementKindName(Element element) {
ElementKind kind = element.getKind();
return getElementKindName(kind);
}
/**
* @return the display name of the {@link ElementKind}.
*/
public static String getElementKindName(ElementKind kind) {
return kind.getDisplayName();
}
/**
* @return the human name of the {@link Element}.
*/
public static String getElementQualifiedName(Element element) {
ElementKind kind = element.getKind();
switch (kind) {
case FIELD:
case METHOD:
return element.getEnclosingElement().getDisplayName() + "." + element.getDisplayName();
default:
return element.getDisplayName();
}
}
/**
* Returns a class or an unit member enclosing the given {@link AstNode}.
*/
public static AstNode getEnclosingClassOrUnitMember(AstNode node) {
AstNode member = node;
while (node != null) {
if (node instanceof ClassDeclaration) {
return member;
}
if (node instanceof CompilationUnit) {
return member;
}
member = node;
node = node.getParent();
}
return null;
}
/**
* @return the {@link ExecutableElement} of the enclosing executable {@link AstNode}.
*/
public static ExecutableElement getEnclosingExecutableElement(AstNode node) {
while (node != null) {
if (node instanceof FunctionDeclaration) {
return ((FunctionDeclaration) node).getElement();
}
if (node instanceof ConstructorDeclaration) {
return ((ConstructorDeclaration) node).getElement();
}
if (node instanceof MethodDeclaration) {
return ((MethodDeclaration) node).getElement();
}
node = node.getParent();
}
return null;
}
/**
* @return the enclosing executable {@link AstNode}.
*/
public static AstNode getEnclosingExecutableNode(AstNode node) {
while (node != null) {
if (node instanceof FunctionDeclaration) {
return node;
}
if (node instanceof ConstructorDeclaration) {
return node;
}
if (node instanceof MethodDeclaration) {
return node;
}
node = node.getParent();
}
return null;
}
/**
* @return {@link Element} exported from the given {@link LibraryElement}.
*/
public static Element getExportedElement(LibraryElement library, String name) {
if (library == null) {
return null;
}
return getExportNamespace(library).get(name);
}
/**
* TODO(scheglov) may be replace with some API for this
*
* @return the namespace of the given {@link ExportElement}.
*/
public static Map<String, Element> getExportNamespace(ExportElement exp) {
Namespace namespace = new NamespaceBuilder().createExportNamespaceForDirective(exp);
return namespace.getDefinedNames();
}
/**
* TODO(scheglov) may be replace with some API for this
*
* @return the export namespace of the given {@link LibraryElement}.
*/
public static Map<String, Element> getExportNamespace(LibraryElement library) {
Namespace namespace = new NamespaceBuilder().createExportNamespaceForLibrary(library);
return namespace.getDefinedNames();
}
/**
* @return {@link #getExpressionPrecedence(AstNode)} for parent node, or {@code 0} if parent node
* is {@link ParenthesizedExpression}. The reason is that {@code (expr)} is always
* executed after {@code expr}.
*/
public static int getExpressionParentPrecedence(AstNode node) {
AstNode parent = node.getParent();
if (parent instanceof ParenthesizedExpression) {
return 0;
}
return getExpressionPrecedence(parent);
}
/**
* @return the precedence of the given node - result of {@link Expression#getPrecedence()} if an
* {@link Expression}, negative otherwise.
*/
public static int getExpressionPrecedence(AstNode node) {
if (node instanceof Expression) {
return ((Expression) node).getPrecedence();
}
return -1000;
}
/**
* TODO(scheglov) may be replace with some API for this
*
* @return the namespace of the given {@link ImportElement}.
*/
public static Map<String, Element> getImportNamespace(ImportElement imp) {
Namespace namespace = new NamespaceBuilder().createImportNamespaceForDirective(imp);
return namespace.getDefinedNames();
}
/**
* @return all {@link CompilationUnitElement} the given {@link LibraryElement} consists of.
*/
public static List<CompilationUnitElement> getLibraryUnits(LibraryElement library) {
List<CompilationUnitElement> units = Lists.newArrayList();
units.add(library.getDefiningCompilationUnit());
Collections.addAll(units, library.getParts());
return units;
}
/**
* @return the line prefix from the given source, i.e. basically just whitespace prefix of the
* given {@link String}.
*/
public static String getLinesPrefix(String lines) {
int index = 0;
while (index < lines.length()) {
char c = lines.charAt(index);
if (!Character.isWhitespace(c)) {
break;
}
index++;
}
return lines.substring(0, index);
}
/**
* @return the {@link LocalVariableElement} or {@link ParameterElement} if given
* {@link SimpleIdentifier} is the reference to local variable or parameter, or
* <code>null</code> in the other case.
*/
public static VariableElement getLocalOrParameterVariableElement(SimpleIdentifier node) {
Element element = node.getStaticElement();
if (element instanceof LocalVariableElement) {
return (LocalVariableElement) element;
}
if (element instanceof ParameterElement) {
return (ParameterElement) element;
}
return null;
}
/**
* @return the {@link LocalVariableElement} if given {@link SimpleIdentifier} is the reference to
* local variable, or <code>null</code> in the other case.
*/
public static LocalVariableElement getLocalVariableElement(SimpleIdentifier node) {
Element element = node.getStaticElement();
if (element instanceof LocalVariableElement) {
return (LocalVariableElement) element;
}
return null;
}
/**
* @return the nearest common ancestor {@link AstNode} of the given {@link AstNode}s.
*/
public static AstNode getNearestCommonAncestor(List<AstNode> nodes) {
// may be no nodes
if (nodes.isEmpty()) {
return null;
}
// prepare parents
List<List<AstNode>> parents = Lists.newArrayList();
for (AstNode node : nodes) {
parents.add(getParents(node));
}
// find min length
int minLength = Integer.MAX_VALUE;
for (List<AstNode> parentList : parents) {
minLength = Math.min(minLength, parentList.size());
}
// find deepest parent
int i = 0;
for (; i < minLength; i++) {
if (!allListsEqual(parents, i)) {
break;
}
}
return parents.get(0).get(i - 1);
}
/**
* @return the {@link Expression} qualified if given node is name part of a {@link PropertyAccess}
* or {@link PrefixedIdentifier}. May be <code>null</code>.
*/
public static Expression getNodeQualifier(SimpleIdentifier node) {
AstNode parent = node.getParent();
if (parent instanceof PropertyAccess) {
PropertyAccess propertyAccess = (PropertyAccess) parent;
if (propertyAccess.getPropertyName() == node) {
return propertyAccess.getTarget();
}
}
if (parent instanceof PrefixedIdentifier) {
PrefixedIdentifier prefixed = (PrefixedIdentifier) parent;
if (prefixed.getIdentifier() == node) {
return prefixed.getPrefix();
}
}
return null;
}
/**
* @return the {@link ParameterElement} if given {@link SimpleIdentifier} is the reference to
* parameter, or <code>null</code> in the other case.
*/
public static ParameterElement getParameterElement(SimpleIdentifier node) {
Element element = node.getStaticElement();
if (element instanceof ParameterElement) {
return (ParameterElement) element;
}
return null;
}
/**
* @return the precedence of the given {@link Expression} parent. May be {@code -1} no operator.
* @see #getPrecedence(Expression)
*/
public static int getParentPrecedence(Expression expression) {
AstNode parent = expression.getParent();
if (parent instanceof Expression) {
return getPrecedence((Expression) parent);
}
return -1;
}
/**
* @return parent {@link AstNode}s from {@link CompilationUnit} (at index "0") to the given one.
*/
public static List<AstNode> getParents(AstNode node) {
// prepare number of parents
int numParents = 0;
{
AstNode current = node.getParent();
while (current != null) {
numParents++;
current = current.getParent();
}
}
// fill array of parents
AstNode[] parents = new AstNode[numParents];
AstNode current = node.getParent();
int index = numParents;
while (current != null) {
parents[--index] = current;
current = current.getParent();
}
return Arrays.asList(parents);
}
/**
* @return the precedence of the given {@link Expression} operator. May be
* {@code Integer#MAX_VALUE} if not an operator.
*/
public static int getPrecedence(Expression expression) {
if (expression instanceof BinaryExpression) {
BinaryExpression binaryExpression = (BinaryExpression) expression;
return binaryExpression.getOperator().getType().getPrecedence();
}
if (expression instanceof PrefixExpression) {
PrefixExpression prefixExpression = (PrefixExpression) expression;
return prefixExpression.getOperator().getType().getPrecedence();
}
if (expression instanceof PostfixExpression) {
PostfixExpression postfixExpression = (PostfixExpression) expression;
return postfixExpression.getOperator().getType().getPrecedence();
}
return Integer.MAX_VALUE;
}
/**
* @return the {@link PropertyAccessorElement} if given {@link SimpleIdentifier} is the reference
* to property, or <code>null</code> in the other case.
*/
public static PropertyAccessorElement getPropertyAccessorElement(SimpleIdentifier node) {
Element element = node.getStaticElement();
if (element instanceof PropertyAccessorElement) {
return (PropertyAccessorElement) element;
}
return null;
}
/**
* If given {@link AstNode} is name of qualified property extraction, returns target from which
* this property is extracted. Otherwise {@code null}.
*/
public static Expression getQualifiedPropertyTarget(AstNode node) {
AstNode parent = node.getParent();
if (parent instanceof PrefixedIdentifier) {
PrefixedIdentifier prefixed = (PrefixedIdentifier) parent;
if (prefixed.getIdentifier() == node) {
return ((PrefixedIdentifier) parent).getPrefix();
}
}
if (parent instanceof PropertyAccess) {
PropertyAccess access = (PropertyAccess) parent;
if (access.getPropertyName() == node) {
return access.getRealTarget();
}
}
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.
*/
public static String getRecommentedFileNameForClass(String className) {
int len = className.length();
StringBuilder sb = new StringBuilder(len * 2);
boolean prevWasUpper = false;
for (int i = 0; i < len; i++) {
char c = className.charAt(i);
if (Character.isUpperCase(c)) {
boolean nextIsUpper = i < len - 1 && Character.isUpperCase(className.charAt(i + 1));
if (i == 0) {
// HttpServer
// ^
} else if (prevWasUpper) {
// HTTPServer
// ^
if (!nextIsUpper) {
sb.append('_');
}
} else {
// HttpServer
// ^
sb.append('_');
}
prevWasUpper = true;
c = Character.toLowerCase(c);
} else {
prevWasUpper = false;
}
sb.append(c);
}
sb.append(".dart");
String fileName = sb.toString();
return fileName;
}
/**
* @return given {@link Statement} if not {@link Block}, first child {@link Statement} if
* {@link Block}, or <code>null</code> if more than one child.
*/
public static Statement getSingleStatement(Statement statement) {
if (statement instanceof Block) {
List<Statement> blockStatements = ((Block) statement).getStatements();
if (blockStatements.size() != 1) {
return null;
}
return blockStatements.get(0);
}
return statement;
}
/**
* @return the {@link String} content of the given {@link Source}.
*/
public static String getSourceContent(AnalysisContext context, Source source) throws Exception {
return context.getContents(source).getData().toString();
}
/**
* @return given {@link Statement} if not {@link Block}, all children {@link Statement}s if
* {@link Block}.
*/
public static List<Statement> getStatements(Statement statement) {
if (statement instanceof Block) {
return ((Block) statement).getStatements();
}
return ImmutableList.of(statement);
}
/**
* @return all top-level elements declared in the given {@link LibraryElement}.
*/
public static List<Element> getTopLevelElements(LibraryElement library) {
List<Element> elements = Lists.newArrayList();
List<CompilationUnitElement> units = getLibraryUnits(library);
for (CompilationUnitElement unit : units) {
Collections.addAll(elements, unit.getFunctions());
Collections.addAll(elements, unit.getFunctionTypeAliases());
Collections.addAll(elements, unit.getTypes());
Collections.addAll(elements, unit.getTopLevelVariables());
}
return elements;
}
/**
* @return the possible names for variable with initializer of the given {@link StringLiteral}.
*/
public static String[] getVariableNameSuggestions(String text, Set<String> excluded) {
// filter out everything except of letters and white spaces
{
StringBuilder sb = new StringBuilder();
for (int i = 0; i < text.length(); i++) {
char c = text.charAt(i);
if (Character.isLetter(c) || Character.isWhitespace(c)) {
sb.append(c);
}
}
text = sb.toString();
}
// make single camel-case text
{
String[] words = StringUtils.split(text);
StringBuilder sb = new StringBuilder();
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 = Sets.newLinkedHashSet();
addAll(excluded, res, getVariableNameSuggestions(text));
return res.toArray(new String[res.size()]);
}
/**
* @return the possible names for variable with given expected type and expression.
*/
public static String[] getVariableNameSuggestions(Type expectedType,
Expression assignedExpression, Set<String> excluded) {
Set<String> res = Sets.newLinkedHashSet();
// 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.getName();
if ("int".equals(typeName)) {
addSingleCharacterName(excluded, res, 'i');
} else if ("double".equals(typeName)) {
addSingleCharacterName(excluded, res, 'd');
} else if ("String".equals(typeName)) {
addSingleCharacterName(excluded, res, 's');
} else {
addAll(excluded, res, getVariableNameSuggestions(typeName));
}
res.remove(typeName);
}
// done
return res.toArray(new String[res.size()]);
}
/**
* @return {@code true} if the given {@link Element#getDisplayName()} equals to the given name.
*/
public static boolean hasDisplayName(Element element, String name) {
if (element == null) {
return false;
}
String elementDisplayName = element.getDisplayName();
return StringUtils.equals(elementDisplayName, name);
}
/**
* @return {@code true} if the given {@link Element#getName()} equals to the given name.
*/
public static boolean hasName(Element element, String name) {
if (element == null) {
return false;
}
String elementName = element.getName();
return StringUtils.equals(elementName, name);
}
/**
* @return {@code true} if the given {@link SimpleIdentifier} is the name of the
* {@link NamedExpression}.
*/
public static boolean isNamedExpressionName(SimpleIdentifier node) {
AstNode parent = node.getParent();
if (parent instanceof Label) {
Label label = (Label) parent;
if (label.getLabel() == node) {
AstNode parent2 = label.getParent();
if (parent2 instanceof NamedExpression) {
return ((NamedExpression) parent2).getName() == label;
}
}
}
return false;
}
/**
* Adds "toAdd" items which are not excluded.
*/
private static void addAll(Set<String> excluded, Set<String> result, Collection<String> toAdd) {
for (String item : 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 += Integer.toString(suffix);
}
// 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.
*/
private static void addSingleCharacterName(Set<String> excluded, Set<String> result, char c) {
while (c < 'z') {
String name = String.valueOf(c);
// may be done
if (!excluded.contains(name)) {
result.add(name);
break;
}
// next character
c = (char) (c + 1);
}
}
private static String getBaseNameFromExpression(Expression expression) {
String name = null;
// e as Type
if (expression instanceof AsExpression) {
AsExpression asExpression = (AsExpression) expression;
expression = asExpression.getExpression();
}
// analyze expressions
if (expression instanceof SimpleIdentifier) {
SimpleIdentifier node = (SimpleIdentifier) expression;
return node.getName();
} else if (expression instanceof PrefixedIdentifier) {
PrefixedIdentifier node = (PrefixedIdentifier) expression;
return node.getIdentifier().getName();
} else if (expression instanceof MethodInvocation) {
name = ((MethodInvocation) expression).getMethodName().getName();
} else if (expression instanceof InstanceCreationExpression) {
InstanceCreationExpression creation = (InstanceCreationExpression) expression;
ConstructorName constructorName = creation.getConstructorName();
TypeName typeName = constructorName.getType();
if (typeName != null) {
Identifier typeNameIdentifier = typeName.getName();
// new ClassName()
if (typeNameIdentifier instanceof SimpleIdentifier) {
return typeNameIdentifier.getName();
}
// new prefix.name();
if (typeNameIdentifier instanceof PrefixedIdentifier) {
PrefixedIdentifier prefixed = (PrefixedIdentifier) typeNameIdentifier;
// new prefix.ClassName()
if (prefixed.getPrefix().getStaticElement() instanceof PrefixElement) {
return prefixed.getIdentifier().getName();
}
// new ClassName.constructorName()
return prefixed.getPrefix().getName();
}
}
}
// 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.equals(curr)) {
return null; // don't suggest 'get' as variable name
} else if (Character.isUpperCase(name.charAt(curr.length()))) {
return name.substring(curr.length());
}
}
}
}
// done
return name;
}
private static String getBaseNameFromLocationInParent(Expression expression) {
// value in named expression
if (expression.getParent() instanceof NamedExpression) {
NamedExpression namedExpression = (NamedExpression) expression.getParent();
if (namedExpression.getExpression() == expression) {
return namedExpression.getName().getLabel().getName();
}
}
// positional argument
{
ParameterElement parameter = expression.getPropagatedParameterElement();
if (parameter == null) {
parameter = expression.getStaticParameterElement();
}
if (parameter != null) {
return parameter.getDisplayName();
}
}
// unknown
return null;
}
/**
* @return {@link Expression}s from <code>operands</code> which are completely covered by given
* {@link SourceRange}. Range should start and end between given {@link Expression}s.
*/
private static List<Expression> getOperandsForSourceRange(List<Expression> operands,
SourceRange range) {
assert !operands.isEmpty();
List<Expression> subOperands = Lists.newArrayList();
// track range enter/exit
boolean entered = false;
boolean exited = false;
// may be range starts before or on first operand
if (range.getOffset() <= operands.get(0).getOffset()) {
entered = true;
}
// iterate over gaps between operands
for (int i = 0; i < operands.size() - 1; i++) {
Expression operand = operands.get(i);
Expression nextOperand = operands.get(i + 1);
SourceRange inclusiveGap = 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.get(operands.size() - 1);
if (range.getEnd() == lastGroupMember.getEnd()) {
subOperands.add(lastGroupMember);
exited = true;
}
// we expect that range covers only given operands
if (!exited) {
return Lists.newArrayList();
}
// done
return subOperands;
}
/**
* @return all operands of the given {@link BinaryExpression} and its children with the same
* operator.
*/
private static List<Expression> getOperandsInOrderFor(BinaryExpression groupRoot) {
final List<Expression> operands = Lists.newArrayList();
final TokenType groupOperatorType = groupRoot.getOperator().getType();
groupRoot.accept(new GeneralizingAstVisitor<Void>() {
@Override
public Void visitExpression(Expression node) {
if (node instanceof BinaryExpression
&& ((BinaryExpression) node).getOperator().getType() == groupOperatorType) {
return super.visitNode(node);
}
operands.add(node);
return null;
}
});
return operands;
}
/**
* @return all variants of names by removing leading words by one.
*/
private static List<String> getVariableNameSuggestions(String name) {
List<String> result = Lists.newArrayList();
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 {@link InvertedCondition} if less than the
* precedence of the expression we are going it to use in.
*/
private static String parenthesizeIfRequired(InvertedCondition expr, int newOperatorPrecedence) {
if (expr.precedence < newOperatorPrecedence) {
return "(" + expr.source + ")";
}
return expr.source;
}
private final CompilationUnit unit;
private final LibraryElement library;
private final String buffer;
private String endOfLine;
public CorrectionUtils(CompilationUnit unit) throws Exception {
this.unit = unit;
CompilationUnitElement element = unit.getElement();
this.library = element.getLibrary();
this.buffer = getSourceContent(element.getContext(), element.getSource());
}
/**
* @return the source of the given {@link SourceRange} with indentation changed from "oldIndent"
* to "newIndent", keeping indentation of the lines relative to each other.
*/
public Edit createIndentEdit(SourceRange range, String oldIndent, String newIndent) {
String newSource = getIndentSource(range, oldIndent, newIndent);
return new Edit(range.getOffset(), range.getLength(), newSource);
}
/**
* @return the {@link AstNode} that encloses the given offset.
*/
public AstNode findNode(int offset) {
return new NodeLocator(offset).searchWithin(unit);
}
/**
* TODO(scheglov) replace with nodes once there will be {@link CompilationUnit#getComments()}.
*
* @return the {@link SourceRange}s of all comments in {@link CompilationUnit}.
*/
public List<SourceRange> getCommentRanges() {
List<SourceRange> ranges = Lists.newArrayList();
Token token = unit.getBeginToken();
while (token != null && token.getType() != TokenType.EOF) {
Token commentToken = token.getPrecedingComments();
while (commentToken != null) {
ranges.add(SourceRangeFactory.rangeToken(commentToken));
commentToken = commentToken.getNext();
}
token = token.getNext();
}
return ranges;
}
/**
* @return the EOL to use for this {@link CompilationUnit}.
*/
public String getEndOfLine() {
if (endOfLine == null) {
if (buffer.contains("\r\n")) {
endOfLine = "\r\n";
} else {
endOfLine = "\n";
}
}
return endOfLine;
}
/**
* @return the default indentation with given level.
*/
public String getIndent(int level) {
return StringUtils.repeat(" ", level);
}
/**
* @return the source of the given {@link SourceRange} with indentation changed from "oldIndent"
* to "newIndent", keeping indentation of the lines relative to each other.
*/
public String getIndentSource(SourceRange range, String oldIndent, String newIndent) {
String oldSource = getText(range);
return getIndentSource(oldSource, oldIndent, newIndent);
}
/**
* Indents given source left or right.
*
* @return the source with changed indentation.
*/
public String getIndentSource(String source, boolean right) {
StringBuilder sb = new StringBuilder();
String indent = getIndent(1);
String eol = getEndOfLine();
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.
*/
public String getIndentSource(String source, String oldIndent, String newIndent) {
// prepare STRING token ranges
List<SourceRange> lineRanges = Lists.newArrayList();
for (Token token : TokenUtils.getTokens(source)) {
if (token.getType() == TokenType.STRING) {
lineRanges.add(rangeToken(token));
}
}
// re-indent lines
StringBuilder sb = new StringBuilder();
String eol = getEndOfLine();
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
boolean inString = false;
for (SourceRange lineRange : lineRanges) {
inString |= lineOffset > lineRange.getOffset() && lineOffset < lineRange.getEnd();
if (lineOffset > lineRange.getEnd()) {
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 {@link InsertDesc}, description where to insert new library-related directive.
*/
public InsertDesc getInsertDescImport() {
// analyze directives
Directive prevDirective = null;
for (Directive directive : unit.getDirectives()) {
if (directive instanceof LibraryDirective || directive instanceof ImportDirective
|| directive instanceof ExportDirective) {
prevDirective = directive;
}
}
// insert after last library-related directive
if (prevDirective != null) {
InsertDesc result = new InsertDesc();
result.offset = prevDirective.getEnd();
String eol = getEndOfLine();
if (prevDirective instanceof LibraryDirective) {
result.prefix = eol + eol;
} else {
result.prefix = eol;
}
return result;
}
// no directives, use "top" location
return getInsertDescTop();
}
/**
* @return {@link InsertDesc}, description where to insert new 'part 'directive.
*/
public InsertDesc getInsertDescPart() {
// analyze directives
Directive prevDirective = null;
for (Directive directive : unit.getDirectives()) {
prevDirective = directive;
}
// insert after last directive
if (prevDirective != null) {
InsertDesc result = new InsertDesc();
result.offset = prevDirective.getEnd();
String eol = getEndOfLine();
if (prevDirective instanceof PartDirective) {
result.prefix = eol;
} else {
result.prefix = eol + eol;
}
return result;
}
// no directives, use "top" location
return getInsertDescTop();
}
/**
* @return {@link InsertDesc}, description where to insert new directive or top-level declaration
* at the top of file.
*/
public InsertDesc getInsertDescTop() {
// skip leading line comments
int offset = 0;
boolean insertEmptyLineBefore = false;
boolean insertEmptyLineAfter = false;
String source = getText();
// skip hash-bang
if (offset < source.length() - 2) {
String linePrefix = getText(offset, 2);
if (linePrefix.equals("#!")) {
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 = getText(offset, 2);
if (linePrefix.equals("//")) {
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
InsertDesc desc = new InsertDesc();
desc.offset = offset;
if (insertEmptyLineBefore) {
desc.prefix = getEndOfLine();
}
if (insertEmptyLineAfter) {
desc.suffix = getEndOfLine();
}
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.
*/
public int getLineContentEnd(int index) {
int length = buffer.length();
// skip whitespace characters
while (index < length) {
char c = buffer.charAt(index);
if (!Character.isWhitespace(c) || c == '\r' || c == '\n') {
break;
}
index++;
}
// skip single \r
if (index < length && buffer.charAt(index) == '\r') {
index++;
}
// skip single \n
if (index < length && buffer.charAt(index) == '\n') {
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.
*/
public int getLineContentStart(int index) {
while (index > 0) {
char c = buffer.charAt(index - 1);
if (c != ' ' && c != '\t') {
break;
}
index--;
}
return index;
}
/**
* @return the start index of the next line after the line which contains given index.
*/
public int getLineNext(int index) {
int length = buffer.length();
// skip to the end of the line
while (index < length) {
char c = buffer.charAt(index);
if (c == '\r' || c == '\n') {
break;
}
index++;
}
// skip single \r
if (index < length && buffer.charAt(index) == '\r') {
index++;
}
// skip single \n
if (index < length && buffer.charAt(index) == '\n') {
index++;
}
// done
return index;
}
/**
* @return the whitespace prefix of the line which contains given offset.
*/
public String getLinePrefix(int index) {
int lineStart = getLineThis(index);
int length = buffer.length();
int lineNonWhitespace = lineStart;
while (lineNonWhitespace < length) {
char c = buffer.charAt(lineNonWhitespace);
if (c == '\r' || c == '\n') {
break;
}
if (!Character.isWhitespace(c)) {
break;
}
lineNonWhitespace++;
}
return getText(lineStart, lineNonWhitespace - lineStart);
}
/**
* @return the {@link #getLinesRange(SourceRange)} for given {@link Statement}s.
*/
public SourceRange getLinesRange(List<Statement> statements) {
SourceRange range = rangeNodes(statements);
return getLinesRange(range);
}
/**
* @return the {@link 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 {@link SourceRange}, i.e. basically
* complete lines of the source for given {@link SourceRange}.
*/
public SourceRange getLinesRange(SourceRange range) {
// start
int startOffset = range.getOffset();
int startLineOffset = getLineContentStart(startOffset);
// end
int endOffset = range.getEnd();
int afterEndLineOffset = getLineContentEnd(endOffset);
// range
return rangeStartEnd(startLineOffset, afterEndLineOffset);
}
/**
* @return the {@link #getLinesRange(SourceRange)} for given {@link Statement}s.
*/
public SourceRange getLinesRange(Statement... statements) {
return getLinesRange(Lists.newArrayList(statements));
}
/**
* @return the start index of the line which contains given index.
*/
public int getLineThis(int index) {
while (index > 0) {
char c = buffer.charAt(index - 1);
if (c == '\r' || c == '\n') {
break;
}
index--;
}
return index;
}
/**
* @return the line prefix consisting of spaces and tabs on the left from the given
* {@link AstNode}.
*/
public String getNodePrefix(AstNode node) {
int offset = node.getOffset();
// function literal is special, it uses offset of enclosing line
if (node instanceof 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.
*/
public int getNonWhitespaceForward(int index) {
int length = buffer.length();
// skip whitespace characters
while (index < length) {
char c = buffer.charAt(index);
if (!Character.isWhitespace(c)) {
break;
}
index++;
}
// done
return index;
}
/**
* @return the source for the parameter with the given type and name.
*/
public String getParameterSource(Type type, String name) {
// no type
if (type == null || type.isDynamic()) {
return name;
}
// function type
if (type instanceof FunctionType) {
FunctionType functionType = (FunctionType) type;
StringBuilder sb = new StringBuilder();
// return type
Type returnType = functionType.getReturnType();
if (returnType != null && !returnType.isDynamic()) {
sb.append(getTypeSource(returnType));
sb.append(' ');
}
// parameter name
sb.append(name);
// parameters
sb.append('(');
ParameterElement[] fParameters = functionType.getParameters();
for (int i = 0; i < fParameters.length; i++) {
ParameterElement fParameter = fParameters[i];
if (i != 0) {
sb.append(", ");
}
sb.append(getParameterSource(fParameter.getType(), fParameter.getName()));
}
sb.append(')');
// done
return sb.toString();
}
// simple type
return getTypeSource(type) + " " + name;
}
/**
* @return the line prefix consisting of spaces and tabs on the left from the given offset.
*/
public String getPrefix(int endIndex) {
int startIndex = getLineContentStart(endIndex);
return buffer.substring(startIndex, endIndex);
}
/**
* @return the full text of unit.
*/
public String getText() {
return buffer;
}
/**
* @return the given range of text from unit.
*/
public String getText(AstNode node) {
return getText(node.getOffset(), node.getLength());
}
/**
* @return the given range of text from unit.
*/
public String getText(int offset, int length) {
return buffer.substring(offset, offset + length);
}
/**
* @return the given range of text from unit.
*/
public String getText(SourceRange range) {
return getText(range.getOffset(), range.getLength());
}
/**
* @return the actual type source of the given {@link Expression}, may be {@code null} if can not
* be resolved, should be treated as <code>Dynamic</code>.
*/
public String getTypeSource(Expression expression) {
if (expression == null) {
return null;
}
Type type = expression.getBestType();
String typeSource = getTypeSource(type);
if ("dynamic".equals(typeSource)) {
return null;
}
return typeSource;
}
/**
* @return the source to reference the given {@link Type} in this {@link CompilationUnit}.
*/
public String getTypeSource(Type type) {
StringBuilder sb = new StringBuilder();
// prepare element
Element element = type.getElement();
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.getPrefix() != null) {
sb.append(imp.getPrefix().getDisplayName());
sb.append(".");
}
}
// append simple name
String name = element.getDisplayName();
sb.append(name);
// may be type arguments
if (type instanceof InterfaceType) {
InterfaceType interfaceType = (InterfaceType) type;
Type[] arguments = interfaceType.getTypeArguments();
// check if has arguments
boolean hasArguments = false;
for (Type argument : arguments) {
if (!argument.isDynamic()) {
hasArguments = true;
break;
}
}
// append type arguments
if (hasArguments) {
sb.append("<");
for (int i = 0; i < arguments.length; i++) {
Type argument = arguments[i];
if (i != 0) {
sb.append(", ");
}
sb.append(getTypeSource(argument));
}
sb.append(">");
}
}
// done
return sb.toString();
}
/**
* @return the underlying {@link CompilationUnit}.
*/
public CompilationUnit getUnit() {
return unit;
}
/**
* @return the source of the inverted condition for the given logical expression.
*/
public String invertCondition(Expression expression) {
return invertCondition0(expression).source;
}
/**
* @return <code>true</code> if selection range contains only whitespace.
*/
public boolean isJustWhitespace(SourceRange range) {
return getText(range).trim().length() == 0;
}
/**
* @return <code>true</code> if selection range contains only whitespace or comments
*/
public boolean isJustWhitespaceOrComment(SourceRange range) {
String trimmedText = getText(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.
*/
public boolean selectionIncludesNonWhitespaceOutsideNode(SourceRange selection, AstNode node) {
return selectionIncludesNonWhitespaceOutsideRange(selection, rangeNode(node));
}
/**
* @return <code>true</code> if given range of {@link BinaryExpression} can be extracted.
*/
public boolean validateBinaryExpressionRange(BinaryExpression binaryExpression, SourceRange range) {
// only parts of associative expression are safe to extract
if (!binaryExpression.getOperator().getType().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 {@link ImportElement} used to import given {@link Element} into {@link #library}.
* May be {@code null} if was not imported, i.e. declared in the same library.
*/
private ImportElement getImportElement(Element element) {
for (ImportElement imp : library.getImports()) {
Map<String, Element> definedNames = getImportNamespace(imp);
if (definedNames.containsValue(element)) {
return imp;
}
}
return null;
}
/**
* @return the {@link InvertedCondition} for the given logical expression.
*/
private InvertedCondition invertCondition0(Expression expression) {
if (expression instanceof BooleanLiteral) {
BooleanLiteral literal = (BooleanLiteral) expression;
if (literal.getValue()) {
return InvertedCondition.simple("false");
} else {
return InvertedCondition.simple("true");
}
}
if (expression instanceof BinaryExpression) {
BinaryExpression binary = (BinaryExpression) expression;
TokenType operator = binary.getOperator().getType();
Expression le = binary.getLeftOperand();
Expression re = binary.getRightOperand();
InvertedCondition ls = invertCondition0(le);
InvertedCondition rs = invertCondition0(re);
if (operator == TokenType.LT) {
return InvertedCondition.binary(ls, " >= ", rs);
}
if (operator == TokenType.GT) {
return InvertedCondition.binary(ls, " <= ", rs);
}
if (operator == TokenType.LT_EQ) {
return InvertedCondition.binary(ls, " > ", rs);
}
if (operator == TokenType.GT_EQ) {
return InvertedCondition.binary(ls, " < ", rs);
}
if (operator == TokenType.EQ_EQ) {
return InvertedCondition.binary(ls, " != ", rs);
}
if (operator == TokenType.BANG_EQ) {
return InvertedCondition.binary(ls, " == ", rs);
}
if (operator == TokenType.AMPERSAND_AMPERSAND) {
int newPrecedence = TokenType.BAR_BAR.getPrecedence();
return InvertedCondition.binary(newPrecedence, ls, " || ", rs);
}
if (operator == TokenType.BAR_BAR) {
int newPrecedence = TokenType.AMPERSAND_AMPERSAND.getPrecedence();
return InvertedCondition.binary(newPrecedence, ls, " && ", rs);
}
}
if (expression instanceof IsExpression) {
IsExpression isExpression = (IsExpression) expression;
String expressionSource = getText(isExpression.getExpression());
String typeSource = getText(isExpression.getType());
if (isExpression.getNotOperator() == null) {
return InvertedCondition.simple(expressionSource + " is! " + typeSource);
} else {
return InvertedCondition.simple(expressionSource + " is " + typeSource);
}
}
if (expression instanceof PrefixExpression) {
PrefixExpression prefixExpression = (PrefixExpression) expression;
TokenType operator = prefixExpression.getOperator().getType();
if (operator == TokenType.BANG) {
Expression operand = prefixExpression.getOperand();
while (operand instanceof ParenthesizedExpression) {
ParenthesizedExpression pe = (ParenthesizedExpression) operand;
operand = pe.getExpression();
}
return InvertedCondition.simple(getText(operand));
}
}
if (expression instanceof ParenthesizedExpression) {
ParenthesizedExpression pe = (ParenthesizedExpression) expression;
Expression innerExpresion = pe.getExpression();
while (innerExpresion instanceof ParenthesizedExpression) {
innerExpresion = ((ParenthesizedExpression) innerExpresion).getExpression();
}
return invertCondition0(innerExpresion);
}
Type type = expression.getBestType();
if (type.getDisplayName().equals("bool")) {
return InvertedCondition.simple("!" + getText(expression));
}
return InvertedCondition.simple(getText(expression));
}
private boolean selectionIncludesNonWhitespaceOutsideOperands(SourceRange selection,
List<Expression> operands) {
return selectionIncludesNonWhitespaceOutsideRange(selection, rangeNodes(operands));
}
/**
* @return <code>true</code> if "selection" covers "range" and there are any non-whitespace tokens
* between "selection" and "range" start/end.
*/
private boolean 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(rangeStartStart(selection, range))) {
return true;
}
// non-whitespace after range
if (!isJustWhitespaceOrComment(rangeEndEnd(range, selection))) {
return true;
}
// only whitespace in selection around range
return false;
}
}