anchor.diff:  and 
       [<NoEquality; NoComparison>]
       SynModuleOrNamespace = 
  -    | SynModuleOrNamespace of LongIdent * (*isModule:*) bool * SynModuleDecls * PreXmlDoc * SynAttributes * SynAccess option * range 
  +    | SynModuleOrNamespace of id:LongIdent * isModule:bool * decls:SynModuleDecls * xmlDoc:PreXmlDoc * attributes:SynAttributes * access:SynAccess option * range:range 
       member this.Range =
           match this with
  -        | SynModuleOrNamespace(_,_,_,_,_,_,m) -> m
  +        | SynModuleOrNamespace (range=r) -> r
   
   and 
       [<NoEquality; NoComparison>]
       SynModuleOrNamespaceSig = 
  -    | SynModuleOrNamespaceSig of LongIdent * (*isModule:*) bool * SynModuleSigDecls * PreXmlDoc * SynAttributes * SynAccess option * range 
  +    | SynModuleOrNamespaceSig of id:LongIdent * isModule:bool * SynModuleSigDecls * xmlDoc:PreXmlDoc * attributes:SynAttributes * SynAccess option * range:range 
   
   and [<NoEquality; NoComparison>]
       ParsedHashDirective = 
  -    | ParsedHashDirective of string * string list * range
  +    | ParsedHashDirective of string * string list * range:range
   
   [<NoEquality; NoComparison; RequireQualifiedAccess>]
   type ParsedImplFileFragment = 
  -    | AnonModule of SynModuleDecls * range
  +    | AnonModule of moduleDecls:SynModuleDecls * range:range
       | NamedModule of SynModuleOrNamespace
  -    | NamespaceFragment of LongIdent * bool * SynModuleDecls * PreXmlDoc * SynAttributes * range
  +    | NamespaceFragment of longId:LongIdent * bool * moduleDecls:SynModuleDecls * xmlDoc:PreXmlDoc * attributes:SynAttributes * range:range
   
   [<NoEquality; NoComparison; RequireQualifiedAccess>]
   type ParsedSigFileFragment = 
  -    | AnonModule of SynModuleSigDecls * range
  +    | AnonModule of moduleSigDecl:SynModuleSigDecls * range:range
       | NamedModule of SynModuleOrNamespaceSig
  -    | NamespaceFragment of LongIdent * bool * SynModuleSigDecls * PreXmlDoc * SynAttributes * range
  +    | NamespaceFragment of longId:LongIdent * bool * moduleSigDecls:SynModuleSigDecls * xmlDoc:PreXmlDoc * attributes:SynAttributes * range:range
   
   [<NoEquality; NoComparison>]
   type ParsedFsiInteraction =
  -    | IDefns of SynModuleDecl list * range
  -    | IHash  of ParsedHashDirective * range
  +    | IDefns of SynModuleDecl list * range:range
  +    | IHash  of ParsedHashDirective * range:range
   
   [<NoEquality; NoComparison>]
   type ParsedImplFile = 
  -    | ParsedImplFile of ParsedHashDirective list * ParsedImplFileFragment list
  +    | ParsedImplFile of hashDirectives:ParsedHashDirective list * ParsedImplFileFragment list
   
   [<NoEquality; NoComparison>]
   type ParsedSigFile = 
  -    | ParsedSigFile of ParsedHashDirective list * ParsedSigFileFragment list
  +    | ParsedSigFile of hashDirectives:ParsedHashDirective list * ParsedSigFileFragment list
   
   //----------------------------------------------------------------------
   // AST and parsing utilities.
  
positive.code:     /// F# syntax : type<type, ..., type> or type type or (type,...,type) type
      ///   isPostfix: indicates a postfix type application e.g. "int list" or "(int,string) dict"
      ///   commasm: ranges for interstitial commas, these only matter for parsing/design-time tooling, the typechecker may munge/discard them
      | App of SynType * range option * SynType list * range list * range option * bool * range
      /// LongIdentApp(typeName, longId, LESSm, tyArgs, commasm, GREATERm, wholem)
      ///
      /// F# syntax : type.A.B.C<type, ..., type>
      ///   commasm: ranges for interstitial commas, these only matter for parsing/design-time tooling, the typechecker may munge/discard them
      | LongIdentApp of SynType * LongIdentWithDots * range option * SynType list * range list * range option * range
      /// F# syntax : type * ... * type
      // the bool is true if / rather than * follows the type
      | Tuple of (bool*SynType) list * range    
      /// F# syntax : type[]
      | Array of  int * SynType * range
      /// F# syntax : type -> type
      | Fun of  SynType * SynType * range
      /// F# syntax : 'Var
      | Var of SynTypar * range
      /// F# syntax : _
      | Anon of range
      /// F# syntax : typ with constraints
      | WithGlobalConstraints of SynType * SynTypeConstraint list * range
      /// F# syntax : #type
      | HashConstraint of SynType * range
      /// F# syntax : for units of measure e.g. m / s 
      | MeasureDivide of SynType * SynType * range       
      /// F# syntax : for units of measure e.g. m^3, kg^1/2
      | MeasurePower of SynType * SynRationalConst * range      
      /// F# syntax : 1, "abc" etc, used in parameters to type providers
      /// For the dimensionless units i.e. 1 , and static parameters to provided types
      | StaticConstant of SynConst * range          
      /// F# syntax : const expr, used in static parameters to type providers
      | StaticConstantExpr of SynExpr * range
      /// F# syntax : ident=1 etc., used in static parameters to type providers
      | StaticConstantNamed of SynType * SynType * range
      /// Get the syntactic range of source code covered by this construct.
      member x.Range = 
          match x with 
          | SynType.LongIdent(lidwd) -> lidwd.Range
          | SynType.App(_,_,_,_,_,_,m) | SynType.LongIdentApp(_,_,_,_,_,_,m) | SynType.Tuple(_,m) | SynType.Array(_,_,m) | SynType.Fun(_,_,m)
          | SynType.Var(_,m) | SynType.Anon m | SynType.WithGlobalConstraints(_,_,m)
          | SynType.StaticConstant(_,m) | SynType.StaticConstantExpr(_,m) | SynType.StaticConstantNamed(_,_,m)
          | SynType.HashConstraint(_,m) | SynType.MeasureDivide(_,_,m) | SynType.MeasurePower(_,_,m) -> m
  
      
  and  
      [<NoEquality; NoComparison;RequireQualifiedAccess>]
  
negative.code:     /// or implementation. 
      SynTypeDefnSimpleRepr =
      /// A union type definition, type X = A | B
      | Union      of accessiblity:SynAccess option * cases:SynUnionCases * range:range
      /// An enum type definition, type X = A = 1 | B = 2
      | Enum       of cases:SynEnumCases * range:range
      /// A record type definition, type X = { A : int; B : int }
      | Record     of accessiblity:SynAccess option * fields:SynFields * range:range
      /// An object oriented type definition. This is not a parse-tree form, but represents the core
      /// type representation which the type checker splits out from the 'ObjectModel' cases of type definitions.
      | General    of SynTypeDefnKind * (SynType * range * Ident option) list * (SynValSig * MemberFlags) list * SynField list  * bool * bool * SynSimplePat list option * range:range 
      /// A type defined by using an IL assembly representation. Only used in FSharp.Core.
      /// 
      /// F# syntax: type X = (# '...' #)
      | LibraryOnlyILAssembly of ILType * range:range
      /// A type abbreviation, 'type X = A.B.C'
      | TypeAbbrev of ParserDetail * SynType * range:range
      /// An abstract definition , 'type X'
      | None       of range
      member this.Range =
          match this with
          | Union (range=r)
          | Enum (range=r)
          | Record (range=r)
          | General (range=r)
          | LibraryOnlyILAssembly (range=r)
          | TypeAbbrev (range=r)
          | None r -> r
  
  and SynEnumCases = SynEnumCase list
  
  