Fix duplicate gradlePluginPortal() in settings.gradle.kts (#7230)

* Add failing tests for duplicate gradlePluginPortal() in KTS with wrong type attribution

When method types have an incorrect declaring type (as happens on the
platform with KTS-parsed settings.gradle.kts), FindRepository's
MethodMatcher fails to detect existing repositories, causing
AddSettingsPluginRepository to add duplicates.

Reproduces moderneinc/customer-requests#2120

* Fix duplicate gradlePluginPortal() in settings.gradle.kts with incorrect type attribution

On the Moderne platform, KTS-parsed settings.gradle.kts files may have
incorrect type attribution on method invocations (e.g. wrong declaring
type instead of RepositoryHandler). This causes FindRepository's
MethodMatcher to fail the strict matching path, missing existing
repository entries and leading AddSettingsPluginRepository to add
duplicates.

Added two defensive checks:
1. In addRepoToRepositoriesBlock: name-based check if the repository
   already exists in the repositories block before adding
2. In addPluginManagementRepos: detect when pluginManagement exists but
   no change was needed, to avoid inserting a duplicate block

Fixes moderneinc/customer-requests#2120

* Clarify comment: workaround for Kotlin parser type attribution issue

* Consolidate comment on repoAlreadyExists method

---------

Co-authored-by: Jente Sondervorst <jentesondervorst@gmail.com>

Author: pstreef

rewrite-gradle/src/main/java/org/openrewrite/gradle/plugins/AddSettingsPluginRepository.java

@@ -138,6 +138,12 @@ private List<Statement> addPluginManagementRepos(List<Statement> statements, J p
                 if (mapped != statements) {
                     return mapped;
                 }
+                // Check if pluginManagement exists but no change was needed (repo already present)
+                for (Statement s : statements) {
+                    if (unwrapMethodCall(s, "pluginManagement") != null) {
+                        return statements;
+                    }
+                }
                 // No existing pluginManagement found — insert after any leading imports
                 Statement pluginManagementStatement = pluginManagement instanceof J.Block ?
                         ((J.Block) pluginManagement).getStatements().get(0) :
@@ -190,6 +196,11 @@ private Statement addRepoToRepositoriesBlock(Statement statement, J pluginManage
                     return statement;
                 }
                 J.MethodInvocation repoToAdd = extractRepository(pluginManagement);
+
+                if (repoAlreadyExists(repos, repoToAdd.getSimpleName())) {
+                    return statement;
+                }
+
                 J.MethodInvocation m2 = repos.withArguments(ListUtils.mapFirst(repos.getArguments(), arg2 -> {
                     if (!(arg2 instanceof J.Lambda) || !(((J.Lambda) arg2).getBody() instanceof J.Block)) {
                         return arg2;
@@ -208,6 +219,23 @@ private Statement addRepoToRepositoriesBlock(Statement statement, J pluginManage
                 return rewrap(statement, m2);
             }
 
+            // Name-based fallback for when MethodMatcher fails due to incorrect type attribution (e.g. rewrite-kotlin)
+            private boolean repoAlreadyExists(J.MethodInvocation repos, String repoName) {
+                if (repos.getArguments().isEmpty() || !(repos.getArguments().get(0) instanceof J.Lambda)) {
+                    return false;
+                }
+                J.Lambda lambda = (J.Lambda) repos.getArguments().get(0);
+                if (!(lambda.getBody() instanceof J.Block)) {
+                    return false;
+                }
+                for (Statement s : ((J.Block) lambda.getBody()).getStatements()) {
+                    if (unwrapMethodCall(s, repoName) != null) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+
             private <T extends JavaSourceFile> J generatePluginManagementBlock(Class<T> compilationUnitClass, Function<T, J> methodExtractor, ExecutionContext ctx) {
                 String code;
                 if (url == null) {

rewrite-gradle/src/test/java/org/openrewrite/gradle/plugins/AddSettingsPluginRepositoryTest.java

@@ -17,6 +17,10 @@
 
 import org.junit.jupiter.api.Test;
 import org.openrewrite.DocumentExample;
+import org.openrewrite.SourceFile;
+import org.openrewrite.java.JavaIsoVisitor;
+import org.openrewrite.java.tree.J;
+import org.openrewrite.java.tree.JavaType;
 import org.openrewrite.test.RewriteTest;
 
 import static org.openrewrite.gradle.Assertions.settingsGradle;
@@ -584,6 +588,60 @@ void noPluginManagementBlockWithBuildCacheKts() {
         );
     }
 
+    /**
+     * Simulate platform behavior where KTS-parsed settings.gradle.kts has incomplete type
+     * attribution — method types have a wrong declaring type instead of being null.
+     */
+    @SuppressWarnings("unchecked")
+    private static <T extends SourceFile> T corruptMethodTypes(T sourceFile) {
+        JavaType.FullyQualified wrongType = JavaType.ShallowClass.build("kotlin.Unit");
+        return (T) new JavaIsoVisitor<Integer>() {
+            @Override
+            public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, Integer p) {
+                J.MethodInvocation m = super.visitMethodInvocation(method, p);
+                if (m.getMethodType() != null) {
+                    return m.withMethodType(m.getMethodType().withDeclaringType(wrongType));
+                }
+                return m;
+            }
+        }.visitNonNull(sourceFile, 0);
+    }
+
+    @Test
+    void skipWhenExistsGradlePluginPortalKtsWithoutTypeAttribution() {
+        rewriteRun(
+          spec -> spec.recipe(new AddSettingsPluginRepository("gradlePluginPortal", null)),
+          settingsGradleKts(
+            """
+              pluginManagement {
+                  repositories {
+                      gradlePluginPortal()
+                  }
+              }
+              """,
+            spec -> spec.mapBeforeRecipe(AddSettingsPluginRepositoryTest::corruptMethodTypes)
+          )
+        );
+    }
+
+    @Test
+    void skipWhenExistsGradlePluginPortalWithOtherReposKtsWithoutTypeAttribution() {
+        rewriteRun(
+          spec -> spec.recipe(new AddSettingsPluginRepository("gradlePluginPortal", null)),
+          settingsGradleKts(
+            """
+              pluginManagement {
+                  repositories {
+                      mavenLocal()
+                      gradlePluginPortal()
+                  }
+              }
+              """,
+            spec -> spec.mapBeforeRecipe(AddSettingsPluginRepositoryTest::corruptMethodTypes)
+          )
+        );
+    }
+
     @Test
     void addToExistingPluginManagementWithPluginsBlockKts() {
         rewriteRun(