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
git://secure.phpeclipse.com / phpeclipse.git / blobdiff