anchor.diff:        let symbolToCompletionData (symbols : FSharpSymbolUse list) =
             match symbols with
             | head :: tail ->
  -              let cd = FSharpMemberCompletionData(head.Symbol.DisplayName, symbolToIcon head, head, tail) :> ICompletionData
  +              let cd = FSharpMemberCompletionData(head.Symbol.DisplayName, symbolToIcon head, head, tail) :> CompletionData
                 match tryGetCategory head with
                 | Some c -> let category = getOrAddCategory c
                             cd.CompletionCategory <- category
                 | None -> ()
                 cd
  -          | _ -> FSharpTryAgainMemberCompletionData() :> ICompletionData
  +          | _ -> null //FSharpTryAgainMemberCompletionData() :> ICompletionData
   
         symbols |> List.map symbolToCompletionData
   
  +  override x.CompletionLanguage = "F#"
     override x.Initialize() = 
  -      do base.Document.Editor.IndentationTracker <- FSharpIndentationTracker(base.Document) :> Mono.TextEditor.IIndentationTracker 
  +      do x.Editor.SetIndentationTracker (FSharpIndentationTracker(base.Editor))
         base.Initialize()
   
     /// Provide parameter and method overload information when you type '(', '<' or ','
  -  override x.HandleParameterCompletion(context:CodeCompletionContext, _completionChar:char) : MonoDevelop.Ide.CodeCompletion.ParameterDataProvider =
  +  override x.HandleParameterCompletionAsync (context, _completionChar, token) =
  +    //TODO refactor computation to remove some return statements (clarity)
  +    Async.StartAsTask (cancellationToken = token, computation = async {
       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 
  +        if suppressParameterCompletion then
  +           suppressParameterCompletion <- false
  +           return null
  +        else
  +        let docText = x.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 x.Editor offset then return null 
  +        else
  +        LoggingService.LogDebug("FSharpTextEditorCompletion: Getting Parameter Info, startOffset = {0}", startOffset)
  +        
  +        let projFile, files, args = MonoDevelop.getCheckerArgs(x.DocumentContext.Project, x.DocumentContext.Name)
  +        
  +        // Try to get typed result - within the specified timeout
  +        let! methsOpt =
  +            async {let! tyRes = MDLanguageService.Instance.GetTypedParseResultAsync (projFile, x.DocumentContext.Name, docText, files, args, AllowStaleResults.MatchingFileName) 
  +                   let line, col, lineStr = MonoDevelop.getLineInfoFromOffset(startOffset, x.Editor)
  +                   let! methsOpt = tyRes.GetMethods(line, col, lineStr)
  +                   return methsOpt }
  +        
  +        match methsOpt with 
  +        | Some(name, meths) when meths.Length > 0 -> 
  +            LoggingService.LogInfo ("FSharpTextEditorCompletion: Getting Parameter Info: {0} methods", meths.Length)
  +            //TODO Convert meths to ParameterHintingData
  +            let data = ResizeArray()
  +            return ParameterHintingResult(data, startOffset) 
  +        | _ -> LoggingService.LogWarning("FSharpTextEditorCompletion: Getting Parameter Info: no methods found")
  +               return null 
       with ex ->
           LoggingService.LogError ("FSharpTextEditorCompletion: Error in HandleParameterCompletion", ex)
  -        null
  -
  -  override x.KeyPress (key, keyChar, modifier) =
  +        return null})
  +
  +  override x.KeyPress (descriptor:KeyDescriptor) =
         // Avoid two dots in sucession turning inte ie '.CompareWith.' instead of '..'
  -      let suppressMemberCompletion = lastCharDottedInto && keyChar = '.'
  +      let suppressMemberCompletion = lastCharDottedInto && descriptor.KeyChar = '.'
         lastCharDottedInto <- false
         if suppressMemberCompletion then true else
  -      // base.KeyPress will execute RunParameterCompletionCommand,
  +      // base.KeyPress will execute RunParameterCompletionCommand
         // so suppress it here.  
  -      suppressParameterCompletion <-
  -         keyChar <> '(' && keyChar <> '<' && keyChar <> ','
  +      suppressParameterCompletion <- descriptor.KeyChar <> '(' && descriptor.KeyChar <> '<' && descriptor.KeyChar <> ','
         
  -      let result = base.KeyPress (key, keyChar, modifier)
  +      let result = base.KeyPress (descriptor)
   
         suppressParameterCompletion <- false
  -      if (keyChar = ')' && x.CanRunParameterCompletionCommand ()) then
  +      if (descriptor.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
  +  override x.HandleCodeCompletionAsync(context, completionChar, token) =
  +      if completionChar <> '.' 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 
  
positive.code:           let res = loop 0 i 1
            res
  
    interface IDebuggerExpressionResolver with
      member x.ResolveExpression(_editor, doc, offset, startOffset) =
          let resolver = TextEditorResolverService.GetProvider(doc.Editor.MimeType)
          let resolveResult, dom = resolver.GetLanguageItem(doc,offset)
          match resolveResult.GetSymbol() with
          //we are only going to process FSharpResolvedVariable types all other types will not be resolved.
          //This will cause the tooltip to be displayed as usual for member lookups etc.  
          | :? FSharpResolvedVariable as resolvedVariable ->
              startOffset <- dom.BeginColumn
              (resolvedVariable :> IVariable).Name
          | _ -> startOffset <- -1
                 null
  
negative.code:                       icon,
                        "Evaluates to the current line number, considering <tt>#line</tt> directives.",
                        CompletionCategory = compilerIdentifierCategory, 
                        DisplayFlags = DisplayFlags.DescriptionHasMarkup)
         CompletionData("__SOURCE_DIRECTORY__",
                        icon,
                        "Evaluates to the current full path of the source directory, considering <tt>#line</tt> directives.",
                        CompletionCategory = compilerIdentifierCategory, 
                        DisplayFlags = DisplayFlags.DescriptionHasMarkup)
         CompletionData("__SOURCE_FILE__",
                        icon,
                        "Evaluates to the current source file name and its path, considering <tt>#line</tt> directives.",
                        CompletionCategory = compilerIdentifierCategory,
                        DisplayFlags = DisplayFlags.DescriptionHasMarkup)]
  
    // Until we build some functionality around a reversing tokenizer that detect this and other contexts
    // A crude detection of being inside an auto property decl: member val Foo = 10 with get,$ set
    let isAnAutoProperty (editor: Editor.TextEditor) offset =
        false
    //TODO
    //  let lastStart = editor.FindPrevWordOffset(offset)
    //  let lastEnd = editor.FindCurrentWordEnd(lastStart)
    //  let lastWord = editor.GetTextBetween(lastStart, lastEnd)
  
    //  let prevStart = editor.FindPrevWordOffset(lastStart)
    //  let prevEnd = editor.FindCurrentWordEnd(prevStart)
    //  let previousWord = editor.GetTextBetween(prevStart, prevEnd)
    //  lastWord = "get" && previousWord = "with"
  
    let getCompletionData (symbols:FSharpSymbolUse list list) =
        let categories = Dictionary<string, Category>()
  