return adviceDecl;
}
- public ASTNode convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration methodDeclaration) {
- checkCanceled();
- if (methodDeclaration instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.AnnotationMethodDeclaration) {
- return convert((org.aspectj.org.eclipse.jdt.internal.compiler.ast.AnnotationMethodDeclaration) methodDeclaration);
- }
- MethodDeclaration methodDecl = new MethodDeclaration(this.ast);
- boolean isConstructor = methodDeclaration.isConstructor();
- methodDecl.setConstructor(isConstructor);
-
- // //////////////// ajh02: added. ugh, polymorphism! Where are you!
- if (methodDeclaration instanceof DeclareDeclaration) {
- return convert((DeclareDeclaration) methodDeclaration);
- } else if (methodDeclaration instanceof InterTypeFieldDeclaration) {
- return convert((InterTypeFieldDeclaration) methodDeclaration);
- } else if (methodDeclaration instanceof InterTypeMethodDeclaration) {
- methodDecl = new org.aspectj.org.eclipse.jdt.core.dom.InterTypeMethodDeclaration(this.ast);
- ((org.aspectj.org.eclipse.jdt.core.dom.InterTypeMethodDeclaration) methodDecl)
- .setOnType(((InterTypeMethodDeclaration) methodDeclaration).getOnType().toString());
- } else if (methodDeclaration instanceof InterTypeConstructorDeclaration) {
- methodDecl = new org.aspectj.org.eclipse.jdt.core.dom.InterTypeMethodDeclaration(this.ast);
- ((org.aspectj.org.eclipse.jdt.core.dom.InterTypeMethodDeclaration) methodDecl)
- .setOnType(((InterTypeConstructorDeclaration) methodDeclaration).getOnType().toString());
- methodDecl.setConstructor(true);
- } else if (methodDeclaration instanceof PointcutDeclaration) {
- return convert((PointcutDeclaration) methodDeclaration);
- } else if (methodDeclaration instanceof AdviceDeclaration) {
- return convert((AdviceDeclaration) methodDeclaration);
- }
- // ///////////////////////
-
- // set modifiers after checking whether we're an itd, otherwise
- // the modifiers are not set on the correct object.
- setModifiers(methodDecl, methodDeclaration);
-
- // for ITD's use the declaredSelector
- final SimpleName methodName = new SimpleName(this.ast);
- if (methodDeclaration instanceof InterTypeDeclaration) {
- InterTypeDeclaration itd = (InterTypeDeclaration) methodDeclaration;
- methodName.internalSetIdentifier(new String(itd.getDeclaredSelector()));
- } else {
- methodName.internalSetIdentifier(new String(methodDeclaration.selector));
- }
- int start = methodDeclaration.sourceStart;
- int end = retrieveIdentifierEndPosition(start, methodDeclaration.sourceEnd);
- methodName.setSourceRange(start, end - start + 1);
- methodDecl.setName(methodName);
-
- org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeReference[] thrownExceptions = methodDeclaration.thrownExceptions;
- if (thrownExceptions != null) {
- int thrownExceptionsLength = thrownExceptions.length;
- for (int i = 0; i < thrownExceptionsLength; i++) {
- methodDecl.thrownExceptions().add(convert(thrownExceptions[i]));
- }
- }
- org.aspectj.org.eclipse.jdt.internal.compiler.ast.Argument[] parameters = methodDeclaration.arguments;
- if (parameters != null) {
- int parametersLength = parameters.length;
- for (int i = 0; i < parametersLength; i++) {
- methodDecl.parameters().add(convert(parameters[i]));
- }
- }
- org.aspectj.org.eclipse.jdt.internal.compiler.ast.ExplicitConstructorCall explicitConstructorCall = null;
- if (isConstructor) {
- org.aspectj.org.eclipse.jdt.internal.compiler.ast.ConstructorDeclaration constructorDeclaration = (org.aspectj.org.eclipse.jdt.internal.compiler.ast.ConstructorDeclaration) methodDeclaration;
- explicitConstructorCall = constructorDeclaration.constructorCall;
- switch (this.ast.apiLevel) {
- case AST.JLS2_INTERNAL:
- // set the return type to VOID
- PrimitiveType returnType = new PrimitiveType(this.ast);
- returnType.setPrimitiveTypeCode(PrimitiveType.VOID);
- returnType.setSourceRange(methodDeclaration.sourceStart, 0);
- methodDecl.internalSetReturnType(returnType);
- break;
- case AST.JLS3:
- methodDecl.setReturnType2(null);
- }
- } else if (methodDeclaration instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.MethodDeclaration) {
- org.aspectj.org.eclipse.jdt.internal.compiler.ast.MethodDeclaration method = (org.aspectj.org.eclipse.jdt.internal.compiler.ast.MethodDeclaration) methodDeclaration;
- org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeReference typeReference = method.returnType;
- if (typeReference != null) {
- Type returnType = convertType(typeReference);
- // get the positions of the right parenthesis
- int rightParenthesisPosition = retrieveEndOfRightParenthesisPosition(end, method.bodyEnd);
- int extraDimensions = retrieveExtraDimension(rightParenthesisPosition, method.bodyEnd);
- methodDecl.setExtraDimensions(extraDimensions);
- setTypeForMethodDeclaration(methodDecl, returnType, extraDimensions);
- }
- }
- int declarationSourceStart = methodDeclaration.declarationSourceStart;
- int declarationSourceEnd = methodDeclaration.bodyEnd;
- methodDecl.setSourceRange(declarationSourceStart, declarationSourceEnd - declarationSourceStart + 1);
- int closingPosition = retrieveRightBraceOrSemiColonPosition(methodDeclaration.bodyEnd + 1,
- methodDeclaration.declarationSourceEnd);
- if (closingPosition != -1) {
- int startPosition = methodDecl.getStartPosition();
- methodDecl.setSourceRange(startPosition, closingPosition - startPosition + 1);
-
- org.aspectj.org.eclipse.jdt.internal.compiler.ast.Statement[] statements = methodDeclaration.statements;
-
- start = retrieveStartBlockPosition(methodDeclaration.sourceStart, declarationSourceEnd);
- end = retrieveEndBlockPosition(methodDeclaration.sourceStart, methodDeclaration.declarationSourceEnd);
- Block block = null;
- if (start != -1 && end != -1) {
- /*
- * start or end can be equal to -1 if we have an interface's method.
- */
- block = new Block(this.ast);
- block.setSourceRange(start, end - start + 1);
- methodDecl.setBody(block);
+ //public ASTNode convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration methodDeclaration) {
+ public ASTNode convert(boolean isInterface, org.aspectj.org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration methodDeclaration) {
+ checkCanceled();
+ if (methodDeclaration instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.AnnotationMethodDeclaration) {
+ return convert((org.aspectj.org.eclipse.jdt.internal.compiler.ast.AnnotationMethodDeclaration) methodDeclaration);
+ }
+ MethodDeclaration methodDecl = new MethodDeclaration(this.ast);
+ boolean isConstructor = methodDeclaration.isConstructor();
+ methodDecl.setConstructor(isConstructor);
+
+ // //////////////// ajh02: added. ugh, polymorphism! Where are you!
+ if (methodDeclaration instanceof DeclareDeclaration) {
+ return convert((DeclareDeclaration) methodDeclaration);
+ } else if (methodDeclaration instanceof InterTypeFieldDeclaration) {
+ return convert((InterTypeFieldDeclaration) methodDeclaration);
+ } else if (methodDeclaration instanceof InterTypeMethodDeclaration) {
+ methodDecl = new org.aspectj.org.eclipse.jdt.core.dom.InterTypeMethodDeclaration(this.ast);
+ ((org.aspectj.org.eclipse.jdt.core.dom.InterTypeMethodDeclaration) methodDecl)
+ .setOnType(((InterTypeMethodDeclaration) methodDeclaration).getOnType().toString());
+ } else if (methodDeclaration instanceof InterTypeConstructorDeclaration) {
+ methodDecl = new org.aspectj.org.eclipse.jdt.core.dom.InterTypeMethodDeclaration(this.ast);
+ ((org.aspectj.org.eclipse.jdt.core.dom.InterTypeMethodDeclaration) methodDecl)
+ .setOnType(((InterTypeConstructorDeclaration) methodDeclaration).getOnType().toString());
+ methodDecl.setConstructor(true);
+ } else if (methodDeclaration instanceof PointcutDeclaration) {
+ return convert((PointcutDeclaration) methodDeclaration);
+ } else if (methodDeclaration instanceof AdviceDeclaration) {
+ return convert((AdviceDeclaration) methodDeclaration);
+ }
+ // ///////////////////////
+
+ // set modifiers after checking whether we're an itd, otherwise
+ // the modifiers are not set on the correct object.
+ setModifiers(methodDecl, methodDeclaration);
+ final SimpleName methodName = new SimpleName(this.ast);
+ // AspectJ Extension - for ITD's use the declaredSelector
+ if (methodDeclaration instanceof InterTypeDeclaration) {
+ InterTypeDeclaration itd = (InterTypeDeclaration) methodDeclaration;
+ methodName.internalSetIdentifier(new String(itd.getDeclaredSelector()));
+ } else {
+ methodName.internalSetIdentifier(new String(methodDeclaration.selector));
+ }
+ // AspectJ Extension end
+ int start = methodDeclaration.sourceStart;
+ int end = retrieveIdentifierEndPosition(start, methodDeclaration.sourceEnd);
+ methodName.setSourceRange(start, end - start + 1);
+ methodDecl.setName(methodName);
+ org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeReference[] thrownExceptions = methodDeclaration.thrownExceptions;
+ int methodHeaderEnd = methodDeclaration.sourceEnd;
+ int thrownExceptionsLength = thrownExceptions == null ? 0 : thrownExceptions.length;
+ if (thrownExceptionsLength > 0) {
+ Name thrownException;
+ int i = 0;
+ do {
+ thrownException = convert(thrownExceptions[i++]);
+ methodDecl.thrownExceptions().add(thrownException);
+ } while (i < thrownExceptionsLength);
+ methodHeaderEnd = thrownException.getStartPosition() + thrownException.getLength();
+ }
+ org.aspectj.org.eclipse.jdt.internal.compiler.ast.Argument[] parameters = methodDeclaration.arguments;
+ int parametersLength = parameters == null ? 0 : parameters.length;
+ if (parametersLength > 0) {
+ SingleVariableDeclaration parameter;
+ int i = 0;
+ do {
+ parameter = convert(parameters[i++]);
+ methodDecl.parameters().add(parameter);
+ } while (i < parametersLength);
+ if (thrownExceptionsLength == 0) {
+ methodHeaderEnd = parameter.getStartPosition() + parameter.getLength();
+ }
}
- if (block != null && (statements != null || explicitConstructorCall != null)) {
- if (explicitConstructorCall != null
- && explicitConstructorCall.accessMode != org.aspectj.org.eclipse.jdt.internal.compiler.ast.ExplicitConstructorCall.ImplicitSuper) {
- block.statements().add(super.convert(explicitConstructorCall));
+ org.aspectj.org.eclipse.jdt.internal.compiler.ast.ExplicitConstructorCall explicitConstructorCall = null;
+ if (isConstructor) {
+ if (isInterface) {
+ // interface cannot have a constructor
+ methodDecl.setFlags(methodDecl.getFlags() | ASTNode.MALFORMED);
}
- int statementsLength = statements == null ? 0 : statements.length;
- for (int i = 0; i < statementsLength; i++) {
- if (statements[i] instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.LocalDeclaration) {
- checkAndAddMultipleLocalDeclaration(statements, i, block.statements());
- } else {
- block.statements().add(convert(statements[i]));
- }
+ org.aspectj.org.eclipse.jdt.internal.compiler.ast.ConstructorDeclaration constructorDeclaration = (org.aspectj.org.eclipse.jdt.internal.compiler.ast.ConstructorDeclaration) methodDeclaration;
+ explicitConstructorCall = constructorDeclaration.constructorCall;
+ switch(this.ast.apiLevel) {
+ case AST.JLS2_INTERNAL :
+ // set the return type to VOID
+ PrimitiveType returnType = new PrimitiveType(this.ast);
+ returnType.setPrimitiveTypeCode(PrimitiveType.VOID);
+ returnType.setSourceRange(methodDeclaration.sourceStart, 0);
+ methodDecl.internalSetReturnType(returnType);
+ break;
+ default :
+ methodDecl.setReturnType2(null);
}
- }
- if (block != null && (Modifier.isAbstract(methodDecl.getModifiers()) || Modifier.isNative(methodDecl.getModifiers()))) {
- methodDecl.setFlags(methodDecl.getFlags() | ASTNode.MALFORMED);
- }
- } else {
- // syntax error in this method declaration
- if (!methodDeclaration.isNative() && !methodDeclaration.isAbstract()) {
- start = retrieveStartBlockPosition(methodDeclaration.sourceStart, declarationSourceEnd);
- end = methodDeclaration.bodyEnd;
- // try to get the best end position
- IProblem[] problems = methodDeclaration.compilationResult().problems;
- if (problems != null) {
- for (int i = 0, max = methodDeclaration.compilationResult().problemCount; i < max; i++) {
- IProblem currentProblem = problems[i];
- if (currentProblem.getSourceStart() == start
- && currentProblem.getID() == IProblem.ParsingErrorInsertToComplete) {
- end = currentProblem.getSourceEnd();
+ } else if (methodDeclaration instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.MethodDeclaration) {
+ org.aspectj.org.eclipse.jdt.internal.compiler.ast.MethodDeclaration method = (org.aspectj.org.eclipse.jdt.internal.compiler.ast.MethodDeclaration) methodDeclaration;
+ org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeReference typeReference = method.returnType;
+ if (typeReference != null) {
+ Type returnType = convertType(typeReference);
+ // get the positions of the right parenthesis
+ int rightParenthesisPosition = retrieveEndOfRightParenthesisPosition(end, method.bodyEnd);
+ int extraDimensions = retrieveExtraDimension(rightParenthesisPosition, method.bodyEnd);
+ methodDecl.setExtraDimensions(extraDimensions);
+ setTypeForMethodDeclaration(methodDecl, returnType, extraDimensions);
+ } else {
+ // no return type for a method that is not a constructor
+ methodDecl.setFlags(methodDecl.getFlags() | ASTNode.MALFORMED);
+ switch(this.ast.apiLevel) {
+ case AST.JLS2_INTERNAL :
break;
- }
+ default :
+ methodDecl.setReturnType2(null);
}
}
+ }
+ int declarationSourceStart = methodDeclaration.declarationSourceStart;
+ int bodyEnd = methodDeclaration.bodyEnd;
+ methodDecl.setSourceRange(declarationSourceStart, bodyEnd - declarationSourceStart + 1);
+ int declarationSourceEnd = methodDeclaration.declarationSourceEnd;
+ int rightBraceOrSemiColonPositionStart = bodyEnd == declarationSourceEnd ? bodyEnd : bodyEnd + 1;
+ int closingPosition = retrieveRightBraceOrSemiColonPosition(rightBraceOrSemiColonPositionStart, declarationSourceEnd);
+ if (closingPosition != -1) {
int startPosition = methodDecl.getStartPosition();
- methodDecl.setSourceRange(startPosition, end - startPosition + 1);
+ methodDecl.setSourceRange(startPosition, closingPosition - startPosition + 1);
+
+ org.aspectj.org.eclipse.jdt.internal.compiler.ast.Statement[] statements = methodDeclaration.statements;
+
+ start = retrieveStartBlockPosition(methodHeaderEnd, methodDeclaration.bodyStart);
+ if (start == -1) start = methodDeclaration.bodyStart; // use recovery position for body start
+ end = retrieveRightBrace(methodDeclaration.bodyEnd, declarationSourceEnd);
+ Block block = null;
if (start != -1 && end != -1) {
/*
* start or end can be equal to -1 if we have an interface's method.
*/
- Block block = new Block(this.ast);
- block.setSourceRange(start, end - start + 1);
+ block = new Block(this.ast);
+ block.setSourceRange(start, closingPosition - start + 1);
methodDecl.setBody(block);
}
- }
- }
-
- org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeParameter[] typeParameters = methodDeclaration.typeParameters();
- if (typeParameters != null) {
- switch (this.ast.apiLevel) {
- case AST.JLS2_INTERNAL:
+ if (block != null && (statements != null || explicitConstructorCall != null)) {
+ if (explicitConstructorCall != null && explicitConstructorCall.accessMode != org.aspectj.org.eclipse.jdt.internal.compiler.ast.ExplicitConstructorCall.ImplicitSuper) {
+ block.statements().add(convert(explicitConstructorCall));
+ }
+ int statementsLength = statements == null ? 0 : statements.length;
+ for (int i = 0; i < statementsLength; i++) {
+ if (statements[i] instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.LocalDeclaration) {
+ checkAndAddMultipleLocalDeclaration(statements, i, block.statements());
+ } else {
+ final Statement statement = convert(statements[i]);
+ if (statement != null) {
+ block.statements().add(statement);
+ }
+ }
+ }
+ }
+ if (block != null
+ && (Modifier.isAbstract(methodDecl.getModifiers())
+ || Modifier.isNative(methodDecl.getModifiers())
+ || isInterface)) {
+ methodDecl.setFlags(methodDecl.getFlags() | ASTNode.MALFORMED);
+ }
+ } else {
+ // syntax error in this method declaration
methodDecl.setFlags(methodDecl.getFlags() | ASTNode.MALFORMED);
- break;
- case AST.JLS3:
- for (int i = 0, max = typeParameters.length; i < max; i++) {
- methodDecl.typeParameters().add(convert(typeParameters[i]));
+ if (!methodDeclaration.isNative() && !methodDeclaration.isAbstract()) {
+ start = retrieveStartBlockPosition(methodHeaderEnd, bodyEnd);
+ if (start == -1) start = methodDeclaration.bodyStart; // use recovery position for body start
+ end = methodDeclaration.bodyEnd;
+ // try to get the best end position
+ CategorizedProblem[] problems = methodDeclaration.compilationResult().problems;
+ if (problems != null) {
+ for (int i = 0, max = methodDeclaration.compilationResult().problemCount; i < max; i++) {
+ CategorizedProblem currentProblem = problems[i];
+ if (currentProblem.getSourceStart() == start && currentProblem.getID() == IProblem.ParsingErrorInsertToComplete) {
+ end = currentProblem.getSourceEnd();
+ break;
+ }
+ }
+ }
+ int startPosition = methodDecl.getStartPosition();
+ methodDecl.setSourceRange(startPosition, end - startPosition + 1);
+ if (start != -1 && end != -1) {
+ /*
+ * start or end can be equal to -1 if we have an interface's method.
+ */
+ Block block = new Block(this.ast);
+ block.setSourceRange(start, end - start + 1);
+ methodDecl.setBody(block);
+ }
}
}
- }
- // The javadoc comment is now got from list store in compilation unit declaration
- if (this.resolveBindings) {
- recordNodes(methodDecl, methodDeclaration);
- recordNodes(methodName, methodDeclaration);
- if (methodDecl.resolveBinding() != null) {
- convert(methodDeclaration.javadoc, methodDecl);
+ org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeParameter[] typeParameters = methodDeclaration.typeParameters();
+ if (typeParameters != null) {
+ switch(this.ast.apiLevel) {
+ case AST.JLS2_INTERNAL :
+ methodDecl.setFlags(methodDecl.getFlags() | ASTNode.MALFORMED);
+ break;
+ default :
+ for (int i = 0, max = typeParameters.length; i < max; i++) {
+ methodDecl.typeParameters().add(convert(typeParameters[i]));
+ }
+ }
}
- } else {
+
+ // The javadoc comment is now got from list store in compilation unit declaration
convert(methodDeclaration.javadoc, methodDecl);
- }
- return methodDecl;
- }
+ if (this.resolveBindings) {
+ recordNodes(methodDecl, methodDeclaration);
+ recordNodes(methodName, methodDeclaration);
+ methodDecl.resolveBinding();
+ }
+ return methodDecl;
+ }
+
+// checkCanceled();
+// if (methodDeclaration instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.AnnotationMethodDeclaration) {
+// return convert((org.aspectj.org.eclipse.jdt.internal.compiler.ast.AnnotationMethodDeclaration) methodDeclaration);
+// }
+// MethodDeclaration methodDecl = new MethodDeclaration(this.ast);
+// boolean isConstructor = methodDeclaration.isConstructor();
+// methodDecl.setConstructor(isConstructor);
+//
+// // //////////////// ajh02: added. ugh, polymorphism! Where are you!
+// if (methodDeclaration instanceof DeclareDeclaration) {
+// return convert((DeclareDeclaration) methodDeclaration);
+// } else if (methodDeclaration instanceof InterTypeFieldDeclaration) {
+// return convert((InterTypeFieldDeclaration) methodDeclaration);
+// } else if (methodDeclaration instanceof InterTypeMethodDeclaration) {
+// methodDecl = new org.aspectj.org.eclipse.jdt.core.dom.InterTypeMethodDeclaration(this.ast);
+// ((org.aspectj.org.eclipse.jdt.core.dom.InterTypeMethodDeclaration) methodDecl)
+// .setOnType(((InterTypeMethodDeclaration) methodDeclaration).getOnType().toString());
+// } else if (methodDeclaration instanceof InterTypeConstructorDeclaration) {
+// methodDecl = new org.aspectj.org.eclipse.jdt.core.dom.InterTypeMethodDeclaration(this.ast);
+// ((org.aspectj.org.eclipse.jdt.core.dom.InterTypeMethodDeclaration) methodDecl)
+// .setOnType(((InterTypeConstructorDeclaration) methodDeclaration).getOnType().toString());
+// methodDecl.setConstructor(true);
+// } else if (methodDeclaration instanceof PointcutDeclaration) {
+// return convert((PointcutDeclaration) methodDeclaration);
+// } else if (methodDeclaration instanceof AdviceDeclaration) {
+// return convert((AdviceDeclaration) methodDeclaration);
+// }
+// // ///////////////////////
+//
+// // set modifiers after checking whether we're an itd, otherwise
+// // the modifiers are not set on the correct object.
+// setModifiers(methodDecl, methodDeclaration);
+//
+// // for ITD's use the declaredSelector
+// final SimpleName methodName = new SimpleName(this.ast);
+// if (methodDeclaration instanceof InterTypeDeclaration) {
+// InterTypeDeclaration itd = (InterTypeDeclaration) methodDeclaration;
+// methodName.internalSetIdentifier(new String(itd.getDeclaredSelector()));
+// } else {
+// methodName.internalSetIdentifier(new String(methodDeclaration.selector));
+// }
+// int start = methodDeclaration.sourceStart;
+// int end = retrieveIdentifierEndPosition(start, methodDeclaration.sourceEnd);
+// methodName.setSourceRange(start, end - start + 1);
+// methodDecl.setName(methodName);
+//
+// org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeReference[] thrownExceptions = methodDeclaration.thrownExceptions;
+// if (thrownExceptions != null) {
+// int thrownExceptionsLength = thrownExceptions.length;
+// for (int i = 0; i < thrownExceptionsLength; i++) {
+// methodDecl.thrownExceptions().add(convert(thrownExceptions[i]));
+// }
+// }
+// org.aspectj.org.eclipse.jdt.internal.compiler.ast.Argument[] parameters = methodDeclaration.arguments;
+// if (parameters != null) {
+// int parametersLength = parameters.length;
+// for (int i = 0; i < parametersLength; i++) {
+// methodDecl.parameters().add(convert(parameters[i]));
+// }
+// }
+// org.aspectj.org.eclipse.jdt.internal.compiler.ast.ExplicitConstructorCall explicitConstructorCall = null;
+// if (isConstructor) {
+// org.aspectj.org.eclipse.jdt.internal.compiler.ast.ConstructorDeclaration constructorDeclaration = (org.aspectj.org.eclipse.jdt.internal.compiler.ast.ConstructorDeclaration) methodDeclaration;
+// explicitConstructorCall = constructorDeclaration.constructorCall;
+// switch (this.ast.apiLevel) {
+// case AST.JLS2_INTERNAL:
+// // set the return type to VOID
+// PrimitiveType returnType = new PrimitiveType(this.ast);
+// returnType.setPrimitiveTypeCode(PrimitiveType.VOID);
+// returnType.setSourceRange(methodDeclaration.sourceStart, 0);
+// methodDecl.internalSetReturnType(returnType);
+// break;
+// case AST.JLS3:
+// methodDecl.setReturnType2(null);
+// }
+// } else if (methodDeclaration instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.MethodDeclaration) {
+// org.aspectj.org.eclipse.jdt.internal.compiler.ast.MethodDeclaration method = (org.aspectj.org.eclipse.jdt.internal.compiler.ast.MethodDeclaration) methodDeclaration;
+// org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeReference typeReference = method.returnType;
+// if (typeReference != null) {
+// Type returnType = convertType(typeReference);
+// // get the positions of the right parenthesis
+// int rightParenthesisPosition = retrieveEndOfRightParenthesisPosition(end, method.bodyEnd);
+// int extraDimensions = retrieveExtraDimension(rightParenthesisPosition, method.bodyEnd);
+// methodDecl.setExtraDimensions(extraDimensions);
+// setTypeForMethodDeclaration(methodDecl, returnType, extraDimensions);
+// }
+// }
+// int declarationSourceStart = methodDeclaration.declarationSourceStart;
+// int declarationSourceEnd = methodDeclaration.bodyEnd;
+// methodDecl.setSourceRange(declarationSourceStart, declarationSourceEnd - declarationSourceStart + 1);
+// int closingPosition = retrieveRightBraceOrSemiColonPosition(methodDeclaration.bodyEnd + 1,
+// methodDeclaration.declarationSourceEnd);
+// if (closingPosition != -1) {
+// int startPosition = methodDecl.getStartPosition();
+// methodDecl.setSourceRange(startPosition, closingPosition - startPosition + 1);
+//
+// org.aspectj.org.eclipse.jdt.internal.compiler.ast.Statement[] statements = methodDeclaration.statements;
+//
+// start = retrieveStartBlockPosition(methodDeclaration.sourceStart, declarationSourceEnd);
+// end = retrieveEndBlockPosition(methodDeclaration.sourceStart, methodDeclaration.declarationSourceEnd);
+// Block block = null;
+// if (start != -1 && end != -1) {
+// /*
+// * start or end can be equal to -1 if we have an interface's method.
+// */
+// block = new Block(this.ast);
+// block.setSourceRange(start, end - start + 1);
+// methodDecl.setBody(block);
+// }
+// if (block != null && (statements != null || explicitConstructorCall != null)) {
+// if (explicitConstructorCall != null
+// && explicitConstructorCall.accessMode != org.aspectj.org.eclipse.jdt.internal.compiler.ast.ExplicitConstructorCall.ImplicitSuper) {
+// block.statements().add(super.convert(explicitConstructorCall));
+// }
+// int statementsLength = statements == null ? 0 : statements.length;
+// for (int i = 0; i < statementsLength; i++) {
+// if (statements[i] instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.LocalDeclaration) {
+// checkAndAddMultipleLocalDeclaration(statements, i, block.statements());
+// } else {
+// block.statements().add(convert(statements[i]));
+// }
+// }
+// }
+// if (block != null && (Modifier.isAbstract(methodDecl.getModifiers()) || Modifier.isNative(methodDecl.getModifiers()))) {
+// methodDecl.setFlags(methodDecl.getFlags() | ASTNode.MALFORMED);
+// }
+// } else {
+// // syntax error in this method declaration
+// if (!methodDeclaration.isNative() && !methodDeclaration.isAbstract()) {
+// start = retrieveStartBlockPosition(methodDeclaration.sourceStart, declarationSourceEnd);
+// end = methodDeclaration.bodyEnd;
+// // try to get the best end position
+// IProblem[] problems = methodDeclaration.compilationResult().problems;
+// if (problems != null) {
+// for (int i = 0, max = methodDeclaration.compilationResult().problemCount; i < max; i++) {
+// IProblem currentProblem = problems[i];
+// if (currentProblem.getSourceStart() == start
+// && currentProblem.getID() == IProblem.ParsingErrorInsertToComplete) {
+// end = currentProblem.getSourceEnd();
+// break;
+// }
+// }
+// }
+// int startPosition = methodDecl.getStartPosition();
+// methodDecl.setSourceRange(startPosition, end - startPosition + 1);
+// if (start != -1 && end != -1) {
+// /*
+// * start or end can be equal to -1 if we have an interface's method.
+// */
+// Block block = new Block(this.ast);
+// block.setSourceRange(start, end - start + 1);
+// methodDecl.setBody(block);
+// }
+// }
+// }
+//
+// org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeParameter[] typeParameters = methodDeclaration.typeParameters();
+// if (typeParameters != null) {
+// switch (this.ast.apiLevel) {
+// case AST.JLS2_INTERNAL:
+// methodDecl.setFlags(methodDecl.getFlags() | ASTNode.MALFORMED);
+// break;
+// case AST.JLS3:
+// for (int i = 0, max = typeParameters.length; i < max; i++) {
+// methodDecl.typeParameters().add(convert(typeParameters[i]));
+// }
+// }
+// }
+//
+// // The javadoc comment is now got from list store in compilation unit declaration
+// if (this.resolveBindings) {
+// recordNodes(methodDecl, methodDeclaration);
+// recordNodes(methodName, methodDeclaration);
+// if (methodDecl.resolveBinding() != null) {
+// convert(methodDeclaration.javadoc, methodDecl);
+// }
+// } else {
+// convert(methodDeclaration.javadoc, methodDecl);
+// }
+// return methodDecl;
+// }
public ASTNode convert(DeclareDeclaration declareDecl) {
checkCanceled(); // is this line needed?
/*
* Internal use only Used to convert class body declarations
*/
- public TypeDeclaration convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.ASTNode[] nodes) {
- final TypeDeclaration typeDecl = TypeDeclaration.getTypeDeclaration(this.ast);
- typeDecl.setInterface(false);
- int nodesLength = nodes.length;
- for (int i = 0; i < nodesLength; i++) {
- org.aspectj.org.eclipse.jdt.internal.compiler.ast.ASTNode node = nodes[i];
- if (node instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.Initializer) {
- org.aspectj.org.eclipse.jdt.internal.compiler.ast.Initializer oldInitializer = (org.aspectj.org.eclipse.jdt.internal.compiler.ast.Initializer) node;
- Initializer initializer = new Initializer(this.ast);
- initializer.setBody(convert(oldInitializer.block));
- setModifiers(initializer, oldInitializer);
- initializer.setSourceRange(oldInitializer.declarationSourceStart, oldInitializer.sourceEnd
- - oldInitializer.declarationSourceStart + 1);
- // setJavaDocComment(initializer);
- // initializer.setJavadoc(convert(oldInitializer.javadoc));
- convert(oldInitializer.javadoc, initializer);
- typeDecl.bodyDeclarations().add(initializer);
- } else if (node instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.FieldDeclaration) {
- org.aspectj.org.eclipse.jdt.internal.compiler.ast.FieldDeclaration fieldDeclaration = (org.aspectj.org.eclipse.jdt.internal.compiler.ast.FieldDeclaration) node;
- if (i > 0
- && (nodes[i - 1] instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.FieldDeclaration)
- && ((org.aspectj.org.eclipse.jdt.internal.compiler.ast.FieldDeclaration) nodes[i - 1]).declarationSourceStart == fieldDeclaration.declarationSourceStart) {
- // we have a multiple field declaration
- // We retrieve the existing fieldDeclaration to add the new VariableDeclarationFragment
- FieldDeclaration currentFieldDeclaration = (FieldDeclaration) typeDecl.bodyDeclarations().get(
- typeDecl.bodyDeclarations().size() - 1);
- currentFieldDeclaration.fragments().add(convertToVariableDeclarationFragment(fieldDeclaration));
- } else {
- // we can create a new FieldDeclaration
- typeDecl.bodyDeclarations().add(convertToFieldDeclaration(fieldDeclaration));
- }
- } else if (node instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration) {
- AbstractMethodDeclaration nextMethodDeclaration = (AbstractMethodDeclaration) node;
- if (!nextMethodDeclaration.isDefaultConstructor() && !nextMethodDeclaration.isClinit()) {
- typeDecl.bodyDeclarations().add(convert(nextMethodDeclaration));
- }
- } else if (node instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration) {
- org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration nextMemberDeclaration = (org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration) node;
- ASTNode nextMemberDeclarationNode = convert(nextMemberDeclaration);
- if (nextMemberDeclarationNode == null) {
- typeDecl.setFlags(typeDecl.getFlags() | ASTNode.MALFORMED);
- } else {
- typeDecl.bodyDeclarations().add(nextMemberDeclarationNode);
- }
- }
- }
- return typeDecl;
- }
+// public TypeDeclaration convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.ASTNode[] nodes) {
+// final TypeDeclaration typeDecl = TypeDeclaration.getTypeDeclaration(this.ast);
+// typeDecl.setInterface(false);
+// int nodesLength = nodes.length;
+// for (int i = 0; i < nodesLength; i++) {
+// org.aspectj.org.eclipse.jdt.internal.compiler.ast.ASTNode node = nodes[i];
+// if (node instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.Initializer) {
+// org.aspectj.org.eclipse.jdt.internal.compiler.ast.Initializer oldInitializer = (org.aspectj.org.eclipse.jdt.internal.compiler.ast.Initializer) node;
+// Initializer initializer = new Initializer(this.ast);
+// initializer.setBody(convert(oldInitializer.block));
+// setModifiers(initializer, oldInitializer);
+// initializer.setSourceRange(oldInitializer.declarationSourceStart, oldInitializer.sourceEnd
+// - oldInitializer.declarationSourceStart + 1);
+// // setJavaDocComment(initializer);
+// // initializer.setJavadoc(convert(oldInitializer.javadoc));
+// convert(oldInitializer.javadoc, initializer);
+// typeDecl.bodyDeclarations().add(initializer);
+// } else if (node instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.FieldDeclaration) {
+// org.aspectj.org.eclipse.jdt.internal.compiler.ast.FieldDeclaration fieldDeclaration = (org.aspectj.org.eclipse.jdt.internal.compiler.ast.FieldDeclaration) node;
+// if (i > 0
+// && (nodes[i - 1] instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.FieldDeclaration)
+// && ((org.aspectj.org.eclipse.jdt.internal.compiler.ast.FieldDeclaration) nodes[i - 1]).declarationSourceStart == fieldDeclaration.declarationSourceStart) {
+// // we have a multiple field declaration
+// // We retrieve the existing fieldDeclaration to add the new VariableDeclarationFragment
+// FieldDeclaration currentFieldDeclaration = (FieldDeclaration) typeDecl.bodyDeclarations().get(
+// typeDecl.bodyDeclarations().size() - 1);
+// currentFieldDeclaration.fragments().add(convertToVariableDeclarationFragment(fieldDeclaration));
+// } else {
+// // we can create a new FieldDeclaration
+// typeDecl.bodyDeclarations().add(convertToFieldDeclaration(fieldDeclaration));
+// }
+// } else if (node instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration) {
+// AbstractMethodDeclaration nextMethodDeclaration = (AbstractMethodDeclaration) node;
+// if (!nextMethodDeclaration.isDefaultConstructor() && !nextMethodDeclaration.isClinit()) {
+// typeDecl.bodyDeclarations().add(convert(nextMethodDeclaration));
+// }
+// } else if (node instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration) {
+// org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration nextMemberDeclaration = (org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration) node;
+// ASTNode nextMemberDeclarationNode = convert(nextMemberDeclaration);
+// if (nextMemberDeclarationNode == null) {
+// typeDecl.setFlags(typeDecl.getFlags() | ASTNode.MALFORMED);
+// } else {
+// typeDecl.bodyDeclarations().add(nextMemberDeclarationNode);
+// }
+// }
+// }
+// return typeDecl;
+// }
// public Expression convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.BinaryExpression expression) {
// InfixExpression infixExpression = new InfixExpression(this.ast);
}
public ASTNode convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration typeDeclaration) {
- switch (org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration.kind(typeDeclaration.modifiers)) {
- case org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration.ENUM_DECL:
- if (this.ast.apiLevel == AST.JLS2_INTERNAL) {
- return null;
- } else {
- return convertToEnumDeclaration(typeDeclaration);
- }
- case org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration.ANNOTATION_TYPE_DECL:
- if (this.ast.apiLevel == AST.JLS2_INTERNAL) {
- return null;
- } else {
- return convertToAnnotationDeclaration(typeDeclaration);
- }
+ int kind = org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration.kind(typeDeclaration.modifiers);
+ switch (kind) {
+ case org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration.ENUM_DECL :
+ if (this.ast.apiLevel == AST.JLS2_INTERNAL) {
+ return null;
+ } else {
+ return convertToEnumDeclaration(typeDeclaration);
+ }
+ case org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration.ANNOTATION_TYPE_DECL :
+ if (this.ast.apiLevel == AST.JLS2_INTERNAL) {
+ return null;
+ } else {
+ return convertToAnnotationDeclaration(typeDeclaration);
+ }
}
checkCanceled();
}
}
// /////////////////////////////
-
if (typeDeclaration.modifiersSourceStart != -1) {
setModifiers(typeDecl, typeDeclaration);
}
- typeDecl.setInterface(org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration.kind(typeDeclaration.modifiers) == org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration.INTERFACE_DECL);
+ boolean isInterface = kind == org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration.INTERFACE_DECL;
+ typeDecl.setInterface(isInterface);
final SimpleName typeName = new SimpleName(this.ast);
typeName.internalSetIdentifier(new String(typeDeclaration.name));
typeName.setSourceRange(typeDeclaration.sourceStart, typeDeclaration.sourceEnd - typeDeclaration.sourceStart + 1);
typeDecl.setName(typeName);
- typeDecl.setSourceRange(typeDeclaration.declarationSourceStart, typeDeclaration.bodyEnd
- - typeDeclaration.declarationSourceStart + 1);
+ typeDecl.setSourceRange(typeDeclaration.declarationSourceStart, typeDeclaration.bodyEnd - typeDeclaration.declarationSourceStart + 1);
// need to set the superclass and super interfaces here since we cannot distinguish them at
// the type references level.
if (typeDeclaration.superclass != null) {
- switch (this.ast.apiLevel) {
- case AST.JLS2_INTERNAL:
- typeDecl.internalSetSuperclass(convert(typeDeclaration.superclass));
- break;
- case AST.JLS3:
- typeDecl.setSuperclassType(convertType(typeDeclaration.superclass));
- break;
+ switch(this.ast.apiLevel) {
+ case AST.JLS2_INTERNAL :
+ typeDecl.internalSetSuperclass(convert(typeDeclaration.superclass));
+ break;
+ default :
+ typeDecl.setSuperclassType(convertType(typeDeclaration.superclass));
+ break;
}
}
org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeReference[] superInterfaces = typeDeclaration.superInterfaces;
if (superInterfaces != null) {
- switch (this.ast.apiLevel) {
- case AST.JLS2_INTERNAL:
- for (int index = 0, length = superInterfaces.length; index < length; index++) {
- typeDecl.internalSuperInterfaces().add(convert(superInterfaces[index]));
- }
- break;
- case AST.JLS3:
- for (int index = 0, length = superInterfaces.length; index < length; index++) {
- typeDecl.superInterfaceTypes().add(convertType(superInterfaces[index]));
- }
+ switch(this.ast.apiLevel) {
+ case AST.JLS2_INTERNAL :
+ for (int index = 0, length = superInterfaces.length; index < length; index++) {
+ typeDecl.internalSuperInterfaces().add(convert(superInterfaces[index]));
+ }
+ break;
+ default :
+ for (int index = 0, length = superInterfaces.length; index < length; index++) {
+ typeDecl.superInterfaceTypes().add(convertType(superInterfaces[index]));
+ }
}
}
org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeParameter[] typeParameters = typeDeclaration.typeParameters;
if (typeParameters != null) {
- switch (this.ast.apiLevel) {
- case AST.JLS2_INTERNAL:
- typeDecl.setFlags(typeDecl.getFlags() | ASTNode.MALFORMED);
- break;
- case AST.JLS3:
- for (int index = 0, length = typeParameters.length; index < length; index++) {
- typeDecl.typeParameters().add(convert(typeParameters[index]));
- }
+ switch(this.ast.apiLevel) {
+ case AST.JLS2_INTERNAL :
+ typeDecl.setFlags(typeDecl.getFlags() | ASTNode.MALFORMED);
+ break;
+ default :
+ for (int index = 0, length = typeParameters.length; index < length; index++) {
+ typeDecl.typeParameters().add(convert(typeParameters[index]));
+ }
}
}
- buildBodyDeclarations(typeDeclaration, typeDecl,org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration.kind(typeDeclaration.modifiers) == org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration.INTERFACE_DECL);
+ buildBodyDeclarations(typeDeclaration, typeDecl, isInterface);
if (this.resolveBindings) {
recordNodes(typeDecl, typeDeclaration);
recordNodes(typeName, typeDeclaration);
projects / aspectj.git / commitdiff