net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/SourceElementParser.java

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