Allow to override the enableFastInit flag via command line for Hilt.

java/dagger/hilt/android/plugin/main/src/main/kotlin/dagger/hilt/android/plugin/HiltCommandLineArgumentProvider.kt

@@ -20,39 +20,38 @@ import dagger.hilt.processor.internal.optionvalues.GradleProjectType
 import org.gradle.api.tasks.Input
 import org.gradle.process.CommandLineArgumentProvider
 
-/**
- * Plugin configured annotation processor options provider.
- */
+/** Plugin configured annotation processor options provider. */
 internal class HiltCommandLineArgumentProvider(
-  @get:Input
-  val forKsp: Boolean,
-  @get:Input
-  val projectType: GradleProjectType,
-  @get:Input
-  val enableAggregatingTask: Boolean,
-  @get:Input
-  val disableCrossCompilationRootValidation: Boolean
-): CommandLineArgumentProvider {
+  @get:Input val forKsp: Boolean,
+  @get:Input val projectType: GradleProjectType,
+  @get:Input val enableAggregatingTask: Boolean,
+  @get:Input val disableCrossCompilationRootValidation: Boolean,
+  @get:Input val enableFastInit: Boolean,
+) : CommandLineArgumentProvider {
 
   private val prefix = if (forKsp) "" else "-A"
 
-  override fun asArguments() = buildMap {
-    // Enable Dagger's fast-init, the best mode for Hilt.
-    put("dagger.fastInit", "enabled")
-    // Disable @AndroidEntryPoint superclass validation.
-    put("dagger.hilt.android.internal.disableAndroidSuperclassValidation", "true")
-    // Report project type for root validation.
-    put("dagger.hilt.android.internal.projectType", projectType.toString())
+  override fun asArguments() =
+    buildMap {
+        // Enable Dagger's fast-init, the best mode for Hilt.
+        if (enableFastInit) {
+          put("dagger.fastInit", "enabled")
+        }
+        // Disable @AndroidEntryPoint superclass validation.
+        put("dagger.hilt.android.internal.disableAndroidSuperclassValidation", "true")
+        // Report project type for root validation.
+        put("dagger.hilt.android.internal.projectType", projectType.toString())
 
-    // Disable the aggregating processor if aggregating task is enabled.
-    if (enableAggregatingTask) {
-      put("dagger.hilt.internal.useAggregatingRootProcessor", "false")
-    }
-    // Disable cross compilation root validation.
-    // The plugin option duplicates the processor flag because it is an input of the
-    // aggregating task.
-    if (disableCrossCompilationRootValidation) {
-      put("dagger.hilt.disableCrossCompilationRootValidation", "true")
-    }
-  }.map { (key, value) -> "$prefix$key=$value" }
-}
+        // Disable the aggregating processor if aggregating task is enabled.
+        if (enableAggregatingTask) {
+          put("dagger.hilt.internal.useAggregatingRootProcessor", "false")
+        }
+        // Disable cross compilation root validation.
+        // The plugin option duplicates the processor flag because it is an input of the
+        // aggregating task.
+        if (disableCrossCompilationRootValidation) {
+          put("dagger.hilt.disableCrossCompilationRootValidation", "true")
+        }
+      }
+      .map { (key, value) -> "$prefix$key=$value" }
+}

java/dagger/hilt/android/plugin/main/src/main/kotlin/dagger/hilt/android/plugin/HiltExtension.kt

@@ -39,9 +39,11 @@ interface HiltExtension {
    *
    * This flag is not necessary when com.android.tools.build:gradle:4.2.0+ is used.
    */
-  @Deprecated("Since Hilt Android Gradle plugin requires the usage of the Android " +
+  @Deprecated(
+    "Since Hilt Android Gradle plugin requires the usage of the Android " +
       "Gradle plugin (AGP) version 7.0 or higher this option is no longer necessary and has no " +
-      "effect in the configuration.")
+      "effect in the configuration."
+  )
   var enableTransformForLocalTests: Boolean
 
   /**
@@ -66,9 +68,11 @@ interface HiltExtension {
 
 internal open class HiltExtensionImpl : HiltExtension {
   override var enableExperimentalClasspathAggregation: Boolean = false
-  @Deprecated("Since Hilt Android Gradle plugin requires the usage of the Android " +
+  @Deprecated(
+    "Since Hilt Android Gradle plugin requires the usage of the Android " +
       "Gradle plugin (AGP) version 7.0 or higher this option is no longer necessary and has no " +
-      "effect in the configuration.")
+      "effect in the configuration."
+  )
   override var enableTransformForLocalTests: Boolean = false
   override var enableAggregatingTask: Boolean = true
   override var disableCrossCompilationRootValidation: Boolean = false

java/dagger/hilt/android/plugin/main/src/main/kotlin/dagger/hilt/android/plugin/HiltGradlePlugin.kt

@@ -353,7 +353,6 @@ class HiltGradlePlugin @Inject constructor(private val providers: ProviderFactor
         if (commonExtension.compileOptions.isJava8Compatible()) {
           compilerArgs.add("-parameters")
         }
-        compilerArgs.add("-Adagger.fastInit=enabled")
         compilerArgs.add("-Adagger.hilt.internal.useAggregatingRootProcessor=false")
         compilerArgs.add("-Adagger.hilt.android.internal.disableAndroidSuperclassValidation=true")
         encoding = commonExtension.compileOptions.encoding
@@ -403,6 +402,19 @@ class HiltGradlePlugin @Inject constructor(private val providers: ProviderFactor
       }
 
     androidExtension.onAllVariants { variant, _ ->
+      // Error if the user is trying to set the fastInit flag via build file.
+      if (
+        variant.javaCompilation
+          ?.annotationProcessor
+          ?.arguments
+          ?.get()
+          ?.containsKey("dagger.fastInit") ?: false
+      ) {
+        error(
+          "[Hilt]: The flag 'dagger.fastInit' can only be set via command line. i.e. " +
+            "add '-Pdagger.fastInit=enabled' to your command line."
+        )
+      }
       // Pass annotation processor flags via a CommandLineArgumentProvider so that plugin
       // options defined in the extension are populated from the user's build file.
       val argsProducer: (Task) -> CommandLineArgumentProvider = { task ->
@@ -411,6 +423,7 @@ class HiltGradlePlugin @Inject constructor(private val providers: ProviderFactor
           projectType = projectType,
           enableAggregatingTask = isAggregatingTaskEnabled(),
           disableCrossCompilationRootValidation = !isCrossCompilationRootValidationEnabled(),
+          enableFastInit = isFastInitEnabled(),
         )
       }
       addJavaTaskProcessorOptions(project, variant, argsProducer)
@@ -530,4 +543,16 @@ private class HiltPluginEnvironment(
 
   fun isCrossCompilationRootValidationEnabled() =
     !hiltExtension.disableCrossCompilationRootValidation
+
+  fun isFastInitEnabled(): Boolean {
+    // Always allow overriding from the command line.
+    val cmdOverride = project.findProperty("dagger.hilt.fastInit")?.toString()?.toBoolean()
+    if (cmdOverride != null) {
+      project.logger.info(
+        "[Hilt] Overriding dagger.hilt.fastInit to $cmdOverride from command line."
+      )
+      return cmdOverride
+    }
+    return true
+  }
 }