anchor.diff:      let asBrackets = asType Brackets
       let asUserType = asType UserType
   
  +
   type TooltipResults =
   | ParseAndCheckNotFound
   | NoToolTipText
  
positive.code:     let printSymbol sb = Printf.bprintf sb "%s"
      let printSymbols sb symbols = symbols |> Seq.iter (printSymbol sb)
       
      let printParamName sb (param: FSharpGenericParameter) =
          printSymbol sb (asSymbol (if param.IsSolveAtCompileTime then "^" else "'"))
          printSymbol sb param.Name
  
  module SymbolTooltips =
  
  
negative.code:                         chopped, true
                      | _, _ -> c.MemberName, false
  
                  seq {
                      yield asSymbol " : ("
                      if c.MemberIsStatic then
                          yield asKeyword "static "
  
                      yield asKeyword "member "
                      yield asUserType formattedMemberName
                      yield asSymbol " : "
  
                      if isProperty then
                          yield asUserType (c.MemberReturnType.Format displayContext)
                      else 
                          if c.MemberArgumentTypes.Count <= 1 then
                              yield asUserType "unit"
                          else
                              printGenericParamName sb param
                          yield asSymbol " -> "
                          yield asUserType ((c.MemberReturnType.Format displayContext).TrimStart())
                      
                      yield asBrackets ")"
                  }
  
              let typeConstraint (tc: FSharpType) =
                  seq {
                      yield asSymbol " :> "
                      yield asUserType (tc.Format displayContext)
                  }
              
              let constructorConstraint () =
                  seq {
                      yield asSymbol " : "
                      yield asBrackets "("
                      yield asKeyword "new"
                      yield asSymbol " : "
                      yield asKeyword "unit"
                      yield asSymbol " -> '"
                      yield param.DisplayName
                      yield asBrackets ")" 
                  }
              let enumConstraint (ec: FSharpType) =
                  seq {
                      yield asSymbol " : "
                      yield asKeyword "enum"
                      yield asBrackets (escapeText "<")
                      yield asUserType (ec.Format displayContext)
                      yield asBrackets (escapeText ">")
                  }
  
              let delegateConstraint (tc: FSharpGenericParameterDelegateConstraint) =
                  seq {
                      yield asSymbol " : "
                      yield asKeyword "delegate"
                      yield asBrackets (escapeText "<")
                      yield asUserType (tc.DelegateTupledArgumentType.Format displayContext)
                      yield asSymbol ", "
                      yield asUserType (tc.DelegateReturnType.Format displayContext)
                      yield asBrackets (escapeText ">")
                  }
  
              let symbols = 
                  match constrainedBy with
                  | _ when constrainedBy.IsCoercesToConstraint -> typeConstraint constrainedBy.CoercesToTarget
                  | _ when constrainedBy.IsMemberConstraint -> memberConstraint constrainedBy.MemberConstraintData
                  | _ when constrainedBy.IsSupportsNullConstraint -> seq { yield asSymbol " : "; yield asKeyword "null" }
                  | _ when constrainedBy.IsRequiresDefaultConstructorConstraint -> constructorConstraint()
                  | _ when constrainedBy.IsReferenceTypeConstraint -> seq { yield asSymbol " : "; yield asKeyword "not struct" }
                  | _ when constrainedBy.IsEnumConstraint -> enumConstraint constrainedBy.EnumConstraintTarget
                  | _ when constrainedBy.IsComparisonConstraint -> seq { yield asSymbol " : "; yield asKeyword "comparison" }
                  | _ when constrainedBy.IsEqualityConstraint -> seq { yield asSymbol " : "; yield asKeyword "equality" }
                  | _ when constrainedBy.IsDelegateConstraint -> delegateConstraint constrainedBy.DelegateConstraintData
                  | _ when constrainedBy.IsUnmanagedConstraint -> seq { yield asSymbol " : "; yield asKeyword "unmanaged"}
                  | _ -> Seq.empty
  
              seq { 
                  yield asKeyword " when "
                  yield asGenericParamName param
                  yield! symbols
              }
  
  
          if param.Constraints.Count > 0 then
              param.Constraints 
              |> Seq.collect getConstraintSymbols 
              |> Seq.iter(fun symbol -> printSymbol sb symbol)
  
          sb.ToString()
  
  