/*******************************************************************************
* 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);
}
}