anchor.diff:      ///
       /// Parenthesized expressions. Kept in AST to distinguish A.M((x,y)) 
       /// from A.M(x,y), among other things.
  -    | Paren of SynExpr * range * range option * range  
  +    | Paren of expr:SynExpr * leftParenRange:range * rightParenRange:range option * range:range  
   
       /// F# syntax: <@ expr @>, <@@ expr @@>
       /// 
       /// Quote(operator,isRaw,quotedSynExpr,isFromQueryExpression,m)
  -    | Quote of SynExpr * bool * SynExpr * bool * range 
  +    | Quote of operator:SynExpr * isRaw:bool * quotedSynExpr:SynExpr * isFromQueryExpression:bool * range:range 
   
       /// F# syntax: 1, 1.3, () etc.
  -    | Const of SynConst * range
  +    | Const of constant:SynConst * range:range
   
       /// F# syntax: expr : type
  -    | Typed of  SynExpr * SynType * range
  +    | Typed of  expr:SynExpr * typeSig:SynType * range:range
   
       /// F# syntax: e1, ..., eN
  -    | Tuple of  SynExpr list * range list * range  // "range list" is for interstitial commas, these only matter for parsing/design-time tooling, the typechecker may munge/discard them
  +    | Tuple of  exprs:SynExpr list * commaRanges:range list * range:range  // "range list" is for interstitial commas, these only matter for parsing/design-time tooling, the typechecker may munge/discard them
   
       /// F# syntax: [ e1; ...; en ], [| e1; ...; en |]
  -    | ArrayOrList of  bool * SynExpr list * range 
  +    | ArrayOrList of  isList:bool * exprs:SynExpr list * range:range 
   
       /// F# syntax: { f1=e1; ...; fn=en }
       /// SynExpr.Record((baseType, baseCtorArgs, mBaseCtor, sepAfterBase, mInherits), (copyExpr, sepAfterCopyExpr), (recordFieldName, fieldValue, sepAfterField), mWholeExpr)
       /// inherit includes location of separator (for tooling) 
       /// copyOpt contains range of the following WITH part (for tooling)
       /// every field includes range of separator after the field (for tooling)
  -    | Record of (SynType * SynExpr * range * BlockSeparator option * range) option * (SynExpr * BlockSeparator) option * (RecordFieldName * (SynExpr option) * BlockSeparator option) list * range
  +    | Record of baseInfo:(SynType * SynExpr * range * BlockSeparator option * range) option * copyInfo:(SynExpr * BlockSeparator) option * recordFields:(RecordFieldName * (SynExpr option) * BlockSeparator option) list * range:range
   
       /// F# syntax: new C(...)
       /// The flag is true if known to be 'family' ('protected') scope 
  -    | New of bool * SynType * SynExpr * range 
  +    | New of isProtected:bool * typeName:SynType * expr:SynExpr * range:range 
   
       /// SynExpr.ObjExpr(objTy,argOpt,binds,extraImpls,mNewExpr,mWholeExpr)
       ///
       /// F# syntax: { new ... with ... }
  -    | ObjExpr of SynType * (SynExpr * Ident option) option * SynBinding list * SynInterfaceImpl list * range * range
  +    | ObjExpr of objType:SynType * argOpt:(SynExpr * Ident option) option * bindings:SynBinding list * extraImpls:SynInterfaceImpl list * newPos:range * range:range
   
       /// F# syntax: 'while ... do ...'
  -    | While of SequencePointInfoForWhileLoop * SynExpr * SynExpr * range
  +    | While of spWhile:SequencePointInfoForWhileLoop * whileBody:SynExpr * doBody:SynExpr * range:range
   
       /// F# syntax: 'for i = ... to ... do ...'
  -    | For of SequencePointInfoForForLoop * Ident * SynExpr * bool * SynExpr * SynExpr * range
  +    | For of spFor:SequencePointInfoForForLoop * id:Ident * idBody:SynExpr * bool * toBody:SynExpr * doBody:SynExpr * range:range
   
       /// SynExpr.ForEach (spBind, seqExprOnly, isFromSource, pat, enumExpr, bodyExpr, mWholeExpr).
       ///
       /// F# syntax: 'for ... in ... do ...'
  -    | ForEach of SequencePointInfoForForLoop * SeqExprOnly * bool * SynPat * SynExpr * SynExpr * range
  +    | ForEach of spFor:SequencePointInfoForForLoop * seqExprOnly:SeqExprOnly * isFromSource:bool * pattern:SynPat * enumExpr:SynExpr * bodyExpr:SynExpr * range:range
   
       /// F# syntax: [ expr ], [| expr |]
  -    | ArrayOrListOfSeqExpr of bool * SynExpr * range
  +    | ArrayOrListOfSeqExpr of isList:bool * elements:SynExpr * range:range
   
       /// CompExpr(isArrayOrList, isNotNakedRefCell, expr)
       ///
       /// F# syntax: { expr }
  -    | CompExpr of bool * bool ref * SynExpr * range
  +    | CompExpr of isArrayOrList:bool * isNotNakedRefCell:bool ref * expr:SynExpr * range:range
   
       /// First bool indicates if lambda originates from a method. Patterns here are always "simple" 
       /// Second bool indicates if this is a "later" part of an iterated sequence of lambdas
       ///
       /// F# syntax: fun pat -> expr
  -    | Lambda of  bool * bool * SynSimplePats * SynExpr * range 
  +    | Lambda of  fromMethod:bool * inLambdaSeq:bool * args:SynSimplePats * body:SynExpr * range:range 
   
       /// F# syntax: function pat1 -> expr | ... | patN -> exprN
  -    | MatchLambda of bool * range * SynMatchClause list * SequencePointInfoForBinding * range
  +    | MatchLambda of bool * range * clauses:SynMatchClause list * spBind:SequencePointInfoForBinding * range:range
   
       /// F# syntax: match expr with pat1 -> expr | ... | patN -> exprN
  -    | Match of  SequencePointInfoForBinding * SynExpr * SynMatchClause list * bool * range (* bool indicates if this is an exception match in a computation expression which throws unmatched exceptions *)
  +    | Match of  spBind:SequencePointInfoForBinding * matchExpr:SynExpr * clauses:SynMatchClause list * isCexprExceptionMatch:bool * range:range (* bool indicates if this is an exception match in a computation expression which throws unmatched exceptions *)
   
       /// F# syntax: do expr 
  -    | Do of  SynExpr * range
  +    | Do of  expr:SynExpr * range:range
   
       /// F# syntax: assert expr 
  -    | Assert of SynExpr * range
  +    | Assert of expr:SynExpr * range:range
   
       /// App(exprAtomicFlag, isInfix, funcExpr, argExpr, m)
       ///  - exprAtomicFlag: indicates if the application is syntactically atomic, e.g. f.[1] is atomic, but 'f x' is not
  
positive.code:     [<NoEquality; NoComparison>]
      /// Represents the explicit declaration of a type parameter
      SynTyparDecl = 
      | TyparDecl of SynAttributes * SynTypar
  
  
  and 
  
negative.code:     [<NoEquality; NoComparison>]
      SynBinding = 
      | Binding of 
          access:SynAccess option *
          bindingKind:SynBindingKind *  
          mustInline:bool  *  
          isMutable:bool  *  
          attributes:SynAttributes * 
          xmlDoc:PreXmlDoc *
          SynValData * 
          headPat:SynPat * 
          SynBindingReturnInfo option * 
          expr:SynExpr  *
          lhsRange:range *
          spBind:SequencePointInfoForBinding
      // no member just named 'Range', as that would be confusing: 
      //  - for everything else, the 'range' member that appears last/second-to-last is the 'full range' of the whole tree construct
      //  - but for Binding, the 'range' is only the range of the left-hand-side, the right-hand-side range is in the SynExpr
      //  - so we use explicit names to avoid confusion
  