anchor.diff:          | false, false -> a + " " + b
   
       let getKeywordTooltip (keyword:string) =
  -        let signatureline = asKeyword (escapeText keyword) ++ "(keyword)"
  +        let signatureline = escapeText keyword ++ "(keyword)"
           let summary =
               match KeywordList.keywordDescriptions.TryGetValue keyword with
               | true, description -> Full description
  
positive.code:             None
  
      let getTooltipFromParameter (p:FSharpParameter) context =
        let typ = asUserType (escapeText(p.Type.Format(context)))
        let signature =
            match p.Name with
            | Some name -> name ++ asSymbol ":" ++ typ
            | None -> typ
  
        signature, getSummaryFromSymbol p
  
negative.code:                     | _, _ -> c.MemberName, false
  
                  seq {
                      yield " : ("
                      if c.MemberIsStatic then yield "static "
  
                      yield "member "
                      yield formattedMemberName
                      yield " : "
  
                      if isProperty then
                          yield (c.MemberReturnType.Format displayContext)
                      else
                          if c.MemberArgumentTypes.Count <= 1 then
                              yield "unit"
                          else
                              yield asGenericParamName param
                          yield " -> "
                          yield ((c.MemberReturnType.Format displayContext).TrimStart())
  
                      yield ")"
                  }
  
              let typeConstraint (tc: FSharpType) =
                  seq {
                      yield " :> "
                      yield (tc.Format displayContext)
                  }
  
              let constructorConstraint () =
                  seq {
                      yield " : "
                      yield "("
                      yield "new"
                      yield " : "
                      yield "unit"
                      yield " -> '"
                      yield param.DisplayName
                      yield ")"
                  }
              let enumConstraint (ec: FSharpType) =
                  seq {
                      yield " : "
                      yield "enum"
                      yield escapeText "<"
                      yield ec.Format displayContext
                      yield escapeText ">"
                  }
  
              let delegateConstraint (tc: FSharpGenericParameterDelegateConstraint) =
                  seq {
                      yield " : "
                      yield "delegate"
                      yield escapeText "<"
                      yield tc.DelegateTupledArgumentType.Format displayContext
                      yield ", "
                      yield tc.DelegateReturnType.Format displayContext
                      yield escapeText ">"
                  }
  
              let symbols =
                  match constrainedBy with
                  | _ when constrainedBy.IsCoercesToConstraint -> typeConstraint constrainedBy.CoercesToTarget
                  | _ when constrainedBy.IsMemberConstraint -> memberConstraint constrainedBy.MemberConstraintData
                  | _ when constrainedBy.IsSupportsNullConstraint -> seq { yield " : "; yield "null" }
                  | _ when constrainedBy.IsRequiresDefaultConstructorConstraint -> constructorConstraint()
                  | _ when constrainedBy.IsReferenceTypeConstraint -> seq { yield " : "; yield "not struct" }
                  | _ when constrainedBy.IsEnumConstraint -> enumConstraint constrainedBy.EnumConstraintTarget
                  | _ when constrainedBy.IsComparisonConstraint -> seq { yield " : "; yield "comparison" }
                  | _ when constrainedBy.IsEqualityConstraint -> seq { yield " : "; yield "equality" }
                  | _ when constrainedBy.IsDelegateConstraint -> delegateConstraint constrainedBy.DelegateConstraintData
                  | _ when constrainedBy.IsUnmanagedConstraint -> seq { yield " : "; yield "unmanaged"}
                  | _ when constrainedBy.IsNonNullableValueTypeConstraint -> seq { yield " : "; yield "struct" }
                  | _ -> Seq.empty
  
              seq {
                  yield " when "
                  yield asGenericParamName param
                  yield! symbols
              }
  