Make non-predeclared spotless compatible with isolated projects

inorichi · inorichi · commit 3db843db12f3 · 2026-02-20T15:40:43.000+01:00
diff --git a/plugin-gradle/src/main/java/com/diffplug/gradle/spotless/FormatExtension.java b/plugin-gradle/src/main/java/com/diffplug/gradle/spotless/FormatExtension.java
@@ -94,11 +94,11 @@ public FormatExtension(SpotlessExtension spotless) {
 	}
 
 	protected final Provisioner provisioner() {
-		return spotless.getRegisterDependenciesTask().getTaskService().get().provisionerFor(spotless);
+		return spotless.getSpotlessTaskService().get().provisionerFor(spotless);
 	}
 
 	protected final com.diffplug.spotless.extra.P2Provisioner p2Provisioner() {
-		return spotless.getRegisterDependenciesTask().getTaskService().get().p2ProvisionerFor(spotless);
+		return spotless.getSpotlessTaskService().get().p2ProvisionerFor(spotless);
 	}
 
 	private String formatName() {
@@ -1098,7 +1098,7 @@ protected void setupTask(SpotlessTask task) {
 		LineEnding lineEndings = getLineEndings();
 		task.setLineEndingsPolicy(
 				getProject().provider(() -> lineEndings.createPolicy(projectDir.getAsFile(), () -> totalTarget)));
-		spotless.getRegisterDependenciesTask().hookSubprojectTask(task);
+		spotless.getSpotlessTaskService().get().hookSubprojectTask(getProject(), task);
 		task.setupRatchet(getRatchetFrom() != null ? getRatchetFrom() : "");
 	}
 
@@ -1134,7 +1134,7 @@ public TaskProvider<SpotlessApply> createIndependentApplyTaskLazy(String taskNam
 				"Task name must not end with " + SpotlessExtension.APPLY);
 		TaskProvider<SpotlessTaskImpl> spotlessTask = spotless.project.getTasks()
 				.register(taskName + SpotlessTaskService.INDEPENDENT_HELPER, SpotlessTaskImpl.class, task -> {
-					task.init(spotless.getRegisterDependenciesTask().getTaskService());
+					task.init(spotless.getSpotlessTaskService());
 					setupTask(task);
 					// clean removes the SpotlessCache, so we have to run after clean
 					task.mustRunAfter(BasePlugin.CLEAN_TASK_NAME);
diff --git a/plugin-gradle/src/main/java/com/diffplug/gradle/spotless/RegisterDependenciesTask.java b/plugin-gradle/src/main/java/com/diffplug/gradle/spotless/RegisterDependenciesTask.java
@@ -64,8 +64,7 @@ void hookSubprojectTask(SpotlessTask task) {
 	void setup() {
 		Preconditions.checkArgument(getProject().getRootProject() == getProject(), "Can only be used on the root project");
 		String compositeBuildSuffix = getName().substring(TASK_NAME.length()); // see https://github.com/diffplug/spotless/pull/1001
-		BuildServiceRegistry buildServices = getProject().getGradle().getSharedServices();
-		taskService = buildServices.registerIfAbsent("SpotlessTaskService" + compositeBuildSuffix, SpotlessTaskService.class, spec -> {});
+		taskService = SpotlessTaskService.registerIfAbsent(getProject(), compositeBuildSuffix);
 		usesService(taskService);
 		getBuildEventsListenerRegistry().onTaskCompletion(taskService);
 		unitOutput = new File(getProject().getLayout().getBuildDirectory().getAsFile().get(), "tmp/spotless-register-dependencies");
diff --git a/plugin-gradle/src/main/java/com/diffplug/gradle/spotless/SpotlessExtension.java b/plugin-gradle/src/main/java/com/diffplug/gradle/spotless/SpotlessExtension.java
@@ -27,15 +27,14 @@
 import org.gradle.api.Action;
 import org.gradle.api.GradleException;
 import org.gradle.api.Project;
-import org.gradle.api.tasks.TaskContainer;
-import org.gradle.api.tasks.TaskProvider;
+import org.gradle.api.provider.Provider;
 import org.gradle.language.base.plugins.LifecycleBasePlugin;
 
 import com.diffplug.spotless.LineEnding;
 
 public abstract class SpotlessExtension {
 	final Project project;
-	private final RegisterDependenciesTask registerDependenciesTask;
+	private final Provider<SpotlessTaskService> spotlessTaskService;
 
 	protected static final String TASK_GROUP = LifecycleBasePlugin.VERIFICATION_GROUP;
 	protected static final String BUILD_SETUP_TASK_GROUP = "build setup";
@@ -52,11 +51,11 @@ public abstract class SpotlessExtension {
 
 	protected SpotlessExtension(Project project) {
 		this.project = requireNonNull(project);
-		this.registerDependenciesTask = findRegisterDepsTask().get();
+		this.spotlessTaskService = SpotlessTaskService.registerIfAbsent(project, "");
 	}
 
-	RegisterDependenciesTask getRegisterDependenciesTask() {
-		return registerDependenciesTask;
+	Provider<SpotlessTaskService> getSpotlessTaskService() {
+		return spotlessTaskService;
 	}
 
 	/** Line endings (if any). */
@@ -303,27 +302,6 @@ <T extends FormatExtension> T instantiateFormatExtension(Class<T> clazz) {
 
 	protected abstract void createFormatTasks(String name, FormatExtension formatExtension);
 
-	TaskProvider<RegisterDependenciesTask> findRegisterDepsTask() {
-		try {
-			return findRegisterDepsTask(RegisterDependenciesTask.TASK_NAME);
-		} catch (Exception e) {
-			// in a composite build there can be multiple Spotless plugins on the classpath, and they will each try to register
-			// a task on the root project with the same name. That will generate casting errors, which we can catch and try again
-			// with an identity-specific identifier.
-			// https://github.com/diffplug/spotless/pull/1001 for details
-			return findRegisterDepsTask(RegisterDependenciesTask.TASK_NAME + System.identityHashCode(RegisterDependenciesTask.class));
-		}
-	}
-
-	private TaskProvider<RegisterDependenciesTask> findRegisterDepsTask(String taskName) {
-		TaskContainer rootProjectTasks = project.getRootProject().getTasks();
-		if (!rootProjectTasks.getNames().contains(taskName)) {
-			return rootProjectTasks.register(taskName, RegisterDependenciesTask.class, RegisterDependenciesTask::setup);
-		} else {
-			return rootProjectTasks.named(taskName, RegisterDependenciesTask.class);
-		}
-	}
-
 	public void predeclareDepsFromBuildscript() {
 		if (project.getRootProject() != project) {
 			throw new GradleException("predeclareDepsFromBuildscript can only be called from the root project");
diff --git a/plugin-gradle/src/main/java/com/diffplug/gradle/spotless/SpotlessExtensionImpl.java b/plugin-gradle/src/main/java/com/diffplug/gradle/spotless/SpotlessExtensionImpl.java
@@ -61,7 +61,7 @@ protected void createFormatTasks(String name, FormatExtension formatExtension) {
 		// create the SpotlessTask
 		String taskName = EXTENSION + SpotlessPlugin.capitalize(name);
 		TaskProvider<SpotlessTaskImpl> spotlessTask = tasks.register(taskName, SpotlessTaskImpl.class, task -> {
-			task.init(getRegisterDependenciesTask().getTaskService());
+			task.init(getSpotlessTaskService());
 			task.setGroup(TASK_GROUP);
 			task.getIdeHookState().set(ideHook);
 			// clean removes the SpotlessCache, so we have to run after clean
diff --git a/plugin-gradle/src/main/java/com/diffplug/gradle/spotless/SpotlessExtensionPredeclare.java b/plugin-gradle/src/main/java/com/diffplug/gradle/spotless/SpotlessExtensionPredeclare.java
@@ -20,23 +20,29 @@
 
 import org.gradle.api.Action;
 import org.gradle.api.Project;
+import org.gradle.api.tasks.TaskContainer;
+import org.gradle.api.tasks.TaskProvider;
 
 import com.diffplug.spotless.LazyForwardingEquality;
 
 public class SpotlessExtensionPredeclare extends SpotlessExtension {
 	private final SortedMap<String, FormatExtension> toSetup = new TreeMap<>();
+	private final RegisterDependenciesTask registerDependenciesTask;
 
 	public SpotlessExtensionPredeclare(Project project, GradleProvisioner.Policy policy) {
 		super(project);
-		getRegisterDependenciesTask().getTaskService().get().predeclaredProvisioner = policy.dedupingProvisioner(project);
-		getRegisterDependenciesTask().getTaskService().get().predeclaredP2Provisioner = policy.dedupingP2Provisioner(project);
+		this.registerDependenciesTask = findRegisterDepsTask().get();
+		SpotlessTaskService taskService = getSpotlessTaskService().get();
+		taskService.isUsingPredeclared = true;
+		taskService.predeclaredProvisioner = policy.dedupingProvisioner(project);
+		taskService.predeclaredP2Provisioner = policy.dedupingP2Provisioner(project);
 		project.afterEvaluate(unused -> toSetup.forEach((name, formatExtension) -> {
 			for (Action<FormatExtension> lazyAction : formatExtension.lazyActions) {
 				lazyAction.execute(formatExtension);
 			}
-			getRegisterDependenciesTask().steps.addAll(formatExtension.steps);
+			registerDependenciesTask.steps.addAll(formatExtension.steps);
 			// needed to fix Deemon memory leaks (#1194), but this line came from https://github.com/diffplug/spotless/pull/1206
-			LazyForwardingEquality.unlazy(getRegisterDependenciesTask().steps);
+			LazyForwardingEquality.unlazy(registerDependenciesTask.steps);
 		}));
 	}
 
@@ -49,4 +55,21 @@ protected void createFormatTasks(String name, FormatExtension formatExtension) {
 	protected void predeclare(GradleProvisioner.Policy policy) {
 		throw new UnsupportedOperationException("predeclare can't be called from within `" + EXTENSION_PREDECLARE + "`");
 	}
+
+	private TaskProvider<RegisterDependenciesTask> findRegisterDepsTask() {
+		try {
+			return findRegisterDepsTask(RegisterDependenciesTask.TASK_NAME);
+		} catch (Exception e) {
+			// in a composite build there can be multiple Spotless plugins on the classpath, and they will each try to register
+			// a task on the root project with the same name. That will generate casting errors, which we can catch and try again
+			// with an identity-specific identifier.
+			// https://github.com/diffplug/spotless/pull/1001 for details
+			return findRegisterDepsTask(RegisterDependenciesTask.TASK_NAME + System.identityHashCode(RegisterDependenciesTask.class));
+		}
+	}
+
+	private TaskProvider<RegisterDependenciesTask> findRegisterDepsTask(String taskName) {
+		return project.getTasks().register(taskName, RegisterDependenciesTask.class, RegisterDependenciesTask::setup);
+	}
+
 }
diff --git a/plugin-gradle/src/main/java/com/diffplug/gradle/spotless/SpotlessTaskService.java b/plugin-gradle/src/main/java/com/diffplug/gradle/spotless/SpotlessTaskService.java
@@ -28,6 +28,7 @@
 import javax.inject.Inject;
 
 import org.gradle.api.DefaultTask;
+import org.gradle.api.Project;
 import org.gradle.api.file.ConfigurableFileTree;
 import org.gradle.api.file.DirectoryProperty;
 import org.gradle.api.file.FileVisitDetails;
@@ -55,6 +56,7 @@
  * apply already did).
  */
 public abstract class SpotlessTaskService implements BuildService<BuildServiceParameters.None>, AutoCloseable, OperationCompletionListener {
+	protected boolean isUsingPredeclared = false;
 	private final Map<String, SpotlessApply> apply = Collections.synchronizedMap(new HashMap<>());
 	private final Map<String, SpotlessTask> source = Collections.synchronizedMap(new HashMap<>());
 	private final Map<String, Provisioner> provisioner = Collections.synchronizedMap(new HashMap<>());
@@ -126,6 +128,20 @@ static void usesServiceTolerateTestFailure(DefaultTask task, Provider<SpotlessTa
 		}
 	}
 
+	public void hookSubprojectTask(Project project, SpotlessTask task) {
+		// This check allows isolated projects support by not accessing the root project tasks unless really needed
+		if (!isUsingPredeclared) return;
+
+		project.getRootProject().getTasks().withType(RegisterDependenciesTask.class, (registerTask) -> {
+			registerTask.hookSubprojectTask(task);
+		});
+	}
+
+	public static Provider<SpotlessTaskService> registerIfAbsent(Project project, String suffix) {
+		return project.getGradle().getSharedServices()
+			.registerIfAbsent("SpotlessTaskService" + suffix, SpotlessTaskService.class, spec -> {});
+	}
+
 	abstract static class ClientTask extends DefaultTask {
 		@Internal
 		abstract Property<File> getSpotlessCleanDirectory();
diff --git a/plugin-gradle/src/test/java/com/diffplug/gradle/spotless/ErrorShouldRethrowTest.java b/plugin-gradle/src/test/java/com/diffplug/gradle/spotless/ErrorShouldRethrowTest.java
@@ -136,10 +136,9 @@ private void expectSuccess() throws Exception {
 	private StringSelfie expectFailureAndConsoleToBe() throws Exception {
 		BuildResult result = gradleRunner().withArguments("check").buildAndFail();
 		String output = result.getOutput();
-		int register = output.indexOf(":spotlessInternalRegisterDependencies");
-		int firstNewlineAfterThat = output.indexOf('\n', register + 1);
+		int firstTask = output.indexOf("> Task");
 		int firstTry = output.indexOf("\n* Try:");
-		String useThisToMatch = output.substring(firstNewlineAfterThat, firstTry).trim();
+		String useThisToMatch = output.substring(firstTask, firstTry).trim();
 		return Selfie.expectSelfie(useThisToMatch);
 	}
 }
diff --git a/plugin-gradle/src/test/java/com/diffplug/gradle/spotless/GradleIntegrationHarness.java b/plugin-gradle/src/test/java/com/diffplug/gradle/spotless/GradleIntegrationHarness.java
@@ -197,7 +197,7 @@ private void taskIsUpToDate(String task, boolean upToDate) throws IOException {
 
 		List<String> expected = outcomes(buildResult, upToDate ? TaskOutcome.UP_TO_DATE : TaskOutcome.SUCCESS);
 		List<String> notExpected = outcomes(buildResult, upToDate ? TaskOutcome.SUCCESS : TaskOutcome.UP_TO_DATE);
-		boolean everythingAsExpected = !expected.isEmpty() && notExpected.isEmpty() && buildResult.getTasks().size() - 1 == expected.size();
+		boolean everythingAsExpected = !expected.isEmpty() && notExpected.isEmpty() && buildResult.getTasks().size() == expected.size();
 		if (!everythingAsExpected) {
 			fail("Expected all tasks to be " + (upToDate ? TaskOutcome.UP_TO_DATE : TaskOutcome.SUCCESS) + ", but instead was\n" + buildResultToString(buildResult));
 		}
diff --git a/plugin-gradle/src/test/java/com/diffplug/gradle/spotless/MultiProjectTest.java b/plugin-gradle/src/test/java/com/diffplug/gradle/spotless/MultiProjectTest.java
@@ -151,4 +151,40 @@ public void predeclaredUndeclared() throws IOException {
 		Assertions.assertThat(gradleRunner().withArguments("spotlessApply").buildAndFail().getOutput())
 				.contains("Could not find method spotlessPredeclare() for arguments");
 	}
+
+	@Test
+	void nonPredeclaredSupportsIsolatedProjects() throws IOException {
+		setFile("gradle.properties").toContent("org.gradle.unsafe.isolated-projects=true");
+		setFile("build.gradle").toLines(
+			"plugins {",
+			"    id 'com.diffplug.spotless'",
+			"}",
+			"repositories { mavenCentral() }",
+			"",
+			"spotless {",
+			"    java {",
+			"        target file('test.java')",
+			"        googleJavaFormat('1.17.0')",
+			"    }",
+			"}");
+		createNSubprojects();
+		gradleRunner().withArguments("spotlessApply").build();
+	}
+
+	@Test
+	void predeclaredRequiresNonIsolatedProjects() throws IOException {
+		setFile("gradle.properties").toContent("org.gradle.unsafe.isolated-projects=true");
+		setFile("build.gradle").toLines(
+			"plugins {",
+			"    id 'com.diffplug.spotless'",
+			"}",
+			"repositories { mavenCentral() }",
+			"spotless { predeclareDeps() }",
+			"spotlessPredeclare {",
+			" java { googleJavaFormat('1.17.0') }",
+			"}");
+		createNSubprojects();
+		Assertions.assertThat(gradleRunner().withArguments("spotlessApply").buildAndFail().getOutput())
+			.contains("Cannot access project");
+	}
 }
diff --git a/plugin-gradle/src/test/java/com/diffplug/gradle/spotless/RegisterDependenciesTaskTest.java b/plugin-gradle/src/test/java/com/diffplug/gradle/spotless/RegisterDependenciesTaskTest.java
@@ -43,8 +43,6 @@ void duplicateConfigs() throws IOException {
 		setFile("gradle.properties").toLines();
 		String newestSupported = gradleRunner().withArguments("spotlessCheck").build().getOutput();
 		Assertions.assertThat(newestSupported.replace("\r", ""))
-				.startsWith(
-						"> Task :spotlessInternalRegisterDependencies\n")
 				.contains(
 						"> Task :sub:spotlessJava\n",
 						"> Task :sub:spotlessJavaCheck\n",
diff --git a/plugin-gradle/src/test/java/com/diffplug/gradle/spotless/UpToDateTest.java b/plugin-gradle/src/test/java/com/diffplug/gradle/spotless/UpToDateTest.java
@@ -88,7 +88,7 @@ void testPathologicalCase() throws IOException {
 		// the format task is UP-TO-DATE (same inputs), but the apply tasks will run again
 		pauseForFilesystem();
 		BuildResult buildResult = gradleRunner().withArguments("spotlessApply").build();
-		Assertions.assertThat(buildResult.taskPaths(TaskOutcome.UP_TO_DATE)).containsExactly(":spotlessInternalRegisterDependencies", ":spotlessMisc");
+		Assertions.assertThat(buildResult.taskPaths(TaskOutcome.UP_TO_DATE)).containsExactly(":spotlessMisc");
 		Assertions.assertThat(buildResult.taskPaths(TaskOutcome.SUCCESS)).containsExactly(":spotlessMiscApply", ":spotlessApply");
 		assertFile("README.md").hasContent("abc");
 

Original file line number	Diff line number	Diff line change
`@@ -136,10 +136,9 @@ private void expectSuccess() throws Exception {`
`136`	`136`	`private StringSelfie expectFailureAndConsoleToBe() throws Exception {`
`137`	`137`	`BuildResult result = gradleRunner().withArguments("check").buildAndFail();`
`138`	`138`	`String output = result.getOutput();`
`139`		`- int register = output.indexOf(":spotlessInternalRegisterDependencies");`
`140`		`- int firstNewlineAfterThat = output.indexOf('\n', register + 1);`
	`139`	`+ int firstTask = output.indexOf("> Task");`
`141`	`140`	`int firstTry = output.indexOf("\n* Try:");`
`142`		`- String useThisToMatch = output.substring(firstNewlineAfterThat, firstTry).trim();`
	`141`	`+ String useThisToMatch = output.substring(firstTask, firstTry).trim();`
`143`	`142`	`return Selfie.expectSelfie(useThisToMatch);`
`144`	`143`	`}`
`145`	`144`	`}`
Original file line number	Diff line number	Diff line change
`@@ -197,7 +197,7 @@ private void taskIsUpToDate(String task, boolean upToDate) throws IOException {`
`197`	`197`
`198`	`198`	`List<String> expected = outcomes(buildResult, upToDate ? TaskOutcome.UP_TO_DATE : TaskOutcome.SUCCESS);`
`199`	`199`	`List<String> notExpected = outcomes(buildResult, upToDate ? TaskOutcome.SUCCESS : TaskOutcome.UP_TO_DATE);`
`200`		`- boolean everythingAsExpected = !expected.isEmpty() && notExpected.isEmpty() && buildResult.getTasks().size() - 1 == expected.size();`
	`200`	`+ boolean everythingAsExpected = !expected.isEmpty() && notExpected.isEmpty() && buildResult.getTasks().size() == expected.size();`
`201`	`201`	`if (!everythingAsExpected) {`
`202`	`202`	`fail("Expected all tasks to be " + (upToDate ? TaskOutcome.UP_TO_DATE : TaskOutcome.SUCCESS) + ", but instead was\n" + buildResultToString(buildResult));`
`203`	`203`	`}`