GH-1299 - Prevent stack overflow during dependency lookup for modules involved in a cycle.

During dependency lookups, we now avoid recursing into modules which we've already seen.

Author: odrotbohm

spring-modulith-core/src/main/java/org/springframework/modulith/core/ApplicationModule.java

@@ -24,14 +24,7 @@
 import static org.springframework.modulith.core.Types.SpringDataTypes.*;
 import static org.springframework.modulith.core.Types.SpringTypes.*;
 
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Optional;
+import java.util.*;
 import java.util.function.Predicate;
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
@@ -599,12 +592,11 @@ public ApplicationModuleDependencies getDependencies(ApplicationModules modules,
 		Assert.notNull(depth, "DependencyDepth must not be null!");
 		Assert.notNull(types, "DependencyTypes must not be null!");
 
-		return getAllModuleDependencies(modules) //
-				.filter(it -> types.length == 0 ? true : Arrays.stream(types).anyMatch(it::hasType)) //
-				.distinct() //
-				.flatMap(it -> DefaultApplicationModuleDependency.of(it, modules)) //
-				.distinct() //
-				.flatMap(it -> resolveRecurseively(modules, it, depth, types)) //
+		if (depth == DependencyDepth.NONE) {
+			return ApplicationModuleDependencies.NONE;
+		}
+
+		return getDependencies(modules, new DependencyTraversal(depth, types))
 				.collect(Collectors.collectingAndThen(Collectors.toList(), ApplicationModuleDependencies::of));
 	}
 
@@ -846,14 +838,26 @@ private Classes findAggregateRoots(Classes source) {
 				.collect(Classes.toClasses());
 	}
 
-	private Stream<ApplicationModuleDependency> resolveRecurseively(ApplicationModules modules,
-			DefaultApplicationModuleDependency dependency, DependencyDepth depth, DependencyType... type) {
+	private Stream<ApplicationModuleDependency> getDependencies(ApplicationModules modules,
+			DependencyTraversal traversal) {
+
+		return getAllModuleDependencies(modules) //
+				.filter(traversal::include) //
+				.distinct() //
+				.flatMap(it -> DefaultApplicationModuleDependency.of(it, modules)) //
+				.distinct() //
+				.flatMap(it -> resolveRecursively(modules, it, traversal)); //
+	}
+
+	private static Stream<ApplicationModuleDependency> resolveRecursively(ApplicationModules modules,
+			ApplicationModuleDependency dependency, DependencyTraversal seen) {
+
+		if (!seen.register(dependency.getTargetModule())) {
+			return Stream.of(dependency);
+		}
 
-		var tail = depth == DependencyDepth.ALL
-				? dependency.getTargetModule()
-						.getDependencies(modules, depth, type)
-						.stream()
-						.distinct()
+		var tail = seen.hasDepth(DependencyDepth.ALL)
+				? dependency.getTargetModule().getDependencies(modules, seen).distinct()
 				: Stream.<ApplicationModuleDependency> empty();
 
 		return Stream.concat(Stream.of(dependency), tail);
@@ -1329,6 +1333,10 @@ boolean hasType(DependencyType type) {
 			return this.type.equals(type);
 		}
 
+		boolean hasAnyType(Collection<DependencyType> candidates) {
+			return candidates.contains(type);
+		}
+
 		Violations isValidDependencyWithin(ApplicationModules modules) {
 
 			var originModule = getExistingModuleOf(source, modules);
@@ -1617,6 +1625,43 @@ private static String getDescriptionFor(JavaMember member) {
 		}
 	}
 
+	/**
+	 * A helper type to keep track of a traversal configuration and seen {@link ApplicationModule}s.
+	 *
+	 * @author Oliver Drotbohm
+	 */
+	private static class DependencyTraversal {
+
+		private final Set<ApplicationModule> seen = new HashSet<>();
+		private final DependencyDepth depth;
+		private final Set<DependencyType> types;
+
+		DependencyTraversal(DependencyDepth depth, DependencyType... types) {
+
+			this.depth = depth;
+			this.types = Set.of(types);
+		}
+
+		boolean include(QualifiedDependency dependency) {
+			return types.isEmpty() || dependency.hasAnyType(types);
+		}
+
+		boolean hasDepth(DependencyDepth depth) {
+			return this.depth == depth;
+		}
+
+		boolean register(ApplicationModule module) {
+
+			if (seen.contains(module)) {
+				return false;
+			}
+
+			seen.add(module);
+
+			return true;
+		}
+	}
+
 	private static class DefaultApplicationModuleDependency
 			implements ApplicationModuleDependency {
 

spring-modulith-core/src/main/java/org/springframework/modulith/core/ApplicationModuleDependencies.java

@@ -16,6 +16,7 @@
 package org.springframework.modulith.core;
 
 import java.util.Collection;
+import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.function.Function;
@@ -31,6 +32,8 @@
  */
 public class ApplicationModuleDependencies {
 
+	static final ApplicationModuleDependencies NONE = new ApplicationModuleDependencies(Collections.emptyList());
+
 	private final List<ApplicationModuleDependency> dependencies;
 	private final Collection<ApplicationModule> modules;
 

spring-modulith-core/src/test/java/example/cycle/Cycle.java

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2025 the original author or 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
+ *
+ *      https://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 example.cycle;
+
+/**
+ * @author Oliver Drotbohm
+ */
+public class Cycle {
+
+}

spring-modulith-core/src/test/java/example/cycle/a/CycleA.java

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2025 the original author or 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
+ *
+ *      https://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 example.cycle.a;
+
+import example.cycle.b.CycleB;
+
+/**
+ * @author Oliver Drotbohm
+ */
+public class CycleA {
+	private CycleB cycleB;
+}

spring-modulith-core/src/test/java/example/cycle/b/CycleB.java

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2025 the original author or 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
+ *
+ *      https://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 example.cycle.b;
+
+import example.cycle.c.CycleC;
+
+/**
+ * @author Oliver Drotbohm
+ */
+public class CycleB {
+	private CycleC cycleC;
+}

spring-modulith-core/src/test/java/example/cycle/c/CycleC.java

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2025 the original author or 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
+ *
+ *      https://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 example.cycle.c;
+
+import example.cycle.d.CycleD;
+
+/**
+ * @author Oliver Drotbohm
+ */
+public class CycleC {
+	CycleD cycleD;
+}

spring-modulith-core/src/test/java/example/cycle/d/CycleD.java

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2025 the original author or 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
+ *
+ *      https://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 example.cycle.d;
+
+import example.cycle.a.CycleA;
+import example.cycle.b.CycleB;
+
+/**
+ * @author Oliver Drotbohm
+ */
+public class CycleD {
+	CycleB cycleB;
+	CycleA cycleA;
+}

spring-modulith-core/src/test/java/org/springframework/modulith/core/ApplicationModulesUnitTests.java

@@ -26,7 +26,7 @@
  */
 class ApplicationModulesUnitTests {
 
-	ApplicationModules modules = TestUtils.of("example", "example.ninvalid");
+	ApplicationModules modules = TestUtils.of("example", "example.ninvalid", "example.cycle..");
 
 	@Test // GH 578
 	void discoversComplexModuleArrangement() {

spring-modulith-core/src/test/java/org/springframework/modulith/core/ModuleUnitTest.java

@@ -105,4 +105,17 @@ void wildcardedDeclaredDependencyAllowsDependenciesToAllNamedInterfaces() {
 		assertThat(dependency.contains(SpiType.class)).isTrue();
 		assertThat(dependency.contains(ApiType.class)).isTrue();
 	}
+
+	@Test // GH-1299
+	void obtainsDependenciesForCyclicArrangement() {
+
+		var modules = TestUtils.of("example.cycle");
+
+		modules.forEach(it -> {
+
+			assertThat(it.getDependencies(modules, DependencyDepth.ALL).uniqueModules())
+					.extracting(ApplicationModule::getIdentifier)
+					.contains(it.getIdentifier());
+		});
+	}
 }