/*
* 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.annotations.VisibleForTesting;
import com.google.common.base.Objects;
import com.google.common.base.Predicate;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import com.google.dart.engine.ast.ArgumentList;
import com.google.dart.engine.ast.AsExpression;
import com.google.dart.engine.ast.AssertStatement;
import com.google.dart.engine.ast.AssignmentExpression;
import com.google.dart.engine.ast.AstNode;
import com.google.dart.engine.ast.BinaryExpression;
import com.google.dart.engine.ast.ClassDeclaration;
import com.google.dart.engine.ast.ClassMember;
import com.google.dart.engine.ast.CompilationUnit;
import com.google.dart.engine.ast.CompilationUnitMember;
import com.google.dart.engine.ast.ConstructorDeclaration;
import com.google.dart.engine.ast.ConstructorInitializer;
import com.google.dart.engine.ast.ConstructorName;
import com.google.dart.engine.ast.Directive;
import com.google.dart.engine.ast.DoStatement;
import com.google.dart.engine.ast.Expression;
import com.google.dart.engine.ast.ExpressionStatement;
import com.google.dart.engine.ast.FieldDeclaration;
import com.google.dart.engine.ast.FunctionBody;
import com.google.dart.engine.ast.Identifier;
import com.google.dart.engine.ast.IfStatement;
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.LibraryDirective;
import com.google.dart.engine.ast.MethodDeclaration;
import com.google.dart.engine.ast.MethodInvocation;
import com.google.dart.engine.ast.NamespaceDirective;
import com.google.dart.engine.ast.ParenthesizedExpression;
import com.google.dart.engine.ast.PartDirective;
import com.google.dart.engine.ast.PrefixExpression;
import com.google.dart.engine.ast.PrefixedIdentifier;
import com.google.dart.engine.ast.ReturnStatement;
import com.google.dart.engine.ast.SimpleIdentifier;
import com.google.dart.engine.ast.SimpleStringLiteral;
import com.google.dart.engine.ast.TypeName;
import com.google.dart.engine.ast.VariableDeclaration;
import com.google.dart.engine.ast.WhileStatement;
import com.google.dart.engine.ast.visitor.NodeLocator;
import com.google.dart.engine.context.AnalysisContext;
import com.google.dart.engine.element.ClassElement;
import com.google.dart.engine.element.CompilationUnitElement;
import com.google.dart.engine.element.ConstructorElement;
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.FunctionElement;
import com.google.dart.engine.element.ImportElement;
import com.google.dart.engine.element.LibraryElement;
import com.google.dart.engine.element.MethodElement;
import com.google.dart.engine.element.NamespaceCombinator;
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.ShowElementCombinator;
import com.google.dart.engine.element.VariableElement;
import com.google.dart.engine.element.visitor.RecursiveElementVisitor;
import com.google.dart.engine.error.AnalysisError;
import com.google.dart.engine.error.AnalysisErrorWithProperties;
import com.google.dart.engine.error.CompileTimeErrorCode;
import com.google.dart.engine.error.ErrorCode;
import com.google.dart.engine.error.ErrorProperty;
import com.google.dart.engine.error.HintCode;
import com.google.dart.engine.error.StaticTypeWarningCode;
import com.google.dart.engine.error.StaticWarningCode;
import com.google.dart.engine.internal.type.VoidTypeImpl;
import com.google.dart.engine.parser.ParserErrorCode;
import com.google.dart.engine.scanner.TokenType;
import com.google.dart.engine.sdk.DartSdk;
import com.google.dart.engine.sdk.SdkLibrary;
import com.google.dart.engine.services.assist.AssistContext;
import com.google.dart.engine.services.change.Edit;
import com.google.dart.engine.services.change.SourceChange;
import com.google.dart.engine.services.correction.AddDependencyCorrectionProposal;
import com.google.dart.engine.services.correction.CorrectionImage;
import com.google.dart.engine.services.correction.CorrectionKind;
import com.google.dart.engine.services.correction.CorrectionProposal;
import com.google.dart.engine.services.correction.CreateFileCorrectionProposal;
import com.google.dart.engine.services.correction.LinkedPositionProposal;
import com.google.dart.engine.services.correction.QuickFixProcessor;
import com.google.dart.engine.services.correction.SourceCorrectionProposal;
import com.google.dart.engine.services.internal.correction.CorrectionUtils.InsertDesc;
import com.google.dart.engine.services.util.HierarchyUtils;
import com.google.dart.engine.source.FileBasedSource;
import com.google.dart.engine.source.Source;
import com.google.dart.engine.source.SourceFactory;
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.dart.ParameterKind;
import com.google.dart.engine.utilities.instrumentation.Instrumentation;
import com.google.dart.engine.utilities.instrumentation.InstrumentationBuilder;
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.rangeError;
import static com.google.dart.engine.utilities.source.SourceRangeFactory.rangeNode;
import static com.google.dart.engine.utilities.source.SourceRangeFactory.rangeShowCombinator;
import static com.google.dart.engine.utilities.source.SourceRangeFactory.rangeStartLength;
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.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import java.io.File;
import java.net.URI;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
/**
* Implementation of {@link QuickFixProcessor}.
*/
public class QuickFixProcessorImpl implements QuickFixProcessor {
/**
* Helper for finding {@link Element} with name closest to the given.
*/
private static class ClosestElementFinder {
private final String targetName;
private final Predicate<Element> predicate;
Element element = null;
int distance = Integer.MAX_VALUE;
public ClosestElementFinder(String targetName, Predicate<Element> predicate) {
this.targetName = targetName;
this.predicate = predicate;
}
void update(Element element) {
if (predicate.apply(element)) {
int memberDistance = StringUtils.getLevenshteinDistance(element.getName(), targetName);
if (memberDistance < distance) {
this.element = element;
this.distance = memberDistance;
}
}
}
void update(Iterable<? extends Element> elements) {
for (Element element : elements) {
update(element);
}
}
}
/**
* Described location for newly created {@link ConstructorDeclaration}.
*/
private static class NewConstructorLocation {
final String prefix;
final int offset;
final String suffix;
public NewConstructorLocation(String prefix, int offset, String suffix) {
this.prefix = prefix;
this.offset = offset;
this.suffix = suffix;
}
}
private static final ErrorCode[] FIXABLE_ERROR_CODES = {
CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE,
CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_EXPLICIT,
CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT,
CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT,
CompileTimeErrorCode.URI_DOES_NOT_EXIST,
//
HintCode.DIVISION_OPTIMIZATION,
HintCode.TYPE_CHECK_IS_NOT_NULL,
HintCode.TYPE_CHECK_IS_NULL,
HintCode.UNNECESSARY_CAST,
HintCode.UNUSED_IMPORT,
HintCode.UNDEFINED_METHOD,
//
ParserErrorCode.EXPECTED_TOKEN,
ParserErrorCode.GETTER_WITH_PARAMETERS,
//
StaticWarningCode.CONCRETE_CLASS_WITH_ABSTRACT_MEMBER,
StaticWarningCode.EXTRA_POSITIONAL_ARGUMENTS,
StaticWarningCode.NEW_WITH_UNDEFINED_CONSTRUCTOR,
StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE,
StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO,
StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_THREE,
StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FOUR,
StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FIVE_PLUS,
StaticWarningCode.UNDEFINED_CLASS,
StaticWarningCode.UNDEFINED_CLASS_BOOLEAN,
StaticWarningCode.UNDEFINED_IDENTIFIER,
//
StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER,
StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION, StaticTypeWarningCode.UNDEFINED_FUNCTION,
StaticTypeWarningCode.UNDEFINED_GETTER, StaticTypeWarningCode.UNDEFINED_METHOD};
private static final CorrectionProposal[] NO_PROPOSALS = {};
/**
* @return the Java {@link File} which corresponds to the given {@link Source}, may be
* {@code null} if cannot be determined.
*/
@VisibleForTesting
public static File getSourceFile(Source source) {
if (source instanceof FileBasedSource) {
FileBasedSource fileBasedSource = (FileBasedSource) source;
return new File(fileBasedSource.getFullName()).getAbsoluteFile();
}
return null;
}
private static void addSuperTypeProposals(SourceBuilder sb, Set<Type> alreadyAdded, Type type) {
if (type != null && !alreadyAdded.contains(type) && type.getElement() instanceof ClassElement) {
alreadyAdded.add(type);
ClassElement element = (ClassElement) type.getElement();
sb.addProposal(CorrectionImage.IMG_CORRECTION_CLASS, element.getName());
addSuperTypeProposals(sb, alreadyAdded, element.getSupertype());
for (InterfaceType interfaceType : element.getInterfaces()) {
addSuperTypeProposals(sb, alreadyAdded, interfaceType);
}
}
}
/**
* @return the {@link Edit} to remove {@link SourceRange}.
*/
private static Edit createRemoveEdit(SourceRange range) {
return createReplaceEdit(range, "");
}
/**
* @return the {@link Edit} to replace {@link SourceRange} with "text".
*/
private static Edit createReplaceEdit(SourceRange range, String text) {
return new Edit(range.getOffset(), range.getLength(), text);
}
/**
* Attempts to convert the given absolute {@link File} to the "package" {@link URI}.
*
* @param context the {@link AnalysisContext} to work in.
* @param file the absolute {@link File}, not null.
* @return the "package" {@link URI}, may be {@code null}.
*/
private static URI findPackageUri(AnalysisContext context, File file) {
Source fileSource = new FileBasedSource(file);
return context.getSourceFactory().restoreUri(fileSource);
}
/**
* @return the suggestions for given {@link Type} and {@link DartExpression}, not empty.
*/
private static String[] getArgumentNameSuggestions(Set<String> excluded, Type type,
Expression expression, int index) {
String[] suggestions = CorrectionUtils.getVariableNameSuggestions(type, expression, excluded);
if (suggestions.length != 0) {
return suggestions;
}
return new String[] {"arg" + index};
}
/**
* @return <code>true</code> if given {@link DartNode} could be type name.
*/
private static boolean mayBeTypeIdentifier(AstNode node) {
if (node instanceof SimpleIdentifier) {
AstNode parent = node.getParent();
if (parent instanceof TypeName) {
return true;
}
if (parent instanceof MethodInvocation) {
MethodInvocation invocation = (MethodInvocation) parent;
return invocation.getRealTarget() == node;
}
if (parent instanceof PrefixedIdentifier) {
PrefixedIdentifier prefixed = (PrefixedIdentifier) parent;
return prefixed.getPrefix() == node;
}
}
return false;
}
private final List<CorrectionProposal> proposals = Lists.newArrayList();
private final List<Edit> textEdits = Lists.newArrayList();
private AnalysisError problem;
private Source source;
private CompilationUnit unit;
private LibraryElement unitLibraryElement;
private File unitFile;
private File unitLibraryFile;
private File unitLibraryFolder;
private AstNode node;
private AstNode coveredNode;
private int selectionOffset;
private int selectionLength;
private CorrectionUtils utils;
private final Map<SourceRange, Edit> positionStopEdits = Maps.newHashMap();
private final Map<String, List<SourceRange>> linkedPositions = Maps.newHashMap();
private final Map<String, List<LinkedPositionProposal>> linkedPositionProposals = Maps.newHashMap();
private SourceRange endRange = null;
@Override
public CorrectionProposal[] computeProposals(AssistContext context, AnalysisError problem)
throws Exception {
if (context == null) {
return NO_PROPOSALS;
}
if (problem == null) {
return NO_PROPOSALS;
}
this.problem = problem;
proposals.clear();
selectionOffset = problem.getOffset();
selectionLength = problem.getLength();
source = context.getSource();
unitFile = getSourceFile(source);
unit = context.getCompilationUnit();
// prepare elements
{
CompilationUnitElement unitElement = unit.getElement();
if (unitElement == null) {
return NO_PROPOSALS;
}
unitLibraryElement = unitElement.getLibrary();
if (unitLibraryElement == null) {
return NO_PROPOSALS;
}
unitLibraryFile = getSourceFile(unitLibraryElement.getSource());
if (unitLibraryFile == null) {
return NO_PROPOSALS;
}
unitLibraryFolder = unitLibraryFile.getParentFile();
}
// prepare CorrectionUtils
utils = new CorrectionUtils(unit);
node = utils.findNode(selectionOffset);
coveredNode = new NodeLocator(selectionOffset, selectionOffset + selectionLength).searchWithin(unit);
//
final InstrumentationBuilder instrumentation = Instrumentation.builder(this.getClass());
try {
ErrorCode errorCode = problem.getErrorCode();
if (errorCode == CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE) {
addFix_replaceWithConstInstanceCreation();
}
if (errorCode == CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_EXPLICIT) {
addFix_createConstructorSuperExplicit();
}
if (errorCode == CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT) {
addFix_createConstructorSuperImplicit();
}
if (errorCode == CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT) {
addFix_createConstructorSuperExplicit();
}
if (errorCode == CompileTimeErrorCode.URI_DOES_NOT_EXIST) {
addFix_createPart();
addFix_addPackageDependency();
}
if (errorCode == HintCode.DIVISION_OPTIMIZATION) {
addFix_useEffectiveIntegerDivision();
}
if (errorCode == HintCode.TYPE_CHECK_IS_NOT_NULL) {
addFix_isNotNull();
}
if (errorCode == HintCode.TYPE_CHECK_IS_NULL) {
addFix_isNull();
}
if (errorCode == HintCode.UNNECESSARY_CAST) {
addFix_removeUnnecessaryCast();
}
if (errorCode == HintCode.UNUSED_IMPORT) {
addFix_removeUnusedImport();
}
if (errorCode == ParserErrorCode.EXPECTED_TOKEN) {
addFix_insertSemicolon();
}
if (errorCode == ParserErrorCode.GETTER_WITH_PARAMETERS) {
addFix_removeParameters_inGetterDeclaration();
}
if (errorCode == StaticWarningCode.CONCRETE_CLASS_WITH_ABSTRACT_MEMBER) {
addFix_makeEnclosingClassAbstract();
}
if (errorCode == StaticWarningCode.EXTRA_POSITIONAL_ARGUMENTS) {
addFix_createConstructor_insteadOfSyntheticDefault();
}
if (errorCode == StaticWarningCode.NEW_WITH_UNDEFINED_CONSTRUCTOR) {
addFix_createConstructor_named();
}
if (errorCode == StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE
|| errorCode == StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO
|| errorCode == StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_THREE
|| errorCode == StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FOUR
|| errorCode == StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FIVE_PLUS) {
// make class abstract
addFix_makeEnclosingClassAbstract();
// implement methods
AnalysisErrorWithProperties errorWithProperties = (AnalysisErrorWithProperties) problem;
Object property = errorWithProperties.getProperty(ErrorProperty.UNIMPLEMENTED_METHODS);
ExecutableElement[] missingOverrides = (ExecutableElement[]) property;
addFix_createMissingOverrides(missingOverrides);
addFix_createNoSuchMethod();
}
if (errorCode == StaticWarningCode.UNDEFINED_CLASS) {
addFix_importLibrary_withType();
addFix_createClass();
addFix_undefinedClass_useSimilar();
}
if (errorCode == StaticWarningCode.UNDEFINED_CLASS_BOOLEAN) {
addFix_boolInsteadOfBoolean();
}
if (errorCode == StaticWarningCode.UNDEFINED_IDENTIFIER) {
addFix_createFunction_forFunctionType();
addFix_importLibrary_withType();
addFix_importLibrary_withTopLevelVariable();
}
if (errorCode == StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER) {
addFix_useStaticAccess_method();
addFix_useStaticAccess_property();
}
if (errorCode == StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION) {
addFix_removeParentheses_inGetterInvocation();
}
if (errorCode == StaticTypeWarningCode.UNDEFINED_FUNCTION) {
addFix_importLibrary_withFunction();
addFix_undefinedFunction_useSimilar();
addFix_undefinedFunction_create();
}
if (errorCode == StaticTypeWarningCode.UNDEFINED_GETTER) {
addFix_createFunction_forFunctionType();
}
if (errorCode == HintCode.UNDEFINED_METHOD
|| errorCode == StaticTypeWarningCode.UNDEFINED_METHOD) {
addFix_undefinedMethod_useSimilar();
addFix_undefinedMethod_create();
addFix_undefinedFunction_create();
}
// clean-up
resetProposalElements();
// write instrumentation
instrumentation.metric("QuickFix-Offset", selectionOffset);
instrumentation.metric("QuickFix-Length", selectionLength);
instrumentation.metric("QuickFix-ProposalCount", proposals.size());
instrumentation.data("QuickFix-Source", utils.getText());
for (int index = 0; index < proposals.size(); index++) {
instrumentation.data("QuickFix-Proposal-" + index, proposals.get(index).getName());
}
// done
return proposals.toArray(new CorrectionProposal[proposals.size()]);
} finally {
instrumentation.log();
}
}
@Override
public ErrorCode[] getFixableErrorCodes() {
return FIXABLE_ERROR_CODES;
}
@Override
public boolean hasFix(AnalysisError problem) {
ErrorCode errorCode = problem.getErrorCode();
// System.out.println(errorCode.getClass() + " " + errorCode);
return errorCode == CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE
|| errorCode == CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_EXPLICIT
|| errorCode == CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT
|| errorCode == CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT
|| errorCode == CompileTimeErrorCode.URI_DOES_NOT_EXIST
|| errorCode == HintCode.DIVISION_OPTIMIZATION
|| errorCode == HintCode.TYPE_CHECK_IS_NOT_NULL || errorCode == HintCode.TYPE_CHECK_IS_NULL
|| errorCode == HintCode.UNNECESSARY_CAST || errorCode == ParserErrorCode.EXPECTED_TOKEN
|| errorCode == HintCode.UNUSED_IMPORT || errorCode == HintCode.UNDEFINED_METHOD
|| errorCode == ParserErrorCode.GETTER_WITH_PARAMETERS
|| errorCode == StaticWarningCode.CONCRETE_CLASS_WITH_ABSTRACT_MEMBER
|| errorCode == StaticWarningCode.EXTRA_POSITIONAL_ARGUMENTS
|| errorCode == StaticWarningCode.NEW_WITH_UNDEFINED_CONSTRUCTOR
|| errorCode == StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE
|| errorCode == StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO
|| errorCode == StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_THREE
|| errorCode == StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FOUR
|| errorCode == StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FIVE_PLUS
|| errorCode == StaticWarningCode.UNDEFINED_CLASS
|| errorCode == StaticWarningCode.UNDEFINED_CLASS_BOOLEAN
|| errorCode == StaticWarningCode.UNDEFINED_IDENTIFIER
|| errorCode == StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER
|| errorCode == StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION
|| errorCode == StaticTypeWarningCode.UNDEFINED_FUNCTION
|| errorCode == StaticTypeWarningCode.UNDEFINED_GETTER
|| errorCode == StaticTypeWarningCode.UNDEFINED_METHOD;
}
private void addFix_addPackageDependency() throws Exception {
if (node instanceof SimpleStringLiteral && node.getParent() instanceof NamespaceDirective) {
SimpleStringLiteral uriLiteral = (SimpleStringLiteral) node;
String uriString = uriLiteral.getValue();
// we need package: import
if (!uriString.startsWith("package:")) {
return;
}
// prepare package name
String packageName = StringUtils.removeStart(uriString, "package:");
packageName = StringUtils.substringBefore(packageName, "/");
// add proposal
proposals.add(new AddDependencyCorrectionProposal(
unitFile,
packageName,
CorrectionKind.QF_ADD_PACKAGE_DEPENDENCY,
packageName));
}
}
private void addFix_boolInsteadOfBoolean() {
SourceRange range = rangeError(problem);
addReplaceEdit(range, "bool");
addUnitCorrectionProposal(CorrectionKind.QF_REPLACE_BOOLEAN_WITH_BOOL);
}
private void addFix_createClass() {
if (mayBeTypeIdentifier(node)) {
String name = ((SimpleIdentifier) node).getName();
// prepare environment
String eol = utils.getEndOfLine();
CompilationUnitMember enclosingMember = node.getAncestor(CompilationUnitMember.class);
int offset = enclosingMember.getEnd();
String prefix = "";
// prepare source
SourceBuilder sb = new SourceBuilder(offset);
{
sb.append(eol + eol);
sb.append(prefix);
// "class"
sb.append("class ");
// append name
{
sb.startPosition("NAME");
sb.append(name);
sb.endPosition();
}
// no members
sb.append(" {");
sb.append(eol);
sb.append("}");
}
// insert source
addInsertEdit(offset, sb.toString());
// add linked positions
addLinkedPosition("NAME", rangeNode(node));
addLinkedPositions(sb);
// add proposal
addUnitCorrectionProposal(CorrectionKind.QF_CREATE_CLASS, name);
}
}
private void addFix_createConstructor_insteadOfSyntheticDefault() throws Exception {
TypeName typeName = null;
ConstructorName constructorName = null;
InstanceCreationExpression instanceCreation = null;
if (node instanceof SimpleIdentifier) {
if (node.getParent() instanceof TypeName) {
typeName = (TypeName) node.getParent();
if (typeName.getName() == node && typeName.getParent() instanceof ConstructorName) {
constructorName = (ConstructorName) typeName.getParent();
// should be synthetic default constructor
{
ConstructorElement constructorElement = constructorName.getStaticElement();
if (constructorElement == null || !constructorElement.isDefaultConstructor()
|| !constructorElement.isSynthetic()) {
return;
}
}
// prepare InstanceCreationExpression
if (constructorName.getParent() instanceof InstanceCreationExpression) {
instanceCreation = (InstanceCreationExpression) constructorName.getParent();
if (instanceCreation.getConstructorName() != constructorName) {
return;
}
}
}
}
}
// do we have enough information?
if (instanceCreation == null) {
return;
}
// prepare environment
String eol = utils.getEndOfLine();
// prepare target
Type targetType = typeName.getType();
if (!(targetType instanceof InterfaceType)) {
return;
}
ClassElement targetElement = (ClassElement) targetType.getElement();
Source targetSource = targetElement.getSource();
ClassDeclaration targetClass = targetElement.getNode();
NewConstructorLocation targetLocation = prepareNewConstructorLocation(targetClass, eol);
// build method source
SourceBuilder sb = new SourceBuilder(targetLocation.offset);
{
String indent = " ";
sb.append(targetLocation.prefix);
sb.append(indent);
sb.append(targetElement.getName());
addFix_undefinedMethod_create_parameters(sb, instanceCreation.getArgumentList());
sb.append(") {" + eol + indent + "}");
sb.append(targetLocation.suffix);
}
// insert source
addInsertEdit(sb);
// add linked positions
addLinkedPositions(sb);
// add proposal
addUnitCorrectionProposal(targetSource, CorrectionKind.QF_CREATE_CONSTRUCTOR, constructorName);
}
private void addFix_createConstructor_named() throws Exception {
SimpleIdentifier name = null;
ConstructorName constructorName = null;
InstanceCreationExpression instanceCreation = null;
if (node instanceof SimpleIdentifier) {
// name
name = (SimpleIdentifier) node;
if (name.getParent() instanceof ConstructorName) {
constructorName = (ConstructorName) name.getParent();
if (constructorName.getName() == name) {
// Type.name
if (constructorName.getParent() instanceof InstanceCreationExpression) {
instanceCreation = (InstanceCreationExpression) constructorName.getParent();
// new Type.name()
if (instanceCreation.getConstructorName() != constructorName) {
return;
}
}
}
}
}
// do we have enough information?
if (instanceCreation == null) {
return;
}
// prepare environment
String eol = utils.getEndOfLine();
// prepare target interface type
Type targetType = constructorName.getType().getType();
if (!(targetType instanceof InterfaceType)) {
return;
}
ClassElement targetElement = (ClassElement) targetType.getElement();
Source targetSource = targetElement.getSource();
ClassDeclaration targetClass = targetElement.getNode();
NewConstructorLocation targetLocation = prepareNewConstructorLocation(targetClass, eol);
// build method source
SourceBuilder sb = new SourceBuilder(targetLocation.offset);
{
String indent = " ";
sb.append(targetLocation.prefix);
sb.append(indent);
sb.append(targetElement.getName());
sb.append(".");
// append name
{
sb.startPosition("NAME");
sb.append(name.getName());
sb.endPosition();
}
addFix_undefinedMethod_create_parameters(sb, instanceCreation.getArgumentList());
sb.append(") {" + eol + indent + "}");
sb.append(targetLocation.suffix);
}
// insert source
addInsertEdit(sb);
// add linked positions
if (Objects.equal(targetSource, source)) {
addLinkedPosition("NAME", sb, rangeNode(name));
}
addLinkedPositions(sb);
// add proposal
addUnitCorrectionProposal(targetSource, CorrectionKind.QF_CREATE_CONSTRUCTOR, constructorName);
}
/**
* @see StaticWarningCode#NO_DEFAULT_SUPER_CONSTRUCTOR_EXPLICIT
*/
private void addFix_createConstructorSuperExplicit() {
ConstructorDeclaration targetConstructor = (ConstructorDeclaration) node.getParent();
ClassDeclaration targetClassNode = (ClassDeclaration) targetConstructor.getParent();
ClassElement targetClassElement = targetClassNode.getElement();
ClassElement superClassElement = targetClassElement.getSupertype().getElement();
// add proposals for all super constructors
ConstructorElement[] superConstructors = superClassElement.getConstructors();
for (ConstructorElement superConstructor : superConstructors) {
String constructorName = superConstructor.getName();
// skip private
if (Identifier.isPrivateName(constructorName)) {
continue;
}
// prepare SourceBuilder
SourceBuilder sb;
{
List<ConstructorInitializer> initializers = targetConstructor.getInitializers();
if (initializers.isEmpty()) {
int insertOffset = targetConstructor.getParameters().getEnd();
sb = new SourceBuilder(insertOffset);
sb.append(" : ");
} else {
ConstructorInitializer lastInitializer = initializers.get(initializers.size() - 1);
int insertOffset = lastInitializer.getEnd();
sb = new SourceBuilder(insertOffset);
sb.append(", ");
}
}
// add super constructor name
sb.append("super");
if (!StringUtils.isEmpty(constructorName)) {
sb.append(".");
sb.append(constructorName);
}
// add arguments
sb.append("(");
boolean firstParameter = true;
for (ParameterElement parameter : superConstructor.getParameters()) {
// skip non-required parameters
if (parameter.getParameterKind() != ParameterKind.REQUIRED) {
break;
}
// comma
if (firstParameter) {
firstParameter = false;
} else {
sb.append(", ");
}
// default value
Type parameterType = parameter.getType();
sb.startPosition(parameter.getName());
sb.append(CorrectionUtils.getDefaultValueCode(parameterType));
sb.endPosition();
}
sb.append(")");
// insert proposal
addLinkedPositions(sb);
addInsertEdit(sb);
// add proposal
String proposalName = getConstructorProposalName(superConstructor);
addUnitCorrectionProposal(CorrectionKind.QF_ADD_SUPER_CONSTRUCTOR_INVOCATION, proposalName);
}
}
/**
* @see StaticWarningCode#NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT
*/
private void addFix_createConstructorSuperImplicit() {
ClassDeclaration targetClassNode = (ClassDeclaration) node.getParent();
ClassElement targetClassElement = targetClassNode.getElement();
ClassElement superClassElement = targetClassElement.getSupertype().getElement();
String targetClassName = targetClassElement.getName();
// add proposals for all super constructors
ConstructorElement[] superConstructors = superClassElement.getConstructors();
for (ConstructorElement superConstructor : superConstructors) {
String constructorName = superConstructor.getName();
// skip private
if (Identifier.isPrivateName(constructorName)) {
continue;
}
// prepare parameters and arguments
StringBuilder parametersBuffer = new StringBuilder();
StringBuilder argumentsBuffer = new StringBuilder();
boolean firstParameter = true;
for (ParameterElement parameter : superConstructor.getParameters()) {
// skip non-required parameters
if (parameter.getParameterKind() != ParameterKind.REQUIRED) {
break;
}
// comma
if (firstParameter) {
firstParameter = false;
} else {
parametersBuffer.append(", ");
argumentsBuffer.append(", ");
}
// name
String parameterName = parameter.getDisplayName();
if (parameterName.length() > 1 && parameterName.startsWith("_")) {
parameterName = parameterName.substring(1);
}
// parameter & argument
appendParameterSource(parametersBuffer, parameter.getType(), parameterName);
argumentsBuffer.append(parameterName);
}
// add proposal
String eol = utils.getEndOfLine();
NewConstructorLocation targetLocation = prepareNewConstructorLocation(targetClassNode, eol);
SourceBuilder sb = new SourceBuilder(targetLocation.offset);
{
String indent = utils.getIndent(1);
sb.append(targetLocation.prefix);
sb.append(indent);
sb.append(targetClassName);
if (!constructorName.isEmpty()) {
sb.startPosition("NAME");
sb.append(".");
sb.append(constructorName);
sb.endPosition();
}
sb.append("(");
sb.append(parametersBuffer);
sb.append(") : super");
if (!constructorName.isEmpty()) {
sb.append(".");
sb.append(constructorName);
}
sb.append("(");
sb.append(argumentsBuffer);
sb.append(");");
sb.append(targetLocation.suffix);
}
addInsertEdit(sb);
// add proposal
String proposalName = getConstructorProposalName(superConstructor);
addUnitCorrectionProposal(CorrectionKind.QF_CREATE_CONSTRUCTOR_SUPER, proposalName);
}
}
private void addFix_createFunction_forFunctionType() throws Exception {
if (node instanceof SimpleIdentifier) {
SimpleIdentifier nameNode = (SimpleIdentifier) node;
// prepare argument expression (to get parameter)
ClassElement targetElement;
Expression argument;
{
Expression target = CorrectionUtils.getQualifiedPropertyTarget(node);
if (target != null) {
Type targetType = target.getBestType();
if (targetType != null && targetType.getElement() instanceof ClassElement) {
targetElement = (ClassElement) targetType.getElement();
argument = (Expression) target.getParent();
} else {
return;
}
} else {
ClassDeclaration enclosingClass = node.getAncestor(ClassDeclaration.class);
targetElement = enclosingClass != null ? enclosingClass.getElement() : null;
argument = nameNode;
}
}
// should be argument of some invocation
ParameterElement parameterElement = argument.getBestParameterElement();
if (parameterElement == null) {
return;
}
// should be parameter of function type
Type parameterType = parameterElement.getType();
if (!(parameterType instanceof FunctionType)) {
return;
}
FunctionType functionType = (FunctionType) parameterType;
// add proposal
if (targetElement != null) {
addProposal_createFunction_method(targetElement, functionType);
} else {
addProposal_createFunction_function(functionType);
}
}
}
private void addFix_createMissingOverrides(ExecutableElement[] missingOverrides) throws Exception {
// sort by name
Arrays.sort(missingOverrides, new Comparator<Element>() {
@Override
public int compare(Element firstElement, Element secondElement) {
return ObjectUtils.compare(firstElement.getDisplayName(), secondElement.getDisplayName());
}
});
// add elements
ClassDeclaration targetClass = (ClassDeclaration) node.getParent();
boolean isFirst = true;
for (ExecutableElement missingOverride : missingOverrides) {
addFix_createMissingOverrides_single(targetClass, missingOverride, isFirst);
isFirst = false;
}
// add proposal
addUnitCorrectionProposal(CorrectionKind.QF_CREATE_MISSING_OVERRIDES, missingOverrides.length);
}
private void addFix_createMissingOverrides_single(ClassDeclaration targetClass,
ExecutableElement missingOverride, boolean isFirst) throws Exception {
// prepare environment
String eol = utils.getEndOfLine();
String prefix = utils.getIndent(1);
String prefix2 = utils.getIndent(2);
int insertOffset = targetClass.getEnd() - 1;
// prepare source
StringBuilder sb = new StringBuilder();
// may be empty line
if (!isFirst || !targetClass.getMembers().isEmpty()) {
sb.append(eol);
}
// may be property
ElementKind elementKind = missingOverride.getKind();
boolean isGetter = elementKind == ElementKind.GETTER;
boolean isSetter = elementKind == ElementKind.SETTER;
boolean isMethod = elementKind == ElementKind.METHOD;
boolean isOperator = isMethod && ((MethodElement) missingOverride).isOperator();
sb.append(prefix);
if (isGetter) {
sb.append("// TODO: implement " + missingOverride.getDisplayName());
sb.append(eol);
sb.append(prefix);
}
// @override
{
sb.append("@override");
sb.append(eol);
sb.append(prefix);
}
// return type
appendType(sb, missingOverride.getType().getReturnType());
if (isGetter) {
sb.append("get ");
} else if (isSetter) {
sb.append("set ");
} else if (isOperator) {
sb.append("operator ");
}
// name
sb.append(missingOverride.getDisplayName());
// parameters + body
if (isGetter) {
sb.append(" => null;");
} else if (isMethod || isSetter) {
ParameterElement[] parameters = missingOverride.getParameters();
appendParameters(sb, parameters);
sb.append(" {");
// TO-DO
sb.append(eol);
sb.append(prefix2);
if (isMethod) {
sb.append("// TODO: implement " + missingOverride.getDisplayName());
} else {
sb.append("// TODO: implement " + missingOverride.getDisplayName());
}
sb.append(eol);
// close method
sb.append(prefix);
sb.append("}");
}
sb.append(eol);
// done
addInsertEdit(insertOffset, sb.toString());
// maybe set end range
if (endRange == null) {
endRange = rangeStartLength(insertOffset, 0);
}
}
private void addFix_createNoSuchMethod() throws Exception {
ClassDeclaration targetClass = (ClassDeclaration) node.getParent();
// prepare environment
String eol = utils.getEndOfLine();
String prefix = utils.getIndent(1);
int insertOffset = targetClass.getEnd() - 1;
// prepare source
SourceBuilder sb = new SourceBuilder(insertOffset);
{
// insert empty line before existing member
if (!targetClass.getMembers().isEmpty()) {
sb.append(eol);
}
// append method
sb.append(prefix);
sb.append("noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);");
sb.append(eol);
}
// done
addInsertEdit(sb);
endRange = rangeStartLength(insertOffset, 0);
// add proposal
addUnitCorrectionProposal(CorrectionKind.QF_CREATE_NO_SUCH_METHOD);
}
private void addFix_createPart() throws Exception {
if (node instanceof SimpleStringLiteral && node.getParent() instanceof PartDirective) {
SimpleStringLiteral uriLiteral = (SimpleStringLiteral) node;
String uriString = uriLiteral.getValue();
// prepare referenced File
File newFile;
{
URI uri = URI.create(uriString);
if (uri.isAbsolute()) {
return;
}
newFile = new File(unitLibraryFolder, uriString);
}
if (!newFile.exists()) {
// prepare new source
String source;
{
String eol = utils.getEndOfLine();
String libraryName = unitLibraryElement.getDisplayName();
source = "part of " + libraryName + ";" + eol + eol;
}
// add proposal
proposals.add(new CreateFileCorrectionProposal(
newFile,
source,
CorrectionKind.QF_CREATE_PART,
uriString));
}
}
}
private void addFix_importLibrary(CorrectionKind kind, String importPath) throws Exception {
CompilationUnitElement libraryUnitElement = unitLibraryElement.getDefiningCompilationUnit();
CompilationUnit libraryUnit = libraryUnitElement.getNode();
// prepare new import location
int offset = 0;
String prefix;
String suffix;
{
String eol = utils.getEndOfLine();
// if no directives
prefix = "";
suffix = eol;
CorrectionUtils libraryUtils = new CorrectionUtils(libraryUnit);
// after last directive in library
for (Directive directive : libraryUnit.getDirectives()) {
if (directive instanceof LibraryDirective || directive instanceof ImportDirective) {
offset = directive.getEnd();
prefix = eol;
suffix = "";
}
}
// if still beginning of file, skip shebang and line comments
if (offset == 0) {
InsertDesc desc = libraryUtils.getInsertDescTop();
offset = desc.offset;
prefix = desc.prefix;
suffix = desc.suffix + eol;
}
}
// insert new import
String importSource = prefix + "import '" + importPath + "';" + suffix;
addInsertEdit(offset, importSource);
// add proposal
addUnitCorrectionProposal(libraryUnitElement.getSource(), kind, importPath);
}
private void addFix_importLibrary_withElement(String name, ElementKind kind) throws Exception {
// ignore if private
if (name.startsWith("_")) {
return;
}
// may be there is an existing import, but it is with prefix and we don't use this prefix
for (ImportElement imp : unitLibraryElement.getImports()) {
// prepare element
LibraryElement libraryElement = imp.getImportedLibrary();
Element element = CorrectionUtils.getExportedElement(libraryElement, name);
if (element == null) {
continue;
}
if (element instanceof PropertyAccessorElement) {
element = ((PropertyAccessorElement) element).getVariable();
}
if (element.getKind() != kind) {
continue;
}
// may be apply prefix
PrefixElement prefix = imp.getPrefix();
if (prefix != null) {
SourceRange range = rangeStartLength(node, 0);
addReplaceEdit(range, prefix.getDisplayName() + ".");
addUnitCorrectionProposal(
CorrectionKind.QF_IMPORT_LIBRARY_PREFIX,
libraryElement.getDisplayName(),
prefix.getDisplayName());
continue;
}
// may be update "show" directive
NamespaceCombinator[] combinators = imp.getCombinators();
if (combinators.length == 1 && combinators[0] instanceof ShowElementCombinator) {
ShowElementCombinator showCombinator = (ShowElementCombinator) combinators[0];
// prepare new set of names to show
Set<String> showNames = Sets.newTreeSet();
Collections.addAll(showNames, showCombinator.getShownNames());
showNames.add(name);
// prepare library name - unit name or 'dart:name' for SDK library
String libraryName = libraryElement.getDefiningCompilationUnit().getDisplayName();
if (libraryElement.isInSdk()) {
libraryName = imp.getUri();
}
// update library
String newShowCode = "show " + StringUtils.join(showNames, ", ");
addReplaceEdit(rangeShowCombinator(showCombinator), newShowCode);
addUnitCorrectionProposal(
unitLibraryElement.getSource(),
CorrectionKind.QF_IMPORT_LIBRARY_SHOW,
libraryName);
// we support only one import without prefix
return;
}
}
// check SDK libraries
AnalysisContext context = unitLibraryElement.getContext();
{
DartSdk sdk = context.getSourceFactory().getDartSdk();
SdkLibrary[] sdkLibraries = sdk.getSdkLibraries();
for (SdkLibrary sdkLibrary : sdkLibraries) {
SourceFactory sdkSourceFactory = context.getSourceFactory();
String libraryUri = sdkLibrary.getShortName();
Source librarySource = sdkSourceFactory.resolveUri(null, libraryUri);
// prepare LibraryElement
LibraryElement libraryElement = context.getLibraryElement(librarySource);
if (libraryElement == null) {
continue;
}
// prepare exported Element
Element element = CorrectionUtils.getExportedElement(libraryElement, name);
if (element == null) {
continue;
}
if (element instanceof PropertyAccessorElement) {
element = ((PropertyAccessorElement) element).getVariable();
}
if (element.getKind() != kind) {
continue;
}
// add import
addFix_importLibrary(CorrectionKind.QF_IMPORT_LIBRARY_SDK, libraryUri);
}
}
// check project libraries
{
Source[] librarySources = context.getLibrarySources();
for (Source librarySource : librarySources) {
// we don't need SDK libraries here
if (librarySource.isInSystemLibrary()) {
continue;
}
// prepare LibraryElement
LibraryElement libraryElement = context.getLibraryElement(librarySource);
if (libraryElement == null) {
continue;
}
// prepare exported Element
Element element = CorrectionUtils.getExportedElement(libraryElement, name);
if (element == null) {
continue;
}
if (element.getKind() != kind) {
continue;
}
// prepare "library" file
File libraryFile = getSourceFile(librarySource);
if (libraryFile == null) {
continue;
}
// may be "package:" URI
{
URI libraryPackageUri = findPackageUri(context, libraryFile);
if (libraryPackageUri != null) {
addFix_importLibrary(
CorrectionKind.QF_IMPORT_LIBRARY_PROJECT,
libraryPackageUri.toString());
continue;
}
}
// relative URI
String relative = URIUtils.computeRelativePath(
unitLibraryFolder.getAbsolutePath(),
libraryFile.getAbsolutePath());
addFix_importLibrary(CorrectionKind.QF_IMPORT_LIBRARY_PROJECT, relative);
}
}
}
private void addFix_importLibrary_withFunction() throws Exception {
if (node instanceof SimpleIdentifier && node.getParent() instanceof MethodInvocation) {
MethodInvocation invocation = (MethodInvocation) node.getParent();
if (invocation.getRealTarget() == null && invocation.getMethodName() == node) {
String name = ((SimpleIdentifier) node).getName();
addFix_importLibrary_withElement(name, ElementKind.FUNCTION);
}
}
}
private void addFix_importLibrary_withTopLevelVariable() throws Exception {
if (node instanceof SimpleIdentifier) {
String name = ((SimpleIdentifier) node).getName();
addFix_importLibrary_withElement(name, ElementKind.TOP_LEVEL_VARIABLE);
}
}
private void addFix_importLibrary_withType() throws Exception {
if (mayBeTypeIdentifier(node)) {
String typeName = ((SimpleIdentifier) node).getName();
addFix_importLibrary_withElement(typeName, ElementKind.CLASS);
}
}
private void addFix_insertSemicolon() {
if (problem.getMessage().contains("';'")) {
int insertOffset = problem.getOffset() + problem.getLength();
addInsertEdit(insertOffset, ";");
addUnitCorrectionProposal(CorrectionKind.QF_INSERT_SEMICOLON);
}
}
private void addFix_isNotNull() throws Exception {
if (coveredNode instanceof IsExpression) {
IsExpression isExpression = (IsExpression) coveredNode;
addReplaceEdit(rangeEndEnd(isExpression.getExpression(), isExpression), " != null");
addUnitCorrectionProposal(CorrectionKind.QF_USE_NOT_EQ_NULL);
}
}
private void addFix_isNull() throws Exception {
if (coveredNode instanceof IsExpression) {
IsExpression isExpression = (IsExpression) coveredNode;
addReplaceEdit(rangeEndEnd(isExpression.getExpression(), isExpression), " == null");
addUnitCorrectionProposal(CorrectionKind.QF_USE_EQ_EQ_NULL);
}
}
private void addFix_makeEnclosingClassAbstract() {
ClassDeclaration enclosingClass = node.getAncestor(ClassDeclaration.class);
String className = enclosingClass.getName().getName();
addInsertEdit(enclosingClass.getClassKeyword().getOffset(), "abstract ");
addUnitCorrectionProposal(CorrectionKind.QF_MAKE_CLASS_ABSTRACT, className);
}
private void addFix_removeParameters_inGetterDeclaration() throws Exception {
if (node instanceof SimpleIdentifier && node.getParent() instanceof MethodDeclaration) {
MethodDeclaration method = (MethodDeclaration) node.getParent();
FunctionBody body = method.getBody();
if (method.getName() == node && body != null) {
addReplaceEdit(rangeEndStart(node, body), " ");
addUnitCorrectionProposal(CorrectionKind.QF_REMOVE_PARAMETERS_IN_GETTER_DECLARATION);
}
}
}
private void addFix_removeParentheses_inGetterInvocation() throws Exception {
if (node instanceof SimpleIdentifier && node.getParent() instanceof MethodInvocation) {
MethodInvocation invocation = (MethodInvocation) node.getParent();
if (invocation.getMethodName() == node && invocation.getTarget() != null) {
addRemoveEdit(rangeEndEnd(node, invocation));
addUnitCorrectionProposal(CorrectionKind.QF_REMOVE_PARENTHESIS_IN_GETTER_INVOCATION);
}
}
}
private void addFix_removeUnnecessaryCast() {
if (!(coveredNode instanceof AsExpression)) {
return;
}
AsExpression asExpression = (AsExpression) coveredNode;
Expression expression = asExpression.getExpression();
int expressionPrecedence = CorrectionUtils.getExpressionPrecedence(expression);
// remove 'as T' from 'e as T'
addRemoveEdit(rangeEndEnd(expression, asExpression));
removeEnclosingParentheses(asExpression, expressionPrecedence);
// done
addUnitCorrectionProposal(CorrectionKind.QF_REMOVE_UNNECASSARY_CAST);
}
private void addFix_removeUnusedImport() {
// prepare ImportDirective
ImportDirective importDirective = node.getAncestor(ImportDirective.class);
if (importDirective == null) {
return;
}
// remove the whole line with import
addRemoveEdit(utils.getLinesRange(rangeNode(importDirective)));
// done
addUnitCorrectionProposal(CorrectionKind.QF_REMOVE_UNUSED_IMPORT);
}
private void addFix_replaceWithConstInstanceCreation() throws Exception {
if (coveredNode instanceof InstanceCreationExpression) {
InstanceCreationExpression instanceCreation = (InstanceCreationExpression) coveredNode;
addReplaceEdit(rangeToken(instanceCreation.getKeyword()), "const");
addUnitCorrectionProposal(CorrectionKind.QF_USE_CONST);
}
}
private void addFix_undefinedClass_useSimilar() {
if (mayBeTypeIdentifier(node)) {
String name = ((SimpleIdentifier) node).getName();
final ClosestElementFinder finder = new ClosestElementFinder(name, new Predicate<Element>() {
@Override
public boolean apply(Element element) {
return element instanceof ClassElement;
}
});
// find closest element
{
// elements of this library
unitLibraryElement.accept(new RecursiveElementVisitor<Void>() {
@Override
public Void visitClassElement(ClassElement element) {
finder.update(element);
return null;
}
});
// elements from imports
for (ImportElement importElement : unitLibraryElement.getImports()) {
if (importElement.getPrefix() == null) {
Map<String, Element> namespace = CorrectionUtils.getImportNamespace(importElement);
finder.update(namespace.values());
}
}
}
// if we have close enough element, suggest to use it
if (finder != null && finder.distance < 5) {
String closestName = finder.element.getName();
addReplaceEdit(rangeNode(node), closestName);
// add proposal
if (closestName != null) {
addUnitCorrectionProposal(CorrectionKind.QF_CHANGE_TO, closestName);
}
}
}
}
private void addFix_undefinedFunction_create() throws Exception {
// should be the name of the invocation
if (node instanceof SimpleIdentifier && node.getParent() instanceof MethodInvocation) {
} else {
return;
}
String name = ((SimpleIdentifier) node).getName();
MethodInvocation invocation = (MethodInvocation) node.getParent();
// function invocation has no target
Expression target = invocation.getRealTarget();
if (target != null) {
return;
}
// prepare environment
String eol = utils.getEndOfLine();
int insertOffset;
String sourcePrefix;
AstNode enclosingMember = node.getAncestor(CompilationUnitMember.class);
insertOffset = enclosingMember.getEnd();
sourcePrefix = eol + eol;
// build method source
SourceBuilder sb = new SourceBuilder(insertOffset);
{
sb.append(sourcePrefix);
// may be return type
{
Type type = addFix_undefinedMethod_create_getReturnType(invocation);
if (type != null) {
String typeSource = utils.getTypeSource(type);
if (!typeSource.equals("dynamic")) {
sb.startPosition("RETURN_TYPE");
sb.append(typeSource);
sb.endPosition();
sb.append(" ");
}
}
}
// append name
{
sb.startPosition("NAME");
sb.append(name);
sb.endPosition();
}
addFix_undefinedMethod_create_parameters(sb, invocation.getArgumentList());
sb.append(") {" + eol + "}");
}
// insert source
addInsertEdit(insertOffset, sb.toString());
// add linked positions
addLinkedPosition("NAME", sb, rangeNode(node));
addLinkedPositions(sb);
// add proposal
addUnitCorrectionProposal(CorrectionKind.QF_CREATE_FUNCTION, name);
}
private void addFix_undefinedFunction_useSimilar() throws Exception {
if (node instanceof SimpleIdentifier) {
String name = ((SimpleIdentifier) node).getName();
final ClosestElementFinder finder = new ClosestElementFinder(name, new Predicate<Element>() {
@Override
public boolean apply(Element element) {
return element instanceof FunctionElement;
}
});
// this library
unitLibraryElement.accept(new RecursiveElementVisitor<Void>() {
@Override
public Void visitFunctionElement(FunctionElement element) {
finder.update(element);
return null;
}
});
// imports
for (ImportElement importElement : unitLibraryElement.getImports()) {
if (importElement.getPrefix() == null) {
Map<String, Element> namespace = CorrectionUtils.getImportNamespace(importElement);
finder.update(namespace.values());
}
}
// if we have close enough element, suggest to use it
String closestName = null;
if (finder != null && finder.distance < 5) {
closestName = finder.element.getName();
addReplaceEdit(rangeNode(node), closestName);
addUnitCorrectionProposal(CorrectionKind.QF_CHANGE_TO, closestName);
}
}
}
private void addFix_undefinedMethod_create() throws Exception {
if (node instanceof SimpleIdentifier && node.getParent() instanceof MethodInvocation) {
String name = ((SimpleIdentifier) node).getName();
MethodInvocation invocation = (MethodInvocation) node.getParent();
// prepare environment
String eol = utils.getEndOfLine();
Source targetSource;
String prefix;
int insertOffset;
String sourcePrefix;
String sourceSuffix;
boolean staticModifier = false;
Expression target = invocation.getRealTarget();
if (target == null) {
targetSource = source;
ClassMember enclosingMember = node.getAncestor(ClassMember.class);
staticModifier = inStaticMemberContext(enclosingMember);
prefix = utils.getNodePrefix(enclosingMember);
insertOffset = enclosingMember.getEnd();
sourcePrefix = eol + prefix + eol;
sourceSuffix = "";
} else {
// prepare target interface type
Type targetType = target.getBestType();
if (!(targetType instanceof InterfaceType)) {
return;
}
ClassElement targetElement = (ClassElement) targetType.getElement();
targetSource = targetElement.getSource();
// may be static
if (target instanceof Identifier) {
staticModifier = ((Identifier) target).getBestElement().getKind() == ElementKind.CLASS;
}
// prepare insert offset
ClassDeclaration targetClass = targetElement.getNode();
prefix = " ";
insertOffset = targetClass.getEnd() - 1;
if (targetClass.getMembers().isEmpty()) {
sourcePrefix = "";
} else {
sourcePrefix = prefix + eol;
}
sourceSuffix = eol;
}
// build method source
SourceBuilder sb = new SourceBuilder(insertOffset);
{
sb.append(sourcePrefix);
sb.append(prefix);
// may be "static"
if (staticModifier) {
sb.append("static ");
}
// may be return type
{
Type type = addFix_undefinedMethod_create_getReturnType(invocation);
if (type != null) {
String typeSource = utils.getTypeSource(type);
if (!typeSource.equals("dynamic")) {
sb.startPosition("RETURN_TYPE");
sb.append(typeSource);
sb.endPosition();
sb.append(" ");
}
}
}
// append name
{
sb.startPosition("NAME");
sb.append(name);
sb.endPosition();
}
addFix_undefinedMethod_create_parameters(sb, invocation.getArgumentList());
sb.append(") {" + eol + prefix + "}");
sb.append(sourceSuffix);
}
// insert source
addInsertEdit(insertOffset, sb.toString());
// add linked positions
if (Objects.equal(targetSource, source)) {
addLinkedPosition("NAME", sb, rangeNode(node));
}
addLinkedPositions(sb);
// add proposal
addUnitCorrectionProposal(targetSource, CorrectionKind.QF_CREATE_METHOD, name);
}
}
/**
* @return the possible return {@link Type}, may be <code>null</code> if can not be identified.
*/
private Type addFix_undefinedMethod_create_getReturnType(MethodInvocation invocation) {
AstNode parent = invocation.getParent();
// myFunction();
if (parent instanceof ExpressionStatement) {
return VoidTypeImpl.getInstance();
}
// return myFunction();
if (parent instanceof ReturnStatement) {
ExecutableElement executable = CorrectionUtils.getEnclosingExecutableElement(invocation);
return executable != null ? executable.getReturnType() : null;
}
// int v = myFunction();
if (parent instanceof VariableDeclaration) {
VariableDeclaration variableDeclaration = (VariableDeclaration) parent;
if (variableDeclaration.getInitializer() == invocation) {
VariableElement variableElement = variableDeclaration.getElement();
if (variableElement != null) {
return variableElement.getType();
}
}
}
// v = myFunction();
if (parent instanceof AssignmentExpression) {
AssignmentExpression assignment = (AssignmentExpression) parent;
if (assignment.getRightHandSide() == invocation) {
if (assignment.getOperator().getType() == TokenType.EQ) {
// v = myFunction();
Expression lhs = assignment.getLeftHandSide();
if (lhs != null) {
return lhs.getBestType();
}
} else {
// v += myFunction();
MethodElement method = assignment.getBestElement();
if (method != null) {
ParameterElement[] parameters = method.getParameters();
if (parameters.length == 1) {
return parameters[0].getType();
}
}
}
}
}
// v + myFunction();
if (parent instanceof BinaryExpression) {
BinaryExpression binary = (BinaryExpression) parent;
MethodElement method = binary.getBestElement();
if (method != null) {
if (binary.getRightOperand() == invocation) {
ParameterElement[] parameters = method.getParameters();
return parameters.length == 1 ? parameters[0].getType() : null;
}
}
}
// foo( myFunction() );
if (parent instanceof ArgumentList) {
ParameterElement parameter = invocation.getBestParameterElement();
return parameter != null ? parameter.getType() : null;
}
// bool
{
// assert( myFunction() );
if (parent instanceof AssertStatement) {
AssertStatement statement = (AssertStatement) parent;
if (statement.getCondition() == invocation) {
return getCoreTypeBool();
}
}
// if ( myFunction() ) {}
if (parent instanceof IfStatement) {
IfStatement statement = (IfStatement) parent;
if (statement.getCondition() == invocation) {
return getCoreTypeBool();
}
}
// while ( myFunction() ) {}
if (parent instanceof WhileStatement) {
WhileStatement statement = (WhileStatement) parent;
if (statement.getCondition() == invocation) {
return getCoreTypeBool();
}
}
// do {} while ( myFunction() );
if (parent instanceof DoStatement) {
DoStatement statement = (DoStatement) parent;
if (statement.getCondition() == invocation) {
return getCoreTypeBool();
}
}
// !myFunction()
if (parent instanceof PrefixExpression) {
PrefixExpression prefixExpression = (PrefixExpression) parent;
if (prefixExpression.getOperator().getType() == TokenType.BANG) {
return getCoreTypeBool();
}
}
// binary expression '&&' or '||'
if (parent instanceof BinaryExpression) {
BinaryExpression binaryExpression = (BinaryExpression) parent;
TokenType operatorType = binaryExpression.getOperator().getType();
if (operatorType == TokenType.AMPERSAND_AMPERSAND || operatorType == TokenType.BAR_BAR) {
return getCoreTypeBool();
}
}
}
// we don't know
return null;
}
private void addFix_undefinedMethod_create_parameters(SourceBuilder sb, ArgumentList argumentList) {
// append parameters
sb.append("(");
Set<String> excluded = Sets.newHashSet();
List<Expression> arguments = argumentList.getArguments();
for (int i = 0; i < arguments.size(); i++) {
Expression argument = arguments.get(i);
// append separator
if (i != 0) {
sb.append(", ");
}
// append type name
Type type = argument.getBestType();
String typeSource = utils.getTypeSource(type);
{
sb.startPosition("TYPE" + i);
sb.append(typeSource);
addSuperTypeProposals(sb, Sets.<Type> newHashSet(), type);
sb.endPosition();
}
sb.append(" ");
// append parameter name
{
String[] suggestions = getArgumentNameSuggestions(excluded, type, argument, i);
String favorite = suggestions[0];
excluded.add(favorite);
sb.startPosition("ARG" + i);
sb.append(favorite);
sb.setProposals(suggestions);
sb.endPosition();
}
}
}
private void addFix_undefinedMethod_useSimilar() throws Exception {
if (node instanceof SimpleIdentifier && node.getParent() instanceof MethodInvocation) {
MethodInvocation invocation = (MethodInvocation) node.getParent();
String name = ((SimpleIdentifier) node).getName();
ClosestElementFinder finder = new ClosestElementFinder(name, new Predicate<Element>() {
@Override
public boolean apply(Element element) {
if (element instanceof MethodElement) {
MethodElement methodElement = (MethodElement) element;
return !methodElement.isOperator();
}
return false;
}
});
// unqualified invocation
Expression target = invocation.getRealTarget();
if (target == null) {
ClassDeclaration clazz = invocation.getAncestor(ClassDeclaration.class);
if (clazz != null) {
ClassElement classElement = clazz.getElement();
updateFinderWithClassMembers(finder, classElement);
}
} else {
Type type = target.getBestType();
if (type instanceof InterfaceType) {
ClassElement classElement = ((InterfaceType) type).getElement();
updateFinderWithClassMembers(finder, classElement);
}
}
// if we have close enough element, suggest to use it
String closestName = null;
if (finder != null && finder.distance < 5) {
closestName = finder.element.getName();
addReplaceEdit(rangeNode(node), closestName);
addUnitCorrectionProposal(CorrectionKind.QF_CHANGE_TO, closestName);
}
}
}
private void addFix_useEffectiveIntegerDivision() throws Exception {
for (AstNode n = node; n != null; n = n.getParent()) {
if (n instanceof MethodInvocation && n.getOffset() == selectionOffset
&& n.getLength() == selectionLength) {
MethodInvocation invocation = (MethodInvocation) n;
Expression target = invocation.getTarget();
while (target instanceof ParenthesizedExpression) {
target = ((ParenthesizedExpression) target).getExpression();
}
// replace "/" with "~/"
BinaryExpression binary = (BinaryExpression) target;
addReplaceEdit(rangeToken(binary.getOperator()), "~/");
// remove everything before and after
addRemoveEdit(rangeStartStart(invocation, binary.getLeftOperand()));
addRemoveEdit(rangeEndEnd(binary.getRightOperand(), invocation));
// add proposal
addUnitCorrectionProposal(CorrectionKind.QF_USE_EFFECTIVE_INTEGER_DIVISION);
// done
break;
}
}
}
private void addFix_useStaticAccess_method() throws Exception {
if (node instanceof SimpleIdentifier && node.getParent() instanceof MethodInvocation) {
MethodInvocation invocation = (MethodInvocation) node.getParent();
if (invocation.getMethodName() == node) {
Expression target = invocation.getTarget();
String targetType = utils.getTypeSource(target);
// replace "target" with class name
SourceRange range = SourceRangeFactory.rangeNode(target);
addReplaceEdit(range, targetType);
// add proposal
addUnitCorrectionProposal(CorrectionKind.QF_CHANGE_TO_STATIC_ACCESS, targetType);
}
}
}
private void addFix_useStaticAccess_property() throws Exception {
if (node instanceof SimpleIdentifier) {
if (node.getParent() instanceof PrefixedIdentifier) {
PrefixedIdentifier prefixed = (PrefixedIdentifier) node.getParent();
if (prefixed.getIdentifier() == node) {
Expression target = prefixed.getPrefix();
String targetType = utils.getTypeSource(target);
// replace "target" with class name
SourceRange range = SourceRangeFactory.rangeNode(target);
addReplaceEdit(range, targetType);
// add proposal
addUnitCorrectionProposal(CorrectionKind.QF_CHANGE_TO_STATIC_ACCESS, targetType);
}
}
}
}
private void addInsertEdit(int offset, String text) {
textEdits.add(createInsertEdit(offset, text));
}
private void addInsertEdit(SourceBuilder builder) {
addInsertEdit(builder.getOffset(), builder.toString());
}
/**
* Adds single linked position to the group. If {@link SourceBuilder} will be inserted before
* "position", translate it.
*/
private void addLinkedPosition(String group, SourceBuilder sb, SourceRange position) {
if (sb.getOffset() < position.getOffset()) {
int delta = sb.length();
position = position.getTranslated(delta);
}
addLinkedPosition(group, position);
}
/**
* Adds single linked position to the group.
*/
private void addLinkedPosition(String group, SourceRange position) {
List<SourceRange> positions = linkedPositions.get(group);
if (positions == null) {
positions = Lists.newArrayList();
linkedPositions.put(group, positions);
}
positions.add(position);
}
private void addLinkedPositionProposal(String group, LinkedPositionProposal proposal) {
List<LinkedPositionProposal> nodeProposals = linkedPositionProposals.get(group);
if (nodeProposals == null) {
nodeProposals = Lists.newArrayList();
linkedPositionProposals.put(group, nodeProposals);
}
nodeProposals.add(proposal);
}
/**
* Adds positions from the given {@link SourceBuilder} to the {@link #linkedPositions}.
*/
private void addLinkedPositions(SourceBuilder builder) {
// positions
for (Entry<String, List<SourceRange>> linkedEntry : builder.getLinkedPositions().entrySet()) {
String group = linkedEntry.getKey();
for (SourceRange position : linkedEntry.getValue()) {
addLinkedPosition(group, position);
}
}
// proposals for positions
for (Entry<String, List<LinkedPositionProposal>> entry : builder.getLinkedProposals().entrySet()) {
String group = entry.getKey();
for (LinkedPositionProposal proposal : entry.getValue()) {
addLinkedPositionProposal(group, proposal);
}
}
}
/**
* Prepares proposal for creating function corresponding to the given {@link FunctionType}.
*/
private void addProposal_createFunction(FunctionType functionType, String name,
Source targetSource, int insertOffset, boolean isStatic, String eol, String prefix,
String sourcePrefix, String sourceSuffix) {
// build method source
SourceBuilder sb = new SourceBuilder(insertOffset);
{
sb.append(sourcePrefix);
sb.append(prefix);
// may be static
if (isStatic) {
sb.append("static ");
}
// may be return type
{
Type returnType = functionType.getReturnType();
if (returnType != null) {
String typeSource = utils.getTypeSource(returnType);
if (!typeSource.equals("dynamic")) {
sb.startPosition("RETURN_TYPE");
sb.append(typeSource);
sb.endPosition();
sb.append(" ");
}
}
}
// append name
{
sb.startPosition("NAME");
sb.append(name);
sb.endPosition();
}
// append parameters
sb.append("(");
ParameterElement[] parameters = functionType.getParameters();
for (int i = 0; i < parameters.length; i++) {
ParameterElement parameter = parameters[i];
// append separator
if (i != 0) {
sb.append(", ");
}
// append type name
Type type = parameter.getType();
String typeSource = utils.getTypeSource(type);
{
sb.startPosition("TYPE" + i);
sb.append(typeSource);
addSuperTypeProposals(sb, Sets.<Type> newHashSet(), type);
sb.endPosition();
}
sb.append(" ");
// append parameter name
{
sb.startPosition("ARG" + i);
sb.append(parameter.getDisplayName());
sb.endPosition();
}
}
sb.append(")");
// close method
sb.append(" {" + eol + prefix + "}");
sb.append(sourceSuffix);
}
// insert source
addInsertEdit(insertOffset, sb.toString());
// add linked positions
if (Objects.equal(targetSource, source)) {
addLinkedPosition("NAME", sb, rangeNode(node));
}
addLinkedPositions(sb);
}
/**
* Adds proposal for creating method corresponding to the given {@link FunctionType} in the given
* {@link ClassElement}.
*/
private void addProposal_createFunction_function(FunctionType functionType) throws Exception {
String name = ((SimpleIdentifier) node).getName();
// prepare environment
String eol = utils.getEndOfLine();
int insertOffset = unit.getEnd();
// prepare prefix
String prefix = "";
String sourcePrefix = eol + eol;
String sourceSuffix = eol;
addProposal_createFunction(
functionType,
name,
source,
insertOffset,
false,
eol,
prefix,
sourcePrefix,
sourceSuffix);
// add proposal
addUnitCorrectionProposal(source, CorrectionKind.QF_CREATE_FUNCTION, name);
}
/**
* Adds proposal for creating method corresponding to the given {@link FunctionType} in the given
* {@link ClassElement}.
*/
private void addProposal_createFunction_method(ClassElement targetClassElement,
FunctionType functionType) throws Exception {
String name = ((SimpleIdentifier) node).getName();
// prepare environment
String eol = utils.getEndOfLine();
Source targetSource = targetClassElement.getSource();
// prepare insert offset
ClassDeclaration targetClassNode = targetClassElement.getNode();
int insertOffset = targetClassNode.getEnd() - 1;
// prepare prefix
String prefix = " ";
String sourcePrefix;
if (targetClassNode.getMembers().isEmpty()) {
sourcePrefix = "";
} else {
sourcePrefix = prefix + eol;
}
String sourceSuffix = eol;
addProposal_createFunction(
functionType,
name,
targetSource,
insertOffset,
inStaticMemberContext(),
eol,
prefix,
sourcePrefix,
sourceSuffix);
// add proposal
addUnitCorrectionProposal(targetSource, CorrectionKind.QF_CREATE_METHOD, name);
}
private void addRemoveEdit(SourceRange range) {
textEdits.add(createRemoveEdit(range));
}
/**
* Adds {@link Edit} to {@link #textEdits}.
*/
private void addReplaceEdit(SourceRange range, String text) {
textEdits.add(createReplaceEdit(range, text));
}
/**
* Adds {@link CorrectionProposal} with single {@link SourceChange} to {@link #proposals}.
*/
private void addUnitCorrectionProposal(CorrectionKind kind, Object... arguments) {
addUnitCorrectionProposal(source, kind, arguments);
}
/**
* Adds {@link CorrectionProposal} with single {@link SourceChange} to {@link #proposals}.
*/
private void addUnitCorrectionProposal(Source source, CorrectionKind kind, Object... arguments) {
if (!textEdits.isEmpty()) {
// prepare SourceChange
SourceChange change = new SourceChange(source.getShortName(), source);
for (Edit edit : textEdits) {
change.addEdit(edit);
}
// create SourceCorrectionProposal
SourceCorrectionProposal proposal = new SourceCorrectionProposal(change, kind, arguments);
proposal.setLinkedPositions(linkedPositions);
proposal.setLinkedPositionProposals(linkedPositionProposals);
proposal.setEndRange(endRange);
// done
proposals.add(proposal);
}
// reset
resetProposalElements();
}
private void appendParameters(StringBuilder sb, ParameterElement[] parameters) throws Exception {
Map<ParameterElement, String> defaultValueMap = getDefaultValueMap(parameters);
appendParameters(sb, parameters, defaultValueMap);
}
private void appendParameters(StringBuilder sb, ParameterElement[] parameters,
Map<ParameterElement, String> defaultValueMap) {
sb.append("(");
boolean firstParameter = true;
boolean sawNamed = false;
boolean sawPositional = false;
for (ParameterElement parameter : parameters) {
if (!firstParameter) {
sb.append(", ");
} else {
firstParameter = false;
}
// may be optional
ParameterKind parameterKind = parameter.getParameterKind();
if (parameterKind == ParameterKind.NAMED) {
if (!sawNamed) {
sb.append("{");
sawNamed = true;
}
}
if (parameterKind == ParameterKind.POSITIONAL) {
if (!sawPositional) {
sb.append("[");
sawPositional = true;
}
}
// parameter
appendParameterSource(sb, parameter.getType(), parameter.getName());
// default value
if (defaultValueMap != null) {
String defaultSource = defaultValueMap.get(parameter);
if (defaultSource != null) {
if (sawPositional) {
sb.append(" = ");
} else {
sb.append(": ");
}
sb.append(defaultSource);
}
}
}
// close parameters
if (sawNamed) {
sb.append("}");
}
if (sawPositional) {
sb.append("]");
}
sb.append(")");
}
private void appendParameterSource(StringBuilder sb, Type type, String name) {
String parameterSource = utils.getParameterSource(type, name);
sb.append(parameterSource);
}
private void appendType(StringBuilder sb, Type type) {
if (type != null && !type.isDynamic()) {
String typeSource = utils.getTypeSource(type);
sb.append(typeSource);
sb.append(" ");
}
}
private Edit createInsertEdit(int offset, String text) {
return new Edit(offset, 0, text);
}
/**
* @return the string to display as the name of the given constructor in a proposal name.
*/
private String getConstructorProposalName(ConstructorElement constructor) {
StringBuilder proposalNameBuffer = new StringBuilder();
proposalNameBuffer.append("super");
// may be named
String constructorName = constructor.getDisplayName();
if (!constructorName.isEmpty()) {
proposalNameBuffer.append(".");
proposalNameBuffer.append(constructorName);
}
// parameters
appendParameters(proposalNameBuffer, constructor.getParameters(), null);
// done
return proposalNameBuffer.toString();
}
/**
* Returns the {@link Type} with given name from the {@code dart:core} library.
*/
private Type getCoreType(String name) {
LibraryElement[] libraries = unitLibraryElement.getImportedLibraries();
for (LibraryElement library : libraries) {
if (library.isDartCore()) {
ClassElement classElement = library.getType(name);
if (classElement != null) {
return classElement.getType();
}
return null;
}
}
return null;
}
private Type getCoreTypeBool() {
return getCoreType("bool");
}
private Map<ParameterElement, String> getDefaultValueMap(ParameterElement[] parameters)
throws Exception {
Map<ParameterElement, String> defaultSourceMap = Maps.newHashMap();
for (ParameterElement parameter : parameters) {
defaultSourceMap.put(parameter, parameter.getDefaultValueCode());
}
return defaultSourceMap;
}
/**
* @return {@code true} if {@link #node} if part of a static method or any field initializer.
*/
private boolean inStaticMemberContext() {
ClassMember member = node.getAncestor(ClassMember.class);
return inStaticMemberContext(member);
}
/**
* @return {@code true} if the given {@link ClassMember} is a part of a static method or any field
* initializer.
*/
private boolean inStaticMemberContext(ClassMember member) {
if (member instanceof MethodDeclaration) {
return ((MethodDeclaration) member).isStatic();
}
// field initializer cannot reference "this"
if (member instanceof FieldDeclaration) {
return true;
}
return false;
}
private NewConstructorLocation prepareNewConstructorLocation(ClassDeclaration classDeclaration,
String eol) {
List<ClassMember> members = classDeclaration.getMembers();
// find the last field/constructor
ClassMember lastFieldOrConstructor = null;
for (ClassMember member : members) {
if (member instanceof FieldDeclaration || member instanceof ConstructorDeclaration) {
lastFieldOrConstructor = member;
} else {
break;
}
}
// after the field/constructor
if (lastFieldOrConstructor != null) {
return new NewConstructorLocation(eol + eol, lastFieldOrConstructor.getEnd(), "");
}
// at the beginning of the class
String suffix = members.isEmpty() ? "" : eol;
return new NewConstructorLocation(eol, classDeclaration.getLeftBracket().getEnd(), suffix);
}
/**
* Removes any {@link ParenthesizedExpression} enclosing the given {@link Expression}.
*
* @param expr the expression in {@link ParenthesizedExpression}
* @param exprPrecedence the effective precedence of the "expr", may be not its
* {@link Expression#getPrecedence()}
*/
private void removeEnclosingParentheses(Expression expr, int exprPrecedence) {
while (expr.getParent() instanceof ParenthesizedExpression) {
ParenthesizedExpression parenthesized = (ParenthesizedExpression) expr.getParent();
if (CorrectionUtils.getExpressionParentPrecedence(parenthesized) > exprPrecedence) {
break;
}
addRemoveEdit(rangeToken(parenthesized.getLeftParenthesis()));
addRemoveEdit(rangeToken(parenthesized.getRightParenthesis()));
expr = parenthesized;
}
}
private void resetProposalElements() {
textEdits.clear();
linkedPositions.clear();
positionStopEdits.clear();
linkedPositionProposals.clear();
endRange = null;
}
private void updateFinderWithClassMembers(ClosestElementFinder finder, ClassElement classElement) {
if (classElement != null) {
List<Element> members = HierarchyUtils.getMembers(classElement, false);
finder.update(members);
}
}
}