| /******************************************************************************* |
| * Copyright (c) 2000, 2010 IBM Corporation and others. |
| * This program and the accompanying materials are made available under the |
| * terms of the Eclipse Public License v. 2.0 which is available at |
| * http://www.eclipse.org/legal/epl-2.0. |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| * Dmitry Stalnov (dstalnov@fusionone.com) - contributed fixes for: |
| * o bug "inline method - doesn't handle implicit cast" (see |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=24941). |
| * o bug inline method: compile error (array related) |
| * (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=38471) |
| * o inline call that is used in a field initializer |
| * (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=38137) |
| * o inline call a field initializer: could detect self reference |
| * (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=44417) |
| * o Allow 'this' constructor to be inlined |
| * (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=38093) |
| *******************************************************************************/ |
| package org.eclipse.dltk.internal.javascript.corext.refactoring.code; |
| |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.dltk.core.ISourceModule; |
| import org.eclipse.dltk.core.ModelException; |
| import org.eclipse.dltk.core.SourceRange; |
| import org.eclipse.dltk.internal.corext.refactoring.base.ScriptStatusContext; |
| import org.eclipse.dltk.internal.javascript.core.manipulation.JavascriptManipulationPlugin; |
| import org.eclipse.dltk.internal.javascript.corext.refactoring.RefactoringCoreMessages; |
| import org.eclipse.dltk.internal.javascript.corext.refactoring.code.flow.FlowContext; |
| import org.eclipse.dltk.internal.javascript.corext.refactoring.code.flow.FlowInfo; |
| import org.eclipse.dltk.internal.javascript.corext.refactoring.code.flow.InputFlowAnalyzer; |
| import org.eclipse.dltk.internal.javascript.corext.refactoring.code.flow.VariableBinding; |
| import org.eclipse.dltk.internal.javascript.corext.refactoring.util.Selection; |
| import org.eclipse.dltk.javascript.core.dom.BinaryExpression; |
| import org.eclipse.dltk.javascript.core.dom.BinaryOperator; |
| import org.eclipse.dltk.javascript.core.dom.BlockStatement; |
| import org.eclipse.dltk.javascript.core.dom.CallExpression; |
| import org.eclipse.dltk.javascript.core.dom.ConditionalExpression; |
| import org.eclipse.dltk.javascript.core.dom.DomFactory; |
| import org.eclipse.dltk.javascript.core.dom.DomPackage; |
| import org.eclipse.dltk.javascript.core.dom.Expression; |
| import org.eclipse.dltk.javascript.core.dom.ExpressionStatement; |
| import org.eclipse.dltk.javascript.core.dom.FunctionExpression; |
| import org.eclipse.dltk.javascript.core.dom.Identifier; |
| import org.eclipse.dltk.javascript.core.dom.IfStatement; |
| import org.eclipse.dltk.javascript.core.dom.Node; |
| import org.eclipse.dltk.javascript.core.dom.ParenthesizedExpression; |
| import org.eclipse.dltk.javascript.core.dom.ReturnStatement; |
| import org.eclipse.dltk.javascript.core.dom.Statement; |
| import org.eclipse.dltk.javascript.core.dom.UnaryExpression; |
| import org.eclipse.dltk.javascript.core.dom.VariableDeclaration; |
| import org.eclipse.dltk.javascript.core.dom.VariableReference; |
| import org.eclipse.dltk.javascript.core.dom.VariableStatement; |
| import org.eclipse.dltk.javascript.core.dom.rewrite.RefactoringUtils; |
| import org.eclipse.dltk.javascript.core.dom.rewrite.VariableLookup; |
| import org.eclipse.dltk.javascript.core.dom.util.DomSwitch; |
| import org.eclipse.emf.common.util.TreeIterator; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.EReference; |
| import org.eclipse.emf.ecore.util.EcoreUtil; |
| import org.eclipse.ltk.core.refactoring.RefactoringStatus; |
| import org.eclipse.ltk.core.refactoring.RefactoringStatusEntry; |
| |
| public class CallInliner { |
| |
| private ISourceModule cu; |
| //private ASTRewrite fRewrite; |
| //private ImportRewrite fImportRewrite; |
| private SourceProvider sourceProvider; |
| //private TypeEnvironment fTypeEnvironment; |
| |
| private Node bodyDeclaration; |
| //private CodeScopeBuilder.Scope fRootScope; |
| //private int fNumberOfLocals; |
| |
| private CallExpression invocation; |
| |
| /*private int fInsertionIndex; |
| private ListRewrite fListRewrite; |
| |
| private boolean fNeedsStatement;*/ |
| private Node targetNode; |
| private FlowContext flowContext; |
| private FlowInfo flowInfo; |
| private Map<Identifier,VariableBinding> bindings; |
| private Expression[] realArguments; |
| //private CodeScopeBuilder.Scope invocationScope; |
| //private boolean fFieldInitializer; |
| private Set<String> usedNames; |
| private List<String> locals; |
| private List<Expression> localInitializers; |
| private Expression receiverExpr; |
| //private CallContext fContext; |
| |
| private class InlineEvaluator extends DomSwitch<Boolean> { |
| private ParameterData formalArgument; |
| private boolean result; |
| public InlineEvaluator(ParameterData argument) { |
| formalArgument= argument; |
| } |
| public boolean getResult() { |
| return result; |
| } |
| public void traverse(Node node) { |
| int accessMode= formalArgument.getSimplifiedAccessMode(); |
| switch(node.eClass().getClassifierID()) { |
| case DomPackage.VARIABLE_REFERENCE: |
| VariableBinding binding = bindings.get(((VariableReference)node).getVariable()); |
| result = accessMode == FlowInfo.READ || accessMode == FlowInfo.UNUSED |
| || flowInfo.hasAccessMode(flowContext, binding, FlowInfo.UNUSED | FlowInfo.WRITE); |
| case DomPackage.BOOLEAN_LITERAL: |
| case DomPackage.NULL_LITERAL: |
| case DomPackage.NUMERIC_LITERAL: |
| case DomPackage.REGULAR_EXPRESSION_LITERAL: |
| case DomPackage.STRING_LITERAL: |
| case DomPackage.THIS_EXPRESSION: |
| result = accessMode != FlowInfo.WRITE; |
| break; |
| case DomPackage.PARENTHESIZED_EXPRESSION: |
| traverse(((ParenthesizedExpression)node).getEnclosed()); |
| break; |
| case DomPackage.PROPERTY_ACCESS_EXPRESSION: |
| case DomPackage.ARRAY_ACCESS_EXPRESSION: |
| result = accessMode == FlowInfo.UNUSED || accessMode == FlowInfo.READ && formalArgument.getNumberOfAccesses() <= 1; |
| result = result && !formalArgument.isFunction(); |
| break; |
| default: |
| result = accessMode == FlowInfo.UNUSED || accessMode == FlowInfo.READ && formalArgument.getNumberOfAccesses() <= 1; |
| } |
| } |
| } |
| |
| /*private static class AmbiguousMethodAnalyzer implements TypeBindingVisitor { |
| private TypeEnvironment fTypeEnvironment; |
| private TType[] fTypes; |
| private IMethodBinding fOriginal; |
| |
| public AmbiguousMethodAnalyzer(TypeEnvironment typeEnvironment, IMethodBinding original, TType[] types) { |
| fTypeEnvironment= typeEnvironment; |
| fOriginal= original; |
| fTypes= types; |
| } |
| public boolean visit(ITypeBinding node) { |
| IMethodBinding[] methods= node.getDeclaredMethods(); |
| for (int i= 0; i < methods.length; i++) { |
| IMethodBinding candidate= methods[i]; |
| if (candidate == fOriginal) { |
| continue; |
| } |
| if (fOriginal.getName().equals(candidate.getName())) { |
| if (canImplicitlyCall(candidate)) { |
| return false; |
| } |
| } |
| } |
| return true; |
| } |
| /** |
| * Returns <code>true</code> if the method can be called without explicit casts; |
| * otherwise <code>false</code>. |
| * @param candidate the method to test |
| * @return <code>true</code> if the method can be called without explicit casts |
| * |
| private boolean canImplicitlyCall(IMethodBinding candidate) { |
| ITypeBinding[] parameters= candidate.getParameterTypes(); |
| if (parameters.length != fTypes.length) { |
| return false; |
| } |
| for (int i= 0; i < parameters.length; i++) { |
| if (!fTypes[i].canAssignTo(fTypeEnvironment.create(parameters[i]))) { |
| return false; |
| } |
| } |
| return true; |
| } |
| }*/ |
| |
| private final class ReceiverAnalyzer { |
| private final Map<VariableBinding, Expression> replacements; |
| private final Map<Identifier, VariableBinding> bindings; |
| |
| private ReceiverAnalyzer(Map<VariableBinding, Expression> replacements, |
| Map<Identifier, VariableBinding> bindings) { |
| this.replacements = replacements; |
| this.bindings = bindings; |
| } |
| |
| void traverse(List<? extends Node> list, Node node) { |
| traverse(list); |
| if (node != null) |
| traverse(node); |
| } |
| |
| void traverse(List<? extends Node> list) { |
| for(int i=0;i<list.size();i++) { |
| Expression expr = process(list.get(i)); |
| if (expr != null) |
| ((List<Expression>)list).set(i, expr); |
| } |
| } |
| |
| void traverse(Node node) { |
| for(EReference ref : node.eClass().getEAllReferences()) |
| if (ref.isMany()) |
| traverse((List<? extends Node>)node.eGet(ref)); |
| else { |
| Expression expr = process((Node)node.eGet(ref)); |
| if (expr != null) |
| node.eSet(ref,expr); |
| } |
| } |
| |
| Expression process(Node value) { |
| if (value == null) |
| return null; |
| switch(value.eClass().getClassifierID()) { |
| case DomPackage.IDENTIFIER: { |
| VariableBinding binding = bindings.get((Identifier)value); |
| Expression res = replacements.get(binding); |
| if (res == null) |
| return null; |
| if (res instanceof VariableReference) { |
| ((Identifier)value).setName(((VariableReference) res).getVariable().getName()); |
| return null; |
| } |
| throw new IllegalStateException("Replacing variable with expression without removing declaration"); // $NON-NLS-1 |
| } |
| case DomPackage.VARIABLE_REFERENCE: |
| VariableBinding binding = bindings.get(((VariableReference)value).getVariable()); |
| if (binding == null) |
| return null; |
| Expression res = replacements.get(binding); |
| if (res != null) { |
| res = (Expression)EcoreUtil.copy(res); |
| if (needsParentheses(res,(Expression)value)) { |
| ParenthesizedExpression pExp = DomFactory.eINSTANCE.createParenthesizedExpression(); |
| pExp.setEnclosed((Expression)res); |
| res = pExp; |
| } |
| return res; |
| } |
| return null; |
| case DomPackage.THIS_EXPRESSION: |
| return receiverExpr==null ? null : (Expression)EcoreUtil.copy(receiverExpr); |
| default: |
| traverse(value); |
| return null; |
| } |
| } |
| } |
| |
| public CallInliner(ISourceModule cu, SourceProvider provider) throws CoreException { |
| this.cu = cu; |
| sourceProvider= provider; |
| //fImportRewrite= StubUtility.createImportRewrite(targetAstRoot, true); |
| /*fRewrite= ASTRewrite.create(targetAstRoot.getAST()); |
| fRewrite.setTargetSourceRangeComputer(new NoCommentSourceRangeComputer()); |
| fTypeEnvironment= new TypeEnvironment();*/ |
| } |
| |
| /*public ImportRewrite getImportEdit() { |
| return fImportRewrite; |
| } |
| |
| public ASTNode getTargetNode() { |
| return fTargetNode; |
| }*/ |
| |
| public void initialize(Node declaration) { |
| bodyDeclaration= declaration; |
| bindings = VariableLookup.findBindings(declaration); |
| /*fRootScope= CodeScopeBuilder.perform(declaration, fSourceProvider.getDeclaration().resolveBinding()); |
| fNumberOfLocals= 0; |
| switch (declaration.getNodeType()) { |
| case ASTNode.METHOD_DECLARATION: |
| case ASTNode.INITIALIZER: |
| fNumberOfLocals= LocalVariableIndex.perform(declaration); |
| break; |
| }*/ |
| } |
| |
| public RefactoringStatus initialize(CallExpression invocation, int severity) { |
| RefactoringStatus result= new RefactoringStatus(); |
| this.invocation= invocation; |
| locals = new ArrayList<String>(); |
| localInitializers = new ArrayList<Expression>(); |
| |
| //checkMethodDeclaration(result, severity); |
| //if (result.getSeverity() >= severity) |
| // return result; |
| |
| //initializeRewriteState(); |
| initializeTargetNode(); |
| flowAnalysis(); |
| |
| //context= new CallContext(invocation, invocationScope, targetNode.getNodeType(), importRewrite); |
| |
| try { |
| computeRealArguments(); |
| computeReceiver(); |
| } catch (ModelException exception) { |
| JavascriptManipulationPlugin.log(exception); |
| } |
| checkInvocationContext(result, severity); |
| |
| return result; |
| } |
| |
| /*private void initializeRewriteState() { |
| fFieldInitializer= false; |
| ASTNode parent= fInvocation.getParent(); |
| do { |
| if (parent instanceof FieldDeclaration) { |
| fFieldInitializer= true; |
| return; |
| } else if (parent instanceof Block) { |
| return; |
| } |
| parent= parent.getParent(); |
| } while (parent != null); |
| }*/ |
| |
| private void initializeTargetNode() { |
| Node parent= (Node)invocation.eContainer(); |
| int nodeType= parent.eClass().getClassifierID(); |
| if (nodeType == DomPackage.EXPRESSION_STATEMENT || nodeType == DomPackage.RETURN_STATEMENT) { |
| targetNode= parent; |
| } else { |
| targetNode= invocation; |
| } |
| } |
| |
| // the checks depend on invocation context and therefore can't be done in SourceAnalyzer |
| //private void checkMethodDeclaration(RefactoringStatus result, int severity) { |
| // FunctionExpression methodDeclaration= sourceProvider.getDeclaration(); |
| /*if (fSourceProvider.hasSuperMethodInvocation() && fInvocation.getNodeType() == ASTNode.METHOD_INVOCATION) { |
| Expression receiver= ((MethodInvocation)fInvocation).getExpression(); |
| if (receiver instanceof ThisExpression) { |
| result.addEntry(new RefactoringStatusEntry( |
| severity, |
| RefactoringCoreMessages.CallInliner_super_into_this_expression, |
| JavaStatusContext.create(fCUnit, fInvocation))); |
| } |
| }*/ |
| //} |
| |
| private void checkInvocationContext(RefactoringStatus result, int severity) { |
| //Expression exp= getReceiver(invocation); |
| //if (exp != null && exp.resolveTypeBinding() == null) { |
| // addEntry(result, RefactoringCoreMessages.CallInliner_receiver_type, |
| // RefactoringStatusCodes.INLINE_METHOD_NULL_BINDING, severity); |
| // return; |
| //} |
| int nodeType= targetNode.eClass().getClassifierID(); |
| if (nodeType == DomPackage.EXPRESSION_STATEMENT) { |
| if (sourceProvider.isExecutionFlowInterrupted()) { |
| addEntry(result, RefactoringCoreMessages.CallInliner_execution_flow); |
| return; |
| } |
| } else if (nodeType == DomPackage.CALL_EXPRESSION) { |
| Node parent= (Node)targetNode.eContainer(); |
| int parentType = parent.eClass().getClassifierID(); |
| if (parentType == DomPackage.RETURN_STATEMENT) { |
| //support inlining even if the execution flow is interrupted |
| return; |
| } |
| if (sourceProvider.isExecutionFlowInterrupted()) { |
| addEntry(result, RefactoringCoreMessages.CallInliner_execution_flow); |
| return; |
| } |
| if (parentType == DomPackage.BINARY_EXPRESSION && RefactoringUtils.isAssignment(((BinaryExpression)parent).getOperation()) |
| && parent.eContainer().eClass().getClassifierID() == DomPackage.EXPRESSION_STATEMENT) { |
| // we support inlining expression in assigment and initializers as |
| // long as the execution flow isn't interrupted. |
| return; |
| } |
| if (parentType == DomPackage.VARIABLE_DECLARATION) { |
| VariableDeclaration decl = (VariableDeclaration)parent; |
| VariableStatement stmt = (VariableStatement)decl.eContainer(); |
| if (stmt.getDeclarations().get(0) == decl) |
| return; |
| } |
| if (parentType == DomPackage.NEW_EXPRESSION) { |
| addEntry(result, RefactoringCoreMessages.CallInliner_constructors); |
| return; |
| } |
| //boolean isFieldDeclaration= ASTNodes.getParent(invocation, FieldDeclaration.class) != null; |
| if (!sourceProvider.isSimpleFunction()) { |
| if (isMultiDeclarationFragment(parent)) { |
| addEntry(result, RefactoringCoreMessages.CallInliner_multiDeclaration); |
| /*} else if (isFieldDeclaration) { |
| addEntry(result, |
| RefactoringCoreMessages.CallInliner_field_initializer_simple, |
| RefactoringStatusCodes.INLINE_METHOD_FIELD_INITIALIZER, severity);*/ |
| } else { |
| addEntry(result, RefactoringCoreMessages.CallInliner_simple_functions); |
| } |
| return; |
| } |
| /*if (isFieldDeclaration) { |
| int argumentsCount= fContext.arguments.length; |
| for (int i= 0; i < argumentsCount; i++) { |
| ParameterData parameter= fSourceProvider.getParameterData(i); |
| if(parameter.isWrite()) { |
| addEntry(result, |
| RefactoringCoreMessages.CallInliner_field_initialize_write_parameter, |
| RefactoringStatusCodes.INLINE_METHOD_FIELD_INITIALIZER, severity); |
| return; |
| } |
| } |
| if(fLocals.size() > 0) { |
| addEntry(result, |
| RefactoringCoreMessages.CallInliner_field_initialize_new_local, |
| RefactoringStatusCodes.INLINE_METHOD_FIELD_INITIALIZER, severity); |
| return; |
| } |
| // verify that the field is not referenced by the initializer method |
| VariableDeclarationFragment variable= (VariableDeclarationFragment)ASTNodes.getParent(fInvocation, ASTNode.VARIABLE_DECLARATION_FRAGMENT); |
| if(fSourceProvider.isVariableReferenced(variable.resolveBinding())) { |
| addEntry(result, |
| RefactoringCoreMessages.CallInliner_field_initialize_self_reference, |
| RefactoringStatusCodes.INLINE_METHOD_FIELD_INITIALIZER, severity); |
| return; |
| } |
| }*/ |
| } |
| } |
| |
| /*private static boolean isAssignment(ASTNode node) { |
| return node instanceof Assignment; |
| } |
| |
| private static boolean isReturnStatement(ASTNode node) { |
| return node instanceof ReturnStatement; |
| } |
| |
| private static boolean isSingleDeclaration(ASTNode node) { |
| int type= node.getNodeType(); |
| if (type == ASTNode.SINGLE_VARIABLE_DECLARATION) |
| return true; |
| if (type == ASTNode.VARIABLE_DECLARATION_FRAGMENT) { |
| node= node.getParent(); |
| if (node.getNodeType() == ASTNode.VARIABLE_DECLARATION_STATEMENT) { |
| VariableDeclarationStatement vs= (VariableDeclarationStatement)node; |
| return vs.fragments().size() == 1; |
| } |
| } |
| return false; |
| }*/ |
| |
| private static boolean isMultiDeclarationFragment(Node node) { |
| return node instanceof VariableDeclaration && ((VariableStatement)node.eContainer()).getDeclarations().size() > 1; |
| } |
| |
| private void addEntry(RefactoringStatus result, String message) { |
| result.addEntry(new RefactoringStatusEntry( |
| RefactoringStatus.ERROR, message, |
| ScriptStatusContext.create(cu, new SourceRange(invocation.getBegin(),invocation.getEnd()-invocation.getBegin())), |
| JavascriptManipulationPlugin.getPluginId(),RefactoringStatusEntry.NO_CODE)); |
| } |
| |
| private void flowAnalysis() { |
| //invocationScope = rootScope.findScope(targetNode.getBegin(), targetNode.getEnd()); |
| //invocationScope.setCursor(targetNode.getBegin()); |
| flowContext= new FlowContext(bindings); |
| flowContext.setConsiderAccessMode(true); |
| flowContext.setComputeMode(FlowContext.Mode.ARGUMENTS); |
| Selection selection= Selection.createFromStartLength(invocation.getBegin(), invocation.getEnd()-invocation.getBegin()); |
| flowInfo= new InputFlowAnalyzer(flowContext, selection, true).perform(bodyDeclaration); |
| } |
| |
| /*public TextEdit getModifications() { |
| return fRewrite.rewriteAST(fBuffer.getDocument(), fCUnit.getJavaProject().getOptions(true)); |
| }*/ |
| |
| private String getUnusedName(String candidate) { |
| if (!usedNames.contains(candidate)) { |
| usedNames.add(candidate); |
| return candidate; |
| } |
| for(int i=1;;i++) { |
| String res = candidate+i; |
| if (!usedNames.contains(res)) { |
| usedNames.add(res); |
| return res; |
| } |
| } |
| } |
| |
| private Set<String> computeRealArguments() throws ModelException { |
| List<Expression> arguments=invocation.getArguments(); |
| Set<Expression> canNotInline=crossCheckArguments(arguments); |
| //boolean needsVarargBoxing=needsVarargBoxing(arguments); |
| //int varargIndex= fSourceProvider.getVarargIndex(); |
| realArguments= new Expression[arguments.size()]; |
| usedNames = VariableLookup.getVisibleNames(invocation); |
| for (int i= 0; i < arguments.size(); i++) { |
| Expression expression= (Expression)arguments.get(i); |
| ParameterData parameter= sourceProvider.getParameterData(i); |
| if (canInline(expression, parameter) && !canNotInline.contains(expression)) { |
| realArguments[i] = (Expression)EcoreUtil.copy(expression); |
| //if (argumentNeedsParentheses(expression, parameter)) { |
| // realArguments[i] = "(" + realArguments[i] + ")"; //$NON-NLS-1$ //$NON-NLS-2$ |
| //} |
| } else { |
| //String name= invocationScope.createName(parameter.getName(), true); |
| Identifier id = DomFactory.eINSTANCE.createIdentifier(); |
| String name = getUnusedName(parameter.getName()); |
| id.setName(name); |
| VariableReference ref = DomFactory.eINSTANCE.createVariableReference(); |
| ref.setVariable(id); |
| realArguments[i]=ref; |
| locals.add(name); |
| localInitializers.add(expression); |
| } |
| } |
| /*if (needsVarargBoxing) { |
| ParameterData parameter= fSourceProvider.getParameterData(varargIndex); |
| String name= fInvocationScope.createName(parameter.getName(), true); |
| realArguments[varargIndex]= name; |
| AST ast= fInvocation.getAST(); |
| Type type= fImportRewrite.addImport(parameter.getTypeBinding(), ast); |
| VariableDeclarationFragment fragment= ast.newVariableDeclarationFragment(); |
| fragment.setName(ast.newSimpleName(name)); |
| ArrayInitializer initializer= ast.newArrayInitializer(); |
| for (int i= varargIndex; i < arguments.size(); i++) { |
| initializer.expressions().add(fRewrite.createCopyTarget((ASTNode)arguments.get(i))); |
| } |
| fragment.setInitializer(initializer); |
| VariableDeclarationStatement decl= ast.newVariableDeclarationStatement(fragment); |
| decl.setType(type); |
| fLocals.add(decl); |
| }*/ |
| return usedNames; |
| } |
| |
| private void computeReceiver() { |
| Expression receiver = RefactoringUtils.getReceiver(invocation); |
| if (receiver == null) { |
| receiverExpr = null; |
| return; |
| } |
| //final boolean isName = receiver instanceof VariableReference; |
| //if (isName) |
| // fContext.receiverIsStatic= ((Name)receiver).resolveBinding() instanceof ITypeBinding; |
| switch(receiver.eClass().getClassifierID()) { |
| case DomPackage.BOOLEAN_LITERAL: |
| case DomPackage.NULL_LITERAL: |
| case DomPackage.NUMERIC_LITERAL: |
| case DomPackage.REGULAR_EXPRESSION_LITERAL: |
| case DomPackage.STRING_LITERAL: |
| case DomPackage.THIS_EXPRESSION: |
| case DomPackage.VARIABLE_REFERENCE: |
| receiverExpr = receiver; |
| return; |
| } |
| if (sourceProvider.getReceiversToBeUpdated() != 1) { |
| while(receiver instanceof ParenthesizedExpression) { |
| Expression expr = ((ParenthesizedExpression)receiver).getEnclosed(); |
| if (expr instanceof BinaryExpression && ((BinaryExpression) expr).getOperation() == BinaryOperator.COMMA) |
| break; |
| receiver = expr; |
| } |
| localInitializers.add(receiver); |
| Identifier id = DomFactory.eINSTANCE.createIdentifier(); |
| String name = getUnusedName("r"); |
| id.setName(name); |
| locals.add(name); |
| VariableReference ref = DomFactory.eINSTANCE.createVariableReference(); |
| ref.setVariable(id); |
| receiverExpr = ref; |
| } else |
| receiverExpr = receiver; |
| return; |
| } |
| /*public String[] getCodeBlocks() { |
| final ASTRewrite rewriter = ASTRewrite.create(fDeclaration.getAST()); |
| replaceParameterWithExpression(rewriter, context.arguments); |
| updateImplicitReceivers(rewriter, context); |
| makeNamesUnique(rewriter, context.scope); |
| updateTypeReferences(rewriter, context); |
| updateStaticReferences(rewriter, context); |
| updateTypeVariables(rewriter, context); |
| updateMethodTypeVariable(rewriter, context); |
| |
| List ranges = null; |
| if (hasReturnValue()) { |
| if (context.callMode == ASTNode.RETURN_STATEMENT) { |
| ranges = getStatementRanges(); |
| } else { |
| ranges = getExpressionRanges(); |
| } |
| } else { |
| ASTNode last = getLastStatement(); |
| if (last != null && last.getNodeType() == ASTNode.RETURN_STATEMENT) { |
| ranges = getReturnStatementRanges(); |
| } else { |
| ranges = getStatementRanges(); |
| } |
| } |
| |
| final TextEdit dummy = rewriter.rewriteAST(fDocument, fTypeRoot |
| .getJavaProject().getOptions(true)); |
| int size = ranges.size(); |
| RangeMarker[] markers = new RangeMarker[size]; |
| for (int i = 0; i < markers.length; i++) { |
| IRegion range = (IRegion) ranges.get(i); |
| markers[i] = new RangeMarker(range.getOffset(), range.getLength()); |
| } |
| int split; |
| if (size <= 1) { |
| split = Integer.MAX_VALUE; |
| } else { |
| IRegion region = (IRegion) ranges.get(0); |
| split = region.getOffset() + region.getLength(); |
| } |
| TextEdit[] edits = dummy.removeChildren(); |
| for (int i = 0; i < edits.length; i++) { |
| TextEdit edit = edits[i]; |
| int pos = edit.getOffset() >= split ? 1 : 0; |
| markers[pos].addChild(edit); |
| } |
| MultiTextEdit root = new MultiTextEdit(0, fDocument.getLength()); |
| root.addChildren(markers); |
| |
| try { |
| TextEditProcessor processor = new TextEditProcessor(fDocument, |
| root, TextEdit.CREATE_UNDO | TextEdit.UPDATE_REGIONS); |
| UndoEdit undo = processor.performEdits(); |
| String[] result = getBlocks(markers); |
| // It is faster to undo the changes than coping the buffer over and |
| // over again. |
| processor = new TextEditProcessor(fDocument, undo, |
| TextEdit.UPDATE_REGIONS); |
| processor.performEdits(); |
| return result; |
| } catch (MalformedTreeException exception) { |
| JavaPlugin.log(exception); |
| } catch (BadLocationException exception) { |
| JavaPlugin.log(exception); |
| } |
| return new String[] {}; |
| }*/ |
| |
| /* |
| * @param status the status |
| * @return <code>true</code> if explicit cast is needed otherwise <code>false</code> |
| * |
| private boolean needsExplicitCast(RefactoringStatus status) { |
| // if the return type of the method is the same as the type of the |
| // returned expression then we don't need an explicit cast. |
| if (fSourceProvider.returnTypeMatchesReturnExpressions()) |
| return false; |
| ASTNode parent= fTargetNode.getParent(); |
| int nodeType= parent.getNodeType(); |
| if (nodeType == ASTNode.METHOD_INVOCATION) { |
| MethodInvocation methodInvocation= (MethodInvocation)parent; |
| if(methodInvocation.getExpression() == fTargetNode) |
| return false; |
| IMethodBinding method= methodInvocation.resolveMethodBinding(); |
| if (method == null) { |
| status.addError(RefactoringCoreMessages.CallInliner_cast_analysis_error, |
| JavaStatusContext.create(fCUnit, methodInvocation)); |
| return false; |
| } |
| ITypeBinding[] parameters= method.getParameterTypes(); |
| int argumentIndex= methodInvocation.arguments().indexOf(fInvocation); |
| List returnExprs= fSourceProvider.getReturnExpressions(); |
| // it is inferred that only methods consisting of a single |
| // return statement can be inlined as parameters in other |
| // method invocations |
| if (returnExprs.size() != 1) |
| return false; |
| parameters[argumentIndex]= ((Expression)returnExprs.get(0)).resolveTypeBinding(); |
| |
| ITypeBinding type= ASTNodes.getReceiverTypeBinding(methodInvocation); |
| TypeBindingVisitor visitor= new AmbiguousMethodAnalyzer( |
| fTypeEnvironment, method, fTypeEnvironment.create(parameters)); |
| if(!visitor.visit(type)) { |
| return true; |
| } |
| else if(type.isInterface()) { |
| return !Bindings.visitInterfaces(type, visitor); |
| } |
| else if(Modifier.isAbstract(type.getModifiers())) { |
| return !Bindings.visitHierarchy(type, visitor); |
| } |
| else { |
| // it is not needed to visit interfaces if receiver is a concrete class |
| return !Bindings.visitSuperclasses(type, visitor); |
| } |
| } |
| return false; |
| }*/ |
| |
| private static boolean needsParentheses(Expression expression, Expression destination) { |
| int inner = OperatorPrecedence.getExpressionPrecedence(expression); |
| int outer; |
| EReference feature = destination.eContainmentFeature(); |
| if (feature == DomPackage.eINSTANCE.getCallExpression_Arguments()) { |
| outer = OperatorPrecedence.SEQUENCE; |
| } else if (feature == DomPackage.eINSTANCE.getArrayLiteral_Elements()) { |
| outer = OperatorPrecedence.SEQUENCE; |
| } else if (feature == DomPackage.eINSTANCE.getParenthesizedExpression_Enclosed()) { |
| outer = OperatorPrecedence.SEQUENCE-1; |
| } else if (destination.eContainer() instanceof Expression) { |
| outer = OperatorPrecedence.getExpressionPrecedence((Expression)destination.eContainer()); |
| } else if (destination.eContainer() instanceof VariableDeclaration) { |
| outer = OperatorPrecedence.SEQUENCE; |
| } else { |
| outer = OperatorPrecedence.SEQUENCE-1; |
| } |
| Node node = destination; |
| while (node != null) { |
| EReference ref = node.eContainmentFeature(); |
| node = (Node)node.eContainer(); |
| |
| if (ref == DomPackage.eINSTANCE.getBinaryExpression_Left() |
| || ref == DomPackage.eINSTANCE.getBinaryExpression_Right() |
| || ref == DomPackage.eINSTANCE.getConditionalExpression_Predicate() |
| || ref == DomPackage.eINSTANCE.getConditionalExpression_Alternative() |
| || ref == DomPackage.eINSTANCE.getVariableDeclaration_Initializer() |
| || ref == DomPackage.eINSTANCE.getVariableStatement_Declarations() |
| || ref == DomPackage.eINSTANCE.getConstStatement_Declarations()) |
| continue; |
| if (ref == DomPackage.eINSTANCE.getForStatement_Initialization() |
| || ref == DomPackage.eINSTANCE.getForInStatement_Item() |
| || ref == DomPackage.eINSTANCE.getForEachInStatement_Item()) { |
| if (!isNodeNoIn(expression)) |
| return true; |
| } |
| break; |
| } |
| if (inner != outer) |
| return inner < outer; |
| if (feature == DomPackage.eINSTANCE.getBinaryExpression_Right()) { |
| return !RefactoringUtils.isAssignment(((BinaryExpression)destination.eContainer()).getOperation()); |
| } |
| return false; |
| } |
| |
| private static boolean isNodeNoIn(Node node) { |
| switch(node.eClass().getClassifierID()) { |
| case DomPackage.BINARY_EXPRESSION: |
| BinaryExpression be = (BinaryExpression)node; |
| return be.getOperation() != BinaryOperator.IN && isNodeNoIn(be.getLeft()) |
| && isNodeNoIn(be.getRight()); |
| case DomPackage.CONDITIONAL_EXPRESSION: |
| ConditionalExpression ce = (ConditionalExpression)node; |
| return isNodeNoIn(ce.getPredicate()) && isNodeNoIn(ce.getAlternative()); |
| default: |
| return true; |
| } |
| } |
| |
| /*private boolean needsParentheses(Statement last) { |
| if (!(last instanceof ReturnStatement)) |
| return false; |
| if (!needsParentheses(((ReturnStatement)last).getExpression())) |
| return false; |
| Node parent= (Node)targetNode.eContainer(); |
| int type= parent.eClass().getClassifierID(); |
| boolean isAssignment = type == DomPackage.BINARY_EXPRESSION && RefactoringUtils.isAssignment(((BinaryExpression)parent).getOperation()); |
| return |
| type == DomPackage.CALL_EXPRESSION || |
| (parent instanceof Expression && !isAssignment) || |
| (returnsConditionalExpression(last) && |
| type == DomPackage.VARIABLE_DECLARATION && |
| ((VariableDeclaration)parent).getInitializer() == targetNode); |
| } |
| private boolean returnsConditionalExpression(Statement last) { |
| if (last instanceof ReturnStatement) { |
| return ((ReturnStatement) last).getExpression() instanceof ConditionalExpression; |
| } |
| return false; |
| }*/ |
| |
| /*private VariableDeclarationStatement createLocalDeclaration(ITypeBinding type, String name, Expression initializer) { |
| ImportRewriteContext context= new ContextSensitiveImportRewriteContext(fTargetNode, fImportRewrite); |
| String typeName= fImportRewrite.addImport(type, context); |
| VariableDeclarationStatement decl= (VariableDeclarationStatement)ASTNodeFactory.newStatement( |
| fInvocation.getAST(), typeName + " " + name + ";"); //$NON-NLS-1$ //$NON-NLS-2$ |
| ((VariableDeclarationFragment)decl.fragments().get(0)).setInitializer(initializer); |
| return decl; |
| }*/ |
| |
| /** |
| * Checks whether arguments are passed to the method which do some assignments |
| * inside the expression. If so these arguments can't be inlined into the |
| * calling method since the assignments might be reorder. An example is: |
| * <code> |
| * add((field=args).length,field.hashCode()); |
| * </code> |
| * Field might not be initialized when the arguments are reorder in the called |
| * method. |
| * @param arguments the arguments |
| * @return all arguments that cannot be inlined |
| */ |
| private Set<Expression> crossCheckArguments(List<Expression> arguments) { |
| //final Set<Expression> assigned= new HashSet<Expression>(); |
| final Set<Expression> result= new HashSet<Expression>(); |
| for (Expression arg : arguments) { |
| TreeIterator<EObject> it = arg.eAllContents(); |
| while (it.hasNext()) { |
| Node node = (Node)it.next(); |
| if (node.eClass().getClassifierID() == DomPackage.BINARY_EXPRESSION) { |
| BinaryExpression expr = (BinaryExpression)node; |
| if (RefactoringUtils.isAssignment(expr.getOperation())) |
| result.add(expr); |
| } |
| if (node.eClass().getClassifierID() == DomPackage.UNARY_EXPRESSION) { |
| UnaryExpression expr = (UnaryExpression)node; |
| if (RefactoringUtils.hasSideEffect(expr.getOperation())) |
| result.add(expr); |
| } |
| } |
| } |
| /*for(Expression expression : arguments) { |
| if (!result.contains(expression)) { |
| expression.accept(new HierarchicalASTVisitor() { |
| public boolean visit(Name node) { |
| IBinding binding= node.resolveBinding(); |
| if (binding != null && assigned.contains(binding)) |
| result.add(expression); |
| return false; |
| } |
| }); |
| } |
| }*/ |
| return result; |
| } |
| |
| private boolean canInline(Expression actualParameter, ParameterData formalParameter) { |
| InlineEvaluator evaluator= new InlineEvaluator(formalParameter); |
| evaluator.traverse(actualParameter); |
| //actualParameter.accept(evaluator); |
| return evaluator.getResult(); |
| } |
| |
| public RefactoringStatus perform() { |
| Node parentStatement=invocation; |
| while (!(parentStatement.eContainmentFeature().getEReferenceType().getClassifierID() == DomPackage.STATEMENT)) |
| parentStatement = (Node)parentStatement.eContainer(); |
| Node container = (Node)parentStatement.eContainer(); |
| EReference ref = parentStatement.eContainmentFeature(); |
| int nos = sourceProvider.getDeclaration().getBody().getStatements().size() + locals.size(); |
| if (!ref.isMany() && (nos > 1 || needsBlockAroundDanglingIf())) { |
| BlockStatement block = DomFactory.eINSTANCE.createBlockStatement(); |
| block.getStatements().add((Statement)parentStatement); |
| container.eSet(ref, block); |
| container = block; |
| ref = DomPackage.eINSTANCE.getBlockStatement_Statements(); |
| } |
| List<Statement> list = null; |
| int idx = -1; |
| if (ref.isMany()) { |
| list = (List<Statement>)container.eGet(ref); |
| idx = list.lastIndexOf(parentStatement); |
| } |
| if (!locals.isEmpty()) { |
| int i=0; |
| for(String str : locals) { |
| Expression init = localInitializers.get(i++); |
| Identifier id = DomFactory.eINSTANCE.createIdentifier(); |
| id.setName(str); |
| VariableDeclaration decl = DomFactory.eINSTANCE.createVariableDeclaration(); |
| decl.setIdentifier(id); |
| //TODO find out if we need to create a copy |
| decl.setInitializer(init); |
| VariableStatement stmt = DomFactory.eINSTANCE.createVariableStatement(); |
| stmt.getDeclarations().add(decl); |
| list.add(idx++, stmt); |
| } |
| } |
| //String block=sourceProvider.getCode(); |
| FunctionExpression declCopy = (FunctionExpression)EcoreUtil.copy(sourceProvider.getDeclaration()); |
| if (!cu.equals(sourceProvider.getSourceModule())) { |
| // TODO handle this without killing old formatting |
| TreeIterator<EObject> it = declCopy.eAllContents(); |
| while(it.hasNext()) { |
| Node node = (Node)it.next(); |
| node.setBegin(-1); |
| node.setEnd(-1); |
| } |
| } |
| final Map<Identifier, VariableBinding> bindings = VariableLookup.findBindings(declCopy); |
| final Map<VariableBinding, Expression> replacements = new HashMap<VariableBinding, Expression>(); |
| for(int i=0;i<realArguments.length;i++) { |
| VariableBinding binding = bindings.get(declCopy.getParameters().get(i).getName()); |
| replacements.put(binding, realArguments[i]); |
| } |
| List<Statement> stmts = new ArrayList<Statement>(); |
| stmts.addAll(declCopy.getBody().getStatements()); |
| List<Identifier> references = VariableLookup.findReferences(declCopy.getBody(), usedNames); |
| for(Identifier id : references) { |
| VariableBinding binding = bindings.get(id); |
| if (binding != null && !replacements.containsKey(binding)) { |
| Identifier var = DomFactory.eINSTANCE.createIdentifier(); |
| var.setName(getUnusedName(id.getName())); |
| VariableReference expr = DomFactory.eINSTANCE.createVariableReference(); |
| expr.setVariable(var); |
| replacements.put(binding,expr); |
| } |
| } |
| Node node = null; |
| if (stmts.isEmpty() && targetNode != null) { |
| if (ref.isMany()) { |
| list.remove(idx); |
| } else { |
| container.eSet(ref, DomFactory.eINSTANCE.createEmptyStatement()); |
| } |
| } else { |
| for(int i= 0; i < stmts.size()-1; i++) { |
| list.add(idx++,stmts.get(i)); |
| } |
| node = stmts.get(stmts.size()-1); |
| if (node.eClass().getClassifierID() == DomPackage.RETURN_STATEMENT) { |
| node = ((ReturnStatement)node).getExpression(); |
| if (targetNode instanceof Expression) { |
| if (needsParentheses((Expression)node,(Expression)targetNode)) { |
| ParenthesizedExpression pExp = DomFactory.eINSTANCE.createParenthesizedExpression(); |
| pExp.setEnclosed((Expression)node); |
| node= pExp; |
| } |
| Node cont = (Node)targetNode.eContainer(); |
| EReference target = targetNode.eContainmentFeature(); |
| if (target.isMany()) { |
| List<Expression> targets = (List<Expression>)cont.eGet(target); |
| targets.set(targets.lastIndexOf(targetNode),(Expression)node); |
| } else |
| cont.eSet(target, node); |
| } else if (targetNode.eClass().getClassifierID() == DomPackage.EXPRESSION_STATEMENT) { |
| if (sourceProvider.mustEvaluateReturnedExpression()) { |
| ExpressionStatement stmt = DomFactory.eINSTANCE.createExpressionStatement(); |
| stmt.setExpression((Expression)node); |
| list.set(idx,stmt); |
| } else |
| list.remove(idx); |
| } else { |
| list.set(idx,stmts.get(stmts.size()-1)); |
| } |
| } else { |
| list.set(idx,stmts.get(stmts.size()-1)); |
| } |
| } |
| |
| new ReceiverAnalyzer(replacements, bindings).traverse(stmts,node); |
| return new RefactoringStatus(); |
| } |
| |
| /*private void initializeInsertionPoint(int nos) { |
| switch(container.eClass().getClassifierID()) { |
| case DomPackage.BLOCK_STATEMENT: |
| Block block= (Block)container; |
| fListRewrite= fRewrite.getListRewrite(block, Block.STATEMENTS_PROPERTY); |
| fInsertionIndex= fListRewrite.getRewrittenList().indexOf(parentStatement); |
| break; |
| case DomPackage.SWITCH_STATEMENT: |
| SwitchStatement switchStatement= (SwitchStatement)container; |
| fListRewrite= fRewrite.getListRewrite(switchStatement, SwitchStatement.STATEMENTS_PROPERTY); |
| fInsertionIndex= fListRewrite.getRewrittenList().indexOf(parentStatement); |
| break; |
| default: // isControlStatement(container) || type == ASTNode.LABELED_STATEMENT |
| fNeedsStatement= true; |
| if (nos > 1 || needsBlockAroundDanglingIf()) { |
| Block block= fInvocation.getAST().newBlock(); |
| fInsertionIndex= 0; |
| Statement currentStatement= null; |
| switch(type) { |
| case ASTNode.LABELED_STATEMENT: |
| currentStatement= ((LabeledStatement)container).getBody(); |
| break; |
| case ASTNode.FOR_STATEMENT: |
| currentStatement= ((ForStatement)container).getBody(); |
| break; |
| case ASTNode.ENHANCED_FOR_STATEMENT: |
| currentStatement= ((EnhancedForStatement)container).getBody(); |
| break; |
| case ASTNode.WHILE_STATEMENT: |
| currentStatement= ((WhileStatement)container).getBody(); |
| break; |
| case ASTNode.DO_STATEMENT: |
| currentStatement= ((DoStatement)container).getBody(); |
| break; |
| case ASTNode.IF_STATEMENT: |
| IfStatement node= (IfStatement)container; |
| Statement thenPart= node.getThenStatement(); |
| if (fTargetNode == thenPart || ASTNodes.isParent(fTargetNode, thenPart)) { |
| currentStatement= thenPart; |
| } else { |
| currentStatement= node.getElseStatement(); |
| } |
| break; |
| } |
| Assert.isNotNull(currentStatement); |
| fRewrite.replace(currentStatement, block, null); |
| fListRewrite= fRewrite.getListRewrite(block, Block.STATEMENTS_PROPERTY); |
| // The method to be inlined is not the body of the control statement. |
| if (currentStatement != fTargetNode) { |
| fListRewrite.insertLast(fRewrite.createCopyTarget(currentStatement), null); |
| } else { |
| // We can't replace a copy with something else. So we |
| // have to insert all statements to be inlined. |
| fTargetNode= null; |
| } |
| } |
| } |
| // We only insert one new statement or we delete the existing call. |
| // So there is no need to have an insertion index. |
| }*/ |
| |
| private boolean needsBlockAroundDanglingIf() { |
| /* see https://bugs.eclipse.org/bugs/show_bug.cgi?id=169331 |
| * |
| * Situation: |
| * boolean a, b; |
| * function toInline() { |
| * if (a) |
| * hashCode() |
| * } |
| * function m() { |
| * if (b) |
| * toInline() |
| * else |
| * toString() |
| * } |
| * => needs block around inlined "if (a)..." to avoid attaching else to wrong if. |
| */ |
| return targetNode.eContainmentFeature() == DomPackage.eINSTANCE.getIfStatement_Consequent() |
| && ((IfStatement)targetNode.eContainer()).getAlternative() == null |
| && sourceProvider.isDanglingIf(); |
| } |
| |
| /*private String getContent(Node node) throws ModelException { |
| return cu.getBuffer().getText(node.getBegin(), node.getEnd()); |
| }*/ |
| |
| /*private boolean isControlStatement(ASTNode node) { |
| int type= node.getNodeType(); |
| return type == ASTNode.IF_STATEMENT || type == ASTNode.FOR_STATEMENT || type == ASTNode.ENHANCED_FOR_STATEMENT || |
| type == ASTNode.WHILE_STATEMENT || type == ASTNode.DO_STATEMENT; |
| }*/ |
| } |
