rkelly-turbo 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: aef98d0989a1aa032fe7e0231129fb518d13c45ff7b359ce4f805fb40a23116e
+  data.tar.gz: 2aef9b143d414fb8c9dc3ddcc67d51e674375d7889ccdc738fe6f909bbeaf239
+SHA512:
+  metadata.gz: 95c57e77d03ed1bc68daabb5cc8450b2fba7cad9bc98dcbea9c2cc7443386f87b90b9369f553dd0c29ce4154701763783385deb9d3f1f1a30f9232cbd110c3d9
+  data.tar.gz: a562b85535364137bd5675506e9c56054be829dbac4d4e347da000bc548a5d33e71adc20baa316c179027a66e10385a6ce7ed410a0248a661d8c05011f5e3c2e

data/CHANGELOG.rdoc

@@ -0,0 +1,38 @@
+= RKelly-Turbo CHANGELOG
+
+=== 0.1.0
+
+* Gain about 2x speedup by enacting some optimizations.
+
+=== 0.0.7
+
+* Allow reserved words reserved only in strict mode.
+
+=== 0.0.6
+
+* Properly treat all unicode whitespace characters as whitespace.
+
+=== 0.0.5
+
+* Update list of reserved words to match ECMAScript 5
+* Fix ecma visitor for function expressions with name
+
+=== 0.0.4
+
+* Allow use of keywords in property names.
+
+=== 0.0.3
+
+* Add RKelly::Parser#stopped_at method for error reporting.
+
+=== 0.0.2
+
+* Handle multibyte characters without crashing.
+
+=== 0.0.1
+
+* A fork of RKelly
+* 10x speedup of Tokenizer.
+* Full begin/end line/char info on each node.
+* List all comment nodes in root node instead of attempting to associate them with syntax nodes and failing at it.
+* Recognize /[/]/ as valid JS regex.

data/Manifest.txt

@@ -0,0 +1,203 @@
+CHANGELOG.rdoc
+Manifest.txt
+README.rdoc
+Rakefile
+lib/parser.y
+lib/rkelly.rb
+lib/rkelly/char_pos.rb
+lib/rkelly/char_range.rb
+lib/rkelly/constants.rb
+lib/rkelly/generated_parser.rb
+lib/rkelly/js.rb
+lib/rkelly/js/array.rb
+lib/rkelly/js/base.rb
+lib/rkelly/js/boolean.rb
+lib/rkelly/js/function.rb
+lib/rkelly/js/function_prototype.rb
+lib/rkelly/js/global_object.rb
+lib/rkelly/js/math.rb
+lib/rkelly/js/nan.rb
+lib/rkelly/js/number.rb
+lib/rkelly/js/object.rb
+lib/rkelly/js/object_prototype.rb
+lib/rkelly/js/property.rb
+lib/rkelly/js/scope.rb
+lib/rkelly/js/string.rb
+lib/rkelly/lexeme.rb
+lib/rkelly/nodes.rb
+lib/rkelly/nodes/binary_node.rb
+lib/rkelly/nodes/bracket_accessor_node.rb
+lib/rkelly/nodes/case_clause_node.rb
+lib/rkelly/nodes/comma_node.rb
+lib/rkelly/nodes/conditional_node.rb
+lib/rkelly/nodes/dot_accessor_node.rb
+lib/rkelly/nodes/for_in_node.rb
+lib/rkelly/nodes/for_node.rb
+lib/rkelly/nodes/function_call_node.rb
+lib/rkelly/nodes/function_decl_node.rb
+lib/rkelly/nodes/function_expr_node.rb
+lib/rkelly/nodes/if_node.rb
+lib/rkelly/nodes/label_node.rb
+lib/rkelly/nodes/new_expr_node.rb
+lib/rkelly/nodes/node.rb
+lib/rkelly/nodes/not_strict_equal_node.rb
+lib/rkelly/nodes/op_equal_node.rb
+lib/rkelly/nodes/postfix_node.rb
+lib/rkelly/nodes/prefix_node.rb
+lib/rkelly/nodes/property_node.rb
+lib/rkelly/nodes/resolve_node.rb
+lib/rkelly/nodes/strict_equal_node.rb
+lib/rkelly/nodes/try_node.rb
+lib/rkelly/nodes/var_decl_node.rb
+lib/rkelly/parser.rb
+lib/rkelly/runtime.rb
+lib/rkelly/runtime/ruby_function.rb
+lib/rkelly/runtime/scope_chain.rb
+lib/rkelly/syntax_error.rb
+lib/rkelly/token.rb
+lib/rkelly/tokenizer.rb
+lib/rkelly/visitable.rb
+lib/rkelly/visitors.rb
+lib/rkelly/visitors/dot_visitor.rb
+lib/rkelly/visitors/ecma_visitor.rb
+lib/rkelly/visitors/enumerable_visitor.rb
+lib/rkelly/visitors/evaluation_visitor.rb
+lib/rkelly/visitors/function_visitor.rb
+lib/rkelly/visitors/pointcut_visitor.rb
+lib/rkelly/visitors/real_sexp_visitor.rb
+lib/rkelly/visitors/sexp_visitor.rb
+lib/rkelly/visitors/visitor.rb
+test/ecma_script_test_case.rb
+test/execute_test_case.rb
+test/execution_contexts/test_10_1_3-1.rb
+test/expressions/test_11_3_1.rb
+test/expressions/test_11_3_2.rb
+test/expressions/test_11_4_2.rb
+test/expressions/test_11_4_3.rb
+test/expressions/test_11_4_4.rb
+test/expressions/test_11_4_5.rb
+test/expressions/test_11_4_6.rb
+test/expressions/test_11_4_8.rb
+test/expressions/test_11_4_9.rb
+test/expressions/test_11_5_1.rb
+test/expressions/test_11_5_2.rb
+test/expressions/test_11_5_3.rb
+test/expressions/test_11_6_1-1.rb
+test/expressions/test_11_9_1.rb
+test/function/test_15_3_1_1-1.rb
+test/global_object/test_15_1_1_1.rb
+test/global_object/test_15_1_1_2.rb
+test/global_object/test_15_1_1_3.rb
+test/helper.rb
+test/node_test_case.rb
+test/object/test_15_2_1_1.rb
+test/object/test_15_2_1_2.rb
+test/object/test_15_2_2_1.rb
+test/statements/test_12_5-1.rb
+test/test_add_node.rb
+test/test_arguments_node.rb
+test/test_array_node.rb
+test/test_assign_expr_node.rb
+test/test_automatic_semicolon_insertion.rb
+test/test_bit_and_node.rb
+test/test_bit_or_node.rb
+test/test_bit_x_or_node.rb
+test/test_bitwise_not_node.rb
+test/test_block_node.rb
+test/test_bracket_accessor_node.rb
+test/test_break_node.rb
+test/test_case_block_node.rb
+test/test_case_clause_node.rb
+test/test_char_pos.rb
+test/test_char_range.rb
+test/test_comma_node.rb
+test/test_comments.rb
+test/test_conditional_node.rb
+test/test_const_statement_node.rb
+test/test_continue_node.rb
+test/test_delete_node.rb
+test/test_divide_node.rb
+test/test_do_while_node.rb
+test/test_dot_accessor_node.rb
+test/test_ecma_visitor.rb
+test/test_element_node.rb
+test/test_empty_statement_node.rb
+test/test_equal_node.rb
+test/test_evaluation_visitor.rb
+test/test_expression_statement_node.rb
+test/test_false_node.rb
+test/test_for_in_node.rb
+test/test_for_node.rb
+test/test_function_body_node.rb
+test/test_function_call_node.rb
+test/test_function_decl_node.rb
+test/test_function_expr_node.rb
+test/test_function_visitor.rb
+test/test_getter_property_node.rb
+test/test_global_object.rb
+test/test_greater_node.rb
+test/test_greater_or_equal_node.rb
+test/test_if_node.rb
+test/test_in_node.rb
+test/test_instance_of_node.rb
+test/test_label_node.rb
+test/test_left_shift_node.rb
+test/test_less_node.rb
+test/test_less_or_equal_node.rb
+test/test_line_number.rb
+test/test_logical_and_node.rb
+test/test_logical_not_node.rb
+test/test_logical_or_node.rb
+test/test_modulus_node.rb
+test/test_multiply_node.rb
+test/test_new_expr_node.rb
+test/test_not_equal_node.rb
+test/test_not_strict_equal_node.rb
+test/test_null_node.rb
+test/test_number_node.rb
+test/test_object_literal_node.rb
+test/test_op_and_equal_node.rb
+test/test_op_divide_equal_node.rb
+test/test_op_equal_node.rb
+test/test_op_l_shift_equal_node.rb
+test/test_op_minus_equal_node.rb
+test/test_op_mod_equal_node.rb
+test/test_op_multiply_equal_node.rb
+test/test_op_or_equal_node.rb
+test/test_op_plus_equal_node.rb
+test/test_op_r_shift_equal_node.rb
+test/test_op_u_r_shift_equal_node.rb
+test/test_op_x_or_equal_node.rb
+test/test_parameter_node.rb
+test/test_parser.rb
+test/test_pointcut_visitor.rb
+test/test_postfix_node.rb
+test/test_prefix_node.rb
+test/test_property_node.rb
+test/test_regexp_node.rb
+test/test_resolve_node.rb
+test/test_return_node.rb
+test/test_right_shift_node.rb
+test/test_rkelly.rb
+test/test_runtime.rb
+test/test_scope_chain.rb
+test/test_setter_property_node.rb
+test/test_source_elements.rb
+test/test_strict_equal_node.rb
+test/test_string_node.rb
+test/test_subtract_node.rb
+test/test_switch_node.rb
+test/test_this_node.rb
+test/test_throw_node.rb
+test/test_tokenizer.rb
+test/test_true_node.rb
+test/test_try_node.rb
+test/test_type_of_node.rb
+test/test_unary_minus_node.rb
+test/test_unary_plus_node.rb
+test/test_unsigned_right_shift_node.rb
+test/test_var_decl_node.rb
+test/test_var_statement_node.rb
+test/test_void_node.rb
+test/test_while_node.rb
+test/test_with_node.rb

data/README.rdoc

@@ -0,0 +1,135 @@
+= RKelly Remix
+
+https://github.com/nene/rkelly-remix
+
+== DESCRIPTION
+
+RKelly Remix is a fork of the
+RKelly[https://github.com/tenderlove/rkelly] JavaScript parser.
+
+== Install
+
+  gem install rkelly-remix
+
+Note that you can't have rkelly and rkelly-remix both installed at the
+same time.  That would cause a conflict since they're both included
+with:
+
+  require 'rkelly'
+
+== Example
+
+  # Iterate over and modify a JavaScript AST.  Then print the modified
+  # AST as JavaScript.
+  require 'rkelly'
+
+  parser = RKelly::Parser.new
+  ast    = parser.parse(
+    "for(var i = 0; i < 10; i++) { var x = 5 + 5; }"
+  )
+
+  ast.each do |node|
+    node.value  = 'hello' if node.value == 'i'
+    node.name   = 'hello' if node.respond_to?(:name) && node.name == 'i'
+  end
+  puts ast.to_ecma # => awesome javascript
+
+== Why fork?
+
+Currently the original RKelly project is unmaintained.  The latest
+release was in late 2012, and since then the author has not responded
+to bug reports or pull requests.
+
+I created this fork mainly to satisfy the needs of my
+JSDuck[https://github.com/senchalabs/jsduck] project, but you too
+should consider using it, as it fixes several problems in the original
+RKelly:
+
+=== Much improved speed
+
+* 20 x faster in Ruby 1.8.
+* 2 x faster in Ruby 1.9 and 2.0.
+
+=== Correct start/end position data for all syntax nodes
+
+Original RKelly only had a rudimentary support for getting the line
+number of an AST node, and even that was often wrong.
+
+In RKelly Remix each AST node has a range property, which contains
+granular data about the exact location of the node in source code:
+
+  parser = RKelly::Parser.new
+  ast = parser.parse(<<-eojs)
+    function aaron() {
+      var x = 10;
+      return 1 + 1;
+    }
+  eojs
+
+  node = ast.pointcut(ReturnNode).matches.first
+
+  node.range.to_s  # <{line:3 char:5 (41)}...{line:3 char:17 (53)}>
+
+  node.range.from.line   # 3
+  node.range.from.char   # 5
+  node.range.from.index  # 41
+
+  node.range.to.line     # 3
+  node.range.to.char     # 17
+  node.range.to.index    # 53
+
+=== Sensible comments handling
+
+Original RKelly attempted to associate each comment with a related AST
+node, but failed to correctly do so, which is understandable, as there
+is no standard way to do such a mapping.  RKelly Remix abandons this
+and just lists all commenst in the root node, leaving the user with
+the task of associating them with AST nodes if he desires so (the same
+approach is taken by another JS parser: Esprima[http://esprima.org] ).
+
+  parser = RKelly::Parser.new
+  ast = parser.parse(<<-eojs)
+    /**
+     * This is an awesome test comment.
+     */
+    function aaron() { // This is a side comment
+      var x = 10;
+      return 1 + 1; // Equals two!
+    }
+  eojs
+
+  # print out all the comments
+  ast.comments.each do |c|
+    puts c.value
+  end
+
+=== Improved parser
+
+* List of reserved words matches with ECMAScript 5.1.
+* Keywords are allowed in property names.
+* Multibyte characters are supported in Ruby >= 1.9.
+* Correct parsing of regexes like /[/]/
+
+== License
+
+The MIT License
+
+Copyright (c) 2007, 2008, 2009 Aaron Patterson, John Barnette
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE

data/Rakefile

@@ -0,0 +1,41 @@
+require 'rubygems'
+require 'hoe'
+
+Hoe.plugin :gemspec # `gem install hoe-gemspec`
+Hoe.plugin :git     # `gem install hoe-git`
+
+GENERATED_PARSER = "lib/rkelly/generated_parser.rb"
+
+HOE = Hoe.spec('rkelly-turbo') do |p|
+  license "MIT"
+  developer('Aaron Patterson', 'aaron.patterson@gmail.com')
+  developer('Rene Saarsoo', 'rene.saarsoo@sencha.com')
+  developer('hmdne', '54514036+hmdne@users.noreply.github.com')
+  self.readme_file   = 'README.rdoc'
+  self.history_file  = 'CHANGELOG.rdoc'
+  self.extra_rdoc_files  = FileList['*.rdoc']
+  self.clean_globs   = [GENERATED_PARSER]
+end
+
+file GENERATED_PARSER => "lib/parser.y" do |t|
+  if ENV['DEBUG']
+    sh "racc -g -v -o #{t.name} #{t.prerequisites.first}"
+  else
+    sh "racc -o #{t.name} #{t.prerequisites.first}"
+  end
+end
+
+task :parser => GENERATED_PARSER
+
+# make sure the parser's up-to-date when we test
+Rake::Task[:test].prerequisites << :parser
+Rake::Task[:check_manifest].prerequisites << :parser
+
+namespace :gem do
+  task :spec do
+    File.open("#{HOE.name}.gemspec", 'w') do |f|
+      HOE.spec.version = "#{HOE.version}.#{Time.now.strftime("%Y%m%d%H%M%S")}"
+      f.write(HOE.spec.to_ruby)
+    end
+  end
+end

data/lib/parser.y

@@ -0,0 +1,883 @@
+/* vim: set filetype=racc : */
+
+class RKelly::GeneratedParser
+
+/* Literals */
+token NULL TRUE FALSE
+
+/* keywords */
+token BREAK CASE CATCH CONST CONTINUE DEBUGGER DEFAULT DELETE DO ELSE
+token FINALLY FOR FUNCTION IF IN INSTANCEOF NEW RETURN SWITCH THIS THROW TRY
+token TYPEOF VAR VOID WHILE WITH
+
+/* reserved keywords */
+token RESERVED
+
+/* punctuators */
+token EQEQ NE                     /* == and != */
+token STREQ STRNEQ                /* === and !== */
+token LE GE                       /* < and > */
+token OR AND                      /* || and && */
+token PLUSPLUS MINUSMINUS         /* ++ and --  */
+token LSHIFT                      /* << */
+token RSHIFT URSHIFT              /* >> and >>> */
+token PLUSEQUAL MINUSEQUAL        /* += and -= */
+token MULTEQUAL DIVEQUAL          /* *= and /= */
+token LSHIFTEQUAL                 /* <<= */
+token RSHIFTEQUAL URSHIFTEQUAL    /* >>= and >>>= */
+token ANDEQUAL MODEQUAL           /* &= and %= */
+token XOREQUAL OREQUAL            /* ^= and |= */
+
+/* Terminal types */
+token REGEXP
+token NUMBER
+token STRING
+token IDENT
+
+token AUTOPLUSPLUS AUTOMINUSMINUS IF_WITHOUT_ELSE
+
+prechigh
+  nonassoc ELSE
+  nonassoc IF_WITHOUT_ELSE
+preclow
+
+rule
+  SourceElements:
+    /* nothing */ 			{ result = SourceElementsNode.new([]) }
+  | SourceElementList			{ result = SourceElementsNode.new([val].flatten) }
+
+  SourceElementList:
+    SourceElement
+  | SourceElementList SourceElement        { result = val.flatten }
+  ;
+
+  SourceElement:
+    FunctionDeclaration
+  | Statement
+  ;
+
+  Statement:
+    Block
+  | VariableStatement
+  | ConstStatement
+  | EmptyStatement
+  | ExprStatement
+  | IfStatement
+  | IterationStatement
+  | ContinueStatement
+  | BreakStatement
+  | ReturnStatement
+  | WithStatement
+  | SwitchStatement
+  | LabelledStatement
+  | ThrowStatement
+  | TryStatement
+  | DebuggerStatement
+  ;
+
+  Literal:
+    NULL    { result = NullNode.new(val.first) }
+  | TRUE    { result = TrueNode.new(val.first) }
+  | FALSE   { result = FalseNode.new(val.first) }
+  | NUMBER  { result = NumberNode.new(val.first) }
+  | STRING  { result = StringNode.new(val.first) }
+  | REGEXP  { result = RegexpNode.new(val.first) }
+  ;
+
+  Property:
+    IdentName ':' AssignmentExpr {
+      result = PropertyNode.new(val[0], val[2])
+    }
+  | STRING ':' AssignmentExpr { result = PropertyNode.new(val.first, val.last) }
+  | NUMBER ':' AssignmentExpr { result = PropertyNode.new(val.first, val.last) }
+  | IDENT IdentName '(' ')' FunctionBody  {
+      klass = property_class_for(val.first)
+      yyabort unless klass
+      result = klass.new(val[1], FunctionExprNode.new(nil, val[4]))
+    }
+  | IDENT IdentName '(' FormalParameterList ')' FunctionBody {
+      klass = property_class_for(val.first)
+      yyabort unless klass
+      result = klass.new(val[1], FunctionExprNode.new(nil, val[5], val[3]))
+    }
+  ;
+
+  IdentName:
+    IDENT
+  | NULL | TRUE | FALSE
+  | BREAK | CASE | CATCH | CONST | CONTINUE | DEBUGGER | DEFAULT | DELETE | DO | ELSE
+  | FINALLY | FOR | FUNCTION | IF | IN | INSTANCEOF | NEW | RETURN | SWITCH | THIS | THROW | TRY
+  | TYPEOF | VAR | VOID | WHILE | WITH
+  | RESERVED
+  ;
+
+  PropertyList:
+    Property                    { result = val }
+  | PropertyList ',' Property   { result = [val.first, val.last].flatten }
+  ;
+
+  PrimaryExpr:
+    PrimaryExprNoBrace
+  | '{' '}'                   { result = ObjectLiteralNode.new([]) }
+  | '{' PropertyList '}'      { result = ObjectLiteralNode.new(val[1]) }
+  | '{' PropertyList ',' '}'  { result = ObjectLiteralNode.new(val[1]) }
+  ;
+
+  PrimaryExprNoBrace:
+    THIS          { result = ThisNode.new(val.first) }
+  | Literal
+  | ArrayLiteral
+  | IDENT         { result = ResolveNode.new(val.first) }
+  | '(' Expr ')'  { result = ParentheticalNode.new(val[1]) }
+  ;
+
+  ArrayLiteral:
+    '[' ElisionOpt ']'           { result = ArrayNode.new([] + [nil] * val[1]) }
+  | '[' ElementList ']'                 { result = ArrayNode.new(val[1]) }
+  | '[' ElementList ',' ElisionOpt ']'  {
+      result = ArrayNode.new(val[1] + [nil] * val[3])
+    }
+  ;
+
+  ElementList:
+    ElisionOpt AssignmentExpr {
+      result = [nil] * val[0] + [ElementNode.new(val[1])]
+    }
+  | ElementList ',' ElisionOpt AssignmentExpr {
+      result = [val[0], [nil] * val[2], ElementNode.new(val[3])].flatten
+    }
+  ;
+
+  ElisionOpt:
+    /* nothing */ { result = 0 }
+  | Elision
+  ;
+
+  Elision:
+    ',' { result = 1 }
+  | Elision ',' { result = val.first + 1 }
+  ;
+
+  MemberExpr:
+    PrimaryExpr
+  | FunctionExpr
+  | MemberExpr '[' Expr ']' { result = BracketAccessorNode.new(val[0], val[2]) }
+  | MemberExpr '.' IdentName { result = DotAccessorNode.new(val[0], val[2]) }
+  | NEW MemberExpr Arguments { result = NewExprNode.new(val[1], val[2]) }
+  ;
+
+  MemberExprNoBF:
+    PrimaryExprNoBrace
+  | MemberExprNoBF '[' Expr ']' {
+      result = BracketAccessorNode.new(val[0], val[2])
+    }
+  | MemberExprNoBF '.' IdentName { result = DotAccessorNode.new(val[0], val[2]) }
+  | NEW MemberExpr Arguments    { result = NewExprNode.new(val[1], val[2]) }
+  ;
+
+  NewExpr:
+    MemberExpr
+  | NEW NewExpr { result = NewExprNode.new(val[1], ArgumentsNode.new([])) }
+  ;
+
+  NewExprNoBF:
+    MemberExprNoBF
+  | NEW NewExpr { result = NewExprNode.new(val[1], ArgumentsNode.new([])) }
+  ;
+
+  CallExpr:
+    MemberExpr Arguments  { result = FunctionCallNode.new(val[0], val[1]) }
+  | CallExpr Arguments    { result = FunctionCallNode.new(val[0], val[1]) }
+  | CallExpr '[' Expr ']' { result = BracketAccessorNode.new(val[0], val[2]) }
+  | CallExpr '.' IdentName { result = DotAccessorNode.new(val[0], val[2]) }
+  ;
+
+  CallExprNoBF:
+    VOID '(' MemberExpr ')' { result = FunctionCallNode.new(ResolveNode.new(val[0]), val[2]) }
+  | MemberExprNoBF Arguments  { result = FunctionCallNode.new(val[0], val[1]) }
+  | CallExprNoBF Arguments    { result = FunctionCallNode.new(val[0], val[1]) }
+  | CallExprNoBF '[' Expr ']' { result = BracketAccessorNode.new(val[0], val[2]) }
+  | CallExprNoBF '.' IdentName { result = DotAccessorNode.new(val[0], val[2]) }
+  ;
+
+  Arguments:
+    '(' ')'               { result = ArgumentsNode.new([]) }
+  | '(' ArgumentList ')'  { result = ArgumentsNode.new(val[1]); }
+  ;
+
+  ArgumentList:
+    AssignmentExpr                      { result = val }
+  | ArgumentList ',' AssignmentExpr     { result = [val[0], val[2]].flatten }
+  ;
+
+  LeftHandSideExpr:
+    NewExpr
+  | CallExpr
+  ;
+
+  LeftHandSideExprNoBF:
+    NewExprNoBF
+  | CallExprNoBF
+  ;
+
+  PostfixExpr:
+    LeftHandSideExpr
+  | LeftHandSideExpr PLUSPLUS   { result = PostfixNode.new(val[0], '++') }
+  | LeftHandSideExpr MINUSMINUS { result = PostfixNode.new(val[0], '--') }
+  ;
+
+  PostfixExprNoBF:
+    LeftHandSideExprNoBF
+  | LeftHandSideExprNoBF PLUSPLUS   { result = PostfixNode.new(val[0], '++') }
+  | LeftHandSideExprNoBF MINUSMINUS { result = PostfixNode.new(val[0], '--') }
+  ;
+
+  UnaryExprCommon:
+    DELETE UnaryExpr     { result = DeleteNode.new(val[1]) }
+  | VOID UnaryExpr       { result = VoidNode.new(val[1]) }
+  | TYPEOF UnaryExpr          { result = TypeOfNode.new(val[1]) }
+  | PLUSPLUS UnaryExpr        { result = PrefixNode.new(val[1], '++') }
+  /* FIXME: Not sure when this can ever happen
+  | AUTOPLUSPLUS UnaryExpr    { result = makePrefixNode($2, OpPlusPlus); } */
+  | MINUSMINUS UnaryExpr      { result = PrefixNode.new(val[1], '--') }
+  /* FIXME: Not sure when this can ever happen
+  | AUTOMINUSMINUS UnaryExpr  { result = makePrefixNode($2, OpMinusMinus); } */
+  | '+' UnaryExpr             { result = UnaryPlusNode.new(val[1]) }
+  | '-' UnaryExpr             { result = UnaryMinusNode.new(val[1]) }
+  | '~' UnaryExpr             { result = BitwiseNotNode.new(val[1]) }
+  | '!' UnaryExpr             { result = LogicalNotNode.new(val[1]) }
+  ;
+
+  UnaryExpr:
+    PostfixExpr
+  | UnaryExprCommon
+  ;
+
+  UnaryExprNoBF:
+    PostfixExprNoBF
+  | UnaryExprCommon
+  ;
+
+  MultiplicativeExpr:
+    UnaryExpr
+  | MultiplicativeExpr '*' UnaryExpr { result = MultiplyNode.new(val[0],val[2])}
+  | MultiplicativeExpr '/' UnaryExpr { result = DivideNode.new(val[0], val[2]) }
+  | MultiplicativeExpr '%' UnaryExpr { result = ModulusNode.new(val[0], val[2])}
+  ;
+
+  MultiplicativeExprNoBF:
+    UnaryExprNoBF
+  | MultiplicativeExprNoBF '*' UnaryExpr { result = MultiplyNode.new(val[0], val[2]) }
+  | MultiplicativeExprNoBF '/' UnaryExpr { result = DivideNode.new(val[0],val[2]) }
+  | MultiplicativeExprNoBF '%' UnaryExpr { result = ModulusNode.new(val[0], val[2]) }
+  ;
+
+  AdditiveExpr:
+    MultiplicativeExpr
+  | AdditiveExpr '+' MultiplicativeExpr { result = AddNode.new(val[0], val[2]) }
+  | AdditiveExpr '-' MultiplicativeExpr { result = SubtractNode.new(val[0], val[2]) }
+  ;
+
+  AdditiveExprNoBF:
+    MultiplicativeExprNoBF
+  | AdditiveExprNoBF '+' MultiplicativeExpr { result = AddNode.new(val[0], val[2]) }
+  | AdditiveExprNoBF '-' MultiplicativeExpr { result = SubtractNode.new(val[0], val[2]) }
+  ;
+
+  ShiftExpr:
+    AdditiveExpr
+  | ShiftExpr LSHIFT AdditiveExpr   { result = LeftShiftNode.new(val[0], val[2]) }
+  | ShiftExpr RSHIFT AdditiveExpr   { result = RightShiftNode.new(val[0], val[2]) }
+  | ShiftExpr URSHIFT AdditiveExpr  { result = UnsignedRightShiftNode.new(val[0], val[2]) }
+  ;
+
+  ShiftExprNoBF:
+    AdditiveExprNoBF
+  | ShiftExprNoBF LSHIFT AdditiveExpr   { result = LeftShiftNode.new(val[0], val[2]) }
+  | ShiftExprNoBF RSHIFT AdditiveExpr   { result = RightShiftNode.new(val[0], val[2]) }
+  | ShiftExprNoBF URSHIFT AdditiveExpr  { result = UnsignedRightShiftNode.new(val[0], val[2]) }
+  ;
+
+  RelationalExpr:
+    ShiftExpr
+  | RelationalExpr '<' ShiftExpr        { result = LessNode.new(val[0], val[2])}
+  | RelationalExpr '>' ShiftExpr        { result = GreaterNode.new(val[0], val[2]) }
+  | RelationalExpr LE ShiftExpr         { result = LessOrEqualNode.new(val[0], val[2]) }
+  | RelationalExpr GE ShiftExpr         { result = GreaterOrEqualNode.new(val[0], val[2]) }
+  | RelationalExpr INSTANCEOF ShiftExpr { result = InstanceOfNode.new(val[0], val[2]) }
+  | RelationalExpr IN ShiftExpr    { result = InNode.new(val[0], val[2]) }
+  ;
+
+  RelationalExprNoIn:
+    ShiftExpr
+  | RelationalExprNoIn '<' ShiftExpr    { result = LessNode.new(val[0], val[2])}
+  | RelationalExprNoIn '>' ShiftExpr    { result = GreaterNode.new(val[0], val[2]) }
+  | RelationalExprNoIn LE ShiftExpr     { result = LessOrEqualNode.new(val[0], val[2]) }
+  | RelationalExprNoIn GE ShiftExpr     { result = GreaterOrEqualNode.new(val[0], val[2]) }
+  | RelationalExprNoIn INSTANCEOF ShiftExpr
+                                        { result = InstanceOfNode.new(val[0], val[2]) }
+  ;
+
+  RelationalExprNoBF:
+    ShiftExprNoBF
+  | RelationalExprNoBF '<' ShiftExpr    { result = LessNode.new(val[0], val[2]) }
+  | RelationalExprNoBF '>' ShiftExpr    { result = GreaterNode.new(val[0], val[2]) }
+  | RelationalExprNoBF LE ShiftExpr     { result = LessOrEqualNode.new(val[0], val[2]) }
+  | RelationalExprNoBF GE ShiftExpr     { result = GreaterOrEqualNode.new(val[0], val[2]) }
+  | RelationalExprNoBF INSTANCEOF ShiftExpr
+                                        { result = InstanceOfNode.new(val[0], val[2]) }
+  | RelationalExprNoBF IN ShiftExpr     { result = InNode.new(val[0], val[2]) }
+  ;
+
+  EqualityExpr:
+    RelationalExpr
+  | EqualityExpr EQEQ RelationalExpr    { result = EqualNode.new(val[0], val[2]) }
+  | EqualityExpr NE RelationalExpr      { result = NotEqualNode.new(val[0], val[2]) }
+  | EqualityExpr STREQ RelationalExpr   { result = StrictEqualNode.new(val[0], val[2]) }
+  | EqualityExpr STRNEQ RelationalExpr  { result = NotStrictEqualNode.new(val[0], val[2]) }
+  ;
+
+  EqualityExprNoIn:
+    RelationalExprNoIn
+  | EqualityExprNoIn EQEQ RelationalExprNoIn
+                                        { result = EqualNode.new(val[0], val[2]) }
+  | EqualityExprNoIn NE RelationalExprNoIn
+                                        { result = NotEqualNode.new(val[0], val[2]) }
+  | EqualityExprNoIn STREQ RelationalExprNoIn
+                                        { result = StrictEqualNode.new(val[0], val[2]) }
+  | EqualityExprNoIn STRNEQ RelationalExprNoIn
+                                        { result = NotStrictEqualNode.new(val[0], val[2]) }
+  ;
+
+  EqualityExprNoBF:
+    RelationalExprNoBF
+  | EqualityExprNoBF EQEQ RelationalExpr
+                                        { result = EqualNode.new(val[0], val[2]) }
+  | EqualityExprNoBF NE RelationalExpr  { result = NotEqualNode.new(val[0], val[2]) }
+  | EqualityExprNoBF STREQ RelationalExpr
+                                        { result = StrictEqualNode.new(val[0], val[2]) }
+  | EqualityExprNoBF STRNEQ RelationalExpr
+                                        { result = NotStrictEqualNode.new(val[0], val[2]) }
+  ;
+
+  BitwiseANDExpr:
+    EqualityExpr
+  | BitwiseANDExpr '&' EqualityExpr     { result = BitAndNode.new(val[0], val[2]) }
+  ;
+
+  BitwiseANDExprNoIn:
+    EqualityExprNoIn
+  | BitwiseANDExprNoIn '&' EqualityExprNoIn
+                                        { result = BitAndNode.new(val[0], val[2]) }
+  ;
+
+  BitwiseANDExprNoBF:
+    EqualityExprNoBF
+  | BitwiseANDExprNoBF '&' EqualityExpr { result = BitAndNode.new(val[0], val[2]) }
+  ;
+
+  BitwiseXORExpr:
+    BitwiseANDExpr
+  | BitwiseXORExpr '^' BitwiseANDExpr   { result = BitXOrNode.new(val[0], val[2]) }
+  ;
+
+  BitwiseXORExprNoIn:
+    BitwiseANDExprNoIn
+  | BitwiseXORExprNoIn '^' BitwiseANDExprNoIn
+                                        { result = BitXOrNode.new(val[0], val[2]) }
+  ;
+
+  BitwiseXORExprNoBF:
+    BitwiseANDExprNoBF
+  | BitwiseXORExprNoBF '^' BitwiseANDExpr
+                                        { result = BitXOrNode.new(val[0], val[2]) }
+  ;
+
+  BitwiseORExpr:
+    BitwiseXORExpr
+  | BitwiseORExpr '|' BitwiseXORExpr    { result = BitOrNode.new(val[0], val[2]) }
+  ;
+
+  BitwiseORExprNoIn:
+    BitwiseXORExprNoIn
+  | BitwiseORExprNoIn '|' BitwiseXORExprNoIn
+                                        { result = BitOrNode.new(val[0], val[2]) }
+  ;
+
+  BitwiseORExprNoBF:
+    BitwiseXORExprNoBF
+  | BitwiseORExprNoBF '|' BitwiseXORExpr
+                                        { result = BitOrNode.new(val[0], val[2]) }
+  ;
+
+  LogicalANDExpr:
+    BitwiseORExpr
+  | LogicalANDExpr AND BitwiseORExpr    { result = LogicalAndNode.new(val[0], val[2]) }
+  ;
+
+  LogicalANDExprNoIn:
+    BitwiseORExprNoIn
+  | LogicalANDExprNoIn AND BitwiseORExprNoIn
+                                        { result = LogicalAndNode.new(val[0], val[2]) }
+  ;
+
+  LogicalANDExprNoBF:
+    BitwiseORExprNoBF
+  | LogicalANDExprNoBF AND BitwiseORExpr
+                                        { result = LogicalAndNode.new(val[0], val[2]) }
+  ;
+
+  LogicalORExpr:
+    LogicalANDExpr
+  | LogicalORExpr OR LogicalANDExpr     { result = LogicalOrNode.new(val[0], val[2]) }
+  ;
+
+  LogicalORExprNoIn:
+    LogicalANDExprNoIn
+  | LogicalORExprNoIn OR LogicalANDExprNoIn
+                                        { result = LogicalOrNode.new(val[0], val[2]) }
+  ;
+
+  LogicalORExprNoBF:
+    LogicalANDExprNoBF
+  | LogicalORExprNoBF OR LogicalANDExpr { result = LogicalOrNode.new(val[0], val[2]) }
+  ;
+
+  ConditionalExpr:
+    LogicalORExpr
+  | LogicalORExpr '?' AssignmentExpr ':' AssignmentExpr {
+      result = ConditionalNode.new(val[0], val[2], val[4])
+    }
+  ;
+
+  ConditionalExprNoIn:
+    LogicalORExprNoIn
+  | LogicalORExprNoIn '?' AssignmentExprNoIn ':' AssignmentExprNoIn {
+      result = ConditionalNode.new(val[0], val[2], val[4])
+    }
+  ;
+
+  ConditionalExprNoBF:
+    LogicalORExprNoBF
+  | LogicalORExprNoBF '?' AssignmentExpr ':' AssignmentExpr {
+      result = ConditionalNode.new(val[0], val[2], val[4])
+    }
+  ;
+
+  AssignmentExpr:
+    ConditionalExpr
+  | LeftHandSideExpr AssignmentOperator AssignmentExpr {
+      result = val[1].new(val.first, val.last)
+    }
+  ;
+
+  AssignmentExprNoIn:
+    ConditionalExprNoIn
+  | LeftHandSideExpr AssignmentOperator AssignmentExprNoIn {
+      result = val[1].new(val.first, val.last)
+    }
+  ;
+
+  AssignmentExprNoBF:
+    ConditionalExprNoBF
+  | LeftHandSideExprNoBF AssignmentOperator AssignmentExpr {
+      result = val[1].new(val.first, val.last)
+    }
+  ;
+
+  AssignmentOperator:
+    '='                                 { result = OpEqualNode }
+  | PLUSEQUAL                           { result = OpPlusEqualNode }
+  | MINUSEQUAL                          { result = OpMinusEqualNode }
+  | MULTEQUAL                           { result = OpMultiplyEqualNode }
+  | DIVEQUAL                            { result = OpDivideEqualNode }
+  | LSHIFTEQUAL                         { result = OpLShiftEqualNode }
+  | RSHIFTEQUAL                         { result = OpRShiftEqualNode }
+  | URSHIFTEQUAL                        { result = OpURShiftEqualNode }
+  | ANDEQUAL                            { result = OpAndEqualNode }
+  | XOREQUAL                            { result = OpXOrEqualNode }
+  | OREQUAL                             { result = OpOrEqualNode }
+  | MODEQUAL                            { result = OpModEqualNode }
+  ;
+
+  Expr:
+    AssignmentExpr
+  | Expr ',' AssignmentExpr             { result = CommaNode.new(val[0], val[2]) }
+  ;
+
+  ExprNoIn:
+    AssignmentExprNoIn
+  | ExprNoIn ',' AssignmentExprNoIn     { result = CommaNode.new(val[0], val[2]) }
+  ;
+
+  ExprNoBF:
+    AssignmentExprNoBF
+  | ExprNoBF ',' AssignmentExpr       { result = CommaNode.new(val[0], val[2]) }
+  ;
+
+
+  Block:
+    '{' SourceElements '}' {
+      result = BlockNode.new(val[1])
+      debug(result)
+    }
+  ;
+
+  VariableStatement:
+    VAR VariableDeclarationList ';' {
+      result = VarStatementNode.new(val[1])
+      debug(result)
+    }
+  | VAR VariableDeclarationList error {
+      result = VarStatementNode.new(val[1])
+      debug(result)
+      yyabort unless allow_auto_semi?(val.last)
+    }
+  ;
+
+  VariableDeclarationList:
+    VariableDeclaration                 { result = val }
+  | VariableDeclarationList ',' VariableDeclaration {
+      result = [val.first, val.last].flatten
+    }
+  ;
+
+  VariableDeclarationListNoIn:
+    VariableDeclarationNoIn             { result = val }
+  | VariableDeclarationListNoIn ',' VariableDeclarationNoIn {
+      result = [val.first, val.last].flatten
+    }
+  ;
+
+  VariableDeclaration:
+    IDENT             { result = VarDeclNode.new(val.first, nil) }
+  | IDENT Initializer { result = VarDeclNode.new(val.first, val[1]) }
+  ;
+
+  VariableDeclarationNoIn:
+    IDENT                               { result = VarDeclNode.new(val[0],nil) }
+  | IDENT InitializerNoIn               { result = VarDeclNode.new(val[0], val[1]) }
+  ;
+
+  ConstStatement:
+    CONST ConstDeclarationList ';' {
+      result = ConstStatementNode.new(val[1])
+      debug(result)
+    }
+  | CONST ConstDeclarationList error {
+      result = ConstStatementNode.new(val[1])
+      debug(result)
+      yyerror unless allow_auto_semi?(val.last)
+    }
+  ;
+
+  ConstDeclarationList:
+    ConstDeclaration                    { result = val }
+  | ConstDeclarationList ',' ConstDeclaration {
+      result = [val.first, val.last].flatten
+    }
+  ;
+
+  ConstDeclaration:
+    IDENT             { result = VarDeclNode.new(val[0], nil, true) }
+  | IDENT Initializer { result = VarDeclNode.new(val[0], val[1], true) }
+  ;
+
+  Initializer:
+    '=' AssignmentExpr                  { result = AssignExprNode.new(val[1]) }
+  ;
+
+  InitializerNoIn:
+    '=' AssignmentExprNoIn              { result = AssignExprNode.new(val[1]) }
+  ;
+
+  EmptyStatement:
+    ';' { result = EmptyStatementNode.new(val[0]) }
+  ;
+
+  ExprStatement:
+    ExprNoBF ';' {
+      result = ExpressionStatementNode.new(val.first)
+      debug(result)
+    }
+  | ExprNoBF error {
+      result = ExpressionStatementNode.new(val.first)
+      debug(result)
+      raise RKelly::SyntaxError unless allow_auto_semi?(val.last)
+    }
+  ;
+
+  IfStatement:
+    IF '(' Expr ')' Statement =IF_WITHOUT_ELSE {
+      result = IfNode.new(val[2], val[4])
+      debug(result)
+    }
+  | IF '(' Expr ')' Statement ELSE Statement {
+      result = IfNode.new(val[2], val[4], val[6])
+      debug(result)
+    }
+  ;
+
+  IterationStatement:
+    DO Statement WHILE '(' Expr ')' ';' {
+      result = DoWhileNode.new(val[1], val[4])
+      debug(result)
+    }
+  | DO Statement WHILE '(' Expr ')' error {
+      result = DoWhileNode.new(val[1], val[4])
+      debug(result)
+    } /* Always performs automatic semicolon insertion. */
+  | WHILE '(' Expr ')' Statement {
+      result = WhileNode.new(val[2], val[4])
+      debug(result)
+    }
+  | FOR '(' ExprNoInOpt ';' ExprOpt ';' ExprOpt ')' Statement {
+      result = ForNode.new(val[2], val[4], val[6], val[8])
+      debug(result)
+    }
+  | FOR '(' VAR VariableDeclarationListNoIn ';' ExprOpt ';' ExprOpt ')' Statement
+    {
+      result = ForNode.new(VarStatementNode.new(val[3]), val[5], val[7], val[9])
+      debug(result)
+    }
+  | FOR '(' LeftHandSideExpr IN Expr ')' Statement {
+      #yyabort if (!n.isLocation())
+      result = ForInNode.new(val[2], val[4], val[6])
+      debug(result);
+    }
+  | FOR '(' VAR IDENT IN Expr ')' Statement {
+      result = ForInNode.new(
+        VarDeclNode.new(val[3], nil), val[5], val[7])
+      debug(result)
+    }
+  | FOR '(' VAR IDENT InitializerNoIn IN Expr ')' Statement {
+      result = ForInNode.new(
+        VarDeclNode.new(val[3], val[4]), val[6], val[8]
+      )
+      debug(result)
+    }
+  ;
+
+  ExprOpt:
+    /* nothing */                       { result = nil }
+  | Expr
+  ;
+
+  ExprNoInOpt:
+    /* nothing */                       { result = nil }
+  | ExprNoIn
+  ;
+
+  ContinueStatement:
+    CONTINUE ';' {
+      result = ContinueNode.new(nil)
+      debug(result)
+    }
+  | CONTINUE error {
+      result = ContinueNode.new(nil)
+      debug(result)
+      yyabort unless allow_auto_semi?(val[1])
+    }
+  | CONTINUE IDENT ';' {
+      result = ContinueNode.new(val[1])
+      debug(result)
+    }
+  | CONTINUE IDENT error {
+      result = ContinueNode.new(val[1])
+      debug(result)
+      yyabort unless allow_auto_semi?(val[2])
+    }
+  ;
+
+  BreakStatement:
+    BREAK ';' {
+      result = BreakNode.new(nil)
+      debug(result)
+    }
+  | BREAK error {
+      result = BreakNode.new(nil)
+      debug(result)
+      yyabort unless allow_auto_semi?(val[1])
+    }
+  | BREAK IDENT ';' {
+      result = BreakNode.new(val[1])
+      debug(result)
+    }
+  | BREAK IDENT error {
+      result = BreakNode.new(val[1])
+      debug(result)
+      yyabort unless allow_auto_semi?(val[2])
+    }
+  ;
+
+  ReturnStatement:
+    RETURN ';' {
+      result = ReturnNode.new(nil)
+      debug(result)
+    }
+  | RETURN error {
+      result = ReturnNode.new(nil)
+      debug(result)
+      yyabort unless allow_auto_semi?(val[1])
+    }
+  | RETURN Expr ';' {
+      result = ReturnNode.new(val[1])
+      debug(result)
+    }
+  | RETURN Expr error {
+      result = ReturnNode.new(val[1])
+      debug(result)
+      yyabort unless allow_auto_semi?(val[2])
+    }
+  ;
+
+  WithStatement:
+    WITH '(' Expr ')' Statement {
+      result = WithNode.new(val[2], val[4])
+      debug(result)
+    }
+  ;
+
+  SwitchStatement:
+    SWITCH '(' Expr ')' CaseBlock {
+      result = SwitchNode.new(val[2], val[4])
+      debug(result)
+    }
+  ;
+
+  CaseBlock:
+    '{' CaseClausesOpt '}'              { result = CaseBlockNode.new(val[1]) }
+  | '{' CaseClausesOpt DefaultClause CaseClausesOpt '}' {
+      result = CaseBlockNode.new([val[1], val[2], val[3]].flatten)
+    }
+  ;
+
+  CaseClausesOpt:
+    /* nothing */                       { result = [] }
+  | CaseClauses
+  ;
+
+  CaseClauses:
+    CaseClause                          { result = val }
+  | CaseClauses CaseClause              { result = val.flatten }
+  ;
+
+  CaseClause:
+    CASE Expr ':' SourceElements        {
+      result = CaseClauseNode.new(val[1], val[3])
+    }
+  ;
+
+  DefaultClause:
+    DEFAULT ':' SourceElements          {
+      result = CaseClauseNode.new(nil, val[2])
+    }
+  ;
+
+  LabelledStatement:
+    IDENT ':' Statement { result = LabelNode.new(val[0], val[2]) }
+  ;
+
+  ThrowStatement:
+    THROW Expr ';' {
+      result = ThrowNode.new(val[1])
+      debug(result)
+    }
+  | THROW Expr error {
+      result = ThrowNode.new(val[1])
+      debug(result)
+      yyabort unless allow_auto_semi?(val[2])
+    }
+  ;
+
+  TryStatement:
+    TRY Block FINALLY Block {
+      result = TryNode.new(val[1], nil, nil, val[3])
+      debug(result)
+    }
+  | TRY Block CATCH '(' IDENT ')' Block {
+      result = TryNode.new(val[1], val[4], val[6])
+      debug(result)
+    }
+  | TRY Block CATCH '(' IDENT ')' Block FINALLY Block {
+      result = TryNode.new(val[1], val[4], val[6], val[8])
+      debug(result)
+    }
+  ;
+
+  DebuggerStatement:
+    DEBUGGER ';' {
+      result = EmptyStatementNode.new(val[0])
+      debug(result)
+    }
+  | DEBUGGER error {
+      result = EmptyStatementNode.new(val[0])
+      debug(result)
+      yyabort unless allow_auto_semi?(val[1])
+    }
+  ;
+
+  FunctionDeclaration:
+    FUNCTION IDENT '(' ')' FunctionBody {
+      result = FunctionDeclNode.new(val[1], val[4])
+      debug(val[5])
+    }
+  | FUNCTION IDENT '(' FormalParameterList ')' FunctionBody {
+      result = FunctionDeclNode.new(val[1], val[5], val[3])
+      debug(val[6])
+    }
+  ;
+
+  FunctionExpr:
+    FUNCTION '(' ')' FunctionBody {
+      result = FunctionExprNode.new(val[0], val[3])
+      debug(val[4])
+    }
+  | FUNCTION '(' FormalParameterList ')' FunctionBody {
+      result = FunctionExprNode.new(val[0], val[4], val[2])
+      debug(val[5])
+    }
+  | FUNCTION IDENT '(' ')' FunctionBody {
+      result = FunctionExprNode.new(val[1], val[4])
+      debug(val[5])
+    }
+  | FUNCTION IDENT '(' FormalParameterList ')' FunctionBody {
+      result = FunctionExprNode.new(val[1], val[5], val[3])
+      debug(val[6])
+    }
+  ;
+
+  FormalParameterList:
+    IDENT                               { result = [ParameterNode.new(val[0])] }
+  | FormalParameterList ',' IDENT       {
+      result = [val.first, ParameterNode.new(val.last)].flatten
+    }
+  ;
+
+  FunctionBody:
+    '{' SourceElements '}'              { result = FunctionBodyNode.new(val[1]) }
+  ;
+end
+
+---- header
+  require "rkelly/nodes"
+
+---- inner
+  include RKelly::Nodes
+
+  def allow_auto_semi?(error_token)
+    error_token == false || error_token == '}' || @terminator
+  end
+
+  def property_class_for(ident)
+    case ident
+    when 'get'
+      GetterPropertyNode
+    when 'set'
+      SetterPropertyNode
+    end
+  end
+
+  def debug(*args)
+    logger.debug(*args) if logger
+  end