<CompileInclude="..\augment.fs">

<Link>augment.fs</Link>

</Compile>

<CompileInclude="..\outcome.fsi">

<Link>outcome.fsi</Link>

</Compile>

<CompileInclude="..\outcome.fs">

<Link>outcome.fs</Link>

</Compile>

<CompileInclude="..\nameres.fsi">

<Link>nameres.fsi</Link>

</Compile>

<CompileInclude="..\nameres.fs">

<Link>nameres.fs</Link>

</Compile>

<CompileInclude="..\typrelns.fs">

<Link>typrelns.fs</Link>

</Compile>

</Compile>

<CompileInclude="..\patcompile.fs">

<Link>patcompile.fs</Link>

</Compile>

<CompileInclude="..\outcome.fsi">

<Link>outcome.fsi</Link>

</Compile>

<CompileInclude="..\outcome.fs">

<Link>outcome.fs</Link>

</Compile>

<CompileInclude="..\csolve.fsi">

<Link>csolve.fsi</Link>

</Compile>

<CompileInclude="..\formats.fs">

<Link>formats.fs</Link>

</Compile>

<CompileInclude="..\nameres.fsi">

<Link>nameres.fsi</Link>

</Compile>

<CompileInclude="..\nameres.fs">

<Link>nameres.fs</Link>

</Compile>

<CompileInclude="..\unsolved.fs">

<Link>unsolved.fs</Link>

letcallerArgs= argtys|> List.map(fun argty-> CallerArg(argty,m,false,dummyExpr))

letminst= FreshenMethInfo m minfo

letobjtys= minfo.GetObjArgTypes(amap, m, minst)

CalledMeth<Expr>(csenv.InfoReader,false,FreshenMethInfo,m,AccessibleFromEverywhere,minfo,minst,minst,None,objtys,[(callerArgs,[])],false,false))

CalledMeth<Expr>(csenv.InfoReader,None,false,FreshenMethInfo,m,AccessibleFromEverywhere,minfo,minst,minst,None,objtys,[(callerArgs,[])],false,false,None))

CollectThenUndo(fun trace-> ResolveOverloading csenv(WithTrace(trace)) nm ndeeptrue(0,0) AccessibleFromEverywhere calledMethGroupfalse(Some rty))

| Some mObjTy,None -> AfterTcOverloadResolution.ForNewConstructors cenv.tcSink env mObjTy methodName minfos

| None, _ -> AfterTcOverloadResolution.DoNothing

TcMethodApplicationThen cenv env overallTy tpenv None [] mWholeCall mItem methodName ad PossiblyMutates false meths afterTcOverloadResolution isSuperInit args ExprAtomicFlag.NonAtomic delayed

TcMethodApplicationThen cenv env overallTy(Some objTy)tpenv None [] mWholeCall mItem methodName ad PossiblyMutates false meths afterTcOverloadResolution isSuperInit args ExprAtomicFlag.NonAtomic delayed

| Item.DelegateCtor typ, [arg] ->

// Re-record the name resolution since we now know it's a constructor call

let afterTcOverloadResolution = AfterTcOverloadResolution.ForNewConstructors cenv.tcSink env synObjTy.Range methodName minfos

let ad = env.eAccessRights

let expr,tpenv = TcMethodApplicationThen cenv env objTy tpenv None [] mWholeExpr mObjTy methodName ad PossiblyMutates false meths afterTcOverloadResolution CtorValUsedAsSuperInit [arg] ExprAtomicFlag.Atomic []

let expr,tpenv = TcMethodApplicationThen cenv env objTyNonetpenv None [] mWholeExpr mObjTy methodName ad PossiblyMutates false meths afterTcOverloadResolution CtorValUsedAsSuperInit [arg] ExprAtomicFlag.Atomic []

// The 'base' value is always bound

let baseIdOpt = (match baseIdOpt with None -> Some(ident("base",mObjTy)) | Some id -> Some(id))

expr,baseIdOpt,tpenv

let afterTcOverloadResolution = afterOverloadResolution |> AfterTcOverloadResolution.ForMethods

match delayed with

| (DelayedApp (atomicFlag, arg, mExprAndArg)::otherDelayed) ->

TcMethodApplicationThen cenv env overallTy tpenv None [] mExprAndArg mItem methodName ad NeverMutates false meths afterTcOverloadResolution NormalValUse [arg] atomicFlag otherDelayed

TcMethodApplicationThen cenv env overallTyNonetpenv None [] mExprAndArg mItem methodName ad NeverMutates false meths afterTcOverloadResolution NormalValUse [arg] atomicFlag otherDelayed

| (DelayedTypeApp(tys, mTypeArgs, mExprAndTypeArgs) :: DelayedApp(atomicFlag, arg, mExprAndArg) :: otherDelayed) ->

// // NOTE: This doesn't take instantiation into account

// CallNameResolutionSink cenv.tcSink (mExprAndTypeArgs,env.NameEnv,item (* ! *), item, ItemOccurence.Use,env.DisplayEnv,env.eAccessRights)

TcMethodApplicationThen cenv env overallTy tpenv None [] mExprAndArg mItem methodName ad NeverMutates false [(minfoAfterStaticArguments, None)] afterTcOverloadResolution NormalValUse [arg] atomicFlag otherDelayed

TcMethodApplicationThen cenv env overallTyNonetpenv None [] mExprAndArg mItem methodName ad NeverMutates false [(minfoAfterStaticArguments, None)] afterTcOverloadResolution NormalValUse [arg] atomicFlag otherDelayed

| None ->

#endif

// NOTE: This doesn't take instantiation into account

CallNameResolutionSink cenv.tcSink (mExprAndTypeArgs,env.NameEnv,item (* ! *), item, ItemOccurence.Use,env.DisplayEnv,env.eAccessRights)

TcMethodApplicationThen cenv env overallTy tpenv (Some tyargs) [] mExprAndArg mItem methodName ad NeverMutates false meths afterTcOverloadResolution NormalValUse [arg] atomicFlag otherDelayed

TcMethodApplicationThen cenv env overallTyNonetpenv (Some tyargs) [] mExprAndArg mItem methodName ad NeverMutates false meths afterTcOverloadResolution NormalValUse [arg] atomicFlag otherDelayed

| _ ->

TcMethodApplicationThen cenv env overallTy tpenv None [] mItem mItem methodName ad NeverMutates false meths afterTcOverloadResolution NormalValUse [] ExprAtomicFlag.Atomic delayed

TcMethodApplicationThen cenv env overallTyNonetpenv None [] mItem mItem methodName ad NeverMutates false meths afterTcOverloadResolution NormalValUse [] ExprAtomicFlag.Atomic delayed

| Item.CtorGroup(nm,minfos) ->

let objTy =

if isNil meths then error (Error (FSComp.SR.tcPropertyCannotBeSet1 nm,mItem))

let afterTcOverloadResolution = afterOverloadResolution |> AfterTcOverloadResolution.ForProperties nm SettersOfPropInfos

// Note: static calls never mutate a struct object argument

TcMethodApplicationThen cenv env overallTy tpenv tyargsOpt [] mStmt mItem nm ad NeverMutates true meths afterTcOverloadResolution NormalValUse (args@[e2]) ExprAtomicFlag.NonAtomic otherDelayed

TcMethodApplicationThen cenv env overallTyNonetpenv tyargsOpt [] mStmt mItem nm ad NeverMutates true meths afterTcOverloadResolution NormalValUse (args@[e2]) ExprAtomicFlag.NonAtomic otherDelayed

| _ ->

// Static Property Get (possibly indexer)

let meths = pinfos |> GettersOfPropInfos

let afterTcOverloadResolution = afterOverloadResolution |> AfterTcOverloadResolution.ForProperties nm GettersOfPropInfos

if isNil meths then error (Error (FSComp.SR.tcPropertyIsNotReadable(nm),mItem))

// Note: static calls never mutate a struct object argument

TcMethodApplicationThen cenv env overallTy tpenv tyargsOpt [] mItem mItem nm ad NeverMutates true meths afterTcOverloadResolution NormalValUse args ExprAtomicFlag.Atomic delayed

TcMethodApplicationThen cenv env overallTyNonetpenv tyargsOpt [] mItem mItem nm ad NeverMutates true meths afterTcOverloadResolution NormalValUse args ExprAtomicFlag.Atomic delayed

| Item.ILField finfo ->

#if EXTENSIONTYPING

match TryTcMethodAppToStaticConstantArgs cenv env tpenv (minfos, tyargsOpt, mExprAndItem, mItem) with

| Some minfo -> TcMethodApplicationThen cenv env overallTy tpenv None objArgs mExprAndItem mItem methodName ad mutates false [(minfo, None)] afterTcOverloadResolution NormalValUse args atomicFlag delayed

| Some minfo -> TcMethodApplicationThen cenv env overallTyNonetpenv None objArgs mExprAndItem mItem methodName ad mutates false [(minfo, None)] afterTcOverloadResolution NormalValUse args atomicFlag delayed

| None ->

#endif

let tyargsOpt,tpenv = TcMemberTyArgsOpt cenv env tpenv tyargsOpt

let meths = minfos |> List.map (fun minfo -> minfo,None)

TcMethodApplicationThen cenv env overallTy tpenv tyargsOpt objArgs mExprAndItem mItem methodName ad mutates false meths afterTcOverloadResolution NormalValUse args atomicFlag delayed

TcMethodApplicationThen cenv env overallTyNonetpenv tyargsOpt objArgs mExprAndItem mItem methodName ad mutates false meths afterTcOverloadResolution NormalValUse args atomicFlag delayed

| Item.Property (nm,pinfos) ->

// Instance property

if isNil meths then error (Error (FSComp.SR.tcPropertyCannotBeSet1 nm,mItem))

let afterTcOverloadResolution = afterOverloadResolution |> AfterTcOverloadResolution.ForProperties nm SettersOfPropInfos

let mut = (if isStructTy cenv.g (tyOfExpr cenv.g objExpr) then DefinitelyMutates else PossiblyMutates)

TcMethodApplicationThen cenv env overallTy tpenv tyargsOpt objArgs mStmt mItem nm ad mut true meths afterTcOverloadResolution NormalValUse (args @ [e2]) atomicFlag []

TcMethodApplicationThen cenv env overallTyNonetpenv tyargsOpt objArgs mStmt mItem nm ad mut true meths afterTcOverloadResolution NormalValUse (args @ [e2]) atomicFlag []

| _ ->

// Instance property getter

let meths = GettersOfPropInfos pinfos

if isNil meths then error (Error (FSComp.SR.tcPropertyIsNotReadable(nm),mItem))

let afterTcOverloadResolution = afterOverloadResolution |> AfterTcOverloadResolution.ForProperties nm GettersOfPropInfos

TcMethodApplicationThen cenv env overallTy tpenv tyargsOpt objArgs mExprAndItem mItem nm ad PossiblyMutates true meths afterTcOverloadResolution NormalValUse args atomicFlag delayed

TcMethodApplicationThen cenv env overallTyNonetpenv tyargsOpt objArgs mExprAndItem mItem nm ad PossiblyMutates true meths afterTcOverloadResolution NormalValUse args atomicFlag delayed

| Item.RecdField rfinfo ->

// Get or set instance F# field or literal

env

overallTy // The type of the overall expression including "delayed". THe method "application" may actually be a use of a member as

// a first-class function value, when this would be a function type.

objTyOpt // methodType

tpenv

callerTyArgs // The return type of the overall expression including "delayed"

objArgs // The 'obj' arguments in obj.M(...) and obj.M, if any

// Call the helper below to do the real checking

let (expr,attributeAssignedNamedItems,delayed),tpenv =

TcMethodApplication false cenv env tpenv callerTyArgs objArgs mWholeExpr mItem methodName ad mut isProp meths afterTcOverloadResolution isSuperInit args exprTy delayed

TcMethodApplication false cenv env tpenv callerTyArgs objArgs mWholeExpr mItem methodNameobjTyOptad mut isProp meths afterTcOverloadResolution isSuperInit args exprTy delayed

// Give errors if some things couldn't be assigned

if nonNil attributeAssignedNamedItems then

mMethExpr // range of the entire method expression

mItem

methodName

(objTyOpt : TType option)

ad

mut

isProp

| Some tyargs -> minfo.AdjustUserTypeInstForFSharpStyleIndexedExtensionMembers(tyargs)

| None -> minst

let allArgs = List.zip unnamedCurriedCallerArgs namedCurriedCallerArgs

CalledMeth<SynExpr>(cenv.infoReader,checkingAttributeCall, FreshenMethInfo, mMethExpr,ad,minfo,minst,callerTyArgs,pinfoOpt,callerObjArgTys,allArgs,usesParamArrayConversion,true)

CalledMeth<SynExpr>(cenv.infoReader,Some(env.NameEnv),checkingAttributeCall, FreshenMethInfo, mMethExpr,ad,minfo,minst,callerTyArgs,pinfoOpt,callerObjArgTys,allArgs,usesParamArrayConversion,true,objTyOpt)

let preArgumentTypeCheckingCalledMethGroup =

[ for (minfo,pinfoOpt) in candidateMethsAndProps do

| Some tyargs -> minfo.AdjustUserTypeInstForFSharpStyleIndexedExtensionMembers(tyargs)

| None -> minst

let callerArgs = List.zip unnamedCurriedCallerArgs namedCurriedCallerArgs

CalledMeth<Expr>(cenv.infoReader,checkingAttributeCall,FreshenMethInfo, mMethExpr,ad,minfo,minst,callerTyArgs,pinfoOpt,callerObjArgTys,callerArgs,usesParamArrayConversion,true))

CalledMeth<Expr>(cenv.infoReader,Some(env.NameEnv),checkingAttributeCall,FreshenMethInfo, mMethExpr,ad,minfo,minst,callerTyArgs,pinfoOpt,callerObjArgTys,callerArgs,usesParamArrayConversion,true,objTyOpt))

let callerArgCounts = (unnamedCurriedCallerArgs.Length, namedCurriedCallerArgs.Length)

let csenv = MakeConstraintSolverEnv cenv.css mMethExpr denv

let meths = minfos |> List.map (fun minfo -> minfo,None)

let afterTcOverloadResolution = AfterTcOverloadResolution.ForNewConstructors cenv.tcSink env tyid.idRange methodName minfos

let (expr,namedCallerArgs,_),_ =

TcMethodApplication true cenv env tpenv None [] mAttr mAttr methodName ad PossiblyMutates false meths afterTcOverloadResolution NormalValUse [arg] (NewInferenceType ()) []

TcMethodApplication true cenv env tpenv None [] mAttr mAttr methodNameNonead PossiblyMutates false meths afterTcOverloadResolution NormalValUse [arg] (NewInferenceType ()) []

UnifyTypes cenv env mAttr ty (tyOfExpr cenv.g expr)

#if EXTENSIONTYPING

(infoReader:InfoReader,

nameEnv: Microsoft.FSharp.Compiler.Nameres.NameResolutionEnv option,

isCheckingAttributeCall,

freshenMethInfo,// afunctionto help generate fresh type variables the property setters methodsin generic classes

m,

callerObjArgTys: TType list,// the types of the actual object argument, if any

curriedCallerArgs:(CallerArg<'T> list* CallerNamedArg<'T> list) list,// the data about any arguments supplied by the caller

allowParamArgs:bool,// do we allow the use of a param args method in its "expanded" form?

allowOutAndOptArgs: bool)// do we allow the use of the transformation that converts out arguments as tuple returns?

allowOutAndOptArgs: bool,// do we allow the use of the transformation that converts out arguments as tuple returns?

tyargsOpt: TType option)// method parameters

letg= infoReader.g

letmethodRetTy= minfo.GetFSharpReturnTy(infoReader.amap, m, calledTyArgs)

letpminst= freshenMethInfo m pminfo

Choice1Of2(AssignedItemSetter(id,AssignedPropSetter(pinfo,pminfo, pminst), e))

match infoReader.GetILFieldInfosOfType(Some(nm),ad,m,returnedObjTy)with

| finfo::_->

Choice1Of2(AssignedItemSetter(id,AssignedILFieldSetter(finfo), e))

match infoReader.TryFindRecdOrClassFieldInfoOfType(nm,m,returnedObjTy)with

| Some rfinfo->

Choice1Of2(AssignedItemSetter(id,AssignedRecdFieldSetter(rfinfo), e))

| None->

Choice2Of2(arg))

match nameEnvwith

| Some(ne)-> ExtensionPropInfosOfTypeInScope infoReader ne(Some(nm), ad) m returnedObjTy

match epinfoswith

|[pinfo]when pinfo.HasSetter&&not pinfo.IsIndexer->

letpminfo= pinfo.SetterMethod

letpminst=match minfowith

| MethInfo.FSMeth(_,TType.TType_app(_,types),_,_)-> types

|_-> freshenMethInfo m pminfo

letpminst=match tyargsOptwith

| Some(TType.TType_app(_, types))-> types

|_-> pminst

Choice1Of2(AssignedItemSetter(id,AssignedPropSetter(pinfo,pminfo, pminst), e))

match infoReader.GetILFieldInfosOfType(Some(nm),ad,m,returnedObjTy)with

| finfo::_->

Choice1Of2(AssignedItemSetter(id,AssignedILFieldSetter(finfo), e))

match infoReader.TryFindRecdOrClassFieldInfoOfType(nm,m,returnedObjTy)with

| Some rfinfo->

Choice1Of2(AssignedItemSetter(id,AssignedRecdFieldSetter(rfinfo), e))

| None->

Choice2Of2(arg))

letnames= namedCallerArgs|> List.map(fun(CallerNamedArg(nm,_))-> nm.idText)