anchor.diff:                                              else None)
                                       |> Seq.toList
   
  -                                return! Some (sym, entitiesNames) |> liftMaybe
  +                                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
  
positive.code:         member x.GetTags _spans =
              seq {
                  match currentWord, state with
                  | Some word, Some (symbol, candidates) ->
                      let span = SnapshotSpan(buffer.CurrentSnapshot, word.Span)
                      yield TagSpan<_>(span, ResolveUnopenedNamespaceSmartTag(getSmartTagActions word candidates symbol))
                            :> _
                  | _ -> ()
              }
  
negative.code:             member x.Invoke() = fullyQualifySymbol snapshotSpan fullSymbolName
          }
  
      let getSmartTagActions snapshotSpan candidates _symbol line col =
          let openNamespaceActions = 
              candidates
              |> List.map (fun e -> e.Namespace) 
              |> List.map (openNamespaceAction snapshotSpan line col)
              
          let qualifySymbolActions =
              candidates
  