open Internal.Utilities

open Microsoft.FSharp.Compiler

open Microsoft.FSharp.Compiler.Range

open Microsoft.FSharp.Compiler.Ast

open Microsoft.FSharp.Compiler.ErrorLogger

open Microsoft.FSharp.Compiler.Tast

open Microsoft.FSharp.Compiler.Tastops

open Microsoft.FSharp.Compiler.Import

open Microsoft.FSharp.Compiler.TcGlobals

open Microsoft.FSharp.Compiler.Lib

open Microsoft.FSharp.Compiler.AbstractIL

open Microsoft.FSharp.Compiler.AbstractIL.Internal

open Microsoft.FSharp.Compiler.AbstractIL.Internal.Library

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

open Microsoft.FSharp.Compiler.AbstractIL.Diagnostics

open Microsoft.FSharp.Compiler.AbstractIL.IL // Abstract IL

open Microsoft.FSharp.Compiler.Infos

open Microsoft.FSharp.Compiler.AccessibilityLogic

open Microsoft.FSharp.Compiler.AttributeChecking

open Microsoft.FSharp.Compiler.InfoReader

open Microsoft.FSharp.Compiler.Layout

open Microsoft.FSharp.Compiler.PrettyNaming

open System.Collections.Generic

#if EXTENSIONTYPING

open Microsoft.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

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|_|) (typ: TType) =

match stripTyparEqns typ 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 or a parameter to an F# exception constructor

| Type of TyconRef

/// The named argument is a static parameter to a union case constructor

| UnionCase of UnionCaseInfo

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 * 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 field.

| RecdField of RecdFieldInfo

// 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 Tast.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.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

| None -> 0

| Some v -> LanguagePrimitives.PhysicalHash v

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 NameResolutionEnv =

{ /// Display environment information for output

eDisplayEnv: DisplayEnv

/// Values and Data Tags available by unqualified name

eUnqualifiedItems: LayeredMap<string,Item>

/// 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<Tast.ModuleOrNamespaceRef>

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

eFullyQualifiedModulesAndNamespaces: NameMultiMap<Tast.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<Tast.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

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 typ = generalizedTyconRef tcrefOfStaticClass

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

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

[ 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 &&

minfo.NumArgs.Length = 1 &&

minfo.NumArgs.Head >= 1 &&

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 (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 amap.g (tcrefOfTypeExtended, _) -> 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

[]

type BulkAdd = Yes | No

let AddValRefsToItems (bulkAddMode: BulkAdd) (eUnqualifiedItems: LayeredMap<_,_>) (vrefs:ValRef[]) =

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

let vrefs = vrefs |> Array.filter (fun vref -> vref.MemberInfo.IsNone)

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.MemberApparentParent, 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 vref.MemberInfo.IsNone 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 apinfo.Names.Length = 0 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 -> 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 -> 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: LayeredMap<_,_>) (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 private AddPartsOfTyconRefToNameEnv bulkAddMode ownDefinition (g:TcGlobals) amap 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 typ = generalizedTyconRef tcref

isClassTy g typ || isStructTy g typ)

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

if isILOrRequiredQualifiedAccess || ucrefs.Length = 0 then

tab

else

AddUnionCases2 bulkAddMode tab ucrefs

let ePatItems =

if isILOrRequiredQualifiedAccess || ucrefs.Length = 0 then

nenv.ePatItems

else

AddUnionCases1 nenv.ePatItems ucrefs

{ nenv with

eFieldLabels = eFieldLabels

eUnqualifiedItems = eUnqualifiedItems

ePatItems = ePatItems

eIndexedExtensionMembers = eIndexedExtensionMembers

eUnindexedExtensionMembers = eUnindexedExtensionMembers }

let TryFindPatternByName name {ePatItems = patternMap} =

NameMap.tryFind name patternMap

let AddTyconRefsToNameEnv bulkAddMode ownDefinition g amap m root nenv tcrefs =

if isNil tcrefs then nenv else

let env = List.fold (AddPartsOfTyconRefToNameEnv bulkAddMode ownDefinition g amap 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 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

nenv

and AddModulesAndNamespacesContentsToNameEnv g amap ad m root nenv modrefs =

(modrefs, nenv) ||> List.foldBack (fun modref acc -> AddModuleOrNamespaceContentsToNameEnv g amap ad m root acc modref)

let AddModuleOrNamespaceRefToNameEnv g amap m root ad nenv (modref:EntityRef) =

AddModuleOrNamespaceRefsToNameEnv g amap m root ad nenv [modref]

type CheckForDuplicateTyparFlag =

| CheckForDuplicateTypars

| NoCheckForDuplicateTypars

let AddDeclaredTyparsToNameEnv check nenv typars =

let typarmap =

List.foldBack

(fun (tp:Typar) sofar ->

match check with

| CheckForDuplicateTypars ->

if Map.containsKey tp.Name sofar then

errorR (Duplicate("type parameter",tp.DisplayName,tp.Range))

| NoCheckForDuplicateTypars -> ()

Map.add tp.Name tp sofar) typars Map.empty

{nenv with eTypars = NameMap.layer typarmap nenv.eTypars }

let FreshenTycon (ncenv: NameResolver) m (tcref:TyconRef) =

let tinst = ncenv.InstantiationGenerator m (tcref.Typars m)

TType_app(tcref,tinst)

let FreshenUnionCaseRef (ncenv: NameResolver) m (ucref:UnionCaseRef) =

let tinst = ncenv.InstantiationGenerator m (ucref.TyconRef.Typars m)

UnionCaseInfo(tinst,ucref)

let FreshenUnqualifiedItem (ncenv: NameResolver) m res =

match res with

| Item.UnionCase(UnionCaseInfo(_,ucref),_) -> Item.UnionCase(FreshenUnionCaseRef ncenv m ucref,false)

| _ -> res

let OneResult res =

match res with

| Result x -> Result [x]

| Exception e -> Exception e

let OneSuccess x = Result [x]

let AddResults res1 res2 =

match res1, res2 with

| Result [],_ -> res2

| _,Result [] -> res1

| Result x,Result l -> Result (x @ l)

| Exception _,Result l -> Result l

| Result x,Exception _ -> Result x

// If we have error messages for the same symbol, then we can merge suggestions.

| Exception (UndefinedName(n1,f,id1,suggestions1)),Exception (UndefinedName(n2,_,id2,suggestions2)) when n1 = n2 && id1.idText = id2.idText && id1.idRange = id2.idRange ->

Exception(UndefinedName(n1,f,id1,fun () -> Set.union (suggestions1()) (suggestions2())))

// This prefers error messages coming from deeper failing long identifier paths

| Exception (UndefinedName(n1,_,_,_) as e1),Exception (UndefinedName(n2,_,_,_) as e2) ->

if n1 < n2 then Exception e2 else Exception e1

// Prefer more concrete errors about things being undefined

| Exception (UndefinedName _ as e1),Exception (Error _) -> Exception e1

| Exception (Error _),Exception (UndefinedName _ as e2) -> Exception e2

| Exception e1,Exception _ -> Exception e1

let (+++) x y = AddResults x y

let NoResultsOrUsefulErrors = Result []

type ResultCollectionSettings =

| AllResults

| AtMostOneResult

let rec CollectResults f = function

| [] -> NoResultsOrUsefulErrors

| [h] -> OneResult (f h)

| h :: t -> AddResults (OneResult (f h)) (CollectResults f t)

let rec CollectAtMostOneResult f = function

| [] -> NoResultsOrUsefulErrors

| [h] -> OneResult (f h)

| h :: t ->

match f h with

| Result r -> Result [r]

| Exception e -> AddResults (Exception e) (CollectAtMostOneResult f t)

let CollectResults2 resultCollectionSettings f =

match resultCollectionSettings with

| ResultCollectionSettings.AtMostOneResult -> CollectAtMostOneResult f

| _ -> CollectResults f

let MapResults f = function

| Result xs -> Result (List.map f xs)

| Exception err -> Exception err

let AtMostOneResult m res =

match res with

| Exception err -> raze err

| Result [] -> raze (Error(FSComp.SR.nrInvalidModuleExprType(),m))

| Result (res :: _) -> success res

type TypeNameResolutionFlag =

| ResolveTypeNamesToCtors

| ResolveTypeNamesToTypeRefs

type TypeNameResolutionStaticArgsInfo =

/// Indicates indefinite knowledge of type arguments

| Indefinite

/// Indicates definite knowledge of type arguments

| Definite of int

/// Indicates definite knowledge of empty type arguments

static member DefiniteEmpty = TypeNameResolutionStaticArgsInfo.Definite 0

static member FromTyArgs (numTyArgs: int) = TypeNameResolutionStaticArgsInfo.Definite numTyArgs

member x.HasNoStaticArgsInfo = match x with TypeNameResolutionStaticArgsInfo.Indefinite -> true | _-> false

member x.NumStaticArgs = match x with TypeNameResolutionStaticArgsInfo.Indefinite -> 0 | TypeNameResolutionStaticArgsInfo.Definite n -> n

// Get the first possible mangled name of the type, assuming the args are generic args

member x.MangledNameForType nm =

if IsMangledGenericName nm || x.NumStaticArgs = 0 then nm

else nm+"`"+string x.NumStaticArgs

type TypeNameResolutionInfo =

| TypeNameResolutionInfo of TypeNameResolutionFlag * TypeNameResolutionStaticArgsInfo

static member Default = TypeNameResolutionInfo (ResolveTypeNamesToCtors,TypeNameResolutionStaticArgsInfo.Indefinite)

static member ResolveToTypeRefs statResInfo = TypeNameResolutionInfo (ResolveTypeNamesToTypeRefs,statResInfo)

member x.StaticArgsInfo = match x with TypeNameResolutionInfo(_,staticResInfo) -> staticResInfo

member x.ResolutionFlag = match x with TypeNameResolutionInfo(flag,_) -> flag

member x.DropStaticArgsInfo = match x with TypeNameResolutionInfo(flag2,_) -> TypeNameResolutionInfo(flag2,TypeNameResolutionStaticArgsInfo.Indefinite)

let LookupTypeNameInEntityHaveArity nm (staticResInfo: TypeNameResolutionStaticArgsInfo) (mty:ModuleOrNamespaceType) =

let attempt1 = mty.TypesByMangledName.TryFind (staticResInfo.MangledNameForType nm)

match attempt1 with

| Some _ as r -> r

| None -> mty.TypesByMangledName.TryFind nm

let LookupTypeNameInEnvHaveArity fq nm numTyArgs (nenv:NameResolutionEnv) =

let key = if IsMangledGenericName nm then DecodeGenericTypeName nm else NameArityPair(nm,numTyArgs)

match nenv.TyconsByDemangledNameAndArity(fq).TryFind(key) with

| Some res -> Some res

| None -> nenv.TyconsByAccessNames(fq).TryFind nm |> Option.map List.head