org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/search/BreakContinueTargetFinder.java - jdt/eclipse.jdt.ui - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 2011 IBM Corporation 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:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.jdt.internal.ui.search;

 import java.util.ArrayList;
 import java.util.List;

 import org.eclipse.core.runtime.CoreException;

 import org.eclipse.jdt.core.JavaModelException;
 import org.eclipse.jdt.core.dom.ASTNode;
 import org.eclipse.jdt.core.dom.ASTVisitor;
 import org.eclipse.jdt.core.dom.BreakStatement;
 import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jdt.core.dom.ContinueStatement;
 import org.eclipse.jdt.core.dom.DoStatement;
 import org.eclipse.jdt.core.dom.EnhancedForStatement;
 import org.eclipse.jdt.core.dom.ForStatement;
 import org.eclipse.jdt.core.dom.Initializer;
 import org.eclipse.jdt.core.dom.LabeledStatement;
 import org.eclipse.jdt.core.dom.MethodDeclaration;
 import org.eclipse.jdt.core.dom.NodeFinder;
 import org.eclipse.jdt.core.dom.SimpleName;
 import org.eclipse.jdt.core.dom.SwitchStatement;
 import org.eclipse.jdt.core.dom.WhileStatement;

 import org.eclipse.jdt.internal.corext.dom.ASTNodes;
 import org.eclipse.jdt.internal.corext.dom.TokenScanner;
 import org.eclipse.jdt.internal.corext.util.Messages;

 import org.eclipse.jdt.internal.ui.viewsupport.BasicElementLabels;


 /**
  * Class used to find the target for a break or continue statement according
  * to the language specification.
  * <p>
  * The target statement is a while, do, switch, for or a labeled statement.
  * Break is described in section 14.15 of the JLS3 and continue in section 14.16.</p>
  *
  * @since 3.2
  */
 public class BreakContinueTargetFinder extends ASTVisitor implements IOccurrencesFinder {

 	public static final String ID= "BreakContinueTargetFinder"; //$NON-NLS-1$

 	private ASTNode fSelected;
 	private boolean fIsBreak;
 	private SimpleName fLabel;
 	private String fDescription;
 	private CompilationUnit fASTRoot;

 	private static final Class<?>[] STOPPERS=        {MethodDeclaration.class, Initializer.class};
 	private static final Class<?>[] BREAKTARGETS=    {ForStatement.class, EnhancedForStatement.class, WhileStatement.class, DoStatement.class, SwitchStatement.class};
 	private static final Class<?>[] CONTINUETARGETS= {ForStatement.class, EnhancedForStatement.class, WhileStatement.class, DoStatement.class};
 	private static final int BRACE_LENGTH= 1;

 	/*
 	 * Initializes the finder. Returns error message or <code>null</code> if everything is OK.
 	 */
 	public String initialize(CompilationUnit root, int offset, int length) {
 		return initialize(root, NodeFinder.perform(root, offset, length));
 	}

 	/*
 	 * Initializes the finder. Returns error message or <code>null</code> if everything is OK.
 	 */
 	public String initialize(CompilationUnit root, ASTNode node) {
 		ASTNode controlNode= getBreakOrContinueNode(node);
 		if (controlNode != null) {
 			fASTRoot= root;

 			try {
 				if (root.getTypeRoot() == null || root.getTypeRoot().getBuffer() == null)
 					return SearchMessages.BreakContinueTargetFinder_cannot_highlight;
 			} catch (JavaModelException e) {
 				return SearchMessages.BreakContinueTargetFinder_cannot_highlight;
 			}
 			fSelected= controlNode;
 			fIsBreak= fSelected instanceof BreakStatement;
 			fLabel= getLabel();
 			fDescription= Messages.format(SearchMessages.BreakContinueTargetFinder_occurrence_description, BasicElementLabels.getJavaElementName(ASTNodes.asString(fSelected)));
 			return null;
 		} else {
 			return SearchMessages.BreakContinueTargetFinder_no_break_or_continue_selected;
 		}
 	}


 	//extract the control node: handle labels
 	private ASTNode getBreakOrContinueNode(ASTNode selectedNode) {
 		if (selectedNode instanceof BreakStatement)
 			return selectedNode;
 		if (selectedNode instanceof ContinueStatement)
 			return selectedNode;
 		if (selectedNode instanceof SimpleName && selectedNode.getParent() instanceof BreakStatement)
 			return selectedNode.getParent();
 		if (selectedNode instanceof SimpleName && selectedNode.getParent() instanceof ContinueStatement)
 			return selectedNode.getParent();
 		return null;
 	}


 	private SimpleName getLabel() {
 		if (fIsBreak){
 			BreakStatement bs= (BreakStatement) fSelected;
 			return bs.getLabel();
 		} else {
 			ContinueStatement cs= (ContinueStatement) fSelected;
 			return cs.getLabel();
 		}
 	}

 	/**
 	 * Returns the locations of all occurrences or <code>null</code> if no matches are found
 	 *
 	 * @return the locations of all occurrences or <code>null</code> if no matches are found
 	 */
 	public OccurrenceLocation[] getOccurrences() {
 		ASTNode targetNode= findTargetNode(fSelected);
 		if (!isEnclosingStatement(targetNode))
 			return null;

 		List<OccurrenceLocation> list= new ArrayList<OccurrenceLocation>();
 		OccurrenceLocation location= getLocationForFirstToken(targetNode);
 		if (location != null) {
 			list.add(location);
 		}
 		if (fIsBreak) {
 			location= getLocationForClosingBrace(targetNode);
 			if (location != null) {
 				list.add(location);
 			}
 		}
 		if (!list.isEmpty()) {
 			return list.toArray(new OccurrenceLocation[list.size()]);
 		}
 		return null;
 	}

 	private boolean isEnclosingStatement(ASTNode targetNode) {
 		return (targetNode != null) && !(targetNode instanceof MethodDeclaration) && !(targetNode instanceof Initializer);
 	}

 	private ASTNode findTargetNode(ASTNode node) {
 		do {
 			node= node.getParent();
 		} while (keepWalkingUp(node));
 		return node;
 	}

 	private OccurrenceLocation getLocationForFirstToken(ASTNode node) {
 		try {
 			int nextEndOffset= new TokenScanner(fASTRoot.getTypeRoot()).getNextEndOffset(node.getStartPosition(), true);
 			return new OccurrenceLocation(node.getStartPosition(), nextEndOffset - node.getStartPosition(), 0, fDescription);
 		} catch (CoreException e) {
 			// ignore
 		}
 		return new OccurrenceLocation(node.getStartPosition(), node.getLength(), 0, fDescription);
 	}

 	private OccurrenceLocation getLocationForClosingBrace(ASTNode targetNode) {
 		/* Ideally, we'd scan backwards to find the '}' token, but it may be an overkill
 		 * so I'll just assume the closing brace token has a fixed length. */
 		int offset= ASTNodes.getExclusiveEnd(targetNode) - BRACE_LENGTH;
 		return new OccurrenceLocation(offset, BRACE_LENGTH, 0, fDescription);
 	}

 	private boolean keepWalkingUp(ASTNode node) {
 		if (node == null)
 			return false;
 		if (isAnyInstanceOf(STOPPERS, node))
 			return false;
 		if (fLabel != null && LabeledStatement.class.isInstance(node)){
 			LabeledStatement ls= (LabeledStatement)node;
 			return ! areEqualLabels(ls.getLabel(), fLabel);
 		}
 		if (fLabel == null) {
 			if (isAnyInstanceOf(fIsBreak ? BREAKTARGETS : CONTINUETARGETS, node))
 				return node.getParent() instanceof LabeledStatement; // for behavior consistency of break targets: see bug 339176
 			if (node instanceof LabeledStatement)
 				return false;
 		}
 		return true;
 	}

 	private static boolean areEqualLabels(SimpleName labelToMatch, SimpleName labelSelected) {
 		return labelSelected.getIdentifier().equals(labelToMatch.getIdentifier());
 	}

 	private static boolean isAnyInstanceOf(Class<?>[] continueTargets, ASTNode node) {
 		for (int i= 0; i < continueTargets.length; i++) {
 			if (continueTargets[i].isInstance(node))
 				return true;
 		}
 		return false;
 	}

 	public CompilationUnit getASTRoot() {
 		return fASTRoot;
 	}

 	public String getElementName() {
 		return ASTNodes.asString(fSelected);
 	}

 	public String getID() {
 		return ID;
 	}

 	public String getJobLabel() {
 		return SearchMessages.BreakContinueTargetFinder_job_label;
 	}

 	public int getSearchKind() {
 		return IOccurrencesFinder.K_BREAK_TARGET_OCCURRENCE;
 	}

 	public String getUnformattedPluralLabel() {
 		if (fIsBreak) {
 			return SearchMessages.BreakContinueTargetFinder_break_label_plural;
 		} else {
 			return SearchMessages.BreakContinueTargetFinder_continue_label_plural;
 		}
 	}

 	public String getUnformattedSingularLabel() {
 		if (fIsBreak) {
 			return SearchMessages.BreakContinueTargetFinder_break_label_singular;
 		} else {
 			return SearchMessages.BreakContinueTargetFinder_continue_label_singular;
 		}
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2000, 2011 IBM Corporation 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:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/
	package org.eclipse.jdt.internal.ui.search;

	import java.util.ArrayList;
	import java.util.List;

	import org.eclipse.core.runtime.CoreException;

	import org.eclipse.jdt.core.JavaModelException;
	import org.eclipse.jdt.core.dom.ASTNode;
	import org.eclipse.jdt.core.dom.ASTVisitor;
	import org.eclipse.jdt.core.dom.BreakStatement;
	import org.eclipse.jdt.core.dom.CompilationUnit;
	import org.eclipse.jdt.core.dom.ContinueStatement;
	import org.eclipse.jdt.core.dom.DoStatement;
	import org.eclipse.jdt.core.dom.EnhancedForStatement;
	import org.eclipse.jdt.core.dom.ForStatement;
	import org.eclipse.jdt.core.dom.Initializer;
	import org.eclipse.jdt.core.dom.LabeledStatement;
	import org.eclipse.jdt.core.dom.MethodDeclaration;
	import org.eclipse.jdt.core.dom.NodeFinder;
	import org.eclipse.jdt.core.dom.SimpleName;
	import org.eclipse.jdt.core.dom.SwitchStatement;
	import org.eclipse.jdt.core.dom.WhileStatement;

	import org.eclipse.jdt.internal.corext.dom.ASTNodes;
	import org.eclipse.jdt.internal.corext.dom.TokenScanner;
	import org.eclipse.jdt.internal.corext.util.Messages;

	import org.eclipse.jdt.internal.ui.viewsupport.BasicElementLabels;


	/**
	* Class used to find the target for a break or continue statement according
	* to the language specification.
	* <p>
	* The target statement is a while, do, switch, for or a labeled statement.
	* Break is described in section 14.15 of the JLS3 and continue in section 14.16.</p>
	*
	* @since 3.2
	*/
	public class BreakContinueTargetFinder extends ASTVisitor implements IOccurrencesFinder {

	public static final String ID= "BreakContinueTargetFinder"; //$NON-NLS-1$

	private ASTNode fSelected;
	private boolean fIsBreak;
	private SimpleName fLabel;
	private String fDescription;
	private CompilationUnit fASTRoot;

	private static final Class<?>[] STOPPERS= {MethodDeclaration.class, Initializer.class};
	private static final Class<?>[] BREAKTARGETS= {ForStatement.class, EnhancedForStatement.class, WhileStatement.class, DoStatement.class, SwitchStatement.class};
	private static final Class<?>[] CONTINUETARGETS= {ForStatement.class, EnhancedForStatement.class, WhileStatement.class, DoStatement.class};
	private static final int BRACE_LENGTH= 1;

	/*
	* Initializes the finder. Returns error message or <code>null</code> if everything is OK.
	*/
	public String initialize(CompilationUnit root, int offset, int length) {
	return initialize(root, NodeFinder.perform(root, offset, length));
	}

	/*
	* Initializes the finder. Returns error message or <code>null</code> if everything is OK.
	*/
	public String initialize(CompilationUnit root, ASTNode node) {
	ASTNode controlNode= getBreakOrContinueNode(node);
	if (controlNode != null) {
	fASTRoot= root;

	try {
	if (root.getTypeRoot() == null \|\| root.getTypeRoot().getBuffer() == null)
	return SearchMessages.BreakContinueTargetFinder_cannot_highlight;
	} catch (JavaModelException e) {
	return SearchMessages.BreakContinueTargetFinder_cannot_highlight;
	}
	fSelected= controlNode;
	fIsBreak= fSelected instanceof BreakStatement;
	fLabel= getLabel();
	fDescription= Messages.format(SearchMessages.BreakContinueTargetFinder_occurrence_description, BasicElementLabels.getJavaElementName(ASTNodes.asString(fSelected)));
	return null;
	} else {
	return SearchMessages.BreakContinueTargetFinder_no_break_or_continue_selected;
	}
	}


	//extract the control node: handle labels
	private ASTNode getBreakOrContinueNode(ASTNode selectedNode) {
	if (selectedNode instanceof BreakStatement)
	return selectedNode;
	if (selectedNode instanceof ContinueStatement)
	return selectedNode;
	if (selectedNode instanceof SimpleName && selectedNode.getParent() instanceof BreakStatement)
	return selectedNode.getParent();
	if (selectedNode instanceof SimpleName && selectedNode.getParent() instanceof ContinueStatement)
	return selectedNode.getParent();
	return null;
	}


	private SimpleName getLabel() {
	if (fIsBreak){
	BreakStatement bs= (BreakStatement) fSelected;
	return bs.getLabel();
	} else {
	ContinueStatement cs= (ContinueStatement) fSelected;
	return cs.getLabel();
	}
	}

	/**
	* Returns the locations of all occurrences or <code>null</code> if no matches are found
	*
	* @return the locations of all occurrences or <code>null</code> if no matches are found
	*/
	public OccurrenceLocation[] getOccurrences() {
	ASTNode targetNode= findTargetNode(fSelected);
	if (!isEnclosingStatement(targetNode))
	return null;

	List<OccurrenceLocation> list= new ArrayList<OccurrenceLocation>();
	OccurrenceLocation location= getLocationForFirstToken(targetNode);
	if (location != null) {
	list.add(location);
	}
	if (fIsBreak) {
	location= getLocationForClosingBrace(targetNode);
	if (location != null) {
	list.add(location);
	}
	}
	if (!list.isEmpty()) {
	return list.toArray(new OccurrenceLocation[list.size()]);
	}
	return null;
	}

	private boolean isEnclosingStatement(ASTNode targetNode) {
	return (targetNode != null) && !(targetNode instanceof MethodDeclaration) && !(targetNode instanceof Initializer);
	}

	private ASTNode findTargetNode(ASTNode node) {
	do {
	node= node.getParent();
	} while (keepWalkingUp(node));
	return node;
	}

	private OccurrenceLocation getLocationForFirstToken(ASTNode node) {
	try {
	int nextEndOffset= new TokenScanner(fASTRoot.getTypeRoot()).getNextEndOffset(node.getStartPosition(), true);
	return new OccurrenceLocation(node.getStartPosition(), nextEndOffset - node.getStartPosition(), 0, fDescription);
	} catch (CoreException e) {
	// ignore
	}
	return new OccurrenceLocation(node.getStartPosition(), node.getLength(), 0, fDescription);
	}

	private OccurrenceLocation getLocationForClosingBrace(ASTNode targetNode) {
	/* Ideally, we'd scan backwards to find the '}' token, but it may be an overkill
	* so I'll just assume the closing brace token has a fixed length. */
	int offset= ASTNodes.getExclusiveEnd(targetNode) - BRACE_LENGTH;
	return new OccurrenceLocation(offset, BRACE_LENGTH, 0, fDescription);
	}

	private boolean keepWalkingUp(ASTNode node) {
	if (node == null)
	return false;
	if (isAnyInstanceOf(STOPPERS, node))
	return false;
	if (fLabel != null && LabeledStatement.class.isInstance(node)){
	LabeledStatement ls= (LabeledStatement)node;
	return ! areEqualLabels(ls.getLabel(), fLabel);
	}
	if (fLabel == null) {
	if (isAnyInstanceOf(fIsBreak ? BREAKTARGETS : CONTINUETARGETS, node))
	return node.getParent() instanceof LabeledStatement; // for behavior consistency of break targets: see bug 339176
	if (node instanceof LabeledStatement)
	return false;
	}
	return true;
	}

	private static boolean areEqualLabels(SimpleName labelToMatch, SimpleName labelSelected) {
	return labelSelected.getIdentifier().equals(labelToMatch.getIdentifier());
	}

	private static boolean isAnyInstanceOf(Class<?>[] continueTargets, ASTNode node) {
	for (int i= 0; i < continueTargets.length; i++) {
	if (continueTargets[i].isInstance(node))
	return true;
	}
	return false;
	}

	public CompilationUnit getASTRoot() {
	return fASTRoot;
	}

	public String getElementName() {
	return ASTNodes.asString(fSelected);
	}

	public String getID() {
	return ID;
	}

	public String getJobLabel() {
	return SearchMessages.BreakContinueTargetFinder_job_label;
	}

	public int getSearchKind() {
	return IOccurrencesFinder.K_BREAK_TARGET_OCCURRENCE;
	}

	public String getUnformattedPluralLabel() {
	if (fIsBreak) {
	return SearchMessages.BreakContinueTargetFinder_break_label_plural;
	} else {
	return SearchMessages.BreakContinueTargetFinder_continue_label_plural;
	}
	}

	public String getUnformattedSingularLabel() {
	if (fIsBreak) {
	return SearchMessages.BreakContinueTargetFinder_break_label_singular;
	} else {
	return SearchMessages.BreakContinueTargetFinder_continue_label_singular;
	}
	}
	}