org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/matching/ConstructorPattern.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 java.io.IOException;

 import org.eclipse.jdt.core.BindingKey;
 import org.eclipse.jdt.core.Flags;
 import org.eclipse.jdt.core.IMethod;
 import org.eclipse.jdt.core.JavaModelException;
 import org.eclipse.jdt.core.compiler.CharOperation;
 import org.eclipse.jdt.core.search.IJavaSearchConstants;
 import org.eclipse.jdt.core.search.SearchPattern;
 import org.eclipse.jdt.internal.compiler.ExtraFlags;
 import org.eclipse.jdt.internal.compiler.ast.ASTNode;
 import org.eclipse.jdt.internal.core.index.EntryResult;
 import org.eclipse.jdt.internal.core.index.Index;
 import org.eclipse.jdt.internal.core.util.Util;

 public class ConstructorPattern extends JavaSearchPattern {

 protected boolean findDeclarations = true;
 protected boolean findReferences = true;

 public char[] declaringQualification;
 public char[] declaringSimpleName;

 public char[][] parameterQualifications;
 public char[][] parameterSimpleNames;
 public int parameterCount;
 public boolean varargs = false;

 // Signatures and arguments for generic search
 char[][][] parametersTypeSignatures;
 char[][][][] parametersTypeArguments;
 boolean constructorParameters = false;
 char[][] constructorArguments;

 protected static char[][] REF_CATEGORIES = { CONSTRUCTOR_REF };
 protected static char[][] REF_AND_DECL_CATEGORIES = { CONSTRUCTOR_REF, CONSTRUCTOR_DECL };
 protected static char[][] DECL_CATEGORIES = { CONSTRUCTOR_DECL };

 public final static int FINE_GRAIN_MASK =
 	IJavaSearchConstants.SUPER_REFERENCE |
 	IJavaSearchConstants.QUALIFIED_REFERENCE |
 	IJavaSearchConstants.THIS_REFERENCE |
 	IJavaSearchConstants.IMPLICIT_THIS_REFERENCE;


 /**
  * Constructor entries are encoded as described
  *
  * Binary constructor for class
  * TypeName '/' Arity '/' TypeModifers '/' PackageName '/' Signature '/' ParameterNamesopt '/' Modifiers
  * Source constructor for class
  * TypeName '/' Arity '/' TypeModifers '/' PackageName '/' ParameterTypes '/' ParameterNamesopt '/' Modifiers
  * Constructor with 0 arity for class
  * TypeName '/' 0 '/' TypeModifers '/' PackageName '/' Modifiers
  * Constructor for enum, interface (annotation) and class with default constructor
  * TypeName '/' # '/' TypeModifers '/' PackageName
  * Constructor for member type
  * TypeName '/' Arity '/' TypeModifers
  *
  * TypeModifiers contains some encoded extra information
  * 		{@link ExtraFlags#IsMemberType}
  * 		{@link ExtraFlags#HasNonPrivateStaticMemberTypes}
  * 		{@link ExtraFlags#ParameterTypesStoredAsSignature}
  */
 public static char[] createDeclarationIndexKey(
 		char[] typeName,
 		int argCount,
 		char[] signature,
 		char[][] parameterTypes,
 		char[][] parameterNames,
 		int modifiers,
 		char[] packageName,
 		int typeModifiers,
 		int extraFlags) {

 	char[] countChars;
 	char[] parameterTypesChars = null;
 	char[] parameterNamesChars = null;

 	if (argCount < 0) {
 		countChars = DEFAULT_CONSTRUCTOR;
 	} else {
 		countChars = argCount < 10
 		? COUNTS[argCount]
 		: ("/" + String.valueOf(argCount)).toCharArray(); //$NON-NLS-1$

 		if (argCount > 0) {
 			if (signature == null) {
 				if (parameterTypes != null && parameterTypes.length == argCount) {
 					char[][] parameterTypeErasures = new char[argCount][];
 					for (int i = 0; i < parameterTypes.length; i++) {
 						parameterTypeErasures[i] = getTypeErasure(parameterTypes[i]);
 					}
 					parameterTypesChars = CharOperation.concatWith(parameterTypeErasures, PARAMETER_SEPARATOR);
 				}
 			} else {
 				extraFlags |= ExtraFlags.ParameterTypesStoredAsSignature;
 			}

 			if (parameterNames != null && parameterNames.length == argCount) {
 				parameterNamesChars = CharOperation.concatWith(parameterNames, PARAMETER_SEPARATOR);
 			}
 		}
 	}

 	boolean isMemberType = (extraFlags & ExtraFlags.IsMemberType) != 0;

 	int typeNameLength = typeName == null ? 0 : typeName.length;
 	int packageNameLength = packageName == null ? 0 : packageName.length;
 	int countCharsLength = countChars.length;
 	int parameterTypesLength = signature == null ? (parameterTypesChars == null ? 0 : parameterTypesChars.length): signature.length;
 	int parameterNamesLength = parameterNamesChars == null ? 0 : parameterNamesChars.length;

 	int resultLength = typeNameLength + countCharsLength + 3; // SEPARATOR=1 + TypeModifers=2
 	if (!isMemberType) {
 		resultLength += packageNameLength + 1; // SEPARATOR=1
 		if (argCount >= 0) {
 			resultLength += 3; // SEPARATOR=1 + Modifiers=2
 		}

 		if (argCount > 0) {
 			resultLength += parameterTypesLength + parameterNamesLength + 2; //SEPARATOR=1 + SEPARATOR=1
 		}
 	}

 	char[] result = new char[resultLength];

 	int pos = 0;
 	if (typeNameLength > 0) {
 		System.arraycopy(typeName, 0, result, pos, typeNameLength);
 		pos += typeNameLength;
 	}

 	if (countCharsLength > 0) {
 		System.arraycopy(countChars, 0, result, pos, countCharsLength);
 		pos += countCharsLength;
 	}

 	int typeModifiersWithExtraFlags = typeModifiers | encodeExtraFlags(extraFlags);
 	result[pos++] = SEPARATOR;
 	result[pos++] = (char) typeModifiersWithExtraFlags;
 	result[pos++] = (char) (typeModifiersWithExtraFlags>>16);

 	if (!isMemberType) {
 		result[pos++] = SEPARATOR;
 		if (packageNameLength > 0) {
 			System.arraycopy(packageName, 0, result, pos, packageNameLength);
 			pos += packageNameLength;
 		}

 		if (argCount == 0) {
 			result[pos++] = SEPARATOR;
 			result[pos++] = (char) modifiers;
 			result[pos++] = (char) (modifiers>>16);
 		} else if (argCount > 0) {
 			result[pos++] = SEPARATOR;
 			if (parameterTypesLength > 0) {
 				if (signature == null) {
 					System.arraycopy(parameterTypesChars, 0, result, pos, parameterTypesLength);
 				} else {
 					System.arraycopy(CharOperation.replaceOnCopy(signature, SEPARATOR, '\\'), 0, result, pos, parameterTypesLength);
 				}
 				pos += parameterTypesLength;
 			}

 			result[pos++] = SEPARATOR;
 			if (parameterNamesLength > 0) {
 				System.arraycopy(parameterNamesChars, 0, result, pos, parameterNamesLength);
 				pos += parameterNamesLength;
 			}

 			result[pos++] = SEPARATOR;
 			result[pos++] = (char) modifiers;
 			result[pos++] = (char) (modifiers>>16);
 		}

 	}

 	return result;
 }
 public static char[] createDefaultDeclarationIndexKey(
 		char[] typeName,
 		char[] packageName,
 		int typeModifiers,
 		int extraFlags) {
 	return createDeclarationIndexKey(
 			typeName,
 			-1, // used to identify default constructor
 			null,
 			null,
 			null,
 			0, //
 			packageName,
 			typeModifiers,
 			extraFlags);
 }

 /**
  * Constructor entries are encoded as TypeName '/' Arity:
  * e.g. 'X/0'
  */
 public static char[] createIndexKey(char[] typeName, int argCount) {
 	char[] countChars = argCount < 10
 		? COUNTS[argCount]
 		: ("/" + String.valueOf(argCount)).toCharArray(); //$NON-NLS-1$
 	return CharOperation.concat(typeName, countChars);
 }
 static int decodeExtraFlags(int modifiersWithExtraFlags) {
 	int extraFlags = 0;

 	if ((modifiersWithExtraFlags & ASTNode.Bit28) != 0) {
 		extraFlags |= ExtraFlags.ParameterTypesStoredAsSignature;
 	}

 	if ((modifiersWithExtraFlags & ASTNode.Bit29) != 0) {
 		extraFlags |= ExtraFlags.IsLocalType;
 	}

 	if ((modifiersWithExtraFlags & ASTNode.Bit30) != 0) {
 		extraFlags |= ExtraFlags.IsMemberType;
 	}

 	if ((modifiersWithExtraFlags & ASTNode.Bit31) != 0) {
 		extraFlags |= ExtraFlags.HasNonPrivateStaticMemberTypes;
 	}

 	return extraFlags;
 }
 static int decodeModifers(int modifiersWithExtraFlags) {
 	return modifiersWithExtraFlags & ~(ASTNode.Bit31 | ASTNode.Bit30 | ASTNode.Bit29 | ASTNode.Bit28);
 }
 private static int encodeExtraFlags(int extraFlags) {
 	int encodedExtraFlags = 0;

 	if ((extraFlags & ExtraFlags.ParameterTypesStoredAsSignature) != 0) {
 		encodedExtraFlags |= ASTNode.Bit28;
 	}

 	if ((extraFlags & ExtraFlags.IsLocalType) != 0) {
 		encodedExtraFlags |= ASTNode.Bit29;
 	}

 	if ((extraFlags & ExtraFlags.IsMemberType) != 0) {
 		encodedExtraFlags |= ASTNode.Bit30;
 	}
 	if ((extraFlags & ExtraFlags.HasNonPrivateStaticMemberTypes) != 0) {
 		encodedExtraFlags |= ASTNode.Bit31;
 	}

 	return encodedExtraFlags;
 }
 private static char[] getTypeErasure(char[] typeName) {
 	int index;
 	if ((index = CharOperation.indexOf('<', typeName)) == -1) return typeName;

 	int length = typeName.length;
 	char[] typeErasurename = new char[length - 2];

 	System.arraycopy(typeName, 0, typeErasurename, 0, index);

 	int depth = 1;
 	for (int i = index + 1; i < length; i++) {
 		switch (typeName[i]) {
 			case '<':
 				depth++;
 				break;
 			case '>':
 				depth--;
 				break;
 			default:
 				if (depth == 0) {
 					typeErasurename[index++] = typeName[i];
 				}
 				break;
 		}
 	}

 	System.arraycopy(typeErasurename, 0, typeErasurename = new char[index], 0, index);
 	return typeErasurename;
 }
 ConstructorPattern(int matchRule) {
 	super(CONSTRUCTOR_PATTERN, matchRule);
 }
 public ConstructorPattern(
 	char[] declaringSimpleName,
 	char[] declaringQualification,
 	char[][] parameterQualifications,
 	char[][] parameterSimpleNames,
 	int limitTo,
 	int matchRule) {

 	this(matchRule);

 	this.fineGrain = limitTo & FINE_GRAIN_MASK;
     if (this.fineGrain == 0) {
 		switch (limitTo) {
 			case IJavaSearchConstants.DECLARATIONS :
 				this.findReferences = false;
 				break;
 			case IJavaSearchConstants.REFERENCES :
 				this.findDeclarations = false;
 				break;
 			case IJavaSearchConstants.ALL_OCCURRENCES :
 				break;
 		}
     } else {
 		this.findDeclarations = false;
     }

 	this.declaringQualification = this.isCaseSensitive ? declaringQualification : CharOperation.toLowerCase(declaringQualification);
 	this.declaringSimpleName = (this.isCaseSensitive || this.isCamelCase) ? declaringSimpleName : CharOperation.toLowerCase(declaringSimpleName);
 	if (parameterSimpleNames != null) {
 		this.parameterCount = parameterSimpleNames.length;
 		boolean synthetic = this.parameterCount>0 && declaringQualification != null && CharOperation.equals(CharOperation.concat(parameterQualifications[0], parameterSimpleNames[0], '.'), declaringQualification);
 		int offset = 0;
 		if (synthetic) {
 			// skip first synthetic parameter
 			this.parameterCount--;
 			offset++;
 		}
 		this.parameterQualifications = new char[this.parameterCount][];
 		this.parameterSimpleNames = new char[this.parameterCount][];
 		for (int i = 0; i < this.parameterCount; i++) {
 			this.parameterQualifications[i] = this.isCaseSensitive ? parameterQualifications[i+offset] : CharOperation.toLowerCase(parameterQualifications[i+offset]);
 			this.parameterSimpleNames[i] = this.isCaseSensitive ? parameterSimpleNames[i+offset] : CharOperation.toLowerCase(parameterSimpleNames[i+offset]);
 		}
 	} else {
 		this.parameterCount = -1;
 	}
 	this.mustResolve = mustResolve();
 }
 /*
  * Instanciate a method pattern with signatures for generics search
  */
 public ConstructorPattern(
 	char[] declaringSimpleName,
 	char[] declaringQualification,
 	char[][] parameterQualifications,
 	char[][] parameterSimpleNames,
 	String[] parameterSignatures,
 	IMethod method,
 	int limitTo,
 	int matchRule) {

 	this(declaringSimpleName,
 		declaringQualification,
 		parameterQualifications,
 		parameterSimpleNames,
 		limitTo,
 		matchRule);

 	// Set flags
 	try {
 		this.varargs = (method.getFlags() & Flags.AccVarargs) != 0;
 	} catch (JavaModelException e) {
 		// do nothing
 	}

 	// Get unique key for parameterized constructors
 	String genericDeclaringTypeSignature = null;
 	if (method.isResolved()) {
 		String key = method.getKey();
 		BindingKey bindingKey = new BindingKey(key);
 		if (bindingKey.isParameterizedType()) {
 			genericDeclaringTypeSignature = Util.getDeclaringTypeSignature(key);
 			// Store type signature and arguments for declaring type
 			if (genericDeclaringTypeSignature != null) {
 					this.typeSignatures = Util.splitTypeLevelsSignature(genericDeclaringTypeSignature);
 					setTypeArguments(Util.getAllTypeArguments(this.typeSignatures));
 			}
 		}
 	} else {
 		this.constructorParameters = true;
 		storeTypeSignaturesAndArguments(method.getDeclaringType());
 	}

 	// store type signatures and arguments for method parameters type
 	if (parameterSignatures != null) {
 		int length = parameterSignatures.length;
 		if (length > 0) {
 			this.parametersTypeSignatures = new char[length][][];
 			this.parametersTypeArguments = new char[length][][][];
 			for (int i=0; i<length; i++) {
 				this.parametersTypeSignatures[i] = Util.splitTypeLevelsSignature(parameterSignatures[i]);
 				this.parametersTypeArguments[i] = Util.getAllTypeArguments(this.parametersTypeSignatures[i]);
 			}
 		}
 	}

 	// Store type signatures and arguments for method
 	this.constructorArguments = extractMethodArguments(method);
 	if (hasConstructorArguments())  this.mustResolve = true;
 }
 /*
  * Instanciate a method pattern with signatures for generics search
  */
 public ConstructorPattern(
 	char[] declaringSimpleName,
 	char[] declaringQualification,
 	String declaringSignature,
 	char[][] parameterQualifications,
 	char[][] parameterSimpleNames,
 	String[] parameterSignatures,
 	char[][] arguments,
 	int limitTo,
 	int matchRule) {

 	this(declaringSimpleName,
 		declaringQualification,
 		parameterQualifications,
 		parameterSimpleNames,
 		limitTo,
 		matchRule);

 	// Store type signature and arguments for declaring type
 	if (declaringSignature != null) {
 		this.typeSignatures = Util.splitTypeLevelsSignature(declaringSignature);
 		setTypeArguments(Util.getAllTypeArguments(this.typeSignatures));
 	}

 	// Store type signatures and arguments for method parameters type
 	if (parameterSignatures != null) {
 		int length = parameterSignatures.length;
 		if (length > 0) {
 			this.parametersTypeSignatures = new char[length][][];
 			this.parametersTypeArguments = new char[length][][][];
 			for (int i=0; i<length; i++) {
 				this.parametersTypeSignatures[i] = Util.splitTypeLevelsSignature(parameterSignatures[i]);
 				this.parametersTypeArguments[i] = Util.getAllTypeArguments(this.parametersTypeSignatures[i]);
 			}
 		}
 	}

 	// Store type signatures and arguments for method
 	this.constructorArguments = arguments;
 	if (arguments  == null || arguments.length == 0) {
 		if (getTypeArguments() != null && getTypeArguments().length > 0) {
 			this.constructorArguments = getTypeArguments()[0];
 		}
 	}
 	if (hasConstructorArguments())  this.mustResolve = true;
 }

 public void decodeIndexKey(char[] key) {
 	int last = key.length - 1;
 	int slash = CharOperation.indexOf(SEPARATOR, key, 0);
 	this.declaringSimpleName = CharOperation.subarray(key, 0, slash);

 	int start = slash + 1;
 	slash = CharOperation.indexOf(SEPARATOR, key, start);
 	if (slash != -1) {
 		last = slash - 1;
 	}

 	boolean isDefaultConstructor = key[last] == '#';
 	if (isDefaultConstructor) {
 		this.parameterCount = -1;
 	} else {
 		this.parameterCount = 0;
 		int power = 1;
 		for (int i = last; i >= start; i--) {
 			if (i == last) {
 				this.parameterCount = key[i] - '0';
 			} else {
 				power *= 10;
 				this.parameterCount += power * (key[i] - '0');
 			}
 		}
 	}
 }
 public SearchPattern getBlankPattern() {
 	return new ConstructorPattern(R_EXACT_MATCH | R_CASE_SENSITIVE);
 }
 public char[][] getIndexCategories() {
 	if (this.findReferences)
 		return this.findDeclarations ? REF_AND_DECL_CATEGORIES : REF_CATEGORIES;
 	if (this.findDeclarations)
 		return DECL_CATEGORIES;
 	return CharOperation.NO_CHAR_CHAR;
 }
 boolean hasConstructorArguments() {
 	return this.constructorArguments != null && this.constructorArguments.length > 0;
 }
 boolean hasConstructorParameters() {
 	return this.constructorParameters;
 }
 public boolean matchesDecodedKey(SearchPattern decodedPattern) {
 	ConstructorPattern pattern = (ConstructorPattern) decodedPattern;

 	return pattern.parameterCount != -1
 		&& (this.parameterCount == pattern.parameterCount || this.parameterCount == -1 || this.varargs)
 		&& matchesName(this.declaringSimpleName, pattern.declaringSimpleName);
 }
 protected boolean mustResolve() {
 	if (this.declaringQualification != null) return true;

 	// parameter types
 	if (this.parameterSimpleNames != null)
 		for (int i = 0, max = this.parameterSimpleNames.length; i < max; i++)
 			if (this.parameterQualifications[i] != null) return true;
 	return this.findReferences; // need to check resolved default constructors and explicit constructor calls
 }
 public EntryResult[] queryIn(Index index) throws IOException {
 	char[] key = this.declaringSimpleName; // can be null
 	int matchRule = getMatchRule();

 	switch(getMatchMode()) {
 		case R_EXACT_MATCH :
 			if (this.declaringSimpleName != null && this.parameterCount >= 0 && !this.varargs) {
 				key = createIndexKey(this.declaringSimpleName, this.parameterCount);
 			}
 			matchRule &= ~R_EXACT_MATCH;
 			matchRule |= R_PREFIX_MATCH;
 			break;
 		case R_PREFIX_MATCH :
 			// do a prefix query with the declaringSimpleName
 			break;
 		case R_PATTERN_MATCH :
 			if (this.parameterCount >= 0 && !this.varargs) {
 				key = CharOperation.concat(createIndexKey(this.declaringSimpleName == null ? ONE_STAR : this.declaringSimpleName, this.parameterCount), ONE_STAR);
 			} else if (this.declaringSimpleName != null && this.declaringSimpleName[this.declaringSimpleName.length - 1] != '*') {
 				key = CharOperation.concat(this.declaringSimpleName, ONE_STAR, SEPARATOR);
 			} else if (key != null){
 				key = CharOperation.concat(key, ONE_STAR);
 			}
 			// else do a pattern query with just the declaringSimpleName
 			break;
 		case R_REGEXP_MATCH :
 			// TODO (frederic) implement regular expression match
 			break;
 		case R_CAMELCASE_MATCH:
 		case R_CAMELCASE_SAME_PART_COUNT_MATCH:
 			// do a prefix query with the declaringSimpleName
 			break;
 	}

 	return index.query(getIndexCategories(), key, matchRule); // match rule is irrelevant when the key is null
 }
 protected StringBuffer print(StringBuffer output) {
 	if (this.findDeclarations) {
 		output.append(this.findReferences
 			? "ConstructorCombinedPattern: " //$NON-NLS-1$
 			: "ConstructorDeclarationPattern: "); //$NON-NLS-1$
 	} else {
 		output.append("ConstructorReferencePattern: "); //$NON-NLS-1$
 	}
 	if (this.declaringQualification != null)
 		output.append(this.declaringQualification).append('.');
 	if (this.declaringSimpleName != null)
 		output.append(this.declaringSimpleName);
 	else if (this.declaringQualification != null)
 		output.append("*"); //$NON-NLS-1$

 	output.append('(');
 	if (this.parameterSimpleNames == null) {
 		output.append("..."); //$NON-NLS-1$
 	} else {
 		for (int i = 0, max = this.parameterSimpleNames.length; i < max; i++) {
 			if (i > 0) output.append(", "); //$NON-NLS-1$
 			if (this.parameterQualifications[i] != null) output.append(this.parameterQualifications[i]).append('.');
 			if (this.parameterSimpleNames[i] == null) output.append('*'); else output.append(this.parameterSimpleNames[i]);
 		}
 	}
 	output.append(')');
 	return super.print(output);
 }
 }
	/*******************************************************************************
	* 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 java.io.IOException;

	import org.eclipse.jdt.core.BindingKey;
	import org.eclipse.jdt.core.Flags;
	import org.eclipse.jdt.core.IMethod;
	import org.eclipse.jdt.core.JavaModelException;
	import org.eclipse.jdt.core.compiler.CharOperation;
	import org.eclipse.jdt.core.search.IJavaSearchConstants;
	import org.eclipse.jdt.core.search.SearchPattern;
	import org.eclipse.jdt.internal.compiler.ExtraFlags;
	import org.eclipse.jdt.internal.compiler.ast.ASTNode;
	import org.eclipse.jdt.internal.core.index.EntryResult;
	import org.eclipse.jdt.internal.core.index.Index;
	import org.eclipse.jdt.internal.core.util.Util;

	public class ConstructorPattern extends JavaSearchPattern {

	protected boolean findDeclarations = true;
	protected boolean findReferences = true;

	public char[] declaringQualification;
	public char[] declaringSimpleName;

	public char[][] parameterQualifications;
	public char[][] parameterSimpleNames;
	public int parameterCount;
	public boolean varargs = false;

	// Signatures and arguments for generic search
	char[][][] parametersTypeSignatures;
	char[][][][] parametersTypeArguments;
	boolean constructorParameters = false;
	char[][] constructorArguments;

	protected static char[][] REF_CATEGORIES = { CONSTRUCTOR_REF };
	protected static char[][] REF_AND_DECL_CATEGORIES = { CONSTRUCTOR_REF, CONSTRUCTOR_DECL };
	protected static char[][] DECL_CATEGORIES = { CONSTRUCTOR_DECL };

	public final static int FINE_GRAIN_MASK =
	IJavaSearchConstants.SUPER_REFERENCE \|
	IJavaSearchConstants.QUALIFIED_REFERENCE \|
	IJavaSearchConstants.THIS_REFERENCE \|
	IJavaSearchConstants.IMPLICIT_THIS_REFERENCE;


	/**
	* Constructor entries are encoded as described
	*
	* Binary constructor for class
	* TypeName '/' Arity '/' TypeModifers '/' PackageName '/' Signature '/' ParameterNamesopt '/' Modifiers
	* Source constructor for class
	* TypeName '/' Arity '/' TypeModifers '/' PackageName '/' ParameterTypes '/' ParameterNamesopt '/' Modifiers
	* Constructor with 0 arity for class
	* TypeName '/' 0 '/' TypeModifers '/' PackageName '/' Modifiers
	* Constructor for enum, interface (annotation) and class with default constructor
	* TypeName '/' # '/' TypeModifers '/' PackageName
	* Constructor for member type
	* TypeName '/' Arity '/' TypeModifers
	*
	* TypeModifiers contains some encoded extra information
	* {@link ExtraFlags#IsMemberType}
	* {@link ExtraFlags#HasNonPrivateStaticMemberTypes}
	* {@link ExtraFlags#ParameterTypesStoredAsSignature}
	*/
	public static char[] createDeclarationIndexKey(
	char[] typeName,
	int argCount,
	char[] signature,
	char[][] parameterTypes,
	char[][] parameterNames,
	int modifiers,
	char[] packageName,
	int typeModifiers,
	int extraFlags) {

	char[] countChars;
	char[] parameterTypesChars = null;
	char[] parameterNamesChars = null;

	if (argCount < 0) {
	countChars = DEFAULT_CONSTRUCTOR;
	} else {
	countChars = argCount < 10
	? COUNTS[argCount]
	: ("/" + String.valueOf(argCount)).toCharArray(); //$NON-NLS-1$

	if (argCount > 0) {
	if (signature == null) {
	if (parameterTypes != null && parameterTypes.length == argCount) {
	char[][] parameterTypeErasures = new char[argCount][];
	for (int i = 0; i < parameterTypes.length; i++) {
	parameterTypeErasures[i] = getTypeErasure(parameterTypes[i]);
	}
	parameterTypesChars = CharOperation.concatWith(parameterTypeErasures, PARAMETER_SEPARATOR);
	}
	} else {
	extraFlags \|= ExtraFlags.ParameterTypesStoredAsSignature;
	}

	if (parameterNames != null && parameterNames.length == argCount) {
	parameterNamesChars = CharOperation.concatWith(parameterNames, PARAMETER_SEPARATOR);
	}
	}
	}

	boolean isMemberType = (extraFlags & ExtraFlags.IsMemberType) != 0;

	int typeNameLength = typeName == null ? 0 : typeName.length;
	int packageNameLength = packageName == null ? 0 : packageName.length;
	int countCharsLength = countChars.length;
	int parameterTypesLength = signature == null ? (parameterTypesChars == null ? 0 : parameterTypesChars.length): signature.length;
	int parameterNamesLength = parameterNamesChars == null ? 0 : parameterNamesChars.length;

	int resultLength = typeNameLength + countCharsLength + 3; // SEPARATOR=1 + TypeModifers=2
	if (!isMemberType) {
	resultLength += packageNameLength + 1; // SEPARATOR=1
	if (argCount >= 0) {
	resultLength += 3; // SEPARATOR=1 + Modifiers=2
	}

	if (argCount > 0) {
	resultLength += parameterTypesLength + parameterNamesLength + 2; //SEPARATOR=1 + SEPARATOR=1
	}
	}

	char[] result = new char[resultLength];

	int pos = 0;
	if (typeNameLength > 0) {
	System.arraycopy(typeName, 0, result, pos, typeNameLength);
	pos += typeNameLength;
	}

	if (countCharsLength > 0) {
	System.arraycopy(countChars, 0, result, pos, countCharsLength);
	pos += countCharsLength;
	}

	int typeModifiersWithExtraFlags = typeModifiers \| encodeExtraFlags(extraFlags);
	result[pos++] = SEPARATOR;
	result[pos++] = (char) typeModifiersWithExtraFlags;
	result[pos++] = (char) (typeModifiersWithExtraFlags>>16);

	if (!isMemberType) {
	result[pos++] = SEPARATOR;
	if (packageNameLength > 0) {
	System.arraycopy(packageName, 0, result, pos, packageNameLength);
	pos += packageNameLength;
	}

	if (argCount == 0) {
	result[pos++] = SEPARATOR;
	result[pos++] = (char) modifiers;
	result[pos++] = (char) (modifiers>>16);
	} else if (argCount > 0) {
	result[pos++] = SEPARATOR;
	if (parameterTypesLength > 0) {
	if (signature == null) {
	System.arraycopy(parameterTypesChars, 0, result, pos, parameterTypesLength);
	} else {
	System.arraycopy(CharOperation.replaceOnCopy(signature, SEPARATOR, '\\'), 0, result, pos, parameterTypesLength);
	}
	pos += parameterTypesLength;
	}

	result[pos++] = SEPARATOR;
	if (parameterNamesLength > 0) {
	System.arraycopy(parameterNamesChars, 0, result, pos, parameterNamesLength);
	pos += parameterNamesLength;
	}

	result[pos++] = SEPARATOR;
	result[pos++] = (char) modifiers;
	result[pos++] = (char) (modifiers>>16);
	}

	}

	return result;
	}
	public static char[] createDefaultDeclarationIndexKey(
	char[] typeName,
	char[] packageName,
	int typeModifiers,
	int extraFlags) {
	return createDeclarationIndexKey(
	typeName,
	-1, // used to identify default constructor
	null,
	null,
	null,
	0, //
	packageName,
	typeModifiers,
	extraFlags);
	}

	/**
	* Constructor entries are encoded as TypeName '/' Arity:
	* e.g. 'X/0'
	*/
	public static char[] createIndexKey(char[] typeName, int argCount) {
	char[] countChars = argCount < 10
	? COUNTS[argCount]
	: ("/" + String.valueOf(argCount)).toCharArray(); //$NON-NLS-1$
	return CharOperation.concat(typeName, countChars);
	}
	static int decodeExtraFlags(int modifiersWithExtraFlags) {
	int extraFlags = 0;

	if ((modifiersWithExtraFlags & ASTNode.Bit28) != 0) {
	extraFlags \|= ExtraFlags.ParameterTypesStoredAsSignature;
	}

	if ((modifiersWithExtraFlags & ASTNode.Bit29) != 0) {
	extraFlags \|= ExtraFlags.IsLocalType;
	}

	if ((modifiersWithExtraFlags & ASTNode.Bit30) != 0) {
	extraFlags \|= ExtraFlags.IsMemberType;
	}

	if ((modifiersWithExtraFlags & ASTNode.Bit31) != 0) {
	extraFlags \|= ExtraFlags.HasNonPrivateStaticMemberTypes;
	}

	return extraFlags;
	}
	static int decodeModifers(int modifiersWithExtraFlags) {
	return modifiersWithExtraFlags & ~(ASTNode.Bit31 \| ASTNode.Bit30 \| ASTNode.Bit29 \| ASTNode.Bit28);
	}
	private static int encodeExtraFlags(int extraFlags) {
	int encodedExtraFlags = 0;

	if ((extraFlags & ExtraFlags.ParameterTypesStoredAsSignature) != 0) {
	encodedExtraFlags \|= ASTNode.Bit28;
	}

	if ((extraFlags & ExtraFlags.IsLocalType) != 0) {
	encodedExtraFlags \|= ASTNode.Bit29;
	}

	if ((extraFlags & ExtraFlags.IsMemberType) != 0) {
	encodedExtraFlags \|= ASTNode.Bit30;
	}
	if ((extraFlags & ExtraFlags.HasNonPrivateStaticMemberTypes) != 0) {
	encodedExtraFlags \|= ASTNode.Bit31;
	}

	return encodedExtraFlags;
	}
	private static char[] getTypeErasure(char[] typeName) {
	int index;
	if ((index = CharOperation.indexOf('<', typeName)) == -1) return typeName;

	int length = typeName.length;
	char[] typeErasurename = new char[length - 2];

	System.arraycopy(typeName, 0, typeErasurename, 0, index);

	int depth = 1;
	for (int i = index + 1; i < length; i++) {
	switch (typeName[i]) {
	case '<':
	depth++;
	break;
	case '>':
	depth--;
	break;
	default:
	if (depth == 0) {
	typeErasurename[index++] = typeName[i];
	}
	break;
	}
	}

	System.arraycopy(typeErasurename, 0, typeErasurename = new char[index], 0, index);
	return typeErasurename;
	}
	ConstructorPattern(int matchRule) {
	super(CONSTRUCTOR_PATTERN, matchRule);
	}
	public ConstructorPattern(
	char[] declaringSimpleName,
	char[] declaringQualification,
	char[][] parameterQualifications,
	char[][] parameterSimpleNames,
	int limitTo,
	int matchRule) {

	this(matchRule);

	this.fineGrain = limitTo & FINE_GRAIN_MASK;
	if (this.fineGrain == 0) {
	switch (limitTo) {
	case IJavaSearchConstants.DECLARATIONS :
	this.findReferences = false;
	break;
	case IJavaSearchConstants.REFERENCES :
	this.findDeclarations = false;
	break;
	case IJavaSearchConstants.ALL_OCCURRENCES :
	break;
	}
	} else {
	this.findDeclarations = false;
	}

	this.declaringQualification = this.isCaseSensitive ? declaringQualification : CharOperation.toLowerCase(declaringQualification);
	this.declaringSimpleName = (this.isCaseSensitive \|\| this.isCamelCase) ? declaringSimpleName : CharOperation.toLowerCase(declaringSimpleName);
	if (parameterSimpleNames != null) {
	this.parameterCount = parameterSimpleNames.length;
	boolean synthetic = this.parameterCount>0 && declaringQualification != null && CharOperation.equals(CharOperation.concat(parameterQualifications[0], parameterSimpleNames[0], '.'), declaringQualification);
	int offset = 0;
	if (synthetic) {
	// skip first synthetic parameter
	this.parameterCount--;
	offset++;
	}
	this.parameterQualifications = new char[this.parameterCount][];
	this.parameterSimpleNames = new char[this.parameterCount][];
	for (int i = 0; i < this.parameterCount; i++) {
	this.parameterQualifications[i] = this.isCaseSensitive ? parameterQualifications[i+offset] : CharOperation.toLowerCase(parameterQualifications[i+offset]);
	this.parameterSimpleNames[i] = this.isCaseSensitive ? parameterSimpleNames[i+offset] : CharOperation.toLowerCase(parameterSimpleNames[i+offset]);
	}
	} else {
	this.parameterCount = -1;
	}
	this.mustResolve = mustResolve();
	}
	/*
	* Instanciate a method pattern with signatures for generics search
	*/
	public ConstructorPattern(
	char[] declaringSimpleName,
	char[] declaringQualification,
	char[][] parameterQualifications,
	char[][] parameterSimpleNames,
	String[] parameterSignatures,
	IMethod method,
	int limitTo,
	int matchRule) {

	this(declaringSimpleName,
	declaringQualification,
	parameterQualifications,
	parameterSimpleNames,
	limitTo,
	matchRule);

	// Set flags
	try {
	this.varargs = (method.getFlags() & Flags.AccVarargs) != 0;
	} catch (JavaModelException e) {
	// do nothing
	}

	// Get unique key for parameterized constructors
	String genericDeclaringTypeSignature = null;
	if (method.isResolved()) {
	String key = method.getKey();
	BindingKey bindingKey = new BindingKey(key);
	if (bindingKey.isParameterizedType()) {
	genericDeclaringTypeSignature = Util.getDeclaringTypeSignature(key);
	// Store type signature and arguments for declaring type
	if (genericDeclaringTypeSignature != null) {
	this.typeSignatures = Util.splitTypeLevelsSignature(genericDeclaringTypeSignature);
	setTypeArguments(Util.getAllTypeArguments(this.typeSignatures));
	}
	}
	} else {
	this.constructorParameters = true;
	storeTypeSignaturesAndArguments(method.getDeclaringType());
	}

	// store type signatures and arguments for method parameters type
	if (parameterSignatures != null) {
	int length = parameterSignatures.length;
	if (length > 0) {
	this.parametersTypeSignatures = new char[length][][];
	this.parametersTypeArguments = new char[length][][][];
	for (int i=0; i<length; i++) {
	this.parametersTypeSignatures[i] = Util.splitTypeLevelsSignature(parameterSignatures[i]);
	this.parametersTypeArguments[i] = Util.getAllTypeArguments(this.parametersTypeSignatures[i]);
	}
	}
	}

	// Store type signatures and arguments for method
	this.constructorArguments = extractMethodArguments(method);
	if (hasConstructorArguments()) this.mustResolve = true;
	}
	/*
	* Instanciate a method pattern with signatures for generics search
	*/
	public ConstructorPattern(
	char[] declaringSimpleName,
	char[] declaringQualification,
	String declaringSignature,
	char[][] parameterQualifications,
	char[][] parameterSimpleNames,
	String[] parameterSignatures,
	char[][] arguments,
	int limitTo,
	int matchRule) {

	this(declaringSimpleName,
	declaringQualification,
	parameterQualifications,
	parameterSimpleNames,
	limitTo,
	matchRule);

	// Store type signature and arguments for declaring type
	if (declaringSignature != null) {
	this.typeSignatures = Util.splitTypeLevelsSignature(declaringSignature);
	setTypeArguments(Util.getAllTypeArguments(this.typeSignatures));
	}

	// Store type signatures and arguments for method parameters type
	if (parameterSignatures != null) {
	int length = parameterSignatures.length;
	if (length > 0) {
	this.parametersTypeSignatures = new char[length][][];
	this.parametersTypeArguments = new char[length][][][];
	for (int i=0; i<length; i++) {
	this.parametersTypeSignatures[i] = Util.splitTypeLevelsSignature(parameterSignatures[i]);
	this.parametersTypeArguments[i] = Util.getAllTypeArguments(this.parametersTypeSignatures[i]);
	}
	}
	}

	// Store type signatures and arguments for method
	this.constructorArguments = arguments;
	if (arguments == null \|\| arguments.length == 0) {
	if (getTypeArguments() != null && getTypeArguments().length > 0) {
	this.constructorArguments = getTypeArguments()[0];
	}
	}
	if (hasConstructorArguments()) this.mustResolve = true;
	}

	public void decodeIndexKey(char[] key) {
	int last = key.length - 1;
	int slash = CharOperation.indexOf(SEPARATOR, key, 0);
	this.declaringSimpleName = CharOperation.subarray(key, 0, slash);

	int start = slash + 1;
	slash = CharOperation.indexOf(SEPARATOR, key, start);
	if (slash != -1) {
	last = slash - 1;
	}

	boolean isDefaultConstructor = key[last] == '#';
	if (isDefaultConstructor) {
	this.parameterCount = -1;
	} else {
	this.parameterCount = 0;
	int power = 1;
	for (int i = last; i >= start; i--) {
	if (i == last) {
	this.parameterCount = key[i] - '0';
	} else {
	power *= 10;
	this.parameterCount += power * (key[i] - '0');
	}
	}
	}
	}
	public SearchPattern getBlankPattern() {
	return new ConstructorPattern(R_EXACT_MATCH \| R_CASE_SENSITIVE);
	}
	public char[][] getIndexCategories() {
	if (this.findReferences)
	return this.findDeclarations ? REF_AND_DECL_CATEGORIES : REF_CATEGORIES;
	if (this.findDeclarations)
	return DECL_CATEGORIES;
	return CharOperation.NO_CHAR_CHAR;
	}
	boolean hasConstructorArguments() {
	return this.constructorArguments != null && this.constructorArguments.length > 0;
	}
	boolean hasConstructorParameters() {
	return this.constructorParameters;
	}
	public boolean matchesDecodedKey(SearchPattern decodedPattern) {
	ConstructorPattern pattern = (ConstructorPattern) decodedPattern;

	return pattern.parameterCount != -1
	&& (this.parameterCount == pattern.parameterCount \|\| this.parameterCount == -1 \|\| this.varargs)
	&& matchesName(this.declaringSimpleName, pattern.declaringSimpleName);
	}
	protected boolean mustResolve() {
	if (this.declaringQualification != null) return true;

	// parameter types
	if (this.parameterSimpleNames != null)
	for (int i = 0, max = this.parameterSimpleNames.length; i < max; i++)
	if (this.parameterQualifications[i] != null) return true;
	return this.findReferences; // need to check resolved default constructors and explicit constructor calls
	}
	public EntryResult[] queryIn(Index index) throws IOException {
	char[] key = this.declaringSimpleName; // can be null
	int matchRule = getMatchRule();

	switch(getMatchMode()) {
	case R_EXACT_MATCH :
	if (this.declaringSimpleName != null && this.parameterCount >= 0 && !this.varargs) {
	key = createIndexKey(this.declaringSimpleName, this.parameterCount);
	}
	matchRule &= ~R_EXACT_MATCH;
	matchRule \|= R_PREFIX_MATCH;
	break;
	case R_PREFIX_MATCH :
	// do a prefix query with the declaringSimpleName
	break;
	case R_PATTERN_MATCH :
	if (this.parameterCount >= 0 && !this.varargs) {
	key = CharOperation.concat(createIndexKey(this.declaringSimpleName == null ? ONE_STAR : this.declaringSimpleName, this.parameterCount), ONE_STAR);
	} else if (this.declaringSimpleName != null && this.declaringSimpleName[this.declaringSimpleName.length - 1] != '*') {
	key = CharOperation.concat(this.declaringSimpleName, ONE_STAR, SEPARATOR);
	} else if (key != null){
	key = CharOperation.concat(key, ONE_STAR);
	}
	// else do a pattern query with just the declaringSimpleName
	break;
	case R_REGEXP_MATCH :
	// TODO (frederic) implement regular expression match
	break;
	case R_CAMELCASE_MATCH:
	case R_CAMELCASE_SAME_PART_COUNT_MATCH:
	// do a prefix query with the declaringSimpleName
	break;
	}

	return index.query(getIndexCategories(), key, matchRule); // match rule is irrelevant when the key is null
	}
	protected StringBuffer print(StringBuffer output) {
	if (this.findDeclarations) {
	output.append(this.findReferences
	? "ConstructorCombinedPattern: " //$NON-NLS-1$
	: "ConstructorDeclarationPattern: "); //$NON-NLS-1$
	} else {
	output.append("ConstructorReferencePattern: "); //$NON-NLS-1$
	}
	if (this.declaringQualification != null)
	output.append(this.declaringQualification).append('.');
	if (this.declaringSimpleName != null)
	output.append(this.declaringSimpleName);
	else if (this.declaringQualification != null)
	output.append("*"); //$NON-NLS-1$

	output.append('(');
	if (this.parameterSimpleNames == null) {
	output.append("..."); //$NON-NLS-1$
	} else {
	for (int i = 0, max = this.parameterSimpleNames.length; i < max; i++) {
	if (i > 0) output.append(", "); //$NON-NLS-1$
	if (this.parameterQualifications[i] != null) output.append(this.parameterQualifications[i]).append('.');
	if (this.parameterSimpleNames[i] == null) output.append('*'); else output.append(this.parameterSimpleNames[i]);
	}
	}
	output.append(')');
	return super.print(output);
	}
	}