issue_id
int64 2.04k
425k
| title
stringlengths 9
251
| body
stringlengths 4
32.8k
⌀ | status
stringclasses 6
values | after_fix_sha
stringlengths 7
7
| project_name
stringclasses 6
values | repo_url
stringclasses 6
values | repo_name
stringclasses 6
values | language
stringclasses 1
value | issue_url
null | before_fix_sha
null | pull_url
null | commit_datetime
timestamp[us, tz=UTC] | report_datetime
timestamp[us, tz=UTC] | updated_file
stringlengths 23
187
| chunk_content
stringlengths 1
22k
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
public static BcelShadow makeConstructorExecution(BcelWorld world, LazyMethodGen enclosingMethod,
InstructionHandle justBeforeStart) {
final InstructionList body = enclosingMethod.getBody();
BcelShadow s = new BcelShadow(world, ConstructorExecution, world.makeJoinPointSignatureFromMethod(enclosingMethod,
Member.CONSTRUCTOR), enclosingMethod, null);
ShadowRange r = new ShadowRange(body);
r.associateWithShadow(s);
r.associateWithTargets(Range.genStart(body, justBeforeStart.getNext()), Range.genEnd(body));
return s;
}
public static BcelShadow makeStaticInitialization(BcelWorld world, LazyMethodGen enclosingMethod) {
InstructionList body = enclosingMethod.getBody();
InstructionHandle clinitStart = body.getStart();
if (clinitStart.getInstruction() instanceof InvokeInstruction) {
InvokeInstruction ii = (InvokeInstruction) clinitStart.getInstruction();
if (ii.getName(enclosingMethod.getEnclosingClass().getConstantPool()).equals(NameMangler.AJC_PRE_CLINIT_NAME)) {
clinitStart = clinitStart.getNext();
}
}
InstructionHandle clinitEnd = body.getEnd();
}
}
BcelShadow s = new BcelShadow(world, StaticInitialization, world.makeJoinPointSignatureFromMethod(enclosingMethod,
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
Member.STATIC_INITIALIZATION), enclosingMethod, null);
ShadowRange r = new ShadowRange(body);
r.associateWithShadow(s);
r.associateWithTargets(Range.genStart(body, clinitStart), Range.genEnd(body, clinitEnd));
return s;
}
/**
* Make the shadow for an exception handler. Currently makes an empty shadow that only allows before advice to be woven into it.
*/
public static BcelShadow makeExceptionHandler(BcelWorld world, ExceptionRange exceptionRange, LazyMethodGen enclosingMethod,
InstructionHandle startOfHandler, BcelShadow enclosingShadow) {
InstructionList body = enclosingMethod.getBody();
UnresolvedType catchType = exceptionRange.getCatchType();
UnresolvedType inType = enclosingMethod.getEnclosingClass().getType();
ResolvedMemberImpl sig = MemberImpl.makeExceptionHandlerSignature(inType, catchType);
sig.setParameterNames(new String[] { findHandlerParamName(startOfHandler) });
BcelShadow s = new BcelShadow(world, ExceptionHandler, sig, enclosingMethod, enclosingShadow);
ShadowRange r = new ShadowRange(body);
r.associateWithShadow(s);
InstructionHandle start = Range.genStart(body, startOfHandler);
InstructionHandle end = Range.genEnd(body, start);
r.associateWithTargets(start, end);
exceptionRange.updateTarget(startOfHandler, start, body);
return s;
}
private static String findHandlerParamName(InstructionHandle startOfHandler) {
if (startOfHandler.getInstruction().isStoreInstruction() && startOfHandler.getNext() != null) {
int slot = startOfHandler.getInstruction().getIndex();
Iterator tIter = startOfHandler.getNext().getTargeters().iterator();
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
while (tIter.hasNext()) {
InstructionTargeter targeter = (InstructionTargeter) tIter.next();
if (targeter instanceof LocalVariableTag) {
LocalVariableTag t = (LocalVariableTag) targeter;
if (t.getSlot() == slot) {
return t.getName();
}
}
}
}
return "<missing>";
}
public static BcelShadow makeIfaceInitialization(BcelWorld world, LazyMethodGen constructor,
Member interfaceConstructorSignature) {
constructor.getBody();
BcelShadow s = new BcelShadow(world, Initialization, interfaceConstructorSignature, constructor, null);
return s;
}
public void initIfaceInitializer(InstructionHandle end) {
final InstructionList body = enclosingMethod.getBody();
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
ShadowRange r = new ShadowRange(body);
r.associateWithShadow(this);
InstructionHandle nop = body.insert(end, InstructionConstants.NOP);
r.associateWithTargets(Range.genStart(body, nop), Range.genEnd(body, nop));
}
{
world,
null);
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
}
/**
* Create an initialization join point associated with a constructor, but not with any body of code yet. If this is actually
* matched, it's range will be set when we inline self constructors.
*
* @param constructor The constructor starting this initialization.
*/
public static BcelShadow makeUnfinishedInitialization(BcelWorld world, LazyMethodGen constructor) {
BcelShadow ret = new BcelShadow(world, Initialization, world.makeJoinPointSignatureFromMethod(constructor,
Member.CONSTRUCTOR), constructor, null);
if (constructor.getEffectiveSignature() != null) {
ret.setMatchingSignature(constructor.getEffectiveSignature().getEffectiveSignature());
}
return ret;
}
public static BcelShadow makeUnfinishedPreinitialization(BcelWorld world, LazyMethodGen constructor) {
BcelShadow ret = new BcelShadow(world, PreInitialization, world.makeJoinPointSignatureFromMethod(constructor,
Member.CONSTRUCTOR), constructor, null);
if (constructor.getEffectiveSignature() != null) {
ret.setMatchingSignature(constructor.getEffectiveSignature().getEffectiveSignature());
}
return ret;
}
public static BcelShadow makeMethodExecution(BcelWorld world, LazyMethodGen enclosingMethod, boolean lazyInit) {
if (!lazyInit)
return makeMethodExecution(world, enclosingMethod);
BcelShadow s = new BcelShadow(world, MethodExecution, enclosingMethod.getMemberView(), enclosingMethod, null);
return s;
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
}
public void init() {
if (range != null)
return;
final InstructionList body = enclosingMethod.getBody();
ShadowRange r = new ShadowRange(body);
r.associateWithShadow(this);
r.associateWithTargets(Range.genStart(body), Range.genEnd(body));
}
public static BcelShadow makeMethodExecution(BcelWorld world, LazyMethodGen enclosingMethod) {
return makeShadowForMethod(world, enclosingMethod, MethodExecution, enclosingMethod.getMemberView());
}
public static BcelShadow makeShadowForMethod(BcelWorld world, LazyMethodGen enclosingMethod, Shadow.Kind kind, Member sig) {
final InstructionList body = enclosingMethod.getBody();
BcelShadow s = new BcelShadow(world, kind, sig, enclosingMethod, null);
ShadowRange r = new ShadowRange(body);
r.associateWithShadow(s);
r.associateWithTargets(
Range.genStart(body), Range.genEnd(body));
return s;
}
public static BcelShadow makeAdviceExecution(BcelWorld world, LazyMethodGen enclosingMethod) {
final InstructionList body = enclosingMethod.getBody();
BcelShadow s = new BcelShadow(world, AdviceExecution, world
.makeJoinPointSignatureFromMethod(enclosingMethod, Member.ADVICE), enclosingMethod, null);
ShadowRange r = new ShadowRange(body);
r.associateWithShadow(s);
r.associateWithTargets(Range.genStart(body), Range.genEnd(body));
return s;
}
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
public static BcelShadow makeConstructorCall(BcelWorld world, LazyMethodGen enclosingMethod, InstructionHandle callHandle,
BcelShadow enclosingShadow) {
final InstructionList body = enclosingMethod.getBody();
Member sig = world.makeJoinPointSignatureForMethodInvocation(enclosingMethod.getEnclosingClass(),
(InvokeInstruction) callHandle.getInstruction());
BcelShadow s = new BcelShadow(world, ConstructorCall, sig, enclosingMethod, enclosingShadow);
ShadowRange r = new ShadowRange(body);
r.associateWithShadow(s);
r.associateWithTargets(Range.genStart(body, callHandle), Range.genEnd(body, callHandle));
retargetAllBranches(callHandle, r.getStart());
return s;
}
public static BcelShadow makeArrayConstructorCall(BcelWorld world, LazyMethodGen enclosingMethod,
InstructionHandle arrayInstruction, BcelShadow enclosingShadow) {
final InstructionList body = enclosingMethod.getBody();
Member sig = world.makeJoinPointSignatureForArrayConstruction(enclosingMethod.getEnclosingClass(), arrayInstruction);
BcelShadow s = new BcelShadow(world, ConstructorCall, sig, enclosingMethod, enclosingShadow);
ShadowRange r = new ShadowRange(body);
r.associateWithShadow(s);
r.associateWithTargets(Range.genStart(body, arrayInstruction), Range.genEnd(body, arrayInstruction));
retargetAllBranches(arrayInstruction, r.getStart());
return s;
}
public static BcelShadow makeMonitorEnter(BcelWorld world, LazyMethodGen enclosingMethod, InstructionHandle monitorInstruction,
BcelShadow enclosingShadow) {
final InstructionList body = enclosingMethod.getBody();
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
Member sig = world.makeJoinPointSignatureForMonitorEnter(enclosingMethod.getEnclosingClass(), monitorInstruction);
BcelShadow s = new BcelShadow(world, SynchronizationLock, sig, enclosingMethod, enclosingShadow);
ShadowRange r = new ShadowRange(body);
r.associateWithShadow(s);
r.associateWithTargets(Range.genStart(body, monitorInstruction), Range.genEnd(body, monitorInstruction));
retargetAllBranches(monitorInstruction, r.getStart());
return s;
}
public static BcelShadow makeMonitorExit(BcelWorld world, LazyMethodGen enclosingMethod, InstructionHandle monitorInstruction,
BcelShadow enclosingShadow) {
final InstructionList body = enclosingMethod.getBody();
Member sig = world.makeJoinPointSignatureForMonitorExit(enclosingMethod.getEnclosingClass(), monitorInstruction);
BcelShadow s = new BcelShadow(world, SynchronizationUnlock, sig, enclosingMethod, enclosingShadow);
ShadowRange r = new ShadowRange(body);
r.associateWithShadow(s);
r.associateWithTargets(Range.genStart(body, monitorInstruction), Range.genEnd(body, monitorInstruction));
retargetAllBranches(monitorInstruction, r.getStart());
return s;
}
{
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
world,
sig,
}
public static BcelShadow makeMethodCall(BcelWorld world, LazyMethodGen enclosingMethod, InstructionHandle callHandle,
BcelShadow enclosingShadow) {
final InstructionList body = enclosingMethod.getBody();
BcelShadow s = new BcelShadow(world, MethodCall, world.makeJoinPointSignatureForMethodInvocation(enclosingMethod
.getEnclosingClass(), (InvokeInstruction) callHandle.getInstruction()), enclosingMethod, enclosingShadow);
ShadowRange r = new ShadowRange(body);
r.associateWithShadow(s);
r.associateWithTargets(Range.genStart(body, callHandle), Range.genEnd(body, callHandle));
retargetAllBranches(callHandle, r.getStart());
return s;
}
public static BcelShadow makeShadowForMethodCall(BcelWorld world, LazyMethodGen enclosingMethod, InstructionHandle callHandle,
BcelShadow enclosingShadow, Kind kind, ResolvedMember sig) {
final InstructionList body = enclosingMethod.getBody();
BcelShadow s = new BcelShadow(world, kind, sig, enclosingMethod, enclosingShadow);
ShadowRange r = new ShadowRange(body);
r.associateWithShadow(s);
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
r.associateWithTargets(Range.genStart(body, callHandle), Range.genEnd(body, callHandle));
retargetAllBranches(callHandle, r.getStart());
return s;
}
public static BcelShadow makeFieldGet(BcelWorld world, ResolvedMember field, LazyMethodGen enclosingMethod,
InstructionHandle getHandle, BcelShadow enclosingShadow) {
final InstructionList body = enclosingMethod.getBody();
BcelShadow s = new BcelShadow(world, FieldGet, field,
enclosingMethod, enclosingShadow);
ShadowRange r = new ShadowRange(body);
r.associateWithShadow(s);
r.associateWithTargets(Range.genStart(body, getHandle), Range.genEnd(body, getHandle));
retargetAllBranches(getHandle, r.getStart());
return s;
}
public static BcelShadow makeFieldSet(BcelWorld world, ResolvedMember field, LazyMethodGen enclosingMethod,
InstructionHandle setHandle, BcelShadow enclosingShadow) {
final InstructionList body = enclosingMethod.getBody();
BcelShadow s = new BcelShadow(world, FieldSet, field,
enclosingMethod, enclosingShadow);
ShadowRange r = new ShadowRange(body);
r.associateWithShadow(s);
r.associateWithTargets(Range.genStart(body, setHandle), Range.genEnd(body, setHandle));
retargetAllBranches(setHandle, r.getStart());
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
return s;
}
public static void retargetAllBranches(InstructionHandle from, InstructionHandle to) {
InstructionTargeter[] sources = from.getTargetersArray();
if (sources != null) {
for (int i = sources.length - 1; i >= 0; i--) {
InstructionTargeter source = sources[i];
if (source instanceof InstructionBranch) {
source.updateTarget(from, to);
}
}
}
}
}
}
/**
* If the end of my range has no real instructions following then my context needs a return at the end.
*/
public boolean terminatesWithReturn() {
return getRange().getRealNext() == null;
}
/**
* Is arg0 occupied with the value of this
*/
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
public boolean arg0HoldsThis() {
if (getKind().isEnclosingKind()) {
return !getSignature().isStatic();
} else if (enclosingShadow == null) {
return !enclosingMethod.isStatic();
} else {
return ((BcelShadow) enclosingShadow).arg0HoldsThis();
}
}
private BcelVar thisVar = null;
private BcelVar targetVar = null;
private BcelVar[] argVars = null;
private MapkindedAnnotationVars = null;
private MapthisAnnotationVars = null;
private MaptargetAnnotationVars = null;
private Map[] argAnnotationVars = null;
private MapwithinAnnotationVars = null;
private MapwithincodeAnnotationVars = null;
private boolean allArgVarsInitialized = false;
public Var getThisVar() {
if (!hasThis()) {
throw new IllegalStateException("no this");
}
initializeThisVar();
return thisVar;
}
public Var getThisAnnotationVar(UnresolvedType forAnnotationType) {
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
if (!hasThis()) {
throw new IllegalStateException("no this");
}
initializeThisAnnotationVars();
Var v = (Var) thisAnnotationVars.get(forAnnotationType);
if (v == null)
v = new TypeAnnotationAccessVar(forAnnotationType.resolve(world), (BcelVar) getThisVar());
return v;
}
public Var getTargetVar() {
if (!hasTarget()) {
throw new IllegalStateException("no target");
}
initializeTargetVar();
return targetVar;
}
public Var getTargetAnnotationVar(UnresolvedType forAnnotationType) {
if (!hasTarget()) {
throw new IllegalStateException("no target");
}
initializeTargetAnnotationVars();
Var v = (Var) targetAnnotationVars.get(forAnnotationType);
if (v == null)
v = new TypeAnnotationAccessVar(forAnnotationType.resolve(world), (BcelVar) getTargetVar());
return v;
}
public Var getArgVar(int i) {
ensureInitializedArgVar(i);
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
return argVars[i];
}
public Var getArgAnnotationVar(int i, UnresolvedType forAnnotationType) {
initializeArgAnnotationVars();
Var v = (Var) argAnnotationVars[i].get(forAnnotationType);
if (v == null)
v = new TypeAnnotationAccessVar(forAnnotationType.resolve(world), (BcelVar) getArgVar(i));
return v;
}
public Var getKindedAnnotationVar(UnresolvedType forAnnotationType) {
initializeKindedAnnotationVars();
return (Var) kindedAnnotationVars.get(forAnnotationType);
}
public Var getWithinAnnotationVar(UnresolvedType forAnnotationType) {
initializeWithinAnnotationVars();
return (Var) withinAnnotationVars.get(forAnnotationType);
}
public Var getWithinCodeAnnotationVar(UnresolvedType forAnnotationType) {
initializeWithinCodeAnnotationVars();
return (Var) withincodeAnnotationVars.get(forAnnotationType);
}
private BcelVar thisJoinPointVar = null;
private boolean isThisJoinPointLazy;
private int lazyTjpConsumers = 0;
private BcelVar thisJoinPointStaticPartVar = null;
public final Var getThisJoinPointStaticPartVar() {
return getThisJoinPointStaticPartBcelVar();
}
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
public final Var getThisEnclosingJoinPointStaticPartVar() {
return getThisEnclosingJoinPointStaticPartBcelVar();
}
public void requireThisJoinPoint(boolean hasGuardTest, boolean isAround) {
if (!isAround) {
if (!hasGuardTest) {
isThisJoinPointLazy = false;
} else {
lazyTjpConsumers++;
}
}
}
if (thisJoinPointVar == null) {
thisJoinPointVar = genTempVar(UnresolvedType.forName("org.aspectj.lang.JoinPoint"));
}
}
public Var getThisJoinPointVar() {
requireThisJoinPoint(false, false);
return thisJoinPointVar;
}
void initializeThisJoinPoint() {
if (thisJoinPointVar == null)
return;
if (isThisJoinPointLazy) {
isThisJoinPointLazy = checkLazyTjp();
}
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
if (isThisJoinPointLazy) {
appliedLazyTjpOptimization = true;
createThisJoinPoint();
if (lazyTjpConsumers == 1)
return;
InstructionFactory fact = getFactory();
InstructionList il = new InstructionList();
il.append(InstructionConstants.ACONST_NULL);
il.append(thisJoinPointVar.createStore(fact));
range.insert(il, Range.OutsideBefore);
} else {
appliedLazyTjpOptimization = false;
InstructionFactory fact = getFactory();
InstructionList il = createThisJoinPoint();
il.append(thisJoinPointVar.createStore(fact));
range.insert(il, Range.OutsideBefore);
}
}
private boolean checkLazyTjp() {
for (Iterator i = mungers.iterator(); i.hasNext();) {
ShadowMunger munger = (ShadowMunger) i.next();
if (munger instanceof Advice) {
if (((Advice) munger).getKind() == AdviceKind.Around) {
if (munger.getSourceLocation() != null) {
if (world.getLint().canNotImplementLazyTjp.isEnabled()) {
world.getLint().canNotImplementLazyTjp.signal(new String[] { toString() }, getSourceLocation(),
new ISourceLocation[] { munger.getSourceLocation() });
}
}
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
return false;
}
}
}
return true;
}
InstructionList loadThisJoinPoint() {
InstructionFactory fact = getFactory();
InstructionList il = new InstructionList();
if (isThisJoinPointLazy) {
il.append(createThisJoinPoint());
if (lazyTjpConsumers > 1) {
il.append(thisJoinPointVar.createStore(fact));
InstructionHandle end = il.append(thisJoinPointVar.createLoad(fact));
il.insert(InstructionFactory.createBranchInstruction(Constants.IFNONNULL, end));
il.insert(thisJoinPointVar.createLoad(fact));
}
} else {
thisJoinPointVar.appendLoad(il, fact);
}
return il;
}
InstructionList createThisJoinPoint() {
InstructionFactory fact = getFactory();
InstructionList il = new InstructionList();
BcelVar staticPart = getThisJoinPointStaticPartBcelVar();
staticPart.appendLoad(il, fact);
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
if (hasThis()) {
((BcelVar) getThisVar()).appendLoad(il, fact);
} else {
il.append(InstructionConstants.ACONST_NULL);
}
if (hasTarget()) {
((BcelVar) getTargetVar()).appendLoad(il, fact);
} else {
il.append(InstructionConstants.ACONST_NULL);
}
switch (getArgCount()) {
case 0:
il.append(fact.createInvoke("org.aspectj.runtime.reflect.Factory", "makeJP", LazyClassGen.tjpType, new Type[] {
LazyClassGen.staticTjpType, Type.OBJECT, Type.OBJECT }, Constants.INVOKESTATIC));
break;
case 1:
((BcelVar) getArgVar(0)).appendLoadAndConvert(il, fact, world.getCoreType(ResolvedType.OBJECT));
il.append(fact.createInvoke("org.aspectj.runtime.reflect.Factory", "makeJP", LazyClassGen.tjpType, new Type[] {
LazyClassGen.staticTjpType, Type.OBJECT, Type.OBJECT, Type.OBJECT }, Constants.INVOKESTATIC));
break;
case 2:
((BcelVar) getArgVar(0)).appendLoadAndConvert(il, fact, world.getCoreType(ResolvedType.OBJECT));
((BcelVar) getArgVar(1)).appendLoadAndConvert(il, fact, world.getCoreType(ResolvedType.OBJECT));
il.append(fact.createInvoke("org.aspectj.runtime.reflect.Factory", "makeJP", LazyClassGen.tjpType, new Type[] {
LazyClassGen.staticTjpType, Type.OBJECT, Type.OBJECT, Type.OBJECT, Type.OBJECT }, Constants.INVOKESTATIC));
break;
default:
il.append(makeArgsObjectArray());
il.append(fact.createInvoke("org.aspectj.runtime.reflect.Factory", "makeJP", LazyClassGen.tjpType, new Type[] {
LazyClassGen.staticTjpType, Type.OBJECT, Type.OBJECT, new ArrayType(Type.OBJECT, 1) }, Constants.INVOKESTATIC));
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
break;
}
return il;
}
/**
* Get the Var for the jpStaticPart
*
* @return
*/
public BcelVar getThisJoinPointStaticPartBcelVar() {
return getThisJoinPointStaticPartBcelVar(false);
}
/**
* Get the Var for the xxxxJpStaticPart, xxx = this or enclosing
*
* @param isEnclosingJp true to have the enclosingJpStaticPart
* @return
*/
public BcelVar getThisJoinPointStaticPartBcelVar(final boolean isEnclosingJp) {
if (thisJoinPointStaticPartVar == null) {
Field field = getEnclosingClass().getTjpField(this, isEnclosingJp);
ResolvedType sjpType = null;
if (world.isTargettingAspectJRuntime12()) {
sjpType = world.getCoreType(UnresolvedType.JOINPOINT_STATICPART);
} else {
sjpType = isEnclosingJp ? world.getCoreType(UnresolvedType.JOINPOINT_ENCLOSINGSTATICPART) : world
.getCoreType(UnresolvedType.JOINPOINT_STATICPART);
}
thisJoinPointStaticPartVar = new BcelFieldRef(sjpType, getEnclosingClass().getClassName(), field.getName());
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
}
return thisJoinPointStaticPartVar;
}
/**
* Get the Var for the enclosingJpStaticPart
*
* @return
*/
public BcelVar getThisEnclosingJoinPointStaticPartBcelVar() {
if (enclosingShadow == null) {
return getThisJoinPointStaticPartBcelVar(true);
} else {
return ((BcelShadow) enclosingShadow).getThisJoinPointStaticPartBcelVar(true);
}
}
public Member getEnclosingCodeSignature() {
if (getKind().isEnclosingKind()) {
return getSignature();
} else if (getKind() == Shadow.PreInitialization) {
return getSignature();
} else if (enclosingShadow == null) {
return getEnclosingMethod().getMemberView();
} else {
return enclosingShadow.getSignature();
}
}
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
private InstructionList makeArgsObjectArray() {
InstructionFactory fact = getFactory();
BcelVar arrayVar = genTempVar(UnresolvedType.OBJECTARRAY);
final InstructionList il = new InstructionList();
int alen = getArgCount();
il.append(Utility.createConstant(fact, alen));
il.append(fact.createNewArray(Type.OBJECT, (short) 1));
arrayVar.appendStore(il, fact);
int stateIndex = 0;
for (int i = 0, len = getArgCount(); i < len; i++) {
arrayVar.appendConvertableArrayStore(il, fact, stateIndex, (BcelVar) getArgVar(i));
stateIndex++;
}
arrayVar.appendLoad(il, fact);
return il;
}
/*
* initializing this is doesn't do anything, because this is protected from side-effects, so we don't need to copy its location
*/
private void initializeThisVar() {
if (thisVar != null)
return;
thisVar = new BcelVar(getThisType().resolve(world), 0);
thisVar.setPositionInAroundState(0);
}
public void initializeTargetVar() {
InstructionFactory fact = getFactory();
if (targetVar != null)
return;
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
if (getKind().isTargetSameAsThis()) {
if (hasThis())
initializeThisVar();
targetVar = thisVar;
} else {
initializeArgVars();
UnresolvedType type = getTargetType();
type = ensureTargetTypeIsCorrect(type);
targetVar = genTempVar(type, "ajc$target");
range.insert(targetVar.createStore(fact), Range.OutsideBefore);
targetVar.setPositionInAroundState(hasThis() ? 1 : 0);
}
}
/*
* PR 72528 This method double checks the target type under certain conditions. The Java 1.4 compilers seem to take calls to
* clone methods on array types and create bytecode that looks like clone is being called on Object. If we advise a clone call
* with around advice we extract the call into a helper method which we can then refer to. Because the type in the bytecode for
* the call to clone is Object we create a helper method with an Object parameter - this is not correct as we have lost the fact
* that the actual type is an array type. If we don't do the check below we will create code that fails java verification. This
* method checks for the peculiar set of conditions and if they are true, it has a sneak peek at the code before the call to see
* what is on the stack.
*/
public UnresolvedType ensureTargetTypeIsCorrect(UnresolvedType tx) {
Member msig = getSignature();
if (msig.getArity() == 0 && getKind() == MethodCall && msig.getName().charAt(0) == 'c' && tx.equals(ResolvedType.OBJECT)
&& msig.getReturnType().equals(ResolvedType.OBJECT) && msig.getName().equals("clone")) {
InstructionHandle searchPtr = range.getStart().getPrev();
while (Range.isRangeHandle(searchPtr) || searchPtr.getInstruction().isStoreInstruction()) {
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
searchPtr = searchPtr.getPrev();
}
if (searchPtr.getInstruction().isLoadInstruction()) {
LocalVariableTag lvt = LazyMethodGen.getLocalVariableTag(searchPtr, searchPtr.getInstruction().getIndex());
if (lvt != null)
return UnresolvedType.forSignature(lvt.getType());
}
if (searchPtr.getInstruction() instanceof FieldInstruction) {
FieldInstruction si = (FieldInstruction) searchPtr.getInstruction();
Type t = si.getFieldType(getEnclosingClass().getConstantPool());
return BcelWorld.fromBcel(t);
}
if (searchPtr.getInstruction().opcode == Constants.ANEWARRAY) {
return BcelWorld.fromBcel(new ArrayType(Type.OBJECT, 1));
}
if (searchPtr.getInstruction() instanceof MULTIANEWARRAY) {
MULTIANEWARRAY ana = (MULTIANEWARRAY) searchPtr.getInstruction();
return BcelWorld.fromBcel(new ArrayType(Type.OBJECT, ana.getDimensions()));
}
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
throw new BCException("Can't determine real target of clone() when processing instruction "
+ searchPtr.getInstruction() + ". Perhaps avoid selecting clone with your pointcut?");
}
return tx;
}
public void ensureInitializedArgVar(int argNumber) {
if (allArgVarsInitialized || (argVars != null && argVars[argNumber] != null)) {
return;
}
InstructionFactory fact = getFactory();
int len = getArgCount();
if (argVars == null) {
argVars = new BcelVar[len];
}
int positionOffset = (hasTarget() ? 1 : 0) + ((hasThis() && !getKind().isTargetSameAsThis()) ? 1 : 0);
if (getKind().argsOnStack()) {
for (int i = len - 1; i >= 0; i--) {
UnresolvedType type = getArgType(i);
BcelVar tmp = genTempVar(type, "ajc$arg" + i);
range.insert(tmp.createStore(getFactory()), Range.OutsideBefore);
int position = i;
position += positionOffset;
tmp.setPositionInAroundState(position);
argVars[i] = tmp;
}
allArgVarsInitialized = true;
} else {
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
int index = 0;
if (arg0HoldsThis()) {
index++;
}
boolean allInited = true;
for (int i = 0; i < len; i++) {
UnresolvedType type = getArgType(i);
if (i == argNumber) {
argVars[argNumber] = genTempVar(type, "ajc$arg" + argNumber);
range.insert(argVars[argNumber].createCopyFrom(fact, index), Range.OutsideBefore);
argVars[argNumber].setPositionInAroundState(argNumber + positionOffset);
}
allInited = allInited && argVars[i] != null;
index += type.getSize();
}
if (allInited && (argNumber + 1) == len) {
allArgVarsInitialized = true;
}
}
}
/**
* Initialize all the available arguments at the shadow. This means creating a copy of them that we can then use for advice
* calls (the copy ensures we are not affected by other advice changing the values). This method initializes all arguments
* whereas the method ensureInitializedArgVar will only ensure a single argument is setup.
*/
public void initializeArgVars() {
if (allArgVarsInitialized) {
return;
}
InstructionFactory fact = getFactory();
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
int len = getArgCount();
if (argVars == null) {
argVars = new BcelVar[len];
}
int positionOffset = (hasTarget() ? 1 : 0) + ((hasThis() && !getKind().isTargetSameAsThis()) ? 1 : 0);
if (getKind().argsOnStack()) {
for (int i = len - 1; i >= 0; i--) {
UnresolvedType type = getArgType(i);
BcelVar tmp = genTempVar(type, "ajc$arg" + i);
range.insert(tmp.createStore(getFactory()), Range.OutsideBefore);
int position = i;
position += positionOffset;
tmp.setPositionInAroundState(position);
argVars[i] = tmp;
}
} else {
int index = 0;
if (arg0HoldsThis()) {
index++;
}
for (int i = 0; i < len; i++) {
UnresolvedType type = getArgType(i);
if (argVars[i] == null) {
BcelVar tmp = genTempVar(type, "ajc$arg" + i);
range.insert(tmp.createCopyFrom(fact, index), Range.OutsideBefore);
argVars[i] = tmp;
tmp.setPositionInAroundState(i + positionOffset);
}
index += type.getSize();
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
}
}
allArgVarsInitialized = true;
}
public void initializeForAroundClosure() {
initializeArgVars();
if (hasTarget())
initializeTargetVar();
if (hasThis())
initializeThisVar();
}
public void initializeThisAnnotationVars() {
if (thisAnnotationVars != null)
return;
thisAnnotationVars = new HashMap();
}
public void initializeTargetAnnotationVars() {
if (targetAnnotationVars != null)
return;
if (getKind().isTargetSameAsThis()) {
if (hasThis())
initializeThisAnnotationVars();
targetAnnotationVars = thisAnnotationVars;
} else {
targetAnnotationVars = new HashMap();
ResolvedType[] rtx = this.getTargetType().resolve(world).getAnnotationTypes();
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
for (int i = 0; i < rtx.length; i++) {
ResolvedType typeX = rtx[i];
targetAnnotationVars.put(typeX, new TypeAnnotationAccessVar(typeX, (BcelVar) getTargetVar()));
}
}
}
public void initializeArgAnnotationVars() {
if (argAnnotationVars != null)
return;
int numArgs = getArgCount();
argAnnotationVars = new Map[numArgs];
for (int i = 0; i < argAnnotationVars.length; i++) {
argAnnotationVars[i] = new HashMap();
}
}
protected ResolvedMember getRelevantMember(ResolvedMember foundMember, Member relevantMember, ResolvedType relevantType) {
if (foundMember != null) {
return foundMember;
}
foundMember = getSignature().resolve(world);
if (foundMember == null && relevantMember != null) {
foundMember = relevantType.lookupMemberWithSupersAndITDs(relevantMember);
}
List mungers = relevantType.resolve(world).getInterTypeMungers();
for (Iterator iter = mungers.iterator(); iter.hasNext();) {
BcelTypeMunger typeMunger = (BcelTypeMunger) iter.next();
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
if (typeMunger.getMunger() instanceof NewMethodTypeMunger || typeMunger.getMunger() instanceof NewConstructorTypeMunger) {
ResolvedMember fakerm = typeMunger.getSignature();
if (fakerm.getName().equals(getSignature().getName())
&& fakerm.getParameterSignature().equals(getSignature().getParameterSignature())) {
if (foundMember.getKind() == ResolvedMember.CONSTRUCTOR) {
foundMember = AjcMemberMaker.interConstructor(relevantType, foundMember, typeMunger.getAspectType());
} else {
foundMember = AjcMemberMaker.interMethod(foundMember, typeMunger.getAspectType(), false);
}
return foundMember;
}
}
}
return foundMember;
}
protected ResolvedType[] getAnnotations(ResolvedMember foundMember, Member relevantMember, ResolvedType relevantType) {
if (foundMember == null) {
List mungers = relevantType.resolve(world).getInterTypeMungers();
for (Iterator iter = mungers.iterator(); iter.hasNext();) {
BcelTypeMunger typeMunger = (BcelTypeMunger) iter.next();
if (typeMunger.getMunger() instanceof NewMethodTypeMunger
|| typeMunger.getMunger() instanceof NewConstructorTypeMunger) {
ResolvedMember fakerm = typeMunger.getSignature();
ResolvedMember ajcMethod = (getSignature().getKind() == ResolvedMember.CONSTRUCTOR ? AjcMemberMaker
.postIntroducedConstructor(typeMunger.getAspectType(), fakerm.getDeclaringType(), fakerm
.getParameterTypes()) : AjcMemberMaker
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
.interMethodDispatcher(fakerm, typeMunger.getAspectType()));
ResolvedMember rmm = findMethod(typeMunger.getAspectType(), ajcMethod);
if (fakerm.getName().equals(getSignature().getName())
&& fakerm.getParameterSignature().equals(getSignature().getParameterSignature())) {
relevantType = typeMunger.getAspectType();
foundMember = rmm;
return foundMember.getAnnotationTypes();
}
}
}
foundMember = relevantType.lookupMemberWithSupersAndITDs(relevantMember);
if (foundMember == null) {
throw new IllegalStateException("Couldn't find member " + relevantMember + " for type " + relevantType);
}
}
return foundMember.getAnnotationTypes();
}
/**
* By determining what "kind" of shadow we are, we can find out the annotations on the appropriate element (method, field,
* constructor, type). Then create one BcelVar entry in the map for each annotation, keyed by annotation type.
*/
public void initializeKindedAnnotationVars() {
if (kindedAnnotationVars != null) {
return;
}
kindedAnnotationVars = new HashMap();
ResolvedType[] annotations = null;
Member shadowSignature = getSignature();
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
Member annotationHolder = getSignature();
ResolvedType relevantType = shadowSignature.getDeclaringType().resolve(world);
if (relevantType.isRawType() || relevantType.isParameterizedType()) {
relevantType = relevantType.getGenericType();
}
if (getKind() == Shadow.StaticInitialization) {
annotations = relevantType.resolve(world).getAnnotationTypes();
} else if (getKind() == Shadow.MethodCall || getKind() == Shadow.ConstructorCall) {
ResolvedMember foundMember = findMethod2(relevantType.resolve(world).getDeclaredMethods(), getSignature());
annotations = getAnnotations(foundMember, shadowSignature, relevantType);
annotationHolder = getRelevantMember(foundMember, shadowSignature, relevantType);
relevantType = annotationHolder.getDeclaringType().resolve(world);
} else if (getKind() == Shadow.FieldSet || getKind() == Shadow.FieldGet) {
annotationHolder = findField(relevantType.getDeclaredFields(), getSignature());
if (annotationHolder == null) {
List mungers = relevantType.resolve(world).getInterTypeMungers();
for (Iterator iter = mungers.iterator(); iter.hasNext();) {
BcelTypeMunger typeMunger = (BcelTypeMunger) iter.next();
if (typeMunger.getMunger() instanceof NewFieldTypeMunger) {
ResolvedMember fakerm = typeMunger.getSignature();
ResolvedMember ajcMethod = AjcMemberMaker.interFieldInitializer(fakerm, typeMunger.getAspectType());
ResolvedMember rmm = findMethod(typeMunger.getAspectType(), ajcMethod);
if (fakerm.equals(getSignature())) {
relevantType = typeMunger.getAspectType();
annotationHolder = rmm;
}
}
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
}
}
annotations = ((ResolvedMember) annotationHolder).getAnnotationTypes();
} else if (getKind() == Shadow.MethodExecution || getKind() == Shadow.ConstructorExecution
|| getKind() == Shadow.AdviceExecution) {
ResolvedMember foundMember = findMethod2(relevantType.getDeclaredMethods(), getSignature());
annotations = getAnnotations(foundMember, shadowSignature, relevantType);
annotationHolder = foundMember;
annotationHolder = getRelevantMember(foundMember, annotationHolder, relevantType);
} else if (getKind() == Shadow.ExceptionHandler) {
relevantType = getSignature().getParameterTypes()[0].resolve(world);
annotations = relevantType.getAnnotationTypes();
} else if (getKind() == Shadow.PreInitialization || getKind() == Shadow.Initialization) {
ResolvedMember found = findMethod2(relevantType.getDeclaredMethods(), getSignature());
annotations = found.getAnnotationTypes();
}
if (annotations == null) {
throw new BCException("Could not discover annotations for shadow: " + getKind());
}
for (int i = 0; i < annotations.length; i++) {
ResolvedType annotationType = annotations[i];
AnnotationAccessVar accessVar = new AnnotationAccessVar(getKind(), annotationType.resolve(world), relevantType,
annotationHolder);
kindedAnnotationVars.put(annotationType, accessVar);
}
}
ResolvedMember findMethod2(ResolvedMember rm[], Member sig) {
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
ResolvedMember found = null;
for (int i = 0; i < rm.length && found == null; i++) {
ResolvedMember member = rm[i];
if (member.getName().equals(sig.getName()) && member.getParameterSignature().equals(sig.getParameterSignature()))
found = member;
}
return found;
}
private ResolvedMember findMethod(ResolvedType aspectType, ResolvedMember ajcMethod) {
ResolvedMember decMethods[] = aspectType.getDeclaredMethods();
for (int i = 0; i < decMethods.length; i++) {
ResolvedMember member = decMethods[i];
if (member.equals(ajcMethod))
return member;
}
return null;
}
private ResolvedMember findField(ResolvedMember[] members, Member lookingFor) {
for (int i = 0; i < members.length; i++) {
ResolvedMember member = members[i];
if (member.getName().equals(getSignature().getName()) && member.getType().equals(getSignature().getType())) {
return member;
}
}
return null;
}
public void initializeWithinAnnotationVars() {
if (withinAnnotationVars != null)
return;
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
withinAnnotationVars = new HashMap();
ResolvedType[] annotations = getEnclosingType().resolve(world).getAnnotationTypes();
for (int i = 0; i < annotations.length; i++) {
ResolvedType ann = annotations[i];
Kind k = Shadow.StaticInitialization;
withinAnnotationVars.put(ann, new AnnotationAccessVar(k, ann, getEnclosingType(), null));
}
}
public void initializeWithinCodeAnnotationVars() {
if (withincodeAnnotationVars != null)
return;
withincodeAnnotationVars = new HashMap();
ResolvedType[] annotations = getEnclosingMethod().getMemberView().getAnnotationTypes();
for (int i = 0; i < annotations.length; i++) {
ResolvedType ann = annotations[i];
Kind k = (getEnclosingMethod().getMemberView().getKind() == Member.CONSTRUCTOR ? Shadow.ConstructorExecution
: Shadow.MethodExecution);
withincodeAnnotationVars.put(ann, new AnnotationAccessVar(k, ann, getEnclosingType(), getEnclosingCodeSignature()));
}
}
void weaveBefore(BcelAdvice munger) {
range.insert(munger.getAdviceInstructions(this, null, range.getRealStart()), Range.InsideBefore);
}
public void weaveAfter(BcelAdvice munger) {
weaveAfterThrowing(munger, UnresolvedType.THROWABLE);
weaveAfterReturning(munger);
}
/**
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
* The basic strategy here is to add a set of instructions at the end of the shadow range that dispatch the advice, and then
* return whatever the shadow was going to return anyway.
*
* To achieve this, we note all the return statements in the advice, and replace them with code that: 1) stores the return value
* on top of the stack in a temp var 2) jumps to the start of our advice block 3) restores the return value at the end of the
* advice block before ultimately returning
*
* We also need to bind the return value into a returning parameter, if the advice specified one.
*/
public void weaveAfterReturning(BcelAdvice munger) {
List returns = findReturnInstructions();
boolean hasReturnInstructions = !returns.isEmpty();
InstructionList retList = new InstructionList();
BcelVar returnValueVar = null;
if (hasReturnInstructions) {
returnValueVar = generateReturnInstructions(returns, retList);
} else {
retList.append(InstructionConstants.NOP);
}
InstructionList advice = getAfterReturningAdviceDispatchInstructions(munger, retList.getStart());
if (hasReturnInstructions) {
InstructionHandle gotoTarget = advice.getStart();
for (Iterator i = returns.iterator(); i.hasNext();) {
InstructionHandle ih = (InstructionHandle) i.next();
retargetReturnInstruction(munger.hasExtraParameter(), returnValueVar, gotoTarget, ih);
}
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
}
range.append(advice);
range.append(retList);
}
/**
* @return a list of all the return instructions in the range of this shadow
*/
private List findReturnInstructions() {
List returns = new ArrayList();
for (InstructionHandle ih = range.getStart(); ih != range.getEnd(); ih = ih.getNext()) {
if (ih.getInstruction().isReturnInstruction()) {
returns.add(ih);
}
}
return returns;
}
/**
* Given a list containing all the return instruction handles for this shadow, finds the last return instruction and copies it,
* making this the ultimate return. If the shadow has a non-void return type, we also create a temporary variable to hold the
* return value, and load the value from this var before returning (see pr148007 for why we do this - it works around a JRockit
* bug, and is also closer to what javac generates)
*
* Sometimes the 'last return' isnt the right one - some rogue code can include the real return from the body of a subroutine
* that exists at the end of the method. In this case the last return is RETURN but that may not be correct for a method with a
* non-void return type... pr151673
*
* @param returns list of all the return instructions in the shadow
* @param returnInstructions instruction list into which the return instructions should be generated
* @return the variable holding the return value, if needed
*/
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
private BcelVar generateReturnInstructions(List returns, InstructionList returnInstructions) {
BcelVar returnValueVar = null;
if (this.hasANonVoidReturnType()) {
Instruction newReturnInstruction = null;
int i = returns.size() - 1;
while (newReturnInstruction == null && i >= 0) {
InstructionHandle ih = (InstructionHandle) returns.get(i);
if (ih.getInstruction().opcode != Constants.RETURN) {
newReturnInstruction = Utility.copyInstruction(ih.getInstruction());
}
i--;
}
returnValueVar = genTempVar(this.getReturnType());
returnValueVar.appendLoad(returnInstructions, getFactory());
returnInstructions.append(newReturnInstruction);
} else {
InstructionHandle lastReturnHandle = (InstructionHandle) returns.get(returns.size() - 1);
Instruction newReturnInstruction = Utility.copyInstruction(lastReturnHandle.getInstruction());
returnInstructions.append(newReturnInstruction);
}
return returnValueVar;
}
/**
* @return true, iff this shadow returns a value
*/
private boolean hasANonVoidReturnType() {
return this.getReturnType() != ResolvedType.VOID;
}
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
/**
* Get the list of instructions used to dispatch to the after advice
*
* @param munger
* @param firstInstructionInReturnSequence
* @return
*/
private InstructionList getAfterReturningAdviceDispatchInstructions(BcelAdvice munger,
InstructionHandle firstInstructionInReturnSequence) {
InstructionList advice = new InstructionList();
BcelVar tempVar = null;
if (munger.hasExtraParameter()) {
tempVar = insertAdviceInstructionsForBindingReturningParameter(advice);
}
advice.append(munger.getAdviceInstructions(this, tempVar, firstInstructionInReturnSequence));
return advice;
}
/**
* If the after() returning(Foo f) form is used, bind the return value to the parameter. If the shadow returns void, bind null.
*
* @param advice
* @return
*/
private BcelVar insertAdviceInstructionsForBindingReturningParameter(InstructionList advice) {
BcelVar tempVar;
UnresolvedType tempVarType = getReturnType();
if (tempVarType.equals(ResolvedType.VOID)) {
tempVar = genTempVar(UnresolvedType.OBJECT);
advice.append(InstructionConstants.ACONST_NULL);
tempVar.appendStore(advice, getFactory());
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
} else {
tempVar = genTempVar(tempVarType);
advice.append(InstructionFactory.createDup(tempVarType.getSize()));
tempVar.appendStore(advice, getFactory());
}
return tempVar;
}
/**
* Helper method for weaveAfterReturning
*
* Each return instruction in the method body is retargeted by calling this method. The return instruction is replaced by up to
* three instructions: 1) if the shadow returns a value, and that value is bound to an after returning parameter, then we DUP
* the return value on the top of the stack 2) if the shadow returns a value, we store it in the returnValueVar (it will be
* retrieved from here when we ultimately return after the advice dispatch) 3) if the return was the last instruction, we add a
* NOP (it will fall through to the advice dispatch), otherwise we add a GOTO that branches to the supplied gotoTarget (start of
* the advice dispatch)
*/
private void retargetReturnInstruction(boolean hasReturningParameter, BcelVar returnValueVar, InstructionHandle gotoTarget,
InstructionHandle returnHandle) {
InstructionList newInstructions = new InstructionList();
if (returnValueVar != null) {
if (hasReturningParameter) {
newInstructions.append(InstructionFactory.createDup(this.getReturnType().getSize()));
}
returnValueVar.appendStore(newInstructions, getFactory());
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
}
if (!isLastInstructionInRange(returnHandle, range)) {
newInstructions.append(InstructionFactory.createBranchInstruction(Constants.GOTO, gotoTarget));
}
if (newInstructions.isEmpty()) {
newInstructions.append(InstructionConstants.NOP);
}
Utility.replaceInstruction(returnHandle, newInstructions, enclosingMethod);
}
private boolean isLastInstructionInRange(InstructionHandle ih, ShadowRange aRange) {
return ih.getNext() == aRange.getEnd();
}
public void weaveAfterThrowing(BcelAdvice munger, UnresolvedType catchType) {
if (getRange().getStart().getNext() == getRange().getEnd())
return;
InstructionFactory fact = getFactory();
InstructionList handler = new InstructionList();
BcelVar exceptionVar = genTempVar(catchType);
exceptionVar.appendStore(handler, fact);
pr62642
if (this.getEnclosingMethod().getName().equals("<clinit>")) {
ResolvedType eiieType = world.resolve("java.lang.ExceptionInInitializerError");
ObjectType eiieBcelType = (ObjectType) BcelWorld.makeBcelType(eiieType);
InstructionList ih = new InstructionList(InstructionConstants.NOP);
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
handler.append(exceptionVar.createLoad(fact));
handler.append(fact.createInstanceOf(eiieBcelType));
InstructionBranch bi = InstructionFactory.createBranchInstruction(Constants.IFEQ, ih.getStart());
handler.append(bi);
handler.append(exceptionVar.createLoad(fact));
handler.append(fact.createCheckCast(eiieBcelType));
handler.append(InstructionConstants.ATHROW);
handler.append(ih);
}
InstructionList endHandler = new InstructionList(exceptionVar.createLoad(fact));
handler.append(munger.getAdviceInstructions(this, exceptionVar, endHandler.getStart()));
handler.append(endHandler);
handler.append(InstructionConstants.ATHROW);
InstructionHandle handlerStart = handler.getStart();
if (isFallsThrough()) {
InstructionHandle jumpTarget = handler.append(InstructionConstants.NOP);
handler.insert(InstructionFactory.createBranchInstruction(Constants.GOTO, jumpTarget));
}
InstructionHandle protectedEnd = handler.getStart();
range.insert(handler, Range.InsideAfter);
enclosingMethod.addExceptionHandler(range.getStart().getNext(), protectedEnd.getPrev(), handlerStart,
(ObjectType) BcelWorld.makeBcelType(catchType),
getKind().hasHighPriorityExceptions());
}
public void weaveSoftener(BcelAdvice munger, UnresolvedType catchType) {
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
if (getRange().getStart().getNext() == getRange().getEnd())
return;
InstructionFactory fact = getFactory();
InstructionList handler = new InstructionList();
InstructionList rtExHandler = new InstructionList();
BcelVar exceptionVar = genTempVar(catchType);
handler.append(fact.createNew(NameMangler.SOFT_EXCEPTION_TYPE));
handler.append(InstructionFactory.createDup(1));
handler.append(exceptionVar.createLoad(fact));
handler.append(fact.createInvoke(NameMangler.SOFT_EXCEPTION_TYPE, "<init>", Type.VOID, new Type[] { Type.THROWABLE },
Constants.INVOKESPECIAL));
handler.append(InstructionConstants.ATHROW);
exceptionVar.appendStore(rtExHandler, fact);
aload_1
rtExHandler.append(exceptionVar.createLoad(fact));
rtExHandler.append(fact.createInstanceOf(new ObjectType("java.lang.RuntimeException")));
rtExHandler.append(InstructionFactory.createBranchInstruction(Constants.IFEQ, handler.getStart()));
aload_1
rtExHandler.append(exceptionVar.createLoad(fact));
athrow
rtExHandler.append(InstructionFactory.ATHROW);
InstructionHandle handlerStart = rtExHandler.getStart();
if (isFallsThrough()) {
InstructionHandle jumpTarget = range.getEnd();
rtExHandler.insert(InstructionFactory.createBranchInstruction(Constants.GOTO, jumpTarget));
}
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
rtExHandler.append(handler);
InstructionHandle protectedEnd = rtExHandler.getStart();
range.insert(rtExHandler, Range.InsideAfter);
enclosingMethod.addExceptionHandler(range.getStart().getNext(), protectedEnd.getPrev(), handlerStart,
(ObjectType) BcelWorld.makeBcelType(catchType),
getKind().hasHighPriorityExceptions());
}
public void weavePerObjectEntry(final BcelAdvice munger, final BcelVar onVar) {
final InstructionFactory fact = getFactory();
InstructionList entryInstructions = new InstructionList();
InstructionList entrySuccessInstructions = new InstructionList();
onVar.appendLoad(entrySuccessInstructions, fact);
entrySuccessInstructions
.append(Utility.createInvoke(fact, world, AjcMemberMaker.perObjectBind(munger.getConcreteAspect())));
InstructionList testInstructions = munger.getTestInstructions(this, entrySuccessInstructions.getStart(), range
.getRealStart(), entrySuccessInstructions.getStart());
entryInstructions.append(testInstructions);
entryInstructions.append(entrySuccessInstructions);
range.insert(entryInstructions, Range.InsideBefore);
}
/**
* Causes the aspect instance to be *set* for later retrievable through localAspectof()/aspectOf()
*/
public void weavePerTypeWithinAspectInitialization(final BcelAdvice munger, UnresolvedType t) {
if (t.resolve(world).isInterface())
return;
final InstructionFactory fact = getFactory();
InstructionList entryInstructions = new InstructionList();
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
InstructionList entrySuccessInstructions = new InstructionList();
BcelWorld.getBcelObjectType(munger.getConcreteAspect());
String aspectname = munger.getConcreteAspect().getName();
String ptwField = NameMangler.perTypeWithinFieldForTarget(munger.getConcreteAspect());
entrySuccessInstructions.append(InstructionFactory.PUSH(fact.getConstantPool(), t.getName()));
entrySuccessInstructions.append(fact.createInvoke(aspectname, "ajc$createAspectInstance", new ObjectType(aspectname),
new Type[] { new ObjectType("java.lang.String") }, Constants.INVOKESTATIC));
entrySuccessInstructions.append(fact.createPutStatic(t.getName(), ptwField, new ObjectType(aspectname)));
entryInstructions.append(entrySuccessInstructions);
range.insert(entryInstructions, Range.InsideBefore);
}
public void weaveCflowEntry(final BcelAdvice munger, final Member cflowField) {
final boolean isPer = munger.getKind() == AdviceKind.PerCflowBelowEntry || munger.getKind() == AdviceKind.PerCflowEntry;
final Type objectArrayType = new ArrayType(Type.OBJECT, 1);
final InstructionFactory fact = getFactory();
final BcelVar testResult = genTempVar(ResolvedType.BOOLEAN);
InstructionList entryInstructions = new InstructionList();
{
InstructionList entrySuccessInstructions = new InstructionList();
if (munger.hasDynamicTests()) {
entryInstructions.append(Utility.createConstant(fact, 0));
testResult.appendStore(entryInstructions, fact);
entrySuccessInstructions.append(Utility.createConstant(fact, 1));
testResult.appendStore(entrySuccessInstructions, fact);
}
if (isPer) {
entrySuccessInstructions.append(fact.createInvoke(munger.getConcreteAspect().getName(),
NameMangler.PERCFLOW_PUSH_METHOD, Type.VOID, new Type[] {}, Constants.INVOKESTATIC));
} else {
BcelVar[] cflowStateVars = munger.getExposedStateAsBcelVars(false);
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
if (cflowStateVars.length == 0) {
if (!cflowField.getType().getName().endsWith("CFlowCounter"))
throw new RuntimeException("Incorrectly attempting counter operation on stacked cflow");
entrySuccessInstructions.append(Utility.createGet(fact, cflowField));
entrySuccessInstructions.append(fact.createInvoke(NameMangler.CFLOW_COUNTER_TYPE, "inc", Type.VOID,
new Type[] {}, Constants.INVOKEVIRTUAL));
} else {
BcelVar arrayVar = genTempVar(UnresolvedType.OBJECTARRAY);
int alen = cflowStateVars.length;
entrySuccessInstructions.append(Utility.createConstant(fact, alen));
entrySuccessInstructions.append(fact.createNewArray(Type.OBJECT, (short) 1));
arrayVar.appendStore(entrySuccessInstructions, fact);
for (int i = 0; i < alen; i++) {
arrayVar.appendConvertableArrayStore(entrySuccessInstructions, fact, i, cflowStateVars[i]);
}
entrySuccessInstructions.append(Utility.createGet(fact, cflowField));
arrayVar.appendLoad(entrySuccessInstructions, fact);
entrySuccessInstructions.append(fact.createInvoke(NameMangler.CFLOW_STACK_TYPE, "push", Type.VOID,
new Type[] { objectArrayType }, Constants.INVOKEVIRTUAL));
}
}
InstructionList testInstructions = munger.getTestInstructions(this, entrySuccessInstructions.getStart(), range
.getRealStart(), entrySuccessInstructions.getStart());
entryInstructions.append(testInstructions);
entryInstructions.append(entrySuccessInstructions);
}
weaveAfter(new BcelAdvice(null, null, null, 0, 0, 0, null, null) {
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
public InstructionList getAdviceInstructions(BcelShadow s, BcelVar extraArgVar, InstructionHandle ifNoAdvice) {
InstructionList exitInstructions = new InstructionList();
if (munger.hasDynamicTests()) {
testResult.appendLoad(exitInstructions, fact);
exitInstructions.append(InstructionFactory.createBranchInstruction(Constants.IFEQ, ifNoAdvice));
}
exitInstructions.append(Utility.createGet(fact, cflowField));
if (munger.getKind() != AdviceKind.PerCflowEntry && munger.getKind() != AdviceKind.PerCflowBelowEntry
&& munger.getExposedStateAsBcelVars(false).length == 0) {
exitInstructions.append(fact.createInvoke(NameMangler.CFLOW_COUNTER_TYPE, "dec", Type.VOID, new Type[] {},
Constants.INVOKEVIRTUAL));
} else {
exitInstructions.append(fact.createInvoke(NameMangler.CFLOW_STACK_TYPE, "pop", Type.VOID, new Type[] {},
Constants.INVOKEVIRTUAL));
}
return exitInstructions;
}
});
range.insert(entryInstructions, Range.InsideBefore);
}
/*
* Implementation notes:
*
* AroundInline still extracts the instructions of the original shadow into an extracted method. This allows inlining of even
* that advice that doesn't call proceed or calls proceed more than once.
*
* It extracts the instructions of the original shadow into a method.
*
* Then it extracts the instructions of the advice into a new method defined on this enclosing class. This new method can then
* be specialized as below.
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
*
* Then it searches in the instructions of the advice for any call to the proceed method.
*
* At such a call, there is stuff on the stack representing the arguments to proceed. Pop these into the frame.
*
* Now build the stack for the call to the extracted method, taking values either from the join point state or from the new
* frame locs from proceed. Now call the extracted method. The right return value should be on the stack, so no cast is
* necessary.
*
* If only one call to proceed is made, we can re-inline the original shadow. We are not doing that presently.
*
* If the body of the advice can be determined to not alter the stack, or if this shadow doesn't care about the stack, i.e.
* method-execution, then the new method for the advice can also be re-lined. We are not doing that presently.
*/
public void weaveAroundInline(BcelAdvice munger, boolean hasDynamicTest) {
Member mungerSig = munger.getSignature();
if (mungerSig instanceof ResolvedMember) {
ResolvedMember rm = (ResolvedMember) mungerSig;
if (rm.hasBackingGenericMember())
mungerSig = rm.getBackingGenericMember();
}
ResolvedType declaringType = world.resolve(mungerSig.getDeclaringType(), true);
if (declaringType.isMissing()) {
world.getLint().cantFindType.signal(new String[] { WeaverMessages.format(
WeaverMessages.CANT_FIND_TYPE_DURING_AROUND_WEAVE, declaringType.getClassName()) }, getSourceLocation(),
new ISourceLocation[] { munger.getSourceLocation() });
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
}
ResolvedType rt = (declaringType.isParameterizedType() ? declaringType.getGenericType() : declaringType);
BcelObjectType ot = BcelWorld.getBcelObjectType(rt);
return;
}
LazyMethodGen adviceMethod = ot.getLazyClassGen().getLazyMethodGen(mungerSig);
if (!adviceMethod.getCanInline()) {
weaveAroundClosure(munger, hasDynamicTest);
return;
}
if (munger.getConcreteAspect().isAnnotationStyleAspect()) {
boolean canSeeProceedPassedToOther = false;
InstructionHandle curr = adviceMethod.getBody().getStart();
InstructionHandle end = adviceMethod.getBody().getEnd();
ConstantPool cpg = adviceMethod.getEnclosingClass().getConstantPool();
while (curr != end) {
InstructionHandle next = curr.getNext();
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
Instruction inst = curr.getInstruction();
if ((inst instanceof InvokeInstruction)
&& ((InvokeInstruction) inst).getSignature(cpg).indexOf("Lorg/aspectj/lang/ProceedingJoinPoint;") > 0) {
canSeeProceedPassedToOther = true;
break;
}
curr = next;
}
if (canSeeProceedPassedToOther) {
adviceMethod.setCanInline(false);
weaveAroundClosure(munger, hasDynamicTest);
return;
}
}
enclosingMethod.setCanInline(false);
final InstructionFactory fact = getFactory();
LazyMethodGen extractedMethod = extractMethod(NameMangler.aroundCallbackMethodName(getSignature(), getEnclosingClass()),
Modifier.PRIVATE, munger);
String adviceMethodName = NameMangler.aroundCallbackMethodName(getSignature(), getEnclosingClass()) + "$advice";
List argVarList = new ArrayList();
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
List proceedVarList = new ArrayList();
int extraParamOffset = 0;
if (thisVar != null) {
argVarList.add(thisVar);
proceedVarList.add(new BcelVar(thisVar.getType(), extraParamOffset));
extraParamOffset += thisVar.getType().getSize();
}
if (targetVar != null && targetVar != thisVar) {
argVarList.add(targetVar);
proceedVarList.add(new BcelVar(targetVar.getType(), extraParamOffset));
extraParamOffset += targetVar.getType().getSize();
}
for (int i = 0, len = getArgCount(); i < len; i++) {
argVarList.add(argVars[i]);
proceedVarList.add(new BcelVar(argVars[i].getType(), extraParamOffset));
extraParamOffset += argVars[i].getType().getSize();
}
if (thisJoinPointVar != null) {
argVarList.add(thisJoinPointVar);
proceedVarList.add(new BcelVar(thisJoinPointVar.getType(), extraParamOffset));
extraParamOffset += thisJoinPointVar.getType().getSize();
}
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
Type[] adviceParameterTypes = BcelWorld.makeBcelTypes(munger.getSignature().getParameterTypes());
adviceMethod.getArgumentTypes();
Type[] extractedMethodParameterTypes = extractedMethod.getArgumentTypes();
Type[] parameterTypes = new Type[extractedMethodParameterTypes.length + adviceParameterTypes.length + 1];
int parameterIndex = 0;
System.arraycopy(extractedMethodParameterTypes, 0, parameterTypes, parameterIndex, extractedMethodParameterTypes.length);
parameterIndex += extractedMethodParameterTypes.length;
parameterTypes[parameterIndex++] = BcelWorld.makeBcelType(adviceMethod.getEnclosingClass().getType());
System.arraycopy(adviceParameterTypes, 0, parameterTypes, parameterIndex, adviceParameterTypes.length);
LazyMethodGen localAdviceMethod = new LazyMethodGen(Modifier.PRIVATE | Modifier.FINAL | Modifier.STATIC, BcelWorld
.makeBcelType(mungerSig.getReturnType()), adviceMethodName, parameterTypes, new String[0], getEnclosingClass());
String donorFileName = adviceMethod.getEnclosingClass().getInternalFileName();
String recipientFileName = getEnclosingClass().getInternalFileName();
if (!donorFileName.equals(recipientFileName)) {
localAdviceMethod.fromFilename = donorFileName;
getEnclosingClass().addInlinedSourceFileInfo(donorFileName, adviceMethod.highestLineNumber);
}
getEnclosingClass().addMethodGen(localAdviceMethod);
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
int nVars = adviceMethod.getMaxLocals() + extraParamOffset;
IntMap varMap = IntMap.idMap(nVars);
for (int i = extraParamOffset; i < nVars; i++) {
varMap.put(i - extraParamOffset, i);
}
localAdviceMethod.getBody().insert(
BcelClassWeaver.genInlineInstructions(adviceMethod, localAdviceMethod, varMap, fact, true));
localAdviceMethod.setMaxLocals(nVars);
InstructionList advice = new InstructionList();
{
for (Iterator i = argVarList.iterator(); i.hasNext();) {
BcelVar var = (BcelVar) i.next();
var.appendLoad(advice, fact);
}
advice.append(munger.getAdviceArgSetup(this, null,
(munger.getConcreteAspect().isAnnotationStyleAspect() && munger.getDeclaringAspect() != null && munger
.getDeclaringAspect().resolve(world).isAnnotationStyleAspect()) ? this.loadThisJoinPoint()
: new InstructionList(InstructionConstants.ACONST_NULL)));
advice.append(Utility.createInvoke(fact, localAdviceMethod));
advice.append(Utility.createConversion(getFactory(), BcelWorld.makeBcelType(mungerSig.getReturnType()), extractedMethod
.getReturnType(), world.isInJava5Mode()));
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
if (!isFallsThrough()) {
advice.append(InstructionFactory.createReturn(extractedMethod.getReturnType()));
}
}
if (!hasDynamicTest) {
range.append(advice);
} else {
InstructionList afterThingie = new InstructionList(InstructionConstants.NOP);
InstructionList callback = makeCallToCallback(extractedMethod);
if (terminatesWithReturn()) {
callback.append(InstructionFactory.createReturn(extractedMethod.getReturnType()));
} else {
advice.append(InstructionFactory.createBranchInstruction(Constants.GOTO, afterThingie.getStart()));
}
range.append(munger.getTestInstructions(this, advice.getStart(), callback.getStart(), advice.getStart()));
range.append(advice);
range.append(callback);
range.append(afterThingie);
}
if (!munger.getDeclaringType().isAnnotationStyleAspect()) {
String proceedName = NameMangler.proceedMethodName(munger.getSignature().getName());
InstructionHandle curr = localAdviceMethod.getBody().getStart();
InstructionHandle end = localAdviceMethod.getBody().getEnd();
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
ConstantPool cpg = localAdviceMethod.getEnclosingClass().getConstantPool();
while (curr != end) {
InstructionHandle next = curr.getNext();
Instruction inst = curr.getInstruction();
if ((inst.opcode == Constants.INVOKESTATIC) && proceedName.equals(((InvokeInstruction) inst).getMethodName(cpg))) {
localAdviceMethod.getBody().append(curr,
getRedoneProceedCall(fact, extractedMethod, munger, localAdviceMethod, proceedVarList));
Utility.deleteInstruction(curr, localAdviceMethod);
}
curr = next;
}
} else {
InstructionHandle curr = localAdviceMethod.getBody().getStart();
InstructionHandle end = localAdviceMethod.getBody().getEnd();
ConstantPool cpg = localAdviceMethod.getEnclosingClass().getConstantPool();
while (curr != end) {
InstructionHandle next = curr.getNext();
Instruction inst = curr.getInstruction();
if ((inst instanceof INVOKEINTERFACE) && "proceed".equals(((INVOKEINTERFACE) inst).getMethodName(cpg))) {
final boolean isProceedWithArgs;
if (((INVOKEINTERFACE) inst).getArgumentTypes(cpg).length == 1) {
isProceedWithArgs = true;
} else {
isProceedWithArgs = false;
}
InstructionList insteadProceedIl = getRedoneProceedCallForAnnotationStyle(fact, extractedMethod, munger,
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
localAdviceMethod, proceedVarList, isProceedWithArgs);
localAdviceMethod.getBody().append(curr, insteadProceedIl);
Utility.deleteInstruction(curr, localAdviceMethod);
}
curr = next;
}
}
}
private InstructionList getRedoneProceedCall(InstructionFactory fact, LazyMethodGen callbackMethod, BcelAdvice munger,
LazyMethodGen localAdviceMethod, List argVarList) {
InstructionList ret = new InstructionList();
BcelVar[] adviceVars = munger.getExposedStateAsBcelVars(true);
IntMap proceedMap = makeProceedArgumentMap(adviceVars);
ResolvedType[] proceedParamTypes = world.resolve(munger.getSignature().getParameterTypes());
if (munger.getBaseParameterCount() + 1 < proceedParamTypes.length) {
int len = munger.getBaseParameterCount() + 1;
ResolvedType[] newTypes = new ResolvedType[len];
System.arraycopy(proceedParamTypes, 0, newTypes, 0, len);
proceedParamTypes = newTypes;
}
BcelVar[] proceedVars = Utility.pushAndReturnArrayOfVars(proceedParamTypes, ret, fact, localAdviceMethod);
Type[] stateTypes = callbackMethod.getArgumentTypes();
for (int i = 0, len = stateTypes.length; i < len; i++) {
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
Type stateType = stateTypes[i];
ResolvedType stateTypeX = BcelWorld.fromBcel(stateType).resolve(world);
if (proceedMap.hasKey(i)) {
proceedVars[proceedMap.get(i)].appendLoadAndConvert(ret, fact, stateTypeX);
} else {
((BcelVar) argVarList.get(i)).appendLoad(ret, fact);
}
}
ret.append(Utility.createInvoke(fact, callbackMethod));
ret.append(Utility.createConversion(fact, callbackMethod.getReturnType(), BcelWorld.makeBcelType(munger.getSignature()
.getReturnType())));
return ret;
}
}
}
}
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
}
}
}
}
/**
* Annotation style handling for inlining.
*
* Note: The proceedingjoinpoint is already on the stack (since the user was calling pjp.proceed(...)
*
* The proceed map is ignored (in terms of argument repositioning) since we have a fixed expected format for annotation style.
* The aim here is to change the proceed() call into a call to the xxx_aroundBody0 method.
*
*
*/
private InstructionList getRedoneProceedCallForAnnotationStyle(InstructionFactory fact, LazyMethodGen callbackMethod,
BcelAdvice munger, LazyMethodGen localAdviceMethod, List argVarList, boolean isProceedWithArgs) {
InstructionList ret = new InstructionList();
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
if (isProceedWithArgs) {
Type objectArrayType = Type.OBJECT_ARRAY;
int theObjectArrayLocalNumber = localAdviceMethod.allocateLocal(objectArrayType);
ret.append(InstructionFactory.createStore(objectArrayType, theObjectArrayLocalNumber));
Type proceedingJpType = Type.getType("Lorg/aspectj/lang/ProceedingJoinPoint;");
int pjpLocalNumber = localAdviceMethod.allocateLocal(proceedingJpType);
ret.append(InstructionFactory.createStore(proceedingJpType, pjpLocalNumber));
boolean pointcutBindsThis = bindsThis(munger);
boolean pointcutBindsTarget = bindsTarget(munger);
boolean targetIsSameAsThis = getKind().isTargetSameAsThis();
int nextArgumentToProvideForCallback = 0;
if (hasThis()) {
if (!(pointcutBindsTarget && targetIsSameAsThis)) {
if (pointcutBindsThis) {
ret.append(InstructionFactory.createLoad(objectArrayType, theObjectArrayLocalNumber));
ret.append(Utility.createConstant(fact, 0));
ret.append(InstructionFactory.createArrayLoad(Type.OBJECT));
ret.append(Utility.createConversion(fact, Type.OBJECT, callbackMethod.getArgumentTypes()[0]));
} else {
ret.append(InstructionFactory.createALOAD(0));
}
nextArgumentToProvideForCallback++;
}
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
}
if (hasTarget()) {
if (pointcutBindsTarget) {
if (getKind().isTargetSameAsThis()) {
ret.append(InstructionFactory.createLoad(objectArrayType, theObjectArrayLocalNumber));
ret.append(Utility.createConstant(fact, pointcutBindsThis ? 1 : 0));
ret.append(InstructionFactory.createArrayLoad(Type.OBJECT));
ret.append(Utility.createConversion(fact, Type.OBJECT, callbackMethod.getArgumentTypes()[0]));
} else {
int position = (hasThis() && pointcutBindsThis ? 1 : 0);
ret.append(InstructionFactory.createLoad(objectArrayType, theObjectArrayLocalNumber));
ret.append(Utility.createConstant(fact, position));
ret.append(InstructionFactory.createArrayLoad(Type.OBJECT));
ret.append(Utility.createConversion(fact, Type.OBJECT, callbackMethod.getArgumentTypes()[position]));
}
nextArgumentToProvideForCallback++;
} else {
if (getKind().isTargetSameAsThis()) {
} else {
ret.append(InstructionFactory.createLoad(localAdviceMethod.getArgumentTypes()[0], hasThis() ? 1 : 0));
nextArgumentToProvideForCallback++;
}
}
}
int indexIntoObjectArrayForArguments = (pointcutBindsThis ? 1 : 0) + (pointcutBindsTarget ? 1 : 0);
int len = callbackMethod.getArgumentTypes().length;
for (int i = nextArgumentToProvideForCallback; i < len; i++) {
Type stateType = callbackMethod.getArgumentTypes()[i];
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
BcelWorld.fromBcel(stateType).resolve(world);
if ("Lorg/aspectj/lang/JoinPoint;".equals(stateType.getSignature())) {
ret.append(new InstructionLV(Constants.ALOAD, pjpLocalNumber));
} else {
ret.append(InstructionFactory.createLoad(objectArrayType, theObjectArrayLocalNumber));
ret.append(Utility
.createConstant(fact, i - nextArgumentToProvideForCallback + indexIntoObjectArrayForArguments));
ret.append(InstructionFactory.createArrayLoad(Type.OBJECT));
ret.append(Utility.createConversion(fact, Type.OBJECT, stateType));
}
}
} else {
Type proceedingJpType = Type.getType("Lorg/aspectj/lang/ProceedingJoinPoint;");
int localJp = localAdviceMethod.allocateLocal(proceedingJpType);
ret.append(InstructionFactory.createStore(proceedingJpType, localJp));
for (int i = 0, len = callbackMethod.getArgumentTypes().length; i < len; i++) {
Type stateType = callbackMethod.getArgumentTypes()[i];
BcelWorld.fromBcel(stateType).resolve(world);
if ("Lorg/aspectj/lang/JoinPoint;".equals(stateType.getSignature())) {
ret.append(InstructionFactory.createALOAD(localJp));
));
} else {
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
ret.append(InstructionFactory.createLoad(stateType, i));
}
}
}
ret.append(Utility.createInvoke(fact, callbackMethod));
if (!UnresolvedType.OBJECT.equals(munger.getSignature().getReturnType())) {
ret.append(Utility.createConversion(fact, callbackMethod.getReturnType(), Type.OBJECT));
}
ret.append(Utility.createConversion(fact, callbackMethod.getReturnType(), BcelWorld.makeBcelType(munger.getSignature()
.getReturnType())));
return ret;
}
}
}
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
}
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
}
}
}
private boolean bindsThis(BcelAdvice munger) {
UsesThisVisitor utv = new UsesThisVisitor();
munger.getPointcut().accept(utv, null);
return utv.usesThis;
}
private boolean bindsTarget(BcelAdvice munger) {
UsesTargetVisitor utv = new UsesTargetVisitor();
munger.getPointcut().accept(utv, null);
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
return utv.usesTarget;
}
private static class UsesThisVisitor extends AbstractPatternNodeVisitor {
boolean usesThis = false;
public Object visit(ThisOrTargetPointcut node, Object data) {
if (node.isThis() && node.isBinding())
usesThis = true;
return node;
}
public Object visit(AndPointcut node, Object data) {
if (!usesThis)
node.getLeft().accept(this, data);
if (!usesThis)
node.getRight().accept(this, data);
return node;
}
public Object visit(NotPointcut node, Object data) {
if (!usesThis)
node.getNegatedPointcut().accept(this, data);
return node;
}
public Object visit(OrPointcut node, Object data) {
if (!usesThis)
node.getLeft().accept(this, data);
if (!usesThis)
node.getRight().accept(this, data);
return node;
}
}
private static class UsesTargetVisitor extends AbstractPatternNodeVisitor {
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
boolean usesTarget = false;
public Object visit(ThisOrTargetPointcut node, Object data) {
if (!node.isThis() && node.isBinding())
usesTarget = true;
return node;
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
}
public Object visit(AndPointcut node, Object data) {
if (!usesTarget)
node.getLeft().accept(this, data);
if (!usesTarget)
node.getRight().accept(this, data);
return node;
}
public Object visit(NotPointcut node, Object data) {
if (!usesTarget)
node.getNegatedPointcut().accept(this, data);
return node;
}
public Object visit(OrPointcut node, Object data) {
if (!usesTarget)
node.getLeft().accept(this, data);
if (!usesTarget)
node.getRight().accept(this, data);
return node;
}
}
public void weaveAroundClosure(BcelAdvice munger, boolean hasDynamicTest) {
InstructionFactory fact = getFactory();
enclosingMethod.setCanInline(false);
int linenumber = getSourceLine();
LazyMethodGen callbackMethod = extractMethod(NameMangler.aroundCallbackMethodName(getSignature(), getEnclosingClass()), 0,
munger);
BcelVar[] adviceVars = munger.getExposedStateAsBcelVars(true);
String closureClassName = NameMangler.makeClosureClassName(getEnclosingClass().getType(), getEnclosingClass()
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
.getNewGeneratedNameTag());
Member constructorSig = new MemberImpl(Member.CONSTRUCTOR, UnresolvedType.forName(closureClassName), 0, "<init>",
"([Ljava/lang/Object;)V");
BcelVar closureHolder = null;
if (getKind() == PreInitialization) {
closureHolder = genTempVar(AjcMemberMaker.AROUND_CLOSURE_TYPE);
}
InstructionList closureInstantiation = makeClosureInstantiation(constructorSig, closureHolder);
makeClosureClassAndReturnConstructor(closureClassName, callbackMethod, makeProceedArgumentMap(adviceVars));
InstructionList returnConversionCode;
if (getKind() == PreInitialization) {
returnConversionCode = new InstructionList();
BcelVar stateTempVar = genTempVar(UnresolvedType.OBJECTARRAY);
closureHolder.appendLoad(returnConversionCode, fact);
returnConversionCode.append(Utility.createInvoke(fact, world, AjcMemberMaker.aroundClosurePreInitializationGetter()));
stateTempVar.appendStore(returnConversionCode, fact);
Type[] stateTypes = getSuperConstructorParameterTypes();
returnConversionCode.append(InstructionConstants.ALOAD_0);
for (int i = 0, len = stateTypes.length; i < len; i++) {
UnresolvedType bcelTX = BcelWorld.fromBcel(stateTypes[i]);
ResolvedType stateRTX = world.resolve(bcelTX, true);
if (stateRTX.isMissing()) {
world.getLint().cantFindType.signal(new String[] { WeaverMessages.format(
WeaverMessages.CANT_FIND_TYPE_DURING_AROUND_WEAVE_PREINIT, bcelTX.getClassName()) },
getSourceLocation(), new ISourceLocation[] { munger.getSourceLocation() });
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
}
stateTempVar.appendConvertableArrayLoad(returnConversionCode, fact, i, stateRTX);
}
} else {
Member mungerSignature = munger.getSignature();
if (munger.getSignature() instanceof ResolvedMember) {
if (((ResolvedMember) mungerSignature).hasBackingGenericMember()) {
mungerSignature = ((ResolvedMember) mungerSignature).getBackingGenericMember();
}
}
UnresolvedType returnType = mungerSignature.getReturnType();
returnConversionCode = Utility.createConversion(getFactory(), BcelWorld.makeBcelType(returnType), callbackMethod
.getReturnType(), world.isInJava5Mode());
if (!isFallsThrough()) {
returnConversionCode.append(InstructionFactory.createReturn(callbackMethod.getReturnType()));
}
}
int bitflags = 0x000000;
if (getKind().isTargetSameAsThis())
bitflags |= 0x010000;
if (hasThis())
bitflags |= 0x001000;
if (bindsThis(munger))
bitflags |= 0x000100;
if (hasTarget())
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
bitflags |= 0x000010;
if (bindsTarget(munger))
bitflags |= 0x000001;
if (munger.getConcreteAspect() != null && munger.getConcreteAspect().isAnnotationStyleAspect()
&& munger.getDeclaringAspect() != null && munger.getDeclaringAspect().resolve(world).isAnnotationStyleAspect()) {
closureInstantiation.append(fact.createConstant(Integer.valueOf(bitflags)));
closureInstantiation.append(Utility.createInvoke(getFactory(), getWorld(), new MemberImpl(Member.METHOD, UnresolvedType
.forName("org.aspectj.runtime.internal.AroundClosure"), Modifier.PUBLIC, "linkClosureAndJoinPoint",
"(I)Lorg/aspectj/lang/ProceedingJoinPoint;")));
}
InstructionList advice = new InstructionList();
advice.append(munger.getAdviceArgSetup(this, null, closureInstantiation));
advice.append(munger.getNonTestAdviceInstructions(this));
advice.append(returnConversionCode);
if (getKind() == Shadow.MethodExecution && linenumber > 0) {
advice.getStart().addTargeter(new LineNumberTag(linenumber));
}
if (!hasDynamicTest) {
range.append(advice);
} else {
InstructionList callback = makeCallToCallback(callbackMethod);
InstructionList postCallback = new InstructionList();
if (terminatesWithReturn()) {
callback.append(InstructionFactory.createReturn(callbackMethod.getReturnType()));
} else {
advice.append(InstructionFactory.createBranchInstruction(Constants.GOTO, postCallback
.append(InstructionConstants.NOP)));
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
}
range.append(munger.getTestInstructions(this, advice.getStart(), callback.getStart(), advice.getStart()));
range.append(advice);
range.append(callback);
range.append(postCallback);
}
}
InstructionList makeCallToCallback(LazyMethodGen callbackMethod) {
InstructionFactory fact = getFactory();
InstructionList callback = new InstructionList();
if (thisVar != null) {
callback.append(InstructionConstants.ALOAD_0);
}
if (targetVar != null && targetVar != thisVar) {
callback.append(BcelRenderer.renderExpr(fact, world, targetVar));
}
callback.append(BcelRenderer.renderExprs(fact, world, argVars));
if (thisJoinPointVar != null) {
callback.append(BcelRenderer.renderExpr(fact, world, thisJoinPointVar));
}
callback.append(Utility.createInvoke(fact, callbackMethod));
return callback;
}
private InstructionList makeClosureInstantiation(Member constructor, BcelVar holder) {
InstructionFactory fact = getFactory();
BcelVar arrayVar = genTempVar(UnresolvedType.OBJECTARRAY);
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
final InstructionList il = new InstructionList();
int alen = getArgCount() + (thisVar == null ? 0 : 1) + ((targetVar != null && targetVar != thisVar) ? 1 : 0)
+ (thisJoinPointVar == null ? 0 : 1);
il.append(Utility.createConstant(fact, alen));
il.append(fact.createNewArray(Type.OBJECT, (short) 1));
arrayVar.appendStore(il, fact);
int stateIndex = 0;
if (thisVar != null) {
arrayVar.appendConvertableArrayStore(il, fact, stateIndex, thisVar);
thisVar.setPositionInAroundState(stateIndex);
stateIndex++;
}
if (targetVar != null && targetVar != thisVar) {
arrayVar.appendConvertableArrayStore(il, fact, stateIndex, targetVar);
targetVar.setPositionInAroundState(stateIndex);
stateIndex++;
}
for (int i = 0, len = getArgCount(); i < len; i++) {
arrayVar.appendConvertableArrayStore(il, fact, stateIndex, argVars[i]);
argVars[i].setPositionInAroundState(stateIndex);
stateIndex++;
}
if (thisJoinPointVar != null) {
arrayVar.appendConvertableArrayStore(il, fact, stateIndex, thisJoinPointVar);
thisJoinPointVar.setPositionInAroundState(stateIndex);
stateIndex++;
}
il.append(fact.createNew(new ObjectType(constructor.getDeclaringType().getName())));
il.append(InstructionConstants.DUP);
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
arrayVar.appendLoad(il, fact);
il.append(Utility.createInvoke(fact, world, constructor));
if (getKind() == PreInitialization) {
il.append(InstructionConstants.DUP);
holder.appendStore(il, fact);
}
return il;
}
private IntMap makeProceedArgumentMap(BcelVar[] adviceArgs) {
IntMap ret = new IntMap();
for (int i = 0, len = adviceArgs.length; i < len; i++) {
BcelVar v = adviceArgs[i];
if (v == null)
continue;
int pos = v.getPositionInAroundState();
if (pos >= 0) {
ret.put(pos, i);
}
}
return ret;
}
/**
*
*
* @param callbackMethod the method we will call back to when our run method gets called.
*
* @param proceedMap A map from state position to proceed argument position. May be non covering on state position.
*/
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
private LazyMethodGen makeClosureClassAndReturnConstructor(String closureClassName, LazyMethodGen callbackMethod,
IntMap proceedMap) {
String superClassName = "org.aspectj.runtime.internal.AroundClosure";
Type objectArrayType = new ArrayType(Type.OBJECT, 1);
LazyClassGen closureClass = new LazyClassGen(closureClassName, superClassName, getEnclosingClass().getFileName(),
Modifier.PUBLIC, new String[] {}, getWorld());
InstructionFactory fact = new InstructionFactory(closureClass.getConstantPool());
LazyMethodGen constructor = new LazyMethodGen(Modifier.PUBLIC, Type.VOID, "<init>", new Type[] { objectArrayType },
new String[] {}, closureClass);
InstructionList cbody = constructor.getBody();
cbody.append(InstructionFactory.createLoad(Type.OBJECT, 0));
cbody.append(InstructionFactory.createLoad(objectArrayType, 1));
cbody.append(fact
.createInvoke(superClassName, "<init>", Type.VOID, new Type[] { objectArrayType }, Constants.INVOKESPECIAL));
cbody.append(InstructionFactory.createReturn(Type.VOID));
closureClass.addMethodGen(constructor);
method
LazyMethodGen runMethod = new LazyMethodGen(Modifier.PUBLIC, Type.OBJECT, "run", new Type[] { objectArrayType },
new String[] {}, closureClass);
InstructionList mbody = runMethod.getBody();
BcelVar proceedVar = new BcelVar(UnresolvedType.OBJECTARRAY.resolve(world), 1);
BcelVar stateVar = new BcelVar(UnresolvedType.OBJECTARRAY.resolve(world), runMethod.allocateLocal(1));
mbody.append(InstructionFactory.createThis());
mbody.append(fact.createGetField(superClassName, "state", objectArrayType));
mbody.append(stateVar.createStore(fact));
Type[] stateTypes = callbackMethod.getArgumentTypes();
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
for (int i = 0, len = stateTypes.length; i < len; i++) {
Type stateType = stateTypes[i];
ResolvedType stateTypeX = BcelWorld.fromBcel(stateType).resolve(world);
if (proceedMap.hasKey(i)) {
mbody.append(proceedVar.createConvertableArrayLoad(fact, proceedMap.get(i), stateTypeX));
} else {
mbody.append(stateVar.createConvertableArrayLoad(fact, i, stateTypeX));
}
}
mbody.append(Utility.createInvoke(fact, callbackMethod));
if (getKind() == PreInitialization) {
mbody.append(Utility.createSet(fact, AjcMemberMaker.aroundClosurePreInitializationField()));
mbody.append(InstructionConstants.ACONST_NULL);
} else {
mbody.append(Utility.createConversion(fact, callbackMethod.getReturnType(), Type.OBJECT));
}
mbody.append(InstructionFactory.createReturn(Type.OBJECT));
closureClass.addMethodGen(runMethod);
class
getEnclosingClass().addGeneratedInner(closureClass);
return constructor;
}
public LazyMethodGen extractMethod(String newMethodName, int visibilityModifier, ShadowMunger munger) {
LazyMethodGen.assertGoodBody(range.getBody(), newMethodName);
if (!getKind().allowsExtraction())
throw new BCException("Attempt to extract method from a shadow kind that does not support this operation (" + getKind()
+ ")");
LazyMethodGen freshMethod = createMethodGen(newMethodName, visibilityModifier);
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
range.extractInstructionsInto(freshMethod, makeRemap(), (getKind() != PreInitialization) && isFallsThrough());
if (getKind() == PreInitialization) {
addPreInitializationReturnCode(freshMethod, getSuperConstructorParameterTypes());
}
getEnclosingClass().addMethodGen(freshMethod, munger.getSourceLocation());
return freshMethod;
}
private void addPreInitializationReturnCode(LazyMethodGen extractedMethod, Type[] superConstructorTypes) {
InstructionList body = extractedMethod.getBody();
final InstructionFactory fact = getFactory();
BcelVar arrayVar = new BcelVar(world.getCoreType(UnresolvedType.OBJECTARRAY), extractedMethod.allocateLocal(1));
int len = superConstructorTypes.length;
body.append(Utility.createConstant(fact, len));
body.append(fact.createNewArray(Type.OBJECT, (short) 1));
arrayVar.appendStore(body, fact);
for (int i = len - 1; i >= 0; i++) {
body.append(Utility.createConversion(fact, superConstructorTypes[i], Type.OBJECT));
arrayVar.appendLoad(body, fact);
swap
body.append(InstructionConstants.SWAP);
body.append(Utility.createConstant(fact, i));
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
body.append(InstructionConstants.SWAP);
body.append(InstructionFactory.createArrayStore(Type.OBJECT));
}
arrayVar.appendLoad(body, fact);
body.append(InstructionConstants.ARETURN);
}
private Type[] getSuperConstructorParameterTypes() {
InstructionHandle superCallHandle = getRange().getEnd().getNext();
InvokeInstruction superCallInstruction = (InvokeInstruction) superCallHandle.getInstruction();
return superCallInstruction.getArgumentTypes(getEnclosingClass().getConstantPool());
}
/**
* make a map from old frame location to new frame location. Any unkeyed frame location picks out a copied local
*/
private IntMap makeRemap() {
IntMap ret = new IntMap(5);
int reti = 0;
if (thisVar != null) {
ret.put(0, reti++);
}
if (targetVar != null && targetVar != thisVar) {
ret.put(targetVar.getSlot(), reti++);
}
for (int i = 0, len = argVars.length; i < len; i++) {
ret.put(argVars[i].getSlot(), reti);
reti += argVars[i].getType().getSize();
}
if (thisJoinPointVar != null) {
ret.put(thisJoinPointVar.getSlot(), reti++);
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
}
point.
if (!getKind().argsOnStack()) {
int oldi = 0;
int newi = 0;
if (arg0HoldsThis()) {
ret.put(0, 0);
oldi++;
newi += 1;
}
for (int i = 0; i < getArgCount(); i++) {
UnresolvedType type = getArgType(i);
ret.put(oldi, newi);
oldi += type.getSize();
newi += type.getSize();
}
}
return ret;
}
/**
* The new method always static. It may take some extra arguments: this, target. If it's argsOnStack, then it must take both
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
* this/target If it's argsOnFrame, it shares this and target. ??? rewrite this to do less array munging, please
*/
private LazyMethodGen createMethodGen(String newMethodName, int visibilityModifier) {
Type[] parameterTypes = BcelWorld.makeBcelTypes(getArgTypes());
int modifiers = Modifier.FINAL | visibilityModifier;
}
modifiers |= Modifier.STATIC;
if (targetVar != null && targetVar != thisVar) {
UnresolvedType targetType = getTargetType();
targetType = ensureTargetTypeIsCorrect(targetType);
if ((getKind() == FieldGet || getKind() == FieldSet) && getActualTargetType() != null
&& !getActualTargetType().equals(targetType.getName())) {
targetType = UnresolvedType.forName(getActualTargetType()).resolve(world);
}
ResolvedMember resolvedMember = getSignature().resolve(world);
if (resolvedMember != null && Modifier.isProtected(resolvedMember.getModifiers())
&& !samePackage(resolvedMember.getDeclaringType().getPackageName(), getEnclosingType().getPackageName())
&& !resolvedMember.getName().equals("clone")) {
if (!hasThis()) {
if (Modifier.isStatic(enclosingMethod.getAccessFlags()) && enclosingMethod.getName().startsWith("access$")) {
targetType = BcelWorld.fromBcel(enclosingMethod.getArgumentTypes()[0]);
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
}
} else {
if (!targetType.resolve(world).isAssignableFrom(getThisType().resolve(world))) {
throw new BCException("bad bytecode");
}
targetType = getThisType();
}
}
parameterTypes = addType(BcelWorld.makeBcelType(targetType), parameterTypes);
}
if (thisVar != null) {
UnresolvedType thisType = getThisType();
parameterTypes = addType(BcelWorld.makeBcelType(thisType), parameterTypes);
}
if (thisJoinPointVar != null) {
parameterTypes = addTypeToEnd(LazyClassGen.tjpType, parameterTypes);
}
UnresolvedType returnType;
if (getKind() == PreInitialization) {
returnType = UnresolvedType.OBJECTARRAY;
} else {
if (getKind() == ConstructorCall)
returnType = getSignature().getDeclaringType();
else if (getKind() == FieldSet)
returnType = ResolvedType.VOID;
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
else
returnType = getSignature().getReturnType().resolve(world);
}
return new LazyMethodGen(modifiers, BcelWorld.makeBcelType(returnType), newMethodName, parameterTypes, new String[0],
getEnclosingClass());
}
private boolean samePackage(String p1, String p2) {
if (p1 == null)
return p2 == null;
if (p2 == null)
return false;
return p1.equals(p2);
}
private Type[] addType(Type type, Type[] types) {
int len = types.length;
Type[] ret = new Type[len + 1];
ret[0] = type;
System.arraycopy(types, 0, ret, 1, len);
return ret;
}
private Type[] addTypeToEnd(Type type, Type[] types) {
int len = types.length;
Type[] ret = new Type[len + 1];
ret[len] = type;
System.arraycopy(types, 0, ret, 0, len);
return ret;
}
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
public BcelVar genTempVar(UnresolvedType typeX) {
return new BcelVar(typeX.resolve(world), genTempVarIndex(typeX.getSize()));
}
public BcelVar genTempVar(UnresolvedType typeX, String localName) {
BcelVar tv = genTempVar(typeX);
}
}
return tv;
}
private int genTempVarIndex(int size) {
return enclosingMethod.allocateLocal(size);
}
public InstructionFactory getFactory() {
return getEnclosingClass().getFactory();
}
public ISourceLocation getSourceLocation() {
int sourceLine = getSourceLine();
if (sourceLine == 0 || sourceLine == -1) {
return getEnclosingClass().getType().getSourceLocation();
} else {
if (getKind() == Shadow.StaticInitialization && getEnclosingClass().getType().getSourceLocation().getOffset() != 0) {
|
186,884 |
Bug 186884 Unhandled Kind of New Exception when have advice for Pointcut call(Throwable+.new(..))
| null |
resolved fixed
|
7a398a2
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-09-30T22:55:35Z | 2007-05-14T22:00:00Z |
weaver/src/org/aspectj/weaver/bcel/BcelShadow.java
|
return getEnclosingClass().getType().getSourceLocation();
} else {
int offset = 0;
Kind kind = getKind();
if ((kind == MethodExecution) || (kind == ConstructorExecution) || (kind == AdviceExecution)
|| (kind == StaticInitialization) || (kind == PreInitialization) || (kind == Initialization)) {
if (getEnclosingMethod().hasDeclaredLineNumberInfo()) {
offset = getEnclosingMethod().getDeclarationOffset();
}
}
return getEnclosingClass().getType().getSourceContext().makeSourceLocation(sourceLine, offset);
}
}
}
public Shadow getEnclosingShadow() {
return enclosingShadow;
}
public LazyMethodGen getEnclosingMethod() {
return enclosingMethod;
}
public boolean isFallsThrough() {
return !terminatesWithReturn();
}
public void setActualTargetType(String className) {
this.actualInstructionTargetType = className;
}
public String getActualTargetType() {
return actualInstructionTargetType;
}
}
|
249,710 |
Bug 249710 [compiling] Problem with -XterminateAfterCompilation
| null |
resolved fixed
|
cffe291
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-10-29T19:08:05Z | 2008-10-05T23:40:00Z |
tests/src/org/aspectj/systemtest/ajc163/Ajc163Tests.java
|
/*******************************************************************************
* Copyright (c) 2008 Contributors
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Andy Clement - initial API and implementation
*******************************************************************************/
package org.aspectj.systemtest.ajc163;
import java.io.File;
import junit.framework.Test;
import org.aspectj.testing.XMLBasedAjcTestCase;
public class Ajc163Tests extends org.aspectj.testing.XMLBasedAjcTestCase {
|
249,710 |
Bug 249710 [compiling] Problem with -XterminateAfterCompilation
| null |
resolved fixed
|
cffe291
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-10-29T19:08:05Z | 2008-10-05T23:40:00Z |
tests/src/org/aspectj/systemtest/ajc163/Ajc163Tests.java
|
public void testItdCCE_pr250091() {
runTest("itd cce");
}
public void testBreakingRecovery_pr226163() {
runTest("breaking recovery");
}
public void testGenericMethodConversions_pr250632() {
runTest("type conversion in generic itd");
}
public void testGenericMethodBridging_pr250493() {
runTest("bridge methods for generic itds");
}
public void testGenericFieldBridging_pr252285() {
runTest("bridge methods for generic itd fields");
}
public static Test suite() {
return XMLBasedAjcTestCase.loadSuite(Ajc163Tests.class);
}
protected File getSpecFile() {
return new File("../tests/src/org/aspectj/systemtest/ajc163/ajc163.xml");
}
}
|
256,400 |
Bug 256400 An internal error occurred during: "Delete and update AspectJ markers for CoreSource".
|
this occured during a clean and build of the project i'm working on. The following was inthe details. An internal error occurred during: "Delete and update AspectJ markers for CoreSource". java.lang.NullPointerException
|
resolved fixed
|
155a888
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-11-27T17:59:09Z | 2008-11-25T10:46:40Z |
asm/src/org/aspectj/asm/internal/JDTLikeHandleProvider.java
|
/********************************************************************
* Copyright (c) 2006 Contributors. All rights reserved.
* This program and the accompanying materials are made available
* under the terms of the Eclipse Public License v1.0
* which accompanies this distribution and is available at
* http://eclipse.org/legal/epl-v10.html
*
* Contributors: IBM Corporation - initial API and implementation
* Helen Hawkins - initial version
*******************************************************************/
package org.aspectj.asm.internal;
import java.io.File;
import java.util.Iterator;
import java.util.List;
import org.aspectj.asm.AsmManager;
import org.aspectj.asm.IElementHandleProvider;
import org.aspectj.asm.IProgramElement;
import org.aspectj.bridge.ISourceLocation;
/**
* Creates JDT-like handles, for example
*
* method with string argument: <tjp{Demo.java[Demo~main~\[QString; method with generic argument:
* <pkg{MyClass.java[MyClass~myMethod~QList\<QString;>; an aspect: <pkg*A1.aj}A1 advice with Integer arg:
* <pkg*A8.aj}A8&afterReturning&QInteger; method call: <pkg*A10.aj[C~m1?method-call(void pkg.C.m2())
*
*/
public class JDTLikeHandleProvider implements IElementHandleProvider {
private final AsmManager asm;
|
256,400 |
Bug 256400 An internal error occurred during: "Delete and update AspectJ markers for CoreSource".
|
this occured during a clean and build of the project i'm working on. The following was inthe details. An internal error occurred during: "Delete and update AspectJ markers for CoreSource". java.lang.NullPointerException
|
resolved fixed
|
155a888
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-11-27T17:59:09Z | 2008-11-25T10:46:40Z |
asm/src/org/aspectj/asm/internal/JDTLikeHandleProvider.java
|
private int initializerCounter = 0;
private final char[] empty = new char[] {};
private final char[] countDelim = new char[] { HandleProviderDelimiter.COUNT.getDelimiter() };
private final String backslash = "\\";
private final String emptyString = "";
public JDTLikeHandleProvider(AsmManager asm) {
this.asm = asm;
}
public String createHandleIdentifier(IProgramElement ipe) {
if (ipe == null || (ipe.getKind().equals(IProgramElement.Kind.FILE_JAVA) && ipe.getName().equals("<root>"))) {
return "";
} else if (ipe.getHandleIdentifier(false) != null) {
return ipe.getHandleIdentifier();
} else if (ipe.getKind().equals(IProgramElement.Kind.FILE_LST)) {
String configFile = asm.getHierarchy().getConfigFile();
int start = configFile.lastIndexOf(File.separator);
int end = configFile.lastIndexOf(".lst");
if (end != -1) {
configFile = configFile.substring(start + 1, end);
} else {
configFile = new StringBuffer("=").append(configFile.substring(start + 1)).toString();
}
ipe.setHandleIdentifier(configFile);
return configFile;
} else if (ipe.getKind() == IProgramElement.Kind.SOURCE_FOLDER) {
StringBuffer sb = new StringBuffer();
|
256,400 |
Bug 256400 An internal error occurred during: "Delete and update AspectJ markers for CoreSource".
|
this occured during a clean and build of the project i'm working on. The following was inthe details. An internal error occurred during: "Delete and update AspectJ markers for CoreSource". java.lang.NullPointerException
|
resolved fixed
|
155a888
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-11-27T17:59:09Z | 2008-11-25T10:46:40Z |
asm/src/org/aspectj/asm/internal/JDTLikeHandleProvider.java
|
sb.append(createHandleIdentifier(ipe.getParent())).append("/");
sb.append(ipe.getName());
String handle = sb.toString();
ipe.setHandleIdentifier(handle);
return handle;
}
IProgramElement parent = ipe.getParent();
if (parent != null && parent.getKind().equals(IProgramElement.Kind.IMPORT_REFERENCE)) {
parent = ipe.getParent().getParent();
}
StringBuffer handle = new StringBuffer();
handle.append(createHandleIdentifier(parent));
handle.append(HandleProviderDelimiter.getDelimiter(ipe));
if (!ipe.getKind().equals(IProgramElement.Kind.INITIALIZER)) {
if (ipe.getKind() == IProgramElement.Kind.CLASS && ipe.getName().endsWith("{..}")) {
} else {
if (ipe.getKind() == IProgramElement.Kind.INTER_TYPE_CONSTRUCTOR) {
handle.append(ipe.getName()).append("_new").append(getParameters(ipe));
} else {
handle.append(ipe.getName()).append(getParameters(ipe));
|
256,400 |
Bug 256400 An internal error occurred during: "Delete and update AspectJ markers for CoreSource".
|
this occured during a clean and build of the project i'm working on. The following was inthe details. An internal error occurred during: "Delete and update AspectJ markers for CoreSource". java.lang.NullPointerException
|
resolved fixed
|
155a888
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-11-27T17:59:09Z | 2008-11-25T10:46:40Z |
asm/src/org/aspectj/asm/internal/JDTLikeHandleProvider.java
|
}
}
}
handle.append(getCount(ipe));
ipe.setHandleIdentifier(handle.toString());
return handle.toString();
}
private String getParameters(IProgramElement ipe) {
if (ipe.getParameterSignatures() == null || ipe.getParameterSignatures().isEmpty()) {
return "";
}
StringBuffer sb = new StringBuffer();
List parameterTypes = ipe.getParameterSignatures();
for (Iterator iter = parameterTypes.iterator(); iter.hasNext();) {
char[] element = (char[]) iter.next();
sb.append(HandleProviderDelimiter.getDelimiter(ipe));
if (element[0] == HandleProviderDelimiter.TYPE.getDelimiter()) {
sb.append(HandleProviderDelimiter.ESCAPE.getDelimiter());
sb.append(HandleProviderDelimiter.TYPE.getDelimiter());
sb.append(NameConvertor.getTypeName(CharOperation.subarray(element, 1, element.length)));
} else if (element[0] == NameConvertor.PARAMETERIZED) {
sb.append(NameConvertor.createShortName(element));
} else {
sb.append(NameConvertor.getTypeName(element));
}
|
256,400 |
Bug 256400 An internal error occurred during: "Delete and update AspectJ markers for CoreSource".
|
this occured during a clean and build of the project i'm working on. The following was inthe details. An internal error occurred during: "Delete and update AspectJ markers for CoreSource". java.lang.NullPointerException
|
resolved fixed
|
155a888
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-11-27T17:59:09Z | 2008-11-25T10:46:40Z |
asm/src/org/aspectj/asm/internal/JDTLikeHandleProvider.java
|
}
return sb.toString();
}
/**
* Determine a count to be suffixed to the handle, this is only necessary for identical looking entries at the same level in the
* model (for example two anonymous class declarations). The format is !<n> where n will be greater than 2.
*
* @param ipe the program element for which the handle is being constructed
* @return a char suffix that will either be empty or of the form "!<n>"
*/
private char[] getCount(IProgramElement ipe) {
char[] byteCodeName = ipe.getBytecodeName().toCharArray();
if (ipe.getKind().isDeclare()) {
int index = CharOperation.lastIndexOf('_', byteCodeName);
if (index != -1) {
return convertCount(CharOperation.subarray(byteCodeName, index + 1, byteCodeName.length));
}
} else if (ipe.getKind().equals(IProgramElement.Kind.ADVICE)) {
int count = 1;
List kids = ipe.getParent().getChildren();
String ipeSig = ipe.getBytecodeSignature();
for (Iterator iterator = kids.iterator(); iterator.hasNext();) {
IProgramElement object = (IProgramElement) iterator.next();
if (object.equals(ipe)) {
break;
}
if (object.getKind() == ipe.getKind()) {
if (object.getName().equals(ipe.getName())) {
|
256,400 |
Bug 256400 An internal error occurred during: "Delete and update AspectJ markers for CoreSource".
|
this occured during a clean and build of the project i'm working on. The following was inthe details. An internal error occurred during: "Delete and update AspectJ markers for CoreSource". java.lang.NullPointerException
|
resolved fixed
|
155a888
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-11-27T17:59:09Z | 2008-11-25T10:46:40Z |
asm/src/org/aspectj/asm/internal/JDTLikeHandleProvider.java
|
String sig1 = object.getBytecodeSignature();
if (sig1 == null && ipeSig == null || sig1.equals(ipeSig)) {
String existingHandle = object.getHandleIdentifier();
int suffixPosition = existingHandle.indexOf('!');
if (suffixPosition != -1) {
count = new Integer(existingHandle.substring(suffixPosition + 1)).intValue() + 1;
} else {
if (count == 1) {
count = 2;
}
}
}
}
}
}
if (count > 1) {
return CharOperation.concat(countDelim, new Integer(count).toString().toCharArray());
}
} else if (ipe.getKind().equals(IProgramElement.Kind.INITIALIZER)) {
return String.valueOf(++initializerCounter).toCharArray();
} else if (ipe.getKind().equals(IProgramElement.Kind.CODE)) {
int index = CharOperation.lastIndexOf('!', byteCodeName);
if (index != -1) {
return convertCount(CharOperation.subarray(byteCodeName, index + 1, byteCodeName.length));
}
} else if (ipe.getKind() == IProgramElement.Kind.CLASS) {
int count = 1;
List kids = ipe.getParent().getChildren();
if (ipe.getName().endsWith("{..}")) {
|
256,400 |
Bug 256400 An internal error occurred during: "Delete and update AspectJ markers for CoreSource".
|
this occured during a clean and build of the project i'm working on. The following was inthe details. An internal error occurred during: "Delete and update AspectJ markers for CoreSource". java.lang.NullPointerException
|
resolved fixed
|
155a888
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-11-27T17:59:09Z | 2008-11-25T10:46:40Z |
asm/src/org/aspectj/asm/internal/JDTLikeHandleProvider.java
|
for (Iterator iterator = kids.iterator(); iterator.hasNext();) {
IProgramElement object = (IProgramElement) iterator.next();
if (object.equals(ipe)) {
break;
}
if (object.getKind() == ipe.getKind()) {
if (object.getName().endsWith("{..}")) {
String existingHandle = object.getHandleIdentifier();
int suffixPosition = existingHandle.indexOf('!');
if (suffixPosition != -1) {
count = new Integer(existingHandle.substring(suffixPosition + 1)).intValue() + 1;
} else {
if (count == 1) {
count = 2;
}
}
}
}
}
} else {
for (Iterator iterator = kids.iterator(); iterator.hasNext();) {
IProgramElement object = (IProgramElement) iterator.next();
if (object.equals(ipe)) {
break;
}
if (object.getKind() == ipe.getKind()) {
if (object.getName().equals(ipe.getName())) {
String existingHandle = object.getHandleIdentifier();
int suffixPosition = existingHandle.indexOf('!');
|
256,400 |
Bug 256400 An internal error occurred during: "Delete and update AspectJ markers for CoreSource".
|
this occured during a clean and build of the project i'm working on. The following was inthe details. An internal error occurred during: "Delete and update AspectJ markers for CoreSource". java.lang.NullPointerException
|
resolved fixed
|
155a888
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-11-27T17:59:09Z | 2008-11-25T10:46:40Z |
asm/src/org/aspectj/asm/internal/JDTLikeHandleProvider.java
|
if (suffixPosition != -1) {
count = new Integer(existingHandle.substring(suffixPosition + 1)).intValue() + 1;
} else {
if (count == 1) {
count = 2;
}
}
}
}
}
}
if (count > 1) {
return CharOperation.concat(countDelim, new Integer(count).toString().toCharArray());
}
}
return empty;
}
/**
* Only returns the count if it's not equal to 1
*/
private char[] convertCount(char[] c) {
if ((c.length == 1 && c[0] != ' ' && c[0] != '1') || c.length > 1) {
return CharOperation.concat(countDelim, c);
}
return empty;
}
public String getFileForHandle(String handle) {
IProgramElement node = asm.getHierarchy().getElement(handle);
if (node != null) {
return asm.getCanonicalFilePath(node.getSourceLocation().getSourceFile());
|
256,400 |
Bug 256400 An internal error occurred during: "Delete and update AspectJ markers for CoreSource".
|
this occured during a clean and build of the project i'm working on. The following was inthe details. An internal error occurred during: "Delete and update AspectJ markers for CoreSource". java.lang.NullPointerException
|
resolved fixed
|
155a888
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-11-27T17:59:09Z | 2008-11-25T10:46:40Z |
asm/src/org/aspectj/asm/internal/JDTLikeHandleProvider.java
|
} else if (handle.charAt(0) == HandleProviderDelimiter.ASPECT_CU.getDelimiter()
|| handle.charAt(0) == HandleProviderDelimiter.COMPILATIONUNIT.getDelimiter()) {
return backslash + handle.substring(1);
}
return emptyString;
}
public int getLineNumberForHandle(String handle) {
IProgramElement node = asm.getHierarchy().getElement(handle);
if (node != null) {
return node.getSourceLocation().getLine();
} else if (handle.charAt(0) == HandleProviderDelimiter.ASPECT_CU.getDelimiter()
|| handle.charAt(0) == HandleProviderDelimiter.COMPILATIONUNIT.getDelimiter()) {
return 1;
}
return -1;
}
public int getOffSetForHandle(String handle) {
IProgramElement node = asm.getHierarchy().getElement(handle);
if (node != null) {
return node.getSourceLocation().getOffset();
} else if (handle.charAt(0) == HandleProviderDelimiter.ASPECT_CU.getDelimiter()
|| handle.charAt(0) == HandleProviderDelimiter.COMPILATIONUNIT.getDelimiter()) {
|
256,400 |
Bug 256400 An internal error occurred during: "Delete and update AspectJ markers for CoreSource".
|
this occured during a clean and build of the project i'm working on. The following was inthe details. An internal error occurred during: "Delete and update AspectJ markers for CoreSource". java.lang.NullPointerException
|
resolved fixed
|
155a888
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-11-27T17:59:09Z | 2008-11-25T10:46:40Z |
asm/src/org/aspectj/asm/internal/JDTLikeHandleProvider.java
|
return 0;
}
return -1;
}
public String createHandleIdentifier(ISourceLocation location) {
IProgramElement node = asm.getHierarchy().findElementForSourceLine(location);
if (node != null) {
return createHandleIdentifier(node);
}
return null;
}
public String createHandleIdentifier(File sourceFile, int line, int column, int offset) {
IProgramElement node = asm.getHierarchy().findElementForOffSet(sourceFile.getAbsolutePath(), line, offset);
if (node != null) {
return createHandleIdentifier(node);
}
return null;
}
public boolean dependsOnLocation() {
return false;
}
public void initialize() {
initializerCounter = 0;
}
}
|
185,447 |
Bug 185447 [plan] [ataspectj] Abstract @Aspect causing problems
|
Trying to use an abstract @Aspect from a library jar file is causing problems. In the (soon to be) attached zip of eclipse projects: * logging-library: defines two abstract trivial logging aspects, one in code-style and one in @AspectJ style. * sample-system: uses the code-style abstract aspect successfully * sample-system2: uses the @AspectJ style abstract aspect and won't compile in Eclipse Exception: java.lang.NullPointerException at org.aspectj.weaver.bcel.AtAjAttributes$LazyResolvedPointcutDefinition.getPointcut(AtAjAttributes.java:1632) at org.aspectj.weaver.ShadowMunger.addChildNodes(ShadowMunger.java:258) at org.aspectj.weaver.ShadowMunger.createHierarchy(ShadowMunger.java:247) at org.aspectj.weaver.AsmRelationshipProvider.adviceMunger(AsmRelationshipProvider.java:180) at org.aspectj.weaver.Shadow.implementMungers(Shadow.java:717) a ... int;)Ljava/lang/String; ARETURN end public Object run(Object[])
|
resolved fixed
|
120b47f
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-12-01T21:00:43Z | 2007-05-03T22:06:40Z |
weaver/src/org/aspectj/weaver/bcel/AtAjAttributes.java
|
/*******************************************************************************
* Copyright (c) 2005 Contributors.
* All rights reserved.
* This program and the accompanying materials are made available
* under the terms of the Eclipse Public License v1.0
* which accompanies this distribution and is available at
* http:eclipse.org/legal/epl-v10.html
*
* Contributors:
* initial implementation Alexandre Vasseur
*******************************************************************************/
package org.aspectj.weaver.bcel;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.StringTokenizer;
import org.aspectj.apache.bcel.Constants;
import org.aspectj.apache.bcel.classfile.Attribute;
import org.aspectj.apache.bcel.classfile.Constant;
import org.aspectj.apache.bcel.classfile.ConstantUtf8;
import org.aspectj.apache.bcel.classfile.Field;
import org.aspectj.apache.bcel.classfile.JavaClass;
import org.aspectj.apache.bcel.classfile.LocalVariable;
import org.aspectj.apache.bcel.classfile.LocalVariableTable;
import org.aspectj.apache.bcel.classfile.Method;
import org.aspectj.apache.bcel.classfile.annotation.AnnotationGen;
import org.aspectj.apache.bcel.classfile.annotation.ClassElementValueGen;
|
185,447 |
Bug 185447 [plan] [ataspectj] Abstract @Aspect causing problems
|
Trying to use an abstract @Aspect from a library jar file is causing problems. In the (soon to be) attached zip of eclipse projects: * logging-library: defines two abstract trivial logging aspects, one in code-style and one in @AspectJ style. * sample-system: uses the code-style abstract aspect successfully * sample-system2: uses the @AspectJ style abstract aspect and won't compile in Eclipse Exception: java.lang.NullPointerException at org.aspectj.weaver.bcel.AtAjAttributes$LazyResolvedPointcutDefinition.getPointcut(AtAjAttributes.java:1632) at org.aspectj.weaver.ShadowMunger.addChildNodes(ShadowMunger.java:258) at org.aspectj.weaver.ShadowMunger.createHierarchy(ShadowMunger.java:247) at org.aspectj.weaver.AsmRelationshipProvider.adviceMunger(AsmRelationshipProvider.java:180) at org.aspectj.weaver.Shadow.implementMungers(Shadow.java:717) a ... int;)Ljava/lang/String; ARETURN end public Object run(Object[])
|
resolved fixed
|
120b47f
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-12-01T21:00:43Z | 2007-05-03T22:06:40Z |
weaver/src/org/aspectj/weaver/bcel/AtAjAttributes.java
|
import org.aspectj.apache.bcel.classfile.annotation.ElementNameValuePairGen;
import org.aspectj.apache.bcel.classfile.annotation.RuntimeAnnotations;
import org.aspectj.apache.bcel.classfile.annotation.RuntimeVisibleAnnotations;
import org.aspectj.apache.bcel.generic.Type;
import org.aspectj.asm.AsmManager;
import org.aspectj.asm.IHierarchy;
import org.aspectj.asm.IProgramElement;
import org.aspectj.bridge.IMessage;
import org.aspectj.bridge.IMessageHandler;
import org.aspectj.bridge.ISourceLocation;
import org.aspectj.bridge.Message;
import org.aspectj.bridge.MessageUtil;
import org.aspectj.weaver.Advice;
import org.aspectj.weaver.AdviceKind;
import org.aspectj.weaver.AjAttribute;
import org.aspectj.weaver.AjcMemberMaker;
import org.aspectj.weaver.BindingScope;
import org.aspectj.weaver.ISourceContext;
import org.aspectj.weaver.MethodDelegateTypeMunger;
import org.aspectj.weaver.NameMangler;
import org.aspectj.weaver.ReferenceType;
import org.aspectj.weaver.ResolvedMember;
import org.aspectj.weaver.ResolvedPointcutDefinition;
import org.aspectj.weaver.ResolvedType;
import org.aspectj.weaver.UnresolvedType;
import org.aspectj.weaver.WeaverMessages;
import org.aspectj.weaver.patterns.Bindings;
import org.aspectj.weaver.patterns.DeclareErrorOrWarning;
import org.aspectj.weaver.patterns.DeclareParents;
import org.aspectj.weaver.patterns.DeclarePrecedence;
|
185,447 |
Bug 185447 [plan] [ataspectj] Abstract @Aspect causing problems
|
Trying to use an abstract @Aspect from a library jar file is causing problems. In the (soon to be) attached zip of eclipse projects: * logging-library: defines two abstract trivial logging aspects, one in code-style and one in @AspectJ style. * sample-system: uses the code-style abstract aspect successfully * sample-system2: uses the @AspectJ style abstract aspect and won't compile in Eclipse Exception: java.lang.NullPointerException at org.aspectj.weaver.bcel.AtAjAttributes$LazyResolvedPointcutDefinition.getPointcut(AtAjAttributes.java:1632) at org.aspectj.weaver.ShadowMunger.addChildNodes(ShadowMunger.java:258) at org.aspectj.weaver.ShadowMunger.createHierarchy(ShadowMunger.java:247) at org.aspectj.weaver.AsmRelationshipProvider.adviceMunger(AsmRelationshipProvider.java:180) at org.aspectj.weaver.Shadow.implementMungers(Shadow.java:717) a ... int;)Ljava/lang/String; ARETURN end public Object run(Object[])
|
resolved fixed
|
120b47f
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-12-01T21:00:43Z | 2007-05-03T22:06:40Z |
weaver/src/org/aspectj/weaver/bcel/AtAjAttributes.java
|
import org.aspectj.weaver.patterns.FormalBinding;
import org.aspectj.weaver.patterns.IScope;
import org.aspectj.weaver.patterns.ParserException;
import org.aspectj.weaver.patterns.PatternParser;
import org.aspectj.weaver.patterns.PerCflow;
import org.aspectj.weaver.patterns.PerClause;
import org.aspectj.weaver.patterns.PerFromSuper;
import org.aspectj.weaver.patterns.PerObject;
import org.aspectj.weaver.patterns.PerSingleton;
import org.aspectj.weaver.patterns.PerTypeWithin;
import org.aspectj.weaver.patterns.Pointcut;
import org.aspectj.weaver.patterns.TypePattern;
/**
* Annotation defined aspect reader. Reads the Java 5 annotations and turns them into AjAttributes
*
* @author <a href="mailto:alex AT gnilux DOT com">Alexandre Vasseur</a>
*/
public class AtAjAttributes {
private final static List EMPTY_LIST = new ArrayList();
private final static String[] EMPTY_STRINGS = new String[0];
private final static String VALUE = "value";
private final static String ARGNAMES = "argNames";
private final static String POINTCUT = "pointcut";
private final static String THROWING = "throwing";
private final static String RETURNING = "returning";
private final static String STRING_DESC = "Ljava/lang/String;";
/**
* A struct that allows to add extra arguments without always breaking the API
*/
private static class AjAttributeStruct {
|
185,447 |
Bug 185447 [plan] [ataspectj] Abstract @Aspect causing problems
|
Trying to use an abstract @Aspect from a library jar file is causing problems. In the (soon to be) attached zip of eclipse projects: * logging-library: defines two abstract trivial logging aspects, one in code-style and one in @AspectJ style. * sample-system: uses the code-style abstract aspect successfully * sample-system2: uses the @AspectJ style abstract aspect and won't compile in Eclipse Exception: java.lang.NullPointerException at org.aspectj.weaver.bcel.AtAjAttributes$LazyResolvedPointcutDefinition.getPointcut(AtAjAttributes.java:1632) at org.aspectj.weaver.ShadowMunger.addChildNodes(ShadowMunger.java:258) at org.aspectj.weaver.ShadowMunger.createHierarchy(ShadowMunger.java:247) at org.aspectj.weaver.AsmRelationshipProvider.adviceMunger(AsmRelationshipProvider.java:180) at org.aspectj.weaver.Shadow.implementMungers(Shadow.java:717) a ... int;)Ljava/lang/String; ARETURN end public Object run(Object[])
|
resolved fixed
|
120b47f
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-12-01T21:00:43Z | 2007-05-03T22:06:40Z |
weaver/src/org/aspectj/weaver/bcel/AtAjAttributes.java
|
/**
* The list of AjAttribute.XXX that we are populating from the @AJ read
*/
List ajAttributes = new ArrayList();
/**
* The resolved type (class) for which we are reading @AJ for (be it class, method, field annotations)
*/
final ResolvedType enclosingType;
final ISourceContext context;
final IMessageHandler handler;
public AjAttributeStruct(ResolvedType type, ISourceContext sourceContext, IMessageHandler messageHandler) {
enclosingType = type;
context = sourceContext;
handler = messageHandler;
}
}
/**
* A struct when we read @AJ on method
*
* @author <a href="mailto:alex AT gnilux DOT com">Alexandre Vasseur</a>
*/
private static class AjAttributeMethodStruct extends AjAttributeStruct {
|
185,447 |
Bug 185447 [plan] [ataspectj] Abstract @Aspect causing problems
|
Trying to use an abstract @Aspect from a library jar file is causing problems. In the (soon to be) attached zip of eclipse projects: * logging-library: defines two abstract trivial logging aspects, one in code-style and one in @AspectJ style. * sample-system: uses the code-style abstract aspect successfully * sample-system2: uses the @AspectJ style abstract aspect and won't compile in Eclipse Exception: java.lang.NullPointerException at org.aspectj.weaver.bcel.AtAjAttributes$LazyResolvedPointcutDefinition.getPointcut(AtAjAttributes.java:1632) at org.aspectj.weaver.ShadowMunger.addChildNodes(ShadowMunger.java:258) at org.aspectj.weaver.ShadowMunger.createHierarchy(ShadowMunger.java:247) at org.aspectj.weaver.AsmRelationshipProvider.adviceMunger(AsmRelationshipProvider.java:180) at org.aspectj.weaver.Shadow.implementMungers(Shadow.java:717) a ... int;)Ljava/lang/String; ARETURN end public Object run(Object[])
|
resolved fixed
|
120b47f
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-12-01T21:00:43Z | 2007-05-03T22:06:40Z |
weaver/src/org/aspectj/weaver/bcel/AtAjAttributes.java
|
private String[] m_argumentNamesLazy = null;
public String unparsedArgumentNames = null;
final Method method;
final BcelMethod bMethod;
public AjAttributeMethodStruct(Method method, BcelMethod bMethod, ResolvedType type, ISourceContext sourceContext,
IMessageHandler messageHandler) {
super(type, sourceContext, messageHandler);
this.method = method;
this.bMethod = bMethod;
}
public String[] getArgumentNames() {
if (m_argumentNamesLazy == null) {
m_argumentNamesLazy = getMethodArgumentNames(method, unparsedArgumentNames, this);
}
return m_argumentNamesLazy;
}
}
/**
* A struct when we read @AJ on field
*/
private static class AjAttributeFieldStruct extends AjAttributeStruct {
|
185,447 |
Bug 185447 [plan] [ataspectj] Abstract @Aspect causing problems
|
Trying to use an abstract @Aspect from a library jar file is causing problems. In the (soon to be) attached zip of eclipse projects: * logging-library: defines two abstract trivial logging aspects, one in code-style and one in @AspectJ style. * sample-system: uses the code-style abstract aspect successfully * sample-system2: uses the @AspectJ style abstract aspect and won't compile in Eclipse Exception: java.lang.NullPointerException at org.aspectj.weaver.bcel.AtAjAttributes$LazyResolvedPointcutDefinition.getPointcut(AtAjAttributes.java:1632) at org.aspectj.weaver.ShadowMunger.addChildNodes(ShadowMunger.java:258) at org.aspectj.weaver.ShadowMunger.createHierarchy(ShadowMunger.java:247) at org.aspectj.weaver.AsmRelationshipProvider.adviceMunger(AsmRelationshipProvider.java:180) at org.aspectj.weaver.Shadow.implementMungers(Shadow.java:717) a ... int;)Ljava/lang/String; ARETURN end public Object run(Object[])
|
resolved fixed
|
120b47f
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-12-01T21:00:43Z | 2007-05-03T22:06:40Z |
weaver/src/org/aspectj/weaver/bcel/AtAjAttributes.java
|
final Field field;
final BcelField bField;
public AjAttributeFieldStruct(Field field, BcelField bField, ResolvedType type, ISourceContext sourceContext,
IMessageHandler messageHandler) {
super(type, sourceContext, messageHandler);
this.field = field;
this.bField = bField;
}
}
/**
* Annotations are RuntimeVisible only. This allow us to not visit RuntimeInvisible ones.
*
* @param attribute
* @return true if runtime visible annotation
*/
public static boolean acceptAttribute(Attribute attribute) {
return (attribute instanceof RuntimeVisibleAnnotations);
}
/**
* Extract class level annotations and turn them into AjAttributes.
*
* @param javaClass
* @param type
* @param context
* @param msgHandler
* @return list of AjAttributes
*/
public static List readAj5ClassAttributes(AsmManager model, JavaClass javaClass, ReferenceType type, ISourceContext context,
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.