letccallInfo= ComputeConstrainedCallInfo g amap m(objArgs,minfo)

(minfo.IsStruct&&not minfo.IsExtensionMember)// don't take the address of a struct when passing to an extension member

(match ccallInfowith

| Some_->true

| None->false)

letccallInfo= ComputeConstrainedCallInfo g amap m(objArgs,minfo)

match objArgswith

|[objArgExpr]->

|[objArgExpr]->

lethasCallInfo= ccallInfo.IsSome

(minfo.IsStruct&&not minfo.IsExtensionMember)// don't take the address of a struct when passing to an extension member

|| hasCallInfo

letobjArgTy= tyOfExpr g objArgExpr

letwrap,objArgExpr'= mkExprAddrOfExpr g mustTakeAddress(Option.isSome ccallInfo) isMutable objArgExpr None m

letwrap,objArgExpr'= mkExprAddrOfExpr g mustTakeAddresshasCallInfo isMutable objArgExpr None m

not(TypeDefinitelySubsumesTypeNoCoercion0 g amap m minfo.ApparentEnclosingType objArgTy)then

mkCoerceExpr(objArgExpr',minfo.ApparentEnclosingType,m,objArgTy)

wrap,[objArgExpr']

(fun x-> x), objArgs

id, objArgs

lete,ety= f ccallInfo objArgs

wrap e,ety

letilMethRef= minfo.ILMethodRef

letnewobj= ctor&&(match valUseFlagswith NormalValUse->true|_->false)

letexprTy=if ctorthen minfo.ApparentEnclosingTypeelse minfo.GetFSharpReturnTy(amap, m, minst)

letretTy=(ifnot ctor&&(ilMethRef.ReturnType= ILType.Void)then[]else[exprTy])

letretTy=ifnot ctor&& ilMethRef.ReturnType= ILType.Voidthen[]else[exprTy]

letisDllImport= minfo.IsDllImport g

Expr.Op(TOp.ILCall(useCallvirt,isProtected,valu,newobj,valUseFlags,isProp,isDllImport,ilMethRef,minfo.DeclaringTypeInst,minst,retTy),[],args,m),

exprTy

((args,vexprty), arities)||> List.mapFold(fun(args,fty)arity->

match arity,argswith

|(0|1),[]when typeEquiv g(domainOfFunTy g fty) g.unit_ty-> mkUnit g m,(args, rangeOfFunTy g fty)

|0,(arg::argst)->

|0,(arg::argst)->

warning(InternalError(sprintf"Unexpected zero arity, args =%s"(Layout.showL(Layout.sepListL(Layout.rightL(Layout.TaggedTextOps.tagText";"))(List.map exprL args))),m));

arg,(argst, rangeOfFunTy g fty)

|1,(arg:: argst)-> arg,(argst, rangeOfFunTy g fty)

match amap.g.knownFSharpCoreModules.TryGetValue(declaringEntity.LogicalName)with

|true,modRef->

match modRef.ModuleOrNamespaceType.AllValsByLogicalName|> Seq.tryPick(fun(KeyValue(_,v))->if v.CompiledName= methodNamethen Some velse None)with

| Some v-> Some(mkNestedValRef modRef v)

| None-> None

modRef.ModuleOrNamespaceType.AllValsByLogicalName

|> Seq.tryPick(fun(KeyValue(_,v))->if v.CompiledName= methodNamethen Some(mkNestedValRef modRef v)else None)

|_-> None

None

letdirect= IsBaseCall objArgs

TakeObjAddrForMethodCall g amap minfo isMutable m objArgs(fun ccallInfo objArgs->

letallArgs=(objArgs@ args)

letallArgs= objArgs@ args

if(direct&&(match valUseFlagswith NormalValUse->true|_->false))then

if direct&&(match valUseFlagswith NormalValUse->true|_->false)then

VSlotDirectCall

match ccallInfowith

if isArrayTy g enclTythen

lettpe= TypeProviderError(FSComp.SR.tcRuntimeSuppliedMethodCannotBeUsedInUserCode(minfo.DisplayName), providedMeth.TypeProviderDesignation, m)

error(tpe)

error tpe

letvalu= isStructTy g enclTy

letisCtor= minfo.IsConstructor

if minfo.IsClassConstructorthen

elif isFunTy g enclTythen[ domainOfFunTy g enclTy; rangeOfFunTy g enclTy]// provided expressions can call Invoke

else minfo.DeclaringTypeInst

letactualMethInst= minst

letretTy=(ifnot isCtor&&(ilMethRef.ReturnType= ILType.Void)then[]else[exprTy])

letretTy=ifnot isCtor&&(ilMethRef.ReturnType= ILType.Void)then[]else[exprTy]

letexpr= Expr.Op(TOp.ILCall(useCallvirt,isProtected,valu,isNewObj,valUseFlags,isProp,noTailCall,ilMethRef,actualTypeInst,actualMethInst, retTy),[],allArgs,m)

expr,exprTy

|> Array.map(fun pty-> eraseSystemType(amap,m,pty))

erasedParamTys

|> Array.mapi(fun i erasedParamTy-> erasedParamTy.PApply((fun ty->ProvidedVar.Fresh("arg"+ i.ToString(),ty)),m))

|> Array.mapi(fun i erasedParamTy-> erasedParamTy.PApply((fun ty-> ProvidedVar.Fresh("arg"+ i.ToString(),ty)),m))