internal static Delegate CreateVoidAdapter(MethodType type) { DynamicMethodBuilder dm = new DynamicMethodBuilder("VoidAdapter", type.changeReturnType(java.lang.Void.TYPE), null, null, null, null, true); Type targetDelegateType = GetMemberWrapperDelegateType(type); dm.Ldarg(0); dm.EmitCheckcast(CoreClasses.java.lang.invoke.MethodHandle.Wrapper); dm.ilgen.Emit(OpCodes.Ldfld, typeof(MethodHandle).GetField("form", BindingFlags.Instance | BindingFlags.NonPublic)); dm.ilgen.Emit(OpCodes.Ldfld, typeof(LambdaForm).GetField("vmentry", BindingFlags.Instance | BindingFlags.NonPublic)); dm.ilgen.Emit(OpCodes.Ldfld, typeof(MemberName).GetField("vmtarget", BindingFlags.Instance | BindingFlags.NonPublic)); dm.ilgen.Emit(OpCodes.Castclass, targetDelegateType); for (int i = 0; i < type.parameterCount(); i++) { dm.Ldarg(i); } dm.CallDelegate(targetDelegateType); dm.ilgen.Emit(OpCodes.Pop); dm.Ret(); return(dm.CreateDelegate()); }
private static void ResolveMethod(MemberName self, JlClass caller) { bool invokeSpecial = self.getReferenceKind() == MethodHandleNatives.Constants.REF_invokeSpecial; bool newInvokeSpecial = self.getReferenceKind() == MethodHandleNatives.Constants.REF_newInvokeSpecial; bool searchBaseClasses = !newInvokeSpecial; MethodWrapper mw = TypeWrapper.FromClass(self.getDeclaringClass()).GetMethodWrapper(self.getName(), self.getSignature().Replace('/', '.'), searchBaseClasses); if (mw == null) { if (self.getReferenceKind() == MethodHandleNatives.Constants.REF_invokeInterface) { mw = TypeWrapper.FromClass(self.getDeclaringClass()).GetInterfaceMethod(self.getName(), self.getSignature().Replace('/', '.')); if (mw == null) { mw = CoreClasses.java.lang.Object.Wrapper.GetMethodWrapper(self.getName(), self.getSignature().Replace('/', '.'), false); } if (mw != null && mw.IsConstructor) { throw new java.lang.IncompatibleClassChangeError("Found interface " + self.getDeclaringClass().getName() + ", but class was expected"); } } if (mw == null) { string msg = String.Format(invokeSpecial ? "{0}: method {1}{2} not found" : "{0}.{1}{2}", self.getDeclaringClass().getName(), self.getName(), self.getSignature()); throw new java.lang.NoSuchMethodError(msg); } } if (mw.IsStatic != IsReferenceKindStatic(self.getReferenceKind())) { string msg = String.Format(mw.IsStatic ? "Expecting non-static method {0}.{1}{2}" : "Expected static method {0}.{1}{2}", mw.DeclaringType.Name, self.getName(), self.getSignature()); throw new java.lang.IncompatibleClassChangeError(msg); } if (self.getReferenceKind() == MethodHandleNatives.Constants.REF_invokeVirtual && mw.DeclaringType.IsInterface) { throw new java.lang.IncompatibleClassChangeError("Found interface " + mw.DeclaringType.Name + ", but class was expected"); } if (!mw.IsPublic && self.getReferenceKind() == MethodHandleNatives.Constants.REF_invokeInterface) { throw new java.lang.IncompatibleClassChangeError("private interface method requires invokespecial, not invokeinterface: method " + self.getDeclaringClass().getName() + "." + self.getName() + self.getSignature()); } if (mw.IsConstructor && mw.DeclaringType == CoreClasses.java.lang.String.Wrapper) { self.vmtarget = CreateMemberNameDelegate(mw, caller, false, self.getMethodType().changeReturnType(CoreClasses.java.lang.String.Wrapper.ClassObject)); } else if (!mw.IsConstructor || invokeSpecial || newInvokeSpecial) { MethodType methodType = self.getMethodType(); if (!mw.IsStatic) { methodType = methodType.insertParameterTypes(0, mw.DeclaringType.ClassObject); if (newInvokeSpecial) { methodType = methodType.changeReturnType(java.lang.Void.TYPE); } } self.vmtarget = CreateMemberNameDelegate(mw, caller, self.hasReceiverTypeDispatch(), methodType); } SetModifiers(self, mw); self._flags(self._flags() | (mw.IsConstructor ? MethodHandleNatives.Constants.MN_IS_CONSTRUCTOR : MethodHandleNatives.Constants.MN_IS_METHOD)); if (self.getReferenceKind() == MethodHandleNatives.Constants.REF_invokeVirtual && (mw.IsPrivate || mw.IsFinal || mw.IsConstructor)) { int flags = self._flags(); flags -= MethodHandleNatives.Constants.REF_invokeVirtual << MethodHandleNatives.Constants.MN_REFERENCE_KIND_SHIFT; flags += MethodHandleNatives.Constants.REF_invokeSpecial << MethodHandleNatives.Constants.MN_REFERENCE_KIND_SHIFT; self._flags(flags); } if (mw.HasCallerID || DynamicTypeWrapper.RequiresDynamicReflectionCallerClass(mw.DeclaringType.Name, mw.Name, mw.Signature)) { self._flags(self._flags() | MemberName.CALLER_SENSITIVE); } }