anchor.diff:      { Namespace: string
         Name: string }
   
  +module Ast =
  +    let findNearestOpenStatementBlock (pos: pos) (ast: ParsedInput) = 
  +        let result = ref None
  +        let doRange (range: range) = if range.StartLine < pos.Line then result := Some range
  +
  +        let rec walkImplFileInput (ParsedImplFileInput(_, _, _, _, _, moduleOrNamespaceList, _)) = 
  +            List.iter walkSynModuleOrNamespace moduleOrNamespaceList
  +
  +        and walkSynModuleOrNamespace(SynModuleOrNamespace(_, _, decls, _, _, _, range)) =
  +            doRange range
  +            List.iter walkSynModuleDecl decls
  +
  +        and walkSynModuleDecl(decl: SynModuleDecl) =
  +            match decl with
  +            | SynModuleDecl.NamespaceFragment fragment -> walkSynModuleOrNamespace fragment
  +            | SynModuleDecl.NestedModule(_, modules, _, _) -> List.iter walkSynModuleDecl modules
  +            | SynModuleDecl.Open (_, range) -> doRange range
  +            | _ -> ()
  +
  +        match ast with
  +        | ParsedInput.SigFile _input -> ()
  +        | ParsedInput.ImplFile input -> walkImplFileInput input
  +        !result |> Option.map (fun res -> Pos.fromZ (res.StartLine - 1) (res.StartColumn + 1))
  +         
   type ResolveUnopenedNamespaceSmartTagger
            (view: ITextView, buffer: ITextBuffer, textUndoHistory: ITextUndoHistory,
             vsLanguageService: VSLanguageService, serviceProvider: IServiceProvider,
             projectFactory: ProjectFactory) as self =
  +    
  +    let codeGenService: ICodeGenerationService<_, _, _> = upcast CodeGenerationService(vsLanguageService, buffer)
             
       let tagsChanged = Event<_, _>()
       let mutable currentWord: SnapshotSpan option = None
  -    let mutable state: (Symbol * Entity list) option = None
  +    let mutable state: (Symbol * Entity list * int * int) option = None
   
       let updateAtCaretPosition() =
           match buffer.GetSnapshotPoint view.Caret.Position, currentWord with
  
positive.code:         snapshotSpan.Snapshot.TextBuffer.Replace (snapshotSpan.Span, fullSymbolName) |> ignore
          transaction.Complete()
  
      let openNamespaceAction snapshot ns =
          { new ISmartTagAction with
              member x.ActionSets = null
              member x.DisplayText = "open " + ns
              member x.Icon = null
              member x.IsEnabled = true
              member x.Invoke() = openNamespace snapshot ns
          }
  
      let qualifySymbolAction snapshotSpan fullSymbolName =
  
negative.code:                                             else None)
                                      |> Seq.toList
  
                                  let! checkResults = 
                                      vsLanguageService.ParseFileInProject (doc.FullName, newWord.Snapshot.GetText(), project) |> liftAsync
  
                                  return! 
                                      checkResults.ParseTree 
                                      |> Option.map (fun tree ->
                                          let line, column = 
                                              match Ast.findNearestOpenStatementBlock (codeGenService.ExtractFSharpPos point) tree with
                                              | Some pos -> pos.Line, pos.Column
                                              | None -> 1, 1
                                          sym, entitiesNames, line, column)
                                      |> liftMaybe
                      }
                      |> Async.map (fun result -> 
                          state <- result
  