From 1f1491f1cad778ed8a4ac78a9f6b7d6f54e09b05 Mon Sep 17 00:00:00 2001 From: Yan Zhulanow Date: Tue, 1 Nov 2016 21:59:13 +0300 Subject: [PATCH] Kapt3: Fix a number of errors in ClassFileToSourceStubConverter: 1. Support strictfp modifier for methods. 2. Support Kotlin top-level methods and properties. 3. Fix visibility modifiers on enum methods. --- .../stubs/ClassFileToSourceStubConverter.kt | 27 +-- ...ileToSourceStubConverterTestGenerated.java | 42 +++++ .../testData/converter/abstractMethods.kt | 9 + .../testData/converter/abstractMethods.txt | 28 ++++ .../kapt3/testData/converter/annotations2.kt | 33 ++++ plugins/kapt3/testData/converter/enums.kt | 3 + plugins/kapt3/testData/converter/enums.txt | 12 +- .../converter/genericRawSignatures.kt | 4 + .../converter/genericRawSignatures.txt | 14 ++ .../converter/jvmStaticFieldInParent.kt | 6 + .../converter/jvmStaticFieldInParent.txt | 23 +++ plugins/kapt3/testData/converter/modifiers.kt | 37 +++++ .../kapt3/testData/converter/modifiers.txt | 157 ++++++++++++++++++ .../kapt3/testData/converter/strangeNames.kt | 12 ++ .../kapt3/testData/converter/strangeNames.txt | 22 +++ plugins/kapt3/testData/converter/topLevel.kt | 21 +++ plugins/kapt3/testData/converter/topLevel.txt | 50 ++++++ 17 files changed, 487 insertions(+), 13 deletions(-) create mode 100644 plugins/kapt3/testData/converter/abstractMethods.kt create mode 100644 plugins/kapt3/testData/converter/abstractMethods.txt create mode 100644 plugins/kapt3/testData/converter/annotations2.kt create mode 100644 plugins/kapt3/testData/converter/genericRawSignatures.kt create mode 100644 plugins/kapt3/testData/converter/genericRawSignatures.txt create mode 100644 plugins/kapt3/testData/converter/jvmStaticFieldInParent.kt create mode 100644 plugins/kapt3/testData/converter/jvmStaticFieldInParent.txt create mode 100644 plugins/kapt3/testData/converter/modifiers.kt create mode 100644 plugins/kapt3/testData/converter/modifiers.txt create mode 100644 plugins/kapt3/testData/converter/strangeNames.kt create mode 100644 plugins/kapt3/testData/converter/strangeNames.txt create mode 100644 plugins/kapt3/testData/converter/topLevel.kt create mode 100644 plugins/kapt3/testData/converter/topLevel.txt diff --git a/plugins/kapt3/src/org/jetbrains/kotlin/kapt3/stubs/ClassFileToSourceStubConverter.kt b/plugins/kapt3/src/org/jetbrains/kotlin/kapt3/stubs/ClassFileToSourceStubConverter.kt index b4db25d95e6..315900de718 100644 --- a/plugins/kapt3/src/org/jetbrains/kotlin/kapt3/stubs/ClassFileToSourceStubConverter.kt +++ b/plugins/kapt3/src/org/jetbrains/kotlin/kapt3/stubs/ClassFileToSourceStubConverter.kt @@ -26,6 +26,7 @@ import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper import org.jetbrains.kotlin.descriptors.CallableDescriptor import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.ClassKind +import org.jetbrains.kotlin.descriptors.DeclarationDescriptor import org.jetbrains.kotlin.kapt3.* import org.jetbrains.kotlin.kapt3.javac.KaptTreeMaker import org.jetbrains.kotlin.kapt3.javac.KaptJavaFileObject @@ -48,7 +49,7 @@ class ClassFileToSourceStubConverter(val kaptContext: KaptContext, val typeMappe (Opcodes.ACC_DEPRECATED or Opcodes.ACC_INTERFACE or Opcodes.ACC_ANNOTATION or Opcodes.ACC_ENUM or Opcodes.ACC_STATIC).toLong() private val METHOD_MODIFIERS = VISIBILITY_MODIFIERS or MODALITY_MODIFIERS or - (Opcodes.ACC_DEPRECATED or Opcodes.ACC_SYNCHRONIZED or Opcodes.ACC_NATIVE or Opcodes.ACC_STATIC).toLong() + (Opcodes.ACC_DEPRECATED or Opcodes.ACC_SYNCHRONIZED or Opcodes.ACC_NATIVE or Opcodes.ACC_STATIC or Opcodes.ACC_STRICT).toLong() private val FIELD_MODIFIERS = VISIBILITY_MODIFIERS or MODALITY_MODIFIERS or (Opcodes.ACC_VOLATILE or Opcodes.ACC_TRANSIENT or Opcodes.ACC_ENUM or Opcodes.ACC_STATIC).toLong() @@ -78,12 +79,11 @@ class ClassFileToSourceStubConverter(val kaptContext: KaptContext, val typeMappe private fun convertTopLevelClass(clazz: ClassNode): JCCompilationUnit? { val origin = kaptContext.origins[clazz] ?: return null - // ? val ktFile = origin.element?.containingFile as? KtFile ?: return null - val descriptor = origin.descriptor as? ClassDescriptor ?: return null + val descriptor = origin.descriptor as? DeclarationDescriptor ?: return null // Nested classes will be processed during the outer classes conversion - if (descriptor.isNested) return null + if ((descriptor as? ClassDescriptor)?.isNested ?: false) return null val classDeclaration = convertClass(clazz) ?: return null @@ -106,9 +106,12 @@ class ClassFileToSourceStubConverter(val kaptContext: KaptContext, val typeMappe private fun convertClass(clazz: ClassNode): JCClassDecl? { if (isSynthetic(clazz.access)) return null - val descriptor = kaptContext.origins[clazz]?.descriptor as? ClassDescriptor ?: return null + val descriptor = kaptContext.origins[clazz]?.descriptor as? DeclarationDescriptor ?: return null + val isNested = (descriptor as? ClassDescriptor)?.isNested ?: false + val isInner = isNested && (descriptor as? ClassDescriptor)?.isInner ?: false + val modifiers = convertModifiers( - if (!descriptor.isInner && descriptor.isNested) (clazz.access or Opcodes.ACC_STATIC) else clazz.access, + if (!isInner && isNested) (clazz.access or Opcodes.ACC_STATIC) else clazz.access, ElementKind.CLASS, clazz.visibleAnnotations, clazz.invisibleAnnotations) val isEnum = clazz.isEnum() @@ -116,6 +119,7 @@ class ClassFileToSourceStubConverter(val kaptContext: KaptContext, val typeMappe val isDefaultImpls = clazz.name.endsWith("${descriptor.name.asString()}/DefaultImpls") && isPublic(clazz.access) && isFinal(clazz.access) + && descriptor is ClassDescriptor && descriptor.kind == ClassKind.INTERFACE // DefaultImpls without any contents don't have INNERCLASS'es inside it (and inside the parent interface) @@ -195,13 +199,16 @@ class ClassFileToSourceStubConverter(val kaptContext: KaptContext, val typeMappe method.visibleAnnotations } - val modifiers = convertModifiers( - if (containingClass.isEnum()) (method.access.toLong() and VISIBILITY_MODIFIERS.inv()) else method.access.toLong(), - ElementKind.METHOD, visibleAnnotations, method.invisibleAnnotations) - val isConstructor = method.name == "" val name = treeMaker.name(method.name) + val modifiers = convertModifiers( + if (containingClass.isEnum() && isConstructor) + (method.access.toLong() and VISIBILITY_MODIFIERS.inv()) + else + method.access.toLong(), + ElementKind.METHOD, visibleAnnotations, method.invisibleAnnotations) + val returnType = Type.getReturnType(method.desc) val jcReturnType = if (isConstructor) null else treeMaker.Type(returnType) diff --git a/plugins/kapt3/test/org/jetbrains/kotlin/kapt3/test/ClassFileToSourceStubConverterTestGenerated.java b/plugins/kapt3/test/org/jetbrains/kotlin/kapt3/test/ClassFileToSourceStubConverterTestGenerated.java index 3eb848abb11..aef494ebd46 100644 --- a/plugins/kapt3/test/org/jetbrains/kotlin/kapt3/test/ClassFileToSourceStubConverterTestGenerated.java +++ b/plugins/kapt3/test/org/jetbrains/kotlin/kapt3/test/ClassFileToSourceStubConverterTestGenerated.java @@ -31,6 +31,12 @@ import java.util.regex.Pattern; @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) public class ClassFileToSourceStubConverterTestGenerated extends AbstractClassFileToSourceStubConverterTest { + @TestMetadata("abstractMethods.kt") + public void testAbstractMethods() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("plugins/kapt3/testData/converter/abstractMethods.kt"); + doTest(fileName); + } + public void testAllFilesPresentInConverter() throws Exception { KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("plugins/kapt3/testData/converter"), Pattern.compile("^(.+)\\.kt$"), true); } @@ -41,6 +47,12 @@ public class ClassFileToSourceStubConverterTestGenerated extends AbstractClassFi doTest(fileName); } + @TestMetadata("annotations2.kt") + public void testAnnotations2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("plugins/kapt3/testData/converter/annotations2.kt"); + doTest(fileName); + } + @TestMetadata("dataClass.kt") public void testDataClass() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("plugins/kapt3/testData/converter/dataClass.kt"); @@ -65,6 +77,12 @@ public class ClassFileToSourceStubConverterTestGenerated extends AbstractClassFi doTest(fileName); } + @TestMetadata("genericRawSignatures.kt") + public void testGenericRawSignatures() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("plugins/kapt3/testData/converter/genericRawSignatures.kt"); + doTest(fileName); + } + @TestMetadata("genericSimple.kt") public void testGenericSimple() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("plugins/kapt3/testData/converter/genericSimple.kt"); @@ -83,9 +101,33 @@ public class ClassFileToSourceStubConverterTestGenerated extends AbstractClassFi doTest(fileName); } + @TestMetadata("jvmStaticFieldInParent.kt") + public void testJvmStaticFieldInParent() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("plugins/kapt3/testData/converter/jvmStaticFieldInParent.kt"); + doTest(fileName); + } + + @TestMetadata("modifiers.kt") + public void testModifiers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("plugins/kapt3/testData/converter/modifiers.kt"); + doTest(fileName); + } + @TestMetadata("nestedClasses.kt") public void testNestedClasses() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("plugins/kapt3/testData/converter/nestedClasses.kt"); doTest(fileName); } + + @TestMetadata("strangeNames.kt") + public void testStrangeNames() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("plugins/kapt3/testData/converter/strangeNames.kt"); + doTest(fileName); + } + + @TestMetadata("topLevel.kt") + public void testTopLevel() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("plugins/kapt3/testData/converter/topLevel.kt"); + doTest(fileName); + } } diff --git a/plugins/kapt3/testData/converter/abstractMethods.kt b/plugins/kapt3/testData/converter/abstractMethods.kt new file mode 100644 index 00000000000..33b46cd2540 --- /dev/null +++ b/plugins/kapt3/testData/converter/abstractMethods.kt @@ -0,0 +1,9 @@ +abstract class Base { + protected abstract fun doJob(job: String, delay: Int) + protected abstract fun doJobGeneric(job: T, delay: Int) +} + +class Impl : Base() { + override fun doJob(job: String, delay: Int) {} + override fun doJobGeneric(job: T, delay: Int) {} +} \ No newline at end of file diff --git a/plugins/kapt3/testData/converter/abstractMethods.txt b/plugins/kapt3/testData/converter/abstractMethods.txt new file mode 100644 index 00000000000..483076b9ec8 --- /dev/null +++ b/plugins/kapt3/testData/converter/abstractMethods.txt @@ -0,0 +1,28 @@ +public abstract class Base { + + protected abstract void doJob(java.lang.String job, int delay); + + protected abstract void doJobGeneric(T job, int delay); + + public Base() { + super(); + } +} + +//////////////////// + + +public final class Impl extends Base { + + @java.lang.Override() + protected void doJob(java.lang.String job, int delay) { + } + + @java.lang.Override() + protected void doJobGeneric(T job, int delay) { + } + + public Impl() { + super(); + } +} diff --git a/plugins/kapt3/testData/converter/annotations2.kt b/plugins/kapt3/testData/converter/annotations2.kt new file mode 100644 index 00000000000..2d65d65529f --- /dev/null +++ b/plugins/kapt3/testData/converter/annotations2.kt @@ -0,0 +1,33 @@ +@file:kotlin.jvm.JvmName("AnnotationsTest") +package test + +@Anno("anno-class") +annotation class Anno @Anno("anno-constructor") constructor( + @Anno("anno-value") val value: String, + val anno: Anno = Anno("anno-default") +) + +@Anno("clazz") +abstract class Test @Anno("test-constructor") protected constructor(@param:Anno("v-param") + @setparam:Anno("v-setparam") + @property:Anno("v-property") + @get:Anno("v-get") + @set:Anno("v-set") var v: String) { + @Anno("abstract-method") + abstract fun abstractMethod(): String + + @Anno("abstract-val") + abstract val abstractVal: String +} + +@Anno("top-level-fun") +fun @receiver:Anno("top-level-fun-receiver") String.topLevelFun() {} + +@Anno("top-level-val") +val @receiver:Anno("top-level-val-receiver") Int.topLevelVal: String + get() = "" + +@Anno("enum") +enum class Enum @Anno("enum-constructor") constructor(@Anno("x") val x: Int) { + @Anno("white") WHITE(1), @Anno("black") BLACK(2) +} \ No newline at end of file diff --git a/plugins/kapt3/testData/converter/enums.kt b/plugins/kapt3/testData/converter/enums.kt index eeb62a8638a..b2d01fe8eee 100644 --- a/plugins/kapt3/testData/converter/enums.kt +++ b/plugins/kapt3/testData/converter/enums.kt @@ -7,4 +7,7 @@ annotation class Anno1(val value: String) enum class Enum2(@Anno1("first") val col: String, @Anno1("second") val col2: Int) { RED("red", 1), WHITE("white", 2); fun color() = col + + private fun privateEnumFun() {} + public fun publicEnumFun() {} } \ No newline at end of file diff --git a/plugins/kapt3/testData/converter/enums.txt b/plugins/kapt3/testData/converter/enums.txt index 8b229e323a6..94bc81c4864 100644 --- a/plugins/kapt3/testData/converter/enums.txt +++ b/plugins/kapt3/testData/converter/enums.txt @@ -23,15 +23,21 @@ public enum Enum2 { private final java.lang.String col = null; private final int col2 = 0; - final java.lang.String color() { + public final java.lang.String color() { return null; } - final java.lang.String getCol() { + private final void privateEnumFun() { + } + + public final void publicEnumFun() { + } + + public final java.lang.String getCol() { return null; } - final int getCol2() { + public final int getCol2() { return 0; } diff --git a/plugins/kapt3/testData/converter/genericRawSignatures.kt b/plugins/kapt3/testData/converter/genericRawSignatures.kt new file mode 100644 index 00000000000..69aded054bb --- /dev/null +++ b/plugins/kapt3/testData/converter/genericRawSignatures.kt @@ -0,0 +1,4 @@ +class GenericRawSignatures { + fun genericFun(): T? = null + fun nonGenericFun(): String? = null +} \ No newline at end of file diff --git a/plugins/kapt3/testData/converter/genericRawSignatures.txt b/plugins/kapt3/testData/converter/genericRawSignatures.txt new file mode 100644 index 00000000000..c87e672d074 --- /dev/null +++ b/plugins/kapt3/testData/converter/genericRawSignatures.txt @@ -0,0 +1,14 @@ +public final class GenericRawSignatures { + + public final T genericFun() { + return null; + } + + public final java.lang.String nonGenericFun() { + return null; + } + + public GenericRawSignatures() { + super(); + } +} diff --git a/plugins/kapt3/testData/converter/jvmStaticFieldInParent.kt b/plugins/kapt3/testData/converter/jvmStaticFieldInParent.kt new file mode 100644 index 00000000000..8a4835138c9 --- /dev/null +++ b/plugins/kapt3/testData/converter/jvmStaticFieldInParent.kt @@ -0,0 +1,6 @@ +class Test { + companion object A { + @JvmStatic + val test: String = "" + } +} \ No newline at end of file diff --git a/plugins/kapt3/testData/converter/jvmStaticFieldInParent.txt b/plugins/kapt3/testData/converter/jvmStaticFieldInParent.txt new file mode 100644 index 00000000000..0396e053a98 --- /dev/null +++ b/plugins/kapt3/testData/converter/jvmStaticFieldInParent.txt @@ -0,0 +1,23 @@ +public final class Test { + private static final java.lang.String test = ""; + public static final Test.A A = null; + + public Test() { + super(); + } + + public static final java.lang.String getTest() { + return null; + } + + public static final class A { + + public final java.lang.String getTest() { + return null; + } + + private A() { + super(); + } + } +} diff --git a/plugins/kapt3/testData/converter/modifiers.kt b/plugins/kapt3/testData/converter/modifiers.kt new file mode 100644 index 00000000000..f56c9a979c5 --- /dev/null +++ b/plugins/kapt3/testData/converter/modifiers.kt @@ -0,0 +1,37 @@ +package modifiers + +public class PublicClass public constructor() + +public open class PublicClassProtectedConstructor protected constructor() { + protected interface ProtectedInterface + private interface PrivateInterface +} + +public abstract class PublicClassPrivateConstructor private constructor() +internal class InternalClass +private class PrivateClass + +public interface PublicInterface +internal interface InternalInterface +private interface PrivateInterface + +sealed class SealedClass { + class One : SealedClass() + open class Two : SealedClass() + abstract class Three : Two() + final class Four : Three() +} + +class Modifiers { + @Transient + val transientField: String = "" + + @Volatile + var volatileField: String = "" + + @Strictfp + fun strictFp() {} + + @JvmOverloads + fun overloads(a: String = "", n: Int = 5): String = null!! +} \ No newline at end of file diff --git a/plugins/kapt3/testData/converter/modifiers.txt b/plugins/kapt3/testData/converter/modifiers.txt new file mode 100644 index 00000000000..4e9edb4d941 --- /dev/null +++ b/plugins/kapt3/testData/converter/modifiers.txt @@ -0,0 +1,157 @@ +package modifiers; + +public final class PublicClass { + + public PublicClass() { + super(); + } +} + +//////////////////// + +package modifiers; + +public class PublicClassProtectedConstructor { + + protected PublicClassProtectedConstructor() { + super(); + } + + protected static abstract interface ProtectedInterface { + } + + private static abstract interface PrivateInterface { + } +} + +//////////////////// + +package modifiers; + +public abstract class PublicClassPrivateConstructor { + + private PublicClassPrivateConstructor() { + super(); + } +} + +//////////////////// + +package modifiers; + +public final class InternalClass { + + public InternalClass() { + super(); + } +} + +//////////////////// + +package modifiers; + +final class PrivateClass { + + public PrivateClass() { + super(); + } +} + +//////////////////// + +package modifiers; + +public abstract interface PublicInterface { +} + +//////////////////// + +package modifiers; + +public abstract interface InternalInterface { +} + +//////////////////// + +package modifiers; + +abstract interface PrivateInterface { +} + +//////////////////// + +package modifiers; + +public abstract class SealedClass { + + private SealedClass() { + super(); + } + + public static final class One extends modifiers.SealedClass { + + public One() { + super(); + } + } + + public static class Two extends modifiers.SealedClass { + + public Two() { + super(); + } + } + + public static abstract class Three extends modifiers.SealedClass.Two { + + public Three() { + super(); + } + } + + public static final class Four extends modifiers.SealedClass.Three { + + public Four() { + super(); + } + } +} + +//////////////////// + +package modifiers; + +public final class Modifiers { + private final transient java.lang.String transientField = ""; + private volatile java.lang.String volatileField; + + public final java.lang.String getTransientField() { + return null; + } + + public final java.lang.String getVolatileField() { + return null; + } + + public final void setVolatileField(java.lang.String p0) { + } + + public final strictfp void strictFp() { + } + + public final java.lang.String overloads(java.lang.String a, int n) { + return null; + } + + public final java.lang.String overloads(java.lang.String p0) { + return null; + } + + public final java.lang.String overloads() { + return null; + } + + public Modifiers() { + super(); + } +} diff --git a/plugins/kapt3/testData/converter/strangeNames.kt b/plugins/kapt3/testData/converter/strangeNames.kt new file mode 100644 index 00000000000..4d9eb6f5b5f --- /dev/null +++ b/plugins/kapt3/testData/converter/strangeNames.kt @@ -0,0 +1,12 @@ +class `My $ name` { + fun `(^_^)`(`)))))`: Int) {} + + // unicode symbol • + val `(@•@)`: String = "" + + // russian + val `Котлин-компилятор`: String = "" + + // japanese hiragana + fun `こ　と　り　ん！`() {} +} \ No newline at end of file diff --git a/plugins/kapt3/testData/converter/strangeNames.txt b/plugins/kapt3/testData/converter/strangeNames.txt new file mode 100644 index 00000000000..6925365aaef --- /dev/null +++ b/plugins/kapt3/testData/converter/strangeNames.txt @@ -0,0 +1,22 @@ +public final class My $ name { + private final java.lang.String (@\u2022@) = ""; + private final java.lang.String \u041a\u043e\u0442\u043b\u0438\u043d-\u043a\u043e\u043c\u043f\u0438\u043b\u044f\u0442\u043e\u0440 = ""; + + public final void (^_^)(int )))))) { + } + + public final java.lang.String get(@\u2022@)() { + return null; + } + + public final java.lang.String get\u041a\u043e\u0442\u043b\u0438\u043d-\u043a\u043e\u043c\u043f\u0438\u043b\u044f\u0442\u043e\u0440() { + return null; + } + + public final void \u3053\u3000\u3068\u3000\u308a\u3000\u3093\uff01() { + } + + public My $ name() { + super(); + } +} diff --git a/plugins/kapt3/testData/converter/topLevel.kt b/plugins/kapt3/testData/converter/topLevel.kt new file mode 100644 index 00000000000..cc8c37b980b --- /dev/null +++ b/plugins/kapt3/testData/converter/topLevel.kt @@ -0,0 +1,21 @@ +package test.another + +annotation class Anno(val value: String) + +fun topLevelFunction(): String? = null + +fun > topLevelGenericFunction(): T? { + return null!! +} + +val topLevelProperty = 2 + +val topLevelProperty2: String + get() = "" + +fun @receiver:Anno("rec") String.extensionFunction(@Anno("1") a: String, @Anno("2") b: String) {} + +@Anno("extpr") +var @receiver:Anno("propRec") T.extensionProperty: String + get() = "" + set(@Anno("setparam") setParamName) {} \ No newline at end of file diff --git a/plugins/kapt3/testData/converter/topLevel.txt b/plugins/kapt3/testData/converter/topLevel.txt new file mode 100644 index 00000000000..b913a60ccfa --- /dev/null +++ b/plugins/kapt3/testData/converter/topLevel.txt @@ -0,0 +1,50 @@ +package test.another; + +public abstract @interface Anno { + + public abstract java.lang.String value(); +} + +//////////////////// + +package test.another; + +public final class another { + + public another() { + super(); + } + private static final int topLevelProperty = 2; + + public static final java.lang.String topLevelFunction() { + return null; + } + + public static final >T topLevelGenericFunction() { + return null; + } + + public static final int getTopLevelProperty() { + return 0; + } + + public static final java.lang.String getTopLevelProperty2() { + return null; + } + + public static final void extensionFunction(@test.another.Anno(value = "rec") + java.lang.String $receiver, @test.another.Anno(value = "1") + java.lang.String a, @test.another.Anno(value = "2") + java.lang.String b) { + } + + public static final java.lang.String getExtensionProperty(@test.another.Anno(value = "propRec") + T $receiver) { + return null; + } + + public static final void setExtensionProperty(@test.another.Anno(value = "propRec") + T $receiver, @test.another.Anno(value = "setparam") + java.lang.String setParamName) { + } +}