anchor.diff:          overloads
           |> Seq.map (fun symbol -> FSharpMemberCompletionData(symbol.Symbol.DisplayName, icon, symbol, List.empty) :> _ )
   
  -    override x.AddOverload (data: ICompletionData) = () //not currently called
  +    override x.AddOverload (data: CompletionData) = () //not currently called
   
       // TODO: what does 'smartWrap' indicate?
       override x.CreateTooltipInformation (smartWrap: bool) = 
  
positive.code:       let symbolToCompletionData (symbols : FSharpSymbolUse list) =
            match symbols with
            | head :: tail ->
                let cd = FSharpMemberCompletionData(head.Symbol.DisplayName, symbolToIcon head, head, tail) :> ICompletionData
                match tryGetCategory head with
                | Some c -> let category = getOrAddCategory c
                            cd.CompletionCategory <- category
                | None -> ()
                cd
            | _ -> FSharpTryAgainMemberCompletionData() :> ICompletionData
  
        symbols |> List.map symbolToCompletionData
  
    override x.Initialize() = 
        do base.Document.Editor.IndentationTracker <- FSharpIndentationTracker(base.Document) :> Mono.TextEditor.IIndentationTracker 
        base.Initialize()
  
    /// Provide parameter and method overload information when you type '(', '<' or ','
    override x.HandleParameterCompletion(context:CodeCompletionContext, _completionChar:char) : MonoDevelop.Ide.CodeCompletion.ParameterDataProvider =
      try
        if suppressParameterCompletion then
           suppressParameterCompletion <- false
           null
        else
        let doc = x.Document
        let docText = doc.Editor.Text
        let offset = context.TriggerOffset
  
        // Parse backwards, skipping (...) and { ... } and [ ... ] to determine the parameter index. 
        // This is an approximation.
        let startOffset =
            let rec loop depth i = 
                if (i <= 0) then i else
                let ch = docText.[i] 
                if ((ch = '(' || ch = '{' || ch = '[') && depth > 0) then loop (depth - 1) (i-1) 
                elif ((ch = ')' || ch = '}' || ch = ']')) then loop (depth+1) (i-1) 
                elif (ch = '(' || ch = '<') then i
                else loop depth (i-1) 
            loop 0 (offset-1)
        
        if docText = null || offset > docText.Length || startOffset < 0 || offset <= 0 || isAnAutoProperty doc.Editor offset then null 
        else
        LoggingService.LogDebug("FSharpTextEditorCompletion: Getting Parameter Info, startOffset = {0}", startOffset)
  
        let projFile, files, args = MonoDevelop.getCheckerArgs(doc.Project, doc.FileName.FullPath.ToString())
  
        // Try to get typed result - within the specified timeout
        let methsOpt =
            Async.RunSynchronously (
                async {let! tyRes = MDLanguageService.Instance.GetTypedParseResultAsync (projFile, doc.FileName.FullPath.ToString(), docText, files, args, AllowStaleResults.MatchingFileName) 
                       let line, col, lineStr = MonoDevelop.getLineInfoFromOffset(startOffset, doc.Editor.Document)
                       let! methsOpt = tyRes.GetMethods(line, col, lineStr)
                       return methsOpt }, ServiceSettings.blockingTimeout)
  
        match methsOpt with 
        | Some(name, meths) when meths.Length > 0 -> 
            LoggingService.LogInfo ("FSharpTextEditorCompletion: Getting Parameter Info: {0} methods", meths.Length)
            new ParameterDataProvider (startOffset, name, meths) :> _ 
        | _ -> LoggingService.LogWarning("FSharpTextEditorCompletion: Getting Parameter Info: no methods found")
               null 
      with ex ->
          LoggingService.LogError ("FSharpTextEditorCompletion: Error in HandleParameterCompletion", ex)
          null
  
    override x.KeyPress (key, keyChar, modifier) =
        // Avoid two dots in sucession turning inte ie '.CompareWith.' instead of '..'
        let suppressMemberCompletion = lastCharDottedInto && keyChar = '.'
        lastCharDottedInto <- false
        if suppressMemberCompletion then true else
        // base.KeyPress will execute RunParameterCompletionCommand,
        // so suppress it here.  
        suppressParameterCompletion <-
           keyChar <> '(' && keyChar <> '<' && keyChar <> ','
        
        let result = base.KeyPress (key, keyChar, modifier)
  
        suppressParameterCompletion <- false
        if (keyChar = ')' && x.CanRunParameterCompletionCommand ()) then
            base.RunParameterCompletionCommand ()
  
        result
  
    // Run completion automatically when the user hits '.'
    // (this means that completion currently also works in comments and strings...)
    override x.HandleCodeCompletion(context, ch, triggerWordLength:byref<int>) =
        if ch <> '.' then null else
  
        // We generally avoids forcing a re-typecheck on '.' presses by using
        // TryGetRecentTypeCheckResults. Forcing a re-typecheck on a user action can cause a 
  
negative.code: open System.Diagnostics
  open MonoDevelop.Core
  open MonoDevelop.Debugger
  open MonoDevelop.Ide
  open MonoDevelop.Ide.Editor.Extension
  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 MonoDevelop.FSharp.NRefactory
  open ICSharpCode.NRefactory.TypeSystem
  open ExtCore.Control
  