// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information.

/// Logic associated with resolving method calls.

module internal FSharp.Compiler.MethodCalls

open Internal.Utilities

open Internal.Utilities.Library

open FSharp.Compiler

open FSharp.Compiler.AbstractIL.IL

open FSharp.Compiler.AccessibilityLogic

open FSharp.Compiler.AttributeChecking

open FSharp.Compiler.DiagnosticsLogger

open FSharp.Compiler.Features

open FSharp.Compiler.Import

open FSharp.Compiler.InfoReader

open FSharp.Compiler.Infos

open FSharp.Compiler.IO

open FSharp.Compiler.NameResolution

open FSharp.Compiler.Syntax

open FSharp.Compiler.Syntax.PrettyNaming

open FSharp.Compiler.SyntaxTreeOps

open FSharp.Compiler.TcGlobals

open FSharp.Compiler.Text

open FSharp.Compiler.Text.Range

open FSharp.Compiler.TypedTree

open FSharp.Compiler.TypedTreeBasics

open FSharp.Compiler.TypedTreeOps

open FSharp.Compiler.TypedTreeOps.DebugPrint

open FSharp.Compiler.TypeHierarchy

open FSharp.Compiler.TypeRelations

#if !NO_TYPEPROVIDERS

open FSharp.Compiler.TypeProviders

#endif

//-------------------------------------------------------------------------

// Sets of methods involved in overload resolution and trait constraint

// satisfaction.

//-------------------------------------------------------------------------

/// In the following, 'T gets instantiated to:

/// 1. the expression being supplied for an argument

/// 2. "unit", when simply checking for the existence of an overload that satisfies

/// a signature, or when finding the corresponding witness.

/// Note the parametricity helps ensure that overload resolution doesn't depend on the

/// expression on the callside (though it is in some circumstances allowed

/// to depend on some type information inferred syntactically from that

/// expression, e.g. a lambda expression may be converted to a delegate as

/// an adhoc conversion.

///

/// The bool indicates if named using a '?', making the caller argument explicit-optional

type CallerArg<'T> =

/// CallerArg(ty, range, isOpt, exprInfo)

| CallerArg of ty: TType * range: range * isOpt: bool * exprInfo: 'T

member x.CallerArgumentType = (let (CallerArg(ty, _, _, _)) = x in ty)

member x.Range = (let (CallerArg(_, m, _, _)) = x in m)

member x.IsExplicitOptional = (let (CallerArg(_, _, isOpt, _)) = x in isOpt)

member x.Expr = (let (CallerArg(_, _, _, expr)) = x in expr)

/// Represents the information about an argument in the method being called

type CalledArg =

{ Position: struct (int * int)

IsParamArray : bool

OptArgInfo : OptionalArgInfo

CallerInfo : CallerInfo

IsInArg: bool

IsOutArg: bool

ReflArgInfo: ReflectedArgInfo

NameOpt: Ident option

CalledArgumentType : TType }

let CalledArg (pos, isParamArray, optArgInfo, callerInfo, isInArg, isOutArg, nameOpt, reflArgInfo, calledArgTy) =

{ Position=pos

IsParamArray=isParamArray

OptArgInfo=optArgInfo

CallerInfo=callerInfo

IsInArg=isInArg

IsOutArg=isOutArg

ReflArgInfo=reflArgInfo

NameOpt=nameOpt

CalledArgumentType=calledArgTy }

/// Represents a match between a caller argument and a called argument, arising from either

/// a named argument or an unnamed argument.

type AssignedCalledArg<'T> =

{ /// The identifier for a named argument, if any

NamedArgIdOpt : Ident option

/// The called argument in the method

CalledArg: CalledArg

/// The argument on the caller side

CallerArg: CallerArg<'T> }

member x.Position = x.CalledArg.Position

/// Represents the possibilities for a named-setter argument (a property, field, or a record field setter)

type AssignedItemSetterTarget =

// the MethInfo is a non-indexer setter property

| AssignedPropSetter of staticTyOpt: TType option * pinfo: PropInfo * minfo: MethInfo * pminst: TypeInst

| AssignedILFieldSetter of ILFieldInfo

| AssignedRecdFieldSetter of RecdFieldInfo

/// Represents the resolution of a caller argument as a named-setter argument

type AssignedItemSetter<'T> = AssignedItemSetter of Ident * AssignedItemSetterTarget * CallerArg<'T>

type CallerNamedArg<'T> =

| CallerNamedArg of Ident * CallerArg<'T>

member x.Ident = (let (CallerNamedArg(id, _)) = x in id)

member x.Name = x.Ident.idText

member x.CallerArg = (let (CallerNamedArg(_, a)) = x in a)

/// Represents the list of unnamed / named arguments at method call site

/// remark: The usage of list list is due to tupling and currying of arguments,

/// stemming from SynValInfo in the AST.

[<Struct>]

type CallerArgs<'T> =

{

Unnamed: CallerArg<'T> list list

Named: CallerNamedArg<'T> list list

}

static member Empty : CallerArgs<'T> = { Unnamed = []; Named = [] }

member x.CallerArgCounts = List.length x.Unnamed, List.length x.Named

member x.CurriedCallerArgs = List.zip x.Unnamed x.Named

member x.ArgumentNamesAndTypes =

let unnamed = x.Unnamed |> List.collect (List.map (fun i -> None, i.CallerArgumentType))

let named = x.Named |> List.collect (List.map (fun i -> Some i.Name, i.CallerArg.CallerArgumentType))

unnamed @ named

//-------------------------------------------------------------------------

// Callsite conversions

//-------------------------------------------------------------------------

let AdjustDelegateTy (infoReader: InfoReader) actualTy reqdTy m =

let g = infoReader.g

let (SigOfFunctionForDelegate(_, delArgTys, _, delFuncTy)) = GetSigOfFunctionForDelegate infoReader reqdTy m AccessibleFromSomewhere

let delArgTys = if isNil delArgTys then [g.unit_ty] else delArgTys

if (fst (stripFunTy g actualTy)).Length = delArgTys.Length then

delFuncTy

else

reqdTy

// Adhoc based on op_Implicit

//

// NOTE:

// no generic method op_Implicit as yet

//

// Search for an adhoc conversion based on op_Implicit, optionally returning a new equational type constraint to

// eliminate artificial constrained type variables.

//

// Allow adhoc for X --> Y where there is an op_Implicit from X to Y, and there is

// no feasible subtype relationship between X and Y.

//

// Also allow adhoc for X --> ? where the ? is a type inference variable constrained

// by a coercion constraint to Y for which there is an op_Implicit from X to Y, and there is

// no feasible subtype relationship between X and Y.

//

// Implicit conversions are only activated if the types precisely match based on known type information

// at the point of resolution. For example

// let f (x: 'T) : Nullable<'T> = x

// is enough, whereas

// let f (x: 'T) : Nullable<_> = x

// let f x : Nullable<'T> = x

// are not enough to activate.

let TryFindRelevantImplicitConversion (infoReader: InfoReader) ad reqdTy actualTy m =

let g = infoReader.g

let amap = infoReader.amap

if g.langVersion.SupportsFeature LanguageFeature.AdditionalTypeDirectedConversions then

// shortcut

if typeEquiv g reqdTy actualTy then None else

let reqdTy2 =

if isTyparTy g reqdTy then

let tp = destTyparTy g reqdTy

match tp.Constraints |> List.choose (function TyparConstraint.CoercesTo (tgtTy, _) -> Some tgtTy | _ -> None) with

| [reqdTy2] when tp.Rigidity = TyparRigidity.Flexible -> reqdTy2

| _ -> reqdTy

else reqdTy

// Implicit conversions only activate if a precise implicit conversion exists and:

// 1. no feasible subtype relationship between X and Y (an approximation), OR

// 2. T --> some-type-containing-precisely-T

// Note that even for (2) implicit conversions are still only activated if the

// types *precisely* and *completely* match based on *known* type information at the point of resolution.

if not (isTyparTy g reqdTy2) &&

(not (TypeFeasiblySubsumesType 0 g amap m reqdTy2 CanCoerce actualTy) ||

isTyparTy g actualTy && (let ftyvs = freeInType CollectAll reqdTy2 in ftyvs.FreeTypars.Contains(destTyparTy g actualTy))) then

let implicits =

[ for conv in infoReader.FindImplicitConversions m ad actualTy do

(conv, actualTy)

for conv in infoReader.FindImplicitConversions m ad reqdTy2 do

(conv, reqdTy2) ]

let implicits =

implicits |> List.filter (fun (minfo, _staticTy) ->

not minfo.IsInstance &&

minfo.FormalMethodTyparInst.IsEmpty &&

(match minfo.GetParamTypes(amap, m, []) with

| [[a]] -> typeEquiv g a actualTy

| _ -> false) &&

(let retTy = minfo.GetFSharpReturnType(amap, m, [])

typeEquiv g retTy reqdTy2)

)

match implicits with

| [(minfo, staticTy) ] ->

Some (minfo, staticTy, (reqdTy, reqdTy2, ignore))

| (minfo, staticTy) :: _ ->

Some (minfo, staticTy, (reqdTy, reqdTy2, fun denv ->

let reqdTy2Text, actualTyText, _cxs = NicePrint.minimalStringsOfTwoTypes denv reqdTy2 actualTy

let implicitsText = NicePrint.multiLineStringOfMethInfos infoReader m denv (List.map fst implicits)

errorR(Error(FSComp.SR.tcAmbiguousImplicitConversion(actualTyText, reqdTy2Text, implicitsText), m))))

| _ -> None

else

None

else

None

[<RequireQualifiedAccess>]

type TypeDirectedConversion =

| BuiltIn

| Implicit of MethInfo

[<RequireQualifiedAccess>]

type TypeDirectedConversionUsed =

| Yes of (DisplayEnv -> exn) * isTwoStepConversion: bool * isNullable: bool

| No

static member Combine a b =

match a, b with

// We want to know which candidates have one or more nullable conversions exclusively

// If one of the values is false we flow false for both.

| Yes(_, true, false), _ -> a

| _, Yes(_, true, false) -> b

| Yes(_, true, _), _ -> a

| _, Yes(_, true, _) -> b

| Yes _, _ -> a

| _, Yes _ -> b

| No, No -> a

let MapCombineTDCD mapper xs =

MapReduceD mapper TypeDirectedConversionUsed.No TypeDirectedConversionUsed.Combine xs

let MapCombineTDC2D mapper xs ys =

MapReduce2D mapper TypeDirectedConversionUsed.No TypeDirectedConversionUsed.Combine xs ys

let rec AdjustRequiredTypeForTypeDirectedConversions (infoReader: InfoReader) ad isMethodArg isConstraint (reqdTy: TType) actualTy m =

let g = infoReader.g

let warn info denv =

let reqdTyText, actualTyText, _cxs = NicePrint.minimalStringsOfTwoTypes denv reqdTy actualTy

match info with

| TypeDirectedConversion.BuiltIn ->

Error(FSComp.SR.tcBuiltInImplicitConversionUsed(actualTyText, reqdTyText), m)

| TypeDirectedConversion.Implicit convMeth ->

let methText = NicePrint.stringOfMethInfo infoReader m denv convMeth

if isMethodArg then

Error(FSComp.SR.tcImplicitConversionUsedForMethodArg(methText, actualTyText, reqdTyText), m)

else

Error(FSComp.SR.tcImplicitConversionUsedForNonMethodArg(methText, actualTyText, reqdTyText), m)

if isConstraint then

reqdTy, TypeDirectedConversionUsed.No, None

else

// Delegate --> function

if isDelegateTy g reqdTy && isFunTy g actualTy then

AdjustDelegateTy infoReader actualTy reqdTy m, TypeDirectedConversionUsed.No, None

// (T -> U) --> Expression<T -> U> LINQ-style quotation

elif isLinqExpressionTy g reqdTy && isDelegateTy g (destLinqExpressionTy g reqdTy) && isFunTy g actualTy then

let delegateTy = destLinqExpressionTy g reqdTy

AdjustRequiredTypeForTypeDirectedConversions infoReader ad isMethodArg isConstraint delegateTy actualTy m

// Adhoc int32 --> int64

elif g.langVersion.SupportsFeature LanguageFeature.AdditionalTypeDirectedConversions && typeEquiv g g.int64_ty reqdTy && typeEquiv g g.int32_ty actualTy then

g.int32_ty, TypeDirectedConversionUsed.Yes(warn TypeDirectedConversion.BuiltIn, false, false), None

// Adhoc int32 --> nativeint

elif g.langVersion.SupportsFeature LanguageFeature.AdditionalTypeDirectedConversions && typeEquiv g g.nativeint_ty reqdTy && typeEquiv g g.int32_ty actualTy then

g.int32_ty, TypeDirectedConversionUsed.Yes(warn TypeDirectedConversion.BuiltIn, false, false), None

// Adhoc int32 --> float64

elif g.langVersion.SupportsFeature LanguageFeature.AdditionalTypeDirectedConversions && typeEquiv g g.float_ty reqdTy && typeEquiv g g.int32_ty actualTy then

g.int32_ty, TypeDirectedConversionUsed.Yes(warn TypeDirectedConversion.BuiltIn, false, false), None

elif g.langVersion.SupportsFeature LanguageFeature.NullableOptionalInterop && isMethodArg && isNullableTy g reqdTy && not (isNullableTy g actualTy) then

let underlyingTy = destNullableTy g reqdTy

// shortcut

if typeEquiv g underlyingTy actualTy then

actualTy, TypeDirectedConversionUsed.Yes(warn TypeDirectedConversion.BuiltIn, false, true), None

else

let adjustedTy, _, _ = AdjustRequiredTypeForTypeDirectedConversions infoReader ad isMethodArg isConstraint underlyingTy actualTy m

if typeEquiv g adjustedTy actualTy then

actualTy, TypeDirectedConversionUsed.Yes(warn TypeDirectedConversion.BuiltIn, true, true), None

else

reqdTy, TypeDirectedConversionUsed.No, None

// Adhoc based on op_Implicit, perhaps returning a new equational type constraint to

// eliminate artificial constrained type variables.

elif g.langVersion.SupportsFeature LanguageFeature.AdditionalTypeDirectedConversions then

match TryFindRelevantImplicitConversion infoReader ad reqdTy actualTy m with

| Some (minfo, _staticTy, eqn) -> actualTy, TypeDirectedConversionUsed.Yes(warn (TypeDirectedConversion.Implicit minfo), false, false), Some eqn

| None -> reqdTy, TypeDirectedConversionUsed.No, None

else reqdTy, TypeDirectedConversionUsed.No, None

// If the called method argument is a delegate type, and the caller is known to be a function type, then the caller may provide a function

// If the called method argument is an Expression<T> type, and the caller is known to be a function type, then the caller may provide a T

// If the called method argument is an [<AutoQuote>] Quotations.Expr<T>, and the caller is not known to be a quoted expression type, then the caller may provide a T

let AdjustCalledArgTypeForTypeDirectedConversionsAndAutoQuote (infoReader: InfoReader) ad (callerArgTy: TType) calledArgTy (calledArg: CalledArg) m =

let g = infoReader.g

if calledArg.ReflArgInfo.AutoQuote && isQuotedExprTy g calledArgTy && not (isQuotedExprTy g callerArgTy) then

destQuotedExprTy g calledArgTy, TypeDirectedConversionUsed.No, None

else

AdjustRequiredTypeForTypeDirectedConversions infoReader ad true false calledArgTy callerArgTy m

let inline tryDestOptionalTy g ty =

if isOptionTy g ty then

destOptionTy g ty

elif g.langVersion.SupportsFeature LanguageFeature.SupportValueOptionsAsOptionalParameters && isValueOptionTy g ty then

destValueOptionTy g ty

else

ty

let inline mkOptionalTy (g: TcGlobals) ty =

if g.langVersion.SupportsFeature LanguageFeature.SupportValueOptionsAsOptionalParameters && isValueOptionTy g ty then

mkValueOptionTy g ty

else

mkOptionTy g ty

let inline mkOptionalNone (g: TcGlobals) ty calledArgTy mMethExpr =

if g.langVersion.SupportsFeature LanguageFeature.SupportValueOptionsAsOptionalParameters && isValueOptionTy g ty then

mkValueNone g calledArgTy mMethExpr

else

mkNone g calledArgTy mMethExpr

let inline mkOptionalSome (g: TcGlobals) outerOptTy innerNonOptionalType expr mMethExpr =

if g.langVersion.SupportsFeature LanguageFeature.SupportValueOptionsAsOptionalParameters && isValueOptionTy g outerOptTy then

mkValueSome g innerNonOptionalType expr mMethExpr

else

mkSome g innerNonOptionalType expr mMethExpr

/// Adjust the called argument type to take into account whether the caller's argument is CSharpMethod(?arg=Some(3)) or CSharpMethod(arg=1)

let AdjustCalledArgTypeForOptionals (infoReader: InfoReader) ad enforceNullableOptionalsKnownTypes (calledArg: CalledArg) calledArgTy (callerArg: CallerArg<_>) =

let g = infoReader.g

let m = callerArg.Range

let callerArgTy = callerArg.CallerArgumentType

if callerArg.IsExplicitOptional then

match calledArg.OptArgInfo with

// CSharpMethod(?x = arg), optional C#-style argument, may have nullable type

| CallerSide _ ->

if g.langVersion.SupportsFeature LanguageFeature.NullableOptionalInterop then

let calledArgTy =

if isNullableTy g calledArgTy then

destNullableTy g calledArgTy

else

calledArgTy

mkOptionalTy g calledArgTy, TypeDirectedConversionUsed.No, None

else

calledArgTy, TypeDirectedConversionUsed.No, None

// FSharpMethod(?x = arg), optional F#-style argument

| CalleeSide ->

// In this case, the called argument will already have option type

calledArgTy, TypeDirectedConversionUsed.No, None

| NotOptional ->

// This condition represents an error but the error is raised in later processing

AdjustCalledArgTypeForTypeDirectedConversionsAndAutoQuote infoReader ad callerArgTy calledArgTy calledArg m

else

match calledArg.OptArgInfo with

// CSharpMethod(x = arg), non-optional C#-style argument, may have type Nullable<ty>.

| NotOptional when not (g.langVersion.SupportsFeature LanguageFeature.NullableOptionalInterop) ->

AdjustCalledArgTypeForTypeDirectedConversionsAndAutoQuote infoReader ad callerArgTy calledArgTy calledArg m

// The arg should have type ty. However for backwards compat, we also allow arg to have type Nullable<ty>

| NotOptional

// CSharpMethod(x = arg), optional C#-style argument, may have type Nullable<ty>.

| CallerSide _ ->

if isNullableTy g calledArgTy && g.langVersion.SupportsFeature LanguageFeature.NullableOptionalInterop then

// If inference has worked out it's a nullable then use this

if isNullableTy g callerArgTy then

calledArgTy, TypeDirectedConversionUsed.No, None

// If inference has worked out it's a struct (e.g. an int) then use this

elif isStructTy g callerArgTy then

AdjustRequiredTypeForTypeDirectedConversions infoReader ad true false calledArgTy callerArgTy m

// If neither and we are at the end of overload resolution then use the Nullable

elif enforceNullableOptionalsKnownTypes then

calledArgTy, TypeDirectedConversionUsed.No, None

// If at the beginning of inference then use a type variable.

else

match calledArg.OptArgInfo with

// If inference has not solved the kind of Nullable on the called arg and is not optional then use this.

| NotOptional when isTyparTy g (destNullableTy g calledArgTy) ->

calledArgTy, TypeDirectedConversionUsed.No, None

| _ ->

let compgenId = mkSynId range0 unassignedTyparName

let tpTy = mkTyparTy (Construct.NewTypar (TyparKind.Type, TyparRigidity.Flexible, SynTypar(compgenId, TyparStaticReq.None, true), false, TyparDynamicReq.No, [], false, false))

tpTy, TypeDirectedConversionUsed.No, None

else

AdjustCalledArgTypeForTypeDirectedConversionsAndAutoQuote infoReader ad callerArgTy calledArgTy calledArg m

// FSharpMethod(x = arg), optional F#-style argument, should have option type

| CalleeSide ->

let calledArgTy2 = tryDestOptionalTy g calledArgTy

AdjustCalledArgTypeForTypeDirectedConversionsAndAutoQuote infoReader ad callerArgTy calledArgTy2 calledArg m

// F# supports adhoc conversions at some specific points

//

// 1. The use of "(fun x y -> ...)" when a delegate it expected. This is not part of

// the ":>" coercion relationship or inference constraint problem as

// such, but is a special rule applied only to method arguments.

//

// The function AdjustCalledArgType detects this case based on types and needs to know that the type being applied

// is a function type.

//

// 2. The use of "(fun x y -> ...)" when Expression<delegate> it expected. This is similar to above.

//

// 3. Two ways to pass a value where a byref is expected. The first (default)

// is to use a reference cell, and the interior address is taken automatically

// The second is an explicit use of the "address-of" operator "&e". Here we detect the second case,

// and record the presence of the syntax "&e" in the pre-inferred actual type for the method argument.

// The function AdjustCalledArgType detects this and refuses to apply the default byref-to-ref transformation.

//

// 4. Other type directed conversions in 'AdjustRequiredTypeForTypeDirectedConversions'

//

// The function AdjustCalledArgType also adjusts for optional arguments.

let AdjustCalledArgType (infoReader: InfoReader) ad isConstraint enforceNullableOptionalsKnownTypes (calledArg: CalledArg) (callerArg: CallerArg<_>) =

let g = infoReader.g

// #424218 - when overload resolution is part of constraint solving - do not perform type-directed conversions

let calledArgTy = calledArg.CalledArgumentType

let callerArgTy = callerArg.CallerArgumentType

if isConstraint then

calledArgTy, TypeDirectedConversionUsed.No, None

else

// If the called method argument is an inref type, then the caller may provide a byref or value

if isInByrefTy g calledArgTy then

calledArgTy, TypeDirectedConversionUsed.No, None

// If the called method argument is a (non inref) byref type, then the caller may provide a byref or ref.

elif isByrefTy g calledArgTy then

if isByrefTy g callerArgTy then

calledArgTy, TypeDirectedConversionUsed.No, None

else

mkRefCellTy g (destByrefTy g calledArgTy), TypeDirectedConversionUsed.No, None

else

AdjustCalledArgTypeForOptionals infoReader ad enforceNullableOptionalsKnownTypes calledArg calledArgTy callerArg

//-------------------------------------------------------------------------

// CalledMeth

//-------------------------------------------------------------------------

type CalledMethArgSet<'T> =

{ /// The called arguments corresponding to "unnamed" arguments

UnnamedCalledArgs : CalledArg list

/// Any unnamed caller arguments not otherwise assigned

UnnamedCallerArgs : CallerArg<'T> list

/// The called "ParamArray" argument, if any

ParamArrayCalledArgOpt : CalledArg option

/// Any unnamed caller arguments assigned to a "param array" argument

ParamArrayCallerArgs : CallerArg<'T> list

/// Named args

AssignedNamedArgs: AssignedCalledArg<'T> list }

member x.NumUnnamedCallerArgs = x.UnnamedCallerArgs.Length

member x.NumAssignedNamedArgs = x.AssignedNamedArgs.Length

member x.NumUnnamedCalledArgs = x.UnnamedCalledArgs.Length

let MakeCalledArgs amap m (minfo: MethInfo) minst =

// Mark up the arguments with their position, so we can sort them back into order later

let paramDatas = minfo.GetParamDatas(amap, m, minst)

paramDatas |> List.mapiSquared (fun i j (ParamData(isParamArrayArg, isInArg, isOutArg, optArgInfo, callerInfoFlags, nmOpt, reflArgInfo, calledArgTy)) ->

{ Position=(i,j)

IsParamArray=isParamArrayArg

OptArgInfo=optArgInfo

CallerInfo = callerInfoFlags

IsInArg=isInArg

IsOutArg=isOutArg

ReflArgInfo=reflArgInfo

NameOpt=nmOpt

CalledArgumentType= changeWithNullReqTyToVariable amap.g calledArgTy})

/// <summary>

/// Represents the syntactic matching between a caller of a method and the called method.

///

/// The constructor takes all the information about the caller and called side of a method, match up named arguments, property setters etc.,

/// and returns a CalledMeth object for further analysis.

/// </summary>

/// <param name='infoReader'></param>

/// <param name='nameEnv'></param>

/// <param name='isCheckingAttributeCall'></param>

/// <param name='freshenMethInfo'>A function to help generate fresh type variables the property setters methods in generic classes</param>

/// <param name='m'>Range</param>

/// <param name='ad'>The access domain of the place where the call is taking place</param>

/// <param name='minfo'>The method we're attempting to call</param>

/// <param name='calledTyArgs'>The 'called type arguments', i.e. the fresh generic instantiation of the method we're attempting to call</param>

/// <param name='callerTyArgs'>The 'caller type arguments', i.e. user-given generic instantiation of the method we're attempting to call</param>

/// <param name='pinfoOpt'>The property related to the method we're attempting to call, if any</param>

/// <param name='callerObjArgTys'>The 'caller method arguments', i.e. a list of user-given parameter expressions, split between unnamed and named arguments</param>

/// <param name='callerArgs'>A function to help generate fresh type variables the property setters methods in generic classes</param>

/// <param name='allowParamArgs'>Do we allow the use of a param args method in its "expanded" form?</param>

/// <param name='allowOutAndOptArgs'>Do we allow the use of the transformation that converts out arguments as tuple returns?</param>

/// <param name='tyargsOpt'>Method parameters</param>

/// <param name='staticTyOpt'>The optional static type governing a constrained static virtual interface call</param>

type CalledMeth<'T>

(infoReader: InfoReader,

nameEnv: NameResolutionEnv option,

isCheckingAttributeCall,

freshenMethInfo,

m,

ad,

minfo: MethInfo,

calledTyArgs,

callerTyArgs: TType list,

pinfoOpt: PropInfo option,

callerObjArgTys: TType list,

callerArgs: CallerArgs<'T>,

allowParamArgs: bool,

allowOutAndOptArgs: bool,

tyargsOpt: TType option,

staticTyOpt: TType option)

=

let g = infoReader.g

let minfo =

match callerObjArgTys,minfo with

| objTy :: [], ILMeth _ when

g.checkNullness

&& minfo.DisplayName = "ToString"

&& minfo.IsNullary

&& (isAnonRecdTy g objTy || isRecdTy g objTy || isUnionTy g objTy || isMeasureableValueType g objTy)

&& ( typeEquiv g g.obj_ty_noNulls minfo.ApparentEnclosingAppType

|| typeEquiv g g.system_Value_ty minfo.ApparentEnclosingAppType) ->

MethInfoWithModifiedReturnType(minfo, g.string_ty)

| _ -> minfo

let methodRetTy = if minfo.IsConstructor then minfo.ApparentEnclosingType else minfo.GetFSharpReturnType(infoReader.amap, m, calledTyArgs)

let fullCurriedCalledArgs = MakeCalledArgs infoReader.amap m minfo calledTyArgs

do assert (fullCurriedCalledArgs.Length = fullCurriedCalledArgs.Length)

// Detect the special case where an indexer setter using param aray takes 'value' argument after ParamArray arguments

let isIndexerSetter =

match pinfoOpt with

| Some pinfo when pinfo.HasSetter && minfo.LogicalName.StartsWithOrdinal("set_") && (List.concat fullCurriedCalledArgs).Length >= 2 -> true

| _ -> false

// Deferred until needed - property lookups are expensive and most candidates get filtered out

let computeAssignedNamedProps (unassignedItems: CallerNamedArg<'T> list) =

let returnedObjTy = methodRetTy

unassignedItems |> List.splitChoose (fun (CallerNamedArg(id, e) as arg) ->

let nm = id.idText

let pinfos = GetIntrinsicPropInfoSetsOfType infoReader (Some nm) ad AllowMultiIntfInstantiations.Yes IgnoreOverrides id.idRange returnedObjTy

let pinfos = pinfos |> ExcludeHiddenOfPropInfos g infoReader.amap m

match pinfos with

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

let pminfo = pinfo.SetterMethod

let pminst = freshenMethInfo m pminfo

let propStaticTyOpt = if isTyparTy g returnedObjTy then Some returnedObjTy else None

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

| _ ->

let epinfos =

match nameEnv with

| Some ne -> ExtensionPropInfosOfTypeInScope ResultCollectionSettings.AllResults infoReader ne (Some nm) LookupIsInstance.Ambivalent ad m returnedObjTy

| _ -> []

match epinfos with

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

let pminfo = pinfo.SetterMethod

let pminst =

match minfo with

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

| _ -> freshenMethInfo m pminfo

let pminst =

match tyargsOpt with

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

| _ -> pminst

let propStaticTyOpt = if isTyparTy g returnedObjTy then Some returnedObjTy else None

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

| _ ->

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

| finfo :: _ when not finfo.IsStatic ->

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

| _ ->

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

| ValueSome rfinfo when not rfinfo.IsStatic ->

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

| _ ->

Choice2Of2(arg))

let argSetInfos =

(callerArgs.CurriedCallerArgs, fullCurriedCalledArgs) ||> List.map2 (fun (unnamedCallerArgs, namedCallerArgs) fullCalledArgs ->

// Find the arguments not given by name

let unnamedCalledArgs =

fullCalledArgs |> List.filter (fun calledArg ->

match calledArg.NameOpt with

| Some nm -> namedCallerArgs |> List.forall (fun (CallerNamedArg(nm2, _e)) -> nm.idText <> nm2.idText)

| None -> true)

// See if any of them are 'out' arguments being returned as part of a return tuple

let unnamedCalledArgs, unnamedCalledOptArgs, unnamedCalledOutArgs =

let nUnnamedCallerArgs = unnamedCallerArgs.Length

let nUnnamedCalledArgs = unnamedCalledArgs.Length

if allowOutAndOptArgs && nUnnamedCallerArgs < nUnnamedCalledArgs then

let unnamedCalledArgsTrimmed, unnamedCalledOptOrOutArgs = List.splitAt nUnnamedCallerArgs unnamedCalledArgs

// take the last ParamArray arg out, make it not break the optional/out params check

let unnamedCalledArgsTrimmed, unnamedCalledOptOrOutArgs =

match List.rev unnamedCalledOptOrOutArgs with

| h :: t when h.IsParamArray -> unnamedCalledArgsTrimmed @ [h], List.rev t

| _ -> unnamedCalledArgsTrimmed, unnamedCalledOptOrOutArgs

let isOpt x = x.OptArgInfo.IsOptional

let isOut x = x.IsOutArg && isByrefTy g x.CalledArgumentType

// Check if all args are optional or byref-out args, same arg cannot be both.

if unnamedCalledOptOrOutArgs |> List.forall (fun x -> isOpt x <> isOut x) then

let unnamedCalledOptArgs, unnamedCalledOutArgs = unnamedCalledOptOrOutArgs |> List.partition isOpt

unnamedCalledArgsTrimmed, unnamedCalledOptArgs, unnamedCalledOutArgs

// Otherwise drop them on the floor

else

unnamedCalledArgs, [], []

else

unnamedCalledArgs, [], []

let (unnamedCallerArgs, paramArrayCallerArgs), unnamedCalledArgs, paramArrayCalledArgOpt =

let nUnnamedCallerArgs = unnamedCallerArgs.Length

let nUnnamedCalledArgs = unnamedCalledArgs.Length

let supportsParamArgs =

allowParamArgs &&

nUnnamedCalledArgs >= 1 &&

nUnnamedCallerArgs >= nUnnamedCalledArgs-1 &&

let possibleParamArg =

if isIndexerSetter then

unnamedCalledArgs[nUnnamedCalledArgs-2]

else

unnamedCalledArgs[nUnnamedCalledArgs-1]

possibleParamArg.IsParamArray && isArray1DTy g possibleParamArg.CalledArgumentType

if supportsParamArgs then

if isIndexerSetter then

// Note, for an indexer setter nUnnamedCalledArgs will be at least two, and normally exactly 2

let unnamedCalledArgs2 =

unnamedCalledArgs[0..unnamedCalledArgs.Length-3] @

[unnamedCalledArgs[unnamedCalledArgs.Length-1]]

let paramArrayCalledArg =

unnamedCalledArgs[unnamedCalledArgs.Length-2]

let unnamedCallerArgs2 =

unnamedCallerArgs[0..nUnnamedCalledArgs-3] @

[unnamedCallerArgs[nUnnamedCallerArgs-1]]

let paramArrayCallerArgs =

unnamedCallerArgs[nUnnamedCalledArgs-2..nUnnamedCallerArgs-2]

(unnamedCallerArgs2, paramArrayCallerArgs), unnamedCalledArgs2, Some paramArrayCalledArg

else

let unnamedCalledArgs2, paramArrayCalledArg = List.frontAndBack unnamedCalledArgs

let unnamedCallerArgs2, paramArrayCallerArgs = List.splitAt (nUnnamedCalledArgs-1) unnamedCallerArgs

(unnamedCallerArgs2, paramArrayCallerArgs), unnamedCalledArgs2, Some paramArrayCalledArg

else

(unnamedCallerArgs, []), unnamedCalledArgs, None

let assignedNamedArgs =

fullCalledArgs |> List.choose (fun calledArg ->

match calledArg.NameOpt with

| Some nm ->

namedCallerArgs |> List.tryPick (fun (CallerNamedArg(nm2, callerArg)) ->

if nm.idText = nm2.idText then Some { NamedArgIdOpt = Some nm2; CallerArg=callerArg; CalledArg=calledArg }

else None)

| _ -> None)

let unassignedNamedItems =

namedCallerArgs |> List.filter (fun (CallerNamedArg(nm, _e)) ->

fullCalledArgs |> List.forall (fun calledArg ->

match calledArg.NameOpt with

| Some nm2 -> nm.idText <> nm2.idText

| None -> true))

let attributeAssignedNamedItems =

if isCheckingAttributeCall then

// The process for assigning names-->properties is substantially different for attribute specifications

// because it permits the bindings of names to immutable fields. So we use the old

// code for this.

unassignedNamedItems

else

[]

let names = System.Collections.Generic.HashSet<_>()

for CallerNamedArg(nm, _) in namedCallerArgs do

if not (names.Add nm.idText) then

errorR(Error(FSComp.SR.typrelNamedArgumentHasBeenAssignedMoreThenOnce nm.idText, m))

let argSet = { UnnamedCalledArgs=unnamedCalledArgs; UnnamedCallerArgs=unnamedCallerArgs; ParamArrayCalledArgOpt=paramArrayCalledArgOpt; ParamArrayCallerArgs=paramArrayCallerArgs; AssignedNamedArgs=assignedNamedArgs }

(argSet, unassignedNamedItems, attributeAssignedNamedItems, unnamedCalledOptArgs, unnamedCalledOutArgs))

let argSets = argSetInfos |> List.map (fun (x, _, _, _, _) -> x)

let unassignedNamedItemsRaw = argSetInfos |> List.collect (fun (_, x, _, _, _) -> x)

let attributeAssignedNamedItems = argSetInfos |> List.collect (fun (_, _, x, _, _) -> x)

let unnamedCalledOptArgs = argSetInfos |> List.collect (fun (_, _, _, x, _) -> x)

let unnamedCalledOutArgs = argSetInfos |> List.collect (fun (_, _, _, _, x) -> x)

let lazyAssignedNamedPropsAndUnassigned = lazy (computeAssignedNamedProps unassignedNamedItemsRaw)

let assignedNamedProps () = fst (lazyAssignedNamedPropsAndUnassigned.Value)

let unassignedNamedItems () = snd (lazyAssignedNamedPropsAndUnassigned.Value)

let hasNoUnassignedNamedItems () =

if isNil unassignedNamedItemsRaw then true // Fast path: no items to look up

else isNil (unassignedNamedItems()) // Slow path: force lazy and check

member x.infoReader = infoReader

member x.amap = infoReader.amap

/// The method we're attempting to call

member x.Method = minfo

/// The instantiation of the method we're attempting to call

member x.CalledTyArgs = calledTyArgs

member x.AllCalledArgs = fullCurriedCalledArgs

/// The instantiation of the method we're attempting to call

member x.CalledTyparInst =

let tps = minfo.FormalMethodTypars

if tps.Length = calledTyArgs.Length then mkTyparInst tps calledTyArgs else []

/// The formal instantiation of the method we're attempting to call

member x.CallerTyArgs = callerTyArgs

/// The types of the actual object arguments, if any

member x.CallerObjArgTys = callerObjArgTys

/// The argument analysis for each set of curried arguments

member x.ArgSets = argSets

/// The return type after implicit deference of byref returns is taken into account

member x.CalledReturnTypeAfterByrefDeref =

if isByrefTy g methodRetTy then destByrefTy g methodRetTy else methodRetTy

/// Return type after tupling of out args is taken into account

member x.CalledReturnTypeAfterOutArgTupling =

let retTy = x.CalledReturnTypeAfterByrefDeref

if isNil unnamedCalledOutArgs then

retTy

else

let outArgTys = unnamedCalledOutArgs |> List.map (fun calledArg -> destByrefTy g calledArg.CalledArgumentType)

if isUnitTy g retTy then mkRefTupledTy g outArgTys

else mkRefTupledTy g (retTy :: outArgTys)

/// Named setters

member x.AssignedItemSetters = assignedNamedProps()

/// The property related to the method we're attempting to call, if any

member x.AssociatedPropertyInfo = pinfoOpt

/// Unassigned args

member x.UnassignedNamedArgs = unassignedNamedItems()

/// Args assigned to specify values for attribute fields and properties (these are not necessarily "property sets")

member x.AttributeAssignedNamedArgs = attributeAssignedNamedItems

/// Unnamed called optional args: pass defaults for these

member x.UnnamedCalledOptArgs = unnamedCalledOptArgs

/// Unnamed called out args: return these as part of the return tuple

member x.UnnamedCalledOutArgs = unnamedCalledOutArgs

static member GetMethod (x: CalledMeth<'T>) = x.Method

member x.NumArgSets = x.ArgSets.Length

member x.HasOptionalArgs = not (isNil x.UnnamedCalledOptArgs)

member x.HasOutArgs = not (isNil x.UnnamedCalledOutArgs)

member x.UsesParamArrayConversion = x.ArgSets |> List.exists (fun argSet -> argSet.ParamArrayCalledArgOpt.IsSome)

member x.IsIndexParamArraySetter = isIndexerSetter && x.UsesParamArrayConversion

member x.ParamArrayCalledArgOpt = x.ArgSets |> List.tryPick (fun argSet -> argSet.ParamArrayCalledArgOpt)

member x.ParamArrayCallerArgs = x.ArgSets |> List.tryPick (fun argSet -> if Option.isSome argSet.ParamArrayCalledArgOpt then Some argSet.ParamArrayCallerArgs else None )

member x.GetParamArrayElementType() =

// turned as a method to avoid assert in variable inspector

assert x.UsesParamArrayConversion

x.ParamArrayCalledArgOpt.Value.CalledArgumentType |> destArrayTy x.amap.g

member x.NumAssignedProps = x.AssignedItemSetters.Length

member x.CalledObjArgTys(m) =

match x.Method.GetObjArgTypes(x.amap, m, x.CalledTyArgs) with

| [ thisArgTy ] when isByrefTy g thisArgTy -> [ destByrefTy g thisArgTy ]

| res -> res

member x.NumCalledTyArgs = x.CalledTyArgs.Length

member x.NumCallerTyArgs = x.CallerTyArgs.Length

member x.AssignsAllNamedArgs = hasNoUnassignedNamedItems()

member x.HasCorrectArity =

(x.NumCalledTyArgs = x.NumCallerTyArgs) &&

x.ArgSets |> List.forall (fun argSet -> argSet.NumUnnamedCalledArgs = argSet.NumUnnamedCallerArgs)

member x.HasCorrectGenericArity =

(x.NumCalledTyArgs = x.NumCallerTyArgs)

member x.IsAccessible(m, ad) =

IsMethInfoAccessible x.amap m ad x.Method

member x.HasCorrectObjArgs(m) =

x.CalledObjArgTys(m).Length = x.CallerObjArgTys.Length

member x.IsCandidate(m, ad) =

x.IsAccessible(m, ad) &&

x.HasCorrectArity &&

x.HasCorrectObjArgs(m) &&

x.AssignsAllNamedArgs

member x.AssignedUnnamedArgs =

// We use Seq.map2 to tolerate there being mismatched caller/called args

x.ArgSets |> List.map (fun argSet ->

(argSet.UnnamedCalledArgs, argSet.UnnamedCallerArgs) ||> Seq.map2 (fun calledArg callerArg ->

{ NamedArgIdOpt=None; CalledArg=calledArg; CallerArg=callerArg }) |> Seq.toList)

member x.AssignedNamedArgs =

x.ArgSets |> List.map (fun argSet -> argSet.AssignedNamedArgs)

member x.AllUnnamedCalledArgs = x.ArgSets |> List.collect (fun x -> x.UnnamedCalledArgs)

member x.TotalNumUnnamedCalledArgs = x.ArgSets |> List.sumBy (fun x -> x.NumUnnamedCalledArgs)

member x.TotalNumUnnamedCallerArgs = x.ArgSets |> List.sumBy (fun x -> x.NumUnnamedCallerArgs)

member x.TotalNumAssignedNamedArgs = x.ArgSets |> List.sumBy (fun x -> x.NumAssignedNamedArgs)

member x.OptionalStaticType = staticTyOpt

override x.ToString() = "call to " + minfo.ToString()

let NamesOfCalledArgs (calledArgs: CalledArg list) =

calledArgs |> List.choose (fun x -> x.NameOpt)

//-------------------------------------------------------------------------

// Helpers dealing with propagating type information in method overload resolution

//-------------------------------------------------------------------------

type ArgumentAnalysis =

| NoInfo

| ArgDoesNotMatch

| CallerLambdaHasArgTypes of TType list

| CalledArgMatchesType of adjustedCalledArgTy: TType * noEagerConstraintApplication: bool

let InferLambdaArgsForLambdaPropagation origRhsExpr =

let rec loop e =

match e with

| SynExpr.Lambda (body = rest) -> 1 + loop rest

| SynExpr.MatchLambda _ -> 1

| SynExpr.DotLambda (expr = body) -> 1 + loop body

| _ -> 0

loop origRhsExpr

let ExamineArgumentForLambdaPropagation (infoReader: InfoReader) ad noEagerConstraintApplication (arg: AssignedCalledArg<SynExpr>) =

let g = infoReader.g

// Find the explicit lambda arguments of the caller. Ignore parentheses.

let argExpr = match arg.CallerArg.Expr with SynExpr.Paren (x, _, _, _) -> x | x -> x

let countOfCallerLambdaArg = InferLambdaArgsForLambdaPropagation argExpr

// Adjust for Expression<_>, Func<_, _>, ...

let adjustedCalledArgTy, _, _ = AdjustCalledArgType infoReader ad false false arg.CalledArg arg.CallerArg

if countOfCallerLambdaArg > 0 then

// Decompose the explicit function type of the target

let calledLambdaArgTys, _calledLambdaRetTy = stripFunTy g adjustedCalledArgTy

if calledLambdaArgTys.Length >= countOfCallerLambdaArg then

// success

CallerLambdaHasArgTypes calledLambdaArgTys

elif isDelegateTy g (if isLinqExpressionTy g adjustedCalledArgTy then destLinqExpressionTy g adjustedCalledArgTy else adjustedCalledArgTy) then

// delegate arity mismatch

ArgDoesNotMatch

else

// not a function type on the called side - no information

NoInfo

else

// not a lambda on the caller side - push information from caller to called

CalledArgMatchesType(adjustedCalledArgTy, noEagerConstraintApplication)

let ExamineMethodForLambdaPropagation (g: TcGlobals) m (meth: CalledMeth<SynExpr>) ad =

let noEagerConstraintApplication =

MethInfoHasWellKnownAttributeSpec

g

m

{ ILFlag = WellKnownILAttributes.NoEagerConstraintApplicationAttribute

ValFlag = WellKnownValAttributes.NoEagerConstraintApplicationAttribute

AttribInfo = g.attrib_NoEagerConstraintApplicationAttribute }

meth.Method

// The logic associated with NoEagerConstraintApplicationAttribute is part of the

// Tasks and Resumable Code RFC

if noEagerConstraintApplication && not (g.langVersion.SupportsFeature LanguageFeature.ResumableStateMachines) then

errorR(Error(FSComp.SR.tcNoEagerConstraintApplicationAttribute(), m))

let unnamedInfo = meth.AssignedUnnamedArgs |> List.mapSquared (ExamineArgumentForLambdaPropagation meth.infoReader ad noEagerConstraintApplication)

let namedInfo = meth.AssignedNamedArgs |> List.mapSquared (fun arg -> (arg.NamedArgIdOpt.Value, ExamineArgumentForLambdaPropagation meth.infoReader ad noEagerConstraintApplication arg))

if unnamedInfo |> List.existsSquared (function CallerLambdaHasArgTypes _ -> true | _ -> false) ||

namedInfo |> List.existsSquared (function _, CallerLambdaHasArgTypes _ -> true | _ -> false) then

Some (unnamedInfo, namedInfo)

else

None

//-------------------------------------------------------------------------

// Additional helpers for building method calls and doing TAST generation

//-------------------------------------------------------------------------

/// Is this a 'base' call (in the sense of C#)

let IsBaseCall objArgs =

match objArgs with

| [Expr.Val (v, _, _)] when v.IsBaseVal -> true

| _ -> false

/// Compute whether we insert a 'coerce' on the 'this' pointer for an object model call

/// For example, when calling an interface method on a struct, or a method on a constrained

/// variable type.

let ComputeConstrainedCallInfo g amap m staticTyOpt args (minfo: MethInfo) =

match args, staticTyOpt with

| _, Some staticTy when not minfo.IsExtensionMember && not minfo.IsInstance && (minfo.IsAbstract || minfo.IsVirtual) -> Some staticTy

| objArgExpr :: _, _ when minfo.IsInstance && not minfo.IsExtensionMember ->

let methObjTy = minfo.ApparentEnclosingType

let objArgTy = tyOfExpr g objArgExpr

let objArgTy = if isByrefTy g objArgTy then destByrefTy g objArgTy else objArgTy

if TypeDefinitelySubsumesTypeNoCoercion 0 g amap m methObjTy objArgTy

// Constrained calls to class types can only ever be needed for the three class types that

// are base types of value types

|| (isClassTy g methObjTy &&

(not (typeEquiv g methObjTy g.system_Object_ty ||

typeEquiv g methObjTy g.system_Value_ty ||

typeEquiv g methObjTy g.system_Enum_ty))) then

None

else

// The object argument is a value type or variable type and the target method is an interface or System.Object

// type. A .NET 2.0 generic constrained call is required

Some objArgTy

| _ ->

None

/// Adjust the 'this' pointer before making a call

/// Take the address of a struct, and coerce to an interface/base/constraint type if necessary

let TakeObjAddrForMethodCall g amap (minfo: MethInfo) isMutable m staticTyOpt objArgs f =

let ccallInfo = ComputeConstrainedCallInfo g amap m staticTyOpt objArgs minfo

let wrap, objArgs =

match objArgs with

| [objArgExpr] ->

let hasCallInfo = ccallInfo.IsSome

let mustTakeAddress = hasCallInfo || minfo.ObjArgNeedsAddress(amap, m)

let objArgTy = tyOfExpr g objArgExpr

let isMutable =

match isMutable with

| DefinitelyMutates

| NeverMutates

| AddressOfOp -> isMutable

| PossiblyMutates ->

// Check to see if the method is read-only. Perf optimization.

// If there is an extension member whose first arg is an inref, we must return NeverMutates.