Apply suggestions

- Fix ConstantValueAttribute remapping and skipStringConstants short-circuit in RelocatorRemapper
- Fix field access flags preservation and module exports/opens relocation in RelocatorRemapper
- Fix class descriptor derivation and annotation string constant relocation

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>

Author: Copilot

src/functionalTest/kotlin/com/github/jengelman/gradle/plugins/shadow/RelocationTest.kt

@@ -533,6 +533,45 @@ class RelocationTest : BasePluginTest() {
     }
   }
 
+  @Test
+  fun relocateAnnotationStringConstants() {
+    writeClass {
+      """
+      package my;
+      import java.lang.annotation.Retention;
+      import java.lang.annotation.RetentionPolicy;
+      @Retention(RetentionPolicy.RUNTIME)
+      @interface MyAnnotation {
+        String value();
+      }
+      @MyAnnotation("foo.Bar")
+      public class Main {
+        public static void main(String[] args) {
+          MyAnnotation ann = Main.class.getAnnotation(MyAnnotation.class);
+          System.out.println(ann.value());
+        }
+      }
+      """
+        .trimIndent()
+    }
+    projectScript.appendText(
+      """
+        $shadowJarTask {
+          manifest {
+            attributes '$mainClassAttributeKey': 'my.Main'
+          }
+          relocate('foo', 'shadow.foo')
+        }
+      """
+        .trimIndent()
+    )
+
+    runWithSuccess(shadowJarPath)
+    val result = runProcess("java", "-jar", outputShadowedJar.use { it.toString() })
+
+    assertThat(result).contains("shadow.foo.Bar")
+  }
+
   @Issue("https://github.com/GradleUp/shadow/issues/1403")
   @Test
   fun relocateMultiClassSignatureStringConstants() {

src/main/kotlin/com/github/jengelman/gradle/plugins/shadow/internal/RelocatorRemapper.kt

@@ -19,11 +19,14 @@ import java.lang.classfile.Signature
 import java.lang.classfile.Superclass
 import java.lang.classfile.TypeAnnotation
 import java.lang.classfile.attribute.AnnotationDefaultAttribute
+import java.lang.classfile.attribute.ConstantValueAttribute
 import java.lang.classfile.attribute.EnclosingMethodAttribute
 import java.lang.classfile.attribute.ExceptionsAttribute
 import java.lang.classfile.attribute.InnerClassInfo
 import java.lang.classfile.attribute.InnerClassesAttribute
 import java.lang.classfile.attribute.ModuleAttribute
+import java.lang.classfile.attribute.ModuleExportInfo
+import java.lang.classfile.attribute.ModuleOpenInfo
 import java.lang.classfile.attribute.ModuleProvideInfo
 import java.lang.classfile.attribute.NestHostAttribute
 import java.lang.classfile.attribute.NestMembersAttribute
@@ -37,6 +40,7 @@ import java.lang.classfile.attribute.RuntimeVisibleAnnotationsAttribute
 import java.lang.classfile.attribute.RuntimeVisibleParameterAnnotationsAttribute
 import java.lang.classfile.attribute.RuntimeVisibleTypeAnnotationsAttribute
 import java.lang.classfile.attribute.SignatureAttribute
+import java.lang.classfile.constantpool.StringEntry
 import java.lang.classfile.instruction.ConstantInstruction
 import java.lang.classfile.instruction.ExceptionCatch
 import java.lang.classfile.instruction.FieldInstruction
@@ -55,6 +59,7 @@ import java.lang.constant.DynamicCallSiteDesc
 import java.lang.constant.DynamicConstantDesc
 import java.lang.constant.MethodHandleDesc
 import java.lang.constant.MethodTypeDesc
+import java.lang.constant.PackageDesc
 import java.util.regex.Pattern
 
 /**
@@ -75,7 +80,7 @@ internal class RelocatorRemapper(
           cle.fieldName().stringValue(),
           mapClassDesc(ClassDesc.ofDescriptor(cle.fieldType().stringValue())),
         ) { fb ->
-          fb.transform(cle, asFieldTransform())
+          fb.withFlags(cle.flags().flagsMask()).transform(cle, asFieldTransform())
         }
       is MethodModel ->
         clb.withMethod(
@@ -123,8 +128,28 @@ internal class RelocatorRemapper(
             cle.moduleFlagsMask(),
             cle.moduleVersion().orElse(null),
             cle.requires(),
-            cle.exports(),
-            cle.opens(),
+            cle.exports().map { mei ->
+              ModuleExportInfo.of(
+                clb
+                  .constantPool()
+                  .packageEntry(
+                    PackageDesc.ofInternalName(map(mei.exportedPackage().asSymbol().internalName()))
+                  ),
+                mei.exportsFlagsMask(),
+                mei.exportsTo(),
+              )
+            },
+            cle.opens().map { moi ->
+              ModuleOpenInfo.of(
+                clb
+                  .constantPool()
+                  .packageEntry(
+                    PackageDesc.ofInternalName(map(moi.openedPackage().asSymbol().internalName()))
+                  ),
+                moi.opensFlagsMask(),
+                moi.opensTo(),
+              )
+            },
             cle.uses().map { clb.constantPool().classEntry(mapClassDesc(it.asSymbol())!!) },
             cle.provides().map { mp ->
               ModuleProvideInfo.of(
@@ -160,6 +185,15 @@ internal class RelocatorRemapper(
 
   private fun asFieldTransform(): FieldTransform = FieldTransform { fb, fe ->
     when (fe) {
+      is ConstantValueAttribute -> {
+        val constant = fe.constant()
+        if (constant is StringEntry) {
+          val remapped = map(constant.stringValue(), true)
+          fb.with(ConstantValueAttribute.of(fb.constantPool().stringEntry(remapped)))
+        } else {
+          fb.with(fe)
+        }
+      }
       is SignatureAttribute -> fb.with(SignatureAttribute.of(mapSignature(fe.asTypeSignature())))
       is RuntimeVisibleAnnotationsAttribute ->
         fb.with(RuntimeVisibleAnnotationsAttribute.of(mapAnnotations(fe.annotations())))
@@ -436,7 +470,16 @@ internal class RelocatorRemapper(
         AnnotationValue.ofAnnotation(mapAnnotation(valObj.annotation()))
       is AnnotationValue.OfArray ->
         AnnotationValue.ofArray(valObj.values().map(this::mapAnnotationValue))
-      is AnnotationValue.OfConstant -> valObj
+      is AnnotationValue.OfConstant -> {
+        if (valObj is AnnotationValue.OfString) {
+          val str = valObj.stringValue()
+          // mapLiterals=true enables the skipStringConstants check in each relocator.
+          val mapped = map(str, mapLiterals = true)
+          if (mapped != str) AnnotationValue.ofString(mapped) else valObj
+        } else {
+          valObj
+        }
+      }
       is AnnotationValue.OfClass -> AnnotationValue.ofClass(mapClassDesc(valObj.classSymbol())!!)
       is AnnotationValue.OfEnum ->
         AnnotationValue.ofEnum(
@@ -486,7 +529,7 @@ internal class RelocatorRemapper(
 
     for (relocator in relocators) {
       if (mapLiterals && relocator.skipStringConstants) {
-        return name
+        continue
       } else if (relocator.canRelocateClass(newName)) {
         return prefix + relocator.relocateClass(newName) + suffix
       } else if (relocator.canRelocatePath(newName)) {

src/main/kotlin/com/github/jengelman/gradle/plugins/shadow/tasks/ShadowCopyAction.kt

@@ -14,7 +14,6 @@ import com.github.jengelman.gradle.plugins.shadow.transformers.ResourceTransform
 import com.github.jengelman.gradle.plugins.shadow.transformers.TransformerContext
 import java.io.File
 import java.lang.classfile.ClassFile
-import java.lang.constant.ClassDesc
 import java.util.GregorianCalendar
 import java.util.zip.ZipException
 import kotlin.metadata.jvm.KmModule
@@ -212,14 +211,14 @@ constructor(
       file.readBytes().let { bytes ->
         var modified = false
         val multiReleasePrefix = "^META-INF/versions/\\d+/".toRegex().find(path)?.value.orEmpty()
-        val internalClassName = path.replace(multiReleasePrefix, "").removeSuffix(".class")
         val remapper = RelocatorRemapper(relocators) { modified = true }
 
         val newBytes =
           try {
             val classFile = ClassFile.of()
             val classModel = classFile.parse(bytes)
-            val newClassDesc = remapper.mapClassDesc(ClassDesc.ofInternalName(internalClassName))!!
+            val originalClassDesc = classModel.thisClass().asSymbol()
+            val newClassDesc = remapper.mapClassDesc(originalClassDesc)!!
             classFile.transformClass(classModel, newClassDesc, remapper.asClassTransform())
           } catch (t: Throwable) {
             throw GradleException("Error in Class-File API processing class $path", t)