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.Infos.AccessibilityLogic

open Microsoft.FSharp.Compiler.Infos.AttributeChecking

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 |> isSome)

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

modref.ModuleOrNamespaceType.AllEntities

|> QueueList.tryFind (fun tycon -> tycon.GetFieldByName id.idText |> 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 () ->

let aprefs = [ for x in mtyp.AllValsAndMembers do yield! ActivePatternElemsOfVal modref x ]

(Map.empty,aprefs) ||> List.fold (fun acc apref -> NameMap.add apref.Name apref acc) )

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 string * MethInfo list

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

/// 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)

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

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(nm,_) -> nm

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

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

| Item.FakeInterfaceCtor typ

| Item.DelegateCtor typ -> DemangleGenericTypeName (tcrefOfAppTy g typ).LogicalName

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

| 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 tcrefOfStaticClass.Typars(m).Length = 0 && 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 && MethInfoHasAttribute g m g.attrib_ExtensionAttribute minfo && minfo.NumArgs.Length = 1 && minfo.NumArgs.Head >= 1 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 =

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 tcref = (tspec |> rescopeILTypeSpec scoref).TypeRef |> Import.ImportILTypeRef amap m

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

else Some tcref

| _ -> 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

match thisTyconRef with

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

| _ -> 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 AddValRefsToNameEnvWithPriority bulkAddMode pri nenv vrefs =

{nenv with eUnqualifiedItems= AddValRefsToItems bulkAddMode nenv.eUnqualifiedItems vrefs;

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

ePatItems =

(nenv.ePatItems,vrefs) ||> Array.fold (fun acc vref ->

let ePatItems =

(ActivePatternElemsOfValRef vref, acc) ||> 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 AddValRefToNameEnv nenv vref =

AddValRefsToNameEnvWithPriority BulkAdd.No (NextExtensionMethodPriority()) nenv [| vref |]

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

let nms = apinfo.Names

let apresl = nms |> List.mapi (fun j nm -> nm, j)

{ nenv with eUnqualifiedItems= (apresl,nenv.eUnqualifiedItems) ||> List.foldBack (fun (nm,j) 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>) =

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,_>) =

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

if not tcref.IsRecordTycon || isIL || flds.Length = 0 || (not ownDefinition && HasFSharpAttribute g g.attrib_RequireQualifiedAccessAttribute tcref.Attribs) 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 isIL || ucrefs.Length = 0 || (not ownDefinition && HasFSharpAttribute g g.attrib_RequireQualifiedAccessAttribute tcref.Attribs) then

tab

else

AddUnionCases2 bulkAddMode tab ucrefs

let ePatItems =

if isIL || ucrefs.Length = 0 || (not ownDefinition && HasFSharpAttribute g g.attrib_RequireQualifiedAccessAttribute tcref.Attribs) 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 =

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

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 tycons = mty.TypeAndExceptionDefinitions

let exncs = mty.ExceptionDefinitions

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

let tcrefs = tycons |> List.map modref.NestedTyconRef |> List.filter (IsEntityAccessible amap m ad)

let exrefs = exncs |> List.map modref.NestedTyconRef |> List.filter (IsEntityAccessible amap m ad)

let nenv = (nenv,exrefs) ||> List.fold (AddExceptionDeclsToNameEnv BulkAdd.Yes)

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

let vrefs =

mty.AllValsAndMembers.ToFlatList()

|> FlatList.choose (fun x ->

if IsAccessible ad x.Accessibility then TryMkValRefInModRef modref x

else None)

|> FlatList.toArray

let nenv = AddValRefsToNameEnvWithPriority BulkAdd.Yes pri nenv vrefs

let nenv = (nenv,MakeNestedModuleRefs modref) ||> 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 ->

begin match check with

| CheckForDuplicateTypars ->

if Map.containsKey tp.Name sofar then errorR (Duplicate("type parameter",tp.DisplayName,tp.Range))

| NoCheckForDuplicateTypars ->

()

end;

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

// 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 []

let rec CollectResults f = function

| [] -> NoResultsOrUsefulErrors

| [h] -> OneResult (f h)

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

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

| 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

let LookupTypeNameNoArity nm (byDemangledNameAndArity: LayeredMap<NameArityPair,_>) (byAccessNames: LayeredMultiMap<string,_>) =

if IsMangledGenericName nm then

match byDemangledNameAndArity.TryFind (DecodeGenericTypeName nm) with

| Some res -> [res]

| None ->

match byAccessNames.TryFind nm with

| Some res -> res

| None -> []

else

byAccessNames.[nm]

let LookupTypeNameInEnvNoArity fq nm (nenv: NameResolutionEnv) =

LookupTypeNameNoArity nm (nenv.TyconsByDemangledNameAndArity(fq)) (nenv.TyconsByAccessNames(fq))

let LookupTypeNameInEntityNoArity m nm (mtyp:ModuleOrNamespaceType) =

LookupTypeNameNoArity nm (mtyp.TypesByDemangledNameAndArity(m)) mtyp.TypesByAccessNames

let LookupTypeNameInEnvMaybeHaveArity fq nm (typeNameResInfo: TypeNameResolutionInfo) nenv =

if typeNameResInfo.StaticArgsInfo.HasNoStaticArgsInfo then

LookupTypeNameInEnvNoArity fq nm nenv

else

LookupTypeNameInEnvHaveArity fq nm typeNameResInfo.StaticArgsInfo.NumStaticArgs nenv |> Option.toList

type PermitDirectReferenceToGeneratedType =

| Yes

| No

#if EXTENSIONTYPING

let CheckForDirectReferenceToGeneratedType (tcref: TyconRef, genOk, m) =

match genOk with

| PermitDirectReferenceToGeneratedType.Yes -> ()

| PermitDirectReferenceToGeneratedType.No ->

match tcref.TypeReprInfo with

| TProvidedTypeExtensionPoint info when not info.IsErased ->

//printfn "checking direct reference to generated type '%s'" tcref.DisplayName

if ExtensionTyping.IsGeneratedTypeDirectReference (info.ProvidedType, m) then

error (Error(FSComp.SR.etDirectReferenceToGeneratedTypeNotAllowed(tcref.DisplayName),m))

| _ -> ()

let AddEntityForProvidedType (amap: Import.ImportMap, modref: ModuleOrNamespaceRef, resolutionEnvironment, st:Tainted<ProvidedType>, m) =

let importProvidedType t = Import.ImportProvidedType amap m t

let isSuppressRelocate = amap.g.isInteractive || st.PUntaint((fun st -> st.IsSuppressRelocate),m)

let tycon = Construct.NewProvidedTycon(resolutionEnvironment, st, importProvidedType, isSuppressRelocate, m)

modref.ModuleOrNamespaceType.AddProvidedTypeEntity(tycon)

let tcref = modref.NestedTyconRef tycon

System.Diagnostics.Debug.Assert modref.TryDeref.IsSome

tcref

let ResolveProvidedTypeNameInEntity (amap, m, typeName, modref: ModuleOrNamespaceRef) =

match modref.TypeReprInfo with

| TProvidedNamespaceExtensionPoint(resolutionEnvironment,resolvers) ->

match modref.Deref.PublicPath with

| Some(PubPath(path)) ->

let matches = resolvers |> List.map (fun r->ExtensionTyping.TryResolveProvidedType(resolutionEnvironment,r,m,path,typeName))

let tcrefs =

[ for st in matches do

match st with

| None -> ()

| Some st ->

yield AddEntityForProvidedType (amap, modref, resolutionEnvironment, st, m) ]

tcrefs

| None -> []

// We have a provided type, look up its nested types (populating them on-demand if necessary)

| TProvidedTypeExtensionPoint info ->

let sty = info.ProvidedType

let resolutionEnvironment = info.ResolutionEnvironment

if resolutionEnvironment.showResolutionMessages then

dprintfn "resolving name '%s' in TProvidedTypeExtensionPoint '%s'" typeName (sty.PUntaint((fun sty -> sty.FullName), m))

match sty.PApply((fun sty -> sty.GetNestedType(typeName)), m) with

| Tainted.Null ->

//if staticResInfo.NumStaticArgs > 0 then

// error(Error(FSComp.SR.etNestedProvidedTypesDoNotTakeStaticArgumentsOrGenericParameters(),m))

[]

| nestedSty ->

[AddEntityForProvidedType (amap, modref, resolutionEnvironment, nestedSty, m) ]

| _ -> []