Introduce BeanFactoryContribution

This commit introduces an infrastructure to contribute generated code
ahead of time to initialize a BeanFactory. Code and hints can be
contributed to a BeanFactorInitialization, with the ability to write to
other packages if necessary.

An implementation of that new interface that registers a BeanDefinition
is also included in this commit. It delegates to a
BeanInstantiationGenerator for geenerating the instance supplier that
creates the bean instance.

For corner cases, a BeanRegistrationContributionProvider can be
implemented. It allows to return a custom BeanFactoryContribution for
a particualr bean definition. This usually uses the default
implementation with a custom instance supplier.

Note that this commit adds an temporary executable resolution that is
meant to be replaced by the use of ConstructorResolver

See gh-28088

Author: snicoll

spring-beans/src/main/java/org/springframework/beans/factory/generator/BeanFactoryContribution.java

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2002-2022 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 org.springframework.beans.factory.generator;
+
+/**
+ * Contribute optimizations ahead of time to initialize a bean factory.
+ *
+ * @author Stephane Nicoll
+ * @since 6.0
+ */
+public interface BeanFactoryContribution {
+
+	/**
+	 * Contribute ahead of time optimizations to the specific
+	 * {@link BeanFactoryInitialization}.
+	 * @param initialization {@link BeanFactoryInitialization} to contribute to
+	 */
+	void applyTo(BeanFactoryInitialization initialization);
+
+}

spring-beans/src/main/java/org/springframework/beans/factory/generator/BeanFactoryInitialization.java

@@ -0,0 +1,110 @@
+/*
+ * Copyright 2002-2022 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 org.springframework.beans.factory.generator;
+
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+import javax.lang.model.element.Modifier;
+
+import org.springframework.aot.generator.GeneratedType;
+import org.springframework.aot.generator.GeneratedTypeContext;
+import org.springframework.aot.generator.ProtectedAccess;
+import org.springframework.beans.factory.BeanFactory;
+import org.springframework.beans.factory.support.DefaultListableBeanFactory;
+import org.springframework.javapoet.CodeBlock;
+import org.springframework.javapoet.CodeBlock.Builder;
+import org.springframework.javapoet.MethodSpec;
+
+/**
+ * The initialization of a {@link BeanFactory}.
+ *
+ * @author Andy Wilkinson
+ * @author Stephane Nicoll
+ * @since 6.0
+ */
+public class BeanFactoryInitialization {
+
+	private final GeneratedTypeContext generatedTypeContext;
+
+	private final CodeBlock.Builder codeContributions;
+
+	public BeanFactoryInitialization(GeneratedTypeContext generatedTypeContext) {
+		this.generatedTypeContext = generatedTypeContext;
+		this.codeContributions = CodeBlock.builder();
+	}
+
+	/**
+	 * Return the {@link GeneratedTypeContext} to use to contribute
+	 * additional methods or hints.
+	 * @return the generation context
+	 */
+	public GeneratedTypeContext generatedTypeContext() {
+		return this.generatedTypeContext;
+	}
+
+	/**
+	 * Contribute code that initializes the bean factory and that does not
+	 * require any privileged access.
+	 * @param code the code to contribute
+	 */
+	public void contribute(Consumer<Builder> code) {
+		CodeBlock.Builder builder = CodeBlock.builder();
+		code.accept(builder);
+		CodeBlock codeBlock = builder.build();
+		this.codeContributions.add(codeBlock);
+		if (!codeBlock.toString().endsWith("\n")) {
+			this.codeContributions.add("\n");
+		}
+	}
+
+	/**
+	 * Contribute code that initializes the bean factory. If privileged access
+	 * is required, a public method in the target package is created and
+	 * invoked, rather than contributing the code directly.
+	 * @param protectedAccess the {@link ProtectedAccess} instance to use
+	 * @param methodName a method name to use if privileged access is required
+	 * @param methodBody the contribution
+	 */
+	public void contribute(ProtectedAccess protectedAccess, Supplier<String> methodName,
+			Consumer<Builder> methodBody) {
+		String targetPackageName = this.generatedTypeContext.getMainGeneratedType().getClassName().packageName();
+		String protectedPackageName = protectedAccess.getPrivilegedPackageName(targetPackageName);
+		if (protectedPackageName != null) {
+			GeneratedType type = this.generatedTypeContext.getGeneratedType(protectedPackageName);
+			MethodSpec.Builder method = MethodSpec.methodBuilder(methodName.get())
+					.addModifiers(Modifier.PUBLIC, Modifier.STATIC)
+					.addParameter(DefaultListableBeanFactory.class, "beanFactory");
+			CodeBlock.Builder code = CodeBlock.builder();
+			methodBody.accept(code);
+			method.addCode(code.build());
+			contribute(main -> main.addStatement("$T.$N(beanFactory)", type.getClassName(), type.addMethod(method)));
+		}
+		else {
+			contribute(methodBody);
+		}
+	}
+
+	/**
+	 * Return the code that has been contributed to this instance.
+	 * @return the code
+	 */
+	public CodeBlock toCodeBlock() {
+		return this.codeContributions.build();
+	}
+
+}

spring-beans/src/main/java/org/springframework/beans/factory/generator/BeanInstantiationGenerator.java

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2002-2022 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 org.springframework.beans.factory.generator;
+
+import java.lang.reflect.Executable;
+
+import org.springframework.aot.generator.CodeContribution;
+import org.springframework.aot.hint.RuntimeHints;
+
+/**
+ * Generate code that instantiate a particular bean.
+ *
+ * @author Stephane Nicoll
+ * @since 6.0
+ */
+public interface BeanInstantiationGenerator {
+
+	/**
+	 * Return the {@link Executable} that is used to create the bean instance
+	 * for further metadata processing.
+	 * @return the executable that is used to create the bean instance
+	 */
+	Executable getInstanceCreator();
+
+	/**
+	 * Return the necessary code to instantiate a bean.
+	 * @param runtimeHints the runtime hints instance to use
+	 * @return a code contribution that provides an initialized bean instance
+	 */
+	CodeContribution generateBeanInstantiation(RuntimeHints runtimeHints);
+
+}
+

spring-beans/src/main/java/org/springframework/beans/factory/generator/BeanParameterGenerator.java

@@ -49,6 +49,11 @@
  */
 public final class BeanParameterGenerator {
 
+	/**
+	 * A default instance that does not handle inner bean definitions.
+	 */
+	public static final BeanParameterGenerator INSTANCE = new BeanParameterGenerator();
+
 	private final ResolvableTypeGenerator typeGenerator = new ResolvableTypeGenerator();
 
 	private final Function<BeanDefinition, CodeBlock> innerBeanDefinitionGenerator;