コード例 #1
0
        private readonly String LambdaClassName;      // Generated name for the generated class "X$$Lambda$1"

        /// <summary>
        /// General meta-factory constructor, supporting both standard cases and
        /// allowing for uncommon options such as serialization or bridging.
        /// </summary>
        /// <param name="caller"> Stacked automatically by VM; represents a lookup context
        ///               with the accessibility privileges of the caller. </param>
        /// <param name="invokedType"> Stacked automatically by VM; the signature of the
        ///                    invoked method, which includes the expected static
        ///                    type of the returned lambda object, and the static
        ///                    types of the captured arguments for the lambda.  In
        ///                    the event that the implementation method is an
        ///                    instance method, the first argument in the invocation
        ///                    signature will correspond to the receiver. </param>
        /// <param name="samMethodName"> Name of the method in the functional interface to
        ///                      which the lambda or method reference is being
        ///                      converted, represented as a String. </param>
        /// <param name="samMethodType"> Type of the method in the functional interface to
        ///                      which the lambda or method reference is being
        ///                      converted, represented as a MethodType. </param>
        /// <param name="implMethod"> The implementation method which should be called (with
        ///                   suitable adaptation of argument types, return types,
        ///                   and adjustment for captured arguments) when methods of
        ///                   the resulting functional interface instance are invoked. </param>
        /// <param name="instantiatedMethodType"> The signature of the primary functional
        ///                               interface method after type variables are
        ///                               substituted with their instantiation from
        ///                               the capture site </param>
        /// <param name="isSerializable"> Should the lambda be made serializable?  If set,
        ///                       either the target type or one of the additional SAM
        ///                       types must extend {@code Serializable}. </param>
        /// <param name="markerInterfaces"> Additional interfaces which the lambda object
        ///                       should implement. </param>
        /// <param name="additionalBridges"> Method types for additional signatures to be
        ///                          bridged to the implementation method </param>
        /// <exception cref="LambdaConversionException"> If any of the meta-factory protocol
        /// invariants are violated </exception>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public InnerClassLambdaMetafactory(MethodHandles.Lookup caller, MethodType invokedType, String samMethodName, MethodType samMethodType, MethodHandle implMethod, MethodType instantiatedMethodType, boolean isSerializable, Class[] markerInterfaces, MethodType[] additionalBridges) throws LambdaConversionException
        public InnerClassLambdaMetafactory(MethodHandles.Lookup caller, MethodType invokedType, String samMethodName, MethodType samMethodType, MethodHandle implMethod, MethodType instantiatedMethodType, bool isSerializable, Class[] markerInterfaces, MethodType[] additionalBridges) : base(caller, invokedType, samMethodName, samMethodType, implMethod, instantiatedMethodType, isSerializable, markerInterfaces, additionalBridges)
        {
            ImplMethodClassName   = ImplDefiningClass.Name.Replace('.', '/');
            ImplMethodName        = ImplInfo.Name;
            ImplMethodDesc        = ImplMethodType.ToMethodDescriptorString();
            ImplMethodReturnClass = (ImplKind == MethodHandleInfo.REF_newInvokeSpecial) ? ImplDefiningClass : ImplMethodType.ReturnType();
            ConstructorType       = invokedType.ChangeReturnType(Void.TYPE);
            LambdaClassName       = TargetClass.Name.Replace('.', '/') + "$$Lambda$" + Counter.IncrementAndGet();
            Cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
            int parameterCount = invokedType.ParameterCount();

            if (parameterCount > 0)
            {
                ArgNames = new String[parameterCount];
                ArgDescs = new String[parameterCount];
                for (int i = 0; i < parameterCount; i++)
                {
                    ArgNames[i] = "arg$" + (i + 1);
                    ArgDescs[i] = BytecodeDescriptor.unparse(invokedType.ParameterType(i));
                }
            }
            else
            {
                ArgNames = ArgDescs = EMPTY_STRING_ARRAY;
            }
        }
コード例 #2
0
        internal virtual LambdaForm CollectArgumentsForm(int pos, MethodType collectorType)
        {
            int  collectorArity = collectorType.ParameterCount();
            bool dropResult     = (collectorType.ReturnType() == typeof(void));

            if (collectorArity == 1 && !dropResult)
            {
                return(FilterArgumentForm(pos, basicType(collectorType.ParameterType(0))));
            }
            BasicType[]    newTypes = BasicType.basicTypes(collectorType.ParameterList());
            Transform.Kind kind     = (dropResult ? Transform.Kind.COLLECT_ARGS_TO_VOID : Transform.Kind.COLLECT_ARGS);
            if (dropResult && collectorArity == 0)             // pure side effect
            {
                pos = 1;
            }
            Transform  key  = Transform.Of(kind, pos, collectorArity, BasicType.basicTypesOrd(newTypes));
            LambdaForm form = GetInCache(key);

            if (form != null)
            {
                assert(form.Arity_Renamed == LambdaForm.Arity_Renamed - (dropResult ? 0 : 1) + collectorArity);
                return(form);
            }
            form = MakeArgumentCombinationForm(pos, collectorType, false, dropResult);
            return(PutInCache(key, form));
        }
コード例 #3
0
        /// <summary>
        /// Create a LF which simply reinvokes a target of the given basic type. </summary>
        internal static LambdaForm MakeReinvokerForm(MethodHandle target, int whichCache, Object constraint, String debugString, bool forceInline, NamedFunction getTargetFn, NamedFunction preActionFn)
        {
            MethodType mtype        = target.Type().BasicType();
            bool       customized   = (whichCache <0 || mtype.ParameterSlotCount()> MethodType.MAX_MH_INVOKER_ARITY);
            bool       hasPreAction = (preActionFn != null);
            LambdaForm form;

            if (!customized)
            {
                form = mtype.Form().CachedLambdaForm(whichCache);
                if (form != null)
                {
                    return(form);
                }
            }
            const int THIS_DMH = 0;
            const int ARG_BASE = 1;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int ARG_LIMIT = ARG_BASE + mtype.parameterCount();
            int ARG_LIMIT  = ARG_BASE + mtype.ParameterCount();
            int nameCursor = ARG_LIMIT;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int PRE_ACTION = hasPreAction ? nameCursor++ : -1;
            int PRE_ACTION = hasPreAction ? nameCursor++: -1;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int NEXT_MH = customized ? -1 : nameCursor++;
            int NEXT_MH = customized ? -1 : nameCursor++;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int REINVOKE = nameCursor++;
            int REINVOKE = nameCursor++;

            LambdaForm.Name[] names = LambdaForm.Arguments(nameCursor - ARG_LIMIT, mtype.InvokerType());
            assert(names.Length == nameCursor);
            names[THIS_DMH] = names[THIS_DMH].WithConstraint(constraint);
            Object[] targetArgs;
            if (hasPreAction)
            {
                names[PRE_ACTION] = new LambdaForm.Name(preActionFn, names[THIS_DMH]);
            }
            if (customized)
            {
                targetArgs      = Arrays.CopyOfRange(names, ARG_BASE, ARG_LIMIT, typeof(Object[]));
                names[REINVOKE] = new LambdaForm.Name(target, targetArgs);                 // the invoker is the target itself
            }
            else
            {
                names[NEXT_MH]  = new LambdaForm.Name(getTargetFn, names[THIS_DMH]);
                targetArgs      = Arrays.CopyOfRange(names, THIS_DMH, ARG_LIMIT, typeof(Object[]));
                targetArgs[0]   = names[NEXT_MH];               // overwrite this MH with next MH
                names[REINVOKE] = new LambdaForm.Name(mtype, targetArgs);
            }
            form = new LambdaForm(debugString, ARG_LIMIT, names, forceInline);
            if (!customized)
            {
                form = mtype.Form().SetCachedLambdaForm(whichCache, form);
            }
            return(form);
        }
コード例 #4
0
        private static MethodHandle BindCaller(MethodHandle target, Class hostClass)
        {
            MethodHandle cbmh = MethodHandleImpl.BindCaller(target, hostClass);

            if (target.VarargsCollector)
            {
                MethodType type  = cbmh.Type();
                int        arity = type.ParameterCount();
                return(cbmh.AsVarargsCollector(type.ParameterType(arity - 1)));
            }
            return(cbmh);
        }
コード例 #5
0
        internal virtual LambdaForm FoldArgumentsForm(int foldPos, bool dropResult, MethodType combinerType)
        {
            int combinerArity = combinerType.ParameterCount();

            Transform.Kind kind = (dropResult ? Transform.Kind.FOLD_ARGS_TO_VOID : Transform.Kind.FOLD_ARGS);
            Transform      key  = Transform.Of(kind, foldPos, combinerArity);
            LambdaForm     form = GetInCache(key);

            if (form != null)
            {
                assert(form.Arity_Renamed == LambdaForm.Arity_Renamed - (kind == Transform.Kind.FOLD_ARGS ? 1 : 0));
                return(form);
            }
            form = MakeArgumentCombinationForm(foldPos, combinerType, true, dropResult);
            return(PutInCache(key, form));
        }
コード例 #6
0
        private static LambdaForm MakePreparedLambdaForm(MethodType mtype, int which)
        {
            bool   needsInit = (which == LF_INVSTATIC_INIT);
            bool   doesAlloc = (which == LF_NEWINVSPECIAL);
            String linkerName, lambdaName;

            switch (which)
            {
            case LF_INVVIRTUAL:
                linkerName = "linkToVirtual";
                lambdaName = "DMH.invokeVirtual";
                break;

            case LF_INVSTATIC:
                linkerName = "linkToStatic";
                lambdaName = "DMH.invokeStatic";
                break;

            case LF_INVSTATIC_INIT:
                linkerName = "linkToStatic";
                lambdaName = "DMH.invokeStaticInit";
                break;

            case LF_INVSPECIAL:
                linkerName = "linkToSpecial";
                lambdaName = "DMH.invokeSpecial";
                break;

            case LF_INVINTERFACE:
                linkerName = "linkToInterface";
                lambdaName = "DMH.invokeInterface";
                break;

            case LF_NEWINVSPECIAL:
                linkerName = "linkToSpecial";
                lambdaName = "DMH.newInvokeSpecial";
                break;

            default:
                throw new InternalError("which=" + which);
            }
            MethodType mtypeWithArg = mtype.AppendParameterTypes(typeof(MemberName));

            if (doesAlloc)
            {
                mtypeWithArg = mtypeWithArg.InsertParameterTypes(0, typeof(Object)).ChangeReturnType(typeof(void));                 // <init> returns void -  insert newly allocated obj
            }
            MemberName linker = new MemberName(typeof(MethodHandle), linkerName, mtypeWithArg, REF_invokeStatic);

            try
            {
                linker = IMPL_NAMES.ResolveOrFail(REF_invokeStatic, linker, null, typeof(NoSuchMethodException));
            }
            catch (ReflectiveOperationException ex)
            {
                throw newInternalError(ex);
            }
            const int DMH_THIS = 0;
            const int ARG_BASE = 1;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int ARG_LIMIT = ARG_BASE + mtype.parameterCount();
            int ARG_LIMIT  = ARG_BASE + mtype.ParameterCount();
            int nameCursor = ARG_LIMIT;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int NEW_OBJ = (doesAlloc ? nameCursor++ : -1);
            int NEW_OBJ = (doesAlloc ? nameCursor++: -1);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int GET_MEMBER = nameCursor++;
            int GET_MEMBER = nameCursor++;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int LINKER_CALL = nameCursor++;
            int LINKER_CALL = nameCursor++;

            Name[] names = arguments(nameCursor - ARG_LIMIT, mtype.InvokerType());
            assert(names.Length == nameCursor);
            if (doesAlloc)
            {
                // names = { argx,y,z,... new C, init method }
                names[NEW_OBJ]    = new Name(Lazy.NF_allocateInstance, names[DMH_THIS]);
                names[GET_MEMBER] = new Name(Lazy.NF_constructorMethod, names[DMH_THIS]);
            }
            else if (needsInit)
            {
                names[GET_MEMBER] = new Name(Lazy.NF_internalMemberNameEnsureInit, names[DMH_THIS]);
            }
            else
            {
                names[GET_MEMBER] = new Name(Lazy.NF_internalMemberName, names[DMH_THIS]);
            }
            assert(FindDirectMethodHandle(names[GET_MEMBER]) == names[DMH_THIS]);
            Object[] outArgs = Arrays.CopyOfRange(names, ARG_BASE, GET_MEMBER + 1, typeof(Object[]));
            assert(outArgs[outArgs.Length - 1] == names[GET_MEMBER]);             // look, shifted args!
            int result = LAST_RESULT;

            if (doesAlloc)
            {
                assert(outArgs[outArgs.Length - 2] == names[NEW_OBJ]);                 // got to move this one
                System.Array.Copy(outArgs, 0, outArgs, 1, outArgs.Length - 2);
                outArgs[0] = names[NEW_OBJ];
                result     = NEW_OBJ;
            }
            names[LINKER_CALL] = new Name(linker, outArgs);
            lambdaName        += "_" + shortenSignature(basicTypeSignature(mtype));
            LambdaForm lform = new LambdaForm(lambdaName, ARG_LIMIT, names, result);

            // This is a tricky bit of code.  Don't send it through the LF interpreter.
            lform.CompileToBytecode();
            return(lform);
        }
コード例 #7
0
        private LambdaForm MakeArgumentCombinationForm(int pos, MethodType combinerType, bool keepArguments, bool dropResult)
        {
            LambdaFormBuffer buf = Buffer();

            buf.StartEdit();
            int combinerArity = combinerType.ParameterCount();
            int resultArity   = (dropResult ? 0 : 1);

            assert(pos <= MethodType.MAX_JVM_ARITY);
            assert(pos + resultArity + (keepArguments ? combinerArity : 0) <= LambdaForm.Arity_Renamed);
            assert(pos > 0);             // cannot filter the MH arg itself
            assert(combinerType == combinerType.BasicType());
            assert(combinerType.ReturnType() != typeof(void) || dropResult);

            BoundMethodHandle.SpeciesData oldData = OldSpeciesData();
            BoundMethodHandle.SpeciesData newData = NewSpeciesData(L_TYPE);

            // The newly created LF will run with a different BMH.
            // Switch over any pre-existing BMH field references to the new BMH class.
            Name oldBaseAddress = LambdaForm.Parameter(0);             // BMH holding the values

            buf.ReplaceFunctions(oldData.GetterFunctions(), newData.GetterFunctions(), oldBaseAddress);
            Name newBaseAddress = oldBaseAddress.withConstraint(newData);

            buf.RenameParameter(0, newBaseAddress);

            Name getCombiner = new Name(newData.GetterFunction(oldData.FieldCount()), newBaseAddress);

            Object[] combinerArgs = new Object[1 + combinerArity];
            combinerArgs[0] = getCombiner;
            Name[] newParams;
            if (keepArguments)
            {
                newParams = new Name[0];
                System.Array.Copy(LambdaForm.Names, pos + resultArity, combinerArgs, 1, combinerArity);
            }
            else
            {
                newParams = new Name[combinerArity];
                BasicType[] newTypes = basicTypes(combinerType.ParameterList());
                for (int i = 0; i < newTypes.Length; i++)
                {
                    newParams[i] = new Name(pos + i, newTypes[i]);
                }
                System.Array.Copy(newParams, 0, combinerArgs, 1, combinerArity);
            }
            Name callCombiner = new Name(combinerType, combinerArgs);

            // insert the two new expressions
            int exprPos = LambdaForm.Arity();

            buf.InsertExpression(exprPos + 0, getCombiner);
            buf.InsertExpression(exprPos + 1, callCombiner);

            // insert new arguments, if needed
            int argPos = pos + resultArity;             // skip result parameter

            foreach (Name newParam in newParams)
            {
                buf.InsertParameter(argPos++, newParam);
            }
            assert(buf.LastIndexOf(callCombiner) == exprPos + 1 + newParams.Length);
            if (!dropResult)
            {
                buf.ReplaceParameterByCopy(pos, exprPos + 1 + newParams.Length);
            }

            return(buf.EndEdit());
        }
コード例 #8
0
        internal virtual LambdaForm CollectArgumentArrayForm(int pos, MethodHandle arrayCollector)
        {
            MethodType collectorType  = arrayCollector.Type();
            int        collectorArity = collectorType.ParameterCount();

            assert(arrayCollector.IntrinsicName() == Intrinsic.NEW_ARRAY);
            Class     arrayType   = collectorType.ReturnType();
            Class     elementType = arrayType.ComponentType;
            BasicType argType     = basicType(elementType);
            int       argTypeKey  = argType.ordinal();

            if (argType.basicTypeClass() != elementType)
            {
                // return null if it requires more metadata (like String[].class)
                if (!elementType.Primitive)
                {
                    return(null);
                }
                argTypeKey = TYPE_LIMIT + Wrapper.forPrimitiveType(elementType).ordinal();
            }
            assert(collectorType.ParameterList().Equals(Collections.NCopies(collectorArity, elementType)));
            Transform.Kind kind = Transform.Kind.COLLECT_ARGS_TO_ARRAY;
            Transform      key  = Transform.Of(kind, pos, collectorArity, argTypeKey);
            LambdaForm     form = GetInCache(key);

            if (form != null)
            {
                assert(form.Arity_Renamed == LambdaForm.Arity_Renamed - 1 + collectorArity);
                return(form);
            }
            LambdaFormBuffer buf = Buffer();

            buf.StartEdit();

            assert(pos + 1 <= LambdaForm.Arity_Renamed);
            assert(pos > 0);             // cannot filter the MH arg itself

            Name[] newParams = new Name[collectorArity];
            for (int i = 0; i < collectorArity; i++)
            {
                newParams[i] = new Name(pos + i, argType);
            }
            Name callCombiner = new Name(arrayCollector, (Object[])newParams);              //...

            // insert the new expression
            int exprPos = LambdaForm.Arity();

            buf.InsertExpression(exprPos, callCombiner);

            // insert new arguments
            int argPos = pos + 1;             // skip result parameter

            foreach (Name newParam in newParams)
            {
                buf.InsertParameter(argPos++, newParam);
            }
            assert(buf.LastIndexOf(callCombiner) == exprPos + newParams.Length);
            buf.ReplaceParameterByCopy(pos, exprPos + newParams.Length);

            form = buf.EndEdit();
            return(PutInCache(key, form));
        }
コード例 #9
0
        /// <summary>
        /// Produces an instance of the given single-method interface which redirects
        /// its calls to the given method handle.
        /// <para>
        /// A single-method interface is an interface which declares a uniquely named method.
        /// When determining the uniquely named method of a single-method interface,
        /// the public {@code Object} methods ({@code toString}, {@code equals}, {@code hashCode})
        /// are disregarded.  For example, <seealso cref="java.util.Comparator"/> is a single-method interface,
        /// even though it re-declares the {@code Object.equals} method.
        /// </para>
        /// <para>
        /// The interface must be public.  No additional access checks are performed.
        /// </para>
        /// <para>
        /// The resulting instance of the required type will respond to
        /// invocation of the type's uniquely named method by calling
        /// the given target on the incoming arguments,
        /// and returning or throwing whatever the target
        /// returns or throws.  The invocation will be as if by
        /// {@code target.invoke}.
        /// The target's type will be checked before the
        /// instance is created, as if by a call to {@code asType},
        /// which may result in a {@code WrongMethodTypeException}.
        /// </para>
        /// <para>
        /// The uniquely named method is allowed to be multiply declared,
        /// with distinct type descriptors.  (E.g., it can be overloaded,
        /// or can possess bridge methods.)  All such declarations are
        /// connected directly to the target method handle.
        /// Argument and return types are adjusted by {@code asType}
        /// for each individual declaration.
        /// </para>
        /// <para>
        /// The wrapper instance will implement the requested interface
        /// and its super-types, but no other single-method interfaces.
        /// This means that the instance will not unexpectedly
        /// pass an {@code instanceof} test for any unrequested type.
        /// <p style="font-size:smaller;">
        /// <em>Implementation Note:</em>
        /// Therefore, each instance must implement a unique single-method interface.
        /// Implementations may not bundle together
        /// multiple single-method interfaces onto single implementation classes
        /// in the style of <seealso cref="java.awt.AWTEventMulticaster"/>.
        /// </para>
        /// <para>
        /// The method handle may throw an <em>undeclared exception</em>,
        /// which means any checked exception (or other checked throwable)
        /// not declared by the requested type's single abstract method.
        /// If this happens, the throwable will be wrapped in an instance of
        /// <seealso cref="java.lang.reflect.UndeclaredThrowableException UndeclaredThrowableException"/>
        /// and thrown in that wrapped form.
        /// </para>
        /// <para>
        /// Like <seealso cref="java.lang.Integer#valueOf Integer.valueOf"/>,
        /// {@code asInterfaceInstance} is a factory method whose results are defined
        /// by their behavior.
        /// It is not guaranteed to return a new instance for every call.
        /// </para>
        /// <para>
        /// Because of the possibility of <seealso cref="java.lang.reflect.Method#isBridge bridge methods"/>
        /// and other corner cases, the interface may also have several abstract methods
        /// with the same name but having distinct descriptors (types of returns and parameters).
        /// In this case, all the methods are bound in common to the one given target.
        /// The type check and effective {@code asType} conversion is applied to each
        /// method type descriptor, and all abstract methods are bound to the target in common.
        /// Beyond this type check, no further checks are made to determine that the
        /// abstract methods are related in any way.
        /// </para>
        /// <para>
        /// Future versions of this API may accept additional types,
        /// such as abstract classes with single abstract methods.
        /// Future versions of this API may also equip wrapper instances
        /// with one or more additional public "marker" interfaces.
        /// </para>
        /// <para>
        /// If a security manager is installed, this method is caller sensitive.
        /// During any invocation of the target method handle via the returned wrapper,
        /// the original creator of the wrapper (the caller) will be visible
        /// to context checks requested by the security manager.
        ///
        /// </para>
        /// </summary>
        /// @param <T> the desired type of the wrapper, a single-method interface </param>
        /// <param name="intfc"> a class object representing {@code T} </param>
        /// <param name="target"> the method handle to invoke from the wrapper </param>
        /// <returns> a correctly-typed wrapper for the given target </returns>
        /// <exception cref="NullPointerException"> if either argument is null </exception>
        /// <exception cref="IllegalArgumentException"> if the {@code intfc} is not a
        ///         valid argument to this method </exception>
        /// <exception cref="WrongMethodTypeException"> if the target cannot
        ///         be converted to the type required by the requested interface </exception>
        // Other notes to implementors:
        // <p>
        // No stable mapping is promised between the single-method interface and
        // the implementation class C.  Over time, several implementation
        // classes might be used for the same type.
        // <p>
        // If the implementation is able
        // to prove that a wrapper of the required type
        // has already been created for a given
        // method handle, or for another method handle with the
        // same behavior, the implementation may return that wrapper in place of
        // a new wrapper.
        // <p>
        // This method is designed to apply to common use cases
        // where a single method handle must interoperate with
        // an interface that implements a function-like
        // API.  Additional variations, such as single-abstract-method classes with
        // private constructors, or interfaces with multiple but related
        // entry points, must be covered by hand-written or automatically
        // generated adapter classes.
        //
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @CallerSensitive public static <T> T asInterfaceInstance(final Class intfc, final MethodHandle target)
//JAVA TO C# CONVERTER WARNING: 'final' parameters are not allowed in .NET:
        public static T asInterfaceInstance <T>(Class intfc, MethodHandle target)
        {
            if (!intfc.Interface || !Modifier.IsPublic(intfc.Modifiers))
            {
                throw newIllegalArgumentException("not a public interface", intfc.Name);
            }
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final MethodHandle mh;
            MethodHandle mh;

            if (System.SecurityManager != null)
            {
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final Class caller = sun.reflect.Reflection.getCallerClass();
                Class caller = Reflection.CallerClass;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final ClassLoader ccl = caller != null ? caller.getClassLoader() : null;
                ClassLoader ccl = caller != null ? caller.ClassLoader : null;
                ReflectUtil.checkProxyPackageAccess(ccl, intfc);
                mh = ccl != null?BindCaller(target, caller) : target;
            }
            else
            {
                mh = target;
            }
            ClassLoader proxyLoader = intfc.ClassLoader;

            if (proxyLoader == null)
            {
                ClassLoader cl = Thread.CurrentThread.ContextClassLoader;                 // avoid use of BCP
                proxyLoader = cl != null ? cl : ClassLoader.SystemClassLoader;
            }
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final Method[] methods = getSingleNameMethods(intfc);
            Method[] methods = GetSingleNameMethods(intfc);
            if (methods == null)
            {
                throw newIllegalArgumentException("not a single-method interface", intfc.Name);
            }
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final MethodHandle[] vaTargets = new MethodHandle[methods.length];
            MethodHandle[] vaTargets = new MethodHandle[methods.Length];
            for (int i = 0; i < methods.Length; i++)
            {
                Method       sm          = methods[i];
                MethodType   smMT        = MethodType.MethodType(sm.ReturnType, sm.ParameterTypes);
                MethodHandle checkTarget = mh.AsType(smMT);                 // make throw WMT
                checkTarget  = checkTarget.AsType(checkTarget.Type().ChangeReturnType(typeof(Object)));
                vaTargets[i] = checkTarget.AsSpreader(typeof(Object[]), smMT.ParameterCount());
            }
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final InvocationHandler ih = new InvocationHandler()
            InvocationHandler ih = new InvocationHandlerAnonymousInnerClassHelper(intfc, target, methods, vaTargets);

//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final Object proxy;
            Object proxy;

            if (System.SecurityManager != null)
            {
                // sun.invoke.WrapperInstance is a restricted interface not accessible
                // by any non-null class loader.
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final ClassLoader loader = proxyLoader;
                ClassLoader loader = proxyLoader;
                proxy = AccessController.doPrivileged(new PrivilegedActionAnonymousInnerClassHelper(intfc, ih, loader));
            }
            else
            {
                proxy = Proxy.NewProxyInstance(proxyLoader, new Class[] { intfc, typeof(WrapperInstance) }, ih);
            }
            return(intfc.Cast(proxy));
        }
コード例 #10
0
        /// <summary>
        /// Check the meta-factory arguments for errors </summary>
        /// <exception cref="LambdaConversionException"> if there are improper conversions </exception>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: void validateMetafactoryArgs() throws LambdaConversionException
        internal virtual void ValidateMetafactoryArgs()
        {
            switch (ImplKind)
            {
            case MethodHandleInfo.REF_invokeInterface:
            case MethodHandleInfo.REF_invokeVirtual:
            case MethodHandleInfo.REF_invokeStatic:
            case MethodHandleInfo.REF_newInvokeSpecial:
            case MethodHandleInfo.REF_invokeSpecial:
                break;

            default:
                throw new LambdaConversionException(string.Format("Unsupported MethodHandle kind: {0}", ImplInfo));
            }

            // Check arity: optional-receiver + captured + SAM == impl
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int implArity = implMethodType.parameterCount();
            int implArity = ImplMethodType.ParameterCount();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int receiverArity = implIsInstanceMethod ? 1 : 0;
            int receiverArity = ImplIsInstanceMethod ? 1 : 0;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int capturedArity = invokedType.parameterCount();
            int capturedArity = InvokedType.ParameterCount();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int samArity = samMethodType.parameterCount();
            int samArity = SamMethodType.ParameterCount();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int instantiatedArity = instantiatedMethodType.parameterCount();
            int instantiatedArity = InstantiatedMethodType.ParameterCount();

            if (implArity + receiverArity != capturedArity + samArity)
            {
                throw new LambdaConversionException(string.Format("Incorrect number of parameters for {0} method {1}; {2:D} captured parameters, {3:D} functional interface method parameters, {4:D} implementation parameters", ImplIsInstanceMethod ? "instance" : "static", ImplInfo, capturedArity, samArity, implArity));
            }
            if (instantiatedArity != samArity)
            {
                throw new LambdaConversionException(string.Format("Incorrect number of parameters for {0} method {1}; {2:D} instantiated parameters, {3:D} functional interface method parameters", ImplIsInstanceMethod ? "instance" : "static", ImplInfo, instantiatedArity, samArity));
            }
            foreach (MethodType bridgeMT in AdditionalBridges)
            {
                if (bridgeMT.ParameterCount() != samArity)
                {
                    throw new LambdaConversionException(string.Format("Incorrect number of parameters for bridge signature {0}; incompatible with {1}", bridgeMT, SamMethodType));
                }
            }

            // If instance: first captured arg (receiver) must be subtype of class where impl method is defined
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int capturedStart;
            int capturedStart;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int samStart;
            int samStart;

            if (ImplIsInstanceMethod)
            {
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final Class receiverClass;
                Class receiverClass;

                // implementation is an instance method, adjust for receiver in captured variables / SAM arguments
                if (capturedArity == 0)
                {
                    // receiver is function parameter
                    capturedStart = 0;
                    samStart      = 1;
                    receiverClass = InstantiatedMethodType.ParameterType(0);
                }
                else
                {
                    // receiver is a captured variable
                    capturedStart = 1;
                    samStart      = 0;
                    receiverClass = InvokedType.ParameterType(0);
                }

                // check receiver type
                if (!receiverClass.IsSubclassOf(ImplDefiningClass))
                {
                    throw new LambdaConversionException(string.Format("Invalid receiver type {0}; not a subtype of implementation type {1}", receiverClass, ImplDefiningClass));
                }

                Class implReceiverClass = ImplMethod.Type().ParameterType(0);
                if (implReceiverClass != ImplDefiningClass && !receiverClass.IsSubclassOf(implReceiverClass))
                {
                    throw new LambdaConversionException(string.Format("Invalid receiver type {0}; not a subtype of implementation receiver type {1}", receiverClass, implReceiverClass));
                }
            }
            else
            {
                // no receiver
                capturedStart = 0;
                samStart      = 0;
            }

            // Check for exact match on non-receiver captured arguments
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int implFromCaptured = capturedArity - capturedStart;
            int implFromCaptured = capturedArity - capturedStart;

            for (int i = 0; i < implFromCaptured; i++)
            {
                Class implParamType     = ImplMethodType.ParameterType(i);
                Class capturedParamType = InvokedType.ParameterType(i + capturedStart);
                if (!capturedParamType.Equals(implParamType))
                {
                    throw new LambdaConversionException(string.Format("Type mismatch in captured lambda parameter {0:D}: expecting {1}, found {2}", i, capturedParamType, implParamType));
                }
            }
            // Check for adaptation match on SAM arguments
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int samOffset = samStart - implFromCaptured;
            int samOffset = samStart - implFromCaptured;

            for (int i = implFromCaptured; i < implArity; i++)
            {
                Class implParamType         = ImplMethodType.ParameterType(i);
                Class instantiatedParamType = InstantiatedMethodType.ParameterType(i + samOffset);
                if (!IsAdaptableTo(instantiatedParamType, implParamType, true))
                {
                    throw new LambdaConversionException(string.Format("Type mismatch for lambda argument {0:D}: {1} is not convertible to {2}", i, instantiatedParamType, implParamType));
                }
            }

            // Adaptation match: return type
            Class expectedType     = InstantiatedMethodType.ReturnType();
            Class actualReturnType = (ImplKind == MethodHandleInfo.REF_newInvokeSpecial) ? ImplDefiningClass : ImplMethodType.ReturnType();
            Class samReturnType    = SamMethodType.ReturnType();

            if (!IsAdaptableToAsReturn(actualReturnType, expectedType))
            {
                throw new LambdaConversionException(string.Format("Type mismatch for lambda return: {0} is not convertible to {1}", actualReturnType, expectedType));
            }
            if (!IsAdaptableToAsReturnStrict(expectedType, samReturnType))
            {
                throw new LambdaConversionException(string.Format("Type mismatch for lambda expected return: {0} is not convertible to {1}", expectedType, samReturnType));
            }
            foreach (MethodType bridgeMT in AdditionalBridges)
            {
                if (!IsAdaptableToAsReturnStrict(expectedType, bridgeMT.ReturnType()))
                {
                    throw new LambdaConversionException(string.Format("Type mismatch for lambda expected return: {0} is not convertible to {1}", expectedType, bridgeMT.ReturnType()));
                }
            }
        }