Find Usages Diff Raw Download HTML Widget
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 /
10
  
11
  package org.eclipse.jdt.internal.codeassist;
12
  
15
  import java.util.Locale;
16
  import java.util.Map;
17
  
18
  import  org.eclipse.core.resources.IFile;
19
  import  org.eclipse.core.runtime.IProgressMonitor;
20
  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. 
67
  
68
  public final class SelectionEngine extends Engine implements ISearchRequestor {
69
  	
71
  		
72
  		class AcceptedType {
73
  			public int modifiers;
74
  			public char[] packageName;
75
  			public char[] simpleTypeName;
76
  			public String path;
78
  			
79
  			public AcceptedType(int modifiers, char[] packageName, char[] simpleTypeName, String path, AccessRestriction access) {
80
  				this. = modifiers;
81
  				this. = packageName;
82
  				this. = simpleTypeName;
83
  				this. = path;
84
  				this. = access;
85
  			}
86
  		}
87
  		
89
  		
90
  		private boolean importCachesNodeInitialized = false;
93
  		private char[][][] importsNodeCache;
94
  		private int importsNodeCacheCount;
95
  		
97
  		private ObjectVector notImportedFound = new ObjectVector();
98
  		
99
  		public SelectionTypeNameMatchRequestorWrapper(TypeNameMatchRequestor requestor, IJavaSearchScope scope, ImportReference[] importReferences) {
100
 			super(requestor, scope);
101
 			this. = importReferences;
102
 		}
103
 		
104
 		public void acceptType(int modifiers, char[] packageName, char[] simpleTypeName, char[][] enclosingTypeNames, String path, AccessRestriction access) {
105
 			if (enclosingTypeNames != null && enclosingTypeNames.length > 0) return;
106
 			
108
 			
109
 			char[] fullyQualifiedTypeName = CharOperation.concat(packageName, simpleTypeName, '.');
110
 			
111
 			for (int i = 0; i < this.; i++) {
112
 				char[][] importName = this.[i];
113
 				if (CharOperation.equals(importName[0], simpleTypeName)) {
114
 					
115
 					if(CharOperation.equals(importName[1], fullyQualifiedTypeName)) {
116
 						super.acceptType(modifiers, packageName, simpleTypeName, enclosingTypeNames, path, access);
117
 					}
118
 					return;
119
 				}
120
 			}
121
 			
122
 			for (int i = 0; i < this.; i++) {
123
 				char[][] importName = this.[i].;
124
 				char[] importFlatName = CharOperation.concatWith(importName, '.');
125
 				
126
 				if (CharOperation.equals(importFlatName, packageName)) {
127
 					
128
 					this..put(simpleTypeName, simpleTypeName);
129
 					super.acceptType(modifiers, packageName, simpleTypeName, enclosingTypeNames, path, access);
130
 					return;
131
 				}
132
 			}
133
 			
134
 			
135
 			this..add(new AcceptedType(modifiers, packageName, simpleTypeName, path, access));
136
 		}
137
 		
138
 		public void acceptNotImported() {
139
 			int size = this..size();
140
 			for (int i = 0; i < size; i++) {
142
 				
143
 				if (this..get(acceptedType.simpleTypeName) == null) {
144
 					super.acceptType(
145
 							acceptedType.modifiers,
146
 							acceptedType.packageName,
147
 							acceptedType.simpleTypeName,
148
 							null,
149
 							acceptedType.path,
150
 							acceptedType.access);
151
 				}
152
 			}
153
 		}
154
 		
155
 		public void initializeImportNodeCaches() {
156
 			int length = this. == null ? 0 : this..length;
157
 			
158
 			for (int i = 0; i < length; i++) {
159
 				ImportReference importReference = this.[i];
160
 				if((importReference.bits & .) != 0) {
161
 					if(this. == null) {
162
 						this. = new ImportReference[length - i];
163
 					}
165
 						importReference;
166
 				} else {
167
 					if(this. == null) {
168
 						this. = new char[length - i][][];
169
 					}
170
 					
171
 					
172
 					this.[this.++] = new char[][]{
173
 							importReference.tokens[importReference.tokens.length - 1],
174
 							CharOperation.concatWith(importReference.tokens, '.')
175
 						};
176
 				}
177
 			}
178
 			
180
 		}
181
 	}
182
 
183
 	public static boolean DEBUG = false;
184
 	public static boolean PERF = false;
185
 
189
 
190
 	boolean acceptedAnswer;
191
 
192
 	private int actualSelectionStart;
193
 	private int actualSelectionEnd;
194
 	private char[] selectedIdentifier;
195
 
196
 	private char[][][] acceptedClasses;
197
 	private int[] acceptedClassesModifiers;
198
 	private char[][][] acceptedInterfaces;
199
 	private int[] acceptedInterfacesModifiers;
200
 	private char[][][] acceptedEnums;
201
 	private int[] acceptedEnumsModifiers;
202
 	private char[][][] acceptedAnnotations;
208
 
209
 	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.
228
 
229
 	public SelectionEngine(
230
 		SearchableEnvironment nameEnvironment,
231
 		ISelectionRequestor requestor,
232
 		Map settings,
233
 		WorkingCopyOwner owner) {
234
 
235
 		super(settings);
236
 
237
 		this. = requestor;
238
 		this. = nameEnvironment;
239
 
240
 		ProblemReporter problemReporter =
242
 				DefaultErrorHandlingPolicies.proceedWithAllProblems(),
244
 				new DefaultProblemFactory(Locale.getDefault())) {
245
 
247
 				char[] fileName,
248
 				int problemId,
249
 				String[] problemArguments,
250
 				String[] messageArguments,
251
 				int severity,
252
 				int problemStartPosition,
253
 				int problemEndPosition,
254
 				int lineNumber,
255
 				int columnNumber) {
257
 					fileName,
258
 					problemId,
259
 					problemArguments,
260
 					messageArguments,
261
 					severity,
262
 					problemStartPosition,
263
 					problemEndPosition,
264
 					lineNumber,
265
 					columnNumber);
266
 					if(SelectionEngine.this. == null && pb.isError() && (pb.getID() & .) == 0) {
267
 						SelectionEngine.this. = pb;
268
 					}
269
 
270
 					return pb;
271
 			}
272
 		};
274
 			new LookupEnvironment(this, this., problemReporter, nameEnvironment);
275
 		this. = new SelectionParser(problemReporter);
276
 		this. = owner;
277
 	}
278
 	
279
 	public void acceptConstructor(
280
 			int modifiers,
281
 			char[] simpleTypeName,
282
 			int parameterCount,
283
 			char[] signature,
284
 			char[][] parameterTypes,
285
 			char[][] parameterNames,
286
 			int typeModifiers,
287
 			char[] packageName,
288
 			int extraFlags,
289
 			String path,
290
 			AccessRestriction access) {
291
 		// constructors aren't searched
292
 	}
293
 
294
 	public void acceptType(char[] packageName, char[] simpleTypeName, char[][] enclosingTypeNames, int modifiers, AccessRestriction accessRestriction) {
295
 		char[] typeName = enclosingTypeNames == null ?
296
 				simpleTypeName :
297
 					CharOperation.concat(
298
 						CharOperation.concatWith(enclosingTypeNames, '.'),
299
 						simpleTypeName,
300
 						'.');
301
 
302
 		if (CharOperation.equals(simpleTypeName, this.)) {
303
 			char[] flatEnclosingTypeNames =
304
 				enclosingTypeNames == null || enclosingTypeNames.length == 0 ?
305
 						null :
306
 							CharOperation.concatWith(enclosingTypeNames, '.');
307
 			if(mustQualifyType(packageName, simpleTypeName, flatEnclosingTypeNames, modifiers)) {
308
 				int length = 0;
310
 				switch (kind) {
313
 						char[][] acceptedAnnotation = new char[2][];
314
 						acceptedAnnotation[0] = packageName;
315
 						acceptedAnnotation[1] = typeName;
316
 
317
 						if(this. == null) {
318
 							this. = new char[10][][];
319
 							this. = new int[10];
321
 						}
322
 						length = this..length;
323
 						if(length == this.) {
324
 							int newLength = (length + 1)* 2;
325
 							System.arraycopy(this., 0, this. = new char[newLength][][], 0, length);
326
 							System.arraycopy(this., 0, this. = new int[newLength], 0, length);
327
 						}
329
 						this.[this.++] = acceptedAnnotation;
330
 						break;
332
 						char[][] acceptedEnum = new char[2][];
333
 						acceptedEnum[0] = packageName;
334
 						acceptedEnum[1] = typeName;
335
 
336
 						if(this. == null) {
337
 							this. = new char[10][][];
338
 							this. = new int[10];
339
 							this. = 0;
340
 						}
341
 						length = this..length;
342
 						if(length == this.) {
343
 							int newLength = (length + 1)* 2;
344
 							System.arraycopy(this., 0, this. = new char[newLength][][], 0, length);
345
 							System.arraycopy(this., 0, this. = new int[newLength], 0, length);
346
 						}
347
 						this.[this.] = modifiers;
348
 						this.[this.++] = acceptedEnum;
349
 						break;
351
 						char[][] acceptedInterface= new char[2][];
352
 						acceptedInterface[0] = packageName;
353
 						acceptedInterface[1] = typeName;
354
 
355
 						if(this. == null) {
356
 							this. = new char[10][][];
357
 							this. = new int[10];
359
 						}
360
 						length = this..length;
361
 						if(length == this.) {
362
 							int newLength = (length + 1)* 2;
363
 							System.arraycopy(this., 0, this. = new char[newLength][][], 0, length);
364
 							System.arraycopy(this., 0, this. = new int[newLength], 0, length);
365
 						}
367
 						this.[this.++] = acceptedInterface;
368
 						break;
369
 					default:
370
 						char[][] acceptedClass = new char[2][];
371
 						acceptedClass[0] = packageName;
372
 						acceptedClass[1] = typeName;
373
 
374
 						if(this. == null) {
375
 							this. = new char[10][][];
376
 							this. = new int[10];
378
 						}
379
 						length = this..length;
380
 						if(length == this.) {
381
 							int newLength = (length + 1)* 2;
382
 							System.arraycopy(this., 0, this. = new char[newLength][][], 0, length);
383
 							System.arraycopy(this., 0, this. = new int[newLength], 0, length);
384
 						}
386
 						this.[this.++] = acceptedClass;
387
 						break;
388
 				}
389
 			} else {
390
 				this. = false;
392
 					packageName,
393
 					typeName,
394
 					modifiers,
395
 					false,
396
 					null,
399
 				this. = true;
400
 			}
401
 		}
402
 	}
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.
411
 
412
 	public void acceptPackage(char[] packageName) {
413
 		// implementation of interface method
414
 	}
415
 
416
 	private void acceptQualifiedTypes() {
417
 		if(this. != null){
418
 			this. = true;
419
 			for (int i = 0; i < this.; i++) {
420
 				this. = false;
422
 					this.[i][0],
423
 					this.[i][1],
425
 					false,
426
 					null,
429
 			}
430
 			this. = null;
431
 			this. = null;
433
 		}
434
 		if(this. != null){
435
 			this. = true;
436
 			for (int i = 0; i < this.; i++) {
437
 				this. = false;
439
 					this.[i][0],
440
 					this.[i][1],
442
 					false,
443
 					null,
446
 			}
447
 			this. = null;
450
 		}
451
 		if(this. != null){
452
 			this. = true;
453
 			for (int i = 0; i < this.; i++) {
454
 				this. = false;
456
 					this.[i][0],
457
 					this.[i][1],
459
 					false,
460
 					null,
463
 			}
464
 			this. = null;
467
 		}
468
 		if(this. != null){
469
 			this. = true;
470
 			for (int i = 0; i < this.; i++) {
471
 				this. = false;
473
 					this.[i][0],
474
 					this.[i][1],
476
 					false,
477
 					null,
480
 			}
481
 			this. = null;
482
 			this. = null;
483
 			this. = 0;
484
 		}
485
 	}
486
 	private boolean checkSelection(
487
 			char[] source,
488
 			int selectionStart,
489
 			int selectionEnd) {
490
 
491
 		Scanner scanner =
492
 			new Scanner(
493
 				false /*comment*/,
494
 				false /*whitespace*/,
495
 				false /*nls*/,
498
 				null/*taskTag*/,
499
 				null/*taskPriorities*/,
500
 				true /*taskCaseSensitive*/);
501
 		scanner.setSource(source);
502
 
503
 		int lastIdentifierStart = -1;
504
 		int lastIdentifierEnd = -1;
505
 		char[] lastIdentifier = null;
506
 		int token;
507
 
508
 		if(selectionStart > selectionEnd){
509
 			int end = source.length - 1;
510
 
511
 			// compute start position of current line
512
 			int currentPosition = selectionStart - 1;
513
 			int nextCharacterPosition = selectionStart;
514
 			char currentCharacter = ' ';
515
 			try {
516
 				lineLoop: while(currentPosition > 0){
517
 
518
 					if(source[currentPosition] == '\\' && source[currentPosition+1] == 'u') {
519
 						int pos = currentPosition + 2;
520
 						int c1 = 0, c2 = 0, c3 = 0, c4 = 0;
521
 						while (source[pos] == 'u') {
522
 							pos++;
523
 						}
524
 
525
 						int endOfUnicode = pos + 3;
526
 						if (end < endOfUnicode) {
527
 							if (endOfUnicode < source.length) {
528
 								end = endOfUnicode;
529
 							} else {
530
 								return false; // not enough characters to decode an unicode
531
 							}
532
 						}
533
 
534
 						if ((c1 = ScannerHelper.getHexadecimalValue(source[pos++])) > 15
535
 							|| c1 < 0
536
 							|| (c2 = ScannerHelper.getHexadecimalValue(source[pos++])) > 15
537
 							|| c2 < 0
538
 							|| (c3 = ScannerHelper.getHexadecimalValue(source[pos++])) > 15
539
 							|| c3 < 0
540
 							|| (c4 = ScannerHelper.getHexadecimalValue(source[pos++])) > 15
541
 							|| c4 < 0) {
542
 							return false;
543
 						} else {
544
 							currentCharacter = (char) (((c1 * 16 + c2) * 16 + c3) * 16 + c4);
545
 							nextCharacterPosition = pos;
546
 						}
547
 					} else {
548
 						currentCharacter = source[currentPosition];
549
 						nextCharacterPosition = currentPosition+1;
550
 					}
551
 
552
 					switch(currentCharacter) {
553
 						case '\r':
554
 						case '\n':
555
 						case '/':
556
 						case '"':
557
 						case '\'':
558
 							break lineLoop;
559
 					}
560
 					currentPosition--;
561
 				}
563
 				return false;
564
 			}
565
 
566
 			// compute start and end of the last token
567
 			scanner.resetTo(nextCharacterPosition, end);
568
 			isolateLastName: do {
569
 				try {
570
 					token = scanner.getNextToken();
571
 				} catch (InvalidInputException e) {
572
 					return false;
573
 				}
574
 				switch (token) {
578
 						if (scanner.startPosition <= selectionStart && selectionStart <= scanner.currentPosition) {
579
 							if (scanner.currentPosition == scanner.eofPosition) {
580
 								int temp = scanner.eofPosition;
581
 								scanner.eofPosition = scanner.source.length;
582
 							 	while(scanner.getNextCharAsJavaIdentifierPart()){/*empty*/}
583
 							 	scanner.eofPosition = temp;
584
 							}
585
 							lastIdentifierStart = scanner.startPosition;
586
 							lastIdentifierEnd = scanner.currentPosition - 1;
587
 							lastIdentifier = scanner.getCurrentTokenSource();
588
 							break isolateLastName;
589
 						}
590
 						break;
591
 				}
592
 			} while (token != .);
593
 		} else {
594
 			scanner.resetTo(selectionStart, selectionEnd);
595
 
596
 			boolean expectingIdentifier = true;
597
 			do {
598
 				try {
599
 					token = scanner.getNextToken();
600
 				} catch (InvalidInputException e) {
601
 					return false;
602
 				}
603
 				switch (token) {
607
 						if (!expectingIdentifier)
608
 							return false;
609
 						lastIdentifier = scanner.getCurrentTokenSource();
610
 						lastIdentifierStart = scanner.startPosition;
611
 						lastIdentifierEnd = scanner.currentPosition - 1;
612
 						if(lastIdentifierEnd > selectionEnd) {
613
 							lastIdentifierEnd = selectionEnd;
614
 							lastIdentifier = CharOperation.subarray(lastIdentifier, 0,lastIdentifierEnd - lastIdentifierStart + 1);
615
 						}
616
 						expectingIdentifier = false;
617
 						break;
619
 						if (expectingIdentifier)
620
 							return false;
621
 						expectingIdentifier = true;
622
 						break;
624
 						if (expectingIdentifier)
625
 							return false;
626
 						break;
628
 						if(!checkTypeArgument(scanner))
629
 							return false;
630
 						break;
632
 						if(scanner.startPosition != scanner.initialPosition)
633
 							return false;
634
 						break;
635
 					default :
636
 						return false;
637
 				}
638
 			} while (token != .);
639
 		}
640
 		if (lastIdentifierStart > 0) {
641
 			this. = lastIdentifierStart;
642
 			this. = lastIdentifierEnd;
643
 			this. = lastIdentifier;
644
 			return true;
645
 		}
646
 		return false;
647
 	}
648
 	private boolean checkTypeArgument(Scanner scanner) {
649
 		int depth = 1;
650
 		int token;
651
 		StringBuffer buffer = new StringBuffer();
652
 		do {
653
 			try {
654
 				token = scanner.getNextToken();
655
 			} catch (InvalidInputException e) {
656
 				return false;
657
 			}
658
 			switch(token) {
660
 					depth++;
661
 					buffer.append(scanner.getCurrentTokenSource());
662
 					break;
664
 					depth--;
665
 					buffer.append(scanner.getCurrentTokenSource());
666
 					break;
668
 					depth-=2;
669
 					buffer.append(scanner.getCurrentTokenSource());
670
 					break;
672
 					depth-=3;
673
 					buffer.append(scanner.getCurrentTokenSource());
674
 					break;
677
 					buffer.append(' ');
678
 					buffer.append(scanner.getCurrentTokenSource());
679
 					buffer.append(' ');
680
 					break;
682
 					if(depth == 1) {
683
 						int length = buffer.length();
684
 						char[] typeRef = new char[length];
685
 						buffer.getChars(0, length, typeRef, 0);
686
 						try {
687
 							Signature.createTypeSignature(typeRef, true);
688
 							buffer = new StringBuffer();
689
 						} catch(IllegalArgumentException e) {
690
 							return false;
691
 						}
692
 					}
693
 					break;
694
 				default :
695
 					buffer.append(scanner.getCurrentTokenSource());
696
 					break;
697
 
698
 			}
699
 			if(depth < 0) {
700
 				return false;
701
 			}
702
 		} while (depth != 0 && token != .);
703
 
704
 		if(depth == 0) {
705
 			int length = buffer.length() - 1;
706
 			char[] typeRef = new char[length];
707
 			buffer.getChars(0, length, typeRef, 0);
708
 			try {
709
 				Signature.createTypeSignature(typeRef, true);
710
 				return true;
711
 			} catch(IllegalArgumentException e) {
712
 				return false;
713
 			}
714
 		}
715
 
716
 		return false;
717
 	}
718
 	
719
 	/*
720
 	 * find all types outside the project scope
721
 	 */
722
 	private void findAllTypes(char[] prefix) {
723
 		try {
724
 			IProgressMonitor progressMonitor = new IProgressMonitor() {
725
 				boolean isCanceled = false;
726
 				public void beginTask(String name, int totalWork) {
727
 					// implements interface method
728
 				}
729
 				public void done() {
730
 					// implements interface method
731
 				}
732
 				public void internalWorked(double work) {
733
 					// implements interface method
734
 				}
735
 				public boolean isCanceled() {
736
 					return this.;
737
 				}
738
 				public void setCanceled(boolean value) {
739
 					this. = value;
740
 				}
741
 				public void setTaskName(String name) {
742
 					// implements interface method
743
 				}
744
 				public void subTask(String name) {
745
 					// implements interface method
746
 				}
747
 				public void worked(int work) {
748
 					// implements interface method
749
 				}
750
 			};
751
 			
752
 			TypeNameMatchRequestor typeNameMatchRequestor = new TypeNameMatchRequestor() {
753
 				public void acceptTypeNameMatch(TypeNameMatch match) {
754
 					if (SelectionEngine.this. instanceof SelectionRequestor) {
755
 						SelectionEngine.this. = false;
757
 					}
758
 				}
759
 			};
760
 			
761
 			IJavaSearchScope scope = BasicSearchEngine.createWorkspaceScope();
762
 			
765
 						typeNameMatchRequestor, 
766
 						scope,
767
 						this. == null ? null : this...);
768
 			
769
 			org.eclipse.jdt.core.ICompilationUnit[] workingCopies = this. == null ? null : JavaModelManager.getJavaModelManager().getWorkingCopies(this., true/*add primary WCs*/);
770
 			
771
 			try {
773
 					null,
775
 					prefix,
778
 					scope,
779
 					requestorWrapper,
781
 					progressMonitor);
782
 			} catch (OperationCanceledException e) {
783
 				// do nothing
784
 			}
785
 			requestorWrapper.acceptNotImported();
786
 		} catch (JavaModelException e) {
787
 			// do nothing
788
 		}
789
 	}
790
 
791
 	public AssistParser getParser() {
792
 		return this.;
793
 	}
794
 
795
 	/*
796
 	 * Returns whether the given binding is a local/anonymous reference binding, or if its declaring class is
797
 	 * local.
798
 	 */
799
 	private boolean isLocal(ReferenceBinding binding) {
800
 		if(binding instanceof ParameterizedTypeBinding) {
802
 		}
803
 		if (!(binding instanceof SourceTypeBinding)) return false;
804
 		if (binding instanceof LocalTypeBinding) return true;
805
 		if (binding instanceof MemberTypeBinding) {
807
 		}
808
 		return false;
809
 	}
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.
821
 
822
 	public void select(
823
 		ICompilationUnit sourceUnit,
824
 		int selectionSourceStart,
825
 		int selectionSourceEnd) {
826
 
827
 		char[] source = sourceUnit.getContents();
828
 
829
 		if() {
830
 			..print("SELECTION IN "); //$NON-NLS-1$
831
 			..print(sourceUnit.getFileName());
832
 			..print(" FROM "); //$NON-NLS-1$
833
 			..print(selectionSourceStart);
834
 			..print(" TO "); //$NON-NLS-1$
835
 			..println(selectionSourceEnd);
836
 			..println("SELECTION - Source :"); //$NON-NLS-1$
837
 			..println(source);
838
 		}
839
 		if (!checkSelection(source, selectionSourceStart, selectionSourceEnd)) {
840
 			return;
841
 		}
842
 		if () {
843
 			..print("SELECTION - Checked : \""); //$NON-NLS-1$
846
 		}
847
 		try {
848
 			this. = false;
849
 			CompilationResult result = new CompilationResult(sourceUnit, 1, 1, this..);
851
 				this..dietParse(sourceUnit, result, this., this.);
852
 
853
 			if (parsedUnit != null) {
854
 				if() {
855
 					..println("SELECTION - Diet AST :"); //$NON-NLS-1$
856
 					..println(parsedUnit.toString());
857
 				}
858
 
859
 				// scan the package & import statements first
860
 				if (parsedUnit.currentPackage instanceof SelectionOnPackageReference) {
861
 					char[][] tokens =
862
 						((SelectionOnPackageReference) parsedUnit.currentPackage).;
863
 					this. = false;
864
 					this..acceptPackage(CharOperation.concatWith(tokens, '.'));
865
 					return;
866
 				}
867
 				ImportReference[] imports = parsedUnit.imports;
868
 				if (imports != null) {
869
 					for (int i = 0, length = imports.length; i < length; i++) {
870
 						ImportReference importReference = imports[i];
871
 						if (importReference instanceof SelectionOnImportReference) {
872
 							char[][] tokens = ((SelectionOnImportReference) importReference).;
873
 							this. = false;
874
 							this..acceptPackage(CharOperation.concatWith(tokens, '.'));
875
 							this..findTypes(CharOperation.concatWith(tokens, '.'), false, false, ., this);
876
 
877
 							this..buildTypeBindings(parsedUnit, null /*no access restriction*/);
878
 							if ((this. = parsedUnit.scope) != null) {
879
 								int tokenCount = tokens.length;
880
 								char[] lastToken = tokens[tokenCount - 1];
881
 								char[][] qualifierTokens = CharOperation.subarray(tokens, 0, tokenCount - 1);
882
 
883
 								if(qualifierTokens != null && qualifierTokens.length > 0) {
884
 									Binding binding = this..getTypeOrPackage(qualifierTokens);
885
 									if(binding != null && binding instanceof ReferenceBinding) {
886
 										ReferenceBinding ref = (ReferenceBinding) binding;
887
 										selectMemberTypeFromImport(parsedUnit, lastToken, ref, importReference.isStatic());
888
 										if(importReference.isStatic()) {
889
 											selectStaticFieldFromStaticImport(parsedUnit, lastToken, ref);
890
 											selectStaticMethodFromStaticImport(parsedUnit, lastToken, ref);
891
 										}
892
 									}
893
 								}
894
 							}
895
 
896
 							// accept qualified types only if no unqualified type was accepted
897
 							if(!this.) {
899
 								if (!this.) {
901
 									// try with simple type name
902
 									if(!this.) {
904
 									}
905
 								}
906
 							}
907
 							if(this. && this. != null) {
909
 							}
910
 							return;
911
 						}
912
 					}
913
 				}
914
 				if (parsedUnit.types != null || parsedUnit.isPackageInfo()) {
915
 					if(selectDeclaration(parsedUnit))
916
 						return;
917
 					this..buildTypeBindings(parsedUnit, null /*no access restriction*/);
918
 					if ((this. = parsedUnit.scope)  != null) {
919
 						try {
920
 							this..completeTypeBindings(parsedUnit, true);
921
 							
922
 							CompilationUnitDeclaration previousUnitBeingCompleted = this..;
924
 							parsedUnit.scope.faultInTypes();
925
 							this.. = previousUnitBeingCompleted;
926
 							ASTNode node = null;
927
 							if (parsedUnit.types != null)
928
 								node = parseBlockStatements(parsedUnit, selectionSourceStart);
929
 							if() {
930
 								..println("SELECTION - AST :"); //$NON-NLS-1$
931
 								..println(parsedUnit.toString());
932
 							}
933
 							parsedUnit.resolve();
934
 							if (node != null) {
936
 							}
937
 						} catch (SelectionNodeFound e) {
938
 							if (e.binding != null) {
939
 								if() {
940
 									..println("SELECTION - Selection binding:"); //$NON-NLS-1$
941
 									..println(e.binding.toString());
942
 								}
943
 								// if null then we found a problem in the selection node
944
 								selectFrom(e.binding, parsedUnit, e.isDeclaration);
945
 							}
946
 						}
947
 					}
948
 				}
949
 			}
950
 			// only reaches here if no selection could be derived from the parsed tree
951
 			// thus use the selected source and perform a textual type search
952
 			if (!this.) {
954
 
955
 				// accept qualified types only if no unqualified type was accepted
956
 				if(!this.) {
958
 					
959
 					// accept types from all the workspace only if no type was found in the project scope
960
 					if (this.) {
962
 					}
963
 				}
964
 			}
965
 			if(this. && this. != null) {
967
 			}
968
 		} catch (IndexOutOfBoundsException e) { // work-around internal failure - 1GEMF6D
969
 			if() {
970
 				..println("Exception caught by SelectionEngine:"); //$NON-NLS-1$
972
 			}
973
 		} catch (AbortCompilation e) { // ignore this exception for now since it typically means we cannot find java.lang.Object
974
 			if() {
975
 				..println("Exception caught by SelectionEngine:"); //$NON-NLS-1$
977
 			}
978
 		} finally {
979
 			reset(true);
980
 		}
981
 	}
982
 
983
 	private void selectMemberTypeFromImport(CompilationUnitDeclaration parsedUnit, char[] lastToken, ReferenceBinding ref, boolean staticOnly) {
984
 		int fieldLength = lastToken.length;
985
 		ReferenceBinding[] memberTypes = ref.memberTypes();
986
 		next : for (int j = 0; j < memberTypes.length; j++) {
987
 			ReferenceBinding memberType = memberTypes[j];
988
 
989
 			if (fieldLength > memberType.sourceName.length)
990
 				continue next;
991
 
992
 			if (staticOnly && !memberType.isStatic())
993
 				continue next;
994
 
995
 			if (!CharOperation.equals(lastToken, memberType.sourceName, true))
996
 				continue next;
997
 
998
 			selectFrom(memberType, parsedUnit, false);
999
 		}
1002
	private void selectStaticFieldFromStaticImport(CompilationUnitDeclaration parsedUnit, char[] lastToken, ReferenceBinding ref) {
1003
		int fieldLength = lastToken.length;
1004
		FieldBinding[] fields = ref.availableFields();
1005
		next : for (int j = 0; j < fields.length; j++) {
1006
			FieldBinding field = fields[j];
1008
			if (fieldLength > field.name.length)
1009
				continue next;
1011
			if (field.isSynthetic())
1012
				continue next;
1014
			if (!field.isStatic())
1015
				continue next;
1017
			if (!CharOperation.equals(lastToken, field.name, true))
1018
				continue next;
1020
			selectFrom(field, parsedUnit, false);
1024
	private void selectStaticMethodFromStaticImport(CompilationUnitDeclaration parsedUnit, char[] lastToken, ReferenceBinding ref) {
1025
		int methodLength = lastToken.length;
1026
		MethodBinding[] methods = ref.availableMethods();
1027
		next : for (int j = 0; j < methods.length; j++) {
1028
			MethodBinding method = methods[j];
1030
			if (method.isSynthetic()) continue next;
1032
			if (method.isDefaultAbstract())	continue next;
1034
			if (method.isConstructor()) continue next;
1036
			if (!method.isStatic()) continue next;
1038
			if (methodLength > method.selector.length)
1039
				continue next;
1041
			if (!CharOperation.equals(lastToken, method.selector, true))
1042
				continue next;
1044
			selectFrom(method, parsedUnit, false);
1048
	private void selectFrom(Binding binding, CompilationUnitDeclaration parsedUnit, boolean isDeclaration) {
1049
		if(binding instanceof TypeVariableBinding) {
1050
			TypeVariableBinding typeVariableBinding = (TypeVariableBinding) binding;
1051
			Binding enclosingElement = typeVariableBinding.declaringElement;
1052
			this. = false;
1054
			if(enclosingElement instanceof SourceTypeBinding) {
1055
				SourceTypeBinding enclosingType = (SourceTypeBinding) enclosingElement;
1056
				if (isLocal(enclosingType) && this. instanceof SelectionRequestor) {
1058
				} else {
1060
						enclosingType.qualifiedPackageName(),
1061
						enclosingType.qualifiedSourceName(),
1062
						typeVariableBinding.sourceName(),
1063
						false,
1067
			} else if(enclosingElement instanceof MethodBinding) {
1068
				MethodBinding enclosingMethod = (MethodBinding) enclosingElement;
1069
				if (isLocal(enclosingMethod.declaringClass) && this. instanceof SelectionRequestor) {
1071
				} else {
1073
						enclosingMethod.declaringClass.qualifiedPackageName(),
1074
						enclosingMethod.declaringClass.qualifiedSourceName(),
1075
						enclosingMethod.isConstructor()
1076
								? enclosingMethod.declaringClass.sourceName()
1077
								: enclosingMethod.selector,
1078
						enclosingMethod.sourceStart(),
1079
						enclosingMethod.sourceEnd(),
1080
						typeVariableBinding.sourceName(),
1081
						false,
1086
			this. = true;
1087
		} else if (binding instanceof ReferenceBinding) {
1088
			ReferenceBinding typeBinding = (ReferenceBinding) binding;
1089
			if(typeBinding instanceof ProblemReferenceBinding) {
1090
				TypeBinding closestMatch = typeBinding.closestMatch();
1091
				if (closestMatch instanceof ReferenceBinding) {
1092
					typeBinding = (ReferenceBinding) closestMatch;
1093
				} else {
1094
					typeBinding = null;
1097
			if (typeBinding == null) return;
1098
			if (isLocal(typeBinding) && this. instanceof SelectionRequestor) {
1099
				this. = false;