public AccessForInlineVisitor(AspectDeclaration inAspect, PrivilegedHandler handler) {
this.inAspect = inAspect;
- this.world = inAspect.world;
+ this.world = inAspect.factory;
this.handler = handler;
}
public ResolvedTypeX.Name typeX;
- public EclipseFactory world; //??? should use this consistently
+ public EclipseFactory factory; //??? should use this consistently
// for better error messages in 1.0 to 1.1 transition
if (perClause == null) {
// we've already produced an error for this
} else if (perClause.getKind() == PerClause.SINGLETON) {
- binding.addField(world.makeFieldBinding(AjcMemberMaker.perSingletonField(
+ binding.addField(factory.makeFieldBinding(AjcMemberMaker.perSingletonField(
typeX)));
methods[0] = new AspectClinit((Clinit)methods[0], compilationResult, false, true);
} else if (perClause.getKind() == PerClause.PERCFLOW) {
binding.addField(
- world.makeFieldBinding(
+ factory.makeFieldBinding(
AjcMemberMaker.perCflowField(
typeX)));
methods[0] = new AspectClinit((Clinit)methods[0], compilationResult, true, false);
codeStream.aload_0();
AstUtil.generateParameterLoads(accessMethod.parameters, codeStream);
codeStream.invokespecial(
- world.makeMethodBinding(method));
+ factory.makeMethodBinding(method));
AstUtil.generateReturn(accessMethod.returnType, codeStream);
// body ends here
}});
}
private void generateInlineAccessors(ClassFile classFile, final InlineAccessFieldBinding accessField, final ResolvedMember field) {
- final FieldBinding fieldBinding = world.makeFieldBinding(field);
+ final FieldBinding fieldBinding = factory.makeFieldBinding(field);
generateMethod(classFile, accessField.reader,
new BodyGenerator() {
public void generate(CodeStream codeStream) {
AstUtil.generateParameterLoads(accessMethod.parameters, codeStream);
if (method.isStatic()) {
- codeStream.invokestatic(world.makeMethodBinding(method));
+ codeStream.invokestatic(factory.makeMethodBinding(method));
} else {
- codeStream.invokevirtual(world.makeMethodBinding(method));
+ codeStream.invokevirtual(factory.makeMethodBinding(method));
}
AstUtil.generateReturn(accessMethod.returnType, codeStream);
checkSpec(classScope);
if (ignoreFurtherInvestigation) return;
- world = EclipseFactory.fromScopeLookupEnvironment(scope);
-// concreteName = world.lookupConcreteName(binding);
-// typeX = concreteName.getResolvedTypeX();
-
+ factory = EclipseFactory.fromScopeLookupEnvironment(scope);
if (isPrivileged) {
binding.privilegedHandler = new PrivilegedHandler(this);
}
-// CrosscuttingMembers xcut = new CrosscuttingMembers(typeX);
-// concreteName.crosscuttingMembers = xcut;
- //typeX.crosscuttingMembers = xcut;
- //XXXxcut.setPerClause(buildPerClause(scope));
buildPerClause(scope);
if (methods != null) {
}
//??? timing is weird
- world.getWorld().getCrosscuttingMembersSet().addOrReplaceAspect(typeX);
+ factory.getWorld().getCrosscuttingMembersSet().addOrReplaceAspect(typeX);
+
+ if (typeX.getSuperclass().isAspect() && !typeX.getSuperclass().isExposedToWeaver()) {
+ factory.getWorld().getCrosscuttingMembersSet().addOrReplaceAspect(typeX.getSuperclass());
+ }
}
public boolean isAspect() {
return binding.scope.referenceContext instanceof AspectDeclaration;
+ }
+ public boolean isWovenBy(ResolvedTypeX aspectType) {
+ return false;
}
public ResolvedTypeX getSuperclass() {
super(baseField, baseField.declaringClass);
this.reader = new SimpleSyntheticAccessMethodBinding(
- inAspect.world.makeMethodBinding(
+ inAspect.factory.makeMethodBinding(
AjcMemberMaker.inlineAccessMethodForFieldGet(
- inAspect.typeX, inAspect.world.makeResolvedMember(baseField)
+ inAspect.typeX, inAspect.factory.makeResolvedMember(baseField)
)));
- this.writer = new SimpleSyntheticAccessMethodBinding(inAspect.world.makeMethodBinding(
+ this.writer = new SimpleSyntheticAccessMethodBinding(inAspect.factory.makeMethodBinding(
AjcMemberMaker.inlineAccessMethodForFieldSet(
- inAspect.typeX, inAspect.world.makeResolvedMember(baseField)
+ inAspect.typeX, inAspect.factory.makeResolvedMember(baseField)
)));
this.constant = AstNode.NotAConstant;
super(baseField, baseField.declaringClass);
this.reader = new SimpleSyntheticAccessMethodBinding(
- inAspect.world.makeMethodBinding(
+ inAspect.factory.makeMethodBinding(
AjcMemberMaker.privilegedAccessMethodForFieldGet(
- inAspect.typeX, inAspect.world.makeResolvedMember(baseField)
+ inAspect.typeX, inAspect.factory.makeResolvedMember(baseField)
)));
- this.writer = new SimpleSyntheticAccessMethodBinding(inAspect.world.makeMethodBinding(
+ this.writer = new SimpleSyntheticAccessMethodBinding(inAspect.factory.makeMethodBinding(
AjcMemberMaker.privilegedAccessMethodForFieldSet(
- inAspect.typeX, inAspect.world.makeResolvedMember(baseField)
+ inAspect.typeX, inAspect.factory.makeResolvedMember(baseField)
)));
this.constant = AstNode.NotAConstant;
}
public FieldBinding getPrivilegedAccessField(FieldBinding baseField, AstNode location) {
- ResolvedMember key = inAspect.world.makeResolvedMember(baseField);
+ ResolvedMember key = inAspect.factory.makeResolvedMember(baseField);
if (accessors.containsKey(key)) return (FieldBinding)accessors.get(key);
FieldBinding ret = new PrivilegedFieldBinding(inAspect, baseField);
checkWeaveAccess(key.getDeclaringType(), location);
}
public MethodBinding getPrivilegedAccessMethod(MethodBinding baseMethod, AstNode location) {
- ResolvedMember key = inAspect.world.makeResolvedMember(baseMethod);
+ ResolvedMember key = inAspect.factory.makeResolvedMember(baseMethod);
if (accessors.containsKey(key)) return (MethodBinding)accessors.get(key);
MethodBinding ret;
if (baseMethod.isConstructor()) {
ret = baseMethod;
} else {
- ret = inAspect.world.makeMethodBinding(
+ ret = inAspect.factory.makeMethodBinding(
AjcMemberMaker.privilegedAccessMethodForMethod(inAspect.typeX, key)
);
}
public void notePrivilegedTypeAccess(ReferenceBinding type, AstNode location) {
ResolvedMember key =
new ResolvedMember(Member.STATIC_INITIALIZATION,
- inAspect.world.fromEclipse(type), 0, ResolvedTypeX.VOID, "", TypeX.NONE);
+ inAspect.factory.fromEclipse(type), 0, ResolvedTypeX.VOID, "", TypeX.NONE);
checkWeaveAccess(key.getDeclaringType(), location);
accessors.put(key, key);
}
private void checkWeaveAccess(TypeX typeX, AstNode location) {
- World world = inAspect.world.getWorld();
+ World world = inAspect.factory.getWorld();
Lint.Kind check = world.getLint().typeNotExposedToWeaver;
if (check.isEnabled()) {
if (!world.resolve(typeX).isExposedToWeaver()) {
System.out.println(c.value);
ConcreteA.Marker m = c;
System.out.println(m.value);
+ System.out.println(ConcreteA.getPrivateValue(c));
try {
new Client();
} catch (SoftException se) {
--- /dev/null
+package client;
+
+import lib.AbstractA;
+import org.aspectj.lang.*;
+
+public class Client1 {
+ public static void main(String[] args) {
+ C1 c = new C1();
+ System.out.println(c.value);
+ AbstractA.Marker m = c;
+ System.out.println(m.value);
+ System.out.println(AbstractA.getPrivateValue(c));
+
+ FooMarkMe f = new FooMarkMe();
+ System.out.println(f.value);
+
+ m = f;
+ }
+
+}
+
+class C1 implements AbstractA.Marker {
+ public void m() {
+ System.out.println("hello");
+ }
+}
+
+class FooMarkMe {
+ public void m() {
+ System.out.println("hello");
+ }
+}
--- /dev/null
+package client;\r
+import lib.AbstractA;\r
+\r
+aspect MyAspect extends AbstractA {\r
+ protected pointcut scope();\r
+}
\ No newline at end of file
--- /dev/null
+package client;\r
+import lib.AbstractA;\r
+\r
+aspect MyAspect1 extends AbstractA {\r
+ protected pointcut scope(): within(client.*);\r
+}
\ No newline at end of file
--- /dev/null
+package lib;\r
+\r
+public abstract aspect AbstractA {\r
+ public interface Marker {}\r
+ \r
+ public String Marker.value = "public";\r
+ private String Marker.pValue = "private";\r
+ \r
+ public static String getPrivateValue(Marker m) { return m.pValue; }\r
+\r
+ protected abstract pointcut scope();\r
+\r
+ declare error: scope() && within(Marker+) && call(* java.io.PrintStream.println(*)):\r
+ "use a proper logger";\r
+ \r
+ before(Marker m): this(m) && execution(new(..)) {\r
+ System.err.println("making a Marker: " + m + " with " + m.pValue);\r
+ }\r
+ \r
+ declare parents: *..*MarkMe implements Marker;\r
+}
\ No newline at end of file
public interface Marker {}\r
\r
public String Marker.value = "public";\r
- //private String Marker.pValue = "private";\r
+ private String Marker.pValue = "private";\r
+ \r
+ public static String getPrivateValue(Marker m) { return m.pValue; }\r
\r
public static class MyException extends Exception {}\r
\r
args.add("out");
args.add("testdata/src1/binary/lib/ConcreteA.aj");
+ args.add("testdata/src1/binary/lib/AbstractA.aj");
CommandTestCase.runCompiler(args, CommandTestCase.NO_ERRORS);
args.add("out");
args.add("testdata/src1/binary/client/Client.java");
+ args.add("testdata/src1/binary/client/Client1.java");
CommandTestCase.runCompiler(args, CommandTestCase.NO_ERRORS);
TestUtil.runMain("out;out/lib.jar", "client.Client");
- }
-
-
- public void XXXtestJar1() throws IOException {
- List args = new ArrayList();
- args.add("-outjar");
- args.add("out/megatrace.jar");
+ TestUtil.runMain("out;out/lib.jar", "client.Client1");
+
+ args = new ArrayList();
+ args.add("-aspectpath");
+ args.add("out/lib.jar");
args.add("-classpath");
args.add("../runtime/bin");
- args.add("testdata/src1/trace/MegaTrace.java");
- args.add("testdata/src1/trace/ExecTrace.java");
+ args.add("-d");
+ args.add("out");
+
+ args.add("testdata/src1/binary/client/MyAspect.aj");
+ args.add("testdata/src1/binary/client/Client1.java");
CommandTestCase.runCompiler(args, CommandTestCase.NO_ERRORS);
+ TestUtil.runMain("out;out/lib.jar", "client.Client1");
+
args = new ArrayList();
args.add("-aspectpath");
- args.add("out/megatrace.jar");
+ args.add("out/lib.jar");
args.add("-classpath");
args.add("../runtime/bin");
- args.add("testdata/src1/tracep1/TraceTest.java");
+ args.add("-d");
+ args.add("out");
+
+ args.add("testdata/src1/binary/client/MyAspect1.aj");
+ args.add("testdata/src1/binary/client/Client1.java");
+
+ CommandTestCase.runCompiler(args, new int[] {24, 30});
+
+ args = new ArrayList();
+ args.add("-classpath");
+ args.add("../runtime/bin;out/lib.jar");
+
+ args.add("-d");
+ args.add("out");
+
+ args.add("testdata/src1/binary/client/Client1.java");
+
+ CommandTestCase.runCompiler(args, new int[] {9, 11, 15, 17});
+
+ args = new ArrayList();
+ args.add("-classpath");
+ args.add("../runtime/bin;out/lib.jar");
+ args.add("-Xlint:error");
+
+ args.add("-d");
+ args.add("out");
+
+ args.add("testdata/src1/binary/client/MyAspect.aj");
+ args.add("testdata/src1/binary/client/Client1.java");
CommandTestCase.runCompiler(args, CommandTestCase.NO_ERRORS);
}
public boolean matches(ResolvedTypeX onType) {
if (munger == null) throw new RuntimeException("huh: " + this);
- return munger.matches(onType);
+ return munger.matches(onType, aspectType);
}
public ResolvedMember getMatchingSyntheticMember(Member member) {
return testPointcut;
}
- public boolean matches(ResolvedTypeX matchType) {
+ public boolean matches(ResolvedTypeX matchType, ResolvedTypeX aspectType) {
//??? this matches many more types than are needed
return !matchType.isInterface();
}
}
- public boolean matches(ResolvedTypeX matchType) {
+ public boolean matches(ResolvedTypeX matchType, ResolvedTypeX aspectType) {
ResolvedTypeX onType = matchType.getWorld().resolve(signature.getDeclaringType());
//System.err.println("matching: " + this + " to " + matchType + " onType = " + onType);
if (matchType.equals(onType)) {
- if (!onType.isExposedToWeaver() &&
- matchType.getWorld().getLint().typeNotExposedToWeaver.isEnabled())
- {
- matchType.getWorld().getLint().typeNotExposedToWeaver.signal(matchType.getName(), signature.getSourceLocation());
+ if (!onType.isExposedToWeaver()) {
+ if (!onType.isWovenBy(aspectType)) {
+ if (matchType.getWorld().getLint().typeNotExposedToWeaver.isEnabled()) {
+ matchType.getWorld().getLint().typeNotExposedToWeaver.signal(
+ matchType.getName(), signature.getSourceLocation());
+ }
+ }
}
return true;
}
public boolean isExposedToWeaver() {
return delegate.isExposedToWeaver(); //??? where does this belong
}
+
+ public boolean isWovenBy(ResolvedTypeX aspectType) {
+ return delegate.isWovenBy(aspectType);
+ }
public ResolvedMember[] getDeclaredFields() {
return delegate.getDeclaredFields();
public abstract ISourceLocation getSourceLocation();
+ public abstract boolean isWovenBy(ResolvedTypeX aspectType);
public ISourceContext getSourceContext() {
return sourceContext;
public ISourceLocation getSourceLocation() { return null; }
public boolean isExposedToWeaver() { return false; }
+ public boolean isWovenBy(ResolvedTypeX aspectType) {
+ return false;
+ }
+
}
ret[len] = d;
pointcuts = ret;
}
-
-
public boolean isAspect() {
return perClause != null;
return perClause;
}
-
-
-
-
-
JavaClass getJavaClass() {
return javaClass;
}
isObject = (javaClass.getSuperclassNameIndex() == 0);
unpackAspectAttributes();
}
-
-
- /**
- * Switch to a new JavaClass and clear all caches
- */
- void replaceJavaClass(JavaClass jc) {
- if (this.javaClass == jc) return;
-
- this.javaClass = jc;
- resetState();
+
+ //XXX we've lost information so that we don't know who wove into this
+ // class, only that someone did. For better error messages we should
+ // probably expand the information in weaverState
+ public boolean isWovenBy(ResolvedTypeX aspectType) {
+ return weaverState == WeaverStateKind.Woven;
}
public WeaverStateKind getWeaverState() {
projects / aspectj.git / commitdiff