fce07546a5933597176614296b59ec5ff4d6dfcf
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / codeassist / SelectionEngine.java
1 /*******************************************************************************
2  * Copyright (c) 2000, 2001, 2002 International Business Machines Corp. and others.
3  * All rights reserved. This program and the accompanying materials 
4  * are made available under the terms of the Common Public License v0.5 
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/cpl-v05.html
7  * 
8  * Contributors:
9  *     IBM Corporation - initial API and implementation
10  ******************************************************************************/
11 package net.sourceforge.phpdt.internal.codeassist;
12
13 import java.util.Locale;
14 import java.util.Map;
15
16 import net.sourceforge.phpdt.core.compiler.IProblem;
17 import net.sourceforge.phpdt.core.compiler.ITerminalSymbols;
18 import net.sourceforge.phpdt.core.compiler.InvalidInputException;
19 import net.sourceforge.phpdt.internal.codeassist.impl.AssistParser;
20 import net.sourceforge.phpdt.internal.codeassist.impl.Engine;
21 import net.sourceforge.phpdt.internal.codeassist.select.SelectionNodeFound;
22 import net.sourceforge.phpdt.internal.codeassist.select.SelectionOnImportReference;
23 import net.sourceforge.phpdt.internal.codeassist.select.SelectionOnPackageReference;
24 import net.sourceforge.phpdt.internal.codeassist.select.SelectionOnQualifiedTypeReference;
25 import net.sourceforge.phpdt.internal.codeassist.select.SelectionOnSingleTypeReference;
26 import net.sourceforge.phpdt.internal.codeassist.select.SelectionParser;
27 import net.sourceforge.phpdt.internal.compiler.CompilationResult;
28 import net.sourceforge.phpdt.internal.compiler.DefaultErrorHandlingPolicies;
29 import net.sourceforge.phpdt.internal.compiler.ast.AbstractMethodDeclaration;
30 import net.sourceforge.phpdt.internal.compiler.ast.CompilationUnitDeclaration;
31 import net.sourceforge.phpdt.internal.compiler.ast.FieldDeclaration;
32 import net.sourceforge.phpdt.internal.compiler.ast.ImportReference;
33 import net.sourceforge.phpdt.internal.compiler.ast.TypeDeclaration;
34 import net.sourceforge.phpdt.internal.compiler.env.ICompilationUnit;
35 import net.sourceforge.phpdt.internal.compiler.env.ISourceType;
36 import net.sourceforge.phpdt.internal.compiler.impl.ReferenceContext;
37 import net.sourceforge.phpdt.internal.compiler.lookup.ArrayBinding;
38 import net.sourceforge.phpdt.internal.compiler.lookup.BaseTypeBinding;
39 import net.sourceforge.phpdt.internal.compiler.lookup.Binding;
40 import net.sourceforge.phpdt.internal.compiler.lookup.FieldBinding;
41 import net.sourceforge.phpdt.internal.compiler.lookup.LocalVariableBinding;
42 import net.sourceforge.phpdt.internal.compiler.lookup.LookupEnvironment;
43 import net.sourceforge.phpdt.internal.compiler.lookup.MethodBinding;
44 import net.sourceforge.phpdt.internal.compiler.lookup.PackageBinding;
45 import net.sourceforge.phpdt.internal.compiler.lookup.ProblemReferenceBinding;
46 import net.sourceforge.phpdt.internal.compiler.lookup.ReferenceBinding;
47 import net.sourceforge.phpdt.internal.compiler.lookup.TypeBinding;
48 import net.sourceforge.phpdt.internal.compiler.parser.Scanner;
49 import net.sourceforge.phpdt.internal.compiler.parser.SourceTypeConverter;
50 import net.sourceforge.phpdt.internal.compiler.problem.AbortCompilation;
51 import net.sourceforge.phpdt.internal.compiler.problem.DefaultProblemFactory;
52 import net.sourceforge.phpdt.internal.compiler.problem.ProblemReporter;
53 import net.sourceforge.phpdt.internal.compiler.util.CharOperation;
54
55 /**
56  * The selection engine is intended to infer the nature of a selected name in some
57  * source code. This name can be qualified.
58  *
59  * Selection is resolving context using a name environment (no need to search), assuming
60  * the source where selection occurred is correct and will not perform any completion
61  * attempt. If this was the desired behavior, a call to the CompletionEngine should be
62  * performed instead.
63  */
64 public final class SelectionEngine extends Engine implements ISearchRequestor {
65
66         public static boolean DEBUG = false;
67         
68         SelectionParser parser;
69         ISelectionRequestor requestor;
70
71         boolean acceptedAnswer;
72
73         private int actualSelectionStart;
74         private int actualSelectionEnd;
75         private char[] qualifiedSelection;
76         private char[] selectedIdentifier;
77         
78         private char[][][] acceptedClasses;
79         private char[][][] acceptedInterfaces;
80         int acceptedClassesCount;
81         int acceptedInterfacesCount;
82
83         /**
84          * The SelectionEngine is responsible for computing the selected object.
85          *
86          * It requires a searchable name environment, which supports some
87          * specific search APIs, and a requestor to feed back the results to a UI.
88          *
89          *  @param nameEnvironment net.sourceforge.phpdt.internal.codeassist.ISearchableNameEnvironment
90          *      used to resolve type/package references and search for types/packages
91          *      based on partial names.
92          *
93          *  @param requestor net.sourceforge.phpdt.internal.codeassist.ISelectionRequestor
94          *      since the engine might produce answers of various forms, the engine 
95          *      is associated with a requestor able to accept all possible completions.
96          *
97          *  @param settings java.util.Map
98          *              set of options used to configure the code assist engine.
99          */
100         public SelectionEngine(
101                 ISearchableNameEnvironment nameEnvironment,
102                 ISelectionRequestor requestor,
103                 Map settings) {
104
105                 super(settings);
106
107                 this.requestor = requestor;
108                 this.nameEnvironment = nameEnvironment;
109
110                 ProblemReporter problemReporter =
111                         new ProblemReporter(
112                                 DefaultErrorHandlingPolicies.proceedWithAllProblems(),
113                                 this.compilerOptions,
114                                 new DefaultProblemFactory(Locale.getDefault())) {
115                         public void record(IProblem problem, CompilationResult unitResult, ReferenceContext referenceContext) {
116                                 unitResult.record(problem, referenceContext);
117                                 SelectionEngine.this.requestor.acceptError(problem);
118                         }
119                 };
120                 this.parser = new SelectionParser(problemReporter, this.compilerOptions.assertMode);
121                 this.lookupEnvironment =
122                         new LookupEnvironment(this, this.compilerOptions, problemReporter, nameEnvironment);
123         }
124
125         /**
126          * One result of the search consists of a new class.
127          * @param packageName char[]
128          * @param className char[]
129          * @param modifiers int
130          *
131          * NOTE - All package and type names are presented in their readable form:
132          *    Package names are in the form "a.b.c".
133          *    Nested type names are in the qualified form "A.M".
134          *    The default package is represented by an empty array.
135          */
136         public void acceptClass(char[] packageName, char[] className, int modifiers) {
137                 if (CharOperation.equals(className, selectedIdentifier)) {
138                         if (qualifiedSelection != null
139                                 && !CharOperation.equals(
140                                         qualifiedSelection,
141                                         CharOperation.concat(packageName, className, '.'))) {
142                                 return;
143                         }
144                         
145                         if(mustQualifyType(packageName, className)) {
146                                 char[][] acceptedClass = new char[2][];
147                                 acceptedClass[0] = packageName;
148                                 acceptedClass[1] = className;
149                                 
150                                 if(acceptedClasses == null) {
151                                         acceptedClasses = new char[10][][];
152                                         acceptedClassesCount = 0;
153                                 }
154                                 int length = acceptedClasses.length;
155                                 if(length == acceptedClassesCount) {
156                                         System.arraycopy(acceptedClasses, 0, acceptedClasses = new char[(length + 1)* 2][][], 0, length);
157                                 }
158                                 acceptedClasses[acceptedClassesCount++] = acceptedClass;
159                                 
160                         } else {
161                                 requestor.acceptClass(
162                                         packageName,
163                                         className,
164                                         false);
165                                 acceptedAnswer = true;
166                         }
167                 }
168         }
169
170         /**
171          * One result of the search consists of a new interface.
172          *
173          * NOTE - All package and type names are presented in their readable form:
174          *    Package names are in the form "a.b.c".
175          *    Nested type names are in the qualified form "A.I".
176          *    The default package is represented by an empty array.
177          */
178         public void acceptInterface(
179                 char[] packageName,
180                 char[] interfaceName,
181                 int modifiers) {
182
183                 if (CharOperation.equals(interfaceName, selectedIdentifier)) {
184                         if (qualifiedSelection != null
185                                 && !CharOperation.equals(
186                                         qualifiedSelection,
187                                         CharOperation.concat(packageName, interfaceName, '.'))) {
188                                 return;
189                         }
190                         
191                         if(mustQualifyType(packageName, interfaceName)) {
192                                 char[][] acceptedInterface= new char[2][];
193                                 acceptedInterface[0] = packageName;
194                                 acceptedInterface[1] = interfaceName;
195                                 
196                                 if(acceptedInterfaces == null) {
197                                         acceptedInterfaces = new char[10][][];
198                                         acceptedInterfacesCount = 0;
199                                 }
200                                 int length = acceptedInterfaces.length;
201                                 if(length == acceptedInterfacesCount) {
202                                         System.arraycopy(acceptedInterfaces, 0, acceptedInterfaces = new char[(length + 1) * 2][][], 0, length);
203                                 }
204                                 acceptedInterfaces[acceptedInterfacesCount++] = acceptedInterface;
205                                 
206                         } else {
207                                 requestor.acceptInterface(
208                                         packageName,
209                                         interfaceName,
210                                         false);
211                                 acceptedAnswer = true;
212                         }
213                 }
214         }
215
216         /**
217          * One result of the search consists of a new package.
218          * @param packageName char[]
219          * 
220          * NOTE - All package names are presented in their readable form:
221          *    Package names are in the form "a.b.c".
222          *    The default package is represented by an empty array.
223          */
224         public void acceptPackage(char[] packageName) {
225         }
226
227         private void acceptQualifiedTypes() {
228                 if(acceptedClasses != null){
229                         acceptedAnswer = true;
230                         for (int i = 0; i < acceptedClassesCount; i++) {
231                                 requestor.acceptClass(
232                                         acceptedClasses[i][0],
233                                         acceptedClasses[i][1],
234                                         true);
235                         }
236                         acceptedClasses = null;
237                         acceptedClassesCount = 0;
238                 }
239                 if(acceptedInterfaces != null){
240                         acceptedAnswer = true;
241                         for (int i = 0; i < acceptedInterfacesCount; i++) {
242                                 requestor.acceptInterface(
243                                         acceptedInterfaces[i][0],
244                                         acceptedInterfaces[i][1],
245                                         true);
246                         }
247                         acceptedInterfaces = null;
248                         acceptedInterfacesCount = 0;
249                 }
250         }
251         
252         /**
253          * One result of the search consists of a new type.
254          * @param packageName char[]
255          * @param typeName char[]
256          * 
257          * NOTE - All package and type names are presented in their readable form:
258          *    Package names are in the form "a.b.c".
259          *    Nested type names are in the qualified form "A.M".
260          *    The default package is represented by an empty array.
261          */
262         public void acceptType(char[] packageName, char[] typeName) {
263                 acceptClass(packageName, typeName, 0);
264         }
265
266         private boolean checkSelection(
267                 char[] source,
268                 int selectionStart,
269                 int selectionEnd) {
270
271                 Scanner scanner = new Scanner();
272                 scanner.setSource(source);
273                 
274                 int lastIdentifierStart = -1;
275                 int lastIdentifierEnd = -1;
276                 char[] lastIdentifier = null;
277                 int token, identCount = 0;
278                 StringBuffer entireSelection = new StringBuffer(selectionEnd - selectionStart + 1);
279                 
280                 if(selectionStart > selectionEnd){
281                         
282                         // compute start position of current line
283                         int currentPosition = selectionStart - 1;
284                         int nextCharacterPosition = selectionStart;
285                         char currentCharacter = ' ';
286                         try {
287                                 while(currentPosition > 0 || currentCharacter == '\r' || currentCharacter == '\n'){
288                                         
289                                         if(source[currentPosition] == '\\' && source[currentPosition+1] == 'u') {
290                                                 int pos = currentPosition + 2;
291                                                 int c1 = 0, c2 = 0, c3 = 0, c4 = 0;
292                                                 while (source[pos] == 'u') {
293                                                         pos++;
294                                                 }
295                                                 if ((c1 = Character.getNumericValue(source[pos++])) > 15
296                                                         || c1 < 0
297                                                         || (c2 = Character.getNumericValue(source[pos++])) > 15
298                                                         || c2 < 0
299                                                         || (c3 = Character.getNumericValue(source[pos++])) > 15
300                                                         || c3 < 0
301                                                         || (c4 = Character.getNumericValue(source[pos++])) > 15
302                                                         || c4 < 0) {
303                                                         return false;
304                                                 } else {
305                                                         currentCharacter = (char) (((c1 * 16 + c2) * 16 + c3) * 16 + c4);
306                                                         nextCharacterPosition = pos;
307                                                 }
308                                         } else {
309                                                 currentCharacter = source[currentPosition];
310                                                 nextCharacterPosition = currentPosition+1;
311                                         }
312                                         
313                                         if(currentCharacter == '\r' || currentCharacter == '\n') {
314                                                 break;
315                                         }
316                                         currentPosition--;
317                                 }
318                         }
319                         catch (ArrayIndexOutOfBoundsException e) {
320                                 return false;
321                         }
322                         
323                         // compute start and end of the last token
324                         scanner.resetTo(nextCharacterPosition, selectionEnd);
325                         do {
326                                 try {
327                                         token = scanner.getNextToken();
328                                 } catch (InvalidInputException e) {
329                                         return false;
330                                 }
331                                 if((
332         // token == ITerminalSymbols.TokenNamethis ||
333                                 // token == ITerminalSymbols.TokenNamesuper ||
334                                         token == ITerminalSymbols.TokenNameIdentifier) &&
335                                         scanner.startPosition <= selectionStart &&
336                                         selectionStart <= scanner.currentPosition) {
337                                         lastIdentifierStart = scanner.startPosition;
338                                         lastIdentifierEnd = scanner.currentPosition - 1;
339                                         lastIdentifier = scanner.getCurrentTokenSource();
340                                 }
341                         } while (token != ITerminalSymbols.TokenNameEOF);
342                 } else {
343                         scanner.resetTo(selectionStart, selectionEnd);
344         
345                         boolean expectingIdentifier = true;
346                         
347                         do {
348                                 try {
349                                         token = scanner.getNextToken();
350                                 } catch (InvalidInputException e) {
351                                         return false;
352                                 }
353                                 switch (token) {
354 //                                      case ITerminalSymbols.TokenNamethis :
355 //                                      case ITerminalSymbols.TokenNamesuper :
356                                         case ITerminalSymbols.TokenNameIdentifier :
357                                                 if (!expectingIdentifier)
358                                                         return false;
359                                                 lastIdentifier = scanner.getCurrentTokenSource();
360                                                 lastIdentifierStart = scanner.startPosition;
361                                                 lastIdentifierEnd = scanner.currentPosition - 1;
362                                                 if(lastIdentifierEnd > selectionEnd) {
363                                                         lastIdentifierEnd = selectionEnd;
364                                                         lastIdentifier = CharOperation.subarray(lastIdentifier, 0,lastIdentifierEnd - lastIdentifierStart + 1);
365                                                 }
366                                                 entireSelection.append(lastIdentifier);
367                                                         
368                                                 identCount++;
369                                                 expectingIdentifier = false;
370                                                 break;
371                                         case ITerminalSymbols.TokenNameDOT :
372                                                 if (expectingIdentifier)
373                                                         return false;
374                                                 entireSelection.append('.');
375                                                 expectingIdentifier = true;
376                                                 break;
377                                         case ITerminalSymbols.TokenNameEOF :
378                                                 if (expectingIdentifier)
379                                                         return false;
380                                                 break;
381                                         default :
382                                                 return false;
383                                 }
384                         } while (token != ITerminalSymbols.TokenNameEOF);
385                 }
386                 if (lastIdentifierStart > 0) {
387                         actualSelectionStart = lastIdentifierStart;
388                         actualSelectionEnd = lastIdentifierEnd;
389                         selectedIdentifier = lastIdentifier;
390                         if (identCount > 1)
391                                 qualifiedSelection = entireSelection.toString().toCharArray();
392                         return true;
393                 }
394                 return false;
395         }
396
397         public AssistParser getParser() {
398                 return parser;
399         }
400
401         /**
402          * Ask the engine to compute the selection at the specified position
403          * of the given compilation unit.
404
405          *  @param sourceUnit net.sourceforge.phpdt.internal.compiler.env.ICompilationUnit
406          *      the source of the current compilation unit.
407          *
408          *  @param selectionSourceStart int
409          *  @param selectionSourceEnd int
410          *      a range in the source where the selection is.
411          */
412         public void select(
413                 ICompilationUnit sourceUnit,
414                 int selectionSourceStart,
415                 int selectionSourceEnd) {
416
417                 char[] source = sourceUnit.getContents();
418                 
419                 if(DEBUG) {
420                         System.out.print("SELECTION IN "); //$NON-NLS-1$
421                         System.out.print(sourceUnit.getFileName());
422                         System.out.print(" FROM "); //$NON-NLS-1$
423                         System.out.print(selectionSourceStart);
424                         System.out.print(" TO "); //$NON-NLS-1$
425                         System.out.println(selectionSourceEnd);
426                         System.out.println("SELECTION - Source :"); //$NON-NLS-1$
427                         System.out.println(source);
428                 }
429                 if (!checkSelection(source, selectionSourceStart, selectionSourceEnd))
430                         return;
431                 try {
432                         acceptedAnswer = false;
433                         CompilationResult result = new CompilationResult(sourceUnit, 1, 1, this.compilerOptions.maxProblemsPerUnit);
434                         CompilationUnitDeclaration parsedUnit =
435                                 parser.dietParse(sourceUnit, result, actualSelectionStart, actualSelectionEnd);
436
437                         if (parsedUnit != null) {
438                                 if(DEBUG) {
439                                         System.out.println("SELECTION - Diet AST :"); //$NON-NLS-1$
440                                         System.out.println(parsedUnit.toString());
441                                 }
442                                 
443                                 // scan the package & import statements first
444                                 if (parsedUnit.currentPackage instanceof SelectionOnPackageReference) {
445                                         char[][] tokens =
446                                                 ((SelectionOnPackageReference) parsedUnit.currentPackage).tokens;
447                                         requestor.acceptPackage(CharOperation.concatWith(tokens, '.'));
448                                         return;
449                                 }
450                                 ImportReference[] imports = parsedUnit.imports;
451                                 if (imports != null) {
452                                         for (int i = 0, length = imports.length; i < length; i++) {
453                                                 ImportReference importReference = imports[i];
454                                                 if (importReference instanceof SelectionOnImportReference) {
455                                                         char[][] tokens = ((SelectionOnImportReference) importReference).tokens;
456                                                         requestor.acceptPackage(CharOperation.concatWith(tokens, '.'));
457                                                         nameEnvironment.findTypes(CharOperation.concatWith(tokens, '.'), this);
458                                                         // accept qualified types only if no unqualified type was accepted
459                                                         if(!acceptedAnswer) {
460                                                                 acceptQualifiedTypes();
461                                                                 if (!acceptedAnswer) {
462                                                                         nameEnvironment.findTypes(selectedIdentifier, this);
463                                                                         // try with simple type name
464                                                                         if(!acceptedAnswer) {
465                                                                                 acceptQualifiedTypes();
466                                                                         }
467                                                                 }
468                                                         }
469                                                         return;
470                                                 }
471                                         }
472                                 }
473                                 if (parsedUnit.types != null) {
474                                         lookupEnvironment.buildTypeBindings(parsedUnit);
475                                         if ((this.unitScope = parsedUnit.scope)  != null) {
476                                                 try {
477                                                         lookupEnvironment.completeTypeBindings(parsedUnit, true);
478                                                         parsedUnit.scope.faultInTypes();
479                                                         selectDeclaration(parsedUnit);
480                                                         parseMethod(parsedUnit, selectionSourceStart);
481                                                         if(DEBUG) {
482                                                                 System.out.println("SELECTION - AST :"); //$NON-NLS-1$
483                                                                 System.out.println(parsedUnit.toString());
484                                                         }
485                                                         parsedUnit.resolve();
486                                                 } catch (SelectionNodeFound e) {
487                                                         if (e.binding != null) {
488                                                                 if(DEBUG) {
489                                                                         System.out.println("SELECTION - Selection binding:"); //$NON-NLS-1$
490                                                                         System.out.println(e.binding.toString());
491                                                                 }
492                                                                 // if null then we found a problem in the selection node
493                                                                 selectFrom(e.binding);
494                                                         }
495                                                 }
496                                         }
497                                 }
498                         }
499                         // only reaches here if no selection could be derived from the parsed tree
500                         // thus use the selected source and perform a textual type search
501                         if (!acceptedAnswer) {
502                                 nameEnvironment.findTypes(selectedIdentifier, this);
503                                 
504                                 // accept qualified types only if no unqualified type was accepted
505                                 if(!acceptedAnswer) {
506                                         acceptQualifiedTypes();
507                                 }
508                         }
509                 } catch (IndexOutOfBoundsException e) { // work-around internal failure - 1GEMF6D               
510                 } catch (AbortCompilation e) { // ignore this exception for now since it typically means we cannot find java.lang.Object
511                 } finally {
512                         reset();
513                 }
514         }
515
516         private void selectFrom(Binding binding) {
517                 if (binding instanceof ReferenceBinding) {
518                         ReferenceBinding typeBinding = (ReferenceBinding) binding;
519                         if (qualifiedSelection != null
520                                 && !CharOperation.equals(qualifiedSelection, typeBinding.readableName())) {
521                                 return;
522                         }
523                         if (typeBinding.isInterface()) {
524                                 requestor.acceptInterface(
525                                         typeBinding.qualifiedPackageName(),
526                                         typeBinding.qualifiedSourceName(),
527                                         false);
528                         } else if(typeBinding instanceof ProblemReferenceBinding){
529                                 ProblemReferenceBinding problemBinding = (ProblemReferenceBinding)typeBinding;
530                                 if(problemBinding.original == null
531                                         || !(problemBinding.original instanceof ReferenceBinding)) {
532                                         return;
533                                 }
534                                 ReferenceBinding original = (ReferenceBinding) problemBinding.original;
535
536                                 requestor.acceptClass(
537                                         original.qualifiedPackageName(),
538                                         original.qualifiedSourceName(),
539                                         false);
540                         } else {
541                                 requestor.acceptClass(
542                                         typeBinding.qualifiedPackageName(),
543                                         typeBinding.qualifiedSourceName(),
544                                         false);
545                         }
546                         acceptedAnswer = true;
547                 } else
548                         if (binding instanceof MethodBinding) {
549                                 MethodBinding methodBinding = (MethodBinding) binding;
550                                 TypeBinding[] parameterTypes = methodBinding.parameters;
551                                 int length = parameterTypes.length;
552                                 char[][] parameterPackageNames = new char[length][];
553                                 char[][] parameterTypeNames = new char[length][];
554                                 for (int i = 0; i < length; i++) {
555                                         parameterPackageNames[i] = parameterTypes[i].qualifiedPackageName();
556                                         parameterTypeNames[i] = parameterTypes[i].qualifiedSourceName();
557                                 }
558                                 requestor.acceptMethod(
559                                         methodBinding.declaringClass.qualifiedPackageName(),
560                                         methodBinding.declaringClass.qualifiedSourceName(),
561                                         methodBinding.isConstructor()
562                                                 ? methodBinding.declaringClass.sourceName()
563                                                 : methodBinding.selector,
564                                         parameterPackageNames,
565                                         parameterTypeNames,
566                                         methodBinding.isConstructor());
567                                 acceptedAnswer = true;
568                         } else
569                                 if (binding instanceof FieldBinding) {
570                                         FieldBinding fieldBinding = (FieldBinding) binding;
571                                         if (fieldBinding.declaringClass != null) { // arraylength
572                                                 requestor.acceptField(
573                                                         fieldBinding.declaringClass.qualifiedPackageName(),
574                                                         fieldBinding.declaringClass.qualifiedSourceName(),
575                                                         fieldBinding.name);
576                                                 acceptedAnswer = true;
577                                         }
578                                 } else
579                                         if (binding instanceof LocalVariableBinding) {
580                                                 selectFrom(((LocalVariableBinding) binding).type);
581                                                 // open on the type of the variable
582                                         } else
583                                                 if (binding instanceof ArrayBinding) {
584                                                         selectFrom(((ArrayBinding) binding).leafComponentType);
585                                                         // open on the type of the array
586                                                 } else
587                                                         if (binding instanceof PackageBinding) {
588                                                                 PackageBinding packageBinding = (PackageBinding) binding;
589                                                                 requestor.acceptPackage(packageBinding.readableName());
590                                                                 acceptedAnswer = true;
591                                                         } else
592                                                                 if(binding instanceof BaseTypeBinding) {
593                                                                         acceptedAnswer = true;
594                                                                 }
595         }
596
597         /**
598          * Asks the engine to compute the selection of the given type
599          * from the source type.
600          *
601          *  @param sourceType net.sourceforge.phpdt.internal.compiler.env.ISourceType
602          *      a source form of the current type in which code assist is invoked.
603          *
604          *  @param typeName char[]
605          *      a type name which is to be resolved in the context of a compilation unit.
606          *              NOTE: the type name is supposed to be correctly reduced (no whitespaces, no unicodes left)
607          * 
608          *  @param searchInEnvironment
609          *      if <code>true</code> and no selection could be found in context then search type in environment.
610          */
611         public void selectType(ISourceType sourceType, char[] typeName, boolean searchInEnvironment) {
612                 try {
613                         acceptedAnswer = false;
614
615                         // find the outer most type
616                         ISourceType outerType = sourceType;
617                         ISourceType parent = sourceType.getEnclosingType();
618                         while (parent != null) {
619                                 outerType = parent;
620                                 parent = parent.getEnclosingType();
621                         }
622                         // compute parse tree for this most outer type
623                         CompilationResult result = new CompilationResult(outerType.getFileName(), 1, 1, this.compilerOptions.maxProblemsPerUnit);
624                         CompilationUnitDeclaration parsedUnit =
625                                 SourceTypeConverter
626                                         .buildCompilationUnit(
627                                                 new ISourceType[] { outerType },
628                                                 false,
629                         // don't need field and methods
630                         true, // by default get member types
631                         this.parser.problemReporter(), result);
632
633                         if (parsedUnit != null && parsedUnit.types != null) {
634                                 if(DEBUG) {
635                                         System.out.println("SELECTION - Diet AST :"); //$NON-NLS-1$
636                                         System.out.println(parsedUnit.toString());
637                                 }
638                                 // find the type declaration that corresponds to the original source type
639                                 char[] packageName = sourceType.getPackageName();
640                                 char[] sourceTypeName = sourceType.getQualifiedName();
641                                 // the fully qualified name without the package name
642                                 if (packageName != null) {
643                                         // remove the package name if necessary
644                                         sourceTypeName =
645                                                 CharOperation.subarray(
646                                                         sourceType.getQualifiedName(),
647                                                         packageName.length + 1,
648                                                         sourceTypeName.length);
649                                 };
650                                 TypeDeclaration typeDecl =
651                                         parsedUnit.declarationOfType(CharOperation.splitOn('.', sourceTypeName));
652                                 if (typeDecl != null) {
653
654                                         // add fake field with the type we're looking for
655                                         // note: since we didn't ask for fields above, there is no field defined yet
656                                         FieldDeclaration field = new FieldDeclaration();
657                                         int dot;
658                                         if ((dot = CharOperation.lastIndexOf('.', typeName)) == -1) {
659                                                 this.selectedIdentifier = typeName;
660                                                 field.type = new SelectionOnSingleTypeReference(typeName, -1);
661                                                 // position not used
662                                         } else {
663                                                 qualifiedSelection = typeName;
664                                                 char[][] previousIdentifiers = CharOperation.splitOn('.', typeName, 0, dot - 1);
665                                                 char[] selectionIdentifier =
666                                                         CharOperation.subarray(typeName, dot + 1, typeName.length);
667                                                 this.selectedIdentifier = selectionIdentifier;
668                                                 field.type =
669                                                         new SelectionOnQualifiedTypeReference(
670                                                                 previousIdentifiers,
671                                                                 selectionIdentifier,
672                                                                 new long[previousIdentifiers.length + 1]);
673                                         }
674                                         field.name = "<fakeField>".toCharArray(); //$NON-NLS-1$
675                                         typeDecl.fields = new FieldDeclaration[] { field };
676
677                                         // build bindings
678                                         lookupEnvironment.buildTypeBindings(parsedUnit);
679                                         if ((this.unitScope = parsedUnit.scope) != null) {
680                                                 try {
681                                                         // build fields
682                                                         // note: this builds fields only in the parsed unit (the buildFieldsAndMethods flag is not passed along)
683                                                         this.lookupEnvironment.completeTypeBindings(parsedUnit, true);
684
685                                                         // resolve
686                                                         parsedUnit.scope.faultInTypes();
687                                                         parsedUnit.resolve();
688                                                 } catch (SelectionNodeFound e) {
689                                                         if (e.binding != null) {
690                                                                 if(DEBUG) {
691                                                                         System.out.println("SELECTION - Selection binding :"); //$NON-NLS-1$
692                                                                         System.out.println(e.binding.toString());
693                                                                 }
694                                                                 // if null then we found a problem in the selection node
695                                                                 selectFrom(e.binding);
696                                                         }
697                                                 }
698                                         }
699                                 }
700                         }
701                         // only reaches here if no selection could be derived from the parsed tree
702                         // thus use the selected source and perform a textual type search
703                         if (!acceptedAnswer && searchInEnvironment) {
704                                 if (this.selectedIdentifier != null) {
705                                         nameEnvironment.findTypes(typeName, this);
706                                         
707                                         // accept qualified types only if no unqualified type was accepted
708                                         if(!acceptedAnswer) {
709                                                 acceptQualifiedTypes();
710                                         }
711                                 }
712                         }
713                 } catch (AbortCompilation e) { // ignore this exception for now since it typically means we cannot find java.lang.Object
714                 } finally {
715                         qualifiedSelection = null;
716                         reset();
717                 }
718         }
719
720         // Check if a declaration got selected in this unit
721         private void selectDeclaration(CompilationUnitDeclaration compilationUnit){
722
723                 // the selected identifier is not identical to the parser one (equals but not identical),
724                 // for traversing the parse tree, the parser assist identifier is necessary for identitiy checks
725                 char[] assistIdentifier = this.getParser().assistIdentifier();
726                 if (assistIdentifier == null) return;
727                 
728                 // iterate over the types
729                 TypeDeclaration[] types = compilationUnit.types;
730                 for (int i = 0, length = types == null ? 0 : types.length; i < length; i++){
731                         selectDeclaration(types[i], assistIdentifier);
732                 }
733         }
734
735         // Check if a declaration got selected in this type
736         private void selectDeclaration(TypeDeclaration typeDeclaration, char[] assistIdentifier){
737
738                 if (typeDeclaration.name == assistIdentifier){
739                         throw new SelectionNodeFound(typeDeclaration.binding);
740                 }
741                 TypeDeclaration[] memberTypes = typeDeclaration.memberTypes;
742                 for (int i = 0, length = memberTypes == null ? 0 : memberTypes.length; i < length; i++){
743                         selectDeclaration(memberTypes[i], assistIdentifier);
744                 }
745                 FieldDeclaration[] fields = typeDeclaration.fields;
746                 for (int i = 0, length = fields == null ? 0 : fields.length; i < length; i++){
747                         if (fields[i].name == assistIdentifier){
748                                 throw new SelectionNodeFound(fields[i].binding);
749                         }
750                 }
751                 AbstractMethodDeclaration[] methods = typeDeclaration.methods;
752                 for (int i = 0, length = methods == null ? 0 : methods.length; i < length; i++){
753                         AbstractMethodDeclaration method = methods[i];
754                         if (method.selector == assistIdentifier){
755                                 if(method.binding != null) {
756                                         throw new SelectionNodeFound(method.binding);
757                                 } else {
758                                         if(method.scope != null) {
759                                                 throw new SelectionNodeFound(new MethodBinding(method.modifiers, method.selector, null, null, null, method.scope.referenceType().binding));
760                                         }
761                                 }
762                 }
763                 }
764         }
765 }