anchor.diff:        | Some tyRes ->
           // Get declarations and generate list for MonoDevelop
           let line, col, lineStr = MonoDevelop.getLineInfoFromOffset(context.TriggerOffset, doc.Editor.Document)
  -        match tyRes.GetDeclarations(line, col, lineStr) with
  -        | Some(decls, _residue) when decls.Items.Any() ->
  -              let items = decls.Items
  -                          |> Array.map (fun mi -> FSharpMemberCompletionData(mi) :> ICompletionData)
  -              result.AddRange(items)
  -        | _ -> ()
  +        match tyRes.GetDeclarationSymbols(line, col, lineStr) with
  +        | Some (symbols, residue) ->
  +            let data = getCompletionData symbols
  +            let debug = data |> Array.ofList
  +            result.AddRange data
  +        | None -> ()
       with
       | e ->
           LoggingService.LogError ("FSharpTextEditorCompletion, An error occured in CodeCompletionCommandImpl", e)
  
positive.code: namespace MonoDevelop.FSharp
  
  open System
  open System.Linq
  open System.Diagnostics
  open MonoDevelop.Core
  open MonoDevelop.Components
  open MonoDevelop.Debugger
  open MonoDevelop.Ide
  open MonoDevelop.Ide.Gui
  open MonoDevelop.Ide.Gui.Content
  open MonoDevelop.Ide.CodeCompletion
  open MonoDevelop.Ide.CodeTemplates
  open Microsoft.FSharp.Compiler
  open Microsoft.FSharp.Compiler.SourceCodeServices
  open FSharp.CompilerBinding
  open ICSharpCode.NRefactory.Editor
  open ICSharpCode.NRefactory.Completion
  open MonoDevelop.FSharp.NRefactory
  
  open ICSharpCode.NRefactory.Semantics
  open ICSharpCode.NRefactory.TypeSystem
  open ICSharpCode.NRefactory.TypeSystem.Implementation
  
  /// A list of completions is returned.  Contains title and can generate description (tool-tip shown on the right) of the item.
  /// Description is generated lazily because it is quite slow and there can be numerous.
  type internal FSharpMemberCompletionData(name, getTip, glyph) =
      inherit CompletionData(CompletionText = Lexhelp.Keywords.QuoteIdentifierIfNeeded name, 
                             DisplayText = name, 
                             DisplayFlags = DisplayFlags.DescriptionHasMarkup)
  
      let icon = lazy (MonoDevelop.Core.IconId(ServiceUtils.getIcon glyph))
  
      new (name, datatip:FSharpToolTipText, glyph) = new FSharpMemberCompletionData(name, (fun () -> datatip), glyph)
      new (mi:FSharpDeclarationListItem) =  new FSharpMemberCompletionData(mi.Name, (fun () -> mi.DescriptionText), mi.Glyph)
  
      override x.Description = name //description.Value   // this is not used
      override x.Icon = icon.Value
  
      /// Check if the datatip has multiple overloads
      override x.HasOverloads = 
          match getTip() with 
          | FSharpToolTipText [xs] ->
              match xs with 
              | FSharpToolTipElement.Group _ -> true 
              | _ -> false
          | FSharpToolTipText _list -> true
  
      /// Split apart the elements into separate overloads
      override x.OverloadedData =
          match getTip() with 
          | FSharpToolTipText xs -> 
              seq{for tooltipElement in xs do
                  match tooltipElement with
                  | FSharpToolTipElement.Single _ -> yield FSharpMemberCompletionData(name, FSharpToolTipText[tooltipElement], glyph) :> _
                  | FSharpToolTipElement.Group(items) ->
                    let overloads =
                        items 
                        |> Seq.map (fun args -> FSharpMemberCompletionData(name, FSharpToolTipText[FSharpToolTipElement.Single(args)], glyph)) 
                        |> Seq.cast
                    yield! overloads
                  | FSharpToolTipElement.CompositionError error ->
                      //show the composition error in the tip, hiding it makes it more difficult to diagnose
                      yield FSharpMemberCompletionData(name, FSharpToolTipText[FSharpToolTipElement.Single(error,FSharpXmlDoc.None)], 0) :> _
                  | FSharpToolTipElement.None -> () }
  
  
      override x.AddOverload (_data: ICompletionData) = ()//not currently called
  
      // TODO: what does 'smartWrap' indicate?
      override x.CreateTooltipInformation (_smartWrap: bool) = 
        
        Debug.WriteLine("computing tooltip for {0}", name)
        let description = TooltipFormatting.formatTip (getTip())
        match description with
        | [signature,comment] -> TooltipInformation(SummaryMarkup = comment, SignatureMarkup = signature)
        //With multiple tips just take the head.  
        //This shouldnt happen anyway as we split them in the resolver provider
        | multiple -> multiple |> List.head |> (fun (signature,comment) -> TooltipInformation(SummaryMarkup = comment, SignatureMarkup = signature))
  
  
  /// Completion data representing a delayed fetch of completion data
  type internal FSharpTryAgainMemberCompletionData() =
  
negative.code:         let prm = meth.Parameters.[paramIndex]
          prm.ParameterName
  
  type Category(category) =
      inherit CompletionCategory(category, null)
      override x.CompareTo other =
          if other = null then -1 else x.DisplayText.CompareTo other.DisplayText
  
  /// Implements text editor extension for MonoDevelop that shows F# completion    
  type FSharpTextEditorCompletion() =
    inherit CompletionTextEditorExtension()
  
    let mutable suppressParameterCompletion = false
    let mutable lastCharDottedInto = false
           
    let compilerIdentifiers =
        let icon = MonoDevelop.Ide.Gui.Stock.Literal
        let compilerIdentifierCategory = Category "Compiler Identifiers"
        [CompletionData("__LINE__",
                        icon,
                        "Evaluates to the current line number, considering <tt>#line</tt> directives.",
  