/**
 * Return a {@link ResolvableType} for the specified {@link Field} with a given
 * implementation.
 * <p>Use this variant when the class that declares the field includes generic
 * parameter variables that are satisfied by the implementation type.
 * @param field the source field
 * @param implementationType the implementation type
 * @return a {@link ResolvableType} for the specified field
 * @see #forField(Field)
 */
public static ResolvableType forField(Field field, @Nullable ResolvableType implementationType) {
	Assert.notNull(field, "Field must not be null");
	ResolvableType owner = (implementationType != null ? implementationType : NONE);
	owner = owner.as(field.getDeclaringClass());
	return forType(null, new FieldTypeProvider(field), owner.asVariableResolver());
}
 

/**
 * Return a {@link ResolvableType} for the specified {@link Field} with a given
 * implementation.
 * <p>Use this variant when the class that declares the field includes generic
 * parameter variables that are satisfied by the implementation type.
 * @param field the source field
 * @param implementationType the implementation type
 * @return a {@link ResolvableType} for the specified field
 * @see #forField(Field)
 */
public static ResolvableType forField(Field field, @Nullable ResolvableType implementationType) {
	Assert.notNull(field, "Field must not be null");
	ResolvableType owner = (implementationType != null ? implementationType : NONE);
	owner = owner.as(field.getDeclaringClass());
	return forType(null, new FieldTypeProvider(field), owner.asVariableResolver());
}
 

/**
 * Return a {@link ResolvableType} for the specified {@link Field} with a given
 * implementation.
 * <p>Use this variant when the class that declares the field includes generic
 * parameter variables that are satisfied by the implementation type.
 * @param field the source field
 * @param implementationType the implementation type
 * @return a {@link ResolvableType} for the specified field
 * @see #forField(Field)
 */
public static ResolvableType forField(Field field, ResolvableType implementationType) {
	Assert.notNull(field, "Field must not be null");
	ResolvableType owner = (implementationType != null ? implementationType : NONE);
	owner = owner.as(field.getDeclaringClass());
	return forType(null, new FieldTypeProvider(field), owner.asVariableResolver());
}
 

/**
 * Return a {@link ResolvableType} for the specified {@link Field} with a given
 * implementation.
 * <p>Use this variant when the class that declares the field includes generic
 * parameter variables that are satisfied by the implementation type.
 * @param field the source field
 * @param implementationType the implementation type
 * @return a {@link ResolvableType} for the specified field
 * @see #forField(Field)
 */
public static ResolvableType forField(Field field, ResolvableType implementationType) {
	Assert.notNull(field, "Field must not be null");
	implementationType = (implementationType == null ? NONE : implementationType);
	ResolvableType owner = implementationType.as(field.getDeclaringClass());
	return forType(null, new FieldTypeProvider(field), owner.asVariableResolver());
}
 

/**
 * Return a {@link ResolvableType} for the specified {@link Field}.
 * @param field the source field
 * @return a {@link ResolvableType} for the specified field
 * @see #forField(Field, Class)
 */
public static ResolvableType forField(Field field) {
	Assert.notNull(field, "Field must not be null");
	return forType(null, new FieldTypeProvider(field), null);
}
 

/**
 * Return a {@link ResolvableType} for the specified {@link Field} with a given
 * implementation.
 * <p>Use this variant when the class that declares the field includes generic
 * parameter variables that are satisfied by the implementation class.
 * @param field the source field
 * @param implementationClass the implementation class
 * @return a {@link ResolvableType} for the specified field
 * @see #forField(Field)
 */
public static ResolvableType forField(Field field, Class<?> implementationClass) {
	Assert.notNull(field, "Field must not be null");
	ResolvableType owner = forType(implementationClass).as(field.getDeclaringClass());
	return forType(null, new FieldTypeProvider(field), owner.asVariableResolver());
}
 

/**
 * Return a {@link ResolvableType} for the specified {@link Field} with the
 * given nesting level.
 * @param field the source field
 * @param nestingLevel the nesting level (1 for the outer level; 2 for a nested
 * generic type; etc)
 * @see #forField(Field)
 */
public static ResolvableType forField(Field field, int nestingLevel) {
	Assert.notNull(field, "Field must not be null");
	return forType(null, new FieldTypeProvider(field), null).getNested(nestingLevel);
}
 

/**
 * Return a {@link ResolvableType} for the specified {@link Field} with a given
 * implementation and the given nesting level.
 * <p>Use this variant when the class that declares the field includes generic
 * parameter variables that are satisfied by the implementation class.
 * @param field the source field
 * @param nestingLevel the nesting level (1 for the outer level; 2 for a nested
 * generic type; etc)
 * @param implementationClass the implementation class
 * @return a {@link ResolvableType} for the specified field
 * @see #forField(Field)
 */
public static ResolvableType forField(Field field, int nestingLevel, @Nullable Class<?> implementationClass) {
	Assert.notNull(field, "Field must not be null");
	ResolvableType owner = forType(implementationClass).as(field.getDeclaringClass());
	return forType(null, new FieldTypeProvider(field), owner.asVariableResolver()).getNested(nestingLevel);
}
 

/**
 * Return a {@link ResolvableType} for the specified {@link Field}.
 * @param field the source field
 * @return a {@link ResolvableType} for the specified field
 * @see #forField(Field, Class)
 */
public static ResolvableType forField(Field field) {
	Assert.notNull(field, "Field must not be null");
	return forType(null, new FieldTypeProvider(field), null);
}
 

/**
 * Return a {@link ResolvableType} for the specified {@link Field} with a given
 * implementation.
 * <p>Use this variant when the class that declares the field includes generic
 * parameter variables that are satisfied by the implementation class.
 * @param field the source field
 * @param implementationClass the implementation class
 * @return a {@link ResolvableType} for the specified field
 * @see #forField(Field)
 */
public static ResolvableType forField(Field field, Class<?> implementationClass) {
	Assert.notNull(field, "Field must not be null");
	ResolvableType owner = forType(implementationClass).as(field.getDeclaringClass());
	return forType(null, new FieldTypeProvider(field), owner.asVariableResolver());
}
 

/**
 * Return a {@link ResolvableType} for the specified {@link Field} with the
 * given nesting level.
 * @param field the source field
 * @param nestingLevel the nesting level (1 for the outer level; 2 for a nested
 * generic type; etc)
 * @see #forField(Field)
 */
public static ResolvableType forField(Field field, int nestingLevel) {
	Assert.notNull(field, "Field must not be null");
	return forType(null, new FieldTypeProvider(field), null).getNested(nestingLevel);
}
 

/**
 * Return a {@link ResolvableType} for the specified {@link Field} with a given
 * implementation and the given nesting level.
 * <p>Use this variant when the class that declares the field includes generic
 * parameter variables that are satisfied by the implementation class.
 * @param field the source field
 * @param nestingLevel the nesting level (1 for the outer level; 2 for a nested
 * generic type; etc)
 * @param implementationClass the implementation class
 * @return a {@link ResolvableType} for the specified field
 * @see #forField(Field)
 */
public static ResolvableType forField(Field field, int nestingLevel, @Nullable Class<?> implementationClass) {
	Assert.notNull(field, "Field must not be null");
	ResolvableType owner = forType(implementationClass).as(field.getDeclaringClass());
	return forType(null, new FieldTypeProvider(field), owner.asVariableResolver()).getNested(nestingLevel);
}
 

/**
 * Return a {@link ResolvableType} for the specified {@link Field}.
 * @param field the source field
 * @return a {@link ResolvableType} for the specified field
 * @see #forField(Field, Class)
 */
public static ResolvableType forField(Field field) {
	Assert.notNull(field, "Field must not be null");
	return forType(null, new FieldTypeProvider(field), null);
}
 

/**
 * Return a {@link ResolvableType} for the specified {@link Field} with a given
 * implementation.
 * <p>Use this variant when the class that declares the field includes generic
 * parameter variables that are satisfied by the implementation class.
 * @param field the source field
 * @param implementationClass the implementation class
 * @return a {@link ResolvableType} for the specified field
 * @see #forField(Field)
 */
public static ResolvableType forField(Field field, Class<?> implementationClass) {
	Assert.notNull(field, "Field must not be null");
	ResolvableType owner = forType(implementationClass).as(field.getDeclaringClass());
	return forType(null, new FieldTypeProvider(field), owner.asVariableResolver());
}
 

/**
 * Return a {@link ResolvableType} for the specified {@link Field} with the
 * given nesting level.
 * @param field the source field
 * @param nestingLevel the nesting level (1 for the outer level; 2 for a nested
 * generic type; etc)
 * @see #forField(Field)
 */
public static ResolvableType forField(Field field, int nestingLevel) {
	Assert.notNull(field, "Field must not be null");
	return forType(null, new FieldTypeProvider(field), null).getNested(nestingLevel);
}
 

/**
 * Return a {@link ResolvableType} for the specified {@link Field} with a given
 * implementation and the given nesting level.
 * <p>Use this variant when the class that declares the field includes generic
 * parameter variables that are satisfied by the implementation class.
 * @param field the source field
 * @param nestingLevel the nesting level (1 for the outer level; 2 for a nested
 * generic type; etc)
 * @param implementationClass the implementation class
 * @return a {@link ResolvableType} for the specified field
 * @see #forField(Field)
 */
public static ResolvableType forField(Field field, int nestingLevel, Class<?> implementationClass) {
	Assert.notNull(field, "Field must not be null");
	ResolvableType owner = forType(implementationClass).as(field.getDeclaringClass());
	return forType(null, new FieldTypeProvider(field), owner.asVariableResolver()).getNested(nestingLevel);
}
 

/**
 * Return a {@link ResolvableType} for the specified {@link Field}.
 * @param field the source field
 * @return a {@link ResolvableType} for the specified field
 * @see #forField(Field, Class)
 */
public static ResolvableType forField(Field field) {
	Assert.notNull(field, "Field must not be null");
	return forType(null, new FieldTypeProvider(field), null);
}
 

/**
 * Return a {@link ResolvableType} for the specified {@link Field} with a given
 * implementation.
 * <p>Use this variant when the class that declares the field includes generic
 * parameter variables that are satisfied by the implementation class.
 * @param field the source field
 * @param implementationClass the implementation class
 * @return a {@link ResolvableType} for the specified field
 * @see #forField(Field)
 */
public static ResolvableType forField(Field field, Class<?> implementationClass) {
	Assert.notNull(field, "Field must not be null");
	ResolvableType owner = forType(implementationClass).as(field.getDeclaringClass());
	return forType(null, new FieldTypeProvider(field), owner.asVariableResolver());
}
 

/**
 * Return a {@link ResolvableType} for the specified {@link Field} with the
 * given nesting level.
 * @param field the source field
 * @param nestingLevel the nesting level (1 for the outer level; 2 for a nested
 * generic type; etc)
 * @see #forField(Field)
 */
public static ResolvableType forField(Field field, int nestingLevel) {
	Assert.notNull(field, "Field must not be null");
	return forType(null, new FieldTypeProvider(field), null).getNested(nestingLevel);
}
 

/**
 * Return a {@link ResolvableType} for the specified {@link Field} with a given
 * implementation and the given nesting level.
 * <p>Use this variant when the class that declares the field includes generic
 * parameter variables that are satisfied by the implementation class.
 * @param field the source field
 * @param nestingLevel the nesting level (1 for the outer level; 2 for a nested
 * generic type; etc)
 * @param implementationClass the implementation class
 * @return a {@link ResolvableType} for the specified field
 * @see #forField(Field)
 */
public static ResolvableType forField(Field field, int nestingLevel, Class<?> implementationClass) {
	Assert.notNull(field, "Field must not be null");
	ResolvableType owner = forType(implementationClass).as(field.getDeclaringClass());
	return forType(null, new FieldTypeProvider(field), owner.asVariableResolver()).getNested(nestingLevel);
}