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: //    member _.Print(_) = ()
  
  type DebuggerStatement =
      {
          Loc: SourceLocation option
      }
      static member AsStatement(?loc) : Statement =
          {
              Loc = loc
          } |> DebuggerStatement
      interface IPrintable with
          member this.Print(printer) =
              printer.Print("debugger", ?loc=this.Loc)
  
  /// Statement (typically loop) prefixed with a label (for continue and break)
  type LabeledStatement =
      {
          Body: Statement
          Label: Identifier
      }
      static member AsStatement(label, body) : Statement =
          {
              Body = body
              Label = label
          } |> LabeledStatement
      interface IPrintable with
          member this.Print(printer) =
              printer.Print(this.Label)
  
negative.code:             printer.Print(this.Value)
  
  type ObjectTypeIndexer =
      { Id: Identifier option
        Key: Identifier
        Value: TypeAnnotationInfo
        Static: bool option }
  
      static member Create(key, value, ?id, ?``static``): Node =
          { Id = id
            Key = key
            Value = value
            Static = ``static`` }
          |> ObjectTypeIndexer
  
      interface IPrintable with
          member _.Print(_) = failwith "not implemented"
  
  type ObjectTypeCallProperty =
      { Value: TypeAnnotationInfo
        Static: bool option }
  
      static member Create(value, ?``static``) = { Value = value; Static = ``static`` }
  
      interface IPrintable with
          member _.Print(_) = failwith "not implemented"
  
  type ObjectTypeInternalSlot =
      { Id: Identifier
        Value: TypeAnnotationInfo
        Optional: bool
        Static: bool
        Method: bool }
  
      static member Create(id, value, optional, ``static``, method) =
          { Id = id
            Value = value
            Optional = optional
            Static = ``static``
            Method = method }
      interface IPrintable with
          member _.Print(_) = failwith "not implemented"
  
  type ObjectTypeAnnotation =
      { Properties: ObjectTypeProperty array
        Indexers: ObjectTypeIndexer array
        CallProperties: ObjectTypeCallProperty array
        InternalSlots: ObjectTypeInternalSlot array
        Exact: bool }
  
      static member Create(properties, ?indexers_, ?callProperties_, ?internalSlots_, ?exact_) =
          let exact = defaultArg exact_ false
          let indexers = defaultArg indexers_ [||]
          let callProperties = defaultArg callProperties_ [||]
          let internalSlots = defaultArg internalSlots_ [||]
  
          { Properties = properties
            Indexers = indexers
            CallProperties = callProperties
            InternalSlots = internalSlots
            Exact = exact }
  
      interface IPrintable with
          member this.Print(printer) =
              printer.Print("{")
  