anchor.diff:          
           // 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) 
  +            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 
  +        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) 
  +            let hintingData =
  +                meths
  +                |> Array.map (fun meth -> FSharpParameterHintingData (name, meth) :> ParameterHintingData)
  +                |> ResizeArray.ofArray
  +
  +            return ParameterHintingResult(hintingData, startOffset) 
           | _ -> LoggingService.LogWarning("FSharpTextEditorCompletion: Getting Parameter Info: no methods found")
  -               return null 
  -    with ex ->
  +               return ParameterHintingResult.Empty 
  +    with
  +    | :? Threading.Tasks.TaskCanceledException ->
  +        return ParameterHintingResult.Empty
  +    | ex ->
           LoggingService.LogError ("FSharpTextEditorCompletion: Error in HandleParameterCompletion", ex)
  -        return null})
  +        return ParameterHintingResult.Empty})
   
     override x.KeyPress (descriptor:KeyDescriptor) =
         // Avoid two dots in sucession turning inte ie '.CompareWith.' instead of '..'
  
positive.code:                 match symbolUse with
                  | Constructor c ->
                      Some c.EnclosingEntity.DisplayName
                  | TypeAbbreviation ta -> None
                  | Class cl -> None
                  | Delegate dl -> None
                  | Event ev ->
                      Some ev.EnclosingEntity.DisplayName
                  | Property pr ->
  
negative.code:   override x.HandleCodeCompletionAsync(context, completionChar, token) =
        if completionChar <> '.' then null else
  
        // We generally avoid forcing a re-typecheck on '.' by using TryGetRecentTypeCheckResults. Forcing a re-typecheck on a user action 
        // can cause a blocking delay in the UI (up to the blockingTimeout=500). We can't do it asynchronously because MD doesn't allow this yet). 
        //
        // However, if a '.' is pressed then in some situations the F# compiler language service really does need to re-typecheck, especially when
        // relying on 'expression' typings (rather than just name lookup). This is specifically the case on '.' because of this curious
        // line in service.fs: https://github.com/fsharp/fsharp/blob/0e80412570847e3e825b30f8636fc313ebaa3be0/src/fsharp/vs/service.fs#L771
        // where the location is adjusted by +1. However that location won't yield good expression typings because the results returned by 
        // TryGetRecentTypeCheckResults will be based on code where the '.' was not present.
        //
        // Because of this, we like to force re-typechecking in those situations where '.' is pressed AND when expression typings are highly 
        // likely to be useful. The most common example of this is where a character to the left of the '.' is not a letter. This catches 
        // situations like (abc + def).
        // Note, however, that this is just an approximation - for example no re-typecheck is enforced here:
        //      (abc + def).PPP.
        
  