Harmonize use of generate

This commit harmonizes the use of the "generate" keyword for anything
related to code generation. Previously, there was a mix of "generate"
and "write."

See gh-28047

Author: snicoll

spring-beans/src/main/java/org/springframework/beans/factory/annotation/AutowiredAnnotationBeanPostProcessor.java

@@ -838,7 +838,7 @@ public void applyTo(CodeContribution contribution) {
 				boolean isRequired = isRequired(element);
 				Member member = element.getMember();
 				analyzeMember(contribution, member);
-				contribution.statements().addStatement(this.generator.writeInjection(member, isRequired));
+				contribution.statements().addStatement(this.generator.generateInjection(member, isRequired));
 			});
 		}
 

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

@@ -43,7 +43,7 @@
 import org.springframework.util.ObjectUtils;
 
 /**
- * Support for writing parameters.
+ * Support for generating parameters.
  *
  * @author Stephane Nicoll
  * @since 6.0
@@ -52,16 +52,16 @@ public final class BeanParameterGenerator {
 
 	private final ResolvableTypeGenerator typeGenerator = new ResolvableTypeGenerator();
 
-	private final BiConsumer<BeanDefinition, Builder> innerBeanDefinitionWriter;
+	private final BiConsumer<BeanDefinition, Builder> innerBeanDefinitionGenerator;
 
 
 	/**
-	 * Create an instance with the callback to use to write an inner bean
+	 * Create an instance with the callback to use to generate an inner bean
 	 * definition.
-	 * @param innerBeanDefinitionWriter the inner bean definition writer
+	 * @param innerBeanDefinitionGenerator the inner bean definition generator
 	 */
-	public BeanParameterGenerator(BiConsumer<BeanDefinition, Builder> innerBeanDefinitionWriter) {
-		this.innerBeanDefinitionWriter = innerBeanDefinitionWriter;
+	public BeanParameterGenerator(BiConsumer<BeanDefinition, Builder> innerBeanDefinitionGenerator) {
+		this.innerBeanDefinitionGenerator = innerBeanDefinitionGenerator;
 	}
 
 	/**
@@ -75,47 +75,47 @@ public BeanParameterGenerator() {
 
 
 	/**
-	 * Write the specified parameter {@code value}.
+	 * Generate the specified parameter {@code value}.
 	 * @param value the value of the parameter
 	 * @return the value of the parameter
 	 */
-	public CodeBlock writeParameterValue(@Nullable Object value) {
-		return writeParameterValue(value, () -> ResolvableType.forInstance(value));
+	public CodeBlock generateParameterValue(@Nullable Object value) {
+		return generateParameterValue(value, () -> ResolvableType.forInstance(value));
 	}
 
 	/**
-	 * Write the specified parameter {@code value}.
+	 * Generate the specified parameter {@code value}.
 	 * @param value the value of the parameter
 	 * @param parameterType the type of the parameter
 	 * @return the value of the parameter
 	 */
-	public CodeBlock writeParameterValue(@Nullable Object value, Supplier<ResolvableType> parameterType) {
+	public CodeBlock generateParameterValue(@Nullable Object value, Supplier<ResolvableType> parameterType) {
 		Builder code = CodeBlock.builder();
-		writeParameterValue(code, value, parameterType);
+		generateParameterValue(code, value, parameterType);
 		return code.build();
 	}
 
 	/**
-	 * Write the parameter types of the specified {@link Executable}.
+	 * Generate the parameter types of the specified {@link Executable}.
 	 * @param executable the executable
 	 * @return the parameter types of the executable as a comma separated list
 	 */
-	public CodeBlock writeExecutableParameterTypes(Executable executable) {
+	public CodeBlock generateExecutableParameterTypes(Executable executable) {
 		Class<?>[] parameterTypes = Arrays.stream(executable.getParameters())
 				.map(Parameter::getType).toArray(Class<?>[]::new);
 		return CodeBlock.of(Arrays.stream(parameterTypes).map(d -> "$T.class")
 				.collect(Collectors.joining(", ")), (Object[]) parameterTypes);
 	}
 
-	private void writeParameterValue(Builder code, @Nullable Object value, Supplier<ResolvableType> parameterTypeSupplier) {
+	private void generateParameterValue(Builder code, @Nullable Object value, Supplier<ResolvableType> parameterTypeSupplier) {
 		if (value == null) {
 			code.add("null");
 			return;
 		}
 		ResolvableType parameterType = parameterTypeSupplier.get();
 		if (parameterType.isArray()) {
 			code.add("new $T { ", parameterType.toClass());
-			code.add(writeAll(Arrays.asList(ObjectUtils.toObjectArray(value)),
+			code.add(generateAll(Arrays.asList(ObjectUtils.toObjectArray(value)),
 					item -> parameterType.getComponentType()));
 			code.add(" }");
 		}
@@ -127,7 +127,7 @@ else if (value instanceof List<?> list) {
 				Class<?> listType = (value instanceof ManagedList ? ManagedList.class : List.class);
 				code.add("$T.of(", listType);
 				ResolvableType collectionType = parameterType.as(List.class).getGenerics()[0];
-				code.add(writeAll(list, item -> collectionType));
+				code.add(generateAll(list, item -> collectionType));
 				code.add(")");
 			}
 		}
@@ -139,7 +139,7 @@ else if (value instanceof Set<?> set) {
 				Class<?> setType = (value instanceof ManagedSet ? ManagedSet.class : Set.class);
 				code.add("$T.of(", setType);
 				ResolvableType collectionType = parameterType.as(Set.class).getGenerics()[0];
-				code.add(writeAll(set, item -> collectionType));
+				code.add(generateAll(set, item -> collectionType));
 				code.add(")");
 			}
 		}
@@ -151,7 +151,7 @@ else if (value instanceof Map<?, ?> map) {
 					parameters.add(mapKey);
 					parameters.add(mapValue);
 				});
-				code.add(writeAll(parameters, ResolvableType::forInstance));
+				code.add(generateAll(parameters, ResolvableType::forInstance));
 				code.add(")");
 			}
 		}
@@ -175,7 +175,7 @@ else if (value instanceof ResolvableType) {
 			code.add(this.typeGenerator.generateTypeFor((ResolvableType) value));
 		}
 		else if (value instanceof BeanDefinition) {
-			this.innerBeanDefinitionWriter.accept((BeanDefinition) value, code);
+			this.innerBeanDefinitionGenerator.accept((BeanDefinition) value, code);
 		}
 		else if (value instanceof BeanReference) {
 			code.add("new $T($S)", RuntimeBeanReference.class, ((BeanReference) value).getBeanName());
@@ -185,10 +185,10 @@ else if (value instanceof BeanReference) {
 		}
 	}
 
-	private <T> CodeBlock writeAll(Iterable<T> items, Function<T, ResolvableType> elementType) {
+	private <T> CodeBlock generateAll(Iterable<T> items, Function<T, ResolvableType> elementType) {
 		MultiCodeBlock multi = new MultiCodeBlock();
 		items.forEach(item -> multi.add(code ->
-				writeParameterValue(code, item, () -> elementType.apply(item))));
+				generateParameterValue(code, item, () -> elementType.apply(item))));
 		return multi.join(", ");
 	}
 

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

@@ -33,7 +33,7 @@
 import org.springframework.util.ClassUtils;
 
 /**
- * Write the necessary statements to instantiate a bean.
+ * Generate the necessary statements to instantiate a bean.
  *
  * @author Stephane Nicoll
  * @see BeanInstantiationContribution
@@ -64,18 +64,18 @@ class DefaultBeanInstantiationGenerator {
 	 * @return a code contribution that provides an initialized bean instance
 	 */
 	public CodeContribution generateBeanInstantiation(RuntimeHints runtimeHints) {
-		DefaultCodeContribution contribution = new DefaultCodeContribution(runtimeHints);
-		contribution.protectedAccess().analyze(this.instanceCreator, this.beanInstanceOptions);
+		DefaultCodeContribution codeContribution = new DefaultCodeContribution(runtimeHints);
+		codeContribution.protectedAccess().analyze(this.instanceCreator, this.beanInstanceOptions);
 		if (this.instanceCreator instanceof Constructor<?> constructor) {
-			writeBeanInstantiation(contribution, constructor);
+			generateBeanInstantiation(codeContribution, constructor);
 		}
 		else if (this.instanceCreator instanceof Method method) {
-			writeBeanInstantiation(contribution, method);
+			generateBeanInstantiation(codeContribution, method);
 		}
-		return contribution;
+		return codeContribution;
 	}
 
-	private void writeBeanInstantiation(CodeContribution contribution, Constructor<?> constructor) {
+	private void generateBeanInstantiation(CodeContribution codeContribution, Constructor<?> constructor) {
 		Class<?> declaringType = ClassUtils.getUserClass(constructor.getDeclaringClass());
 		boolean innerClass = isInnerClass(declaringType);
 		boolean multiStatements = !this.contributions.isEmpty();
@@ -96,24 +96,24 @@ private void writeBeanInstantiation(CodeContribution contribution, Constructor<?
 					code.add("$T::new", declaringType);
 				}
 			}
-			contribution.statements().addStatement(code.build());
+			codeContribution.statements().addStatement(code.build());
 			return;
 		}
-		contribution.runtimeHints().reflection().registerConstructor(constructor,
+		codeContribution.runtimeHints().reflection().registerConstructor(constructor,
 				hint -> hint.withMode(ExecutableMode.INTROSPECT));
 		code.add("(instanceContext) ->");
 		branch(multiStatements, () -> code.beginControlFlow(""), () -> code.add(" "));
 		if (multiStatements) {
 			code.add("$T bean = ", declaringType);
 		}
-		code.add(this.injectionGenerator.writeInstantiation(constructor));
-		contribution.statements().addStatement(code.build());
+		code.add(this.injectionGenerator.generateInstantiation(constructor));
+		codeContribution.statements().addStatement(code.build());
 
 		if (multiStatements) {
-			for (BeanInstantiationContribution contributor : this.contributions) {
-				contributor.applyTo(contribution);
+			for (BeanInstantiationContribution contribution : this.contributions) {
+				contribution.applyTo(codeContribution);
 			}
-			contribution.statements().addStatement("return bean")
+			codeContribution.statements().addStatement("return bean")
 					.add(codeBlock -> codeBlock.unindent().add("}"));
 		}
 	}
@@ -122,9 +122,9 @@ private static boolean isInnerClass(Class<?> type) {
 		return type.isMemberClass() && !Modifier.isStatic(type.getModifiers());
 	}
 
-	private void writeBeanInstantiation(CodeContribution contribution, Method method) {
+	private void generateBeanInstantiation(CodeContribution codeContribution, Method method) {
 		// Factory method can be introspected
-		contribution.runtimeHints().reflection().registerMethod(method,
+		codeContribution.runtimeHints().reflection().registerMethod(method,
 				hint -> hint.withMode(ExecutableMode.INTROSPECT));
 		List<Class<?>> parameterTypes = new ArrayList<>(Arrays.asList(method.getParameterTypes()));
 		boolean multiStatements = !this.contributions.isEmpty();
@@ -137,21 +137,21 @@ private void writeBeanInstantiation(CodeContribution contribution, Method method
 					() -> code.add("$T", declaringType),
 					() -> code.add("beanFactory.getBean($T.class)", declaringType));
 			code.add(".$L()", method.getName());
-			contribution.statements().addStatement(code.build());
+			codeContribution.statements().addStatement(code.build());
 			return;
 		}
 		code.add("(instanceContext) ->");
 		branch(multiStatements, () -> code.beginControlFlow(""), () -> code.add(" "));
 		if (multiStatements) {
 			code.add("$T bean = ", method.getReturnType());
 		}
-		code.add(this.injectionGenerator.writeInstantiation(method));
-		contribution.statements().addStatement(code.build());
+		code.add(this.injectionGenerator.generateInstantiation(method));
+		codeContribution.statements().addStatement(code.build());
 		if (multiStatements) {
-			for (BeanInstantiationContribution contributor : this.contributions) {
-				contributor.applyTo(contribution);
+			for (BeanInstantiationContribution contribution : this.contributions) {
+				contribution.applyTo(codeContribution);
 			}
-			contribution.statements().addStatement("return bean")
+			codeContribution.statements().addStatement("return bean")
 					.add(codeBlock -> codeBlock.unindent().add("}"));
 		}
 	}

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

@@ -37,8 +37,8 @@
 import org.springframework.util.ReflectionUtils;
 
 /**
- * Generate the necessary code to {@link #writeInstantiation(Executable)
- * create a bean instance} or {@link #writeInjection(Member, boolean)
+ * Generate the necessary code to {@link #generateInstantiation(Executable)
+ * create a bean instance} or {@link #generateInjection(Member, boolean)
  * inject dependencies}.
  * <p/>
  * The generator assumes a number of variables to be accessible:
@@ -63,37 +63,37 @@ public class InjectionGenerator {
 
 
 	/**
-	 * Write the necessary code to instantiate an object using the specified
+	 * Generate the necessary code to instantiate an object using the specified
 	 * {@link Executable}. The code is suitable to be assigned to a variable
 	 * or used as a {@literal return} statement.
 	 * @param creator the executable to invoke to create an instance of the
 	 * requested object
 	 * @return the code to instantiate an object using the specified executable
 	 */
-	public CodeBlock writeInstantiation(Executable creator) {
+	public CodeBlock generateInstantiation(Executable creator) {
 		if (creator instanceof Constructor<?> constructor) {
-			return write(constructor);
+			return generateConstructorInstantiation(constructor);
 		}
 		if (creator instanceof Method method) {
-			return writeMethodInstantiation(method);
+			return generateMethodInstantiation(method);
 		}
 		throw new IllegalArgumentException("Could not handle creator " + creator);
 	}
 
 	/**
-	 * Write the code to inject a value resolved by {@link BeanInstanceContext}
+	 * Generate the code to inject a value resolved by {@link BeanInstanceContext}
 	 * in the specified {@link Member}.
 	 * @param member the field or method to inject
 	 * @param required whether the value is required
 	 * @return a statement that injects a value to the specified member
 	 * @see #getProtectedAccessInjectionOptions(Member)
 	 */
-	public CodeBlock writeInjection(Member member, boolean required) {
+	public CodeBlock generateInjection(Member member, boolean required) {
 		if (member instanceof Method method) {
-			return writeMethodInjection(method, required);
+			return generateMethodInjection(method, required);
 		}
 		if (member instanceof Field field) {
-			return writeFieldInjection(field, required);
+			return generateFieldInjection(field, required);
 		}
 		throw new IllegalArgumentException("Could not handle member " + member);
 	}
@@ -115,7 +115,7 @@ public Options getProtectedAccessInjectionOptions(Member member) {
 		throw new IllegalArgumentException("Could not handle member " + member);
 	}
 
-	private CodeBlock write(Constructor<?> creator) {
+	private CodeBlock generateConstructorInstantiation(Constructor<?> creator) {
 		Builder code = CodeBlock.builder();
 		Class<?> declaringType = ClassUtils.getUserClass(creator.getDeclaringClass());
 		boolean innerClass = isInnerClass(declaringType);
@@ -162,7 +162,7 @@ private static boolean isInnerClass(Class<?> type) {
 		return type.isMemberClass() && !Modifier.isStatic(type.getModifiers());
 	}
 
-	private CodeBlock writeMethodInstantiation(Method injectionPoint) {
+	private CodeBlock generateMethodInstantiation(Method injectionPoint) {
 		if (injectionPoint.getParameterCount() == 0) {
 			Builder code = CodeBlock.builder();
 			Class<?> declaringType = injectionPoint.getDeclaringClass();
@@ -175,10 +175,10 @@ private CodeBlock writeMethodInstantiation(Method injectionPoint) {
 			code.add(".$L()", injectionPoint.getName());
 			return code.build();
 		}
-		return write(injectionPoint, code -> code.add(".create(beanFactory, (attributes) ->"), true);
+		return generateMethodInvocation(injectionPoint, code -> code.add(".create(beanFactory, (attributes) ->"), true);
 	}
 
-	private CodeBlock writeMethodInjection(Method injectionPoint, boolean required) {
+	private CodeBlock generateMethodInjection(Method injectionPoint, boolean required) {
 		Consumer<Builder> attributesResolver = code -> {
 			if (required) {
 				code.add(".invoke(beanFactory, (attributes) ->");
@@ -187,15 +187,15 @@ private CodeBlock writeMethodInjection(Method injectionPoint, boolean required)
 				code.add(".resolve(beanFactory, false).ifResolved((attributes) ->");
 			}
 		};
-		return write(injectionPoint, attributesResolver, false);
+		return generateMethodInvocation(injectionPoint, attributesResolver, false);
 	}
 
-	private CodeBlock write(Method injectionPoint, Consumer<Builder> attributesResolver, boolean instantiation) {
+	private CodeBlock generateMethodInvocation(Method injectionPoint, Consumer<Builder> attributesResolver, boolean instantiation) {
 		Builder code = CodeBlock.builder();
 		code.add("instanceContext");
 		if (!instantiation) {
 			code.add(".method($S, ", injectionPoint.getName());
-			code.add(this.parameterGenerator.writeExecutableParameterTypes(injectionPoint));
+			code.add(this.parameterGenerator.generateExecutableParameterTypes(injectionPoint));
 			code.add(")\n").indent().indent();
 		}
 		attributesResolver.accept(code);
@@ -222,7 +222,7 @@ private CodeBlock write(Method injectionPoint, Consumer<Builder> attributesResol
 		return code.build();
 	}
 
-	CodeBlock writeFieldInjection(Field injectionPoint, boolean required) {
+	CodeBlock generateFieldInjection(Field injectionPoint, boolean required) {
 		Builder code = CodeBlock.builder();
 		code.add("instanceContext.field($S, $T.class", injectionPoint.getName(), injectionPoint.getType());
 		code.add(")\n").indent().indent();