kotlin.reflect.KFunction Java Examples

@Override
public Type getMethodReturnType(Method method) {
    final KFunction<?> kFunction = ReflectJvmMapping.getKotlinFunction(method);
    if (kFunction != null) {
        return getType(kFunction.getReturnType(), new LinkedHashMap<>());
    } else {
        // `method` might be a getter so try to find a corresponding field and pass it to Kotlin reflection
        final KClass<?> kClass = JvmClassMappingKt.getKotlinClass(method.getDeclaringClass());
        final Optional<Field> field = KClasses.getMemberProperties(kClass).stream()
                .filter(kProperty -> Objects.equals(ReflectJvmMapping.getJavaGetter(kProperty), method))
                .map(kProperty -> ReflectJvmMapping.getJavaField(kProperty))
                .filter(Objects::nonNull)
                .findFirst();
        if (field.isPresent()) {
            return getFieldType(field.get());
        }
    }
    return javaTypeParser.getMethodReturnType(method);
}
 

private void refreshMethods(List<Object> lines) {
  functions.clear();
  for (Object line : lines) {
    Method[] methods = line.getClass().getMethods();
    for (Method method : methods) {
      if (objectMethods.contains(method) || method.getName().equals("main")) {
        continue;
      }
      KFunction<?> function = ReflectJvmMapping.getKotlinFunction(method);
      if (function == null) {
        continue;
      }
      functions.add(new KotlinFunctionInfo(function));
    }
  }
}
 

/**
 * Instantiate a Kotlin class using the provided constructor.
 * @param ctor the constructor of the Kotlin class to instantiate
 * @param args the constructor arguments to apply
 * (use {@code null} for unspecified parameter if needed)
 */
public static <T> T instantiateClass(Constructor<T> ctor, Object... args)
		throws IllegalAccessException, InvocationTargetException, InstantiationException {

	KFunction<T> kotlinConstructor = ReflectJvmMapping.getKotlinFunction(ctor);
	if (kotlinConstructor == null) {
		return ctor.newInstance(args);
	}
	List<KParameter> parameters = kotlinConstructor.getParameters();
	Map<KParameter, Object> argParameters = new HashMap<>(parameters.size());
	Assert.isTrue(args.length <= parameters.size(),
			"Number of provided arguments should be less of equals than number of constructor parameters");
	for (int i = 0 ; i < args.length ; i++) {
		if (!(parameters.get(i).isOptional() && args[i] == null)) {
			argParameters.put(parameters.get(i), args[i]);
		}
	}
	return kotlinConstructor.callBy(argParameters);
}
 

/**
 * Retrieve the Java constructor corresponding to the Kotlin primary constructor, if any.
 * @param clazz the {@link Class} of the Kotlin class
 * @see <a href="http://kotlinlang.org/docs/reference/classes.html#constructors">
 * http://kotlinlang.org/docs/reference/classes.html#constructors</a>
 */
@Nullable
public static <T> Constructor<T> findPrimaryConstructor(Class<T> clazz) {
	try {
		KFunction<T> primaryCtor = KClasses.getPrimaryConstructor(JvmClassMappingKt.getKotlinClass(clazz));
		if (primaryCtor == null) {
			return null;
		}
		Constructor<T> constructor = ReflectJvmMapping.getJavaConstructor(primaryCtor);
		if (constructor == null) {
			throw new IllegalStateException(
					"Failed to find Java constructor for Kotlin primary constructor: " + clazz.getName());
		}
		return constructor;
	}
	catch (UnsupportedOperationException ex) {
		return null;
	}
}
 

/**
 * Retrieve the Java constructor corresponding to the Kotlin primary constructor, if any.
 * @param clazz the {@link Class} of the Kotlin class
 * @see <a href="https://kotlinlang.org/docs/reference/classes.html#constructors">
 * https://kotlinlang.org/docs/reference/classes.html#constructors</a>
 */
@Nullable
public static <T> Constructor<T> findPrimaryConstructor(Class<T> clazz) {
	try {
		KFunction<T> primaryCtor = KClasses.getPrimaryConstructor(JvmClassMappingKt.getKotlinClass(clazz));
		if (primaryCtor == null) {
			return null;
		}
		Constructor<T> constructor = ReflectJvmMapping.getJavaConstructor(primaryCtor);
		if (constructor == null) {
			throw new IllegalStateException(
					"Failed to find Java constructor for Kotlin primary constructor: " + clazz.getName());
		}
		return constructor;
	}
	catch (UnsupportedOperationException ex) {
		return null;
	}
}
 

/**
 * Instantiate a Kotlin class using the provided constructor.
 * @param ctor the constructor of the Kotlin class to instantiate
 * @param args the constructor arguments to apply
 * (use {@code null} for unspecified parameter if needed)
 */
public static <T> T instantiateClass(Constructor<T> ctor, Object... args)
		throws IllegalAccessException, InvocationTargetException, InstantiationException {

	KFunction<T> kotlinConstructor = ReflectJvmMapping.getKotlinFunction(ctor);
	if (kotlinConstructor == null) {
		return ctor.newInstance(args);
	}
	List<KParameter> parameters = kotlinConstructor.getParameters();
	Map<KParameter, Object> argParameters = new HashMap<>(parameters.size());
	Assert.isTrue(args.length <= parameters.size(),
			"Number of provided arguments should be less of equals than number of constructor parameters");
	for (int i = 0 ; i < args.length ; i++) {
		if (!(parameters.get(i).isOptional() && args[i] == null)) {
			argParameters.put(parameters.get(i), args[i]);
		}
	}
	return kotlinConstructor.callBy(argParameters);
}
 

private List<Type> getKFunctionParameterTypes(Executable executable, KFunction<?> kFunction) {
    if (kFunction != null) {
        final List<KParameter> kParameters = kFunction.getParameters().stream()
                .filter(kParameter -> kParameter.getKind() == KParameter.Kind.VALUE)
                .collect(Collectors.toList());
        return getTypes(
                kParameters.stream()
                        .map(parameter -> parameter.getType())
                        .collect(Collectors.toList()),
                new LinkedHashMap<>()
        );
    }
    return javaTypeParser.getExecutableParameterTypes(executable);
}
 

static private boolean isSuspend(@Nullable Method method) {
	if (method == null) {
		return false;
	}
	KFunction<?> function = ReflectJvmMapping.getKotlinFunction(method);
	return (function != null && function.isSuspend());
}
 

@Override
@Nullable
public String[] getParameterNames(Constructor<?> ctor) {
	if (ctor.getDeclaringClass().isEnum() || !KotlinDetector.isKotlinType(ctor.getDeclaringClass())) {
		return null;
	}

	try {
		KFunction<?> function = ReflectJvmMapping.getKotlinFunction(ctor);
		return (function != null ? getParameterNames(function.getParameters()) : null);
	}
	catch (UnsupportedOperationException ex) {
		return null;
	}
}
 

@Override
@Nullable
public String[] getParameterNames(Method method) {
	if (!KotlinDetector.isKotlinType(method.getDeclaringClass())) {
		return null;
	}

	try {
		KFunction<?> function = ReflectJvmMapping.getKotlinFunction(method);
		return (function != null ? getParameterNames(function.getParameters()) : null);
	}
	catch (UnsupportedOperationException ex) {
		return null;
	}
}
 

@Override
@Nullable
public String[] getParameterNames(Constructor<?> ctor) {
	if (ctor.getDeclaringClass().isEnum() || !KotlinDetector.isKotlinType(ctor.getDeclaringClass())) {
		return null;
	}

	try {
		KFunction<?> function = ReflectJvmMapping.getKotlinFunction(ctor);
		return (function != null ? getParameterNames(function.getParameters()) : null);
	}
	catch (UnsupportedOperationException ex) {
		return null;
	}
}
 

@Override
@Nullable
public String[] getParameterNames(Method method) {
	if (!KotlinDetector.isKotlinType(method.getDeclaringClass())) {
		return null;
	}

	try {
		KFunction<?> function = ReflectJvmMapping.getKotlinFunction(method);
		return (function != null ? getParameterNames(function.getParameters()) : null);
	}
	catch (UnsupportedOperationException ex) {
		return null;
	}
}
 

/**
 * Return the return type of the method, with support of suspending
 * functions via Kotlin reflection.
 */
static private Class<?> getReturnType(Method method) {
	KFunction<?> function = ReflectJvmMapping.getKotlinFunction(method);
	if (function != null && function.isSuspend()) {
		Type paramType = ReflectJvmMapping.getJavaType(function.getReturnType());
		Class<?> paramClass = ResolvableType.forType(paramType).resolve();
		Assert.notNull(paramClass, "Type " + paramType + "can't be resolved to a class");
		return paramClass;
	}
	return method.getReturnType();
}
 

/**
 * Return the generic return type of the method, with support of suspending
 * functions via Kotlin reflection.
 */
static private Type getGenericReturnType(Method method) {
	KFunction<?> function = ReflectJvmMapping.getKotlinFunction(method);
	if (function != null && function.isSuspend()) {
		return ReflectJvmMapping.getJavaType(function.getReturnType());
	}
	return method.getGenericReturnType();
}
 

public static String functionSignature(KFunction<?> function) {
  return function.toString().replaceAll("Line_\\d+\\.", "");
}
 

public KotlinFunctionInfo(KFunction<?> function) {
  this.function = function;
}
 

public KFunction<?> getFunction() {
  return function;
}
 

@Override
public List<Type> getMethodParameterTypes(Method method) {
    final KFunction<?> kFunction = ReflectJvmMapping.getKotlinFunction(method);
    return getKFunctionParameterTypes(method, kFunction);
}
 

@Override
public List<Type> getConstructorParameterTypes(Constructor<?> constructor) {
    final KFunction<?> kFunction = ReflectJvmMapping.getKotlinFunction(constructor);
    return getKFunctionParameterTypes(constructor, kFunction);
}
 

static private boolean isSuspend(Method method) {
	KFunction<?> function = ReflectJvmMapping.getKotlinFunction(method);
	return function != null && function.isSuspend();
}