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

[codeconsole]

New Auto Configuration Bean DSL

@CompileStatic
class Application extends GrailsAutoConfiguration {
    static void main(String[] args) {
        GrailsApp.run(Application, args)
    }

    def beans = {  
        // insert autoconfig bean dsl here
    }
}

@CompileStatic
class MyGrailsPlugin extends Plugin {
    def version = GrailsUtil.getGrailsVersion()

    def beans = {
        // insert autoconfig bean dsl here
    }
}

Plugin.beanRegistrar() gives Grails a Spring-native, statically-compilable way to register beans, but it can't express fine-grained ordering against other @AutoConfiguration classes (Grails' own or third-party), and BeanRegistry.Spec has only one conditional primitive (fallback()) — nothing like @ConditionalOnProperty, @ConditionalOnClass, @ConditionalOnBean, or a custom Condition.

@GrailsBeans closes that gap: an AST transformation that compiles a doWithSpring()-style beans = { bean(["name", ] Type) { ... } } closure into real @Bean factory methods on a plain @AutoConfiguration class. Both the name and the body are optional: the name defaults to the type's JavaBeans-decapitalized simple name, and a bean that is nothing but its own no-argument construction needs no body at all, so bean(XmlDataBindingSourceCreator) says everything bean('xmlDataBindingSourceCreator', XmlDataBindingSourceCreator) { new XmlDataBindingSourceCreator() } does. Chaining .conditionalOnMissingBean(...) (positional types, the annotation's own named attributes, or bare to back off by return type), .conditionalOnMissingBeanName(...) (backs off by this bean's own name, stated once), .primary(), .lazy(), .scope("name"), and (repeatably) .annotate(AnnotationType[, attr: value, ...]) covers everything a hand-written @Bean method could carry — any @Conditional* (built-in or custom), @Order, @DependsOn, anything — and typed closure parameters (including their own annotations, e.g. @Qualifier) become constructor-style method parameters. One bean name may even be declared by several bean(...) statements when every declaration carries its own discriminating condition — the standard autoconfiguration pattern for mutually exclusive variants of one bean, e.g. UrlMappingsAutoConfiguration's two grailsUrlConverter beans selected by @ConditionalOnProperty; an unconditioned duplicate (which Spring would silently skip in favour of the first definition) stays a compile-time error. field(...) and method(...) round it out with private fields and helper methods on the generated class - field(...).value(Settings.SOME_KEY, 'default') compiles straight to a @Value("${...}") injection, bare constant keys included, and single-argument .value('app.some.key') auto-wraps a bare key into @Value("${app.some.key}") (strings already carrying ${...}/#{...} pass through verbatim) - for injected config and shared logic across beans - the same role a hand-written @Configuration class's own fields and methods play. Nothing DSL-specific survives into the compiled bytecode — verified with javap — so the result gets the entire @Conditional* family and Boot's own before=/after= ordering for free, correctly sequenced in Boot's deferred condition-evaluation pipeline.

Usage

Standalone class:

@GrailsBeans
@AutoConfiguration(before = [MessageSourceAutoConfiguration, WebMvcAutoConfiguration])
class MyBeans {
    def beans = {
        // a bean that is nothing but its own no-argument construction needs neither a
        // name (it is derived from the type) nor a body
        bean(FancyGreeter).conditionalOnMissingBean().primary()

        bean(SlowGreeter).lazy().scope('prototype')

        // a body is only needed when there is something to say
        bean(Greeter) {
            new Greeter('hello')
        }

        bean(LoudGreeter) { Greeter greeter ->
            new LoudGreeter(greeter)
        }

        bean(SpecialGreeter).annotate(Order, value: 1) { @Qualifier('special') Greeter greeter ->
            new SpecialGreeter(greeter)
        }

        // an explicit name is for when the type does not produce the name you need.
        // 'legacy-greeter' isn't a valid Java identifier either, so the generated method gets a
        // synthesized name (greeter$0) - an implementation detail; Spring resolves the bean
        // by its @Bean("legacy-greeter") value, never by the method name
        bean('legacy-greeter', Greeter) {
            new Greeter('bonjour')
        }
    }
}

The standalone form works on any class Spring Boot processes as a configuration source — including an application's own Application class, where no imports-file registration is needed because Boot reads @Bean methods directly off the class it is launched with.

Directly on a *GrailsPlugin.groovy class, so bean definitions can live in the familiar plugin descriptor instead of a separate file — and there the annotation is implicit. A beans property on a plugin descriptor, or on an application's Application class, is compiled automatically, in the same way doWithSpring, watchedResources and dependsOn are conventions rather than annotated members; GlobalGrailsClassInjectorTransformation already runs at the same compile phase and already identifies these classes. @GrailsBeans is written out only for a standalone @AutoConfiguration class, which is neither. A class with no beans property is untouched, and declaring the annotation explicitly still works. This is the actual conversion now live in this repository's own grails-i18n module — not an illustration; imports and comments are trimmed here for brevity; each block's linked filename is the verbatim, commit-pinned source. A second real conversion, UrlMappingsGrailsPlugin.groovy, replaces grails-url-mappings' hand-written UrlMappingsAutoConfiguration the same way — including its two mutually exclusive grailsUrlConverter variants sharing one bean name, selected by @ConditionalOnProperty.

Eight of the framework's own auto-configurations are now authored this way, most with their own before/after comment below: grails-i18n, grails-url-mappings, grails-sitemesh3, grails-mail, grails-core, grails-cache, grails-domain-class and grails-databinding.

grails-core is the module where the conversion goes furthest. CoreGrailsPlugin declared twelve beans through the deprecated bean builder DSL and now declares eleven of them without it: the four that benefit from Boot's condition and ordering machinery — classLoader, grailsConfigProperties, grailsResourceLocator, and the placeholder configurer ordered before = PropertyPlaceholderAutoConfiguration — in the beans block, and the seven that depend on the plugin's own runtime state — the auto-proxy-creator variant, the two aware BeanPostProcessors, customEditors, proxyHandler, grailsBeanOverrideConfigurer, and the development shutdown hook — through beanRegistrar(). The twelfth, abstractGrailsResourceLocator, keeps doWithSpring alive on its own; see Limitations.

That move exposed a gap in the legacy unit-test harnesses rather than in the framework. AbstractGrailsTagTests calls doWithRuntimeConfiguration(springConfig) and stops there, running only the first of the two halves the runtime runs for a plugin, so any plugin contributing through beanRegistrar() was invisible to it. Both copies of that harness now apply the registrars after the DSL flush, in the same order and with the same precedence as GrailsApplicationPostProcessor.

The first four kept their exact class identity, because the *GrailsPlugin → *AutoConfiguration convention already produced the deleted class's name. The other four did not, and rather than pin the old names with @GrailsBeans(autoConfigurationName = ...) they take the convention name: GrailsCacheAutoConfiguration → CacheAutoConfiguration, GrailsDomainClassAutoConfiguration → DomainClassAutoConfiguration, and DataBindingConfiguration → DataBindingAutoConfiguration (which was registered as an auto-configuration while named only *Configuration). grails-core's keeps its name but changes package, since the generated sibling is emitted beside its plugin — org.grails.plugins.core.CoreAutoConfiguration → org.grails.plugins.CoreAutoConfiguration. All four are FQCN changes for anyone excluding them via @EnableAutoConfiguration(exclude = ...) or spring.autoconfigure.exclude; autoConfigurationName remains for a name that genuinely cannot move.

Before, I18nAutoConfiguration.java (since deleted) — a hand-written @Configuration-style class, six @Value-injected fields, a strategy-selecting helper method, four beans each backing off an existing same-named bean via @ConditionalOnMissingBean(name = ..., search = SearchStrategy.CURRENT):

@AutoConfiguration(before = { MessageSourceAutoConfiguration.class, WebMvcAutoConfiguration.class })
@ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET)
public class I18nAutoConfiguration {

    @Value("${" + Settings.GSP_VIEW_ENCODING + ":UTF-8}")
    private String encoding;

    @Value("${" + Settings.GSP_ENABLE_RELOAD + ":false}")
    private boolean gspEnableReload;

    @Value("${" + Settings.I18N_CACHE_SECONDS + ":5}")
    private int cacheSeconds;

    @Value("${" + Settings.I18N_FILE_CACHE_SECONDS + ":5}")
    private int fileCacheSeconds;

    @Value("${" + Settings.I18N_LOCALE_RESOLVER + ":session}")
    private String localeResolverType;

    @Value("${grails.i18n.default.locale:}")
    private String defaultLocale;

    enum LocaleResolverStrategy { SESSION, COOKIE, ACCEPT_HEADER, FIXED }

    static LocaleResolverStrategy resolveStrategy(String value) {
        String normalized = value == null ? "" : value.toLowerCase(Locale.ROOT).replaceAll("[^a-z]", "");
        return switch (normalized) {
            case "cookie" -> LocaleResolverStrategy.COOKIE;
            case "acceptheader", "header", "accept" -> LocaleResolverStrategy.ACCEPT_HEADER;
            case "fixed" -> LocaleResolverStrategy.FIXED;
            default -> LocaleResolverStrategy.SESSION;
        };
    }

    @Bean(DispatcherServlet.LOCALE_RESOLVER_BEAN_NAME)
    @ConditionalOnMissingBean(name = DispatcherServlet.LOCALE_RESOLVER_BEAN_NAME, search = SearchStrategy.CURRENT)
    public LocaleResolver localeResolver() {
        return switch (resolveStrategy(localeResolverType)) {
            case COOKIE -> new CookieLocaleResolver("locale");
            case ACCEPT_HEADER -> new AcceptHeaderLocaleResolver();
            case FIXED -> new FixedLocaleResolver(fixedLocale());
            case SESSION -> new SessionLocaleResolver();
        };
    }

    private Locale fixedLocale() {
        if (StringUtils.hasText(defaultLocale)) {
            Locale parsed = StringUtils.parseLocale(defaultLocale);
            if (parsed != null) {
                return parsed;
            }
        }
        return Locale.getDefault();
    }

    @Bean
    @ConditionalOnMissingBean(name = "localeChangeInterceptor", search = SearchStrategy.CURRENT)
    public LocaleChangeInterceptor localeChangeInterceptor() {
        ParamsAwareLocaleChangeInterceptor localeChangeInterceptor = new ParamsAwareLocaleChangeInterceptor();
        localeChangeInterceptor.setParamName("lang");
        return localeChangeInterceptor;
    }

    @Bean(AbstractApplicationContext.MESSAGE_SOURCE_BEAN_NAME)
    @ConditionalOnMissingBean(name = AbstractApplicationContext.MESSAGE_SOURCE_BEAN_NAME, search = SearchStrategy.CURRENT)
    public MessageSource messageSource(GrailsApplication grailsApplication, GrailsPluginManager pluginManager) {
        PluginAwareResourceBundleMessageSource messageSource = new PluginAwareResourceBundleMessageSource(grailsApplication, pluginManager);
        messageSource.setDefaultEncoding(encoding);
        messageSource.setFallbackToSystemLocale(false);
        if (Environment.getCurrent().isReloadEnabled() || gspEnableReload) {
            messageSource.setCacheSeconds(cacheSeconds);
            messageSource.setFileCacheSeconds(fileCacheSeconds);
        }
        return messageSource;
    }

    @Bean
    @ConditionalOnMissingBean(AvailableLocaleResolver.class)
    public AvailableLocaleResolver availableLocaleResolver(GrailsApplication grailsApplication,
            @Value("${grails.i18n.availableLocales.includePlugins:true}") boolean includePlugins) {
        return new AvailableLocaleResolver(grailsApplication.getClassLoader(), fixedLocale(), includePlugins);
    }
}

After — I18nGrailsPlugin.groovy's class declaration and beans block (the rest of the file — doWithApplicationContext(), onChange(), isChildOfFile() — is pre-existing plugin-lifecycle logic, untouched by this conversion):

@Slf4j
@CompileStatic
@AutoConfiguration(before = [MessageSourceAutoConfiguration, WebMvcAutoConfiguration])
@ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET)
class I18nGrailsPlugin extends Plugin {

    String baseDir = 'grails-app/i18n'
    String version = GrailsUtil.getGrailsVersion()
    String watchedResources = "file:./${baseDir}/**/*.properties".toString()

    static final String AVAILABLE_LOCALES_ATTRIBUTE = 'availableLocales'

    def beans = {
        field('encoding', String).value(Settings.GSP_VIEW_ENCODING, 'UTF-8')
        field('gspEnableReload', boolean).value(Settings.GSP_ENABLE_RELOAD, 'false')
        field('cacheSeconds', int).value(Settings.I18N_CACHE_SECONDS, '5')
        field('fileCacheSeconds', int).value(Settings.I18N_FILE_CACHE_SECONDS, '5')
        field('localeResolverType', String).value(Settings.I18N_LOCALE_RESOLVER, 'session')
        field('defaultLocale', String).value('grails.i18n.default.locale', '')

        method('fixedLocale', Locale) {
            if (StringUtils.hasText(defaultLocale)) {
                Locale parsed = StringUtils.parseLocale(defaultLocale)
                if (parsed != null) {
                    return parsed
                }
            }
            Locale.getDefault()
        }

        bean(LocaleResolver).conditionalOnMissingBeanName(search: SearchStrategy.CURRENT) {
            String normalized = localeResolverType == null ? '' :
                    localeResolverType.toLowerCase(Locale.ROOT).replaceAll('[^a-z]', '')
            switch (normalized) {
                case 'cookie':
                    return new CookieLocaleResolver('locale')
                case 'acceptheader':
                case 'header':
                case 'accept':
                    return new AcceptHeaderLocaleResolver()
                case 'fixed':
                    return new FixedLocaleResolver(fixedLocale())
                default:
                    return new SessionLocaleResolver()
            }
        }

        bean(LocaleChangeInterceptor).conditionalOnMissingBeanName(search: SearchStrategy.CURRENT) {
            new ParamsAwareLocaleChangeInterceptor(paramName: 'lang')
        }

        bean(MessageSource).conditionalOnMissingBeanName(search: SearchStrategy.CURRENT) { GrailsApplication grailsApplication, GrailsPluginManager pluginManager ->
            // Captured before tap: the message source has cacheSeconds/fileCacheSeconds
            // properties of its own, which inside tap would shadow these injected fields.
            int configuredCacheSeconds = cacheSeconds
            int configuredFileCacheSeconds = fileCacheSeconds
            new PluginAwareResourceBundleMessageSource(grailsApplication, pluginManager).tap {
                defaultEncoding = encoding
                fallbackToSystemLocale = false
                if (Environment.current.reloadEnabled || gspEnableReload) {
                    cacheSeconds = configuredCacheSeconds
                    fileCacheSeconds = configuredFileCacheSeconds
                }
            }
        }

        bean(AvailableLocaleResolver).conditionalOnMissingBean() { GrailsApplication grailsApplication,
                @Value('${grails.i18n.availableLocales.includePlugins:true}') boolean includePlugins ->
            new AvailableLocaleResolver(grailsApplication.classLoader, fixedLocale(), includePlugins)
        }
    }

Two simplifications versus the original, both functionally identical: bean names are the literal strings 'localeResolver'/'messageSource' rather than references to DispatcherServlet.LOCALE_RESOLVER_BEAN_NAME/AbstractApplicationContext.MESSAGE_SOURCE_BEAN_NAME (bean(name, Type) requires a String literal, and those constants' values are exactly those strings); and the original's LocaleResolverStrategy enum plus its resolveStrategy(String) helper are inlined as a plain switch on a normalized string, since the DSL can't declare a nested type.

The bean name argument itself is optional, same as it is on field(...)/method(...): all four beans derive their Spring names from their types via Introspector.decapitalize() (LocaleResolver → 'localeResolver', MessageSource → 'messageSource', ...) — exactly the values the original file's DispatcherServlet.LOCALE_RESOLVER_BEAN_NAME/AbstractApplicationContext.MESSAGE_SOURCE_BEAN_NAME constants carry. For the three name-guarded beans, .conditionalOnMissingBeanName(...) then feeds that same derived name into the condition's name member, so the bean name and the back-off name are one statement that cannot diverge; availableLocaleResolver's bare .conditionalOnMissingBean() is type-based, with Spring inferring the type from the method's return type. The derived names remain contractual — external code (e.g. grails-test-suite-uber's PluginTests.java) references localeChangeInterceptor by literal string — so a bean's type rename would change its derived name and break those references.

The sibling's name derives from the plugin-descriptor convention: a *GrailsPlugin class swaps that suffix for AutoConfiguration, so bare @GrailsBeans on I18nGrailsPlugin regenerates exactly the class identity I18nAutoConfiguration had before this conversion — anything referencing it by name (AutoConfiguration.imports, another auto-configuration's beforeName/afterName, a test importing it directly) keeps working unchanged, with no attribute needed. A class not ending in GrailsPlugin appends AutoConfiguration instead, and @GrailsBeans(autoConfigurationName = "...") overrides either derivation.

What the DSL above actually compiles to — the generated I18nAutoConfiguration sibling, shown here as its Java equivalent (verified via javap: nothing DSL-specific survives into the real bytecode — the beans closure itself is gone, and the one tap block in the messageSource body compiles the way tap does in any statically-compiled Groovy class: an inner closure class, no dynamic dispatch):

@AutoConfiguration(before = {MessageSourceAutoConfiguration.class, WebMvcAutoConfiguration.class})
@ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET)
public class I18nAutoConfiguration {

    @Value("${grails.views.gsp.encoding:UTF-8}")
    private String encoding;

    @Value("${grails.gsp.enable.reload:false}")
    private boolean gspEnableReload;

    @Value("${grails.i18n.cache.seconds:5}")
    private int cacheSeconds;

    @Value("${grails.i18n.filecache.seconds:5}")
    private int fileCacheSeconds;

    @Value("${grails.i18n.localeResolver:session}")
    private String localeResolverType;

    @Value("${grails.i18n.default.locale:}")
    private String defaultLocale;

    private Locale fixedLocale() {
        if (StringUtils.hasText(defaultLocale)) {
            Locale parsed = StringUtils.parseLocale(defaultLocale);
            if (parsed != null) {
                return parsed;
            }
        }
        return Locale.getDefault();
    }

    @Bean("localeResolver")
    @ConditionalOnMissingBean(name = "localeResolver", search = SearchStrategy.CURRENT)
    public LocaleResolver localeResolver() {
        String normalized = localeResolverType == null ? "" :
                localeResolverType.toLowerCase(Locale.ROOT).replaceAll("[^a-z]", "");
        switch (normalized) {
            case "cookie":
                return new CookieLocaleResolver("locale");
            case "acceptheader":
            case "header":
            case "accept":
                return new AcceptHeaderLocaleResolver();
            case "fixed":
                return new FixedLocaleResolver(fixedLocale());
            default:
                return new SessionLocaleResolver();
        }
    }

    @Bean("localeChangeInterceptor")
    @ConditionalOnMissingBean(name = "localeChangeInterceptor", search = SearchStrategy.CURRENT)
    public LocaleChangeInterceptor localeChangeInterceptor() {
        ParamsAwareLocaleChangeInterceptor localeChangeInterceptor = new ParamsAwareLocaleChangeInterceptor();
        localeChangeInterceptor.setParamName("lang");
        return localeChangeInterceptor;
    }

    @Bean("messageSource")
    @ConditionalOnMissingBean(name = "messageSource", search = SearchStrategy.CURRENT)
    public MessageSource messageSource(GrailsApplication grailsApplication, GrailsPluginManager pluginManager) {
        int configuredCacheSeconds = this.cacheSeconds;
        int configuredFileCacheSeconds = this.fileCacheSeconds;
        PluginAwareResourceBundleMessageSource source = new PluginAwareResourceBundleMessageSource(grailsApplication, pluginManager);
        source.setDefaultEncoding(encoding);
        source.setFallbackToSystemLocale(false);
        if (Environment.getCurrent().isReloadEnabled() || gspEnableReload) {
            source.setCacheSeconds(configuredCacheSeconds);
            source.setFileCacheSeconds(configuredFileCacheSeconds);
        }
        return source;
    }

    @Bean
    @ConditionalOnMissingBean
    public AvailableLocaleResolver availableLocaleResolver(GrailsApplication grailsApplication,
            @Value("${grails.i18n.availableLocales.includePlugins:true}") boolean includePlugins) {
        return new AvailableLocaleResolver(grailsApplication.getClassLoader(), fixedLocale(), includePlugins);
    }
}

This isn't just plausible-looking: the full pre-existing grails-i18n test suite (conditional back-off by name and SearchStrategy.CURRENT, property-driven strategy selection, parent-context isolation, ordering against GrailsLocaleResolverAutoConfiguration) passes unmodified against the generated class, now renamed back to I18nAutoConfigurationSpec.groovy to match.

A Plugin subclass is instantiated by DefaultGrailsPlugin via plain reflection, never as a Spring bean, so it can't itself carry @Bean methods or a meaningful @AutoConfiguration/@Conditional* annotation. In this form, the compiled members land on a generated sibling class in the same package, named by the plugin-descriptor convention — a *GrailsPlugin class swaps that suffix for AutoConfiguration (I18nGrailsPlugin → I18nAutoConfiguration here), any other name appends it, and @GrailsBeans(autoConfigurationName = "...") overrides both. Every annotation that only makes sense on whatever Spring Boot actually evaluates moves onto that sibling, not just @AutoConfiguration: the whole @Conditional* family, @Import/@ImportAutoConfiguration/@ImportResource, @ComponentScan, @EnableConfigurationProperties, @PropertySource/@PropertySources, @AutoConfigureOrder/Before/After — including a composed annotation built on top of any of these (e.g. a project-specific @ConditionalOnFeature meta-annotated with Spring Boot's own @ConditionalOnProperty, found by walking the meta-annotation chain rather than requiring an exact match). An annotation outside that set stays put, since no automatic determination from metadata can cover annotations this transform has never heard of — name those explicitly with @GrailsBeans(moveAnnotations = [SomeVendorAnnotation]) and they move the same way. @AutoConfiguration is required on the plugin class (even bare) whenever this form is used — omitting it is a compile-time error, not a silent runtime gap, since the generated sibling would otherwise never be processed by Boot.

Registration

Because the result is an ordinary @AutoConfiguration class, it must be registered in META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports like any other. Apply the new org.apache.grails.buildsrc.autoconfiguration-imports convention plugin to generate that file automatically at build time by scanning the module's compiled classes for @AutoConfiguration — no hand-maintained imports file:

plugins {
    id 'org.apache.grails.buildsrc.autoconfiguration-imports'
}

(grails-i18n predates this convention plugin and hand-maintains its imports file instead — either way works, the convention plugin just saves remembering to update it.)

Bugs found while converting

Converting the framework's own auto-configurations surfaced five defects, all silent and none caught by existing tests. Each is a separate commit and can be reviewed — or cherry-picked to a maintenance line — on its own.

Component scanning ignored grails.spring.bean.packages outside the project directory (0161f9d). This is the one worth reviewing on its own merits, and it is present on 7.1.x and 7.2.x as well. BuildSettings resolves CLASSES_DIR from a working-directory-relative probe:

boolean grailsAppDirPresent = new File('grails-app').exists() || new File('Application.groovy').exists()
if (!grailsAppDirPresent) { CLASSES_DIR = null }

and the scanner wrapped its entire resource lookup in if (BuildSettings.CLASSES_DIR != null), returning an empty array everywhere else. Reproduced on released 8.0.0-M4 by running one jar from two directories — started from the project root the scanned @Component registered, started from an empty directory it did not, same jar and same application.yml. That covers a systemd unit, a container with its own WORKDIR, or an app server, while sparing java -jar build/libs/app.jar from the project root, which is presumably why it survived. The custom resolution is replaced by PathMatchingResourcePatternResolver's own; the closure-class filter and plugin TypeFilters are kept. Applications that deploy this way will start getting beans they currently miss.

grails.spring.placeholder.prefix never applied (100b9db). The configurer is a BeanFactoryPostProcessor, so its configuration class is built before @Value injection is active and the injected field was always null.

grails.gorm.autoTimestampCacheAnnotations never reached its consumers (1544bd7). The default was written with Config.put, but AutoTimestampEventListener and DomainModelServiceImpl read it through @Value("${...}"), which resolves against the environment. Development mode cached annotations — the opposite of the intent.

Sitemesh3EnvironmentPostProcessor never ran (da28b4f), registered under org.springframework.boot.env.EnvironmentPostProcessor, which Spring Boot 4 deprecated forRemoval and no longer loads. Its warning could not have printed anyway, logging from a phase that precedes Boot's logging initialisation; it now takes DeferredLogFactory and logs at error.

Three of those trace to one cause, since removed (2930502): GrailsPlaceholderConfigurer advertised GrailsConfigurationAware while being created before the BeanPostProcessor that populates it, so its Config was always null.

Limitations

The DSL still covers a narrower surface than doWithSpring(BeanBuilder):

• Each top-level statement inside beans { } must be exactly bean(...), field(...), or method(...) with their respective chaining — an if, a for loop, or any other imperative Groovy directly inside beans { } is a compile-time error. This is about the DSL's own top-level statements, not the bodies of bean(...)/method(...) closures, which accept arbitrary Groovy — field(...)/method(...) already cover the common reasons to want shared state or logic in the first place.
• .annotate(...) attribute values must be simple compile-time constants (strings, numbers, booleans, class literals, enum constants, or arrays of these) — an attribute that itself takes a nested annotation as its value isn't supported. field(...)/method(...) can't declare a nested type either (no inner enums/classes).
• Dependencies on other beans are expressed only through typed closure parameters (autowired by type), not by name — no ref('beanName') lookup.
• Abstract parent bean definitions have no equivalent — neither in the DSL nor in BeanRegistry.Spec, whose registerBean always takes a class. This is the one thing that keeps doWithSpring on CoreGrailsPlugin: abstractGrailsResourceLocator is a classless definition carrying a single property, and it is public surface — third-party plugins inherit from it with bean.parent = 'abstractGrailsResourceLocator', asset-pipeline's assetResourceLocator among them.

@GrailsBeans is independent of Plugin/beanRegistrar()/doWithSpring — reach for it specifically when a bean's registration needs ordering or conditioning against a particular other auto-configuration; beanRegistrar() remains the recommended way to register beans from a Plugin otherwise. Both are documented side by side in grails-doc/src/en/guide/plugins/hookingIntoRuntimeConfiguration.adoc, and application usage — including directly on the Application class — in the Grails-and-Spring chapter (spring/springdslAdditional.adoc).

[codecov]

Codecov Report

❌ Patch coverage is 82.71429% with 121 lines in your changes missing coverage. Please review.
✅ Project coverage is 51.6926%. Comparing base (3c5b1b9) to head (2930502).

Files with missing lines	Patch %	Lines
...s/compiler/beans/GrailsBeansASTTransformation.java	84.8485%	39 Missing and 46 partials ⚠️
...ion/GlobalGrailsClassInjectorTransformation.groovy	6.6667%	13 Missing and 1 partial ⚠️
...vy/org/grails/plugins/i18n/I18nGrailsPlugin.groovy	74.0741%	3 Missing and 4 partials ⚠️
...sitemesh3/Sitemesh3EnvironmentPostProcessor.groovy	42.8571%	4 Missing ⚠️
...ails/plugins/domain/DomainClassGrailsPlugin.groovy	40.0000%	2 Missing and 1 partial ⚠️
...ils/plugins/sitemesh3/Sitemesh3GrailsPlugin.groovy	76.9231%	0 Missing and 3 partials ⚠️
...plugins/web/mapping/UrlMappingsGrailsPlugin.groovy	70.0000%	0 Missing and 3 partials ⚠️
.../groovy/org/grails/plugins/CoreGrailsPlugin.groovy	88.8889%	0 Missing and 1 partial ⚠️
.../domain/DomainClassEnvironmentPostProcessor.groovy	85.7143%	0 Missing and 1 partial ⚠️

Additional details and impacted files

@@                Coverage Diff                 @@
##                8.0.x     #16019        +/-   ##
==================================================
+ Coverage     51.4814%   51.6926%   +0.2113%     
- Complexity      17775      17971       +196     
==================================================
  Files            2039       2043         +4     
  Lines           95586      96151       +565     
  Branches        16591      16757       +166     
==================================================
+ Hits            49209      49703       +494     
- Misses          39066      39095        +29     
- Partials         7311       7353        +42     

Files with missing lines	Coverage Δ
...rc/main/groovy/beandsl/example/ExampleBeans.groovy	100.0000% <100.0000%> (ø)
...rc/main/groovy/beandsl/example/FancyGreeter.groovy	100.0000% <100.0000%> (ø)
...ple/src/main/groovy/beandsl/example/Greeter.groovy	100.0000% <100.0000%> (ø)
...src/main/groovy/beandsl/example/LoudGreeter.groovy	100.0000% <100.0000%> (ø)
...main/groovy/beandsl/example/plugin/Farewell.groovy	100.0000% <100.0000%> (ø)
...beandsl/example/plugin/FarewellGrailsPlugin.groovy	100.0000% <100.0000%> (ø)
...main/groovy/beandsl/example/plugin/Greeting.groovy	100.0000% <100.0000%> (ø)
...beandsl/example/plugin/GreetingGrailsPlugin.groovy	100.0000% <100.0000%> (ø)
...roovy/grails/plugin/cache/CacheGrailsPlugin.groovy	17.6471% <100.0000%> (-7.3529%)	⬇️
.../web/controllers/ControllersAutoConfiguration.java	95.0820% <ø> (ø)
... and 12 more

... and 6 files with indirect coverage changes

🚀 New features to boost your workflow:

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.
• 📦 JS Bundle Analysis: Save yourself from yourself by tracking and limiting bundle sizes in JS merges.

[codeconsole]

The grails-core conversion (6986f0c, with the follow-up fix in 100b9db), same pattern. This is the first one where the plugin keeps its legacy doWithSpring() — the bean builder closure is isolated with @CompileDynamic so the class itself can carry @CompileStatic, which the transform copies onto the generated sibling — and the first where the sibling does not land on the deleted class's exact package. Imports and comments are trimmed here; each linked filename is the verbatim, commit-pinned source.

Before, CoreAutoConfiguration.java (since deleted):

@AutoConfiguration(before = { PropertyPlaceholderAutoConfiguration.class })
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
public class CoreAutoConfiguration {

    @Value("${" + Settings.SPRING_PLACEHOLDER_PREFIX + ":#{null}}")
    private String placeholderPrefix;

    @Bean
    @Primary
    public ClassLoader classLoader(GrailsApplication grailsApplication) {
        return grailsApplication.getClassLoader();
    }

    @Bean
    @Primary
    public ConfigProperties grailsConfigProperties(GrailsApplication grailsApplication) {
        return new ConfigProperties(grailsApplication.getConfig());
    }

    @Bean
    @Primary
    PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer() {
        GrailsPlaceholderConfigurer grailsPlaceholderConfigurer = new GrailsPlaceholderConfigurer();
        if (placeholderPrefix != null) {
            grailsPlaceholderConfigurer.setPlaceholderPrefix(placeholderPrefix);
        }
        return grailsPlaceholderConfigurer;
    }
}

After — CoreGrailsPlugin.groovy's class declaration and beans block (the plugin's metadata properties between them are elided below, unchanged by the conversion; doWithSpring() and onChange() further down the file are pre-existing plugin logic, untouched):

@CompileStatic
@GrailsBeans
@AutoConfiguration(before = [PropertyPlaceholderAutoConfiguration])
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
class CoreGrailsPlugin extends Plugin {

    // ... pre-existing plugin metadata properties, unchanged ...

    def beans = {
        bean(ClassLoader).primary() { GrailsApplication grailsApplication ->
            grailsApplication.classLoader
        }

        bean('grailsConfigProperties', ConfigProperties).primary() { GrailsApplication grailsApplication ->
            new ConfigProperties(grailsApplication.config)
        }

        bean(PropertySourcesPlaceholderConfigurer).primary().staticMethod() { Environment environment ->
            def configurer = new GrailsPlaceholderConfigurer()
            String prefix = environment.getProperty(Settings.SPRING_PLACEHOLDER_PREFIX)
            if (prefix != null) {
                configurer.placeholderPrefix = prefix
            }
            configurer
        }
    }

CoreGrailsPlugin lives in org.grails.plugins while the deleted class was in org.grails.plugins.core, and the sibling is always emitted into the plugin's own package, so the class becomes org.grails.plugins.CoreAutoConfiguration and the single hand-maintained AutoConfiguration.imports entry moves with it. Nothing else in the repository referenced the old package, and the org.grails prefix filter in grails-testing-support-core still matches. @AutoConfiguration(before = ...) and @AutoConfigureOrder move onto the sibling at compile time, and javap confirms the rest is equivalent to the deleted Java class: the same three method signatures, the same @Bean/@Primary pairs, and no invokedynamic call sites, with the beans closure not surviving on the plugin class.

The .staticMethod() on the placeholder configurer is a behaviour fix rather than a like-for-like port, and it is worth calling out because the DSL made it visible. grails.spring.placeholder.prefix never had any effect: the configurer is a BeanFactoryPostProcessor, so its configuration class is instantiated during invokeBeanFactoryPostProcessors, before AutowiredAnnotationBeanPostProcessor is registered, and the @Value field the original instance method read was therefore always null — confirmed by reflection against a refreshed context, where the field held null and the configurer kept the default ${ prefix. A static factory method needs no enclosing instance and can take the Environment directly, which is the shape Boot's own PropertyPlaceholderAutoConfiguration uses, so the configured prefix now actually applies.

The auto-configuration previously had no test coverage at all; the new CoreAutoConfigurationSpec asserts the three beans and their types, the class loader identity, @Primary winning against a competing ClassLoader candidate, the config properties read-through to the application config, Boot's PropertyPlaceholderAutoConfiguration ordering after this one and backing off, default-prefix placeholder resolution in bean definitions, an unresolvable placeholder being left in place rather than failing the context, and — newly possible — a configured prefix both resolving @{foo.bar} and displacing the default so ${foo.bar} is left literal. One dependency note for anyone writing similar specs: spring-boot-test alone is not enough, because ApplicationContextRunner's signatures reach AssertJ through ApplicationContextAssertProvider; without assertj-core on the test classpath Groovy cannot introspect the runner at all — its metaclass degrades to Object's methods and every call fails to dispatch with MissingMethodException.

[codeconsole]

The grails-cache conversion (311fb9a), same pattern. This is the first one where the generated sibling is deliberately not given the deleted class's name: CacheGrailsPlugin derives CacheAutoConfiguration, and pinning the old GrailsCacheAutoConfiguration with @GrailsBeans(autoConfigurationName = ...) would have baked in a naming inconsistency the rest of the framework does not share — UrlMappingsAutoConfiguration, Sitemesh3AutoConfiguration, MailAutoConfiguration, I18nAutoConfiguration and ControllersAutoConfiguration all already follow the *GrailsPlugin -> *AutoConfiguration convention, and the redundant Grails prefix is the outlier. That attribute is for a name that genuinely cannot move, not for preserving legacy naming. Imports and comments are trimmed here; each linked filename is the verbatim, commit-pinned source.

Before, GrailsCacheAutoConfiguration.groovy (since deleted):

@AutoConfiguration
@ConditionalOnBooleanProperty(name = 'grails.cache.enabled', matchIfMissing = true)
@ConditionalOnBean(CachePluginConfiguration)
@CompileStatic
class GrailsCacheAutoConfiguration {

    @Value('${grails.cache.cacheManager:}')
    String cacheManagerType

    @Bean
    @ConditionalOnMissingBean(name = 'customCacheKeyGenerator')
    CustomCacheKeyGenerator customCacheKeyGenerator() {
        new CustomCacheKeyGenerator()
    }

    @Bean
    @ConditionalOnMissingBean(name = 'grailsCacheManager')
    GrailsCacheManager grailsCacheManager(CachePluginConfiguration grailsCacheConfiguration) {
        if (cacheManagerType == 'GrailsConcurrentLinkedMapCacheManager') {
            return new GrailsConcurrentLinkedMapCacheManager(configuration: grailsCacheConfiguration)
        }
        new GrailsConcurrentMapCacheManager(configuration: grailsCacheConfiguration)
    }

}

After — CacheGrailsPlugin.groovy's class declaration and beans block (the plugin's metadata properties between them are elided below, unchanged by the conversion; beanRegistrar() and doWithApplicationContext() further down the file are pre-existing plugin logic, untouched):

@Slf4j
@CompileStatic
@AutoConfiguration
@ConditionalOnBooleanProperty(name = 'grails.cache.enabled', matchIfMissing = true)
@ConditionalOnBean(CachePluginConfiguration)
class CacheGrailsPlugin extends Plugin {

    // ... pre-existing plugin metadata properties and isCachingEnabled(), unchanged ...

    def beans = {
        field('cacheManagerType', String).value('grails.cache.cacheManager', '')

        bean(CustomCacheKeyGenerator).conditionalOnMissingBeanName()

        bean(GrailsCacheManager).conditionalOnMissingBeanName() { CachePluginConfiguration grailsCacheConfiguration ->
            if (cacheManagerType == 'GrailsConcurrentLinkedMapCacheManager') {
                return new GrailsConcurrentLinkedMapCacheManager(configuration: grailsCacheConfiguration)
            }
            new GrailsConcurrentMapCacheManager(configuration: grailsCacheConfiguration)
        }
    }

This conversion sits next to a beanRegistrar() that the two auto-configured beans are gated on: @ConditionalOnBean(CachePluginConfiguration) refers to the grailsCacheConfiguration definition the registrar contributes, and the registrar runs before auto-configuration conditions are evaluated, so the pair backs off entirely when the plugin is inactive — the jar on the classpath but the plugin excluded. The deleted class's design documentation now lives on the plugin, next to the registrar it describes. @AutoConfiguration, @ConditionalOnBooleanProperty and @ConditionalOnBean all move onto the sibling at compile time, and @CompileStatic is copied onto it so the generated configuration keeps the deleted class's static compilation.

The rename is contained: the only references were the module's own tests, so GrailsCacheAutoConfigurationSpec becomes CacheAutoConfigurationSpec and CacheGrailsPluginSpec's description is updated. It remains a public FQCN change for anyone excluding the auto-configuration through @EnableAutoConfiguration(exclude = ...) or spring.autoconfigure.exclude, which a major release is the right place to take. The full grails-cache suite passes unmodified against the generated class, including CacheAutoConfigurationSpec's direct context.register(CacheAutoConfiguration).

[codeconsole]

The grails-domain-class conversion (700cf9c), same pattern and the same naming decision as the cache one: the sibling takes the convention name DomainClassAutoConfiguration rather than being pinned to GrailsDomainClassAutoConfiguration. This one also exercises two things the earlier conversions did not — replacing constructor injection, and a rename that other modules reference. Imports and comments are trimmed here; each linked filename is the verbatim, commit-pinned source.

Before, GrailsDomainClassAutoConfiguration.groovy (since deleted):

@CompileStatic
@AutoConfiguration(afterName = ['org.grails.plugins.i18n.I18nAutoConfiguration'])
@ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET)
class GrailsDomainClassAutoConfiguration {

    GrailsApplication grailsApplication

    List<MessageSource> messageSources

    @Autowired
    GrailsDomainClassAutoConfiguration(GrailsApplication grailsApplication, List<MessageSource> messageSources) {
        this.grailsApplication = grailsApplication
        this.messageSources = messageSources
    }

    @Lazy
    @Bean(name = 'grailsDomainClassMappingContext')
    DefaultMappingContextFactoryBean grailsDomainClassMappingContext(List<ConstraintFactory> factories) {
        new DefaultMappingContextFactoryBean(grailsApplication, messageSources).tap {
            constraintFactories = factories ?: []
        }
    }

    @Lazy
    @Bean
    DefaultConstraintEvaluatorFactoryBean validateableConstraintsEvaluator(@Qualifier('grailsDomainClassMappingContext') MappingContext mappingContext) {
        new DefaultConstraintEvaluatorFactoryBean(messageSources, mappingContext, grailsApplication)
    }

    @Lazy
    @Bean
    ValidatorRegistryFactoryBean gormValidatorRegistry(@Qualifier('grailsDomainClassMappingContext') MappingContext mappingContext) {
        new ValidatorRegistryFactoryBean().tap {
            it.mappingContext = mappingContext
        }
    }
}

After — DomainClassGrailsPlugin.groovy's class declaration and beans block (the plugin's metadata properties between them are elided below, unchanged by the conversion; beanRegistrar() further down the file is pre-existing plugin logic, untouched):

@CompileStatic
@AutoConfiguration(afterName = ['org.grails.plugins.i18n.I18nAutoConfiguration'])
@ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET)
class DomainClassGrailsPlugin extends Plugin {

    // ... pre-existing plugin metadata properties, unchanged ...

    def beans = {
        bean('grailsDomainClassMappingContext', DefaultMappingContextFactoryBean).lazy() { GrailsApplication grailsApplication, List<MessageSource> messageSources, List<ConstraintFactory> factories ->
            new DefaultMappingContextFactoryBean(grailsApplication, messageSources).tap {
                constraintFactories = factories ?: []
            }
        }

        bean('validateableConstraintsEvaluator', DefaultConstraintEvaluatorFactoryBean).lazy() { GrailsApplication grailsApplication, List<MessageSource> messageSources, @Qualifier('grailsDomainClassMappingContext') MappingContext mappingContext ->
            new DefaultConstraintEvaluatorFactoryBean(messageSources, mappingContext, grailsApplication)
        }

        bean('gormValidatorRegistry', ValidatorRegistryFactoryBean).lazy() { @Qualifier('grailsDomainClassMappingContext') MappingContext mappingContext ->
            new ValidatorRegistryFactoryBean().tap {
                it.mappingContext = mappingContext
            }
        }
    }

The one structural change is the constructor. The deleted class held grailsApplication and messageSources as fields populated by an @Autowired constructor, and the generated sibling always has a no-arg constructor, so neither could be reproduced as-is. Declaring them as field(...) instead would not have worked either: a field('messageSources', List) is a raw List, and Spring cannot resolve that injection point without an element type. Taking both as bean method parameters keeps the generics, and Spring resolves them identically — only when the bean that needs them is created, rather than when the configuration class is instantiated. Verified with javap:

public DefaultMappingContextFactoryBean grailsDomainClassMappingContext(GrailsApplication, List<MessageSource>, List<ConstraintFactory>)

List<MessageSource> and List<ConstraintFactory> survive as distinct injection points, and the two @Qualifier('grailsDomainClassMappingContext') MappingContext parameters carry their annotation through from the closure.

Unlike the cache rename, this class is referenced across modules, so two call sites move with it. ControllersAutoConfiguration orders itself after this one by class literal, and that reference simply follows the rename — worth stating explicitly, since the generated sibling is emitted into the module's jar and therefore resolves from a dependent module's Java compile like any other class. (Verified rather than assumed: swapping the reference to after = {DomainClassAutoConfiguration.class} compiles cleanly.) That keeps the reference type-safe, so a future rename is a compile error rather than a silently stale string. The 8.0 upgrade guide's grails-domain-class row also gains a note naming the new class and telling anyone with an @EnableAutoConfiguration(exclude = ...) or spring.autoconfigure.exclude entry to update it; the row's existing mention of the old name is left alone, since it documents the removed constraintsEvaluator API rather than the current class.

grails-domain-class, grails-controllers, grails-cache and the uber, web and persistence test suites all pass.

[codeconsole]

The grails-databinding conversion (623ce97), which drove a DSL addition: bean(Type) no longer requires a factory closure (4dab384). Five of these seven beans were nothing but their own no-argument construction, and spelling that out as bean('xmlDataBindingSourceCreator', XmlDataBindingSourceCreator) { new XmlDataBindingSourceCreator() } restates the type three times to say nothing. Imports and comments are trimmed here; each linked filename is the verbatim, commit-pinned source.

Before, DataBindingConfiguration.java (since deleted):

@AutoConfiguration
@AutoConfigureOrder
@EnableConfigurationProperties(DataBindingConfigurationProperties.class)
@ImportAutoConfiguration(DefaultConvertersConfiguration.class)
public class DataBindingConfiguration {

    private final DataBindingConfigurationProperties configurationProperties;

    public DataBindingConfiguration(DataBindingConfigurationProperties configurationProperties) {
        this.configurationProperties = configurationProperties;
    }

    @Lazy
    @Bean("grailsWebDataBinder")
    protected GrailsWebDataBinder grailsWebDataBinder(
            GrailsApplication grailsApplication,
            ValueConverter[] valueConverters,
            FormattedValueConverter[] formattedValueConverters,
            TypedStructuredBindingEditor[] structuredBindingEditors,
            DataBindingListener[] dataBindingListeners) {

        GrailsWebDataBinder dataBinder = new GrailsWebDataBinder(grailsApplication);
        dataBinder.setConvertEmptyStringsToNull(configurationProperties.isConvertEmptyStringsToNull());
        // ... converter/editor/listener merging with the main context, elided ...
        return dataBinder;
    }

    @Bean("xmlDataBindingSourceCreator")
    protected XmlDataBindingSourceCreator xmlDataBindingSourceCreator() {
        return new XmlDataBindingSourceCreator();
    }

    @Bean("jsonDataBindingSourceCreator")
    protected JsonDataBindingSourceCreator jsonDataBindingSourceCreator() {
        return new JsonDataBindingSourceCreator();
    }

    @Bean("halJsonDataBindingSourceCreator")
    protected HalJsonDataBindingSourceCreator halJsonDataBindingSourceCreator() {
        return new HalJsonDataBindingSourceCreator();
    }

    @Bean("halXmlDataBindingSourceCreator")
    protected HalXmlDataBindingSourceCreator halXmlDataBindingSourceCreator() {
        return new HalXmlDataBindingSourceCreator();
    }

    @Bean("jsonApiDataBindingSourceCreator")
    protected JsonApiDataBindingSourceCreator jsonApiDataBindingSourceCreator() {
        return new JsonApiDataBindingSourceCreator();
    }

    @Bean("dataBindingSourceRegistry")
    protected DataBindingSourceRegistry dataBindingSourceRegistry(DataBindingSourceCreator... creators) {
        final DefaultDataBindingSourceRegistry registry = new DefaultDataBindingSourceRegistry();
        registry.setDataBindingSourceCreators(creators);
        registry.initialize();
        return registry;
    }
}

After — DataBindingGrailsPlugin.groovy's class declaration and beans block. The plugin previously held nothing but a version property, so this is the whole file:

@CompileStatic
@AutoConfiguration
@AutoConfigureOrder
@EnableConfigurationProperties(DataBindingConfigurationProperties)
@ImportAutoConfiguration(DefaultConvertersConfiguration)
class DataBindingGrailsPlugin extends Plugin {

    def version = GrailsUtil.getGrailsVersion()

    def beans = {
        bean(GrailsWebDataBinder).lazy() { GrailsApplication grailsApplication,
                DataBindingConfigurationProperties configurationProperties,
                ValueConverter[] valueConverters,
                FormattedValueConverter[] formattedValueConverters,
                TypedStructuredBindingEditor[] structuredBindingEditors,
                DataBindingListener[] dataBindingListeners ->

            GrailsWebDataBinder dataBinder = new GrailsWebDataBinder(grailsApplication)
            dataBinder.convertEmptyStringsToNull = configurationProperties.convertEmptyStringsToNull
            dataBinder.trimStrings = configurationProperties.trimStrings
            dataBinder.autoGrowCollectionLimit = configurationProperties.autoGrowCollectionLimit

            ApplicationContext mainContext = grailsApplication.mainContext
            ValueConverter[] allValueConverters = (valueConverters + mainContext.getBeansOfType(ValueConverter).values()) as ValueConverter[]
            AnnotationAwareOrderComparator.sort(allValueConverters)
            dataBinder.valueConverters = allValueConverters

            dataBinder.formattedValueConverters =
                    (formattedValueConverters + mainContext.getBeansOfType(FormattedValueConverter).values()) as FormattedValueConverter[]
            dataBinder.structuredBindingEditors =
                    (structuredBindingEditors + mainContext.getBeansOfType(TypedStructuredBindingEditor).values()) as TypedStructuredBindingEditor[]
            dataBinder.dataBindingListeners =
                    (dataBindingListeners + mainContext.getBeansOfType(DataBindingListener).values()) as DataBindingListener[]

            dataBinder.messageSource = mainContext.getBean('messageSource', MessageSource)
            dataBinder
        }

        bean(XmlDataBindingSourceCreator)
        bean(JsonDataBindingSourceCreator)
        bean(HalJsonDataBindingSourceCreator)
        bean(HalXmlDataBindingSourceCreator)
        bean(JsonApiDataBindingSourceCreator)

        bean(DataBindingSourceRegistry) { DataBindingSourceCreator[] creators ->
            new DefaultDataBindingSourceRegistry().tap {
                dataBindingSourceCreators = creators
                initialize()
            }
        }
    }
}

The bodyless bean(Type) form. The trailing closure is now optional: bean(Type) and bean('name', Type) generate a parameterless factory method returning new Type(), and chain the existing qualifiers exactly as the closure form does — bean(Widget).primary().lazy().conditionalOnMissingBean() compiles the same way it would with an empty body. Because it constructs the declared type, it is rejected at compile time for an interface or abstract class with a message pointing at the fix, rather than deferring to a confusing error inside generated code. That is precisely why dataBindingSourceRegistry above keeps its closure: it declares the DataBindingSourceRegistry interface while constructing DefaultDataBindingSourceRegistry and then initializing it.

No explicit names. Each of these seven types decapitalizes to exactly the bean name the hand-written class declared, so passing the name would only restate it. Reading the @Bean values back out of the bytecode confirms all seven are unchanged. The same cleanup was applied to the earlier grails-core and grails-cache conversions (bab7b05), which had carried the same redundancy; the names that remain across all conversions are the ones a type genuinely does not produce — grailsUrlConverter from UrlConverter, mailSession from JndiObjectFactoryBean, grailsDomainClassMappingContext from DefaultMappingContextFactoryBean, and so on.

Two structural notes. configurationProperties was a constructor-injected field, and the generated sibling always has a no-arg constructor; only grailsWebDataBinder reads it, so that one bean takes it as a parameter. And dataBindingSourceRegistry's DataBindingSourceCreator... parameter is written as an array — Spring resolves both identically, and javap shows Groovy hands the generated method the varargs flag back anyway, since a trailing array parameter on a closure compiles to varargs.

The class is renamed DataBindingConfiguration → DataBindingAutoConfiguration by the *GrailsPlugin → *AutoConfiguration convention. Beyond dropping the inconsistency, it corrects a class that was registered in AutoConfiguration.imports while named only *Configuration. The imports entry was its only reference in the repository; the 7.0 upgrade guide's note about the original DataBindingGrailsPlugin → DataBindingConfiguration move is left alone as an accurate record of the 7.x change.