Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
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.jdt.internal.codeassist;
  
  import java.util.Locale;
  import java.util.Map;
  
  import  org.eclipse.core.resources.IFile;
  import  org.eclipse.core.runtime.IProgressMonitor;
  import  org.eclipse.core.runtime.OperationCanceledException;
The selection engine is intended to infer the nature of a selected name in some source code. This name can be qualified. Selection is resolving context using a name environment (no need to search), assuming the source where selection occurred is correct and will not perform any completion attempt. If this was the desired behavior, a call to the CompletionEngine should be performed instead.
  
  public final class SelectionEngine extends Engine implements ISearchRequestor {
  	
  		
  		class AcceptedType {
  			public int modifiers;
  			public char[] packageName;
  			public char[] simpleTypeName;
  			public String path;
  			
  			public AcceptedType(int modifierschar[] packageNamechar[] simpleTypeNameString pathAccessRestriction access) {
  				this. = modifiers;
  				this. = packageName;
  				this. = simpleTypeName;
  				this. = path;
  				this. = access;
  			}
  		}
  		
  		
  		private boolean importCachesNodeInitialized = false;
  		private char[][][] importsNodeCache;
  		private int importsNodeCacheCount;
  		
  		private ObjectVector notImportedFound = new ObjectVector();
  		
  		public SelectionTypeNameMatchRequestorWrapper(TypeNameMatchRequestor requestorIJavaSearchScope scopeImportReference[] importReferences) {
 			super(requestorscope);
 			this. = importReferences;
 		}
 		
 		public void acceptType(int modifierschar[] packageNamechar[] simpleTypeNamechar[][] enclosingTypeNamesString pathAccessRestriction access) {
 			if (enclosingTypeNames != null && enclosingTypeNames.length > 0) return;
 			
 			
 			char[] fullyQualifiedTypeName = CharOperation.concat(packageNamesimpleTypeName'.');
 			
 			for (int i = 0; i < this.i++) {
 				char[][] importName = this.[i];
 				if (CharOperation.equals(importName[0], simpleTypeName)) {
 					
 					if(CharOperation.equals(importName[1], fullyQualifiedTypeName)) {
 						super.acceptType(modifierspackageNamesimpleTypeNameenclosingTypeNamespathaccess);
 					}
 					return;
 				}
 			}
 			
 			for (int i = 0; i < this.i++) {
 				char[][] importName = this.[i].;
 				char[] importFlatName = CharOperation.concatWith(importName'.');
 				
 				if (CharOperation.equals(importFlatNamepackageName)) {
 					
 					this..put(simpleTypeNamesimpleTypeName);
 					super.acceptType(modifierspackageNamesimpleTypeNameenclosingTypeNamespathaccess);
 					return;
 				}
 			}
 			
 			
 			this..add(new AcceptedType(modifierspackageNamesimpleTypeNamepathaccess));
 		}
 		
 		public void acceptNotImported() {
 			int size = this..size();
 			for (int i = 0; i < sizei++) {
 				
 				if (this..get(acceptedType.simpleTypeName) == null) {
 					super.acceptType(
 							acceptedType.modifiers,
 							acceptedType.packageName,
 							acceptedType.simpleTypeName,
 							null,
 							acceptedType.path,
 							acceptedType.access);
 				}
 			}
 		}
 		
 		public void initializeImportNodeCaches() {
 			int length = this. == null ? 0 : this..length;
 			
 			for (int i = 0; i < lengthi++) {
 				ImportReference importReference = this.[i];
 				if((importReference.bits & .) != 0) {
 					if(this. == null) {
 						this. = new ImportReference[length - i];
 					}
 						importReference;
 				} else {
 					if(this. == null) {
 						this. = new char[length - i][][];
 					}
 					
 					
 					this.[this.++] = new char[][]{
 							importReference.tokens[importReference.tokens.length - 1],
 							CharOperation.concatWith(importReference.tokens'.')
 						};
 				}
 			}
 			
 		}
 	}
 
 	public static boolean DEBUG = false;
 	public static boolean PERF = false;
 
 
 	boolean acceptedAnswer;
 
 	private int actualSelectionStart;
 	private int actualSelectionEnd;
 	private char[] selectedIdentifier;
 
 	private char[][][] acceptedClasses;
 	private int[] acceptedClassesModifiers;
 	private char[][][] acceptedInterfaces;
 	private int[] acceptedInterfacesModifiers;
 	private char[][][] acceptedEnums;
 	private int[] acceptedEnumsModifiers;
 	private char[][][] acceptedAnnotations;
 
 	boolean noProposal = true;
The SelectionEngine is responsible for computing the selected object. 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.core.SearchableEnvironment used to resolve type/package references and search for types/packages based on partial names.
requestor org.eclipse.jdt.internal.codeassist.ISelectionRequestor 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 SelectionEngine(
 		SearchableEnvironment nameEnvironment,
 		ISelectionRequestor requestor,
 		Map settings,
 		WorkingCopyOwner owner) {
 
 		super(settings);
 
 		this. = requestor;
 		this. = nameEnvironment;
 
 		ProblemReporter problemReporter =
 				DefaultErrorHandlingPolicies.proceedWithAllProblems(),
 				new DefaultProblemFactory(Locale.getDefault())) {
 
 				char[] fileName,
 				int problemId,
 				String[] problemArguments,
 				String[] messageArguments,
 				int severity,
 				int problemStartPosition,
 				int problemEndPosition,
 				int lineNumber,
 				int columnNumber) {
 					fileName,
 					problemId,
 					problemArguments,
 					messageArguments,
 					severity,
 					problemStartPosition,
 					problemEndPosition,
 					lineNumber,
 					columnNumber);
 					if(SelectionEngine.this. == null && pb.isError() && (pb.getID() & .) == 0) {
 						SelectionEngine.this. = pb;
 					}
 
 					return pb;
 			}
 		};
 			new LookupEnvironment(thisthis.problemReporternameEnvironment);
 		this. = new SelectionParser(problemReporter);
 		this. = owner;
 	}
 	
 	public void acceptConstructor(
 			int modifiers,
 			char[] simpleTypeName,
 			int parameterCount,
 			char[] signature,
 			char[][] parameterTypes,
 			char[][] parameterNames,
 			int typeModifiers,
 			char[] packageName,
 			int extraFlags,
 			String path,
 			AccessRestriction access) {
 		// constructors aren't searched
 	}
 
 	public void acceptType(char[] packageNamechar[] simpleTypeNamechar[][] enclosingTypeNamesint modifiersAccessRestriction accessRestriction) {
 		char[] typeName = enclosingTypeNames == null ?
 				simpleTypeName :
 					CharOperation.concat(
 						CharOperation.concatWith(enclosingTypeNames'.'),
 						simpleTypeName,
 						'.');
 
 		if (CharOperation.equals(simpleTypeNamethis.)) {
 			char[] flatEnclosingTypeNames =
 				enclosingTypeNames == null || enclosingTypeNames.length == 0 ?
 						null :
 							CharOperation.concatWith(enclosingTypeNames'.');
 			if(mustQualifyType(packageNamesimpleTypeNameflatEnclosingTypeNamesmodifiers)) {
 				int length = 0;
 				switch (kind) {
 						char[][] acceptedAnnotation = new char[2][];
 						acceptedAnnotation[0] = packageName;
 						acceptedAnnotation[1] = typeName;
 
 						if(this. == null) {
 							this. = new char[10][][];
 							this. = new int[10];
 						}
 						length = this..length;
 						if(length == this.) {
 							int newLength = (length + 1)* 2;
 							System.arraycopy(this., 0, this. = new char[newLength][][], 0, length);
 							System.arraycopy(this., 0, this. = new int[newLength], 0, length);
 						}
 						this.[this.++] = acceptedAnnotation;
 						break;
 						char[][] acceptedEnum = new char[2][];
 						acceptedEnum[0] = packageName;
 						acceptedEnum[1] = typeName;
 
 						if(this. == null) {
 							this. = new char[10][][];
 							this. = new int[10];
 							this. = 0;
 						}
 						length = this..length;
 						if(length == this.) {
 							int newLength = (length + 1)* 2;
 							System.arraycopy(this., 0, this. = new char[newLength][][], 0, length);
 							System.arraycopy(this., 0, this. = new int[newLength], 0, length);
 						}
 						this.[this.] = modifiers;
 						this.[this.++] = acceptedEnum;
 						break;
 						char[][] acceptedInterfacenew char[2][];
 						acceptedInterface[0] = packageName;
 						acceptedInterface[1] = typeName;
 
 						if(this. == null) {
 							this. = new char[10][][];
 							this. = new int[10];
 						}
 						length = this..length;
 						if(length == this.) {
 							int newLength = (length + 1)* 2;
 							System.arraycopy(this., 0, this. = new char[newLength][][], 0, length);
 							System.arraycopy(this., 0, this. = new int[newLength], 0, length);
 						}
 						this.[this.++] = acceptedInterface;
 						break;
 					default:
 						char[][] acceptedClass = new char[2][];
 						acceptedClass[0] = packageName;
 						acceptedClass[1] = typeName;
 
 						if(this. == null) {
 							this. = new char[10][][];
 							this. = new int[10];
 						}
 						length = this..length;
 						if(length == this.) {
 							int newLength = (length + 1)* 2;
 							System.arraycopy(this., 0, this. = new char[newLength][][], 0, length);
 							System.arraycopy(this., 0, this. = new int[newLength], 0, length);
 						}
 						this.[this.++] = acceptedClass;
 						break;
 				}
 			} else {
 				this. = false;
 					packageName,
 					typeName,
 					modifiers,
 					false,
 					null,
 				this. = true;
 			}
 		}
 	}

One result of the search consists of a new package.

Parameters:
packageName char[] 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) {
 		// implementation of interface method
 	}
 
 	private void acceptQualifiedTypes() {
 		if(this. != null){
 			this. = true;
 			for (int i = 0; i < this.i++) {
 				this. = false;
 					this.[i][0],
 					this.[i][1],
 					false,
 					null,
 			}
 			this. = null;
 			this. = null;
 		}
 		if(this. != null){
 			this. = true;
 			for (int i = 0; i < this.i++) {
 				this. = false;
 					this.[i][0],
 					this.[i][1],
 					false,
 					null,
 			}
 			this. = null;
 		}
 		if(this. != null){
 			this. = true;
 			for (int i = 0; i < this.i++) {
 				this. = false;
 					this.[i][0],
 					this.[i][1],
 					false,
 					null,
 			}
 			this. = null;
 		}
 		if(this. != null){
 			this. = true;
 			for (int i = 0; i < this.i++) {
 				this. = false;
 					this.[i][0],
 					this.[i][1],
 					false,
 					null,
 			}
 			this. = null;
 			this. = null;
 			this. = 0;
 		}
 	}
 	private boolean checkSelection(
 			char[] source,
 			int selectionStart,
 			int selectionEnd) {
 
 		Scanner scanner =
 			new Scanner(
 				false /*comment*/,
 				false /*whitespace*/,
 				false /*nls*/,
 				null/*taskTag*/,
 				null/*taskPriorities*/,
 				true /*taskCaseSensitive*/);
 		scanner.setSource(source);
 
 		int lastIdentifierStart = -1;
 		int lastIdentifierEnd = -1;
 		char[] lastIdentifier = null;
 		int token;
 
 		if(selectionStart > selectionEnd){
 			int end = source.length - 1;
 
 			// compute start position of current line
 			int currentPosition = selectionStart - 1;
 			int nextCharacterPosition = selectionStart;
 			char currentCharacter = ' ';
 			try {
 				lineLoop: while(currentPosition > 0){
 
 					if(source[currentPosition] == '\\' && source[currentPosition+1] == 'u') {
 						int pos = currentPosition + 2;
 						int c1 = 0, c2 = 0, c3 = 0, c4 = 0;
 						while (source[pos] == 'u') {
 							pos++;
 						}
 
 						int endOfUnicode = pos + 3;
 						if (end < endOfUnicode) {
 							if (endOfUnicode < source.length) {
 								end = endOfUnicode;
 							} else {
 								return false// not enough characters to decode an unicode
 							}
 						}
 
 						if ((c1 = ScannerHelper.getHexadecimalValue(source[pos++])) > 15
 							|| c1 < 0
 							|| (c2 = ScannerHelper.getHexadecimalValue(source[pos++])) > 15
 							|| c2 < 0
 							|| (c3 = ScannerHelper.getHexadecimalValue(source[pos++])) > 15
 							|| c3 < 0
 							|| (c4 = ScannerHelper.getHexadecimalValue(source[pos++])) > 15
 							|| c4 < 0) {
 							return false;
 						} else {
 							currentCharacter = (char) (((c1 * 16 + c2) * 16 + c3) * 16 + c4);
 							nextCharacterPosition = pos;
 						}
 					} else {
 						currentCharacter = source[currentPosition];
 						nextCharacterPosition = currentPosition+1;
 					}
 
 					switch(currentCharacter) {
 						case '\r':
 						case '\n':
 						case '/':
 						case '"':
 						case '\'':
 							break lineLoop;
 					}
 					currentPosition--;
 				}
 				return false;
 			}
 
 			// compute start and end of the last token
 			scanner.resetTo(nextCharacterPositionend);
 			isolateLastName: do {
 				try {
 					token = scanner.getNextToken();
 				} catch (InvalidInputException e) {
 					return false;
 				}
 				switch (token) {
 						if (scanner.startPosition <= selectionStart && selectionStart <= scanner.currentPosition) {
 							if (scanner.currentPosition == scanner.eofPosition) {
 								int temp = scanner.eofPosition;
 								scanner.eofPosition = scanner.source.length;
 							 	while(scanner.getNextCharAsJavaIdentifierPart()){/*empty*/}
 							 	scanner.eofPosition = temp;
 							}
 							lastIdentifierStart = scanner.startPosition;
 							lastIdentifierEnd = scanner.currentPosition - 1;
 							lastIdentifier = scanner.getCurrentTokenSource();
 							break isolateLastName;
 						}
 						break;
 				}
 			} while (token != .);
 		} else {
 			scanner.resetTo(selectionStartselectionEnd);
 
 			boolean expectingIdentifier = true;
 			do {
 				try {
 					token = scanner.getNextToken();
 				} catch (InvalidInputException e) {
 					return false;
 				}
 				switch (token) {
 						if (!expectingIdentifier)
 							return false;
 						lastIdentifier = scanner.getCurrentTokenSource();
 						lastIdentifierStart = scanner.startPosition;
 						lastIdentifierEnd = scanner.currentPosition - 1;
 						if(lastIdentifierEnd > selectionEnd) {
 							lastIdentifierEnd = selectionEnd;
 							lastIdentifier = CharOperation.subarray(lastIdentifier, 0,lastIdentifierEnd - lastIdentifierStart + 1);
 						}
 						expectingIdentifier = false;
 						break;
 						if (expectingIdentifier)
 							return false;
 						expectingIdentifier = true;
 						break;
 						if (expectingIdentifier)
 							return false;
 						break;
 						if(!checkTypeArgument(scanner))
 							return false;
 						break;
 						if(scanner.startPosition != scanner.initialPosition)
 							return false;
 						break;
 					default :
 						return false;
 				}
 			} while (token != .);
 		}
 		if (lastIdentifierStart > 0) {
 			this. = lastIdentifierStart;
 			this. = lastIdentifierEnd;
 			this. = lastIdentifier;
 			return true;
 		}
 		return false;
 	}
 	private boolean checkTypeArgument(Scanner scanner) {
 		int depth = 1;
 		int token;
 		StringBuffer buffer = new StringBuffer();
 		do {
 			try {
 				token = scanner.getNextToken();
 			} catch (InvalidInputException e) {
 				return false;
 			}
 			switch(token) {
 					depth++;
 					buffer.append(scanner.getCurrentTokenSource());
 					break;
 					depth--;
 					buffer.append(scanner.getCurrentTokenSource());
 					break;
 					depth-=2;
 					buffer.append(scanner.getCurrentTokenSource());
 					break;
 					depth-=3;
 					buffer.append(scanner.getCurrentTokenSource());
 					break;
 					buffer.append(' ');
 					buffer.append(scanner.getCurrentTokenSource());
 					buffer.append(' ');
 					break;
 					if(depth == 1) {
 						int length = buffer.length();
 						char[] typeRef = new char[length];
 						buffer.getChars(0, lengthtypeRef, 0);
 						try {
 							Signature.createTypeSignature(typeReftrue);
 							buffer = new StringBuffer();
 						} catch(IllegalArgumentException e) {
 							return false;
 						}
 					}
 					break;
 				default :
 					buffer.append(scanner.getCurrentTokenSource());
 					break;
 
 			}
 			if(depth < 0) {
 				return false;
 			}
 		} while (depth != 0 && token != .);
 
 		if(depth == 0) {
 			int length = buffer.length() - 1;
 			char[] typeRef = new char[length];
 			buffer.getChars(0, lengthtypeRef, 0);
 			try {
 				Signature.createTypeSignature(typeReftrue);
 				return true;
 			} catch(IllegalArgumentException e) {
 				return false;
 			}
 		}
 
 		return false;
 	}
 	
 	/*
 	 * find all types outside the project scope
 	 */
 	private void findAllTypes(char[] prefix) {
 		try {
 			IProgressMonitor progressMonitor = new IProgressMonitor() {
 				boolean isCanceled = false;
 				public void beginTask(String nameint totalWork) {
 					// implements interface method
 				}
 				public void done() {
 					// implements interface method
 				}
 				public void internalWorked(double work) {
 					// implements interface method
 				}
 				public boolean isCanceled() {
 					return this.;
 				}
 				public void setCanceled(boolean value) {
 					this. = 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
 				}
 			};
 			
 			TypeNameMatchRequestor typeNameMatchRequestor = new TypeNameMatchRequestor() {
 				public void acceptTypeNameMatch(TypeNameMatch match) {
 					if (SelectionEngine.this. instanceof SelectionRequestor) {
 						SelectionEngine.this. = false;
 					}
 				}
 			};
 			
 			IJavaSearchScope scope = BasicSearchEngine.createWorkspaceScope();
 			
 						typeNameMatchRequestor
 						scope,
 						this. == null ? null : this...);
 			
 			org.eclipse.jdt.core.ICompilationUnit[] workingCopies = this. == null ? null : JavaModelManager.getJavaModelManager().getWorkingCopies(this.true/*add primary WCs*/);
 			
 			try {
 					null,
 					prefix,
 					scope,
 					requestorWrapper,
 					progressMonitor);
 			} catch (OperationCanceledException e) {
 				// do nothing
 			}
 			requestorWrapper.acceptNotImported();
 		} catch (JavaModelException e) {
 			// do nothing
 		}
 	}
 
 	public AssistParser getParser() {
 		return this.;
 	}
 
 	/*
 	 * Returns whether the given binding is a local/anonymous reference binding, or if its declaring class is
 	 * local.
 	 */
 	private boolean isLocal(ReferenceBinding binding) {
 		if(binding instanceof ParameterizedTypeBinding) {
 		}
 		if (!(binding instanceof SourceTypeBinding)) return false;
 		if (binding instanceof LocalTypeBindingreturn true;
 		if (binding instanceof MemberTypeBinding) {
 		}
 		return false;
 	}

Ask the engine to compute the selection at the specified position of the given compilation unit.

Parameters:
sourceUnit org.eclipse.jdt.internal.compiler.env.ICompilationUnit the source of the current compilation unit.
selectionSourceStart int
selectionSourceEnd int a range in the source where the selection is.
 
 	public void select(
 		ICompilationUnit sourceUnit,
 		int selectionSourceStart,
 		int selectionSourceEnd) {
 
 		char[] source = sourceUnit.getContents();
 
 		if() {
 			..print("SELECTION IN "); //$NON-NLS-1$
 			..print(sourceUnit.getFileName());
 			..print(" FROM "); //$NON-NLS-1$
 			..print(selectionSourceStart);
 			..print(" TO "); //$NON-NLS-1$
 			..println(selectionSourceEnd);
 			..println("SELECTION - Source :"); //$NON-NLS-1$
 			..println(source);
 		}
 		if (!checkSelection(sourceselectionSourceStartselectionSourceEnd)) {
 			return;
 		}
 		if () {
 			..print("SELECTION - Checked : \""); //$NON-NLS-1$
 		}
 		try {
 			this. = false;
 			CompilationResult result = new CompilationResult(sourceUnit, 1, 1, this..);
 				this..dietParse(sourceUnitresultthis.this.);
 
 			if (parsedUnit != null) {
 				if() {
 					..println("SELECTION - Diet AST :"); //$NON-NLS-1$
 					..println(parsedUnit.toString());
 				}
 
 				// scan the package & import statements first
 				if (parsedUnit.currentPackage instanceof SelectionOnPackageReference) {
 					char[][] tokens =
 						((SelectionOnPackageReferenceparsedUnit.currentPackage).;
 					this. = false;
 					this..acceptPackage(CharOperation.concatWith(tokens'.'));
 					return;
 				}
 				ImportReference[] imports = parsedUnit.imports;
 				if (imports != null) {
 					for (int i = 0, length = imports.lengthi < lengthi++) {
 						ImportReference importReference = imports[i];
 						if (importReference instanceof SelectionOnImportReference) {
 							char[][] tokens = ((SelectionOnImportReferenceimportReference).;
 							this. = false;
 							this..acceptPackage(CharOperation.concatWith(tokens'.'));
 							this..findTypes(CharOperation.concatWith(tokens'.'), falsefalse.this);
 
 							this..buildTypeBindings(parsedUnitnull /*no access restriction*/);
 							if ((this. = parsedUnit.scope) != null) {
 								int tokenCount = tokens.length;
 								char[] lastToken = tokens[tokenCount - 1];
 								char[][] qualifierTokens = CharOperation.subarray(tokens, 0, tokenCount - 1);
 
 								if(qualifierTokens != null && qualifierTokens.length > 0) {
 									Binding binding = this..getTypeOrPackage(qualifierTokens);
 									if(binding != null && binding instanceof ReferenceBinding) {
 										ReferenceBinding ref = (ReferenceBindingbinding;
 										selectMemberTypeFromImport(parsedUnitlastTokenrefimportReference.isStatic());
 										if(importReference.isStatic()) {
 											selectStaticFieldFromStaticImport(parsedUnitlastTokenref);
 											selectStaticMethodFromStaticImport(parsedUnitlastTokenref);
 										}
 									}
 								}
 							}
 
 							// accept qualified types only if no unqualified type was accepted
 							if(!this.) {
 								if (!this.) {
 									// try with simple type name
 									if(!this.) {
 									}
 								}
 							}
 							if(this. && this. != null) {
 							}
 							return;
 						}
 					}
 				}
 				if (parsedUnit.types != null || parsedUnit.isPackageInfo()) {
 					if(selectDeclaration(parsedUnit))
 						return;
 					this..buildTypeBindings(parsedUnitnull /*no access restriction*/);
 					if ((this. = parsedUnit.scope)  != null) {
 						try {
 							this..completeTypeBindings(parsedUnittrue);
 							
 							CompilationUnitDeclaration previousUnitBeingCompleted = this..;
 							parsedUnit.scope.faultInTypes();
 							this.. = previousUnitBeingCompleted;
 							ASTNode node = null;
 							if (parsedUnit.types != null)
 								node = parseBlockStatements(parsedUnitselectionSourceStart);
 							if() {
 								..println("SELECTION - AST :"); //$NON-NLS-1$
 								..println(parsedUnit.toString());
 							}
 							parsedUnit.resolve();
 							if (node != null) {
 							}
 						} catch (SelectionNodeFound e) {
 							if (e.binding != null) {
 								if() {
 									..println("SELECTION - Selection binding:"); //$NON-NLS-1$
 									..println(e.binding.toString());
 								}
 								// if null then we found a problem in the selection node
 								selectFrom(e.bindingparsedUnite.isDeclaration);
 							}
 						}
 					}
 				}
 			}
 			// only reaches here if no selection could be derived from the parsed tree
 			// thus use the selected source and perform a textual type search
 			if (!this.) {
 
 				// accept qualified types only if no unqualified type was accepted
 				if(!this.) {
 					
 					// accept types from all the workspace only if no type was found in the project scope
 					if (this.) {
 					}
 				}
 			}
 			if(this. && this. != null) {
 			}
 		} catch (IndexOutOfBoundsException e) { // work-around internal failure - 1GEMF6D
 			if() {
 				..println("Exception caught by SelectionEngine:"); //$NON-NLS-1$
 			}
 		} catch (AbortCompilation e) { // ignore this exception for now since it typically means we cannot find java.lang.Object
 			if() {
 				..println("Exception caught by SelectionEngine:"); //$NON-NLS-1$
 			}
 		} finally {
 			reset(true);
 		}
 	}
 
 	private void selectMemberTypeFromImport(CompilationUnitDeclaration parsedUnitchar[] lastTokenReferenceBinding refboolean staticOnly) {
 		int fieldLength = lastToken.length;
 		ReferenceBinding[] memberTypes = ref.memberTypes();
 		next : for (int j = 0; j < memberTypes.lengthj++) {
 			ReferenceBinding memberType = memberTypes[j];
 
 			if (fieldLength > memberType.sourceName.length)
 				continue next;
 
 			if (staticOnly && !memberType.isStatic())
 				continue next;
 
 			if (!CharOperation.equals(lastTokenmemberType.sourceNametrue))
 				continue next;
 
 			selectFrom(memberTypeparsedUnitfalse);
 		}
	private void selectStaticFieldFromStaticImport(CompilationUnitDeclaration parsedUnitchar[] lastTokenReferenceBinding ref) {
		int fieldLength = lastToken.length;
		FieldBinding[] fields = ref.availableFields();
		next : for (int j = 0; j < fields.lengthj++) {
			FieldBinding field = fields[j];
			if (fieldLength > field.name.length)
				continue next;
			if (field.isSynthetic())
				continue next;
			if (!field.isStatic())
				continue next;
			if (!CharOperation.equals(lastTokenfield.nametrue))
				continue next;
			selectFrom(fieldparsedUnitfalse);
	private void selectStaticMethodFromStaticImport(CompilationUnitDeclaration parsedUnitchar[] lastTokenReferenceBinding ref) {
		int methodLength = lastToken.length;
		MethodBinding[] methods = ref.availableMethods();
		next : for (int j = 0; j < methods.lengthj++) {
			MethodBinding method = methods[j];
			if (method.isSynthetic()) continue next;
			if (method.isDefaultAbstract())	continue next;
			if (method.isConstructor()) continue next;
			if (!method.isStatic()) continue next;
			if (methodLength > method.selector.length)
				continue next;
			if (!CharOperation.equals(lastTokenmethod.selectortrue))
				continue next;
			selectFrom(methodparsedUnitfalse);
	private void selectFrom(Binding bindingCompilationUnitDeclaration parsedUnitboolean isDeclaration) {
		if(binding instanceof TypeVariableBinding) {
			TypeVariableBinding typeVariableBinding = (TypeVariableBindingbinding;
			Binding enclosingElement = typeVariableBinding.declaringElement;
			this. = false;
			if(enclosingElement instanceof SourceTypeBinding) {
				SourceTypeBinding enclosingType = (SourceTypeBindingenclosingElement;
				if (isLocal(enclosingType) && this. instanceof SelectionRequestor) {
else {
						enclosingType.qualifiedPackageName(),
						enclosingType.qualifiedSourceName(),
						typeVariableBinding.sourceName(),
						false,
else if(enclosingElement instanceof MethodBinding) {
				MethodBinding enclosingMethod = (MethodBindingenclosingElement;
				if (isLocal(enclosingMethod.declaringClass) && this. instanceof SelectionRequestor) {
else {
						enclosingMethod.declaringClass.qualifiedPackageName(),
						enclosingMethod.declaringClass.qualifiedSourceName(),
						enclosingMethod.isConstructor()
enclosingMethod.declaringClass.sourceName()
enclosingMethod.selector,
						enclosingMethod.sourceStart(),
						enclosingMethod.sourceEnd(),
						typeVariableBinding.sourceName(),
						false,
			this. = true;
else if (binding instanceof ReferenceBinding) {
			ReferenceBinding typeBinding = (ReferenceBindingbinding;
			if(typeBinding instanceof ProblemReferenceBinding) {
				TypeBinding closestMatch = typeBinding.closestMatch();
				if (closestMatch instanceof ReferenceBinding) {
					typeBinding = (ReferenceBindingclosestMatch;
else {
					typeBinding = null;
			if (typeBinding == nullreturn;
			if (isLocal(typeBinding) && this. instanceof SelectionRequestor) {
				this. = false;