anchor.diff:      let asBrackets = asType Brackets
       let asUserType = asType UserType
   
  +
   type TooltipResults =
   | ParseAndCheckNotFound
   | NoToolTipText
  
positive.code:                         chopped, true
                      | _, _ -> c.MemberName, false
  
                  printSymbol sb (asSymbol " : (")
                  if c.MemberIsStatic then
                      printSymbol sb (asKeyword "static ")
  
                  printSymbols sb [ asKeyword "member "
                                    asUserType formattedMemberName
                                    asSymbol " : " ]
  
                  if isProperty then
                      printSymbol sb (asUserType (c.MemberReturnType.Format displayContext))
                  else 
                      if c.MemberArgumentTypes.Count <= 1 then
                          printSymbol sb (asUserType "unit")
                      else
                          printParamName sb param
                      printSymbols sb [ asSymbol " -> "
                                        asUserType ((c.MemberReturnType.Format displayContext).TrimStart()) ]
  
                  printSymbol sb (asBrackets ")")
  
              let typeConstraint (tc: FSharpType) =
                  printSymbols sb [ asSymbol " :> "
                                    asUserType (tc.Format displayContext) ]
  
              let constructorConstraint () =
                  printSymbols sb [ asSymbol " : "
                                    asBrackets "("
                                    asKeyword "new"
                                    asSymbol " : "
                                    asKeyword "unit"
                                    asSymbol " -> '"
                                    param.DisplayName
                                    asBrackets ")" ]
  
              let enumConstraint (ec: FSharpType) =
                  printSymbols sb [ asSymbol " : "
                                    asKeyword "enum"
                                    asBrackets (escapeText "<")
                                    asUserType (ec.Format displayContext)
                                    asBrackets (escapeText ">") ]
  
              let delegateConstraint (tc: FSharpGenericParameterDelegateConstraint) =
                  printSymbols sb [ asSymbol " : "
                                    asKeyword "delegate"
                                    asBrackets (escapeText "<")
                                    asUserType (tc.DelegateTupledArgumentType.Format displayContext)
                                    asSymbol ", "
                                    asUserType (tc.DelegateReturnType.Format displayContext)
                                    asBrackets (escapeText ">") ]
  
              match constrainedBy with
              | _ when constrainedBy.IsCoercesToConstraint -> typeConstraint constrainedBy.CoercesToTarget
              | _ when constrainedBy.IsMemberConstraint -> memberConstraint constrainedBy.MemberConstraintData
              | _ when constrainedBy.IsSupportsNullConstraint -> printSymbols sb [(asSymbol " : "); (asKeyword "null")]
              | _ when constrainedBy.IsRequiresDefaultConstructorConstraint -> constructorConstraint()
              | _ when constrainedBy.IsReferenceTypeConstraint -> printSymbols sb [(asSymbol " : "); asKeyword "not struct"]
              | _ when constrainedBy.IsEnumConstraint -> enumConstraint constrainedBy.EnumConstraintTarget
              | _ when constrainedBy.IsComparisonConstraint -> printSymbols sb [(asSymbol " : "); (asKeyword "comparison")]
              | _ when constrainedBy.IsEqualityConstraint -> printSymbols sb [(asSymbol " : "); (asKeyword "equality")]
              | _ when constrainedBy.IsDelegateConstraint -> delegateConstraint constrainedBy.DelegateConstraintData
              | _ when constrainedBy.IsUnmanagedConstraint -> printSymbols sb [(asSymbol " : "); (asKeyword "unmanaged")]
              | _ -> ()
  
          if param.Constraints.Count > 0 then
              param.Constraints |> Seq.iter formatConstraint
  
          sb.ToString()
  
  
negative.code: 
          let sb = new StringBuilder()
          
          printGenericParamName sb param
  
          let getConstraintSymbols (constrainedBy: FSharpGenericParameterConstraint) =
              let memberConstraint (c: FSharpGenericParameterMemberConstraint) =
                  let hasPropertyShape =
                      (c.MemberIsStatic && c.MemberArgumentTypes.Count = 0) ||
  