Skip KSP config resolution when no KSP dependencies exist

Similar to PR #159, this optimizes configuration time by skipping
expensive KSP resolution for projects/variants without KSP deps.

- Add hasKspDependencies() to check project's base ksp configuration
- Conditionally process KSP configs only when dependencies exist
- Skip processor class extraction and resolution when not needed

Author: minkuan88

grazel-gradle-plugin/src/main/kotlin/com/grab/grazel/tasks/internal/ResolveVariantDependenciesTask.kt

@@ -18,6 +18,7 @@ package com.grab.grazel.tasks.internal
 
 import com.grab.grazel.gradle.dependencies.KspProcessorClassExtractor
 import com.grab.grazel.gradle.dependencies.ResolvedComponentsVisitor
+import com.grab.grazel.gradle.hasKsp
 import com.grab.grazel.gradle.dependencies.model.ExcludeRule
 import com.grab.grazel.gradle.dependencies.model.ResolveDependenciesResult
 import com.grab.grazel.gradle.dependencies.model.ResolveDependenciesResult.Companion.Scope.COMPILE
@@ -285,6 +286,28 @@ internal abstract class ResolveVariantDependenciesTask : DefaultTask() {
             return hasDirectDeps
         }
 
+        /**
+         * Check if a variant has any KSP dependencies.
+         * Checks the project's base 'ksp' configuration which should exist at configuration time.
+         */
+        private fun hasKspDependencies(variant: Variant<*>, project: Project): Boolean {
+            if (!project.hasKsp) return false
+
+            // Check if project has any KSP dependencies declared
+            // The 'ksp' configuration is the base config that variant-specific configs extend from
+            val kspConfig = project.configurations.findByName("ksp")
+            val hasKspDeps = kspConfig?.dependencies
+                ?.filterIsInstance<ExternalDependency>()
+                ?.isNotEmpty() == true
+
+            if (!hasKspDeps) {
+                project.logger.info(
+                    "Grazel: Skipping KSP resolution for variant '${variant.name}' (no KSP dependencies)"
+                )
+            }
+            return hasKspDeps
+        }
+
         private fun processVariant(
             project: Project,
             variant: Variant<*>,
@@ -327,25 +350,36 @@ internal abstract class ResolveVariantDependenciesTask : DefaultTask() {
                     }.filterValues { it.isNotEmpty() }
             }
 
-            // Collect KSP direct dependencies
-            val kspConfigurationProvider = project.provider { variant.kspConfiguration }
-            val kspExternalDependencies = kspConfigurationProvider.map { configs ->
-                configs
-                    .filter { it.isCanBeResolved }
-                    .asSequence()
-                    .flatMap { it.incoming.dependencies }
-                    .filterIsInstance<ExternalDependency>()
-            }
-            val directDependenciesKsp = kspExternalDependencies.map { deps ->
-                deps.associateTo(TreeMap()) { "${it.group}:${it.name}" to "${it.group}:${it.name}" }
-            }
-            // Extract processor classes from KSP JARs
-            val processorClasses = kspConfigurationProvider.map { configs ->
-                configs
-                    .filter { it.isCanBeResolved }
-                    .flatMap { KspProcessorClassExtractor.extractProcessorClasses(it).entries }
-                    .associate { it.key to it.value.firstOrNull().orEmpty() }
-                    .filterValues { it.isNotEmpty() }
+            // Check if variant has KSP dependencies before processing
+            val hasKsp = hasKspDependencies(variant, project)
+
+            // Collect KSP direct dependencies only if variant has KSP deps
+            val directDependenciesKsp: org.gradle.api.provider.Provider<Map<String, String>>
+            val processorClasses: org.gradle.api.provider.Provider<Map<String, String>>
+
+            if (hasKsp) {
+                val kspConfigurationProvider = project.provider { variant.kspConfiguration }
+                val kspExternalDependencies = kspConfigurationProvider.map { configs ->
+                    configs
+                        .filter { it.isCanBeResolved }
+                        .asSequence()
+                        .flatMap { it.incoming.dependencies }
+                        .filterIsInstance<ExternalDependency>()
+                }
+                directDependenciesKsp = kspExternalDependencies.map { deps ->
+                    deps.associateTo(TreeMap()) { "${it.group}:${it.name}" to "${it.group}:${it.name}" }
+                }
+                // Extract processor classes from KSP JARs
+                processorClasses = kspConfigurationProvider.map { configs ->
+                    configs
+                        .filter { it.isCanBeResolved }
+                        .flatMap { KspProcessorClassExtractor.extractProcessorClasses(it).entries }
+                        .associate { it.key to it.value.firstOrNull().orEmpty() }
+                        .filterValues { it.isNotEmpty() }
+                }
+            } else {
+                directDependenciesKsp = project.provider { emptyMap() }
+                processorClasses = project.provider { emptyMap() }
             }
 
             val resolveVariantDependenciesTask = project.tasks
@@ -359,12 +393,14 @@ internal abstract class ResolveVariantDependenciesTask : DefaultTask() {
                         compileConfiguration.add(it.incoming.resolutionResult.rootComponent)
                     }
 
-                    // Resolve KSP configurations
-                    variant.kspConfiguration
-                        .filter { it.isCanBeResolved }
-                        .forEach {
-                            kspConfiguration.add(it.incoming.resolutionResult.rootComponent)
-                        }
+                    // Resolve KSP configurations only if variant has KSP deps
+                    if (hasKsp) {
+                        variant.kspConfiguration
+                            .filter { it.isCanBeResolved }
+                            .forEach {
+                                kspConfiguration.add(it.incoming.resolutionResult.rootComponent)
+                            }
+                    }
 
                     compileDirectDependencies.set(directDependenciesCompile)
                     compileExcludeRules.set(excludeRulesCompile)