anchor.diff:  // Statements
   /// An expression statement, i.e., a statement consisting of a single expression.
   type ExpressionStatement =
  -    {
  -        Expression: Expression
  -    }
  -    static member AsStatement(expression) : Statement =
  -        {
  -            Expression = expression
  -        } |> ExpressionStatement
  -    interface IPrintable with
  -        member this.Print(printer) =
  -            printer.Print(this.Expression)
  +    { Expression: Expression }
  +
  +    static member AsStatement(expression): Statement = { Expression = expression } |> ExpressionStatement
  +
  +    interface IPrintable with
  +        member this.Print(printer) = printer.Print(this.Expression)
   
   /// A block statement, i.e., a sequence of statements surrounded by braces.
   type BlockStatement =
  -    {
  -        Body: Statement array
  -    }
  +    { Body: Statement array }
   
       static member Create(body) = // ?directives_,
  -        {
  -            Body = body
  -        }
  -    static member AsStatement(body) =
  -        BlockStatement.Create(body) |> BlockStatement
  -//    let directives = [||] // defaultArg directives_ [||]
  +        { Body = body }
  +
  +    static member AsStatement(body) = BlockStatement.Create(body) |> BlockStatement
  +    //    let directives = [||] // defaultArg directives_ [||]
   //    member _.Directives: Directive array = directives
       interface IPrintable with
  -        member this.Print(printer) =
  -            printer.PrintBlock(this.Body)
  +        member this.Print(printer) = printer.PrintBlock(this.Body)
   
   /// An empty statement, i.e., a solitary semicolon.
   //type EmptyStatement(?loc) =
  
positive.code:             printer.Print(")")
  
  type NewExpression =
      {
          Callee: Expression
          // Arguments: Choice<Expression, SpreadElement> array = arguments
          Arguments: Expression array
          TypeArguments: TypeParameterInstantiation option
          Loc: SourceLocation option
      }
      static member AsExpr(callee, arguments, ?typeArguments, ?loc) : Expression =
          {
              Callee = callee
              Arguments = arguments
              TypeArguments = typeArguments
              Loc = loc
          } |> NewExpression
      interface IPrintable with
          member this.Print(printer) =
              printer.Print("new ", ?loc=this.Loc)
  
negative.code: 
  // Binary Operations
  type BinaryExpression =
      { Left: Expression
        Right: Expression
        Operator: string
        Loc: SourceLocation option }
  
      static member AsExpr(operator_, left, right, ?loc): Expression =
          let operator =
              match operator_ with
              | BinaryEqual -> "=="
  