anchor.diff:      /// TType_forall(typars, bodyTy).
       ///
       /// Indicates the type is a universal type, only used for types of values and members 
  -    | TType_forall of Typars * TType
  +    | TType_forall of typars: Typars * bodyTy: TType
   
       /// TType_app(tyconRef, typeInstantiation).
       ///
       /// Indicates the type is built from a named type and a number of type arguments
  -    | TType_app of TyconRef * TypeInst
  +    | TType_app of tyconRef: TyconRef * typeInstantiation: TypeInst
   
       /// TType_anon
       ///
       /// Indicates the type is an anonymous record type whose compiled representation is located in the given assembly
  -    | TType_anon of AnonRecdTypeInfo * TType list
  +    | TType_anon of anonInfo: AnonRecdTypeInfo * tys: TType list
   
       /// TType_tuple(elementTypes).
       ///
       /// Indicates the type is a tuple type. elementTypes must be of length 2 or greater.
  -    | TType_tuple of TupInfo * TTypes
  +    | TType_tuple of tupInfo: TupInfo * elementTypes: TTypes
   
       /// TType_fun(domainType, rangeType).
       ///
       /// Indicates the type is a function type 
  -    | TType_fun of TType * TType
  +    | TType_fun of domainType: TType * rangeType: TType
   
       /// TType_ucase(unionCaseRef, typeInstantiation)
       ///
       /// Indicates the type is a non-F#-visible type representing a "proof" that a union value belongs to a particular union case
       /// These types are not user-visible and will never appear as an inferred type. They are the types given to
       /// the temporaries arising out of pattern matching on union values.
  -    | TType_ucase of UnionCaseRef * TypeInst
  +    | TType_ucase of unionCaseRef: UnionCaseRef * typeInstantiation: TypeInst
   
       /// Indicates the type is a variable type, whether declared, generalized or an inference type parameter  
  -    | TType_var of Typar 
  +    | TType_var of typar: Typar 
   
       /// Indicates the type is a unit-of-measure expression being used as an argument to a type or member
  -    | TType_measure of Measure
  +    | TType_measure of measure: Measure
   
       /// For now, used only as a discriminant in error message.
       /// See https://github.com/Microsoft/visualfsharp/issues/2561
  
positive.code:     ///    tinst -- the instantiation of the declaring type
      ///    rfref -- the reference to the record field
      ///    isSetProp -- indicates if this is a set of a record field
      | FSRecdFieldSln of TypeInst * RecdFieldRef * bool
  
      /// Indicates a trait is solved by an F# anonymous record field.
      | FSAnonRecdFieldSln of AnonRecdTypeInfo * TypeInst * int
  
      /// ILMethSln(ty, extOpt, ilMethodRef, minst)
      ///
  
negative.code: type TyparConstraint = 
  
      /// A constraint that a type is a subtype of the given type 
      | CoercesTo of ty: TType * range: range
  
      /// A constraint for a default value for an inference type variable should it be neither generalized nor solved 
      | DefaultsTo of priority: int * ty: TType * range: range 
      
      /// A constraint that a type has a 'null' value 
      | SupportsNull of range: range 
      
      /// A constraint that a type has a member with the given signature 
      | MayResolveMember of constraintInfo: TraitConstraintInfo * range: range
      
      /// A constraint that a type is a non-Nullable value type 
      /// These are part of .NET's model of generic constraints, and in order to 
      /// generate verifiable code we must attach them to F# generalized type variables as well. 
      | IsNonNullableStruct of range: range 
      
      /// A constraint that a type is a reference type 
      | IsReferenceType of range: range 
  
      /// A constraint that a type is a simple choice between one of the given ground types. Only arises from 'printf' format strings. See format.fs 
      | SimpleChoice of tys: TTypes * range: range 
  
      /// A constraint that a type has a parameterless constructor 
      | RequiresDefaultConstructor of range: range 
  
      /// A constraint that a type is an enum with the given underlying 
      | IsEnum of ty: TType * range: range 
      
      /// A constraint that a type implements IComparable, with special rules for some known structural container types
      | SupportsComparison of range: range 
      
      /// A constraint that a type does not have the Equality(false) attribute, or is not a structural type with this attribute, with special rules for some known structural container types
      | SupportsEquality of range: range 
      
      /// A constraint that a type is a delegate from the given tuple of args to the given return type
      | IsDelegate of aty: TType * bty: TType * range: range 
      
      /// A constraint that a type is .NET unmanaged type
      | IsUnmanaged of range: range
  
      // %+A formatting is used, so this is not needed
      //[<DebuggerBrowsable(DebuggerBrowsableState.Never)>]
  