jdk8-mips64-public/nashorn: comparison src/jdk/internal/dynalink/beans/AbstractJavaLinker.java

-:3245e174fe3a
+:f8221ce53c2e
 import jdk.internal.dynalink.linker.LinkerServices;
 import jdk.internal.dynalink.support.CallSiteDescriptorFactory;
 import jdk.internal.dynalink.support.Guards;
 import jdk.internal.dynalink.support.Lookup;
 /**
 * A base class for both {@link StaticClassLinker} and {@link BeanLinker}. Deals with common aspects of property
 * exposure and method calls for both static and instance facets of a class.
 *
 * @author Attila Szegedi
 this.clazz = clazz;
 this.classGuard = classGuard;
 this.assignableGuard = assignableGuard;
 final FacetIntrospector introspector = createFacetIntrospector();
-try {
+// Add methods and properties
-// Add methods and properties
+for(Method method: introspector.getMethods()) {
-for(Method method: introspector.getMethods()) {
+final String name = method.getName();
-final String name = method.getName();
+final MethodHandle methodHandle = introspector.unreflect(method);
-final MethodHandle methodHandle = introspector.unreflect(method);
+// Add method
-// Add method
+addMember(name, methodHandle, methods);
-addMember(name, methodHandle, methods);
+// Add the method as a property getter and/or setter
-// Add the method as a property getter and/or setter
+if(name.startsWith("get") && name.length() > 3 && method.getParameterTypes().length == 0) {
-if(name.startsWith("get") && name.length() > 3 && method.getParameterTypes().length == 0) {
+// Property getter
-// Property getter
+setPropertyGetter(Introspector.decapitalize(name.substring(3)), introspector.unreflect(
-setPropertyGetter(Introspector.decapitalize(name.substring(3)), introspector.unreflect(
+getMostGenericGetter(method)), ValidationType.INSTANCE_OF);
-getMostGenericGetter(method)), ValidationType.INSTANCE_OF);
+} else if(name.startsWith("is") && name.length() > 2 && method.getParameterTypes().length == 0 &&
-} else if(name.startsWith("is") && name.length() > 2 && method.getParameterTypes().length == 0 &&
+method.getReturnType() == boolean.class) {
-method.getReturnType() == boolean.class) {
+// Boolean property getter
-// Boolean property getter
+setPropertyGetter(Introspector.decapitalize(name.substring(2)), introspector.unreflect(
-setPropertyGetter(Introspector.decapitalize(name.substring(2)), introspector.unreflect(
+getMostGenericGetter(method)), ValidationType.INSTANCE_OF);
-getMostGenericGetter(method)), ValidationType.INSTANCE_OF);
+} else if(name.startsWith("set") && name.length() > 3 && method.getParameterTypes().length == 1) {
-} else if(name.startsWith("set") && name.length() > 3 && method.getParameterTypes().length == 1) {
+// Property setter
-// Property setter
+addMember(Introspector.decapitalize(name.substring(3)), methodHandle, propertySetters);
-addMember(Introspector.decapitalize(name.substring(3)), methodHandle, propertySetters);
+}
 }
-}
+// Add field getter/setters as property getters/setters.
-// Add field getter/setters as property getters/setters.
+for(Field field: introspector.getFields()) {
-for(Field field: introspector.getFields()) {
+final String name = field.getName();
-final String name = field.getName();
+// Only add a property getter when one is not defined already as a getXxx()/isXxx() method.
-// Only add a property getter when one is not defined already as a getXxx()/isXxx() method.
+if(!propertyGetters.containsKey(name)) {
-if(!propertyGetters.containsKey(name)) {
+setPropertyGetter(name, introspector.unreflectGetter(field), ValidationType.EXACT_CLASS);
-setPropertyGetter(name, introspector.unreflectGetter(field), ValidationType.EXACT_CLASS);
+}
-}
+if(!(Modifier.isFinal(field.getModifiers()) || propertySetters.containsKey(name))) {
-if(!(Modifier.isFinal(field.getModifiers()) || propertySetters.containsKey(name))) {
+addMember(name, introspector.unreflectSetter(field), propertySetters);
-addMember(name, introspector.unreflectSetter(field), propertySetters);
+}
 }
-}
+// Add inner classes, but only those for which we don't hide a property with it
-// Add inner classes, but only those for which we don't hide a property with it
+for(Map.Entry<String, MethodHandle> innerClassSpec: introspector.getInnerClassGetters().entrySet()) {
-for(Map.Entry<String, MethodHandle> innerClassSpec: introspector.getInnerClassGetters().entrySet()) {
+final String name = innerClassSpec.getKey();
-final String name = innerClassSpec.getKey();
+if(!propertyGetters.containsKey(name)) {
-if(!propertyGetters.containsKey(name)) {
+setPropertyGetter(name, innerClassSpec.getValue(), ValidationType.EXACT_CLASS);
-setPropertyGetter(name, innerClassSpec.getValue(), ValidationType.EXACT_CLASS);
+}
-}
-}
-} finally {
-introspector.close();
 }
 }
 abstract FacetIntrospector createFacetIntrospector();
 // fold(R(MethodHandle, O, N, V), MethodHandle(O, N, V))
 final MethodHandle compositeSetter = MethodHandles.foldArguments(MethodHandles.guardWithTest(
 IS_METHOD_HANDLE_NOT_NULL, invokeHandleFolded, fallbackFolded), typedGetter);
 if(nextComponent == null) {
 return getClassGuardedInvocationComponent(compositeSetter, type);
-} else {
+}
-return nextComponent.compose(compositeSetter, getClassGuard(type), clazz,
+return nextComponent.compose(compositeSetter, getClassGuard(type), clazz, ValidationType.EXACT_CLASS);
-ValidationType.EXACT_CLASS);
-}
 }
 case 3: {
 // Must have two arguments: target object and property value
 assertParameterCount(callSiteDescriptor, 2);
 final GuardedInvocation gi = createGuardedDynamicMethodInvocation(callSiteDescriptor.getMethodType(),
 // fold(R(AnnotatedMethodHandle, T0, T1), AnnotatedMethodHandle(T0, T1))
 final MethodHandle compositeGetter = MethodHandles.foldArguments(MethodHandles.guardWithTest(
 IS_ANNOTATED_HANDLE_NOT_NULL, invokeHandleFolded, fallbackFolded), typedGetter);
 if(nextComponent == null) {
 return getClassGuardedInvocationComponent(compositeGetter, type);
-} else {
+}
-return nextComponent.compose(compositeGetter, getClassGuard(type), clazz,
+return nextComponent.compose(compositeGetter, getClassGuard(type), clazz, ValidationType.EXACT_CLASS);
-ValidationType.EXACT_CLASS);
-}
 }
 case 3: {
 // Must have exactly one argument: receiver
 assertParameterCount(callSiteDescriptor, 1);
 // Fixed name
 return Guards.isArray(0, methodType);
 }
 case NONE: {
 return null;
 }
-}
+default: {
 throw new AssertionError();
+}
+}
 }
 private static final MethodHandle IS_DYNAMIC_METHOD_NOT_NULL = Guards.asType(Guards.isNotNull(),
 MethodType.methodType(boolean.class, DynamicMethod.class));
 private static final MethodHandle DYNAMIC_METHOD_IDENTITY = MethodHandles.identity(DynamicMethod.class);
 final GuardedInvocationComponent nextComponent = getGuardedInvocationComponent(callSiteDescriptor,
 linkerServices, ops);
 if(nextComponent == null) {
 // No next component operation; just return a component for this operation.
 return getClassGuardedInvocationComponent(linkerServices.asType(getDynamicMethod, type), type);
-} else {
+}
-// What's below is basically:
-//   foldArguments(guardWithTest(isNotNull, identity, nextComponent.invocation), getter)
+// What's below is basically:
-// only with a bunch of method signature adjustments. Basically, execute method getter; if
+// foldArguments(guardWithTest(isNotNull, identity, nextComponent.invocation), getter) only with a
-// it returns a non-null DynamicMethod, use identity to return it, otherwise delegate to
+// bunch of method signature adjustments. Basically, execute method getter; if it returns a non-null
-// nextComponent's invocation.
+// DynamicMethod, use identity to return it, otherwise delegate to nextComponent's invocation.
 final MethodHandle typedGetter = linkerServices.asType(getDynamicMethod, type.changeReturnType(
 DynamicMethod.class));
 // Since it is part of the foldArgument() target, it will have extra args that we need to drop.
 final MethodHandle returnMethodHandle = linkerServices.asType(MethodHandles.dropArguments(
 DYNAMIC_METHOD_IDENTITY, 1, type.parameterList()), type.insertParameterTypes(0,
 DynamicMethod.class));
 final MethodHandle nextComponentInvocation = nextComponent.getGuardedInvocation().getInvocation();
 // The assumption is that getGuardedInvocationComponent() already asType()'d it correctly
 assert nextComponentInvocation.type().equals(type);
 // Since it is part of the foldArgument() target, we have to drop an extra arg it receives.
 final MethodHandle nextCombinedInvocation = MethodHandles.dropArguments(nextComponentInvocation, 0,
 DynamicMethod.class);
 // Assemble it all into a fold(guard(isNotNull, identity, nextInvocation), get)
 final MethodHandle compositeGetter = MethodHandles.foldArguments(MethodHandles.guardWithTest(
 IS_DYNAMIC_METHOD_NOT_NULL, returnMethodHandle, nextCombinedInvocation), typedGetter);
-return nextComponent.compose(compositeGetter, getClassGuard(type), clazz,
+return nextComponent.compose(compositeGetter, getClassGuard(type), clazz, ValidationType.EXACT_CLASS);
-ValidationType.EXACT_CLASS);
-}
 }
 case 3: {
 // Must have exactly one argument: receiver
 assertParameterCount(callSiteDescriptor, 1);
 final DynamicMethod method = getDynamicMethod(callSiteDescriptor.getNameToken(
 *
 * @param name name of the method
 * @return the dynamic method (either {@link SimpleDynamicMethod} or {@link OverloadedDynamicMethod}, or null if the
 * method with the specified name does not exist.
 */
-public DynamicMethod getDynamicMethod(String name) {
+DynamicMethod getDynamicMethod(String name) {
 return getDynamicMethod(name, methods);
 }
 /**
 * Find the most generic superclass that declares this getter. Since getters have zero args (aside from the

Mercurial > jdk8-mips64-public > nashorn / file comparison

comparison: src/jdk/internal/dynalink/beans/AbstractJavaLinker.java

src/jdk/internal/dynalink/beans/AbstractJavaLinker.java