/** * Generate customized bytecode for a given LambdaForm. */ public static MemberName generateCustomizedCode(LambdaForm form, MethodType invokerType) { try { MemberName memberName = new MemberName(); memberName._clazz(AnonymousClass.Instance); memberName._name(form.debugName); memberName._type(invokerType); memberName._flags(MethodHandleNatives.Constants.MN_IS_METHOD | MethodHandleNatives.Constants.ACC_STATIC | (MethodHandleNatives.Constants.REF_invokeStatic << MethodHandleNatives.Constants.MN_REFERENCE_KIND_SHIFT)); memberName.vmtarget = new NativeInvokerBytecodeGenerator(form, invokerType).generateCustomizedCodeBytes(); return(memberName); } #if DEBUG catch (BailoutException x) { Console.WriteLine(x.Message); Console.WriteLine("generateCustomizedCode: " + form + ", " + invokerType); } #else catch (BailoutException) { } #endif return(InvokerBytecodeGenerator.generateCustomizedCode(form, invokerType)); }
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)); }
private static void MaybeCompile(LambdaForm lform, MemberName m) { if (VerifyAccess.isSamePackage(m.DeclaringClass, typeof(MethodHandle))) { // Help along bootstrapping... lform.CompileToBytecode(); } }
/// <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); }
internal virtual BoundMethodHandle BindArgumentD(BoundMethodHandle mh, int pos, double value) { assert(mh.SpeciesData() == OldSpeciesData()); BasicType bt = D_TYPE; MethodType type2 = BindArgumentType(mh, pos, bt); LambdaForm form2 = BindArgumentForm(1 + pos); return(mh.CopyWithExtendD(type2, form2, value)); }
// Factory method. internal static LambdaFormEditor LambdaFormEditor(LambdaForm lambdaForm) { // TO DO: Consider placing intern logic here, to cut down on duplication. // lambdaForm = findPreexistingEquivalent(lambdaForm) // Always use uncustomized version for editing. // It helps caching and customized LambdaForms reuse transformCache field to keep a link to uncustomized version. return(new LambdaFormEditor(lambdaForm.Uncustomize())); }
internal virtual LambdaForm SpreadArgumentsForm(int pos, Class arrayType, int arrayLength) { Class elementType = arrayType.ComponentType; Class erasedArrayType = arrayType; if (!elementType.Primitive) { erasedArrayType = typeof(Object[]); } BasicType bt = basicType(elementType); int elementTypeKey = bt.ordinal(); if (bt.basicTypeClass() != elementType) { if (elementType.Primitive) { elementTypeKey = TYPE_LIMIT + Wrapper.forPrimitiveType(elementType).ordinal(); } } Transform key = Transform.Of(Transform.Kind.SPREAD_ARGS, pos, elementTypeKey, arrayLength); LambdaForm form = GetInCache(key); if (form != null) { assert(form.Arity_Renamed == LambdaForm.Arity_Renamed - arrayLength + 1); return(form); } LambdaFormBuffer buf = Buffer(); buf.StartEdit(); assert(pos <= MethodType.MAX_JVM_ARITY); assert(pos + arrayLength <= LambdaForm.Arity_Renamed); assert(pos > 0); // cannot spread the MH arg itself Name spreadParam = new Name(L_TYPE); Name checkSpread = new Name(MethodHandleImpl.Lazy.NF_checkSpreadArgument, spreadParam, arrayLength); // insert the new expressions int exprPos = LambdaForm.Arity(); buf.InsertExpression(exprPos++, checkSpread); // adjust the arguments MethodHandle aload = MethodHandles.ArrayElementGetter(erasedArrayType); for (int i = 0; i < arrayLength; i++) { Name loadArgument = new Name(aload, spreadParam, i); buf.InsertExpression(exprPos + i, loadArgument); buf.ReplaceParameterByCopy(pos + i, exprPos + i); } buf.InsertParameter(pos, spreadParam); form = buf.EndEdit(); return(PutInCache(key, form)); }
private NativeInvokerBytecodeGenerator(LambdaForm lambdaForm, MethodType invokerType) { if (invokerType != invokerType.basicType()) { throw new BailoutException(Bailout.NotBasicType, invokerType); } this.lambdaForm = lambdaForm; this.invokerType = invokerType; this.delegateType = MethodHandleUtil.GetMemberWrapperDelegateType(invokerType); MethodInfo mi = MethodHandleUtil.GetDelegateInvokeMethod(delegateType); Type[] paramTypes = MethodHandleUtil.GetParameterTypes(typeof(object[]), mi); // HACK the code we generate is not verifiable (known issue: locals aren't typed correctly), so we stick the DynamicMethod into mscorlib (a security critical assembly) this.dm = new DynamicMethod(lambdaForm.debugName, mi.ReturnType, paramTypes, typeof(object).Module, true); this.ilgen = CodeEmitter.Create(this.dm); if (invokerType.parameterCount() > MethodHandleUtil.MaxArity) { this.packedArgType = paramTypes[paramTypes.Length - 1]; this.packedArgPos = paramTypes.Length - 1; } else { this.packedArgPos = Int32.MaxValue; } locals = new CodeEmitterLocal[lambdaForm.names.Length]; for (int i = lambdaForm._arity(); i < lambdaForm.names.Length; i++) { Name name = lambdaForm.names[i]; if (name.index() != i) { throw new BailoutException(Bailout.PreconditionViolated, "name.index() != i"); } switch (name.typeChar()) { case 'L': locals[i] = ilgen.DeclareLocal(Types.Object); break; case 'I': locals[i] = ilgen.DeclareLocal(Types.Int32); break; case 'J': locals[i] = ilgen.DeclareLocal(Types.Int64); break; case 'F': locals[i] = ilgen.DeclareLocal(Types.Single); break; case 'D': locals[i] = ilgen.DeclareLocal(Types.Double); break; case 'V': break; default: throw new BailoutException(Bailout.PreconditionViolated, "Unsupported typeChar(): " + name.typeChar()); } } }
private static LambdaForm PreparedLambdaForm(MethodType mtype, int which) { LambdaForm lform = mtype.Form().CachedLambdaForm(which); if (lform != null) { return(lform); } lform = MakePreparedLambdaForm(mtype, which); return(mtype.Form().SetCachedLambdaForm(which, lform)); }
internal override BoundMethodHandle CopyWithExtendF(MethodType mt, LambdaForm lf, float narg) /*non-public*/ { try { return((BoundMethodHandle)SPECIES_DATA.ExtendWith(F_TYPE).Constructor().invokeBasic(mt, lf, narg)); } catch (Throwable ex) { throw uncaughtException(ex); } }
private static LambdaForm PreparedFieldLambdaForm(sbyte formOp, bool isVolatile, Class ftype) { int afIndex = AfIndex(formOp, isVolatile, FtypeKind(ftype)); LambdaForm lform = ACCESSOR_FORMS[afIndex]; if (lform != null) { return(lform); } lform = MakePreparedFieldLambdaForm(formOp, isVolatile, FtypeKind(ftype)); ACCESSOR_FORMS[afIndex] = lform; // don't bother with a CAS return(lform); }
private static DirectMethodHandle MakeAllocator(MemberName ctor) { assert(ctor.Constructor && ctor.Name.Equals("<init>")); Class instanceClass = ctor.DeclaringClass; ctor = ctor.AsConstructor(); assert(ctor.Constructor && ctor.ReferenceKind == REF_newInvokeSpecial) : ctor; MethodType mtype = ctor.MethodType.ChangeReturnType(instanceClass); LambdaForm lform = PreparedLambdaForm(ctor); MemberName init = ctor.AsSpecial(); assert(init.MethodType.ReturnType() == typeof(void)); return(new Constructor(mtype, lform, ctor, init, instanceClass)); }
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)); }
internal LambdaFormBuffer(LambdaForm lf) { this.Arity = lf.Arity_Renamed; Names = lf.Names; int result = lf.Result; if (result == LAST_RESULT) { result = Length - 1; } if (result >= 0 && lf.Names[result].Type_Renamed != V_TYPE) { ResultName = lf.Names[result]; } DebugName = lf.DebugName; assert(lf.NameRefsAreLegal()); }
/// <summary> /// Create a LF which can invoke the given method. /// Cache and share this structure among all methods with /// the same basicType and refKind. /// </summary> private static LambdaForm PreparedLambdaForm(MemberName m) { assert(m.Invocable) : m; // call preparedFieldLambdaForm instead MethodType mtype = m.InvocationType.BasicType(); assert(!m.MethodHandleInvoke || "invokeBasic".Equals(m.Name)) : m; int which; switch (m.ReferenceKind) { case REF_invokeVirtual: which = LF_INVVIRTUAL; break; case REF_invokeStatic: which = LF_INVSTATIC; break; case REF_invokeSpecial: which = LF_INVSPECIAL; break; case REF_invokeInterface: which = LF_INVINTERFACE; break; case REF_newInvokeSpecial: which = LF_NEWINVSPECIAL; break; default: throw new InternalError(m.ToString()); } if (which == LF_INVSTATIC && ShouldBeInitialized(m)) { // precompute the barrier-free version: PreparedLambdaForm(mtype, which); which = LF_INVSTATIC_INIT; } LambdaForm lform = PreparedLambdaForm(mtype, which); MaybeCompile(lform, m); assert(lform.MethodType().DropParameterTypes(0, 1).Equals(m.InvocationType.BasicType())) : Arrays.asList(m, m.InvocationType.BasicType(), lform, lform.MethodType()); return(lform); }
internal virtual LambdaForm FilterArgumentForm(int pos, BasicType newType) { Transform key = Transform.Of(Transform.Kind.FILTER_ARG, pos, newType.ordinal()); LambdaForm form = GetInCache(key); if (form != null) { assert(form.Arity_Renamed == LambdaForm.Arity_Renamed); assert(form.ParameterType(pos) == newType); return(form); } BasicType oldType = LambdaForm.ParameterType(pos); MethodType filterType = MethodType.MethodType(oldType.basicTypeClass(), newType.basicTypeClass()); form = MakeArgumentCombinationForm(pos, filterType, false, false); return(PutInCache(key, form)); }
// hooked up via map.xml (as a replacement for makePairwiseConvertByEditor) public static MethodHandle makePairwiseConvert(MethodHandle target, MethodType srcType, bool strict, bool monobox) { #if FIRST_PASS return(null); #else object[] convSpecs = MethodHandleImpl.computeValueConversions(srcType, target.type(), strict, monobox); List <LambdaForm.Name> names = new List <LambdaForm.Name>(); names.Add(new LambdaForm.Name(0, LambdaForm.BasicType.L_TYPE)); for (int i = 0; i < srcType.parameterCount(); i++) { names.Add(new LambdaForm.Name(i + 1, LambdaForm.BasicType.basicType(srcType.parameterType(i)))); } LambdaForm.Name[] invokeArgs = new LambdaForm.Name[srcType.parameterCount()]; for (int i = 0; i < invokeArgs.Length; i++) { object convSpec = convSpecs[i]; if (convSpec == null) { invokeArgs[i] = names[i + 1]; } else { LambdaForm.Name temp = new LambdaForm.Name(convSpec as MethodHandle ?? MethodHandleImpl.Lazy.MH_castReference.bindTo(convSpec), names[i + 1]); names.Add(temp); invokeArgs[i] = temp; } } names.Add(new LambdaForm.Name(target, invokeArgs)); if (convSpecs[convSpecs.Length - 1] != null) { object convSpec = convSpecs[convSpecs.Length - 1]; if (convSpec != java.lang.Void.TYPE) { names.Add(new LambdaForm.Name(convSpec as MethodHandle ?? MethodHandleImpl.Lazy.MH_castReference.bindTo(convSpec), names[names.Count - 1])); } } if (target.type().returnType() == java.lang.Void.TYPE && srcType.returnType() != java.lang.Void.TYPE) { names.Add(new LambdaForm.Name(LambdaForm.constantZero(LambdaForm.BasicType.basicType(srcType.returnType())))); } LambdaForm form = new LambdaForm("PairwiseConvert", srcType.parameterCount() + 1, names.ToArray()); return(new LightWeightMethodHandle(srcType, form)); #endif }
// Factory methods: internal static DirectMethodHandle Make(sbyte refKind, Class receiver, MemberName member) { MethodType mtype = member.MethodOrFieldType; if (!member.Static) { if (!receiver.IsSubclassOf(member.DeclaringClass) || member.Constructor) { throw new InternalError(member.ToString()); } mtype = mtype.InsertParameterTypes(0, receiver); } if (!member.Field) { if (refKind == REF_invokeSpecial) { member = member.AsSpecial(); LambdaForm lform = PreparedLambdaForm(member); return(new Special(mtype, lform, member)); } else { LambdaForm lform = PreparedLambdaForm(member); return(new DirectMethodHandle(mtype, lform, member)); } } else { LambdaForm lform = PreparedFieldLambdaForm(member); if (member.Static) { long offset = MethodHandleNatives.staticFieldOffset(member); Object @base = MethodHandleNatives.staticFieldBase(member); return(new StaticAccessor(mtype, lform, member, @base, offset)); } else { long offset = MethodHandleNatives.objectFieldOffset(member); assert(offset == (int)offset); return(new Accessor(mtype, lform, member, (int)offset)); } } }
internal virtual LambdaForm AddArgumentForm(int pos, BasicType type) { Transform key = Transform.Of(Transform.Kind.ADD_ARG, pos, type.ordinal()); LambdaForm form = GetInCache(key); if (form != null) { assert(form.Arity_Renamed == LambdaForm.Arity_Renamed + 1); assert(form.ParameterType(pos) == type); return(form); } LambdaFormBuffer buf = Buffer(); buf.StartEdit(); buf.InsertParameter(pos, new Name(type)); form = buf.EndEdit(); return(PutInCache(key, form)); }
/// Editing methods for lambda forms. // Each editing method can (potentially) cache the edited LF so that it can be reused later. internal virtual LambdaForm BindArgumentForm(int pos) { Transform key = Transform.Of(Transform.Kind.BIND_ARG, pos); LambdaForm form = GetInCache(key); if (form != null) { assert(form.ParameterConstraint(0) == NewSpeciesData(LambdaForm.ParameterType(pos))); return(form); } LambdaFormBuffer buf = Buffer(); buf.StartEdit(); BoundMethodHandle.SpeciesData oldData = OldSpeciesData(); BoundMethodHandle.SpeciesData newData = NewSpeciesData(LambdaForm.ParameterType(pos)); Name oldBaseAddress = LambdaForm.Parameter(0);// BMH holding the values Name newBaseAddress; NamedFunction getter = newData.GetterFunction(oldData.FieldCount()); if (pos != 0) { // The newly created LF will run with a different BMH. // Switch over any pre-existing BMH field references to the new BMH class. buf.ReplaceFunctions(oldData.GetterFunctions(), newData.GetterFunctions(), oldBaseAddress); newBaseAddress = oldBaseAddress.withConstraint(newData); buf.RenameParameter(0, newBaseAddress); buf.ReplaceParameterByNewExpression(pos, new Name(getter, newBaseAddress)); } else { // cannot bind the MH arg itself, unless oldData is empty assert(oldData == BoundMethodHandle.SpeciesData.EMPTY); newBaseAddress = (new Name(L_TYPE)).withConstraint(newData); buf.ReplaceParameterByNewExpression(0, new Name(getter, newBaseAddress)); buf.InsertParameter(0, newBaseAddress); } form = buf.EndEdit(); return(PutInCache(key, form)); }
// Constructors and factory methods in this class *must* be package scoped or private. private DirectMethodHandle(MethodType mtype, LambdaForm form, MemberName member) : base(mtype, form) { if (!member.Resolved) { throw new InternalError(); } if (member.DeclaringClass.Interface && member.Method && !member.Abstract) { // Check for corner case: invokeinterface of Object method MemberName m = new MemberName(typeof(Object), member.Name, member.MethodType, member.ReferenceKind); m = MemberName.Factory.ResolveOrNull(m.ReferenceKind, m, null); if (m != null && m.Public) { assert(member.ReferenceKind == m.ReferenceKind); // else this.form is wrong member = m; } } this.Member = member; }
internal virtual LambdaForm DupArgumentForm(int srcPos, int dstPos) { Transform key = Transform.Of(Transform.Kind.DUP_ARG, srcPos, dstPos); LambdaForm form = GetInCache(key); if (form != null) { assert(form.Arity_Renamed == LambdaForm.Arity_Renamed - 1); return(form); } LambdaFormBuffer buf = Buffer(); buf.StartEdit(); assert(LambdaForm.Parameter(srcPos).Constraint == null); assert(LambdaForm.Parameter(dstPos).Constraint == null); buf.ReplaceParameterByCopy(dstPos, srcPos); form = buf.EndEdit(); return(PutInCache(key, form)); }
/// <summary> /// Create a LF which can access the given field. /// Cache and share this structure among all fields with /// the same basicType and refKind. /// </summary> private static LambdaForm PreparedFieldLambdaForm(MemberName m) { Class ftype = m.FieldType; bool isVolatile = m.Volatile; sbyte formOp; switch (m.ReferenceKind) { case REF_getField: formOp = AF_GETFIELD; break; case REF_putField: formOp = AF_PUTFIELD; break; case REF_getStatic: formOp = AF_GETSTATIC; break; case REF_putStatic: formOp = AF_PUTSTATIC; break; default: throw new InternalError(m.ToString()); } if (ShouldBeInitialized(m)) { // precompute the barrier-free version: PreparedFieldLambdaForm(formOp, isVolatile, ftype); assert((AF_GETSTATIC_INIT - AF_GETSTATIC) == (AF_PUTSTATIC_INIT - AF_PUTSTATIC)); formOp += (sbyte)(AF_GETSTATIC_INIT - AF_GETSTATIC); } LambdaForm lform = PreparedFieldLambdaForm(formOp, isVolatile, ftype); MaybeCompile(lform, m); assert(lform.MethodType().DropParameterTypes(0, 1).Equals(m.InvocationType.BasicType())) : Arrays.asList(m, m.InvocationType.BasicType(), lform, lform.MethodType()); return(lform); }
/** * Generate customized bytecode for a given LambdaForm. */ public static MemberName generateCustomizedCode(LambdaForm form, MethodType invokerType) { try { MemberName memberName = new MemberName(); memberName._clazz(AnonymousClass.Instance); memberName._name(form.debugName); memberName._type(invokerType); memberName._flags(MethodHandleNatives.Constants.MN_IS_METHOD | MethodHandleNatives.Constants.ACC_STATIC | (MethodHandleNatives.Constants.REF_invokeStatic << MethodHandleNatives.Constants.MN_REFERENCE_KIND_SHIFT)); memberName.vmtarget = new NativeInvokerBytecodeGenerator(form, invokerType).generateCustomizedCodeBytes(); return memberName; } #if DEBUG catch (BailoutException x) { Console.WriteLine(x.Message); Console.WriteLine("generateCustomizedCode: " + form + ", " + invokerType); } #else catch (BailoutException) { } #endif return InvokerBytecodeGenerator.generateCustomizedCode(form, invokerType); }
internal override MethodHandle CopyWith(MethodType mt, LambdaForm lf) { return(new StaticAccessor(mt, lf, Member, StaticBase, StaticOffset)); }
internal StaticAccessor(MethodType mtype, LambdaForm form, MemberName member, Object staticBase, long staticOffset) : base(mtype, form, member) { this.FieldType = member.FieldType; this.StaticBase = staticBase; this.StaticOffset = staticOffset; }
internal override MethodHandle CopyWith(MethodType mt, LambdaForm lf) { return(new Accessor(mt, lf, Member, FieldOffset)); }
internal Accessor(MethodType mtype, LambdaForm form, MemberName member, int fieldOffset) : base(mtype, form, member) { this.FieldType = member.FieldType; this.FieldOffset = fieldOffset; }
internal override MethodHandle CopyWith(MethodType mt, LambdaForm lf) { return(new Constructor(mt, lf, Member, InitMethod, InstanceClass)); }
internal Constructor(MethodType mtype, LambdaForm form, MemberName constructor, MemberName initMethod, Class instanceClass) : base(mtype, form, constructor) { this.InitMethod = initMethod; this.InstanceClass = instanceClass; assert(initMethod.Resolved); }
internal override MethodHandle CopyWith(MethodType mt, LambdaForm lf) { return(new Special(mt, lf, Member)); }
internal Special(MethodType mtype, LambdaForm form, MemberName member) : base(mtype, form, member) { }
public static MemberName generateCustomizedCode(LambdaForm form, MethodType invokerType) { return null; }