Attachment #199775 for bug #352160

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.wst.jsdt.core.compiler.CharOperation;
import org.eclipse.wst.jsdt.internal.codeassist.InternalCompletionProposal;
import org.eclipse.wst.jsdt.internal.core.util.QualificationHelpers;

/**
 * Completion proposal.

//		return this.declarationPackageName;
//	}
//
	/**
	 * Returns the type name of the relevant
	 * declaration in the context without the package fragment,
	 * or <code>null</code> if none.
	 * <p>
	 * This field is available for the following kinds of
	 * completion proposals:
	 * <ul>
	 * <li><code>ANONYMOUS_CLASS_DECLARATION</code> - the dot-based type name
	 * of the type that is being subclassed or implemented</li>
	 * 	<li><code>FIELD_REF</code> - the dot-based type name
	 * of the type that declares the field that is referenced
	 * or an anonymous type instantiation ("new X(){}") if it is an anonymous type</li>
	 * 	<li><code>FUNCTION_REF</code> - the dot-based type name
	 * of the type that declares the method that is referenced
	 * or an anonymous type instantiation ("new X(){}") if it is an anonymous type</li>
	 * 	<li><code>FUNCTION_DECLARATION</code> - the dot-based type name
	 * of the type that declares the method that is being
	 * implemented or overridden</li>
	 * </ul>
	 * For kinds of completion proposals, this method returns
	 * <code>null</code>. Clients must not modify the array
	 * returned.
	 * </p>
	 *
	 * @return the dot-based package name, or
	 * <code>null</code> if none
	 * @see #getDeclarationSignature()
	 * @see #getSignature()
	 *
	 */
	public char[] getDeclarationTypeName() {
		return this.declarationTypeName;
	}

	public char[][] getParameterTypeNames() {
		return this.parameterTypeNames;
	}
	
	public char[] getReturnType() {
		return QualificationHelpers.createFullyQualifiedName(this.getReturnQualification(), this.getReturnSimpleName());
	}

	/**
	 * Returns the accessibility of the proposal.




	int size = length - 1;
	int index = length;
	while (--index >= 0) {
		if ((array[index] == null || array[index].length == 0) && ignoreEmptyElements) {
			size--;
		} else {
			size += array[index] != null ? array[index].length : 0;
		}
	}
	if (size <= 0)
		return CharOperation.NO_CHAR;
	char[] result = new char[size];
	index = length;
	while (--index >= 0) {
		length = array[index] != null ? array[index].length : 0;
		if (length > 0 || (length == 0 && !ignoreEmptyElements)) {
			System.arraycopy(
				array[index] != null ? array[index] : NO_CHAR,
				0,
				result,
				(size -= length),




				findReferences,
				isFunction,
				selectorChars,
				declaringTypeQualification,
				declaringTypeSimpleName,
				declaringTypeSignature,
				returnTypeQualification,
				returnTypeSimpleName,
				returnTypeSignature,
				parameterTypeQualifications,
				parameterTypeSimpleNames,
				returnTypeQualification,
				returnTypeSimpleName,
				declaringTypeQualification,
				declaringTypeSimpleName,
				matchRule);
	}
}

						findMethodReferences,
						isFunction,
						selector,
						declaringQualification,
						declaringSimpleName,
						returnQualification,
						returnSimpleName,
						returnSignature,
						parameterQualifications,
						parameterSimpleNames,
						returnQualification,
						returnSimpleName,
						declaringQualification,
						declaringSimpleName,
						matchRule);
			}
			break;




import org.eclipse.wst.jsdt.internal.core.SourceMethodElementInfo;
import org.eclipse.wst.jsdt.internal.core.SourceType;
import org.eclipse.wst.jsdt.internal.core.SourceTypeElementInfo;
import org.eclipse.wst.jsdt.internal.core.util.QualificationHelpers;
import org.eclipse.wst.jsdt.internal.oaametadata.ClassData;
import org.eclipse.wst.jsdt.internal.oaametadata.Method;


	}
	
	/**
	 * @see org.eclipse.wst.jsdt.internal.codeassist.ISearchRequestor#acceptFunction(char[], int, char[][], char[][], char[][], char[], char[], char[], char[], int, java.lang.String)
	 */
	public void acceptFunction(char[] signature, int parameterCount,
			char[][] parameterQualifications, char[][] parameterSimpleNames,
			char[][] parameterNames, char[] returnQualification,
			char[] returnSimpleName, char[] declaringQualification,
			char[] declaringSimpleName, int modifiers, String path) {
		
		this.proposeFunction(signature, parameterCount, parameterQualifications, parameterSimpleNames, parameterNames,
				returnQualification, returnSimpleName, declaringQualification, declaringSimpleName, modifiers, path);
	}
	
	/**
	 * @see org.eclipse.wst.jsdt.internal.codeassist.ISearchRequestor#acceptConstructor(
	 * 		int, char[], int, char[][], char[][], java.lang.String, org.eclipse.wst.jsdt.internal.compiler.env.AccessRestriction)
	 */

		if(!CompletionEngine.this.requestor.isIgnored(CompletionProposal.LOCAL_VARIABLE_REF)) {
			CompletionProposal proposal = CompletionEngine.this.createProposal(CompletionProposal.LOCAL_VARIABLE_REF, CompletionEngine.this.actualCompletionPosition);
			proposal.setSignature(JAVA_LANG_OBJECT_SIGNATURE);
			proposal.setReturnQualification(JAVA_LANG_NAME);
			proposal.setReturnSimpleName(OBJECT);
			proposal.setName(name);
			proposal.setCompletion(name);
			proposal.setFlags(Flags.AccDefault);

	 * @param name the name of the binding
	 * @param exactMatch <code>true</code> if an exact match is needed, <code>false</code> otherwise
	 * @param prefixRequired
	 * @param onlyConstructors <code>true</code> if only constructors should be accepted,
	 * <code>false</code> otherwise.  Only applies when matching on {@link Binding#METHOD}s.
	 */
	private void acceptBindings(char[] name,boolean exactMatch, boolean prefixRequired) {
		

						proposal.setParameterTypeNames(parameterFullTypeNames);

						if(method.returnType!=null) {
							proposal.setReturnQualification(method.returnType.qualifiedPackageName());
							proposal.setReturnSimpleName(method.returnType.qualifiedSourceName());
						}else {
							proposal.setReturnSimpleName(null);
						}



						proposal.setDeclarationTypeName(method.declaringClass.qualifiedSourceName());
						proposal.setParameterPackageNames(parameterPackageNames);
						proposal.setParameterTypeNames(parameterFullTypeNames);
						proposal.setReturnQualification(method.returnType.qualifiedPackageName());
						proposal.setReturnSimpleName(method.returnType.qualifiedSourceName());
						proposal.setName(bindingName);
						proposal.setCompletion(javadocCompletion);
						proposal.setFlags( modifiers);

					}
					proposal.setSignature(getSignature(variableBinding.type));
					proposal.setDeclarationTypeName(packageName);
					proposal.setReturnQualification(variableBinding.type.qualifiedPackageName());
					proposal.setReturnSimpleName(variableBinding.type.qualifiedSourceName());
					proposal.setName(variableBinding.name);
					proposal.setCompletion(completion);
					proposal.setFlags(variableBinding.modifiers);

					CompletionProposal proposal = this.createProposal(CompletionProposal.JSDOC_FIELD_REF, this.actualCompletionPosition);
					proposal.setSignature(getSignature(variableBinding.type));
					proposal.setDeclarationPackageName(packageName);
					proposal.setReturnQualification(variableBinding.type.qualifiedPackageName());
					proposal.setReturnSimpleName(variableBinding.type.qualifiedSourceName());
					proposal.setName(variableBinding.name);
					proposal.setCompletion(javadocCompletion);
					proposal.setFlags(variableBinding.modifiers);

			long completionPosition = access.nameSourcePosition;
			setSourceRange((int) (completionPosition >>> 32), (int) completionPosition);



//			this.assistNodeIsClass = true;
//			this.assistNodeIsConstructor = true;

			// can be the start of a qualified type name
			if (qualifiedBinding == null) {
			

			} else {
				this.completionToken = access.token;
				if (qualifiedBinding.problemId() == ProblemReasons.NotFound) {
					/* complete method members with missing return type
					 * class X {
					 *   Missing f() {return null;}
					 *   void foo() {
					 *     f().|
					 *   }
					 * }
					 */
					if (this.assistNodeInJavadoc == 0 &&
							(this.requestor.isAllowingRequiredProposals(CompletionProposal.FIELD_REF, CompletionProposal.TYPE_REF) ||
									this.requestor.isAllowingRequiredProposals(CompletionProposal.METHOD_REF, CompletionProposal.TYPE_REF))) {

				proposal.setSignature(signature);
				//proposal.setDeclarationPackageName(null);
				//proposal.setDeclarationTypeName(null);
				proposal.setReturnQualification(CharOperation.concatWith(JAVA_LANG, '.'));
				proposal.setReturnSimpleName(CLASS);
				proposal.setName(classField);
				proposal.setCompletion(classField);
				proposal.setFlags(Flags.AccStatic | Flags.AccPublic);

				proposal.setSignature(getSignature(field.type));
				proposal.setDeclarationPackageName(field.declaringClass.qualifiedPackageName());
				proposal.setDeclarationTypeName(field.declaringClass.qualifiedSourceName());
				proposal.setReturnQualification(field.type.qualifiedPackageName());
				proposal.setReturnSimpleName(field.type.qualifiedSourceName());
				proposal.setName(field.name);
				if (missingElements != null) {
					CompletionProposal[] subProposals = new CompletionProposal[missingElements.length];

				proposal.setSignature(getSignature(field.type));
				proposal.setDeclarationPackageName(field.declaringClass.qualifiedPackageName());
				proposal.setDeclarationTypeName(field.declaringClass.qualifiedSourceName());
				proposal.setReturnQualification(field.type.qualifiedPackageName());
				proposal.setReturnSimpleName(field.type.qualifiedSourceName());
				proposal.setName(field.name);
				proposal.setCompletion(javadocCompletion);
				proposal.setFlags(field.modifiers);

					proposal.setSignature(getSignature(field.type));
					proposal.setDeclarationPackageName(field.declaringClass.qualifiedPackageName());
					proposal.setDeclarationTypeName(field.declaringClass.qualifiedSourceName());
					proposal.setReturnQualification(field.type.qualifiedPackageName());
					proposal.setReturnSimpleName(field.type.qualifiedSourceName());
					proposal.setName(field.name);
					proposal.setCompletion(completion);
					proposal.setFlags(field.modifiers);

					char[] packageName = receiverType.qualifiedPackageName();
					typeImportProposal.setDeclarationSignature(packageName);
					typeImportProposal.setSignature(getSignature(receiverType));
					typeImportProposal.setReturnQualification(packageName);
					typeImportProposal.setReturnSimpleName(receiverType.qualifiedSourceName());
					typeImportProposal.setCompletion(typeImportCompletion);
					typeImportProposal.setFlags(receiverType.modifiers);
					typeImportProposal.setAdditionalFlags(CompletionFlags.Default);

					proposal.setSignature(getSignature(field.type));
					proposal.setDeclarationPackageName(field.declaringClass.qualifiedPackageName());
					proposal.setDeclarationTypeName(field.declaringClass.qualifiedSourceName());
					proposal.setReturnQualification(field.type.qualifiedPackageName());
					proposal.setReturnSimpleName(field.type.qualifiedSourceName());
					proposal.setName(field.name);
					proposal.setCompletion(completion);
					proposal.setFlags(field.modifiers);

					fieldImportProposal.setSignature(getSignature(field.type));
					fieldImportProposal.setDeclarationPackageName(field.declaringClass.qualifiedPackageName());
					fieldImportProposal.setDeclarationTypeName(field.declaringClass.qualifiedSourceName());
					fieldImportProposal.setReturnQualification(field.type.qualifiedPackageName());
					fieldImportProposal.setReturnSimpleName(field.type.qualifiedSourceName());
					fieldImportProposal.setName(field.name);
					fieldImportProposal.setCompletion(fieldImportCompletion);
					fieldImportProposal.setFlags(field.modifiers);

				proposal.setDeclarationTypeName(method.declaringClass.qualifiedSourceName());
				proposal.setParameterPackageNames(parameterPackageNames);
				proposal.setParameterTypeNames(parameterTypeNames);
				proposal.setReturnQualification(method.returnType.qualifiedPackageName());
				proposal.setReturnSimpleName(method.returnType.qualifiedSourceName());
				proposal.setName(method.selector);
				proposal.setIsContructor(method.isConstructor());
				

				proposal.setDeclarationTypeName(method.declaringClass.qualifiedSourceName());
				proposal.setParameterPackageNames(parameterPackageNames);
				proposal.setParameterTypeNames(parameterTypeNames);
				proposal.setReturnQualification(method.returnType.qualifiedPackageName());
				proposal.setReturnSimpleName(method.returnType.qualifiedSourceName());
				proposal.setName(method.selector);
				proposal.setCompletion(javadocCompletion);
				proposal.setFlags(method.modifiers);

							proposal.setDeclarationTypeName(method.declaringClass.qualifiedSourceName());
							proposal.setParameterPackageNames(parameterPackageNames);
							proposal.setParameterTypeNames(parameterTypeNames);
							proposal.setReturnQualification(method.returnType.qualifiedPackageName());
							proposal.setReturnSimpleName(method.returnType.qualifiedSourceName());
							proposal.setName(method.selector);
							proposal.setCompletion(completion);
							proposal.setFlags(method.modifiers);

						proposal.setDeclarationTypeName(method.declaringClass.qualifiedSourceName());
						proposal.setParameterPackageNames(parameterPackageNames);
						proposal.setParameterTypeNames(parameterTypeNames);
						proposal.setReturnQualification(method.returnType.qualifiedPackageName());
						proposal.setReturnSimpleName(method.returnType.qualifiedSourceName());
						proposal.setName(method.selector);
						proposal.setCompletion(completion);
						proposal.setFlags(method.modifiers);

						char[] packageName = receiverType.qualifiedPackageName();
						typeImportProposal.setDeclarationSignature(packageName);
						typeImportProposal.setSignature(getSignature(receiverType));
						typeImportProposal.setReturnQualification(packageName);
						typeImportProposal.setReturnSimpleName(receiverType.qualifiedSourceName());
						typeImportProposal.setCompletion(typeImportCompletion);
						typeImportProposal.setFlags(receiverType.modifiers);
						typeImportProposal.setAdditionalFlags(CompletionFlags.Default);

						proposal.setDeclarationTypeName(method.declaringClass.qualifiedSourceName());
						proposal.setParameterPackageNames(parameterPackageNames);
						proposal.setParameterTypeNames(parameterTypeNames);
						proposal.setReturnQualification(method.returnType.qualifiedPackageName());
						proposal.setReturnSimpleName(method.returnType.qualifiedSourceName());
						proposal.setName(method.selector);
						proposal.setCompletion(completion);
						proposal.setFlags(method.modifiers);

						methodImportProposal.setDeclarationTypeName(method.declaringClass.qualifiedSourceName());
						methodImportProposal.setParameterPackageNames(parameterPackageNames);
						methodImportProposal.setParameterTypeNames(parameterTypeNames);
						methodImportProposal.setReturnQualification(method.returnType.qualifiedPackageName());
						methodImportProposal.setReturnSimpleName(method.returnType.qualifiedSourceName());
						methodImportProposal.setName(method.selector);
						methodImportProposal.setCompletion(methodImportCompletion);
						methodImportProposal.setFlags(method.modifiers);

			proposal.completionEngine = this;
			proposal.setDeclarationSignature(packageName);
			proposal.setSignature(getSignature(typeBinding));
			proposal.setReturnQualification(packageName);
			proposal.setReturnSimpleName(typeName);
			proposal.setCompletion(fullyQualifiedName);
			proposal.setFlags(typeBinding.modifiers);
			proposal.setReplaceRange(start - this.offset, end - this.offset);


			proposal = this.createProposal(CompletionProposal.PACKAGE_REF, this.actualCompletionPosition);
			proposal.setDeclarationSignature(packageName);
			proposal.setReturnQualification(packageName);
			proposal.setCompletion(packageName);
			proposal.setReplaceRange(start - this.offset, end - this.offset);
			proposal.setRelevance(relevance);

				proposal.setDeclarationTypeName(method.declaringClass.qualifiedSourceName());
				proposal.setParameterPackageNames(parameterPackageNames);
				proposal.setParameterTypeNames(parameterFullTypeNames);
				proposal.setReturnQualification(method.returnType.qualifiedPackageName());
				proposal.setReturnSimpleName(method.returnType.qualifiedSourceName());
				proposal.setCompletion(completion.toString().toCharArray());
				proposal.setName(method.selector);
				proposal.setFlags(method.modifiers);

									: getSignature(local.type));
								if(local.type == null) {
									//proposal.setPackageName(null);
									proposal.setReturnSimpleName(local.declaration.getTypeName().toCharArray());
								} else {
									proposal.setReturnQualification(local.type.qualifiedPackageName());
									proposal.setReturnSimpleName(local.type.qualifiedSourceName());
								}
								proposal.setName(local.name);
								proposal.setCompletion(local.name);

									null,
									null,
									false);


						}
						break;
//					case Scope.CLASS_SCOPE :
					case Scope.COMPILATION_UNIT_SCOPE :
						CompilationUnitScope compilationUnitScope = (CompilationUnitScope) currentScope;
//						ClassScope classScope = (ClassScope) currentScope;
						SourceTypeBinding enclosingType = compilationUnitScope.enclosingCompilationUnit();
						/*				if (tokenLength == 0) { // only search inside the type itself if no prefix was provided
											findFields(token, enclosingType.fields(), classScope, fieldsFound, staticsOnly);
											findMethods(token, enclosingType.methods(), classScope, methodsFound, staticsOnly, false);
											break done;
										} else { */
						if(!insideTypeAnnotation) {
							if(proposeField) {
								findFields(

						}
						staticsOnly |= enclosingType.isStatic();
						insideTypeAnnotation = false;
						//				}
//						break;

//					case Scope.COMPILATION_UNIT_SCOPE :
						break done2;
				}
				currentScope = currentScope.parent;

			}
			
			//propose methods from environment if token length is not 0
			if (proposeMethod  && token.length > 0) {
				this.nameEnvironment.findFunctions(
				this.nameEnvironment.findBindings(
						token,
						null,
						this.options.camelCaseMatch,
						this);
				acceptBindings(token,false,false);
			}
			
			//propose fields from environment if token length is not 0

						if(!CompletionEngine.this.requestor.isIgnored(CompletionProposal.VARIABLE_DECLARATION)) {
							CompletionProposal proposal = CompletionEngine.this.createProposal(CompletionProposal.VARIABLE_DECLARATION, CompletionEngine.this.actualCompletionPosition);
							proposal.setSignature(getSignature(type.resolvedType));
							proposal.setReturnQualification(type.resolvedType.qualifiedPackageName());
							proposal.setReturnSimpleName(type.resolvedType.qualifiedSourceName());
							proposal.setName(name);
							proposal.setCompletion(name);
							//proposal.setFlags(Flags.AccDefault);

					if(!CompletionEngine.this.requestor.isIgnored(CompletionProposal.VARIABLE_DECLARATION)) {
						CompletionProposal proposal = CompletionEngine.this.createProposal(CompletionProposal.VARIABLE_DECLARATION, CompletionEngine.this.actualCompletionPosition);
						proposal.setSignature(getSignature(typeBinding));
						proposal.setReturnQualification(q);
						proposal.setReturnSimpleName(displayName);
						proposal.setName(name);
						proposal.setCompletion(name);
						//proposal.setFlags(Flags.AccDefault);

			proposal.setDeclarationTypeName(reference.qualifiedSourceName());

			//proposal.setPackageName(null);
			proposal.setReturnSimpleName(VOID);
			proposal.setName(token);
			//proposal.setParameterPackageNames(null);
			//proposal.setParameterTypeNames(null);

			proposal.completionEngine = this;
			proposal.setDeclarationSignature(packageName);
			proposal.setSignature(createNonGenericTypeSignature(typeName));
			proposal.setReturnQualification(packageName);
			proposal.setReturnSimpleName(typeName);
			proposal.setCompletion(completionName);
			proposal.setFlags(modifiers);
			proposal.setReplaceRange(this.startPosition - this.offset, this.endPosition - this.offset);

			proposal.completionEngine = this;
			proposal.setDeclarationSignature(packageName);
			proposal.setSignature(createNonGenericTypeSignature(typeName));
			proposal.setReturnQualification(packageName);
			proposal.setReturnSimpleName(typeName);
			proposal.setCompletion(javadocCompletion);
			proposal.setFlags(modifiers);
			int start = (this.assistNodeInJavadoc & CompletionOnJavadoc.REPLACE_TAG) != 0 ? this.javadocTagPosition : this.startPosition;

			proposal.completionEngine = this;
			proposal.setDeclarationSignature(refBinding.qualifiedPackageName());
			proposal.setSignature(getSignature(refBinding));
			proposal.setReturnQualification(refBinding.qualifiedPackageName());
			proposal.setReturnSimpleName(typeName);
			proposal.setCompletion(completionName);
			proposal.setFlags(refBinding.modifiers);
			proposal.setReplaceRange(this.startPosition - this.offset, this.endPosition - this.offset);

			proposal.completionEngine = this;
			proposal.setDeclarationSignature(refBinding.qualifiedPackageName());
			proposal.setSignature(getSignature(refBinding));
			proposal.setReturnQualification(refBinding.qualifiedPackageName());
			proposal.setReturnSimpleName(typeName);
			proposal.setCompletion(javadocCompletion);
			proposal.setFlags(refBinding.modifiers);
			int start = (this.assistNodeInJavadoc & CompletionOnJavadoc.REPLACE_TAG) != 0 ? this.javadocTagPosition : this.startPosition;

								CompletionProposal proposal =  createProposal(CompletionProposal.TYPE_REF, this.actualCompletionPosition);
								proposal.setDeclarationSignature(packageName);
								proposal.setSignature(getSignature(refBinding));
								proposal.setReturnQualification(packageName);
								proposal.setReturnSimpleName(typeName);
								proposal.setCompletion(completionName);
								proposal.setFlags(refBinding.modifiers);
								proposal.setReplaceRange(this.startPosition - this.offset, this.endPosition - this.offset);

	}
	
	/**
	 * <p>Creates a function proposal based on all of the given information</p>
	 * 
	 * @param signature
	 * @param parameterCount
	 * @param parameterQualifications
	 * @param parameterSimpleNames
	 * @param parameterNames
	 * @param returnQualification
	 * @param returnSimpleName
	 * @param declaringQualification
	 * @param declaringSimpleName
	 * @param modifiers
	 * @param path
	 */
	private void proposeFunction(char[] signature,
			int parameterCount,
			char[][] parameterQualifications,
			char[][] parameterSimpleNames,
			char[][] parameterNames,
			char[] returnQualification,
			char[] returnSimpleName,
			char[] declaringQualification,
			char[] declaringSimpleName,
			int modifiers,
			String path) {
		
		//compute completion
		char[] completion;
		if (this.source != null
				&& this.source.length > this.endPosition
				&& this.source[this.endPosition] == '(') {
			
			completion = signature;
		} else {
			completion = CharOperation.concat(signature, new char[] { '(', ')' });
		}
		
		//compute relevance
		int relevance = computeBaseRelevance();
		relevance += computeRelevanceForInterestingProposal();
		if (this.completionToken != null) relevance += computeRelevanceForCaseMatching(this.completionToken, signature);
		relevance += computeRelevanceForExpectingType(returnQualification, returnSimpleName);
		relevance += computeRelevanceForQualification(false);
		relevance += computeRelevanceForRestrictions(IAccessRule.K_ACCESSIBLE);
		
		this.noProposal = false;
		// Standard proposal
		if(!this.requestor.isIgnored(CompletionProposal.METHOD_REF) && (this.assistNodeInJavadoc & CompletionOnJavadoc.ONLY_INLINE_TAG) == 0) {
			CompletionProposal proposal = this.createProposal(CompletionProposal.METHOD_REF, this.actualCompletionPosition);
			proposal.setDeclarationSignature(QualificationHelpers.createFullyQualifiedName(declaringQualification, declaringSimpleName));
			proposal.setDeclarationPackageName(declaringQualification);
			proposal.setDeclarationTypeName(declaringSimpleName);
			proposal.setParameterPackageNames(parameterQualifications);
			proposal.setParameterTypeNames(parameterSimpleNames);
			proposal.setReturnQualification(returnQualification);
			proposal.setReturnSimpleName(returnSimpleName);
			proposal.setName(signature);
			proposal.setCompletion(completion);
			proposal.setFlags(modifiers | Flags.AccPublic );
			proposal.setReplaceRange(this.startPosition - this.offset, this.endPosition - this.offset);
			proposal.setRelevance(relevance);
			if(parameterNames != null) proposal.setParameterNames(parameterNames);
			proposal.setIsContructor(false);
			this.requestor.accept(proposal);
			if(DEBUG) {
				this.printDebug(proposal);
			}
		}
	}
	
	/**
	 * <p>Represents a constructor accepted from the index.</p>
	 */
	private static class AcceptedConstructor {




			char[][] parameterNames,
			String path,
			AccessRestriction access);
	
	/**
	 * <p>Accept a function defined with all of the given information</p>
	 * 
	 * @param signature
	 * @param parameterCount
	 * @param parameterQualifications
	 * @param parameterSimpleNames
	 * @param parameterNames
	 * @param returnQualification
	 * @param returnSimpleName
	 * @param declaringQualification
	 * @param declaringSimpleName
	 * @param modifiers
	 * @param path
	 */
	public void acceptFunction(char[] signature,
			int parameterCount,
			char[][] parameterQualifications,
			char[][] parameterSimpleNames,
			char[][] parameterNames,
			char[] returnQualification,
			char[] returnSimpleName,
			char[] declaringQualification,
			char[] declaringSimpleName,
			int modifiers,
			String path);
}





	protected char[] declarationPackageName;
	protected char[] declarationTypeName;
	protected char[] returnQualification;
	protected char[] returnSimpleName;
	protected char[][] parameterPackageNames;
	protected char[][] parameterTypeNames;


		return this.declarationTypeName;
	}

	protected char[] getReturnQualification() {
		return this.returnQualification;
	}

	protected char[] getReturnSimpleName() {
		return this.returnSimpleName;
	}

	protected char[][] getParameterPackageNames() {

		this.declarationTypeName = declarationTypeName;
	}

	protected void setReturnQualification(char[] packageName) {
		this.returnQualification = packageName;
	}

	protected void setReturnSimpleName(char[] typeName) {
		this.returnSimpleName = typeName;
	}

	protected void setParameterPackageNames(char[][] parameterPackageNames) {




				
				//do nothing
			}
			
			/**
			 * @see org.eclipse.wst.jsdt.internal.codeassist.ISearchRequestor#acceptFunction(char[], int, char[][], char[][], char[][], char[], char[], char[], char[], int, java.lang.String)
			 */
			public void acceptFunction(char[] signature, int parameterCount,
					char[][] parameterQualifications,
					char[][] parameterSimpleNames, char[][] parameterNames,
					char[] returnQualification, char[] returnSimpleName,
					char[] declaringQualification, char[] declaringSimpleName,
					int modifiers, String path) {
				
				//do nothing
			}
		};
		nameEnvironment.findExactTypes(missingSimpleName, true, IJavaScriptSearchConstants.TYPE, storage);
		if(results.size() == 0) return null;




		
		// do nothing
	}
	
	/**
	 * @see org.eclipse.wst.jsdt.internal.codeassist.ISearchRequestor#acceptFunction(char[], int, char[][], char[][], char[][], char[], char[], char[], char[], int, java.lang.String)
	 */
	public void acceptFunction(char[] signature, int parameterCount,
			char[][] parameterQualifications,
			char[][] parameterSimpleNames, char[][] parameterNames,
			char[] returnQualification, char[] returnSimpleName,
			char[] declaringQualification, char[] declaringSimpleName,
			int modifiers, String path) {
		
		//do nothing
	}

	private void acceptQualifiedTypes() {
		if(this.acceptedClasses != null){

			localParser.inferTypes(parsedUnit,this.compilerOptions);
			return parsedUnit;
		} catch (AbortCompilationUnit e) {
			throw e; // want to abort enclosing request to compile
//			// one requested further along to resolve sourceUnit.
//			if (unitResult.compilationUnit == sourceUnit) { // only report once
//				requestor.acceptResult(unitResult.tagAsAccepted());
//			} else {
				throw e; // want to abort enclosing request to compile
//			}
		}

	}

}

Lines 60-65 Link Here

(-)src/org/eclipse/wst/jsdt/internal/compiler/ISourceElementRequestor.java (+1 lines)
60	public int nameSourceEnd;	60	public int nameSourceEnd;
61	public char[][] parameterTypes;	61	public char[][] parameterTypes;
62	public char[][] parameterNames;	62	public char[][] parameterNames;
		63	public char[] declaringType;
63	public char[][] categories;	64	public char[][] categories;
64	}	65	}
65		66

Lines 193-199 Link Here

(-)src/org/eclipse/wst/jsdt/internal/compiler/SourceElementParser.java (-1 / +22 lines)
193		193
194	char[] selector = Util.getTypeName(leftHandSide);	194	char[] selector = Util.getTypeName(leftHandSide);
195	MethodDeclaration methodDecl = ((IFunctionExpression) righHandSide).getMethodDeclaration();	195	MethodDeclaration methodDecl = ((IFunctionExpression) righHandSide).getMethodDeclaration();
196	if(selector != null && methodDecl.isConstructor()) {	196	if(selector != null /&& methodDecl.isConstructor() /) {
197	notifySourceElementRequestor(methodDecl,	197	notifySourceElementRequestor(methodDecl,
198	selector);	198	selector);
199	}	199	}
Lines 798-803 Link Here
798	methodInfo.parameterTypes = argumentTypes;	798	methodInfo.parameterTypes = argumentTypes;
799	methodInfo.parameterNames = argumentNames;	799	methodInfo.parameterNames = argumentNames;
800	methodInfo.categories = (char[][]) this.nodesToCategories.get(methodDeclaration);	800	methodInfo.categories = (char[][]) this.nodesToCategories.get(methodDeclaration);
		801	InferredMethod inferredMeth = methodDeclaration.getInferredMethod();
		802	if(inferredMeth != null) {
		803	InferredType declaringType = inferredMeth.inType;
		804	if(declaringType != null) {
		805	methodInfo.declaringType = declaringType.getName();
		806	}
		807	}
801		808
802	//enter either constructor or method where appropriate	809	//enter either constructor or method where appropriate
803	if(methodInfo.isConstructor) {	810	if(methodInfo.isConstructor) {
Lines 916-921 Link Here
916	methodInfo.parameterTypes = argumentTypes;	923	methodInfo.parameterTypes = argumentTypes;
917	methodInfo.parameterNames = argumentNames;	924	methodInfo.parameterNames = argumentNames;
918	methodInfo.categories = (char[][]) this.nodesToCategories.get(methodDeclaration);	925	methodInfo.categories = (char[][]) this.nodesToCategories.get(methodDeclaration);
		926	InferredMethod inferredMeth = methodDeclaration.getInferredMethod();
		927	if(inferredMeth != null) {
		928	InferredType declaringType = inferredMeth.inType;
		929	if(declaringType != null) {
		930	methodInfo.declaringType = declaringType.getName();
		931	}
		932	}
919	requestor.enterConstructor(methodInfo);	933	requestor.enterConstructor(methodInfo);
920	}	934	}
921	/* need this check because a constructor could have been made a constructor after the	935	/* need this check because a constructor could have been made a constructor after the
Lines 970-975 Link Here
970	methodInfo.parameterTypes = argumentTypes;	984	methodInfo.parameterTypes = argumentTypes;
971	methodInfo.parameterNames = argumentNames;	985	methodInfo.parameterNames = argumentNames;
972	methodInfo.categories = (char[][]) this.nodesToCategories.get(methodDeclaration);	986	methodInfo.categories = (char[][]) this.nodesToCategories.get(methodDeclaration);
		987	InferredMethod inferredMeth = methodDeclaration.getInferredMethod();
		988	if(inferredMeth != null) {
		989	InferredType declaringType = inferredMeth.inType;
		990	if(declaringType != null) {
		991	methodInfo.declaringType = declaringType.getName();
		992	}
		993	}
973	requestor.enterMethod(methodInfo);	994	requestor.enterMethod(methodInfo);
974	}	995	}
975		996




}

void connectTypeHierarchy(char[][] typeNames) {
		// if(superType!=null) {
		// if(superType instanceof SourceTypeBinding) {
		// ((SourceTypeBinding)superType).classScope.buildFieldsAndMethods();
		// ((SourceTypeBinding)superType).classScope.connectTypeHierarchy();
		//
		// }
		// ReferenceBinding[] memberTypes = superType.memberTypes();
		// ReferenceBinding[] memberFields = superType.typeVariables();
		// FunctionBinding[] memberMethods = superType.availableMethods();
		// for(int i=0;i<memberTypes.length;i++) {
		// recordReference(memberTypes[i], memberTypes[i].sourceName);
		// }
		// }

		// if(superTypeName!=null) {
		// ReferenceBinding binding = environment.askForType(new char[][]
		// {superTypeName});
		// this.recordSuperTypeReference(binding);
		// }
		if (classScope != null)
			classScope.connectTypeHierarchy();
		nextType: for (int i = 0; i < referenceContext.numberInferredTypes; i++) {

					continue nextType;
			
		}
			if (inferredType.binding != null && inferredType.binding.classScope != null) {
				inferredType.binding.classScope.connectTypeHierarchy();
			}
		}
}
void connectTypeHierarchy() {




import org.eclipse.wst.jsdt.internal.compiler.impl.ITypeRequestor;
import org.eclipse.wst.jsdt.internal.core.search.BasicSearchEngine;
import org.eclipse.wst.jsdt.internal.core.search.IConstructorRequestor;
import org.eclipse.wst.jsdt.internal.core.search.IFunctionRequester;
import org.eclipse.wst.jsdt.internal.core.search.IRestrictedAccessBindingRequestor;
import org.eclipse.wst.jsdt.internal.core.search.IRestrictedAccessTypeRequestor;


					for (int i = 0, index = 1; i < length; i++) {
						ISourceType otherType = (ISourceType) ((JavaElement) types[i])
								.getElementInfo();
						//check that the index is in bounds (see Bug 62861)
						if (!otherType.equals(topLevelType) && index < length) {
																				// the
																				// index
																				// is
																				// in
																				// bounds
																				// (see
																				// https://bugs.eclipse.org/bugs/show_bug.cgi?id=62861)
							sourceTypes[index++] = otherType;
						}
					}
					return new NameEnvironmentAnswer(sourceTypes,
							answer.restriction);

				System.arraycopy(elements, 0, units, 0, elements.length);
				return new NameEnvironmentAnswer(units,answer.restriction);
			}
				// return new NameEnvironmentAnswer((IBinaryType) ((BinaryType)
				// answer.type).getElementInfo(), answer.restriction);
		}
		return null;
	}

				}
			}

			IProgressMonitor progressMonitor = new CancelableProgressMonitor();
			

				public void beginTask(String name, int totalWork) {
					// implements interface method
				}

				public void done() {
					// implements interface method
				}

				public void internalWorked(double work) {
					// implements interface method
				}

				public boolean isCanceled() {
					return isCanceled;
				}

				public void setCanceled(boolean value) {
					isCanceled = value;
				}

				public void setTaskName(String name) {
					// implements interface method
				}

				public void subTask(String name) {
					// implements interface method
				}

				public void worked(int work) {
					// implements interface method
				}
			};
			IRestrictedAccessBindingRequestor bindingRequestor = new IRestrictedAccessBindingRequestor() {
				String exclude;
				public boolean acceptBinding(int type,int modifiers, char[] packageName,

			findTypes(new String(prefix), storage, NameLookup.ACCEPT_ALL);
		}
	}
	
	/**
	 * <p>Used to find all functions in the environment using the given information.</p>
	 * 
	 * <p><b>NOTE:</b> this function will currently ignore any results either from the index
	 * or working copies from the {@link #unitToSkip}.</p>
	 * 
	 * @param selectorPrefix prefix to the selector to search for functions matches for, or
	 * <code>null</code> to search for functions with any selector.  The <code>null</code>
	 * option is useful when searching for all functions on a given type.
	 * @param declaringTypeName fully qualified type name that any function results should be
	 * defined on, or <code>null</code> if the function results should not be defined on any type
	 * @param searchRequester search requester to return any search results too
	 */
	public void findFunctions(char[] selectorPrefix, String declaringTypeName, final ISearchRequestor searchRequester) {
		//calculate the exclude path
		final String excludePath;
		if (this.unitToSkip != null && this.unitToSkip instanceof IJavaScriptElement) {
			excludePath = ((IJavaScriptElement)this.unitToSkip).getPath().toString();
		} else {
			excludePath = null;
		}
		
		//create the requester
		IFunctionRequester functionRequestor = new IFunctionRequester() {
			public void acceptFunction(char[] signature,
					int parameterCount,
					char[][] parameterQualifications, char[][] parameterSimpleNames,
					char[][] parameterNames,
					char[] returnQualification, char[] returnSimpleName,
					char[] declaringQualification, char[] declaringSimpleName,
					int modifiers,
					String path) {
				
				if (excludePath == null || !excludePath.equals(path)) {
					searchRequester.acceptFunction(signature, parameterCount, parameterQualifications, parameterSimpleNames, parameterNames,
							returnQualification, returnSimpleName, declaringQualification, declaringSimpleName, modifiers, path);
				}
			}
		};
		
		/* if selector specified then search for any selector with the given selector as a prefix
		 * else search for any selector
		 */
		char[] selectorPattern;
		int selectorPatternMatchRule;
		if(selectorPrefix != null) {
			selectorPattern = selectorPrefix;
			selectorPatternMatchRule = SearchPattern.R_PREFIX_MATCH;
		} else {
			selectorPattern = new char[] {'*'};
			selectorPatternMatchRule = SearchPattern.R_PATTERN_MATCH;
		}
		
		/* if a declaring type name is specified then make it the pattern for matching
		 * else find methods not on a type
		 */
		String declaringType;
		if(declaringTypeName != null) {
			declaringType = declaringTypeName;
		} else {
			declaringType = null;
		}
		
		//do the search
		new BasicSearchEngine(this.workingCopies).searchAllFunctions(
				functionRequestor,
				selectorPattern,
				declaringType,
				selectorPatternMatchRule,
				this.searchScope,
				WAIT_UNTIL_READY_TO_SEARCH,
				new CancelableProgressMonitor());
	}

	/**
	 * <p>The progress monitor is used to be able to cancel completion operations</p>

			excludePath = null;
		}

		IProgressMonitor progressMonitor = new CancelableProgressMonitor();
			boolean isCanceled = false;
			public void beginTask(String name, int totalWork) {
				// implements interface method
			}
			public void done() {
				// implements interface method
			}
			public void internalWorked(double work) {
				// implements interface method
			}
			public boolean isCanceled() {
				return this.isCanceled;
			}
			public void setCanceled(boolean value) {
				this.isCanceled = value;
			}
			public void setTaskName(String name) {
				// implements interface method
			}
			public void subTask(String name) {
				// implements interface method
			}
			public void worked(int work) {
				// implements interface method
			}
		};
		
		IConstructorRequestor constructorRequestor = new IConstructorRequestor() {
			/**

			this.nameLookup.seekBindings(prefix, bindingType,null, true, type, requestor);
		} else {
			throw new UnimplementedException("shouldnt get here"); //$NON-NLS-1$
//			String packageName = prefix.substring(0, index);
//			JavaElementRequestor elementRequestor = new JavaElementRequestor();
//			this.nameLookup.seekPackageFragments(packageName, false,
//					elementRequestor);
//			IPackageFragment[] fragments = elementRequestor
//					.getPackageFragments();
//			if (fragments != null) {
//				String className = prefix.substring(index + 1);
//				for (int i = 0, length = fragments.length; i < length; i++)
//					if (fragments[i] != null)
//						this.nameLookup.seekTypes(className, fragments[i],
//								true, type, requestor);
//			}
		}
	}
	/**

	{
		nameLookup.setScriptFile(file);
	}
	
	/**
	 * <p>A cancelable progress monitor</p>
	 */
	private static class CancelableProgressMonitor implements IProgressMonitor {
		boolean isCanceled = false;
		public void beginTask(String name, int totalWork) {
			// implements interface method
		}
		public void done() {
			// implements interface method
		}
		public void internalWorked(double work) {
			// implements interface method
		}
		public boolean isCanceled() {
			return this.isCanceled;
		}
		public void setCanceled(boolean value) {
			this.isCanceled = value;
		}
		public void setTaskName(String name) {
			// implements interface method
		}
		public void subTask(String name) {
			// implements interface method
		}
		public void worked(int work) {
			// implements interface method
		}
	}
}

Lines 52-58 Link Here

(-)src/org/eclipse/wst/jsdt/internal/core/index/DiskIndex.java (-1 / +1 lines)
52	private int bufferIndex, bufferEnd; // used when reading from the file into the streamBuffer	52	private int bufferIndex, bufferEnd; // used when reading from the file into the streamBuffer
53	private int streamEnd; // used when writing data from the streamBuffer to the file	53	private int streamEnd; // used when writing data from the streamBuffer to the file
54		54
55	public static final String SIGNATURE= "INDEX VERSION 1.122"; //$NON-NLS-1$	55	public static final String SIGNATURE= "INDEX VERSION 1.123"; //$NON-NLS-1$
56	private static final char[] SIGNATURE_CHARS = SIGNATURE.toCharArray();	56	private static final char[] SIGNATURE_CHARS = SIGNATURE.toCharArray();
57	public static boolean DEBUG = false;	57	public static boolean DEBUG = false;
58		58

Lines 29-35 Link Here

(-)src/org/eclipse/wst/jsdt/internal/core/search/BasicSearchEngine.java (-99 / +310 lines)
29	import org.eclipse.wst.jsdt.core.IType;	29	import org.eclipse.wst.jsdt.core.IType;
30	import org.eclipse.wst.jsdt.core.JavaScriptCore;	30	import org.eclipse.wst.jsdt.core.JavaScriptCore;
31	import org.eclipse.wst.jsdt.core.JavaScriptModelException;	31	import org.eclipse.wst.jsdt.core.JavaScriptModelException;
		32	import org.eclipse.wst.jsdt.core.Signature;
32	import org.eclipse.wst.jsdt.core.WorkingCopyOwner;	33	import org.eclipse.wst.jsdt.core.WorkingCopyOwner;
		34	import org.eclipse.wst.jsdt.core.ast.IArgument;
		35	import org.eclipse.wst.jsdt.core.ast.IFunctionDeclaration;
33	import org.eclipse.wst.jsdt.core.compiler.CharOperation;	36	import org.eclipse.wst.jsdt.core.compiler.CharOperation;
34	import org.eclipse.wst.jsdt.core.infer.InferredAttribute;	37	import org.eclipse.wst.jsdt.core.infer.InferredAttribute;
35	import org.eclipse.wst.jsdt.core.infer.InferredMethod;	38	import org.eclipse.wst.jsdt.core.infer.InferredMethod;
Lines 52-57 Link Here
52	import org.eclipse.wst.jsdt.internal.compiler.classfmt.ClassFileConstants;	55	import org.eclipse.wst.jsdt.internal.compiler.classfmt.ClassFileConstants;
53	import org.eclipse.wst.jsdt.internal.compiler.env.AccessRestriction;	56	import org.eclipse.wst.jsdt.internal.compiler.env.AccessRestriction;
54	import org.eclipse.wst.jsdt.internal.compiler.env.AccessRuleSet;	57	import org.eclipse.wst.jsdt.internal.compiler.env.AccessRuleSet;
		58	import org.eclipse.wst.jsdt.internal.compiler.env.ICompilationUnit;
55	import org.eclipse.wst.jsdt.internal.compiler.impl.CompilerOptions;	59	import org.eclipse.wst.jsdt.internal.compiler.impl.CompilerOptions;
56	import org.eclipse.wst.jsdt.internal.compiler.lookup.Binding;	60	import org.eclipse.wst.jsdt.internal.compiler.lookup.Binding;
57	import org.eclipse.wst.jsdt.internal.compiler.lookup.BlockScope;	61	import org.eclipse.wst.jsdt.internal.compiler.lookup.BlockScope;
Lines 65-70 Link Here
65	import org.eclipse.wst.jsdt.internal.core.DefaultWorkingCopyOwner;	69	import org.eclipse.wst.jsdt.internal.core.DefaultWorkingCopyOwner;
66	import org.eclipse.wst.jsdt.internal.core.JavaModelManager;	70	import org.eclipse.wst.jsdt.internal.core.JavaModelManager;
67	import org.eclipse.wst.jsdt.internal.core.JavaProject;	71	import org.eclipse.wst.jsdt.internal.core.JavaProject;
		72	import org.eclipse.wst.jsdt.internal.core.Logger;
68	import org.eclipse.wst.jsdt.internal.core.search.indexing.IIndexConstants;	73	import org.eclipse.wst.jsdt.internal.core.search.indexing.IIndexConstants;
69	import org.eclipse.wst.jsdt.internal.core.search.indexing.IndexManager;	74	import org.eclipse.wst.jsdt.internal.core.search.indexing.IndexManager;
70	import org.eclipse.wst.jsdt.internal.core.search.matching.ConstructorDeclarationPattern;	75	import org.eclipse.wst.jsdt.internal.core.search.matching.ConstructorDeclarationPattern;
Lines 81-86 Link Here
81	import org.eclipse.wst.jsdt.internal.core.search.matching.SecondaryTypeDeclarationPattern;	86	import org.eclipse.wst.jsdt.internal.core.search.matching.SecondaryTypeDeclarationPattern;
82	import org.eclipse.wst.jsdt.internal.core.search.matching.TypeDeclarationPattern;	87	import org.eclipse.wst.jsdt.internal.core.search.matching.TypeDeclarationPattern;
83	import org.eclipse.wst.jsdt.internal.core.util.Messages;	88	import org.eclipse.wst.jsdt.internal.core.util.Messages;
		89	import org.eclipse.wst.jsdt.internal.core.util.QualificationHelpers;
84	import org.eclipse.wst.jsdt.internal.core.util.Util;	90	import org.eclipse.wst.jsdt.internal.core.util.Util;
85		91
86	/**	92	/**
Lines 101-106 Link Here
101	* compilation units.	107	* compilation units.
102	*/	108	*/
103	private IJavaScriptUnit[] workingCopies;	109	private IJavaScriptUnit[] workingCopies;
		110
		111	/**
		112	* <p>Set of all of the working copies paths</p>
		113	*/
		114	private HashSet fWorkingCopiesPaths;
104		115
105	/*	116	/*
106	* A working copy owner whose working copies will take precedent over	117	* A working copy owner whose working copies will take precedent over
Lines 366-374 Link Here
366	return this.parser;	377	return this.parser;
367	}	378	}
368		379
369	/*	380	/**
370	* Returns the list of working copies used by this search engine.	381	* @return list of working copies used by this search engine,
371	* Returns null if none.	382	* or <code>null</code> if none.
372	*/	383	*/
373	private IJavaScriptUnit[] getWorkingCopies() {	384	private IJavaScriptUnit[] getWorkingCopies() {
374	IJavaScriptUnit[] copies;	385	IJavaScriptUnit[] copies;
Lines 425-430 Link Here
425	}	436	}
426	return result;	437	return result;
427	}	438	}
		439
		440	/**
		441	* @return {@link HashSet} of all of the working copy paths
		442	*/
		443	private HashSet getWorkingCopiesPaths() {
		444	if(this.fWorkingCopiesPaths == null) {
		445	this.fWorkingCopiesPaths = new HashSet();
		446
		447	IJavaScriptUnit[] workingCopies = this.getWorkingCopies();
		448	for(int i = 0; workingCopies != null && i < workingCopies.length; ++i) {
		449	this.fWorkingCopiesPaths.add(workingCopies[i].getPath().toString());
		450	}
		451	}
		452
		453	return this.fWorkingCopiesPaths;
		454	}
428		455
429	/*	456	/*
430	* Returns the list of working copies used to do the search on the given Java element.	457	* Returns the list of working copies used to do the search on the given Java element.
Lines 566-572 Link Here
566	true,false,true,	593	true,false,true,
567	bindingName,	594	bindingName,
568	null,null,null,null,	595	null,null,null,null,
569	null,null,null,	596	null,null,
570	matchRule);	597	matchRule);
571		598
572	}	599	}
Lines 578-585 Link Here
578	searchPattern = new MethodPattern(	605	searchPattern = new MethodPattern(
579	true,false,true,	606	true,false,true,
580	bindingName,	607	bindingName,
581	null,null,null,null,
582	null,null,null,
583	matchRule);	608	matchRule);
584		609
585	}	610	}
Lines 610-633 Link Here
610	final SearchPattern pattern =searchPattern;	635	final SearchPattern pattern =searchPattern;
611	final char typeSuffix=suffix;	636	final char typeSuffix=suffix;
612		637
613	// Get working copy path(s). Store in a single string in case of only one to optimize comparison in requestor	638	// Index requester
614	final HashSet workingCopyPaths = new HashSet();
615	String workingCopyPath = null;
616	IJavaScriptUnit[] copies = getWorkingCopies();
617	final int copiesLength = copies == null ? 0 : copies.length;
618	if (copies != null) {
619	if (copiesLength == 1) {
620	workingCopyPath = copies[0].getPath().toString();
621	} else {
622	for (int i = 0; i < copiesLength; i++) {
623	IJavaScriptUnit workingCopy = copies[i];
624	workingCopyPaths.add(workingCopy.getPath().toString());
625	}
626	}
627	}
628	final String singleWkcpPath = workingCopyPath;
629
630	// Index requestor
631	IndexQueryRequestor searchRequestor = new IndexQueryRequestor(){	639	IndexQueryRequestor searchRequestor = new IndexQueryRequestor(){
632	public boolean acceptIndexMatch(String documentPath, SearchPattern indexRecord, SearchParticipant participant, AccessRuleSet access) {	640	public boolean acceptIndexMatch(String documentPath, SearchPattern indexRecord, SearchParticipant participant, AccessRuleSet access) {
633	// Filter unexpected types	641	// Filter unexpected types
Lines 691-696 Link Here
691	progressMonitor == null ? null : new SubProgressMonitor(progressMonitor, 100));	699	progressMonitor == null ? null : new SubProgressMonitor(progressMonitor, 100));
692		700
693	// add type names from working copies	701	// add type names from working copies
		702	IJavaScriptUnit[] copies = getWorkingCopies();
		703	final int copiesLength = copies == null ? 0 : copies.length;
694	if (copies != null && doParse) {	704	if (copies != null && doParse) {
695	for (int i = 0; i < copiesLength; i++) {	705	for (int i = 0; i < copiesLength; i++) {
696	IJavaScriptUnit workingCopy = copies[i];	706	IJavaScriptUnit workingCopy = copies[i];
Lines 705-718 Link Here
705	IType[] allTypes = workingCopy.getAllTypes();	715	IType[] allTypes = workingCopy.getAllTypes();
706	for (int j = 0, allTypesLength = allTypes.length; j < allTypesLength; j++) {	716	for (int j = 0, allTypesLength = allTypes.length; j < allTypesLength; j++) {
707	IType type = allTypes[j];	717	IType type = allTypes[j];
708	IJavaScriptElement parent = type.getParent();
709	char[][] enclosingTypeNames;
710	if (parent instanceof IType) {
711	char[] parentQualifiedName = ((IType)parent).getTypeQualifiedName('.').toCharArray();
712	enclosingTypeNames = CharOperation.splitOn('.', parentQualifiedName);
713	} else {
714	enclosingTypeNames = CharOperation.NO_CHAR_CHAR;
715	}
716	char[] simpleName = type.getElementName().toCharArray();	718	char[] simpleName = type.getElementName().toCharArray();
717	int kind = TypeDeclaration.CLASS_DECL;	719	int kind = TypeDeclaration.CLASS_DECL;
718		720
Lines 726-741 Link Here
726	IFunction[] allMethods = workingCopy.getFunctions();	728	IFunction[] allMethods = workingCopy.getFunctions();
727	for (int j = 0, allMethodsLength = allMethods.length; j < allMethodsLength; j++) {	729	for (int j = 0, allMethodsLength = allMethods.length; j < allMethodsLength; j++) {
728	IFunction method = allMethods[j];	730	IFunction method = allMethods[j];
729	IJavaScriptElement parent = method.getParent();
730	// char[][] enclosingTypeNames;
731	if (parent instanceof IType) {
732	// char[] parentQualifiedName = ((IType)parent).getTypeQualifiedName('.').toCharArray();
733	// enclosingTypeNames = CharOperation.splitOn('.', parentQualifiedName);
734	} else {
735	// enclosingTypeNames = CharOperation.NO_CHAR_CHAR;
736	}
737	char[] simpleName = method.getElementName().toCharArray();	731	char[] simpleName = method.getElementName().toCharArray();
738	// int kind;
739	if (match(typeSuffix, packageName, bindingName, matchRule, 0, packageDeclaration, simpleName)) {	732	if (match(typeSuffix, packageName, bindingName, matchRule, 0, packageDeclaration, simpleName)) {
740	nameRequestor.acceptBinding(bindingType,method.getFlags(), packageDeclaration, simpleName, path, null);	733	nameRequestor.acceptBinding(bindingType,method.getFlags(), packageDeclaration, simpleName, path, null);
741	}	734	}
Lines 749-764 Link Here
749	IField[] allFields = workingCopy.getFields ();	742	IField[] allFields = workingCopy.getFields ();
750	for (int j = 0, allFieldsLength = allFields.length; j < allFieldsLength; j++) {	743	for (int j = 0, allFieldsLength = allFields.length; j < allFieldsLength; j++) {
751	IField field = allFields[j];	744	IField field = allFields[j];
752	IJavaScriptElement parent = field.getParent();
753	char[][] enclosingTypeNames;
754	if (parent instanceof IType) {
755	char[] parentQualifiedName = ((IType)parent).getTypeQualifiedName('.').toCharArray();
756	enclosingTypeNames = CharOperation.splitOn('.', parentQualifiedName);
757	} else {
758	enclosingTypeNames = CharOperation.NO_CHAR_CHAR;
759	}
760	char[] simpleName = field.getElementName().toCharArray();	745	char[] simpleName = field.getElementName().toCharArray();
761	int kind;
762	if (match(typeSuffix, packageName, bindingName, matchRule, 0, packageDeclaration, simpleName)) {	746	if (match(typeSuffix, packageName, bindingName, matchRule, 0, packageDeclaration, simpleName)) {
763	nameRequestor.acceptBinding(bindingType,field.getFlags(), packageDeclaration, simpleName, path, null);	747	nameRequestor.acceptBinding(bindingType,field.getFlags(), packageDeclaration, simpleName, path, null);
764	}	748	}
Lines 799-822 Link Here
799	}	783	}
800	return true;	784	return true;
801	}	785	}
802	// public boolean visit(TypeDeclaration memberTypeDeclaration, ClassScope classScope) {
803	// if (match(typeSuffix, packageName, bindingName, matchRule, TypeDeclaration.kind(memberTypeDeclaration.modifiers), packageDeclaration, memberTypeDeclaration.name)) {
804	// // compute encloising type names
805	// TypeDeclaration enclosing = memberTypeDeclaration.enclosingType;
806	// char[][] enclosingTypeNames = CharOperation.NO_CHAR_CHAR;
807	// while (enclosing != null) {
808	// enclosingTypeNames = CharOperation.arrayConcat(new char[][] {enclosing.name}, enclosingTypeNames);
809	// if ((enclosing.bits & ASTNode.IsMemberType) != 0) {
810	// enclosing = enclosing.enclosingType;
811	// } else {
812	// enclosing = null;
813	// }
814	// }
815	// // report
816	// nameRequestor.acceptType(memberTypeDeclaration.modifiers, packageDeclaration, memberTypeDeclaration.name, enclosingTypeNames, path, null);
817	// }
818	// return true;
819	// }
820	public boolean visit(InferredType inferredType, BlockScope scope) {	786	public boolean visit(InferredType inferredType, BlockScope scope) {
821	if (bindingType==Binding.TYPE &&	787	if (bindingType==Binding.TYPE &&
822	match(typeSuffix, packageName, bindingName, matchRule, TypeDeclaration.kind(0), packageDeclaration, inferredType.getName())) {	788	match(typeSuffix, packageName, bindingName, matchRule, TypeDeclaration.kind(0), packageDeclaration, inferredType.getName())) {
Lines 885-908 Link Here
885	IndexManager indexManager = JavaModelManager.getJavaModelManager().getIndexManager();	851	IndexManager indexManager = JavaModelManager.getJavaModelManager().getIndexManager();
886	final TypeDeclarationPattern pattern = new SecondaryTypeDeclarationPattern();	852	final TypeDeclarationPattern pattern = new SecondaryTypeDeclarationPattern();
887		853
888	// Get working copy path(s). Store in a single string in case of only one to optimize comparison in requestor	854	// Get working copy path(s). Store in a single string in case of only one to optimize comparison in requester
889	final HashSet workingCopyPaths = new HashSet();	855	final HashSet workingCopyPaths = this.getWorkingCopiesPaths();
890	String workingCopyPath = null;
891	IJavaScriptUnit[] copies = getWorkingCopies();
892	final int copiesLength = copies == null ? 0 : copies.length;
893	if (copies != null) {
894	if (copiesLength == 1) {
895	workingCopyPath = copies[0].getPath().toString();
896	} else {
897	for (int i = 0; i < copiesLength; i++) {
898	IJavaScriptUnit workingCopy = copies[i];
899	workingCopyPaths.add(workingCopy.getPath().toString());
900	}
901	}
902	}
903	final String singleWkcpPath = workingCopyPath;
904		856
905	// Index requestor	857	// Index requester
906	IndexQueryRequestor searchRequestor = new IndexQueryRequestor(){	858	IndexQueryRequestor searchRequestor = new IndexQueryRequestor(){
907	public boolean acceptIndexMatch(String documentPath, SearchPattern indexRecord, SearchParticipant participant, AccessRuleSet access) {	859	public boolean acceptIndexMatch(String documentPath, SearchPattern indexRecord, SearchParticipant participant, AccessRuleSet access) {
908	// Filter unexpected types	860	// Filter unexpected types
Lines 913-931 Link Here
913	if (record.enclosingTypeNames == IIndexConstants.ONE_ZERO_CHAR) {	865	if (record.enclosingTypeNames == IIndexConstants.ONE_ZERO_CHAR) {
914	return true; // filter out local and anonymous classes	866	return true; // filter out local and anonymous classes
915	}	867	}
916	switch (copiesLength) {	868
917	case 0:	869	if (workingCopyPaths.contains(documentPath)) {
918	break;	870	return true; // filter out working copies
919	case 1:
920	if (singleWkcpPath.equals(documentPath)) {
921	return true; // fliter out the working copy
922	}
923	break;
924	default:
925	if (workingCopyPaths.contains(documentPath)) {
926	return true; // filter out working copies
927	}
928	break;
929	}	871	}
930		872
931	// Accept document path	873	// Accept document path
Lines 1610-1616 Link Here
1610	record.modifiers,	1552	record.modifiers,
1611	record.declaringSimpleName,	1553	record.declaringSimpleName,
1612	record.parameterCount,	1554	record.parameterCount,
1613	record.parameterTypes,	1555	record.parameterTypeNames,
1614	record.parameterNames,	1556	record.parameterNames,
1615	documentPath,	1557	documentPath,
1616	accessRestriction);	1558	accessRestriction);
Lines 1637-1640 Link Here
1637	}	1579	}
1638	}	1580	}
1639	}	1581	}
		1582
		1583	/**
		1584	* <p>Searches for all methods in the index and working copies.</p>
		1585	*
		1586	* @param functionRequester requester to report results to
		1587	* @param selectorPattern selector pattern that the results need to match
		1588	* @param declaringType type that all results must be defined on
		1589	* @param selectorPatternMatchRule the match rule used with the given <code>selectorPattern</code>
		1590	* @param scope of the search
		1591	* @param waitingPolicy policy to use when waiting for the index to index
		1592	* @param progressMonitor monitor to report status too
		1593	*
		1594	* @see SearchPattern
		1595	*
		1596	* @see IJob#ForceImmediate
		1597	* @see IJob#CancelIfNotReady
		1598	* @see IJob#WaitUntilReady
		1599	*/
		1600	public void searchAllFunctions(final IFunctionRequester functionRequester,
		1601	char[] selectorPattern, String declaringType, final int selectorPatternMatchRule,
		1602	IJavaScriptSearchScope scope,
		1603	int waitingPolicy, IProgressMonitor progressMonitor) {
		1604
		1605	//determine the declaring type pattern characters
		1606	char[] declaringTypePatternChars = null;
		1607	if(declaringType != null && declaringType.trim().length() > 0) {
		1608	declaringTypePatternChars = declaringType.toCharArray();
		1609	}
		1610
		1611	//pattern for searching the index and working copies
		1612	final MethodPattern searchPattern = new MethodPattern(true, false,
		1613	selectorPattern, declaringTypePatternChars, selectorPatternMatchRule);
		1614
		1615	//requester used to accept index matches
		1616	final HashSet workingCopiesPaths = this.getWorkingCopiesPaths();
		1617	IndexQueryRequestor queryRequestor = new IndexQueryRequestor() {
		1618	/**
		1619	* @see org.eclipse.wst.jsdt.internal.core.search.IndexQueryRequestor#acceptIndexMatch(java.lang.String, org.eclipse.wst.jsdt.core.search.SearchPattern, org.eclipse.wst.jsdt.core.search.SearchParticipant, org.eclipse.wst.jsdt.internal.compiler.env.AccessRuleSet)
		1620	*/
		1621	public boolean acceptIndexMatch(String documentPath,
		1622	SearchPattern indexRecord, SearchParticipant participant,
		1623	AccessRuleSet access) {
		1624
		1625	if(!workingCopiesPaths.contains(documentPath)) {
		1626	MethodPattern record = (MethodPattern)indexRecord;
		1627	functionRequester.acceptFunction(record.selector, record.parameterCount,
		1628	record.parameterQualifications, record.parameterSimpleNames, record.parameterNames,
		1629	record.returnQualification, record.returnSimpleName,
		1630	record.declaringQualification, record.declaringSimpleName,
		1631	record.modifiers,
		1632	documentPath);
		1633	}
		1634
		1635	return true;
		1636	}
		1637	};
		1638
		1639	// Find function matches from index
		1640	IndexManager indexManager = JavaModelManager.getJavaModelManager().getIndexManager();
		1641	try {
		1642	if (progressMonitor != null) {
		1643	progressMonitor.beginTask(Messages.engine_searching, 1000);
		1644	}
		1645
1646	indexManager.performConcurrentJob(
1647	new PatternSearchJob(
1648	searchPattern,
1649	getDefaultSearchParticipant(), // JavaScript search only
1650	scope,
1651	queryRequestor),
1652	waitingPolicy,
1653	progressMonitor == null ? null : new SubProgressMonitor(progressMonitor, 1000));
1654	} finally {
1655	if (progressMonitor != null) {
1656	progressMonitor.done();
1657	}
1658	}
1659
1660	// find function matches from working copies
1661	IJavaScriptUnit[] workingCopies = this.getWorkingCopies();
1662	for (int i = 0; workingCopies != null && i < workingCopies.length; i++) {
1663	final IJavaScriptUnit workingCopy = workingCopies[i];
1664
1665	//skip this working copy if not in the scope
1666	if(!scope.encloses(workingCopy)) {
1667	continue;
1668	}
1669
1670	try {
1671	/* if working copy is consistent use the working copy as is
1672	* else need to re-parse the working copy and visit its AST
1673	*/
1674	if (workingCopy.isConsistent()) {
1675	//check each function in the working copy for a match
1676	IFunction[] allFunctions = workingCopy.getFunctions();
1677	for (int j = 0; j < allFunctions.length; ++j) {
1678	IFunction function = allFunctions[j];
1679
1680	//selector must not be null for it to be a match
1681	char[] wcSelector = null;
1682	if(function.getElementName() != null) {
1683	wcSelector = function.getElementName().toCharArray();
1684	}
1685	if(wcSelector != null) {
1686
1687	//create a pattern from the working copy method
1688	char[] wcDeclaringType = null;
1689	if(function.getDeclaringType() != null && function.getDeclaringType().getTypeQualifiedName() != null) {
1690	wcDeclaringType = function.getDeclaringType().getTypeQualifiedName().toCharArray();
1691	}
1692	MethodPattern wcPattern = new MethodPattern(true, false,
1693	wcSelector ,wcDeclaringType, selectorPatternMatchRule);
1694
1695	//if working copy function matches the search pattern then accept the function
1696	if(searchPattern.matchesDecodedKey(wcPattern)) {
1697	//figure out parameter names and types
1698	String[] wcParameterNames = function.getParameterNames();
1699	char[][][] wcSeperatedParamTypes =
1700	QualificationHelpers.seperateFullyQualifiednames(function.getParameterTypes(), wcParameterNames.length);
1701
1702	//figure out the return type parts
1703	char[] wcReturnQualification = null;
1704	char[] wcReturnSimpleName = null;
1705	String wcReturnTypeSig = function.getReturnType();
1706	if(wcReturnTypeSig != null) {
1707	char[] wcReturnType = Signature.toString(wcReturnTypeSig).toCharArray();
1708	char[][] wcSeperatedReturnType =
1709	QualificationHelpers.seperateFullyQualifedName(wcReturnType);
1710	wcReturnQualification = wcSeperatedReturnType[QualificationHelpers.QULIFIERS_INDEX];
1711	wcReturnSimpleName = wcSeperatedReturnType[QualificationHelpers.SIMPLE_NAMES_INDEX];
1712	}
1713
1714	//get the declaring type parts
1715	char[][] wcSeperatedDeclaringType = QualificationHelpers.seperateFullyQualifedName(wcDeclaringType);
1716
1717	//accept the method
1718	functionRequester.acceptFunction(wcSelector, wcParameterNames.length,
1719	wcSeperatedParamTypes[QualificationHelpers.QULIFIERS_INDEX],
1720	wcSeperatedParamTypes[QualificationHelpers.SIMPLE_NAMES_INDEX],
1721	QualificationHelpers.stringArrayToCharArray(wcParameterNames),
1722	wcReturnQualification, wcReturnSimpleName,
1723	wcSeperatedDeclaringType[QualificationHelpers.QULIFIERS_INDEX],
1724	wcSeperatedDeclaringType[QualificationHelpers.SIMPLE_NAMES_INDEX],
1725	function.getFlags(), workingCopy.getPath().toString());
1726	}
1727	}
1728	}
1729	} else {
1730	Parser basicParser = getParser();
1731	ICompilationUnit unit = (ICompilationUnit) workingCopy;
1732	CompilationResult compilationUnitResult = new CompilationResult(unit, 0, 0, this.compilerOptions.maxProblemsPerUnit);
1733	CompilationUnitDeclaration parsedUnit = basicParser.dietParse(unit, compilationUnitResult);
1734	if (parsedUnit != null) {
1735	basicParser.inferTypes(parsedUnit, null);
1736	parsedUnit.traverse( new ASTVisitor() {
1737	/**
1738	* @see org.eclipse.wst.jsdt.internal.compiler.ASTVisitor#visit(org.eclipse.wst.jsdt.internal.compiler.ast.MethodDeclaration, org.eclipse.wst.jsdt.internal.compiler.lookup.Scope)
1739	*/
1740	public boolean visit(MethodDeclaration methodDeclaration, Scope scope) {
1741	if(methodDeclaration.inferredMethod != null) {
1742	this.visit(methodDeclaration.inferredMethod);
1743	} else {
1744	this.visit(methodDeclaration, methodDeclaration.getName(), null);
1745	}
1746
1747	return true;
1748	}
1749
1750	/**
1751	* @see org.eclipse.wst.jsdt.internal.compiler.ASTVisitor#visit(org.eclipse.wst.jsdt.core.infer.InferredMethod, org.eclipse.wst.jsdt.internal.compiler.lookup.BlockScope)
1752	*/
1753	public boolean visit(InferredMethod inferredMethod, BlockScope scope) {
1754	visit(inferredMethod);
1755	return true;
1756	}
1757
1758	/**
1759	* <p>Visits an {@link InferredMethod} on a working copy</p>
1760	*
1761	* @param inferredMethod {@link InferredMethod} on the working copy to visit
1762	*/
1763	private void visit(InferredMethod inferredMethod) {
1764	char[] wcDeclaringType = null;
1765	if(inferredMethod.inType != null) {
1766	wcDeclaringType = inferredMethod.inType.getName();
1767	}
1768
1769	this.visit(inferredMethod.getFunctionDeclaration(),
1770	inferredMethod.name, wcDeclaringType);
1771	}
1772
1773	/**
1774	* <p>Visits an {@link IFunctionDeclaration} using a given selector name
1775	* and declaring type</p>
1776	*
1777	* @param funcDecl function declaration to visit
1778	* @param wcSelector selector to use when visiting the declaration
1779	* @param wcDeclaringType declaring type to use when visiting the declaration
1780	*/
1781	private void visit(IFunctionDeclaration funcDecl,
1782	char[] wcSelector, char[] wcDeclaringType) {
1783
1784	//create the working copy pattern
1785	MethodPattern wcPattern = new MethodPattern(true, false,
1786	wcSelector,wcDeclaringType, selectorPatternMatchRule);
1787
1788	//if working copy function matches the search pattern then accept the function qualification
1789	if(searchPattern.matchesDecodedKey(wcPattern)) {
1790	//get parameter names and types
1791	IArgument[] args = funcDecl.getArguments();
1792	char[][] wcParameterNames = null;
1793	char[][] wcParameterQualifications = null;
1794	char[][] wcParameterSimpleNames = null;
1795	int wcParametersLength = 0;
1796	if(args != null) {
1797	wcParameterNames = new char[args.length][];
1798	wcParameterQualifications = new char[args.length][];
1799	wcParameterSimpleNames = new char[args.length][];
1800	wcParametersLength = args.length;
1801
1802	for(int i = 0; i < args.length; ++i) {
1803	wcParameterNames[i] = args[i].getName();
1804	if(args[i].getInferredType() != null) {
1805	char[][] wcSeperatedParamType =
1806	QualificationHelpers.seperateFullyQualifedName(args[i].getInferredType().getName());
1807	wcParameterQualifications[i] = wcSeperatedParamType[QualificationHelpers.QULIFIERS_INDEX];
1808	wcParameterSimpleNames[i] = wcSeperatedParamType[QualificationHelpers.SIMPLE_NAMES_INDEX];
1809	}
1810	}
1811	}
1812
1813	//get return type
1814	char[] wcReturnQualification = null;
1815	char[] wcReturnSimpleName = null;
1816	if(funcDecl.getInferredType() != null) {
1817	char[][] seperatedReturnType = QualificationHelpers.seperateFullyQualifedName(
1818	funcDecl.getInferredType().getName());
1819	wcReturnQualification = seperatedReturnType[QualificationHelpers.QULIFIERS_INDEX];
1820	wcReturnSimpleName = seperatedReturnType[QualificationHelpers.SIMPLE_NAMES_INDEX];
1821	}
1822
1823	//get the declaring type parts
1824	char[][] wcSeperatedDeclaringType = QualificationHelpers.seperateFullyQualifedName(wcDeclaringType);
1825
1826	//get the modifiers
1827	int modifiers = 0;
1828	if(funcDecl instanceof MethodDeclaration) {
1829	modifiers = ((MethodDeclaration) funcDecl).modifiers;
1830	}
1831
1832	//accept the method
1833	functionRequester.acceptFunction(wcSelector, wcParametersLength,
1834	wcParameterQualifications,
1835	wcParameterSimpleNames,
1836	wcParameterNames,
1837	wcReturnQualification, wcReturnSimpleName,
1838	wcSeperatedDeclaringType[QualificationHelpers.QULIFIERS_INDEX],
1839	wcSeperatedDeclaringType[QualificationHelpers.SIMPLE_NAMES_INDEX],
1840	modifiers, workingCopy.getPath().toString());
1841	}
1842	}
1843	}, parsedUnit.scope);
1844	}
1845	}
1846	} catch(JavaScriptModelException e) {
1847	Logger.logException("Error while processing working copy", e);
1848	}
1849	}
1850	}
1640	}	1851	}




/*******************************************************************************
 * Copyright (c) 2011 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.wst.jsdt.internal.core.search;

/**
 * <p>Requester to use when requesting function matches.</p>
 */
public interface IFunctionRequester {

	/**
	 * <p>Accept a function defined with all of the given information.</p>
	 * 
	 * @param signature
	 * @param parameterCount
	 * @param parameterQualifications
	 * @param parameterSimpleNames
	 * @param parameterNames
	 * @param returnQualification
	 * @param returnSimpleName
	 * @param declaringQualification
	 * @param declaringSimpleName
	 * @param modifiers
	 * @param path
	 */
	public void acceptFunction(
				char[] signature,
				int parameterCount,
				char[][] parameterQualifications,
				char[][] parameterSimpleNames,
				char[][] parameterNames,
				char[] returnQualification,
				char[] returnSimpleName,
				char[] declaringQualification,
				char[] declaringSimpleName,
				int modifiers,
				String path);
}




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

import org.eclipse.wst.jsdt.internal.compiler.env.AccessRuleSet;

/**
 * <p>Requester used when searching an index for matches to a pattern.</p>
 */
public abstract class IndexQueryRequestor {

	/**
	 * <p>Accepts an index match when searching an index.</p>
	 * 
	 * @param documentPath
	 * @param indexRecord
	 * @param participant
	 * @param access
	 * 
	 * @return <code>true</code> to continue search, <code>false</code> to request cancel of search
	 */
	public abstract boolean acceptIndexMatch(String documentPath, SearchPattern indexRecord,
			SearchParticipant participant, AccessRuleSet access);

}

Lines 74-83 Link Here

(-)src/org/eclipse/wst/jsdt/internal/core/search/indexing/AbstractIndexer.java (-4 / +13 lines)
74	protected void addIndexEntry(char[] category, char[] key) {	74	protected void addIndexEntry(char[] category, char[] key) {
75	this.document.addIndexEntry(category, key);	75	this.document.addIndexEntry(category, key);
76	}	76	}
77	public void addMethodDeclaration(char[] methodName, char[][] parameterTypes,	77	public void addMethodDeclaration(char[] methodName, char[][] parameterTypes, char[][] paramaterNames,
78	char[] returnType,boolean isFunction) {	78	char[] returnType, char[] declaringType, boolean isFunction, int modifiers) {
79	int argCount = parameterTypes == null ? 0 : parameterTypes.length;	79	int argCount = parameterTypes == null ? 0 : parameterTypes.length;
80	addIndexEntry(isFunction ? FUNCTION_DECL : METHOD_DECL, MethodPattern.createIndexKey(methodName, argCount));	80
		81	//compute key
		82	char[] key = MethodPattern.createIndexKey(methodName, argCount,
		83	parameterTypes, paramaterNames, declaringType, returnType, modifiers);
		84	if(key != null) {
		85	addIndexEntry(isFunction ? FUNCTION_DECL : METHOD_DECL, key);
		86	}
81		87
82	if (parameterTypes != null) {	88	if (parameterTypes != null) {
83	for (int i = 0; i < argCount; i++)	89	for (int i = 0; i < argCount; i++)
Lines 87-93 Link Here
87	addTypeReference(returnType);	93	addTypeReference(returnType);
88	}	94	}
89	public void addMethodReference(char[] methodName, int argCount) {	95	public void addMethodReference(char[] methodName, int argCount) {
90	addIndexEntry(METHOD_REF, MethodPattern.createIndexKey(methodName, argCount));	96	char[] key = MethodPattern.createIndexKey(methodName, argCount);
		97	if(key != null) {
		98	addIndexEntry(METHOD_REF, key);
		99	}
91	}	100	}
92	public void addNameReference(char[] name) {	101	public void addNameReference(char[] name) {
93	addIndexEntry(REF, name);	102	addIndexEntry(REF, name);




public interface IIndexConstants {

	/* index encoding */
	final char[] REF= "ref".toCharArray(); //$NON-NLS-1$
	final char[] METHOD_REF= "methodRef".toCharArray(); //$NON-NLS-1$
	final char[] CONSTRUCTOR_REF= "constructorRef".toCharArray(); //$NON-NLS-1$
	final char[] SUPER_REF = "superRef".toCharArray(); //$NON-NLS-1$
	final char[] TYPE_DECL = "typeDecl".toCharArray(); //$NON-NLS-1$
	final char[] METHOD_DECL= "methodDecl".toCharArray(); //$NON-NLS-1$
	final char[] FUNCTION_DECL= "functionDecl".toCharArray(); //$NON-NLS-1$
	final char[] CONSTRUCTOR_DECL= "constructorDecl".toCharArray(); //$NON-NLS-1$
	final char[] FIELD_DECL= "fieldDecl".toCharArray(); //$NON-NLS-1$
	final char[] VAR_DECL= "varDecl".toCharArray(); //$NON-NLS-1$
	final char[] OBJECT = "Object".toCharArray(); //$NON-NLS-1$
	final char[][] COUNTS=
		new char[][] { new char[] {'/', '0'}, new char[] {'/', '1'}, new char[] {'/', '2'}, new char[] {'/', '3'}, new char[] {'/', '4'},
			new char[] {'/', '5'}, new char[] {'/', '6'}, new char[] {'/', '7'}, new char[] {'/', '8'}, new char[] {'/', '9'}
	};
	final char CLASS_SUFFIX = 'C';
	final char TYPE_SUFFIX = 0;
	final char SEPARATOR= '/';
	final char PARAMETER_SEPARATOR= ',';
	final char SECONDARY_SUFFIX = 'S';
	final char DOT = '.';

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

	// used as special marker for enclosing type name of local and anonymous classes
	final char ZERO_CHAR = '0';
	final char[] ONE_ZERO = new char[] { ZERO_CHAR };
	final char[][] ONE_ZERO_CHAR = new char[][] {ONE_ZERO};

	final int PKG_REF_PATTERN = 0x0001;
	final int PKG_DECL_PATTERN = 0x0002;
	final int TYPE_REF_PATTERN = 0x0004;
	final int TYPE_DECL_PATTERN = 0x0008;
	final int SUPER_REF_PATTERN = 0x0010;
	final int CONSTRUCTOR_PATTERN = 0x0020;
	final int FIELD_PATTERN = 0x0040;
	final int METHOD_PATTERN = 0x0080;
	final int OR_PATTERN = 0x0100;
	final int LOCAL_VAR_PATTERN = 0x0200;
}




import org.eclipse.wst.jsdt.internal.compiler.util.SuffixConstants;
import org.eclipse.wst.jsdt.internal.core.BasicCompilationUnit;
import org.eclipse.wst.jsdt.internal.core.JavaModelManager;
import org.eclipse.wst.jsdt.internal.core.Logger;
import org.eclipse.wst.jsdt.internal.core.search.JavaSearchDocument;
import org.eclipse.wst.jsdt.internal.core.search.processing.JobManager;
import org.eclipse.wst.jsdt.internal.oaametadata.LibraryAPIs;
import org.eclipse.wst.jsdt.internal.oaametadata.MetadataReader;
import org.eclipse.wst.jsdt.internal.oaametadata.MetadataSourceElementNotifier;

		try {
			parser.parseCompilationUnit(compilationUnit, true/*full parse*/);
		} catch (Exception e) {
			Logger.logException("Error while indexing document", e);
				e.printStackTrace();
			}
		}
	}
	public void indexMetadata() {

Lines 190-196 Link Here

(-)src/org/eclipse/wst/jsdt/internal/core/search/indexing/SourceIndexerRequestor.java (-1 / +3 lines)
190	*/	190	*/
191	public void enterMethod(MethodInfo methodInfo) {	191	public void enterMethod(MethodInfo methodInfo) {
192	boolean isFunction=this.depth==0;	192	boolean isFunction=this.depth==0;
193	this.indexer.addMethodDeclaration(methodInfo.name, methodInfo.parameterTypes, methodInfo.returnType,isFunction);	193	this.indexer.addMethodDeclaration(methodInfo.name, methodInfo.parameterTypes,
		194	methodInfo.parameterNames, methodInfo.returnType, methodInfo.declaringType,
		195	isFunction, methodInfo.modifiers);
194	this.methodDepth++;	196	this.methodDepth++;
195	}	197	}
196	/**	198	/**





import org.eclipse.wst.jsdt.core.compiler.CharOperation;
import org.eclipse.wst.jsdt.core.search.SearchPattern;
import org.eclipse.wst.jsdt.internal.compiler.classfmt.ClassFileConstants;

/**
 * <p>Pattern used to find and store constructor declarations.</p>
 */
public class ConstructorDeclarationPattern extends ConstructorPattern {
	/** <p> Modifiers for the constructor</p> */
	public int modifiers;
	
	/** <p>Fully qualified type names for the parameters of the constructor</p> */
	public char[][] parameterTypeNames;
	
	/** <p>names of the parameters</p> */
	public char[][] parameterNames;

	public ConstructorDeclarationPattern(char[] declaringSimpleName, int matchRule) {

		
		// initialize optional fields
		this.modifiers = 0;
		this.parameterTypeNames = null;
		this.parameterNames = null;
		
		/* if no parameters just decode modifiers
		 * else decode parameters and modifiers
		 */
		start = slash + 1;
		if (this.parameterCount <= 0 ) {
			slash = slash + 3;
			last = slash - 1;
			

			last = slash - 1;
			
			
			this.parameterTypeNames = CharOperation.splitOn(PARAMETER_SEPARATOR, key, start, slash);
			
			start = slash + 1;
			slash = CharOperation.indexOf(SEPARATOR, key, start);

			last = slash - 1;
			
			this.modifiers = key[last-1] + (key[last]<<16);
		} else {
			this.modifiers = ClassFileConstants.AccPublic;
		}
	}
	

		if (parameterCount > 0) {
			//get param types
			if (parameterTypes != null && parameterTypes.length == parameterCount) {
				parameterTypesChars = CharOperation.concatWith(parameterTypes, PARAMETER_SEPARATOR, false);
				for (int i = 0; i < parameterTypes.length; i++) {
					parameterTypeErasures[i] = getTypeErasure(parameterTypes[i]);
				}
				parameterTypesChars = CharOperation.concatWith(parameterTypeErasures, PARAMETER_SEPARATOR, false);
			}
			
			//get param names

		
		return result;
	}
	
	private static char[] getTypeErasure(char[] typeName) {
		char[] typeErasurename = new char[0];
		if(typeName != null) {
			int index;
			if ((index = CharOperation.indexOf('<', typeName)) == -1) return typeName;
			
			int length = typeName.length;
			typeErasurename = new char[length - 2];
			
			System.arraycopy(typeName, 0, typeErasurename, 0, index);
			
			int depth = 1;
			for (int i = index + 1; i < length; i++) {
				switch (typeName[i]) {
					case '<':
						depth++;
						break;
					case '>':
						depth--;
						break;
					default:
						if (depth == 0) {
							typeErasurename[index++] = typeName[i];
						}
						break;
				}
			}
			
			System.arraycopy(typeErasurename, 0, typeErasurename = new char[index], 0, index);
		}
		return typeErasurename;
	}
}

Lines 21-27 Link Here

(-)src/org/eclipse/wst/jsdt/internal/core/search/matching/DeclarationOfReferencedMethodsPattern.java (-1 / +1 lines)
21	protected SimpleSet knownMethods;	21	protected SimpleSet knownMethods;
22		22
23	public DeclarationOfReferencedMethodsPattern(IJavaScriptElement enclosingElement) {	23	public DeclarationOfReferencedMethodsPattern(IJavaScriptElement enclosingElement) {
24	super(false, true, false,null, null, null, null, null, null, null, null, R_PATTERN_MATCH);	24	super(false, true, false,null, R_PATTERN_MATCH);
25		25
26	this.enclosingElement = enclosingElement;	26	this.enclosingElement = enclosingElement;
27	this.knownMethods = new SimpleSet();	27	this.knownMethods = new SimpleSet();

Lines 926-935 Link Here

(-)src/org/eclipse/wst/jsdt/internal/core/search/matching/MatchLocator.java (-4 lines)
926	}	926	}
927	// Get binding from unit scope	927	// Get binding from unit scope
928	char[] typeName = PatternLocator.qualifiedPattern(methodPattern.declaringSimpleName, methodPattern.declaringQualification);	928	char[] typeName = PatternLocator.qualifiedPattern(methodPattern.declaringSimpleName, methodPattern.declaringQualification);
929	if (typeName == null) {
930	if (methodPattern.declaringType == null) return null;
931	typeName = methodPattern.declaringType.getFullyQualifiedName().toCharArray();
932	}
933	TypeBinding declaringTypeBinding = getType(typeName, typeName);	929	TypeBinding declaringTypeBinding = getType(typeName, typeName);
934	if (declaringTypeBinding != null) {	930	if (declaringTypeBinding != null) {
935	if (declaringTypeBinding.isArrayType()) {	931	if (declaringTypeBinding.isArrayType()) {




import org.eclipse.wst.jsdt.core.infer.InferredMethod;
import org.eclipse.wst.jsdt.core.search.MethodDeclarationMatch;
import org.eclipse.wst.jsdt.core.search.SearchMatch;
import org.eclipse.wst.jsdt.core.search.SearchPattern;
import org.eclipse.wst.jsdt.internal.compiler.ast.ASTNode;
import org.eclipse.wst.jsdt.internal.compiler.ast.AbstractMethodDeclaration;
import org.eclipse.wst.jsdt.internal.compiler.ast.Argument;

				this.pattern.declaringSimpleName,
				this.pattern.declaringQualification,
				locator,
				null,
				locator.progressMonitor).collect();
	} catch (JavaScriptModelException e) {
		// inaccurate matches will be found

		}
	}

	// Verify type arguments (do not reject if pattern has no argument as it can be an erasure match)
	if (this.pattern.hasMethodArguments()) {
		return IMPOSSIBLE_MATCH;
	}

	// Method declaration may match pattern
	return nodeSet.addMatch(node, resolve ? POSSIBLE_MATCH : ACCURATE_MATCH);
}

	if (!this.pattern.findReferences) return IMPOSSIBLE_MATCH;

	if (!matchesName(this.pattern.selector, node.selector)) return IMPOSSIBLE_MATCH;
	if (this.pattern.parameterSimpleNames != null && ((node.bits & ASTNode.InsideJavadoc) != 0)) {
		int length = this.pattern.parameterSimpleNames.length;
		ASTNode[] args = node.arguments;
		int argsLength = args == null ? 0 : args.length;

	}
}
void matchReportReference(MessageSend messageSend, MatchLocator locator, MethodBinding methodBinding) throws CoreException {

	if (this.pattern.hasMethodArguments()) { // binding has no type params, compatible erasure if pattern does
		match.setRule(SearchPattern.R_ERASURE_MATCH);
	}

	// See whether it is necessary to report or not
	if (match.getRule() == 0) return; // impossible match
	boolean report = (this.isErasureMatch && match.isErasure()) || (this.isEquivalentMatch && match.isEquivalent()) || match.isExact();

	match.setLength(messageSend.sourceEnd - offset + 1);
	locator.report(match);
}
/*
 * Return whether method parameters are equals to pattern ones.
 */
private boolean methodParametersEqualsPattern(MethodBinding method) {
	TypeBinding[] methodParameters = method.parameters;

	int length = methodParameters.length;
	if (length != this.pattern.parameterSimpleNames.length) return false;

	for (int i = 0; i < length; i++) {
		char[] paramQualifiedName = qualifiedPattern(this.pattern.parameterSimpleNames[i], this.pattern.parameterQualifications[i]);
		if (!CharOperation.match(paramQualifiedName, methodParameters[i].readableName(), this.isCaseSensitive)) {
			return false;
		}
	}
	return true;
}
public SearchMatch newDeclarationMatch(ASTNode reference, IJavaScriptElement element, Binding elementBinding, int accuracy, int length, MatchLocator locator) {
	if (elementBinding != null) {
		MethodBinding methodBinding = (MethodBinding) elementBinding;

						nodeSet.mustResolve = true;
						resolve = true;
					}
					this.methodDeclarationsWithInvalidParam.put(inferredMethod.getFunctionDeclaration(), null);
				} else {
					return IMPOSSIBLE_MATCH;
				}





import java.io.IOException;

import org.eclipse.wst.jsdt.core.Flags;
import org.eclipse.wst.jsdt.core.IFunction;
import org.eclipse.wst.jsdt.core.IType;
import org.eclipse.wst.jsdt.core.JavaScriptModelException;
import org.eclipse.wst.jsdt.core.compiler.CharOperation;
import org.eclipse.wst.jsdt.core.search.SearchPattern;
import org.eclipse.wst.jsdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.wst.jsdt.internal.core.Logger;
import org.eclipse.wst.jsdt.internal.core.index.EntryResult;
import org.eclipse.wst.jsdt.internal.core.index.Index;
import org.eclipse.wst.jsdt.internal.core.util.QualificationHelpers;

public class MethodPattern extends JavaSearchPattern  {

protected boolean findDeclarations;
protected boolean findReferences;

public char[] selector;

public char[] declaringQualification;
public char[] declaringSimpleName;

public char[] returnQualification;
public char[] returnSimpleName;

public char[][] parameterQualifications;
public char[][] parameterSimpleNames;
public int parameterCount;
public boolean varargs = false;

protected boolean isFunction;
// extra reference info
protected IType declaringType;

// Signatures and arguments for generic search
char[][] returnTypeSignatures;
char[][][] returnTypeArguments;
char[][][] parametersTypeSignatures;
char[][][][] parametersTypeArguments;
boolean methodParameters = false;
char[][] methodArguments;

protected static char[][] REF_CATEGORIES = { METHOD_REF };
protected static char[][] REF_AND_DECL_CATEGORIES = { METHOD_REF, METHOD_DECL };
protected static char[][] DECL_CATEGORIES = { METHOD_DECL };
protected static char[][] FUNCTION_REF_AND_DECL_CATEGORIES = { METHOD_REF, FUNCTION_DECL, METHOD_DECL };
protected static char[][] FUNCTION_DECL_CATEGORIES = { FUNCTION_DECL, METHOD_DECL };

/**
 * <p>Pattern used when adding functions to an index or searching an index for functions.</p>
 * e.g. 'foo/0'
 */
public static char[] createIndexKey(char[] selector, int argCount) {
	char[] countChars = argCount < 10
		? COUNTS[argCount]
		: ("/" + String.valueOf(argCount)).toCharArray(); //$NON-NLS-1$
	return CharOperation.concat(selector, countChars);
}

MethodPattern(int matchRule, boolean isFunction) {
	super(METHOD_PATTERN, matchRule);
	this.isFunction=isFunction;
}
public MethodPattern(
	boolean findDeclarations,
	boolean findReferences,
	boolean isFunction,
	char[] selector,
	char[] declaringQualification,
	char[] declaringSimpleName,
	char[] returnQualification,
	char[] returnSimpleName,
	char[][] parameterQualifications,
	char[][] parameterSimpleNames,
	IType declaringType,
	int matchRule) {

	this(matchRule,isFunction);

	this.findDeclarations = findDeclarations;
	this.findReferences = findReferences;

	this.selector = (isCaseSensitive() || isCamelCase())  ? selector : CharOperation.toLowerCase(selector);
	this.declaringQualification = isCaseSensitive() ? declaringQualification : CharOperation.toLowerCase(declaringQualification);
	this.declaringSimpleName = isCaseSensitive() ? declaringSimpleName : CharOperation.toLowerCase(declaringSimpleName);
	this.returnQualification = isCaseSensitive() ? returnQualification : CharOperation.toLowerCase(returnQualification);
	this.returnSimpleName = isCaseSensitive() ? returnSimpleName : CharOperation.toLowerCase(returnSimpleName);
	if (parameterSimpleNames != null) {
		this.parameterCount = parameterSimpleNames.length;
		this.parameterQualifications = new char[this.parameterCount][];
		this.parameterSimpleNames = new char[this.parameterCount][];
		for (int i = 0; i < this.parameterCount; i++) {
			this.parameterQualifications[i] = isCaseSensitive() ? parameterQualifications[i] : CharOperation.toLowerCase(parameterQualifications[i]);
			this.parameterSimpleNames[i] = isCaseSensitive() ? parameterSimpleNames[i] : CharOperation.toLowerCase(parameterSimpleNames[i]);
		}
	} else {
		this.parameterCount = -1;
	}
	this.declaringType = declaringType;
	((InternalSearchPattern)this).mustResolve = mustResolve();
}
/*
 * Instanciate a method pattern with signatures for generics search
 */
public class MethodPattern extends JavaSearchPattern  {
	boolean findDeclarations,
	boolean findReferences,
	boolean isFunction,
	char[] selector,
	char[] declaringQualification,
	char[] declaringSimpleName,
	char[] returnQualification,
	char[] returnSimpleName,
	String returnSignature,
	char[][] parameterQualifications,
	char[][] parameterSimpleNames,
	String[] parameterSignatures,
	IFunction method,
	int matchRule) {

	this(findDeclarations,
		findReferences,
		isFunction,
		selector,
		declaringQualification,
		declaringSimpleName,
		returnQualification,
		returnSimpleName,
		parameterQualifications,
		parameterSimpleNames,
		method.getDeclaringType(),
		matchRule);

	protected static final char[][] REF_CATEGORIES = { METHOD_REF };
	protected static final char[][] REF_AND_DECL_CATEGORIES = { METHOD_REF, METHOD_DECL };
	protected static final char[][] DECL_CATEGORIES = { METHOD_DECL };
	protected static final char[][] FUNCTION_REF_AND_DECL_CATEGORIES = { METHOD_REF, FUNCTION_DECL, METHOD_DECL };
	protected static final char[][] FUNCTION_DECL_CATEGORIES = { FUNCTION_DECL, METHOD_DECL };
	
	/**
	 * <p><b>Required</b></p>
	 * 
	 * <p>Name of the function</p>
	 */
	public char[] selector;
	
	/**
	 * <p><b>Required</b></p>
	 * 
	 * <p>Number of specified parameters for this function.
	 * Must be equal to or greater then 0.</p>
	 */
	public int parameterCount;
	
	/**
	 * <p><b>Optional</b></p>
	 * 
	 * <p>Qualifications of the parameter types for this function.</p>
	 * <p>This should have the same length as {@link #parameterCount}, or
	 * <code>null</code> if {@link #parameterCount} is 0</p>
	 * 
	 * <p><b>Note:</b> If this field is defined then the {@link #parameterSimpleNames} must
	 * also be defined.</p>
	 * 
	 * @see #parameterSimpleNames
	 */
	public char[][] parameterQualifications;
	
	/**
	 * <p><b>Optional</b></p>
	 * 
	 * <p>Simple names of the parameter types for this function.</p>
	 * <p>This should have the same length as {@link #parameterCount}, or
	 * <code>null</code> if {@link #parameterCount} is 0</p>
	 * 
	 * <p><b>Note:</b> If this field is defined then the {@link #parameterQualifications}
	 * filed can be defined, but does not have to be.</p>
	 * 
	 * @see #parameterQualifications
	 */
	public char[][] parameterSimpleNames;
	
	/**
	 * <p><b>Required</b> if {@link #parameterCount} is greater then 0</p>
	 * 
	 * <p>Names of the defined parameters for this function.</p>
	 * <p>This should have the same length as {@link #parameterCount}, or
	 * <code>null</code> if {@link #parameterCount} is 0</p>
	 */
	public char[][] parameterNames;
	
	/**
	 * <p><b>Optional</b></p>
	 * 
	 * <p>Qualification of the return type of this function.</p>
	 * 
	 * <p><b>Note:</b> If this field is defined then the {@link #returnSimpleName} must
	 * also be defined.</p>
	 */
	public char[] returnQualification;
	
	/**
	 * <p><b>Optional</b></p>
	 * 
	 * <p>Simple name of the return type of this function.</p>
	 * 
	 * <p><b>Note:</b> If this field is defined then the {@link #returnQualification}
	 * filed can be defined, but does not have to be.</p>
	 */
	public char[] returnSimpleName;
	
	/**
	 * <p><b>Optional</b></p>
	 * 
	 * <p>Qualification of the declaring type containing this function.</p>
	 * 
	 * <p><b>Note:</b> If this field is defined then the {@link #declaringSimpleName} must
	 * also be defined.</p>
	 * 
	 * @see #declaringSimpleName
	 */
	public char[] declaringQualification;
	
	/**
	 * <p><b>Optional</b></p>
	 * 
	 * <p>Simple name of the declaring type containing this function.</p>
	 * 
	 * <p><b>Note:</b> If this field is defined then the {@link #declaringQualification}
	 * can be defined, but does not have to be.</p>
	 * 
	 * @see #declaringQualification
	 */
	public char[] declaringSimpleName;
	
	/**
	 * <p><b>Optional</b></p>
	 * 
	 * <p>Any modifiers for this function.</p>
	 * 
	 * @see ClassFileConstants
	 */
	public int modifiers;
	
	/**
	 * <p>When using this pattern to do a search <code>true</code> to
	 * find function declarations that match this pattern, <code>false</code> otherwise.</p>
	 */
	protected boolean findDeclarations;
	
	/**
	 * <p>When using this pattern to do a search <code>true</code> to
	 * find function references that match this pattern, <code>false</code> otherwise.</p>
	 */
	protected boolean findReferences;
	
	/**
	 * <p><code>true</code> if this pattern represents a function,
	 * <code>false</code> otherwise.</p>
	 * 
	 * <p><b>NOTE:</b> this whole concept should be removed, a function is a function is a function.</p>
	 */
	protected boolean isFunction;

	/**
	 * <p>Internal constructor for creating plank patterns</p>
	 *
	 * @param matchRule match rule used when comparing this pattern to search results
	 * @param isFunction <code>true</code> if this pattern represents a function,
	 * <code>false</code> otherwise
	 */
	MethodPattern(int matchRule, boolean isFunction) {
		super(METHOD_PATTERN, matchRule);
		this.isFunction=isFunction;
	}
	
	/**
	 * <p>Useful constructor when creating a pattern to search for index matches
	 * while doing content assist.</p>
	 *
	 * @param findDeclarations when using this pattern to do a search <code>true</code> to
	 * find function declarations that match this pattern, <code>false</code> otherwise.
	 * @param findReferences hen using this pattern to do a search <code>true</code> to
	 * find function references that match this pattern, <code>false</code> otherwise
	 * @param isFunction <code>true</code> if this pattern represents a function,
	 * <code>false</code> otherwise
	 * @param selector pattern for the name of the function
	 * @param selectorMatchRule match rule used when comparing this pattern to search results.
	 * This dictates what type of pattern is present, if any, in the specified <code>selector</code>
	 * 
	 * @see SearchPattern
	 */
	public MethodPattern(boolean findDeclarations,
			boolean findReferences,
			boolean isFunction,
			char[] selector,
			int selectorMatchRule) {
		
		this(findDeclarations, findReferences, isFunction, selector,
				null, null, null, null, null, null,
				selectorMatchRule);
	}
	
	/**
	 * <p>Useful constructor for finding index matches based on content assist pattern.</p>
	 *
	 * @param findDeclarations when using this pattern to do a search <code>true</code> to
	 * find function declarations that match this pattern, <code>false</code> otherwise.
	 * @param findReferences hen using this pattern to do a search <code>true</code> to
	 * find function references that match this pattern, <code>false</code> otherwise
	 * @param selector pattern for the name of the function
	 * @param declaringType optional declaring type that the given selector must be
	 * defined on to be a valid match, or <code>null</code> to specify the function is not
	 * defined on a type
	 * @param selectorMatchRule match rule used when comparing this pattern to search results.
	 * This dictates what type of pattern is present, if any, in the specified <code>selector</code>
	 */
	public MethodPattern(boolean findDeclarations, boolean findReferences,
			char[] selector, char[] declaringType,
			int selectorMatchRule){
		
		this(selectorMatchRule, true);
		
		this.findDeclarations = findDeclarations;
		this.findReferences = findReferences;
		this.selector = isCaseSensitive() ? selector : CharOperation.toLowerCase(selector);
		this.parameterCount = -1;
		
		char[][] seperatedDeclaringType = QualificationHelpers.seperateFullyQualifedName(declaringType);
		this.declaringQualification = isCaseSensitive() ?
				seperatedDeclaringType[QualificationHelpers.QULIFIERS_INDEX] : CharOperation.toLowerCase(seperatedDeclaringType[QualificationHelpers.QULIFIERS_INDEX]);
		this.declaringSimpleName = isCaseSensitive() ?
				seperatedDeclaringType[QualificationHelpers.SIMPLE_NAMES_INDEX] : CharOperation.toLowerCase(seperatedDeclaringType[QualificationHelpers.SIMPLE_NAMES_INDEX]);
	}
	
	/**
	 * <p>Constructor to create a pattern that accepts all possible information about a function.</p>
	 *
	 * @param findDeclarations
	 * @param findReferences
	 * @param isFunction
	 * @param selector
	 * @param declaringQualification
	 * @param declaringSimpleName
	 * @param returnQualification
	 * @param returnSimpleName
	 * @param parameterQualifications
	 * @param parameterSimpleNames
	 * @param matchRule
	 */
	public MethodPattern(
		boolean findDeclarations,
		boolean findReferences,
		boolean isFunction,
		char[] selector,
		char[][] parameterQualifications,
		char[][] parameterSimpleNames,
		char[] returnQualification,
		char[] returnSimpleName,
		char[] declaringQualification,
		char[] declaringSimpleName,
		int matchRule) {

		this(matchRule,isFunction);

		this.findDeclarations = findDeclarations;
		this.findReferences = findReferences;

		this.selector = (isCaseSensitive() || isCamelCase())  ? selector : CharOperation.toLowerCase(selector);
		this.declaringQualification = isCaseSensitive() ? declaringQualification : CharOperation.toLowerCase(declaringQualification);
		this.declaringSimpleName = isCaseSensitive() ? declaringSimpleName : CharOperation.toLowerCase(declaringSimpleName);
		this.returnQualification = isCaseSensitive() ? returnQualification : CharOperation.toLowerCase(returnQualification);
		this.returnSimpleName = isCaseSensitive() ? returnSimpleName : CharOperation.toLowerCase(returnSimpleName);
		if (parameterSimpleNames != null) {
			this.parameterCount = parameterSimpleNames.length;
			this.parameterQualifications = new char[this.parameterCount][];
			this.parameterSimpleNames = new char[this.parameterCount][];
			for (int i = 0; i < this.parameterCount; i++) {
				this.parameterQualifications[i] = isCaseSensitive() ? parameterQualifications[i] : CharOperation.toLowerCase(parameterQualifications[i]);
				this.parameterSimpleNames[i] = isCaseSensitive() ? parameterSimpleNames[i] : CharOperation.toLowerCase(parameterSimpleNames[i]);
			}
		} else {
			this.parameterCount = -1;
		}
		
		((InternalSearchPattern)this).mustResolve = false;
	}
	
	/**
	 * <p>Given an index key created by this class decodes that key into the
	 * various fields of this pattern.</p>
	 * 
	 * @param key to decode into the fields of this pattern
	 * 
	 * @see #createIndexKey(char[], int)
	 * @see #createIndexKey(char[], int, char[][], char[][], char[], char[], int)
	 * @see #createSearchIndexKey(char[], char[], char[], int)
	 * @see #createSearchIndexKey(char[], int, char[][], char[][], char[][], char[], char[], char[], char[], int)
	 */
	public void decodeIndexKey(char[] key) {
		char[][] seperated = CharOperation.splitOn(SEPARATOR, key);
		
		//get the selector
		this.selector = seperated[0];
		
		//get the parameter count
		this.parameterCount = Integer.parseInt(new String(seperated[1]));
		
		//get parameter types
		char[][][] parameterTypes = QualificationHelpers.seperateFullyQualifiedNames(seperated[2], this.parameterCount);
		this.parameterQualifications = parameterTypes[QualificationHelpers.QULIFIERS_INDEX];
		this.parameterSimpleNames = parameterTypes[QualificationHelpers.SIMPLE_NAMES_INDEX];
		
		//get parameter names
		char[][] parameterNames = CharOperation.splitOn(PARAMETER_SEPARATOR, seperated[3]);
		if(parameterNames.length > 0) {
			this.parameterNames = parameterNames;
		} else {
			this.parameterNames = null;
		}
		
		//get the return type
		char[][] returnType = QualificationHelpers.seperateFullyQualifedName(seperated[4]);
		this.returnQualification = returnType[QualificationHelpers.QULIFIERS_INDEX];
		this.returnSimpleName = returnType[QualificationHelpers.SIMPLE_NAMES_INDEX];
		
		//get the declaration type
		char[][] declaringType = QualificationHelpers.seperateFullyQualifedName(seperated[5]);
		this.declaringQualification = declaringType[QualificationHelpers.QULIFIERS_INDEX];
		this.declaringSimpleName = declaringType[QualificationHelpers.SIMPLE_NAMES_INDEX];
		
		//get the modifiers
		this.modifiers = seperated[6][0] + seperated[6][1];
	}
	
	public SearchPattern getBlankPattern() {
		return new MethodPattern(R_EXACT_MATCH | R_CASE_SENSITIVE,isFunction);
	}
	public char[][] getIndexCategories() {
		if (this.findReferences)
			return this.findDeclarations ?
					(isFunction ? FUNCTION_REF_AND_DECL_CATEGORIES : REF_AND_DECL_CATEGORIES)
					: REF_CATEGORIES;
		if (this.findDeclarations)
			return isFunction ? FUNCTION_DECL_CATEGORIES : DECL_CATEGORIES;
		return CharOperation.NO_CHAR_CHAR;
	}

	boolean hasMethodParameters() {
		return this.parameterCount > 0;
	}
	boolean isPolymorphicSearch() {
		return this.findReferences;
	}
	
	/**
	 * @see org.eclipse.wst.jsdt.core.search.SearchPattern#matchesDecodedKey(org.eclipse.wst.jsdt.core.search.SearchPattern)
	 */
	public boolean matchesDecodedKey(SearchPattern decodedPattern) {
		boolean matches = false;
		if(decodedPattern instanceof MethodPattern) {
			MethodPattern pattern = (MethodPattern) decodedPattern;
			
			matches = matchesName(this.selector, pattern.selector)
					&& (this.parameterCount == pattern.parameterCount || this.parameterCount == -1)
					&& matchesName(this.returnQualification, pattern.returnSimpleName)
					&& matchesName(this.returnSimpleName, pattern.returnSimpleName)
					&& matchesName(this.declaringQualification, pattern.declaringQualification)
					&& matchesName(this.declaringSimpleName, pattern.declaringSimpleName);
			
			if(matches) {
				for(int i = 0; i < this.parameterCount && matches; ++i) {
					matches = matches
							&& matchesName(this.parameterQualifications[i], pattern.parameterQualifications[i])
							&& matchesName(this.parameterSimpleNames[i], pattern.parameterSimpleNames[i]);
				}
			}
		}
		
		return matches;
	}
	
	/**
	 * @see org.eclipse.wst.jsdt.internal.core.search.matching.InternalSearchPattern#queryIn(org.eclipse.wst.jsdt.internal.core.index.Index)
	 */
	EntryResult[] queryIn(Index index) throws IOException {
		char[] key = this.selector; // can be null
		int matchRule = getMatchRule();
	
		int matchRuleToUse = matchRule;
		switch(getMatchMode()) {
			case R_EXACT_MATCH :
				key = createSearchIndexKey(this.selector, this.parameterCount,
						this.parameterQualifications, this.parameterSimpleNames,
						this.parameterNames, this.returnQualification, this.returnSimpleName,
						this.declaringQualification, this.declaringSimpleName, this.modifiers);
				break;
			case R_PREFIX_MATCH :
				char[] selector = CharOperation.concat(this.selector, ONE_STAR);
				
				key = createSearchIndexKey(selector,
						this.declaringQualification, this.declaringSimpleName,
						this.modifiers);
				
				//the prefix match refers to the selector, but to do the actual match need to use a pattern
				matchRuleToUse = R_PATTERN_MATCH;
				break;
			case R_PATTERN_MATCH :
				key = createSearchIndexKey(this.selector,
						this.declaringQualification, this.declaringSimpleName,
						this.modifiers);
				break;
			case R_REGEXP_MATCH :
				// TODO implement regular expression match
				Logger.log(Logger.WARNING, "Regular expression matching is not yet implimented for MethodPattern");
				break;
		}
	
		return index.query(getIndexCategories(), key, matchRuleToUse); // match rule is irrelevant when the key is null
	}
	
	/**
	 * @see org.eclipse.wst.jsdt.internal.core.search.matching.JavaSearchPattern#print(java.lang.StringBuffer)
	 */
	protected StringBuffer print(StringBuffer output) {
		if (this.findDeclarations) {
			output.append(this.findReferences
				? "MethodCombinedPattern: " //$NON-NLS-1$
				: "MethodDeclarationPattern: "); //$NON-NLS-1$
		} else {
			output.append("MethodReferencePattern: "); //$NON-NLS-1$
		}
		if (declaringQualification != null)
			output.append(declaringQualification).append('.');
		if (declaringSimpleName != null)
			output.append(declaringSimpleName).append('.');
		else if (declaringQualification != null)
			output.append("*."); //$NON-NLS-1$

		if (selector != null)
			output.append(selector);
		else
			output.append("*"); //$NON-NLS-1$
		output.append('(');
		if (parameterSimpleNames == null) {
			output.append("..."); //$NON-NLS-1$
		} else {
			for (int i = 0, max = parameterSimpleNames.length; i < max; i++) {
				if (i > 0) output.append(", "); //$NON-NLS-1$
				if (parameterQualifications[i] != null) output.append(parameterQualifications[i]).append('.');
				if (parameterSimpleNames[i] == null) output.append('*'); else output.append(parameterSimpleNames[i]);
			}
		}
		output.append(')');
		if (returnQualification != null)
			output.append(" --> ").append(returnQualification).append('.'); //$NON-NLS-1$
		else if (returnSimpleName != null)
			output.append(" --> "); //$NON-NLS-1$
		if (returnSimpleName != null)
			output.append(returnSimpleName);
		else if (returnQualification != null)
			output.append("*"); //$NON-NLS-1$
		return super.print(output);
	}
	
	/**
	 * <p>Create an index key from a selector and a parameter count.</p>
	 * 
	 * <p><b>Note</b> Currently used to index function references, but the
	 * validity of this use is questionable.</p>
	 * 
	 * @param selector
	 * @param parameterCount
	 * 
	 * @return a function index key created from a selector and a parameter count
	 */
	public static char[] createIndexKey(char[] selector, int parameterCount) {
		return createIndexKey(selector, parameterCount, null, null, null, null, 0);
	return methodArguments != null && methodArguments.length > 0;
}
boolean hasMethodParameters() {
	return methodParameters;
}
boolean isPolymorphicSearch() {
	return this.findReferences;
}
public boolean matchesDecodedKey(SearchPattern decodedPattern) {
	MethodPattern pattern = (MethodPattern) decodedPattern;

	return (this.parameterCount == pattern.parameterCount || this.parameterCount == -1 || this.varargs)
		&& matchesName(this.selector, pattern.selector);
}
/**
 * Returns whether a method declaration or message send must be resolved to
 * find out if this method pattern matches it.
 */
protected boolean mustResolve() {
	// declaring type
	// If declaring type is specified - even with simple name - always resolves
	if (declaringSimpleName != null || declaringQualification != null) return true;

	// return type
	// If return type is specified - even with simple name - always resolves
	if (returnSimpleName != null || returnQualification != null) return true;

	// parameter types
	if (parameterSimpleNames != null)
		for (int i = 0, max = parameterSimpleNames.length; i < max; i++)
			if (parameterQualifications[i] != null) return true;
	return false;
}
EntryResult[] queryIn(Index index) throws IOException {
	char[] key = this.selector; // can be null
	int matchRule = getMatchRule();

	switch(getMatchMode()) {
		case R_EXACT_MATCH :
			if (this.isCamelCase) break;
			if (this.selector != null && this.parameterCount >= 0 && !this.varargs)
				key = createIndexKey(this.selector, this.parameterCount);
			else { // do a prefix query with the selector
				matchRule &= ~R_EXACT_MATCH;
				matchRule |= R_PREFIX_MATCH;
			}
			break;
		case R_PREFIX_MATCH :
			// do a prefix query with the selector
			break;
		case R_PATTERN_MATCH :
			if (this.parameterCount >= 0 && !this.varargs)
				key = createIndexKey(this.selector == null ? ONE_STAR : this.selector, this.parameterCount);
			else if (this.selector != null && this.selector[this.selector.length - 1] != '*')
				key = CharOperation.concat(this.selector, ONE_STAR, SEPARATOR);
			// else do a pattern query with just the selector
			break;
		case R_REGEXP_MATCH :
			// TODO (frederic) implement regular expression match
			break;
	}
	
	/**
	 * <p>Creates an index key based on the given function definition information.</p>
	 * 
	 * <p><b>Key Syntax</b>:
	 * <code>selector/parameterCount/parameterFullTypeNames/paramaterNames/returnFulLTypeName/declaringFullTypeName</code></p>
	 * 
	 * <p>
	 * <b>Examples:</b><ul>
	 * <li><code>myFunction/0////</code> - function with no parameters and no return type</li>
	 * <li><code>myFunction/0///String/</code> - function with no parameters with a return type</li>
	 * <li><code>myFunction/0////foo.bar.Type</code> - function on a type with no parameters and no return type</li>
	 * <li><code>myFunction/0///String/foo.bar.Type</code> - function on a type with no parameters with a return type </li>
	 * <li><code>myFunction/2//param1,param2//</code> - function with no parameter types, with parameter names with no return type</li>
	 * <li><code>myFunction/2//param1,param2/String/</code> - function with no parameter types, with parameter names with a return type</li>
	 * <li><code>myFunction/2//param1,param2//foo.bar.Type</code> - function on a type with no parameter types, with parameter  names with no return type</li>
	 * <li><code>myFunction/2//param1,param2/String/foo.bar.Type</code> - function on a type with no parameter types, with parameter names with a return type</li>
	 * <li><code>myFunction/2/String,Number/param1,param2//</code> - function with parameter types and names with no return type</li>
	 * <li><code>myFunction/2/String,Number/param1,param2/String/</code> - function with parameter types and names with a return type</li>
	 * <li><code>myFunction/2/String,Number/param1,param2//foo.bar.Type</code> - function on a type with parameter types and names with no return type</li>
	 * <li><code>myFunction/2/String,Number/param1,param2/String/foo.bar.Type</code> - function on a type with parameter types and names with a return type</li>
	 * <li><code>myFunction/2/,Number/param1,param2//</code> - function where only one of the parameters has a type</li>
	 * <li><code>myFunction/2/,Number/param1,param2/String/</code> - function where only one of the parameters has a type with a return type</li>
	 * <li><code>myFunction/2/,Number/param1,param2//foo.bar.Type</code> - function on a type where only one of the parameters has a type</li>
	 * <li><code>myFunction/2/,Number/param1,param2/String/foo.bar.Type</code> - function on a type where only one of the parameters has a type with a return type</li>
	 * </ul></p>
	 * 
	 * @param selector
	 * @param parameterCount
	 * @param declaringFullTypeName
	 * @param returnFullTypeName
	 * @param parameterFullTypeNames
	 * @param parameterNames
	 * @param modifiers
	 * 
	 * @see #decodeIndexKey(char[])
	 * 
	 * @return a key that can be put in an index or used to search an index for functions
	 */
	public static char[] createIndexKey(char[] selector, int parameterCount,
			char[][] parameterFullTypeNames,
			char[][] parameterNames,
			char[] declaringFullTypeName,
			char[] returnFullTypeName,
			int modifiers) {
		
		char[] indexKey = null;
		
		if(selector != null  && selector.length > 0) {
			char[] paramaterCountChars = null;
			char[] parameterTypesChars = CharOperation.NO_CHAR;
			char[] parameterNamesChars = CharOperation.NO_CHAR;
			
			
			//get param types
			if (parameterFullTypeNames != null) {
				parameterTypesChars = CharOperation.concatWith(parameterFullTypeNames, PARAMETER_SEPARATOR, false);
			}
			
			//get param names
			if (parameterNames != null) {
				parameterNamesChars = CharOperation.concatWith(parameterNames, PARAMETER_SEPARATOR);
			}
			
			//use pre-made char array for arg counts less then 10, else build a new one
			if(parameterCount >= 0) {
				paramaterCountChars = parameterCount < 10 ?
						COUNTS[parameterCount] : (SEPARATOR + String.valueOf(parameterCount)).toCharArray();
			} else {
				paramaterCountChars = CharOperation.concat(new char[] {SEPARATOR}, ONE_STAR);
			}
			
				
			//get lengths
			int parameterTypesLength = (parameterTypesChars == null ? 0 : parameterTypesChars.length);
			int parameterNamesLength = (parameterNamesChars == null ? 0 : parameterNamesChars.length);
			int returnTypeLength = (returnFullTypeName == null ? 0 : returnFullTypeName.length);
			int delaringTypeLength = declaringFullTypeName == null ? 0 : declaringFullTypeName.length;
			
			int resultLength = selector.length + paramaterCountChars.length
					+ 1 + parameterTypesLength
					+ 1 + parameterNamesLength
					+ 1 + returnTypeLength
					+ 1 + delaringTypeLength
					+ 3; //modifiers
			
			//create result char array
			indexKey = new char[resultLength];
			
			//add type name to result
			int pos = 0;
			System.arraycopy(selector, 0, indexKey, pos, selector.length);
			pos += selector.length;
			
			//add param count to result
			if (paramaterCountChars.length > 0) {
				System.arraycopy(paramaterCountChars, 0, indexKey, pos, paramaterCountChars.length);
				pos += paramaterCountChars.length;
			}
			
			//add param types
			indexKey[pos++] = SEPARATOR;
			if (parameterTypesLength > 0) {
				System.arraycopy(parameterTypesChars, 0, indexKey, pos, parameterTypesLength);
				pos += parameterTypesLength;
			}
			
			//add param names
			indexKey[pos++] = SEPARATOR;
			if (parameterNamesLength > 0) {
				System.arraycopy(parameterNamesChars, 0, indexKey, pos, parameterNamesLength);
				pos += parameterNamesLength;
			}
			
			//add return type
			indexKey[pos++] = SEPARATOR;
			if(returnTypeLength > 0) {
				System.arraycopy(returnFullTypeName, 0, indexKey, pos, returnTypeLength);
				pos += returnTypeLength;
			}
			
			//add declaring type
			indexKey[pos++] = SEPARATOR;
			if(delaringTypeLength > 0) {
				System.arraycopy(declaringFullTypeName, 0, indexKey, pos, delaringTypeLength);
				pos += delaringTypeLength;
			}
			
			//add modifiers
			indexKey[pos++] = SEPARATOR;
			indexKey[pos++] = (char) modifiers;
			indexKey[pos++] = (char) (modifiers>>16);
		}
			
		return indexKey;
	}
	
	/**
	 * <p>Create an index key for search the index for any function that matches the given selector
	 * pattern, on the optionally defined declaring type, with the given modifiers.</p>
	 * 
	 * @param selectorPattern
	 * @param declarationType
	 * @param modifiers
	 * 
	 * @return
	 */
	private static char[] createSearchIndexKey(char[] selectorPattern,
			char[] declaringQualification, char[] declaringSimpleName, int modifiers) {
		
		char[] declaringFullTypeName = null;
		if(declaringSimpleName != null) {
			declaringFullTypeName = QualificationHelpers.createFullyQualifiedName(declaringQualification, declaringSimpleName);
		}
		
		return createIndexKey(selectorPattern, -1,
				ONE_STAR_CHAR,
				ONE_STAR_CHAR,
				declaringFullTypeName,
				ONE_STAR,
				modifiers);
	}
	
	/**
	 * <p>Used to create an index key to search for a specific function.</p>
	 * 
	 * @param selector
	 * @param parameterCount
	 * @param parameterQualifications
	 * @param parameterSimpleNames
	 * @param parameterNames
	 * @param returnQualification
	 * @param returnSimpleName
	 * @param declaringQualification
	 * @param declaringSimpleName
	 * @param modifiers
	 * @return
	 */
	private static char[] createSearchIndexKey(char[] selector, int parameterCount,
			char[][] parameterQualifications,
			char[][] parameterSimpleNames,
			char[][] parameterNames,
			char[] returnQualification,
			char[] returnSimpleName,
			char[] declaringQualification,
			char[] declaringSimpleName,
			int modifiers) {
		
		//create fully qualified type names
		char[] declaringFullTypeName = QualificationHelpers.createFullyQualifiedName(declaringQualification, declaringSimpleName);
		char[] returnFullTypeName = QualificationHelpers.createFullyQualifiedName(returnQualification, returnSimpleName);
		char[][] parameterFullTypeNames = QualificationHelpers.createFullyQualifiedNames(parameterQualifications, parameterSimpleNames);
		
		return createIndexKey(selector, parameterCount, parameterFullTypeNames,
				parameterNames, declaringFullTypeName, returnFullTypeName, modifiers);
	}
	output.append(')');
	if (returnQualification != null)
		output.append(" --> ").append(returnQualification).append('.'); //$NON-NLS-1$
	else if (returnSimpleName != null)
		output.append(" --> "); //$NON-NLS-1$
	if (returnSimpleName != null)
		output.append(returnSimpleName);
	else if (returnQualification != null)
		output.append("*"); //$NON-NLS-1$
	return super.print(output);
}
}




/*******************************************************************************
 * Copyright (c) 2011 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.wst.jsdt.internal.core.util;

import org.eclipse.wst.jsdt.core.Signature;
import org.eclipse.wst.jsdt.core.compiler.CharOperation;
import org.eclipse.wst.jsdt.internal.core.search.indexing.IIndexConstants;

/**
 * <p>Methods for helping with qualified type names, both to separate them into
 * qualifier and simple name, as well as recombining qualifier with simple name.</p>
 */
public class QualificationHelpers {
	
	/**
	 * <p>The index in the array containing the qualifier of a fully qualified name
	 * separated by a method in this class.</p>
	 * 
	 * @see #seperateFullyQualifedName(char[])
	 * @see #seperateFullyQualifedTypeNames(char[])
	 */
	public static final int QULIFIERS_INDEX = 0;
	
	/**
	 * <p>The index in the array containing the simple name of a fully qualified name
	 * separated by a method in this class.</p>
	 * 
	 * @see #seperateFullyQualifedName(char[])
	 * @see #seperateFullyQualifedTypeNames(char[])
	 */
	public static final int SIMPLE_NAMES_INDEX = 1;
	
	/**
	 * <p>Given a qualification and a simple name creates a fully qualified name.</p>
	 * 
	 * @param qualification the qualification, or <code>null</code> if no qualification
	 * @param simpleName the simple name, can not be <code>null</code>
	 * 
	 * @return fully qualified name created from the given <code>simpleName</code> and
	 * the optional <code>qualification</code>
	 */
	public static char[] createFullyQualifiedName(char[] qualification, char[] simpleName) {
		char[] fullTypeName = null;
		if(simpleName != null && simpleName.length > 0) {
			if(qualification != null && qualification.length > 0) {
				fullTypeName = CharOperation.concat(qualification, simpleName, IIndexConstants.DOT);
			} else {
				fullTypeName = simpleName;
			}
		}
		
		return fullTypeName;
	}
	
	/**
	 * <p>Given a list of qualifications and a list of simple names creates a single list of
	 * fully qualified names created by matching one qualification and one simple name from
	 * their respective lists in order.</p>
	 * 
	 * @param qualifications to match with the given <code>simpleNames</code>, this can be
	 * <code>null</code> if there are not qualifications, or an array of the same size as
	 * <code>simpleNames</code> where any one of the indices maybe <code>null</code> to signify
	 * there is no qualifier for that specific simple name.
	 * @param simpleNames to match with the given <code>qualifications</code>, this array
	 * can <b>not</b> be <code>null</code> and no indices in the array can be <code>null</code> either
	 * 
	 * @return an array of fully qualified names created from the given <code>simpleNames</code>
	 * and the optional <code>qualifications</code>
	 */
	public static char[][] createFullyQualifiedNames(char[][] qualifications, char[][] simpleNames) {
		char[][] fullTypeNames = null;
		
		if(simpleNames != null) {
			fullTypeNames = new char[simpleNames.length][];
			for(int i = 0; i < fullTypeNames.length; ++i) {
				if(qualifications != null && qualifications.length > i) {
					fullTypeNames[i] = createFullyQualifiedName(qualifications[i], simpleNames[i]);
				} else {
					fullTypeNames[i] = simpleNames[i];
				}
			}
		}
		
		return fullTypeNames;
	}
	
	/**
	 * <p>Separates a fully qualified name into its qualifier and its simple name</p>
	 * 
	 * @param fullyQualifiedName fully qualified type name to separate into its qualifier and simple name
	 * 
	 * @return a multidimensional array with one dimension for the qualifier and one for the simple name
	 * 
	 * @see #QULIFIERS_INDEX
	 * @see #SIMPLE_NAMES_INDEX
	 */
	public static char[][] seperateFullyQualifedName(char[] fullyQualifiedName) {
		char[][] seperatedTypeName = new char[2][];
		
		if(fullyQualifiedName != null && fullyQualifiedName.length > 0) {
			int lastIndexOfDot = CharOperation.lastIndexOf(IIndexConstants.DOT, fullyQualifiedName);
			if(lastIndexOfDot != -1) {
				seperatedTypeName[QULIFIERS_INDEX] = CharOperation.subarray(fullyQualifiedName, 0, lastIndexOfDot);
				seperatedTypeName[SIMPLE_NAMES_INDEX] = CharOperation.subarray(fullyQualifiedName, lastIndexOfDot+1, -1);
			} else {
				seperatedTypeName[QULIFIERS_INDEX] = null;
				seperatedTypeName[SIMPLE_NAMES_INDEX] = fullyQualifiedName;
			}
		}
		
		return seperatedTypeName;
	}
	
	/**
	 * <p>Separates an array of fully qualified names into their qualifiers and their simple names</p>
	 * 
	 * @param fullyQualifiedNames fully qualified type names to separate into their qualifiers and their simple names
	 * @param minLength the minimum length of the result, padding will be with <code>null</code>
	 * 
	 * @return resulting array consists of three indices.  The first is either {@link #QULIFIERS_INDEX} or
	 * {@link #SIMPLE_NAMES_INDEX}, the second is then a list of either the qualifiers or the simple names,
	 * depending on the first index, the last index is the char[] "string" qualifier or simple name.
	 * 
	 * @see #QULIFIERS_INDEX
	 * @see #SIMPLE_NAMES_INDEX
	 */
	public static char[][][] seperateFullyQualifiednames(String[] fullyQualifiedNames, int minLength) {
		return seperateFullyQualifiedNames(stringArrayToCharArray(fullyQualifiedNames), minLength);
	}
	
	/**
	 * <p>Separates a list of fully qualified names separated by {@link IIndexConstants#PARAMETER_SEPARATOR}
	 * into their qualifiers and their simple names</p>
	 * 
	 * @param fullyQualifiedNames a list of fully qualified type names separated by {@link IIndexConstants#PARAMETER_SEPARATOR}
	 * to separate into their qualifiers and their simple names
	 * @param minLength the minimum length of the result, padding will be with <code>null</code>
	 * 
	 * @return resulting array consists of three indices.  The first is either {@link #QULIFIERS_INDEX} or
	 * {@link #SIMPLE_NAMES_INDEX}, the second is then a list of either the qualifiers or the simple names,
	 * depending on the first index, the last index is the char[] "string" qualifier or simple name.
	 * 
	 * @see #QULIFIERS_INDEX
	 * @see #SIMPLE_NAMES_INDEX
	 */
	public static char[][][] seperateFullyQualifiedNames(char[] fullyQualifiedNames, int minLength) {
		char[][] names = CharOperation.splitOn(IIndexConstants.PARAMETER_SEPARATOR, fullyQualifiedNames);
		return seperateFullyQualifiedNames(names, minLength);
	}
	
	/**
	 * <p>Separates an array of fully qualified names into their qualifiers and their simple names</p>
	 * 
	 * @param fullyQualifiedNames fully qualified type names to separate into their qualifiers and their simple names
	 * @param minLength the minimum length of the result, padding will be with <code>null</code>
	 * 
	 * @return resulting array consists of three indices.  The first is either {@link #QULIFIERS_INDEX} or
	 * {@link #SIMPLE_NAMES_INDEX}, the second is then a list of either the qualifiers or the simple names,
	 * depending on the first index, the last index is the char[] "string" qualifier or simple name.
	 * 
	 * @see #QULIFIERS_INDEX
	 * @see #SIMPLE_NAMES_INDEX
	 */
	public static char[][][] seperateFullyQualifiedNames(char[][] fullyQualifiedNames, int minLength) {
		/* 
		 * First index is 0 or 1 for the list of qualifiers qualifier and then the list of simple names respectively
		 * Second index is a list of the qualifiers and simple names
		 * Third index is the actual 'string' qualifier or simple name
		 */
		char[][][] seperatedTypeNames = new char[2][][];
		
		if(fullyQualifiedNames.length > 0) {
			int length = minLength > fullyQualifiedNames.length ? minLength : fullyQualifiedNames.length;
			seperatedTypeNames[QULIFIERS_INDEX] = new char[length][];
			seperatedTypeNames[SIMPLE_NAMES_INDEX] = new char[length][];
			
			for(int i = 0; i < fullyQualifiedNames.length; ++i) {
				char[][] seperatedTypeName = seperateFullyQualifedName(fullyQualifiedNames[i]);
				seperatedTypeNames[QULIFIERS_INDEX][i] = seperatedTypeName[QULIFIERS_INDEX];
				seperatedTypeNames[SIMPLE_NAMES_INDEX][i] = seperatedTypeName[SIMPLE_NAMES_INDEX];
				
				//in case the qualifier is a signature, nothing happens if it is not
				if(seperatedTypeNames[QULIFIERS_INDEX][i] != null) {
					seperatedTypeNames[QULIFIERS_INDEX][i] = Signature.toCharArray(seperatedTypeNames[QULIFIERS_INDEX][i]);
				}
				
				//in case the simple name is a signature, nothing happens if it is not
				if(seperatedTypeNames[SIMPLE_NAMES_INDEX][i] != null) {
					seperatedTypeNames[SIMPLE_NAMES_INDEX][i] = Signature.toCharArray(seperatedTypeNames[SIMPLE_NAMES_INDEX][i]);
				}
			}
			
		} else if (minLength > 0) {
			seperatedTypeNames[QULIFIERS_INDEX] = new char[minLength][];
			seperatedTypeNames[SIMPLE_NAMES_INDEX] = new char[minLength][];
		} else {
			seperatedTypeNames[QULIFIERS_INDEX] = null;
			seperatedTypeNames[SIMPLE_NAMES_INDEX] = null;
		}
		
		return seperatedTypeNames;
	}
	
	/**
	 * <p>Transform a {@link String} array into a <code>char</code> array.</p>
	 * 
	 * @param array of {@link String}s to transform into an array of <code>char</code>s
	 * 
	 * @return array of {@link String}s built from the given array of <code>char</code>s
	 */
	public static char[][] stringArrayToCharArray(String[] array) {
		char[][] results = null;
		if(array != null) {
			results = new char[array.length][];
			for(int i = 0; i < array.length; ++i) {
				results[i] = array[i].toCharArray();
			}
		}
		
		return results;
	}
}




import org.eclipse.wst.jsdt.core.tests.compiler.regression.UtilTest;
import org.eclipse.wst.jsdt.core.tests.compiler.util.ExclusionTests;
import org.eclipse.wst.jsdt.core.tests.interpret.BasicInterpretTest;
import org.eclipse.wst.jsdt.core.tests.search.SearchTests;

/**
 * Run all compiler regression tests

	// interpret tests
	standardTests.add(BasicInterpretTest.class);
	
	
	
	
//	standardTests.addAll(JavadocTest.allTestClasses);

//	standardTests.add(BasicErrorTests.class);

	//	// add all javadoc tests
//	for (int i=0, l=JavadocTest.ALL_CLASSES.size(); i<l; i++) {
//		standardTests.add(JavadocTest.ALL_CLASSES.get(i));
//	}
//
	TestSuite all = new TestSuite("JSDT 'Compiler' Tests");
	all.addTest(ExclusionTests.suite());
	
	
//	int possibleComplianceLevels = AbstractCompilerTest.getPossibleComplianceLevels();
//	if ((possibleComplianceLevels & AbstractCompilerTest.F_1_3) != 0) {
//		ArrayList tests_1_3 = (ArrayList)standardTests.clone();
//		tests_1_3.add(Compliance_1_3.class);
//		tests_1_3.add(JavadocTest_1_3.class);
//		// Reset forgotten subsets tests
//		TestCase.TESTS_PREFIX = null;
//		TestCase.TESTS_NAMES = null;
//		TestCase.TESTS_NUMBERS= null;
//		TestCase.TESTS_RANGE = null;
//		TestCase.RUN_ONLY_ID = null;
//		all.addTest(AbstractCompilerTest.buildComplianceTestSuite(AbstractCompilerTest.COMPLIANCE_1_3, tests_1_3));
//	}
//	if ((possibleComplianceLevels & AbstractCompilerTest.F_1_4) != 0) {
//		ArrayList tests_1_4 = (ArrayList)standardTests.clone();
//		tests_1_4.add(AssertionTest.class);
//		tests_1_4.add(Compliance_1_4.class);
//		tests_1_4.add(ClassFileReaderTest_1_4.class);
//		tests_1_4.add(JavadocTest_1_4.class);
//		// Reset forgotten subsets tests
//		TestCase.TESTS_PREFIX = null;
//		TestCase.TESTS_NAMES = null;
//		TestCase.TESTS_NUMBERS= null;
//		TestCase.TESTS_RANGE = null;
//		TestCase.RUN_ONLY_ID = null;
//		all.addTest(AbstractCompilerTest.buildComplianceTestSuite(AbstractCompilerTest.COMPLIANCE_1_4, tests_1_4));
//	}
//	if ((possibleComplianceLevels & AbstractCompilerTest.F_1_5) != 0) {
//		ArrayList tests_1_5 = (ArrayList)standardTests.clone();
//		tests_1_5.addAll(RunComparableTests.ALL_CLASSES);
//		tests_1_5.add(AssertionTest.class);
//		tests_1_5.add(ClassFileReaderTest_1_5.class);
//		tests_1_5.add(GenericTypeSignatureTest.class);
//		tests_1_5.add(InternalHexFloatTest.class);
//		tests_1_5.add(JavadocTest_1_5.class);
//		tests_1_5.add(BatchCompilerTest.class);
//		tests_1_5.add(ExternalizeStringLiterals15Test.class);
//		// Reset forgotten subsets tests
//		TestCase.TESTS_PREFIX = null;
//		TestCase.TESTS_NAMES = null;
//		TestCase.TESTS_NUMBERS= null;
//		TestCase.TESTS_RANGE = null;
//		TestCase.RUN_ONLY_ID = null;
//		all.addTest(AbstractCompilerTest.buildComplianceTestSuite(AbstractCompilerTest.COMPLIANCE_1_5, tests_1_5));
//	}
//	if ((possibleComplianceLevels & AbstractCompilerTest.F_1_6) != 0) {
//		ArrayList tests_1_6 = (ArrayList)standardTests.clone();
//		tests_1_6.addAll(RunComparableTests.ALL_CLASSES);
//		tests_1_6.add(AssertionTest.class);
//		tests_1_6.add(ClassFileReaderTest_1_5.class);
//		tests_1_6.add(GenericTypeSignatureTest.class);
//		tests_1_6.add(InternalHexFloatTest.class);
//		tests_1_6.add(JavadocTest_1_5.class);
//		tests_1_6.add(BatchCompilerTest.class);
//		tests_1_6.add(ExternalizeStringLiterals15Test.class);
//		tests_1_6.add(StackMapAttributeTest.class);
//		// Reset forgotten subsets tests
//		TestCase.TESTS_PREFIX = null;
//		TestCase.TESTS_NAMES = null;
//		TestCase.TESTS_NUMBERS= null;
//		TestCase.TESTS_RANGE = null;
//		TestCase.RUN_ONLY_ID = null;
//		all.addTest(AbstractCompilerTest.buildComplianceTestSuite(AbstractCompilerTest.COMPLIANCE_1_6, tests_1_6));
//	}
	for (Iterator iter = standardTests.iterator(); iter.hasNext();) {
		Class test = (Class) iter.next();
		all.addTestSuite(test); 
	}
	
	all.addTest(SearchTests.suite());
	return all;
} 
}




/*******************************************************************************
 * Copyright (c) 2011 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.wst.jsdt.core.tests.search;

import junit.framework.Test;
import junit.framework.TestSuite;

/**
 * <p>Test suite for all JSDT Search Tests.<p>
 */
public class SearchTests extends TestSuite {
	/**
	 * <p>Default constructor</p>
	 */
	public SearchTests() {
		this("JavaScript Search Tests");
	}

	/**
	 * <p>Constructor with specified test name.</p>
	 *
	 * @param testName of this test suite
	 */
	public SearchTests(String testName) {
		super(testName);
	}
	
	public static Test suite() {
		TestSuite all = new TestSuite("JavaScript Search Tests");
		
		all.addTestSuite(TestMethodPattern.class);
		
		return all;
	}
}




/**
 * 
 */
package org.eclipse.wst.jsdt.core.tests.search;

import org.eclipse.wst.jsdt.core.compiler.CharOperation;
import org.eclipse.wst.jsdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.wst.jsdt.internal.core.search.indexing.IIndexConstants;
import org.eclipse.wst.jsdt.internal.core.search.matching.MethodPattern;

import junit.framework.TestCase;

/**
 * <p>Tests for MethodPattern.</p>
 * 
 * @see MethodPattern
 */
public class TestMethodPattern extends TestCase {
	
	public void testCreateIndexKey_0() {
		runCreateIndexKeyTest("myFunction/0/////", "myFunction".toCharArray(), 0, null, null, null, null, 0);
	}
	
	public void testCreateIndexKey_1() {
		runCreateIndexKeyTest("myFunction/1/////", "myFunction".toCharArray(), 1, null, null, null, null, 0);
	}
	
	public void testCreateIndexKey_2() {
		runCreateIndexKeyTest("myFunction/0///String//",
				"myFunction".toCharArray(), 0, null, null, null, "String".toCharArray(), 0);
	}
	
	public void testCreateIndexKey_3() {
		runCreateIndexKeyTest("myFunction/0////foo.bar.Type/",
				"myFunction".toCharArray(), 0, null, null, "foo.bar.Type".toCharArray(), null, ClassFileConstants.AccStatic);
	}
	
	public void testCreateIndexKey_4() {
		runCreateIndexKeyTest("myFunction/0///String/foo.bar.Type/",
				"myFunction".toCharArray(), 0, null, null, "foo.bar.Type".toCharArray(), "String".toCharArray(), ClassFileConstants.AccStatic);
	}
	
	public void testCreateIndexKey_5() {
		runCreateIndexKeyTest("myFunction/2//param1,param2///",
				"myFunction".toCharArray(), 2, null, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, null, null, 0);
	}
	
	public void testCreateIndexKey_6() {
		runCreateIndexKeyTest("myFunction/2//param1,param2/String//",
				"myFunction".toCharArray(), 2, null, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, null, "String".toCharArray(), 0);
	}
	
	public void testCreateIndexKey_7() {
		runCreateIndexKeyTest("myFunction/2//param1,param2//foo.bar.Type/",
				"myFunction".toCharArray(), 2, null, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, "foo.bar.Type".toCharArray(), null, ClassFileConstants.AccStatic);
	}
	
	public void testCreateIndexKey_8() {
		runCreateIndexKeyTest("myFunction/2//param1,param2/String/foo.bar.Type/",
				"myFunction".toCharArray(), 2, null, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, "foo.bar.Type".toCharArray(), "String".toCharArray(), ClassFileConstants.AccStatic);
	}
	
	public void testCreateIndexKey_9() {
		runCreateIndexKeyTest("myFunction/2/String,Number/param1,param2///",
				"myFunction".toCharArray(), 2, new char[][] { "String".toCharArray(), "Number".toCharArray()}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, null, null, 0);
	}
	
	public void testCreateIndexKey_10() {
		runCreateIndexKeyTest("myFunction/2/String,Number/param1,param2/String//",
				"myFunction".toCharArray(), 2, new char[][] { "String".toCharArray(), "Number".toCharArray()}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, null, "String".toCharArray(), 0);
	}
	
	public void testCreateIndexKey_11() {
		runCreateIndexKeyTest("myFunction/2/String,Number/param1,param2//foo.bar.Type/",
				"myFunction".toCharArray(), 2, new char[][] { "String".toCharArray(), "Number".toCharArray()}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, "foo.bar.Type".toCharArray(), null, ClassFileConstants.AccStatic);
	}
	
	public void testCreateIndexKey_12() {
		runCreateIndexKeyTest("myFunction/2/String,Number/param1,param2/String/foo.bar.Type/",
				"myFunction".toCharArray(), 2, new char[][] { "String".toCharArray(), "Number".toCharArray()}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, "foo.bar.Type".toCharArray(), "String".toCharArray(), ClassFileConstants.AccStatic);
	}
	
	public void testCreateIndexKey_13() {
		runCreateIndexKeyTest("myFunction/2/,Number/param1,param2///",
				"myFunction".toCharArray(), 2, new char[][] { null, "Number".toCharArray()}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, null, null, 0);
	}
	
	public void testCreateIndexKey_14() {
		runCreateIndexKeyTest("myFunction/2/,Number/param1,param2/String//",
				"myFunction".toCharArray(), 2, new char[][] { null, "Number".toCharArray()}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, null, "String".toCharArray(), 0);
	}
	
	public void testCreateIndexKey_15() {
		runCreateIndexKeyTest("myFunction/2/,Number/param1,param2//foo.bar.Type/",
				"myFunction".toCharArray(), 2, new char[][] { null, "Number".toCharArray()}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, "foo.bar.Type".toCharArray(), null, ClassFileConstants.AccStatic);
	}
	
	public void testCreateIndexKey_16() {
		runCreateIndexKeyTest("myFunction/2/,Number/param1,param2/String/foo.bar.Type/",
				"myFunction".toCharArray(), 2, new char[][] { null, "Number".toCharArray()}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, "foo.bar.Type".toCharArray(), "String".toCharArray(), ClassFileConstants.AccStatic);
	}
	
	public void testCreateIndexKey_17() {
		runCreateIndexKeyTest("myFunction/2/,Number/param1,param2///",
				"myFunction".toCharArray(), 2, new char[][] { new char[0], "Number".toCharArray()}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, null, null, 0);
	}
	
	public void testCreateIndexKey_18() {
		runCreateIndexKeyTest("myFunction/2/,Number/param1,param2/String//",
				"myFunction".toCharArray(), 2, new char[][] { new char[0], "Number".toCharArray()}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, null, "String".toCharArray(), 0);
	}
	
	public void testCreateIndexKey_19() {
		runCreateIndexKeyTest("myFunction/2/,Number/param1,param2//foo.bar.Type/",
				"myFunction".toCharArray(), 2, new char[][] { new char[0], "Number".toCharArray()}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, "foo.bar.Type".toCharArray(), null, ClassFileConstants.AccStatic);
	}
	
	public void testCreateIndexKey_20() {
		runCreateIndexKeyTest("myFunction/2/,Number/param1,param2/String/foo.bar.Type/",
				"myFunction".toCharArray(), 2, new char[][] { new char[0], "Number".toCharArray()}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, "foo.bar.Type".toCharArray(), "String".toCharArray(), ClassFileConstants.AccStatic);
	}
	
	public void testCreateIndexKey_21() {
		runCreateIndexKeyTest("myFunction/2/String,/param1,param2///",
				"myFunction".toCharArray(), 2, new char[][] {"String".toCharArray(), null}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, null, null, 0);
	}
	
	public void testCreateIndexKey_22() {
		runCreateIndexKeyTest("myFunction/2/String,/param1,param2/String//",
				"myFunction".toCharArray(), 2, new char[][] {"String".toCharArray(), null}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, null, "String".toCharArray(), 0);
	}
	
	public void testCreateIndexKey_23() {
		runCreateIndexKeyTest("myFunction/2/String,/param1,param2//foo.bar.Type/",
				"myFunction".toCharArray(), 2, new char[][] {"String".toCharArray(), null}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, "foo.bar.Type".toCharArray(), null, ClassFileConstants.AccStatic);
	}
	
	public void testCreateIndexKey_24() {
		runCreateIndexKeyTest("myFunction/2/String,/param1,param2/String/foo.bar.Type/",
				"myFunction".toCharArray(), 2, new char[][] {"String".toCharArray(), null}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, "foo.bar.Type".toCharArray(), "String".toCharArray(), ClassFileConstants.AccStatic);
	}
	
	public void testCreateIndexKey_25() {
		runCreateIndexKeyTest("myFunction/2/String,/param1,param2///",
				"myFunction".toCharArray(), 2, new char[][] {"String".toCharArray(), new char[0]}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, null, null, 0);
	}
	
	public void testCreateIndexKey_26() {
		runCreateIndexKeyTest("myFunction/2/String,/param1,param2/String//",
				"myFunction".toCharArray(), 2, new char[][] {"String".toCharArray(), new char[0]}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, null, "String".toCharArray(), 0);
	}
	
	public void testCreateIndexKey_27() {
		runCreateIndexKeyTest("myFunction/2/String,/param1,param2//foo.bar.Type/",
				"myFunction".toCharArray(), 2, new char[][] {"String".toCharArray(), new char[0]}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, "foo.bar.Type".toCharArray(), null, ClassFileConstants.AccStatic);
	}
	
	public void testCreateIndexKey_28() {
		runCreateIndexKeyTest("myFunction/2/String,/param1,param2/String/foo.bar.Type/", "myFunction".toCharArray(), 2, new char[][] {"String".toCharArray(), new char[0]}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, "foo.bar.Type".toCharArray(), "String".toCharArray(), ClassFileConstants.AccStatic);
	}
	
	public void testCreateIndexKey_29() {
		char[] keyChars = MethodPattern.createIndexKey("".toCharArray(), 2, new char[][] {"String".toCharArray(), new char[0]}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, "foo.bar.Type".toCharArray(), "String".toCharArray(), ClassFileConstants.AccStatic);
		
		String key = null;
		if(keyChars != null) {
			key = new String(keyChars);
		}
		
		assertNull("If selector is empty the key should be null.\nWAS:\n" + key, key);
	}
	
	public void testCreateIndexKey_30() {
		char[] keyChars = MethodPattern.createIndexKey(null, 2, new char[][] {"String".toCharArray(), new char[0]}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, "foo.bar.Type".toCharArray(), "String".toCharArray(), ClassFileConstants.AccStatic);
		
		String key = null;
		if(keyChars != null) {
			key = new String(keyChars);
		}
		
		assertNull("If selector is empty the key should be null.\nWAS:\n" + key, key);
	}
	
	public void testDecodeIndexKey_0() {
		runDecodeIndexKeyTest("myFunction/0////", "myFunction", 0, null, null, null,null, null, null, null, 0);
	}
	
	public void testDecodeIndexKey_2() {
		runDecodeIndexKeyTest("myFunction/0///String/", "myFunction", 0, null, null, null,null, "String", null, null, 0);
	}
	
	public void testDecodeIndexKey_3() {
		runDecodeIndexKeyTest("myFunction/0////foo.bar.Type", "myFunction", 0, null, null, null,null, null, "foo.bar", "Type", 0);
	}
	
	public void testDecodeIndexKey_4() {
		runDecodeIndexKeyTest("myFunction/0///String/foo.bar.Type", "myFunction", 0, null, null, null,null, "String", "foo.bar", "Type", 0);
	}
	
	public void testDecodeIndexKey_5() {
		runDecodeIndexKeyTest("myFunction/2//param1,param2//", "myFunction", 2, new String[2], new String[2], new String[] {"param1", "param2"},null, null, null, null, 0);
	}
	
	public void testDecodeIndexKey_6() {
		runDecodeIndexKeyTest("myFunction/2//param1,param2/String/", "myFunction", 2, new String[2], new String[2], new String[] {"param1", "param2"},null, "String", null, null, 0);
	}
	
	public void testDecodeIndexKey_7() {
		runDecodeIndexKeyTest("myFunction/2//param1,param2//foo.bar.Type", "myFunction", 2, new String[2], new String[2], new String[] {"param1", "param2"},null, null, "foo.bar", "Type", 0);
	}
	
	public void testDecodeIndexKey_8() {
		runDecodeIndexKeyTest("myFunction/2//param1,param2/String/foo.bar.Type", "myFunction", 2, new String[2], new String[2], new String[] {"param1", "param2"},null, "String", "foo.bar", "Type", 0);
	}
	
	public void testDecodeIndexKey_9() {
		runDecodeIndexKeyTest("myFunction/2/String,Number/param1,param2//", "myFunction", 2, new String[]{null, null}, new String[]{"String", "Number"}, new String[] {"param1", "param2"},null, null, null, null, 0);
	}
	
	public void testDecodeIndexKey_10() {
		runDecodeIndexKeyTest("myFunction/2/String,Number/param1,param2/String/", "myFunction", 2, new String[]{null, null}, new String[]{"String", "Number"}, new String[] {"param1", "param2"},null, "String", null, null, 0);
	}
	
	public void testDecodeIndexKey_11() {
		runDecodeIndexKeyTest("myFunction/2/String,Number/param1,param2//foo.bar.Type", "myFunction", 2, new String[]{null, null}, new String[]{"String", "Number"}, new String[] {"param1", "param2"},null, null, "foo.bar", "Type", 0);
	}
	
	public void testDecodeIndexKey_12() {
		runDecodeIndexKeyTest("myFunction/2/String,Number/param1,param2/String/foo.bar.Type", "myFunction", 2, new String[]{null, null}, new String[]{"String", "Number"}, new String[] {"param1", "param2"},null, "String", "foo.bar", "Type", 0);
	}
	
	public void testDecodeIndexKey_13() {
		runDecodeIndexKeyTest("myFunction/2/,Number/param1,param2//", "myFunction", 2, new String[]{null, null}, new String[]{null, "Number"}, new String[] {"param1", "param2"},null, null, null, null, 0);
	}
	
	public void testDecodeIndexKey_14() {
		runDecodeIndexKeyTest("myFunction/2/,Number/param1,param2/String/", "myFunction", 2, new String[]{null, null}, new String[]{null, "Number"}, new String[] {"param1", "param2"},null, "String", null, null, 0);
	}
	
	public void testDecodeIndexKey_15() {
		runDecodeIndexKeyTest("myFunction/2/,Number/param1,param2//foo.bar.Type", "myFunction", 2, new String[]{null, null}, new String[]{null, "Number"}, new String[] {"param1", "param2"},null, null, "foo.bar", "Type", 0);
	}
	
	public void testDecodeIndexKey_16() {
		runDecodeIndexKeyTest("myFunction/2/,Number/param1,param2/String/foo.bar.Type", "myFunction", 2, new String[]{null, null}, new String[]{null, "Number"}, new String[] {"param1", "param2"},null, "String", "foo.bar", "Type", 0);
	}
	
	public void testDecodeIndexKey_17() {
		runDecodeIndexKeyTest("myFunction/2/String,/param1,param2//", "myFunction", 2, new String[]{null, null}, new String[]{"String", null}, new String[] {"param1", "param2"},null, null, null, null, 0);
	}
	
	public void testDecodeIndexKey_18() {
		runDecodeIndexKeyTest("myFunction/2/String,/param1,param2/String/", "myFunction", 2, new String[]{null, null}, new String[]{"String", null}, new String[] {"param1", "param2"},null, "String", null, null, 0);
	}
	
	public void testDecodeIndexKey_19() {
		runDecodeIndexKeyTest("myFunction/2/String,/param1,param2//foo.bar.Type", "myFunction", 2, new String[]{null, null}, new String[]{"String", null}, new String[] {"param1", "param2"},null, null, "foo.bar", "Type", 0);
	}
	
	public void testDecodeIndexKey_20() {
		runDecodeIndexKeyTest("myFunction/2/String,/param1,param2/String/foo.bar.Type", "myFunction", 2, new String[]{null, null}, new String[]{"String", null}, new String[] {"param1", "param2"},null, "String", "foo.bar", "Type", 0);
	}
	
	public void testDecodeIndexKey_21() {
		runDecodeIndexKeyTest("myFunction/2/bar.foo.String,neto.crazy.Number/param1,param2//", "myFunction", 2, new String[]{"bar.foo", "neto.crazy"}, new String[]{"String", "Number"}, new String[] {"param1", "param2"},null, null, null, null, 0);
	}
	
	public void testDecodeIndexKey_22() {
		runDecodeIndexKeyTest("myFunction/2/bar.foo.String,neto.crazy.Number/param1,param2/String/", "myFunction", 2, new String[]{"bar.foo", "neto.crazy"}, new String[]{"String", "Number"}, new String[] {"param1", "param2"},null, "String", null, null, 0);
	}
	
	public void testDecodeIndexKey_23() {
		runDecodeIndexKeyTest("myFunction/2/bar.foo.String,neto.crazy.Number/param1,param2//foo.bar.Type", "myFunction", 2, new String[]{"bar.foo", "neto.crazy"}, new String[]{"String", "Number"}, new String[] {"param1", "param2"},null, null, "foo.bar", "Type", 0);
	}
	
	public void testDecodeIndexKey_24() {
		runDecodeIndexKeyTest("myFunction/2/bar.foo.String,neto.crazy.Number/param1,param2/String/foo.bar.Type", "myFunction", 2, new String[]{"bar.foo", "neto.crazy"}, new String[]{"String", "Number"}, new String[] {"param1", "param2"},null, "String", "foo.bar", "Type", 0);
	}
	
	public void testDecodeIndexKey_25() {
		runDecodeIndexKeyTest("myFunction/2/,neto.crazy.Number/param1,param2//", "myFunction", 2, new String[]{null, "neto.crazy"}, new String[]{null, "Number"}, new String[] {"param1", "param2"},null, null, null, null, 0);
	}
	
	public void testDecodeIndexKey_26() {
		runDecodeIndexKeyTest("myFunction/2/,neto.crazy.Number/param1,param2/String/", "myFunction", 2, new String[]{null, "neto.crazy"}, new String[]{null, "Number"}, new String[] {"param1", "param2"},null, "String", null, null, 0);
	}
	
	public void testDecodeIndexKey_27() {
		runDecodeIndexKeyTest("myFunction/2/,neto.crazy.Number/param1,param2//foo.bar.Type", "myFunction", 2, new String[]{null, "neto.crazy"}, new String[]{null, "Number"}, new String[] {"param1", "param2"},null, null, "foo.bar", "Type", 0);
	}
	
	public void testDecodeIndexKey_28() {
		runDecodeIndexKeyTest("myFunction/2/,neto.crazy.Number/param1,param2/String/foo.bar.Type", "myFunction", 2, new String[]{null, "neto.crazy"}, new String[]{null, "Number"}, new String[] {"param1", "param2"},null, "String", "foo.bar", "Type", 0);
	}
	
	public void testDecodeIndexKey_29() {
		runDecodeIndexKeyTest("myFunction/2/bar.foo.String,/param1,param2//", "myFunction", 2, new String[]{"bar.foo", null}, new String[]{"String", null}, new String[] {"param1", "param2"},null, null, null, null, 0);
	}
	
	public void testDecodeIndexKey_30() {
		runDecodeIndexKeyTest("myFunction/2/bar.foo.String,/param1,param2/String/", "myFunction", 2, new String[]{"bar.foo", null}, new String[]{"String", null}, new String[] {"param1", "param2"},null, "String", null, null, 0);
	}
	
	public void testDecodeIndexKey_31() {
		runDecodeIndexKeyTest("myFunction/2/bar.foo.String,/param1,param2//foo.bar.Type", "myFunction", 2, new String[]{"bar.foo", null}, new String[]{"String", null}, new String[] {"param1", "param2"},null, null, "foo.bar", "Type", 0);
	}
	
	public void testDecodeIndexKey_32() {
		runDecodeIndexKeyTest("myFunction/2/bar.foo.String,/param1,param2/String/foo.bar.Type", "myFunction", 2, new String[]{"bar.foo", null}, new String[]{"String", null}, new String[] {"param1", "param2"},null, "String", "foo.bar", "Type", 0);
	}
	
	/**
	 * <p>Runs the asserts for a single create index key test.</p>
	 * 
	 * @param expected
	 * @param selector
	 * @param parameterCount
	 * @param parameterFullTypeNames
	 * @param parameterNames
	 * @param declaringFullTypeName
	 * @param returnFullTypeName
	 * @param modifiers
	 */
	private static void runCreateIndexKeyTest(String expected,
			char[] selector,
			int parameterCount,
			char[][] parameterFullTypeNames,
			char[][] parameterNames,
			char[] declaringFullTypeName,
			char[] returnFullTypeName,
			int modifiers) {
		
		char[] indexKey = MethodPattern.createIndexKey(selector, parameterCount, parameterFullTypeNames, parameterNames, declaringFullTypeName, returnFullTypeName, modifiers);
		
		String expectedWithModifiers = expected + (char) modifiers + (char) (modifiers>>16);
		
		assertNotNull("The created index key should not be null.\nEXPECTED:\n" + expectedWithModifiers, indexKey);
		
		assertTrue("The expected index key does not match the generated index key.\nWAS:\n" + new String(indexKey) + "\nEXPECTED:\n" + expected,
				CharOperation.equals(indexKey, expectedWithModifiers.toCharArray()));
	}
	
	/**
	 * <p>Runs a single decode index key test</p>
	 * 
	 * @param key
	 * @param selector
	 * @param parameterCount
	 * @param parameterQualifications
	 * @param parameterSimpleNames
	 * @param parameterNames
	 * @param returnQualification
	 * @param returnSimpleName
	 * @param declaringQualification
	 * @param declaringSimpleName
	 * @param modifiers
	 */
	private static void runDecodeIndexKeyTest(String key,
			String selector,
			int parameterCount,
			String[] parameterQualifications,
			String[] parameterSimpleNames,
			String[] parameterNames,
			String returnQualification,
			String returnSimpleName,
			String declaringQualification,
			String declaringSimpleName,
			int modifiers) {
		
		char[] keyWithModifiers = new char[key.length() + 3];
		System.arraycopy(key.toCharArray(), 0, keyWithModifiers, 0, key.length());
		keyWithModifiers[keyWithModifiers.length-3] = '/';
		keyWithModifiers[keyWithModifiers.length-2] = (char) modifiers;
		keyWithModifiers[keyWithModifiers.length-1] = (char) (modifiers>>16);
		
		MethodPattern pattern = new MethodPattern(false, false, false, null, 0);
		pattern = (MethodPattern)pattern.getBlankPattern();
		pattern.decodeIndexKey(keyWithModifiers);
		
		assertEquals("Expected selector does not equal decoded selector.", selector, pattern.selector);
		assertEquals("Expected parameter count does not equal decoded parameter count.", parameterCount, pattern.parameterCount);
		assertEquals("Expected parameter qualifications does not equal decoded parameter qualifications.", parameterQualifications, pattern.parameterQualifications);
		assertEquals("Expected parameter simple names does not equal decoded parameter simple names.", parameterSimpleNames, pattern.parameterSimpleNames);
		assertEquals("Expected parameter names does not equal decoded parameter names.", parameterNames, pattern.parameterNames);
		assertEquals("Expected return qualification does not equal decoded return wualification.", returnQualification, pattern.returnQualification);
		assertEquals("Expected return simple name does not equal decoded return simple name.", returnSimpleName, pattern.returnSimpleName);
		assertEquals("Expected declaring qualification does not equal decoded declaring qualification.", declaringQualification, pattern.declaringQualification);
		assertEquals("Expected declaring simple name does not equal decoded declaring simple name.", declaringSimpleName, pattern.declaringSimpleName);
	}
	
	private static void assertEquals(String message, String expected, char[] chars) {
		String actual = null;
		if(chars != null) {
			actual = new String(chars);
		}
		
		assertEquals(message, expected, actual);
	}
	
	private static void assertEquals(String message, String[] expected, char[][] actual) {
		
		String expectedColappsed = null;
		String actualColappsed = null;
		if(actual != null) {
			char[] actualColappsedChars = CharOperation.concatWith(actual, IIndexConstants.PARAMETER_SEPARATOR, false);
			if(actualColappsedChars != null) {
				actualColappsed = new String(actualColappsedChars);
			}
		}
		
		if(expected != null) {
			expectedColappsed = "";
			for(int i = 0; i < expected.length; ++i) {
				if(i > 0) {
					expectedColappsed += ",";
				}
				
				if(expected[i] != null) {
					expectedColappsed += expected[i];
				}
			}
		}
		
		assertEquals(message, expectedColappsed, actualColappsed);
	}
}

Lines 1-4 Link Here

(-).settings/org.eclipse.core.resources.prefs (-1 / +2 lines)
1	#Mon Jan 28 15:47:49 CST 2008	1	#Thu Jul 14 08:12:53 EDT 2011
2	eclipse.preferences.version=1	2	eclipse.preferences.version=1
		3	encoding//src/org/eclipse/wst/jsdt/core/tests/model/JSDTModelTests.java=US-ASCII
3	encoding/<project>=ISO-8859-1	4	encoding/<project>=ISO-8859-1
4	instance/org.eclipse.core.net/org.eclipse.core.net.hasMigrated=true	5	instance/org.eclipse.core.net/org.eclipse.core.net.hasMigrated=true




/*******************************************************************************
 * Copyright (c) 2000, 2011 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.wst.jsdt.core.tests.model;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.StringTokenizer;

import junit.framework.ComparisonFailure;
import junit.framework.Test;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IWorkspaceRunnable;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.wst.jsdt.core.IAccessRule;
import org.eclipse.wst.jsdt.core.IIncludePathAttribute;
import org.eclipse.wst.jsdt.core.IIncludePathEntry;
import org.eclipse.wst.jsdt.core.IJavaScriptProject;
import org.eclipse.wst.jsdt.core.IJavaScriptUnit;
import org.eclipse.wst.jsdt.core.IJsGlobalScopeContainer;
import org.eclipse.wst.jsdt.core.JavaScriptCore;
import org.eclipse.wst.jsdt.internal.codeassist.RelevanceConstants;

public class CompletionTests2 extends ModifyingResourceTests implements RelevanceConstants {
	
	public static final String DEFUALT_JSDTSCOPE = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + 
												  "<classpath>\n" + 
												   "       <classpathentry kind=\"src\" path=\"\"/>\n" + 
												   "       <classpathentry kind=\"con\" path=\"org.eclipse.wst.jsdt.launching.JRE_CONTAINER\"/>\n"+
												   "       <classpathentry kind=\"output\" path=\"\"/>\n"+
												   "</classpath>";
	/* 
		.project = DEFAULT_PROJECT_LEFT + project name + DEFAULT_PROJECT_RIGHT;
	*/
	public static final String DEFAULT_PROJECT_LEFT = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + 
													  "<projectDescription>\n" + 
													  "     <name>";
		
		
	public static final String DEFAULT_PROJECT_RIGHT ="</name>\n" + 
													  "     <comment></comment>\n" +
													  "     <projects>\n" +
													  "     </projects>\n"+
													  "     <buildSpec>\n"+
													  "     	<buildCommand>\n"+
													  "            <name>org.eclipse.wst.jsdt.core.javascriptValidator</name>\n"+
													  "               <arguments>\n"+
													  "               </arguments>\n"+
													  "         </buildCommand>\n"+
													  "     </buildSpec>\n"+
													  "     <natures>\n"+
													  "       <nature>org.eclipse.wst.jsdt.core.jsNature</nature>\n"+
													  "     </natures>\n" +
													  "</projectDescription>";

	
		
		
		
	public static class CompletionContainerInitializer implements ContainerInitializer.ITestInitializer {
		
		public static class DefaultContainer implements IJsGlobalScopeContainer {
			char[][] libPaths;
			boolean[] areExported;
			String[] forbiddenReferences;
			public DefaultContainer(char[][] libPaths, boolean[] areExported, String[] forbiddenReferences) {
				this.libPaths = libPaths;
				this.areExported = areExported;
				this.forbiddenReferences = forbiddenReferences;
			}
			/**
			 * @deprecated Use {@link #getIncludepathEntries()} instead
			 */
			public IIncludePathEntry[] getClasspathEntries() {
				return getIncludepathEntries();
			}
			public IIncludePathEntry[] getIncludepathEntries() {
				int length = this.libPaths.length;
				IIncludePathEntry[] entries = new IIncludePathEntry[length];
				for (int j = 0; j < length; j++) {
				    IPath path = new Path(new String(this.libPaths[j]));
				    boolean isExported = this.areExported[j];
		
				    IAccessRule[] accessRules;
				    if(forbiddenReferences != null && forbiddenReferences[j]!= null && forbiddenReferences[j].length() != 0) {
					    StringTokenizer tokenizer = new StringTokenizer(forbiddenReferences[j], ";");
					    int count = tokenizer.countTokens();
					    accessRules = new IAccessRule[count];
					    String token = null;
					    for (int i = 0; i < count; i++) {
					    	token = tokenizer.nextToken();
							accessRules[i] = JavaScriptCore.newAccessRule(new Path(token), IAccessRule.K_NON_ACCESSIBLE);
						}
					} else {
						accessRules = new IAccessRule[0];
					}
				    if (path.segmentCount() == 1) {
				        entries[j] = JavaScriptCore.newProjectEntry(path, accessRules, true, new IIncludePathAttribute[0], isExported);
				    } else {
						entries[j] = JavaScriptCore.newLibraryEntry(path, null, null, accessRules, new IIncludePathAttribute[0], isExported);
				    }
				}
				return entries;
			}
			public String getDescription() {
				return "Test container";
			}
			public int getKind() {
				return IJsGlobalScopeContainer.K_APPLICATION;
			}
			public IPath getPath() {
				return new Path("org.eclipse.wst.jsdt.core.tests.model.TEST_CONTAINER");
			}
			/* (non-Javadoc)
			 * @see org.eclipse.wst.jsdt.core.IJsGlobalScopeContainer#resolvedLibraryImport(java.lang.String)
			 */
			public String[] resolvedLibraryImport(String a) {
				return new String[] {a};
			}
		}
		
		Map containerValues;
		CoreException exception;
		
		public CompletionContainerInitializer(String projectName, String[] libPaths, boolean[] areExported) {
			this(projectName, libPaths, areExported, null);
		}
		public CompletionContainerInitializer(String projectName, String[] libPaths, boolean[] areExported, String[] forbiddenRefrences) {
			containerValues = new HashMap();
			
			int libPathsLength = libPaths.length;
			char[][] charLibPaths = new char[libPathsLength][];
			for (int i = 0; i < libPathsLength; i++) {
				charLibPaths[i] = libPaths[i].toCharArray();
			}
			containerValues.put(
				projectName, 
				newContainer(charLibPaths, areExported, forbiddenRefrences)
			);
		}
		protected DefaultContainer newContainer(final char[][] libPaths, final boolean[] areExperted, final String[] forbiddenRefrences) {
			return new DefaultContainer(libPaths, areExperted, forbiddenRefrences);
		}
		public boolean allowFailureContainer() {
			return true;
		}
		public void initialize(IPath containerPath, IJavaScriptProject project) throws CoreException {
			if (containerValues == null) return;
			try {
				JavaScriptCore.setJsGlobalScopeContainer(
					containerPath, 
					new IJavaScriptProject[] {project},
					new IJsGlobalScopeContainer[] {(IJsGlobalScopeContainer)containerValues.get(project.getElementName())}, 
					null);
			} catch (CoreException e) {
				this.exception = e;
				throw e;
			}
		}
	}
public CompletionTests2(String name) {
	super(name);
}
public void setUpSuite() throws Exception {
	super.setUpSuite();
	
	setUpJavaProject("Completion");
}
public void tearDownSuite() throws Exception {
	deleteProject("Completion");
	
	super.tearDownSuite();
}

protected static void assertResults(String expected, String actual) {
	try {
		assertEquals(expected, actual);
	} catch(ComparisonFailure c) {
		System.out.println(actual);
		System.out.println();
		throw c;
	}
}
static {
//	TESTS_NAMES = new String[] { "testBug96950" };
}
public static Test suite() {
	return buildModelTestSuite(CompletionTests2.class);
}

File createFile(File parent, String name, String content) throws IOException {
	File file = new File(parent, name);
	FileOutputStream out = new FileOutputStream(file);
	out.write(content.getBytes());
	out.close();
	return file;
}
File createDirectory(File parent, String name) {
	File dir = new File(parent, name);
	dir.mkdirs();
	return dir;
}
/**
 * Test for bug 29832
 */
public void testBug29832() throws Exception {
	try {
		// create variable
//		JavaScriptCore.setClasspathVariables(
//			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
//			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
//			null);

		// create P1
	//	IFile f = getFile("/Completion/lib.jar");
		IFile f = getFile("/Completion/ZZZ.js");
		
		
		IJavaScriptProject p = this.createJavaProject(
			"P1",
			new String[]{"/"},
			new String[]{});
		IFile libFile = this.createFile("/P1/ZZZ.js", f.getContents());
		this.addLibraryEntry(p, libFile.getLocation().toString(), true);
		
		// create P2
		this.createJavaProject(
			"P2",
			new String[]{"/"},
			new String[]{},
			new String[]{"/P1"});
		this.createFile(
			"/P2/X.js",
			"function testZZZClass {\n"+
			"  var z = new ZZZ();\n"+
			"  z;\n" +
			"}");
		
		waitUntilIndexesReady();
		
		// do completion
		CompletionTestsRequestor requestor = new CompletionTestsRequestor();
		IJavaScriptUnit cu= getCompilationUnit("P2", "", "", "X.js");
		
		String str = cu.getSource();
		String completeBehind = "z";
		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
		cu.codeComplete(cursorLocation, requestor);

//		assertEquals(
//			"element:ZZZ    completion:pz.ZZZ    relevance:"+(R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED),
//			requestor.getResults());
		assertEquals(
					"element:ZZZ    completion:ZZZ    relevance:" +(R_DEFAULT+R_RESOLVED+R_INTERESTING+R_NON_RESTRICTED) + "\n"+
					"element:ZZZ_FUNCTION    completion:ZZZ_FUNCTION()    relevance:11\n" +
					"element:ZZZ_FUNCTION    completion:ZZZ_FUNCTION()    relevance:11\n" +
					"element:z    completion:z    relevance:"+ (R_DEFAULT+R_RESOLVED+R_INTERESTING+R_CASE+R_EXACT_NAME+R_UNQUALIFIED+R_NON_RESTRICTED),
					requestor.getResults());
		
		// delete P1
		p.getProject().delete(true, false, null);
		
		// create P1
		File dest = getWorkspaceRoot().getLocation().toFile();
		File pro = this.createDirectory(dest, "P1");
		File proSet = this.createDirectory(pro,".settings");
		
		this.createFile(proSet, ".jsdtscope", DEFUALT_JSDTSCOPE);
					
					
//					"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
//			"<classpath>\n" +
//			"    <classpathentry kind=\"src\" path=\"\"/>\n" +
//			"    <classpathentry kind=\"var\" path=\"JCL_LIB\" sourcepath=\"JCL_SRC\" rootpath=\"JCL_SRCROOT\"/>\n" +
//			"    <classpathentry kind=\"output\" path=\"bin\"/>\n" +
//			"</classpath>");
			
		this.createFile(pro, ".project", DEFAULT_PROJECT_LEFT + "org.eclipse.wst.jsdt.core" + DEFAULT_PROJECT_RIGHT);
//			"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
//			"<projectDescription>\n" +
//			"	<name>org.eclipse.wst.jsdt.core</name>\n" +
//			"	<comment></comment>\n" +
//			"	<projects>\n" +
//			"	</projects>\n" +
//			"	<buildSpec>\n" +
//			"		<buildCommand>\n" +
//			"			<name>org.eclipse.wst.jsdt.core.javabuilder</name>\n" +
//			"			<arguments>\n" +
//			"			</arguments>\n" +
//			"		</buildCommand>\n" +
//			"	</buildSpec>\n" +
//			"	<natures>\n" +
//			"		<nature>org.eclipse.wst.jsdt.core.javanature</nature>\n" +
//			"	</natures>\n" +
//			"</projectDescription>");
		
		//File src = this.createDirectory(pro, "src");
		
		//File pz = this.createDirectory(src, "pz");

		this.createFile(pro,"ZZZ.js","function testZZZClass {\n"+
										"  var z = new ZZZ();\n"+
										"  z;\n" +
										"}");
		
		final IProject project = getWorkspaceRoot().getProject("P1");
		IWorkspaceRunnable populate = new IWorkspaceRunnable() {
			public void run(IProgressMonitor monitor) throws CoreException {
				project.create(null);
				project.open(null);
			}
		};
		getWorkspace().run(populate, null);
		JavaScriptCore.create(project);
		
		waitUntilIndexesReady();
		
		// do completion
		requestor = new CompletionTestsRequestor();
		cu.codeComplete(cursorLocation, requestor);

		assertEquals(
			"element:z    completion:z    relevance:"+ (R_DEFAULT+R_INTERESTING+R_CASE+R_EXACT_NAME+R_UNQUALIFIED+R_NON_RESTRICTED) + "\n" +		
			"element:z    completion:z    relevance:"+(R_DEFAULT+R_RESOLVED+R_INTERESTING + R_CASE + R_EXACT_NAME + R_UNQUALIFIED + R_NON_RESTRICTED),
			requestor.getResults());
	} finally {
		this.deleteProject("P1");
		this.deleteProject("P2");
	}
}
/**
 * Test for bug 33560
 */
public void testBug33560() throws Exception {
	try {
		// create variable
//		JavaScriptCore.setClasspathVariables(
//			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
//			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
//			null);

		// create P1
		//IFile f = getFile("/Completion/lib.jar");
		IFile f = getFile("/Completion/ZZZ.js");
		IJavaScriptProject p = this.createJavaProject(
					"P1",
					new String[]{"/"},
					new String[]{});;
					 IFile libFile = this.createFile("/P1/ZZZ.js", f.getContents());
						this.addLibraryEntry(p, libFile.getLocation().toString(), true);
		
		// create P2
						this.createJavaProject(
									"P2",
									new String[]{"/"},
									new String[]{},
									new String[]{"/P1"});
					
		// create P3
						this.createJavaProject(
									"P3",
									new String[]{"/"},
									new String[]{},
									new String[]{"/P1"});
						this.createFile(
									"/P3/X.js",
									"function testZZZClass {\n"+
									"  var z = new ZZZ();\n"+
									"  z;\n" +
									"}");
		
		waitUntilIndexesReady();
		
		// do completion
		CompletionTestsRequestor requestor = new CompletionTestsRequestor();
		IJavaScriptUnit cu= getCompilationUnit("P3", "", "", "X.js");
		
		String str = cu.getSource();
		String completeBehind = "z";
		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
		cu.codeComplete(cursorLocation, requestor);
		assertEquals(
		"element:ZZZ    completion:ZZZ    relevance:" +(R_DEFAULT+R_RESOLVED+R_INTERESTING+R_NON_RESTRICTED ) + "\n"+
		"element:ZZZ_FUNCTION    completion:ZZZ_FUNCTION()    relevance:11\n" +
		"element:ZZZ_FUNCTION    completion:ZZZ_FUNCTION()    relevance:11\n" +
		"element:z    completion:z    relevance:"+ (R_DEFAULT+R_RESOLVED+R_INTERESTING+R_CASE+R_EXACT_NAME+R_UNQUALIFIED+R_NON_RESTRICTED),
		requestor.getResults());
		
		
		// delete P1
		p.getProject().delete(true, false, null);
		
		// create P1
		File dest = getWorkspaceRoot().getLocation().toFile();
		File pro = this.createDirectory(dest, "P1");
		File proSet = this.createDirectory(pro,".settings");
		
		this.createFile(proSet, ".jsdtscope", DEFUALT_JSDTSCOPE);
//		this.createFile(pro, ".classpath", "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
//			"<classpath>\n" +
//			"    <classpathentry kind=\"src\" path=\"src\"/>\n" +
//			"    <classpathentry kind=\"var\" path=\"JCL_LIB\" sourcepath=\"JCL_SRC\" rootpath=\"JCL_SRCROOT\"/>\n" +
//			"    <classpathentry kind=\"output\" path=\"bin\"/>\n" +
//			"</classpath>");
		this.createFile(pro, ".project", DEFAULT_PROJECT_LEFT + "org.eclipse.wst.jsdt.core" + DEFAULT_PROJECT_RIGHT);
//		this.createFile(pro, ".project", 
//			"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
//			"<projectDescription>\n" +
//			"	<name>org.eclipse.wst.jsdt.core</name>\n" +
//			"	<comment></comment>\n" +
//			"	<projects>\n" +
//			"	</projects>\n" +
//			"	<buildSpec>\n" +
//			"		<buildCommand>\n" +
//			"			<name>org.eclipse.wst.jsdt.core.javabuilder</name>\n" +
//			"			<arguments>\n" +
//			"			</arguments>\n" +
//			"		</buildCommand>\n" +
//			"	</buildSpec>\n" +
//			"	<natures>\n" +
//			"		<nature>org.eclipse.wst.jsdt.core.javanature</nature>\n" +
//			"	</natures>\n" +
//			"</projectDescription>");
//		
		File src = this.createDirectory(pro, "src");
		
		File pz = this.createDirectory(src, "pz");
		
		this.createFile(pro,"ZZZ.js","function testZZZClass {\n"+
					"  var z = new ZZZ();\n"+
					"  z;\n" +
					"}");
		
		final IProject project = getWorkspaceRoot().getProject("P1");
		IWorkspaceRunnable populate = new IWorkspaceRunnable() {
			public void run(IProgressMonitor monitor) throws CoreException {
				project.create(null);
				project.open(null);
			}
		};
		getWorkspace().run(populate, null);
		JavaScriptCore.create(project);
		
		waitUntilIndexesReady();
		
		// do completion
		requestor = new CompletionTestsRequestor();
		cu.codeComplete(cursorLocation, requestor);

		assertEquals(
					"element:z    completion:z    relevance:"+ (R_DEFAULT+R_INTERESTING+R_CASE+R_EXACT_NAME+R_UNQUALIFIED+R_NON_RESTRICTED) + "\n" +
					"element:z    completion:z    relevance:"+(R_DEFAULT+R_RESOLVED+R_INTERESTING + R_CASE + R_EXACT_NAME + R_UNQUALIFIED + R_NON_RESTRICTED),
					requestor.getResults());
		} finally {
		this.deleteProject("P1");
		this.deleteProject("P2");
		this.deleteProject("P3");
	}
}
/*
 * 
 * This tests a project which includes functions and methods marked as "not exported" from another project.  This is N/A for JS.
 */

//public void testBug79288() throws Exception {
//	try {
//		// create variable
////		JavaScriptCore.setClasspathVariables(
////			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
////			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
////			null);
//
//		// create P1
//		this.createJavaProject(
//			"P1",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			 "bin");
//		
//		this.createFolder("/P1/src/a");
//		this.createFile(
//				"/P1/src/a/XX1.js",
//				"package a;\n"+
//				"public class XX1 {\n"+
//				"}");
//		
//		// create P2
//		this.createJavaProject(
//			"P2",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			new String[]{"/P1"},
//			"bin");
//		
//		this.createFolder("/P2/src/b");
//		this.createFile(
//				"/P2/src/b/XX2.js",
//				"package b;\n"+
//				"public class XX2 {\n"+
//				"}");
//		
//		// create P3
//		this.createJavaProject(
//			"P3",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			new String[]{"/P2"},
//			"bin");
//		
//		this.createFile(
//				"/P3/src/YY.js",
//				"public class YY {\n"+
//				"  vois foo(){\n"+
//				"    XX\n"+
//				"  }\n"+
//				"}");
//		
//		waitUntilIndexesReady();
//		
//		// do completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit cu= getCompilationUnit("P3", "src", "", "YY.js");
//		
//		String str = cu.getSource();
//		String completeBehind = "XX";
//		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
//		cu.codeComplete(cursorLocation, requestor);
//		
//		assertResults(
//			"XX2[TYPE_REF]{b.XX2, b, Lb.XX2;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}",
//			requestor.getResults());
//	} finally {
//		this.deleteProject("P1");
//		this.deleteProject("P2");
//		this.deleteProject("P3");
//	}
//}




//public void testBug91772() throws Exception {
//	try {
//		// create variable
////		JavaScriptCore.setClasspathVariables(
////			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
////			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
////			null);
//
//		// create P1
//		this.createJavaProject(
//			"P1",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			 "bin");
//		
//		this.createFolder("/P1/src/a");
//		this.createFile(
//				"/P1/src/a/XX1.js",
//				"package a;\n"+
//				"public class XX1 {\n"+
//				"}");
//		
//		// create P2
//		ContainerInitializer.setInitializer(new CompletionContainerInitializer("P2", new String[] {"/P1"}, new boolean[] {true}));
//		String[] classLib = new String[]{"JCL_LIB"};
//		int classLibLength = classLib.length;
//		String[] lib = new String[classLibLength + 1];
//		System.arraycopy(classLib, 0, lib, 0, classLibLength);
//		lib[classLibLength] = "org.eclipse.wst.jsdt.core.tests.model.TEST_CONTAINER";
//		this.createJavaProject(
//			"P2",
//			new String[]{"src"},
//			lib,
//			"bin");
//		
//		this.createFolder("/P2/src/b");
//		this.createFile(
//				"/P2/src/b/XX2.js",
//				"package b;\n"+
//				"public class XX2 {\n"+
//				"}");
//		
//		// create P3
//		this.createJavaProject(
//			"P3",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			new String[]{"/P2"},
//			"bin");
//		
//		this.createFile(
//				"/P3/src/YY.js",
//				"public class YY {\n"+
//				"  vois foo(){\n"+
//				"    XX\n"+
//				"  }\n"+
//				"}");
//		
//		waitUntilIndexesReady();
//		
//		// do completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit cu= getCompilationUnit("P3", "src", "", "YY.js");
//		
//		String str = cu.getSource();
//		String completeBehind = "XX";
//		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
//		cu.codeComplete(cursorLocation, requestor);
//		
//		assertResults(
//			"XX1[TYPE_REF]{a.XX1, a, La.XX1;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
//			"XX2[TYPE_REF]{b.XX2, b, Lb.XX2;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}",
//			requestor.getResults());
//	} finally {
//		this.deleteProject("P1");
//		this.deleteProject("P2");
//		this.deleteProject("P3");
//		
//		
//		// TODO the following code is not the correct way to remove the container
//		// Cleanup caches
//		JavaModelManager manager = JavaModelManager.getJavaModelManager();
//		manager.containers = new HashMap(5);
//		manager.variables = new HashMap(5);
//	}
//}
//public void testBug93891() throws Exception {
//	Hashtable oldOptions = JavaScriptCore.getOptions();
//	try {
//		Hashtable options = new Hashtable(oldOptions);
//		options.put(JavaScriptCore.COMPILER_PB_FORBIDDEN_REFERENCE, JavaScriptCore.ERROR);
//		options.put(JavaScriptCore.CODEASSIST_FORBIDDEN_REFERENCE_CHECK, JavaScriptCore.ENABLED);
//		options.put(JavaScriptCore.CODEASSIST_DISCOURAGED_REFERENCE_CHECK, JavaScriptCore.DISABLED);
//		JavaScriptCore.setOptions(options);
//		
//		// create variable
////		JavaScriptCore.setClasspathVariables(
////			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
////			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
////			null);
//
//		// create P1
//		this.createJavaProject(
//			"P1",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			 "bin");
//		
//		this.createFolder("/P1/src/a");
//		this.createFile(
//				"/P1/src/a/XX1.js",
//				"package a;\n"+
//				"public class XX1 {\n"+
//				"}");
//		
//		this.createFolder("/P1/src/b");
//		this.createFile(
//				"/P1/src/b/XX2.js",
//				"package b;\n"+
//				"public class XX2 {\n"+
//				"}");
//		
//		// create P2
//		ContainerInitializer.setInitializer(new CompletionContainerInitializer("P2", new String[] {"/P1"}, new boolean[] {true}, new String[]{"a/*"}));
//		String[] classLib = new String[]{"JCL_LIB"};
//		int classLibLength = classLib.length;
//		String[] lib = new String[classLibLength + 1];
//		System.arraycopy(classLib, 0, lib, 0, classLibLength);
//		lib[classLibLength] = "org.eclipse.wst.jsdt.core.tests.model.TEST_CONTAINER";
//		this.createJavaProject(
//			"P2",
//			new String[]{"src"},
//			lib,
//			"bin");
//		
//		this.createFolder("/P2/src/b");
//		this.createFile(
//				"/P2/src/YY.js",
//				"public class YY {\n"+
//				"  void foo() {\n"+
//				"    XX\n"+
//				"  }\n"+
//				"}");
//		
//		waitUntilIndexesReady();
//		
//		// do completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit cu= getCompilationUnit("P2", "src", "", "YY.js");
//		
//		String str = cu.getSource();
//		String completeBehind = "XX";
//		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
//		cu.codeComplete(cursorLocation, requestor);
//		
//		assertResults(
//			"XX2[TYPE_REF]{b.XX2, b, Lb.XX2;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}",
//			requestor.getResults());
//	} finally {
//		this.deleteProject("P1");
//		this.deleteProject("P2");
//		
//		// TODO the following code is not the correct way to remove the container
//		// Cleanup caches
//		JavaModelManager manager = JavaModelManager.getJavaModelManager();
//		manager.containers = new HashMap(5);
//		manager.variables = new HashMap(5);
//		
//		JavaScriptCore.setOptions(oldOptions);
//	}
//}
//public void testAccessRestriction1() throws Exception {
//	Hashtable oldOptions = JavaScriptCore.getOptions();
//	try {
//		Hashtable options = new Hashtable(oldOptions);
//		options.put(JavaScriptCore.COMPILER_PB_FORBIDDEN_REFERENCE, JavaScriptCore.IGNORE);
//		options.put(JavaScriptCore.COMPILER_PB_DISCOURAGED_REFERENCE, JavaScriptCore.IGNORE);
//		options.put(JavaScriptCore.CODEASSIST_FORBIDDEN_REFERENCE_CHECK, JavaScriptCore.DISABLED);
//		options.put(JavaScriptCore.CODEASSIST_DISCOURAGED_REFERENCE_CHECK, JavaScriptCore.DISABLED);
//		JavaScriptCore.setOptions(options);
//		
//		// create variable
////		JavaScriptCore.setClasspathVariables(
////			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
////			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
////			null);
//
//		// create P1
//		this.createJavaProject(
//			"P1",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			 "bin");
//		
//		this.createFolder("/P1/src/a");
//		this.createFile(
//				"/P1/src/a/XX1.js",
//				"package a;\n"+
//				"public class XX1 {\n"+
//				"}");
//
//		this.createFolder("/P1/src/b");
//		this.createFile(
//				"/P1/src/b/XX2.js",
//				"package b;\n"+
//				"public class XX2 {\n"+
//				"}");
//		
//		// create P2
//		this.createJavaProject(
//			"P2",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			new String[]{"/P1"},
//			"bin");
//		this.createFile(
//			"/P2/src/YY.js",
//			"public class YY {\n"+
//			"  void foo() {\n"+
//			"    XX\n"+
//			"  }\n"+
//			"}");
//		
//		waitUntilIndexesReady();
//		
//		// do completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit cu= getCompilationUnit("P2", "src", "", "YY.js");
//		
//		String str = cu.getSource();
//		String completeBehind = "XX";
//		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
//		cu.codeComplete(cursorLocation, requestor);
//		
//		assertResults(
//			"XX1[TYPE_REF]{a.XX1, a, La.XX1;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
// 			"XX2[TYPE_REF]{b.XX2, b, Lb.XX2;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}",
//			requestor.getResults());
//	} finally {
//		this.deleteProject("P1");
//		this.deleteProject("P2");
//		JavaScriptCore.setOptions(oldOptions);
//	}
//}
//
//public void testAccessRestriction2() throws Exception {
//	Hashtable oldOptions = JavaScriptCore.getOptions();
//	try {
//		Hashtable options = new Hashtable(oldOptions);
//		options.put(JavaScriptCore.COMPILER_PB_FORBIDDEN_REFERENCE, JavaScriptCore.IGNORE);
//		options.put(JavaScriptCore.COMPILER_PB_DISCOURAGED_REFERENCE, JavaScriptCore.IGNORE);
//		options.put(JavaScriptCore.CODEASSIST_FORBIDDEN_REFERENCE_CHECK, JavaScriptCore.DISABLED);
//		options.put(JavaScriptCore.CODEASSIST_DISCOURAGED_REFERENCE_CHECK, JavaScriptCore.DISABLED);
//		JavaScriptCore.setOptions(options);
//		
//		// create variable
////		JavaScriptCore.setClasspathVariables(
////			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
////			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
////			null);
//
//		// create P1
//		this.createJavaProject(
//			"P1",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			 "bin");
//		
//		this.createFolder("/P1/src/a");
//		this.createFile(
//				"/P1/src/a/XX1.js",
//				"package a;\n"+
//				"public class XX1 {\n"+
//				"}");
//
//		this.createFolder("/P1/src/b");
//		this.createFile(
//				"/P1/src/b/XX2.js",
//				"package b;\n"+
//				"public class XX2 {\n"+
//				"}");
//		
//		// create P2
//		this.createJavaProject(
//			"P2",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P1"},
//			new String[][]{{}},
//			new String[][]{{"a/*"}},
//			new boolean[]{false},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		this.createFile(
//			"/P2/src/YY.js",
//			"public class YY {\n"+
//			"  void foo() {\n"+
//			"    XX\n"+
//			"  }\n"+
//			"}");
//		
//		waitUntilIndexesReady();
//		
//		// do completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit cu= getCompilationUnit("P2", "src", "", "YY.js");
//		
//		String str = cu.getSource();
//		String completeBehind = "XX";
//		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
//		cu.codeComplete(cursorLocation, requestor);
//		
//		assertResults(
//			"XX1[TYPE_REF]{a.XX1, a, La.XX1;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
// 			"XX2[TYPE_REF]{b.XX2, b, Lb.XX2;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}",
//			requestor.getResults());
//	} finally {
//		this.deleteProject("P1");
//		this.deleteProject("P2");
//		JavaScriptCore.setOptions(oldOptions);
//	}
//}
//public void testAccessRestriction3() throws Exception {
//	Hashtable oldOptions = JavaScriptCore.getOptions();
//	try {
//		Hashtable options = new Hashtable(oldOptions);
//		options.put(JavaScriptCore.COMPILER_PB_FORBIDDEN_REFERENCE, JavaScriptCore.ERROR);
//		options.put(JavaScriptCore.CODEASSIST_FORBIDDEN_REFERENCE_CHECK, JavaScriptCore.DISABLED);
//		options.put(JavaScriptCore.CODEASSIST_DISCOURAGED_REFERENCE_CHECK, JavaScriptCore.DISABLED);
//		JavaScriptCore.setOptions(options);
//		
//		// create variable
////		JavaScriptCore.setClasspathVariables(
////			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
////			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
////			null);
//
//		// create P1
//		this.createJavaProject(
//			"P1",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			 "bin");
//		
//		this.createFolder("/P1/src/a");
//		this.createFile(
//				"/P1/src/a/XX1.js",
//				"package a;\n"+
//				"public class XX1 {\n"+
//				"}");
//
//		this.createFolder("/P1/src/b");
//		this.createFile(
//				"/P1/src/b/XX2.js",
//				"package b;\n"+
//				"public class XX2 {\n"+
//				"}");
//		
//		// create P2
//		this.createJavaProject(
//			"P2",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P1"},
//			new String[][]{{}},
//			new String[][]{{"a/*"}},
//			new boolean[]{false},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		this.createFile(
//			"/P2/src/YY.js",
//			"public class YY {\n"+
//			"  void foo() {\n"+
//			"    XX\n"+
//			"  }\n"+
//			"}");
//		
//		waitUntilIndexesReady();
//		
//		// do completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit cu= getCompilationUnit("P2", "src", "", "YY.js");
//		
//		String str = cu.getSource();
//		String completeBehind = "XX";
//		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
//		cu.codeComplete(cursorLocation, requestor);
//		
//		assertResults(
//			"XX1[TYPE_REF]{a.XX1, a, La.XX1;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE) + "}\n" +
// 			"XX2[TYPE_REF]{b.XX2, b, Lb.XX2;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}",
//			requestor.getResults());
//	} finally {
//		this.deleteProject("P1");
//		this.deleteProject("P2");
//		JavaScriptCore.setOptions(oldOptions);
//	}
//}
//public void testAccessRestriction4() throws Exception {
//	Hashtable oldOptions = JavaScriptCore.getOptions();
//	try {
//		Hashtable options = new Hashtable(oldOptions);
//		options.put(JavaScriptCore.COMPILER_PB_FORBIDDEN_REFERENCE, JavaScriptCore.IGNORE);
//		options.put(JavaScriptCore.COMPILER_PB_DISCOURAGED_REFERENCE, JavaScriptCore.IGNORE);
//		options.put(JavaScriptCore.CODEASSIST_FORBIDDEN_REFERENCE_CHECK, JavaScriptCore.ENABLED);
//		options.put(JavaScriptCore.CODEASSIST_DISCOURAGED_REFERENCE_CHECK, JavaScriptCore.DISABLED);
//		JavaScriptCore.setOptions(options);
//		
//		// create variable
////		JavaScriptCore.setClasspathVariables(
////			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
////			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
////			null);
//
//		// create P1
//		this.createJavaProject(
//			"P1",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			 "bin");
//		
//		this.createFolder("/P1/src/a");
//		this.createFile(
//				"/P1/src/a/XX1.js",
//				"package a;\n"+
//				"public class XX1 {\n"+
//				"}");
//
//		this.createFolder("/P1/src/b");
//		this.createFile(
//				"/P1/src/b/XX2.js",
//				"package b;\n"+
//				"public class XX2 {\n"+
//				"}");
//		
//		// create P2
//		this.createJavaProject(
//			"P2",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P1"},
//			new String[][]{{}},
//			new String[][]{{"a/*"}},
//			new boolean[]{false},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		this.createFile(
//			"/P2/src/YY.js",
//			"public class YY {\n"+
//			"  void foo() {\n"+
//			"    XX\n"+
//			"  }\n"+
//			"}");
//		
//		waitUntilIndexesReady();
//		
//		// do completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit cu= getCompilationUnit("P2", "src", "", "YY.js");
//		
//		String str = cu.getSource();
//		String completeBehind = "XX";
//		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
//		cu.codeComplete(cursorLocation, requestor);
//		
//		assertResults(
//			"XX1[TYPE_REF]{a.XX1, a, La.XX1;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
// 			"XX2[TYPE_REF]{b.XX2, b, Lb.XX2;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}",
//			requestor.getResults());
//	} finally {
//		this.deleteProject("P1");
//		this.deleteProject("P2");
//		JavaScriptCore.setOptions(oldOptions);
//	}
//}
//public void testAccessRestriction5() throws Exception {
//	Hashtable oldOptions = JavaScriptCore.getOptions();
//	try {
//		Hashtable options = new Hashtable(oldOptions);
//		options.put(JavaScriptCore.COMPILER_PB_FORBIDDEN_REFERENCE, JavaScriptCore.ERROR);
//		options.put(JavaScriptCore.CODEASSIST_FORBIDDEN_REFERENCE_CHECK, JavaScriptCore.ENABLED);
//		options.put(JavaScriptCore.CODEASSIST_DISCOURAGED_REFERENCE_CHECK, JavaScriptCore.DISABLED);
//		JavaScriptCore.setOptions(options);
//		
//		// create variable
////		JavaScriptCore.setClasspathVariables(
////			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
////			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
////			null);
//
//		// create P1
//		this.createJavaProject(
//			"P1",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			 "bin");
//		
//		this.createFolder("/P1/src/a");
//		this.createFile(
//				"/P1/src/a/XX1.js",
//				"package a;\n"+
//				"public class XX1 {\n"+
//				"}");
//
//		this.createFolder("/P1/src/b");
//		this.createFile(
//				"/P1/src/b/XX2.js",
//				"package b;\n"+
//				"public class XX2 {\n"+
//				"}");
//		
//		// create P2
//		this.createJavaProject(
//			"P2",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P1"},
//			new String[][]{{}},
//			new String[][]{{"a/*"}},
//			new boolean[]{false},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		this.createFile(
//			"/P2/src/YY.js",
//			"public class YY {\n"+
//			"  void foo() {\n"+
//			"    XX\n"+
//			"  }\n"+
//			"}");
//		
//		waitUntilIndexesReady();
//		
//		// do completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit cu= getCompilationUnit("P2", "src", "", "YY.js");
//		
//		String str = cu.getSource();
//		String completeBehind = "XX";
//		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
//		cu.codeComplete(cursorLocation, requestor);
//		
//		assertResults(
//			"XX2[TYPE_REF]{b.XX2, b, Lb.XX2;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}",
//			requestor.getResults());
//	} finally {
//		this.deleteProject("P1");
//		this.deleteProject("P2");
//		JavaScriptCore.setOptions(oldOptions);
//	}
//}
//public void testAccessRestriction6() throws Exception {
//	Hashtable oldOptions = JavaScriptCore.getOptions();
//	try {
//		Hashtable options = new Hashtable(oldOptions);
//		options.put(JavaScriptCore.COMPILER_PB_FORBIDDEN_REFERENCE, JavaScriptCore.ERROR);
//		options.put(JavaScriptCore.CODEASSIST_FORBIDDEN_REFERENCE_CHECK, JavaScriptCore.ENABLED);
//		options.put(JavaScriptCore.CODEASSIST_DISCOURAGED_REFERENCE_CHECK, JavaScriptCore.DISABLED);
//		JavaScriptCore.setOptions(options);
//		
//		// create variable
////		JavaScriptCore.setClasspathVariables(
////			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
////			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
////			null);
//
//		// create P1
//		this.createJavaProject(
//			"P1",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			 "bin");
//		
//		this.createFolder("/P1/src/a");
//		this.createFile(
//				"/P1/src/a/XX1.js",
//				"package a;\n"+
//				"public class XX1 {\n"+
//				"}");
//
//		this.createFolder("/P1/src/b");
//		this.createFile(
//				"/P1/src/b/XX2.js",
//				"package b;\n"+
//				"public class XX2 {\n"+
//				"}");
//		
//		this.createFolder("/P1/src/c");
//		this.createFile(
//				"/P1/src/c/XX3.js",
//				"package c;\n"+
//				"public class XX3 {\n"+
//				"}");
//		
//		// create P2
//		this.createJavaProject(
//			"P2",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P1"},
//			new String[][]{{}},
//			new String[][]{{"a/*"}},
//			new boolean[]{true},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		
//		// create P3
//		this.createJavaProject(
//			"P3",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P2"},
//			new String[][]{{}},
//			new String[][]{{"b/*"}},
//			new boolean[]{false},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		
//		this.createFile(
//			"/P3/src/YY.js",
//			"public class YY {\n"+
//			"  void foo() {\n"+
//			"    XX\n"+
//			"  }\n"+
//			"}");
//		
//		waitUntilIndexesReady();
//		
//		// do completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit cu= getCompilationUnit("P3", "src", "", "YY.js");
//		
//		String str = cu.getSource();
//		String completeBehind = "XX";
//		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
//		cu.codeComplete(cursorLocation, requestor);
//		
//		assertResults(
//			"XX3[TYPE_REF]{c.XX3, c, Lc.XX3;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}",
//			requestor.getResults());
//	} finally {
//		this.deleteProject("P1");
//		this.deleteProject("P2");
//		this.deleteProject("P3");
//		JavaScriptCore.setOptions(oldOptions);
//	}
//}
//public void testAccessRestriction7() throws Exception {
//	Hashtable oldOptions = JavaScriptCore.getOptions();
//	try {
//		Hashtable options = new Hashtable(oldOptions);
//		options.put(JavaScriptCore.COMPILER_PB_FORBIDDEN_REFERENCE, JavaScriptCore.ERROR);
//		options.put(JavaScriptCore.CODEASSIST_FORBIDDEN_REFERENCE_CHECK, JavaScriptCore.ENABLED);
//		options.put(JavaScriptCore.CODEASSIST_DISCOURAGED_REFERENCE_CHECK, JavaScriptCore.DISABLED);
//		JavaScriptCore.setOptions(options);
//		
//		// create variable
////		JavaScriptCore.setClasspathVariables(
////			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
////			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
////			null);
//
//		// create P1
//		this.createJavaProject(
//			"P1",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			 "bin");
//		
//		this.createFolder("/P1/src/a");
//		this.createFile(
//				"/P1/src/a/XX1.js",
//				"package a;\n"+
//				"public class XX1 {\n"+
//				"}");
//
//		this.createFolder("/P1/src/b");
//		this.createFile(
//				"/P1/src/b/XX2.js",
//				"package b;\n"+
//				"public class XX2 {\n"+
//				"}");
//		
//		// create P2
//		this.createJavaProject(
//			"P2",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P1", "/P3"},
//			new String[][]{{}, {}},
//			new String[][]{{"a/*"}, {}},
//			new boolean[]{false, false},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		this.createFile(
//				"/P2/src/YY.js",
//				"public class YY {\n"+
//				"  void foo() {\n"+
//				"    XX\n"+
//				"  }\n"+
//				"}");
//		
//		// create P3
//		this.createJavaProject(
//			"P3",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P1"},
//			new String[][]{{}},
//			new String[][]{{}},
//			new boolean[]{true},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		
//		waitUntilIndexesReady();
//		
//		// do completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit cu= getCompilationUnit("P2", "src", "", "YY.js");
//		
//		String str = cu.getSource();
//		String completeBehind = "XX";
//		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
//		cu.codeComplete(cursorLocation, requestor);
//		
//		assertResults(
//			"XX2[TYPE_REF]{b.XX2, b, Lb.XX2;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}",
//			requestor.getResults());
//	} finally {
//		this.deleteProject("P1");
//		this.deleteProject("P2");
//		this.deleteProject("P3");
//		JavaScriptCore.setOptions(oldOptions);
//	}
//}
//public void testAccessRestriction8() throws Exception {
//	Hashtable oldOptions = JavaScriptCore.getOptions();
//	try {
//		Hashtable options = new Hashtable(oldOptions);
//		options.put(JavaScriptCore.COMPILER_PB_FORBIDDEN_REFERENCE, JavaScriptCore.ERROR);
//		options.put(JavaScriptCore.CODEASSIST_FORBIDDEN_REFERENCE_CHECK, JavaScriptCore.ENABLED);
//		options.put(JavaScriptCore.CODEASSIST_DISCOURAGED_REFERENCE_CHECK, JavaScriptCore.DISABLED);
//		JavaScriptCore.setOptions(options);
//		
//		// create variable
////		JavaScriptCore.setClasspathVariables(
////			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
////			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
////			null);
//
//		// create P1
//		this.createJavaProject(
//			"P1",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			 "bin");
//		
//		this.createFolder("/P1/src/a");
//		this.createFile(
//				"/P1/src/a/XX1.js",
//				"package a;\n"+
//				"public class XX1 {\n"+
//				"}");
//
//		this.createFolder("/P1/src/b");
//		this.createFile(
//				"/P1/src/b/XX2.js",
//				"package b;\n"+
//				"public class XX2 {\n"+
//				"}");
//		
//		// create P2
//		this.createJavaProject(
//			"P2",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P3", "/P1"},
//			new String[][]{{}, {}},
//			new String[][]{{}, {"a/*"}},
//			new boolean[]{false, false},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		this.createFile(
//				"/P2/src/YY.js",
//				"public class YY {\n"+
//				"  void foo() {\n"+
//				"    XX\n"+
//				"  }\n"+
//				"}");
//		
//		// create P3
//		this.createJavaProject(
//			"P3",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P1"},
//			new String[][]{{}},
//			new String[][]{{}},
//			new boolean[]{true},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		
//		waitUntilIndexesReady();
//		
//		// do completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit cu= getCompilationUnit("P2", "src", "", "YY.js");
//		
//		String str = cu.getSource();
//		String completeBehind = "XX";
//		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
//		cu.codeComplete(cursorLocation, requestor);
//		
//		assertResults(
//			"XX1[TYPE_REF]{a.XX1, a, La.XX1;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
//			"XX2[TYPE_REF]{b.XX2, b, Lb.XX2;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}",
//			requestor.getResults());
//	} finally {
//		this.deleteProject("P1");
//		this.deleteProject("P2");
//		this.deleteProject("P3");
//		JavaScriptCore.setOptions(oldOptions);
//	}
//}
//public void testAccessRestriction9() throws Exception {
//	Hashtable oldOptions = JavaScriptCore.getOptions();
//	try {
//		Hashtable options = new Hashtable(oldOptions);
//		options.put(JavaScriptCore.COMPILER_PB_FORBIDDEN_REFERENCE, JavaScriptCore.ERROR);
//		options.put(JavaScriptCore.CODEASSIST_FORBIDDEN_REFERENCE_CHECK, JavaScriptCore.ENABLED);
//		options.put(JavaScriptCore.CODEASSIST_DISCOURAGED_REFERENCE_CHECK, JavaScriptCore.DISABLED);
//		JavaScriptCore.setOptions(options);
//		
//		// create variable
////		JavaScriptCore.setClasspathVariables(
////			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
////			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
////			null);
//
//		// create P1
//		this.createJavaProject(
//			"P1",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			 "bin");
//		
//		this.createFolder("/P1/src/p11");
//		this.createFile(
//				"/P1/src/p11/XX11.js",
//				"package p11;\n"+
//				"public class XX11 {\n"+
//				"}");
//		
//		this.createFolder("/P1/src/p12");
//		this.createFile(
//				"/P1/src/p12/XX12.js",
//				"package p12;\n"+
//				"public class XX12 {\n"+
//				"}");
//		
//		// create P2
//		this.createJavaProject(
//			"P2",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P1", "/P3"},
//			new String[][]{{}, {}},
//			new String[][]{{"p11/*"}, {"p31/*"}},
//			new boolean[]{true, true},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		
//		this.createFolder("/P2/src/p21");
//		this.createFile(
//				"/P2/src/p21/XX21.js",
//				"package p21;\n"+
//				"public class XX21 {\n"+
//				"}");
//		
//		this.createFolder("/P2/src/p22");
//		this.createFile(
//				"/P2/src/p22/XX22.js",
//				"package p22;\n"+
//				"public class XX22 {\n"+
//				"}");
//		
//		// create P3
//		this.createJavaProject(
//			"P3",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P1"},
//			new String[][]{{}},
//			new String[][]{{"p12/*"}},
//			new boolean[]{true},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		
//		this.createFolder("/P3/src/p31");
//		this.createFile(
//				"/P3/src/p31/XX31.js",
//				"package p31;\n"+
//				"public class XX31 {\n"+
//				"}");
//		
//		this.createFolder("/P3/src/p32");
//		this.createFile(
//				"/P3/src/p32/XX32.js",
//				"package p32;\n"+
//				"public class XX32 {\n"+
//				"}");
//		
//		// create PX
//		this.createJavaProject(
//				"PX",
//				new String[]{"src"},
//				new String[]{"JCL_LIB"},
//				null,
//				null,
//				new String[]{"/P2"},
//				null,
//				null,
//				new boolean[]{false},
//				"bin",
//				null,
//				null,
//				null,
//				"1.4");
//		
//		this.createFile(
//				"/PX/src/X.js",
//				"public class X {\n"+
//				"  void foo() {\n"+
//				"    XX\n"+
//				"  }\n"+
//				"}");
//		
//		waitUntilIndexesReady();
//		
//		// do completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit cu= getCompilationUnit("PX", "src", "", "X.js");
//		
//		String str = cu.getSource();
//		String completeBehind = "XX";
//		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
//		cu.codeComplete(cursorLocation, requestor);
//		
//		assertResults(
//			"XX12[TYPE_REF]{p12.XX12, p12, Lp12.XX12;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
//			"XX21[TYPE_REF]{p21.XX21, p21, Lp21.XX21;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
//			"XX22[TYPE_REF]{p22.XX22, p22, Lp22.XX22;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
//			"XX32[TYPE_REF]{p32.XX32, p32, Lp32.XX32;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}",
//			requestor.getResults());
//	} finally {
//		this.deleteProject("P1");
//		this.deleteProject("P2");
//		this.deleteProject("P3");
//		this.deleteProject("PX");
//		JavaScriptCore.setOptions(oldOptions);
//	}
//}
//public void testAccessRestriction10() throws Exception {
//	Hashtable oldOptions = JavaScriptCore.getOptions();
//	try {
//		Hashtable options = new Hashtable(oldOptions);
//		options.put(JavaScriptCore.COMPILER_PB_FORBIDDEN_REFERENCE, JavaScriptCore.ERROR);
//		options.put(JavaScriptCore.CODEASSIST_FORBIDDEN_REFERENCE_CHECK, JavaScriptCore.DISABLED);
//		options.put(JavaScriptCore.CODEASSIST_DISCOURAGED_REFERENCE_CHECK, JavaScriptCore.DISABLED);
//		JavaScriptCore.setOptions(options);
//		
//		// create variable
////		JavaScriptCore.setClasspathVariables(
////			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
////			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
////			null);
//
//		// create P1
//		this.createJavaProject(
//			"P1",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			 "bin");
//		
//		this.createFolder("/P1/src/p11");
//		this.createFile(
//				"/P1/src/p11/XX11.js",
//				"package p11;\n"+
//				"public class XX11 {\n"+
//				"}");
//		
//		this.createFolder("/P1/src/p12");
//		this.createFile(
//				"/P1/src/p12/XX12.js",
//				"package p12;\n"+
//				"public class XX12 {\n"+
//				"}");
//		
//		// create P2
//		this.createJavaProject(
//			"P2",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P1", "/P3"},
//			new String[][]{{}, {}},
//			new String[][]{{"p11/*"}, {"p31/*"}},
//			new boolean[]{true, true},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		
//		this.createFolder("/P2/src/p21");
//		this.createFile(
//				"/P2/src/p21/XX21.js",
//				"package p21;\n"+
//				"public class XX21 {\n"+
//				"}");
//		
//		this.createFolder("/P2/src/p22");
//		this.createFile(
//				"/P2/src/p22/XX22.js",
//				"package p22;\n"+
//				"public class XX22 {\n"+
//				"}");
//		
//		// create P3
//		this.createJavaProject(
//			"P3",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P1"},
//			new String[][]{{}},
//			new String[][]{{"p12/*"}},
//			new boolean[]{true},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		
//		this.createFolder("/P3/src/p31");
//		this.createFile(
//				"/P3/src/p31/XX31.js",
//				"package p31;\n"+
//				"public class XX31 {\n"+
//				"}");
//		
//		this.createFolder("/P3/src/p32");
//		this.createFile(
//				"/P3/src/p32/XX32.js",
//				"package p32;\n"+
//				"public class XX32 {\n"+
//				"}");
//		
//		// create PX
//		this.createJavaProject(
//				"PX",
//				new String[]{"src"},
//				new String[]{"JCL_LIB"},
//				null,
//				null,
//				new String[]{"/P2"},
//				null,
//				null,
//				new boolean[]{false},
//				"bin",
//				null,
//				null,
//				null,
//				"1.4");
//		
//		this.createFile(
//				"/PX/src/X.js",
//				"public class X {\n"+
//				"  void foo() {\n"+
//				"    XX\n"+
//				"  }\n"+
//				"}");
//		
//		waitUntilIndexesReady();
//		
//		// do completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit cu= getCompilationUnit("PX", "src", "", "X.js");
//		
//		String str = cu.getSource();
//		String completeBehind = "XX";
//		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
//		cu.codeComplete(cursorLocation, requestor);
//		
//		assertResults(
//			"XX11[TYPE_REF]{p11.XX11, p11, Lp11.XX11;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE) + "}\n" +
//			"XX31[TYPE_REF]{p31.XX31, p31, Lp31.XX31;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE) + "}\n" +
//			"XX12[TYPE_REF]{p12.XX12, p12, Lp12.XX12;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
//			"XX21[TYPE_REF]{p21.XX21, p21, Lp21.XX21;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
//			"XX22[TYPE_REF]{p22.XX22, p22, Lp22.XX22;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
//			"XX32[TYPE_REF]{p32.XX32, p32, Lp32.XX32;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}",
//			requestor.getResults());
//	} finally {
//		this.deleteProject("P1");
//		this.deleteProject("P2");
//		this.deleteProject("P3");
//		this.deleteProject("PX");
//		JavaScriptCore.setOptions(oldOptions);
//	}
//}
//public void testAccessRestriction11() throws Exception {
//	Hashtable oldOptions = JavaScriptCore.getOptions();
//	try {
//		Hashtable options = new Hashtable(oldOptions);
//		options.put(JavaScriptCore.COMPILER_PB_FORBIDDEN_REFERENCE, JavaScriptCore.ERROR);
//		options.put(JavaScriptCore.CODEASSIST_FORBIDDEN_REFERENCE_CHECK, JavaScriptCore.ENABLED);
//		options.put(JavaScriptCore.CODEASSIST_DISCOURAGED_REFERENCE_CHECK, JavaScriptCore.DISABLED);
//		JavaScriptCore.setOptions(options);
//		
//		// create variable
////		JavaScriptCore.setClasspathVariables(
////			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
////			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
////			null);
//
//		// create P1
//		this.createJavaProject(
//			"P1",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			 "bin");
//		
//		this.createFolder("/P1/src/x/y/z/p11");
//		this.createFile(
//				"/P1/src/x/y/z/p11/XX11.js",
//				"package x.y.z.p11;\n"+
//				"public class XX11 {\n"+
//				"}");
//		
//		this.createFolder("/P1/src/x/y/z/p12");
//		this.createFile(
//				"/P1/src/x/y/z/p12/XX12.js",
//				"package x.y.z.p12;\n"+
//				"public class XX12 {\n"+
//				"}");
//		
//		// create P2
//		this.createJavaProject(
//			"P2",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P3", "/P1"},
//			new String[][]{{}, {}},
//			new String[][]{{"x/y/z/p31/*"}, {"x/y/z/p11/*"}},
//			new boolean[]{true, true},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		
//		this.createFolder("/P2/src/x/y/z/p21");
//		this.createFile(
//				"/P2/src/x/y/z/p21/XX21.js",
//				"package x.y.z.p21;\n"+
//				"public class XX21 {\n"+
//				"}");
//		
//		this.createFolder("/P2/src/x/y/z/p22");
//		this.createFile(
//				"/P2/src/x/y/z/p22/XX22.js",
//				"package x.y.z.p22;\n"+
//				"public class XX22 {\n"+
//				"}");
//		
//		// create P3
//		this.createJavaProject(
//			"P3",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P1"},
//			new String[][]{{}},
//			new String[][]{{"x/y/z/p12/*"}},
//			new boolean[]{true},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		
//		this.createFolder("/P3/src/x/y/z/p31");
//		this.createFile(
//				"/P3/src/x/y/z/p31/XX31.js",
//				"package x.y.z.p31;\n"+
//				"public class XX31 {\n"+
//				"}");
//		
//		this.createFolder("/P3/src/x/y/z/p32");
//		this.createFile(
//				"/P3/src/x/y/z/p32/XX32.js",
//				"package x.y.z.p32;\n"+
//				"public class XX32 {\n"+
//				"}");
//		
//		// create PX
//		this.createJavaProject(
//				"PX",
//				new String[]{"src"},
//				new String[]{"JCL_LIB"},
//				null,
//				null,
//				new String[]{"/P2"},
//				null,
//				null,
//				new boolean[]{false},
//				"bin",
//				null,
//				null,
//				null,
//				"1.4");
//		
//		this.createFile(
//				"/PX/src/X.js",
//				"public class X {\n"+
//				"  void foo() {\n"+
//				"    XX\n"+
//				"  }\n"+
//				"}");
//		
//		waitUntilIndexesReady();
//		
//		// do completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit cu= getCompilationUnit("PX", "src", "", "X.js");
//		
//		String str = cu.getSource();
//		String completeBehind = "XX";
//		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
//		cu.codeComplete(cursorLocation, requestor);
//		
//		assertResults(
//			"XX11[TYPE_REF]{x.y.z.p11.XX11, x.y.z.p11, Lx.y.z.p11.XX11;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
//			"XX21[TYPE_REF]{x.y.z.p21.XX21, x.y.z.p21, Lx.y.z.p21.XX21;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
//			"XX22[TYPE_REF]{x.y.z.p22.XX22, x.y.z.p22, Lx.y.z.p22.XX22;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
//			"XX32[TYPE_REF]{x.y.z.p32.XX32, x.y.z.p32, Lx.y.z.p32.XX32;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}",
//			requestor.getResults());
//	} finally {
//		this.deleteProject("P1");
//		this.deleteProject("P2");
//		this.deleteProject("P3");
//		this.deleteProject("PX");
//		JavaScriptCore.setOptions(oldOptions);
//	}
//}
//public void testAccessRestriction12() throws Exception {
//	Hashtable oldOptions = JavaScriptCore.getOptions();
//	try {
//		Hashtable options = new Hashtable(oldOptions);
//		options.put(JavaScriptCore.COMPILER_PB_FORBIDDEN_REFERENCE, JavaScriptCore.ERROR);
//		options.put(JavaScriptCore.CODEASSIST_FORBIDDEN_REFERENCE_CHECK, JavaScriptCore.DISABLED);
//		options.put(JavaScriptCore.CODEASSIST_DISCOURAGED_REFERENCE_CHECK, JavaScriptCore.DISABLED);
//		JavaScriptCore.setOptions(options);
//		
//		// create variable
////		JavaScriptCore.setClasspathVariables(
////			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
////			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
////			null);
//
//		// create P1
//		this.createJavaProject(
//			"P1",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			 "bin");
//		
//		this.createFolder("/P1/src/p11");
//		this.createFile(
//				"/P1/src/p11/XX11.js",
//				"package p11;\n"+
//				"public class XX11 {\n"+
//				"}");
//		
//		this.createFolder("/P1/src/p12");
//		this.createFile(
//				"/P1/src/p12/XX12.js",
//				"package p12;\n"+
//				"public class XX12 {\n"+
//				"}");
//		
//		// create P2
//		this.createJavaProject(
//			"P2",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P3", "/P1"},
//			new String[][]{{}, {}},
//			new String[][]{{"p31/*"}, {"p11/*"}},
//			new boolean[]{true, true},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		
//		this.createFolder("/P2/src/p21");
//		this.createFile(
//				"/P2/src/p21/XX21.js",
//				"package p21;\n"+
//				"public class XX21 {\n"+
//				"}");
//		
//		this.createFolder("/P2/src/p22");
//		this.createFile(
//				"/P2/src/p22/XX22.js",
//				"package p22;\n"+
//				"public class XX22 {\n"+
//				"}");
//		
//		// create P3
//		this.createJavaProject(
//			"P3",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P1"},
//			new String[][]{{}},
//			new String[][]{{"p12/*"}},
//			new boolean[]{true},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		
//		this.createFolder("/P3/src/p31");
//		this.createFile(
//				"/P3/src/p31/XX31.js",
//				"package p31;\n"+
//				"public class XX31 {\n"+
//				"}");
//		
//		this.createFolder("/P3/src/p32");
//		this.createFile(
//				"/P3/src/p32/XX32.js",
//				"package p32;\n"+
//				"public class XX32 {\n"+
//				"}");
//		
//		// create PX
//		this.createJavaProject(
//				"PX",
//				new String[]{"src"},
//				new String[]{"JCL_LIB"},
//				null,
//				null,
//				new String[]{"/P2"},
//				null,
//				null,
//				new boolean[]{false},
//				"bin",
//				null,
//				null,
//				null,
//				"1.4");
//		
//		this.createFile(
//				"/PX/src/X.js",
//				"public class X {\n"+
//				"  void foo() {\n"+
//				"    XX\n"+
//				"  }\n"+
//				"}");
//		
//		waitUntilIndexesReady();
//		
//		// do completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit cu= getCompilationUnit("PX", "src", "", "X.js");
//		
//		String str = cu.getSource();
//		String completeBehind = "XX";
//		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
//		cu.codeComplete(cursorLocation, requestor);
//		
//		assertResults(
//			"XX12[TYPE_REF]{p12.XX12, p12, Lp12.XX12;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE) + "}\n" +
//			"XX31[TYPE_REF]{p31.XX31, p31, Lp31.XX31;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE) + "}\n" +
//			"XX11[TYPE_REF]{p11.XX11, p11, Lp11.XX11;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
//			"XX21[TYPE_REF]{p21.XX21, p21, Lp21.XX21;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
//			"XX22[TYPE_REF]{p22.XX22, p22, Lp22.XX22;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
//			"XX32[TYPE_REF]{p32.XX32, p32, Lp32.XX32;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}",
//			requestor.getResults());
//	} finally {
//		this.deleteProject("P1");
//		this.deleteProject("P2");
//		this.deleteProject("P3");
//		this.deleteProject("PX");
//		JavaScriptCore.setOptions(oldOptions);
//	}
//}
//public void testAccessRestriction13() throws Exception {
//	Hashtable oldOptions = JavaScriptCore.getOptions();
//	try {
//		Hashtable options = new Hashtable(oldOptions);
//		options.put(JavaScriptCore.COMPILER_PB_FORBIDDEN_REFERENCE, JavaScriptCore.WARNING);
//		options.put(JavaScriptCore.CODEASSIST_FORBIDDEN_REFERENCE_CHECK, JavaScriptCore.ENABLED);
//		options.put(JavaScriptCore.CODEASSIST_DISCOURAGED_REFERENCE_CHECK, JavaScriptCore.DISABLED);
//		JavaScriptCore.setOptions(options);
//		
//		// create variable
////		JavaScriptCore.setClasspathVariables(
////			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
////			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
////			null);
//
//		// create P1
//		this.createJavaProject(
//			"P1",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			 "bin");
//		
//		this.createFolder("/P1/src/a");
//		this.createFile(
//				"/P1/src/a/XX1.js",
//				"package a;\n"+
//				"public class XX1 {\n"+
//				"}");
//
//		this.createFolder("/P1/src/b");
//		this.createFile(
//				"/P1/src/b/XX2.js",
//				"package b;\n"+
//				"public class XX2 {\n"+
//				"}");
//		
//		// create P2
//		this.createJavaProject(
//			"P2",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P1"},
//			new String[][]{{}},
//			new String[][]{{"a/*"}},
//			new boolean[]{false},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		this.createFile(
//			"/P2/src/YY.js",
//			"public class YY {\n"+
//			"  void foo() {\n"+
//			"    XX\n"+
//			"  }\n"+
//			"}");
//		
//		waitUntilIndexesReady();
//		
//		// do completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit cu= getCompilationUnit("P2", "src", "", "YY.js");
//		
//		String str = cu.getSource();
//		String completeBehind = "XX";
//		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
//		cu.codeComplete(cursorLocation, requestor);
//		
//		assertResults(
//			"XX2[TYPE_REF]{b.XX2, b, Lb.XX2;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}",
//			requestor.getResults());
//	} finally {
//		this.deleteProject("P1");
//		this.deleteProject("P2");
//		JavaScriptCore.setOptions(oldOptions);
//	}
//}
//public void testAccessRestriction14() throws Exception {
//	Hashtable oldOptions = JavaScriptCore.getOptions();
//	try {
//		Hashtable options = new Hashtable(oldOptions);
//		options.put(JavaScriptCore.COMPILER_PB_FORBIDDEN_REFERENCE, JavaScriptCore.WARNING);
//		options.put(JavaScriptCore.CODEASSIST_FORBIDDEN_REFERENCE_CHECK, JavaScriptCore.ENABLED);
//		options.put(JavaScriptCore.CODEASSIST_DISCOURAGED_REFERENCE_CHECK, JavaScriptCore.ENABLED);
//		JavaScriptCore.setOptions(options);
//		
//		// create variable
////		JavaScriptCore.setClasspathVariables(
////			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
////			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
////			null);
//
//		// create P1
//		this.createJavaProject(
//			"P1",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			 "bin");
//		
//		this.createFolder("/P1/src/a");
//		this.createFile(
//				"/P1/src/a/XX1.js",
//				"package a;\n"+
//				"public class XX1 {\n"+
//				"}");
//
//		this.createFolder("/P1/src/b");
//		this.createFile(
//				"/P1/src/b/XX2.js",
//				"package b;\n"+
//				"public class XX2 {\n"+
//				"}");
//		
//		// create P2
//		this.createJavaProject(
//			"P2",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P1"},
//			new String[][]{{}},
//			new String[][]{{"a/*"}},
//			new boolean[]{false},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		this.createFile(
//			"/P2/src/YY.js",
//			"public class YY {\n"+
//			"  void foo() {\n"+
//			"    XX\n"+
//			"  }\n"+
//			"}");
//		
//		waitUntilIndexesReady();
//		
//		// do completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit cu= getCompilationUnit("P2", "src", "", "YY.js");
//		
//		String str = cu.getSource();
//		String completeBehind = "XX";
//		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
//		cu.codeComplete(cursorLocation, requestor);
//		
//		assertResults(
//			"XX2[TYPE_REF]{b.XX2, b, Lb.XX2;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}",
//			requestor.getResults());
//	} finally {
//		this.deleteProject("P1");
//		this.deleteProject("P2");
//		JavaScriptCore.setOptions(oldOptions);
//	}
//}
//public void testAccessRestrictionX() throws Exception {
//	Hashtable oldOptions = JavaScriptCore.getOptions();
//	try {
//		Hashtable options = new Hashtable(oldOptions);
//		options.put(JavaScriptCore.COMPILER_PB_FORBIDDEN_REFERENCE, JavaScriptCore.ERROR);
//		options.put(JavaScriptCore.CODEASSIST_RESTRICTIONS_CHECK, JavaScriptCore.DISABLED);
//		JavaScriptCore.setOptions(options);
//		
//		// create variable
//		JavaScriptCore.setClasspathVariables(
//			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
//			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
//			null);
//
//		// create P1
//		this.createJavaProject(
//			"P1",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			 "bin");
//		
//		this.createFolder("/P1/src/a");
//		this.createFile(
//				"/P1/src/a/XX1.js",
//				"package a;\n"+
//				"public class XX1 {\n"+
//				"  public void foo() {\n"+
//				"  }\n"+
//				"}");
//		
//		// create P2
//		this.createJavaProject(
//			"P2",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P1"},
//			new String[][]{{}},
//			new String[][]{{"a/*"}},
//			new boolean[]{false},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		this.createFile(
//			"/P2/src/YY.js",
//			"public class YY {\n"+
//			"  void foo() {\n"+
//			"    a.XX1 x;\n"+
//			"    x.fo\n"+
//			"  }\n"+
//			"}");
//		
//		waitUntilIndexesReady();
//		
//		// do completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit cu= getCompilationUnit("P2", "src", "", "YY.js");
//		
//		String str = cu.getSource();
//		String completeBehind = "x.fo";
//		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
//		cu.codeComplete(cursorLocation, requestor);
//		
//		assertResults(
//			"foo[FUNCTION_REF]{foo(), La.XX1;, ()V, foo, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_STATIC) + "}",
//			requestor.getResults());
//	} finally {
//		this.deleteProject("P1");
//		this.deleteProject("P2");
//		JavaScriptCore.setOptions(oldOptions);
//	}
//}
//public void testBug96950() throws Exception {
//	try {
//		// create variable
////		JavaScriptCore.setClasspathVariables(
////			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
////			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
////			null);
//
//		// create P1
//		this.createJavaProject(
//			"P1",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			 "bin");
//		this.createFile(
//				"/P1/src/Taratata.js",
//				"public class Taratata {\n"+
//				"}");
//		
//		// create P2
//		this.createJavaProject(
//			"P2",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P1"},
//			new String[][]{{}},
//			new String[][]{{"**/*"}},
//			new boolean[]{false},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		this.createFile(
//				"/P2/src/BreakRules.js",
//				"public class BreakRules {\n"+
//				"	Tara\n"+
//				"}");
//		
//		waitUntilIndexesReady();
//		
//		// do completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit cu= getCompilationUnit("P2", "src", "", "BreakRules.js");
//		
//		String str = cu.getSource();
//		String completeBehind = "Tara";
//		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
//		cu.codeComplete(cursorLocation, requestor);
//		
//		assertResults(
//			"Tara[POTENTIAL_METHOD_DECLARATION]{Tara, LBreakRules;, ()V, Tara, "+(R_DEFAULT + R_INTERESTING + R_NON_RESTRICTED) + "}",
//			requestor.getResults());
//	} finally {
//		this.deleteProject("P1");
//		this.deleteProject("P2");
//	}
//}
/**
 * @bug 162621: [model][delta] Validation errors do not clear after replacing jar file
 * @test Ensures that changing an internal jar and refreshing takes the change into account
 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=162621"
 */
//public void testChangeInternalJar() throws CoreException, IOException {
//	
//	
//	IJavaScriptProject p = this.createJavaProject(
//				"P1",
//				new String[]{"/"},
//				new String[]{},
//				 "");
//	
//	
//	
//	
//	try {
//		// Create jar file with a class with 2 methods doXXX
//		String[] pathAndContents = new String[] {
//			"pack/Util.js",
//			"package pack;\n" + 
//			"public class Util {\n" + 
//			"    public void doit2A(int x, int y) { }\n" + 
//			"    public void doit2B(int x) { }\n" + 
//			"}\n"
//		};
//		addLibrary(jarName, "b162621_src.zip", pathAndContents, JavaScriptCore.VERSION_1_4);
//
//		// Wait a little bit to be sure file system is aware of zip file creation
//		try {
//			Thread.sleep(1000);
//		}
//		catch (InterruptedException ie) {
//			// skip
//		}
//
//		// Create compilation unit in which completion occurs
//		String path = "/Completion/src/test/Test.js";
//		String source = "package test;\n" + 
//			"import pack.*;\n" + 
//			"public class Test {\n" + 
//			"	public void foo() {\n" + 
//			"		Util test = new Util();\n" + 
//			"		test.doit2A(1, 2);\n" + 
//			"	}\n" + 
//			"}\n";
//		createFolder("/Completion/src/test");
//		createFile(path, source);
//
//		// first completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit unit = getCompilationUnit(path);
//		String completeBehind = "test.do";
//		int cursorLocation = source.lastIndexOf(completeBehind) + completeBehind.length();
//		unit.codeComplete(cursorLocation, requestor);
//		assertResults(
//			"doit2A[FUNCTION_REF]{doit2A, Lpack.Util;, (II)V, doit2A, "+(R_DEFAULT + R_CASE + R_INTERESTING + R_NON_RESTRICTED + R_NON_STATIC) + "}\n" +
//			"doit2B[FUNCTION_REF]{doit2B, Lpack.Util;, (I)V, doit2B, "+(R_DEFAULT + R_CASE + R_INTERESTING + R_NON_RESTRICTED + R_NON_STATIC) + "}",
//			requestor.getResults());
//
//		// change class file to add a third doXXX method and refresh
//		String projectLocation = this.currentProject.getProject().getLocation().toOSString();
//		String jarPath = projectLocation + File.separator + jarName;
//		org.eclipse.wst.jsdt.core.tests.util.Util.createJar(new String[] {
//			"pack/Util.js",
//			"package pack;\n" + 
//			"public class Util {\n" + 
//			"    public void doit2A(int x, int y) { }\n" + 
//			"    public void doit2B(int x) { }\n" + 
//			"    public void doit2C(int x) { }\n" + 
//			"}\n"
//		}, jarPath, "1.4");
//		this.currentProject.getProject().refreshLocal(IResource.DEPTH_INFINITE, null);
//
//		try {
//			Thread.sleep(1000);
//		}
//		catch (InterruptedException ie) {
//			// skip
//		}
//
//		// second completion
//		requestor = new CompletionTestsRequestor2();
//		unit.codeComplete(cursorLocation, requestor);
//		assertResults(
//			"doit2A[FUNCTION_REF]{doit2A, Lpack.Util;, (II)V, doit2A, "+(R_DEFAULT + R_CASE + R_INTERESTING + R_NON_RESTRICTED + R_NON_STATIC) + "}\n" +
//			"doit2B[FUNCTION_REF]{doit2B, Lpack.Util;, (I)V, doit2B, "+(R_DEFAULT + R_CASE + R_INTERESTING + R_NON_RESTRICTED + R_NON_STATIC) + "}\n" +
//			"doit2C[FUNCTION_REF]{doit2C, Lpack.Util;, (I)V, doit2C, "+(R_DEFAULT + R_CASE + R_INTERESTING + R_NON_RESTRICTED + R_NON_STATIC) + "}",
//			requestor.getResults());
//	} finally {
//		removeLibraryEntry(this.currentProject, new Path(jarName));
//		deleteFile(new File(jarName));
//	}
//}
}




		// Binding key tests
		BindingKeyTests.class,

		// Working copy tests
//		CreateMembersTests.class,
//		
//		// Java Naming convention tests
//		JavaConventionTests.class,
//	
//		// Project & Root API unit tests
//		JavaProjectTests.class,
//	
//		// Compilation unit tests
//		CompilationUnitTests.class,
//	
//		// Source attachment tests
//		AttachSourceTests.class,
//		
//		// Attached javadoc tests
//		AttachedJavadocTests.class,
//	
//		// Java search tests
//		RunJavaSearchTests.class,
//			
//		// Working copy tests
		WorkingCopyTests.class,

//		HierarchyOnWorkingCopiesTests.class,
//		
//		// test IJavaScriptModel
//		JavaModelTests.class,
//	
//		// tests to check the encoding
//		EncodingTests.class,
//		
//		// test class name with special names like names containing '$'
//		ClassNameTests.class,
//		
		// IBuffer tests
		BufferTests.class,

//		// Name lookup tests
//		NameLookupTests2.class,
//	
//		// Classpath and output location tests
//		ClasspathTests.class,
//	
//		// Delta tests
//		JavaElementDeltaTests.class,
//		ExternalJarDeltaTests.class,
//	
//		// Java element existence tests
//		ExistenceTests.class,
//		
//		// Support for "open on" feature tests
//		ResolveTests.class,
//		ResolveTests_1_5.class,
//		SelectionJavadocModelTests.class,
//
//		// Support for completion tests
		RunCompletionModelTests.class,
//		
//		// Prefix and suffix tests
//		NamingConventionTests.class,
//		
//		// Code correction tests
//		CodeCorrectionTests.class,
//		
//		// Options tests
//		OptionTests.class,
//		
//		// Type hierarchy tests
//		TypeHierarchyTests.class,
//		TypeHierarchyNotificationTests.class,
//		TypeHierarchySerializationTests.class,
//		
//		// Resolve type tests
//		TypeResolveTests.class,
//	
//		// Reconciler tests
//		ReconcilerTests.class,
//		ReconcilerStatementsRecoveryTests.class,
//		
//		// Copy and move operation tests
//		CopyMoveElementsTests.class,
//		CopyMoveResourcesTests.class,
//	
//		// Rename tests
//		RenameTests.class,
//		
//		// Exclusion patterns tests
//		ExclusionPatternsTests.class,
//		
//		// Inclusion patterns tests
//		InclusionPatternsTests.class,
//		
//		// Access restrictions tests
//		AccessRestrictionsTests.class,
//		
//		// Signature tests
//		SignatureTests.class,
//		
//		// Variable initializers and container initializers tests
//		ClasspathInitializerTests.class,
//	
//		// Java Model Factory tests
//		FactoryTests.class,
//				
//		// Java Element persistence tests
//		MementoTests.class,
//		
//		// Java Element sorting tests
//		SortCompilationUnitElementsTests.class,
//	
//		// Package fragment root manipulation tests
//		RootManipulationsTests.class,
//		
//		// Owverflowing cache tests
//		OverflowingCacheTests.class,
//		
//		// Working copy owner tests
//		WorkingCopyOwnerTests.class,
//	
//		// Delete Java element tests
//		DeleteTests.class,
//		
//		// Local element tests
//		LocalElementTests.class,
//		
//		// Get source tests
//		GetSourceTests.class,
//			
//		// Create packages tests
//		CreatePackageTests.class,
//	
//		// Create compilation units tests
//		CreateCompilationUnitTests.class,
//		
//		// Create search participant tests
//		SearchParticipantTests.class,
//		
//		// Class file tests
//		ClassFileTests.class,
//		
		// Java-like extensions tests
		JavaScriptLikeExtensionsTests.class,
		




/*******************************************************************************
 * Copyright (c) 2000, 2008 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.jsdt.core.tests.model;

import java.lang.reflect.*;
import java.util.ArrayList;
import java.util.List;

import org.eclipse.wst.jsdt.core.tests.junit.extension.TestCase;

import junit.framework.Test;
import junit.framework.TestSuite;

public class RunCompletionModelTests extends junit.framework.TestCase {

	protected static final boolean ONLY_JAVADOC = "true".equals(System.getProperty("onlyJavadoc", "false"));

	public final static List COMPLETION_SUITES = new ArrayList();
	static {
		if (!ONLY_JAVADOC) {
			if(false) COMPLETION_SUITES.add(CompletionTests.class);
			COMPLETION_SUITES.add(CompletionTests2.class);
			if(false) COMPLETION_SUITES.add(CompletionContextTests.class);
			if(false) COMPLETION_SUITES.add(CompletionWithMissingTypesTests.class);
			if(false) COMPLETION_SUITES.add(CompletionWithMissingTypesTests2.class);
			if(false) COMPLETION_SUITES.add(SnippetCompletionContextTests.class);
		}
		if(false) COMPLETION_SUITES.add(JavadocTypeCompletionModelTest.class);
		if(false) COMPLETION_SUITES.add(JavadocFieldCompletionModelTest.class);
		if(false) COMPLETION_SUITES.add(JavadocMethodCompletionModelTest.class);
		if(false) COMPLETION_SUITES.add(JavadocPackageCompletionModelTest.class);
		if(false) COMPLETION_SUITES.add(JavadocTextCompletionModelTest.class);
		if(false) COMPLETION_SUITES.add(JavadocBugsCompletionModelTest.class);
		if(false) COMPLETION_SUITES.add(JavadocCompletionContextTests.class);
	}

	public static Class[] getTestClasses() {
//		int size = COMPLETION_SUITES.size();
//		if (!ONLY_JAVADOC) {
//			Class[] testClasses = new Class[size+1];
//			COMPLETION_SUITES.toArray(testClasses);
//			testClasses[size] = CompletionTests2.class;
//			testClasses[size+1] = CompletionWithMissingTypesTests2.class;
//			if(false) testClasses[size+2] = SnippetCompletionTests.class;
//			if(false) testClasses[size+3] = SnippetCompletionTests_1_5.class;
//			return testClasses;
//		}
//		Class[] testClasses = new Class[size];
		return  (Class[])COMPLETION_SUITES.toArray(new Class[COMPLETION_SUITES.size()]);
		//return testClasses;
	}

	public RunCompletionModelTests(String name) {
		super(name);
	}

	public static Test suite() {
		TestSuite ts = new TestSuite(RunCompletionModelTests.class.getName());

		// Store test classes with same "Completion"project
		AbstractJavaModelCompletionTests.COMPLETION_SUITES = new ArrayList(COMPLETION_SUITES);

		// Get all classes
		Class[] allClasses = getTestClasses();

		// Reset forgotten subsets of tests
		TestCase.TESTS_PREFIX = null;
		TestCase.TESTS_NAMES = null;
		TestCase.TESTS_NUMBERS = null;
		TestCase.TESTS_RANGE = null;
		TestCase.RUN_ONLY_ID = null;

		// Add all tests suite of tests
		for (int i = 0, length = allClasses.length; i < length; i++) {
			Class testClass = allClasses[i];

			// call the suite() method and add the resulting suite to the suite
			try {
				Method suiteMethod = testClass.getDeclaredMethod("suite", new Class[0]); //$NON-NLS-1$
				Test suite = (Test) suiteMethod.invoke(null, new Object[0]);
				ts.addTest(suite);
			} catch (IllegalAccessException e) {
				e.printStackTrace();
			} catch (InvocationTargetException e) {
				e.getTargetException().printStackTrace();
			} catch (NoSuchMethodException e) {
				e.printStackTrace();
			}
		}
		return ts;
	}
}

Lines 196-203 Link Here

(-)src/org/eclipse/wst/jsdt/internal/ui/text/java/JavaMethodCompletionProposal.java (-2 / +7 lines)
196	parameterCount= Signature.getParameterCount(fProposal.getSignature()) % 10; // we don't care about insane methods with >9 parameters	196	parameterCount= Signature.getParameterCount(fProposal.getSignature()) % 10; // we don't care about insane methods with >9 parameters
197	} else {	197	} else {
198	char[][] params = this.fProposal.getParamaterNames();	198	char[][] params = this.fProposal.getParamaterNames();
199	parameterList = CharOperation.concatWith(params, ',');	199	if(params != null) {
200	parameterCount = params.length % 10; // we don't care about insane methods with >9 parameters	200	parameterList = CharOperation.concatWith(params, ',');
		201	parameterCount = params.length % 10; // we don't care about insane methods with >9 parameters
		202	} else {
		203	parameterList = new char[0];
		204	parameterCount = 0;
		205	}
201	}	206	}
202		207
203	StringBuffer buf= new StringBuffer(name.length + 2 + parameterList.length);	208	StringBuffer buf= new StringBuffer(name.length + 2 + parameterList.length);




					buffer.append(',');
					buffer.append(' ');
				}
				if (parameterTypes[i] != null && parameterTypes[i].length > 0 &&  !Arrays.equals(Signature.ANY, parameterTypes[i])) {
					buffer.append(parameterTypes[i]);
					buffer.append(' ');
				}


		// return type
		if (!methodProposal.isConstructor()) {
			char[] returnType= methodProposal.getReturnType();
			if (returnType != null && returnType.length > 0 &&  !Arrays.equals(Signature.ANY,returnType)) {
			if (!Arrays.equals(Signature.ANY,returnType))
			{
				nameBuffer.append("  "); //$NON-NLS-1$
				//@GINO: Anonymous UI Label
				org.eclipse.wst.jsdt.internal.core.util.Util.insertTypeLabel( returnType, nameBuffer );

		}

		// declaring type
		nameBuffer.append(" - "); //$NON-NLS-1$
		String declaringType= extractDeclaringTypeFQN(methodProposal);
		if(declaringType != null) {
			nameBuffer.append(" - "); //$NON-NLS-1$
			org.eclipse.wst.jsdt.internal.core.util.Util.insertTypeLabel( declaringType, nameBuffer );
		}

		return nameBuffer.toString();
	}

	private String extractDeclaringTypeFQN(CompletionProposal methodProposal) {
		char[] declaringTypeSignature= methodProposal.getDeclarationSignature();
		char[] compUnit = methodProposal.getDeclarationTypeName();
		if(compUnit != null) {
			IJavaScriptProject project = methodProposal.getJavaProject();
			JsGlobalScopeContainerInitializer init = JSDScopeUtil.findLibraryInitializer(new Path(new String(compUnit)),project);
			if(init!=null) {
				String description = init.getDescription(new Path(new String(compUnit)),project);
				if( description!=null) return  "[" +  description + "]"; //$NON-NLS-1$ //$NON-NLS-2$
			}
		}
		
		String qualifedName = null;
		if(declaringTypeSignature != null ) {
			qualifedName = SignatureUtil.stripSignatureToFQN(String.valueOf(declaringTypeSignature));
		}
		
		return qualifedName;
		// TODO remove when bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=84690 gets fixed
		if (declaringTypeSignature == null)
			return "java.lang.Object"; //$NON-NLS-1$
		return SignatureUtil.stripSignatureToFQN(String.valueOf(declaringTypeSignature));
	}

	/**




		return new ContentAssistTestsSetup(ts);
	}
	
	public void testFindFunctions_OtherFile_BeforeOpen_ExpressionStarted_0() throws Exception {
		String[][] expectedProposals = new String[][] {{"funcOne()", "funcTwo()", "funcThree(paramOne)", "funcFour(paramOne, paramTwo)",
			"funcFive(Number paramOne, String paramTwo)  String", "funcSix(paramOne, String paramTwo)  Number",
			"funcSeven(String paramOne, paramTwo)  Number", "funcEight(paramOne)  String", "funcNine(paramOne)  Number"}};
		runProposalTest("test0_1.js", 0, 1, expectedProposals);
	}
	
	public void testFindFunctions_OtherFile_BeforeOpen_ExpressionStarted_1() throws Exception {
		String[][] expectedProposals = new String[][] {{"funcOne()", "funcTwo()", "funcThree(paramOne)", "funcFour(paramOne, paramTwo)",
			"funcFive(Number paramOne, String paramTwo)  String", "funcSix(paramOne, String paramTwo)  Number",
			"funcSeven(String paramOne, paramTwo)  Number", "funcEight(paramOne)  String", "funcNine(paramOne)  Number"}};
		runProposalTest("test0_1.js", 2, 4, expectedProposals);
	}
	
	public void testFindFunctions_OtherFile_BeforeOpen_ExpressionStarted_2() throws Exception {
		String[][] expectedProposals = new String[][] {{"funcTwo()", "funcThree(paramOne)"}};
		runProposalTest("test0_1.js", 4, 5, expectedProposals);
	}
	
	public void testFindFunctions_ThisFile_EmptyLine() throws Exception {
		String[][] expectedProposals = new String[][] {{"funcOne()", "funcTwo()", "funcThree(paramOne)", "funcFour(paramOne, paramTwo)"}};
		runProposalTest("test0_0.js", 55, 0, expectedProposals);
	}
	
	public void testFindFunctions_ThisFile_ExpressionStarted_0() throws Exception {
		String[][] expectedProposals = new String[][] {{"funcOne()", "funcTwo()", "funcThree(paramOne)", "funcFour(paramOne, paramTwo)",
			"funcFive(Number paramOne, String paramTwo)  String", "funcSix(paramOne, String paramTwo)  Number",
			"funcSeven(String paramOne, paramTwo)  Number"}};
		runProposalTest("test0_0.js", 57, 1, expectedProposals);
	}
	
	public void testFindFunctions_ThisFile_ExpressionStarted_1() throws Exception {
		String[][] expectedProposals = new String[][] {{"funcOne()", "funcTwo()", "funcThree(paramOne)", "funcFour(paramOne, paramTwo)",
			"funcFive(Number paramOne, String paramTwo)  String", "funcSix(paramOne, String paramTwo)  Number",
			"funcSeven(String paramOne, paramTwo)  Number"}};
		runProposalTest("test0_0.js", 59, 4, expectedProposals);
	}
	
	public void testFindFunctions_ThisFile_ExpressionStarted_2() throws Exception {
		String[][] expectedProposals = new String[][] {{"funcTwo()", "funcThree(paramOne)"}};
		runProposalTest("test0_0.js", 61, 5, expectedProposals);
	}
	
	public void testFindFunctions_OtherFile_AftereOpen_ExpressionStarted_0() throws Exception {
		String[][] expectedProposals = new String[][] {{"funcOne()", "funcTwo()", "funcThree(paramOne)", "funcFour(paramOne, paramTwo)",
			"funcFive(Number paramOne, String paramTwo)  String", "funcSix(paramOne, String paramTwo)  Number",
			"funcSeven(String paramOne, paramTwo)  Number", "funcEight(paramOne)  String", "funcNine(paramOne)  Number"}};
		runProposalTest("test0_1.js", 0, 1, expectedProposals);
	}
	
	public void testFindFunctions_OtherFile_AfterOpen_ExpressionStarted_1() throws Exception {
		String[][] expectedProposals = new String[][] {{"funcOne()", "funcTwo()", "funcThree(paramOne)", "funcFour(paramOne, paramTwo)",
			"funcFive(Number paramOne, String paramTwo)  String", "funcSix(paramOne, String paramTwo)  Number",
			"funcSeven(String paramOne, paramTwo)  Number", "funcEight(paramOne)  String", "funcNine(paramOne)  Number"}};
		runProposalTest("test0_1.js", 2, 4, expectedProposals);
	}
	
	public void testFindFunctions_OtherFile_AfterOpen_ExpressionStarted_2() throws Exception {
		String[][] expectedProposals = new String[][] {{"funcTwo()", "funcThree(paramOne)"}};
		runProposalTest("test0_1.js", 4, 5, expectedProposals);
	}
	
	public void testFindAnonymousTypeField_0() throws Exception {

		runProposalTest("test8_1.js", 8, 13, expectedProposals);
	}
	
	public void testFindConstructors_OtherFile_BeforeOpen_ExpressionStarted_0() throws Exception {
		String[][] expectedProposals = new String[][] {{"Awesome(param1, param2)"}};
		runProposalTest("test2_1.js", 0, 6, expectedProposals);
	}
	
	public void testFindConstructors_OtherFile_BeforeOpen_ExpressionStarted_1() throws Exception {
		String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
		runProposalTest("test2_1.js", 2, 6, expectedProposals);
	}
	
	public void testFindConstructors_OtherFile_BeforeOpen_ExpressionStarted_2() throws Exception {
		String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)"}};
		runProposalTest("test2_1.js", 4, 9, expectedProposals);
	}
	
	public void testFindConstructors_OtherFile_BeforeOpen_ExpressionStarted_3() throws Exception {
		String[][] expectedProposals = new String[][] {{"bar.foo.Class3(param1, param2, param3, param4)"}};
		runProposalTest("test2_1.js", 6, 10, expectedProposals);
	}
	
	public void testFindConstructors_OtherFile_BeforeOpen_ExpressionStarted_4() throws Exception {
		String[][] expectedProposals = new String[][] {{"bar.foo.Class3(param1, param2, param3, param4)"}};
		runProposalTest("test2_1.js", 8, 13, expectedProposals);
	}
	
	public void testFindConstructors_OtherFile_BeforeOpen_ExpressionStarted_5() throws Exception {
		String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
		runProposalTest("test2_1.js", 10, 5, expectedProposals);
	}
	
	public void testFindConstructors_OtherFile_BeforeOpen_ExpressionStarted_6() throws Exception {
		String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
		runProposalTest("test2_1.js", 12, 9, expectedProposals);
	}
	
	public void testFindConstructors_ThisFile_JustNew() throws Exception {
		String[][] expectedProposals = new String[][] {{"Awesome(param1, param2)", "bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
		runProposalTest("test2_0.js", 17, 4, expectedProposals);
	}
	
	public void testFindConstructors_ThisFile_ExpressionStarted_0() throws Exception {
		String[][] expectedProposals = new String[][] {{"Awesome(param1, param2)"}};
		runProposalTest("test2_0.js", 19, 6, expectedProposals);
	}
	
	public void testFindConstructors_ThisFile_ExpressionStarted_1() throws Exception {
		String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
		runProposalTest("test2_0.js", 21, 6, expectedProposals);
	}
	
	public void testFindConstructors_ThisFile_ExpressionStarted_2() throws Exception {
		String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)"}};
		runProposalTest("test2_0.js", 23, 9, expectedProposals);
	}
	
	public void testFindConstructors_ThisFile_ExpressionStarted_3() throws Exception {
		String[][] expectedProposals = new String[][] {{"bar.foo.Class3(param1, param2, param3, param4)"}};
		runProposalTest("test2_0.js", 25, 10, expectedProposals);
	}
	
	public void testFindConstructors_ThisFile_ExpressionStarted_4() throws Exception {
		String[][] expectedProposals = new String[][] {{"bar.foo.Class3(param1, param2, param3, param4)"}};
		runProposalTest("test2_0.js", 27, 13, expectedProposals);
	}
	
	public void testFindConstructors_ThisFile_ExpressionStarted_5() throws Exception {
		String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
		runProposalTest("test2_0.js", 29, 5, expectedProposals);
	}
	
	public void testFindConstructors_ThisFile_ExpressionStarted_6() throws Exception {
		String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
		runProposalTest("test2_0.js", 31, 9, expectedProposals);
	}
	
	public void testFindConstructors_OtherFile_AfterOpen_ExpressionStarted_0() throws Exception {
		String[][] expectedProposals = new String[][] {{"Awesome(param1, param2)"}};
		runProposalTest("test2_1.js", 0, 6, expectedProposals);
	}
	
	public void testFindConstructors_OtherFile_AfterOpen_ExpressionStarted_1() throws Exception {
		String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
		runProposalTest("test2_1.js", 2, 6, expectedProposals);
	}
	
	public void testFindConstructors_OtherFile_AfterOpen_ExpressionStarted_2() throws Exception {
		String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)"}};
		runProposalTest("test2_1.js", 4, 9, expectedProposals);
	}
	
	public void testFindConstructors_OtherFile_AfterOpen_ExpressionStarted_3() throws Exception {
		String[][] expectedProposals = new String[][] {{"bar.foo.Class3(param1, param2, param3, param4)"}};
		runProposalTest("test2_1.js", 6, 10, expectedProposals);
	}
	
	public void testFindConstructors_OtherFile_ExpressionStarted_4() throws Exception {
		String[][] expectedProposals = new String[][] {{"bar.foo.Class3(param1, param2, param3, param4)"}};
		runProposalTest("test2_1.js", 8, 13, expectedProposals);
	}
	
	public void testFindConstructors_OtherFile_AfterOpen_ExpressionStarted_5() throws Exception {
		String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
		runProposalTest("test2_1.js", 10, 5, expectedProposals);
	}
	
	public void testFindConstructors_OtherFile_AfterOpen_ExpressionStarted_6() throws Exception {
		String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
		runProposalTest("test2_1.js", 12, 9, expectedProposals);
	}
	
	public void testFindConstructors_OtherFile_BeforeOpen_VarDeclaration_ExpressionStarted_0() throws Exception {
		String[][] expectedProposals = new String[][] {{"MyClass1(a)", "MyClass2()"}};
		runProposalTest("test6.js", 0, 8, expectedProposals);
	}
	
	public void testFindConstructors_ThisFile_VarDeclaration_ExpressionStarted_0() throws Exception {

		runProposalTest("test5.js", 7, 8, expectedProposals);
	}
	
	public void testFindConstructors_OtherFile_AfterOpen_VarDeclaration_ExpressionStarted_0() throws Exception {
		String[][] expectedProposals = new String[][] {{"MyClass1(a)", "MyClass2()"}};
		runProposalTest("test6.js", 0, 8, expectedProposals);
	}

		runProposalTest("test7.js", 10, 11, expectedProposals);
	}
	
	public void testFindConstructors_OtherFile_BeforeOpen_ArrayReferenceDeclaration_ExpressionStarted_0() throws Exception {
		String[][] expectedProposals = new String[][] {{"test.Foo(x, y, z)"}};
		runProposalTest("test9_1.js", 0, 7, expectedProposals);
	}
	
	public void testFindConstructors_ThisFile_ArrayReferenceDeclaration_ExpressionStarted_0() throws Exception {
		String[][] expectedProposals = new String[][] {{"test.Foo(x, y, z)"}};
		runProposalTest("test9_0.js", 7, 7, expectedProposals);
	}
	
	public void testFindConstructors_OtherFile_AfterOpen_ArrayReferenceDeclaration_ExpressionStarted_0() throws Exception {
		String[][] expectedProposals = new String[][] {{"test.Foo(x, y, z)"}};
		runProposalTest("test9_1.js", 0, 7, expectedProposals);
	}
	
	public void testFindFunctionOnType_OtherFile_ExpressionStarted_0() throws Exception {
		String[][] expectedProposals = new String[][] {{"myFunc1(Number param1)", "foo"}};
		runProposalTest("test10_1.js", 1, 4, expectedProposals);
	}
	
	/**
	 * <p>Run a proposal test by opening the given file and invoking content assist for
	 * each expected proposal count at the given line number and line character

Return to bug 352160

Lines 1089-1108 Link Here

(-)src/org/eclipse/wst/jsdt/core/compiler/CharOperation.java (-5 / +6 lines)
1089	int size = length - 1;	1089	int size = length - 1;
1090	int index = length;	1090	int index = length;
1091	while (--index >= 0) {	1091	while (--index >= 0) {
1092	if (array[index].length == 0 && ignoreEmptyElements)	1092	if ((array[index] == null \|\| array[index].length == 0) && ignoreEmptyElements) {
1093	size--;	1093	size--;
1094	else	1094	} else {
1095	size += array[index].length;	1095	size += array[index] != null ? array[index].length : 0;
		1096	}
1096	}	1097	}
1097	if (size <= 0)	1098	if (size <= 0)
1098	return CharOperation.NO_CHAR;	1099	return CharOperation.NO_CHAR;
1099	char[] result = new char[size];	1100	char[] result = new char[size];
1100	index = length;	1101	index = length;
1101	while (--index >= 0) {	1102	while (--index >= 0) {
1102	length = array[index].length;	1103	length = array[index] != null ? array[index].length : 0;
1103	if (length > 0 \|\| (length == 0 && !ignoreEmptyElements)) {	1104	if (length > 0 \|\| (length == 0 && !ignoreEmptyElements)) {
1104	System.arraycopy(	1105	System.arraycopy(
1105	array[index],	1106	array[index] != null ? array[index] : NO_CHAR,
1106	0,	1107	0,
1107	result,	1108	result,
1108	(size -= length),	1109	(size -= length),

Lines 333-339 Link Here

(-)src/org/eclipse/wst/jsdt/internal/codeassist/MissingTypesGuesser.java (-1 / +13 lines)
333		333
334	//do nothing	334	//do nothing
335	}	335	}
336		336
		337	/**
		338	* @see org.eclipse.wst.jsdt.internal.codeassist.ISearchRequestor#acceptFunction(char[], int, char[][], char[][], char[][], char[], char[], char[], char[], int, java.lang.String)
		339	*/
		340	public void acceptFunction(char[] signature, int parameterCount,
		341	char[][] parameterQualifications,
		342	char[][] parameterSimpleNames, char[][] parameterNames,
		343	char[] returnQualification, char[] returnSimpleName,
		344	char[] declaringQualification, char[] declaringSimpleName,
		345	int modifiers, String path) {
		346
		347	//do nothing
		348	}
337	};	349	};
338	nameEnvironment.findExactTypes(missingSimpleName, true, IJavaScriptSearchConstants.TYPE, storage);	350	nameEnvironment.findExactTypes(missingSimpleName, true, IJavaScriptSearchConstants.TYPE, storage);
339	if(results.size() == 0) return null;	351	if(results.size() == 0) return null;

Lines 303-308 Link Here

(-)src/org/eclipse/wst/jsdt/internal/codeassist/SelectionEngine.java (-8 / +14 lines)
303		303
304	// do nothing	304	// do nothing
305	}	305	}
		306
		307	/**
		308	* @see org.eclipse.wst.jsdt.internal.codeassist.ISearchRequestor#acceptFunction(char[], int, char[][], char[][], char[][], char[], char[], char[], char[], int, java.lang.String)
		309	*/
		310	public void acceptFunction(char[] signature, int parameterCount,
		311	char[][] parameterQualifications,
		312	char[][] parameterSimpleNames, char[][] parameterNames,
		313	char[] returnQualification, char[] returnSimpleName,
		314	char[] declaringQualification, char[] declaringSimpleName,
		315	int modifiers, String path) {
		316
		317	//do nothing
		318	}
306		319
307	private void acceptQualifiedTypes() {	320	private void acceptQualifiedTypes() {
308	if(this.acceptedClasses != null){	321	if(this.acceptedClasses != null){
Lines 1287-1301 Link Here
1287	localParser.inferTypes(parsedUnit,this.compilerOptions);	1300	localParser.inferTypes(parsedUnit,this.compilerOptions);
1288	return parsedUnit;	1301	return parsedUnit;
1289	} catch (AbortCompilationUnit e) {	1302	} catch (AbortCompilationUnit e) {
1290	// // at this point, currentCompilationUnitResult may not be sourceUnit, but some other	1303	throw e; // want to abort enclosing request to compile
1291	// // one requested further along to resolve sourceUnit.
1292	// if (unitResult.compilationUnit == sourceUnit) { // only report once
1293	// requestor.acceptResult(unitResult.tagAsAccepted());
1294	// } else {
1295	throw e; // want to abort enclosing request to compile
1296	// }
1297	}	1304	}
1298		1305
1299	}	1306	}
1300
1301	}	1307	}

Lines 203-209 Link Here

(-)src/org/eclipse/wst/jsdt/ui/text/java/CompletionProposalLabelProvider.java (-20 / +20 lines)
203	buffer.append(',');	203	buffer.append(',');
204	buffer.append(' ');	204	buffer.append(' ');
205	}	205	}
206	if (parameterTypes[i].length > 0 & !Arrays.equals(Signature.ANY, parameterTypes[i])) {	206	if (parameterTypes[i] != null && parameterTypes[i].length > 0 && !Arrays.equals(Signature.ANY, parameterTypes[i])) {
207	buffer.append(parameterTypes[i]);	207	buffer.append(parameterTypes[i]);
208	buffer.append(' ');	208	buffer.append(' ');
209	}	209	}
Lines 249-258 Link Here
249		249
250	// return type	250	// return type
251	if (!methodProposal.isConstructor()) {	251	if (!methodProposal.isConstructor()) {
252	// TODO remove SignatureUtil.fix83600 call when bugs are fixed	252	char[] returnType= methodProposal.getReturnType();
253	char[] returnType= createTypeDisplayName(Signature.getReturnType(methodProposal.getSignature()));	253	if (returnType != null && returnType.length > 0 && !Arrays.equals(Signature.ANY,returnType)) {
254	if (!Arrays.equals(Signature.ANY,returnType))
255	{
256	nameBuffer.append(" "); //$NON-NLS-1$	254	nameBuffer.append(" "); //$NON-NLS-1$
257	//@GINO: Anonymous UI Label	255	//@GINO: Anonymous UI Label
258	org.eclipse.wst.jsdt.internal.core.util.Util.insertTypeLabel( returnType, nameBuffer );	256	org.eclipse.wst.jsdt.internal.core.util.Util.insertTypeLabel( returnType, nameBuffer );
Lines 260-270 Link Here
260	}	258	}
261		259
262	// declaring type	260	// declaring type
263	nameBuffer.append(" - "); //$NON-NLS-1$
264	String declaringType= extractDeclaringTypeFQN(methodProposal);	261	String declaringType= extractDeclaringTypeFQN(methodProposal);
265		262	if(declaringType != null) {
266	//@GINO: Anonymous UI Label	263	nameBuffer.append(" - "); //$NON-NLS-1$
267	org.eclipse.wst.jsdt.internal.core.util.Util.insertTypeLabel( declaringType, nameBuffer );	264	org.eclipse.wst.jsdt.internal.core.util.Util.insertTypeLabel( declaringType, nameBuffer );
		265	}
268		266
269	return nameBuffer.toString();	267	return nameBuffer.toString();
270	}	268	}
Lines 338-356 Link Here
338	private String extractDeclaringTypeFQN(CompletionProposal methodProposal) {	336	private String extractDeclaringTypeFQN(CompletionProposal methodProposal) {
339	char[] declaringTypeSignature= methodProposal.getDeclarationSignature();	337	char[] declaringTypeSignature= methodProposal.getDeclarationSignature();
340	char[] compUnit = methodProposal.getDeclarationTypeName();	338	char[] compUnit = methodProposal.getDeclarationTypeName();
341	IJavaScriptProject project = methodProposal.getJavaProject();	339	if(compUnit != null) {
342	JsGlobalScopeContainerInitializer init = JSDScopeUtil.findLibraryInitializer(new Path(new String(compUnit)),project);	340	IJavaScriptProject project = methodProposal.getJavaProject();
343	if(init!=null) {	341	JsGlobalScopeContainerInitializer init = JSDScopeUtil.findLibraryInitializer(new Path(new String(compUnit)),project);
344	String description = init.getDescription(new Path(new String(compUnit)),project);	342	if(init!=null) {
345	if( description!=null) return "[" + description + "]"; //$NON-NLS-1$ //$NON-NLS-2$	343	String description = init.getDescription(new Path(new String(compUnit)),project);
346		344	if( description!=null) return "[" + description + "]"; //$NON-NLS-1$ //$NON-NLS-2$
		345	}
		346	}
		347
		348	String qualifedName = null;
		349	if(declaringTypeSignature != null ) {
		350	qualifedName = SignatureUtil.stripSignatureToFQN(String.valueOf(declaringTypeSignature));
347	}	351	}
348		352
349	// special methods may not have a declaring type: methods defined on arrays etc.	353	return qualifedName;
350	// TODO remove when bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=84690 gets fixed
351	if (declaringTypeSignature == null)
352	return "java.lang.Object"; //$NON-NLS-1$
353	return SignatureUtil.stripSignatureToFQN(String.valueOf(declaringTypeSignature));
354	}	354	}
355		355
356	/**	356	/**

Lines 13-18 Link Here

(-)src/org/eclipse/wst/jsdt/core/CompletionProposal.java (-31 / +36 lines)
13	import org.eclipse.core.runtime.IProgressMonitor;	13	import org.eclipse.core.runtime.IProgressMonitor;
14	import org.eclipse.wst.jsdt.core.compiler.CharOperation;	14	import org.eclipse.wst.jsdt.core.compiler.CharOperation;
15	import org.eclipse.wst.jsdt.internal.codeassist.InternalCompletionProposal;	15	import org.eclipse.wst.jsdt.internal.codeassist.InternalCompletionProposal;
		16	import org.eclipse.wst.jsdt.internal.core.util.QualificationHelpers;
16		17
17	/**	18	/**
18	* Completion proposal.	19	* Completion proposal.
Lines 1402-1438 Link Here
1402	// return this.declarationPackageName;	1403	// return this.declarationPackageName;
1403	// }	1404	// }
1404	//	1405	//
1405	// /**	1406	/**
1406	// * Returns the type name of the relevant	1407	* Returns the type name of the relevant
1407	// * declaration in the context without the package fragment,	1408	* declaration in the context without the package fragment,
1408	// * or <code>null</code> if none.	1409	* or <code>null</code> if none.
1409	// * <p>	1410	* <p>
1410	// * This field is available for the following kinds of	1411	* This field is available for the following kinds of
1411	// * completion proposals:	1412	* completion proposals:
1412	// * <ul>	1413	* <ul>
1413	// * <li><code>ANONYMOUS_CLASS_DECLARATION</code> - the dot-based type name	1414	* <li><code>ANONYMOUS_CLASS_DECLARATION</code> - the dot-based type name
1414	// * of the type that is being subclassed or implemented</li>	1415	* of the type that is being subclassed or implemented</li>
1415	// * <li><code>FIELD_REF</code> - the dot-based type name	1416	* <li><code>FIELD_REF</code> - the dot-based type name
1416	// * of the type that declares the field that is referenced	1417	* of the type that declares the field that is referenced
1417	// * or an anonymous type instantiation ("new X(){}") if it is an anonymous type</li>	1418	* or an anonymous type instantiation ("new X(){}") if it is an anonymous type</li>
1418	// * <li><code>FUNCTION_REF</code> - the dot-based type name	1419	* <li><code>FUNCTION_REF</code> - the dot-based type name
1419	// * of the type that declares the method that is referenced	1420	* of the type that declares the method that is referenced
1420	// * or an anonymous type instantiation ("new X(){}") if it is an anonymous type</li>	1421	* or an anonymous type instantiation ("new X(){}") if it is an anonymous type</li>
1421	// * <li><code>FUNCTION_DECLARATION</code> - the dot-based type name	1422	* <li><code>FUNCTION_DECLARATION</code> - the dot-based type name
1422	// * of the type that declares the method that is being	1423	* of the type that declares the method that is being
1423	// * implemented or overridden</li>	1424	* implemented or overridden</li>
1424	// * </ul>	1425	* </ul>
1425	// * For kinds of completion proposals, this method returns	1426	* For kinds of completion proposals, this method returns
1426	// * <code>null</code>. Clients must not modify the array	1427	* <code>null</code>. Clients must not modify the array
1427	// * returned.	1428	* returned.
1428	// * </p>	1429	* </p>
1429	// *	1430	*
1430	// * @return the dot-based package name, or	1431	* @return the dot-based package name, or
1431	// * <code>null</code> if none	1432	* <code>null</code> if none
1432	// * @see #getDeclarationSignature()	1433	* @see #getDeclarationSignature()
1433	// * @see #getSignature()	1434	* @see #getSignature()
1434	// *	1435	*
1435	// */	1436	*/
1436	public char[] getDeclarationTypeName() {	1437	public char[] getDeclarationTypeName() {
1437	return this.declarationTypeName;	1438	return this.declarationTypeName;
1438	}	1439	}
Lines 1861-1866 Link Here
1861	public char[][] getParameterTypeNames() {	1862	public char[][] getParameterTypeNames() {
1862	return this.parameterTypeNames;	1863	return this.parameterTypeNames;
1863	}	1864	}
		1865
		1866	public char[] getReturnType() {
		1867	return QualificationHelpers.createFullyQualifiedName(this.getReturnQualification(), this.getReturnSimpleName());
		1868	}
1864		1869
1865	/**	1870	/**
1866	* Returns the accessibility of the proposal.	1871	* Returns the accessibility of the proposal.

Lines 981-996 Link Here

(-)src/org/eclipse/wst/jsdt/core/search/SearchPattern.java (-15 / +8 lines)
981	findReferences,	981	findReferences,
982	isFunction,	982	isFunction,
983	selectorChars,	983	selectorChars,
984	declaringTypeQualification,
985	declaringTypeSimpleName,
986	declaringTypeSignature,
987	returnTypeQualification,
988	returnTypeSimpleName,
989	returnTypeSignature,
990	parameterTypeQualifications,	984	parameterTypeQualifications,
991	parameterTypeSimpleNames,	985	parameterTypeSimpleNames,
992	parameterTypeSignatures,	986	returnTypeQualification,
993	typeArguments,	987	returnTypeSimpleName,
		988	declaringTypeQualification,
		989	declaringTypeSimpleName,
994	matchRule);	990	matchRule);
995	}	991	}
996	}	992	}
Lines 1475-1489 Link Here
1475	findMethodReferences,	1471	findMethodReferences,
1476	isFunction,	1472	isFunction,
1477	selector,	1473	selector,
1478	declaringQualification,
1479	declaringSimpleName,
1480	returnQualification,
1481	returnSimpleName,
1482	returnSignature,
1483	parameterQualifications,	1474	parameterQualifications,
1484	parameterSimpleNames,	1475	parameterSimpleNames,
1485	parameterSignatures,	1476	returnQualification,
1486	method,	1477	returnSimpleName,
		1478	declaringQualification,
		1479	declaringSimpleName,
1487	matchRule);	1480	matchRule);
1488	}	1481	}
1489	break;	1482	break;

Lines 64-67 Link Here

(-)src/org/eclipse/wst/jsdt/internal/codeassist/ISearchRequestor.java (+27 lines)
64	char[][] parameterNames,	64	char[][] parameterNames,
65	String path,	65	String path,
66	AccessRestriction access);	66	AccessRestriction access);
		67
		68	/**
		69	* <p>Accept a function defined with all of the given information</p>
		70	*
		71	* @param signature
		72	* @param parameterCount
		73	* @param parameterQualifications
		74	* @param parameterSimpleNames
		75	* @param parameterNames
		76	* @param returnQualification
		77	* @param returnSimpleName
		78	* @param declaringQualification
		79	* @param declaringSimpleName
		80	* @param modifiers
		81	* @param path
		82	*/
		83	public void acceptFunction(char[] signature,
		84	int parameterCount,
		85	char[][] parameterQualifications,
		86	char[][] parameterSimpleNames,
		87	char[][] parameterNames,
		88	char[] returnQualification,
		89	char[] returnSimpleName,
		90	char[] declaringQualification,
		91	char[] declaringSimpleName,
		92	int modifiers,
		93	String path);
67	}	94	}

Lines 41-48 Link Here

(-)src/org/eclipse/wst/jsdt/internal/codeassist/InternalCompletionProposal.java (-10 / +10 lines)
41		41
42	protected char[] declarationPackageName;	42	protected char[] declarationPackageName;
43	protected char[] declarationTypeName;	43	protected char[] declarationTypeName;
44	protected char[] packageName;	44	protected char[] returnQualification;
45	protected char[] typeName;	45	protected char[] returnSimpleName;
46	protected char[][] parameterPackageNames;	46	protected char[][] parameterPackageNames;
47	protected char[][] parameterTypeNames;	47	protected char[][] parameterTypeNames;
48		48
Lines 143-154 Link Here
143	return this.declarationTypeName;	143	return this.declarationTypeName;
144	}	144	}
145		145
146	protected char[] getPackageName() {	146	protected char[] getReturnQualification() {
147	return this.packageName;	147	return this.returnQualification;
148	}	148	}
149		149
150	protected char[] getTypeName() {	150	protected char[] getReturnSimpleName() {
151	return this.typeName;	151	return this.returnSimpleName;
152	}	152	}
153		153
154	protected char[][] getParameterPackageNames() {	154	protected char[][] getParameterPackageNames() {
Lines 168-179 Link Here
168	this.declarationTypeName = declarationTypeName;	168	this.declarationTypeName = declarationTypeName;
169	}	169	}
170		170
171	protected void setPackageName(char[] packageName) {	171	protected void setReturnQualification(char[] packageName) {
172	this.packageName = packageName;	172	this.returnQualification = packageName;
173	}	173	}
174		174
175	protected void setTypeName(char[] typeName) {	175	protected void setReturnSimpleName(char[] typeName) {
176	this.typeName = typeName;	176	this.returnSimpleName = typeName;
177	}	177	}
178		178
179	protected void setParameterPackageNames(char[][] parameterPackageNames) {	179	protected void setParameterPackageNames(char[][] parameterPackageNames) {

Lines 632-656 Link Here

(-)src/org/eclipse/wst/jsdt/internal/compiler/lookup/CompilationUnitScope.java (-21 / +2 lines)
632	}	632	}
633		633
634	void connectTypeHierarchy(char[][] typeNames) {	634	void connectTypeHierarchy(char[][] typeNames) {
635	// if(superType!=null) {
636	// if(superType instanceof SourceTypeBinding) {
637	// ((SourceTypeBinding)superType).classScope.buildFieldsAndMethods();
638	// ((SourceTypeBinding)superType).classScope.connectTypeHierarchy();
639	//
640	// }
641	// ReferenceBinding[] memberTypes = superType.memberTypes();
642	// ReferenceBinding[] memberFields = superType.typeVariables();
643	// FunctionBinding[] memberMethods = superType.availableMethods();
644	// for(int i=0;i<memberTypes.length;i++) {
645	// recordReference(memberTypes[i], memberTypes[i].sourceName);
646	// }
647	// }
648
649	// if(superTypeName!=null) {
650	// ReferenceBinding binding = environment.askForType(new char[][]
651	// {superTypeName});
652	// this.recordSuperTypeReference(binding);
653	// }
654	if (classScope != null)	635	if (classScope != null)
655	classScope.connectTypeHierarchy();	636	classScope.connectTypeHierarchy();
656	nextType: for (int i = 0; i < referenceContext.numberInferredTypes; i++) {	637	nextType: for (int i = 0; i < referenceContext.numberInferredTypes; i++) {
Lines 667-675 Link Here
667	continue nextType;	648	continue nextType;
668		649
669	}	650	}
670	if (inferredType.binding != null)	651	if (inferredType.binding != null && inferredType.binding.classScope != null) {
671	inferredType.binding.classScope.connectTypeHierarchy();	652	inferredType.binding.classScope.connectTypeHierarchy();
672		653	}
673	}	654	}
674	}	655	}
675	void connectTypeHierarchy() {	656	void connectTypeHierarchy() {

Added Link Here

(-)src/org/eclipse/wst/jsdt/internal/core/search/IFunctionRequester.java (+45 lines)
1	/*******************************************************************************
2	* Copyright (c) 2011 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.wst.jsdt.internal.core.search;
12
13	/**
14	* <p>Requester to use when requesting function matches.</p>
15	*/
16	public interface IFunctionRequester {
17
18	/**
19	* <p>Accept a function defined with all of the given information.</p>
20	*
21	* @param signature
22	* @param parameterCount
23	* @param parameterQualifications
24	* @param parameterSimpleNames
25	* @param parameterNames
26	* @param returnQualification
27	* @param returnSimpleName
28	* @param declaringQualification
29	* @param declaringSimpleName
30	* @param modifiers
31	* @param path
32	*/
33	public void acceptFunction(
34	char[] signature,
35	int parameterCount,
36	char[][] parameterQualifications,
37	char[][] parameterSimpleNames,
38	char[][] parameterNames,
39	char[] returnQualification,
40	char[] returnSimpleName,
41	char[] declaringQualification,
42	char[] declaringSimpleName,
43	int modifiers,
44	String path);
45	}

Lines 14-56 Link Here

(-)src/org/eclipse/wst/jsdt/internal/core/search/indexing/IIndexConstants.java (-32 / +33 lines)
14	public interface IIndexConstants {	14	public interface IIndexConstants {
15		15
16	/* index encoding */	16	/* index encoding */
17	char[] REF= "ref".toCharArray(); //$NON-NLS-1$	17	final char[] REF= "ref".toCharArray(); //$NON-NLS-1$
18	char[] METHOD_REF= "methodRef".toCharArray(); //$NON-NLS-1$	18	final char[] METHOD_REF= "methodRef".toCharArray(); //$NON-NLS-1$
19	char[] CONSTRUCTOR_REF= "constructorRef".toCharArray(); //$NON-NLS-1$	19	final char[] CONSTRUCTOR_REF= "constructorRef".toCharArray(); //$NON-NLS-1$
20	char[] SUPER_REF = "superRef".toCharArray(); //$NON-NLS-1$	20	final char[] SUPER_REF = "superRef".toCharArray(); //$NON-NLS-1$
21	char[] TYPE_DECL = "typeDecl".toCharArray(); //$NON-NLS-1$	21	final char[] TYPE_DECL = "typeDecl".toCharArray(); //$NON-NLS-1$
22	char[] METHOD_DECL= "methodDecl".toCharArray(); //$NON-NLS-1$	22	final char[] METHOD_DECL= "methodDecl".toCharArray(); //$NON-NLS-1$
23	char[] FUNCTION_DECL= "functionDecl".toCharArray(); //$NON-NLS-1$	23	final char[] FUNCTION_DECL= "functionDecl".toCharArray(); //$NON-NLS-1$
24	char[] CONSTRUCTOR_DECL= "constructorDecl".toCharArray(); //$NON-NLS-1$	24	final char[] CONSTRUCTOR_DECL= "constructorDecl".toCharArray(); //$NON-NLS-1$
25	char[] FIELD_DECL= "fieldDecl".toCharArray(); //$NON-NLS-1$	25	final char[] FIELD_DECL= "fieldDecl".toCharArray(); //$NON-NLS-1$
26	char[] VAR_DECL= "varDecl".toCharArray(); //$NON-NLS-1$	26	final char[] VAR_DECL= "varDecl".toCharArray(); //$NON-NLS-1$
27	char[] OBJECT = "Object".toCharArray(); //$NON-NLS-1$	27	final char[] OBJECT = "Object".toCharArray(); //$NON-NLS-1$
28	char[][] COUNTS=	28	final char[][] COUNTS=
29	new char[][] { new char[] {'/', '0'}, new char[] {'/', '1'}, new char[] {'/', '2'}, new char[] {'/', '3'}, new char[] {'/', '4'},	29	new char[][] { new char[] {'/', '0'}, new char[] {'/', '1'}, new char[] {'/', '2'}, new char[] {'/', '3'}, new char[] {'/', '4'},
30	new char[] {'/', '5'}, new char[] {'/', '6'}, new char[] {'/', '7'}, new char[] {'/', '8'}, new char[] {'/', '9'}	30	new char[] {'/', '5'}, new char[] {'/', '6'}, new char[] {'/', '7'}, new char[] {'/', '8'}, new char[] {'/', '9'}
31	};	31	};
32	char CLASS_SUFFIX = 'C';	32	final char CLASS_SUFFIX = 'C';
33	char TYPE_SUFFIX = 0;	33	final char TYPE_SUFFIX = 0;
34	char SEPARATOR= '/';	34	final char SEPARATOR= '/';
35	char PARAMETER_SEPARATOR= ',';	35	final char PARAMETER_SEPARATOR= ',';
36	char SECONDARY_SUFFIX = 'S';	36	final char SECONDARY_SUFFIX = 'S';
		37	final char DOT = '.';
37		38
38	char[] ONE_STAR = new char[] {'*'};	39	final char[] ONE_STAR = new char[] {'*'};
39	char[][] ONE_STAR_CHAR = new char[][] {ONE_STAR};	40	final char[][] ONE_STAR_CHAR = new char[][] {ONE_STAR};
40		41
41	// used as special marker for enclosing type name of local and anonymous classes	42	// used as special marker for enclosing type name of local and anonymous classes
42	char ZERO_CHAR = '0';	43	final char ZERO_CHAR = '0';
43	char[] ONE_ZERO = new char[] { ZERO_CHAR };	44	final char[] ONE_ZERO = new char[] { ZERO_CHAR };
44	char[][] ONE_ZERO_CHAR = new char[][] {ONE_ZERO};	45	final char[][] ONE_ZERO_CHAR = new char[][] {ONE_ZERO};
45		46
46	int PKG_REF_PATTERN = 0x0001;	47	final int PKG_REF_PATTERN = 0x0001;
47	int PKG_DECL_PATTERN = 0x0002;	48	final int PKG_DECL_PATTERN = 0x0002;
48	int TYPE_REF_PATTERN = 0x0004;	49	final int TYPE_REF_PATTERN = 0x0004;
49	int TYPE_DECL_PATTERN = 0x0008;	50	final int TYPE_DECL_PATTERN = 0x0008;
50	int SUPER_REF_PATTERN = 0x0010;	51	final int SUPER_REF_PATTERN = 0x0010;
51	int CONSTRUCTOR_PATTERN = 0x0020;	52	final int CONSTRUCTOR_PATTERN = 0x0020;
52	int FIELD_PATTERN = 0x0040;	53	final int FIELD_PATTERN = 0x0040;
53	int METHOD_PATTERN = 0x0080;	54	final int METHOD_PATTERN = 0x0080;
54	int OR_PATTERN = 0x0100;	55	final int OR_PATTERN = 0x0100;
55	int LOCAL_VAR_PATTERN = 0x0200;	56	final int LOCAL_VAR_PATTERN = 0x0200;
56	}	57	}

Lines 26-31 Link Here

(-)src/org/eclipse/wst/jsdt/core/tests/compiler/JSDTCompilerTests.java (-76 / +3 lines)
26	import org.eclipse.wst.jsdt.core.tests.compiler.regression.UtilTest;	26	import org.eclipse.wst.jsdt.core.tests.compiler.regression.UtilTest;
27	import org.eclipse.wst.jsdt.core.tests.compiler.util.ExclusionTests;	27	import org.eclipse.wst.jsdt.core.tests.compiler.util.ExclusionTests;
28	import org.eclipse.wst.jsdt.core.tests.interpret.BasicInterpretTest;	28	import org.eclipse.wst.jsdt.core.tests.interpret.BasicInterpretTest;
		29	import org.eclipse.wst.jsdt.core.tests.search.SearchTests;
29		30
30	/**	31	/**
31	* Run all compiler regression tests	32	* Run all compiler regression tests
Lines 61-150 Link Here
61	// interpret tests	62	// interpret tests
62	standardTests.add(BasicInterpretTest.class);	63	standardTests.add(BasicInterpretTest.class);
63		64
64
65
66
67	// standardTests.addAll(JavadocTest.allTestClasses);
68		65
69	// standardTests.add(BasicErrorTests.class);
70
71	// // add all javadoc tests
72	// for (int i=0, l=JavadocTest.ALL_CLASSES.size(); i<l; i++) {
73	// standardTests.add(JavadocTest.ALL_CLASSES.get(i));
74	// }
75	//
76	TestSuite all = new TestSuite("JSDT 'Compiler' Tests");	66	TestSuite all = new TestSuite("JSDT 'Compiler' Tests");
77	all.addTest(ExclusionTests.suite());	67	all.addTest(ExclusionTests.suite());
78		68
79
80	// int possibleComplianceLevels = AbstractCompilerTest.getPossibleComplianceLevels();
81	// if ((possibleComplianceLevels & AbstractCompilerTest.F_1_3) != 0) {
82	// ArrayList tests_1_3 = (ArrayList)standardTests.clone();
83	// tests_1_3.add(Compliance_1_3.class);
84	// tests_1_3.add(JavadocTest_1_3.class);
85	// // Reset forgotten subsets tests
86	// TestCase.TESTS_PREFIX = null;
87	// TestCase.TESTS_NAMES = null;
88	// TestCase.TESTS_NUMBERS= null;
89	// TestCase.TESTS_RANGE = null;
90	// TestCase.RUN_ONLY_ID = null;
91	// all.addTest(AbstractCompilerTest.buildComplianceTestSuite(AbstractCompilerTest.COMPLIANCE_1_3, tests_1_3));
92	// }
93	// if ((possibleComplianceLevels & AbstractCompilerTest.F_1_4) != 0) {
94	// ArrayList tests_1_4 = (ArrayList)standardTests.clone();
95	// tests_1_4.add(AssertionTest.class);
96	// tests_1_4.add(Compliance_1_4.class);
97	// tests_1_4.add(ClassFileReaderTest_1_4.class);
98	// tests_1_4.add(JavadocTest_1_4.class);
99	// // Reset forgotten subsets tests
100	// TestCase.TESTS_PREFIX = null;
101	// TestCase.TESTS_NAMES = null;
102	// TestCase.TESTS_NUMBERS= null;
103	// TestCase.TESTS_RANGE = null;
104	// TestCase.RUN_ONLY_ID = null;
105	// all.addTest(AbstractCompilerTest.buildComplianceTestSuite(AbstractCompilerTest.COMPLIANCE_1_4, tests_1_4));
106	// }
107	// if ((possibleComplianceLevels & AbstractCompilerTest.F_1_5) != 0) {
108	// ArrayList tests_1_5 = (ArrayList)standardTests.clone();
109	// tests_1_5.addAll(RunComparableTests.ALL_CLASSES);
110	// tests_1_5.add(AssertionTest.class);
111	// tests_1_5.add(ClassFileReaderTest_1_5.class);
112	// tests_1_5.add(GenericTypeSignatureTest.class);
113	// tests_1_5.add(InternalHexFloatTest.class);
114	// tests_1_5.add(JavadocTest_1_5.class);
115	// tests_1_5.add(BatchCompilerTest.class);
116	// tests_1_5.add(ExternalizeStringLiterals15Test.class);
117	// // Reset forgotten subsets tests
118	// TestCase.TESTS_PREFIX = null;
119	// TestCase.TESTS_NAMES = null;
120	// TestCase.TESTS_NUMBERS= null;
121	// TestCase.TESTS_RANGE = null;
122	// TestCase.RUN_ONLY_ID = null;
123	// all.addTest(AbstractCompilerTest.buildComplianceTestSuite(AbstractCompilerTest.COMPLIANCE_1_5, tests_1_5));
124	// }
125	// if ((possibleComplianceLevels & AbstractCompilerTest.F_1_6) != 0) {
126	// ArrayList tests_1_6 = (ArrayList)standardTests.clone();
127	// tests_1_6.addAll(RunComparableTests.ALL_CLASSES);
128	// tests_1_6.add(AssertionTest.class);
129	// tests_1_6.add(ClassFileReaderTest_1_5.class);
130	// tests_1_6.add(GenericTypeSignatureTest.class);
131	// tests_1_6.add(InternalHexFloatTest.class);
132	// tests_1_6.add(JavadocTest_1_5.class);
133	// tests_1_6.add(BatchCompilerTest.class);
134	// tests_1_6.add(ExternalizeStringLiterals15Test.class);
135	// tests_1_6.add(StackMapAttributeTest.class);
136	// // Reset forgotten subsets tests
137	// TestCase.TESTS_PREFIX = null;
138	// TestCase.TESTS_NAMES = null;
139	// TestCase.TESTS_NUMBERS= null;
140	// TestCase.TESTS_RANGE = null;
141	// TestCase.RUN_ONLY_ID = null;
142	// all.addTest(AbstractCompilerTest.buildComplianceTestSuite(AbstractCompilerTest.COMPLIANCE_1_6, tests_1_6));
143	// }
144	for (Iterator iter = standardTests.iterator(); iter.hasNext();) {	69	for (Iterator iter = standardTests.iterator(); iter.hasNext();) {
145	Class test = (Class) iter.next();	70	Class test = (Class) iter.next();
146	all.addTestSuite(test);	71	all.addTestSuite(test);
147	}	72	}
		73
		74	all.addTest(SearchTests.suite());
148	return all;	75	return all;
149	}	76	}
150	}	77	}

Added Link Here

(-)src/org/eclipse/wst/jsdt/core/tests/search/SearchTests.java (+43 lines)
1	/*******************************************************************************
2	* Copyright (c) 2011 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.wst.jsdt.core.tests.search;
12
13	import junit.framework.Test;
14	import junit.framework.TestSuite;
15
16	/**
17	* <p>Test suite for all JSDT Search Tests.<p>
18	*/
19	public class SearchTests extends TestSuite {
20	/**
21	* <p>Default constructor</p>
22	*/
23	public SearchTests() {
24	this("JavaScript Search Tests");
25	}
26
27	/**
28	* <p>Constructor with specified test name.</p>
29	*
30	* @param testName of this test suite
31	*/
32	public SearchTests(String testName) {
33	super(testName);
34	}
35
36	public static Test suite() {
37	TestSuite all = new TestSuite("JavaScript Search Tests");
38
39	all.addTestSuite(TestMethodPattern.class);
40
41	return all;
42	}
43	}

Lines 47-193 Link Here

(-)src/org/eclipse/wst/jsdt/core/tests/model/JSDTModelTests.java (-138 / +3 lines)
47	// Binding key tests	47	// Binding key tests
48	BindingKeyTests.class,	48	BindingKeyTests.class,
49		49
50	// // creation of method	50	// Working copy tests
51	// CreateMembersTests.class,
52	//
53	// // Java Naming convention tests
54	// JavaConventionTests.class,
55	//
56	// // Project & Root API unit tests
57	// JavaProjectTests.class,
58	//
59	// // Compilation unit tests
60	// CompilationUnitTests.class,
61	//
62	// // Source attachment tests
63	// AttachSourceTests.class,
64	//
65	// // Attached javadoc tests
66	// AttachedJavadocTests.class,
67	//
68	// // Java search tests
69	// RunJavaSearchTests.class,
70	//
71	// // Working copy tests
72	WorkingCopyTests.class,	51	WorkingCopyTests.class,
73	// WorkingCopyNotInClasspathTests.class,	52
74	// HierarchyOnWorkingCopiesTests.class,
75	//
76	// // test IJavaScriptModel
77	// JavaModelTests.class,
78	//
79	// // tests to check the encoding
80	// EncodingTests.class,
81	//
82	// // test class name with special names like names containing '$'
83	// ClassNameTests.class,
84	//
85	// IBuffer tests	53	// IBuffer tests
86	BufferTests.class,	54	BufferTests.class,
87	//	55
88	// // Name lookup tests
89	// NameLookupTests2.class,
90	//
91	// // Classpath and output location tests
92	// ClasspathTests.class,
93	//
94	// // Delta tests
95	// JavaElementDeltaTests.class,
96	// ExternalJarDeltaTests.class,
97	//
98	// // Java element existence tests
99	// ExistenceTests.class,
100	//
101	// // Support for "open on" feature tests
102	// ResolveTests.class,
103	// ResolveTests_1_5.class,
104	// SelectionJavadocModelTests.class,
105	//
106	// // Support for completion tests
107	RunCompletionModelTests.class,
108	//
109	// // Prefix and suffix tests
110	// NamingConventionTests.class,
111	//
112	// // Code correction tests
113	// CodeCorrectionTests.class,
114	//
115	// // Options tests
116	// OptionTests.class,
117	//
118	// // Type hierarchy tests
119	// TypeHierarchyTests.class,
120	// TypeHierarchyNotificationTests.class,
121	// TypeHierarchySerializationTests.class,
122	//
123	// // Resolve type tests
124	// TypeResolveTests.class,
125	//
126	// // Reconciler tests
127	// ReconcilerTests.class,
128	// ReconcilerStatementsRecoveryTests.class,
129	//
130	// // Copy and move operation tests
131	// CopyMoveElementsTests.class,
132	// CopyMoveResourcesTests.class,
133	//
134	// // Rename tests
135	// RenameTests.class,
136	//
137	// // Exclusion patterns tests
138	// ExclusionPatternsTests.class,
139	//
140	// // Inclusion patterns tests
141	// InclusionPatternsTests.class,
142	//
143	// // Access restrictions tests
144	// AccessRestrictionsTests.class,
145	//
146	// // Signature tests
147	// SignatureTests.class,
148	//
149	// // Variable initializers and container initializers tests
150	// ClasspathInitializerTests.class,
151	//
152	// // Java Model Factory tests
153	// FactoryTests.class,
154	//
155	// // Java Element persistence tests
156	// MementoTests.class,
157	//
158	// // Java Element sorting tests
159	// SortCompilationUnitElementsTests.class,
160	//
161	// // Package fragment root manipulation tests
162	// RootManipulationsTests.class,
163	//
164	// // Owverflowing cache tests
165	// OverflowingCacheTests.class,
166	//
167	// // Working copy owner tests
168	// WorkingCopyOwnerTests.class,
169	//
170	// // Delete Java element tests
171	// DeleteTests.class,
172	//
173	// // Local element tests
174	// LocalElementTests.class,
175	//
176	// // Get source tests
177	// GetSourceTests.class,
178	//
179	// // Create packages tests
180	// CreatePackageTests.class,
181	//
182	// // Create compilation units tests
183	// CreateCompilationUnitTests.class,
184	//
185	// // Create search participant tests
186	// SearchParticipantTests.class,
187	//
188	// // Class file tests
189	// ClassFileTests.class,
190	//
191	// Java-like extensions tests	56	// Java-like extensions tests
192	JavaScriptLikeExtensionsTests.class,	57	JavaScriptLikeExtensionsTests.class,
193		58

Removed Link Here

(-)src/org/eclipse/wst/jsdt/core/tests/model/RunCompletionModelTests.java (-100 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.wst.jsdt.core.tests.model;
12
13	import java.lang.reflect.*;
14	import java.util.ArrayList;
15	import java.util.List;
16
17	import org.eclipse.wst.jsdt.core.tests.junit.extension.TestCase;
18
19	import junit.framework.Test;
20	import junit.framework.TestSuite;
21
22	public class RunCompletionModelTests extends junit.framework.TestCase {
23
24	protected static final boolean ONLY_JAVADOC = "true".equals(System.getProperty("onlyJavadoc", "false"));
25
26	public final static List COMPLETION_SUITES = new ArrayList();
27	static {
28	if (!ONLY_JAVADOC) {
29	if(false) COMPLETION_SUITES.add(CompletionTests.class);
30	COMPLETION_SUITES.add(CompletionTests2.class);
31	if(false) COMPLETION_SUITES.add(CompletionContextTests.class);
32	if(false) COMPLETION_SUITES.add(CompletionWithMissingTypesTests.class);
33	if(false) COMPLETION_SUITES.add(CompletionWithMissingTypesTests2.class);
34	if(false) COMPLETION_SUITES.add(SnippetCompletionContextTests.class);
35	}
36	if(false) COMPLETION_SUITES.add(JavadocTypeCompletionModelTest.class);
37	if(false) COMPLETION_SUITES.add(JavadocFieldCompletionModelTest.class);
38	if(false) COMPLETION_SUITES.add(JavadocMethodCompletionModelTest.class);
39	if(false) COMPLETION_SUITES.add(JavadocPackageCompletionModelTest.class);
40	if(false) COMPLETION_SUITES.add(JavadocTextCompletionModelTest.class);
41	if(false) COMPLETION_SUITES.add(JavadocBugsCompletionModelTest.class);
42	if(false) COMPLETION_SUITES.add(JavadocCompletionContextTests.class);
43	}
44
45	public static Class[] getTestClasses() {
46	// int size = COMPLETION_SUITES.size();
47	// if (!ONLY_JAVADOC) {
48	// Class[] testClasses = new Class[size+1];
49	// COMPLETION_SUITES.toArray(testClasses);
50	// testClasses[size] = CompletionTests2.class;
51	// testClasses[size+1] = CompletionWithMissingTypesTests2.class;
52	// if(false) testClasses[size+2] = SnippetCompletionTests.class;
53	// if(false) testClasses[size+3] = SnippetCompletionTests_1_5.class;
54	// return testClasses;
55	// }
56	// Class[] testClasses = new Class[size];
57	return (Class[])COMPLETION_SUITES.toArray(new Class[COMPLETION_SUITES.size()]);
58	//return testClasses;
59	}
60
61	public RunCompletionModelTests(String name) {
62	super(name);
63	}
64
65	public static Test suite() {
66	TestSuite ts = new TestSuite(RunCompletionModelTests.class.getName());
67
68	// Store test classes with same "Completion"project
69	AbstractJavaModelCompletionTests.COMPLETION_SUITES = new ArrayList(COMPLETION_SUITES);
70
71	// Get all classes
72	Class[] allClasses = getTestClasses();
73
74	// Reset forgotten subsets of tests
75	TestCase.TESTS_PREFIX = null;
76	TestCase.TESTS_NAMES = null;
77	TestCase.TESTS_NUMBERS = null;
78	TestCase.TESTS_RANGE = null;
79	TestCase.RUN_ONLY_ID = null;
80
81	// Add all tests suite of tests
82	for (int i = 0, length = allClasses.length; i < length; i++) {
83	Class testClass = allClasses[i];
84
85	// call the suite() method and add the resulting suite to the suite
86	try {
87	Method suiteMethod = testClass.getDeclaredMethod("suite", new Class[0]); //$NON-NLS-1$
88	Test suite = (Test) suiteMethod.invoke(null, new Object[0]);
89	ts.addTest(suite);
90	} catch (IllegalAccessException e) {
91	e.printStackTrace();
92	} catch (InvocationTargetException e) {
93	e.getTargetException().printStackTrace();
94	} catch (NoSuchMethodException e) {
95	e.printStackTrace();
96	}
97	}
98	return ts;
99	}
100	}

Lines 103-131 Link Here

(-)src/org/eclipse/wst/jsdt/ui/tests/contentassist/ContentAssistTests.java (-32 / +119 lines)
103	return new ContentAssistTestsSetup(ts);	103	return new ContentAssistTestsSetup(ts);
104	}	104	}
105		105
		106	public void testFindFunctions_OtherFile_BeforeOpen_ExpressionStarted_0() throws Exception {
		107	String[][] expectedProposals = new String[][] {{"funcOne()", "funcTwo()", "funcThree(paramOne)", "funcFour(paramOne, paramTwo)",
		108	"funcFive(Number paramOne, String paramTwo) String", "funcSix(paramOne, String paramTwo) Number",
		109	"funcSeven(String paramOne, paramTwo) Number", "funcEight(paramOne) String", "funcNine(paramOne) Number"}};
		110	runProposalTest("test0_1.js", 0, 1, expectedProposals);
		111	}
		112
		113	public void testFindFunctions_OtherFile_BeforeOpen_ExpressionStarted_1() throws Exception {
		114	String[][] expectedProposals = new String[][] {{"funcOne()", "funcTwo()", "funcThree(paramOne)", "funcFour(paramOne, paramTwo)",
		115	"funcFive(Number paramOne, String paramTwo) String", "funcSix(paramOne, String paramTwo) Number",
		116	"funcSeven(String paramOne, paramTwo) Number", "funcEight(paramOne) String", "funcNine(paramOne) Number"}};
		117	runProposalTest("test0_1.js", 2, 4, expectedProposals);
		118	}
		119
		120	public void testFindFunctions_OtherFile_BeforeOpen_ExpressionStarted_2() throws Exception {
		121	String[][] expectedProposals = new String[][] {{"funcTwo()", "funcThree(paramOne)"}};
		122	runProposalTest("test0_1.js", 4, 5, expectedProposals);
		123	}
		124
106	public void testFindFunctions_ThisFile_EmptyLine() throws Exception {	125	public void testFindFunctions_ThisFile_EmptyLine() throws Exception {
107	String[][] expectedProposals = new String[][] {{"funcOne()", "funcTwo()", "funcThree(paramOne)", "funcFour(paramOne, paramTwo)"}};	126	String[][] expectedProposals = new String[][] {{"funcOne()", "funcTwo()", "funcThree(paramOne)", "funcFour(paramOne, paramTwo)"}};
108	runProposalTest("test1.js", 16, 0, expectedProposals);	127	runProposalTest("test0_0.js", 55, 0, expectedProposals);
109	}	128	}
110		129
111	public void testFindFunctions_ThisFile_ExpressionStarted_0() throws Exception {	130	public void testFindFunctions_ThisFile_ExpressionStarted_0() throws Exception {
112	String[][] expectedProposals = new String[][] {{"funcOne()", "funcTwo()", "funcThree(paramOne)", "funcFour(paramOne, paramTwo)"}};	131	String[][] expectedProposals = new String[][] {{"funcOne()", "funcTwo()", "funcThree(paramOne)", "funcFour(paramOne, paramTwo)",
113	runProposalTest("test1.js", 18, 3, expectedProposals);	132	"funcFive(Number paramOne, String paramTwo) String", "funcSix(paramOne, String paramTwo) Number",
		133	"funcSeven(String paramOne, paramTwo) Number"}};
		134	runProposalTest("test0_0.js", 57, 1, expectedProposals);
114	}	135	}
115		136
116	public void testFindFunctions_ThisFile_ExpressionStarted_1() throws Exception {	137	public void testFindFunctions_ThisFile_ExpressionStarted_1() throws Exception {
		138	String[][] expectedProposals = new String[][] {{"funcOne()", "funcTwo()", "funcThree(paramOne)", "funcFour(paramOne, paramTwo)",
		139	"funcFive(Number paramOne, String paramTwo) String", "funcSix(paramOne, String paramTwo) Number",
		140	"funcSeven(String paramOne, paramTwo) Number"}};
		141	runProposalTest("test0_0.js", 59, 4, expectedProposals);
		142	}
		143
		144	public void testFindFunctions_ThisFile_ExpressionStarted_2() throws Exception {
117	String[][] expectedProposals = new String[][] {{"funcTwo()", "funcThree(paramOne)"}};	145	String[][] expectedProposals = new String[][] {{"funcTwo()", "funcThree(paramOne)"}};
118	runProposalTest("test1.js", 20, 5, expectedProposals);	146	runProposalTest("test0_0.js", 61, 5, expectedProposals);
119	}	147	}
120		148
121	public void testFindFunctions_OtherFile_ExpressionStarted_0() throws Exception {	149	public void testFindFunctions_OtherFile_AftereOpen_ExpressionStarted_0() throws Exception {
122	String[][] expectedProposals = new String[][] {{"funcOne()", "funcTwo()", "funcThree(paramOne)", "funcFour(paramOne, paramTwo)"}};	150	String[][] expectedProposals = new String[][] {{"funcOne()", "funcTwo()", "funcThree(paramOne)", "funcFour(paramOne, paramTwo)",
123	runProposalTest("test2.js", 0, 1, expectedProposals);	151	"funcFive(Number paramOne, String paramTwo) String", "funcSix(paramOne, String paramTwo) Number",
		152	"funcSeven(String paramOne, paramTwo) Number", "funcEight(paramOne) String", "funcNine(paramOne) Number"}};
		153	runProposalTest("test0_1.js", 0, 1, expectedProposals);
124	}	154	}
125		155
126	public void testFindFunctions_OtherFile_ExpressionStarted_1() throws Exception {	156	public void testFindFunctions_OtherFile_AfterOpen_ExpressionStarted_1() throws Exception {
		157	String[][] expectedProposals = new String[][] {{"funcOne()", "funcTwo()", "funcThree(paramOne)", "funcFour(paramOne, paramTwo)",
		158	"funcFive(Number paramOne, String paramTwo) String", "funcSix(paramOne, String paramTwo) Number",
		159	"funcSeven(String paramOne, paramTwo) Number", "funcEight(paramOne) String", "funcNine(paramOne) Number"}};
		160	runProposalTest("test0_1.js", 2, 4, expectedProposals);
		161	}
		162
		163	public void testFindFunctions_OtherFile_AfterOpen_ExpressionStarted_2() throws Exception {
127	String[][] expectedProposals = new String[][] {{"funcTwo()", "funcThree(paramOne)"}};	164	String[][] expectedProposals = new String[][] {{"funcTwo()", "funcThree(paramOne)"}};
128	runProposalTest("test2.js", 2, 5, expectedProposals);	165	runProposalTest("test0_1.js", 4, 5, expectedProposals);
129	}	166	}
130		167
131	public void testFindAnonymousTypeField_0() throws Exception {	168	public void testFindAnonymousTypeField_0() throws Exception {
Lines 148-226 Link Here
148	runProposalTest("test8_1.js", 8, 13, expectedProposals);	185	runProposalTest("test8_1.js", 8, 13, expectedProposals);
149	}	186	}
150		187
		188	public void testFindConstructors_OtherFile_BeforeOpen_ExpressionStarted_0() throws Exception {
		189	String[][] expectedProposals = new String[][] {{"Awesome(param1, param2)"}};
		190	runProposalTest("test2_1.js", 0, 6, expectedProposals);
		191	}
		192
		193	public void testFindConstructors_OtherFile_BeforeOpen_ExpressionStarted_1() throws Exception {
		194	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
		195	runProposalTest("test2_1.js", 2, 6, expectedProposals);
		196	}
		197
		198	public void testFindConstructors_OtherFile_BeforeOpen_ExpressionStarted_2() throws Exception {
		199	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)"}};
		200	runProposalTest("test2_1.js", 4, 9, expectedProposals);
		201	}
		202
		203	public void testFindConstructors_OtherFile_BeforeOpen_ExpressionStarted_3() throws Exception {
		204	String[][] expectedProposals = new String[][] {{"bar.foo.Class3(param1, param2, param3, param4)"}};
		205	runProposalTest("test2_1.js", 6, 10, expectedProposals);
		206	}
		207
		208	public void testFindConstructors_OtherFile_BeforeOpen_ExpressionStarted_4() throws Exception {
		209	String[][] expectedProposals = new String[][] {{"bar.foo.Class3(param1, param2, param3, param4)"}};
		210	runProposalTest("test2_1.js", 8, 13, expectedProposals);
		211	}
		212
		213	public void testFindConstructors_OtherFile_BeforeOpen_ExpressionStarted_5() throws Exception {
		214	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
		215	runProposalTest("test2_1.js", 10, 5, expectedProposals);
		216	}
		217
		218	public void testFindConstructors_OtherFile_BeforeOpen_ExpressionStarted_6() throws Exception {
		219	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
		220	runProposalTest("test2_1.js", 12, 9, expectedProposals);
		221	}
		222
151	public void testFindConstructors_ThisFile_JustNew() throws Exception {	223	public void testFindConstructors_ThisFile_JustNew() throws Exception {
152	String[][] expectedProposals = new String[][] {{"Awesome(param1, param2)", "bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};	224	String[][] expectedProposals = new String[][] {{"Awesome(param1, param2)", "bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
153	runProposalTest("test3.js", 17, 4, expectedProposals);	225	runProposalTest("test2_0.js", 17, 4, expectedProposals);
154	}	226	}
155		227
156	public void testFindConstructors_ThisFile_ExpressionStarted_0() throws Exception {	228	public void testFindConstructors_ThisFile_ExpressionStarted_0() throws Exception {
157	String[][] expectedProposals = new String[][] {{"Awesome(param1, param2)"}};	229	String[][] expectedProposals = new String[][] {{"Awesome(param1, param2)"}};
158	runProposalTest("test3.js", 19, 6, expectedProposals);	230	runProposalTest("test2_0.js", 19, 6, expectedProposals);
159	}	231	}
160		232
161	public void testFindConstructors_ThisFile_ExpressionStarted_1() throws Exception {	233	public void testFindConstructors_ThisFile_ExpressionStarted_1() throws Exception {
162	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};	234	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
163	runProposalTest("test3.js", 21, 6, expectedProposals);	235	runProposalTest("test2_0.js", 21, 6, expectedProposals);
164	}	236	}
165		237
166	public void testFindConstructors_ThisFile_ExpressionStarted_2() throws Exception {	238	public void testFindConstructors_ThisFile_ExpressionStarted_2() throws Exception {
167	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)"}};	239	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)"}};
168	runProposalTest("test3.js", 23, 9, expectedProposals);	240	runProposalTest("test2_0.js", 23, 9, expectedProposals);
169	}	241	}
170		242
171	public void testFindConstructors_ThisFile_ExpressionStarted_3() throws Exception {	243	public void testFindConstructors_ThisFile_ExpressionStarted_3() throws Exception {
172	String[][] expectedProposals = new String[][] {{"bar.foo.Class3(param1, param2, param3, param4)"}};	244	String[][] expectedProposals = new String[][] {{"bar.foo.Class3(param1, param2, param3, param4)"}};
173	runProposalTest("test3.js", 25, 10, expectedProposals);	245	runProposalTest("test2_0.js", 25, 10, expectedProposals);
174	}	246	}
175		247
176	public void testFindConstructors_ThisFile_ExpressionStarted_4() throws Exception {	248	public void testFindConstructors_ThisFile_ExpressionStarted_4() throws Exception {
177	String[][] expectedProposals = new String[][] {{"bar.foo.Class3(param1, param2, param3, param4)"}};	249	String[][] expectedProposals = new String[][] {{"bar.foo.Class3(param1, param2, param3, param4)"}};
178	runProposalTest("test3.js", 27, 13, expectedProposals);	250	runProposalTest("test2_0.js", 27, 13, expectedProposals);
179	}	251	}
180		252
181	public void testFindConstructors_ThisFile_ExpressionStarted_5() throws Exception {	253	public void testFindConstructors_ThisFile_ExpressionStarted_5() throws Exception {
182	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};	254	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
183	runProposalTest("test3.js", 29, 5, expectedProposals);	255	runProposalTest("test2_0.js", 29, 5, expectedProposals);
184	}	256	}
185		257
186	public void testFindConstructors_ThisFile_ExpressionStarted_6() throws Exception {	258	public void testFindConstructors_ThisFile_ExpressionStarted_6() throws Exception {
187	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};	259	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
188	runProposalTest("test3.js", 31, 9, expectedProposals);	260	runProposalTest("test2_0.js", 31, 9, expectedProposals);
189	}	261	}
190		262
191	public void testFindConstructors_OtherFile_ExpressionStarted_0() throws Exception {	263	public void testFindConstructors_OtherFile_AfterOpen_ExpressionStarted_0() throws Exception {
192	String[][] expectedProposals = new String[][] {{"Awesome(param1, param2)"}};	264	String[][] expectedProposals = new String[][] {{"Awesome(param1, param2)"}};
193	runProposalTest("test4.js", 0, 6, expectedProposals);	265	runProposalTest("test2_1.js", 0, 6, expectedProposals);
194	}	266	}
195		267
196	public void testFindConstructors_OtherFile_ExpressionStarted_1() throws Exception {	268	public void testFindConstructors_OtherFile_AfterOpen_ExpressionStarted_1() throws Exception {
197	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};	269	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
198	runProposalTest("test4.js", 2, 6, expectedProposals);	270	runProposalTest("test2_1.js", 2, 6, expectedProposals);
199	}	271	}
200		272
201	public void testFindConstructors_OtherFile_ExpressionStarted_2() throws Exception {	273	public void testFindConstructors_OtherFile_AfterOpen_ExpressionStarted_2() throws Exception {
202	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)"}};	274	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)"}};
203	runProposalTest("test4.js", 4, 9, expectedProposals);	275	runProposalTest("test2_1.js", 4, 9, expectedProposals);
204	}	276	}
205		277
206	public void testFindConstructors_OtherFile_ExpressionStarted_3() throws Exception {	278	public void testFindConstructors_OtherFile_AfterOpen_ExpressionStarted_3() throws Exception {
207	String[][] expectedProposals = new String[][] {{"bar.foo.Class3(param1, param2, param3, param4)"}};	279	String[][] expectedProposals = new String[][] {{"bar.foo.Class3(param1, param2, param3, param4)"}};
208	runProposalTest("test4.js", 6, 10, expectedProposals);	280	runProposalTest("test2_1.js", 6, 10, expectedProposals);
209	}	281	}
210		282
211	public void testFindConstructors_OtherFile_ExpressionStarted_4() throws Exception {	283	public void testFindConstructors_OtherFile_ExpressionStarted_4() throws Exception {
212	String[][] expectedProposals = new String[][] {{"bar.foo.Class3(param1, param2, param3, param4)"}};	284	String[][] expectedProposals = new String[][] {{"bar.foo.Class3(param1, param2, param3, param4)"}};
213	runProposalTest("test4.js", 8, 13, expectedProposals);	285	runProposalTest("test2_1.js", 8, 13, expectedProposals);
214	}	286	}
215		287
216	public void testFindConstructors_OtherFile_ExpressionStarted_5() throws Exception {	288	public void testFindConstructors_OtherFile_AfterOpen_ExpressionStarted_5() throws Exception {
217	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};	289	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
218	runProposalTest("test4.js", 10, 5, expectedProposals);	290	runProposalTest("test2_1.js", 10, 5, expectedProposals);
219	}	291	}
220		292
221	public void testFindConstructors_OtherFile_ExpressionStarted_6() throws Exception {	293	public void testFindConstructors_OtherFile_AfterOpen_ExpressionStarted_6() throws Exception {
222	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};	294	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
223	runProposalTest("test4.js", 12, 9, expectedProposals);	295	runProposalTest("test2_1.js", 12, 9, expectedProposals);
		296	}
		297
		298	public void testFindConstructors_OtherFile_BeforeOpen_VarDeclaration_ExpressionStarted_0() throws Exception {
		299	String[][] expectedProposals = new String[][] {{"MyClass1(a)", "MyClass2()"}};
		300	runProposalTest("test6.js", 0, 8, expectedProposals);
224	}	301	}
225		302
226	public void testFindConstructors_ThisFile_VarDeclaration_ExpressionStarted_0() throws Exception {	303	public void testFindConstructors_ThisFile_VarDeclaration_ExpressionStarted_0() throws Exception {
Lines 228-234 Link Here
228	runProposalTest("test5.js", 7, 8, expectedProposals);	305	runProposalTest("test5.js", 7, 8, expectedProposals);
229	}	306	}
230		307
231	public void testFindConstructors_OtherFile_VarDeclaration_ExpressionStarted_0() throws Exception {	308	public void testFindConstructors_OtherFile_AfterOpen_VarDeclaration_ExpressionStarted_0() throws Exception {
232	String[][] expectedProposals = new String[][] {{"MyClass1(a)", "MyClass2()"}};	309	String[][] expectedProposals = new String[][] {{"MyClass1(a)", "MyClass2()"}};
233	runProposalTest("test6.js", 0, 8, expectedProposals);	310	runProposalTest("test6.js", 0, 8, expectedProposals);
234	}	311	}
Lines 243-258 Link Here
243	runProposalTest("test7.js", 10, 11, expectedProposals);	320	runProposalTest("test7.js", 10, 11, expectedProposals);
244	}	321	}
245		322
		323	public void testFindConstructors_OtherFile_BeforeOpen_ArrayReferenceDeclaration_ExpressionStarted_0() throws Exception {
		324	String[][] expectedProposals = new String[][] {{"test.Foo(x, y, z)"}};
		325	runProposalTest("test9_1.js", 0, 7, expectedProposals);
		326	}
		327
246	public void testFindConstructors_ThisFile_ArrayReferenceDeclaration_ExpressionStarted_0() throws Exception {	328	public void testFindConstructors_ThisFile_ArrayReferenceDeclaration_ExpressionStarted_0() throws Exception {
247	String[][] expectedProposals = new String[][] {{"test.Foo(x, y, z)"}};	329	String[][] expectedProposals = new String[][] {{"test.Foo(x, y, z)"}};
248	runProposalTest("test9_0.js", 7, 7, expectedProposals);	330	runProposalTest("test9_0.js", 7, 7, expectedProposals);
249	}	331	}
250		332
251	public void testFindConstructors_OtherFile_ArrayReferenceDeclaration_ExpressionStarted_0() throws Exception {	333	public void testFindConstructors_OtherFile_AfterOpen_ArrayReferenceDeclaration_ExpressionStarted_0() throws Exception {
252	String[][] expectedProposals = new String[][] {{"test.Foo(x, y, z)"}};	334	String[][] expectedProposals = new String[][] {{"test.Foo(x, y, z)"}};
253	runProposalTest("test9_1.js", 0, 7, expectedProposals);	335	runProposalTest("test9_1.js", 0, 7, expectedProposals);
254	}	336	}
255		337
		338	public void testFindFunctionOnType_OtherFile_ExpressionStarted_0() throws Exception {
		339	String[][] expectedProposals = new String[][] {{"myFunc1(Number param1)", "foo"}};
		340	runProposalTest("test10_1.js", 1, 4, expectedProposals);
		341	}
		342
256	/**	343	/**
257	* <p>Run a proposal test by opening the given file and invoking content assist for	344	* <p>Run a proposal test by opening the given file and invoking content assist for
258	* each expected proposal count at the given line number and line character	345	* each expected proposal count at the given line number and line character