org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/matching/MemberDeclarationVisitor.java - aspectj/org.aspectj.shadows - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 2009 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.core.search.matching;

 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.jdt.core.IAnnotatable;
 import org.eclipse.jdt.core.IJavaElement;
 import org.eclipse.jdt.core.compiler.CharOperation;
 import org.eclipse.jdt.internal.compiler.ASTVisitor;
 import org.eclipse.jdt.internal.compiler.ast.*;
 import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
 import org.eclipse.jdt.internal.compiler.util.HashtableOfIntValues;
 import org.eclipse.jdt.internal.core.search.matching.MatchLocator.WrappedCoreException;

 /**
  * Specific visitor of field or method declaration which can identify and store
  * the local and  other elements of one or several matching nodes.
  * <p>
  * This visitor can also peek up local or anonymous type declaration and restart
  * a new {@link MatchLocator} traverse on this type.
  * </p>
  */
 class MemberDeclarationVisitor extends ASTVisitor {
 	// Matches information
 	private final MatchLocator locator;
 	private final IJavaElement enclosingElement;
 	private final MatchingNodeSet nodeSet;
 	private final ASTNode[] matchingNodes;
 	private final ASTNode matchingNode;

 	// Local type storage
 	HashtableOfIntValues occurrencesCounts = new HashtableOfIntValues(); // key = class name (char[]), value = occurrenceCount (int)
 	int nodesCount = 0;

 	// Local and other elements storage
 	private Annotation annotation;
 	private LocalDeclaration localDeclaration;
 	IJavaElement localElement;
 	IJavaElement[] localElements, otherElements;
 	IJavaElement[][] allOtherElements;
 	int ptr = -1;
 	int[] ptrs;

 public MemberDeclarationVisitor(IJavaElement element, ASTNode[] nodes, MatchingNodeSet set, MatchLocator locator) {
 	this.enclosingElement = element;
 	this.nodeSet = set;
 	this.locator = locator;
 	if (nodes == null) {
 		this.matchingNode = null;
 		this.matchingNodes = null;
 	} else {
 		this.nodesCount = nodes.length;
 		if (nodes.length == 1) {
 			this.matchingNode = nodes[0];
 			this.matchingNodes = null;
 		} else {
 			this.matchingNode = null;
 			this.matchingNodes = nodes;
 			this.localElements = new IJavaElement[this.nodesCount];
 			this.ptrs = new int[this.nodesCount];
 			this.allOtherElements = new IJavaElement[this.nodesCount][];
 		}
 	}
 }
 public void endVisit(Argument argument, BlockScope scope) {
     this.localDeclaration = null;
 }
 public void endVisit(LocalDeclaration declaration, BlockScope scope) {
     this.localDeclaration = null;
 }
 public void endVisit(MarkerAnnotation markerAnnotation, BlockScope unused) {
 	this.annotation = null;
 }
 public void endVisit(NormalAnnotation normalAnnotation, BlockScope unused) {
 	this.annotation = null;
 }
 public void endVisit(SingleMemberAnnotation singleMemberAnnotation, BlockScope unused) {
 	this.annotation = null;
 }
 IJavaElement getLocalElement(int idx) {
 	if (this.nodesCount == 1) {
 		return this.localElement;
 	}
 	if (this.localElements != null) {
 		return this.localElements[idx];
 	}
 	return null;
 }
 IJavaElement[] getOtherElements(int idx) {
 	if (this.nodesCount == 1) {
 		if (this.otherElements != null) {
 			int length = this.otherElements.length;
 			if (this.ptr < (length-1)) {
 				System.arraycopy(this.otherElements, 0, this.otherElements = new IJavaElement[this.ptr+1], 0, this.ptr+1);
 			}
 		}
 		return this.otherElements;
 	}
 	IJavaElement[] elements = this.allOtherElements == null ? null : this.allOtherElements[idx];
 	if (elements != null) {
 		int length = elements.length;
 		if (this.ptrs[idx] < (length-1)) {
 			System.arraycopy(elements, 0, elements = this.allOtherElements[idx] = new IJavaElement[this.ptrs[idx]+1], 0, this.ptrs[idx]+1);
 		}
 	}
 	return elements;
 }
 private int matchNode(ASTNode reference) {
 	if (this.matchingNode != null) {
 		if (this.matchingNode == reference) return 0;
 	} else {
 	    int length = this.matchingNodes.length;
 		for (int i=0; i<length; i++) {
 			if (this.matchingNodes[i] == reference)  { // == is intentional
 				return i;
 			}
 		}
 	}
 	return -1;
 }
 /*
  * Store the handle for the reference of the given index (e.g. peek in #matchingNodes
  * or #matchingNode).
  * Note that for performance reason, matching node and associated handles are
  * not stored in array when there's only one reference to identify.
  */
 private void storeHandle(int idx) {
 	if (this.localDeclaration == null) return;
 	IJavaElement handle = this.locator.createHandle(this.localDeclaration, this.enclosingElement);
     if (this.nodesCount == 1) {
     	if (this.localElement == null) {
     		if (this.annotation == null) {
 		    	this.localElement =  handle;
     		} else {
 		    	IJavaElement annotHandle = this.locator.createHandle(this.annotation, (IAnnotatable) handle);
 		    	if (annotHandle == null) {
 			    	annotHandle = this.locator.createHandle(this.annotation, (IAnnotatable) this.enclosingElement);
 		    	}
 		    	this.localElement = annotHandle == null ? handle : annotHandle;
     		}
     	} else {
 	    	if (++this.ptr == 0) {
 	    		this.otherElements = new IJavaElement[10];
 	    	} else {
 	            int length = this.otherElements.length;
 	            if (this.ptr == length) {
 	            	System.arraycopy(this.otherElements, 0, this.otherElements = new IJavaElement[length+10], 0, length);
 	            }
             }
     		if (this.annotation == null) {
 		    	this.otherElements[this.ptr] = handle;
     		} else {
 		    	IJavaElement annotHandle = this.locator.createHandle(this.annotation, (IAnnotatable) handle);
 		    	if (annotHandle == null) {
 			    	annotHandle = this.locator.createHandle(this.annotation, (IAnnotatable) this.enclosingElement);
 		    	}
 		    	this.otherElements[this.ptr] = annotHandle == null ? handle : annotHandle;
     		}
     	}
     } else {
     	if (this.localElements[idx] == null) {
 	    	if (this.annotation == null) {
 		    	this.localElements[idx] =  handle;
     		} else {
 		    	IJavaElement annotHandle = this.locator.createHandle(this.annotation, (IAnnotatable) handle);
 		    	if (annotHandle == null) {
 			    	annotHandle = this.locator.createHandle(this.annotation, (IAnnotatable) this.enclosingElement);
 		    	}
 		    	this.localElements[idx] = annotHandle == null ? handle : annotHandle;
     		}
 			this.ptrs[idx] = -1;
 	    } else {
 	        int oPtr = ++this.ptrs[idx];
 	    	if (oPtr== 0) {
     			this.allOtherElements[idx] = new IJavaElement[10];
     		} else {
             	int length = this.allOtherElements[idx].length;
 	            if (oPtr == length) {
 	            	System.arraycopy(this.allOtherElements[idx], 0, this.allOtherElements[idx] = new IJavaElement[length+10], 0, length);
         	    }
 	        }
 	    	if (this.annotation == null) {
 	 		   	this.allOtherElements[idx][oPtr] = handle;
     		} else {
 		    	IJavaElement annotHandle = this.locator.createHandle(this.annotation, (IAnnotatable) handle);
 		    	if (annotHandle == null) {
 			    	annotHandle = this.locator.createHandle(this.annotation, (IAnnotatable) this.enclosingElement);
 		    	}
 	 		   	this.allOtherElements[idx][oPtr] = annotHandle == null ? handle : annotHandle;
     		}
     	}
     }
 }
 public boolean visit(Argument argument, BlockScope scope) {
     this.localDeclaration = argument;
     return true;
 }
 public boolean visit(LocalDeclaration declaration, BlockScope scope) {
     this.localDeclaration = declaration;
     return true;
 }
 public boolean visit(MarkerAnnotation markerAnnotation, BlockScope unused) {
 	this.annotation = markerAnnotation;
 	return true;
 }
 public boolean visit(NormalAnnotation normalAnnotation, BlockScope unused) {
 	this.annotation = normalAnnotation;
 	return true;
 }
 public boolean visit(QualifiedNameReference nameReference, BlockScope unused) {
 	if (this.nodesCount > 0){
 		int idx = matchNode(nameReference);
 		if (idx >= 0) {
 			storeHandle(idx);
 		}
 	}
 	return false;
 }
 public boolean visit(QualifiedTypeReference typeReference, BlockScope unused) {
 	if (this.nodesCount > 0){
 		int idx = matchNode(typeReference);
 		if (idx >= 0) {
 			storeHandle(idx);
 		}
 	}
 	return false;
 }
 public boolean visit(SingleMemberAnnotation singleMemberAnnotation, BlockScope unused) {
 	this.annotation = singleMemberAnnotation;
 	return true;
 }
 public boolean visit(SingleNameReference nameReference, BlockScope unused) {
 	if (this.nodesCount > 0){
 		int idx = matchNode(nameReference);
 		if (idx >= 0) {
 			storeHandle(idx);
 		}
 	}
 	return false;
 }
 public boolean visit(SingleTypeReference typeReference, BlockScope unused) {
 	if (this.nodesCount > 0){
 		int idx = matchNode(typeReference);
 		if (idx >= 0) {
 			storeHandle(idx);
 		}
 	}
 	return false;
 }
 public boolean visit(TypeDeclaration typeDeclaration, BlockScope unused) {
 	try {
 		char[] simpleName;
 		if ((typeDeclaration.bits & ASTNode.IsAnonymousType) != 0) {
 			simpleName = CharOperation.NO_CHAR;
 		} else {
 			simpleName = typeDeclaration.name;
 		}
 		int occurrenceCount = this.occurrencesCounts.get(simpleName);
 		if (occurrenceCount == HashtableOfIntValues.NO_VALUE) {
 			occurrenceCount = 1;
 		} else {
 			occurrenceCount = occurrenceCount + 1;
 		}
 		this.occurrencesCounts.put(simpleName, occurrenceCount);
 		if ((typeDeclaration.bits & ASTNode.IsAnonymousType) != 0) {
 			this.locator.reportMatching(typeDeclaration, this.enclosingElement, -1, this.nodeSet, occurrenceCount);
 		} else {
 			Integer level = (Integer) this.nodeSet.matchingNodes.removeKey(typeDeclaration);
 			this.locator.reportMatching(typeDeclaration, this.enclosingElement, level != null ? level.intValue() : -1, this.nodeSet, occurrenceCount);
 		}
 		return false; // don't visit members as this was done during reportMatching(...)
 	} catch (CoreException e) {
 		throw new WrappedCoreException(e);
 	}
 }
 }
	/*******************************************************************************
	* Copyright (c) 2000, 2009 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.core.search.matching;

	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.jdt.core.IAnnotatable;
	import org.eclipse.jdt.core.IJavaElement;
	import org.eclipse.jdt.core.compiler.CharOperation;
	import org.eclipse.jdt.internal.compiler.ASTVisitor;
	import org.eclipse.jdt.internal.compiler.ast.*;
	import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
	import org.eclipse.jdt.internal.compiler.util.HashtableOfIntValues;
	import org.eclipse.jdt.internal.core.search.matching.MatchLocator.WrappedCoreException;

	/**
	* Specific visitor of field or method declaration which can identify and store
	* the local and other elements of one or several matching nodes.
	* <p>
	* This visitor can also peek up local or anonymous type declaration and restart
	* a new {@link MatchLocator} traverse on this type.
	* </p>
	*/
	class MemberDeclarationVisitor extends ASTVisitor {
	// Matches information
	private final MatchLocator locator;
	private final IJavaElement enclosingElement;
	private final MatchingNodeSet nodeSet;
	private final ASTNode[] matchingNodes;
	private final ASTNode matchingNode;

	// Local type storage
	HashtableOfIntValues occurrencesCounts = new HashtableOfIntValues(); // key = class name (char[]), value = occurrenceCount (int)
	int nodesCount = 0;

	// Local and other elements storage
	private Annotation annotation;
	private LocalDeclaration localDeclaration;
	IJavaElement localElement;
	IJavaElement[] localElements, otherElements;
	IJavaElement[][] allOtherElements;
	int ptr = -1;
	int[] ptrs;

	public MemberDeclarationVisitor(IJavaElement element, ASTNode[] nodes, MatchingNodeSet set, MatchLocator locator) {
	this.enclosingElement = element;
	this.nodeSet = set;
	this.locator = locator;
	if (nodes == null) {
	this.matchingNode = null;
	this.matchingNodes = null;
	} else {
	this.nodesCount = nodes.length;
	if (nodes.length == 1) {
	this.matchingNode = nodes[0];
	this.matchingNodes = null;
	} else {
	this.matchingNode = null;
	this.matchingNodes = nodes;
	this.localElements = new IJavaElement[this.nodesCount];
	this.ptrs = new int[this.nodesCount];
	this.allOtherElements = new IJavaElement[this.nodesCount][];
	}
	}
	}
	public void endVisit(Argument argument, BlockScope scope) {
	this.localDeclaration = null;
	}
	public void endVisit(LocalDeclaration declaration, BlockScope scope) {
	this.localDeclaration = null;
	}
	public void endVisit(MarkerAnnotation markerAnnotation, BlockScope unused) {
	this.annotation = null;
	}
	public void endVisit(NormalAnnotation normalAnnotation, BlockScope unused) {
	this.annotation = null;
	}
	public void endVisit(SingleMemberAnnotation singleMemberAnnotation, BlockScope unused) {
	this.annotation = null;
	}
	IJavaElement getLocalElement(int idx) {
	if (this.nodesCount == 1) {
	return this.localElement;
	}
	if (this.localElements != null) {
	return this.localElements[idx];
	}
	return null;
	}
	IJavaElement[] getOtherElements(int idx) {
	if (this.nodesCount == 1) {
	if (this.otherElements != null) {
	int length = this.otherElements.length;
	if (this.ptr < (length-1)) {
	System.arraycopy(this.otherElements, 0, this.otherElements = new IJavaElement[this.ptr+1], 0, this.ptr+1);
	}
	}
	return this.otherElements;
	}
	IJavaElement[] elements = this.allOtherElements == null ? null : this.allOtherElements[idx];
	if (elements != null) {
	int length = elements.length;
	if (this.ptrs[idx] < (length-1)) {
	System.arraycopy(elements, 0, elements = this.allOtherElements[idx] = new IJavaElement[this.ptrs[idx]+1], 0, this.ptrs[idx]+1);
	}
	}
	return elements;
	}
	private int matchNode(ASTNode reference) {
	if (this.matchingNode != null) {
	if (this.matchingNode == reference) return 0;
	} else {
	int length = this.matchingNodes.length;
	for (int i=0; i<length; i++) {
	if (this.matchingNodes[i] == reference) { // == is intentional
	return i;
	}
	}
	}
	return -1;
	}
	/*
	* Store the handle for the reference of the given index (e.g. peek in #matchingNodes
	* or #matchingNode).
	* Note that for performance reason, matching node and associated handles are
	* not stored in array when there's only one reference to identify.
	*/
	private void storeHandle(int idx) {
	if (this.localDeclaration == null) return;
	IJavaElement handle = this.locator.createHandle(this.localDeclaration, this.enclosingElement);
	if (this.nodesCount == 1) {
	if (this.localElement == null) {
	if (this.annotation == null) {
	this.localElement = handle;
	} else {
	IJavaElement annotHandle = this.locator.createHandle(this.annotation, (IAnnotatable) handle);
	if (annotHandle == null) {
	annotHandle = this.locator.createHandle(this.annotation, (IAnnotatable) this.enclosingElement);
	}
	this.localElement = annotHandle == null ? handle : annotHandle;
	}
	} else {
	if (++this.ptr == 0) {
	this.otherElements = new IJavaElement[10];
	} else {
	int length = this.otherElements.length;
	if (this.ptr == length) {
	System.arraycopy(this.otherElements, 0, this.otherElements = new IJavaElement[length+10], 0, length);
	}
	}
	if (this.annotation == null) {
	this.otherElements[this.ptr] = handle;
	} else {
	IJavaElement annotHandle = this.locator.createHandle(this.annotation, (IAnnotatable) handle);
	if (annotHandle == null) {
	annotHandle = this.locator.createHandle(this.annotation, (IAnnotatable) this.enclosingElement);
	}
	this.otherElements[this.ptr] = annotHandle == null ? handle : annotHandle;
	}
	}
	} else {
	if (this.localElements[idx] == null) {
	if (this.annotation == null) {
	this.localElements[idx] = handle;
	} else {
	IJavaElement annotHandle = this.locator.createHandle(this.annotation, (IAnnotatable) handle);
	if (annotHandle == null) {
	annotHandle = this.locator.createHandle(this.annotation, (IAnnotatable) this.enclosingElement);
	}
	this.localElements[idx] = annotHandle == null ? handle : annotHandle;
	}
	this.ptrs[idx] = -1;
	} else {
	int oPtr = ++this.ptrs[idx];
	if (oPtr== 0) {
	this.allOtherElements[idx] = new IJavaElement[10];
	} else {
	int length = this.allOtherElements[idx].length;
	if (oPtr == length) {
	System.arraycopy(this.allOtherElements[idx], 0, this.allOtherElements[idx] = new IJavaElement[length+10], 0, length);
	}
	}
	if (this.annotation == null) {
	this.allOtherElements[idx][oPtr] = handle;
	} else {
	IJavaElement annotHandle = this.locator.createHandle(this.annotation, (IAnnotatable) handle);
	if (annotHandle == null) {
	annotHandle = this.locator.createHandle(this.annotation, (IAnnotatable) this.enclosingElement);
	}
	this.allOtherElements[idx][oPtr] = annotHandle == null ? handle : annotHandle;
	}
	}
	}
	}
	public boolean visit(Argument argument, BlockScope scope) {
	this.localDeclaration = argument;
	return true;
	}
	public boolean visit(LocalDeclaration declaration, BlockScope scope) {
	this.localDeclaration = declaration;
	return true;
	}
	public boolean visit(MarkerAnnotation markerAnnotation, BlockScope unused) {
	this.annotation = markerAnnotation;
	return true;
	}
	public boolean visit(NormalAnnotation normalAnnotation, BlockScope unused) {
	this.annotation = normalAnnotation;
	return true;
	}
	public boolean visit(QualifiedNameReference nameReference, BlockScope unused) {
	if (this.nodesCount > 0){
	int idx = matchNode(nameReference);
	if (idx >= 0) {
	storeHandle(idx);
	}
	}
	return false;
	}
	public boolean visit(QualifiedTypeReference typeReference, BlockScope unused) {
	if (this.nodesCount > 0){
	int idx = matchNode(typeReference);
	if (idx >= 0) {
	storeHandle(idx);
	}
	}
	return false;
	}
	public boolean visit(SingleMemberAnnotation singleMemberAnnotation, BlockScope unused) {
	this.annotation = singleMemberAnnotation;
	return true;
	}
	public boolean visit(SingleNameReference nameReference, BlockScope unused) {
	if (this.nodesCount > 0){
	int idx = matchNode(nameReference);
	if (idx >= 0) {
	storeHandle(idx);
	}
	}
	return false;
	}
	public boolean visit(SingleTypeReference typeReference, BlockScope unused) {
	if (this.nodesCount > 0){
	int idx = matchNode(typeReference);
	if (idx >= 0) {
	storeHandle(idx);
	}
	}
	return false;
	}
	public boolean visit(TypeDeclaration typeDeclaration, BlockScope unused) {
	try {
	char[] simpleName;
	if ((typeDeclaration.bits & ASTNode.IsAnonymousType) != 0) {
	simpleName = CharOperation.NO_CHAR;
	} else {
	simpleName = typeDeclaration.name;
	}
	int occurrenceCount = this.occurrencesCounts.get(simpleName);
	if (occurrenceCount == HashtableOfIntValues.NO_VALUE) {
	occurrenceCount = 1;
	} else {
	occurrenceCount = occurrenceCount + 1;
	}
	this.occurrencesCounts.put(simpleName, occurrenceCount);
	if ((typeDeclaration.bits & ASTNode.IsAnonymousType) != 0) {
	this.locator.reportMatching(typeDeclaration, this.enclosingElement, -1, this.nodeSet, occurrenceCount);
	} else {
	Integer level = (Integer) this.nodeSet.matchingNodes.removeKey(typeDeclaration);
	this.locator.reportMatching(typeDeclaration, this.enclosingElement, level != null ? level.intValue() : -1, this.nodeSet, occurrenceCount);
	}
	return false; // don't visit members as this was done during reportMatching(...)
	} catch (CoreException e) {
	throw new WrappedCoreException(e);
	}
	}
	}