anchor.diff:              let toolTipInfo = new TooltipInformation(SignatureMarkup = signature)
               match xmldoc with
               | Full(summary) -> toolTipInfo.SummaryMarkup <- summary
  -            | Lookup(key, filename) ->
  -                match filename with
  -                | Some f ->
  -                    let markup = TipFormatter.findDocForEntity(f, key)
  -                    match markup with
  -                    | Some summaryText -> toolTipInfo.SummaryMarkup <- Tooltips.getTooltip Styles.simpleMarkup summaryText
  -                    | _ -> ()
  -                | _ -> ()
  -            | _ -> ()
  -
  +            | Lookup(key, potentialFilename) ->
  +                let summary = 
  +                    maybe {let! filename = potentialFilename
  +                           let! markup = TipFormatter.findDocForEntity(filename, key)
  +                           let summary = Tooltips.getTooltip Styles.simpleMarkup markup
  +                           return summary}
  +                summary |> Option.iter (fun summary -> toolTipInfo.SummaryMarkup <- summary)
  +            | EmptyDoc -> ()
               result.AddOverload(toolTipInfo)
               result.RepositionWindow ()                  
               result :> _
  
positive.code:             if String.IsNullOrWhiteSpace xmlDocSig then XmlDoc.EmptyDoc
              else Lookup(xmlDocSig, symbolUse.Symbol.Assembly.FileName)
  
  /// Resolves locations to tooltip items, and orchestrates their display.
  /// We resolve language items to an NRefactory symbol.
  type FSharpTooltipProvider() = 
  
negative.code:         if docText = null || offset >= docText.Length || offset < 0 then null else
  
          let projFile, files, args, framework = MonoDevelop.getCheckerArgs(extEditor.Project, fileName)
  
          let line, col, lineStr = MonoDevelop.getLineInfoFromOffset(offset, editor.Document)
          let result = async {
             let! parseAndCheckResults = MDLanguageService.Instance.GetTypedParseResultWithTimeout (projFile, fileName, docText, files, args, AllowStaleResults.MatchingSource, ServiceSettings.blockingTimeout, framework)
             LoggingService.LogInfo "TooltipProvider: Getting tool tip"
             match parseAndCheckResults with
             | None -> return ParseAndCheckNotFound
             | Some parseAndCheckResults ->
                 let! symbol = parseAndCheckResults.GetSymbol(line, col, lineStr)
                 let typeTip = getTooltipFromSymbol symbol extEditor
                 // As the new tooltips are unfinished we match ToolTip here to use the new tooltips and anything else to run through the old tooltip system
                 // In the section above we return EmptyTip for any tooltips symbols that have not yet ben finished
                 match typeTip with
                 | ToolTip(signature, summary, textSeg) ->
                      //check to see if the last result is the same tooltipitem, if so return the previous tooltipitem
                      match lastResult with
                      | Some(tooltipItem) when
                          tooltipItem.Item :? (string * XmlDoc) &&
                          tooltipItem.Item :?> (string * XmlDoc) = (signature, summary) &&
                          tooltipItem.ItemSegment = textSeg ->
                              return Tooltip tooltipItem
                      //If theres no match or previous cached result generate a new tooltipitem
                      | Some(_)
                      | None -> let tooltipItem = TooltipItem ((signature, summary), textSeg)
                                lastResult <- Some(tooltipItem)
                                return Tooltip tooltipItem
                 | EmptyTip ->
                     // Get tool-tip from the language service
                     let! tip = parseAndCheckResults.GetToolTip(line, col, lineStr)
                     match tip with
                     | None -> return NoToolTipText
                     | Some (ToolTipText(elems),_) when elems |> List.forall (function ToolTipElementNone -> true | _ -> false) -> return NoToolTipData
                     | Some(tiptext,(col1,col2)) -> 
                         LoggingService.LogInfo "TooltipProvider: Got data"
                         //check to see if the last result is the same tooltipitem, if so return the previous tooltipitem
                         match lastResult with
                         | Some(tooltipItem) when
                             tooltipItem.Item :? ToolTipText && 
                             tooltipItem.Item :?> ToolTipText = tiptext && 
                             tooltipItem.ItemSegment = TextSegment(editor.LocationToOffset (line, col1 + 1), col2 - col1) ->
                                 return Tooltip tooltipItem
                         //If theres no match or previous cached result generate a new tooltipitem
                         | Some(_)
                         | None -> let line = editor.Document.OffsetToLineNumber offset
                                   let segment = TextSegment(editor.LocationToOffset (line, col1 + 1), col2 - col1)
                                   let tooltipItem = TooltipItem (tiptext, segment)
                                   lastResult <- Some(tooltipItem)
                                   return Tooltip tooltipItem } |> Async.RunSynchronously
          match result with
          | ParseAndCheckNotFound -> LoggingService.LogWarning "TooltipProvider: ParseAndCheckResults not found"; null
          | NoToolTipText -> LoggingService.LogWarning "TooltipProvider: TootipText not returned"; null
          | NoToolTipData -> LoggingService.LogWarning "TooltipProvider: No data found"; null
          | Tooltip t -> t
         
        with exn -> LoggingService.LogError ("TooltipProvider: Error retrieving tooltip", exn); null
  
      override x.CreateTooltipWindow (editor, offset, modifierState, item) = 
          let doc = IdeApp.Workbench.ActiveDocument
  