anchor.diff:          | Some tyRes ->
           // Get tool-tip from the language service
           let line, col, lineStr = MonoDevelop.getLineInfoFromOffset(offset, editor.Document)
  -        let tip = tyRes.GetToolTip(line, col, lineStr) |> Async.RunSynchronously
  +        let tip, symbolUse = async {let! tooltip = tyRes.GetToolTip(line, col, lineStr)
  +                                    let! symbol = tyRes.GetSymbol(line, col, lineStr)
  +                                    return tooltip, symbol} |> Async.RunSynchronously
  +
  +        let typeTip =
  +            match symbolUse with
  +            | Some symbolUse -> 
  +                match symbolUse.Symbol with
  +                | :? FSharpEntity as fse ->
  +                    try
  +                        let cs = getColourScheme()
  +
  +                        let displayName = fse.DisplayName
  +
  +                        let modifier = match fse.Accessibility with
  +                                       | a when a.IsInternal -> hl "internal " cs.KeywordTypes
  +                                       | a when a.IsPrivate -> hl "private " cs.KeywordTypes
  +                                       | _ -> ""
  +
  +                        let attributes =
  +                            // Maybe search for modifier attributes like abstract, sealed and append them above the type:
  +                            // [<Abstract>]
  +                            // type Test = ...
  +                            String.Join ("\n", fse.Attributes 
  +                                               |> Seq.map (fun a -> let name = a.AttributeType.DisplayName.Replace("Attribute", "")
  +                                                                    let parameters = String.Join(", ",  a.ConstructorArguments |> Seq.filter (fun ca -> ca :? string ) |> Seq.cast<string>)
  +                                                                    if String.IsNullOrWhiteSpace parameters then "[<" + name + ">]"
  +                                                                    else "[<" + name + "( " + parameters + " )" + ">]" ) 
  +                                               |> Seq.toArray)
  +
  +                        let signature =
  +                            let typeName =
  +                                match fse with
  +                                | _ when fse.IsFSharpModule -> "module"
  +                                | _ when fse.IsEnum         -> "enum"
  +                                | _ when fse.IsValueType    -> "struct"
  +                                | _                         -> "type"
  +
  +                            let enumtip () =
  +                                hl " =" cs.KeywordOperators + "\n" + 
  +                                hl "| " cs.KeywordOperators +
  +                                (fse.FSharpFields
  +                                |> Seq.filter (fun f -> not f.IsCompilerGenerated)
  +                                |> Seq.map (fun field -> field.Name) //TODO Fix FSC to expose enum filed literals: field.Name + (hl " = " cs.KeywordOperators) + hl field.LiteralValue cs.UserTypesValueTypes*)
  +                                |> String.concat ("\n" + hl "| " cs.KeywordOperators) )
  +               
  +
  +                            let uniontip () = 
  +                                hl " =" cs.KeywordOperators + "\n" + 
  +                                hl "| " cs.KeywordOperators +
  +                                (fse.UnionCases 
  +                                |> Seq.map (fun unionCase -> 
  +                                                if unionCase.UnionCaseFields.Count > 0 then
  +                                                   let typeList =
  +                                                      unionCase.UnionCaseFields
  +                                                      |> Seq.map (fun unionField -> unionField.Name + (hl " : " cs.KeywordOperators) + hl (unionField.FieldType.Format symbolUse.DisplayContext) cs.UserTypes ) 
  +                                                      |> String.concat (hl " * " cs.KeywordOperators)
  +                                                   unionCase.Name + (hl " of " cs.KeywordTypes) + typeList
  +                                                 else unionCase.Name)
  +
  +                                |> String.concat ("\n" + hl "| " cs.KeywordOperators) )
  +                                                     
  +                            modifier +
  +                            hl typeName cs.KeywordTypes ++ 
  +                            hl displayName cs.UserTypes +
  +                            (if fse.IsFSharpUnion then uniontip()
  +                             elif fse.IsEnum then enumtip() 
  +                             else "") +
  +                            "\n\nFull name: " + fse.FullName
  +
  +                        ToolTip(signature, getSummaryFromSymbol symbolUse, getSegFromSymbolUse editor symbolUse)
  +                    with exn -> ToolTips.EmptyTip
  +
  +                | :? FSharpMemberFunctionOrValue as func ->
  +                    try
  +                    if func.CompiledName = ".ctor" then 
  +                        if func.EnclosingEntity.IsValueType || func.EnclosingEntity.IsEnum then
  +                            //TODO: Add ValueType
  +                            ToolTips.EmptyTip
  +                        else
  +                            //TODO: Add ReferenceType
  +                            ToolTips.EmptyTip
  +
  +                    elif func.FullType.IsFunctionType && not func.IsPropertyGetterMethod && not func.IsPropertySetterMethod && not symbolUse.IsFromComputationExpression then 
  +                        if isOperator func.DisplayName then
  +                            //TODO: Add operators, the text will look like:
  +                            // val ( symbol ) : x:string -> y:string -> string
  +                            // Full name: Name.Blah.( symbol )
  +                            // Note: (In the current compiler tooltips a closure defined symbol will be missing the named types and the full name)
  +                            ToolTips.EmptyTip
  +                        else
  +                            //TODO: Add closure/nested functions
  +                            if not func.IsModuleValueOrMember then
  +                                //represents a closure or nested function
  +                                ToolTips.EmptyTip
  +                            else
  +                                let signature =
  +
  +                                    let cs = getColourScheme()
  +
  +                                    let backupSignature = func.FullType.Format symbolUse.DisplayContext
  +                                    let argInfos =
  +                                        func.CurriedParameterGroups 
  +                                        |> Seq.map Seq.toList 
  +                                        |> Seq.toList 
  +
  +                                    let retType = hl (GLib.Markup.EscapeText(func.ReturnParameter.Type.Format symbolUse.DisplayContext)) cs.UserTypes
  +
  +                                    //example of building up the parameters using Display name and Type
  +                                    let signature =
  +                                        let padLength = argInfos |> List.concat |> List.map (fun p -> p.DisplayName.Length) |> List.max
  +                                        let parameters = 
  +                                            match argInfos with
  +                                            | [] -> retType
  +                                            | [[single]] -> "   " + single.DisplayName + hl ": " cs.KeywordOperators + hl (GLib.Markup.EscapeText(single.Type.Format symbolUse.DisplayContext)) cs.UserTypes
  +                                            | many ->
  +                                                many
  +                                                |> List.map(fun listOfParams ->
  +                                                                listOfParams
  +                                                                |> List.map(fun (p:FSharpParameter) ->
  +                                                                                "   " + p.DisplayName.PadRight (padLength) + hl ": " cs.KeywordOperators + hl (GLib.Markup.EscapeText(p.Type.Format symbolUse.DisplayContext)) cs.UserTypes)
  +                                                                                |> String.concat (hl " * " cs.KeywordOperators + "\n"))
  +                                                |> String.concat (hl " ->" cs.KeywordOperators + "\n")
  +                                        parameters + hl ("\n   " + (String.replicate (padLength-1) " ") +  "-> ") cs.KeywordOperators + retType
  +
  +                                    let modifiers = 
  +                                        if func.IsMember then 
  +                                            if func.IsInstanceMember then
  +                                                if func.IsDispatchSlot then "abstract member"
  +                                                else "member"
  +                                            else "static member"
  +                                        else
  +                                            if func.InlineAnnotation = FSharpInlineAnnotation.AlwaysInline then "inline val"
  +                                            elif func.IsInstanceMember then "val"
  +                                            else "val" //does this need to be static prefixed?
  +
  +                                    hl modifiers cs.KeywordTypes ++ func.DisplayName + hl " : " cs.KeywordOperators + "\n" + signature
  +
  +                                ToolTip(signature, getSummaryFromSymbol symbolUse, getSegFromSymbolUse editor symbolUse)                            
  +
  +                    else
  +                        //val name : Type
  +                        let signature =
  +                                let cs = getColourScheme()
  +                                let retType = hl (GLib.Markup.EscapeText(func.ReturnParameter.Type.Format symbolUse.DisplayContext)) cs.UserTypes
  +                                let prefix = 
  +                                    if func.IsMutable then hl "val" cs.KeywordTypes ++ hl "mutable" cs.KeywordModifiers
  +                                    else hl "val" cs.KeywordTypes
  +                                prefix ++ func.DisplayName ++ hl ":" cs.KeywordOperators ++ retType
  +
  +                        ToolTip(signature, getSummaryFromSymbol symbolUse, getSegFromSymbolUse editor symbolUse)
  +                    with exn -> ToolTips.EmptyTip
  +
  +                | _ -> ToolTips.EmptyTip
  +
  +            | None -> ToolTips.EmptyTip
  +        
  +        //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) -> TooltipItem ((signature, summary), textSeg)
  +        | EmptyTip ->
  +
           match tip with
           | None -> LoggingService.LogWarning "TooltipProvider: TootipText not returned"
                     null
  
positive.code: 
      // Keep the last result and tooltip window cached
      let mutable lastResult = None : TooltipItem option
      static let mutable lastWindow = None
  
      let killTooltipWindow() =
         match lastWindow with
         | Some(w:TooltipInformationWindow) -> w.Destroy()
  
negative.code:     override x.CreateTooltipWindow (editor, offset, modifierState, item) = 
          let doc = IdeApp.Workbench.ActiveDocument
          if (doc = null) then null else
          //At the moment as the new tooltips are unfinished we have two types here
          // ToolTipText for the old tooltips and (string * XmlDoc) for the new tooltips
          match item.Item with 
          | :? ToolTipText as titem ->
              let tooltip = TipFormatter.formatTip(titem)
  