anchor.diff:      | NumericLiteral of NumericLiteral
       | DirectiveLiteral of DirectiveLiteral
   
  -    interface IPrintable with
  -        member this.Print(printer) =
  -            match this with
  -            | RegExp(l) -> printer.Print(l)
  -            | NullLiteral(l) -> printer.Print(l)
  -            | StringLiteral(l) -> printer.Print(l)
  -            | BooleanLiteral(l) -> printer.Print(l)
  -            | NumericLiteral(l) -> printer.Print(l)
  -            | DirectiveLiteral(l) -> printer.Print(l)
  +    member this.Print(printer: Printer) =
  +        match this with
  +        | RegExp(l) -> l.Print(printer)
  +        | NullLiteral(l) -> l.Print(printer)
  +        | StringLiteral(l) -> l.Print(printer)
  +        | BooleanLiteral(l) -> l.Print(printer)
  +        | NumericLiteral(l) -> l.Print(printer)
  +        | DirectiveLiteral(l) -> l.Print(printer)
   
   type Statement =
       | Declaration of Declaration
  
positive.code:     | ContinueStatement of ContinueStatement
      | ExpressionStatement of ExpressionStatement
  
      interface IPrintable with
          member this.Print(printer) =
              match this with
              | Declaration(s) -> printer.Print(s)
              | IfStatement(s) -> printer.Print(s)
              | TryStatement(s) -> printer.Print(s)
              | ForStatement(s) -> printer.Print(s)
              | BreakStatement(s) -> printer.Print(s)
              | WhileStatement(s) -> printer.Print(s)
              | ThrowStatement(s) -> printer.Print(s)
              | BlockStatement(s) -> printer.Print(s)
              | ReturnStatement(s) -> printer.Print(s)
              | SwitchStatement(s) -> printer.Print(s)
              | LabeledStatement(s) -> printer.Print(s)
              | DebuggerStatement(s) -> printer.Print(s)
              | ContinueStatement(s) -> printer.Print(s)
              | ExpressionStatement(s) -> printer.Print(s)
  
  /// Note that declarations are considered statements; this is because declarations can appear in any statement context.
  type Declaration =
  
negative.code:         VariableDeclaration.AsDeclaration(var, ?init = init, ?kind = kind, ?loc = loc)
          |> Declaration
  
      member this.Print(printer: Printer) =
          printer.Print(this.Kind + " ", ?loc = this.Loc)
          let canConflict = this.Declarations.Length > 1
  
          for i = 0 to this.Declarations.Length - 1 do
              let decl = this.Declarations.[i]
              decl.Id.Print(printer)
  
              match decl.Init with
              | None -> ()
              | Some e ->
                  printer.Print(" = ")
                  if canConflict then printer.ComplexExpressionWithParens(e)
                  else printer.SequenceExpressionWithParens(e)
              if i < this.Declarations.Length - 1 then
                  printer.Print(", ")
  
  // Loops
  type WhileStatement =
  