org.aspectj.ajdt.internal.compiler.ast.AtAspectJAnnotationFactory Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of aspectjtools Show documentation
Show all versions of aspectjtools Show documentation
AspectJ tools most notably contains the AspectJ compiler (AJC). AJC applies aspects to Java classes during
compilation, fully replacing Javac for plain Java classes and also compiling native AspectJ or annotation-based
@AspectJ syntax. Furthermore, AJC can weave aspects into existing class files in a post-compile binary weaving step.
This library is a superset of AspectJ weaver and hence also of AspectJ runtime.
/* *******************************************************************
* Copyright (c) 2005 Contributors.
* All rights reserved.
* This program and the accompanying materials are made available
* under the terms of the Eclipse Public License v 2.0
* which accompanies this distribution and is available at
* https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.txt
*
* Contributors:
* Adrian Colyer Initial implementation
* ******************************************************************/
package org.aspectj.ajdt.internal.compiler.ast;
import org.aspectj.org.eclipse.jdt.internal.compiler.ast.Annotation;
import org.aspectj.org.eclipse.jdt.internal.compiler.ast.Expression;
import org.aspectj.org.eclipse.jdt.internal.compiler.ast.IntLiteral;
import org.aspectj.org.eclipse.jdt.internal.compiler.ast.MemberValuePair;
import org.aspectj.org.eclipse.jdt.internal.compiler.ast.NormalAnnotation;
import org.aspectj.org.eclipse.jdt.internal.compiler.ast.QualifiedTypeReference;
import org.aspectj.org.eclipse.jdt.internal.compiler.ast.StringLiteral;
import org.aspectj.org.eclipse.jdt.internal.compiler.ast.TrueLiteral;
import org.aspectj.org.eclipse.jdt.internal.compiler.ast.FalseLiteral;
import org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeReference;
import org.aspectj.org.eclipse.jdt.internal.compiler.lookup.BlockScope;
import org.aspectj.org.eclipse.jdt.internal.compiler.lookup.TagBits;
/**
* @author colyer
* Creates @AspectJ annotations for use by AtAspectJVisitor
*/
public class AtAspectJAnnotationFactory {
static final char[] org = "org".toCharArray();
static final char[] aspectj = "aspectj".toCharArray();
static final char[] lang = "lang".toCharArray();
static final char[] internal = "internal".toCharArray();
static final char[] annotation = "annotation".toCharArray();
static final char[] value = "value".toCharArray();
static final char[] aspect = "Aspect".toCharArray();
static final char[] privileged = "ajcPrivileged".toCharArray();
static final char[] before = "Before".toCharArray();
static final char[] after = "After".toCharArray();
static final char[] afterReturning = "AfterReturning".toCharArray();
static final char[] afterThrowing = "AfterThrowing".toCharArray();
static final char[] around = "Around".toCharArray();
static final char[] pointcut = "Pointcut".toCharArray();
static final char[] declareErrorOrWarning = "ajcDeclareEoW".toCharArray();
static final char[] declareParents = "ajcDeclareParents".toCharArray();
static final char[] declareSoft = "ajcDeclareSoft".toCharArray();
static final char[] declarePrecedence = "ajcDeclarePrecedence".toCharArray();
static final char[] declareAnnotation = "ajcDeclareAnnotation".toCharArray();
static final char[] itdAnnotation = "ajcITD".toCharArray();
/**
* Create an @Aspect annotation for a code style aspect declaration starting at
* the given position in the source file
*/
public static Annotation createAspectAnnotation(String perclause, int pos) {
char[][] typeName = new char[][] {org,aspectj,lang,annotation,aspect};
long[] positions = new long[] {pos,pos,pos,pos,pos};
TypeReference orgAspectJLangAnnotationAspect = new QualifiedTypeReference(typeName,positions);
NormalAnnotation atAspectAnnotation = new NormalAnnotation(orgAspectJLangAnnotationAspect,pos);
if (!perclause.equals("")) {
// we have to set the value
Expression perclauseExpr = new StringLiteral(perclause.toCharArray(),pos,pos,1);
MemberValuePair[] mvps = new MemberValuePair[1];
mvps[0] = new MemberValuePair(value,pos,pos,perclauseExpr);
atAspectAnnotation.memberValuePairs = mvps;
}
return atAspectAnnotation;
}
public static Annotation createPrivilegedAnnotation(int pos) {
char[][] typeName = new char[][] {org,aspectj,internal,lang,annotation,privileged};
long[] positions = new long[] {pos,pos,pos,pos,pos,pos};
TypeReference annType = new QualifiedTypeReference(typeName,positions);
NormalAnnotation ann = new NormalAnnotation(annType,pos);
return ann;
}
public static Annotation createBeforeAnnotation(String pointcutExpression, String argNames, int pos) {
char[][] typeName = new char[][] {org,aspectj,lang,annotation,before};
long[] positions = new long[] {pos,pos,pos,pos,pos};
TypeReference annType = new QualifiedTypeReference(typeName,positions);
NormalAnnotation ann = new NormalAnnotation(annType,pos);
Expression pcExpr = new StringLiteral(pointcutExpression.toCharArray(),pos,pos,1);
MemberValuePair[] mvps = new MemberValuePair[2];
mvps[0] = new MemberValuePair("value".toCharArray(),pos,pos,pcExpr);
Expression argNamesExpr = new StringLiteral(argNames.toCharArray(),pos,pos,1);
mvps[1] = new MemberValuePair("argNames".toCharArray(),pos,pos,argNamesExpr);
ann.memberValuePairs = mvps;
return ann;
}
public static Annotation createAfterAnnotation(String pointcutExpression, String argNames, int pos) {
char[][] typeName = new char[][] {org,aspectj,lang,annotation,after};
long[] positions = new long[] {pos,pos,pos,pos,pos};
TypeReference annType = new QualifiedTypeReference(typeName,positions);
NormalAnnotation ann = new NormalAnnotation(annType,pos);
Expression pcExpr = new StringLiteral(pointcutExpression.toCharArray(),pos,pos,1);
MemberValuePair[] mvps = new MemberValuePair[2];
mvps[0] = new MemberValuePair("value".toCharArray(),pos,pos,pcExpr);
Expression argNamesExpr = new StringLiteral(argNames.toCharArray(),pos,pos,1);
mvps[1] = new MemberValuePair("argNames".toCharArray(),pos,pos,argNamesExpr);
ann.memberValuePairs = mvps;
return ann;
}
public static Annotation createAfterReturningAnnotation(String pointcutExpression, String argNames, String extraArgumentName, int pos) {
char[][] typeName = new char[][] {org,aspectj,lang,annotation,afterReturning};
long[] positions = new long[] {pos,pos,pos,pos,pos};
TypeReference annType = new QualifiedTypeReference(typeName,positions);
NormalAnnotation ann = new NormalAnnotation(annType,pos);
Expression pcExpr = new StringLiteral(pointcutExpression.toCharArray(),pos,pos,1);
MemberValuePair[] mvps = new MemberValuePair[3];
mvps[0] = new MemberValuePair("pointcut".toCharArray(),pos,pos,pcExpr);
Expression argExpr = new StringLiteral(extraArgumentName.toCharArray(),pos,pos,1);
mvps[1] = new MemberValuePair("returning".toCharArray(),pos,pos,argExpr);
Expression argNamesExpr = new StringLiteral(argNames.toCharArray(),pos,pos,1);
mvps[2] = new MemberValuePair("argNames".toCharArray(),pos,pos,argNamesExpr);
ann.memberValuePairs = mvps;
return ann;
}
public static Annotation createAfterThrowingAnnotation(String pointcutExpression, String argNames, String extraArgumentName, int pos) {
char[][] typeName = new char[][] {org,aspectj,lang,annotation,afterThrowing};
long[] positions = new long[] {pos,pos,pos,pos,pos};
TypeReference annType = new QualifiedTypeReference(typeName,positions);
NormalAnnotation ann = new NormalAnnotation(annType,pos);
Expression pcExpr = new StringLiteral(pointcutExpression.toCharArray(),pos,pos,1);
MemberValuePair[] mvps = new MemberValuePair[3];
mvps[0] = new MemberValuePair("pointcut".toCharArray(),pos,pos,pcExpr);
Expression argExpr = new StringLiteral(extraArgumentName.toCharArray(),pos,pos,1);
mvps[1] = new MemberValuePair("throwing".toCharArray(),pos,pos,argExpr);
Expression argNamesExpr = new StringLiteral(argNames.toCharArray(),pos,pos,1);
mvps[2] = new MemberValuePair("argNames".toCharArray(),pos,pos,argNamesExpr);
ann.memberValuePairs = mvps;
return ann;
}
public static Annotation createAroundAnnotation(String pointcutExpression, String argNames, int pos) {
char[][] typeName = new char[][] {org,aspectj,lang,annotation,around};
long[] positions = new long[] {pos,pos,pos,pos,pos};
TypeReference annType = new QualifiedTypeReference(typeName,positions);
NormalAnnotation ann = new NormalAnnotation(annType,pos);
Expression pcExpr = new StringLiteral(pointcutExpression.toCharArray(),pos,pos,1);
MemberValuePair[] mvps = new MemberValuePair[2];
mvps[0] = new MemberValuePair("value".toCharArray(),pos,pos,pcExpr);
Expression argNamesExpr = new StringLiteral(argNames.toCharArray(),pos,pos,1);
mvps[1] = new MemberValuePair("argNames".toCharArray(),pos,pos,argNamesExpr);
ann.memberValuePairs = mvps;
return ann;
}
public static Annotation createPointcutAnnotation(String pointcutExpression, String argNames, int pos) {
char[][] typeName = new char[][] {org,aspectj,lang,annotation,pointcut};
long[] positions = new long[] {pos,pos,pos,pos,pos};
TypeReference annType = new QualifiedTypeReference(typeName,positions);
NormalAnnotation ann = new NormalAnnotation(annType,pos);
Expression pcExpr = new StringLiteral(pointcutExpression.toCharArray(),pos,pos,1);
MemberValuePair[] mvps = new MemberValuePair[2];
mvps[0] = new MemberValuePair("value".toCharArray(),pos,pos,pcExpr);
Expression argExpr = new StringLiteral(argNames.toCharArray(),pos,pos,1);
mvps[1] = new MemberValuePair("argNames".toCharArray(),pos,pos,argExpr);
ann.memberValuePairs = mvps;
return ann;
}
public static Annotation createDeclareErrorOrWarningAnnotation(String pointcutExpression, String message, boolean isError, int pos) {
char[][] typeName = new char[][] {org,aspectj,internal,lang,annotation,declareErrorOrWarning};
long[] positions = new long[typeName.length];
for (int i = 0; i < positions.length; i++) positions[i] = pos;
TypeReference annType = new QualifiedTypeReference(typeName,positions);
NormalAnnotation ann = new NormalAnnotation(annType,pos);
Expression pcutExpr = new StringLiteral(pointcutExpression.toCharArray(),pos,pos,1);
Expression msgExpr = new StringLiteral(message.toCharArray(),pos,pos,1);
Expression isErrorExpr;
if (isError) {
isErrorExpr = new TrueLiteral(pos,pos);
} else {
isErrorExpr = new FalseLiteral(pos,pos);
}
MemberValuePair[] mvps = new MemberValuePair[3];
mvps[0] = new MemberValuePair("pointcut".toCharArray(),pos,pos,pcutExpr);
mvps[1] = new MemberValuePair("message".toCharArray(),pos,pos,msgExpr);
mvps[2] = new MemberValuePair("isError".toCharArray(),pos,pos,isErrorExpr);
ann.memberValuePairs = mvps;
return ann;
}
public static Annotation createDeclareParentsAnnotation(String childPattern, String parentPatterns, boolean isExtends, int pos) {
char[][] typeName = new char[][] {org,aspectj,internal,lang,annotation,declareParents};
long[] positions = new long[typeName.length];
for (int i = 0; i < positions.length; i++) positions[i] = pos;
TypeReference annType = new QualifiedTypeReference(typeName,positions);
NormalAnnotation ann = new NormalAnnotation(annType,pos);
Expression targetExpression = new StringLiteral(childPattern.toCharArray(),pos,pos,1);
Expression parentsExpression = new StringLiteral(parentPatterns.toCharArray(),pos,pos,1);
Expression isExtendsExpression;
if (isExtends) {
isExtendsExpression = new TrueLiteral(pos,pos);
} else {
isExtendsExpression = new FalseLiteral(pos,pos);
}
MemberValuePair[] mvps = new MemberValuePair[3];
mvps[0] = new MemberValuePair("targetTypePattern".toCharArray(),pos,pos,targetExpression);
mvps[1] = new MemberValuePair("parentTypes".toCharArray(),pos,pos,parentsExpression);
mvps[2] = new MemberValuePair("isExtends".toCharArray(),pos,pos,isExtendsExpression);
ann.memberValuePairs = mvps;
return ann;
}
public static Annotation createDeclareSoftAnnotation(String pointcutExpression, String exceptionType, int pos) {
char[][] typeName = new char[][] {org,aspectj,internal,lang,annotation,declareSoft};
long[] positions = new long[typeName.length];
for (int i = 0; i < positions.length; i++) positions[i] = pos;
TypeReference annType = new QualifiedTypeReference(typeName,positions);
NormalAnnotation ann = new NormalAnnotation(annType,pos);
Expression pcutExpr = new StringLiteral(pointcutExpression.toCharArray(),pos,pos,1);
Expression exExpr = new StringLiteral(exceptionType.toCharArray(),pos,pos,1);
MemberValuePair[] mvps = new MemberValuePair[2];
mvps[0] = new MemberValuePair("pointcut".toCharArray(),pos,pos,pcutExpr);
mvps[1] = new MemberValuePair("exceptionType".toCharArray(),pos,pos,exExpr);
ann.memberValuePairs = mvps;
return ann;
}
public static Annotation createDeclareAnnAnnotation(String patternString, String annString, String kind, int pos) {
char[][] typeName = new char[][] {org,aspectj,internal,lang,annotation,declareAnnotation};
long[] positions = new long[typeName.length];
for (int i = 0; i < positions.length; i++) positions[i] = pos;
TypeReference annType = new QualifiedTypeReference(typeName,positions);
NormalAnnotation ann = new NormalAnnotation(annType,pos);
Expression pattExpr = new StringLiteral(patternString.toCharArray(),pos,pos,1);
Expression annExpr = new StringLiteral(annString.toCharArray(),pos,pos,1);
Expression kindExpr = new StringLiteral(kind.toCharArray(),pos,pos,1);
MemberValuePair[] mvps = new MemberValuePair[3];
mvps[0] = new MemberValuePair("pattern".toCharArray(),pos,pos,pattExpr);
mvps[1] = new MemberValuePair("annotation".toCharArray(),pos,pos,annExpr);
mvps[2] = new MemberValuePair("kind".toCharArray(),pos,pos,kindExpr);
ann.memberValuePairs = mvps;
return ann;
}
public static Annotation createITDAnnotation(char[] targetTypeName, int modifiers, char[] name, int pos) {
char[][] typeName = new char[][] {org,aspectj,internal,lang,annotation,itdAnnotation};
long[] positions = new long[typeName.length];
for (int i = 0; i < positions.length; i++) positions[i] = pos;
TypeReference annType = new QualifiedTypeReference(typeName,positions);
NormalAnnotation ann = new NormalAnnotation(annType,pos);
Expression targetExpr = new StringLiteral(targetTypeName,pos,pos,1);
Expression nameExpr = new StringLiteral(name,pos,pos,1);
Expression modsExpr = IntLiteral.buildIntLiteral(Integer.toString(modifiers).toCharArray(),pos,pos);
MemberValuePair[] mvps = new MemberValuePair[3];
mvps[0] = new MemberValuePair("targetType".toCharArray(),pos,pos,targetExpr);
mvps[1] = new MemberValuePair("name".toCharArray(),pos,pos,nameExpr);
mvps[2] = new MemberValuePair("modifiers".toCharArray(),pos,pos,modsExpr);
ann.memberValuePairs = mvps;
return ann;
}
public static Annotation createDeclarePrecedenceAnnotation(String pointcutExpression, int pos) {
char[][] typeName = new char[][] {org,aspectj,internal,lang,annotation,declarePrecedence};
return makeSingleStringMemberAnnotation(typeName, pos, pointcutExpression);
}
private static Annotation makeSingleStringMemberAnnotation(char[][] name, int pos, String annValue) {
long[] positions = new long[name.length];
for (int i = 0; i < positions.length; i++) positions[i] = pos;
TypeReference annType = new QualifiedTypeReference(name,positions);
NormalAnnotation ann = new NormalAnnotation(annType,pos);
Expression valueExpr = new StringLiteral(annValue.toCharArray(),pos,pos,1);
MemberValuePair[] mvps = new MemberValuePair[1];
mvps[0] = new MemberValuePair(value,pos,pos,valueExpr);
ann.memberValuePairs = mvps;
return ann;
}
public static void addAnnotation(AjMethodDeclaration decl, Annotation annotation, BlockScope scope) {
if (decl.annotations == null) {
decl.annotations = new Annotation[] { annotation };
} else {
Annotation[] old = decl.annotations;
decl.annotations = new Annotation[old.length +1];
System.arraycopy(old,0,decl.annotations,0,old.length);
decl.annotations[old.length] = annotation;
}
if (decl.binding!= null) {
if ((decl.binding.tagBits & TagBits.AnnotationResolved) != 0) {
annotation.resolve(scope);
}
}
}
}