transformer: Improve error message for non-matching visibility of methods

Author: NotStirred

build.gradle

@@ -10,7 +10,7 @@ plugins {
 
 group 'io.github.notstirred'
 archivesBaseName = "dasm"
-version '2.2.1'
+version '2.3.0'
 
 ext.ossrhUsername = project.findProperty("ossrhUsername") ?: "" // Enter in ~/.gradle/gradle.properties, not here.
 ext.ossrhPassword = project.findProperty("ossrhPassword") ?: "" // Enter in ~/.gradle/gradle.properties, not here.

src/main/java/io/github/notstirred/dasm/annotation/AnnotationParser.java

@@ -186,7 +186,8 @@ public Optional<Collection<MethodTransform>> buildMethodTargets(ClassNode target
                                 addedParameters,
                                 visibility.first,
                                 visibility.second
-                        )
+                        ),
+                        new MethodTransform.OriginalTransformData(targetClass.name, method)
                 );
 
                 AnnotationNode addToSetsAnnotation = getAnnotationIfPresent(method.invisibleAnnotations, AddTransformToSets.class);

src/main/java/io/github/notstirred/dasm/transformer/Transformer.java

@@ -142,9 +142,9 @@ public void transform(ClassNode targetClass, Collection<MethodTransform> transfo
             TransformRedirects transformRedirects = new TransformRedirects(transform.redirectSets(), this.mappingsProvider);
             try {
                 if (transform.inPlace()) {
-                    applyRedirects(srcClass, transform.srcMethod(), transformRedirects, transform.transformChanges(), true);
+                    applyRedirects(srcClass, transform.srcMethod(), transformRedirects, transform.transformChanges(), transform.originalTransformData(), true);
                 } else {
-                    cloneAndApplyRedirects(srcClass, targetClass, transform.srcMethod(), transform.dstMethodName(), transformRedirects, transform.transformChanges(), true);
+                    cloneAndApplyRedirects(srcClass, targetClass, transform.srcMethod(), transform.dstMethodName(), transformRedirects, transform.transformChanges(), transform.originalTransformData(), true);
                 }
 
             } catch (SrcMethodNotFound e) {
@@ -163,8 +163,9 @@ private MethodNode cloneAndApplyRedirects(ClassNode srcClass, ClassNode targetCl
                                               ClassMethod srcMethod, String dstMethodName,
                                               TransformRedirects redirects,
                                               MethodTransform.TransformChanges transformChanges,
+                                              MethodTransform.OriginalTransformData originalTransformData,
                                               boolean debugLogging) throws DasmTransformException {
-        return redirects(srcClass, targetClass, srcMethod, dstMethodName, redirects, transformChanges, debugLogging,
+        return redirects(srcClass, targetClass, srcMethod, dstMethodName, redirects, transformChanges, originalTransformData, debugLogging,
                 (srcMethodNode, dstMethodNode, existingMethodNode) -> {
                     cloneAndApplyLambdaRedirects(srcClass, targetClass, srcMethodNode, redirects, debugLogging);
                     if (debugLogging && existingMethodNode != null && (existingMethodNode.access & ACC_NATIVE) == 0) {
@@ -179,8 +180,9 @@ private MethodNode cloneAndApplyRedirects(ClassNode srcClass, ClassNode targetCl
     private void applyRedirects(ClassNode srcClass, ClassMethod srcMethod,
                                 TransformRedirects redirects,
                                 MethodTransform.TransformChanges transformChanges,
+                                MethodTransform.OriginalTransformData originalTransformData,
                                 boolean debugLogging) throws DasmTransformException {
-        redirects(srcClass, srcClass, srcMethod, srcMethod.method().getName(), redirects, transformChanges, debugLogging,
+        redirects(srcClass, srcClass, srcMethod, srcMethod.method().getName(), redirects, transformChanges, originalTransformData, debugLogging,
                 (srcMethodNode, dstMethodNode, existingMethodNode) -> {
                     applyLambdaRedirects(srcClass, srcMethodNode, redirects, debugLogging);
                     if (debugLogging && existingMethodNode != null && (existingMethodNode.access & ACC_NATIVE) == 0 && !srcMethodNode.desc.equals(dstMethodNode.desc)) {
@@ -202,6 +204,7 @@ private MethodNode redirects(ClassNode srcClass, ClassNode targetClass,
                                  ClassMethod srcMethod, String dstMethodName,
                                  TransformRedirects redirects,
                                  MethodTransform.TransformChanges transformChanges,
+                                 MethodTransform.OriginalTransformData originalTransformData,
                                  boolean debugLogging,
                                  RedirectsFunction f) throws DasmTransformException {
         Method existingMethod = srcMethod.remap(this.mappingsProvider).method();
@@ -213,7 +216,7 @@ private MethodNode redirects(ClassNode srcClass, ClassNode targetClass,
         String dstMethodDescriptor = applyTransformsToMethodDescriptor(srcMethodNode.desc, redirects, transformChanges.addedParameters());
         MethodNode existingMethodNode = removeExistingMethod(targetClass, dstMethodName, dstMethodDescriptor);
 
-        transformChanges.throwIfInvalidAccess(Visibility.fromAccess(srcMethodNode.access));
+        transformChanges.throwIfInvalidAccess(originalTransformData, Visibility.fromAccess(srcMethodNode.access));
         // FIXME: transform exceptions
         int access = transformChanges.dstMethodVisibility().access | (srcMethodNode.access & ~(ACC_PUBLIC | ACC_PROTECTED | ACC_PRIVATE));
         MethodNode dstMethodNode = new MethodNode(access, dstMethodName, dstMethodDescriptor, null, srcMethodNode.exceptions.toArray(new String[0]));
@@ -287,6 +290,7 @@ private void cloneAndApplyLambdaRedirects(ClassNode srcClass, ClassNode targetCl
                     newName,
                     redirects,
                     new MethodTransform.TransformChanges(Collections.emptyList(), Visibility.PRIVATE, Visibility.SAME_AS_TARGET),
+                    new MethodTransform.OriginalTransformData(srcClass.name, method),
                     debugLogging
             );
         });
@@ -311,6 +315,7 @@ private void applyLambdaRedirects(ClassNode srcClass, MethodNode method, Transfo
                 classMethod,
                 redirects,
                 new MethodTransform.TransformChanges(Collections.emptyList(), Visibility.PRIVATE, Visibility.SAME_AS_TARGET),
+                new MethodTransform.OriginalTransformData(srcClass.name, method), // Assume lambas are always private, the passed in method here is therefore irrelevant
                 debugLogging
         ));
     }

src/main/java/io/github/notstirred/dasm/transformer/data/MethodTransform.java

@@ -7,6 +7,7 @@
 import io.github.notstirred.dasm.data.ClassMethod;
 import io.github.notstirred.dasm.exception.DasmTransformException;
 import lombok.Data;
+import org.objectweb.asm.tree.MethodNode;
 
 import java.util.List;
 
@@ -17,34 +18,44 @@ public class MethodTransform {
     private final List<RedirectSetImpl> redirectSets;
     private final ApplicationStage stage;
     private final boolean inPlace;
+
     private final TransformChanges transformChanges;
 
+    private final OriginalTransformData originalTransformData;
+
     @Data
     public static class TransformChanges {
         private final List<AddedParameter> addedParameters;
         private final Visibility dstMethodVisibility;
         private final Visibility annotationVisibility;
 
-        public void throwIfInvalidAccess(Visibility srcMethodVisibility) throws DasmTransformException {
+        public void throwIfInvalidAccess(OriginalTransformData originalTransformData, Visibility srcMethodVisibility) throws DasmTransformException {
             if (this.annotationVisibility == Visibility.SAME_AS_TARGET) {
                 // if the annotation is default, the dst must match the src method
                 if (this.dstMethodVisibility != srcMethodVisibility) {
-                    throw new InvalidVisibility(this.dstMethodVisibility, srcMethodVisibility);
+                    throw new InvalidVisibility(originalTransformData, this.dstMethodVisibility, srcMethodVisibility);
                 } else {
                     return;
                 }
             }
 
             // otherwise the dst method must match the annotation
             if (this.dstMethodVisibility != this.annotationVisibility) {
-                throw new InvalidVisibility(this.dstMethodVisibility, this.annotationVisibility);
+                throw new InvalidVisibility(originalTransformData, this.dstMethodVisibility, this.annotationVisibility);
             }
         }
 
         public static class InvalidVisibility extends DasmTransformException {
-            public InvalidVisibility(Visibility has, Visibility expected) {
-                super("Transform has invalid visibility. Has `" + has + "`, expected `" + expected + "`");
+            public InvalidVisibility(OriginalTransformData originalTransformData, Visibility has, Visibility expected) {
+                super("Transform " + originalTransformData.className.substring(originalTransformData.className.lastIndexOf('/') + 1)
+                        + "#" + originalTransformData.methodNode.name + " has invalid visibility. Has `" + has + "`, expected `" + expected + "`");
             }
         }
     }
+
+    @Data
+    public static class OriginalTransformData {
+        private final String className;
+        private final MethodNode methodNode;
+    }
 }