nashorn/src/jdk/internal/dynalink/beans/StaticClassLinker.java
changeset 18841 9bbc4b8832b2
parent 17247 607f6372b21b
child 18876 ada98218aaae
equal deleted inserted replaced
18840:3e7bff1b7b59 18841:9bbc4b8832b2
    85 
    85 
    86 import java.lang.invoke.MethodHandle;
    86 import java.lang.invoke.MethodHandle;
    87 import java.lang.invoke.MethodHandles;
    87 import java.lang.invoke.MethodHandles;
    88 import java.lang.invoke.MethodType;
    88 import java.lang.invoke.MethodType;
    89 import java.lang.reflect.Array;
    89 import java.lang.reflect.Array;
    90 import java.lang.reflect.Constructor;
    90 import java.util.Arrays;
    91 import java.util.ArrayList;
       
    92 import java.util.List;
       
    93 import jdk.internal.dynalink.CallSiteDescriptor;
    91 import jdk.internal.dynalink.CallSiteDescriptor;
    94 import jdk.internal.dynalink.beans.GuardedInvocationComponent.ValidationType;
    92 import jdk.internal.dynalink.beans.GuardedInvocationComponent.ValidationType;
    95 import jdk.internal.dynalink.linker.GuardedInvocation;
    93 import jdk.internal.dynalink.linker.GuardedInvocation;
    96 import jdk.internal.dynalink.linker.GuardingDynamicLinker;
    94 import jdk.internal.dynalink.linker.GuardingDynamicLinker;
    97 import jdk.internal.dynalink.linker.LinkRequest;
    95 import jdk.internal.dynalink.linker.LinkRequest;
   129          * constructors, returns null.
   127          * constructors, returns null.
   130          */
   128          */
   131         private static DynamicMethod createConstructorMethod(Class<?> clazz) {
   129         private static DynamicMethod createConstructorMethod(Class<?> clazz) {
   132             if(clazz.isArray()) {
   130             if(clazz.isArray()) {
   133                 final MethodHandle boundArrayCtor = ARRAY_CTOR.bindTo(clazz.getComponentType());
   131                 final MethodHandle boundArrayCtor = ARRAY_CTOR.bindTo(clazz.getComponentType());
   134                 return new SimpleDynamicMethod(drop(boundArrayCtor.asType(boundArrayCtor.type().changeReturnType(
   132                 return new SimpleDynamicMethod(StaticClassIntrospector.editConstructorMethodHandle(
   135                         clazz))), clazz, "<init>");
   133                         boundArrayCtor.asType(boundArrayCtor.type().changeReturnType(clazz))), clazz, "<init>");
   136             }
   134             }
   137 
   135 
   138             final Constructor<?>[] ctrs = clazz.getConstructors();
   136             return createDynamicMethod(Arrays.asList(clazz.getConstructors()), clazz, "<init>");
   139             final List<MethodHandle> mhs = new ArrayList<>(ctrs.length);
       
   140             for(int i = 0; i < ctrs.length; ++i) {
       
   141                 mhs.add(drop(SafeUnreflector.unreflectConstructor(ctrs[i])));
       
   142             }
       
   143             return createDynamicMethod(mhs, clazz, "<init>");
       
   144         }
       
   145 
       
   146         private static MethodHandle drop(MethodHandle mh) {
       
   147             return StaticClassIntrospector.dropReceiver(mh, StaticClass.class);
       
   148         }
   137         }
   149 
   138 
   150         @Override
   139         @Override
   151         FacetIntrospector createFacetIntrospector() {
   140         FacetIntrospector createFacetIntrospector() {
   152             return new StaticClassIntrospector(clazz);
   141             return new StaticClassIntrospector(clazz);
   159             if(gi != null) {
   148             if(gi != null) {
   160                 return gi;
   149                 return gi;
   161             }
   150             }
   162             final CallSiteDescriptor desc = request.getCallSiteDescriptor();
   151             final CallSiteDescriptor desc = request.getCallSiteDescriptor();
   163             final String op = desc.getNameToken(CallSiteDescriptor.OPERATOR);
   152             final String op = desc.getNameToken(CallSiteDescriptor.OPERATOR);
   164             final MethodType methodType = desc.getMethodType();
       
   165             if("new" == op && constructor != null) {
   153             if("new" == op && constructor != null) {
   166                 final MethodHandle ctorInvocation = constructor.getInvocation(methodType, linkerServices);
   154                 final MethodHandle ctorInvocation = constructor.getInvocation(desc, linkerServices);
   167                 if(ctorInvocation != null) {
   155                 if(ctorInvocation != null) {
   168                     return new GuardedInvocation(ctorInvocation, getClassGuard(methodType));
   156                     return new GuardedInvocation(ctorInvocation, getClassGuard(desc.getMethodType()));
   169                 }
   157                 }
   170             }
   158             }
   171             return null;
   159             return null;
   172         }
   160         }
   173     }
   161     }