net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/codeassist/impl/AssistParser.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.impl;
  12
  13 /*
  14  * Parser extension for code assist task
  15  *
  16  */
  17
  18 import net.sourceforge.phpdt.internal.compiler.ast.AbstractMethodDeclaration;
  19 import net.sourceforge.phpdt.internal.compiler.ast.AstNode;
  20 import net.sourceforge.phpdt.internal.compiler.ast.Block;
  21 import net.sourceforge.phpdt.internal.compiler.ast.CompilationUnitDeclaration;
  22 import net.sourceforge.phpdt.internal.compiler.ast.ConstructorDeclaration;
  23 import net.sourceforge.phpdt.internal.compiler.ast.ExplicitConstructorCall;
  24 import net.sourceforge.phpdt.internal.compiler.ast.Expression;
  25 import net.sourceforge.phpdt.internal.compiler.ast.FieldDeclaration;
  26 import net.sourceforge.phpdt.internal.compiler.ast.ImportReference;
  27 import net.sourceforge.phpdt.internal.compiler.ast.Initializer;
  28 import net.sourceforge.phpdt.internal.compiler.ast.LocalDeclaration;
  29 import net.sourceforge.phpdt.internal.compiler.ast.MessageSend;
  30 import net.sourceforge.phpdt.internal.compiler.ast.MethodDeclaration;
  31 import net.sourceforge.phpdt.internal.compiler.ast.NameReference;
  32 import net.sourceforge.phpdt.internal.compiler.ast.TypeDeclaration;
  33 import net.sourceforge.phpdt.internal.compiler.ast.TypeReference;
  34 import net.sourceforge.phpdt.internal.compiler.parser.Parser;
  35 import net.sourceforge.phpdt.internal.compiler.parser.RecoveredElement;
  36 import net.sourceforge.phpdt.internal.compiler.parser.RecoveredField;
  37 import net.sourceforge.phpdt.internal.compiler.parser.RecoveredInitializer;
  38 import net.sourceforge.phpdt.internal.compiler.parser.RecoveredMethod;
  39 import net.sourceforge.phpdt.internal.compiler.parser.RecoveredType;
  40 import net.sourceforge.phpdt.internal.compiler.parser.RecoveredUnit;
  41 import net.sourceforge.phpdt.internal.compiler.problem.AbortCompilation;
  42 import net.sourceforge.phpdt.internal.compiler.problem.ProblemReporter;
  43
  44 public abstract class AssistParser extends Parser {
  45
  46         public AstNode assistNode;
  47         public boolean isOrphanCompletionNode;
  48
  49         /* recovery */
  50         int[] blockStarts = new int[30];
  51
  52         // the previous token read by the scanner
  53         protected int previousToken;
  54
  55         // the index in the identifier stack of the previous identifier
  56         protected int previousIdentifierPtr;
  57
  58         // the stacks of selectors for invocations (ie. method invocations, allocation expressions and
  59         // explicit constructor invocations)
  60         // the selector stack contains pointers to the identifier stack or one of the selector constants below
  61         protected int invocationPtr;
  62         protected int[] selectorStack = new int[StackIncrement];
  63
  64         // selector constants
  65         protected static final int THIS_CONSTRUCTOR = -1;
  66         protected static final int SUPER_CONSTRUCTOR = -2;
  67
  68         // whether the parser is in a field initializer
  69         // (false is pushed each time a new type is entered,
  70         //  it is changed to true when the initializer is entered,
  71         //  it is changed back to false when the initializer is exited,
  72         //  and it is poped when the type is exited)
  73         protected int inFieldInitializationPtr;
  74         protected boolean[] inFieldInitializationStack = new boolean[StackIncrement];
  75
  76         // whether the parser is in a method, constructor or initializer
  77         // (false is pushed each time a new type is entered,
  78         //  it is changed to true when the method is entered,
  79         //  it is changed back to false when the method is exited,
  80         //  and it is poped when the type is exited)
  81         protected int inMethodPtr;
  82         protected boolean[] inMethodStack = new boolean[StackIncrement];
  83 public AssistParser(ProblemReporter problemReporter, boolean assertMode) {
  84         super(problemReporter, true, assertMode);
  85 }
  86 public abstract char[] assistIdentifier();
  87 public int bodyEnd(AbstractMethodDeclaration method){
  88         return method.declarationSourceEnd;
  89 }
  90 public int bodyEnd(Initializer initializer){
  91         return initializer.declarationSourceEnd;
  92 }
  93 /*
  94  * Build initial recovery state.
  95  * Recovery state is inferred from the current state of the parser (reduced node stack).
  96  */
  97 public RecoveredElement buildInitialRecoveryState(){
  98
  99         /* recovery in unit structure */
 100         if (referenceContext instanceof CompilationUnitDeclaration){
 101                 RecoveredElement element = super.buildInitialRecoveryState();
 102                 flushAssistState();
 103                 initInMethodAndInFieldInitializationStack(element);
 104                 return element;
 105         }
 106
 107         /* recovery in method body */
 108         lastCheckPoint = 0;
 109
 110         RecoveredElement element = null;
 111         if (referenceContext instanceof AbstractMethodDeclaration){
 112                 element = new RecoveredMethod((AbstractMethodDeclaration) referenceContext, null, 0, this);
 113                 lastCheckPoint = ((AbstractMethodDeclaration) referenceContext).bodyStart;
 114         } else {
 115                 /* Initializer bodies are parsed in the context of the type declaration, we must thus search it inside */
 116                 if (referenceContext instanceof TypeDeclaration){
 117                         TypeDeclaration type = (TypeDeclaration) referenceContext;
 118                         for (int i = 0; i < type.fields.length; i++){
 119                                 FieldDeclaration field = type.fields[i];
 120                                 if (!field.isField()
 121                                                 && field.declarationSourceStart <= scanner.initialPosition
 122                                                 && scanner.initialPosition <= field.declarationSourceEnd
 123                                                 && scanner.eofPosition <= field.declarationSourceEnd+1){
 124                                         element = new RecoveredInitializer((Initializer) field, null, 1, this);
 125                                         lastCheckPoint = field.declarationSourceStart;
 126                                         break;
 127                                 }
 128                         }
 129                 }
 130         }
 131
 132         if (element == null) return element;
 133
 134         /* add initial block */
 135         Block block = new Block(0);
 136         int lastStart = blockStarts[0];
 137         block.sourceStart = lastStart;
 138         element = element.add(block, 1);
 139         int blockIndex = 1;     // ignore first block start, since manually rebuilt here
 140
 141         for(int i = 0; i <= astPtr; i++){
 142                 AstNode node = astStack[i];
 143
 144                 /* check for intermediate block creation, so recovery can properly close them afterwards */
 145                 int nodeStart = node.sourceStart;
 146                 for (int j = blockIndex; j <= realBlockPtr; j++){
 147                         if (blockStarts[j] > nodeStart){
 148                                 blockIndex = j; // shift the index to the new block
 149                                 break;
 150                         }
 151                         if (blockStarts[j] != lastStart){ // avoid multiple block if at same position
 152                                 block = new Block(0);
 153                                 block.sourceStart = lastStart = blockStarts[j];
 154                                 element = element.add(block, 1);
 155                         }
 156                         blockIndex = j+1; // shift the index to the new block
 157                 }
 158                 if (node instanceof LocalDeclaration){
 159                         LocalDeclaration local = (LocalDeclaration) node;
 160                         if (local.declarationSourceEnd == 0){
 161                                 element = element.add(local, 0);
 162                                 if (local.initialization == null){
 163                                         lastCheckPoint = local.sourceEnd + 1;
 164                                 } else {
 165                                         lastCheckPoint = local.initialization.sourceEnd + 1;
 166                                 }
 167                         } else {
 168                                 element = element.add(local, 0);
 169                                 lastCheckPoint = local.declarationSourceEnd + 1;
 170                         }
 171                         continue;
 172                 }
 173                 if (node instanceof AbstractMethodDeclaration){
 174                         AbstractMethodDeclaration method = (AbstractMethodDeclaration) node;
 175                         if (method.declarationSourceEnd == 0){
 176                                 element = element.add(method, 0);
 177                                 lastCheckPoint = method.bodyStart;
 178                         } else {
 179                                 element = element.add(method, 0);
 180                                 lastCheckPoint = method.declarationSourceEnd + 1;
 181                         }
 182                         continue;
 183                 }
 184                 if (node instanceof Initializer){
 185                         Initializer initializer = (Initializer) node;
 186                         if (initializer.declarationSourceEnd == 0){
 187                                 element = element.add(initializer, 1);
 188                                 lastCheckPoint = initializer.bodyStart;
 189                         } else {
 190                                 element = element.add(initializer, 0);
 191                                 lastCheckPoint = initializer.declarationSourceEnd + 1;
 192                         }
 193                         continue;
 194                 }
 195                 if (node instanceof FieldDeclaration){
 196                         FieldDeclaration field = (FieldDeclaration) node;
 197                         if (field.declarationSourceEnd == 0){
 198                                 element = element.add(field, 0);
 199                                 if (field.initialization == null){
 200                                         lastCheckPoint = field.sourceEnd + 1;
 201                                 } else {
 202                                         lastCheckPoint = field.initialization.sourceEnd + 1;
 203                                 }
 204                         } else {
 205                                 element = element.add(field, 0);
 206                                 lastCheckPoint = field.declarationSourceEnd + 1;
 207                         }
 208                         continue;
 209                 }
 210                 if (node instanceof TypeDeclaration){
 211                         TypeDeclaration type = (TypeDeclaration) node;
 212                         if (type.declarationSourceEnd == 0){
 213                                 element = element.add(type, 0);
 214                                 lastCheckPoint = type.bodyStart;
 215                         } else {
 216                                 element = element.add(type, 0);
 217                                 lastCheckPoint = type.declarationSourceEnd + 1;
 218                         }
 219                         continue;
 220                 }
 221                 if (node instanceof ImportReference){
 222                         ImportReference importRef = (ImportReference) node;
 223                         element = element.add(importRef, 0);
 224                         lastCheckPoint = importRef.declarationSourceEnd + 1;
 225                 }
 226         }
 227         if (this.currentToken == TokenNameRBRACE) {
 228                 this.currentToken = 0; // closing brace has already been taken care of
 229         }
 230
 231         /* might need some extra block (after the last reduced node) */
 232         int pos = this.assistNode == null ? lastCheckPoint : this.assistNode.sourceStart;
 233         for (int j = blockIndex; j <= realBlockPtr; j++){
 234                 if ((blockStarts[j] < pos) && (blockStarts[j] != lastStart)){ // avoid multiple block if at same position
 235                         block = new Block(0);
 236                         block.sourceStart = lastStart = blockStarts[j];
 237                         element = element.add(block, 1);
 238                 }
 239         }
 240
 241         initInMethodAndInFieldInitializationStack(element);
 242         return element;
 243 }
 244 protected void consumeClassBodyDeclarationsopt() {
 245         super.consumeClassBodyDeclarationsopt();
 246         this.inFieldInitializationPtr--;
 247         this.inMethodPtr--;
 248 }
 249 protected void consumeClassBodyopt() {
 250         super.consumeClassBodyopt();
 251         this.invocationPtr--; // NB: This can be decremented below -1 only if in diet mode and not in field initializer
 252 }
 253 protected void consumeClassHeader() {
 254         super.consumeClassHeader();
 255         this.pushNotInInitializer();
 256         this.pushNotInMethod();
 257 }
 258 protected void consumeConstructorBody() {
 259         super.consumeConstructorBody();
 260         this.inMethodStack[this.inMethodPtr] = false;
 261 }
 262 protected void consumeConstructorHeader() {
 263         super.consumeConstructorHeader();
 264         this.inMethodStack[this.inMethodPtr] = true;
 265 }
 266 protected void consumeEmptyClassBodyDeclarationsopt() {
 267         super.consumeEmptyClassBodyDeclarationsopt();
 268         this.inFieldInitializationPtr--;
 269         this.inMethodPtr--;
 270 }
 271 protected void consumeEnterAnonymousClassBody() {
 272         super.consumeEnterAnonymousClassBody();
 273         this.invocationPtr--; // NB: This can be decremented below -1 only if in diet mode and not in field initializer
 274         this.pushNotInInitializer();
 275         this.pushNotInMethod();
 276 }
 277 protected void consumeExplicitConstructorInvocation(int flag, int recFlag) {
 278         super.consumeExplicitConstructorInvocation(flag, recFlag);
 279         this.invocationPtr--; // NB: This can be decremented below -1 only if in diet mode and not in field initializer
 280 }
 281 protected void consumeForceNoDiet() {
 282         super.consumeForceNoDiet();
 283         // if we are not in a method (ie. we are not in a local variable initializer)
 284         // then we are entering a field initializer
 285         if (!this.inMethodStack[this.inMethodPtr]) {
 286                 this.inFieldInitializationStack[this.inFieldInitializationPtr] = true;
 287         }
 288 }
 289 protected void consumeInterfaceHeader() {
 290         super.consumeInterfaceHeader();
 291         this.pushNotInInitializer();
 292         this.pushNotInMethod();
 293 }
 294 protected void consumeInterfaceMemberDeclarationsopt() {
 295         super.consumeInterfaceMemberDeclarationsopt();
 296         this.inFieldInitializationPtr--;
 297         this.inMethodPtr--;
 298 }
 299 protected void consumeMethodBody() {
 300         super.consumeMethodBody();
 301         this.inMethodStack[this.inMethodPtr] = false;
 302 }
 303 protected void consumeMethodHeader() {
 304         super.consumeMethodHeader();
 305         this.inMethodStack[this.inMethodPtr] = true;
 306 }
 307 protected void consumeMethodInvocationName() {
 308         super.consumeMethodInvocationName();
 309         this.invocationPtr--; // NB: This can be decremented below -1 only if in diet mode and not in field initializer
 310         MessageSend messageSend = (MessageSend)expressionStack[expressionPtr];
 311         if (messageSend == assistNode){
 312                 this.lastCheckPoint = messageSend.sourceEnd + 1;
 313         }
 314 }
 315 protected void consumeMethodInvocationPrimary() {
 316         super.consumeMethodInvocationPrimary();
 317         this.invocationPtr--; // NB: This can be decremented below -1 only if in diet mode and not in field initializer
 318         MessageSend messageSend = (MessageSend)expressionStack[expressionPtr];
 319         if (messageSend == assistNode){
 320                 this.lastCheckPoint = messageSend.sourceEnd + 1;
 321         }
 322 }
 323 protected void consumeMethodInvocationSuper() {
 324         super.consumeMethodInvocationSuper();
 325         this.invocationPtr--; // NB: This can be decremented below -1 only if in diet mode and not in field initializer
 326         MessageSend messageSend = (MessageSend)expressionStack[expressionPtr];
 327         if (messageSend == assistNode){
 328                 this.lastCheckPoint = messageSend.sourceEnd + 1;
 329         }
 330 }
 331 protected void consumeNestedMethod() {
 332         super.consumeNestedMethod();
 333         this.inMethodStack[this.inMethodPtr] = true;
 334 }
 335 protected void consumeOpenBlock() {
 336         // OpenBlock ::= $empty
 337
 338         super.consumeOpenBlock();
 339         try {
 340                 blockStarts[realBlockPtr] = scanner.startPosition;
 341         } catch (IndexOutOfBoundsException e) {
 342                 //realBlockPtr is correct
 343                 int oldStackLength = blockStarts.length;
 344                 int oldStack[] = blockStarts;
 345                 blockStarts = new int[oldStackLength + StackIncrement];
 346                 System.arraycopy(oldStack, 0, blockStarts, 0, oldStackLength);
 347                 blockStarts[realBlockPtr] = scanner.startPosition;
 348         }
 349 }
 350 protected void consumePackageDeclarationName() {
 351         // PackageDeclarationName ::= 'package' Name
 352         /* build an ImportRef build from the last name
 353         stored in the identifier stack. */
 354
 355         int index;
 356
 357         /* no need to take action if not inside assist identifiers */
 358         if ((index = indexOfAssistIdentifier()) < 0) {
 359                 super.consumePackageDeclarationName();
 360                 return;
 361         }
 362         /* retrieve identifiers subset and whole positions, the assist node positions
 363                 should include the entire replaced source. */
 364         int length = identifierLengthStack[identifierLengthPtr];
 365         char[][] subset = identifierSubSet(index+1); // include the assistIdentifier
 366         identifierLengthPtr--;
 367         identifierPtr -= length;
 368         long[] positions = new long[length];
 369         System.arraycopy(
 370                 identifierPositionStack,
 371                 identifierPtr + 1,
 372                 positions,
 373                 0,
 374                 length);
 375
 376         /* build specific assist node on package statement */
 377         ImportReference reference = this.createAssistPackageReference(subset, positions);
 378         assistNode = reference;
 379         this.lastCheckPoint = reference.sourceEnd + 1;
 380         compilationUnit.currentPackage = reference;
 381
 382         if (currentToken == TokenNameSEMICOLON){
 383                 reference.declarationSourceEnd = scanner.currentPosition - 1;
 384         } else {
 385                 reference.declarationSourceEnd = (int) positions[length-1];
 386         }
 387         //endPosition is just before the ;
 388         reference.declarationSourceStart = intStack[intPtr--];
 389         // flush annotations defined prior to import statements
 390         reference.declarationSourceEnd = this.flushAnnotationsDefinedPriorTo(reference.declarationSourceEnd);
 391
 392         // recovery
 393         if (currentElement != null){
 394                 lastCheckPoint = reference.declarationSourceEnd+1;
 395                 restartRecovery = true; // used to avoid branching back into the regular automaton
 396         }
 397 }
 398 protected void consumeRestoreDiet() {
 399         super.consumeRestoreDiet();
 400         // if we are not in a method (ie. we were not in a local variable initializer)
 401         // then we are exiting a field initializer
 402         if (!this.inMethodStack[this.inMethodPtr]) {
 403                 this.inFieldInitializationStack[this.inFieldInitializationPtr] = false;
 404         }
 405 }
 406 protected void consumeSingleTypeImportDeclarationName() {
 407         // SingleTypeImportDeclarationName ::= 'import' Name
 408         /* push an ImportRef build from the last name
 409         stored in the identifier stack. */
 410
 411         int index;
 412
 413         /* no need to take action if not inside assist identifiers */
 414         if ((index = indexOfAssistIdentifier()) < 0) {
 415                 super.consumeSingleTypeImportDeclarationName();
 416                 return;
 417         }
 418         /* retrieve identifiers subset and whole positions, the assist node positions
 419                 should include the entire replaced source. */
 420         int length = identifierLengthStack[identifierLengthPtr];
 421         char[][] subset = identifierSubSet(index+1); // include the assistIdentifier
 422         identifierLengthPtr--;
 423         identifierPtr -= length;
 424         long[] positions = new long[length];
 425         System.arraycopy(
 426                 identifierPositionStack,
 427                 identifierPtr + 1,
 428                 positions,
 429                 0,
 430                 length);
 431
 432         /* build specific assist node on import statement */
 433         ImportReference reference = this.createAssistImportReference(subset, positions);
 434         assistNode = reference;
 435         this.lastCheckPoint = reference.sourceEnd + 1;
 436
 437         pushOnAstStack(reference);
 438
 439         if (currentToken == TokenNameSEMICOLON){
 440                 reference.declarationSourceEnd = scanner.currentPosition - 1;
 441         } else {
 442                 reference.declarationSourceEnd = (int) positions[length-1];
 443         }
 444         //endPosition is just before the ;
 445         reference.declarationSourceStart = intStack[intPtr--];
 446         // flush annotations defined prior to import statements
 447         reference.declarationSourceEnd = this.flushAnnotationsDefinedPriorTo(reference.declarationSourceEnd);
 448
 449         // recovery
 450         if (currentElement != null){
 451                 lastCheckPoint = reference.declarationSourceEnd+1;
 452                 currentElement = currentElement.add(reference, 0);
 453                 lastIgnoredToken = -1;
 454                 restartRecovery = true; // used to avoid branching back into the regular automaton
 455         }
 456 }
 457 protected void consumeStaticInitializer() {
 458         super.consumeStaticInitializer();
 459         this.inMethodStack[this.inMethodPtr] = false;
 460 }
 461 protected void consumeStaticOnly() {
 462         super.consumeStaticOnly();
 463         this.inMethodStack[this.inMethodPtr] = true;
 464 }
 465 protected void consumeToken(int token) {
 466         super.consumeToken(token);
 467         // register message send selector only if inside a method or if looking at a field initializer
 468         // and if the current token is an open parenthesis
 469         if ((this.inMethodStack[this.inMethodPtr] || this.inFieldInitializationStack[this.inFieldInitializationPtr]) && token == TokenNameLPAREN) {
 470                 switch (this.previousToken) {
 471                         case TokenNameIdentifier:
 472                                 this.pushOnSelectorStack(this.identifierPtr);
 473                                 break;
 474 //                      case TokenNamethis: // explicit constructor invocation, eg. this(1, 2)
 475 //                              this.pushOnSelectorStack(THIS_CONSTRUCTOR);
 476 //                              break;
 477 //                      case TokenNamesuper: // explicit constructor invocation, eg. super(1, 2)
 478 //                              this.pushOnSelectorStack(SUPER_CONSTRUCTOR);
 479 //                              break;
 480                 }
 481         }
 482         this.previousToken = token;
 483         if (token == TokenNameIdentifier) {
 484                 this.previousIdentifierPtr = this.identifierPtr;
 485         }
 486 }
 487 protected void consumeTypeImportOnDemandDeclarationName() {
 488         // TypeImportOnDemandDeclarationName ::= 'import' Name '.' '*'
 489         /* push an ImportRef build from the last name
 490         stored in the identifier stack. */
 491
 492         int index;
 493
 494         /* no need to take action if not inside assist identifiers */
 495         if ((index = indexOfAssistIdentifier()) < 0) {
 496                 super.consumeTypeImportOnDemandDeclarationName();
 497                 return;
 498         }
 499         /* retrieve identifiers subset and whole positions, the assist node positions
 500                 should include the entire replaced source. */
 501         int length = identifierLengthStack[identifierLengthPtr];
 502         char[][] subset = identifierSubSet(index+1); // include the assistIdentifier
 503         identifierLengthPtr--;
 504         identifierPtr -= length;
 505         long[] positions = new long[length];
 506         System.arraycopy(
 507                 identifierPositionStack,
 508                 identifierPtr + 1,
 509                 positions,
 510                 0,
 511                 length);
 512
 513         /* build specific assist node on import statement */
 514         ImportReference reference = this.createAssistImportReference(subset, positions);
 515         reference.onDemand = true;
 516         assistNode = reference;
 517         this.lastCheckPoint = reference.sourceEnd + 1;
 518
 519         pushOnAstStack(reference);
 520
 521         if (currentToken == TokenNameSEMICOLON){
 522                 reference.declarationSourceEnd = scanner.currentPosition - 1;
 523         } else {
 524                 reference.declarationSourceEnd = (int) positions[length-1];
 525         }
 526         //endPosition is just before the ;
 527         reference.declarationSourceStart = intStack[intPtr--];
 528         // flush annotations defined prior to import statements
 529         reference.declarationSourceEnd = this.flushAnnotationsDefinedPriorTo(reference.declarationSourceEnd);
 530
 531         // recovery
 532         if (currentElement != null){
 533                 lastCheckPoint = reference.declarationSourceEnd+1;
 534                 currentElement = currentElement.add(reference, 0);
 535                 lastIgnoredToken = -1;
 536                 restartRecovery = true; // used to avoid branching back into the regular automaton
 537         }
 538 }
 539 public abstract ImportReference createAssistImportReference(char[][] tokens, long[] positions);
 540 public abstract ImportReference createAssistPackageReference(char[][] tokens, long[] positions);
 541 public abstract NameReference createQualifiedAssistNameReference(char[][] previousIdentifiers, char[] name, long[] positions);
 542 public abstract TypeReference createQualifiedAssistTypeReference(char[][] previousIdentifiers, char[] name, long[] positions);
 543 public abstract NameReference createSingleAssistNameReference(char[] name, long position);
 544 public abstract TypeReference createSingleAssistTypeReference(char[] name, long position);
 545 /*
 546  * Flush parser/scanner state regarding to code assist
 547  */
 548 public void flushAssistState(){
 549         this.assistNode = null;
 550         this.isOrphanCompletionNode = false;
 551         this.setAssistIdentifier(null);
 552 }
 553 /*
 554  * Build specific type reference nodes in case the cursor is located inside the type reference
 555  */
 556 protected TypeReference getTypeReference(int dim) {
 557
 558         int index;
 559
 560         /* no need to take action if not inside completed identifiers */
 561         if ((index = indexOfAssistIdentifier()) < 0) {
 562                 return super.getTypeReference(dim);
 563         }
 564
 565         /* retrieve identifiers subset and whole positions, the assist node positions
 566                 should include the entire replaced source. */
 567         int length = identifierLengthStack[identifierLengthPtr];
 568         char[][] subset = identifierSubSet(index);
 569         identifierLengthPtr--;
 570         identifierPtr -= length;
 571         long[] positions = new long[length];
 572         System.arraycopy(
 573                 identifierPositionStack,
 574                 identifierPtr + 1,
 575                 positions,
 576                 0,
 577                 length);
 578
 579         /* build specific assist on type reference */
 580         TypeReference reference;
 581         if (index == 0) {
 582                 /* assist inside first identifier */
 583                 reference = this.createSingleAssistTypeReference(
 584                                                 assistIdentifier(),
 585                                                 positions[0]);
 586         } else {
 587                 /* assist inside subsequent identifier */
 588                 reference =     this.createQualifiedAssistTypeReference(
 589                                                 subset,
 590                                                 assistIdentifier(),
 591                                                 positions);
 592         }
 593         assistNode = reference;
 594         this.lastCheckPoint = reference.sourceEnd + 1;
 595         return reference;
 596 }
 597 /*
 598  * Copy of code from superclass with the following change:
 599  * In the case of qualified name reference if the cursor location is on the
 600  * qualified name reference, then create a CompletionOnQualifiedNameReference
 601  * instead.
 602  */
 603 protected NameReference getUnspecifiedReferenceOptimized() {
 604
 605         int completionIndex;
 606
 607         /* no need to take action if not inside completed identifiers */
 608         if ((completionIndex = indexOfAssistIdentifier()) < 0) {
 609                 return super.getUnspecifiedReferenceOptimized();
 610         }
 611
 612         /* retrieve identifiers subset and whole positions, the completion node positions
 613                 should include the entire replaced source. */
 614         int length = identifierLengthStack[identifierLengthPtr];
 615         char[][] subset = identifierSubSet(completionIndex);
 616         identifierLengthPtr--;
 617         identifierPtr -= length;
 618         long[] positions = new long[length];
 619         System.arraycopy(
 620                 identifierPositionStack,
 621                 identifierPtr + 1,
 622                 positions,
 623                 0,
 624                 length);
 625
 626         /* build specific completion on name reference */
 627         NameReference reference;
 628         if (completionIndex == 0) {
 629                 /* completion inside first identifier */
 630                 reference = this.createSingleAssistNameReference(assistIdentifier(), positions[0]);
 631         } else {
 632                 /* completion inside subsequent identifier */
 633                 reference = this.createQualifiedAssistNameReference(subset, assistIdentifier(), positions);
 634         };
 635         reference.bits &= ~AstNode.RestrictiveFlagMASK;
 636         reference.bits |= LOCAL | FIELD;
 637
 638         assistNode = reference;
 639         lastCheckPoint = reference.sourceEnd + 1;
 640         return reference;
 641 }
 642 public void goForBlockStatementsopt() {
 643         //tells the scanner to go for block statements opt parsing
 644
 645         firstToken = TokenNameTWIDDLE;
 646         scanner.recordLineSeparator = false;
 647 }
 648 public void goForConstructorBlockStatementsopt() {
 649         //tells the scanner to go for constructor block statements opt parsing
 650
 651         firstToken = TokenNameNOT;
 652         scanner.recordLineSeparator = false;
 653 }
 654 /*
 655  * Retrieve a partial subset of a qualified name reference up to the completion point.
 656  * It does not pop the actual awaiting identifiers, so as to be able to retrieve position
 657  * information afterwards.
 658  */
 659 protected char[][] identifierSubSet(int subsetLength){
 660
 661         if (subsetLength == 0) return null;
 662
 663         char[][] subset;
 664         System.arraycopy(
 665                 identifierStack,
 666                 identifierPtr - identifierLengthStack[identifierLengthPtr] + 1,
 667                 (subset = new char[subsetLength][]),
 668                 0,
 669                 subsetLength);
 670         return subset;
 671 }
 672 /*
 673  * Iterate the most recent group of awaiting identifiers (grouped for qualified name reference (eg. aa.bb.cc)
 674  * so as to check whether one of them is the assist identifier.
 675  * If so, then answer the index of the assist identifier (0 being the first identifier of the set).
 676  *      eg. aa(0).bb(1).cc(2)
 677  * If no assist identifier was found, answers -1.
 678  */
 679 protected int indexOfAssistIdentifier(){
 680
 681         if (identifierLengthPtr < 0){
 682                 return -1; // no awaiting identifier
 683         }
 684
 685         char[] assistIdentifier ;
 686         if ((assistIdentifier = this.assistIdentifier()) == null){
 687                 return -1; // no assist identifier found yet
 688         }
 689
 690         // iterate awaiting identifiers backwards
 691         int length = identifierLengthStack[identifierLengthPtr];
 692         for (int i = 0; i < length; i++){
 693                 if (identifierStack[identifierPtr - i] == assistIdentifier){
 694                         return length - i - 1;
 695                 }
 696         }
 697         // none of the awaiting identifiers is the completion one
 698         return -1;
 699 }
 700 public void initialize() {
 701         super.initialize();
 702         this.flushAssistState();
 703         this.invocationPtr = -1;
 704         this.inMethodStack[this.inMethodPtr = 0] = false;
 705         this.inFieldInitializationStack[this.inFieldInitializationPtr = 0] = false;
 706         this.previousIdentifierPtr = -1;
 707 }
 708 public abstract void initializeScanner();
 709
 710 protected void initInMethodAndInFieldInitializationStack(RecoveredElement currentElement) {
 711
 712         int length = currentElement.depth() + 1;
 713         int ptr = length;
 714         boolean[] methodStack = new boolean[length];
 715         boolean[] fieldInitializationStack = new boolean[length];
 716         boolean inMethod = false;
 717         boolean inFieldInitializer = false;
 718
 719         RecoveredElement element = currentElement;
 720         while(element != null){
 721                 if(element instanceof RecoveredMethod ||
 722                         element instanceof RecoveredInitializer) {
 723                         if(element.parent == null) {
 724                                 methodStack[--ptr] = true;
 725                                 fieldInitializationStack[ptr] = false;
 726                         }
 727                         inMethod = true;
 728                 } else if(element instanceof RecoveredField){
 729                         inFieldInitializer = element.sourceEnd() == 0;
 730                 } else if(element instanceof RecoveredType){
 731                         methodStack[--ptr] = inMethod;
 732                         fieldInitializationStack[ptr] = inFieldInitializer;
 733
 734                         inMethod = false;
 735                         inFieldInitializer = false;
 736                 } else if(element instanceof RecoveredUnit) {
 737                         methodStack[--ptr] = false;
 738                         fieldInitializationStack[ptr] = false;
 739                 }
 740                 element = element.parent;
 741         }
 742
 743         inMethodPtr = length - ptr - 1;
 744         inFieldInitializationPtr = inMethodPtr;
 745         System.arraycopy(methodStack, ptr, inMethodStack, 0, inMethodPtr + 1);
 746         System.arraycopy(fieldInitializationStack, ptr, inFieldInitializationStack, 0, inFieldInitializationPtr + 1);
 747
 748 }
 749
 750 /**
 751  * Returns whether we are directly or indirectly inside a field initializer.
 752  */
 753 protected boolean insideFieldInitialization() {
 754         for (int i = this.inFieldInitializationPtr; i >= 0; i--) {
 755                 if (this.inFieldInitializationStack[i]) {
 756                         return true;
 757                 }
 758         }
 759         return false;
 760 }
 761 /**
 762  * Parse the block statements inside the given method declaration and try to complete at the
 763  * cursor location.
 764  */
 765 public void parseBlockStatements(AbstractMethodDeclaration md, CompilationUnitDeclaration unit) {
 766         if (md instanceof MethodDeclaration) {
 767                 parseBlockStatements((MethodDeclaration) md, unit);
 768         } else if (md instanceof ConstructorDeclaration) {
 769                 parseBlockStatements((ConstructorDeclaration) md, unit);
 770         }
 771 }
 772 /**
 773  * Parse the block statements inside the given constructor declaration and try to complete at the
 774  * cursor location.
 775  */
 776 public void parseBlockStatements(ConstructorDeclaration cd, CompilationUnitDeclaration unit) {
 777         //only parse the method body of cd
 778         //fill out its statements
 779
 780         //convert bugs into parse error
 781
 782         initialize();
 783
 784         // simulate goForConstructorBody except that we don't want to balance brackets because they are not going to be balanced
 785         goForConstructorBlockStatementsopt();
 786
 787         referenceContext = cd;
 788         compilationUnit = unit;
 789
 790         scanner.resetTo(cd.bodyStart, bodyEnd(cd));
 791         consumeNestedMethod();
 792         try {
 793                 parse();
 794         } catch (AbortCompilation ex) {
 795                 lastAct = ERROR_ACTION;
 796         }
 797 }
 798 /**
 799  * Parse the block statements inside the given initializer and try to complete at the
 800  * cursor location.
 801  */
 802 public void parseBlockStatements(
 803         Initializer ini,
 804         TypeDeclaration type,
 805         CompilationUnitDeclaration unit) {
 806
 807         initialize();
 808
 809         // simulate goForInitializer except that we don't want to balance brackets because they are not going to be balanced
 810         goForBlockStatementsopt();
 811
 812         referenceContext = type;
 813         compilationUnit = unit;
 814
 815         scanner.resetTo(ini.sourceStart, bodyEnd(ini)); // just after the beginning {
 816         consumeNestedMethod();
 817         try {
 818                 parse();
 819         } catch (AbortCompilation ex) {
 820                 lastAct = ERROR_ACTION;
 821         } finally {
 822                 nestedMethod[nestedType]--;
 823         }
 824 }
 825 /**
 826  * Parse the block statements inside the given method declaration and try to complete at the
 827  * cursor location.
 828  */
 829 public void parseBlockStatements(MethodDeclaration md, CompilationUnitDeclaration unit) {
 830         //only parse the method body of md
 831         //fill out method statements
 832
 833         //convert bugs into parse error
 834
 835         if (md.isAbstract())
 836                 return;
 837         if (md.isNative())
 838                 return;
 839         if ((md.modifiers & AccSemicolonBody) != 0)
 840                 return;
 841
 842         initialize();
 843
 844         // simulate goForMethodBody except that we don't want to balance brackets because they are not going to be balanced
 845         goForBlockStatementsopt();
 846
 847         referenceContext = md;
 848         compilationUnit = unit;
 849
 850         scanner.resetTo(md.bodyStart, bodyEnd(md)); // reset the scanner to parser from { down to the cursor location
 851         consumeNestedMethod();
 852         try {
 853                 parse();
 854         } catch (AbortCompilation ex) {
 855                 lastAct = ERROR_ACTION;
 856         } finally {
 857                 nestedMethod[nestedType]--;
 858         }
 859 }
 860 /*
 861  * Prepares the state of the parser to go for BlockStatements.
 862  */
 863 protected void prepareForBlockStatements() {
 864         this.nestedMethod[this.nestedType = 0] = 1;
 865         this.variablesCounter[this.nestedType] = 0;
 866         this.realBlockStack[this.realBlockPtr = 1] = 0;
 867         this.invocationPtr = -1;
 868 }
 869 /*
 870  * Pushes 'false' on the inInitializerStack.
 871  */
 872 protected void pushNotInInitializer() {
 873         try {
 874                 this.inFieldInitializationStack[++this.inFieldInitializationPtr] = false;
 875         } catch (IndexOutOfBoundsException e) {
 876                 //except in test's cases, it should never raise
 877                 int oldStackLength = this.inFieldInitializationStack.length;
 878                 System.arraycopy(this.inFieldInitializationStack , 0, (this.inFieldInitializationStack = new boolean[oldStackLength + StackIncrement]), 0, oldStackLength);
 879                 this.inFieldInitializationStack[this.inFieldInitializationPtr] = false;
 880         }
 881 }
 882 /*
 883  * Pushes 'false' on the inMethodStack.
 884  */
 885 protected void pushNotInMethod() {
 886         try {
 887                 this.inMethodStack[++this.inMethodPtr] = false;
 888         } catch (IndexOutOfBoundsException e) {
 889                 //except in test's cases, it should never raise
 890                 int oldStackLength = this.inMethodStack.length;
 891                 System.arraycopy(this.inMethodStack , 0, (this.inMethodStack = new boolean[oldStackLength + StackIncrement]), 0, oldStackLength);
 892                 this.inMethodStack[this.inMethodPtr] = false;
 893         }
 894 }
 895 /**
 896  * Pushes the given the given selector (an identifier pointer to the identifier stack) on the selector stack.
 897  */
 898 protected void pushOnSelectorStack(int selectorIdPtr) {
 899         if (this.invocationPtr < -1) return;
 900         try {
 901                 this.selectorStack[++this.invocationPtr] = selectorIdPtr;
 902         } catch (IndexOutOfBoundsException e) {
 903                 int oldStackLength = this.selectorStack.length;
 904                 int oldSelectorStack[] = this.selectorStack;
 905                 this.selectorStack = new int[oldStackLength + StackIncrement];
 906                 System.arraycopy(oldSelectorStack, 0, this.selectorStack, 0, oldStackLength);
 907                 this.selectorStack[this.invocationPtr] = selectorIdPtr;
 908         }
 909 }
 910 public void reset(){
 911         this.flushAssistState();
 912 }
 913 /*
 914  * Reset context so as to resume to regular parse loop
 915  */
 916 protected void resetStacks() {
 917         super.resetStacks();
 918         this.inFieldInitializationStack[this.inFieldInitializationPtr = 0] = false;
 919         this.inMethodStack[this.inMethodPtr = 0] = false;
 920 }
 921 /*
 922  * Reset context so as to resume to regular parse loop
 923  * If unable to reset for resuming, answers false.
 924  *
 925  * Move checkpoint location, reset internal stacks and
 926  * decide which grammar goal is activated.
 927  */
 928 protected boolean resumeAfterRecovery() {
 929
 930         // reset internal stacks
 931         astPtr = -1;
 932         astLengthPtr = -1;
 933         expressionPtr = -1;
 934         expressionLengthPtr = -1;
 935         identifierPtr = -1;
 936         identifierLengthPtr     = -1;
 937         intPtr = -1;
 938         dimensions = 0 ;
 939         recoveredStaticInitializerStart = 0;
 940
 941         // if in diet mode, reset the diet counter because we're going to restart outside an initializer.
 942         if (diet) dietInt = 0;
 943
 944         /* attempt to move checkpoint location */
 945         if (!this.moveRecoveryCheckpoint()) return false;
 946
 947         initInMethodAndInFieldInitializationStack(currentElement);
 948
 949         // only look for headers
 950         if (referenceContext instanceof CompilationUnitDeclaration
 951                 || this.assistNode != null){
 952
 953                 if(inMethodStack[inMethodPtr] &&
 954                         insideFieldInitialization() &&
 955                         this.assistNode == null
 956                         ){
 957                         this.prepareForBlockStatements();
 958                         goForBlockStatementsOrMethodHeaders();
 959                 } else {
 960                         nestedMethod[nestedType = 0] = 0;
 961                         variablesCounter[nestedType] = 0;
 962                         realBlockStack[realBlockPtr = 0] = 0;
 963                         goForHeaders();
 964                         diet = true; // passed this point, will not consider method bodies
 965                 }
 966                 return true;
 967         }
 968         if (referenceContext instanceof AbstractMethodDeclaration
 969                 || referenceContext instanceof TypeDeclaration){
 970
 971                 if (currentElement instanceof RecoveredType){
 972                         nestedMethod[nestedType = 0] = 0;
 973                         variablesCounter[nestedType] = 0;
 974                         realBlockStack[realBlockPtr = 0] = 0;
 975                         goForHeaders();
 976                 } else {
 977                         this.prepareForBlockStatements();
 978                         goForBlockStatementsOrMethodHeaders();
 979                 }
 980                 return true;
 981         }
 982         // does not know how to restart
 983         return false;
 984 }
 985 public abstract void setAssistIdentifier(char[] assistIdent);
 986 /**
 987  * If the given ast node is inside an explicit constructor call
 988  * then wrap it with a fake constructor call.
 989  * Returns the wrapped completion node or the completion node itself.
 990  */
 991 protected AstNode wrapWithExplicitConstructorCallIfNeeded(AstNode ast) {
 992         int selector;
 993         if (ast != null && this.invocationPtr >= 0 && ast instanceof Expression &&
 994                         (((selector = this.selectorStack[this.invocationPtr]) == THIS_CONSTRUCTOR) ||
 995                         (selector == SUPER_CONSTRUCTOR))) {
 996                 ExplicitConstructorCall call = new ExplicitConstructorCall(
 997                         (selector == THIS_CONSTRUCTOR) ?
 998                                 ExplicitConstructorCall.This :
 999                                 ExplicitConstructorCall.Super
1000                 );
1001                 call.arguments = new Expression[] {(Expression)ast};
1002                 call.sourceStart = ast.sourceStart;
1003                 call.sourceEnd = ast.sourceEnd;
1004                 return call;
1005         } else {
1006                 return ast;
1007         }
1008 }
1009 }