anchor.diff:  [<System.Diagnostics.DebuggerDisplay("{idText}")>]
   [<Sealed>]
   [<NoEquality; NoComparison>]
  -type Ident (text,range) = 
  +type Ident (text,range) =
        member x.idText = text
        member x.idRange = range
        override x.ToString() = text
   
   type LongIdent = Ident list
   type LongIdentWithDots =
  -    /// LongIdentWithDots(lid, dotms)   
  +    /// LongIdentWithDots(lid, dotms)
       /// Typically dotms.Length = lid.Length-1, but they may be same if (incomplete) code ends in a dot, e.g. "Foo.Bar."
  -    /// The dots mostly matter for parsing, and are typically ignored by the typechecker, but 
  +    /// The dots mostly matter for parsing, and are typically ignored by the typechecker, but
       /// if dotms.Length = lid.Length, then the parser must have reported an error, so the typechecker is allowed
       /// more freedom about typechecking these expressions.
       /// LongIdent can be empty list - it is used to denote that name of some AST element is absent (i.e. empty type name in inherit)
  
positive.code:     member x.RangeOfBindingAndRhs = let (Binding(_,_,_,_,_,_,_,_,_,e,m,_)) = x in unionRanges e.Range m
      member x.RangeOfHeadPat = let (Binding(_,_,_,_,_,_,_,headPat,_,_,_,_)) = x in headPat.Range
  
  and 
      [<NoEquality; NoComparison>]
      SynBindingReturnInfo = 
      | SynBindingReturnInfo of typeName:SynType * range:range * attributes:SynAttributes
  
  
  and 
      [<NoComparison>]
      MemberFlags =
      { IsInstance: bool
  
negative.code: type RecordFieldName = LongIdentWithDots * bool
  
  type ExprAtomicFlag =
      /// Says that the expression is an atomic expression, i.e. is of a form that has no whitespace unless
      /// enclosed in parentheses, e.g. 1, "3", ident, ident.[expr] and (expr). If an atomic expression has
      /// type T, then the largest expression ending at the same range as the atomic expression also has type T.
      | Atomic = 0
      | NonAtomic = 1
  
  /// The kind associated with a binding - "let", "do" or a standalone expression
  type SynBindingKind =
      /// A standalone expression in a module
      | StandaloneExpression
      /// A normal 'let' binding in a module
      | NormalBinding
      /// A 'do' binding in a module. Must have type 'unit'
      | DoBinding
  
  type
      [<NoEquality; NoComparison>]
      /// Represents the explicit declaration of a type parameter
      SynTyparDecl =
      | TyparDecl of attributes:SynAttributes * SynTypar
  
  
  and
      [<NoEquality; NoComparison>]
      /// The unchecked abstract syntax tree of F# type constraints
      SynTypeConstraint =
  