Attachment #121945 for bug #6930

Lines 46-52 Link Here

(-)search/org/eclipse/jdt/internal/core/index/DiskIndex.java (-1 / +1 lines)
46	private int streamEnd; // used when writing data from the streamBuffer to the file	46	private int streamEnd; // used when writing data from the streamBuffer to the file
47	char separator = Index.DEFAULT_SEPARATOR;	47	char separator = Index.DEFAULT_SEPARATOR;
48		48
49	public static final String SIGNATURE= "INDEX VERSION 1.125"; //$NON-NLS-1$	49	public static final String SIGNATURE= "INDEX VERSION 1.126"; //$NON-NLS-1$
50	private static final char[] SIGNATURE_CHARS = SIGNATURE.toCharArray();	50	private static final char[] SIGNATURE_CHARS = SIGNATURE.toCharArray();
51	public static boolean DEBUG = false;	51	public static boolean DEBUG = false;
52		52

Lines 572-577 Link Here

(-)codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionParser.java (+22 lines)
572	}	572	}
573	}	573	}
574	}	574	}
		575	public Object becomeSimpleParser() {
		576	CompletionScanner completionScanner = (CompletionScanner)this.scanner;
		577	int[] parserState = new int[] {this.cursorLocation, completionScanner.cursorLocation};
		578
		579	this.cursorLocation = Integer.MAX_VALUE;
		580	completionScanner.cursorLocation = Integer.MAX_VALUE;
		581
		582	return parserState;
		583	}
575	private void buildMoreAnnotationCompletionContext(MemberValuePair memberValuePair) {	584	private void buildMoreAnnotationCompletionContext(MemberValuePair memberValuePair) {
576	if(this.identifierPtr < 0 \|\| this.identifierLengthPtr < 0 ) return;	585	if(this.identifierPtr < 0 \|\| this.identifierLengthPtr < 0 ) return;
577		586
Lines 1208-1213 Link Here
1208	}	1217	}
1209	if(type instanceof CompletionOnSingleTypeReference) {	1218	if(type instanceof CompletionOnSingleTypeReference) {
1210	((CompletionOnSingleTypeReference)type).isConstructorType = true;	1219	((CompletionOnSingleTypeReference)type).isConstructorType = true;
		1220	} else if (type instanceof CompletionOnQualifiedTypeReference) {
		1221	((CompletionOnQualifiedTypeReference)type).isConstructorType = true;
1211	}	1222	}
1212	allocExpr.type = type;	1223	allocExpr.type = type;
1213	allocExpr.sourceStart = type.sourceStart;	1224	allocExpr.sourceStart = type.sourceStart;
Lines 1227-1232 Link Here
1227	} else {	1238	} else {
1228	type = getTypeReference(0);	1239	type = getTypeReference(0);
1229	}	1240	}
		1241	if(type instanceof CompletionOnSingleTypeReference) {
		1242	((CompletionOnSingleTypeReference)type).isConstructorType = true;
		1243	}
1230	allocExpr.type = type;	1244	allocExpr.type = type;
1231	allocExpr.enclosingInstance = this.expressionStack[this.qualifier];	1245	allocExpr.enclosingInstance = this.expressionStack[this.qualifier];
1232	allocExpr.sourceStart = this.intStack[this.intPtr--];	1246	allocExpr.sourceStart = this.intStack[this.intPtr--];
Lines 4539-4544 Link Here
4539	this.cursorLocation = 0;	4553	this.cursorLocation = 0;
4540	flushAssistState();	4554	flushAssistState();
4541	}	4555	}
		4556	public void restoreAssistParser(Object parserState) {
		4557	int[] state = (int[]) parserState;
		4558
		4559	CompletionScanner completionScanner = (CompletionScanner)this.scanner;
		4560
		4561	this.cursorLocation = state[0];
		4562	completionScanner.cursorLocation = state[1];
		4563	}
4542	/*	4564	/*
4543	* Reset context so as to resume to regular parse loop	4565	* Reset context so as to resume to regular parse loop
4544	* If unable to reset for resuming, answers false.	4566	* If unable to reset for resuming, answers false.

Lines 35-40 Link Here

(-)codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionOnQualifiedTypeReference.java (+3 lines)
35		35
36	private int kind = K_TYPE;	36	private int kind = K_TYPE;
37	public char[] completionIdentifier;	37	public char[] completionIdentifier;
		38
		39	public boolean isConstructorType;
		40
38	public CompletionOnQualifiedTypeReference(char[][] previousIdentifiers, char[] completionIdentifier, long[] positions) {	41	public CompletionOnQualifiedTypeReference(char[][] previousIdentifiers, char[] completionIdentifier, long[] positions) {
39	this(previousIdentifiers, completionIdentifier, positions, K_TYPE);	42	this(previousIdentifiers, completionIdentifier, positions, K_TYPE);
40	}	43	}




import java.util.ArrayList;
import java.util.Map;

import org.eclipse.jdt.core.Signature;
import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.internal.compiler.ISourceElementRequestor.TypeParameterInfo;
import org.eclipse.jdt.internal.compiler.ast.ASTNode;

	 * An ast visitor that visits local type declarations.
	 */
	public class LocalDeclarationVisitor extends ASTVisitor {
		public ImportReference currentPackage;
		ArrayList declaringTypes;
		public void pushDeclaringType(TypeDeclaration declaringType) {
			if (this.declaringTypes == null) {

			return (TypeDeclaration) this.declaringTypes.get(size-1);
		}
		public boolean visit(TypeDeclaration typeDeclaration, BlockScope scope) {
			notifySourceElementRequestor(typeDeclaration, true, peekDeclaringType(), this.currentPackage);
			return false; // don't visit members as this was done during notifySourceElementRequestor(...)
		}
		public boolean visit(TypeDeclaration typeDeclaration, ClassScope scope) {
			notifySourceElementRequestor(typeDeclaration, true, peekDeclaringType(), this.currentPackage);
			return false; // don't visit members as this was done during notifySourceElementRequestor(...)
		}
	}

/*
 * Update the bodyStart of the corresponding parse node
 */
protected void notifySourceElementRequestor(AbstractMethodDeclaration methodDeclaration, TypeDeclaration declaringType, ImportReference currentPackage) {

	// range check
	boolean isInRange =

			methodInfo.typeParameters = getTypeParameterInfos(methodDeclaration.typeParameters());
			methodInfo.categories = (char[][]) this.nodesToCategories.get(methodDeclaration);
			methodInfo.annotations = methodDeclaration.annotations;
			methodInfo.declaringPackageName = currentPackage == null ? CharOperation.NO_CHAR : CharOperation.concatWith(currentPackage.tokens, '.');
			methodInfo.declaringTypeModifiers = declaringType.modifiers;
			methodInfo.extraFlags = ExtraFlags.getExtraFlags(declaringType);
			methodInfo.node = methodDeclaration;
			this.requestor.enterConstructor(methodInfo);
		}

			this.requestor.enterCompilationUnit();
		}
		ImportReference currentPackage = parsedUnit.currentPackage;
		if (this.localDeclarationVisitor !=  null) {
			this.localDeclarationVisitor.currentPackage = currentPackage;
		}
		ImportReference[] imports = parsedUnit.imports;
		TypeDeclaration[] types = parsedUnit.types;
		length =

						notifySourceElementRequestor(importRef, false);
					}
				} else { // instanceof TypeDeclaration
					notifySourceElementRequestor((TypeDeclaration)node, true, null, currentPackage);
				}
			}
		}

			importReference.modifiers);
	}
}
protected void notifySourceElementRequestor(TypeDeclaration typeDeclaration, boolean notifyTypePresence, TypeDeclaration declaringType, ImportReference currentPackage) {

	if (CharOperation.equals(TypeConstants.PACKAGE_INFO_NAME, typeDeclaration.name)) return;


			typeInfo.secondary = typeDeclaration.isSecondary();
			typeInfo.anonymousMember = typeDeclaration.allocation != null && typeDeclaration.allocation.enclosingInstance != null;
			typeInfo.annotations = typeDeclaration.annotations;
			typeInfo.extraFlags = ExtraFlags.getExtraFlags(typeDeclaration);
			typeInfo.node = typeDeclaration;
			this.requestor.enterType(typeInfo);
			switch (kind) {

				break;
			case 1 :
				methodIndex++;
				notifySourceElementRequestor(nextMethodDeclaration, typeDeclaration, currentPackage);
				break;
			case 2 :
				memberTypeIndex++;
				notifySourceElementRequestor(nextMemberDeclaration, true, null, currentPackage);
		}
	}
	if (notifyTypePresence){

Lines 59-64 Link Here

(-)model/org/eclipse/jdt/internal/compiler/ISourceElementRequestor.java (+4 lines)
59	public boolean secondary;	59	public boolean secondary;
60	public boolean anonymousMember;	60	public boolean anonymousMember;
61	public Annotation[] annotations;	61	public Annotation[] annotations;
		62	public int extraFlags;
62	public TypeDeclaration node;	63	public TypeDeclaration node;
63	public HashMap childrenCategories = new HashMap();	64	public HashMap childrenCategories = new HashMap();
64	}	65	}
Lines 87-92 Link Here
87	public TypeParameterInfo[] typeParameters;	88	public TypeParameterInfo[] typeParameters;
88	public char[][] categories;	89	public char[][] categories;
89	public Annotation[] annotations;	90	public Annotation[] annotations;
		91	public char[] declaringPackageName;
		92	public int declaringTypeModifiers;
		93	public int extraFlags;
90	public AbstractMethodDeclaration node;	94	public AbstractMethodDeclaration node;
91	}	95	}
92		96





import org.eclipse.jdt.core.Signature;
import org.eclipse.jdt.core.compiler.*;
import org.eclipse.jdt.internal.compiler.ExtraFlags;
import org.eclipse.jdt.internal.compiler.ISourceElementRequestor;
import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
import org.eclipse.jdt.internal.compiler.ast.Expression;
import org.eclipse.jdt.internal.compiler.ast.ImportReference;
import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;

public void acceptUnknownReference(char[] name, int sourcePosition) {
	this.indexer.addNameReference(name);
}

private void addDefaultConstructorIfNecessary(TypeInfo typeInfo) {
	boolean hasConstructor = false;
	
	TypeDeclaration typeDeclaration = typeInfo.node;
	AbstractMethodDeclaration[] methods = typeDeclaration.methods;
	int methodCounter = methods == null ? 0 : methods.length;
	done : for (int i = 0; i < methodCounter; i++) {
		AbstractMethodDeclaration method = methods[i];
		if (method.isConstructor() && !method.isDefaultConstructor()) {
			hasConstructor = true;
			break done;
		}
	}
	
	if (!hasConstructor) {
		this.indexer.addDefaultConstructorDeclaration(
				typeInfo.name,
				this.packageName == null ? CharOperation.NO_CHAR : this.packageName,
				typeInfo.modifiers,
				getMoreExtraFlags(typeInfo.extraFlags));
	}
}
/*
 * Rebuild the proper qualification for the current source type:
 *

		typeNames = enclosingTypeNames();
	}
	this.indexer.addAnnotationTypeDeclaration(typeInfo.modifiers, this.packageName, typeInfo.name, typeNames, typeInfo.secondary);
	addDefaultConstructorIfNecessary(typeInfo);
	pushTypeName(typeInfo.name);
}


		}
	}
	this.indexer.addClassDeclaration(typeInfo.modifiers, this.packageName, typeInfo.name, typeNames, typeInfo.superclass, typeInfo.superinterfaces, typeParameterSignatures, typeInfo.secondary);
	addDefaultConstructorIfNecessary(typeInfo);
	pushTypeName(typeInfo.name);
}
/**

 * @see ISourceElementRequestor#enterConstructor(ISourceElementRequestor.MethodInfo)
 */
public void enterConstructor(MethodInfo methodInfo) {
	int argCount = methodInfo.parameterTypes == null ? 0 : methodInfo.parameterTypes.length;
	this.indexer.addConstructorDeclaration(
			methodInfo.name,
			argCount,
			null,
			methodInfo.parameterTypes,
			methodInfo.parameterNames,
			methodInfo.modifiers,
			methodInfo.declaringPackageName,
			methodInfo.declaringTypeModifiers,
			methodInfo.exceptionTypes,
			getMoreExtraFlags(methodInfo.extraFlags));
	this.methodDepth++;
}
private void enterEnum(TypeInfo typeInfo) {

	}
	char[] superclass = typeInfo.superclass == null ? CharOperation.concatWith(TypeConstants.JAVA_LANG_ENUM, '.'): typeInfo.superclass;
	this.indexer.addEnumDeclaration(typeInfo.modifiers, this.packageName, typeInfo.name, typeNames, superclass, typeInfo.superinterfaces, typeInfo.secondary);
	addDefaultConstructorIfNecessary(typeInfo);
	pushTypeName(typeInfo.name);
}
/**

		}
	}
	this.indexer.addInterfaceDeclaration(typeInfo.modifiers, this.packageName, typeInfo.name, typeNames, typeInfo.superinterfaces, typeParameterSignatures, typeInfo.secondary);
	addDefaultConstructorIfNecessary(typeInfo);
	pushTypeName(typeInfo.name);
}
/**

	}
	return  CharOperation.subarray(typeName, lastDot + 1, lastGenericStart);
}
private int getMoreExtraFlags(int extraFlags) {
	if (this.methodDepth > 0) {
		extraFlags |= ExtraFlags.IsLocalType;
	}
	return extraFlags;
}
public void popTypeName() {
	if (this.depth > 0) {
		this.enclosingTypeNames[--this.depth] = null;




	char[] TYPE_DECL = "typeDecl".toCharArray(); //$NON-NLS-1$
	char[] METHOD_DECL= "methodDecl".toCharArray(); //$NON-NLS-1$
	char[] CONSTRUCTOR_DECL= "constructorDecl".toCharArray(); //$NON-NLS-1$
	char[] EXT_CONSTRUCTOR_DECL= "extConstructorDecl".toCharArray(); //$NON-NLS-1$
	char[] FIELD_DECL= "fieldDecl".toCharArray(); //$NON-NLS-1$
	char[] OBJECT = "Object".toCharArray(); //$NON-NLS-1$
	char[][] COUNTS=
		new char[][] { new char[] {'/', '0'}, new char[] {'/', '1'}, new char[] {'/', '2'}, new char[] {'/', '3'}, new char[] {'/', '4'},
			new char[] {'/', '5'}, new char[] {'/', '6'}, new char[] {'/', '7'}, new char[] {'/', '8'}, new char[] {'/', '9'}
	};
	char[] DEFAULT_CONSTRUCTOR = new char[]{'/', '#'};
	char CLASS_SUFFIX = 'C';
	char INTERFACE_SUFFIX = 'I';
	char ENUM_SUFFIX = 'E';

	char CLASS_AND_INTERFACE_SUFFIX = IJavaSearchConstants.CLASS_AND_INTERFACE;
	char INTERFACE_AND_ANNOTATION_SUFFIX = IJavaSearchConstants.INTERFACE_AND_ANNOTATION;
	char SEPARATOR= '/';
	char PARAMETER_SEPARATOR= ',';
	char SECONDARY_SUFFIX = 'S';

	char[] ONE_STAR = new char[] {'*'};




			typeName = CharOperation.subarray(typeName, 0, genericStart);
		return typeName;
	}
	public void addConstructorDeclaration(
			char[] typeName,
			int argCount,
			char[] signature,
			char[][] parameterTypes,
			char[][] parameterNames,
			int modifiers,
			char[] packageName,
			int typeModifiers,
			char[][] exceptionTypes,
			int extraFlags) {
		addIndexEntry(
				CONSTRUCTOR_DECL,
				ConstructorPattern.createDeclarationIndexKey(
						typeName,
						argCount,
						signature,
						parameterTypes,
						parameterNames,
						modifiers,
						packageName,
						typeModifiers,
						extraFlags));
		
		if (parameterTypes != null) {
			for (int i = 0; i < argCount; i++)
				addTypeReference(parameterTypes[i]);

		if (innermostTypeName != simpleTypeName)
			addIndexEntry(CONSTRUCTOR_REF, ConstructorPattern.createIndexKey(innermostTypeName, argCount));
	}
	public void addDefaultConstructorDeclaration(
			char[] typeName,
			char[] packageName,
			int typeModifiers,
			int extraFlags) {
		addIndexEntry(CONSTRUCTOR_DECL, ConstructorPattern.createDefaultDeclarationIndexKey(CharOperation.lastSegment(typeName,'.'), packageName, typeModifiers, extraFlags));
	}
	public void addEnumDeclaration(int modifiers, char[] packageName, char[] name, char[][] enclosingTypeNames, char[] superclass, char[][] superinterfaces, boolean secondary) {
		addTypeDeclaration(modifiers, packageName, name, enclosingTypeNames, secondary);


Lines 14-19 Link Here

(-)search/org/eclipse/jdt/internal/core/search/indexing/BinaryIndexer.java (-1 / +44 lines)
14	import org.eclipse.jdt.core.Signature;	14	import org.eclipse.jdt.core.Signature;
15	import org.eclipse.jdt.core.compiler.CharOperation;	15	import org.eclipse.jdt.core.compiler.CharOperation;
16	import org.eclipse.jdt.core.search.SearchDocument;	16	import org.eclipse.jdt.core.search.SearchDocument;
		17	import org.eclipse.jdt.internal.compiler.ExtraFlags;
17	import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;	18	import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
18	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;	19	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
19	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader;	20	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader;
Lines 700-708 Link Here
700	if (tagBits != 0) {	701	if (tagBits != 0) {
701	addBinaryStandardAnnotations(tagBits);	702	addBinaryStandardAnnotations(tagBits);
702	}	703	}
		704
		705	int extraFlags = ExtraFlags.getExtraFlags(reader);
703		706
704	// first reference all methods declarations and field declarations	707	// first reference all methods declarations and field declarations
705	MethodInfo[] methods = (MethodInfo[]) reader.getMethods();	708	MethodInfo[] methods = (MethodInfo[]) reader.getMethods();
		709	boolean noConstructor = true;
706	if (methods != null) {	710	if (methods != null) {
707	for (int i = 0, max = methods.length; i < max; i++) {	711	for (int i = 0, max = methods.length; i < max; i++) {
708	MethodInfo method = methods[i];	712	MethodInfo method = methods[i];
Lines 712-718 Link Here
712	char[] returnType = decodeReturnType(descriptor);	716	char[] returnType = decodeReturnType(descriptor);
713	char[][] exceptionTypes = replace('/', '.', method.getExceptionTypeNames());	717	char[][] exceptionTypes = replace('/', '.', method.getExceptionTypeNames());
714	if (isConstructor) {	718	if (isConstructor) {
715	addConstructorDeclaration(className, parameterTypes, exceptionTypes);	719	noConstructor = false;
		720	char[] signature = method.getGenericSignature();
		721	if (signature == null) {
		722	if (reader.isNestedType() && ((modifiers & ClassFileConstants.AccStatic) == 0)) {
		723	signature = removeFirstSyntheticParameter(descriptor);
		724	} else {
		725	signature = descriptor;
		726	}
		727	}
		728	addConstructorDeclaration(
		729	name,
		730	parameterTypes == null ? 0 : parameterTypes.length,
		731	signature,
		732	parameterTypes,
		733	method.getArgumentNames(),
		734	method.getModifiers(),
		735	packageName,
		736	modifiers,
		737	exceptionTypes,
		738	extraFlags);
716	} else {	739	} else {
717	if (!method.isClinit()) {	740	if (!method.isClinit()) {
718	addMethodDeclaration(method.getSelector(), parameterTypes, returnType, exceptionTypes);	741	addMethodDeclaration(method.getSelector(), parameterTypes, returnType, exceptionTypes);
Lines 732-737 Link Here
732	}	755	}
733	}	756	}
734	}	757	}
		758	if (noConstructor) {
		759	addDefaultConstructorDeclaration(className, packageName, modifiers, extraFlags);
		760	}
735	FieldInfo[] fields = (FieldInfo[]) reader.getFields();	761	FieldInfo[] fields = (FieldInfo[]) reader.getFields();
736	if (fields != null) {	762	if (fields != null) {
737	for (int i = 0, max = fields.length; i < max; i++) {	763	for (int i = 0, max = fields.length; i < max; i++) {
Lines 767-772 Link Here
767	Util.log(IStatus.WARNING, "The Java indexing could not index " + this.document.getPath() + ". This .class file doesn't follow the class file format specification. Please report this issue against the .class file vendor"); //$NON-NLS-1$ //$NON-NLS-2$	793	Util.log(IStatus.WARNING, "The Java indexing could not index " + this.document.getPath() + ". This .class file doesn't follow the class file format specification. Please report this issue against the .class file vendor"); //$NON-NLS-1$ //$NON-NLS-2$
768	}	794	}
769	}	795	}
		796
		797	private char[] removeFirstSyntheticParameter(char[] descriptor) {
		798	if (descriptor == null) return null;
		799	if (descriptor.length < 3) return descriptor;
		800	if (descriptor[0] != '(') return descriptor;
		801	if (descriptor[1] != ')') {
		802	// remove the first synthetic parameter
		803	int start = Util.scanTypeSignature(descriptor, 1) + 1;
		804	int length = descriptor.length - start;
		805	char[] signature = new char[length + 1];
		806	signature[0] = descriptor[0];
		807	System.arraycopy(descriptor, start, signature, 1, length);
		808	return signature;
		809	} else {
		810	return descriptor;
		811	}
		812	}
770	/*	813	/*
771	* Modify the array by replacing all occurences of toBeReplaced with newChar	814	* Modify the array by replacing all occurences of toBeReplaced with newChar
772	*/	815	*/




	setStatementsRecovery(false);
}
public abstract char[] assistIdentifier();

/**
 * The parser become a simple parser which behave like a Parser
 * @return the state of the assist parser to be able to restore the assist parser state
 */
public Object becomeSimpleParser() {
	return null;
}
/**
 * Restore the parser as an assist parser
 * @param parserState
 */
public void restoreAssistParser(Object parserState) {
	//Do nothing
}
public int bodyEnd(AbstractMethodDeclaration method){
	return method.bodyEnd;
}

Lines 65-72 Link Here

(-)codeassist/org/eclipse/jdt/internal/codeassist/impl/Engine.java (-10 / +22 lines)
65	*/	65	*/
66	public void accept(ICompilationUnit sourceUnit, AccessRestriction accessRestriction) {	66	public void accept(ICompilationUnit sourceUnit, AccessRestriction accessRestriction) {
67	CompilationResult result = new CompilationResult(sourceUnit, 1, 1, this.compilerOptions.maxProblemsPerUnit);	67	CompilationResult result = new CompilationResult(sourceUnit, 1, 1, this.compilerOptions.maxProblemsPerUnit);
		68
		69	AssistParser assistParser = getParser();
		70	Object parserState = assistParser.becomeSimpleParser();
		71
68	CompilationUnitDeclaration parsedUnit =	72	CompilationUnitDeclaration parsedUnit =
69	getParser().dietParse(sourceUnit, result);	73	assistParser.dietParse(sourceUnit, result);
		74
		75	assistParser.restoreAssistParser(parserState);
70		76
71	this.lookupEnvironment.buildTypeBindings(parsedUnit, accessRestriction);	77	this.lookupEnvironment.buildTypeBindings(parsedUnit, accessRestriction);
72	this.lookupEnvironment.completeTypeBindings(parsedUnit, true);	78	this.lookupEnvironment.completeTypeBindings(parsedUnit, true);
Lines 97-114 Link Here
97	public abstract AssistParser getParser();	103	public abstract AssistParser getParser();
98		104
99	public void initializeImportCaches() {	105	public void initializeImportCaches() {
		106	if (this.currentPackageName == null) {
		107	initializePackageCache();
		108	}
		109
100	ImportBinding[] importBindings = this.unitScope.imports;	110	ImportBinding[] importBindings = this.unitScope.imports;
101	int length = importBindings == null ? 0 : importBindings.length;	111	int length = importBindings == null ? 0 : importBindings.length;
102		112
103	if (this.unitScope.fPackage != null) {
104	this.currentPackageName = CharOperation.concatWith(this.unitScope.fPackage.compoundName, '.');
105	} else if (this.unitScope.referenceContext != null &&
106	this.unitScope.referenceContext.currentPackage != null) {
107	this.currentPackageName = CharOperation.concatWith(this.unitScope.referenceContext.currentPackage.tokens, '.');
108	} else {
109	this.currentPackageName = CharOperation.NO_CHAR;
110	}
111
112	for (int i = 0; i < length; i++) {	113	for (int i = 0; i < length; i++) {
113	ImportBinding importBinding = importBindings[i];	114	ImportBinding importBinding = importBindings[i];
114	if(importBinding.onDemand) {	115	if(importBinding.onDemand) {
Lines 133-138 Link Here
133		134
134	this.importCachesInitialized = true;	135	this.importCachesInitialized = true;
135	}	136	}
		137
		138	public void initializePackageCache() {
		139	if (this.unitScope.fPackage != null) {
		140	this.currentPackageName = CharOperation.concatWith(this.unitScope.fPackage.compoundName, '.');
		141	} else if (this.unitScope.referenceContext != null &&
		142	this.unitScope.referenceContext.currentPackage != null) {
		143	this.currentPackageName = CharOperation.concatWith(this.unitScope.referenceContext.currentPackage.tokens, '.');
		144	} else {
		145	this.currentPackageName = CharOperation.NO_CHAR;
		146	}
		147	}
136		148
137	protected boolean mustQualifyType(	149	protected boolean mustQualifyType(
138	char[] packageName,	150	char[] packageName,




			isQualified ? CharOperation.concatWith(missingTypeName, '.') : null;
		final ArrayList results = new ArrayList();
		ISearchRequestor storage = new ISearchRequestor() {
			public void acceptConstructor(
					int modifiers,
					char[] simpleTypeName,
					int parameterCount,
					char[] signature,
					char[][] parameterTypes,
					char[][] parameterNames,
					int typeModifiers,
					char[] packageName,
					int extraFlags,
					String path,
					AccessRestriction access) {
				// constructors aren't searched
			}
			public void acceptPackage(char[] packageName) {
				// package aren't searched
			}




import org.eclipse.jdt.internal.codeassist.impl.Keywords;
import org.eclipse.jdt.internal.compiler.CompilationResult;
import org.eclipse.jdt.internal.compiler.DefaultErrorHandlingPolicies;
import org.eclipse.jdt.internal.compiler.ExtraFlags;
import org.eclipse.jdt.internal.compiler.ast.*;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.env.*;

import org.eclipse.jdt.internal.core.BasicCompilationUnit;
import org.eclipse.jdt.internal.core.INamingRequestor;
import org.eclipse.jdt.internal.core.InternalNamingConventions;
import org.eclipse.jdt.internal.core.JavaModelManager;
import org.eclipse.jdt.internal.core.SourceMethod;
import org.eclipse.jdt.internal.core.SourceMethodElementInfo;
import org.eclipse.jdt.internal.core.SourceType;
import org.eclipse.jdt.internal.core.BinaryTypeConverter;
import org.eclipse.jdt.internal.core.SearchableEnvironment;
import org.eclipse.jdt.internal.core.SourceTypeElementInfo;
import org.eclipse.jdt.internal.core.search.matching.JavaSearchNameEnvironment;
import org.eclipse.jdt.internal.core.util.Messages;

/**

	extends Engine
	implements ISearchRequestor, TypeConstants , TerminalTokens , RelevanceConstants, SuffixConstants {
	
	private static class AcceptedConstructor {
		public int modifiers;
		public char[] simpleTypeName;
		public int parameterCount;
		public char[] signature;
		public char[][] parameterTypes;
		public char[][] parameterNames;
		public int typeModifiers;
		public char[] packageName;
		public int extraFlags;
		public int accessibility;
		public boolean proposeType = false;
		public boolean proposeConstructor = false;
		public char[] fullyQualifiedName = null;
		
		public boolean mustBeQualified = false;
		
		public AcceptedConstructor(
				int modifiers,
				char[] simpleTypeName,
				int parameterCount,
				char[] signature,
				char[][] parameterTypes,
				char[][] parameterNames,
				int typeModifiers,
				char[] packageName,
				int extraFlags,
				int accessibility) {
			this.modifiers = modifiers;
			this.simpleTypeName = simpleTypeName;
			this.parameterCount = parameterCount;
			this.signature = signature;
			this.parameterTypes = parameterTypes;
			this.parameterNames = parameterNames;
			this.typeModifiers = typeModifiers;
			this.packageName = packageName;
			this.extraFlags = extraFlags;
			this.accessibility = accessibility;
		}

		public String toString() {
			StringBuffer buffer = new StringBuffer();
			buffer.append('{');
			buffer.append(this.packageName);
			buffer.append(',');
			buffer.append(this.simpleTypeName);
			buffer.append('}');
			return buffer.toString();
		}
	}
	
	private static class AcceptedType {
		public char[] packageName;
		public char[] simpleTypeName;

			this.checkProblems = false;
		}
	}
	
	public static char[] createBindingKey(char[] packageName, char[] typeName) {
		char[] signature = createTypeSignature(packageName, typeName);
		CharOperation.replace(signature, '.', '/');
		return signature;
	}

	public static char[][] createDefaultParameterNames(int length) {
		char[][] parameters;
		switch (length) {
			case 0 :
				parameters = new char[length][];
				break;
			case 1 :
				parameters = ARGS1;
				break;
			case 2 :
				parameters = ARGS2;
				break;
			case 3 :
				parameters = ARGS3;
				break;
			case 4 :
				parameters = ARGS4;
				break;
			default :
				parameters = new char[length][];
				for (int i = 0; i < length; i++) {
					parameters[i] = CharOperation.concat(ARG, String.valueOf(i).toCharArray());
				}
				break;
		}
		return parameters;
	}
	public static char[] createMethodSignature(char[][] parameterPackageNames, char[][] parameterTypeNames, char[] returnTypeSignature) {
		char[][] parameterTypeSignature = new char[parameterTypeNames.length][];
		for (int i = 0; i < parameterTypeSignature.length; i++) {

		result = CharOperation.replaceOnCopy(result, '/', '.');
		return result;
	}
	
	private static boolean hasStaticMemberTypes(ReferenceBinding typeBinding, SourceTypeBinding invocationType, CompilationUnitScope unitScope) {
		ReferenceBinding[] memberTypes = typeBinding.memberTypes();
		int length = memberTypes == null ? 0 : memberTypes.length;
		next : for (int i = 0; i < length; i++) {
			ReferenceBinding memberType = memberTypes[i];
			if (invocationType != null && !memberType.canBeSeenBy(typeBinding, invocationType)) {
				continue next;
			} else if(invocationType == null && !memberType.canBeSeenBy(unitScope.fPackage)) {
				continue next;
			}
			
			if ((memberType.modifiers & ClassFileConstants.AccStatic) != 0) {
				return true;
			}
		}
		return false;
	}
	public HashtableOfObject typeCache;
	
	public static boolean DEBUG = false;
	public static boolean PERF = false;
	
	private static final char[] KNOWN_TYPE_WITH_UNKNOWN_CONSTRUCTORS = new char[]{};
	private static final char[] KNOWN_TYPE_WITH_KNOWN_CONSTRUCTORS = new char[]{};
	
	private static final char[] ARG = "arg".toCharArray();  //$NON-NLS-1$
	private static final char[] ARG0 = "arg0".toCharArray();  //$NON-NLS-1$
	private static final char[] ARG1 = "arg1".toCharArray();  //$NON-NLS-1$
	private static final char[] ARG2 = "arg2".toCharArray();  //$NON-NLS-1$
	private static final char[] ARG3 = "arg3".toCharArray();  //$NON-NLS-1$
	private static final char[][] ARGS1 = new char[][]{ARG0};
	private static final char[][] ARGS2 = new char[][]{ARG0, ARG1};
	private static final char[][] ARGS3 = new char[][]{ARG0, ARG1, ARG2};
	private static final char[][] ARGS4 = new char[][]{ARG0, ARG1, ARG2, ARG3};
	
	private final static int CHECK_CANCEL_FREQUENCY = 50;
	
	// temporary constants to quickly disabled polish features if necessary
	public final static boolean NO_TYPE_COMPLETION_ON_EMPTY_TOKEN = false;

	private final static char[] VALUE = "value".toCharArray();  //$NON-NLS-1$
	private final static char[] EXTENDS = "extends".toCharArray();  //$NON-NLS-1$
	private final static char[] SUPER = "super".toCharArray();  //$NON-NLS-1$
	private final static char[] DEFAULT_CONSTRUCTOR_SIGNATURE = "()V".toCharArray();  //$NON-NLS-1$
	
	private final static char[] DOT = ".".toCharArray();  //$NON-NLS-1$


	CompletionRequestor requestor;
	CompletionProblemFactory problemFactory;
	ProblemReporter problemReporter;
	private JavaSearchNameEnvironment noCacheNameEnvironment;
	char[] source;
	char[] completionToken;
	char[] qualifiedCompletionToken;


	private int foundTypesCount;
	private ObjectVector acceptedTypes;
	
	private int foundConstructorsCount;
	private ObjectVector acceptedConstructors;

	/**
	 * The CompletionEngine is responsible for computing source completions.

		this.owner = owner;
		this.monitor = monitor;
	}
	
	public void acceptConstructor(
			int modifiers,
			char[] simpleTypeName,
			int parameterCount,
			char[] signature,
			char[][] parameterTypes,
			char[][] parameterNames,
			int typeModifiers,
			char[] packageName,
			int extraFlags,
			String path,
			AccessRestriction accessRestriction) {
		
		// does not check cancellation for every types to avoid performance loss
		if ((this.foundConstructorsCount % (CHECK_CANCEL_FREQUENCY)) == 0) checkCancel();
		this.foundConstructorsCount++;
		
		if ((typeModifiers & ClassFileConstants.AccEnum) != 0) return;
		
		if (this.options.checkDeprecation && (typeModifiers & ClassFileConstants.AccDeprecated) != 0) return;

		if (this.options.checkVisibility) {
			if((typeModifiers & ClassFileConstants.AccPublic) == 0) {
				if((typeModifiers & ClassFileConstants.AccPrivate) != 0) return;

				if (this.currentPackageName == null) {
					initializePackageCache();
				}
				
				if(!CharOperation.equals(packageName, this.currentPackageName)) return;
			}
		}

		int accessibility = IAccessRule.K_ACCESSIBLE;
		if(accessRestriction != null) {
			switch (accessRestriction.getProblemId()) {
				case IProblem.ForbiddenReference:
					if (this.options.checkForbiddenReference) {
						return;
					}
					accessibility = IAccessRule.K_NON_ACCESSIBLE;
					break;
				case IProblem.DiscouragedReference:
					if (this.options.checkDiscouragedReference) {
						return;
					}
					accessibility = IAccessRule.K_DISCOURAGED;
					break;
			}
		}
		
		if(this.acceptedConstructors == null) {
			this.acceptedConstructors = new ObjectVector();
		}
		this.acceptedConstructors.add(
				new AcceptedConstructor(
						modifiers,
						simpleTypeName,
						parameterCount,
						signature,
						parameterTypes,
						parameterNames,
						typeModifiers,
						packageName,
						extraFlags,
						accessibility));
	}
	
	private void acceptConstructors(Scope scope) {
		final boolean DEFER_QUALIFIED_PROPOSALS = false;
		
		this.checkCancel();
		
		if(this.acceptedConstructors == null) return;

		int length = this.acceptedConstructors.size();

		if(length == 0) return;
		
		HashtableOfObject onDemandFound = new HashtableOfObject();
		
		ArrayList deferredProposals = new ArrayList();
		
		try {
			next : for (int i = 0; i < length; i++) {
				
				// does not check cancellation for every types to avoid performance loss
				if ((i % CHECK_CANCEL_FREQUENCY) == 0) checkCancel();
				
				AcceptedConstructor acceptedConstructor = (AcceptedConstructor)this.acceptedConstructors.elementAt(i);
				final int typeModifiers = acceptedConstructor.typeModifiers;
				final char[] packageName = acceptedConstructor.packageName;
				final char[] simpleTypeName = acceptedConstructor.simpleTypeName;
				final int modifiers = acceptedConstructor.modifiers;
				final int parameterCount = acceptedConstructor.parameterCount;
				final char[] signature = acceptedConstructor.signature;
				final char[][] parameterTypes = acceptedConstructor.parameterTypes;
				final char[][] parameterNames = acceptedConstructor.parameterNames;
				final int extraFlags = acceptedConstructor.extraFlags;
				final int accessibility = acceptedConstructor.accessibility;
				
				boolean proposeType = (extraFlags & ExtraFlags.HasNonPrivateStaticMemberTypes) != 0;
				
				char[] fullyQualifiedName = CharOperation.concat(packageName, simpleTypeName, '.');
						
				Object knownTypeKind = this.knownTypes.get(fullyQualifiedName);
				if (knownTypeKind != null) {
					if (knownTypeKind == KNOWN_TYPE_WITH_KNOWN_CONSTRUCTORS) {
						// the type and its constructors are already accepted
						continue next;
					}
					// this type is already accepted
					proposeType = false;
				} else {
					this.knownTypes.put(fullyQualifiedName, KNOWN_TYPE_WITH_UNKNOWN_CONSTRUCTORS);
				}
				
				boolean proposeConstructor = true;
					
				if (this.options.checkVisibility) {
					if((modifiers & ClassFileConstants.AccPublic) == 0) {
						if((modifiers & ClassFileConstants.AccPrivate) != 0) {
							if (!proposeType) continue next;
							proposeConstructor = false;
						} else {
							if (this.currentPackageName == null) {
								initializePackageCache();
							}
							
							if(!CharOperation.equals(packageName, this.currentPackageName)) {
								if (!proposeType) continue next;
								proposeConstructor = false;
							}
						}
					}
				}
				
				acceptedConstructor.fullyQualifiedName = fullyQualifiedName;
				acceptedConstructor.proposeType = proposeType;
				acceptedConstructor.proposeConstructor = proposeConstructor;
				
				
				if(!this.importCachesInitialized) {
					initializeImportCaches();
				}
				
				for (int j = 0; j < this.importCacheCount; j++) {
					char[][] importName = this.importsCache[j];
					if(CharOperation.equals(simpleTypeName, importName[0])) {
						if (proposeType) {
							proposeType(
									packageName,
									simpleTypeName,
									typeModifiers,
									accessibility,
									simpleTypeName,
									fullyQualifiedName,
									!CharOperation.equals(fullyQualifiedName, importName[1]),
									scope);
						}
						
						if (proposeConstructor && !Flags.isEnum(typeModifiers)) {
							boolean isQualified = !CharOperation.equals(fullyQualifiedName, importName[1]);
							if (!isQualified) {
								proposeConstructor(
										simpleTypeName,
										parameterCount,
										signature,
										parameterTypes,
										parameterNames,
										modifiers,
										packageName,
										typeModifiers,
										accessibility,
										simpleTypeName,
										fullyQualifiedName,
										isQualified,
										scope,
										extraFlags);
							} else {
								acceptedConstructor.mustBeQualified = true;
								if (DEFER_QUALIFIED_PROPOSALS) {
									deferredProposals.add(acceptedConstructor);
								} else {
									proposeConstructor(acceptedConstructor, scope);
								}
							}
						}
						continue next;
					}
				}


				if (CharOperation.equals(this.currentPackageName, packageName)) {
					if (proposeType) {
						proposeType(
								packageName,
								simpleTypeName,
								typeModifiers,
								accessibility,
								simpleTypeName,
								fullyQualifiedName,
								false,
								scope);
					}
					
					if (proposeConstructor && !Flags.isEnum(typeModifiers)) {
						proposeConstructor(
								simpleTypeName,
								parameterCount,
								signature,
								parameterTypes,
								parameterNames,
								modifiers,
								packageName,
								typeModifiers,
								accessibility,
								simpleTypeName,
								fullyQualifiedName,
								false,
								scope,
								extraFlags);
					}
					continue next;
				} else {
					char[] fullyQualifiedEnclosingTypeOrPackageName = null;

					AcceptedConstructor foundConstructor = null;
					if((foundConstructor = (AcceptedConstructor)onDemandFound.get(simpleTypeName)) == null) {
						for (int j = 0; j < this.onDemandImportCacheCount; j++) {
							ImportBinding importBinding = this.onDemandImportsCache[j];

							char[][] importName = importBinding.compoundName;
							char[] importFlatName = CharOperation.concatWith(importName, '.');

							if(fullyQualifiedEnclosingTypeOrPackageName == null) {
								fullyQualifiedEnclosingTypeOrPackageName = packageName;
							}
							if(CharOperation.equals(fullyQualifiedEnclosingTypeOrPackageName, importFlatName)) {
								if(importBinding.isStatic()) {
									if((typeModifiers & ClassFileConstants.AccStatic) != 0) {
										onDemandFound.put(
												simpleTypeName,
												acceptedConstructor);
										continue next;
									}
								} else {
									onDemandFound.put(
											simpleTypeName,
											acceptedConstructor);
									continue next;
								}
							}
						}
					} else if(!foundConstructor.mustBeQualified){
						done : for (int j = 0; j < this.onDemandImportCacheCount; j++) {
							ImportBinding importBinding = this.onDemandImportsCache[j];

							char[][] importName = importBinding.compoundName;
							char[] importFlatName = CharOperation.concatWith(importName, '.');

							if(fullyQualifiedEnclosingTypeOrPackageName == null) {
								fullyQualifiedEnclosingTypeOrPackageName = packageName;
							}
							if(CharOperation.equals(fullyQualifiedEnclosingTypeOrPackageName, importFlatName)) {
								if(importBinding.isStatic()) {
									if((typeModifiers & ClassFileConstants.AccStatic) != 0) {
										foundConstructor.mustBeQualified = true;
										break done;
									}
								} else {
									foundConstructor.mustBeQualified = true;
									break done;
								}
							}
						}
					}
					if (proposeType) {
						proposeType(
								packageName,
								simpleTypeName,
								typeModifiers,
								accessibility,
								simpleTypeName,
								fullyQualifiedName,
								true,
								scope);
					}
					
					if (proposeConstructor && !Flags.isEnum(typeModifiers)) {
						acceptedConstructor.mustBeQualified = true;
						if (DEFER_QUALIFIED_PROPOSALS) {
							deferredProposals.add(acceptedConstructor);
						} else {
							proposeConstructor(acceptedConstructor, scope);
						}
					}
				}
			}
		
			char[][] keys = onDemandFound.keyTable;
			Object[] values = onDemandFound.valueTable;
			int max = keys.length;
			for (int i = 0; i < max; i++) {
				
				// does not check cancellation for every types to avoid performance loss
				if ((i % CHECK_CANCEL_FREQUENCY) == 0) checkCancel();
				
				if(keys[i] != null) {
					AcceptedConstructor value = (AcceptedConstructor) values[i];
					if(value != null) {
						if (value.proposeType) {
							proposeType(
									value.packageName,
									value.simpleTypeName,
									value.typeModifiers,
									value.accessibility,
									value.simpleTypeName,
									value.fullyQualifiedName,
									value.mustBeQualified,
									scope);
						}
						
						if (value.proposeConstructor && !Flags.isEnum(value.modifiers)) {
							if (!value.mustBeQualified) {
								proposeConstructor(
										value.simpleTypeName,
										value.parameterCount,
										value.signature,
										value.parameterTypes,
										value.parameterNames,
										value.modifiers,
										value.packageName,
										value.typeModifiers,
										value.accessibility,
										value.simpleTypeName,
										value.fullyQualifiedName,
										value.mustBeQualified,
										scope,
										value.extraFlags);
							} else {
								if (DEFER_QUALIFIED_PROPOSALS) {
									deferredProposals.add(value);
								} else {
									proposeConstructor(value, scope);
								}
							}
						}
					}
				}
			}
			
			if (DEFER_QUALIFIED_PROPOSALS) {
				int size = deferredProposals.size();
				for (int i = 0; i < size; i++) {
					
					// does not check cancellation for every types to avoid performance loss
					if ((i % CHECK_CANCEL_FREQUENCY) == 0) checkCancel();
				
					AcceptedConstructor deferredProposal = (AcceptedConstructor)deferredProposals.get(i);
					
					if (deferredProposal.proposeConstructor) {
						proposeConstructor(
								deferredProposal.simpleTypeName,
								deferredProposal.parameterCount,
								deferredProposal.signature,
								deferredProposal.parameterTypes,
								deferredProposal.parameterNames,
								deferredProposal.modifiers,
								deferredProposal.packageName,
								deferredProposal.typeModifiers,
								deferredProposal.accessibility,
								deferredProposal.simpleTypeName,
								deferredProposal.fullyQualifiedName,
								deferredProposal.mustBeQualified,
								scope,
								deferredProposal.extraFlags);
					}
				}
			}
		} finally {
			this.acceptedTypes = null; // reset
		}
	}

	/**
	 * One result of the search consists of a new package.

		AccessRestriction accessRestriction) {
		
		// does not check cancellation for every types to avoid performance loss
		if ((this.foundTypesCount % CHECK_CANCEL_FREQUENCY) == 0) checkCancel();
		this.foundTypesCount++;
		
		if (this.options.checkDeprecation && (modifiers & ClassFileConstants.AccDeprecated) != 0) return;

			next : for (int i = 0; i < length; i++) {
				
				// does not check cancellation for every types to avoid performance loss
				if ((i % CHECK_CANCEL_FREQUENCY) == 0) checkCancel();
				
				AcceptedType acceptedType = (AcceptedType)this.acceptedTypes.elementAt(i);
				char[] packageName = acceptedType.packageName;

	
				if (this.knownTypes.containsKey(fullyQualifiedName)) continue next;
	
				this.knownTypes.put(fullyQualifiedName, KNOWN_TYPE_WITH_UNKNOWN_CONSTRUCTORS);
	
				if (this.resolvingImports) {
					if(this.compilerOptions.complianceLevel >= ClassFileConstants.JDK1_4 && packageName.length == 0) {

			Object[] values = onDemandFound.valueTable;
			int max = keys.length;
			for (int i = 0; i < max; i++) {
				if ((i % CHECK_CANCEL_FREQUENCY) == 0) checkCancel();
				if(keys[i] != null) {
					AcceptedType value = (AcceptedType) values[i];
					if(value != null) {

		this.assistNodeIsClass = ref.isClass();
		this.assistNodeIsException = ref.isException();
		this.assistNodeIsInterface = ref.isInterface();
		this.assistNodeIsConstructor = ref.isConstructorType;
		this.assistNodeIsSuperType = ref.isSuperType();

		this.completionToken = ref.completionIdentifier;

						TypeBinding caughtException = catchArguments[i].type.resolvedType;
						if (caughtException != null) {
							addForbiddenBindings(caughtException);
							this.knownTypes.put(CharOperation.concat(caughtException.qualifiedPackageName(), caughtException.qualifiedSourceName(), '.'), KNOWN_TYPE_WITH_KNOWN_CONSTRUCTORS);
						}
					}
					this.forbbidenBindingsFilter = SUBTYPE;

		}
	}
	private void findAnonymousType(
			ReferenceBinding currentType,
			TypeBinding[] argTypes,
			Scope scope,
			InvocationSite invocationSite) {
		
		int relevance = computeBaseRelevance();
		relevance += computeRelevanceForResolution();
		relevance += computeRelevanceForInterestingProposal();
		relevance += computeRelevanceForRestrictions(IAccessRule.K_ACCESSIBLE);
		
		findAnonymousType(currentType, argTypes, scope, invocationSite, true, false, relevance);
	}
	private void findAnonymousType(
		ReferenceBinding currentType,
		TypeBinding[] argTypes,
		Scope scope,
		InvocationSite invocationSite,
		boolean exactMatch,
		boolean isQualified,
		int relevance) {

		if (currentType.isInterface()) {
			char[] completion = CharOperation.NO_CHAR;
			
			if (!exactMatch) {
				char[] typeName = 
					isQualified ?
							CharOperation.concat(currentType.qualifiedPackageName(), currentType.qualifiedSourceName(), '.') :
								currentType.sourceName();
				completion = CharOperation.concat(typeName, new char[]{'(', ')'});
			}

			this.noProposal = false;
			if (!exactMatch) {
				if(!this.requestor.isIgnored(CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION)) {
					InternalCompletionProposal proposal = createProposal(CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION, this.actualCompletionPosition);
					proposal.setDeclarationSignature(getSignature(currentType));
					proposal.setDeclarationKey(currentType.computeUniqueKey());
					proposal.setSignature(
							createMethodSignature(
									CharOperation.NO_CHAR_CHAR,
									CharOperation.NO_CHAR_CHAR,
									CharOperation.NO_CHAR,
									CharOperation.NO_CHAR));
					//proposal.setOriginalSignature(null);
					//proposal.setUniqueKey(null);
					proposal.setDeclarationPackageName(currentType.qualifiedPackageName());
					proposal.setDeclarationTypeName(currentType.qualifiedSourceName());
					//proposal.setParameterPackageNames(null);
					//proposal.setParameterTypeNames(null);
					//proposal.setPackageName(null);
					//proposal.setTypeName(null);
					proposal.setCompletion(completion);
					proposal.setFlags(Flags.AccPublic);
					proposal.setReplaceRange(this.startPosition - this.offset, this.endPosition - this.offset);
					proposal.setTokenRange(this.tokenStart - this.offset, this.tokenEnd - this.offset);
					proposal.setRelevance(relevance);
					this.requestor.accept(proposal);
					if(DEBUG) {
						this.printDebug(proposal);
					}
				}
			}  else {
				if(!this.requestor.isIgnored(CompletionProposal.ANONYMOUS_CLASS_DECLARATION)) {
					InternalCompletionProposal proposal = createProposal(CompletionProposal.ANONYMOUS_CLASS_DECLARATION, this.actualCompletionPosition);
					proposal.setDeclarationSignature(getSignature(currentType));
					proposal.setDeclarationKey(currentType.computeUniqueKey());
					proposal.setSignature(
							createMethodSignature(
									CharOperation.NO_CHAR_CHAR,
									CharOperation.NO_CHAR_CHAR,
									CharOperation.NO_CHAR,
									CharOperation.NO_CHAR));
					//proposal.setOriginalSignature(null);
					//proposal.setUniqueKey(null);
					proposal.setDeclarationPackageName(currentType.qualifiedPackageName());
					proposal.setDeclarationTypeName(currentType.qualifiedSourceName());
					//proposal.setParameterPackageNames(null);
					//proposal.setParameterTypeNames(null);
					//proposal.setPackageName(null);
					//proposal.setTypeName(null);
					proposal.setCompletion(completion);
					proposal.setFlags(Flags.AccPublic);
					proposal.setReplaceRange(this.endPosition - this.offset, this.endPosition - this.offset);
					proposal.setTokenRange(this.tokenEnd - this.offset, this.tokenEnd - this.offset);
					proposal.setRelevance(relevance);
					this.requestor.accept(proposal);
					if(DEBUG) {
						this.printDebug(proposal);
					}
				}
			}
		} else {

				argTypes,
				scope,
				invocationSite,
				true,
				exactMatch,
				isQualified,
				relevance);
		}
	}
	private void findClassField(

		Scope scope,
		InvocationSite invocationSite,
		boolean forAnonymousType) {
		
		int relevance = computeBaseRelevance();
						relevance += computeRelevanceForResolution();
						relevance += computeRelevanceForInterestingProposal();
						relevance += computeRelevanceForRestrictions(IAccessRule.K_ACCESSIBLE);
		
		findConstructors(currentType, argTypes, scope, invocationSite, forAnonymousType, true, false, relevance);
	}
		
	private void findConstructors(
		ReferenceBinding currentType,
		TypeBinding[] argTypes,
		Scope scope,
		InvocationSite invocationSite,
		boolean forAnonymousType,
		boolean exactMatch,
		boolean isQualified,
		int relevance) {

		// No visibility checks can be performed without the scope & invocationSite
		MethodBinding[] methods = currentType.availableMethods();

					char[][] parameterNames = findMethodParameterNames(constructor,parameterTypeNames);

					char[] completion = CharOperation.NO_CHAR;
					
					if(forAnonymousType){
						if (!exactMatch) {
							char[] typeName = 
								isQualified ?
										CharOperation.concat(currentType.qualifiedPackageName(), currentType.qualifiedSourceName(), '.') :
											currentType.sourceName();
							completion = CharOperation.concat(typeName, new char[]{'(', ')'});
						}
						
						this.noProposal = false;
						if (!exactMatch) {
							if(!this.requestor.isIgnored(CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION)) {
								InternalCompletionProposal proposal = createProposal(CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION, this.actualCompletionPosition);
								proposal.setDeclarationSignature(getSignature(currentType));
								proposal.setDeclarationKey(currentType.computeUniqueKey());
								proposal.setSignature(getSignature(constructor));
								MethodBinding original = constructor.original();
								if(original != constructor) {
									proposal.setOriginalSignature(getSignature(original));
								}
								proposal.setKey(constructor.computeUniqueKey());
								proposal.setDeclarationPackageName(currentType.qualifiedPackageName());
								proposal.setDeclarationTypeName(currentType.qualifiedSourceName());
								proposal.setParameterPackageNames(parameterPackageNames);
								proposal.setParameterTypeNames(parameterTypeNames);
								//proposal.setPackageName(null);
								//proposal.setTypeName(null);
								proposal.setCompletion(completion);
								proposal.setFlags(constructor.modifiers);
								proposal.setReplaceRange(this.startPosition - this.offset, this.endPosition - this.offset);
								proposal.setTokenRange(this.tokenStart - this.offset, this.tokenEnd - this.offset);
								proposal.setRelevance(relevance);
								if(parameterNames != null) proposal.setParameterNames(parameterNames);
								this.requestor.accept(proposal);
								if(DEBUG) {
									this.printDebug(proposal);
								}
							}
						} else {
							if(!this.requestor.isIgnored(CompletionProposal.ANONYMOUS_CLASS_DECLARATION)) {
								InternalCompletionProposal proposal = createProposal(CompletionProposal.ANONYMOUS_CLASS_DECLARATION, this.actualCompletionPosition);
								proposal.setDeclarationSignature(getSignature(currentType));
								proposal.setDeclarationKey(currentType.computeUniqueKey());
								proposal.setSignature(getSignature(constructor));
								MethodBinding original = constructor.original();
								if(original != constructor) {
									proposal.setOriginalSignature(getSignature(original));
								}
								proposal.setKey(constructor.computeUniqueKey());
								proposal.setDeclarationPackageName(currentType.qualifiedPackageName());
								proposal.setDeclarationTypeName(currentType.qualifiedSourceName());
								proposal.setParameterPackageNames(parameterPackageNames);
								proposal.setParameterTypeNames(parameterTypeNames);
								//proposal.setPackageName(null);
								//proposal.setTypeName(null);
								proposal.setCompletion(completion);
								proposal.setFlags(constructor.modifiers);
								proposal.setReplaceRange(this.endPosition - this.offset, this.endPosition - this.offset);
								proposal.setTokenRange(this.tokenEnd - this.offset, this.tokenEnd - this.offset);
								proposal.setRelevance(relevance);
								if(parameterNames != null) proposal.setParameterNames(parameterNames);
								this.requestor.accept(proposal);
								if(DEBUG) {
									this.printDebug(proposal);
								}
							}
						}
					} else {
						int relevance = computeBaseRelevance();
						relevance += computeRelevanceForResolution();
						relevance += computeRelevanceForInterestingProposal();
						relevance += computeRelevanceForRestrictions(IAccessRule.K_ACCESSIBLE);

						// Special case for completion in javadoc
						if (this.assistNodeInJavadoc > 0) {
							Expression receiver = null;

								javadocCompletion.append(')');
								completion = javadocCompletion.toString().toCharArray();
							}
						} else {
							if (!exactMatch) {
								char[] typeName = 
									isQualified ?
											CharOperation.concat(currentType.qualifiedPackageName(), currentType.qualifiedSourceName(), '.') :
												currentType.sourceName();
								completion = CharOperation.concat(typeName, new char[]{'(', ')'});
							}
						}

						// Create standard proposal
						this.noProposal = false;
						if (!exactMatch) {
							if(!this.requestor.isIgnored(CompletionProposal.CONSTRUCTOR_INVOCATION)) {
								InternalCompletionProposal proposal =  createProposal(CompletionProposal.CONSTRUCTOR_INVOCATION, this.actualCompletionPosition);
								proposal.setDeclarationSignature(getSignature(currentType));
								proposal.setSignature(getSignature(constructor));
								MethodBinding original = constructor.original();
								if(original != constructor) {
									proposal.setOriginalSignature(getSignature(original));
								}
								proposal.setDeclarationPackageName(currentType.qualifiedPackageName());
								proposal.setDeclarationTypeName(currentType.qualifiedSourceName());
								proposal.setParameterPackageNames(parameterPackageNames);
								proposal.setParameterTypeNames(parameterTypeNames);
								//proposal.setPackageName(null);
								//proposal.setTypeName(null);
								proposal.setName(currentType.sourceName());
								proposal.setIsContructor(true);
								proposal.setCompletion(completion);
								proposal.setFlags(constructor.modifiers);
								proposal.setReplaceRange(this.startPosition - this.offset, this.endPosition - this.offset);
								proposal.setTokenRange(this.tokenStart - this.offset, this.tokenEnd - this.offset);
								proposal.setRelevance(relevance);
								if(parameterNames != null) proposal.setParameterNames(parameterNames);
								this.requestor.accept(proposal);
								if(DEBUG) {
									this.printDebug(proposal);
								}
							}
						} else {
							if(!this.requestor.isIgnored(CompletionProposal.METHOD_REF) && (this.assistNodeInJavadoc & CompletionOnJavadoc.ONLY_INLINE_TAG) == 0) {
								InternalCompletionProposal proposal =  createProposal(CompletionProposal.METHOD_REF, this.actualCompletionPosition);
								proposal.setDeclarationSignature(getSignature(currentType));
								proposal.setSignature(getSignature(constructor));
								MethodBinding original = constructor.original();
								if(original != constructor) {
									proposal.setOriginalSignature(getSignature(original));
								}
								proposal.setDeclarationPackageName(currentType.qualifiedPackageName());
								proposal.setDeclarationTypeName(currentType.qualifiedSourceName());
								proposal.setParameterPackageNames(parameterPackageNames);
								proposal.setParameterTypeNames(parameterTypeNames);
								//proposal.setPackageName(null);
								//proposal.setTypeName(null);
								proposal.setName(currentType.sourceName());
								proposal.setIsContructor(true);
								proposal.setCompletion(completion);
								proposal.setFlags(constructor.modifiers);
								int start = (this.assistNodeInJavadoc > 0) ? this.startPosition : this.endPosition;
								proposal.setReplaceRange(start - this.offset, this.endPosition - this.offset);
								proposal.setTokenRange(this.tokenStart - this.offset, this.tokenEnd - this.offset);
								proposal.setRelevance(relevance);
								if(parameterNames != null) proposal.setParameterNames(parameterNames);
								this.requestor.accept(proposal);
								if(DEBUG) {
									this.printDebug(proposal);
								}
							}
							if ((this.assistNodeInJavadoc & CompletionOnJavadoc.TEXT) != 0 && !this.requestor.isIgnored(CompletionProposal.JAVADOC_METHOD_REF)) {
								char[] javadocCompletion = inlineTagCompletion(completion, JavadocTagConstants.TAG_LINK);
								InternalCompletionProposal proposal =  createProposal(CompletionProposal.JAVADOC_METHOD_REF, this.actualCompletionPosition);
								proposal.setDeclarationSignature(getSignature(currentType));
								proposal.setSignature(getSignature(constructor));
								MethodBinding original = constructor.original();
								if(original != constructor) {
									proposal.setOriginalSignature(getSignature(original));
								}
								proposal.setDeclarationPackageName(currentType.qualifiedPackageName());
								proposal.setDeclarationTypeName(currentType.qualifiedSourceName());
								proposal.setParameterPackageNames(parameterPackageNames);
								proposal.setParameterTypeNames(parameterTypeNames);
								//proposal.setPackageName(null);
								//proposal.setTypeName(null);
								proposal.setName(currentType.sourceName());
								proposal.setIsContructor(true);
								proposal.setCompletion(javadocCompletion);
								proposal.setFlags(constructor.modifiers);
								int start = (this.assistNodeInJavadoc & CompletionOnJavadoc.REPLACE_TAG) != 0 ? this.javadocTagPosition : this.startPosition;
								proposal.setReplaceRange(start - this.offset, this.endPosition - this.offset);
								proposal.setTokenRange(this.tokenStart - this.offset, this.tokenEnd - this.offset);
								proposal.setRelevance(relevance+R_INLINE_TAG);
								if(parameterNames != null) proposal.setParameterNames(parameterNames);
								this.requestor.accept(proposal);
								if(DEBUG) {
									this.printDebug(proposal);
								}
							}
						}
					}
				}
			}
		}
	}
	
	private char[] getResolvedSignature(char[][] parameterTypes, char[] fullyQualifiedTypeName, int parameterCount, Scope scope) {
		char[][] cn = CharOperation.splitOn('.', fullyQualifiedTypeName);

		TypeReference ref;
		if (cn.length == 1) {
			ref = new SingleTypeReference(cn[0], 0);
		} else {
			ref = new QualifiedTypeReference(cn,new long[cn.length]);
		}
		
		TypeBinding guessedType = null;
		INameEnvironment oldNameEnvironment = this.lookupEnvironment.nameEnvironment;
		this.lookupEnvironment.nameEnvironment = getNoCacheNameEnvironment();
		try {
			switch (scope.kind) {
				case Scope.METHOD_SCOPE :
				case Scope.BLOCK_SCOPE :
					guessedType = ref.resolveType((BlockScope)scope);
					break;
				case Scope.CLASS_SCOPE :
					guessedType = ref.resolveType((ClassScope)scope);
					break;
			}
		} finally {
			this.lookupEnvironment.nameEnvironment = oldNameEnvironment;
		}

		if (guessedType != null && guessedType.isValidBinding()) {
			if (guessedType instanceof ReferenceBinding) {
				ReferenceBinding refBinding = (ReferenceBinding) guessedType;
				
				MethodBinding bestConstructor = null;
				int[] bestMatchingLengths = null;
				
				MethodBinding[] methods = refBinding.methods();
				next : for (int i = 0; i < methods.length; i++) {
					MethodBinding method = methods[i];
					
					if (!method.isConstructor()) break next;
					
					TypeBinding[] parameters = method.parameters;
					//TODO take careful of member types
					int parametersLength = parameters == null ? 0 : parameters.length;
					if (parameterCount != parametersLength) continue next;
					
					int[] matchingLengths = new int[parameterCount];
					for (int j = 0; j < parametersLength; j++) {
						TypeBinding parameter = parameters[j];
						
						char[] parameterTypeName;
						if (parameter instanceof ReferenceBinding) {
							parameterTypeName = CharOperation.concatWith(((ReferenceBinding)parameter).compoundName, '.');
						} else {
							parameterTypeName = parameter.sourceName();
						}
						
						if (!CharOperation.endsWith(parameterTypeName, parameterTypes[j])) {
							break next;
						}
						
						int matchingLength = parameterTypes[j].length;
						
						if (bestMatchingLengths != null) {
							if (bestMatchingLengths[j] > matchingLength) {
								continue next;
							}
						}
						
						matchingLengths[j] = matchingLength;
					}
					
					
					bestConstructor = method;
					bestMatchingLengths = matchingLengths;
				}
				
				if (bestConstructor == null) return null;
				return getSignature(bestConstructor);
			}
		}
		
		return null;
	}

	private void findConstructorsOrAnonymousTypes(
			ReferenceBinding currentType,
			Scope scope,
			InvocationSite invocationSite,
			boolean isQualified,
			int relevance) {
		
		if (!this.requestor.isIgnored(CompletionProposal.CONSTRUCTOR_INVOCATION)
				&& currentType.isClass()
				&& !currentType.isAbstract()) {
				findConstructors(
					currentType,
					null,
					scope,
					invocationSite,
					false,
					false,
					isQualified,
					relevance);
		}
		
		// This code is disabled because there is too much proposals when constructors and anonymous are proposed
		if (!this.requestor.isIgnored(CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION)
				&& !currentType.isFinal()
				&& (currentType.isInterface() || (currentType.isClass() && currentType.isAbstract()))){
			findAnonymousType(
				currentType,
				null,
				scope,
				invocationSite,
				false,
				isQualified,
				relevance);
		}
	}
	private char[][] findEnclosingTypeNames(Scope scope){
		char[][] excludedNames = new char[10][];

				relevance += computeRelevanceForMissingElements(missingElementsHaveProblems);
			}

			boolean allowingLongComputationProposals = this.requestor.isAllowingLongComputationProposals();
			
			this.noProposal = false;
			if (!this.assistNodeIsConstructor || !allowingLongComputationProposals || hasStaticMemberTypes(memberType, invocationType, this.unitScope)) {
				createTypeProposal(
						memberType,
						memberType.qualifiedSourceName(),
						IAccessRule.K_ACCESSIBLE,
						completionName,
						relevance,
						missingElements,
						missingElementsStarts,
						missingElementsEnds,
						missingElementsHaveProblems);
			}
			
			if (this.assistNodeIsConstructor && allowingLongComputationProposals) {
				findConstructorsOrAnonymousTypes(
						memberType,
						scope,
						FakeInvocationSite,
						isQualified,
						relevance);
			}
		}
	}
	private void findMemberTypesFromMissingType(

								relevance += computeRelevanceForRestrictions(IAccessRule.K_ACCESSIBLE); // no access restriction for nested type
								relevance += computeRelevanceForAnnotationTarget(localType);

								boolean allowingLongComputationProposals = this.requestor.isAllowingLongComputationProposals();
								if (!this.assistNodeIsConstructor || !allowingLongComputationProposals) {
									this.noProposal = false;
									if(!this.requestor.isIgnored(CompletionProposal.TYPE_REF)) {
										createTypeProposal(
												localType,
												localType.sourceName,
												IAccessRule.K_ACCESSIBLE,
												localType.sourceName,
												relevance,
												null,
												null,
												null,
												false);
									}
								}
								
								if (this.assistNodeIsConstructor && allowingLongComputationProposals) {
									findConstructorsOrAnonymousTypes(
											localType,
											blockScope,
											FakeInvocationSite,
											false,
											relevance);
											null,
											null,
											null,
											false);
								}
							}
						}


		if (token == null)
			return;
		
		boolean allowingLongComputationProposals = this.requestor.isAllowingLongComputationProposals();
		
		boolean proposeType =
			!this.requestor.isIgnored(CompletionProposal.TYPE_REF) ||
			((this.assistNodeInJavadoc & CompletionOnJavadoc.TEXT) != 0 && !this.requestor.isIgnored(CompletionProposal.JAVADOC_TYPE_REF));

		boolean proposeAllMemberTypes = !this.assistNodeIsConstructor;
		
		boolean proposeConstructor =
			allowingLongComputationProposals &&
			this.assistNodeIsConstructor &&
			(!this.requestor.isIgnored(CompletionProposal.CONSTRUCTOR_INVOCATION) || !this.requestor.isIgnored(CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION));
		

		if ((proposeType || proposeConstructor) && scope.enclosingSourceType() != null) {
			
			checkCancel();
			


		boolean isEmptyPrefix = token.length == 0;

		if ((proposeType || proposeConstructor) && this.unitScope != null) {
			
			ReferenceBinding outerInvocationType = scope.enclosingSourceType();
			if(outerInvocationType != null) {

				if (typeLength > sourceType.sourceName.length) continue next;

				if (!CharOperation.prefixEquals(token, sourceType.sourceName, false)
						&& !(this.options.camelCaseMatch && CharOperation.camelCaseMatch(token, sourceType.sourceName))) continue next;

				if (this.assistNodeIsAnnotation && !hasPossibleAnnotationTarget(sourceType, scope)) {
					continue next;


					if (sourceType == otherType) continue next;
				}
				
				typesFound.add(sourceType);

				if(this.assistNodeIsClass) {
					if(!sourceType.isClass()) continue next;

					relevance += computeRelevanceForClass();
					relevance += computeRelevanceForException(sourceType.sourceName);
				}
				
				
				this.noProposal = false;
				if(proposeType && (!this.assistNodeIsConstructor || !allowingLongComputationProposals || hasStaticMemberTypes(sourceType, null, this.unitScope))) {
					char[] typeName = sourceType.sourceName();
					createTypeProposal(
							sourceType,

							null,
							false);
				}
				
				if (proposeConstructor) {
					findConstructorsOrAnonymousTypes(
							sourceType,
							scope,
							FakeInvocationSite,
							false,
							relevance);
				}
			}
		}

		if (proposeConstructor && !isEmptyPrefix) {
			
			checkCancel();
			
			findTypesFromImports(token, scope, proposeType, typesFound);
		} else if(proposeType) {
			
			checkCancel();
			
			findTypesFromStaticImports(token, scope, proposeAllMemberTypes, typesFound);
		}
		
		if (proposeConstructor) {
			
			checkCancel();
			
			findTypesFromExpectedTypes(token, scope, typesFound, proposeType, proposeConstructor);
		}

		if (isEmptyPrefix && !this.assistNodeIsAnnotation) {
			if (!proposeConstructor) {
				findTypesFromExpectedTypes(token, scope, typesFound, proposeType, proposeConstructor);
			}
		} else {
			if(!isEmptyPrefix && !this.requestor.isIgnored(CompletionProposal.KEYWORD)) {
				if (this.assistNodeInJavadoc == 0 || (this.assistNodeInJavadoc & CompletionOnJavadoc.BASE_TYPES) != 0) {
					if (proposeBaseTypes) {
						if (proposeVoidType) {
							findKeywords(token, BASE_TYPE_NAMES, false, false);
						} else {
							findKeywords(token, BASE_TYPE_NAMES_WITHOUT_VOID, false, false);
						}
						if (this.options.checkDeprecation &&
								refBinding.isViewedAsDeprecated() &&
								!scope.isDefinedInSameUnit(refBinding))
							continue next;

						int accessibility = IAccessRule.K_ACCESSIBLE;
						if(refBinding.hasRestrictedAccess()) {
							AccessRestriction accessRestriction = this.lookupEnvironment.getAccessRestriction(refBinding);
							if(accessRestriction != null) {
								switch (accessRestriction.getProblemId()) {
									case IProblem.ForbiddenReference:
										if (this.options.checkForbiddenReference) {
											continue next;
										}
										accessibility = IAccessRule.K_NON_ACCESSIBLE;
										break;
									case IProblem.DiscouragedReference:
										if (this.options.checkDiscouragedReference) {
											continue next;
										}
										accessibility = IAccessRule.K_DISCOURAGED;
										break;
								}
							}
						}

						for (int j = 0; j < typesFound.size(); j++) {
							ReferenceBinding typeFound = (ReferenceBinding)typesFound.elementAt(j);
							if (typeFound == refBinding) {
								continue next;
							}
						}

						boolean inSameUnit = this.unitScope.isDefinedInSameUnit(refBinding);

						// top level types of the current unit are already proposed.
						if(!inSameUnit || (inSameUnit && refBinding.isMemberType())) {
							char[] packageName = refBinding.qualifiedPackageName();
							char[] typeName = refBinding.sourceName();
							char[] completionName = typeName;

							boolean isQualified = false;
							if (!this.insideQualifiedReference && !refBinding.isMemberType()) {
								if (mustQualifyType(packageName, typeName, null, refBinding.modifiers)) {
									if (packageName == null || packageName.length == 0)
										if (this.unitScope != null && this.unitScope.fPackage.compoundName != CharOperation.NO_CHAR_CHAR)
											continue next; // ignore types from the default package from outside it
									completionName = CharOperation.concat(packageName, typeName, '.');
									isQualified = true;
								}
							}

							if(this.assistNodeIsClass) {
								if(!refBinding.isClass()) continue next;
							} else if(this.assistNodeIsInterface) {
								if(!refBinding.isInterface() && !refBinding.isAnnotationType()) continue next;
							} else if (this.assistNodeIsAnnotation) {
								if(!refBinding.isAnnotationType()) continue next;
							}

							int relevance = computeBaseRelevance();
							relevance += computeRelevanceForResolution();
							relevance += computeRelevanceForInterestingProposal();
							relevance += computeRelevanceForCaseMatching(token, typeName);
							relevance += computeRelevanceForExpectingType(refBinding);
							relevance += computeRelevanceForQualification(isQualified);
							relevance += computeRelevanceForRestrictions(accessibility);

							if(refBinding.isClass()) {
								relevance += computeRelevanceForClass();
								relevance += computeRelevanceForException(typeName);
							} else if(refBinding.isEnum()) {
								relevance += computeRelevanceForEnum();
							} else if(refBinding.isInterface()) {
								relevance += computeRelevanceForInterface();
							}

							this.noProposal = false;
							if(!this.requestor.isIgnored(CompletionProposal.TYPE_REF)) {
								InternalCompletionProposal proposal =  createProposal(CompletionProposal.TYPE_REF, this.actualCompletionPosition);
								proposal.setDeclarationSignature(packageName);
								proposal.setSignature(getSignature(refBinding));
								proposal.setPackageName(packageName);
								proposal.setTypeName(typeName);
								proposal.setCompletion(completionName);
								proposal.setFlags(refBinding.modifiers);
								proposal.setReplaceRange(this.startPosition - this.offset, this.endPosition - this.offset);
								proposal.setTokenRange(this.tokenStart - this.offset, this.tokenEnd - this.offset);
								proposal.setRelevance(relevance);
								proposal.setAccessibility(accessibility);
								this.requestor.accept(proposal);
								if(DEBUG) {
									this.printDebug(proposal);
								}
							}
						}
					}
				}
			}
			
			if (proposeConstructor) {
				int l = typesFound.size();
				for (int i = 0; i < l; i++) {
					ReferenceBinding typeFound = (ReferenceBinding) typesFound.elementAt(i);
					char[] fullyQualifiedTypeName =
						CharOperation.concat(
								typeFound.qualifiedPackageName(),
								typeFound.qualifiedSourceName(),
								'.');
					this.knownTypes.put(fullyQualifiedTypeName, KNOWN_TYPE_WITH_KNOWN_CONSTRUCTORS);
				}
				
				checkCancel();
				
				this.foundConstructorsCount = 0;
				this.nameEnvironment.findConstructorDeclarations(
						token,
						this.options.camelCaseMatch,
						this,
						this.monitor);
				acceptConstructors(scope);
			} else if (proposeType) {
				int l = typesFound.size();
				for (int i = 0; i < l; i++) {
					ReferenceBinding typeFound = (ReferenceBinding) typesFound.elementAt(i);

								typeFound.qualifiedPackageName(),
								typeFound.qualifiedSourceName(),
								'.');
					this.knownTypes.put(fullyQualifiedTypeName, KNOWN_TYPE_WITH_KNOWN_CONSTRUCTORS);
				}
				int searchFor = IJavaSearchConstants.TYPE;
				if(this.assistNodeIsClass) {

		char[] token,
		PackageBinding packageBinding,
		Scope scope) {
		
		boolean allowingLongComputationProposals = this.requestor.isAllowingLongComputationProposals();

		boolean proposeType =
			!this.requestor.isIgnored(CompletionProposal.TYPE_REF) ||
			((this.assistNodeInJavadoc & CompletionOnJavadoc.TEXT) != 0 && !this.requestor.isIgnored(CompletionProposal.JAVADOC_TYPE_REF));
		
		boolean proposeConstructor =
			allowingLongComputationProposals &&
			this.assistNodeIsConstructor &&
			(!this.requestor.isIgnored(CompletionProposal.CONSTRUCTOR_INVOCATION) || !this.requestor.isIgnored(CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION));

		char[] qualifiedName =
			CharOperation.concatWith(packageBinding.compoundName, token, '.');


		this.qualifiedCompletionToken = qualifiedName;

		if ((proposeType || proposeConstructor) && this.unitScope != null) {
			int typeLength = qualifiedName.length;
			SourceTypeBinding[] types = this.unitScope.topLevelTypes;


					}
				}

				this.knownTypes.put(CharOperation.concat(sourceType.qualifiedPackageName(), sourceType.sourceName(), '.'), KNOWN_TYPE_WITH_KNOWN_CONSTRUCTORS);

				int relevance = computeBaseRelevance();
				relevance += computeRelevanceForResolution();

					relevance += computeRelevanceForClass();
					relevance += computeRelevanceForException(sourceType.sourceName);
				}
				
				this.noProposal = false;
				if(proposeType && (!this.assistNodeIsConstructor || !allowingLongComputationProposals || hasStaticMemberTypes(sourceType, null, this.unitScope))) {
					char[] typeName = sourceType.sourceName();
					createTypeProposal(
							sourceType,

							null,
							false);
				}
				
				if (proposeConstructor) {
					findConstructorsOrAnonymousTypes(
							sourceType,
							scope,
							FakeInvocationSite,
							false,
							relevance);
				}
			}
		}

		if (proposeConstructor) {

			
			checkCancel();
			
			this.foundConstructorsCount = 0;
			this.nameEnvironment.findConstructorDeclarations(
					qualifiedName,
					this.options.camelCaseMatch,
					this,
					this.monitor);
			acceptConstructors(scope);
		} if(proposeType) {
			int searchFor = IJavaSearchConstants.TYPE;
			if(this.assistNodeIsClass) {
				searchFor = IJavaSearchConstants.CLASS;

					this.monitor);
			acceptTypes(scope);
		}
		
		if(!this.requestor.isIgnored(CompletionProposal.PACKAGE_REF)) {
			this.nameEnvironment.findPackages(qualifiedName, this);
		}
	}
	
	private void findTypesFromExpectedTypes(char[] token, Scope scope, ObjectVector typesFound, boolean proposeType, boolean proposeConstructor) {
		if(this.expectedTypesPtr > -1) {
			boolean allowingLongComputationProposals = this.requestor.isAllowingLongComputationProposals();
			
			int typeLength = token == null ? 0 : token.length;
			
			next : for (int i = 0; i <= this.expectedTypesPtr; i++) {
				
				checkCancel();
				
				if(this.expectedTypes[i] instanceof ReferenceBinding) {
					ReferenceBinding refBinding = (ReferenceBinding)this.expectedTypes[i];
					
					if (typeLength > 0) {
						if (typeLength > refBinding.sourceName.length) continue next;
	
						if (!CharOperation.prefixEquals(token, refBinding.sourceName, false)
								&& !(this.options.camelCaseMatch && CharOperation.camelCaseMatch(token, refBinding.sourceName))) continue next;
					}


					if(refBinding.isTypeVariable() && this.assistNodeIsConstructor) {
						// don't propose type variable if the completion is a constructor ('new |')
						continue next;
					}
					if (this.options.checkDeprecation &&
							refBinding.isViewedAsDeprecated() &&
							!scope.isDefinedInSameUnit(refBinding))
						continue next;

					int accessibility = IAccessRule.K_ACCESSIBLE;
					if(refBinding.hasRestrictedAccess()) {
						AccessRestriction accessRestriction = this.lookupEnvironment.getAccessRestriction(refBinding);
						if(accessRestriction != null) {
							switch (accessRestriction.getProblemId()) {
								case IProblem.ForbiddenReference:
									if (this.options.checkForbiddenReference) {
										continue next;
									}
									accessibility = IAccessRule.K_NON_ACCESSIBLE;
									break;
								case IProblem.DiscouragedReference:
									if (this.options.checkDiscouragedReference) {
										continue next;
									}
									accessibility = IAccessRule.K_DISCOURAGED;
									break;
							}
						}
					}

					for (int j = 0; j < typesFound.size(); j++) {
						ReferenceBinding typeFound = (ReferenceBinding)typesFound.elementAt(j);
						if (typeFound == refBinding) {
							continue next;
						}
					}
					
					typesFound.add(refBinding);

					boolean inSameUnit = this.unitScope.isDefinedInSameUnit(refBinding);

					// top level types of the current unit are already proposed.
					if(!inSameUnit || (inSameUnit && refBinding.isMemberType())) {
						char[] packageName = refBinding.qualifiedPackageName();
						char[] typeName = refBinding.sourceName();
						char[] completionName = typeName;

						boolean isQualified = false;
						if (!this.insideQualifiedReference && !refBinding.isMemberType()) {
							if (mustQualifyType(packageName, typeName, null, refBinding.modifiers)) {
								if (packageName == null || packageName.length == 0)
									if (this.unitScope != null && this.unitScope.fPackage.compoundName != CharOperation.NO_CHAR_CHAR)
										continue next; // ignore types from the default package from outside it
								completionName = CharOperation.concat(packageName, typeName, '.');
								isQualified = true;
							}
						}

						if(this.assistNodeIsClass) {
							if(!refBinding.isClass()) continue next;
						} else if(this.assistNodeIsInterface) {
							if(!refBinding.isInterface() && !refBinding.isAnnotationType()) continue next;
						} else if (this.assistNodeIsAnnotation) {
							if(!refBinding.isAnnotationType()) continue next;
						}

						int relevance = computeBaseRelevance();
						relevance += computeRelevanceForResolution();
						relevance += computeRelevanceForInterestingProposal();
						relevance += computeRelevanceForCaseMatching(token, typeName);
						relevance += computeRelevanceForExpectingType(refBinding);
						relevance += computeRelevanceForQualification(isQualified);
						relevance += computeRelevanceForRestrictions(accessibility);

						if(refBinding.isClass()) {
							relevance += computeRelevanceForClass();
							relevance += computeRelevanceForException(typeName);
						} else if(refBinding.isEnum()) {
							relevance += computeRelevanceForEnum();
						} else if(refBinding.isInterface()) {
							relevance += computeRelevanceForInterface();
						}
						
						if (proposeType && (!this.assistNodeIsConstructor || !allowingLongComputationProposals || hasStaticMemberTypes(refBinding, scope.enclosingSourceType() ,this.unitScope))) {
							this.noProposal = false;
							if(!this.requestor.isIgnored(CompletionProposal.TYPE_REF)) {
								InternalCompletionProposal proposal =  createProposal(CompletionProposal.TYPE_REF, this.actualCompletionPosition);
								proposal.setDeclarationSignature(packageName);
								proposal.setSignature(getSignature(refBinding));
								proposal.setPackageName(packageName);
								proposal.setTypeName(typeName);
								proposal.setCompletion(completionName);
								proposal.setFlags(refBinding.modifiers);
								proposal.setReplaceRange(this.startPosition - this.offset, this.endPosition - this.offset);
								proposal.setTokenRange(this.tokenStart - this.offset, this.tokenEnd - this.offset);
								proposal.setRelevance(relevance);
								proposal.setAccessibility(accessibility);
								this.requestor.accept(proposal);
								if(DEBUG) {
									this.printDebug(proposal);
								}
							}
						}
						
						if (proposeConstructor) {
							findConstructorsOrAnonymousTypes(
									refBinding,
									scope,
									FakeInvocationSite,
									isQualified,
									relevance);
						}
					}
				}
			}
		}
	}

	private void findTypesFromImports(char[] token, Scope scope, boolean proposeType, ObjectVector typesFound) {
		ImportBinding[] importBindings = scope.compilationUnitScope().imports;
		next : for (int i = 0; i < importBindings.length; i++) {
			ImportBinding importBinding = importBindings[i];
			if(importBinding.isValidBinding()) {
				Binding binding = importBinding.resolvedImport;
				if(binding != null && binding.isValidBinding()) {
					if(importBinding.onDemand) {
						if (importBinding.isStatic()) {
							if((binding.kind() & Binding.TYPE) != 0) {
								this.findMemberTypes(
										token,
										(ReferenceBinding) binding,
										scope,
										scope.enclosingSourceType(),
										true,
										false,
										true,
										true,
										false,
										null,
										typesFound,
										null,
										null,
										null,
										false);
							}
						}
					} else {
						if ((binding.kind() & Binding.TYPE) != 0) {
							ReferenceBinding typeBinding = (ReferenceBinding) binding;
							int typeLength = token.length;

							if (!typeBinding.isStatic()) continue next;

							if (typeLength > typeBinding.sourceName.length)	continue next;

							if (!CharOperation.prefixEquals(token, typeBinding.sourceName, false)
									&& !(this.options.camelCaseMatch && CharOperation.camelCaseMatch(token, typeBinding.sourceName))) continue next;
							
							int accessibility = IAccessRule.K_ACCESSIBLE;
							if(typeBinding.hasRestrictedAccess()) {
								AccessRestriction accessRestriction = this.lookupEnvironment.getAccessRestriction(typeBinding);
								if(accessRestriction != null) {
									switch (accessRestriction.getProblemId()) {
										case IProblem.ForbiddenReference:
											if (this.options.checkForbiddenReference) {
												continue next;
											}
											accessibility = IAccessRule.K_NON_ACCESSIBLE;
											break;
										case IProblem.DiscouragedReference:
											if (this.options.checkDiscouragedReference) {
												continue next;
											}
											accessibility = IAccessRule.K_DISCOURAGED;
											break;
									}
								}
							}
							
							if (typesFound.contains(typeBinding)) continue next;
							
							typesFound.add(typeBinding);
							
							if(this.assistNodeIsClass) {
								if(!typeBinding.isClass()) continue;
							} else if(this.assistNodeIsInterface) {
								if(!typeBinding.isInterface() && !typeBinding.isAnnotationType()) continue;
							} else if (this.assistNodeIsAnnotation) {
								if(!typeBinding.isAnnotationType()) continue;
							}
							
							int relevance = computeBaseRelevance();
							relevance += computeRelevanceForResolution();
							relevance += computeRelevanceForInterestingProposal();
							relevance += computeRelevanceForCaseMatching(token, typeBinding.sourceName);
							relevance += computeRelevanceForExpectingType(typeBinding);
							relevance += computeRelevanceForQualification(false);
							relevance += computeRelevanceForRestrictions(accessibility);
			
							if (typeBinding.isAnnotationType()) {
								relevance += computeRelevanceForAnnotation();
								relevance += computeRelevanceForAnnotationTarget(typeBinding);
							} else if (typeBinding.isInterface()) {
								relevance += computeRelevanceForInterface();
							} else if(typeBinding.isClass()){
								relevance += computeRelevanceForClass();
								relevance += computeRelevanceForException(typeBinding.sourceName);
							}
							
							if (proposeType && hasStaticMemberTypes(typeBinding, scope.enclosingSourceType(), this.unitScope)) {
								this.noProposal = false;
								if(!this.requestor.isIgnored(CompletionProposal.TYPE_REF)) {
									InternalCompletionProposal proposal =  createProposal(CompletionProposal.TYPE_REF, this.actualCompletionPosition);
									proposal.setDeclarationSignature(typeBinding.qualifiedPackageName());
									proposal.setSignature(getSignature(typeBinding));
									proposal.setPackageName(typeBinding.qualifiedPackageName());
									proposal.setTypeName(typeBinding.qualifiedSourceName());
									proposal.setCompletion(typeBinding.sourceName());
									proposal.setFlags(typeBinding.modifiers);
									proposal.setReplaceRange(this.startPosition - this.offset, this.endPosition - this.offset);
									proposal.setTokenRange(this.tokenStart - this.offset, this.tokenEnd - this.offset);
									proposal.setRelevance(relevance);
									this.requestor.accept(proposal);
									if(DEBUG) {
										this.printDebug(proposal);
									}
								}
							}
							
							findConstructorsOrAnonymousTypes(
									typeBinding,
									scope,
									FakeInvocationSite,
									false,
									relevance);
						}
					}
				}
			}
		}
	}
	
	private void findTypesFromStaticImports(char[] token, Scope scope, boolean proposeAllMemberTypes, ObjectVector typesFound) {
		ImportBinding[] importBindings = scope.compilationUnitScope().imports;
		for (int i = 0; i < importBindings.length; i++) {


		return this.favoriteReferenceBindings = resolvedImports;
	}
	
	private INameEnvironment getNoCacheNameEnvironment() {
		if (this.noCacheNameEnvironment == null) {
			JavaModelManager.getJavaModelManager().cacheZipFiles();
			this.noCacheNameEnvironment = new JavaSearchNameEnvironment(this.javaProject, this.owner == null ? null : JavaModelManager.getJavaModelManager().getWorkingCopies(this.owner, true/*add primary WCs*/));
		}
		return this.noCacheNameEnvironment;
	}

	public AssistParser getParser() {


			case CompletionProposal.TYPE_IMPORT :
				buffer.append("TYPE_IMPORT"); //$NON-NLS-1$
				break;
			case CompletionProposal.CONSTRUCTOR_INVOCATION :
				buffer.append("CONSTRUCTOR_INVOCATION"); //$NON-NLS-1$
				break;
			case CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION :
				buffer.append("ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION"); //$NON-NLS-1$
				break;
			default :
				buffer.append("PROPOSAL"); //$NON-NLS-1$
				break;

			buffer.append('\t');
		}
	}
	
	private void proposeConstructor(AcceptedConstructor deferredProposal, Scope scope) {
		if (deferredProposal.proposeConstructor) {
			proposeConstructor(
					deferredProposal.simpleTypeName,
					deferredProposal.parameterCount,
					deferredProposal.signature,
					deferredProposal.parameterTypes,
					deferredProposal.parameterNames,
					deferredProposal.modifiers,
					deferredProposal.packageName,
					deferredProposal.typeModifiers,
					deferredProposal.accessibility,
					deferredProposal.simpleTypeName,
					deferredProposal.fullyQualifiedName,
					deferredProposal.mustBeQualified,
					scope,
					deferredProposal.extraFlags);
		}
	}
	
	private void proposeConstructor(
			char[] simpleTypeName,
			int parameterCount,
			char[] signature,
			char[][] parameterTypes,
			char[][] parameterNames,
			int modifiers,
			char[] packageName,
			int typeModifiers,
			int accessibility,
			char[] typeName,
			char[] fullyQualifiedName,
			boolean isQualified,
			Scope scope,
			int extraFlags) {
		char[] completionName = fullyQualifiedName;
		if(isQualified) {
			if (packageName == null || packageName.length == 0)
				if (this.unitScope != null && this.unitScope.fPackage.compoundName != CharOperation.NO_CHAR_CHAR)
					return; // ignore types from the default package from outside it
		} else {
			completionName = simpleTypeName;
		}

		int relevance = computeBaseRelevance();
		relevance += computeRelevanceForResolution();
		relevance += computeRelevanceForInterestingProposal();
		relevance += computeRelevanceForRestrictions(accessibility);
		relevance += computeRelevanceForCaseMatching(this.completionToken, simpleTypeName);
		relevance += computeRelevanceForExpectingType(packageName, simpleTypeName);
		relevance += computeRelevanceForQualification(isQualified);

		boolean isInterface = false;
		int kind = typeModifiers & (ClassFileConstants.AccInterface | ClassFileConstants.AccEnum | ClassFileConstants.AccAnnotation);
		switch (kind) {
			case ClassFileConstants.AccAnnotation:
			case ClassFileConstants.AccAnnotation | ClassFileConstants.AccInterface:
				relevance += computeRelevanceForAnnotation();
				relevance += computeRelevanceForInterface();
				isInterface = true;
				break;
			case ClassFileConstants.AccEnum:
				relevance += computeRelevanceForEnum();
				break;
			case ClassFileConstants.AccInterface:
				relevance += computeRelevanceForInterface();
				isInterface = true;
				break;
			default:
				relevance += computeRelevanceForClass();
				relevance += computeRelevanceForException(simpleTypeName);
				break;
		}
		
		char[] completion;
		if (this.source != null
					&& this.source.length > this.endPosition
					&& this.source[this.endPosition] == '(') {
			completion = completionName;
		} else {
			completion = CharOperation.concat(completionName, new char[] { '(', ')' });
		}
		
		switch (parameterCount) {
			case -1: // default constructor
				int flags = Flags.AccPublic;
				if (Flags.isDeprecated(typeModifiers)) {
					flags |= Flags.AccDeprecated;
				}
				
				if (isInterface || (typeModifiers & ClassFileConstants.AccAbstract) != 0) {
					this.noProposal = false;
					if(!this.requestor.isIgnored(CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION)) {
						InternalCompletionProposal proposal = createProposal(CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION, this.actualCompletionPosition);
						proposal.setDeclarationSignature(createNonGenericTypeSignature(packageName, typeName));
						proposal.setDeclarationKey(createBindingKey(packageName, typeName));
						proposal.setSignature(DEFAULT_CONSTRUCTOR_SIGNATURE);
						proposal.setDeclarationPackageName(packageName);
						proposal.setDeclarationTypeName(typeName);
						proposal.setParameterPackageNames(CharOperation.NO_CHAR_CHAR);
						proposal.setParameterTypeNames(CharOperation.NO_CHAR_CHAR);
						proposal.setParameterNames(CharOperation.NO_CHAR_CHAR);
						proposal.setName(simpleTypeName);
						proposal.setIsContructor(true);
						proposal.setCompletion(completion);
						proposal.setFlags(flags);
						proposal.setReplaceRange(this.startPosition - this.offset, this.endPosition - this.offset);
						proposal.setTokenRange(this.tokenStart - this.offset, this.tokenEnd - this.offset);
						proposal.setRelevance(relevance);
						this.requestor.accept(proposal);
						if(DEBUG) {
							this.printDebug(proposal);
						}
					}
				} else {
					this.noProposal = false;
					if(!this.requestor.isIgnored(CompletionProposal.CONSTRUCTOR_INVOCATION)) {
						InternalCompletionProposal proposal =  createProposal(CompletionProposal.CONSTRUCTOR_INVOCATION, this.actualCompletionPosition);
						proposal.setDeclarationSignature(createNonGenericTypeSignature(packageName, typeName));
						proposal.setSignature(DEFAULT_CONSTRUCTOR_SIGNATURE);
						proposal.setDeclarationPackageName(packageName);
						proposal.setDeclarationTypeName(typeName);
						proposal.setParameterPackageNames(CharOperation.NO_CHAR_CHAR);
						proposal.setParameterTypeNames(CharOperation.NO_CHAR_CHAR);
						proposal.setParameterNames(CharOperation.NO_CHAR_CHAR);
						proposal.setName(simpleTypeName);
						proposal.setIsContructor(true);
						proposal.setCompletion(completion);
						proposal.setFlags(flags);
						proposal.setReplaceRange(this.startPosition - this.offset, this.endPosition - this.offset);
						proposal.setTokenRange(this.tokenStart - this.offset, this.tokenEnd - this.offset);
						proposal.setRelevance(relevance);
						this.requestor.accept(proposal);
						if(DEBUG) {
							this.printDebug(proposal);
						}
					}
				}
				break;
			case 0: // constructor with no parameter
				
				if ((typeModifiers & ClassFileConstants.AccAbstract) != 0) {
					this.noProposal = false;
					if(!this.requestor.isIgnored(CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION)) {
						InternalCompletionProposal proposal = createProposal(CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION, this.actualCompletionPosition);
						proposal.setDeclarationSignature(createNonGenericTypeSignature(packageName, typeName));
						proposal.setDeclarationKey(createBindingKey(packageName, typeName));
						proposal.setSignature(DEFAULT_CONSTRUCTOR_SIGNATURE);
						proposal.setDeclarationPackageName(packageName);
						proposal.setDeclarationTypeName(typeName);
						proposal.setParameterPackageNames(CharOperation.NO_CHAR_CHAR);
						proposal.setParameterTypeNames(CharOperation.NO_CHAR_CHAR);
						proposal.setParameterNames(CharOperation.NO_CHAR_CHAR);
						proposal.setName(simpleTypeName);
						proposal.setIsContructor(true);
						proposal.setCompletion(completion);
						proposal.setFlags(modifiers);
						proposal.setReplaceRange(this.startPosition - this.offset, this.endPosition - this.offset);
						proposal.setTokenRange(this.tokenStart - this.offset, this.tokenEnd - this.offset);
						proposal.setRelevance(relevance);
						this.requestor.accept(proposal);
						if(DEBUG) {
							this.printDebug(proposal);
						}
					}
				} else {
					this.noProposal = false;
					if(!this.requestor.isIgnored(CompletionProposal.CONSTRUCTOR_INVOCATION)) {
						InternalCompletionProposal proposal =  createProposal(CompletionProposal.CONSTRUCTOR_INVOCATION, this.actualCompletionPosition);
						proposal.setDeclarationSignature(createNonGenericTypeSignature(packageName, typeName));
						proposal.setSignature(DEFAULT_CONSTRUCTOR_SIGNATURE);
						proposal.setDeclarationPackageName(packageName);
						proposal.setDeclarationTypeName(typeName);
						proposal.setParameterPackageNames(CharOperation.NO_CHAR_CHAR);
						proposal.setParameterTypeNames(CharOperation.NO_CHAR_CHAR);
						proposal.setParameterNames(CharOperation.NO_CHAR_CHAR);
						proposal.setName(simpleTypeName);
						proposal.setIsContructor(true);
						proposal.setCompletion(completion);
						proposal.setFlags(modifiers);
						proposal.setReplaceRange(this.startPosition - this.offset, this.endPosition - this.offset);
						proposal.setTokenRange(this.tokenStart - this.offset, this.tokenEnd - this.offset);
						proposal.setRelevance(relevance);
						this.requestor.accept(proposal);
						if(DEBUG) {
							this.printDebug(proposal);
						}
					}
				}
				break;
			default: // constructor with parameter
				if (signature == null) {
					// resolve type to found parameter types
					signature = getResolvedSignature(parameterTypes, fullyQualifiedName, parameterCount, scope);
					if (signature == null) return;
				} else {
					signature = CharOperation.replaceOnCopy(signature, '/', '.');
				}
				
				int parameterNamesLength = parameterNames == null ? 0 : parameterNames.length;
				if (parameterCount != parameterNamesLength) {
					parameterNames = createDefaultParameterNames(parameterCount);
				}
				
				if ((typeModifiers & ClassFileConstants.AccAbstract) != 0) {
					this.noProposal = false;
					if(!this.requestor.isIgnored(CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION)) {
						InternalCompletionProposal proposal = createProposal(CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION, this.actualCompletionPosition);
						proposal.setDeclarationSignature(createNonGenericTypeSignature(packageName, typeName));
						proposal.setDeclarationKey(createBindingKey(packageName, typeName));
						proposal.setSignature(signature);
						proposal.setDeclarationPackageName(packageName);
						proposal.setDeclarationTypeName(typeName);
						proposal.setParameterPackageNames(CharOperation.NO_CHAR_CHAR);
						proposal.setParameterTypeNames(CharOperation.NO_CHAR_CHAR);
						proposal.setParameterNames(parameterNames);
						proposal.setName(simpleTypeName);
						proposal.setIsContructor(true);
						proposal.setCompletion(completion);
						proposal.setFlags(modifiers);
						proposal.setReplaceRange(this.startPosition - this.offset, this.endPosition - this.offset);
						proposal.setTokenRange(this.tokenStart - this.offset, this.tokenEnd - this.offset);
						proposal.setRelevance(relevance);
						this.requestor.accept(proposal);
						if(DEBUG) {
							this.printDebug(proposal);
						}
					}
				} else {
					this.noProposal = false;
					if(!this.requestor.isIgnored(CompletionProposal.CONSTRUCTOR_INVOCATION)) {
						InternalCompletionProposal proposal =  createProposal(CompletionProposal.CONSTRUCTOR_INVOCATION, this.actualCompletionPosition);
						proposal.setDeclarationSignature(createNonGenericTypeSignature(packageName, typeName));
						proposal.setSignature(signature);
						proposal.setDeclarationPackageName(packageName);
						proposal.setDeclarationTypeName(typeName);
						proposal.setParameterPackageNames(CharOperation.NO_CHAR_CHAR);
						proposal.setParameterTypeNames(CharOperation.NO_CHAR_CHAR);
						proposal.setParameterNames(parameterNames);
						proposal.setName(simpleTypeName);
						proposal.setIsContructor(true);
						proposal.setCompletion(completion);
						proposal.setFlags(modifiers);
						proposal.setReplaceRange(this.startPosition - this.offset, this.endPosition - this.offset);
						proposal.setTokenRange(this.tokenStart - this.offset, this.tokenEnd - this.offset);
						proposal.setRelevance(relevance);
						
						this.requestor.accept(proposal);
						if(DEBUG) {
							this.printDebug(proposal);
						}
					}
				}
				break;
		}
	}

	private void proposeNewMethod(char[] token, ReferenceBinding reference) {
		if(!this.requestor.isIgnored(CompletionProposal.POTENTIAL_METHOD_DECLARATION)) {

		super.reset(false);
		this.knownPkgs = new HashtableOfObject(10);
		this.knownTypes = new HashtableOfObject(10);
		if (this.noCacheNameEnvironment != null) {
			this.noCacheNameEnvironment.cleanup();
			this.noCacheNameEnvironment = null;
			JavaModelManager.getJavaModelManager().flushZipFiles();
		}
	}

	private void setSourceAndTokenRange(int start, int end) {




public class InternalCompletionProposal extends CompletionProposal {
	private static Object NO_ATTACHED_SOURCE = new Object();


	static final char[] ARG0 = "arg0".toCharArray();  //$NON-NLS-1$
	static final char[] ARG1 = "arg1".toCharArray();  //$NON-NLS-1$
	static final char[] ARG2 = "arg2".toCharArray();  //$NON-NLS-1$
	static final char[] ARG3 = "arg3".toCharArray();  //$NON-NLS-1$
	static final char[][] ARGS1 = new char[][]{ARG0};
	static final char[][] ARGS2 = new char[][]{ARG0, ARG1};
	static final char[][] ARGS3 = new char[][]{ARG0, ARG1, ARG2};
	static final char[][] ARGS4 = new char[][]{ARG0, ARG1, ARG2, ARG3};

	protected CompletionEngine completionEngine;
	protected NameLookup nameLookup;

	 * Indicates whether parameter names have been computed.
	 */
	private boolean parameterNamesComputed = false;
	
	protected char[][] createDefaultParameterNames(int length) {
		char[][] parameters;
		switch (length) {
			case 0 :
				parameters = new char[length][];
				break;
			case 1 :
				parameters = ARGS1;
				break;
			case 2 :
				parameters = ARGS2;
				break;
			case 3 :
				parameters = ARGS3;
				break;
			case 4 :
				parameters = ARGS4;
				break;
			default :
				parameters = new char[length][];
				for (int i = 0; i < length; i++) {
					parameters[i] = CharOperation.concat(ARG, String.valueOf(i).toCharArray());
				}
				break;
		}
		return parameters;
	}
	protected char[][] findMethodParameterNames(char[] declaringTypePackageName, char[] declaringTypeName, char[] selector, char[][] paramTypeNames){
		if(paramTypeNames == null || declaringTypeName == null) return null;



		// default parameters name
		if(parameters == null) {
			parameters = CompletionEngine.createDefaultParameterNames(length);
		}

		return parameters;

					} catch(IllegalArgumentException e) {
						// protection for invalid signature
						if(this.parameterTypeNames != null) {
							this.parameterNames =  CompletionEngine.createDefaultParameterNames(this.parameterTypeNames.length);
						} else {
							this.parameterNames = null;
						}

					} catch(IllegalArgumentException e) {
						// protection for invalid signature
						if(this.parameterTypeNames != null) {
							this.parameterNames =  CompletionEngine.createDefaultParameterNames(this.parameterTypeNames.length);
						} else {
							this.parameterNames = null;
						}

					} catch(IllegalArgumentException e) {
						// protection for invalid signature
						if(this.parameterTypeNames != null) {
							this.parameterNames =  CompletionEngine.createDefaultParameterNames(this.parameterTypeNames.length);
						} else {
							this.parameterNames = null;
						}

			case CompletionProposal.FIELD_REF_WITH_CASTED_RECEIVER :
				buffer.append("FIELD_REF_WITH_CASTED_RECEIVER"); //$NON-NLS-1$
				break;
			case CompletionProposal.CONSTRUCTOR_INVOCATION :
				buffer.append("CONSTRUCTOR_INVOCATION"); //$NON-NLS-1$
				break;
			case CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION :
				buffer.append("ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION"); //$NON-NLS-1$
				break;
			default :
				buffer.append("PROPOSAL"); //$NON-NLS-1$
				break;




 * to the raw name environment results before answering them to the UI.
 */
public interface ISearchRequestor {
	public void acceptConstructor(
						int modifiers,
						char[] simpleTypeName,
						int parameterCount,
						char[] signature,
						char[][] parameterTypes,
						char[][] parameterNames,
						int typeModifiers,
						char[] packageName,
						int extraFlags,
						String path,
						AccessRestriction access);
	/**
	 * One result of the search consists of a new type.
	 *




		this.parser = new SelectionParser(problemReporter);
		this.owner = owner;
	}
	
	public void acceptConstructor(
			int modifiers,
			char[] simpleTypeName,
			int parameterCount,
			char[] signature,
			char[][] parameterTypes,
			char[][] parameterNames,
			int typeModifiers,
			char[] packageName,
			int extraFlags,
			String path,
			AccessRestriction access) {
		// constructors aren't searched
	}

	public void acceptType(char[] packageName, char[] simpleTypeName, char[][] enclosingTypeNames, int modifiers, AccessRestriction accessRestriction) {
		char[] typeName = enclosingTypeNames == null ?




		return typeParameterBounds;
	}

	protected void notifySourceElementRequestor(AbstractMethodDeclaration methodDeclaration, TypeDeclaration declaringType, ImportReference currentPackage) {
		if (methodDeclaration instanceof CompletionOnMethodReturnType) return;
		if (methodDeclaration instanceof CompletionOnMethodTypeParameter) return;
		if (methodDeclaration instanceof CompletionOnMethodName) return;
		super.notifySourceElementRequestor(methodDeclaration, declaringType, currentPackage);
	}

	public void notifySourceElementRequestor(CompilationUnitDeclaration parsedUnit, int sourceStart, int sourceEnd, boolean reportReference, HashtableOfObjectToInt sourceEndsMap, Map nodesToCategoriesMap) {

		super.notifySourceElementRequestor(importReference, isPackage);
	}

	protected void notifySourceElementRequestor(TypeDeclaration typeDeclaration, boolean notifyTypePresence, TypeDeclaration declaringType, ImportReference currentPackage) {
		if (typeDeclaration instanceof CompletionOnAnnotationOfType) return;
		super.notifySourceElementRequestor(typeDeclaration, notifyTypePresence, declaringType, currentPackage);
	}
}




	/**
	 * Completion is a declaration of an anonymous class.
	 * This kind of completion might occur in a context like
	 * <code>"new List(^;"</code> and complete it to
	 * <code>"new List() {}"</code>.
	 * <p>
	 * The following additional context information is available

	 * @since 3.4
	 */
	public static final int FIELD_REF_WITH_CASTED_RECEIVER = 25;
	
	/**
	 * Completion is a reference to a constructor.
	 * This kind of completion might occur in a context like
	 * <code>"new Lis"</code> and complete it to
	 * <code>"new List();"</code>.
	 * <p>
	 * The following additional context information is available
	 * for this kind of completion proposal at little extra cost:
	 * <ul>
	 * <li>{@link #getDeclarationSignature()} -
	 * the type signature of the type that declares the constructor that is referenced
	 * </li>
	 * <li>{@link #getFlags()} -
	 * the modifiers flags of the constructor that is referenced
	 * </li>
	 * <li>{@link #getName()} -
	 * the simple name of the constructor that is referenced
	 * </li>
	 * <li>{@link #getSignature()} -
	 * the method signature of the constructor that is referenced
	 * </li>
	 * </ul>
	 * </p>
	 * <p>
	 * This kind of proposal could require a long computation, so they are computed only if 
	 * {@link CompletionRequestor#isAllowingLongComputationProposals()} return <code>true</code>.
	 * </p>
	 *
	 * @see #getKind()
	 * @see CompletionRequestor#isAllowingLongComputationProposals()
	 * 
	 * @since 3.5
	 */
	public static final int CONSTRUCTOR_INVOCATION = 26;
	
	/**
	 * Completion is a reference of a constructor of an anonymous class.
	 * This kind of completion might occur in a context like
	 * <code>"new Lis^;"</code> and complete it to
	 * <code>"new List() {}"</code>.
	 * <p>
	 * The following additional context information is available
	 * for this kind of completion proposal at little extra cost:
	 * <ul>
	 * <li>{@link #getDeclarationSignature()} -
	 * the type signature of the type being implemented or subclassed
	 * </li>
	 * <li>{@link #getDeclarationKey()} -
	 * the type unique key of the type being implemented or subclassed
	 * </li>
	 * <li>{@link #getSignature()} -
	 * the method signature of the constructor that is referenced
	 * </li>
	 * <li>{@link #getKey()} -
	 * the method unique key of the constructor that is referenced
	 * if the declaring type is not an interface
	 * </li>
	 * <li>{@link #getFlags()} -
	 * the modifiers flags of the constructor that is referenced
	 * </li>
	 * </ul>
	 * </p>
	 * <p>
	 * This kind of proposal could require a long computation, so they are computed only if 
	 * {@link CompletionRequestor#isAllowingLongComputationProposals()} return <code>true</code>.
	 * </p>
	 *
	 * @see #getKind()
	 * @see CompletionRequestor#isAllowingLongComputationProposals()
	 * 
	 * @since 3.5
	 */
	public static final int ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION = 27;

	/**
	 * First valid completion kind.

	 *
	 * @since 3.1
	 */
	protected static final int LAST_KIND = ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION;

	/**
	 * Creates a basic completion proposal. All instance

Lines 70-75 Link Here

(-)model/org/eclipse/jdt/core/CompletionRequestor.java (-1 / +61 lines)
70	private int requiredProposalAllowSet[] = null;	70	private int requiredProposalAllowSet[] = null;
71		71
72	private boolean requireExtendedContext = false;	72	private boolean requireExtendedContext = false;
		73
		74	private boolean allowsLongComputationProposals = false;
73		75
74	/**	76	/**
75	* Creates a new completion requestor.	77	* Creates a new completion requestor.
Lines 140-145 Link Here
140	this.ignoreSet &= ~(1 << completionProposalKind);	142	this.ignoreSet &= ~(1 << completionProposalKind);
141	}	143	}
142	}	144	}
		145
		146	/**
		147	* Returns whether proposals which could require long computation must be proposed.
		148	* Proposals which could require long computation are among the following kinds
		149	* <ul>
		150	* <li><code>CONSTRUCTOR_INVOCATION</code></li>
		151	* <li><code>ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION</code></li>
		152	* </ul>
		153	*
		154	* @return <code>true</code> proposals which could require long computation must be proposed
		155	* , and <code>false</code> if it isn't of interest.
		156	*
		157	* <p>
		158	* By default, proposals which could require long computation aren't allowed.
		159	* </p>
		160	*
		161	* @see #setAllowsLongComputationProposals(boolean)
		162	* @see ICodeAssist#codeComplete(int, CompletionRequestor, org.eclipse.core.runtime.IProgressMonitor)
		163	*
		164	* @since 3.5
		165	*/
		166	public boolean isAllowingLongComputationProposals() {
		167	return this.allowsLongComputationProposals;
		168	}
143		169
144	/**	170	/**
145	* Returns whether a proposal of a given kind with a required proposal	171	* Returns whether a proposal of a given kind with a required proposal
Lines 174-180 Link Here
174		200
175	return 0 != (this.requiredProposalAllowSet[proposalKind] & (1 << requiredProposalKind));	201	return 0 != (this.requiredProposalAllowSet[proposalKind] & (1 << requiredProposalKind));
176	}	202	}
177		203
		204	/**
		205	* Sets whether proposals which could require long computation must be proposed.
		206	* <p>
		207	* Compute these proposals can be very long in some circumstance (eg. a workspace with lot of types).
		208	* To avoid that the code assist operation take too much time you could call code assist operation
		209	* with a progress monitor ({@link ICodeAssist#codeComplete(int, CompletionRequestor, org.eclipse.core.runtime.IProgressMonitor)}
		210	* and automatically cancel the code assist operation when a specified amount of time is reached.
		211	*
		212	* <pre>
		213	* ICodeAssist var = ...;
		214	* int offset = = ...;
		215	* CompletionRequestor requestor = ...;
		216	* var.codeComplete(offset, requestor, new IProgressMonitor() {
		217	* private long endTime;
		218	* public void beginTask(String name, int totalWork) {
		219	* fEndTime= System.currentTimeMillis() + timeout;
		220	* }
		221	* public boolean isCanceled() {
		222	* return endTime <= System.currentTimeMillis();
		223	* }
		224	* ...
		225	* });
		226	* </pre>
		227	* <p>
		228	*
		229	* @param allow <code>true</code> if proposals which could require long computation must be proposed,
		230	* and <code>false</code> if it isn't of interest
		231	* @see #isAllowingLongComputationProposals()
		232	*
		233	* @since 3.5
		234	*/
		235	public void setAllowsLongComputationProposals(boolean allow) {
		236	this.allowsLongComputationProposals = allow;
		237	}
178	/**	238	/**
179	* Sets whether a proposal of a given kind with a required proposal	239	* Sets whether a proposal of a given kind with a required proposal
180	* of the given kind is allowed.	240	* of the given kind is allowed.




import org.eclipse.jdt.internal.compiler.env.ISourceType;
import org.eclipse.jdt.internal.compiler.env.NameEnvironmentAnswer;
import org.eclipse.jdt.internal.core.search.BasicSearchEngine;
import org.eclipse.jdt.internal.core.search.IRestrictedAccessConstructorRequestor;
import org.eclipse.jdt.internal.core.search.IRestrictedAccessTypeRequestor;

/**

				convertSearchFilterToModelFilter(searchFor));
		}
	}
	
	/**
	 * Must be used only by CompletionEngine.
	 * The progress monitor is used to be able to cancel completion operations
	 * 
	 * Find constructor declarations that are defined
	 * in the current environment and whose name starts with the
	 * given prefix. The prefix is a qualified name separated by periods
	 * or a simple name (ex. java.util.V or V).
	 *
	 * The constructors found are passed to one of the following methods:
	 *    ISearchRequestor.acceptConstructor(...)
	 */
	public void findConstructorDeclarations(char[] prefix, boolean camelCaseMatch, final ISearchRequestor storage, IProgressMonitor monitor) {
		try {
			final String excludePath;
			if (this.unitToSkip != null && this.unitToSkip instanceof IJavaElement) {
				excludePath = ((IJavaElement) this.unitToSkip).getPath().toString();
			} else {
				excludePath = null;
			}
			
			int lastDotIndex = CharOperation.lastIndexOf('.', prefix);
			char[] qualification, simpleName;
			if (lastDotIndex < 0) {
				qualification = null;
				if (camelCaseMatch) {
					simpleName = prefix;
				} else {
					simpleName = CharOperation.toLowerCase(prefix);
				}
			} else {
				qualification = CharOperation.subarray(prefix, 0, lastDotIndex);
				if (camelCaseMatch) {
					simpleName = CharOperation.subarray(prefix, lastDotIndex + 1, prefix.length);
				} else {
					simpleName =
						CharOperation.toLowerCase(
							CharOperation.subarray(prefix, lastDotIndex + 1, prefix.length));
				}
			}

			IProgressMonitor progressMonitor = new IProgressMonitor() {
				boolean isCanceled = false;
				public void beginTask(String name, int totalWork) {
					// implements interface method
				}
				public void done() {
					// implements interface method
				}
				public void internalWorked(double work) {
					// implements interface method
				}
				public boolean isCanceled() {
					return this.isCanceled;
				}
				public void setCanceled(boolean value) {
					this.isCanceled = value;
				}
				public void setTaskName(String name) {
					// implements interface method
				}
				public void subTask(String name) {
					// implements interface method
				}
				public void worked(int work) {
					// implements interface method
				}
			};
			
			IRestrictedAccessConstructorRequestor constructorRequestor = new IRestrictedAccessConstructorRequestor() {
				public void acceptConstructor(
						int modifiers,
						char[] simpleTypeName,
						int parameterCount,
						char[] signature,
						char[][] parameterTypes,
						char[][] parameterNames,
						int typeModifiers,
						char[] packageName,
						int extraFlags,
						String path,
						AccessRestriction access) {
					if (excludePath != null && excludePath.equals(path))
						return;
					
					storage.acceptConstructor(
							modifiers,
							simpleTypeName,
							parameterCount,
							signature,
							parameterTypes,
							parameterNames, 
							typeModifiers,
							packageName,
							extraFlags,
							path,
							access);
				}
			};
			
			int matchRule = SearchPattern.R_PREFIX_MATCH;
			if (camelCaseMatch) matchRule |= SearchPattern.R_CAMELCASE_MATCH;
			if (monitor != null) {
				found : while (true) { //the loop will finish if the search request ends or is cancelled
					try {
						new BasicSearchEngine(this.workingCopies).searchAllConstructorDeclarations(
								qualification,
								simpleName,
								matchRule,
								getSearchScope(),
								constructorRequestor,
								CANCEL_IF_NOT_READY_TO_SEARCH,
								progressMonitor);
						break found;
					} catch (OperationCanceledException e) {
						if (monitor.isCanceled()) {
							throw e;
						} else {
							try {
								Thread.sleep(50); // indexes are not ready. sleep 50ms and retry the search request
							} catch (InterruptedException e1) {
								// Do nothing
							}
						}
					}
				}
			} else {
				try {
					new BasicSearchEngine(this.workingCopies).searchAllConstructorDeclarations(
							qualification,
							simpleName,
							matchRule,
							getSearchScope(),
							constructorRequestor,
							CANCEL_IF_NOT_READY_TO_SEARCH,
							progressMonitor);
				} catch (OperationCanceledException e) {
					// Do nothing
				}
			}
		} catch (JavaModelException e) {
			// Do nothing
		}
	}

	/**
	 * Returns all types whose name starts with the given (qualified) <code>prefix</code>.




		}
		return true;
	}
	
	boolean match(char[] patternName, char[] patternPackageName, int matchRule, char[] name, char[] packageName) {
		
		boolean isCaseSensitive = (matchRule & SearchPattern.R_CASE_SENSITIVE) != 0;
		
		if (patternPackageName != null && !CharOperation.equals(patternPackageName, packageName, true))
			return false;
		
		if (patternName != null) {
			boolean isCamelCase = (matchRule & (SearchPattern.R_CAMELCASE_MATCH | SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH)) != 0;
			int matchMode = matchRule & JavaSearchPattern.MATCH_MODE_MASK;
			if (!isCaseSensitive && !isCamelCase) {
				patternName = CharOperation.toLowerCase(patternName);
			}
			boolean matchFirstChar = !isCaseSensitive || patternName[0] == name[0];
			switch(matchMode) {
				case SearchPattern.R_EXACT_MATCH :
					return matchFirstChar && CharOperation.equals(patternName, name, isCaseSensitive);
				case SearchPattern.R_PREFIX_MATCH :
					return matchFirstChar && CharOperation.prefixEquals(patternName, name, isCaseSensitive);
				case SearchPattern.R_PATTERN_MATCH :
					return CharOperation.match(patternName, name, isCaseSensitive);
				case SearchPattern.R_REGEXP_MATCH :
					// TODO (frederic) implement regular expression match
					break;
				case SearchPattern.R_CAMELCASE_MATCH:
					if (matchFirstChar && CharOperation.camelCaseMatch(patternName, name, false)) {
						return true;
					}
					return !isCaseSensitive && matchFirstChar && CharOperation.prefixEquals(patternName, name, false);
				case SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH:
					return matchFirstChar && CharOperation.camelCaseMatch(patternName, name, true);
			}
		}
		return true;

	}

	boolean match(char patternTypeSuffix, char[] patternPkg, char[] patternTypeName, int matchRule, int typeKind, char[] pkg, char[] typeName) {
		switch(patternTypeSuffix) {

		}
		findMatches(pattern, participants, scope, requestor, monitor);
	}
	
	public void searchAllConstructorDeclarations(
		final char[] packageName,
		final char[] typeName,
		final int typeMatchRule,
		IJavaSearchScope scope,
		final IRestrictedAccessConstructorRequestor nameRequestor,
		int waitingPolicy,
		IProgressMonitor progressMonitor)  throws JavaModelException {

		// Validate match rule first
		final int validatedTypeMatchRule = SearchPattern.validateMatchRule(typeName == null ? null : new String (typeName), typeMatchRule);

		// Debug
		if (VERBOSE) {
			Util.verbose("BasicSearchEngine.searchAllTypeNames(char[], char[], int, int, IJavaSearchScope, IRestrictedAccessTypeRequestor, int, IProgressMonitor)"); //$NON-NLS-1$
			Util.verbose("	- package name: "+(packageName==null?"null":new String(packageName))); //$NON-NLS-1$ //$NON-NLS-2$
			Util.verbose("	- type name: "+(typeName==null?"null":new String(typeName))); //$NON-NLS-1$ //$NON-NLS-2$
			Util.verbose("	- type match rule: "+getMatchRuleString(typeMatchRule)); //$NON-NLS-1$
			if (validatedTypeMatchRule != typeMatchRule) {
				Util.verbose("	- validated type match rule: "+getMatchRuleString(validatedTypeMatchRule)); //$NON-NLS-1$
			}
			Util.verbose("	- scope: "+scope); //$NON-NLS-1$
		}
		if (validatedTypeMatchRule == -1) return; // invalid match rule => return no results

		// Create pattern
		IndexManager indexManager = JavaModelManager.getIndexManager();
		final ConstructorDeclarationPattern pattern = new ConstructorDeclarationPattern(
				packageName,
				typeName,
				validatedTypeMatchRule);

		// Get working copy path(s). Store in a single string in case of only one to optimize comparison in requestor
		final HashSet workingCopyPaths = new HashSet();
		String workingCopyPath = null;
		ICompilationUnit[] copies = getWorkingCopies();
		final int copiesLength = copies == null ? 0 : copies.length;
		if (copies != null) {
			if (copiesLength == 1) {
				workingCopyPath = copies[0].getPath().toString();
			} else {
				for (int i = 0; i < copiesLength; i++) {
					ICompilationUnit workingCopy = copies[i];
					workingCopyPaths.add(workingCopy.getPath().toString());
				}
			}
		}
		final String singleWkcpPath = workingCopyPath;

		// Index requestor
		IndexQueryRequestor searchRequestor = new IndexQueryRequestor(){
			public boolean acceptIndexMatch(String documentPath, SearchPattern indexRecord, SearchParticipant participant, AccessRuleSet access) {
				// Filter unexpected types
				ConstructorDeclarationPattern record = (ConstructorDeclarationPattern)indexRecord;
				
				if ((record.extraFlags & ExtraFlags.IsMemberType) != 0) {
					return true; // filter out member classes
				}
				if ((record.extraFlags & ExtraFlags.IsLocalType) != 0) {
					return true; // filter out local and anonymous classes
				}
				switch (copiesLength) {
					case 0:
						break;
					case 1:
						if (singleWkcpPath.equals(documentPath)) {
							return true; // filter out *the* working copy
						}
						break;
					default:
						if (workingCopyPaths.contains(documentPath)) {
							return true; // filter out working copies
						}
						break;
				}

				// Accept document path
				AccessRestriction accessRestriction = null;
				if (access != null) {
					// Compute document relative path
					int pkgLength = (record.declaringPackageName==null || record.declaringPackageName.length==0) ? 0 : record.declaringPackageName.length+1;
					int nameLength = record.declaringSimpleName==null ? 0 : record.declaringSimpleName.length;
					char[] path = new char[pkgLength+nameLength];
					int pos = 0;
					if (pkgLength > 0) {
						System.arraycopy(record.declaringPackageName, 0, path, pos, pkgLength-1);
						CharOperation.replace(path, '.', '/');
						path[pkgLength-1] = '/';
						pos += pkgLength;
					}
					if (nameLength > 0) {
						System.arraycopy(record.declaringSimpleName, 0, path, pos, nameLength);
						pos += nameLength;
					}
					// Update access restriction if path is not empty
					if (pos > 0) {
						accessRestriction = access.getViolatedRestriction(path);
					}
				}
				nameRequestor.acceptConstructor(
						record.modifiers,
						record.declaringSimpleName,
						record.parameterCount,
						record.signature,
						record.parameterTypes,
						record.parameterNames,
						record.declaringTypeModifiers,
						record.declaringPackageName,
						record.extraFlags,
						documentPath,
						accessRestriction);
				return true;
			}
		};

		try {
			if (progressMonitor != null) {
				progressMonitor.beginTask(Messages.engine_searching, 1000);
			}
			// add type names from indexes
			indexManager.performConcurrentJob(
				new PatternSearchJob(
					pattern,
					getDefaultSearchParticipant(), // Java search only
					scope,
					searchRequestor),
				waitingPolicy,
				progressMonitor == null ? null : new SubProgressMonitor(progressMonitor, 1000-copiesLength));

			// add type names from working copies
			if (copies != null) {
				for (int i = 0; i < copiesLength; i++) {
					final ICompilationUnit workingCopy = copies[i];
					if (!scope.encloses(workingCopy)) continue;
					final String path = workingCopy.getPath().toString();
					if (workingCopy.isConsistent()) {
						IPackageDeclaration[] packageDeclarations = workingCopy.getPackageDeclarations();
						char[] packageDeclaration = packageDeclarations.length == 0 ? CharOperation.NO_CHAR : packageDeclarations[0].getElementName().toCharArray();
						IType[] allTypes = workingCopy.getAllTypes();
						for (int j = 0, allTypesLength = allTypes.length; j < allTypesLength; j++) {
							IType type = allTypes[j];
							char[] simpleName = type.getElementName().toCharArray();
							if (match(typeName, packageName, validatedTypeMatchRule, simpleName, packageDeclaration) && !type.isMember()) {
								
								int extraFlags = ExtraFlags.getExtraFlags(type);
								
								boolean hasConstructor = false;
								
								IMethod[] methods = type.getMethods();
								for (int k = 0; k < methods.length; k++) {
									IMethod method = methods[k];
									if (method.isConstructor()) {
										hasConstructor = true;
										
										String[] stringParameterNames = method.getParameterNames();
										String[] stringParameterTypes = method.getParameterTypes();
										int length = stringParameterNames.length;
										char[][] parameterNames = new char[length][];
										char[][] parameterTypes = new char[length][];
										for (int l = 0; l < length; l++) {
											parameterNames[l] = stringParameterNames[l].toCharArray();
											parameterTypes[l] = Signature.toCharArray(Signature.getTypeErasure(stringParameterTypes[l]).toCharArray());
										}
										
										nameRequestor.acceptConstructor(
												method.getFlags(),
												simpleName,
												parameterNames.length,
												null,// signature is not used for source type
												parameterTypes, 
												parameterNames,
												type.getFlags(),
												packageDeclaration,
												extraFlags,
												path,
												null);
									}
								}
								
								if (!hasConstructor) {
									nameRequestor.acceptConstructor(
											Flags.AccPublic,
											simpleName,
											-1,
											null, // signature is not used for source type
											CharOperation.NO_CHAR_CHAR,
											CharOperation.NO_CHAR_CHAR,
											type.getFlags(),
											packageDeclaration,
											extraFlags,
											path,
											null);
								}
							}
						}
					} else {
						Parser basicParser = getParser();
						org.eclipse.jdt.internal.compiler.env.ICompilationUnit unit = (org.eclipse.jdt.internal.compiler.env.ICompilationUnit) workingCopy;
						CompilationResult compilationUnitResult = new CompilationResult(unit, 0, 0, this.compilerOptions.maxProblemsPerUnit);
						CompilationUnitDeclaration parsedUnit = basicParser.dietParse(unit, compilationUnitResult);
						if (parsedUnit != null) {
							final char[] packageDeclaration = parsedUnit.currentPackage == null ? CharOperation.NO_CHAR : CharOperation.concatWith(parsedUnit.currentPackage.getImportName(), '.');
							class AllConstructorDeclarationsVisitor extends ASTVisitor {
								private TypeDeclaration[] declaringTypes = new TypeDeclaration[0];
								private int declaringTypesPtr = -1;
								
								private void endVisit(TypeDeclaration typeDeclaration) {
									if (!hasConstructor(typeDeclaration) && typeDeclaration.enclosingType == null) {
									
										if (match(typeName, packageName, validatedTypeMatchRule, typeDeclaration.name, packageDeclaration)) {
											nameRequestor.acceptConstructor(
													Flags.AccPublic,
													typeName,
													-1,
													null, // signature is not used for source type
													CharOperation.NO_CHAR_CHAR,
													CharOperation.NO_CHAR_CHAR,
													typeDeclaration.modifiers,
													packageDeclaration,
													ExtraFlags.getExtraFlags(typeDeclaration),
													path,
													null);
										}
									}
									
									this.declaringTypes[this.declaringTypesPtr] = null;
									this.declaringTypesPtr--;
								}
								
								public void endVisit(TypeDeclaration typeDeclaration, CompilationUnitScope s) {
									endVisit(typeDeclaration);
								}
								
								public void endVisit(TypeDeclaration memberTypeDeclaration, ClassScope s) {
									endVisit(memberTypeDeclaration);
								}
								
								private boolean hasConstructor(TypeDeclaration typeDeclaration) {
									AbstractMethodDeclaration[] methods = typeDeclaration.methods;
									int length = methods == null ? 0 : methods.length;
									for (int j = 0; j < length; j++) {
										if (methods[j].isConstructor()) {
											return true;
										}
									}
									
									return false;
								}
								public boolean visit(ConstructorDeclaration constructorDeclaration, ClassScope classScope) {
									TypeDeclaration typeDeclaration = this.declaringTypes[this.declaringTypesPtr];
									if (match(typeName, packageName, validatedTypeMatchRule, typeDeclaration.name, packageDeclaration)) {
										Argument[] arguments = constructorDeclaration.arguments;
										int length = arguments == null ? 0 : arguments.length;
										char[][] parameterNames = new char[length][];
										char[][] parameterTypes = new char[length][];
										for (int l = 0; l < length; l++) {
											Argument argument = arguments[l];
											parameterNames[l] = argument.name;
											if (argument.type instanceof SingleTypeReference) {
												parameterTypes[l] = ((SingleTypeReference)argument.type).token;
											} else {
												parameterTypes[l] = CharOperation.concatWith(((QualifiedTypeReference)argument.type).tokens, '.');
											}
										}
										
										TypeDeclaration enclosing = typeDeclaration.enclosingType;
										char[][] enclosingTypeNames = CharOperation.NO_CHAR_CHAR;
										while (enclosing != null) {
											enclosingTypeNames = CharOperation.arrayConcat(new char[][] {enclosing.name}, enclosingTypeNames);
											if ((enclosing.bits & ASTNode.IsMemberType) != 0) {
												enclosing = enclosing.enclosingType;
											} else {
												enclosing = null;
											}
										}
										
										nameRequestor.acceptConstructor(
												constructorDeclaration.modifiers,
												typeName,
												parameterNames.length,
												null, // signature is not used for source type
												parameterTypes,
												parameterNames,
												typeDeclaration.modifiers,
												packageDeclaration,
												ExtraFlags.getExtraFlags(typeDeclaration),
												path,
												null);
									}
									return false; // no need to find constructors from local/anonymous type
								}
								public boolean visit(TypeDeclaration typeDeclaration, BlockScope blockScope) {
									return false; 
								}
								
								private boolean visit(TypeDeclaration typeDeclaration) {
									if(this.declaringTypes.length <= ++this.declaringTypesPtr) {
										int length = this.declaringTypesPtr;
										System.arraycopy(this.declaringTypes, 0, this.declaringTypes = new TypeDeclaration[length * 2 + 1], 0, length);
									}
									this.declaringTypes[this.declaringTypesPtr] = typeDeclaration;
									return true;
								}
								
								public boolean visit(TypeDeclaration typeDeclaration, CompilationUnitScope s) {
									return visit(typeDeclaration);
								}
								
								public boolean visit(TypeDeclaration memberTypeDeclaration, ClassScope s) {
									return visit(memberTypeDeclaration);
								}
							}
							parsedUnit.traverse(new AllConstructorDeclarationsVisitor(), parsedUnit.scope);
						}
					}
					if (progressMonitor != null) {
						if (progressMonitor.isCanceled()) throw new OperationCanceledException();
						progressMonitor.worked(1);
					}
				}
			}
		} finally {
			if (progressMonitor != null) {
				progressMonitor.done();
			}
		}
	}

	/**
	 * Searches for all secondary types in the given scope.

Lines 19-24 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/ConstructorPattern.java (-19 / +260 lines)
19	import org.eclipse.jdt.core.compiler.CharOperation;	19	import org.eclipse.jdt.core.compiler.CharOperation;
20	import org.eclipse.jdt.core.search.IJavaSearchConstants;	20	import org.eclipse.jdt.core.search.IJavaSearchConstants;
21	import org.eclipse.jdt.core.search.SearchPattern;	21	import org.eclipse.jdt.core.search.SearchPattern;
		22	import org.eclipse.jdt.internal.compiler.ExtraFlags;
		23	import org.eclipse.jdt.internal.compiler.ast.ASTNode;
22	import org.eclipse.jdt.internal.core.index.EntryResult;	24	import org.eclipse.jdt.internal.core.index.EntryResult;
23	import org.eclipse.jdt.internal.core.index.Index;	25	import org.eclipse.jdt.internal.core.index.Index;
24	import org.eclipse.jdt.internal.core.util.Util;	26	import org.eclipse.jdt.internal.core.util.Util;
Lines 52-57 Link Here
52	IJavaSearchConstants.THIS_REFERENCE \|	54	IJavaSearchConstants.THIS_REFERENCE \|
53	IJavaSearchConstants.IMPLICIT_THIS_REFERENCE;	55	IJavaSearchConstants.IMPLICIT_THIS_REFERENCE;
54		56
		57
		58	/**
		59	* Constructor entries are encoded as described
		60	*
		61	* Binary constructor for class
		62	* TypeName '/' Arity '/' TypeModifers '/' PackageName '/' Signature '/' ParameterNamesopt '/' Modifiers
		63	* Source constructor for class
		64	* TypeName '/' Arity '/' TypeModifers '/' PackageName '/' ParameterTypes '/' ParameterNamesopt
		65	* Constructor with 0 arity for class
		66	* TypeName '/' 0 '/' TypeModifers '/' PackageName '/' Modifiers
		67	* Constructor for enum, interface (annotation) and class with default constructor
		68	* TypeName '/' # '/' TypeModifers '/' PackageName
		69	* Constructor for member type
		70	* TypeName '/' Arity '/' TypeModifers
		71	*
		72	* TypeModifiers contains some encoded extra information
		73	* {@link ExtraFlags#IsMemberType}
		74	* {@link ExtraFlags#HasNonPrivateStaticMemberTypes}
		75	* {@link ExtraFlags#ParameterTypesStoredAsSignature}
		76	*/
		77	public static char[] createDeclarationIndexKey(
		78	char[] typeName,
		79	int argCount,
		80	char[] signature,
		81	char[][] parameterTypes,
		82	char[][] parameterNames,
		83	int modifiers,
		84	char[] packageName,
		85	int typeModifiers,
		86	int extraFlags) {
		87
		88	char[] countChars;
		89	char[] parameterTypesChars = null;
		90	char[] parameterNamesChars = null;
		91
		92	if (argCount < 0) {
		93	countChars = DEFAULT_CONSTRUCTOR;
		94	} else {
		95	countChars = argCount < 10
		96	? COUNTS[argCount]
		97	: ("/" + String.valueOf(argCount)).toCharArray(); //$NON-NLS-1$
		98
		99	if (argCount > 0) {
		100	if (signature == null) {
		101	if (parameterTypes != null && parameterTypes.length == argCount) {
		102	char[][] parameterTypeErasures = new char[argCount][];
		103	for (int i = 0; i < parameterTypes.length; i++) {
		104	parameterTypeErasures[i] = getTypeErasure(parameterTypes[i]);
		105	}
		106	parameterTypesChars = CharOperation.concatWith(parameterTypeErasures, PARAMETER_SEPARATOR);
		107	}
		108	} else {
		109	extraFlags \|= ExtraFlags.ParameterTypesStoredAsSignature;
		110	}
		111
		112	if (parameterNames != null && parameterNames.length == argCount) {
		113	parameterNamesChars = CharOperation.concatWith(parameterNames, PARAMETER_SEPARATOR);
		114	}
		115	}
		116	}
		117
		118	boolean isMemberType = (extraFlags & ExtraFlags.IsMemberType) != 0;
		119	boolean hasStoredParameterTypesAsSignature = (extraFlags & ExtraFlags.ParameterTypesStoredAsSignature) != 0;
		120
121	int typeNameLength = typeName == null ? 0 : typeName.length;
122	int packageNameLength = packageName == null ? 0 : packageName.length;
123	int countCharsLength = countChars.length;
124	int parameterTypesLength = signature == null ? (parameterTypesChars == null ? 0 : parameterTypesChars.length): signature.length;
125	int parameterNamesLength = parameterNamesChars == null ? 0 : parameterNamesChars.length;
126
127	int resultLength = typeNameLength + countCharsLength + 3; // SEPARATOR=1 + TypeModifers=2
128	if (!isMemberType) {
129	resultLength += packageNameLength + 1; // SEPARATOR=1
130	if (argCount == 0 \|\| hasStoredParameterTypesAsSignature) {
131	resultLength += 3; // SEPARATOR=1 + Modifiers=2
132	}
133
134	if (argCount > 0) {
135	resultLength += parameterTypesLength + parameterNamesLength + 2; //SEPARATOR=1 + SEPARATOR=1
136	}
137	}
138
139	char[] result = new char[resultLength];
140
141	int pos = 0;
142	if (typeNameLength > 0) {
143	System.arraycopy(typeName, 0, result, pos, typeNameLength);
144	pos += typeNameLength;
145	}
146
147	if (countCharsLength > 0) {
148	System.arraycopy(countChars, 0, result, pos, countCharsLength);
149	pos += countCharsLength;
150	}
151
152	int typeModifiersWithExtraFlags = typeModifiers \| encodeExtraFlags(extraFlags);
153	result[pos++] = SEPARATOR;
154	result[pos++] = (char) typeModifiersWithExtraFlags;
155	result[pos++] = (char) (typeModifiersWithExtraFlags>>16);
156
157	if (!isMemberType) {
158	result[pos++] = SEPARATOR;
159	if (packageNameLength > 0) {
160	System.arraycopy(packageName, 0, result, pos, packageNameLength);
161	pos += packageNameLength;
162	}
163
164	if (argCount == 0) {
165	result[pos++] = SEPARATOR;
166	result[pos++] = (char) modifiers;
167	result[pos++] = (char) (modifiers>>16);
168	} else if (argCount > 0) {
169	result[pos++] = SEPARATOR;
170	if (parameterTypesLength > 0) {
171	if (signature == null) {
172	System.arraycopy(parameterTypesChars, 0, result, pos, parameterTypesLength);
173	} else {
174	System.arraycopy(CharOperation.replaceOnCopy(signature, SEPARATOR, '\\'), 0, result, pos, parameterTypesLength);
175	}
176	pos += parameterTypesLength;
177	}
178
179	result[pos++] = SEPARATOR;
180	if (parameterNamesLength > 0) {
181	System.arraycopy(parameterNamesChars, 0, result, pos, parameterNamesLength);
182	pos += parameterNamesLength;
183	}
184
185	if (hasStoredParameterTypesAsSignature) {
186	result[pos++] = SEPARATOR;
187	result[pos++] = (char) modifiers;
188	result[pos++] = (char) (modifiers>>16);
189	}
190	}
191
192	}
193
194	return result;
195	}
196	public static char[] createDefaultDeclarationIndexKey(
197	char[] typeName,
198	char[] packageName,
199	int typeModifiers,
200	int extraFlags) {
201	return createDeclarationIndexKey(
202	typeName,
203	-1, // used to identify default constructor
204	null,
205	null,
206	null,
207	0, //
208	packageName,
209	typeModifiers,
210	extraFlags);
211	}
212
55	/**	213	/**
56	* Constructor entries are encoded as TypeName '/' Arity:	214	* Constructor entries are encoded as TypeName '/' Arity:
57	* e.g. 'X/0'	215	* e.g. 'X/0'
Lines 62-68 Link Here
62	: ("/" + String.valueOf(argCount)).toCharArray(); //$NON-NLS-1$	220	: ("/" + String.valueOf(argCount)).toCharArray(); //$NON-NLS-1$
63	return CharOperation.concat(typeName, countChars);	221	return CharOperation.concat(typeName, countChars);
64	}	222	}
65		223	static int decodeExtraFlags(int modifiersWithExtraFlags) {
		224	int extraFlags = 0;
		225
		226	if ((modifiersWithExtraFlags & ASTNode.Bit28) != 0) {
		227	extraFlags \|= ExtraFlags.ParameterTypesStoredAsSignature;
		228	}
		229
		230	if ((modifiersWithExtraFlags & ASTNode.Bit29) != 0) {
		231	extraFlags \|= ExtraFlags.IsLocalType;
		232	}
		233
		234	if ((modifiersWithExtraFlags & ASTNode.Bit30) != 0) {
		235	extraFlags \|= ExtraFlags.IsMemberType;
		236	}
		237
		238	if ((modifiersWithExtraFlags & ASTNode.Bit31) != 0) {
		239	extraFlags \|= ExtraFlags.HasNonPrivateStaticMemberTypes;
		240	}
		241
		242	return extraFlags;
		243	}
		244	static int decodeModifers(int modifiersWithExtraFlags) {
		245	return modifiersWithExtraFlags & ~(ASTNode.Bit31 \| ASTNode.Bit30 \| ASTNode.Bit29 \| ASTNode.Bit28);
		246	}
		247	private static int encodeExtraFlags(int extraFlags) {
		248	int encodedExtraFlags = 0;
		249
		250	if ((extraFlags & ExtraFlags.ParameterTypesStoredAsSignature) != 0) {
		251	encodedExtraFlags \|= ASTNode.Bit28;
		252	}
		253
		254	if ((extraFlags & ExtraFlags.IsLocalType) != 0) {
		255	encodedExtraFlags \|= ASTNode.Bit29;
		256	}
		257
		258	if ((extraFlags & ExtraFlags.IsMemberType) != 0) {
		259	encodedExtraFlags \|= ASTNode.Bit30;
		260	}
		261	if ((extraFlags & ExtraFlags.HasNonPrivateStaticMemberTypes) != 0) {
		262	encodedExtraFlags \|= ASTNode.Bit31;
		263	}
		264
		265	return encodedExtraFlags;
		266	}
		267	private static char[] getTypeErasure(char[] typeName) {
		268	int index;
		269	if ((index = CharOperation.indexOf('<', typeName)) == -1) return typeName;
		270
		271	int length = typeName.length;
		272	char[] typeErasurename = new char[length - 2];
		273
		274	System.arraycopy(typeName, 0, typeErasurename, 0, index);
		275
		276	int depth = 1;
		277	for (int i = index + 1; i < length; i++) {
		278	switch (typeName[i]) {
		279	case '<':
		280	depth++;
		281	break;
		282	case '>':
		283	depth--;
		284	break;
		285	default:
		286	if (depth == 0) {
		287	typeErasurename[index++] = typeName[i];
288	}
289	break;
290	}
291	}
292
293	System.arraycopy(typeErasurename, 0, typeErasurename = new char[index], 0, index);
294	return typeErasurename;
295	}
66	ConstructorPattern(int matchRule) {	296	ConstructorPattern(int matchRule) {
67	super(CONSTRUCTOR_PATTERN, matchRule);	297	super(CONSTRUCTOR_PATTERN, matchRule);
68	}	298	}
Lines 225-245 Link Here
225	}	455	}
226	if (hasConstructorArguments()) this.mustResolve = true;	456	if (hasConstructorArguments()) this.mustResolve = true;
227	}	457	}
		458
228	public void decodeIndexKey(char[] key) {	459	public void decodeIndexKey(char[] key) {
229	int last = key.length - 1;	460	int last = key.length - 1;
230	this.parameterCount = 0;	461	int slash = CharOperation.indexOf(SEPARATOR, key, 0);
231	this.declaringSimpleName = null;	462	this.declaringSimpleName = CharOperation.subarray(key, 0, slash);
232	int power = 1;	463
233	for (int i=last; i>=0; i--) {	464	int start = slash + 1;
234	if (key[i] == SEPARATOR) {	465	slash = CharOperation.indexOf(SEPARATOR, key, start);
235	System.arraycopy(key, 0, this.declaringSimpleName = new char[i], 0, i);	466	if (slash != -1) {
236	break;	467	last = slash - 1;
237	}	468	}
238	if (i == last) {	469
239	this.parameterCount = key[i] - '0';	470	boolean isDefaultConstructor = key[last] == '#';
240	} else {	471	if (isDefaultConstructor) {
241	power *= 10;	472	this.parameterCount = -1;
242	this.parameterCount += power * (key[i] - '0');	473	} else {
		474	this.parameterCount = 0;
		475	int power = 1;
		476	for (int i = last; i >= start; i--) {
		477	if (i == last) {
		478	this.parameterCount = key[i] - '0';
		479	} else {
		480	power *= 10;
		481	this.parameterCount += power * (key[i] - '0');
		482	}
243	}	483	}
244	}	484	}
245	}	485	}
Lines 262-268 Link Here
262	public boolean matchesDecodedKey(SearchPattern decodedPattern) {	502	public boolean matchesDecodedKey(SearchPattern decodedPattern) {
263	ConstructorPattern pattern = (ConstructorPattern) decodedPattern;	503	ConstructorPattern pattern = (ConstructorPattern) decodedPattern;
264		504
265	return (this.parameterCount == pattern.parameterCount \|\| this.parameterCount == -1 \|\| this.varargs)	505	return pattern.parameterCount != -1
		506	&& (this.parameterCount == pattern.parameterCount \|\| this.parameterCount == -1 \|\| this.varargs)
266	&& matchesName(this.declaringSimpleName, pattern.declaringSimpleName);	507	&& matchesName(this.declaringSimpleName, pattern.declaringSimpleName);
267	}	508	}
268	protected boolean mustResolve() {	509	protected boolean mustResolve() {
Lines 280-291 Link Here
280		521
281	switch(getMatchMode()) {	522	switch(getMatchMode()) {
282	case R_EXACT_MATCH :	523	case R_EXACT_MATCH :
283	if (this.declaringSimpleName != null && this.parameterCount >= 0 && !this.varargs)	524	if (this.declaringSimpleName != null && this.parameterCount >= 0 && !this.varargs) {
284	key = createIndexKey(this.declaringSimpleName, this.parameterCount);	525	key = createIndexKey(this.declaringSimpleName, this.parameterCount);
285	else { // do a prefix query with the declaringSimpleName
286	matchRule &= ~R_EXACT_MATCH;
287	matchRule \|= R_PREFIX_MATCH;
288	}	526	}
		527	matchRule &= ~R_EXACT_MATCH;
		528	matchRule \|= R_PREFIX_MATCH;
289	break;	529	break;
290	case R_PREFIX_MATCH :	530	case R_PREFIX_MATCH :
291	// do a prefix query with the declaringSimpleName	531	// do a prefix query with the declaringSimpleName
Lines 295-300 Link Here
295	key = createIndexKey(this.declaringSimpleName == null ? ONE_STAR : this.declaringSimpleName, this.parameterCount);	535	key = createIndexKey(this.declaringSimpleName == null ? ONE_STAR : this.declaringSimpleName, this.parameterCount);
296	else if (this.declaringSimpleName != null && this.declaringSimpleName[this.declaringSimpleName.length - 1] != '*')	536	else if (this.declaringSimpleName != null && this.declaringSimpleName[this.declaringSimpleName.length - 1] != '*')
297	key = CharOperation.concat(this.declaringSimpleName, ONE_STAR, SEPARATOR);	537	key = CharOperation.concat(this.declaringSimpleName, ONE_STAR, SEPARATOR);
		538	key = CharOperation.concat(key, ONE_STAR);
298	// else do a pattern query with just the declaringSimpleName	539	// else do a pattern query with just the declaringSimpleName
299	break;	540	break;
300	case R_REGEXP_MATCH :	541	case R_REGEXP_MATCH :




/*******************************************************************************
 * Copyright (c) 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.compiler.CharOperation;
import org.eclipse.jdt.core.search.SearchPattern;
import org.eclipse.jdt.internal.compiler.ExtraFlags;
import org.eclipse.jdt.internal.core.index.EntryResult;
import org.eclipse.jdt.internal.core.index.Index;

public class ConstructorDeclarationPattern extends ConstructorPattern {
	private static final char[][] EXT_DECL_CATEGORIES = {CONSTRUCTOR_DECL};
	
	public int extraFlags;
	
	public int declaringTypeModifiers;
	public char[] declaringPackageName;
	
	public int modifiers;
	public char[] signature;
	public char[][] parameterTypes;
	public char[][] parameterNames;

public ConstructorDeclarationPattern(char[] declaringPackageName, char[] declaringSimpleName, int matchRule) {
	this(matchRule);
	this.declaringSimpleName = (this.isCaseSensitive || this.isCamelCase) ? declaringSimpleName : CharOperation.toLowerCase(declaringSimpleName);
	this.declaringPackageName = declaringPackageName;
	this.findDeclarations = true;
	this.findReferences = false;
	this.parameterCount = -1;
	this.mustResolve = false;
}

ConstructorDeclarationPattern(int matchRule) {
	super(matchRule);
}
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);
	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');
			}
		}
	}
	
	slash = slash + 3;
	last = slash - 1;
	
	int typeModifiersWithExtraFlags = key[last-1] + (key[last]<<16);
	this.declaringTypeModifiers = decodeModifers(typeModifiersWithExtraFlags);
	this.extraFlags = decodeExtraFlags(typeModifiersWithExtraFlags);
	
	boolean isMemberType = (this.extraFlags & ExtraFlags.IsMemberType) != 0;
	
	if (!isMemberType) {
		start = slash + 1;
		if (this.parameterCount == -1) {
			slash = key.length;
			last = slash - 1;
		} else {
			slash = CharOperation.indexOf(SEPARATOR, key, start);
		}
		last = slash - 1;
		
		this.declaringPackageName = CharOperation.subarray(key, start, slash);
		
		start = slash + 1;
		if (this.parameterCount == 0) {
			slash = slash + 3;
			last = slash - 1;
			
			this.modifiers = key[last-1] + (key[last]<<16);
		} else if (this.parameterCount > 0){
			slash = CharOperation.indexOf(SEPARATOR, key, start);
			last = slash - 1;
			
			boolean hasParameterStoredAsSignature = (this.extraFlags & ExtraFlags.ParameterTypesStoredAsSignature) != 0;
			if (hasParameterStoredAsSignature) {
				this.signature  = CharOperation.subarray(key, start, slash);
				CharOperation.replace(this.signature , '\\', SEPARATOR);
				
				start = slash + 1;
				slash = CharOperation.indexOf(SEPARATOR, key, start);
			} else {
				this.parameterTypes = CharOperation.splitOn(PARAMETER_SEPARATOR, key, start, slash);
				
				start = slash + 1;
				slash = key.length;
			}
			last = slash - 1;
			
			if (slash != start) {
				this.parameterNames = CharOperation.splitOn(PARAMETER_SEPARATOR, key, start, slash);
			}
			
			if (hasParameterStoredAsSignature) {
				slash = slash + 3;
				last = slash - 1;
				
				this.modifiers = key[last-1] + (key[last]<<16);
			}
		}
	}
	
	removeInternalFlags(); // remove internal flags
}

public SearchPattern getBlankPattern() {
	return new ConstructorDeclarationPattern(R_EXACT_MATCH | R_CASE_SENSITIVE);
}
public char[][] getIndexCategories() {
	return EXT_DECL_CATEGORIES;
}
public boolean matchesDecodedKey(SearchPattern decodedPattern) {
	ConstructorDeclarationPattern pattern = (ConstructorDeclarationPattern) decodedPattern;
	
	// only top level types
	if ((pattern.extraFlags & ExtraFlags.IsMemberType) != 0) return false;
	
	// check package - exact match only
	if (this.declaringPackageName != null && !CharOperation.equals(this.declaringPackageName, pattern.declaringPackageName, true))
		return false;

	return (this.parameterCount == pattern.parameterCount || this.parameterCount == -1 || this.varargs)
		&& matchesName(this.declaringSimpleName, pattern.declaringSimpleName);
}
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 = createIndexKey(this.declaringSimpleName == null ? ONE_STAR : this.declaringSimpleName, this.parameterCount);
			else if (this.declaringSimpleName != null && this.declaringSimpleName[this.declaringSimpleName.length - 1] != '*')
				key = CharOperation.concat(this.declaringSimpleName, ONE_STAR, SEPARATOR);
			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
}
private void removeInternalFlags() {
	this.extraFlags = this.extraFlags & ~ExtraFlags.ParameterTypesStoredAsSignature; // ParameterTypesStoredAsSignature is an internal flags only used to decode key
}
}




/*******************************************************************************
 * Copyright (c) 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;

import org.eclipse.jdt.internal.compiler.env.AccessRestriction;

/**
 * A <code>IRestrictedAccessConstructorRequestor</code> collects search results from a <code>searchAllConstructorDeclarations</code>
 * query to a <code>SearchBasicEngine</code> providing restricted access information of declaring type when a constructor is accepted.
 */
public interface IRestrictedAccessConstructorRequestor {

	public void acceptConstructor(
			int modifiers,
			char[] simpleTypeName,
			int parameterCount,
			char[] signature,
			char[][] parameterTypes,
			char[][] parameterNames,
			int typeModifiers,
			char[] packageName,
			int extraFlags,
			String path,
			AccessRestriction access);

}




/*******************************************************************************
 * Copyright (c) 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.compiler;

import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader;
import org.eclipse.jdt.internal.compiler.env.IBinaryNestedType;

public final class ExtraFlags {
	public final static int HasNonPrivateStaticMemberTypes = 0x0001;
	public final static int IsMemberType = 0x0002;
	public final static int IsLocalType = 0x0004;
	
	//internal flags
	public final static int ParameterTypesStoredAsSignature = 0x0010;
	
	public static int getExtraFlags(ClassFileReader reader) {
		int extraFlags = 0;
		
		if (reader.isNestedType()) {
			extraFlags |= ExtraFlags.IsMemberType;
		}
		
		if (reader.isLocal()) {
			extraFlags |= ExtraFlags.IsLocalType;
		}
		
		IBinaryNestedType[] memberTypes = reader.getMemberTypes();
		int memberTypeCounter = memberTypes == null ? 0 : memberTypes.length;
		if (memberTypeCounter > 0) {
			done : for (int i = 0; i < memberTypeCounter; i++) {
				int modifiers = memberTypes[i].getModifiers();
				// if the member type is static and not private
				if ((modifiers & ClassFileConstants.AccStatic) != 0 && (modifiers & ClassFileConstants.AccPrivate) == 0) {
					extraFlags |= ExtraFlags.HasNonPrivateStaticMemberTypes;
					break done;
				}
			}
			
		}
		
		return extraFlags;
	}
	
	public static int getExtraFlags(IType type) throws JavaModelException {
		int extraFlags = 0;
		
		if (type.isMember()) {
			extraFlags |= ExtraFlags.IsMemberType;
		}
		
		if (type.isLocal()) {
			extraFlags |= ExtraFlags.IsLocalType;
		}
		
		IType[] memberTypes = type.getTypes();
		int memberTypeCounter = memberTypes == null ? 0 : memberTypes.length;
		if (memberTypeCounter > 0) {
			done : for (int i = 0; i < memberTypeCounter; i++) {
				int flags = memberTypes[i].getFlags();
				// if the member type is static and not private
				if ((flags & ClassFileConstants.AccStatic) != 0 && (flags & ClassFileConstants.AccPrivate) == 0 ) {
					extraFlags |= ExtraFlags.HasNonPrivateStaticMemberTypes;
					break done;
				}
			}
		}
		
		return extraFlags;
	}
	
	public static int getExtraFlags(TypeDeclaration typeDeclaration) {
		int extraFlags = 0;
		
		if (typeDeclaration.enclosingType != null) {
			extraFlags |= ExtraFlags.IsMemberType;
		}
		TypeDeclaration[] memberTypes = typeDeclaration.memberTypes;
		int memberTypeCounter = memberTypes == null ? 0 : memberTypes.length;
		if (memberTypeCounter > 0) {
			done : for (int i = 0; i < memberTypeCounter; i++) {
				int modifiers = memberTypes[i].modifiers;
				// if the member type is static and not private
				if ((modifiers & ClassFileConstants.AccStatic) != 0 && (modifiers & ClassFileConstants.AccPrivate) == 0) {
					extraFlags |= ExtraFlags.HasNonPrivateStaticMemberTypes;
					break done;
				}
			}
		}
		
		return extraFlags;
	}
}




		this.deleteProject("P3");
	}
}
public void testBug6930_01() throws Exception {
	try {
		IJavaProject p = createJavaProject("P", new String[] {"src"}, new String[]{"JCL_LIB"}, "bin");
		
		createFolder("/P/src/p6930");
		
		this.workingCopies = new ICompilationUnit[3];
		
		this.workingCopies[1] = getWorkingCopy("/P/src/p6930/AllConstructors01.java",
			"package p6930;\n" +
			"public class AllConstructors01 {\n" +
			"  public AllConstructors01() {}\n" +
			"  public AllConstructors01(Object o) {}\n" +
			"  public AllConstructors01(Object o, String s) {}\n" +
			"}\n"
		);
		
		this.workingCopies[2] = getWorkingCopy("/P/src/p6930/AllConstructors01b.java",
			"package p6930;\n" +
			"public class AllConstructors01b {\n" +
			"}\n"
		);
		
		refresh(p);
		
		waitUntilIndexesReady();
		
		this.workingCopies[0] = getWorkingCopy(
				"/P/src/test/Test.java",
				"package test;"+
				"public class Test {\n" +
				"  void foo() {\n" +
				"    new AllConstructors\n" +
				"  }\n" +
				"}");

		// do completion
		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
		requestor.setAllowsLongComputationProposals(true);

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
	    
	    assertResults(
			"AllConstructors01[CONSTRUCTOR_INVOCATION]{p6930.AllConstructors01(), Lp6930.AllConstructors01;, ()V, AllConstructors01, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors01[CONSTRUCTOR_INVOCATION]{p6930.AllConstructors01(), Lp6930.AllConstructors01;, (Ljava.lang.Object;)V, AllConstructors01, (o), "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors01[CONSTRUCTOR_INVOCATION]{p6930.AllConstructors01(), Lp6930.AllConstructors01;, (Ljava.lang.Object;Ljava.lang.String;)V, AllConstructors01, (o, s), "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors01b[CONSTRUCTOR_INVOCATION]{p6930.AllConstructors01b(), Lp6930.AllConstructors01b;, ()V, AllConstructors01b, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}",
			requestor.getResults());
	} finally {
		deleteProject("P");
	}
}
public void testBug6930_02() throws Exception {
	try {
		IJavaProject p = createJavaProject("P", new String[] {"src"}, new String[]{"JCL_LIB", "/P/lib6930.jar"}, "bin");
		
		createJar(new String[] {
			"p6930/AllConstructors02.java",
			"package p6930;\n" +
			"public class AllConstructors02 {\n" +
			"  public AllConstructors02() {}\n" +
			"  public AllConstructors02(Object o) {}\n" +
			"  public AllConstructors02(Object o, String s) {}\n" +
			"}",
			"p6930/AllConstructors02b.java",
			"package p6930;\n" +
			"public class AllConstructors02b {\n" +
			"}"
		}, p.getProject().getLocation().append("lib6930.jar").toOSString());
		
		refresh(p);
		
		waitUntilIndexesReady();
		
		this.workingCopies = new ICompilationUnit[1];
		this.workingCopies[0] = getWorkingCopy(
				"/P/src/test/Test.java",
				"package test;"+
				"public class Test {\n" +
				"  void foo() {\n" +
				"    new AllConstructors\n" +
				"  }\n" +
				"}");

		// do completion
		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
		requestor.setAllowsLongComputationProposals(true);

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
	    
	    assertResults(
			"AllConstructors02[CONSTRUCTOR_INVOCATION]{p6930.AllConstructors02(), Lp6930.AllConstructors02;, ()V, AllConstructors02, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors02[CONSTRUCTOR_INVOCATION]{p6930.AllConstructors02(), Lp6930.AllConstructors02;, (Ljava.lang.Object;)V, AllConstructors02, (o), "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors02[CONSTRUCTOR_INVOCATION]{p6930.AllConstructors02(), Lp6930.AllConstructors02;, (Ljava.lang.Object;Ljava.lang.String;)V, AllConstructors02, (o, s), "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors02b[CONSTRUCTOR_INVOCATION]{p6930.AllConstructors02b(), Lp6930.AllConstructors02b;, ()V, AllConstructors02b, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}",
			requestor.getResults());
	} finally {
		deleteProject("P");
	}
}
public void testBug6930_03() throws Exception {
	try {
		IJavaProject p = createJavaProject("P", new String[] {"src"}, new String[]{"JCL_LIB"}, "bin");
		
		createFolder("/P/src/p6930");
		
		createFile(
				"/P/src/p6930/AllConstructors03.java",
				"package p6930;\n" +
				"public class AllConstructors03 {\n" +
				"  public AllConstructors03() {}\n" +
				"  public AllConstructors03(Object o) {}\n" +
				"  public AllConstructors03(Object o, String s) {}\n" +
				"}");
		
		createFile(
				"/P/src/p6930/AllConstructors03b.java",
				"package p6930;\n" +
				"public class AllConstructors03b {\n" +
				"}");
		refresh(p);
		
		waitUntilIndexesReady();
		
		this.workingCopies = new ICompilationUnit[1];
		this.workingCopies[0] = getWorkingCopy(
				"/P/src/test/Test.java",
				"package test;"+
				"public class Test {\n" +
				"  void foo() {\n" +
				"    new AllConstructors\n" +
				"  }\n" +
				"}");

		// do completion
		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
		requestor.setAllowsLongComputationProposals(true);

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
	    
	    assertResults(
			"AllConstructors03[CONSTRUCTOR_INVOCATION]{p6930.AllConstructors03(), Lp6930.AllConstructors03;, ()V, AllConstructors03, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors03[CONSTRUCTOR_INVOCATION]{p6930.AllConstructors03(), Lp6930.AllConstructors03;, (Ljava.lang.Object;)V, AllConstructors03, (o), "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors03[CONSTRUCTOR_INVOCATION]{p6930.AllConstructors03(), Lp6930.AllConstructors03;, (Ljava.lang.Object;Ljava.lang.String;)V, AllConstructors03, (o, s), "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors03b[CONSTRUCTOR_INVOCATION]{p6930.AllConstructors03b(), Lp6930.AllConstructors03b;, ()V, AllConstructors03b, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}",
			requestor.getResults());
	} finally {
		deleteProject("P");
	}
}
public void testBug6930_04() throws Exception {
	try {
		IJavaProject p = createJavaProject("P", new String[] {"src"}, new String[]{"JCL_LIB"}, "bin");
		
		refresh(p);
		
		waitUntilIndexesReady();
		
		this.workingCopies = new ICompilationUnit[2];
		this.workingCopies[0] = getWorkingCopy(
				"/P/src/test/Test.java",
				"package test;"+
				"class AllConstructors04a {\n" +
				"  public class AllConstructors0b {\n" +
				"  }\n" +
				"}\n" +
				"public class Test {\n" +
				"  public class AllConstructors04c {\n" +
				"    public class AllConstructors04d {\n" +
				"    }\n" +
				"  }\n" +
				"  void foo() {\n" +
				"    class AllConstructors04e {\n" +
				"      class AllConstructors04f {\n" +
				"      }\n" +
				"    }\n" +
				"    new AllConstructors\n" +
				"  }\n" +
				"}");
		
		this.workingCopies[1] = getWorkingCopy(
				"/P/src/test/AllConstructors04g.java",
				"package test;"+
				"public class AllConstructors04g {\n" +
				"  public class AllConstructors0h {\n" +
				"  }\n" +
				"}");

		// do completion
		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
		requestor.setAllowsLongComputationProposals(true);

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
	    
	    assertResults(
			"AllConstructors04a[CONSTRUCTOR_INVOCATION]{AllConstructors04a(), Ltest.AllConstructors04a;, ()V, AllConstructors04a, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors04c[CONSTRUCTOR_INVOCATION]{AllConstructors04c(), Ltest.Test$AllConstructors04c;, ()V, AllConstructors04c, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors04e[CONSTRUCTOR_INVOCATION]{AllConstructors04e(), LAllConstructors04e;, ()V, AllConstructors04e, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors04g[CONSTRUCTOR_INVOCATION]{AllConstructors04g(), Ltest.AllConstructors04g;, ()V, AllConstructors04g, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}",
			requestor.getResults());
	} finally {
		deleteProject("P");
	}
}
public void testBug6930_05() throws Exception {
	try {
		IJavaProject p = createJavaProject("P", new String[] {"src"}, new String[]{"JCL_LIB"}, "bin");
		
		refresh(p);
		
		waitUntilIndexesReady();
		
		this.workingCopies = new ICompilationUnit[2];
		this.workingCopies[0] = getWorkingCopy(
				"/P/src/test/Test.java",
				"package test;"+
				"class AllConstructors05a {\n" +
				"  public static class AllConstructors0b {\n" +
				"  }\n" +
				"}\n" +
				"public class Test {\n" +
				"  public static class AllConstructors05c {\n" +
				"    public static class AllConstructors05d {\n" +
				"    }\n" +
				"  }\n" +
				"  void foo() {\n" +
				"    new AllConstructors\n" +
				"  }\n" +
				"}");
		
		this.workingCopies[1] = getWorkingCopy(
				"/P/src/test/AllConstructors05g.java",
				"package test;"+
				"public class AllConstructors05g {\n" +
				"  public static class AllConstructors0h {\n" +
				"  }\n" +
				"}");

		// do completion
		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
		requestor.setAllowsLongComputationProposals(true);

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
	    
	    assertResults(
			"AllConstructors05a[TYPE_REF]{AllConstructors05a, test, Ltest.AllConstructors05a;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors05a[CONSTRUCTOR_INVOCATION]{AllConstructors05a(), Ltest.AllConstructors05a;, ()V, AllConstructors05a, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors05c[CONSTRUCTOR_INVOCATION]{AllConstructors05c(), Ltest.Test$AllConstructors05c;, ()V, AllConstructors05c, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors05g[TYPE_REF]{AllConstructors05g, test, Ltest.AllConstructors05g;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors05g[CONSTRUCTOR_INVOCATION]{AllConstructors05g(), Ltest.AllConstructors05g;, ()V, AllConstructors05g, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"Test.AllConstructors05c[TYPE_REF]{AllConstructors05c, test, Ltest.Test$AllConstructors05c;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}",
			requestor.getResults());
	} finally {
		deleteProject("P");
	}
}
public void testBug6930_06() throws Exception {
	try {
		IJavaProject p = createJavaProject("P", new String[] {"src"}, new String[]{"JCL_LIB", "/P/lib6930.jar"}, "bin");
		
		createFolder("/P/src/p6930");
		
		createFile(
				"/P/src/p6930/AllConstructors06a.java",
				"package p6930;\n" +
				"public class AllConstructors06a {\n" +
				"}");
		
		createJar(new String[] {
			"p6930/AllConstructors06b.java",
			"package p6930;\n" +
			"public class AllConstructors06b {\n" +
			"}"
		}, p.getProject().getLocation().append("lib6930.jar").toOSString());
		
		refresh(p);
		
		waitUntilIndexesReady();
		
		this.workingCopies = new ICompilationUnit[2];
		this.workingCopies[0] = getWorkingCopy(
				"/P/src/test/Test.java",
				"package test;\n"+
				"import p6930.AllConstructors06a;\n"+
				"import p6930.AllConstructors06b;\n"+
				"import p6930.AllConstructors06c;\n"+
				"public class Test {\n" +
				"  void foo() {\n" +
				"    new AllConstructors\n" +
				"  }\n" +
				"}");
		
		this.workingCopies[1] = getWorkingCopy(
				"/P/src/p6930/AllConstructors06c.java",
				"package p6930;"+
				"public class AllConstructors06c {\n" +
				"}");

		// do completion
		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
		requestor.setAllowsLongComputationProposals(true);

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
	    
	    assertResults(
			"AllConstructors06a[CONSTRUCTOR_INVOCATION]{AllConstructors06a(), Lp6930.AllConstructors06a;, ()V, AllConstructors06a, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors06b[CONSTRUCTOR_INVOCATION]{AllConstructors06b(), Lp6930.AllConstructors06b;, ()V, AllConstructors06b, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors06c[CONSTRUCTOR_INVOCATION]{AllConstructors06c(), Lp6930.AllConstructors06c;, ()V, AllConstructors06c, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}",
			requestor.getResults());
	} finally {
		deleteProject("P");
	}
}
public void testBug6930_07() throws Exception {
	try {
		IJavaProject p = createJavaProject("P", new String[] {"src"}, new String[]{"JCL_LIB", "/P/lib6930.jar"}, "bin");
		
		createFolder("/P/src/p6930");
		
		createFile(
				"/P/src/p6930/AllConstructors07a.java",
				"package p6930;\n" +
				"public class AllConstructors07a {\n" +
				"  public class AllConstructors07b {\n" +
				"  }\n" +
				"  public static class AllConstructors07c {\n" +
				"  }\n" +
				"}");
		
		createFile(
				"/P/src/p6930/AllConstructors07d.java",
				"package p6930;\n" +
				"public class AllConstructors07d {\n" +
				"  public class AllConstructors07e {\n" +
				"  }\n" +
				"  public static class AllConstructors07f {\n" +
				"  }\n" +
				"}");
		
		refresh(p);
		
		waitUntilIndexesReady();
		
		this.workingCopies = new ICompilationUnit[1];
		this.workingCopies[0] = getWorkingCopy(
				"/P/src/test/Test.java",
				"package test;\n"+
				"import p6930.*;\n"+
				"public class Test {\n" +
				"  void foo() {\n" +
				"    new AllConstructors\n" +
				"  }\n" +
				"}");

		// do completion
		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
		requestor.setAllowsLongComputationProposals(true);

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
	    
	    assertResults(
			"AllConstructors07a[TYPE_REF]{AllConstructors07a, p6930, Lp6930.AllConstructors07a;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors07a[CONSTRUCTOR_INVOCATION]{AllConstructors07a(), Lp6930.AllConstructors07a;, ()V, AllConstructors07a, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors07d[TYPE_REF]{AllConstructors07d, p6930, Lp6930.AllConstructors07d;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors07d[CONSTRUCTOR_INVOCATION]{AllConstructors07d(), Lp6930.AllConstructors07d;, ()V, AllConstructors07d, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}",
			requestor.getResults());
	} finally {
		deleteProject("P");
	}
}
public void testBug6930_08() throws Exception {
	try {
		IJavaProject p = createJavaProject("P", new String[] {"src"}, new String[]{"JCL15_LIB", "/P/lib6930.jar"}, "bin", "1.5");
		
		createFolder("/P/src/p6930");
		
		createFile(
				"/P/src/p6930/AllConstructors08a.java",
				"package p6930;\n" +
				"public class AllConstructors08a {\n" +
				"  public class AllConstructors08b {\n" +
				"  }\n" +
				"  public static class AllConstructors08c {\n" +
				"  }\n" +
				"}");
		
		createFile(
				"/P/src/p6930/AllConstructors08d.java",
				"package p6930;\n" +
				"public class AllConstructors08d {\n" +
				"  public class AllConstructors08e {\n" +
				"  }\n" +
				"  public static class AllConstructors08f {\n" +
				"  }\n" +
				"}");
		
		refresh(p);
		
		waitUntilIndexesReady();
		
		this.workingCopies = new ICompilationUnit[1];
		this.workingCopies[0] = getWorkingCopy(
				"/P/src/test/Test.java",
				"package test;\n"+
				"import p6930.AllConstructors08a;\n"+
				"public class Test {\n" +
				"  void foo() {\n" +
				"    new AllConstructors\n" +
				"  }\n" +
				"}");

		// do completion
		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
		requestor.setAllowsLongComputationProposals(true);

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
	    
	    assertResults(
			"AllConstructors08d[TYPE_REF]{p6930.AllConstructors08d, p6930, Lp6930.AllConstructors08d;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors08d[CONSTRUCTOR_INVOCATION]{p6930.AllConstructors08d(), Lp6930.AllConstructors08d;, ()V, AllConstructors08d, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors08a[TYPE_REF]{AllConstructors08a, p6930, Lp6930.AllConstructors08a;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors08a[CONSTRUCTOR_INVOCATION]{AllConstructors08a(), Lp6930.AllConstructors08a;, ()V, AllConstructors08a, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}",
			requestor.getResults());
	} finally {
		deleteProject("P");
	}
}

public void testBug6930_09() throws Exception {
	try {
		IJavaProject p = createJavaProject("P", new String[] {"src"}, new String[]{"JCL15_LIB", "/P/lib6930.jar"}, "bin", "1.5");
		
		createFolder("/P/src/p6930");
		
		createFile(
				"/P/src/p6930/AllConstructors09a.java",
				"package p6930;\n" +
				"public class AllConstructors09a {\n" +
				"  public class AllConstructors09b {\n" +
				"  }\n" +
				"  public static class AllConstructors09c {\n" +
				"  }\n" +
				"}");
		
		createFile(
				"/P/src/p6930/AllConstructors09d.java",
				"package p6930;\n" +
				"public class AllConstructors09d {\n" +
				"  public class AllConstructors09e {\n" +
				"  }\n" +
				"  public static class AllConstructors09f {\n" +
				"    public static class AllConstructors09g {\n" +
				"    }\n" +
				"  }\n" +
				"}");
		
		refresh(p);
		
		waitUntilIndexesReady();
		
		this.workingCopies = new ICompilationUnit[1];
		this.workingCopies[0] = getWorkingCopy(
				"/P/src/test/Test.java",
				"package test;\n"+
				"import p6930.AllConstructors09a.*;\n"+
				"import static p6930.AllConstructors09d.*;\n"+
				"public class Test {\n" +
				"  void foo() {\n" +
				"    new AllConstructors\n" +
				"  }\n" +
				"}");

		// do completion
		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
		requestor.setAllowsLongComputationProposals(true);

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
	    
	    assertResults(
			"AllConstructors09a[TYPE_REF]{p6930.AllConstructors09a, p6930, Lp6930.AllConstructors09a;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors09a[CONSTRUCTOR_INVOCATION]{p6930.AllConstructors09a(), Lp6930.AllConstructors09a;, ()V, AllConstructors09a, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors09d[TYPE_REF]{p6930.AllConstructors09d, p6930, Lp6930.AllConstructors09d;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors09d[CONSTRUCTOR_INVOCATION]{p6930.AllConstructors09d(), Lp6930.AllConstructors09d;, ()V, AllConstructors09d, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors09d.AllConstructors09f[TYPE_REF]{AllConstructors09f, p6930, Lp6930.AllConstructors09d$AllConstructors09f;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors09f[CONSTRUCTOR_INVOCATION]{AllConstructors09f(), Lp6930.AllConstructors09d$AllConstructors09f;, ()V, AllConstructors09f, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}",
			requestor.getResults());
	} finally {
		deleteProject("P");
	}
}
public void testBug6930_10() throws Exception {
	try {
		IJavaProject p = createJavaProject("P", new String[] {"src"}, new String[]{"JCL15_LIB", "/P/lib6930.jar"}, "bin", "1.5");
		
		createFolder("/P/src/p6930");
		
		createFile(
				"/P/src/p6930/AllConstructors10a.java",
				"package p6930;\n" +
				"public class AllConstructors10a {\n" +
				"  public class AllConstructors10b {\n" +
				"    public static class AllConstructors10bs {\n" +
				"    }\n" +
				"  }\n" +
				"  public static class AllConstructors10c {\n" +
				"    public static class AllConstructors10cs {\n" +
				"    }\n" +
				"  }\n" +
				"}");
		
		createFile(
				"/P/src/p6930/AllConstructors10d.java",
				"package p6930;\n" +
				"public class AllConstructors10d {\n" +
				"  public class AllConstructors10e {\n" +
				"    public static class AllConstructors10es {\n" +
				"    }\n" +
				"  }\n" +
				"  public static class AllConstructors10f {\n" +
				"    public static class AllConstructors10fs {\n" +
				"    }\n" +
				"  }\n" +
				"}");
		
		refresh(p);
		
		waitUntilIndexesReady();
		
		this.workingCopies = new ICompilationUnit[1];
		this.workingCopies[0] = getWorkingCopy(
				"/P/src/test/Test.java",
				"package test;\n"+
				"import p6930.AllConstructors10a.AllConstructors10b;\n"+
				"import p6930.AllConstructors10a.AllConstructors10c;\n"+
				"import static p6930.AllConstructors10d.AllConstructors10e;\n"+
				"import static p6930.AllConstructors10d.AllConstructors10f;\n"+
				"public class Test {\n" +
				"  void foo() {\n" +
				"    new AllConstructors\n" +
				"  }\n" +
				"}");

		// do completion
		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
		requestor.setAllowsLongComputationProposals(true);

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
	    
	    assertResults(
			"AllConstructors10a[TYPE_REF]{p6930.AllConstructors10a, p6930, Lp6930.AllConstructors10a;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors10a[CONSTRUCTOR_INVOCATION]{p6930.AllConstructors10a(), Lp6930.AllConstructors10a;, ()V, AllConstructors10a, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors10d[TYPE_REF]{p6930.AllConstructors10d, p6930, Lp6930.AllConstructors10d;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors10d[CONSTRUCTOR_INVOCATION]{p6930.AllConstructors10d(), Lp6930.AllConstructors10d;, ()V, AllConstructors10d, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors10a.AllConstructors10c[TYPE_REF]{AllConstructors10c, p6930, Lp6930.AllConstructors10a$AllConstructors10c;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors10c[CONSTRUCTOR_INVOCATION]{AllConstructors10c(), Lp6930.AllConstructors10a$AllConstructors10c;, ()V, AllConstructors10c, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors10d.AllConstructors10f[TYPE_REF]{AllConstructors10f, p6930, Lp6930.AllConstructors10d$AllConstructors10f;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors10f[CONSTRUCTOR_INVOCATION]{AllConstructors10f(), Lp6930.AllConstructors10d$AllConstructors10f;, ()V, AllConstructors10f, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}",
			requestor.getResults());
	} finally {
		deleteProject("P");
	}
}
public void testBug6930_11() throws Exception {
	try {
		IJavaProject p = createJavaProject("P", new String[] {"src"}, new String[]{"JCL_LIB", "/P/lib6930.jar"}, "bin");
		
		createFolder("/P/src/p6930");
		
		createFile(
				"/P/src/p6930/AllConstructors11a.java",
				"package p6930;\n" +
				"public class AllConstructors11a {\n" +
				"}");

		
		refresh(p);
		
		waitUntilIndexesReady();
		
		this.workingCopies = new ICompilationUnit[1];
		this.workingCopies[0] = getWorkingCopy(
				"/P/src/test/Test.java",
				"package test;\n"+
				"public class Test {\n" +
				"  void foo() {\n" +
				"    p6930.AllConstructors11a a = new \n" +
				"  }\n" +
				"}");

		// do completion
		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
		requestor.setAllowsLongComputationProposals(true);

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "new ";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
	    
	    assertResults(
			"Test[CONSTRUCTOR_INVOCATION]{Test(), Ltest.Test;, ()V, Test, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors11a[CONSTRUCTOR_INVOCATION]{p6930.AllConstructors11a(), Lp6930.AllConstructors11a;, ()V, AllConstructors11a, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_EXACT_EXPECTED_TYPE + R_NON_RESTRICTED)+"}",
			requestor.getResults());
	} finally {
		deleteProject("P");
	}
}
public void testBug6930_12() throws Exception {
	try {
		IJavaProject p = createJavaProject("P", new String[] {"src"}, new String[]{"JCL_LIB", "/P/lib6930.jar"}, "bin");
		
		createFolder("/P/src/p6930");
		
		createFile(
				"/P/src/p6930/AllConstructors12a.java",
				"package p6930;\n" +
				"public class AllConstructors12a {\n" +
				"  public static class AllConstructors12b {\n" +
				"  }\n" +
				"}");
		
		refresh(p);
		
		waitUntilIndexesReady();
		
		this.workingCopies = new ICompilationUnit[1];
		this.workingCopies[0] = getWorkingCopy(
				"/P/src/test/Test.java",
				"package test;\n"+
				"public class Test {\n" +
				"  void foo() {\n" +
				"    p6930.AllConstructors12a a = new \n" +
				"  }\n" +
				"}");

		// do completion
		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
		requestor.setAllowsLongComputationProposals(true);

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "new ";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
	    
	    assertResults(
			"Test[CONSTRUCTOR_INVOCATION]{Test(), Ltest.Test;, ()V, Test, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors12a[TYPE_REF]{p6930.AllConstructors12a, p6930, Lp6930.AllConstructors12a;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_EXACT_EXPECTED_TYPE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors12a[CONSTRUCTOR_INVOCATION]{p6930.AllConstructors12a(), Lp6930.AllConstructors12a;, ()V, AllConstructors12a, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_EXACT_EXPECTED_TYPE + R_NON_RESTRICTED)+"}",
			requestor.getResults());
	} finally {
		deleteProject("P");
	}
}
public void testBug6930_13() throws Exception {
	try {
		IJavaProject p = createJavaProject("P", new String[] {"src"}, new String[]{"JCL_LIB", "/P/lib6930.jar"}, "bin");
		
		createFolder("/P/src/p6930");
		
		createFile(
				"/P/src/p6930/AllConstructors13a.java",
				"package p6930;\n" +
				"public class AllConstructors13a {\n" +
				"}");

		
		refresh(p);
		
		waitUntilIndexesReady();
		
		this.workingCopies = new ICompilationUnit[1];
		this.workingCopies[0] = getWorkingCopy(
				"/P/src/test/Test.java",
				"package test;\n"+
				"public class Test {\n" +
				"  void foo() {\n" +
				"    p6930.AllConstructors13a a = new AllConstructors\n" +
				"  }\n" +
				"}");

		// do completion
		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
		requestor.setAllowsLongComputationProposals(true);

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "new AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
	    
	    assertResults(
			"AllConstructors13a[CONSTRUCTOR_INVOCATION]{p6930.AllConstructors13a(), Lp6930.AllConstructors13a;, ()V, AllConstructors13a, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_EXACT_EXPECTED_TYPE + R_NON_RESTRICTED)+"}",
			requestor.getResults());
	} finally {
		deleteProject("P");
	}
}
public void testBug6930_14() throws Exception {
	try {
		IJavaProject p = createJavaProject("P", new String[] {"src"}, new String[]{"JCL_LIB", "/P/lib6930.jar"}, "bin");
		
		createFolder("/P/src/p6930");
		
		createFile(
				"/P/src/p6930/AllConstructors14a.java",
				"package p6930;\n" +
				"public class AllConstructors14a {\n" +
				"  public static class AllConstructors14b {\n" +
				"  }\n" +
				"}");
		
		refresh(p);
		
		waitUntilIndexesReady();
		
		this.workingCopies = new ICompilationUnit[1];
		this.workingCopies[0] = getWorkingCopy(
				"/P/src/test/Test.java",
				"package test;\n"+
				"public class Test {\n" +
				"  void foo() {\n" +
				"    p6930.AllConstructors14a a = new AllConstructors\n" +
				"  }\n" +
				"}");

		// do completion
		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
		requestor.setAllowsLongComputationProposals(true);

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "new AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
	    
	    assertResults(
			"AllConstructors14a[TYPE_REF]{p6930.AllConstructors14a, p6930, Lp6930.AllConstructors14a;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_EXACT_EXPECTED_TYPE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors14a[CONSTRUCTOR_INVOCATION]{p6930.AllConstructors14a(), Lp6930.AllConstructors14a;, ()V, AllConstructors14a, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_EXACT_EXPECTED_TYPE + R_NON_RESTRICTED)+"}",
			requestor.getResults());
	} finally {
		deleteProject("P");
	}
}
public void testBug6930_15() throws Exception {
	try {
		IJavaProject p = createJavaProject("P", new String[] {"src"}, new String[]{"JCL15_LIB", "/P/lib6930.jar"}, "bin", "1.5");
		
		createFolder("/P/src/p6930");
		
		createFile(
				"/P/src/p6930/AllConstructors15a.java",
				"package p6930;\n" +
				"public class AllConstructors15a<T> {\n" +
				"}");
		
		createJar(
				new String[] {
					"p6930/AllConstructors15b.java",
					"package p6930;\n" +
					"public class AllConstructors15b<T> {\n" +
					"}"
				},
				p.getProject().getLocation().append("lib6930.jar").toOSString(),
				new String[]{getExternalJCLPathString("1.5")},
				"1.5");
		
		refresh(p);
		
		waitUntilIndexesReady();
		
		this.workingCopies = new ICompilationUnit[2];
		this.workingCopies[0] = getWorkingCopy(
				"/P/src/test/Test.java",
				"package test;\n"+
				"public class Test {\n" +
				"  void foo() {\n" +
				"    new AllConstructors\n" +
				"  }\n" +
				"}");
		
		this.workingCopies[1] = getWorkingCopy(
				"/P/src/p6930/AllConstructors15c.java",
				"package p6930;"+
				"public class AllConstructors15c<T> {\n" +
				"}");

		// do completion
		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
		requestor.setAllowsLongComputationProposals(true);

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
	    
	    assertResults(
			"AllConstructors15a[CONSTRUCTOR_INVOCATION]{p6930.AllConstructors15a(), Lp6930.AllConstructors15a;, ()V, AllConstructors15a, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors15b[CONSTRUCTOR_INVOCATION]{p6930.AllConstructors15b(), Lp6930.AllConstructors15b;, ()V, AllConstructors15b, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors15c[CONSTRUCTOR_INVOCATION]{p6930.AllConstructors15c(), Lp6930.AllConstructors15c;, ()V, AllConstructors15c, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}",
			requestor.getResults());
	} finally {
		deleteProject("P");
	}
}
public void testBug6930_16() throws Exception {
	try {
		IJavaProject p = createJavaProject("P", new String[] {"src"}, new String[]{"JCL15_LIB", "/P/lib6930.jar"}, "bin", "1.5");
		
		createFolder("/P/src/p6930");
		
		createFile(
				"/P/src/p6930/AllConstructors16a.java",
				"package p6930;\n" +
				"public class AllConstructors16a{\n" +
				"  public <T> AllConstructors16a(){}\n" +
				"}");
		
		createJar(
				new String[] {
					"p6930/AllConstructors16b.java",
					"package p6930;\n" +
					"public class AllConstructors16b {\n" +
					"  public <T> AllConstructors16b(){}\n" +
					"}"
				},
				p.getProject().getLocation().append("lib6930.jar").toOSString(),
				new String[]{getExternalJCLPathString("1.5")},
				"1.5");
		
		refresh(p);
		
		waitUntilIndexesReady();
		
		this.workingCopies = new ICompilationUnit[2];
		this.workingCopies[0] = getWorkingCopy(
				"/P/src/test/Test.java",
				"package test;\n"+
				"public class Test {\n" +
				"  void foo() {\n" +
				"    new AllConstructors\n" +
				"  }\n" +
				"}");
		
		this.workingCopies[1] = getWorkingCopy(
				"/P/src/p6930/AllConstructors16c.java",
				"package p6930;"+
				"public class AllConstructors16c {\n" +
				"  public <T> AllConstructors16c(){}\n" +
				"}");

		// do completion
		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
		requestor.setAllowsLongComputationProposals(true);

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
	    
	    assertResults(
			"AllConstructors16a[CONSTRUCTOR_INVOCATION]{p6930.AllConstructors16a(), Lp6930.AllConstructors16a;, ()V, AllConstructors16a, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors16b[CONSTRUCTOR_INVOCATION]{p6930.AllConstructors16b(), Lp6930.AllConstructors16b;, ()V, AllConstructors16b, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors16c[CONSTRUCTOR_INVOCATION]{p6930.AllConstructors16c(), Lp6930.AllConstructors16c;, ()V, AllConstructors16c, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}",
			requestor.getResults());
	} finally {
		deleteProject("P");
	}
}
public void testBug6930_17() throws Exception {
	try {
		IJavaProject p = createJavaProject("P", new String[] {"src"}, new String[]{"JCL15_LIB", "/P/lib6930.jar"}, "bin", "1.5");
		
		createFolder("/P/src/p6930");
		
		createFile(
				"/P/src/p6930/AllConstructors17a.java",
				"package p6930;\n" +
				"public class AllConstructors17a{\n" +
				"  public AllConstructors17a(java.util.Collection<Object> o){}\n" +
				"}");
		
		createJar(
				new String[] {
					"p6930/AllConstructors17b.java",
					"package p6930;\n" +
					"public class AllConstructors17b {\n" +
					"  public AllConstructors17b(java.util.Collection<Object> o){}\n" +
					"}"
				},
				p.getProject().getLocation().append("lib6930.jar").toOSString(),
				new String[]{getExternalJCLPathString("1.5")},
				"1.5");
		
		refresh(p);
		
		waitUntilIndexesReady();
		
		this.workingCopies = new ICompilationUnit[2];
		this.workingCopies[0] = getWorkingCopy(
				"/P/src/test/Test.java",
				"package test;\n"+
				"public class Test {\n" +
				"  void foo() {\n" +
				"    new AllConstructors\n" +
				"  }\n" +
				"}");
		
		this.workingCopies[1] = getWorkingCopy(
				"/P/src/p6930/AllConstructors17c.java",
				"package p6930;"+
				"public class AllConstructors17c {\n" +
				"  public AllConstructors17c(java.util.Collection<Object> o){}\n" +
				"}");

		// do completion
		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
		requestor.setAllowsLongComputationProposals(true);

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
	    
	    assertResults(
			"AllConstructors17a[CONSTRUCTOR_INVOCATION]{p6930.AllConstructors17a(), Lp6930.AllConstructors17a;, (Ljava.util.Collection<Ljava.lang.Object;>;)V, AllConstructors17a, (o), "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors17b[CONSTRUCTOR_INVOCATION]{p6930.AllConstructors17b(), Lp6930.AllConstructors17b;, (Ljava.util.Collection<Ljava.lang.Object;>;)V, AllConstructors17b, (o), "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors17c[CONSTRUCTOR_INVOCATION]{p6930.AllConstructors17c(), Lp6930.AllConstructors17c;, (Ljava.util.Collection<Ljava.lang.Object;>;)V, AllConstructors17c, (o), "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}",
			requestor.getResults());
	} finally {
		deleteProject("P");
	}
}
public void testBug6930_18() throws Exception {
	try {
		IJavaProject p = createJavaProject("P", new String[] {"src"}, new String[]{"JCL_LIB", "/P/lib6930.jar"}, "bin");
		
		createFolder("/P/src/p6930");
		
		createFile(
				"/P/src/p6930/AllConstructors18a.java",
				"package p6930;\n" +
				"public interface AllConstructors18a {\n" +
				"}");
		
		createJar(new String[] {
			"p6930/AllConstructors18b.java",
			"package p6930;\n" +
			"public interface AllConstructors18b {\n" +
			"}"
		}, p.getProject().getLocation().append("lib6930.jar").toOSString());
		
		refresh(p);
		
		waitUntilIndexesReady();
		
		this.workingCopies = new ICompilationUnit[2];
		this.workingCopies[0] = getWorkingCopy(
				"/P/src/test/Test.java",
				"package test;\n"+
				"public class Test {\n" +
				"  void foo() {\n" +
				"    new AllConstructors\n" +
				"  }\n" +
				"}");
		
		this.workingCopies[1] = getWorkingCopy(
				"/P/src/p6930/AllConstructors18c.java",
				"package p6930;"+
				"public interface AllConstructors18c {\n" +
				"}");

		// do completion
		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
		requestor.setAllowsLongComputationProposals(true);

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
	    
	    assertResults(
			"AllConstructors18a[ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION]{p6930.AllConstructors18a(), Lp6930.AllConstructors18a;, ()V, AllConstructors18a, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors18b[ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION]{p6930.AllConstructors18b(), Lp6930.AllConstructors18b;, ()V, AllConstructors18b, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors18c[ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION]{p6930.AllConstructors18c(), Lp6930.AllConstructors18c;, ()V, AllConstructors18c, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}",
			requestor.getResults());
	} finally {
		deleteProject("P");
	}
}
public void testBug6930_19() throws Exception {
	try {
		IJavaProject p = createJavaProject("P", new String[] {"src"}, new String[]{"JCL_LIB", "/P/lib6930.jar"}, "bin");
		
		createFolder("/P/src/p6930");
		
		createFile(
				"/P/src/p6930/AllConstructors19a.java",
				"package p6930;\n" +
				"public interface AllConstructors19a {\n" +
				"}");
		
		createJar(new String[] {
			"p6930/AllConstructors19b.java",
			"package p6930;\n" +
			"public interface AllConstructors19b {\n" +
			"}"
		}, p.getProject().getLocation().append("lib6930.jar").toOSString());
		
		refresh(p);
		
		waitUntilIndexesReady();
		
		this.workingCopies = new ICompilationUnit[2];
		this.workingCopies[0] = getWorkingCopy(
				"/P/src/test/Test.java",
				"package test;\n"+
				"import p6930.AllConstructors19a;\n"+
				"import p6930.AllConstructors19b;\n"+
				"import p6930.AllConstructors19c;\n"+
				"public class Test {\n" +
				"  void foo() {\n" +
				"    new AllConstructors\n" +
				"  }\n" +
				"}");
		
		this.workingCopies[1] = getWorkingCopy(
				"/P/src/p6930/AllConstructors19c.java",
				"package p6930;"+
				"public interface AllConstructors19c {\n" +
				"}");

		// do completion
		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
		requestor.setAllowsLongComputationProposals(true);

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
	    
	    assertResults(
			"AllConstructors19a[ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION]{AllConstructors19a(), Lp6930.AllConstructors19a;, ()V, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors19b[ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION]{AllConstructors19b(), Lp6930.AllConstructors19b;, ()V, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors19c[ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION]{AllConstructors19c(), Lp6930.AllConstructors19c;, ()V, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}",
			requestor.getResults());
	} finally {
		deleteProject("P");
	}
}
public void testBug6930_20() throws Exception {
	try {
		IJavaProject p = createJavaProject("P", new String[] {"src"}, new String[]{"JCL15_LIB", "/P/lib6930.jar"}, "bin", "1.5");
		
		createFolder("/P/src/p6930");
		
		createFile(
				"/P/src/p6930/AllConstructors20a.java",
				"package p6930;\n" +
				"public enum AllConstructors20a {\n" +
				"	ZZZ;\n" +
				"}");
		
		createJar(new String[] {
				"p6930/AllConstructors20b.java",
				"package p6930;\n" +
				"public enum AllConstructors20b {\n" +
				"	ZZZ;\n" +
				"}"
			},
			p.getProject().getLocation().append("lib6930.jar").toOSString(),
			new String[]{getExternalJCLPathString("1.5")},
			"1.5");
		
		refresh(p);
		
		waitUntilIndexesReady();
		
		this.workingCopies = new ICompilationUnit[2];
		this.workingCopies[0] = getWorkingCopy(
				"/P/src/test/Test.java",
				"package test;\n"+
				"public class Test {\n" +
				"  void foo() {\n" +
				"    new AllConstructors\n" +
				"  }\n" +
				"}");
		
		this.workingCopies[1] = getWorkingCopy(
				"/P/src/p6930/AllConstructors20c.java",
				"package p6930;"+
				"public enum AllConstructors20c {\n" +
				"	ZZZ;\n" +
				"}");

		// do completion
		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
		requestor.setAllowsLongComputationProposals(true);

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
	    
	    assertResults(
			"",
			requestor.getResults());
	} finally {
		deleteProject("P");
	}
}
public void testBug6930_21() throws Exception {
	try {
		IJavaProject p = createJavaProject("P", new String[] {"src"}, new String[]{"JCL15_LIB", "/P/lib6930.jar"}, "bin", "1.5");
		
		createFolder("/P/src/p6930");
		
		createFile(
				"/P/src/p6930/AllConstructors21a.java",
				"package p6930;\n" +
				"public enum AllConstructors21a {\n" +
				"	ZZZ;\n" +
				"}");
		
		createJar(
				new String[] {
					"p6930/AllConstructors21b.java",
					"package p6930;\n" +
					"public enum AllConstructors21b {\n" +
					"	ZZZ;\n" +
					"}"
				},
				p.getProject().getLocation().append("lib6930.jar").toOSString(),
				new String[]{getExternalJCLPathString("1.5")},
				"1.5");
		
		refresh(p);
		
		waitUntilIndexesReady();
		
		this.workingCopies = new ICompilationUnit[2];
		this.workingCopies[0] = getWorkingCopy(
				"/P/src/test/Test.java",
				"package test;\n"+
				"import p6930.AllConstructors21a;\n"+
				"import p6930.AllConstructors21b;\n"+
				"import p6930.AllConstructors21c;\n"+
				"public class Test {\n" +
				"  void foo() {\n" +
				"    new AllConstructors\n" +
				"  }\n" +
				"}");
		
		this.workingCopies[1] = getWorkingCopy(
				"/P/src/p6930/AllConstructors21c.java",
				"package p6930;"+
				"public enum AllConstructors21c {\n" +
				"	ZZZ;\n" +
				"}");

		// do completion
		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
		requestor.setAllowsLongComputationProposals(true);

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
	    
	    assertResults(
			"",
			requestor.getResults());
	} finally {
		deleteProject("P");
	}
}
public void testBug6930_22() throws Exception {
	Hashtable oldOptions = JavaCore.getOptions();
	try {
		Hashtable options = new Hashtable(oldOptions);
		options.put(JavaCore.CODEASSIST_VISIBILITY_CHECK, JavaCore.ENABLED);
		JavaCore.setOptions(options);
		
		IJavaProject p = createJavaProject("P", new String[] {"src"}, new String[]{"JCL_LIB", "/P/lib6930.jar"}, "bin");
		
		createFolder("/P/src/p6930");
		
		createFile(
				"/P/src/p6930/AllConstructors22a.java",
				"package p6930;\n" +
				"public class AllConstructors22a {\n" +
				"	private AllConstructors22a(){}\n" +
				"	public static class AllConstructorsInner{}\n" +
				"}");
		
		createJar(new String[] {
			"p6930/AllConstructors22b.java",
			"package p6930;\n" +
			"public class AllConstructors22b {\n" +
			"	private AllConstructors22b(){}\n" +
			"	public static class AllConstructorsInner{}\n" +
			"}"
		}, p.getProject().getLocation().append("lib6930.jar").toOSString());
		
		refresh(p);
		
		waitUntilIndexesReady();
		
		this.workingCopies = new ICompilationUnit[2];
		this.workingCopies[0] = getWorkingCopy(
				"/P/src/test/Test.java",
				"package test;\n"+
				"public class Test {\n" +
				"  void foo() {\n" +
				"    new AllConstructors\n" +
				"  }\n" +
				"}");
		
		this.workingCopies[1] = getWorkingCopy(
				"/P/src/p6930/AllConstructors22c.java",
				"package p6930;"+
				"public class AllConstructors22c {\n" +
				"	private AllConstructors22c(){}\n" +
				"	public static class AllConstructorsInner{}\n" +
				"}");

		// do completion
		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
		requestor.setAllowsLongComputationProposals(true);

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
	    
	    assertResults(
			"AllConstructors22a[TYPE_REF]{p6930.AllConstructors22a, p6930, Lp6930.AllConstructors22a;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors22b[TYPE_REF]{p6930.AllConstructors22b, p6930, Lp6930.AllConstructors22b;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors22c[TYPE_REF]{p6930.AllConstructors22c, p6930, Lp6930.AllConstructors22c;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}",
			requestor.getResults());
	} finally {
		deleteProject("P");
		
		JavaCore.setOptions(oldOptions);
	}
}
public void testBug6930_23() throws Exception {
	Hashtable oldOptions = JavaCore.getOptions();
	try {
		Hashtable options = new Hashtable(oldOptions);
		options.put(JavaCore.CODEASSIST_VISIBILITY_CHECK, JavaCore.ENABLED);
		JavaCore.setOptions(options);
		
		IJavaProject p = createJavaProject("P", new String[] {"src"}, new String[]{"JCL_LIB", "/P/lib6930.jar"}, "bin");
		
		createFolder("/P/src/p6930");
		
		createFile(
				"/P/src/p6930/AllConstructors23a.java",
				"package p6930;\n" +
				"public class AllConstructors23a {\n" +
				"	private AllConstructors23a(){}\n" +
				"	public static class AllConstructorsInner{}\n" +
				"}");
		
		createJar(new String[] {
			"p6930/AllConstructors23b.java",
			"package p6930;\n" +
			"public class AllConstructors23b {\n" +
			"	private AllConstructors23b(){}\n" +
			"	public static class AllConstructorsInner{}\n" +
			"}"
		}, p.getProject().getLocation().append("lib6930.jar").toOSString());
		
		refresh(p);
		
		waitUntilIndexesReady();
		
		this.workingCopies = new ICompilationUnit[2];
		this.workingCopies[0] = getWorkingCopy(
				"/P/src/test/Test.java",
				"package test;\n"+
				"import p6930.AllConstructors23a;\n"+
				"import p6930.AllConstructors23b;\n"+
				"import p6930.AllConstructors23c;\n"+
				"public class Test {\n" +
				"  void foo() {\n" +
				"    new AllConstructors\n" +
				"  }\n" +
				"}");
		
		this.workingCopies[1] = getWorkingCopy(
				"/P/src/p6930/AllConstructors23c.java",
				"package p6930;"+
				"public class AllConstructors23c {\n" +
				"	private AllConstructors23c(){}\n" +
				"	public static class AllConstructorsInner{}\n" +
				"}");

		// do completion
		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
		requestor.setAllowsLongComputationProposals(true);

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
	    
	    assertResults(
			"AllConstructors23a[TYPE_REF]{AllConstructors23a, p6930, Lp6930.AllConstructors23a;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors23b[TYPE_REF]{AllConstructors23b, p6930, Lp6930.AllConstructors23b;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors23c[TYPE_REF]{AllConstructors23c, p6930, Lp6930.AllConstructors23c;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}",
			requestor.getResults());
	} finally {
		deleteProject("P");
		
		JavaCore.setOptions(oldOptions);
	}
}
public void testBug6930_24() throws Exception {
	Hashtable oldOptions = JavaCore.getOptions();
	try {
		Hashtable options = new Hashtable(oldOptions);
		options.put(JavaCore.CODEASSIST_VISIBILITY_CHECK, JavaCore.ENABLED);
		JavaCore.setOptions(options);
		
		IJavaProject p = createJavaProject("P", new String[] {"src"}, new String[]{"JCL_LIB", "/P/lib6930.jar"}, "bin");
		
		createFolder("/P/src/p6930");
		
		createFile(
				"/P/src/p6930/AllConstructors24a.java",
				"package p6930;\n" +
				"public class AllConstructors24a {\n" +
				"	public AllConstructors24a(){}\n" +
				"	private static class AllConstructorsInner{}\n" +
				"}");
		
		createJar(new String[] {
			"p6930/AllConstructors24b.java",
			"package p6930;\n" +
			"public class AllConstructors24b {\n" +
			"	public AllConstructors24b(){}\n" +
			"	private static class AllConstructorsInner{}\n" +
			"}"
		}, p.getProject().getLocation().append("lib6930.jar").toOSString());
		
		refresh(p);
		
		waitUntilIndexesReady();
		
		this.workingCopies = new ICompilationUnit[2];
		this.workingCopies[0] = getWorkingCopy(
				"/P/src/test/Test.java",
				"package test;\n"+
				"public class Test {\n" +
				"  void foo() {\n" +
				"    new AllConstructors\n" +
				"  }\n" +
				"}");
		
		this.workingCopies[1] = getWorkingCopy(
				"/P/src/p6930/AllConstructors24c.java",
				"package p6930;"+
				"public class AllConstructors24c {\n" +
				"	public AllConstructors24c(){}\n" +
				"	private static class AllConstructorsInner{}\n" +
				"}");

		// do completion
		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
		requestor.setAllowsLongComputationProposals(true);

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
	    
	    assertResults(
			"AllConstructors24a[CONSTRUCTOR_INVOCATION]{p6930.AllConstructors24a(), Lp6930.AllConstructors24a;, ()V, AllConstructors24a, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors24b[CONSTRUCTOR_INVOCATION]{p6930.AllConstructors24b(), Lp6930.AllConstructors24b;, ()V, AllConstructors24b, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors24c[CONSTRUCTOR_INVOCATION]{p6930.AllConstructors24c(), Lp6930.AllConstructors24c;, ()V, AllConstructors24c, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}",
			requestor.getResults());
	} finally {
		deleteProject("P");
		
		JavaCore.setOptions(oldOptions);
	}
}
public void testBug6930_25() throws Exception {
	Hashtable oldOptions = JavaCore.getOptions();
	try {
		Hashtable options = new Hashtable(oldOptions);
		options.put(JavaCore.CODEASSIST_VISIBILITY_CHECK, JavaCore.ENABLED);
		JavaCore.setOptions(options);
		
		IJavaProject p = createJavaProject("P", new String[] {"src"}, new String[]{"JCL_LIB", "/P/lib6930.jar"}, "bin");
		
		createFolder("/P/src/p6930");
		
		createFile(
				"/P/src/p6930/AllConstructors25a.java",
				"package p6930;\n" +
				"public class AllConstructors25a {\n" +
				"	public AllConstructors25a(){}\n" +
				"	private static class AllConstructorsInner{}\n" +
				"}");
		
		createJar(new String[] {
			"p6930/AllConstructors25b.java",
			"package p6930;\n" +
			"public class AllConstructors25b {\n" +
			"	public AllConstructors25b(){}\n" +
			"	private static class AllConstructorsInner{}\n" +
			"}"
		}, p.getProject().getLocation().append("lib6930.jar").toOSString());
		
		refresh(p);
		
		waitUntilIndexesReady();
		
		this.workingCopies = new ICompilationUnit[2];
		this.workingCopies[0] = getWorkingCopy(
				"/P/src/test/Test.java",
				"package test;\n"+
				"import p6930.AllConstructors25a;\n"+
				"import p6930.AllConstructors25b;\n"+
				"import p6930.AllConstructors25c;\n"+
				"public class Test {\n" +
				"  void foo() {\n" +
				"    new AllConstructors\n" +
				"  }\n" +
				"}");
		
		this.workingCopies[1] = getWorkingCopy(
				"/P/src/p6930/AllConstructors25c.java",
				"package p6930;"+
				"public class AllConstructors25c {\n" +
				"	public AllConstructors25c(){}\n" +
				"	private static class AllConstructorsInner{}\n" +
				"}");

		// do completion
		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
		requestor.setAllowsLongComputationProposals(true);

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
	    
	    assertResults(
			"AllConstructors25a[CONSTRUCTOR_INVOCATION]{AllConstructors25a(), Lp6930.AllConstructors25a;, ()V, AllConstructors25a, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors25b[CONSTRUCTOR_INVOCATION]{AllConstructors25b(), Lp6930.AllConstructors25b;, ()V, AllConstructors25b, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors25c[CONSTRUCTOR_INVOCATION]{AllConstructors25c(), Lp6930.AllConstructors25c;, ()V, AllConstructors25c, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}",
			requestor.getResults());
	} finally {
		deleteProject("P");
		
		JavaCore.setOptions(oldOptions);
	}
}
public void testBug6930_26() throws Exception {
	try {
		IJavaProject p = createJavaProject("P", new String[] {"src"}, new String[]{"JCL_LIB"}, "bin");
		
		refresh(p);
		
		waitUntilIndexesReady();
		
		this.workingCopies = new ICompilationUnit[2];
		this.workingCopies[0] = getWorkingCopy(
				"/P/src/test/Test.java",
				"package test;\n"+
				"public class Test {\n" +
				"  void foo(p6930.AllConstructors26a var) {\n" +
				"    var.new AllConstructors\n" +
				"  }\n" +
				"}");
		
		this.workingCopies[1] = getWorkingCopy(
				"/P/src/p6930/AllConstructors26a.java",
				"package p6930;"+
				"public class AllConstructors26a {\n" +
				"	public class AllConstructors26b {\n" +
				"	  public AllConstructors26b(int i) {}\n" +
				"	}\n" +
				"}");

		// do completion
		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
		requestor.setAllowsLongComputationProposals(true);

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
	    
	    assertResults(
			"AllConstructors26b[CONSTRUCTOR_INVOCATION]{AllConstructors26b(), Lp6930.AllConstructors26a$AllConstructors26b;, (I)V, AllConstructors26b, (i), "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}",
			requestor.getResults());
	} finally {
		deleteProject("P");
	}
}
public void testBug6930_27() throws Exception {
	try {
		IJavaProject p = createJavaProject("P", new String[] {"src"}, new String[]{"JCL_LIB"}, "bin");
		
		refresh(p);
		
		waitUntilIndexesReady();
		
		this.workingCopies = new ICompilationUnit[2];
		this.workingCopies[0] = getWorkingCopy(
				"/P/src/test/Test.java",
				"package test;\n"+
				"public class Test {\n" +
				"  void foo() {\n" +
				"    new p6930.AllConstructors27a.AllConstructors\n" +
				"  }\n" +
				"}");
		
		this.workingCopies[1] = getWorkingCopy(
				"/P/src/p6930/AllConstructors27a.java",
				"package p6930;"+
				"public class AllConstructors27a {\n" +
				"	public static class AllConstructors27b {\n" +
				"	  public AllConstructors27b(int i) {}\n" +
				"	}\n" +
				"}");

		// do completion
		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
		requestor.setAllowsLongComputationProposals(true);

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
	    
	    assertResults(
			"AllConstructors27b[CONSTRUCTOR_INVOCATION]{AllConstructors27b(), Lp6930.AllConstructors27a$AllConstructors27b;, (I)V, AllConstructors27b, (i), "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}",
			requestor.getResults());
	} finally {
		deleteProject("P");
	}
}
public void testBug6930_28() throws Exception {
	try {
		IJavaProject p = createJavaProject("P", new String[] {"src"}, new String[]{"JCL_LIB"}, "bin");
		
		refresh(p);
		
		waitUntilIndexesReady();
		
		this.workingCopies = new ICompilationUnit[3];
		this.workingCopies[0] = getWorkingCopy(
				"/P/src/p6930/Test.java",
				"package p6930;\n"+
				"class AllConstructors28a {\n" +
				"	public AllConstructors28a(int i) {}\n" +
				"}\n" +
				"public class Test {\n" +
				"  void foo() {\n" +
				"    new p6930.AllConstructors\n" +
				"  }\n" +
				"}");
		
		this.workingCopies[1] = getWorkingCopy(
				"/P/src/p6930/AllConstructors28b.java",
				"package p6930;"+
				"public class AllConstructors28b {\n" +
				"	public AllConstructors28b(int i) {}\n" +
				"}");
		
		this.workingCopies[2] = getWorkingCopy(
				"/P/src/p6930b/AllConstructors28c.java",
				"package p6930b;"+
				"public class AllConstructors28c {\n" +
				"	public AllConstructors28c(int i) {}\n" +
				"}");

		// do completion
		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);
		requestor.setAllowsLongComputationProposals(true);

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
	    
	    assertResults(
			"AllConstructors28a[CONSTRUCTOR_INVOCATION]{AllConstructors28a(), Lp6930.AllConstructors28a;, (I)V, AllConstructors28a, (i), "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors28b[CONSTRUCTOR_INVOCATION]{AllConstructors28b(), Lp6930.AllConstructors28b;, (I)V, AllConstructors28b, (i), "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}",
			requestor.getResults());
	} finally {
		deleteProject("P");
	}
}
public void testBug79288() throws Exception {
	try {
		// create variable




	);
}

public void testBug6930_AllConstructorDeclarations01() throws Exception {
	this.workingCopies = new ICompilationUnit[2];
	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/p6930/AllConstructorDeclarations01.java",
		"package p6930;\n" +
		"public class AllConstructorDeclarations01 {\n" +
		"  public AllConstructorDeclarations01() {}\n" +
		"  public AllConstructorDeclarations01(Object o) {}\n" +
		"  public AllConstructorDeclarations01(Object o, String s) {}\n" +
		"}\n"
	);
	
	this.workingCopies[1] = getWorkingCopy("/JavaSearchBugs/src/p6930/AllConstructorDeclarations01b.java",
		"package p6930;\n" +
		"public class AllConstructorDeclarations01b {\n" +
		"}\n"
	);
	
	ConstructorDeclarationsCollector requestor = new ConstructorDeclarationsCollector();
	searchAllConstructorDeclarations("AllConstructorDeclarations", SearchPattern.R_PREFIX_MATCH, requestor);
	assertSearchResults(
		"p6930.AllConstructorDeclarations01#AllConstructorDeclarations01()\n" + 
		"p6930.AllConstructorDeclarations01#AllConstructorDeclarations01(Object o)\n" + 
		"p6930.AllConstructorDeclarations01#AllConstructorDeclarations01(Object o,String s)\n" + 
		"p6930.AllConstructorDeclarations01b#AllConstructorDeclarations01b()*",
		requestor
	);
}

public void testBug6930_AllConstructorDeclarations02() throws Exception {
	try {
		IJavaProject p = createJavaProject("P", new String[] {}, new String[] {"/P/lib6930.jar"}, "");
		
		createJar(new String[] {
			"p6930/AllConstructorDeclarations02.java",
			"package p6930;\n" +
			"public class AllConstructorDeclarations02 {\n" +
			"  public AllConstructorDeclarations02() {}\n" +
			"  public AllConstructorDeclarations02(Object o) {}\n" +
			"  public AllConstructorDeclarations02(Object o, String s) {}\n" +
			"}",
			"p6930/AllConstructorDeclarations02b.java",
			"package p6930;\n" +
			"public class AllConstructorDeclarations02b {\n" +
			"}"
		}, p.getProject().getLocation().append("lib6930.jar").toOSString());
		refresh(p);
		
		ConstructorDeclarationsCollector requestor = new ConstructorDeclarationsCollector();
		searchAllConstructorDeclarations("AllConstructorDeclarations", SearchPattern.R_PREFIX_MATCH, requestor);
		assertSearchResults(
			"p6930.AllConstructorDeclarations02#AllConstructorDeclarations02()\n" + 
			"p6930.AllConstructorDeclarations02#AllConstructorDeclarations02(java.lang.Object o)\n" + 
			"p6930.AllConstructorDeclarations02#AllConstructorDeclarations02(java.lang.Object o,java.lang.String s)\n" + 
			"p6930.AllConstructorDeclarations02b#AllConstructorDeclarations02b()",
			requestor
		);
	} finally {
		deleteProject("P");
	}
}

public void testBug6930_AllConstructorDeclarations03() throws Exception {
	try {
		IJavaProject p = createJavaProject("P", new String[] {"src"}, new String[] {}, "bin");
		
		createFolder("/P/src/p6930");
		
		createFile(
				"/P/src/p6930/AllConstructorDeclarations03.java",
				"package p6930;\n" +
				"public class AllConstructorDeclarations03 {\n" +
				"  public AllConstructorDeclarations03() {}\n" +
				"  public AllConstructorDeclarations03(Object o) {}\n" +
				"  public AllConstructorDeclarations03(Object o, String s) {}\n" +
				"}");
		
		createFile(
				"/P/src/p6930/AllConstructorDeclarations03b.java",
				"package p6930;\n" +
				"public class AllConstructorDeclarations03b {\n" +
				"}");
		refresh(p);
		
		ConstructorDeclarationsCollector requestor = new ConstructorDeclarationsCollector();
		searchAllConstructorDeclarations("AllConstructorDeclarations", SearchPattern.R_PREFIX_MATCH, requestor);
		assertSearchResults(
			"p6930.AllConstructorDeclarations03#AllConstructorDeclarations03()\n" + 
			"p6930.AllConstructorDeclarations03#AllConstructorDeclarations03(Object o)\n" + 
			"p6930.AllConstructorDeclarations03#AllConstructorDeclarations03(Object o,String s)\n" + 
			"p6930.AllConstructorDeclarations03b#AllConstructorDeclarations03b()*",
			requestor
		);
	} finally {
		deleteProject("P");
	}
}

public void testBug6930_AllConstructorDeclarations04() throws Exception {
	try {
		IJavaProject p = createJavaProject("P", new String[] {}, new String[] {"/P/lib6930.jar"}, "","1.5");
		
		createJar(
			new String[] {
				"p6930/AllConstructorDeclarations04.java",
				"package p6930;\n" +
				"public class AllConstructorDeclarations04 {\n" +
				"  public AllConstructorDeclarations04(java.util.Collection<Object> c) {}\n" +
				"}"
			},
			p.getProject().getLocation().append("lib6930.jar").toOSString(),
			new String[]{getExternalJCLPathString("1.5")},
			"1.5");
		refresh(p);
		
		ConstructorDeclarationsCollector requestor = new ConstructorDeclarationsCollector();
		searchAllConstructorDeclarations("AllConstructorDeclarations", SearchPattern.R_PREFIX_MATCH, requestor);
		assertSearchResults(
			"p6930.AllConstructorDeclarations04#AllConstructorDeclarations04(java.util.Collection<java.lang.Object> c)",
			requestor
		);
	} finally {
		deleteProject("P");
	}
}

public void testBug6930_AllConstructorDeclarations05() throws Exception {
	try {
		IJavaProject p = createJavaProject("P", new String[] {}, new String[] {"/P/lib6930.jar"}, "");
		
		createJar(new String[] {
			"p6930/AllConstructorDeclarations05.java",
			"package p6930;\n" +
			"public class AllConstructorDeclarations05 {\n" +
			"  public class AllConstructorDeclarations05b {\n" +
			"    public AllConstructorDeclarations05b(Object o) {}\n" +
			"  }\n" +
			"}"
		}, p.getProject().getLocation().append("lib6930.jar").toOSString());
		refresh(p);
		
		ConstructorDeclarationsCollector requestor = new ConstructorDeclarationsCollector();
		searchAllConstructorDeclarations("AllConstructorDeclarations", SearchPattern.R_PREFIX_MATCH, requestor);
		assertSearchResults(
			"p6930.AllConstructorDeclarations05#AllConstructorDeclarations05()",
			requestor
		);
	} finally {
		deleteProject("P");
	}
}

/**
 * @bug 70827: [Search] wrong reference match to private method of supertype
 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=70827"

		deleteProject("P");
	}
}

}




		this.shortContext = shortContext;
		this.showMissingTypes = showMissingTypes;
		this.showModifiers = showModifiers;

	}
	public void acceptContext(CompletionContext cc) {
		this.context = cc;

	}

	public void allowAllRequiredProposals() {
		for (int i = CompletionProposal.ANONYMOUS_CLASS_DECLARATION; i <= CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION; i++) {
			for (int j = CompletionProposal.ANONYMOUS_CLASS_DECLARATION; j <= CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION; j++) {
				setAllowsRequiredProposals(i, j, true);
			}
		}

			case CompletionProposal.TYPE_IMPORT :
				buffer.append("TYPE_IMPORT"); //$NON-NLS-1$
				break;
			case CompletionProposal.CONSTRUCTOR_INVOCATION :
				buffer.append("CONSTRUCTOR_INVOCATION"); //$NON-NLS-1$
				break;
			case CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION :
				buffer.append("ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION"); //$NON-NLS-1$
				break;
			default :
				buffer.append("PROPOSAL"); //$NON-NLS-1$
				break;

	protected String getElementName(CompletionProposal proposal) {
		switch(proposal.getKind()) {
			case CompletionProposal.ANONYMOUS_CLASS_DECLARATION :
			case CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION :
				return new String(Signature.getSignatureSimpleName(proposal.getDeclarationSignature()));
			case CompletionProposal.TYPE_REF :
			case CompletionProposal.TYPE_IMPORT :

			case CompletionProposal.JAVADOC_VALUE_REF :
			case CompletionProposal.FIELD_IMPORT :
			case CompletionProposal.METHOD_IMPORT :
			case CompletionProposal.CONSTRUCTOR_INVOCATION :
			
				return new String(proposal.getName());
			case CompletionProposal.PACKAGE_REF:
				return new String(proposal.getDeclarationSignature());

Lines 17-32 Link Here

(-)src/org/eclipse/jdt/core/tests/model/AbstractJavaSearchTests.java (+100 lines)
17	import java.util.Collections;	17	import java.util.Collections;
18	import java.util.Comparator;	18	import java.util.Comparator;
19	import java.util.List;	19	import java.util.List;
		20	import java.util.Vector;
20		21
21	import org.eclipse.core.resources.*;	22	import org.eclipse.core.resources.*;
22	import org.eclipse.core.runtime.*;	23	import org.eclipse.core.runtime.*;
23	import org.eclipse.jdt.core.*;	24	import org.eclipse.jdt.core.*;
24	import org.eclipse.jdt.core.compiler.CharOperation;	25	import org.eclipse.jdt.core.compiler.CharOperation;
25	import org.eclipse.jdt.core.search.*;	26	import org.eclipse.jdt.core.search.*;
		27	import org.eclipse.jdt.internal.compiler.ExtraFlags;
		28	import org.eclipse.jdt.internal.compiler.env.AccessRestriction;
26	import org.eclipse.jdt.internal.compiler.problem.AbortCompilationUnit;	29	import org.eclipse.jdt.internal.compiler.problem.AbortCompilationUnit;
27	import org.eclipse.jdt.internal.core.Member;	30	import org.eclipse.jdt.internal.core.Member;
28	import org.eclipse.jdt.internal.core.PackageFragment;	31	import org.eclipse.jdt.internal.core.PackageFragment;
29	import org.eclipse.jdt.internal.core.SourceRefElement;	32	import org.eclipse.jdt.internal.core.SourceRefElement;
		33	import org.eclipse.jdt.internal.core.search.BasicSearchEngine;
		34	import org.eclipse.jdt.internal.core.search.IRestrictedAccessConstructorRequestor;
30	import org.eclipse.jdt.internal.core.search.matching.PatternLocator;	35	import org.eclipse.jdt.internal.core.search.matching.PatternLocator;
31		36
32	/**	37	/**
Lines 60-65 Link Here
60	static protected final int SHOW_MATCH_KIND = 0x0200;	65	static protected final int SHOW_MATCH_KIND = 0x0200;
61	static protected final int SHOW_JAR_FILE = 0x0400;	66	static protected final int SHOW_JAR_FILE = 0x0400;
62		67
		68	public static class ConstructorDeclarationsCollector implements IRestrictedAccessConstructorRequestor {
		69	Vector results = new Vector();
		70
		71	public void acceptConstructor(
		72	int modifiers,
		73	char[] simpleTypeName,
		74	int parameterCount,
		75	char[] signature,
		76	char[][] parameterTypes,
		77	char[][] parameterNames,
		78	int typeModifiers,
		79	char[] packageName,
		80	int extraFlags,
		81	String path,
		82	AccessRestriction access) {
		83	StringBuffer buffer = new StringBuffer();
		84
		85	boolean isMemberType = (extraFlags & ExtraFlags.IsMemberType) != 0;
		86
		87	buffer.append(packageName == null ? CharOperation.NO_CHAR : packageName);
		88	if (isMemberType) {
		89	buffer.append('.');
		90	buffer.append('?'); // enclosing type names are not stored in the indexes
		91	buffer.append('?');
		92	buffer.append('?');
		93	}
		94	buffer.append('.');
		95	buffer.append(simpleTypeName);
		96	buffer.append('#');
		97	buffer.append(simpleTypeName);
		98	buffer.append('(');
		99
		100	parameterTypes = signature == null ? parameterTypes : Signature.getParameterTypes(signature);
		101
		102	for (int i = 0; i < parameterCount; i++) {
		103	if (i != 0) buffer.append(',');
		104
		105	if (parameterTypes != null) {
		106	char[] parameterType;
		107	if (signature != null) {
		108	parameterType = Signature.toCharArray(parameterTypes[i]);
		109	CharOperation.replace(parameterType, '/', '.');
		110	} else {
		111	parameterType = parameterTypes[i];
		112	}
		113	buffer.append(parameterType);
		114	} else {
		115	buffer.append('?'); // parameter type names are not stored in the indexes
		116	buffer.append('?');
		117	buffer.append('?');
		118	}
		119	buffer.append(' ');
		120	if (parameterNames != null) {
		121	buffer.append(parameterNames[i]);
		122	} else {
		123	buffer.append("arg"+i);
		124	}
		125	}
		126	buffer.append(')');
		127
		128	if (parameterCount < 0) {
		129	buffer.append('*');
		130	}
		131
132	this.results.addElement(buffer.toString());
133	}
134
135	public String toString(){
136	int length = this.results.size();
137	String[] strings = new String[length];
138	this.results.toArray(strings);
139	org.eclipse.jdt.internal.core.util.Util.sort(strings);
140	StringBuffer buffer = new StringBuffer(100);
141	for (int i = 0; i < length; i++){
142	buffer.append(strings[i]);
143	if (i != length-1) {
144	buffer.append('\n');
145	}
146	}
147	return buffer.toString();
148	}
149	public int size() {
150	return this.results.size();
151	}
152	}
63	/**	153	/**
64	* Collects results as a string.	154	* Collects results as a string.
65	*/	155	*/
Lines 767-772 Link Here
767	protected void search(String patternString, int searchFor, int limitTo, int matchRule) throws CoreException {	857	protected void search(String patternString, int searchFor, int limitTo, int matchRule) throws CoreException {
768	search(patternString, searchFor, limitTo, matchRule, getJavaSearchScope(), this.resultCollector);	858	search(patternString, searchFor, limitTo, matchRule, getJavaSearchScope(), this.resultCollector);
769	}	859	}
		860	protected void searchAllConstructorDeclarations(String pattern, int matchRule, IRestrictedAccessConstructorRequestor requestor) throws JavaModelException {
		861	new BasicSearchEngine(this.workingCopies).searchAllConstructorDeclarations(
		862	null,
		863	pattern.toCharArray(),
		864	matchRule,
		865	SearchEngine.createWorkspaceScope(),
		866	requestor,
		867	IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		868	null);
		869	}
770	protected void searchAllTypeNames(String pattern, int matchRule, TypeNameRequestor requestor) throws JavaModelException {	870	protected void searchAllTypeNames(String pattern, int matchRule, TypeNameRequestor requestor) throws JavaModelException {
771	new SearchEngine(this.workingCopies).searchAllTypeNames(	871	new SearchEngine(this.workingCopies).searchAllTypeNames(
772	null,	872	null,

Lines 1128-1133 Link Here

(-)src/org/eclipse/jdt/core/tests/model/AbstractJavaModelTests.java (+4 lines)
1128	protected void createJar(String[] javaPathsAndContents, String jarPath) throws IOException {	1128	protected void createJar(String[] javaPathsAndContents, String jarPath) throws IOException {
1129	org.eclipse.jdt.core.tests.util.Util.createJar(javaPathsAndContents, jarPath, "1.4");	1129	org.eclipse.jdt.core.tests.util.Util.createJar(javaPathsAndContents, jarPath, "1.4");
1130	}	1130	}
		1131
		1132	protected void createJar(String[] javaPathsAndContents, String jarPath, String[] classpath, String compliance) throws IOException {
		1133	org.eclipse.jdt.core.tests.util.Util.createJar(javaPathsAndContents, null,jarPath, classpath, compliance);
		1134	}
1131		1135
1132	/*	1136	/*
1133	}	1137	}

Return to bug 6930

Lines 13-18 Link Here

(-)model/org/eclipse/jdt/internal/compiler/SourceElementNotifier.java (-7 / +16 lines)
13	import java.util.ArrayList;	13	import java.util.ArrayList;
14	import java.util.Map;	14	import java.util.Map;
15		15
		16	import org.eclipse.jdt.core.Signature;
16	import org.eclipse.jdt.core.compiler.CharOperation;	17	import org.eclipse.jdt.core.compiler.CharOperation;
17	import org.eclipse.jdt.internal.compiler.ISourceElementRequestor.TypeParameterInfo;	18	import org.eclipse.jdt.internal.compiler.ISourceElementRequestor.TypeParameterInfo;
18	import org.eclipse.jdt.internal.compiler.ast.ASTNode;	19	import org.eclipse.jdt.internal.compiler.ast.ASTNode;
Lines 54-59 Link Here
54	* An ast visitor that visits local type declarations.	55	* An ast visitor that visits local type declarations.
55	*/	56	*/
56	public class LocalDeclarationVisitor extends ASTVisitor {	57	public class LocalDeclarationVisitor extends ASTVisitor {
		58	public ImportReference currentPackage;
57	ArrayList declaringTypes;	59	ArrayList declaringTypes;
58	public void pushDeclaringType(TypeDeclaration declaringType) {	60	public void pushDeclaringType(TypeDeclaration declaringType) {
59	if (this.declaringTypes == null) {	61	if (this.declaringTypes == null) {
Lines 71-81 Link Here
71	return (TypeDeclaration) this.declaringTypes.get(size-1);	73	return (TypeDeclaration) this.declaringTypes.get(size-1);
72	}	74	}
73	public boolean visit(TypeDeclaration typeDeclaration, BlockScope scope) {	75	public boolean visit(TypeDeclaration typeDeclaration, BlockScope scope) {
74	notifySourceElementRequestor(typeDeclaration, true, peekDeclaringType());	76	notifySourceElementRequestor(typeDeclaration, true, peekDeclaringType(), this.currentPackage);
75	return false; // don't visit members as this was done during notifySourceElementRequestor(...)	77	return false; // don't visit members as this was done during notifySourceElementRequestor(...)
76	}	78	}
77	public boolean visit(TypeDeclaration typeDeclaration, ClassScope scope) {	79	public boolean visit(TypeDeclaration typeDeclaration, ClassScope scope) {
78	notifySourceElementRequestor(typeDeclaration, true, peekDeclaringType());	80	notifySourceElementRequestor(typeDeclaration, true, peekDeclaringType(), this.currentPackage);
79	return false; // don't visit members as this was done during notifySourceElementRequestor(...)	81	return false; // don't visit members as this was done during notifySourceElementRequestor(...)
80	}	82	}
81	}	83	}
Lines 215-221 Link Here
215	/*	217	/*
216	* Update the bodyStart of the corresponding parse node	218	* Update the bodyStart of the corresponding parse node
217	*/	219	*/
218	protected void notifySourceElementRequestor(AbstractMethodDeclaration methodDeclaration) {	220	protected void notifySourceElementRequestor(AbstractMethodDeclaration methodDeclaration, TypeDeclaration declaringType, ImportReference currentPackage) {
219		221
220	// range check	222	// range check
221	boolean isInRange =	223	boolean isInRange =
Lines 288-293 Link Here
288	methodInfo.typeParameters = getTypeParameterInfos(methodDeclaration.typeParameters());	290	methodInfo.typeParameters = getTypeParameterInfos(methodDeclaration.typeParameters());
289	methodInfo.categories = (char[][]) this.nodesToCategories.get(methodDeclaration);	291	methodInfo.categories = (char[][]) this.nodesToCategories.get(methodDeclaration);
290	methodInfo.annotations = methodDeclaration.annotations;	292	methodInfo.annotations = methodDeclaration.annotations;
		293	methodInfo.declaringPackageName = currentPackage == null ? CharOperation.NO_CHAR : CharOperation.concatWith(currentPackage.tokens, '.');
		294	methodInfo.declaringTypeModifiers = declaringType.modifiers;
		295	methodInfo.extraFlags = ExtraFlags.getExtraFlags(declaringType);
291	methodInfo.node = methodDeclaration;	296	methodInfo.node = methodDeclaration;
292	this.requestor.enterConstructor(methodInfo);	297	this.requestor.enterConstructor(methodInfo);
293	}	298	}
Lines 394-399 Link Here
394	this.requestor.enterCompilationUnit();	399	this.requestor.enterCompilationUnit();
395	}	400	}
396	ImportReference currentPackage = parsedUnit.currentPackage;	401	ImportReference currentPackage = parsedUnit.currentPackage;
		402	if (this.localDeclarationVisitor != null) {
		403	this.localDeclarationVisitor.currentPackage = currentPackage;
		404	}
397	ImportReference[] imports = parsedUnit.imports;	405	ImportReference[] imports = parsedUnit.imports;
398	TypeDeclaration[] types = parsedUnit.types;	406	TypeDeclaration[] types = parsedUnit.types;
399	length =	407	length =
Lines 429-435 Link Here
429	notifySourceElementRequestor(importRef, false);	437	notifySourceElementRequestor(importRef, false);
430	}	438	}
431	} else { // instanceof TypeDeclaration	439	} else { // instanceof TypeDeclaration
432	notifySourceElementRequestor((TypeDeclaration)node, true, null);	440	notifySourceElementRequestor((TypeDeclaration)node, true, null, currentPackage);
433	}	441	}
434	}	442	}
435	}	443	}
Lines 544-550 Link Here
544	importReference.modifiers);	552	importReference.modifiers);
545	}	553	}
546	}	554	}
547	protected void notifySourceElementRequestor(TypeDeclaration typeDeclaration, boolean notifyTypePresence, TypeDeclaration declaringType) {	555	protected void notifySourceElementRequestor(TypeDeclaration typeDeclaration, boolean notifyTypePresence, TypeDeclaration declaringType, ImportReference currentPackage) {
548		556
549	if (CharOperation.equals(TypeConstants.PACKAGE_INFO_NAME, typeDeclaration.name)) return;	557	if (CharOperation.equals(TypeConstants.PACKAGE_INFO_NAME, typeDeclaration.name)) return;
550		558
Lines 600-605 Link Here
600	typeInfo.secondary = typeDeclaration.isSecondary();	608	typeInfo.secondary = typeDeclaration.isSecondary();
601	typeInfo.anonymousMember = typeDeclaration.allocation != null && typeDeclaration.allocation.enclosingInstance != null;	609	typeInfo.anonymousMember = typeDeclaration.allocation != null && typeDeclaration.allocation.enclosingInstance != null;
602	typeInfo.annotations = typeDeclaration.annotations;	610	typeInfo.annotations = typeDeclaration.annotations;
		611	typeInfo.extraFlags = ExtraFlags.getExtraFlags(typeDeclaration);
603	typeInfo.node = typeDeclaration;	612	typeInfo.node = typeDeclaration;
604	this.requestor.enterType(typeInfo);	613	this.requestor.enterType(typeInfo);
605	switch (kind) {	614	switch (kind) {
Lines 663-673 Link Here
663	break;	672	break;
664	case 1 :	673	case 1 :
665	methodIndex++;	674	methodIndex++;
666	notifySourceElementRequestor(nextMethodDeclaration);	675	notifySourceElementRequestor(nextMethodDeclaration, typeDeclaration, currentPackage);
667	break;	676	break;
668	case 2 :	677	case 2 :
669	memberTypeIndex++;	678	memberTypeIndex++;
670	notifySourceElementRequestor(nextMemberDeclaration, true, null);	679	notifySourceElementRequestor(nextMemberDeclaration, true, null, currentPackage);
671	}	680	}
672	}	681	}
673	if (notifyTypePresence){	682	if (notifyTypePresence){

Lines 23-34 Link Here

(-)search/org/eclipse/jdt/internal/core/search/indexing/IIndexConstants.java (+3 lines)
23	char[] TYPE_DECL = "typeDecl".toCharArray(); //$NON-NLS-1$	23	char[] TYPE_DECL = "typeDecl".toCharArray(); //$NON-NLS-1$
24	char[] METHOD_DECL= "methodDecl".toCharArray(); //$NON-NLS-1$	24	char[] METHOD_DECL= "methodDecl".toCharArray(); //$NON-NLS-1$
25	char[] CONSTRUCTOR_DECL= "constructorDecl".toCharArray(); //$NON-NLS-1$	25	char[] CONSTRUCTOR_DECL= "constructorDecl".toCharArray(); //$NON-NLS-1$
		26	char[] EXT_CONSTRUCTOR_DECL= "extConstructorDecl".toCharArray(); //$NON-NLS-1$
26	char[] FIELD_DECL= "fieldDecl".toCharArray(); //$NON-NLS-1$	27	char[] FIELD_DECL= "fieldDecl".toCharArray(); //$NON-NLS-1$
27	char[] OBJECT = "Object".toCharArray(); //$NON-NLS-1$	28	char[] OBJECT = "Object".toCharArray(); //$NON-NLS-1$
28	char[][] COUNTS=	29	char[][] COUNTS=
29	new char[][] { new char[] {'/', '0'}, new char[] {'/', '1'}, new char[] {'/', '2'}, new char[] {'/', '3'}, new char[] {'/', '4'},	30	new char[][] { new char[] {'/', '0'}, new char[] {'/', '1'}, new char[] {'/', '2'}, new char[] {'/', '3'}, new char[] {'/', '4'},
30	new char[] {'/', '5'}, new char[] {'/', '6'}, new char[] {'/', '7'}, new char[] {'/', '8'}, new char[] {'/', '9'}	31	new char[] {'/', '5'}, new char[] {'/', '6'}, new char[] {'/', '7'}, new char[] {'/', '8'}, new char[] {'/', '9'}
31	};	32	};
		33	char[] DEFAULT_CONSTRUCTOR = new char[]{'/', '#'};
32	char CLASS_SUFFIX = 'C';	34	char CLASS_SUFFIX = 'C';
33	char INTERFACE_SUFFIX = 'I';	35	char INTERFACE_SUFFIX = 'I';
34	char ENUM_SUFFIX = 'E';	36	char ENUM_SUFFIX = 'E';
Lines 38-43 Link Here
38	char CLASS_AND_INTERFACE_SUFFIX = IJavaSearchConstants.CLASS_AND_INTERFACE;	40	char CLASS_AND_INTERFACE_SUFFIX = IJavaSearchConstants.CLASS_AND_INTERFACE;
39	char INTERFACE_AND_ANNOTATION_SUFFIX = IJavaSearchConstants.INTERFACE_AND_ANNOTATION;	41	char INTERFACE_AND_ANNOTATION_SUFFIX = IJavaSearchConstants.INTERFACE_AND_ANNOTATION;
40	char SEPARATOR= '/';	42	char SEPARATOR= '/';
		43	char PARAMETER_SEPARATOR= ',';
41	char SECONDARY_SUFFIX = 'S';	44	char SECONDARY_SUFFIX = 'S';
42		45
43	char[] ONE_STAR = new char[] {'*'};	46	char[] ONE_STAR = new char[] {'*'};

Lines 71-80 Link Here

(-)search/org/eclipse/jdt/internal/core/search/indexing/AbstractIndexer.java (-4 / +31 lines)
71	typeName = CharOperation.subarray(typeName, 0, genericStart);	71	typeName = CharOperation.subarray(typeName, 0, genericStart);
72	return typeName;	72	return typeName;
73	}	73	}
74	public void addConstructorDeclaration(char[] typeName, char[][] parameterTypes, char[][] exceptionTypes) {	74	public void addConstructorDeclaration(
75	int argCount = parameterTypes == null ? 0 : parameterTypes.length;	75	char[] typeName,
76	addIndexEntry(CONSTRUCTOR_DECL, ConstructorPattern.createIndexKey(CharOperation.lastSegment(typeName,'.'), argCount));	76	int argCount,
77		77	char[] signature,
		78	char[][] parameterTypes,
		79	char[][] parameterNames,
		80	int modifiers,
		81	char[] packageName,
		82	int typeModifiers,
		83	char[][] exceptionTypes,
		84	int extraFlags) {
		85	addIndexEntry(
		86	CONSTRUCTOR_DECL,
		87	ConstructorPattern.createDeclarationIndexKey(
		88	typeName,
		89	argCount,
		90	signature,
		91	parameterTypes,
		92	parameterNames,
		93	modifiers,
		94	packageName,
		95	typeModifiers,
		96	extraFlags));
		97
78	if (parameterTypes != null) {	98	if (parameterTypes != null) {
79	for (int i = 0; i < argCount; i++)	99	for (int i = 0; i < argCount; i++)
80	addTypeReference(parameterTypes[i]);	100	addTypeReference(parameterTypes[i]);
Lines 91-96 Link Here
91	if (innermostTypeName != simpleTypeName)	111	if (innermostTypeName != simpleTypeName)
92	addIndexEntry(CONSTRUCTOR_REF, ConstructorPattern.createIndexKey(innermostTypeName, argCount));	112	addIndexEntry(CONSTRUCTOR_REF, ConstructorPattern.createIndexKey(innermostTypeName, argCount));
93	}	113	}
		114	public void addDefaultConstructorDeclaration(
		115	char[] typeName,
		116	char[] packageName,
		117	int typeModifiers,
		118	int extraFlags) {
		119	addIndexEntry(CONSTRUCTOR_DECL, ConstructorPattern.createDefaultDeclarationIndexKey(CharOperation.lastSegment(typeName,'.'), packageName, typeModifiers, extraFlags));
		120	}
94	public void addEnumDeclaration(int modifiers, char[] packageName, char[] name, char[][] enclosingTypeNames, char[] superclass, char[][] superinterfaces, boolean secondary) {	121	public void addEnumDeclaration(int modifiers, char[] packageName, char[] name, char[][] enclosingTypeNames, char[] superclass, char[][] superinterfaces, boolean secondary) {
95	addTypeDeclaration(modifiers, packageName, name, enclosingTypeNames, secondary);	122	addTypeDeclaration(modifiers, packageName, name, enclosingTypeNames, secondary);
96		123

Lines 85-90 Link Here

(-)codeassist/org/eclipse/jdt/internal/codeassist/impl/AssistParser.java (+15 lines)
85	setStatementsRecovery(false);	85	setStatementsRecovery(false);
86	}	86	}
87	public abstract char[] assistIdentifier();	87	public abstract char[] assistIdentifier();
		88
		89	/**
		90	* The parser become a simple parser which behave like a Parser
		91	* @return the state of the assist parser to be able to restore the assist parser state
		92	*/
		93	public Object becomeSimpleParser() {
		94	return null;
		95	}
		96	/**
		97	* Restore the parser as an assist parser
		98	* @param parserState
		99	*/
		100	public void restoreAssistParser(Object parserState) {
		101	//Do nothing
		102	}
88	public int bodyEnd(AbstractMethodDeclaration method){	103	public int bodyEnd(AbstractMethodDeclaration method){
89	return method.bodyEnd;	104	return method.bodyEnd;
90	}	105	}

Lines 462-468 Link Here

(-)codeassist/org/eclipse/jdt/internal/codeassist/MissingTypesGuesser.java (-1 / +14 lines)
462	isQualified ? CharOperation.concatWith(missingTypeName, '.') : null;	462	isQualified ? CharOperation.concatWith(missingTypeName, '.') : null;
463	final ArrayList results = new ArrayList();	463	final ArrayList results = new ArrayList();
464	ISearchRequestor storage = new ISearchRequestor() {	464	ISearchRequestor storage = new ISearchRequestor() {
465		465	public void acceptConstructor(
		466	int modifiers,
		467	char[] simpleTypeName,
		468	int parameterCount,
		469	char[] signature,
		470	char[][] parameterTypes,
		471	char[][] parameterNames,
		472	int typeModifiers,
		473	char[] packageName,
		474	int extraFlags,
		475	String path,
		476	AccessRestriction access) {
		477	// constructors aren't searched
		478	}
466	public void acceptPackage(char[] packageName) {	479	public void acceptPackage(char[] packageName) {
467	// package aren't searched	480	// package aren't searched
468	}	481	}

Lines 33-47 Link Here

(-)codeassist/org/eclipse/jdt/internal/codeassist/InternalCompletionProposal.java (-41 / +12 lines)
33	public class InternalCompletionProposal extends CompletionProposal {	33	public class InternalCompletionProposal extends CompletionProposal {
34	private static Object NO_ATTACHED_SOURCE = new Object();	34	private static Object NO_ATTACHED_SOURCE = new Object();
35		35
36	static final char[] ARG = "arg".toCharArray(); //$NON-NLS-1$	36
37	static final char[] ARG0 = "arg0".toCharArray(); //$NON-NLS-1$
38	static final char[] ARG1 = "arg1".toCharArray(); //$NON-NLS-1$
39	static final char[] ARG2 = "arg2".toCharArray(); //$NON-NLS-1$
40	static final char[] ARG3 = "arg3".toCharArray(); //$NON-NLS-1$
41	static final char[][] ARGS1 = new char[][]{ARG0};
42	static final char[][] ARGS2 = new char[][]{ARG0, ARG1};
43	static final char[][] ARGS3 = new char[][]{ARG0, ARG1, ARG2};
44	static final char[][] ARGS4 = new char[][]{ARG0, ARG1, ARG2, ARG3};
45		37
46	protected CompletionEngine completionEngine;	38	protected CompletionEngine completionEngine;
47	protected NameLookup nameLookup;	39	protected NameLookup nameLookup;
Lines 179-212 Link Here
179	* Indicates whether parameter names have been computed.	171	* Indicates whether parameter names have been computed.
180	*/	172	*/
181	private boolean parameterNamesComputed = false;	173	private boolean parameterNamesComputed = false;
182		174
183	protected char[][] createDefaultParameterNames(int length) {
184	char[][] parameters;
185	switch (length) {
186	case 0 :
187	parameters = new char[length][];
188	break;
189	case 1 :
190	parameters = ARGS1;
191	break;
192	case 2 :
193	parameters = ARGS2;
194	break;
195	case 3 :
196	parameters = ARGS3;
197	break;
198	case 4 :
199	parameters = ARGS4;
200	break;
201	default :
202	parameters = new char[length][];
203	for (int i = 0; i < length; i++) {
204	parameters[i] = CharOperation.concat(ARG, String.valueOf(i).toCharArray());
205	}
206	break;
207	}
208	return parameters;
209	}
210	protected char[][] findMethodParameterNames(char[] declaringTypePackageName, char[] declaringTypeName, char[] selector, char[][] paramTypeNames){	175	protected char[][] findMethodParameterNames(char[] declaringTypePackageName, char[] declaringTypeName, char[] selector, char[][] paramTypeNames){
211	if(paramTypeNames == null \|\| declaringTypeName == null) return null;	176	if(paramTypeNames == null \|\| declaringTypeName == null) return null;
212		177
Lines 257-263 Link Here
257		222
258	// default parameters name	223	// default parameters name
259	if(parameters == null) {	224	if(parameters == null) {
260	parameters = createDefaultParameterNames(length);	225	parameters = CompletionEngine.createDefaultParameterNames(length);
261	}	226	}
262		227
263	return parameters;	228	return parameters;
Lines 1312-1318 Link Here
1312	} catch(IllegalArgumentException e) {	1277	} catch(IllegalArgumentException e) {
1313	// protection for invalid signature	1278	// protection for invalid signature
1314	if(this.parameterTypeNames != null) {	1279	if(this.parameterTypeNames != null) {
1315	this.parameterNames = createDefaultParameterNames(this.parameterTypeNames.length);	1280	this.parameterNames = CompletionEngine.createDefaultParameterNames(this.parameterTypeNames.length);
1316	} else {	1281	} else {
1317	this.parameterNames = null;	1282	this.parameterNames = null;
1318	}	1283	}
Lines 1329-1335 Link Here
1329	} catch(IllegalArgumentException e) {	1294	} catch(IllegalArgumentException e) {
1330	// protection for invalid signature	1295	// protection for invalid signature
1331	if(this.parameterTypeNames != null) {	1296	if(this.parameterTypeNames != null) {
1332	this.parameterNames = createDefaultParameterNames(this.parameterTypeNames.length);	1297	this.parameterNames = CompletionEngine.createDefaultParameterNames(this.parameterTypeNames.length);
1333	} else {	1298	} else {
1334	this.parameterNames = null;	1299	this.parameterNames = null;
1335	}	1300	}
Lines 1345-1351 Link Here
1345	} catch(IllegalArgumentException e) {	1310	} catch(IllegalArgumentException e) {
1346	// protection for invalid signature	1311	// protection for invalid signature
1347	if(this.parameterTypeNames != null) {	1312	if(this.parameterTypeNames != null) {
1348	this.parameterNames = createDefaultParameterNames(this.parameterTypeNames.length);	1313	this.parameterNames = CompletionEngine.createDefaultParameterNames(this.parameterTypeNames.length);
1349	} else {	1314	} else {
1350	this.parameterNames = null;	1315	this.parameterNames = null;
1351	}	1316	}
Lines 1623-1628 Link Here
1623	case CompletionProposal.FIELD_REF_WITH_CASTED_RECEIVER :	1588	case CompletionProposal.FIELD_REF_WITH_CASTED_RECEIVER :
1624	buffer.append("FIELD_REF_WITH_CASTED_RECEIVER"); //$NON-NLS-1$	1589	buffer.append("FIELD_REF_WITH_CASTED_RECEIVER"); //$NON-NLS-1$
1625	break;	1590	break;
		1591	case CompletionProposal.CONSTRUCTOR_INVOCATION :
		1592	buffer.append("CONSTRUCTOR_INVOCATION"); //$NON-NLS-1$
		1593	break;
		1594	case CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION :
		1595	buffer.append("ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION"); //$NON-NLS-1$
		1596	break;
1626	default :	1597	default :
1627	buffer.append("PROPOSAL"); //$NON-NLS-1$	1598	buffer.append("PROPOSAL"); //$NON-NLS-1$
1628	break;	1599	break;

Lines 20-25 Link Here

(-)codeassist/org/eclipse/jdt/internal/codeassist/ISearchRequestor.java (+12 lines)
20	* to the raw name environment results before answering them to the UI.	20	* to the raw name environment results before answering them to the UI.
21	*/	21	*/
22	public interface ISearchRequestor {	22	public interface ISearchRequestor {
		23	public void acceptConstructor(
		24	int modifiers,
		25	char[] simpleTypeName,
		26	int parameterCount,
		27	char[] signature,
		28	char[][] parameterTypes,
		29	char[][] parameterNames,
		30	int typeModifiers,
		31	char[] packageName,
		32	int extraFlags,
		33	String path,
		34	AccessRestriction access);
23	/**	35	/**
24	* One result of the search consists of a new type.	36	* One result of the search consists of a new type.
25	*	37	*

Lines 269-274 Link Here

(-)codeassist/org/eclipse/jdt/internal/codeassist/SelectionEngine.java (+15 lines)
269	this.parser = new SelectionParser(problemReporter);	269	this.parser = new SelectionParser(problemReporter);
270	this.owner = owner;	270	this.owner = owner;
271	}	271	}
		272
		273	public void acceptConstructor(
		274	int modifiers,
		275	char[] simpleTypeName,
		276	int parameterCount,
		277	char[] signature,
		278	char[][] parameterTypes,
		279	char[][] parameterNames,
		280	int typeModifiers,
		281	char[] packageName,
		282	int extraFlags,
		283	String path,
		284	AccessRestriction access) {
		285	// constructors aren't searched
		286	}
272		287
273	public void acceptType(char[] packageName, char[] simpleTypeName, char[][] enclosingTypeNames, int modifiers, AccessRestriction accessRestriction) {	288	public void acceptType(char[] packageName, char[] simpleTypeName, char[][] enclosingTypeNames, int modifiers, AccessRestriction accessRestriction) {
274	char[] typeName = enclosingTypeNames == null ?	289	char[] typeName = enclosingTypeNames == null ?

Lines 182-192 Link Here

(-)codeassist/org/eclipse/jdt/internal/codeassist/CompletionElementNotifier.java (-4 / +4 lines)
182	return typeParameterBounds;	182	return typeParameterBounds;
183	}	183	}
184		184
185	protected void notifySourceElementRequestor(AbstractMethodDeclaration methodDeclaration) {	185	protected void notifySourceElementRequestor(AbstractMethodDeclaration methodDeclaration, TypeDeclaration declaringType, ImportReference currentPackage) {
186	if (methodDeclaration instanceof CompletionOnMethodReturnType) return;	186	if (methodDeclaration instanceof CompletionOnMethodReturnType) return;
187	if (methodDeclaration instanceof CompletionOnMethodTypeParameter) return;	187	if (methodDeclaration instanceof CompletionOnMethodTypeParameter) return;
188	if (methodDeclaration instanceof CompletionOnMethodName) return;	188	if (methodDeclaration instanceof CompletionOnMethodName) return;
189	super.notifySourceElementRequestor(methodDeclaration);	189	super.notifySourceElementRequestor(methodDeclaration, declaringType, currentPackage);
190	}	190	}
191		191
192	public void notifySourceElementRequestor(CompilationUnitDeclaration parsedUnit, int sourceStart, int sourceEnd, boolean reportReference, HashtableOfObjectToInt sourceEndsMap, Map nodesToCategoriesMap) {	192	public void notifySourceElementRequestor(CompilationUnitDeclaration parsedUnit, int sourceStart, int sourceEnd, boolean reportReference, HashtableOfObjectToInt sourceEndsMap, Map nodesToCategoriesMap) {
Lines 209-216 Link Here
209	super.notifySourceElementRequestor(importReference, isPackage);	209	super.notifySourceElementRequestor(importReference, isPackage);
210	}	210	}
211		211
212	protected void notifySourceElementRequestor(TypeDeclaration typeDeclaration, boolean notifyTypePresence, TypeDeclaration declaringType) {	212	protected void notifySourceElementRequestor(TypeDeclaration typeDeclaration, boolean notifyTypePresence, TypeDeclaration declaringType, ImportReference currentPackage) {
213	if (typeDeclaration instanceof CompletionOnAnnotationOfType) return;	213	if (typeDeclaration instanceof CompletionOnAnnotationOfType) return;
214	super.notifySourceElementRequestor(typeDeclaration, notifyTypePresence, declaringType);	214	super.notifySourceElementRequestor(typeDeclaration, notifyTypePresence, declaringType, currentPackage);
215	}	215	}
216	}	216	}

Lines 55-61 Link Here

(-)model/org/eclipse/jdt/core/CompletionProposal.java (-2 / +76 lines)
55	/**	55	/**
56	* Completion is a declaration of an anonymous class.	56	* Completion is a declaration of an anonymous class.
57	* This kind of completion might occur in a context like	57	* This kind of completion might occur in a context like
58	* <code>"new List^;"</code> and complete it to	58	* <code>"new List(^;"</code> and complete it to
59	* <code>"new List() {}"</code>.	59	* <code>"new List() {}"</code>.
60	* <p>	60	* <p>
61	* The following additional context information is available	61	* The following additional context information is available
Lines 792-797 Link Here
792	* @since 3.4	792	* @since 3.4
793	*/	793	*/
794	public static final int FIELD_REF_WITH_CASTED_RECEIVER = 25;	794	public static final int FIELD_REF_WITH_CASTED_RECEIVER = 25;
		795
		796	/**
		797	* Completion is a reference to a constructor.
		798	* This kind of completion might occur in a context like
		799	* <code>"new Lis"</code> and complete it to
		800	* <code>"new List();"</code>.
		801	* <p>
		802	* The following additional context information is available
		803	* for this kind of completion proposal at little extra cost:
		804	* <ul>
		805	* <li>{@link #getDeclarationSignature()} -
		806	* the type signature of the type that declares the constructor that is referenced
		807	* </li>
		808	* <li>{@link #getFlags()} -
		809	* the modifiers flags of the constructor that is referenced
		810	* </li>
		811	* <li>{@link #getName()} -
		812	* the simple name of the constructor that is referenced
		813	* </li>
		814	* <li>{@link #getSignature()} -
		815	* the method signature of the constructor that is referenced
		816	* </li>
		817	* </ul>
		818	* </p>
		819	* <p>
		820	* This kind of proposal could require a long computation, so they are computed only if
		821	* {@link CompletionRequestor#isAllowingLongComputationProposals()} return <code>true</code>.
		822	* </p>
		823	*
		824	* @see #getKind()
		825	* @see CompletionRequestor#isAllowingLongComputationProposals()
		826	*
		827	* @since 3.5
		828	*/
		829	public static final int CONSTRUCTOR_INVOCATION = 26;
		830
		831	/**
		832	* Completion is a reference of a constructor of an anonymous class.
		833	* This kind of completion might occur in a context like
		834	* <code>"new Lis^;"</code> and complete it to
		835	* <code>"new List() {}"</code>.
		836	* <p>
		837	* The following additional context information is available
		838	* for this kind of completion proposal at little extra cost:
		839	* <ul>
		840	* <li>{@link #getDeclarationSignature()} -
		841	* the type signature of the type being implemented or subclassed
		842	* </li>
		843	* <li>{@link #getDeclarationKey()} -
		844	* the type unique key of the type being implemented or subclassed
		845	* </li>
		846	* <li>{@link #getSignature()} -
		847	* the method signature of the constructor that is referenced
		848	* </li>
		849	* <li>{@link #getKey()} -
		850	* the method unique key of the constructor that is referenced
		851	* if the declaring type is not an interface
		852	* </li>
		853	* <li>{@link #getFlags()} -
		854	* the modifiers flags of the constructor that is referenced
		855	* </li>
		856	* </ul>
		857	* </p>
		858	* <p>
859	* This kind of proposal could require a long computation, so they are computed only if
860	* {@link CompletionRequestor#isAllowingLongComputationProposals()} return <code>true</code>.
861	* </p>
862	*
863	* @see #getKind()
864	* @see CompletionRequestor#isAllowingLongComputationProposals()
865	*
866	* @since 3.5
867	*/
868	public static final int ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION = 27;
795		869
796	/**	870	/**
797	* First valid completion kind.	871	* First valid completion kind.
Lines 805-811 Link Here
805	*	879	*
806	* @since 3.1	880	* @since 3.1
807	*/	881	*/
808	protected static final int LAST_KIND = FIELD_REF_WITH_CASTED_RECEIVER;	882	protected static final int LAST_KIND = ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION;
809		883
810	/**	884	/**
811	* Creates a basic completion proposal. All instance	885	* Creates a basic completion proposal. All instance

Lines 23-28 Link Here

(-)model/org/eclipse/jdt/internal/core/SearchableEnvironment.java (+146 lines)
23	import org.eclipse.jdt.internal.compiler.env.ISourceType;	23	import org.eclipse.jdt.internal.compiler.env.ISourceType;
24	import org.eclipse.jdt.internal.compiler.env.NameEnvironmentAnswer;	24	import org.eclipse.jdt.internal.compiler.env.NameEnvironmentAnswer;
25	import org.eclipse.jdt.internal.core.search.BasicSearchEngine;	25	import org.eclipse.jdt.internal.core.search.BasicSearchEngine;
		26	import org.eclipse.jdt.internal.core.search.IRestrictedAccessConstructorRequestor;
26	import org.eclipse.jdt.internal.core.search.IRestrictedAccessTypeRequestor;	27	import org.eclipse.jdt.internal.core.search.IRestrictedAccessTypeRequestor;
27		28
28	/**	29	/**
Lines 447-452 Link Here
447	convertSearchFilterToModelFilter(searchFor));	448	convertSearchFilterToModelFilter(searchFor));
448	}	449	}
449	}	450	}
		451
		452	/**
		453	* Must be used only by CompletionEngine.
		454	* The progress monitor is used to be able to cancel completion operations
		455	*
		456	* Find constructor declarations that are defined
		457	* in the current environment and whose name starts with the
		458	* given prefix. The prefix is a qualified name separated by periods
		459	* or a simple name (ex. java.util.V or V).
		460	*
		461	* The constructors found are passed to one of the following methods:
		462	* ISearchRequestor.acceptConstructor(...)
		463	*/
		464	public void findConstructorDeclarations(char[] prefix, boolean camelCaseMatch, final ISearchRequestor storage, IProgressMonitor monitor) {
		465	try {
		466	final String excludePath;
		467	if (this.unitToSkip != null && this.unitToSkip instanceof IJavaElement) {
		468	excludePath = ((IJavaElement) this.unitToSkip).getPath().toString();
		469	} else {
		470	excludePath = null;
		471	}
		472
		473	int lastDotIndex = CharOperation.lastIndexOf('.', prefix);
		474	char[] qualification, simpleName;
		475	if (lastDotIndex < 0) {
		476	qualification = null;
		477	if (camelCaseMatch) {
		478	simpleName = prefix;
		479	} else {
		480	simpleName = CharOperation.toLowerCase(prefix);
		481	}
		482	} else {
		483	qualification = CharOperation.subarray(prefix, 0, lastDotIndex);
		484	if (camelCaseMatch) {
		485	simpleName = CharOperation.subarray(prefix, lastDotIndex + 1, prefix.length);
		486	} else {
		487	simpleName =
		488	CharOperation.toLowerCase(
		489	CharOperation.subarray(prefix, lastDotIndex + 1, prefix.length));
		490	}
		491	}
		492
		493	IProgressMonitor progressMonitor = new IProgressMonitor() {
		494	boolean isCanceled = false;
		495	public void beginTask(String name, int totalWork) {
		496	// implements interface method
		497	}
		498	public void done() {
		499	// implements interface method
		500	}
		501	public void internalWorked(double work) {
		502	// implements interface method
		503	}
		504	public boolean isCanceled() {
		505	return this.isCanceled;
		506	}
		507	public void setCanceled(boolean value) {
		508	this.isCanceled = value;
		509	}
		510	public void setTaskName(String name) {
		511	// implements interface method
		512	}
		513	public void subTask(String name) {
		514	// implements interface method
515	}
516	public void worked(int work) {
517	// implements interface method
518	}
519	};
520
521	IRestrictedAccessConstructorRequestor constructorRequestor = new IRestrictedAccessConstructorRequestor() {
522	public void acceptConstructor(
523	int modifiers,
524	char[] simpleTypeName,
525	int parameterCount,
526	char[] signature,
527	char[][] parameterTypes,
528	char[][] parameterNames,
529	int typeModifiers,
530	char[] packageName,
531	int extraFlags,
532	String path,
533	AccessRestriction access) {
534	if (excludePath != null && excludePath.equals(path))
535	return;
536
537	storage.acceptConstructor(
538	modifiers,
539	simpleTypeName,
540	parameterCount,
541	signature,
542	parameterTypes,
543	parameterNames,
544	typeModifiers,
545	packageName,
546	extraFlags,
547	path,
548	access);
549	}
550	};
551
552	int matchRule = SearchPattern.R_PREFIX_MATCH;
553	if (camelCaseMatch) matchRule \|= SearchPattern.R_CAMELCASE_MATCH;
554	if (monitor != null) {
555	found : while (true) { //the loop will finish if the search request ends or is cancelled
556	try {
557	new BasicSearchEngine(this.workingCopies).searchAllConstructorDeclarations(
558	qualification,
559	simpleName,
560	matchRule,
561	getSearchScope(),
562	constructorRequestor,
563	CANCEL_IF_NOT_READY_TO_SEARCH,
564	progressMonitor);
565	break found;
566	} catch (OperationCanceledException e) {
567	if (monitor.isCanceled()) {
568	throw e;
569	} else {
570	try {
571	Thread.sleep(50); // indexes are not ready. sleep 50ms and retry the search request
572	} catch (InterruptedException e1) {
573	// Do nothing
574	}
575	}
576	}
577	}
578	} else {
579	try {
580	new BasicSearchEngine(this.workingCopies).searchAllConstructorDeclarations(
581	qualification,
582	simpleName,
583	matchRule,
584	getSearchScope(),
585	constructorRequestor,
586	CANCEL_IF_NOT_READY_TO_SEARCH,
587	progressMonitor);
588	} catch (OperationCanceledException e) {
589	// Do nothing
590	}
591	}
592	} catch (JavaModelException e) {
593	// Do nothing
594	}
595	}
450		596
451	/**	597	/**
452	* Returns all types whose name starts with the given (qualified) <code>prefix</code>.	598	* Returns all types whose name starts with the given (qualified) <code>prefix</code>.

Lines 430-435 Link Here

(-)search/org/eclipse/jdt/internal/core/search/BasicSearchEngine.java (+365 lines)
430	}	430	}
431	return true;	431	return true;
432	}	432	}
		433
		434	boolean match(char[] patternName, char[] patternPackageName, int matchRule, char[] name, char[] packageName) {
		435
		436	boolean isCaseSensitive = (matchRule & SearchPattern.R_CASE_SENSITIVE) != 0;
		437
		438	if (patternPackageName != null && !CharOperation.equals(patternPackageName, packageName, true))
		439	return false;
		440
		441	if (patternName != null) {
		442	boolean isCamelCase = (matchRule & (SearchPattern.R_CAMELCASE_MATCH \| SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH)) != 0;
		443	int matchMode = matchRule & JavaSearchPattern.MATCH_MODE_MASK;
		444	if (!isCaseSensitive && !isCamelCase) {
		445	patternName = CharOperation.toLowerCase(patternName);
		446	}
		447	boolean matchFirstChar = !isCaseSensitive \|\| patternName[0] == name[0];
		448	switch(matchMode) {
		449	case SearchPattern.R_EXACT_MATCH :
		450	return matchFirstChar && CharOperation.equals(patternName, name, isCaseSensitive);
		451	case SearchPattern.R_PREFIX_MATCH :
		452	return matchFirstChar && CharOperation.prefixEquals(patternName, name, isCaseSensitive);
		453	case SearchPattern.R_PATTERN_MATCH :
		454	return CharOperation.match(patternName, name, isCaseSensitive);
		455	case SearchPattern.R_REGEXP_MATCH :
		456	// TODO (frederic) implement regular expression match
		457	break;
		458	case SearchPattern.R_CAMELCASE_MATCH:
		459	if (matchFirstChar && CharOperation.camelCaseMatch(patternName, name, false)) {
		460	return true;
		461	}
		462	return !isCaseSensitive && matchFirstChar && CharOperation.prefixEquals(patternName, name, false);
		463	case SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH:
		464	return matchFirstChar && CharOperation.camelCaseMatch(patternName, name, true);
		465	}
		466	}
		467	return true;
		468
		469	}
433		470
434	boolean match(char patternTypeSuffix, char[] patternPkg, char[] patternTypeName, int matchRule, int typeKind, char[] pkg, char[] typeName) {	471	boolean match(char patternTypeSuffix, char[] patternPkg, char[] patternTypeName, int matchRule, int typeKind, char[] pkg, char[] typeName) {
435	switch(patternTypeSuffix) {	472	switch(patternTypeSuffix) {
Lines 505-510 Link Here
505	}	542	}
506	findMatches(pattern, participants, scope, requestor, monitor);	543	findMatches(pattern, participants, scope, requestor, monitor);
507	}	544	}
		545
		546	public void searchAllConstructorDeclarations(
		547	final char[] packageName,
		548	final char[] typeName,
		549	final int typeMatchRule,
		550	IJavaSearchScope scope,
		551	final IRestrictedAccessConstructorRequestor nameRequestor,
		552	int waitingPolicy,
		553	IProgressMonitor progressMonitor) throws JavaModelException {
		554
		555	// Validate match rule first
		556	final int validatedTypeMatchRule = SearchPattern.validateMatchRule(typeName == null ? null : new String (typeName), typeMatchRule);
		557
		558	// Debug
		559	if (VERBOSE) {
		560	Util.verbose("BasicSearchEngine.searchAllTypeNames(char[], char[], int, int, IJavaSearchScope, IRestrictedAccessTypeRequestor, int, IProgressMonitor)"); //$NON-NLS-1$
		561	Util.verbose(" - package name: "+(packageName==null?"null":new String(packageName))); //$NON-NLS-1$ //$NON-NLS-2$
		562	Util.verbose(" - type name: "+(typeName==null?"null":new String(typeName))); //$NON-NLS-1$ //$NON-NLS-2$
		563	Util.verbose(" - type match rule: "+getMatchRuleString(typeMatchRule)); //$NON-NLS-1$
		564	if (validatedTypeMatchRule != typeMatchRule) {
		565	Util.verbose(" - validated type match rule: "+getMatchRuleString(validatedTypeMatchRule)); //$NON-NLS-1$
		566	}
		567	Util.verbose(" - scope: "+scope); //$NON-NLS-1$
		568	}
		569	if (validatedTypeMatchRule == -1) return; // invalid match rule => return no results
		570
		571	// Create pattern
		572	IndexManager indexManager = JavaModelManager.getIndexManager();
		573	final ConstructorDeclarationPattern pattern = new ConstructorDeclarationPattern(
		574	packageName,
		575	typeName,
		576	validatedTypeMatchRule);
		577
		578	// Get working copy path(s). Store in a single string in case of only one to optimize comparison in requestor
		579	final HashSet workingCopyPaths = new HashSet();
		580	String workingCopyPath = null;
		581	ICompilationUnit[] copies = getWorkingCopies();
		582	final int copiesLength = copies == null ? 0 : copies.length;
		583	if (copies != null) {
		584	if (copiesLength == 1) {
		585	workingCopyPath = copies[0].getPath().toString();
		586	} else {
		587	for (int i = 0; i < copiesLength; i++) {
		588	ICompilationUnit workingCopy = copies[i];
		589	workingCopyPaths.add(workingCopy.getPath().toString());
		590	}
		591	}
		592	}
		593	final String singleWkcpPath = workingCopyPath;
		594
		595	// Index requestor
		596	IndexQueryRequestor searchRequestor = new IndexQueryRequestor(){
		597	public boolean acceptIndexMatch(String documentPath, SearchPattern indexRecord, SearchParticipant participant, AccessRuleSet access) {
		598	// Filter unexpected types
		599	ConstructorDeclarationPattern record = (ConstructorDeclarationPattern)indexRecord;
		600
		601	if ((record.extraFlags & ExtraFlags.IsMemberType) != 0) {
		602	return true; // filter out member classes
		603	}
		604	if ((record.extraFlags & ExtraFlags.IsLocalType) != 0) {
		605	return true; // filter out local and anonymous classes
		606	}
		607	switch (copiesLength) {
		608	case 0:
609	break;
610	case 1:
611	if (singleWkcpPath.equals(documentPath)) {
612	return true; // filter out the working copy
613	}
614	break;
615	default:
616	if (workingCopyPaths.contains(documentPath)) {
617	return true; // filter out working copies
618	}
619	break;
620	}
621
622	// Accept document path
623	AccessRestriction accessRestriction = null;
624	if (access != null) {
625	// Compute document relative path
626	int pkgLength = (record.declaringPackageName==null \|\| record.declaringPackageName.length==0) ? 0 : record.declaringPackageName.length+1;
627	int nameLength = record.declaringSimpleName==null ? 0 : record.declaringSimpleName.length;
628	char[] path = new char[pkgLength+nameLength];
629	int pos = 0;
630	if (pkgLength > 0) {
631	System.arraycopy(record.declaringPackageName, 0, path, pos, pkgLength-1);
632	CharOperation.replace(path, '.', '/');
633	path[pkgLength-1] = '/';
634	pos += pkgLength;
635	}
636	if (nameLength > 0) {
637	System.arraycopy(record.declaringSimpleName, 0, path, pos, nameLength);
638	pos += nameLength;
639	}
640	// Update access restriction if path is not empty
641	if (pos > 0) {
642	accessRestriction = access.getViolatedRestriction(path);
643	}
644	}
645	nameRequestor.acceptConstructor(
646	record.modifiers,
647	record.declaringSimpleName,
648	record.parameterCount,
649	record.signature,
650	record.parameterTypes,
651	record.parameterNames,
652	record.declaringTypeModifiers,
653	record.declaringPackageName,
654	record.extraFlags,
655	documentPath,
656	accessRestriction);
657	return true;
658	}
659	};
660
661	try {
662	if (progressMonitor != null) {
663	progressMonitor.beginTask(Messages.engine_searching, 1000);
664	}
665	// add type names from indexes
666	indexManager.performConcurrentJob(
667	new PatternSearchJob(
668	pattern,
669	getDefaultSearchParticipant(), // Java search only
670	scope,
671	searchRequestor),
672	waitingPolicy,
673	progressMonitor == null ? null : new SubProgressMonitor(progressMonitor, 1000-copiesLength));
674
675	// add type names from working copies
676	if (copies != null) {
677	for (int i = 0; i < copiesLength; i++) {
678	final ICompilationUnit workingCopy = copies[i];
679	if (!scope.encloses(workingCopy)) continue;
680	final String path = workingCopy.getPath().toString();
681	if (workingCopy.isConsistent()) {
682	IPackageDeclaration[] packageDeclarations = workingCopy.getPackageDeclarations();
683	char[] packageDeclaration = packageDeclarations.length == 0 ? CharOperation.NO_CHAR : packageDeclarations[0].getElementName().toCharArray();
684	IType[] allTypes = workingCopy.getAllTypes();
685	for (int j = 0, allTypesLength = allTypes.length; j < allTypesLength; j++) {
686	IType type = allTypes[j];
687	char[] simpleName = type.getElementName().toCharArray();
688	if (match(typeName, packageName, validatedTypeMatchRule, simpleName, packageDeclaration) && !type.isMember()) {
689
690	int extraFlags = ExtraFlags.getExtraFlags(type);
691
692	boolean hasConstructor = false;
693
694	IMethod[] methods = type.getMethods();
695	for (int k = 0; k < methods.length; k++) {
696	IMethod method = methods[k];
697	if (method.isConstructor()) {
698	hasConstructor = true;
699
700	String[] stringParameterNames = method.getParameterNames();
701	String[] stringParameterTypes = method.getParameterTypes();
702	int length = stringParameterNames.length;
703	char[][] parameterNames = new char[length][];
704	char[][] parameterTypes = new char[length][];
705	for (int l = 0; l < length; l++) {
706	parameterNames[l] = stringParameterNames[l].toCharArray();
707	parameterTypes[l] = Signature.toCharArray(Signature.getTypeErasure(stringParameterTypes[l]).toCharArray());
708	}
709
710	nameRequestor.acceptConstructor(
711	method.getFlags(),
712	simpleName,
713	parameterNames.length,
714	null,// signature is not used for source type
715	parameterTypes,
716	parameterNames,
717	type.getFlags(),
718	packageDeclaration,
719	extraFlags,
720	path,
721	null);
722	}
723	}
724
725	if (!hasConstructor) {
726	nameRequestor.acceptConstructor(
727	Flags.AccPublic,
728	simpleName,
729	-1,
730	null, // signature is not used for source type
731	CharOperation.NO_CHAR_CHAR,
732	CharOperation.NO_CHAR_CHAR,
733	type.getFlags(),
734	packageDeclaration,
735	extraFlags,
736	path,
737	null);
738	}
739	}
740	}
741	} else {
742	Parser basicParser = getParser();
743	org.eclipse.jdt.internal.compiler.env.ICompilationUnit unit = (org.eclipse.jdt.internal.compiler.env.ICompilationUnit) workingCopy;
744	CompilationResult compilationUnitResult = new CompilationResult(unit, 0, 0, this.compilerOptions.maxProblemsPerUnit);
745	CompilationUnitDeclaration parsedUnit = basicParser.dietParse(unit, compilationUnitResult);
746	if (parsedUnit != null) {
747	final char[] packageDeclaration = parsedUnit.currentPackage == null ? CharOperation.NO_CHAR : CharOperation.concatWith(parsedUnit.currentPackage.getImportName(), '.');
748	class AllConstructorDeclarationsVisitor extends ASTVisitor {
749	private TypeDeclaration[] declaringTypes = new TypeDeclaration[0];
750	private int declaringTypesPtr = -1;
751
752	private void endVisit(TypeDeclaration typeDeclaration) {
753	if (!hasConstructor(typeDeclaration) && typeDeclaration.enclosingType == null) {
754
755	if (match(typeName, packageName, validatedTypeMatchRule, typeDeclaration.name, packageDeclaration)) {
756	nameRequestor.acceptConstructor(
757	Flags.AccPublic,
758	typeName,
759	-1,
760	null, // signature is not used for source type
761	CharOperation.NO_CHAR_CHAR,
762	CharOperation.NO_CHAR_CHAR,
763	typeDeclaration.modifiers,
764	packageDeclaration,
765	ExtraFlags.getExtraFlags(typeDeclaration),
766	path,
767	null);
768	}
769	}
770
771	this.declaringTypes[this.declaringTypesPtr] = null;
772	this.declaringTypesPtr--;
773	}
774
775	public void endVisit(TypeDeclaration typeDeclaration, CompilationUnitScope s) {
776	endVisit(typeDeclaration);
777	}
778
779	public void endVisit(TypeDeclaration memberTypeDeclaration, ClassScope s) {
780	endVisit(memberTypeDeclaration);
781	}
782
783	private boolean hasConstructor(TypeDeclaration typeDeclaration) {
784	AbstractMethodDeclaration[] methods = typeDeclaration.methods;
785	int length = methods == null ? 0 : methods.length;
786	for (int j = 0; j < length; j++) {
787	if (methods[j].isConstructor()) {
788	return true;
789	}
790	}
791
792	return false;
793	}
794	public boolean visit(ConstructorDeclaration constructorDeclaration, ClassScope classScope) {
795	TypeDeclaration typeDeclaration = this.declaringTypes[this.declaringTypesPtr];
796	if (match(typeName, packageName, validatedTypeMatchRule, typeDeclaration.name, packageDeclaration)) {
797	Argument[] arguments = constructorDeclaration.arguments;
798	int length = arguments == null ? 0 : arguments.length;
799	char[][] parameterNames = new char[length][];
800	char[][] parameterTypes = new char[length][];
801	for (int l = 0; l < length; l++) {
802	Argument argument = arguments[l];
803	parameterNames[l] = argument.name;
804	if (argument.type instanceof SingleTypeReference) {
805	parameterTypes[l] = ((SingleTypeReference)argument.type).token;
806	} else {
807	parameterTypes[l] = CharOperation.concatWith(((QualifiedTypeReference)argument.type).tokens, '.');
808	}
809	}
810
811	TypeDeclaration enclosing = typeDeclaration.enclosingType;
812	char[][] enclosingTypeNames = CharOperation.NO_CHAR_CHAR;
813	while (enclosing != null) {
814	enclosingTypeNames = CharOperation.arrayConcat(new char[][] {enclosing.name}, enclosingTypeNames);
815	if ((enclosing.bits & ASTNode.IsMemberType) != 0) {
816	enclosing = enclosing.enclosingType;
817	} else {
818	enclosing = null;
819	}
820	}
821
822	nameRequestor.acceptConstructor(
823	constructorDeclaration.modifiers,
824	typeName,
825	parameterNames.length,
826	null, // signature is not used for source type
827	parameterTypes,
828	parameterNames,
829	typeDeclaration.modifiers,
830	packageDeclaration,
831	ExtraFlags.getExtraFlags(typeDeclaration),
832	path,
833	null);
834	}
835	return false; // no need to find constructors from local/anonymous type
836	}
837	public boolean visit(TypeDeclaration typeDeclaration, BlockScope blockScope) {
838	return false;
839	}
840
841	private boolean visit(TypeDeclaration typeDeclaration) {
842	if(this.declaringTypes.length <= ++this.declaringTypesPtr) {
843	int length = this.declaringTypesPtr;
844	System.arraycopy(this.declaringTypes, 0, this.declaringTypes = new TypeDeclaration[length * 2 + 1], 0, length);
845	}
846	this.declaringTypes[this.declaringTypesPtr] = typeDeclaration;
847	return true;
848	}
849
850	public boolean visit(TypeDeclaration typeDeclaration, CompilationUnitScope s) {
851	return visit(typeDeclaration);
852	}
853
854	public boolean visit(TypeDeclaration memberTypeDeclaration, ClassScope s) {
855	return visit(memberTypeDeclaration);
856	}
857	}
858	parsedUnit.traverse(new AllConstructorDeclarationsVisitor(), parsedUnit.scope);
859	}
860	}
861	if (progressMonitor != null) {
862	if (progressMonitor.isCanceled()) throw new OperationCanceledException();
863	progressMonitor.worked(1);
864	}
865	}
866	}
867	} finally {
868	if (progressMonitor != null) {
869	progressMonitor.done();
870	}
871	}
872	}
508		873
509	/**	874	/**
510	* Searches for all secondary types in the given scope.	875	* Searches for all secondary types in the given scope.

Added Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/ConstructorDeclarationPattern.java (+190 lines)
1	/*******************************************************************************
2	* Copyright (c) 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.jdt.internal.core.search.matching;
12
13	import java.io.IOException;
14
15	import org.eclipse.jdt.core.compiler.CharOperation;
16	import org.eclipse.jdt.core.search.SearchPattern;
17	import org.eclipse.jdt.internal.compiler.ExtraFlags;
18	import org.eclipse.jdt.internal.core.index.EntryResult;
19	import org.eclipse.jdt.internal.core.index.Index;
20
21	public class ConstructorDeclarationPattern extends ConstructorPattern {
22	private static final char[][] EXT_DECL_CATEGORIES = {CONSTRUCTOR_DECL};
23
24	public int extraFlags;
25
26	public int declaringTypeModifiers;
27	public char[] declaringPackageName;
28
29	public int modifiers;
30	public char[] signature;
31	public char[][] parameterTypes;
32	public char[][] parameterNames;
33
34	public ConstructorDeclarationPattern(char[] declaringPackageName, char[] declaringSimpleName, int matchRule) {
35	this(matchRule);
36	this.declaringSimpleName = (this.isCaseSensitive \|\| this.isCamelCase) ? declaringSimpleName : CharOperation.toLowerCase(declaringSimpleName);
37	this.declaringPackageName = declaringPackageName;
38	this.findDeclarations = true;
39	this.findReferences = false;
40	this.parameterCount = -1;
41	this.mustResolve = false;
42	}
43
44	ConstructorDeclarationPattern(int matchRule) {
45	super(matchRule);
46	}
47	public void decodeIndexKey(char[] key) {
48	int last = key.length - 1;
49	int slash = CharOperation.indexOf(SEPARATOR, key, 0);
50	this.declaringSimpleName = CharOperation.subarray(key, 0, slash);
51
52	int start = slash + 1;
53	slash = CharOperation.indexOf(SEPARATOR, key, start);
54	last = slash - 1;
55
56	boolean isDefaultConstructor = key[last] == '#';
57	if (isDefaultConstructor) {
58	this.parameterCount = -1;
59	} else {
60	this.parameterCount = 0;
61	int power = 1;
62	for (int i = last; i >= start; i--) {
63	if (i == last) {
64	this.parameterCount = key[i] - '0';
65	} else {
66	power *= 10;
67	this.parameterCount += power * (key[i] - '0');
68	}
69	}
70	}
71
72	slash = slash + 3;
73	last = slash - 1;
74
75	int typeModifiersWithExtraFlags = key[last-1] + (key[last]<<16);
76	this.declaringTypeModifiers = decodeModifers(typeModifiersWithExtraFlags);
77	this.extraFlags = decodeExtraFlags(typeModifiersWithExtraFlags);
78
79	boolean isMemberType = (this.extraFlags & ExtraFlags.IsMemberType) != 0;
80
81	if (!isMemberType) {
82	start = slash + 1;
83	if (this.parameterCount == -1) {
84	slash = key.length;
85	last = slash - 1;
86	} else {
87	slash = CharOperation.indexOf(SEPARATOR, key, start);
88	}
89	last = slash - 1;
90
91	this.declaringPackageName = CharOperation.subarray(key, start, slash);
92
93	start = slash + 1;
94	if (this.parameterCount == 0) {
95	slash = slash + 3;
96	last = slash - 1;
97
98	this.modifiers = key[last-1] + (key[last]<<16);
99	} else if (this.parameterCount > 0){
100	slash = CharOperation.indexOf(SEPARATOR, key, start);
101	last = slash - 1;
102
103	boolean hasParameterStoredAsSignature = (this.extraFlags & ExtraFlags.ParameterTypesStoredAsSignature) != 0;
104	if (hasParameterStoredAsSignature) {
105	this.signature = CharOperation.subarray(key, start, slash);
106	CharOperation.replace(this.signature , '\\', SEPARATOR);
107
108	start = slash + 1;
109	slash = CharOperation.indexOf(SEPARATOR, key, start);
110	} else {
111	this.parameterTypes = CharOperation.splitOn(PARAMETER_SEPARATOR, key, start, slash);
112
113	start = slash + 1;
114	slash = key.length;
115	}
116	last = slash - 1;
117
118	if (slash != start) {
119	this.parameterNames = CharOperation.splitOn(PARAMETER_SEPARATOR, key, start, slash);
120	}
121
122	if (hasParameterStoredAsSignature) {
123	slash = slash + 3;
124	last = slash - 1;
125
126	this.modifiers = key[last-1] + (key[last]<<16);
127	}
128	}
129	}
130
131	removeInternalFlags(); // remove internal flags
132	}
133
134	public SearchPattern getBlankPattern() {
135	return new ConstructorDeclarationPattern(R_EXACT_MATCH \| R_CASE_SENSITIVE);
136	}
137	public char[][] getIndexCategories() {
138	return EXT_DECL_CATEGORIES;
139	}
140	public boolean matchesDecodedKey(SearchPattern decodedPattern) {
141	ConstructorDeclarationPattern pattern = (ConstructorDeclarationPattern) decodedPattern;
142
143	// only top level types
144	if ((pattern.extraFlags & ExtraFlags.IsMemberType) != 0) return false;
145
146	// check package - exact match only
147	if (this.declaringPackageName != null && !CharOperation.equals(this.declaringPackageName, pattern.declaringPackageName, true))
148	return false;
149
150	return (this.parameterCount == pattern.parameterCount \|\| this.parameterCount == -1 \|\| this.varargs)
151	&& matchesName(this.declaringSimpleName, pattern.declaringSimpleName);
152	}
153	public EntryResult[] queryIn(Index index) throws IOException {
154	char[] key = this.declaringSimpleName; // can be null
155	int matchRule = getMatchRule();
156
157	switch(getMatchMode()) {
158	case R_EXACT_MATCH :
159	if (this.declaringSimpleName != null && this.parameterCount >= 0 && !this.varargs) {
160	key = createIndexKey(this.declaringSimpleName, this.parameterCount);
161	}
162	matchRule &= ~R_EXACT_MATCH;
163	matchRule \|= R_PREFIX_MATCH;
164	break;
165	case R_PREFIX_MATCH :
166	// do a prefix query with the declaringSimpleName
167	break;
168	case R_PATTERN_MATCH :
169	if (this.parameterCount >= 0 && !this.varargs)
170	key = createIndexKey(this.declaringSimpleName == null ? ONE_STAR : this.declaringSimpleName, this.parameterCount);
171	else if (this.declaringSimpleName != null && this.declaringSimpleName[this.declaringSimpleName.length - 1] != '*')
172	key = CharOperation.concat(this.declaringSimpleName, ONE_STAR, SEPARATOR);
173	key = CharOperation.concat(key, ONE_STAR);
174	// else do a pattern query with just the declaringSimpleName
175	break;
176	case R_REGEXP_MATCH :
177	// TODO (frederic) implement regular expression match
178	break;
179	case R_CAMELCASE_MATCH:
180	case R_CAMELCASE_SAME_PART_COUNT_MATCH:
181	// do a prefix query with the declaringSimpleName
182	break;
183	}
184
185	return index.query(getIndexCategories(), key, matchRule); // match rule is irrelevant when the key is null
186	}
187	private void removeInternalFlags() {
188	this.extraFlags = this.extraFlags & ~ExtraFlags.ParameterTypesStoredAsSignature; // ParameterTypesStoredAsSignature is an internal flags only used to decode key
189	}
190	}

Lines 160-165 Link Here

(-)src/org/eclipse/jdt/core/tests/model/JavaSearchBugsTests.java (-1 / +151 lines)
160	);	160	);
161	}	161	}
162		162
		163	public void testBug6930_AllConstructorDeclarations01() throws Exception {
		164	this.workingCopies = new ICompilationUnit[2];
		165	this.workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/p6930/AllConstructorDeclarations01.java",
		166	"package p6930;\n" +
		167	"public class AllConstructorDeclarations01 {\n" +
		168	" public AllConstructorDeclarations01() {}\n" +
		169	" public AllConstructorDeclarations01(Object o) {}\n" +
		170	" public AllConstructorDeclarations01(Object o, String s) {}\n" +
		171	"}\n"
		172	);
		173
		174	this.workingCopies[1] = getWorkingCopy("/JavaSearchBugs/src/p6930/AllConstructorDeclarations01b.java",
		175	"package p6930;\n" +
		176	"public class AllConstructorDeclarations01b {\n" +
		177	"}\n"
		178	);
		179
		180	ConstructorDeclarationsCollector requestor = new ConstructorDeclarationsCollector();
		181	searchAllConstructorDeclarations("AllConstructorDeclarations", SearchPattern.R_PREFIX_MATCH, requestor);
		182	assertSearchResults(
		183	"p6930.AllConstructorDeclarations01#AllConstructorDeclarations01()\n" +
		184	"p6930.AllConstructorDeclarations01#AllConstructorDeclarations01(Object o)\n" +
		185	"p6930.AllConstructorDeclarations01#AllConstructorDeclarations01(Object o,String s)\n" +
		186	"p6930.AllConstructorDeclarations01b#AllConstructorDeclarations01b()*",
		187	requestor
		188	);
		189	}
		190
		191	public void testBug6930_AllConstructorDeclarations02() throws Exception {
		192	try {
		193	IJavaProject p = createJavaProject("P", new String[] {}, new String[] {"/P/lib6930.jar"}, "");
		194
		195	createJar(new String[] {
		196	"p6930/AllConstructorDeclarations02.java",
		197	"package p6930;\n" +
		198	"public class AllConstructorDeclarations02 {\n" +
		199	" public AllConstructorDeclarations02() {}\n" +
		200	" public AllConstructorDeclarations02(Object o) {}\n" +
		201	" public AllConstructorDeclarations02(Object o, String s) {}\n" +
		202	"}",
		203	"p6930/AllConstructorDeclarations02b.java",
		204	"package p6930;\n" +
		205	"public class AllConstructorDeclarations02b {\n" +
		206	"}"
		207	}, p.getProject().getLocation().append("lib6930.jar").toOSString());
		208	refresh(p);
		209
		210	ConstructorDeclarationsCollector requestor = new ConstructorDeclarationsCollector();
		211	searchAllConstructorDeclarations("AllConstructorDeclarations", SearchPattern.R_PREFIX_MATCH, requestor);
		212	assertSearchResults(
		213	"p6930.AllConstructorDeclarations02#AllConstructorDeclarations02()\n" +
		214	"p6930.AllConstructorDeclarations02#AllConstructorDeclarations02(java.lang.Object o)\n" +
		215	"p6930.AllConstructorDeclarations02#AllConstructorDeclarations02(java.lang.Object o,java.lang.String s)\n" +
		216	"p6930.AllConstructorDeclarations02b#AllConstructorDeclarations02b()",
		217	requestor
		218	);
		219	} finally {
		220	deleteProject("P");
		221	}
		222	}
		223
		224	public void testBug6930_AllConstructorDeclarations03() throws Exception {
		225	try {
		226	IJavaProject p = createJavaProject("P", new String[] {"src"}, new String[] {}, "bin");
227
228	createFolder("/P/src/p6930");
229
230	createFile(
231	"/P/src/p6930/AllConstructorDeclarations03.java",
232	"package p6930;\n" +
233	"public class AllConstructorDeclarations03 {\n" +
234	" public AllConstructorDeclarations03() {}\n" +
235	" public AllConstructorDeclarations03(Object o) {}\n" +
236	" public AllConstructorDeclarations03(Object o, String s) {}\n" +
237	"}");
238
239	createFile(
240	"/P/src/p6930/AllConstructorDeclarations03b.java",
241	"package p6930;\n" +
242	"public class AllConstructorDeclarations03b {\n" +
243	"}");
244	refresh(p);
245
246	ConstructorDeclarationsCollector requestor = new ConstructorDeclarationsCollector();
247	searchAllConstructorDeclarations("AllConstructorDeclarations", SearchPattern.R_PREFIX_MATCH, requestor);
248	assertSearchResults(
249	"p6930.AllConstructorDeclarations03#AllConstructorDeclarations03()\n" +
250	"p6930.AllConstructorDeclarations03#AllConstructorDeclarations03(Object o)\n" +
251	"p6930.AllConstructorDeclarations03#AllConstructorDeclarations03(Object o,String s)\n" +
252	"p6930.AllConstructorDeclarations03b#AllConstructorDeclarations03b()*",
253	requestor
254	);
255	} finally {
256	deleteProject("P");
257	}
258	}
259
260	public void testBug6930_AllConstructorDeclarations04() throws Exception {
261	try {
262	IJavaProject p = createJavaProject("P", new String[] {}, new String[] {"/P/lib6930.jar"}, "","1.5");
263
264	createJar(
265	new String[] {
266	"p6930/AllConstructorDeclarations04.java",
267	"package p6930;\n" +
268	"public class AllConstructorDeclarations04 {\n" +
269	" public AllConstructorDeclarations04(java.util.Collection<Object> c) {}\n" +
270	"}"
271	},
272	p.getProject().getLocation().append("lib6930.jar").toOSString(),
273	new String[]{getExternalJCLPathString("1.5")},
274	"1.5");
275	refresh(p);
276
277	ConstructorDeclarationsCollector requestor = new ConstructorDeclarationsCollector();
278	searchAllConstructorDeclarations("AllConstructorDeclarations", SearchPattern.R_PREFIX_MATCH, requestor);
279	assertSearchResults(
280	"p6930.AllConstructorDeclarations04#AllConstructorDeclarations04(java.util.Collection<java.lang.Object> c)",
281	requestor
282	);
283	} finally {
284	deleteProject("P");
285	}
286	}
287
288	public void testBug6930_AllConstructorDeclarations05() throws Exception {
289	try {
290	IJavaProject p = createJavaProject("P", new String[] {}, new String[] {"/P/lib6930.jar"}, "");
291
292	createJar(new String[] {
293	"p6930/AllConstructorDeclarations05.java",
294	"package p6930;\n" +
295	"public class AllConstructorDeclarations05 {\n" +
296	" public class AllConstructorDeclarations05b {\n" +
297	" public AllConstructorDeclarations05b(Object o) {}\n" +
298	" }\n" +
299	"}"
300	}, p.getProject().getLocation().append("lib6930.jar").toOSString());
301	refresh(p);
302
303	ConstructorDeclarationsCollector requestor = new ConstructorDeclarationsCollector();
304	searchAllConstructorDeclarations("AllConstructorDeclarations", SearchPattern.R_PREFIX_MATCH, requestor);
305	assertSearchResults(
306	"p6930.AllConstructorDeclarations05#AllConstructorDeclarations05()",
307	requestor
308	);
309	} finally {
310	deleteProject("P");
311	}
312	}
313
163	/**	314	/**
164	* @bug 70827: [Search] wrong reference match to private method of supertype	315	* @bug 70827: [Search] wrong reference match to private method of supertype
165	* @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=70827"	316	* @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=70827"
Lines 10273-10277 Link Here
10273	deleteProject("P");	10424	deleteProject("P");
10274	}	10425	}
10275	}	10426	}
10276
10277	}	10427	}

Lines 84-90 Link Here

(-)src/org/eclipse/jdt/core/tests/model/CompletionTestsRequestor2.java (-3 / +11 lines)
84	this.shortContext = shortContext;	84	this.shortContext = shortContext;
85	this.showMissingTypes = showMissingTypes;	85	this.showMissingTypes = showMissingTypes;
86	this.showModifiers = showModifiers;	86	this.showModifiers = showModifiers;
87
88	}	87	}
89	public void acceptContext(CompletionContext cc) {	88	public void acceptContext(CompletionContext cc) {
90	this.context = cc;	89	this.context = cc;
Lines 98-105 Link Here
98	}	97	}
99		98
100	public void allowAllRequiredProposals() {	99	public void allowAllRequiredProposals() {
101	for (int i = CompletionProposal.ANONYMOUS_CLASS_DECLARATION; i <= CompletionProposal.TYPE_IMPORT; i++) {	100	for (int i = CompletionProposal.ANONYMOUS_CLASS_DECLARATION; i <= CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION; i++) {
102	for (int j = CompletionProposal.ANONYMOUS_CLASS_DECLARATION; j <= CompletionProposal.FIELD_REF_WITH_CASTED_RECEIVER; j++) {	101	for (int j = CompletionProposal.ANONYMOUS_CLASS_DECLARATION; j <= CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION; j++) {
103	setAllowsRequiredProposals(i, j, true);	102	setAllowsRequiredProposals(i, j, true);
104	}	103	}
105	}	104	}
Lines 394-399 Link Here
394	case CompletionProposal.TYPE_IMPORT :	393	case CompletionProposal.TYPE_IMPORT :
395	buffer.append("TYPE_IMPORT"); //$NON-NLS-1$	394	buffer.append("TYPE_IMPORT"); //$NON-NLS-1$
396	break;	395	break;
		396	case CompletionProposal.CONSTRUCTOR_INVOCATION :
		397	buffer.append("CONSTRUCTOR_INVOCATION"); //$NON-NLS-1$
		398	break;
		399	case CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION :
		400	buffer.append("ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION"); //$NON-NLS-1$
		401	break;
397	default :	402	default :
398	buffer.append("PROPOSAL"); //$NON-NLS-1$	403	buffer.append("PROPOSAL"); //$NON-NLS-1$
399	break;	404	break;
Lines 547-552 Link Here
547	protected String getElementName(CompletionProposal proposal) {	552	protected String getElementName(CompletionProposal proposal) {
548	switch(proposal.getKind()) {	553	switch(proposal.getKind()) {
549	case CompletionProposal.ANONYMOUS_CLASS_DECLARATION :	554	case CompletionProposal.ANONYMOUS_CLASS_DECLARATION :
		555	case CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION :
550	return new String(Signature.getSignatureSimpleName(proposal.getDeclarationSignature()));	556	return new String(Signature.getSignatureSimpleName(proposal.getDeclarationSignature()));
551	case CompletionProposal.TYPE_REF :	557	case CompletionProposal.TYPE_REF :
552	case CompletionProposal.TYPE_IMPORT :	558	case CompletionProposal.TYPE_IMPORT :
Lines 572-577 Link Here
572	case CompletionProposal.JAVADOC_VALUE_REF :	578	case CompletionProposal.JAVADOC_VALUE_REF :
573	case CompletionProposal.FIELD_IMPORT :	579	case CompletionProposal.FIELD_IMPORT :
574	case CompletionProposal.METHOD_IMPORT :	580	case CompletionProposal.METHOD_IMPORT :
		581	case CompletionProposal.CONSTRUCTOR_INVOCATION :
		582
575	return new String(proposal.getName());	583	return new String(proposal.getName());
576	case CompletionProposal.PACKAGE_REF:	584	case CompletionProposal.PACKAGE_REF:
577	return new String(proposal.getDeclarationSignature());	585	return new String(proposal.getDeclarationSignature());