root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions Packages Projects Releases Wiki Activity

Nullability refinements and related polishing

This commit is contained in:
Juergen Hoeller 2019-08-01 13:04:46 +02:00
parent 223074295d
commit 4612544505
2 changed files with 44 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
spring-core/src/main/java/org/springframework/core/MethodParameter.java
View File

@ -300,6 +300,16 @@ public class MethodParameter {
return this.nestingLevel;
}
/**
* Return a variant of this {@code MethodParameter} with the type
* for the current level set to the specified value.
* @param typeIndex the new type index
* @since 5.2
*/
public MethodParameter withTypeIndex(int typeIndex) {
return nested(this.nestingLevel, typeIndex);
}
/**
* Set the type index for the current nesting level.
* @param typeIndex the corresponding type index
@ -312,15 +322,6 @@ public class MethodParameter {
getTypeIndexesPerLevel().put(this.nestingLevel, typeIndex);
}
/**
* Return a variant of this {@code MethodParameter} with the type for the current
* level set to the specified value.
* @param typeIndex the new type index
*/
public MethodParameter withTypeIndex(int typeIndex) {
return nested(this.nestingLevel, typeIndex);
}
/**
* Return the type index for the current nesting level.
* @return the corresponding type index, or {@code null}
@ -435,22 +436,39 @@ public class MethodParameter {
return (getParameterType() == Optional.class ? nested() : this);
}
public Class<?> getContainingClass() {
Class<?> containingClass = this.containingClass;
return (containingClass != null ? containingClass : getDeclaringClass());
/**
* Return a variant of this {@code MethodParameter} which refers to the
* given containing class.
* @param containingClass a specific containing class (potentially a
* subclass of the declaring class, e.g. substituting a type variable)
* @since 5.2
* @see #getParameterType()
*/
public MethodParameter withContainingClass(@Nullable Class<?> containingClass) {
MethodParameter result = clone();
result.containingClass = containingClass;
result.parameterType = null;
return result;
}
/**
* Set a containing class to resolve the parameter type against.
*/
@Deprecated
void setContainingClass(Class<?> containingClass) {
this.containingClass = containingClass;
this.parameterType = null;
}
public MethodParameter withContainingClass(@Nullable Class<?> containingClass) {
MethodParameter result = clone();
result.containingClass = containingClass;
result.parameterType = null;
return result;
/**
* Return the containing class for this method parameter.
* @return a specific containing class (potentially a subclass of the
* declaring class), or otherwise simply the declaring class itself
* @see #getDeclaringClass()
*/
public Class<?> getContainingClass() {
Class<?> containingClass = this.containingClass;
return (containingClass != null ? containingClass : getDeclaringClass());
}
/**
@ -470,7 +488,7 @@ public class MethodParameter {
if (paramType != null) {
return paramType;
}
if (getContainingClass() != null) {
if (this.containingClass != null) {
paramType = ResolvableType.forMethodParameter(this, null, 1, null).resolve();
}
if (paramType == null) {

20
spring-core/src/main/java/org/springframework/core/annotation/AnnotationsScanner.java
View File

@ -189,20 +189,18 @@ abstract class AnnotationsScanner {
@Nullable
private static <C, R> R processClassHierarchy(C context, Class<?> source,
AnnotationsProcessor<C, R> processor,
@Nullable BiPredicate<C, Class<?>> classFilter, boolean includeInterfaces,
boolean includeEnclosing) {
AnnotationsProcessor<C, R> processor, @Nullable BiPredicate<C, Class<?>> classFilter,
boolean includeInterfaces, boolean includeEnclosing) {
int[] aggregateIndex = new int[] { 0 };
int[] aggregateIndex = new int[] {0};
return processClassHierarchy(context, aggregateIndex, source, processor,
classFilter, includeInterfaces, includeEnclosing);
}
@Nullable
private static <C, R> R processClassHierarchy(C context, int[] aggregateIndex,
Class<?> source, AnnotationsProcessor<C, R> processor,
@Nullable BiPredicate<C, Class<?>> classFilter, boolean includeInterfaces,
boolean includeEnclosing) {
private static <C, R> R processClassHierarchy(C context, int[] aggregateIndex, Class<?> source,
AnnotationsProcessor<C, R> processor, @Nullable BiPredicate<C, Class<?>> classFilter,
boolean includeInterfaces, boolean includeEnclosing) {
R result = processor.doWithAggregate(context, aggregateIndex[0]);
if (result != null) {
@ -229,8 +227,7 @@ abstract class AnnotationsScanner {
Class<?> superclass = source.getSuperclass();
if (superclass != Object.class && superclass != null) {
R superclassResult = processClassHierarchy(context, aggregateIndex,
superclass, processor, classFilter, includeInterfaces,
includeEnclosing);
superclass, processor, classFilter, includeInterfaces, includeEnclosing);
if (superclassResult != null) {
return superclassResult;
}
@ -238,8 +235,7 @@ abstract class AnnotationsScanner {
Class<?> enclosingClass = source.getEnclosingClass();
if (includeEnclosing && enclosingClass != null) {
R enclosingResult = processClassHierarchy(context, aggregateIndex,
enclosingClass, processor, classFilter, includeInterfaces,
includeEnclosing);
enclosingClass, processor, classFilter, includeInterfaces, true);
if (enclosingResult != null) {
return enclosingResult;
}