anchor.diff:              |> Map.ofSeq
           | None -> Map.empty
   
  -    let qualifiedSymbols: (Range * (SymbolAccess * string)) [] =
  +    let qualifiedSymbols: (Range.range * (SymbolAccess * string)) [] =
           allSymbolsUses
           |> Array.map (fun (symbolUse, _) ->
               let r = symbolUse.RangeAlternate
               let fullName = symbolUse.Symbol.FullName
  -            { Start = { Line = r.StartLine; Col = r.StartColumn }   
  -              End = { Line = r.EndLine; Col = r.EndColumn }},
  +            r,
               match longIdentsByLine |> Map.tryFind r.StartLine with
               | Some idents ->
                   match idents |> Seq.tryFind (fun (identRange, _) -> 
  
positive.code:     { Category: Category
        WordSpan: WordSpan }
  
  type private Point =
      { Line: int 
        Col: int }
  
  type private Range =
      { Start: Point
        End: Point }
  
  [<NoComparison>]
  type private OpenDeclaration =
      { Idents: Set<string>
        DeclRange: Range.range
        Range: Range }
  
  type private SymbolAccess =
      | FullName
  
negative.code:     debug "Qualified symbols: %A" qualifiedSymbols
          
      let unusedOpenDeclarations: OpenDeclaration list =
          Array.foldBack (fun (symbolRange: Range.range, (symbolAccess, name: string)) openDecls ->
              openDecls |> List.fold (fun (acc, found) (openDecl, used) -> 
                  if found then
                      (openDecl, used) :: acc, found
                  else
                      let usedByCurrentSymbol =
                          Range.rangeContainsRange openDecl.Range symbolRange
                          && (match symbolAccess with 
                              | FullName -> openDecl.Idents |> Set.exists name.StartsWith
                              | OpenPrefix -> openDecl.Idents |> Set.contains name)
  