Attachment #122551 for bug #6930

Lines 1-5 Link Here

(-)codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionParser.java (-1 / +23 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.	2	* Copyright (c) 2000, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 572-577 Link Here
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 1-5 Link Here

(-)codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionOnQualifiedTypeReference.java (-1 / +4 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.	2	* Copyright (c) 2000, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 35-40 Link Here
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	}

Lines 1-5 Link Here

(-)search/org/eclipse/jdt/internal/core/index/DiskIndex.java (-2 / +2 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2007 IBM Corporation and others.	2	* Copyright (c) 2000, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 46-52 Link Here
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




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

	 * 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 1-5 Link Here

(-)model/org/eclipse/jdt/internal/compiler/ISourceElementRequestor.java (-1 / +5 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.	2	* Copyright (c) 2000, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 59-64 Link Here
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




/*******************************************************************************
 * Copyright (c) 2000, 2009 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at


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;




/*******************************************************************************
 * Copyright (c) 2000, 2009 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

			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 1-5 Link Here

(-)search/org/eclipse/jdt/internal/core/search/indexing/IIndexConstants.java (-1 / +3 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.	2	* Copyright (c) 2000, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 29-34 Link Here
29	new char[][] { new char[] {'/', '0'}, new char[] {'/', '1'}, new char[] {'/', '2'}, new char[] {'/', '3'}, new char[] {'/', '4'},	29	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'}	30	new char[] {'/', '5'}, new char[] {'/', '6'}, new char[] {'/', '7'}, new char[] {'/', '8'}, new char[] {'/', '9'}
31	};	31	};
		32	char[] DEFAULT_CONSTRUCTOR = new char[]{'/', '#'};
32	char CLASS_SUFFIX = 'C';	33	char CLASS_SUFFIX = 'C';
33	char INTERFACE_SUFFIX = 'I';	34	char INTERFACE_SUFFIX = 'I';
34	char ENUM_SUFFIX = 'E';	35	char ENUM_SUFFIX = 'E';
Lines 38-43 Link Here
38	char CLASS_AND_INTERFACE_SUFFIX = IJavaSearchConstants.CLASS_AND_INTERFACE;	39	char CLASS_AND_INTERFACE_SUFFIX = IJavaSearchConstants.CLASS_AND_INTERFACE;
39	char INTERFACE_AND_ANNOTATION_SUFFIX = IJavaSearchConstants.INTERFACE_AND_ANNOTATION;	40	char INTERFACE_AND_ANNOTATION_SUFFIX = IJavaSearchConstants.INTERFACE_AND_ANNOTATION;
40	char SEPARATOR= '/';	41	char SEPARATOR= '/';
		42	char PARAMETER_SEPARATOR= ',';
41	char SECONDARY_SUFFIX = 'S';	43	char SECONDARY_SUFFIX = 'S';
42		44
43	char[] ONE_STAR = new char[] {'*'};	45	char[] ONE_STAR = new char[] {'*'};

Lines 1-5 Link Here

(-)search/org/eclipse/jdt/internal/core/search/indexing/BinaryIndexer.java (-2 / +45 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2007 IBM Corporation and others.	2	* Copyright (c) 2000, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 14-19 Link Here
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	*/




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 int openedBinaryTypes; // used during InternalCompletionProposal#findConstructorParameterNames()
	
	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.requestor = requestor;
		this.nameEnvironment = nameEnvironment;
		this.typeCache = new HashtableOfObject(5);
		this.openedBinaryTypes = 0;

		this.problemFactory = new CompletionProblemFactory(Locale.getDefault());
		this.problemReporter = new ProblemReporter(

		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;
			char[] typeCompletion = null;
			if (!exactMatch) {
				typeCompletion = 
					isQualified ?
							CharOperation.concat(currentType.qualifiedPackageName(), currentType.qualifiedSourceName(), '.') :
								currentType.sourceName();
				if (this.source != null
							&& this.source.length > this.endPosition
							&& this.source[this.endPosition] == '(') {
					completion = CharOperation.NO_CHAR;
				} else {
					completion = new char[] { '(', ')' };
				}
			}

			this.noProposal = false;
			if (!exactMatch) {
				if(!isIgnored(CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION, CompletionProposal.TYPE_REF)) {
					char[] packageName = currentType.isLocalType() ? null : currentType.qualifiedPackageName();
					char[] typeName = currentType.qualifiedSourceName();
					
					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(packageName);
					proposal.setDeclarationTypeName(typeName);
					//proposal.setParameterPackageNames(null);
					//proposal.setParameterTypeNames(null);
					//proposal.setPackageName(null);
					//proposal.setTypeName(null);
					proposal.setName(currentType.sourceName());
					
					InternalCompletionProposal typeProposal = createProposal(CompletionProposal.TYPE_REF, this.actualCompletionPosition);
					typeProposal.nameLookup = this.nameEnvironment.nameLookup;
					typeProposal.completionEngine = this;
					typeProposal.setDeclarationSignature(packageName);
					typeProposal.setSignature(getRequiredTypeSignature(currentType));
					typeProposal.setPackageName(packageName);
					typeProposal.setTypeName(typeName);
					typeProposal.setCompletion(typeCompletion);
					typeProposal.setFlags(currentType.modifiers);
					typeProposal.setReplaceRange(this.startPosition - this.offset, this.endPosition - this.offset);
					typeProposal.setTokenRange(this.startPosition - this.offset, this.endPosition - this.offset);
					typeProposal.setRelevance(relevance);
					proposal.setRequiredProposals( new CompletionProposal[]{typeProposal});
								
					proposal.setCompletion(completion);
					proposal.setFlags(Flags.AccPublic);
					proposal.setReplaceRange(this.endPosition - 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){
						char[] typeCompletion = null;
						if (!exactMatch) {
							typeCompletion = 
								isQualified ?
										CharOperation.concat(currentType.qualifiedPackageName(), currentType.qualifiedSourceName(), '.') :
											currentType.sourceName();
							if (this.source != null
										&& this.source.length > this.endPosition
										&& this.source[this.endPosition] == '(') {
								completion = CharOperation.NO_CHAR;
							} else {
								completion = new char[] { '(', ')' };
							}
						}
						
						this.noProposal = false;
						if (!exactMatch) {
							if(!isIgnored(CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION, CompletionProposal.TYPE_REF)) {
								char[] packageName = currentType.isLocalType() ? null : currentType.qualifiedPackageName();
								char[] typeName = currentType.qualifiedSourceName();
								
								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(packageName);
								proposal.setDeclarationTypeName(typeName);
								proposal.setParameterPackageNames(parameterPackageNames);
								proposal.setParameterTypeNames(parameterTypeNames);
								//proposal.setPackageName(null);
								//proposal.setTypeName(null);
								proposal.setName(currentType.sourceName());
								
								InternalCompletionProposal typeProposal = createProposal(CompletionProposal.TYPE_REF, this.actualCompletionPosition);
								typeProposal.nameLookup = this.nameEnvironment.nameLookup;
								typeProposal.completionEngine = this;
								typeProposal.setDeclarationSignature(packageName);
								typeProposal.setSignature(getRequiredTypeSignature(currentType));
								typeProposal.setPackageName(packageName);
								typeProposal.setTypeName(typeName);
								typeProposal.setCompletion(typeCompletion);
								typeProposal.setFlags(currentType.modifiers);
								typeProposal.setReplaceRange(this.startPosition - this.offset, this.endPosition - this.offset);
								typeProposal.setTokenRange(this.startPosition - this.offset, this.endPosition - this.offset);
								typeProposal.setRelevance(relevance);
								proposal.setRequiredProposals( new CompletionProposal[]{typeProposal});
								
								proposal.setCompletion(completion);
								proposal.setFlags(constructor.modifiers);
								proposal.setReplaceRange(this.endPosition - 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 {
						char[] typeCompletion = null;
						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) {
								typeCompletion = 
									isQualified ?
											CharOperation.concat(currentType.qualifiedPackageName(), currentType.qualifiedSourceName(), '.') :
												currentType.sourceName();
								
								if (this.source != null
											&& this.source.length > this.endPosition
											&& this.source[this.endPosition] == '(') {
									completion = CharOperation.NO_CHAR;
								} else {
									completion = new char[] { '(', ')' };
								}
							}
						}

						// Create standard proposal
						this.noProposal = false;
						if (!exactMatch) {
							if(!isIgnored(CompletionProposal.CONSTRUCTOR_INVOCATION, CompletionProposal.TYPE_REF)) {
								char[] packageName = currentType.isLocalType() ? null : currentType.qualifiedPackageName();
								char[] typeName = currentType.qualifiedSourceName();
								
								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(packageName);
								proposal.setDeclarationTypeName(typeName);
								proposal.setParameterPackageNames(parameterPackageNames);
								proposal.setParameterTypeNames(parameterTypeNames);
								//proposal.setPackageName(null);
								//proposal.setTypeName(null);
								proposal.setName(currentType.sourceName());
					
								InternalCompletionProposal typeProposal = createProposal(CompletionProposal.TYPE_REF, this.actualCompletionPosition);
								typeProposal.nameLookup = this.nameEnvironment.nameLookup;
								typeProposal.completionEngine = this;
								typeProposal.setDeclarationSignature(packageName);
								typeProposal.setSignature(getRequiredTypeSignature(currentType));
								typeProposal.setPackageName(packageName);
								typeProposal.setTypeName(typeName);
								typeProposal.setCompletion(typeCompletion);
								typeProposal.setFlags(currentType.modifiers);
								typeProposal.setReplaceRange(this.startPosition - this.offset, this.endPosition - this.offset);
								typeProposal.setTokenRange(this.startPosition - this.offset, this.endPosition - this.offset);
								typeProposal.setRelevance(relevance);
								proposal.setRequiredProposals( new CompletionProposal[]{typeProposal});
								
								proposal.setIsContructor(true);
								proposal.setCompletion(completion);
								proposal.setFlags(constructor.modifiers);
								proposal.setReplaceRange(this.endPosition - 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 (!isIgnored(CompletionProposal.CONSTRUCTOR_INVOCATION, CompletionProposal.TYPE_REF)
				&& 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 (!isIgnored(CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION, CompletionProposal.TYPE_REF)
				&& !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 = 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 = 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 = 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 &&
			(!isIgnored(CompletionProposal.CONSTRUCTOR_INVOCATION, CompletionProposal.TYPE_REF) ||
					!isIgnored(CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION, CompletionProposal.TYPE_REF));
		

		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 = 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 &&
			(!isIgnored(CompletionProposal.CONSTRUCTOR_INVOCATION, CompletionProposal.TYPE_REF) ||
					!isIgnored(CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION, CompletionProposal.TYPE_REF));

		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 = 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() {


		inlineCompletion[inlineLength-1] = '}';
		return inlineCompletion;
	}
	private boolean isAllowingLongComputationProposals() {
		return this.monitor != null;
	}
	private boolean isForbidden(Binding binding) {
		for (int i = 0; i <= this.forbbidenBindingsPtr; i++) {
			if(this.forbbidenBindings[i] == binding) {

			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[] typeCompletion = 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 {
			typeCompletion = 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 = CharOperation.NO_CHAR;
		} else {
			completion = new char[] { '(', ')' };
		}
		
		InternalCompletionProposal typeProposal = createProposal(CompletionProposal.TYPE_REF, this.actualCompletionPosition);
		typeProposal.nameLookup = this.nameEnvironment.nameLookup;
		typeProposal.completionEngine = this;
		typeProposal.setDeclarationSignature(packageName);
		typeProposal.setSignature(createNonGenericTypeSignature(packageName, typeName));
		typeProposal.setPackageName(packageName);
		typeProposal.setTypeName(typeName);
		typeProposal.setCompletion(typeCompletion);
		typeProposal.setFlags(typeModifiers);
		typeProposal.setReplaceRange(this.startPosition - this.offset, this.endPosition - this.offset);
		typeProposal.setTokenRange(this.startPosition - this.offset, this.endPosition - this.offset);
		typeProposal.setRelevance(relevance);
		
		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(!isIgnored(CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION, CompletionProposal.TYPE_REF)) {
						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.setRequiredProposals(new CompletionProposal[]{typeProposal});
						proposal.setIsContructor(true);
						proposal.setCompletion(completion);
						proposal.setFlags(flags);
						proposal.setReplaceRange(this.endPosition - 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(!isIgnored(CompletionProposal.CONSTRUCTOR_INVOCATION, CompletionProposal.TYPE_REF)) {
						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.setRequiredProposals(new CompletionProposal[]{typeProposal});
						proposal.setIsContructor(true);
						proposal.setCompletion(completion);
						proposal.setFlags(flags);
						proposal.setReplaceRange(this.endPosition - 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(!isIgnored(CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION, CompletionProposal.TYPE_REF)) {
						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.setRequiredProposals(new CompletionProposal[]{typeProposal});
						proposal.setIsContructor(true);
						proposal.setCompletion(completion);
						proposal.setFlags(modifiers);
						proposal.setReplaceRange(this.endPosition - 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(!isIgnored(CompletionProposal.CONSTRUCTOR_INVOCATION, CompletionProposal.TYPE_REF)) {
						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.setRequiredProposals(new CompletionProposal[]{typeProposal});
						proposal.setIsContructor(true);
						proposal.setCompletion(completion);
						proposal.setFlags(modifiers);
						proposal.setReplaceRange(this.endPosition - 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 = null;
				}
				
				if ((typeModifiers & ClassFileConstants.AccAbstract) != 0) {
					this.noProposal = false;
					if(!isIgnored(CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION, CompletionProposal.TYPE_REF)) {
						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);
						if (parameterNames != null) {
							proposal.setParameterNames(parameterNames);
						} else {
							proposal.setHasNoParameterNamesFromIndex(true);
						}
						proposal.setName(simpleTypeName);
						proposal.setRequiredProposals(new CompletionProposal[]{typeProposal});
						proposal.setIsContructor(true);
						proposal.setCompletion(completion);
						proposal.setFlags(modifiers);
						proposal.setReplaceRange(this.endPosition - 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(!isIgnored(CompletionProposal.CONSTRUCTOR_INVOCATION, CompletionProposal.TYPE_REF)) {
						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);
						if (parameterNames != null) {
							proposal.setParameterNames(parameterNames);
						} else {
							proposal.setHasNoParameterNamesFromIndex(true);
						}
						proposal.setName(simpleTypeName);
						proposal.setRequiredProposals(new CompletionProposal[]{typeProposal});
						proposal.setIsContructor(true);
						proposal.setCompletion(completion);
						proposal.setFlags(modifiers);
						proposal.setReplaceRange(this.endPosition - 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) {

Lines 1-5 Link Here

(-)codeassist/org/eclipse/jdt/internal/codeassist/InternalCompletionProposal.java (-37 / +148 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2004, 2006 IBM Corporation and others.	2	* Copyright (c) 2004, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 18-30 Link Here
18	import org.eclipse.jdt.core.IAccessRule;	18	import org.eclipse.jdt.core.IAccessRule;
19	import org.eclipse.jdt.core.ICodeAssist;	19	import org.eclipse.jdt.core.ICodeAssist;
20	import org.eclipse.jdt.core.ICompilationUnit;	20	import org.eclipse.jdt.core.ICompilationUnit;
		21	import org.eclipse.jdt.core.IJavaElement;
21	import org.eclipse.jdt.core.IMethod;	22	import org.eclipse.jdt.core.IMethod;
		23	import org.eclipse.jdt.core.IPackageFragmentRoot;
22	import org.eclipse.jdt.core.IType;	24	import org.eclipse.jdt.core.IType;
23	import org.eclipse.jdt.core.JavaModelException;	25	import org.eclipse.jdt.core.JavaModelException;
24	import org.eclipse.jdt.core.Signature;	26	import org.eclipse.jdt.core.Signature;
25	import org.eclipse.jdt.core.compiler.CharOperation;	27	import org.eclipse.jdt.core.compiler.CharOperation;
		28	import org.eclipse.jdt.internal.compiler.env.IBinaryMethod;
		29	import org.eclipse.jdt.internal.compiler.env.IBinaryType;
26	import org.eclipse.jdt.internal.core.BinaryType;	30	import org.eclipse.jdt.internal.core.BinaryType;
		31	import org.eclipse.jdt.internal.core.JavaElement;
27	import org.eclipse.jdt.internal.core.NameLookup;	32	import org.eclipse.jdt.internal.core.NameLookup;
		33	import org.eclipse.jdt.internal.core.SourceMapper;
28		34
29	/**	35	/**
30	* Internal completion proposal	36	* Internal completion proposal
Lines 32-47 Link Here
32	*/	38	*/
33	public class InternalCompletionProposal extends CompletionProposal {	39	public class InternalCompletionProposal extends CompletionProposal {
34	private static Object NO_ATTACHED_SOURCE = new Object();	40	private static Object NO_ATTACHED_SOURCE = new Object();
		41	private static final int OPENED_BYNARY_TYPES_THRESHOLD = 100; // threshold of opened binary to avoid to harm java model cache
35		42
36	static final char[] ARG = "arg".toCharArray(); //$NON-NLS-1$
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		43
46	protected CompletionEngine completionEngine;	44	protected CompletionEngine completionEngine;
47	protected NameLookup nameLookup;	45	protected NameLookup nameLookup;
Lines 55-60 Link Here
55		53
56	protected char[] originalSignature;	54	protected char[] originalSignature;
57		55
		56	private boolean hasNoParameterNamesFromIndex = false;
58	private boolean updateCompletion = false;	57	private boolean updateCompletion = false;
59		58
60	protected int accessibility = IAccessRule.K_ACCESSIBLE;	59	protected int accessibility = IAccessRule.K_ACCESSIBLE;
Lines 179-212 Link Here
179	* Indicates whether parameter names have been computed.	178	* Indicates whether parameter names have been computed.
180	*/	179	*/
181	private boolean parameterNamesComputed = false;	180	private boolean parameterNamesComputed = false;
		181
		182	protected char[][] findConstructorParameterNames(char[] declaringTypePackageName, char[] declaringTypeName, char[] selector, char[][] paramTypeNames){
		183	if(paramTypeNames == null \|\| declaringTypeName == null) return null;
182		184
183	protected char[][] createDefaultParameterNames(int length) {	185	char[][] parameters = null;
184	char[][] parameters;	186	int length = paramTypeNames.length;
185	switch (length) {	187
186	case 0 :	188	char[] tName = CharOperation.concat(declaringTypePackageName,declaringTypeName,'.');
187	parameters = new char[length][];	189	Object cachedType = this.completionEngine.typeCache.get(tName);
188	break;	190
189	case 1 :	191	IType type = null;
190	parameters = ARGS1;	192	if(cachedType != null) {
191	break;	193	if(cachedType != NO_ATTACHED_SOURCE && cachedType instanceof BinaryType) {
192	case 2 :	194	type = (BinaryType)cachedType;
193	parameters = ARGS2;	195	}
194	break;	196	} else {
195	case 3 :	197	// TODO (david) shouldn't it be NameLookup.ACCEPT_ALL ?
196	parameters = ARGS3;	198	NameLookup.Answer answer = this.nameLookup.findType(new String(tName),
197	break;	199	false,
198	case 4 :	200	NameLookup.ACCEPT_CLASSES & NameLookup.ACCEPT_INTERFACES,
199	parameters = ARGS4;	201	true/* consider secondary types */,
200	break;	202	false/* do NOT wait for indexes */,
201	default :	203	false/don't check restrictions/,
202	parameters = new char[length][];	204	null);
203	for (int i = 0; i < length; i++) {	205	type = answer == null ? null : answer.type;
204	parameters[i] = CharOperation.concat(ARG, String.valueOf(i).toCharArray());	206	if(type instanceof BinaryType){
		207	this.completionEngine.typeCache.put(tName, type);
		208	} else {
		209	type = null;
		210	}
		211	}
		212
		213	if(type != null) {
		214	String[] args = new String[length];
		215	for(int i = 0; i< length ; i++){
		216	args[i] = new String(paramTypeNames[i]);
		217	}
		218	IMethod method = type.getMethod(new String(selector),args);
		219
		220	if (this.hasNoParameterNamesFromIndex) {
		221	IPackageFragmentRoot packageFragmentRoot = (IPackageFragmentRoot)type.getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);
		222	if (packageFragmentRoot.isArchive() \|\|
		223	this.completionEngine.openedBinaryTypes < OPENED_BYNARY_TYPES_THRESHOLD) {
		224	SourceMapper mapper = ((JavaElement)method).getSourceMapper();
		225	if (mapper != null) {
		226	try {
		227	char[][] paramNames = mapper.getMethodParameterNames(method);
		228
		229	// map source and try to find parameter names
		230	if(paramNames == null) {
		231	this.completionEngine.openedBinaryTypes++;
		232	IBinaryType info = (IBinaryType) ((BinaryType) type).getElementInfo();
		233	char[] source = mapper.findSource(type, info);
		234	if (source != null){
		235	mapper.mapSource(type, source, info);
		236	}
		237	paramNames = mapper.getMethodParameterNames(method);
		238	}
		239
		240	if(paramNames != null) {
		241	parameters = paramNames;
		242	}
		243	} catch(JavaModelException e){
		244	//parameters == null;
		245	}
		246	}
205	}	247	}
206	break;	248	} else {
		249	try{
		250	IBinaryMethod info = (IBinaryMethod) ((JavaElement)method).getElementInfo();
		251	char[][] argumentNames = info.getArgumentNames();
		252	if (argumentNames != null && argumentNames.length == length) {
		253	parameters = argumentNames;
		254	}
		255	} catch(JavaModelException e){
		256	//parameters == null;
		257	}
		258
		259	try{
		260	parameters = new char[length][];
		261	String[] params = method.getParameterNames();
		262	for(int i = 0; i< length ; i++){
		263	parameters[i] = params[i].toCharArray();
		264	}
		265	} catch(JavaModelException e){
		266	parameters = null;
		267	}
		268	}
		269	}
		270
		271	// default parameters name
		272	if(parameters == null) {
		273	parameters = CompletionEngine.createDefaultParameterNames(length);
207	}	274	}
		275
208	return parameters;	276	return parameters;
209	}	277	}
		278
210	protected char[][] findMethodParameterNames(char[] declaringTypePackageName, char[] declaringTypeName, char[] selector, char[][] paramTypeNames){	279	protected char[][] findMethodParameterNames(char[] declaringTypePackageName, char[] declaringTypeName, char[] selector, char[][] paramTypeNames){
211	if(paramTypeNames == null \|\| declaringTypeName == null) return null;	280	if(paramTypeNames == null \|\| declaringTypeName == null) return null;
212		281
Lines 257-263 Link Here
257		326
258	// default parameters name	327	// default parameters name
259	if(parameters == null) {	328	if(parameters == null) {
260	parameters = createDefaultParameterNames(length);	329	parameters = CompletionEngine.createDefaultParameterNames(length);
261	}	330	}
262		331
263	return parameters;	332	return parameters;
Lines 1206-1211 Link Here
1206	public void setFlags(int flags) {	1275	public void setFlags(int flags) {
1207	this.flags = flags;	1276	this.flags = flags;
1208	}	1277	}
		1278
		1279	public void setHasNoParameterNamesFromIndex(boolean hasNoParameterNamesFromIndex) {
		1280	this.hasNoParameterNamesFromIndex = hasNoParameterNamesFromIndex;
		1281	}
1209		1282
1210	/**	1283	/**
1211	* Returns the required completion proposals.	1284	* Returns the required completion proposals.
Lines 1312-1318 Link Here
1312	} catch(IllegalArgumentException e) {	1385	} catch(IllegalArgumentException e) {
1313	// protection for invalid signature	1386	// protection for invalid signature
1314	if(this.parameterTypeNames != null) {	1387	if(this.parameterTypeNames != null) {
1315	this.parameterNames = createDefaultParameterNames(this.parameterTypeNames.length);	1388	this.parameterNames = CompletionEngine.createDefaultParameterNames(this.parameterTypeNames.length);
		1389	} else {
		1390	this.parameterNames = null;
		1391	}
		1392	}
		1393	break;
		1394	case ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION:
		1395	try {
		1396	this.parameterNames = findConstructorParameterNames(
		1397	this.declarationPackageName,
		1398	this.declarationTypeName,
		1399	CharOperation.lastSegment(this.declarationTypeName, '.'),
		1400	Signature.getParameterTypes(this.originalSignature == null ? this.signature : this.originalSignature));
		1401	} catch(IllegalArgumentException e) {
		1402	// protection for invalid signature
		1403	if(this.parameterTypeNames != null) {
		1404	this.parameterNames = CompletionEngine.createDefaultParameterNames(this.parameterTypeNames.length);
1316	} else {	1405	} else {
1317	this.parameterNames = null;	1406	this.parameterNames = null;
1318	}	1407	}
Lines 1329-1335 Link Here
1329	} catch(IllegalArgumentException e) {	1418	} catch(IllegalArgumentException e) {
1330	// protection for invalid signature	1419	// protection for invalid signature
1331	if(this.parameterTypeNames != null) {	1420	if(this.parameterTypeNames != null) {
1332	this.parameterNames = createDefaultParameterNames(this.parameterTypeNames.length);	1421	this.parameterNames = CompletionEngine.createDefaultParameterNames(this.parameterTypeNames.length);
		1422	} else {
		1423	this.parameterNames = null;
		1424	}
		1425	}
		1426	break;
		1427	case CONSTRUCTOR_INVOCATION:
		1428	try {
		1429	this.parameterNames = findConstructorParameterNames(
		1430	this.declarationPackageName,
		1431	this.declarationTypeName,
		1432	this.name,
		1433	Signature.getParameterTypes(this.originalSignature == null ? this.signature : this.originalSignature));
		1434	} catch(IllegalArgumentException e) {
		1435	// protection for invalid signature
		1436	if(this.parameterTypeNames != null) {
		1437	this.parameterNames = CompletionEngine.createDefaultParameterNames(this.parameterTypeNames.length);
1333	} else {	1438	} else {
1334	this.parameterNames = null;	1439	this.parameterNames = null;
1335	}	1440	}
Lines 1345-1351 Link Here
1345	} catch(IllegalArgumentException e) {	1450	} catch(IllegalArgumentException e) {
1346	// protection for invalid signature	1451	// protection for invalid signature
1347	if(this.parameterTypeNames != null) {	1452	if(this.parameterTypeNames != null) {
1348	this.parameterNames = createDefaultParameterNames(this.parameterTypeNames.length);	1453	this.parameterNames = CompletionEngine.createDefaultParameterNames(this.parameterTypeNames.length);
1349	} else {	1454	} else {
1350	this.parameterNames = null;	1455	this.parameterNames = null;
1351	}	1456	}
Lines 1623-1628 Link Here
1623	case CompletionProposal.FIELD_REF_WITH_CASTED_RECEIVER :	1728	case CompletionProposal.FIELD_REF_WITH_CASTED_RECEIVER :
1624	buffer.append("FIELD_REF_WITH_CASTED_RECEIVER"); //$NON-NLS-1$	1729	buffer.append("FIELD_REF_WITH_CASTED_RECEIVER"); //$NON-NLS-1$
1625	break;	1730	break;
		1731	case CompletionProposal.CONSTRUCTOR_INVOCATION :
		1732	buffer.append("CONSTRUCTOR_INVOCATION"); //$NON-NLS-1$
		1733	break;
		1734	case CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION :
		1735	buffer.append("ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION"); //$NON-NLS-1$
		1736	break;
1626	default :	1737	default :
1627	buffer.append("PROPOSAL"); //$NON-NLS-1$	1738	buffer.append("PROPOSAL"); //$NON-NLS-1$
1628	break;	1739	break;




/*******************************************************************************
 * Copyright (c) 2000, 2009 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

 * 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.
	 *




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

			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
			}




/*******************************************************************************
 * Copyright (c) 2000, 2009 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

		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 ?




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

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




	 * An <code>offset</code> of -1 indicates to code assist at the beginning of this
	 * compilation unit.
	 * <p>
	 * <p>
	 * If {@link IProgressMonitor} is not <code>null</code> then some proposals which
	 * can be very long to compute are proposed. To avoid that the code assist operation
	 * take too much time a {@link IProgressMonitor} which automatically cancel the code
	 * assist operation when a specified amount of time is reached could be used.
	 * 
	 * <pre>
	 * new IProgressMonitor() {
	 *     private final static int TIMEOUT = 500; //ms
	 *     private long endTime;
	 *     public void beginTask(String name, int totalWork) {
	 *         fEndTime= System.currentTimeMillis() + TIMEOUT;
	 *     }
	 *     public boolean isCanceled() {
	 *         return endTime <= System.currentTimeMillis();
	 *     }
	 *     ...
	 * };
	 * </pre>
	 * <p>
	 *
	 * @param offset the given offset position
	 * @param requestor the given completion requestor

	 * Note that if a working copy is empty, it will be as if the original compilation
	 * unit had been deleted.
	 * </p>
	 * <p>
	 * If {@link IProgressMonitor} is not <code>null</code> then some proposals which
	 * can be very long to compute are proposed. To avoid that the code assist operation
	 * take too much time a {@link IProgressMonitor} which automatically cancel the code
	 * assist operation when a specified amount of time is reached could be used.
	 * 
	 * <pre>
	 * new IProgressMonitor() {
	 *     private final static int TIMEOUT = 500; //ms
	 *     private long endTime;
	 *     public void beginTask(String name, int totalWork) {
	 *         fEndTime= System.currentTimeMillis() + TIMEOUT;
	 *     }
	 *     public boolean isCanceled() {
	 *         return endTime <= System.currentTimeMillis();
	 *     }
	 *     ...
	 * };
	 * </pre>
	 * <p>
	 *
	 * @param offset the given offset position
	 * @param requestor the given completion requestor




	 * If the type has access to its source code and the insertion position is valid,
	 * then completion is performed against the source. Otherwise the completion is performed
	 * against the type structure and the given locals variables.
	 * <p>
	 * If {@link IProgressMonitor} is not <code>null</code> then some proposals which
	 * can be very long to compute are proposed. To avoid that the code assist operation
	 * take too much time a {@link IProgressMonitor} which automatically cancel the code
	 * assist operation when a specified amount of time is reached could be used.
	 * 
	 * <pre>
	 * new IProgressMonitor() {
	 *     private final static int TIMEOUT = 500; //ms
	 *     private long endTime;
	 *     public void beginTask(String name, int totalWork) {
	 *         fEndTime= System.currentTimeMillis() + TIMEOUT;
	 *     }
	 *     public boolean isCanceled() {
	 *         return endTime <= System.currentTimeMillis();
	 *     }
	 *     ...
	 * };
	 * </pre>
	 * <p>
	 *
	 * @param snippet the code snippet
	 * @param insertion the position with in source where the snippet

	 * then completion is performed against the source. Otherwise the completion is performed
	 * against the type structure and the given locals variables.
	 * </p>
	 * <p>
	 * If {@link IProgressMonitor} is not <code>null</code> then some proposals which
	 * can be very long to compute are proposed. To avoid that the code assist operation
	 * take too much time a {@link IProgressMonitor} which automatically cancel the code
	 * assist operation when a specified amount of time is reached could be used.
	 * 
	 * <pre>
	 * new IProgressMonitor() {
	 *     private final static int TIMEOUT = 500; //ms
	 *     private long endTime;
	 *     public void beginTask(String name, int totalWork) {
	 *         fEndTime= System.currentTimeMillis() + TIMEOUT;
	 *     }
	 *     public boolean isCanceled() {
	 *         return endTime <= System.currentTimeMillis();
	 *     }
	 *     ...
	 * };
	 * </pre>
	 * <p>
	 *
	 * @param snippet the code snippet
	 * @param insertion the position with in source where the snippet




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

	/**
	 * 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> if List is a class that is not abstract.
	 * <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 completion operation is called with a {@link IProgressMonitor}
	 * (eg. {@link ICodeAssist#codeComplete(int, CompletionRequestor, IProgressMonitor)})
	 * </p>
	 *
	 * @see #getKind()
	 * 
	 * @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> if List is an interface or abstract class.
	 * <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 completion operation is called with a {@link IProgressMonitor}
	 * (eg. {@link ICodeAssist#codeComplete(int, CompletionRequestor, IProgressMonitor)})
	 * </p>
	 *
	 * @see #getKind()
	 * 
	 * @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

	 *    <li><code>TYPE_REF</code></li>
	 *   </ul>
	 *  </li>
	 *  <li><code>CONSTRUCTOR_INVOCATION</code> - The allowed required proposals for this kind are:
	 *   <ul>
	 *    <li><code>TYPE_REF</code></li>
	 *   </ul>
	 *  </li>
	 *  <li><code>ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION</code> - The allowed required proposals for this kind are:
	 *   <ul>
	 *    <li><code>TYPE_REF</code></li>
	 *   </ul>
	 *  </li>
	 * </ul>
	 * </p>
	 * <p>

Lines 1-5 Link Here

(-)model/org/eclipse/jdt/core/CompletionRequestor.java (-2 / +2 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2004, 2008 IBM Corporation and others.	2	* Copyright (c) 2004, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 174-180 Link Here
174		174
175	return 0 != (this.requiredProposalAllowSet[proposalKind] & (1 << requiredProposalKind));	175	return 0 != (this.requiredProposalAllowSet[proposalKind] & (1 << requiredProposalKind));
176	}	176	}
177		177
178	/**	178	/**
179	* Sets whether a proposal of a given kind with a required proposal	179	* Sets whether a proposal of a given kind with a required proposal
180	* of the given kind is allowed.	180	* of the given kind is allowed.

Lines 1-5 Link Here

(-)codeassist/org/eclipse/jdt/internal/codeassist/impl/Engine.java (-11 / +23 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.	2	* Copyright (c) 2000, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 65-72 Link Here
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,




/*******************************************************************************
 * Copyright (c) 2000, 2009 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

	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;
}




	 * <p>
	 * Note that code completion does not involve evaluation.
	 * <p>
	 * <p>
	 * If {@link IProgressMonitor} is not <code>null</code> then some proposals which
	 * can be very long to compute are proposed. To avoid that the code assist operation
	 * take too much time a {@link IProgressMonitor} which automatically cancel the code
	 * assist operation when a specified amount of time is reached could be used.
	 * 
	 * <pre>
	 * new IProgressMonitor() {
	 *     private final static int TIMEOUT = 500; //ms
	 *     private long endTime;
	 *     public void beginTask(String name, int totalWork) {
	 *         fEndTime= System.currentTimeMillis() + TIMEOUT;
	 *     }
	 *     public boolean isCanceled() {
	 *         return endTime <= System.currentTimeMillis();
	 *     }
	 *     ...
	 * };
	 * </pre>
	 * <p>
	 *
	 * @param codeSnippet the code snippet to complete in
	 * @param position the character position in the code snippet to complete at,

	 * <p>
	 * Note that code completion does not involve evaluation.
	 * <p>
	 * <p>
	 * If {@link IProgressMonitor} is not <code>null</code> then some proposals which
	 * can be very long to compute are proposed. To avoid that the code assist operation
	 * take too much time a {@link IProgressMonitor} which automatically cancel the code
	 * assist operation when a specified amount of time is reached could be used.
	 * 
	 * <pre>
	 * new IProgressMonitor() {
	 *     private final static int TIMEOUT = 500; //ms
	 *     private long endTime;
	 *     public void beginTask(String name, int totalWork) {
	 *         fEndTime= System.currentTimeMillis() + TIMEOUT;
	 *     }
	 *     public boolean isCanceled() {
	 *         return endTime <= System.currentTimeMillis();
	 *     }
	 *     ...
	 * };
	 * </pre>
	 * <p>
	 *
	 * @param codeSnippet the code snippet to complete in
	 * @param position the character position in the code snippet to complete at,




/*******************************************************************************
 * Copyright (c) 2000, 2009 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

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>.




/*******************************************************************************
 * Copyright (c) 2000, 2009 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

		}
		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 1-5 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/ConstructorPattern.java (-20 / +261 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.	2	* Copyright (c) 2000, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 19-24 Link Here
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;
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2009 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

	);
}

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");
	}
}

}




/*******************************************************************************
 * Copyright (c) 2000, 2009 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.jdt.core.IAccessRule;
import org.eclipse.jdt.core.IClasspathAttribute;

		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, false, false, true, true);
		requestor.allowAllRequiredProposals();
		NullProgressMonitor monitor = new NullProgressMonitor();

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner, monitor);
	    
	    assertResults(
			"AllConstructors01[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors01;, ()V, AllConstructors01, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors01[TYPE_REF]{p6930.AllConstructors01, p6930, Lp6930.AllConstructors01;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors01[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors01;, (Ljava.lang.Object;)V, AllConstructors01, (o), "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors01[TYPE_REF]{p6930.AllConstructors01, p6930, Lp6930.AllConstructors01;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors01[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors01;, (Ljava.lang.Object;Ljava.lang.String;)V, AllConstructors01, (o, s), "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors01[TYPE_REF]{p6930.AllConstructors01, p6930, Lp6930.AllConstructors01;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors01b[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors01b;, ()V, AllConstructors01b, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors01b[TYPE_REF]{p6930.AllConstructors01b, p6930, Lp6930.AllConstructors01b;, null, 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, false, false, true, true);
		requestor.allowAllRequiredProposals();
		NullProgressMonitor monitor = new NullProgressMonitor();

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner, monitor);
	    
	    assertResults(
			"AllConstructors02[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors02;, ()V, AllConstructors02, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors02[TYPE_REF]{p6930.AllConstructors02, p6930, Lp6930.AllConstructors02;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors02[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors02;, (Ljava.lang.Object;)V, AllConstructors02, (o), "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors02[TYPE_REF]{p6930.AllConstructors02, p6930, Lp6930.AllConstructors02;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors02[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors02;, (Ljava.lang.Object;Ljava.lang.String;)V, AllConstructors02, (o, s), "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors02[TYPE_REF]{p6930.AllConstructors02, p6930, Lp6930.AllConstructors02;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors02b[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors02b;, ()V, AllConstructors02b, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors02b[TYPE_REF]{p6930.AllConstructors02b, p6930, Lp6930.AllConstructors02b;, null, 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, false, false, true, true);
		requestor.allowAllRequiredProposals();
		NullProgressMonitor monitor = new NullProgressMonitor();

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner, monitor);
	    
	    assertResults(
			"AllConstructors03[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors03;, ()V, AllConstructors03, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors03[TYPE_REF]{p6930.AllConstructors03, p6930, Lp6930.AllConstructors03;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors03[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors03;, (Ljava.lang.Object;)V, AllConstructors03, (o), "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors03[TYPE_REF]{p6930.AllConstructors03, p6930, Lp6930.AllConstructors03;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors03[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors03;, (Ljava.lang.Object;Ljava.lang.String;)V, AllConstructors03, (o, s), "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors03[TYPE_REF]{p6930.AllConstructors03, p6930, Lp6930.AllConstructors03;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors03b[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors03b;, ()V, AllConstructors03b, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors03b[TYPE_REF]{p6930.AllConstructors03b, p6930, Lp6930.AllConstructors03b;, null, 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, false, false, true, true);
		requestor.allowAllRequiredProposals();
		NullProgressMonitor monitor = new NullProgressMonitor();

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner, monitor);
	    
	    assertResults(
			"AllConstructors04a[CONSTRUCTOR_INVOCATION]{(), Ltest.AllConstructors04a;, ()V, AllConstructors04a, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors04a[TYPE_REF]{AllConstructors04a, test, Ltest.AllConstructors04a;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors04c[CONSTRUCTOR_INVOCATION]{(), Ltest.Test$AllConstructors04c;, ()V, AllConstructors04c, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"   Test.AllConstructors04c[TYPE_REF]{AllConstructors04c, test, Ltest.Test$AllConstructors04c;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors04e[CONSTRUCTOR_INVOCATION]{(), LAllConstructors04e;, ()V, AllConstructors04e, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors04e[TYPE_REF]{AllConstructors04e, null, LAllConstructors04e;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors04g[CONSTRUCTOR_INVOCATION]{(), Ltest.AllConstructors04g;, ()V, AllConstructors04g, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors04g[TYPE_REF]{AllConstructors04g, test, Ltest.AllConstructors04g;, null, 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, false, false, true, true);
		requestor.allowAllRequiredProposals();
		NullProgressMonitor monitor = new NullProgressMonitor();

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner, monitor);
	    
	    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]{(), Ltest.AllConstructors05a;, ()V, AllConstructors05a, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors05a[TYPE_REF]{AllConstructors05a, test, Ltest.AllConstructors05a;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors05c[CONSTRUCTOR_INVOCATION]{(), Ltest.Test$AllConstructors05c;, ()V, AllConstructors05c, 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)+"}\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]{(), Ltest.AllConstructors05g;, ()V, AllConstructors05g, 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" +
			"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, false, false, true, true);
		requestor.allowAllRequiredProposals();
		NullProgressMonitor monitor = new NullProgressMonitor();

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner, monitor);
	    
	    assertResults(
			"AllConstructors06a[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors06a;, ()V, AllConstructors06a, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors06a[TYPE_REF]{AllConstructors06a, p6930, Lp6930.AllConstructors06a;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors06b[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors06b;, ()V, AllConstructors06b, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors06b[TYPE_REF]{AllConstructors06b, p6930, Lp6930.AllConstructors06b;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors06c[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors06c;, ()V, AllConstructors06c, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors06c[TYPE_REF]{AllConstructors06c, p6930, Lp6930.AllConstructors06c;, null, 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, false, false, true, true);
		requestor.allowAllRequiredProposals();
		NullProgressMonitor monitor = new NullProgressMonitor();

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner, monitor);
	    
	    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]{(), Lp6930.AllConstructors07a;, ()V, AllConstructors07a, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors07a[TYPE_REF]{AllConstructors07a, p6930, Lp6930.AllConstructors07a;, null, 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]{(), Lp6930.AllConstructors07d;, ()V, AllConstructors07d, 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)+"}",
			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, false, false, true, true);
		requestor.allowAllRequiredProposals();
		NullProgressMonitor monitor = new NullProgressMonitor();

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner, monitor);
	    
	    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]{(), Lp6930.AllConstructors08d;, ()V, AllConstructors08d, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors08d[TYPE_REF]{p6930.AllConstructors08d, p6930, Lp6930.AllConstructors08d;, null, 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]{(), Lp6930.AllConstructors08a;, ()V, AllConstructors08a, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + 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)+"}",
			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, false, false, true, true);
		requestor.allowAllRequiredProposals();
		NullProgressMonitor monitor = new NullProgressMonitor();

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner, monitor);
	    
	    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]{(), Lp6930.AllConstructors09a;, ()V, AllConstructors09a, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors09a[TYPE_REF]{p6930.AllConstructors09a, p6930, Lp6930.AllConstructors09a;, null, 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]{(), Lp6930.AllConstructors09d;, ()V, AllConstructors09d, 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.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]{(), Lp6930.AllConstructors09d$AllConstructors09f;, ()V, AllConstructors09f, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + 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)+"}",
			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, false, false, true, true);
		requestor.allowAllRequiredProposals();
		NullProgressMonitor monitor = new NullProgressMonitor();

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner, monitor);
	    
	    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]{(), Lp6930.AllConstructors10a;, ()V, AllConstructors10a, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors10a[TYPE_REF]{p6930.AllConstructors10a, p6930, Lp6930.AllConstructors10a;, null, 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]{(), Lp6930.AllConstructors10d;, ()V, AllConstructors10d, 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" +
			"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]{(), Lp6930.AllConstructors10a$AllConstructors10c;, ()V, AllConstructors10c, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + 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" +
			"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]{(), Lp6930.AllConstructors10d$AllConstructors10f;, ()V, AllConstructors10f, 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)+"}",
			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, false, false, true, true);
		requestor.allowAllRequiredProposals();
		NullProgressMonitor monitor = new NullProgressMonitor();

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "new ";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner, monitor);
	    
	    assertResults(
			"Test[CONSTRUCTOR_INVOCATION]{(), Ltest.Test;, ()V, Test, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"   Test[TYPE_REF]{Test, test, Ltest.Test;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors11a[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors11a;, ()V, AllConstructors11a, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_EXACT_EXPECTED_TYPE + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors11a[TYPE_REF]{p6930.AllConstructors11a, p6930, Lp6930.AllConstructors11a;, null, 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, false, false, true, true);
		requestor.allowAllRequiredProposals();
		NullProgressMonitor monitor = new NullProgressMonitor();

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "new ";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner, monitor);
	    
	    assertResults(
			"Test[CONSTRUCTOR_INVOCATION]{(), Ltest.Test;, ()V, Test, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"   Test[TYPE_REF]{Test, test, Ltest.Test;, null, 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]{(), Lp6930.AllConstructors12a;, ()V, AllConstructors12a, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_EXACT_EXPECTED_TYPE + 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)+"}",
			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, false, false, true, true);
		requestor.allowAllRequiredProposals();
		NullProgressMonitor monitor = new NullProgressMonitor();

	    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, monitor);
	    
	    assertResults(
			"AllConstructors13a[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors13a;, ()V, AllConstructors13a, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_EXACT_EXPECTED_TYPE + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors13a[TYPE_REF]{p6930.AllConstructors13a, p6930, Lp6930.AllConstructors13a;, null, 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, false, false, true, true);
		requestor.allowAllRequiredProposals();
		NullProgressMonitor monitor = new NullProgressMonitor();

	    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, monitor);
	    
	    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]{(), Lp6930.AllConstructors14a;, ()V, AllConstructors14a, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_EXACT_EXPECTED_TYPE + R_NON_RESTRICTED)+"}\n" +
			"   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)+"}",
			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, false, false, true, true);
		requestor.allowAllRequiredProposals();
		NullProgressMonitor monitor = new NullProgressMonitor();

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner, monitor);
	    
	    assertResults(
			"AllConstructors15a[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors15a;, ()V, AllConstructors15a, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors15a[TYPE_REF]{p6930.AllConstructors15a, p6930, Lp6930.AllConstructors15a;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors15b[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors15b;, ()V, AllConstructors15b, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors15b[TYPE_REF]{p6930.AllConstructors15b, p6930, Lp6930.AllConstructors15b;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors15c[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors15c;, ()V, AllConstructors15c, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors15c[TYPE_REF]{p6930.AllConstructors15c, p6930, Lp6930.AllConstructors15c;, null, 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, false, false, true, true);
		requestor.allowAllRequiredProposals();
		NullProgressMonitor monitor = new NullProgressMonitor();

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner, monitor);
	    
	    assertResults(
			"AllConstructors16a[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors16a;, ()V, AllConstructors16a, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors16a[TYPE_REF]{p6930.AllConstructors16a, p6930, Lp6930.AllConstructors16a;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors16b[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors16b;, ()V, AllConstructors16b, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors16b[TYPE_REF]{p6930.AllConstructors16b, p6930, Lp6930.AllConstructors16b;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors16c[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors16c;, ()V, AllConstructors16c, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors16c[TYPE_REF]{p6930.AllConstructors16c, p6930, Lp6930.AllConstructors16c;, null, 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, false, false, true, true);
		requestor.allowAllRequiredProposals();
		NullProgressMonitor monitor = new NullProgressMonitor();

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner, monitor);
	    
	    assertResults(
			"AllConstructors17a[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors17a;, (Ljava.util.Collection<Ljava.lang.Object;>;)V, AllConstructors17a, (o), "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors17a[TYPE_REF]{p6930.AllConstructors17a, p6930, Lp6930.AllConstructors17a;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors17b[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors17b;, (Ljava.util.Collection<Ljava.lang.Object;>;)V, AllConstructors17b, (o), "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors17b[TYPE_REF]{p6930.AllConstructors17b, p6930, Lp6930.AllConstructors17b;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors17c[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors17c;, (Ljava.util.Collection<Ljava.lang.Object;>;)V, AllConstructors17c, (o), "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors17c[TYPE_REF]{p6930.AllConstructors17c, p6930, Lp6930.AllConstructors17c;, null, null, "+(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, false, false, true, true);
		requestor.allowAllRequiredProposals();
		NullProgressMonitor monitor = new NullProgressMonitor();

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner, monitor);
	    
	    assertResults(
			"AllConstructors18a[ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors18a;, ()V, AllConstructors18a, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors18a[TYPE_REF]{p6930.AllConstructors18a, p6930, Lp6930.AllConstructors18a;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors18b[ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors18b;, ()V, AllConstructors18b, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors18b[TYPE_REF]{p6930.AllConstructors18b, p6930, Lp6930.AllConstructors18b;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors18c[ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors18c;, ()V, AllConstructors18c, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors18c[TYPE_REF]{p6930.AllConstructors18c, p6930, Lp6930.AllConstructors18c;, null, 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, false, false, true, true);
		requestor.allowAllRequiredProposals();
		NullProgressMonitor monitor = new NullProgressMonitor();

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner, monitor);
	    
	    assertResults(
			"AllConstructors19a[ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors19a;, ()V, AllConstructors19a, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors19a[TYPE_REF]{AllConstructors19a, p6930, Lp6930.AllConstructors19a;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors19b[ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors19b;, ()V, AllConstructors19b, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors19b[TYPE_REF]{AllConstructors19b, p6930, Lp6930.AllConstructors19b;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors19c[ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors19c;, ()V, AllConstructors19c, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors19c[TYPE_REF]{AllConstructors19c, p6930, Lp6930.AllConstructors19c;, 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, false, false, true, true);
		requestor.allowAllRequiredProposals();
		NullProgressMonitor monitor = new NullProgressMonitor();

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner, monitor);
	    
	    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, false, false, true, true);
		requestor.allowAllRequiredProposals();
		NullProgressMonitor monitor = new NullProgressMonitor();

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner, monitor);
	    
	    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, false, false, true, true);
		requestor.allowAllRequiredProposals();
		NullProgressMonitor monitor = new NullProgressMonitor();

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner, monitor);
	    
	    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, false, false, true, true);
		requestor.allowAllRequiredProposals();
		NullProgressMonitor monitor = new NullProgressMonitor();

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner, monitor);
	    
	    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, false, false, true, true);
		requestor.allowAllRequiredProposals();
		NullProgressMonitor monitor = new NullProgressMonitor();

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner, monitor);
	    
	    assertResults(
			"AllConstructors24a[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors24a;, ()V, AllConstructors24a, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors24a[TYPE_REF]{p6930.AllConstructors24a, p6930, Lp6930.AllConstructors24a;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors24b[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors24b;, ()V, AllConstructors24b, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors24b[TYPE_REF]{p6930.AllConstructors24b, p6930, Lp6930.AllConstructors24b;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors24c[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors24c;, ()V, AllConstructors24c, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors24c[TYPE_REF]{p6930.AllConstructors24c, p6930, Lp6930.AllConstructors24c;, null, 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, false, false, true, true);
		requestor.allowAllRequiredProposals();
		NullProgressMonitor monitor = new NullProgressMonitor();

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner, monitor);
	    
	    assertResults(
			"AllConstructors25a[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors25a;, ()V, AllConstructors25a, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors25a[TYPE_REF]{AllConstructors25a, p6930, Lp6930.AllConstructors25a;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors25b[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors25b;, ()V, AllConstructors25b, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors25b[TYPE_REF]{AllConstructors25b, p6930, Lp6930.AllConstructors25b;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors25c[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors25c;, ()V, AllConstructors25c, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors25c[TYPE_REF]{AllConstructors25c, p6930, Lp6930.AllConstructors25c;, 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_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, false, false, true, true);
		requestor.allowAllRequiredProposals();
		NullProgressMonitor monitor = new NullProgressMonitor();

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner, monitor);
	    
	    assertResults(
			"AllConstructors26b[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors26a$AllConstructors26b;, (I)V, AllConstructors26b, (i), "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_UNQUALIFIED + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors26a.AllConstructors26b[TYPE_REF]{AllConstructors26b, p6930, Lp6930.AllConstructors26a$AllConstructors26b;, null, null, "+(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, false, false, true, true);
		requestor.allowAllRequiredProposals();
		NullProgressMonitor monitor = new NullProgressMonitor();

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner, monitor);
	    
	    assertResults(
			"AllConstructors27b[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors27a$AllConstructors27b;, (I)V, AllConstructors27b, (i), "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors27a.AllConstructors27b[TYPE_REF]{AllConstructors27b, p6930, Lp6930.AllConstructors27a$AllConstructors27b;, null, null, "+(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, false, false, true, true);
		requestor.allowAllRequiredProposals();
		NullProgressMonitor monitor = new NullProgressMonitor();

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner, monitor);
	    
	    assertResults(
			"AllConstructors28a[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors28a;, (I)V, AllConstructors28a, (i), "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors28a[TYPE_REF]{AllConstructors28a, p6930, Lp6930.AllConstructors28a;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors28b[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors28b;, (I)V, AllConstructors28b, (i), "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors28b[TYPE_REF]{AllConstructors28b, p6930, Lp6930.AllConstructors28b;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_NON_RESTRICTED)+"}",
			requestor.getResults());
	} finally {
		deleteProject("P");
	}
}
public void testBug6930_29() 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" +
			"}"
		}, 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" +
				"    p6930.AllConstructors02 var = new AllConstructors\n" +
				"  }\n" +
				"}");

		// do completion
		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, false, true, true);
		requestor.allowAllRequiredProposals();
		NullProgressMonitor monitor = new NullProgressMonitor();

	    String str = this.workingCopies[0].getSource();
	    String completeBehind = "AllConstructors";
	    int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	    this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner, monitor);
	    
	    assertResults(
			"AllConstructors02[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors02;, ()V, AllConstructors02, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_EXACT_EXPECTED_TYPE + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors02[TYPE_REF]{p6930.AllConstructors02, p6930, Lp6930.AllConstructors02;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_EXACT_EXPECTED_TYPE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors02[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors02;, (Ljava.lang.Object;)V, AllConstructors02, (o), "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_EXACT_EXPECTED_TYPE + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors02[TYPE_REF]{p6930.AllConstructors02, p6930, Lp6930.AllConstructors02;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_EXACT_EXPECTED_TYPE + R_NON_RESTRICTED)+"}\n" +
			"AllConstructors02[CONSTRUCTOR_INVOCATION]{(), Lp6930.AllConstructors02;, (Ljava.lang.Object;Ljava.lang.String;)V, AllConstructors02, (o, s), "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_EXACT_EXPECTED_TYPE + R_NON_RESTRICTED)+"}\n" +
			"   AllConstructors02[TYPE_REF]{p6930.AllConstructors02, p6930, Lp6930.AllConstructors02;, null, null, "+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_EXACT_EXPECTED_TYPE + R_NON_RESTRICTED)+"}",
			requestor.getResults());
	} finally {
		deleteProject("P");
	}
}
public void testBug79288() throws Exception {
	try {
		// create variable




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

		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;

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

Lines 1-5 Link Here

(-)src/org/eclipse/jdt/core/tests/model/AbstractJavaSearchTests.java (-1 / +101 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.	2	* Copyright (c) 2000, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 17-32 Link Here
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 1-5 Link Here

(-)src/org/eclipse/jdt/core/tests/model/AbstractJavaModelTests.java (-1 / +5 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.	2	* Copyright (c) 2000, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 1128-1133 Link Here
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 92-97 Link Here

(-)model/org/eclipse/jdt/core/ICodeAssist.java (+40 lines)
92	* An <code>offset</code> of -1 indicates to code assist at the beginning of this	92	* An <code>offset</code> of -1 indicates to code assist at the beginning of this
93	* compilation unit.	93	* compilation unit.
94	* <p>	94	* <p>
		95	* <p>
		96	* If {@link IProgressMonitor} is not <code>null</code> then some proposals which
		97	* can be very long to compute are proposed. To avoid that the code assist operation
		98	* take too much time a {@link IProgressMonitor} which automatically cancel the code
		99	* assist operation when a specified amount of time is reached could be used.
		100	*
		101	* <pre>
		102	* new IProgressMonitor() {
		103	* private final static int TIMEOUT = 500; //ms
		104	* private long endTime;
		105	* public void beginTask(String name, int totalWork) {
		106	* fEndTime= System.currentTimeMillis() + TIMEOUT;
		107	* }
		108	* public boolean isCanceled() {
		109	* return endTime <= System.currentTimeMillis();
		110	* }
		111	* ...
		112	* };
		113	* </pre>
		114	* <p>
95	*	115	*
96	* @param offset the given offset position	116	* @param offset the given offset position
97	* @param requestor the given completion requestor	117	* @param requestor the given completion requestor
Lines 180-185 Link Here
180	* Note that if a working copy is empty, it will be as if the original compilation	200	* Note that if a working copy is empty, it will be as if the original compilation
181	* unit had been deleted.	201	* unit had been deleted.
182	* </p>	202	* </p>
		203	* <p>
		204	* If {@link IProgressMonitor} is not <code>null</code> then some proposals which
		205	* can be very long to compute are proposed. To avoid that the code assist operation
		206	* take too much time a {@link IProgressMonitor} which automatically cancel the code
		207	* assist operation when a specified amount of time is reached could be used.
		208	*
		209	* <pre>
		210	* new IProgressMonitor() {
		211	* private final static int TIMEOUT = 500; //ms
		212	* private long endTime;
		213	* public void beginTask(String name, int totalWork) {
		214	* fEndTime= System.currentTimeMillis() + TIMEOUT;
		215	* }
		216	* public boolean isCanceled() {
		217	* return endTime <= System.currentTimeMillis();
		218	* }
		219	* ...
		220	* };
		221	* </pre>
		222	* <p>
183	*	223	*
184	* @param offset the given offset position	224	* @param offset the given offset position
185	* @param requestor the given completion requestor	225	* @param requestor the given completion requestor

Lines 161-166 Link Here

(-)model/org/eclipse/jdt/core/IType.java (+40 lines)
161	* If the type has access to its source code and the insertion position is valid,	161	* If the type has access to its source code and the insertion position is valid,
162	* then completion is performed against the source. Otherwise the completion is performed	162	* then completion is performed against the source. Otherwise the completion is performed
163	* against the type structure and the given locals variables.	163	* against the type structure and the given locals variables.
		164	* <p>
		165	* If {@link IProgressMonitor} is not <code>null</code> then some proposals which
		166	* can be very long to compute are proposed. To avoid that the code assist operation
		167	* take too much time a {@link IProgressMonitor} which automatically cancel the code
		168	* assist operation when a specified amount of time is reached could be used.
		169	*
		170	* <pre>
		171	* new IProgressMonitor() {
		172	* private final static int TIMEOUT = 500; //ms
		173	* private long endTime;
		174	* public void beginTask(String name, int totalWork) {
		175	* fEndTime= System.currentTimeMillis() + TIMEOUT;
		176	* }
		177	* public boolean isCanceled() {
		178	* return endTime <= System.currentTimeMillis();
		179	* }
		180	* ...
		181	* };
		182	* </pre>
		183	* <p>
164	*	184	*
165	* @param snippet the code snippet	185	* @param snippet the code snippet
166	* @param insertion the position with in source where the snippet	186	* @param insertion the position with in source where the snippet
Lines 251-256 Link Here
251	* then completion is performed against the source. Otherwise the completion is performed	271	* then completion is performed against the source. Otherwise the completion is performed
252	* against the type structure and the given locals variables.	272	* against the type structure and the given locals variables.
253	* </p>	273	* </p>
		274	* <p>
		275	* If {@link IProgressMonitor} is not <code>null</code> then some proposals which
		276	* can be very long to compute are proposed. To avoid that the code assist operation
		277	* take too much time a {@link IProgressMonitor} which automatically cancel the code
		278	* assist operation when a specified amount of time is reached could be used.
		279	*
		280	* <pre>
		281	* new IProgressMonitor() {
		282	* private final static int TIMEOUT = 500; //ms
		283	* private long endTime;
		284	* public void beginTask(String name, int totalWork) {
		285	* fEndTime= System.currentTimeMillis() + TIMEOUT;
		286	* }
		287	* public boolean isCanceled() {
		288	* return endTime <= System.currentTimeMillis();
		289	* }
		290	* ...
		291	* };
		292	* </pre>
		293	* <p>
254	*	294	*
255	* @param snippet the code snippet	295	* @param snippet the code snippet
256	* @param insertion the position with in source where the snippet	296	* @param insertion the position with in source where the snippet

Lines 184-189 Link Here

(-)model/org/eclipse/jdt/core/eval/IEvaluationContext.java (+40 lines)
184	* <p>	184	* <p>
185	* Note that code completion does not involve evaluation.	185	* Note that code completion does not involve evaluation.
186	* <p>	186	* <p>
		187	* <p>
		188	* If {@link IProgressMonitor} is not <code>null</code> then some proposals which
		189	* can be very long to compute are proposed. To avoid that the code assist operation
		190	* take too much time a {@link IProgressMonitor} which automatically cancel the code
		191	* assist operation when a specified amount of time is reached could be used.
		192	*
		193	* <pre>
		194	* new IProgressMonitor() {
		195	* private final static int TIMEOUT = 500; //ms
		196	* private long endTime;
		197	* public void beginTask(String name, int totalWork) {
		198	* fEndTime= System.currentTimeMillis() + TIMEOUT;
		199	* }
		200	* public boolean isCanceled() {
		201	* return endTime <= System.currentTimeMillis();
		202	* }
		203	* ...
		204	* };
		205	* </pre>
		206	* <p>
187	*	207	*
188	* @param codeSnippet the code snippet to complete in	208	* @param codeSnippet the code snippet to complete in
189	* @param position the character position in the code snippet to complete at,	209	* @param position the character position in the code snippet to complete at,
Lines 252-257 Link Here
252	* <p>	272	* <p>
253	* Note that code completion does not involve evaluation.	273	* Note that code completion does not involve evaluation.
254	* <p>	274	* <p>
		275	* <p>
		276	* If {@link IProgressMonitor} is not <code>null</code> then some proposals which
		277	* can be very long to compute are proposed. To avoid that the code assist operation
		278	* take too much time a {@link IProgressMonitor} which automatically cancel the code
		279	* assist operation when a specified amount of time is reached could be used.
		280	*
		281	* <pre>
		282	* new IProgressMonitor() {
		283	* private final static int TIMEOUT = 500; //ms
		284	* private long endTime;
		285	* public void beginTask(String name, int totalWork) {
		286	* fEndTime= System.currentTimeMillis() + TIMEOUT;
		287	* }
		288	* public boolean isCanceled() {
		289	* return endTime <= System.currentTimeMillis();
		290	* }
		291	* ...
		292	* };
		293	* </pre>
		294	* <p>
255	*	295	*
256	* @param codeSnippet the code snippet to complete in	296	* @param codeSnippet the code snippet to complete in
257	* @param position the character position in the code snippet to complete at,	297	* @param position the character position in the code snippet to complete at,

Lines 1-5 Link Here

(-)model/org/eclipse/jdt/internal/core/SearchableEnvironment.java (-1 / +147 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.	2	* Copyright (c) 2000, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 23-28 Link Here
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>.

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	}