diff options
Diffstat (limited to 'integration-tests/src/test/resources/playground')
13 files changed, 563 insertions, 0 deletions
diff --git a/integration-tests/src/test/resources/playground/build.gradle.kts b/integration-tests/src/test/resources/playground/build.gradle.kts new file mode 100644 index 00000000..c5737a2e --- /dev/null +++ b/integration-tests/src/test/resources/playground/build.gradle.kts @@ -0,0 +1,8 @@ +plugins { + kotlin("jvm") +} + +repositories { + mavenCentral() + maven("https://maven.pkg.jetbrains.space/kotlin/p/kotlin/bootstrap/") +} diff --git a/integration-tests/src/test/resources/playground/settings.gradle.kts b/integration-tests/src/test/resources/playground/settings.gradle.kts new file mode 100644 index 00000000..9d60cbc7 --- /dev/null +++ b/integration-tests/src/test/resources/playground/settings.gradle.kts @@ -0,0 +1,19 @@ +pluginManagement { + val kotlinVersion: String by settings + val kspVersion: String by settings + val testRepo: String by settings + plugins { + id("com.google.devtools.ksp") version kspVersion + kotlin("jvm") version kotlinVersion + } + repositories { + maven(testRepo) + gradlePluginPortal() + maven("https://maven.pkg.jetbrains.space/kotlin/p/kotlin/bootstrap/") + } +} + +rootProject.name = "playground" + +include(":workload") +include(":test-processor") diff --git a/integration-tests/src/test/resources/playground/test-processor/build.gradle.kts b/integration-tests/src/test/resources/playground/test-processor/build.gradle.kts new file mode 100644 index 00000000..75c6c7c5 --- /dev/null +++ b/integration-tests/src/test/resources/playground/test-processor/build.gradle.kts @@ -0,0 +1,25 @@ +val kspVersion: String by project +val testRepo: String by project + +plugins { + kotlin("jvm") +} + +group = "com.example" +version = "1.0-SNAPSHOT" + +repositories { + maven(testRepo) + mavenCentral() + maven("https://maven.pkg.jetbrains.space/kotlin/p/kotlin/bootstrap/") +} + +dependencies { + implementation(kotlin("stdlib")) + implementation("com.squareup:javapoet:1.12.1") + implementation("com.google.devtools.ksp:symbol-processing-api:$kspVersion") +} + +sourceSets.main { + java.srcDirs("src/main/kotlin") +} diff --git a/integration-tests/src/test/resources/playground/test-processor/src/main/kotlin/Builder.kt b/integration-tests/src/test/resources/playground/test-processor/src/main/kotlin/Builder.kt new file mode 100644 index 00000000..9434b362 --- /dev/null +++ b/integration-tests/src/test/resources/playground/test-processor/src/main/kotlin/Builder.kt @@ -0,0 +1,3 @@ +package com.example.annotation + +annotation class Builder diff --git a/integration-tests/src/test/resources/playground/test-processor/src/main/kotlin/BuilderProcessor.kt b/integration-tests/src/test/resources/playground/test-processor/src/main/kotlin/BuilderProcessor.kt new file mode 100644 index 00000000..efa5ddcf --- /dev/null +++ b/integration-tests/src/test/resources/playground/test-processor/src/main/kotlin/BuilderProcessor.kt @@ -0,0 +1,104 @@ +import com.google.devtools.ksp.containingFile +import com.google.devtools.ksp.processing.* +import com.google.devtools.ksp.symbol.* +import com.google.devtools.ksp.validate +import java.io.OutputStream + +fun OutputStream.appendText(str: String) { + this.write(str.toByteArray()) +} + +class BuilderProcessor : SymbolProcessor { + lateinit var codeGenerator: CodeGenerator + lateinit var logger: KSPLogger + + fun init( + options: Map<String, String>, + kotlinVersion: KotlinVersion, + codeGenerator: CodeGenerator, + logger: KSPLogger, + ) { + this.codeGenerator = codeGenerator + this.logger = logger + } + + override fun process(resolver: Resolver): List<KSAnnotated> { + val symbols = resolver.getSymbolsWithAnnotation("com.example.annotation.Builder") + val ret = symbols.filter { !it.validate() } + symbols + .filter { it is KSClassDeclaration && it.validate() } + .forEach { it.accept(BuilderVisitor(), Unit) } + return ret.toList() + } + + inner class BuilderVisitor : KSVisitorVoid() { + override fun visitClassDeclaration(classDeclaration: KSClassDeclaration, data: Unit) { + classDeclaration.primaryConstructor?.accept(this, data) + } + + override fun visitFunctionDeclaration(function: KSFunctionDeclaration, data: Unit) { + val parent = function.parentDeclaration as KSClassDeclaration + val packageName = parent.containingFile!!.packageName.asString() + val className = "${parent.simpleName.asString()}Builder" + + // For regression testing https://github.com/google/ksp/pull/467 + codeGenerator.createNewFile( + Dependencies(true, function.containingFile!!), + "", + "META-INF/proguard/builder-$className", + "pro" + ).use { proguardFile -> + proguardFile.appendText("-keep class $packageName.$className { *; }") + } + + val file = codeGenerator.createNewFile( + Dependencies(true, function.containingFile!!), packageName, className + ) + file.appendText("package $packageName\n\n") + file.appendText("import hello.HELLO\n\n") + file.appendText("class $className{\n") + function.parameters.forEach { + val name = it.name!!.asString() + val typeName = StringBuilder(it.type.resolve().declaration.qualifiedName?.asString() ?: "<ERROR>") + val typeArgs = it.type.element!!.typeArguments + if (it.type.element!!.typeArguments.toList().isNotEmpty()) { + typeName.append("<") + typeName.append( + typeArgs.map { + val type = it.type?.resolve() + "${it.variance.label} ${type?.declaration?.qualifiedName?.asString() ?: "ERROR"}" + + if (type?.nullability == Nullability.NULLABLE) "?" else "" + }.joinToString(", ") + ) + typeName.append(">") + } + file.appendText(" private var $name: $typeName? = null\n") + file.appendText(" internal fun with${name.capitalize()}($name: $typeName): $className {\n") + file.appendText(" this.$name = $name\n") + file.appendText(" return this\n") + file.appendText(" }\n\n") + } + file.appendText(" internal fun build(): ${parent.qualifiedName!!.asString()} {\n") + file.appendText(" return ${parent.qualifiedName!!.asString()}(") + file.appendText( + function.parameters.map { + "${it.name!!.asString()}!!" + }.joinToString(", ") + ) + file.appendText(")\n") + file.appendText(" }\n") + file.appendText("}\n") + file.close() + } + } +} + +class TestProcessorProvider : SymbolProcessorProvider { + override fun create( + env: SymbolProcessorEnvironment, + ): SymbolProcessor { + return BuilderProcessor().apply { + init(env.options, env.kotlinVersion, env.codeGenerator, env.logger) + } + } +} diff --git a/integration-tests/src/test/resources/playground/test-processor/src/main/kotlin/RewriteProcessor.kt b/integration-tests/src/test/resources/playground/test-processor/src/main/kotlin/RewriteProcessor.kt new file mode 100644 index 00000000..6c6e2354 --- /dev/null +++ b/integration-tests/src/test/resources/playground/test-processor/src/main/kotlin/RewriteProcessor.kt @@ -0,0 +1,30 @@ +import com.google.devtools.ksp.processing.* +import com.google.devtools.ksp.symbol.* + +class RewriteProcessor : SymbolProcessor { + lateinit var codeGenerator: CodeGenerator + + fun init( + options: Map<String, String>, + kotlinVersion: KotlinVersion, + codeGenerator: CodeGenerator, + logger: KSPLogger + ) { + this.codeGenerator = codeGenerator + } + + override fun process(resolver: Resolver): List<KSAnnotated> { + val fileKt = codeGenerator.createNewFile(Dependencies(false), "hello", "HELLO", "java") + return emptyList() + } +} + +class RewriteProcessorProvider : SymbolProcessorProvider { + override fun create( + env: SymbolProcessorEnvironment + ): SymbolProcessor { + return RewriteProcessor().apply { + init(env.options, env.kotlinVersion, env.codeGenerator, env.logger) + } + } +} diff --git a/integration-tests/src/test/resources/playground/test-processor/src/main/kotlin/TestProcessor.kt b/integration-tests/src/test/resources/playground/test-processor/src/main/kotlin/TestProcessor.kt new file mode 100644 index 00000000..4b5a3cb5 --- /dev/null +++ b/integration-tests/src/test/resources/playground/test-processor/src/main/kotlin/TestProcessor.kt @@ -0,0 +1,283 @@ +import com.google.devtools.ksp.containingFile +import com.google.devtools.ksp.processing.* +import com.google.devtools.ksp.symbol.* +import java.io.OutputStream + +class TestProcessor : SymbolProcessor { + lateinit var codeGenerator: CodeGenerator + lateinit var file: OutputStream + var invoked = false + + fun emit(s: String, indent: String) { + file.appendText("$indent$s\n") + } + + fun init( + options: Map<String, String>, + kotlinVersion: KotlinVersion, + codeGenerator: CodeGenerator, + logger: KSPLogger + ) { + logger.warn("This is a harmless warning.") + this.codeGenerator = codeGenerator + file = codeGenerator.createNewFile(Dependencies(false), "", "TestProcessor", "log") + emit("TestProcessor: init($options)", "") + + val javaFile = codeGenerator.createNewFile(Dependencies(false), "", "Generated", "java") + javaFile.appendText("class Generated {}") + } + + override fun process(resolver: Resolver): List<KSAnnotated> { + if (invoked) { + return emptyList() + } + val fileKt = codeGenerator.createNewFile(Dependencies(false), "hello", "HELLO", "java") + fileKt.appendText("package hello;\n") + fileKt.appendText("public class HELLO{\n") + fileKt.appendText("public int foo() { return 1234; }\n") + fileKt.appendText("}") + + val files = resolver.getAllFiles() + emit("TestProcessor: process()", "") + val visitor = TestVisitor() + for (file in files) { + emit("TestProcessor: processing ${file.fileName}", "") + file.accept(visitor, "") + } + invoked = true + return emptyList() + } + + inner class TestVisitor : KSVisitor<String, Unit> { + + override fun visitReferenceElement(element: KSReferenceElement, data: String) { + } + + override fun visitModifierListOwner(modifierListOwner: KSModifierListOwner, data: String) { + TODO("Not yet implemented") + } + + override fun visitNode(node: KSNode, data: String) { + TODO("Not yet implemented") + } + + override fun visitPropertyAccessor(accessor: KSPropertyAccessor, data: String) { + TODO("Not yet implemented") + } + + override fun visitDynamicReference(reference: KSDynamicReference, data: String) { + TODO("Not yet implemented") + } + + override fun visitDefNonNullReference(reference: KSDefNonNullReference, data: String) { + TODO("Not yet implemented") + } + + val visited = HashSet<Any>() + + private fun checkVisited(symbol: Any): Boolean { + return if (visited.contains(symbol)) { + true + } else { + visited.add(symbol) + false + } + } + + private fun invokeCommonDeclarationApis(declaration: KSDeclaration, indent: String) { + emit( + "${declaration.modifiers.joinToString(" ")} ${declaration.simpleName.asString()}", indent + ) + declaration.annotations.map { it.accept(this, "$indent ") } + if (declaration.parentDeclaration != null) + emit(" enclosing: ${declaration.parentDeclaration!!.qualifiedName?.asString()}", indent) + declaration.containingFile?.let { emit("${it.packageName.asString()}.${it.fileName}", indent) } + declaration.typeParameters.map { it.accept(this, "$indent ") } + } + + override fun visitFile(file: KSFile, data: String) { +// if (!file.packageName.asString().startsWith("eu.kanade.tachiyomi.data")) { +// return +// } + if (checkVisited(file)) return + file.annotations.forEach { it.accept(this, "$data ") } + emit(file.packageName.asString(), data) + for (declaration in file.declarations) { + declaration.accept(this, data) + } + } + + override fun visitAnnotation(annotation: KSAnnotation, data: String) { + if (checkVisited(annotation)) return + emit("annotation", data) + annotation.annotationType.accept(this, "$data ") + annotation.arguments.forEach { it.accept(this, "$data ") } + } + + override fun visitCallableReference(reference: KSCallableReference, data: String) { + if (checkVisited(reference)) return + emit("element: ", data) + reference.functionParameters.forEach { it.accept(this, "$data ") } + reference.receiverType?.accept(this, "$data receiver") + reference.returnType.accept(this, "$data ") + } + + override fun visitPropertyGetter(getter: KSPropertyGetter, data: String) { + if (checkVisited(getter)) return + emit("propertyGetter: ", data) + getter.annotations.forEach { it.accept(this, "$data ") } + emit(getter.modifiers.joinToString(" "), data) + getter.returnType?.accept(this, "$data ") + } + + override fun visitPropertySetter(setter: KSPropertySetter, data: String) { + if (checkVisited(setter)) return + emit("propertySetter: ", data) + setter.annotations.forEach { it.accept(this, "$data ") } + emit(setter.modifiers.joinToString(" "), data) +// setter.parameter.accept(this, "$data ") + } + + override fun visitTypeArgument(typeArgument: KSTypeArgument, data: String) { + if (checkVisited(typeArgument)) return + typeArgument.annotations.forEach { it.accept(this, "$data ") } + emit( + when (typeArgument.variance) { + Variance.STAR -> "*" + Variance.COVARIANT -> "out" + Variance.CONTRAVARIANT -> "in" + else -> "" + }, + data + ) + typeArgument.type?.accept(this, "$data ") + } + + override fun visitTypeParameter(typeParameter: KSTypeParameter, data: String) { + if (checkVisited(typeParameter)) return + typeParameter.annotations.forEach { it.accept(this, "$data ") } + if (typeParameter.isReified) { + emit("reified ", data) + } + emit( + when (typeParameter.variance) { + Variance.COVARIANT -> "out " + Variance.CONTRAVARIANT -> "in " + else -> "" + } + typeParameter.name.asString(), + data + ) + if (typeParameter.bounds.toList().isNotEmpty()) { + typeParameter.bounds.forEach { it.accept(this, "$data ") } + } + } + + override fun visitValueParameter(valueParameter: KSValueParameter, data: String) { + if (checkVisited(valueParameter)) return + valueParameter.annotations.forEach { it.accept(this, "$data ") } + if (valueParameter.isVararg) { + emit("vararg", "$data ") + } + if (valueParameter.isNoInline) { + emit("noinline", "$data ") + } + if (valueParameter.isCrossInline) { + emit("crossinline ", "$data ") + } + emit(valueParameter.name?.asString() ?: "_", "$data ") + valueParameter.type.accept(this, "$data ") + } + + override fun visitFunctionDeclaration(function: KSFunctionDeclaration, data: String) { + if (checkVisited(function)) return + invokeCommonDeclarationApis(function, data) + for (declaration in function.declarations) { + declaration.accept(this, "$data ") + } + function.parameters.forEach { it.accept(this, "$data ") } + function.typeParameters.forEach { it.accept(this, "$data ") } + function.extensionReceiver?.accept(this, "$data extension:") + emit("returnType:", data) + function.returnType?.accept(this, "$data ") + } + + override fun visitClassDeclaration(classDeclaration: KSClassDeclaration, data: String) { + if (checkVisited(classDeclaration)) return + invokeCommonDeclarationApis(classDeclaration, data) + emit(classDeclaration.classKind.type, data) + for (declaration in classDeclaration.declarations) { + declaration.accept(this, "$data ") + } + classDeclaration.superTypes.forEach { it.accept(this, "$data ") } + classDeclaration.primaryConstructor?.accept(this, "$data ") + } + + override fun visitPropertyDeclaration(property: KSPropertyDeclaration, data: String) { + if (checkVisited(property)) return + invokeCommonDeclarationApis(property, data) + property.type.accept(this, "$data ") + property.extensionReceiver?.accept(this, "$data extension:") + property.setter?.accept(this, "$data ") + property.getter?.accept(this, "$data ") + } + + override fun visitTypeReference(typeReference: KSTypeReference, data: String) { + if (checkVisited(typeReference)) return + typeReference.annotations.forEach { it.accept(this, "$data ") } + val type = typeReference.resolve() + type.let { + emit("resolved to: ${it.declaration.qualifiedName?.asString()}", data) + } + // resolved.accept(this, "$data ") + // TODO: KSTypeReferenceJavaImpl hasn't completed yet. + try { + typeReference.element?.accept(this, "$data ") + } catch (e: IllegalStateException) { + emit("TestProcessor: exception: $e", data) + } + } + + override fun visitAnnotated(annotated: KSAnnotated, data: String) { + } + + override fun visitDeclaration(declaration: KSDeclaration, data: String) { + } + + override fun visitDeclarationContainer(declarationContainer: KSDeclarationContainer, data: String) { + } + + override fun visitParenthesizedReference(reference: KSParenthesizedReference, data: String) { + } + + override fun visitClassifierReference(reference: KSClassifierReference, data: String) { + if (checkVisited(reference)) return + if (reference.typeArguments.toList().isNotEmpty()) { + reference.typeArguments.forEach { it.accept(this, "$data ") } + } + } + + override fun visitTypeAlias(typeAlias: KSTypeAlias, data: String) { + } + + override fun visitValueArgument(valueArgument: KSValueArgument, data: String) { + if (checkVisited(valueArgument)) return + val name = valueArgument.name?.asString() ?: "<no name>" + emit("$name: ${valueArgument.value}", data) + valueArgument.annotations.forEach { it.accept(this, "$data ") } + } + } +} + +class TestProcessorProvider2 : SymbolProcessorProvider { + override fun create( + env: SymbolProcessorEnvironment + ): SymbolProcessor { + return TestProcessor().apply { + init(env.options, env.kotlinVersion, env.codeGenerator, env.logger) + + env.logger.warn("language version: ${env.kotlinVersion}") + env.logger.warn("api version: ${env.apiVersion}") + env.logger.warn("compiler version: ${env.compilerVersion}") + } + } +} diff --git a/integration-tests/src/test/resources/playground/test-processor/src/main/resources/META-INF/services/com.google.devtools.ksp.processing.SymbolProcessorProvider b/integration-tests/src/test/resources/playground/test-processor/src/main/resources/META-INF/services/com.google.devtools.ksp.processing.SymbolProcessorProvider new file mode 100644 index 00000000..3a1528c9 --- /dev/null +++ b/integration-tests/src/test/resources/playground/test-processor/src/main/resources/META-INF/services/com.google.devtools.ksp.processing.SymbolProcessorProvider @@ -0,0 +1,2 @@ +TestProcessorProvider +TestProcessorProvider2 diff --git a/integration-tests/src/test/resources/playground/workload/G.kt b/integration-tests/src/test/resources/playground/workload/G.kt new file mode 100644 index 00000000..f2f80ffe --- /dev/null +++ b/integration-tests/src/test/resources/playground/workload/G.kt @@ -0,0 +1,6 @@ +package g + +import com.example.annotation.Builder + +@Builder +class G diff --git a/integration-tests/src/test/resources/playground/workload/build.gradle.kts b/integration-tests/src/test/resources/playground/workload/build.gradle.kts new file mode 100644 index 00000000..6cb48fad --- /dev/null +++ b/integration-tests/src/test/resources/playground/workload/build.gradle.kts @@ -0,0 +1,36 @@ +import org.jetbrains.kotlin.gradle.tasks.AbstractKotlinCompileTool + +val testRepo: String by project + +plugins { + id("com.google.devtools.ksp") + kotlin("jvm") +} + +version = "1.0-SNAPSHOT" + +repositories { + maven(testRepo) + mavenCentral() + maven("https://maven.pkg.jetbrains.space/kotlin/p/kotlin/bootstrap/") +} + +dependencies { + implementation(kotlin("stdlib")) + implementation(project(":test-processor")) + ksp(project(":test-processor")) +} + +ksp { + arg("option1", "value1") + arg("option2", "value2") +} + +val compileKotlin: AbstractKotlinCompileTool<*> by tasks +tasks.register<Copy>("copyG") { + from("G.kt") + into(File(buildDir, "generatedSources").apply { mkdirs() }) +}.let { + // Magic. `map` creates a provider to propagate task dependency. + compileKotlin.setSource(it.map { it.destinationDir }) +} diff --git a/integration-tests/src/test/resources/playground/workload/src/main/java/com/example/A.kt b/integration-tests/src/test/resources/playground/workload/src/main/java/com/example/A.kt new file mode 100644 index 00000000..e5fa7f97 --- /dev/null +++ b/integration-tests/src/test/resources/playground/workload/src/main/java/com/example/A.kt @@ -0,0 +1,16 @@ +package com.example + +import hello.HELLO + +fun main() { + val hello = HELLO() + println(hello.foo()) + + val builder = AClassBuilder() + builder + .withA(1) + .withB("foo") + .withC(2.3) + val aClass: AClass = builder.build() + println(aClass.foo()) +} diff --git a/integration-tests/src/test/resources/playground/workload/src/main/java/com/example/AClass.kt b/integration-tests/src/test/resources/playground/workload/src/main/java/com/example/AClass.kt new file mode 100644 index 00000000..180dbe6a --- /dev/null +++ b/integration-tests/src/test/resources/playground/workload/src/main/java/com/example/AClass.kt @@ -0,0 +1,17 @@ +package com.example + +import com.example.annotation.Builder +import hello.HELLO + +@Builder +class AClass(private val a: Int, val b: String, val c: Double, val d: HELLO) { + val p = "$a, $b, $c" + fun foo() = HELLO() + val hello = HELLO() + var hello2: HELLO = HELLO() + get() { return hello2 } + private set + class innerClass<T : HELLO> + + val generic = innerClass<HELLO>() +} diff --git a/integration-tests/src/test/resources/playground/workload/src/main/java/com/example/BClass.java b/integration-tests/src/test/resources/playground/workload/src/main/java/com/example/BClass.java new file mode 100644 index 00000000..fcfbcbcf --- /dev/null +++ b/integration-tests/src/test/resources/playground/workload/src/main/java/com/example/BClass.java @@ -0,0 +1,14 @@ +package com.example; + +import com.example.annotation.Builder; +import hello.HELLO; +import java.util.List; + +@Builder +public class BClass { + public HELLO hello; + public HELLO helloFun(){ + return null; + } + public List<HELLO> list = null; +}
\ No newline at end of file |