PHPLanguagePreferencePage.spanish and PHPEditorSyntaxPreferencePage.background added...
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / codeassist / complete / CompletionParser.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.complete;
12
13 /*
14  * Parser able to build specific completion parse nodes, given a cursorLocation.
15  *
16  * Cursor location denotes the position of the last character behind which completion
17  * got requested:
18  *  -1 means completion at the very beginning of the source
19  *      0  means completion behind the first character
20  *  n  means completion behind the n-th character
21  */
22 import net.sourceforge.phpdt.internal.compiler.*;
23 import net.sourceforge.phpdt.internal.compiler.env.*;
24
25 import net.sourceforge.phpdt.internal.compiler.ast.*;
26 import net.sourceforge.phpdt.internal.compiler.parser.*;
27 import net.sourceforge.phpdt.internal.compiler.problem.*;
28 import net.sourceforge.phpdt.internal.codeassist.impl.*;
29
30 public class CompletionParser extends AssistParser {
31
32         /* public fields */
33
34         public int cursorLocation;
35         public char[][] labels; // the visible labels up to the cursor location
36         public AstNode assistNodeParent; // the parent node of assist node
37         /* the following fields are internal flags */
38         
39         boolean betweenNewAndLeftBraket; // whether we are between the keyword 'new' and the following left braket, ie. '[', '(' or '{'
40         boolean betweenCatchAndRightParen; // whether we are between the keyword 'catch' and the following ')'
41         boolean completionBehindDot; // true when completion identifier immediately follows a dot
42         
43         boolean nextTypeReferenceIsClass;
44         boolean nextTypeReferenceIsException;
45         boolean nextTypeReferenceIsInterface;
46         
47         int bracketDepth;
48         int throwBracketDepth;
49
50         // the stacks of types and qualifiers for invocations (ie. method invocations, allocation expressions and
51         // explicit constructor invocations). They use the same stack pointer as the selector stack (ie. invocationPtr)
52         // the invocation type stack contains one of the invocation type constants below
53         // the qualifier stack contains pointers to the expression stack or -1 if there is no qualifier
54         // (a qualifier is the expression that qualifies a 'new', a 'super' constructor or a 'this' constructor
55         //  or it is the receiver of a message send)
56         int[] invocationTypeStack = new int[StackIncrement];
57         int[] qualifierStack = new int[StackIncrement];
58
59         // invocation type constants
60         static final int EXPLICIT_RECEIVER = 0;
61         static final int NO_RECEIVER = -1;
62         static final int SUPER_RECEIVER = -2;
63         static final int NAME_RECEIVER = -3;
64         static final int ALLOCATION = -4;
65         static final int QUALIFIED_ALLOCATION = -5;
66
67         // the type of the current invocation (one of the invocation type constants)
68         int invocationType;
69
70         // a pointer in the expression stack to the qualifier of a invocation
71         int qualifier;
72
73         // a stack of label counters
74         // a new counter is pushed on the stack each time when a method (or a constructor) is entered, 
75         // it is poped when the method (or constructor) is exited,
76         // it is incremented when a new label is defined
77         int labelCounterPtr;
78         int[] labelCounterStack = new int[StackIncrement];
79
80         // a stack of invocationPtr: contains the first invocationPtr of a block
81         // the current invocationPtr+1 is pushed when a block is entered
82         // it is poped when a block is exited 
83         int blockInvocationPtr;
84         int[] blockInvocationStack = new int[StackIncrement];
85         
86         // last modifiers info
87         int lastModifiers = AccDefault;
88         int lastModifiersStart = -1;
89         
90 public CompletionParser(ProblemReporter problemReporter, boolean assertMode) {
91         super(problemReporter, assertMode);
92 }
93 public char[] assistIdentifier(){
94         return ((CompletionScanner)scanner).completionIdentifier;
95 }
96 protected void attachOrphanCompletionNode(){
97         if (this.isOrphanCompletionNode) {
98                 AstNode orphan = this.assistNode;
99                 this.isOrphanCompletionNode = false;
100                 
101                 /* if in context of a type, then persists the identifier into a fake field return type */
102                 if (currentElement instanceof RecoveredType){
103                         RecoveredType recoveredType = (RecoveredType)currentElement;
104                         /* filter out cases where scanner is still inside type header */
105                         if (recoveredType.foundOpeningBrace) {
106                                 /* generate a pseudo field with a completion on type reference */       
107                                 if (orphan instanceof TypeReference){
108                                         CompletionOnFieldType fieldDeclaration = new CompletionOnFieldType((TypeReference)orphan, false);
109
110                                         // retrieve available modifiers if any
111                                         if (intPtr >= 2 && intStack[intPtr-1] == this.lastModifiersStart && intStack[intPtr-2] == this.lastModifiers){
112                                                 fieldDeclaration.modifiersSourceStart = intStack[intPtr-1];
113                                                 fieldDeclaration.modifiers = intStack[intPtr-2];
114                                         }
115
116                                         currentElement = currentElement.add(fieldDeclaration, 0);
117                                         return;
118                                 }
119                         }
120                 }
121                 /* if in context of a method, persists if inside arguments as a type */
122                 if (currentElement instanceof RecoveredMethod){
123                         RecoveredMethod recoveredMethod = (RecoveredMethod)currentElement;
124                         /* only consider if inside method header */
125                         if (!recoveredMethod.foundOpeningBrace) {
126                                 //if (rParenPos < lParenPos){ // inside arguments
127                                 if (orphan instanceof TypeReference){
128                                         currentElement = currentElement.parent.add(
129                                                 new CompletionOnFieldType((TypeReference)orphan, true), 0);
130                                         return;
131                                 }
132                         }
133                 }
134
135                 // add the completion node to the method declaration or constructor declaration
136                 if (orphan instanceof Statement) {
137                         /* check for completion at the beginning of method body
138                                 behind an invalid signature
139                          */
140                         RecoveredMethod method = currentElement.enclosingMethod();
141                         if (method != null){
142                                 AbstractMethodDeclaration methodDecl = method.methodDeclaration;
143                                 if ((methodDecl.bodyStart == methodDecl.sourceEnd+1) // was missing opening brace
144                                         && (scanner.getLineNumber(orphan.sourceStart) == scanner.getLineNumber(methodDecl.sourceEnd))){
145                                         return;
146                                 }
147                         }
148                         // add the completion node as a statement to the list of block statements
149                         currentElement = currentElement.add((Statement)orphan, 0);
150                         return;
151                 } 
152         }
153         
154         // the following code applies only in methods, constructors or initializers
155         if ((!this.inMethodStack[this.inMethodPtr] && !this.inFieldInitializationStack[this.inFieldInitializationPtr])) { 
156                 return;
157         }
158         
159         // push top expression on ast stack if it contains the completion node
160         Expression expression;
161         if (this.expressionPtr > -1 && containsCompletionNode(expression = this.expressionStack[this.expressionPtr])) {
162                 /* check for completion at the beginning of method body
163                         behind an invalid signature
164                  */
165                 RecoveredMethod method = currentElement.enclosingMethod();
166                 if (method != null){
167                         AbstractMethodDeclaration methodDecl = method.methodDeclaration;
168                         if ((methodDecl.bodyStart == methodDecl.sourceEnd+1) // was missing opening brace
169                                 && (scanner.getLineNumber(expression.sourceStart) == scanner.getLineNumber(methodDecl.sourceEnd))){
170                                 return;
171                         }
172                 }
173                 if (expression instanceof AllocationExpression) {
174                         // keep the context if it is an allocation expression
175                         Statement statement = (Statement)wrapWithExplicitConstructorCallIfNeeded(expression);
176                         currentElement = currentElement.add(statement, 0);
177                 } else {
178                         Statement statement = (Statement)wrapWithExplicitConstructorCallIfNeeded(this.assistNode);
179                         currentElement = currentElement.add(statement, 0);
180                 }
181         }
182 }
183 public int bodyEnd(AbstractMethodDeclaration method){
184         return cursorLocation;
185 }
186 public int bodyEnd(Initializer initializer){
187         return cursorLocation;
188 }
189 /**
190  * Checks if the completion is on the exception type of a catch clause.
191  * Returns whether we found a completion node.
192  */
193 private boolean checkCatchClause() {
194         if (this.betweenCatchAndRightParen && this.identifierPtr > -1) { 
195                 // NB: if the cursor is on the variable, then it has been reduced (so identifierPtr is -1), 
196                 //     thus this can only be a completion on the type of the catch clause
197                 this.assistNode = getTypeReference(0);
198                 this.lastCheckPoint = this.assistNode.sourceEnd + 1;
199                 this.isOrphanCompletionNode = true;
200                 return true;
201         }
202         return false;
203 }
204 /**
205  * Checks if the completion is on the type following a 'new'.
206  * Returns whether we found a completion node.
207  */
208 private boolean checkClassInstanceCreation() {
209         if (this.betweenNewAndLeftBraket) {
210                 // completion on type inside an allocation expression
211                 
212                 if(this.throwBracketDepth != -1 && this.throwBracketDepth == this.bracketDepth) {
213                         this.nextTypeReferenceIsException = true;       
214                 }
215                 TypeReference type = getTypeReference(0);
216                 this.nextTypeReferenceIsException = false;
217                 this.assistNode = type;
218                 this.lastCheckPoint = type.sourceEnd + 1;
219                 if (this.invocationType == ALLOCATION) {
220                         // non qualified allocation expression
221                         AllocationExpression allocExpr = new AllocationExpression();
222                         allocExpr.type = type;
223                         allocExpr.sourceStart = type.sourceStart;
224                         allocExpr.sourceEnd = type.sourceEnd;
225                         pushOnExpressionStack(allocExpr);
226                         this.isOrphanCompletionNode = false;
227                 } else {
228                         // qualified allocation expression
229                         QualifiedAllocationExpression allocExpr = new QualifiedAllocationExpression();
230                         allocExpr.type = type;
231                         allocExpr.enclosingInstance = this.expressionStack[this.qualifier];
232                         allocExpr.sourceStart = this.intStack[this.intPtr--];
233                         allocExpr.sourceEnd = type.sourceEnd;
234                         this.expressionStack[this.qualifier] = allocExpr; // attach it now (it replaces the qualifier expression)
235                         this.isOrphanCompletionNode = false;
236                 }
237                 return true;
238         }
239         return false;
240 }
241 /**
242  * Checks if the completion is on the dot following an array type,
243  * a primitive type or an primitive array type.
244  * Returns whether we found a completion node.
245  */
246 private boolean checkClassLiteralAccess() {
247         if (this.identifierLengthPtr >= 1 && this.previousToken == TokenNameDOT) { // (NB: the top id length is 1 and it is for the completion identifier)
248                 int length;
249                 // if the penultimate id length is negative, 
250                 // the completion is after a primitive type or a primitive array type
251                 if ((length = this.identifierLengthStack[this.identifierLengthPtr-1]) < 0) {
252                         // build the primitive type node
253                         int dim = this.isAfterArrayType() ? this.intStack[this.intPtr--] : 0;
254                         SingleTypeReference typeRef = (SingleTypeReference)TypeReference.baseTypeReference(-length, dim);
255                         typeRef.sourceStart = this.intStack[this.intPtr--];
256                         if (dim == 0) {
257                                 typeRef.sourceEnd = this.intStack[this.intPtr--];
258                         } else {
259                                 this.intPtr--;
260                                 typeRef.sourceEnd = this.endPosition;
261                         }
262                         //typeRef.sourceEnd = typeRef.sourceStart + typeRef.token.length; // NB: It's ok to use the length of the token since it doesn't contain any unicode
263
264                         // find the completion identifier and its source positions
265                         char[] source = identifierStack[identifierPtr];
266                         long pos = this.identifierPositionStack[this.identifierPtr--];
267                         this.identifierLengthPtr--; // it can only be a simple identifier (so its length is one)
268
269                         // build the completion on class literal access node
270                         CompletionOnClassLiteralAccess access = new CompletionOnClassLiteralAccess(pos, typeRef);
271                         access.completionIdentifier = source;
272                         this.identifierLengthPtr--; // pop the length that was used to say it is a primitive type
273                         this.assistNode = access;
274                         this.isOrphanCompletionNode = true;
275                         return true;
276                 }
277
278                 // if the completion is after a regular array type
279                 if (isAfterArrayType()) {
280                         // find the completion identifier and its source positions
281                         char[] source = identifierStack[identifierPtr];
282                         long pos = this.identifierPositionStack[this.identifierPtr--];
283                         this.identifierLengthPtr--; // it can only be a simple identifier (so its length is one)
284                         
285                         // get the type reference
286                         TypeReference typeRef = getTypeReference(this.intPtr--);
287                         
288                         // build the completion on class literal access node
289                         CompletionOnClassLiteralAccess access = new CompletionOnClassLiteralAccess(pos, typeRef);
290                         access.completionIdentifier = source;
291                         this.assistNode = access;
292                         this.isOrphanCompletionNode = true;
293                         return true;
294                 }
295
296         }
297         return false;
298 }
299 /**
300  * Checks if the completion is inside a method invocation or a constructor invocation.
301  * Returns whether we found a completion node.
302  */
303 private boolean checkInvocation() {
304         Expression topExpression = this.expressionPtr >= 0 ? 
305                 this.expressionStack[this.expressionPtr] :
306                 null;
307         boolean isEmptyNameCompletion = false;
308         boolean isEmptyAssistIdentifier = false;
309         int startInvocationPtr = this.blockInvocationPtr >= 0 ? this.blockInvocationStack[this.blockInvocationPtr] : 0;
310         if (this.invocationPtr >= startInvocationPtr
311                 && ((isEmptyNameCompletion = topExpression == this.assistNode && this.isEmptyNameCompletion()) // eg. it is something like "this.fred([cursor]" but it is not something like "this.fred(1 + [cursor]"
312                         || (isEmptyAssistIdentifier = this.indexOfAssistIdentifier() >= 0 && this.identifierStack[this.identifierPtr].length == 0))) { // eg. it is something like "this.fred(1 [cursor]"
313                                 
314                 // pop empty name completion
315                 if (isEmptyNameCompletion) {
316                         this.expressionPtr--;
317                         this.expressionLengthStack[this.expressionLengthPtr]--;
318                 } else if (isEmptyAssistIdentifier) {
319                         this.identifierPtr--;
320                         this.identifierLengthPtr--;
321                 }
322
323                 // find receiver and qualifier
324                 int invocationType = this.invocationTypeStack[this.invocationPtr];
325                 int qualifierExprPtr = this.qualifierStack[this.invocationPtr];
326
327                 // find arguments
328                 int numArgs = this.expressionPtr - qualifierExprPtr;
329                 int argStart = qualifierExprPtr + 1;
330                 Expression[] arguments = null;
331                 if (numArgs > 0) {
332                         // remember the arguments
333                         arguments = new Expression[numArgs];
334                         System.arraycopy(this.expressionStack, argStart, arguments, 0, numArgs);
335
336                         // consume the expression arguments
337                         this.expressionPtr -= numArgs;
338                         int count = numArgs;
339                         while (count > 0) {
340                                 count -= this.expressionLengthStack[this.expressionLengthPtr--];
341                         } 
342                 }
343
344                 // build ast node
345                 if (invocationType != ALLOCATION && invocationType != QUALIFIED_ALLOCATION) {
346                         // creates completion on message send   
347                         CompletionOnMessageSend messageSend = new CompletionOnMessageSend();
348                         messageSend.arguments = arguments;
349                         switch (invocationType) {
350                                 case NO_RECEIVER:
351                                         // implicit this
352                                         messageSend.receiver = ThisReference.ThisImplicit;
353                                         break;
354                                 case NAME_RECEIVER:
355                                         // remove special flags for primitive types
356                                         while (this.identifierLengthPtr >= 0 && this.identifierLengthStack[this.identifierLengthPtr] < 0) {
357                                                 this.identifierLengthPtr--;
358                                         }
359                                 
360                                         // remove selector 
361                                         this.identifierPtr--; 
362                                         this.identifierLengthStack[this.identifierLengthPtr]--;
363                                         // consume the receiver
364                                         messageSend.receiver = this.getUnspecifiedReference();
365                                         break;
366                                 case SUPER_RECEIVER:
367                                         messageSend.receiver = SuperReference.Super;
368                                         break;
369                                 case EXPLICIT_RECEIVER:
370                                         messageSend.receiver = this.expressionStack[qualifierExprPtr];
371                         }
372
373                         // set selector
374                         int selectorPtr = this.selectorStack[this.invocationPtr];
375                         messageSend.selector = this.identifierStack[selectorPtr];
376                         // remove selector
377                         if (this.identifierLengthPtr >=0 && this.identifierLengthStack[this.identifierLengthPtr] == 1) {
378                                 this.identifierPtr--; 
379                                 this.identifierLengthPtr--;
380                         }
381                 
382                         // the entire message may be replaced in case qualification is needed
383                         messageSend.sourceStart = (int)(this.identifierPositionStack[selectorPtr] >> 32); //this.cursorLocation + 1;
384                         messageSend.sourceEnd = this.cursorLocation;
385
386                         // remember the message send as an orphan completion node
387                         this.assistNode = messageSend;
388                         this.lastCheckPoint = messageSend.sourceEnd + 1;
389                         this.isOrphanCompletionNode = true;
390                         return true;
391                 } else {
392                         int selectorPtr = this.selectorStack[this.invocationPtr];
393                         if (selectorPtr == THIS_CONSTRUCTOR || selectorPtr == SUPER_CONSTRUCTOR) {
394                                 // creates an explicit constructor call
395                                 CompletionOnExplicitConstructorCall call = new CompletionOnExplicitConstructorCall(
396                                         (selectorPtr == THIS_CONSTRUCTOR) ? ExplicitConstructorCall.This : ExplicitConstructorCall.Super);
397                                 call.arguments = arguments;
398                                 if (invocationType == QUALIFIED_ALLOCATION) {
399                                         call.qualification = this.expressionStack[qualifierExprPtr];
400                                 }
401                 
402                                 // no source is going to be replaced
403                                 call.sourceStart = this.cursorLocation + 1;
404                                 call.sourceEnd = this.cursorLocation;
405
406                                 // remember the explicit constructor call as an orphan completion node
407                                 this.assistNode = call;
408                                 this.lastCheckPoint = call.sourceEnd + 1;
409                                 this.isOrphanCompletionNode = true;
410                                 return true;
411                         } else {
412                                 // creates an allocation expression 
413                                 CompletionOnQualifiedAllocationExpression allocExpr = new CompletionOnQualifiedAllocationExpression();
414                                 allocExpr.arguments = arguments;
415                                 allocExpr.type = super.getTypeReference(0); // we don't want a completion node here, so call super
416                                 if (invocationType == QUALIFIED_ALLOCATION) {
417                                         allocExpr.enclosingInstance = this.expressionStack[qualifierExprPtr];
418                                 }
419                                 // no source is going to be replaced
420                                 allocExpr.sourceStart = this.cursorLocation + 1;
421                                 allocExpr.sourceEnd = this.cursorLocation;
422                                 
423                                 // remember the allocation expression as an orphan completion node
424                                 this.assistNode = allocExpr;
425                                 this.lastCheckPoint = allocExpr.sourceEnd + 1;
426                                 this.isOrphanCompletionNode = true;
427                                 return true;
428                         }
429                 }
430         }
431         return false;
432 }
433 /**
434  * Checks if the completion is on a member access (ie. in an identifier following a dot).
435  * Returns whether we found a completion node.
436  */
437 private boolean checkMemberAccess() {
438         if (this.previousToken == TokenNameDOT && this.qualifier > -1 && this.expressionPtr == this.qualifier) {
439                 // the receiver is an expression
440                 pushCompletionOnMemberAccessOnExpressionStack(false);
441                 return true;
442         }
443         return false;
444 }
445 /**
446  * Checks if the completion is on a name reference.
447  * Returns whether we found a completion node.
448  */
449 private boolean checkNameCompletion() {
450         /* 
451                 We didn't find any other completion, but the completion identifier is on the identifier stack,
452                 so it can only be a completion on name.
453                 Note that we allow the completion on a name even if nothing is expected (eg. foo() b[cursor] would
454                 be a completion on 'b'). This policy gives more to the user than he/she would expect, but this 
455                 simplifies the problem. To fix this, the recovery must be changed to work at a 'statement' granularity
456                 instead of at the 'expression' granularity as it does right now.
457         */ 
458         
459         // NB: at this point the completion identifier is on the identifier stack
460         this.assistNode = getUnspecifiedReferenceOptimized();
461         this.lastCheckPoint = this.assistNode.sourceEnd + 1;
462         this.isOrphanCompletionNode = true;
463         return true;
464 }
465 /**
466  * Checks if the completion is in the context of a method and on the type of one of its arguments
467  * Returns whether we found a completion node.
468  */
469 private boolean checkRecoveredMethod() {
470         if (currentElement instanceof RecoveredMethod){
471                 /* check if current awaiting identifier is the completion identifier */
472                 if (this.indexOfAssistIdentifier() < 0) return false;
473
474                 /* check if on line with an error already - to avoid completing inside 
475                         illegal type names e.g.  int[<cursor> */
476                 if (lastErrorEndPosition <= cursorLocation+1
477                         && scanner.getLineNumber(lastErrorEndPosition) 
478                                 == scanner.getLineNumber(((CompletionScanner)scanner).completedIdentifierStart)){
479                         return false;
480                 }               
481                 RecoveredMethod recoveredMethod = (RecoveredMethod)currentElement;
482                 /* only consider if inside method header */
483                 if (!recoveredMethod.foundOpeningBrace
484                         && lastIgnoredToken == -1) {
485                         //if (rParenPos < lParenPos){ // inside arguments
486                         this.assistNode = this.getTypeReference(0);
487                         this.lastCheckPoint = this.assistNode.sourceEnd + 1;
488                         this.isOrphanCompletionNode = true;
489                         return true;
490                 }
491         }
492         return false;
493 }
494 /**
495  * Checks if the completion is in the context of a type and on a type reference in this type.
496  * Persists the identifier into a fake field return type
497  * Returns whether we found a completion node.
498  */
499 private boolean checkRecoveredType() {
500         if (currentElement instanceof RecoveredType){
501                 /* check if current awaiting identifier is the completion identifier */
502                 if (this.indexOfAssistIdentifier() < 0) return false;
503
504                 /* check if on line with an error already - to avoid completing inside 
505                         illegal type names e.g.  int[<cursor> */
506                 if ((lastErrorEndPosition <= cursorLocation+1)
507                         && scanner.getLineNumber(lastErrorEndPosition) 
508                                 == scanner.getLineNumber(((CompletionScanner)scanner).completedIdentifierStart)){
509                         return false;
510                 }
511                 RecoveredType recoveredType = (RecoveredType)currentElement;
512                 /* filter out cases where scanner is still inside type header */
513                 if (recoveredType.foundOpeningBrace) {
514                         this.assistNode = this.getTypeReference(0);
515                         this.lastCheckPoint = this.assistNode.sourceEnd + 1;
516                         this.isOrphanCompletionNode = true;
517                         return true;
518                 }
519         }
520         return false;
521 }
522 /* 
523  * Check whether about to shift beyond the completion token.
524  * If so, depending on the context, a special node might need to be created
525  * and attached to the existing recovered structure so as to be remember in the
526  * resulting parsed structure.
527  */
528 public void completionIdentifierCheck(){
529
530         if (checkRecoveredType()) return;
531         if (checkRecoveredMethod()) return;
532
533         // if not in a method in non diet mode and if not inside a field initializer, only record references attached to types
534         if (!(this.inMethodStack[this.inMethodPtr] && !this.diet)
535                 && !insideFieldInitialization()) return; 
536
537         /*
538                 In some cases, the completion identifier may not have yet been consumed,
539                 e.g.  int.[cursor]
540                 This is because the grammar does not allow any (empty) identifier to follow
541                 a base type. We thus have to manually force the identifier to be consumed
542                 (i.e. pushed).
543          */
544         if (assistIdentifier() == null && this.currentToken == TokenNameIdentifier) { // Test below copied from CompletionScanner.getCurrentIdentifierSource()
545                 if (cursorLocation < this.scanner.startPosition && this.scanner.currentPosition == this.scanner.startPosition){ // fake empty identifier got issued
546                         this.pushIdentifier();                                  
547                 } else if (cursorLocation+1 >= this.scanner.startPosition && cursorLocation < this.scanner.currentPosition){
548                         this.pushIdentifier();
549                 }
550         }
551
552         // check for different scenarii
553         try {
554                 // no need to go further if we found a non empty completion node
555                 // (we still need to store labels though)
556                 if (this.assistNode != null) {
557                         // however inside an invocation, the completion identifier may already have been consumed into an empty name 
558                         // completion, so this check should be before we check that we are at the cursor location
559                         if (!isEmptyNameCompletion() || checkInvocation()) return;
560                 }
561
562                 // no need to check further if we are not at the cursor location
563                 if (this.indexOfAssistIdentifier() < 0) return;
564
565                 if (checkClassInstanceCreation()) return;
566                 if (checkCatchClause()) return;
567                 if (checkMemberAccess()) return;
568                 if (checkClassLiteralAccess()) return;
569
570                 // if the completion was not on an empty name, it can still be inside an invocation (eg. this.fred("abc"[cursor])
571                 // (NB: Put this check before checkNameCompletion() because the selector of the invocation can be on the identifier stack)
572                 if (checkInvocation()) return;
573
574                 if (checkNameCompletion()) return;
575         } finally {
576                 storeLabelsIfNeeded();
577         }
578 }
579 protected void consumeCaseLabel() {
580         Expression caseExpression = this.expressionStack[this.expressionPtr];
581         if (caseExpression instanceof SingleNameReference || caseExpression instanceof QualifiedNameReference) {
582                 // label counter was wrongly incremented in consumeToken
583                 if (this.labelCounterPtr >= 0) this.labelCounterStack[this.labelCounterPtr]--;
584         }
585         super.consumeCaseLabel();
586 }
587 protected void consumeClassHeaderExtends() {
588         this.nextTypeReferenceIsClass = true;
589         super.consumeClassHeaderExtends();
590         this.nextTypeReferenceIsClass = false;
591 }
592 protected void consumeClassTypeElt() {
593         this.nextTypeReferenceIsException = true;
594         super.consumeClassTypeElt();
595         this.nextTypeReferenceIsException = false;
596 }
597 protected void consumeConditionalExpression(int op) {
598         Expression valueIfTrue = this.expressionStack[this.expressionPtr - 1];
599         if (valueIfTrue instanceof SingleNameReference || valueIfTrue instanceof QualifiedNameReference) {
600                 // label counter was wrongly incremented in consumeToken
601                 if (this.labelCounterPtr >= 0) this.labelCounterStack[this.labelCounterPtr]--;
602         }
603         super.consumeConditionalExpression(op);
604 }
605 protected void consumeConstructorBody() {
606         super.consumeConstructorBody();
607         this.labelCounterPtr--;
608         if (this.blockInvocationPtr >= 0) this.blockInvocationPtr--;
609 }
610 protected void consumeConstructorHeader() {
611         super.consumeConstructorHeader();
612         pushBlockInvocationPtr();
613 }
614 protected void consumeConstructorHeaderName() {
615
616         /* no need to take action if not inside assist identifiers */
617         if (indexOfAssistIdentifier() < 0) {
618                 super.consumeConstructorHeaderName();
619                 return;
620         }
621                 
622         /* force to start recovering in order to get fake field behavior */
623         if (currentElement == null){
624                 this.hasReportedError = true; // do not report any error
625         }
626         this.restartRecovery = true;
627 }
628 protected void consumeEnterVariable() {
629         identifierPtr--;
630         identifierLengthPtr--;
631
632         boolean isLocalDeclaration = nestedMethod[nestedType] != 0;
633         int variableIndex = variablesCounter[nestedType];
634         int extendedDimension = intStack[intPtr + 1];
635         
636         if(isLocalDeclaration || indexOfAssistIdentifier() < 0 || variableIndex != 0 || extendedDimension != 0) {
637                 identifierPtr++;
638                 identifierLengthPtr++;
639                 super.consumeEnterVariable();
640         } else {
641                 restartRecovery = true;
642                 
643                 // recovery
644                 if (currentElement != null) {
645                         int nameSourceStart = (int)(identifierPositionStack[identifierPtr] >>> 32);
646                         intPtr--;
647                         
648                         TypeReference type = getTypeReference(intStack[intPtr--]);
649                         intPtr--;
650                         
651                         if (!(currentElement instanceof RecoveredType)
652                                 && (currentToken == TokenNameDOT
653                                         || (scanner.getLineNumber(type.sourceStart)
654                                                         != scanner.getLineNumber(nameSourceStart)))){
655                                 lastCheckPoint = nameSourceStart;
656                                 restartRecovery = true;
657                                 return;
658                         }
659                         
660                         FieldDeclaration completionFieldDecl = new CompletionOnFieldType(type, false);
661                         completionFieldDecl.modifiers = intStack[intPtr--];
662                         assistNode = completionFieldDecl;
663                         lastCheckPoint = type.sourceEnd + 1;
664                         currentElement = currentElement.add(completionFieldDecl, 0);
665                         lastIgnoredToken = -1;
666                 }
667         }
668 }
669 protected void consumeExitVariableWithInitialization() {
670         super.consumeExitVariableWithInitialization();
671         
672         // does not keep the initialization if completion is not inside
673         AbstractVariableDeclaration variable = (AbstractVariableDeclaration) astStack[astPtr];
674         if (cursorLocation + 1 < variable.initialization.sourceStart ||
675                 cursorLocation > variable.initialization.sourceEnd) {
676                 variable.initialization = null;
677         }
678 }
679
680 /*
681  * Copy of code from superclass with the following change:
682  * If the cursor location is on the field access, then create a 
683  * CompletionOnMemberAccess instead.
684  */
685 protected void consumeFieldAccess(boolean isSuperAccess) {
686         // FieldAccess ::= Primary '.' 'Identifier'
687         // FieldAccess ::= 'super' '.' 'Identifier'
688
689         // potential receiver is being poped, so reset potential receiver
690         this.invocationType = NO_RECEIVER;
691
692         if (this.indexOfAssistIdentifier() < 0) {
693                 super.consumeFieldAccess(isSuperAccess);
694         } else {
695                 this.pushCompletionOnMemberAccessOnExpressionStack(isSuperAccess);
696         }
697 }
698
699 protected void consumeFormalParameter() {
700         if (this.indexOfAssistIdentifier() < 0) {
701                 super.consumeFormalParameter();
702         } else {
703
704                 identifierLengthPtr--;
705                 char[] name = identifierStack[identifierPtr];
706                 long namePositions = identifierPositionStack[identifierPtr--];
707                 TypeReference type = getTypeReference(intStack[intPtr--] + intStack[intPtr--]);
708                 intPtr -= 2;
709                 Argument arg = 
710                         new CompletionOnArgumentName(
711                                 name, 
712                                 namePositions, 
713                                 type, 
714                                 intStack[intPtr + 1] & ~AccDeprecated); // modifiers
715                 pushOnAstStack(arg);
716                 
717                 assistNode = arg;
718                 this.lastCheckPoint = (int) namePositions;
719                 isOrphanCompletionNode = true;
720
721                 /* if incomplete method header, listLength counter will not have been reset,
722                         indicating that some arguments are available on the stack */
723                 listLength++;
724         }       
725 }
726 protected void consumeInterfaceType() {
727         this.nextTypeReferenceIsInterface = true;
728         super.consumeInterfaceType();
729         this.nextTypeReferenceIsInterface = false;
730 }
731 protected void consumeMethodHeaderName() {
732         if(this.indexOfAssistIdentifier() < 0) {
733                 identifierPtr--;
734                 identifierLengthPtr--;
735                 if(this.indexOfAssistIdentifier() != 0) {
736                         identifierPtr++;
737                         identifierLengthPtr++;
738                         super.consumeMethodHeaderName();
739                 } else {
740                         restartRecovery = true;
741                         
742                         // recovery
743                         if (currentElement != null) {
744                                 //name
745                                 char[] selector = identifierStack[identifierPtr + 1];
746                                 long selectorSource = identifierPositionStack[identifierPtr + 1];
747                                 
748                                 //type
749                                 TypeReference type = getTypeReference(intStack[intPtr--]);
750                                 ((CompletionOnSingleTypeReference)type).isCompletionNode = false;
751                                 //modifiers
752                                 int declarationSourceStart = intStack[intPtr--];
753                                 int modifiers = intStack[intPtr--];
754                                 
755                                 if(scanner.getLineNumber(type.sourceStart) != scanner.getLineNumber((int) (selectorSource >>> 32))) {
756                                         FieldDeclaration completionFieldDecl = new CompletionOnFieldType(type, false);
757                                         completionFieldDecl.modifiers = modifiers;
758                                         assistNode = completionFieldDecl;
759                                         lastCheckPoint = type.sourceEnd + 1;
760                                         currentElement = currentElement.add(completionFieldDecl, 0);
761                                         lastIgnoredToken = -1;
762                                 } else {
763                                         CompletionOnMethodReturnType md = new CompletionOnMethodReturnType(type, this.compilationUnit.compilationResult);
764                                         md.selector = selector;
765                                         md.declarationSourceStart = declarationSourceStart;
766                                         md.modifiers = modifiers;
767                                         md.bodyStart = lParenPos+1;
768                                         listLength = 0; // initialize listLength before reading parameters/throws
769                                         assistNode = md;
770                                         this.lastCheckPoint = md.bodyStart;
771                                         currentElement = currentElement.add(md, 0);
772                                         lastIgnoredToken = -1;
773                                 }
774                         }
775                 }
776         } else {
777                 // MethodHeaderName ::= Modifiersopt Type 'Identifier' '('
778                 CompletionOnMethodName md = new CompletionOnMethodName(this.compilationUnit.compilationResult);
779         
780                 //name
781                 md.selector = identifierStack[identifierPtr];
782                 long selectorSource = identifierPositionStack[identifierPtr--];
783                 //type
784                 md.returnType = getTypeReference(intStack[intPtr--]);
785                 //modifiers
786                 md.declarationSourceStart = intStack[intPtr--];
787                 md.modifiers = intStack[intPtr--];
788         
789                 //highlight starts at selector start
790                 md.sourceStart = (int) (selectorSource >>> 32);
791                 md.selectorEnd = (int) selectorSource;
792                 pushOnAstStack(md);
793                 md.sourceEnd = lParenPos;
794                 md.bodyStart = lParenPos+1;
795                 listLength = 0; // initialize listLength before reading parameters/throws
796                 
797                 this.assistNode = md;   
798                 this.lastCheckPoint = md.sourceEnd;
799                 // recovery
800                 if (currentElement != null){
801                         if (currentElement instanceof RecoveredType 
802                                 //|| md.modifiers != 0
803                                 || (scanner.getLineNumber(md.returnType.sourceStart)
804                                                 == scanner.getLineNumber(md.sourceStart))){
805                                 lastCheckPoint = md.bodyStart;
806                                 currentElement = currentElement.add(md, 0);
807                                 lastIgnoredToken = -1;
808                         } else {
809                                 lastCheckPoint = md.sourceStart;
810                                 restartRecovery = true;
811                         }
812                 }
813         }
814 }
815
816
817 protected void consumeMethodBody() {
818         super.consumeMethodBody();
819         this.labelCounterPtr--;
820         if (this.blockInvocationPtr >= 0) this.blockInvocationPtr--;
821 }
822
823 protected void consumeMethodHeader() {
824         super.consumeMethodHeader();
825         pushBlockInvocationPtr();
826 }
827 protected void consumeModifiers() {
828         super.consumeModifiers();
829         // save from stack values
830         this.lastModifiersStart = intStack[intPtr];
831         this.lastModifiers =    intStack[intPtr-1];
832 }
833 protected void consumeNestedMethod() {
834         super.consumeNestedMethod();
835         this.pushNewLabelCounter();
836 }
837 protected void consumeStatementLabel() {
838         super.consumeStatementLabel();
839         if (this.labelCounterPtr >= 0) this.labelCounterStack[this.labelCounterPtr]--;
840 }
841 protected void consumeToken(int token) {
842         int previous = this.previousToken;
843         int previousIdentifierPtr = this.previousIdentifierPtr;
844         super.consumeToken(token);
845
846         // if in field initializer (directly or not), on the completion identifier and not in recovery mode yet
847         // then position end of file at cursor location (so that we have the same behavior as
848         // in method bodies)
849         if (token == TokenNameIdentifier
850                         && this.identifierStack[this.identifierPtr] == assistIdentifier()
851                         && this.currentElement == null
852                         && this.insideFieldInitialization()) {
853                 this.scanner.eofPosition = cursorLocation < Integer.MAX_VALUE ? cursorLocation+1 : cursorLocation;
854         }
855         
856         // if in a method or if in a field initializer 
857         if (this.inMethodStack[this.inMethodPtr] || this.inFieldInitializationStack[this.inFieldInitializationPtr]) {
858                 switch (token) {
859                         case TokenNameDOT:
860                                 switch (previous) {
861 //                                      case TokenNamethis: // eg. this[.]fred()
862 //                                              this.invocationType = EXPLICIT_RECEIVER;
863 //                                              break;
864 //                                      case TokenNamesuper: // eg. super[.]fred()
865 //                                              this.invocationType = SUPER_RECEIVER;
866 //                                              break;
867                                         case TokenNameIdentifier: // eg. bar[.]fred()
868                                                 if (!this.betweenNewAndLeftBraket) { // eg. not new z.y[.]X()
869                                                         if (this.identifierPtr != previousIdentifierPtr) { // if identifier has been consumed, eg. this.x[.]fred()
870                                                                 this.invocationType = EXPLICIT_RECEIVER;
871                                                         } else {
872                                                                 this.invocationType = NAME_RECEIVER;
873                                                         }
874                                                 }
875                                                 break;
876                                 }
877                                 break;
878                         case TokenNameIdentifier:
879                                 if (previous == TokenNameDOT) { // eg. foo().[fred]()
880                                         // if current identifier is the empty completion one
881                                         if (identifierStack[identifierPtr] == CompletionScanner.EmptyCompletionIdentifier){
882                                                 this.completionBehindDot = true;
883                                         }
884                                         if (this.invocationType != SUPER_RECEIVER // eg. not super.[fred]()
885                                                 && this.invocationType != NAME_RECEIVER // eg. not bar.[fred]()
886                                                 && this.invocationType != ALLOCATION // eg. not new foo.[Bar]()
887                                                 && this.invocationType != QUALIFIED_ALLOCATION) { // eg. not fred().new foo.[Bar]()
888
889                                                 this.invocationType = EXPLICIT_RECEIVER;
890                                                 this.qualifier = this.expressionPtr;
891                                         }
892                                 }
893                                 break;  
894                         case TokenNamenew:
895                                 this.betweenNewAndLeftBraket = true;
896                                 this.qualifier = this.expressionPtr; // NB: even if there is no qualification, set it to the expression ptr so that the number of arguments are correctly computed
897                                 if (previous == TokenNameDOT) { // eg. fred().[new] X()
898                                         this.invocationType = QUALIFIED_ALLOCATION;
899                                 } else { // eg. [new] X()
900                                         this.invocationType = ALLOCATION;
901                                 }
902                                 break;
903 //                      case TokenNamethis:
904 //                              if (previous == TokenNameDOT) { // eg. fred().[this]()
905 //                                      this.invocationType = QUALIFIED_ALLOCATION;
906 //                                      this.qualifier = this.expressionPtr;
907 //                              }
908 //                              break;
909 //                      case TokenNamesuper:
910 //                              if (previous == TokenNameDOT) { // eg. fred().[super]()
911 //                                      this.invocationType = QUALIFIED_ALLOCATION;
912 //                                      this.qualifier = this.expressionPtr;
913 //                              }
914 //                              break;
915 //                      case TokenNamecatch:
916 //                              this.betweenCatchAndRightParen = true;
917 //                              break;
918                         case TokenNameLPAREN:
919                                 this.betweenNewAndLeftBraket = false;
920                                 this.bracketDepth++;
921                                 if (this.invocationType == NO_RECEIVER || this.invocationType == NAME_RECEIVER) {
922                                         this.qualifier = this.expressionPtr; // remenber the last expression so that arguments are correctly computed
923                                 }
924                                 switch (previous) {
925                                         case TokenNameIdentifier: // eg. fred[(]) or foo.fred[(])
926                                                 this.pushOnInvocationStacks(this.invocationType, this.qualifier);
927                                                 this.invocationType = NO_RECEIVER;
928                                                 break;
929 //                                      case TokenNamethis: // explicit constructor invocation, eg. this[(]1, 2)
930 //                                              this.pushOnInvocationStacks(
931 //                                                      (this.invocationType == QUALIFIED_ALLOCATION) ? QUALIFIED_ALLOCATION : ALLOCATION, 
932 //                                                      this.qualifier);
933 //                                              this.invocationType = NO_RECEIVER;
934 //                                              break;
935 //                                      case TokenNamesuper: // explicit constructor invocation, eg. super[(]1, 2)
936 //                                              this.pushOnInvocationStacks(
937 //                                                      (this.invocationType == QUALIFIED_ALLOCATION) ? QUALIFIED_ALLOCATION : ALLOCATION, 
938 //                                                      this.qualifier);
939 //                                              this.invocationType = NO_RECEIVER;
940 //                                              break;
941                                 }
942                                 break;
943                         case TokenNameLBRACE:
944                                 this.betweenNewAndLeftBraket = false;
945                                 this.bracketDepth++;
946                                 this.pushBlockInvocationPtr();
947                                 break;
948                         case TokenNameLBRACKET:
949                                 this.betweenNewAndLeftBraket = false;
950                                 this.bracketDepth++;
951                                 break; 
952                         case TokenNameRBRACE:
953                                 this.bracketDepth--;
954                                 if (this.blockInvocationPtr >= 0) this.blockInvocationPtr--;
955                                 break;
956                         case TokenNameRBRACKET:
957                                 this.bracketDepth--;
958                                 break; 
959                         case TokenNameRPAREN:
960                                 this.betweenCatchAndRightParen = false;
961                                 this.bracketDepth--;
962                                 break;
963                         case TokenNameCOLON:
964                                 if (previous == TokenNameIdentifier) {
965                                         if (this.labelCounterPtr >= 0) this.labelCounterStack[this.labelCounterPtr]++;
966                                 }
967                                 break;
968 //                      case TokenNamethrow:
969 //                              this.throwBracketDepth= bracketDepth;
970 //                              break;
971                 }
972         }
973 }
974 /**
975  * Return whether the given ast node contains the completion node.
976  */
977 private boolean containsCompletionNode(AstNode ast) {
978         if (this.assistNode == null || ast instanceof Literal) {
979                 return false;
980         }
981         if (this.assistNode == ast) {
982                 return true;
983         }
984         if (ast instanceof Reference || ast instanceof TypeReference) {
985                 return ast == this.assistNode;
986         }
987         if (ast instanceof Assignment) {
988                 Assignment assign = (Assignment)ast;
989                 return containsCompletionNode(assign.lhs) || containsCompletionNode(assign.expression);
990         }
991         if (ast instanceof UnaryExpression) {
992                 UnaryExpression unary = (UnaryExpression)ast;
993                 return containsCompletionNode(unary.expression);
994         }
995         if (ast instanceof BinaryExpression) {
996                 BinaryExpression binary = (BinaryExpression)ast;
997                 return containsCompletionNode(binary.left) || containsCompletionNode(binary.right);
998         }
999         if (ast instanceof InstanceOfExpression) {
1000                 InstanceOfExpression instanceOfExpr = (InstanceOfExpression)ast;
1001                 return containsCompletionNode(instanceOfExpr.expression) || containsCompletionNode(instanceOfExpr.type);
1002         }
1003         if (ast instanceof ConditionalExpression) {
1004                 ConditionalExpression conditional = (ConditionalExpression)ast;
1005                 return containsCompletionNode(conditional.condition) || containsCompletionNode(conditional.valueIfTrue) || containsCompletionNode(conditional.valueIfFalse);
1006         }
1007         if (ast instanceof AllocationExpression) {
1008                 AllocationExpression alloc = (AllocationExpression)ast;
1009                 return containsCompletionNode(alloc.type);
1010         }
1011         if (ast instanceof CastExpression) {
1012                 CastExpression cast = (CastExpression)ast;
1013                 return containsCompletionNode(cast.expression) || containsCompletionNode(cast.type);
1014         }
1015         if (ast instanceof ExplicitConstructorCall) {
1016                 ExplicitConstructorCall call = (ExplicitConstructorCall)ast;
1017                 Expression[] arguments = call.arguments;
1018                 if (arguments != null) {
1019                         for (int i = 0; i < arguments.length; i++) {
1020                                 if (containsCompletionNode(arguments[i])) {
1021                                         return true;
1022                                 }
1023                         }
1024                         return false;
1025                 }
1026         }
1027         return false;
1028 }
1029 public ImportReference createAssistImportReference(char[][] tokens, long[] positions){
1030         return new CompletionOnImportReference(tokens, positions);
1031 }
1032 public ImportReference createAssistPackageReference(char[][] tokens, long[] positions){
1033         return new CompletionOnPackageReference(tokens, positions);
1034 }
1035 public NameReference createQualifiedAssistNameReference(char[][] previousIdentifiers, char[] name, long[] positions){
1036         return new CompletionOnQualifiedNameReference(
1037                                         previousIdentifiers, 
1038                                         name, 
1039                                         positions);     
1040 }
1041 public TypeReference createQualifiedAssistTypeReference(char[][] previousIdentifiers, char[] name, long[] positions){
1042         return this.betweenCatchAndRightParen || this.nextTypeReferenceIsException // check for exception scenario 
1043                                 ? new CompletionOnQualifiedExceptionReference(
1044                                         previousIdentifiers,  
1045                                         name, 
1046                                         positions)
1047                                 : this.nextTypeReferenceIsInterface
1048                                         ? new CompletionOnQualifiedInterfaceReference(
1049                                                 previousIdentifiers, 
1050                                                 name, 
1051                                                 positions)
1052                                         : this.nextTypeReferenceIsClass
1053                                                 ? new CompletionOnQualifiedClassReference(
1054                                                         previousIdentifiers, 
1055                                                         name, 
1056                                                         positions)
1057                                                 : new CompletionOnQualifiedTypeReference(
1058                                                         previousIdentifiers, 
1059                                                         name, 
1060                                                         positions);     
1061 }
1062 public NameReference createSingleAssistNameReference(char[] name, long position) {
1063         return new CompletionOnSingleNameReference(name, position);
1064 }
1065 public TypeReference createSingleAssistTypeReference(char[] name, long position) {
1066         return this.betweenCatchAndRightParen || this.nextTypeReferenceIsException // check for exception scenario 
1067                 ? new CompletionOnExceptionReference(name, position) 
1068                 : this.nextTypeReferenceIsInterface
1069                         ? new CompletionOnInterfaceReference(name, position) 
1070                         : this.nextTypeReferenceIsClass
1071                                 ? new CompletionOnClassReference(name, position) 
1072                                 : new CompletionOnSingleTypeReference(name, position);
1073 }
1074 public CompilationUnitDeclaration dietParse(ICompilationUnit sourceUnit, CompilationResult compilationResult, int cursorLocation) {
1075
1076         this.cursorLocation = cursorLocation;
1077         CompletionScanner completionScanner = (CompletionScanner)this.scanner;
1078         completionScanner.completionIdentifier = null;
1079         completionScanner.cursorLocation = cursorLocation;
1080         return this.dietParse(sourceUnit, compilationResult);
1081 }
1082 /*
1083  * Flush parser/scanner state regarding to code assist
1084  */
1085 public void flushAssistState() {
1086
1087         super.flushAssistState();
1088         this.isOrphanCompletionNode = false;
1089         CompletionScanner completionScanner = (CompletionScanner)this.scanner;
1090         completionScanner.completedIdentifierStart = 0;
1091         completionScanner.completedIdentifierEnd = -1;
1092 }
1093 protected NameReference getUnspecifiedReferenceOptimized() {
1094         if (this.identifierLengthStack[this.identifierLengthPtr] > 1) { // reducing a qualified name
1095                 // potential receiver is being poped, so reset potential receiver
1096                 this.invocationType = NO_RECEIVER;
1097         }
1098         return super.getUnspecifiedReferenceOptimized();
1099 }
1100 /**
1101  * Return whether the given ast node has information interresting for code completion.
1102  */
1103 private boolean hasCompletionInformation(AstNode ast) {
1104         return (
1105                 ast instanceof AbstractMethodDeclaration ||
1106                 ast instanceof AbstractVariableDeclaration ||
1107                 ast instanceof LabeledStatement ||
1108                 ast instanceof TypeDeclaration);
1109 }
1110 public void initialize() {
1111         super.initialize();
1112         this.initializeForBlockStatements();
1113         this.labelCounterPtr = -1;
1114 }
1115 /*
1116  * Initializes the state of the parser that is about to go for BlockStatements.
1117  */
1118 private void initializeForBlockStatements() {
1119         this.previousToken = -1;
1120         this.previousIdentifierPtr = -1;
1121         this.completionBehindDot = false;
1122         this.betweenNewAndLeftBraket = false;
1123         this.betweenCatchAndRightParen = false;
1124         this.bracketDepth = 0;
1125         this.throwBracketDepth = -1;
1126         this.invocationType = NO_RECEIVER;
1127         this.qualifier = -1;
1128         this.blockInvocationPtr = -1;
1129 }
1130 public void initializeScanner(){
1131         this.scanner = new CompletionScanner(this.assertMode);
1132 }
1133 /**
1134  * Returns whether the completion is just after an array type
1135  * eg. String[].[cursor]
1136  */
1137 private boolean isAfterArrayType() {
1138         // TBD: The following relies on the fact that array dimensions are small: it says that if the
1139         //      top of the intStack is less than 11, then it must be a dimension 
1140         //      (smallest position of array type in a compilation unit is 11 as in "class X{Y[]")
1141         if ((this.intPtr > -1) && (this.intStack[this.intPtr] < 11)) {
1142                 return true;
1143         }
1144         return false;
1145 }
1146 private boolean isEmptyNameCompletion() {
1147         return
1148                 this.assistNode != null && 
1149                 this.assistNode instanceof CompletionOnSingleNameReference &&
1150                 (((CompletionOnSingleNameReference)this.assistNode).token.length == 0);
1151 }
1152 public CompilationUnitDeclaration parse(ICompilationUnit sourceUnit, CompilationResult compilationResult, int cursorLocation) {
1153
1154         this.cursorLocation = cursorLocation;
1155         CompletionScanner completionScanner = (CompletionScanner)this.scanner;
1156         completionScanner.completionIdentifier = null;
1157         completionScanner.cursorLocation = cursorLocation;
1158         return this.parse(sourceUnit, compilationResult);
1159 }
1160 /*
1161  * Prepares the state of the parser to go for BlockStatements.
1162  */
1163 protected void prepareForBlockStatements() {
1164         super.prepareForBlockStatements();
1165         this.initializeForBlockStatements();
1166 }
1167 protected void pushBlockInvocationPtr() {
1168         try {
1169                 this.blockInvocationStack[++this.blockInvocationPtr] = this.invocationPtr+1;
1170         } catch (IndexOutOfBoundsException e) {
1171                 int oldStackLength = this.blockInvocationStack.length;
1172                 int[] oldStack = this.blockInvocationStack;
1173                 this.blockInvocationStack = new int[oldStackLength + StackIncrement];
1174                 System.arraycopy(oldStack, 0, this.blockInvocationStack, 0, oldStackLength);
1175                 this.blockInvocationStack[this.blockInvocationPtr] = this.invocationPtr+1;
1176         }
1177 }
1178 /**
1179  * Creates a completion on member access node and push it
1180  * on the expression stack.
1181  */
1182 private void pushCompletionOnMemberAccessOnExpressionStack(boolean isSuperAccess) {
1183         char[] source = identifierStack[identifierPtr];
1184         long pos = identifierPositionStack[identifierPtr--];
1185         CompletionOnMemberAccess fr = new CompletionOnMemberAccess(source, pos);
1186         this.assistNode = fr;
1187         this.lastCheckPoint = fr.sourceEnd + 1;
1188         identifierLengthPtr--;
1189         if (isSuperAccess) { //considerates the fieldReference beginning at the 'super' ....    
1190                 fr.sourceStart = intStack[intPtr--];
1191                 fr.receiver = new SuperReference(fr.sourceStart, endPosition);
1192                 pushOnExpressionStack(fr);
1193         } else { //optimize push/pop
1194                 if ((fr.receiver = expressionStack[expressionPtr]).isThis()) { //fieldreference begins at the this
1195                         fr.sourceStart = fr.receiver.sourceStart;
1196                 }
1197                 expressionStack[expressionPtr] = fr;
1198         }
1199 }
1200 protected void pushNewLabelCounter() {
1201         try {
1202                 this.labelCounterStack[++this.labelCounterPtr] = 0;
1203         } catch (IndexOutOfBoundsException e) {
1204                 int oldStackLength = this.labelCounterStack.length;
1205                 int[] oldStack = this.labelCounterStack;
1206                 this.labelCounterStack = new int[oldStackLength + StackIncrement];
1207                 System.arraycopy(oldStack, 0, this.labelCounterStack, 0, oldStackLength);
1208                 this.labelCounterStack[this.labelCounterPtr] = 0;
1209         }
1210 }
1211 /**
1212  * Pushes the given invocation type (one of the invocation type constants) on the invocation type stack,
1213  * and the given qualifier (an expression pointer to the expression stack) on the qualifier stack.
1214  */
1215 protected void pushOnInvocationStacks(int invocationType, int qualifierExprPtr) {
1216         // NB: invocationPtr has already been incremented by a call to pushOnSelectorStack()
1217         try {
1218                 this.invocationTypeStack[this.invocationPtr] = invocationType;
1219                 this.qualifierStack[this.invocationPtr] = qualifierExprPtr;
1220         } catch (IndexOutOfBoundsException e) {
1221                 int oldStackLength = this.invocationTypeStack.length;
1222                 int oldInvocationTypeStack[] = this.invocationTypeStack;
1223                 int oldQualifierStack[] = this.qualifierStack;
1224                 this.invocationTypeStack = new int[oldStackLength + StackIncrement];
1225                 this.qualifierStack = new int[oldStackLength + StackIncrement];
1226                 System.arraycopy(oldInvocationTypeStack, 0, this.invocationTypeStack, 0, oldStackLength);
1227                 System.arraycopy(oldQualifierStack, 0, this.qualifierStack, 0, oldStackLength);
1228                 this.invocationTypeStack[this.invocationPtr] = invocationType;
1229                 this.qualifierStack[this.invocationPtr] = qualifierExprPtr;
1230         }
1231 }
1232 public void recordCompletionOnReference(){
1233
1234         if (currentElement instanceof RecoveredType){
1235                 RecoveredType recoveredType = (RecoveredType)currentElement;
1236
1237                 /* filter out cases where scanner is still inside type header */
1238                 if (!recoveredType.foundOpeningBrace) return;
1239                 
1240                 /* generate a pseudo field with a completion on type reference */       
1241                 currentElement.add(
1242                         new CompletionOnFieldType(this.getTypeReference(0), false), 0);
1243                 return;
1244         }
1245         if (!diet) return; // only record references attached to types
1246
1247 }
1248 protected void reportSyntaxError(int act, int currentKind, int stateStackTop) {
1249
1250         /* Intercept error state on EOF inside method bodies, due to 
1251            cursor location being used as an EOF position.
1252         */
1253         if (!diet && currentToken == TokenNameEOF) return;
1254         super.reportSyntaxError(act, currentKind, stateStackTop);
1255 }
1256 /*
1257  * Reset internal state after completion is over
1258  */
1259  
1260 public void reset() {
1261         super.reset();
1262         this.cursorLocation = 0;
1263 }
1264 /*
1265  * Reset internal state after completion is over
1266  */
1267  
1268 public void resetAfterCompletion() {
1269         this.cursorLocation = 0;
1270         this.flushAssistState();
1271 }
1272 /*
1273  * Reset context so as to resume to regular parse loop
1274  * If unable to reset for resuming, answers false.
1275  *
1276  * Move checkpoint location, reset internal stacks and
1277  * decide which grammar goal is activated.
1278  */
1279 protected boolean resumeAfterRecovery() {
1280         if (this.assistNode != null) {
1281                 /* if reached [eof] inside method body, but still inside nested type,
1282                         or inside a field initializer, should continue in diet mode until 
1283                         the end of the method body or compilation unit */
1284                 if ((scanner.eofPosition == cursorLocation+1)
1285                         && (!(referenceContext instanceof CompilationUnitDeclaration) 
1286                                 || insideFieldInitialization())) {
1287
1288                         /*      disabled since does not handle possible field/message refs, i.e. Obj[ASSIST HERE]ect.registerNatives()              
1289                         // consume extra tokens which were part of the qualified reference
1290                         //   so that the replaced source comprises them as well 
1291                         if (this.assistNode instanceof NameReference){
1292                                 int oldEof = scanner.eofPosition;
1293                                 scanner.eofPosition = currentElement.topElement().sourceEnd()+1;
1294                                 scanner.currentPosition = this.cursorLocation+1;
1295                                 int token = -1;
1296                                 try {
1297                                         do {
1298                                                 // first token might not have to be a dot
1299                                                 if (token >= 0 || !this.completionBehindDot){
1300                                                         if ((token = scanner.getNextToken()) != TokenNameDOT) break;
1301                                                 }
1302                                                 if ((token = scanner.getNextToken()) != TokenNameIdentifier) break;
1303                                                 this.assistNode.sourceEnd = scanner.currentPosition - 1;
1304                                         } while (token != TokenNameEOF);
1305                                 } catch (InvalidInputException e){
1306                                 } finally {
1307                                         scanner.eofPosition = oldEof;
1308                                 }
1309                         }
1310                         */                      
1311                         /* restart in diet mode for finding sibling constructs */
1312                         if (currentElement.enclosingType() != null){
1313                                 lastCheckPoint = this.assistNode.sourceEnd+1;
1314                                 int end = currentElement.topElement().sourceEnd();
1315                                 scanner.eofPosition = end < Integer.MAX_VALUE ? end + 1 : end;
1316                         } else {
1317                                 this.resetStacks();
1318                                 return false;   
1319                         }
1320                 }
1321         }
1322         return super.resumeAfterRecovery();
1323 }
1324 public void setAssistIdentifier(char[] assistIdent){
1325         ((CompletionScanner)scanner).completionIdentifier = assistIdent;
1326 }
1327 /**
1328  * Stores the labels left on the identifier stack if they have not been stored yet.
1329  */
1330 private void storeLabelsIfNeeded() {
1331 //      int counter = this.labelCounterPtr >= 0 ? this.labelCounterStack[this.labelCounterPtr] : 0;
1332 //      if (this.labels == null && this.identifierPtr >= 0) {
1333 //              this.labels = new char[counter][];
1334 //              System.arraycopy(this.identifierStack, this.identifierPtr - counter + 1, this.labels, 0, counter);
1335 //      }
1336 //      this.identifierPtr -= counter;
1337 //      this.identifierLengthPtr -= counter; // labels have not been concatenated yet
1338 }
1339 /*
1340  * Update recovery state based on current parser/scanner state
1341  */
1342 protected void updateRecoveryState() {
1343
1344         /* expose parser state to recovery state */
1345         currentElement.updateFromParserState();
1346
1347         /* may be able to retrieve completionNode as an orphan, and then attach it */
1348         this.completionIdentifierCheck();
1349         this.attachOrphanCompletionNode();
1350         
1351         // if an assist node has been found and a recovered element exists,
1352         // mark enclosing blocks as to be preserved
1353         if (this.assistNode != null && this.currentElement != null) {
1354                 currentElement.preserveEnclosingBlocks();
1355         }
1356         
1357         /* check and update recovered state based on current token,
1358                 this action is also performed when shifting token after recovery
1359                 got activated once. 
1360         */
1361         this.recoveryTokenCheck();
1362 }
1363
1364 protected LocalDeclaration createLocalDeclaration(Expression initialization, char[] name, int sourceStart, int sourceEnd) {
1365         if (this.indexOfAssistIdentifier() < 0) {
1366                 return super.createLocalDeclaration(initialization, name, sourceStart, sourceEnd);
1367         } else {
1368                 CompletionOnLocalName local = new CompletionOnLocalName(initialization, name, sourceStart, sourceEnd);
1369                 this.assistNode = local;
1370                 this.lastCheckPoint = sourceEnd + 1;
1371                 return local;
1372         }
1373 }
1374
1375 protected FieldDeclaration createFieldDeclaration(Expression initialization, char[] name, int sourceStart, int sourceEnd) {
1376         if (this.indexOfAssistIdentifier() < 0) {
1377                 return super.createFieldDeclaration(initialization, name, sourceStart, sourceEnd);
1378         } else {
1379                 CompletionOnFieldName field = new CompletionOnFieldName(initialization, name, sourceStart, sourceEnd);
1380                 this.assistNode = field;
1381                 this.lastCheckPoint = sourceEnd + 1;
1382                 return field;
1383         }
1384 }
1385
1386 }