Add @GrailsBeans: compile bean-wiring DSL into real @AutoConfiguration classes

build-logic/plugins/build.gradle

@@ -44,6 +44,10 @@ dependencies {
     testImplementation "org.spockframework:spock-core:${gradleBomDependencyVersions['gradle-spock.version']}"
     testImplementation gradleTestKit()
     testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
+
+    // Fixture sources compiled by GenerateAutoConfigurationImportsTaskSpec need the real
+    // annotation on their classpath so it resolves as a genuine annotation type when scanned.
+    testImplementation "org.springframework.boot:spring-boot-autoconfigure:${gradleBomDependencyVersions['spring-boot.version']}"
 }
 
 tasks.named('test') {
@@ -108,5 +112,9 @@ gradlePlugin {
             id = 'org.apache.grails.buildsrc.vulnerability-scan'
             implementationClass = 'org.apache.grails.buildsrc.VulnerabilityScanPlugin'
         }
+        register('autoConfigurationImportsPlugin') {
+            id = 'org.apache.grails.buildsrc.autoconfiguration-imports'
+            implementationClass = 'org.apache.grails.buildsrc.AutoConfigurationImportsPlugin'
+        }
     }
 }

build-logic/plugins/src/main/groovy/org/apache/grails/buildsrc/AutoConfigurationImportsPlugin.groovy

@@ -0,0 +1,66 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you 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 org.apache.grails.buildsrc
+
+import groovy.transform.CompileStatic
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.file.Directory
+import org.gradle.api.plugins.JavaPluginExtension
+import org.gradle.api.provider.Provider
+import org.gradle.api.tasks.SourceSet
+import org.gradle.api.tasks.TaskProvider
+
+/**
+ * Convention plugin that wires {@link GenerateAutoConfigurationImportsTask} into the {@code main}
+ * source set's output, so a module authoring {@code @AutoConfiguration} classes never has to
+ * hand-maintain {@code META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports}.
+ *
+ * <p>The generated resources directory is registered via {@code sourceSets.main.output.dir(...)}
+ * rather than routed through {@code processResources}, so it lands on the compile/runtime/test
+ * classpath and in the final jar without depending on {@code Copy}-task ordering semantics.
+ */
+@CompileStatic
+class AutoConfigurationImportsPlugin implements Plugin<Project> {
+
+    static final String TASK_NAME = 'generateAutoConfigurationImports'
+    static final String GENERATED_RESOURCES_PATH = 'generated/resources/autoConfigurationImports'
+
+    @Override
+    void apply(Project project) {
+        project.pluginManager.apply('java-base')
+
+        SourceSet main = project.extensions.getByType(JavaPluginExtension).sourceSets.getByName('main')
+        Provider<Directory> generatedDir = project.layout.buildDirectory.dir(GENERATED_RESOURCES_PATH)
+
+        TaskProvider<GenerateAutoConfigurationImportsTask> task = project.tasks.register(
+                TASK_NAME, GenerateAutoConfigurationImportsTask) { GenerateAutoConfigurationImportsTask t ->
+            t.group = 'build'
+            t.description = 'Generates META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports ' +
+                    'by scanning compiled classes for @AutoConfiguration'
+            t.classesDirs.from(main.output.classesDirs)
+            t.scanClasspath.from(main.compileClasspath, main.output.classesDirs)
+            t.outputDirectory.set(generatedDir)
+        }
+
+        main.output.dir(Collections.<String, Object> singletonMap('builtBy', task), generatedDir)
+    }
+
+}

build-logic/plugins/src/main/groovy/org/apache/grails/buildsrc/GenerateAutoConfigurationImportsTask.groovy

@@ -0,0 +1,133 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you 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 org.apache.grails.buildsrc
+
+import org.gradle.api.DefaultTask
+import org.gradle.api.file.ConfigurableFileCollection
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.tasks.Classpath
+import org.gradle.api.tasks.IgnoreEmptyDirectories
+import org.gradle.api.tasks.InputFiles
+import org.gradle.api.tasks.OutputDirectory
+import org.gradle.api.tasks.PathSensitive
+import org.gradle.api.tasks.PathSensitivity
+import org.gradle.api.tasks.TaskAction
+
+/**
+ * Scans this project's own compiled main classes for {@code @AutoConfiguration} and writes
+ * {@code META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports}, so the
+ * file never needs to be hand-maintained. Mirrors how {@code META-INF/grails-plugin.xml} is already
+ * generated from scanned {@code *GrailsPlugin} classes elsewhere in this build.
+ *
+ * <p>Classes are inspected via a scratch {@link URLClassLoader} over this project's own runtime
+ * classpath, isolated from the Gradle daemon's classpath (parent set to the platform loader) so a
+ * different Spring/Groovy version on the daemon's classpath cannot shadow the project's own.
+ */
+abstract class GenerateAutoConfigurationImportsTask extends DefaultTask {
+
+    static final String IMPORTS_RESOURCE_PATH =
+            'META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports'
+
+    static final String AUTO_CONFIGURATION_ANNOTATION = 'org.springframework.boot.autoconfigure.AutoConfiguration'
+
+    @InputFiles
+    @IgnoreEmptyDirectories
+    @PathSensitive(PathSensitivity.RELATIVE)
+    abstract ConfigurableFileCollection getClassesDirs()
+
+    /**
+     * The classpath the scratch classloader resolves annotations/supertypes against. Deliberately
+     * built from the project's compile classpath (dependencies only) rather than its runtime
+     * classpath: the runtime classpath includes the source set's own output, which - once this
+     * task's generated directory is registered on that same output - would make this task depend
+     * on itself.
+     */
+    @Classpath
+    abstract ConfigurableFileCollection getScanClasspath()
+
+    @OutputDirectory
+    abstract DirectoryProperty getOutputDirectory()
+
+    @TaskAction
+    void generate() {
+        SortedSet<String> discovered = scan(classesDirs.files, scanClasspath.files) { String className, Throwable failure ->
+            logger.warn('generateAutoConfigurationImports: could not inspect {} - it will be excluded from ' +
+                    'the generated imports file even if it is genuinely annotated @AutoConfiguration. Cause: {}',
+                    className, failure.toString())
+        }
+        File importsFile = outputDirectory.file(IMPORTS_RESOURCE_PATH).get().asFile
+        importsFile.parentFile.mkdirs()
+        importsFile.text = discovered.isEmpty() ? '' : discovered.join('\n') + '\n'
+    }
+
+    /**
+     * Package-private so it is directly unit-testable without running a real Gradle task.
+     *
+     * @param classesDirs directories of compiled {@code .class} files to inspect (a project's own
+     * output only - dependency jars on {@code classpathFiles} are never scanned for candidates)
+     * @param classpathFiles the classpath the scratch classloader resolves supertypes/annotations
+     * against; must include {@code classesDirs} plus every runtime dependency
+     * @param onUnresolvable invoked with (className, failure) for every candidate class that could
+     * not be loaded against {@code classpathFiles}. Defaults to a no-op so existing callers are
+     * unaffected; {@link #generate()} passes a callback that logs a build warning, since a class
+     * that fails to load here is silently excluded from the generated imports file - which, if it
+     * was genuinely a real {@code @AutoConfiguration}, means its beans would never be registered
+     * with no other signal that anything went wrong.
+     * @return the fully-qualified names of every top-level class annotated {@code @AutoConfiguration},
+     * sorted for a deterministic, diff-friendly output file
+     */
+    static SortedSet<String> scan(Set<File> classesDirs, Set<File> classpathFiles,
+            Closure<?> onUnresolvable = { String className, Throwable failure -> }) {
+        URL[] urls = classpathFiles.collect { it.toURI().toURL() } as URL[]
+        URLClassLoader scanLoader = new URLClassLoader(urls, ClassLoader.systemClassLoader.parent)
+        try {
+            Class<?> autoConfigurationAnnotation = Class.forName(AUTO_CONFIGURATION_ANNOTATION, false, scanLoader)
+            SortedSet<String> discovered = new TreeSet<>()
+            classesDirs.each { dir -> scanDirectory(dir, scanLoader, autoConfigurationAnnotation, discovered, onUnresolvable) }
+            discovered
+        }
+        finally {
+            scanLoader.close()
+        }
+    }
+
+    private static void scanDirectory(File dir, URLClassLoader scanLoader, Class<?> autoConfigurationAnnotation,
+            SortedSet<String> discovered, Closure<?> onUnresolvable) {
+        if (!dir.exists()) {
+            return
+        }
+        dir.eachFileRecurse(groovy.io.FileType.FILES) { file ->
+            if (!file.name.endsWith('.class') || file.name.contains('$')) {
+                return
+            }
+            String relative = dir.toPath().relativize(file.toPath()).toString()
+            String className = relative.replace(File.separator, '.') - '.class'
+            try {
+                Class<?> candidate = Class.forName(className, false, scanLoader)
+                if (candidate.isAnnotationPresent(autoConfigurationAnnotation)) {
+                    discovered << candidate.name
+                }
+            }
+            catch (Throwable unresolvable) {
+                onUnresolvable.call(className, unresolvable)
+            }
+        }
+    }
+
+}

build-logic/plugins/src/test/groovy/org/apache/grails/buildsrc/GenerateAutoConfigurationImportsTaskSpec.groovy

@@ -0,0 +1,173 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you 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 org.apache.grails.buildsrc
+
+import groovy.io.FileType
+import org.codehaus.groovy.control.CompilationUnit
+import org.codehaus.groovy.control.CompilerConfiguration
+import org.codehaus.groovy.control.Phases
+import org.springframework.boot.autoconfigure.AutoConfiguration
+import spock.lang.TempDir
+
+import spock.lang.Specification
+
+/**
+ * Compiles small fixture sources to real {@code .class} files (the same way {@code groovyc} would)
+ * and scans them, rather than mocking the classloading behaviour {@link GenerateAutoConfigurationImportsTask#scan}
+ * depends on.
+ */
+class GenerateAutoConfigurationImportsTaskSpec extends Specification {
+
+    @TempDir
+    File tempDir
+
+    private static void compileFixtures(File srcDir, File destDir) {
+        CompilerConfiguration config = new CompilerConfiguration()
+        config.targetDirectory = destDir
+        CompilationUnit unit = new CompilationUnit(config)
+        srcDir.eachFileRecurse(FileType.FILES) { File source ->
+            if (source.name.endsWith('.groovy')) {
+                unit.addSource(source)
+            }
+        }
+        unit.compile(Phases.OUTPUT)
+    }
+
+    private static File springBootAutoconfigureClasspathEntry() {
+        new File(AutoConfiguration.protectionDomain.codeSource.location.toURI())
+    }
+
+    /**
+     * Compiled fixture classes are themselves Groovy classes (they implement
+     * {@code groovy.lang.GroovyObject}), so the scratch classloader needs the Groovy runtime too -
+     * exactly as a real project's {@code runtimeClasspath} always would.
+     */
+    private static File groovyRuntimeClasspathEntry() {
+        new File(GroovyObject.protectionDomain.codeSource.location.toURI())
+    }
+
+    private static Set<File> testClasspath(File destDir) {
+        [destDir, springBootAutoconfigureClasspathEntry(), groovyRuntimeClasspathEntry()] as Set
+    }
+
+    def "finds a top-level class annotated @AutoConfiguration"() {
+        given:
+        File srcDir = new File(tempDir, 'src')
+        srcDir.mkdirs()
+        new File(srcDir, 'RealAutoConfig.groovy').text = '''
+            package fixture
+
+            import org.springframework.boot.autoconfigure.AutoConfiguration
+
+            @AutoConfiguration
+            class RealAutoConfig {
+            }
+        '''
+        File destDir = new File(tempDir, 'classes')
+        destDir.mkdirs()
+        compileFixtures(srcDir, destDir)
+
+        when:
+        SortedSet<String> found = GenerateAutoConfigurationImportsTask.scan([destDir] as Set, testClasspath(destDir))
+
+        then:
+        found == ['fixture.RealAutoConfig'] as SortedSet
+    }
+
+    def "ignores classes with no @AutoConfiguration annotation"() {
+        given:
+        File srcDir = new File(tempDir, 'src')
+        srcDir.mkdirs()
+        new File(srcDir, 'PlainClass.groovy').text = '''
+            package fixture
+
+            class PlainClass {
+            }
+        '''
+        File destDir = new File(tempDir, 'classes')
+        destDir.mkdirs()
+        compileFixtures(srcDir, destDir)
+
+        when:
+        SortedSet<String> found = GenerateAutoConfigurationImportsTask.scan([destDir] as Set, testClasspath(destDir))
+
+        then:
+        found.isEmpty()
+    }
+
+    def "ignores nested/inner classes even when annotated"() {
+        given: "an @AutoConfiguration nested inside a plain outer class"
+        File srcDir = new File(tempDir, 'src')
+        srcDir.mkdirs()
+        new File(srcDir, 'Outer.groovy').text = '''
+            package fixture
+
+            import org.springframework.boot.autoconfigure.AutoConfiguration
+
+            class Outer {
+                @AutoConfiguration
+                static class Nested {
+                }
+            }
+        '''
+        File destDir = new File(tempDir, 'classes')
+        destDir.mkdirs()
+        compileFixtures(srcDir, destDir)
+
+        expect: "compilation really did produce a \$-named class file, proving this isn't a vacuous pass"
+        new File(destDir, 'fixture/Outer$Nested.class').exists()
+
+        when:
+        SortedSet<String> found = GenerateAutoConfigurationImportsTask.scan([destDir] as Set, testClasspath(destDir))
+
+        then:
+        found.isEmpty()
+    }
+
+    def "returns an empty set for a nonexistent classes directory"() {
+        expect:
+        GenerateAutoConfigurationImportsTask.scan(
+                [new File(tempDir, 'does-not-exist')] as Set, [springBootAutoconfigureClasspathEntry()] as Set).isEmpty()
+    }
+
+    def "reports classes that fail to load instead of silently dropping them"() {
+        given: "a compiled class whose superclass is deliberately removed from the classpath afterwards"
+        File srcDir = new File(tempDir, 'src')
+        srcDir.mkdirs()
+        new File(srcDir, 'Missing.groovy').text = 'class Missing {}'
+        new File(srcDir, 'Broken.groovy').text = 'class Broken extends Missing {}'
+        File destDir = new File(tempDir, 'classes')
+        destDir.mkdirs()
+        compileFixtures(srcDir, destDir)
+        assert new File(destDir, 'Missing.class').delete()
+
+        when:
+        List<String> reportedFailures = []
+        SortedSet<String> found = GenerateAutoConfigurationImportsTask.scan(
+                [destDir] as Set, testClasspath(destDir)) { String className, Throwable failure ->
+            reportedFailures << className
+            assert failure != null
+        }
+
+        then: "the unloadable class is excluded from the result but not silently - the callback fires for it"
+        found.isEmpty()
+        reportedFailures == ['Broken']
+    }
+
+}