Test cases for nullability annotations

(cherry picked from commit e09196b)

Author: ting-yuan

integration-tests/src/test/kotlin/com/google/devtools/ksp/test/NullabilityAnnotationsIT.kt

@@ -0,0 +1,49 @@
+package com.google.devtools.ksp.test
+
+import com.google.devtools.ksp.test.fixtures.TemporaryTestProject
+import org.gradle.testkit.runner.BuildResult
+import org.gradle.testkit.runner.GradleRunner
+import org.gradle.testkit.runner.TaskOutcome
+import org.junit.Assert
+import org.junit.Assume
+import org.junit.Rule
+import org.junit.Test
+
+class NullabilityAnnotationsIT() {
+    @Rule
+    @JvmField
+    val project: TemporaryTestProject = TemporaryTestProject("nullability-annotations")
+
+    private fun GradleRunner.buildAndCheck(vararg args: String, extraCheck: (BuildResult) -> Unit = {}) =
+        buildAndCheckOutcome(*args, outcome = TaskOutcome.SUCCESS, extraCheck = extraCheck)
+
+    private fun GradleRunner.buildAndCheckOutcome(
+        vararg args: String,
+        outcome: TaskOutcome,
+        extraCheck: (BuildResult) -> Unit = {}
+    ) {
+        val result = this.withArguments(*args).build()
+
+        Assert.assertEquals(outcome, result.task(":workload:build")?.outcome)
+
+        extraCheck(result)
+    }
+
+    @Test
+    fun testNullableAnnotations() {
+        // FIXME: `clean` fails to delete files on windows.
+        Assume.assumeFalse(System.getProperty("os.name").startsWith("Windows", ignoreCase = true))
+        val gradleRunner = GradleRunner.create().withProjectDir(project.root)
+        gradleRunner.buildAndCheck("clean", "build") { result ->
+            Assert.assertTrue(result.output.contains("w: [ksp] [Nullability check] s0: (String..String?)\n"))
+            Assert.assertTrue(result.output.contains("w: [ksp] [Nullability check] s1: String?\n"))
+            Assert.assertTrue(result.output.contains("w: [ksp] [Nullability check] s2: String\n"))
+            Assert.assertTrue(result.output.contains("w: [ksp] [Nullability check] s3: [@Nullable] String?\n"))
+            Assert.assertTrue(result.output.contains("w: [ksp] [Nullability check] s4: [@NotNull] String\n"))
+            Assert.assertTrue(result.output.contains("w: [ksp] [Nullability check] s5: [@Nullable] String?\n"))
+            Assert.assertTrue(result.output.contains("w: [ksp] [Nullability check] s6: [@NonNull] String\n"))
+            Assert.assertTrue(result.output.contains("w: [ksp] [Nullability check] s7: (String..String?)\n"))
+            Assert.assertTrue(result.output.contains("w: [ksp] [Nullability check] s8: (String..String?)\n"))
+        }
+    }
+}

integration-tests/src/test/resources/nullability-annotations/build.gradle.kts

@@ -0,0 +1,8 @@
+plugins {
+    kotlin("jvm")
+}
+
+repositories {
+    mavenCentral()
+    maven("https://redirector.kotlinlang.org/maven/bootstrap/")
+}

integration-tests/src/test/resources/nullability-annotations/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://redirector.kotlinlang.org/maven/bootstrap/")
+    }
+}
+
+rootProject.name = "playground"
+
+include(":workload")
+include(":test-processor")

integration-tests/src/test/resources/nullability-annotations/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://redirector.kotlinlang.org/maven/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")
+}

integration-tests/src/test/resources/nullability-annotations/test-processor/src/main/kotlin/TestProcessor.kt

@@ -0,0 +1,49 @@
+import com.google.devtools.ksp.KspExperimental
+import com.google.devtools.ksp.getClassDeclarationByName
+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
+    lateinit var logger: KSPLogger
+    var invoked = false
+
+    fun init(
+        options: Map<String, String>,
+        kotlinVersion: KotlinVersion,
+        codeGenerator: CodeGenerator,
+        logger: KSPLogger
+    ) {
+        this.logger = logger
+        this.codeGenerator = codeGenerator
+    }
+
+    @OptIn(KspExperimental::class)
+    override fun process(resolver: Resolver): List<KSAnnotated> {
+        if (invoked) {
+            return emptyList()
+        }
+
+        resolver.getClassDeclarationByName("com.example.NullabilityTest")?.let { tc ->
+            tc.declarations.filterIsInstance<KSFunctionDeclaration>().forEach { decl ->
+                val declName = decl.simpleName.asString()
+                val returnType = decl.returnType!!.resolve()
+                logger.warn("[Nullability check] $declName: $returnType")
+            }
+        }
+        invoked = true
+        return emptyList()
+    }
+}
+
+class TestProcessorProvider : SymbolProcessorProvider {
+    override fun create(
+        env: SymbolProcessorEnvironment
+    ): SymbolProcessor {
+        return TestProcessor().apply {
+            init(env.options, env.kotlinVersion, env.codeGenerator, env.logger)
+        }
+    }
+}

integration-tests/src/test/resources/nullability-annotations/test-processor/src/main/resources/META-INF/services/com.google.devtools.ksp.processing.SymbolProcessorProvider

@@ -0,0 +1 @@
+TestProcessorProvider

integration-tests/src/test/resources/nullability-annotations/workload/build.gradle.kts

@@ -0,0 +1,40 @@
+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://redirector.kotlinlang.org/maven/bootstrap/")
+}
+
+dependencies {
+    implementation(kotlin("stdlib"))
+    implementation(project(":test-processor"))
+    implementation("javax.annotation:javax.annotation-api:1.3.2")
+    implementation("com.google.code.findbugs:jsr305:3.0.2")
+    implementation("org.checkerframework:checker-qual:1.8.1")
+    implementation("org.jetbrains:annotations:26.0.2-1")
+    ksp(project(":test-processor"))
+}
+
+ksp {
+    arg("option1", "value1")
+    arg("option2", "value2")
+}
+
+val compileKotlin: AbstractKotlinCompileTool<*> by tasks
+tasks.register<Copy>("copyG") {
+    from("G.kt")
+    into(layout.buildDirectory.file("generatedSources"))
+}.let {
+    // Magic. `map` creates a provider to propagate task dependency.
+    compileKotlin.source(it.map { it.destinationDir })
+}

integration-tests/src/test/resources/nullability-annotations/workload/src/main/java/com/example/NullabilityTest.java

@@ -0,0 +1,35 @@
+package com.example;
+
+// Unrecognized by Kotlin compiler. Should not affect nullability at all.
+@interface Nullable {}
+
+// Unrecognized by Kotlin compiler. Should not affect nullability at all.
+@interface NotNull {}
+
+interface NullabilityTest {
+  String s0();
+
+  @javax.annotation.Nullable
+  String s1();
+
+  @javax.annotation.Nonnull
+  String s2();
+
+  @org.jetbrains.annotations.Nullable
+  String s3();
+
+  @org.jetbrains.annotations.NotNull
+  String s4();
+
+  @org.checkerframework.checker.nullness.qual.Nullable
+  String s5();
+
+  @org.checkerframework.checker.nullness.qual.NonNull
+  String s6();
+
+  @Nullable
+  String s7();
+
+  @NotNull
+  String s8();
+}