diff --git a/plugins/kapt3/kapt3-compiler/src/org/jetbrains/kotlin/kapt3/KaptContext.kt b/plugins/kapt3/kapt3-compiler/src/org/jetbrains/kotlin/kapt3/KaptContext.kt index 65e7590661e..7dd8d8b7991 100644 --- a/plugins/kapt3/kapt3-compiler/src/org/jetbrains/kotlin/kapt3/KaptContext.kt +++ b/plugins/kapt3/kapt3-compiler/src/org/jetbrains/kotlin/kapt3/KaptContext.kt @@ -50,7 +50,7 @@ class KaptContext( val javaLog: KaptJavaLog init { - KaptJavaLog.preRegister(context, logger.messageCollector) + KaptJavaLog.preRegister(this, logger.messageCollector) JavacFileManager.preRegister(context) KaptTreeMaker.preRegister(context, this) KaptJavaCompiler.preRegister(context) diff --git a/plugins/kapt3/kapt3-compiler/src/org/jetbrains/kotlin/kapt3/javac/KaptJavaLog.kt b/plugins/kapt3/kapt3-compiler/src/org/jetbrains/kotlin/kapt3/javac/KaptJavaLog.kt index ed6d46d9c5f..b3fc13a8b5c 100644 --- a/plugins/kapt3/kapt3-compiler/src/org/jetbrains/kotlin/kapt3/javac/KaptJavaLog.kt +++ b/plugins/kapt3/kapt3-compiler/src/org/jetbrains/kotlin/kapt3/javac/KaptJavaLog.kt @@ -16,24 +16,36 @@ package org.jetbrains.kotlin.kapt3.javac +import com.intellij.openapi.project.Project import com.intellij.psi.PsiElement import com.sun.tools.javac.tree.JCTree import com.sun.tools.javac.util.* +import com.sun.tools.javac.util.JCDiagnostic.DiagnosticType import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.* import org.jetbrains.kotlin.cli.common.messages.MessageCollector import org.jetbrains.kotlin.kapt3.KaptContext +import org.jetbrains.kotlin.kapt3.stubs.KaptStubLineInformation +import org.jetbrains.kotlin.kapt3.stubs.KotlinPosition import org.jetbrains.kotlin.kapt3.util.MessageCollectorBackedWriter +import java.io.File import java.io.PrintWriter import javax.tools.JavaFileObject +import com.sun.tools.javac.util.List as JavacList class KaptJavaLog( + private val project: Project, context: Context, errWriter: PrintWriter, warnWriter: PrintWriter, noticeWriter: PrintWriter, val interceptorData: DiagnosticInterceptorData ) : Log(context, errWriter, warnWriter, noticeWriter) { + private val stubLineInfo = KaptStubLineInformation() + + private val diagnosticFactory by lazy { JCDiagnostic.Factory.instance(context) } + private val javacMessages by lazy { JavacMessages.instance(context) } + init { context.put(Log.outKey, noticeWriter) } @@ -75,8 +87,9 @@ class KaptJavaLog( } val targetElement = diagnostic.diagnosticPosition + val sourceFile = interceptorData.files[diagnostic.source] + if (diagnostic.code.contains("err.cant.resolve") && targetElement != null) { - val sourceFile = interceptorData.files[diagnostic.source] if (sourceFile != null) { val insideImports = targetElement.tree in sourceFile.imports // Ignore resolve errors in import statements @@ -84,10 +97,64 @@ class KaptJavaLog( } } + if (sourceFile != null && targetElement.tree != null) { + val kotlinPosition = stubLineInfo.getPositionInKotlinFile(sourceFile, targetElement.tree) + val kotlinFile = kotlinPosition?.let { getKotlinSourceFile(it) } + if (kotlinPosition != null && kotlinFile != null) { + val locationMessage = "$KOTLIN_LOCATION_PREFIX${kotlinFile.absolutePath}: (${kotlinPosition.line}, ${kotlinPosition.column})" + val locationDiagnostic = diagnosticFactory.note("proc.messager", locationMessage) + val wrappedDiagnostic = JCDiagnostic.MultilineDiagnostic(diagnostic, JavacList.of(locationDiagnostic)) + + super.report(wrappedDiagnostic) + _reportedDiagnostics += wrappedDiagnostic + + // Avoid reporting the diagnostic twice + return + } + } + _reportedDiagnostics += diagnostic + super.report(diagnostic) } + override fun writeDiagnostic(diagnostic: JCDiagnostic) { + if (hasDiagnosticListener()) { + diagListener.report(diagnostic) + return + } + + val writer = when (diagnostic.type) { + DiagnosticType.FRAGMENT, null -> kotlin.error("Invalid root diagnostic type: ${diagnostic.type}") + DiagnosticType.NOTE -> super.noticeWriter + DiagnosticType.WARNING -> super.warnWriter + DiagnosticType.ERROR -> super.errWriter + } + + val formattedMessage = diagnosticFormatter.format(diagnostic, javacMessages.currentLocale) + .lines() + .joinToString(LINE_SEPARATOR) { original -> + // Kotlin location is put as a sub-diagnostic, so the formatter indents it with four additional spaces (6 in total). + // It looks weird, especially in the build log inside IntelliJ, so let's make things a bit better. + val trimmed = original.trimStart() + // Typically, javac places additional details about the diagnostics indented by two spaces + if (trimmed.startsWith(KOTLIN_LOCATION_PREFIX)) " " + trimmed else original + } + + writer.print(formattedMessage) + writer.flush() + } + + private fun getKotlinSourceFile(pos: KotlinPosition): File? { + return if (pos.isRelativePath) { + val basePath = project.basePath + if (basePath != null) File(basePath, pos.path) else null + } + else { + File(pos.path) + } + } + private operator fun Iterable.contains(element: JCTree?): Boolean { if (element == null) { return false @@ -114,6 +181,9 @@ class KaptJavaLog( } companion object { + private val LINE_SEPARATOR: String = System.getProperty("line.separator") + private val KOTLIN_LOCATION_PREFIX = "Kotlin location: " + private val IGNORED_DIAGNOSTICS = setOf( "compiler.err.name.clash.same.erasure", "compiler.err.name.clash.same.erasure.no.override", @@ -123,14 +193,14 @@ class KaptJavaLog( "compiler.err.annotation.type.not.applicable", "compiler.err.doesnt.exist") - internal fun preRegister(context: Context, messageCollector: MessageCollector) { + internal fun preRegister(kaptContext: KaptContext<*>, messageCollector: MessageCollector) { val interceptorData = DiagnosticInterceptorData() - context.put(Log.logKey, Context.Factory { + kaptContext.context.put(Log.logKey, Context.Factory { newContext -> fun makeWriter(severity: CompilerMessageSeverity) = PrintWriter(MessageCollectorBackedWriter(messageCollector, severity)) val errWriter = makeWriter(ERROR) val warnWriter = makeWriter(STRONG_WARNING) val noticeWriter = makeWriter(WARNING) - KaptJavaLog(it, errWriter, warnWriter, noticeWriter, interceptorData) + KaptJavaLog(kaptContext.project, newContext, errWriter, warnWriter, noticeWriter, interceptorData) }) } } diff --git a/plugins/kapt3/kapt3-compiler/src/org/jetbrains/kotlin/kapt3/stubs/ClassFileToSourceStubConverter.kt b/plugins/kapt3/kapt3-compiler/src/org/jetbrains/kotlin/kapt3/stubs/ClassFileToSourceStubConverter.kt index 7917fdf2601..dfd8d5e2079 100644 --- a/plugins/kapt3/kapt3-compiler/src/org/jetbrains/kotlin/kapt3/stubs/ClassFileToSourceStubConverter.kt +++ b/plugins/kapt3/kapt3-compiler/src/org/jetbrains/kotlin/kapt3/stubs/ClassFileToSourceStubConverter.kt @@ -50,6 +50,8 @@ import org.jetbrains.org.objectweb.asm.Type import org.jetbrains.org.objectweb.asm.tree.* import javax.lang.model.element.ElementKind import com.sun.tools.javac.util.List as JavacList +import org.jetbrains.kotlin.kapt3.stubs.KaptLineMappingCollector.Companion.KAPT_METADATA_ANNOTATION_FQNAME +import org.jetbrains.kotlin.kapt3.stubs.KaptLineMappingCollector.Companion.KAPT_SIGNATURE_ANNOTATION_FQNAME class ClassFileToSourceStubConverter( val kaptContext: KaptContext, @@ -108,6 +110,9 @@ class ClassFileToSourceStubConverter( stubs = stubs.append(generateNonExistentClass()) } + stubs = stubs.append(generateSimpleParametrizedAnnotationClass(KAPT_METADATA_ANNOTATION_FQNAME)) + stubs = stubs.append(generateSimpleParametrizedAnnotationClass(KAPT_SIGNATURE_ANNOTATION_FQNAME)) + return stubs } @@ -128,6 +133,31 @@ class ClassFileToSourceStubConverter( return topLevel } + private fun generateSimpleParametrizedAnnotationClass(fqName: FqName): JCCompilationUnit { + val valueMethod = treeMaker.MethodDef( + treeMaker.Modifiers(Flags.PUBLIC.toLong()), + treeMaker.name("value"), + treeMaker.FqName("java.lang.String"), + JavacList.nil(), + JavacList.nil(), + JavacList.nil(), + null, + null) + + val nonExistentClass = treeMaker.ClassDef( + treeMaker.Modifiers((Flags.PUBLIC or Flags.ANNOTATION or Flags.INTERFACE).toLong()), + treeMaker.name(fqName.shortName().asString()), + JavacList.nil(), + null, + JavacList.nil(), + JavacList.of(valueMethod)) + + val packageName = fqName.parent().asString() + val topLevel = treeMaker.TopLevelJava9Aware(treeMaker.FqName(packageName), JavacList.of(nonExistentClass)) + topLevel.sourcefile = KaptJavaFileObject(topLevel, nonExistentClass) + return topLevel + } + private fun convertTopLevelClass(clazz: ClassNode): JCCompilationUnit? { val origin = kaptContext.origins[clazz] ?: return null val ktFile = origin.element?.containingFile as? KtFile ?: return null @@ -136,10 +166,15 @@ class ClassFileToSourceStubConverter( // Nested classes will be processed during the outer classes conversion if ((descriptor as? ClassDescriptor)?.isNested ?: false) return null + val lineMappings = KaptLineMappingCollector(kaptContext) + val packageName = ktFile.packageFqName.asString() val packageClause = if (packageName.isEmpty()) null else treeMaker.FqName(packageName) - val classDeclaration = convertClass(clazz, packageName, true) ?: return null + val classDeclaration = convertClass(clazz, lineMappings, packageName, true) ?: return null + + classDeclaration.mods.annotations = classDeclaration.mods.annotations.append( + createAnnotation(KAPT_METADATA_ANNOTATION_FQNAME, lineMappings.serializeLineInfo ())) val imports = if (correctErrorTypes) convertImports(ktFile, classDeclaration) else JavacList.nil() val classes = JavacList.of(classDeclaration) @@ -154,6 +189,11 @@ class ClassFileToSourceStubConverter( return topLevel } + private fun createAnnotation(fqName: FqName, value: String): JCAnnotation { + val offsetsLiteral = convertLiteralExpression(value) + return treeMaker.Annotation(treeMaker.FqName(fqName), JavacList.of(offsetsLiteral)) + } + private fun convertImports(file: KtFile, classDeclaration: JCClassDecl): JavacList { val imports = mutableListOf() @@ -195,7 +235,12 @@ class ClassFileToSourceStubConverter( /** * Returns false for the inner classes or if the origin for the class was not found. */ - private fun convertClass(clazz: ClassNode, packageFqName: String, isTopLevel: Boolean): JCClassDecl? { + private fun convertClass( + clazz: ClassNode, + lineMappings: KaptLineMappingCollector, + packageFqName: String, + isTopLevel: Boolean + ): JCClassDecl? { if (isSynthetic(clazz.access)) return null if (checkIfShouldBeIgnored(Type.getObjectType(clazz.name))) return null @@ -264,9 +309,9 @@ class ClassFileToSourceStubConverter( val args = mapJList(constructorArguments.drop(2)) { convertLiteralExpression(getDefaultValue(it)) } - val def = data.correspondingClass?.let { convertClass(it, packageFqName, false) } + val def = data.correspondingClass?.let { convertClass(it, lineMappings, packageFqName, false) } - convertField(data.field, packageFqName, treeMaker.NewClass( + convertField(data.field, clazz, lineMappings, packageFqName, treeMaker.NewClass( /* enclosing = */ null, /* typeArgs = */ JavacList.nil(), /* clazz = */ treeMaker.Ident(treeMaker.name(data.field.name)), @@ -275,7 +320,7 @@ class ClassFileToSourceStubConverter( } val fields = mapJList(clazz.fields) { - if (it.isEnumValue()) null else convertField(it, packageFqName) + if (it.isEnumValue()) null else convertField(it, clazz, lineMappings, packageFqName) } val methods = mapJList(clazz.methods) { @@ -284,16 +329,18 @@ class ClassFileToSourceStubConverter( if (it.name == "valueOf" && it.desc == "(Ljava/lang/String;)L${clazz.name};") return@mapJList null } - convertMethod(it, clazz, packageFqName) + convertMethod(it, clazz, lineMappings, packageFqName) } val nestedClasses = mapJList(clazz.innerClasses) { innerClass -> if (enumValuesData.any { it.innerClass == innerClass }) return@mapJList null if (innerClass.outerName != clazz.name) return@mapJList null val innerClassNode = kaptContext.compiledClasses.firstOrNull { it.name == innerClass.name } ?: return@mapJList null - convertClass(innerClassNode, packageFqName, false) + convertClass(innerClassNode, lineMappings, packageFqName, false) } + lineMappings.registerClass(clazz) + return treeMaker.ClassDef( modifiers, treeMaker.name(simpleName), @@ -361,6 +408,8 @@ class ClassFileToSourceStubConverter( private fun convertField( field: FieldNode, + containingClass: ClassNode, + lineMappings: KaptLineMappingCollector, packageFqName: String, explicitInitializer: JCExpression? = null ): JCVariableDecl? { @@ -397,10 +446,17 @@ class ClassFileToSourceStubConverter( ?: convertValueOfPrimitiveTypeOrString(value) ?: if (isFinal(field.access)) convertLiteralExpression(getDefaultValue(type)) else null + lineMappings.registerField(containingClass, field) + return treeMaker.VarDef(modifiers, treeMaker.name(name), typeExpression, initializer) } - private fun convertMethod(method: MethodNode, containingClass: ClassNode, packageFqName: String): JCMethodDecl? { + private fun convertMethod( + method: MethodNode, + containingClass: ClassNode, + lineMappings: KaptLineMappingCollector, + packageFqName: String + ): JCMethodDecl? { if (isIgnored(method.invisibleAnnotations)) return null val descriptor = kaptContext.origins[method]?.descriptor as? CallableDescriptor ?: return null @@ -428,6 +484,9 @@ class ClassFileToSourceStubConverter( method.access.toLong(), ElementKind.METHOD, packageFqName, visibleAnnotations, method.invisibleAnnotations, descriptor.annotations) + modifiers.annotations = modifiers.annotations.append( + createAnnotation(KAPT_SIGNATURE_ANNOTATION_FQNAME, method.name + method.desc)) + val asmReturnType = Type.getReturnType(method.desc) val jcReturnType = if (isConstructor) null else treeMaker.Type(asmReturnType) @@ -494,6 +553,8 @@ class ClassFileToSourceStubConverter( treeMaker.Block(0, JavacList.of(returnStatement)) } + lineMappings.registerMethod(containingClass, method) + return treeMaker.MethodDef( modifiers, treeMaker.name(name), returnType, genericSignature.typeParameters, genericSignature.parameterTypes, genericSignature.exceptionTypes, @@ -820,4 +881,21 @@ private fun Any?.isOfPrimiviteType(): Boolean = when(this) { } private val ClassDescriptor.isNested: Boolean - get() = containingDeclaration is ClassDescriptor \ No newline at end of file + get() = containingDeclaration is ClassDescriptor + +internal fun getAnnotationValue(fqName: FqName, mods: JCTree.JCModifiers?): String? { + val annotations = mods?.annotations ?: return null + + val annotationName = fqName.asString() + val annotation = annotations.firstOrNull { it.annotationType.toString() == annotationName } ?: return null + + val valueArg = annotation.args.singleOrNull() + + return when (valueArg) { + is JCTree.JCLiteral -> valueArg.value as? String + is JCTree.JCAssign -> { + ((valueArg.rhs as? JCTree.JCLiteral)?.value as? String)?.takeIf { valueArg.lhs.toString() == "value" } + } + else -> null + } +} diff --git a/plugins/kapt3/kapt3-compiler/src/org/jetbrains/kotlin/kapt3/stubs/KaptLineMappingCollector.kt b/plugins/kapt3/kapt3-compiler/src/org/jetbrains/kotlin/kapt3/stubs/KaptLineMappingCollector.kt new file mode 100644 index 00000000000..61bd2121353 --- /dev/null +++ b/plugins/kapt3/kapt3-compiler/src/org/jetbrains/kotlin/kapt3/stubs/KaptLineMappingCollector.kt @@ -0,0 +1,141 @@ +/* + * Copyright 2010-2017 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.kapt3.stubs + +import com.intellij.psi.PsiElement +import com.intellij.psi.PsiFile +import com.sun.tools.javac.tree.JCTree +import org.jetbrains.kotlin.diagnostics.DiagnosticUtils +import org.jetbrains.kotlin.kapt3.KaptContext +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.org.objectweb.asm.tree.ClassNode +import org.jetbrains.org.objectweb.asm.tree.FieldNode +import org.jetbrains.org.objectweb.asm.tree.MethodNode +import java.io.* +import java.util.* + +data class KotlinPosition(val path: String, val isRelativePath: Boolean, val line: Int, val column: Int) + +private typealias LineInfoMap = MutableMap + +class KaptLineMappingCollector(private val kaptContext: KaptContext<*>) { + companion object { + val KAPT_METADATA_ANNOTATION_FQNAME = FqName("kapt.internal.KaptMetadata") + val KAPT_SIGNATURE_ANNOTATION_FQNAME = FqName("kapt.internal.KaptSignature") + + fun parseMetadataAnnotation(file: JCTree.JCCompilationUnit): LineInfo { + val metadata = file.defs.asSequence() + .filterIsInstance() + .mapNotNull { getAnnotationValue(KAPT_METADATA_ANNOTATION_FQNAME, it.mods) } + .firstOrNull() ?: return LineInfo.EMPTY + + return LineInfo(deserializeMetadata(metadata)) + } + + private fun deserializeMetadata(data: String): LineInfoMap { + val map: LineInfoMap = mutableMapOf() + + val ois = ObjectInputStream(ByteArrayInputStream(Base64.getDecoder().decode(data))) + val count = ois.readInt() + + repeat(count) { + val fqName = ois.readUTF() + val path = ois.readUTF() + val isRelative = ois.readBoolean() + val line = ois.readInt() + val column = ois.readInt() + + map[fqName] = KotlinPosition(path, isRelative, line, column) + } + + return map + } + } + + private val lineInfo: LineInfoMap = mutableMapOf() + private val filePaths = mutableMapOf>() + + fun registerClass(clazz: ClassNode) { + register(clazz, clazz.name) + } + + fun registerMethod(clazz: ClassNode, method: MethodNode) { + register(method, clazz.name + "#" + method.name + method.desc) + } + + fun registerField(clazz: ClassNode, field: FieldNode) { + register(field, clazz.name + "#" + field.name) + } + + private fun register(asmNode: Any, fqName: String) { + val psiElement = kaptContext.origins[asmNode]?.element ?: return + register(fqName, psiElement) + } + + private fun register(fqName: String, psiElement: PsiElement) { + val textRange = psiElement.textRange ?: return + val psiFile = psiElement.containingFile + val lineAndColumn = DiagnosticUtils.getLineAndColumnInPsiFile(psiFile, textRange) + + if (lineAndColumn.line >= 0 && lineAndColumn.column >= 0) { + val (path, isRelative) = getFilePathRelativePreferred(psiFile) + lineInfo[fqName] = KotlinPosition(path, isRelative, lineAndColumn.line, lineAndColumn.column) + } + } + + private fun getFilePathRelativePreferred(file: PsiFile): Pair { + return filePaths.getOrPut(file) { + val absolutePath = file.virtualFile.canonicalPath ?: file.virtualFile.path + val absoluteFile = File(absolutePath) + val baseFile = file.project.basePath?.let { File(it) } + + if (absoluteFile.exists() && baseFile != null && baseFile.exists()) { + val relativePath = absoluteFile.relativeToOrNull(baseFile)?.path + if (relativePath != null) { + return@getOrPut Pair(relativePath, true) + } + } + + return@getOrPut Pair(absolutePath, false) + } + } + + fun serializeLineInfo(): String { + val os = ByteArrayOutputStream() + val oos = ObjectOutputStream(os) + + oos.writeInt(lineInfo.size) + for ((fqName, kotlinPosition) in lineInfo) { + oos.writeUTF(fqName) + oos.writeUTF(kotlinPosition.path) + oos.writeBoolean(kotlinPosition.isRelativePath) + oos.writeInt(kotlinPosition.line) + oos.writeInt(kotlinPosition.column) + } + + oos.flush() + return Base64.getEncoder().encodeToString(os.toByteArray()) + } + + class LineInfo(private val map: LineInfoMap) { + companion object { + val EMPTY = LineInfo(mutableMapOf()) + } + + fun getPositionFor(fqName: String) = map[fqName] + } +} \ No newline at end of file diff --git a/plugins/kapt3/kapt3-compiler/src/org/jetbrains/kotlin/kapt3/stubs/KaptStubLineInformation.kt b/plugins/kapt3/kapt3-compiler/src/org/jetbrains/kotlin/kapt3/stubs/KaptStubLineInformation.kt new file mode 100644 index 00000000000..3810bf6398f --- /dev/null +++ b/plugins/kapt3/kapt3-compiler/src/org/jetbrains/kotlin/kapt3/stubs/KaptStubLineInformation.kt @@ -0,0 +1,140 @@ +/* + * Copyright 2010-2017 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.kapt3.stubs + +import com.sun.tools.javac.tree.JCTree +import com.sun.tools.javac.tree.TreeScanner +import org.jetbrains.kotlin.kapt3.stubs.KaptLineMappingCollector.Companion.KAPT_SIGNATURE_ANNOTATION_FQNAME + +class KaptStubLineInformation { + private val offsets = mutableMapOf() + private val declarations = mutableMapOf>() + + fun getPositionInKotlinFile(file: JCTree.JCCompilationUnit, element: JCTree): KotlinPosition? { + val declaration = findDeclarationFor(element, file) ?: return null + val elementDescriptor = getKaptDescriptor(declaration, file) ?: return null + + val offsets = offsets.getOrPut(file) { KaptLineMappingCollector.parseMetadataAnnotation(file) } + return offsets.getPositionFor(elementDescriptor) + } + + private fun findDeclarationFor(element: JCTree, file: JCTree.JCCompilationUnit): JCTree? { + val fileDeclarations = declarations.getOrPut(file) { collectDeclarations(file) } + return fileDeclarations.firstOrNull { element.isLocatedInside(it) } + } + + private fun getKaptDescriptor(declaration: JCTree, file: JCTree.JCCompilationUnit): String? { + fun getFqName(declaration: JCTree, parent: JCTree, currentName: String): String? { + return when (parent) { + is JCTree.JCCompilationUnit -> { + for (definition in parent.defs) { + // There could be only class definitions on the top level + definition as? JCTree.JCClassDecl ?: continue + getFqName(declaration, definition, "")?.let { return it } + } + return null + } + is JCTree.JCClassDecl -> { + val className = parent.simpleName.toString() + val newName = if (currentName.isEmpty()) className else currentName + "#" + className + if (declaration === parent) { + return newName + } + + for (definition in parent.defs) { + getFqName(declaration, definition, className)?.let { return it } + } + + return null + } + is JCTree.JCVariableDecl -> { + if (declaration === parent) { + return currentName + "#" + parent.name.toString() + } + + return null + } + is JCTree.JCMethodDecl -> { + // We don't need to process local declarations here as kapt does not support locals entirely. + if (declaration === parent) { + val nameAndSignature = getAnnotationValue(KAPT_SIGNATURE_ANNOTATION_FQNAME, parent.mods) ?: return null + return currentName + "#" + nameAndSignature + } + + return null + } + else -> null + } + } + + // Unfortunately, we have to do this the hard way, as symbols may be not available yet + // (for instance, if this code is called inside the "enterTrees()") + val simpleDescriptor = getFqName(declaration, file, "") + val packageName = file.packageName?.toString()?.replace('.', '/') + return if (packageName == null) simpleDescriptor else "$packageName/$simpleDescriptor" + } + + private fun collectDeclarations(file: JCTree.JCCompilationUnit): List { + val declarations = mutableListOf() + + // Note that super.visit...() is above the declarations saving. + // This allows us to get the deepest declarations in the beginning of the list. + file.accept(object : TreeScanner() { + override fun visitClassDef(tree: JCTree.JCClassDecl) { + super.visitClassDef(tree) + declarations += tree + } + + override fun visitVarDef(tree: JCTree.JCVariableDecl) { + // Do not visit variable contents, there can be nothing but local declarations which we don't support + declarations += tree + } + + override fun visitMethodDef(tree: JCTree.JCMethodDecl) { + // Do not visit methods contents, there can be nothing but local declarations which we don't support + declarations += tree + } + + override fun visitTree(tree: JCTree?) {} + }) + + return declarations + } + + private fun JCTree.isLocatedInside(declaration: JCTree): Boolean { + var found = false + + declaration.accept(object : TreeScanner() { + override fun scan(tree: JCTree?) { + if (!found && tree === this@isLocatedInside) { + found = true + } + + if (found) return + super.scan(tree) + } + + override fun scan(trees: com.sun.tools.javac.util.List?) { + // We don't need to repeat the logic above here as scan(List) calls scan(JCTree) + if (found) return + super.scan(trees) + } + }) + + return found + } +} \ No newline at end of file diff --git a/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/AbstractKotlinKapt3Test.kt b/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/AbstractKotlinKapt3Test.kt index 5dafe3800bc..126b3d573c8 100644 --- a/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/AbstractKotlinKapt3Test.kt +++ b/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/AbstractKotlinKapt3Test.kt @@ -21,6 +21,7 @@ import com.sun.tools.javac.comp.CompileStates import com.sun.tools.javac.tree.JCTree.JCCompilationUnit import com.sun.tools.javac.util.JCDiagnostic import com.sun.tools.javac.util.Log +import junit.framework.TestCase import org.jetbrains.kotlin.cli.common.messages.MessageRenderer import org.jetbrains.kotlin.cli.common.messages.PrintingMessageCollector import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment @@ -31,6 +32,7 @@ import org.jetbrains.kotlin.codegen.state.GenerationState import org.jetbrains.kotlin.kapt3.Kapt3BuilderFactory import org.jetbrains.kotlin.kapt3.KaptContext import org.jetbrains.kotlin.kapt3.doAnnotationProcessing +import org.jetbrains.kotlin.kapt3.javac.KaptJavaFileObject import org.jetbrains.kotlin.kapt3.javac.KaptJavaLog import org.jetbrains.kotlin.kapt3.stubs.ClassFileToSourceStubConverter import org.jetbrains.kotlin.kapt3.util.KaptLogger @@ -40,6 +42,7 @@ import org.jetbrains.kotlin.test.ConfigurationKind import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.util.trimTrailingWhitespacesAndAddNewlineAtEOF import org.jetbrains.kotlin.utils.PathUtil +import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstance import java.io.File import java.nio.file.Files import java.util.* @@ -51,6 +54,15 @@ abstract class AbstractKotlinKapt3Test : CodegenTestCase() { val messageCollector = PrintingMessageCollector(System.err, MessageRenderer.PLAIN_FULL_PATHS, false) } + private val tempFiles = mutableListOf() + + private fun createTempFile(prefix: String, suffix: String, text: String): File { + return File.createTempFile(prefix, suffix).apply { + writeText(text) + tempFiles += this + } + } + override fun doMultiFileTest(wholeFile: File, files: List, javaFilesDir: File?) { val javaSources = javaFilesDir?.let { arrayOf(it) } ?: emptyArray() @@ -72,12 +84,14 @@ abstract class AbstractKotlinKapt3Test : CodegenTestCase() { val javaFiles = files .filter { it.name.toLowerCase().endsWith(".java") } - .map { File.createTempFile(it.name.substringBeforeLast('.'), ".java").apply { writeText(it.content) } } + .map { createTempFile(it.name.substringBeforeLast('.'), ".java", it.content) } try { check(kaptContext, javaFiles, txtFile, wholeFile) } finally { javaFiles.forEach { it.delete() } + tempFiles.forEach { it.delete() } + tempFiles.clear() kaptContext.close() } } @@ -89,8 +103,29 @@ abstract class AbstractKotlinKapt3Test : CodegenTestCase() { correctErrorTypes: Boolean ): JavacList { val converter = ClassFileToSourceStubConverter(kaptContext, generateNonExistentClass, correctErrorTypes) - val parsedJavaFiles = kaptContext.compiler.parseFiles(kaptContext.fileManager.getJavaFileObjectsFromFiles(javaFiles)) - return converter.convert().appendList(parsedJavaFiles) + + val convertedTrees = converter.convert() + val convertedFiles = convertedTrees.map { tree -> createTempFile("stub", ".java", tree.toString()) } + + val allJavaFiles = javaFiles + convertedFiles + + // A workaround needed for Javac to parse files correctly even if errors were already reported + // If nerrors > 0, "parseFiles()" returns the empty list + val oldErrorCount = kaptContext.compiler.log.nerrors + kaptContext.compiler.log.nerrors = 0 + + try { + val parsedJavaFiles = kaptContext.compiler.parseFiles(kaptContext.fileManager.getJavaFileObjectsFromFiles(allJavaFiles)) + for (file in parsedJavaFiles) { + // By default, JavaFileObject.getName() returns the absolute path to the file. + // In our test, such a path will be temporary, so the comparision against it will lead to flaky tests. + file.sourcefile = KaptJavaFileObject(file, file.defs.firstIsInstance()) + } + + return parsedJavaFiles + } finally { + kaptContext.compiler.log.nerrors = oldErrorCount + } } protected abstract fun check( @@ -104,31 +139,34 @@ abstract class AbstractClassFileToSourceStubConverterTest : AbstractKotlinKapt3T internal companion object { private val KOTLIN_METADATA_GROUP = "[a-z0-9]+ = (\\{.+?\\}|[0-9]+)" private val KOTLIN_METADATA_REGEX = "@kotlin\\.Metadata\\(($KOTLIN_METADATA_GROUP)(, $KOTLIN_METADATA_GROUP)*\\)".toRegex() + private val KAPT_METADATA_REGEX = "@kapt\\.internal\\.KaptMetadata\\((value = )?\"[^(].*?\"\\)".toRegex() - fun removeMetadataAnnotationContents(s: String): String = s.replace(KOTLIN_METADATA_REGEX, "@kotlin.Metadata()") + private val EXPECTED_ERROR = "EXPECTED_ERROR" + + fun removeMetadataAnnotationContents(s: String): String { + return s.replace(KOTLIN_METADATA_REGEX, "@kotlin.Metadata()") + .replace(KAPT_METADATA_REGEX, "@kapt.internal.KaptMetadata()") + } } override fun check(kaptContext: KaptContext, javaFiles: List, txtFile: File, wholeFile: File) { fun isOptionSet(name: String) = wholeFile.useLines { lines -> lines.any { it.trim() == "// $name" } } fun getOptionValues(name: String) = wholeFile.useLines { lines -> - lines.filter { it.startsWith("// $name") } - .map { it.drop(name.length + 3).trim() } - .filter { it.isNotEmpty() } - .toList() + lines.filter { it.startsWith("// $name") }.toList() } val generateNonExistentClass = isOptionSet("NON_EXISTENT_CLASS") val correctErrorTypes = isOptionSet("CORRECT_ERROR_TYPES") val validate = !isOptionSet("NO_VALIDATION") - val expectedErrors = getOptionValues("EXPECTED_ERROR").sorted() + val expectedErrors = getOptionValues(EXPECTED_ERROR).sorted() val convertedFiles = convert(kaptContext, javaFiles, generateNonExistentClass, correctErrorTypes) kaptContext.javaLog.interceptorData.files = convertedFiles.map { it.sourceFile to it }.toMap() if (validate) kaptContext.compiler.enterTrees(convertedFiles) - val actualRaw = convertedFiles.sortedBy { it.sourceFile.name }.joinToString (FILE_SEPARATOR) + val actualRaw = convertedFiles.sortedBy { it.sourceFile.name }.joinToString(FILE_SEPARATOR) val actual = StringUtil.convertLineSeparators(actualRaw.trim({ it <= ' ' })) .trimTrailingWhitespacesAndAddNewlineAtEOF() .let { removeMetadataAnnotationContents(it) } @@ -138,18 +176,27 @@ abstract class AbstractClassFileToSourceStubConverterTest : AbstractKotlinKapt3T val actualErrors = log.reportedDiagnostics .filter { it.type == JCDiagnostic.DiagnosticType.ERROR } - .map { it.getMessage(Locale.US).lines().first() } + .map { + val location = it.subdiagnostics + .firstOrNull { it.getMessage(Locale.US).startsWith("Kotlin location:") } + ?.getMessage(Locale.US) + + val javaLocation = "(${it.lineNumber};${it.columnNumber}) " + val message = javaLocation + it.getMessage(Locale.US).lines().first() + if (location != null) "$message ($location)" else message + } + .map { "// " + EXPECTED_ERROR + it } .sorted() log.flush() if (expectedErrors.isEmpty()) { error("There were errors during analysis. See errors above. Stubs:\n\n$actual") - } else if (actualErrors != expectedErrors) { - error("Expected error matching assertion. Expected: \n" - + expectedErrors.joinToString("\n") { "'$it'" } - + "\n, found: \n" - + actualErrors.joinToString("\n") { "'$it'" }) + } else { + val lineSeparator = System.getProperty("line.separator") + TestCase.assertEquals("Expected error matching failed", + expectedErrors.joinToString(lineSeparator), + actualErrors.joinToString(lineSeparator)) } } KotlinTestUtils.assertEqualsToFile(txtFile, actual) diff --git a/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/ClassFileToSourceStubConverterTestGenerated.java b/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/ClassFileToSourceStubConverterTestGenerated.java index 9b0bfb37c86..f54dcc894ee 100644 --- a/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/ClassFileToSourceStubConverterTestGenerated.java +++ b/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/ClassFileToSourceStubConverterTestGenerated.java @@ -78,6 +78,12 @@ public class ClassFileToSourceStubConverterTestGenerated extends AbstractClassFi doTest(fileName); } + @TestMetadata("errorLocationMapping.kt") + public void testErrorLocationMapping() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("plugins/kapt3/kapt3-compiler/testData/converter/errorLocationMapping.kt"); + doTest(fileName); + } + @TestMetadata("fileFacadeJvmName.kt") public void testFileFacadeJvmName() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("plugins/kapt3/kapt3-compiler/testData/converter/fileFacadeJvmName.kt"); diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/abstractEnum.txt b/plugins/kapt3/kapt3-compiler/testData/converter/abstractEnum.txt index 434858db687..412486b6efd 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/abstractEnum.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/abstractEnum.txt @@ -1,31 +1,17 @@ @kotlin.Metadata() +@kapt.internal.KaptMetadata() public enum E { - /*public static final*/ X /* = new @kotlin.Metadata() X(){ - - @java.lang.Override() - public void a() { - } - - X() { - super(); - } - } */, - /*public static final*/ Y /* = new @kotlin.Metadata() Y(){ - - @java.lang.Override() - public void a() { - } - - Y() { - super(); - } - } */; + /*public static final*/ X /* = new E() */, + /*public static final*/ Y /* = new E() */; + @kapt.internal.KaptSignature(value = "a()V") public abstract void a(); + @kapt.internal.KaptSignature(value = "b()V") public final void b() { } + @kapt.internal.KaptSignature(value = "(Ljava/lang/String;I)V") E() { } @@ -33,6 +19,7 @@ public enum E { public static final class Obj { public static final E.Obj INSTANCE = null; + @kapt.internal.KaptSignature(value = "()V") private Obj() { super(); } @@ -41,6 +28,7 @@ public enum E { @kotlin.Metadata() public static final class NestedClass { + @kapt.internal.KaptSignature(value = "()V") public NestedClass() { super(); } @@ -51,33 +39,19 @@ public enum E { @kotlin.Metadata() +@kapt.internal.KaptMetadata() public enum E2 { - /*public static final*/ X /* = new @kotlin.Metadata() X(0){ - - @java.lang.Override() - public void a() { - } - - X() { - super(0); - } - } */, - /*public static final*/ Y /* = new @kotlin.Metadata() Y(0){ - - @java.lang.Override() - public void a() { - } - - Y() { - super(0); - } - } */; + /*public static final*/ X /* = new E2() */, + /*public static final*/ Y /* = new E2() */; + @kapt.internal.KaptSignature(value = "a()V") public abstract void a(); + @kapt.internal.KaptSignature(value = "(Ljava/lang/String;II)V") E2(int n) { } + @kapt.internal.KaptSignature(value = "(Ljava/lang/String;ILjava/lang/String;)V") E2(@org.jetbrains.annotations.NotNull() java.lang.String s) { } @@ -87,17 +61,20 @@ public enum E2 { @kotlin.Metadata() +@kapt.internal.KaptMetadata() public enum E3 { - /*public static final*/ X /* = new X(null) */, - /*public static final*/ Y /* = new Y(null) */; + /*public static final*/ X /* = new E3() */, + /*public static final*/ Y /* = new E3() */; @org.jetbrains.annotations.NotNull() private final java.lang.String a = null; @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "getA()Ljava/lang/String;") public final java.lang.String getA() { return null; } + @kapt.internal.KaptSignature(value = "(Ljava/lang/String;ILjava/lang/String;)V") E3(@org.jetbrains.annotations.NotNull() java.lang.String a) { } @@ -107,8 +84,9 @@ public enum E3 { @kotlin.Metadata() +@kapt.internal.KaptMetadata() public enum E4 { - /*public static final*/ X /* = new X(null, 0, 0L, false) */; + /*public static final*/ X /* = new E4() */; @org.jetbrains.annotations.NotNull() private final java.lang.String a = null; private final int b = 0; @@ -116,23 +94,46 @@ public enum E4 { private final boolean d = false; @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "getA()Ljava/lang/String;") public final java.lang.String getA() { return null; } + @kapt.internal.KaptSignature(value = "getB()I") public final int getB() { return 0; } + @kapt.internal.KaptSignature(value = "getC()J") public final long getC() { return 0L; } + @kapt.internal.KaptSignature(value = "getD()Z") public final boolean getD() { return false; } + @kapt.internal.KaptSignature(value = "(Ljava/lang/String;ILjava/lang/String;IJZ)V") E4(@org.jetbrains.annotations.NotNull() java.lang.String a, int b, long c, boolean d) { } } + +//////////////////// + +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/abstractMethods.txt b/plugins/kapt3/kapt3-compiler/testData/converter/abstractMethods.txt index c001ec3c4ed..a7298921259 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/abstractMethods.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/abstractMethods.txt @@ -1,12 +1,16 @@ @kotlin.Metadata() +@kapt.internal.KaptMetadata() public abstract class Base { + @kapt.internal.KaptSignature(value = "doJob(Ljava/lang/String;I)V") protected abstract void doJob(@org.jetbrains.annotations.NotNull() java.lang.String job, int delay); + @kapt.internal.KaptSignature(value = "doJobGeneric(Ljava/lang/CharSequence;I)V") protected abstract void doJobGeneric(@org.jetbrains.annotations.NotNull() T job, int delay); + @kapt.internal.KaptSignature(value = "()V") public Base() { super(); } @@ -16,19 +20,41 @@ public abstract class Base { @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class Impl extends Base { @java.lang.Override() + @kapt.internal.KaptSignature(value = "doJob(Ljava/lang/String;I)V") protected void doJob(@org.jetbrains.annotations.NotNull() java.lang.String job, int delay) { } @java.lang.Override() + @kapt.internal.KaptSignature(value = "doJobGeneric(Ljava/lang/CharSequence;I)V") protected void doJobGeneric(@org.jetbrains.annotations.NotNull() T job, int delay) { } + @kapt.internal.KaptSignature(value = "()V") public Impl() { super(); } } + +//////////////////// + +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/annotations.txt b/plugins/kapt3/kapt3-compiler/testData/converter/annotations.txt index 27f688198fb..53e8ad53f21 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/annotations.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/annotations.txt @@ -1,5 +1,6 @@ @kotlin.Metadata() @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME) +@kapt.internal.KaptMetadata() public abstract @interface Anno1 { } @@ -8,24 +9,34 @@ public abstract @interface Anno1 { @kotlin.Metadata() @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME) +@kapt.internal.KaptMetadata() public abstract @interface Anno2 { + @kapt.internal.KaptSignature(value = "i()I") public abstract int i() default 5; + @kapt.internal.KaptSignature(value = "s()Ljava/lang/String;") public abstract java.lang.String s() default "ABC"; + @kapt.internal.KaptSignature(value = "ii()[I") public abstract int[] ii() default {1, 2, 3}; + @kapt.internal.KaptSignature(value = "ss()[Ljava/lang/String;") public abstract java.lang.String[] ss() default {"A", "B"}; + @kapt.internal.KaptSignature(value = "a()LAnno1;") public abstract Anno1 a(); + @kapt.internal.KaptSignature(value = "color()LColors;") public abstract Colors color() default Colors.BLACK; + @kapt.internal.KaptSignature(value = "colors()[LColors;") public abstract Colors[] colors() default {Colors.BLACK, Colors.WHITE}; + @kapt.internal.KaptSignature(value = "clazz()Ljava/lang/Class;") public abstract java.lang.Class clazz(); + @kapt.internal.KaptSignature(value = "classes()[Ljava/lang/Class;") public abstract java.lang.Class[] classes(); } @@ -34,8 +45,10 @@ public abstract @interface Anno2 { @kotlin.Metadata() @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME) +@kapt.internal.KaptMetadata() public abstract @interface Anno3 { + @kapt.internal.KaptSignature(value = "value()Ljava/lang/String;") public abstract java.lang.String value(); } @@ -43,10 +56,12 @@ public abstract @interface Anno3 { @kotlin.Metadata() +@kapt.internal.KaptMetadata() public enum Colors { - /*public static final*/ WHITE /* = new WHITE() */, - /*public static final*/ BLACK /* = new BLACK() */; + /*public static final*/ WHITE /* = new Colors() */, + /*public static final*/ BLACK /* = new Colors() */; + @kapt.internal.KaptSignature(value = "(Ljava/lang/String;I)V") Colors() { } } @@ -58,8 +73,10 @@ public enum Colors { @Anno3(value = "value") @Anno2(a = @Anno1(), clazz = TestAnno.class, classes = {TestAnno.class, Anno1.class}) @Anno1() +@kapt.internal.KaptMetadata() public final class TestAnno { + @kapt.internal.KaptSignature(value = "()V") public TestAnno() { super(); } @@ -71,34 +88,58 @@ public final class TestAnno { @kotlin.Metadata() @Anno2(i = 6, s = "BCD", ii = {4, 5, 6}, ss = {"Z", "X"}, a = @Anno1(), color = Colors.WHITE, colors = {Colors.WHITE}, clazz = TestAnno.class, classes = {TestAnno.class, Anno1.class}) @Anno3(value = "value") +@kapt.internal.KaptMetadata() public final class TestAnno2 { @org.jetbrains.annotations.NotNull() @Anno3(value = "field") private java.lang.String b; @Anno1() + @kapt.internal.KaptSignature(value = "a(Ljava/lang/String;)V") public final void a(@org.jetbrains.annotations.NotNull() @Anno3(value = "param-pam-pam") java.lang.String param) { } @Anno3(value = "property") + @kapt.internal.KaptSignature(value = "b$annotations()V") public static void b$annotations() { } @org.jetbrains.annotations.NotNull() @Anno3(value = "getter") + @kapt.internal.KaptSignature(value = "getB()Ljava/lang/String;") public final java.lang.String getB() { return null; } @Anno3(value = "setter") + @kapt.internal.KaptSignature(value = "setB(Ljava/lang/String;)V") public final void setB(@org.jetbrains.annotations.NotNull() @Anno3(value = "setparam") java.lang.String p0) { } + @kapt.internal.KaptSignature(value = "()V") public TestAnno2() { super(); } } + +//////////////////// + +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/annotations2.txt b/plugins/kapt3/kapt3-compiler/testData/converter/annotations2.txt index 2f5bea636e0..6c79e14fbef 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/annotations2.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/annotations2.txt @@ -1,10 +1,30 @@ +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} + +//////////////////// + package test; @kotlin.Metadata() @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME) @Anno(value = "anno-class") +@kapt.internal.KaptMetadata() public abstract @interface Anno { + @kapt.internal.KaptSignature(value = "value()Ljava/lang/String;") public abstract java.lang.String value(); } @@ -13,6 +33,7 @@ public abstract @interface Anno { package test; @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class AnnotationsTest { public AnnotationsTest() { @@ -20,16 +41,19 @@ public final class AnnotationsTest { } @Anno(value = "top-level-fun") + @kapt.internal.KaptSignature(value = "topLevelFun(Ljava/lang/String;)V") public static final void topLevelFun(@org.jetbrains.annotations.NotNull() @Anno(value = "top-level-fun-receiver") java.lang.String $receiver) { } @Anno(value = "top-level-val") + @kapt.internal.KaptSignature(value = "topLevelVal$annotations(I)V") public static void topLevelVal$annotations(int p0) { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "getTopLevelVal(I)Ljava/lang/String;") public static final java.lang.String getTopLevelVal(@Anno(value = "top-level-val-receiver") int $receiver) { return null; @@ -42,16 +66,19 @@ package test; @kotlin.Metadata() @Anno(value = "enum") +@kapt.internal.KaptMetadata() public enum Enum { - /*public static final*/ WHITE /* = new WHITE(0) */, - /*public static final*/ BLACK /* = new BLACK(0) */; + /*public static final*/ WHITE /* = new Enum() */, + /*public static final*/ BLACK /* = new Enum() */; private final int x = 0; + @kapt.internal.KaptSignature(value = "getX()I") public final int getX() { return 0; } @Anno(value = "enum-constructor") + @kapt.internal.KaptSignature(value = "(Ljava/lang/String;II)V") Enum(@Anno(value = "x") int x) { } @@ -63,38 +90,46 @@ package test; @kotlin.Metadata() @Anno(value = "clazz") +@kapt.internal.KaptMetadata() public abstract class Test { @org.jetbrains.annotations.NotNull() private java.lang.String v; @org.jetbrains.annotations.NotNull() @Anno(value = "abstract-method") + @kapt.internal.KaptSignature(value = "abstractMethod()Ljava/lang/String;") public abstract java.lang.String abstractMethod(); @Anno(value = "abstract-val") + @kapt.internal.KaptSignature(value = "abstractVal$annotations()V") public static void abstractVal$annotations() { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "getAbstractVal()Ljava/lang/String;") public abstract java.lang.String getAbstractVal(); @Anno(value = "v-property") + @kapt.internal.KaptSignature(value = "v$annotations()V") public static void v$annotations() { } @org.jetbrains.annotations.NotNull() @Anno(value = "v-get") + @kapt.internal.KaptSignature(value = "getV()Ljava/lang/String;") public final java.lang.String getV() { return null; } @Anno(value = "v-set") + @kapt.internal.KaptSignature(value = "setV(Ljava/lang/String;)V") public final void setV(@org.jetbrains.annotations.NotNull() @Anno(value = "v-setparam") java.lang.String p0) { } @Anno(value = "test-constructor") + @kapt.internal.KaptSignature(value = "(Ljava/lang/String;)V") protected Test(@org.jetbrains.annotations.NotNull() @Anno(value = "v-param") java.lang.String v) { diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/dataClass.txt b/plugins/kapt3/kapt3-compiler/testData/converter/dataClass.txt index c0246772be2..0faaadebd2b 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/dataClass.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/dataClass.txt @@ -1,4 +1,5 @@ @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class User { @org.jetbrains.annotations.NotNull() private final java.lang.String firstName = null; @@ -6,23 +7,28 @@ public final class User { private final java.lang.String secondName = null; private final int age = 0; + @kapt.internal.KaptSignature(value = "procedure()V") public final void procedure() { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "getFirstName()Ljava/lang/String;") public final java.lang.String getFirstName() { return null; } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "getSecondName()Ljava/lang/String;") public final java.lang.String getSecondName() { return null; } + @kapt.internal.KaptSignature(value = "getAge()I") public final int getAge() { return 0; } + @kapt.internal.KaptSignature(value = "(Ljava/lang/String;Ljava/lang/String;I)V") public User(@org.jetbrains.annotations.NotNull() java.lang.String firstName, @org.jetbrains.annotations.NotNull() java.lang.String secondName, int age) { @@ -30,20 +36,24 @@ public final class User { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "component1()Ljava/lang/String;") public final java.lang.String component1() { return null; } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "component2()Ljava/lang/String;") public final java.lang.String component2() { return null; } + @kapt.internal.KaptSignature(value = "component3()I") public final int component3() { return 0; } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "copy(Ljava/lang/String;Ljava/lang/String;I)LUser;") public final User copy(@org.jetbrains.annotations.NotNull() java.lang.String firstName, @org.jetbrains.annotations.NotNull() java.lang.String secondName, int age) { @@ -51,17 +61,38 @@ public final class User { } @java.lang.Override() + @kapt.internal.KaptSignature(value = "toString()Ljava/lang/String;") public java.lang.String toString() { return null; } @java.lang.Override() + @kapt.internal.KaptSignature(value = "hashCode()I") public int hashCode() { return 0; } @java.lang.Override() + @kapt.internal.KaptSignature(value = "equals(Ljava/lang/Object;)Z") public boolean equals(java.lang.Object p0) { return false; } } + +//////////////////// + +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/defaultImpls.txt b/plugins/kapt3/kapt3-compiler/testData/converter/defaultImpls.txt index 94bb15ac85e..3be3c441499 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/defaultImpls.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/defaultImpls.txt @@ -1,8 +1,10 @@ @kotlin.Metadata() +@kapt.internal.KaptMetadata() public abstract interface Intf { public static final Intf.Companion Companion = null; public static final int WHITE = 2; + @kapt.internal.KaptSignature(value = "getColor()I") public abstract int getColor(); @kotlin.Metadata() @@ -12,6 +14,7 @@ public abstract interface Intf { super(); } + @kapt.internal.KaptSignature(value = "getColor(LIntf;)I") public static int getColor(Intf $this) { return 0; } @@ -22,10 +25,12 @@ public abstract interface Intf { private static final int BLACK = 1; public static final int WHITE = 2; + @kapt.internal.KaptSignature(value = "getBLACK()I") public final int getBLACK() { return 0; } + @kapt.internal.KaptSignature(value = "()V") private Companion() { super(); } @@ -36,8 +41,10 @@ public abstract interface Intf { @kotlin.Metadata() +@kapt.internal.KaptMetadata() public abstract interface IntfWithDefaultImpls { + @kapt.internal.KaptSignature(value = "a()V") public abstract void a(); @kotlin.Metadata() @@ -47,6 +54,7 @@ public abstract interface IntfWithDefaultImpls { super(); } + @kapt.internal.KaptSignature(value = "a(LIntfWithDefaultImpls;)V") public static void a(IntfWithDefaultImpls $this) { } } @@ -56,5 +64,24 @@ public abstract interface IntfWithDefaultImpls { @kotlin.Metadata() +@kapt.internal.KaptMetadata() public abstract interface IntfWithoutDefaultImpls { } + +//////////////////// + +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/enums.txt b/plugins/kapt3/kapt3-compiler/testData/converter/enums.txt index 06bc4abc15c..2b0835d3d64 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/enums.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/enums.txt @@ -1,7 +1,9 @@ @kotlin.Metadata() @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME) +@kapt.internal.KaptMetadata() public abstract @interface Anno1 { + @kapt.internal.KaptSignature(value = "value()Ljava/lang/String;") public abstract java.lang.String value(); } @@ -9,10 +11,12 @@ public abstract @interface Anno1 { @kotlin.Metadata() +@kapt.internal.KaptMetadata() public enum Enum1 { - /*public static final*/ BLACK /* = new BLACK() */, - /*public static final*/ WHITE /* = new WHITE() */; + /*public static final*/ BLACK /* = new Enum1() */, + /*public static final*/ WHITE /* = new Enum1() */; + @kapt.internal.KaptSignature(value = "(Ljava/lang/String;I)V") Enum1() { } } @@ -21,36 +25,61 @@ public enum Enum1 { @kotlin.Metadata() +@kapt.internal.KaptMetadata() public enum Enum2 { - /*public static final*/ RED /* = new RED(null, 0) */, - /*public static final*/ WHITE /* = new WHITE(null, 0) */; + /*public static final*/ RED /* = new Enum2() */, + /*public static final*/ WHITE /* = new Enum2() */; @org.jetbrains.annotations.NotNull() private final java.lang.String col = null; private final int col2 = 0; @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "color()Ljava/lang/String;") public final java.lang.String color() { return null; } + @kapt.internal.KaptSignature(value = "privateEnumFun()V") private final void privateEnumFun() { } + @kapt.internal.KaptSignature(value = "publicEnumFun()V") public final void publicEnumFun() { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "getCol()Ljava/lang/String;") public final java.lang.String getCol() { return null; } + @kapt.internal.KaptSignature(value = "getCol2()I") public final int getCol2() { return 0; } + @kapt.internal.KaptSignature(value = "(Ljava/lang/String;ILjava/lang/String;I)V") Enum2(@org.jetbrains.annotations.NotNull() @Anno1(value = "first") java.lang.String col, @Anno1(value = "second") int col2) { } } + +//////////////////// + +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/errorLocationMapping.kt b/plugins/kapt3/kapt3-compiler/testData/converter/errorLocationMapping.kt new file mode 100644 index 00000000000..3d91155267c --- /dev/null +++ b/plugins/kapt3/kapt3-compiler/testData/converter/errorLocationMapping.kt @@ -0,0 +1,41 @@ +// CORRECT_ERROR_TYPES + +// EXPECTED_ERROR(10;12) cannot find symbol (Kotlin location: /errorLocationMapping.kt: (29, 5)) +// EXPECTED_ERROR(12;12) cannot find symbol (Kotlin location: /errorLocationMapping.kt: (30, 5)) +// EXPECTED_ERROR(27;18) cannot find symbol (Kotlin location: /errorLocationMapping.kt: (29, 5)) +// EXPECTED_ERROR(33;5) cannot find symbol (Kotlin location: /errorLocationMapping.kt: (29, 5)) +// EXPECTED_ERROR(35;5) cannot find symbol (Kotlin location: /errorLocationMapping.kt: (22, 34)) +// EXPECTED_ERROR(36;30) cannot find symbol (Kotlin location: /errorLocationMapping.kt: (22, 34)) +// EXPECTED_ERROR(38;18) cannot find symbol (Kotlin location: /errorLocationMapping.kt: (30, 5)) +// EXPECTED_ERROR(44;5) cannot find symbol (Kotlin location: /errorLocationMapping.kt: (30, 5)) +// EXPECTED_ERROR(54;5) cannot find symbol (Kotlin location: /errorLocationMapping.kt: (33, 5)) +// EXPECTED_ERROR(5;11) cannot find symbol (Kotlin location: /errorLocationMapping.kt: (19, 1)) +// EXPECTED_ERROR(60;5) cannot find symbol (Kotlin location: /errorLocationMapping.kt: (35, 5)) +// EXPECTED_ERROR(73;18) cannot find symbol (Kotlin location: /errorLocationMapping.kt: (38, 5)) + +@file:Suppress("UNRESOLVED_REFERENCE", "ANNOTATION_PARAMETER_MUST_BE_CONST", "NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION") +import kotlin.reflect.KClass + +@Anno(ABC::class) +class ErrorInAnnotation + +class ErrorInConstructorParameter(val a: String, val b: ABC, val c: List) + +class ErrorInSupertype : ABC +class ErrorInSupertype2 : ABC() + +class ErrorInDeclarations { + lateinit var p1: String + lateinit var p2: ABC + lateinit var p3: BCD + + fun overloads(a: String) {} + fun overloads(a: ABC) {} + + fun f1(a: String, b: ABC>) {} + fun f2() {} + fun f3() {} + fun f4(): ABC? = null +} + +annotation class Anno(val a: KClass) \ No newline at end of file diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/errorLocationMapping.txt b/plugins/kapt3/kapt3-compiler/testData/converter/errorLocationMapping.txt new file mode 100644 index 00000000000..54988369ce4 --- /dev/null +++ b/plugins/kapt3/kapt3-compiler/testData/converter/errorLocationMapping.txt @@ -0,0 +1,200 @@ +import kotlin.reflect.KClass; + +@kotlin.Metadata() +@java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME) +@kapt.internal.KaptMetadata() +public abstract @interface Anno { + + @kapt.internal.KaptSignature(value = "a()Ljava/lang/Class;") + public abstract java.lang.Class a(); +} + +//////////////////// + + +import kotlin.reflect.KClass; + +@kotlin.Metadata() +@Anno(a = ABC.class) +@kapt.internal.KaptMetadata() +public final class ErrorInAnnotation { + + @kapt.internal.KaptSignature(value = "()V") + public ErrorInAnnotation() { + super(); + } +} + +//////////////////// + + +import kotlin.reflect.KClass; + +@kotlin.Metadata() +@kapt.internal.KaptMetadata() +public final class ErrorInConstructorParameter { + @org.jetbrains.annotations.NotNull() + private final java.lang.String a = null; + @org.jetbrains.annotations.NotNull() + private final error.NonExistentClass b = null; + @org.jetbrains.annotations.NotNull() + private final java.util.List c = null; + + @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "getA()Ljava/lang/String;") + public final java.lang.String getA() { + return null; + } + + @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "getB()Lerror/NonExistentClass;") + public final error.NonExistentClass getB() { + return null; + } + + @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "getC()Ljava/util/List;") + public final java.util.List getC() { + return null; + } + + @kapt.internal.KaptSignature(value = "(Ljava/lang/String;Lerror/NonExistentClass;Ljava/util/List;)V") + public ErrorInConstructorParameter(@org.jetbrains.annotations.NotNull() + java.lang.String a, @org.jetbrains.annotations.NotNull() + ABC b, @org.jetbrains.annotations.NotNull() + java.util.List c) { + super(); + } +} + +//////////////////// + + +import kotlin.reflect.KClass; + +@kotlin.Metadata() +@kapt.internal.KaptMetadata() +public final class ErrorInDeclarations { + @org.jetbrains.annotations.NotNull() + public java.lang.String p1; + @org.jetbrains.annotations.NotNull() + public ABC p2; + @org.jetbrains.annotations.NotNull() + public BCD p3; + + @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "getP1()Ljava/lang/String;") + public final java.lang.String getP1() { + return null; + } + + @kapt.internal.KaptSignature(value = "setP1(Ljava/lang/String;)V") + public final void setP1(@org.jetbrains.annotations.NotNull() + java.lang.String p0) { + } + + @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "getP2()Lerror/NonExistentClass;") + public final ABC getP2() { + return null; + } + + @kapt.internal.KaptSignature(value = "setP2(Lerror/NonExistentClass;)V") + public final void setP2(@org.jetbrains.annotations.NotNull() + ABC p0) { + } + + @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "getP3()Lerror/NonExistentClass;") + public final BCD getP3() { + return null; + } + + @kapt.internal.KaptSignature(value = "setP3(Lerror/NonExistentClass;)V") + public final void setP3(@org.jetbrains.annotations.NotNull() + BCD p0) { + } + + @kapt.internal.KaptSignature(value = "overloads(Ljava/lang/String;)V") + public final void overloads(@org.jetbrains.annotations.NotNull() + java.lang.String a) { + } + + @kapt.internal.KaptSignature(value = "overloads(Lerror/NonExistentClass;)V") + public final void overloads(@org.jetbrains.annotations.NotNull() + ABC a) { + } + + @kapt.internal.KaptSignature(value = "f1(Ljava/lang/String;Lerror/NonExistentClass;)V") + public final void f1(@org.jetbrains.annotations.NotNull() + java.lang.String a, @org.jetbrains.annotations.NotNull() + ABC> b) { + } + + @kapt.internal.KaptSignature(value = "f2()V") + public final void f2() { + } + + @kapt.internal.KaptSignature(value = "f3()V") + public final void f3() { + } + + @org.jetbrains.annotations.Nullable() + @kapt.internal.KaptSignature(value = "f4()Lerror/NonExistentClass;") + public final ABC f4() { + return null; + } + + @kapt.internal.KaptSignature(value = "()V") + public ErrorInDeclarations() { + super(); + } +} + +//////////////////// + + +import kotlin.reflect.KClass; + +@kotlin.Metadata() +@kapt.internal.KaptMetadata() +public final class ErrorInSupertype { + + @kapt.internal.KaptSignature(value = "()V") + public ErrorInSupertype() { + super(); + } +} + +//////////////////// + + +import kotlin.reflect.KClass; + +@kotlin.Metadata() +@kapt.internal.KaptMetadata() +public final class ErrorInSupertype2 { + + @kapt.internal.KaptSignature(value = "()V") + public ErrorInSupertype2() { + super(); + } +} + +//////////////////// + +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/fileFacadeJvmName.txt b/plugins/kapt3/kapt3-compiler/testData/converter/fileFacadeJvmName.txt index 3edb2886c26..22d85469d86 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/fileFacadeJvmName.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/fileFacadeJvmName.txt @@ -1,6 +1,7 @@ package a.b.c; @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class FacadeName { public FacadeName() { @@ -8,10 +9,30 @@ public final class FacadeName { } private static final int bar = 3; + @kapt.internal.KaptSignature(value = "foo()V") public static final void foo() { } + @kapt.internal.KaptSignature(value = "getBar()I") public static final int getBar() { return 0; } } + +//////////////////// + +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/functions.txt b/plugins/kapt3/kapt3-compiler/testData/converter/functions.txt index 05b1a40dcd4..06b3b7d1967 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/functions.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/functions.txt @@ -1,24 +1,48 @@ @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class FunctionsTest { @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "f()Lkotlin/reflect/KProperty1;") public final kotlin.reflect.KProperty1 f() { return null; } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "f2()Lkotlin/jvm/functions/Function2;") public final kotlin.jvm.functions.Function2 f2() { return null; } + @kapt.internal.KaptSignature(value = "f3()V") public final void f3() { } + @kapt.internal.KaptSignature(value = "f4()I") public final int f4() { return 0; } + @kapt.internal.KaptSignature(value = "()V") public FunctionsTest() { super(); } } + +//////////////////// + +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/genericRawSignatures.txt b/plugins/kapt3/kapt3-compiler/testData/converter/genericRawSignatures.txt index 73e5547d094..5a2b62ade36 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/genericRawSignatures.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/genericRawSignatures.txt @@ -1,17 +1,39 @@ @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class GenericRawSignatures { @org.jetbrains.annotations.Nullable() + @kapt.internal.KaptSignature(value = "genericFun()Ljava/lang/Object;") public final T genericFun() { return null; } @org.jetbrains.annotations.Nullable() + @kapt.internal.KaptSignature(value = "nonGenericFun()Ljava/lang/String;") public final java.lang.String nonGenericFun() { return null; } + @kapt.internal.KaptSignature(value = "()V") public GenericRawSignatures() { super(); } } + +//////////////////// + +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/genericSimple.txt b/plugins/kapt3/kapt3-compiler/testData/converter/genericSimple.txt index d026ddb9f2c..c7032f4f6bb 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/genericSimple.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/genericSimple.txt @@ -1,12 +1,15 @@ @kotlin.Metadata() +@kapt.internal.KaptMetadata() public abstract interface ABC { @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "abc(Ljava/lang/CharSequence;Ljava/util/List;[Ljava/lang/CharSequence;)Ljava/util/List;") public abstract java.util.List abc(@org.jetbrains.annotations.NotNull() T item, @org.jetbrains.annotations.NotNull() java.util.List items, @org.jetbrains.annotations.NotNull() T... otherItems); + @kapt.internal.KaptSignature(value = "bcd([C)I") public abstract int bcd(@org.jetbrains.annotations.NotNull() char... a); } @@ -15,8 +18,10 @@ public abstract interface ABC { @kotlin.Metadata() +@kapt.internal.KaptMetadata() public class BaseClass { + @kapt.internal.KaptSignature(value = "()V") public BaseClass() { super(); } @@ -26,6 +31,7 @@ public class BaseClass { @kotlin.Metadata() +@kapt.internal.KaptMetadata() public abstract interface Intf { } @@ -33,6 +39,7 @@ public abstract interface Intf, M extends T> { } @@ -40,15 +47,18 @@ public abstract interface Intf2 extends BaseClass implements Intf, OtherIntf { @org.jetbrains.annotations.Nullable() private final java.util.List> fld = null; @org.jetbrains.annotations.Nullable() + @kapt.internal.KaptSignature(value = "getFld()Ljava/util/List;") public final java.util.List> getFld() { return null; } + @kapt.internal.KaptSignature(value = "()V") public MyClass() { super(); } @@ -58,5 +68,24 @@ public final class MyClass { } + +//////////////////// + +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/ignoredMembers.txt b/plugins/kapt3/kapt3-compiler/testData/converter/ignoredMembers.txt index 3a402a1c451..51d1f841ee8 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/ignoredMembers.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/ignoredMembers.txt @@ -1,17 +1,41 @@ @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class Test { + @org.jetbrains.annotations.NotNull() + private final java.lang.String ignoredProperty = ""; @org.jetbrains.annotations.NotNull() private final java.lang.String nonIgnoredProperty = ""; + @kapt.internal.KaptSignature(value = "nonIgnoredFun()V") public final void nonIgnoredFun() { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "getNonIgnoredProperty()Ljava/lang/String;") public final java.lang.String getNonIgnoredProperty() { return null; } + @kapt.internal.KaptSignature(value = "()V") public Test() { super(); } } + +//////////////////// + +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/importsForErrorTypes.txt b/plugins/kapt3/kapt3-compiler/testData/converter/importsForErrorTypes.txt index d41ddb6e733..f69524ad4cb 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/importsForErrorTypes.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/importsForErrorTypes.txt @@ -6,6 +6,7 @@ import java.util.concurrent.TimeUnit.*; import java.util.Calendar.*; @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class ImportsForErrorTypesKt { public ImportsForErrorTypesKt() { @@ -13,7 +14,26 @@ public final class ImportsForErrorTypesKt { } @org.jetbrains.annotations.Nullable() + @kapt.internal.KaptSignature(value = "test()Ljava/lang/Object;") public static final java.lang.Object test() { return null; } } + +//////////////////// + +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/inheritanceSimple.txt b/plugins/kapt3/kapt3-compiler/testData/converter/inheritanceSimple.txt index 8eb9fc08e7e..fa01226538e 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/inheritanceSimple.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/inheritanceSimple.txt @@ -1,9 +1,12 @@ @kotlin.Metadata() +@kapt.internal.KaptMetadata() public abstract class BaseClass { @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "doJob()LResult;") public abstract Result doJob(); + @kapt.internal.KaptSignature(value = "(LContext;IZ)V") public BaseClass(@org.jetbrains.annotations.NotNull() Context context, int num, boolean bool) { super(); @@ -14,6 +17,7 @@ public abstract class BaseClass { @kotlin.Metadata() +@kapt.internal.KaptMetadata() public abstract interface Context { } @@ -21,14 +25,17 @@ public abstract interface Context { @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class Inheritor extends BaseClass { @org.jetbrains.annotations.NotNull() @java.lang.Override() + @kapt.internal.KaptSignature(value = "doJob()LResult;") public Result doJob() { return null; } + @kapt.internal.KaptSignature(value = "(LContext;)V") public Inheritor(@org.jetbrains.annotations.NotNull() Context context) { super(null, 0, false); @@ -39,10 +46,30 @@ public final class Inheritor extends BaseClass { @kotlin.Metadata() +@kapt.internal.KaptMetadata() public enum Result { - /*public static final*/ SUCCESS /* = new SUCCESS() */, - /*public static final*/ ERROR /* = new ERROR() */; + /*public static final*/ SUCCESS /* = new Result() */, + /*public static final*/ ERROR /* = new Result() */; + @kapt.internal.KaptSignature(value = "(Ljava/lang/String;I)V") Result() { } } + +//////////////////// + +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/innerClassesWithTypeParameters.txt b/plugins/kapt3/kapt3-compiler/testData/converter/innerClassesWithTypeParameters.txt index cbd97275789..74b7f0df06f 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/innerClassesWithTypeParameters.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/innerClassesWithTypeParameters.txt @@ -1,7 +1,9 @@ @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class Test { private Test.FilterValueDelegate a; + @kapt.internal.KaptSignature(value = "()V") public Test() { super(); } @@ -9,6 +11,7 @@ public final class Test { @kotlin.Metadata() final class FilterValueDelegate { + @kapt.internal.KaptSignature(value = "(LTest;)V") public FilterValueDelegate() { super(); } @@ -19,8 +22,10 @@ public final class Test { @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class Test2 { + @kapt.internal.KaptSignature(value = "()V") public Test2() { super(); } @@ -29,6 +34,7 @@ public final class Test2 { public final class FilterValueDelegate { private Test2.FilterValueDelegate.Filter2 a; + @kapt.internal.KaptSignature(value = "(LTest2;)V") public FilterValueDelegate() { super(); } @@ -36,6 +42,7 @@ public final class Test2 { @kotlin.Metadata() public final class Filter2 { + @kapt.internal.KaptSignature(value = "(LTest2$FilterValueDelegate;)V") public Filter2() { super(); } @@ -47,9 +54,11 @@ public final class Test2 { @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class Test3 { private Test3.FilterValueDelegate a; + @kapt.internal.KaptSignature(value = "()V") public Test3() { super(); } @@ -57,8 +66,27 @@ public final class Test3 { @kotlin.Metadata() static final class FilterValueDelegate { + @kapt.internal.KaptSignature(value = "()V") public FilterValueDelegate() { super(); } } } + +//////////////////// + +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/invalidFieldName.kt b/plugins/kapt3/kapt3-compiler/testData/converter/invalidFieldName.kt index e88918a4d1f..b39a3769a32 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/invalidFieldName.kt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/invalidFieldName.kt @@ -1,6 +1,5 @@ -// EXPECTED_ERROR 'WHI-TE' is an invalid Java enum value name -// EXPECTED_ERROR an enum annotation value must be an enum constant -// EXPECTED_ERROR cannot find symbol +// EXPECTED_ERROR(-1;-1) 'WHI-TE' is an invalid Java enum value name +// EXPECTED_ERROR(4;20) cannot find symbol (Kotlin location: /invalidFieldName.kt: (8, 1)) enum class Color { BLACK, `WHI-TE` diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/invalidFieldName.txt b/plugins/kapt3/kapt3-compiler/testData/converter/invalidFieldName.txt index 35c47513c05..8f654b17423 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/invalidFieldName.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/invalidFieldName.txt @@ -1,8 +1,10 @@ @kotlin.Metadata() @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME) @Anno(color = Color.InvalidFieldName) +@kapt.internal.KaptMetadata() public abstract @interface Anno { + @kapt.internal.KaptSignature(value = "color()LColor;") public abstract Color color(); } @@ -10,9 +12,29 @@ public abstract @interface Anno { @kotlin.Metadata() +@kapt.internal.KaptMetadata() public enum Color { - /*public static final*/ BLACK /* = new BLACK() */; + /*public static final*/ BLACK /* = new Color() */; + @kapt.internal.KaptSignature(value = "(Ljava/lang/String;I)V") Color() { } } + +//////////////////// + +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/javaKeywords.txt b/plugins/kapt3/kapt3-compiler/testData/converter/javaKeywords.txt index 8b137891791..cb11bb99b4c 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/javaKeywords.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/javaKeywords.txt @@ -1 +1,15 @@ +package kapt.internal; +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/javaKeywordsInPackageNames.txt b/plugins/kapt3/kapt3-compiler/testData/converter/javaKeywordsInPackageNames.txt index a93f52c5781..fda3f9eb36d 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/javaKeywordsInPackageNames.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/javaKeywordsInPackageNames.txt @@ -1,8 +1,10 @@ package a.b.c; @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class A { + @kapt.internal.KaptSignature(value = "()V") public A() { super(); } @@ -13,9 +15,29 @@ public final class A { package a.b.typealias.c; @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class E { + @kapt.internal.KaptSignature(value = "()V") public E() { super(); } } + +//////////////////// + +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/jvmOverloads.txt b/plugins/kapt3/kapt3-compiler/testData/converter/jvmOverloads.txt index 827dd942b68..c6a5b78dd5d 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/jvmOverloads.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/jvmOverloads.txt @@ -1,28 +1,34 @@ @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class State { private final int someInt = 0; private final long someLong = 0L; @org.jetbrains.annotations.NotNull() private final java.lang.String someString = null; + @kapt.internal.KaptSignature(value = "getSomeInt()I") public final int getSomeInt() { return 0; } + @kapt.internal.KaptSignature(value = "getSomeLong()J") public final long getSomeLong() { return 0L; } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "getSomeString()Ljava/lang/String;") public final java.lang.String getSomeString() { return null; } + @kapt.internal.KaptSignature(value = "(IJLjava/lang/String;)V") public State(int someInt, long someLong, @org.jetbrains.annotations.NotNull() java.lang.String someString) { super(); } + @kapt.internal.KaptSignature(value = "(IJ)V") public State(int someInt, long someLong) { super(); } @@ -32,42 +38,69 @@ public final class State { @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class State2 { public final int someInt = 0; public final long someLong = 0L; @org.jetbrains.annotations.NotNull() public final java.lang.String someString = null; + @kapt.internal.KaptSignature(value = "test(IJLjava/lang/String;)I") public final int test(int someInt, long someLong, @org.jetbrains.annotations.NotNull() java.lang.String someString) { return 0; } + @kapt.internal.KaptSignature(value = "test(IJ)I") public final int test(int someInt, long someLong) { return 0; } + @kapt.internal.KaptSignature(value = "test(I)I") public final int test(int someInt) { return 0; } + @kapt.internal.KaptSignature(value = "someMethod(Ljava/lang/String;)V") public final void someMethod(@org.jetbrains.annotations.NotNull() java.lang.String str) { } + @kapt.internal.KaptSignature(value = "methodWithoutArgs()V") public final void methodWithoutArgs() { } + @kapt.internal.KaptSignature(value = "(IJLjava/lang/String;)V") public State2(int someInt, long someLong, @org.jetbrains.annotations.NotNull() java.lang.String someString) { super(); } + @kapt.internal.KaptSignature(value = "(IJ)V") public State2(int someInt, long someLong) { super(); } + @kapt.internal.KaptSignature(value = "(I)V") public State2(int someInt) { super(); } } + +//////////////////// + +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/jvmStatic.txt b/plugins/kapt3/kapt3-compiler/testData/converter/jvmStatic.txt index 8ed14d8a143..ce3bde3df2c 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/jvmStatic.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/jvmStatic.txt @@ -1,4 +1,5 @@ @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class JvmStaticTest { private final byte three = (byte)3; private final char d = 'D'; @@ -7,18 +8,22 @@ public final class JvmStaticTest { public static final char c = 'C'; public static final JvmStaticTest.Companion Companion = null; + @kapt.internal.KaptSignature(value = "getThree()B") public final byte getThree() { return 0; } + @kapt.internal.KaptSignature(value = "getD()C") public final char getD() { return '\u0000'; } + @kapt.internal.KaptSignature(value = "()V") public JvmStaticTest() { super(); } + @kapt.internal.KaptSignature(value = "getOne()I") public static final int getOne() { return 0; } @@ -26,19 +31,41 @@ public final class JvmStaticTest { @kotlin.Metadata() public static final class Companion { + @kapt.internal.KaptSignature(value = "one$annotations()V") public static void one$annotations() { } + @kapt.internal.KaptSignature(value = "getOne()I") public final int getOne() { return 0; } + @kapt.internal.KaptSignature(value = "getTwo()I") public final int getTwo() { return 0; } + @kapt.internal.KaptSignature(value = "()V") private Companion() { super(); } } } + +//////////////////// + +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/jvmStaticFieldInParent.txt b/plugins/kapt3/kapt3-compiler/testData/converter/jvmStaticFieldInParent.txt index 38982ca0847..b949ae7c942 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/jvmStaticFieldInParent.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/jvmStaticFieldInParent.txt @@ -1,14 +1,17 @@ @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class Test { @org.jetbrains.annotations.NotNull() private static final java.lang.String test = ""; public static final Test.A A = null; + @kapt.internal.KaptSignature(value = "()V") public Test() { super(); } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "getTest()Ljava/lang/String;") public static final java.lang.String getTest() { return null; } @@ -16,16 +19,37 @@ public final class Test { @kotlin.Metadata() public static final class A { + @kapt.internal.KaptSignature(value = "test$annotations()V") public static void test$annotations() { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "getTest()Ljava/lang/String;") public final java.lang.String getTest() { return null; } + @kapt.internal.KaptSignature(value = "()V") private A() { super(); } } } + +//////////////////// + +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/kt14996.txt b/plugins/kapt3/kapt3-compiler/testData/converter/kt14996.txt index fe0d1934cd5..ef671362708 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/kt14996.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/kt14996.txt @@ -1,4 +1,5 @@ @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class Kt14996Kt { public Kt14996Kt() { @@ -6,14 +7,34 @@ public final class Kt14996Kt { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "crashMe(Ljava/util/List;)Ljava/lang/String;") public static final java.lang.String crashMe(@org.jetbrains.annotations.NotNull() java.util.List values) { return null; } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "crashMe(Ljava/util/List;)Ljava/lang/CharSequence;") public static final java.lang.CharSequence crashMe(@org.jetbrains.annotations.NotNull() java.util.List values) { return null; } } + +//////////////////// + +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/kt14997.txt b/plugins/kapt3/kapt3-compiler/testData/converter/kt14997.txt index 5036cb601bc..2a3794a5ad2 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/kt14997.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/kt14997.txt @@ -1,7 +1,9 @@ @kotlin.Metadata() +@kapt.internal.KaptMetadata() public class CrashMe { private final java.lang.Runnable notReally = null; + @kapt.internal.KaptSignature(value = "()V") public CrashMe() { super(); } @@ -12,6 +14,7 @@ public class CrashMe { @kotlin.Suppress(names = {"AMBIGUOUS_ANONYMOUS_TYPE_INFERRED"}) @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class Kt14997Kt { public Kt14997Kt() { @@ -19,17 +22,38 @@ public final class Kt14997Kt { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "a()Ljava/lang/Runnable;") public static final java.lang.Runnable a() { return null; } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "b()LKt14997Kt$b$1;") public static final java.lang.Runnable b() { return null; } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "c()LKt14997Kt$c$1;") public static final CrashMe c() { return null; } } + +//////////////////// + +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/kt14998.txt b/plugins/kapt3/kapt3-compiler/testData/converter/kt14998.txt index 51fe76722a5..37c20bfdd16 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/kt14998.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/kt14998.txt @@ -1,10 +1,13 @@ @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class Outer { + @kapt.internal.KaptSignature(value = "nonAbstract(Ljava/lang/String;I)V") public final void nonAbstract(@org.jetbrains.annotations.NotNull() java.lang.String s, int i) { } + @kapt.internal.KaptSignature(value = "()V") public Outer() { super(); } @@ -17,15 +20,18 @@ public final class Outer { private final java.lang.String bar = null; @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "getFoo()Ljava/lang/String;") public final java.lang.String getFoo() { return null; } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "getBar()Ljava/lang/String;") public final java.lang.String getBar() { return null; } + @kapt.internal.KaptSignature(value = "(LOuter;Ljava/lang/String;Ljava/lang/String;)V") public Inner(@org.jetbrains.annotations.NotNull() java.lang.String foo, @org.jetbrains.annotations.NotNull() java.lang.String bar) { @@ -41,15 +47,18 @@ public final class Outer { private final java.lang.String bar = null; @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "getFoo()Ljava/lang/String;") public final java.lang.String getFoo() { return null; } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "getBar()Ljava/lang/String;") public final java.lang.String getBar() { return null; } + @kapt.internal.KaptSignature(value = "(Ljava/lang/String;Ljava/lang/String;)V") public Nested(@org.jetbrains.annotations.NotNull() java.lang.String foo, @org.jetbrains.annotations.NotNull() java.lang.String bar) { @@ -57,3 +66,21 @@ public final class Outer { } } } + +//////////////////// + +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/kt15145.txt b/plugins/kapt3/kapt3-compiler/testData/converter/kt15145.txt index e83fd18a317..043b3786799 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/kt15145.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/kt15145.txt @@ -1,13 +1,34 @@ @kotlin.Metadata() +@kapt.internal.KaptMetadata() public abstract interface MyInterface { + @kapt.internal.KaptSignature(value = "someFun()V") public abstract void someFun(); @kotlin.Metadata() public static final class MyDefaultInferface { + @kapt.internal.KaptSignature(value = "()V") public MyDefaultInferface() { super(); } } } + +//////////////////// + +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/kt17567.txt b/plugins/kapt3/kapt3-compiler/testData/converter/kt17567.txt index c0ff08774ce..b0a46f371c8 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/kt17567.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/kt17567.txt @@ -1,15 +1,36 @@ +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} + +//////////////////// + package test; @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class MutableEntry implements java.util.Map.Entry, kotlin.jvm.internal.markers.KMutableMap.Entry { private final java.util.Map internal = null; private final K key = null; @java.lang.Override() + @kapt.internal.KaptSignature(value = "getKey()Ljava/lang/Object;") public K getKey() { return null; } + @kapt.internal.KaptSignature(value = "(Ljava/util/Map;Ljava/lang/Object;Ljava/lang/Object;)V") public MutableEntry(@org.jetbrains.annotations.NotNull() java.util.Map internal, K key, V value) { super(); diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/kt18377.txt b/plugins/kapt3/kapt3-compiler/testData/converter/kt18377.txt index 34284ec82db..4acc6de0bd7 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/kt18377.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/kt18377.txt @@ -1,4 +1,5 @@ @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class Kt18377Kt { public Kt18377Kt() { @@ -6,7 +7,26 @@ public final class Kt18377Kt { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "Date(D)Ljava/util/Date;") public static final java.util.Date Date(double p0_1484504552) { return null; } } + +//////////////////// + +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/kt18682.txt b/plugins/kapt3/kapt3-compiler/testData/converter/kt18682.txt index e02c7426051..a9c9a278f5f 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/kt18682.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/kt18682.txt @@ -1,6 +1,8 @@ @kotlin.Metadata() +@kapt.internal.KaptMetadata() public abstract class Foo { + @kapt.internal.KaptSignature(value = "()V") public Foo() { super(); } @@ -10,6 +12,7 @@ public abstract class Foo { @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class Kt18682Kt { public Kt18682Kt() { @@ -17,22 +20,44 @@ public final class Kt18682Kt { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "test1()Ljava/util/List;") public static final java.util.List test1() { return null; } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "test2()Ljava/util/List;") public static final java.util.List test2() { return null; } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "test3()Ljava/util/List;") public static final java.util.List test3() { return null; } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "test4()Ljava/util/List;") public static final java.util.List test4() { return null; } } + +//////////////////// + +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/kt18791.txt b/plugins/kapt3/kapt3-compiler/testData/converter/kt18791.txt index 24fe2663978..5d344d3b7a1 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/kt18791.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/kt18791.txt @@ -1,5 +1,42 @@ package app; +@kotlin.Metadata() +@java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME) +@kapt.internal.KaptMetadata() +public abstract @interface Anno { + + @kapt.internal.KaptSignature(value = "a1()Z") + public abstract boolean a1(); + + @kapt.internal.KaptSignature(value = "a2()B") + public abstract byte a2(); + + @kapt.internal.KaptSignature(value = "a3()I") + public abstract int a3(); + + @kapt.internal.KaptSignature(value = "a4()S") + public abstract short a4(); + + @kapt.internal.KaptSignature(value = "a5()J") + public abstract long a5(); + + @kapt.internal.KaptSignature(value = "a6()C") + public abstract char a6(); + + @kapt.internal.KaptSignature(value = "a7()F") + public abstract float a7(); + + @kapt.internal.KaptSignature(value = "a8()D") + public abstract double a8(); + + @kapt.internal.KaptSignature(value = "a9()Ljava/lang/String;") + public abstract java.lang.String a9(); +} + +//////////////////// + +package app; + public class B { public B() { @@ -28,6 +65,83 @@ public class B { package app; +@kotlin.Metadata() +@java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME) +@kapt.internal.KaptMetadata() +public abstract @interface Bind { + + @kapt.internal.KaptSignature(value = "id()I") + public abstract int id(); +} + +//////////////////// + +package app; + +@kotlin.Metadata() +@kapt.internal.KaptMetadata() +public final class MyActivity { + + @Bind(id = lib.R.id.textView) + @kapt.internal.KaptSignature(value = "foo()V") + public final void foo() { + } + + @Bind(id = lib.R.id.textView) + @kapt.internal.KaptSignature(value = "foo2()V") + public final void foo2() { + } + + @Bind(id = app.R.layout.mainActivity) + @kapt.internal.KaptSignature(value = "foo3()V") + public final void foo3() { + } + + @Bind(id = app.R.layout.mainActivity) + @kapt.internal.KaptSignature(value = "foo4()V") + public final void foo4() { + } + + @Anno(a1 = app.B.a1, a2 = app.B.a2, a3 = app.B.a3, a4 = app.B.a4, a5 = app.B.a5, a6 = app.B.a6, a7 = app.B.a7, a8 = app.B.a8, a9 = "A") + @Bind(id = app.R2.layout.mainActivity) + @kapt.internal.KaptSignature(value = "foo5()V") + public final void foo5() { + } + + @Bind(id = app.B.id.textView) + @kapt.internal.KaptSignature(value = "plainIntConstant()V") + public final void plainIntConstant() { + } + + @kapt.internal.KaptSignature(value = "()V") + public MyActivity() { + super(); + } +} + +//////////////////// + +package app; + +public class R { + + public R() { + super(); + } + + public static class layout { + + public layout() { + super(); + } + public static final int mainActivity = 100; + } +} + +//////////////////// + +package app; + public class R2 { public R2() { @@ -45,6 +159,24 @@ public class R2 { //////////////////// +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} + +//////////////////// + package lib; public class R { @@ -61,97 +193,3 @@ public class R { public static final int textView = 100; } } - -//////////////////// - -package app; - -public class R { - - public R() { - super(); - } - - public static class layout { - - public layout() { - super(); - } - public static final int mainActivity = 100; - } -} - -//////////////////// - -package app; - -@kotlin.Metadata() -@java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME) -public abstract @interface Anno { - - public abstract boolean a1(); - - public abstract byte a2(); - - public abstract int a3(); - - public abstract short a4(); - - public abstract long a5(); - - public abstract char a6(); - - public abstract float a7(); - - public abstract double a8(); - - public abstract java.lang.String a9(); -} - -//////////////////// - -package app; - -@kotlin.Metadata() -@java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME) -public abstract @interface Bind { - - public abstract int id(); -} - -//////////////////// - -package app; - -@kotlin.Metadata() -public final class MyActivity { - - @Bind(id = lib.R.id.textView) - public final void foo() { - } - - @Bind(id = lib.R.id.textView) - public final void foo2() { - } - - @Bind(id = app.R.layout.mainActivity) - public final void foo3() { - } - - @Bind(id = app.R.layout.mainActivity) - public final void foo4() { - } - - @Anno(a1 = app.B.a1, a2 = app.B.a2, a3 = app.B.a3, a4 = app.B.a4, a5 = app.B.a5, a6 = app.B.a6, a7 = app.B.a7, a8 = app.B.a8, a9 = "A") - @Bind(id = app.R2.layout.mainActivity) - public final void foo5() { - } - - @Bind(id = app.B.id.textView) - public final void plainIntConstant() { - } - - public MyActivity() { - super(); - } -} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/kt19700.txt b/plugins/kapt3/kapt3-compiler/testData/converter/kt19700.txt index a357c1ae126..65630c657a6 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/kt19700.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/kt19700.txt @@ -1,8 +1,28 @@ +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} + +//////////////////// + package test; @kotlin.Metadata() +@kapt.internal.KaptMetadata() public abstract interface ListUpdateCallback { + @kapt.internal.KaptSignature(value = "onInserted(II)V") public abstract void onInserted(int position, int count); } @@ -11,9 +31,11 @@ public abstract interface ListUpdateCallback { package test; @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class Test { private final test.ListUpdateCallback x = null; + @kapt.internal.KaptSignature(value = "()V") public Test() { super(); } diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/kt19750.txt b/plugins/kapt3/kapt3-compiler/testData/converter/kt19750.txt index 9a062a45135..cdbca40f0fc 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/kt19750.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/kt19750.txt @@ -1,9 +1,29 @@ +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} + +//////////////////// + package test; @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class Test { private final test.TypedListUpdateCallback x = null; + @kapt.internal.KaptSignature(value = "()V") public Test() { super(); } @@ -14,8 +34,10 @@ public final class Test { + @kapt.internal.KaptSignature(value = "onInserted(Ljava/lang/Number;Ljava/lang/Number;Ljava/lang/Object;)V") public abstract void onInserted(@org.jetbrains.annotations.NotNull() C position, @org.jetbrains.annotations.NotNull() C count, @org.jetbrains.annotations.NotNull() diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/mapEntry.txt b/plugins/kapt3/kapt3-compiler/testData/converter/mapEntry.txt index 1fab800ca1c..f4ae55338a2 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/mapEntry.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/mapEntry.txt @@ -1,10 +1,31 @@ @kotlin.Metadata() +@kapt.internal.KaptMetadata() public abstract interface EntryHolder { @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "entry(Ljava/util/Map$Entry;)Ljava/util/Map$Entry;") public abstract java.util.Map.Entry entry(@org.jetbrains.annotations.NotNull() java.util.Map.Entry> p); @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "getEntryProperty()Ljava/util/Map$Entry;") public abstract java.util.Map.Entry getEntryProperty(); } + +//////////////////// + +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/methodParameterNames.txt b/plugins/kapt3/kapt3-compiler/testData/converter/methodParameterNames.txt index b6e36a2a0db..35284513338 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/methodParameterNames.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/methodParameterNames.txt @@ -1,14 +1,18 @@ @kotlin.Metadata() +@kapt.internal.KaptMetadata() public abstract class Cls { + @kapt.internal.KaptSignature(value = "foo(Ljava/lang/String;)V") public abstract void foo(@org.jetbrains.annotations.NotNull() java.lang.String abc); @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "bar(I)Ljava/lang/String;") public final java.lang.String bar(int bcd) { return null; } + @kapt.internal.KaptSignature(value = "()V") public Cls() { super(); } @@ -18,12 +22,15 @@ public abstract class Cls { @kotlin.Metadata() +@kapt.internal.KaptMetadata() public abstract interface Intf { + @kapt.internal.KaptSignature(value = "foo(Ljava/lang/String;)V") public abstract void foo(@org.jetbrains.annotations.NotNull() java.lang.String abc); @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "bar(I)Ljava/lang/String;") public abstract java.lang.String bar(int bcd); @kotlin.Metadata() @@ -34,8 +41,27 @@ public abstract interface Intf { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "bar(LIntf;I)Ljava/lang/String;") public static java.lang.String bar(Intf $this, int bcd) { return null; } } } + +//////////////////// + +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/methodPropertySignatureClash.txt b/plugins/kapt3/kapt3-compiler/testData/converter/methodPropertySignatureClash.txt index e10bf958be1..44d4364e4aa 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/methodPropertySignatureClash.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/methodPropertySignatureClash.txt @@ -1,17 +1,39 @@ @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class CrashMe { private final int resources = 1; + @kapt.internal.KaptSignature(value = "getResources()I") public final int getResources() { return 0; } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "getResources()Ljava/lang/String;") public final java.lang.String getResources() { return null; } + @kapt.internal.KaptSignature(value = "()V") public CrashMe() { super(); } } + +//////////////////// + +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/modifiers.txt b/plugins/kapt3/kapt3-compiler/testData/converter/modifiers.txt index 9229e8fe495..d84cc3ae5f6 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/modifiers.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/modifiers.txt @@ -1,8 +1,28 @@ +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} + +//////////////////// + package modifiers; @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class InternalClass { + @kapt.internal.KaptSignature(value = "()V") public InternalClass() { super(); } @@ -13,6 +33,7 @@ public final class InternalClass { package modifiers; @kotlin.Metadata() +@kapt.internal.KaptMetadata() public abstract interface InternalInterface { } @@ -21,6 +42,7 @@ public abstract interface InternalInterface { package modifiers; @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class Modifiers { @org.jetbrains.annotations.NotNull() private final transient java.lang.String transientField = ""; @@ -28,39 +50,47 @@ public final class Modifiers { private volatile java.lang.String volatileField; @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "getTransientField()Ljava/lang/String;") public final java.lang.String getTransientField() { return null; } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "getVolatileField()Ljava/lang/String;") public final java.lang.String getVolatileField() { return null; } + @kapt.internal.KaptSignature(value = "setVolatileField(Ljava/lang/String;)V") public final void setVolatileField(@org.jetbrains.annotations.NotNull() java.lang.String p0) { } + @kapt.internal.KaptSignature(value = "strictFp()V") public final strictfp void strictFp() { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "overloads(Ljava/lang/String;I)Ljava/lang/String;") public final java.lang.String overloads(@org.jetbrains.annotations.NotNull() java.lang.String a, int n) { return null; } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "overloads(Ljava/lang/String;)Ljava/lang/String;") public final java.lang.String overloads(@org.jetbrains.annotations.NotNull() java.lang.String a) { return null; } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "overloads()Ljava/lang/String;") public final java.lang.String overloads() { return null; } + @kapt.internal.KaptSignature(value = "()V") public Modifiers() { super(); } @@ -71,8 +101,10 @@ public final class Modifiers { package modifiers; @kotlin.Metadata() +@kapt.internal.KaptMetadata() final class PrivateClass { + @kapt.internal.KaptSignature(value = "()V") public PrivateClass() { super(); } @@ -83,6 +115,7 @@ final class PrivateClass { package modifiers; @kotlin.Metadata() +@kapt.internal.KaptMetadata() abstract interface PrivateInterface { } @@ -91,8 +124,10 @@ abstract interface PrivateInterface { package modifiers; @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class PublicClass { + @kapt.internal.KaptSignature(value = "()V") public PublicClass() { super(); } @@ -103,8 +138,10 @@ public final class PublicClass { package modifiers; @kotlin.Metadata() +@kapt.internal.KaptMetadata() public abstract class PublicClassPrivateConstructor { + @kapt.internal.KaptSignature(value = "()V") private PublicClassPrivateConstructor() { super(); } @@ -115,8 +152,10 @@ public abstract class PublicClassPrivateConstructor { package modifiers; @kotlin.Metadata() +@kapt.internal.KaptMetadata() public class PublicClassProtectedConstructor { + @kapt.internal.KaptSignature(value = "()V") protected PublicClassProtectedConstructor() { super(); } @@ -135,6 +174,7 @@ public class PublicClassProtectedConstructor { package modifiers; @kotlin.Metadata() +@kapt.internal.KaptMetadata() public abstract interface PublicInterface { } @@ -143,8 +183,10 @@ public abstract interface PublicInterface { package modifiers; @kotlin.Metadata() +@kapt.internal.KaptMetadata() public abstract class SealedClass { + @kapt.internal.KaptSignature(value = "()V") private SealedClass() { super(); } @@ -152,6 +194,7 @@ public abstract class SealedClass { @kotlin.Metadata() public static final class One extends modifiers.SealedClass { + @kapt.internal.KaptSignature(value = "()V") public One() { super(); } @@ -160,6 +203,7 @@ public abstract class SealedClass { @kotlin.Metadata() public static class Two extends modifiers.SealedClass { + @kapt.internal.KaptSignature(value = "()V") public Two() { super(); } @@ -168,6 +212,7 @@ public abstract class SealedClass { @kotlin.Metadata() public static abstract class Three extends modifiers.SealedClass.Two { + @kapt.internal.KaptSignature(value = "()V") public Three() { super(); } @@ -176,6 +221,7 @@ public abstract class SealedClass { @kotlin.Metadata() public static final class Four extends modifiers.SealedClass.Three { + @kapt.internal.KaptSignature(value = "()V") public Four() { super(); } diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/multifileClass.txt b/plugins/kapt3/kapt3-compiler/testData/converter/multifileClass.txt index 1c341e16481..2faab7c4e0a 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/multifileClass.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/multifileClass.txt @@ -1,15 +1,36 @@ +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} + +//////////////////// + package test; @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class M1 { public M1() { super(); } + @kapt.internal.KaptSignature(value = "bar()V") public static final void bar() { } + @kapt.internal.KaptSignature(value = "foo()V") public static final void foo() { } } @@ -19,12 +40,14 @@ public final class M1 { package test; @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class M2 { public M2() { super(); } + @kapt.internal.KaptSignature(value = "baz()V") public static final void baz() { } } diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/nestedClasses.txt b/plugins/kapt3/kapt3-compiler/testData/converter/nestedClasses.txt index 36c1398acd3..6a60c62c434 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/nestedClasses.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/nestedClasses.txt @@ -1,20 +1,24 @@ @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class A { @org.jetbrains.annotations.Nullable() private final A x = null; @org.jetbrains.annotations.Nullable() + @kapt.internal.KaptSignature(value = "getX()LA;") public final A getX() { return null; } @org.jetbrains.annotations.Nullable() + @kapt.internal.KaptSignature(value = "f1(LA;LA$B;)LA;") public final A f1(@org.jetbrains.annotations.NotNull() A a, @org.jetbrains.annotations.NotNull() A.B b) { return null; } + @kapt.internal.KaptSignature(value = "()V") public A() { super(); } @@ -23,6 +27,7 @@ public final class A { public static abstract interface B { @org.jetbrains.annotations.Nullable() + @kapt.internal.KaptSignature(value = "getY()LA$B;") public abstract A.B getY(); @kotlin.Metadata() @@ -38,6 +43,7 @@ public final class A { public static final class C { public static final A.C INSTANCE = null; + @kapt.internal.KaptSignature(value = "()V") private C() { super(); } @@ -48,8 +54,10 @@ public final class A { @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class A2 { + @kapt.internal.KaptSignature(value = "()V") public A2() { super(); } @@ -57,6 +65,7 @@ public final class A2 { @kotlin.Metadata() public static final class B { + @kapt.internal.KaptSignature(value = "()V") public B() { super(); } @@ -64,6 +73,7 @@ public final class A2 { @kotlin.Metadata() public static final class C { + @kapt.internal.KaptSignature(value = "()V") public C() { super(); } @@ -71,6 +81,7 @@ public final class A2 { @kotlin.Metadata() public static final class D { + @kapt.internal.KaptSignature(value = "()V") public D() { super(); } @@ -78,6 +89,7 @@ public final class A2 { @kotlin.Metadata() public static final class Cme { + @kapt.internal.KaptSignature(value = "()V") public Cme() { super(); } @@ -86,6 +98,7 @@ public final class A2 { @kotlin.Metadata() public static final class E { + @kapt.internal.KaptSignature(value = "()V") public E() { super(); } @@ -99,8 +112,10 @@ public final class A2 { @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class Foo { + @kapt.internal.KaptSignature(value = "()V") public Foo() { super(); } @@ -110,8 +125,10 @@ public final class Foo { @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class Test { + @kapt.internal.KaptSignature(value = "()V") public Test() { super(); } @@ -119,6 +136,7 @@ public final class Test { @kotlin.Metadata() public static final class Nested { + @kapt.internal.KaptSignature(value = "()V") public Nested() { super(); } @@ -126,6 +144,7 @@ public final class Test { @kotlin.Metadata() public static final class NestedNested { + @kapt.internal.KaptSignature(value = "()V") public NestedNested() { super(); } @@ -135,6 +154,7 @@ public final class Test { @kotlin.Metadata() public final class Inner { + @kapt.internal.KaptSignature(value = "(LTest;)V") public Inner() { super(); } @@ -144,6 +164,7 @@ public final class Test { public static final class NestedObject { public static final Test.NestedObject INSTANCE = null; + @kapt.internal.KaptSignature(value = "()V") private NestedObject() { super(); } @@ -155,10 +176,29 @@ public final class Test { @kotlin.Metadata() public static enum NestedEnum { - /*public static final*/ BLACK /* = new BLACK() */, - /*public static final*/ WHITE /* = new WHITE() */; + /*public static final*/ BLACK /* = new NestedEnum() */, + /*public static final*/ WHITE /* = new NestedEnum() */; + @kapt.internal.KaptSignature(value = "(Ljava/lang/String;I)V") NestedEnum() { } } } + +//////////////////// + +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/nestedClasses2.txt b/plugins/kapt3/kapt3-compiler/testData/converter/nestedClasses2.txt index b69062897f5..c6121dd3ce7 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/nestedClasses2.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/nestedClasses2.txt @@ -1,3 +1,187 @@ +@kotlin.Metadata() +@kapt.internal.KaptMetadata() +public final class A$B { + @org.jetbrains.annotations.NotNull() + public A$B.C c; + @org.jetbrains.annotations.NotNull() + public A$B.D$E de; + @org.jetbrains.annotations.NotNull() + public J$B.C jc; + @org.jetbrains.annotations.NotNull() + public J$B.D$E jde; + @org.jetbrains.annotations.NotNull() + public A$B.D$$E dee; + @org.jetbrains.annotations.NotNull() + public A$B.D$$$E deee; + @org.jetbrains.annotations.NotNull() + public J$B.D$$E jdee; + @org.jetbrains.annotations.NotNull() + public J$B.D$$$E jdeee; + + @kapt.internal.KaptSignature(value = "()V") + public A$B() { + super(); + } + + @kotlin.Metadata() + public static final class C { + + @kapt.internal.KaptSignature(value = "()V") + public C() { + super(); + } + } + + @kotlin.Metadata() + public static final class D$E { + @org.jetbrains.annotations.NotNull() + public A$B.D$E.F f; + @org.jetbrains.annotations.NotNull() + public A$B.D$E.F$G fg; + @org.jetbrains.annotations.NotNull() + public J$B.D$E.F jf; + @org.jetbrains.annotations.NotNull() + public J$B.D$E.F$G jfg; + + @kapt.internal.KaptSignature(value = "()V") + public D$E() { + super(); + } + + @kotlin.Metadata() + public static final class F { + + @kapt.internal.KaptSignature(value = "()V") + public F() { + super(); + } + } + + @kotlin.Metadata() + public static final class F$G { + + @kapt.internal.KaptSignature(value = "()V") + public F$G() { + super(); + } + } + } + + @kotlin.Metadata() + public static final class D$$E { + + @kapt.internal.KaptSignature(value = "()V") + public D$$E() { + super(); + } + } + + @kotlin.Metadata() + public static final class D$$$E { + + @kapt.internal.KaptSignature(value = "()V") + public D$$$E() { + super(); + } + } +} + +//////////////////// + + +@kotlin.Metadata() +@kapt.internal.KaptMetadata() +public final class Experiment { + + @kapt.internal.KaptSignature(value = "()V") + public Experiment() { + super(); + } + + @kotlin.Metadata() + @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME) + public static abstract @interface Type { + } + + @kotlin.Metadata() + @Experiment.Type() + public static final class Group { + + @kapt.internal.KaptSignature(value = "(Ljava/lang/String;)V") + public Group(@org.jetbrains.annotations.NotNull() + java.lang.String s) { + super(); + } + + @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "copy(Ljava/lang/String;)LExperiment$Group;") + public final Experiment.Group copy(@org.jetbrains.annotations.NotNull() + java.lang.String s) { + return null; + } + } +} + +//////////////////// + + +@kotlin.Metadata() +@kapt.internal.KaptMetadata() +public final class Foo { + + @kapt.internal.KaptSignature(value = "()V") + public Foo() { + super(); + } + + @kotlin.Metadata() + public static class Bar { + + @kapt.internal.KaptSignature(value = "()V") + public Bar() { + super(); + } + + @kotlin.Metadata() + public static final class Zoo { + public static final Foo.Bar.Zoo INSTANCE = null; + + @kapt.internal.KaptSignature(value = "()V") + private Zoo() { + super(); + } + } + } +} + +//////////////////// + + +@kotlin.Metadata() +@kapt.internal.KaptMetadata() +public abstract interface IFoo { + + @kotlin.Metadata() + public static abstract interface IBar { + + @kotlin.Metadata() + @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME) + public static abstract @interface Anno { + + @kapt.internal.KaptSignature(value = "value()[Ljava/lang/Class;") + public abstract java.lang.Class[] value(); + } + + @kotlin.Metadata() + @IFoo.IBar.Anno(value = {IFoo.IBar.IZoo.class}) + public static abstract interface IZoo { + } + } +} + +//////////////////// + + public class J$B { public J$B() { @@ -74,195 +258,52 @@ public class JavaClass { //////////////////// -@kotlin.Metadata() -public final class A$B { - @org.jetbrains.annotations.NotNull() - public A$B.C c; - @org.jetbrains.annotations.NotNull() - public A$B.D$E de; - @org.jetbrains.annotations.NotNull() - public J$B.C jc; - @org.jetbrains.annotations.NotNull() - public J$B.D$E jde; - @org.jetbrains.annotations.NotNull() - public A$B.D$$E dee; - @org.jetbrains.annotations.NotNull() - public A$B.D$$$E deee; - @org.jetbrains.annotations.NotNull() - public J$B.D$$E jdee; - @org.jetbrains.annotations.NotNull() - public J$B.D$$$E jdeee; - - public A$B() { - super(); - } - - @kotlin.Metadata() - public static final class C { - - public C() { - super(); - } - } - - @kotlin.Metadata() - public static final class D$E { - @org.jetbrains.annotations.NotNull() - public A$B.D$E.F f; - @org.jetbrains.annotations.NotNull() - public A$B.D$E.F$G fg; - @org.jetbrains.annotations.NotNull() - public J$B.D$E.F jf; - @org.jetbrains.annotations.NotNull() - public J$B.D$E.F$G jfg; - - public D$E() { - super(); - } - - @kotlin.Metadata() - public static final class F { - - public F() { - super(); - } - } - - @kotlin.Metadata() - public static final class F$G { - - public F$G() { - super(); - } - } - } - - @kotlin.Metadata() - public static final class D$$E { - - public D$$E() { - super(); - } - } - - @kotlin.Metadata() - public static final class D$$$E { - - public D$$$E() { - super(); - } - } -} - -//////////////////// - - -@kotlin.Metadata() -public final class Experiment { - - public Experiment() { - super(); - } - - @kotlin.Metadata() - @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME) - public static abstract @interface Type { - } - - @kotlin.Metadata() - @Experiment.Type() - public static final class Group { - - public Group(@org.jetbrains.annotations.NotNull() - java.lang.String s) { - super(); - } - - @org.jetbrains.annotations.NotNull() - public final Experiment.Group copy(@org.jetbrains.annotations.NotNull() - java.lang.String s) { - return null; - } - } -} - -//////////////////// - - -@kotlin.Metadata() -public final class Foo { - - public Foo() { - super(); - } - - @kotlin.Metadata() - public static class Bar { - - public Bar() { - super(); - } - - @kotlin.Metadata() - public static final class Zoo { - public static final Foo.Bar.Zoo INSTANCE = null; - - private Zoo() { - super(); - } - } - } -} - -//////////////////// - - -@kotlin.Metadata() -public abstract interface IFoo { - - @kotlin.Metadata() - public static abstract interface IBar { - - @kotlin.Metadata() - @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME) - public static abstract @interface Anno { - - public abstract java.lang.Class[] value(); - } - - @kotlin.Metadata() - @IFoo.IBar.Anno(value = {IFoo.IBar.IZoo.class}) - public static abstract interface IZoo { - } - } -} - -//////////////////// - - @kotlin.Metadata() @IFoo.IBar.Anno(value = {IFoo.IBar.IZoo.class, Foo.Bar.class}) +@kapt.internal.KaptMetadata() public final class Test1 extends Foo.Bar implements IFoo.IBar, IFoo.IBar.IZoo { @org.jetbrains.annotations.NotNull() private final Foo.Bar.Zoo zoo = null; @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "a()Ljava/lang/Thread$State;") public final java.lang.Thread.State a() { return null; } + @kapt.internal.KaptSignature(value = "b(LJavaClass$Foo;LJavaClass$Foo$Bar;)V") public final void b(@org.jetbrains.annotations.NotNull() JavaClass.Foo foo, @org.jetbrains.annotations.NotNull() JavaClass.Foo.Bar bar) { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "getZoo()LFoo$Bar$Zoo;") public final Foo.Bar.Zoo getZoo() { return null; } + @kapt.internal.KaptSignature(value = "(LFoo$Bar$Zoo;)V") public Test1(@org.jetbrains.annotations.NotNull() Foo.Bar.Zoo zoo) { super(); } } + +//////////////////// + +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/nestedClassesNonRootPackage.txt b/plugins/kapt3/kapt3-compiler/testData/converter/nestedClassesNonRootPackage.txt index cfcd1a772e9..c1461f05835 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/nestedClassesNonRootPackage.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/nestedClassesNonRootPackage.txt @@ -1,3 +1,209 @@ +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} + +//////////////////// + +package test; + +@kotlin.Metadata() +@kapt.internal.KaptMetadata() +public final class A$B { + @org.jetbrains.annotations.NotNull() + public test.A$B.C c; + @org.jetbrains.annotations.NotNull() + public test.A$B.D$E de; + @org.jetbrains.annotations.NotNull() + public test.J$B.C jc; + @org.jetbrains.annotations.NotNull() + public test.J$B.D$E jde; + @org.jetbrains.annotations.NotNull() + public test.A$B.D$$E dee; + @org.jetbrains.annotations.NotNull() + public test.A$B.D$$$E deee; + @org.jetbrains.annotations.NotNull() + public test.J$B.D$$E jdee; + @org.jetbrains.annotations.NotNull() + public test.J$B.D$$$E jdeee; + + @kapt.internal.KaptSignature(value = "()V") + public A$B() { + super(); + } + + @kotlin.Metadata() + public static final class C { + + @kapt.internal.KaptSignature(value = "()V") + public C() { + super(); + } + } + + @kotlin.Metadata() + public static final class D$E { + @org.jetbrains.annotations.NotNull() + public test.A$B.D$E.F f; + @org.jetbrains.annotations.NotNull() + public test.A$B.D$E.F$G fg; + @org.jetbrains.annotations.NotNull() + public test.J$B.D$E.F jf; + @org.jetbrains.annotations.NotNull() + public test.J$B.D$E.F$G jfg; + + @kapt.internal.KaptSignature(value = "()V") + public D$E() { + super(); + } + + @kotlin.Metadata() + public static final class F { + + @kapt.internal.KaptSignature(value = "()V") + public F() { + super(); + } + } + + @kotlin.Metadata() + public static final class F$G { + + @kapt.internal.KaptSignature(value = "()V") + public F$G() { + super(); + } + } + } + + @kotlin.Metadata() + public static final class D$$E { + + @kapt.internal.KaptSignature(value = "()V") + public D$$E() { + super(); + } + } + + @kotlin.Metadata() + public static final class D$$$E { + + @kapt.internal.KaptSignature(value = "()V") + public D$$$E() { + super(); + } + } +} + +//////////////////// + +package test; + +@kotlin.Metadata() +@kapt.internal.KaptMetadata() +public final class Experiment { + + @kapt.internal.KaptSignature(value = "()V") + public Experiment() { + super(); + } + + @kotlin.Metadata() + @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME) + public static abstract @interface Type { + } + + @kotlin.Metadata() + @test.Experiment.Type() + public static final class Group { + + @kapt.internal.KaptSignature(value = "(Ljava/lang/String;)V") + public Group(@org.jetbrains.annotations.NotNull() + java.lang.String s) { + super(); + } + + @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "copy(Ljava/lang/String;)Ltest/Experiment$Group;") + public final test.Experiment.Group copy(@org.jetbrains.annotations.NotNull() + java.lang.String s) { + return null; + } + } +} + +//////////////////// + +package test; + +@kotlin.Metadata() +@kapt.internal.KaptMetadata() +public final class Foo { + + @kapt.internal.KaptSignature(value = "()V") + public Foo() { + super(); + } + + @kotlin.Metadata() + public static class Bar { + + @kapt.internal.KaptSignature(value = "()V") + public Bar() { + super(); + } + + @kotlin.Metadata() + public static final class Zoo { + public static final test.Foo.Bar.Zoo INSTANCE = null; + + @kapt.internal.KaptSignature(value = "()V") + private Zoo() { + super(); + } + } + } +} + +//////////////////// + +package test; + +@kotlin.Metadata() +@kapt.internal.KaptMetadata() +public abstract interface IFoo { + + @kotlin.Metadata() + public static abstract interface IBar { + + @kotlin.Metadata() + @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME) + public static abstract @interface Anno { + + @kapt.internal.KaptSignature(value = "value()[Ljava/lang/Class;") + public abstract java.lang.Class[] value(); + } + + @kotlin.Metadata() + @test.IFoo.IBar.Anno(value = {test.IFoo.IBar.IZoo.class}) + public static abstract interface IZoo { + } + } +} + +//////////////////// + package test; public class J$B { @@ -78,197 +284,32 @@ class JavaClass { package test; -@kotlin.Metadata() -public final class A$B { - @org.jetbrains.annotations.NotNull() - public test.A$B.C c; - @org.jetbrains.annotations.NotNull() - public test.A$B.D$E de; - @org.jetbrains.annotations.NotNull() - public test.J$B.C jc; - @org.jetbrains.annotations.NotNull() - public test.J$B.D$E jde; - @org.jetbrains.annotations.NotNull() - public test.A$B.D$$E dee; - @org.jetbrains.annotations.NotNull() - public test.A$B.D$$$E deee; - @org.jetbrains.annotations.NotNull() - public test.J$B.D$$E jdee; - @org.jetbrains.annotations.NotNull() - public test.J$B.D$$$E jdeee; - - public A$B() { - super(); - } - - @kotlin.Metadata() - public static final class C { - - public C() { - super(); - } - } - - @kotlin.Metadata() - public static final class D$E { - @org.jetbrains.annotations.NotNull() - public test.A$B.D$E.F f; - @org.jetbrains.annotations.NotNull() - public test.A$B.D$E.F$G fg; - @org.jetbrains.annotations.NotNull() - public test.J$B.D$E.F jf; - @org.jetbrains.annotations.NotNull() - public test.J$B.D$E.F$G jfg; - - public D$E() { - super(); - } - - @kotlin.Metadata() - public static final class F { - - public F() { - super(); - } - } - - @kotlin.Metadata() - public static final class F$G { - - public F$G() { - super(); - } - } - } - - @kotlin.Metadata() - public static final class D$$E { - - public D$$E() { - super(); - } - } - - @kotlin.Metadata() - public static final class D$$$E { - - public D$$$E() { - super(); - } - } -} - -//////////////////// - -package test; - -@kotlin.Metadata() -public final class Experiment { - - public Experiment() { - super(); - } - - @kotlin.Metadata() - @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME) - public static abstract @interface Type { - } - - @kotlin.Metadata() - @test.Experiment.Type() - public static final class Group { - - public Group(@org.jetbrains.annotations.NotNull() - java.lang.String s) { - super(); - } - - @org.jetbrains.annotations.NotNull() - public final test.Experiment.Group copy(@org.jetbrains.annotations.NotNull() - java.lang.String s) { - return null; - } - } -} - -//////////////////// - -package test; - -@kotlin.Metadata() -public final class Foo { - - public Foo() { - super(); - } - - @kotlin.Metadata() - public static class Bar { - - public Bar() { - super(); - } - - @kotlin.Metadata() - public static final class Zoo { - public static final test.Foo.Bar.Zoo INSTANCE = null; - - private Zoo() { - super(); - } - } - } -} - -//////////////////// - -package test; - -@kotlin.Metadata() -public abstract interface IFoo { - - @kotlin.Metadata() - public static abstract interface IBar { - - @kotlin.Metadata() - @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME) - public static abstract @interface Anno { - - public abstract java.lang.Class[] value(); - } - - @kotlin.Metadata() - @test.IFoo.IBar.Anno(value = {test.IFoo.IBar.IZoo.class}) - public static abstract interface IZoo { - } - } -} - -//////////////////// - -package test; - @kotlin.Metadata() @test.IFoo.IBar.Anno(value = {test.IFoo.IBar.IZoo.class, test.Foo.Bar.class}) +@kapt.internal.KaptMetadata() public final class Test1 extends test.Foo.Bar implements test.IFoo.IBar, test.IFoo.IBar.IZoo { @org.jetbrains.annotations.NotNull() private final test.Foo.Bar.Zoo zoo = null; @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "a()Ljava/lang/Thread$State;") public final java.lang.Thread.State a() { return null; } + @kapt.internal.KaptSignature(value = "b(Ltest/JavaClass$Foo;Ltest/JavaClass$Foo$Bar;)V") public final void b(@org.jetbrains.annotations.NotNull() test.JavaClass.Foo foo, @org.jetbrains.annotations.NotNull() test.JavaClass.Foo.Bar bar) { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "getZoo()Ltest/Foo$Bar$Zoo;") public final test.Foo.Bar.Zoo getZoo() { return null; } + @kapt.internal.KaptSignature(value = "(Ltest/Foo$Bar$Zoo;)V") public Test1(@org.jetbrains.annotations.NotNull() test.Foo.Bar.Zoo zoo) { super(); diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/nonExistentClass.txt b/plugins/kapt3/kapt3-compiler/testData/converter/nonExistentClass.txt index aa5a5a6eb26..35688b035b4 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/nonExistentClass.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/nonExistentClass.txt @@ -1,5 +1,6 @@ @kotlin.Suppress(names = {"UNRESOLVED_REFERENCE"}) @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class NonExistentType { @org.jetbrains.annotations.Nullable() private static final ABCDEF a = null; @@ -12,26 +13,31 @@ public final class NonExistentType { public static final NonExistentType INSTANCE = null; @org.jetbrains.annotations.Nullable() + @kapt.internal.KaptSignature("getA()Lerror/NonExistentClass;") public final ABCDEF getA() { return null; } @org.jetbrains.annotations.Nullable() + @kapt.internal.KaptSignature("getB()Ljava/util/List;") public final java.util.List getB() { return null; } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature("getC()Lkotlin/jvm/functions/Function1;") public final Function1 getC() { return null; } @org.jetbrains.annotations.Nullable() + @kapt.internal.KaptSignature("getD()Lerror/NonExistentClass;") public final ABCDEF, kotlin.Unit>> getD() { return null; } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature("a(Lerror/NonExistentClass;Ljava/lang/String;)Lerror/NonExistentClass;") public final ABCDEF a(@org.jetbrains.annotations.NotNull() ABCDEF a, @org.jetbrains.annotations.NotNull() java.lang.String s) { @@ -39,11 +45,13 @@ public final class NonExistentType { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature("b(Ljava/lang/String;)Lerror/NonExistentClass;") public final ABCDEF b(@org.jetbrains.annotations.NotNull() java.lang.String s) { return null; } + @kapt.internal.KaptSignature("()V") private NonExistentType() { super(); } @@ -55,3 +63,21 @@ package error; public final class NonExistentClass { } + +//////////////////// + +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/nonExistentClassTypesConversion.txt b/plugins/kapt3/kapt3-compiler/testData/converter/nonExistentClassTypesConversion.txt index 3f6eafd0241..cf7fc8d25e9 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/nonExistentClassTypesConversion.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/nonExistentClassTypesConversion.txt @@ -3,14 +3,19 @@ import kotlin.reflect.KClass; @kotlin.Metadata() @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME) +@kapt.internal.KaptMetadata() public abstract @interface Anno { + @kapt.internal.KaptSignature("a()Ljava/lang/Class;") public abstract java.lang.Class a(); + @kapt.internal.KaptSignature("b()[Ljava/lang/Class;") public abstract java.lang.Class[] b(); + @kapt.internal.KaptSignature("c()[Ljava/lang/Class;") public abstract java.lang.Class[] c(); + @kapt.internal.KaptSignature("d()[Ljava/lang/Class;") public abstract java.lang.Class[] d(); } @@ -21,8 +26,10 @@ import java.util.Calendar; import kotlin.reflect.KClass; @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class MyType { + @kapt.internal.KaptSignature("()V") public MyType() { super(); } @@ -36,6 +43,7 @@ import kotlin.reflect.KClass; @kotlin.Suppress(names = {"UNRESOLVED_REFERENCE", "ANNOTATION_PARAMETER_MUST_BE_CONST", "NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION", "UNSUPPORTED_FEATURE"}) @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class NonExistentClassTypesConversionKt { } @@ -47,6 +55,7 @@ import kotlin.reflect.KClass; @kotlin.Metadata() @Anno(a = Blah.class, b = {NoFoo1.class, NoBar1.class}, c = {NoFoo2.class, String.class}, d = {Boolean.class, NoBar3.class}) +@kapt.internal.KaptMetadata() public final class Test { @org.jetbrains.annotations.NotNull() public ABC a; @@ -96,218 +105,265 @@ public final class Test { public java.util.Calendar.Builder p; @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature("getA()Lerror/NonExistentClass;") public final ABC getA() { return null; } + @kapt.internal.KaptSignature("setA(Lerror/NonExistentClass;)V") public final void setA(@org.jetbrains.annotations.NotNull() ABC p0) { } @org.jetbrains.annotations.Nullable() + @kapt.internal.KaptSignature("getB()Lerror/NonExistentClass;") public final ABC getB() { return null; } @org.jetbrains.annotations.Nullable() + @kapt.internal.KaptSignature("getC()Ljava/util/List;") public final java.util.List getC() { return null; } @org.jetbrains.annotations.Nullable() + @kapt.internal.KaptSignature("getD()Ljava/util/List;") public final java.util.List>>> getD() { return null; } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature("getE()Ljava/util/List;") public final java.util.List> getE() { return null; } + @kapt.internal.KaptSignature("setE(Ljava/util/List;)V") public final void setE(@org.jetbrains.annotations.NotNull() java.util.List> p0) { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature("getF()Lerror/NonExistentClass;") public final ABC getF() { return null; } + @kapt.internal.KaptSignature("setF(Lerror/NonExistentClass;)V") public final void setF(@org.jetbrains.annotations.NotNull() ABC p0) { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature("getG()Ljava/util/List;") public final java.util.List getG() { return null; } + @kapt.internal.KaptSignature("setG(Ljava/util/List;)V") public final void setG(@org.jetbrains.annotations.NotNull() java.util.List p0) { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature("getH()Lerror/NonExistentClass;") public final ABC getH() { return null; } + @kapt.internal.KaptSignature("setH(Lerror/NonExistentClass;)V") public final void setH(@org.jetbrains.annotations.NotNull() ABC p0) { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature("getI()Lkotlin/jvm/functions/Function2;") public final Function2, CDE> getI() { return null; } + @kapt.internal.KaptSignature("setI(Lkotlin/jvm/functions/Function2;)V") public final void setI(@org.jetbrains.annotations.NotNull() Function2, CDE> p0) { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature("getJ()Lkotlin/jvm/functions/Function0;") public final Function0 getJ() { return null; } + @kapt.internal.KaptSignature("setJ(Lkotlin/jvm/functions/Function0;)V") public final void setJ(@org.jetbrains.annotations.NotNull() Function0 p0) { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature("getK()Lkotlin/jvm/functions/Function2;") public final Function2, CDE> getK() { return null; } + @kapt.internal.KaptSignature("setK(Lkotlin/jvm/functions/Function2;)V") public final void setK(@org.jetbrains.annotations.NotNull() Function2, CDE> p0) { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature("getL()Lerror/NonExistentClass;") public final ABC.BCD.EFG getL() { return null; } + @kapt.internal.KaptSignature("setL(Lerror/NonExistentClass;)V") public final void setL(@org.jetbrains.annotations.NotNull() ABC.BCD.EFG p0) { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature("getCoocoo()Lerror/NonExistentClass;") public final ABC getCoocoo() { return null; } + @kapt.internal.KaptSignature("setCoocoo(Lerror/NonExistentClass;)V") public final void setCoocoo(@org.jetbrains.annotations.NotNull() ABC p0) { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature("getCoocoo2()Lerror/NonExistentClass;") public final ABC getCoocoo2() { return null; } + @kapt.internal.KaptSignature("setCoocoo2(Lerror/NonExistentClass;)V") public final void setCoocoo2(@org.jetbrains.annotations.NotNull() ABC p0) { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature("getCoocoo21()Lerror/NonExistentClass;") public final ABC getCoocoo21() { return null; } + @kapt.internal.KaptSignature("setCoocoo21(Lerror/NonExistentClass;)V") public final void setCoocoo21(@org.jetbrains.annotations.NotNull() ABC p0) { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature("getCoocoo3()Lerror/NonExistentClass;") public final ABC getCoocoo3() { return null; } + @kapt.internal.KaptSignature("setCoocoo3(Lerror/NonExistentClass;)V") public final void setCoocoo3(@org.jetbrains.annotations.NotNull() ABC p0) { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature("getCoocoo31()Lerror/NonExistentClass;") public final ABC> getCoocoo31() { return null; } + @kapt.internal.KaptSignature("setCoocoo31(Lerror/NonExistentClass;)V") public final void setCoocoo31(@org.jetbrains.annotations.NotNull() ABC> p0) { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature("getNested()Lerror/NonExistentClass;") public final ABC getNested() { return null; } + @kapt.internal.KaptSignature("setNested(Lerror/NonExistentClass;)V") public final void setNested(@org.jetbrains.annotations.NotNull() ABC p0) { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature("getM()Lerror/NonExistentClass;") public final error.NonExistentClass getM() { return null; } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature("getN()Ljava/lang/String;") public final java.lang.String getN() { return null; } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature("getO11()Ljava/util/List;") public final java.util.List>>>>>>>>> getO11() { return null; } + @kapt.internal.KaptSignature("setO11(Ljava/util/List;)V") public final void setO11(@org.jetbrains.annotations.NotNull() java.util.List>>>>>>>>> p0) { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature("getO10()Ljava/util/List;") public final java.util.List>>>>>>>> getO10() { return null; } + @kapt.internal.KaptSignature("setO10(Ljava/util/List;)V") public final void setO10(@org.jetbrains.annotations.NotNull() java.util.List>>>>>>>> p0) { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature("getP()Lerror/NonExistentClass;") public final java.util.Calendar.Builder getP() { return null; } + @kapt.internal.KaptSignature("setP(Lerror/NonExistentClass;)V") public final void setP(@org.jetbrains.annotations.NotNull() java.util.Calendar.Builder p0) { } @org.jetbrains.annotations.Nullable() + @kapt.internal.KaptSignature("f1(Lerror/NonExistentClass;)Lerror/NonExistentClass;") public final BCD f1(@org.jetbrains.annotations.NotNull() ABC a) { return null; } + @kapt.internal.KaptSignature("f2(Lerror/NonExistentClass;)V") public final void f2(@org.jetbrains.annotations.NotNull() ABC> a) { } + @kapt.internal.KaptSignature("f3(Lerror/NonExistentClass;I)J") public final long f3(@org.jetbrains.annotations.NotNull() ABC a, int b) { return 0L; } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature("f4()Lerror/NonExistentClass;") public final error.NonExistentClass f4() { return null; } @org.jetbrains.annotations.Nullable() + @kapt.internal.KaptSignature("f5(LMyType;)Ljava/lang/Class;") public final java.lang.Class> f5(@org.jetbrains.annotations.NotNull() MyType $receiver) { return null; } + @kapt.internal.KaptSignature("()V") public Test() { super(); } @@ -319,3 +375,21 @@ package error; public final class NonExistentClass { } + +//////////////////// + +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/nonExistentClassWIthoutCorrection.txt b/plugins/kapt3/kapt3-compiler/testData/converter/nonExistentClassWIthoutCorrection.txt index 4cb68a3dbc8..3ae67634591 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/nonExistentClassWIthoutCorrection.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/nonExistentClassWIthoutCorrection.txt @@ -1,5 +1,6 @@ @kotlin.Suppress(names = {"UNRESOLVED_REFERENCE"}) @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class NonExistentClassWIthoutCorrectionKt { } @@ -7,6 +8,7 @@ public final class NonExistentClassWIthoutCorrectionKt { @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class NonExistentType { @org.jetbrains.annotations.Nullable() private static final error.NonExistentClass a = null; @@ -31,80 +33,97 @@ public final class NonExistentType { public static final NonExistentType INSTANCE = null; @org.jetbrains.annotations.Nullable() + @kapt.internal.KaptSignature("getA()Lerror/NonExistentClass;") public final error.NonExistentClass getA() { return null; } @org.jetbrains.annotations.Nullable() + @kapt.internal.KaptSignature("getB()Ljava/util/List;") public final java.util.List getB() { return null; } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature("getC()Lkotlin/jvm/functions/Function1;") public final kotlin.jvm.functions.Function1 getC() { return null; } @org.jetbrains.annotations.Nullable() + @kapt.internal.KaptSignature("getD()Lerror/NonExistentClass;") public final error.NonExistentClass getD() { return null; } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature("getString2()Ljava/lang/String;") public final java.lang.String getString2() { return null; } + @kapt.internal.KaptSignature("setString2(Ljava/lang/String;)V") public final void setString2(@org.jetbrains.annotations.NotNull() java.lang.String p0) { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature("getCoocoo()Lerror/NonExistentClass;") public final error.NonExistentClass getCoocoo() { return null; } + @kapt.internal.KaptSignature("setCoocoo(Lerror/NonExistentClass;)V") public final void setCoocoo(@org.jetbrains.annotations.NotNull() error.NonExistentClass p0) { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature("getCoocoo2()Lerror/NonExistentClass;") public final error.NonExistentClass getCoocoo2() { return null; } + @kapt.internal.KaptSignature("setCoocoo2(Lerror/NonExistentClass;)V") public final void setCoocoo2(@org.jetbrains.annotations.NotNull() error.NonExistentClass p0) { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature("getCoocoo21()Lerror/NonExistentClass;") public final error.NonExistentClass getCoocoo21() { return null; } + @kapt.internal.KaptSignature("setCoocoo21(Lerror/NonExistentClass;)V") public final void setCoocoo21(@org.jetbrains.annotations.NotNull() error.NonExistentClass p0) { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature("getCoocoo3()Lerror/NonExistentClass;") public final error.NonExistentClass getCoocoo3() { return null; } + @kapt.internal.KaptSignature("setCoocoo3(Lerror/NonExistentClass;)V") public final void setCoocoo3(@org.jetbrains.annotations.NotNull() error.NonExistentClass p0) { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature("getCoocoo31()Lerror/NonExistentClass;") public final error.NonExistentClass getCoocoo31() { return null; } + @kapt.internal.KaptSignature("setCoocoo31(Lerror/NonExistentClass;)V") public final void setCoocoo31(@org.jetbrains.annotations.NotNull() error.NonExistentClass p0) { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature("a(Lerror/NonExistentClass;Ljava/lang/String;)Lerror/NonExistentClass;") public final error.NonExistentClass a(@org.jetbrains.annotations.NotNull() error.NonExistentClass a, @org.jetbrains.annotations.NotNull() java.lang.String s) { @@ -112,11 +131,13 @@ public final class NonExistentType { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature("b(Ljava/lang/String;)Lerror/NonExistentClass;") public final error.NonExistentClass b(@org.jetbrains.annotations.NotNull() java.lang.String s) { return null; } + @kapt.internal.KaptSignature("()V") private NonExistentType() { super(); } @@ -128,3 +149,21 @@ package error; public final class NonExistentClass { } + +//////////////////// + +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/primitiveTypes.txt b/plugins/kapt3/kapt3-compiler/testData/converter/primitiveTypes.txt index b3b50542ece..d609aca40c1 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/primitiveTypes.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/primitiveTypes.txt @@ -1,4 +1,5 @@ @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class PrimitiveTypes { public static final boolean booleanFalse = false; public static final boolean booleanTrue = true; @@ -36,39 +37,66 @@ public final class PrimitiveTypes { public static final java.lang.String stringRN = "\r\n"; public static final PrimitiveTypes INSTANCE = null; + @kapt.internal.KaptSignature(value = "getFloatMaxValue()F") public final float getFloatMaxValue() { return 0.0F; } + @kapt.internal.KaptSignature(value = "getFloatNan()F") public final float getFloatNan() { return 0.0F; } + @kapt.internal.KaptSignature(value = "getFloatPositiveInfinity()F") public final float getFloatPositiveInfinity() { return 0.0F; } + @kapt.internal.KaptSignature(value = "getFloatNegativeInfinity()F") public final float getFloatNegativeInfinity() { return 0.0F; } + @kapt.internal.KaptSignature(value = "getDoubleMaxValue()D") public final double getDoubleMaxValue() { return 0.0; } + @kapt.internal.KaptSignature(value = "getDoubleNan()D") public final double getDoubleNan() { return 0.0; } + @kapt.internal.KaptSignature(value = "getDoublePositiveInfinity()D") public final double getDoublePositiveInfinity() { return 0.0; } + @kapt.internal.KaptSignature(value = "getDoubleNegativeInfinity()D") public final double getDoubleNegativeInfinity() { return 0.0; } + @kapt.internal.KaptSignature(value = "()V") private PrimitiveTypes() { super(); } } + +//////////////////// + +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/propertyAnnotations.txt b/plugins/kapt3/kapt3-compiler/testData/converter/propertyAnnotations.txt index 04b4981497f..4da66f07e32 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/propertyAnnotations.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/propertyAnnotations.txt @@ -1,5 +1,6 @@ @kotlin.Metadata() @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME) +@kapt.internal.KaptMetadata() public abstract @interface Anno { } @@ -10,6 +11,7 @@ public abstract @interface Anno { @java.lang.annotation.Target(value = {java.lang.annotation.ElementType.TYPE}) @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME) @kotlin.annotation.Target(allowedTargets = {kotlin.annotation.AnnotationTarget.PROPERTY, kotlin.annotation.AnnotationTarget.CLASS}) +@kapt.internal.KaptMetadata() public abstract @interface Anno2 { } @@ -17,21 +19,43 @@ public abstract @interface Anno2 { @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class Test { @org.jetbrains.annotations.NotNull() private final java.lang.String prop = "A"; @Anno2() @Anno() + @kapt.internal.KaptSignature(value = "prop$annotations()V") public static void prop$annotations() { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "getProp()Ljava/lang/String;") public final java.lang.String getProp() { return null; } + @kapt.internal.KaptSignature(value = "()V") public Test() { super(); } } + +//////////////////// + +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/severalPackageParts.txt b/plugins/kapt3/kapt3-compiler/testData/converter/severalPackageParts.txt index 34af72c4d62..a2f1381c32c 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/severalPackageParts.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/severalPackageParts.txt @@ -1,12 +1,32 @@ +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} + +//////////////////// + package test; @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class AKt { public AKt() { super(); } + @kapt.internal.KaptSignature(value = "foo()V") public static final void foo() { } } @@ -16,12 +36,14 @@ public final class AKt { package test; @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class BKt { public BKt() { super(); } + @kapt.internal.KaptSignature(value = "bar()V") public static final void bar() { } } diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/strangeIdentifiers.kt b/plugins/kapt3/kapt3-compiler/testData/converter/strangeIdentifiers.kt index 76f0db2d485..381ee920627 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/strangeIdentifiers.kt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/strangeIdentifiers.kt @@ -1,4 +1,4 @@ -// EXPECTED_ERROR '60x60' is an invalid Java enum value name +// EXPECTED_ERROR(-1;-1) '60x60' is an invalid Java enum value name class `:)` { lateinit val f: String diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/strangeIdentifiers.txt b/plugins/kapt3/kapt3-compiler/testData/converter/strangeIdentifiers.txt index a2e662094bc..b2e5385ba26 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/strangeIdentifiers.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/strangeIdentifiers.txt @@ -1,9 +1,12 @@ @kotlin.Metadata() @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME) +@kapt.internal.KaptMetadata() public abstract @interface Anno { + @kapt.internal.KaptSignature(value = "size()LStrangeEnum;") public abstract StrangeEnum size(); + @kapt.internal.KaptSignature(value = "name()Ljava/lang/String;") public abstract java.lang.String name(); } @@ -11,16 +14,19 @@ public abstract @interface Anno { @kotlin.Metadata() +@kapt.internal.KaptMetadata() public enum StrangeEnum { - /*public static final*/ InvalidFieldName /* = new InvalidFieldName(null) */; + /*public static final*/ InvalidFieldName /* = new StrangeEnum() */; @org.jetbrains.annotations.NotNull() private final java.lang.String size = null; @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "getSize()Ljava/lang/String;") public final java.lang.String getSize() { return null; } + @kapt.internal.KaptSignature(value = "(Ljava/lang/String;ILjava/lang/String;)V") StrangeEnum(@org.jetbrains.annotations.NotNull() java.lang.String size) { } @@ -30,30 +36,54 @@ public enum StrangeEnum { @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class Test { @org.jetbrains.annotations.NotNull() public java.lang.String simpleName; @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "getSimpleName()Ljava/lang/String;") public final java.lang.String getSimpleName() { return null; } + @kapt.internal.KaptSignature(value = "simpleFun()V") public final void simpleFun() { } @Anno(name = "Woofwoof", size = StrangeEnum.InvalidFieldName) + @kapt.internal.KaptSignature(value = "simpleFun2(Ljava/lang/String;Ljava/lang/String;)V") public final void simpleFun2(@org.jetbrains.annotations.NotNull() java.lang.String a, @org.jetbrains.annotations.NotNull() java.lang.String b) { } + @kapt.internal.KaptSignature(value = "strangeFun4(Ljava/lang/String;Ljava/lang/String;)V") public final void strangeFun4(@org.jetbrains.annotations.NotNull() java.lang.String a, @org.jetbrains.annotations.NotNull() java.lang.String p1_949560896) { } + @kapt.internal.KaptSignature(value = "()V") public Test() { super(); } } + +//////////////////// + +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/strangeNames.txt b/plugins/kapt3/kapt3-compiler/testData/converter/strangeNames.txt index 8b137891791..cb11bb99b4c 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/strangeNames.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/strangeNames.txt @@ -1 +1,15 @@ +package kapt.internal; +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/topLevel.txt b/plugins/kapt3/kapt3-compiler/testData/converter/topLevel.txt index ccc264ef101..5b33c16ac15 100644 --- a/plugins/kapt3/kapt3-compiler/testData/converter/topLevel.txt +++ b/plugins/kapt3/kapt3-compiler/testData/converter/topLevel.txt @@ -1,9 +1,29 @@ +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} + +//////////////////// + package test.another; @kotlin.Metadata() @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME) +@kapt.internal.KaptMetadata() public abstract @interface Anno { + @kapt.internal.KaptSignature(value = "value()Ljava/lang/String;") public abstract java.lang.String value(); } @@ -12,6 +32,7 @@ public abstract @interface Anno { package test.another; @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class TopLevelKt { public TopLevelKt() { @@ -20,24 +41,29 @@ public final class TopLevelKt { private static final int topLevelProperty = 2; @org.jetbrains.annotations.Nullable() + @kapt.internal.KaptSignature(value = "topLevelFunction()Ljava/lang/String;") public static final java.lang.String topLevelFunction() { return null; } @org.jetbrains.annotations.Nullable() + @kapt.internal.KaptSignature(value = "topLevelGenericFunction()Ljava/util/List;") public static final >T topLevelGenericFunction() { return null; } + @kapt.internal.KaptSignature(value = "getTopLevelProperty()I") public static final int getTopLevelProperty() { return 0; } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "getTopLevelProperty2()Ljava/lang/String;") public static final java.lang.String getTopLevelProperty2() { return null; } + @kapt.internal.KaptSignature(value = "extensionFunction(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V") public static final void extensionFunction(@org.jetbrains.annotations.NotNull() @Anno(value = "rec") java.lang.String $receiver, @org.jetbrains.annotations.NotNull() @@ -48,16 +74,19 @@ public final class TopLevelKt { } @Anno(value = "extpr") + @kapt.internal.KaptSignature(value = "extensionProperty$annotations(Ljava/lang/Object;)V") public static void extensionProperty$annotations(java.lang.Object p0) { } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature(value = "getExtensionProperty(Ljava/lang/Object;)Ljava/lang/String;") public static final java.lang.String getExtensionProperty(@org.jetbrains.annotations.NotNull() @Anno(value = "propRec") T $receiver) { return null; } + @kapt.internal.KaptSignature(value = "setExtensionProperty(Ljava/lang/Object;Ljava/lang/String;)V") public static final void setExtensionProperty(@org.jetbrains.annotations.NotNull() @Anno(value = "propRec") T $receiver, @org.jetbrains.annotations.NotNull() diff --git a/plugins/kapt3/kapt3-compiler/testData/kotlinRunner/NestedClasses.it.txt b/plugins/kapt3/kapt3-compiler/testData/kotlinRunner/NestedClasses.it.txt index 66749b59890..e8f3c68a68c 100644 --- a/plugins/kapt3/kapt3-compiler/testData/kotlinRunner/NestedClasses.it.txt +++ b/plugins/kapt3/kapt3-compiler/testData/kotlinRunner/NestedClasses.it.txt @@ -5,10 +5,29 @@ public final class NonExistentClass { //////////////////// +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} + +//////////////////// + package test; @kotlin.Metadata() @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME) +@kapt.internal.KaptMetadata() public abstract @interface MyAnnotation { } @@ -17,13 +36,16 @@ public abstract @interface MyAnnotation { package test; @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class Simple { public static final test.Simple.Companion Companion = null; @MyAnnotation() + @kapt.internal.KaptSignature("myMethod()V") public final void myMethod() { } + @kapt.internal.KaptSignature("()V") public Simple() { super(); } @@ -31,6 +53,7 @@ public final class Simple { @kotlin.Metadata() public static final class NestedClass { + @kapt.internal.KaptSignature("()V") public NestedClass() { super(); } @@ -38,6 +61,7 @@ public final class Simple { @kotlin.Metadata() public static final class NestedNestedClass { + @kapt.internal.KaptSignature("()V") public NestedNestedClass() { super(); } @@ -47,6 +71,7 @@ public final class Simple { @kotlin.Metadata() public final class InnerClass { + @kapt.internal.KaptSignature("(Ltest/Simple;)V") public InnerClass() { super(); } @@ -55,6 +80,7 @@ public final class Simple { @kotlin.Metadata() public static final class Companion { + @kapt.internal.KaptSignature("()V") private Companion() { super(); } diff --git a/plugins/kapt3/kapt3-compiler/testData/kotlinRunner/Overloads.it.txt b/plugins/kapt3/kapt3-compiler/testData/kotlinRunner/Overloads.it.txt index 3e322a2e3a4..34d98c5176e 100644 --- a/plugins/kapt3/kapt3-compiler/testData/kotlinRunner/Overloads.it.txt +++ b/plugins/kapt3/kapt3-compiler/testData/kotlinRunner/Overloads.it.txt @@ -5,10 +5,29 @@ public final class NonExistentClass { //////////////////// +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} + +//////////////////// + package test; @kotlin.Metadata() @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME) +@kapt.internal.KaptMetadata() public abstract @interface MyAnnotation { } @@ -18,30 +37,36 @@ package test; @kotlin.Metadata() @MyAnnotation() +@kapt.internal.KaptMetadata() public final class State { private final int someInt = 0; private final long someLong = 0L; @org.jetbrains.annotations.NotNull() private final java.lang.String someString = null; + @kapt.internal.KaptSignature("getSomeInt()I") public final int getSomeInt() { return 0; } + @kapt.internal.KaptSignature("getSomeLong()J") public final long getSomeLong() { return 0L; } @org.jetbrains.annotations.NotNull() + @kapt.internal.KaptSignature("getSomeString()Ljava/lang/String;") public final java.lang.String getSomeString() { return null; } + @kapt.internal.KaptSignature("(IJLjava/lang/String;)V") public State(int someInt, long someLong, @org.jetbrains.annotations.NotNull() java.lang.String someString) { super(); } + @kapt.internal.KaptSignature("(IJ)V") public State(int someInt, long someLong) { super(); } diff --git a/plugins/kapt3/kapt3-compiler/testData/kotlinRunner/Simple.it.txt b/plugins/kapt3/kapt3-compiler/testData/kotlinRunner/Simple.it.txt index 88ba429d118..ecd7e5725b6 100644 --- a/plugins/kapt3/kapt3-compiler/testData/kotlinRunner/Simple.it.txt +++ b/plugins/kapt3/kapt3-compiler/testData/kotlinRunner/Simple.it.txt @@ -5,13 +5,33 @@ public final class NonExistentClass { //////////////////// +package kapt.internal; + +public @interface KaptMetadata { + + public java.lang.String value(); +} + +//////////////////// + +package kapt.internal; + +public @interface KaptSignature { + + public java.lang.String value(); +} + +//////////////////// + package test; @kotlin.Metadata() +@kapt.internal.KaptMetadata() public enum EnumClass { /*public static final*/ BLACK /* = new BLACK() */, /*public static final*/ WHITE /* = new WHITE() */; + @kapt.internal.KaptSignature("(Ljava/lang/String;I)V") EnumClass() { } } @@ -22,6 +42,7 @@ package test; @kotlin.Metadata() @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME) +@kapt.internal.KaptMetadata() public abstract @interface MyAnnotation { } @@ -30,11 +51,13 @@ public abstract @interface MyAnnotation { package test; @kotlin.Metadata() +@kapt.internal.KaptMetadata() public enum EnumClass2 { /*public static final*/ WHITE /* = new WHITE(null) */, /*public static final*/ RED /* = new RED(null) */; private final java.lang.String blah = null; + @kapt.internal.KaptSignature("(Ljava/lang/String;ILjava/lang/String;)V") EnumClass2(@org.jetbrains.annotations.NotNull() java.lang.String blah) { } @@ -44,17 +67,22 @@ public enum EnumClass2 { package test; +@kotlin.Suppress(names = {"UNRESOLVED_REFERENCE"}) @kotlin.Metadata() +@kapt.internal.KaptMetadata() public final class Simple { @MyAnnotation() + @kapt.internal.KaptSignature("myMethod()V") public final void myMethod() { } + @kapt.internal.KaptSignature("heavyMethod()I") public final int heavyMethod() { return 0; } + @kapt.internal.KaptSignature("()V") public Simple() { super(); } diff --git a/plugins/kapt3/kapt3-compiler/testData/kotlinRunner/Simple.kt b/plugins/kapt3/kapt3-compiler/testData/kotlinRunner/Simple.kt index 4dabfb6feef..de73c3a379a 100644 --- a/plugins/kapt3/kapt3-compiler/testData/kotlinRunner/Simple.kt +++ b/plugins/kapt3/kapt3-compiler/testData/kotlinRunner/Simple.kt @@ -1,5 +1,6 @@ package test +@Suppress("UNRESOLVED_REFERENCE") internal class Simple { @MyAnnotation fun myMethod() {