Names:Set<string>

LiteralIdent:string

AllPossibleIdents:Set<string>

Range:range

[for declin declsdo

match declwith

| SynModuleDecl.Open(LongIdentWithDots.LongIdentWithDots(id= longId), range)->

letliteralIdent= longId|> List.map(fun l-> l.idText)|> String.concat"."

{ Names=

set[yield(longId|> List.map(fun l-> l.idText)|> String.concat".")

{ LiteralIdent= literalIdent

AllPossibleIdents=

set[yield literalIdent

ifnot(List.isEmpty parent)then

yield(parent@ longId|> List.map(fun l-> l.idText)|> String.concat".")]

[for namein fullNamesdo

yield getPartNamespace symbolUse name

letpartNamespace= getPartNamespace symbolUse name

yield partNamespace

yield! entityNamespace declaringEntity]

}|> Option.toList|> List.concat|> List.choose id

symbolUses

|> Array.filter(fun(s: FSharpSymbolUse)->not s.IsFromDefinition)

symbolUses

|> Array.filter(fun(symbolUse: FSharpSymbolUse)->

not symbolUse.IsFromDefinition&&

match symbolUse.Symbolwith

|:? FSharpEntityas e->not e.IsNamespace

importantSymbolUses

|> Array.toList

|> List.collect(fun x->

getPossibleNamespaces x

|> List.distinct

|> List.map(fun ns->{ Ident= ns; Location= x.RangeAlternate}))

|> List.collect(fun su->

letlineStr= sourceText.Lines.[Line.toZ su.RangeAlternate.StartLine].ToString()

letpartialName= QuickParse.GetPartialLongNameEx(lineStr, su.RangeAlternate.EndColumn-1)

letqualifier= partialName.QualifyingIdents|> String.concat"."

getPossibleNamespaces su

|> List.distinct

|> List.choose(fun ns->

if qualifier=""then Some ns

elif ns= qualifierthen None

elif ns.EndsWith qualifierthen Some ns.[..(ns.Length- qualifier.Length)-2]

else None)

|> List.map(fun ns->

{ Ident= ns

Location= su.RangeAlternate}))

letnotUsedAnywhere=not(namespacesInUse|> List.exists(fun nsu-> rangeContainsRange os.ModuleRange nsu.Location&& os.Names|> Set.contains nsu.Ident))

not(namespacesInUse|> List.exists(fun nsu->

rangeContainsRange os.ModuleRange nsu.Location&& os.AllPossibleIdents|> Set.contains nsu.Ident))

if notUsedAnywherethentrue

seenOpenStatements

|> List.exists(fun seenNs->

(seenNs.ModuleRange= os.ModuleRange|| rangeContainsRange seenNs.ModuleRange os.ModuleRange)&&

not(os.Names|> Set.intersect seenNs.Names|> Set.isEmpty))

rangeContainsRange seenNs.ModuleRange os.ModuleRange&& os.LiteralIdent= seenNs.LiteralIdent)

alreadySeen

match listwith

letprivatechecker= FSharpChecker.Create()

let(=>)(source: string)(expectedRanges:(int*(int* int)) list)=

let(=>)(source: string)(expectedRanges:((*line*)int*((*start column*)int*(*end column*)int)) list)=

letsourceText= SourceText.From(source)