Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright (c) 2000, 2013 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html Contributors: IBM Corporation - initial API and implementation /
   
   package org.eclipse.jdt.internal.codeassist;
   
   import java.util.ArrayList;
   import java.util.Locale;
   import java.util.Map;
   
   import  org.eclipse.core.runtime.IProgressMonitor;
   import  org.eclipse.core.runtime.OperationCanceledException;
   
This class is the entry point for source completions. It contains two public APIs used to call CodeAssist on a given source with a given environment, assisting position and storage (and possibly options).
   
   public final class CompletionEngine
   	extends Engine
   	
   	private static class AcceptedConstructor {
   		public int modifiers;
   		public char[] simpleTypeName;
   		public int parameterCount;
   		public char[] signature;
   		public char[][] parameterTypes;
   		public char[][] parameterNames;
   		public int typeModifiers;
   		public char[] packageName;
   		public int extraFlags;
   		public int accessibility;
   		public boolean proposeType = false;
   		public boolean proposeConstructor = false;
   		public char[] fullyQualifiedName = null;
   		
   		public boolean mustBeQualified = false;
   		
   		public AcceptedConstructor(
  				int modifiers,
  				char[] simpleTypeName,
  				int parameterCount,
  				char[] signature,
  				char[][] parameterTypes,
  				char[][] parameterNames,
  				int typeModifiers,
  				char[] packageName,
  				int extraFlags,
  				int accessibility) {
  			this. = modifiers;
  			this. = simpleTypeName;
  			this. = parameterCount;
  			this. = signature;
  			this. = parameterTypes;
  			this. = parameterNames;
  			this. = typeModifiers;
  			this. = packageName;
  			this. = extraFlags;
  			this. = accessibility;
  		}
  
  		public String toString() {
  			StringBuffer buffer = new StringBuffer();
  			buffer.append('{');
  			buffer.append(this.);
  			buffer.append(',');
  			buffer.append(this.);
  			buffer.append('}');
  			return buffer.toString();
  		}
  	}
  	
  	private static class AcceptedType {
  		public char[] packageName;
  		public char[] simpleTypeName;
  		public char[][] enclosingTypeNames;
  		public int modifiers;
  		public int accessibility;
  		public boolean mustBeQualified = false;
  
  		public char[] fullyQualifiedName = null;
  		public char[] qualifiedTypeName = null;
  		public AcceptedType(
  			char[] packageName,
  			char[] simpleTypeName,
  			char[][] enclosingTypeNames,
  			int modifiers,
  			int accessibility) {
  			this. = packageName;
  			this. = simpleTypeName;
  			this. = enclosingTypeNames;
  			this. = modifiers;
  			this. = accessibility;
  		}
  
  		public String toString() {
  			StringBuffer buffer = new StringBuffer();
  			buffer.append('{');
  			buffer.append(this.);
  			buffer.append(',');
  			buffer.append(this.);
  			buffer.append(',');
  			buffer.append(CharOperation.concatWith(this.'.'));
  			buffer.append('}');
  			return buffer.toString();
  		}
  	}
  	
  	public class CompletionProblemFactory extends DefaultProblemFactory {
  		private int lastErrorStart;
  
  		private boolean checkProblems = false;
  		public boolean hasForbiddenProblems = false;
  		public boolean hasAllowedProblems = false;
  
  		public CompletionProblemFactory(Locale loc) {
  			super(loc);
  		}
  
  			char[] originatingFileName,	int severityint start) {
  			int id = pb.getID();
  				&& this. < start
  				&& pb.isError()
  				&& (id & .) == 0
  				&& (CompletionEngine.this. == null || CharOperation.equals(CompletionEngine.this.originatingFileName))) {
  
  				CompletionEngine.this. = pb;
  				this. = start;
  			}
  			if (this. && !this.) {
  				switch (id) {
  						break;
  						break;
  						break;
  						break;
  					default:
  						if ((severity & .) != 0) {
  							this. = true;
  						} else {
  							this. = true;
  						}
  
  						break;
  				}
  			}
  
  			return pb;
  		}
  
  				char[] originatingFileName,
  				int problemId,
  				String[] problemArguments,
  				int elaborationId,
  				String[] messageArguments,
  				int severity,
  				int start,
  				int end,
  				int lineNumber,
  				int columnNumber) {
  				return checkProblem(
  					super.createProblem(
  						originatingFileName,
  						problemId,
  						problemArguments,
  						elaborationId,
  						messageArguments,
  						severity,
  						start,
  						end,
  						lineNumber,
  						columnNumber), originatingFileNameseveritystart);
  		}
  
  				char[] originatingFileName,
  				int problemId,
  				String[] problemArguments,
  				String[] messageArguments,
  				int severity,
  				int start,
  				int end,
  				int lineNumber,
  				int columnNumber) {
  				return checkProblem(
  					super.createProblem(
  						originatingFileName,
  						problemId,
  						problemArguments,
  						messageArguments,
  						severity,
  						start,
  						end,
  						lineNumber,
  						columnNumber), originatingFileNameseveritystart);
  		}
  
  		public void startCheckingProblems() {
  			this. = true;
  			this. = false;
  			this. = false;
  		}
  
  		public void stopCheckingProblems() {
  			this. = false;
  		}
  	}
  	
  	public static char[] createBindingKey(char[] packageNamechar[] typeName) {
  		char[] signature = createTypeSignature(packageNametypeName);
  		CharOperation.replace(signature'.''/');
  		return signature;
  	}
  
  	public static char[][] createDefaultParameterNames(int length) {
  		char[][] parameters;
  		switch (length) {
  			case 0 :
  				parameters = new char[length][];
  				break;
  			case 1 :
  				parameters = ;
  				break;
  			case 2 :
  				parameters = ;
  				break;
  			case 3 :
  				parameters = ;
  				break;
  			case 4 :
  				parameters = ;
  				break;
  			default :
  				parameters = new char[length][];
  				for (int i = 0; i < lengthi++) {
  					parameters[i] = CharOperation.concat(, String.valueOf(i).toCharArray());
  				}
  				break;
  		}
  		return parameters;
  	}
  	public static char[] createMethodSignature(char[][] parameterPackageNameschar[][] parameterTypeNameschar[] returnTypeSignature) {
  		char[][] parameterTypeSignature = new char[parameterTypeNames.length][];
  		for (int i = 0; i < parameterTypeSignature.lengthi++) {
  			parameterTypeSignature[i] =
  						CharOperation.concat(
  								parameterPackageNames[i],
  								CharOperation.replaceOnCopy(parameterTypeNames[i], '.''$'), '.'), true);
  		}
  
  		return Signature.createMethodSignature(
  				parameterTypeSignature,
  				returnTypeSignature);
  	}
  
  	public static char[] createMethodSignature(char[][] parameterPackageNameschar[][] parameterTypeNameschar[] returnPackagenamechar[] returnTypeName) {
  		char[] returnTypeSignature =
  			returnTypeName == null || returnTypeName.length == 0
  			? Signature.createCharArrayTypeSignature(true)
  					CharOperation.concat(
  							returnPackagename,
  							CharOperation.replaceOnCopy(returnTypeName'.''$'), '.'), true);
  
  				parameterPackageNames,
  				parameterTypeNames,
  				returnTypeSignature);
  	}
  	public static char[] createNonGenericTypeSignature(char[] qualifiedPackageNamechar[] qualifiedTypeName) {
  		return Signature.createCharArrayTypeSignature(
  				CharOperation.concat(
  						qualifiedPackageName,
  						CharOperation.replaceOnCopy(qualifiedTypeName'.''$'), '.'), true);
  	}
  
  	public static char[] createTypeSignature(char[] qualifiedPackageNamechar[] qualifiedTypeName) {
  		char[] name = new char[qualifiedTypeName.length];
  		System.arraycopy(qualifiedTypeName, 0, name, 0, qualifiedTypeName.length);
  
  		int depth = 0;
  		int length = name.length;
  		for (int i = length -1; i >= 0; i--) {
  			switch (name[i]) {
  				case '.':
  					if (depth == 0 && name[i - 1] != '>') {
  						name[i] = '$';
  					}
  					break;
  				case '<':
  					depth--;
  					break;
  				case '>':
  					depth++;
  					break;
  			}
  		}
  		return Signature.createCharArrayTypeSignature(
  				CharOperation.concat(
  						qualifiedPackageName,
  						name'.'), true);
  	}
  
  	private static char[] getRequiredTypeSignature(TypeBinding typeBinding) {
  		char[] result = null;
  		StringBuffer sig = new StringBuffer(10);
  
  		sig.append(typeBinding.signature());
  
  		int sigLength = sig.length();
  		result = new char[sigLength];
  		sig.getChars(0, sigLengthresult, 0);
  		result = CharOperation.replaceOnCopy(result'/''.');
  		return result;
  	}
  	
  	private static char[] getTypeName(TypeReference typeReference) {
  		char[] typeName = CharOperation.concatWith(typeReference.getTypeName(), '.');
  		int dims = typeReference.dimensions();
  		if (dims > 0) {
  			int length = typeName.length;
  			int newLength = length + (dims*2);
  			System.arraycopy(typeName, 0, typeName = new char[newLength], 0, length);
  			for (int k = lengthk < newLengthk += 2) {
  				typeName[k] = '[';
  				typeName[k+1] = ']';
  			}
  		}
  		
  		return typeName;
  	}
  	
  	private static boolean hasStaticMemberTypes(ReferenceBinding typeBindingSourceTypeBinding invocationTypeCompilationUnitScope unitScope) {
  		ReferenceBinding[] memberTypes = typeBinding.memberTypes();
  		int length = memberTypes == null ? 0 : memberTypes.length;
  		next : for (int i = 0; i < lengthi++) {
  			ReferenceBinding memberType = memberTypes[i];
  			if (invocationType != null && !memberType.canBeSeenBy(typeBindinginvocationType)) {
  				continue next;
  			} else if(invocationType == null && !memberType.canBeSeenBy(unitScope.fPackage)) {
  				continue next;
  			}
  			
  			if ((memberType.modifiers & .) != 0) {
  				return true;
  			}
  		}
  		return false;
  	}
  	
  	private static boolean hasMemberTypesInEnclosingScope(SourceTypeBinding typeBindingScope scope) {
  		ReferenceBinding[] memberTypes = typeBinding.memberTypes();
  		int length = memberTypes == null ? 0 : memberTypes.length;
  		
  		if (length > 0) {
  			MethodScope methodScope = scope.methodScope();
  			if (methodScope != null && !methodScope.isStatic) {
  				ClassScope classScope = typeBinding.scope;
  				Scope currentScope = scope;
  				while (currentScope != null) {
  					if (currentScope == classScope) {
  						return true;
  					}
  					currentScope = currentScope.parent;
  				}
  			}
  		}
  		return false;
  	}
  	
  	public int openedBinaryTypes// used during InternalCompletionProposal#findConstructorParameterNames()
  	
  	public static boolean DEBUG = false;
  	public static boolean PERF = false;
  	
  	private static final char[] KNOWN_TYPE_WITH_UNKNOWN_CONSTRUCTORS = new char[]{};
  	private static final char[] KNOWN_TYPE_WITH_KNOWN_CONSTRUCTORS = new char[]{};
  	
  	private static final char[] ARG = "arg".toCharArray();  //$NON-NLS-1$
  	private static final char[] ARG0 = "arg0".toCharArray();  //$NON-NLS-1$
  	private static final char[] ARG1 = "arg1".toCharArray();  //$NON-NLS-1$
  	private static final char[] ARG2 = "arg2".toCharArray();  //$NON-NLS-1$
  	private static final char[] ARG3 = "arg3".toCharArray();  //$NON-NLS-1$
  	private static final char[][] ARGS1 = new char[][]{};
  	private static final char[][] ARGS2 = new char[][]{};
  	private static final char[][] ARGS3 = new char[][]{};
  	private static final char[][] ARGS4 = new char[][]{};
  	
  	private final static int CHECK_CANCEL_FREQUENCY = 50;
  	
  	// temporary constants to quickly disabled polish features if necessary
  	public final static boolean NO_TYPE_COMPLETION_ON_EMPTY_TOKEN = false;
  	
  	private final static char[] ERROR_PATTERN = "*error*".toCharArray();  //$NON-NLS-1$
  	private final static char[] EXCEPTION_PATTERN = "*exception*".toCharArray();  //$NON-NLS-1$
  	private final static char[] SEMICOLON = new char[] { ';' };
  
  	private final static char[] CLASS = "Class".toCharArray();  //$NON-NLS-1$
  	private final static char[] VOID = "void".toCharArray();  //$NON-NLS-1$
  	private final static char[] INT = "int".toCharArray();  //$NON-NLS-1$
  	private final static char[] INT_SIGNATURE = new char[]{.};
  	private final static char[] VALUE = "value".toCharArray();  //$NON-NLS-1$
  	private final static char[] EXTENDS = "extends".toCharArray();  //$NON-NLS-1$
  	private final static char[] SUPER = "super".toCharArray();  //$NON-NLS-1$
  	private final static char[] DEFAULT_CONSTRUCTOR_SIGNATURE = "()V".toCharArray();  //$NON-NLS-1$
  	
  	private final static char[] DOT = ".".toCharArray();  //$NON-NLS-1$
  
  	private final static char[] VARARGS = "...".toCharArray();  //$NON-NLS-1$
  	
  	private final static char[] IMPORT = "import".toCharArray();  //$NON-NLS-1$
  	private final static char[] STATIC = "static".toCharArray();  //$NON-NLS-1$
  	private final static char[] ON_DEMAND = ".*".toCharArray();  //$NON-NLS-1$
  	private final static char[] IMPORT_END = ";\n".toCharArray();  //$NON-NLS-1$
  
  	private final static char[] JAVA_LANG_OBJECT_SIGNATURE =
  		createTypeSignature(CharOperation.concatWith('.'), );
  	private final static char[] JAVA_LANG_NAME =
  		CharOperation.concatWith('.');
  	
  	private final static int NONE = 0;
  	private final static int SUPERTYPE = 1;
  	private final static int SUBTYPE = 2;
  	
  	private final static char[] DOT_ENUM = ".enum".toCharArray(); //$NON-NLS-1$
  	
  	int expectedTypesPtr = -1;
  	boolean hasJavaLangObjectAsExpectedType = false;
  	boolean hasExpectedArrayTypes = false;
  	boolean hasComputedExpectedArrayTypes = false;
  	int uninterestingBindingsPtr = -1;
  	int forbbidenBindingsPtr = -1;
  	Binding[] forbbidenBindings = new Binding[1];
  	int uninterestingBindingsFilter;     // only set when completing on an exception type
  	
  	
  	boolean assistNodeIsClass;
  	boolean assistNodeIsEnum;
  	boolean assistNodeIsInterfaceExcludingAnnotation// https://bugs.eclipse.org/bugs/show_bug.cgi?id=310423
  	int  assistNodeInJavadoc = 0;
  	boolean assistNodeIsInsideCase = false// https://bugs.eclipse.org/bugs/show_bug.cgi?id=195346
  	boolean assistNodeIsString = false;	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=343476
  	
  	long targetedElement;
  	
  	IProgressMonitor monitor;
  	char[] source;
  	char[] completionToken;
  	boolean resolvingImports = false;
  	boolean resolvingStaticImports = false;
  	boolean insideQualifiedReference = false;
  	boolean noProposal = true;
  	char[] fileName = null;
  	int tokenStarttokenEnd;
  	int javadocTagPosition// Position of previous tag while completing in javadoc
  	
   	/*
  		static final char[][] mainDeclarations =
  			new char[][] {
  				"package".toCharArray(),
  				"import".toCharArray(),
  				"abstract".toCharArray(),
  				"final".toCharArray(),
  				"public".toCharArray(),
  				"class".toCharArray(),
  				"interface".toCharArray()};
  
  		static final char[][] modifiers = // may want field, method, type & member type modifiers
  			new char[][] {
  				"abstract".toCharArray(),
  				"final".toCharArray(),
  				"native".toCharArray(),
  				"public".toCharArray(),
  				"protected".toCharArray(),
  				"private".toCharArray(),
  				"static".toCharArray(),
  				"strictfp".toCharArray(),
  				"synchronized".toCharArray(),
  				"transient".toCharArray(),
  				"volatile".toCharArray()};
  	*/
  	static final BaseTypeBinding[] BASE_TYPES = {
  	};
  	static final int BASE_TYPES_LENGTH = .;
  	static final char[][] BASE_TYPE_NAMES = new char[][];
  	static final int BASE_TYPES_WITHOUT_VOID_LENGTH = . - 1;
  	static final char[][] BASE_TYPE_NAMES_WITHOUT_VOID = new char[][];
  	static {
   		for (int i=0; i<i++) {
   		}
  		for (int i=0; i<i++) {
  		}
   	}
  	
  	static final char[] classField = "class".toCharArray();  //$NON-NLS-1$
  	static final char[] lengthField = "length".toCharArray();  //$NON-NLS-1$
  	static final char[] cloneMethod = "clone".toCharArray();  //$NON-NLS-1$
  	static final char[] THIS = "this".toCharArray();  //$NON-NLS-1$
  	static final char[] THROWS = "throws".toCharArray();  //$NON-NLS-1$
  
  		public TypeBinding[] genericTypeArguments() { return null; }
  		public boolean isSuperAccess(){ return false; }
  		public boolean isTypeAccess(){ return false; }
  		public void setActualReceiverType(ReferenceBinding receiverType) {/* empty */}
  		public void setDepth(int depth){/* empty */}
  		public void setFieldIndex(int depth){/* empty */}
  		public int sourceEnd() { return 0; 	}
  		public int sourceStart() { return 0; 	}
  		public TypeBinding expectedType() { return null; }
  	};
  
  	private int foundTypesCount;
  	
  	private int foundConstructorsCount;
The CompletionEngine is responsible for computing source completions. It requires a searchable name environment, which supports some specific search APIs, and a requestor to feed back the results to a UI.

Parameters:
nameEnvironment org.eclipse.jdt.internal.codeassist.ISearchableNameEnvironment used to resolve type/package references and search for types/packages based on partial names.
requestor org.eclipse.jdt.internal.codeassist.ICompletionRequestor since the engine might produce answers of various forms, the engine is associated with a requestor able to accept all possible completions.
settings java.util.Map set of options used to configure the code assist engine.
  
  	public CompletionEngine(
  			SearchableEnvironment nameEnvironment,
  			CompletionRequestor requestor,
  			Map settings,
  			IJavaProject javaProject,
  			WorkingCopyOwner owner,
  			IProgressMonitor monitor) {
  		super(settings);
  		this. = javaProject;
  		this. = requestor;
  		this. = nameEnvironment;
  		this. = new HashtableOfObject(5);
  		this. = 0;
  
  				DefaultErrorHandlingPolicies.proceedWithAllProblems(),
  				this.);
  			new LookupEnvironment(thisthis.this.nameEnvironment);
  		this. =
  		this. = owner;
  		this. = monitor;
  	}
  	
  	public void accept(ICompilationUnit sourceUnitAccessRestriction accessRestriction) {
  		if (!CharOperation.equals(sourceUnit.getMainTypeName(), .)) {
  			// do not accept package-info.java as a type for completion engine
  			// because it contains no extra info that will help in completion
  			// https://bugs.eclipse.org/bugs/show_bug.cgi?id=343865
  			// Required after the fix for https://bugs.eclipse.org/bugs/show_bug.cgi?id=337868
  			// because now we get a type corresponding to the package-info.java from the java model.
  			super.accept(sourceUnitaccessRestriction);
  		}
  	}
  	
  	public void acceptConstructor(
  			int modifiers,
  			char[] simpleTypeName,
  			int parameterCount,
  			char[] signature,
  			char[][] parameterTypes,
  			char[][] parameterNames,
  			int typeModifiers,
  			char[] packageName,
  			int extraFlags,
  			String path,
  			AccessRestriction accessRestriction) {
  		
  		// does not check cancellation for every types to avoid performance loss
  		
  		if ((typeModifiers & .) != 0) return;
  		
  		if (this.. && (typeModifiers & .) != 0) return;
  
  		if (this..) {
  			if((typeModifiers & .) == 0) {
  				if((typeModifiers & .) != 0) return;
  
  				if (this. == null) {
  				}
  				
  				if(!CharOperation.equals(packageNamethis.)) return;
  			}
  		}
  
  		int accessibility = .;
  		if(accessRestriction != null) {
  			switch (accessRestriction.getProblemId()) {
  						return;
  					}
  					accessibility = .;
  					break;
  						return;
  					}
  					accessibility = .;
  					break;
  			}
  		}
  		
  		if(this. == null) {
  		}
  						modifiers,
  						simpleTypeName,
  						parameterCount,
  						signature,
  						parameterTypes,
  						parameterNames,
  						typeModifiers,
  						packageName,
  						extraFlags,
  						accessibility));
  	}
  	
  	private void acceptConstructors(Scope scope) {
  		final boolean DEFER_QUALIFIED_PROPOSALS = false;
  		
  		this.checkCancel();
  		
  		if(this. == nullreturn;
  
  		int length = this..size();
  
  		if(length == 0) return;
  		
  		HashtableOfObject onDemandFound = new HashtableOfObject();
  		
  		ArrayList deferredProposals = null;
  		if (DEFER_QUALIFIED_PROPOSALS) {
  			deferredProposals = new ArrayList();
  		}
  		
  		try {
  			next : for (int i = 0; i < lengthi++) {
  				
  				// does not check cancellation for every types to avoid performance loss
  				if ((i % ) == 0) checkCancel();
  				
  				final int typeModifiers = acceptedConstructor.typeModifiers;
  				final char[] packageName = acceptedConstructor.packageName;
  				final char[] simpleTypeName = acceptedConstructor.simpleTypeName;
  				final int modifiers = acceptedConstructor.modifiers;
  				final int parameterCount = acceptedConstructor.parameterCount;
  				final char[] signature = acceptedConstructor.signature;
  				final char[][] parameterTypes = acceptedConstructor.parameterTypes;
  				final char[][] parameterNames = acceptedConstructor.parameterNames;
  				final int extraFlags = acceptedConstructor.extraFlags;
  				final int accessibility = acceptedConstructor.accessibility;
  				
  				boolean proposeType = hasArrayTypeAsExpectedSuperTypes() || (extraFlags & .) != 0;
  				
  				char[] fullyQualifiedName = CharOperation.concat(packageNamesimpleTypeName'.');
  						
  				Object knownTypeKind = this..get(fullyQualifiedName);
  				if (knownTypeKind != null) {
  					if (knownTypeKind == ) {
  						// the type and its constructors are already accepted
  						continue next;
  					}
  					// this type is already accepted
  					proposeType = false;
  				} else {
  					this..put(fullyQualifiedName);
  				}
  				
  				boolean proposeConstructor = true;
  					
  				if (this..) {
  					if((modifiers & .) == 0) {
  						if((modifiers & .) != 0) {
  							if (!proposeTypecontinue next;
  							proposeConstructor = false;
  						} else {
  							if (this. == null) {
  							}
  							
  							if(!CharOperation.equals(packageNamethis.)) {
  								
  								if((typeModifiers & .) == 0 ||
  										(modifiers & .) == 0) {
  									if (!proposeTypecontinue next;
  									proposeConstructor = false;
  								}
  							}
  						}
  					}
  				}
  				
  				acceptedConstructor.fullyQualifiedName = fullyQualifiedName;
  				acceptedConstructor.proposeType = proposeType;
  				acceptedConstructor.proposeConstructor = proposeConstructor;
  				
  				
  				if(!this.) {
  				}
  				
  				for (int j = 0; j < this.j++) {
  					char[][] importName = this.[j];
  					if(CharOperation.equals(simpleTypeNameimportName[0])) {
  						if (proposeType) {
  									packageName,
  									simpleTypeName,
  									typeModifiers,
  									accessibility,
  									simpleTypeName,
  									fullyQualifiedName,
  									!CharOperation.equals(fullyQualifiedNameimportName[1]),
  									scope);
  						}
  						
  						if (proposeConstructor && !Flags.isEnum(typeModifiers)) {
  							boolean isQualified = !CharOperation.equals(fullyQualifiedNameimportName[1]);
  							if (!isQualified) {
  										simpleTypeName,
  										parameterCount,
  										signature,
  										parameterTypes,
  										parameterNames,
  										modifiers,
  										packageName,
  										typeModifiers,
  										accessibility,
  										simpleTypeName,
  										fullyQualifiedName,
  										isQualified,
  										scope,
  										extraFlags);
  							} else {
  								acceptedConstructor.mustBeQualified = true;
  								if (DEFER_QUALIFIED_PROPOSALS) {
  									deferredProposals.add(acceptedConstructor);
  								} else {
  									proposeConstructor(acceptedConstructorscope);
  								}
  							}
  						}
  						continue next;
  					}
  				}
  
  
  				if (CharOperation.equals(this.packageName)) {
  					if (proposeType) {
  								packageName,
  								simpleTypeName,
  								typeModifiers,
  								accessibility,
  								simpleTypeName,
  								fullyQualifiedName,
  								false,
  								scope);
  					}
  					
  					if (proposeConstructor && !Flags.isEnum(typeModifiers)) {
  								simpleTypeName,
  								parameterCount,
  								signature,
  								parameterTypes,
  								parameterNames,
  								modifiers,
  								packageName,
  								typeModifiers,
  								accessibility,
  								simpleTypeName,
  								fullyQualifiedName,
  								false,
  								scope,
  								extraFlags);
  					}
  					continue next;
  				} else {
  					char[] fullyQualifiedEnclosingTypeOrPackageName = null;
  
  					AcceptedConstructor foundConstructor = null;
  					if((foundConstructor = (AcceptedConstructor)onDemandFound.get(simpleTypeName)) == null) {
  						for (int j = 0; j < this.j++) {
  							ImportBinding importBinding = this.[j];
  
  							char[][] importName = importBinding.compoundName;
  							char[] importFlatName = CharOperation.concatWith(importName'.');
  
  							if(fullyQualifiedEnclosingTypeOrPackageName == null) {
  								fullyQualifiedEnclosingTypeOrPackageName = packageName;
  							}
  							if(CharOperation.equals(fullyQualifiedEnclosingTypeOrPackageNameimportFlatName)) {
  								if(importBinding.isStatic()) {
  									if((typeModifiers & .) != 0) {
  										onDemandFound.put(
  												simpleTypeName,
  												acceptedConstructor);
  										continue next;
  									}
  								} else {
  									onDemandFound.put(
  											simpleTypeName,
  											acceptedConstructor);
  									continue next;
  								}
  							}
  						}
  					} else if(!foundConstructor.mustBeQualified){
  						done : for (int j = 0; j < this.j++) {
  							ImportBinding importBinding = this.[j];
  
  							char[][] importName = importBinding.compoundName;
  							char[] importFlatName = CharOperation.concatWith(importName'.');
  
  							if(fullyQualifiedEnclosingTypeOrPackageName == null) {
  								fullyQualifiedEnclosingTypeOrPackageName = packageName;
  							}
  							if(CharOperation.equals(fullyQualifiedEnclosingTypeOrPackageNameimportFlatName)) {
  								if(importBinding.isStatic()) {
  									if((typeModifiers & .) != 0) {
  										foundConstructor.mustBeQualified = true;
  										break done;
  									}
  								} else {
  									foundConstructor.mustBeQualified = true;
  									break done;
  								}
  							}
  						}
  					}
  					if (proposeType) {
  								packageName,
  								simpleTypeName,
  								typeModifiers,
  								accessibility,
  								simpleTypeName,
  								fullyQualifiedName,
  								true,
  								scope);
  					}
  					
  					if (proposeConstructor && !Flags.isEnum(typeModifiers)) {
  						acceptedConstructor.mustBeQualified = true;
  						if (DEFER_QUALIFIED_PROPOSALS) {
  							deferredProposals.add(acceptedConstructor);
  						} else {
  							proposeConstructor(acceptedConstructorscope);
  						}
  					}
  				}
  			}
  		
  			char[][] keys = onDemandFound.keyTable;
  			Object[] values = onDemandFound.valueTable;
  			int max = keys.length;
  			for (int i = 0; i < maxi++) {
  				
  				// does not check cancellation for every types to avoid performance loss
  				if ((i % ) == 0) checkCancel();
  				
 				if(keys[i] != null) {
 					AcceptedConstructor value = (AcceptedConstructorvalues[i];
 					if(value != null) {
 						char[] fullyQualifiedEnclosingTypeOrPackageName = null;
 						done : for (int j = 0; j < this.j++) {
 							ImportBinding importBinding = this.[j];
 							char[][] importName = importBinding.compoundName;
 							char[] importFlatName = CharOperation.concatWith(importName'.');
 							if(fullyQualifiedEnclosingTypeOrPackageName == null) {
 								fullyQualifiedEnclosingTypeOrPackageName = value.packageName;
 							}
 							if(CharOperation.equals(fullyQualifiedEnclosingTypeOrPackageNameimportFlatName)) {
 								if(importBinding.isStatic()) {
 									if((value.modifiers & .) != 0) {
 										value.mustBeQualified = true;
 										break done;
 									}
 								} else {
 									value.mustBeQualified = true;
 									break done;
 								}
 							}
 						}
 						if (value.proposeType) {
 									value.packageName,
 									value.simpleTypeName,
 									value.typeModifiers,
 									value.accessibility,
 									value.simpleTypeName,
 									value.fullyQualifiedName,
 									value.mustBeQualified,
 									scope);
 						}
 						
 						if (value.proposeConstructor && !Flags.isEnum(value.modifiers)) {
 							if (!value.mustBeQualified) {
 										value.simpleTypeName,
 										value.parameterCount,
 										value.signature,
 										value.parameterTypes,
 										value.parameterNames,
 										value.modifiers,
 										value.packageName,
 										value.typeModifiers,
 										value.accessibility,
 										value.simpleTypeName,
 										value.fullyQualifiedName,
 										value.mustBeQualified,
 										scope,
 										value.extraFlags);
 							} else {
 								if (DEFER_QUALIFIED_PROPOSALS) {
 									deferredProposals.add(value);
 								} else {
 									proposeConstructor(valuescope);
 								}
 							}
 						}
 					}
 				}
 			}
 			
 			if (DEFER_QUALIFIED_PROPOSALS) {
 				int size = deferredProposals.size();
 				for (int i = 0; i < sizei++) {
 					
 					// does not check cancellation for every types to avoid performance loss
 					if ((i % ) == 0) checkCancel();
 				
 					AcceptedConstructor deferredProposal = (AcceptedConstructor)deferredProposals.get(i);
 					
 					if (deferredProposal.proposeConstructor) {
 								deferredProposal.simpleTypeName,
 								deferredProposal.parameterCount,
 								deferredProposal.signature,
 								deferredProposal.parameterTypes,
 								deferredProposal.parameterNames,
 								deferredProposal.modifiers,
 								deferredProposal.packageName,
 								deferredProposal.typeModifiers,
 								deferredProposal.accessibility,
 								deferredProposal.simpleTypeName,
 								deferredProposal.fullyQualifiedName,
 								deferredProposal.mustBeQualified,
 								scope,
 								deferredProposal.extraFlags);
 					}
 				}
 			}
 		} finally {
 			this. = null// reset
 		}
 	}

One result of the search consists of a new package. NOTE - All package names are presented in their readable form: Package names are in the form "a.b.c". The default package is represented by an empty array.
 	public void acceptPackage(char[] packageName) {
 		if (this..containsKey(packageName)) return;
 		this..put(packageNamethis);
 		char[] completion;
 		if(this.) {
 				completion = CharOperation.concat(packageNamenew char[] { '.' });
 			} else {
 				completion = CharOperation.concat(packageNamenew char[] { '.''*'';' });
 			}
 		} else {
 			completion = packageName;
 		}
 		int relevance = computeBaseRelevance();
 		relevance += computeRelevanceForCaseMatching(this. == null ? this. : this.packageName);
 		if(!this.) {
 			relevance += computeRelevanceForQualification(true);
 		}
 		this. = false;
 			proposal.setDeclarationSignature(packageName);
 			proposal.setPackageName(packageName);