Fix 548785: Check level is >=1.8 when looking to skip inlining around advice lambdas

diff --git a/weaver/src/main/java/org/aspectj/weaver/bcel/BcelAdvice.java b/weaver/src/main/java/org/aspectj/weaver/bcel/BcelAdvice.java
index 924e6e10c90912d81b5185e430e463ca24520ec8..0c2cadb1fa18283aa6e8723cda307d9f9d0f2a34 100644 (file)
--- a/weaver/src/main/java/org/aspectj/weaver/bcel/BcelAdvice.java
+++ b/weaver/src/main/java/org/aspectj/weaver/bcel/BcelAdvice.java
@@ -57,7 +57,7 @@ import org.aspectj.weaver.patterns.Pointcut;
 
 /**
  * Advice implemented for BCEL
- * 
+ *
  * @author Erik Hilsdale
  * @author Jim Hugunin
  * @author Andy Clement
@@ -71,12 +71,12 @@ class BcelAdvice extends Advice {
        private Test runtimeTest;
        private ExposedState exposedState;
        private int containsInvokedynamic = 0;// 0 = dontknow, 1=no, 2=yes
-       
+
        public BcelAdvice(AjAttribute.AdviceAttribute attribute, Pointcut pointcut, Member adviceSignature, ResolvedType concreteAspect) {
                super(attribute, pointcut, simplify(attribute.getKind(), adviceSignature));
                this.concreteAspect = concreteAspect;
        }
-       
+
        public boolean bindsProceedingJoinPoint() {
                UnresolvedType[] parameterTypes = signature.getParameterTypes();
                for (int i=0;i<parameterTypes.length;i++) {
@@ -86,7 +86,7 @@ class BcelAdvice extends Advice {
                }
                return false;
        }
-       
+
        /**
         * A heavyweight BcelMethod object is only required for around advice that will be inlined. For other kinds of advice it is
         * possible to save some space.
@@ -247,7 +247,7 @@ class BcelAdvice extends Advice {
                }
                // Need isJava8 check
                // Does the advice contain invokedynamic...
-               if (boType.javaClass.getMajor() == Constants.MAJOR_1_8) {
+               if (boType.javaClass.getMajor() >= Constants.MAJOR_1_8) {
                        if (containsInvokedynamic == 0) {
                                containsInvokedynamic = 1;
                                LazyMethodGen lmg = boType.getLazyClassGen().getLazyMethodGen(this.signature.getName(), this.signature.getSignature(), true);
@@ -472,7 +472,7 @@ class BcelAdvice extends Advice {
        /**
         * The munger must not check for the advice exceptions to be declared by the shadow in the case of @AJ aspects so that around
         * can throws Throwable
-        * 
+        *
         * @return
         */
        @Override
@@ -499,7 +499,7 @@ class BcelAdvice extends Advice {
        /**
         * get the instruction list for the really simple version of this advice. Is broken apart for other advice, but if you want it
         * in one block, this is the method to call.
-        * 
+        *
         * @param s The shadow around which these instructions will eventually live.
         * @param extraArgVar The var that will hold the return value or thrown exception for afterX advice
         * @param ifNoAdvice The instructionHandle to jump to if the dynamic tests for this munger fails.

diff --git a/weaver/src/main/java/org/aspectj/weaver/bcel/asm/StackMapAdder.java b/weaver/src/main/java/org/aspectj/weaver/bcel/asm/StackMapAdder.java
index dd3965b612cb494166b55e7e50516a87105c76cb..9ede3e99dfcb830572b2f1bd7b5661fc48204d6a 100644 (file)
--- a/weaver/src/main/java/org/aspectj/weaver/bcel/asm/StackMapAdder.java
+++ b/weaver/src/main/java/org/aspectj/weaver/bcel/asm/StackMapAdder.java
@@ -25,14 +25,14 @@ import aj.org.objectweb.asm.Opcodes;
  * Uses asm to add the stack map attribute to methods in a class. The class is passed in as pure byte data and then a reader/writer
  * process it. The writer is wired into the world so that types can be resolved and getCommonSuperClass() can be implemented without
  * class loading using the context class loader.
- * 
+ *
  * It is important that the constant pool is preserved here and asm does not try to remove unused entries.  That is because some
  * entries are refered to from classfile attributes.  Asm cannot see into these attributes so does not realise the constant pool
  * entries are in use.  In order to ensure the copying of cp occurs, we use the variant super constructor call in AspectJConnectClassWriter
  * that passes in the classreader.  However, ordinarily that change causes a further optimization: that if a classreader sees
  * a methodvisitor that has been created by a ClassWriter then it just copies the data across without changing it (and so it
  * fails to attach the stackmapattribute).  In order to avoid this further optimization we use our own minimal MethodVisitor.
- * 
+ *
  * @author Andy Clement
  */
 public class StackMapAdder {
@@ -46,11 +46,12 @@ public class StackMapAdder {
                        return cw.toByteArray();
                } catch (Throwable t) {
                        System.err.println("AspectJ Internal Error: unable to add stackmap attributes. " + t.getMessage());
+                       t.printStackTrace();
                        AsmDetector.isAsmAround = false;
                        return data;
                }
        }
-       
+
        private static class AspectJClassVisitor extends ClassVisitor {
 
                public AspectJClassVisitor(ClassVisitor classwriter) {
@@ -62,7 +63,7 @@ public class StackMapAdder {
                        MethodVisitor mv = super.visitMethod(access, name, desc, signature, exceptions);
                        return new AJMethodVisitor(mv);
                }
-               
+
                // Minimal pass through MethodVisitor just so that the ClassReader doesn't see one that has been directly
                // created by a ClassWriter (see top level class comment)
                static class AJMethodVisitor extends MethodVisitor {
@@ -70,7 +71,7 @@ public class StackMapAdder {
                                super(Opcodes.ASM7,mv);
                        }
                }
-               
+
        }
 
        private static class AspectJConnectClassWriter extends ClassWriter {
@@ -80,7 +81,7 @@ public class StackMapAdder {
                        super(cr, ClassWriter.COMPUTE_FRAMES); // passing in cr is necessary so cpool isnt modified (see 2.2.4 of asm doc)
                        this.world = w;
                }
-               
+
 
                // Implementation of getCommonSuperClass() that avoids Class.forName()
                @Override
@@ -103,7 +104,7 @@ public class StackMapAdder {
                                do {
                                        resolvedType1 = resolvedType1.getSuperclass();
                                        if (resolvedType1 == null) {
-                                               // This happens if some types are missing, the getSuperclass() call on 
+                                               // This happens if some types are missing, the getSuperclass() call on
                                                // MissingResolvedTypeWithKnownSignature will return the Missing type which
                                                // in turn returns a superclass of null. By returning Object here it
                                                // should surface the cantFindType message raised in the first problematic