anchor.diff:  
   %% Generates a SourceLocation node
   -spec source_location(pos_integer(),
  -                     non_neg_integer(),
  -                     non_neg_integer()) -> source_location_node().
  +                      non_neg_integer(),
  +                      non_neg_integer()) -> source_location_node().
   source_location(LineNumber, ColStart, ColEnd) ->
       %?spec([{LineNumber, integer}, {ColStart, integer}, {ColEnd, integer}]),
       node("SourceLocation", [{"source", null},
  
positive.code: 
  %% Generates a Function expression
  -spec function_expression(identifier_node() | 'null',
                           [identifier_node()],
                           block_statement_node(),
                           boolean()) -> function_expression_node().
  function_expression(Identifier, Params, Body, Expression) ->
      %?spec([{Identifier, [identifier, null]},
      %       {Params, list_of_identifier},
      %       {Body, blockStatement},
      %       {Expression, boolean}]),
      update_record(expression(), [{"type", <<"FunctionExpression">>},
                                  {"id", Identifier},
                                  {"params", Params},
                                  {"body", Body},
                                  {"expression", Expression}]).
  
  %% Generate a sequence expression
  -spec sequence_expression([expression_node()]) -> sequence_expression_node().
  sequence_expression(Expressions) ->
      %?spec([{Expressions, list_of_expression}]),
      update_record(expression(), [{"type", <<"SequenceExpression">>},
                                  {"expressions", Expressions}]).
  
  %% Generate a unary operation expression
  -spec unary_expression(any(),
                        boolean(),
                        expression_node()) -> unary_expression_node().
  unary_expression(Operator, Prefix, Argument) when ?IS_UNARY_OPERATOR(Operator)  ->
      %?spec([{Operator, anything},
      %       {Prefix, boolean},
      %       {Argument, expression}]),
      update_record(expression(), [{"type", <<"UnaryExpression">>},
                                  {"operator", Operator},
                                  {"prefix", Prefix},
                                  {"argument", Argument}]).
  
  %% Generate an assignment expression
  -spec assignment_expression(any(),
                             expression_node(),
                             expression_node()) -> assignment_expression_node().
  assignment_expression(Operator, Left, Right) ->
      %?spec([{Operator, anything},
      %       {Left, expression},
      %       {Right, expression}]),
      update_record(expression(), [{"type", <<"AssignmentExpression">>},
                                  {"operator", Operator},
                                  {"left", Left},
                                  {"right", Right}]).
  
  %% Generate a binary operation expression
  -spec binary_expression(any(),
                         expression_node(),
                         expression_node()) -> binary_expression_node().
  binary_expression(Operator, Left, Right) when ?IS_BINARY_OPERATOR(Operator) ->
      %?spec([{Operator, anything},
      %       {Left, expression},
      %       {Right, expression}]),
      update_record(expression(), [{"type", <<"BinaryExpression">>},
                                  {"operator", Operator},
                                  {"left", Left},
                                  {"right", Right}]).
  
  %% Generate an update (increment or decrement) operator expression
  -spec update_expression(any(),
                         expression_node(),
                         boolean()) -> update_expression_node().
  update_expression(Operator, Argument, Prefix) when ?IS_UPDATE_OPERATOR(Operator) ->
      %?spec([{Operator, anything},
      %       {Argument, expression},
      %       {Prefix, boolean}]),
      update_record(expression(), [{"type", <<"UpdateExpression">>},
                                  {"operator", Operator},
                                  {"argument", Argument},
                                  {"prefix", Prefix}]).
  
  %% Generate a logical operator expression
  -spec logical_expression(any(),
                          expression_node(),
                          expression_node()) -> logical_expression_node().
  logical_expression(Operator, Left, Right) when ?IS_LOGICAL_OPERATOR(Operator) ->
      %?spec([{Operator, anything},
      %       {Left, expression},
      %       {Right, expression}]),
      update_record(expression(), [{"type", <<"LogicalExpression">>},
                                  {"operator", Operator},
                                  {"left", Left},
                                  {"right", Right}]).
  
  %% Generate a conditional expression
  -spec conditional_expression(expression_node(),
                              expression_node(),
                              expression_node()) -> conditional_expression_node().
  conditional_expression(Test, Alternate, Consequent) ->
      %?spec([{Test, expression}, {Alternate, expression}, {Consequent, expression}]),
      update_record(expression(), [{"type", <<"ConditionalExpression">>},
                                  {"test", Test},
                                  {"alternate", Alternate},
                                  {"consequent", Consequent}]).
  
  %% Generate a new expression
  -spec new_expression(expression_node(),
                      [expression_node()]) -> new_expression_node().
  new_expression(Callee, Arguments) ->
      %?spec([{Callee, expression}, {Arguments, list_of_expression}]),
      update_record(expression(), [{"type", <<"NewExpression">>},
                                  {"callee", Callee},
                                  {"arguments", Arguments}]).
  
  %% Generate a call expression
  -spec call_expression(expression_node(),
                       [expression_node()]) -> call_expression_node().
  call_expression(Callee, Arguments) ->
      %?spec([{Callee, expression}, {Arguments, list_of_expression}]),
      update_record(expression(), [{"type", <<"CallExpression">>},
                                  {"callee", Callee},
                                  {"arguments", Arguments}]).
  
  %% Generate a member expression
  -spec member_expression(expression_node(),
                         identifier_node() | expression_node(),
                         boolean()) -> member_expression_node().
  member_expression(Object, Property, Computed) ->
      %?spec([{Object, expression}, {Property, [identifier, expression]}, {Computed, boolean}]),
      update_record(expression(), [{"type", <<"MemberExpression">>},
                                  {"object", Object},
                                  {"property", Property},
                                  {"computed", Computed}]).
  
  
  
  
  
  
negative.code:                               | while_statement_node()
                                | for_statement_node()
                                | for_in_statement_node()
                                | for_of_statement_node()
                                | do_while_statement_node()
                                | debugger_statement_node().
  
  %% Declarations
  -type variable_declaration_node() :: {'__estree_node', 'VariableDeclaration', PropertyFields::es_node_fields()}.
  