net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/SourceElementParser.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.compiler;
  12
  13 /**
  14  * A source element parser extracts structural and reference information
  15  * from a piece of source.
  16  *
  17  * also see @ISourceElementRequestor
  18  *
  19  * The structural investigation includes:
  20  * - the package statement
  21  * - import statements
  22  * - top-level types: package member, member types (member types of member types...)
  23  * - fields
  24  * - methods
  25  *
  26  * If reference information is requested, then all source constructs are
  27  * investigated and type, field & method references are provided as well.
  28  *
  29  * Any (parsing) problem encountered is also provided.
  30  */
  31
  32 import net.sourceforge.phpdt.internal.compiler.env.*;
  33 import net.sourceforge.phpdt.internal.compiler.impl.*;
  34 import net.sourceforge.phpdt.core.compiler.*;
  35 import net.sourceforge.phpdt.internal.compiler.ast.*;
  36 import net.sourceforge.phpdt.internal.compiler.lookup.*;
  37 import net.sourceforge.phpdt.internal.compiler.parser.*;
  38 import net.sourceforge.phpdt.internal.compiler.problem.*;
  39 import net.sourceforge.phpdt.internal.compiler.util.*;
  40
  41 public class SourceElementParser extends Parser {
  42
  43         ISourceElementRequestor requestor;
  44         private int fieldCount;
  45         private int localIntPtr;
  46         private int lastFieldEndPosition;
  47         private ISourceType sourceType;
  48         private boolean reportReferenceInfo;
  49         private char[][] typeNames;
  50         private char[][] superTypeNames;
  51         private int nestedTypeIndex;
  52         private static final char[] JAVA_LANG_OBJECT = "java.lang.Object".toCharArray(); //$NON-NLS-1$
  53         private NameReference[] unknownRefs;
  54         private int unknownRefsCounter;
  55         private LocalDeclarationVisitor localDeclarationVisitor = null;
  56         private CompilerOptions options;
  57
  58 /**
  59  * An ast visitor that visits local type declarations.
  60  */
  61 public class LocalDeclarationVisitor extends AbstractSyntaxTreeVisitorAdapter {
  62         public boolean visit(
  63                         AnonymousLocalTypeDeclaration anonymousTypeDeclaration,
  64                         BlockScope scope) {
  65                 notifySourceElementRequestor(anonymousTypeDeclaration, sourceType == null);
  66                 return false; // don't visit members as this was done during notifySourceElementRequestor(...)
  67         }
  68         public boolean visit(LocalTypeDeclaration typeDeclaration, BlockScope scope) {
  69                 notifySourceElementRequestor(typeDeclaration, sourceType == null);
  70                 return false; // don't visit members as this was done during notifySourceElementRequestor(...)
  71         }
  72         public boolean visit(MemberTypeDeclaration typeDeclaration, ClassScope scope) {
  73                 notifySourceElementRequestor(typeDeclaration, sourceType == null);
  74                 return false; // don't visit members as this was done during notifySourceElementRequestor(...)
  75         }
  76
  77 }
  78
  79 public SourceElementParser(
  80         final ISourceElementRequestor requestor,
  81         IProblemFactory problemFactory,
  82         CompilerOptions options) {
  83         // we want to notify all syntax error with the acceptProblem API
  84         // To do so, we define the record method of the ProblemReporter
  85         super(new ProblemReporter(
  86                 DefaultErrorHandlingPolicies.exitAfterAllProblems(),
  87                 options,
  88                 problemFactory) {
  89                 public void record(IProblem problem, CompilationResult unitResult, ReferenceContext referenceContext) {
  90                         unitResult.record(problem, referenceContext);
  91                         requestor.acceptProblem(problem);
  92                 }
  93         },
  94         true,
  95         options.assertMode);
  96         this.requestor = requestor;
  97         typeNames = new char[4][];
  98         superTypeNames = new char[4][];
  99         nestedTypeIndex = 0;
 100         this.options = options;
 101 }
 102
 103 /** @deprecated use SourceElementParser(ISourceElementRequestor, IProblemFactory, CompilerOptions) */
 104 public SourceElementParser(
 105         final ISourceElementRequestor requestor,
 106         IProblemFactory problemFactory) {
 107                 this(requestor, problemFactory, new CompilerOptions());
 108 }
 109
 110 public SourceElementParser(
 111         final ISourceElementRequestor requestor,
 112         IProblemFactory problemFactory,
 113         CompilerOptions options,
 114         boolean reportLocalDeclarations) {
 115                 this(requestor, problemFactory, options);
 116                 if (reportLocalDeclarations) {
 117                         this.localDeclarationVisitor = new LocalDeclarationVisitor();
 118                 }
 119 }
 120
 121 public void checkAnnotation() {
 122         int firstCommentIndex = scanner.commentPtr;
 123
 124         super.checkAnnotation();
 125
 126         // modify the modifier source start to point at the first comment
 127         if (firstCommentIndex >= 0) {
 128                 modifiersSourceStart = scanner.commentStarts[0];
 129         }
 130 }
 131
 132 protected void classInstanceCreation(boolean alwaysQualified) {
 133
 134         boolean previousFlag = reportReferenceInfo;
 135         reportReferenceInfo = false; // not to see the type reference reported in super call to getTypeReference(...)
 136         super.classInstanceCreation(alwaysQualified);
 137         reportReferenceInfo = previousFlag;
 138         if (reportReferenceInfo){
 139                 AllocationExpression alloc = (AllocationExpression)expressionStack[expressionPtr];
 140                 TypeReference typeRef = alloc.type;
 141                 requestor.acceptConstructorReference(
 142                         typeRef instanceof SingleTypeReference
 143                                 ? ((SingleTypeReference) typeRef).token
 144                                 : CharOperation.concatWith(alloc.type.getTypeName(), '.'),
 145                         alloc.arguments == null ? 0 : alloc.arguments.length,
 146                         alloc.sourceStart);
 147         }
 148 }
 149 protected void consumeConstructorHeaderName() {
 150         // ConstructorHeaderName ::=  Modifiersopt 'Identifier' '('
 151
 152         /* recovering - might be an empty message send */
 153         if (currentElement != null){
 154                 if (lastIgnoredToken == TokenNamenew){ // was an allocation expression
 155                         lastCheckPoint = scanner.startPosition; // force to restart at this exact position
 156                         restartRecovery = true;
 157                         return;
 158                 }
 159         }
 160         SourceConstructorDeclaration cd = new SourceConstructorDeclaration(this.compilationUnit.compilationResult);
 161
 162         //name -- this is not really revelant but we do .....
 163         cd.selector = identifierStack[identifierPtr];
 164         long selectorSourcePositions = identifierPositionStack[identifierPtr--];
 165         identifierLengthPtr--;
 166
 167         //modifiers
 168         cd.declarationSourceStart = intStack[intPtr--];
 169         cd.modifiers = intStack[intPtr--];
 170
 171         //highlight starts at the selector starts
 172         cd.sourceStart = (int) (selectorSourcePositions >>> 32);
 173         cd.selectorSourceEnd = (int) selectorSourcePositions;
 174         pushOnAstStack(cd);
 175
 176         cd.sourceEnd = lParenPos;
 177         cd.bodyStart = lParenPos+1;
 178         listLength = 0; // initialize listLength before reading parameters/throws
 179
 180         // recovery
 181         if (currentElement != null){
 182                 lastCheckPoint = cd.bodyStart;
 183                 if ((currentElement instanceof RecoveredType && lastIgnoredToken != TokenNameDOT)
 184                         || cd.modifiers != 0){
 185                         currentElement = currentElement.add(cd, 0);
 186                         lastIgnoredToken = -1;
 187                 }
 188         }
 189 }
 190 /**
 191  *
 192  * INTERNAL USE-ONLY
 193  */
 194 protected void consumeExitVariableWithInitialization() {
 195         // ExitVariableWithInitialization ::= $empty
 196         // the scanner is located after the comma or the semi-colon.
 197         // we want to include the comma or the semi-colon
 198         super.consumeExitVariableWithInitialization();
 199         if (isLocalDeclaration() || ((currentToken != TokenNameCOMMA) && (currentToken != TokenNameSEMICOLON)))
 200                 return;
 201         ((SourceFieldDeclaration) astStack[astPtr]).fieldEndPosition = scanner.currentPosition - 1;
 202 }
 203 protected void consumeExitVariableWithoutInitialization() {
 204         // ExitVariableWithoutInitialization ::= $empty
 205         // do nothing by default
 206         if (isLocalDeclaration() || ((currentToken != TokenNameCOMMA) && (currentToken != TokenNameSEMICOLON)))
 207                 return;
 208         ((SourceFieldDeclaration) astStack[astPtr]).fieldEndPosition = scanner.currentPosition - 1;
 209 }
 210 /**
 211  *
 212  * INTERNAL USE-ONLY
 213  */
 214 protected void consumeFieldAccess(boolean isSuperAccess) {
 215         // FieldAccess ::= Primary '.' 'Identifier'
 216         // FieldAccess ::= 'super' '.' 'Identifier'
 217         super.consumeFieldAccess(isSuperAccess);
 218         FieldReference fr = (FieldReference) expressionStack[expressionPtr];
 219         if (reportReferenceInfo) {
 220                 requestor.acceptFieldReference(fr.token, fr.sourceStart);
 221         }
 222 }
 223 protected void consumeMethodHeaderName() {
 224         // MethodHeaderName ::= Modifiersopt Type 'Identifier' '('
 225         SourceMethodDeclaration md = new SourceMethodDeclaration(this.compilationUnit.compilationResult);
 226
 227         //name
 228         md.selector = identifierStack[identifierPtr];
 229         long selectorSourcePositions = identifierPositionStack[identifierPtr--];
 230         identifierLengthPtr--;
 231         //type
 232         md.returnType = getTypeReference(intStack[intPtr--]);
 233         //modifiers
 234         md.declarationSourceStart = intStack[intPtr--];
 235         md.modifiers = intStack[intPtr--];
 236
 237         //highlight starts at selector start
 238         md.sourceStart = (int) (selectorSourcePositions >>> 32);
 239         md.selectorSourceEnd = (int) selectorSourcePositions;
 240         pushOnAstStack(md);
 241         md.sourceEnd = lParenPos;
 242         md.bodyStart = lParenPos+1;
 243         listLength = 0; // initialize listLength before reading parameters/throws
 244
 245         // recovery
 246         if (currentElement != null){
 247                 if (currentElement instanceof RecoveredType
 248                         //|| md.modifiers != 0
 249                         || (scanner.getLineNumber(md.returnType.sourceStart)
 250                                         == scanner.getLineNumber(md.sourceStart))){
 251                         lastCheckPoint = md.bodyStart;
 252                         currentElement = currentElement.add(md, 0);
 253                         lastIgnoredToken = -1;
 254                 } else {
 255                         lastCheckPoint = md.sourceStart;
 256                         restartRecovery = true;
 257                 }
 258         }
 259 }
 260 /**
 261  *
 262  * INTERNAL USE-ONLY
 263  */
 264 protected void consumeMethodInvocationName() {
 265         // MethodInvocation ::= Name '(' ArgumentListopt ')'
 266
 267         // when the name is only an identifier...we have a message send to "this" (implicit)
 268         super.consumeMethodInvocationName();
 269         MessageSend messageSend = (MessageSend) expressionStack[expressionPtr];
 270         Expression[] args = messageSend.arguments;
 271         if (reportReferenceInfo) {
 272                 requestor.acceptMethodReference(
 273                         messageSend.selector,
 274                         args == null ? 0 : args.length,
 275                         (int)(messageSend.nameSourcePosition >>> 32));
 276         }
 277 }
 278 /**
 279  *
 280  * INTERNAL USE-ONLY
 281  */
 282 protected void consumeMethodInvocationPrimary() {
 283         super.consumeMethodInvocationPrimary();
 284         MessageSend messageSend = (MessageSend) expressionStack[expressionPtr];
 285         Expression[] args = messageSend.arguments;
 286         if (reportReferenceInfo) {
 287                 requestor.acceptMethodReference(
 288                         messageSend.selector,
 289                         args == null ? 0 : args.length,
 290                         (int)(messageSend.nameSourcePosition >>> 32));
 291         }
 292 }
 293 /**
 294  *
 295  * INTERNAL USE-ONLY
 296  */
 297 protected void consumeMethodInvocationSuper() {
 298         // MethodInvocation ::= 'super' '.' 'Identifier' '(' ArgumentListopt ')'
 299         super.consumeMethodInvocationSuper();
 300         MessageSend messageSend = (MessageSend) expressionStack[expressionPtr];
 301         Expression[] args = messageSend.arguments;
 302         if (reportReferenceInfo) {
 303                 requestor.acceptMethodReference(
 304                         messageSend.selector,
 305                         args == null ? 0 : args.length,
 306                         (int)(messageSend.nameSourcePosition >>> 32));
 307         }
 308 }
 309 protected void consumeSingleTypeImportDeclarationName() {
 310         // SingleTypeImportDeclarationName ::= 'import' Name
 311         /* push an ImportRef build from the last name
 312         stored in the identifier stack. */
 313
 314         super.consumeSingleTypeImportDeclarationName();
 315         ImportReference impt = (ImportReference)astStack[astPtr];
 316         if (reportReferenceInfo) {
 317                 requestor.acceptTypeReference(impt.tokens, impt.sourceStart, impt.sourceEnd);
 318         }
 319 }
 320 protected void consumeTypeImportOnDemandDeclarationName() {
 321         // TypeImportOnDemandDeclarationName ::= 'import' Name '.' '*'
 322         /* push an ImportRef build from the last name
 323         stored in the identifier stack. */
 324
 325         super.consumeTypeImportOnDemandDeclarationName();
 326         ImportReference impt = (ImportReference)astStack[astPtr];
 327         if (reportReferenceInfo) {
 328                 requestor.acceptUnknownReference(impt.tokens, impt.sourceStart, impt.sourceEnd);
 329         }
 330 }
 331 protected FieldDeclaration createFieldDeclaration(Expression initialization, char[] name, int sourceStart, int sourceEnd) {
 332         return new SourceFieldDeclaration(null, name, sourceStart, sourceEnd);
 333 }
 334 protected CompilationUnitDeclaration endParse(int act) {
 335         if (sourceType != null) {
 336                 if (sourceType.isInterface()) {
 337                         consumeInterfaceDeclaration();
 338                 } else {
 339                         consumeClassDeclaration();
 340                 }
 341         }
 342         if (compilationUnit != null) {
 343                 CompilationUnitDeclaration result = super.endParse(act);
 344                 return result;
 345         } else {
 346                 return null;
 347         }
 348 }
 349 /*
 350  * Flush annotations defined prior to a given positions.
 351  *
 352  * Note: annotations are stacked in syntactical order
 353  *
 354  * Either answer given <position>, or the end position of a comment line
 355  * immediately following the <position> (same line)
 356  *
 357  * e.g.
 358  * void foo(){
 359  * } // end of method foo
 360  */
 361
 362 public int flushAnnotationsDefinedPriorTo(int position) {
 363
 364         return lastFieldEndPosition = super.flushAnnotationsDefinedPriorTo(position);
 365 }
 366 public TypeReference getTypeReference(int dim) {
 367         /* build a Reference on a variable that may be qualified or not
 368          * This variable is a type reference and dim will be its dimensions
 369          */
 370         int length;
 371         if ((length = identifierLengthStack[identifierLengthPtr--]) == 1) {
 372                 // single variable reference
 373                 if (dim == 0) {
 374                         SingleTypeReference ref =
 375                                 new SingleTypeReference(
 376                                         identifierStack[identifierPtr],
 377                                         identifierPositionStack[identifierPtr--]);
 378                         if (reportReferenceInfo) {
 379                                 requestor.acceptTypeReference(ref.token, ref.sourceStart);
 380                         }
 381                         return ref;
 382                 } else {
 383                         ArrayTypeReference ref =
 384                                 new ArrayTypeReference(
 385                                         identifierStack[identifierPtr],
 386                                         dim,
 387                                         identifierPositionStack[identifierPtr--]);
 388                         ref.sourceEnd = endPosition;
 389                         if (reportReferenceInfo) {
 390                                 requestor.acceptTypeReference(ref.token, ref.sourceStart);
 391                         }
 392                         return ref;
 393                 }
 394         } else {
 395                 if (length < 0) { //flag for precompiled type reference on base types
 396                         TypeReference ref = TypeReference.baseTypeReference(-length, dim);
 397                         ref.sourceStart = intStack[intPtr--];
 398                         if (dim == 0) {
 399                                 ref.sourceEnd = intStack[intPtr--];
 400                         } else {
 401                                 intPtr--; // no need to use this position as it is an array
 402                                 ref.sourceEnd = endPosition;
 403                         }
 404                         if (reportReferenceInfo){
 405                                         requestor.acceptTypeReference(ref.getTypeName(), ref.sourceStart, ref.sourceEnd);
 406                         }
 407                         return ref;
 408                 } else { //Qualified variable reference
 409                         char[][] tokens = new char[length][];
 410                         identifierPtr -= length;
 411                         long[] positions = new long[length];
 412                         System.arraycopy(identifierStack, identifierPtr + 1, tokens, 0, length);
 413                         System.arraycopy(
 414                                 identifierPositionStack,
 415                                 identifierPtr + 1,
 416                                 positions,
 417                                 0,
 418                                 length);
 419                         if (dim == 0) {
 420                                 QualifiedTypeReference ref = new QualifiedTypeReference(tokens, positions);
 421                                 if (reportReferenceInfo) {
 422                                         requestor.acceptTypeReference(ref.tokens, ref.sourceStart, ref.sourceEnd);
 423                                 }
 424                                 return ref;
 425                         } else {
 426                                 ArrayQualifiedTypeReference ref =
 427                                         new ArrayQualifiedTypeReference(tokens, dim, positions);
 428                                 ref.sourceEnd = endPosition;
 429                                 if (reportReferenceInfo) {
 430                                         requestor.acceptTypeReference(ref.tokens, ref.sourceStart, ref.sourceEnd);
 431                                 }
 432                                 return ref;
 433                         }
 434                 }
 435         }
 436 }
 437 public NameReference getUnspecifiedReference() {
 438         /* build a (unspecified) NameReference which may be qualified*/
 439
 440         int length;
 441         if ((length = identifierLengthStack[identifierLengthPtr--]) == 1) {
 442                 // single variable reference
 443                 SingleNameReference ref =
 444                         new SingleNameReference(
 445                                 identifierStack[identifierPtr],
 446                                 identifierPositionStack[identifierPtr--]);
 447                 if (reportReferenceInfo) {
 448                         this.addUnknownRef(ref);
 449                 }
 450                 return ref;
 451         } else {
 452                 //Qualified variable reference
 453                 char[][] tokens = new char[length][];
 454                 identifierPtr -= length;
 455                 System.arraycopy(identifierStack, identifierPtr + 1, tokens, 0, length);
 456                 QualifiedNameReference ref =
 457                         new QualifiedNameReference(
 458                                 tokens,
 459                                 (int) (identifierPositionStack[identifierPtr + 1] >> 32), // sourceStart
 460                                 (int) identifierPositionStack[identifierPtr + length]); // sourceEnd
 461                 if (reportReferenceInfo) {
 462                         this.addUnknownRef(ref);
 463                 }
 464                 return ref;
 465         }
 466 }
 467 public NameReference getUnspecifiedReferenceOptimized() {
 468         /* build a (unspecified) NameReference which may be qualified
 469         The optimization occurs for qualified reference while we are
 470         certain in this case the last item of the qualified name is
 471         a field access. This optimization is IMPORTANT while it results
 472         that when a NameReference is build, the type checker should always
 473         look for that it is not a type reference */
 474
 475         int length;
 476         if ((length = identifierLengthStack[identifierLengthPtr--]) == 1) {
 477                 // single variable reference
 478                 SingleNameReference ref =
 479                         new SingleNameReference(
 480                                 identifierStack[identifierPtr],
 481                                 identifierPositionStack[identifierPtr--]);
 482                 ref.bits &= ~AstNode.RestrictiveFlagMASK;
 483                 ref.bits |= LOCAL | FIELD;
 484                 if (reportReferenceInfo) {
 485                         this.addUnknownRef(ref);
 486                 }
 487                 return ref;
 488         }
 489
 490         //Qualified-variable-reference
 491         //In fact it is variable-reference DOT field-ref , but it would result in a type
 492         //conflict tha can be only reduce by making a superclass (or inetrface ) between
 493         //nameReference and FiledReference or putting FieldReference under NameReference
 494         //or else..........This optimisation is not really relevant so just leave as it is
 495
 496         char[][] tokens = new char[length][];
 497         identifierPtr -= length;
 498         System.arraycopy(identifierStack, identifierPtr + 1, tokens, 0, length);
 499         QualifiedNameReference ref =
 500                 new QualifiedNameReference(
 501                         tokens,
 502                         (int) (identifierPositionStack[identifierPtr + 1] >> 32),
 503         // sourceStart
 504          (int) identifierPositionStack[identifierPtr + length]); // sourceEnd
 505         ref.bits &= ~AstNode.RestrictiveFlagMASK;
 506         ref.bits |= LOCAL | FIELD;
 507         if (reportReferenceInfo) {
 508                 this.addUnknownRef(ref);
 509         }
 510         return ref;
 511 }
 512 /**
 513  *
 514  * INTERNAL USE-ONLY
 515  */
 516 private boolean isLocalDeclaration() {
 517         int nestedDepth = nestedType;
 518         while (nestedDepth >= 0) {
 519                 if (nestedMethod[nestedDepth] != 0) {
 520                         return true;
 521                 }
 522                 nestedDepth--;
 523         }
 524         return false;
 525 }
 526 /*
 527  * Update the bodyStart of the corresponding parse node
 528  */
 529 public void notifySourceElementRequestor(CompilationUnitDeclaration parsedUnit) {
 530         if (parsedUnit == null) {
 531                 // when we parse a single type member declaration the compilation unit is null, but we still
 532                 // want to be able to notify the requestor on the created ast node
 533                 if (astStack[0] instanceof AbstractMethodDeclaration) {
 534                         notifySourceElementRequestor((AbstractMethodDeclaration) astStack[0]);
 535                         return;
 536                 }
 537                 return;
 538         }
 539         // range check
 540         boolean isInRange =
 541                                 scanner.initialPosition <= parsedUnit.sourceStart
 542                                 && scanner.eofPosition >= parsedUnit.sourceEnd;
 543
 544         if (reportReferenceInfo) {
 545                 notifyAllUnknownReferences();
 546         }
 547         // collect the top level ast nodes
 548         int length = 0;
 549         AstNode[] nodes = null;
 550         if (sourceType == null){
 551                 if (isInRange) {
 552                         requestor.enterCompilationUnit();
 553                 }
 554                 ImportReference currentPackage = parsedUnit.currentPackage;
 555                 ImportReference[] imports = parsedUnit.imports;
 556                 TypeDeclaration[] types = parsedUnit.types;
 557                 length =
 558                         (currentPackage == null ? 0 : 1)
 559                         + (imports == null ? 0 : imports.length)
 560                         + (types == null ? 0 : types.length);
 561                 nodes = new AstNode[length];
 562                 int index = 0;
 563                 if (currentPackage != null) {
 564                         nodes[index++] = currentPackage;
 565                 }
 566                 if (imports != null) {
 567                         for (int i = 0, max = imports.length; i < max; i++) {
 568                                 nodes[index++] = imports[i];
 569                         }
 570                 }
 571                 if (types != null) {
 572                         for (int i = 0, max = types.length; i < max; i++) {
 573                                 nodes[index++] = types[i];
 574                         }
 575                 }
 576         } else {
 577                 TypeDeclaration[] types = parsedUnit.types;
 578                 if (types != null) {
 579                         length = types.length;
 580                         nodes = new AstNode[length];
 581                         for (int i = 0, max = types.length; i < max; i++) {
 582                                 nodes[i] = types[i];
 583                         }
 584                 }
 585         }
 586
 587         // notify the nodes in the syntactical order
 588         if (nodes != null && length > 0) {
 589                 quickSort(nodes, 0, length-1);
 590                 for (int i=0;i<length;i++) {
 591                         AstNode node = nodes[i];
 592                         if (node instanceof ImportReference) {
 593                                 ImportReference importRef = (ImportReference)node;
 594                                 if (node == parsedUnit.currentPackage) {
 595                                         notifySourceElementRequestor(importRef, true);
 596                                 } else {
 597                                         notifySourceElementRequestor(importRef, false);
 598                                 }
 599                         } else { // instanceof TypeDeclaration
 600                                 notifySourceElementRequestor((TypeDeclaration)node, sourceType == null);
 601                         }
 602                 }
 603         }
 604
 605         if (sourceType == null){
 606                 if (isInRange) {
 607                         requestor.exitCompilationUnit(parsedUnit.sourceEnd);
 608                 }
 609         }
 610 }
 611
 612 private void notifyAllUnknownReferences() {
 613         for (int i = 0, max = this.unknownRefsCounter; i < max; i++) {
 614                 NameReference nameRef = this.unknownRefs[i];
 615                 if ((nameRef.bits & BindingIds.VARIABLE) != 0) {
 616                         if ((nameRef.bits & BindingIds.TYPE) == 0) {
 617                                 // variable but not type
 618                                 if (nameRef instanceof SingleNameReference) {
 619                                         // local var or field
 620                                         requestor.acceptUnknownReference(((SingleNameReference) nameRef).token, nameRef.sourceStart);
 621                                 } else {
 622                                         // QualifiedNameReference
 623                                         // The last token is a field reference and the previous tokens are a type/variable references
 624                                         char[][] tokens = ((QualifiedNameReference) nameRef).tokens;
 625                                         int tokensLength = tokens.length;
 626                                         requestor.acceptFieldReference(tokens[tokensLength - 1], nameRef.sourceEnd - tokens[tokensLength - 1].length + 1);
 627                                         char[][] typeRef = new char[tokensLength - 1][];
 628                                         System.arraycopy(tokens, 0, typeRef, 0, tokensLength - 1);
 629                                         requestor.acceptUnknownReference(typeRef, nameRef.sourceStart, nameRef.sourceEnd - tokens[tokensLength - 1].length);
 630                                 }
 631                         } else {
 632                                 // variable or type
 633                                 if (nameRef instanceof SingleNameReference) {
 634                                         requestor.acceptUnknownReference(((SingleNameReference) nameRef).token, nameRef.sourceStart);
 635                                 } else {
 636                                         //QualifiedNameReference
 637                                         requestor.acceptUnknownReference(((QualifiedNameReference) nameRef).tokens, nameRef.sourceStart, nameRef.sourceEnd);
 638                                 }
 639                         }
 640                 } else if ((nameRef.bits & BindingIds.TYPE) != 0) {
 641                         if (nameRef instanceof SingleNameReference) {
 642                                 requestor.acceptTypeReference(((SingleNameReference) nameRef).token, nameRef.sourceStart);
 643                         } else {
 644                                 // it is a QualifiedNameReference
 645                                 requestor.acceptTypeReference(((QualifiedNameReference) nameRef).tokens, nameRef.sourceStart, nameRef.sourceEnd);
 646                         }
 647                 }
 648         }
 649 }
 650 /*
 651  * Update the bodyStart of the corresponding parse node
 652  */
 653 public void notifySourceElementRequestor(AbstractMethodDeclaration methodDeclaration) {
 654
 655         // range check
 656         boolean isInRange =
 657                                 scanner.initialPosition <= methodDeclaration.declarationSourceStart
 658                                 && scanner.eofPosition >= methodDeclaration.declarationSourceEnd;
 659
 660         if (methodDeclaration.isClinit()) {
 661                 this.visitIfNeeded(methodDeclaration);
 662                 return;
 663         }
 664
 665         if (methodDeclaration.isDefaultConstructor()) {
 666                 if (reportReferenceInfo) {
 667                         ConstructorDeclaration constructorDeclaration = (ConstructorDeclaration) methodDeclaration;
 668                         ExplicitConstructorCall constructorCall = constructorDeclaration.constructorCall;
 669                         if (constructorCall != null) {
 670                                 switch(constructorCall.accessMode) {
 671                                         case ExplicitConstructorCall.This :
 672                                                 requestor.acceptConstructorReference(
 673                                                         typeNames[nestedTypeIndex-1],
 674                                                         constructorCall.arguments == null ? 0 : constructorCall.arguments.length,
 675                                                         constructorCall.sourceStart);
 676                                                 break;
 677                                         case ExplicitConstructorCall.Super :
 678                                         case ExplicitConstructorCall.ImplicitSuper :
 679                                                 requestor.acceptConstructorReference(
 680                                                         superTypeNames[nestedTypeIndex-1],
 681                                                         constructorCall.arguments == null ? 0 : constructorCall.arguments.length,
 682                                                         constructorCall.sourceStart);
 683                                                 break;
 684                                 }
 685                         }
 686                 }
 687                 return;
 688         }
 689         char[][] argumentTypes = null;
 690         char[][] argumentNames = null;
 691         Argument[] arguments = methodDeclaration.arguments;
 692         if (arguments != null) {
 693                 int argumentLength = arguments.length;
 694                 argumentTypes = new char[argumentLength][];
 695                 argumentNames = new char[argumentLength][];
 696                 for (int i = 0; i < argumentLength; i++) {
 697                         argumentTypes[i] = returnTypeName(arguments[i].type);
 698                         argumentNames[i] = arguments[i].name;
 699                 }
 700         }
 701         char[][] thrownExceptionTypes = null;
 702         TypeReference[] thrownExceptions = methodDeclaration.thrownExceptions;
 703         if (thrownExceptions != null) {
 704                 int thrownExceptionLength = thrownExceptions.length;
 705                 thrownExceptionTypes = new char[thrownExceptionLength][];
 706                 for (int i = 0; i < thrownExceptionLength; i++) {
 707                         thrownExceptionTypes[i] =
 708                                 CharOperation.concatWith(thrownExceptions[i].getTypeName(), '.');
 709                 }
 710         }
 711         // by default no selector end position
 712         int selectorSourceEnd = -1;
 713         if (methodDeclaration.isConstructor()) {
 714                 if (methodDeclaration instanceof SourceConstructorDeclaration) {
 715                         selectorSourceEnd =
 716                                 ((SourceConstructorDeclaration) methodDeclaration).selectorSourceEnd;
 717                 }
 718                 if (isInRange){
 719                         requestor.enterConstructor(
 720                                 methodDeclaration.declarationSourceStart,
 721                                 methodDeclaration.modifiers,
 722                                 methodDeclaration.selector,
 723                                 methodDeclaration.sourceStart,
 724                                 selectorSourceEnd,
 725                                 argumentTypes,
 726                                 argumentNames,
 727                                 thrownExceptionTypes);
 728                 }
 729                 if (reportReferenceInfo) {
 730                         ConstructorDeclaration constructorDeclaration = (ConstructorDeclaration) methodDeclaration;
 731                         ExplicitConstructorCall constructorCall = constructorDeclaration.constructorCall;
 732                         if (constructorCall != null) {
 733                                 switch(constructorCall.accessMode) {
 734                                         case ExplicitConstructorCall.This :
 735                                                 requestor.acceptConstructorReference(
 736                                                         typeNames[nestedTypeIndex-1],
 737                                                         constructorCall.arguments == null ? 0 : constructorCall.arguments.length,
 738                                                         constructorCall.sourceStart);
 739                                                 break;
 740                                         case ExplicitConstructorCall.Super :
 741                                         case ExplicitConstructorCall.ImplicitSuper :
 742                                                 requestor.acceptConstructorReference(
 743                                                         superTypeNames[nestedTypeIndex-1],
 744                                                         constructorCall.arguments == null ? 0 : constructorCall.arguments.length,
 745                                                         constructorCall.sourceStart);
 746                                                 break;
 747                                 }
 748                         }
 749                 }
 750                 this.visitIfNeeded(methodDeclaration);
 751                 if (isInRange){
 752                         requestor.exitConstructor(methodDeclaration.declarationSourceEnd);
 753                 }
 754                 return;
 755         }
 756         if (methodDeclaration instanceof SourceMethodDeclaration) {
 757                 selectorSourceEnd =
 758                         ((SourceMethodDeclaration) methodDeclaration).selectorSourceEnd;
 759         }
 760         if (isInRange){
 761                 requestor.enterMethod(
 762                         methodDeclaration.declarationSourceStart,
 763                         methodDeclaration.modifiers & AccJustFlag,
 764                         returnTypeName(((MethodDeclaration) methodDeclaration).returnType),
 765                         methodDeclaration.selector,
 766                         methodDeclaration.sourceStart,
 767                         selectorSourceEnd,
 768                         argumentTypes,
 769                         argumentNames,
 770                         thrownExceptionTypes);
 771         }
 772         this.visitIfNeeded(methodDeclaration);
 773
 774         if (isInRange){
 775                 requestor.exitMethod(methodDeclaration.declarationSourceEnd);
 776         }
 777 }
 778 /*
 779 * Update the bodyStart of the corresponding parse node
 780 */
 781 public void notifySourceElementRequestor(FieldDeclaration fieldDeclaration) {
 782
 783         // range check
 784         boolean isInRange =
 785                                 scanner.initialPosition <= fieldDeclaration.declarationSourceStart
 786                                 && scanner.eofPosition >= fieldDeclaration.declarationSourceEnd;
 787
 788         if (fieldDeclaration.isField()) {
 789                 int fieldEndPosition = fieldDeclaration.declarationSourceEnd;
 790                 if (fieldDeclaration instanceof SourceFieldDeclaration) {
 791                         fieldEndPosition = ((SourceFieldDeclaration) fieldDeclaration).fieldEndPosition;
 792                         if (fieldEndPosition == 0) {
 793                                 // use the declaration source end by default
 794                                 fieldEndPosition = fieldDeclaration.declarationSourceEnd;
 795                         }
 796                 }
 797                 if (isInRange) {
 798                         requestor.enterField(
 799                                 fieldDeclaration.declarationSourceStart,
 800                                 fieldDeclaration.modifiers & AccJustFlag,
 801                                 returnTypeName(fieldDeclaration.type),
 802                                 fieldDeclaration.name,
 803                                 fieldDeclaration.sourceStart,
 804                                 fieldDeclaration.sourceEnd);
 805                 }
 806                 this.visitIfNeeded(fieldDeclaration);
 807                 if (isInRange){
 808                         requestor.exitField(fieldEndPosition);
 809                 }
 810
 811         } else {
 812                 if (isInRange){
 813                         requestor.enterInitializer(
 814                                 fieldDeclaration.declarationSourceStart,
 815                                 fieldDeclaration.modifiers);
 816                 }
 817                 this.visitIfNeeded((Initializer)fieldDeclaration);
 818                 if (isInRange){
 819                         requestor.exitInitializer(fieldDeclaration.declarationSourceEnd);
 820                 }
 821         }
 822 }
 823 public void notifySourceElementRequestor(
 824         ImportReference importReference,
 825         boolean isPackage) {
 826         if (isPackage) {
 827                 requestor.acceptPackage(
 828                         importReference.declarationSourceStart,
 829                         importReference.declarationSourceEnd,
 830                         CharOperation.concatWith(importReference.getImportName(), '.'));
 831         } else {
 832                 requestor.acceptImport(
 833                         importReference.declarationSourceStart,
 834                         importReference.declarationSourceEnd,
 835                         CharOperation.concatWith(importReference.getImportName(), '.'),
 836                         importReference.onDemand);
 837         }
 838 }
 839 public void notifySourceElementRequestor(TypeDeclaration typeDeclaration, boolean notifyTypePresence) {
 840
 841         // range check
 842         boolean isInRange =
 843                                 scanner.initialPosition <= typeDeclaration.declarationSourceStart
 844                                 && scanner.eofPosition >= typeDeclaration.declarationSourceEnd;
 845
 846         FieldDeclaration[] fields = typeDeclaration.fields;
 847         AbstractMethodDeclaration[] methods = typeDeclaration.methods;
 848         MemberTypeDeclaration[] memberTypes = typeDeclaration.memberTypes;
 849         int fieldCount = fields == null ? 0 : fields.length;
 850         int methodCount = methods == null ? 0 : methods.length;
 851         int memberTypeCount = memberTypes == null ? 0 : memberTypes.length;
 852         int fieldIndex = 0;
 853         int methodIndex = 0;
 854         int memberTypeIndex = 0;
 855         boolean isInterface = typeDeclaration.isInterface();
 856
 857         if (notifyTypePresence){
 858                 char[][] interfaceNames = null;
 859                 int superInterfacesLength = 0;
 860                 TypeReference[] superInterfaces = typeDeclaration.superInterfaces;
 861                 if (superInterfaces != null) {
 862                         superInterfacesLength = superInterfaces.length;
 863                         interfaceNames = new char[superInterfacesLength][];
 864                 } else {
 865                         if (typeDeclaration instanceof AnonymousLocalTypeDeclaration) {
 866                                 // see PR 3442
 867                                 QualifiedAllocationExpression alloc = ((AnonymousLocalTypeDeclaration)typeDeclaration).allocation;
 868                                 if (alloc != null && alloc.type != null) {
 869                                         superInterfaces = new TypeReference[] { ((AnonymousLocalTypeDeclaration)typeDeclaration).allocation.type};
 870                                         superInterfacesLength = 1;
 871                                         interfaceNames = new char[1][];
 872                                 }
 873                         }
 874                 }
 875                 if (superInterfaces != null) {
 876                         for (int i = 0; i < superInterfacesLength; i++) {
 877                                 interfaceNames[i] =
 878                                         CharOperation.concatWith(superInterfaces[i].getTypeName(), '.');
 879                         }
 880                 }
 881                 if (isInterface) {
 882                         if (isInRange){
 883                                 requestor.enterInterface(
 884                                         typeDeclaration.declarationSourceStart,
 885                                         typeDeclaration.modifiers & AccJustFlag,
 886                                         typeDeclaration.name,
 887                                         typeDeclaration.sourceStart,
 888                                         typeDeclaration.sourceEnd,
 889                                         interfaceNames);
 890                         }
 891                         if (nestedTypeIndex == typeNames.length) {
 892                                 // need a resize
 893                                 System.arraycopy(typeNames, 0, (typeNames = new char[nestedTypeIndex * 2][]), 0, nestedTypeIndex);
 894                                 System.arraycopy(superTypeNames, 0, (superTypeNames = new char[nestedTypeIndex * 2][]), 0, nestedTypeIndex);
 895                         }
 896                         typeNames[nestedTypeIndex] = typeDeclaration.name;
 897                         superTypeNames[nestedTypeIndex++] = JAVA_LANG_OBJECT;
 898                 } else {
 899                         TypeReference superclass = typeDeclaration.superclass;
 900                         if (superclass == null) {
 901                                 if (isInRange){
 902                                         requestor.enterClass(
 903                                                 typeDeclaration.declarationSourceStart,
 904                                                 typeDeclaration.modifiers,
 905                                                 typeDeclaration.name,
 906                                                 typeDeclaration.sourceStart,
 907                                                 typeDeclaration.sourceEnd,
 908                                                 null,
 909                                                 interfaceNames);
 910                                 }
 911                         } else {
 912                                 if (isInRange){
 913                                         requestor.enterClass(
 914                                                 typeDeclaration.declarationSourceStart,
 915                                                 typeDeclaration.modifiers,
 916                                                 typeDeclaration.name,
 917                                                 typeDeclaration.sourceStart,
 918                                                 typeDeclaration.sourceEnd,
 919                                                 CharOperation.concatWith(superclass.getTypeName(), '.'),
 920                                                 interfaceNames);
 921                                 }
 922                         }
 923                         if (nestedTypeIndex == typeNames.length) {
 924                                 // need a resize
 925                                 System.arraycopy(typeNames, 0, (typeNames = new char[nestedTypeIndex * 2][]), 0, nestedTypeIndex);
 926                                 System.arraycopy(superTypeNames, 0, (superTypeNames = new char[nestedTypeIndex * 2][]), 0, nestedTypeIndex);
 927                         }
 928                         typeNames[nestedTypeIndex] = typeDeclaration.name;
 929                         superTypeNames[nestedTypeIndex++] = superclass == null ? JAVA_LANG_OBJECT : CharOperation.concatWith(superclass.getTypeName(), '.');
 930                 }
 931         }
 932         while ((fieldIndex < fieldCount)
 933                 || (memberTypeIndex < memberTypeCount)
 934                 || (methodIndex < methodCount)) {
 935                 FieldDeclaration nextFieldDeclaration = null;
 936                 AbstractMethodDeclaration nextMethodDeclaration = null;
 937                 TypeDeclaration nextMemberDeclaration = null;
 938
 939                 int position = Integer.MAX_VALUE;
 940                 int nextDeclarationType = -1;
 941                 if (fieldIndex < fieldCount) {
 942                         nextFieldDeclaration = fields[fieldIndex];
 943                         if (nextFieldDeclaration.declarationSourceStart < position) {
 944                                 position = nextFieldDeclaration.declarationSourceStart;
 945                                 nextDeclarationType = 0; // FIELD
 946                         }
 947                 }
 948                 if (methodIndex < methodCount) {
 949                         nextMethodDeclaration = methods[methodIndex];
 950                         if (nextMethodDeclaration.declarationSourceStart < position) {
 951                                 position = nextMethodDeclaration.declarationSourceStart;
 952                                 nextDeclarationType = 1; // METHOD
 953                         }
 954                 }
 955                 if (memberTypeIndex < memberTypeCount) {
 956                         nextMemberDeclaration = memberTypes[memberTypeIndex];
 957                         if (nextMemberDeclaration.declarationSourceStart < position) {
 958                                 position = nextMemberDeclaration.declarationSourceStart;
 959                                 nextDeclarationType = 2; // MEMBER
 960                         }
 961                 }
 962                 switch (nextDeclarationType) {
 963                         case 0 :
 964                                 fieldIndex++;
 965                                 notifySourceElementRequestor(nextFieldDeclaration);
 966                                 break;
 967                         case 1 :
 968                                 methodIndex++;
 969                                 notifySourceElementRequestor(nextMethodDeclaration);
 970                                 break;
 971                         case 2 :
 972                                 memberTypeIndex++;
 973                                 notifySourceElementRequestor(nextMemberDeclaration, true);
 974                 }
 975         }
 976         if (notifyTypePresence){
 977                 if (isInRange){
 978                         if (isInterface) {
 979                                 requestor.exitInterface(typeDeclaration.declarationSourceEnd);
 980                         } else {
 981                                 requestor.exitClass(typeDeclaration.declarationSourceEnd);
 982                         }
 983                 }
 984                 nestedTypeIndex--;
 985         }
 986 }
 987 public void parseCompilationUnit(
 988         ICompilationUnit unit,
 989         int start,
 990         int end,
 991         boolean needReferenceInfo) {
 992
 993         reportReferenceInfo = needReferenceInfo;
 994         boolean old = diet;
 995         if (needReferenceInfo) {
 996                 unknownRefs = new NameReference[10];
 997                 unknownRefsCounter = 0;
 998         }
 999         try {
1000                 diet = true;
1001                 CompilationResult compilationUnitResult = new CompilationResult(unit, 0, 0, this.options.maxProblemsPerUnit);
1002                 CompilationUnitDeclaration parsedUnit = parse(unit, compilationUnitResult, start, end);
1003                 if (needReferenceInfo){
1004                         diet = false;
1005                         this.getMethodBodies(parsedUnit);
1006                 }
1007                 this.scanner.resetTo(start, end);
1008                 notifySourceElementRequestor(parsedUnit);
1009         } catch (AbortCompilation e) {
1010         } finally {
1011                 if (scanner.recordLineSeparator) {
1012                         requestor.acceptLineSeparatorPositions(scanner.getLineEnds());
1013                 }
1014                 diet = old;
1015         }
1016 }
1017 public void parseCompilationUnit(
1018         ICompilationUnit unit,
1019         boolean needReferenceInfo) {
1020         boolean old = diet;
1021         if (needReferenceInfo) {
1022                 unknownRefs = new NameReference[10];
1023                 unknownRefsCounter = 0;
1024         }
1025
1026         try {
1027 /*              diet = !needReferenceInfo;
1028                 reportReferenceInfo = needReferenceInfo;
1029                 CompilationResult compilationUnitResult = new CompilationResult(unit, 0, 0);
1030                 parse(unit, compilationUnitResult);
1031 */              diet = true;
1032                 reportReferenceInfo = needReferenceInfo;
1033                 CompilationResult compilationUnitResult = new CompilationResult(unit, 0, 0, this.options.maxProblemsPerUnit);
1034                 CompilationUnitDeclaration parsedUnit = parse(unit, compilationUnitResult);
1035                 int initialStart = this.scanner.initialPosition;
1036                 int initialEnd = this.scanner.eofPosition;
1037                 if (needReferenceInfo){
1038                         diet = false;
1039                         this.getMethodBodies(parsedUnit);
1040                 }
1041                 this.scanner.resetTo(initialStart, initialEnd);
1042                 notifySourceElementRequestor(parsedUnit);
1043         } catch (AbortCompilation e) {
1044         } finally {
1045                 if (scanner.recordLineSeparator) {
1046                         requestor.acceptLineSeparatorPositions(scanner.getLineEnds());
1047                 }
1048                 diet = old;
1049         }
1050 }
1051 public void parseTypeMemberDeclarations(
1052         ISourceType sourceType,
1053         ICompilationUnit sourceUnit,
1054         int start,
1055         int end,
1056         boolean needReferenceInfo) {
1057         boolean old = diet;
1058         if (needReferenceInfo) {
1059                 unknownRefs = new NameReference[10];
1060                 unknownRefsCounter = 0;
1061         }
1062
1063         try {
1064                 diet = !needReferenceInfo;
1065                 reportReferenceInfo = needReferenceInfo;
1066                 CompilationResult compilationUnitResult =
1067                         new CompilationResult(sourceUnit, 0, 0, this.options.maxProblemsPerUnit);
1068                 CompilationUnitDeclaration unit =
1069                         SourceTypeConverter.buildCompilationUnit(
1070                                 new ISourceType[]{sourceType},
1071                                 false,
1072                                 false,
1073                                 problemReporter(),
1074                                 compilationUnitResult);
1075                 if ((unit == null) || (unit.types == null) || (unit.types.length != 1))
1076                         return;
1077                 this.sourceType = sourceType;
1078                 try {
1079                         /* automaton initialization */
1080                         initialize();
1081                         goForClassBodyDeclarations();
1082                         /* scanner initialization */
1083                         scanner.setSource(sourceUnit.getContents());
1084                         scanner.resetTo(start, end);
1085                         /* unit creation */
1086                         referenceContext = compilationUnit = unit;
1087                         /* initialize the astStacl */
1088                         // the compilationUnitDeclaration should contain exactly one type
1089                         pushOnAstStack(unit.types[0]);
1090                         /* run automaton */
1091                         parse();
1092                         notifySourceElementRequestor(unit);
1093                 } finally {
1094                         unit = compilationUnit;
1095                         compilationUnit = null; // reset parser
1096                 }
1097         } catch (AbortCompilation e) {
1098         } finally {
1099                 if (scanner.recordLineSeparator) {
1100                         requestor.acceptLineSeparatorPositions(scanner.getLineEnds());
1101                 }
1102                 diet = old;
1103         }
1104 }
1105
1106 public void parseTypeMemberDeclarations(
1107         char[] contents,
1108         int start,
1109         int end) {
1110
1111         boolean old = diet;
1112
1113         try {
1114                 diet = true;
1115
1116                 /* automaton initialization */
1117                 initialize();
1118                 goForClassBodyDeclarations();
1119                 /* scanner initialization */
1120                 scanner.setSource(contents);
1121                 scanner.recordLineSeparator = false;
1122                 scanner.resetTo(start, end);
1123
1124                 /* unit creation */
1125                 referenceContext = null;
1126
1127                 /* initialize the astStacl */
1128                 // the compilationUnitDeclaration should contain exactly one type
1129                 /* run automaton */
1130                 parse();
1131                 notifySourceElementRequestor((CompilationUnitDeclaration)null);
1132         } catch (AbortCompilation e) {
1133         } finally {
1134                 diet = old;
1135         }
1136 }
1137 /**
1138  * Sort the given ast nodes by their positions.
1139  */
1140 private static void quickSort(AstNode[] sortedCollection, int left, int right) {
1141         int original_left = left;
1142         int original_right = right;
1143         AstNode mid = sortedCollection[ (left + right) / 2];
1144         do {
1145                 while (sortedCollection[left].sourceStart < mid.sourceStart) {
1146                         left++;
1147                 }
1148                 while (mid.sourceStart < sortedCollection[right].sourceStart) {
1149                         right--;
1150                 }
1151                 if (left <= right) {
1152                         AstNode tmp = sortedCollection[left];
1153                         sortedCollection[left] = sortedCollection[right];
1154                         sortedCollection[right] = tmp;
1155                         left++;
1156                         right--;
1157                 }
1158         } while (left <= right);
1159         if (original_left < right) {
1160                 quickSort(sortedCollection, original_left, right);
1161         }
1162         if (left < original_right) {
1163                 quickSort(sortedCollection, left, original_right);
1164         }
1165 }
1166 /*
1167  * Answer a char array representation of the type name formatted like:
1168  * - type name + dimensions
1169  * Example:
1170  * "A[][]".toCharArray()
1171  * "java.lang.String".toCharArray()
1172  */
1173 private char[] returnTypeName(TypeReference type) {
1174         if (type == null)
1175                 return null;
1176         int dimension = type.dimensions();
1177         if (dimension != 0) {
1178                 char[] dimensionsArray = new char[dimension * 2];
1179                 for (int i = 0; i < dimension; i++) {
1180                         dimensionsArray[i * 2] = '[';
1181                         dimensionsArray[(i * 2) + 1] = ']';
1182                 }
1183                 return CharOperation.concat(
1184                         CharOperation.concatWith(type.getTypeName(), '.'),
1185                         dimensionsArray);
1186         }
1187         return CharOperation.concatWith(type.getTypeName(), '.');
1188 }
1189
1190 public void addUnknownRef(NameReference nameRef) {
1191         if (this.unknownRefs.length == this.unknownRefsCounter) {
1192                 // resize
1193                 System.arraycopy(
1194                         this.unknownRefs,
1195                         0,
1196                         (this.unknownRefs = new NameReference[this.unknownRefsCounter * 2]),
1197                         0,
1198                         this.unknownRefsCounter);
1199         }
1200         this.unknownRefs[this.unknownRefsCounter++] = nameRef;
1201 }
1202 private TypeReference typeReference(
1203         int dim,
1204         int localIdentifierPtr,
1205         int localIdentifierLengthPtr) {
1206         /* build a Reference on a variable that may be qualified or not
1207          * This variable is a type reference and dim will be its dimensions.
1208          * We don't have any side effect on the stacks' pointers.
1209          */
1210
1211         int length;
1212         TypeReference ref;
1213         if ((length = identifierLengthStack[localIdentifierLengthPtr]) == 1) {
1214                 // single variable reference
1215                 if (dim == 0) {
1216                         ref =
1217                                 new SingleTypeReference(
1218                                         identifierStack[localIdentifierPtr],
1219                                         identifierPositionStack[localIdentifierPtr--]);
1220                 } else {
1221                         ref =
1222                                 new ArrayTypeReference(
1223                                         identifierStack[localIdentifierPtr],
1224                                         dim,
1225                                         identifierPositionStack[localIdentifierPtr--]);
1226                         ref.sourceEnd = endPosition;
1227                 }
1228         } else {
1229                 if (length < 0) { //flag for precompiled type reference on base types
1230                         ref = TypeReference.baseTypeReference(-length, dim);
1231                         ref.sourceStart = intStack[localIntPtr--];
1232                         if (dim == 0) {
1233                                 ref.sourceEnd = intStack[localIntPtr--];
1234                         } else {
1235                                 localIntPtr--;
1236                                 ref.sourceEnd = endPosition;
1237                         }
1238                 } else { //Qualified variable reference
1239                         char[][] tokens = new char[length][];
1240                         localIdentifierPtr -= length;
1241                         long[] positions = new long[length];
1242                         System.arraycopy(identifierStack, localIdentifierPtr + 1, tokens, 0, length);
1243                         System.arraycopy(
1244                                 identifierPositionStack,
1245                                 localIdentifierPtr + 1,
1246                                 positions,
1247                                 0,
1248                                 length);
1249                         if (dim == 0)  {
1250                                 ref = new QualifiedTypeReference(tokens, positions);
1251                         } else {
1252                                 ref = new ArrayQualifiedTypeReference(tokens, dim, positions);
1253                                 ref.sourceEnd = endPosition;
1254                         }
1255                 }
1256         };
1257         return ref;
1258 }
1259
1260 private void visitIfNeeded(AbstractMethodDeclaration method) {
1261         if (this.localDeclarationVisitor != null
1262                 && (method.bits & AstNode.HasLocalTypeMASK) != 0) {
1263                         if (method.statements != null) {
1264                                 int statementsLength = method.statements.length;
1265                                 for (int i = 0; i < statementsLength; i++)
1266                                         method.statements[i].traverse(this.localDeclarationVisitor, method.scope);
1267                         }
1268         }
1269 }
1270
1271 private void visitIfNeeded(FieldDeclaration field) {
1272         if (this.localDeclarationVisitor != null
1273                 && (field.bits & AstNode.HasLocalTypeMASK) != 0) {
1274                         if (field.initialization != null) {
1275                                 field.initialization.traverse(this.localDeclarationVisitor, null);
1276                         }
1277         }
1278 }
1279
1280 private void visitIfNeeded(Initializer initializer) {
1281         if (this.localDeclarationVisitor != null
1282                 && (initializer.bits & AstNode.HasLocalTypeMASK) != 0) {
1283                         if (initializer.block != null) {
1284                                 initializer.block.traverse(this.localDeclarationVisitor, null);
1285                         }
1286         }
1287 }
1288
1289 protected void reportSyntaxError(int act, int currentKind, int stateStackTop) {
1290         if (compilationUnit == null) return;
1291         super.reportSyntaxError(act, currentKind,stateStackTop);
1292 }
1293
1294 }