Attachment #91767 for bug #202470

Lines 26-31 Link Here

(-)codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionParser.java (-3 / +81 lines)
26	import org.eclipse.jdt.internal.compiler.ast.*;	26	import org.eclipse.jdt.internal.compiler.ast.*;
27	import org.eclipse.jdt.internal.compiler.parser.*;	27	import org.eclipse.jdt.internal.compiler.parser.*;
28	import org.eclipse.jdt.internal.compiler.problem.*;	28	import org.eclipse.jdt.internal.compiler.problem.*;
		29	import org.eclipse.jdt.internal.compiler.util.HashtableOfObjectToInt;
29	import org.eclipse.jdt.internal.compiler.util.Util;	30	import org.eclipse.jdt.internal.compiler.util.Util;
30	import org.eclipse.jdt.core.compiler.CharOperation;	31	import org.eclipse.jdt.core.compiler.CharOperation;
31	import org.eclipse.jdt.internal.codeassist.impl.*;	32	import org.eclipse.jdt.internal.codeassist.impl.*;
Lines 160-169 Link Here
160		161
161	CompletionOnAnnotationOfType pendingAnnotation;	162	CompletionOnAnnotationOfType pendingAnnotation;
162		163
163	public CompletionParser(ProblemReporter problemReporter) {	164	private boolean storeSourceEnds;
		165	public HashtableOfObjectToInt sourceEnds;
		166
		167	public CompletionParser(ProblemReporter problemReporter, boolean storeExtraSourceEnds) {
164	super(problemReporter);	168	super(problemReporter);
165	this.reportSyntaxErrorIsRequired = false;	169	this.reportSyntaxErrorIsRequired = false;
166	this.javadocParser.checkDocComment = true;	170	this.javadocParser.checkDocComment = true;
		171	if (storeExtraSourceEnds) {
		172	this.storeSourceEnds = true;
		173	this.sourceEnds = new HashtableOfObjectToInt();
		174	}
167	}	175	}
168	private void addPotentialName(char[] potentialVariableName, int start, int end) {	176	private void addPotentialName(char[] potentialVariableName, int start, int end) {
169	int length = this.potentialVariableNames.length;	177	int length = this.potentialVariableNames.length;
Lines 2118-2123 Link Here
2118		2126
2119	/* no need to take action if not inside assist identifiers */	2127	/* no need to take action if not inside assist identifiers */
2120	if (indexOfAssistIdentifier() < 0) {	2128	if (indexOfAssistIdentifier() < 0) {
		2129	long selectorSourcePositions = this.identifierPositionStack[this.identifierPtr];
		2130	int selectorSourceEnd = (int) selectorSourcePositions;
		2131	int currentAstPtr = this.astPtr;
2121	/* recovering - might be an empty message send */	2132	/* recovering - might be an empty message send */
2122	if (this.currentElement != null && this.lastIgnoredToken == TokenNamenew){ // was an allocation expression	2133	if (this.currentElement != null && this.lastIgnoredToken == TokenNamenew){ // was an allocation expression
2123	super.consumeConstructorHeaderName();	2134	super.consumeConstructorHeaderName();
Lines 2128-2133 Link Here
2128	this.pendingAnnotation = null;	2139	this.pendingAnnotation = null;
2129	}	2140	}
2130	}	2141	}
		2142	if (this.sourceEnds != null && this.astPtr > currentAstPtr) { // if ast node was pushed on the ast stack
		2143	this.sourceEnds.put(this.astStack[this.astPtr], selectorSourceEnd);
		2144	}
2131	return;	2145	return;
2132	}	2146	}
2133		2147
Lines 2140-2145 Link Here
2140	this.restartRecovery = true;	2154	this.restartRecovery = true;
2141	}	2155	}
2142	protected void consumeConstructorHeaderNameWithTypeParameters() {	2156	protected void consumeConstructorHeaderNameWithTypeParameters() {
		2157	long selectorSourcePositions = this.identifierPositionStack[this.identifierPtr];
		2158	int selectorSourceEnd = (int) selectorSourcePositions;
		2159	int currentAstPtr = this.astPtr;
2143	if (this.currentElement != null && this.lastIgnoredToken == TokenNamenew){ // was an allocation expression	2160	if (this.currentElement != null && this.lastIgnoredToken == TokenNamenew){ // was an allocation expression
2144	super.consumeConstructorHeaderNameWithTypeParameters();	2161	super.consumeConstructorHeaderNameWithTypeParameters();
2145	} else {	2162	} else {
Lines 2149-2154 Link Here
2149	this.pendingAnnotation = null;	2166	this.pendingAnnotation = null;
2150	}	2167	}
2151	}	2168	}
		2169	if (this.sourceEnds != null && this.astPtr > currentAstPtr) { // if ast node was pushed on the ast stack
		2170	this.sourceEnds.put(this.astStack[this.astPtr], selectorSourceEnd);
		2171	}
2152	}	2172	}
2153	protected void consumeDefaultLabel() {	2173	protected void consumeDefaultLabel() {
2154	super.consumeDefaultLabel();	2174	super.consumeDefaultLabel();
Lines 2269-2274 Link Here
2269	this.pendingAnnotation = null;	2289	this.pendingAnnotation = null;
2270	}	2290	}
2271	}	2291	}
		2292	protected void consumeEnumConstantNoClassBody() {
		2293	super.consumeEnumConstantNoClassBody();
		2294	if ((currentToken == TokenNameCOMMA \|\| currentToken == TokenNameSEMICOLON)
		2295	&& this.astStack[this.astPtr] instanceof FieldDeclaration) {
		2296	if (this.sourceEnds != null) {
		2297	this.sourceEnds.put(this.astStack[this.astPtr], this.scanner.currentPosition - 1);
		2298	}
		2299	}
		2300	}
		2301	protected void consumeEnumConstantWithClassBody() {
		2302	super.consumeEnumConstantWithClassBody();
		2303	if ((currentToken == TokenNameCOMMA \|\| currentToken == TokenNameSEMICOLON)
		2304	&& astStack[astPtr] instanceof FieldDeclaration) {
		2305	if (this.sourceEnds != null) {
		2306	this.sourceEnds.put(this.astStack[this.astPtr], this.scanner.currentPosition - 1);
		2307	}
		2308	}
		2309	}
2272	protected void consumeEnumHeaderName() {	2310	protected void consumeEnumHeaderName() {
2273	super.consumeEnumHeaderName();	2311	super.consumeEnumHeaderName();
2274	this.hasUnusedModifiers = false;	2312	this.hasUnusedModifiers = false;
Lines 2304-2310 Link Here
2304	}	2342	}
2305	protected void consumeExitVariableWithInitialization() {	2343	protected void consumeExitVariableWithInitialization() {
2306	super.consumeExitVariableWithInitialization();	2344	super.consumeExitVariableWithInitialization();
2307		2345	if ((currentToken == TokenNameCOMMA \|\| currentToken == TokenNameSEMICOLON)
		2346	&& this.astStack[this.astPtr] instanceof FieldDeclaration) {
		2347	if (this.sourceEnds != null) {
		2348	this.sourceEnds.put(this.astStack[this.astPtr], this.scanner.currentPosition - 1);
		2349	}
		2350	}
		2351
2308	// does not keep the initialization if completion is not inside	2352	// does not keep the initialization if completion is not inside
2309	AbstractVariableDeclaration variable = (AbstractVariableDeclaration) astStack[astPtr];	2353	AbstractVariableDeclaration variable = (AbstractVariableDeclaration) astStack[astPtr];
2310	if (cursorLocation + 1 < variable.initialization.sourceStart \|\|	2354	if (cursorLocation + 1 < variable.initialization.sourceStart \|\|
Lines 2314-2319 Link Here
2314	assistNodeParent = variable;	2358	assistNodeParent = variable;
2315	}	2359	}
2316	}	2360	}
		2361	protected void consumeExitVariableWithoutInitialization() {
		2362	// ExitVariableWithoutInitialization ::= $empty
		2363	// do nothing by default
		2364	super.consumeExitVariableWithoutInitialization();
		2365	if ((currentToken == TokenNameCOMMA \|\| currentToken == TokenNameSEMICOLON)
		2366	&& astStack[astPtr] instanceof FieldDeclaration) {
		2367	if (this.sourceEnds != null) {
		2368	this.sourceEnds.put(this.astStack[this.astPtr], this.scanner.currentPosition - 1);
		2369	}
		2370	}
		2371	}
2317	protected void consumeExplicitConstructorInvocation(int flag, int recFlag) {	2372	protected void consumeExplicitConstructorInvocation(int flag, int recFlag) {
2318	popElement(K_SELECTOR_QUALIFIER);	2373	popElement(K_SELECTOR_QUALIFIER);
2319	popElement(K_SELECTOR_INVOCATION_TYPE);	2374	popElement(K_SELECTOR_INVOCATION_TYPE);
Lines 2561-2567 Link Here
2561	this.identifierLengthStack[this.identifierLengthPtr] != this.genericsIdentifiersLengthStack[this.genericsIdentifiersLengthPtr]) {	2616	this.identifierLengthStack[this.identifierLengthPtr] != this.genericsIdentifiersLengthStack[this.genericsIdentifiersLengthPtr]) {
2562	identifierPtr++;	2617	identifierPtr++;
2563	identifierLengthPtr++;	2618	identifierLengthPtr++;
		2619	long selectorSourcePositions = this.identifierPositionStack[this.identifierPtr];
		2620	int selectorSourceEnd = (int) selectorSourcePositions;
		2621	int currentAstPtr = this.astPtr;
2564	super.consumeMethodHeaderName(isAnnotationMethod);	2622	super.consumeMethodHeaderName(isAnnotationMethod);
		2623	if (this.sourceEnds != null && this.astPtr > currentAstPtr) { // if ast node was pushed on the ast stack
		2624	this.sourceEnds.put(this.astStack[this.astPtr], selectorSourceEnd);
		2625	}
2565	if (this.pendingAnnotation != null) {	2626	if (this.pendingAnnotation != null) {
2566	this.pendingAnnotation.potentialAnnotatedNode = this.astStack[this.astPtr];	2627	this.pendingAnnotation.potentialAnnotatedNode = this.astStack[this.astPtr];
2567	this.pendingAnnotation = null;	2628	this.pendingAnnotation = null;
Lines 2681-2687 Link Here
2681	}	2742	}
2682	}	2743	}
2683	protected void consumeMethodHeaderNameWithTypeParameters( boolean isAnnotationMethod) {	2744	protected void consumeMethodHeaderNameWithTypeParameters( boolean isAnnotationMethod) {
		2745	long selectorSourcePositions = this.identifierPositionStack[this.identifierPtr];
		2746	int selectorSourceEnd = (int) selectorSourcePositions;
		2747	int currentAstPtr = this.astPtr;
2684	super.consumeMethodHeaderNameWithTypeParameters(isAnnotationMethod);	2748	super.consumeMethodHeaderNameWithTypeParameters(isAnnotationMethod);
		2749	if (this.sourceEnds != null && this.astPtr > currentAstPtr) {// if ast node was pushed on the ast stack
		2750	this.sourceEnds.put(this.astStack[this.astPtr], selectorSourceEnd);
		2751	}
2685	if (this.pendingAnnotation != null) {	2752	if (this.pendingAnnotation != null) {
2686	this.pendingAnnotation.potentialAnnotatedNode = this.astStack[this.astPtr];	2753	this.pendingAnnotation.potentialAnnotatedNode = this.astStack[this.astPtr];
2687	this.pendingAnnotation = null;	2754	this.pendingAnnotation = null;
Lines 3730-3736 Link Here
3730	}	3797	}
3731	}	3798	}
3732	}	3799	}
3733		3800	public MethodDeclaration convertToMethodDeclaration(ConstructorDeclaration c, CompilationResult compilationResult) {
		3801	MethodDeclaration methodDeclaration = super.convertToMethodDeclaration(c, compilationResult);
		3802	if (this.sourceEnds != null) {
		3803	int selectorSourceEnd = this.sourceEnds.removeKey(c);
		3804	if (selectorSourceEnd != -1)
		3805	this.sourceEnds.put(methodDeclaration, selectorSourceEnd);
		3806	}
		3807	return methodDeclaration;
		3808	}
3734	public ImportReference createAssistImportReference(char[][] tokens, long[] positions, int mod){	3809	public ImportReference createAssistImportReference(char[][] tokens, long[] positions, int mod){
3735	return new CompletionOnImportReference(tokens, positions, mod);	3810	return new CompletionOnImportReference(tokens, positions, mod);
3736	}	3811	}
Lines 4420-4425 Link Here
4420	public void reset() {	4495	public void reset() {
4421	super.reset();	4496	super.reset();
4422	this.cursorLocation = 0;	4497	this.cursorLocation = 0;
		4498	if (this.storeSourceEnds) {
		4499	this.sourceEnds = new HashtableOfObjectToInt();
		4500	}
4423	}	4501	}
4424	/*	4502	/*
4425	* Reset internal state after completion is over	4503	* Reset internal state after completion is over





package org.eclipse.jdt.core.dom;

import java.io.File;

import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.Path;
import org.eclipse.jdt.core.IClassFile;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.internal.compiler.ast.Expression;
import org.eclipse.jdt.internal.compiler.ast.Wildcard;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.env.IDependent;
import org.eclipse.jdt.internal.compiler.lookup.ArrayBinding;
import org.eclipse.jdt.internal.compiler.lookup.BaseTypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.Binding;

import org.eclipse.jdt.internal.compiler.lookup.TypeVariableBinding;
import org.eclipse.jdt.internal.compiler.lookup.WildcardBinding;
import org.eclipse.jdt.internal.compiler.problem.AbortCompilation;
import org.eclipse.jdt.internal.compiler.util.SuffixConstants;
import org.eclipse.jdt.internal.compiler.util.Util;
import org.eclipse.jdt.internal.core.ClassFile;
import org.eclipse.jdt.internal.core.CompilationUnit;
import org.eclipse.jdt.internal.core.JavaElement;
import org.eclipse.jdt.internal.core.PackageFragment;

	}

	/*
	 * Returns the class file for the given file name, or null if not found.
	 * @see org.eclipse.jdt.internal.compiler.env.IDependent#getFileName()
	 */
	private IClassFile getClassFile(char[] fileName) {
		int jarSeparator = CharOperation.indexOf(IDependent.JAR_FILE_ENTRY_SEPARATOR, fileName);
		int pkgEnd = CharOperation.lastIndexOf('/', fileName); // pkgEnd is exclusive
		if (pkgEnd == -1)
			pkgEnd = CharOperation.lastIndexOf(File.separatorChar, fileName);
		if (jarSeparator != -1 && pkgEnd < jarSeparator) // if in a jar and no slash, it is a default package -> pkgEnd should be equal to jarSeparator
			pkgEnd = jarSeparator;
		if (pkgEnd == -1)
			return null;
		IPackageFragment pkg = getPackageFragment(fileName, pkgEnd, jarSeparator);
		if (pkg == null) return null;
		int start;
		return pkg.getClassFile(new String(fileName, start = pkgEnd + 1, fileName.length - start));
	}

	/*
	 * Returns the compilation unit for the given file name, or null if not found.
	 * @see org.eclipse.jdt.internal.compiler.env.IDependent#getFileName()
	 */
	private ICompilationUnit getCompilationUnit(char[] fileName) {
		char[] slashSeparatedFileName = CharOperation.replaceOnCopy(fileName, File.separatorChar, '/');
		int pkgEnd = CharOperation.lastIndexOf('/', slashSeparatedFileName); // pkgEnd is exclusive
		if (pkgEnd == -1)
			return null;
		IPackageFragment pkg = getPackageFragment(slashSeparatedFileName, pkgEnd, -1/*no jar separator for .java files*/);
		if (pkg == null) return null;
		int start;
		ICompilationUnit cu = pkg.getCompilationUnit(new String(slashSeparatedFileName, start =  pkgEnd+1, slashSeparatedFileName.length - start));
		if (this.resolver instanceof DefaultBindingResolver) {
			ICompilationUnit workingCopy = cu.findWorkingCopy(((DefaultBindingResolver) this.resolver).workingCopyOwner);
			if (workingCopy != null)
				return workingCopy;
		}
		return cu;
	}

	/*
	 * @see ITypeBinding#getComponentType()
	 */
	public ITypeBinding getComponentType() {

		return getUnresolvedJavaElement(this.binding);
	}
	private JavaElement getUnresolvedJavaElement(org.eclipse.jdt.internal.compiler.lookup.TypeBinding typeBinding ) {
		if (this.resolver instanceof DefaultBindingResolver) {
			DefaultBindingResolver defaultBindingResolver = (DefaultBindingResolver) this.resolver;
			return org.eclipse.jdt.internal.core.util.Util.getUnresolvedJavaElement(
					typeBinding,
					defaultBindingResolver.workingCopyOwner,
					defaultBindingResolver.getBindingsToNodesMap());
			case Binding.BASE_TYPE :
			case Binding.WILDCARD_TYPE :
			case Binding.INTERSECTION_TYPE:
				return null;
			default :
				if (typeBinding.isCapture())
					return null;
		}
		ReferenceBinding referenceBinding;
		if (typeBinding.isParameterizedType() || typeBinding.isRawType())
			referenceBinding = (ReferenceBinding) typeBinding.erasure();
		else
			referenceBinding = (ReferenceBinding) typeBinding;
		char[] fileName = referenceBinding.getFileName();
		if (referenceBinding.isLocalType() || referenceBinding.isAnonymousType()) {
			// local or anonymous type
			if (Util.isClassFileName(fileName)) {
				int jarSeparator = CharOperation.indexOf(IDependent.JAR_FILE_ENTRY_SEPARATOR, fileName);
				int pkgEnd = CharOperation.lastIndexOf('/', fileName); // pkgEnd is exclusive
				if (pkgEnd == -1)
					pkgEnd = CharOperation.lastIndexOf(File.separatorChar, fileName);
				if (jarSeparator != -1 && pkgEnd < jarSeparator) // if in a jar and no slash, it is a default package -> pkgEnd should be equal to jarSeparator
					pkgEnd = jarSeparator;
				if (pkgEnd == -1)
					return null;
				IPackageFragment pkg = getPackageFragment(fileName, pkgEnd, jarSeparator);
				char[] constantPoolName = referenceBinding.constantPoolName();
				if (constantPoolName == null) {
					ClassFile classFile = (ClassFile) getClassFile(fileName);
					return classFile == null ? null : (JavaElement) classFile.getType();
				}
				pkgEnd = CharOperation.lastIndexOf('/', constantPoolName);
				char[] classFileName = CharOperation.subarray(constantPoolName, pkgEnd+1, constantPoolName.length);
				ClassFile classFile = (ClassFile) pkg.getClassFile(new String(classFileName) + SuffixConstants.SUFFIX_STRING_class);
				return (JavaElement) classFile.getType();
			}
			ICompilationUnit cu = getCompilationUnit(fileName);
			if (cu == null) return null;
			// must use getElementAt(...) as there is no back pointer to the defining method (scope is null after resolution has ended)
			try {
				int sourceStart = ((LocalTypeBinding) referenceBinding).sourceStart;
				return (JavaElement) cu.getElementAt(sourceStart);
			} catch (JavaModelException e) {
				// does not exist
				return null;
			}
		} else if (referenceBinding.isTypeVariable()) {
			// type parameter
			final String typeVariableName = new String(referenceBinding.sourceName());
			Binding declaringElement = ((TypeVariableBinding) referenceBinding).declaringElement;
			IBinding declaringTypeBinding = null;
			if (declaringElement instanceof MethodBinding) {
				declaringTypeBinding = this.resolver.getMethodBinding((MethodBinding) declaringElement);
				IMethod declaringMethod = (IMethod) declaringTypeBinding.getJavaElement();
				return (JavaElement) declaringMethod.getTypeParameter(typeVariableName);
			} else {
				ITypeBinding typeBinding2 = this.resolver.getTypeBinding((org.eclipse.jdt.internal.compiler.lookup.TypeBinding) declaringElement);
				if (typeBinding2 == null) return null;
				declaringTypeBinding = typeBinding2;
				IType declaringType = (IType) declaringTypeBinding.getJavaElement();
				return (JavaElement) declaringType.getTypeParameter(typeVariableName);
			}
		} else {
			return org.eclipse.jdt.internal.core.util.Util.getUnresolvedJavaElement(typeBinding, null, null);
			// member or top level type
			ITypeBinding declaringTypeBinding = null;
			if (this.isArray()) {
				declaringTypeBinding = this.getElementType().getDeclaringClass();
			} else {
				declaringTypeBinding = this.getDeclaringClass();
			}
			if (declaringTypeBinding == null) {
				// top level type
				if (Util.isClassFileName(fileName)) {
					ClassFile classFile = (ClassFile) getClassFile(fileName);
					if (classFile == null) return null;
					return (JavaElement) classFile.getType();
				}
				ICompilationUnit cu = getCompilationUnit(fileName);
				if (cu == null) return null;
				return (JavaElement) cu.getType(new String(referenceBinding.sourceName()));
			} else {
				// member type
				IType declaringType = (IType) declaringTypeBinding.getJavaElement();
				if (declaringType == null) return null;
				return (JavaElement) declaringType.getType(new String(referenceBinding.sourceName()));
			}
		}
	}


		return this.resolver.getPackageBinding(referenceBinding.getPackage());
	}

	/*
	 * Returns the package that includes the given file name, or null if not found.
	 * pkgEnd == jarSeparator if default package in a jar
	 * pkgEnd > jarSeparator if non default package in a jar
	 * pkgEnd > 0 if package not in a jar
	 *
	 * @see org.eclipse.jdt.internal.compiler.env.IDependent#getFileName()
	 */
	private IPackageFragment getPackageFragment(char[] fileName, int pkgEnd, int jarSeparator) {
		if (jarSeparator != -1) {
			String jarMemento = new String(fileName, 0, jarSeparator);
			IPackageFragmentRoot root = (IPackageFragmentRoot) JavaCore.create(jarMemento);
			if (pkgEnd == jarSeparator)
				return root.getPackageFragment(IPackageFragment.DEFAULT_PACKAGE_NAME);
			char[] pkgName = CharOperation.subarray(fileName, jarSeparator+1, pkgEnd);
			CharOperation.replace(pkgName, '/', '.');
			return root.getPackageFragment(new String(pkgName));
		} else {
			Path path = new Path(new String(fileName, 0, pkgEnd));
			IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();
			IContainer folder = path.segmentCount() == 1 ? workspaceRoot.getProject(path.lastSegment()) : (IContainer) workspaceRoot.getFolder(path);
			IJavaElement element = JavaCore.create(folder);
			if (element == null) return null;
			switch (element.getElementType()) {
				case IJavaElement.PACKAGE_FRAGMENT:
					return (IPackageFragment) element;
				case IJavaElement.PACKAGE_FRAGMENT_ROOT:
					return ((IPackageFragmentRoot) element).getPackageFragment(IPackageFragment.DEFAULT_PACKAGE_NAME);
				case IJavaElement.JAVA_PROJECT:
					IPackageFragmentRoot root = ((IJavaProject) element).getPackageFragmentRoot(folder);
					if (root == null) return null;
					return root.getPackageFragment(IPackageFragment.DEFAULT_PACKAGE_NAME);
			}
			return null;
		}
	}

	/**
	 * @see org.eclipse.jdt.core.dom.ITypeBinding#getQualifiedName()
	 */





package org.eclipse.jdt.core.dom;

import java.util.ArrayList;
import java.util.Iterator;

import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.Signature;
import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.internal.compiler.lookup.ExtraCompilerModifiers;
import org.eclipse.jdt.internal.compiler.lookup.LookupEnvironment;
import org.eclipse.jdt.internal.compiler.lookup.ParameterizedGenericMethodBinding;

import org.eclipse.jdt.internal.compiler.lookup.TypeVariableBinding;
import org.eclipse.jdt.internal.compiler.problem.AbortCompilation;
import org.eclipse.jdt.internal.core.JavaElement;
import org.eclipse.jdt.internal.core.Member;
import org.eclipse.jdt.internal.core.util.Util;

/**

	}

	private JavaElement getUnresolvedJavaElement() {
		IType declaringType = (IType) getDeclaringClass().getJavaElement();
		if (declaringType == null) return null;
		if (!(this.resolver instanceof DefaultBindingResolver)) return null;
		
		DefaultBindingResolver defaultBindingResolver = (DefaultBindingResolver) this.resolver;
		return Util.getUnresolvedJavaElement(
				this.binding,
				defaultBindingResolver.workingCopyOwner,
				defaultBindingResolver.getBindingsToNodesMap());
				while (iterator.hasNext()) {
					SingleVariableDeclaration parameter = (SingleVariableDeclaration) iterator.next();
					Type type = parameter.getType();
					String typeSig = Util.getSignature(type);
					int arrayDim = parameter.getExtraDimensions();
					if (parameter.getAST().apiLevel() >= AST.JLS3 && parameter.isVarargs()) {
						arrayDim++;
					}
					if (arrayDim > 0) {
						typeSig = Signature.createArraySignature(typeSig, arrayDim);
					}
					parameterSignatures.add(typeSig);
				}
				int parameterCount = parameterSignatures.size();
				String[] parameters = new String[parameterCount];
				parameterSignatures.toArray(parameters);
				return (JavaElement) declaringType.getMethod(getName(), parameters);
			} else {
				// annotation type member declaration
				AnnotationTypeMemberDeclaration typeMemberDeclaration = (AnnotationTypeMemberDeclaration) node;
				return (JavaElement) declaringType.getMethod(typeMemberDeclaration.getName().getIdentifier(), CharOperation.NO_STRINGS); // annotation type members don't have parameters
			}
		} else {
			// case of method not in the created AST, or a binary method
			org.eclipse.jdt.internal.compiler.lookup.MethodBinding original = this.binding.original();
			String selector = original.isConstructor() ? declaringType.getElementName() : new String(original.selector);
			boolean isBinary = declaringType.isBinary();
			ReferenceBinding enclosingType = original.declaringClass.enclosingType();
			boolean isInnerBinaryTypeConstructor = isBinary && original.isConstructor() && enclosingType != null;
			TypeBinding[] parameters = original.parameters;
			int length = parameters == null ? 0 : parameters.length;
			int declaringIndex = isInnerBinaryTypeConstructor ? 1 : 0;
			String[] parameterSignatures = new String[declaringIndex + length];
			if (isInnerBinaryTypeConstructor)
				parameterSignatures[0] = new String(enclosingType.genericTypeSignature()).replace('/', '.');
			for (int i = 0;  i < length; i++) {
				parameterSignatures[declaringIndex + i] = new String(parameters[i].genericTypeSignature()).replace('/', '.');
			}
			IMethod result = declaringType.getMethod(selector, parameterSignatures);
			if (isBinary)
				return (JavaElement) result;
			IMethod[] methods = null;
			try {
				methods = declaringType.getMethods();
			} catch (JavaModelException e) {
				// declaring type doesn't exist
				return null;
			}
			IMethod[] candidates = Member.findMethods(result, methods);
			if (candidates == null || candidates.length == 0)
				return null;
			return (JavaElement) candidates[0];
		}
	}

	/**




package org.eclipse.jdt.core.dom;

import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.util.IModifierConstants;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.impl.Constant;

import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
import org.eclipse.jdt.internal.core.JavaElement;
import org.eclipse.jdt.internal.core.LocalVariable;
import org.eclipse.jdt.internal.core.util.Util;

/**
 * Internal implementation of variable bindings.


	private JavaElement getUnresolvedJavaElement() {
		if (isField()) {
			if (this.resolver instanceof DefaultBindingResolver) {
				DefaultBindingResolver defaultBindingResolver = (DefaultBindingResolver) this.resolver;
				return Util.getUnresolvedJavaElement(
						(FieldBinding) this.binding,
						defaultBindingResolver.workingCopyOwner,
						defaultBindingResolver.getBindingsToNodesMap());
			} else {
				return Util.getUnresolvedJavaElement((FieldBinding) this.binding, null, null);
			}
		}
		// local variable
		IMethodBinding declaringMethod = getDeclaringMethod();




import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
import org.eclipse.jdt.internal.compiler.problem.AbortCompilation;
import org.eclipse.jdt.internal.core.util.Util;

/**
 * Internal class for resolving bindings using old ASTs.

		}
		return null;
	}
	
	Util.BindingsToNodesMap getBindingsToNodesMap() {
		return new Util.BindingsToNodesMap() {
			public org.eclipse.jdt.internal.compiler.ast.ASTNode get(Binding binding) {
				return (org.eclipse.jdt.internal.compiler.ast.ASTNode)
					DefaultBindingResolver.this.newAstToOldAst.get(DefaultBindingResolver.this.bindingsToAstNodes.get(binding));
			}
		};
	}

	synchronized org.eclipse.jdt.internal.compiler.ast.ASTNode getCorrespondingNode(ASTNode currentNode) {
		return (org.eclipse.jdt.internal.compiler.ast.ASTNode) this.newAstToOldAst.get(currentNode);

Lines 17-23 Link Here

(-)model/org/eclipse/jdt/internal/core/PackageDeclaration.java (-1 / +1 lines)
17	* @see IPackageDeclaration	17	* @see IPackageDeclaration
18	*/	18	*/
19		19
20	/* package */ class PackageDeclaration extends SourceRefElement implements IPackageDeclaration {	20	public class PackageDeclaration extends SourceRefElement implements IPackageDeclaration {
21		21
22	String name;	22	String name;
23		23

Lines 81-87 Link Here

(-)model/org/eclipse/jdt/internal/core/SourceType.java (-2 / +2 lines)
81		81
82	JavaProject project = (JavaProject) getJavaProject();	82	JavaProject project = (JavaProject) getJavaProject();
83	SearchableEnvironment environment = project.newSearchableNameEnvironment(owner);	83	SearchableEnvironment environment = project.newSearchableNameEnvironment(owner);
84	CompletionEngine engine = new CompletionEngine(environment, requestor, project.getOptions(true), project);	84	CompletionEngine engine = new CompletionEngine(environment, requestor, project.getOptions(true), project, owner);
85		85
86	String source = getCompilationUnit().getSource();	86	String source = getCompilationUnit().getSource();
87	if (source != null && insertion > -1 && insertion < source.length()) {	87	if (source != null && insertion > -1 && insertion < source.length()) {
Lines 97-103 Link Here
97	getElementName(),	97	getElementName(),
98	getParent());	98	getParent());
99		99
100	engine.complete(cu, prefix.length + position, prefix.length);	100	engine.complete(cu, prefix.length + position, prefix.length, null);
101	} else {	101	} else {
102	engine.complete(this, snippet, position, localVariableTypeNames, localVariableNames, localVariableModifiers, isStatic);	102	engine.complete(this, snippet, position, localVariableTypeNames, localVariableNames, localVariableModifiers, isStatic);
103	}	103	}

Lines 136-142 Link Here

(-)model/org/eclipse/jdt/internal/core/ClassFile.java (-1 / +1 lines)
136	null,	136	null,
137	type.sourceFileName((IBinaryType) type.getElementInfo()),	137	type.sourceFileName((IBinaryType) type.getElementInfo()),
138	getJavaProject()); // use project to retrieve corresponding .java IFile	138	getJavaProject()); // use project to retrieve corresponding .java IFile
139	codeComplete(cu, cu, offset, requestor, owner);	139	codeComplete(cu, cu, offset, requestor, owner, null);
140	}	140	}
141	}	141	}
142		142

Lines 96-102 Link Here

(-)model/org/eclipse/jdt/internal/core/Openable.java (-3 / +8 lines)
96	protected void closing(Object info) {	96	protected void closing(Object info) {
97	closeBuffer();	97	closeBuffer();
98	}	98	}
99	protected void codeComplete(org.eclipse.jdt.internal.compiler.env.ICompilationUnit cu, org.eclipse.jdt.internal.compiler.env.ICompilationUnit unitToSkip, int position, CompletionRequestor requestor, WorkingCopyOwner owner) throws JavaModelException {	99	protected void codeComplete(
		100	org.eclipse.jdt.internal.compiler.env.ICompilationUnit cu,
		101	org.eclipse.jdt.internal.compiler.env.ICompilationUnit unitToSkip,
		102	int position, CompletionRequestor requestor,
		103	WorkingCopyOwner owner,
		104	ITypeRoot typeRoot) throws JavaModelException {
100	if (requestor == null) {	105	if (requestor == null) {
101	throw new IllegalArgumentException("Completion requestor cannot be null"); //$NON-NLS-1$	106	throw new IllegalArgumentException("Completion requestor cannot be null"); //$NON-NLS-1$
102	}	107	}
Lines 120-127 Link Here
120	environment.unitToSkip = unitToSkip;	125	environment.unitToSkip = unitToSkip;
121		126
122	// code complete	127	// code complete
123	CompletionEngine engine = new CompletionEngine(environment, requestor, project.getOptions(true), project);	128	CompletionEngine engine = new CompletionEngine(environment, requestor, project.getOptions(true), project, owner);
124	engine.complete(cu, position, 0);	129	engine.complete(cu, position, 0, typeRoot);
125	if(performanceStats != null) {	130	if(performanceStats != null) {
126	performanceStats.endRun();	131	performanceStats.endRun();
127	}	132	}

Lines 92-98 Link Here

(-)model/org/eclipse/jdt/internal/core/BinaryType.java (-2 / +2 lines)
92	}	92	}
93	JavaProject project = (JavaProject) getJavaProject();	93	JavaProject project = (JavaProject) getJavaProject();
94	SearchableEnvironment environment = project.newSearchableNameEnvironment(owner);	94	SearchableEnvironment environment = project.newSearchableNameEnvironment(owner);
95	CompletionEngine engine = new CompletionEngine(environment, requestor, project.getOptions(true), project);	95	CompletionEngine engine = new CompletionEngine(environment, requestor, project.getOptions(true), project, owner);
96		96
97	String source = getClassFile().getSource();	97	String source = getClassFile().getSource();
98	if (source != null && insertion > -1 && insertion < source.length()) {	98	if (source != null && insertion > -1 && insertion < source.length()) {
Lines 109-115 Link Here
109	getElementName(),	109	getElementName(),
110	project); // use project to retrieve corresponding .java IFile	110	project); // use project to retrieve corresponding .java IFile
111		111
112	engine.complete(cu, prefix.length + position, prefix.length);	112	engine.complete(cu, prefix.length + position, prefix.length, null);
113	} else {	113	} else {
114	engine.complete(this, snippet, position, localVariableTypeNames, localVariableNames, localVariableModifiers, isStatic);	114	engine.complete(this, snippet, position, localVariableTypeNames, localVariableNames, localVariableModifiers, isStatic);
115	}	115	}

Lines 47-53 Link Here

(-)model/org/eclipse/jdt/internal/core/ResolvedSourceField.java (-1 / +1 lines)
47	super.toStringInfo(tab, buffer, info, showResolvedInfo);	47	super.toStringInfo(tab, buffer, info, showResolvedInfo);
48	if (showResolvedInfo) {	48	if (showResolvedInfo) {
49	buffer.append(" {key="); //$NON-NLS-1$	49	buffer.append(" {key="); //$NON-NLS-1$
50	buffer.append(this.uniqueKey);	50	buffer.append(this.getKey());
51	buffer.append("}"); //$NON-NLS-1$	51	buffer.append("}"); //$NON-NLS-1$
52	}	52	}
53	}	53	}





	ICompilationUnit parentCU= (ICompilationUnit)parentHandle;
	//create the import container and its info
	ImportContainer importContainer= createImportContainer(parentCU);
	if (this.importContainerInfo == null) {
		this.importContainerInfo = new JavaElementInfo();
		JavaElementInfo parentInfo = (JavaElementInfo) this.infoStack.peek();

	}
	
	String elementName = JavaModelManager.getJavaModelManager().intern(new String(CharOperation.concatWith(tokens, '.')));
	ImportDeclaration handle = createImportDeclaration(importContainer, elementName, onDemand);
	resolveDuplicates(handle);
	
	ImportDeclarationElementInfo info = new ImportDeclarationElementInfo();

		
		if (parentHandle.getElementType() == IJavaElement.COMPILATION_UNIT) {
			char[] name = CharOperation.concatWith(importReference.getImportName(), '.');
			handle = createPackageDeclaration(parentHandle, new String(name));
		}
		else {
			Assert.isTrue(false); // Should not happen

		this.children.put(parentInfo, childrenList = new ArrayList());
	childrenList.add(handle);
}
protected Annotation createAnnotation(JavaElement parent, String name) {
	return new Annotation(parent, name);
}
protected SourceField createField(JavaElement parent, FieldInfo fieldInfo) {
	String fieldName = JavaModelManager.getJavaModelManager().intern(new String(fieldInfo.name));
	return new SourceField(parent, fieldName);
}
protected ImportContainer createImportContainer(ICompilationUnit parent) {
	return (ImportContainer)parent.getImportContainer();
}
protected ImportDeclaration createImportDeclaration(ImportContainer parent, String name, boolean onDemand) {
	return new ImportDeclaration(parent, name, onDemand);
}
protected Initializer createInitializer(JavaElement parent) {
	return new Initializer(parent, 1);
}
protected SourceMethod createMethod(JavaElement parent, MethodInfo methodInfo) {
	String selector = JavaModelManager.getJavaModelManager().intern(new String(methodInfo.name));
	String[] parameterTypeSigs = convertTypeNamesToSigs(methodInfo.parameterTypes);
	return new SourceMethod(parent, selector, parameterTypeSigs);
}
protected PackageDeclaration createPackageDeclaration(JavaElement parent, String name) {
	return new PackageDeclaration((CompilationUnit) parent, name);
}
protected SourceType createType(JavaElement parent, TypeInfo typeInfo) {
	String nameString= new String(typeInfo.name);
	return new SourceType(parent, nameString);
}
protected TypeParameter createTypeParameter(JavaElement parent, String name) {
	return new TypeParameter(parent, name);
}
/**
 * Convert these type names to signatures.
 * @see Signature
 */
protected static String[] convertTypeNamesToSigs(char[][] typeNames) {
	if (typeNames == null)
		return CharOperation.NO_STRINGS;
	int n = typeNames.length;

}
protected IAnnotation enterAnnotation(org.eclipse.jdt.internal.compiler.ast.Annotation annotation, AnnotatableInfo parentInfo, JavaElement parentHandle) {
	String nameString = new String(CharOperation.concatWith(annotation.type.getTypeName(), '.'));
	Annotation handle = createAnnotation(parentHandle, nameString); //NB: occurenceCount is computed in resolveDuplicates
	resolveDuplicates(handle);
	
	AnnotationInfo info = new AnnotationInfo();

	if (membersLength == 0) {
		info.members = Annotation.NO_MEMBER_VALUE_PAIRS;
	} else {
		info.members = getMemberValuePairs(memberValuePairs);
		for (int j = 0; j < membersLength; j++) {
			members[j] = getMemberValuePair(memberValuePairs[j]);
		}
		info.members = members;
	}
	
	if (parentInfo != null) {

	JavaElement parentHandle= (JavaElement) this.handleStack.peek();
	SourceField handle = null;
	if (parentHandle.getElementType() == IJavaElement.TYPE) {
		handle = createField(parentHandle, fieldInfo);
		handle = new SourceField(parentHandle, fieldName);
	}
	else {
		Assert.isTrue(false); // Should not happen

		Initializer handle = null;
		
		if (parentHandle.getElementType() == IJavaElement.TYPE) {
			handle = createInitializer(parentHandle);
		}
		else {
			Assert.isTrue(false); // Should not happen

		methodInfo.exceptionTypes= CharOperation.NO_CHAR_CHAR;
	}
	
	String[] parameterTypeSigs = convertTypeNamesToSigs(methodInfo.parameterTypes);
	if (parentHandle.getElementType() == IJavaElement.TYPE) {
		handle = createMethod(parentHandle, methodInfo);
		handle = new SourceMethod(parentHandle, selector, parameterTypeSigs);
	}
	else {
		Assert.isTrue(false); // Should not happen


	JavaElementInfo parentInfo = (JavaElementInfo) this.infoStack.peek();
	JavaElement parentHandle= (JavaElement) this.handleStack.peek();
	SourceType handle = this.createType(parentHandle, typeInfo); //NB: occurenceCount is computed in resolveDuplicates
	SourceType handle = new SourceType(parentHandle, nameString); //NB: occurenceCount is computed in resolveDuplicates
	resolveDuplicates(handle);
	
	SourceTypeElementInfo info = 

	JavaElementInfo parentInfo = (JavaElementInfo) this.infoStack.peek();
	JavaElement parentHandle = (JavaElement) this.handleStack.peek();
	String nameString = new String(typeParameterInfo.name);
	TypeParameter handle = createTypeParameter(parentHandle, nameString); //NB: occurenceCount is computed in resolveDuplicates
	resolveDuplicates(handle);
	
	TypeParameterElementInfo info = new TypeParameterElementInfo();

		handle.occurrenceCount++;
	}
}
protected IMemberValuePair getMemberValuePair(MemberValuePair memberValuePair) {
	String memberName = new String(memberValuePair.name);
	org.eclipse.jdt.internal.core.MemberValuePair result = new org.eclipse.jdt.internal.core.MemberValuePair(memberName);
	result.value = getMemberValue(result, memberValuePair.value);
	return result;
}
protected IMemberValuePair[] getMemberValuePairs(MemberValuePair[] memberValuePairs) {
	int membersLength = memberValuePairs.length;
	IMemberValuePair[] members = new IMemberValuePair[membersLength];
	for (int j = 0; j < membersLength; j++) {
		members[j] = getMemberValuePair(memberValuePairs[j]);
	}
	return members;
}
/*
 * Creates the value from the given expression, and sets the valueKind on the given memberValuePair
 */
protected Object getMemberValue(org.eclipse.jdt.internal.core.MemberValuePair memberValuePair, Expression expression) {
	if (expression instanceof NullLiteral) {
		return null;
	} else if (expression instanceof Literal) {

Lines 338-344 Link Here

(-)model/org/eclipse/jdt/internal/core/CompilationUnit.java (-1 / +7 lines)
338	* @see org.eclipse.jdt.core.ICodeAssist#codeComplete(int, org.eclipse.jdt.core.CompletionRequestor, org.eclipse.jdt.core.WorkingCopyOwner)	338	* @see org.eclipse.jdt.core.ICodeAssist#codeComplete(int, org.eclipse.jdt.core.CompletionRequestor, org.eclipse.jdt.core.WorkingCopyOwner)
339	*/	339	*/
340	public void codeComplete(int offset, CompletionRequestor requestor, WorkingCopyOwner workingCopyOwner) throws JavaModelException {	340	public void codeComplete(int offset, CompletionRequestor requestor, WorkingCopyOwner workingCopyOwner) throws JavaModelException {
341	codeComplete(this, isWorkingCopy() ? (org.eclipse.jdt.internal.compiler.env.ICompilationUnit) getOriginalElement() : this, offset, requestor, workingCopyOwner);	341	codeComplete(
		342	this,
		343	isWorkingCopy() ? (org.eclipse.jdt.internal.compiler.env.ICompilationUnit) getOriginalElement() : this,
		344	offset,
		345	requestor,
		346	workingCopyOwner,
		347	this);
342	}	348	}
343		349
344	/**	350	/**

Lines 53-59 Link Here

(-)model/org/eclipse/jdt/internal/core/ResolvedSourceType.java (-1 / +1 lines)
53	super.toStringInfo(tab, buffer, info, showResolvedInfo);	53	super.toStringInfo(tab, buffer, info, showResolvedInfo);
54	if (showResolvedInfo) {	54	if (showResolvedInfo) {
55	buffer.append(" {key="); //$NON-NLS-1$	55	buffer.append(" {key="); //$NON-NLS-1$
56	buffer.append(this.uniqueKey);	56	buffer.append(this.getKey());
57	buffer.append("}"); //$NON-NLS-1$	57	buffer.append("}"); //$NON-NLS-1$
58	}	58	}
59	}	59	}

Lines 24-30 Link Here

(-)model/org/eclipse/jdt/internal/core/Initializer.java (-1 / +1 lines)
24	* @see IInitializer	24	* @see IInitializer
25	*/	25	*/
26		26
27	/* package */ class Initializer extends Member implements IInitializer {	27	public class Initializer extends Member implements IInitializer {
28		28
29	protected Initializer(JavaElement parent, int count) {	29	protected Initializer(JavaElement parent, int count) {
30	super(parent);	30	super(parent);

Lines 46-52 Link Here

(-)model/org/eclipse/jdt/internal/core/ResolvedSourceMethod.java (-1 / +1 lines)
46	super.toStringInfo(tab, buffer, info, showResolvedInfo);	46	super.toStringInfo(tab, buffer, info, showResolvedInfo);
47	if (showResolvedInfo) {	47	if (showResolvedInfo) {
48	buffer.append(" {key="); //$NON-NLS-1$	48	buffer.append(" {key="); //$NON-NLS-1$
49	buffer.append(this.uniqueKey);	49	buffer.append(this.getKey());
50	buffer.append("}"); //$NON-NLS-1$	50	buffer.append("}"); //$NON-NLS-1$
51	}	51	}
52	}	52	}

Lines 69-74 Link Here

(-)model/org/eclipse/jdt/internal/core/ImportContainer.java (+3 lines)
69	if (isOnDemand)	69	if (isOnDemand)
70	// make sure to copy the string (so that it doesn't hold on the underlying char[] that might be much bigger than necessary)	70	// make sure to copy the string (so that it doesn't hold on the underlying char[] that might be much bigger than necessary)
71	importName = new String(importName.substring(0, index));	71	importName = new String(importName.substring(0, index));
		72	return getImport(importName, isOnDemand);
		73	}
		74	protected IImportDeclaration getImport(String importName, boolean isOnDemand) {
72	return new ImportDeclaration(this, importName, isOnDemand);	75	return new ImportDeclaration(this, importName, isOnDemand);
73	}	76	}
74	/*	77	/*

Lines 16-22 Link Here

(-)model/org/eclipse/jdt/internal/core/JavaElementInfo.java (-1 / +1 lines)
16	* Holds cached structure and properties for a Java element.	16	* Holds cached structure and properties for a Java element.
17	* Subclassed to carry properties for specific kinds of elements.	17	* Subclassed to carry properties for specific kinds of elements.
18	*/	18	*/
19	/* package */ class JavaElementInfo {	19	public class JavaElementInfo {
20		20
21	/**	21	/**
22	* Collection of handles of immediate children of this	22	* Collection of handles of immediate children of this




import org.eclipse.jdt.core.util.IFieldInfo;
import org.eclipse.jdt.core.util.IMethodInfo;
import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
import org.eclipse.jdt.internal.compiler.ast.AnnotationMethodDeclaration;
import org.eclipse.jdt.internal.compiler.ast.Argument;
import org.eclipse.jdt.internal.compiler.ast.MethodDeclaration;
import org.eclipse.jdt.internal.compiler.ast.TypeReference;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFormatException;
import org.eclipse.jdt.internal.compiler.env.IDependent;
import org.eclipse.jdt.internal.compiler.impl.Constant;
import org.eclipse.jdt.internal.compiler.lookup.Binding;
import org.eclipse.jdt.internal.compiler.lookup.FieldBinding;
import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
import org.eclipse.jdt.internal.compiler.parser.ScannerHelper;
import org.eclipse.jdt.internal.compiler.util.SuffixConstants;
import org.eclipse.jdt.internal.core.ClassFile;
import org.eclipse.jdt.internal.core.JavaElement;
import org.eclipse.jdt.internal.core.JavaModelManager;
import org.eclipse.jdt.internal.core.Member;
import org.eclipse.jdt.internal.core.MemberValuePair;
import org.eclipse.jdt.internal.core.PackageFragment;
import org.eclipse.jdt.internal.core.PackageFragmentRoot;

		 */
		int compare(Object a, Object b);
	}
	
	public static interface BindingsToNodesMap {
		public org.eclipse.jdt.internal.compiler.ast.ASTNode get(Binding binding);
	}
	
	private static final String ARGUMENTS_DELIMITER = "#"; //$NON-NLS-1$

	private static final String EMPTY_ARGUMENT = "   "; //$NON-NLS-1$

		return null;
	}
	
	private static IClassFile getClassFile(char[] fileName) {
		int jarSeparator = CharOperation.indexOf(IDependent.JAR_FILE_ENTRY_SEPARATOR, fileName);
		int pkgEnd = CharOperation.lastIndexOf('/', fileName); // pkgEnd is exclusive
		if (pkgEnd == -1)
			pkgEnd = CharOperation.lastIndexOf(File.separatorChar, fileName);
		if (jarSeparator != -1 && pkgEnd < jarSeparator) // if in a jar and no slash, it is a default package -> pkgEnd should be equal to jarSeparator
			pkgEnd = jarSeparator;
		if (pkgEnd == -1)
			return null;
		IPackageFragment pkg = getPackageFragment(fileName, pkgEnd, jarSeparator);
		if (pkg == null) return null;
		int start;
		return pkg.getClassFile(new String(fileName, start = pkgEnd + 1, fileName.length - start));
	}
	
	private static ICompilationUnit getCompilationUnit(char[] fileName, WorkingCopyOwner workingCopyOwner) {
		char[] slashSeparatedFileName = CharOperation.replaceOnCopy(fileName, File.separatorChar, '/');
		int pkgEnd = CharOperation.lastIndexOf('/', slashSeparatedFileName); // pkgEnd is exclusive
		if (pkgEnd == -1)
			return null;
		IPackageFragment pkg = getPackageFragment(slashSeparatedFileName, pkgEnd, -1/*no jar separator for .java files*/);
		if (pkg == null) return null;
		int start;
		ICompilationUnit cu = pkg.getCompilationUnit(new String(slashSeparatedFileName, start =  pkgEnd+1, slashSeparatedFileName.length - start));
		if (workingCopyOwner != null) {
			ICompilationUnit workingCopy = cu.findWorkingCopy(workingCopyOwner);
			if (workingCopy != null)
				return workingCopy;
		}
		return cu;
	}
	
	/**
	 * Returns the registered Java like extensions.
	 */

		}
		return lineSeparator;
	}
	
	private static IPackageFragment getPackageFragment(char[] fileName, int pkgEnd, int jarSeparator) {
		if (jarSeparator != -1) {
			String jarMemento = new String(fileName, 0, jarSeparator);
			IPackageFragmentRoot root = (IPackageFragmentRoot) JavaCore.create(jarMemento);
			if (pkgEnd == jarSeparator)
				return root.getPackageFragment(IPackageFragment.DEFAULT_PACKAGE_NAME);
			char[] pkgName = CharOperation.subarray(fileName, jarSeparator+1, pkgEnd);
			CharOperation.replace(pkgName, '/', '.');
			return root.getPackageFragment(new String(pkgName));
		} else {
			Path path = new Path(new String(fileName, 0, pkgEnd));
			IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();
			IContainer folder = path.segmentCount() == 1 ? workspaceRoot.getProject(path.lastSegment()) : (IContainer) workspaceRoot.getFolder(path);
			IJavaElement element = JavaCore.create(folder);
			if (element == null) return null;
			switch (element.getElementType()) {
				case IJavaElement.PACKAGE_FRAGMENT:
					return (IPackageFragment) element;
				case IJavaElement.PACKAGE_FRAGMENT_ROOT:
					return ((IPackageFragmentRoot) element).getPackageFragment(IPackageFragment.DEFAULT_PACKAGE_NAME);
				case IJavaElement.JAVA_PROJECT:
					IPackageFragmentRoot root = ((IJavaProject) element).getPackageFragmentRoot(folder);
					if (root == null) return null;
					return root.getPackageFragment(IPackageFragment.DEFAULT_PACKAGE_NAME);
			}
			return null;
		}
	}
	
	/**
	 * Returns the number of parameter types in a method signature.
	 */

		return result;
	}
	
	/**
	 * Return the java element corresponding to the given compiler binding.
	 */
	public static JavaElement getUnresolvedJavaElement(FieldBinding binding, WorkingCopyOwner workingCopyOwner, BindingsToNodesMap bindingsToNodes) {
		if (binding.declaringClass == null) return null; // arraylength
		IType declaringType = (IType) getUnresolvedJavaElement(binding.declaringClass, workingCopyOwner, bindingsToNodes);
		if (declaringType == null) return null;
		return (JavaElement) declaringType.getField(String.valueOf(binding.name));
	}
	
	/**
	 * Return the java element corresponding to the given compiler binding.
	 */
	public static JavaElement getUnresolvedJavaElement(MethodBinding methodBinding, WorkingCopyOwner workingCopyOwner, BindingsToNodesMap bindingsToNodes) {
		IType declaringType = (IType) getUnresolvedJavaElement(methodBinding.declaringClass, workingCopyOwner, bindingsToNodes);
		
		if (declaringType == null) return null;
		
		org.eclipse.jdt.internal.compiler.ast.ASTNode node = bindingsToNodes == null ? null : bindingsToNodes.get(methodBinding);
		if (node != null && !declaringType.isBinary()) {
			if (node instanceof AnnotationMethodDeclaration) {
				// node is an AnnotationMethodDeclaration
				AnnotationMethodDeclaration typeMemberDeclaration = (AnnotationMethodDeclaration) node;
				return (JavaElement) declaringType.getMethod(String.valueOf(typeMemberDeclaration.selector), CharOperation.NO_STRINGS); // annotation type members don't have parameters
			} else {
				// node is an MethodDeclaration
				MethodDeclaration methodDeclaration = (MethodDeclaration) node;
				
				Argument[] arguments = methodDeclaration.arguments;
				String[] parameterSignatures;
				if (arguments != null) {
					parameterSignatures = new String[arguments.length];
					for (int i = 0; i < arguments.length; i++) {
						Argument argument = arguments[i];
						TypeReference typeReference = argument.type;
						int arrayDim = typeReference.dimensions();
						
						String typeSig = 
							Signature.createTypeSignature(
									CharOperation.concatWith(
											typeReference.getTypeName(), '.'), false);
						if (arrayDim > 0) {
							typeSig = Signature.createArraySignature(typeSig, arrayDim);
						}
						parameterSignatures[i] = typeSig;
						
					}
				} else {
					parameterSignatures = new String[0];
				}
				return (JavaElement) declaringType.getMethod(String.valueOf(methodDeclaration.selector), parameterSignatures);
			}
		} else {
			// case of method not in the created AST, or a binary method
			org.eclipse.jdt.internal.compiler.lookup.MethodBinding original = methodBinding.original();
			String selector = original.isConstructor() ? declaringType.getElementName() : new String(original.selector);
			boolean isBinary = declaringType.isBinary();
			ReferenceBinding enclosingType = original.declaringClass.enclosingType();
			boolean isInnerBinaryTypeConstructor = isBinary && original.isConstructor() && enclosingType != null;
			TypeBinding[] parameters = original.parameters;
			int length = parameters == null ? 0 : parameters.length;
			int declaringIndex = isInnerBinaryTypeConstructor ? 1 : 0;
			String[] parameterSignatures = new String[declaringIndex + length];
			if (isInnerBinaryTypeConstructor)
				parameterSignatures[0] = new String(enclosingType.genericTypeSignature()).replace('/', '.');
			for (int i = 0;  i < length; i++) {
				parameterSignatures[declaringIndex + i] = new String(parameters[i].genericTypeSignature()).replace('/', '.');
			}
			IMethod result = declaringType.getMethod(selector, parameterSignatures);
			if (isBinary)
				return (JavaElement) result;
			IMethod[] methods = null;
			try {
				methods = declaringType.getMethods();
			} catch (JavaModelException e) {
				// declaring type doesn't exist
				return null;
			}
			IMethod[] candidates = Member.findMethods(result, methods);
			if (candidates == null || candidates.length == 0)
				return null;
			return (JavaElement) candidates[0];
		}
	}
	
	/**
	 * Return the java element corresponding to the given compiler binding.
	 */
	public static JavaElement getUnresolvedJavaElement(TypeBinding typeBinding, WorkingCopyOwner workingCopyOwner, BindingsToNodesMap bindingsToNodes) {
		if (typeBinding == null)
			return null;
		switch (typeBinding.kind()) {
			case Binding.ARRAY_TYPE :
				typeBinding = ((org.eclipse.jdt.internal.compiler.lookup.ArrayBinding) typeBinding).leafComponentType();
				return getUnresolvedJavaElement(typeBinding, workingCopyOwner, bindingsToNodes);
			case Binding.BASE_TYPE :
			case Binding.WILDCARD_TYPE :
			case Binding.INTERSECTION_TYPE:
				return null;
			default :
				if (typeBinding.isCapture())
					return null;
		}
		ReferenceBinding referenceBinding;
		if (typeBinding.isParameterizedType() || typeBinding.isRawType())
			referenceBinding = (ReferenceBinding) typeBinding.erasure();
		else
			referenceBinding = (ReferenceBinding) typeBinding;
		char[] fileName = referenceBinding.getFileName();
		if (referenceBinding.isLocalType() || referenceBinding.isAnonymousType()) {
			// local or anonymous type
			if (org.eclipse.jdt.internal.compiler.util.Util.isClassFileName(fileName)) {
				int jarSeparator = CharOperation.indexOf(IDependent.JAR_FILE_ENTRY_SEPARATOR, fileName);
				int pkgEnd = CharOperation.lastIndexOf('/', fileName); // pkgEnd is exclusive
				if (pkgEnd == -1)
					pkgEnd = CharOperation.lastIndexOf(File.separatorChar, fileName);
				if (jarSeparator != -1 && pkgEnd < jarSeparator) // if in a jar and no slash, it is a default package -> pkgEnd should be equal to jarSeparator
					pkgEnd = jarSeparator;
				if (pkgEnd == -1)
					return null;
				IPackageFragment pkg = getPackageFragment(fileName, pkgEnd, jarSeparator);
				char[] constantPoolName = referenceBinding.constantPoolName();
				if (constantPoolName == null) {
					ClassFile classFile = (ClassFile) getClassFile(fileName);
					return classFile == null ? null : (JavaElement) classFile.getType();
				}
				pkgEnd = CharOperation.lastIndexOf('/', constantPoolName);
				char[] classFileName = CharOperation.subarray(constantPoolName, pkgEnd+1, constantPoolName.length);
				ClassFile classFile = (ClassFile) pkg.getClassFile(new String(classFileName) + SuffixConstants.SUFFIX_STRING_class);
				return (JavaElement) classFile.getType();
			}
			ICompilationUnit cu = getCompilationUnit(fileName, workingCopyOwner);
			if (cu == null) return null;
			// must use getElementAt(...) as there is no back pointer to the defining method (scope is null after resolution has ended)
			try {
				int sourceStart = ((org.eclipse.jdt.internal.compiler.lookup.LocalTypeBinding) referenceBinding).sourceStart;
				return (JavaElement) cu.getElementAt(sourceStart);
			} catch (JavaModelException e) {
				// does not exist
				return null;
			}
		} else if (referenceBinding.isTypeVariable()) {
			// type parameter
			final String typeVariableName = new String(referenceBinding.sourceName());
			org.eclipse.jdt.internal.compiler.lookup.Binding declaringElement = ((org.eclipse.jdt.internal.compiler.lookup.TypeVariableBinding) referenceBinding).declaringElement;
			if (declaringElement instanceof MethodBinding) {
				IMethod declaringMethod = (IMethod) getUnresolvedJavaElement((MethodBinding) declaringElement, workingCopyOwner, bindingsToNodes);
				return (JavaElement) declaringMethod.getTypeParameter(typeVariableName);
			} else {
				IType declaringType = (IType) getUnresolvedJavaElement((TypeBinding) declaringElement, workingCopyOwner, bindingsToNodes);
				return (JavaElement) declaringType.getTypeParameter(typeVariableName);
			}
		} else {
			if (fileName == null) return null; // case of a WilCardBinding that doesn't have a corresponding Java element
			// member or top level type
			TypeBinding declaringTypeBinding = typeBinding.enclosingType();
			if (declaringTypeBinding == null) {
				// top level type
				if (org.eclipse.jdt.internal.compiler.util.Util.isClassFileName(fileName)) {
					ClassFile classFile = (ClassFile) getClassFile(fileName);
					if (classFile == null) return null;
					return (JavaElement) classFile.getType();
				}
				ICompilationUnit cu = getCompilationUnit(fileName, workingCopyOwner);
				if (cu == null) return null;
				return (JavaElement) cu.getType(new String(referenceBinding.sourceName()));
			} else {
				// member type
				IType declaringType = (IType) getUnresolvedJavaElement(declaringTypeBinding, workingCopyOwner, bindingsToNodes);
				if (declaringType == null) return null;
				return (JavaElement) declaringType.getType(new String(referenceBinding.sourceName()));
			}
		}
	}
	
	/*
	 * Returns the index of the most specific argument paths which is strictly enclosing the path to check
	 */
	public static int indexOfEnclosingPath(IPath checkedPath, IPath[] paths, int pathCount) {




import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.ITypeRoot;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.Signature;
import org.eclipse.jdt.core.WorkingCopyOwner;
import org.eclipse.jdt.core.compiler.CategorizedProblem;
import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.core.compiler.IProblem;

	
	long targetedElement;
	
	WorkingCopyOwner owner;
	IJavaProject javaProject;
	ITypeRoot typeRoot; 
	CompletionParser parser;
	CompletionRequestor requestor;
	CompletionProblemFactory problemFactory;

			SearchableEnvironment nameEnvironment,
			CompletionRequestor requestor,
			Map settings,
			IJavaProject javaProject,
			WorkingCopyOwner owner) {
		super(settings);
		this.javaProject = javaProject;
		this.requestor = requestor;

		this.lookupEnvironment =
			new LookupEnvironment(this, this.compilerOptions, this.problemReporter, nameEnvironment);
		this.parser =
			new CompletionParser(this.problemReporter, this.requestor.isExtendedContextRequired());
		this.nameScanner =
			new Scanner(
				false /*comment*/, 

				null /*taskTags*/, 
				null/*taskPriorities*/,
				true/*taskCaseSensitive*/);
		this.owner = owner;
	}

	/**

	private void buildContext(
			ASTNode astNode,
			ASTNode astNodeParent,
			CompilationUnitDeclaration compilationUnitDeclaration,
			Binding qualifiedBinding,
			Scope scope) {
		CompletionContext context = new CompletionContext();
		if (this.requestor.isExtendedContextRequired()) {
			context.setExtendedData(
					this.typeRoot,
					compilationUnitDeclaration,
					this.lookupEnvironment,
					scope,
					astNode,
					this.owner,
					this.parser);
		}
		
		// build expected types context
		if (this.expectedTypesPtr > -1) {

		}
	}

	private boolean complete(
			ASTNode astNode,
			ASTNode astNodeParent,
			ASTNode enclosingNode,
			CompilationUnitDeclaration compilationUnitDeclaration,
			Binding qualifiedBinding,
			Scope scope,
			boolean insideTypeAnnotation) {

		setSourceAndTokenRange(astNode.sourceStart, astNode.sourceEnd);


			computeExpectedTypes(astNodeParent, astNode, scope);
		}
		
		buildContext(astNode, astNodeParent, compilationUnitDeclaration, qualifiedBinding, scope);
		
		if (astNode instanceof CompletionOnFieldType) {


									e.astNode,
									this.parser.assistNodeParent,
									this.parser.enclosingNode,
									compilationUnit,
									e.qualifiedBinding,
									e.scope,
									e.insideTypeAnnotation);

	 *      a position in the source where the completion is taking place. 
	 *      This position is relative to the source provided.
	 */
	public void complete(ICompilationUnit sourceUnit, int completionPosition, int pos, ITypeRoot root) {

		if(DEBUG) {
			System.out.print("COMPLETION IN "); //$NON-NLS-1$

			this.fileName = sourceUnit.getFileName();
			this.actualCompletionPosition = completionPosition - 1;
			this.offset = pos;
			this.typeRoot = root;
			// for now until we can change the UI.
			CompilationResult result = new CompilationResult(sourceUnit, 1, 1, this.compilerOptions.maxProblemsPerUnit);
			CompilationUnitDeclaration parsedUnit = this.parser.dietParse(sourceUnit, result, this.actualCompletionPosition);

				// scan the package & import statements first
				if (parsedUnit.currentPackage instanceof CompletionOnPackageReference) {
					contextAccepted = true;
					this.buildContext(parsedUnit.currentPackage, null, parsedUnit, null, null);
					if(!this.requestor.isIgnored(CompletionProposal.PACKAGE_REF)) {
						findPackages((CompletionOnPackageReference) parsedUnit.currentPackage);
					}

							this.lookupEnvironment.buildTypeBindings(parsedUnit, null /*no access restriction*/);
							if ((this.unitScope = parsedUnit.scope) != null) {
								contextAccepted = true;
								this.buildContext(importReference, null, parsedUnit, null, null);
								
								long positions = importReference.sourcePositions[importReference.sourcePositions.length - 1];
								setSourceAndTokenRange((int) (positions >>> 32), (int) positions);

							return;
						} else if(importReference instanceof CompletionOnKeyword) {
							contextAccepted = true;
							this.buildContext(importReference, null, parsedUnit, null, null);
							if(!this.requestor.isIgnored(CompletionProposal.KEYWORD)) {
								setSourceAndTokenRange(importReference.sourceStart, importReference.sourceEnd);
								CompletionOnKeyword keyword = (CompletionOnKeyword)importReference;

									e.astNode,
									this.parser.assistNodeParent,
									this.parser.enclosingNode,
									parsedUnit,
									e.qualifiedBinding,
									e.scope,
									e.insideTypeAnnotation);


	protected void reset() {

		super.reset(false);
		this.knownPkgs = new HashtableOfObject(10);
		this.knownTypes = new HashtableOfObject(10);
	}

Lines 10-15 Link Here

(-)codeassist/org/eclipse/jdt/internal/codeassist/InternalCompletionContext.java (-14 / +45 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.jdt.internal.codeassist;	11	package org.eclipse.jdt.internal.codeassist;
12		12
		13	import org.eclipse.jdt.core.ITypeRoot;
		14	import org.eclipse.jdt.core.WorkingCopyOwner;
		15	import org.eclipse.jdt.internal.codeassist.complete.CompletionParser;
		16	import org.eclipse.jdt.internal.compiler.ast.ASTNode;
		17	import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
		18	import org.eclipse.jdt.internal.compiler.lookup.LookupEnvironment;
		19	import org.eclipse.jdt.internal.compiler.lookup.Scope;
		20
13		21
14	/**	22	/**
15	* Internal completion context	23	* Internal completion context
Lines 27-38 Link Here
27	protected int tokenKind;	35	protected int tokenKind;
28	protected int tokenLocation;	36	protected int tokenLocation;
29		37
		38	protected InternalExtendedCompletionContext extendedContext;
		39
		40	protected void setExpectedTypesKeys(char[][] expectedTypesKeys) {
		41	this.expectedTypesKeys = expectedTypesKeys;
		42	}
		43
30	protected void setExpectedTypesSignatures(char[][] expectedTypesSignatures) {	44	protected void setExpectedTypesSignatures(char[][] expectedTypesSignatures) {
31	this.expectedTypesSignatures = expectedTypesSignatures;	45	this.expectedTypesSignatures = expectedTypesSignatures;
32	}	46	}
33		47
34	protected void setExpectedTypesKeys(char[][] expectedTypesKeys) {	48	protected void setExtendedData(
35	this.expectedTypesKeys = expectedTypesKeys;	49	ITypeRoot typeRoot,
		50	CompilationUnitDeclaration compilationUnitDeclaration,
		51	LookupEnvironment lookupEnvironment,
		52	Scope scope,
		53	ASTNode astNode,
		54	WorkingCopyOwner owner,
		55	CompletionParser parser) {
		56	this.extendedContext =
		57	new InternalExtendedCompletionContext(
		58	this,
		59	typeRoot,
		60	compilationUnitDeclaration,
		61	lookupEnvironment,
		62	scope,
		63	astNode,
		64	owner,
		65	parser);
36	}	66	}
37		67
38	protected void setJavadoc(int javadoc) {	68	protected void setJavadoc(int javadoc) {
Lines 42-51 Link Here
42	protected void setOffset(int offset) {	72	protected void setOffset(int offset) {
43	this.offset = offset;	73	this.offset = offset;
44	}	74	}
		75
		76	protected void setToken(char[] token) {
		77	this.token = token;
		78	}
		79
		80	protected void setTokenKind(int tokenKind) {
		81	this.tokenKind = tokenKind;
		82	}
45		83
		84	protected void setTokenLocation(int tokenLocation) {
		85	this.tokenLocation = tokenLocation;
		86	}
		87
46	protected void setTokenRange(int start, int end) {	88	protected void setTokenRange(int start, int end) {
47	this.setTokenRange(start, end, -1);	89	this.setTokenRange(start, end, -1);
48	}	90	}
		91
49	protected void setTokenRange(int start, int end, int endOfEmptyToken) {	92	protected void setTokenRange(int start, int end, int endOfEmptyToken) {
50	this.tokenStart = start;	93	this.tokenStart = start;
51	this.tokenEnd = endOfEmptyToken > end ? endOfEmptyToken : end;	94	this.tokenEnd = endOfEmptyToken > end ? endOfEmptyToken : end;
Lines 57-72 Link Here
57	this.tokenEnd = 0;	100	this.tokenEnd = 0;
58	}	101	}
59	}	102	}
60
61	protected void setToken(char[] token) {
62	this.token = token;
63	}
64
65	protected void setTokenKind(int tokenKind) {
66	this.tokenKind = tokenKind;
67	}
68
69	protected void setTokenLocation(int tokenLocation) {
70	this.tokenLocation = tokenLocation;
71	}
72	}	103	}

Lines 737-743 Link Here

(-)codeassist/org/eclipse/jdt/internal/codeassist/SelectionEngine.java (-2 / +2 lines)
737	e.printStackTrace(System.out);	737	e.printStackTrace(System.out);
738	}	738	}
739	} finally {	739	} finally {
740	reset();	740	reset(true);
741	}	741	}
742	}	742	}
743		743
Lines 1193-1199 Link Here
1193	}	1193	}
1194	} catch (AbortCompilation e) { // ignore this exception for now since it typically means we cannot find java.lang.Object	1194	} catch (AbortCompilation e) { // ignore this exception for now since it typically means we cannot find java.lang.Object
1195	} finally {	1195	} finally {
1196	reset();	1196	reset(true);
1197	}	1197	}
1198	}	1198	}
1199		1199

Lines 110-116 Link Here

(-)model/org/eclipse/jdt/internal/core/eval/EvaluationContextWrapper.java (-1 / +2 lines)
110	environment,	110	environment,
111	requestor,	111	requestor,
112	this.project.getOptions(true),	112	this.project.getOptions(true),
113	this.project	113	this.project,
		114	owner
114	);	115	);
115	}	116	}
116	/**	117	/**

Lines 50-56 Link Here

(-)search/org/eclipse/jdt/internal/core/search/indexing/SourceIndexer.java (-1 / +1 lines)
50	IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(path.segment(0));	50	IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(path.segment(0));
51	parser = JavaModelManager.getJavaModelManager().indexManager.getSourceElementParser(JavaCore.create(project), requestor);	51	parser = JavaModelManager.getJavaModelManager().indexManager.getSourceElementParser(JavaCore.create(project), requestor);
52	} else {	52	} else {
53	parser.requestor = requestor;	53	parser.setRequestor(requestor);
54	}	54	}
55		55
56	// Launch the parser	56	// Launch the parser

Lines 309-316 Link Here

(-)codeassist/org/eclipse/jdt/internal/codeassist/impl/Engine.java (-2 / +2 lines)
309	return null;	309	return null;
310	}	310	}
311		311
312	protected void reset() {	312	protected void reset(boolean resetLookupEnvironment) {
313	lookupEnvironment.reset();	313	if (resetLookupEnvironment) lookupEnvironment.reset();
314	}	314	}
315		315
316	public static char[] getTypeSignature(TypeBinding typeBinding) {	316	public static char[] getTypeSignature(TypeBinding typeBinding) {




package org.eclipse.jdt.internal.compiler;

import org.eclipse.jdt.core.compiler.CategorizedProblem;
import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
import org.eclipse.jdt.internal.compiler.ast.Annotation;
import org.eclipse.jdt.internal.compiler.ast.Expression;
import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;
import org.eclipse.jdt.internal.compiler.ast.ImportReference;
import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;

/*
 * Part of the source element parser responsible for building the output. It

		public boolean secondary;
		public boolean anonymousMember;
		public Annotation[] annotations;
		public TypeDeclaration node;
	}
	
	public static class TypeParameterInfo {

		public TypeParameterInfo[] typeParameters;
		public char[][] categories;
		public Annotation[] annotations;
		public AbstractMethodDeclaration node;
	}
	
	public static class FieldInfo {

		public int nameSourceEnd;
		public char[][] categories;
		public Annotation[] annotations;
		public FieldDeclaration node;
	}

	void acceptAnnotationTypeReference(char[][] annotation, int sourceStart, int sourceEnd);




 *******************************************************************************/
package org.eclipse.jdt.internal.compiler;

import java.util.ArrayList;
import java.util.HashMap;

import org.eclipse.core.runtime.IProgressMonitor;

 */
public class SourceElementParser extends CommentRecorderParser {
	
	ISourceElementRequestor requestor;
	ISourceType sourceType;
	boolean reportReferenceInfo;
	boolean reportLocalDeclarations;
	char[][] superTypeNames;
	int nestedTypeIndex;
	LocalDeclarationVisitor localDeclarationVisitor = null;
	HashtableOfObjectToInt sourceEnds = new HashtableOfObjectToInt();
	HashMap nodesToCategories = new HashMap(); // a map from ASTNode to char[][]
	boolean useSourceJavadocParser = true;
	
	SourceElementNotifier notifier;
 * An ast visitor that visits local type declarations.
 */
public class LocalDeclarationVisitor extends ASTVisitor {
	ArrayList declaringTypes;
	public void pushDeclaringType(TypeDeclaration declaringType) {
		if (this.declaringTypes == null) {
			this.declaringTypes = new ArrayList();
		}
		this.declaringTypes.add(declaringType);
	}
	public void popDeclaringType() {
		this.declaringTypes.remove(this.declaringTypes.size()-1);
	}
	public TypeDeclaration peekDeclaringType() {
		if (this.declaringTypes == null) return null;
		int size = this.declaringTypes.size();
		if (size == 0) return null;
		return (TypeDeclaration) this.declaringTypes.get(size-1);
	}
	public boolean visit(TypeDeclaration typeDeclaration, BlockScope scope) {
		notifySourceElementRequestor(typeDeclaration, sourceType == null, peekDeclaringType());
		return false; // don't visit members as this was done during notifySourceElementRequestor(...)
	}
	public boolean visit(TypeDeclaration typeDeclaration, ClassScope scope) {
		notifySourceElementRequestor(typeDeclaration, sourceType == null, peekDeclaringType());
		return false; // don't visit members as this was done during notifySourceElementRequestor(...)
	}	
}

public SourceElementParser(
		final ISourceElementRequestor requestor, 

			problemFactory),
		optimizeStringLiterals);
	
	this.reportLocalDeclarations = reportLocalDeclarations;
	
	// we want to notify all syntax error with the acceptProblem API
	// To do so, we define the record method of the ProblemReporter
	this.problemReporter = new ProblemReporter(

		}
	};
	this.requestor = requestor;
	typeNames = new char[4][];
	superTypeNames = new char[4][];
	nestedTypeIndex = 0;
	this.options = options;
	
	this.notifier = new SourceElementNotifier(this.requestor, reportLocalDeclarations);
	
	// set specific javadoc parser
	this.useSourceJavadocParser = useSourceJavadocParser;
	if (useSourceJavadocParser) {

	return methodDeclaration;
}
protected CompilationUnitDeclaration endParse(int act) {
	if (sourceType != null) {
		switch (TypeDeclaration.kind(sourceType.getModifiers())) {
			case TypeDeclaration.CLASS_DECL :
				consumeClassDeclaration();
				break;
			case TypeDeclaration.INTERFACE_DECL :
				consumeInterfaceDeclaration();
				break;
			case TypeDeclaration.ENUM_DECL :
				consumeEnumDeclaration();
				break;
			case TypeDeclaration.ANNOTATION_TYPE_DECL :
				consumeAnnotationTypeDeclaration();
				break;
		}
	}
	if (compilationUnit != null) {
		CompilationUnitDeclaration result = super.endParse(act);
		return result;

		return null;
	}		
}
private ISourceElementRequestor.TypeParameterInfo[] getTypeParameterInfos(TypeParameter[] typeParameters) {
	if (typeParameters == null) return null;
	int typeParametersLength = typeParameters.length;
	ISourceElementRequestor.TypeParameterInfo[] result = new ISourceElementRequestor.TypeParameterInfo[typeParametersLength];
	for (int i = 0; i < typeParametersLength; i++) {
		TypeParameter typeParameter = typeParameters[i];
		TypeReference firstBound = typeParameter.type;
		TypeReference[] otherBounds = typeParameter.bounds;
		char[][] typeParameterBounds = null;
		if (firstBound != null) {
			if (otherBounds != null) {
				int otherBoundsLength = otherBounds.length;
				char[][] boundNames = new char[otherBoundsLength+1][];
				boundNames[0] = CharOperation.concatWith(firstBound.getParameterizedTypeName(), '.');
				for (int j = 0; j < otherBoundsLength; j++) {
					boundNames[j+1] = 
						CharOperation.concatWith(otherBounds[j].getParameterizedTypeName(), '.'); 
				}
				typeParameterBounds = boundNames;
			} else {
				typeParameterBounds = new char[][] { CharOperation.concatWith(firstBound.getParameterizedTypeName(), '.')};
			}
		} else {
			typeParameterBounds = CharOperation.NO_CHAR_CHAR;
		}
		ISourceElementRequestor.TypeParameterInfo typeParameterInfo = new ISourceElementRequestor.TypeParameterInfo();
		typeParameterInfo.declarationStart = typeParameter.declarationSourceStart;
		typeParameterInfo.declarationEnd = typeParameter.declarationSourceEnd;
		typeParameterInfo.name = typeParameter.name;
		typeParameterInfo.nameSourceStart = typeParameter.sourceStart;
		typeParameterInfo.nameSourceEnd = typeParameter.sourceEnd;
		typeParameterInfo.bounds = typeParameterBounds;
		result[i] = typeParameterInfo;
	}
	return result;
}
public TypeReference getTypeReference(int dim) {
	/* build a Reference on a variable that may be qualified or not
	 * This variable is a type reference and dim will be its dimensions

	}
	return ref;
}

/*
 * Checks whether one of the annotations is the @Deprecated annotation
 * (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=89807)
 */
private boolean hasDeprecatedAnnotation(Annotation[] annotations) {
	if (annotations != null) {
		for (int i = 0, length = annotations.length; i < length; i++) {
			Annotation annotation = annotations[i];
			if (CharOperation.equals(annotation.type.getLastToken(), TypeConstants.JAVA_LANG_DEPRECATED[2])) {
				return true;
			}
		}
	}
	return false;
}

protected ImportReference newImportReference(char[][] tokens, long[] positions, boolean onDemand, int mod) {
	return new ImportReference(tokens, positions, onDemand, mod);
}

protected SingleNameReference newSingleNameReference(char[] source, long positions) {
	return new SingleNameReference(source, positions);
}
/*
 * Update the bodyStart of the corresponding parse node
 */
public void notifySourceElementRequestor(CompilationUnitDeclaration parsedUnit) {
	if (parsedUnit == null) {
		// when we parse a single type member declaration the compilation unit is null, but we still
		// want to be able to notify the requestor on the created ast node
		if (astStack[0] instanceof AbstractMethodDeclaration) {
			notifySourceElementRequestor((AbstractMethodDeclaration) astStack[0]);
			return;
		}
		return;
	}
	// range check
	boolean isInRange = 
				scanner.initialPosition <= parsedUnit.sourceStart
				&& scanner.eofPosition >= parsedUnit.sourceEnd;
	
	// collect the top level ast nodes
	int length = 0;
	ASTNode[] nodes = null;
	if (sourceType == null){
		if (isInRange) {
			requestor.enterCompilationUnit();
		}
		ImportReference currentPackage = parsedUnit.currentPackage;
		ImportReference[] imports = parsedUnit.imports;
		TypeDeclaration[] types = parsedUnit.types;
		length = 
			(currentPackage == null ? 0 : 1) 
			+ (imports == null ? 0 : imports.length)
			+ (types == null ? 0 : types.length);
		nodes = new ASTNode[length];
		int index = 0;
		if (currentPackage != null) {
			nodes[index++] = currentPackage;
		}
		if (imports != null) {
			for (int i = 0, max = imports.length; i < max; i++) {
				nodes[index++] = imports[i];
			}
		}
		if (types != null) {
			for (int i = 0, max = types.length; i < max; i++) {
				nodes[index++] = types[i];
			}
		}
	} else {
		TypeDeclaration[] types = parsedUnit.types;
		if (types != null) {
			length = types.length;
			nodes = new ASTNode[length];
			for (int i = 0, max = types.length; i < max; i++) {
				nodes[i] = types[i];
			}
		}
	}
	
	// notify the nodes in the syntactical order
	if (nodes != null && length > 0) {
		quickSort(nodes, 0, length-1);
		for (int i=0;i<length;i++) {
			ASTNode node = nodes[i];
			if (node instanceof ImportReference) {
				ImportReference importRef = (ImportReference)node;
				if (node == parsedUnit.currentPackage) {
					notifySourceElementRequestor(importRef, true);
				} else {
					notifySourceElementRequestor(importRef, false);
				}
			} else { // instanceof TypeDeclaration
				notifySourceElementRequestor((TypeDeclaration)node, sourceType == null, null);
			}
		}
	}
	
	if (sourceType == null){
		if (isInRange) {
			requestor.exitCompilationUnit(parsedUnit.sourceEnd);
		}
	}
}

/*
 * Update the bodyStart of the corresponding parse node
 */
public void notifySourceElementRequestor(AbstractMethodDeclaration methodDeclaration) {

	// range check
	boolean isInRange = 
				scanner.initialPosition <= methodDeclaration.declarationSourceStart
				&& scanner.eofPosition >= methodDeclaration.declarationSourceEnd;

	if (methodDeclaration.isClinit()) {
		this.visitIfNeeded(methodDeclaration);
		return;
	}

	if (methodDeclaration.isDefaultConstructor()) {
		if (reportReferenceInfo) {
			ConstructorDeclaration constructorDeclaration = (ConstructorDeclaration) methodDeclaration;
			ExplicitConstructorCall constructorCall = constructorDeclaration.constructorCall;
			if (constructorCall != null) {
				switch(constructorCall.accessMode) {
					case ExplicitConstructorCall.This :
						requestor.acceptConstructorReference(
							typeNames[nestedTypeIndex-1],
							constructorCall.arguments == null ? 0 : constructorCall.arguments.length, 
							constructorCall.sourceStart);
						break;
					case ExplicitConstructorCall.Super :
					case ExplicitConstructorCall.ImplicitSuper :					
						requestor.acceptConstructorReference(
							superTypeNames[nestedTypeIndex-1],
							constructorCall.arguments == null ? 0 : constructorCall.arguments.length, 
							constructorCall.sourceStart);
						break;
				}
			}
		}	
		return;	
	}	
	char[][] argumentTypes = null;
	char[][] argumentNames = null;
	boolean isVarArgs = false;
	Argument[] arguments = methodDeclaration.arguments;
	if (arguments != null) {
		int argumentLength = arguments.length;
		argumentTypes = new char[argumentLength][];
		argumentNames = new char[argumentLength][];
		for (int i = 0; i < argumentLength; i++) {
			argumentTypes[i] = CharOperation.concatWith(arguments[i].type.getParameterizedTypeName(), '.');
			argumentNames[i] = arguments[i].name;
		}
		isVarArgs = arguments[argumentLength-1].isVarArgs();
	}
	char[][] thrownExceptionTypes = null;
	TypeReference[] thrownExceptions = methodDeclaration.thrownExceptions;
	if (thrownExceptions != null) {
		int thrownExceptionLength = thrownExceptions.length;
		thrownExceptionTypes = new char[thrownExceptionLength][];
		for (int i = 0; i < thrownExceptionLength; i++) {
			thrownExceptionTypes[i] = 
				CharOperation.concatWith(thrownExceptions[i].getParameterizedTypeName(), '.'); 
		}
	}
	// by default no selector end position
	int selectorSourceEnd = -1;
	if (methodDeclaration.isConstructor()) {
		selectorSourceEnd = this.sourceEnds.get(methodDeclaration);
		if (isInRange){
			int currentModifiers = methodDeclaration.modifiers;
			if (isVarArgs)
				currentModifiers |= ClassFileConstants.AccVarargs;
			
			// remember deprecation so as to not lose it below
			boolean deprecated = (currentModifiers & ClassFileConstants.AccDeprecated) != 0 || hasDeprecatedAnnotation(methodDeclaration.annotations);
			
			ISourceElementRequestor.MethodInfo methodInfo = new ISourceElementRequestor.MethodInfo();
			methodInfo.isConstructor = true;
			methodInfo.declarationStart = methodDeclaration.declarationSourceStart;
			methodInfo.modifiers = deprecated ? (currentModifiers & ExtraCompilerModifiers.AccJustFlag) | ClassFileConstants.AccDeprecated : currentModifiers & ExtraCompilerModifiers.AccJustFlag;
			methodInfo.name = methodDeclaration.selector;
			methodInfo.nameSourceStart = methodDeclaration.sourceStart;
			methodInfo.nameSourceEnd = selectorSourceEnd;
			methodInfo.parameterTypes = argumentTypes;
			methodInfo.parameterNames = argumentNames;
			methodInfo.exceptionTypes = thrownExceptionTypes;
			methodInfo.typeParameters = getTypeParameterInfos(methodDeclaration.typeParameters());
			methodInfo.categories = (char[][]) this.nodesToCategories.get(methodDeclaration);
			methodInfo.annotations = methodDeclaration.annotations;
			requestor.enterConstructor(methodInfo);
		}
		if (reportReferenceInfo) {
			ConstructorDeclaration constructorDeclaration = (ConstructorDeclaration) methodDeclaration;
			ExplicitConstructorCall constructorCall = constructorDeclaration.constructorCall;
			if (constructorCall != null) {
				switch(constructorCall.accessMode) {
					case ExplicitConstructorCall.This :
						requestor.acceptConstructorReference(
							typeNames[nestedTypeIndex-1],
							constructorCall.arguments == null ? 0 : constructorCall.arguments.length, 
							constructorCall.sourceStart);
						break;
					case ExplicitConstructorCall.Super :
					case ExplicitConstructorCall.ImplicitSuper :
						requestor.acceptConstructorReference(
							superTypeNames[nestedTypeIndex-1],
							constructorCall.arguments == null ? 0 : constructorCall.arguments.length, 
							constructorCall.sourceStart);
						break;
				}
			}
		}
		this.visitIfNeeded(methodDeclaration);
		if (isInRange){
			requestor.exitConstructor(methodDeclaration.declarationSourceEnd);
		}
		return;
	}
	selectorSourceEnd = this.sourceEnds.get(methodDeclaration);
	if (isInRange) {
		int currentModifiers = methodDeclaration.modifiers;
		if (isVarArgs)
			currentModifiers |= ClassFileConstants.AccVarargs;
		
		// remember deprecation so as to not lose it below
		boolean deprecated = (currentModifiers & ClassFileConstants.AccDeprecated) != 0 || hasDeprecatedAnnotation(methodDeclaration.annotations);	
			
		TypeReference returnType = methodDeclaration instanceof MethodDeclaration
			? ((MethodDeclaration) methodDeclaration).returnType
			: null;
		ISourceElementRequestor.MethodInfo methodInfo = new ISourceElementRequestor.MethodInfo();
		methodInfo.isAnnotation = methodDeclaration instanceof AnnotationMethodDeclaration;
		methodInfo.declarationStart = methodDeclaration.declarationSourceStart;
		methodInfo.modifiers = deprecated ? (currentModifiers & ExtraCompilerModifiers.AccJustFlag) | ClassFileConstants.AccDeprecated : currentModifiers & ExtraCompilerModifiers.AccJustFlag;
		methodInfo.returnType = returnType == null ? null : CharOperation.concatWith(returnType.getParameterizedTypeName(), '.');
		methodInfo.name = methodDeclaration.selector;
		methodInfo.nameSourceStart = methodDeclaration.sourceStart;
		methodInfo.nameSourceEnd = selectorSourceEnd;
		methodInfo.parameterTypes = argumentTypes;
		methodInfo.parameterNames = argumentNames;
		methodInfo.exceptionTypes = thrownExceptionTypes;
		methodInfo.typeParameters = getTypeParameterInfos(methodDeclaration.typeParameters());
		methodInfo.categories = (char[][]) this.nodesToCategories.get(methodDeclaration);
		methodInfo.annotations = methodDeclaration.annotations;
		requestor.enterMethod(methodInfo);
	}		
		
	this.visitIfNeeded(methodDeclaration);

	if (isInRange) {
		if (methodDeclaration instanceof AnnotationMethodDeclaration) {
			AnnotationMethodDeclaration annotationMethodDeclaration = (AnnotationMethodDeclaration) methodDeclaration;
			Expression expression = annotationMethodDeclaration.defaultValue;
			if (expression != null) {
				requestor.exitMethod(methodDeclaration.declarationSourceEnd, expression);
				return;
			}
		} 
		requestor.exitMethod(methodDeclaration.declarationSourceEnd, null);
	}
}

/*
* Update the bodyStart of the corresponding parse node
*/
public void notifySourceElementRequestor(FieldDeclaration fieldDeclaration, TypeDeclaration declaringType) {
	
	// range check
	boolean isInRange = 
				scanner.initialPosition <= fieldDeclaration.declarationSourceStart
				&& scanner.eofPosition >= fieldDeclaration.declarationSourceEnd;

	switch(fieldDeclaration.getKind()) {
		case AbstractVariableDeclaration.ENUM_CONSTANT:
			// accept constructor reference for enum constant
			if (fieldDeclaration.initialization instanceof AllocationExpression) {
				AllocationExpression alloc = (AllocationExpression) fieldDeclaration.initialization;
				requestor.acceptConstructorReference(
					declaringType.name,
					alloc.arguments == null ? 0 : alloc.arguments.length, 
					alloc.sourceStart);
			}
			// fall through next case
		case AbstractVariableDeclaration.FIELD:
			int fieldEndPosition = this.sourceEnds.get(fieldDeclaration);
			if (fieldEndPosition == -1) {
				// use the declaration source end by default
				fieldEndPosition = fieldDeclaration.declarationSourceEnd;
			}
			if (isInRange) {
				int currentModifiers = fieldDeclaration.modifiers;
				
				// remember deprecation so as to not lose it below
				boolean deprecated = (currentModifiers & ClassFileConstants.AccDeprecated) != 0 || hasDeprecatedAnnotation(fieldDeclaration.annotations);	
			
				char[] typeName = null;
				if (fieldDeclaration.type == null) {
					// enum constant
					typeName = declaringType.name;
					currentModifiers |= ClassFileConstants.AccEnum;
				} else {
					// regular field
					typeName = CharOperation.concatWith(fieldDeclaration.type.getParameterizedTypeName(), '.');
				}
				ISourceElementRequestor.FieldInfo fieldInfo = new ISourceElementRequestor.FieldInfo();
				fieldInfo.declarationStart = fieldDeclaration.declarationSourceStart;
				fieldInfo.name = fieldDeclaration.name;
				fieldInfo.modifiers = deprecated ? (currentModifiers & ExtraCompilerModifiers.AccJustFlag) | ClassFileConstants.AccDeprecated : currentModifiers & ExtraCompilerModifiers.AccJustFlag;
				fieldInfo.type = typeName;
				fieldInfo.nameSourceStart = fieldDeclaration.sourceStart;
				fieldInfo.nameSourceEnd = fieldDeclaration.sourceEnd;
				fieldInfo.categories = (char[][]) this.nodesToCategories.get(fieldDeclaration);
				fieldInfo.annotations = fieldDeclaration.annotations;
				requestor.enterField(fieldInfo);
			}
			this.visitIfNeeded(fieldDeclaration, declaringType);
			if (isInRange){
				requestor.exitField(
					// filter out initializations that are not a constant (simple check)
					(fieldDeclaration.initialization == null 
							|| fieldDeclaration.initialization instanceof ArrayInitializer
							|| fieldDeclaration.initialization instanceof AllocationExpression
							|| fieldDeclaration.initialization instanceof ArrayAllocationExpression
							|| fieldDeclaration.initialization instanceof Assignment
							|| fieldDeclaration.initialization instanceof ClassLiteralAccess
							|| fieldDeclaration.initialization instanceof MessageSend
							|| fieldDeclaration.initialization instanceof ArrayReference
							|| fieldDeclaration.initialization instanceof ThisReference) ? 
						-1 :  
						fieldDeclaration.initialization.sourceStart, 
					fieldEndPosition,
					fieldDeclaration.declarationSourceEnd);
			}
			break;
		case AbstractVariableDeclaration.INITIALIZER:
			if (isInRange){
				requestor.enterInitializer(
					fieldDeclaration.declarationSourceStart,
					fieldDeclaration.modifiers); 
			}
			this.visitIfNeeded((Initializer)fieldDeclaration);
			if (isInRange){
				requestor.exitInitializer(fieldDeclaration.declarationSourceEnd);
			}
			break;
	}
}
public void notifySourceElementRequestor(
	ImportReference importReference, 
	boolean isPackage) {
	if (isPackage) {
		requestor.acceptPackage(importReference); 
	} else {
		requestor.acceptImport(
			importReference.declarationSourceStart, 
			importReference.declarationSourceEnd, 
			importReference.tokens, 
			(importReference.bits & ASTNode.OnDemand) != 0,
			importReference.modifiers); 
	}
}
public void notifySourceElementRequestor(TypeDeclaration typeDeclaration, boolean notifyTypePresence, TypeDeclaration declaringType) {
	
	if (CharOperation.equals(TypeConstants.PACKAGE_INFO_NAME, typeDeclaration.name)) return;

	// range check
	boolean isInRange = 
		scanner.initialPosition <= typeDeclaration.declarationSourceStart
		&& scanner.eofPosition >= typeDeclaration.declarationSourceEnd;
	
	FieldDeclaration[] fields = typeDeclaration.fields;
	AbstractMethodDeclaration[] methods = typeDeclaration.methods;
	TypeDeclaration[] memberTypes = typeDeclaration.memberTypes;
	int fieldCounter = fields == null ? 0 : fields.length;
	int methodCounter = methods == null ? 0 : methods.length;
	int memberTypeCounter = memberTypes == null ? 0 : memberTypes.length;
	int fieldIndex = 0;
	int methodIndex = 0;
	int memberTypeIndex = 0;
	
	if (notifyTypePresence){
		char[][] interfaceNames = null;
		int superInterfacesLength = 0;
		TypeReference[] superInterfaces = typeDeclaration.superInterfaces;
		if (superInterfaces != null) {
			superInterfacesLength = superInterfaces.length;
			interfaceNames = new char[superInterfacesLength][];
		} else {
			if ((typeDeclaration.bits & ASTNode.IsAnonymousType) != 0) {
				// see PR 3442
				QualifiedAllocationExpression alloc = typeDeclaration.allocation;
				if (alloc != null && alloc.type != null) {
					superInterfaces = new TypeReference[] { alloc.type};
					superInterfacesLength = 1;
					interfaceNames = new char[1][];
				}
			}
		}
		if (superInterfaces != null) {
			for (int i = 0; i < superInterfacesLength; i++) {
				interfaceNames[i] = 
					CharOperation.concatWith(superInterfaces[i].getParameterizedTypeName(), '.'); 
			}
		}
		int kind = TypeDeclaration.kind(typeDeclaration.modifiers);
		char[] implicitSuperclassName = TypeConstants.CharArray_JAVA_LANG_OBJECT;
		if (isInRange) {
			int currentModifiers = typeDeclaration.modifiers;
			
			// remember deprecation so as to not lose it below
			boolean deprecated = (currentModifiers & ClassFileConstants.AccDeprecated) != 0 || hasDeprecatedAnnotation(typeDeclaration.annotations);	
			
			boolean isEnumInit = typeDeclaration.allocation != null && typeDeclaration.allocation.enumConstant != null;
			char[] superclassName;
			if (isEnumInit) {
				currentModifiers |= ClassFileConstants.AccEnum;
				superclassName = declaringType.name;
			} else {
				TypeReference superclass = typeDeclaration.superclass;
				superclassName = superclass != null ? CharOperation.concatWith(superclass.getParameterizedTypeName(), '.') : null;
			}
			ISourceElementRequestor.TypeInfo typeInfo = new ISourceElementRequestor.TypeInfo();
			typeInfo.declarationStart = typeDeclaration.allocation == null ? typeDeclaration.declarationSourceStart : typeDeclaration.allocation.sourceStart;
			typeInfo.modifiers = deprecated ? (currentModifiers & ExtraCompilerModifiers.AccJustFlag) | ClassFileConstants.AccDeprecated : currentModifiers & ExtraCompilerModifiers.AccJustFlag;
			typeInfo.name = typeDeclaration.name;
			typeInfo.nameSourceStart = typeDeclaration.sourceStart;
			typeInfo.nameSourceEnd = sourceEnd(typeDeclaration);
			typeInfo.superclass = superclassName;
			typeInfo.superinterfaces = interfaceNames;
			typeInfo.typeParameters = getTypeParameterInfos(typeDeclaration.typeParameters);
			typeInfo.categories = (char[][]) this.nodesToCategories.get(typeDeclaration);
			typeInfo.secondary = typeDeclaration.isSecondary();
			typeInfo.anonymousMember = typeDeclaration.allocation != null && typeDeclaration.allocation.enclosingInstance != null;
			typeInfo.annotations = typeDeclaration.annotations;
			requestor.enterType(typeInfo);
			switch (kind) {
				case TypeDeclaration.CLASS_DECL :
					if (superclassName != null)
						implicitSuperclassName = superclassName;
					break;
				case TypeDeclaration.INTERFACE_DECL :
					implicitSuperclassName = TypeConstants.CharArray_JAVA_LANG_OBJECT;
					break;
				case TypeDeclaration.ENUM_DECL :
					implicitSuperclassName = TypeConstants.CharArray_JAVA_LANG_ENUM;
					break;
				case TypeDeclaration.ANNOTATION_TYPE_DECL :
					implicitSuperclassName = TypeConstants.CharArray_JAVA_LANG_ANNOTATION_ANNOTATION;
					break;
			}
		}
		if (this.nestedTypeIndex == this.typeNames.length) {
			// need a resize
			System.arraycopy(this.typeNames, 0, (this.typeNames = new char[this.nestedTypeIndex * 2][]), 0, this.nestedTypeIndex);
			System.arraycopy(this.superTypeNames, 0, (this.superTypeNames = new char[this.nestedTypeIndex * 2][]), 0, this.nestedTypeIndex);
		}
		this.typeNames[this.nestedTypeIndex] = typeDeclaration.name;
		this.superTypeNames[this.nestedTypeIndex++] = implicitSuperclassName;
	}
	while ((fieldIndex < fieldCounter)
			|| (memberTypeIndex < memberTypeCounter)
			|| (methodIndex < methodCounter)) {
		FieldDeclaration nextFieldDeclaration = null;
		AbstractMethodDeclaration nextMethodDeclaration = null;
		TypeDeclaration nextMemberDeclaration = null;
		
		int position = Integer.MAX_VALUE;
		int nextDeclarationType = -1;
		if (fieldIndex < fieldCounter) {
			nextFieldDeclaration = fields[fieldIndex];
			if (nextFieldDeclaration.declarationSourceStart < position) {
				position = nextFieldDeclaration.declarationSourceStart;
				nextDeclarationType = 0; // FIELD
			}
		}
		if (methodIndex < methodCounter) {
			nextMethodDeclaration = methods[methodIndex];
			if (nextMethodDeclaration.declarationSourceStart < position) {
				position = nextMethodDeclaration.declarationSourceStart;
				nextDeclarationType = 1; // METHOD
			}
		}
		if (memberTypeIndex < memberTypeCounter) {
			nextMemberDeclaration = memberTypes[memberTypeIndex];
			if (nextMemberDeclaration.declarationSourceStart < position) {
				position = nextMemberDeclaration.declarationSourceStart;
				nextDeclarationType = 2; // MEMBER
			}
		}
		switch (nextDeclarationType) {
			case 0 :
				fieldIndex++;
				notifySourceElementRequestor(nextFieldDeclaration, typeDeclaration);
				break;
			case 1 :
				methodIndex++;
				notifySourceElementRequestor(nextMethodDeclaration);
				break;
			case 2 :
				memberTypeIndex++;
				notifySourceElementRequestor(nextMemberDeclaration, true, null);
		}
	}
	if (notifyTypePresence){
		if (isInRange){
			requestor.exitType(typeDeclaration.declarationSourceEnd);
		}
		nestedTypeIndex--;
	}
}
public CompilationUnitDeclaration parseCompilationUnit(
	ICompilationUnit unit, 
	boolean fullParse,

		}
		int initialStart = this.scanner.initialPosition;
		int initialEnd = this.scanner.eofPosition;
		if (this.reportLocalDeclarations || fullParse){
			diet = false;
			this.getMethodBodies(parsedUnit);
		}
		this.scanner.resetTo(initialStart, initialEnd);
		this.notifier.notifySourceElementRequestor(
				parsedUnit,
				this.scanner.initialPosition,
				this.scanner.eofPosition,
				this.reportReferenceInfo,
				this.sourceEnds,
				this.nodesToCategories);
		return parsedUnit;
	} catch (AbortCompilation e) {
		// ignore this exception

	}
	return parsedUnit;
}
/*
 * Sort the given ast nodes by their positions.
 */
private static void quickSort(ASTNode[] sortedCollection, int left, int right) {
	int original_left = left;
	int original_right = right;
	ASTNode mid = sortedCollection[left +  (right - left) / 2];
	do {
		while (sortedCollection[left].sourceStart < mid.sourceStart) {
			left++;
		}
		while (mid.sourceStart < sortedCollection[right].sourceStart) {
			right--;
		}
		if (left <= right) {
			ASTNode tmp = sortedCollection[left];
			sortedCollection[left] = sortedCollection[right];
			sortedCollection[right] = tmp;
			left++;
			right--;
		}
	} while (left <= right);
	if (original_left < right) {
		quickSort(sortedCollection, original_left, right);
	}
	if (left < original_right) {
		quickSort(sortedCollection, left, original_right);
	}
}
private void rememberCategories() {
	if (this.useSourceJavadocParser) {
		SourceJavadocParser sourceJavadocParser = (SourceJavadocParser) this.javadocParser;

private void reset() {
	this.sourceEnds = new HashtableOfObjectToInt();
	this.nodesToCategories = new HashMap();
	typeNames = new char[4][];
	superTypeNames = new char[4][];
	nestedTypeIndex = 0;
}
private int sourceEnd(TypeDeclaration typeDeclaration) {
	if ((typeDeclaration.bits & ASTNode.IsAnonymousType) != 0) {
		QualifiedAllocationExpression allocation = typeDeclaration.allocation;
		if (allocation.type == null) // case of enum constant body
			return typeDeclaration.sourceEnd;
		return allocation.type.sourceEnd;
	} else {
		return typeDeclaration.sourceEnd;
	}
}
private void visitIfNeeded(AbstractMethodDeclaration method) {
	if (this.localDeclarationVisitor != null 
		&& (method.bits & ASTNode.HasLocalType) != 0) {
			if (method instanceof ConstructorDeclaration) {
				ConstructorDeclaration constructorDeclaration = (ConstructorDeclaration) method;
				if (constructorDeclaration.constructorCall != null) {
					constructorDeclaration.constructorCall.traverse(this.localDeclarationVisitor, method.scope);
				}
			}
			if (method.statements != null) {
				int statementsLength = method.statements.length;
				for (int i = 0; i < statementsLength; i++)
					method.statements[i].traverse(this.localDeclarationVisitor, method.scope);
			}
	}
}
public void setRequestor(ISourceElementRequestor requestor) {
	this.requestor = requestor;
	this.notifier.requestor = requestor;
		&& (field.bits & ASTNode.HasLocalType) != 0) {
			if (field.initialization != null) {
				try {
					this.localDeclarationVisitor.pushDeclaringType(declaringType);
					field.initialization.traverse(this.localDeclarationVisitor, (MethodScope) null);
				} finally {
					this.localDeclarationVisitor.popDeclaringType();
				}
			}
	}
}

private void visitIfNeeded(Initializer initializer) {
	if (this.localDeclarationVisitor != null 
		&& (initializer.bits & ASTNode.HasLocalType) != 0) {
			if (initializer.block != null) {
				initializer.block.traverse(this.localDeclarationVisitor, null);
			}
	}
}
}




	return createArrayType(binding, dimension);
}

public TypeBinding getTypeFromTypeSignature(SignatureWrapper wrapper, TypeVariableBinding[] staticVariables, ReferenceBinding enclosingType, char[][][] missingTypeNames) {
	// TypeVariableSignature = 'T' Identifier ';'
	// ArrayTypeSignature = '[' TypeSignature
	// ClassTypeSignature = 'L' Identifier TypeArgs(optional) ';'

				return dimension == 0 ? (TypeBinding) staticVariables[i] : createArrayType(staticVariables[i], dimension);
	    ReferenceBinding initialType = enclosingType;
		do {
			TypeVariableBinding[] enclosingTypeVariables;
			if (enclosingType instanceof BinaryTypeBinding) { // compiler normal case, no eager resolution of binary variables
				enclosingTypeVariables = ((BinaryTypeBinding)enclosingType).typeVariables; // do not trigger resolution of variables
			} else { // codepath only use by codeassist for decoding signatures
				enclosingTypeVariables = enclosingType.typeVariables();
			}
			for (int i = enclosingTypeVariables.length; --i >= 0;)
				if (CharOperation.equals(enclosingTypeVariables[i].sourceName, wrapper.signature, varStart, varEnd))
					return dimension == 0 ? (TypeBinding) enclosingTypeVariables[i] : createArrayType(enclosingTypeVariables[i], dimension);
		} while ((enclosingType = enclosingType.enclosingType()) != null);
		problemReporter.undefinedTypeVariableSignature(CharOperation.subarray(wrapper.signature, varStart, varEnd), initialType);
		return null; // cannot reach this, since previous problem will abort compilation




public final class CompletionContext extends InternalCompletionContext {

	/**
	 * The completed token is the first token of a member declaration.<br>
	 * e.g.
	 * <pre>
	 * public class X {
	 *   Foo| // completion occurs at |
	 * }
	 * </pre>
	 * 
	 * @see #getTokenLocation()
	 * 
	 * @since 3.4
	 */
	public static final int TL_MEMBER_START = 1;
	
	/**
	 * The completed token is the first token of a statement.<br>
	 * e.g.
	 * <pre>
	 * public class X {
	 *   public void bar() {
	 *     Foo| // completion occurs at |
	 *   }
	 * }
	 * </pre>
	 * 
	 * @see #getTokenLocation()
	 * 
	 * @since 3.4
	 */
	public static final int TL_STATEMENT_START = 2;
	
	/**
	 * The completion token is unknown.
	 * @since 3.2
	 */

	public boolean isInJavadocFormalReference() {
		return (this.javadoc & CompletionOnJavadoc.FORMAL_REFERENCE) != 0;
	}
	
	/**
	 * Returns whether this completion context is an extended context.
	 * Some methods of this context can be used only if this context is an extended context but an extended context consumes more memory.
	 * 
	 * @return <code>true</code> if this completion context is an extended context.
	 * 
	 * @since 3.4
	 */
	public boolean isExtended() {
		return this.extendedContext != null;
	}

	/**
	 * Return signatures of expected types of a potential completion proposal at the completion position.

		return this.offset;
	}
	
	
	/**
	 * Returns the innermost enclosing Java element which contains the completion location or <code>null</code> if this element cannot be computed.
	 * The returned Java element and all Java elements in the same compilation unit which can be navigated to from the returned Java element are special Java elements:
	 * <ul>
	 * <li>they are based on the current content of the compilation unit's buffer, they are not the result of a reconcile operation</li>
	 * <li>they are not updated if the buffer changes.</li>
	 * <li>they do not contain local types which are not visible from the completion location.</li>
	 * <li>they do not give information about categories. {@link IMember#getCategories()} will return an empty array</li>
	 * </ul>
	 * 
	 * Reasons for returning <code>null</code> include:
	 * <ul>
	 * <li>the compilation unit no longer exists</li>
	 * <li>the completion occurred in a binary type. However this restriction might be relaxed in the future.</li>
	 * </ul>
	 * 
	 * @return the innermost enclosing Java element which contains the completion location or <code>null</code> if this element cannot be computed.
	 * 
	 * @exception UnsupportedOperationException if the context is not an extended context
	 * 
	 * @since 3.4
	 */
	public IJavaElement getEnclosingElement() {
		if (!this.isExtended()) throw new UnsupportedOperationException("Operation only supported in extended context"); //$NON-NLS-1$
		
		if (this.extendedContext == null) return null;
		
		return this.extendedContext.getEnclosingElement();
	}
	
	/**
	 * Return the elements which are visible from the completion location and which can be assigned to the given type.
	 * An element is assignable if its type can be assigned to a variable
	 * of the given type, as specified in section 5.2 of <em>The Java Language
	 * Specification, Third Edition</em> (JLS3).
	 * A visible element is either:
	 * <ul>
	 * <li>a {@link ILocalVariable} - the element type is {@link ILocalVariable#getTypeSignature()}</li>
	 * <li>a {@link IField} - the element type is {@link IField#getTypeSignature()}</li>
	 * <li>a {@link IMethod} - the element type is {@link IMethod#getReturnType()}</li>
	 * </ul>
	 * 
	 * Returned elements defined in the completed compilation unit are special Java elements:
	 * <ul>
	 * <li>they are based on the current content of the compilation unit's buffer, they are not the result of a reconcile operation</li>
	 * <li>they are not updated if the buffer changes.</li>
	 * <li>they do not contain local types which are not visible from the completion location.</li>
	 * <li>they do not give information about categories. {@link IMember#getCategories()} will return an empty array</li>
	 * </ul>
	 * 
	 * Note the array can be empty if:
	 * <ul>
	 * <li>the compilation unit no longer exists</li>
	 * <li>the completion occurred in a binary type. However this restriction might be relaxed in the future.</li>
	 * </ul>
	 * 
	 * @param typeSignature elements which can be assigned to this type are returned.
	 * 		If <code>null</code> there is no constraint on the type of the returned elements.
	 * 
	 * @return elements which are visible from the completion location and which can be assigned to the given type.
	 * 
	 * @exception UnsupportedOperationException if the context is not an extended context
	 * 
	 * @see #isExtended()
	 * 
	 * @since 3.4
	 */
	public IJavaElement[] getVisibleElements(String typeSignature) {
		if (!this.isExtended()) throw new UnsupportedOperationException("Operation only supported in extended context"); //$NON-NLS-1$
		
		if (this.extendedContext == null) return new IJavaElement[0];
		
		return this.extendedContext.getVisibleElements(typeSignature);
	}
	
	public String toString() {
		StringBuffer buffer = new StringBuffer();

		buffer.append('\n');
		
		if (tokenLocation == 0) {
			buffer.append("tokenLocation=UNKNOWN"); //$NON-NLS-1$
		} else {
			buffer.append("tokenLocation={"); //$NON-NLS-1$
			boolean first = true;
			if ((tokenLocation & CompletionContext.TL_MEMBER_START) != 0) {
				if (!first) buffer.append(',');

			buffer.append('}');
		}
		buffer.append('\n');
		
		return buffer.toString();
	}
}

Lines 68-73 Link Here

(-)model/org/eclipse/jdt/core/CompletionRequestor.java (+31 lines)
68	* 1 << completionProposalKind	68	* 1 << completionProposalKind
69	*/	69	*/
70	private int requiredProposalAllowSet[] = null;	70	private int requiredProposalAllowSet[] = null;
		71
		72	private boolean requireExtendedContext = false;
71		73
72	/**	74	/**
73	* Creates a new completion requestor.	75	* Creates a new completion requestor.
Lines 324-327 Link Here
324	public void acceptContext(CompletionContext context) {	326	public void acceptContext(CompletionContext context) {
325	// do nothing	327	// do nothing
326	}	328	}
		329
		330	/**
		331	* Returns whether this requestor requires an extended context.
		332	*
		333	* By default this method return <code>false</code>.
		334	*
		335	* @return <code>true</code> if this requestor requires an extended context.
		336	*
		337	* @see CompletionContext#isExtended()
		338	*
		339	* @since 3.4
		340	*/
		341	public boolean isExtendedContextRequired() {
		342	return this.requireExtendedContext;
		343	}
		344
		345
		346	/**
		347	* Sets whether this requestor requires an extended context.
		348	*
		349	* @param require <code>true</code> if this requestor requires an extended context.
		350	*
		351	* @see CompletionContext#isExtended()
		352	*
		353	* @since 3.4
		354	*/
		355	public void setRequireExtendedContext(boolean require) {
		356	this.requireExtendedContext = require;
		357	}
327	}	358	}

Lines 19-24 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/SuperTypeNamesCollector.java (+1 lines)
19	import org.eclipse.jdt.internal.compiler.ASTVisitor;	19	import org.eclipse.jdt.internal.compiler.ASTVisitor;
20	import org.eclipse.jdt.internal.compiler.CompilationResult;	20	import org.eclipse.jdt.internal.compiler.CompilationResult;
21	import org.eclipse.jdt.internal.compiler.ast.*;	21	import org.eclipse.jdt.internal.compiler.ast.*;
		22	import org.eclipse.jdt.internal.compiler.ast.Initializer;
22	import org.eclipse.jdt.internal.compiler.env.AccessRuleSet;	23	import org.eclipse.jdt.internal.compiler.env.AccessRuleSet;
23	import org.eclipse.jdt.internal.compiler.lookup.*;	24	import org.eclipse.jdt.internal.compiler.lookup.*;
24	import org.eclipse.jdt.internal.compiler.problem.AbortCompilation;	25	import org.eclipse.jdt.internal.compiler.problem.AbortCompilation;

Lines 14-20 Link Here

(-)batch/org/eclipse/jdt/internal/compiler/batch/messages.properties (-1 / +1 lines)
14	#Format: compiler.name = word1 word2 word3	14	#Format: compiler.name = word1 word2 word3
15	compiler.name = Eclipse Java Compiler	15	compiler.name = Eclipse Java Compiler
16	#Format: compiler.version = 0.XXX[, other words (don't forget the comma if adding other words)]	16	#Format: compiler.version = 0.XXX[, other words (don't forget the comma if adding other words)]
17	compiler.version = 0.843, pre-3.4.0 milestone-6	17	compiler.version = 0.844, pre-3.4.0 milestone-6
18	compiler.copyright = Copyright IBM Corp 2000, 2008. All rights reserved.	18	compiler.copyright = Copyright IBM Corp 2000, 2008. All rights reserved.
19		19
20	### progress	20	### progress

Lines 36-41 Link Here

(-)model/org/eclipse/jdt/internal/compiler/parser/SourceTypeConverter.java (+1 lines)
36	import org.eclipse.jdt.internal.compiler.CompilationResult;	36	import org.eclipse.jdt.internal.compiler.CompilationResult;
37	import org.eclipse.jdt.internal.compiler.ast.*;	37	import org.eclipse.jdt.internal.compiler.ast.*;
38	import org.eclipse.jdt.internal.compiler.ast.Annotation;	38	import org.eclipse.jdt.internal.compiler.ast.Annotation;
		39	import org.eclipse.jdt.internal.compiler.ast.Initializer;
39	import org.eclipse.jdt.internal.compiler.ast.TypeParameter;	40	import org.eclipse.jdt.internal.compiler.ast.TypeParameter;
40	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;	41	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
41	import org.eclipse.jdt.internal.compiler.env.*;	42	import org.eclipse.jdt.internal.compiler.env.*;




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

import java.util.Map;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.internal.core.Annotation;
import org.eclipse.jdt.internal.core.JavaElement;

public class AssistAnnotation extends Annotation {
	private Map infoCache;
	public AssistAnnotation(JavaElement parent, String name, Map infoCache) {
		super(parent, name);
		this.infoCache = infoCache;
	}
	
	public Object getElementInfo(IProgressMonitor monitor) throws JavaModelException {
		return infoCache.get(this);
	}
}




/*******************************************************************************
 * Copyright (c) 2008 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 java.util.ArrayList;
import java.util.Map;

import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.internal.compiler.ast.ASTNode;
import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
import org.eclipse.jdt.internal.compiler.ast.AbstractVariableDeclaration;
import org.eclipse.jdt.internal.compiler.ast.AllocationExpression;
import org.eclipse.jdt.internal.compiler.ast.Annotation;
import org.eclipse.jdt.internal.compiler.ast.AnnotationMethodDeclaration;
import org.eclipse.jdt.internal.compiler.ast.Argument;
import org.eclipse.jdt.internal.compiler.ast.ArrayAllocationExpression;
import org.eclipse.jdt.internal.compiler.ast.ArrayInitializer;
import org.eclipse.jdt.internal.compiler.ast.ArrayReference;
import org.eclipse.jdt.internal.compiler.ast.Assignment;
import org.eclipse.jdt.internal.compiler.ast.ClassLiteralAccess;
import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
import org.eclipse.jdt.internal.compiler.ast.ConstructorDeclaration;
import org.eclipse.jdt.internal.compiler.ast.ExplicitConstructorCall;
import org.eclipse.jdt.internal.compiler.ast.Expression;
import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;
import org.eclipse.jdt.internal.compiler.ast.ImportReference;
import org.eclipse.jdt.internal.compiler.ast.Initializer;
import org.eclipse.jdt.internal.compiler.ast.MessageSend;
import org.eclipse.jdt.internal.compiler.ast.MethodDeclaration;
import org.eclipse.jdt.internal.compiler.ast.QualifiedAllocationExpression;
import org.eclipse.jdt.internal.compiler.ast.ThisReference;
import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
import org.eclipse.jdt.internal.compiler.ast.TypeParameter;
import org.eclipse.jdt.internal.compiler.ast.TypeReference;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
import org.eclipse.jdt.internal.compiler.lookup.ClassScope;
import org.eclipse.jdt.internal.compiler.lookup.ExtraCompilerModifiers;
import org.eclipse.jdt.internal.compiler.lookup.MethodScope;
import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
import org.eclipse.jdt.internal.compiler.util.HashtableOfObjectToInt;

public class SourceElementNotifier {
	/**
	 * An ast visitor that visits local type declarations.
	 */
	public class LocalDeclarationVisitor extends ASTVisitor {
		ArrayList declaringTypes;
		public void pushDeclaringType(TypeDeclaration declaringType) {
			if (this.declaringTypes == null) {
				this.declaringTypes = new ArrayList();
			}
			this.declaringTypes.add(declaringType);
		}
		public void popDeclaringType() {
			this.declaringTypes.remove(this.declaringTypes.size()-1);
		}
		public TypeDeclaration peekDeclaringType() {
			if (this.declaringTypes == null) return null;
			int size = this.declaringTypes.size();
			if (size == 0) return null;
			return (TypeDeclaration) this.declaringTypes.get(size-1);
		}
		public boolean visit(TypeDeclaration typeDeclaration, BlockScope scope) {
			notifySourceElementRequestor(typeDeclaration, true, peekDeclaringType());
			return false; // don't visit members as this was done during notifySourceElementRequestor(...)
		}
		public boolean visit(TypeDeclaration typeDeclaration, ClassScope scope) {
			notifySourceElementRequestor(typeDeclaration, true, peekDeclaringType());
			return false; // don't visit members as this was done during notifySourceElementRequestor(...)
		}	
	}
	
	ISourceElementRequestor requestor;
	boolean reportReferenceInfo;
	char[][] typeNames;
	char[][] superTypeNames;
	int nestedTypeIndex;
	LocalDeclarationVisitor localDeclarationVisitor = null;
	
	HashtableOfObjectToInt sourceEnds;
	Map nodesToCategories;
	
	int initialPosition;
	int eofPosition;
	
public SourceElementNotifier(ISourceElementRequestor requestor, boolean reportLocalDeclarations) {
	this.requestor = requestor;
	if (reportLocalDeclarations) {
		this.localDeclarationVisitor = new LocalDeclarationVisitor();
	}
	typeNames = new char[4][];
	superTypeNames = new char[4][];
	nestedTypeIndex = 0;
}
protected char[][][] getArguments(Argument[] arguments) {
	int argumentLength = arguments.length;
	char[][] argumentTypes = new char[argumentLength][];
	char[][] argumentNames = new char[argumentLength][];
	for (int i = 0; i < argumentLength; i++) {
		argumentTypes[i] = CharOperation.concatWith(arguments[i].type.getParameterizedTypeName(), '.');
		argumentNames[i] = arguments[i].name;
	}
	
	return new char[][][] {argumentTypes, argumentNames};
}
protected char[][] getInterfaceNames(TypeDeclaration typeDeclaration) {
	char[][] interfaceNames = null;
	int superInterfacesLength = 0;
	TypeReference[] superInterfaces = typeDeclaration.superInterfaces;
	if (superInterfaces != null) {
		superInterfacesLength = superInterfaces.length;
		interfaceNames = new char[superInterfacesLength][];
	} else {
		if ((typeDeclaration.bits & ASTNode.IsAnonymousType) != 0) {
			// see PR 3442
			QualifiedAllocationExpression alloc = typeDeclaration.allocation;
			if (alloc != null && alloc.type != null) {
				superInterfaces = new TypeReference[] { alloc.type};
				superInterfacesLength = 1;
				interfaceNames = new char[1][];
			}
		}
	}
	if (superInterfaces != null) {
		for (int i = 0; i < superInterfacesLength; i++) {
			interfaceNames[i] = 
				CharOperation.concatWith(superInterfaces[i].getParameterizedTypeName(), '.'); 
		}
	}
	return interfaceNames;
}
protected char[] getSuperclassName(TypeDeclaration typeDeclaration) {
	TypeReference superclass = typeDeclaration.superclass;
	return superclass != null ? CharOperation.concatWith(superclass.getParameterizedTypeName(), '.') : null;
}
protected char[][] getThrownExceptions(AbstractMethodDeclaration methodDeclaration) {
	char[][] thrownExceptionTypes = null;
	TypeReference[] thrownExceptions = methodDeclaration.thrownExceptions;
	if (thrownExceptions != null) {
		int thrownExceptionLength = thrownExceptions.length;
		thrownExceptionTypes = new char[thrownExceptionLength][];
		for (int i = 0; i < thrownExceptionLength; i++) {
			thrownExceptionTypes[i] = 
				CharOperation.concatWith(thrownExceptions[i].getParameterizedTypeName(), '.'); 
		}
	}
	return thrownExceptionTypes;
}
protected char[][] getTypeParameterBounds(TypeParameter typeParameter) {
	TypeReference firstBound = typeParameter.type;
	TypeReference[] otherBounds = typeParameter.bounds;
	char[][] typeParameterBounds = null;
	if (firstBound != null) {
		if (otherBounds != null) {
			int otherBoundsLength = otherBounds.length;
			char[][] boundNames = new char[otherBoundsLength+1][];
			boundNames[0] = CharOperation.concatWith(firstBound.getParameterizedTypeName(), '.');
			for (int j = 0; j < otherBoundsLength; j++) {
				boundNames[j+1] = 
					CharOperation.concatWith(otherBounds[j].getParameterizedTypeName(), '.'); 
			}
			typeParameterBounds = boundNames;
		} else {
			typeParameterBounds = new char[][] { CharOperation.concatWith(firstBound.getParameterizedTypeName(), '.')};
		}
	} else {
		typeParameterBounds = CharOperation.NO_CHAR_CHAR;
	}
	
	return typeParameterBounds;
}
private ISourceElementRequestor.TypeParameterInfo[] getTypeParameterInfos(TypeParameter[] typeParameters) {
	if (typeParameters == null) return null;
	int typeParametersLength = typeParameters.length;
	ISourceElementRequestor.TypeParameterInfo[] result = new ISourceElementRequestor.TypeParameterInfo[typeParametersLength];
	for (int i = 0; i < typeParametersLength; i++) {
		TypeParameter typeParameter = typeParameters[i];
		char[][] typeParameterBounds = this.getTypeParameterBounds(typeParameter);
		ISourceElementRequestor.TypeParameterInfo typeParameterInfo = new ISourceElementRequestor.TypeParameterInfo();
		typeParameterInfo.declarationStart = typeParameter.declarationSourceStart;
		typeParameterInfo.declarationEnd = typeParameter.declarationSourceEnd;
		typeParameterInfo.name = typeParameter.name;
		typeParameterInfo.nameSourceStart = typeParameter.sourceStart;
		typeParameterInfo.nameSourceEnd = typeParameter.sourceEnd;
		typeParameterInfo.bounds = typeParameterBounds;
		result[i] = typeParameterInfo;
	}
	return result;
}
/*
 * Checks whether one of the annotations is the @Deprecated annotation
 * (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=89807)
 */
private boolean hasDeprecatedAnnotation(Annotation[] annotations) {
	if (annotations != null) {
		for (int i = 0, length = annotations.length; i < length; i++) {
			Annotation annotation = annotations[i];
			if (CharOperation.equals(annotation.type.getLastToken(), TypeConstants.JAVA_LANG_DEPRECATED[2])) {
				return true;
			}
		}
	}
	return false;
}
/*
 * Update the bodyStart of the corresponding parse node
 */
protected void notifySourceElementRequestor(AbstractMethodDeclaration methodDeclaration) {

	// range check
	boolean isInRange = 
				initialPosition <= methodDeclaration.declarationSourceStart
				&& eofPosition >= methodDeclaration.declarationSourceEnd;

	if (methodDeclaration.isClinit()) {
		this.visitIfNeeded(methodDeclaration);
		return;
	}

	if (methodDeclaration.isDefaultConstructor()) {
		if (reportReferenceInfo) {
			ConstructorDeclaration constructorDeclaration = (ConstructorDeclaration) methodDeclaration;
			ExplicitConstructorCall constructorCall = constructorDeclaration.constructorCall;
			if (constructorCall != null) {
				switch(constructorCall.accessMode) {
					case ExplicitConstructorCall.This :
						requestor.acceptConstructorReference(
							typeNames[nestedTypeIndex-1],
							constructorCall.arguments == null ? 0 : constructorCall.arguments.length, 
							constructorCall.sourceStart);
						break;
					case ExplicitConstructorCall.Super :
					case ExplicitConstructorCall.ImplicitSuper :					
						requestor.acceptConstructorReference(
							superTypeNames[nestedTypeIndex-1],
							constructorCall.arguments == null ? 0 : constructorCall.arguments.length, 
							constructorCall.sourceStart);
						break;
				}
			}
		}	
		return;	
	}	
	char[][] argumentTypes = null;
	char[][] argumentNames = null;
	boolean isVarArgs = false;
	Argument[] arguments = methodDeclaration.arguments;
	if (arguments != null) {
		char[][][] argumentTypesAndNames = this.getArguments(arguments);
		argumentTypes = argumentTypesAndNames[0];
		argumentNames = argumentTypesAndNames[1];
		
		isVarArgs = arguments[arguments.length-1].isVarArgs();
	}
	char[][] thrownExceptionTypes = getThrownExceptions(methodDeclaration);
	// by default no selector end position
	int selectorSourceEnd = -1;
	if (methodDeclaration.isConstructor()) {
		selectorSourceEnd = this.sourceEnds.get(methodDeclaration);
		if (isInRange){
			int currentModifiers = methodDeclaration.modifiers;
			if (isVarArgs)
				currentModifiers |= ClassFileConstants.AccVarargs;
			
			// remember deprecation so as to not lose it below
			boolean deprecated = (currentModifiers & ClassFileConstants.AccDeprecated) != 0 || hasDeprecatedAnnotation(methodDeclaration.annotations);
			
			ISourceElementRequestor.MethodInfo methodInfo = new ISourceElementRequestor.MethodInfo();
			methodInfo.isConstructor = true;
			methodInfo.declarationStart = methodDeclaration.declarationSourceStart;
			methodInfo.modifiers = deprecated ? (currentModifiers & ExtraCompilerModifiers.AccJustFlag) | ClassFileConstants.AccDeprecated : currentModifiers & ExtraCompilerModifiers.AccJustFlag;
			methodInfo.name = methodDeclaration.selector;
			methodInfo.nameSourceStart = methodDeclaration.sourceStart;
			methodInfo.nameSourceEnd = selectorSourceEnd;
			methodInfo.parameterTypes = argumentTypes;
			methodInfo.parameterNames = argumentNames;
			methodInfo.exceptionTypes = thrownExceptionTypes;
			methodInfo.typeParameters = getTypeParameterInfos(methodDeclaration.typeParameters());
			methodInfo.categories = (char[][]) this.nodesToCategories.get(methodDeclaration);
			methodInfo.annotations = methodDeclaration.annotations;
			methodInfo.node = methodDeclaration;
			requestor.enterConstructor(methodInfo);
		}
		if (reportReferenceInfo) {
			ConstructorDeclaration constructorDeclaration = (ConstructorDeclaration) methodDeclaration;
			ExplicitConstructorCall constructorCall = constructorDeclaration.constructorCall;
			if (constructorCall != null) {
				switch(constructorCall.accessMode) {
					case ExplicitConstructorCall.This :
						requestor.acceptConstructorReference(
							typeNames[nestedTypeIndex-1],
							constructorCall.arguments == null ? 0 : constructorCall.arguments.length, 
							constructorCall.sourceStart);
						break;
					case ExplicitConstructorCall.Super :
					case ExplicitConstructorCall.ImplicitSuper :
						requestor.acceptConstructorReference(
							superTypeNames[nestedTypeIndex-1],
							constructorCall.arguments == null ? 0 : constructorCall.arguments.length, 
							constructorCall.sourceStart);
						break;
				}
			}
		}
		this.visitIfNeeded(methodDeclaration);
		if (isInRange){
			requestor.exitConstructor(methodDeclaration.declarationSourceEnd);
		}
		return;
	}
	selectorSourceEnd = this.sourceEnds.get(methodDeclaration);
	if (isInRange) {
		int currentModifiers = methodDeclaration.modifiers;
		if (isVarArgs)
			currentModifiers |= ClassFileConstants.AccVarargs;
		
		// remember deprecation so as to not lose it below
		boolean deprecated = (currentModifiers & ClassFileConstants.AccDeprecated) != 0 || hasDeprecatedAnnotation(methodDeclaration.annotations);	
			
		TypeReference returnType = methodDeclaration instanceof MethodDeclaration
			? ((MethodDeclaration) methodDeclaration).returnType
			: null;
		ISourceElementRequestor.MethodInfo methodInfo = new ISourceElementRequestor.MethodInfo();
		methodInfo.isAnnotation = methodDeclaration instanceof AnnotationMethodDeclaration;
		methodInfo.declarationStart = methodDeclaration.declarationSourceStart;
		methodInfo.modifiers = deprecated ? (currentModifiers & ExtraCompilerModifiers.AccJustFlag) | ClassFileConstants.AccDeprecated : currentModifiers & ExtraCompilerModifiers.AccJustFlag;
		methodInfo.returnType = returnType == null ? null : CharOperation.concatWith(returnType.getParameterizedTypeName(), '.');
		methodInfo.name = methodDeclaration.selector;
		methodInfo.nameSourceStart = methodDeclaration.sourceStart;
		methodInfo.nameSourceEnd = selectorSourceEnd;
		methodInfo.parameterTypes = argumentTypes;
		methodInfo.parameterNames = argumentNames;
		methodInfo.exceptionTypes = thrownExceptionTypes;
		methodInfo.typeParameters = getTypeParameterInfos(methodDeclaration.typeParameters());
		methodInfo.categories = (char[][]) this.nodesToCategories.get(methodDeclaration);
		methodInfo.annotations = methodDeclaration.annotations;
		methodInfo.node = methodDeclaration;
		requestor.enterMethod(methodInfo);
	}		
		
	this.visitIfNeeded(methodDeclaration);

	if (isInRange) {
		if (methodDeclaration instanceof AnnotationMethodDeclaration) {
			AnnotationMethodDeclaration annotationMethodDeclaration = (AnnotationMethodDeclaration) methodDeclaration;
			Expression expression = annotationMethodDeclaration.defaultValue;
			if (expression != null) {
				requestor.exitMethod(methodDeclaration.declarationSourceEnd, expression);
				return;
			}
		} 
		requestor.exitMethod(methodDeclaration.declarationSourceEnd, null);
	}
}

/*
 * Update the bodyStart of the corresponding parse node
 */
public void notifySourceElementRequestor(
		CompilationUnitDeclaration parsedUnit,
		int sourceStart,
		int sourceEnd,
		boolean reportReference,
		HashtableOfObjectToInt sourceEndsMap,
		Map nodesToCategoriesMap) {
	
	this.initialPosition = sourceStart;
	this.eofPosition = sourceEnd;
	
	this.reportReferenceInfo = reportReference;
	this.sourceEnds = sourceEndsMap;
	this.nodesToCategories = nodesToCategoriesMap;
	
	try {
		// range check
		boolean isInRange = 
					initialPosition <= parsedUnit.sourceStart
					&& eofPosition >= parsedUnit.sourceEnd;
		
		// collect the top level ast nodes
		int length = 0;
		ASTNode[] nodes = null;
		if (isInRange) {
			requestor.enterCompilationUnit();
		}
		ImportReference currentPackage = parsedUnit.currentPackage;
		ImportReference[] imports = parsedUnit.imports;
		TypeDeclaration[] types = parsedUnit.types;
		length = 
			(currentPackage == null ? 0 : 1) 
			+ (imports == null ? 0 : imports.length)
			+ (types == null ? 0 : types.length);
		nodes = new ASTNode[length];
		int index = 0;
		if (currentPackage != null) {
			nodes[index++] = currentPackage;
		}
		if (imports != null) {
			for (int i = 0, max = imports.length; i < max; i++) {
				nodes[index++] = imports[i];
			}
		}
		if (types != null) {
			for (int i = 0, max = types.length; i < max; i++) {
				nodes[index++] = types[i];
			}
		}
		
		// notify the nodes in the syntactical order
		if (length > 0) {
			quickSort(nodes, 0, length-1);
			for (int i=0;i<length;i++) {
				ASTNode node = nodes[i];
				if (node instanceof ImportReference) {
					ImportReference importRef = (ImportReference)node;
					if (node == parsedUnit.currentPackage) {
						notifySourceElementRequestor(importRef, true);
					} else {
						notifySourceElementRequestor(importRef, false);
					}
				} else { // instanceof TypeDeclaration
					notifySourceElementRequestor((TypeDeclaration)node, true, null);
				}
			}
		}
		
		if (isInRange) {
			requestor.exitCompilationUnit(parsedUnit.sourceEnd);
		}
	} finally {
		this.reset();
	}
}

/*
* Update the bodyStart of the corresponding parse node
*/
protected void notifySourceElementRequestor(FieldDeclaration fieldDeclaration, TypeDeclaration declaringType) {
	
	// range check
	boolean isInRange = 
				initialPosition <= fieldDeclaration.declarationSourceStart
				&& eofPosition >= fieldDeclaration.declarationSourceEnd;

	switch(fieldDeclaration.getKind()) {
		case AbstractVariableDeclaration.ENUM_CONSTANT:
			if (this.reportReferenceInfo) {
				// accept constructor reference for enum constant
				if (fieldDeclaration.initialization instanceof AllocationExpression) {
					AllocationExpression alloc = (AllocationExpression) fieldDeclaration.initialization;
					requestor.acceptConstructorReference(
						declaringType.name,
						alloc.arguments == null ? 0 : alloc.arguments.length, 
						alloc.sourceStart);
				}
			}
			// fall through next case
		case AbstractVariableDeclaration.FIELD:
			int fieldEndPosition = this.sourceEnds.get(fieldDeclaration);
			if (fieldEndPosition == -1) {
				// use the declaration source end by default
				fieldEndPosition = fieldDeclaration.declarationSourceEnd;
			}
			if (isInRange) {
				int currentModifiers = fieldDeclaration.modifiers;
				
				// remember deprecation so as to not lose it below
				boolean deprecated = (currentModifiers & ClassFileConstants.AccDeprecated) != 0 || hasDeprecatedAnnotation(fieldDeclaration.annotations);	
			
				char[] typeName = null;
				if (fieldDeclaration.type == null) {
					// enum constant
					typeName = declaringType.name;
					currentModifiers |= ClassFileConstants.AccEnum;
				} else {
					// regular field
					typeName = CharOperation.concatWith(fieldDeclaration.type.getParameterizedTypeName(), '.');
				}
				ISourceElementRequestor.FieldInfo fieldInfo = new ISourceElementRequestor.FieldInfo();
				fieldInfo.declarationStart = fieldDeclaration.declarationSourceStart;
				fieldInfo.name = fieldDeclaration.name;
				fieldInfo.modifiers = deprecated ? (currentModifiers & ExtraCompilerModifiers.AccJustFlag) | ClassFileConstants.AccDeprecated : currentModifiers & ExtraCompilerModifiers.AccJustFlag;
				fieldInfo.type = typeName;
				fieldInfo.nameSourceStart = fieldDeclaration.sourceStart;
				fieldInfo.nameSourceEnd = fieldDeclaration.sourceEnd;
				fieldInfo.categories = (char[][]) this.nodesToCategories.get(fieldDeclaration);
				fieldInfo.annotations = fieldDeclaration.annotations;
				fieldInfo.node = fieldDeclaration;
				requestor.enterField(fieldInfo);
			}
			this.visitIfNeeded(fieldDeclaration, declaringType);
			if (isInRange){
				requestor.exitField(
					// filter out initializations that are not a constant (simple check)
					(fieldDeclaration.initialization == null 
							|| fieldDeclaration.initialization instanceof ArrayInitializer
							|| fieldDeclaration.initialization instanceof AllocationExpression
							|| fieldDeclaration.initialization instanceof ArrayAllocationExpression
							|| fieldDeclaration.initialization instanceof Assignment
							|| fieldDeclaration.initialization instanceof ClassLiteralAccess
							|| fieldDeclaration.initialization instanceof MessageSend
							|| fieldDeclaration.initialization instanceof ArrayReference
							|| fieldDeclaration.initialization instanceof ThisReference) ? 
						-1 :  
						fieldDeclaration.initialization.sourceStart, 
					fieldEndPosition,
					fieldDeclaration.declarationSourceEnd);
			}
			break;
		case AbstractVariableDeclaration.INITIALIZER:
			if (isInRange){
				requestor.enterInitializer(
					fieldDeclaration.declarationSourceStart,
					fieldDeclaration.modifiers); 
			}
			this.visitIfNeeded((Initializer)fieldDeclaration);
			if (isInRange){
				requestor.exitInitializer(fieldDeclaration.declarationSourceEnd);
			}
			break;
	}
}
protected void notifySourceElementRequestor(
	ImportReference importReference, 
	boolean isPackage) {
	if (isPackage) {
		requestor.acceptPackage(importReference); 
	} else {
		requestor.acceptImport(
			importReference.declarationSourceStart, 
			importReference.declarationSourceEnd, 
			importReference.tokens, 
			(importReference.bits & ASTNode.OnDemand) != 0,
			importReference.modifiers); 
	}
}
protected void notifySourceElementRequestor(TypeDeclaration typeDeclaration, boolean notifyTypePresence, TypeDeclaration declaringType) {
	
	if (CharOperation.equals(TypeConstants.PACKAGE_INFO_NAME, typeDeclaration.name)) return;

	// range check
	boolean isInRange = 
		initialPosition <= typeDeclaration.declarationSourceStart
		&& eofPosition >= typeDeclaration.declarationSourceEnd;
	
	FieldDeclaration[] fields = typeDeclaration.fields;
	AbstractMethodDeclaration[] methods = typeDeclaration.methods;
	TypeDeclaration[] memberTypes = typeDeclaration.memberTypes;
	int fieldCounter = fields == null ? 0 : fields.length;
	int methodCounter = methods == null ? 0 : methods.length;
	int memberTypeCounter = memberTypes == null ? 0 : memberTypes.length;
	int fieldIndex = 0;
	int methodIndex = 0;
	int memberTypeIndex = 0;
	
	if (notifyTypePresence){
		char[][] interfaceNames = getInterfaceNames(typeDeclaration);
		int kind = TypeDeclaration.kind(typeDeclaration.modifiers);
		char[] implicitSuperclassName = TypeConstants.CharArray_JAVA_LANG_OBJECT;
		if (isInRange) {
			int currentModifiers = typeDeclaration.modifiers;
			
			// remember deprecation so as to not lose it below
			boolean deprecated = (currentModifiers & ClassFileConstants.AccDeprecated) != 0 || hasDeprecatedAnnotation(typeDeclaration.annotations);	
			
			boolean isEnumInit = typeDeclaration.allocation != null && typeDeclaration.allocation.enumConstant != null;
			char[] superclassName;
			if (isEnumInit) {
				currentModifiers |= ClassFileConstants.AccEnum;
				superclassName = declaringType.name;
			} else {
				superclassName = getSuperclassName(typeDeclaration);
			}
			ISourceElementRequestor.TypeInfo typeInfo = new ISourceElementRequestor.TypeInfo();
			typeInfo.declarationStart = typeDeclaration.allocation == null ? typeDeclaration.declarationSourceStart : typeDeclaration.allocation.sourceStart;
			typeInfo.modifiers = deprecated ? (currentModifiers & ExtraCompilerModifiers.AccJustFlag) | ClassFileConstants.AccDeprecated : currentModifiers & ExtraCompilerModifiers.AccJustFlag;
			typeInfo.name = typeDeclaration.name;
			typeInfo.nameSourceStart = typeDeclaration.sourceStart;
			typeInfo.nameSourceEnd = sourceEnd(typeDeclaration);
			typeInfo.superclass = superclassName;
			typeInfo.superinterfaces = interfaceNames;
			typeInfo.typeParameters = getTypeParameterInfos(typeDeclaration.typeParameters);
			typeInfo.categories = (char[][]) this.nodesToCategories.get(typeDeclaration);
			typeInfo.secondary = typeDeclaration.isSecondary();
			typeInfo.anonymousMember = typeDeclaration.allocation != null && typeDeclaration.allocation.enclosingInstance != null;
			typeInfo.annotations = typeDeclaration.annotations;
			typeInfo.node = typeDeclaration;
			requestor.enterType(typeInfo);
			switch (kind) {
				case TypeDeclaration.CLASS_DECL :
					if (superclassName != null)
						implicitSuperclassName = superclassName;
					break;
				case TypeDeclaration.INTERFACE_DECL :
					implicitSuperclassName = TypeConstants.CharArray_JAVA_LANG_OBJECT;
					break;
				case TypeDeclaration.ENUM_DECL :
					implicitSuperclassName = TypeConstants.CharArray_JAVA_LANG_ENUM;
					break;
				case TypeDeclaration.ANNOTATION_TYPE_DECL :
					implicitSuperclassName = TypeConstants.CharArray_JAVA_LANG_ANNOTATION_ANNOTATION;
					break;
			}
		}
		if (this.nestedTypeIndex == this.typeNames.length) {
			// need a resize
			System.arraycopy(this.typeNames, 0, (this.typeNames = new char[this.nestedTypeIndex * 2][]), 0, this.nestedTypeIndex);
			System.arraycopy(this.superTypeNames, 0, (this.superTypeNames = new char[this.nestedTypeIndex * 2][]), 0, this.nestedTypeIndex);
		}
		this.typeNames[this.nestedTypeIndex] = typeDeclaration.name;
		this.superTypeNames[this.nestedTypeIndex++] = implicitSuperclassName;
	}
	while ((fieldIndex < fieldCounter)
			|| (memberTypeIndex < memberTypeCounter)
			|| (methodIndex < methodCounter)) {
		FieldDeclaration nextFieldDeclaration = null;
		AbstractMethodDeclaration nextMethodDeclaration = null;
		TypeDeclaration nextMemberDeclaration = null;
		
		int position = Integer.MAX_VALUE;
		int nextDeclarationType = -1;
		if (fieldIndex < fieldCounter) {
			nextFieldDeclaration = fields[fieldIndex];
			if (nextFieldDeclaration.declarationSourceStart < position) {
				position = nextFieldDeclaration.declarationSourceStart;
				nextDeclarationType = 0; // FIELD
			}
		}
		if (methodIndex < methodCounter) {
			nextMethodDeclaration = methods[methodIndex];
			if (nextMethodDeclaration.declarationSourceStart < position) {
				position = nextMethodDeclaration.declarationSourceStart;
				nextDeclarationType = 1; // METHOD
			}
		}
		if (memberTypeIndex < memberTypeCounter) {
			nextMemberDeclaration = memberTypes[memberTypeIndex];
			if (nextMemberDeclaration.declarationSourceStart < position) {
				position = nextMemberDeclaration.declarationSourceStart;
				nextDeclarationType = 2; // MEMBER
			}
		}
		switch (nextDeclarationType) {
			case 0 :
				fieldIndex++;
				notifySourceElementRequestor(nextFieldDeclaration, typeDeclaration);
				break;
			case 1 :
				methodIndex++;
				notifySourceElementRequestor(nextMethodDeclaration);
				break;
			case 2 :
				memberTypeIndex++;
				notifySourceElementRequestor(nextMemberDeclaration, true, null);
		}
	}
	if (notifyTypePresence){
		if (isInRange){
			requestor.exitType(typeDeclaration.declarationSourceEnd);
		}
		nestedTypeIndex--;
	}
}
/*
 * Sort the given ast nodes by their positions.
 */
private static void quickSort(ASTNode[] sortedCollection, int left, int right) {
	int original_left = left;
	int original_right = right;
	ASTNode mid = sortedCollection[left +  (right - left) / 2];
	do {
		while (sortedCollection[left].sourceStart < mid.sourceStart) {
			left++;
		}
		while (mid.sourceStart < sortedCollection[right].sourceStart) {
			right--;
		}
		if (left <= right) {
			ASTNode tmp = sortedCollection[left];
			sortedCollection[left] = sortedCollection[right];
			sortedCollection[right] = tmp;
			left++;
			right--;
		}
	} while (left <= right);
	if (original_left < right) {
		quickSort(sortedCollection, original_left, right);
	}
	if (left < original_right) {
		quickSort(sortedCollection, left, original_right);
	}
}
private void reset() {
	typeNames = new char[4][];
	superTypeNames = new char[4][];
	nestedTypeIndex = 0;
	
	this.sourceEnds = null;
}
private int sourceEnd(TypeDeclaration typeDeclaration) {
	if ((typeDeclaration.bits & ASTNode.IsAnonymousType) != 0) {
		QualifiedAllocationExpression allocation = typeDeclaration.allocation;
		if (allocation.type == null) // case of enum constant body
			return typeDeclaration.sourceEnd;
		return allocation.type.sourceEnd;
	} else {
		return typeDeclaration.sourceEnd;
	}
}
private void visitIfNeeded(AbstractMethodDeclaration method) {
	if (this.localDeclarationVisitor != null 
		&& (method.bits & ASTNode.HasLocalType) != 0) {
			if (method instanceof ConstructorDeclaration) {
				ConstructorDeclaration constructorDeclaration = (ConstructorDeclaration) method;
				if (constructorDeclaration.constructorCall != null) {
					constructorDeclaration.constructorCall.traverse(this.localDeclarationVisitor, method.scope);
				}
			}
			if (method.statements != null) {
				int statementsLength = method.statements.length;
				for (int i = 0; i < statementsLength; i++)
					method.statements[i].traverse(this.localDeclarationVisitor, method.scope);
			}
	}
}

private void visitIfNeeded(FieldDeclaration field, TypeDeclaration declaringType) {
	if (this.localDeclarationVisitor != null 
		&& (field.bits & ASTNode.HasLocalType) != 0) {
			if (field.initialization != null) {
				try {
					this.localDeclarationVisitor.pushDeclaringType(declaringType);
					field.initialization.traverse(this.localDeclarationVisitor, (MethodScope) null);
				} finally {
					this.localDeclarationVisitor.popDeclaringType();
				}
			}
	}
}

private void visitIfNeeded(Initializer initializer) {
	if (this.localDeclarationVisitor != null 
		&& (initializer.bits & ASTNode.HasLocalType) != 0) {
			if (initializer.block != null) {
				initializer.block.traverse(this.localDeclarationVisitor, null);
			}
	}
}
}




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

import java.util.Map;

import org.eclipse.jdt.core.IAnnotation;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IMemberValuePair;
import org.eclipse.jdt.internal.codeassist.complete.CompletionOnMarkerAnnotationName;
import org.eclipse.jdt.internal.codeassist.complete.CompletionOnMemberValueName;
import org.eclipse.jdt.internal.codeassist.complete.CompletionOnParameterizedQualifiedTypeReference;
import org.eclipse.jdt.internal.codeassist.complete.CompletionOnQualifiedNameReference;
import org.eclipse.jdt.internal.codeassist.complete.CompletionOnQualifiedTypeReference;
import org.eclipse.jdt.internal.codeassist.complete.CompletionOnSingleNameReference;
import org.eclipse.jdt.internal.codeassist.complete.CompletionOnSingleTypeReference;
import org.eclipse.jdt.internal.codeassist.impl.AssistAnnotation;
import org.eclipse.jdt.internal.codeassist.impl.AssistImportContainer;
import org.eclipse.jdt.internal.codeassist.impl.AssistImportDeclaration;
import org.eclipse.jdt.internal.codeassist.impl.AssistInitializer;
import org.eclipse.jdt.internal.codeassist.impl.AssistPackageDeclaration;
import org.eclipse.jdt.internal.codeassist.impl.AssistSourceField;
import org.eclipse.jdt.internal.codeassist.impl.AssistSourceMethod;
import org.eclipse.jdt.internal.codeassist.impl.AssistSourceType;
import org.eclipse.jdt.internal.codeassist.impl.AssistTypeParameter;
import org.eclipse.jdt.internal.compiler.ast.ASTNode;
import org.eclipse.jdt.internal.compiler.ast.Expression;
import org.eclipse.jdt.internal.compiler.ast.MemberValuePair;
import org.eclipse.jdt.internal.compiler.ast.ParameterizedQualifiedTypeReference;
import org.eclipse.jdt.internal.compiler.ast.ParameterizedSingleTypeReference;
import org.eclipse.jdt.internal.compiler.ast.TypeReference;
import org.eclipse.jdt.internal.compiler.parser.Parser;
import org.eclipse.jdt.internal.core.AnnotatableInfo;
import org.eclipse.jdt.internal.core.Annotation;
import org.eclipse.jdt.internal.core.CompilationUnit;
import org.eclipse.jdt.internal.core.CompilationUnitElementInfo;
import org.eclipse.jdt.internal.core.CompilationUnitStructureRequestor;
import org.eclipse.jdt.internal.core.ImportContainer;
import org.eclipse.jdt.internal.core.ImportDeclaration;
import org.eclipse.jdt.internal.core.Initializer;
import org.eclipse.jdt.internal.core.JavaElement;
import org.eclipse.jdt.internal.core.JavaModelManager;
import org.eclipse.jdt.internal.core.PackageDeclaration;
import org.eclipse.jdt.internal.core.SourceField;
import org.eclipse.jdt.internal.core.SourceMethod;
import org.eclipse.jdt.internal.core.SourceType;
import org.eclipse.jdt.internal.core.TypeParameter;

public class CompletionUnitStructureRequestor extends CompilationUnitStructureRequestor {
	private ASTNode assistNode;
	
	private Map bindingCache;
	private Map elementCache;
	
	public CompletionUnitStructureRequestor(
			ICompilationUnit unit,
			CompilationUnitElementInfo unitInfo,
			Parser parser,
			ASTNode assistNode,
			Map bindingCache,
			Map elementCache,
			Map newElements) {
		super(unit, unitInfo, newElements);
		this.parser = parser;
		this.assistNode = assistNode;
		this.bindingCache = bindingCache;
		this.elementCache = elementCache;
	}
	
	protected Annotation createAnnotation(JavaElement parent, String name) {
		return new AssistAnnotation(parent, name, this.newElements);
	}

	protected SourceField createField(JavaElement parent, FieldInfo fieldInfo) {
		String fieldName = JavaModelManager.getJavaModelManager().intern(new String(fieldInfo.name));
		AssistSourceField field = new AssistSourceField(parent, fieldName, this.bindingCache, this.newElements);
		if (fieldInfo.node.binding != null) {
			this.bindingCache.put(field, fieldInfo.node.binding);
			this.elementCache.put(fieldInfo.node.binding, field);
		}
		return field;
	}

	protected ImportContainer createImportContainer(ICompilationUnit parent) {
		return new AssistImportContainer((CompilationUnit)parent, this.newElements);
	}

	protected ImportDeclaration createImportDeclaration(ImportContainer parent, String name, boolean onDemand) {
		return new AssistImportDeclaration(parent, name, onDemand, this.newElements);
	}

	protected Initializer createInitializer(JavaElement parent) {
		return new AssistInitializer(parent, 1, this.bindingCache, this.newElements);
	}

	protected SourceMethod createMethod(JavaElement parent, MethodInfo methodInfo) {
		String selector = JavaModelManager.getJavaModelManager().intern(new String(methodInfo.name));
		String[] parameterTypeSigs = convertTypeNamesToSigs(methodInfo.parameterTypes);
		AssistSourceMethod method = new AssistSourceMethod(parent, selector, parameterTypeSigs, this.bindingCache, this.newElements);
		if (methodInfo.node.binding != null) {
			this.bindingCache.put(method, methodInfo.node.binding);
			this.elementCache.put(methodInfo.node.binding, method);
		}
		return method;
	}

	protected PackageDeclaration createPackageDeclaration(JavaElement parent, String name) {
		return new AssistPackageDeclaration((CompilationUnit) parent, name, this.newElements);
	}
	
	protected SourceType createType(JavaElement parent, TypeInfo typeInfo) {
		String nameString= new String(typeInfo.name);
		AssistSourceType type = new AssistSourceType(parent, nameString, this.bindingCache, this.newElements);
		if (typeInfo.node.binding != null) {
			this.bindingCache.put(type, typeInfo.node.binding);
			this.elementCache.put(typeInfo.node.binding, type);
		}
		return type;
	}
	
	protected TypeParameter createTypeParameter(JavaElement parent, String name) {
		return new AssistTypeParameter(parent, name, this.newElements);
	}
	
	protected IAnnotation enterAnnotation(
			org.eclipse.jdt.internal.compiler.ast.Annotation annotation,
			AnnotatableInfo parentInfo,
			JavaElement parentHandle) {
		if (annotation instanceof CompletionOnMarkerAnnotationName) {
			if (hasEmptyName(annotation.type, assistNode)) {
				super.enterAnnotation(annotation, null, parentHandle);
				return null;
			}
		}
		return super.enterAnnotation(annotation, parentInfo, parentHandle);
	}
	
	protected Object getMemberValue(
			org.eclipse.jdt.internal.core.MemberValuePair memberValuePair,
			Expression expression) {
		if (expression instanceof CompletionOnSingleNameReference) {
			CompletionOnSingleNameReference reference = (CompletionOnSingleNameReference) expression;
			if (reference.token.length == 0) return null;
		} else if (expression instanceof CompletionOnQualifiedNameReference) {
			CompletionOnQualifiedNameReference reference = (CompletionOnQualifiedNameReference) expression;
			if (reference.tokens[reference.tokens.length - 1].length == 0) return null;
		}
		return super.getMemberValue(memberValuePair, expression);
	}
	protected IMemberValuePair[] getMemberValuePairs(MemberValuePair[] memberValuePairs) {
		int membersLength = memberValuePairs.length;
		int membersCount = 0;
		IMemberValuePair[] members = new IMemberValuePair[membersLength];
		next : for (int j = 0; j < membersLength; j++) {
			if (memberValuePairs[j] instanceof CompletionOnMemberValueName) continue next;
			
			members[membersCount++] = getMemberValuePair(memberValuePairs[j]);
		}
		
		if (membersCount > membersLength) {
			System.arraycopy(members, 0, members, 0, membersCount);
		}
		return members;
	}

	protected static boolean hasEmptyName(TypeReference reference, ASTNode assistNode) {
		if (reference == null) return false;
		
		if (reference.sourceStart <= assistNode.sourceStart && assistNode.sourceEnd <= reference.sourceEnd) return false;
		
		if (reference instanceof CompletionOnSingleTypeReference ||
				reference instanceof CompletionOnQualifiedTypeReference ||
				reference instanceof CompletionOnParameterizedQualifiedTypeReference) {
			char[][] typeName = reference.getTypeName();
			if (typeName[typeName.length - 1].length == 0) return true;
		}
		if (reference instanceof ParameterizedSingleTypeReference) {
			ParameterizedSingleTypeReference parameterizedReference = (ParameterizedSingleTypeReference) reference;
			TypeReference[] typeArguments = parameterizedReference.typeArguments;
			if (typeArguments != null) {
				for (int i = 0; i < typeArguments.length; i++) {
					if (hasEmptyName(typeArguments[i], assistNode)) return true;
				}
			}
		} else if (reference instanceof ParameterizedQualifiedTypeReference) {
			ParameterizedQualifiedTypeReference parameterizedReference = (ParameterizedQualifiedTypeReference) reference;
			TypeReference[][] typeArguments = parameterizedReference.typeArguments;
			if (typeArguments != null) {
				for (int i = 0; i < typeArguments.length; i++) {
					if (typeArguments[i] != null) {
						for (int j = 0; j < typeArguments[i].length; j++) {
							if (hasEmptyName(typeArguments[i][j], assistNode)) return true;
						}
					}
				}
			}
		}
		return false;
	}
}




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

import java.util.Map;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.internal.core.JavaElement;
import org.eclipse.jdt.internal.core.TypeParameter;

public class AssistTypeParameter extends TypeParameter {
	private Map infoCache;
	public AssistTypeParameter(JavaElement parent, String name, Map infoCache) {
		super(parent, name);
		this.infoCache = infoCache;
	}
	
	public Object getElementInfo(IProgressMonitor monitor) throws JavaModelException {
		return infoCache.get(this);
	}
}




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

import java.util.Map;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IImportContainer;
import org.eclipse.jdt.core.IPackageDeclaration;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.WorkingCopyOwner;
import org.eclipse.jdt.internal.core.CompilationUnit;
import org.eclipse.jdt.internal.core.JavaElementInfo;
import org.eclipse.jdt.internal.core.PackageFragment;

public class AssistCompilationUnit extends CompilationUnit {
	private Map infoCache;
	private Map bindingCache;
	public AssistCompilationUnit(ICompilationUnit compilationUnit, WorkingCopyOwner owner, Map bindingCache, Map infoCache) {
		super((PackageFragment)compilationUnit.getParent(), compilationUnit.getElementName(), owner);
		this.bindingCache = bindingCache;
		this.infoCache = infoCache;
	}
	
	public Object getElementInfo(IProgressMonitor monitor) throws JavaModelException {
		return infoCache.get(this);
	}
	
	public IImportContainer getImportContainer() {
		return new AssistImportContainer(this, this.infoCache);
	}
	
	public IPackageDeclaration getPackageDeclaration(String pkg) {
		return new AssistPackageDeclaration(this, pkg, this.infoCache);
	}
	
	public IType getType(String typeName) {
		return new AssistSourceType(this, typeName, this.bindingCache, this.infoCache);
	}
	
	public boolean hasChildren() throws JavaModelException {
		JavaElementInfo info = (JavaElementInfo)this.infoCache.get(this);
		return info.getChildren().length > 0;
	}
}




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

import java.util.Map;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jdt.core.IAnnotation;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.internal.compiler.lookup.Binding;
import org.eclipse.jdt.internal.core.JavaElement;
import org.eclipse.jdt.internal.core.ResolvedSourceField;

public class AssistSourceField extends ResolvedSourceField {
	private Map bindingCache;
	private Map infoCache;
	
	private String uniqueKey;
	
	public AssistSourceField(JavaElement parent, String name, Map bindingCache, Map infoCache) {
		super(parent, name, null);
		this.bindingCache = bindingCache;
		this.infoCache = infoCache;
	}
	
	public Object getElementInfo(IProgressMonitor monitor) throws JavaModelException {
		return infoCache.get(this);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jdt.internal.core.SourceField#getKey()
	 */
	public String getKey() {
		if (this.uniqueKey == null) {
			Binding binding = (Binding) this.bindingCache.get(this);
			if (binding != null) {
				this.uniqueKey = new String(binding.computeUniqueKey());
			}
		}
		return this.uniqueKey;
	}
	
	public boolean isResolved() {
		return getKey() != null;
	}
	
	protected void toStringInfo(int tab, StringBuffer buffer, Object info,boolean showResolvedInfo) {
		super.toStringInfo(tab, buffer, info, showResolvedInfo && this.isResolved());
	}
	
	public IAnnotation getAnnotation(String annotationName) {
		return new AssistAnnotation(this, annotationName, this.infoCache);
	}
	
	public IType getType(String typeName, int count) {
		AssistSourceType type = new AssistSourceType(this, typeName, this.bindingCache, this.infoCache);
		type.occurrenceCount = count;
		return type;
	}
}




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

import java.util.Map;

import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.internal.codeassist.complete.CompletionOnAnnotationOfType;
import org.eclipse.jdt.internal.codeassist.complete.CompletionOnArgumentName;
import org.eclipse.jdt.internal.codeassist.complete.CompletionOnFieldName;
import org.eclipse.jdt.internal.codeassist.complete.CompletionOnFieldType;
import org.eclipse.jdt.internal.codeassist.complete.CompletionOnImportReference;
import org.eclipse.jdt.internal.codeassist.complete.CompletionOnKeyword;
import org.eclipse.jdt.internal.codeassist.complete.CompletionOnKeyword2;
import org.eclipse.jdt.internal.codeassist.complete.CompletionOnMethodName;
import org.eclipse.jdt.internal.codeassist.complete.CompletionOnMethodReturnType;
import org.eclipse.jdt.internal.codeassist.complete.CompletionOnMethodTypeParameter;
import org.eclipse.jdt.internal.codeassist.complete.CompletionOnPackageReference;
import org.eclipse.jdt.internal.compiler.SourceElementNotifier;
import org.eclipse.jdt.internal.compiler.ast.ASTNode;
import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
import org.eclipse.jdt.internal.compiler.ast.Argument;
import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;
import org.eclipse.jdt.internal.compiler.ast.ImportReference;
import org.eclipse.jdt.internal.compiler.ast.QualifiedAllocationExpression;
import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
import org.eclipse.jdt.internal.compiler.ast.TypeParameter;
import org.eclipse.jdt.internal.compiler.ast.TypeReference;
import org.eclipse.jdt.internal.compiler.util.HashtableOfObjectToInt;

public class CompletionElementNotifier extends SourceElementNotifier {
	
	private ASTNode assistNode;
	
	public CompletionElementNotifier(
			CompletionUnitStructureRequestor requestor,
			boolean reportLocalDeclarations,
			ASTNode assistNode) {
		super(requestor, reportLocalDeclarations);
		this.assistNode = assistNode;
	}
	
	protected char[][][] getArguments(Argument[] arguments) {
		int argumentLength = arguments.length;
		char[][] argumentTypes = new char[argumentLength][];
		char[][] argumentNames = new char[argumentLength][];
		int argumentCount = 0;
		next : for (int i = 0; i < argumentLength; i++) {
			Argument argument = arguments[i];
			
			if (argument instanceof CompletionOnArgumentName && argument.name.length == 0) continue next;
			
			argumentTypes[argumentCount] = CharOperation.concatWith(argument.type.getParameterizedTypeName(), '.');
			argumentNames[argumentCount++] = argument.name;
		}
		
		if (argumentCount < argumentLength) {
			System.arraycopy(argumentTypes, 0, argumentTypes = new char[argumentCount][], 0, argumentCount);
			System.arraycopy(argumentNames, 0, argumentNames = new char[argumentCount][], 0, argumentCount);
		}
		
		return new char[][][] {argumentTypes, argumentNames};
	}
	
	protected char[][] getInterfaceNames(TypeDeclaration typeDeclaration) {
		char[][] interfaceNames = null;
		int superInterfacesLength = 0;
		TypeReference[] superInterfaces = typeDeclaration.superInterfaces;
		if (superInterfaces != null) {
			superInterfacesLength = superInterfaces.length;
			interfaceNames = new char[superInterfacesLength][];
		} else {
			if ((typeDeclaration.bits & ASTNode.IsAnonymousType) != 0) {
				// see PR 3442
				QualifiedAllocationExpression alloc = typeDeclaration.allocation;
				if (alloc != null && alloc.type != null) {
					superInterfaces = new TypeReference[] { alloc.type};
					superInterfacesLength = 1;
					interfaceNames = new char[1][];
				}
			}
		}
		if (superInterfaces != null) {
			int superInterfaceCount = 0;
			next: for (int i = 0; i < superInterfacesLength; i++) {
				TypeReference superInterface = superInterfaces[i];
				
				if (superInterface instanceof CompletionOnKeyword) continue next;
				if (CompletionUnitStructureRequestor.hasEmptyName(superInterface, this.assistNode)) continue next;
				
				interfaceNames[superInterfaceCount++] = CharOperation.concatWith(superInterface.getParameterizedTypeName(), '.'); 
			}
			
			if (superInterfaceCount == 0) return null;
			if (superInterfaceCount < superInterfacesLength) {
				System.arraycopy(interfaceNames, 0, interfaceNames = new char[superInterfaceCount][], 0, superInterfaceCount);
			}
		}
		return interfaceNames;
	}
	
	protected char[] getSuperclassName(TypeDeclaration typeDeclaration) {
		TypeReference superclass = typeDeclaration.superclass;
		
		if (superclass instanceof CompletionOnKeyword) return null;
		if (CompletionUnitStructureRequestor.hasEmptyName(superclass, this.assistNode)) return null;
				
		return superclass != null ? CharOperation.concatWith(superclass.getParameterizedTypeName(), '.') : null;
	}
	
	protected char[][] getThrownExceptions(AbstractMethodDeclaration methodDeclaration) {
		char[][] thrownExceptionTypes = null;
		TypeReference[] thrownExceptions = methodDeclaration.thrownExceptions;
		if (thrownExceptions != null) {
			int thrownExceptionLength = thrownExceptions.length;
			int thrownExceptionCount = 0;
			thrownExceptionTypes = new char[thrownExceptionLength][];
			next : for (int i = 0; i < thrownExceptionLength; i++) {
				TypeReference thrownException = thrownExceptions[i];
				
				if (thrownException instanceof CompletionOnKeyword) continue next;
				if (CompletionUnitStructureRequestor.hasEmptyName(thrownException, this.assistNode)) continue next;
				
				thrownExceptionTypes[thrownExceptionCount++] = 
					CharOperation.concatWith(thrownException.getParameterizedTypeName(), '.'); 
			}
			
			if (thrownExceptionCount == 0) return null;
			if (thrownExceptionCount < thrownExceptionLength) {
				System.arraycopy(thrownExceptionTypes, 0, thrownExceptionTypes = new char[thrownExceptionCount][], 0, thrownExceptionCount);
			}
		}
		return thrownExceptionTypes;
	}
	
	protected char[][] getTypeParameterBounds(TypeParameter typeParameter) {
		TypeReference firstBound = typeParameter.type;
		TypeReference[] otherBounds = typeParameter.bounds;
		char[][] typeParameterBounds = null;
		if (firstBound != null) {
			if (otherBounds != null) {
				int otherBoundsLength = otherBounds.length;
				char[][] boundNames = new char[otherBoundsLength+1][];
				int boundCount = 0;
				if (!CompletionUnitStructureRequestor.hasEmptyName(firstBound, this.assistNode)) {
					boundNames[boundCount++] = CharOperation.concatWith(firstBound.getParameterizedTypeName(), '.');
				}
				for (int j = 0; j < otherBoundsLength; j++) {
					TypeReference otherBound = otherBounds[j];
					if (!CompletionUnitStructureRequestor.hasEmptyName(otherBound, this.assistNode)) {
						boundNames[boundCount++] = 
							CharOperation.concatWith(otherBound.getParameterizedTypeName(), '.');
					}
				}
				
				if (boundCount == 0) {
					boundNames = CharOperation.NO_CHAR_CHAR;
				} else if (boundCount < otherBoundsLength + 1){
					System.arraycopy(boundNames, 0, boundNames = new char[boundCount][], 0, boundCount);
				}
				typeParameterBounds = boundNames;
			} else {
				if (!CompletionUnitStructureRequestor.hasEmptyName(firstBound, this.assistNode)) {
					typeParameterBounds = new char[][] { CharOperation.concatWith(firstBound.getParameterizedTypeName(), '.')};
				} else {
					typeParameterBounds = CharOperation.NO_CHAR_CHAR;
				}
			}
		} else {
			typeParameterBounds = CharOperation.NO_CHAR_CHAR;
		}
		
		return typeParameterBounds;
	}
	
	protected void notifySourceElementRequestor(AbstractMethodDeclaration methodDeclaration) {
		if (methodDeclaration instanceof CompletionOnMethodReturnType) return;
		if (methodDeclaration instanceof CompletionOnMethodTypeParameter) return;
		if (methodDeclaration instanceof CompletionOnMethodName) return;
		super.notifySourceElementRequestor(methodDeclaration);
	}
	
	public void notifySourceElementRequestor(CompilationUnitDeclaration parsedUnit, int sourceStart, int sourceEnd, boolean reportReference, HashtableOfObjectToInt sourceEndsMap, Map nodesToCategoriesMap) {
		super.notifySourceElementRequestor(parsedUnit, sourceStart, sourceEnd, reportReference, sourceEndsMap, nodesToCategoriesMap);
	}
	
	protected void notifySourceElementRequestor(FieldDeclaration fieldDeclaration, TypeDeclaration declaringType) {
		if (fieldDeclaration instanceof CompletionOnFieldType) return;
		if (fieldDeclaration instanceof CompletionOnFieldName) return;
		super.notifySourceElementRequestor(fieldDeclaration, declaringType);
	}
	
	protected void notifySourceElementRequestor(ImportReference importReference, boolean isPackage) {
		if (importReference instanceof CompletionOnKeyword2) return;
		if (importReference instanceof CompletionOnImportReference ||
				importReference instanceof CompletionOnPackageReference) {
			if (importReference.tokens[importReference.tokens.length - 1].length == 0) return;
		}
		
		super.notifySourceElementRequestor(importReference, isPackage);
	}
	
	protected void notifySourceElementRequestor(TypeDeclaration typeDeclaration, boolean notifyTypePresence, TypeDeclaration declaringType) {
		if (typeDeclaration instanceof CompletionOnAnnotationOfType) return;
		super.notifySourceElementRequestor(typeDeclaration, notifyTypePresence, declaringType);
	}
}




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

import java.util.Map;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jdt.core.IAnnotation;
import org.eclipse.jdt.core.IField;
import org.eclipse.jdt.core.IInitializer;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.ITypeParameter;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.internal.compiler.lookup.Binding;
import org.eclipse.jdt.internal.core.JavaElement;
import org.eclipse.jdt.internal.core.ResolvedSourceType;

public class AssistSourceType extends ResolvedSourceType {
	private Map bindingCache;
	private Map infoCache;
	
	private String uniqueKey;
	
	public AssistSourceType(JavaElement parent, String name, Map bindingCache, Map infoCache) {
		super(parent, name, null);
		this.bindingCache = bindingCache;
		this.infoCache = infoCache;
	}
	
	public Object getElementInfo(IProgressMonitor monitor) throws JavaModelException {
		return infoCache.get(this);
	}
	
	public String getFullyQualifiedParameterizedName() throws JavaModelException {
		if (this.isResolved()) {
			return getFullyQualifiedParameterizedName(getFullyQualifiedName(), this.getKey());
		}
		return getFullyQualifiedName('.', true/*show parameters*/);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jdt.internal.core.SourceType#getKey()
	 */
	public String getKey() {
		if (this.uniqueKey == null) {
			Binding binding = (Binding) this.bindingCache.get(this);
			if (binding != null) {
				this.uniqueKey = new String(binding.computeUniqueKey());
			}
		}
		return this.uniqueKey;
	}
	
	public boolean isResolved() {
		return getKey() != null;
	}
	
	protected void toStringInfo(int tab, StringBuffer buffer, Object info,boolean showResolvedInfo) {
		super.toStringInfo(tab, buffer, info, showResolvedInfo && this.isResolved());
	}
	
	public IAnnotation getAnnotation(String annotationName) {
		return new AssistAnnotation(this, annotationName, this.infoCache);
	}
	
	public IField getField(String fieldName) {
		return new AssistSourceField(this, fieldName, this.bindingCache, this.infoCache);
	}
	
	public IInitializer getInitializer(int count) {
		return new AssistInitializer(this, count, this.bindingCache, this.infoCache);
	}
	
	public IMethod getMethod(String selector, String[] parameterTypeSignatures) {
		return new AssistSourceMethod(this, selector, parameterTypeSignatures, this.bindingCache, this.infoCache);
	}
	
	public IType getType(String typeName) {
		return new AssistSourceType(this, typeName, this.bindingCache, this.infoCache);
	}
	
	public IType getType(String typeName, int count) {
		AssistSourceType type = new AssistSourceType(this, typeName, this.bindingCache, this.infoCache);
		type.occurrenceCount = count;
		return type;
	}
	
	public ITypeParameter getTypeParameter(String typeParameterName) {
		return new AssistTypeParameter(this, typeParameterName, this.infoCache);
	}
}




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

import java.util.Map;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jdt.core.IImportDeclaration;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.internal.core.CompilationUnit;
import org.eclipse.jdt.internal.core.ImportContainer;

public class AssistImportContainer extends ImportContainer {
	private Map infoCache;
	public AssistImportContainer(CompilationUnit parent, Map infoCache) {
		super(parent);
		this.infoCache = infoCache;
	}
	
	public Object getElementInfo(IProgressMonitor monitor) throws JavaModelException {
		return infoCache.get(this);
	}
	
	protected IImportDeclaration getImport(String importName, boolean isOnDemand) {
		return new AssistImportDeclaration(this, importName, isOnDemand, this.infoCache);
	}
}




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

import java.util.Map;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.internal.core.ImportContainer;
import org.eclipse.jdt.internal.core.ImportDeclaration;

public class AssistImportDeclaration extends ImportDeclaration {
	private Map infoCache;
	public AssistImportDeclaration(ImportContainer parent, String name, boolean isOnDemand, Map infoCache) {
		super(parent, name, isOnDemand);
		this.infoCache = infoCache;
	}
	
	public Object getElementInfo(IProgressMonitor monitor) throws JavaModelException {
		return infoCache.get(this);
	}
}




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

import java.util.Map;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jdt.core.IAnnotation;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.ITypeParameter;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.internal.compiler.lookup.Binding;
import org.eclipse.jdt.internal.core.JavaElement;
import org.eclipse.jdt.internal.core.ResolvedSourceMethod;

public class AssistSourceMethod extends ResolvedSourceMethod {
	private Map bindingCache;
	private Map infoCache;
	
	private String uniqueKey;
	
	public AssistSourceMethod(JavaElement parent, String name, String[] parameterTypes, Map bindingCache, Map infoCache) {
		super(parent, name, parameterTypes, null);
		this.bindingCache = bindingCache;
		this.infoCache = infoCache;
	}
	
	public Object getElementInfo(IProgressMonitor monitor) throws JavaModelException {
		return infoCache.get(this);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jdt.internal.core.SourceMethod#getKey()
	 */
	public String getKey() {
		if (this.uniqueKey == null) {
			Binding binding = (Binding) this.bindingCache.get(this);
			if (binding != null) {
				this.uniqueKey = new String(binding.computeUniqueKey());
			}
		}
		return this.uniqueKey;
	}
	
	public boolean isResolved() {
		return getKey() != null;
	}
	
	protected void toStringInfo(int tab, StringBuffer buffer, Object info,boolean showResolvedInfo) {
		super.toStringInfo(tab, buffer, info, showResolvedInfo && this.isResolved());
	}
	
	public IAnnotation getAnnotation(String annotationName) {
		return new AssistAnnotation(this, annotationName, this.infoCache);
	}
	
	public IType getType(String typeName, int count) {
		AssistSourceType type = new AssistSourceType(this, typeName, this.bindingCache, this.infoCache);
		type.occurrenceCount = count;
		return type;
	}
	
	public ITypeParameter getTypeParameter(String typeParameterName) {
		return new AssistTypeParameter(this, typeParameterName, this.infoCache);
	}
}




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

import java.util.Map;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.internal.core.Initializer;
import org.eclipse.jdt.internal.core.JavaElement;

public class AssistInitializer extends Initializer {
	private Map bindingCache;
	private Map infoCache;
	public AssistInitializer(JavaElement parent, int count, Map bindingCache, Map infoCache) {
		super(parent, count);
		this.bindingCache = bindingCache;
		this.infoCache = infoCache;
	}
	
	public Object getElementInfo(IProgressMonitor monitor) throws JavaModelException {
		return infoCache.get(this);
	}
	
	public IType getType(String typeName, int count) {
		AssistSourceType type = new AssistSourceType(this, typeName, this.bindingCache, this.infoCache);
		type.occurrenceCount = count;
		return type;
	}
}




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

import java.util.Map;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jdt.core.IAnnotation;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.internal.core.CompilationUnit;
import org.eclipse.jdt.internal.core.PackageDeclaration;

public class AssistPackageDeclaration extends PackageDeclaration {
	private Map infoCache;
	public AssistPackageDeclaration(CompilationUnit parent, String name, Map infoCache) {
		super(parent, name);
		this.infoCache = infoCache;
	}
	
	public Object getElementInfo(IProgressMonitor monitor) throws JavaModelException {
		return infoCache.get(this);
	}
	
	public IAnnotation getAnnotation(String name) {
		return new AssistAnnotation(this, name, this.infoCache);
	}
}




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

import java.util.HashMap;
import java.util.Map;

import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IInitializer;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.ISourceRange;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.ITypeRoot;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.WorkingCopyOwner;
import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.internal.codeassist.complete.CompletionParser;
import org.eclipse.jdt.internal.codeassist.impl.AssistCompilationUnit;
import org.eclipse.jdt.internal.compiler.ast.ASTNode;
import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;
import org.eclipse.jdt.internal.compiler.ast.Initializer;
import org.eclipse.jdt.internal.compiler.ast.LocalDeclaration;
import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
import org.eclipse.jdt.internal.compiler.impl.ReferenceContext;
import org.eclipse.jdt.internal.compiler.lookup.BinaryTypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.Binding;
import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
import org.eclipse.jdt.internal.compiler.lookup.ClassScope;
import org.eclipse.jdt.internal.compiler.lookup.FieldBinding;
import org.eclipse.jdt.internal.compiler.lookup.ImportBinding;
import org.eclipse.jdt.internal.compiler.lookup.InvocationSite;
import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;
import org.eclipse.jdt.internal.compiler.lookup.LookupEnvironment;
import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
import org.eclipse.jdt.internal.compiler.lookup.MethodScope;
import org.eclipse.jdt.internal.compiler.lookup.ParameterizedTypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
import org.eclipse.jdt.internal.compiler.lookup.Scope;
import org.eclipse.jdt.internal.compiler.lookup.SignatureWrapper;
import org.eclipse.jdt.internal.compiler.lookup.SourceTypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeVariableBinding;
import org.eclipse.jdt.internal.compiler.problem.AbortCompilation;
import org.eclipse.jdt.internal.compiler.util.ObjectVector;
import org.eclipse.jdt.internal.core.CompilationUnitElementInfo;
import org.eclipse.jdt.internal.core.JavaElement;
import org.eclipse.jdt.internal.core.LocalVariable;
import org.eclipse.jdt.internal.core.util.Util;

public class InternalExtendedCompletionContext {
	private static Util.BindingsToNodesMap EmptyNodeMap = new Util.BindingsToNodesMap() {
		public ASTNode get(Binding binding) {
			return null;
		}
	};
	
	private InternalCompletionContext completionContext;
	
	// static data
	private ITypeRoot typeRoot;
	private CompilationUnitDeclaration compilationUnitDeclaration;
	private LookupEnvironment lookupEnvironment;
	private Scope assistScope;
	private ASTNode assistNode;
	private WorkingCopyOwner owner;
	
	private CompletionParser parser;
	
	// computed data
	private boolean hasComputedVisibleElementBindings;
	private ObjectVector visibleLocalVariables;
	private ObjectVector visibleFields;
	private ObjectVector visibleMethods;
	
	private boolean hasComputedEnclosingJavaElements;
	Map bindingsToNodes;
	private Map bindingsToHandles;
	private ICompilationUnit compilationUnit;
	
	public InternalExtendedCompletionContext(
			InternalCompletionContext completionContext,
			ITypeRoot typeRoot,
			CompilationUnitDeclaration compilationUnitDeclaration,
			LookupEnvironment lookupEnvironment,
			Scope assistScope,
			ASTNode assistNode,
			WorkingCopyOwner owner,
			CompletionParser parser) {
		this.completionContext = completionContext;
		this.typeRoot = typeRoot;
		this.compilationUnitDeclaration = compilationUnitDeclaration;
		this.lookupEnvironment = lookupEnvironment;
		this.assistScope = assistScope;
		this.assistNode = assistNode;
		this.owner = owner;
		this.parser = parser;
	}
	
	private void computeEnclosingJavaElements() {
		this.hasComputedEnclosingJavaElements = true;
		
		if (this.typeRoot == null) return;
		
		if (this.typeRoot.getElementType() == IJavaElement.COMPILATION_UNIT) {
	 		ICompilationUnit original = (org.eclipse.jdt.core.ICompilationUnit)this.typeRoot;
			
			HashMap handleToBinding = new HashMap();
			HashMap bindingToHandle = new HashMap();
			HashMap handleToInfo = new HashMap();
			
			org.eclipse.jdt.core.ICompilationUnit handle = new AssistCompilationUnit(original, this.owner, handleToBinding, handleToInfo);
			CompilationUnitElementInfo info = new CompilationUnitElementInfo();
			
			handleToInfo.put(handle, info);
			
			CompletionUnitStructureRequestor structureRequestor = 
				new CompletionUnitStructureRequestor(
						handle,
						info,
						this.parser,
						this.assistNode,
						handleToBinding,
						bindingToHandle,
						handleToInfo);
			
			CompletionElementNotifier notifier =
				new CompletionElementNotifier(
						structureRequestor,
						true,
						this.assistNode);
			
			notifier.notifySourceElementRequestor(
					this.compilationUnitDeclaration,
					this.compilationUnitDeclaration.sourceStart,
					this.compilationUnitDeclaration.sourceEnd,
					false,
					this.parser.sourceEnds,
					new HashMap());
			
			this.bindingsToHandles = bindingToHandle;
			this.compilationUnit = handle;
		}
	}
	
	private void computeVisibleElementBindings() {
		this.hasComputedVisibleElementBindings = true;
		
		Scope scope = this.assistScope;
		ASTNode astNode = this.assistNode;
		boolean notInJavadoc = this.completionContext.javadoc == 0;
		
		this.visibleLocalVariables = new ObjectVector();
		this.visibleFields = new ObjectVector();
		this.visibleMethods = new ObjectVector();
		this.bindingsToNodes = new HashMap();
		
		ReferenceContext referenceContext = scope.referenceContext();
		if (referenceContext instanceof AbstractMethodDeclaration) {
			// completion is inside a method body
			searchVisibleVariablesAndMethods(scope, visibleLocalVariables, visibleFields, visibleMethods, notInJavadoc);
		} else if (referenceContext instanceof TypeDeclaration) {
			TypeDeclaration typeDeclaration = (TypeDeclaration) referenceContext;
			FieldDeclaration[] fields = typeDeclaration.fields;
			if (fields != null) {
				done : for (int i = 0; i < fields.length; i++) {
					if (fields[i] instanceof Initializer) {
						Initializer initializer = (Initializer) fields[i];
						if (initializer.block.sourceStart <= astNode.sourceStart &&
								astNode.sourceStart < initializer.bodyEnd) {
							// completion is inside an initializer
							searchVisibleVariablesAndMethods(scope, visibleLocalVariables, visibleFields, visibleMethods, notInJavadoc);
							break done;
						}
					} else {
						FieldDeclaration fieldDeclaration = fields[i];
						if (fieldDeclaration.initialization != null && 
								fieldDeclaration.initialization.sourceStart <= astNode.sourceStart &&
								astNode.sourceEnd <= fieldDeclaration.initialization.sourceEnd) {
							// completion is inside a field initializer
							searchVisibleVariablesAndMethods(scope, visibleLocalVariables, visibleFields, visibleMethods, notInJavadoc);
							break done;
						}  
					}
				}
			}
		}
	}
	
	public IJavaElement getEnclosingElement() {
		try {
			if (!this.hasComputedEnclosingJavaElements) {
				this.computeEnclosingJavaElements();
			}
			if (this.compilationUnit == null) return null;
			IJavaElement enclosingElement = compilationUnit.getElementAt(this.completionContext.offset);
			return enclosingElement == null ? this.compilationUnit : enclosingElement;
		} catch (JavaModelException e) {
			Util.log(e, "Cannot compute enclosing element"); //$NON-NLS-1$
			return null;
		}
	}
	
	private JavaElement getJavaElement(LocalVariableBinding binding) {
		LocalDeclaration local = binding.declaration;
		
		JavaElement parent = null;
		ReferenceContext referenceContext = binding.declaringScope.referenceContext();
		if (referenceContext instanceof AbstractMethodDeclaration) {
			AbstractMethodDeclaration methodDeclaration = (AbstractMethodDeclaration) referenceContext;
			parent = this.getJavaElementOfCompilationUnit(methodDeclaration.binding);
		} else if (referenceContext instanceof TypeDeclaration){
			// Local variable is declared inside an initializer
			TypeDeclaration typeDeclaration = (TypeDeclaration) referenceContext;
			
			IType type = (IType)this.getJavaElementOfCompilationUnit(typeDeclaration.binding);
			if (type != null) {
				try {
					IInitializer[] initializers = type.getInitializers();
					if (initializers != null) {
						done : for (int i = 0; i < initializers.length; i++) {
							IInitializer initializer = initializers[i];
							ISourceRange sourceRange = initializer.getSourceRange();
							if (sourceRange != null) {
								int initializerStart = sourceRange.getOffset();
								int initializerEnd = initializerStart + sourceRange.getLength();
								if (initializerStart <= local.sourceStart &&
										local.sourceEnd <= initializerEnd) {
									parent = (JavaElement)initializer;
									break done;
								}
							}
						}
					}
				} catch (JavaModelException e) {
					return null;
				}
			}
		}
		if (parent == null) return null;
		
		return new LocalVariable(
				parent,
				new String(local.name),
				local.declarationSourceStart,
				local.declarationSourceEnd,
				local.sourceStart,
				local.sourceEnd,
				Util.typeSignature(local.type),
				binding.declaration.annotations);
	}
	
	private JavaElement getJavaElementOfCompilationUnit(Binding binding) {
		if (!this.hasComputedEnclosingJavaElements) {
			computeEnclosingJavaElements();
		}
		if (this.bindingsToHandles == null) return null;
		return (JavaElement)this.bindingsToHandles.get(binding);
	}
	
	private TypeBinding getTypeFromSignature(String typeSignature, Scope scope) {
		TypeBinding assignableTypeBinding = null;
		
		TypeVariableBinding[] typeVariables = Binding.NO_TYPE_VARIABLES;
		ReferenceContext referenceContext = scope.referenceContext();
		if (referenceContext instanceof AbstractMethodDeclaration) {
			AbstractMethodDeclaration methodDeclaration = (AbstractMethodDeclaration) referenceContext;
			typeVariables = methodDeclaration.binding.typeVariables;
		}
		
		CompilationUnitDeclaration previousUnitBeingCompleted = lookupEnvironment.unitBeingCompleted;
		lookupEnvironment.unitBeingCompleted = this.compilationUnitDeclaration;
		try {
			
			SignatureWrapper wrapper = new SignatureWrapper(typeSignature.toCharArray());
			assignableTypeBinding = lookupEnvironment.getTypeFromTypeSignature(wrapper, typeVariables, this.assistScope.enclosingClassScope().referenceContext.binding, null);
			if (assignableTypeBinding instanceof ReferenceBinding) {
				assignableTypeBinding = BinaryTypeBinding.resolveType((ReferenceBinding)assignableTypeBinding, lookupEnvironment, true);
			}
		} catch (AbortCompilation e) {
			assignableTypeBinding = null;
		} finally {
			lookupEnvironment.unitBeingCompleted = previousUnitBeingCompleted;
		}
		return assignableTypeBinding;
	}
	
	public IJavaElement[] getVisibleElements(String typeSignature) {
		if (this.assistScope == null) return new IJavaElement[0];
		
		if (!this.hasComputedVisibleElementBindings) {
			this.computeVisibleElementBindings();
		}
		
		TypeBinding assignableTypeBinding = null;
		if (typeSignature != null) {
			assignableTypeBinding = this.getTypeFromSignature(typeSignature, this.assistScope);
			if (assignableTypeBinding == null) return new IJavaElement[0];
		}
		 
		int length = visibleLocalVariables.size() + visibleFields.size() + visibleMethods.size();
		if (length == 0) return new IJavaElement[0];
		
		IJavaElement[] result = new IJavaElement[length];
		
		int elementCount = 0;
		
		int size = visibleLocalVariables.size();
		if (size > 0) {
			next : for (int i = 0; i < size; i++) {
				LocalVariableBinding binding = (LocalVariableBinding) visibleLocalVariables.elementAt(i);
				if (assignableTypeBinding != null && !binding.type.isCompatibleWith(assignableTypeBinding)) continue next;
				result[elementCount++] = getJavaElement(binding);
			}
		
		}
		size = visibleFields.size();
		if (size > 0) {
			next : for (int i = 0; i < size; i++) {
				FieldBinding binding = (FieldBinding) visibleFields.elementAt(i);
				if (assignableTypeBinding != null && !binding.type.isCompatibleWith(assignableTypeBinding)) continue next;
				if (this.assistScope.isDefinedInSameUnit(binding.declaringClass)) {
					JavaElement field = getJavaElementOfCompilationUnit(binding);
					if (field != null) result[elementCount++] = field;
				} else {
					JavaElement field = Util.getUnresolvedJavaElement(binding, owner, EmptyNodeMap);
					if (field != null) result[elementCount++] = field.resolved(binding);
				}
			}
		
		}
		size = visibleMethods.size();
		if (size > 0) {
			next : for (int i = 0; i < size; i++) {
				MethodBinding binding = (MethodBinding) visibleMethods.elementAt(i);
				if (assignableTypeBinding != null && !binding.returnType.isCompatibleWith(assignableTypeBinding)) continue next;
				if (this.assistScope.isDefinedInSameUnit(binding.declaringClass)) {
					JavaElement method = getJavaElementOfCompilationUnit(binding);
					if (method != null) result[elementCount++] = method;
				} else {
					JavaElement method = Util.getUnresolvedJavaElement(binding, owner, EmptyNodeMap);
					if (method != null) result[elementCount++] = method.resolved(binding);
				}
				
			}
		}
		
		if (elementCount != result.length) {
			System.arraycopy(result, 0, result = new IJavaElement[elementCount], 0, elementCount);
		}

		return result;
	}
	
	private void searchVisibleFields(
			FieldBinding[] fields,
			ReferenceBinding receiverType,
			Scope scope,
			InvocationSite invocationSite,
			Scope invocationScope,
			boolean onlyStaticFields,
			ObjectVector localsFound,
			ObjectVector fieldsFound) {
		ObjectVector newFieldsFound = new ObjectVector();
		// Inherited fields which are hidden by subclasses are filtered out
		// No visibility checks can be performed without the scope & invocationSite
		
		next : for (int f = fields.length; --f >= 0;) {			
			FieldBinding field = fields[f];

			if (field.isSynthetic()) continue next;
			
			if (onlyStaticFields && !field.isStatic()) continue next;
			
			if (!field.canBeSeenBy(receiverType, invocationSite, scope)) continue next;
			
			for (int i = fieldsFound.size; --i >= 0;) {
				FieldBinding otherField = (FieldBinding) fieldsFound.elementAt(i);
				if (CharOperation.equals(field.name, otherField.name, true)) {
					continue next;
				}
			}

			for (int l = localsFound.size; --l >= 0;) {
				LocalVariableBinding local = (LocalVariableBinding) localsFound.elementAt(l);	

				if (CharOperation.equals(field.name, local.name, true)) {
					continue next;
				}
			}
			
			newFieldsFound.add(field);
		}
		
		fieldsFound.addAll(newFieldsFound);
	}
	
	private void searchVisibleFields(
			ReferenceBinding receiverType,
			Scope scope,
			InvocationSite invocationSite,
			Scope invocationScope,
			boolean onlyStaticFields,
			boolean notInJavadoc,
			ObjectVector localsFound,
			ObjectVector fieldsFound) {

		ReferenceBinding currentType = receiverType;
		ReferenceBinding[] interfacesToVisit = null;
		int nextPosition = 0;
		do {
			ReferenceBinding[] itsInterfaces = currentType.superInterfaces();
			if (notInJavadoc && itsInterfaces != Binding.NO_SUPERINTERFACES) {
				if (interfacesToVisit == null) {
					interfacesToVisit = itsInterfaces;
					nextPosition = interfacesToVisit.length;
				} else {
					int itsLength = itsInterfaces.length;
					if (nextPosition + itsLength >= interfacesToVisit.length)
						System.arraycopy(interfacesToVisit, 0, interfacesToVisit = new ReferenceBinding[nextPosition + itsLength + 5], 0, nextPosition);
					nextInterface : for (int a = 0; a < itsLength; a++) {
						ReferenceBinding next = itsInterfaces[a];
						for (int b = 0; b < nextPosition; b++)
							if (next == interfacesToVisit[b]) continue nextInterface;
						interfacesToVisit[nextPosition++] = next;
					}
				}
			}

			FieldBinding[] fields = currentType.availableFields();
			if(fields != null && fields.length > 0) {
				
				searchVisibleFields(
						fields,
						receiverType,
						scope,
						invocationSite,
						invocationScope,
						onlyStaticFields,
						localsFound,
						fieldsFound);
			}
			currentType = currentType.superclass();
		} while (notInJavadoc && currentType != null);

		if (notInJavadoc && interfacesToVisit != null) {
			for (int i = 0; i < nextPosition; i++) {
				ReferenceBinding anInterface = interfacesToVisit[i];
				FieldBinding[] fields = anInterface.availableFields();
				if(fields !=  null) {
					searchVisibleFields(
							fields,
							receiverType,
							scope,
							invocationSite,
							invocationScope,
							onlyStaticFields,
							localsFound,
							fieldsFound);
				}

				ReferenceBinding[] itsInterfaces = anInterface.superInterfaces();
				if (itsInterfaces != Binding.NO_SUPERINTERFACES) {
					int itsLength = itsInterfaces.length;
					if (nextPosition + itsLength >= interfacesToVisit.length)
						System.arraycopy(interfacesToVisit, 0, interfacesToVisit = new ReferenceBinding[nextPosition + itsLength + 5], 0, nextPosition);
					nextInterface : for (int a = 0; a < itsLength; a++) {
						ReferenceBinding next = itsInterfaces[a];
						for (int b = 0; b < nextPosition; b++)
							if (next == interfacesToVisit[b]) continue nextInterface;
						interfacesToVisit[nextPosition++] = next;
					}
				}
			}
		}
	}

	private void searchVisibleInterfaceMethods(
			ReferenceBinding[] itsInterfaces,
			ReferenceBinding receiverType,
			Scope scope,
			InvocationSite invocationSite,
			Scope invocationScope,
			boolean onlyStaticMethods,
			ObjectVector methodsFound) {
		if (itsInterfaces != Binding.NO_SUPERINTERFACES) {
			ReferenceBinding[] interfacesToVisit = itsInterfaces;
			int nextPosition = interfacesToVisit.length;

			for (int i = 0; i < nextPosition; i++) {
				ReferenceBinding currentType = interfacesToVisit[i];
				MethodBinding[] methods = currentType.availableMethods();
				if(methods != null) {
					searchVisibleLocalMethods(
							methods,
							receiverType,
							scope,
							invocationSite,
							invocationScope,
							onlyStaticMethods,
							methodsFound);
				}

				itsInterfaces = currentType.superInterfaces();
				if (itsInterfaces != null && itsInterfaces != Binding.NO_SUPERINTERFACES) {
					int itsLength = itsInterfaces.length;
					if (nextPosition + itsLength >= interfacesToVisit.length)
						System.arraycopy(interfacesToVisit, 0, interfacesToVisit = new ReferenceBinding[nextPosition + itsLength + 5], 0, nextPosition);
					nextInterface : for (int a = 0; a < itsLength; a++) {
						ReferenceBinding next = itsInterfaces[a];
						for (int b = 0; b < nextPosition; b++)
							if (next == interfacesToVisit[b]) continue nextInterface;
						interfacesToVisit[nextPosition++] = next;
					}
				}
			}
		}
	}
	
	private void searchVisibleLocalMethods(
			MethodBinding[] methods,
			ReferenceBinding receiverType,
			Scope scope,
			InvocationSite invocationSite,
			Scope invocationScope,
			boolean onlyStaticMethods,
			ObjectVector methodsFound) {
		ObjectVector newMethodsFound =  new ObjectVector();
		// Inherited methods which are hidden by subclasses are filtered out
		// No visibility checks can be performed without the scope & invocationSite

		next : for (int f = methods.length; --f >= 0;) {
			MethodBinding method = methods[f];

			if (method.isSynthetic()) continue next;

			if (method.isDefaultAbstract())	continue next;

			if (method.isConstructor()) continue next;
			
			if (onlyStaticMethods && !method.isStatic()) continue next;

			if (!method.canBeSeenBy(receiverType, invocationSite, scope)) continue next;
			
			for (int i = methodsFound.size; --i >= 0;) {
				MethodBinding otherMethod = (MethodBinding) methodsFound.elementAt(i);
				if (method == otherMethod)
					continue next;
				
				if (CharOperation.equals(method.selector, otherMethod.selector, true)) {
					if (this.lookupEnvironment.methodVerifier().isMethodSubsignature(otherMethod, method)) {
						continue next;
					}
				}
			}

			newMethodsFound.add(method);
		}
		
		methodsFound.addAll(newMethodsFound);
	}
	
	private void searchVisibleMethods(
			ReferenceBinding receiverType,
			Scope scope,
			InvocationSite invocationSite,
			Scope invocationScope,
			boolean onlyStaticMethods,
			boolean notInJavadoc,
			ObjectVector methodsFound) {
		ReferenceBinding currentType = receiverType;
		if (notInJavadoc) {
			if (receiverType.isInterface()) {
				searchVisibleInterfaceMethods(
						new ReferenceBinding[]{currentType},
						receiverType,
						scope,
						invocationSite,
						invocationScope,
						onlyStaticMethods,
						methodsFound);
				
				currentType = scope.getJavaLangObject();
			}
		}
		boolean hasPotentialDefaultAbstractMethods = true;
		while (currentType != null) {
			
			MethodBinding[] methods = currentType.availableMethods();
			if (methods != null) {
				searchVisibleLocalMethods(
						methods,
						receiverType,
						scope,
						invocationSite,
						invocationScope,
						onlyStaticMethods,
						methodsFound);
			}
			
			if (notInJavadoc &&
					hasPotentialDefaultAbstractMethods &&
					(currentType.isAbstract() ||
							currentType.isTypeVariable() ||
							currentType.isIntersectionType() ||
							currentType.isEnum())){
				
				ReferenceBinding[] superInterfaces = currentType.superInterfaces();
				if (superInterfaces != null && currentType.isIntersectionType()) {
					for (int i = 0; i < superInterfaces.length; i++) {
						superInterfaces[i] = (ReferenceBinding)superInterfaces[i].capture(invocationScope, invocationSite.sourceEnd());
					}
				}
				
				searchVisibleInterfaceMethods(
						superInterfaces,
						receiverType,
						scope,
						invocationSite,
						invocationScope,
						onlyStaticMethods,
						methodsFound);
			} else {
				hasPotentialDefaultAbstractMethods = false;
			}
			if(currentType.isParameterizedType()) {
				currentType = ((ParameterizedTypeBinding)currentType).genericType().superclass();
			} else {
				currentType = currentType.superclass();
			}
		}
	}
	private void searchVisibleVariablesAndMethods(
			Scope scope,
			ObjectVector localsFound,
			ObjectVector fieldsFound,
			ObjectVector methodsFound,
			boolean notInJavadoc) {
		
		InvocationSite invocationSite = CompletionEngine.FakeInvocationSite;
		
		boolean staticsOnly = false;
		// need to know if we're in a static context (or inside a constructor)

		Scope currentScope = scope;
		
		done1 : while (true) { // done when a COMPILATION_UNIT_SCOPE is found

			switch (currentScope.kind) {

				case Scope.METHOD_SCOPE :
					// handle the error case inside an explicit constructor call (see MethodScope>>findField)
					MethodScope methodScope = (MethodScope) currentScope;
					staticsOnly |= methodScope.isStatic | methodScope.isConstructorCall;

				case Scope.BLOCK_SCOPE :
					BlockScope blockScope = (BlockScope) currentScope;

					next : for (int i = 0, length = blockScope.locals.length; i < length; i++) {
						LocalVariableBinding local = blockScope.locals[i];

						if (local == null)
							break next;

						if (local.isSecret())
							continue next;

						for (int f = 0; f < localsFound.size; f++) {
							LocalVariableBinding otherLocal =
								(LocalVariableBinding) localsFound.elementAt(f);
							if (CharOperation.equals(otherLocal.name, local.name, true))
								continue next;
						}
						
						localsFound.add(local);
					}
					break;

				case Scope.COMPILATION_UNIT_SCOPE :
					break done1;
			}
			currentScope = currentScope.parent;
		}
		
		staticsOnly = false;
		currentScope = scope;
		
		done2 : while (true) { // done when a COMPILATION_UNIT_SCOPE is found

			switch (currentScope.kind) {
				case Scope.METHOD_SCOPE :
					// handle the error case inside an explicit constructor call (see MethodScope>>findField)
					MethodScope methodScope = (MethodScope) currentScope;
					staticsOnly |= methodScope.isStatic | methodScope.isConstructorCall;
					break;
				case Scope.CLASS_SCOPE :
					ClassScope classScope = (ClassScope) currentScope;
					SourceTypeBinding enclosingType = classScope.referenceContext.binding;
					
					searchVisibleFields(
							enclosingType,
							classScope,
							invocationSite,
							scope,
							staticsOnly,
							notInJavadoc,
							localsFound,
							fieldsFound);
					
					searchVisibleMethods(
							enclosingType,
							classScope,
							invocationSite,
							scope,
							staticsOnly,
							notInJavadoc,
							methodsFound);
					
					staticsOnly |= enclosingType.isStatic();
					break;

				case Scope.COMPILATION_UNIT_SCOPE :
					break done2;
			}
			currentScope = currentScope.parent;
		}
		
		// search in static import
		ImportBinding[] importBindings = scope.compilationUnitScope().imports;
		for (int i = 0; i < importBindings.length; i++) {
			ImportBinding importBinding = importBindings[i];
			if(importBinding.isValidBinding() && importBinding.isStatic()) {
				Binding binding = importBinding.resolvedImport;
				if(binding != null && binding.isValidBinding()) {
					if(importBinding.onDemand) {
						if((binding.kind() & Binding.TYPE) != 0) {
							searchVisibleFields(
									(ReferenceBinding)binding,
									scope,
									invocationSite,
									scope,
									staticsOnly,
									notInJavadoc,
									localsFound,
									fieldsFound);
							
							searchVisibleMethods(
									(ReferenceBinding)binding,
									scope,
									invocationSite,
									scope,
									staticsOnly,
									notInJavadoc,
									methodsFound);
						}
					} else {
						if ((binding.kind() & Binding.FIELD) != 0) {
							searchVisibleFields(
									new FieldBinding[]{(FieldBinding)binding},
									((FieldBinding)binding).declaringClass,
									scope,
									invocationSite,
									scope,
									staticsOnly,
									localsFound,
									fieldsFound);
						} else if ((binding.kind() & Binding.METHOD) != 0) {
							MethodBinding methodBinding = (MethodBinding)binding;
							
							searchVisibleLocalMethods(
									methodBinding.declaringClass.getMethods(methodBinding.selector),
									methodBinding.declaringClass,
									scope,
									invocationSite,
									scope,
									true,
									methodsFound);
						}
					}
				}
			}
		}
	}
}

Lines 236-242 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/parser/GenericDietRecoveryTest.java (-1 / +2 lines)
236	new ProblemReporter(	236	new ProblemReporter(
237	DefaultErrorHandlingPolicies.proceedWithAllProblems(),	237	DefaultErrorHandlingPolicies.proceedWithAllProblems(),
238	options,	238	options,
239	new DefaultProblemFactory(Locale.getDefault())));	239	new DefaultProblemFactory(Locale.getDefault())),
		240	false);
240		241
241	ICompilationUnit sourceUnit = new CompilationUnit(source, testName, null);	242	ICompilationUnit sourceUnit = new CompilationUnit(source, testName, null);
242	CompilationResult compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);	243	CompilationResult compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);

Lines 230-236 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/parser/DietRecoveryTest.java (-1 / +2 lines)
230	new ProblemReporter(	230	new ProblemReporter(
231	DefaultErrorHandlingPolicies.proceedWithAllProblems(),	231	DefaultErrorHandlingPolicies.proceedWithAllProblems(),
232	options,	232	options,
233	new DefaultProblemFactory(Locale.getDefault())));	233	new DefaultProblemFactory(Locale.getDefault())),
		234	false);
234		235
235	ICompilationUnit sourceUnit = new CompilationUnit(source, testName, null);	236	ICompilationUnit sourceUnit = new CompilationUnit(source, testName, null);
236	CompilationResult compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);	237	CompilationResult compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);

Lines 193-199 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/parser/EnumDietRecoveryTest.java (-1 / +2 lines)
193	new ProblemReporter(	193	new ProblemReporter(
194	DefaultErrorHandlingPolicies.proceedWithAllProblems(),	194	DefaultErrorHandlingPolicies.proceedWithAllProblems(),
195	options,	195	options,
196	new DefaultProblemFactory(Locale.getDefault())));	196	new DefaultProblemFactory(Locale.getDefault())),
		197	false);
197		198
198	ICompilationUnit sourceUnit = new CompilationUnit(source, testName, null);	199	ICompilationUnit sourceUnit = new CompilationUnit(source, testName, null);
199	CompilationResult compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);	200	CompilationResult compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);

Lines 98-104 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/parser/JavadocCompletionParserTest.java (-1 / +2 lines)
98	CompilerOptions options = new CompilerOptions(getCompilerOptions());	98	CompilerOptions options = new CompilerOptions(getCompilerOptions());
99	CompletionParser parser = new CompletionParser(new ProblemReporter(DefaultErrorHandlingPolicies.proceedWithAllProblems(),	99	CompletionParser parser = new CompletionParser(new ProblemReporter(DefaultErrorHandlingPolicies.proceedWithAllProblems(),
100	options,	100	options,
101	new DefaultProblemFactory(Locale.getDefault())));	101	new DefaultProblemFactory(Locale.getDefault())),
		102	false);
102		103
103	ICompilationUnit sourceUnit = new CompilationUnit(source.toCharArray(), "Test.java", null);	104	ICompilationUnit sourceUnit = new CompilationUnit(source.toCharArray(), "Test.java", null);
104	CompilationResult compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);	105	CompilationResult compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);




			new ProblemReporter(
				DefaultErrorHandlingPolicies.proceedWithAllProblems(), 
				options, 
				new DefaultProblemFactory(Locale.getDefault())),
			false);

	ICompilationUnit sourceUnit = new CompilationUnit(source, testName, null);
	CompilationResult compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);	

			new ProblemReporter(
				DefaultErrorHandlingPolicies.proceedWithAllProblems(), 
				options, 
				new DefaultProblemFactory(Locale.getDefault())),
			false);

	ICompilationUnit sourceUnit = new CompilationUnit(source, testName, null);
	CompilationResult compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);	

Lines 204-210 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/parser/AnnotationDietRecoveryTest.java (-1 / +2 lines)
204	new ProblemReporter(	204	new ProblemReporter(
205	DefaultErrorHandlingPolicies.proceedWithAllProblems(),	205	DefaultErrorHandlingPolicies.proceedWithAllProblems(),
206	options,	206	options,
207	new DefaultProblemFactory(Locale.getDefault())));	207	new DefaultProblemFactory(Locale.getDefault())),
		208	false);
208		209
209	ICompilationUnit sourceUnit = new CompilationUnit(source, testName, null);	210	ICompilationUnit sourceUnit = new CompilationUnit(source, testName, null);
210	CompilationResult compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);	211	CompilationResult compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);




		"completion token location=UNKNOWN",
		result.context);
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=202470
public void test0028() throws JavaModelException {
	this.workingCopies = new ICompilationUnit[2];
	this.workingCopies[0] = getWorkingCopy(
		"/Completion/src3/test/X.java",
		"package test;\n" + 
		"public class X<TX> extends A<String> {\n" + 
		"  public void methodX(TX x) {}\n" + 
		"  public void foo() {\n" +
		"    zzzz\n" +
		"  }\n" +
		"}");
	
	this.workingCopies[1] = getWorkingCopy(
		"/Completion/src3/test/A.java",
		"package test;\n" + 
		"public class A<TA> {\n" + 
		"  public void methodA(TA a) {}\n" + 
		"}");
	
	String str = this.workingCopies[0].getSource();
	int tokenStart = str.lastIndexOf("zzzz");
	int tokenEnd = tokenStart + "zzzz".length() - 1;
	int cursorLocation = str.lastIndexOf("zzzz") + "zzzz".length();

	CompletionResult result = contextComplete(this.workingCopies[0], cursorLocation, false, true);
	
	String jclPath = getExternalJCLPathString("1.5");
	assertResults(
		"completion offset="+(cursorLocation)+"\n" +
		"completion range=["+(tokenStart)+", "+(tokenEnd)+"]\n" +
		"completion token=\"zzzz\"\n" +
		"completion token kind=TOKEN_KIND_NAME\n" +
		"expectedTypesSignatures=null\n" +
		"expectedTypesKeys=null\n" +
		"completion token location={STATEMENT_START}\n" +
		"visibleElements={\n" +
		"	methodX(TX) {key=Ltest/X;.methodX(TTX;)V} [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]],\n" +
		"	foo() {key=Ltest/X;.foo()V} [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]],\n" +
		"	methodA(TA) {key=Ltest/A<Ljava/lang/String;>;.methodA(Ljava/lang/String;)V} [in A [in [Working copy] A.java [in test [in src3 [in Completion]]]]],\n" +
		"	wait(long, int) {key=Ljava/lang/Object;.wait(JI)V|Ljava/lang/IllegalMonitorStateException;|Ljava/lang/InterruptedException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
		"	wait(long) {key=Ljava/lang/Object;.wait(J)V|Ljava/lang/IllegalMonitorStateException;|Ljava/lang/InterruptedException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
		"	wait() {key=Ljava/lang/Object;.wait()V|Ljava/lang/IllegalMonitorStateException;|Ljava/lang/InterruptedException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
		"	toString() {key=Ljava/lang/Object;.toString()Ljava/lang/String;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
		"	notifyAll() {key=Ljava/lang/Object;.notifyAll()V|Ljava/lang/IllegalMonitorStateException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
		"	notify() {key=Ljava/lang/Object;.notify()V|Ljava/lang/IllegalMonitorStateException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
		"	hashCode() {key=Ljava/lang/Object;.hashCode()I} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
		"	getClass() {key=Ljava/lang/Object;.getClass()Ljava/lang/Class<+Ljava/lang/Object;>;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
		"	finalize() {key=Ljava/lang/Object;.finalize()V|Ljava/lang/Throwable;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
		"	equals(java.lang.Object) {key=Ljava/lang/Object;.equals(Ljava/lang/Object;)Z} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
		"	clone() {key=Ljava/lang/Object;.clone()Ljava/lang/Object;|Ljava/lang/CloneNotSupportedException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
		"}",
		result.context);
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=202470
public void test0029() throws JavaModelException {
	this.workingCopies = new ICompilationUnit[2];
	this.workingCopies[0] = getWorkingCopy(
		"/Completion/src3/test/X.java",
		"package test;\n" + 
		"public class X {\n" + 
		"  public A<String> methodX() {return null;}\n" + 
		"  public void foo() {\n" +
		"    zzzz\n" +
		"  }\n" +
		"}");
	
	this.workingCopies[1] = getWorkingCopy(
		"/Completion/src3/test/A.java",
		"package test;\n" + 
		"public class A<TA> {\n" + 
		"}");
	
	String str = this.workingCopies[0].getSource();
	int tokenStart = str.lastIndexOf("zzzz");
	int tokenEnd = tokenStart + "zzzz".length() - 1;
	int cursorLocation = str.lastIndexOf("zzzz") + "zzzz".length();

	CompletionResult result = contextComplete(this.workingCopies[0], cursorLocation, false, true, "Ltest/A<Ljava/lang/String;>;");
	
	assertResults(
		"completion offset="+(cursorLocation)+"\n" +
		"completion range=["+(tokenStart)+", "+(tokenEnd)+"]\n" +
		"completion token=\"zzzz\"\n" +
		"completion token kind=TOKEN_KIND_NAME\n" +
		"expectedTypesSignatures=null\n" +
		"expectedTypesKeys=null\n" +
		"completion token location={STATEMENT_START}\n" +
		"visibleElements={\n" +
		"	methodX() {key=Ltest/X;.methodX()Ltest/A<Ljava/lang/String;>;} [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]],\n" +
		"}",
		result.context);
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=202470
public void test0030() throws JavaModelException {
	this.workingCopies = new ICompilationUnit[3];
	this.workingCopies[0] = getWorkingCopy(
		"/Completion/src3/test/X.java",
		"package test;\n" + 
		"public class X {\n" + 
		"  public A<String> methodX() {return null;}\n" + 
		"  public void foo() {\n" +
		"    zzzz\n" +
		"  }\n" +
		"}");
	
	this.workingCopies[1] = getWorkingCopy(
		"/Completion/src3/test/A.java",
		"package test;\n" + 
		"public class A<TA> {\n" + 
		"}");
	
	this.workingCopies[2] = getWorkingCopy(
		"/Completion/src3/test/B.java",
		"package test;\n" + 
		"public class B<TB> {\n" + 
		"}");
	
	String str = this.workingCopies[0].getSource();
	int tokenStart = str.lastIndexOf("zzzz");
	int tokenEnd = tokenStart + "zzzz".length() - 1;
	int cursorLocation = str.lastIndexOf("zzzz") + "zzzz".length();

	CompletionResult result = contextComplete(this.workingCopies[0], cursorLocation, false, true, "Ltest/B<Ljava/lang/String;>;");
	
	assertResults(
		"completion offset="+(cursorLocation)+"\n" +
		"completion range=["+(tokenStart)+", "+(tokenEnd)+"]\n" +
		"completion token=\"zzzz\"\n" +
		"completion token kind=TOKEN_KIND_NAME\n" +
		"expectedTypesSignatures=null\n" +
		"expectedTypesKeys=null\n" +
		"completion token location={STATEMENT_START}\n" +
		"visibleElements={}",
		result.context);
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=202470
public void test0031() throws JavaModelException {
	this.workingCopies = new ICompilationUnit[3];
	this.workingCopies[0] = getWorkingCopy(
		"/Completion/src3/test/X.java",
		"package test;\n" + 
		"public class X {\n" + 
		"  public A<String> methodX() {return null;}\n" + 
		"  public void foo() {\n" +
		"    zzzz\n" +
		"  }\n" +
		"}");
	
	this.workingCopies[1] = getWorkingCopy(
		"/Completion/src3/test/A.java",
		"package test;\n" + 
		"public class A<TA> extends B<TA>{\n" + 
		"}");
	
	this.workingCopies[2] = getWorkingCopy(
		"/Completion/src3/test/B.java",
		"package test;\n" + 
		"public class B<TB> {\n" + 
		"}");
	
	String str = this.workingCopies[0].getSource();
	int tokenStart = str.lastIndexOf("zzzz");
	int tokenEnd = tokenStart + "zzzz".length() - 1;
	int cursorLocation = str.lastIndexOf("zzzz") + "zzzz".length();

	CompletionResult result = contextComplete(this.workingCopies[0], cursorLocation, false, true, "Ltest/B<Ljava/lang/String;>;");
	
	assertResults(
		"completion offset="+(cursorLocation)+"\n" +
		"completion range=["+(tokenStart)+", "+(tokenEnd)+"]\n" +
		"completion token=\"zzzz\"\n" +
		"completion token kind=TOKEN_KIND_NAME\n" +
		"expectedTypesSignatures=null\n" +
		"expectedTypesKeys=null\n" +
		"completion token location={STATEMENT_START}\n" +
		"visibleElements={\n" +
		"	methodX() {key=Ltest/X;.methodX()Ltest/A<Ljava/lang/String;>;} [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]],\n" +
		"}",
		result.context);
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=202470
public void test0032() throws JavaModelException {
	this.workingCopies = new ICompilationUnit[2];
	this.workingCopies[0] = getWorkingCopy(
		"/Completion/src3/test/X.java",
		"package test;\n" + 
		"public class X {\n" + 
		"  public A<String> methodX() {return null;}\n" + 
		"  public void foo() {\n" +
		"    zzzz\n" +
		"  }\n" +
		"}");
	
	this.workingCopies[1] = getWorkingCopy(
		"/Completion/src3/test/A.java",
		"package test;\n" + 
		"public class A<TA> {\n" + 
		"}");
	
	String str = this.workingCopies[0].getSource();
	int tokenStart = str.lastIndexOf("zzzz");
	int tokenEnd = tokenStart + "zzzz".length() - 1;
	int cursorLocation = str.lastIndexOf("zzzz") + "zzzz".length();

	CompletionResult result = contextComplete(this.workingCopies[0], cursorLocation, false, true, "Ltest/Zork<Ljava/lang/String;>;");
	
	assertResults(
		"completion offset="+(cursorLocation)+"\n" +
		"completion range=["+(tokenStart)+", "+(tokenEnd)+"]\n" +
		"completion token=\"zzzz\"\n" +
		"completion token kind=TOKEN_KIND_NAME\n" +
		"expectedTypesSignatures=null\n" +
		"expectedTypesKeys=null\n" +
		"completion token location={STATEMENT_START}\n" +
		"visibleElements={}",
		result.context);
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=202470
public void test0033() throws JavaModelException {
	this.workingCopies = new ICompilationUnit[2];
	this.workingCopies[0] = getWorkingCopy(
		"/Completion/src3/test/X.java",
		"package test;\n" + 
		"public class X {\n" + 
		"  public A<String> methodX() {return null;}\n" + 
		"  public void foo() {\n" +
		"    zzzz\n" +
		"  }\n" +
		"}");
	
	this.workingCopies[1] = getWorkingCopy(
		"/Completion/src3/test/A.java",
		"package test;\n" + 
		"public class A<TA> {\n" + 
		"}");
	
	
	String str = this.workingCopies[0].getSource();
	int tokenStart = str.lastIndexOf("zzzz");
	int tokenEnd = tokenStart + "zzzz".length() - 1;
	int cursorLocation = str.lastIndexOf("zzzz") + "zzzz".length();

	CompletionResult result = contextComplete(this.workingCopies[0], cursorLocation, false, true, "Ltest/A<LZork;>;");
	
	assertResults(
		"completion offset="+(cursorLocation)+"\n" +
		"completion range=["+(tokenStart)+", "+(tokenEnd)+"]\n" +
		"completion token=\"zzzz\"\n" +
		"completion token kind=TOKEN_KIND_NAME\n" +
		"expectedTypesSignatures=null\n" +
		"expectedTypesKeys=null\n" +
		"completion token location={STATEMENT_START}\n" +
		"visibleElements={}",
		result.context);
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=202470
public void test0034() throws JavaModelException {
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy(
		"/Completion/src3/test/X.java",
		"package test;\n" + 
		"public class X<T> {\n" + 
		"  public T methodX() {return null;}\n" + 
		"  public void foo() {\n" +
		"    zzzz\n" +
		"  }\n" +
		"}");
	
	String str = this.workingCopies[0].getSource();
	int tokenStart = str.lastIndexOf("zzzz");
	int tokenEnd = tokenStart + "zzzz".length() - 1;
	int cursorLocation = str.lastIndexOf("zzzz") + "zzzz".length();

	CompletionResult result = contextComplete(this.workingCopies[0], cursorLocation, false, true, "TT;");
	
	assertResults(
		"completion offset="+(cursorLocation)+"\n" +
		"completion range=["+(tokenStart)+", "+(tokenEnd)+"]\n" +
		"completion token=\"zzzz\"\n" +
		"completion token kind=TOKEN_KIND_NAME\n" +
		"expectedTypesSignatures=null\n" +
		"expectedTypesKeys=null\n" +
		"completion token location={STATEMENT_START}\n" +
		"visibleElements={\n" +
		"	methodX() {key=Ltest/X;.methodX()TT;} [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]],\n" +
		"}",
		result.context);
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=202470
public void test0035() throws JavaModelException {
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy(
		"/Completion/src3/test/X.java",
		"package test;\n" + 
		"public class X {\n" + 
		"  public <T> T methodX() {return null;}\n" + 
		"  public void foo() {\n" +
		"    zzzz\n" +
		"  }\n" +
		"}");
	
	String str = this.workingCopies[0].getSource();
	int tokenStart = str.lastIndexOf("zzzz");
	int tokenEnd = tokenStart + "zzzz".length() - 1;
	int cursorLocation = str.lastIndexOf("zzzz") + "zzzz".length();

	CompletionResult result = contextComplete(this.workingCopies[0], cursorLocation, false, true, "TT;");
	
	assertResults(
		"completion offset="+(cursorLocation)+"\n" +
		"completion range=["+(tokenStart)+", "+(tokenEnd)+"]\n" +
		"completion token=\"zzzz\"\n" +
		"completion token kind=TOKEN_KIND_NAME\n" +
		"expectedTypesSignatures=null\n" +
		"expectedTypesKeys=null\n" +
		"completion token location={STATEMENT_START}\n" +
		"visibleElements={}",
		result.context);
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=202470
public void test0036() throws JavaModelException {
	this.workingCopies = new ICompilationUnit[1];
	this.workingCopies[0] = getWorkingCopy(
		"/Completion/src3/test/X.java",
		"package test;\n" + 
		"public class X {\n" + 
		"  public <T> T methodX() {\n" + 
		"    zzzz\n" +
		"  }\n" +
		"}");
	
	String str = this.workingCopies[0].getSource();
	int tokenStart = str.lastIndexOf("zzzz");
	int tokenEnd = tokenStart + "zzzz".length() - 1;
	int cursorLocation = str.lastIndexOf("zzzz") + "zzzz".length();

	CompletionResult result = contextComplete(this.workingCopies[0], cursorLocation, false, true, "TT;");
	
	assertResults(
		"completion offset="+(cursorLocation)+"\n" +
		"completion range=["+(tokenStart)+", "+(tokenEnd)+"]\n" +
		"completion token=\"zzzz\"\n" +
		"completion token kind=TOKEN_KIND_NAME\n" +
		"expectedTypesSignatures=null\n" +
		"expectedTypesKeys=null\n" +
		"completion token location={STATEMENT_START}\n" +
		"visibleElements={\n" +
		"	methodX() {key=Ltest/X;.methodX<T:Ljava/lang/Object;>()TT;} [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]],\n" +
		"}",
		result.context);
}
}

Lines 10-15 Link Here

(-)src/org/eclipse/jdt/core/tests/model/CompletionContextTests.java (+825 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.jdt.core.tests.model;	11	package org.eclipse.jdt.core.tests.model;
12		12
		13	import java.io.IOException;
		14
		15	import org.eclipse.core.runtime.CoreException;
13	import org.eclipse.jdt.core.*;	16	import org.eclipse.jdt.core.*;
14		17
15	import org.eclipse.jdt.internal.codeassist.RelevanceConstants;	18	import org.eclipse.jdt.internal.codeassist.RelevanceConstants;
Lines 3914-3917 Link Here
3914	"completion token location={STATEMENT_START}",	3917	"completion token location={STATEMENT_START}",
3915	result.context);	3918	result.context);
3916	}	3919	}
		3920	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=202470
		3921	public void test0143() throws JavaModelException {
		3922	this.workingCopies = new ICompilationUnit[1];
		3923	this.workingCopies[0] = getWorkingCopy(
		3924	"/Completion/src3/test/X.java",
		3925	"package test;\n" +
		3926	"zzzz\n" +
		3927	"public class X {\n" +
		3928	" public int field0;\n" +
		3929	"}");
		3930
		3931	String str = this.workingCopies[0].getSource();
		3932	int tokenStart = str.lastIndexOf("zzzz");
		3933	int tokenEnd = tokenStart + "zzzz".length() - 1;
		3934	int cursorLocation = str.lastIndexOf("zzzz") + "zzzz".length();
		3935
		3936	CompletionResult result = contextComplete(this.workingCopies[0], cursorLocation, false, true);
		3937
		3938	assertResults(
		3939	"completion offset="+(cursorLocation)+"\n" +
		3940	"completion range=["+(tokenStart)+", "+(tokenEnd)+"]\n" +
		3941	"completion token=\"zzzz\"\n" +
		3942	"completion token kind=TOKEN_KIND_NAME\n" +
		3943	"expectedTypesSignatures=null\n" +
		3944	"expectedTypesKeys=null\n" +
		3945	"completion token location=UNKNOWN\n" +
		3946	"visibleElements={}",
		3947	result.context);
		3948	}
		3949	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=202470
		3950	public void test0144() throws JavaModelException {
		3951	this.workingCopies = new ICompilationUnit[1];
		3952	this.workingCopies[0] = getWorkingCopy(
		3953	"/Completion/src3/test/X.java",
		3954	"package test;\n" +
		3955	"public class X {\n" +
		3956	" zzzz\n" +
		3957	" public int field0;\n" +
		3958	"}");
		3959
		3960	String str = this.workingCopies[0].getSource();
		3961	int tokenStart = str.lastIndexOf("zzzz");
		3962	int tokenEnd = tokenStart + "zzzz".length() - 1;
		3963	int cursorLocation = str.lastIndexOf("zzzz") + "zzzz".length();
		3964
		3965	CompletionResult result = contextComplete(this.workingCopies[0], cursorLocation, false, true);
		3966
		3967	assertResults(
		3968	"completion offset="+(cursorLocation)+"\n" +
		3969	"completion range=["+(tokenStart)+", "+(tokenEnd)+"]\n" +
		3970	"completion token=\"zzzz\"\n" +
		3971	"completion token kind=TOKEN_KIND_NAME\n" +
		3972	"expectedTypesSignatures=null\n" +
		3973	"expectedTypesKeys=null\n" +
		3974	"completion token location={MEMBER_START}\n" +
		3975	"visibleElements={}",
		3976	result.context);
		3977	}
		3978	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=202470
		3979	public void test0145() throws JavaModelException {
		3980	this.workingCopies = new ICompilationUnit[1];
		3981	this.workingCopies[0] = getWorkingCopy(
		3982	"/Completion/src3/test/X.java",
		3983	"package test;\n" +
3984	"public class X {\n" +
3985	" public int field0;\n" +
3986	" public int field1 = zzzz;\n" +
3987	"}");
3988
3989	String str = this.workingCopies[0].getSource();
3990	int tokenStart = str.lastIndexOf("zzzz");
3991	int tokenEnd = tokenStart + "zzzz".length() - 1;
3992	int cursorLocation = str.lastIndexOf("zzzz") + "zzzz".length();
3993
3994	CompletionResult result = contextComplete(this.workingCopies[0], cursorLocation, false, true);
3995
3996	String jclPath = getExternalJCLPathString();
3997	assertResults(
3998	"completion offset="+(cursorLocation)+"\n" +
3999	"completion range=["+(tokenStart)+", "+(tokenEnd)+"]\n" +
4000	"completion token=\"zzzz\"\n" +
4001	"completion token kind=TOKEN_KIND_NAME\n" +
4002	"expectedTypesSignatures={I}\n" +
4003	"expectedTypesKeys={I}\n" +
4004	"completion token location=UNKNOWN\n" +
4005	"visibleElements={\n" +
4006	" field1 {key=Ltest/X;.field1)I} [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]],\n" +
4007	" field0 {key=Ltest/X;.field0)I} [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]],\n" +
4008	" wait(long, int) {key=Ljava/lang/Object;.wait(JI)V\|Ljava/lang/IllegalMonitorStateException;\|Ljava/lang/InterruptedException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4009	" wait(long) {key=Ljava/lang/Object;.wait(J)V\|Ljava/lang/IllegalMonitorStateException;\|Ljava/lang/InterruptedException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4010	" wait() {key=Ljava/lang/Object;.wait()V\|Ljava/lang/IllegalMonitorStateException;\|Ljava/lang/InterruptedException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4011	" toString() {key=Ljava/lang/Object;.toString()Ljava/lang/String;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4012	" notifyAll() {key=Ljava/lang/Object;.notifyAll()V\|Ljava/lang/IllegalMonitorStateException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4013	" notify() {key=Ljava/lang/Object;.notify()V\|Ljava/lang/IllegalMonitorStateException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4014	" hashCode() {key=Ljava/lang/Object;.hashCode()I} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4015	" getClass() {key=Ljava/lang/Object;.getClass()Ljava/lang/Class;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4016	" finalize() {key=Ljava/lang/Object;.finalize()V\|Ljava/lang/Throwable;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4017	" equals(java.lang.Object) {key=Ljava/lang/Object;.equals(Ljava/lang/Object;)Z} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4018	" clone() {key=Ljava/lang/Object;.clone()Ljava/lang/Object;\|Ljava/lang/CloneNotSupportedException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4019	"}",
4020	result.context);
4021	}
4022	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=202470
4023	public void test0146() throws JavaModelException {
4024	this.workingCopies = new ICompilationUnit[1];
4025	this.workingCopies[0] = getWorkingCopy(
4026	"/Completion/src3/test/X.java",
4027	"package test;\n" +
4028	"public class X {\n" +
4029	" public int field0;\n" +
4030	" { zzzz }\n" +
4031	"}");
4032
4033	String str = this.workingCopies[0].getSource();
4034	int tokenStart = str.lastIndexOf("zzzz");
4035	int tokenEnd = tokenStart + "zzzz".length() - 1;
4036	int cursorLocation = str.lastIndexOf("zzzz") + "zzzz".length();
4037
4038	CompletionResult result = contextComplete(this.workingCopies[0], cursorLocation, false, true);
4039
4040	String jclPath = getExternalJCLPathString();
4041	assertResults(
4042	"completion offset="+(cursorLocation)+"\n" +
4043	"completion range=["+(tokenStart)+", "+(tokenEnd)+"]\n" +
4044	"completion token=\"zzzz\"\n" +
4045	"completion token kind=TOKEN_KIND_NAME\n" +
4046	"expectedTypesSignatures=null\n" +
4047	"expectedTypesKeys=null\n" +
4048	"completion token location={STATEMENT_START}\n" +
4049	"visibleElements={\n" +
4050	" field0 {key=Ltest/X;.field0)I} [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]],\n" +
4051	" wait(long, int) {key=Ljava/lang/Object;.wait(JI)V\|Ljava/lang/IllegalMonitorStateException;\|Ljava/lang/InterruptedException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4052	" wait(long) {key=Ljava/lang/Object;.wait(J)V\|Ljava/lang/IllegalMonitorStateException;\|Ljava/lang/InterruptedException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4053	" wait() {key=Ljava/lang/Object;.wait()V\|Ljava/lang/IllegalMonitorStateException;\|Ljava/lang/InterruptedException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4054	" toString() {key=Ljava/lang/Object;.toString()Ljava/lang/String;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4055	" notifyAll() {key=Ljava/lang/Object;.notifyAll()V\|Ljava/lang/IllegalMonitorStateException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4056	" notify() {key=Ljava/lang/Object;.notify()V\|Ljava/lang/IllegalMonitorStateException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4057	" hashCode() {key=Ljava/lang/Object;.hashCode()I} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4058	" getClass() {key=Ljava/lang/Object;.getClass()Ljava/lang/Class;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4059	" finalize() {key=Ljava/lang/Object;.finalize()V\|Ljava/lang/Throwable;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4060	" equals(java.lang.Object) {key=Ljava/lang/Object;.equals(Ljava/lang/Object;)Z} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4061	" clone() {key=Ljava/lang/Object;.clone()Ljava/lang/Object;\|Ljava/lang/CloneNotSupportedException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4062	"}",
4063	result.context);
4064	}
4065	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=202470
4066	public void test0147() throws JavaModelException {
4067	this.workingCopies = new ICompilationUnit[1];
4068	this.workingCopies[0] = getWorkingCopy(
4069	"/Completion/src3/test/X.java",
4070	"package test;\n" +
4071	"public class X {\n" +
4072	" public int field0;\n" +
4073	" public void foo() {\n" +
4074	" zzzz\n" +
4075	" }\n" +
4076	"}");
4077
4078	String str = this.workingCopies[0].getSource();
4079	int tokenStart = str.lastIndexOf("zzzz");
4080	int tokenEnd = tokenStart + "zzzz".length() - 1;
4081	int cursorLocation = str.lastIndexOf("zzzz") + "zzzz".length();
4082
4083	CompletionResult result = contextComplete(this.workingCopies[0], cursorLocation, false, true);
4084
4085	String jclPath = getExternalJCLPathString();
4086	assertResults(
4087	"completion offset="+(cursorLocation)+"\n" +
4088	"completion range=["+(tokenStart)+", "+(tokenEnd)+"]\n" +
4089	"completion token=\"zzzz\"\n" +
4090	"completion token kind=TOKEN_KIND_NAME\n" +
4091	"expectedTypesSignatures=null\n" +
4092	"expectedTypesKeys=null\n" +
4093	"completion token location={STATEMENT_START}\n" +
4094	"visibleElements={\n" +
4095	" field0 {key=Ltest/X;.field0)I} [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]],\n" +
4096	" foo() {key=Ltest/X;.foo()V} [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]],\n" +
4097	" wait(long, int) {key=Ljava/lang/Object;.wait(JI)V\|Ljava/lang/IllegalMonitorStateException;\|Ljava/lang/InterruptedException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4098	" wait(long) {key=Ljava/lang/Object;.wait(J)V\|Ljava/lang/IllegalMonitorStateException;\|Ljava/lang/InterruptedException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4099	" wait() {key=Ljava/lang/Object;.wait()V\|Ljava/lang/IllegalMonitorStateException;\|Ljava/lang/InterruptedException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4100	" toString() {key=Ljava/lang/Object;.toString()Ljava/lang/String;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4101	" notifyAll() {key=Ljava/lang/Object;.notifyAll()V\|Ljava/lang/IllegalMonitorStateException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4102	" notify() {key=Ljava/lang/Object;.notify()V\|Ljava/lang/IllegalMonitorStateException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4103	" hashCode() {key=Ljava/lang/Object;.hashCode()I} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4104	" getClass() {key=Ljava/lang/Object;.getClass()Ljava/lang/Class;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4105	" finalize() {key=Ljava/lang/Object;.finalize()V\|Ljava/lang/Throwable;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4106	" equals(java.lang.Object) {key=Ljava/lang/Object;.equals(Ljava/lang/Object;)Z} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4107	" clone() {key=Ljava/lang/Object;.clone()Ljava/lang/Object;\|Ljava/lang/CloneNotSupportedException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4108	"}",
4109	result.context);
4110	}
4111	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=202470
4112	public void test0148() throws JavaModelException {
4113	this.workingCopies = new ICompilationUnit[1];
4114	this.workingCopies[0] = getWorkingCopy(
4115	"/Completion/src3/test/X.java",
4116	"package test;\n" +
4117	"public class X {\n" +
4118	" public int field0;\n" +
4119	" public int fieldX0;\n" +
4120	" public class Y {\n" +
4121	" public int field0;\n" +
4122	" public int fieldY0;\n" +
4123	" public void fooY() {\n" +
4124	" int local0;\n" +
4125	" int localfooY0;\n" +
4126	" if (true) {\n" +
4127	" int local0;\n" +
4128	" int localfooY1;\n" +
4129	" zzzz\n" +
4130	" }\n" +
4131	" }\n" +
4132	"}");
4133
4134	String str = this.workingCopies[0].getSource();
4135	int tokenStart = str.lastIndexOf("zzzz");
4136	int tokenEnd = tokenStart + "zzzz".length() - 1;
4137	int cursorLocation = str.lastIndexOf("zzzz") + "zzzz".length();
4138
4139	CompletionResult result = contextComplete(this.workingCopies[0], cursorLocation, false, true);
4140
4141	String jclPath = getExternalJCLPathString();
4142	assertResults(
4143	"completion offset="+(cursorLocation)+"\n" +
4144	"completion range=["+(tokenStart)+", "+(tokenEnd)+"]\n" +
4145	"completion token=\"zzzz\"\n" +
4146	"completion token kind=TOKEN_KIND_NAME\n" +
4147	"expectedTypesSignatures=null\n" +
4148	"expectedTypesKeys=null\n" +
4149	"completion token location={STATEMENT_START}\n" +
4150	"visibleElements={\n" +
4151	" local0 [in fooY() [in Y [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]]]],\n" +
4152	" localfooY0 [in fooY() [in Y [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]]]],\n" +
4153	" localfooY1 [in fooY() [in Y [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]]]],\n" +
4154	" fieldY0 {key=Ltest/X$Y;.fieldY0)I} [in Y [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]]],\n" +
4155	" field0 {key=Ltest/X$Y;.field0)I} [in Y [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]]],\n" +
4156	" fieldX0 {key=Ltest/X;.fieldX0)I} [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]],\n" +
4157	" fooY() {key=Ltest/X$Y;.fooY()V} [in Y [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]]],\n" +
4158	" wait(long, int) {key=Ljava/lang/Object;.wait(JI)V\|Ljava/lang/IllegalMonitorStateException;\|Ljava/lang/InterruptedException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4159	" wait(long) {key=Ljava/lang/Object;.wait(J)V\|Ljava/lang/IllegalMonitorStateException;\|Ljava/lang/InterruptedException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4160	" wait() {key=Ljava/lang/Object;.wait()V\|Ljava/lang/IllegalMonitorStateException;\|Ljava/lang/InterruptedException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4161	" toString() {key=Ljava/lang/Object;.toString()Ljava/lang/String;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4162	" notifyAll() {key=Ljava/lang/Object;.notifyAll()V\|Ljava/lang/IllegalMonitorStateException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4163	" notify() {key=Ljava/lang/Object;.notify()V\|Ljava/lang/IllegalMonitorStateException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4164	" hashCode() {key=Ljava/lang/Object;.hashCode()I} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4165	" getClass() {key=Ljava/lang/Object;.getClass()Ljava/lang/Class;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4166	" finalize() {key=Ljava/lang/Object;.finalize()V\|Ljava/lang/Throwable;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4167	" equals(java.lang.Object) {key=Ljava/lang/Object;.equals(Ljava/lang/Object;)Z} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4168	" clone() {key=Ljava/lang/Object;.clone()Ljava/lang/Object;\|Ljava/lang/CloneNotSupportedException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4169	"}",
4170	result.context);
4171	}
4172	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=202470
4173	public void test0149() throws JavaModelException {
4174	this.workingCopies = new ICompilationUnit[1];
4175	this.workingCopies[0] = getWorkingCopy(
4176	"/Completion/src3/test/X.java",
4177	"package test;\n" +
4178	"public class X {\n" +
4179	" public void method0() {}\n" +
4180	" public void method0(int i) {}\n" +
4181	" public class Y {\n" +
4182	" public void method1() {}\n" +
4183	" public void method0(int i) {}\n" +
4184	" public void foo() {\n" +
4185	" zzzz\n" +
4186	" }\n" +
4187	" }\n" +
4188	"}");
4189
4190	String str = this.workingCopies[0].getSource();
4191	int tokenStart = str.lastIndexOf("zzzz");
4192	int tokenEnd = tokenStart + "zzzz".length() - 1;
4193	int cursorLocation = str.lastIndexOf("zzzz") + "zzzz".length();
4194
4195	CompletionResult result = contextComplete(this.workingCopies[0], cursorLocation, false, true);
4196
4197	String jclPath = getExternalJCLPathString();
4198	assertResults(
4199	"completion offset="+(cursorLocation)+"\n" +
4200	"completion range=["+(tokenStart)+", "+(tokenEnd)+"]\n" +
4201	"completion token=\"zzzz\"\n" +
4202	"completion token kind=TOKEN_KIND_NAME\n" +
4203	"expectedTypesSignatures=null\n" +
4204	"expectedTypesKeys=null\n" +
4205	"completion token location={STATEMENT_START}\n" +
4206	"visibleElements={\n" +
4207	" method1() {key=Ltest/X$Y;.method1()V} [in Y [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]]],\n" +
4208	" method0(int) {key=Ltest/X$Y;.method0(I)V} [in Y [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]]],\n" +
4209	" foo() {key=Ltest/X$Y;.foo()V} [in Y [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]]],\n" +
4210	" wait(long, int) {key=Ljava/lang/Object;.wait(JI)V\|Ljava/lang/IllegalMonitorStateException;\|Ljava/lang/InterruptedException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4211	" wait(long) {key=Ljava/lang/Object;.wait(J)V\|Ljava/lang/IllegalMonitorStateException;\|Ljava/lang/InterruptedException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4212	" wait() {key=Ljava/lang/Object;.wait()V\|Ljava/lang/IllegalMonitorStateException;\|Ljava/lang/InterruptedException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4213	" toString() {key=Ljava/lang/Object;.toString()Ljava/lang/String;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4214	" notifyAll() {key=Ljava/lang/Object;.notifyAll()V\|Ljava/lang/IllegalMonitorStateException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4215	" notify() {key=Ljava/lang/Object;.notify()V\|Ljava/lang/IllegalMonitorStateException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4216	" hashCode() {key=Ljava/lang/Object;.hashCode()I} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4217	" getClass() {key=Ljava/lang/Object;.getClass()Ljava/lang/Class;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4218	" finalize() {key=Ljava/lang/Object;.finalize()V\|Ljava/lang/Throwable;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4219	" equals(java.lang.Object) {key=Ljava/lang/Object;.equals(Ljava/lang/Object;)Z} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4220	" clone() {key=Ljava/lang/Object;.clone()Ljava/lang/Object;\|Ljava/lang/CloneNotSupportedException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4221	" method0() {key=Ltest/X;.method0()V} [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]],\n" +
4222	"}",
4223	result.context);
4224	}
4225	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=202470
4226	public void test0150() throws JavaModelException {
4227	this.workingCopies = new ICompilationUnit[3];
4228	this.workingCopies[0] = getWorkingCopy(
4229	"/Completion/src3/test/X.java",
4230	"package test;\n" +
4231	"public class X extends A {\n" +
4232	" public void method0() {}\n" +
4233	" public void method0(int i) {}\n" +
4234	" public class Y extends B {\n" +
4235	" public void method1() {}\n" +
4236	" public void method0(int i) {}\n" +
4237	" public void foo() {\n" +
4238	" zzzz\n" +
4239	" }\n" +
4240	" }\n" +
4241	"}");
4242
4243	this.workingCopies[1] = getWorkingCopy(
4244	"/Completion/src3/test/A.java",
4245	"package test;\n" +
4246	"public class A {\n" +
4247	" public void methodA() {}\n" +
4248	" public void method0(int i) {}\n" +
4249	"}");
4250
4251	this.workingCopies[2] = getWorkingCopy(
4252	"/Completion/src3/test/B.java",
4253	"package test;\n" +
4254	"public class B {\n" +
4255	" public void methodB() {}\n" +
4256	" public void method0(int i) {}\n" +
4257	"}");
4258
4259	String str = this.workingCopies[0].getSource();
4260	int tokenStart = str.lastIndexOf("zzzz");
4261	int tokenEnd = tokenStart + "zzzz".length() - 1;
4262	int cursorLocation = str.lastIndexOf("zzzz") + "zzzz".length();
4263
4264	CompletionResult result = contextComplete(this.workingCopies[0], cursorLocation, false, true);
4265
4266	String jclPath = getExternalJCLPathString();
4267	assertResults(
4268	"completion offset="+(cursorLocation)+"\n" +
4269	"completion range=["+(tokenStart)+", "+(tokenEnd)+"]\n" +
4270	"completion token=\"zzzz\"\n" +
4271	"completion token kind=TOKEN_KIND_NAME\n" +
4272	"expectedTypesSignatures=null\n" +
4273	"expectedTypesKeys=null\n" +
4274	"completion token location={STATEMENT_START}\n" +
4275	"visibleElements={\n" +
4276	" method1() {key=Ltest/X$Y;.method1()V} [in Y [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]]],\n" +
4277	" method0(int) {key=Ltest/X$Y;.method0(I)V} [in Y [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]]],\n" +
4278	" foo() {key=Ltest/X$Y;.foo()V} [in Y [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]]],\n" +
4279	" methodB() {key=Ltest/B;.methodB()V} [in B [in [Working copy] B.java [in test [in src3 [in Completion]]]]],\n" +
4280	" wait(long, int) {key=Ljava/lang/Object;.wait(JI)V\|Ljava/lang/IllegalMonitorStateException;\|Ljava/lang/InterruptedException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4281	" wait(long) {key=Ljava/lang/Object;.wait(J)V\|Ljava/lang/IllegalMonitorStateException;\|Ljava/lang/InterruptedException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4282	" wait() {key=Ljava/lang/Object;.wait()V\|Ljava/lang/IllegalMonitorStateException;\|Ljava/lang/InterruptedException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4283	" toString() {key=Ljava/lang/Object;.toString()Ljava/lang/String;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4284	" notifyAll() {key=Ljava/lang/Object;.notifyAll()V\|Ljava/lang/IllegalMonitorStateException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4285	" notify() {key=Ljava/lang/Object;.notify()V\|Ljava/lang/IllegalMonitorStateException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4286	" hashCode() {key=Ljava/lang/Object;.hashCode()I} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4287	" getClass() {key=Ljava/lang/Object;.getClass()Ljava/lang/Class;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4288	" finalize() {key=Ljava/lang/Object;.finalize()V\|Ljava/lang/Throwable;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4289	" equals(java.lang.Object) {key=Ljava/lang/Object;.equals(Ljava/lang/Object;)Z} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4290	" clone() {key=Ljava/lang/Object;.clone()Ljava/lang/Object;\|Ljava/lang/CloneNotSupportedException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4291	" method0() {key=Ltest/X;.method0()V} [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]],\n" +
4292	" methodA() {key=Ltest/A;.methodA()V} [in A [in [Working copy] A.java [in test [in src3 [in Completion]]]]],\n" +
4293	"}",
4294	result.context);
4295	}
4296	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=202470
4297	public void test0151() throws CoreException, IOException {
4298	this.workingCopies = new ICompilationUnit[3];
4299	this.workingCopies[0] = getWorkingCopy(
4300	"/Completion/src3/test/X.java",
4301	"package test;\n" +
4302	"public class X extends A {\n" +
4303	" public void method0() {}\n" +
4304	" public void method0(int i) {}\n" +
4305	" public class Y extends B {\n" +
4306	" public void method1() {}\n" +
4307	" public void method0(int i) {}\n" +
4308	" public void foo() {\n" +
4309	" zzzz\n" +
4310	" }\n" +
4311	" }\n" +
4312	"}");
4313
4314	this.workingCopies[1] = getWorkingCopy(
4315	"/Completion/src3/test/B.java",
4316	"package test;\n" +
4317	"public class B extends D {\n" +
4318	" public void methodB() {}\n" +
4319	" public void method0(int i) {}\n" +
4320	"}");
4321
4322	this.workingCopies[2] = getWorkingCopy(
4323	"/Completion/src3/test/D.java",
4324	"package test;\n" +
4325	"public class D {\n" +
4326	" public void methodD() {}\n" +
4327	" public void method0(int i) {}\n" +
4328	"}");
4329
4330	this.addLibrary(
4331	getJavaProject("Completion"),
4332	"test.jar",
4333	"testsrc.zip",
4334	new String[] {
4335	"/Completion/test/A.java",
4336	"package test;\n" +
4337	"public class A extends C {\n" +
4338	" public void methodA() {}\n" +
4339	" public void method0(int i) {}\n" +
4340	"}",
4341	"/Completion/test/C.java",
4342	"package test;\n" +
4343	"public class C {\n" +
4344	" public void methodC() {}\n" +
4345	" public void method0(int i) {}\n" +
4346	"}"
4347	},
4348	"1.4");
4349
4350
4351	String str = this.workingCopies[0].getSource();
4352	int tokenStart = str.lastIndexOf("zzzz");
4353	int tokenEnd = tokenStart + "zzzz".length() - 1;
4354	int cursorLocation = str.lastIndexOf("zzzz") + "zzzz".length();
4355
4356	CompletionResult result = contextComplete(this.workingCopies[0], cursorLocation, false, true);
4357
4358	String jclPath = getExternalJCLPathString();
4359	assertResults(
4360	"completion offset="+(cursorLocation)+"\n" +
4361	"completion range=["+(tokenStart)+", "+(tokenEnd)+"]\n" +
4362	"completion token=\"zzzz\"\n" +
4363	"completion token kind=TOKEN_KIND_NAME\n" +
4364	"expectedTypesSignatures=null\n" +
4365	"expectedTypesKeys=null\n" +
4366	"completion token location={STATEMENT_START}\n" +
4367	"visibleElements={\n" +
4368	" method1() {key=Ltest/X$Y;.method1()V} [in Y [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]]],\n" +
4369	" method0(int) {key=Ltest/X$Y;.method0(I)V} [in Y [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]]],\n" +
4370	" foo() {key=Ltest/X$Y;.foo()V} [in Y [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]]],\n" +
4371	" methodB() {key=Ltest/B;.methodB()V} [in B [in [Working copy] B.java [in test [in src3 [in Completion]]]]],\n" +
4372	" methodD() {key=Ltest/D;.methodD()V} [in D [in [Working copy] D.java [in test [in src3 [in Completion]]]]],\n" +
4373	" wait(long, int) {key=Ljava/lang/Object;.wait(JI)V\|Ljava/lang/IllegalMonitorStateException;\|Ljava/lang/InterruptedException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4374	" wait(long) {key=Ljava/lang/Object;.wait(J)V\|Ljava/lang/IllegalMonitorStateException;\|Ljava/lang/InterruptedException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4375	" wait() {key=Ljava/lang/Object;.wait()V\|Ljava/lang/IllegalMonitorStateException;\|Ljava/lang/InterruptedException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4376	" toString() {key=Ljava/lang/Object;.toString()Ljava/lang/String;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4377	" notifyAll() {key=Ljava/lang/Object;.notifyAll()V\|Ljava/lang/IllegalMonitorStateException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4378	" notify() {key=Ljava/lang/Object;.notify()V\|Ljava/lang/IllegalMonitorStateException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4379	" hashCode() {key=Ljava/lang/Object;.hashCode()I} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4380	" getClass() {key=Ljava/lang/Object;.getClass()Ljava/lang/Class;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4381	" finalize() {key=Ljava/lang/Object;.finalize()V\|Ljava/lang/Throwable;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4382	" equals(java.lang.Object) {key=Ljava/lang/Object;.equals(Ljava/lang/Object;)Z} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4383	" clone() {key=Ljava/lang/Object;.clone()Ljava/lang/Object;\|Ljava/lang/CloneNotSupportedException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
4384	" method0() {key=Ltest/X;.method0()V} [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]],\n" +
4385	" methodA() {key=Ltest/A;.methodA()V} [in A [in A.class [in test [in test.jar [in Completion]]]]],\n" +
4386	" methodC() {key=Ltest/C;.methodC()V} [in C [in C.class [in test [in test.jar [in Completion]]]]],\n" +
4387	"}",
4388	result.context);
4389	}
4390	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=202470
4391	public void test0152() throws JavaModelException {
4392	this.workingCopies = new ICompilationUnit[1];
4393	this.workingCopies[0] = getWorkingCopy(
4394	"/Completion/src3/test/X.java",
4395	"package test;\n" +
4396	"public class X {\n" +
4397	" public void method0() {}\n" +
4398	" public void method0(int i) {}\n" +
4399	" public class Y {\n" +
4400	" public void method1() {}\n" +
4401	" public void method0(int i) {}\n" +
4402	" public void foo() {\n" +
4403	" zzzz\n" +
4404	" }\n" +
4405	" }\n" +
4406	"}");
4407
4408	String str = this.workingCopies[0].getSource();
4409	int cursorLocation = str.lastIndexOf("zzzz") + "zzzz".length();
4410
4411	boolean unsupported = false;
4412	try {
4413	contextComplete0(this.workingCopies[0], cursorLocation, false /do not use extended context/,true /ask enclosing element/, true /ask visible elements/, null);
4414	} catch (UnsupportedOperationException e) {
4415	// this is expected because visible elements computation require heavy context
4416	unsupported = true;
4417	}
4418	assertTrue("getVisibleElements() shouldn't be supported", unsupported);
4419	}
4420	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=202470
4421	public void test0153() throws JavaModelException {
4422	this.workingCopies = new ICompilationUnit[2];
4423	this.workingCopies[0] = getWorkingCopy(
4424	"/Completion/src3/test/X.java",
4425	"package test;\n" +
4426	"public class X {\n" +
4427	" public A methodX() {return null;}\n" +
4428	" public void foo() {\n" +
4429	" zzzz\n" +
4430	" }\n" +
4431	"}");
4432
4433	this.workingCopies[1] = getWorkingCopy(
4434	"/Completion/src3/test/A.java",
4435	"package test;\n" +
4436	"public class A {\n" +
4437	"}");
4438
4439
4440	String str = this.workingCopies[0].getSource();
4441	int tokenStart = str.lastIndexOf("zzzz");
4442	int tokenEnd = tokenStart + "zzzz".length() - 1;
4443	int cursorLocation = str.lastIndexOf("zzzz") + "zzzz".length();
4444
4445	CompletionResult result = contextComplete(this.workingCopies[0], cursorLocation, false, true, "Ltest/A;");
4446
4447	assertResults(
4448	"completion offset="+(cursorLocation)+"\n" +
4449	"completion range=["+(tokenStart)+", "+(tokenEnd)+"]\n" +
4450	"completion token=\"zzzz\"\n" +
4451	"completion token kind=TOKEN_KIND_NAME\n" +
4452	"expectedTypesSignatures=null\n" +
4453	"expectedTypesKeys=null\n" +
4454	"completion token location={STATEMENT_START}\n" +
4455	"visibleElements={\n" +
4456	" methodX() {key=Ltest/X;.methodX()Ltest/A;} [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]],\n" +
4457	"}",
4458	result.context);
4459	}
4460	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=202470
4461	public void test0154() throws JavaModelException {
4462	this.workingCopies = new ICompilationUnit[3];
4463	this.workingCopies[0] = getWorkingCopy(
4464	"/Completion/src3/test/X.java",
4465	"package test;\n" +
4466	"public class X {\n" +
4467	" public A methodX() {return null;}\n" +
4468	" public void foo() {\n" +
4469	" zzzz\n" +
4470	" }\n" +
4471	"}");
4472
4473	this.workingCopies[1] = getWorkingCopy(
4474	"/Completion/src3/test/A.java",
4475	"package test;\n" +
4476	"public class A {\n" +
4477	"}");
4478
4479	this.workingCopies[2] = getWorkingCopy(
4480	"/Completion/src3/test/B.java",
4481	"package test;\n" +
4482	"public class B {\n" +
4483	"}");
4484
4485
4486	String str = this.workingCopies[0].getSource();
4487	int tokenStart = str.lastIndexOf("zzzz");
4488	int tokenEnd = tokenStart + "zzzz".length() - 1;
4489	int cursorLocation = str.lastIndexOf("zzzz") + "zzzz".length();
4490
4491	CompletionResult result = contextComplete(this.workingCopies[0], cursorLocation, false, true, "Ltest/B;");
4492
4493	assertResults(
4494	"completion offset="+(cursorLocation)+"\n" +
4495	"completion range=["+(tokenStart)+", "+(tokenEnd)+"]\n" +
4496	"completion token=\"zzzz\"\n" +
4497	"completion token kind=TOKEN_KIND_NAME\n" +
4498	"expectedTypesSignatures=null\n" +
4499	"expectedTypesKeys=null\n" +
4500	"completion token location={STATEMENT_START}\n" +
4501	"visibleElements={}",
4502	result.context);
4503	}
4504	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=202470
4505	public void test0155() throws JavaModelException {
4506	this.workingCopies = new ICompilationUnit[3];
4507	this.workingCopies[0] = getWorkingCopy(
4508	"/Completion/src3/test/X.java",
4509	"package test;\n" +
4510	"public class X {\n" +
4511	" public A methodX() {return null;}\n" +
4512	" public void foo() {\n" +
4513	" zzzz\n" +
4514	" }\n" +
4515	"}");
4516
4517	this.workingCopies[1] = getWorkingCopy(
4518	"/Completion/src3/test/A.java",
4519	"package test;\n" +
4520	"public class A extends B {\n" +
4521	"}");
4522
4523	this.workingCopies[2] = getWorkingCopy(
4524	"/Completion/src3/test/B.java",
4525	"package test;\n" +
4526	"public class B {\n" +
4527	"}");
4528
4529
4530	String str = this.workingCopies[0].getSource();
4531	int tokenStart = str.lastIndexOf("zzzz");
4532	int tokenEnd = tokenStart + "zzzz".length() - 1;
4533	int cursorLocation = str.lastIndexOf("zzzz") + "zzzz".length();
4534
4535	CompletionResult result = contextComplete(this.workingCopies[0], cursorLocation, false, true, "Ltest/B;");
4536
4537	assertResults(
4538	"completion offset="+(cursorLocation)+"\n" +
4539	"completion range=["+(tokenStart)+", "+(tokenEnd)+"]\n" +
4540	"completion token=\"zzzz\"\n" +
4541	"completion token kind=TOKEN_KIND_NAME\n" +
4542	"expectedTypesSignatures=null\n" +
4543	"expectedTypesKeys=null\n" +
4544	"completion token location={STATEMENT_START}\n" +
4545	"visibleElements={\n" +
4546	" methodX() {key=Ltest/X;.methodX()Ltest/A;} [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]],\n" +
4547	"}",
4548	result.context);
4549	}
4550	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=202470
4551	public void test0156() throws JavaModelException {
4552	this.workingCopies = new ICompilationUnit[3];
4553	this.workingCopies[0] = getWorkingCopy(
4554	"/Completion/src3/test/X.java",
4555	"package test;\n" +
4556	"public class X {\n" +
4557	" public A methodX() {return null;}\n" +
4558	" public void foo() {\n" +
4559	" zzzz\n" +
4560	" }\n" +
4561	"}");
4562
4563
4564	String str = this.workingCopies[0].getSource();
4565	int tokenStart = str.lastIndexOf("zzzz");
4566	int tokenEnd = tokenStart + "zzzz".length() - 1;
4567	int cursorLocation = str.lastIndexOf("zzzz") + "zzzz".length();
4568
4569	CompletionResult result = contextComplete(this.workingCopies[0], cursorLocation, false, true, "Ltest/Zork;");
4570
4571	assertResults(
4572	"completion offset="+(cursorLocation)+"\n" +
4573	"completion range=["+(tokenStart)+", "+(tokenEnd)+"]\n" +
4574	"completion token=\"zzzz\"\n" +
4575	"completion token kind=TOKEN_KIND_NAME\n" +
4576	"expectedTypesSignatures=null\n" +
4577	"expectedTypesKeys=null\n" +
4578	"completion token location={STATEMENT_START}\n" +
4579	"visibleElements={}",
4580	result.context);
4581	}
4582	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=202470
4583	public void test0157() throws JavaModelException {
4584	this.workingCopies = new ICompilationUnit[3];
4585	this.workingCopies[0] = getWorkingCopy(
4586	"/Completion/src3/test/X.java",
4587	"package test;\n" +
4588	"public class X {\n" +
4589	" public test.Zork methodX() {return null;}\n" +
4590	" public void foo() {\n" +
4591	" zzzz\n" +
4592	" }\n" +
4593	"}");
4594
4595
4596	String str = this.workingCopies[0].getSource();
4597	int tokenStart = str.lastIndexOf("zzzz");
4598	int tokenEnd = tokenStart + "zzzz".length() - 1;
4599	int cursorLocation = str.lastIndexOf("zzzz") + "zzzz".length();
4600
4601	CompletionResult result = contextComplete(this.workingCopies[0], cursorLocation, false, true, "Ltest/Zork;");
4602
4603	assertResults(
4604	"completion offset="+(cursorLocation)+"\n" +
4605	"completion range=["+(tokenStart)+", "+(tokenEnd)+"]\n" +
4606	"completion token=\"zzzz\"\n" +
4607	"completion token kind=TOKEN_KIND_NAME\n" +
4608	"expectedTypesSignatures=null\n" +
4609	"expectedTypesKeys=null\n" +
4610	"completion token location={STATEMENT_START}\n" +
4611	"visibleElements={\n" +
4612	" methodX() {key=Ltest/X;.methodX()Ltest/Zork;} [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]],\n" +
4613	"}",
4614	result.context);
4615	}
4616	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=202470
4617	public void test0158() throws JavaModelException {
4618	this.workingCopies = new ICompilationUnit[3];
4619	this.workingCopies[0] = getWorkingCopy(
4620	"/Completion/src3/test/X.java",
4621	"package test;\n" +
4622	"public class X {\n" +
4623	" public void foo() {\n" +
4624	" zzzz\n" +
4625	" }\n" +
4626	"}");
4627
4628
4629	String str = this.workingCopies[0].getSource();
4630	int tokenStart = str.lastIndexOf("zzzz");
4631	int tokenEnd = tokenStart + "zzzz".length() - 1;
4632	int cursorLocation = str.lastIndexOf("zzzz") + "zzzz".length();
4633
4634	CompletionResult result = contextComplete(this.workingCopies[0], cursorLocation, true, false);
4635
4636	assertResults(
4637	"completion offset="+(cursorLocation)+"\n" +
4638	"completion range=["+(tokenStart)+", "+(tokenEnd)+"]\n" +
4639	"completion token=\"zzzz\"\n" +
4640	"completion token kind=TOKEN_KIND_NAME\n" +
4641	"expectedTypesSignatures=null\n" +
4642	"expectedTypesKeys=null\n" +
4643	"completion token location={STATEMENT_START}\n" +
4644	"enclosingElement=foo() {key=Ltest/X;.foo()V} [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]]",
4645	result.context);
4646	}
4647	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=202470
4648	public void test0159() throws JavaModelException {
4649	this.workingCopies = new ICompilationUnit[3];
4650	this.workingCopies[0] = getWorkingCopy(
4651	"/Completion/src3/test/X.java",
4652	"package test;\n" +
4653	"public class X {\n" +
4654	" public void foo() {}\n" +
4655	" zzzz\n" +
4656	" public void bar() {}\n" +
4657	"}");
4658
4659
4660	String str = this.workingCopies[0].getSource();
4661	int tokenStart = str.lastIndexOf("zzzz");
4662	int tokenEnd = tokenStart + "zzzz".length() - 1;
4663	int cursorLocation = str.lastIndexOf("zzzz") + "zzzz".length();
4664
4665	CompletionResult result = contextComplete(this.workingCopies[0], cursorLocation, true, false);
4666
4667	assertResults(
4668	"completion offset="+(cursorLocation)+"\n" +
4669	"completion range=["+(tokenStart)+", "+(tokenEnd)+"]\n" +
4670	"completion token=\"zzzz\"\n" +
4671	"completion token kind=TOKEN_KIND_NAME\n" +
4672	"expectedTypesSignatures=null\n" +
4673	"expectedTypesKeys=null\n" +
4674	"completion token location={MEMBER_START}\n" +
4675	"enclosingElement=X {key=Ltest/X;} [in [Working copy] X.java [in test [in src3 [in Completion]]]]",
4676	result.context);
4677	}
4678	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=202470
4679	public void test0160() throws JavaModelException {
4680	this.workingCopies = new ICompilationUnit[3];
4681	this.workingCopies[0] = getWorkingCopy(
4682	"/Completion/src3/test/X.java",
4683	"package test;\n" +
4684	"zzzz\n" +
4685	"public class X {\n" +
4686	"}");
4687
4688
4689	String str = this.workingCopies[0].getSource();
4690	int tokenStart = str.lastIndexOf("zzzz");
4691	int tokenEnd = tokenStart + "zzzz".length() - 1;
4692	int cursorLocation = str.lastIndexOf("zzzz") + "zzzz".length();
4693
4694	CompletionResult result = contextComplete(this.workingCopies[0], cursorLocation, true, false);
4695
4696	assertResults(
4697	"completion offset="+(cursorLocation)+"\n" +
4698	"completion range=["+(tokenStart)+", "+(tokenEnd)+"]\n" +
4699	"completion token=\"zzzz\"\n" +
4700	"completion token kind=TOKEN_KIND_NAME\n" +
4701	"expectedTypesSignatures=null\n" +
4702	"expectedTypesKeys=null\n" +
4703	"completion token location=UNKNOWN\n" +
4704	"enclosingElement=[Working copy] X.java [in test [in src3 [in Completion]]]",
4705	result.context);
4706	}
4707	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=202470
4708	public void test0161() throws JavaModelException {
4709	this.workingCopies = new ICompilationUnit[3];
4710	this.workingCopies[0] = getWorkingCopy(
4711	"/Completion/src3/test/X.java",
4712	"package test;\n" +
4713	"public class X {\n" +
4714	" public void foo() {}\n" +
4715	" public class Y {\n" +
4716	" public void fooY() {}\n" +
4717	" zzzz\n" +
4718	" public void barY() {}\n" +
4719	" }\n" +
4720	" public void bar() {}\n" +
4721	"}");
4722
4723
4724	String str = this.workingCopies[0].getSource();
4725	int tokenStart = str.lastIndexOf("zzzz");
4726	int tokenEnd = tokenStart + "zzzz".length() - 1;
4727	int cursorLocation = str.lastIndexOf("zzzz") + "zzzz".length();
4728
4729	CompletionResult result = contextComplete(this.workingCopies[0], cursorLocation, true, false);
4730
4731	assertResults(
4732	"completion offset="+(cursorLocation)+"\n" +
4733	"completion range=["+(tokenStart)+", "+(tokenEnd)+"]\n" +
4734	"completion token=\"zzzz\"\n" +
4735	"completion token kind=TOKEN_KIND_NAME\n" +
4736	"expectedTypesSignatures=null\n" +
4737	"expectedTypesKeys=null\n" +
4738	"completion token location={MEMBER_START}\n" +
4739	"enclosingElement=Y {key=Ltest/X$Y;} [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]]",
4740	result.context);
4741	}
3917	}	4742	}




	return result;
}
protected CompletionResult contextComplete(ICompilationUnit cu, int cursorLocation) throws JavaModelException {
	return contextComplete0(cu, cursorLocation, false, false, false, null);
}
protected CompletionResult contextComplete(
		ICompilationUnit cu,
		int cursorLocation,
		boolean computeEnclosingElement,
		boolean computeVisibleElements) throws JavaModelException {
	return contextComplete0(cu, cursorLocation, true, computeEnclosingElement, computeVisibleElements, null);
}
protected CompletionResult contextComplete(
		ICompilationUnit cu,
		int cursorLocation,
		boolean computeEnclosingElement,
		boolean computeVisibleElements,
		String typeSignature) throws JavaModelException {
	return contextComplete0(cu, cursorLocation, true, computeEnclosingElement, computeVisibleElements, typeSignature);
}
protected CompletionResult contextComplete0(
		ICompilationUnit cu,
		int cursorLocation,
		boolean useExtendedContext,
		boolean computeEnclosingElement,
		boolean computeVisibleElements,
		String typeSignature) throws JavaModelException {
	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, false, false);
	requestor.setRequireExtendedContext(useExtendedContext);
	requestor.setComputeEnclosingElement(computeEnclosingElement);
	requestor.setComputeVisibleElements(computeVisibleElements);
	requestor.setAssignableType(typeSignature);
	
	cu.codeComplete(cursorLocation, requestor, this.wcOwner);
	
	CompletionResult result =  new CompletionResult();

Lines 16-23 Link Here

(-)src/org/eclipse/jdt/core/tests/model/CompletionTestsRequestor2.java (+49 lines)
16	import org.eclipse.jdt.core.CompletionContext;	16	import org.eclipse.jdt.core.CompletionContext;
17	import org.eclipse.jdt.core.CompletionProposal;	17	import org.eclipse.jdt.core.CompletionProposal;
18	import org.eclipse.jdt.core.CompletionRequestor;	18	import org.eclipse.jdt.core.CompletionRequestor;
		19	import org.eclipse.jdt.core.IJavaElement;
19	import org.eclipse.jdt.core.Signature;	20	import org.eclipse.jdt.core.Signature;
20	import org.eclipse.jdt.core.compiler.IProblem;	21	import org.eclipse.jdt.core.compiler.IProblem;
		22	import org.eclipse.jdt.internal.core.JavaElement;
21		23
22	public class CompletionTestsRequestor2 extends CompletionRequestor {	24	public class CompletionTestsRequestor2 extends CompletionRequestor {
23	private final char[] NULL_LITERAL = "null".toCharArray();//$NON-NLS-1$	25	private final char[] NULL_LITERAL = "null".toCharArray();//$NON-NLS-1$
Lines 35-40 Link Here
35	private boolean shortContext;	37	private boolean shortContext;
36	private boolean showMissingTypes;	38	private boolean showMissingTypes;
37		39
		40	private boolean computeVisibleElements;
		41	private boolean computeEnclosingElement;
		42	private String assignableType;
		43
38	public boolean fDebug = false;	44	public boolean fDebug = false;
39		45
40	public CompletionTestsRequestor2() {	46	public CompletionTestsRequestor2() {
Lines 181-186 Link Here
181	buffer.append('}');	187	buffer.append('}');
182	}	188	}
183	}	189	}
		190
		191	if (this.computeEnclosingElement) {
		192	buffer.append('\n');
		193	buffer.append("enclosingElement="); //$NON-NLS-1$
		194	JavaElement enclosingElement = (JavaElement)this.context.getEnclosingElement();
		195	if (enclosingElement == null) {
		196	buffer.append("null"); //$NON-NLS-1$
		197	} else {
		198	buffer.append(enclosingElement.toStringWithAncestors(true /show resolved info/));
		199	}
		200	}
		201
		202	if (this.computeVisibleElements) {
		203	buffer.append('\n');
		204
		205	IJavaElement[] visibleElements = this.context.getVisibleElements(this.assignableType);
		206	buffer.append("visibleElements="); //$NON-NLS-1$
		207	if (visibleElements == null) {
		208	buffer.append("null"); //$NON-NLS-1$
		209	} else if (visibleElements.length == 0) {
		210	buffer.append("{}"); //$NON-NLS-1$
		211	} else {
		212	buffer.append('{');
		213	buffer.append('\n');
		214	for (int i = 0; i < visibleElements.length; i++) {
		215	JavaElement element = (JavaElement) visibleElements[i];
		216	buffer.append('\t');
		217	buffer.append(element.toStringWithAncestors(true /show resolved info/));
		218	buffer.append(",\n"); //$NON-NLS-1$
		219	}
		220	buffer.append('}');
		221	}
		222	}
		223
184	//buffer.append('\n');	224	//buffer.append('\n');
185		225
186		226
Lines 522-525 Link Here
522	public String toString() {	562	public String toString() {
523	return getResults();	563	return getResults();
524	}	564	}
		565	public void setComputeVisibleElements(boolean computeVisibleElements) {
		566	this.computeVisibleElements = computeVisibleElements;
		567	}
		568	public void setAssignableType(String typeSignature) {
		569	this.assignableType = typeSignature;
		570	}
		571	public void setComputeEnclosingElement(boolean computeEnclosingElement) {
		572	this.computeEnclosingElement = computeEnclosingElement;
		573	}
525	}	574	}

Return to bug 202470

Lines 1220-1226 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/LookupEnvironment.java (-7 / +10 lines)
1220	return createArrayType(binding, dimension);	1220	return createArrayType(binding, dimension);
1221	}	1221	}
1222		1222
1223	TypeBinding getTypeFromTypeSignature(SignatureWrapper wrapper, TypeVariableBinding[] staticVariables, ReferenceBinding enclosingType, char[][][] missingTypeNames) {	1223	public TypeBinding getTypeFromTypeSignature(SignatureWrapper wrapper, TypeVariableBinding[] staticVariables, ReferenceBinding enclosingType, char[][][] missingTypeNames) {
1224	// TypeVariableSignature = 'T' Identifier ';'	1224	// TypeVariableSignature = 'T' Identifier ';'
1225	// ArrayTypeSignature = '[' TypeSignature	1225	// ArrayTypeSignature = '[' TypeSignature
1226	// ClassTypeSignature = 'L' Identifier TypeArgs(optional) ';'	1226	// ClassTypeSignature = 'L' Identifier TypeArgs(optional) ';'
Lines 1239-1250 Link Here
1239	return dimension == 0 ? (TypeBinding) staticVariables[i] : createArrayType(staticVariables[i], dimension);	1239	return dimension == 0 ? (TypeBinding) staticVariables[i] : createArrayType(staticVariables[i], dimension);
1240	ReferenceBinding initialType = enclosingType;	1240	ReferenceBinding initialType = enclosingType;
1241	do {	1241	do {
1242	if (enclosingType instanceof BinaryTypeBinding) { // per construction can only be binary type binding	1242	TypeVariableBinding[] enclosingTypeVariables;
1243	TypeVariableBinding[] enclosingVariables = ((BinaryTypeBinding)enclosingType).typeVariables; // do not trigger resolution of variables	1243	if (enclosingType instanceof BinaryTypeBinding) { // compiler normal case, no eager resolution of binary variables
1244	for (int i = enclosingVariables.length; --i >= 0;)	1244	enclosingTypeVariables = ((BinaryTypeBinding)enclosingType).typeVariables; // do not trigger resolution of variables
1245	if (CharOperation.equals(enclosingVariables[i].sourceName, wrapper.signature, varStart, varEnd))	1245	} else { // codepath only use by codeassist for decoding signatures
1246	return dimension == 0 ? (TypeBinding) enclosingVariables[i] : createArrayType(enclosingVariables[i], dimension);	1246	enclosingTypeVariables = enclosingType.typeVariables();
1247	}	1247	}
		1248	for (int i = enclosingTypeVariables.length; --i >= 0;)
		1249	if (CharOperation.equals(enclosingTypeVariables[i].sourceName, wrapper.signature, varStart, varEnd))
		1250	return dimension == 0 ? (TypeBinding) enclosingTypeVariables[i] : createArrayType(enclosingTypeVariables[i], dimension);
1248	} while ((enclosingType = enclosingType.enclosingType()) != null);	1251	} while ((enclosingType = enclosingType.enclosingType()) != null);
1249	problemReporter.undefinedTypeVariableSignature(CharOperation.subarray(wrapper.signature, varStart, varEnd), initialType);	1252	problemReporter.undefinedTypeVariableSignature(CharOperation.subarray(wrapper.signature, varStart, varEnd), initialType);
1250	return null; // cannot reach this, since previous problem will abort compilation	1253	return null; // cannot reach this, since previous problem will abort compilation

Lines 11-37 Link Here

(-)dom/org/eclipse/jdt/core/dom/TypeBinding.java (-187 / +7 lines)
11		11
12	package org.eclipse.jdt.core.dom;	12	package org.eclipse.jdt.core.dom;
13		13
14	import java.io.File;
15
16	import org.eclipse.core.resources.IContainer;
17	import org.eclipse.core.resources.IWorkspaceRoot;
18	import org.eclipse.core.resources.ResourcesPlugin;
19	import org.eclipse.core.runtime.Path;
20	import org.eclipse.jdt.core.IClassFile;
21	import org.eclipse.jdt.core.ICompilationUnit;
22	import org.eclipse.jdt.core.IJavaElement;	14	import org.eclipse.jdt.core.IJavaElement;
23	import org.eclipse.jdt.core.IJavaProject;
24	import org.eclipse.jdt.core.IMethod;
25	import org.eclipse.jdt.core.IPackageFragment;
26	import org.eclipse.jdt.core.IPackageFragmentRoot;
27	import org.eclipse.jdt.core.IType;
28	import org.eclipse.jdt.core.JavaCore;
29	import org.eclipse.jdt.core.JavaModelException;	15	import org.eclipse.jdt.core.JavaModelException;
30	import org.eclipse.jdt.core.compiler.CharOperation;	16	import org.eclipse.jdt.core.compiler.CharOperation;
31	import org.eclipse.jdt.internal.compiler.ast.Expression;	17	import org.eclipse.jdt.internal.compiler.ast.Expression;
32	import org.eclipse.jdt.internal.compiler.ast.Wildcard;	18	import org.eclipse.jdt.internal.compiler.ast.Wildcard;
33	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;	19	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
34	import org.eclipse.jdt.internal.compiler.env.IDependent;
35	import org.eclipse.jdt.internal.compiler.lookup.ArrayBinding;	20	import org.eclipse.jdt.internal.compiler.lookup.ArrayBinding;
36	import org.eclipse.jdt.internal.compiler.lookup.BaseTypeBinding;	21	import org.eclipse.jdt.internal.compiler.lookup.BaseTypeBinding;
37	import org.eclipse.jdt.internal.compiler.lookup.Binding;	22	import org.eclipse.jdt.internal.compiler.lookup.Binding;
Lines 49-57 Link Here
49	import org.eclipse.jdt.internal.compiler.lookup.TypeVariableBinding;	34	import org.eclipse.jdt.internal.compiler.lookup.TypeVariableBinding;
50	import org.eclipse.jdt.internal.compiler.lookup.WildcardBinding;	35	import org.eclipse.jdt.internal.compiler.lookup.WildcardBinding;
51	import org.eclipse.jdt.internal.compiler.problem.AbortCompilation;	36	import org.eclipse.jdt.internal.compiler.problem.AbortCompilation;
52	import org.eclipse.jdt.internal.compiler.util.SuffixConstants;
53	import org.eclipse.jdt.internal.compiler.util.Util;
54	import org.eclipse.jdt.internal.core.ClassFile;
55	import org.eclipse.jdt.internal.core.CompilationUnit;	37	import org.eclipse.jdt.internal.core.CompilationUnit;
56	import org.eclipse.jdt.internal.core.JavaElement;	38	import org.eclipse.jdt.internal.core.JavaElement;
57	import org.eclipse.jdt.internal.core.PackageFragment;	39	import org.eclipse.jdt.internal.core.PackageFragment;
Lines 184-229 Link Here
184	}	166	}
185		167
186	/*	168	/*
187	* Returns the class file for the given file name, or null if not found.
188	* @see org.eclipse.jdt.internal.compiler.env.IDependent#getFileName()
189	*/
190	private IClassFile getClassFile(char[] fileName) {
191	int jarSeparator = CharOperation.indexOf(IDependent.JAR_FILE_ENTRY_SEPARATOR, fileName);
192	int pkgEnd = CharOperation.lastIndexOf('/', fileName); // pkgEnd is exclusive
193	if (pkgEnd == -1)
194	pkgEnd = CharOperation.lastIndexOf(File.separatorChar, fileName);
195	if (jarSeparator != -1 && pkgEnd < jarSeparator) // if in a jar and no slash, it is a default package -> pkgEnd should be equal to jarSeparator
196	pkgEnd = jarSeparator;
197	if (pkgEnd == -1)
198	return null;
199	IPackageFragment pkg = getPackageFragment(fileName, pkgEnd, jarSeparator);
200	if (pkg == null) return null;
201	int start;
202	return pkg.getClassFile(new String(fileName, start = pkgEnd + 1, fileName.length - start));
203	}
204
205	/*
206	* Returns the compilation unit for the given file name, or null if not found.
207	* @see org.eclipse.jdt.internal.compiler.env.IDependent#getFileName()
208	*/
209	private ICompilationUnit getCompilationUnit(char[] fileName) {
210	char[] slashSeparatedFileName = CharOperation.replaceOnCopy(fileName, File.separatorChar, '/');
211	int pkgEnd = CharOperation.lastIndexOf('/', slashSeparatedFileName); // pkgEnd is exclusive
212	if (pkgEnd == -1)
213	return null;
214	IPackageFragment pkg = getPackageFragment(slashSeparatedFileName, pkgEnd, -1/no jar separator for .java files/);
215	if (pkg == null) return null;
216	int start;
217	ICompilationUnit cu = pkg.getCompilationUnit(new String(slashSeparatedFileName, start = pkgEnd+1, slashSeparatedFileName.length - start));
218	if (this.resolver instanceof DefaultBindingResolver) {
219	ICompilationUnit workingCopy = cu.findWorkingCopy(((DefaultBindingResolver) this.resolver).workingCopyOwner);
220	if (workingCopy != null)
221	return workingCopy;
222	}
223	return cu;
224	}
225
226	/*
227	* @see ITypeBinding#getComponentType()	169	* @see ITypeBinding#getComponentType()
228	*/	170	*/
229	public ITypeBinding getComponentType() {	171	public ITypeBinding getComponentType() {
Lines 545-643 Link Here
545	return getUnresolvedJavaElement(this.binding);	487	return getUnresolvedJavaElement(this.binding);
546	}	488	}
547	private JavaElement getUnresolvedJavaElement(org.eclipse.jdt.internal.compiler.lookup.TypeBinding typeBinding ) {	489	private JavaElement getUnresolvedJavaElement(org.eclipse.jdt.internal.compiler.lookup.TypeBinding typeBinding ) {
548	if (typeBinding == null)	490	if (this.resolver instanceof DefaultBindingResolver) {
549	return null;	491	DefaultBindingResolver defaultBindingResolver = (DefaultBindingResolver) this.resolver;
550	switch (typeBinding.kind()) {	492	return org.eclipse.jdt.internal.core.util.Util.getUnresolvedJavaElement(
551	case Binding.ARRAY_TYPE :	493	typeBinding,
552	typeBinding = ((ArrayBinding) typeBinding).leafComponentType();	494	defaultBindingResolver.workingCopyOwner,
553	return getUnresolvedJavaElement(typeBinding);	495	defaultBindingResolver.getBindingsToNodesMap());
554	case Binding.BASE_TYPE :
555	case Binding.WILDCARD_TYPE :
556	case Binding.INTERSECTION_TYPE:
557	return null;
558	default :
559	if (typeBinding.isCapture())
560	return null;
561	}
562	ReferenceBinding referenceBinding;
563	if (typeBinding.isParameterizedType() \|\| typeBinding.isRawType())
564	referenceBinding = (ReferenceBinding) typeBinding.erasure();
565	else
566	referenceBinding = (ReferenceBinding) typeBinding;
567	char[] fileName = referenceBinding.getFileName();
568	if (referenceBinding.isLocalType() \|\| referenceBinding.isAnonymousType()) {
569	// local or anonymous type
570	if (Util.isClassFileName(fileName)) {
571	int jarSeparator = CharOperation.indexOf(IDependent.JAR_FILE_ENTRY_SEPARATOR, fileName);
572	int pkgEnd = CharOperation.lastIndexOf('/', fileName); // pkgEnd is exclusive
573	if (pkgEnd == -1)
574	pkgEnd = CharOperation.lastIndexOf(File.separatorChar, fileName);
575	if (jarSeparator != -1 && pkgEnd < jarSeparator) // if in a jar and no slash, it is a default package -> pkgEnd should be equal to jarSeparator
576	pkgEnd = jarSeparator;
577	if (pkgEnd == -1)
578	return null;
579	IPackageFragment pkg = getPackageFragment(fileName, pkgEnd, jarSeparator);
580	char[] constantPoolName = referenceBinding.constantPoolName();
581	if (constantPoolName == null) {
582	ClassFile classFile = (ClassFile) getClassFile(fileName);
583	return classFile == null ? null : (JavaElement) classFile.getType();
584	}
585	pkgEnd = CharOperation.lastIndexOf('/', constantPoolName);
586	char[] classFileName = CharOperation.subarray(constantPoolName, pkgEnd+1, constantPoolName.length);
587	ClassFile classFile = (ClassFile) pkg.getClassFile(new String(classFileName) + SuffixConstants.SUFFIX_STRING_class);
588	return (JavaElement) classFile.getType();
589	}
590	ICompilationUnit cu = getCompilationUnit(fileName);
591	if (cu == null) return null;
592	// must use getElementAt(...) as there is no back pointer to the defining method (scope is null after resolution has ended)
593	try {
594	int sourceStart = ((LocalTypeBinding) referenceBinding).sourceStart;
595	return (JavaElement) cu.getElementAt(sourceStart);
596	} catch (JavaModelException e) {
597	// does not exist
598	return null;
599	}
600	} else if (referenceBinding.isTypeVariable()) {
601	// type parameter
602	final String typeVariableName = new String(referenceBinding.sourceName());
603	Binding declaringElement = ((TypeVariableBinding) referenceBinding).declaringElement;
604	IBinding declaringTypeBinding = null;
605	if (declaringElement instanceof MethodBinding) {
606	declaringTypeBinding = this.resolver.getMethodBinding((MethodBinding) declaringElement);
607	IMethod declaringMethod = (IMethod) declaringTypeBinding.getJavaElement();
608	return (JavaElement) declaringMethod.getTypeParameter(typeVariableName);
609	} else {
610	ITypeBinding typeBinding2 = this.resolver.getTypeBinding((org.eclipse.jdt.internal.compiler.lookup.TypeBinding) declaringElement);
611	if (typeBinding2 == null) return null;
612	declaringTypeBinding = typeBinding2;
613	IType declaringType = (IType) declaringTypeBinding.getJavaElement();
614	return (JavaElement) declaringType.getTypeParameter(typeVariableName);
615	}
616	} else {	496	} else {
617	if (fileName == null) return null; // case of a WilCardBinding that doesn't have a corresponding Java element	497	return org.eclipse.jdt.internal.core.util.Util.getUnresolvedJavaElement(typeBinding, null, null);
618	// member or top level type
619	ITypeBinding declaringTypeBinding = null;
620	if (this.isArray()) {
621	declaringTypeBinding = this.getElementType().getDeclaringClass();
622	} else {
623	declaringTypeBinding = this.getDeclaringClass();
624	}
625	if (declaringTypeBinding == null) {
626	// top level type
627	if (Util.isClassFileName(fileName)) {
628	ClassFile classFile = (ClassFile) getClassFile(fileName);
629	if (classFile == null) return null;
630	return (JavaElement) classFile.getType();
631	}
632	ICompilationUnit cu = getCompilationUnit(fileName);
633	if (cu == null) return null;
634	return (JavaElement) cu.getType(new String(referenceBinding.sourceName()));
635	} else {
636	// member type
637	IType declaringType = (IType) declaringTypeBinding.getJavaElement();
638	if (declaringType == null) return null;
639	return (JavaElement) declaringType.getType(new String(referenceBinding.sourceName()));
640	}
641	}	498	}
642	}	499	}
643		500
Lines 781-823 Link Here
781	return this.resolver.getPackageBinding(referenceBinding.getPackage());	638	return this.resolver.getPackageBinding(referenceBinding.getPackage());
782	}	639	}
783		640
784	/*
785	* Returns the package that includes the given file name, or null if not found.
786	* pkgEnd == jarSeparator if default package in a jar
787	* pkgEnd > jarSeparator if non default package in a jar
788	* pkgEnd > 0 if package not in a jar
789	*
790	* @see org.eclipse.jdt.internal.compiler.env.IDependent#getFileName()
791	*/
792	private IPackageFragment getPackageFragment(char[] fileName, int pkgEnd, int jarSeparator) {
793	if (jarSeparator != -1) {
794	String jarMemento = new String(fileName, 0, jarSeparator);
795	IPackageFragmentRoot root = (IPackageFragmentRoot) JavaCore.create(jarMemento);
796	if (pkgEnd == jarSeparator)
797	return root.getPackageFragment(IPackageFragment.DEFAULT_PACKAGE_NAME);
798	char[] pkgName = CharOperation.subarray(fileName, jarSeparator+1, pkgEnd);
799	CharOperation.replace(pkgName, '/', '.');
800	return root.getPackageFragment(new String(pkgName));
801	} else {
802	Path path = new Path(new String(fileName, 0, pkgEnd));
803	IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();
804	IContainer folder = path.segmentCount() == 1 ? workspaceRoot.getProject(path.lastSegment()) : (IContainer) workspaceRoot.getFolder(path);
805	IJavaElement element = JavaCore.create(folder);
806	if (element == null) return null;
807	switch (element.getElementType()) {
808	case IJavaElement.PACKAGE_FRAGMENT:
809	return (IPackageFragment) element;
810	case IJavaElement.PACKAGE_FRAGMENT_ROOT:
811	return ((IPackageFragmentRoot) element).getPackageFragment(IPackageFragment.DEFAULT_PACKAGE_NAME);
812	case IJavaElement.JAVA_PROJECT:
813	IPackageFragmentRoot root = ((IJavaProject) element).getPackageFragmentRoot(folder);
814	if (root == null) return null;
815	return root.getPackageFragment(IPackageFragment.DEFAULT_PACKAGE_NAME);
816	}
817	return null;
818	}
819	}
820
821	/**	641	/**
822	* @see org.eclipse.jdt.core.dom.ITypeBinding#getQualifiedName()	642	* @see org.eclipse.jdt.core.dom.ITypeBinding#getQualifiedName()
823	*/	643	*/

Lines 11-25 Link Here

(-)dom/org/eclipse/jdt/core/dom/MethodBinding.java (-70 / +6 lines)
11		11
12	package org.eclipse.jdt.core.dom;	12	package org.eclipse.jdt.core.dom;
13		13
14	import java.util.ArrayList;
15	import java.util.Iterator;
16
17	import org.eclipse.jdt.core.IJavaElement;	14	import org.eclipse.jdt.core.IJavaElement;
18	import org.eclipse.jdt.core.IMethod;
19	import org.eclipse.jdt.core.IType;
20	import org.eclipse.jdt.core.JavaModelException;
21	import org.eclipse.jdt.core.Signature;
22	import org.eclipse.jdt.core.compiler.CharOperation;
23	import org.eclipse.jdt.internal.compiler.lookup.ExtraCompilerModifiers;	15	import org.eclipse.jdt.internal.compiler.lookup.ExtraCompilerModifiers;
24	import org.eclipse.jdt.internal.compiler.lookup.LookupEnvironment;	16	import org.eclipse.jdt.internal.compiler.lookup.LookupEnvironment;
25	import org.eclipse.jdt.internal.compiler.lookup.ParameterizedGenericMethodBinding;	17	import org.eclipse.jdt.internal.compiler.lookup.ParameterizedGenericMethodBinding;
Lines 29-35 Link Here
29	import org.eclipse.jdt.internal.compiler.lookup.TypeVariableBinding;	21	import org.eclipse.jdt.internal.compiler.lookup.TypeVariableBinding;
30	import org.eclipse.jdt.internal.compiler.problem.AbortCompilation;	22	import org.eclipse.jdt.internal.compiler.problem.AbortCompilation;
31	import org.eclipse.jdt.internal.core.JavaElement;	23	import org.eclipse.jdt.internal.core.JavaElement;
32	import org.eclipse.jdt.internal.core.Member;
33	import org.eclipse.jdt.internal.core.util.Util;	24	import org.eclipse.jdt.internal.core.util.Util;
34		25
35	/**	26	/**
Lines 252-319 Link Here
252	}	243	}
253		244
254	private JavaElement getUnresolvedJavaElement() {	245	private JavaElement getUnresolvedJavaElement() {
255	IType declaringType = (IType) getDeclaringClass().getJavaElement();
256	if (declaringType == null) return null;
257	if (!(this.resolver instanceof DefaultBindingResolver)) return null;	246	if (!(this.resolver instanceof DefaultBindingResolver)) return null;
258	ASTNode node = (ASTNode) ((DefaultBindingResolver) this.resolver).bindingsToAstNodes.get(this);	247
259	if (node != null && declaringType.getParent().getElementType() != IJavaElement.CLASS_FILE) {	248	DefaultBindingResolver defaultBindingResolver = (DefaultBindingResolver) this.resolver;
260	if (node instanceof MethodDeclaration) {	249	return Util.getUnresolvedJavaElement(
261	MethodDeclaration methodDeclaration = (MethodDeclaration) node;	250	this.binding,
262	ArrayList parameterSignatures = new ArrayList();	251	defaultBindingResolver.workingCopyOwner,
263	Iterator iterator = methodDeclaration.parameters().iterator();	252	defaultBindingResolver.getBindingsToNodesMap());
264	while (iterator.hasNext()) {
265	SingleVariableDeclaration parameter = (SingleVariableDeclaration) iterator.next();
266	Type type = parameter.getType();
267	String typeSig = Util.getSignature(type);
268	int arrayDim = parameter.getExtraDimensions();
269	if (parameter.getAST().apiLevel() >= AST.JLS3 && parameter.isVarargs()) {
270	arrayDim++;
271	}
272	if (arrayDim > 0) {
273	typeSig = Signature.createArraySignature(typeSig, arrayDim);
274	}
275	parameterSignatures.add(typeSig);
276	}
277	int parameterCount = parameterSignatures.size();
278	String[] parameters = new String[parameterCount];
279	parameterSignatures.toArray(parameters);
280	return (JavaElement) declaringType.getMethod(getName(), parameters);
281	} else {
282	// annotation type member declaration
283	AnnotationTypeMemberDeclaration typeMemberDeclaration = (AnnotationTypeMemberDeclaration) node;
284	return (JavaElement) declaringType.getMethod(typeMemberDeclaration.getName().getIdentifier(), CharOperation.NO_STRINGS); // annotation type members don't have parameters
285	}
286	} else {
287	// case of method not in the created AST, or a binary method
288	org.eclipse.jdt.internal.compiler.lookup.MethodBinding original = this.binding.original();
289	String selector = original.isConstructor() ? declaringType.getElementName() : new String(original.selector);
290	boolean isBinary = declaringType.isBinary();
291	ReferenceBinding enclosingType = original.declaringClass.enclosingType();
292	boolean isInnerBinaryTypeConstructor = isBinary && original.isConstructor() && enclosingType != null;
293	TypeBinding[] parameters = original.parameters;
294	int length = parameters == null ? 0 : parameters.length;
295	int declaringIndex = isInnerBinaryTypeConstructor ? 1 : 0;
296	String[] parameterSignatures = new String[declaringIndex + length];
297	if (isInnerBinaryTypeConstructor)
298	parameterSignatures[0] = new String(enclosingType.genericTypeSignature()).replace('/', '.');
299	for (int i = 0; i < length; i++) {
300	parameterSignatures[declaringIndex + i] = new String(parameters[i].genericTypeSignature()).replace('/', '.');
301	}
302	IMethod result = declaringType.getMethod(selector, parameterSignatures);
303	if (isBinary)
304	return (JavaElement) result;
305	IMethod[] methods = null;
306	try {
307	methods = declaringType.getMethods();
308	} catch (JavaModelException e) {
309	// declaring type doesn't exist
310	return null;
311	}
312	IMethod[] candidates = Member.findMethods(result, methods);
313	if (candidates == null \|\| candidates.length == 0)
314	return null;
315	return (JavaElement) candidates[0];
316	}
317	}	253	}
318		254
319	/**	255	/**

Lines 12-18 Link Here

(-)dom/org/eclipse/jdt/core/dom/VariableBinding.java (-7 / +10 lines)
12	package org.eclipse.jdt.core.dom;	12	package org.eclipse.jdt.core.dom;
13		13
14	import org.eclipse.jdt.core.IJavaElement;	14	import org.eclipse.jdt.core.IJavaElement;
15	import org.eclipse.jdt.core.IType;
16	import org.eclipse.jdt.core.util.IModifierConstants;	15	import org.eclipse.jdt.core.util.IModifierConstants;
17	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;	16	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
18	import org.eclipse.jdt.internal.compiler.impl.Constant;	17	import org.eclipse.jdt.internal.compiler.impl.Constant;
Lines 22-27 Link Here
22	import org.eclipse.jdt.internal.compiler.lookup.TypeIds;	21	import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
23	import org.eclipse.jdt.internal.core.JavaElement;	22	import org.eclipse.jdt.internal.core.JavaElement;
24	import org.eclipse.jdt.internal.core.LocalVariable;	23	import org.eclipse.jdt.internal.core.LocalVariable;
		24	import org.eclipse.jdt.internal.core.util.Util;
25		25
26	/**	26	/**
27	* Internal implementation of variable bindings.	27	* Internal implementation of variable bindings.
Lines 201-212 Link Here
201		201
202	private JavaElement getUnresolvedJavaElement() {	202	private JavaElement getUnresolvedJavaElement() {
203	if (isField()) {	203	if (isField()) {
204	// field	204	if (this.resolver instanceof DefaultBindingResolver) {
205	FieldBinding fieldBinding = (FieldBinding) this.binding;	205	DefaultBindingResolver defaultBindingResolver = (DefaultBindingResolver) this.resolver;
206	if (fieldBinding.declaringClass == null) return null; // arraylength	206	return Util.getUnresolvedJavaElement(
207	IType declaringType = (IType) getDeclaringClass().getJavaElement();	207	(FieldBinding) this.binding,
208	if (declaringType == null) return null;	208	defaultBindingResolver.workingCopyOwner,
209	return (JavaElement) declaringType.getField(getName());	209	defaultBindingResolver.getBindingsToNodesMap());
		210	} else {
		211	return Util.getUnresolvedJavaElement((FieldBinding) this.binding, null, null);
		212	}
210	}	213	}
211	// local variable	214	// local variable
212	IMethodBinding declaringMethod = getDeclaringMethod();	215	IMethodBinding declaringMethod = getDeclaringMethod();

Lines 61-66 Link Here

(-)dom/org/eclipse/jdt/core/dom/DefaultBindingResolver.java (+10 lines)
61	import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;	61	import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
62	import org.eclipse.jdt.internal.compiler.lookup.TypeIds;	62	import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
63	import org.eclipse.jdt.internal.compiler.problem.AbortCompilation;	63	import org.eclipse.jdt.internal.compiler.problem.AbortCompilation;
		64	import org.eclipse.jdt.internal.core.util.Util;
64		65
65	/**	66	/**
66	* Internal class for resolving bindings using old ASTs.	67	* Internal class for resolving bindings using old ASTs.
Lines 208-213 Link Here
208	}	209	}
209	return null;	210	return null;
210	}	211	}
		212
		213	Util.BindingsToNodesMap getBindingsToNodesMap() {
		214	return new Util.BindingsToNodesMap() {
		215	public org.eclipse.jdt.internal.compiler.ast.ASTNode get(Binding binding) {
		216	return (org.eclipse.jdt.internal.compiler.ast.ASTNode)
		217	DefaultBindingResolver.this.newAstToOldAst.get(DefaultBindingResolver.this.bindingsToAstNodes.get(binding));
		218	}
		219	};
		220	}
211		221
212	synchronized org.eclipse.jdt.internal.compiler.ast.ASTNode getCorrespondingNode(ASTNode currentNode) {	222	synchronized org.eclipse.jdt.internal.compiler.ast.ASTNode getCorrespondingNode(ASTNode currentNode) {
213	return (org.eclipse.jdt.internal.compiler.ast.ASTNode) this.newAstToOldAst.get(currentNode);	223	return (org.eclipse.jdt.internal.compiler.ast.ASTNode) this.newAstToOldAst.get(currentNode);

Lines 126-132 Link Here

(-)model/org/eclipse/jdt/internal/core/CompilationUnitStructureRequestor.java (-21 / +52 lines)
126		126
127	ICompilationUnit parentCU= (ICompilationUnit)parentHandle;	127	ICompilationUnit parentCU= (ICompilationUnit)parentHandle;
128	//create the import container and its info	128	//create the import container and its info
129	ImportContainer importContainer= (ImportContainer)parentCU.getImportContainer();	129	ImportContainer importContainer= createImportContainer(parentCU);
130	if (this.importContainerInfo == null) {	130	if (this.importContainerInfo == null) {
131	this.importContainerInfo = new JavaElementInfo();	131	this.importContainerInfo = new JavaElementInfo();
132	JavaElementInfo parentInfo = (JavaElementInfo) this.infoStack.peek();	132	JavaElementInfo parentInfo = (JavaElementInfo) this.infoStack.peek();
Lines 135-141 Link Here
135	}	135	}
136		136
137	String elementName = JavaModelManager.getJavaModelManager().intern(new String(CharOperation.concatWith(tokens, '.')));	137	String elementName = JavaModelManager.getJavaModelManager().intern(new String(CharOperation.concatWith(tokens, '.')));
138	ImportDeclaration handle = new ImportDeclaration(importContainer, elementName, onDemand);	138	ImportDeclaration handle = createImportDeclaration(importContainer, elementName, onDemand);
139	resolveDuplicates(handle);	139	resolveDuplicates(handle);
140		140
141	ImportDeclarationElementInfo info = new ImportDeclarationElementInfo();	141	ImportDeclarationElementInfo info = new ImportDeclarationElementInfo();
Lines 167-173 Link Here
167		167
168	if (parentHandle.getElementType() == IJavaElement.COMPILATION_UNIT) {	168	if (parentHandle.getElementType() == IJavaElement.COMPILATION_UNIT) {
169	char[] name = CharOperation.concatWith(importReference.getImportName(), '.');	169	char[] name = CharOperation.concatWith(importReference.getImportName(), '.');
170	handle = new PackageDeclaration((CompilationUnit) parentHandle, new String(name));	170	handle = createPackageDeclaration(parentHandle, new String(name));
171	}	171	}
172	else {	172	else {
173	Assert.isTrue(false); // Should not happen	173	Assert.isTrue(false); // Should not happen
Lines 200-210 Link Here
200	this.children.put(parentInfo, childrenList = new ArrayList());	200	this.children.put(parentInfo, childrenList = new ArrayList());
201	childrenList.add(handle);	201	childrenList.add(handle);
202	}	202	}
		203	protected Annotation createAnnotation(JavaElement parent, String name) {
		204	return new Annotation(parent, name);
		205	}
		206	protected SourceField createField(JavaElement parent, FieldInfo fieldInfo) {
		207	String fieldName = JavaModelManager.getJavaModelManager().intern(new String(fieldInfo.name));
		208	return new SourceField(parent, fieldName);
		209	}
		210	protected ImportContainer createImportContainer(ICompilationUnit parent) {
		211	return (ImportContainer)parent.getImportContainer();
		212	}
		213	protected ImportDeclaration createImportDeclaration(ImportContainer parent, String name, boolean onDemand) {
		214	return new ImportDeclaration(parent, name, onDemand);
		215	}
		216	protected Initializer createInitializer(JavaElement parent) {
		217	return new Initializer(parent, 1);
		218	}
		219	protected SourceMethod createMethod(JavaElement parent, MethodInfo methodInfo) {
		220	String selector = JavaModelManager.getJavaModelManager().intern(new String(methodInfo.name));
		221	String[] parameterTypeSigs = convertTypeNamesToSigs(methodInfo.parameterTypes);
		222	return new SourceMethod(parent, selector, parameterTypeSigs);
		223	}
		224	protected PackageDeclaration createPackageDeclaration(JavaElement parent, String name) {
		225	return new PackageDeclaration((CompilationUnit) parent, name);
		226	}
		227	protected SourceType createType(JavaElement parent, TypeInfo typeInfo) {
		228	String nameString= new String(typeInfo.name);
		229	return new SourceType(parent, nameString);
		230	}
		231	protected TypeParameter createTypeParameter(JavaElement parent, String name) {
		232	return new TypeParameter(parent, name);
		233	}
203	/**	234	/**
204	* Convert these type names to signatures.	235	* Convert these type names to signatures.
205	* @see Signature	236	* @see Signature
206	*/	237	*/
207	/* default */ static String[] convertTypeNamesToSigs(char[][] typeNames) {	238	protected static String[] convertTypeNamesToSigs(char[][] typeNames) {
208	if (typeNames == null)	239	if (typeNames == null)
209	return CharOperation.NO_STRINGS;	240	return CharOperation.NO_STRINGS;
210	int n = typeNames.length;	241	int n = typeNames.length;
Lines 219-225 Link Here
219	}	250	}
220	protected IAnnotation enterAnnotation(org.eclipse.jdt.internal.compiler.ast.Annotation annotation, AnnotatableInfo parentInfo, JavaElement parentHandle) {	251	protected IAnnotation enterAnnotation(org.eclipse.jdt.internal.compiler.ast.Annotation annotation, AnnotatableInfo parentInfo, JavaElement parentHandle) {
221	String nameString = new String(CharOperation.concatWith(annotation.type.getTypeName(), '.'));	252	String nameString = new String(CharOperation.concatWith(annotation.type.getTypeName(), '.'));
222	Annotation handle = new Annotation(parentHandle, nameString); //NB: occurenceCount is computed in resolveDuplicates	253	Annotation handle = createAnnotation(parentHandle, nameString); //NB: occurenceCount is computed in resolveDuplicates
223	resolveDuplicates(handle);	254	resolveDuplicates(handle);
224		255
225	AnnotationInfo info = new AnnotationInfo();	256	AnnotationInfo info = new AnnotationInfo();
Lines 237-247 Link Here
237	if (membersLength == 0) {	268	if (membersLength == 0) {
238	info.members = Annotation.NO_MEMBER_VALUE_PAIRS;	269	info.members = Annotation.NO_MEMBER_VALUE_PAIRS;
239	} else {	270	} else {
240	IMemberValuePair[] members = new IMemberValuePair[membersLength];	271	info.members = getMemberValuePairs(memberValuePairs);
241	for (int j = 0; j < membersLength; j++) {
242	members[j] = getMemberValuePair(memberValuePairs[j]);
243	}
244	info.members = members;
245	}	272	}
246		273
247	if (parentInfo != null) {	274	if (parentInfo != null) {
Lines 278-285 Link Here
278	JavaElement parentHandle= (JavaElement) this.handleStack.peek();	305	JavaElement parentHandle= (JavaElement) this.handleStack.peek();
279	SourceField handle = null;	306	SourceField handle = null;
280	if (parentHandle.getElementType() == IJavaElement.TYPE) {	307	if (parentHandle.getElementType() == IJavaElement.TYPE) {
281	String fieldName = JavaModelManager.getJavaModelManager().intern(new String(fieldInfo.name));	308	handle = createField(parentHandle, fieldInfo);
282	handle = new SourceField(parentHandle, fieldName);
283	}	309	}
284	else {	310	else {
285	Assert.isTrue(false); // Should not happen	311	Assert.isTrue(false); // Should not happen
Lines 322-328 Link Here
322	Initializer handle = null;	348	Initializer handle = null;
323		349
324	if (parentHandle.getElementType() == IJavaElement.TYPE) {	350	if (parentHandle.getElementType() == IJavaElement.TYPE) {
325	handle = new Initializer(parentHandle, 1);	351	handle = createInitializer(parentHandle);
326	}	352	}
327	else {	353	else {
328	Assert.isTrue(false); // Should not happen	354	Assert.isTrue(false); // Should not happen
Lines 359-368 Link Here
359	methodInfo.exceptionTypes= CharOperation.NO_CHAR_CHAR;	385	methodInfo.exceptionTypes= CharOperation.NO_CHAR_CHAR;
360	}	386	}
361		387
362	String[] parameterTypeSigs = convertTypeNamesToSigs(methodInfo.parameterTypes);
363	if (parentHandle.getElementType() == IJavaElement.TYPE) {	388	if (parentHandle.getElementType() == IJavaElement.TYPE) {
364	String selector = JavaModelManager.getJavaModelManager().intern(new String(methodInfo.name));	389	handle = createMethod(parentHandle, methodInfo);
365	handle = new SourceMethod(parentHandle, selector, parameterTypeSigs);
366	}	390	}
367	else {	391	else {
368	Assert.isTrue(false); // Should not happen	392	Assert.isTrue(false); // Should not happen
Lines 422-429 Link Here
422		446
423	JavaElementInfo parentInfo = (JavaElementInfo) this.infoStack.peek();	447	JavaElementInfo parentInfo = (JavaElementInfo) this.infoStack.peek();
424	JavaElement parentHandle= (JavaElement) this.handleStack.peek();	448	JavaElement parentHandle= (JavaElement) this.handleStack.peek();
425	String nameString= new String(typeInfo.name);	449	SourceType handle = this.createType(parentHandle, typeInfo); //NB: occurenceCount is computed in resolveDuplicates
426	SourceType handle = new SourceType(parentHandle, nameString); //NB: occurenceCount is computed in resolveDuplicates
427	resolveDuplicates(handle);	450	resolveDuplicates(handle);
428		451
429	SourceTypeElementInfo info =	452	SourceTypeElementInfo info =
Lines 475-481 Link Here
475	JavaElementInfo parentInfo = (JavaElementInfo) this.infoStack.peek();	498	JavaElementInfo parentInfo = (JavaElementInfo) this.infoStack.peek();
476	JavaElement parentHandle = (JavaElement) this.handleStack.peek();	499	JavaElement parentHandle = (JavaElement) this.handleStack.peek();
477	String nameString = new String(typeParameterInfo.name);	500	String nameString = new String(typeParameterInfo.name);
478	TypeParameter handle = new TypeParameter(parentHandle, nameString); //NB: occurenceCount is computed in resolveDuplicates	501	TypeParameter handle = createTypeParameter(parentHandle, nameString); //NB: occurenceCount is computed in resolveDuplicates
479	resolveDuplicates(handle);	502	resolveDuplicates(handle);
480		503
481	TypeParameterElementInfo info = new TypeParameterElementInfo();	504	TypeParameterElementInfo info = new TypeParameterElementInfo();
Lines 601-616 Link Here
601	handle.occurrenceCount++;	624	handle.occurrenceCount++;
602	}	625	}
603	}	626	}
604	private IMemberValuePair getMemberValuePair(MemberValuePair memberValuePair) {	627	protected IMemberValuePair getMemberValuePair(MemberValuePair memberValuePair) {
605	String memberName = new String(memberValuePair.name);	628	String memberName = new String(memberValuePair.name);
606	org.eclipse.jdt.internal.core.MemberValuePair result = new org.eclipse.jdt.internal.core.MemberValuePair(memberName);	629	org.eclipse.jdt.internal.core.MemberValuePair result = new org.eclipse.jdt.internal.core.MemberValuePair(memberName);
607	result.value = getMemberValue(result, memberValuePair.value);	630	result.value = getMemberValue(result, memberValuePair.value);
608	return result;	631	return result;
609	}	632	}
		633	protected IMemberValuePair[] getMemberValuePairs(MemberValuePair[] memberValuePairs) {
		634	int membersLength = memberValuePairs.length;
		635	IMemberValuePair[] members = new IMemberValuePair[membersLength];
		636	for (int j = 0; j < membersLength; j++) {
		637	members[j] = getMemberValuePair(memberValuePairs[j]);
		638	}
		639	return members;
		640	}
610	/*	641	/*
611	* Creates the value from the given expression, and sets the valueKind on the given memberValuePair	642	* Creates the value from the given expression, and sets the valueKind on the given memberValuePair
612	*/	643	*/
613	private Object getMemberValue(org.eclipse.jdt.internal.core.MemberValuePair memberValuePair, Expression expression) {	644	protected Object getMemberValue(org.eclipse.jdt.internal.core.MemberValuePair memberValuePair, Expression expression) {
614	if (expression instanceof NullLiteral) {	645	if (expression instanceof NullLiteral) {
615	return null;	646	return null;
616	} else if (expression instanceof Literal) {	647	} else if (expression instanceof Literal) {

Lines 39-54 Link Here

(-)model/org/eclipse/jdt/internal/core/util/Util.java (-2 / +253 lines)
39	import org.eclipse.jdt.core.util.IFieldInfo;	39	import org.eclipse.jdt.core.util.IFieldInfo;
40	import org.eclipse.jdt.core.util.IMethodInfo;	40	import org.eclipse.jdt.core.util.IMethodInfo;
41	import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;	41	import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
		42	import org.eclipse.jdt.internal.compiler.ast.AnnotationMethodDeclaration;
42	import org.eclipse.jdt.internal.compiler.ast.Argument;	43	import org.eclipse.jdt.internal.compiler.ast.Argument;
		44	import org.eclipse.jdt.internal.compiler.ast.MethodDeclaration;
43	import org.eclipse.jdt.internal.compiler.ast.TypeReference;	45	import org.eclipse.jdt.internal.compiler.ast.TypeReference;
44	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader;	46	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader;
45	import org.eclipse.jdt.internal.compiler.classfmt.ClassFormatException;	47	import org.eclipse.jdt.internal.compiler.classfmt.ClassFormatException;
		48	import org.eclipse.jdt.internal.compiler.env.IDependent;
46	import org.eclipse.jdt.internal.compiler.impl.Constant;	49	import org.eclipse.jdt.internal.compiler.impl.Constant;
		50	import org.eclipse.jdt.internal.compiler.lookup.Binding;
		51	import org.eclipse.jdt.internal.compiler.lookup.FieldBinding;
		52	import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
		53	import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
		54	import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
47	import org.eclipse.jdt.internal.compiler.lookup.TypeIds;	55	import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
48	import org.eclipse.jdt.internal.compiler.parser.ScannerHelper;	56	import org.eclipse.jdt.internal.compiler.parser.ScannerHelper;
49	import org.eclipse.jdt.internal.compiler.util.SuffixConstants;	57	import org.eclipse.jdt.internal.compiler.util.SuffixConstants;
		58	import org.eclipse.jdt.internal.core.ClassFile;
50	import org.eclipse.jdt.internal.core.JavaElement;	59	import org.eclipse.jdt.internal.core.JavaElement;
51	import org.eclipse.jdt.internal.core.JavaModelManager;	60	import org.eclipse.jdt.internal.core.JavaModelManager;
		61	import org.eclipse.jdt.internal.core.Member;
52	import org.eclipse.jdt.internal.core.MemberValuePair;	62	import org.eclipse.jdt.internal.core.MemberValuePair;
53	import org.eclipse.jdt.internal.core.PackageFragment;	63	import org.eclipse.jdt.internal.core.PackageFragment;
54	import org.eclipse.jdt.internal.core.PackageFragmentRoot;	64	import org.eclipse.jdt.internal.core.PackageFragmentRoot;
Lines 76-81 Link Here
76	*/	86	*/
77	int compare(Object a, Object b);	87	int compare(Object a, Object b);
78	}	88	}
		89
		90	public static interface BindingsToNodesMap {
		91	public org.eclipse.jdt.internal.compiler.ast.ASTNode get(Binding binding);
		92	}
		93
79	private static final String ARGUMENTS_DELIMITER = "#"; //$NON-NLS-1$	94	private static final String ARGUMENTS_DELIMITER = "#"; //$NON-NLS-1$
80		95
81	private static final String EMPTY_ARGUMENT = " "; //$NON-NLS-1$	96	private static final String EMPTY_ARGUMENT = " "; //$NON-NLS-1$
Lines 747-752 Link Here
747	return null;	762	return null;
748	}	763	}
749		764
		765	private static IClassFile getClassFile(char[] fileName) {
		766	int jarSeparator = CharOperation.indexOf(IDependent.JAR_FILE_ENTRY_SEPARATOR, fileName);
		767	int pkgEnd = CharOperation.lastIndexOf('/', fileName); // pkgEnd is exclusive
		768	if (pkgEnd == -1)
		769	pkgEnd = CharOperation.lastIndexOf(File.separatorChar, fileName);
		770	if (jarSeparator != -1 && pkgEnd < jarSeparator) // if in a jar and no slash, it is a default package -> pkgEnd should be equal to jarSeparator
		771	pkgEnd = jarSeparator;
		772	if (pkgEnd == -1)
		773	return null;
		774	IPackageFragment pkg = getPackageFragment(fileName, pkgEnd, jarSeparator);
		775	if (pkg == null) return null;
		776	int start;
		777	return pkg.getClassFile(new String(fileName, start = pkgEnd + 1, fileName.length - start));
		778	}
		779
		780	private static ICompilationUnit getCompilationUnit(char[] fileName, WorkingCopyOwner workingCopyOwner) {
		781	char[] slashSeparatedFileName = CharOperation.replaceOnCopy(fileName, File.separatorChar, '/');
		782	int pkgEnd = CharOperation.lastIndexOf('/', slashSeparatedFileName); // pkgEnd is exclusive
		783	if (pkgEnd == -1)
		784	return null;
		785	IPackageFragment pkg = getPackageFragment(slashSeparatedFileName, pkgEnd, -1/no jar separator for .java files/);
		786	if (pkg == null) return null;
		787	int start;
		788	ICompilationUnit cu = pkg.getCompilationUnit(new String(slashSeparatedFileName, start = pkgEnd+1, slashSeparatedFileName.length - start));
		789	if (workingCopyOwner != null) {
		790	ICompilationUnit workingCopy = cu.findWorkingCopy(workingCopyOwner);
		791	if (workingCopy != null)
		792	return workingCopy;
		793	}
		794	return cu;
		795	}
		796
750	/**	797	/**
751	* Returns the registered Java like extensions.	798	* Returns the registered Java like extensions.
752	*/	799	*/
Lines 910-916 Link Here
910	}	957	}
911	return lineSeparator;	958	return lineSeparator;
912	}	959	}
913		960
		961	private static IPackageFragment getPackageFragment(char[] fileName, int pkgEnd, int jarSeparator) {
		962	if (jarSeparator != -1) {
		963	String jarMemento = new String(fileName, 0, jarSeparator);
		964	IPackageFragmentRoot root = (IPackageFragmentRoot) JavaCore.create(jarMemento);
		965	if (pkgEnd == jarSeparator)
		966	return root.getPackageFragment(IPackageFragment.DEFAULT_PACKAGE_NAME);
		967	char[] pkgName = CharOperation.subarray(fileName, jarSeparator+1, pkgEnd);
		968	CharOperation.replace(pkgName, '/', '.');
		969	return root.getPackageFragment(new String(pkgName));
		970	} else {
		971	Path path = new Path(new String(fileName, 0, pkgEnd));
		972	IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();
		973	IContainer folder = path.segmentCount() == 1 ? workspaceRoot.getProject(path.lastSegment()) : (IContainer) workspaceRoot.getFolder(path);
		974	IJavaElement element = JavaCore.create(folder);
		975	if (element == null) return null;
		976	switch (element.getElementType()) {
		977	case IJavaElement.PACKAGE_FRAGMENT:
		978	return (IPackageFragment) element;
		979	case IJavaElement.PACKAGE_FRAGMENT_ROOT:
		980	return ((IPackageFragmentRoot) element).getPackageFragment(IPackageFragment.DEFAULT_PACKAGE_NAME);
		981	case IJavaElement.JAVA_PROJECT:
		982	IPackageFragmentRoot root = ((IJavaProject) element).getPackageFragmentRoot(folder);
		983	if (root == null) return null;
		984	return root.getPackageFragment(IPackageFragment.DEFAULT_PACKAGE_NAME);
		985	}
		986	return null;
		987	}
		988	}
		989
914	/**	990	/**
915	* Returns the number of parameter types in a method signature.	991	* Returns the number of parameter types in a method signature.
916	*/	992	*/
Lines 1204-1210 Link Here
1204	return result;	1280	return result;
1205	}	1281	}
1206		1282
1207	/*	1283	/**
		1284	* Return the java element corresponding to the given compiler binding.
		1285	*/
		1286	public static JavaElement getUnresolvedJavaElement(FieldBinding binding, WorkingCopyOwner workingCopyOwner, BindingsToNodesMap bindingsToNodes) {
		1287	if (binding.declaringClass == null) return null; // arraylength
		1288	IType declaringType = (IType) getUnresolvedJavaElement(binding.declaringClass, workingCopyOwner, bindingsToNodes);
		1289	if (declaringType == null) return null;
		1290	return (JavaElement) declaringType.getField(String.valueOf(binding.name));
		1291	}
		1292
		1293	/**
		1294	* Return the java element corresponding to the given compiler binding.
		1295	*/
		1296	public static JavaElement getUnresolvedJavaElement(MethodBinding methodBinding, WorkingCopyOwner workingCopyOwner, BindingsToNodesMap bindingsToNodes) {
		1297	IType declaringType = (IType) getUnresolvedJavaElement(methodBinding.declaringClass, workingCopyOwner, bindingsToNodes);
		1298
		1299	if (declaringType == null) return null;
		1300
		1301	org.eclipse.jdt.internal.compiler.ast.ASTNode node = bindingsToNodes == null ? null : bindingsToNodes.get(methodBinding);
		1302	if (node != null && !declaringType.isBinary()) {
		1303	if (node instanceof AnnotationMethodDeclaration) {
		1304	// node is an AnnotationMethodDeclaration
		1305	AnnotationMethodDeclaration typeMemberDeclaration = (AnnotationMethodDeclaration) node;
		1306	return (JavaElement) declaringType.getMethod(String.valueOf(typeMemberDeclaration.selector), CharOperation.NO_STRINGS); // annotation type members don't have parameters
		1307	} else {
		1308	// node is an MethodDeclaration
		1309	MethodDeclaration methodDeclaration = (MethodDeclaration) node;
		1310
		1311	Argument[] arguments = methodDeclaration.arguments;
		1312	String[] parameterSignatures;
		1313	if (arguments != null) {
		1314	parameterSignatures = new String[arguments.length];
		1315	for (int i = 0; i < arguments.length; i++) {
		1316	Argument argument = arguments[i];
		1317	TypeReference typeReference = argument.type;
		1318	int arrayDim = typeReference.dimensions();
		1319
		1320	String typeSig =
		1321	Signature.createTypeSignature(
		1322	CharOperation.concatWith(
		1323	typeReference.getTypeName(), '.'), false);
		1324	if (arrayDim > 0) {
		1325	typeSig = Signature.createArraySignature(typeSig, arrayDim);
		1326	}
		1327	parameterSignatures[i] = typeSig;
		1328
		1329	}
		1330	} else {
		1331	parameterSignatures = new String[0];
		1332	}
		1333	return (JavaElement) declaringType.getMethod(String.valueOf(methodDeclaration.selector), parameterSignatures);
		1334	}
		1335	} else {
		1336	// case of method not in the created AST, or a binary method
		1337	org.eclipse.jdt.internal.compiler.lookup.MethodBinding original = methodBinding.original();
		1338	String selector = original.isConstructor() ? declaringType.getElementName() : new String(original.selector);
		1339	boolean isBinary = declaringType.isBinary();
		1340	ReferenceBinding enclosingType = original.declaringClass.enclosingType();
		1341	boolean isInnerBinaryTypeConstructor = isBinary && original.isConstructor() && enclosingType != null;
		1342	TypeBinding[] parameters = original.parameters;
		1343	int length = parameters == null ? 0 : parameters.length;
		1344	int declaringIndex = isInnerBinaryTypeConstructor ? 1 : 0;
		1345	String[] parameterSignatures = new String[declaringIndex + length];
		1346	if (isInnerBinaryTypeConstructor)
		1347	parameterSignatures[0] = new String(enclosingType.genericTypeSignature()).replace('/', '.');
1348	for (int i = 0; i < length; i++) {
1349	parameterSignatures[declaringIndex + i] = new String(parameters[i].genericTypeSignature()).replace('/', '.');
1350	}
1351	IMethod result = declaringType.getMethod(selector, parameterSignatures);
1352	if (isBinary)
1353	return (JavaElement) result;
1354	IMethod[] methods = null;
1355	try {
1356	methods = declaringType.getMethods();
1357	} catch (JavaModelException e) {
1358	// declaring type doesn't exist
1359	return null;
1360	}
1361	IMethod[] candidates = Member.findMethods(result, methods);
1362	if (candidates == null \|\| candidates.length == 0)
1363	return null;
1364	return (JavaElement) candidates[0];
1365	}
1366	}
1367
1368	/**
1369	* Return the java element corresponding to the given compiler binding.
1370	*/
1371	public static JavaElement getUnresolvedJavaElement(TypeBinding typeBinding, WorkingCopyOwner workingCopyOwner, BindingsToNodesMap bindingsToNodes) {
1372	if (typeBinding == null)
1373	return null;
1374	switch (typeBinding.kind()) {
1375	case Binding.ARRAY_TYPE :
1376	typeBinding = ((org.eclipse.jdt.internal.compiler.lookup.ArrayBinding) typeBinding).leafComponentType();
1377	return getUnresolvedJavaElement(typeBinding, workingCopyOwner, bindingsToNodes);
1378	case Binding.BASE_TYPE :
1379	case Binding.WILDCARD_TYPE :
1380	case Binding.INTERSECTION_TYPE:
1381	return null;
1382	default :
1383	if (typeBinding.isCapture())
1384	return null;
1385	}
1386	ReferenceBinding referenceBinding;
1387	if (typeBinding.isParameterizedType() \|\| typeBinding.isRawType())
1388	referenceBinding = (ReferenceBinding) typeBinding.erasure();
1389	else
1390	referenceBinding = (ReferenceBinding) typeBinding;
1391	char[] fileName = referenceBinding.getFileName();
1392	if (referenceBinding.isLocalType() \|\| referenceBinding.isAnonymousType()) {
1393	// local or anonymous type
1394	if (org.eclipse.jdt.internal.compiler.util.Util.isClassFileName(fileName)) {
1395	int jarSeparator = CharOperation.indexOf(IDependent.JAR_FILE_ENTRY_SEPARATOR, fileName);
1396	int pkgEnd = CharOperation.lastIndexOf('/', fileName); // pkgEnd is exclusive
1397	if (pkgEnd == -1)
1398	pkgEnd = CharOperation.lastIndexOf(File.separatorChar, fileName);
1399	if (jarSeparator != -1 && pkgEnd < jarSeparator) // if in a jar and no slash, it is a default package -> pkgEnd should be equal to jarSeparator
1400	pkgEnd = jarSeparator;
1401	if (pkgEnd == -1)
1402	return null;
1403	IPackageFragment pkg = getPackageFragment(fileName, pkgEnd, jarSeparator);
1404	char[] constantPoolName = referenceBinding.constantPoolName();
1405	if (constantPoolName == null) {
1406	ClassFile classFile = (ClassFile) getClassFile(fileName);
1407	return classFile == null ? null : (JavaElement) classFile.getType();
1408	}
1409	pkgEnd = CharOperation.lastIndexOf('/', constantPoolName);
1410	char[] classFileName = CharOperation.subarray(constantPoolName, pkgEnd+1, constantPoolName.length);
1411	ClassFile classFile = (ClassFile) pkg.getClassFile(new String(classFileName) + SuffixConstants.SUFFIX_STRING_class);
1412	return (JavaElement) classFile.getType();
1413	}
1414	ICompilationUnit cu = getCompilationUnit(fileName, workingCopyOwner);
1415	if (cu == null) return null;
1416	// must use getElementAt(...) as there is no back pointer to the defining method (scope is null after resolution has ended)
1417	try {
1418	int sourceStart = ((org.eclipse.jdt.internal.compiler.lookup.LocalTypeBinding) referenceBinding).sourceStart;
1419	return (JavaElement) cu.getElementAt(sourceStart);
1420	} catch (JavaModelException e) {
1421	// does not exist
1422	return null;
1423	}
1424	} else if (referenceBinding.isTypeVariable()) {
1425	// type parameter
1426	final String typeVariableName = new String(referenceBinding.sourceName());
1427	org.eclipse.jdt.internal.compiler.lookup.Binding declaringElement = ((org.eclipse.jdt.internal.compiler.lookup.TypeVariableBinding) referenceBinding).declaringElement;
1428	if (declaringElement instanceof MethodBinding) {
1429	IMethod declaringMethod = (IMethod) getUnresolvedJavaElement((MethodBinding) declaringElement, workingCopyOwner, bindingsToNodes);
1430	return (JavaElement) declaringMethod.getTypeParameter(typeVariableName);
1431	} else {
1432	IType declaringType = (IType) getUnresolvedJavaElement((TypeBinding) declaringElement, workingCopyOwner, bindingsToNodes);
1433	return (JavaElement) declaringType.getTypeParameter(typeVariableName);
1434	}
1435	} else {
1436	if (fileName == null) return null; // case of a WilCardBinding that doesn't have a corresponding Java element
1437	// member or top level type
1438	TypeBinding declaringTypeBinding = typeBinding.enclosingType();
1439	if (declaringTypeBinding == null) {
1440	// top level type
1441	if (org.eclipse.jdt.internal.compiler.util.Util.isClassFileName(fileName)) {
1442	ClassFile classFile = (ClassFile) getClassFile(fileName);
1443	if (classFile == null) return null;
1444	return (JavaElement) classFile.getType();
1445	}
1446	ICompilationUnit cu = getCompilationUnit(fileName, workingCopyOwner);
1447	if (cu == null) return null;
1448	return (JavaElement) cu.getType(new String(referenceBinding.sourceName()));
1449	} else {
1450	// member type
1451	IType declaringType = (IType) getUnresolvedJavaElement(declaringTypeBinding, workingCopyOwner, bindingsToNodes);
1452	if (declaringType == null) return null;
1453	return (JavaElement) declaringType.getType(new String(referenceBinding.sourceName()));
1454	}
1455	}
1456	}
1457
1458	/*
1208	* Returns the index of the most specific argument paths which is strictly enclosing the path to check	1459	* Returns the index of the most specific argument paths which is strictly enclosing the path to check
1209	*/	1460	*/
1210	public static int indexOfEnclosingPath(IPath checkedPath, IPath[] paths, int pathCount) {	1461	public static int indexOfEnclosingPath(IPath checkedPath, IPath[] paths, int pathCount) {

Lines 11-19 Link Here

(-)model/org/eclipse/jdt/internal/compiler/ISourceElementRequestor.java (+6 lines)
11	package org.eclipse.jdt.internal.compiler;	11	package org.eclipse.jdt.internal.compiler;
12		12
13	import org.eclipse.jdt.core.compiler.CategorizedProblem;	13	import org.eclipse.jdt.core.compiler.CategorizedProblem;
		14	import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
14	import org.eclipse.jdt.internal.compiler.ast.Annotation;	15	import org.eclipse.jdt.internal.compiler.ast.Annotation;
15	import org.eclipse.jdt.internal.compiler.ast.Expression;	16	import org.eclipse.jdt.internal.compiler.ast.Expression;
		17	import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;
16	import org.eclipse.jdt.internal.compiler.ast.ImportReference;	18	import org.eclipse.jdt.internal.compiler.ast.ImportReference;
		19	import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
17		20
18	/*	21	/*
19	* Part of the source element parser responsible for building the output. It	22	* Part of the source element parser responsible for building the output. It
Lines 54-59 Link Here
54	public boolean secondary;	57	public boolean secondary;
55	public boolean anonymousMember;	58	public boolean anonymousMember;
56	public Annotation[] annotations;	59	public Annotation[] annotations;
		60	public TypeDeclaration node;
57	}	61	}
58		62
59	public static class TypeParameterInfo {	63	public static class TypeParameterInfo {
Lines 80-85 Link Here
80	public TypeParameterInfo[] typeParameters;	84	public TypeParameterInfo[] typeParameters;
81	public char[][] categories;	85	public char[][] categories;
82	public Annotation[] annotations;	86	public Annotation[] annotations;
		87	public AbstractMethodDeclaration node;
83	}	88	}
84		89
85	public static class FieldInfo {	90	public static class FieldInfo {
Lines 91-96 Link Here
91	public int nameSourceEnd;	96	public int nameSourceEnd;
92	public char[][] categories;	97	public char[][] categories;
93	public Annotation[] annotations;	98	public Annotation[] annotations;
		99	public FieldDeclaration node;
94	}	100	}
95		101
96	void acceptAnnotationTypeReference(char[][] annotation, int sourceStart, int sourceEnd);	102	void acceptAnnotationTypeReference(char[][] annotation, int sourceStart, int sourceEnd);

Lines 27-32 Link Here

(-)model/org/eclipse/jdt/core/CompletionContext.java (-24 / +110 lines)
27	public final class CompletionContext extends InternalCompletionContext {	27	public final class CompletionContext extends InternalCompletionContext {
28		28
29	/**	29	/**
		30	* The completed token is the first token of a member declaration.<br>
		31	* e.g.
		32	* <pre>
		33	* public class X {
		34	* Foo\| // completion occurs at \|
		35	* }
		36	* </pre>
		37	*
		38	* @see #getTokenLocation()
		39	*
		40	* @since 3.4
		41	*/
		42	public static final int TL_MEMBER_START = 1;
		43
		44	/**
		45	* The completed token is the first token of a statement.<br>
		46	* e.g.
		47	* <pre>
		48	* public class X {
		49	* public void bar() {
		50	* Foo\| // completion occurs at \|
		51	* }
		52	* }
		53	* </pre>
		54	*
		55	* @see #getTokenLocation()
		56	*
		57	* @since 3.4
		58	*/
		59	public static final int TL_STATEMENT_START = 2;
		60
		61	/**
30	* The completion token is unknown.	62	* The completion token is unknown.
31	* @since 3.2	63	* @since 3.2
32	*/	64	*/
Lines 83-88 Link Here
83	public boolean isInJavadocFormalReference() {	115	public boolean isInJavadocFormalReference() {
84	return (this.javadoc & CompletionOnJavadoc.FORMAL_REFERENCE) != 0;	116	return (this.javadoc & CompletionOnJavadoc.FORMAL_REFERENCE) != 0;
85	}	117	}
		118
		119	/**
		120	* Returns whether this completion context is an extended context.
		121	* Some methods of this context can be used only if this context is an extended context but an extended context consumes more memory.
		122	*
		123	* @return <code>true</code> if this completion context is an extended context.
		124	*
		125	* @since 3.4
		126	*/
		127	public boolean isExtended() {
		128	return this.extendedContext != null;
		129	}
86		130
87	/**	131	/**
88	* Return signatures of expected types of a potential completion proposal at the completion position.	132	* Return signatures of expected types of a potential completion proposal at the completion position.
Lines 210-247 Link Here
210	return this.offset;	254	return this.offset;
211	}	255	}
212		256
213
214	/**	257	/**
215	* The completed token is the first token of a member declaration.<br>	258	* Returns the innermost enclosing Java element which contains the completion location or <code>null</code> if this element cannot be computed.
216	* e.g.	259	* The returned Java element and all Java elements in the same compilation unit which can be navigated to from the returned Java element are special Java elements:
217	* <pre>	260	* <ul>
218	* public class X {	261	* <li>they are based on the current content of the compilation unit's buffer, they are not the result of a reconcile operation</li>
219	* Foo\| // completion occurs at \|	262	* <li>they are not updated if the buffer changes.</li>
220	* }	263	* <li>they do not contain local types which are not visible from the completion location.</li>
221	* </pre>	264	* <li>they do not give information about categories. {@link IMember#getCategories()} will return an empty array</li>
		265	* </ul>
222	*	266	*
223	* @see #getTokenLocation()	267	* Reasons for returning <code>null</code> include:
		268	* <ul>
		269	* <li>the compilation unit no longer exists</li>
		270	* <li>the completion occurred in a binary type. However this restriction might be relaxed in the future.</li>
		271	* </ul>
		272	*
		273	* @return the innermost enclosing Java element which contains the completion location or <code>null</code> if this element cannot be computed.
		274	*
		275	* @exception UnsupportedOperationException if the context is not an extended context
224	*	276	*
225	* @since 3.4	277	* @since 3.4
226	*/	278	*/
227	public static final int TL_MEMBER_START = 1;	279	public IJavaElement getEnclosingElement() {
		280	if (!this.isExtended()) throw new UnsupportedOperationException("Operation only supported in extended context"); //$NON-NLS-1$
		281
		282	if (this.extendedContext == null) return null;
		283
		284	return this.extendedContext.getEnclosingElement();
		285	}
228		286
229	/**	287	/**
230	* The completed token is the first token of a statement.<br>	288	* Return the elements which are visible from the completion location and which can be assigned to the given type.
231	* e.g.	289	* An element is assignable if its type can be assigned to a variable
232	* <pre>	290	* of the given type, as specified in section 5.2 of <em>The Java Language
233	* public class X {	291	* Specification, Third Edition</em> (JLS3).
234	* public void bar() {	292	* A visible element is either:
235	* Foo\| // completion occurs at \|	293	* <ul>
236	* }	294	* <li>a {@link ILocalVariable} - the element type is {@link ILocalVariable#getTypeSignature()}</li>
237	* }	295	* <li>a {@link IField} - the element type is {@link IField#getTypeSignature()}</li>
238	* </pre>	296	* <li>a {@link IMethod} - the element type is {@link IMethod#getReturnType()}</li>
		297	* </ul>
239	*	298	*
240	* @see #getTokenLocation()	299	* Returned elements defined in the completed compilation unit are special Java elements:
		300	* <ul>
		301	* <li>they are based on the current content of the compilation unit's buffer, they are not the result of a reconcile operation</li>
		302	* <li>they are not updated if the buffer changes.</li>
		303	* <li>they do not contain local types which are not visible from the completion location.</li>
		304	* <li>they do not give information about categories. {@link IMember#getCategories()} will return an empty array</li>
		305	* </ul>
		306	*
		307	* Note the array can be empty if:
		308	* <ul>
		309	* <li>the compilation unit no longer exists</li>
		310	* <li>the completion occurred in a binary type. However this restriction might be relaxed in the future.</li>
		311	* </ul>
		312	*
		313	* @param typeSignature elements which can be assigned to this type are returned.
		314	* If <code>null</code> there is no constraint on the type of the returned elements.
		315	*
		316	* @return elements which are visible from the completion location and which can be assigned to the given type.
		317	*
		318	* @exception UnsupportedOperationException if the context is not an extended context
		319	*
		320	* @see #isExtended()
241	*	321	*
242	* @since 3.4	322	* @since 3.4
243	*/	323	*/
244	public static final int TL_STATEMENT_START = 2;	324	public IJavaElement[] getVisibleElements(String typeSignature) {
		325	if (!this.isExtended()) throw new UnsupportedOperationException("Operation only supported in extended context"); //$NON-NLS-1$
		326
		327	if (this.extendedContext == null) return new IJavaElement[0];
		328
		329	return this.extendedContext.getVisibleElements(typeSignature);
		330	}
245		331
246	public String toString() {	332	public String toString() {
247	StringBuffer buffer = new StringBuffer();	333	StringBuffer buffer = new StringBuffer();
Lines 296-304 Link Here
296	buffer.append('\n');	382	buffer.append('\n');
297		383
298	if (tokenLocation == 0) {	384	if (tokenLocation == 0) {
299	buffer.append("locationType=UNKNOWN"); //$NON-NLS-1$	385	buffer.append("tokenLocation=UNKNOWN"); //$NON-NLS-1$
300	} else {	386	} else {
301	buffer.append("locationType={"); //$NON-NLS-1$	387	buffer.append("tokenLocation={"); //$NON-NLS-1$
302	boolean first = true;	388	boolean first = true;
303	if ((tokenLocation & CompletionContext.TL_MEMBER_START) != 0) {	389	if ((tokenLocation & CompletionContext.TL_MEMBER_START) != 0) {
304	if (!first) buffer.append(',');	390	if (!first) buffer.append(',');
Lines 313-319 Link Here
313	buffer.append('}');	399	buffer.append('}');
314	}	400	}
315	buffer.append('\n');	401	buffer.append('\n');
316		402
317	return buffer.toString();	403	return buffer.toString();
318	}	404	}
319	}	405	}

Lines 15-20 Link Here

(-)eval/org/eclipse/jdt/internal/eval/EvaluationContext.java (-3 / +7 lines)
15		15
16	import org.eclipse.jdt.core.CompletionRequestor;	16	import org.eclipse.jdt.core.CompletionRequestor;
17	import org.eclipse.jdt.core.IJavaProject;	17	import org.eclipse.jdt.core.IJavaProject;
		18	import org.eclipse.jdt.core.WorkingCopyOwner;
18	import org.eclipse.jdt.core.compiler.*;	19	import org.eclipse.jdt.core.compiler.*;
19	import org.eclipse.jdt.internal.codeassist.CompletionEngine;	20	import org.eclipse.jdt.internal.codeassist.CompletionEngine;
20	import org.eclipse.jdt.internal.codeassist.ISelectionRequestor;	21	import org.eclipse.jdt.internal.codeassist.ISelectionRequestor;
Lines 100-107 Link Here
100	*	101	*
101	* @param options	102	* @param options
102	* set of options used to configure the code assist engine.	103	* set of options used to configure the code assist engine.
		104	*
		105	* @param owner
		106	* the owner of working copies that take precedence over their original compilation units
103	*/	107	*/
104	public void complete(char[] codeSnippet, int completionPosition, SearchableEnvironment environment, CompletionRequestor requestor, Map options, IJavaProject project) {	108	public void complete(char[] codeSnippet, int completionPosition, SearchableEnvironment environment, CompletionRequestor requestor, Map options, final IJavaProject project, WorkingCopyOwner owner) {
105	try {	109	try {
106	IRequestor variableRequestor = new IRequestor() {	110	IRequestor variableRequestor = new IRequestor() {
107	public boolean acceptClassFiles(ClassFile[] classFiles, char[] codeSnippetClassName) {	111	public boolean acceptClassFiles(ClassFile[] classFiles, char[] codeSnippetClassName) {
Lines 144-150 Link Here
144	}	148	}
145	};	149	};
146		150
147	CompletionEngine engine = new CompletionEngine(environment, mapper.getCompletionRequestor(requestor), options, project);	151	CompletionEngine engine = new CompletionEngine(environment, mapper.getCompletionRequestor(requestor), options, project, owner);
148		152
149	if (this.installedVars != null) {	153	if (this.installedVars != null) {
150	IBinaryType binaryType = this.getRootCodeSnippetBinary();	154	IBinaryType binaryType = this.getRootCodeSnippetBinary();
Lines 165-171 Link Here
165	}	169	}
166	}	170	}
167		171
168	engine.complete(sourceUnit, mapper.startPosOffset + completionPosition, mapper.startPosOffset);	172	engine.complete(sourceUnit, mapper.startPosOffset + completionPosition, mapper.startPosOffset, null);
169	}	173	}
170	/**	174	/**
171	* Deletes the given variable from this evaluation context. This will take effect in the target VM only	175	* Deletes the given variable from this evaluation context. This will take effect in the target VM only

Added Link Here

(-)codeassist/org/eclipse/jdt/internal/codeassist/impl/AssistAnnotation.java (+30 lines)
1	/*******************************************************************************
2	* Copyright (c) 2008 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.codeassist.impl;
12
13	import java.util.Map;
14
15	import org.eclipse.core.runtime.IProgressMonitor;
16	import org.eclipse.jdt.core.JavaModelException;
17	import org.eclipse.jdt.internal.core.Annotation;
18	import org.eclipse.jdt.internal.core.JavaElement;
19
20	public class AssistAnnotation extends Annotation {
21	private Map infoCache;
22	public AssistAnnotation(JavaElement parent, String name, Map infoCache) {
23	super(parent, name);
24	this.infoCache = infoCache;
25	}
26
27	public Object getElementInfo(IProgressMonitor monitor) throws JavaModelException {
28	return infoCache.get(this);
29	}
30	}

Lines 778-781 Link Here

(-)src/org/eclipse/jdt/core/tests/model/CompletionContextTests_1_5.java (+352 lines)
778	"completion token location=UNKNOWN",	778	"completion token location=UNKNOWN",
779	result.context);	779	result.context);
780	}	780	}
		781	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=202470
		782	public void test0028() throws JavaModelException {
		783	this.workingCopies = new ICompilationUnit[2];
		784	this.workingCopies[0] = getWorkingCopy(
		785	"/Completion/src3/test/X.java",
		786	"package test;\n" +
		787	"public class X<TX> extends A<String> {\n" +
		788	" public void methodX(TX x) {}\n" +
		789	" public void foo() {\n" +
		790	" zzzz\n" +
		791	" }\n" +
		792	"}");
		793
		794	this.workingCopies[1] = getWorkingCopy(
		795	"/Completion/src3/test/A.java",
		796	"package test;\n" +
		797	"public class A<TA> {\n" +
		798	" public void methodA(TA a) {}\n" +
		799	"}");
		800
		801	String str = this.workingCopies[0].getSource();
		802	int tokenStart = str.lastIndexOf("zzzz");
		803	int tokenEnd = tokenStart + "zzzz".length() - 1;
		804	int cursorLocation = str.lastIndexOf("zzzz") + "zzzz".length();
		805
		806	CompletionResult result = contextComplete(this.workingCopies[0], cursorLocation, false, true);
		807
		808	String jclPath = getExternalJCLPathString("1.5");
		809	assertResults(
		810	"completion offset="+(cursorLocation)+"\n" +
		811	"completion range=["+(tokenStart)+", "+(tokenEnd)+"]\n" +
		812	"completion token=\"zzzz\"\n" +
		813	"completion token kind=TOKEN_KIND_NAME\n" +
		814	"expectedTypesSignatures=null\n" +
		815	"expectedTypesKeys=null\n" +
		816	"completion token location={STATEMENT_START}\n" +
		817	"visibleElements={\n" +
		818	" methodX(TX) {key=Ltest/X;.methodX(TTX;)V} [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]],\n" +
		819	" foo() {key=Ltest/X;.foo()V} [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]],\n" +
		820	" methodA(TA) {key=Ltest/A<Ljava/lang/String;>;.methodA(Ljava/lang/String;)V} [in A [in [Working copy] A.java [in test [in src3 [in Completion]]]]],\n" +
		821	" wait(long, int) {key=Ljava/lang/Object;.wait(JI)V\|Ljava/lang/IllegalMonitorStateException;\|Ljava/lang/InterruptedException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
		822	" wait(long) {key=Ljava/lang/Object;.wait(J)V\|Ljava/lang/IllegalMonitorStateException;\|Ljava/lang/InterruptedException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
		823	" wait() {key=Ljava/lang/Object;.wait()V\|Ljava/lang/IllegalMonitorStateException;\|Ljava/lang/InterruptedException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
		824	" toString() {key=Ljava/lang/Object;.toString()Ljava/lang/String;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
		825	" notifyAll() {key=Ljava/lang/Object;.notifyAll()V\|Ljava/lang/IllegalMonitorStateException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
		826	" notify() {key=Ljava/lang/Object;.notify()V\|Ljava/lang/IllegalMonitorStateException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
		827	" hashCode() {key=Ljava/lang/Object;.hashCode()I} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
		828	" getClass() {key=Ljava/lang/Object;.getClass()Ljava/lang/Class<+Ljava/lang/Object;>;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
		829	" finalize() {key=Ljava/lang/Object;.finalize()V\|Ljava/lang/Throwable;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
		830	" equals(java.lang.Object) {key=Ljava/lang/Object;.equals(Ljava/lang/Object;)Z} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
		831	" clone() {key=Ljava/lang/Object;.clone()Ljava/lang/Object;\|Ljava/lang/CloneNotSupportedException;} [in Object [in Object.class [in java.lang [in "+jclPath+"]]]],\n" +
		832	"}",
		833	result.context);
		834	}
		835	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=202470
		836	public void test0029() throws JavaModelException {
		837	this.workingCopies = new ICompilationUnit[2];
		838	this.workingCopies[0] = getWorkingCopy(
		839	"/Completion/src3/test/X.java",
		840	"package test;\n" +
		841	"public class X {\n" +
		842	" public A<String> methodX() {return null;}\n" +
		843	" public void foo() {\n" +
		844	" zzzz\n" +
845	" }\n" +
846	"}");
847
848	this.workingCopies[1] = getWorkingCopy(
849	"/Completion/src3/test/A.java",
850	"package test;\n" +
851	"public class A<TA> {\n" +
852	"}");
853
854	String str = this.workingCopies[0].getSource();
855	int tokenStart = str.lastIndexOf("zzzz");
856	int tokenEnd = tokenStart + "zzzz".length() - 1;
857	int cursorLocation = str.lastIndexOf("zzzz") + "zzzz".length();
858
859	CompletionResult result = contextComplete(this.workingCopies[0], cursorLocation, false, true, "Ltest/A<Ljava/lang/String;>;");
860
861	assertResults(
862	"completion offset="+(cursorLocation)+"\n" +
863	"completion range=["+(tokenStart)+", "+(tokenEnd)+"]\n" +
864	"completion token=\"zzzz\"\n" +
865	"completion token kind=TOKEN_KIND_NAME\n" +
866	"expectedTypesSignatures=null\n" +
867	"expectedTypesKeys=null\n" +
868	"completion token location={STATEMENT_START}\n" +
869	"visibleElements={\n" +
870	" methodX() {key=Ltest/X;.methodX()Ltest/A<Ljava/lang/String;>;} [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]],\n" +
871	"}",
872	result.context);
873	}
874	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=202470
875	public void test0030() throws JavaModelException {
876	this.workingCopies = new ICompilationUnit[3];
877	this.workingCopies[0] = getWorkingCopy(
878	"/Completion/src3/test/X.java",
879	"package test;\n" +
880	"public class X {\n" +
881	" public A<String> methodX() {return null;}\n" +
882	" public void foo() {\n" +
883	" zzzz\n" +
884	" }\n" +
885	"}");
886
887	this.workingCopies[1] = getWorkingCopy(
888	"/Completion/src3/test/A.java",
889	"package test;\n" +
890	"public class A<TA> {\n" +
891	"}");
892
893	this.workingCopies[2] = getWorkingCopy(
894	"/Completion/src3/test/B.java",
895	"package test;\n" +
896	"public class B<TB> {\n" +
897	"}");
898
899	String str = this.workingCopies[0].getSource();
900	int tokenStart = str.lastIndexOf("zzzz");
901	int tokenEnd = tokenStart + "zzzz".length() - 1;
902	int cursorLocation = str.lastIndexOf("zzzz") + "zzzz".length();
903
904	CompletionResult result = contextComplete(this.workingCopies[0], cursorLocation, false, true, "Ltest/B<Ljava/lang/String;>;");
905
906	assertResults(
907	"completion offset="+(cursorLocation)+"\n" +
908	"completion range=["+(tokenStart)+", "+(tokenEnd)+"]\n" +
909	"completion token=\"zzzz\"\n" +
910	"completion token kind=TOKEN_KIND_NAME\n" +
911	"expectedTypesSignatures=null\n" +
912	"expectedTypesKeys=null\n" +
913	"completion token location={STATEMENT_START}\n" +
914	"visibleElements={}",
915	result.context);
916	}
917	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=202470
918	public void test0031() throws JavaModelException {
919	this.workingCopies = new ICompilationUnit[3];
920	this.workingCopies[0] = getWorkingCopy(
921	"/Completion/src3/test/X.java",
922	"package test;\n" +
923	"public class X {\n" +
924	" public A<String> methodX() {return null;}\n" +
925	" public void foo() {\n" +
926	" zzzz\n" +
927	" }\n" +
928	"}");
929
930	this.workingCopies[1] = getWorkingCopy(
931	"/Completion/src3/test/A.java",
932	"package test;\n" +
933	"public class A<TA> extends B<TA>{\n" +
934	"}");
935
936	this.workingCopies[2] = getWorkingCopy(
937	"/Completion/src3/test/B.java",
938	"package test;\n" +
939	"public class B<TB> {\n" +
940	"}");
941
942	String str = this.workingCopies[0].getSource();
943	int tokenStart = str.lastIndexOf("zzzz");
944	int tokenEnd = tokenStart + "zzzz".length() - 1;
945	int cursorLocation = str.lastIndexOf("zzzz") + "zzzz".length();
946
947	CompletionResult result = contextComplete(this.workingCopies[0], cursorLocation, false, true, "Ltest/B<Ljava/lang/String;>;");
948
949	assertResults(
950	"completion offset="+(cursorLocation)+"\n" +
951	"completion range=["+(tokenStart)+", "+(tokenEnd)+"]\n" +
952	"completion token=\"zzzz\"\n" +
953	"completion token kind=TOKEN_KIND_NAME\n" +
954	"expectedTypesSignatures=null\n" +
955	"expectedTypesKeys=null\n" +
956	"completion token location={STATEMENT_START}\n" +
957	"visibleElements={\n" +
958	" methodX() {key=Ltest/X;.methodX()Ltest/A<Ljava/lang/String;>;} [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]],\n" +
959	"}",
960	result.context);
961	}
962	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=202470
963	public void test0032() throws JavaModelException {
964	this.workingCopies = new ICompilationUnit[2];
965	this.workingCopies[0] = getWorkingCopy(
966	"/Completion/src3/test/X.java",
967	"package test;\n" +
968	"public class X {\n" +
969	" public A<String> methodX() {return null;}\n" +
970	" public void foo() {\n" +
971	" zzzz\n" +
972	" }\n" +
973	"}");
974
975	this.workingCopies[1] = getWorkingCopy(
976	"/Completion/src3/test/A.java",
977	"package test;\n" +
978	"public class A<TA> {\n" +
979	"}");
980
981	String str = this.workingCopies[0].getSource();
982	int tokenStart = str.lastIndexOf("zzzz");
983	int tokenEnd = tokenStart + "zzzz".length() - 1;
984	int cursorLocation = str.lastIndexOf("zzzz") + "zzzz".length();
985
986	CompletionResult result = contextComplete(this.workingCopies[0], cursorLocation, false, true, "Ltest/Zork<Ljava/lang/String;>;");
987
988	assertResults(
989	"completion offset="+(cursorLocation)+"\n" +
990	"completion range=["+(tokenStart)+", "+(tokenEnd)+"]\n" +
991	"completion token=\"zzzz\"\n" +
992	"completion token kind=TOKEN_KIND_NAME\n" +
993	"expectedTypesSignatures=null\n" +
994	"expectedTypesKeys=null\n" +
995	"completion token location={STATEMENT_START}\n" +
996	"visibleElements={}",
997	result.context);
998	}
999	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=202470
1000	public void test0033() throws JavaModelException {
1001	this.workingCopies = new ICompilationUnit[2];
1002	this.workingCopies[0] = getWorkingCopy(
1003	"/Completion/src3/test/X.java",
1004	"package test;\n" +
1005	"public class X {\n" +
1006	" public A<String> methodX() {return null;}\n" +
1007	" public void foo() {\n" +
1008	" zzzz\n" +
1009	" }\n" +
1010	"}");
1011
1012	this.workingCopies[1] = getWorkingCopy(
1013	"/Completion/src3/test/A.java",
1014	"package test;\n" +
1015	"public class A<TA> {\n" +
1016	"}");
1017
1018
1019	String str = this.workingCopies[0].getSource();
1020	int tokenStart = str.lastIndexOf("zzzz");
1021	int tokenEnd = tokenStart + "zzzz".length() - 1;
1022	int cursorLocation = str.lastIndexOf("zzzz") + "zzzz".length();
1023
1024	CompletionResult result = contextComplete(this.workingCopies[0], cursorLocation, false, true, "Ltest/A<LZork;>;");
1025
1026	assertResults(
1027	"completion offset="+(cursorLocation)+"\n" +
1028	"completion range=["+(tokenStart)+", "+(tokenEnd)+"]\n" +
1029	"completion token=\"zzzz\"\n" +
1030	"completion token kind=TOKEN_KIND_NAME\n" +
1031	"expectedTypesSignatures=null\n" +
1032	"expectedTypesKeys=null\n" +
1033	"completion token location={STATEMENT_START}\n" +
1034	"visibleElements={}",
1035	result.context);
1036	}
1037	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=202470
1038	public void test0034() throws JavaModelException {
1039	this.workingCopies = new ICompilationUnit[1];
1040	this.workingCopies[0] = getWorkingCopy(
1041	"/Completion/src3/test/X.java",
1042	"package test;\n" +
1043	"public class X<T> {\n" +
1044	" public T methodX() {return null;}\n" +
1045	" public void foo() {\n" +
1046	" zzzz\n" +
1047	" }\n" +
1048	"}");
1049
1050	String str = this.workingCopies[0].getSource();
1051	int tokenStart = str.lastIndexOf("zzzz");
1052	int tokenEnd = tokenStart + "zzzz".length() - 1;
1053	int cursorLocation = str.lastIndexOf("zzzz") + "zzzz".length();
1054
1055	CompletionResult result = contextComplete(this.workingCopies[0], cursorLocation, false, true, "TT;");
1056
1057	assertResults(
1058	"completion offset="+(cursorLocation)+"\n" +
1059	"completion range=["+(tokenStart)+", "+(tokenEnd)+"]\n" +
1060	"completion token=\"zzzz\"\n" +
1061	"completion token kind=TOKEN_KIND_NAME\n" +
1062	"expectedTypesSignatures=null\n" +
1063	"expectedTypesKeys=null\n" +
1064	"completion token location={STATEMENT_START}\n" +
1065	"visibleElements={\n" +
1066	" methodX() {key=Ltest/X;.methodX()TT;} [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]],\n" +
1067	"}",
1068	result.context);
1069	}
1070	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=202470
1071	public void test0035() throws JavaModelException {
1072	this.workingCopies = new ICompilationUnit[1];
1073	this.workingCopies[0] = getWorkingCopy(
1074	"/Completion/src3/test/X.java",
1075	"package test;\n" +
1076	"public class X {\n" +
1077	" public <T> T methodX() {return null;}\n" +
1078	" public void foo() {\n" +
1079	" zzzz\n" +
1080	" }\n" +
1081	"}");
1082
1083	String str = this.workingCopies[0].getSource();
1084	int tokenStart = str.lastIndexOf("zzzz");
1085	int tokenEnd = tokenStart + "zzzz".length() - 1;
1086	int cursorLocation = str.lastIndexOf("zzzz") + "zzzz".length();
1087
1088	CompletionResult result = contextComplete(this.workingCopies[0], cursorLocation, false, true, "TT;");
1089
1090	assertResults(
1091	"completion offset="+(cursorLocation)+"\n" +
1092	"completion range=["+(tokenStart)+", "+(tokenEnd)+"]\n" +
1093	"completion token=\"zzzz\"\n" +
1094	"completion token kind=TOKEN_KIND_NAME\n" +
1095	"expectedTypesSignatures=null\n" +
1096	"expectedTypesKeys=null\n" +
1097	"completion token location={STATEMENT_START}\n" +
1098	"visibleElements={}",
1099	result.context);
1100	}
1101	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=202470
1102	public void test0036() throws JavaModelException {
1103	this.workingCopies = new ICompilationUnit[1];
1104	this.workingCopies[0] = getWorkingCopy(
1105	"/Completion/src3/test/X.java",
1106	"package test;\n" +
1107	"public class X {\n" +
1108	" public <T> T methodX() {\n" +
1109	" zzzz\n" +
1110	" }\n" +
1111	"}");
1112
1113	String str = this.workingCopies[0].getSource();
1114	int tokenStart = str.lastIndexOf("zzzz");
1115	int tokenEnd = tokenStart + "zzzz".length() - 1;
1116	int cursorLocation = str.lastIndexOf("zzzz") + "zzzz".length();
1117
1118	CompletionResult result = contextComplete(this.workingCopies[0], cursorLocation, false, true, "TT;");
1119
1120	assertResults(
1121	"completion offset="+(cursorLocation)+"\n" +
1122	"completion range=["+(tokenStart)+", "+(tokenEnd)+"]\n" +
1123	"completion token=\"zzzz\"\n" +
1124	"completion token kind=TOKEN_KIND_NAME\n" +
1125	"expectedTypesSignatures=null\n" +
1126	"expectedTypesKeys=null\n" +
1127	"completion token location={STATEMENT_START}\n" +
1128	"visibleElements={\n" +
1129	" methodX() {key=Ltest/X;.methodX<T:Ljava/lang/Object;>()TT;} [in X [in [Working copy] X.java [in test [in src3 [in Completion]]]]],\n" +
1130	"}",
1131	result.context);
1132	}
781	}	1133	}