anchor.diff:                                      match bs with
                                       | Refactoring.BaseSymbol.Member m -> m :> FSharpSymbol
                                       | Refactoring.BaseSymbol.Type t -> t :> FSharpSymbol
  -                                let _baseIdent = symbol.DisplayName
  +                                //let _baseIdent = symbol.DisplayName
                                   let locations = Symbols.getLocationFromSymbol symbol
                                   match locations with
                                   | [] -> ()
                                   | [location] -> 
  -                                    let description = GettextCatalog.GetString ("Go to _Base Symbol")
  +                                    let description =
  +                                      match symbolUse.Symbol with
  +                                      | :? FSharpEntity ->
  +                                          getCatalogString "Go to _Base Type"
  +                                      | :? FSharpMemberOrFunctionOrValue as mfv when mfv.EnclosingEntity.IsInterface ->
  +                                          if mfv.IsProperty then getCatalogString "Go to _Interface Property"
  +                                          elif mfv.IsEvent then getCatalogString "Go to _Interface Event"
  +                                          else GettextCatalog.GetString ("Go to _Interface Method")
  +                                      | :? FSharpMemberOrFunctionOrValue as mfv ->
  +                                          if mfv.IsProperty then  getCatalogString "Go to _Base Property"
  +                                          elif mfv.IsEvent then getCatalogString "Go to _Base Event"
  +                                          else getCatalogString "Go to _Base Method"
  +                                      | _-> getCatalogString "Go to _Base Symbol"
                                       ainfo.Add (description, Action (fun () -> Refactoring.jumpTo (doc.Editor, doc, symbol, location)))
                                       |> ignore
                                       
                                   | locations ->
  -                                    let declSet = CommandInfoSet (Text = GettextCatalog.GetString ("Go to _Base Symbol"))
  +                                    let declSet = CommandInfoSet (Text = getCatalogString "Go to _Base Symbol")
                                       for location in locations do
  -                                        let commandText = String.Format (GettextCatalog.GetString ("{0}, Line {1}"), formatFileName location.FileName, location.StartLine)
  +                                        let commandText = String.Format (getCatalogString"{0}, Line {1}", formatFileName location.FileName, location.StartLine)
                                           declSet.CommandInfos.Add (commandText, Action (fun () -> Refactoring.jumpTo (doc.Editor, doc, symbol, location)))
                                           |> ignore
                                       ainfo.Add (declSet)
                               | _ -> ()
    
                           //find references
  -                        // renamable indicates the source symbol is internal to the project
  -                        if canRename then
  -                            let command = IdeApp.CommandService.GetCommandInfo (RefactoryCommands.FindReferences)
  -                            command.Enabled <- true
  -                            ainfo.Add (command, Action (fun () -> Refactoring.findReferences (doc.Editor, doc, symbolUse, lastIdent)))
  -                            //this one finds all overloads of a given symbol
  -                            //All that needs to happen here is to pass all dependent project infos
  -                            //ainfo.Add (IdeApp.CommandService.GetCommandInfo (RefactoryCommands.FindAllReferences), Action (fun () -> Refactoring.FindRefs (sym)))
  -
  -                        //TODO: find derived symbols, find overloads, find extension methods, find type extensions
  +                        let findReferencesCommand = IdeApp.CommandService.GetCommandInfo (RefactoryCommands.FindReferences)
  +                        findReferencesCommand.Enabled <- true
  +                        ainfo.Add (findReferencesCommand, Action (fun () -> Refactoring.findReferences (doc.Editor, doc, symbolUse, lastIdent)))
  +
  +                        //TODO: this one finds all overloads of a given symbol
  +                        //All that needs to happen here is to pass all dependent project infos
  +                        //ainfo.Add (IdeApp.CommandService.GetCommandInfo (RefactoryCommands.FindAllReferences), Action (fun () -> Refactoring.FindRefs (sym)))
  +
  +                        // find derived symbols
  +                        if symbolUse.Symbol :? FSharpEntity || symbolUse.Symbol :? FSharpMemberOrFunctionOrValue  then
  +                          let description = 
  +                            match symbolUse.Symbol with
  +                            | :? FSharpEntity as fse when fse.IsInterface -> getCatalogString "Find Implementing Types"
  +                            | :? FSharpEntity -> getCatalogString "Find Derived Types"
  +                            | :? FSharpMemberOrFunctionOrValue as mfv when mfv.EnclosingEntity.IsInterface -> getCatalogString "Find Implementing Symbols"
  +                            | :? FSharpMemberOrFunctionOrValue -> getCatalogString "Find overriden Symbols"
  +                            | _ -> getCatalogString "Find Derived Symbols"
  +                          ainfo.Add (description, Action (fun () -> Refactoring.findDerivedReferences (doc.Editor, doc, symbolUse, lastIdent))) |> ignore
  +
  +                        //find overloads
  +                        if Refactoring.canGotoOverloads symbolUse then
  +                          let description = getCatalogString "Find Method Overloads"
  +                          ainfo.Add (description, Action (fun () -> Refactoring.findOverloads (doc.Editor, doc, symbolUse, lastIdent))) |> ignore
  +
  +                        //TODO: find extension methods, find type extensions
               
                           if ciset.CommandInfos.Count > 0 then
                               ainfo.Add (ciset, null)
  
positive.code:                 | Some ast ->
                      match Refactoring.getSymbolAndLineInfoAtCaret ast doc.Editor with
                      | (_line, col, lineTxt), Some symbolUse ->
                          let ciset = new CommandInfoSet (Text = GettextCatalog.GetString ("Refactor"))
              
                          //last ident part of surrent symbol
                          let lastIdent = Symbols.lastIdent col lineTxt
  
negative.code:                                 commandInfo.Enabled <- true
                                  ainfo.Add (commandInfo, Action (fun _ -> Refactoring.jumpToDeclaration (doc.Editor, doc, symbolUse) ))
                              | locations ->
                                  let declSet = CommandInfoSet (Text = getCatalogString "_Go to Declaration")
                                  for location in locations do
                                      let commandText = String.Format (getCatalogString "{0}, Line {1}", formatFileName location.FileName, location.StartLine)
                                      declSet.CommandInfos.Add (commandText, Action (fun () -> Refactoring.jumpTo (doc.Editor, doc, symbolUse.Symbol, location)))
                                      |> ignore
                                  ainfo.Add (declSet)
  