add symbol validation API

Author: neetopia

api/src/main/kotlin/com/google/devtools/ksp/utils.kt

@@ -20,6 +20,7 @@ package com.google.devtools.ksp
 
 import com.google.devtools.ksp.processing.Resolver
 import com.google.devtools.ksp.symbol.*
+import com.google.devtools.ksp.visitor.KSValidateVisitor
 
 /**
  * Try to resolve the [KSClassDeclaration] for a class using its fully qualified name.
@@ -78,6 +79,14 @@ fun KSDeclaration.isLocal(): Boolean {
     return this.parentDeclaration != null && this.parentDeclaration !is KSClassDeclaration
 }
 
+/**
+ * Perform a validation on a given symbol to check if all interested types in symbols enclosed scope are valid, i.e. resolvable.
+ * @param predicate: A lambda for filtering interested symbols for performance purpose. Default checks all.
+ */
+fun KSNode.validate(predicate: (KSNode, KSNode) -> Boolean = { _, _-> true } ): Boolean {
+    return this.accept(KSValidateVisitor(predicate), Unit)
+}
+
 /**
  * Find the KSClassDeclaration that the alias points to recursively.
  */

api/src/main/kotlin/com/google/devtools/ksp/visitor/KSValidateVisitor.kt

@@ -0,0 +1,78 @@
+package com.google.devtools.ksp.visitor
+
+import com.google.devtools.ksp.symbol.*
+
+class KSValidateVisitor(private val predicate: (KSNode, KSNode) -> Boolean) : KSDefaultVisitor<Unit, Boolean>() {
+    private fun validateDeclarations(declarationContainer: KSDeclarationContainer): Boolean {
+        return !declarationContainer.declarations.any { predicate(declarationContainer, it) && !it.accept(this, Unit) }
+    }
+
+    private fun validateTypeParameters(declaration: KSDeclaration): Boolean {
+        return !declaration.typeParameters.any { predicate(declaration, it) && !it.accept(this, Unit) }
+    }
+
+    private fun validateType(type: KSType): Boolean {
+        return !type.isError && !type.arguments.any { it.type?.accept(this, Unit) == false }
+    }
+
+    override fun defaultHandler(node: KSNode, data: Unit): Boolean {
+        throw IllegalStateException("unhandled validation condition, please file a bug at https://github.com/google/ksp/issues/new")
+    }
+
+    override fun visitTypeReference(typeReference: KSTypeReference, data: Unit): Boolean {
+        return validateType(typeReference.resolve())
+    }
+
+    override fun visitClassDeclaration(classDeclaration: KSClassDeclaration, data: Unit): Boolean {
+        if (!validateTypeParameters(classDeclaration)) {
+            return false
+        }
+        if (classDeclaration.asStarProjectedType().isError) {
+            return false
+        }
+        if (classDeclaration.superTypes.any { predicate(classDeclaration, it) && !it.accept(this, Unit) }) {
+            return false
+        }
+        if (!validateDeclarations(classDeclaration)) {
+            return false
+        }
+        return true
+    }
+
+    override fun visitFunctionDeclaration(function: KSFunctionDeclaration, data: Unit): Boolean {
+        if (function.returnType != null && !(predicate(function, function.returnType!!) && function.returnType!!.accept(this, data))) {
+            return false
+        }
+        if (function.parameters.any { predicate(function, it) && !it.accept(this, Unit)}) {
+            return false
+        }
+        if (!validateTypeParameters(function)) {
+            return false
+        }
+        if (!validateDeclarations(function)) {
+            return false
+        }
+        return true
+    }
+
+    override fun visitPropertyDeclaration(property: KSPropertyDeclaration, data: Unit): Boolean {
+        if (predicate(property, property.type) && property.type.resolve().isError) {
+            return false
+        }
+        if (!validateTypeParameters(property)) {
+            return false
+        }
+        return true
+    }
+
+    override fun visitTypeParameter(typeParameter: KSTypeParameter, data: Unit): Boolean {
+        if (typeParameter.bounds.any { predicate(typeParameter, it) && !it.accept(this, Unit) }) {
+            return false
+        }
+        return true
+    }
+
+    override fun visitValueParameter(valueParameter: KSValueParameter, data: Unit): Boolean {
+        return valueParameter.type?.accept(this, Unit) != false
+    }
+}

compiler-plugin/src/main/kotlin/com/google/devtools/ksp/processor/ValidateProcessor.kt

@@ -0,0 +1,31 @@
+package com.google.devtools.ksp.processor
+
+import com.google.devtools.ksp.getClassDeclarationByName
+import com.google.devtools.ksp.processing.Resolver
+import com.google.devtools.ksp.symbol.KSDeclaration
+import com.google.devtools.ksp.validate
+
+class ValidateProcessor : AbstractTestProcessor() {
+    val results = mutableListOf<String>()
+
+    private fun validate(symbol: KSDeclaration) {
+        if (symbol.validate()) {
+            results.add("${symbol.simpleName.asString()} valid")
+        } else {
+            results.add("${symbol.simpleName.asString()} invalid")
+        }
+    }
+    override fun toResult(): List<String> = results
+
+    override fun process(resolver: Resolver) {
+        val ErrorInMember = resolver.getClassDeclarationByName("ErrorInMember")!!
+        val GoodClass = resolver.getClassDeclarationByName("GoodClass")!!
+        val C = resolver.getClassDeclarationByName("C")!!
+        val BadJavaClass = resolver.getClassDeclarationByName("BadJavaClass")!!
+        validate(ErrorInMember)
+        ErrorInMember.declarations.map { validate(it) }
+        validate(GoodClass)
+        validate(C)
+        validate(BadJavaClass)
+    }
+}

compiler-plugin/src/test/java/com/google/devtools/ksp/test/KotlinKSPTestGenerated.java

@@ -176,6 +176,11 @@ public void testVarianceTypeCheck() throws Exception {
         runTest("testData/api/varianceTypeCheck.kt");
     }
 
+    @TestMetadata("validateTypes.kt")
+    public void testValidateTypes() throws Exception {
+        runTest("testData/api/validateTypes.kt");
+    }
+
     @TestMetadata("visibilities.kt")
     public void testVisibilities() throws Exception {
         runTest("testData/api/visibilities.kt");

compiler-plugin/testData/api/validateTypes.kt

@@ -0,0 +1,31 @@
+// WITH_RUNTIME
+// TEST PROCESSOR: ValidateProcessor
+// EXPECTED:
+// ErrorInMember invalid
+// goodProp valid
+// errorFun invalid
+// GoodClass valid
+// C valid
+// BadJavaClass invalid
+// END
+// FILE: a.kt
+class ErrorInMember : C {
+    val goodProp: Int
+    fun errorFun(): NonExistType {
+
+    }
+}
+
+open class GoodClass {
+    val a: Int
+
+    fun foo(): Int = 1
+}
+
+// FILE: C.java
+
+public class C extends GoodClass {}
+
+class BadJavaClass extends NonExistType {
+
+}