Java ResolvedJavaMethod.isBridge方法代码示例

import jdk.vm.ci.meta.ResolvedJavaMethod; //导入方法依赖的package包/类
/**
 * A helper for {@link ResolvedJavaMethod#getAnnotation(Class)} that handles the absence of
 * annotations on bridge methods where the bridged method has annotations.
 */
public static <T extends Annotation> T getAnnotation(Class<T> annotationClass, ResolvedJavaMethod method) {
    T a = method.getAnnotation(annotationClass);
    if (a == null && method.isBridge()) {
        ResolvedJavaMethod bridged = getBridgedMethod(method);
        if (bridged != null) {
            a = bridged.getAnnotation(annotationClass);
        }
    }
    return a;
}
 

import jdk.vm.ci.meta.ResolvedJavaMethod; //导入方法依赖的package包/类
/**
 * A helper for {@link ResolvedJavaMethod#getAnnotations()} that handles the absence of
 * annotations on bridge methods where the bridged method has annotations.
 */
public static Annotation[] getAnnotations(ResolvedJavaMethod method) {
    Annotation[] a = method.getAnnotations();
    if (a.length == 0 && method.isBridge()) {
        ResolvedJavaMethod bridged = getBridgedMethod(method);
        if (bridged != null) {
            a = bridged.getAnnotations();
        }
    }
    return a;
}
 

import jdk.vm.ci.meta.ResolvedJavaMethod; //导入方法依赖的package包/类
/**
 * A helper for {@link ResolvedJavaMethod#getDeclaredAnnotations()} that handles the absence of
 * annotations on bridge methods where the bridged method has annotations.
 */
public static Annotation[] getDeclaredAnnotations(ResolvedJavaMethod method) {
    Annotation[] a = method.getAnnotations();
    if (a.length == 0 && method.isBridge()) {
        ResolvedJavaMethod bridged = getBridgedMethod(method);
        if (bridged != null) {
            a = bridged.getDeclaredAnnotations();
        }
    }
    return a;
}
 

import jdk.vm.ci.meta.ResolvedJavaMethod; //导入方法依赖的package包/类
/**
 * A helper for {@link ResolvedJavaMethod#getParameterAnnotations()} that handles the absence of
 * parameter annotations on bridge methods where the bridged method has parameter annotations.
 */
public static Annotation[][] getParameterAnnotations(ResolvedJavaMethod method) {
    Annotation[][] a = method.getParameterAnnotations();
    if (a.length == 0 && method.isBridge()) {
        ResolvedJavaMethod bridged = getBridgedMethod(method);
        if (bridged != null) {
            a = bridged.getParameterAnnotations();
        }
    }
    return a;
}
 

import jdk.vm.ci.meta.ResolvedJavaMethod; //导入方法依赖的package包/类
/**
 * A helper for {@link ResolvedJavaMethod#getParameterAnnotation(Class, int)} that handles the
 * absence of parameter annotations on bridge methods where the bridged method has parameter
 * annotations.
 */
public static <T extends Annotation> T getParameterAnnotation(Class<T> annotationClass, int parameterIndex, ResolvedJavaMethod method) {
    T a = method.getParameterAnnotation(annotationClass, parameterIndex);
    if (a == null && method.isBridge()) {
        ResolvedJavaMethod bridged = getBridgedMethod(method);
        if (bridged != null) {
            a = bridged.getParameterAnnotation(annotationClass, parameterIndex);
        }
    }
    return a;
}
 

import jdk.vm.ci.meta.ResolvedJavaMethod; //导入方法依赖的package包/类
InvocationPlugin get(ResolvedJavaMethod method) {
    if (resolvedRegistrations != null) {
        return resolvedRegistrations.get(method);
    } else {
        if (!method.isBridge()) {
            ResolvedJavaType declaringClass = method.getDeclaringClass();
            flushDeferrables();
            String internalName = declaringClass.getName();
            ClassPlugins classPlugins = registrations.get(internalName);
            InvocationPlugin res = null;
            if (classPlugins != null) {
                res = classPlugins.get(method);
            }
            if (res == null) {
                LateClassPlugins lcp = findLateClassPlugins(internalName);
                if (lcp != null) {
                    res = lcp.get(method);
                }
            }
            if (res != null) {
                if (canBeIntrinsified(declaringClass)) {
                    return res;
                }
            }
            if (testExtensions != null) {
                // Avoid the synchronization in the common case that there
                // are no test extensions.
                synchronized (this) {
                    if (testExtensions != null) {
                        List<Binding> bindings = testExtensions.get(internalName);
                        if (bindings != null) {
                            String name = method.getName();
                            String descriptor = method.getSignature().toMethodDescriptor();
                            for (Binding b : bindings) {
                                if (b.isStatic == method.isStatic() &&
                                                b.name.equals(name) &&
                                                descriptor.startsWith(b.argumentsDescriptor)) {
                                    return b.plugin;
                                }
                            }
                        }
                    }
                }
            }
        } else {
            // Supporting plugins for bridge methods would require including
            // the return type in the registered signature. Until needed,
            // this extra complexity is best avoided.
        }
    }
    return null;
}