net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/codeassist/CompletionEngine.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.ICompletionRequestor;
  17 import net.sourceforge.phpdt.core.compiler.IProblem;
  18 import net.sourceforge.phpdt.core.compiler.ITerminalSymbols;
  19 import net.sourceforge.phpdt.core.compiler.InvalidInputException;
  20 import net.sourceforge.phpdt.internal.codeassist.complete.CompletionNodeFound;
  21 import net.sourceforge.phpdt.internal.codeassist.complete.CompletionOnArgumentName;
  22 import net.sourceforge.phpdt.internal.codeassist.complete.CompletionOnClassLiteralAccess;
  23 import net.sourceforge.phpdt.internal.codeassist.complete.CompletionOnClassReference;
  24 import net.sourceforge.phpdt.internal.codeassist.complete.CompletionOnExceptionReference;
  25 import net.sourceforge.phpdt.internal.codeassist.complete.CompletionOnExplicitConstructorCall;
  26 import net.sourceforge.phpdt.internal.codeassist.complete.CompletionOnFieldName;
  27 import net.sourceforge.phpdt.internal.codeassist.complete.CompletionOnFieldType;
  28 import net.sourceforge.phpdt.internal.codeassist.complete.CompletionOnImportReference;
  29 import net.sourceforge.phpdt.internal.codeassist.complete.CompletionOnInterfaceReference;
  30 import net.sourceforge.phpdt.internal.codeassist.complete.CompletionOnLocalName;
  31 import net.sourceforge.phpdt.internal.codeassist.complete.CompletionOnMemberAccess;
  32 import net.sourceforge.phpdt.internal.codeassist.complete.CompletionOnMessageSend;
  33 import net.sourceforge.phpdt.internal.codeassist.complete.CompletionOnMethodName;
  34 import net.sourceforge.phpdt.internal.codeassist.complete.CompletionOnMethodReturnType;
  35 import net.sourceforge.phpdt.internal.codeassist.complete.CompletionOnPackageReference;
  36 import net.sourceforge.phpdt.internal.codeassist.complete.CompletionOnQualifiedAllocationExpression;
  37 import net.sourceforge.phpdt.internal.codeassist.complete.CompletionOnQualifiedClassReference;
  38 import net.sourceforge.phpdt.internal.codeassist.complete.CompletionOnQualifiedExceptionReference;
  39 import net.sourceforge.phpdt.internal.codeassist.complete.CompletionOnQualifiedInterfaceReference;
  40 import net.sourceforge.phpdt.internal.codeassist.complete.CompletionOnQualifiedNameReference;
  41 import net.sourceforge.phpdt.internal.codeassist.complete.CompletionOnQualifiedTypeReference;
  42 import net.sourceforge.phpdt.internal.codeassist.complete.CompletionOnSingleNameReference;
  43 import net.sourceforge.phpdt.internal.codeassist.complete.CompletionOnSingleTypeReference;
  44 import net.sourceforge.phpdt.internal.codeassist.complete.CompletionParser;
  45 import net.sourceforge.phpdt.internal.codeassist.complete.InvalidCursorLocation;
  46 import net.sourceforge.phpdt.internal.codeassist.impl.AssistParser;
  47 import net.sourceforge.phpdt.internal.codeassist.impl.Engine;
  48 import net.sourceforge.phpdt.internal.compiler.CompilationResult;
  49 import net.sourceforge.phpdt.internal.compiler.DefaultErrorHandlingPolicies;
  50 import net.sourceforge.phpdt.internal.compiler.ast.AbstractMethodDeclaration;
  51 import net.sourceforge.phpdt.internal.compiler.ast.AbstractVariableDeclaration;
  52 import net.sourceforge.phpdt.internal.compiler.ast.Argument;
  53 import net.sourceforge.phpdt.internal.compiler.ast.Assignment;
  54 import net.sourceforge.phpdt.internal.compiler.ast.AstNode;
  55 import net.sourceforge.phpdt.internal.compiler.ast.CompilationUnitDeclaration;
  56 import net.sourceforge.phpdt.internal.compiler.ast.Expression;
  57 import net.sourceforge.phpdt.internal.compiler.ast.ImportReference;
  58 import net.sourceforge.phpdt.internal.compiler.ast.LocalDeclaration;
  59 import net.sourceforge.phpdt.internal.compiler.ast.ReturnStatement;
  60 import net.sourceforge.phpdt.internal.compiler.ast.SingleTypeReference;
  61 import net.sourceforge.phpdt.internal.compiler.ast.TypeDeclaration;
  62 import net.sourceforge.phpdt.internal.compiler.ast.TypeReference;
  63 import net.sourceforge.phpdt.internal.compiler.env.ICompilationUnit;
  64 import net.sourceforge.phpdt.internal.compiler.env.IConstants;
  65 import net.sourceforge.phpdt.internal.compiler.env.ISourceMethod;
  66 import net.sourceforge.phpdt.internal.compiler.env.ISourceType;
  67 import net.sourceforge.phpdt.internal.compiler.env.NameEnvironmentAnswer;
  68 import net.sourceforge.phpdt.internal.compiler.impl.ReferenceContext;
  69 import net.sourceforge.phpdt.internal.compiler.lookup.BaseTypes;
  70 import net.sourceforge.phpdt.internal.compiler.lookup.Binding;
  71 import net.sourceforge.phpdt.internal.compiler.lookup.BlockScope;
  72 import net.sourceforge.phpdt.internal.compiler.lookup.ClassScope;
  73 import net.sourceforge.phpdt.internal.compiler.lookup.CompilerModifiers;
  74 import net.sourceforge.phpdt.internal.compiler.lookup.FieldBinding;
  75 import net.sourceforge.phpdt.internal.compiler.lookup.InvocationSite;
  76 import net.sourceforge.phpdt.internal.compiler.lookup.LocalVariableBinding;
  77 import net.sourceforge.phpdt.internal.compiler.lookup.LookupEnvironment;
  78 import net.sourceforge.phpdt.internal.compiler.lookup.MethodBinding;
  79 import net.sourceforge.phpdt.internal.compiler.lookup.MethodScope;
  80 import net.sourceforge.phpdt.internal.compiler.lookup.PackageBinding;
  81 import net.sourceforge.phpdt.internal.compiler.lookup.ReferenceBinding;
  82 import net.sourceforge.phpdt.internal.compiler.lookup.Scope;
  83 import net.sourceforge.phpdt.internal.compiler.lookup.SourceTypeBinding;
  84 import net.sourceforge.phpdt.internal.compiler.lookup.TagBits;
  85 import net.sourceforge.phpdt.internal.compiler.lookup.TypeBinding;
  86 import net.sourceforge.phpdt.internal.compiler.lookup.TypeConstants;
  87 import net.sourceforge.phpdt.internal.compiler.lookup.VariableBinding;
  88 import net.sourceforge.phpdt.internal.compiler.parser.Scanner;
  89 import net.sourceforge.phpdt.internal.compiler.problem.AbortCompilation;
  90 import net.sourceforge.phpdt.internal.compiler.problem.DefaultProblemFactory;
  91 import net.sourceforge.phpdt.internal.compiler.problem.ProblemReporter;
  92 import net.sourceforge.phpdt.internal.compiler.util.CharOperation;
  93 import net.sourceforge.phpdt.internal.compiler.util.HashtableOfObject;
  94 import net.sourceforge.phpdt.internal.compiler.util.ObjectVector;
  95
  96 /**
  97  * This class is the entry point for source completions.
  98  * It contains two public APIs used to call CodeAssist on a given source with
  99  * a given environment, assisting position and storage (and possibly options).
 100  */
 101 public final class CompletionEngine
 102         extends Engine
 103         implements ISearchRequestor, TypeConstants , ITerminalSymbols , RelevanceConstants {
 104
 105         public static boolean DEBUG = false;
 106
 107         private final static char[] ERROR_PATTERN = "*error*".toCharArray();  //$NON-NLS-1$
 108         private final static char[] EXCEPTION_PATTERN = "*exception*".toCharArray();  //$NON-NLS-1$
 109         private final static char[] SEMICOLON = new char[] { ';' };
 110         TypeBinding[] expectedTypes;
 111
 112         boolean assistNodeIsClass;
 113         boolean assistNodeIsException;
 114         boolean assistNodeIsInterface;
 115
 116         CompletionParser parser;
 117         ICompletionRequestor requestor;
 118         ProblemReporter problemReporter;
 119         char[] source;
 120         char[] token;
 121         boolean resolvingImports = false;
 122         boolean insideQualifiedReference = false;
 123         int startPosition, actualCompletionPosition, endPosition, offset;
 124         HashtableOfObject knownPkgs = new HashtableOfObject(10);
 125         HashtableOfObject knownTypes = new HashtableOfObject(10);
 126         Scanner nameScanner;
 127
 128         /*
 129                 static final char[][] mainDeclarations =
 130                         new char[][] {
 131                                 "package".toCharArray(),
 132                                 "import".toCharArray(),
 133                                 "abstract".toCharArray(),
 134                                 "final".toCharArray(),
 135                                 "public".toCharArray(),
 136                                 "class".toCharArray(),
 137                                 "interface".toCharArray()};
 138
 139                 static final char[][] modifiers = // may want field, method, type & member type modifiers
 140                         new char[][] {
 141                                 "abstract".toCharArray(),
 142                                 "final".toCharArray(),
 143                                 "native".toCharArray(),
 144                                 "public".toCharArray(),
 145                                 "protected".toCharArray(),
 146                                 "private".toCharArray(),
 147                                 "static".toCharArray(),
 148                                 "strictfp".toCharArray(),
 149                                 "synchronized".toCharArray(),
 150                                 "transient".toCharArray(),
 151                                 "volatile".toCharArray()};
 152         */
 153         static final char[][] baseTypes = new char[][] {
 154                 "boolean".toCharArray(), //$NON-NLS-1$
 155                 "byte".toCharArray(), //$NON-NLS-1$
 156                 "char".toCharArray(), //$NON-NLS-1$
 157                 "double".toCharArray(), //$NON-NLS-1$
 158                 "float".toCharArray(), //$NON-NLS-1$
 159                 "int".toCharArray(), //$NON-NLS-1$
 160                 "long".toCharArray(), //$NON-NLS-1$
 161                 "short".toCharArray(), //$NON-NLS-1$
 162                 "void".toCharArray(), //$NON-NLS-1$
 163         };
 164
 165         static final char[] classField = "class".toCharArray();  //$NON-NLS-1$
 166         static final char[] lengthField = "length".toCharArray();  //$NON-NLS-1$
 167         static final char[] THIS = "this".toCharArray();  //$NON-NLS-1$
 168         static final char[] THROWS = "throws".toCharArray();  //$NON-NLS-1$
 169
 170         static InvocationSite FakeInvocationSite = new InvocationSite(){
 171                 public boolean isSuperAccess(){ return false; }
 172                 public boolean isTypeAccess(){ return false; }
 173                 public void setActualReceiverType(ReferenceBinding receiverType) {}
 174                 public void setDepth(int depth){}
 175                 public void setFieldIndex(int depth){}
 176         };
 177
 178         /**
 179          * The CompletionEngine is responsible for computing source completions.
 180          *
 181          * It requires a searchable name environment, which supports some
 182          * specific search APIs, and a requestor to feed back the results to a UI.
 183          *
 184          *  @param nameEnvironment net.sourceforge.phpdt.internal.codeassist.ISearchableNameEnvironment
 185          *      used to resolve type/package references and search for types/packages
 186          *      based on partial names.
 187          *
 188          *  @param requestor net.sourceforge.phpdt.internal.codeassist.ICompletionRequestor
 189          *      since the engine might produce answers of various forms, the engine
 190          *      is associated with a requestor able to accept all possible completions.
 191          *
 192          *  @param settings java.util.Map
 193          *              set of options used to configure the code assist engine.
 194          */
 195         public CompletionEngine(
 196                 ISearchableNameEnvironment nameEnvironment,
 197                 ICompletionRequestor requestor,
 198                 Map settings) {
 199
 200                 super(settings);
 201                 this.requestor = requestor;
 202                 this.nameEnvironment = nameEnvironment;
 203
 204                 problemReporter = new ProblemReporter(
 205                                 DefaultErrorHandlingPolicies.proceedWithAllProblems(),
 206                                 this.compilerOptions,
 207                                 new DefaultProblemFactory(Locale.getDefault()) {
 208                                         public void record(IProblem problem, CompilationResult unitResult, ReferenceContext referenceContext) {
 209                                                 if (problem.isError() && (problem.getID() & IProblem.Syntax) != 0) {
 210                                                         CompletionEngine.this.requestor.acceptError(problem);
 211                                                 }
 212                                         }
 213                                 });
 214                 this.parser =
 215                         new CompletionParser(problemReporter, this.compilerOptions.assertMode);
 216                 this.lookupEnvironment =
 217                         new LookupEnvironment(this, this.compilerOptions, problemReporter, nameEnvironment);
 218                 this.nameScanner =
 219                         new Scanner(false, false, false, this.compilerOptions.assertMode);
 220         }
 221
 222         /**
 223          * One result of the search consists of a new class.
 224          *
 225          * NOTE - All package and type names are presented in their readable form:
 226          *    Package names are in the form "a.b.c".
 227          *    Nested type names are in the qualified form "A.M".
 228          *    The default package is represented by an empty array.
 229          */
 230         public void acceptClass(char[] packageName, char[] className, int modifiers) {
 231
 232                 char[] fullyQualifiedName = CharOperation.concat(packageName, className, '.');
 233                 char[] completionName = fullyQualifiedName;
 234
 235                 if (this.knownTypes.containsKey(completionName)) return;
 236
 237                 this.knownTypes.put(completionName, this);
 238
 239                 int relevance = R_DEFAULT;
 240                 if (resolvingImports) {
 241                         completionName = CharOperation.concat(completionName, SEMICOLON);
 242                         relevance += computeRelevanceForCaseMatching(token, fullyQualifiedName);
 243                 } else {
 244                         if (!insideQualifiedReference) {
 245                                 if (mustQualifyType(packageName, className)) {
 246                                         if (packageName == null || packageName.length == 0)
 247                                                 if (unitScope != null && unitScope.fPackage.compoundName != NoCharChar)
 248                                                         return; // ignore types from the default package from outside it
 249                                 } else {
 250                                         completionName = className;
 251                                 }
 252                         }
 253                         relevance += computeRelevanceForCaseMatching(token, className);
 254                         relevance += computeRelevanceForExpectingType(packageName, className);
 255                         relevance += computeRelevanceForClass();
 256                         relevance += computeRelevanceForException(className);
 257                 }
 258
 259                 requestor.acceptClass(
 260                         packageName,
 261                         className,
 262                         completionName,
 263                         modifiers,
 264                         startPosition - offset,
 265                         endPosition - offset,
 266                         relevance);
 267         }
 268
 269         /**
 270          * One result of the search consists of a new interface.
 271          *
 272          * NOTE - All package and type names are presented in their readable form:
 273          *    Package names are in the form "a.b.c".
 274          *    Nested type names are in the qualified form "A.I".
 275          *    The default package is represented by an empty array.
 276          */
 277         public void acceptInterface(
 278                 char[] packageName,
 279                 char[] interfaceName,
 280                 int modifiers) {
 281
 282                 char[] fullyQualifiedName = CharOperation.concat(packageName, interfaceName, '.');
 283                 char[] completionName = fullyQualifiedName;
 284
 285                 if (this.knownTypes.containsKey(completionName)) return;
 286
 287                 this.knownTypes.put(completionName, this);
 288
 289                 int relevance = R_DEFAULT;
 290                 if (resolvingImports) {
 291                         completionName = CharOperation.concat(completionName, new char[] { ';' });
 292                         relevance += computeRelevanceForCaseMatching(token, fullyQualifiedName);
 293                 } else {
 294                         if (!insideQualifiedReference) {
 295                                 if (mustQualifyType(packageName, interfaceName)) {
 296                                         if (packageName == null || packageName.length == 0)
 297                                                 if (unitScope != null && unitScope.fPackage.compoundName != NoCharChar)
 298                                                         return; // ignore types from the default package from outside it
 299                                 } else {
 300                                         completionName = interfaceName;
 301                                 }
 302                         }
 303                         relevance += computeRelevanceForCaseMatching(token, interfaceName);
 304                         relevance += computeRelevanceForExpectingType(packageName, interfaceName);
 305                         relevance += computeRelevanceForInterface();
 306                 }
 307
 308                 requestor.acceptInterface(
 309                         packageName,
 310                         interfaceName,
 311                         completionName,
 312                         modifiers,
 313                         startPosition - offset,
 314                         endPosition - offset,
 315                         relevance);
 316         }
 317
 318         /**
 319          * One result of the search consists of a new package.
 320          *
 321          * NOTE - All package names are presented in their readable form:
 322          *    Package names are in the form "a.b.c".
 323          *    The default package is represented by an empty array.
 324          */
 325         public void acceptPackage(char[] packageName) {
 326
 327                 if (this.knownPkgs.containsKey(packageName)) return;
 328
 329                 this.knownPkgs.put(packageName, this);
 330
 331                 int relevance = R_DEFAULT;
 332                 relevance += computeRelevanceForCaseMatching(token, packageName);
 333
 334                 requestor.acceptPackage(
 335                         packageName,
 336                         resolvingImports
 337                                 ? CharOperation.concat(packageName, new char[] { '.', '*', ';' })
 338                                 : packageName,
 339                         startPosition - offset,
 340                         endPosition - offset,
 341                         relevance);
 342         }
 343
 344         /**
 345          * One result of the search consists of a new type.
 346          *
 347          * NOTE - All package and type names are presented in their readable form:
 348          *    Package names are in the form "a.b.c".
 349          *    Nested type names are in the qualified form "A.M".
 350          *    The default package is represented by an empty array.
 351          */
 352         public void acceptType(char[] packageName, char[] typeName) {
 353
 354                 char[] fullyQualifiedName = CharOperation.concat(packageName, typeName, '.');
 355                 char[] completionName = fullyQualifiedName;
 356
 357                 if (this.knownTypes.containsKey(completionName)) return;
 358
 359                 this.knownTypes.put(completionName, this);
 360
 361                 int relevance = R_DEFAULT;
 362                 if (resolvingImports) {
 363                         completionName = CharOperation.concat(completionName, new char[] { ';' });
 364                         relevance += computeRelevanceForCaseMatching(token, fullyQualifiedName);
 365                 } else {
 366                         if (!insideQualifiedReference) {
 367                                 if (mustQualifyType(packageName, typeName)) {
 368                                         if (packageName == null || packageName.length == 0)
 369                                                 if (unitScope != null && unitScope.fPackage.compoundName != NoCharChar)
 370                                                         return; // ignore types from the default package from outside it
 371                                 } else {
 372                                         completionName = typeName;
 373                                 }
 374                         }
 375                         relevance += computeRelevanceForCaseMatching(token, typeName);
 376                         relevance += computeRelevanceForExpectingType(packageName, typeName);
 377                 }
 378
 379                 requestor.acceptType(
 380                         packageName,
 381                         typeName,
 382                         completionName,
 383                         startPosition - offset,
 384                         endPosition - offset,
 385                         relevance);
 386         }
 387
 388         private void complete(AstNode astNode, Binding qualifiedBinding, Scope scope) {
 389
 390                 setSourceRange(astNode.sourceStart, astNode.sourceEnd);
 391
 392                 if(parser.assistNodeParent != null) {
 393                         computeExpectedTypes(parser.assistNodeParent, scope);
 394                 }
 395
 396                 // defaults... some nodes will change these
 397                 if (astNode instanceof CompletionOnFieldType) {
 398
 399                         CompletionOnFieldType field = (CompletionOnFieldType) astNode;
 400                         CompletionOnSingleTypeReference type = (CompletionOnSingleTypeReference) field.type;
 401                         token = type.token;
 402                         setSourceRange(type.sourceStart, type.sourceEnd);
 403                         //              findKeywords(token, modifiers, scope); // could be the start of a field, method or member type
 404                         findTypesAndPackages(token, scope);
 405
 406                         if(!field.isLocalVariable && field.modifiers == CompilerModifiers.AccDefault) {
 407                                 findMethods(token,null,scope.enclosingSourceType(),scope,new ObjectVector(),false,false,true,null,null,false);
 408                         }
 409                 } else {
 410                         if(astNode instanceof CompletionOnMethodReturnType) {
 411
 412                                 CompletionOnMethodReturnType method = (CompletionOnMethodReturnType) astNode;
 413                                 SingleTypeReference type = (CompletionOnSingleTypeReference) method.returnType;
 414                                 token = type.token;
 415                                 setSourceRange(type.sourceStart, type.sourceEnd);
 416                                 findTypesAndPackages(token, scope);
 417
 418                                 if(method.modifiers == CompilerModifiers.AccDefault) {
 419                                         findMethods(token,null,scope.enclosingSourceType(),scope,new ObjectVector(),false,false,true,null,null,false);
 420                                 }
 421                         } else {
 422
 423                                 if (astNode instanceof CompletionOnSingleNameReference) {
 424
 425                                         token = ((CompletionOnSingleNameReference) astNode).token;
 426                                         findVariablesAndMethods(
 427                                                 token,
 428                                                 scope,
 429                                                 (CompletionOnSingleNameReference) astNode,
 430                                                 scope);
 431                                         // can be the start of a qualified type name
 432                                         findTypesAndPackages(token, scope);
 433
 434                                 } else {
 435
 436                                         if (astNode instanceof CompletionOnSingleTypeReference) {
 437
 438                                                 token = ((CompletionOnSingleTypeReference) astNode).token;
 439
 440                                                 assistNodeIsClass = astNode instanceof CompletionOnClassReference;
 441                                                 assistNodeIsException = astNode instanceof CompletionOnExceptionReference;
 442                                                 assistNodeIsInterface = astNode instanceof CompletionOnInterfaceReference;
 443
 444                                                 // can be the start of a qualified type name
 445                                                 if (qualifiedBinding == null) {
 446                                                         findTypesAndPackages(token, scope);
 447                                                         } else {
 448                                                                 findMemberTypes(
 449                                                                 token,
 450                                                                 (ReferenceBinding) qualifiedBinding,
 451                                                                 scope,
 452                                                                 scope.enclosingSourceType());
 453                                                 }
 454                                         } else {
 455
 456                                                 if (astNode instanceof CompletionOnQualifiedNameReference) {
 457
 458                                                         insideQualifiedReference = true;
 459                                                         CompletionOnQualifiedNameReference ref =
 460                                                                 (CompletionOnQualifiedNameReference) astNode;
 461                                                         token = ref.completionIdentifier;
 462                                                         long completionPosition = ref.sourcePositions[ref.sourcePositions.length - 1];
 463
 464                                                         if (qualifiedBinding instanceof VariableBinding) {
 465
 466                                                                 setSourceRange((int) (completionPosition >>> 32), (int) completionPosition);
 467                                                                 TypeBinding receiverType = ((VariableBinding) qualifiedBinding).type;
 468                                                                 if (receiverType != null) {
 469                                                                         findFieldsAndMethods(token, receiverType, scope, ref, scope,false);
 470                                                                 }
 471
 472                                                         } else {
 473
 474                                                                 if (qualifiedBinding instanceof ReferenceBinding) {
 475
 476                                                                         ReferenceBinding receiverType = (ReferenceBinding) qualifiedBinding;
 477                                                                         setSourceRange((int) (completionPosition >>> 32), (int) completionPosition);
 478
 479                                                                         findMemberTypes(token, receiverType, scope, scope.enclosingSourceType());
 480
 481                                                                         findClassField(token, (TypeBinding) qualifiedBinding, scope);
 482
 483                                                                         findFields(
 484                                                                                 token,
 485                                                                                 receiverType,
 486                                                                                 scope,
 487                                                                                 new ObjectVector(),
 488                                                                                 new ObjectVector(),
 489                                                                                 true,
 490                                                                                 ref,
 491                                                                                 scope,
 492                                                                                 false);
 493
 494                                                                         findMethods(
 495                                                                                 token,
 496                                                                                 null,
 497                                                                                 receiverType,
 498                                                                                 scope,
 499                                                                                 new ObjectVector(),
 500                                                                                 true,
 501                                                                                 false,
 502                                                                                 false,
 503                                                                                 ref,
 504                                                                                 scope,
 505                                                                                 false);
 506
 507                                                                 } else {
 508
 509                                                                         if (qualifiedBinding instanceof PackageBinding) {
 510
 511                                                                                 setSourceRange(astNode.sourceStart, (int) completionPosition);
 512                                                                                 // replace to the end of the completion identifier
 513                                                                                 findTypesAndSubpackages(token, (PackageBinding) qualifiedBinding);
 514                                                                         }
 515                                                                 }
 516                                                         }
 517
 518                                                 } else {
 519
 520                                                                 if (astNode instanceof CompletionOnQualifiedTypeReference) {
 521
 522                                                                 insideQualifiedReference = true;
 523
 524                                                                 assistNodeIsClass = astNode instanceof CompletionOnQualifiedClassReference;
 525                                                                 assistNodeIsException = astNode instanceof CompletionOnQualifiedExceptionReference;
 526                                                                 assistNodeIsInterface = astNode instanceof CompletionOnQualifiedInterfaceReference;
 527
 528                                                                 CompletionOnQualifiedTypeReference ref =
 529                                                                         (CompletionOnQualifiedTypeReference) astNode;
 530                                                                 token = ref.completionIdentifier;
 531                                                                 long completionPosition = ref.sourcePositions[ref.tokens.length];
 532
 533                                                                 // get the source positions of the completion identifier
 534                                                                 if (qualifiedBinding instanceof ReferenceBinding) {
 535
 536                                                                         setSourceRange((int) (completionPosition >>> 32), (int) completionPosition);
 537                                                                         findMemberTypes(
 538                                                                                 token,
 539                                                                                 (ReferenceBinding) qualifiedBinding,
 540                                                                                 scope,
 541                                                                                 scope.enclosingSourceType());
 542
 543                                                                 } else {
 544
 545                                                                         if (qualifiedBinding instanceof PackageBinding) {
 546
 547                                                                                 setSourceRange(astNode.sourceStart, (int) completionPosition);
 548                                                                                 // replace to the end of the completion identifier
 549                                                                                 findTypesAndSubpackages(token, (PackageBinding) qualifiedBinding);
 550                                                                         }
 551                                                                 }
 552
 553                                                         } else {
 554
 555                                                                 if (astNode instanceof CompletionOnMemberAccess) {
 556
 557                                                                         CompletionOnMemberAccess access = (CompletionOnMemberAccess) astNode;
 558                                                                         long completionPosition = access.nameSourcePosition;
 559                                                                         setSourceRange((int) (completionPosition >>> 32), (int) completionPosition);
 560
 561                                                                         token = access.token;
 562
 563                                                                         findFieldsAndMethods(
 564                                                                                 token,
 565                                                                                 (TypeBinding) qualifiedBinding,
 566                                                                                 scope,
 567                                                                                 access,
 568                                                                                 scope,
 569                                                                                 false);
 570
 571                                                                 } else {
 572
 573                                                                         if (astNode instanceof CompletionOnMessageSend) {
 574
 575                                                                                 CompletionOnMessageSend messageSend = (CompletionOnMessageSend) astNode;
 576                                                                                 TypeBinding[] argTypes =
 577                                                                                         computeTypes(messageSend.arguments, (BlockScope) scope);
 578                                                                                 token = messageSend.selector;
 579                                                                                 if (qualifiedBinding == null) {
 580
 581                                                                                         findImplicitMessageSends(token, argTypes, scope, messageSend, scope);
 582                                                                                 } else {
 583
 584                                                                                         findMethods(
 585                                                                                                 token,
 586                                                                                                 argTypes,
 587                                                                                                 (ReferenceBinding) qualifiedBinding,
 588                                                                                                 scope,
 589                                                                                                 new ObjectVector(),
 590                                                                                                 false,
 591                                                                                                 true,
 592                                                                                                 false,
 593                                                                                                 messageSend,
 594                                                                                                 scope,
 595                                                                                                 false);
 596                                                                                 }
 597
 598                                                                         } else {
 599
 600                                                                                 if (astNode instanceof CompletionOnExplicitConstructorCall) {
 601
 602                                                                                         CompletionOnExplicitConstructorCall constructorCall =
 603                                                                                                 (CompletionOnExplicitConstructorCall) astNode;
 604                                                                                         TypeBinding[] argTypes =
 605                                                                                                 computeTypes(constructorCall.arguments, (BlockScope) scope);
 606                                                                                         findConstructors(
 607                                                                                                 (ReferenceBinding) qualifiedBinding,
 608                                                                                                 argTypes,
 609                                                                                                 scope,
 610                                                                                                 constructorCall,
 611                                                                                                 false);
 612
 613                                                                                 } else {
 614
 615                                                                                         if (astNode instanceof CompletionOnQualifiedAllocationExpression) {
 616
 617                                                                                                 CompletionOnQualifiedAllocationExpression allocExpression =
 618                                                                                                         (CompletionOnQualifiedAllocationExpression) astNode;
 619                                                                                                 TypeBinding[] argTypes =
 620                                                                                                         computeTypes(allocExpression.arguments, (BlockScope) scope);
 621
 622                                                                                                 ReferenceBinding ref = (ReferenceBinding) qualifiedBinding;
 623                                                                                                 if(ref.isClass()) {
 624                                                                                                         if(!ref.isAbstract()) {
 625                                                                                                                 findConstructors(
 626                                                                                                                         ref,
 627                                                                                                                         argTypes,
 628                                                                                                                         scope,
 629                                                                                                                         allocExpression,
 630                                                                                                                         false);
 631                                                                                                         }
 632                                                                                                 }
 633                                                                                                 if(!ref.isFinal()){
 634                                                                                                         findAnonymousType(
 635                                                                                                                 ref,
 636                                                                                                                 argTypes,
 637                                                                                                                 scope,
 638                                                                                                                 allocExpression);
 639                                                                                                 }
 640
 641                                                                                         } else {
 642
 643                                                                                                 if (astNode instanceof CompletionOnClassLiteralAccess) {
 644                                                                                                         CompletionOnClassLiteralAccess access = (CompletionOnClassLiteralAccess) astNode;
 645                                                                                                         setSourceRange(access.classStart, access.sourceEnd);
 646
 647                                                                                                         token = access.completionIdentifier;
 648
 649                                                                                                         findClassField(token, (TypeBinding) qualifiedBinding, scope);
 650                                                                                                 } else {
 651                                                                                                         if(astNode instanceof CompletionOnMethodName) {
 652                                                                                                                 CompletionOnMethodName method = (CompletionOnMethodName) astNode;
 653
 654                                                                                                                 setSourceRange(method.sourceStart, method.selectorEnd);
 655
 656                                                                                                                 FieldBinding[] fields = scope.enclosingSourceType().fields();
 657                                                                                                                 char[][] excludeNames = new char[fields.length][];
 658                                                                                                                 for(int i = 0 ; i < fields.length ; i++){
 659                                                                                                                         excludeNames[i] = fields[i].name;
 660                                                                                                                 }
 661
 662                                                                                                                 token = method.selector;
 663
 664                                                                                                                 findVariableNames(token, method.returnType, excludeNames);
 665                                                                                                         } else {
 666                                                                                                                 if (astNode instanceof CompletionOnFieldName) {
 667                                                                                                                         CompletionOnFieldName field = (CompletionOnFieldName) astNode;
 668
 669                                                                                                                         FieldBinding[] fields = scope.enclosingSourceType().fields();
 670                                                                                                                         char[][] excludeNames = new char[fields.length][];
 671                                                                                                                         for(int i = 0 ; i < fields.length ; i++){
 672                                                                                                                                 excludeNames[i] = fields[i].name;
 673                                                                                                                         }
 674
 675                                                                                                                         token = field.realName;
 676
 677                                                                                                                         findVariableNames(field.realName, field.type, excludeNames);
 678                                                                                                                 } else {
 679                                                                                                                         if (astNode instanceof CompletionOnLocalName ||
 680                                                                                                                                 astNode instanceof CompletionOnArgumentName){
 681                                                                                                                                 LocalDeclaration variable = (LocalDeclaration) astNode;
 682
 683                                                                                                                                 LocalVariableBinding[] locals = ((BlockScope)scope).locals;
 684                                                                                                                                 char[][] excludeNames = new char[locals.length][];
 685                                                                                                                                 int localCount = 0;
 686                                                                                                                                 for(int i = 0 ; i < locals.length ; i++){
 687                                                                                                                                         if(locals[i] != null) {
 688                                                                                                                                                 excludeNames[localCount++] = locals[i].name;
 689                                                                                                                                         }
 690                                                                                                                                 }
 691                                                                                                                                 System.arraycopy(excludeNames, 0, excludeNames = new char[localCount][], 0, localCount);
 692
 693                                                                                                                                 if(variable instanceof CompletionOnLocalName){
 694                                                                                                                                         token = ((CompletionOnLocalName) variable).realName;
 695                                                                                                                                 } else {
 696                                                                                                                                         token = ((CompletionOnArgumentName) variable).realName;
 697                                                                                                                                 }
 698                                                                                                                                 findVariableNames(token, variable.type, excludeNames);
 699                                                                                                                         }
 700                                                                                                                 }
 701                                                                                                         }
 702                                                                                                 }
 703                                                                                         }
 704                                                                                 }
 705                                                                         }
 706                                                                 }
 707                                                         }
 708                                                 }
 709                                         }
 710                                 }
 711                         }
 712                 }
 713         }
 714
 715 //      public void complete(IType type, char[] snippet, int position, char[][] localVariableTypeNames, char[][] localVariableNames, int[] localVariableModifiers, boolean isStatic){
 716 //              TypeConverter converter = new TypeConverter();
 717 //
 718 //              IType topLevelType = type;
 719 //              while(topLevelType.getDeclaringType() != null) {
 720 //                      topLevelType = topLevelType.getDeclaringType();
 721 //              }
 722 //
 723 //              CompilationResult compilationResult = new CompilationResult((topLevelType.getElementName() + ".java").toCharArray(), 1, 1, this.compilerOptions.maxProblemsPerUnit); //$NON-NLS-1$
 724 //
 725 //              CompilationUnitDeclaration compilationUnit = new CompilationUnitDeclaration(problemReporter, compilationResult, 0);
 726 //
 727 //              try {
 728 //                      TypeDeclaration typeDeclaration = converter.buildTypeDeclaration(type, compilationUnit, compilationResult, problemReporter);
 729 //
 730 //                      if(typeDeclaration != null) {
 731 //                              // build AST from snippet
 732 //                              Initializer fakeInitializer = parseSnippeInitializer(snippet, position, localVariableTypeNames, localVariableNames, localVariableModifiers, isStatic);
 733 //
 734 //                              // merge AST
 735 //                              FieldDeclaration[] oldFields = typeDeclaration.fields;
 736 //                              FieldDeclaration[] newFields = new FieldDeclaration[oldFields.length + 1];
 737 //                              System.arraycopy(oldFields, 0, newFields, 0, oldFields.length);
 738 //                              newFields[oldFields.length] = fakeInitializer;
 739 //                              typeDeclaration.fields = newFields;
 740 //
 741 //                              if(DEBUG) {
 742 //                                      System.out.println("SNIPPET COMPLETION AST :"); //$NON-NLS-1$
 743 //                                      System.out.println(compilationUnit.toString());
 744 //                              }
 745 //
 746 //                              if (compilationUnit.types != null) {
 747 //                                      try {
 748 //                                              lookupEnvironment.buildTypeBindings(compilationUnit);
 749 //
 750 //                                              if ((unitScope = compilationUnit.scope) != null) {
 751 //                                                      lookupEnvironment.completeTypeBindings(compilationUnit, true);
 752 //                                                      compilationUnit.scope.faultInTypes();
 753 //                                                      compilationUnit.resolve();
 754 //                                              }
 755 //                                      } catch (CompletionNodeFound e) {
 756 //                                              //                                      completionNodeFound = true;
 757 //                                              if (e.astNode != null) {
 758 //                                                      // if null then we found a problem in the completion node
 759 //                                                      complete(e.astNode, e.qualifiedBinding, e.scope);
 760 //                                              }
 761 //                                      }
 762 //                              }
 763 //                      }
 764 //              } catch(JavaModelException e) {
 765 //                      // Do nothing
 766 //              }
 767 //      }
 768
 769 //      private Initializer parseSnippeInitializer(char[] snippet, int position, char[][] localVariableTypeNames, char[][] localVariableNames, int[] localVariableModifiers, boolean isStatic){
 770 //              StringBuffer prefix = new StringBuffer();
 771 //              prefix.append("public class FakeType {\n "); //$NON-NLS-1$
 772 //              if(isStatic) {
 773 //                      prefix.append("static "); //$NON-NLS-1$
 774 //              }
 775 //              prefix.append("{\n"); //$NON-NLS-1$
 776 //              for (int i = 0; i < localVariableTypeNames.length; i++) {
 777 //                      prefix.append(AstNode.modifiersString(localVariableModifiers[i]));
 778 //                      prefix.append(' ');
 779 //                      prefix.append(localVariableTypeNames[i]);
 780 //                      prefix.append(' ');
 781 //                      prefix.append(localVariableNames[i]);
 782 //                      prefix.append(';');
 783 //              }
 784 //
 785 //              char[] fakeSource = CharOperation.concat(prefix.toString().toCharArray(), snippet, "}}".toCharArray());//$NON-NLS-1$
 786 //              offset = prefix.length();
 787 //
 788 //              String encoding = JavaCore.getOption(JavaCore.CORE_ENCODING);
 789 //              BasicCompilationUnit fakeUnit = new BasicCompilationUnit(
 790 //                      fakeSource,
 791 //                      null,
 792 //                      "FakeType.java", //$NON-NLS-1$
 793 //                      encoding);
 794 //
 795 //              actualCompletionPosition = prefix.length() + position - 1;
 796 //
 797 //              CompilationResult fakeResult = new CompilationResult(fakeUnit, 1, 1, this.compilerOptions.maxProblemsPerUnit);
 798 //              CompilationUnitDeclaration fakeAST = parser.dietParse(fakeUnit, fakeResult, actualCompletionPosition);
 799 //
 800 //              parseMethod(fakeAST, actualCompletionPosition);
 801 //
 802 //              return (Initializer)fakeAST.types[0].fields[0];
 803 //      }
 804
 805         /**
 806          * Ask the engine to compute a completion at the specified position
 807          * of the given compilation unit.
 808          *
 809          *  @return void
 810          *      completion results are answered through a requestor.
 811          *
 812          *  @param sourceUnit net.sourceforge.phpdt.internal.compiler.env.ICompilationUnit
 813          *      the source of the current compilation unit.
 814          *
 815          *  @param completionPosition int
 816          *      a position in the source where the completion is taking place.
 817          *      This position is relative to the source provided.
 818          */
 819         public void complete(ICompilationUnit sourceUnit, int completionPosition, int offset) {
 820
 821                 if(DEBUG) {
 822                         System.out.print("COMPLETION IN "); //$NON-NLS-1$
 823                         System.out.print(sourceUnit.getFileName());
 824                         System.out.print(" AT POSITION "); //$NON-NLS-1$
 825                         System.out.println(completionPosition);
 826                         System.out.println("COMPLETION - Source :"); //$NON-NLS-1$
 827                         System.out.println(sourceUnit.getContents());
 828                 }
 829                 try {
 830                         actualCompletionPosition = completionPosition - 1;
 831                         this.offset = offset;
 832                         // for now until we can change the UI.
 833                         CompilationResult result = new CompilationResult(sourceUnit, 1, 1, this.compilerOptions.maxProblemsPerUnit);
 834                         CompilationUnitDeclaration parsedUnit = parser.dietParse(sourceUnit, result, actualCompletionPosition);
 835
 836                         //              boolean completionNodeFound = false;
 837                         if (parsedUnit != null) {
 838                                 if(DEBUG) {
 839                                         System.out.println("COMPLETION - Diet AST :"); //$NON-NLS-1$
 840                                         System.out.println(parsedUnit.toString());
 841                                 }
 842
 843                                 // scan the package & import statements first
 844                                 if (parsedUnit.currentPackage instanceof CompletionOnPackageReference) {
 845                                         findPackages((CompletionOnPackageReference) parsedUnit.currentPackage);
 846                                         return;
 847                                 }
 848
 849                                 ImportReference[] imports = parsedUnit.imports;
 850                                 if (imports != null) {
 851                                         for (int i = 0, length = imports.length; i < length; i++) {
 852                                                 ImportReference importReference = imports[i];
 853                                                 if (importReference instanceof CompletionOnImportReference) {
 854                                                         findImports((CompletionOnImportReference) importReference);
 855                                                         return;
 856                                                 }
 857                                         }
 858                                 }
 859
 860                                 if (parsedUnit.types != null) {
 861                                         try {
 862                                                 lookupEnvironment.buildTypeBindings(parsedUnit);
 863
 864                                                 if ((unitScope = parsedUnit.scope) != null) {
 865                                                         source = sourceUnit.getContents();
 866                                                         lookupEnvironment.completeTypeBindings(parsedUnit, true);
 867                                                         parsedUnit.scope.faultInTypes();
 868                                                         parseMethod(parsedUnit, actualCompletionPosition);
 869                                                         if(DEBUG) {
 870                                                                 System.out.println("COMPLETION - AST :"); //$NON-NLS-1$
 871                                                                 System.out.println(parsedUnit.toString());
 872                                                         }
 873                                                         parsedUnit.resolve();
 874                                                 }
 875                                         } catch (CompletionNodeFound e) {
 876                                                 //                                      completionNodeFound = true;
 877                                                 if (e.astNode != null) {
 878                                                         if(DEBUG) {
 879                                                                 System.out.print("COMPLETION - Completion node : "); //$NON-NLS-1$
 880                                                                 System.out.println(e.astNode.toString());
 881                                                         }
 882                                                         // if null then we found a problem in the completion node
 883                                                         complete(e.astNode, e.qualifiedBinding, e.scope);
 884                                                 }
 885                                         }
 886                                 }
 887                         }
 888
 889                         /* Ignore package, import, class & interface keywords for now...
 890                                         if (!completionNodeFound) {
 891                                                 if (parsedUnit == null || parsedUnit.types == null) {
 892                                                         // this is not good enough... can still be trying to define a second type
 893                                                         CompletionScanner scanner = (CompletionScanner) parser.scanner;
 894                                                         setSourceRange(scanner.completedIdentifierStart, scanner.completedIdentifierEnd);
 895                                                         findKeywords(scanner.completionIdentifier, mainDeclarations, null);
 896                                                 }
 897                                                 // currently have no way to know if extends/implements are possible keywords
 898                                         }
 899                         */
 900                 } catch (IndexOutOfBoundsException e) { // work-around internal failure - 1GEMF6D
 901                 } catch (InvalidCursorLocation e) { // may eventually report a usefull error
 902                 } catch (AbortCompilation e) { // ignore this exception for now since it typically means we cannot find java.lang.Object
 903                 } catch (CompletionNodeFound e){ // internal failure - bugs 5618
 904                 } finally {
 905                         reset();
 906                 }
 907         }
 908
 909         private TypeBinding[] computeTypes(Expression[] arguments, BlockScope scope) {
 910
 911                 if (arguments == null)
 912                         return null;
 913
 914                 int argsLength = arguments.length;
 915                 TypeBinding[] argTypes = new TypeBinding[argsLength];
 916                 for (int a = argsLength; --a >= 0;)
 917                         argTypes[a] = arguments[a].resolveType(scope);
 918                 return argTypes;
 919         }
 920
 921         private void findAnonymousType(
 922                 ReferenceBinding currentType,
 923                 TypeBinding[] argTypes,
 924                 Scope scope,
 925                 InvocationSite invocationSite) {
 926
 927                 if (currentType.isInterface()) {
 928                         char[] completion = TypeConstants.NoChar;
 929                         // nothing to insert - do not want to replace the existing selector & arguments
 930                         if (source == null
 931                                 || source.length <= endPosition
 932                                 || source[endPosition] != ')')
 933                                 completion = new char[] { ')' };
 934
 935                         requestor.acceptAnonymousType(
 936                                 currentType.qualifiedPackageName(),
 937                                 currentType.qualifiedSourceName(),
 938                                 TypeConstants.NoCharChar,
 939                                 TypeConstants.NoCharChar,
 940                                 TypeConstants.NoCharChar,
 941                                 completion,
 942                                 IConstants.AccPublic,
 943                                 endPosition - offset,
 944                                 endPosition - offset,
 945                                 R_DEFAULT);
 946                 } else {
 947                         findConstructors(
 948                                 currentType,
 949                                 argTypes,
 950                                 scope,
 951                                 invocationSite,
 952                                 true);
 953                 }
 954         }
 955
 956         private void findClassField(char[] token, TypeBinding receiverType, Scope scope) {
 957
 958                 if (token == null)
 959                         return;
 960
 961                 if (token.length <= classField.length
 962                         && CharOperation.prefixEquals(token, classField, false /* ignore case */
 963                 )) {
 964                         int relevance = R_DEFAULT;
 965                         relevance += computeRelevanceForCaseMatching(token, classField);
 966                         relevance += computeRelevanceForExpectingType(scope.getJavaLangClass());
 967
 968                         requestor.acceptField(
 969                                 NoChar,
 970                                 NoChar,
 971                                 classField,
 972                                 NoChar,
 973                                 NoChar,
 974                                 classField,
 975                                 CompilerModifiers.AccStatic | CompilerModifiers.AccPublic,
 976                                 startPosition - offset,
 977                                 endPosition - offset,
 978                                 relevance);
 979                 }
 980         }
 981
 982         private void findConstructors(
 983                 ReferenceBinding currentType,
 984                 TypeBinding[] argTypes,
 985                 Scope scope,
 986                 InvocationSite invocationSite,
 987                 boolean forAnonymousType) {
 988
 989                 // No visibility checks can be performed without the scope & invocationSite
 990                 MethodBinding[] methods = currentType.availableMethods();
 991                 if(methods != null) {
 992                         int minArgLength = argTypes == null ? 0 : argTypes.length;
 993                         next : for (int f = methods.length; --f >= 0;) {
 994                                 MethodBinding constructor = methods[f];
 995                                 if (constructor.isConstructor()) {
 996
 997                                         if (constructor.isSynthetic()) continue next;
 998
 999                                         if (options.checkVisibility
1000                                                 && !constructor.canBeSeenBy(invocationSite, scope)) continue next;
1001
1002                                         TypeBinding[] parameters = constructor.parameters;
1003                                         int paramLength = parameters.length;
1004                                         if (minArgLength > paramLength)
1005                                                 continue next;
1006                                         for (int a = minArgLength; --a >= 0;)
1007                                                 if (argTypes[a] != null) // can be null if it could not be resolved properly
1008                                                         if (!Scope.areTypesCompatible(argTypes[a], constructor.parameters[a]))
1009                                                                 continue next;
1010
1011                                         char[][] parameterPackageNames = new char[paramLength][];
1012                                         char[][] parameterTypeNames = new char[paramLength][];
1013                                         for (int i = 0; i < paramLength; i++) {
1014                                                 TypeBinding type = parameters[i];
1015                                                 parameterPackageNames[i] = type.qualifiedPackageName();
1016                                                 parameterTypeNames[i] = type.qualifiedSourceName();
1017                                         }
1018                                         char[][] parameterNames = findMethodParameterNames(constructor,parameterTypeNames);
1019
1020                                         char[] completion = TypeConstants.NoChar;
1021                                         // nothing to insert - do not want to replace the existing selector & arguments
1022                                         if (source == null
1023                                                 || source.length <= endPosition
1024                                                 || source[endPosition] != ')')
1025                                                 completion = new char[] { ')' };
1026
1027                                         if(forAnonymousType){
1028                                                 requestor.acceptAnonymousType(
1029                                                         currentType.qualifiedPackageName(),
1030                                                         currentType.qualifiedSourceName(),
1031                                                         parameterPackageNames,
1032                                                         parameterTypeNames,
1033                                                         parameterNames,
1034                                                         completion,
1035                                                         constructor.modifiers,
1036                                                         endPosition - offset,
1037                                                         endPosition - offset,
1038                                                         R_DEFAULT);
1039                                         } else {
1040                                                 requestor.acceptMethod(
1041                                                         currentType.qualifiedPackageName(),
1042                                                         currentType.qualifiedSourceName(),
1043                                                         currentType.sourceName(),
1044                                                         parameterPackageNames,
1045                                                         parameterTypeNames,
1046                                                         parameterNames,
1047                                                         TypeConstants.NoChar,
1048                                                         TypeConstants.NoChar,
1049                                                         completion,
1050                                                         constructor.modifiers,
1051                                                         endPosition - offset,
1052                                                         endPosition - offset,
1053                                                         R_DEFAULT);
1054                                         }
1055                                 }
1056                         }
1057                 }
1058         }
1059
1060         // Helper method for findFields(char[], ReferenceBinding, Scope, ObjectVector, boolean)
1061         private void findFields(
1062                 char[] fieldName,
1063                 FieldBinding[] fields,
1064                 Scope scope,
1065                 ObjectVector fieldsFound,
1066                 ObjectVector localsFound,
1067                 boolean onlyStaticFields,
1068                 ReferenceBinding receiverType,
1069                 InvocationSite invocationSite,
1070                 Scope invocationScope,
1071                 boolean implicitCall) {
1072
1073                 // Inherited fields which are hidden by subclasses are filtered out
1074                 // No visibility checks can be performed without the scope & invocationSite
1075
1076                 int fieldLength = fieldName.length;
1077                 next : for (int f = fields.length; --f >= 0;) {
1078                         FieldBinding field = fields[f];
1079
1080                         if (field.isSynthetic())        continue next;
1081
1082                         if (onlyStaticFields && !field.isStatic()) continue next;
1083
1084                         if (fieldLength > field.name.length) continue next;
1085
1086                         if (!CharOperation.prefixEquals(fieldName, field.name, false /* ignore case */))        continue next;
1087
1088                         if (options.checkVisibility
1089                                 && !field.canBeSeenBy(receiverType, invocationSite, scope))     continue next;
1090
1091                         boolean prefixRequired = false;
1092
1093                         for (int i = fieldsFound.size; --i >= 0;) {
1094                                 Object[] other = (Object[])fieldsFound.elementAt(i);
1095                                 FieldBinding otherField = (FieldBinding) other[0];
1096                                 ReferenceBinding otherReceiverType = (ReferenceBinding) other[1];
1097                                 if (field == otherField && receiverType == otherReceiverType)
1098                                         continue next;
1099                                 if (CharOperation.equals(field.name, otherField.name, true)) {
1100                                         if (field.declaringClass.isSuperclassOf(otherField.declaringClass))
1101                                                 continue next;
1102                                         if (otherField.declaringClass.isInterface())
1103                                                 if (field.declaringClass.implementsInterface(otherField.declaringClass, true))
1104                                                         continue next;
1105                                         if (field.declaringClass.isInterface())
1106                                                 if (otherField.declaringClass.implementsInterface(field.declaringClass, true))
1107                                                         continue next;
1108                                         prefixRequired = true;
1109                                 }
1110                         }
1111
1112                         for (int l = localsFound.size; --l >= 0;) {
1113                                 LocalVariableBinding local = (LocalVariableBinding) localsFound.elementAt(l);
1114
1115                                 if (CharOperation.equals(field.name, local.name, true)) {
1116                                         SourceTypeBinding declarationType = scope.enclosingSourceType();
1117                                         if (declarationType.isAnonymousType() && declarationType != invocationScope.enclosingSourceType()) {
1118                                                 continue next;
1119                                         }
1120                                         prefixRequired = true;
1121                                         break;
1122                                 }
1123                         }
1124
1125                         fieldsFound.add(new Object[]{field, receiverType});
1126
1127                         char[] completion = field.name;
1128
1129                         if(prefixRequired || options.forceImplicitQualification){
1130                                 char[] prefix = computePrefix(scope.enclosingSourceType(), invocationScope.enclosingSourceType(), field.isStatic());
1131                                 completion = CharOperation.concat(prefix,completion,'.');
1132                         }
1133
1134                         int relevance = R_DEFAULT;
1135                         relevance += computeRelevanceForCaseMatching(fieldName, field.name);
1136                         relevance += computeRelevanceForExpectingType(field.type);
1137
1138                         requestor
1139                                 .acceptField(
1140                                         field.declaringClass.qualifiedPackageName(),
1141                                         field.declaringClass.qualifiedSourceName(),
1142                                         field.name,
1143                                         field.type.qualifiedPackageName(),
1144                                         field.type.qualifiedSourceName(),
1145                                         completion,
1146                         // may include some qualification to resolve ambiguities
1147                         field.modifiers, startPosition - offset, endPosition - offset,
1148                         relevance);
1149                 }
1150         }
1151
1152         private void findFields(
1153                 char[] fieldName,
1154                 ReferenceBinding receiverType,
1155                 Scope scope,
1156                 ObjectVector fieldsFound,
1157                 ObjectVector localsFound,
1158                 boolean onlyStaticFields,
1159                 InvocationSite invocationSite,
1160                 Scope invocationScope,
1161                 boolean implicitCall) {
1162
1163                 if (fieldName == null)
1164                         return;
1165
1166                 ReferenceBinding currentType = receiverType;
1167                 ReferenceBinding[][] interfacesToVisit = null;
1168                 int lastPosition = -1;
1169                 do {
1170
1171                         ReferenceBinding[] itsInterfaces = currentType.superInterfaces();
1172                         if (itsInterfaces != NoSuperInterfaces) {
1173
1174                                 if (interfacesToVisit == null)
1175                                         interfacesToVisit = new ReferenceBinding[5][];
1176
1177                                 if (++lastPosition == interfacesToVisit.length)
1178                                         System.arraycopy(
1179                                                 interfacesToVisit,
1180                                                 0,
1181                                                 interfacesToVisit = new ReferenceBinding[lastPosition * 2][],
1182                                                 0,
1183                                                 lastPosition);
1184                                 interfacesToVisit[lastPosition] = itsInterfaces;
1185                         }
1186
1187                         FieldBinding[] fields = currentType.availableFields();
1188                         if(fields != null) {
1189                                 findFields(
1190                                         fieldName,
1191                                         fields,
1192                                         scope,
1193                                         fieldsFound,
1194                                         localsFound,
1195                                         onlyStaticFields,
1196                                         receiverType,
1197                                         invocationSite,
1198                                         invocationScope,
1199                                         implicitCall);
1200                         }
1201                         currentType = currentType.superclass();
1202                 } while (currentType != null);
1203
1204                 if (interfacesToVisit != null) {
1205                         for (int i = 0; i <= lastPosition; i++) {
1206                                 ReferenceBinding[] interfaces = interfacesToVisit[i];
1207                                 for (int j = 0, length = interfaces.length; j < length; j++) {
1208
1209                                         ReferenceBinding anInterface = interfaces[j];
1210                                         if ((anInterface.tagBits & TagBits.InterfaceVisited) == 0) {
1211                                                 // if interface as not already been visited
1212                                                 anInterface.tagBits |= TagBits.InterfaceVisited;
1213
1214                                                 FieldBinding[] fields = anInterface.availableFields();
1215                                                 if(fields !=  null) {
1216                                                         findFields(
1217                                                                 fieldName,
1218                                                                 fields,
1219                                                                 scope,
1220                                                                 fieldsFound,
1221                                                                 localsFound,
1222                                                                 onlyStaticFields,
1223                                                                 receiverType,
1224                                                                 invocationSite,
1225                                                                 invocationScope,
1226                                                                 implicitCall);
1227                                                 }
1228
1229                                                 ReferenceBinding[] itsInterfaces = anInterface.superInterfaces();
1230                                                 if (itsInterfaces != NoSuperInterfaces) {
1231                                                         if (++lastPosition == interfacesToVisit.length)
1232                                                                 System.arraycopy(
1233                                                                         interfacesToVisit,
1234                                                                         0,
1235                                                                         interfacesToVisit = new ReferenceBinding[lastPosition * 2][],
1236                                                                         0,
1237                                                                         lastPosition);
1238                                                         interfacesToVisit[lastPosition] = itsInterfaces;
1239                                                 }
1240                                         }
1241                                 }
1242                         }
1243
1244                         // bit reinitialization
1245                         for (int i = 0; i <= lastPosition; i++) {
1246                                 ReferenceBinding[] interfaces = interfacesToVisit[i];
1247                                 for (int j = 0, length = interfaces.length; j < length; j++)
1248                                         interfaces[j].tagBits &= ~TagBits.InterfaceVisited;
1249                         }
1250                 }
1251         }
1252
1253         private void findFieldsAndMethods(
1254                 char[] token,
1255                 TypeBinding receiverType,
1256                 Scope scope,
1257                 InvocationSite invocationSite,
1258                 Scope invocationScope,
1259                 boolean implicitCall) {
1260
1261                 if (token == null)
1262                         return;
1263
1264                 if (receiverType.isBaseType())
1265                         return; // nothing else is possible with base types
1266
1267                 if (receiverType.isArrayType()) {
1268                         if (token.length <= lengthField.length
1269                                 && CharOperation.prefixEquals(token, lengthField, false /* ignore case */
1270                         )) {
1271
1272                                 int relevance = R_DEFAULT;
1273                                 relevance += computeRelevanceForCaseMatching(token,lengthField);
1274                                 relevance += computeRelevanceForExpectingType(BaseTypes.IntBinding);
1275
1276                                 requestor.acceptField(
1277                                         NoChar,
1278                                         NoChar,
1279                                         lengthField,
1280                                         NoChar,
1281                                         NoChar,
1282                                         lengthField,
1283                                         CompilerModifiers.AccPublic,
1284                                         startPosition - offset,
1285                                         endPosition - offset,
1286                                         relevance);
1287                         }
1288                         receiverType = scope.getJavaLangObject();
1289                 }
1290
1291                 findFields(
1292                         token,
1293                         (ReferenceBinding) receiverType,
1294                         scope,
1295                         new ObjectVector(),
1296                         new ObjectVector(),
1297                         false,
1298                         invocationSite,
1299                         invocationScope,
1300                         implicitCall);
1301
1302                 findMethods(
1303                         token,
1304                         null,
1305                         (ReferenceBinding) receiverType,
1306                         scope,
1307                         new ObjectVector(),
1308                         false,
1309                         false,
1310                         false,
1311                         invocationSite,
1312                         invocationScope,
1313                         implicitCall);
1314         }
1315
1316         private void findImports(CompletionOnImportReference importReference) {
1317                 char[][] tokens = importReference.tokens;
1318
1319                 char[] importName = CharOperation.concatWith(tokens, '.');
1320
1321                 if (importName.length == 0)
1322                         return;
1323
1324                 char[] lastToken = tokens[tokens.length - 1];
1325                 if(lastToken != null && lastToken.length == 0)
1326                         importName = CharOperation.concat(importName, new char[]{'.'});
1327
1328                 resolvingImports = true;
1329                 setSourceRange(
1330                         importReference.sourceStart,
1331                         importReference.declarationSourceEnd);
1332
1333                 token =  importName;
1334                 // want to replace the existing .*;
1335                 nameEnvironment.findPackages(importName, this);
1336                 nameEnvironment.findTypes(importName, this);
1337         }
1338
1339         // what about onDemand types? Ignore them since it does not happen!
1340         // import p1.p2.A.*;
1341         private void findKeywords(char[] keyword, char[][] choices, Scope scope) {
1342
1343                 int length = keyword.length;
1344                 if (length > 0)
1345                         for (int i = 0; i < choices.length; i++)
1346                                 if (length <= choices[i].length
1347                                         && CharOperation.prefixEquals(keyword, choices[i], false /* ignore case */
1348                                 )){
1349                                         int relevance = R_DEFAULT;
1350                                         relevance += computeRelevanceForCaseMatching(keyword, choices[i]);
1351
1352                                         requestor.acceptKeyword(choices[i], startPosition - offset, endPosition - offset,relevance);
1353                                 }
1354         }
1355
1356         // Helper method for findMemberTypes(char[], ReferenceBinding, Scope)
1357         private void findMemberTypes(
1358                 char[] typeName,
1359                 ReferenceBinding[] memberTypes,
1360                 ObjectVector typesFound,
1361                 ReferenceBinding receiverType,
1362                 SourceTypeBinding invocationType) {
1363
1364                 // Inherited member types which are hidden by subclasses are filtered out
1365                 // No visibility checks can be performed without the scope & invocationSite
1366                 int typeLength = typeName.length;
1367                 next : for (int m = memberTypes.length; --m >= 0;) {
1368                         ReferenceBinding memberType = memberTypes[m];
1369                         //              if (!wantClasses && memberType.isClass()) continue next;
1370                         //              if (!wantInterfaces && memberType.isInterface()) continue next;
1371                         if (typeLength > memberType.sourceName.length)
1372                                 continue next;
1373
1374                         if (!CharOperation.prefixEquals(typeName, memberType.sourceName, false
1375                                 /* ignore case */
1376                                 ))
1377                                 continue next;
1378
1379                         if (options.checkVisibility
1380                                 && !memberType.canBeSeenBy(receiverType, invocationType))
1381                                 continue next;
1382
1383                         for (int i = typesFound.size; --i >= 0;) {
1384                                 ReferenceBinding otherType = (ReferenceBinding) typesFound.elementAt(i);
1385
1386                                 if (memberType == otherType)
1387                                         continue next;
1388
1389                                 if (CharOperation.equals(memberType.sourceName, otherType.sourceName, true)) {
1390
1391                                         if (memberType.enclosingType().isSuperclassOf(otherType.enclosingType()))
1392                                                 continue next;
1393
1394                                         if (otherType.enclosingType().isInterface())
1395                                                 if (memberType.enclosingType()
1396                                                         .implementsInterface(otherType.enclosingType(), true))
1397                                                         continue next;
1398
1399                                         if (memberType.enclosingType().isInterface())
1400                                                 if (otherType.enclosingType()
1401                                                         .implementsInterface(memberType.enclosingType(), true))
1402                                                         continue next;
1403                                 }
1404                         }
1405
1406                         typesFound.add(memberType);
1407
1408                         int relevance = R_DEFAULT;
1409                         relevance += computeRelevanceForCaseMatching(typeName, memberType.sourceName);
1410                         relevance += computeRelevanceForExpectingType(memberType);
1411
1412                         if (memberType.isClass()) {
1413                                 relevance += computeRelevanceForClass();
1414                                 requestor.acceptClass(
1415                                         memberType.qualifiedPackageName(),
1416                                         memberType.qualifiedSourceName(),
1417                                         memberType.sourceName(),
1418                                         memberType.modifiers,
1419                                         startPosition - offset,
1420                                         endPosition - offset,
1421                                         relevance);
1422
1423                         } else {
1424                                 relevance += computeRelevanceForInterface();
1425                                 requestor.acceptInterface(
1426                                         memberType.qualifiedPackageName(),
1427                                         memberType.qualifiedSourceName(),
1428                                         memberType.sourceName(),
1429                                         memberType.modifiers,
1430                                         startPosition - offset,
1431                                         endPosition - offset,
1432                                         relevance);
1433                         }
1434                 }
1435         }
1436
1437         private void findMemberTypes(
1438                 char[] typeName,
1439                 ReferenceBinding receiverType,
1440                 Scope scope,
1441                 SourceTypeBinding typeInvocation) {
1442
1443                 ReferenceBinding currentType = receiverType;
1444                 if (typeName == null)
1445                         return;
1446
1447                 if (currentType.superInterfaces() == null)
1448                         return; // we're trying to find a supertype
1449
1450                 ObjectVector typesFound = new ObjectVector();
1451                 if (insideQualifiedReference
1452                         || typeName.length == 0) { // do not search up the hierarchy
1453
1454                         findMemberTypes(
1455                                 typeName,
1456                                 currentType.memberTypes(),
1457                                 typesFound,
1458                                 receiverType,
1459                                 typeInvocation);
1460                         return;
1461                 }
1462
1463                 ReferenceBinding[][] interfacesToVisit = null;
1464                 int lastPosition = -1;
1465
1466                 do {
1467
1468                         ReferenceBinding[] itsInterfaces = currentType.superInterfaces();
1469                         if (itsInterfaces != NoSuperInterfaces) {
1470
1471                                 if (interfacesToVisit == null)
1472                                         interfacesToVisit = new ReferenceBinding[5][];
1473
1474                                 if (++lastPosition == interfacesToVisit.length)
1475                                         System.arraycopy(
1476                                                 interfacesToVisit,
1477                                                 0,
1478                                                 interfacesToVisit = new ReferenceBinding[lastPosition * 2][],
1479                                                 0,
1480                                                 lastPosition);
1481                                 interfacesToVisit[lastPosition] = itsInterfaces;
1482                         }
1483
1484                         findMemberTypes(
1485                                 typeName,
1486                                 currentType.memberTypes(),
1487                                 typesFound,
1488                                 receiverType,
1489                                 typeInvocation);
1490                         currentType = currentType.superclass();
1491
1492                 } while (currentType != null);
1493
1494                 if (interfacesToVisit != null) {
1495                         for (int i = 0; i <= lastPosition; i++) {
1496                                 ReferenceBinding[] interfaces = interfacesToVisit[i];
1497                                 for (int j = 0, length = interfaces.length; j < length; j++) {
1498
1499                                         ReferenceBinding anInterface = interfaces[j];
1500                                         if ((anInterface.tagBits & TagBits.InterfaceVisited) == 0) {
1501                                                 // if interface as not already been visited
1502                                                 anInterface.tagBits |= TagBits.InterfaceVisited;
1503
1504                                                 findMemberTypes(
1505                                                         typeName,
1506                                                         anInterface.memberTypes(),
1507                                                         typesFound,
1508                                                         receiverType,
1509                                                         typeInvocation);
1510
1511                                                 ReferenceBinding[] itsInterfaces = anInterface.superInterfaces();
1512                                                 if (itsInterfaces != NoSuperInterfaces) {
1513
1514                                                         if (++lastPosition == interfacesToVisit.length)
1515                                                                 System.arraycopy(
1516                                                                         interfacesToVisit,
1517                                                                         0,
1518                                                                         interfacesToVisit = new ReferenceBinding[lastPosition * 2][],
1519                                                                         0,
1520                                                                         lastPosition);
1521                                                         interfacesToVisit[lastPosition] = itsInterfaces;
1522                                                 }
1523                                         }
1524                                 }
1525                         }
1526
1527                         // bit reinitialization
1528                         for (int i = 0; i <= lastPosition; i++) {
1529                                 ReferenceBinding[] interfaces = interfacesToVisit[i];
1530                                 for (int j = 0, length = interfaces.length; j < length; j++)
1531                                         interfaces[j].tagBits &= ~TagBits.InterfaceVisited;
1532                         }
1533                 }
1534         }
1535
1536         private void findIntefacesMethods(
1537                 char[] selector,
1538                 TypeBinding[] argTypes,
1539                 ReferenceBinding receiverType,
1540                 ReferenceBinding[] itsInterfaces,
1541                 Scope scope,
1542                 ObjectVector methodsFound,
1543                 boolean onlyStaticMethods,
1544                 boolean exactMatch,
1545                 boolean isCompletingDeclaration,
1546                 InvocationSite invocationSite,
1547                 Scope invocationScope,
1548                 boolean implicitCall) {
1549
1550                 if (selector == null)
1551                         return;
1552
1553                 if (itsInterfaces != NoSuperInterfaces) {
1554                         ReferenceBinding[][] interfacesToVisit = new ReferenceBinding[5][];
1555                         int lastPosition = 0;
1556                         interfacesToVisit[lastPosition] = itsInterfaces;
1557
1558                         for (int i = 0; i <= lastPosition; i++) {
1559                                 ReferenceBinding[] interfaces = interfacesToVisit[i];
1560
1561                                 for (int j = 0, length = interfaces.length; j < length; j++) {
1562                                         ReferenceBinding currentType = interfaces[j];
1563
1564                                         if ((currentType.tagBits & TagBits.InterfaceVisited) == 0) {
1565                                                 // if interface as not already been visited
1566                                                 currentType.tagBits |= TagBits.InterfaceVisited;
1567
1568                                                 MethodBinding[] methods = currentType.availableMethods();
1569                                                 if(methods != null) {
1570                                                         if(isCompletingDeclaration){
1571
1572                                                                 findLocalMethodDeclarations(
1573                                                                         selector,
1574                                                                         methods,
1575                                                                         scope,
1576                                                                         methodsFound,
1577                                                                         onlyStaticMethods,
1578                                                                         exactMatch,
1579                                                                         receiverType);
1580
1581                                                         } else {
1582
1583                                                                 findLocalMethods(
1584                                                                         selector,
1585                                                                         argTypes,
1586                                                                         methods,
1587                                                                         scope,
1588                                                                         methodsFound,
1589                                                                         onlyStaticMethods,
1590                                                                         exactMatch,
1591                                                                         receiverType,
1592                                                                         invocationSite,
1593                                                                         invocationScope,
1594                                                                         implicitCall);
1595                                                         }
1596                                                 }
1597
1598                                                 itsInterfaces = currentType.superInterfaces();
1599                                                 if (itsInterfaces != NoSuperInterfaces) {
1600
1601                                                         if (++lastPosition == interfacesToVisit.length)
1602                                                                 System.arraycopy(
1603                                                                         interfacesToVisit,
1604                                                                         0,
1605                                                                         interfacesToVisit = new ReferenceBinding[lastPosition * 2][],
1606                                                                         0,
1607                                                                         lastPosition);
1608                                                         interfacesToVisit[lastPosition] = itsInterfaces;
1609                                                 }
1610                                         }
1611                                 }
1612                         }
1613
1614                         // bit reinitialization
1615                         for (int i = 0; i <= lastPosition; i++) {
1616                                 ReferenceBinding[] interfaces = interfacesToVisit[i];
1617
1618                                 for (int j = 0, length = interfaces.length; j < length; j++){
1619                                         interfaces[j].tagBits &= ~TagBits.InterfaceVisited;
1620                                 }
1621                         }
1622                 }
1623         }
1624
1625         private void findImplicitMessageSends(
1626                 char[] token,
1627                 TypeBinding[] argTypes,
1628                 Scope scope,
1629                 InvocationSite invocationSite,
1630                 Scope invocationScope) {
1631
1632                 if (token == null)
1633                         return;
1634
1635                 boolean staticsOnly = false;
1636                 // need to know if we're in a static context (or inside a constructor)
1637                 ObjectVector methodsFound = new ObjectVector();
1638
1639                 done : while (true) { // done when a COMPILATION_UNIT_SCOPE is found
1640
1641                         switch (scope.kind) {
1642
1643                                 case Scope.METHOD_SCOPE :
1644                                         // handle the error case inside an explicit constructor call (see MethodScope>>findField)
1645                                         MethodScope methodScope = (MethodScope) scope;
1646                                         staticsOnly |= methodScope.isStatic | methodScope.isConstructorCall;
1647                                         break;
1648
1649                                 case Scope.CLASS_SCOPE :
1650                                         ClassScope classScope = (ClassScope) scope;
1651                                         SourceTypeBinding enclosingType = classScope.referenceContext.binding;
1652                                         findMethods(
1653                                                 token,
1654                                                 argTypes,
1655                                                 enclosingType,
1656                                                 classScope,
1657                                                 methodsFound,
1658                                                 staticsOnly,
1659                                                 true,
1660                                                 false,
1661                                                 invocationSite,
1662                                                 invocationScope,
1663                                                 true);
1664                                         staticsOnly |= enclosingType.isStatic();
1665                                         break;
1666
1667                                 case Scope.COMPILATION_UNIT_SCOPE :
1668                                         break done;
1669                         }
1670                         scope = scope.parent;
1671                 }
1672         }
1673
1674         // Helper method for findMethods(char[], TypeBinding[], ReferenceBinding, Scope, ObjectVector, boolean, boolean, boolean)
1675         private void findLocalMethods(
1676                 char[] methodName,
1677                 TypeBinding[] argTypes,
1678                 MethodBinding[] methods,
1679                 Scope scope,
1680                 ObjectVector methodsFound,
1681                 boolean onlyStaticMethods,
1682                 boolean exactMatch,
1683                 ReferenceBinding receiverType,
1684                 InvocationSite invocationSite,
1685                 Scope invocationScope,
1686                 boolean implicitCall) {
1687
1688                 // Inherited methods which are hidden by subclasses are filtered out
1689                 // No visibility checks can be performed without the scope & invocationSite
1690
1691                 int methodLength = methodName.length;
1692                 int minArgLength = argTypes == null ? 0 : argTypes.length;
1693
1694                 next : for (int f = methods.length; --f >= 0;) {
1695                         MethodBinding method = methods[f];
1696
1697                         if (method.isSynthetic()) continue next;
1698
1699                         if (method.isDefaultAbstract()) continue next;
1700
1701                         if (method.isConstructor()) continue next;
1702
1703                         //              if (noVoidReturnType && method.returnType == BaseTypes.VoidBinding) continue next;
1704                         if (onlyStaticMethods && !method.isStatic()) continue next;
1705
1706                         if (options.checkVisibility
1707                                 && !method.canBeSeenBy(receiverType, invocationSite, scope)) continue next;
1708
1709                         if (exactMatch) {
1710                                 if (!CharOperation.equals(methodName, method.selector, false /* ignore case */
1711                                         ))
1712                                         continue next;
1713
1714                         } else {
1715
1716                                 if (methodLength > method.selector.length)
1717                                         continue next;
1718
1719                                 if (!CharOperation.prefixEquals(methodName, method.selector, false
1720                                         /* ignore case */
1721                                         ))
1722                                         continue next;
1723                         }
1724                         if (minArgLength > method.parameters.length)
1725                                 continue next;
1726
1727                         for (int a = minArgLength; --a >= 0;){
1728                                 if (argTypes[a] != null){ // can be null if it could not be resolved properly
1729                                         if (!Scope.areTypesCompatible(argTypes[a], method.parameters[a])) {
1730                                                 continue next;
1731                                         }
1732                                 }
1733                         }
1734
1735                         boolean prefixRequired = false;
1736
1737                         for (int i = methodsFound.size; --i >= 0;) {
1738                                 Object[] other = (Object[]) methodsFound.elementAt(i);
1739                                 MethodBinding otherMethod = (MethodBinding) other[0];
1740                                 ReferenceBinding otherReceiverType = (ReferenceBinding) other[1];
1741                                 if (method == otherMethod && receiverType == otherReceiverType)
1742                                         continue next;
1743
1744                                 if (CharOperation.equals(method.selector, otherMethod.selector, true)
1745                                         && method.areParametersEqual(otherMethod)) {
1746
1747                                         if (method.declaringClass.isSuperclassOf(otherMethod.declaringClass))
1748                                                 continue next;
1749
1750                                         if (otherMethod.declaringClass.isInterface())
1751                                                 if (method
1752                                                         .declaringClass
1753                                                         .implementsInterface(otherMethod.declaringClass, true))
1754                                                         continue next;
1755
1756                                         if (method.declaringClass.isInterface())
1757                                                 if(otherMethod
1758                                                         .declaringClass
1759                                                         .implementsInterface(method.declaringClass,true))
1760                                                         continue next;
1761                                         prefixRequired = true;
1762                                 }
1763                         }
1764
1765                         methodsFound.add(new Object[]{method, receiverType});
1766                         int length = method.parameters.length;
1767                         char[][] parameterPackageNames = new char[length][];
1768                         char[][] parameterTypeNames = new char[length][];
1769
1770                         for (int i = 0; i < length; i++) {
1771                                 TypeBinding type = method.parameters[i];
1772                                 parameterPackageNames[i] = type.qualifiedPackageName();
1773                                 parameterTypeNames[i] = type.qualifiedSourceName();
1774                         }
1775                         char[][] parameterNames = findMethodParameterNames(method,parameterTypeNames);
1776
1777                         char[] completion = TypeConstants.NoChar;
1778
1779                         int previousStartPosition = startPosition;
1780
1781                         // nothing to insert - do not want to replace the existing selector & arguments
1782                         if (!exactMatch) {
1783                                 if (source != null
1784                                         && source.length > endPosition
1785                                         && source[endPosition] == '(')
1786                                         completion = method.selector;
1787                                 else
1788                                         completion = CharOperation.concat(method.selector, new char[] { '(', ')' });
1789                         } else {
1790                                 if(prefixRequired && (source != null)) {
1791                                         completion = CharOperation.subarray(source, startPosition, endPosition);
1792                                 } else {
1793                                         startPosition = endPosition;
1794                                 }
1795                         }
1796
1797                         if(prefixRequired || options.forceImplicitQualification){
1798                                 char[] prefix = computePrefix(scope.enclosingSourceType(), invocationScope.enclosingSourceType(), method.isStatic());
1799                                 completion = CharOperation.concat(prefix,completion,'.');
1800                         }
1801
1802                         int relevance = R_DEFAULT;
1803                         relevance += computeRelevanceForCaseMatching(methodName, method.selector);
1804                         relevance += computeRelevanceForExpectingType(method.returnType);
1805
1806                         requestor.acceptMethod(
1807                                 method.declaringClass.qualifiedPackageName(),
1808                                 method.declaringClass.qualifiedSourceName(),
1809                                 method.selector,
1810                                 parameterPackageNames,
1811                                 parameterTypeNames,
1812                                 parameterNames,
1813                                 method.returnType.qualifiedPackageName(),
1814                                 method.returnType.qualifiedSourceName(),
1815                                 completion,
1816                                 method.modifiers,
1817                                 startPosition - offset,
1818                                 endPosition - offset,
1819                                 relevance);
1820                         startPosition = previousStartPosition;
1821                 }
1822         }
1823
1824         private int computeRelevanceForCaseMatching(char[] token, char[] proposalName){
1825                 if (CharOperation.prefixEquals(token, proposalName, true /* do not ignore case */)) {
1826                         return  R_CASE;
1827                 } else {
1828                         return R_DEFAULT;
1829                 }
1830         }
1831         private int computeRelevanceForClass(){
1832                 if(assistNodeIsClass) {
1833                         return R_CLASS;
1834                 }
1835                 return 0;
1836         }
1837         private int computeRelevanceForInterface(){
1838                 if(assistNodeIsInterface) {
1839                         return R_INTERFACE;
1840                 }
1841                 return R_DEFAULT;
1842         }
1843         private int computeRelevanceForException(char[] proposalName){
1844
1845                 if(assistNodeIsException &&
1846                         (CharOperation.match(EXCEPTION_PATTERN, proposalName, false) ||
1847                         CharOperation.match(ERROR_PATTERN, proposalName, false))) {
1848                         return R_EXCEPTION;
1849                 }
1850                 return R_DEFAULT;
1851         }
1852         private int computeRelevanceForExpectingType(TypeBinding proposalType){
1853                 if(expectedTypes != null && proposalType != null) {
1854                         for (int i = 0; i < expectedTypes.length; i++) {
1855                                 if(Scope.areTypesCompatible(proposalType, expectedTypes[i])) {
1856                                         return R_EXPECTED_TYPE;
1857                                 }
1858                         }
1859                 }
1860                 return R_DEFAULT;
1861         }
1862         private int computeRelevanceForExpectingType(char[] packageName, char[] typeName){
1863                 if(expectedTypes != null) {
1864                         for (int i = 0; i < expectedTypes.length; i++) {
1865                                 if(CharOperation.equals(expectedTypes[i].qualifiedPackageName(), packageName) &&
1866                                         CharOperation.equals(expectedTypes[i].qualifiedSourceName(), typeName)) {
1867                                         return R_EXPECTED_TYPE;
1868                                 }
1869                         }
1870                 }
1871                 return R_DEFAULT;
1872         }
1873
1874         // Helper method for findMethods(char[], MethodBinding[], Scope, ObjectVector, boolean, boolean, boolean, TypeBinding)
1875         private void findLocalMethodDeclarations(
1876                 char[] methodName,
1877                 MethodBinding[] methods,
1878                 Scope scope,
1879                 ObjectVector methodsFound,
1880                 //      boolean noVoidReturnType, how do you know?
1881                 boolean onlyStaticMethods,
1882                 boolean exactMatch,
1883                 ReferenceBinding receiverType) {
1884
1885                 // Inherited methods which are hidden by subclasses are filtered out
1886                 // No visibility checks can be performed without the scope & invocationSite
1887                 int methodLength = methodName.length;
1888                 next : for (int f = methods.length; --f >= 0;) {
1889
1890                         MethodBinding method = methods[f];
1891                         if (method.isSynthetic())       continue next;
1892
1893                         if (method.isDefaultAbstract()) continue next;
1894
1895                         if (method.isConstructor()) continue next;
1896
1897                         if (method.isFinal()) continue next;
1898
1899                         //              if (noVoidReturnType && method.returnType == BaseTypes.VoidBinding) continue next;
1900                         if (onlyStaticMethods && !method.isStatic()) continue next;
1901
1902                         if (options.checkVisibility
1903                                 && !method.canBeSeenBy(receiverType, FakeInvocationSite , scope)) continue next;
1904
1905                         if (exactMatch) {
1906                                 if (!CharOperation.equals(methodName, method.selector, false /* ignore case */
1907                                         ))
1908                                         continue next;
1909
1910                         } else {
1911
1912                                 if (methodLength > method.selector.length)
1913                                         continue next;
1914
1915                                 if (!CharOperation.prefixEquals(methodName, method.selector, false
1916                                         /* ignore case */
1917                                         ))
1918                                         continue next;
1919                         }
1920
1921                         for (int i = methodsFound.size; --i >= 0;) {
1922                                 MethodBinding otherMethod = (MethodBinding) methodsFound.elementAt(i);
1923                                 if (method == otherMethod)
1924                                         continue next;
1925
1926                                 if (CharOperation.equals(method.selector, otherMethod.selector, true)
1927                                         && method.areParametersEqual(otherMethod)) {
1928                                         continue next;
1929                                 }
1930                         }
1931
1932                         methodsFound.add(method);
1933
1934                         int length = method.parameters.length;
1935                         char[][] parameterPackageNames = new char[length][];
1936                         char[][] parameterTypeNames = new char[length][];
1937
1938                         for (int i = 0; i < length; i++) {
1939                                 TypeBinding type = method.parameters[i];
1940                                 parameterPackageNames[i] = type.qualifiedPackageName();
1941                                 parameterTypeNames[i] = type.qualifiedSourceName();
1942                         }
1943
1944                         char[][] parameterNames = findMethodParameterNames(method,parameterTypeNames);
1945
1946                         StringBuffer completion = new StringBuffer(10);
1947                         // flush uninteresting modifiers
1948                         int insertedModifiers = method.modifiers & ~(CompilerModifiers.AccNative | CompilerModifiers.AccAbstract);
1949
1950                         if (!exactMatch) {
1951                                 if(insertedModifiers != CompilerModifiers.AccDefault){
1952                                         completion.append(AstNode.modifiersString(insertedModifiers));
1953                                 }
1954                                 char[] returnPackageName = method.returnType.qualifiedPackageName();
1955                                 char[] returnTypeName = method.returnType.qualifiedSourceName();
1956                                 if(mustQualifyType(returnPackageName, returnTypeName)) {
1957                                         completion.append(CharOperation.concat(returnPackageName, returnTypeName,'.'));
1958                                 } else {
1959                                         completion.append(method.returnType.sourceName());
1960                                 }
1961                                 completion.append(' ');
1962                                 completion.append(method.selector);
1963                                 completion.append('(');
1964
1965                                 for(int i = 0; i < length ; i++){
1966                                         if(mustQualifyType(parameterPackageNames[i], parameterTypeNames[i])){
1967                                                 completion.append(CharOperation.concat(parameterPackageNames[i], parameterTypeNames[i], '.'));
1968                                         } else {
1969                                                 completion.append(parameterTypeNames[i]);
1970                                         }
1971                                         completion.append(' ');
1972                                         if(parameterNames != null){
1973                                                 completion.append(parameterNames[i]);
1974                                         } else {
1975                                                 completion.append('%');
1976                                         }
1977                                         if(i != (length - 1))
1978                                                 completion.append(',');
1979                                 }
1980                                 completion.append(')');
1981
1982                                 ReferenceBinding[] exceptions = method.thrownExceptions;
1983
1984                                 if (exceptions != null && exceptions.length > 0){
1985                                         completion.append(' ');
1986                                         completion.append(THROWS);
1987                                         completion.append(' ');
1988                                         for(int i = 0; i < exceptions.length ; i++){
1989                                                 ReferenceBinding exception = exceptions[i];
1990
1991                                                 char[] exceptionPackageName = exception.qualifiedPackageName();
1992                                                 char[] exceptionTypeName = exception.qualifiedSourceName();
1993
1994                                                 if(i != 0){
1995                                                         completion.append(',');
1996                                                         completion.append(' ');
1997                                                 }
1998
1999                                                 if(mustQualifyType(exceptionPackageName, exceptionTypeName)){
2000                                                         completion.append(CharOperation.concat(exceptionPackageName, exceptionTypeName, '.'));
2001                                                 } else {
2002                                                         completion.append(exception.sourceName());
2003                                                 }
2004                                         }
2005                                 }
2006                         }
2007
2008                         int relevance = R_DEFAULT;
2009                         relevance += computeRelevanceForCaseMatching(methodName, method.selector);
2010
2011                         requestor.acceptMethodDeclaration(
2012                                 method.declaringClass.qualifiedPackageName(),
2013                                 method.declaringClass.qualifiedSourceName(),
2014                                 method.selector,
2015                                 parameterPackageNames,
2016                                 parameterTypeNames,
2017                                 parameterNames,
2018                                 method.returnType.qualifiedPackageName(),
2019                                 method.returnType.qualifiedSourceName(),
2020                                 completion.toString().toCharArray(),
2021                                 method.modifiers,
2022                                 startPosition - offset,
2023                                 endPosition - offset,
2024                                 relevance);
2025                 }
2026         }
2027         private void findMethods(
2028                 char[] selector,
2029                 TypeBinding[] argTypes,
2030                 ReferenceBinding receiverType,
2031                 Scope scope,
2032                 ObjectVector methodsFound,
2033                 boolean onlyStaticMethods,
2034                 boolean exactMatch,
2035                 boolean isCompletingDeclaration,
2036                 InvocationSite invocationSite,
2037                 Scope invocationScope,
2038                 boolean implicitCall) {
2039                 if (selector == null)
2040                         return;
2041
2042                 if(isCompletingDeclaration) {
2043                         MethodBinding[] methods = receiverType.availableMethods();
2044                         if (methods != null){
2045                                 for (int i = 0; i < methods.length; i++) {
2046                                         if(!methods[i].isDefaultAbstract()) {
2047                                                 methodsFound.add(methods[i]);
2048                                         }
2049                                 }
2050                         }
2051                 }
2052
2053                 ReferenceBinding currentType = receiverType;
2054                 if (receiverType.isInterface()) {
2055                         if(isCompletingDeclaration) {
2056                                 findIntefacesMethods(
2057                                         selector,
2058                                         argTypes,
2059                                         receiverType,
2060                                         currentType.superInterfaces(),
2061                                         scope,
2062                                         methodsFound,
2063                                         onlyStaticMethods,
2064                                         exactMatch,
2065                                         isCompletingDeclaration,
2066                                         invocationSite,
2067                                         invocationScope,
2068                                         implicitCall);
2069                         } else {
2070                                 findIntefacesMethods(
2071                                         selector,
2072                                         argTypes,
2073                                         receiverType,
2074                                         new ReferenceBinding[]{currentType},
2075                                         scope,
2076                                         methodsFound,
2077                                         onlyStaticMethods,
2078                                         exactMatch,
2079                                         isCompletingDeclaration,
2080                                         invocationSite,
2081                                         invocationScope,
2082                                         implicitCall);
2083                         }
2084
2085                         currentType = scope.getJavaLangObject();
2086                 } else {
2087                         if(isCompletingDeclaration){
2088                                 findIntefacesMethods(
2089                                         selector,
2090                                         argTypes,
2091                                         receiverType,
2092                                         currentType.superInterfaces(),
2093                                         scope,
2094                                         methodsFound,
2095                                         onlyStaticMethods,
2096                                         exactMatch,
2097                                         isCompletingDeclaration,
2098                                         invocationSite,
2099                                         invocationScope,
2100                                         implicitCall);
2101
2102                                 currentType = receiverType.superclass();
2103                         }
2104                 }
2105                 boolean hasPotentialDefaultAbstractMethods = true;
2106                 while (currentType != null) {
2107
2108                         MethodBinding[] methods = currentType.availableMethods();
2109                         if(methods != null) {
2110                                 if(isCompletingDeclaration){
2111                                         findLocalMethodDeclarations(
2112                                                 selector,
2113                                                 methods,
2114                                                 scope,
2115                                                 methodsFound,
2116                                                 onlyStaticMethods,
2117                                                 exactMatch,
2118                                                 receiverType);
2119                                 } else{
2120                                         findLocalMethods(
2121                                                 selector,
2122                                                 argTypes,
2123                                                 methods,
2124                                                 scope,
2125                                                 methodsFound,
2126                                                 onlyStaticMethods,
2127                                                 exactMatch,
2128                                                 receiverType,
2129                                                 invocationSite,
2130                                                 invocationScope,
2131                                                 implicitCall);
2132                                 }
2133                         }
2134
2135                         if(hasPotentialDefaultAbstractMethods && currentType.isAbstract()){
2136                                 findIntefacesMethods(
2137                                         selector,
2138                                         argTypes,
2139                                         receiverType,
2140                                         currentType.superInterfaces(),
2141                                         scope,
2142                                         methodsFound,
2143                                         onlyStaticMethods,
2144                                         exactMatch,
2145                                         isCompletingDeclaration,
2146                                         invocationSite,
2147                                         invocationScope,
2148                                         implicitCall);
2149                         } else {
2150                                 hasPotentialDefaultAbstractMethods = false;
2151                         }
2152                         currentType = currentType.superclass();
2153                 }
2154         }
2155         private char[][] findMethodParameterNames(MethodBinding method, char[][] parameterTypeNames){
2156                 ReferenceBinding bindingType = method.declaringClass;
2157
2158                 char[][] parameterNames = null;
2159
2160                 int length = parameterTypeNames.length;
2161
2162                 if (length == 0){
2163                         return TypeConstants.NoCharChar;
2164                 }
2165                 // look into the corresponding unit if it is available
2166                 if (bindingType instanceof SourceTypeBinding){
2167                         SourceTypeBinding sourceType = (SourceTypeBinding) bindingType;
2168
2169                         if (sourceType.scope != null){
2170                                 TypeDeclaration parsedType;
2171
2172                                 if ((parsedType = sourceType.scope.referenceContext) != null){
2173                                         AbstractMethodDeclaration methodDecl = parsedType.declarationOf(method);
2174
2175                                         if (methodDecl != null){
2176                                                 Argument[] arguments = methodDecl.arguments;
2177                                                 parameterNames = new char[length][];
2178
2179                                                 for(int i = 0 ; i < length ; i++){
2180                                                         parameterNames[i] = arguments[i].name;
2181                                                 }
2182                                         }
2183                                 }
2184                         }
2185                 }
2186                 // look into the model
2187                 if(parameterNames == null){
2188                         NameEnvironmentAnswer answer = nameEnvironment.findType(bindingType.compoundName);
2189
2190                         if(answer != null){
2191                                 if(answer.isSourceType()) {
2192                                         ISourceType sourceType = answer.getSourceTypes()[0];
2193                                         ISourceMethod[] sourceMethods = sourceType.getMethods();
2194                                         int len = sourceMethods == null ? 0 : sourceMethods.length;
2195                                         for(int i = 0; i < len ; i++){
2196                                                 ISourceMethod sourceMethod = sourceMethods[i];
2197                                                 char[][] argTypeNames = sourceMethod.getArgumentTypeNames();
2198
2199                                                 if(argTypeNames != null &&
2200                                                         CharOperation.equals(method.selector,sourceMethod.getSelector()) &&
2201                                                         CharOperation.equals(argTypeNames,parameterTypeNames)){
2202                                                         parameterNames = sourceMethod.getArgumentNames();
2203                                                         break;
2204                                                 }
2205                                         }
2206                                 }
2207                         }
2208                 }
2209                 return parameterNames;
2210         }
2211
2212         private void findNestedTypes(
2213                 char[] typeName,
2214                 SourceTypeBinding currentType,
2215                 Scope scope) {
2216                 if (typeName == null)
2217                         return;
2218
2219                 int typeLength = typeName.length;
2220
2221                 while (scope != null) { // done when a COMPILATION_UNIT_SCOPE is found
2222
2223                         switch (scope.kind) {
2224
2225                                 case Scope.METHOD_SCOPE :
2226                                 case Scope.BLOCK_SCOPE :
2227                                         BlockScope blockScope = (BlockScope) scope;
2228
2229                                         next : for (int i = 0, length = blockScope.scopeIndex; i < length; i++) {
2230
2231                                                 if (blockScope.subscopes[i] instanceof ClassScope) {
2232                                                         SourceTypeBinding localType =
2233                                                                 ((ClassScope) blockScope.subscopes[i]).referenceContext.binding;
2234
2235                                                         if (!localType.isAnonymousType()) {
2236                                                                 if (typeLength > localType.sourceName.length)
2237                                                                         continue next;
2238                                                                 if (!CharOperation.prefixEquals(typeName, localType.sourceName, false
2239                                                                         /* ignore case */
2240                                                                         ))
2241                                                                         continue next;
2242
2243                                                                 int relevance = R_DEFAULT;
2244                                                                 relevance += computeRelevanceForCaseMatching(typeName, localType.sourceName);
2245                                                                 relevance += computeRelevanceForExpectingType(localType);
2246                                                                 relevance += computeRelevanceForClass();
2247
2248                                                                 requestor.acceptClass(
2249                                                                         localType.qualifiedPackageName(),
2250                                                                         localType.sourceName,
2251                                                                         localType.sourceName,
2252                                                                         localType.modifiers,
2253                                                                         startPosition - offset,
2254                                                                         endPosition - offset,
2255                                                                         relevance);
2256                                                         }
2257                                                 }
2258                                         }
2259                                         break;
2260
2261                                 case Scope.CLASS_SCOPE :
2262                                         findMemberTypes(typeName, scope.enclosingSourceType(), scope, currentType);
2263                                         if (typeLength == 0)
2264                                                 return; // do not search outside the class scope if no prefix was provided
2265                                         break;
2266
2267                                 case Scope.COMPILATION_UNIT_SCOPE :
2268                                         return;
2269                         }
2270                         scope = scope.parent;
2271                 }
2272         }
2273
2274         private void findPackages(CompletionOnPackageReference packageStatement) {
2275
2276                 token = CharOperation.concatWith(packageStatement.tokens, '.');
2277                 if (token.length == 0)
2278                         return;
2279
2280                 setSourceRange(packageStatement.sourceStart, packageStatement.sourceEnd);
2281                 nameEnvironment.findPackages(CharOperation.toLowerCase(token), this);
2282         }
2283
2284         private void findTypesAndPackages(char[] token, Scope scope) {
2285
2286                 if (token == null)
2287                         return;
2288
2289                 if (scope.enclosingSourceType() != null)
2290                         findNestedTypes(token, scope.enclosingSourceType(), scope);
2291
2292                 if (unitScope != null) {
2293                         int typeLength = token.length;
2294                         SourceTypeBinding[] types = unitScope.topLevelTypes;
2295
2296                         for (int i = 0, length = types.length; i < length; i++) {
2297                                 SourceTypeBinding sourceType = types[i];
2298
2299                                 if (typeLength > sourceType.sourceName.length)  continue;
2300
2301                                 if (!CharOperation.prefixEquals(token, sourceType.sourceName, false))   continue;
2302
2303                                 int relevance = R_DEFAULT;
2304                                 relevance += computeRelevanceForCaseMatching(token, sourceType.sourceName);
2305                                 relevance += computeRelevanceForExpectingType(sourceType);
2306
2307                                 if (sourceType.isClass()){
2308                                         relevance += computeRelevanceForClass();
2309                                         requestor.acceptClass(
2310                                                 sourceType.qualifiedPackageName(),
2311                                                 sourceType.sourceName(),
2312                                                 sourceType.sourceName(),
2313                                                 sourceType.modifiers,
2314                                                 startPosition - offset,
2315                                                 endPosition - offset,
2316                                                 relevance);
2317                                 } else {
2318                                         relevance += computeRelevanceForInterface();
2319                                         requestor.acceptInterface(
2320                                                 sourceType.qualifiedPackageName(),
2321                                                 sourceType.sourceName(),
2322                                                 sourceType.sourceName(),
2323                                                 sourceType.modifiers,
2324                                                 startPosition - offset,
2325                                                 endPosition - offset,
2326                                                 relevance);
2327                                 }
2328                         }
2329                 }
2330
2331                 if (token.length == 0)
2332                         return;
2333
2334                 findKeywords(token, baseTypes, scope);
2335                 nameEnvironment.findTypes(token, this);
2336                 nameEnvironment.findPackages(token, this);
2337         }
2338
2339         private void findTypesAndSubpackages(
2340                 char[] token,
2341                 PackageBinding packageBinding) {
2342
2343                 char[] qualifiedName =
2344                         CharOperation.concatWith(packageBinding.compoundName, token, '.');
2345
2346                 if (token == null || token.length == 0) {
2347                         int length = qualifiedName.length;
2348                         System.arraycopy(
2349                                 qualifiedName,
2350                                 0,
2351                                 qualifiedName = new char[length + 1],
2352                                 0,
2353                                 length);
2354                         qualifiedName[length] = '.';
2355                 }
2356                 nameEnvironment.findTypes(qualifiedName, this);
2357                 nameEnvironment.findPackages(qualifiedName, this);
2358         }
2359
2360         private void findVariablesAndMethods(
2361                 char[] token,
2362                 Scope scope,
2363                 InvocationSite invocationSite,
2364                 Scope invocationScope) {
2365
2366                 if (token == null)
2367                         return;
2368
2369                 // Should local variables hide fields from the receiver type or any of its enclosing types?
2370                 // we know its an implicit field/method access... see BlockScope getBinding/getImplicitMethod
2371
2372                 boolean staticsOnly = false;
2373                 // need to know if we're in a static context (or inside a constructor)
2374                 int tokenLength = token.length;
2375
2376                 ObjectVector localsFound = new ObjectVector();
2377                 ObjectVector fieldsFound = new ObjectVector();
2378                 ObjectVector methodsFound = new ObjectVector();
2379
2380                 Scope currentScope = scope;
2381
2382                 done1 : while (true) { // done when a COMPILATION_UNIT_SCOPE is found
2383
2384                         switch (currentScope.kind) {
2385
2386                                 case Scope.METHOD_SCOPE :
2387                                         // handle the error case inside an explicit constructor call (see MethodScope>>findField)
2388                                         MethodScope methodScope = (MethodScope) currentScope;
2389                                         staticsOnly |= methodScope.isStatic | methodScope.isConstructorCall;
2390
2391                                 case Scope.BLOCK_SCOPE :
2392                                         BlockScope blockScope = (BlockScope) currentScope;
2393
2394                                         next : for (int i = 0, length = blockScope.locals.length; i < length; i++) {
2395                                                 LocalVariableBinding local = blockScope.locals[i];
2396
2397                                                 if (local == null)
2398                                                         break next;
2399
2400                                                 if (tokenLength > local.name.length)
2401                                                         continue next;
2402
2403                                                 if (!CharOperation.prefixEquals(token, local.name, false /* ignore case */
2404                                                         ))
2405                                                         continue next;
2406
2407                                                 if (local.isSecret())
2408                                                         continue next;
2409
2410                                                 for (int f = 0; f < localsFound.size; f++) {
2411                                                         LocalVariableBinding otherLocal =
2412                                                                 (LocalVariableBinding) localsFound.elementAt(f);
2413                                                         if (CharOperation.equals(otherLocal.name, local.name, true))
2414                                                                 continue next;
2415                                                 }
2416                                                 localsFound.add(local);
2417
2418                                                 int relevance = R_DEFAULT;
2419                                                 relevance += computeRelevanceForCaseMatching(token, local.name);
2420                                                 relevance += computeRelevanceForExpectingType(local.type);
2421
2422                                                 requestor.acceptLocalVariable(
2423                                                         local.name,
2424                                                         local.type == null
2425                                                                 ? NoChar
2426                                                                 : local.type.qualifiedPackageName(),
2427                                                         local.type == null
2428                                                                 ? local.declaration.type.toString().toCharArray()
2429                                                                 : local.type.qualifiedSourceName(),
2430                                                         local.modifiers,
2431                                                         startPosition - offset,
2432                                                         endPosition - offset,
2433                                                         relevance);
2434                                         }
2435                                         break;
2436
2437                                 case Scope.COMPILATION_UNIT_SCOPE :
2438                                         break done1;
2439                         }
2440                         currentScope = currentScope.parent;
2441                 }
2442
2443                 currentScope = scope;
2444
2445                 done2 : while (true) { // done when a COMPILATION_UNIT_SCOPE is found
2446
2447                         switch (currentScope.kind) {
2448
2449                                 case Scope.CLASS_SCOPE :
2450                                         ClassScope classScope = (ClassScope) currentScope;
2451                                         SourceTypeBinding enclosingType = classScope.referenceContext.binding;
2452                                         /*                              if (tokenLength == 0) { // only search inside the type itself if no prefix was provided
2453                                                                                 findFields(token, enclosingType.fields(), classScope, fieldsFound, staticsOnly);
2454                                                                                 findMethods(token, enclosingType.methods(), classScope, methodsFound, staticsOnly, false);
2455                                                                                 break done;
2456                                                                         } else { */
2457                                         findFields(
2458                                                 token,
2459                                                 enclosingType,
2460                                                 classScope,
2461                                                 fieldsFound,
2462                                                 localsFound,
2463                                                 staticsOnly,
2464                                                 invocationSite,
2465                                                 invocationScope,
2466                                                 true);
2467
2468                                         findMethods(
2469                                                 token,
2470                                                 null,
2471                                                 enclosingType,
2472                                                 classScope,
2473                                                 methodsFound,
2474                                                 staticsOnly,
2475                                                 false,
2476                                                 false,
2477                                                 invocationSite,
2478                                                 invocationScope,
2479                                                 true);
2480                                         staticsOnly |= enclosingType.isStatic();
2481                                         //                              }
2482                                         break;
2483
2484                                 case Scope.COMPILATION_UNIT_SCOPE :
2485                                         break done2;
2486                         }
2487                         currentScope = currentScope.parent;
2488                 }
2489         }
2490
2491         // Helper method for private void findVariableNames(char[] name, TypeReference type )
2492         private void findVariableName(char[] token, char[] qualifiedPackageName, char[] qualifiedSourceName, char[] sourceName, char[][] excludeNames, int dim){
2493                         if(sourceName == null || sourceName.length == 0)
2494                                 return;
2495
2496                         char[] name = null;
2497
2498                         // compute variable name for base type
2499                         try{
2500                                 nameScanner.setSource(sourceName);
2501         nameScanner.getNextToken();  // switch (nameScanner.getNextToken()) {
2502 //                                      case TokenNameint :
2503 //                                      case TokenNamebyte :
2504 //                                      case TokenNameshort :
2505 //                                      case TokenNamechar :
2506 //                                      case TokenNamelong :
2507 //                                      case TokenNamefloat :
2508 //                                      case TokenNamedouble :
2509 //                                      case TokenNameboolean :
2510 //                                              if(token != null && token.length != 0)
2511 //                                                      return;
2512 //                                              name = computeBaseNames(sourceName[0], excludeNames);
2513 //                                              break;
2514 //                              }
2515                                 if(name != null) {
2516                                         int relevance = R_DEFAULT;
2517                                         relevance += computeRelevanceForCaseMatching(token, name);
2518
2519                                         // accept result
2520                                         requestor.acceptVariableName(
2521                                                 qualifiedPackageName,
2522                                                 qualifiedSourceName,
2523                                                 name,
2524                                                 name,
2525                                                 startPosition - offset,
2526                                                 endPosition - offset,
2527                                                 relevance);
2528                                         return;
2529                                 }
2530                         } catch(InvalidInputException e){
2531                         }
2532
2533                         // compute variable name for non base type
2534                         char[][] names = computeNames(sourceName, dim > 0);
2535                         char[] displayName;
2536                         if (dim > 0){
2537                                 int l = qualifiedSourceName.length;
2538                                 displayName = new char[l+(2*dim)];
2539                                 System.arraycopy(qualifiedSourceName, 0, displayName, 0, l);
2540                                 for(int i = 0; i < dim; i++){
2541                                         displayName[l+(i*2)] = '[';
2542                                         displayName[l+(i*2)+1] = ']';
2543                                 }
2544                         } else {
2545                                 displayName = qualifiedSourceName;
2546                         }
2547                         next : for(int i = 0 ; i < names.length ; i++){
2548                                 name = names[i];
2549
2550                                 if (!CharOperation.prefixEquals(token, name, false))
2551                                         continue next;
2552
2553                                 // completion must be an identifier (not a keyword, ...).
2554                                 try{
2555                                         nameScanner.setSource(name);
2556                                         if(nameScanner.getNextToken() != TokenNameIdentifier)
2557                                                 continue next;
2558                                 } catch(InvalidInputException e){
2559                                         continue next;
2560                                 }
2561
2562                                 int count = 2;
2563                                 char[] originalName = name;
2564                                 for(int j = 0 ; j < excludeNames.length ; j++){
2565                                         if(CharOperation.equals(name, excludeNames[j], false)) {
2566                                                 name = CharOperation.concat(originalName, String.valueOf(count++).toCharArray());
2567                                                 j = 0;
2568                                         }
2569                                 }
2570
2571                                 int relevance = R_DEFAULT;
2572                                 relevance += computeRelevanceForCaseMatching(token, name);
2573
2574                                 // accept result
2575                                 requestor.acceptVariableName(
2576                                         qualifiedPackageName,
2577                                         displayName,
2578                                         name,
2579                                         name,
2580                                         startPosition - offset,
2581                                         endPosition - offset,
2582                                         relevance);
2583                         }
2584         }
2585
2586         private void findVariableNames(char[] name, TypeReference type , char[][] excludeNames){
2587
2588                 if(type != null &&
2589                         type.binding != null &&
2590                         type.binding.problemId() == Binding.NoError){
2591                         TypeBinding tb = type.binding;
2592                         findVariableName(
2593                                 name,
2594                                 tb.leafComponentType().qualifiedPackageName(),
2595                                 tb.leafComponentType().qualifiedSourceName(),
2596                                 tb.leafComponentType().sourceName(),
2597                                 excludeNames,
2598                                 type.dimensions());
2599                 }/*     else {
2600                         char[][] typeName = type.getTypeName();
2601                         findVariableName(
2602                                 name,
2603                                 NoChar,
2604                                 CharOperation.concatWith(typeName, '.'),
2605                                 typeName[typeName.length - 1],
2606                                 excludeNames,
2607                                 type.dimensions());
2608                 }*/
2609         }
2610
2611         public AssistParser getParser() {
2612
2613                 return parser;
2614         }
2615
2616         protected void reset() {
2617
2618                 super.reset();
2619                 this.knownPkgs = new HashtableOfObject(10);
2620                 this.knownTypes = new HashtableOfObject(10);
2621         }
2622
2623         private void setSourceRange(int start, int end) {
2624
2625                 this.startPosition = start;
2626                 this.endPosition = end + 1;
2627         }
2628
2629         private char[] computeBaseNames(char firstName, char[][] excludeNames){
2630                 char[] name = new char[]{firstName};
2631
2632                 for(int i = 0 ; i < excludeNames.length ; i++){
2633                         if(CharOperation.equals(name, excludeNames[i], false)) {
2634                                 name[0]++;
2635                                 if(name[0] > 'z')
2636                                         name[0] = 'a';
2637                                 if(name[0] == firstName)
2638                                         return null;
2639                                 i = 0;
2640                         }
2641                 }
2642
2643                 return name;
2644         }
2645         private void computeExpectedTypes(AstNode parent, Scope scope){
2646                 int expectedTypeCount = 0;
2647                 expectedTypes = new TypeBinding[1];
2648
2649                 if(parent instanceof AbstractVariableDeclaration) {
2650                         TypeBinding binding = ((AbstractVariableDeclaration)parent).type.binding;
2651                         if(binding != null) {
2652                                 expectedTypes[expectedTypeCount++] = binding;
2653                         }
2654                 } else if(parent instanceof Assignment) {
2655                         TypeBinding binding = ((Assignment)parent).lhsType;
2656                         if(binding != null) {
2657                                 expectedTypes[expectedTypeCount++] = binding;
2658                         }
2659                 } else if(parent instanceof ReturnStatement) {
2660                         MethodBinding methodBinding = ((AbstractMethodDeclaration) scope.methodScope().referenceContext).binding;
2661                         TypeBinding binding = methodBinding  == null ? null : methodBinding.returnType;
2662                         if(binding != null) {
2663                                 expectedTypes[expectedTypeCount++] = binding;
2664                         }
2665                 }
2666
2667                 System.arraycopy(expectedTypes, 0, expectedTypes = new TypeBinding[expectedTypeCount], 0, expectedTypeCount);
2668         }
2669         private char[][] computeNames(char[] sourceName, boolean forArray){
2670                 char[][] names = new char[5][];
2671                 int nameCount = 0;
2672                 boolean previousIsUpperCase = false;
2673                 for(int i = sourceName.length - 1 ; i >= 0 ; i--){
2674                         boolean isUpperCase = Character.isUpperCase(sourceName[i]);
2675                         if(isUpperCase && !previousIsUpperCase){
2676                                 char[] name = CharOperation.subarray(sourceName,i,sourceName.length);
2677                                 if(name.length > 1){
2678                                         if(nameCount == names.length) {
2679                                                 System.arraycopy(names, 0, names = new char[nameCount * 2][], 0, nameCount);
2680                                         }
2681                                         name[0] = Character.toLowerCase(name[0]);
2682
2683                                         if(forArray) {
2684                                                 int length = name.length;
2685                                                 if (name[length-1] == 's'){
2686                                                         System.arraycopy(name, 0, name = new char[length + 2], 0, length);
2687                                                         name[length] = 'e';
2688                                                         name[length+1] = 's';
2689                                                 } else {
2690                                                         System.arraycopy(name, 0, name = new char[length + 1], 0, length);
2691                                                         name[length] = 's';
2692                                                 }
2693                                         }
2694                                         names[nameCount++] = name;
2695                                 }
2696                         }
2697                         previousIsUpperCase = isUpperCase;
2698                 }
2699                 if(nameCount == 0){
2700                         char[] name = CharOperation.toLowerCase(sourceName);
2701                         if(forArray) {
2702                                 int length = name.length;
2703                                 if (name[length-1] == 's'){
2704                                         System.arraycopy(name, 0, name = new char[length + 2], 0, length);
2705                                         name[length] = 'e';
2706                                         name[length+1] = 's';
2707                                 } else {
2708                                         System.arraycopy(name, 0, name = new char[length + 1], 0, length);
2709                                         name[length] = 's';
2710                                 }
2711                         }
2712                         names[nameCount++] = name;
2713
2714                 }
2715                 System.arraycopy(names, 0, names = new char[nameCount][], 0, nameCount);
2716                 return names;
2717         }
2718
2719         private char[] computePrefix(SourceTypeBinding declarationType, SourceTypeBinding invocationType, boolean isStatic){
2720
2721                 StringBuffer completion = new StringBuffer(10);
2722
2723                 if (isStatic) {
2724                         completion.append(declarationType.sourceName());
2725
2726                 } else if (declarationType == invocationType) {
2727                         completion.append(THIS);
2728
2729                 } else {
2730
2731                         if (!declarationType.isNestedType()) {
2732
2733                                 completion.append(declarationType.sourceName());
2734                                 completion.append('.');
2735                                 completion.append(THIS);
2736
2737                         } else if (!declarationType.isAnonymousType()) {
2738
2739                                 completion.append(declarationType.sourceName());
2740                                 completion.append('.');
2741                                 completion.append(THIS);
2742
2743                         }
2744                 }
2745
2746                 return completion.toString().toCharArray();
2747         }
2748
2749         private boolean isEnclosed(ReferenceBinding possibleEnclosingType, ReferenceBinding type){
2750                 if(type.isNestedType()){
2751                         ReferenceBinding enclosing = type.enclosingType();
2752                         while(enclosing != null ){
2753                                 if(possibleEnclosingType == enclosing)
2754                                         return true;
2755                                 enclosing = enclosing.enclosingType();
2756                         }
2757                 }
2758                 return false;
2759         }
2760
2761 }