mirrors/cdt
1
0
Fork 0
mirror of https://github.com/eclipse-cdt/cdt synced 2025-08-13 19:25:38 +02:00
Code Issues Wiki Activity

Fixed a bug in Extract Function refactoring.

Browse source
This commit is contained in:
sprigogin 2012-03-25 21:31:00 -07:00
parent a13c09f28d
commit c73b8c8a4a
6 changed files with 69 additions and 60 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/EqualityChecker.java
View file

@ -7,10 +7,10 @@
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Institute for Software - initial API and implementation
* Institute for Software - initial API and implementation
*******************************************************************************/
package org.eclipse.cdt.internal.ui.refactoring;
public interface EqualityChecker<T> {
boolean isEquals(T object1, T object2);
boolean isEqual(T object1, T object2);
}

2
core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/extractfunction/ExtractFunctionInputPage.java
View file

@ -62,7 +62,7 @@ public class ExtractFunctionInputPage extends UserInputWizardPage {
private Text textField;
private boolean firstTime;
private CSourceViewer signaturePreview;
private Document signaturePreviewDocument;
private final Document signaturePreviewDocument;
private IDialogSettings settings;
private static final String DESCRIPTION = Messages.ExtractFunctionInputPage_description;

4
core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/extractfunction/ExtractFunctionRefactoring.java
View file

@ -518,7 +518,7 @@ public class ExtractFunctionRefactoring extends CRefactoring {
IASTNode trailNode = trail.get(pos);
trailPos.setObject(Integer.valueOf(pos + 1));
if (equalityChecker.isEquals(trailNode, node)) {
if (equalityChecker.isEqual(trailNode, node)) {
if (node instanceof ICPPASTQualifiedName || node instanceof IASTNamedTypeSpecifier) {
return PROCESS_SKIP;
} else {
@ -563,7 +563,7 @@ public class ExtractFunctionRefactoring extends CRefactoring {
IASTParameterDeclaration newParameter = declarator.getParameters()[i];
// If not the same break;
if (!(equalityChecker.isEquals(origParameter.getDeclSpecifier(),
if (!(equalityChecker.isEqual(origParameter.getDeclSpecifier(),
newParameter.getDeclSpecifier()) &&
ASTHelper.samePointers(origParameter.getDeclarator().getPointerOperators(),
newParameter.getDeclarator().getPointerOperators(),

8
core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/extractfunction/Messages.properties
View file

@ -22,7 +22,7 @@ ExtractFunctionRefactoring_CreateFunctionDef=Create Function Definition
ExtractFunctionRefactoring_CreateMethodCall=Create Method Call
ExtractFunctionRefactoring_CreateFunctionCall=Create Function Call
ExtractFunctionRefactoring_Error_Return=Extracting return statements is not supported
ExtractFunctionRefactoring_Error_Continue=Extracting cotinue statements without the surrounding loop is not possible. Please adjust your selection.
ExtractFunctionRefactoring_Error_Continue=Extracting continue statements without the surrounding loop is not possible. Please adjust your selection.
ExtractFunctionRefactoring_Error_Break=Extracting break statements without the surrounding loop is not possible. Please adjust your selection.
ExtractFunctionInputPage_description=Enter new method name and specify the method's visibility
ExtractFunctionInputPage_access_modifier=&Access modifier:
@ -34,7 +34,7 @@ ExtractFunctionInputPage_label_text=Function &name:
ExtractFunctionInputPage_parameters=&Parameters:
ExtractFunctionInputPage_validation_empty_function_name=Provide a method name
ExtractFunctionInputPage_validation_empty_parameter_name=Parameter names cannot be empty
ExtractFunctionInputPage_duplicates_none=&Replace additional occurrences of statements with method
ExtractFunctionInputPage_duplicates_single=&Replace 1 additional occurrence of statements with method
ExtractFunctionInputPage_duplicates_multi=&Replace {0} additional occurrences of statements with method
ExtractFunctionInputPage_duplicates_none=&Replace additional occurrences of statements with a function call
ExtractFunctionInputPage_duplicates_single=&Replace 1 additional occurrence of statements with a function call
ExtractFunctionInputPage_duplicates_multi=&Replace {0} additional occurrences of statements with a function call
SimilarFinderVisitor_replaceDuplicateCode=Replace Duplicated Code

71
core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/extractfunction/TrailNodeEqualityChecker.java
View file

@ -8,6 +8,7 @@
*
* Contributors:
* Institute for Software - initial API and implementation
* Sergey Prigogin (Google)
*******************************************************************************/
package org.eclipse.cdt.internal.ui.refactoring.extractfunction;
@ -56,6 +57,7 @@ import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTNewExpression;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTOperatorName;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTSimpleTypeConstructorExpression;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTTemplateDeclaration;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTTypeId;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTUsingDeclaration;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTVisibilityLabel;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPVariable;
@ -80,36 +82,39 @@ public class TrailNodeEqualityChecker implements EqualityChecker<IASTNode> {
}
@Override
public boolean isEquals(IASTNode trailNode, IASTNode node) {
public boolean isEqual(IASTNode trailNode, IASTNode node) {
if ((trailNode instanceof TrailName && node instanceof IASTName)
|| Arrays.equals(getInterfaces(node), getInterfaces(trailNode))) {
// Is same type
if (node instanceof IASTExpression) {
return isExpressionEquals(trailNode, node);
return isExpressionEqual(trailNode, node);
} else if (node instanceof IASTStatement) {
return isStatementEquals(trailNode, node);
return isStatementEqual(trailNode, node);
} else if (node instanceof IASTPointerOperator) {
return isPointerOperatorEquals(trailNode, node);
return isPointerOperatorEqual(trailNode, node);
} else if (node instanceof IASTDeclaration) {
return isDeclarationEquals(trailNode, node);
return isDeclarationEqual(trailNode, node);
} else if (node instanceof IASTDeclarator) {
return isDeclaratorEquals(trailNode, node);
return isDeclaratorEqual(trailNode, node);
} else if (node instanceof IASTInitializer) {
// No speciality, is the same type return true
// No special case, the same type means equality
return true;
} else if (node instanceof IASTDeclSpecifier) {
return isDeclSpecifierEquals(trailNode, node);
return isDeclSpecifierEqual(trailNode, node);
} else if (node instanceof ICPPASTTypeId) {
return idTypeIdEqual((ICPPASTTypeId) trailNode, (ICPPASTTypeId) node);
} else if (node instanceof IASTName) {
return isNameEquals(trailNode, node);
return isNameEqual(trailNode, node);
} else {
Assert.isLegal(false, "Unexpected Node, this code shoud nod reached"); //$NON-NLS-1$
Assert.isLegal(false, "Unexpected node type " + node.getClass().getSimpleName() + //$NON-NLS-1$
", this code shoud not be reached"); //$NON-NLS-1$
return true;
}
}
return false;
}
private boolean isNameEquals(IASTNode trailNode, IASTNode node) {
private boolean isNameEqual(IASTNode trailNode, IASTNode node) {
if (trailNode instanceof ICPPASTConversionName) {
return true;
} else if (trailNode instanceof ICPPASTOperatorName) {
@ -119,21 +124,21 @@ public class TrailNodeEqualityChecker implements EqualityChecker<IASTNode> {
} else if (trailNode instanceof TrailName && node instanceof IASTName) {
TrailName trailName = (TrailName) trailNode;
IASTName name = (IASTName)node;
return isNameEquals(trailName, name);
return isNameEqual(trailName, name);
} else {
return true;
}
}
private boolean isDeclSpecifierEquals(IASTNode trailNode, IASTNode node) {
private boolean isDeclSpecifierEqual(IASTNode trailNode, IASTNode node) {
if (trailNode instanceof IASTSimpleDeclSpecifier) {
IASTSimpleDeclSpecifier trailDecl = (IASTSimpleDeclSpecifier) trailNode;
IASTSimpleDeclSpecifier decl = (IASTSimpleDeclSpecifier) node;
return isSimpleDeclSpecifierEquals(trailDecl, decl);
return isSimpleDeclSpecifierEqual(trailDecl, decl);
} else if (trailNode instanceof ICPPASTNamedTypeSpecifier) {
ICPPASTNamedTypeSpecifier trailDecl = (ICPPASTNamedTypeSpecifier) trailNode;
ICPPASTNamedTypeSpecifier decl = (ICPPASTNamedTypeSpecifier) node;
return isDeclSpecifierEquals(trailDecl, decl)
return isDeclSpecifierEqual(trailDecl, decl)
&& isSameNamedTypeSpecifierName(trailDecl, decl)
&& trailDecl.isTypename() == decl.isTypename()
&& trailDecl.isExplicit() == decl.isExplicit()
@ -142,41 +147,41 @@ public class TrailNodeEqualityChecker implements EqualityChecker<IASTNode> {
} else if (trailNode instanceof IASTNamedTypeSpecifier) {
IASTNamedTypeSpecifier trailDecl = (IASTNamedTypeSpecifier) trailNode;
IASTNamedTypeSpecifier decl = (IASTNamedTypeSpecifier) node;
return isDeclSpecifierEquals(trailDecl, decl)
return isDeclSpecifierEqual(trailDecl, decl)
&& isSameNamedTypeSpecifierName(trailDecl, decl);
} else if (trailNode instanceof IASTElaboratedTypeSpecifier) {
IASTElaboratedTypeSpecifier trailDecl = (IASTElaboratedTypeSpecifier) trailNode;
IASTElaboratedTypeSpecifier decl = (IASTElaboratedTypeSpecifier) node;
return isDeclSpecifierEquals(trailDecl, decl)
return isDeclSpecifierEqual(trailDecl, decl)
&& trailDecl.getKind() == decl.getKind();
} else if (trailNode instanceof IASTCompositeTypeSpecifier) {
IASTCompositeTypeSpecifier trailDecl = (IASTCompositeTypeSpecifier) trailNode;
IASTCompositeTypeSpecifier decl = (IASTCompositeTypeSpecifier) node;
return isDeclSpecifierEquals(trailDecl, decl)
return isDeclSpecifierEqual(trailDecl, decl)
&& trailDecl.getKey() == decl.getKey();
} else if (trailNode instanceof ICPPASTDeclSpecifier) {
ICPPASTDeclSpecifier trailDecl = (ICPPASTDeclSpecifier) trailNode;
ICPPASTDeclSpecifier decl = (ICPPASTDeclSpecifier) node;
return isDeclSpecifierEquals(trailDecl, decl)
return isDeclSpecifierEqual(trailDecl, decl)
&& trailDecl.isExplicit() == decl.isExplicit()
&& trailDecl.isFriend() == decl.isFriend()
&& trailDecl.isVirtual() == decl.isVirtual();
} else if (trailNode instanceof ICASTDeclSpecifier) {
ICASTDeclSpecifier trailDecl = (ICASTDeclSpecifier) trailNode;
ICASTDeclSpecifier decl = (ICASTDeclSpecifier) node;
return isDeclSpecifierEquals(trailDecl, decl)
return isDeclSpecifierEqual(trailDecl, decl)
&& trailDecl.isRestrict() == decl.isRestrict();
} else if (trailNode instanceof IASTDeclSpecifier) {
IASTDeclSpecifier trailDecl = (IASTDeclSpecifier) trailNode;
IASTDeclSpecifier decl = (IASTDeclSpecifier) node;
return isDeclSpecifierEquals(trailDecl, decl);
return isDeclSpecifierEqual(trailDecl, decl);
} else {
//is same
return true;
}
}
private boolean isDeclaratorEquals(IASTNode trailNode, IASTNode node) {
private boolean isDeclaratorEqual(IASTNode trailNode, IASTNode node) {
if (trailNode instanceof IASTStandardFunctionDeclarator) {
IASTStandardFunctionDeclarator trailFunc = (IASTStandardFunctionDeclarator) trailNode;
IASTStandardFunctionDeclarator func = (IASTStandardFunctionDeclarator) node;
@ -193,7 +198,7 @@ public class TrailNodeEqualityChecker implements EqualityChecker<IASTNode> {
}
}
private boolean isDeclarationEquals(IASTNode trailNode, IASTNode node) {
private boolean isDeclarationEqual(IASTNode trailNode, IASTNode node) {
if (trailNode instanceof IASTASMDeclaration) {
IASTASMDeclaration trailASMDecl = (IASTASMDeclaration) trailNode;
IASTASMDeclaration asmDecl = (IASTASMDeclaration) node;
@ -224,7 +229,7 @@ public class TrailNodeEqualityChecker implements EqualityChecker<IASTNode> {
}
}
private boolean isPointerOperatorEquals(IASTNode trailNode, IASTNode node) {
private boolean isPointerOperatorEqual(IASTNode trailNode, IASTNode node) {
if (trailNode instanceof IASTPointer) {
IASTPointer trailGPointer = (IASTPointer) trailNode;
IASTPointer gPointer = (IASTPointer) node;
@ -237,7 +242,7 @@ public class TrailNodeEqualityChecker implements EqualityChecker<IASTNode> {
}
}
private boolean isStatementEquals(IASTNode trailNode, IASTNode node) {
private boolean isStatementEqual(IASTNode trailNode, IASTNode node) {
if (trailNode instanceof ICPPASTCatchHandler) {
ICPPASTCatchHandler trailCatch = (ICPPASTCatchHandler) trailNode;
ICPPASTCatchHandler nodeCatch = (ICPPASTCatchHandler) node;
@ -247,7 +252,11 @@ public class TrailNodeEqualityChecker implements EqualityChecker<IASTNode> {
return true;
}
private boolean isExpressionEquals(IASTNode trailNode, IASTNode node) {
private boolean idTypeIdEqual(ICPPASTTypeId trailNode, ICPPASTTypeId node) {
return trailNode.isPackExpansion() == node.isPackExpansion();
}
private boolean isExpressionEqual(IASTNode trailNode, IASTNode node) {
if (trailNode instanceof IASTBinaryExpression) {
IASTBinaryExpression trailExpr = (IASTBinaryExpression) trailNode;
IASTBinaryExpression expr = (IASTBinaryExpression) node;
@ -284,7 +293,7 @@ public class TrailNodeEqualityChecker implements EqualityChecker<IASTNode> {
} else if (trailNode instanceof ICPPASTSimpleTypeConstructorExpression) {
ICPPASTSimpleTypeConstructorExpression trailConsExpr = (ICPPASTSimpleTypeConstructorExpression) trailNode;
ICPPASTSimpleTypeConstructorExpression consExpr = (ICPPASTSimpleTypeConstructorExpression) node;
return isDeclSpecifierEquals(trailConsExpr.getDeclSpecifier(), consExpr.getDeclSpecifier());
return isDeclSpecifierEqual(trailConsExpr.getDeclSpecifier(), consExpr.getDeclSpecifier());
} else {
// same type
return true;
@ -302,7 +311,7 @@ public class TrailNodeEqualityChecker implements EqualityChecker<IASTNode> {
return interfaceList.toArray(returnArray);
}
private boolean isDeclSpecifierEquals(IASTDeclSpecifier trailDeclSpeci, IASTDeclSpecifier declSpeci) {
private boolean isDeclSpecifierEqual(IASTDeclSpecifier trailDeclSpeci, IASTDeclSpecifier declSpeci) {
if (trailDeclSpeci instanceof ICPPASTDeclSpecifier) {
ICPPASTDeclSpecifier trailCppDecl= (ICPPASTDeclSpecifier) trailDeclSpeci;
ICPPASTDeclSpecifier cppDecl= (ICPPASTDeclSpecifier) declSpeci;
@ -319,8 +328,8 @@ public class TrailNodeEqualityChecker implements EqualityChecker<IASTNode> {
&& trailDeclSpeci.getStorageClass() == declSpeci.getStorageClass();
}
private boolean isSimpleDeclSpecifierEquals(IASTSimpleDeclSpecifier trailDeclSpeci, IASTSimpleDeclSpecifier declSpeci) {
return isDeclSpecifierEquals(trailDeclSpeci, declSpeci)
private boolean isSimpleDeclSpecifierEqual(IASTSimpleDeclSpecifier trailDeclSpeci, IASTSimpleDeclSpecifier declSpeci) {
return isDeclSpecifierEqual(trailDeclSpeci, declSpeci)
&& trailDeclSpeci.isLong() == declSpeci.isLong()
&& trailDeclSpeci.isShort() == declSpeci.isShort()
&& trailDeclSpeci.isSigned() == declSpeci.isSigned()
@ -331,7 +340,7 @@ public class TrailNodeEqualityChecker implements EqualityChecker<IASTNode> {
&& trailDeclSpeci.isLongLong() == declSpeci.isLongLong();
}
private boolean isNameEquals(TrailName trailName, IASTName name) {
private boolean isNameEqual(TrailName trailName, IASTName name) {
int actCount = namesCounter.getObject().intValue();
if (names.containsKey(name.getRawSignature())) {
Integer nameId = names.get(name.getRawSignature());

2
core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/utils/ASTHelper.java
View file

@ -84,7 +84,7 @@ public class ASTHelper {
for (int i = 0; i < pointerOperators2.length; i++) {
IASTPointerOperator operator1 = pointerOperators1[i];
IASTPointerOperator operator2 = pointerOperators2[i];
if (!checker.isEquals(operator1, operator2)) {
if (!checker.isEqual(operator1, operator2)) {
return false;
}
}