Updating syntax.xml to attempt fix issues reported in ticket #761
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / compiler / SourceElementParser.java
index b7dda3f..c120843 100644 (file)
@@ -39,1297 +39,1404 @@ import net.sourceforge.phpdt.internal.compiler.problem.ProblemReporter;
 import net.sourceforge.phpdt.internal.core.util.CommentRecorderParser;
 
 /**
- * A source element parser extracts structural and reference information
- * from a piece of source.
- *
- * also see @ISourceElementRequestor
- *
- * The structural investigation includes:
- * - the package statement
- * - import statements
- * - top-level types: package member, member types (member types of member types...)
- * - fields
- * - methods
- *
+ * A source element parser extracts structural and reference information from a
+ * piece of source.
+ * 
+ * also see
+ * 
+ * @ISourceElementRequestor
+ * 
+ * The structural investigation includes: - the package statement - import
+ * statements - top-level types: package member, member types (member types of
+ * member types...) - fields - methods
+ * 
  * If reference information is requested, then all source constructs are
  * investigated and type, field & method references are provided as well.
- *
+ * 
  * Any (parsing) problem encountered is also provided.
  */
 
-public class SourceElementParser extends CommentRecorderParser {//extends
-                                                                // UnitParser {
+public class SourceElementParser extends CommentRecorderParser {// extends
+       // UnitParser {
+
+       ISourceElementRequestor requestor;
+
+       int fieldCount;
+
+       int localIntPtr;
+
+       int lastFieldEndPosition;
+
+       ISourceType sourceType;
+
+       boolean reportReferenceInfo;
+
+       char[][] typeNames;
+
+       char[][] superTypeNames;
+
+       int nestedTypeIndex;
+
+       static final char[] JAVA_LANG_OBJECT = "java.lang.Object".toCharArray(); //$NON-NLS-1$
+
+       NameReference[] unknownRefs;
+
+       int unknownRefsCounter;
+
+       LocalDeclarationVisitor localDeclarationVisitor = null;
+
+       // CompilerOptions options;
+
+       /**
+        * An ast visitor that visits local type declarations.
+        */
+       public class LocalDeclarationVisitor extends ASTVisitor {
+               public boolean visit(TypeDeclaration typeDeclaration, BlockScope scope) {
+                       notifySourceElementRequestor(typeDeclaration, sourceType == null);
+                       return false; // don't visit members as this was done during
+                                                       // notifySourceElementRequestor(...)
+               }
+
+               public boolean visit(TypeDeclaration typeDeclaration, ClassScope scope) {
+                       notifySourceElementRequestor(typeDeclaration, sourceType == null);
+                       return false; // don't visit members as this was done during
+                                                       // notifySourceElementRequestor(...)
+               }
+
+       }
+
+       public SourceElementParser(final ISourceElementRequestor requestor,
+                       IProblemFactory problemFactory, CompilerOptions options) {
+               // we want to notify all syntax error with the acceptProblem API
+               // To do so, we define the record method of the ProblemReporter
+               super(new ProblemReporter(DefaultErrorHandlingPolicies
+                               .exitAfterAllProblems(), options, problemFactory) {
+                       public void record(IProblem problem, CompilationResult unitResult,
+                                       ReferenceContext referenceContext) {
+                               unitResult.record(problem, referenceContext);
+                               if (requestor != null) {
+                                       requestor.acceptProblem(problem);
+                               }
+                       }
+               });
+               // true);
+               // options.sourceLevel >= CompilerOptions.JDK1_4);
+               this.requestor = requestor;
+               typeNames = new char[4][];
+               superTypeNames = new char[4][];
+               nestedTypeIndex = 0;
+               this.options = options;
+       }
+
+       /**
+        * @deprecated use SourceElementParser(ISourceElementRequestor,
+        *             IProblemFactory, CompilerOptions)
+        */
+       public SourceElementParser(final ISourceElementRequestor requestor,
+                       IProblemFactory problemFactory) {
+               this(requestor, problemFactory, new CompilerOptions());
+       }
+
+       public SourceElementParser(final ISourceElementRequestor requestor,
+                       IProblemFactory problemFactory, CompilerOptions options,
+                       boolean reportLocalDeclarations) {
+               this(requestor, problemFactory, options);
+               if (reportLocalDeclarations) {
+                       this.localDeclarationVisitor = new LocalDeclarationVisitor();
+               }
+       }
+
+       // public void checkAnnotation() {
+       // int firstCommentIndex = scanner.commentPtr;
+       //
+       // super.checkAnnotation();
+       //
+       // // modify the modifier source start to point at the first comment
+       // if (firstCommentIndex >= 0) {
+       // modifiersSourceStart = scanner.commentStarts[0];
+       // }
+       // }
+       // protected void classInstanceCreation(boolean alwaysQualified) {
+       //
+       // boolean previousFlag = reportReferenceInfo;
+       // reportReferenceInfo = false; // not to see the type reference reported in
+       // super call to getTypeReference(...)
+       // super.classInstanceCreation(alwaysQualified);
+       // reportReferenceInfo = previousFlag;
+       // if (reportReferenceInfo){
+       // AllocationExpression alloc =
+       // (AllocationExpression)expressionStack[expressionPtr];
+       // TypeReference typeRef = alloc.type;
+       // requestor.acceptConstructorReference(
+       // typeRef instanceof SingleTypeReference
+       // ? ((SingleTypeReference) typeRef).token
+       // : CharOperation.concatWith(alloc.type.getTypeName(), '.'),
+       // alloc.arguments == null ? 0 : alloc.arguments.length,
+       // alloc.sourceStart);
+       // }
+       // }
+       // protected void consumeConstructorHeaderName() {
+       // // ConstructorHeaderName ::= Modifiersopt 'Identifier' '('
+       //
+       // /* recovering - might be an empty message send */
+       // if (currentElement != null){
+       // if (lastIgnoredToken == TokenNamenew){ // was an allocation expression
+       // lastCheckPoint = scanner.startPosition; // force to restart at this exact
+       // position
+       // restartRecovery = true;
+       // return;
+       // }
+       // }
+       // SourceConstructorDeclaration cd = new
+       // SourceConstructorDeclaration(this.compilationUnit.compilationResult);
+       //
+       // //name -- this is not really revelant but we do .....
+       // cd.selector = identifierStack[identifierPtr];
+       // long selectorSourcePositions = identifierPositionStack[identifierPtr--];
+       // identifierLengthPtr--;
+       //
+       // //modifiers
+       // cd.declarationSourceStart = intStack[intPtr--];
+       // cd.modifiers = intStack[intPtr--];
+       //
+       // //highlight starts at the selector starts
+       // cd.sourceStart = (int) (selectorSourcePositions >>> 32);
+       // cd.selectorSourceEnd = (int) selectorSourcePositions;
+       // pushOnAstStack(cd);
+       //
+       // cd.sourceEnd = lParenPos;
+       // cd.bodyStart = lParenPos+1;
+       // listLength = 0; // initialize listLength before reading parameters/throws
+       //
+       // // recovery
+       // if (currentElement != null){
+       // lastCheckPoint = cd.bodyStart;
+       // if ((currentElement instanceof RecoveredType && lastIgnoredToken !=
+       // TokenNameDOT)
+       // || cd.modifiers != 0){
+       // currentElement = currentElement.add(cd, 0);
+       // lastIgnoredToken = -1;
+       // }
+       // }
+       // }
+       // /**
+       // *
+       // * INTERNAL USE-ONLY
+       // */
+       // protected void consumeExitVariableWithInitialization() {
+       // // ExitVariableWithInitialization ::= $empty
+       // // the scanner is located after the comma or the semi-colon.
+       // // we want to include the comma or the semi-colon
+       // super.consumeExitVariableWithInitialization();
+       // if (isLocalDeclaration() || ((currentToken != TokenNameCOMMA) &&
+       // (currentToken != TokenNameSEMICOLON)))
+       // return;
+       // ((SourceFieldDeclaration) astStack[astPtr]).fieldEndPosition =
+       // scanner.currentPosition - 1;
+       // }
+       // protected void consumeExitVariableWithoutInitialization() {
+       // // ExitVariableWithoutInitialization ::= $empty
+       // // do nothing by default
+       // super.consumeExitVariableWithoutInitialization();
+       // if (isLocalDeclaration() || ((currentToken != TokenNameCOMMA) &&
+       // (currentToken != TokenNameSEMICOLON)))
+       // return;
+       // ((SourceFieldDeclaration) astStack[astPtr]).fieldEndPosition =
+       // scanner.currentPosition - 1;
+       // }
+       // /**
+       // *
+       // * INTERNAL USE-ONLY
+       // */
+       // protected void consumeFieldAccess(boolean isSuperAccess) {
+       // // FieldAccess ::= Primary '.' 'Identifier'
+       // // FieldAccess ::= 'super' '.' 'Identifier'
+       // super.consumeFieldAccess(isSuperAccess);
+       // FieldReference fr = (FieldReference) expressionStack[expressionPtr];
+       // if (reportReferenceInfo) {
+       // requestor.acceptFieldReference(fr.token, fr.sourceStart);
+       // }
+       // }
+       // protected void consumeMethodHeaderName() {
+       // // MethodHeaderName ::= Modifiersopt Type 'Identifier' '('
+       // SourceMethodDeclaration md = new
+       // SourceMethodDeclaration(this.compilationUnit.compilationResult);
+       //
+       // //name
+       // md.selector = identifierStack[identifierPtr];
+       // long selectorSourcePositions = identifierPositionStack[identifierPtr--];
+       // identifierLengthPtr--;
+       // //type
+       // md.returnType = getTypeReference(intStack[intPtr--]);
+       // //modifiers
+       // md.declarationSourceStart = intStack[intPtr--];
+       // md.modifiers = intStack[intPtr--];
+       //
+       // //highlight starts at selector start
+       // md.sourceStart = (int) (selectorSourcePositions >>> 32);
+       // md.selectorSourceEnd = (int) selectorSourcePositions;
+       // pushOnAstStack(md);
+       // md.sourceEnd = lParenPos;
+       // md.bodyStart = lParenPos+1;
+       // listLength = 0; // initialize listLength before reading parameters/throws
+       //      
+       // // recovery
+       // if (currentElement != null){
+       // if (currentElement instanceof RecoveredType
+       // //|| md.modifiers != 0
+       // || (scanner.getLineNumber(md.returnType.sourceStart)
+       // == scanner.getLineNumber(md.sourceStart))){
+       // lastCheckPoint = md.bodyStart;
+       // currentElement = currentElement.add(md, 0);
+       // lastIgnoredToken = -1;
+       // } else {
+       // lastCheckPoint = md.sourceStart;
+       // restartRecovery = true;
+       // }
+       // }
+       // }
+       // /**
+       // *
+       // * INTERNAL USE-ONLY
+       // */
+       // protected void consumeMethodInvocationName() {
+       // // MethodInvocation ::= Name '(' ArgumentListopt ')'
+       //
+       // // when the name is only an identifier...we have a message send to "this"
+       // (implicit)
+       // super.consumeMethodInvocationName();
+       // MessageSend messageSend = (MessageSend) expressionStack[expressionPtr];
+       // Expression[] args = messageSend.arguments;
+       // if (reportReferenceInfo) {
+       // requestor.acceptMethodReference(
+       // messageSend.selector,
+       // args == null ? 0 : args.length,
+       // (int)(messageSend.nameSourcePosition >>> 32));
+       // }
+       // }
+       // /**
+       // *
+       // * INTERNAL USE-ONLY
+       // */
+       // protected void consumeMethodInvocationPrimary() {
+       // super.consumeMethodInvocationPrimary();
+       // MessageSend messageSend = (MessageSend) expressionStack[expressionPtr];
+       // Expression[] args = messageSend.arguments;
+       // if (reportReferenceInfo) {
+       // requestor.acceptMethodReference(
+       // messageSend.selector,
+       // args == null ? 0 : args.length,
+       // (int)(messageSend.nameSourcePosition >>> 32));
+       // }
+       // }
+       // /**
+       // *
+       // * INTERNAL USE-ONLY
+       // */
+       // protected void consumeMethodInvocationSuper() {
+       // // MethodInvocation ::= 'super' '.' 'Identifier' '(' ArgumentListopt ')'
+       // super.consumeMethodInvocationSuper();
+       // MessageSend messageSend = (MessageSend) expressionStack[expressionPtr];
+       // Expression[] args = messageSend.arguments;
+       // if (reportReferenceInfo) {
+       // requestor.acceptMethodReference(
+       // messageSend.selector,
+       // args == null ? 0 : args.length,
+       // (int)(messageSend.nameSourcePosition >>> 32));
+       // }
+       // }
+       // protected void consumeSingleTypeImportDeclarationName() {
+       // // SingleTypeImportDeclarationName ::= 'import' Name
+       // /* push an ImportRef build from the last name
+       // stored in the identifier stack. */
+       //
+       // super.consumeSingleTypeImportDeclarationName();
+       // ImportReference impt = (ImportReference)astStack[astPtr];
+       // if (reportReferenceInfo) {
+       // requestor.acceptTypeReference(impt.tokens, impt.sourceStart,
+       // impt.sourceEnd);
+       // }
+       // }
+       // protected void consumeTypeImportOnDemandDeclarationName() {
+       // // TypeImportOnDemandDeclarationName ::= 'import' Name '.' '*'
+       // /* push an ImportRef build from the last name
+       // stored in the identifier stack. */
+       //
+       // super.consumeTypeImportOnDemandDeclarationName();
+       // ImportReference impt = (ImportReference)astStack[astPtr];
+       // if (reportReferenceInfo) {
+       // requestor.acceptUnknownReference(impt.tokens, impt.sourceStart,
+       // impt.sourceEnd);
+       // }
+       // }
+       // protected FieldDeclaration createFieldDeclaration(Expression
+       // initialization, char[] name, int sourceStart, int sourceEnd) {
+       // return new SourceFieldDeclaration(null, name, sourceStart, sourceEnd);
+       // }
+       // protected CompilationUnitDeclaration endParse(int act) {
+       // if (sourceType != null) {
+       // if (sourceType.isInterface()) {
+       // consumeInterfaceDeclaration();
+       // } else {
+       // consumeClassDeclaration();
+       // }
+       // }
+       // if (compilationUnit != null) {
+       // CompilationUnitDeclaration result = super.endParse(act);
+       // return result;
+       // } else {
+       // return null;
+       // }
+       // }
+       /*
+        * Flush annotations defined prior to a given positions.
+        * 
+        * Note: annotations are stacked in syntactical order
+        * 
+        * Either answer given <position>, or the end position of a comment line
+        * immediately following the <position> (same line)
+        * 
+        * e.g. void foo(){ } // end of method foo
+        */
+       // 
+       // public int flushAnnotationsDefinedPriorTo(int position) {
+       //
+       // return lastFieldEndPosition =
+       // super.flushAnnotationsDefinedPriorTo(position);
+       // }
+       // public TypeReference getTypeReference(int dim) {
+       // /* build a Reference on a variable that may be qualified or not
+       // * This variable is a type reference and dim will be its dimensions
+       // */
+       // int length;
+       // if ((length = identifierLengthStack[identifierLengthPtr--]) == 1) {
+       // // single variable reference
+       // if (dim == 0) {
+       // SingleTypeReference ref =
+       // new SingleTypeReference(
+       // identifierStack[identifierPtr],
+       // identifierPositionStack[identifierPtr--]);
+       // if (reportReferenceInfo) {
+       // requestor.acceptTypeReference(ref.token, ref.sourceStart);
+       // }
+       // return ref;
+       // } else {
+       // ArrayTypeReference ref =
+       // new ArrayTypeReference(
+       // identifierStack[identifierPtr],
+       // dim,
+       // identifierPositionStack[identifierPtr--]);
+       // ref.sourceEnd = endPosition;
+       // if (reportReferenceInfo) {
+       // requestor.acceptTypeReference(ref.token, ref.sourceStart);
+       // }
+       // return ref;
+       // }
+       // } else {
+       // if (length < 0) { //flag for precompiled type reference on base types
+       // TypeReference ref = TypeReference.baseTypeReference(-length, dim);
+       // ref.sourceStart = intStack[intPtr--];
+       // if (dim == 0) {
+       // ref.sourceEnd = intStack[intPtr--];
+       // } else {
+       // intPtr--; // no need to use this position as it is an array
+       // ref.sourceEnd = endPosition;
+       // }
+       // if (reportReferenceInfo){
+       // requestor.acceptTypeReference(ref.getTypeName(), ref.sourceStart,
+       // ref.sourceEnd);
+       // }
+       // return ref;
+       // } else { //Qualified variable reference
+       // char[][] tokens = new char[length][];
+       // identifierPtr -= length;
+       // long[] positions = new long[length];
+       // System.arraycopy(identifierStack, identifierPtr + 1, tokens, 0, length);
+       // System.arraycopy(
+       // identifierPositionStack,
+       // identifierPtr + 1,
+       // positions,
+       // 0,
+       // length);
+       // if (dim == 0) {
+       // QualifiedTypeReference ref = new QualifiedTypeReference(tokens,
+       // positions);
+       // if (reportReferenceInfo) {
+       // requestor.acceptTypeReference(ref.tokens, ref.sourceStart,
+       // ref.sourceEnd);
+       // }
+       // return ref;
+       // } else {
+       // ArrayQualifiedTypeReference ref =
+       // new ArrayQualifiedTypeReference(tokens, dim, positions);
+       // ref.sourceEnd = endPosition;
+       // if (reportReferenceInfo) {
+       // requestor.acceptTypeReference(ref.tokens, ref.sourceStart,
+       // ref.sourceEnd);
+       // }
+       // return ref;
+       // }
+       // }
+       // }
+       // }
+       // public NameReference getUnspecifiedReference() {
+       // /* build a (unspecified) NameReference which may be qualified*/
+       //
+       // int length;
+       // if ((length = identifierLengthStack[identifierLengthPtr--]) == 1) {
+       // // single variable reference
+       // SingleNameReference ref =
+       // new SingleNameReference(
+       // identifierStack[identifierPtr],
+       // identifierPositionStack[identifierPtr--]);
+       // if (reportReferenceInfo) {
+       // this.addUnknownRef(ref);
+       // }
+       // return ref;
+       // } else {
+       // //Qualified variable reference
+       // char[][] tokens = new char[length][];
+       // identifierPtr -= length;
+       // System.arraycopy(identifierStack, identifierPtr + 1, tokens, 0, length);
+       // QualifiedNameReference ref =
+       // new QualifiedNameReference(
+       // tokens,
+       // (int) (identifierPositionStack[identifierPtr + 1] >> 32), // sourceStart
+       // (int) identifierPositionStack[identifierPtr + length]); // sourceEnd
+       // if (reportReferenceInfo) {
+       // this.addUnknownRef(ref);
+       // }
+       // return ref;
+       // }
+       // }
+       // public NameReference getUnspecifiedReferenceOptimized() {
+       // /* build a (unspecified) NameReference which may be qualified
+       // The optimization occurs for qualified reference while we are
+       // certain in this case the last item of the qualified name is
+       // a field access. This optimization is IMPORTANT while it results
+       // that when a NameReference is build, the type checker should always
+       // look for that it is not a type reference */
+       //
+       // int length;
+       // if ((length = identifierLengthStack[identifierLengthPtr--]) == 1) {
+       // // single variable reference
+       // SingleNameReference ref =
+       // new SingleNameReference(
+       // identifierStack[identifierPtr],
+       // identifierPositionStack[identifierPtr--]);
+       // ref.bits &= ~ASTNode.RestrictiveFlagMASK;
+       // ref.bits |= LOCAL | FIELD;
+       // if (reportReferenceInfo) {
+       // this.addUnknownRef(ref);
+       // }
+       // return ref;
+       // }
+       //
+       // //Qualified-variable-reference
+       // //In fact it is variable-reference DOT field-ref , but it would result in
+       // a
+       // type
+       // //conflict tha can be only reduce by making a superclass (or inetrface )
+       // between
+       // //nameReference and FiledReference or putting FieldReference under
+       // NameReference
+       // //or else..........This optimisation is not really relevant so just leave
+       // as it is
+       //
+       // char[][] tokens = new char[length][];
+       // identifierPtr -= length;
+       // System.arraycopy(identifierStack, identifierPtr + 1, tokens, 0, length);
+       // QualifiedNameReference ref =
+       // new QualifiedNameReference(
+       // tokens,
+       // (int) (identifierPositionStack[identifierPtr + 1] >> 32),
+       // // sourceStart
+       // (int) identifierPositionStack[identifierPtr + length]); // sourceEnd
+       // ref.bits &= ~ASTNode.RestrictiveFlagMASK;
+       // ref.bits |= LOCAL | FIELD;
+       // if (reportReferenceInfo) {
+       // this.addUnknownRef(ref);
+       // }
+       // return ref;
+       // }
+       // /**
+       // *
+       // * INTERNAL USE-ONLY
+       // */
+       // private boolean isLocalDeclaration() {
+       // int nestedDepth = nestedType;
+       // while (nestedDepth >= 0) {
+       // if (nestedMethod[nestedDepth] != 0) {
+       // return true;
+       // }
+       // nestedDepth--;
+       // }
+       // return false;
+       // }
+       /*
+        * Update the bodyStart of the corresponding parse node
+        */
+       public void notifySourceElementRequestor(
+                       CompilationUnitDeclaration parsedUnit) {
+               if (parsedUnit == null) {
+                       // when we parse a single type member declaration the compilation
+                       // unit is
+                       // null, but we still
+                       // want to be able to notify the requestor on the created ast node
+                       if (astStack[0] instanceof AbstractMethodDeclaration) {
+                               notifySourceElementRequestor((AbstractMethodDeclaration) astStack[0]);
+                               return;
+                       }
+                       return;
+               }
+               // range check
+               boolean isInRange = scanner.initialPosition <= parsedUnit.sourceStart
+                               && scanner.eofPosition >= parsedUnit.sourceEnd;
+
+               // if (reportReferenceInfo) {
+               // notifyAllUnknownReferences();
+               // }
+               // collect the top level ast nodes
+               int length = 0;
+               ASTNode[] nodes = null;
+               if (sourceType == null) {
+                       if (isInRange) {
+                               requestor.enterCompilationUnit();
+                       }
+                       // ImportReference currentPackage = parsedUnit.currentPackage;
+                       ImportReference[] imports = parsedUnit.imports;
+                       // TypeDeclaration[] types = parsedUnit.types;
+                       ArrayList types = parsedUnit.types;
+                       if (types != null) {
+                               // length =
+                               // (currentPackage == null ? 0 : 1)
+                               // + (imports == null ? 0 : imports.length)
+                               // + (types == null ? 0 : types.length);
+                               // nodes = new ASTNode[length];
+                               length = (imports == null ? 0 : imports.length) + types.size();
+                               nodes = new ASTNode[length];
+                               int index = 0;
+                               // if (currentPackage != null) {
+                               // nodes[index++] = currentPackage;
+                               // }
+                               if (imports != null) {
+                                       for (int i = 0, max = imports.length; i < max; i++) {
+                                               nodes[index++] = imports[i];
+                                       }
+                               }
+
+                               for (int i = 0, max = types.size(); i < max; i++) {
+                                       nodes[index++] = (ASTNode) types.get(i);
+                               }
+                       }
+               } else {
+                       // TypeDeclaration[] types = parsedUnit.types;
+                       ArrayList types = parsedUnit.types;
+                       if (types != null) {
+                               length = types.size();
+                               nodes = new ASTNode[length];
+                               for (int i = 0, max = types.size(); i < max; i++) {
+                                       nodes[i] = (ASTNode) types.get(i);
+                               }
+                       }
+               }
+
+               // notify the nodes in the syntactical order
+               if (nodes != null && length > 0) {
+                       quickSort(nodes, 0, length - 1);
+                       for (int i = 0; i < length; i++) {
+                               ASTNode node = nodes[i];
+                               if (node instanceof ImportReference) {
+                                       ImportReference importRef = (ImportReference) node;
+                                       // if (node == parsedUnit.currentPackage) {
+                                       // notifySourceElementRequestor(importRef, true);
+                                       // } else {
+                                       notifySourceElementRequestor(importRef, false);
+                                       // }
+                               } // else { instanceof TypeDeclaration
+                               if (node instanceof TypeDeclaration) {
+                                       notifySourceElementRequestor((TypeDeclaration) node,
+                                                       sourceType == null);
+                                       // notifySourceElementRequestor((CompilationUnitDeclaration)node,
+                                       // sourceType == null);
+                               }
+                               // jsurfer - INSERT start
+                               if (node instanceof AbstractMethodDeclaration) {
+                                       notifySourceElementRequestor((AbstractMethodDeclaration) node);
+                               }
+                               // jsurfer - INSERT end
+                       }
+               }
 
-  ISourceElementRequestor requestor;
-  int fieldCount;
-  int localIntPtr;
-  int lastFieldEndPosition;
-  ISourceType sourceType;
-  boolean reportReferenceInfo;
-  char[][] typeNames;
-  char[][] superTypeNames;
-  int nestedTypeIndex;
-  static final char[] JAVA_LANG_OBJECT = "java.lang.Object".toCharArray(); //$NON-NLS-1$
-  NameReference[] unknownRefs;
-  int unknownRefsCounter;
-  LocalDeclarationVisitor localDeclarationVisitor = null;
-  //   CompilerOptions options;
+               if (sourceType == null) {
+                       if (isInRange) {
+                               requestor.exitCompilationUnit(parsedUnit.sourceEnd);
+                       }
+               }
+       }
 
-  /**
-   * An ast visitor that visits local type declarations.
-   */
-  public class LocalDeclarationVisitor extends ASTVisitor {
-       public boolean visit(TypeDeclaration typeDeclaration, BlockScope scope) {
-               notifySourceElementRequestor(typeDeclaration, sourceType == null);
-               return false; // don't visit members as this was done during notifySourceElementRequestor(...)
-       }
-       public boolean visit(TypeDeclaration typeDeclaration, ClassScope scope) {
-               notifySourceElementRequestor(typeDeclaration, sourceType == null);
-               return false; // don't visit members as this was done during notifySourceElementRequestor(...)
-       }
-       
-  }
+       // private void notifyAllUnknownReferences() {
+       // for (int i = 0, max = this.unknownRefsCounter; i < max; i++) {
+       // NameReference nameRef = this.unknownRefs[i];
+       // if ((nameRef.bits & BindingIds.VARIABLE) != 0) {
+       // if ((nameRef.bits & BindingIds.TYPE) == 0) {
+       // // variable but not type
+       // if (nameRef instanceof SingleNameReference) {
+       // // local var or field
+       // requestor.acceptUnknownReference(((SingleNameReference) nameRef).token,
+       // nameRef.sourceStart);
+       // } else {
+       // // QualifiedNameReference
+       // // The last token is a field reference and the previous tokens are a
+       // type/variable references
+       // char[][] tokens = ((QualifiedNameReference) nameRef).tokens;
+       // int tokensLength = tokens.length;
+       // requestor.acceptFieldReference(tokens[tokensLength - 1],
+       // nameRef.sourceEnd
+       // - tokens[tokensLength - 1].length + 1);
+       // char[][] typeRef = new char[tokensLength - 1][];
+       // System.arraycopy(tokens, 0, typeRef, 0, tokensLength - 1);
+       // requestor.acceptUnknownReference(typeRef, nameRef.sourceStart,
+       // nameRef.sourceEnd - tokens[tokensLength - 1].length);
+       // }
+       // } else {
+       // // variable or type
+       // if (nameRef instanceof SingleNameReference) {
+       // requestor.acceptUnknownReference(((SingleNameReference) nameRef).token,
+       // nameRef.sourceStart);
+       // } else {
+       // //QualifiedNameReference
+       // requestor.acceptUnknownReference(((QualifiedNameReference)
+       // nameRef).tokens,
+       // nameRef.sourceStart, nameRef.sourceEnd);
+       // }
+       // }
+       // } else if ((nameRef.bits & BindingIds.TYPE) != 0) {
+       // if (nameRef instanceof SingleNameReference) {
+       // requestor.acceptTypeReference(((SingleNameReference) nameRef).token,
+       // nameRef.sourceStart);
+       // } else {
+       // // it is a QualifiedNameReference
+       // requestor.acceptTypeReference(((QualifiedNameReference) nameRef).tokens,
+       // nameRef.sourceStart, nameRef.sourceEnd);
+       // }
+       // }
+       // }
+       // }
+       /*
+        * Update the bodyStart of the corresponding parse node
+        */
+       public void notifySourceElementRequestor(
+                       AbstractMethodDeclaration methodDeclaration) {
 
-  public SourceElementParser(final ISourceElementRequestor requestor, IProblemFactory problemFactory, CompilerOptions options) {
-    // we want to notify all syntax error with the acceptProblem API
-    // To do so, we define the record method of the ProblemReporter
-    super( new ProblemReporter(DefaultErrorHandlingPolicies.exitAfterAllProblems(), options, problemFactory) {
-      public void record(IProblem problem, CompilationResult unitResult, ReferenceContext referenceContext) {
-        unitResult.record(problem, referenceContext);
-        if (requestor!=null) {
-          requestor.acceptProblem(problem);
-        }
-      }
-    });
-    // true);
-    // options.sourceLevel >= CompilerOptions.JDK1_4);
-    this.requestor = requestor;
-    typeNames = new char[4][];
-    superTypeNames = new char[4][];
-    nestedTypeIndex = 0;
-    this.options = options;
-  }
+               // range check
+               boolean isInRange = scanner.initialPosition <= methodDeclaration.declarationSourceStart
+                               && scanner.eofPosition >= methodDeclaration.declarationSourceEnd;
 
-  /**
-   * @deprecated use SourceElementParser(ISourceElementRequestor,
-   *             IProblemFactory, CompilerOptions)
-   */
-  public SourceElementParser(
-       final ISourceElementRequestor requestor,
-       IProblemFactory problemFactory) {
-               this(requestor, problemFactory, new CompilerOptions());
-  }
-  public SourceElementParser(
-       final ISourceElementRequestor requestor,
-       IProblemFactory problemFactory,
-       CompilerOptions options,
-       boolean reportLocalDeclarations) {
-               this(requestor, problemFactory, options);
-               if (reportLocalDeclarations) {
-                       this.localDeclarationVisitor = new LocalDeclarationVisitor();
-               }
-  }
-  //public void checkAnnotation() {
-  //   int firstCommentIndex = scanner.commentPtr;
-  //
-  //   super.checkAnnotation();
-  //
-  //   // modify the modifier source start to point at the first comment
-  //   if (firstCommentIndex >= 0) {
-  //           modifiersSourceStart = scanner.commentStarts[0];
-  //   }
-  //}
-  //protected void classInstanceCreation(boolean alwaysQualified) {
-  //
-  //   boolean previousFlag = reportReferenceInfo;
-  //   reportReferenceInfo = false; // not to see the type reference reported in
-  // super call to getTypeReference(...)
-  //   super.classInstanceCreation(alwaysQualified);
-  //   reportReferenceInfo = previousFlag;
-  //   if (reportReferenceInfo){
-  //           AllocationExpression alloc =
-  // (AllocationExpression)expressionStack[expressionPtr];
-  //           TypeReference typeRef = alloc.type;
-  //           requestor.acceptConstructorReference(
-  //                   typeRef instanceof SingleTypeReference
-  //                           ? ((SingleTypeReference) typeRef).token
-  //                           : CharOperation.concatWith(alloc.type.getTypeName(), '.'),
-  //                   alloc.arguments == null ? 0 : alloc.arguments.length,
-  //                   alloc.sourceStart);
-  //   }
-  //}
-  //protected void consumeConstructorHeaderName() {
-  //   // ConstructorHeaderName ::= Modifiersopt 'Identifier' '('
-  //
-  //   /* recovering - might be an empty message send */
-  //   if (currentElement != null){
-  //           if (lastIgnoredToken == TokenNamenew){ // was an allocation expression
-  //                   lastCheckPoint = scanner.startPosition; // force to restart at this exact
-  // position
-  //                   restartRecovery = true;
-  //                   return;
-  //           }
-  //   }
-  //   SourceConstructorDeclaration cd = new
-  // SourceConstructorDeclaration(this.compilationUnit.compilationResult);
-  //
-  //   //name -- this is not really revelant but we do .....
-  //   cd.selector = identifierStack[identifierPtr];
-  //   long selectorSourcePositions = identifierPositionStack[identifierPtr--];
-  //   identifierLengthPtr--;
-  //
-  //   //modifiers
-  //   cd.declarationSourceStart = intStack[intPtr--];
-  //   cd.modifiers = intStack[intPtr--];
-  //
-  //   //highlight starts at the selector starts
-  //   cd.sourceStart = (int) (selectorSourcePositions >>> 32);
-  //   cd.selectorSourceEnd = (int) selectorSourcePositions;
-  //   pushOnAstStack(cd);
-  //
-  //   cd.sourceEnd = lParenPos;
-  //   cd.bodyStart = lParenPos+1;
-  //   listLength = 0; // initialize listLength before reading parameters/throws
-  //
-  //   // recovery
-  //   if (currentElement != null){
-  //           lastCheckPoint = cd.bodyStart;
-  //           if ((currentElement instanceof RecoveredType && lastIgnoredToken !=
-  // TokenNameDOT)
-  //                   || cd.modifiers != 0){
-  //                   currentElement = currentElement.add(cd, 0);
-  //                   lastIgnoredToken = -1;
-  //           }
-  //   }
-  //}
-  ///**
-  // *
-  // * INTERNAL USE-ONLY
-  // */
-  //protected void consumeExitVariableWithInitialization() {
-  //   // ExitVariableWithInitialization ::= $empty
-  //   // the scanner is located after the comma or the semi-colon.
-  //   // we want to include the comma or the semi-colon
-  //   super.consumeExitVariableWithInitialization();
-  //   if (isLocalDeclaration() || ((currentToken != TokenNameCOMMA) &&
-  // (currentToken != TokenNameSEMICOLON)))
-  //           return;
-  //   ((SourceFieldDeclaration) astStack[astPtr]).fieldEndPosition =
-  // scanner.currentPosition - 1;
-  //}
-  //protected void consumeExitVariableWithoutInitialization() {
-  //   // ExitVariableWithoutInitialization ::= $empty
-  //   // do nothing by default
-  //   super.consumeExitVariableWithoutInitialization();
-  //   if (isLocalDeclaration() || ((currentToken != TokenNameCOMMA) &&
-  // (currentToken != TokenNameSEMICOLON)))
-  //           return;
-  //   ((SourceFieldDeclaration) astStack[astPtr]).fieldEndPosition =
-  // scanner.currentPosition - 1;
-  //}
-  ///**
-  // *
-  // * INTERNAL USE-ONLY
-  // */
-  //protected void consumeFieldAccess(boolean isSuperAccess) {
-  //   // FieldAccess ::= Primary '.' 'Identifier'
-  //   // FieldAccess ::= 'super' '.' 'Identifier'
-  //   super.consumeFieldAccess(isSuperAccess);
-  //   FieldReference fr = (FieldReference) expressionStack[expressionPtr];
-  //   if (reportReferenceInfo) {
-  //           requestor.acceptFieldReference(fr.token, fr.sourceStart);
-  //   }
-  //}
-  //protected void consumeMethodHeaderName() {
-  //   // MethodHeaderName ::= Modifiersopt Type 'Identifier' '('
-  //   SourceMethodDeclaration md = new
-  // SourceMethodDeclaration(this.compilationUnit.compilationResult);
-  //
-  //   //name
-  //   md.selector = identifierStack[identifierPtr];
-  //   long selectorSourcePositions = identifierPositionStack[identifierPtr--];
-  //   identifierLengthPtr--;
-  //   //type
-  //   md.returnType = getTypeReference(intStack[intPtr--]);
-  //   //modifiers
-  //   md.declarationSourceStart = intStack[intPtr--];
-  //   md.modifiers = intStack[intPtr--];
-  //
-  //   //highlight starts at selector start
-  //   md.sourceStart = (int) (selectorSourcePositions >>> 32);
-  //   md.selectorSourceEnd = (int) selectorSourcePositions;
-  //   pushOnAstStack(md);
-  //   md.sourceEnd = lParenPos;
-  //   md.bodyStart = lParenPos+1;
-  //   listLength = 0; // initialize listLength before reading parameters/throws
-  //   
-  //   // recovery
-  //   if (currentElement != null){
-  //           if (currentElement instanceof RecoveredType
-  //                   //|| md.modifiers != 0
-  //                   || (scanner.getLineNumber(md.returnType.sourceStart)
-  //                                   == scanner.getLineNumber(md.sourceStart))){
-  //                   lastCheckPoint = md.bodyStart;
-  //                   currentElement = currentElement.add(md, 0);
-  //                   lastIgnoredToken = -1;
-  //           } else {
-  //                   lastCheckPoint = md.sourceStart;
-  //                   restartRecovery = true;
-  //           }
-  //   }
-  //}
-  ///**
-  // *
-  // * INTERNAL USE-ONLY
-  // */
-  //protected void consumeMethodInvocationName() {
-  //   // MethodInvocation ::= Name '(' ArgumentListopt ')'
-  //
-  //   // when the name is only an identifier...we have a message send to "this"
-  // (implicit)
-  //   super.consumeMethodInvocationName();
-  //   MessageSend messageSend = (MessageSend) expressionStack[expressionPtr];
-  //   Expression[] args = messageSend.arguments;
-  //   if (reportReferenceInfo) {
-  //           requestor.acceptMethodReference(
-  //                   messageSend.selector,
-  //                   args == null ? 0 : args.length,
-  //                   (int)(messageSend.nameSourcePosition >>> 32));
-  //   }
-  //}
-  ///**
-  // *
-  // * INTERNAL USE-ONLY
-  // */
-  //protected void consumeMethodInvocationPrimary() {
-  //   super.consumeMethodInvocationPrimary();
-  //   MessageSend messageSend = (MessageSend) expressionStack[expressionPtr];
-  //   Expression[] args = messageSend.arguments;
-  //   if (reportReferenceInfo) {
-  //           requestor.acceptMethodReference(
-  //                   messageSend.selector,
-  //                   args == null ? 0 : args.length,
-  //                   (int)(messageSend.nameSourcePosition >>> 32));
-  //   }
-  //}
-  ///**
-  // *
-  // * INTERNAL USE-ONLY
-  // */
-  //protected void consumeMethodInvocationSuper() {
-  //   // MethodInvocation ::= 'super' '.' 'Identifier' '(' ArgumentListopt ')'
-  //   super.consumeMethodInvocationSuper();
-  //   MessageSend messageSend = (MessageSend) expressionStack[expressionPtr];
-  //   Expression[] args = messageSend.arguments;
-  //   if (reportReferenceInfo) {
-  //           requestor.acceptMethodReference(
-  //                   messageSend.selector,
-  //                   args == null ? 0 : args.length,
-  //                   (int)(messageSend.nameSourcePosition >>> 32));
-  //   }
-  //}
-  //protected void consumeSingleTypeImportDeclarationName() {
-  //   // SingleTypeImportDeclarationName ::= 'import' Name
-  //   /* push an ImportRef build from the last name
-  //   stored in the identifier stack. */
-  //
-  //   super.consumeSingleTypeImportDeclarationName();
-  //   ImportReference impt = (ImportReference)astStack[astPtr];
-  //   if (reportReferenceInfo) {
-  //           requestor.acceptTypeReference(impt.tokens, impt.sourceStart,
-  // impt.sourceEnd);
-  //   }
-  //}
-  //protected void consumeTypeImportOnDemandDeclarationName() {
-  //   // TypeImportOnDemandDeclarationName ::= 'import' Name '.' '*'
-  //   /* push an ImportRef build from the last name
-  //   stored in the identifier stack. */
-  //
-  //   super.consumeTypeImportOnDemandDeclarationName();
-  //   ImportReference impt = (ImportReference)astStack[astPtr];
-  //   if (reportReferenceInfo) {
-  //           requestor.acceptUnknownReference(impt.tokens, impt.sourceStart,
-  // impt.sourceEnd);
-  //   }
-  //}
-  //protected FieldDeclaration createFieldDeclaration(Expression
-  // initialization, char[] name, int sourceStart, int sourceEnd) {
-  //   return new SourceFieldDeclaration(null, name, sourceStart, sourceEnd);
-  //}
-  //protected CompilationUnitDeclaration endParse(int act) {
-  //   if (sourceType != null) {
-  //           if (sourceType.isInterface()) {
-  //                   consumeInterfaceDeclaration();
-  //           } else {
-  //                   consumeClassDeclaration();
-  //           }
-  //   }
-  //   if (compilationUnit != null) {
-  //           CompilationUnitDeclaration result = super.endParse(act);
-  //           return result;
-  //   } else {
-  //           return null;
-  //   }
-  //}
-  /*
-   * Flush annotations defined prior to a given positions.
-   * 
-   * Note: annotations are stacked in syntactical order
-   * 
-   * Either answer given <position>, or the end position of a comment line
-   * immediately following the <position> (same line)
-   * 
-   * e.g. void foo(){ } // end of method foo
-   */
-  // 
-  //public int flushAnnotationsDefinedPriorTo(int position) {
-  //
-  //   return lastFieldEndPosition =
-  // super.flushAnnotationsDefinedPriorTo(position);
-  //}
-  //public TypeReference getTypeReference(int dim) {
-  //   /* build a Reference on a variable that may be qualified or not
-  //    * This variable is a type reference and dim will be its dimensions
-  //    */
-  //   int length;
-  //   if ((length = identifierLengthStack[identifierLengthPtr--]) == 1) {
-  //           // single variable reference
-  //           if (dim == 0) {
-  //                   SingleTypeReference ref =
-  //                           new SingleTypeReference(
-  //                                   identifierStack[identifierPtr],
-  //                                   identifierPositionStack[identifierPtr--]);
-  //                   if (reportReferenceInfo) {
-  //                           requestor.acceptTypeReference(ref.token, ref.sourceStart);
-  //                   }
-  //                   return ref;
-  //           } else {
-  //                   ArrayTypeReference ref =
-  //                           new ArrayTypeReference(
-  //                                   identifierStack[identifierPtr],
-  //                                   dim,
-  //                                   identifierPositionStack[identifierPtr--]);
-  //                   ref.sourceEnd = endPosition;
-  //                   if (reportReferenceInfo) {
-  //                           requestor.acceptTypeReference(ref.token, ref.sourceStart);
-  //                   }
-  //                   return ref;
-  //           }
-  //   } else {
-  //           if (length < 0) { //flag for precompiled type reference on base types
-  //                   TypeReference ref = TypeReference.baseTypeReference(-length, dim);
-  //                   ref.sourceStart = intStack[intPtr--];
-  //                   if (dim == 0) {
-  //                           ref.sourceEnd = intStack[intPtr--];
-  //                   } else {
-  //                           intPtr--; // no need to use this position as it is an array
-  //                           ref.sourceEnd = endPosition;
-  //                   }
-  //                   if (reportReferenceInfo){
-  //                                   requestor.acceptTypeReference(ref.getTypeName(), ref.sourceStart,
-  // ref.sourceEnd);
-  //                   }
-  //                   return ref;
-  //           } else { //Qualified variable reference
-  //                   char[][] tokens = new char[length][];
-  //                   identifierPtr -= length;
-  //                   long[] positions = new long[length];
-  //                   System.arraycopy(identifierStack, identifierPtr + 1, tokens, 0, length);
-  //                   System.arraycopy(
-  //                           identifierPositionStack,
-  //                           identifierPtr + 1,
-  //                           positions,
-  //                           0,
-  //                           length);
-  //                   if (dim == 0) {
-  //                           QualifiedTypeReference ref = new QualifiedTypeReference(tokens, positions);
-  //                           if (reportReferenceInfo) {
-  //                                   requestor.acceptTypeReference(ref.tokens, ref.sourceStart, ref.sourceEnd);
-  //                           }
-  //                           return ref;
-  //                   } else {
-  //                           ArrayQualifiedTypeReference ref =
-  //                                   new ArrayQualifiedTypeReference(tokens, dim, positions);
-  //                           ref.sourceEnd = endPosition;
-  //                           if (reportReferenceInfo) {
-  //                                   requestor.acceptTypeReference(ref.tokens, ref.sourceStart, ref.sourceEnd);
-  //                           }
-  //                           return ref;
-  //                   }
-  //           }
-  //   }
-  //}
-  //public NameReference getUnspecifiedReference() {
-  //   /* build a (unspecified) NameReference which may be qualified*/
-  //
-  //   int length;
-  //   if ((length = identifierLengthStack[identifierLengthPtr--]) == 1) {
-  //           // single variable reference
-  //           SingleNameReference ref =
-  //                   new SingleNameReference(
-  //                           identifierStack[identifierPtr],
-  //                           identifierPositionStack[identifierPtr--]);
-  //           if (reportReferenceInfo) {
-  //                   this.addUnknownRef(ref);
-  //           }
-  //           return ref;
-  //   } else {
-  //           //Qualified variable reference
-  //           char[][] tokens = new char[length][];
-  //           identifierPtr -= length;
-  //           System.arraycopy(identifierStack, identifierPtr + 1, tokens, 0, length);
-  //           QualifiedNameReference ref =
-  //                   new QualifiedNameReference(
-  //                           tokens,
-  //                           (int) (identifierPositionStack[identifierPtr + 1] >> 32), // sourceStart
-  //                           (int) identifierPositionStack[identifierPtr + length]); // sourceEnd
-  //           if (reportReferenceInfo) {
-  //                   this.addUnknownRef(ref);
-  //           }
-  //           return ref;
-  //   }
-  //}
-  //public NameReference getUnspecifiedReferenceOptimized() {
-  //   /* build a (unspecified) NameReference which may be qualified
-  //   The optimization occurs for qualified reference while we are
-  //   certain in this case the last item of the qualified name is
-  //   a field access. This optimization is IMPORTANT while it results
-  //   that when a NameReference is build, the type checker should always
-  //   look for that it is not a type reference */
-  //
-  //   int length;
-  //   if ((length = identifierLengthStack[identifierLengthPtr--]) == 1) {
-  //           // single variable reference
-  //           SingleNameReference ref =
-  //                   new SingleNameReference(
-  //                           identifierStack[identifierPtr],
-  //                           identifierPositionStack[identifierPtr--]);
-  //           ref.bits &= ~ASTNode.RestrictiveFlagMASK;
-  //           ref.bits |= LOCAL | FIELD;
-  //           if (reportReferenceInfo) {
-  //                   this.addUnknownRef(ref);
-  //           }
-  //           return ref;
-  //   }
-  //
-  //   //Qualified-variable-reference
-  //   //In fact it is variable-reference DOT field-ref , but it would result in a
-  // type
-  //   //conflict tha can be only reduce by making a superclass (or inetrface )
-  // between
-  //   //nameReference and FiledReference or putting FieldReference under
-  // NameReference
-  //   //or else..........This optimisation is not really relevant so just leave
-  // as it is
-  //
-  //   char[][] tokens = new char[length][];
-  //   identifierPtr -= length;
-  //   System.arraycopy(identifierStack, identifierPtr + 1, tokens, 0, length);
-  //   QualifiedNameReference ref =
-  //           new QualifiedNameReference(
-  //                   tokens,
-  //                   (int) (identifierPositionStack[identifierPtr + 1] >> 32),
-  //   // sourceStart
-  //    (int) identifierPositionStack[identifierPtr + length]); // sourceEnd
-  //   ref.bits &= ~ASTNode.RestrictiveFlagMASK;
-  //   ref.bits |= LOCAL | FIELD;
-  //   if (reportReferenceInfo) {
-  //           this.addUnknownRef(ref);
-  //   }
-  //   return ref;
-  //}
-  ///**
-  // *
-  // * INTERNAL USE-ONLY
-  // */
-  //private boolean isLocalDeclaration() {
-  //   int nestedDepth = nestedType;
-  //   while (nestedDepth >= 0) {
-  //           if (nestedMethod[nestedDepth] != 0) {
-  //                   return true;
-  //           }
-  //           nestedDepth--;
-  //   }
-  //   return false;
-  //}
-  /*
-   * Update the bodyStart of the corresponding parse node
-   */
-  public void notifySourceElementRequestor(CompilationUnitDeclaration parsedUnit) {
-    if (parsedUnit == null) {
-      // when we parse a single type member declaration the compilation unit is
-      // null, but we still
-      // want to be able to notify the requestor on the created ast node
-      if (astStack[0] instanceof AbstractMethodDeclaration) {
-        notifySourceElementRequestor((AbstractMethodDeclaration) astStack[0]);
-        return;
-      }
-      return;
-    }
-    // range check
-    boolean isInRange = scanner.initialPosition <= parsedUnit.sourceStart && scanner.eofPosition >= parsedUnit.sourceEnd;
+               if (methodDeclaration.isClinit()) {
+                       this.visitIfNeeded(methodDeclaration);
+                       return;
+               }
 
-    // if (reportReferenceInfo) {
-    //         notifyAllUnknownReferences();
-    // }
-    // collect the top level ast nodes
-    int length = 0;
-    ASTNode[] nodes = null;
-    if (sourceType == null) {
-      if (isInRange) {
-        requestor.enterCompilationUnit();
-      }
-      //               ImportReference currentPackage = parsedUnit.currentPackage;
-      ImportReference[] imports = parsedUnit.imports;
-      //               TypeDeclaration[] types = parsedUnit.types;
-      ArrayList types = parsedUnit.types;
-      if (types != null) {
-        //             length =
-        //                     (currentPackage == null ? 0 : 1)
-        //                     + (imports == null ? 0 : imports.length)
-        //                     + (types == null ? 0 : types.length);
-        //             nodes = new ASTNode[length];
-        length = (imports == null ? 0 : imports.length) + types.size();
-        nodes = new ASTNode[length];
-        int index = 0;
-        //             if (currentPackage != null) {
-        //                     nodes[index++] = currentPackage;
-        //             }
-        if (imports != null) {
-          for (int i = 0, max = imports.length; i < max; i++) {
-            nodes[index++] = imports[i];
-          }
-        }
+               if (methodDeclaration.isDefaultConstructor()) {
+                       if (reportReferenceInfo) {
+                               ConstructorDeclaration constructorDeclaration = (ConstructorDeclaration) methodDeclaration;
+                               ExplicitConstructorCall constructorCall = constructorDeclaration.constructorCall;
+                               if (constructorCall != null) {
+                                       switch (constructorCall.accessMode) {
+                                       case ExplicitConstructorCall.This:
+                                               requestor.acceptConstructorReference(
+                                                               typeNames[nestedTypeIndex - 1],
+                                                               constructorCall.arguments == null ? 0
+                                                                               : constructorCall.arguments.length,
+                                                               constructorCall.sourceStart);
+                                               break;
+                                       case ExplicitConstructorCall.Super:
+                                       case ExplicitConstructorCall.ImplicitSuper:
+                                               requestor.acceptConstructorReference(
+                                                               superTypeNames[nestedTypeIndex - 1],
+                                                               constructorCall.arguments == null ? 0
+                                                                               : constructorCall.arguments.length,
+                                                               constructorCall.sourceStart);
+                                               break;
+                                       }
+                               }
+                       }
+                       return;
+               }
+               char[][] argumentTypes = null;
+               char[][] argumentNames = null;
+               Argument[] arguments = methodDeclaration.arguments;
+               if (arguments != null) {
+                       int argumentLength = arguments.length;
+                       argumentTypes = new char[argumentLength][];
+                       argumentNames = new char[argumentLength][];
+                       for (int i = 0; i < argumentLength; i++) {
+                               argumentTypes[i] = returnTypeName(arguments[i].type);
+                               argumentNames[i] = arguments[i].name;
+                       }
+               }
+               char[][] thrownExceptionTypes = null;
+               TypeReference[] thrownExceptions = methodDeclaration.thrownExceptions;
+               if (thrownExceptions != null) {
+                       int thrownExceptionLength = thrownExceptions.length;
+                       thrownExceptionTypes = new char[thrownExceptionLength][];
+                       for (int i = 0; i < thrownExceptionLength; i++) {
+                               thrownExceptionTypes[i] = CharOperation.concatWith(
+                                               thrownExceptions[i].getTypeName(), '.');
+                       }
+               }
+               // by default no selector end position
+               int selectorSourceEnd = -1;
+               if (methodDeclaration.isConstructor()) {
+                       // if (methodDeclaration instanceof SourceConstructorDeclaration) {
+                       // selectorSourceEnd =
+                       // ((SourceConstructorDeclaration)
+                       // methodDeclaration).selectorSourceEnd;
+                       // }
+                       if (isInRange) {
+                               requestor.enterConstructor(
+                                               methodDeclaration.declarationSourceStart,
+                                               methodDeclaration.modifiers,
+                                               methodDeclaration.selector,
+                                               methodDeclaration.sourceStart, selectorSourceEnd,
+                                               argumentTypes, argumentNames, thrownExceptionTypes);
+                       }
+                       if (reportReferenceInfo) {
+                               ConstructorDeclaration constructorDeclaration = (ConstructorDeclaration) methodDeclaration;
+                               ExplicitConstructorCall constructorCall = constructorDeclaration.constructorCall;
+                               if (constructorCall != null) {
+                                       switch (constructorCall.accessMode) {
+                                       case ExplicitConstructorCall.This:
+                                               requestor.acceptConstructorReference(
+                                                               typeNames[nestedTypeIndex - 1],
+                                                               constructorCall.arguments == null ? 0
+                                                                               : constructorCall.arguments.length,
+                                                               constructorCall.sourceStart);
+                                               break;
+                                       case ExplicitConstructorCall.Super:
+                                       case ExplicitConstructorCall.ImplicitSuper:
+                                               requestor.acceptConstructorReference(
+                                                               superTypeNames[nestedTypeIndex - 1],
+                                                               constructorCall.arguments == null ? 0
+                                                                               : constructorCall.arguments.length,
+                                                               constructorCall.sourceStart);
+                                               break;
+                                       }
+                               }
+                       }
+                       this.visitIfNeeded(methodDeclaration);
+                       if (isInRange) {
+                               requestor
+                                               .exitConstructor(methodDeclaration.declarationSourceEnd);
+                       }
+                       return;
+               }
+               // if (methodDeclaration instanceof SourceMethodDeclaration) {
+               // selectorSourceEnd =
+               // ((SourceMethodDeclaration) methodDeclaration).selectorSourceEnd;
+               // }
+               if (isInRange) {
+                       int modifiers = methodDeclaration.modifiers;
+                       // boolean deprecated = (modifiers & AccDeprecated) != 0; //
+                       // remember
+                       // deprecation so as to not lose it below
+                       requestor
+                                       .enterMethod(
+                                                       methodDeclaration.declarationSourceStart,
+                                                       modifiers, // deprecated
+                                                       // ?
+                                                       // (modifiers
+                                                       // &
+                                                       // AccJustFlag)
+                                                       // |
+                                                       // AccDeprecated
+                                                       // :
+                                                       // modifiers
+                                                       // &
+                                                       // AccJustFlag,
+                                                       returnTypeName(((MethodDeclaration) methodDeclaration).returnType),
+                                                       methodDeclaration.selector,
+                                                       methodDeclaration.sourceStart, selectorSourceEnd,
+                                                       argumentTypes, argumentNames, thrownExceptionTypes);
+               }
+               this.visitIfNeeded(methodDeclaration);
 
-        for (int i = 0, max = types.size(); i < max; i++) {
-          nodes[index++] = (ASTNode) types.get(i);
-        }
-      }
-    } else {
-      //               TypeDeclaration[] types = parsedUnit.types;
-      ArrayList types = parsedUnit.types;
-      if (types != null) {
-        length = types.size();
-        nodes = new ASTNode[length];
-        for (int i = 0, max = types.size(); i < max; i++) {
-          nodes[i] = (ASTNode) types.get(i);
-        }
-      }
-    }
+               if (isInRange) {
+                       requestor.exitMethod(methodDeclaration.declarationSourceEnd);
+               }
+       }
 
-    // notify the nodes in the syntactical order
-    if (nodes != null && length > 0) {
-      quickSort(nodes, 0, length - 1);
-      for (int i = 0; i < length; i++) {
-        ASTNode node = nodes[i];
-                               if (node instanceof ImportReference) {
-                                       ImportReference importRef = (ImportReference)node;
-//                                     if (node == parsedUnit.currentPackage) {
-//                                             notifySourceElementRequestor(importRef, true);
-//                                     } else {
-                                               notifySourceElementRequestor(importRef, false);
-//                                     }
-                               } //else { instanceof TypeDeclaration
-        if (node instanceof TypeDeclaration) {
-          notifySourceElementRequestor((TypeDeclaration) node, sourceType == null);
-          //                           notifySourceElementRequestor((CompilationUnitDeclaration)node,
-          // sourceType == null);
-        }
-        // jsurfer - INSERT start
-        if (node instanceof AbstractMethodDeclaration) {
-          notifySourceElementRequestor((AbstractMethodDeclaration) node);
-        }
-        //             jsurfer - INSERT end
-      }
-    }
+       /*
+        * Update the bodyStart of the corresponding parse node
+        */
+       public void notifySourceElementRequestor(FieldDeclaration fieldDeclaration) {
 
-    if (sourceType == null) {
-      if (isInRange) {
-        requestor.exitCompilationUnit(parsedUnit.sourceEnd);
-      }
-    }
-  }
+               // range check
+               boolean isInRange = scanner.initialPosition <= fieldDeclaration.declarationSourceStart
+                               && scanner.eofPosition >= fieldDeclaration.declarationSourceEnd;
 
-  //private void notifyAllUnknownReferences() {
-  //   for (int i = 0, max = this.unknownRefsCounter; i < max; i++) {
-  //           NameReference nameRef = this.unknownRefs[i];
-  //           if ((nameRef.bits & BindingIds.VARIABLE) != 0) {
-  //                   if ((nameRef.bits & BindingIds.TYPE) == 0) {
-  //                           // variable but not type
-  //                           if (nameRef instanceof SingleNameReference) {
-  //                                   // local var or field
-  //                                   requestor.acceptUnknownReference(((SingleNameReference) nameRef).token,
-  // nameRef.sourceStart);
-  //                           } else {
-  //                                   // QualifiedNameReference
-  //                                   // The last token is a field reference and the previous tokens are a
-  // type/variable references
-  //                                   char[][] tokens = ((QualifiedNameReference) nameRef).tokens;
-  //                                   int tokensLength = tokens.length;
-  //                                   requestor.acceptFieldReference(tokens[tokensLength - 1], nameRef.sourceEnd
-  // - tokens[tokensLength - 1].length + 1);
-  //                                   char[][] typeRef = new char[tokensLength - 1][];
-  //                                   System.arraycopy(tokens, 0, typeRef, 0, tokensLength - 1);
-  //                                   requestor.acceptUnknownReference(typeRef, nameRef.sourceStart,
-  // nameRef.sourceEnd - tokens[tokensLength - 1].length);
-  //                           }
-  //                   } else {
-  //                           // variable or type
-  //                           if (nameRef instanceof SingleNameReference) {
-  //                                   requestor.acceptUnknownReference(((SingleNameReference) nameRef).token,
-  // nameRef.sourceStart);
-  //                           } else {
-  //                                   //QualifiedNameReference
-  //                                   requestor.acceptUnknownReference(((QualifiedNameReference) nameRef).tokens,
-  // nameRef.sourceStart, nameRef.sourceEnd);
-  //                           }
-  //                   }
-  //           } else if ((nameRef.bits & BindingIds.TYPE) != 0) {
-  //                   if (nameRef instanceof SingleNameReference) {
-  //                           requestor.acceptTypeReference(((SingleNameReference) nameRef).token,
-  // nameRef.sourceStart);
-  //                   } else {
-  //                           // it is a QualifiedNameReference
-  //                           requestor.acceptTypeReference(((QualifiedNameReference) nameRef).tokens,
-  // nameRef.sourceStart, nameRef.sourceEnd);
-  //                   }
-  //           }
-  //   }
-  //}
-  /*
-   * Update the bodyStart of the corresponding parse node
-   */
-  public void notifySourceElementRequestor(AbstractMethodDeclaration methodDeclaration) {
+               if (fieldDeclaration.isField()) {
+                       int fieldEndPosition = fieldDeclaration.declarationSourceEnd;
+                       // if (fieldDeclaration instanceof SourceFieldDeclaration) {
+                       // fieldEndPosition = ((SourceFieldDeclaration)
+                       // fieldDeclaration).fieldEndPosition;
+                       // if (fieldEndPosition == 0) {
+                       // // use the declaration source end by default
+                       // fieldEndPosition = fieldDeclaration.declarationSourceEnd;
+                       // }
+                       // }
+                       if (isInRange) {
+                               int modifiers = fieldDeclaration.modifiers;
+                               boolean deprecated = (modifiers & AccDeprecated) != 0; // remember
+                               // deprecation so
+                               // as to not lose
+                               // it below
+                               requestor.enterField(fieldDeclaration.declarationSourceStart,
+                                               deprecated ? (modifiers & AccJustFlag) | AccDeprecated
+                                                               : modifiers & AccJustFlag,
+                                               returnTypeName(fieldDeclaration.type),
+                                               fieldDeclaration.name, fieldDeclaration.sourceStart,
+                                               fieldDeclaration.sourceEnd);
+                       }
+                       // this.visitIfNeeded(fieldDeclaration);
+                       if (isInRange) {
+                               // requestor.exitField(
+                               // // filter out initializations that are not a constant (simple
+                               // check)
+                               // (fieldDeclaration.initialization == null
+                               // || fieldDeclaration.initialization instanceof
+                               // ArrayInitializer
+                               // || fieldDeclaration.initialization instanceof
+                               // AllocationExpression
+                               // || fieldDeclaration.initialization instanceof
+                               // ArrayAllocationExpression
+                               // || fieldDeclaration.initialization instanceof Assignment
+                               // || fieldDeclaration.initialization instanceof
+                               // ClassLiteralAccess
+                               // || fieldDeclaration.initialization instanceof MessageSend
+                               // || fieldDeclaration.initialization instanceof ArrayReference
+                               // || fieldDeclaration.initialization instanceof ThisReference)
+                               // ?
+                               // -1 :
+                               // fieldDeclaration.initialization.sourceStart,
+                               // fieldEndPosition,
+                               // fieldDeclaration.declarationSourceEnd);
+                               requestor.exitField(
+                                               // filter out initializations that are not a constant
+                                               // (simple check)
+                                               -1, fieldEndPosition,
+                                               fieldDeclaration.declarationSourceEnd);
+                       }
 
-    // range check
-    boolean isInRange = scanner.initialPosition <= methodDeclaration.declarationSourceStart
-        && scanner.eofPosition >= methodDeclaration.declarationSourceEnd;
+               } else {
+                       // if (isInRange){
+                       // requestor.enterInitializer(
+                       // fieldDeclaration.declarationSourceStart,
+                       // fieldDeclaration.modifiers);
+                       // }
+                       // this.visitIfNeeded((Initializer)fieldDeclaration);
+                       // if (isInRange){
+                       // requestor.exitInitializer(fieldDeclaration.declarationSourceEnd);
+                       // }
+               }
+       }
 
-    if (methodDeclaration.isClinit()) {
-      this.visitIfNeeded(methodDeclaration);
-      return;
-    }
+       public void notifySourceElementRequestor(ImportReference importReference,
+                       boolean isPackage) {
+               // if (isPackage) {
+               // requestor.acceptPackage(
+               // importReference.declarationSourceStart,
+               // importReference.declarationSourceEnd,
+               // CharOperation.concatWith(importReference.getImportName(), '.'));
+               // } else {
+               requestor.acceptImport(importReference.declarationSourceStart,
+                               importReference.declarationSourceEnd, importReference
+                                               .getIncludeName(), // CharOperation.concatWith(importReference.getImportName(),
+                                                                                       // '.'),
+                               importReference.onDemand);
+               // }
+       }
 
-    if (methodDeclaration.isDefaultConstructor()) {
-      if (reportReferenceInfo) {
-        ConstructorDeclaration constructorDeclaration = (ConstructorDeclaration) methodDeclaration;
-        ExplicitConstructorCall constructorCall = constructorDeclaration.constructorCall;
-        if (constructorCall != null) {
-          switch (constructorCall.accessMode) {
-            case ExplicitConstructorCall.This :
-              requestor.acceptConstructorReference(typeNames[nestedTypeIndex - 1], constructorCall.arguments == null
-                  ? 0
-                  : constructorCall.arguments.length, constructorCall.sourceStart);
-              break;
-            case ExplicitConstructorCall.Super :
-            case ExplicitConstructorCall.ImplicitSuper :
-              requestor.acceptConstructorReference(superTypeNames[nestedTypeIndex - 1], constructorCall.arguments == null
-                  ? 0
-                  : constructorCall.arguments.length, constructorCall.sourceStart);
-              break;
-          }
-        }
-      }
-      return;
-    }
-    char[][] argumentTypes = null;
-    char[][] argumentNames = null;
-    Argument[] arguments = methodDeclaration.arguments;
-    if (arguments != null) {
-      int argumentLength = arguments.length;
-      argumentTypes = new char[argumentLength][];
-      argumentNames = new char[argumentLength][];
-      for (int i = 0; i < argumentLength; i++) {
-        argumentTypes[i] = returnTypeName(arguments[i].type);
-        argumentNames[i] = arguments[i].name;
-      }
-    }
-    char[][] thrownExceptionTypes = null;
-    TypeReference[] thrownExceptions = methodDeclaration.thrownExceptions;
-    if (thrownExceptions != null) {
-      int thrownExceptionLength = thrownExceptions.length;
-      thrownExceptionTypes = new char[thrownExceptionLength][];
-      for (int i = 0; i < thrownExceptionLength; i++) {
-        thrownExceptionTypes[i] = CharOperation.concatWith(thrownExceptions[i].getTypeName(), '.');
-      }
-    }
-    // by default no selector end position
-    int selectorSourceEnd = -1;
-    if (methodDeclaration.isConstructor()) {
-      //               if (methodDeclaration instanceof SourceConstructorDeclaration) {
-      //                       selectorSourceEnd =
-      //                               ((SourceConstructorDeclaration) methodDeclaration).selectorSourceEnd;
-      //               }
-      if (isInRange) {
-        requestor.enterConstructor(methodDeclaration.declarationSourceStart, methodDeclaration.modifiers,
-            methodDeclaration.selector, methodDeclaration.sourceStart, selectorSourceEnd, argumentTypes, argumentNames,
-            thrownExceptionTypes);
-      }
-      if (reportReferenceInfo) {
-        ConstructorDeclaration constructorDeclaration = (ConstructorDeclaration) methodDeclaration;
-        ExplicitConstructorCall constructorCall = constructorDeclaration.constructorCall;
-        if (constructorCall != null) {
-          switch (constructorCall.accessMode) {
-            case ExplicitConstructorCall.This :
-              requestor.acceptConstructorReference(typeNames[nestedTypeIndex - 1], constructorCall.arguments == null
-                  ? 0
-                  : constructorCall.arguments.length, constructorCall.sourceStart);
-              break;
-            case ExplicitConstructorCall.Super :
-            case ExplicitConstructorCall.ImplicitSuper :
-              requestor.acceptConstructorReference(superTypeNames[nestedTypeIndex - 1], constructorCall.arguments == null
-                  ? 0
-                  : constructorCall.arguments.length, constructorCall.sourceStart);
-              break;
-          }
-        }
-      }
-      this.visitIfNeeded(methodDeclaration);
-      if (isInRange) {
-        requestor.exitConstructor(methodDeclaration.declarationSourceEnd);
-      }
-      return;
-    }
-    // if (methodDeclaration instanceof SourceMethodDeclaration) {
-    //         selectorSourceEnd =
-    //                 ((SourceMethodDeclaration) methodDeclaration).selectorSourceEnd;
-    // }
-    if (isInRange) {
-      int modifiers = methodDeclaration.modifiers;
-      //               boolean deprecated = (modifiers & AccDeprecated) != 0; // remember
-      // deprecation so as to not lose it below
-      requestor.enterMethod(methodDeclaration.declarationSourceStart, modifiers, // deprecated
-                                                                                 // ?
-                                                                                 // (modifiers
-                                                                                 // &
-                                                                                 // AccJustFlag)
-                                                                                 // |
-                                                                                 // AccDeprecated
-                                                                                 // :
-                                                                                 // modifiers
-                                                                                 // &
-                                                                                 // AccJustFlag,
-          returnTypeName(((MethodDeclaration) methodDeclaration).returnType), methodDeclaration.selector,
-          methodDeclaration.sourceStart, selectorSourceEnd, argumentTypes, argumentNames, thrownExceptionTypes);
-    }
-    this.visitIfNeeded(methodDeclaration);
+       public void notifySourceElementRequestor(TypeDeclaration typeDeclaration,
+                       boolean notifyTypePresence) {
+               // // public void notifySourceElementRequestor(ASTNode typeDeclaration,
+               // boolean notifyTypePresence) {
 
-    if (isInRange) {
-      requestor.exitMethod(methodDeclaration.declarationSourceEnd);
-    }
-  }
-  /*
-   * Update the bodyStart of the corresponding parse node
-   */
-  public void notifySourceElementRequestor(FieldDeclaration fieldDeclaration) {
+               // range check
+               boolean isInRange = scanner.initialPosition <= typeDeclaration.declarationSourceStart
+                               && scanner.eofPosition >= typeDeclaration.declarationSourceEnd;
 
-    // range check
-    boolean isInRange = scanner.initialPosition <= fieldDeclaration.declarationSourceStart
-        && scanner.eofPosition >= fieldDeclaration.declarationSourceEnd;
+               FieldDeclaration[] fields = typeDeclaration.fields;
+               AbstractMethodDeclaration[] methods = typeDeclaration.methods;
+               TypeDeclaration[] memberTypes = typeDeclaration.memberTypes;
+               int fieldCount = fields == null ? 0 : fields.length;
+               int methodCount = methods == null ? 0 : methods.length;
+               int memberTypeCount = memberTypes == null ? 0 : memberTypes.length;
+               int fieldIndex = 0;
+               int methodIndex = 0;
+               int memberTypeIndex = 0;
+               boolean isInterface = typeDeclaration.isInterface();
 
-    if (fieldDeclaration.isField()) {
-      int fieldEndPosition = fieldDeclaration.declarationSourceEnd;
-      //               if (fieldDeclaration instanceof SourceFieldDeclaration) {
-      //                       fieldEndPosition = ((SourceFieldDeclaration)
-      // fieldDeclaration).fieldEndPosition;
-      //                       if (fieldEndPosition == 0) {
-      //                               // use the declaration source end by default
-      //                               fieldEndPosition = fieldDeclaration.declarationSourceEnd;
-      //                       }
-      //               }
-      if (isInRange) {
-        int modifiers = fieldDeclaration.modifiers;
-        boolean deprecated = (modifiers & AccDeprecated) != 0; // remember
-                                                               // deprecation so
-                                                               // as to not lose
-                                                               // it below
-        requestor.enterField(fieldDeclaration.declarationSourceStart, deprecated
-            ? (modifiers & AccJustFlag) | AccDeprecated
-            : modifiers & AccJustFlag, returnTypeName(fieldDeclaration.type), fieldDeclaration.name, fieldDeclaration.sourceStart,
-            fieldDeclaration.sourceEnd);
-      }
-      //               this.visitIfNeeded(fieldDeclaration);
-      if (isInRange) {
-        //                     requestor.exitField(
-        //                             // filter out initializations that are not a constant (simple check)
-        //                             (fieldDeclaration.initialization == null
-        //                                             || fieldDeclaration.initialization instanceof ArrayInitializer
-        //                                             || fieldDeclaration.initialization instanceof AllocationExpression
-        //                                             || fieldDeclaration.initialization instanceof
-        // ArrayAllocationExpression
-        //                                             || fieldDeclaration.initialization instanceof Assignment
-        //                                             || fieldDeclaration.initialization instanceof ClassLiteralAccess
-        //                                             || fieldDeclaration.initialization instanceof MessageSend
-        //                                             || fieldDeclaration.initialization instanceof ArrayReference
-        //                                             || fieldDeclaration.initialization instanceof ThisReference) ?
-        //                                     -1 :
-        //                                     fieldDeclaration.initialization.sourceStart,
-        //                             fieldEndPosition,
-        //                             fieldDeclaration.declarationSourceEnd);
-        requestor.exitField(
-        // filter out initializations that are not a constant (simple check)
-            -1, fieldEndPosition, fieldDeclaration.declarationSourceEnd);
-      }
+               if (notifyTypePresence) {
+                       char[][] interfaceNames = null;
+                       int superInterfacesLength = 0;
+                       TypeReference[] superInterfaces = typeDeclaration.superInterfaces;
+                       if (superInterfaces != null) {
+                               superInterfacesLength = superInterfaces.length;
+                               interfaceNames = new char[superInterfacesLength][];
+                       } else {
+                               if (typeDeclaration instanceof AnonymousLocalTypeDeclaration) {
+                                       // see PR 3442
+                                       QualifiedAllocationExpression alloc = ((AnonymousLocalTypeDeclaration) typeDeclaration).allocation;
+                                       if (alloc != null && alloc.type != null) {
+                                               superInterfaces = new TypeReference[] { ((AnonymousLocalTypeDeclaration) typeDeclaration).allocation.type };
+                                               superInterfacesLength = 1;
+                                               interfaceNames = new char[1][];
+                                       }
+                               }
+                       }
+                       if (superInterfaces != null) {
+                               for (int i = 0; i < superInterfacesLength; i++) {
+                                       interfaceNames[i] = CharOperation.concatWith(
+                                                       superInterfaces[i].getTypeName(), '.');
+                               }
+                       }
+                       if (isInterface) {
+                               if (isInRange) {
+                                       int modifiers = typeDeclaration.modifiers;
+                                       boolean deprecated = false; // (modifiers & AccDeprecated)
+                                                                                               // != 0; //
+                                       // remember deprecation so as to not lose
+                                       // it below
+                                       requestor.enterInterface(
+                                                       typeDeclaration.declarationSourceStart,
+                                                       modifiers, // deprecated
+                                                       // ?
+                                                       // (modifiers
+                                                       // &
+                                                       // AccJustFlag)
+                                                       // |
+                                                       // AccDeprecated
+                                                       // :
+                                                       // modifiers
+                                                       // &
+                                                       // AccJustFlag,
+                                                       typeDeclaration.name, typeDeclaration.sourceStart,
+                                                       typeDeclaration.sourceEnd, interfaceNames);
+                               }
+                               if (nestedTypeIndex == typeNames.length) {
+                                       // need a resize
+                                       System.arraycopy(typeNames, 0,
+                                                       (typeNames = new char[nestedTypeIndex * 2][]), 0,
+                                                       nestedTypeIndex);
+                                       System.arraycopy(superTypeNames, 0,
+                                                       (superTypeNames = new char[nestedTypeIndex * 2][]),
+                                                       0, nestedTypeIndex);
+                               }
+                               typeNames[nestedTypeIndex] = typeDeclaration.name;
+                               superTypeNames[nestedTypeIndex++] = JAVA_LANG_OBJECT;
+                       } else {
+                               TypeReference superclass = typeDeclaration.superclass;
+                               if (superclass == null) {
+                                       if (isInRange) {
+                                               requestor
+                                                               .enterClass(
+                                                                               typeDeclaration.declarationSourceStart,
+                                                                               typeDeclaration.modifiers,
+                                                                               typeDeclaration.name,
+                                                                               typeDeclaration.sourceStart,
+                                                                               typeDeclaration.sourceEnd, null,
+                                                                               interfaceNames);
+                                       }
+                               } else {
+                                       if (isInRange) {
+                                               requestor.enterClass(
+                                                               typeDeclaration.declarationSourceStart,
+                                                               typeDeclaration.modifiers,
+                                                               typeDeclaration.name,
+                                                               typeDeclaration.sourceStart,
+                                                               typeDeclaration.sourceEnd, CharOperation
+                                                                               .concatWith(superclass.getTypeName(),
+                                                                                               '.'), interfaceNames);
+                                       }
+                               }
+                               if (nestedTypeIndex == typeNames.length) {
+                                       // need a resize
+                                       System.arraycopy(typeNames, 0,
+                                                       (typeNames = new char[nestedTypeIndex * 2][]), 0,
+                                                       nestedTypeIndex);
+                                       System.arraycopy(superTypeNames, 0,
+                                                       (superTypeNames = new char[nestedTypeIndex * 2][]),
+                                                       0, nestedTypeIndex);
+                               }
+                               typeNames[nestedTypeIndex] = typeDeclaration.name;
+                               superTypeNames[nestedTypeIndex++] = superclass == null ? JAVA_LANG_OBJECT
+                                               : CharOperation.concatWith(superclass.getTypeName(),
+                                                               '.');
+                       }
+               }
+               while ((fieldIndex < fieldCount) || (memberTypeIndex < memberTypeCount)
+                               || (methodIndex < methodCount)) {
+                       FieldDeclaration nextFieldDeclaration = null;
+                       AbstractMethodDeclaration nextMethodDeclaration = null;
+                       TypeDeclaration nextMemberDeclaration = null;
 
-    } else {
-      //               if (isInRange){
-      //                       requestor.enterInitializer(
-      //                               fieldDeclaration.declarationSourceStart,
-      //                               fieldDeclaration.modifiers);
-      //               }
-      //               this.visitIfNeeded((Initializer)fieldDeclaration);
-      //               if (isInRange){
-      //                       requestor.exitInitializer(fieldDeclaration.declarationSourceEnd);
-      //               }
-    }
-  }
-  public void notifySourceElementRequestor(
-       ImportReference importReference,
-       boolean isPackage) {
-//     if (isPackage) {
-//             requestor.acceptPackage(
-//                     importReference.declarationSourceStart,
-//                     importReference.declarationSourceEnd,
-//                     CharOperation.concatWith(importReference.getImportName(), '.'));
-//     } else {
-               requestor.acceptImport(
-                       importReference.declarationSourceStart,
-                       importReference.declarationSourceEnd,
-                       importReference.getIncludeName(), //CharOperation.concatWith(importReference.getImportName(), '.'),
-                       importReference.onDemand);
-//     }
-  }
-  public void notifySourceElementRequestor(TypeDeclaration typeDeclaration, boolean notifyTypePresence) {
-    //// public void notifySourceElementRequestor(ASTNode typeDeclaration,
-    // boolean notifyTypePresence) {
+                       int position = Integer.MAX_VALUE;
+                       int nextDeclarationType = -1;
+                       if (fieldIndex < fieldCount) {
+                               nextFieldDeclaration = fields[fieldIndex];
+                               if (nextFieldDeclaration.declarationSourceStart < position) {
+                                       position = nextFieldDeclaration.declarationSourceStart;
+                                       nextDeclarationType = 0; // FIELD
+                               }
+                       }
+                       if (methodIndex < methodCount) {
+                               nextMethodDeclaration = methods[methodIndex];
+                               if (nextMethodDeclaration.declarationSourceStart < position) {
+                                       position = nextMethodDeclaration.declarationSourceStart;
+                                       nextDeclarationType = 1; // METHOD
+                               }
+                       }
+                       if (memberTypeIndex < memberTypeCount) {
+                               nextMemberDeclaration = memberTypes[memberTypeIndex];
+                               if (nextMemberDeclaration.declarationSourceStart < position) {
+                                       position = nextMemberDeclaration.declarationSourceStart;
+                                       nextDeclarationType = 2; // MEMBER
+                               }
+                       }
+                       switch (nextDeclarationType) {
+                       case 0:
+                               fieldIndex++;
+                               notifySourceElementRequestor(nextFieldDeclaration);
+                               break;
+                       case 1:
+                               methodIndex++;
+                               notifySourceElementRequestor(nextMethodDeclaration);
+                               break;
+                       case 2:
+                               memberTypeIndex++;
+                               notifySourceElementRequestor(nextMemberDeclaration, true);
+                       }
+               }
+               if (notifyTypePresence) {
+                       if (isInRange) {
+                               if (isInterface) {
+                                       requestor
+                                                       .exitInterface(typeDeclaration.declarationSourceEnd);
+                               } else {
+                                       requestor.exitClass(typeDeclaration.declarationSourceEnd);
+                               }
+                       }
+                       nestedTypeIndex--;
+               }
+       }
 
-    // range check
-    boolean isInRange = scanner.initialPosition <= typeDeclaration.declarationSourceStart
-        && scanner.eofPosition >= typeDeclaration.declarationSourceEnd;
+       public void parseCompilationUnit(ICompilationUnit unit, int start, int end) {
+               // boolean needReferenceInfo) {
 
-    FieldDeclaration[] fields = typeDeclaration.fields;
-    AbstractMethodDeclaration[] methods = typeDeclaration.methods;
-    TypeDeclaration[] memberTypes = typeDeclaration.memberTypes;
-    int fieldCount = fields == null ? 0 : fields.length;
-    int methodCount = methods == null ? 0 : methods.length;
-    int memberTypeCount = memberTypes == null ? 0 : memberTypes.length;
-    int fieldIndex = 0;
-    int methodIndex = 0;
-    int memberTypeIndex = 0;
-    boolean isInterface = typeDeclaration.isInterface();
+               // reportReferenceInfo = needReferenceInfo;
+               // boolean old = diet;
+               // if (needReferenceInfo) {
+               // unknownRefs = new NameReference[10];
+               // unknownRefsCounter = 0;
+               // }
 
-    if (notifyTypePresence) {
-      char[][] interfaceNames = null;
-      int superInterfacesLength = 0;
-      TypeReference[] superInterfaces = typeDeclaration.superInterfaces;
-      if (superInterfaces != null) {
-        superInterfacesLength = superInterfaces.length;
-        interfaceNames = new char[superInterfacesLength][];
-      } else {
-        if (typeDeclaration instanceof AnonymousLocalTypeDeclaration) {
-          // see PR 3442
-          QualifiedAllocationExpression alloc = ((AnonymousLocalTypeDeclaration) typeDeclaration).allocation;
-          if (alloc != null && alloc.type != null) {
-            superInterfaces = new TypeReference[]{((AnonymousLocalTypeDeclaration) typeDeclaration).allocation.type};
-            superInterfacesLength = 1;
-            interfaceNames = new char[1][];
-          }
-        }
-      }
-      if (superInterfaces != null) {
-        for (int i = 0; i < superInterfacesLength; i++) {
-          interfaceNames[i] = CharOperation.concatWith(superInterfaces[i].getTypeName(), '.');
-        }
-      }
-      if (isInterface) {
-        if (isInRange) {
-          int modifiers = typeDeclaration.modifiers;
-          boolean deprecated = false; //(modifiers & AccDeprecated) != 0; //
-                                      // remember deprecation so as to not lose
-                                      // it below
-          requestor.enterInterface(typeDeclaration.declarationSourceStart, modifiers, //deprecated
-                                                                                      // ?
-                                                                                      // (modifiers
-                                                                                      // &
-                                                                                      // AccJustFlag)
-                                                                                      // |
-                                                                                      // AccDeprecated
-                                                                                      // :
-                                                                                      // modifiers
-                                                                                      // &
-                                                                                      // AccJustFlag,
-              typeDeclaration.name, typeDeclaration.sourceStart, typeDeclaration.sourceEnd, interfaceNames);
-        }
-        if (nestedTypeIndex == typeNames.length) {
-          // need a resize
-          System.arraycopy(typeNames, 0, (typeNames = new char[nestedTypeIndex * 2][]), 0, nestedTypeIndex);
-          System.arraycopy(superTypeNames, 0, (superTypeNames = new char[nestedTypeIndex * 2][]), 0, nestedTypeIndex);
-        }
-        typeNames[nestedTypeIndex] = typeDeclaration.name;
-        superTypeNames[nestedTypeIndex++] = JAVA_LANG_OBJECT;
-      } else {
-        TypeReference superclass = typeDeclaration.superclass;
-        if (superclass == null) {
-          if (isInRange) {
-            requestor.enterClass(typeDeclaration.declarationSourceStart, typeDeclaration.modifiers, typeDeclaration.name,
-                typeDeclaration.sourceStart, typeDeclaration.sourceEnd, null, interfaceNames);
-          }
-        } else {
-          if (isInRange) {
-            requestor.enterClass(typeDeclaration.declarationSourceStart, typeDeclaration.modifiers, typeDeclaration.name,
-                typeDeclaration.sourceStart, typeDeclaration.sourceEnd, CharOperation.concatWith(superclass.getTypeName(), '.'),
-                interfaceNames);
-          }
-        }
-        if (nestedTypeIndex == typeNames.length) {
-          // need a resize
-          System.arraycopy(typeNames, 0, (typeNames = new char[nestedTypeIndex * 2][]), 0, nestedTypeIndex);
-          System.arraycopy(superTypeNames, 0, (superTypeNames = new char[nestedTypeIndex * 2][]), 0, nestedTypeIndex);
-        }
-        typeNames[nestedTypeIndex] = typeDeclaration.name;
-        superTypeNames[nestedTypeIndex++] = superclass == null ? JAVA_LANG_OBJECT : CharOperation.concatWith(superclass
-            .getTypeName(), '.');
-      }
-    }
-    while ((fieldIndex < fieldCount) || (memberTypeIndex < memberTypeCount) || (methodIndex < methodCount)) {
-      FieldDeclaration nextFieldDeclaration = null;
-      AbstractMethodDeclaration nextMethodDeclaration = null;
-      TypeDeclaration nextMemberDeclaration = null;
+               try {
+                       // diet = true;
+                       CompilationResult compilationUnitResult = new CompilationResult(
+                                       unit, 0, 0, 10); // this.options.maxProblemsPerUnit);
+                       CompilationUnitDeclaration parsedUnit = parse(unit,
+                                       compilationUnitResult, start, end);
+                       // if (scanner.recordLineSeparator) {
+                       // requestor.acceptLineSeparatorPositions(scanner.getLineEnds());
+                       // }
+                       // if (this.localDeclarationVisitor != null || needReferenceInfo){
+                       // diet = false;
+                       // this.getMethodBodies(parsedUnit);
+                       // }
+                       // this.scanner.resetTo(start, end);
+                       // notifySourceElementRequestor(parsedUnit);
+               } catch (AbortCompilation e) {
+               } finally {
+                       // diet = old;
+               }
+       }
 
-      int position = Integer.MAX_VALUE;
-      int nextDeclarationType = -1;
-      if (fieldIndex < fieldCount) {
-        nextFieldDeclaration = fields[fieldIndex];
-        if (nextFieldDeclaration.declarationSourceStart < position) {
-          position = nextFieldDeclaration.declarationSourceStart;
-          nextDeclarationType = 0; // FIELD
-        }
-      }
-      if (methodIndex < methodCount) {
-        nextMethodDeclaration = methods[methodIndex];
-        if (nextMethodDeclaration.declarationSourceStart < position) {
-          position = nextMethodDeclaration.declarationSourceStart;
-          nextDeclarationType = 1; // METHOD
-        }
-      }
-      if (memberTypeIndex < memberTypeCount) {
-        nextMemberDeclaration = memberTypes[memberTypeIndex];
-        if (nextMemberDeclaration.declarationSourceStart < position) {
-          position = nextMemberDeclaration.declarationSourceStart;
-          nextDeclarationType = 2; // MEMBER
-        }
-      }
-      switch (nextDeclarationType) {
-        case 0 :
-          fieldIndex++;
-          notifySourceElementRequestor(nextFieldDeclaration);
-          break;
-        case 1 :
-          methodIndex++;
-          notifySourceElementRequestor(nextMethodDeclaration);
-          break;
-        case 2 :
-          memberTypeIndex++;
-          notifySourceElementRequestor(nextMemberDeclaration, true);
-      }
-    }
-    if (notifyTypePresence) {
-      if (isInRange) {
-        if (isInterface) {
-          requestor.exitInterface(typeDeclaration.declarationSourceEnd);
-        } else {
-          requestor.exitClass(typeDeclaration.declarationSourceEnd);
-        }
-      }
-      nestedTypeIndex--;
-    }
-  }
-  public void parseCompilationUnit(ICompilationUnit unit, int start, int end) {
-    // boolean needReferenceInfo) {
+       public CompilationUnitDeclaration parseCompilationUnit(
+                       ICompilationUnit unit, boolean fullParse) {
 
-    // reportReferenceInfo = needReferenceInfo;
-    // boolean old = diet;
-    // if (needReferenceInfo) {
-    //         unknownRefs = new NameReference[10];
-    //         unknownRefsCounter = 0;
-    // }
+               // boolean old = diet;
+               // if (fullParse) {
+               // unknownRefs = new NameReference[10];
+               // unknownRefsCounter = 0;
+               // }
 
-    try {
-      //               diet = true;
-      CompilationResult compilationUnitResult = new CompilationResult(unit, 0, 0, 10); //this.options.maxProblemsPerUnit);
-      CompilationUnitDeclaration parsedUnit = parse(unit, compilationUnitResult, start, end);
-      //               if (scanner.recordLineSeparator) {
-      //                       requestor.acceptLineSeparatorPositions(scanner.getLineEnds());
-      //               }
-      //               if (this.localDeclarationVisitor != null || needReferenceInfo){
-      //                       diet = false;
-      //                       this.getMethodBodies(parsedUnit);
-      //               }
-      //               this.scanner.resetTo(start, end);
-      //               notifySourceElementRequestor(parsedUnit);
-    } catch (AbortCompilation e) {
-    } finally {
-      //               diet = old;
-    }
-  }
-  public CompilationUnitDeclaration parseCompilationUnit(ICompilationUnit unit, boolean fullParse) {
+               try {
+                       // diet = true;
+                       this.reportReferenceInfo = fullParse;
+                       CompilationResult compilationUnitResult = new CompilationResult(
+                                       unit, 0, 0, this.options.maxProblemsPerUnit);
+                       CompilationUnitDeclaration parsedUnit = parse(unit,
+                                       compilationUnitResult, false);
+                       if (scanner.recordLineSeparator) {
+                               requestor.acceptLineSeparatorPositions(scanner.getLineEnds());
+                       }
+                       int initialStart = this.scanner.initialPosition;
+                       int initialEnd = this.scanner.eofPosition;
+                       // if (this.localDeclarationVisitor != null || fullParse){
+                       // diet = false;
+                       // this.getMethodBodies(parsedUnit);
+                       // }
+                       this.scanner.resetTo(initialStart, initialEnd);
+                       notifySourceElementRequestor(parsedUnit);
+                       return parsedUnit;
+               } catch (AbortCompilation e) {
+                       // ignore this exception
+               } finally {
+                       // diet = old;
+               }
+               return null;
+       }
 
-    //         boolean old = diet;
-    //         if (fullParse) {
-    //                 unknownRefs = new NameReference[10];
-    //                 unknownRefsCounter = 0;
-    //         }
+       public CompilationUnitDeclaration parseCompletionUnit(
+                       ICompilationUnit unit, boolean fullParse) {
 
-    try {
-      //                       diet = true;
-      this.reportReferenceInfo = fullParse;
-      CompilationResult compilationUnitResult = new CompilationResult(unit, 0, 0, this.options.maxProblemsPerUnit);
-      CompilationUnitDeclaration parsedUnit = parse(unit, compilationUnitResult, false);
-      if (scanner.recordLineSeparator) {
-        requestor.acceptLineSeparatorPositions(scanner.getLineEnds());
-      }
-      int initialStart = this.scanner.initialPosition;
-      int initialEnd = this.scanner.eofPosition;
-      //                       if (this.localDeclarationVisitor != null || fullParse){
-      //                               diet = false;
-      //                               this.getMethodBodies(parsedUnit);
-      //                       }
-      this.scanner.resetTo(initialStart, initialEnd);
-      notifySourceElementRequestor(parsedUnit);
-      return parsedUnit;
-    } catch (AbortCompilation e) {
-      // ignore this exception
-    } finally {
-      //                       diet = old;
-    }
-    return null;
-  }
+               // boolean old = diet;
+               // if (fullParse) {
+               // unknownRefs = new NameReference[10];
+               // unknownRefsCounter = 0;
+               // }
 
-  public CompilationUnitDeclaration parseCompletionUnit(ICompilationUnit unit, boolean fullParse) {
+               try {
+                       // diet = true;
+                       this.reportReferenceInfo = fullParse;
+                       CompilationResult compilationUnitResult = new CompilationResult(
+                                       unit, 0, 0, this.options.maxProblemsPerUnit);
+                       CompilationUnitDeclaration parsedUnit = parse(unit,
+                                       compilationUnitResult, false);
+                       // if (scanner.recordLineSeparator) {
+                       // requestor.acceptLineSeparatorPositions(scanner.getLineEnds());
+                       // }
+                       // int initialStart = this.scanner.initialPosition;
+                       // int initialEnd = this.scanner.eofPosition;
+                       // // if (this.localDeclarationVisitor != null || fullParse){
+                       // // diet = false;
+                       // // this.getMethodBodies(parsedUnit);
+                       // // }
+                       // this.scanner.resetTo(initialStart, initialEnd);
+                       // notifySourceElementRequestor(parsedUnit);
+                       return parsedUnit;
+               } catch (AbortCompilation e) {
+                       // ignore this exception
+               } finally {
+                       // diet = old;
+               }
+               return null;
+       }
 
-    //         boolean old = diet;
-    //         if (fullParse) {
-    //                 unknownRefs = new NameReference[10];
-    //                 unknownRefsCounter = 0;
-    //         }
+       // public void parseTypeMemberDeclarations(
+       // ISourceType sourceType,
+       // ICompilationUnit sourceUnit,
+       // int start,
+       // int end,
+       // boolean needReferenceInfo) {
+       // boolean old = diet;
+       // if (needReferenceInfo) {
+       // unknownRefs = new NameReference[10];
+       // unknownRefsCounter = 0;
+       // }
+       //      
+       // try {
+       // diet = !needReferenceInfo;
+       // reportReferenceInfo = needReferenceInfo;
+       // CompilationResult compilationUnitResult =
+       // new CompilationResult(sourceUnit, 0, 0, this.options.maxProblemsPerUnit);
+       // CompilationUnitDeclaration unit =
+       // SourceTypeConverter.buildCompilationUnit(
+       // new ISourceType[]{sourceType},
+       // false, // no need for field and methods
+       // false, // no need for member types
+       // false, // no need for field initialization
+       // problemReporter(),
+       // compilationUnitResult);
+       // if ((unit == null) || (unit.types == null) || (unit.types.length != 1))
+       // return;
+       // this.sourceType = sourceType;
+       // try {
+       // /* automaton initialization */
+       // initialize();
+       // goForClassBodyDeclarations();
+       // /* scanner initialization */
+       // scanner.setSource(sourceUnit.getContents());
+       // scanner.resetTo(start, end);
+       // /* unit creation */
+       // referenceContext = compilationUnit = unit;
+       // /* initialize the astStacl */
+       // // the compilationUnitDeclaration should contain exactly one type
+       // pushOnAstStack(unit.types[0]);
+       // /* run automaton */
+       // parse();
+       // notifySourceElementRequestor(unit);
+       // } finally {
+       // unit = compilationUnit;
+       // compilationUnit = null; // reset parser
+       // }
+       // } catch (AbortCompilation e) {
+       // } finally {
+       // if (scanner.recordLineSeparator) {
+       // requestor.acceptLineSeparatorPositions(scanner.getLineEnds());
+       // }
+       // diet = old;
+       // }
+       // }
+       //
+       // public void parseTypeMemberDeclarations(
+       // char[] contents,
+       // int start,
+       // int end) {
+       //
+       // boolean old = diet;
+       //      
+       // try {
+       // diet = true;
+       //
+       // /* automaton initialization */
+       // initialize();
+       // goForClassBodyDeclarations();
+       // /* scanner initialization */
+       // scanner.setSource(contents);
+       // scanner.recordLineSeparator = false;
+       // scanner.taskTags = null;
+       // scanner.taskPriorities = null;
+       // scanner.resetTo(start, end);
+       //
+       // /* unit creation */
+       // referenceContext = null;
+       //
+       // /* initialize the astStacl */
+       // // the compilationUnitDeclaration should contain exactly one type
+       // /* run automaton */
+       // parse();
+       // notifySourceElementRequestor((CompilationUnitDeclaration)null);
+       // } catch (AbortCompilation e) {
+       // } finally {
+       // diet = old;
+       // }
+       // }
+       /**
+        * Sort the given ast nodes by their positions.
+        */
+       private static void quickSort(ASTNode[] sortedCollection, int left,
+                       int right) {
+               int original_left = left;
+               int original_right = right;
+               ASTNode mid = sortedCollection[(left + right) / 2];
+               do {
+                       while (sortedCollection[left].sourceStart < mid.sourceStart) {
+                               left++;
+                       }
+                       while (mid.sourceStart < sortedCollection[right].sourceStart) {
+                               right--;
+                       }
+                       if (left <= right) {
+                               ASTNode tmp = sortedCollection[left];
+                               sortedCollection[left] = sortedCollection[right];
+                               sortedCollection[right] = tmp;
+                               left++;
+                               right--;
+                       }
+               } while (left <= right);
+               if (original_left < right) {
+                       quickSort(sortedCollection, original_left, right);
+               }
+               if (left < original_right) {
+                       quickSort(sortedCollection, left, original_right);
+               }
+       }
 
-    try {
-      //                       diet = true;
-      this.reportReferenceInfo = fullParse;
-      CompilationResult compilationUnitResult = new CompilationResult(unit, 0, 0, this.options.maxProblemsPerUnit);
-      CompilationUnitDeclaration parsedUnit = parse(unit, compilationUnitResult, false);
-//      if (scanner.recordLineSeparator) {
-//        requestor.acceptLineSeparatorPositions(scanner.getLineEnds());
-//      }
-//      int initialStart = this.scanner.initialPosition;
-//      int initialEnd = this.scanner.eofPosition;
-//      //                     if (this.localDeclarationVisitor != null || fullParse){
-//      //                             diet = false;
-//      //                             this.getMethodBodies(parsedUnit);
-//      //                     }
-//      this.scanner.resetTo(initialStart, initialEnd);
-//      notifySourceElementRequestor(parsedUnit);
-      return parsedUnit;
-    } catch (AbortCompilation e) {
-      // ignore this exception
-    } finally {
-      //                       diet = old;
-    }
-    return null;
-  }
-  //public void parseTypeMemberDeclarations(
-  //   ISourceType sourceType,
-  //   ICompilationUnit sourceUnit,
-  //   int start,
-  //   int end,
-  //   boolean needReferenceInfo) {
-  //   boolean old = diet;
-  //   if (needReferenceInfo) {
-  //           unknownRefs = new NameReference[10];
-  //           unknownRefsCounter = 0;
-  //   }
-  //   
-  //   try {
-  //           diet = !needReferenceInfo;
-  //           reportReferenceInfo = needReferenceInfo;
-  //           CompilationResult compilationUnitResult =
-  //                   new CompilationResult(sourceUnit, 0, 0, this.options.maxProblemsPerUnit);
-  //           CompilationUnitDeclaration unit =
-  //                   SourceTypeConverter.buildCompilationUnit(
-  //                           new ISourceType[]{sourceType},
-  //                           false, // no need for field and methods
-  //                           false, // no need for member types
-  //                           false, // no need for field initialization
-  //                           problemReporter(),
-  //                           compilationUnitResult);
-  //           if ((unit == null) || (unit.types == null) || (unit.types.length != 1))
-  //                   return;
-  //           this.sourceType = sourceType;
-  //           try {
-  //                   /* automaton initialization */
-  //                   initialize();
-  //                   goForClassBodyDeclarations();
-  //                   /* scanner initialization */
-  //                   scanner.setSource(sourceUnit.getContents());
-  //                   scanner.resetTo(start, end);
-  //                   /* unit creation */
-  //                   referenceContext = compilationUnit = unit;
-  //                   /* initialize the astStacl */
-  //                   // the compilationUnitDeclaration should contain exactly one type
-  //                   pushOnAstStack(unit.types[0]);
-  //                   /* run automaton */
-  //                   parse();
-  //                   notifySourceElementRequestor(unit);
-  //           } finally {
-  //                   unit = compilationUnit;
-  //                   compilationUnit = null; // reset parser
-  //           }
-  //   } catch (AbortCompilation e) {
-  //   } finally {
-  //           if (scanner.recordLineSeparator) {
-  //                   requestor.acceptLineSeparatorPositions(scanner.getLineEnds());
-  //           }
-  //           diet = old;
-  //   }
-  //}
-  //
-  //public void parseTypeMemberDeclarations(
-  //   char[] contents,
-  //   int start,
-  //   int end) {
-  //
-  //   boolean old = diet;
-  //   
-  //   try {
-  //           diet = true;
-  //
-  //           /* automaton initialization */
-  //           initialize();
-  //           goForClassBodyDeclarations();
-  //           /* scanner initialization */
-  //           scanner.setSource(contents);
-  //           scanner.recordLineSeparator = false;
-  //           scanner.taskTags = null;
-  //           scanner.taskPriorities = null;
-  //           scanner.resetTo(start, end);
-  //
-  //           /* unit creation */
-  //           referenceContext = null;
-  //
-  //           /* initialize the astStacl */
-  //           // the compilationUnitDeclaration should contain exactly one type
-  //           /* run automaton */
-  //           parse();
-  //           notifySourceElementRequestor((CompilationUnitDeclaration)null);
-  //   } catch (AbortCompilation e) {
-  //   } finally {
-  //           diet = old;
-  //   }
-  //}
-  /**
-   * Sort the given ast nodes by their positions.
-   */
-  private static void quickSort(ASTNode[] sortedCollection, int left, int right) {
-    int original_left = left;
-    int original_right = right;
-    ASTNode mid = sortedCollection[(left + right) / 2];
-    do {
-      while (sortedCollection[left].sourceStart < mid.sourceStart) {
-        left++;
-      }
-      while (mid.sourceStart < sortedCollection[right].sourceStart) {
-        right--;
-      }
-      if (left <= right) {
-        ASTNode tmp = sortedCollection[left];
-        sortedCollection[left] = sortedCollection[right];
-        sortedCollection[right] = tmp;
-        left++;
-        right--;
-      }
-    } while (left <= right);
-    if (original_left < right) {
-      quickSort(sortedCollection, original_left, right);
-    }
-    if (left < original_right) {
-      quickSort(sortedCollection, left, original_right);
-    }
-  }
-  /*
-   * Answer a char array representation of the type name formatted like: - type
-   * name + dimensions Example: "A[][]".toCharArray()
-   * "java.lang.String".toCharArray()
-   */
-  private char[] returnTypeName(TypeReference type) {
-    if (type == null)
-      return null;
-    int dimension = type.dimensions();
-    if (dimension != 0) {
-      char[] dimensionsArray = new char[dimension * 2];
-      for (int i = 0; i < dimension; i++) {
-        dimensionsArray[i * 2] = '[';
-        dimensionsArray[(i * 2) + 1] = ']';
-      }
-      return CharOperation.concat(CharOperation.concatWith(type.getTypeName(), '.'), dimensionsArray);
-    }
-    return CharOperation.concatWith(type.getTypeName(), '.');
-  }
+       /*
+        * Answer a char array representation of the type name formatted like: -
+        * type name + dimensions Example: "A[][]".toCharArray()
+        * "java.lang.String".toCharArray()
+        */
+       private char[] returnTypeName(TypeReference type) {
+               if (type == null)
+                       return null;
+               int dimension = type.dimensions();
+               if (dimension != 0) {
+                       char[] dimensionsArray = new char[dimension * 2];
+                       for (int i = 0; i < dimension; i++) {
+                               dimensionsArray[i * 2] = '[';
+                               dimensionsArray[(i * 2) + 1] = ']';
+                       }
+                       return CharOperation.concat(CharOperation.concatWith(type
+                                       .getTypeName(), '.'), dimensionsArray);
+               }
+               return CharOperation.concatWith(type.getTypeName(), '.');
+       }
 
-  public void addUnknownRef(NameReference nameRef) {
-    if (this.unknownRefs.length == this.unknownRefsCounter) {
-      // resize
-      System.arraycopy(this.unknownRefs, 0, (this.unknownRefs = new NameReference[this.unknownRefsCounter * 2]), 0,
-          this.unknownRefsCounter);
-    }
-    this.unknownRefs[this.unknownRefsCounter++] = nameRef;
-  }
+       public void addUnknownRef(NameReference nameRef) {
+               if (this.unknownRefs.length == this.unknownRefsCounter) {
+                       // resize
+                       System
+                                       .arraycopy(
+                                                       this.unknownRefs,
+                                                       0,
+                                                       (this.unknownRefs = new NameReference[this.unknownRefsCounter * 2]),
+                                                       0, this.unknownRefsCounter);
+               }
+               this.unknownRefs[this.unknownRefsCounter++] = nameRef;
+       }
 
-  private void visitIfNeeded(AbstractMethodDeclaration method) {
-    if (this.localDeclarationVisitor != null && (method.bits & ASTNode.HasLocalTypeMASK) != 0) {
-      if (method.statements != null) {
-        int statementsLength = method.statements.length;
-        for (int i = 0; i < statementsLength; i++)
-          method.statements[i].traverse(this.localDeclarationVisitor, method.scope);
-      }
-    }
-  }
+       private void visitIfNeeded(AbstractMethodDeclaration method) {
+               if (this.localDeclarationVisitor != null
+                               && (method.bits & ASTNode.HasLocalTypeMASK) != 0) {
+                       if (method.statements != null) {
+                               int statementsLength = method.statements.length;
+                               for (int i = 0; i < statementsLength; i++)
+                                       method.statements[i].traverse(this.localDeclarationVisitor,
+                                                       method.scope);
+                       }
+               }
+       }
 
-  //private void visitIfNeeded(FieldDeclaration field) {
-  //   if (this.localDeclarationVisitor != null
-  //           && (field.bits & ASTNode.HasLocalTypeMASK) != 0) {
-  //                   if (field.initialization != null) {
-  //                           field.initialization.traverse(this.localDeclarationVisitor, null);
-  //                   }
-  //   }
-  //}
-  //
-  //private void visitIfNeeded(Initializer initializer) {
-  //   if (this.localDeclarationVisitor != null
-  //           && (initializer.bits & ASTNode.HasLocalTypeMASK) != 0) {
-  //                   if (initializer.block != null) {
-  //                           initializer.block.traverse(this.localDeclarationVisitor, null);
-  //                   }
-  //   }
-  //}
-  //
-  //protected void reportSyntaxError(int act, int currentKind, int
-  // stateStackTop) {
-  //   if (compilationUnit == null) return;
-  //   super.reportSyntaxError(act, currentKind,stateStackTop);
-  //}
-  protected CompilationUnitDeclaration endParse(int act) {
-    // if (sourceType != null) {
-    //         if (sourceType.isInterface()) {
-    //                 consumeInterfaceDeclaration();
-    //         } else {
-    //                 consumeClassDeclaration();
-    //         }
-    // }
-    if (compilationUnit != null) {
-      CompilationUnitDeclaration result = super.endParse(act);
-      return result;
-    } else {
-      return null;
-    }
-  }
+       // private void visitIfNeeded(FieldDeclaration field) {
+       // if (this.localDeclarationVisitor != null
+       // && (field.bits & ASTNode.HasLocalTypeMASK) != 0) {
+       // if (field.initialization != null) {
+       // field.initialization.traverse(this.localDeclarationVisitor, null);
+       // }
+       // }
+       // }
+       //
+       // private void visitIfNeeded(Initializer initializer) {
+       // if (this.localDeclarationVisitor != null
+       // && (initializer.bits & ASTNode.HasLocalTypeMASK) != 0) {
+       // if (initializer.block != null) {
+       // initializer.block.traverse(this.localDeclarationVisitor, null);
+       // }
+       // }
+       // }
+       //
+       // protected void reportSyntaxError(int act, int currentKind, int
+       // stateStackTop) {
+       // if (compilationUnit == null) return;
+       // super.reportSyntaxError(act, currentKind,stateStackTop);
+       // }
+       protected CompilationUnitDeclaration endParse(int act) {
+               // if (sourceType != null) {
+               // if (sourceType.isInterface()) {
+               // consumeInterfaceDeclaration();
+               // } else {
+               // consumeClassDeclaration();
+               // }
+               // }
+               if (compilationUnit != null) {
+                       CompilationUnitDeclaration result = super.endParse(act);
+                       return result;
+               } else {
+                       return null;
+               }
+       }
 }
\ No newline at end of file