Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright (c) 2000, 2012 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;
 
 public class ConstructorLocator extends PatternLocator {
 
 
 	super(pattern);
 
 	this. = pattern;
 }
 public int match(ASTNode nodeMatchingNodeSet nodeSet) { // interested in ExplicitConstructorCall
 	if (!this..return ;
 	if (!(node instanceof ExplicitConstructorCall)) return ;
 
 
 	return nodeSet.addMatch(nodethis.. ?  : );
 }
 public int match(ConstructorDeclaration nodeMatchingNodeSet nodeSet) {
 	int referencesLevel = this.. ? matchLevelForReferences(node) : ;
 	int declarationsLevel = this.. ? matchLevelForDeclarations(node) : ;
 
 	return nodeSet.addMatch(nodereferencesLevel >= declarationsLevel ? referencesLevel : declarationsLevel); // use the stronger match
 }
 public int match(Expression nodeMatchingNodeSet nodeSet) { // interested in AllocationExpression
 	if (!this..return ;
 	if (!(node instanceof AllocationExpression)) return ;
 
 	// constructor name is simple type name
 	AllocationExpression allocation = (AllocationExpressionnode;
 	char[][] typeName = allocation.type.getTypeName();
 	if (this.. != null && !matchesName(this..typeName[typeName.length-1]))
 		return ;
 
 	if (!matchParametersCount(nodeallocation.arguments)) return ;
 
 	return nodeSet.addMatch(nodethis.. ?  : );
 }
 public int match(FieldDeclaration fieldMatchingNodeSet nodeSet) {
 	if (!this..return ;
 	// look only for enum constant
 	if (field.type != null || !(field.initialization instanceof AllocationExpression)) return ;
 
 	AllocationExpression allocation = (AllocationExpressionfield.initialization;
 	if (field.binding != null && field.binding.declaringClass != null) {
 		if (this.. != null && !matchesName(this..field.binding.declaringClass.sourceName()))
 			return ;
 	}
 
 	if (!matchParametersCount(fieldallocation.arguments)) return ;
 
 	return nodeSet.addMatch(fieldthis.. ?  : );
 }
 //public int match(MethodDeclaration node, MatchingNodeSet nodeSet) - SKIP IT
Special case for message send in javadoc comment. They can be in fact bound to a constructor.

See also:
"http://bugs.eclipse.org/bugs/show_bug.cgi?id=83285"
 
 public int match(MessageSend msgSendMatchingNodeSet nodeSet)  {
 	if ((msgSend.bits & .) == 0) return ;
 	if (!this..return ;
 	if (this.. == null || CharOperation.equals(msgSend.selectorthis..)) {
 		return nodeSet.addMatch(msgSendthis.. ?  : );
 	}
 	return ;
 }
 //public int match(Reference node, MatchingNodeSet nodeSet) - SKIP IT
 public int match(TypeDeclaration nodeMatchingNodeSet nodeSet) {
 	if (!this..return ;
 
 	// need to look for a generated default constructor
 	return nodeSet.addMatch(nodethis.. ?  : );
 }
 //public int match(TypeReference node, MatchingNodeSet nodeSet) - SKIP IT
 
protected int matchConstructor(MethodBinding constructor) {
	if (!constructor.isConstructor()) return ;
	// declaring type, simple name has already been matched by matchIndexEntry()
	int level = resolveLevelForType(this..this..constructor.declaringClass);
	if (level == return ;
	// parameter types
	int parameterCount = this..;
	if (parameterCount > -1) {
		if (constructor.parameters == nullreturn ;
		if (parameterCount != constructor.parameters.lengthreturn ;
		for (int i = 0; i < parameterCounti++) {
			// TODO (frederic) use this call to refine accuracy on parameter types
//			int newLevel = resolveLevelForType(this.pattern.parameterSimpleNames[i], this.pattern.parameterQualifications[i], this.pattern.parametersTypeArguments[i], 0, constructor.parameters[i]);
			int newLevel = resolveLevelForType(this..[i], this..[i], constructor.parameters[i]);
			if (level > newLevel) {
				if (newLevel == ) {
//					if (isErasureMatch) {
//						return ERASURE_MATCH;
//					}
				}
				level = newLevel// can only be downgraded
			}
		}
	}
	return level;
protected int matchContainer() {
	if (this..return // handles both declarations + references & just references
	// COMPILATION_UNIT_CONTAINER - implicit constructor call: case of Y extends X and Y doesn't define any constructor
	// CLASS_CONTAINER - implicit constructor call: case of constructor declaration with no explicit super call
	// METHOD_CONTAINER - reference in another constructor
	// FIELD_CONTAINER - anonymous in a field initializer
	// declarations are only found in Class
protected int matchLevelForReferences(ConstructorDeclaration constructor) {
	ExplicitConstructorCall constructorCall = constructor.constructorCall;
	if (constructorCall == null || constructorCall.accessMode != .)
	if (this.. != null) {
		int length = this...length;
		Expression[] args = constructorCall.arguments;
		int argsLength = args == null ? 0 : args.length;
		if (length != argsLengthreturn ;
	}
protected int matchLevelForDeclarations(ConstructorDeclaration constructor) {
	// constructor name is stored in selector field
	if (this.. != null && !matchesName(this..constructor.selector))
	if (this.. != null) {
		int length = this...length;
		Argument[] args = constructor.arguments;
		int argsLength = args == null ? 0 : args.length;
		if (length != argsLengthreturn ;
	}
	// Verify type arguments (do not reject if pattern has no argument as it can be an erasure match)
		if (constructor.typeParameters == null || constructor.typeParameters.length != this...lengthreturn ;
	}
boolean matchParametersCount(ASTNode nodeExpression[] args) {
	if (this.. != null && (!this.. || ((node.bits & .) != 0))) {
		int length = this..;
		if (length < 0) length = this...length;
		int argsLength = args == null ? 0 : args.length;
		if (length != argsLength) {
			return false;
		}
	}
	return true;
protected void matchReportReference(ASTNode referenceIJavaElement elementBinding elementBindingint accuracyMatchLocator locatorthrows CoreException {
	MethodBinding constructorBinding = null;
	boolean isSynthetic = false;
	if (reference instanceof ExplicitConstructorCall) {
		isSynthetic = call.isImplicitSuper();
		constructorBinding = call.binding;
else if (reference instanceof AllocationExpression) {
		constructorBinding = alloc.binding;
else if (reference instanceof TypeDeclaration || reference instanceof FieldDeclaration) {
		super.matchReportReference(referenceelementelementBindingaccuracylocator);
		if (this. != nullreturn;
	}
	// Create search match
	this. = locator.newMethodReferenceMatch(elementelementBindingaccuracy, -1, -1, trueisSyntheticreference);
	// Look to refine accuracy
	if (constructorBinding instanceof ParameterizedGenericMethodBinding) { // parameterized generic method
		// Update match regarding constructor type arguments
		ParameterizedGenericMethodBinding parameterizedMethodBinding = (ParameterizedGenericMethodBindingconstructorBinding;
		this..setRaw(parameterizedMethodBinding.isRaw);
		TypeBinding[] typeBindings = parameterizedMethodBinding.isRaw ? null : parameterizedMethodBinding.typeArguments;
		// Update match regarding declaring class type arguments
		if (constructorBinding.declaringClass.isParameterizedType() || constructorBinding.declaringClass.isRawType()) {
			ParameterizedTypeBinding parameterizedBinding = (ParameterizedTypeBinding)constructorBinding.declaringClass;
			if (!this..hasTypeArguments() && this..hasConstructorArguments() || parameterizedBinding.isParameterizedWithOwnVariables()) {
				// special case for constructor pattern which defines arguments but no type
				// in this case, we only use refined accuracy for constructor
else if (this..hasTypeArguments() && !this..hasConstructorArguments()) {
				// special case for constructor pattern which defines no constructor arguments but has type ones
				// in this case, we do not use refined accuracy
				updateMatch(parameterizedBindingthis..getTypeArguments(), this..hasTypeParameters(), 0, locator);
else {
				updateMatch(parameterizedBindingthis..getTypeArguments(), this..hasTypeParameters(), 0, locator);
			}
else if (this..hasTypeArguments()) {
		}
		// Update match regarding constructor parameters
		// TODO ? (frederic)
else if (constructorBinding instanceof ParameterizedMethodBinding) {
		// Update match regarding declaring class type arguments
		if (constructorBinding.declaringClass.isParameterizedType() || constructorBinding.declaringClass.isRawType()) {
			ParameterizedTypeBinding parameterizedBinding = (ParameterizedTypeBinding)constructorBinding.declaringClass;
				// special case for constructor pattern which defines arguments but no type
				updateMatch(parameterizedBindingnew char[][][] {this..}, this..hasTypeParameters(), 0, locator);
else if (!parameterizedBinding.isParameterizedWithOwnVariables()) {
				updateMatch(parameterizedBindingthis..getTypeArguments(), this..hasTypeParameters(), 0, locator);
			}
else if (this..hasTypeArguments()) {
		}
		// Update match regarding constructor parameters
		// TODO ? (frederic)
else if (this..hasConstructorArguments()) { // binding has no type params, compatible erasure if pattern does
	}
	// See whether it is necessary to report or not
	if (this..getRule() == 0) return// impossible match
	boolean report = (this. && this..isErasure()) || (this. && this..isEquivalent()) || this..isExact();
	if (!reportreturn;
	// Report match
	int offset = reference.sourceStart;
	this..setOffset(offset);
	this..setLength(reference.sourceEnd - offset + 1);
	if (reference instanceof FieldDeclaration) { // enum declaration
		FieldDeclaration enumConstant  = (FieldDeclarationreference;
		if (enumConstant.initialization instanceof QualifiedAllocationExpression) {
			locator.reportAccurateEnumConstructorReference(this.enumConstant, (QualifiedAllocationExpressionenumConstant.initialization);
			return;
		}
	}
	locator.report(this.);
public SearchMatch newDeclarationMatch(ASTNode referenceIJavaElement elementBinding bindingint accuracyint lengthMatchLocator locator) {
	this. = null;
	int offset = reference.sourceStart;
	if (this..) {
		if (reference instanceof TypeDeclaration) {
			TypeDeclaration type = (TypeDeclarationreference;
			AbstractMethodDeclaration[] methods = type.methods;
			if (methods != null) {
				for (int i = 0, max = methods.lengthi < maxi++) {
					AbstractMethodDeclaration method = methods[i];
					boolean synthetic = method.isDefaultConstructor() && method.sourceStart < type.bodyStart;
					this. = locator.newMethodReferenceMatch(elementbindingaccuracyoffsetlengthmethod.isConstructor(), syntheticmethod);
				}
			}
else if (reference instanceof ConstructorDeclaration) {
			ConstructorDeclaration constructor = (ConstructorDeclarationreference;
			ExplicitConstructorCall call = constructor.constructorCall;
			boolean synthetic = call != null && call.isImplicitSuper();
			this. = locator.newMethodReferenceMatch(elementbindingaccuracyoffsetlengthconstructor.isConstructor(), syntheticconstructor);
		}
	}
	if (this. != null) {
		return this.;
	}
	// super implementation...
    return locator.newDeclarationMatch(elementbindingaccuracyreference.sourceStartlength);
public int resolveLevel(ASTNode node) {
	if (this..) {
		if (node instanceof AllocationExpression)
		if (node instanceof ExplicitConstructorCall)
		if (node instanceof TypeDeclaration)
			return resolveLevel((TypeDeclarationnode);
		if (node instanceof FieldDeclaration)
		if (node instanceof JavadocMessageSend) {
		}
	}
	if (node instanceof ConstructorDeclaration)
		return resolveLevel((ConstructorDeclarationnodetrue);
protected int referenceType() {
protected int resolveLevel(AllocationExpression allocation) {
	// constructor name is simple type name
	char[][] typeName = allocation.type.getTypeName();
	if (this.. != null && !matchesName(this..typeName[typeName.length-1]))
	return resolveLevel(allocation.binding);
protected int resolveLevel(FieldDeclaration field) {
	// only accept enum constants
	if (field.type != null || field.binding == nullreturn ;
	if (this.. != null && !matchesName(this..field.binding.type.sourceName()))
	if (!(field.initialization instanceof AllocationExpression) || field.initialization.resolvedType.isLocalType()) return ;
	return resolveLevel(((AllocationExpression)field.initialization).);
public int resolveLevel(Binding binding) {
	if (binding == nullreturn ;
	if (!(binding instanceof MethodBinding)) return ;
	MethodBinding constructor = (MethodBindingbinding;
	int levelmatchConstructor(constructor);
	if (level== ) {
		if (constructor != constructor.original()) {
			levelmatchConstructor(constructor.original());
		}
	}
	return level;
protected int resolveLevel(ConstructorDeclaration constructorboolean checkDeclarations) {
	int referencesLevel = ;
	if (this..) {
		ExplicitConstructorCall constructorCall = constructor.constructorCall;
		if (constructorCall != null && constructorCall.accessMode == .) {
			// eliminate explicit super call as it will be treated with matchLevel(ExplicitConstructorCall, boolean)
			int callCount = (constructorCall.arguments == null) ? 0 : constructorCall.arguments.length;
			int patternCount = (this.. == null) ? 0 : this...length;
			if (patternCount != callCount) {
				referencesLevel = ;
else {
				referencesLevel = resolveLevel(constructorCall.binding);
				if (referencesLevel == return // cannot get better
			}
		}
	}
	if (!checkDeclarationsreturn referencesLevel;
	int declarationsLevel = this.. ? resolveLevel(constructor.binding) : ;
	return referencesLevel >= declarationsLevel ? referencesLevel : declarationsLevel// answer the stronger match
protected int resolveLevel(TypeDeclaration type) {
	// find default constructor
	AbstractMethodDeclaration[] methods = type.methods;
	if (methods != null) {
		for (int i = 0, length = methods.lengthi < lengthi++) {
			AbstractMethodDeclaration method = methods[i];
			if (method.isDefaultConstructor() && method.sourceStart < type.bodyStart// if synthetic
				return resolveLevel((ConstructorDeclarationmethodfalse);
		}
	}
public String toString() {
	return "Locator for " + this..toString(); //$NON-NLS-1$
New to GrepCode? Check out our FAQ X