mirrors/cdt
1
0
Fork 0
mirror of https://github.com/eclipse-cdt/cdt synced 2025-04-29 19:45:01 +02:00
Code Issues Wiki Activity

Cosmetics.

Browse source
This commit is contained in:
Sergey Prigogin 2011-08-20 22:05:26 -07:00
parent 41ee60794f
commit 0a9a6d9c7b
2 changed files with 94 additions and 106 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

44
core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/extractfunction/ExtractExpression.java
View file

@ -7,7 +7,7 @@
* http://www.eclipse.org/legal/epl-v10.html * http://www.eclipse.org/legal/epl-v10.html
* *
* Contributors: * Contributors:
* Institute for Software - initial API and implementation * Institute for Software - initial API and implementation
*******************************************************************************/ *******************************************************************************/
package org.eclipse.cdt.internal.ui.refactoring.extractfunction; package org.eclipse.cdt.internal.ui.refactoring.extractfunction;
@ -56,59 +56,54 @@ import org.eclipse.cdt.internal.ui.refactoring.NodeContainer.NameInformation;
* Handles the extraction of expression nodes, like return type determination. * Handles the extraction of expression nodes, like return type determination.
* *
* @author Mirko Stocker * @author Mirko Stocker
*
*/ */
public class ExtractExpression extends ExtractedFunctionConstructionHelper { public class ExtractExpression extends ExtractedFunctionConstructionHelper {
final static char[] ZERO= { '0' };
final static char[] ZERO= {'0'};
@Override @Override
public void constructMethodBody(IASTCompoundStatement compound, public void constructMethodBody(IASTCompoundStatement compound, List<IASTNode> list,
List<IASTNode> list, ASTRewrite rewrite, TextEditGroup group) { ASTRewrite rewrite, TextEditGroup group) {
CPPASTReturnStatement statement = new CPPASTReturnStatement(); CPPASTReturnStatement statement = new CPPASTReturnStatement();
IASTExpression nullReturnExp = new CPPASTLiteralExpression(IASTLiteralExpression.lk_integer_constant, ZERO); IASTExpression nullReturnExp = new CPPASTLiteralExpression(IASTLiteralExpression.lk_integer_constant, ZERO);
statement.setReturnValue(nullReturnExp); statement.setReturnValue(nullReturnExp);
ASTRewrite nestedRewrite = rewrite.insertBefore(compound, null, statement, group); ASTRewrite nestedRewrite = rewrite.insertBefore(compound, null, statement, group);
nestedRewrite.replace(nullReturnExp, getExpression(list), group); nestedRewrite.replace(nullReturnExp, getExpression(list), group);
} }
private IASTExpression getExpression(List<IASTNode> list) { private IASTExpression getExpression(List<IASTNode> list) {
if(list.size()> 1 ) { if (list.size()> 1) {
CPPASTBinaryExpression bExp = new CPPASTBinaryExpression(); CPPASTBinaryExpression bExp = new CPPASTBinaryExpression();
bExp.setParent(list.get(0).getParent()); bExp.setParent(list.get(0).getParent());
bExp.setOperand1((IASTExpression) list.get(0).copy(CopyStyle.withLocations)); bExp.setOperand1((IASTExpression) list.get(0).copy(CopyStyle.withLocations));
bExp.setOperator(((IASTBinaryExpression)list.get(1).getParent()).getOperator()); bExp.setOperator(((IASTBinaryExpression)list.get(1).getParent()).getOperator());
bExp.setOperand2(getExpression(list.subList(1, list.size()))); bExp.setOperand2(getExpression(list.subList(1, list.size())));
return bExp; return bExp;
}else { } else {
return (IASTExpression) list.get(0).copy(CopyStyle.withLocations); return (IASTExpression) list.get(0).copy(CopyStyle.withLocations);
} }
} }
@Override @Override
public IASTDeclSpecifier determineReturnType(IASTNode extractedNode, NameInformation _) { public IASTDeclSpecifier determineReturnType(IASTNode extractedNode, NameInformation _) {
List<ITypedef> typdefs = getTypdefs(extractedNode); List<ITypedef> typedefs = getTypedefs(extractedNode);
if (extractedNode instanceof IASTExpression) { if (extractedNode instanceof IASTExpression) {
IASTExpression exp = (IASTExpression) extractedNode; IASTExpression exp = (IASTExpression) extractedNode;
INodeFactory factory = extractedNode.getTranslationUnit().getASTNodeFactory(); INodeFactory factory = extractedNode.getTranslationUnit().getASTNodeFactory();
DeclarationGenerator generator = DeclarationGenerator.create(factory); DeclarationGenerator generator = DeclarationGenerator.create(factory);
IType expressionType = exp.getExpressionType(); IType expressionType = exp.getExpressionType();
for (ITypedef typedef : typdefs) { for (ITypedef typedef : typedefs) {
if (typedef.getType().isSameType(expressionType)) { if (typedef.getType().isSameType(expressionType)) {
return generator.createDeclSpecFromType(typedef); return generator.createDeclSpecFromType(typedef);
} }
} }
return generator.createDeclSpecFromType(expressionType); return generator.createDeclSpecFromType(expressionType);
} else {// Fallback } else { // Fallback
return createSimpleDeclSpecifier(Kind.eVoid); return createSimpleDeclSpecifier(Kind.eVoid);
} }
} }
private List<ITypedef> getTypdefs(IASTNode extractedNode) { private List<ITypedef> getTypedefs(IASTNode extractedNode) {
final ArrayList<ITypedef> typeDefs = new ArrayList<ITypedef>(); final ArrayList<ITypedef> typeDefs = new ArrayList<ITypedef>();
extractedNode.accept(new ASTVisitor() { extractedNode.accept(new ASTVisitor() {
{ {
@ -148,10 +143,10 @@ public class ExtractExpression extends ExtractedFunctionConstructionHelper {
IASTExpression functionNameExpression = callExpression.getFunctionNameExpression(); IASTExpression functionNameExpression = callExpression.getFunctionNameExpression();
IASTName functionName = null; IASTName functionName = null;
if(functionNameExpression instanceof CPPASTIdExpression) { if (functionNameExpression instanceof CPPASTIdExpression) {
CPPASTIdExpression idExpression = (CPPASTIdExpression) functionNameExpression; CPPASTIdExpression idExpression = (CPPASTIdExpression) functionNameExpression;
functionName = idExpression.getName(); functionName = idExpression.getName();
} else if(functionNameExpression instanceof CPPASTFieldReference) { } else if (functionNameExpression instanceof CPPASTFieldReference) {
CPPASTFieldReference fieldReference = (CPPASTFieldReference) functionNameExpression; CPPASTFieldReference fieldReference = (CPPASTFieldReference) functionNameExpression;
functionName = fieldReference.getFieldName(); functionName = fieldReference.getFieldName();
} }
@ -160,28 +155,29 @@ public class ExtractExpression extends ExtractedFunctionConstructionHelper {
@Override @Override
protected boolean isReturnTypeAPointer(IASTNode node) { protected boolean isReturnTypeAPointer(IASTNode node) {
if(node instanceof ICPPASTNewExpression) { if (node instanceof ICPPASTNewExpression) {
return true; return true;
} else if(!(node instanceof IASTFunctionCallExpression)) { } else if (!(node instanceof IASTFunctionCallExpression)) {
return false; return false;
} }
IASTName functionName = findCalledFunctionName((IASTFunctionCallExpression) node); IASTName functionName = findCalledFunctionName((IASTFunctionCallExpression) node);
if(functionName != null) { if (functionName != null) {
IBinding binding = functionName.resolveBinding(); IBinding binding = functionName.resolveBinding();
if (binding instanceof CPPFunction) { if (binding instanceof CPPFunction) {
CPPFunction function = (CPPFunction) binding; CPPFunction function = (CPPFunction) binding;
if(function.getDefinition() != null) { if (function.getDefinition() != null) {
IASTNode parent = function.getDefinition().getParent(); IASTNode parent = function.getDefinition().getParent();
if(parent instanceof CPPASTFunctionDefinition) { if (parent instanceof CPPASTFunctionDefinition) {
CPPASTFunctionDefinition definition = (CPPASTFunctionDefinition) parent; CPPASTFunctionDefinition definition = (CPPASTFunctionDefinition) parent;
return definition.getDeclarator().getPointerOperators().length > 0; return definition.getDeclarator().getPointerOperators().length > 0;
} }
} else if(hasDeclaration(function)) { } else if (hasDeclaration(function)) {
IASTNode parent = function.getDeclarations()[0].getParent(); IASTNode parent = function.getDeclarations()[0].getParent();
if (parent instanceof CPPASTSimpleDeclaration) { if (parent instanceof CPPASTSimpleDeclaration) {
CPPASTSimpleDeclaration declaration = (CPPASTSimpleDeclaration) parent; CPPASTSimpleDeclaration declaration = (CPPASTSimpleDeclaration) parent;
return declaration.getDeclarators().length > 0 && declaration.getDeclarators()[0].getPointerOperators().length > 0; return declaration.getDeclarators().length > 0 &&
declaration.getDeclarators()[0].getPointerOperators().length > 0;
} }
} }
} }

156
core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/extractfunction/SimilarFinderVisitor.java
View file

@ -7,7 +7,7 @@
* http://www.eclipse.org/legal/epl-v10.html * http://www.eclipse.org/legal/epl-v10.html
* *
* Contributors: * Contributors:
* Institute for Software - initial API and implementation * Institute for Software - initial API and implementation
*******************************************************************************/ *******************************************************************************/
package org.eclipse.cdt.internal.ui.refactoring.extractfunction; package org.eclipse.cdt.internal.ui.refactoring.extractfunction;
@ -30,14 +30,13 @@ import org.eclipse.cdt.internal.ui.refactoring.NodeContainer;
import org.eclipse.cdt.internal.ui.refactoring.NodeContainer.NameInformation; import org.eclipse.cdt.internal.ui.refactoring.NodeContainer.NameInformation;
final class SimilarFinderVisitor extends ASTVisitor { final class SimilarFinderVisitor extends ASTVisitor {
private final ExtractFunctionRefactoring refactoring;
private final ExtractFunctionRefactoring refactoring; private final Vector<IASTNode> trail;
private final IASTName name;
private final Vector<IASTNode> trail; private final List<IASTNode> stmts;
private final IASTName name; private int i;
private final List<IASTNode> stmts; private NodeContainer similarContainer;
private int i = 0;
private NodeContainer similarContainer;
private final List<IASTStatement> stmtToReplace = new ArrayList<IASTStatement>(); private final List<IASTStatement> stmtToReplace = new ArrayList<IASTStatement>();
private final ModificationCollector collector; private final ModificationCollector collector;
@ -51,95 +50,88 @@ final class SimilarFinderVisitor extends ASTVisitor {
this.stmts = stmts; this.stmts = stmts;
this.collector = collector; this.collector = collector;
this.similarContainer = new NodeContainer(); this.similarContainer = new NodeContainer();
shouldVisitStatements = true;
} }
{ @Override
shouldVisitStatements = true; public int visit(IASTStatement stmt) {
} boolean isAllreadyInMainRefactoring = isInSelection(stmt);
@Override if ((!isAllreadyInMainRefactoring)
public int visit(IASTStatement stmt) { && this.refactoring.isStatementInTrail(stmt, trail, this.refactoring.getIndex())) {
stmtToReplace.add(stmt);
boolean isAllreadyInMainRefactoring = isInSelection(stmt); similarContainer.add(stmt);
++i;
if( (!isAllreadyInMainRefactoring)
&& this.refactoring.isStatementInTrail(stmt, trail, this.refactoring.getIndex())){ if (i == stmts.size()) {
stmtToReplace.add(stmt); // Found similar code
similarContainer.add(stmt);
++i; boolean similarOnReturnWays = true;
for (NameInformation nameInfo : similarContainer.getAllAfterUsedNames()) {
if(i==stmts.size()){ if (this.refactoring.names.containsKey(nameInfo.getDeclaration().getRawSignature())) {
//found similar code Integer nameOrderNumber = this.refactoring.names.get(nameInfo.getDeclaration().getRawSignature());
if (this.refactoring.nameTrail.containsValue(nameOrderNumber)) {
boolean similarOnReturnWays = true; String orgName = null;
for (NameInformation nameInfo : similarContainer.getAllAfterUsedNames()) { boolean found = false;
if(this.refactoring.names.containsKey(nameInfo.getDeclaration().getRawSignature())){ for (Entry<String, Integer> entry : this.refactoring.nameTrail.entrySet()) {
Integer nameOrderNumber = this.refactoring.names.get(nameInfo.getDeclaration().getRawSignature()); if (entry.getValue().equals(nameOrderNumber)) {
if(this.refactoring.nameTrail.containsValue(nameOrderNumber)){ orgName = entry.getKey();
String orgName = null; }
boolean found = false; }
for (Entry<String, Integer> entry : this.refactoring.nameTrail.entrySet()) { if (orgName != null) {
if(entry.getValue().equals(nameOrderNumber)){ for (NameInformation orgNameInfo : this.refactoring.container.getAllAfterUsedNamesChoosenByUser()) {
orgName = entry.getKey(); if (orgName.equals(orgNameInfo.getDeclaration().getRawSignature())) {
found = true;
} }
} }
if(orgName != null){ }
for (NameInformation orgNameInfo : this.refactoring.container.getAllAfterUsedNamesChoosenByUser()) {
if( orgName.equals(orgNameInfo.getDeclaration().getRawSignature()) ){ if (!found) {
found = true; similarOnReturnWays = false;
}
}
}
if(!found){
similarOnReturnWays = false;
}
} }
} }
} }
if(similarOnReturnWays){
IASTNode call = refactoring.getMethodCall(name,
this.refactoring.nameTrail, this.refactoring.names,
this.refactoring.container, similarContainer);
ASTRewrite rewrite = collector.rewriterForTranslationUnit(stmtToReplace.get(0)
.getTranslationUnit());
TextEditGroup editGroup = new TextEditGroup(Messages.SimilarFinderVisitor_replaceDuplicateCode);
rewrite.replace(stmtToReplace.get(0), call, editGroup);
if (stmtToReplace.size() > 1) {
for (int i = 1; i < stmtToReplace.size(); ++i) {
rewrite.remove(stmtToReplace.get(i), editGroup);
}
}
}
clear();
} }
return PROCESS_SKIP; if (similarOnReturnWays) {
} else { IASTNode call = refactoring.getMethodCall(name,
this.refactoring.nameTrail, this.refactoring.names,
this.refactoring.container, similarContainer);
ASTRewrite rewrite =
collector.rewriterForTranslationUnit(stmtToReplace.get(0).getTranslationUnit());
TextEditGroup editGroup = new TextEditGroup(Messages.SimilarFinderVisitor_replaceDuplicateCode);
rewrite.replace(stmtToReplace.get(0), call, editGroup);
if (stmtToReplace.size() > 1) {
for (int i = 1; i < stmtToReplace.size(); ++i) {
rewrite.remove(stmtToReplace.get(i), editGroup);
}
}
}
clear(); clear();
return super.visit(stmt);
} }
return PROCESS_SKIP;
} else {
clear();
return super.visit(stmt);
} }
}
private boolean isInSelection(IASTStatement stmt) { private boolean isInSelection(IASTStatement stmt) {
List<IASTNode>nodes = this.refactoring.container.getNodesToWrite(); List<IASTNode>nodes = this.refactoring.container.getNodesToWrite();
for (IASTNode node : nodes) { for (IASTNode node : nodes) {
if(node.equals(stmt)) { if (node.equals(stmt)) {
return true; return true;
}
} }
return false;
} }
return false;
}
private void clear() { private void clear() {
i = 0; i = 0;
this.refactoring.names.clear(); this.refactoring.names.clear();
similarContainer = new NodeContainer(); similarContainer = new NodeContainer();
this.refactoring.namesCounter.setObject(ExtractFunctionRefactoring.NULL_INTEGER); this.refactoring.namesCounter.setObject(ExtractFunctionRefactoring.NULL_INTEGER);
this.refactoring.trailPos.setObject(ExtractFunctionRefactoring.NULL_INTEGER); this.refactoring.trailPos.setObject(ExtractFunctionRefactoring.NULL_INTEGER);
stmtToReplace.clear(); stmtToReplace.clear();
} }
} }