Add a dagger.experimentalKsp compiler option.

java/dagger/hilt/android/plugin/main/src/test/kotlin/SPIPluginTest.kt

@@ -54,6 +54,11 @@ class SPIPluginTest(val backend: Backend) {
         gradleRunner.addPluginId("kotlin-kapt")
       } else {
         gradleRunner.addPluginId("com.google.devtools.ksp")
+        gradleRunner.addAdditionalClosure("""
+        |ksp {
+        |    arg("dagger.allowKsp", "enabled")
+        |}
+        """.trimMargin())
       }
       gradleRunner.addAdditionalClosure("""
       |kotlin {

java/dagger/hilt/android/testing/compile/HiltCompilerTests.java

@@ -61,6 +61,7 @@
 import dagger.testing.compile.CompilerTests;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.function.Consumer;
@@ -211,7 +212,7 @@ public abstract static class HiltCompiler {
     static Builder builder() {
       return new AutoValue_HiltCompilerTests_HiltCompiler.Builder()
           // Set the builder defaults.
-          .processorOptions(ImmutableMap.of())
+          .processorOptions(CompilerTests.DEFAULT_PROCESSOR_OPTIONS)
           .additionalJavacProcessors(ImmutableList.of())
           .additionalKspProcessors(ImmutableList.of())
           .processingSteps(ImmutableList.of())
@@ -235,7 +236,11 @@ static Builder builder() {
 
     /** Returns a new {@link HiltCompiler} instance with the annotation processors options. */
     public HiltCompiler withProcessorOptions(ImmutableMap<String, String> processorOptions) {
-      return toBuilder().processorOptions(processorOptions).build();
+      // Add default processor options first to allow overridding with new key-value pairs.
+      Map<String, String> newProcessorOptions =
+          new HashMap<>(CompilerTests.DEFAULT_PROCESSOR_OPTIONS);
+      newProcessorOptions.putAll(processorOptions);
+      return toBuilder().processorOptions(ImmutableMap.copyOf(newProcessorOptions)).build();
     }
 
     /** Returns the processing steps suppliers. */

java/dagger/internal/codegen/compileroption/CompilerOptions.java

@@ -134,6 +134,14 @@ public int keysPerComponentShard(XTypeElement component) {
     return 3500;
   }
 
+  /**
+   * Returns {@code true} if the Dagger/Hilt KSP processors are allowed.
+   *
+   * <p>Note: the Dagger/Hilt KSP processors are still in alpha. Once the processors are stable, we
+   * will likely remove the need for this flag.
+   */
+  public abstract boolean allowKsp();
+
   /**
    * This option enables a fix to an issue where Dagger previously would erroneously allow
    * multibinding contributions in a component to have dependencies on child components. This will

java/dagger/internal/codegen/compileroption/ProcessingEnvironmentCompilerOptions.java

@@ -22,6 +22,7 @@
 import static com.google.common.collect.Sets.immutableEnumSet;
 import static dagger.internal.codegen.compileroption.FeatureStatus.DISABLED;
 import static dagger.internal.codegen.compileroption.FeatureStatus.ENABLED;
+import static dagger.internal.codegen.compileroption.ProcessingEnvironmentCompilerOptions.Feature.ALLOW_KSP;
 import static dagger.internal.codegen.compileroption.ProcessingEnvironmentCompilerOptions.Feature.EXPERIMENTAL_AHEAD_OF_TIME_SUBCOMPONENTS;
 import static dagger.internal.codegen.compileroption.ProcessingEnvironmentCompilerOptions.Feature.EXPERIMENTAL_ANDROID_MODE;
 import static dagger.internal.codegen.compileroption.ProcessingEnvironmentCompilerOptions.Feature.EXPERIMENTAL_DAGGER_ERROR_MESSAGES;
@@ -114,6 +115,11 @@ private boolean fastInitInternal(XTypeElement component) {
     return isEnabled(FAST_INIT);
   }
 
+  @Override
+  public boolean allowKsp() {
+    return isEnabled(ALLOW_KSP);
+  }
+
   @Override
   public boolean formatGeneratedSource() {
     return isEnabled(FORMAT_GENERATED_SOURCE);
@@ -254,6 +260,15 @@ private ProcessingEnvironmentCompilerOptions checkValid() {
                 "https://dagger.dev/dev-guide/compiler-options#ignore-provision-key-wildcards"));
       }
     }
+    if (processingEnv.getBackend() == XProcessingEnv.Backend.KSP
+            && !isEnabled(ALLOW_KSP)) {
+      messager.printMessage(
+          Diagnostic.Kind.ERROR,
+          String.format(
+              "Dagger's KSP processor is still in alpha. Until the feature goes stable, set the "
+                  + "'%s=ENABLED' compiler option when using KSP.",
+              optionName(ALLOW_KSP)));
+    }
     return this;
   }
 
@@ -315,6 +330,8 @@ public String toString() {
   enum Feature implements EnumOption<FeatureStatus> {
     FAST_INIT,
 
+    ALLOW_KSP,
+
     EXPERIMENTAL_ANDROID_MODE,
 
     FORMAT_GENERATED_SOURCE,

java/dagger/internal/codegen/javac/JavacPluginCompilerOptions.java

@@ -140,4 +140,9 @@ public boolean generatedClassExtendsComponent() {
   public boolean ignoreProvisionKeyWildcards() {
     return false;
   }
+
+  @Override
+  public boolean allowKsp() {
+    return false;
+  }
 }

java/dagger/testing/compile/CompilerTests.java

@@ -60,8 +60,9 @@ public final class CompilerTests {
       new XProcessingEnvConfig.Builder().disableAnnotatedElementValidation(true).build();
 
   // TODO(bcorso): Share this with javatests/dagger/internal/codegen/Compilers.java
-  private static final ImmutableMap<String, String> DEFAULT_PROCESSOR_OPTIONS =
+  public static final ImmutableMap<String, String> DEFAULT_PROCESSOR_OPTIONS =
       ImmutableMap.of(
+          "dagger.allowKsp", "enabled",
           "dagger.experimentalDaggerErrorMessages", "enabled");
 
   /** Returns the {@link XProcessingEnv.Backend} for the given {@link CompilationResultSubject}. */

javatests/artifacts/dagger-ksp/build.gradle

@@ -36,7 +36,6 @@ allprojects {
     mavenCentral()
     mavenLocal()
   }
-
   configurations.all {
     resolutionStrategy.eachDependency { DependencyResolveDetails details ->
       if (details.requested.group == 'com.google.dagger'
@@ -47,3 +46,9 @@ allprojects {
     }
   }
 }
+
+subprojects {
+  ksp {
+    arg("dagger.allowKsp", "enabled")
+  }
+}

javatests/artifacts/hilt-android/simpleKotlin/build.gradle

@@ -53,3 +53,9 @@ allprojects {
         }
     }
 }
+
+subprojects {
+  ksp {
+    arg("dagger.allowKsp", "enabled")
+  }
+}

javatests/dagger/internal/codegen/KspCompilerOptionTest.java

@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2023 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen;
+
+import androidx.room.compiler.processing.XProcessingEnv;
+import androidx.room.compiler.processing.util.Source;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import dagger.testing.compile.CompilerTests;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class KspCompilerOptionTest {
+  @Parameters(name = "{0}")
+  public static ImmutableList<Object[]> parameters() {
+    return ImmutableList.copyOf(new Object[][] {{"enabled"}, {"disabled"}});
+  }
+
+  private final String allowKspValue;
+
+  public KspCompilerOptionTest(String allowKspValue) {
+    this.allowKspValue = allowKspValue;
+  }
+
+  @Test
+  public void testallowKsp() {
+    Source component =
+        CompilerTests.kotlinSource(
+            "test.MyComponent.kt",
+            "package test",
+            "",
+            "import dagger.Component",
+            "",
+            "@Component",
+            "interface MyComponent");
+    CompilerTests.daggerCompiler(component)
+        .withProcessingOptions(
+            ImmutableMap.of("dagger.allowKsp", allowKspValue))
+        .compile(
+            subject -> {
+              if (CompilerTests.backend(subject) == XProcessingEnv.Backend.KSP
+                  && allowKspValue.contentEquals("disabled")) {
+                subject.hasErrorCount(1);
+                subject.hasErrorContaining(
+                    "set the 'dagger.allowKsp=ENABLED' compiler option when using KSP");
+              } else {
+                subject.hasErrorCount(0);
+              }
+            });
+  }
+}