diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/rewrite/astwriter/ASTWriter.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/rewrite/astwriter/ASTWriter.java index f9992e2c681..8e42873d8a0 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/rewrite/astwriter/ASTWriter.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/rewrite/astwriter/ASTWriter.java @@ -12,8 +12,6 @@ *******************************************************************************/ package org.eclipse.cdt.internal.core.dom.rewrite.astwriter; -import java.util.List; - import org.eclipse.cdt.core.dom.ast.IASTASMDeclaration; import org.eclipse.cdt.core.dom.ast.IASTCompoundStatement; import org.eclipse.cdt.core.dom.ast.IASTDeclarator; @@ -32,6 +30,8 @@ import org.eclipse.cdt.internal.core.dom.rewrite.changegenerator.ChangeGenerator import org.eclipse.cdt.internal.core.dom.rewrite.commenthandler.ASTCommenter; import org.eclipse.cdt.internal.core.dom.rewrite.commenthandler.NodeCommentMap; +import java.util.List; + /** * ASTWriter main class. Generates source code from IASTNode. * Uses a {@link ChangeGeneratorWriterVisitor} to generate the code for the given nodes. @@ -82,7 +82,7 @@ public class ASTWriter { /** * Returns true if the node should be separated by a blank line from the node * before it. - * + * * @param node The node. * @return true if the node should be separated by a blank line from the node * before it. @@ -99,7 +99,7 @@ public class ASTWriter { /** * Returns true if the node should be separated by a blank line from the node * after it. - * + * * @param node The node. * @return true if the node should be separated by a blank line from the node * after it. @@ -126,7 +126,7 @@ public class ASTWriter { /** * Returns true if there should be no blank line after this node even if a blank * line is normally required before the subsequent node. - * + * * @param node The node. * @return true if there should be no blank line after this node. */ @@ -136,7 +136,7 @@ public class ASTWriter { /** * Returns true if the two given nodes should be separated by a blank line. - * + * * @param node1 The first node. * @param node2 The second node. * @return true if the blank line between the nodes is needed. @@ -173,7 +173,7 @@ public class ASTWriter { if (isFunctionDeclaration(node1) != isFunctionDeclaration(node2)) { return true; } - if (requiresTrailingBlankLine(node1)) { + if (node2 != null && requiresTrailingBlankLine(node1)) { return true; } diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/rewrite/astwriter/ASTWriterVisitor.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/rewrite/astwriter/ASTWriterVisitor.java index 4f63e427e7c..9a2a669e9eb 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/rewrite/astwriter/ASTWriterVisitor.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/rewrite/astwriter/ASTWriterVisitor.java @@ -13,8 +13,6 @@ *******************************************************************************/ package org.eclipse.cdt.internal.core.dom.rewrite.astwriter; -import java.util.List; - import org.eclipse.cdt.core.dom.ast.ASTVisitor; import org.eclipse.cdt.core.dom.ast.IASTArrayModifier; import org.eclipse.cdt.core.dom.ast.IASTComment; @@ -36,6 +34,8 @@ import org.eclipse.cdt.core.dom.ast.gnu.IGNUASTCompoundStatementExpression; import org.eclipse.cdt.internal.core.dom.rewrite.ASTLiteralNode; import org.eclipse.cdt.internal.core.dom.rewrite.commenthandler.NodeCommentMap; +import java.util.List; + /** * Visits all nodes, prints leading comments and handles macro expansions. The * source code generation is delegated to severals {@code NodeWriter}s. diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/rewrite/astwriter/StatementWriter.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/rewrite/astwriter/StatementWriter.java index 776f5f0da04..96995e9e4b3 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/rewrite/astwriter/StatementWriter.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/rewrite/astwriter/StatementWriter.java @@ -1,12 +1,12 @@ /******************************************************************************* - * Copyright (c) 2008, 2010 Institute for Software, HSR Hochschule fuer Technik + * Copyright (c) 2008, 2010 Institute for Software, HSR Hochschule fuer Technik * Rapperswil, University of applied sciences and others - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the Eclipse Public License v1.0 - * which accompanies this distribution, and is available at - * http://www.eclipse.org/legal/epl-v10.html - * - * Contributors: + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: * Institute for Software - initial API and implementation *******************************************************************************/ package org.eclipse.cdt.internal.core.dom.rewrite.astwriter; @@ -45,7 +45,7 @@ import org.eclipse.cdt.internal.core.dom.rewrite.commenthandler.NodeCommentMap; /** * Generates source code of statement nodes. The actual string operations are delegated * to the Scribe class. - * + * * @see Scribe * @see IASTStatement * @author Emanuel Graf IFS @@ -75,10 +75,10 @@ public class StatementWriter extends NodeWriter { super(scribe, visitor, commentMap); declWriter = new DeclarationWriter(scribe, visitor, commentMap); } - + /** * Prints a statement. - * + * * @param statement the statement * @param newLine if true print a newline if statement usually have one. * @return {@link ASTVisitor#PROCESS_SKIP} @@ -108,18 +108,18 @@ public class StatementWriter extends NodeWriter { newLine = false; } else if (statement instanceof IASTCaseStatement) { writeCaseStatement((IASTCaseStatement) statement); -// usually newLine +// usually newLine } else if (statement instanceof IASTDefaultStatement) { writeDefaultStatement((IASTDefaultStatement)statement); } else if (statement instanceof IASTContinueStatement) { writeContinueStatement((IASTContinueStatement)statement); // usually newLine } else if (statement instanceof IASTCompoundStatement) { - writeCompoundStatement((IASTCompoundStatement) statement); if (compoundNoNewLine) { newLine = false; compoundNoNewLine = false; } + writeCompoundStatement((IASTCompoundStatement) statement); } else if (statement instanceof IASTBreakStatement) { writeBreakStatement((IASTBreakStatement) statement); // usually newLine @@ -127,7 +127,7 @@ public class StatementWriter extends NodeWriter { writeSwitchStatement((IASTSwitchStatement) statement); newLine = false; } else if (statement instanceof IASTIfStatement) { - writeIfStatement((IASTIfStatement) statement); + writeIfStatement((IASTIfStatement) statement); newLine = false; } else if (statement instanceof IASTWhileStatement) { writeWhileStatement((IASTWhileStatement) statement); @@ -149,16 +149,16 @@ public class StatementWriter extends NodeWriter { newLine = false; } else if (statement instanceof IASTProblemStatement) { throw new ProblemRuntimeException((IASTProblemStatement)statement); - } - - writeTrailingComments(statement, newLine); + } + + writeTrailingComments(statement, newLine); return ASTVisitor.PROCESS_SKIP; } private void writeDoStatement(IASTDoStatement doStatement) { nextCompoundNoNewLine(); - + scribe.print(DO); writeBodyStatement(doStatement.getBody(), true); scribe.print(DO_WHILE); @@ -186,7 +186,7 @@ public class StatementWriter extends NodeWriter { scribe.printSemicolon(); } } - + visitNodeIfNotNull(forStatement.getIterationExpression()); scribe.print(')'); scribe.newLines(); @@ -220,13 +220,13 @@ public class StatementWriter extends NodeWriter { } else { ifStatement.getConditionExpression().accept(visitor); } - + scribe.print(')'); scribe.newLines(); nextCompoundNoNewLine(); IASTStatement elseClause = ifStatement.getElseClause(); writeBodyStatement(ifStatement.getThenClause(), elseClause != null); - + if (elseClause != null) { scribe.print(ELSE); nextCompoundNoNewLine(); @@ -251,7 +251,7 @@ public class StatementWriter extends NodeWriter { private void writeLabelStatement(IASTLabelStatement labelStatement) { labelStatement.getName().accept(visitor); scribe.print(':'); - scribe.newLine(); + scribe.newLine(); labelStatement.getNestedStatement().accept(visitor); } @@ -276,7 +276,7 @@ public class StatementWriter extends NodeWriter { private void writeNullStatement(IASTNullStatement nullStmt) { scribe.printSemicolon(); } - + private void writeDeclarationStatement(IASTDeclarationStatement decStmt) { decStmt.getDeclaration().accept(visitor); } @@ -317,7 +317,7 @@ public class StatementWriter extends NodeWriter { cppWhileStatment.getCondition().accept(visitor); } else { writeDeclarationWithoutSemicolon(cppWhileStatment.getConditionDeclaration()); - } + } } else { whileStatment.getCondition().accept(visitor); } @@ -329,7 +329,7 @@ public class StatementWriter extends NodeWriter { private void writeCaseStatement(IASTCaseStatement caseStatement) { nextCompoundIndentationLevelOneMore(); - + if (!switchIsNew) { scribe.decrementIndentationLevel(); } @@ -342,7 +342,7 @@ public class StatementWriter extends NodeWriter { private void writeSwitchStatement(IASTSwitchStatement switchStatement) { switchIsNew = true; - + scribe.print(SWITCH_BRACKET); scribe.noNewLines(); if (switchStatement instanceof ICPPASTSwitchStatement) { @@ -359,13 +359,13 @@ public class StatementWriter extends NodeWriter { scribe.newLines(); nextCompoundNoNewLine(); writeBodyStatement(switchStatement.getBody(), false); - + switchIsNew = false; } private void writeDefaultStatement(IASTDefaultStatement defaultStatement) { nextCompoundIndentationLevelOneMore(); - + if (!switchIsNew) { scribe.decrementIndentationLevel(); } @@ -373,18 +373,18 @@ public class StatementWriter extends NodeWriter { scribe.incrementIndentationLevel(); switchIsNew = false; } - + private void writeCompoundStatement(IASTCompoundStatement compoundStatement) { scribe.printLBrace(); scribe.newLine(); for (IASTStatement statements : getNestedStatements(compoundStatement)) { statements.accept(visitor); } - + if (hasFreestandingComments(compoundStatement)) { - writeFreestandingComments(compoundStatement); + writeFreestandingComments(compoundStatement); } - + if (decrementIndentationLevelOneMore) { scribe.decrementIndentationLevel(); decrementIndentationLevelOneMore = false; @@ -394,9 +394,9 @@ public class StatementWriter extends NodeWriter { protected IASTStatement[] getNestedStatements(IASTCompoundStatement compoundStatement) { return compoundStatement.getStatements(); - } + } - // TODO(sprigogin): Rename second parameter + // TODO(sprigogin): Invert and rename second parameter protected void writeBodyStatement(IASTStatement statement, boolean isDoStatement) { if (statement instanceof IASTCompoundStatement) { //TODO hsr existiert noch eine methode @@ -409,23 +409,23 @@ public class StatementWriter extends NodeWriter { statement.accept(visitor); scribe.newLine(); } else { - scribe.incrementIndentationLevel(); - scribe.newLine(); + scribe.incrementIndentationLevel(); + scribe.newLine(); statement.accept(visitor); - scribe.decrementIndentationLevel(); + scribe.decrementIndentationLevel(); } } /** - * Write no new Line after the next compound statement + * Write no new line after the next compound statement */ protected void nextCompoundNoNewLine() { compoundNoNewLine = true; } - + /** - * Indent one time more at the end (before the closing brackets) - * of a compound statement + * Indent one time more at the end (before the closing brackets) + * of a compound statement */ protected void nextCompoundIndentationLevelOneMore() { decrementIndentationLevelOneMore = true; diff --git a/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/ClassMemberInserter.java b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/ClassMemberInserter.java index d64bf24bf0d..92e235c3e91 100644 --- a/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/ClassMemberInserter.java +++ b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/ClassMemberInserter.java @@ -1,12 +1,12 @@ /******************************************************************************* - * Copyright (c) 2007, 2011 Institute for Software, HSR Hochschule fuer Technik + * Copyright (c) 2007, 2011 Institute for Software, HSR Hochschule fuer Technik * Rapperswil, University of applied sciences and others - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the Eclipse Public License v1.0 - * which accompanies this distribution, and is available at - * http://www.eclipse.org/legal/epl-v10.html + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html * - * Contributors: + * Contributors: * Institute for Software - initial API and implementation * Sergey Prigogin (Google) *******************************************************************************/ @@ -42,13 +42,54 @@ import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPASTVisibilityLabel; import org.eclipse.cdt.internal.ui.refactoring.utils.VisibilityEnum; /** - * Adds a declaration to an existing class via the ModificationCollector. Automatically determines + * Adds a declaration to an existing class via the ModificationCollector. Automatically determines * an appropriate insertion point for the desired visibility. - * + * * @author Mirko Stocker */ public class ClassMemberInserter { - + public static class InsertionInfo { + private final IASTNode parentNode; + /** + * The node before which the new node should be inserted. A null value indicates insertion + * to the end of parentNode + */ + private IASTNode insertBeforeNode; // + /** Visibility label to insert before the new node or null. */ + private ICPPASTVisibilityLabel prologue; + /** Visibility label to insert after the new node or null. */ + private ICPPASTVisibilityLabel epilogue; + + public InsertionInfo(IASTNode parentNode, IASTNode insertBeforeNode) { + this.parentNode = parentNode; + this.insertBeforeNode = insertBeforeNode; + } + + public InsertionInfo(IASTNode parentNode) { + this(parentNode, null); + } + + public IASTNode getParentNode() { + return parentNode; + } + + public IASTNode getInsertBeforeNode() { + return insertBeforeNode; + } + + public ICPPASTVisibilityLabel getPrologue() { + return prologue; + } + + public ICPPASTVisibilityLabel getEpilogue() { + return epilogue; + } + } + + // Not instantiatable. All methods are static. + private ClassMemberInserter() { + } + public static void createChange(ICPPASTCompositeTypeSpecifier classNode, VisibilityEnum visibility, IASTNode nodeToAdd, boolean isField, ModificationCollector collector) { @@ -58,7 +99,23 @@ public class ClassMemberInserter { public static void createChange(ICPPASTCompositeTypeSpecifier classNode, VisibilityEnum visibility, List nodesToAdd, boolean isField, ModificationCollector collector) { + InsertionInfo info = findInsertionPoint(classNode, visibility, isField); nodesToAdd = new ArrayList(nodesToAdd); + if (info.getPrologue() != null) + nodesToAdd.add(0, info.getPrologue()); + if (info.getEpilogue() != null) + nodesToAdd.add(info.getEpilogue()); + + ASTRewrite rewrite = collector.rewriterForTranslationUnit(classNode.getTranslationUnit()); + for (IASTNode node : nodesToAdd) { + rewrite.insertBefore(info.getParentNode(), info.getInsertBeforeNode(), node, + createEditDescription(classNode)); + } + } + + public static InsertionInfo findInsertionPoint(ICPPASTCompositeTypeSpecifier classNode, + VisibilityEnum visibility, boolean isField) { + InsertionInfo info = new InsertionInfo(classNode); VisibilityEnum defaultVisibility = classNode.getKey() == IASTCompositeTypeSpecifier.k_struct ? VisibilityEnum.v_public : VisibilityEnum.v_private; VisibilityEnum currentVisibility = defaultVisibility; @@ -69,13 +126,13 @@ public class ClassMemberInserter { int lastMatchingVisibilityIndex = -1; int lastPrecedingVisibilityIndex = -1; IASTDeclaration[] members = classNode.getMembers(); - - // Find the insert location by iterating over the elements of the class + + // Find the insert location by iterating over the elements of the class // and remembering the last element with the matching visibility and the last element - // with preceding visibility (according to the visibility order preference). + // with preceding visibility (according to the visibility order preference). for (int i = 0; i < members.length; i++) { IASTDeclaration declaration = members[i]; - + if (declaration instanceof ICPPASTVisibilityLabel) { currentVisibility = VisibilityEnum.from((ICPPASTVisibilityLabel) declaration); } @@ -105,24 +162,19 @@ public class ClassMemberInserter { if (index < 0) index = lastPrecedingVisibilityIndex; index++; - IASTNode nextNode = index < members.length ? members[index] : null; - + if (index < members.length) + info.insertBeforeNode = members[index]; + if (lastMatchingVisibilityIndex < 0 && - !(index == 0 && classNode.getKey() == IASTCompositeTypeSpecifier.k_struct && visibility == defaultVisibility)) { - nodesToAdd.add(0, new CPPASTVisibilityLabel(visibility.getVisibilityLabelValue())); - if (index == 0 && nextNode != null && !(nextNode instanceof ICPPASTVisibilityLabel)) { - nodesToAdd.add(new CPPASTVisibilityLabel(defaultVisibility.getVisibilityLabelValue())); + !(index == 0 && classNode.getKey() == IASTCompositeTypeSpecifier.k_struct && + visibility == defaultVisibility)) { + info.prologue = new CPPASTVisibilityLabel(visibility.getVisibilityLabelValue()); + if (index == 0 && info.insertBeforeNode != null && + !(info.insertBeforeNode instanceof ICPPASTVisibilityLabel)) { + info.epilogue = new CPPASTVisibilityLabel(defaultVisibility.getVisibilityLabelValue()); } } - - ASTRewrite rewrite = collector.rewriterForTranslationUnit(classNode.getTranslationUnit()); - for (IASTNode node : nodesToAdd) { - rewrite.insertBefore(classNode, nextNode, node, createEditDescription(classNode)); - } - } - - // Not instantiatable. All methods are static. - private ClassMemberInserter() { + return info; } private static TextEditGroup createEditDescription(ICPPASTCompositeTypeSpecifier classNode) { diff --git a/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/EqualityChecker.java b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/EqualityChecker.java index 42f5d0e12fd..52553bd4207 100644 --- a/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/EqualityChecker.java +++ b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/EqualityChecker.java @@ -1,16 +1,16 @@ /******************************************************************************* - * Copyright (c) 2008 Institute for Software, HSR Hochschule fuer Technik + * Copyright (c) 2008 Institute for Software, HSR Hochschule fuer Technik * Rapperswil, University of applied sciences and others - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the Eclipse Public License v1.0 - * which accompanies this distribution, and is available at - * http://www.eclipse.org/legal/epl-v10.html - * - * Contributors: - * Institute for Software - initial API and implementation + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Institute for Software - initial API and implementation *******************************************************************************/ package org.eclipse.cdt.internal.ui.refactoring; public interface EqualityChecker { - boolean isEquals(T object1, T object2); + boolean isEqual(T object1, T object2); } diff --git a/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/MethodContext.java b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/MethodContext.java index 612a888749d..ecc7578a922 100644 --- a/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/MethodContext.java +++ b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/MethodContext.java @@ -1,12 +1,12 @@ /******************************************************************************* - * Copyright (c) 2008, 2010 Institute for Software, HSR Hochschule fuer Technik + * Copyright (c) 2008, 2010 Institute for Software, HSR Hochschule fuer Technik * Rapperswil, University of applied sciences and others - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the Eclipse Public License v1.0 - * which accompanies this distribution, and is available at - * http://www.eclipse.org/legal/epl-v10.html - * - * Contributors: + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: * Institute for Software - initial API and implementation *******************************************************************************/ package org.eclipse.cdt.internal.ui.refactoring; @@ -26,8 +26,8 @@ import org.eclipse.cdt.internal.core.dom.parser.ASTInternal; import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPInternalBinding; /** - * Represents a function or method and adds some useful helper methods to - * determine if methods are in the same class. + * Represents a function or method and adds some useful helper methods to determine + * if two methods are in the same class. */ public class MethodContext { public enum ContextType { NONE, FUNCTION, METHOD } @@ -55,7 +55,7 @@ public class MethodContext { public IASTName getMethodDeclarationName() { return declarationName; } - + public IASTDeclaration getMethodDeclaration() { IASTNode parent = declarationName.getParent().getParent(); if (parent instanceof IASTDeclaration) { @@ -63,7 +63,7 @@ public class MethodContext { } return null; } - + public Visibility getMethodDeclarationVisibility() { return Visibility.getVisibility(declarationName); } @@ -71,17 +71,17 @@ public class MethodContext { public void setMethodQName(ICPPASTQualifiedName qname) { this.qname = qname; } - + public ICPPASTQualifiedName getMethodQName() { return qname; } - + public static boolean isSameClass(ICPPASTQualifiedName qname1, ICPPASTQualifiedName qname2) { ICPPClassType bind1 = getClassBinding(qname1); ICPPClassType bind2 = getClassBinding(qname2); return bind1.equals(bind2); } - + public static boolean isSameOrSubClass(MethodContext context1, MethodContext contextOfSameOrSubclass) { ICPPInternalBinding bind1 = getICPPInternalBinding(context1); ICPPInternalBinding subclassBind = getICPPInternalBinding(contextOfSameOrSubclass); @@ -90,7 +90,7 @@ public class MethodContext { } return isSubclass(bind1,subclassBind); } - + private static boolean isSubclass(ICPPInternalBinding bind1, ICPPInternalBinding subclassBind) { if (subclassBind instanceof ICPPClassType) { ICPPClassType classType = (ICPPClassType) subclassBind; @@ -110,7 +110,7 @@ public class MethodContext { ICPPInternalBinding bind2 = getICPPInternalBinding(context2); return isSameClass(bind1,bind2); } - + private static boolean isSameClass(ICPPBase base, ICPPInternalBinding bind2) { try { IBinding bind1 = base.getBaseClass(); @@ -118,12 +118,12 @@ public class MethodContext { if (scope1 == null) return false; IASTNode node1 = ASTInternal.getPhysicalNodeOfScope(scope1); - + IScope scope2 = bind2.getScope(); if (scope2 == null) return false; IASTNode node2 = ASTInternal.getPhysicalNodeOfScope(scope2); - + if (node1.equals(node2)) { if (bind1 instanceof ICPPInternalBinding) { ICPPInternalBinding bind1int = (ICPPInternalBinding) bind1; @@ -134,30 +134,30 @@ public class MethodContext { return false; } catch (DOMException e) { return false; - } + } } - + private static boolean isSameClass(ICPPInternalBinding bind1, ICPPInternalBinding bind2) { try { IScope scope1 = bind1.getScope(); if (scope1 == null) return false; IASTNode node1 = ASTInternal.getPhysicalNodeOfScope(scope1); - + IScope scope2 = bind2.getScope(); if (scope2 == null) return false; IASTNode node2 = ASTInternal.getPhysicalNodeOfScope(scope2); - + if (node1.equals(node2)) { return bind1.getDefinition().equals(bind2.getDefinition()); } return false; } catch (DOMException e) { return false; - } + } } - + public static ICPPInternalBinding getICPPInternalBinding(MethodContext context) { IASTName decl = context.getMethodDeclarationName(); IASTNode node = decl; @@ -169,17 +169,17 @@ public class MethodContext { } node = node.getParent(); } - + return null; } - + public boolean isInline() { return qname == null; } - + private static ICPPClassType getClassBinding(ICPPASTQualifiedName qname) { IASTName classname = qname.getNames()[qname.getNames().length - 2]; - ICPPClassType bind = (ICPPClassType)classname.resolveBinding(); + ICPPClassType bind = (ICPPClassType)classname.resolveBinding(); return bind; } diff --git a/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/extractfunction/ExtractFunctionInformation.java b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/extractfunction/ExtractFunctionInformation.java index 2d3713394a3..427e1f883cb 100644 --- a/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/extractfunction/ExtractFunctionInformation.java +++ b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/extractfunction/ExtractFunctionInformation.java @@ -1,12 +1,12 @@ /******************************************************************************* - * Copyright (c) 2008, 2012 Institute for Software, HSR Hochschule fuer Technik + * Copyright (c) 2008, 2012 Institute for Software, HSR Hochschule fuer Technik * Rapperswil, University of applied sciences and others - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the Eclipse Public License v1.0 - * which accompanies this distribution, and is available at - * http://www.eclipse.org/legal/epl-v10.html - * - * Contributors: + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: * Institute for Software - initial API and implementation * Sergey Prigogin (Google) *******************************************************************************/ @@ -31,15 +31,15 @@ public class ExtractFunctionInformation { private String methodName; private boolean replaceDuplicates; private List parameters; - private NameInformation mandatoryReturnVariable; + private NameInformation mandatoryReturnVariable; private ICPPASTFunctionDeclarator declarator; private MethodContext context; private boolean isExtractExpression; private boolean virtual; /** - * Returns the function declarator of the method / function from were the statements - * are extacted from. + * Returns the function declarator of the method or function from were the statements + * are extracted from. * @return the function declarator or null */ public ICPPASTFunctionDeclarator getDeclarator() { diff --git a/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/extractfunction/ExtractFunctionInputPage.java b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/extractfunction/ExtractFunctionInputPage.java index 3c066b08b31..78ac71edbe9 100644 --- a/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/extractfunction/ExtractFunctionInputPage.java +++ b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/extractfunction/ExtractFunctionInputPage.java @@ -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; @@ -252,7 +252,7 @@ public class ExtractFunctionInputPage extends UserInputWizardPage { if (methodName.isEmpty()) { methodName = StubUtility.suggestMethodName("someMethodName", null, //$NON-NLS-1$ - refactoring.getTranslationUnit()); + refactoring.getTranslationUnit()); } int top = signaturePreview.getTextWidget().getTopPixel(); diff --git a/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/extractfunction/ExtractFunctionRefactoring.java b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/extractfunction/ExtractFunctionRefactoring.java index ef15e271284..4a1618d5268 100644 --- a/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/extractfunction/ExtractFunctionRefactoring.java +++ b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/extractfunction/ExtractFunctionRefactoring.java @@ -1,12 +1,12 @@ /******************************************************************************* - * Copyright (c) 2008, 2012 Institute for Software, HSR Hochschule fuer Technik + * Copyright (c) 2008, 2012 Institute for Software, HSR Hochschule fuer Technik * Rapperswil, University of applied sciences and others - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the Eclipse Public License v1.0 - * which accompanies this distribution, and is available at - * http://www.eclipse.org/legal/epl-v10.html - * - * Contributors: + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: * Institute for Software - initial API and implementation * Sergey Prigogin (Google) *******************************************************************************/ @@ -108,6 +108,7 @@ import org.eclipse.cdt.internal.core.dom.rewrite.astwriter.ASTWriterVisitor; import org.eclipse.cdt.internal.ui.refactoring.CRefactoring; import org.eclipse.cdt.internal.ui.refactoring.CRefactoringDescriptor; import org.eclipse.cdt.internal.ui.refactoring.ClassMemberInserter; +import org.eclipse.cdt.internal.ui.refactoring.ClassMemberInserter.InsertionInfo; import org.eclipse.cdt.internal.ui.refactoring.Container; import org.eclipse.cdt.internal.ui.refactoring.MethodContext; import org.eclipse.cdt.internal.ui.refactoring.MethodContext.ContextType; @@ -172,17 +173,17 @@ public class ExtractFunctionRefactoring extends CRefactoring { ast = getAST(tu, sm.newChild(1)); nodeFactory = ast.getASTNodeFactory(); container = findExtractableNodes(); - + if (isProgressMonitorCanceled(sm, initStatus)) return initStatus; - + if (container.isEmpty()) { initStatus.addFatalError(Messages.ExtractFunctionRefactoring_NoStmtSelected); return initStatus; } - + checkForNonExtractableStatements(container, initStatus); - + List returnValueCandidates = container.getReturnValueCandidates(); if (returnValueCandidates.size() > 1) { initStatus.addFatalError(Messages.ExtractFunctionRefactoring_TooManySelected); @@ -190,27 +191,27 @@ public class ExtractFunctionRefactoring extends CRefactoring { } else if (returnValueCandidates.size() == 1) { info.setMandatoryReturnVariable(returnValueCandidates.get(0)); } - + info.setParameters(container.getParameterCandidates()); initStatus.merge(checkParameterAndReturnTypes()); if (initStatus.hasFatalError()) return initStatus; - + extractor = FunctionExtractor.createFor(container.getNodesToWrite()); - + if (extractor.canChooseReturnValue() && info.getMandatoryReturnVariable() == null) { chooseReturnVariable(); } - + IPreferencesService preferences = Platform.getPreferencesService(); final boolean outFirst = preferences.getBoolean(CUIPlugin.PLUGIN_ID, PreferenceConstants.FUNCTION_OUTPUT_PARAMETERS_BEFORE_INPUT, false, PreferenceConstants.getPreferenceScopes(project.getProject())); info.sortParameters(outFirst); - + boolean isExtractExpression = container.getNodesToWrite().get(0) instanceof IASTExpression; info.setExtractExpression(isExtractExpression); - + info.setDeclarator(getDeclaration(container.getNodesToWrite().get(0))); MethodContext context = NodeHelper.findMethodContext(container.getNodesToWrite().get(0), refactoringContext, sm.newChild(1)); @@ -347,7 +348,7 @@ public class ExtractFunctionRefactoring extends CRefactoring { if (node != firstNodeToWrite) { rewriter.remove(node, editGroup); } - } + } } private void insertCallIntoTree(IASTNode methodCall, List list, ASTRewrite rewriter, @@ -379,9 +380,10 @@ public class ExtractFunctionRefactoring extends CRefactoring { } private void createMethodDefinition(final IASTName methodName, MethodContext context, - IASTNode firstNode, ModificationCollector collector) { - IASTFunctionDefinition node = CPPVisitor.findAncestorWithType(firstNode, IASTFunctionDefinition.class); - if (node != null) { + IASTNode firstExtractedNode, ModificationCollector collector) { + IASTFunctionDefinition functionToExtractFrom = + CPPVisitor.findAncestorWithType(firstExtractedNode, IASTFunctionDefinition.class); + if (functionToExtractFrom != null) { String title; if (context.getType() == MethodContext.ContextType.METHOD) { title = Messages.ExtractFunctionRefactoring_CreateMethodDef; @@ -389,8 +391,8 @@ public class ExtractFunctionRefactoring extends CRefactoring { title = Messages.ExtractFunctionRefactoring_CreateFunctionDef; } - ASTRewrite rewriter = collector.rewriterForTranslationUnit(node.getTranslationUnit()); - addMethod(methodName, context, rewriter, node, new TextEditGroup(title)); + ASTRewrite rewriter = collector.rewriterForTranslationUnit(functionToExtractFrom.getTranslationUnit()); + addMethod(methodName, context, rewriter, functionToExtractFrom, new TextEditGroup(title)); } } @@ -518,7 +520,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 +565,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(), @@ -584,7 +586,7 @@ public class ExtractFunctionRefactoring extends CRefactoring { } private void addMethod(IASTName methodName, MethodContext context, ASTRewrite rewrite, - IASTNode insertPoint, TextEditGroup group) { + IASTNode functionToExtractFrom, TextEditGroup group) { ICPPASTQualifiedName qname = new CPPASTQualifiedName(); if (context.getType() == ContextType.METHOD) { if (context.getMethodQName() != null) { @@ -600,7 +602,7 @@ public class ExtractFunctionRefactoring extends CRefactoring { IASTDeclSpecifier returnType = getReturnType(); func.setDeclSpecifier(returnType); - + IASTStandardFunctionDeclarator createdFunctionDeclarator = extractor.createFunctionDeclarator(qname, info.getDeclarator(), info.getReturnVariable(), container.getNodesToWrite(), @@ -609,22 +611,46 @@ public class ExtractFunctionRefactoring extends CRefactoring { IASTCompoundStatement compound = new CPPASTCompoundStatement(); func.setBody(compound); - + ASTRewrite subRewrite; - IASTNode parent = insertPoint.getParent(); + IASTNode parent = functionToExtractFrom.getParent(); + IASTNode nodeToInsert = func; if (parent instanceof ICPPASTTemplateDeclaration) { ICPPASTTemplateDeclaration parentTemplate = (ICPPASTTemplateDeclaration) parent; CPPASTTemplateDeclaration templateDeclaration = new CPPASTTemplateDeclaration(); templateDeclaration.setParent(ast); - + for (ICPPASTTemplateParameter param : parentTemplate.getTemplateParameters()) { templateDeclaration.addTemplateParameter(param.copy(CopyStyle.withLocations)); } - + + functionToExtractFrom = parentTemplate; templateDeclaration.setDeclaration(func); - subRewrite = rewrite.insertBefore(parent.getParent(), parent, templateDeclaration, group); + nodeToInsert = templateDeclaration; + parent = parent.getParent(); + } + + InsertionInfo insertion; + if (parent instanceof ICPPASTCompositeTypeSpecifier) { + // Inserting into a class declaration + insertion = ClassMemberInserter.findInsertionPoint((ICPPASTCompositeTypeSpecifier) parent, + info.getVisibility(), false); } else { - subRewrite = rewrite.insertBefore(parent, insertPoint, func, group); + // Inserting into a translation unit or a namespace. + // TODO(sprigogin): Use insertBeforeNode instead of functionToExtractFrom when creating InsertionInfo +// IASTNode insertBeforeNode = info.getMethodContext().getType() == ContextType.METHOD ? +// null : functionToExtractFrom; + insertion = new InsertionInfo(parent, functionToExtractFrom); + } + if (insertion.getPrologue() != null) { + rewrite.insertBefore(insertion.getParentNode(), + insertion.getInsertBeforeNode(), insertion.getPrologue(), group); + } + subRewrite = rewrite.insertBefore(insertion.getParentNode(), + insertion.getInsertBeforeNode(), nodeToInsert, group); + if (insertion.getEpilogue() != null) { + rewrite.insertBefore(insertion.getParentNode(), + insertion.getInsertBeforeNode(), insertion.getEpilogue(), group); } extractor.constructMethodBody(compound, container.getNodesToWrite(), @@ -777,7 +803,7 @@ public class ExtractFunctionRefactoring extends CRefactoring { IASTNode node = container.getNodesToWrite().get(0); return extractor.createReturnAssignment(node, stmt, callExpression); } - + private IASTSimpleDeclaration getDeclaration(IASTName name) { IASTSimpleDeclaration simpleDecl = new CPPASTSimpleDeclaration(); IASTStandardFunctionDeclarator declarator = diff --git a/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/extractfunction/Messages.properties b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/extractfunction/Messages.properties index df9538cfaf6..85834ad3ac3 100644 --- a/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/extractfunction/Messages.properties +++ b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/extractfunction/Messages.properties @@ -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 diff --git a/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/extractfunction/TrailNodeEqualityChecker.java b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/extractfunction/TrailNodeEqualityChecker.java index 6ba975f6303..d2e70c22c7c 100644 --- a/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/extractfunction/TrailNodeEqualityChecker.java +++ b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/extractfunction/TrailNodeEqualityChecker.java @@ -1,13 +1,14 @@ /******************************************************************************* - * Copyright (c) 2008, 2010 Institute for Software, HSR Hochschule fuer Technik + * Copyright (c) 2008, 2010 Institute for Software, HSR Hochschule fuer Technik * Rapperswil, University of applied sciences and others - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the Eclipse Public License v1.0 - * which accompanies this distribution, and is available at - * http://www.eclipse.org/legal/epl-v10.html - * - * Contributors: + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * 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; @@ -70,7 +72,7 @@ public class TrailNodeEqualityChecker implements EqualityChecker { private final Map names; private final Container namesCounter; private final IIndex index; - + public TrailNodeEqualityChecker(Map names, Container namesCounter, IIndex index) { super(); @@ -78,38 +80,41 @@ public class TrailNodeEqualityChecker implements EqualityChecker { this.namesCounter = namesCounter; this.index = index; } - + @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); - } else if (node instanceof IASTDeclarator) { - return isDeclaratorEquals(trailNode, node); + return isDeclarationEqual(trailNode, node); + } else if (node instanceof IASTDeclarator) { + 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 { } 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 { } 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 { } } - 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 { } } - 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 { } } - 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 { 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 { } 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 { 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 { && 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 { && 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()); @@ -344,7 +353,7 @@ public class TrailNodeEqualityChecker implements EqualityChecker { if (actCount != trailName.getNameNumber()) { return false; - } + } if (trailName.isGloballyQualified()) { IBinding realBind = trailName.getRealName().resolveBinding(); diff --git a/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/utils/ASTHelper.java b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/utils/ASTHelper.java index 552290d5db9..faa92fc6cd7 100644 --- a/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/utils/ASTHelper.java +++ b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/refactoring/utils/ASTHelper.java @@ -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; } }