From ec291455faea94a9ca2db90f4fa7a7ab774920b7 Mon Sep 17 00:00:00 2001 From: Yan Zhulanow Date: Wed, 11 Jan 2017 16:58:52 +0900 Subject: [PATCH] Kapt3: Replace error/NonExistentClass with the actual type (from PSI) (KT-15421) --- .../jetbrains/kotlin/kapt3/Kapt3Extension.kt | 2 +- .../org/jetbrains/kotlin/kapt3/KaptContext.kt | 2 + .../stubs/ClassFileToSourceStubConverter.kt | 75 ++++++++++- .../kapt3/stubs/SignatureParserVisitor.kt | 13 +- .../kotlin/kapt3/stubs/errorTypeConversion.kt | 114 ++++++++++++++++ .../kapt3/test/AbstractKotlinKapt3Test.kt | 11 +- ...ileToSourceStubConverterTestGenerated.java | 6 + .../kotlin/kapt3/test/JavaKaptContextTest.kt | 4 +- .../testData/converter/nonExistentClass.kt | 1 + .../testData/converter/nonExistentClass.txt | 24 ++-- .../nonExistentClassTypesConversion.kt | 34 +++++ .../nonExistentClassTypesConversion.txt | 126 ++++++++++++++++++ 12 files changed, 385 insertions(+), 27 deletions(-) create mode 100644 plugins/kapt3/src/org/jetbrains/kotlin/kapt3/stubs/errorTypeConversion.kt create mode 100644 plugins/kapt3/testData/converter/nonExistentClassTypesConversion.kt create mode 100644 plugins/kapt3/testData/converter/nonExistentClassTypesConversion.txt diff --git a/plugins/kapt3/src/org/jetbrains/kotlin/kapt3/Kapt3Extension.kt b/plugins/kapt3/src/org/jetbrains/kotlin/kapt3/Kapt3Extension.kt index 9423625e102..57bb336cf1d 100644 --- a/plugins/kapt3/src/org/jetbrains/kotlin/kapt3/Kapt3Extension.kt +++ b/plugins/kapt3/src/org/jetbrains/kotlin/kapt3/Kapt3Extension.kt @@ -198,7 +198,7 @@ abstract class AbstractKapt3Extension( logger.info { "Stubs compilation took $classFilesCompilationTime ms" } logger.info { "Compiled classes: " + compiledClasses.joinToString { it.name } } - return Pair(KaptContext(logger, compiledClasses, origins, options), generationState) + return Pair(KaptContext(logger, bindingContext, compiledClasses, origins, options), generationState) } private fun generateKotlinSourceStubs(kaptContext: KaptContext, generationState: GenerationState) { diff --git a/plugins/kapt3/src/org/jetbrains/kotlin/kapt3/KaptContext.kt b/plugins/kapt3/src/org/jetbrains/kotlin/kapt3/KaptContext.kt index 62a1164db46..1581a1b09e4 100644 --- a/plugins/kapt3/src/org/jetbrains/kotlin/kapt3/KaptContext.kt +++ b/plugins/kapt3/src/org/jetbrains/kotlin/kapt3/KaptContext.kt @@ -24,12 +24,14 @@ import org.jetbrains.kotlin.kapt3.javac.KaptJavaCompiler import org.jetbrains.kotlin.kapt3.javac.KaptJavaLog import org.jetbrains.kotlin.kapt3.javac.KaptTreeMaker import org.jetbrains.kotlin.kapt3.util.KaptLogger +import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin import org.jetbrains.org.objectweb.asm.tree.ClassNode import javax.tools.JavaFileManager class KaptContext( val logger: KaptLogger, + val bindingContext: BindingContext, val compiledClasses: List, val origins: Map, processorOptions: Map diff --git a/plugins/kapt3/src/org/jetbrains/kotlin/kapt3/stubs/ClassFileToSourceStubConverter.kt b/plugins/kapt3/src/org/jetbrains/kotlin/kapt3/stubs/ClassFileToSourceStubConverter.kt index a784230fcfe..42823f59e2b 100644 --- a/plugins/kapt3/src/org/jetbrains/kotlin/kapt3/stubs/ClassFileToSourceStubConverter.kt +++ b/plugins/kapt3/src/org/jetbrains/kotlin/kapt3/stubs/ClassFileToSourceStubConverter.kt @@ -28,10 +28,11 @@ import org.jetbrains.kotlin.kapt3.* import org.jetbrains.kotlin.kapt3.javac.KaptTreeMaker import org.jetbrains.kotlin.kapt3.javac.KaptJavaFileObject import org.jetbrains.kotlin.kapt3.util.* -import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.resolve.DescriptorUtils import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperClassNotAny import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperClassOrAny +import org.jetbrains.kotlin.types.KotlinType import org.jetbrains.kotlin.types.typeUtil.isAnyOrNullableAny import org.jetbrains.org.objectweb.asm.Opcodes import org.jetbrains.org.objectweb.asm.Type @@ -76,7 +77,7 @@ class ClassFileToSourceStubConverter( get() = _bindings private val fileManager = kaptContext.context.get(JavaFileManager::class.java) as JavacFileManager - private val treeMaker = TreeMaker.instance(kaptContext.context) as KaptTreeMaker + val treeMaker = TreeMaker.instance(kaptContext.context) as KaptTreeMaker private val signatureParser = SignatureParser(treeMaker) private var done = false @@ -228,7 +229,11 @@ class ClassFileToSourceStubConverter( val typeExpression = if (isEnum(field.access)) treeMaker.SimpleName(type.className.substringAfterLast('.')) else - getNotAnonymousType(descriptor) { signatureParser.parseFieldSignature(field.signature, treeMaker.Type(type)) } + getNotAnonymousType(descriptor) { + getNonErrorType((descriptor as? CallableDescriptor)?.returnType, + ktTypeProvider = { (kaptContext.origins[field]?.element as? KtVariableDeclaration)?.typeReference }, + ifNonError = { signatureParser.parseFieldSignature(field.signature, treeMaker.Type(type)) }) + } val value = field.value @@ -288,8 +293,9 @@ class ClassFileToSourceStubConverter( val exceptionTypes = mapJList(method.exceptions) { treeMaker.FqName(it) } - val genericSignature = signatureParser.parseMethodSignature(method.signature, parameters, exceptionTypes, jcReturnType) - val returnType = getNotAnonymousType(descriptor) { genericSignature.returnType } + val valueParametersFromDescriptor = descriptor.valueParameters + val (genericSignature, returnType) = extractMethodSignatureTypes( + descriptor, exceptionTypes, jcReturnType, method, parameters, valueParametersFromDescriptor) val defaultValue = method.annotationDefault?.let { convertLiteralExpression(it) } @@ -329,6 +335,65 @@ class ClassFileToSourceStubConverter( body, defaultValue) } + private fun extractMethodSignatureTypes( + descriptor: CallableDescriptor, + exceptionTypes: JavacList, + jcReturnType: JCExpression?, method: MethodNode, + parameters: JavacList, + valueParametersFromDescriptor: List + ): Pair { + val genericSignature = signatureParser.parseMethodSignature( + method.signature, parameters, exceptionTypes, jcReturnType, + nonErrorParameterTypeProvider = { index, lazyType -> + if (descriptor is PropertySetterDescriptor && valueParametersFromDescriptor.size == 1 && index == 0) { + getNonErrorType(descriptor.correspondingProperty.returnType, + ktTypeProvider = { (kaptContext.origins[method]?.element as? KtVariableDeclaration)?.typeReference }, + ifNonError = { lazyType() }) + } + else if (descriptor is FunctionDescriptor && valueParametersFromDescriptor.size == parameters.size) { + getNonErrorType(valueParametersFromDescriptor[index].type, + ktTypeProvider = { + (kaptContext.origins[method]?.element as? KtFunction)?.valueParameters?.get(index)?.typeReference + }, + ifNonError = { lazyType() }) + } + else { + lazyType() + } + }) + + val returnType = getNotAnonymousType(descriptor) { + getNonErrorType(descriptor.returnType, + ktTypeProvider = { + val element = kaptContext.origins[method]?.element + when (element) { + is KtFunction -> element.typeReference + is KtProperty -> if (method.name.startsWith("get")) element.typeReference else null + else -> null + } + }, + ifNonError = { genericSignature.returnType }) + } + + return Pair(genericSignature, returnType) + } + + private inline fun getNonErrorType( + type: KotlinType?, + ktTypeProvider: () -> KtTypeReference?, + ifNonError: () -> T + ): T { + if (type?.containsErrorTypes() ?: false) { + val ktType = ktTypeProvider() + if (ktType != null) { + @Suppress("UNCHECKED_CAST") + return convertKtType(ktType, this) as T + } + } + + return ifNonError() + } + private inline fun getNotAnonymousType(descriptor: DeclarationDescriptor?, f: () -> T): T { if (descriptor is CallableDescriptor) { val returnTypeDescriptor = descriptor.returnType?.constructor?.declarationDescriptor diff --git a/plugins/kapt3/src/org/jetbrains/kotlin/kapt3/stubs/SignatureParserVisitor.kt b/plugins/kapt3/src/org/jetbrains/kotlin/kapt3/stubs/SignatureParserVisitor.kt index 56b908af356..a1c6456b529 100644 --- a/plugins/kapt3/src/org/jetbrains/kotlin/kapt3/stubs/SignatureParserVisitor.kt +++ b/plugins/kapt3/src/org/jetbrains/kotlin/kapt3/stubs/SignatureParserVisitor.kt @@ -131,10 +131,15 @@ class SignatureParser(val treeMaker: KaptTreeMaker) { signature: String?, rawParameters: JavacList, rawExceptionTypes: JavacList, - rawReturnType: JCExpression? + rawReturnType: JCExpression?, + nonErrorParameterTypeProvider: (Int, () -> JCExpression) -> JCExpression ): MethodGenericSignature { if (signature == null) { - return MethodGenericSignature(JavacList.nil(), rawParameters, rawExceptionTypes, rawReturnType) + val parameters = mapJListIndexed(rawParameters) { index, it -> + val nonErrorType = nonErrorParameterTypeProvider(index) { it.vartype } + treeMaker.VarDef(it.modifiers, it.getName(), nonErrorType, it.initializer) + } + return MethodGenericSignature(JavacList.nil(), parameters, rawExceptionTypes, rawReturnType) } val root = parse(signature) @@ -149,7 +154,9 @@ class SignatureParser(val treeMaker: KaptTreeMaker) { val offset = rawParameters.size - parameterTypes.size val jcParameters = mapJListIndexed(parameterTypes) { index, it -> val rawParameter = rawParameters[index + offset] - treeMaker.VarDef(rawParameter.modifiers, rawParameter.getName(), parseType(it.children.single()), rawParameter.initializer) + val nonErrorType = nonErrorParameterTypeProvider(index) { parseType(it.children.single()) } + + treeMaker.VarDef(rawParameter.modifiers, rawParameter.getName(), nonErrorType, rawParameter.initializer) } val jcExceptionTypes = mapJList(exceptionTypes) { parseType(it) } val jcReturnType = if (rawReturnType == null) null else parseType(returnTypes.single().children.single()) diff --git a/plugins/kapt3/src/org/jetbrains/kotlin/kapt3/stubs/errorTypeConversion.kt b/plugins/kapt3/src/org/jetbrains/kotlin/kapt3/stubs/errorTypeConversion.kt new file mode 100644 index 00000000000..e605e69de0b --- /dev/null +++ b/plugins/kapt3/src/org/jetbrains/kotlin/kapt3/stubs/errorTypeConversion.kt @@ -0,0 +1,114 @@ +/* + * 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.code.BoundKind +import com.sun.tools.javac.tree.JCTree +import org.jetbrains.kotlin.codegen.signature.BothSignatureWriter +import org.jetbrains.kotlin.kapt3.mapJList +import org.jetbrains.kotlin.load.kotlin.TypeMappingMode +import org.jetbrains.kotlin.psi.* +import org.jetbrains.kotlin.resolve.BindingContext +import org.jetbrains.kotlin.types.KotlinType + +internal fun convertKtType( + reference: KtTypeReference?, + converter: ClassFileToSourceStubConverter, + shouldBeBoxed: Boolean = false, + gotTypeElement: KtTypeElement? = null +): JCTree.JCExpression { + val type = gotTypeElement ?: reference?.typeElement + + if (reference != null) { + val kotlinType = converter.kaptContext.bindingContext[BindingContext.TYPE, reference] + if (kotlinType != null && !kotlinType.containsErrorTypes()) { + val signatureWriter = BothSignatureWriter(BothSignatureWriter.Mode.TYPE) + converter.typeMapper.mapType(kotlinType, signatureWriter, + if (shouldBeBoxed) TypeMappingMode.GENERIC_ARGUMENT else TypeMappingMode.DEFAULT) + + return SignatureParser(converter.treeMaker).parseFieldSignature( + signatureWriter.toString(), getDefaultTypeForUnknownType(converter)) + } + } + + return when (type) { + is KtUserType -> convertUserType(type, converter) + is KtNullableType -> { + // Prevent infinite recursion + val innerType = type.innerType ?: return getDefaultTypeForUnknownType(converter) + convertKtType(reference, converter, shouldBeBoxed = true, gotTypeElement = innerType) + } + is KtFunctionType -> convertFunctionType(type, converter) + else -> getDefaultTypeForUnknownType(converter) + } +} + +private fun getDefaultTypeForUnknownType(converter: ClassFileToSourceStubConverter) = converter.treeMaker.FqName("error.NonExistentClass") + +private fun convertUserType(type: KtUserType, converter: ClassFileToSourceStubConverter): JCTree.JCExpression { + val qualifierExpression = type.qualifier?.let { convertUserType(it, converter) } + val referencedName = type.referencedName ?: "error" + val treeMaker = converter.treeMaker + + val baseExpression = if (qualifierExpression == null) { + treeMaker.SimpleName(referencedName) + } else { + treeMaker.Select(qualifierExpression, treeMaker.name(referencedName)) + } + + val arguments = type.typeArguments + if (arguments.isEmpty()) { + return baseExpression + } + + return treeMaker.TypeApply(baseExpression, mapJList(arguments) { convertTypeProjection(it, converter) }) +} + +private fun convertTypeProjection(type: KtTypeProjection, converter: ClassFileToSourceStubConverter): JCTree.JCExpression { + val reference = type.typeReference + val treeMaker = converter.treeMaker + + return when (type.projectionKind) { + KtProjectionKind.IN -> treeMaker.Wildcard(treeMaker.TypeBoundKind(BoundKind.SUPER), + convertKtType(reference, converter, shouldBeBoxed = true)) + KtProjectionKind.OUT -> treeMaker.Wildcard(treeMaker.TypeBoundKind(BoundKind.EXTENDS), + convertKtType(reference, converter, shouldBeBoxed = true)) + KtProjectionKind.STAR -> treeMaker.Wildcard(treeMaker.TypeBoundKind(BoundKind.UNBOUND), null) + KtProjectionKind.NONE -> return convertKtType(reference, converter, shouldBeBoxed = true) + } +} + +private fun convertFunctionType(type: KtFunctionType, converter: ClassFileToSourceStubConverter): JCTree.JCExpression { + val receiverType = type.receiverTypeReference + var parameterTypes = mapJList(type.parameters) { convertKtType(it.typeReference, converter) } + val returnType = convertKtType(type.returnTypeReference, converter) + + if (receiverType != null) { + parameterTypes = parameterTypes.prepend(convertKtType(receiverType, converter)) + } + + parameterTypes = parameterTypes.append(returnType) + + val treeMaker = converter.treeMaker + return treeMaker.TypeApply(treeMaker.SimpleName("Function" + (parameterTypes.size - 1)), parameterTypes) +} + +fun KotlinType.containsErrorTypes(): Boolean { + if (this.isError) return true + if (this.arguments.any { it.type.containsErrorTypes() }) return true + return false +} \ No newline at end of file diff --git a/plugins/kapt3/test/org/jetbrains/kotlin/kapt3/test/AbstractKotlinKapt3Test.kt b/plugins/kapt3/test/org/jetbrains/kotlin/kapt3/test/AbstractKotlinKapt3Test.kt index 22aa8d2b1b4..6568fb5e39c 100644 --- a/plugins/kapt3/test/org/jetbrains/kotlin/kapt3/test/AbstractKotlinKapt3Test.kt +++ b/plugins/kapt3/test/org/jetbrains/kotlin/kapt3/test/AbstractKotlinKapt3Test.kt @@ -59,7 +59,7 @@ abstract class AbstractKotlinKapt3Test : CodegenTestCase() { val typeMapper = factory.generationState.typeMapper val logger = KaptLogger(isVerbose = true, messageCollector = messageCollector) - val kaptContext = KaptContext(logger, classBuilderFactory.compiledClasses, + val kaptContext = KaptContext(logger, factory.generationState.bindingContext, classBuilderFactory.compiledClasses, classBuilderFactory.origins, processorOptions = emptyMap()) try { check(kaptContext, typeMapper, txtFile, wholeFile) @@ -82,9 +82,14 @@ abstract class AbstractKotlinKapt3Test : CodegenTestCase() { abstract class AbstractClassFileToSourceStubConverterTest : AbstractKotlinKapt3Test() { override fun check(kaptRunner: KaptContext, typeMapper: KotlinTypeMapper, txtFile: File, wholeFile: File) { - val generateNonExistentClass = wholeFile.useLines { lines -> lines.any { it.trim() == "// NON_EXISTENT_CLASS" } } + fun isOptionSet(name: String) = wholeFile.useLines { lines -> lines.any { it.trim() == "// $name" } } + + val generateNonExistentClass = isOptionSet("NON_EXISTENT_CLASS") + val validate = !isOptionSet("NO_VALIDATION") + val javaFiles = convert(kaptRunner, typeMapper, generateNonExistentClass) - kaptRunner.compiler.enterTrees(javaFiles) + + if (validate) kaptRunner.compiler.enterTrees(javaFiles) val actualRaw = javaFiles.sortedBy { it.sourceFile.name }.joinToString (FILE_SEPARATOR) val actual = StringUtil.convertLineSeparators(actualRaw.trim({ it <= ' ' })).trimTrailingWhitespacesAndAddNewlineAtEOF() diff --git a/plugins/kapt3/test/org/jetbrains/kotlin/kapt3/test/ClassFileToSourceStubConverterTestGenerated.java b/plugins/kapt3/test/org/jetbrains/kotlin/kapt3/test/ClassFileToSourceStubConverterTestGenerated.java index e5a5ffde856..fee967332dc 100644 --- a/plugins/kapt3/test/org/jetbrains/kotlin/kapt3/test/ClassFileToSourceStubConverterTestGenerated.java +++ b/plugins/kapt3/test/org/jetbrains/kotlin/kapt3/test/ClassFileToSourceStubConverterTestGenerated.java @@ -186,6 +186,12 @@ public class ClassFileToSourceStubConverterTestGenerated extends AbstractClassFi doTest(fileName); } + @TestMetadata("nonExistentClassTypesConversion.kt") + public void testNonExistentClassTypesConversion() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("plugins/kapt3/testData/converter/nonExistentClassTypesConversion.kt"); + doTest(fileName); + } + @TestMetadata("primitiveTypes.kt") public void testPrimitiveTypes() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("plugins/kapt3/testData/converter/primitiveTypes.kt"); diff --git a/plugins/kapt3/test/org/jetbrains/kotlin/kapt3/test/JavaKaptContextTest.kt b/plugins/kapt3/test/org/jetbrains/kotlin/kapt3/test/JavaKaptContextTest.kt index 1ca63cfff0c..f49b0aa93ff 100644 --- a/plugins/kapt3/test/org/jetbrains/kotlin/kapt3/test/JavaKaptContextTest.kt +++ b/plugins/kapt3/test/org/jetbrains/kotlin/kapt3/test/JavaKaptContextTest.kt @@ -22,6 +22,7 @@ import org.jetbrains.kotlin.kapt3.KaptContext import org.jetbrains.kotlin.kapt3.diagnostic.KaptError import org.jetbrains.kotlin.kapt3.doAnnotationProcessing import org.jetbrains.kotlin.kapt3.util.KaptLogger +import org.jetbrains.kotlin.resolve.BindingContext import org.junit.Assert.* import org.junit.Test import java.io.File @@ -70,7 +71,7 @@ class JavaKaptContextTest { } } - return true; + return true } override fun getSupportedAnnotationTypes() = setOf("test.MyAnnotation") @@ -79,6 +80,7 @@ class JavaKaptContextTest { private fun doAnnotationProcessing(javaSourceFile: File, processor: Processor, outputDir: File) { KaptContext(KaptLogger(isVerbose = true, messageCollector = messageCollector), + bindingContext = BindingContext.EMPTY, compiledClasses = emptyList(), origins = emptyMap(), processorOptions = emptyMap() diff --git a/plugins/kapt3/testData/converter/nonExistentClass.kt b/plugins/kapt3/testData/converter/nonExistentClass.kt index d1686384cf9..c43339fae4d 100644 --- a/plugins/kapt3/testData/converter/nonExistentClass.kt +++ b/plugins/kapt3/testData/converter/nonExistentClass.kt @@ -1,4 +1,5 @@ // NON_EXISTENT_CLASS +// NO_VALIDATION @Suppress("UNRESOLVED_REFERENCE") object NonExistentType { diff --git a/plugins/kapt3/testData/converter/nonExistentClass.txt b/plugins/kapt3/testData/converter/nonExistentClass.txt index a89090fefb1..b0c42bb9494 100644 --- a/plugins/kapt3/testData/converter/nonExistentClass.txt +++ b/plugins/kapt3/testData/converter/nonExistentClass.txt @@ -1,32 +1,32 @@ @kotlin.Suppress(names = {"UNRESOLVED_REFERENCE"}) public final class NonExistentType { - private static final error.NonExistentClass a = null; - private static final java.util.List b = null; - private static final kotlin.jvm.functions.Function1 c = null; - private static final error.NonExistentClass d = null; + private static final ABCDEF a = null; + private static final List b = null; + private static final Function1 c = null; + private static final ABCDEF, kotlin.Unit>> d = null; public static final NonExistentType INSTANCE = null; - public final error.NonExistentClass getA() { + public final ABCDEF getA() { return null; } - public final java.util.List getB() { + public final List getB() { return null; } - public final kotlin.jvm.functions.Function1 getC() { + public final Function1 getC() { return null; } - public final error.NonExistentClass getD() { + public final ABCDEF, kotlin.Unit>> getD() { return null; } - public final error.NonExistentClass a(error.NonExistentClass a, java.lang.String s) { + public final ABCDEF a(ABCDEF a, java.lang.String s) { return null; } - public final error.NonExistentClass b(java.lang.String s) { + public final ABCDEF b(java.lang.String s) { return null; } @@ -40,8 +40,4 @@ public final class NonExistentType { package error; public final class NonExistentClass { - - public NonExistentClass() { - super(); - } } diff --git a/plugins/kapt3/testData/converter/nonExistentClassTypesConversion.kt b/plugins/kapt3/testData/converter/nonExistentClassTypesConversion.kt new file mode 100644 index 00000000000..dba98b62b68 --- /dev/null +++ b/plugins/kapt3/testData/converter/nonExistentClassTypesConversion.kt @@ -0,0 +1,34 @@ +// NON_EXISTENT_CLASS +// NO_VALIDATION + +@Suppress("UNRESOLVED_REFERENCE") +class Test { + lateinit var a: ABC + val b: ABC? = null + val c: List? = null + val d: List>>>? = null + lateinit var e: List?> + lateinit var f: ABC<*> + lateinit var g: List<*> + lateinit var h: ABC + lateinit var i: (ABC, List) -> CDE + lateinit var j: () -> CDE + lateinit var k: ABC.(List) -> CDE + + lateinit var l: ABC.BCD.EFG + + val m = ABC() + val n = "".toString() + + fun f1(a: ABC): BCD? { + return null + } + + fun f2(a: ABC BCD>) {} + + fun f3(a: ABC, b: Int): Long { + return 0 + } + + fun f4() = ABC() +} \ No newline at end of file diff --git a/plugins/kapt3/testData/converter/nonExistentClassTypesConversion.txt b/plugins/kapt3/testData/converter/nonExistentClassTypesConversion.txt new file mode 100644 index 00000000000..14d7ed140a3 --- /dev/null +++ b/plugins/kapt3/testData/converter/nonExistentClassTypesConversion.txt @@ -0,0 +1,126 @@ +@kotlin.Suppress(names = {"UNRESOLVED_REFERENCE"}) +public final class Test { + public ABC a; + private final ABC b = null; + private final List c = null; + private final List>>> d = null; + public List> e; + public ABC f; + public java.util.List g; + public ABC h; + public Function2, CDE> i; + public Function0 j; + public Function2, CDE> k; + public ABC.BCD.EFG l; + private final error.NonExistentClass m = null; + private final java.lang.String n = ""; + + public final ABC getA() { + return null; + } + + public final void setA(ABC p0) { + } + + public final ABC getB() { + return null; + } + + public final List getC() { + return null; + } + + public final List>>> getD() { + return null; + } + + public final List> getE() { + return null; + } + + public final void setE(List> p0) { + } + + public final ABC getF() { + return null; + } + + public final void setF(ABC p0) { + } + + public final java.util.List getG() { + return null; + } + + public final void setG(java.util.List p0) { + } + + public final ABC getH() { + return null; + } + + public final void setH(ABC p0) { + } + + public final Function2, CDE> getI() { + return null; + } + + public final void setI(Function2, CDE> p0) { + } + + public final Function0 getJ() { + return null; + } + + public final void setJ(Function0 p0) { + } + + public final Function2, CDE> getK() { + return null; + } + + public final void setK(Function2, CDE> p0) { + } + + public final ABC.BCD.EFG getL() { + return null; + } + + public final void setL(ABC.BCD.EFG p0) { + } + + public final error.NonExistentClass getM() { + return null; + } + + public final java.lang.String getN() { + return null; + } + + public final BCD f1(ABC a) { + return null; + } + + public final void f2(ABC> a) { + } + + public final long f3(ABC a, int b) { + return 0L; + } + + public final error.NonExistentClass f4() { + return null; + } + + public Test() { + super(); + } +} + +//////////////////// + +package error; + +public final class NonExistentClass { +}