anchor.diff:          member x.GetTags _spans =
               seq {
                   match currentWord, state with
  -                | Some word, Some (symbol, candidates, line, col) ->
  +                | Some word, Some (candidates, line, col) ->
                       let span = SnapshotSpan(buffer.CurrentSnapshot, word.Span)
  -                    yield TagSpan<_>(span, ResolveUnopenedNamespaceSmartTag(getSmartTagActions word candidates symbol line col))
  +                    yield TagSpan<_>(span, ResolveUnopenedNamespaceSmartTag(getSmartTagActions word candidates line col))
                             :> _
                   | _ -> ()
               }
  
positive.code: type ResolveUnopenedNamespaceSmartTag(actionSets) =
      inherit SmartTag(SmartTagType.Factoid, actionSets)
  
  type Entity = 
      { Namespace: string
        Name: string }
  
  module Ast =
      let findNearestOpenStatementBlock (pos: pos) (ast: ParsedInput) = 
          let result = ref None
          
          let doRange (syn: obj) (startLine, col, endLine) = 
              if startLine < pos.Line && endLine >= pos.Line then 
                  match !result with
                  | None -> result := Some (syn, startLine, col)
                  | Some (_, oldLine, _) when oldLine < startLine -> 
                      result := Some (syn, startLine, col)
                  | _ -> ()
  
          let rec walkImplFileInput (ParsedImplFileInput(_, _, _, _, _, moduleOrNamespaceList, _)) = 
              List.iter walkSynModuleOrNamespace moduleOrNamespaceList
  
          and walkSynModuleOrNamespace(SynModuleOrNamespace(_, _, decls, _, _, _, range) as syn) =
              doRange syn (range.StartLine, range.StartColumn, range.EndLine)
              List.iter walkSynModuleDecl decls
  
          and walkSynModuleDecl(decl: SynModuleDecl) =
              match decl with
              | SynModuleDecl.NamespaceFragment fragment -> walkSynModuleOrNamespace fragment
              | SynModuleDecl.NestedModule(ComponentInfo(_, _, _, _, _, _, _, range), modules, _, _) as syn ->
                  doRange syn (range.StartLine, range.StartColumn + 4, range.EndLine)
                  List.iter walkSynModuleDecl modules
              | SynModuleDecl.Open (_, range) as syn -> doRange syn (range.StartLine, range.StartColumn - 5, range.EndLine)
              | _ -> ()
  
          match ast with
          | ParsedInput.SigFile _input -> ()
          | ParsedInput.ImplFile input -> walkImplFileInput input
  
          let res = !result |> Option.map (fun (_, line, col) -> Pos.fromZ line col)
          //debug "[ResolveUnopenedNamespaceSmartTagger] Syn, line, col = %A, AST = %A" (!result) ast
          res 
           
  type ResolveUnopenedNamespaceSmartTagger
  
negative.code:           
      let tagsChanged = Event<_, _>()
      let mutable currentWord: SnapshotSpan option = None
      let mutable state: (Entity list * int * int) option = None 
  
      let triggerTagsChanged() =
          let span = SnapshotSpan(buffer.CurrentSnapshot, 0, buffer.CurrentSnapshot.Length)
          tagsChanged.Trigger(self, SnapshotSpanEventArgs(span))
  
      let updateAtCaretPosition() =
          match buffer.GetSnapshotPoint view.Caret.Position, currentWord with
  