Attachment #56767 for bug #152123

Lines 1-5 Link Here

(-)model/org/eclipse/jdt/core/CompletionRequestor.java (-2 / +6 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2004, 2005 IBM Corporation and others.	2	* Copyright (c) 2004, 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 205-211 Link Here
205	* It can be a reference to a static method or field (as in a static import)<br>	205	* It can be a reference to a static method or field (as in a static import)<br>
206	* e.g. <code>{"java.util.Arrays.equals"}</code>	206	* e.g. <code>{"java.util.Arrays.equals"}</code>
207	* </p>	207	* </p>
208	*	208	* <p>
		209	* Currently only on demand type references (<code>"java.util.Arrays.*"</code>),
		210	* references to a static method or a static field are used to compute completion proposals.
		211	* Other kind of reference could be used in the future.
		212	* </p>
209	* @return favorites imports	213	* @return favorites imports
210	*	214	*
211	* @since 3.3	215	* @since 3.3




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

	public static final int JAVADOC_INLINE_TAG = 20;

	/**
	 * Completion is an import of reference to a field.
	 * <p>
	 * The following additional context information is available
	 * for this kind of completion proposal at little extra cost:
	 * <ul>
	 * <li>{@link #getDeclarationSignature()} -
	 * the type signature of the type that declares the field that is imported
	 * </li>
	 * <li>{@link #getFlags()} -
	 * the modifiers flags (including ACC_ENUM) of the field that is imported
	 * </li>
	 * <li>{@link #getName()} -
	 * the simple name of the field that is imported
	 * </li>
	 * <li>{@link #getSignature()} -
	 * the type signature of the field's type (as opposed to the
	 * signature of the type in which the referenced field
	 * is declared)
	 * </li>
	 * <li>{@link #getAdditionalFlags()} -
	 * the completion flags (including ComletionFlags.StaticImport)
	 * of the prosposed import
	 * </li>
	 * </ul>
	 * </p>
	 * 
	 * @see #getKind()
	 * 
	 * @since 3.3
	 */
	public static final int FIELD_IMPORT = 21;
	
	/**
	 * Completion is an import of reference to a static method.
	 * <p>
	 * The following additional context information is available
	 * for this kind of completion proposal at little extra cost:
	 * <ul>
	 * <li>{@link #getDeclarationSignature()} -
	 * the type signature of the type that declares the method that is imported
	 * </li>
	 * <li>{@link #getFlags()} -
	 * the modifiers flags of the method that is imported
	 * </li>
	 * <li>{@link #getName()} -
	 * the simple name of the method that is imported
	 * </li>
	 * <li>{@link #getSignature()} -
	 * the method signature of the method that is imported
	 * </li>
	 * <li>{@link #getAdditionalFlags()} -
	 * the completion flags (including ComletionFlags.StaticImport)
	 * of the prosposed import
	 * </li>
	 * </ul>
	 * </p>
	 * 
	 * @see #getKind()
	 * 
	 * @since 3.3
	 */
	public static final int METHOD_IMPORT = 22;
	
	/**
	 * Completion is an import of reference to a type.
	 * Only reference to reference types are allowed.
	 * <p>
	 * The following additional context information is available
	 * for this kind of completion proposal at little extra cost:
	 * <ul>
	 * <li>{@link #getDeclarationSignature()} -
	 * the dot-based package name of the package that contains
	 * the type that is imported
	 * </li>
	 * <li>{@link #getSignature()} -
	 * the type signature of the type that is imported
	 * </li>
	 * <li>{@link #getFlags()} -
	 * the modifiers flags (including Flags.AccInterface, AccEnum,
	 * and AccAnnotation) of the type that is imported
	 * </li>
	 * <li>{@link #getAdditionalFlags()} -
	 * the completion flags (including ComletionFlags.StaticImport)
	 * of the prosposed import
	 * </li>
	 * </ul>
	 * </p>
	 * 
	 * @see #getKind()
	 * 
	 * @since 3.3
	 */
	public static final int TYPE_IMPORT = 23;
	
	/**
	 * First valid completion kind.
	 * 
	 * @since 3.1

	 * 
	 * @since 3.1
	 */
	protected static final int LAST_KIND = TYPE_IMPORT;
	
	/**
	 * Kind of completion request.

	 */
	private int flags = Flags.AccDefault;
	
	private int additionalFlags = 0;
	
	/**
	 * Parameter names (for method completions), or
	 * <code>null</code> if none. Lazily computed.

	}
	
	/**
	 * Returns the completion flags relevant in the context, or
	 * <code>CompletionFlags.Default</code> if none.
	 * <p>
	 * This field is available for the following kinds of
	 * completion proposals:
	 * <ul>
	 * <li><code>FIELD_IMPORT</code> - completion flags
	 * of the attribute that is referenced. Completion flags for
	 * this proposal kind can only include <code>CompletionFlags.StaticImport</code></li>
	 * <li><code>METHOD_IMPORT</code> - completion flags
	 * of the attribute that is referenced. Completion flags for
	 * this proposal kind can only include <code>CompletionFlags.StaticImport</code></li>
	 * <li><code>TYPE_IMPORT</code> - completion flags
	 * of the attribute that is referenced. Completion flags for
	 * this proposal kind can only include <code>CompletionFlags.StaticImport</code></li>
	 * </ul>
	 * For other kinds of completion proposals, this method returns
	 * <code>CompletionFlags.Default</code>.
	 * </p>
	 * 
	 * @return the completion flags, or
	 * <code>CompletionFlags.Default</code> if none
	 * @see CompletionFlags
	 * 
	 * @since 3.3
	 */
	public int getAdditionalFlags() {
		return this.additionalFlags;
	}

	/**
	 * Sets the completion flags relevant in the context.
	 * <p>
	 * If not set, defaults to none.
	 * </p>
	 * <p>
	 * The completion engine creates instances of this class and sets
	 * its properties; this method is not intended to be used by other clients.
	 * </p>
	 * 
	 * @param additionalFlags the completion flags, or
	 * <code>CompletionFlags.Default</code> if none
	 * 
	 * @since 3.3
	 */
	public void setAdditionalFlags(int additionalFlags) {
		this.additionalFlags = additionalFlags;
	}
	
	/**
	 * Returns the kind of completion being proposed.
	 * <p>
	 * The set of different kinds of completion proposals is

	 * of the annotation that declares the attribute that is referenced</li>
	 * <li><code>ANONYMOUS_CLASS_DECLARATION</code> - type signature
	 * of the type that is being subclassed or implemented</li>
	 * 	<li><code>FIELD_IMPORT</code> - type signature
	 * of the type that declares the field that is imported</li>
	 *  <li><code>FIELD_REF</code> - type signature
	 * of the type that declares the field that is referenced</li>
	 * 	<li><code>METHOD_IMPORT</code> - type signature
	 * of the type that declares the method that is imported</li>
	 *  <li><code>METHOD_REF</code> - type signature
	 * of the type that declares the method that is referenced</li>
	 * 	<li><code>METHOD_DECLARATION</code> - type signature
	 * of the type that declares the method that is being
	 * implemented or overridden</li>
	 * 	<li><code>PACKAGE_REF</code> - dot-based package 
	 * name of the package that is referenced</li>
	 * 	<li><code>TYPE_IMPORT</code> - dot-based package 
	 * name of the package containing the type that is imported</li>
	 *  <li><code>TYPE_REF</code> - dot-based package 
	 * name of the package containing the type that is referenced</li>
	 *  <li><code>POTENTIAL_METHOD_DECLARATION</code> - type signature
	 * of the type that declares the method that is being created</li>

	 * completion proposals:
	 * <ul>
	 *  <li><code>ANNOTATION_ATTRIBUT_REF</code> - the name of the attribute</li>
	 * 	<li><code>FIELD_IMPORT</code> - the name of the field</li>
	 *  <li><code>FIELD_REF</code> - the name of the field</li>
	 * 	<li><code>KEYWORD</code> - the keyword</li>
	 * 	<li><code>LABEL_REF</code> - the name of the label</li>
	 * 	<li><code>LOCAL_VARIABLE_REF</code> - the name of the local variable</li>
	 * 	<li><code>METHOD_IMPORT</code> - the name of the method</li>
	 *  <li><code>METHOD_REF</code> - the name of the method (the type simple name for constructor)</li>
	 * 	<li><code>METHOD_DECLARATION</code> - the name of the method (the type simple name for constructor)</li>
	 * 	<li><code>VARIABLE_DECLARATION</code> - the name of the variable</li>
	 *  <li><code>POTENTIAL_METHOD_DECLARATION</code> - the name of the method</li>

	 * of the referenced attribute's type</li>
	 * <li><code>ANONYMOUS_CLASS_DECLARATION</code> - method signature
	 * of the constructor that is being invoked</li>
	 * 	<li><code>FIELD_IMPORT</code> - the type signature
	 * of the referenced field's type</li>
	 *  <li><code>FIELD_REF</code> - the type signature
	 * of the referenced field's type</li>
	 * 	<li><code>LOCAL_VARIABLE_REF</code> - the type signature
	 * of the referenced local variable's type</li>
	 * 	<li><code>METHOD_IMPORT</code> - method signature
	 * of the method that is imported</li>
	 *  <li><code>METHOD_REF</code> - method signature
	 * of the method that is referenced</li>
	 * 	<li><code>METHOD_DECLARATION</code> - method signature
	 * of the method that is being implemented or overridden</li>
	 * 	<li><code>TYPE_IMPORT</code> - type signature
	 * of the type that is imported</li>
	 * 	<li><code>TYPE_REF</code> - type signature
	 * of the type that is referenced</li>
	 * 	<li><code>VARIABLE_DECLARATION</code> - the type signature

	 * of the attribute that is referenced; 
	 * <li><code>ANONYMOUS_CLASS_DECLARATION</code> - modifier flags
	 * of the constructor that is referenced</li>
	 * 	<li><code>FIELD_IMPORT</code> - modifier flags
	 * of the field that is imported.</li>
	 *  <li><code>FIELD_REF</code> - modifier flags
	 * of the field that is referenced; 
	 * <code>Flags.AccEnum</code> can be used to recognize
	 * references to enum constants

	 * corrresponding to the modifier keyword</li>
	 * 	<li><code>LOCAL_VARIABLE_REF</code> - modifier flags
	 * of the local variable that is referenced</li>
	 *  <li><code>METHOD_IMPORT</code> - modifier flags
	 * of the method that is imported;
	 *  </li>
	 * 	<li><code>METHOD_REF</code> - modifier flags
	 * of the method that is referenced;
	 * <code>Flags.AccAnnotation</code> can be used to recognize
	 * references to annotation type members
	 * </li>
	 * <li><code>METHOD_DECLARATION</code> - modifier flags
	 * for the method that is being implemented or overridden</li>
	 * <li><code>TYPE_IMPORT</code> - modifier flags
	 * of the type that is imporetd; <code>Flags.AccInterface</code>
	 * can be used to recognize references to interfaces, 
	 * <code>Flags.AccEnum</code> enum types,
	 * and <code>Flags.AccAnnotation</code> annotation types</li>
	 * <li><code>TYPE_REF</code> - modifier flags
	 * of the type that is referenced; <code>Flags.AccInterface</code>
	 * can be used to recognize references to interfaces, 
	 * <code>Flags.AccEnum</code> enum types,

	 * 	<li><code>FIELD_REF</code> - The allowed required proposals for this kind are:
	 *   <ul>
	 *    <li><code>TYPE_REF</code></li>
	 *    <li><code>TYPE_IMPORT</code></li>
	 *    <li><code>FIELD_IMPORT</code></li>
	 *   </ul>
	 * </li>
	 * 	<li><code>METHOD_REF</code> - The allowed required proposals for this kind are:
	 *   <ul>
	 *    <li><code>TYPE_REF</code></li>
	 *    <li><code>TYPE_IMPORT</code></li>
	 *    <li><code>METHOD_IMPORT</code></li>
	 *   </ul>
	 *  </li>
	 * </ul>

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

Lines 1-5 Link Here

(-)codeassist/org/eclipse/jdt/internal/codeassist/CompletionEngine.java (-54 / +273 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2006 IBM Corporation and others.	2	* Copyright (c) 2000, 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 15-20 Link Here
15	import java.util.Map;	15	import java.util.Map;
16		16
17	import org.eclipse.jdt.core.CompletionContext;	17	import org.eclipse.jdt.core.CompletionContext;
		18	import org.eclipse.jdt.core.CompletionFlags;
18	import org.eclipse.jdt.core.CompletionProposal;	19	import org.eclipse.jdt.core.CompletionProposal;
19	import org.eclipse.jdt.core.CompletionRequestor;	20	import org.eclipse.jdt.core.CompletionRequestor;
20	import org.eclipse.jdt.core.Flags;	21	import org.eclipse.jdt.core.Flags;
Lines 214-219 Link Here
214		215
215	private final static char[] VARARGS = "...".toCharArray(); //$NON-NLS-1$	216	private final static char[] VARARGS = "...".toCharArray(); //$NON-NLS-1$
216		217
		218	private final static char[] IMPORT = "import".toCharArray(); //$NON-NLS-1$
		219	private final static char[] STATIC = "static".toCharArray(); //$NON-NLS-1$
		220	private final static char[] ON_DEMAND = ".*".toCharArray(); //$NON-NLS-1$
		221	private final static char[] IMPORT_END = ";\n".toCharArray(); //$NON-NLS-1$
		222
217	private final static int SUPERTYPE = 1;	223	private final static int SUPERTYPE = 1;
218	private final static int SUBTYPE = 2;	224	private final static int SUBTYPE = 2;
219		225
Lines 3360-3367 Link Here
3360		3366
3361	fieldsFound.add(new Object[]{field, receiverType});	3367	fieldsFound.add(new Object[]{field, receiverType});
3362		3368
3363	char[] completion = CharOperation.concat(typeName, field.name, '.');
3364
3365	int relevance = computeBaseRelevance();	3369	int relevance = computeBaseRelevance();
3366	relevance += computeRelevanceForInterestingProposal(field);	3370	relevance += computeRelevanceForInterestingProposal(field);
3367	if (fieldName != null) relevance += computeRelevanceForCaseMatching(fieldName, field.name);	3371	if (fieldName != null) relevance += computeRelevanceForCaseMatching(fieldName, field.name);
Lines 3369-3392 Link Here
3369	relevance += computeRelevanceForStatic(true, true);	3373	relevance += computeRelevanceForStatic(true, true);
3370	relevance += computeRelevanceForRestrictions(IAccessRule.K_ACCESSIBLE);	3374	relevance += computeRelevanceForRestrictions(IAccessRule.K_ACCESSIBLE);
3371		3375
		3376	CompilationUnitDeclaration cu = this.unitScope.referenceContext;
		3377	int importStart = cu.types[0].declarationSourceStart;
		3378	int importEnd = importStart;
		3379
3372	this.noProposal = false;	3380	this.noProposal = false;
3373		3381
3374	if (!this.isIgnored(CompletionProposal.FIELD_REF)) {	3382	if (this.compilerOptions.complianceLevel < ClassFileConstants.JDK1_5) {
3375	CompletionProposal proposal = this.createProposal(CompletionProposal.FIELD_REF, this.actualCompletionPosition);	3383	if (!this.isIgnored(CompletionProposal.FIELD_REF, CompletionProposal.TYPE_IMPORT)) {
3376	proposal.setDeclarationSignature(getSignature(field.declaringClass));	3384	char[] completion = CharOperation.concat(receiverType.sourceName, field.name, '.');
3377	proposal.setSignature(getSignature(field.type));	3385
3378	proposal.setDeclarationPackageName(field.declaringClass.qualifiedPackageName());	3386	CompletionProposal proposal = this.createProposal(CompletionProposal.FIELD_REF, this.actualCompletionPosition);
3379	proposal.setDeclarationTypeName(field.declaringClass.qualifiedSourceName());	3387	proposal.setDeclarationSignature(getSignature(field.declaringClass));
3380	proposal.setPackageName(field.type.qualifiedPackageName());	3388	proposal.setSignature(getSignature(field.type));
3381	proposal.setTypeName(field.type.qualifiedSourceName());	3389	proposal.setDeclarationPackageName(field.declaringClass.qualifiedPackageName());
3382	proposal.setName(field.name);	3390	proposal.setDeclarationTypeName(field.declaringClass.qualifiedSourceName());
3383	proposal.setCompletion(completion);	3391	proposal.setPackageName(field.type.qualifiedPackageName());
3384	proposal.setFlags(field.modifiers);	3392	proposal.setTypeName(field.type.qualifiedSourceName());
3385	proposal.setReplaceRange(this.startPosition - this.offset, this.endPosition - this.offset);	3393	proposal.setName(field.name);
3386	proposal.setRelevance(relevance);	3394	proposal.setCompletion(completion);
3387	this.requestor.accept(proposal);	3395	proposal.setFlags(field.modifiers);
3388	if(DEBUG) {	3396	proposal.setReplaceRange(this.startPosition - this.offset, this.endPosition - this.offset);
3389	this.printDebug(proposal);	3397	proposal.setRelevance(relevance);
		3398
		3399	char[] typeImportCompletion = createImportCharArray(typeName, false, false);
		3400
		3401	CompletionProposal typeImportProposal = this.createProposal(CompletionProposal.TYPE_IMPORT, this.actualCompletionPosition);
		3402	typeImportProposal.nameLookup = this.nameEnvironment.nameLookup;
		3403	typeImportProposal.completionEngine = this;
		3404	char[] packageName = receiverType.qualifiedPackageName();
		3405	typeImportProposal.setDeclarationSignature(packageName);
		3406	typeImportProposal.setSignature(getSignature(receiverType));
		3407	typeImportProposal.setPackageName(packageName);
		3408	typeImportProposal.setTypeName(receiverType.qualifiedSourceName());
		3409	typeImportProposal.setCompletion(typeImportCompletion);
		3410	typeImportProposal.setFlags(receiverType.modifiers);
		3411	typeImportProposal.setAdditionalFlags(CompletionFlags.Default);
		3412	typeImportProposal.setReplaceRange(importStart - this.offset, importEnd - this.offset);
		3413	typeImportProposal.setRelevance(relevance);
		3414
		3415	proposal.setRequiredProposals(new CompletionProposal[]{typeImportProposal});
		3416
		3417	this.requestor.accept(proposal);
		3418	if(DEBUG) {
		3419	this.printDebug(proposal);
		3420	}
		3421	}
		3422	} else {
		3423	if (!this.isIgnored(CompletionProposal.FIELD_REF, CompletionProposal.FIELD_IMPORT)) {
		3424	char[] completion = field.name;
		3425
		3426	CompletionProposal proposal = this.createProposal(CompletionProposal.FIELD_REF, this.actualCompletionPosition);
		3427	proposal.setDeclarationSignature(getSignature(field.declaringClass));
		3428	proposal.setSignature(getSignature(field.type));
		3429	proposal.setDeclarationPackageName(field.declaringClass.qualifiedPackageName());
		3430	proposal.setDeclarationTypeName(field.declaringClass.qualifiedSourceName());
		3431	proposal.setPackageName(field.type.qualifiedPackageName());
		3432	proposal.setTypeName(field.type.qualifiedSourceName());
		3433	proposal.setName(field.name);
		3434	proposal.setCompletion(completion);
		3435	proposal.setFlags(field.modifiers);
		3436	proposal.setReplaceRange(this.startPosition - this.offset, this.endPosition - this.offset);
		3437	proposal.setRelevance(relevance);
		3438
		3439	char[] fieldImportCompletion = createImportCharArray(CharOperation.concat(typeName, field.name, '.'), true, false);
		3440
		3441	CompletionProposal fieldImportProposal = this.createProposal(CompletionProposal.FIELD_IMPORT, this.actualCompletionPosition);
		3442	fieldImportProposal.setDeclarationSignature(getSignature(field.declaringClass));
		3443	fieldImportProposal.setSignature(getSignature(field.type));
		3444	fieldImportProposal.setDeclarationPackageName(field.declaringClass.qualifiedPackageName());
		3445	fieldImportProposal.setDeclarationTypeName(field.declaringClass.qualifiedSourceName());
		3446	fieldImportProposal.setPackageName(field.type.qualifiedPackageName());
		3447	fieldImportProposal.setTypeName(field.type.qualifiedSourceName());
		3448	fieldImportProposal.setName(field.name);
		3449	fieldImportProposal.setCompletion(fieldImportCompletion);
		3450	fieldImportProposal.setFlags(field.modifiers);
		3451	fieldImportProposal.setAdditionalFlags(CompletionFlags.StaticImport);
		3452	fieldImportProposal.setReplaceRange(importStart - this.offset, importEnd - this.offset);
		3453	fieldImportProposal.setRelevance(relevance);
		3454
		3455	proposal.setRequiredProposals(new CompletionProposal[]{fieldImportProposal});
		3456
		3457	this.requestor.accept(proposal);
		3458	if(DEBUG) {
		3459	this.printDebug(proposal);
		3460	}
3390	}	3461	}
3391	}	3462	}
3392	}	3463	}
Lines 4681-4686 Link Here
4681	MethodBinding otherMethod = (MethodBinding) other[0];	4752	MethodBinding otherMethod = (MethodBinding) other[0];
4682		4753
4683	if (method == otherMethod) continue next;	4754	if (method == otherMethod) continue next;
		4755
		4756	if (CharOperation.equals(method.selector, otherMethod.selector, true)) {
		4757	if (lookupEnvironment.methodVerifier().doesMethodOverride(otherMethod, method)) {
		4758	continue next;
		4759	}
		4760	}
		4761	}
		4762
		4763	boolean proposeStaticImport = !(this.compilerOptions.complianceLevel < ClassFileConstants.JDK1_5);
		4764
		4765	boolean isAlreadyImported = false;
		4766	if (!proposeStaticImport) {
		4767	if(!this.importCachesInitialized) {
		4768	this.initializeImportCaches();
		4769	}
		4770	for (int j = 0; j < this.importCacheCount; j++) {
		4771	char[][] importName = this.importsCache[j];
		4772	if(CharOperation.equals(receiverType.sourceName, importName[0])) {
		4773	if (!CharOperation.equals(typeName, importName[1])) {
		4774	continue next;
		4775	} else {
		4776	isAlreadyImported = true;
		4777	}
		4778	}
		4779	}
4684	}	4780	}
4685		4781
4686	methodsFound.add(new Object[]{method, receiverType});	4782	methodsFound.add(new Object[]{method, receiverType});
Lines 4718-4725 Link Here
4718	completion = CharOperation.concat(method.selector, new char[] { '(', ')' });	4814	completion = CharOperation.concat(method.selector, new char[] { '(', ')' });
4719	}	4815	}
4720		4816
4721	completion = CharOperation.concat(typeName, completion, '.');
4722
4723	int relevance = computeBaseRelevance();	4817	int relevance = computeBaseRelevance();
4724	relevance += computeRelevanceForInterestingProposal();	4818	relevance += computeRelevanceForInterestingProposal();
4725	if (methodName != null) relevance += computeRelevanceForCaseMatching(methodName, method.selector);	4819	if (methodName != null) relevance += computeRelevanceForCaseMatching(methodName, method.selector);
Lines 4728-4759 Link Here
4728	relevance += computeRelevanceForQualification(true);	4822	relevance += computeRelevanceForQualification(true);
4729	relevance += computeRelevanceForRestrictions(IAccessRule.K_ACCESSIBLE);	4823	relevance += computeRelevanceForRestrictions(IAccessRule.K_ACCESSIBLE);
4730		4824
		4825	CompilationUnitDeclaration cu = this.unitScope.referenceContext;
		4826	int importStart = cu.types[0].declarationSourceStart;
		4827	int importEnd = importStart;
4731		4828
4732	this.noProposal = false;	4829	this.noProposal = false;
4733	// Standard proposal	4830
4734	if(!this.isIgnored(CompletionProposal.METHOD_REF)) {	4831	if (!proposeStaticImport) {
4735	CompletionProposal proposal = this.createProposal(CompletionProposal.METHOD_REF, this.actualCompletionPosition);	4832	if (isAlreadyImported) {
4736	proposal.setDeclarationSignature(getSignature(method.declaringClass));	4833	if (!isIgnored(CompletionProposal.METHOD_REF)) {
4737	proposal.setSignature(getSignature(method));	4834	completion = CharOperation.concat(receiverType.sourceName, completion, '.');
4738	MethodBinding original = method.original();	4835
4739	if(original != method) {	4836	CompletionProposal proposal = this.createProposal(CompletionProposal.METHOD_REF, this.actualCompletionPosition);
4740	proposal.setOriginalSignature(getSignature(original));	4837	proposal.setDeclarationSignature(getSignature(method.declaringClass));
4741	}	4838	proposal.setSignature(getSignature(method));
4742	proposal.setDeclarationPackageName(method.declaringClass.qualifiedPackageName());	4839	MethodBinding original = method.original();
4743	proposal.setDeclarationTypeName(method.declaringClass.qualifiedSourceName());	4840	if(original != method) {
4744	proposal.setParameterPackageNames(parameterPackageNames);	4841	proposal.setOriginalSignature(getSignature(original));
4745	proposal.setParameterTypeNames(parameterTypeNames);	4842	}
4746	proposal.setPackageName(method.returnType.qualifiedPackageName());	4843	proposal.setDeclarationPackageName(method.declaringClass.qualifiedPackageName());
4747	proposal.setTypeName(method.returnType.qualifiedSourceName());	4844	proposal.setDeclarationTypeName(method.declaringClass.qualifiedSourceName());
4748	proposal.setName(method.selector);	4845	proposal.setParameterPackageNames(parameterPackageNames);
4749	proposal.setCompletion(completion);	4846	proposal.setParameterTypeNames(parameterTypeNames);
4750	proposal.setFlags(method.modifiers);	4847	proposal.setPackageName(method.returnType.qualifiedPackageName());
4751	proposal.setReplaceRange(this.startPosition - this.offset, this.endPosition - this.offset);	4848	proposal.setTypeName(method.returnType.qualifiedSourceName());
4752	proposal.setRelevance(relevance);	4849	proposal.setName(method.selector);
4753	if(parameterNames != null) proposal.setParameterNames(parameterNames);	4850	proposal.setCompletion(completion);
4754	this.requestor.accept(proposal);	4851	proposal.setFlags(method.modifiers);
4755	if(DEBUG) {	4852	proposal.setReplaceRange(this.startPosition - this.offset, this.endPosition - this.offset);
4756	this.printDebug(proposal);	4853	proposal.setRelevance(relevance);
		4854	if(parameterNames != null) proposal.setParameterNames(parameterNames);
		4855
		4856	this.requestor.accept(proposal);
		4857	if(DEBUG) {
		4858	this.printDebug(proposal);
		4859	}
		4860	}
		4861	} else if (!this.isIgnored(CompletionProposal.METHOD_REF, CompletionProposal.TYPE_IMPORT)) {
		4862	completion = CharOperation.concat(receiverType.sourceName, completion, '.');
		4863
		4864	CompletionProposal proposal = this.createProposal(CompletionProposal.METHOD_REF, this.actualCompletionPosition);
		4865	proposal.setDeclarationSignature(getSignature(method.declaringClass));
		4866	proposal.setSignature(getSignature(method));
		4867	MethodBinding original = method.original();
		4868	if(original != method) {
		4869	proposal.setOriginalSignature(getSignature(original));
		4870	}
		4871	proposal.setDeclarationPackageName(method.declaringClass.qualifiedPackageName());
		4872	proposal.setDeclarationTypeName(method.declaringClass.qualifiedSourceName());
		4873	proposal.setParameterPackageNames(parameterPackageNames);
		4874	proposal.setParameterTypeNames(parameterTypeNames);
		4875	proposal.setPackageName(method.returnType.qualifiedPackageName());
		4876	proposal.setTypeName(method.returnType.qualifiedSourceName());
		4877	proposal.setName(method.selector);
		4878	proposal.setCompletion(completion);
		4879	proposal.setFlags(method.modifiers);
		4880	proposal.setReplaceRange(this.startPosition - this.offset, this.endPosition - this.offset);
		4881	proposal.setRelevance(relevance);
		4882	if(parameterNames != null) proposal.setParameterNames(parameterNames);
		4883
		4884	char[] typeImportCompletion = createImportCharArray(typeName, false, false);
		4885
		4886	CompletionProposal typeImportProposal = this.createProposal(CompletionProposal.TYPE_IMPORT, this.actualCompletionPosition);
		4887	typeImportProposal.nameLookup = this.nameEnvironment.nameLookup;
		4888	typeImportProposal.completionEngine = this;
		4889	char[] packageName = receiverType.qualifiedPackageName();
		4890	typeImportProposal.setDeclarationSignature(packageName);
		4891	typeImportProposal.setSignature(getSignature(receiverType));
		4892	typeImportProposal.setPackageName(packageName);
		4893	typeImportProposal.setTypeName(receiverType.qualifiedSourceName());
		4894	typeImportProposal.setCompletion(typeImportCompletion);
		4895	typeImportProposal.setFlags(receiverType.modifiers);
		4896	typeImportProposal.setAdditionalFlags(CompletionFlags.Default);
		4897	typeImportProposal.setReplaceRange(importStart - this.offset, importEnd - this.offset);
		4898	typeImportProposal.setRelevance(relevance);
		4899
		4900	proposal.setRequiredProposals(new CompletionProposal[]{typeImportProposal});
		4901
		4902	this.requestor.accept(proposal);
		4903	if(DEBUG) {
		4904	this.printDebug(proposal);
		4905	}
		4906	}
		4907	} else {
		4908	if (!this.isIgnored(CompletionProposal.METHOD_REF, CompletionProposal.METHOD_IMPORT)) {
		4909	CompletionProposal proposal = this.createProposal(CompletionProposal.METHOD_REF, this.actualCompletionPosition);
		4910	proposal.setDeclarationSignature(getSignature(method.declaringClass));
		4911	proposal.setSignature(getSignature(method));
		4912	MethodBinding original = method.original();
		4913	if(original != method) {
		4914	proposal.setOriginalSignature(getSignature(original));
		4915	}
		4916	proposal.setDeclarationPackageName(method.declaringClass.qualifiedPackageName());
		4917	proposal.setDeclarationTypeName(method.declaringClass.qualifiedSourceName());
4918	proposal.setParameterPackageNames(parameterPackageNames);
4919	proposal.setParameterTypeNames(parameterTypeNames);
4920	proposal.setPackageName(method.returnType.qualifiedPackageName());
4921	proposal.setTypeName(method.returnType.qualifiedSourceName());
4922	proposal.setName(method.selector);
4923	proposal.setCompletion(completion);
4924	proposal.setFlags(method.modifiers);
4925	proposal.setReplaceRange(this.startPosition - this.offset, this.endPosition - this.offset);
4926	proposal.setRelevance(relevance);
4927	if(parameterNames != null) proposal.setParameterNames(parameterNames);
4928
4929	char[] methodImportCompletion = createImportCharArray(CharOperation.concat(typeName, method.selector, '.'), true, false);
4930
4931	CompletionProposal methodImportProposal = this.createProposal(CompletionProposal.METHOD_IMPORT, this.actualCompletionPosition);
4932	methodImportProposal.setDeclarationSignature(getSignature(method.declaringClass));
4933	methodImportProposal.setSignature(getSignature(method));
4934	if(original != method) {
4935	proposal.setOriginalSignature(getSignature(original));
4936	}
4937	methodImportProposal.setDeclarationPackageName(method.declaringClass.qualifiedPackageName());
4938	methodImportProposal.setDeclarationTypeName(method.declaringClass.qualifiedSourceName());
4939	methodImportProposal.setParameterPackageNames(parameterPackageNames);
4940	methodImportProposal.setParameterTypeNames(parameterTypeNames);
4941	methodImportProposal.setPackageName(method.returnType.qualifiedPackageName());
4942	methodImportProposal.setTypeName(method.returnType.qualifiedSourceName());
4943	methodImportProposal.setName(method.selector);
4944	methodImportProposal.setCompletion(methodImportCompletion);
4945	methodImportProposal.setFlags(method.modifiers);
4946	methodImportProposal.setAdditionalFlags(CompletionFlags.StaticImport);
4947	methodImportProposal.setReplaceRange(importStart - this.offset, importEnd - this.offset);
4948	methodImportProposal.setRelevance(relevance);
4949	if(parameterNames != null) methodImportProposal.setParameterNames(parameterNames);
4950
4951	proposal.setRequiredProposals(new CompletionProposal[]{methodImportProposal});
4952
4953	this.requestor.accept(proposal);
4954	if(DEBUG) {
4955	this.printDebug(proposal);
4956	}
4757	}	4957	}
4758	}	4958	}
4759		4959
Lines 5326-5331 Link Here
5326	createType(type, completion);	5526	createType(type, completion);
5327	}	5527	}
5328	}	5528	}
		5529	private char[] createImportCharArray(char[] importedElement, boolean isStatic, boolean onDemand) {
		5530	char[] result = IMPORT;
		5531	if (isStatic) {
		5532	result = CharOperation.concat(result, STATIC, ' ');
		5533	}
		5534	result = CharOperation.concat(result, importedElement, ' ');
		5535	if (onDemand) {
		5536	result = CharOperation.concat(result, ON_DEMAND);
		5537	}
		5538	return CharOperation.concat(result, IMPORT_END);
		5539	}
5329	private void createMethod(MethodBinding method, char[][] parameterPackageNames, char[][] parameterTypeNames, char[][] parameterNames, StringBuffer completion) {	5540	private void createMethod(MethodBinding method, char[][] parameterPackageNames, char[][] parameterTypeNames, char[][] parameterNames, StringBuffer completion) {
5330	//// Modifiers	5541	//// Modifiers
5331	// flush uninteresting modifiers	5542	// flush uninteresting modifiers
Lines 5404-5409 Link Here
5404	return this.requestor.isIgnored(kind);	5615	return this.requestor.isIgnored(kind);
5405	}	5616	}
5406		5617
		5618	private boolean isIgnored(int kind, int requiredProposalKind) {
		5619	return this.requestor.isIgnored(kind) \|\|
		5620	!this.requestor.isAllowingRequiredProposals(kind, requiredProposalKind);
		5621	}
		5622
5407	private void findMethods(	5623	private void findMethods(
5408	char[] selector,	5624	char[] selector,
5409	TypeBinding[] typeArgTypes,	5625	TypeBinding[] typeArgTypes,
Lines 6845-6851 Link Here
6845	}	7061	}
6846	}	7062	}
6847		7063
6848	boolean isStatic = this.compilerOptions.sourceLevel > ClassFileConstants.JDK1_4;	7064	boolean isStatic = true;
6849		7065
6850	ImportReference importReference =	7066	ImportReference importReference =
6851	new ImportReference(	7067	new ImportReference(
Lines 6860-6873 Link Here
6860	continue next;	7076	continue next;
6861	}	7077	}
6862		7078
6863	if (onDemand) {	7079	if (importBinding instanceof PackageBinding) {
6864	if (importReference.isStatic() && importBinding instanceof PackageBinding) {	7080	continue next;
6865	importReference.modifiers = importReference.modifiers & ~ClassFileConstants.AccStatic;
6866	}
6867	} else {
6868	if (importBinding instanceof PackageBinding) {
6869	continue next;
6870	}
6871	}	7081	}
6872		7082
6873	resolvedImports[count++] =	7083	resolvedImports[count++] =
Lines 7878-7883 Link Here
7878	case CompletionProposal.ANNOTATION_ATTRIBUTE_REF :	8088	case CompletionProposal.ANNOTATION_ATTRIBUTE_REF :
7879	buffer.append("ANNOTATION_ATTRIBUT_REF"); //$NON-NLS-1$	8089	buffer.append("ANNOTATION_ATTRIBUT_REF"); //$NON-NLS-1$
7880	break;	8090	break;
		8091	case CompletionProposal.FIELD_IMPORT :
		8092	buffer.append("FIELD_IMPORT"); //$NON-NLS-1$
		8093	break;
		8094	case CompletionProposal.METHOD_IMPORT :
		8095	buffer.append("METHOD_IMPORT"); //$NON-NLS-1$
		8096	break;
		8097	case CompletionProposal.TYPE_IMPORT :
		8098	buffer.append("TYPE_IMPORT"); //$NON-NLS-1$
		8099	break;
7881	default :	8100	default :
7882	buffer.append("PROPOSAL"); //$NON-NLS-1$	8101	buffer.append("PROPOSAL"); //$NON-NLS-1$
7883	break;	8102	break;




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

/**
 * Utility class for decoding additional flags in completion proposal.
 * <p>
 * This class provides static methods only; it is not intended to be
 * instantiated or subclassed by clients.
 * </p>
 *
 * @see CompletionProposal#getAdditionalFlags()
 * 
 * @since 3.3
 */
public final class CompletionFlags {
	/**
	 * Constant representing the absence of any flag
	 */
	public static final int Default = 0x0000;
	
	/**
	 * Constant representing a static import
	 */
	public static final int StaticImport = 0x0001;

	/**
	 * Not instantiable.
	 */
	private CompletionFlags() {
		// Not instantiable
	}
	
	/**
	 * Returns whether the given integer includes the {@link #StaticImport} flag.
	 *
	 * @param flags the flags
	 * @return <code>true</code> if the {@link #StaticImport} flag is included
	 */
	public static boolean isStaticImport(int flags) {
		return (flags & StaticImport) != 0;
	}
}

Lines 71-78 Link Here

(-)src/org/eclipse/jdt/core/tests/model/CompletionTestsRequestor2.java (-2 / +14 lines)
71	}	71	}
72		72
73	public void allowAllRequiredProposals() {	73	public void allowAllRequiredProposals() {
74	for (int i = CompletionProposal.ANONYMOUS_CLASS_DECLARATION; i <= CompletionProposal.JAVADOC_INLINE_TAG; i++) {	74	for (int i = CompletionProposal.ANONYMOUS_CLASS_DECLARATION; i <= CompletionProposal.TYPE_IMPORT; i++) {
75	for (int j = CompletionProposal.ANONYMOUS_CLASS_DECLARATION; j <= CompletionProposal.JAVADOC_INLINE_TAG; j++) {	75	for (int j = CompletionProposal.ANONYMOUS_CLASS_DECLARATION; j <= CompletionProposal.TYPE_IMPORT; j++) {
76	this.setAllowsRequiredProposals(i, j, true);	76	this.setAllowsRequiredProposals(i, j, true);
77	}	77	}
78	}	78	}
Lines 289-294 Link Here
289	case CompletionProposal.JAVADOC_VALUE_REF :	289	case CompletionProposal.JAVADOC_VALUE_REF :
290	buffer.append("JAVADOC_VALUE_REF"); //$NON-NLS-1$	290	buffer.append("JAVADOC_VALUE_REF"); //$NON-NLS-1$
291	break;	291	break;
		292	case CompletionProposal.FIELD_IMPORT :
		293	buffer.append("FIELD_IMPORT"); //$NON-NLS-1$
		294	break;
		295	case CompletionProposal.METHOD_IMPORT :
		296	buffer.append("METHOD_IMPORT"); //$NON-NLS-1$
		297	break;
		298	case CompletionProposal.TYPE_IMPORT :
		299	buffer.append("TYPE_IMPORT"); //$NON-NLS-1$
		300	break;
292	default :	301	default :
293	buffer.append("PROPOSAL"); //$NON-NLS-1$	302	buffer.append("PROPOSAL"); //$NON-NLS-1$
294	break;	303	break;
Lines 412-417 Link Here
412	case CompletionProposal.ANONYMOUS_CLASS_DECLARATION :	421	case CompletionProposal.ANONYMOUS_CLASS_DECLARATION :
413	return new String(Signature.getSignatureSimpleName(proposal.getDeclarationSignature()));	422	return new String(Signature.getSignatureSimpleName(proposal.getDeclarationSignature()));
414	case CompletionProposal.TYPE_REF :	423	case CompletionProposal.TYPE_REF :
		424	case CompletionProposal.TYPE_IMPORT :
415	case CompletionProposal.JAVADOC_TYPE_REF :	425	case CompletionProposal.JAVADOC_TYPE_REF :
416	return new String(Signature.getSignatureSimpleName(proposal.getSignature()));	426	return new String(Signature.getSignatureSimpleName(proposal.getSignature()));
417	case CompletionProposal.FIELD_REF :	427	case CompletionProposal.FIELD_REF :
Lines 430-435 Link Here
430	case CompletionProposal.JAVADOC_METHOD_REF :	440	case CompletionProposal.JAVADOC_METHOD_REF :
431	case CompletionProposal.JAVADOC_PARAM_REF :	441	case CompletionProposal.JAVADOC_PARAM_REF :
432	case CompletionProposal.JAVADOC_VALUE_REF :	442	case CompletionProposal.JAVADOC_VALUE_REF :
		443	case CompletionProposal.FIELD_IMPORT :
		444	case CompletionProposal.METHOD_IMPORT :
433	return new String(proposal.getName());	445	return new String(proposal.getName());
434	case CompletionProposal.PACKAGE_REF:	446	case CompletionProposal.PACKAGE_REF:
435	return new String(proposal.getDeclarationSignature());	447	return new String(proposal.getDeclarationSignature());




			"    public static int foo;\n" +
			"}");
	
	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
	requestor.allowAllRequiredProposals();
	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.*"});
	
	String str = this.workingCopies[0].getSource();
	String completeBehind = "foo";
	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
	
	int relevance1 = R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED;
	int start1 = str.lastIndexOf("foo") + "".length();
	int end1 = start1 + "foo".length();
	int start2 = str.lastIndexOf("public class");
	int end2 = start2 + "".length();
	assertResults(
			"foo[FIELD_REF]{ZZZ.foo, Ltest.p.ZZZ;, I, foo, null, ["+start1+", "+end1+"], "+(relevance1)+"}\n" +
			"   ZZZ[TYPE_IMPORT]{import test.p.ZZZ;\n, test.p, Ltest.p.ZZZ;, null, null, ["+start2+", "+end2+"], " + (relevance1) + "}",
			requestor.getResults());
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123

			"    public static int foo(){}\n" +
			"}");
	
	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
	requestor.allowAllRequiredProposals();
	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.*"});
	
	String str = this.workingCopies[0].getSource();

	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);

	int relevance1 = R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED;
	int start1 = str.lastIndexOf("foo") + "".length();
	int end1 = start1 + "foo".length();
	int start2 = str.lastIndexOf("public class");
	int end2 = start2 + "".length();
	assertResults(
			"foo[METHOD_REF]{ZZZ.foo(), Ltest.p.ZZZ;, ()I, foo, null, ["+start1+", "+end1+"], "+(relevance1)+"}\n" +
			"   ZZZ[TYPE_IMPORT]{import test.p.ZZZ;\n, test.p, Ltest.p.ZZZ;, null, null, ["+start2+", "+end2+"], " + (relevance1) + "}",
			requestor.getResults());
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123

			"    public static int foo;\n" +
			"}");
	
	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
	requestor.allowAllRequiredProposals();
	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ"});
	
	String str = this.workingCopies[0].getSource();

			"    public static int foo(){}\n" +
			"}");
	
	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
	requestor.allowAllRequiredProposals();
	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ"});
	
	String str = this.workingCopies[0].getSource();

			"    public static int foo;\n" +
			"}");
	
	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
	requestor.allowAllRequiredProposals();
	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.foo"});
	
	String str = this.workingCopies[0].getSource();

	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);

	int relevance1 = R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED;
	int start1 = str.lastIndexOf("foo") + "".length();
	int end1 = start1 + "foo".length();
	int start2 = str.lastIndexOf("public class");
	int end2 = start2 + "".length();
	assertResults(
			"foo[FIELD_REF]{ZZZ.foo, Ltest.p.ZZZ;, I, foo, null, ["+start1+", "+end1+"], "+(relevance1)+"}\n" +
			"   ZZZ[TYPE_IMPORT]{import test.p.ZZZ;\n, test.p, Ltest.p.ZZZ;, null, null, ["+start2+", "+end2+"], " + (relevance1) + "}",
			requestor.getResults());
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123

			"    public static int foo(){}\n" +
			"}");
	
	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
	requestor.allowAllRequiredProposals();
	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.foo"});
	
	String str = this.workingCopies[0].getSource();

	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);

	int relevance1 = R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED;
	int start1 = str.lastIndexOf("foo") + "".length();
	int end1 = start1 + "foo".length();
	int start2 = str.lastIndexOf("public class");
	int end2 = start2 + "".length();
	assertResults(
			"foo[METHOD_REF]{ZZZ.foo(), Ltest.p.ZZZ;, ()I, foo, null, ["+start1+", "+end1+"], "+(relevance1)+"}\n" +
			"   ZZZ[TYPE_IMPORT]{import test.p.ZZZ;\n, test.p, Ltest.p.ZZZ;, null, null, ["+start2+", "+end2+"], " + (relevance1) + "}",
			requestor.getResults());
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123

			"    public static int foo(){}\n" +
			"}");
	
	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
	requestor.allowAllRequiredProposals();
	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.*"});
	
	String str = this.workingCopies[0].getSource();

	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);

	int relevance1 = R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED;
	int start1 = str.lastIndexOf("foo") + "".length();
	int end1 = start1 + "foo".length();
	int start2 = str.lastIndexOf("public class");
	int end2 = start2 + "".length();
	assertResults(
			"foo[METHOD_REF]{ZZZ.foo(), Ltest.p.ZZZ;, ()I, foo, null, ["+start1+", "+end1+"], "+(relevance1)+"}\n" +
			"   ZZZ[TYPE_IMPORT]{import test.p.ZZZ;\n, test.p, Ltest.p.ZZZ;, null, null, ["+start2+", "+end2+"], " + (relevance1) + "}",
			requestor.getResults());
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123

			"    public static int foo(){}\n" +
			"}");
	
	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
	requestor.allowAllRequiredProposals();
	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.foo"});
	
	String str = this.workingCopies[0].getSource();

	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);

	int relevance1 = R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED;
	int start1 = str.lastIndexOf("foo") + "".length();
	int end1 = start1 + "foo".length();
	int start2 = str.lastIndexOf("public class");
	int end2 = start2 + "".length();
	assertResults(
			"foo[METHOD_REF]{ZZZ.foo(), Ltest.p.ZZZ;, ()I, foo, null, ["+start1+", "+end1+"], "+(relevance1)+"}\n" +
			"   ZZZ[TYPE_IMPORT]{import test.p.ZZZ;\n, test.p, Ltest.p.ZZZ;, null, null, ["+start2+", "+end2+"], " + (relevance1) + "}",
			requestor.getResults());
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123

			"    public static int foo(){}\n" +
			"}");
	
	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
	requestor.allowAllRequiredProposals();
	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.*"});
	
	String str = this.workingCopies[0].getSource();

	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);

	int relevance1 = R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED;
	int start1 = str.lastIndexOf("foo") + "".length();
	int end1 = start1 + "foo".length();
	int start2 = str.lastIndexOf("public class");
	int end2 = start2 + "".length();
	assertResults(
			"foo[METHOD_REF]{ZZZ.foo(), Ltest.p.ZZZ;, ()I, foo, null, ["+start1+", "+end1+"], "+(relevance1)+"}\n" +
			"   ZZZ[TYPE_IMPORT]{import test.p.ZZZ;\n, test.p, Ltest.p.ZZZ;, null, null, ["+start2+", "+end2+"], " + (relevance1) + "}",
			requestor.getResults());
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123

			"    public static int foo(){}\n" +
			"}");
	
	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
	requestor.allowAllRequiredProposals();
	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.foo"});
	
	String str = this.workingCopies[0].getSource();

	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);

	int relevance1 = R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED;
	int start1 = str.lastIndexOf("foo") + "".length();
	int end1 = start1 + "foo".length();
	int start2 = str.lastIndexOf("public class");
	int end2 = start2 + "".length();
	assertResults(
			"foo[METHOD_REF]{ZZZ.foo(), Ltest.p.ZZZ;, ()I, foo, null, ["+start1+", "+end1+"], "+(relevance1)+"}\n" +
			"   ZZZ[TYPE_IMPORT]{import test.p.ZZZ;\n, test.p, Ltest.p.ZZZ;, null, null, ["+start2+", "+end2+"], " + (relevance1) + "}",
			requestor.getResults());
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123

			"    public static int foo(){}\n" +
			"}");
	
	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
	requestor.allowAllRequiredProposals();
	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.*"});
	
	String str = this.workingCopies[0].getSource();
	String completeBehind = "foo";
	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
	
	int relevance1 = R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED;
	int start1 = str.lastIndexOf("foo") + "".length();
	int end1 = start1 + "foo".length();
	int start2 = str.lastIndexOf("public class Test");
	int end2 = start2 + "".length();
	assertResults(
			"foo[METHOD_REF]{ZZZ.foo(), Ltest.p.ZZZ;, ()I, foo, null, ["+start1+", "+end1+"], "+(relevance1)+"}\n" +
			"   ZZZ[TYPE_IMPORT]{import test.p.ZZZ;\n, test.p, Ltest.p.ZZZ;, null, null, ["+start2+", "+end2+"], " + (relevance1) + "}\n"+
			"Test.foo[TYPE_REF]{foo, test, Ltest.Test$foo;, null, null, ["+start1+", "+end1+"], "+(R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_UNQUALIFIED + R_NON_RESTRICTED)+"}",
			requestor.getResults());
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123

			"    public static int foo(){}\n" +
			"}");
	
	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
	requestor.allowAllRequiredProposals();
	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.*"});
	
	String str = this.workingCopies[0].getSource();

	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);

	int start1 = str.lastIndexOf("foo") + "".length();
	int end1 = start1 + "foo".length();
	assertResults(
			"foo[METHOD_REF]{foo(), Ltest.Test;, ()V, foo, null, ["+start1+", "+end1+"], "+(R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_UNQUALIFIED + R_NON_RESTRICTED)+"}",
			"foo[METHOD_REF]{foo(), Ltest.Test;, ()V, foo, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_UNQUALIFIED + R_NON_RESTRICTED)+"}",
			requestor.getResults());
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123

			"    public static int foo(){}\n" +
			"}");
	
	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
	requestor.allowAllRequiredProposals();
	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.*"});
	
	String str = this.workingCopies[0].getSource();

	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);

	int relevance1 = R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED;
	int start1 = str.lastIndexOf("foo") + "".length();
	int end1 = start1 + "foo".length();
	int start2 = str.lastIndexOf("public class Test");
	int end2 = start2 + "".length();
	assertResults(
			"foo[METHOD_REF]{ZZZ.foo(), Ltest.p.ZZZ;, ()I, foo, null, ["+start1+", "+end1+"], "+(relevance1)+"}\n" +
			"   ZZZ[TYPE_IMPORT]{import test.p.ZZZ;\n, test.p, Ltest.p.ZZZ;, null, null, ["+start2+", "+end2+"], " + (relevance1) + "}\n"+
			"foo[FIELD_REF]{foo, Ltest.Test;, I, foo, null, ["+start1+", "+end1+"], "+(R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_UNQUALIFIED + R_NON_RESTRICTED)+"}",
			requestor.getResults());
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123

			"    public static int foo(){}\n" +
			"}");
	
	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
	requestor.allowAllRequiredProposals();
	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.*"});
	
	String str = this.workingCopies[0].getSource();

	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);

	int relevance1 = R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED;
	int start1 = str.lastIndexOf("foo") + "".length();
	int end1 = start1 + "foo".length();
	int start2 = str.lastIndexOf("public class Test");
	int end2 = start2 + "".length();
	assertResults(
			"foo[METHOD_REF]{ZZZ.foo(), Ltest.p.ZZZ;, ()I, foo, null, ["+start1+", "+end1+"], "+(relevance1)+"}\n" +
			"   ZZZ[TYPE_IMPORT]{import test.p.ZZZ;\n, test.p, Ltest.p.ZZZ;, null, null, ["+start2+", "+end2+"], " + (relevance1) + "}\n"+
			"foo[LOCAL_VARIABLE_REF]{foo, null, I, foo, null, ["+start1+", "+end1+"], "+(R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_UNQUALIFIED + R_NON_RESTRICTED)+"}",
			requestor.getResults());
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123

			"    public static int foo(int i){}\n" +
			"}");
	
	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
	requestor.allowAllRequiredProposals();
	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.*"});
	
	String str = this.workingCopies[0].getSource();

	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);

	int relevance1 = R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED;
	int start1 = str.lastIndexOf("foo") + "".length();
	int end1 = start1 + "foo".length();
	int start2 = str.lastIndexOf("public class Test");
	int end2 = start2 + "".length();
	assertResults(
			"foo[METHOD_REF]{ZZZ.foo(), Ltest.p.ZZZ;, ()I, foo, null, ["+start1+", "+end1+"], "+(relevance1)+"}\n" +
			"   ZZZ[TYPE_IMPORT]{import test.p.ZZZ;\n, test.p, Ltest.p.ZZZ;, null, null, ["+start2+", "+end2+"], " + (relevance1) + "}\n"+
			"foo[METHOD_REF]{ZZZ.foo(), Ltest.p.ZZZ;, (I)I, foo, (i), ["+start1+", "+end1+"], "+(relevance1)+"}\n" +
			"   ZZZ[TYPE_IMPORT]{import test.p.ZZZ;\n, test.p, Ltest.p.ZZZ;, null, null, ["+start2+", "+end2+"], " + (relevance1) + "}",
			requestor.getResults());
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123

			"    public static int foo(){}\n" +
			"}");
	
	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
	requestor.allowAllRequiredProposals();
	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.*"});
	
	String str = this.workingCopies[0].getSource();

			"",
			requestor.getResults());
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123
public void testFavoriteImports023() throws JavaModelException {
	this.workingCopies = new ICompilationUnit[2];
	this.workingCopies[0] = getWorkingCopy(
			"/Completion/src3/test/Test.java",
			"package test;\n" +
			"/** */\n" +
			"public class Test {\n" +
			"    public void method() {\n" +
			"        foo\n" +
			"    }\n" +
			"}");
	
	this.workingCopies[1] = getWorkingCopy(
			"/Completion/src3/test/p/ZZZ.java",
			"package test.p;\n" +
			"public class ZZZ {\n" +
			"    public static int foo;\n" +
			"}");
	
	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
	requestor.allowAllRequiredProposals();
	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.*"});
	
	String str = this.workingCopies[0].getSource();
	String completeBehind = "foo";
	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);

	int relevance1 = R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED;
	int start1 = str.lastIndexOf("foo") + "".length();
	int end1 = start1 + "foo".length();
	int start2 = str.lastIndexOf("/** */");
	int end2 = start2 + "".length();
	assertResults(
			"foo[FIELD_REF]{ZZZ.foo, Ltest.p.ZZZ;, I, foo, null, ["+start1+", "+end1+"], "+(relevance1)+"}\n" +
			"   ZZZ[TYPE_IMPORT]{import test.p.ZZZ;\n, test.p, Ltest.p.ZZZ;, null, null, ["+start2+", "+end2+"], " + (relevance1) + "}",
			requestor.getResults());
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123
public void testFavoriteImports024() throws JavaModelException {
	this.workingCopies = new ICompilationUnit[2];
	this.workingCopies[0] = getWorkingCopy(
			"/Completion/src3/test/Test.java",
			"package test;\n" +
			"public class Test {\n" +
			"    public void method() {\n" +
			"        foo\n" +
			"    }\n" +
			"}");
	
	this.workingCopies[1] = getWorkingCopy(
			"/Completion/src3/test/p/ZZZ.java",
			"package test.p;\n" +
			"public class ZZZ {\n" +
			"    public int foo;\n" +
			"}");
	
	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
	requestor.allowAllRequiredProposals();
	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.*"});
	
	String str = this.workingCopies[0].getSource();
	String completeBehind = "foo";
	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);

	assertResults(
			"",
			requestor.getResults());
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123
public void testFavoriteImports025() throws JavaModelException {
	this.workingCopies = new ICompilationUnit[2];
	this.workingCopies[0] = getWorkingCopy(
			"/Completion/src3/test/Test.java",
			"package test;\n" +
			"public class Test {\n" +
			"    public void method() {\n" +
			"        foo\n" +
			"    }\n" +
			"}");
	
	this.workingCopies[1] = getWorkingCopy(
			"/Completion/src3/test/p/ZZZ.java",
			"package test.p;\n" +
			"public class ZZZ {\n" +
			"    public int foo;\n" +
			"}");
	
	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
	requestor.allowAllRequiredProposals();
	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.foo"});
	
	String str = this.workingCopies[0].getSource();
	String completeBehind = "foo";
	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);

	assertResults(
			"",
			requestor.getResults());
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123
public void testFavoriteImports026() throws JavaModelException {
	this.workingCopies = new ICompilationUnit[2];
	this.workingCopies[0] = getWorkingCopy(
			"/Completion/src3/test/Test.java",
			"package test;\n" +
			"public class Test {\n" +
			"    public void method() {\n" +
			"        foo\n" +
			"    }\n" +
			"}");
	
	this.workingCopies[1] = getWorkingCopy(
			"/Completion/src3/test/p/ZZZ.java",
			"package test.p;\n" +
			"public class ZZZ {\n" +
			"    public int foo(){return 0;};\n" +
			"}");
	
	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
	requestor.allowAllRequiredProposals();
	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.*"});
	
	String str = this.workingCopies[0].getSource();
	String completeBehind = "foo";
	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);

	assertResults(
			"",
			requestor.getResults());
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123
public void testFavoriteImports027() throws JavaModelException {
	this.workingCopies = new ICompilationUnit[2];
	this.workingCopies[0] = getWorkingCopy(
			"/Completion/src3/test/Test.java",
			"package test;\n" +
			"public class Test {\n" +
			"    public void method() {\n" +
			"        foo\n" +
			"    }\n" +
			"}");
	
	this.workingCopies[1] = getWorkingCopy(
			"/Completion/src3/test/p/ZZZ.java",
			"package test.p;\n" +
			"public class ZZZ {\n" +
			"    public int foo(){return 0;};\n" +
			"}");
	
	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
	requestor.allowAllRequiredProposals();
	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.foo"});
	
	String str = this.workingCopies[0].getSource();
	String completeBehind = "foo";
	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);

	assertResults(
			"",
			requestor.getResults());
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123
public void testFavoriteImports028() throws JavaModelException {
	this.workingCopies = new ICompilationUnit[2];
	this.workingCopies[0] = getWorkingCopy(
			"/Completion/src3/test/Test.java",
			"package test;\n" +
			"import test.p.ZZZ;\n" +
			"public class Test {\n" +
			"    public void method() {\n" +
			"        foo\n" +
			"    }\n" +
			"}");
	
	this.workingCopies[1] = getWorkingCopy(
			"/Completion/src3/test/p/ZZZ.java",
			"package test.p;\n" +
			"public class ZZZ {\n" +
			"    public static int foo(){return 0;};\n" +
			"}");
	
	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
	requestor.allowAllRequiredProposals();
	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.foo"});
	
	String str = this.workingCopies[0].getSource();
	String completeBehind = "foo";
	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);

	int start1 = str.lastIndexOf("foo") + "".length();
	int end1 = start1 + "foo".length();
	assertResults(
			"foo[METHOD_REF]{ZZZ.foo(), Ltest.p.ZZZ;, ()I, foo, null, ["+start1+", "+end1+"], " + (R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED) + "}",
			requestor.getResults());
}
}

Lines 9444-9450 Link Here

(-)src/org/eclipse/jdt/core/tests/model/CompletionTests_1_5.java (-55 / +372 lines)
9444	" public static int foo;\n" +	9444	" public static int foo;\n" +
9445	"}");	9445	"}");
9446		9446
9447	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);	9447	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
		9448	requestor.allowAllRequiredProposals();
9448	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.*"});	9449	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.*"});
9449		9450
9450	String str = this.workingCopies[0].getSource();	9451	String str = this.workingCopies[0].getSource();
Lines 9452-9459 Link Here
9452	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();	9453	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
9453	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);	9454	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
9454		9455
		9456	int relevance1 = R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED;
		9457	int start1 = str.lastIndexOf("foo") + "".length();
		9458	int end1 = start1 + "foo".length();
		9459	int start2 = str.lastIndexOf("public class");
		9460	int end2 = start2 + "".length();
9455	assertResults(	9461	assertResults(
9456	"foo[FIELD_REF]{test.p.ZZZ.foo, Ltest.p.ZZZ;, I, foo, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED)+"}",	9462	"foo[FIELD_REF]{foo, Ltest.p.ZZZ;, I, foo, null, ["+start1+", "+end1+"], "+(relevance1)+"}\n" +
		9463	" foo[FIELD_IMPORT]{import static test.p.ZZZ.foo;\n, Ltest.p.ZZZ;, I, foo, null, ["+start2+", "+end2+"], " + (relevance1) + "}",
9457	requestor.getResults());	9464	requestor.getResults());
9458	}	9465	}
9459	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123	9466	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123
Lines 9475-9490 Link Here
9475	" public static int foo(){}\n" +	9482	" public static int foo(){}\n" +
9476	"}");	9483	"}");
9477		9484
9478	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);	9485	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
		9486	requestor.allowAllRequiredProposals();
9479	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.*"});	9487	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.*"});
9480		9488
9481	String str = this.workingCopies[0].getSource();	9489	String str = this.workingCopies[0].getSource();
9482	String completeBehind = "foo";	9490	String completeBehind = "foo";
9483	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();	9491	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
9484	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);	9492	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
9485		9493
		9494	int relevance1 = R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED;
		9495	int start1 = str.lastIndexOf("foo") + "".length();
		9496	int end1 = start1 + "foo".length();
		9497	int start2 = str.lastIndexOf("public class");
		9498	int end2 = start2 + "".length();
9486	assertResults(	9499	assertResults(
9487	"foo[METHOD_REF]{test.p.ZZZ.foo(), Ltest.p.ZZZ;, ()I, foo, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED)+"}",	9500	"foo[METHOD_REF]{foo(), Ltest.p.ZZZ;, ()I, foo, null, ["+start1+", "+end1+"], "+(relevance1)+"}\n" +
		9501	" foo[METHOD_IMPORT]{import static test.p.ZZZ.foo;\n, Ltest.p.ZZZ;, ()I, foo, null, ["+start2+", "+end2+"], " + (relevance1) + "}",
9488	requestor.getResults());	9502	requestor.getResults());
9489	}	9503	}
9490	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123	9504	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123
Lines 9506-9512 Link Here
9506	" public static int foo;\n" +	9520	" public static int foo;\n" +
9507	"}");	9521	"}");
9508		9522
9509	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);	9523	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
		9524	requestor.allowAllRequiredProposals();
9510	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ"});	9525	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ"});
9511		9526
9512	String str = this.workingCopies[0].getSource();	9527	String str = this.workingCopies[0].getSource();
Lines 9537-9543 Link Here
9537	" public static int foo(){}\n" +	9552	" public static int foo(){}\n" +
9538	"}");	9553	"}");
9539		9554
9540	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);	9555	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
		9556	requestor.allowAllRequiredProposals();
9541	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ"});	9557	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ"});
9542		9558
9543	String str = this.workingCopies[0].getSource();	9559	String str = this.workingCopies[0].getSource();
Lines 9568-9583 Link Here
9568	" public static int foo;\n" +	9584	" public static int foo;\n" +
9569	"}");	9585	"}");
9570		9586
9571	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);	9587	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
		9588	requestor.allowAllRequiredProposals();
9572	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.foo"});	9589	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.foo"});
9573		9590
9574	String str = this.workingCopies[0].getSource();	9591	String str = this.workingCopies[0].getSource();
9575	String completeBehind = "foo";	9592	String completeBehind = "foo";
9576	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();	9593	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
9577	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);	9594	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
9578		9595
		9596	int relevance1 = R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED;
		9597	int start1 = str.lastIndexOf("foo") + "".length();
		9598	int end1 = start1 + "foo".length();
		9599	int start2 = str.lastIndexOf("public class");
		9600	int end2 = start2 + "".length();
9579	assertResults(	9601	assertResults(
9580	"foo[FIELD_REF]{test.p.ZZZ.foo, Ltest.p.ZZZ;, I, foo, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED)+"}",	9602	"foo[FIELD_REF]{foo, Ltest.p.ZZZ;, I, foo, null, ["+start1+", "+end1+"], "+(relevance1)+"}\n" +
		9603	" foo[FIELD_IMPORT]{import static test.p.ZZZ.foo;\n, Ltest.p.ZZZ;, I, foo, null, ["+start2+", "+end2+"], " + (relevance1) + "}",
9581	requestor.getResults());	9604	requestor.getResults());
9582	}	9605	}
9583	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123	9606	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123
Lines 9599-9605 Link Here
9599	" public static int foo(){}\n" +	9622	" public static int foo(){}\n" +
9600	"}");	9623	"}");
9601		9624
9602	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);	9625	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
		9626	requestor.allowAllRequiredProposals();
9603	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.foo"});	9627	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.foo"});
9604		9628
9605	String str = this.workingCopies[0].getSource();	9629	String str = this.workingCopies[0].getSource();
Lines 9607-9614 Link Here
9607	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();	9631	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
9608	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);	9632	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
9609		9633
		9634	int relevance1 = R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED;
		9635	int start1 = str.lastIndexOf("foo") + "".length();
		9636	int end1 = start1 + "foo".length();
		9637	int start2 = str.lastIndexOf("public class");
		9638	int end2 = start2 + "".length();
9610	assertResults(	9639	assertResults(
9611	"foo[METHOD_REF]{test.p.ZZZ.foo(), Ltest.p.ZZZ;, ()I, foo, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED)+"}",	9640	"foo[METHOD_REF]{foo(), Ltest.p.ZZZ;, ()I, foo, null, ["+start1+", "+end1+"], "+(relevance1)+"}\n" +
		9641	" foo[METHOD_IMPORT]{import static test.p.ZZZ.foo;\n, Ltest.p.ZZZ;, ()I, foo, null, ["+start2+", "+end2+"], " + (relevance1) + "}",
9612	requestor.getResults());	9642	requestor.getResults());
9613	}	9643	}
9614	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123	9644	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123
Lines 9631-9637 Link Here
9631	" public static int foo(){}\n" +	9661	" public static int foo(){}\n" +
9632	"}");	9662	"}");
9633		9663
9634	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);	9664	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
		9665	requestor.allowAllRequiredProposals();
9635	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.*"});	9666	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.*"});
9636		9667
9637	String str = this.workingCopies[0].getSource();	9668	String str = this.workingCopies[0].getSource();
Lines 9639-9646 Link Here
9639	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();	9670	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
9640	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);	9671	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
9641		9672
		9673	int relevance1 = R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED;
		9674	int start1 = str.lastIndexOf("foo") + "".length();
		9675	int end1 = start1 + "foo".length();
		9676	int start2 = str.lastIndexOf("public class");
		9677	int end2 = start2 + "".length();
9642	assertResults(	9678	assertResults(
9643	"foo[METHOD_REF]{test.p.ZZZ.foo(), Ltest.p.ZZZ;, ()I, foo, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED)+"}",	9679	"foo[METHOD_REF]{foo(), Ltest.p.ZZZ;, ()I, foo, null, ["+start1+", "+end1+"], "+(relevance1)+"}\n" +
		9680	" foo[METHOD_IMPORT]{import static test.p.ZZZ.foo;\n, Ltest.p.ZZZ;, ()I, foo, null, ["+start2+", "+end2+"], " + (relevance1) + "}",
9644	requestor.getResults());	9681	requestor.getResults());
9645	}	9682	}
9646	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123	9683	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123
Lines 9663-9678 Link Here
9663	" public static int foo(){}\n" +	9700	" public static int foo(){}\n" +
9664	"}");	9701	"}");
9665		9702
9666	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);	9703	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
		9704	requestor.allowAllRequiredProposals();
9667	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.*"});	9705	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.*"});
9668		9706
9669	String str = this.workingCopies[0].getSource();	9707	String str = this.workingCopies[0].getSource();
9670	String completeBehind = "foo";	9708	String completeBehind = "foo";
9671	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();	9709	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
9672	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);	9710	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
9673		9711
		9712	int start1 = str.lastIndexOf("foo") + "".length();
		9713	int end1 = start1 + "foo".length();
9674	assertResults(	9714	assertResults(
9675	"foo[METHOD_REF]{foo(), Ltest.p.ZZZ;, ()I, foo, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_UNQUALIFIED +R_NON_RESTRICTED)+"}",	9715	"foo[METHOD_REF]{foo(), Ltest.p.ZZZ;, ()I, foo, null, ["+start1+", "+end1+"], "+(R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_UNQUALIFIED +R_NON_RESTRICTED)+"}",
9676	requestor.getResults());	9716	requestor.getResults());
9677	}	9717	}
9678	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123	9718	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123
Lines 9695-9701 Link Here
9695	" public static int foo(){}\n" +	9735	" public static int foo(){}\n" +
9696	"}");	9736	"}");
9697		9737
9698	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);	9738	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
		9739	requestor.allowAllRequiredProposals();
9699	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.foo"});	9740	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.foo"});
9700		9741
9701	String str = this.workingCopies[0].getSource();	9742	String str = this.workingCopies[0].getSource();
Lines 9703-9710 Link Here
9703	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();	9744	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
9704	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);	9745	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
9705		9746
		9747	int relevance1 = R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED;
		9748	int start1 = str.lastIndexOf("foo") + "".length();
		9749	int end1 = start1 + "foo".length();
		9750	int start2 = str.lastIndexOf("public class");
		9751	int end2 = start2 + "".length();
9706	assertResults(	9752	assertResults(
9707	"foo[METHOD_REF]{test.p.ZZZ.foo(), Ltest.p.ZZZ;, ()I, foo, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED)+"}",	9753	"foo[METHOD_REF]{foo(), Ltest.p.ZZZ;, ()I, foo, null, ["+start1+", "+end1+"], "+(relevance1)+"}\n" +
		9754	" foo[METHOD_IMPORT]{import static test.p.ZZZ.foo;\n, Ltest.p.ZZZ;, ()I, foo, null, ["+start2+", "+end2+"], " + (relevance1) + "}",
9708	requestor.getResults());	9755	requestor.getResults());
9709	}	9756	}
9710	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123	9757	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123
Lines 9727-9733 Link Here
9727	" public static int foo(){}\n" +	9774	" public static int foo(){}\n" +
9728	"}");	9775	"}");
9729		9776
9730	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);	9777	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
		9778	requestor.allowAllRequiredProposals();
9731	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.foo"});	9779	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.foo"});
9732		9780
9733	String str = this.workingCopies[0].getSource();	9781	String str = this.workingCopies[0].getSource();
Lines 9735-9742 Link Here
9735	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();	9783	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
9736	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);	9784	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
9737		9785
		9786	int start1 = str.lastIndexOf("foo") + "".length();
		9787	int end1 = start1 + "foo".length();
9738	assertResults(	9788	assertResults(
9739	"foo[METHOD_REF]{foo(), Ltest.p.ZZZ;, ()I, foo, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_UNQUALIFIED + R_NON_RESTRICTED)+"}",	9789	"foo[METHOD_REF]{foo(), Ltest.p.ZZZ;, ()I, foo, null, ["+start1+", "+end1+"], "+(R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_UNQUALIFIED +R_NON_RESTRICTED)+"}",
9740	requestor.getResults());	9790	requestor.getResults());
9741	}	9791	}
9742	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123	9792	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123
Lines 9759-9765 Link Here
9759	" public static int foo(){}\n" +	9809	" public static int foo(){}\n" +
9760	"}");	9810	"}");
9761		9811
9762	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);	9812	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
		9813	requestor.allowAllRequiredProposals();
9763	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.*"});	9814	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.*"});
9764		9815
9765	String str = this.workingCopies[0].getSource();	9816	String str = this.workingCopies[0].getSource();
Lines 9767-9774 Link Here
9767	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();	9818	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
9768	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);	9819	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
9769		9820
		9821	int relevance1 = R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED;
		9822	int start1 = str.lastIndexOf("foo") + "".length();
		9823	int end1 = start1 + "foo".length();
		9824	int start2 = str.lastIndexOf("public class");
		9825	int end2 = start2 + "".length();
9770	assertResults(	9826	assertResults(
9771	"foo[METHOD_REF]{test.p.ZZZ.foo(), Ltest.p.ZZZ;, ()I, foo, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED)+"}",	9827	"foo[METHOD_REF]{foo(), Ltest.p.ZZZ;, ()I, foo, null, ["+start1+", "+end1+"], "+(relevance1)+"}\n" +
		9828	" foo[METHOD_IMPORT]{import static test.p.ZZZ.foo;\n, Ltest.p.ZZZ;, ()I, foo, null, ["+start2+", "+end2+"], " + (relevance1) + "}",
9772	requestor.getResults());	9829	requestor.getResults());
9773	}	9830	}
9774	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123	9831	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123
Lines 9791-9797 Link Here
9791	" public static int foo(){}\n" +	9848	" public static int foo(){}\n" +
9792	"}");	9849	"}");
9793		9850
9794	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);	9851	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
		9852	requestor.allowAllRequiredProposals();
9795	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.*"});	9853	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.*"});
9796		9854
9797	String str = this.workingCopies[0].getSource();	9855	String str = this.workingCopies[0].getSource();
Lines 9799-9806 Link Here
9799	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();	9857	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
9800	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);	9858	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
9801		9859
		9860	int start1 = str.lastIndexOf("foo") + "".length();
		9861	int end1 = start1 + "foo".length();
9802	assertResults(	9862	assertResults(
9803	"foo[METHOD_REF]{foo(), Ltest.p.ZZZ;, ()I, foo, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_UNQUALIFIED + R_NON_RESTRICTED)+"}",	9863	"foo[METHOD_REF]{foo(), Ltest.p.ZZZ;, ()I, foo, null, ["+start1+", "+end1+"], "+(R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_UNQUALIFIED +R_NON_RESTRICTED)+"}",
9804	requestor.getResults());	9864	requestor.getResults());
9805	}	9865	}
9806	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123	9866	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123
Lines 9823-9829 Link Here
9823	" public static int foo(){}\n" +	9883	" public static int foo(){}\n" +
9824	"}");	9884	"}");
9825		9885
9826	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);	9886	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
		9887	requestor.allowAllRequiredProposals();
9827	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.foo"});	9888	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.foo"});
9828		9889
9829	String str = this.workingCopies[0].getSource();	9890	String str = this.workingCopies[0].getSource();
Lines 9831-9838 Link Here
9831	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();	9892	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
9832	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);	9893	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
9833		9894
		9895	int relevance1 = R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED;
		9896	int start1 = str.lastIndexOf("foo") + "".length();
		9897	int end1 = start1 + "foo".length();
		9898	int start2 = str.lastIndexOf("public class");
		9899	int end2 = start2 + "".length();
9834	assertResults(	9900	assertResults(
9835	"foo[METHOD_REF]{test.p.ZZZ.foo(), Ltest.p.ZZZ;, ()I, foo, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED)+"}",	9901	"foo[METHOD_REF]{foo(), Ltest.p.ZZZ;, ()I, foo, null, ["+start1+", "+end1+"], "+(relevance1)+"}\n" +
		9902	" foo[METHOD_IMPORT]{import static test.p.ZZZ.foo;\n, Ltest.p.ZZZ;, ()I, foo, null, ["+start2+", "+end2+"], " + (relevance1) + "}",
9836	requestor.getResults());	9903	requestor.getResults());
9837	}	9904	}
9838	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123	9905	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123
Lines 9855-9861 Link Here
9855	" public static int foo(){}\n" +	9922	" public static int foo(){}\n" +
9856	"}");	9923	"}");
9857		9924
9858	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);	9925	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
		9926	requestor.allowAllRequiredProposals();
9859	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.foo"});	9927	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.foo"});
9860		9928
9861	String str = this.workingCopies[0].getSource();	9929	String str = this.workingCopies[0].getSource();
Lines 9863-9870 Link Here
9863	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();	9931	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
9864	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);	9932	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
9865		9933
		9934	int start1 = str.lastIndexOf("foo") + "".length();
		9935	int end1 = start1 + "foo".length();
9866	assertResults(	9936	assertResults(
9867	"foo[METHOD_REF]{foo(), Ltest.p.ZZZ;, ()I, foo, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_UNQUALIFIED + R_NON_RESTRICTED)+"}",	9937	"foo[METHOD_REF]{foo(), Ltest.p.ZZZ;, ()I, foo, null, ["+start1+", "+end1+"], "+(R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_UNQUALIFIED +R_NON_RESTRICTED)+"}",
9868	requestor.getResults());	9938	requestor.getResults());
9869	}	9939	}
9870	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123	9940	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123
Lines 9894-9900 Link Here
9894	" public static int foo(){}\n" +	9964	" public static int foo(){}\n" +
9895	"}");	9965	"}");
9896		9966
9897	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);	9967	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
		9968	requestor.allowAllRequiredProposals();
9898	requestor.setFavoriteReferences(new String[]{"test.q.ZZZ2.foo"});	9969	requestor.setFavoriteReferences(new String[]{"test.q.ZZZ2.foo"});
9899		9970
9900	String str = this.workingCopies[0].getSource();	9971	String str = this.workingCopies[0].getSource();
Lines 9902-9910 Link Here
9902	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();	9973	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
9903	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);	9974	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
9904		9975
		9976	int start1 = str.lastIndexOf("foo") + "".length();
		9977	int end1 = start1 + "foo".length();
9905	assertResults(	9978	assertResults(
9906	"foo[METHOD_REF]{test.q.ZZZ2.foo(), Ltest.q.ZZZ2;, ()I, foo, null, " + (R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED) + "}\n" +	9979	"foo[METHOD_REF]{foo(), Ltest.p.ZZZ;, ()I, foo, null, ["+start1+", "+end1+"], " + (R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_UNQUALIFIED + R_NON_RESTRICTED) + "}",
9907	"foo[METHOD_REF]{foo(), Ltest.p.ZZZ;, ()I, foo, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_UNQUALIFIED + R_NON_RESTRICTED)+"}",
9908	requestor.getResults());	9980	requestor.getResults());
9909	}	9981	}
9910	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123	9982	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123
Lines 9928-9944 Link Here
9928	" public static int foo(){}\n" +	10000	" public static int foo(){}\n" +
9929	"}");	10001	"}");
9930		10002
9931	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);	10003	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
		10004	requestor.allowAllRequiredProposals();
9932	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.*"});	10005	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.*"});
9933		10006
9934	String str = this.workingCopies[0].getSource();	10007	String str = this.workingCopies[0].getSource();
9935	String completeBehind = "foo";	10008	String completeBehind = "foo";
9936	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();	10009	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
9937	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);	10010	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
9938		10011
9939	assertResults(	10012	int relevance1 = R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED;
9940	"foo[METHOD_REF]{test.p.ZZZ.foo(), Ltest.p.ZZZ;, ()I, foo, null, " + (R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED) + "}\n" +	10013	int start1 = str.lastIndexOf("foo") + "".length();
9941	"Test.foo[TYPE_REF]{foo, test, Ltest.Test$foo;, null, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_UNQUALIFIED + R_NON_RESTRICTED)+"}",	10014	int end1 = start1 + "foo".length();
		10015	int start2 = str.lastIndexOf("public class Test");
		10016	int end2 = start2 + "".length();
		10017	assertResults(
		10018	"foo[METHOD_REF]{foo(), Ltest.p.ZZZ;, ()I, foo, null, ["+start1+", "+end1+"], " + (relevance1) + "}\n" +
		10019	" foo[METHOD_IMPORT]{import static test.p.ZZZ.foo;\n, Ltest.p.ZZZ;, ()I, foo, null, ["+start2+", "+end2+"], " + (relevance1) + "}\n" +
		10020	"Test.foo[TYPE_REF]{foo, test, Ltest.Test$foo;, null, null, ["+start1+", "+end1+"], "+(R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_UNQUALIFIED + R_NON_RESTRICTED)+"}",
9942	requestor.getResults());	10021	requestor.getResults());
9943	}	10022	}
9944	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123	10023	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123
Lines 9960-9966 Link Here
9960	" public static int foo(){}\n" +	10039	" public static int foo(){}\n" +
9961	"}");	10040	"}");
9962		10041
9963	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);	10042	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
		10043	requestor.allowAllRequiredProposals();
9964	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.*"});	10044	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.*"});
9965		10045
9966	String str = this.workingCopies[0].getSource();	10046	String str = this.workingCopies[0].getSource();
Lines 9968-9976 Link Here
9968	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();	10048	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
9969	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);	10049	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
9970		10050
		10051	int start1 = str.lastIndexOf("foo") + "".length();
		10052	int end1 = start1 + "foo".length();
9971	assertResults(	10053	assertResults(
9972	"foo[METHOD_REF]{test.p.ZZZ.foo(), Ltest.p.ZZZ;, ()I, foo, null, " + (R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED) + "}\n" +	10054	"foo[METHOD_REF]{foo(), Ltest.Test;, ()V, foo, null, ["+start1+", "+end1+"], "+(R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_UNQUALIFIED + R_NON_RESTRICTED)+"}",
9973	"foo[METHOD_REF]{foo(), Ltest.Test;, ()V, foo, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_UNQUALIFIED + R_NON_RESTRICTED)+"}",
9974	requestor.getResults());	10055	requestor.getResults());
9975	}	10056	}
9976	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123	10057	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123
Lines 9993-9999 Link Here
9993	" public static int foo(){}\n" +	10074	" public static int foo(){}\n" +
9994	"}");	10075	"}");
9995		10076
9996	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);	10077	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
		10078	requestor.allowAllRequiredProposals();
9997	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.*"});	10079	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.*"});
9998		10080
9999	String str = this.workingCopies[0].getSource();	10081	String str = this.workingCopies[0].getSource();
Lines 10001-10009 Link Here
10001	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();	10083	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
10002	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);	10084	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
10003		10085
10004	assertResults(	10086	int relevance1 = R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED;
10005	"foo[METHOD_REF]{test.p.ZZZ.foo(), Ltest.p.ZZZ;, ()I, foo, null, " + (R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED) + "}\n" +	10087	int start1 = str.lastIndexOf("foo") + "".length();
10006	"foo[FIELD_REF]{foo, Ltest.Test;, I, foo, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_UNQUALIFIED + R_NON_RESTRICTED)+"}",	10088	int end1 = start1 + "foo".length();
		10089	int start2 = str.lastIndexOf("public class");
		10090	int end2 = start2 + "".length();
		10091	assertResults(
		10092	"foo[METHOD_REF]{foo(), Ltest.p.ZZZ;, ()I, foo, null, ["+start1+", "+end1+"], "+(relevance1)+"}\n" +
		10093	" foo[METHOD_IMPORT]{import static test.p.ZZZ.foo;\n, Ltest.p.ZZZ;, ()I, foo, null, ["+start2+", "+end2+"], " + (relevance1) + "}\n"+
		10094	"foo[FIELD_REF]{foo, Ltest.Test;, I, foo, null, ["+start1+", "+end1+"], " + (R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_UNQUALIFIED + R_NON_RESTRICTED) + "}",
10007	requestor.getResults());	10095	requestor.getResults());
10008	}	10096	}
10009	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123	10097	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123
Lines 10026-10032 Link Here
10026	" public static int foo(){}\n" +	10114	" public static int foo(){}\n" +
10027	"}");	10115	"}");
10028		10116
10029	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);	10117	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
		10118	requestor.allowAllRequiredProposals();
10030	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.*"});	10119	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.*"});
10031		10120
10032	String str = this.workingCopies[0].getSource();	10121	String str = this.workingCopies[0].getSource();
Lines 10034-10042 Link Here
10034	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();	10123	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
10035	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);	10124	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
10036		10125
10037	assertResults(	10126	int relevance1 = R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED;
10038	"foo[METHOD_REF]{test.p.ZZZ.foo(), Ltest.p.ZZZ;, ()I, foo, null, " + (R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED) + "}\n" +	10127	int start1 = str.lastIndexOf("foo") + "".length();
10039	"foo[LOCAL_VARIABLE_REF]{foo, null, I, foo, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_UNQUALIFIED + R_NON_RESTRICTED)+"}",	10128	int end1 = start1 + "foo".length();
		10129	int start2 = str.lastIndexOf("public class");
		10130	int end2 = start2 + "".length();
		10131	assertResults(
		10132	"foo[METHOD_REF]{foo(), Ltest.p.ZZZ;, ()I, foo, null, ["+start1+", "+end1+"], "+(relevance1)+"}\n" +
		10133	" foo[METHOD_IMPORT]{import static test.p.ZZZ.foo;\n, Ltest.p.ZZZ;, ()I, foo, null, ["+start2+", "+end2+"], " + (relevance1) + "}\n"+
		10134	"foo[LOCAL_VARIABLE_REF]{foo, null, I, foo, null, ["+start1+", "+end1+"], "+(R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_UNQUALIFIED + R_NON_RESTRICTED)+"}",
10040	requestor.getResults());	10135	requestor.getResults());
10041	}	10136	}
10042	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123	10137	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123
Lines 10059-10065 Link Here
10059	" public static int foo(int i){}\n" +	10154	" public static int foo(int i){}\n" +
10060	"}");	10155	"}");
10061		10156
10062	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);	10157	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
		10158	requestor.allowAllRequiredProposals();
10063	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.foo"});	10159	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.foo"});
10064		10160
10065	String str = this.workingCopies[0].getSource();	10161	String str = this.workingCopies[0].getSource();
Lines 10067-10075 Link Here
10067	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();	10163	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
10068	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);	10164	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
10069		10165
10070	assertResults(	10166	int relevance1 = R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED;
10071	"foo[METHOD_REF]{test.p.ZZZ.foo(), Ltest.p.ZZZ;, ()I, foo, null, " + (R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED) + "}\n" +	10167	int start1 = str.lastIndexOf("foo") + "".length();
10072	"foo[METHOD_REF]{test.p.ZZZ.foo(), Ltest.p.ZZZ;, (I)I, foo, (i), "+(R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED)+"}",	10168	int end1 = start1 + "foo".length();
		10169	int start2 = str.lastIndexOf("public class");
		10170	int end2 = start2 + "".length();
		10171	assertResults(
		10172	"foo[METHOD_REF]{foo(), Ltest.p.ZZZ;, ()I, foo, null, ["+start1+", "+end1+"], "+(relevance1)+"}\n" +
		10173	" foo[METHOD_IMPORT]{import static test.p.ZZZ.foo;\n, Ltest.p.ZZZ;, ()I, foo, null, ["+start2+", "+end2+"], " + (relevance1) + "}\n"+
		10174	"foo[METHOD_REF]{foo(), Ltest.p.ZZZ;, (I)I, foo, (i), ["+start1+", "+end1+"], "+(relevance1)+"}\n" +
		10175	" foo[METHOD_IMPORT]{import static test.p.ZZZ.foo;\n, Ltest.p.ZZZ;, (I)I, foo, (i), ["+start2+", "+end2+"], " + (relevance1) + "}",
10073	requestor.getResults());	10176	requestor.getResults());
10074	}	10177	}
10075	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123	10178	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123
Lines 10091-10097 Link Here
10091	" public static <T> int foo(){}\n" +	10194	" public static <T> int foo(){}\n" +
10092	"}");	10195	"}");
10093		10196
10094	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);	10197	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
		10198	requestor.allowAllRequiredProposals();
10095	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.foo"});	10199	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.foo"});
10096		10200
10097	String str = this.workingCopies[0].getSource();	10201	String str = this.workingCopies[0].getSource();
Lines 10099-10106 Link Here
10099	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();	10203	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
10100	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);	10204	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
10101		10205
		10206	int relevance1 = R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED;
		10207	int start1 = str.lastIndexOf("foo") + "".length();
		10208	int end1 = start1 + "foo".length();
		10209	int start2 = str.lastIndexOf("public class");
		10210	int end2 = start2 + "".length();
10102	assertResults(	10211	assertResults(
10103	"foo[METHOD_REF]{test.p.ZZZ.foo(), Ltest.p.ZZZ;, <T:Ljava.lang.Object;>()I, foo, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED)+"}",	10212	"foo[METHOD_REF]{foo(), Ltest.p.ZZZ;, <T:Ljava.lang.Object;>()I, foo, null, ["+start1+", "+end1+"], "+(relevance1)+"}\n" +
		10213	" foo[METHOD_IMPORT]{import static test.p.ZZZ.foo;\n, Ltest.p.ZZZ;, <T:Ljava.lang.Object;>()I, foo, null, ["+start2+", "+end2+"], " + (relevance1) + "}",
10104	requestor.getResults());	10214	requestor.getResults());
10105	}	10215	}
10106	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123	10216	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123
Lines 10122-10128 Link Here
10122	" public static int foo(){}\n" +	10232	" public static int foo(){}\n" +
10123	"}");	10233	"}");
10124		10234
10125	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true);	10235	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
		10236	requestor.allowAllRequiredProposals();
10126	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.foo"});	10237	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.foo"});
10127		10238
10128	String str = this.workingCopies[0].getSource();	10239	String str = this.workingCopies[0].getSource();
Lines 10134-10137 Link Here
10134	"",	10245	"",
10135	requestor.getResults());	10246	requestor.getResults());
10136	}	10247	}
		10248	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123
		10249	public void testFavoriteImports023() throws JavaModelException {
		10250	this.workingCopies = new ICompilationUnit[2];
		10251	this.workingCopies[0] = getWorkingCopy(
		10252	"/Completion/src3/test/Test.java",
		10253	"package test;\n" +
		10254	"/** */\n" +
		10255	"public class Test {\n" +
		10256	" public void method() {\n" +
		10257	" foo\n" +
		10258	" }\n" +
		10259	"}");
		10260
		10261	this.workingCopies[1] = getWorkingCopy(
		10262	"/Completion/src3/test/p/ZZZ.java",
		10263	"package test.p;\n" +
		10264	"public class ZZZ {\n" +
		10265	" public static int foo;\n" +
		10266	"}");
		10267
		10268	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
		10269	requestor.allowAllRequiredProposals();
		10270	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.*"});
		10271
		10272	String str = this.workingCopies[0].getSource();
		10273	String completeBehind = "foo";
		10274	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
		10275	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
		10276
		10277	int relevance1 = R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED;
		10278	int start1 = str.lastIndexOf("foo") + "".length();
		10279	int end1 = start1 + "foo".length();
		10280	int start2 = str.lastIndexOf("/** */");
		10281	int end2 = start2 + "".length();
		10282	assertResults(
		10283	"foo[FIELD_REF]{foo, Ltest.p.ZZZ;, I, foo, null, ["+start1+", "+end1+"], "+(relevance1)+"}\n" +
		10284	" foo[FIELD_IMPORT]{import static test.p.ZZZ.foo;\n, Ltest.p.ZZZ;, I, foo, null, ["+start2+", "+end2+"], " + (relevance1) + "}",
		10285	requestor.getResults());
		10286	}
		10287	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123
		10288	public void testFavoriteImports024() throws JavaModelException {
		10289	this.workingCopies = new ICompilationUnit[2];
		10290	this.workingCopies[0] = getWorkingCopy(
		10291	"/Completion/src3/test/Test.java",
		10292	"package test;\n" +
		10293	"public class Test {\n" +
		10294	" public void method() {\n" +
		10295	" foo\n" +
		10296	" }\n" +
		10297	"}");
		10298
		10299	this.workingCopies[1] = getWorkingCopy(
		10300	"/Completion/src3/test/p/ZZZ.java",
		10301	"package test.p;\n" +
		10302	"public class ZZZ {\n" +
		10303	" public int foo;\n" +
		10304	"}");
		10305
		10306	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
		10307	requestor.allowAllRequiredProposals();
		10308	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.*"});
		10309
		10310	String str = this.workingCopies[0].getSource();
		10311	String completeBehind = "foo";
10312	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
10313	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
10314
10315	assertResults(
10316	"",
10317	requestor.getResults());
10318	}
10319	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123
10320	public void testFavoriteImports025() throws JavaModelException {
10321	this.workingCopies = new ICompilationUnit[2];
10322	this.workingCopies[0] = getWorkingCopy(
10323	"/Completion/src3/test/Test.java",
10324	"package test;\n" +
10325	"public class Test {\n" +
10326	" public void method() {\n" +
10327	" foo\n" +
10328	" }\n" +
10329	"}");
10330
10331	this.workingCopies[1] = getWorkingCopy(
10332	"/Completion/src3/test/p/ZZZ.java",
10333	"package test.p;\n" +
10334	"public class ZZZ {\n" +
10335	" public int foo;\n" +
10336	"}");
10337
10338	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
10339	requestor.allowAllRequiredProposals();
10340	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.foo"});
10341
10342	String str = this.workingCopies[0].getSource();
10343	String completeBehind = "foo";
10344	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
10345	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
10346
10347	assertResults(
10348	"",
10349	requestor.getResults());
10350	}
10351	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123
10352	public void testFavoriteImports026() throws JavaModelException {
10353	this.workingCopies = new ICompilationUnit[2];
10354	this.workingCopies[0] = getWorkingCopy(
10355	"/Completion/src3/test/Test.java",
10356	"package test;\n" +
10357	"public class Test {\n" +
10358	" public void method() {\n" +
10359	" foo\n" +
10360	" }\n" +
10361	"}");
10362
10363	this.workingCopies[1] = getWorkingCopy(
10364	"/Completion/src3/test/p/ZZZ.java",
10365	"package test.p;\n" +
10366	"public class ZZZ {\n" +
10367	" public int foo(){return 0;};\n" +
10368	"}");
10369
10370	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
10371	requestor.allowAllRequiredProposals();
10372	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.*"});
10373
10374	String str = this.workingCopies[0].getSource();
10375	String completeBehind = "foo";
10376	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
10377	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
10378
10379	assertResults(
10380	"",
10381	requestor.getResults());
10382	}
10383	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123
10384	public void testFavoriteImports027() throws JavaModelException {
10385	this.workingCopies = new ICompilationUnit[2];
10386	this.workingCopies[0] = getWorkingCopy(
10387	"/Completion/src3/test/Test.java",
10388	"package test;\n" +
10389	"public class Test {\n" +
10390	" public void method() {\n" +
10391	" foo\n" +
10392	" }\n" +
10393	"}");
10394
10395	this.workingCopies[1] = getWorkingCopy(
10396	"/Completion/src3/test/p/ZZZ.java",
10397	"package test.p;\n" +
10398	"public class ZZZ {\n" +
10399	" public int foo(){return 0;};\n" +
10400	"}");
10401
10402	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
10403	requestor.allowAllRequiredProposals();
10404	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.foo"});
10405
10406	String str = this.workingCopies[0].getSource();
10407	String completeBehind = "foo";
10408	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
10409	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
10410
10411	assertResults(
10412	"",
10413	requestor.getResults());
10414	}
10415	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=152123
10416	public void testFavoriteImports029() throws JavaModelException {
10417	this.workingCopies = new ICompilationUnit[2];
10418	this.workingCopies[0] = getWorkingCopy(
10419	"/Completion/src3/test/Test.java",
10420	"package test;\n" +
10421	"import test.p.ZZZ;\n" +
10422	"public class Test {\n" +
10423	" public void method() {\n" +
10424	" foo\n" +
10425	" }\n" +
10426	"}");
10427
10428	this.workingCopies[1] = getWorkingCopy(
10429	"/Completion/src3/test/p/ZZZ.java",
10430	"package test.p;\n" +
10431	"public class ZZZ {\n" +
10432	" public static int foo(){return 0;};\n" +
10433	"}");
10434
10435	CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2(true, false, true, false, true);
10436	requestor.allowAllRequiredProposals();
10437	requestor.setFavoriteReferences(new String[]{"test.p.ZZZ.foo"});
10438
10439	String str = this.workingCopies[0].getSource();
10440	String completeBehind = "foo";
10441	int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
10442	this.workingCopies[0].codeComplete(cursorLocation, requestor, this.wcOwner);
10443
10444	int relevance1 = R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED;
10445	int start1 = str.lastIndexOf("foo") + "".length();
10446	int end1 = start1 + "foo".length();
10447	int start2 = str.lastIndexOf("public class");
10448	int end2 = start2 + "".length();
10449	assertResults(
10450	"foo[METHOD_REF]{foo(), Ltest.p.ZZZ;, ()I, foo, null, ["+start1+", "+end1+"], "+(relevance1)+"}\n" +
10451	" foo[METHOD_IMPORT]{import static test.p.ZZZ.foo;\n, Ltest.p.ZZZ;, ()I, foo, null, ["+start2+", "+end2+"], " + (relevance1) + "}",
10452	requestor.getResults());
10453	}
10137	}	10454	}

Return to bug 152123

Added Link Here

(-)model/org/eclipse/jdt/core/CompletionFlags.java (+51 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 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.core;
12
13	/**
14	* Utility class for decoding additional flags in completion proposal.
15	* <p>
16	* This class provides static methods only; it is not intended to be
17	* instantiated or subclassed by clients.
18	* </p>
19	*
20	* @see CompletionProposal#getAdditionalFlags()
21	*
22	* @since 3.3
23	*/
24	public final class CompletionFlags {
25	/**
26	* Constant representing the absence of any flag
27	*/
28	public static final int Default = 0x0000;
29
30	/**
31	* Constant representing a static import
32	*/
33	public static final int StaticImport = 0x0001;
34
35	/**
36	* Not instantiable.
37	*/
38	private CompletionFlags() {
39	// Not instantiable
40	}
41
42	/**
43	* Returns whether the given integer includes the {@link #StaticImport} flag.
44	*
45	* @param flags the flags
46	* @return <code>true</code> if the {@link #StaticImport} flag is included
47	*/
48	public static boolean isStaticImport(int flags) {
49	return (flags & StaticImport) != 0;
50	}
51	}