yield ClosureFile(filename, m, None,[],[],[])]

closureSources|> List.map loop|> List.concat,!tcConfig

closureSources|> List.collect loop,!tcConfig

letmainFile= fst(List.last files)

letclosureSources= files|> List.map(fun(filename,m)-> ClosureSourceOfFilename(filename,m,tcConfig.inputCodePage,true))|> List.concat

letclosureSources= files|> List.collect(fun(filename,m)-> ClosureSourceOfFilename(filename,m,tcConfig.inputCodePage,true))

letclosureFiles,tcConfig= FindClosureFiles(closureSources,tcConfig,codeContext,lexResourceManager)

GetLoadClosure(mainFile,closureFiles,tcConfig,codeContext)

if Set.contains heading doneHeadingsthen

doneHeadings

letheadingOptions= List.filter(fst>> equals heading) publicBlocks|> List.map snd|> List.concat

letheadingOptions= List.filter(fst>> equals heading) publicBlocks|> List.collect snd

PrintPublicOptions(heading,headingOptions)

Set.add heading doneHeadings

List.fold consider Set.empty publicBlocks|> ignore<Set<string>>

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

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

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

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

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

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

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

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

pinfoItems

|> List.map(function Item.Event(FSEvent(_,_,addValRef,removeValRef))->[addValRef.LogicalName;removeValRef.LogicalName]|_->[])

|> List.concat

|> List.collect(function Item.Event(FSEvent(_,_,addValRef,removeValRef))->[addValRef.LogicalName;removeValRef.LogicalName]|_->[])

|> set

if addersAndRemovers.IsEmptythen minfos

letg= ncenv.g

letmty= modref.ModuleOrNamespaceType

mty.TypeDefinitions

|> List.filter(fun tcref->not(tcref.LogicalName.Contains(",")))

|> List.filter(fun tycon->not(IsTyconUnseen ad g ncenv.amap m(modref.NestedTyconRef tycon)))

mty.TypesByAccessNames.Values

|> List.choose(fun(tycon:Tycon)->if tycon.IsILTyconthen Some tycon.DisplayNameelse None)

|> Set.ofList

match plidwith

mty.TypeDefinitions

|> List.filter(fun tcref->not(tcref.LogicalName.Contains(",")))

|> List.filter(fun tycon->not(IsTyconUnseen ad g ncenv.amap m(modref.NestedTyconRef tycon)))

mty.TypesByAccessNames.Values

|> List.choose(fun(tycon:Tycon)->if tycon.IsILTyconthen Some tycon.DisplayNameelse None)

|> Set.ofList

(mty.AllValsAndMembers

@(UnionCaseRefsInModuleOrNamespace modref

|> List.filter(IsUnionCaseUnseen ad g ncenv.amap m>>not)

|> List.map GeneralizeUnionCaseRef

|> List.map(fun x-> Item.UnionCase(x,false)))

|> List.map(fun x-> Item.UnionCase(GeneralizeUnionCaseRef x,false)))

@(ActivePatternElemsOfModuleOrNamespace modref

@(mty.ModulesAndNamespacesByDemangledName

|> NameMap.range

|> List.filter(fun x-> x.DemangledModuleOrNamespaceName|> notFakeContainerModule ilTyconNames)

|> List.filter(fun x-> x.DemangledModuleOrNamespaceName|> IsInterestingModuleName)

|> List.filter(fun x->

letdemangledName= x.DemangledModuleOrNamespaceName

notFakeContainerModule ilTyconNames demangledName&& IsInterestingModuleName demangledName)

|> List.map modref.NestedTyconRef

|> List.filter(IsTyconUnseen ad g ncenv.amap m>>not)

|> List.filter(EntityRefContainsSomethingAccessible ncenv m ad)

|> List.map(modref.NestedTyconRef>> ItemOfTyconRef ncenv m))

@(tycons

|> List.map(modref.NestedTyconRef>> InfosForTyconConstructors ncenv m ad)|> List.concat)

|> List.collect(modref.NestedTyconRef>> InfosForTyconConstructors ncenv m ad))

| id:: rest->

letg= ncenv.g

matchplidwith

match plidwith

| id:: plidwhen id="global"->// this is deliberately not the mangled name

ResolvePartialLongIdentPrim ncenv nenv isApplicableMeth FullyQualified m ad plid allowObsolete

nenv.ModulesAndNamespaces(fullyQualified)

|> NameMultiMap.range

|> List.filter(fun x-> x.DemangledModuleOrNamespaceName|> IsInterestingModuleName)

|> List.filter(fun x-> x.DemangledModuleOrNamespaceName|> notFakeContainerModule ilTyconNames)

|> List.filter(fun x->

letdemangledName= x.DemangledModuleOrNamespaceName

IsInterestingModuleName demangledName&& notFakeContainerModule ilTyconNames demangledName)

|> List.filter(EntityRefContainsSomethingAccessible ncenv m ad)

|> List.filter(IsTyconUnseen ad g ncenv.amap m>>not)

|> List.map ItemForModuleOrNamespaceRef

letg= ncenv.g

letmty= modref.ModuleOrNamespaceType

mty.TypeDefinitions

|> List.filter(fun tcref->not(tcref.LogicalName.Contains(",")))

|> List.filter(fun tycon-> tycon.IsRecordTycon)

|> List.filter(fun tycon->not(IsTyconUnseen ad g ncenv.amap m(modref.NestedTyconRef tycon)))

mty.TypesByAccessNames.Values

|> List.choose(fun(tycon:Tycon)->if tycon.IsILTyconthen Some tycon.DisplayNameelse None)

|> Set.ofList

match plidwith

mty.TypeDefinitions

|> List.filter(fun tcref->not(tcref.LogicalName.Contains(",")))

|> List.filter(fun tycon-> tycon.IsRecordTycon)

|> List.filter(fun tycon->not(IsTyconUnseen ad g ncenv.amap m(modref.NestedTyconRef tycon)))

mty.TypesByAccessNames.Values

|> List.choose(fun(tycon:Tycon)->if tycon.IsILTyconthen Some tycon.DisplayNameelse None)

|> Set.ofList

(mty.ModulesAndNamespacesByDemangledName

|> NameMap.range

|> List.filter(fun x-> x.DemangledModuleOrNamespaceName|> notFakeContainerModule ilTyconNames)

|> List.filter(fun x-> x.DemangledModuleOrNamespaceName|> IsInterestingModuleName)

|> List.filter(fun x->

letdemangledName= x.DemangledModuleOrNamespaceName

notFakeContainerModule ilTyconNames demangledName&& IsInterestingModuleName demangledName)

|> List.map modref.NestedTyconRef

|> List.filter(IsTyconUnseen ad g ncenv.amap m>>not)

|> List.filter(EntityRefContainsSomethingAccessible ncenv m ad)

|> List.collect(fun tycon->

lettcref= modref.NestedTyconRef tycon

letttype= FreshenTycon ncenv m tcref

ncenv.InfoReader.GetRecordOrClassFieldsOfType(None, ad, m, ttype)

ncenv.InfoReader.GetRecordOrClassFieldsOfType(None, ad, m, ttype))

|> List.map Item.RecdField

nenv.ModulesAndNamespaces(fullyQualified)

|> NameMultiMap.range

|> List.filter(fun x-> x.DemangledModuleOrNamespaceName|> IsInterestingModuleName)

|> List.filter(fun x-> x.DemangledModuleOrNamespaceName|> notFakeContainerModule iltyconNames)

|> List.filter(fun x->

letdemangledName= x.DemangledModuleOrNamespaceName

IsInterestingModuleName demangledName&& notFakeContainerModule iltyconNames demangledName)

|> List.filter(EntityRefContainsSomethingAccessible ncenv m ad)

|> List.filter(IsTyconUnseen ad g ncenv.amap m>>not)

|> List.map ItemForModuleOrNamespaceRef

|> Seq.collect(fun(KeyValue(_,v))-> v)

|> Seq.map(fun fref->

lettypeInsts= fref.TyconRef.TyparsNoRange|> List.map(fun tyar-> tyar.AsType)

Item.RecdField(RecdFieldInfo(typeInsts, fref))

Item.RecdField(RecdFieldInfo(typeInsts, fref)))

|> List.ofSeq

mods@ recdTyCons@ recdFields

tycons

|> List.collect(fun tcref->

letttype= FreshenTycon ncenv m tcref

ncenv.InfoReader.GetRecordOrClassFieldsOfType(None, ad, m, ttype)

ncenv.InfoReader.GetRecordOrClassFieldsOfType(None, ad, m, ttype))

|> List.map Item.RecdField

modsOrNs@ qualifiedFields

// Now deal with all the 'let' and 'member' declarations

let initActions,reps = List.mapFold TransDec reps decs

let cctorInitActions2, ctorInitActions2,methodBinds2 = List.unzip3 initActions

let cctorInitActions = cctorInitActions1 @List.concat cctorInitActions2

let cctorInitActions = cctorInitActions1 @ List.concat cctorInitActions2

let ctorInitActions = ctorInitActions1 @ List.concat ctorInitActions2

let methodBinds = methodBinds1 @ List.concat methodBinds2

[ for (RecDefnBindingInfo(a,b,c,bind)) in recBinds do

yield NormalizedRecBindingDefn(a,b,c,BindingNormalization.NormalizeBinding ValOrMemberBinding cenv envForDecls bind) ]

let bindsAndValues,(tpenv,recBindIdx) = ((tpenv,recBindIdx), normRecDefns) ||> List.mapFold (AnalyzeAndMakeAndPublishRecursiveValue ErrorOnOverrides false cenv envForDecls)

let binds = bindsAndValues |> List.map fst |> List.concat

let binds = bindsAndValues |> List.collect fst

let defnAs = MutRecShape.Lets binds

defnAs,(tpenv,recBindIdx,List.rev binds @ uncheckedBindsRev)

let defns = [MutRecShape.Tycon(MutRecDefnsPhase2DataForTycon(Some exnc, parent, ModuleOrMemberBinding, mkLocalEntityRef exnc, None, NoSafeInitInfo, [], aug, m, NoNewSlots, (fun () -> ())))]

let binds2,envFinal = TcMutRecDefns_Phase2 cenv envInitial m scopem None envMutRec defns

let binds2flat = binds2 |> MutRecShapes.collectTycons |> List.map snd |> List.concat

let binds2flat = binds2 |> MutRecShapes.collectTycons |> List.collect snd

// Augment types with references to values that implement the pre-baked semantics of the type

let binds3 = AddAugmentationDeclarations.AddGenericEqualityBindings cenv envFinal exnc

binds1 @ binds2flat @ binds3,exnc,envFinal

letclosure= LoadClosure.ComputeClosureOfSourceFiles(tcConfig,[filename, rangeStartup], CodeContext.Compilation, lexResourceManager=lexResourceManager)

letreferences= closure.References|> List.map snd|> List.concat|> List.filter(fun r->r.originalReference.Range<>range0&& r.originalReference.Range<>rangeStartup)

letreferences= closure.References|> List.collect snd|> List.filter(fun r->r.originalReference.Range<>range0&& r.originalReference.Range<>rangeStartup)

references|> List.iter(fun r-> tcConfigB.AddReferencedAssemblyByPath(r.originalReference.Range, r.resolvedPath))

closure.NoWarns|> List.map(fun(n,ms)->ms|>List.map(fun m->m, n))|> List.concat|> List.iter tcConfigB.TurnWarningOff

closure.NoWarns|> List.collect(fun(n,ms)->ms|>List.map(fun m->m, n))|> List.iter tcConfigB.TurnWarningOff

closure.SourceFiles|> List.map fst|> List.iter AddIfNotPresent

closure.AllRootFileDiagnostics|> List.iter diagnosticSink