added Spanish language in the page (why wasn't it ?)
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / codeassist / select / SelectionParser.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.select;
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  
23 import net.sourceforge.phpdt.internal.compiler.*;
24 import net.sourceforge.phpdt.internal.compiler.env.*;
25
26 import net.sourceforge.phpdt.internal.codeassist.impl.*;
27 import net.sourceforge.phpdt.internal.compiler.ast.*;
28 import net.sourceforge.phpdt.internal.compiler.lookup.BlockScope;
29 import net.sourceforge.phpdt.internal.compiler.lookup.TypeBinding;
30 import net.sourceforge.phpdt.internal.compiler.parser.*;
31 import net.sourceforge.phpdt.internal.compiler.problem.*;
32 import net.sourceforge.phpdt.internal.compiler.util.CharOperation;
33
34 public class SelectionParser extends AssistParser {
35
36         /* public fields */
37
38         public int selectionStart, selectionEnd;
39
40         public static final char[] SUPER = "super".toCharArray(); //$NON-NLS-1$
41         public static final char[] THIS = "this".toCharArray(); //$NON-NLS-1$
42         
43 public SelectionParser(ProblemReporter problemReporter, boolean assertMode) {
44         super(problemReporter, assertMode);
45 }
46 public char[] assistIdentifier(){
47         return ((SelectionScanner)scanner).selectionIdentifier;
48 }
49 protected void attachOrphanCompletionNode(){
50         if (isOrphanCompletionNode){
51                 AstNode orphan = this.assistNode;
52                 isOrphanCompletionNode = false;
53                 
54                 
55                 /* if in context of a type, then persists the identifier into a fake field return type */
56                 if (currentElement instanceof RecoveredType){
57                         RecoveredType recoveredType = (RecoveredType)currentElement;
58                         /* filter out cases where scanner is still inside type header */
59                         if (recoveredType.foundOpeningBrace) {
60                                 /* generate a pseudo field with a completion on type reference */       
61                                 if (orphan instanceof TypeReference){
62                                         currentElement = currentElement.add(new SelectionOnFieldType((TypeReference)orphan), 0);
63                                         return;
64                                 }
65                         }
66                 }
67                 
68                 Statement statement = (Statement)wrapWithExplicitConstructorCallIfNeeded(orphan);
69                 currentElement = currentElement.add(statement, 0);
70                 currentToken = 0; // given we are not on an eof, we do not want side effects caused by looked-ahead token
71         }
72 }
73
74 private boolean checkRecoveredType() {
75         if (currentElement instanceof RecoveredType){
76                 /* check if current awaiting identifier is the completion identifier */
77                 if (this.indexOfAssistIdentifier() < 0) return false;
78
79                 if ((lastErrorEndPosition >= selectionStart)
80                         && (lastErrorEndPosition <= selectionEnd+1)){
81                         return false;
82                 }
83                 RecoveredType recoveredType = (RecoveredType)currentElement;
84                 /* filter out cases where scanner is still inside type header */
85                 if (recoveredType.foundOpeningBrace) {
86                         this.assistNode = this.getTypeReference(0);
87                         this.lastCheckPoint = this.assistNode.sourceEnd + 1;
88                         this.isOrphanCompletionNode = true;
89                         return true;
90                 }
91         }
92         return false;
93 }
94 protected void classInstanceCreation(boolean alwaysQualified) {
95         
96         // ClassInstanceCreationExpression ::= 'new' ClassType '(' ArgumentListopt ')' ClassBodyopt
97
98         // ClassBodyopt produces a null item on the astStak if it produces NO class body
99         // An empty class body produces a 0 on the length stack.....
100
101         int length;
102         if (((length = astLengthStack[astLengthPtr]) == 1)
103                 && (astStack[astPtr] == null)) {
104
105                 if (this.indexOfAssistIdentifier() < 0) {
106                         super.classInstanceCreation(alwaysQualified);
107                         return;
108                 }
109                 QualifiedAllocationExpression alloc;
110                 astPtr--;
111                 astLengthPtr--;
112                 alloc = new SelectionOnQualifiedAllocationExpression();
113                 alloc.sourceEnd = endPosition; //the position has been stored explicitly
114
115                 if ((length = expressionLengthStack[expressionLengthPtr--]) != 0) {
116                         expressionPtr -= length;
117                         System.arraycopy(
118                                 expressionStack, 
119                                 expressionPtr + 1, 
120                                 alloc.arguments = new Expression[length], 
121                                 0, 
122                                 length); 
123                 }
124                 // trick to avoid creating a selection on type reference
125                 char [] oldIdent = this.assistIdentifier();
126                 this.setAssistIdentifier(null);                 
127                 alloc.type = getTypeReference(0);
128                 this.setAssistIdentifier(oldIdent);
129                 
130                 //the default constructor with the correct number of argument
131                 //will be created and added by the TC (see createsInternalConstructorWithBinding)
132                 alloc.sourceStart = intStack[intPtr--];
133                 pushOnExpressionStack(alloc);
134
135                 this.assistNode = alloc;
136                 this.lastCheckPoint = alloc.sourceEnd + 1;
137                 if (!diet){
138                         this.restartRecovery    = true; // force to restart in recovery mode
139                         this.lastIgnoredToken = -1;     
140                 }
141                 this.isOrphanCompletionNode = true;
142         } else {
143                 super.classInstanceCreation(alwaysQualified);
144         }
145 }
146
147 protected void consumeArrayCreationExpression() {
148         // ArrayCreationExpression ::= 'new' PrimitiveType DimWithOrWithOutExprs ArrayInitializeropt
149         // ArrayCreationExpression ::= 'new' ClassOrInterfaceType DimWithOrWithOutExprs ArrayInitializeropt
150
151         super.consumeArrayCreationExpression();
152
153         ArrayAllocationExpression alloc = (ArrayAllocationExpression)expressionStack[expressionPtr];
154         if (alloc.type == assistNode){
155                 if (!diet){
156                         this.restartRecovery    = true; // force to restart in recovery mode
157                         this.lastIgnoredToken = -1;     
158                 }
159                 this.isOrphanCompletionNode = true;
160         }
161 }
162 protected void consumeEnterAnonymousClassBody() {
163         // EnterAnonymousClassBody ::= $empty
164
165         if (this.indexOfAssistIdentifier() < 0) {
166                 super.consumeEnterAnonymousClassBody();
167                 return;
168         }
169         QualifiedAllocationExpression alloc;
170         AnonymousLocalTypeDeclaration anonymousType = 
171                 new AnonymousLocalTypeDeclaration(this.compilationUnit.compilationResult); 
172         alloc = 
173                 anonymousType.allocation = new SelectionOnQualifiedAllocationExpression(anonymousType); 
174         markCurrentMethodWithLocalType();
175         pushOnAstStack(anonymousType);
176
177         alloc.sourceEnd = rParenPos; //the position has been stored explicitly
178         int argumentLength;
179         if ((argumentLength = expressionLengthStack[expressionLengthPtr--]) != 0) {
180                 expressionPtr -= argumentLength;
181                 System.arraycopy(
182                         expressionStack, 
183                         expressionPtr + 1, 
184                         alloc.arguments = new Expression[argumentLength], 
185                         0, 
186                         argumentLength); 
187         }
188         // trick to avoid creating a selection on type reference
189         char [] oldIdent = this.assistIdentifier();
190         this.setAssistIdentifier(null);                 
191         alloc.type = getTypeReference(0);
192         this.setAssistIdentifier(oldIdent);             
193
194         anonymousType.sourceEnd = alloc.sourceEnd;
195         //position at the type while it impacts the anonymous declaration
196         anonymousType.sourceStart = anonymousType.declarationSourceStart = alloc.type.sourceStart;
197         alloc.sourceStart = intStack[intPtr--];
198         pushOnExpressionStack(alloc);
199
200         assistNode = alloc;
201         this.lastCheckPoint = alloc.sourceEnd + 1;
202         if (!diet){
203                 this.restartRecovery    = true; // force to restart in recovery mode
204                 this.lastIgnoredToken = -1;     
205         }
206         this.isOrphanCompletionNode = true;
207                 
208         anonymousType.bodyStart = scanner.currentPosition;      
209         listLength = 0; // will be updated when reading super-interfaces
210         // recovery
211         if (currentElement != null){ 
212                 lastCheckPoint = anonymousType.bodyStart;
213                 currentElement = currentElement.add(anonymousType, 0); // the recoveryTokenCheck will deal with the open brace
214                 lastIgnoredToken = -1;          
215         }
216 }
217 protected void consumeEnterVariable() {
218         // EnterVariable ::= $empty
219         // do nothing by default
220
221         super.consumeEnterVariable();
222
223         AbstractVariableDeclaration variable = (AbstractVariableDeclaration) astStack[astPtr];
224         if (variable.type == assistNode){
225                 if (!diet){
226                         this.restartRecovery    = true; // force to restart in recovery mode
227                         this.lastIgnoredToken = -1;     
228                 }
229                 isOrphanCompletionNode = false; // already attached inside variable decl
230         }
231 }
232
233 protected void consumeExitVariableWithInitialization() {
234         super.consumeExitVariableWithInitialization();
235         
236         // does not keep the initialization if selection is not inside
237         AbstractVariableDeclaration variable = (AbstractVariableDeclaration) astStack[astPtr];
238         int start = variable.initialization.sourceStart;
239         int end =  variable.initialization.sourceEnd;
240         if ((selectionStart < start) &&  (selectionEnd < start) ||
241                 (selectionStart > end) && (selectionEnd > end)) {
242                 variable.initialization = null;
243         }
244 }
245
246 protected void consumeFieldAccess(boolean isSuperAccess) {
247         // FieldAccess ::= Primary '.' 'Identifier'
248         // FieldAccess ::= 'super' '.' 'Identifier'
249
250         if (this.indexOfAssistIdentifier() < 0) {
251                 super.consumeFieldAccess(isSuperAccess);
252                 return;
253         } 
254         FieldReference fieldReference = 
255                 new SelectionOnFieldReference(
256                         identifierStack[identifierPtr], 
257                         identifierPositionStack[identifierPtr--]);
258         identifierLengthPtr--;
259         if (isSuperAccess) { //considerates the fieldReferenceerence beginning at the 'super' ....      
260                 fieldReference.sourceStart = intStack[intPtr--];
261                 fieldReference.receiver = new SuperReference(fieldReference.sourceStart, endPosition);
262                 pushOnExpressionStack(fieldReference);
263         } else { //optimize push/pop
264                 if ((fieldReference.receiver = expressionStack[expressionPtr]).isThis()) { //fieldReferenceerence begins at the this
265                         fieldReference.sourceStart = fieldReference.receiver.sourceStart;
266                 }
267                 expressionStack[expressionPtr] = fieldReference;
268         }
269         assistNode = fieldReference;
270         this.lastCheckPoint = fieldReference.sourceEnd + 1;
271         if (!diet){
272                 this.restartRecovery    = true; // force to restart in recovery mode
273                 this.lastIgnoredToken = -1;
274         }
275         this.isOrphanCompletionNode = true;     
276 }
277 protected void consumeFormalParameter() {
278         if (this.indexOfAssistIdentifier() < 0) {
279                 super.consumeFormalParameter();
280         } else {
281
282                 identifierLengthPtr--;
283                 char[] name = identifierStack[identifierPtr];
284                 long namePositions = identifierPositionStack[identifierPtr--];
285                 TypeReference type = getTypeReference(intStack[intPtr--] + intStack[intPtr--]);
286                 intPtr -= 2;
287                 Argument arg = 
288                         new SelectionOnArgumentName(
289                                 name, 
290                                 namePositions, 
291                                 type, 
292                                 intStack[intPtr + 1] & ~AccDeprecated); // modifiers
293                 pushOnAstStack(arg);
294                 
295                 assistNode = arg;
296                 this.lastCheckPoint = (int) namePositions;
297                 isOrphanCompletionNode = true;
298                 
299                 if (!diet){
300                         this.restartRecovery    = true; // force to restart in recovery mode
301                         this.lastIgnoredToken = -1;     
302                 }
303
304                 /* if incomplete method header, listLength counter will not have been reset,
305                         indicating that some arguments are available on the stack */
306                 listLength++;
307         }       
308 }
309 protected void consumeInstanceOfExpression(int op) {
310         if (indexOfAssistIdentifier() < 0) {
311                 super.consumeInstanceOfExpression(op);
312         } else {
313                 getTypeReference(intStack[intPtr--]);
314                 this.isOrphanCompletionNode = true;
315                 this.restartRecovery = true;
316                 this.lastIgnoredToken = -1;
317         }
318 }
319 protected void consumeMethodInvocationName() {
320         // MethodInvocation ::= Name '(' ArgumentListopt ')'
321
322         // when the name is only an identifier...we have a message send to "this" (implicit)
323
324         char[] selector = identifierStack[identifierPtr];
325         int accessMode;
326         if(selector == this.assistIdentifier()) {
327                 if(CharOperation.equals(selector, SUPER)) {
328                         accessMode = ExplicitConstructorCall.Super;
329                 } else if(CharOperation.equals(selector, THIS)) {
330                         accessMode = ExplicitConstructorCall.This;
331                 } else {
332                         super.consumeMethodInvocationName();
333                         return;
334                 }
335         } else {
336                 super.consumeMethodInvocationName();
337                 return;
338         }
339         
340         final ExplicitConstructorCall constructorCall = new SelectionOnExplicitConstructorCall(accessMode);
341         constructorCall.sourceEnd = rParenPos;
342         constructorCall.sourceStart = (int) (identifierPositionStack[identifierPtr] >>> 32);
343         int length;
344         if ((length = expressionLengthStack[expressionLengthPtr--]) != 0) {
345                 expressionPtr -= length;
346                 System.arraycopy(expressionStack, expressionPtr + 1, constructorCall.arguments = new Expression[length], 0, length);
347         }
348
349         if (!diet){
350                 pushOnAstStack(constructorCall);
351                 this.restartRecovery    = true; // force to restart in recovery mode
352                 this.lastIgnoredToken = -1;
353         } else {
354                 pushOnExpressionStack(new Expression(){
355                         public TypeBinding resolveType(BlockScope scope) {
356                                 constructorCall.resolve(scope);
357                                 return null;
358                         }
359                 });
360         }
361         this.assistNode = constructorCall;      
362         this.lastCheckPoint = constructorCall.sourceEnd + 1;
363         this.isOrphanCompletionNode = true;
364 }
365 protected void consumeMethodInvocationPrimary() {
366         //optimize the push/pop
367         //MethodInvocation ::= Primary '.' 'Identifier' '(' ArgumentListopt ')'
368
369         char[] selector = identifierStack[identifierPtr];
370         int accessMode;
371         if(selector == this.assistIdentifier()) {
372                 if(CharOperation.equals(selector, SUPER)) {
373                         accessMode = ExplicitConstructorCall.Super;
374                 } else if(CharOperation.equals(selector, THIS)) {
375                         accessMode = ExplicitConstructorCall.This;
376                 } else {
377                         super.consumeMethodInvocationPrimary();
378                         return;
379                 }
380         } else {
381                 super.consumeMethodInvocationPrimary();
382                 return;
383         }
384         
385         final ExplicitConstructorCall constructorCall = new SelectionOnExplicitConstructorCall(accessMode);
386         constructorCall.sourceEnd = rParenPos;
387         int length;
388         if ((length = expressionLengthStack[expressionLengthPtr--]) != 0) {
389                 expressionPtr -= length;
390                 System.arraycopy(expressionStack, expressionPtr + 1, constructorCall.arguments = new Expression[length], 0, length);
391         }
392         constructorCall.qualification = expressionStack[expressionPtr--];
393         constructorCall.sourceStart = constructorCall.qualification.sourceStart;
394         
395         if (!diet){
396                 pushOnAstStack(constructorCall);
397                 this.restartRecovery    = true; // force to restart in recovery mode
398                 this.lastIgnoredToken = -1;
399         } else {
400                 pushOnExpressionStack(new Expression(){
401                         public TypeBinding resolveType(BlockScope scope) {
402                                 constructorCall.resolve(scope);
403                                 return null;
404                         }
405                 });
406         }
407         
408         this.assistNode = constructorCall;
409         this.lastCheckPoint = constructorCall.sourceEnd + 1;
410         this.isOrphanCompletionNode = true;
411 }
412 protected void consumeTypeImportOnDemandDeclarationName() {
413         // TypeImportOnDemandDeclarationName ::= 'import' Name '.' '*'
414         /* push an ImportRef build from the last name 
415         stored in the identifier stack. */
416
417         int index;
418
419         /* no need to take action if not inside assist identifiers */
420         if ((index = indexOfAssistIdentifier()) < 0) {
421                 super.consumeTypeImportOnDemandDeclarationName();
422                 return;
423         }
424         /* retrieve identifiers subset and whole positions, the assist node positions
425                 should include the entire replaced source. */
426         int length = identifierLengthStack[identifierLengthPtr];
427         char[][] subset = identifierSubSet(index+1); // include the assistIdentifier
428         identifierLengthPtr--;
429         identifierPtr -= length;
430         long[] positions = new long[length];
431         System.arraycopy(
432                 identifierPositionStack, 
433                 identifierPtr + 1, 
434                 positions, 
435                 0, 
436                 length); 
437
438         /* build specific assist node on import statement */
439         ImportReference reference = this.createAssistImportReference(subset, positions);
440         reference.onDemand = true;
441         assistNode = reference;
442         this.lastCheckPoint = reference.sourceEnd + 1;
443         
444         pushOnAstStack(reference);
445
446         if (currentToken == TokenNameSEMICOLON){
447                 reference.declarationSourceEnd = scanner.currentPosition - 1;
448         } else {
449                 reference.declarationSourceEnd = (int) positions[length-1];
450         }
451         //endPosition is just before the ;
452         reference.declarationSourceStart = intStack[intPtr--];
453         // flush annotations defined prior to import statements
454         reference.declarationSourceEnd = this.flushAnnotationsDefinedPriorTo(reference.declarationSourceEnd);
455
456         // recovery
457         if (currentElement != null){
458                 lastCheckPoint = reference.declarationSourceEnd+1;
459                 currentElement = currentElement.add(reference, 0);
460                 lastIgnoredToken = -1;
461                 restartRecovery = true; // used to avoid branching back into the regular automaton              
462         }
463 }
464 public ImportReference createAssistImportReference(char[][] tokens, long[] positions){
465         return new SelectionOnImportReference(tokens, positions);
466 }
467 public ImportReference createAssistPackageReference(char[][] tokens, long[] positions){
468         return new SelectionOnPackageReference(tokens, positions);
469 }
470 protected LocalDeclaration createLocalDeclaration(Expression initialization,char[] name,int sourceStart,int sourceEnd) {
471         if (this.indexOfAssistIdentifier() < 0) {
472                 return super.createLocalDeclaration(initialization, name, sourceStart, sourceEnd);
473         } else {
474                 SelectionOnLocalName local = new SelectionOnLocalName(initialization, name, sourceStart, sourceEnd);
475                 this.assistNode = local;
476                 this.lastCheckPoint = sourceEnd + 1;
477                 if (!diet){
478                         this.restartRecovery    = true; // force to restart in recovery mode
479                         this.lastIgnoredToken = -1;     
480                 }
481                 return local;
482         }
483 }
484 public NameReference createQualifiedAssistNameReference(char[][] previousIdentifiers, char[] name, long[] positions){
485         return new SelectionOnQualifiedNameReference(
486                                         previousIdentifiers, 
487                                         name, 
488                                         positions);     
489 }
490 public TypeReference createQualifiedAssistTypeReference(char[][] previousIdentifiers, char[] name, long[] positions){
491         return new SelectionOnQualifiedTypeReference(
492                                         previousIdentifiers, 
493                                         name, 
494                                         positions);     
495 }
496 public NameReference createSingleAssistNameReference(char[] name, long position) {
497         return new SelectionOnSingleNameReference(name, position);
498 }
499 public TypeReference createSingleAssistTypeReference(char[] name, long position) {
500         return new SelectionOnSingleTypeReference(name, position);
501 }
502 public CompilationUnitDeclaration dietParse(ICompilationUnit sourceUnit, CompilationResult compilationResult, int selectionStart, int selectionEnd) {
503
504         this.selectionStart = selectionStart;
505         this.selectionEnd = selectionEnd;       
506         SelectionScanner selectionScanner = (SelectionScanner)this.scanner;
507         selectionScanner.selectionIdentifier = null;
508         selectionScanner.selectionStart = selectionStart;
509         selectionScanner.selectionEnd = selectionEnd;   
510         return this.dietParse(sourceUnit, compilationResult);
511 }
512 protected NameReference getUnspecifiedReference() {
513         /* build a (unspecified) NameReference which may be qualified*/
514
515         int completionIndex;
516
517         /* no need to take action if not inside completed identifiers */
518         if ((completionIndex = indexOfAssistIdentifier()) < 0) {
519                 return super.getUnspecifiedReference();
520         }
521
522         int length = identifierLengthStack[identifierLengthPtr];
523         if (CharOperation.equals(assistIdentifier(), SUPER)){
524                 Reference reference;
525                 if (completionIndex > 0){ // qualified super
526                         // discard 'super' from identifier stacks
527                         identifierLengthStack[identifierLengthPtr] = completionIndex;
528                         int ptr = identifierPtr -= (length - completionIndex);
529                         reference = 
530                                 new SelectionOnQualifiedSuperReference(
531                                         getTypeReference(0), 
532                                         (int)(identifierPositionStack[ptr+1] >>> 32),
533                                         (int) identifierPositionStack[ptr+1]);
534                 } else { // standard super
535                         identifierPtr -= length;
536                         identifierLengthPtr--;
537                         reference = new SelectionOnSuperReference((int)(identifierPositionStack[identifierPtr+1] >>> 32), (int) identifierPositionStack[identifierPtr+1]);
538                 }
539                 pushOnAstStack(reference);
540                 this.assistNode = reference;    
541                 this.lastCheckPoint = reference.sourceEnd + 1;
542                 if (!diet || dietInt != 0){
543                         this.restartRecovery    = true; // force to restart in recovery mode
544                         this.lastIgnoredToken = -1;             
545                 }
546                 this.isOrphanCompletionNode = true;
547                 return new SingleNameReference(new char[0], 0); // dummy reference
548         }
549         NameReference nameReference;
550         /* retrieve identifiers subset and whole positions, the completion node positions
551                 should include the entire replaced source. */
552         char[][] subset = identifierSubSet(completionIndex);
553         identifierLengthPtr--;
554         identifierPtr -= length;
555         long[] positions = new long[length];
556         System.arraycopy(
557                 identifierPositionStack, 
558                 identifierPtr + 1, 
559                 positions, 
560                 0, 
561                 length);
562         /* build specific completion on name reference */
563         if (completionIndex == 0) {
564                 /* completion inside first identifier */
565                 nameReference = this.createSingleAssistNameReference(assistIdentifier(), positions[0]);
566         } else {
567                 /* completion inside subsequent identifier */
568                 nameReference = this.createQualifiedAssistNameReference(subset, assistIdentifier(), positions);
569         }
570         assistNode = nameReference;
571         this.lastCheckPoint = nameReference.sourceEnd + 1;
572         if (!diet){
573                 this.restartRecovery    = true; // force to restart in recovery mode
574                 this.lastIgnoredToken = -1;     
575         }
576         this.isOrphanCompletionNode = true;
577         return nameReference;
578 }
579 /*
580  * Copy of code from superclass with the following change:
581  * In the case of qualified name reference if the cursor location is on the 
582  * qualified name reference, then create a CompletionOnQualifiedNameReference 
583  * instead.
584  */
585 protected NameReference getUnspecifiedReferenceOptimized() {
586
587         int index = indexOfAssistIdentifier();
588         NameReference reference = super.getUnspecifiedReferenceOptimized();
589
590         if (index >= 0){
591                 if (!diet){
592                         this.restartRecovery    = true; // force to restart in recovery mode
593                         this.lastIgnoredToken = -1;             
594                 }
595                 this.isOrphanCompletionNode = true;
596         }
597         return reference;
598 }
599 public void initializeScanner(){
600         this.scanner = new SelectionScanner(this.assertMode);
601 }
602 protected MessageSend newMessageSend() {
603         // '(' ArgumentListopt ')'
604         // the arguments are on the expression stack
605
606         char[] selector = identifierStack[identifierPtr];
607         if (selector != this.assistIdentifier()){
608                 return super.newMessageSend();
609         }       
610         MessageSend messageSend = new SelectionOnMessageSend();
611         int length;
612         if ((length = expressionLengthStack[expressionLengthPtr--]) != 0) {
613                 expressionPtr -= length;
614                 System.arraycopy(
615                         expressionStack, 
616                         expressionPtr + 1, 
617                         messageSend.arguments = new Expression[length], 
618                         0, 
619                         length); 
620         };
621         assistNode = messageSend;
622         if (!diet){
623                 this.restartRecovery    = true; // force to restart in recovery mode
624                 this.lastIgnoredToken = -1;     
625         }
626         
627         this.isOrphanCompletionNode = true;
628         return messageSend;
629 }
630 public CompilationUnitDeclaration parse(ICompilationUnit sourceUnit, CompilationResult compilationResult, int selectionStart, int selectionEnd) {
631
632         this.selectionStart = selectionStart;
633         this.selectionEnd = selectionEnd;       
634         SelectionScanner selectionScanner = (SelectionScanner)this.scanner;
635         selectionScanner.selectionIdentifier = null;
636         selectionScanner.selectionStart = selectionStart;
637         selectionScanner.selectionEnd = selectionEnd;   
638         return this.parse(sourceUnit, compilationResult);
639 }
640 /*
641  * Reset context so as to resume to regular parse loop
642  * If unable to reset for resuming, answers false.
643  *
644  * Move checkpoint location, reset internal stacks and
645  * decide which grammar goal is activated.
646  */
647 protected boolean resumeAfterRecovery() {
648
649         /* if reached assist node inside method body, but still inside nested type,
650                 should continue in diet mode until the end of the method body */
651         if (this.assistNode != null
652                 && !(referenceContext instanceof CompilationUnitDeclaration)){
653                 currentElement.preserveEnclosingBlocks();
654                 if (currentElement.enclosingType() == null){
655                         this.resetStacks();
656                         return false;
657                 }
658         }
659         return super.resumeAfterRecovery();                     
660 }
661
662 public void selectionIdentifierCheck(){
663         if (checkRecoveredType()) return;
664 }
665 public void setAssistIdentifier(char[] assistIdent){
666         ((SelectionScanner)scanner).selectionIdentifier = assistIdent;
667 }
668 /*
669  * Update recovery state based on current parser/scanner state
670  */
671 protected void updateRecoveryState() {
672
673         /* expose parser state to recovery state */
674         currentElement.updateFromParserState();
675
676         /* may be able to retrieve completionNode as an orphan, and then attach it */
677         this.selectionIdentifierCheck();
678         this.attachOrphanCompletionNode();
679         
680         /* check and update recovered state based on current token,
681                 this action is also performed when shifting token after recovery
682                 got activated once. 
683         */
684         this.recoveryTokenCheck();
685 }
686 }