Spring/spring-framework
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Harmonize use of generate

Browse Source 
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
This commit is contained in:
Stephane Nicoll
2022-03-04 10:00:57 +01:00
parent ea19b92deb
commit 97986b368a
6 changed files with 151 additions and 149 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -838,7 +838,7 @@ public class AutowiredAnnotationBeanPostProcessor implements SmartInstantiationA
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));
});
}

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

@@ -43,7 +43,7 @@ import org.springframework.lang.Nullable;
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,39 +75,39 @@ public final class 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;
@@ -115,7 +115,7 @@ public final class BeanParameterGenerator {
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 @@ public final class BeanParameterGenerator {
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 @@ public final class BeanParameterGenerator {
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 @@ public final class BeanParameterGenerator {
parameters.add(mapKey);
parameters.add(mapValue);
});
code.add(writeAll(parameters, ResolvableType::forInstance));
code.add(generateAll(parameters, ResolvableType::forInstance));
code.add(")");
}
}
@@ -175,7 +175,7 @@ public final class BeanParameterGenerator {
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 @@ public final class BeanParameterGenerator {
}
}
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(", ");
}

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

@@ -33,7 +33,7 @@ import org.springframework.javapoet.CodeBlock;
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 @@ class DefaultBeanInstantiationGenerator {
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 @@ class DefaultBeanInstantiationGenerator {
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,7 +137,7 @@ class DefaultBeanInstantiationGenerator {
() -> 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) ->");
@@ -145,13 +145,13 @@ class DefaultBeanInstantiationGenerator {
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("}"));
}
}

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

@@ -37,8 +37,8 @@ import org.springframework.util.ClassUtils;
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 class InjectionGenerator {
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 @@ public class InjectionGenerator {
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 @@ public class InjectionGenerator {
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 @@ public class InjectionGenerator {
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 @@ public class InjectionGenerator {
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();