Always include Gradle API stubs in GradleParser classpath

When `settingsClasspath` or `buildscriptClasspath` is explicitly set
(even to empty), `GradleParser` previously replaced the default Gradle
API stubs entirely. This caused incorrect type attribution on DSL
methods like `pluginManagement()`, `repositories()`, and
`gradlePluginPortal()`, leading recipes like
`AddSettingsPluginRepository` to fail to detect existing entries.

Introduce `mergeClasspath()` which always includes the default Gradle
API stubs alongside any externally-provided classpath. Add a
reproducer test that sets `settingsClasspath` to empty and verifies
`AddSettingsPluginRepository` correctly detects an existing
`gradlePluginPortal()`.

Author: pstreef

rewrite-gradle/src/main/java/org/openrewrite/gradle/GradleParser.java

@@ -27,8 +27,7 @@
 import org.openrewrite.kotlin.KotlinParser;
 
 import java.nio.file.Path;
-import java.util.Collection;
-import java.util.List;
+import java.util.*;
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
 
@@ -65,51 +64,35 @@ public class GradleParser implements Parser {
     @Override
     public Stream<SourceFile> parseInputs(Iterable<Input> sources, @Nullable Path relativeTo, ExecutionContext ctx) {
         if (groovyBuildParser == null) {
-            Collection<Path> buildscriptClasspath = base.buildscriptClasspath;
-            if (buildscriptClasspath == null) {
-                buildscriptClasspath = defaultClasspath(ctx);
-            }
             groovyBuildParser = GroovyParser.builder(base.groovyParser)
-                    .classpath(buildscriptClasspath)
+                    .classpath(mergeClasspath(base.buildscriptClasspath, ctx))
                     .compilerCustomizers(
                             new DefaultImportsCustomizer(),
                             config -> config.setScriptBaseClass("RewriteGradleProject")
                     )
                     .build();
         }
         if (kotlinBuildParser == null) {
-            Collection<Path> buildscriptClasspath = base.buildscriptClasspath;
-            if (buildscriptClasspath == null) {
-                buildscriptClasspath = defaultClasspath(ctx);
-            }
             kotlinBuildParser = KotlinParser.builder(base.kotlinParser)
-                    .classpath(buildscriptClasspath)
+                    .classpath(mergeClasspath(base.buildscriptClasspath, ctx))
                     .dependsOn(KTS_BUILD_STUBS)
                     .isKotlinScript(true)
                     .scriptImplicitReceivers("org.gradle.api.Project")
                     .scriptDefaultImports(DefaultImportsCustomizer.DEFAULT_IMPORTS)
                     .build();
         }
         if (groovySettingsParser == null) {
-            Collection<Path> settingsClasspath = base.settingsClasspath;
-            if (settingsClasspath == null) {
-                settingsClasspath = defaultClasspath(ctx);
-            }
             groovySettingsParser = GroovyParser.builder(base.groovyParser)
-                    .classpath(settingsClasspath)
+                    .classpath(mergeClasspath(base.settingsClasspath, ctx))
                     .compilerCustomizers(
                             new DefaultImportsCustomizer(),
                             config -> config.setScriptBaseClass("RewriteSettings")
                     )
                     .build();
         }
         if (kotlinSettingsParser == null) {
-            Collection<Path> settingsClasspath = base.settingsClasspath;
-            if (settingsClasspath == null) {
-                settingsClasspath = defaultClasspath(ctx);
-            }
             kotlinSettingsParser = KotlinParser.builder(base.kotlinParser)
-                    .classpath(settingsClasspath)
+                    .classpath(mergeClasspath(base.settingsClasspath, ctx))
                     .dependsOn(KTS_SETTINGS_STUBS)
                     .isKotlinScript(true)
                     .scriptImplicitReceivers("org.gradle.api.initialization.Settings")
@@ -210,6 +193,21 @@ public String getDslName() {
         }
     }
 
+    /**
+     * Always include the default Gradle API stubs alongside any externally-provided classpath.
+     * The external classpath (e.g. settings buildscript dependencies) typically contains custom
+     * plugin jars but not the Gradle API itself, which is needed for correct type attribution
+     * of DSL methods like pluginManagement(), repositories(), gradlePluginPortal(), etc.
+     */
+    private Collection<Path> mergeClasspath(@Nullable Collection<Path> provided, ExecutionContext ctx) {
+        if (provided == null) {
+            return defaultClasspath(ctx);
+        }
+        Set<Path> merged = new LinkedHashSet<>(defaultClasspath(ctx));
+        merged.addAll(provided);
+        return merged;
+    }
+
     private List<Path> defaultClasspath(ExecutionContext ctx) {
         if (defaultClasspath == null) {
             defaultClasspath = JavaParser.dependenciesFromResources(ctx,

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

@@ -17,7 +17,16 @@
 
 import org.junit.jupiter.api.Test;
 import org.openrewrite.DocumentExample;
+import org.openrewrite.gradle.GradleParser;
+import org.openrewrite.kotlin.KotlinParser;
+import org.openrewrite.kotlin.tree.K;
 import org.openrewrite.test.RewriteTest;
+import org.openrewrite.test.SourceSpec;
+import org.openrewrite.test.SourceSpecs;
+import org.openrewrite.test.TypeValidation;
+
+import java.nio.file.Paths;
+import java.util.Collections;
 
 import static org.openrewrite.gradle.Assertions.settingsGradle;
 import static org.openrewrite.gradle.Assertions.settingsGradleKts;
@@ -624,4 +633,35 @@ void addToExistingPluginManagementWithPluginsBlockKts() {
           )
         );
     }
+
+    /**
+     * Helper to create settingsGradleKts specs using a GradleParser with empty settingsClasspath.
+     * When settingsClasspath is explicitly set to empty (e.g. no custom plugins in the settings
+     * buildscript), the Gradle API stubs must still be included for correct type attribution.
+     */
+    private static SourceSpecs settingsGradleKtsWithEmptyClasspath(String before) {
+        GradleParser.Builder parser = GradleParser.builder()
+                .kotlinParser(KotlinParser.builder().logCompilationWarningsAndErrors(true))
+                .settingsClasspath(Collections.emptyList());
+        SourceSpec<K.CompilationUnit> gradle = new SourceSpec<>(K.CompilationUnit.class, "gradle", parser, before, null);
+        gradle.path(Paths.get("settings.gradle.kts"));
+        return gradle;
+    }
+
+    @Test
+    void skipWhenExistsGradlePluginPortalKtsWithEmptyClasspath() {
+        rewriteRun(
+          spec -> spec.recipe(new AddSettingsPluginRepository("gradlePluginPortal", null))
+            .typeValidationOptions(TypeValidation.none()),
+          settingsGradleKtsWithEmptyClasspath(
+            """
+              pluginManagement {
+                  repositories {
+                      gradlePluginPortal()
+                  }
+              }
+              """
+          )
+        );
+    }
 }