/*
* 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.refactoring;
import com.google.common.base.Objects;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import com.google.dart.engine.ast.AdjacentStrings;
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.Block;
import com.google.dart.engine.ast.BlockFunctionBody;
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.DoubleLiteral;
import com.google.dart.engine.ast.Expression;
import com.google.dart.engine.ast.ExpressionFunctionBody;
import com.google.dart.engine.ast.FormalParameterList;
import com.google.dart.engine.ast.FunctionBody;
import com.google.dart.engine.ast.FunctionDeclaration;
import com.google.dart.engine.ast.IntegerLiteral;
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.NullLiteral;
import com.google.dart.engine.ast.PrefixedIdentifier;
import com.google.dart.engine.ast.PropertyAccess;
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.Statement;
import com.google.dart.engine.ast.SymbolLiteral;
import com.google.dart.engine.ast.ThisExpression;
import com.google.dart.engine.ast.VariableDeclaration;
import com.google.dart.engine.ast.VariableDeclarationList;
import com.google.dart.engine.ast.VariableDeclarationStatement;
import com.google.dart.engine.ast.visitor.GeneralizingAstVisitor;
import com.google.dart.engine.ast.visitor.RecursiveAstVisitor;
import com.google.dart.engine.element.ClassElement;
import com.google.dart.engine.element.Element;
import com.google.dart.engine.element.ExecutableElement;
import com.google.dart.engine.element.FieldElement;
import com.google.dart.engine.element.FunctionElement;
import com.google.dart.engine.element.LocalElement;
import com.google.dart.engine.element.MethodElement;
import com.google.dart.engine.element.ParameterElement;
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.search.SearchMatch;
import com.google.dart.engine.services.assist.AssistContext;
import com.google.dart.engine.services.change.Change;
import com.google.dart.engine.services.change.CompositeChange;
import com.google.dart.engine.services.change.Edit;
import com.google.dart.engine.services.change.MergeCompositeChange;
import com.google.dart.engine.services.change.SourceChange;
import com.google.dart.engine.services.change.SourceChangeManager;
import com.google.dart.engine.services.internal.correction.CorrectionUtils;
import com.google.dart.engine.services.refactoring.InlineMethodRefactoring;
import com.google.dart.engine.services.refactoring.ProgressMonitor;
import com.google.dart.engine.services.status.RefactoringStatus;
import com.google.dart.engine.services.status.RefactoringStatusContext;
import com.google.dart.engine.services.util.HierarchyUtils;
import com.google.dart.engine.source.Source;
import com.google.dart.engine.utilities.source.SourceRange;
import static com.google.dart.engine.services.internal.correction.CorrectionUtils.getExpressionParentPrecedence;
import static com.google.dart.engine.services.internal.correction.CorrectionUtils.getExpressionPrecedence;
import static com.google.dart.engine.utilities.source.SourceRangeFactory.rangeFromBase;
import static com.google.dart.engine.utilities.source.SourceRangeFactory.rangeNode;
import static com.google.dart.engine.utilities.source.SourceRangeFactory.rangeStartEnd;
import static com.google.dart.engine.utilities.source.SourceRangeFactory.rangeStartLength;
import static com.google.dart.engine.utilities.source.SourceRangeFactory.rangeStartStart;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
/**
* Implementation of {@link InlineMethodRefactoring}.
*/
public class InlineMethodRefactoringImpl extends RefactoringImpl implements InlineMethodRefactoring {
private static class ParameterOccurrence {
final int parentPrecedence;
final SourceRange range;
public ParameterOccurrence(int parentPrecedence, SourceRange range) {
this.parentPrecedence = parentPrecedence;
this.range = range;
}
}
/**
* Processor for single {@link SearchMatch} reference to {@link #methodElement}.
*/
private class ReferenceProcessor {
private final Source refSource;
private final CorrectionUtils refUtils;
private final AstNode node;
private final SourceRange refLineRange;
private final String refPrefix;
private boolean argsHaveSideEffect;
ReferenceProcessor(SearchMatch reference) throws Exception {
// prepare SourceChange to update
Element refElement = reference.getElement();
refSource = refElement.getSource();
// prepare CorrectionUtils
CompilationUnit refUnit = refElement.getUnit();
refUtils = new CorrectionUtils(refUnit);
// prepare node and environment
node = refUtils.findNode(reference.getSourceRange().getOffset());
Statement refStatement = node.getAncestor(Statement.class);
if (refStatement != null) {
refLineRange = refUtils.getLinesRange(ImmutableList.of(refStatement));
refPrefix = refUtils.getNodePrefix(refStatement);
} else {
refLineRange = null;
refPrefix = refUtils.getLinePrefix(node.getOffset());
}
}
public void updateRequiresPreviewFlag() {
if (!shouldProcess()) {
return;
}
requiresPreview |= argsHaveSideEffect;
}
void checkForSideEffects() throws Exception {
AstNode nodeParent = node.getParent();
// may be invocation of inline method
if (nodeParent instanceof MethodInvocation) {
MethodInvocation invocation = (MethodInvocation) nodeParent;
List<Expression> arguments = invocation.getArgumentList().getArguments();
argsHaveSideEffect = hasSideEffect(arguments);
} else {
if (methodElement instanceof PropertyAccessorElement) {
// prepare arguments
List<Expression> arguments = Lists.newArrayList();
if (((SimpleIdentifier) node).inSetterContext()) {
arguments.add(((AssignmentExpression) nodeParent.getParent()).getRightHandSide());
}
// check arguments
argsHaveSideEffect = hasSideEffect(arguments);
}
}
}
void process(RefactoringStatus status) throws Exception {
AstNode nodeParent = node.getParent();
// may be only single place should be inlined
if (!shouldProcess()) {
return;
}
// may be invocation of inline method
if (nodeParent instanceof MethodInvocation) {
MethodInvocation invocation = (MethodInvocation) nodeParent;
Expression target = invocation.getTarget();
List<Expression> arguments = invocation.getArgumentList().getArguments();
inlineMethodInvocation(status, invocation, invocation.isCascaded(), target, arguments);
} else {
// cannot inline reference to method: var v = new A().method;
if (methodElement instanceof MethodElement) {
status.addFatalError(
"Cannot inline class method reference.",
new RefactoringStatusContext(node));
return;
}
// PropertyAccessorElement
if (methodElement instanceof PropertyAccessorElement) {
Expression target = null;
boolean cascade = false;
// TODO(scheglov) hopefully at some point in future we will have only PropertyAccess
if (nodeParent instanceof PrefixedIdentifier) {
PrefixedIdentifier propertyAccess = (PrefixedIdentifier) nodeParent;
target = propertyAccess.getPrefix();
cascade = false;
}
if (nodeParent instanceof PropertyAccess) {
PropertyAccess propertyAccess = (PropertyAccess) nodeParent;
target = propertyAccess.getRealTarget();
cascade = propertyAccess.isCascaded();
}
// prepare arguments
List<Expression> arguments = Lists.newArrayList();
if (((SimpleIdentifier) node).inSetterContext()) {
arguments.add(((AssignmentExpression) nodeParent.getParent()).getRightHandSide());
}
// inline body
inlineMethodInvocation(status, (Expression) nodeParent, cascade, target, arguments);
return;
}
// not invocation, just reference to function
String source;
{
source = methodUtils.getText(rangeStartEnd(
methodParameters.getLeftParenthesis(),
methodNode));
String methodPrefix = methodUtils.getLinePrefix(methodNode.getOffset());
source = refUtils.getIndentSource(source, methodPrefix, refPrefix);
source = source.trim();
}
// do insert
SourceChange refChange = safeManager.get(refSource);
SourceRange range = rangeNode(node);
Edit edit = new Edit(range, source);
refChange.addEdit(edit, "Replace all references to method with statements");
}
}
private boolean canInlineBody(AstNode usage) {
// no statements, usually just expression
if (methodStatementsPart == null) {
// empty method, inline as closure
if (methodExpressionPart == null) {
return false;
}
// OK, just expression
return true;
}
// analyze point of invocation
AstNode parent = usage.getParent();
AstNode parent2 = parent.getParent();
// OK, if statement in block
if (parent instanceof Statement) {
return parent2 instanceof Block;
}
// may be assignment, in block
if (parent instanceof AssignmentExpression) {
AssignmentExpression assignment = (AssignmentExpression) parent;
// inlining setter
if (assignment.getLeftHandSide() == usage) {
return parent2 instanceof Statement && parent2.getParent() instanceof Block;
}
// inlining initializer
return methodExpressionPart != null;
}
// may be value for variable initializer, in block
if (methodExpressionPart != null) {
if (parent instanceof VariableDeclaration) {
if (parent2 instanceof VariableDeclarationList) {
AstNode parent3 = parent2.getParent();
return parent3 instanceof VariableDeclarationStatement
&& parent3.getParent() instanceof Block;
}
}
}
// not in block, cannot inline body
return false;
}
private void inlineMethodInvocation(RefactoringStatus status, Expression methodUsage,
boolean cascaded, Expression target, List<Expression> arguments) {
// prepare change
SourceChange refChange;
if (argsHaveSideEffect) {
refChange = previewManager.get(refSource);
} else {
refChange = safeManager.get(refSource);
}
// we don't support cascade
if (cascaded) {
status.addError("Cannot inline cascade invocation.", new RefactoringStatusContext(
methodUsage));
}
// can we inline method body into "methodUsage" block?
if (canInlineBody(methodUsage)) {
// insert non-return statements
if (methodStatementsPart != null) {
// prepare statements source for invocation
String source = getMethodSourceForInvocation(
methodStatementsPart,
refUtils,
methodUsage,
target,
arguments);
source = refUtils.getIndentSource(source, methodStatementsPart.prefix, refPrefix);
// do insert
SourceRange range = rangeStartLength(refLineRange, 0);
Edit edit = new Edit(range, source);
refChange.addEdit(edit, "Replace all references to method with statements");
}
// replace invocation with return expression
if (methodExpressionPart != null) {
// prepare expression source for invocation
String source = getMethodSourceForInvocation(
methodExpressionPart,
refUtils,
methodUsage,
target,
arguments);
if (getExpressionPrecedence(methodExpression) < getExpressionParentPrecedence(methodUsage)) {
source = "(" + source + ")";
}
// do replace
SourceRange methodUsageRange = rangeNode(methodUsage);
Edit edit = new Edit(methodUsageRange, source);
refChange.addEdit(edit, "Replace all references to method with statements");
} else {
Edit edit = new Edit(refLineRange, "");
refChange.addEdit(edit, "Replace all references to method with statements");
}
return;
}
// inline as closure invocation
String source;
{
source = methodUtils.getText(rangeStartEnd(
methodParameters.getLeftParenthesis(),
methodNode));
String methodPrefix = methodUtils.getLinePrefix(methodNode.getOffset());
source = refUtils.getIndentSource(source, methodPrefix, refPrefix);
source = source.trim();
}
// do insert
SourceRange range = rangeNode(node);
Edit edit = new Edit(range, source);
refChange.addEdit(edit, "Replace all references to method with statements");
}
private boolean shouldProcess() {
if (currentMode == Mode.INLINE_SINGLE) {
SourceRange parentRange = rangeNode(node);
return parentRange.contains(context.getSelectionOffset());
}
return true;
}
}
/**
* Information about part of the source in {@link #methodUnit}.
*/
private static class SourcePart {
private final SourceRange baseRange;
final String source;
final String prefix;
final Map<ParameterElement, List<ParameterOccurrence>> parameters = Maps.newHashMap();
final Map<VariableElement, List<SourceRange>> variables = Maps.newHashMap();
final List<SourceRange> instanceFieldQualifiers = Lists.newArrayList();
final Map<String, List<SourceRange>> staticFieldQualifiers = Maps.newHashMap();
public SourcePart(SourceRange baseRange, String source, String prefix) {
this.baseRange = baseRange;
this.source = source;
this.prefix = prefix;
}
public void addInstanceFieldQualifier(SourceRange range) {
range = rangeFromBase(range, baseRange);
instanceFieldQualifiers.add(range);
}
public void addParameterOccurrence(ParameterElement parameter, SourceRange range, int precedence) {
if (parameter != null) {
List<ParameterOccurrence> occurrences = parameters.get(parameter);
if (occurrences == null) {
occurrences = Lists.newArrayList();
parameters.put(parameter, occurrences);
}
range = rangeFromBase(range, baseRange);
occurrences.add(new ParameterOccurrence(precedence, range));
}
}
public void addStaticFieldQualifier(String className, SourceRange range) {
List<SourceRange> ranges = staticFieldQualifiers.get(className);
if (ranges == null) {
ranges = Lists.newArrayList();
staticFieldQualifiers.put(className, ranges);
}
range = rangeFromBase(range, baseRange);
ranges.add(range);
}
public void addVariable(VariableElement element, SourceRange range) {
List<SourceRange> ranges = variables.get(element);
if (ranges == null) {
ranges = Lists.newArrayList();
variables.put(element, ranges);
}
range = rangeFromBase(range, baseRange);
ranges.add(range);
}
}
/**
* If the given {@link AstNode} is a some {@link ClassDeclaration}, returns the
* {@link ClassElement}. Otherwise returns {@code null}.
*/
private static ClassElement getEnclosingClassElement(AstNode node) {
ClassDeclaration enclosingClassNode = node.getAncestor(ClassDeclaration.class);
if (enclosingClassNode != null) {
return enclosingClassNode.getElement();
}
return null;
}
private final AssistContext context;
private SourceChangeManager safeManager;
private SourceChangeManager previewManager;
private Mode initialMode;
private List<ReferenceProcessor> referenceProcessors = Lists.newArrayList();
private boolean requiresPreview;
private Mode currentMode;
private boolean deleteSource;
private ExecutableElement methodElement;
private CompilationUnit methodUnit;
private CorrectionUtils methodUtils;
private AstNode methodNode;
private FormalParameterList methodParameters;
private FunctionBody methodBody;
private Expression methodExpression;
private SourcePart methodExpressionPart;
private SourcePart methodStatementsPart;
public InlineMethodRefactoringImpl(AssistContext context) throws Exception {
this.context = context;
}
@Override
public boolean canDeleteSource() {
// TODO(scheglov) check that declaration and all references can be updated
return true;
}
@Override
public RefactoringStatus checkFinalConditions(ProgressMonitor pm) throws Exception {
pm = checkProgressMonitor(pm);
pm.beginTask("Checking final conditions", 5);
RefactoringStatus result = new RefactoringStatus();
try {
safeManager = new SourceChangeManager();
previewManager = new SourceChangeManager();
// prepare changes
for (ReferenceProcessor processor : referenceProcessors) {
processor.process(result);
}
// delete method
if (deleteSource && currentMode == Mode.INLINE_ALL) {
SourceRange methodRange = rangeNode(methodNode);
SourceRange linesRange = methodUtils.getLinesRange(methodRange);
SourceChange change = safeManager.get(methodElement.getSource());
change.addEdit(new Edit(linesRange, ""), "Remove method declaration");
}
} finally {
pm.done();
}
return result;
}
@Override
public RefactoringStatus checkInitialConditions(ProgressMonitor pm) throws Exception {
pm = checkProgressMonitor(pm);
pm.beginTask("Checking initial conditions", 3);
try {
RefactoringStatus result = new RefactoringStatus();
// prepare method information
result.merge(prepareMethod());
if (result.hasFatalError()) {
return result;
}
pm.worked(1);
// may be operator
if (methodElement.isOperator()) {
return RefactoringStatus.createFatalErrorStatus("Cannot inline operator.");
}
// analyze method body
result.merge(prepareMethodParts());
pm.worked(1);
// process references
{
requiresPreview = false;
// find references
List<SearchMatch> references = context.getSearchEngine().searchReferences(
methodElement,
null,
null);
// prepare reference processors
referenceProcessors.clear();
for (SearchMatch reference : references) {
ReferenceProcessor processor = new ReferenceProcessor(reference);
referenceProcessors.add(processor);
processor.checkForSideEffects();
}
// update preview flag
updateRequiresPreviewFlag();
}
pm.worked(1);
// done
return result;
} finally {
pm.done();
}
}
@Override
public Change createChange(ProgressMonitor pm) throws Exception {
pm = checkProgressMonitor(pm);
try {
SourceChange[] safeChanges = safeManager.getChanges();
SourceChange[] previewChanges = previewManager.getChanges();
if (previewChanges.length == 0) {
CompositeChange compositeChange = new CompositeChange(getRefactoringName());
compositeChange.add(safeChanges);
return compositeChange;
} else {
CompositeChange safeChange = new CompositeChange("(Safe changes)");
CompositeChange previewChange = new CompositeChange("(Has arguments with side-effects)");
safeChange.add(safeChanges);
previewChange.add(previewChanges);
return new MergeCompositeChange(getRefactoringName(), previewChange, safeChange);
}
} finally {
pm.done();
}
}
@Override
public ExecutableElement getElement() {
return methodElement;
}
@Override
public Mode getInitialMode() {
return initialMode;
}
@Override
public String getRefactoringName() {
if (methodElement instanceof MethodElement) {
return "Inline Method";
} else {
return "Inline Function";
}
}
@Override
public boolean requiresPreview() {
return requiresPreview;
}
@Override
public void setCurrentMode(Mode currentMode) {
this.currentMode = currentMode;
updateRequiresPreviewFlag();
}
@Override
public void setDeleteSource(boolean delete) {
this.deleteSource = delete;
}
private SourcePart createSourcePart(final SourceRange sourceRange) {
final SourcePart result;
{
String source = methodUtils.getText(sourceRange);
String prefix = CorrectionUtils.getLinesPrefix(source);
result = new SourcePart(sourceRange, source, prefix);
}
// remember parameters and variables occurrences
methodUnit.accept(new GeneralizingAstVisitor<Void>() {
@Override
public Void visitNode(AstNode node) {
SourceRange nodeRange = rangeNode(node);
if (!sourceRange.intersects(nodeRange)) {
return null;
}
return super.visitNode(node);
}
@Override
public Void visitSimpleIdentifier(SimpleIdentifier node) {
SourceRange nodeRange = rangeNode(node);
if (sourceRange.covers(nodeRange)) {
addInstanceFieldQualifier(node);
addParameter(node);
addVariable(node);
}
return null;
}
private void addInstanceFieldQualifier(SimpleIdentifier node) {
PropertyAccessorElement accessor = CorrectionUtils.getPropertyAccessorElement(node);
if (isFieldAccessorElement(accessor)) {
AstNode qualifier = CorrectionUtils.getNodeQualifier(node);
if (qualifier == null || qualifier instanceof ThisExpression) {
if (accessor.isStatic()) {
String className = accessor.getEnclosingElement().getDisplayName();
if (qualifier == null) {
SourceRange qualifierRange = rangeStartLength(node, 0);
result.addStaticFieldQualifier(className, qualifierRange);
}
} else {
SourceRange qualifierRange;
if (qualifier != null) {
qualifierRange = rangeStartStart(qualifier, node);
} else {
qualifierRange = rangeStartLength(node, 0);
}
result.addInstanceFieldQualifier(qualifierRange);
}
}
}
}
private void addParameter(SimpleIdentifier node) {
ParameterElement parameterElement = CorrectionUtils.getParameterElement(node);
// not parameter
if (parameterElement == null) {
return;
}
// not parameter of a function being inlined
if (!ArrayUtils.contains(methodElement.getParameters(), parameterElement)) {
return;
}
// OK, add occurrence
SourceRange nodeRange = rangeNode(node);
int parentPrecedence = getExpressionParentPrecedence(node);
result.addParameterOccurrence(parameterElement, nodeRange, parentPrecedence);
}
private void addVariable(SimpleIdentifier node) {
VariableElement variableElement = CorrectionUtils.getLocalVariableElement(node);
if (variableElement != null) {
SourceRange nodeRange = rangeNode(node);
result.addVariable(variableElement, nodeRange);
}
}
});
// done
return result;
}
/**
* @return the source which should replace given invocation with given arguments.
*/
private String getMethodSourceForInvocation(SourcePart part, CorrectionUtils utils,
AstNode contextNode, Expression targetExpression, List<Expression> arguments) {
// prepare edits to replace parameters with arguments
List<Edit> edits = Lists.newArrayList();
for (Entry<ParameterElement, List<ParameterOccurrence>> entry : part.parameters.entrySet()) {
ParameterElement parameter = entry.getKey();
// prepare argument
Expression argument = null;
for (Expression arg : arguments) {
if (Objects.equal(arg.getBestParameterElement(), parameter)) {
argument = arg;
break;
}
}
if (argument instanceof NamedExpression) {
argument = ((NamedExpression) argument).getExpression();
}
int argumentPrecedence = getExpressionPrecedence(argument);
String argumentSource = utils.getText(argument);
// replace all occurrences of this parameter
for (ParameterOccurrence occurrence : entry.getValue()) {
SourceRange range = occurrence.range;
// prepare argument source to apply at this occurrence
String occurrenceArgumentSource;
if (argumentPrecedence < occurrence.parentPrecedence) {
occurrenceArgumentSource = "(" + argumentSource + ")";
} else {
occurrenceArgumentSource = argumentSource;
}
// do replace
edits.add(new Edit(range, occurrenceArgumentSource));
}
}
// replace static field "qualifier" with invocation target
for (Entry<String, List<SourceRange>> entry : part.staticFieldQualifiers.entrySet()) {
String className = entry.getKey();
for (SourceRange range : entry.getValue()) {
edits.add(new Edit(range, className + "."));
}
}
// replace instance field "qualifier" with invocation target
if (targetExpression != null) {
String targetSource = utils.getText(targetExpression) + ".";
for (SourceRange qualifierRange : part.instanceFieldQualifiers) {
edits.add(new Edit(qualifierRange, targetSource));
}
}
// prepare edits to replace conflicting variables
Set<String> conflictingNames = getNamesConflictingWithLocal(utils.getUnit(), contextNode);
for (Entry<VariableElement, List<SourceRange>> entry : part.variables.entrySet()) {
String originalName = entry.getKey().getDisplayName();
// prepare unique name
String uniqueName;
{
uniqueName = originalName;
int uniqueIndex = 2;
while (conflictingNames.contains(uniqueName)) {
uniqueName = originalName + uniqueIndex;
uniqueIndex++;
}
}
// update references, if name was change
if (!StringUtils.equals(uniqueName, originalName)) {
for (SourceRange range : entry.getValue()) {
edits.add(new Edit(range, uniqueName));
}
}
}
// prepare source with applied arguments
return CorrectionUtils.applyReplaceEdits(part.source, edits);
}
private SourceRange getNamesConflictingRange(AstNode node) {
// may be Block
Block block = node.getAncestor(Block.class);
if (block != null) {
int offset = node.getOffset();
int endOffset = block.getEnd();
return rangeStartEnd(offset, endOffset);
}
// may be whole executable
AstNode executableNode = CorrectionUtils.getEnclosingExecutableNode(node);
if (executableNode != null) {
return rangeNode(executableNode);
}
// not a part of declaration with locals
return SourceRange.EMPTY;
}
/**
* @return the names which will shadow or will be shadowed by any declaration at "node".
*/
private Set<String> getNamesConflictingWithLocal(CompilationUnit unit, AstNode node) {
final Set<String> result = Sets.newHashSet();
// local variables and functions
{
final SourceRange offsetRange = getNamesConflictingRange(node);
ExecutableElement enclosingExecutable = CorrectionUtils.getEnclosingExecutableElement(node);
if (enclosingExecutable != null) {
enclosingExecutable.accept(new GeneralizingElementVisitor<Void>() {
@Override
public Void visitLocalElement(LocalElement element) {
SourceRange elementRange = element.getVisibleRange();
if (elementRange != null && elementRange.intersects(offsetRange)) {
result.add(element.getDisplayName());
}
return super.visitLocalElement(element);
}
});
}
}
// fields
{
ClassElement enclosingClassElement = getEnclosingClassElement(node);
if (enclosingClassElement != null) {
Set<ClassElement> elements = Sets.newHashSet(enclosingClassElement);
elements.addAll(HierarchyUtils.getSuperClasses(enclosingClassElement));
for (ClassElement classElement : elements) {
List<Element> classMembers = CorrectionUtils.getChildren(classElement);
for (Element classMemberElement : classMembers) {
result.add(classMemberElement.getDisplayName());
}
}
}
}
// done
return result;
}
/**
* @return {@code true} if we can prove that the given {@link Expression} has no side effects.
*/
private boolean hasSideEffect(Expression e) {
if (e instanceof BooleanLiteral || e instanceof DoubleLiteral || e instanceof IntegerLiteral
|| e instanceof NullLiteral || e instanceof SimpleStringLiteral
|| e instanceof AdjacentStrings || e instanceof SymbolLiteral) {
return false;
}
if (e instanceof ThisExpression) {
return false;
}
if (e instanceof NamedExpression) {
NamedExpression namedExpression = (NamedExpression) e;
return hasSideEffect(namedExpression.getExpression());
}
if (e instanceof SimpleIdentifier) {
SimpleIdentifier identifier = (SimpleIdentifier) e;
Element element = identifier.getBestElement();
if (element instanceof VariableElement) {
return false;
}
if (element instanceof PropertyAccessorElement) {
return !element.isSynthetic();
}
}
if (e instanceof BinaryExpression) {
BinaryExpression binary = (BinaryExpression) e;
return hasSideEffect(binary.getLeftOperand()) || hasSideEffect(binary.getRightOperand());
}
return true;
}
/**
* @return {@code true} if we can prove that all of the given {@link Expression} have no side
* effects.
*/
private boolean hasSideEffect(List<Expression> arguments) {
for (Expression argument : arguments) {
if (hasSideEffect(argument)) {
return true;
}
}
return false;
}
/**
* @return <code>true</code> if given {@link PropertyAccessorElement} is accessor of some
* {@link FieldElement}.
*/
private boolean isFieldAccessorElement(PropertyAccessorElement accessor) {
return accessor != null && accessor.getVariable() instanceof FieldElement
&& accessor.getVariable().getEnclosingElement() instanceof ClassElement;
}
/**
* Initializes "method*" fields.
*/
private RefactoringStatus prepareMethod() throws Exception {
methodElement = null;
methodParameters = null;
methodBody = null;
// prepare selected SimpleIdentifier
AstNode selectedNode = context.getCoveringNode();
if (!(selectedNode instanceof SimpleIdentifier)) {
return RefactoringStatus.createFatalErrorStatus("Method declaration or reference must be selected to activate this refactoring.");
}
SimpleIdentifier selectedIdentifier = (SimpleIdentifier) selectedNode;
// prepare selected ExecutableElement
Element selectedElement = selectedIdentifier.getBestElement();
if (!(selectedElement instanceof ExecutableElement)) {
return RefactoringStatus.createFatalErrorStatus("Method declaration or reference must be selected to activate this refactoring.");
}
methodElement = (ExecutableElement) selectedElement;
methodUnit = selectedElement.getUnit();
methodUtils = new CorrectionUtils(methodUnit);
if (selectedElement instanceof MethodElement
|| selectedElement instanceof PropertyAccessorElement) {
MethodDeclaration methodDeclaration = (MethodDeclaration) methodElement.getNode();
methodNode = methodDeclaration;
methodParameters = methodDeclaration.getParameters();
methodBody = methodDeclaration.getBody();
// prepare mode
boolean isDeclaration = methodDeclaration.getName() == selectedNode;
initialMode = currentMode = isDeclaration ? Mode.INLINE_ALL : Mode.INLINE_SINGLE;
}
if (selectedElement instanceof FunctionElement) {
FunctionDeclaration functionDeclaration = (FunctionDeclaration) methodElement.getNode();
methodNode = functionDeclaration;
methodParameters = functionDeclaration.getFunctionExpression().getParameters();
methodBody = functionDeclaration.getFunctionExpression().getBody();
// prepare mode
boolean isDeclaration = functionDeclaration.getName() == selectedNode;
initialMode = currentMode = isDeclaration ? Mode.INLINE_ALL : Mode.INLINE_SINGLE;
}
// OK
return new RefactoringStatus();
}
/**
* Analyze {@link #methodBody} to fill {@link #methodExpressionPart} and
* {@link #methodStatementsPart}.
*/
private RefactoringStatus prepareMethodParts() {
final RefactoringStatus result = new RefactoringStatus();
if (methodBody instanceof ExpressionFunctionBody) {
ExpressionFunctionBody body = (ExpressionFunctionBody) methodBody;
methodExpression = body.getExpression();
SourceRange methodExpressionRange = rangeNode(methodExpression);
methodExpressionPart = createSourcePart(methodExpressionRange);
} else if (methodBody instanceof BlockFunctionBody) {
Block body = ((BlockFunctionBody) methodBody).getBlock();
List<Statement> statements = body.getStatements();
if (statements.size() >= 1) {
Statement lastStatement = statements.get(statements.size() - 1);
// "return" statement requires special handling
if (lastStatement instanceof ReturnStatement) {
methodExpression = ((ReturnStatement) lastStatement).getExpression();
SourceRange methodExpressionRange = rangeNode(methodExpression);
methodExpressionPart = createSourcePart(methodExpressionRange);
// exclude "return" statement from statements
statements = ImmutableList.copyOf(statements).subList(0, statements.size() - 1);
}
// if there are statements, process them
if (!statements.isEmpty()) {
SourceRange statementsRange = methodUtils.getLinesRange(statements);
methodStatementsPart = createSourcePart(statementsRange);
}
}
// check if more than one return
body.accept(new RecursiveAstVisitor<Void>() {
private int numReturns = 0;
@Override
public Void visitReturnStatement(ReturnStatement node) {
numReturns++;
if (numReturns == 2) {
result.addError("Ambiguous return value.", new RefactoringStatusContext(node));
}
return super.visitReturnStatement(node);
}
});
} else {
return RefactoringStatus.createFatalErrorStatus("Cannot inline method without body.");
}
return result;
}
private void updateRequiresPreviewFlag() {
requiresPreview = false;
for (ReferenceProcessor processor : referenceProcessors) {
processor.updateRequiresPreviewFlag();
}
}
}