下面列出了怎么用org.eclipse.jdt.core.dom.WhileStatement的API类实例代码及写法,或者点击链接到github查看源代码。
public boolean visit(SingleVariableDeclaration node){
ASTNode parent = node.getParent();
while(parent != null){
if(parent instanceof Block || parent instanceof ForStatement || parent instanceof IfStatement || parent instanceof EnhancedForStatement || parent instanceof WhileStatement){
break;
}
parent = parent.getParent();
}
if(parent != null) {
int start = _unit.getLineNumber(node.getStartPosition());
int end = _unit.getLineNumber(parent.getStartPosition() + parent.getLength());
Pair<String, Type> pair = new Pair<String, Type>(node.getName().getFullyQualifiedName(), node.getType());
Pair<Integer, Integer> range = new Pair<Integer, Integer>(start, end);
_tmpVars.put(pair, range);
}
return true;
}
private Statement getParentLoopBody(ASTNode node) {
Statement stmt = null;
ASTNode start = node;
while (start != null && !(start instanceof ForStatement) && !(start instanceof DoStatement) && !(start instanceof WhileStatement) && !(start instanceof EnhancedForStatement) && !(start instanceof SwitchStatement)) {
start = start.getParent();
}
if (start instanceof ForStatement) {
stmt = ((ForStatement) start).getBody();
} else if (start instanceof DoStatement) {
stmt = ((DoStatement) start).getBody();
} else if (start instanceof WhileStatement) {
stmt = ((WhileStatement) start).getBody();
} else if (start instanceof EnhancedForStatement) {
stmt = ((EnhancedForStatement) start).getBody();
}
if (start != null && start.getParent() instanceof LabeledStatement) {
LabeledStatement labeledStatement = (LabeledStatement) start.getParent();
fEnclosingLoopLabel = labeledStatement.getLabel();
}
return stmt;
}
private void checkSendInLoopNode(Statement loopNode) {
Statement body;
if (loopNode instanceof WhileStatement) {
WhileStatement whileLoop = (WhileStatement) loopNode;
body = whileLoop.getBody();
} else if (loopNode instanceof ForStatement) {
ForStatement forLoop = (ForStatement) loopNode;
body = forLoop.getBody();
} else {
DoStatement doWhileLoop = (DoStatement) loopNode;
body = doWhileLoop.getBody();
}
boolean showErrorHere = placeOfError == loopNode;
if (showErrorHere) {
placeOfError = body;
}
if (body instanceof Block) {
checkSendInBlock((Block) body, showErrorHere);
} else {
checkSendInStatement(body);
}
}
@Override
public boolean preNext(Statement curElement) {
switch (curElement.getNodeType()) {
case ASTNode.WHILE_STATEMENT:
exportWhile((WhileStatement) curElement);
break;
case ASTNode.FOR_STATEMENT:
exportFor((ForStatement) curElement);
break;
case ASTNode.ENHANCED_FOR_STATEMENT:
exportForEach((EnhancedForStatement) curElement);
break;
case ASTNode.DO_STATEMENT:
exportDoWhileStatement((DoStatement) curElement);
break;
}
return true;
}
private boolean isSingleControlStatementWithoutBlock() {
List<Statement> statements= fDeclaration.getBody().statements();
int size= statements.size();
if (size != 1)
return false;
Statement statement= statements.get(size - 1);
int nodeType= statement.getNodeType();
if (nodeType == ASTNode.IF_STATEMENT) {
IfStatement ifStatement= (IfStatement) statement;
return !(ifStatement.getThenStatement() instanceof Block)
&& !(ifStatement.getElseStatement() instanceof Block);
} else if (nodeType == ASTNode.FOR_STATEMENT) {
return !(((ForStatement)statement).getBody() instanceof Block);
} else if (nodeType == ASTNode.WHILE_STATEMENT) {
return !(((WhileStatement)statement).getBody() instanceof Block);
}
return false;
}
private Statement getParentLoopBody(ASTNode node) {
Statement stmt= null;
ASTNode start= node;
while (start != null
&& !(start instanceof ForStatement)
&& !(start instanceof DoStatement)
&& !(start instanceof WhileStatement)
&& !(start instanceof EnhancedForStatement)
&& !(start instanceof SwitchStatement)) {
start= start.getParent();
}
if (start instanceof ForStatement) {
stmt= ((ForStatement)start).getBody();
} else if (start instanceof DoStatement) {
stmt= ((DoStatement)start).getBody();
} else if (start instanceof WhileStatement) {
stmt= ((WhileStatement)start).getBody();
} else if (start instanceof EnhancedForStatement) {
stmt= ((EnhancedForStatement)start).getBody();
}
if (start != null && start.getParent() instanceof LabeledStatement) {
LabeledStatement labeledStatement= (LabeledStatement)start.getParent();
fEnclosingLoopLabel= labeledStatement.getLabel();
}
return stmt;
}
private static boolean locationNeedsParentheses(StructuralPropertyDescriptor locationInParent) {
if (locationInParent instanceof ChildListPropertyDescriptor && locationInParent != InfixExpression.EXTENDED_OPERANDS_PROPERTY) {
// e.g. argument lists of MethodInvocation, ClassInstanceCreation, dimensions of ArrayCreation ...
return false;
}
if (locationInParent == VariableDeclarationFragment.INITIALIZER_PROPERTY
|| locationInParent == SingleVariableDeclaration.INITIALIZER_PROPERTY
|| locationInParent == ReturnStatement.EXPRESSION_PROPERTY
|| locationInParent == EnhancedForStatement.EXPRESSION_PROPERTY
|| locationInParent == ForStatement.EXPRESSION_PROPERTY
|| locationInParent == WhileStatement.EXPRESSION_PROPERTY
|| locationInParent == DoStatement.EXPRESSION_PROPERTY
|| locationInParent == AssertStatement.EXPRESSION_PROPERTY
|| locationInParent == AssertStatement.MESSAGE_PROPERTY
|| locationInParent == IfStatement.EXPRESSION_PROPERTY
|| locationInParent == SwitchStatement.EXPRESSION_PROPERTY
|| locationInParent == SwitchCase.EXPRESSION_PROPERTY
|| locationInParent == ArrayAccess.INDEX_PROPERTY
|| locationInParent == ThrowStatement.EXPRESSION_PROPERTY
|| locationInParent == SynchronizedStatement.EXPRESSION_PROPERTY
|| locationInParent == ParenthesizedExpression.EXPRESSION_PROPERTY) {
return false;
}
return true;
}
private static boolean isLastStatementInEnclosingMethodOrLambda(Statement statement) {
ASTNode currentStructure= statement;
ASTNode currentParent= statement.getParent();
while (!(currentParent instanceof MethodDeclaration || currentParent instanceof LambdaExpression)) {
// should not be in a loop
if (currentParent instanceof ForStatement || currentParent instanceof EnhancedForStatement
|| currentParent instanceof WhileStatement || currentParent instanceof DoStatement) {
return false;
}
if (currentParent instanceof Block) {
Block parentBlock= (Block) currentParent;
if (parentBlock.statements().indexOf(currentStructure) != parentBlock.statements().size() - 1) { // not last statement in the block
return false;
}
}
currentStructure= currentParent;
currentParent= currentParent.getParent();
}
return true;
}
private static AbstractLoop generateAbstractLoop(Object object)
{
if (object instanceof ForStatement)
{
return new ConditionalLoop((ForStatement) object);
}
else if (object instanceof WhileStatement)
{
return new ConditionalLoop((WhileStatement) object);
}
else if (object instanceof DoStatement)
{
return new ConditionalLoop((DoStatement) object);
}
else if (object instanceof EnhancedForStatement)
{
return new EnhancedForLoop((EnhancedForStatement) object);
}
return null;
}
public Statement getLoopBody()
{
if (loopStatement instanceof WhileStatement)
{
return ((WhileStatement)loopStatement).getBody();
}
else if (loopStatement instanceof ForStatement)
{
return ((ForStatement)loopStatement).getBody();
}
else if (loopStatement instanceof DoStatement)
{
return ((DoStatement)loopStatement).getBody();
}
else if (loopStatement instanceof EnhancedForStatement)
{
return ((EnhancedForStatement)loopStatement).getBody();
}
return null;
}
public boolean visit(WhileStatement node) {
int start = _unit.getLineNumber(node.getExpression().getStartPosition());
if(start == _extendedLine){
_extendedStatement = node;
return false;
}
return true;
}
private WhileStmt visit(WhileStatement node) {
int startLine = _cunit.getLineNumber(node.getStartPosition());
int endLine = _cunit.getLineNumber(node.getStartPosition() + node.getLength());
WhileStmt whileStmt = new WhileStmt(startLine, endLine, node);
Expr expression = (Expr) process(node.getExpression());
expression.setParent(whileStmt);
whileStmt.setExpression(expression);
Stmt body = (Stmt) process(node.getBody());
body.setParent(whileStmt);
whileStmt.setBody(body);
return whileStmt;
}
@Override
public void endVisit(WhileStatement node) {
if (skipNode(node)) {
return;
}
WhileFlowInfo info = createWhile();
setFlowInfo(node, info);
info.mergeCondition(getFlowInfo(node.getExpression()), fFlowContext);
info.mergeAction(getFlowInfo(node.getBody()), fFlowContext);
info.removeLabel(null);
}
private static Expression getBooleanExpression(ASTNode node) {
if (!(node instanceof Expression)) {
return null;
}
// check if the node is a location where it can be negated
StructuralPropertyDescriptor locationInParent = node.getLocationInParent();
if (locationInParent == QualifiedName.NAME_PROPERTY) {
node = node.getParent();
locationInParent = node.getLocationInParent();
}
while (locationInParent == ParenthesizedExpression.EXPRESSION_PROPERTY) {
node = node.getParent();
locationInParent = node.getLocationInParent();
}
Expression expression = (Expression) node;
if (!isBoolean(expression)) {
return null;
}
if (expression.getParent() instanceof InfixExpression) {
return expression;
}
if (locationInParent == Assignment.RIGHT_HAND_SIDE_PROPERTY || locationInParent == IfStatement.EXPRESSION_PROPERTY || locationInParent == WhileStatement.EXPRESSION_PROPERTY || locationInParent == DoStatement.EXPRESSION_PROPERTY
|| locationInParent == ReturnStatement.EXPRESSION_PROPERTY || locationInParent == ForStatement.EXPRESSION_PROPERTY || locationInParent == AssertStatement.EXPRESSION_PROPERTY
|| locationInParent == MethodInvocation.ARGUMENTS_PROPERTY || locationInParent == ConstructorInvocation.ARGUMENTS_PROPERTY || locationInParent == SuperMethodInvocation.ARGUMENTS_PROPERTY
|| locationInParent == EnumConstantDeclaration.ARGUMENTS_PROPERTY || locationInParent == SuperConstructorInvocation.ARGUMENTS_PROPERTY || locationInParent == ClassInstanceCreation.ARGUMENTS_PROPERTY
|| locationInParent == ConditionalExpression.EXPRESSION_PROPERTY || locationInParent == PrefixExpression.OPERAND_PROPERTY) {
return expression;
}
return null;
}
@Override
public boolean visit(final WhileStatement node) {
this.appendToBuffer("while (");
node.getExpression().accept(this);
this.appendToBuffer(") ");
node.getBody().accept(this);
return false;
}
/**
* We create this access explicitly to catch a boolean variable used in
* condition. Complicated expressions are handled in
* {@link #visit(InfixExpression)}
*/
@Override
public boolean visit(WhileStatement node) {
if (importer.topFromContainerStack(Method.class) != null) {
importer.topFromContainerStack(Method.class).incCyclomaticComplexity();
importer.createAccessFromExpression((Expression) node.getExpression());
}
return true;
}
public boolean isDangligIf() {
List<Statement> statements= fDeclaration.getBody().statements();
if (statements.size() != 1)
return false;
ASTNode p= statements.get(0);
while (true) {
if (p instanceof IfStatement) {
return ((IfStatement) p).getElseStatement() == null;
} else {
ChildPropertyDescriptor childD;
if (p instanceof WhileStatement) {
childD= WhileStatement.BODY_PROPERTY;
} else if (p instanceof ForStatement) {
childD= ForStatement.BODY_PROPERTY;
} else if (p instanceof EnhancedForStatement) {
childD= EnhancedForStatement.BODY_PROPERTY;
} else if (p instanceof DoStatement) {
childD= DoStatement.BODY_PROPERTY;
} else if (p instanceof LabeledStatement) {
childD= LabeledStatement.BODY_PROPERTY;
} else {
return false;
}
Statement body= (Statement) p.getStructuralProperty(childD);
if (body instanceof Block) {
return false;
} else {
p= body;
}
}
}
}
@Override
public void endVisit(WhileStatement node) {
if (skipNode(node))
return;
WhileFlowInfo info= createWhile();
setFlowInfo(node, info);
info.mergeCondition(getFlowInfo(node.getExpression()), fFlowContext);
info.mergeAction(getFlowInfo(node.getBody()), fFlowContext);
info.removeLabel(null);
}
private void insertAt(ASTNode target, Statement declaration) {
ASTRewrite rewrite= fCURewrite.getASTRewrite();
TextEditGroup groupDescription= fCURewrite.createGroupDescription(RefactoringCoreMessages.ExtractTempRefactoring_declare_local_variable);
ASTNode parent= target.getParent();
StructuralPropertyDescriptor locationInParent= target.getLocationInParent();
while (locationInParent != Block.STATEMENTS_PROPERTY && locationInParent != SwitchStatement.STATEMENTS_PROPERTY) {
if (locationInParent == IfStatement.THEN_STATEMENT_PROPERTY
|| locationInParent == IfStatement.ELSE_STATEMENT_PROPERTY
|| locationInParent == ForStatement.BODY_PROPERTY
|| locationInParent == EnhancedForStatement.BODY_PROPERTY
|| locationInParent == DoStatement.BODY_PROPERTY
|| locationInParent == WhileStatement.BODY_PROPERTY) {
// create intermediate block if target was the body property of a control statement:
Block replacement= rewrite.getAST().newBlock();
ListRewrite replacementRewrite= rewrite.getListRewrite(replacement, Block.STATEMENTS_PROPERTY);
replacementRewrite.insertFirst(declaration, null);
replacementRewrite.insertLast(rewrite.createMoveTarget(target), null);
rewrite.replace(target, replacement, groupDescription);
return;
}
target= parent;
parent= parent.getParent();
locationInParent= target.getLocationInParent();
}
ListRewrite listRewrite= rewrite.getListRewrite(parent, (ChildListPropertyDescriptor)locationInParent);
listRewrite.insertBefore(declaration, target, groupDescription);
}
@Override
public void endVisit(WhileStatement node) {
ASTNode[] selectedNodes= getSelectedNodes();
if (doAfterValidation(node, selectedNodes)) {
if (contains(selectedNodes, node.getExpression()) && contains(selectedNodes, node.getBody())) {
invalidSelection(RefactoringCoreMessages.StatementAnalyzer_while_expression_body);
}
}
super.endVisit(node);
}
/**
* Returns true if a node at a given location is a body of a control statement. Such body nodes are
* interesting as when replacing them, it has to be evaluates if a Block is needed instead.
* E.g. <code> if (x) do(); -> if (x) { do1(); do2() } </code>
*
* @param locationInParent Location of the body node
* @return Returns true if the location is a body node location of a control statement.
*/
public static boolean isControlStatementBody(StructuralPropertyDescriptor locationInParent) {
return locationInParent == IfStatement.THEN_STATEMENT_PROPERTY
|| locationInParent == IfStatement.ELSE_STATEMENT_PROPERTY
|| locationInParent == ForStatement.BODY_PROPERTY
|| locationInParent == EnhancedForStatement.BODY_PROPERTY
|| locationInParent == WhileStatement.BODY_PROPERTY
|| locationInParent == DoStatement.BODY_PROPERTY;
}
private static Expression getBooleanExpression(ASTNode node) {
if (!(node instanceof Expression)) {
return null;
}
// check if the node is a location where it can be negated
StructuralPropertyDescriptor locationInParent= node.getLocationInParent();
if (locationInParent == QualifiedName.NAME_PROPERTY) {
node= node.getParent();
locationInParent= node.getLocationInParent();
}
while (locationInParent == ParenthesizedExpression.EXPRESSION_PROPERTY) {
node= node.getParent();
locationInParent= node.getLocationInParent();
}
Expression expression= (Expression) node;
if (!isBoolean(expression)) {
return null;
}
if (expression.getParent() instanceof InfixExpression) {
return expression;
}
if (locationInParent == Assignment.RIGHT_HAND_SIDE_PROPERTY || locationInParent == IfStatement.EXPRESSION_PROPERTY
|| locationInParent == WhileStatement.EXPRESSION_PROPERTY || locationInParent == DoStatement.EXPRESSION_PROPERTY
|| locationInParent == ReturnStatement.EXPRESSION_PROPERTY || locationInParent == ForStatement.EXPRESSION_PROPERTY
|| locationInParent == AssertStatement.EXPRESSION_PROPERTY || locationInParent == MethodInvocation.ARGUMENTS_PROPERTY
|| locationInParent == ConstructorInvocation.ARGUMENTS_PROPERTY || locationInParent == SuperMethodInvocation.ARGUMENTS_PROPERTY
|| locationInParent == EnumConstantDeclaration.ARGUMENTS_PROPERTY || locationInParent == SuperConstructorInvocation.ARGUMENTS_PROPERTY
|| locationInParent == ClassInstanceCreation.ARGUMENTS_PROPERTY || locationInParent == ConditionalExpression.EXPRESSION_PROPERTY
|| locationInParent == PrefixExpression.OPERAND_PROPERTY) {
return expression;
}
return null;
}
private boolean isLoop(CompositeStatementObject compositeStatement) {
if(compositeStatement.getStatement() instanceof WhileStatement ||
compositeStatement.getStatement() instanceof ForStatement ||
compositeStatement.getStatement() instanceof EnhancedForStatement)
return true;
return false;
}
protected boolean isInfixExpressionWithCompositeParent(ASTNode node) {
if(node instanceof InfixExpression &&
(node.getParent() instanceof IfStatement || node.getParent() instanceof InfixExpression ||
node.getParent() instanceof WhileStatement || node.getParent() instanceof DoStatement ||
node.getParent() instanceof ForStatement)) {
return true;
}
return false;
}
public boolean match(WhileStatement node, Object other) {
if (other instanceof WhileStatement)
{
WhileStatement o = (WhileStatement) other;
if(isNestedUnderAnonymousClassDeclaration(node) && isNestedUnderAnonymousClassDeclaration(o)) {
return super.match(node, o);
}
if ((safeSubtreeMatch(node.getExpression(), o.getExpression())))
{
return true;
}
}
AbstractLoop nodeConditionalLoop = new ConditionalLoop(node);
return loopMatch(nodeConditionalLoop, other);
}
public ConditionalLoop(WhileStatement whileStatement) {
super(whileStatement);
this.condition = whileStatement.getExpression();
Statement loopBody = whileStatement.getBody();
List<Expression> forUpdaters = new ArrayList<Expression>();
this.conditionControlVariables = generateConditionControlVariables(this.condition, loopBody, forUpdaters);
}
public boolean visit(WhileStatement stmnt) {
/*
* while ( Expression ) Statement
*/
styledString.append("while", new StyledStringStyler(keywordStyle));
appendSpace();
appendOpenParenthesis();
handleExpression((Expression) stmnt.getExpression());
appendClosedParenthesis();
return false;
}
public boolean process(Statement statement) {
// TODO : wait for completing ...
int start = _unit.getLineNumber(statement.getStartPosition());
int end = _unit.getLineNumber(statement.getStartPosition() + statement.getLength());
if (start <= _buggyLine && _buggyLine <= end) {
if (statement instanceof IfStatement || statement instanceof ForStatement
|| statement instanceof WhileStatement || statement instanceof DoStatement
|| statement instanceof EnhancedForStatement) {
_nodes.add(statement);
return false;
} else if(statement instanceof Block){
if(statement.getParent() instanceof IfStatement && (end - start) < Constant.MAX_BLOCK_LINE){
_nodes.add(statement.getParent());
return true;
}
Block block = (Block) statement;
for(Object object : block.statements()){
process((Statement)object);
}
} else if(statement instanceof SwitchStatement){
SwitchStatement switchStmt = (SwitchStatement) statement;
for(int i = 0; i < switchStmt.statements().size(); i++){
Statement stmt = (Statement) switchStmt.statements().get(i);
int s = _unit.getLineNumber(stmt.getStartPosition());
int e = _unit.getLineNumber(stmt.getStartPosition() + stmt.getLength());
if(s <= _buggyLine && _buggyLine <= e){
_nodes.add(stmt);
if(stmt instanceof SwitchCase){
for(int j = i + 1 ; j < switchStmt.statements().size(); j++){
Statement SC = (Statement) switchStmt.statements().get(j);
if(SC instanceof SwitchCase){
return false;
} else {
_nodes.add(SC);
}
}
} else {
_nodes.add(stmt);
return false;
}
}
}
} else {
_nodes.add(statement);
return false;
}
}
return true;
}
public boolean visit(WhileStatement node) {
whileStatements.add(node);
return true;
}
public List<WhileStatement> getWhileStatements() {
return whileStatements;
}