open System.Collections.Generic

open Internal.Utilities

open FSharp.Compiler

open FSharp.Compiler.AbstractIL.Internal

open FSharp.Compiler.AbstractIL.Internal.Library

open FSharp.Compiler.AbstractIL.Internal.Library.ResultOrException

open FSharp.Compiler.AbstractIL.Diagnostics

open FSharp.Compiler.AbstractIL.IL

open FSharp.Compiler.AccessibilityLogic

open FSharp.Compiler.AttributeChecking

open FSharp.Compiler.ErrorLogger

open FSharp.Compiler.CompilerGlobalState

open FSharp.Compiler.InfoReader

open FSharp.Compiler.Infos

open FSharp.Compiler.Features

open FSharp.Compiler.Lib

open FSharp.Compiler.PrettyNaming

open FSharp.Compiler.Range

open FSharp.Compiler.SyntaxTree

open FSharp.Compiler.SyntaxTreeOps

open FSharp.Compiler.TcGlobals

open FSharp.Compiler.TypedTree

open FSharp.Compiler.TypedTreeBasics

open FSharp.Compiler.TypedTreeOps

open FSharp.Compiler.Text

#if !NO_EXTENSIONTYPING

open FSharp.Compiler.ExtensionTyping

type NameResolver(g: TcGlobals,

amap: Import.ImportMap,

infoReader: InfoReader,

instantiationGenerator: (range -> Typars -> TypeInst)) =

/// Used to transform typars into new inference typars

// instantiationGenerator is a function to help us create the

// type parameters by copying them from type parameter specifications read

// from IL code.

//

// When looking up items in generic types we create a fresh instantiation

// of the type, i.e. instantiate the type with inference variables.

// This means the item is returned ready for use by the type inference engine

// without further freshening. However it does mean we end up plumbing 'instantiationGenerator'

// around a bit more than we would like to, which is a bit annoying.

member nr.InstantiationGenerator = instantiationGenerator

member nr.g = g

member nr.amap = amap

member nr.InfoReader = infoReader

member nr.languageSupportsNameOf = g.langVersion.SupportsFeature LanguageFeature.NameOf

let UnionCaseRefsInTycon (modref: ModuleOrNamespaceRef) (tycon: Tycon) =

tycon.UnionCasesAsList |> List.map (mkModuleUnionCaseRef modref tycon)

let UnionCaseRefsInModuleOrNamespace (modref: ModuleOrNamespaceRef) =

[ for x in modref.ModuleOrNamespaceType.AllEntities do yield! UnionCaseRefsInTycon modref x ]

let TryFindTypeWithUnionCase (modref: ModuleOrNamespaceRef) (id: Ident) =

modref.ModuleOrNamespaceType.AllEntities

|> QueueList.tryFind (fun tycon -> tycon.GetUnionCaseByName id.idText |> Option.isSome)

let TryFindTypeWithRecdField (modref: ModuleOrNamespaceRef) (id: Ident) =

modref.ModuleOrNamespaceType.AllEntities

|> QueueList.tryFind (fun tycon -> tycon.GetFieldByName id.idText |> Option.isSome)

let ActivePatternElemsOfValRef vref =

match TryGetActivePatternInfo vref with

| Some apinfo -> apinfo.ActiveTags |> List.mapi (fun i _ -> APElemRef(apinfo, vref, i))

| None -> []

let TryMkValRefInModRef modref vspec =

protectAssemblyExploration

None

(fun () -> Some (mkNestedValRef modref vspec))

let ActivePatternElemsOfVal modref vspec =

// If the assembly load set is incomplete then don't add anything to the table

match TryMkValRefInModRef modref vspec with

| None -> []

| Some vref -> ActivePatternElemsOfValRef vref

let ActivePatternElemsOfModuleOrNamespace (modref: ModuleOrNamespaceRef) : NameMap<ActivePatternElemRef> =

let mtyp = modref.ModuleOrNamespaceType

cacheOptRef mtyp.ActivePatternElemRefLookupTable (fun () ->

mtyp.AllValsAndMembers

|> Seq.collect (ActivePatternElemsOfVal modref)

|> Seq.fold (fun acc apref -> NameMap.add apref.Name apref acc) Map.empty)

let (|AbbrevOrAppTy|_|) (ty: TType) =

match stripTyparEqns ty with

| TType_app (tcref, _) -> Some tcref

| _ -> None

type ArgumentContainer =

/// The named argument is an argument of a method

| Method of MethInfo

/// The named argument is a static parameter to a provided type.

| Type of TyconRef

type Item =

/// Represents the resolution of a name to an F# value or function.

| Value of ValRef

/// Represents the resolution of a name to an F# union case.

| UnionCase of UnionCaseInfo * hasRequireQualifiedAccessAttr: bool

/// Represents the resolution of a name to an F# active pattern result.

| ActivePatternResult of ActivePatternInfo * TType * int * range

/// Represents the resolution of a name to an F# active pattern case within the body of an active pattern.

| ActivePatternCase of ActivePatternElemRef

/// Represents the resolution of a name to an F# exception definition.

| ExnCase of TyconRef

/// Represents the resolution of a name to an F# record or exception field.

| RecdField of RecdFieldInfo

/// Represents the resolution of a name to a union case field.

| UnionCaseField of UnionCaseInfo * fieldIndex: int

/// Represents the resolution of a name to a field of an anonymous record type.

| AnonRecdField of AnonRecdTypeInfo * TTypes * int * range

// The following are never in the items table but are valid results of binding

// an identifier in different circumstances.

/// Represents the resolution of a name at the point of its own definition.

| NewDef of Ident

/// Represents the resolution of a name to a .NET field

| ILField of ILFieldInfo

/// Represents the resolution of a name to an event

| Event of EventInfo

/// Represents the resolution of a name to a property

| Property of string * PropInfo list

/// Represents the resolution of a name to a group of methods.

| MethodGroup of displayName: string * methods: MethInfo list * uninstantiatedMethodOpt: MethInfo option

/// Represents the resolution of a name to a constructor

| CtorGroup of string * MethInfo list

/// Represents the resolution of a name to the fake constructor simulated for an interface type.

| FakeInterfaceCtor of TType

/// Represents the resolution of a name to a delegate

| DelegateCtor of TType

/// Represents the resolution of a name to a group of types

| Types of string * TType list

/// CustomOperation(nm, helpText, methInfo)

///

/// Used to indicate the availability or resolution of a custom query operation such as 'sortBy' or 'where' in computation expression syntax

| CustomOperation of string * (unit -> string option) * MethInfo option

/// Represents the resolution of a name to a custom builder in the F# computation expression syntax

| CustomBuilder of string * ValRef

/// Represents the resolution of a name to a type variable

| TypeVar of string * Typar

/// Represents the resolution of a name to a module or namespace

| ModuleOrNamespaces of ModuleOrNamespaceRef list

/// Represents the resolution of a name to an operator

| ImplicitOp of Ident * TraitConstraintSln option ref

/// Represents the resolution of a name to a named argument

| ArgName of Ident * TType * ArgumentContainer option

/// Represents the resolution of a name to a named property setter

| SetterArg of Ident * Item

/// Represents the potential resolution of an unqualified name to a type.

| UnqualifiedType of TyconRef list

static member MakeMethGroup (nm, minfos: MethInfo list) =

let minfos = minfos |> List.sortBy (fun minfo -> minfo.NumArgs |> List.sum)

Item.MethodGroup (nm, minfos, None)

static member MakeCtorGroup (nm, minfos: MethInfo list) =

let minfos = minfos |> List.sortBy (fun minfo -> minfo.NumArgs |> List.sum)

Item.CtorGroup (nm, minfos)

member d.DisplayName =

match d with

| Item.Value v -> v.DisplayName

| Item.ActivePatternCase apref -> apref.Name

| Item.UnionCase(uinfo, _) -> DecompileOpName uinfo.UnionCase.DisplayName

| Item.ExnCase tcref -> tcref.LogicalName

| Item.RecdField rfinfo -> DecompileOpName rfinfo.RecdField.Name

| Item.UnionCaseField (uci, fieldIndex) -> uci.UnionCase.GetFieldByIndex(fieldIndex).Name

| Item.AnonRecdField (anonInfo, _tys, i, _m) -> anonInfo.SortedNames.[i]

| Item.NewDef id -> id.idText

| Item.ILField finfo -> finfo.FieldName

| Item.Event einfo -> einfo.EventName

| Item.Property(_, FSProp(_, _, Some v, _) :: _)

| Item.Property(_, FSProp(_, _, _, Some v) :: _) -> v.DisplayName

| Item.Property(nm, _) -> PrettyNaming.DemangleOperatorName nm

| Item.MethodGroup(_, (FSMeth(_, _, v, _) :: _), _) -> v.DisplayName

| Item.MethodGroup(nm, _, _) -> PrettyNaming.DemangleOperatorName nm

| Item.CtorGroup(nm, _) -> DemangleGenericTypeName nm

| Item.FakeInterfaceCtor (AbbrevOrAppTy tcref)

| Item.DelegateCtor (AbbrevOrAppTy tcref) -> DemangleGenericTypeName tcref.DisplayName

| Item.Types(nm, _) -> DemangleGenericTypeName nm

| Item.UnqualifiedType(tcref :: _) -> tcref.DisplayName

| Item.TypeVar (nm, _) -> nm

| Item.ModuleOrNamespaces(modref :: _) -> modref.DemangledModuleOrNamespaceName

| Item.ArgName (id, _, _) -> id.idText

| Item.SetterArg (id, _) -> id.idText

| Item.CustomOperation (customOpName, _, _) -> customOpName

| Item.CustomBuilder (nm, _) -> nm

| _ -> ""

let valRefHash (vref: ValRef) =

match vref.TryDeref with

| ValueNone -> 0

| ValueSome v -> LanguagePrimitives.PhysicalHash v

type ItemWithInst =

{ Item: Item

TyparInst: TyparInst }

let ItemWithNoInst item = ({ Item = item; TyparInst = emptyTyparInst } : ItemWithInst)

let (|ItemWithInst|) (x: ItemWithInst) = (x.Item, x.TyparInst)

type FieldResolution = FieldResolution of RecdFieldRef * bool

type ExtensionMember =

/// F#-style Extrinsic extension member, defined in F# code

| FSExtMem of ValRef * ExtensionMethodPriority

/// ILExtMem(declaringTyconRef, ilMetadata, pri)

///

/// IL-style extension member, backed by some kind of method with an [<Extension>] attribute

| ILExtMem of TyconRef * MethInfo * ExtensionMethodPriority

/// Check if two extension members refer to the same definition

static member Equality g e1 e2 =

match e1, e2 with

| FSExtMem (vref1, _), FSExtMem (vref2, _) -> valRefEq g vref1 vref2

| ILExtMem (_, md1, _), ILExtMem (_, md2, _) -> MethInfo.MethInfosUseIdenticalDefinitions md1 md2

| _ -> false

static member Hash e1 =

match e1 with

| FSExtMem(vref, _) -> valRefHash vref

| ILExtMem(_, m, _) ->

match m with

| ILMeth(_, ilmeth, _) -> LanguagePrimitives.PhysicalHash ilmeth.RawMetadata

| FSMeth(_, _, vref, _) -> valRefHash vref

| _ -> 0

static member Comparer g = HashIdentity.FromFunctions ExtensionMember.Hash (ExtensionMember.Equality g)

/// Describes the sequence order of the introduction of an extension method. Extension methods that are introduced

/// later through 'open' get priority in overload resolution.

member x.Priority =

match x with

| FSExtMem (_, pri) -> pri

| ILExtMem (_, _, pri) -> pri

type FullyQualifiedFlag =

/// Only resolve full paths

| FullyQualified

/// Resolve any paths accessible via 'open'

| OpenQualified

type UnqualifiedItems = LayeredMap<string, Item>

type NameResolutionEnv =

{ /// Display environment information for output

eDisplayEnv: DisplayEnv

/// Values, functions, methods and other items available by unqualified name

eUnqualifiedItems: UnqualifiedItems

/// Data Tags and Active Pattern Tags available by unqualified name

ePatItems: NameMap<Item>

/// Modules accessible via "." notation. Note this is a multi-map.

/// Adding a module abbreviation adds it a local entry to this List.map.

/// Likewise adding a ccu or opening a path adds entries to this List.map.

/// REVIEW (old comment)

/// "The boolean flag is means the namespace or module entry shouldn't 'really' be in the

/// map, and if it is ever used to resolve a name then we give a warning.

/// This is used to give warnings on unqualified namespace accesses, e.g.

/// open System

/// open Collections <--- give a warning

/// let v = new Collections.Generic.List<int>() <--- give a warning"

eModulesAndNamespaces: NameMultiMap<ModuleOrNamespaceRef>

/// Fully qualified modules and namespaces. 'open' does not change this.

eFullyQualifiedModulesAndNamespaces: NameMultiMap<ModuleOrNamespaceRef>

/// RecdField labels in scope. RecdField labels are those where type are inferred

/// by label rather than by known type annotation.

/// Bools indicate if from a record, where no warning is given on indeterminate lookup

eFieldLabels: NameMultiMap<RecdFieldRef>

/// Tycons indexed by the various names that may be used to access them, e.g.

/// "List" --> multiple TyconRef's for the various tycons accessible by this name.

/// "List`1" --> TyconRef

eTyconsByAccessNames: LayeredMultiMap<string, TyconRef>

eFullyQualifiedTyconsByAccessNames: LayeredMultiMap<string, TyconRef>

/// Tycons available by unqualified, demangled names (i.e. (List, 1) --> TyconRef)

eTyconsByDemangledNameAndArity: LayeredMap<NameArityPair, TyconRef>

/// Tycons available by unqualified, demangled names (i.e. (List, 1) --> TyconRef)

eFullyQualifiedTyconsByDemangledNameAndArity: LayeredMap<NameArityPair, TyconRef>

/// Extension members by type and name

eIndexedExtensionMembers: TyconRefMultiMap<ExtensionMember>

/// Other extension members unindexed by type

eUnindexedExtensionMembers: ExtensionMember list

/// Typars (always available by unqualified names). Further typars can be

/// in the tpenv, a structure folded through each top-level definition.

eTypars: NameMap<Typar>

}

/// The initial, empty name resolution environment. The mother of all things.

static member Empty g =

{ eDisplayEnv = DisplayEnv.Empty g

eModulesAndNamespaces = Map.empty

eFullyQualifiedModulesAndNamespaces = Map.empty

eFieldLabels = Map.empty

eUnqualifiedItems = LayeredMap.Empty

ePatItems = Map.empty

eTyconsByAccessNames = LayeredMultiMap.Empty

eTyconsByDemangledNameAndArity = LayeredMap.Empty

eFullyQualifiedTyconsByAccessNames = LayeredMultiMap.Empty

eFullyQualifiedTyconsByDemangledNameAndArity = LayeredMap.Empty

eIndexedExtensionMembers = TyconRefMultiMap<_>.Empty

eUnindexedExtensionMembers = []

eTypars = Map.empty }

member nenv.DisplayEnv = nenv.eDisplayEnv

member nenv.FindUnqualifiedItem nm = nenv.eUnqualifiedItems.[nm]

/// Get the table of types, indexed by name and arity

member nenv.TyconsByDemangledNameAndArity fq =

match fq with

| FullyQualified -> nenv.eFullyQualifiedTyconsByDemangledNameAndArity

| OpenQualified -> nenv.eTyconsByDemangledNameAndArity

/// Get the table of types, indexed by name

member nenv.TyconsByAccessNames fq =

match fq with

| FullyQualified -> nenv.eFullyQualifiedTyconsByAccessNames

| OpenQualified -> nenv.eTyconsByAccessNames

/// Get the table of modules and namespaces

member nenv.ModulesAndNamespaces fq =

match fq with

| FullyQualified -> nenv.eFullyQualifiedModulesAndNamespaces

| OpenQualified -> nenv.eModulesAndNamespaces

type ResultCollectionSettings =

| AllResults

| AtMostOneResult

let NextExtensionMethodPriority() = uint64 (newStamp())

let private GetCSharpStyleIndexedExtensionMembersForTyconRef (amap: Import.ImportMap) m (tcrefOfStaticClass: TyconRef) =

let g = amap.g

// Type must be non-generic and have 'Extension' attribute

if isNil(tcrefOfStaticClass.Typars m) && TyconRefHasAttribute g m g.attrib_ExtensionAttribute tcrefOfStaticClass then

let pri = NextExtensionMethodPriority()

let ty = generalizedTyconRef tcrefOfStaticClass

// Get the 'plain' methods, not interpreted as extension methods

let minfos = GetImmediateIntrinsicMethInfosOfType (None, AccessorDomain.AccessibleFromSomeFSharpCode) g amap m ty

[ for minfo in minfos do

// Method must be static, have 'Extension' attribute, must not be curried, must have at least one argument

if not minfo.IsInstance &&

not minfo.IsExtensionMember &&

(match minfo.NumArgs with [x] when x >= 1 -> true | _ -> false) &&

MethInfoHasAttribute g m g.attrib_ExtensionAttribute minfo

then

let ilExtMem = ILExtMem (tcrefOfStaticClass, minfo, pri)

// The results are indexed by the TyconRef of the first 'this' argument, if any.

// So we need to go and crack the type of the 'this' argument.

//

// This is convoluted because we only need the ILTypeRef of the first argument, and we don't

// want to read any other metadata as it can trigger missing-assembly errors. It turns out ImportILTypeRef

// is less eager in reading metadata than GetParamTypes.

//

// We don't use the index for the IL extension method for tuple of F# function types (e.g. if extension

// methods for tuple occur in C# code)

let thisTyconRef =

try

let rs =

match metadataOfTycon tcrefOfStaticClass.Deref, minfo with

| ILTypeMetadata (TILObjectReprData(scoref, _, _)), ILMeth(_, ILMethInfo(_, _, _, ilMethod, _), _) ->

match ilMethod.ParameterTypes with

| firstTy :: _ ->

match firstTy with

| ILType.Boxed tspec | ILType.Value tspec ->

let tref = (tspec |> rescopeILTypeSpec scoref).TypeRef

if Import.CanImportILTypeRef amap m tref then

let tcref = tref |> Import.ImportILTypeRef amap m

if isCompiledTupleTyconRef g tcref || tyconRefEq g tcref g.fastFunc_tcr then None

else Some tcref

else None

| _ -> None

| _ -> None

| _ ->

// The results are indexed by the TyconRef of the first 'this' argument, if any.

// So we need to go and crack the type of the 'this' argument.

let thisTy = minfo.GetParamTypes(amap, m, generalizeTypars minfo.FormalMethodTypars).Head.Head

match thisTy with

| AppTy g (tcrefOfTypeExtended, _) when not (isByrefTy g thisTy) -> Some tcrefOfTypeExtended

| _ -> None

Some rs

with e -> // Import of the ILType may fail, if so report the error and skip on

errorRecovery e m

None

match thisTyconRef with

| None -> ()

| Some (Some tcref) -> yield Choice1Of2(tcref, ilExtMem)

| Some None -> yield Choice2Of2 ilExtMem ]

else

[]

let IntrinsicPropInfosOfTypeInScope (infoReader: InfoReader) optFilter ad findFlag m ty =

let g = infoReader.g

let amap = infoReader.amap

let pinfos = GetIntrinsicPropInfoSetsOfType infoReader optFilter ad AllowMultiIntfInstantiations.Yes findFlag m ty

let pinfos = pinfos |> ExcludeHiddenOfPropInfos g amap m

pinfos

let SelectPropInfosFromExtMembers (infoReader: InfoReader) ad optFilter declaringTy m extMemInfos =

let g = infoReader.g

let amap = infoReader.amap

// NOTE: multiple "open"'s push multiple duplicate values into eIndexedExtensionMembers, hence use a set.

let seen = HashSet(ExtensionMember.Comparer g)

let propCollector = new PropertyCollector(g, amap, m, declaringTy, optFilter, ad)

for emem in extMemInfos do

if seen.Add emem then

match emem with

| FSExtMem (vref, _pri) ->

match vref.MemberInfo with

| None -> ()

| Some membInfo -> propCollector.Collect(membInfo, vref)

| ILExtMem _ ->

// No extension properties coming from .NET

()

propCollector.Close()

let ExtensionPropInfosOfTypeInScope collectionSettings (infoReader:InfoReader) (nenv: NameResolutionEnv) optFilter ad m ty =

let g = infoReader.g

let extMemsDangling = SelectPropInfosFromExtMembers infoReader ad optFilter ty m nenv.eUnindexedExtensionMembers

if collectionSettings = ResultCollectionSettings.AtMostOneResult && not (isNil extMemsDangling) then

extMemsDangling

else

let extMemsFromHierarchy =

infoReader.GetEntireTypeHierarchy(AllowMultiIntfInstantiations.Yes, m, ty)

|> List.collect (fun ty ->

match tryTcrefOfAppTy g ty with

| ValueSome tcref ->

let extMemInfos = nenv.eIndexedExtensionMembers.Find tcref

SelectPropInfosFromExtMembers infoReader ad optFilter ty m extMemInfos

| _ -> [])

extMemsDangling @ extMemsFromHierarchy

let AllPropInfosOfTypeInScope collectionSettings infoReader nenv optFilter ad findFlag m ty =

IntrinsicPropInfosOfTypeInScope infoReader optFilter ad findFlag m ty

@ ExtensionPropInfosOfTypeInScope collectionSettings infoReader nenv optFilter ad m ty

let IntrinsicMethInfosOfType (infoReader: InfoReader) optFilter ad allowMultiIntfInst findFlag m ty =

let g = infoReader.g

let amap = infoReader.amap

let minfos = GetIntrinsicMethInfoSetsOfType infoReader optFilter ad allowMultiIntfInst findFlag m ty

let minfos = minfos |> ExcludeHiddenOfMethInfos g amap m

minfos

let TrySelectExtensionMethInfoOfILExtMem m amap apparentTy (actualParent, minfo, pri) =

match minfo with

| ILMeth(_,ilminfo,_) ->

MethInfo.CreateILExtensionMeth (amap, m, apparentTy, actualParent, Some pri, ilminfo.RawMetadata) |> Some

// F#-defined IL-style extension methods are not seen as extension methods in F# code

| FSMeth(g,_,vref,_) ->

FSMeth(g, apparentTy, vref, Some pri) |> Some

#if !NO_EXTENSIONTYPING

// // Provided extension methods are not yet supported

| ProvidedMeth(amap,providedMeth,_,m) ->

ProvidedMeth(amap, providedMeth, Some pri,m) |> Some

| DefaultStructCtor _ ->

None

let SelectMethInfosFromExtMembers (infoReader: InfoReader) optFilter apparentTy m extMemInfos =

let g = infoReader.g

// NOTE: multiple "open"'s push multiple duplicate values into eIndexedExtensionMembers

let seen = HashSet(ExtensionMember.Comparer g)

[

for emem in extMemInfos do

if seen.Add emem then

match emem with

| FSExtMem (vref, pri) ->

match vref.MemberInfo with

| None -> ()

| Some membInfo ->

match TrySelectMemberVal g optFilter apparentTy (Some pri) membInfo vref with

| Some m -> yield m

| _ -> ()

| ILExtMem (actualParent, minfo, pri) when (match optFilter with None -> true | Some nm -> nm = minfo.LogicalName) ->

// Make a reference to the type containing the extension members

match TrySelectExtensionMethInfoOfILExtMem m infoReader.amap apparentTy (actualParent, minfo, pri) with

| Some minfo -> yield minfo

| None -> ()

| _ -> ()

]

let ExtensionMethInfosOfTypeInScope (collectionSettings: ResultCollectionSettings) (infoReader: InfoReader) (nenv: NameResolutionEnv) optFilter m ty =

let extMemsDangling = SelectMethInfosFromExtMembers infoReader optFilter ty m nenv.eUnindexedExtensionMembers

if collectionSettings = ResultCollectionSettings.AtMostOneResult && not (isNil extMemsDangling) then

extMemsDangling

else

let extMemsFromHierarchy =

infoReader.GetEntireTypeHierarchy(AllowMultiIntfInstantiations.Yes, m, ty)

|> List.collect (fun ty ->

let g = infoReader.g

match tryTcrefOfAppTy g ty with

| ValueSome tcref ->

let extValRefs = nenv.eIndexedExtensionMembers.Find tcref

SelectMethInfosFromExtMembers infoReader optFilter ty m extValRefs

| _ -> [])

extMemsDangling @ extMemsFromHierarchy

let AllMethInfosOfTypeInScope collectionSettings infoReader nenv optFilter ad findFlag m ty =

let intrinsic = IntrinsicMethInfosOfType infoReader optFilter ad AllowMultiIntfInstantiations.Yes findFlag m ty

if collectionSettings = ResultCollectionSettings.AtMostOneResult && not (isNil intrinsic) then

intrinsic

else

intrinsic @ ExtensionMethInfosOfTypeInScope collectionSettings infoReader nenv optFilter m ty

type BulkAdd = Yes | No

let AddValRefsToItems (bulkAddMode: BulkAdd) (eUnqualifiedItems: UnqualifiedItems) (vrefs: ValRef[]) =

// Object model members are not added to the unqualified name resolution environment

let vrefs = vrefs |> Array.filter (fun vref -> not vref.IsMember)

if vrefs.Length = 0 then eUnqualifiedItems else

match bulkAddMode with

| BulkAdd.Yes ->

eUnqualifiedItems.AddAndMarkAsCollapsible(vrefs |> Array.map (fun vref -> KeyValuePair(vref.LogicalName, Item.Value vref)))

| BulkAdd.No ->

assert (vrefs.Length = 1)

let vref = vrefs.[0]

eUnqualifiedItems.Add (vref.LogicalName, Item.Value vref)

let AddValRefToExtensionMembers pri (eIndexedExtensionMembers: TyconRefMultiMap<_>) (vref: ValRef) =

if vref.IsMember && vref.IsExtensionMember then

eIndexedExtensionMembers.Add (vref.MemberApparentEntity, FSExtMem (vref, pri))

else

eIndexedExtensionMembers

let AddFakeNamedValRefToNameEnv nm nenv vref =

{nenv with eUnqualifiedItems = nenv.eUnqualifiedItems.Add (nm, Item.Value vref) }

let AddFakeNameToNameEnv nm nenv item =

{nenv with eUnqualifiedItems = nenv.eUnqualifiedItems.Add (nm, item) }

let AddValRefsToActivePatternsNameEnv ePatItems (vref: ValRef) =

let ePatItems =

(ActivePatternElemsOfValRef vref, ePatItems)

||> List.foldBack (fun apref tab ->

NameMap.add apref.Name (Item.ActivePatternCase apref) tab)

// Add literal constants to the environment available for resolving items in patterns

let ePatItems =

match vref.LiteralValue with

| None -> ePatItems

| Some _ -> NameMap.add vref.LogicalName (Item.Value vref) ePatItems

ePatItems

let AddValRefsToNameEnvWithPriority bulkAddMode pri nenv (vrefs: ValRef []) =

if vrefs.Length = 0 then nenv else

{ nenv with

eUnqualifiedItems = AddValRefsToItems bulkAddMode nenv.eUnqualifiedItems vrefs

eIndexedExtensionMembers = (nenv.eIndexedExtensionMembers, vrefs) ||> Array.fold (AddValRefToExtensionMembers pri)

ePatItems = (nenv.ePatItems, vrefs) ||> Array.fold AddValRefsToActivePatternsNameEnv }

let AddValRefToNameEnv nenv (vref: ValRef) =

let pri = NextExtensionMethodPriority()

{ nenv with

eUnqualifiedItems =

if not vref.IsMember then

nenv.eUnqualifiedItems.Add (vref.LogicalName, Item.Value vref)

else

nenv.eUnqualifiedItems

eIndexedExtensionMembers = AddValRefToExtensionMembers pri nenv.eIndexedExtensionMembers vref

ePatItems = AddValRefsToActivePatternsNameEnv nenv.ePatItems vref }

let AddActivePatternResultTagsToNameEnv (apinfo: PrettyNaming.ActivePatternInfo) nenv ty m =

if List.isEmpty apinfo.Names then nenv else

let apresl = List.indexed apinfo.Names

{ nenv with

eUnqualifiedItems =

(apresl, nenv.eUnqualifiedItems)

||> List.foldBack (fun (j, nm) acc -> acc.Add(nm, Item.ActivePatternResult(apinfo, ty, j, m))) }

let GeneralizeUnionCaseRef (ucref: UnionCaseRef) =

UnionCaseInfo (fst (generalizeTyconRef ucref.TyconRef), ucref)

let AddTyconsByDemangledNameAndArity (bulkAddMode: BulkAdd) (tcrefs: TyconRef[]) (tab: LayeredMap<NameArityPair, TyconRef>) =

if tcrefs.Length = 0 then tab else

let entries =

tcrefs

|> Array.map (fun tcref -> Construct.KeyTyconByDemangledNameAndArity tcref.LogicalName tcref.TyparsNoRange tcref)

match bulkAddMode with

| BulkAdd.Yes -> tab.AddAndMarkAsCollapsible entries

| BulkAdd.No -> (tab, entries) ||> Array.fold (fun tab (KeyValue(k, v)) -> tab.Add(k, v))

let AddTyconByAccessNames bulkAddMode (tcrefs: TyconRef[]) (tab: LayeredMultiMap<string, _>) =

if tcrefs.Length = 0 then tab else

let entries =

tcrefs

|> Array.collect (fun tcref -> Construct.KeyTyconByAccessNames tcref.LogicalName tcref)

match bulkAddMode with

| BulkAdd.Yes -> tab.AddAndMarkAsCollapsible entries

| BulkAdd.No -> (tab, entries) ||> Array.fold (fun tab (KeyValue(k, v)) -> tab.Add (k, v))

let AddRecdField (rfref: RecdFieldRef) tab = NameMultiMap.add rfref.FieldName rfref tab

let AddUnionCases1 (tab: Map<_, _>) (ucrefs: UnionCaseRef list) =

(tab, ucrefs) ||> List.fold (fun acc ucref ->

let item = Item.UnionCase(GeneralizeUnionCaseRef ucref, false)

acc.Add (ucref.CaseName, item))

let AddUnionCases2 bulkAddMode (eUnqualifiedItems: UnqualifiedItems) (ucrefs: UnionCaseRef list) =

match bulkAddMode with

| BulkAdd.Yes ->

let items =

ucrefs |> Array.ofList |> Array.map (fun ucref ->

let item = Item.UnionCase(GeneralizeUnionCaseRef ucref, false)

KeyValuePair(ucref.CaseName, item))

eUnqualifiedItems.AddAndMarkAsCollapsible items

| BulkAdd.No ->

(eUnqualifiedItems, ucrefs) ||> List.fold (fun acc ucref ->

let item = Item.UnionCase(GeneralizeUnionCaseRef ucref, false)

acc.Add (ucref.CaseName, item))

let AddStaticContentOfTyconRefToNameEnv (g:TcGlobals) (amap: Import.ImportMap) ad m (nenv: NameResolutionEnv) (tcref:TyconRef) =

// If OpenStaticClasses is not enabled then don't do this

if amap.g.langVersion.SupportsFeature LanguageFeature.OpenStaticClasses then

let ty = generalizedTyconRef tcref

let infoReader = InfoReader(g,amap)

let items =

[| let methGroups =

AllMethInfosOfTypeInScope ResultCollectionSettings.AllResults infoReader nenv None ad PreferOverrides m ty

|> List.groupBy (fun m -> m.LogicalName)

for (methName, methGroup) in methGroups do

let methGroup = methGroup |> List.filter (fun m -> not m.IsInstance && not m.IsClassConstructor)

if not methGroup.IsEmpty then

yield KeyValuePair(methName, Item.MethodGroup(methName, methGroup, None))

let propInfos =

AllPropInfosOfTypeInScope ResultCollectionSettings.AllResults infoReader nenv None ad PreferOverrides m ty

|> List.groupBy (fun m -> m.PropertyName)

for (propName, propInfos) in propInfos do

let propInfos = propInfos |> List.filter (fun m -> m.IsStatic)

for propInfo in propInfos do

yield KeyValuePair(propName , Item.Property(propName,[propInfo]))

let fields =

infoReader.GetILFieldInfosOfType(None, ad, m, ty)

|> List.groupBy (fun f -> f.FieldName)

for (fieldName, fieldInfos) in fields do

let fieldInfos = fieldInfos |> List.filter (fun fi -> fi.IsStatic)

for fieldInfo in fieldInfos do

yield KeyValuePair(fieldName, Item.ILField(fieldInfo))

|]

{ nenv with eUnqualifiedItems = nenv.eUnqualifiedItems.AddAndMarkAsCollapsible items }

else

nenv

let private AddPartsOfTyconRefToNameEnv bulkAddMode ownDefinition (g: TcGlobals) amap ad m nenv (tcref: TyconRef) =

let isIL = tcref.IsILTycon

let ucrefs = if isIL then [] else tcref.UnionCasesAsList |> List.map tcref.MakeNestedUnionCaseRef

let flds = if isIL then [| |] else tcref.AllFieldsArray

let eIndexedExtensionMembers, eUnindexedExtensionMembers =

let ilStyleExtensionMeths = GetCSharpStyleIndexedExtensionMembersForTyconRef amap m tcref

((nenv.eIndexedExtensionMembers, nenv.eUnindexedExtensionMembers), ilStyleExtensionMeths) ||> List.fold (fun (tab1, tab2) extMemInfo ->

match extMemInfo with

| Choice1Of2 (tcref, extMemInfo) -> tab1.Add (tcref, extMemInfo), tab2

| Choice2Of2 extMemInfo -> tab1, extMemInfo :: tab2)

let isILOrRequiredQualifiedAccess = isIL || (not ownDefinition && HasFSharpAttribute g g.attrib_RequireQualifiedAccessAttribute tcref.Attribs)

let eFieldLabels =

if isILOrRequiredQualifiedAccess || not tcref.IsRecordTycon || flds.Length = 0 then

nenv.eFieldLabels

else

(nenv.eFieldLabels, flds) ||> Array.fold (fun acc f ->

if f.IsStatic || f.IsCompilerGenerated then acc

else AddRecdField (tcref.MakeNestedRecdFieldRef f) acc)

let eUnqualifiedItems =

let tab = nenv.eUnqualifiedItems

// add the type name for potential use as a constructor

// The rules are

// - The unqualified lookup table in the environment can contain map names to a set of type names (the set of type names is a new kind of "item").

// - When the contents of a type definition is added to the environment, an entry is added in this table for all class and struct types.

// - When opening a module, types are added first to the environment, then values, then auto-opened sub-modules.

// - When a value is added by an "open" previously available type names will become inaccessible by this table.

let tab =

// This may explore into an unreferenced assembly if the name

// is a type abbreviation. If it does, assume the name does not

// have a constructor.

let mayHaveConstruction =

protectAssemblyExploration

false

(fun () ->

let ty = generalizedTyconRef tcref

isClassTy g ty || isStructTy g ty)

if mayHaveConstruction then

tab.LinearTryModifyThenLaterFlatten (tcref.DisplayName, (fun prev ->

match prev with

| Some (Item.UnqualifiedType tcrefs) -> Item.UnqualifiedType (tcref :: tcrefs)

| _ -> Item.UnqualifiedType [tcref]))

else

tab

let tab =

if isILOrRequiredQualifiedAccess || List.isEmpty ucrefs then

tab

else

AddUnionCases2 bulkAddMode tab ucrefs

tab

let ePatItems =

if isILOrRequiredQualifiedAccess || List.isEmpty ucrefs then

nenv.ePatItems

else

AddUnionCases1 nenv.ePatItems ucrefs

let nenv =

{ nenv with

eFieldLabels = eFieldLabels

eUnqualifiedItems = eUnqualifiedItems

ePatItems = ePatItems

eIndexedExtensionMembers = eIndexedExtensionMembers

eUnindexedExtensionMembers = eUnindexedExtensionMembers }

let nenv =

if TryFindFSharpBoolAttribute g g.attrib_AutoOpenAttribute tcref.Attribs = Some true && isStaticClass g tcref then

AddStaticContentOfTyconRefToNameEnv g amap ad m nenv tcref

else

nenv

nenv

let AddTyconRefsToNameEnv bulkAddMode ownDefinition g amap ad m root nenv tcrefs =

if isNil tcrefs then nenv else

let env = List.fold (AddPartsOfTyconRefToNameEnv bulkAddMode ownDefinition g amap ad m) nenv tcrefs

// Add most of the contents of the tycons en-masse, then flatten the tables if we're opening a module or namespace

let tcrefs = Array.ofList tcrefs

{ env with

eFullyQualifiedTyconsByDemangledNameAndArity =

if root then

AddTyconsByDemangledNameAndArity bulkAddMode tcrefs nenv.eFullyQualifiedTyconsByDemangledNameAndArity

else

nenv.eFullyQualifiedTyconsByDemangledNameAndArity

eFullyQualifiedTyconsByAccessNames =

if root then

AddTyconByAccessNames bulkAddMode tcrefs nenv.eFullyQualifiedTyconsByAccessNames

else

nenv.eFullyQualifiedTyconsByAccessNames

eTyconsByDemangledNameAndArity =

AddTyconsByDemangledNameAndArity bulkAddMode tcrefs nenv.eTyconsByDemangledNameAndArity

eTyconsByAccessNames =

AddTyconByAccessNames bulkAddMode tcrefs nenv.eTyconsByAccessNames }

let AddExceptionDeclsToNameEnv bulkAddMode nenv (ecref: TyconRef) =

assert ecref.IsExceptionDecl

let item = Item.ExnCase ecref

{nenv with

eUnqualifiedItems =

match bulkAddMode with

| BulkAdd.Yes ->

nenv.eUnqualifiedItems.AddAndMarkAsCollapsible [| KeyValuePair(ecref.LogicalName, item) |]

| BulkAdd.No ->

nenv.eUnqualifiedItems.Add (ecref.LogicalName, item)

ePatItems = nenv.ePatItems.Add (ecref.LogicalName, item) }

let AddModuleAbbrevToNameEnv (id: Ident) nenv modrefs =

{nenv with

eModulesAndNamespaces =

let add old nw = nw @ old

NameMap.layerAdditive add (Map.add id.idText modrefs Map.empty) nenv.eModulesAndNamespaces }

let MakeNestedModuleRefs (modref: ModuleOrNamespaceRef) =

modref.ModuleOrNamespaceType.ModuleAndNamespaceDefinitions

|> List.map modref.NestedTyconRef

let rec AddModuleOrNamespaceRefsToNameEnv g amap m root ad nenv (modrefs: ModuleOrNamespaceRef list) =

if isNil modrefs then nenv else

let modrefsMap = modrefs |> NameMap.ofKeyedList (fun modref -> modref.DemangledModuleOrNamespaceName)

let addModrefs tab =

let add old nw =

if IsEntityAccessible amap m ad nw then

nw :: old

else

old

NameMap.layerAdditive add modrefsMap tab

let nenv =

{nenv with

eModulesAndNamespaces = addModrefs nenv.eModulesAndNamespaces

eFullyQualifiedModulesAndNamespaces =

if root then

addModrefs nenv.eFullyQualifiedModulesAndNamespaces

else

nenv.eFullyQualifiedModulesAndNamespaces }

let nenv =

(nenv, modrefs) ||> List.fold (fun nenv modref ->

if modref.IsModule && TryFindFSharpBoolAttribute g g.attrib_AutoOpenAttribute modref.Attribs = Some true then

AddModuleOrNamespaceContentsToNameEnv g amap ad m false nenv modref

else

nenv)

nenv

and AddModuleOrNamespaceContentsToNameEnv (g: TcGlobals) amap (ad: AccessorDomain) m root nenv (modref: ModuleOrNamespaceRef) =

let pri = NextExtensionMethodPriority()

let mty = modref.ModuleOrNamespaceType

let nenv =

let mutable state = { nenv with eDisplayEnv = nenv.eDisplayEnv.AddOpenModuleOrNamespace modref }

for exnc in mty.ExceptionDefinitions do

let tcref = modref.NestedTyconRef exnc

if IsEntityAccessible amap m ad tcref then

state <- AddExceptionDeclsToNameEnv BulkAdd.Yes state tcref

state

let tcrefs =

mty.TypeAndExceptionDefinitions

|> List.choose (fun tycon ->

let tcref = modref.NestedTyconRef tycon

if IsEntityAccessible amap m ad tcref then Some tcref else None)

let nenv = (nenv, tcrefs) ||> AddTyconRefsToNameEnv BulkAdd.Yes false g amap ad m false

let vrefs =

mty.AllValsAndMembers.ToList()

|> List.choose (fun x -> if IsAccessible ad x.Accessibility then TryMkValRefInModRef modref x else None)

|> List.toArray

let nenv = AddValRefsToNameEnvWithPriority BulkAdd.Yes pri nenv vrefs

let nestedModules = MakeNestedModuleRefs modref

let nenv = (nenv, nestedModules) ||> AddModuleOrNamespaceRefsToNameEnv g amap m root ad