C>- name и type некликабельные, т.е. для них нельзя задать handler, а может оно и не надо

<hint value='текст отображаемый вместо данного тега' key='ключ' handler='обработчик'>ХМЛ вложенного хинта</hint>

private Func<string, string> _getHintContent;

public void Show(IntPtr owner, Rect placementRect, Func<string, string> getHintContent, string text)

def makeTypeStr(key : string) : string
{
  def ty = idToTypeMap[int.Parse(key)];
  def cnv = Convert();
  cnv.ConvertTypeName = convertTypeName;
  $"<hint>$(cnv.FixedTypeToString(ty))</hint>"
}

mutable currentId = 1;
def idToTypeMap = Hashtable();
def getTyId(ty) : int
{
  currentId++;
  idToTypeMap.Add(currentId, ty);
  currentId
}

def convertTypeName(ty, name)
{
  $"<font color='DarkCyan'><hint value='$name' key='$(getTyId(ty))' /></font>"
}

<tbl>
  <row><col><keyword>this</keyword></col><col>param1</col><col>: Type1, </col></row>
  <row><col>[NotNull]</col>              <col>param2</col><col>: Type2</col></row>
</tbl>

C>PS В svn коммить лучше сам

CallbackOnCollectedDelegate was detected
Message: A callback was made on a garbage collected delegate of type 'WpfHint!WpfHint.Win32+Callback::Invoke'. This may cause application crashes, corruption and data loss. When passing delegates to unmanaged code, they must be kept alive by the managed application until it is guaranteed that they will never be called.

        // PreviewHint event handler
        void OnPreviewHint(PreviewHintArgs args)
        {
            // analyze args.Key
            // if (valid)
            // {
            //  args.HintText = ...
            //  args.ShowHint = true
            // }
            // else            
            //  args.ShowHint = false
        }

        class PreviewHintArgs
        {
            public string Key { get; private set; }
            public string HintText { get; set; }
            public bool ShowHint { get; set; }
        }

C>        // PreviewHint event handler
C>        void OnPreviewHint(PreviewHintArgs args)
C>        {
C>            // analyze args.Key
C>            // if (valid)
C>            // {
C>            //  args.HintText = ...
C>            //  args.ShowHint = true
C>            // }
C>            // else            
C>            //  args.ShowHint = false
C>        }

if (Service.ShowHint(view, hintSpan, tipInfo.GetHintContent, hintText))
  return (int)TipSuccesses2.TIP_S_NODEFAULTTIP;

    public GetDelayedHintHendler() : Func[string, string]
    {
      def makeTypeStr(key : string) : string
      {
        AddNamespaces  = true;
        ExpandTypeArgs = false;
        def ty = _idToTypeMap[int.Parse(key)];
        
        def makeDelegateExt(ti)
        {
          def m = ti.LookupMember("Invoke").Head;
          "<lb/>Signature: " + FixedTypeToString(m.GetMemType()) + "<lb/>"
          + "Inferred: " + TypeVarToString(ty.TypeOfMember(m))
        }
        
        def baseTypesExt(ti : TypeInfo, baseTypeName = "Base type") : string
        {
          def implementsInfo(itfs : list[MType.Class]) : string
          {
            def plural = if (itfs.Length > 1) "s" else "";
            def prompt = if (ti.IsInterface) $"Base interface$plural" else "Implements";
            if (itfs.IsEmpty) ""
            else $<#<lb/>$prompt: ..$(itfs; ", "; FixedClassTypeToString)#>
          }
          def old = AddNamespaces;
          AddNamespaces = false;
          def itfs1 = ti.GetDirectSuperTypes();
          def baseType = ti.BaseType;
          def itfs = if (baseType == null) itfs1 else itfs1.Tail;
          def res = 
            if (baseType != null)
              $"<lb/>$baseTypeName: " + TypeVarToString(ty.GetInstantiatedSuperType(baseType)) + implementsInfo(itfs)
            else implementsInfo(itfs);
          
          AddNamespaces = old;
          
          res
        }
        
        def (kind, ext) = 
          match (ty)
          {
            | Class(ti, _args) => 
              def (kind, ext) =
                if      (ti.IsDelegate)  ("delegate ", makeDelegateExt(ti))
                else if (ti.IsModule)    ("module ", "")
                else if (ti.IsValueType) ("value type ", "")
                else match (ti.GetTydecl())
                {
                  | Class     with kind = "class "
                  | Interface with kind = "interface " => (kind, baseTypesExt(ti))
                  | VariantOption => 
                    def old = AddNamespaces;
                    AddNamespaces = false;
                    def flds = ti.GetFields(BFlg.DeclaredOnly | BFlg.Instance | BFlg.Public)
                                 .Map(f => $"$(f.Name) : $(TypeVarToString(ty.TypeOfMember(f)));");
                    def flds = if (flds.IsEmpty) "" else  $<#<lb/>Fields: ..$flds#>;
                    AddNamespaces = old;
                    ("variant option ", flds + baseTypesExt(ti, "Declaring variant"))
                      
                  | Variant(members) when members.IsEmpty => ("variant ", baseTypesExt(ti))
                  | Variant(members) =>
                    def old = AddNamespaces;
                    AddNamespaces = false;
                    def ops = members.Map(o => FixedClassTypeToString(o.GetMemType()));
                    AddNamespaces = old;
                    ("variant ", $<#<lb/>Variant options: ..$ops<lb/>$(baseTypesExt(ti))#>)
                    
                  | Enum              => ("enum ", "")
                  | Alias             => assert(false);
                };
              def obsolete = if (ti.IsObsolete) "[Obsolete] " else "";

              (obsolete + "<keyword>" + Utils.MakeAccessModifiers(ti) + kind + "</keyword>", ext)
            
            | TyVarRef       => ("type parameter ", "")
            | Fun            => ("function type ", "")
            | Tuple          => ("tuple ", "")
            | Array(_, rank) => ($"$rank dimention ", "")
            | Ref            => ("ref parameter ", "")
            | Out            => ("out parameter ", "")
            | Void           => ("", "")
            | Intersection   => ("", "")
          };
        
        $"<hint>$kind$(FixedTypeToString(ty))$ext</hint>"
      }
      
      makeTypeStr
    }

C>        class PreviewHintArgs
C>        {
C>            public string Key { get; private set; }
C>            public string HintText { get; set; }
C>            public bool ShowHint { get; set; }
C>        }
C>

Теперь обещанное описание требуемых возможностей

Форматирвоание

<hint value='отображаемое значение' key='ключ для считывания содержимого вложенного хинта'/>
<hint value='отображаемое значение'>Содержимое вложенного хинта в котором так же возможна разметка</hint>

Некоторый текст вначале
<tabulated>
  <row><col>текст первой колонки</col><col>текст второй колонки</col></row>
  <row><col>текст первой колонки второй стоки</col><col>текст второй колонки второй стоки</col></row>
  ...
</tabulated>
текст в конце

public GetInheritors([NotNull]filePath : string, line : int, col : int) : array [GotoInfo]

public GetInheritors(
<tabulated>
   <row><col>[NotNull]</col> <col>filePath </col> <col>: string, </col></row>
   <row><col></col>          <col>line </col>     <col>: int, </col></row>
   <row><col></col>          <col>col </col>      <col>: int</col></row>
<tabulated>
) : array [GotoInfo]

public GetInheritors([NotNull]filePath : string, line : int, col : int) : array [GotoInfo]

public GetInheritors(
  [NotNull] filePath : string, 
            line     : int, 
            col      : int
) : array [GotoInfo]/c#]

Перенос строк