formatting and other stuff ig idk

1 files changed, 42 insertions, 17 deletions

diff --git a/annotations/src/main/kotlin/io/github/moulberry/notenoughupdates/autosubscribe/NEUAutoSymbolProcessor.kt b/annotations/src/main/kotlin/io/github/moulberry/notenoughupdates/autosubscribe/NEUAutoSymbolProcessor.kt
index 3ab71912..157749d0 100644
--- a/annotations/src/main/kotlin/io/github/moulberry/notenoughupdates/autosubscribe/NEUAutoSymbolProcessor.kt
+++ b/annotations/src/main/kotlin/io/github/moulberry/notenoughupdates/autosubscribe/NEUAutoSymbolProcessor.kt
@@ -28,22 +28,29 @@ import com.google.devtools.ksp.processing.SymbolProcessor
 import com.google.devtools.ksp.symbol.ClassKind
 import com.google.devtools.ksp.symbol.KSAnnotated
 import com.google.devtools.ksp.symbol.KSClassDeclaration
+import com.google.devtools.ksp.symbol.Modifier
+import com.google.devtools.ksp.validate
 import com.squareup.kotlinpoet.FileSpec
 import com.squareup.kotlinpoet.FunSpec
 import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy
 import com.squareup.kotlinpoet.TypeSpec
-import com.squareup.kotlinpoet.ksp.addOriginatingKSFile
+import com.squareup.kotlinpoet.asTypeName
 import com.squareup.kotlinpoet.ksp.toClassName
 import com.squareup.kotlinpoet.ksp.writeTo
 import java.util.function.Consumer
+import java.util.function.Supplier
 
 internal class NEUAutoSymbolProcessor(val codeGenerator: CodeGenerator, val logger: KSPLogger) : SymbolProcessor {
-    fun collectSubscribers(elements: Sequence<KSAnnotated>): List<NEUEventSubscriber> = buildList {
+    fun collectSubscribers(elements: List<KSAnnotated>): List<NEUEventSubscriber> = buildList {
         for (element in elements) {
             if (element !is KSClassDeclaration) {
                 logger.error("@NEUAutoSubscribe is only valid on class or object declarations", element)
                 continue
             }
+            if (element.typeParameters.isNotEmpty()) {
+                logger.error("@NEUAutoSubscribe is not valid on generic classes", element)
+                continue
+            }
             val name = element.qualifiedName
             if (name == null) {
                 logger.error("@NEUAutoSubscribe could not find name", element)
@@ -59,13 +66,25 @@ internal class NEUAutoSymbolProcessor(val codeGenerator: CodeGenerator, val logg
                     }
                     if (instanceGetter != null) {
                         val returnType = instanceGetter.returnType
-                        // TODO: typechecking
+                        if (returnType == null || !element.asStarProjectedType().isAssignableFrom(returnType.resolve())) {
+                            logger.error(
+                                "getInstance() does not have the expected return type ${element.asStarProjectedType()}",
+                                instanceGetter
+                            )
+                            continue
+                        }
                         add(NEUEventSubscriber(InvocationKind.GET_INSTANCE, element))
                     } else if (instanceVariable != null) {
-                        // TODO: typechecking
+                        val variableType = instanceVariable.type
+                        if (!element.asStarProjectedType().isAssignableFrom(variableType.resolve())) {
+                            logger.error(
+                                "INSTANCE does not have expected type ${element.asStarProjectedType()}",
+                                instanceVariable
+                            )
+                            continue
+                        }
                         add(NEUEventSubscriber(InvocationKind.ACCESS_INSTANCE, element))
                     } else {
-                        // TODO: typechecking
                         add(NEUEventSubscriber(InvocationKind.DEFAULT_CONSTRUCTOR, element))
                     }
                 }
@@ -88,46 +107,52 @@ internal class NEUAutoSymbolProcessor(val codeGenerator: CodeGenerator, val logg
 
     val subscribers = mutableListOf<NEUEventSubscriber>()
     override fun process(resolver: Resolver): List<KSAnnotated> {
-        val candidates = resolver.getSymbolsWithAnnotation(NEUAutoSubscribe::class.qualifiedName!!)
-        subscribers.addAll(collectSubscribers(candidates))
-        return emptyList()
+        val candidates = resolver.getSymbolsWithAnnotation(NEUAutoSubscribe::class.qualifiedName!!).toList()
+        val valid = candidates.filter { it.validate() }
+        val invalid = candidates.filter { !it.validate() }
+
+        subscribers.addAll(collectSubscribers(valid))
+        return invalid
     }
 
     override fun finish() {
         if (subscribers.isEmpty()) return
+        val deps = subscribers.mapNotNull { it.declaration.containingFile }
+        logger.info("Dependencies: $deps")
         FileSpec.builder("io.github.moulberry.notenoughupdates.autosubscribe", "AutoLoad")
             .addFileComment("@generated by ${NEUAutoSymbolProcessor::class.simpleName}")
             .addType(
                 TypeSpec.objectBuilder("AutoLoad")
                     .addFunction(
                         FunSpec.builder("provide")
-                            .addParameter("consumer", Consumer::class.parameterizedBy(Any::class))
+                            .addParameter(
+                                "consumer",
+                                Consumer::class.asTypeName()
+                                    .parameterizedBy(Supplier::class.parameterizedBy(Any::class))
+                            )
                             .apply {
                                 subscribers.sortedBy { it.declaration.simpleName.asString() }.forEach { (invocationKind, declaration) ->
                                     when (invocationKind) {
                                         InvocationKind.GET_INSTANCE -> addStatement(
-                                            "consumer.accept(%T.getInstance())",
+                                            "consumer.accept { %T.getInstance() }",
                                             declaration.toClassName()
                                         )
 
                                         InvocationKind.OBJECT_INSTANCE -> addStatement(
-                                            "consumer.accept(%T)",
+                                            "consumer.accept { %T }",
                                             declaration.toClassName()
                                         )
 
                                         InvocationKind.DEFAULT_CONSTRUCTOR -> addStatement(
-                                            "consumer.accept(%T())",
+                                            "consumer.accept { %T() }",
                                             declaration.toClassName()
                                         )
 
                                         InvocationKind.ACCESS_INSTANCE -> addStatement(
-                                            "consumer.accept(%T.INSTANCE)",
+                                            "consumer.accept { %T.INSTANCE }",
                                             declaration.toClassName()
                                         )
                                     }
-                                    declaration.containingFile?.let {
-                                        addOriginatingKSFile(it)
-                                    }
                                 }
                             }
                             .build()
@@ -135,6 +160,6 @@ internal class NEUAutoSymbolProcessor(val codeGenerator: CodeGenerator, val logg
                     .build()
             )
             .build()
-            .writeTo(codeGenerator, aggregating = true)
+            .writeTo(codeGenerator, aggregating = true, originatingKSFiles = deps)
     }
 }