twostroke 0.1.0 → 0.2.0

data/lib/twostroke/parser.rb

@@ -1,5 +1,5 @@
 module Twostroke
-  class ParseError < Error
+  class ParseError < SyntaxError
   end
   
   class Parser
@@ -12,9 +12,9 @@ module Twostroke
     end
     
     def parse
-      while try_peek_token
+      while try_peek_token(true)
         st = statement
-        statements.push st.collapse if st
+        statements.push st.collapse if st # don't collapse
       end
     end
   
@@ -38,15 +38,15 @@ module Twostroke
     def token
       @cur_token or raise ParseError, "unexpected end of input"
     end
-    def next_token(allow_regexp = true)
+    def next_token(allow_regexp = false)
       @cur_token = @peek_token || @lexer.read_token(allow_regexp)
       @peek_token = nil
       token
     end
-    def try_peek_token(allow_regexp = true)
+    def try_peek_token(allow_regexp = false)
       @peek_token ||= @lexer.read_token(allow_regexp)
     end
-    def peek_token(allow_regexp = true)
+    def peek_token(allow_regexp = false)
       @peek_token ||= @lexer.read_token(allow_regexp) or raise ParseError, "unexpected end of input"
     end
     
@@ -69,119 +69,290 @@ module Twostroke
       when :OPEN_BRACE; consume_semicolon = false; body
       when :FUNCTION;   consume_semicolon = false; function
       when :SEMICOLON;  nil
+      when :LINE_TERMINATOR;  nil
+      when :BAREWORD;   label
       else; expression
       end
       if consume_semicolon
-        next_token if try_peek_token && peek_token.type == :SEMICOLON
-        #assert_type next_token, :SEMICOLON
+        if try_peek_token and peek_token.type == :SEMICOLON
+          next_token
+        end
       end
       st
     end
-   
-    def expression(no_comma = false, no_in = false, no_ternary = false)
-      expr = expression_after_unary no_comma
-      expr = if [:PLUS, :MINUS, :ASTERISK, :SLASH, :MOD,
-          :LEFT_SHIFT, :RIGHT_SHIFT, :RIGHT_TRIPLE_SHIFT,
-          :AMPERSAND, :CARET, :PIPE ].include? peek_token(false).type
-          state = save_state
-          next_token
-          combined = (peek_token(false).type == :EQUALS)
-          load_state state
-          if combined
-            # combination assignment
-            op = next_token(false).type
-            assert_type next_token(false), :EQUALS
-            AST::UnsortedBinop.operator_class[op].new left: expr, assign_result_left: true, right: expression(true, false, true)
-          else
-            binop expr
-          end
-      elsif [ :GT, :LT, :GTE, :LTE, :DOUBLE_EQUALS,
-              :TRIPLE_EQUALS, :NOT_EQUALS, :NOT_DOUBLE_EQUALS,
-              :AND, :OR, :LEFT_SHIFT, :RIGHT_SHIFT,
-              :RIGHT_TRIPLE_SHIFT, :INSTANCEOF,
-              *(no_in ? [] : [:IN]) ].include? peek_token(false).type
-        expr = binop expr
-        # this has a higher precedence than the ternary
-        # so we'll hackily check for a ternary after this
-        if !no_ternary && try_peek_token && peek_token(false).type == :QUESTION
-          ternary(expr)
-        else
-          expr
-        end
+
+    def label
+      state = save_state
+      assert_type next_token, :BAREWORD
+      name = token.val
+      if try_peek_token and peek_token.type == :COLON
+        next_token
+        return AST::Label.new name: name, line: token.line, statement: statement(false)
       else
-        expr
+        load_state state
+        expression
+      end
+    end
+    
+    def expression
+      multi_expression
+    end
+    
+    def multi_expression
+      expr = assignment_expression
+      while try_peek_token and peek_token.type == :COMMA
+        next_token
+        expr = AST::MultiExpression.new left: expr, line: token.line, right: assignment_expression
+      end
+      expr
+    end
+    
+    def assignment_expression
+      nodes = {
+        :ADD_EQUALS         => AST::Addition,
+        :MINUS_EQUALS       => AST::Subtraction,
+        :TIMES_EQUALS       => AST::Multiplication,
+        :DIVIDE_EQUALS      => AST::Division,
+        :MOD_EQUALS         => AST::Modulus,
+        :LEFT_SHIFT         => AST::LeftShift,
+        :RIGHT_SHIFT_EQUALS => AST::RightArithmeticShift,
+        :RIGHT_TRIPLE_SHIFT_EQUALS => AST::RightLogicalShift,
+        :BITWISE_AND_EQUALS => AST::BitwiseAnd,
+        :BITWISE_XOR_EQUALS => AST::BitwiseXor,
+        :BITWISE_OR_EQUALS  => AST::BitwiseOr
+      }
+      expr = conditional_expression
+      if try_peek_token and peek_token.type == :EQUALS
+        next_token
+        expr = AST::Assignment.new left: expr, line: token.line, right: assignment_expression
+      elsif try_peek_token and nodes.keys.include? peek_token.type
+        expr = nodes[next_token.type].new left: expr, line: token.line, assign_result_left: true, right: assignment_expression
+      end
+      expr
+    end
+    
+    def conditional_expression
+      cond = logical_or_expression
+      if try_peek_token and peek_token.type == :QUESTION
+        next_token
+        cond = AST::Ternary.new line: token.line, condition: cond
+        cond.if_true = assignment_expression
+        assert_type next_token, :COLON
+        cond.if_false = assignment_expression
+      end
+      cond
+    end
+    
+    def logical_or_expression
+      expr = logical_and_expression
+      while try_peek_token and peek_token.type == :OR
+        next_token
+        expr = AST::Or.new left: expr, line: token.line, right: logical_and_expression
+      end
+      expr
+    end
+    
+    def logical_and_expression
+      expr = bitwise_or_expression
+      while try_peek_token and peek_token.type == :AND
+        next_token
+        expr = AST::And.new left: expr, line: token.line, right: bitwise_or_expression
+      end
+      expr
+    end
+    
+    def bitwise_or_expression
+      expr = bitwise_xor_expression
+      while try_peek_token and peek_token.type == :PIPE
+        next_token
+        expr = AST::BitwiseOr.new left: expr, line: token.line, right: bitwise_xor_expression
       end
-      expr = if peek_token(false).type == :EQUALS
+      expr
+    end
+    
+    def bitwise_xor_expression
+      expr = bitwise_and_expression
+      while try_peek_token and peek_token.type == :CARET
+        next_token
+        expr = AST::BitwiseXor.new left: expr, line: token.line, right: bitwise_and_expression
+      end
+      expr
+    end
+    
+    def bitwise_and_expression
+      expr = equality_expression
+      while try_peek_token and peek_token.type == :AMPERSAND
         next_token
-        AST::Assignment.new left: expr, right: expression(true)
-      elsif !no_ternary && peek_token(false).type == :QUESTION
-        ternary(expr)
+        expr = AST::BitwiseAnd.new left: expr, line: token.line, right: equality_expression
+      end
+      expr
+    end
+    
+    def equality_expression
+      nodes = {
+        :DOUBLE_EQUALS        => AST::Equality,
+        :NOT_EQUALS           => AST::Inequality,
+        :TRIPLE_EQUALS        => AST::StrictEquality,
+        :NOT_DOUBLE_EQUALS    => AST::StrictInequality
+      }
+      expr = relational_in_instanceof_expression
+      while try_peek_token and nodes.keys.include? peek_token.type
+        expr = nodes[next_token.type].new left: expr, line: token.line, right: relational_in_instanceof_expression
+      end
+      expr
+    end
+    
+    def relational_in_instanceof_expression
+      nodes = {
+        :LT           => AST::LessThan,
+        :LTE          => AST::LessThanEqual,
+        :GT           => AST::GreaterThan,
+        :GTE          => AST::GreaterThanEqual,
+        :IN           => AST::In,
+        :INSTANCEOF   => AST::InstanceOf
+      }
+      expr = shift_expression
+      while try_peek_token(true) and nodes.keys.include? peek_token(true).type
+        expr = nodes[next_token(true).type].new left: expr, line: token.line, right: shift_expression
+      end
+      expr
+    end
+    
+    def shift_expression
+      nodes = {
+        :LEFT_SHIFT         => AST::LeftShift,
+        :RIGHT_TRIPLE_SHIFT => AST::RightArithmeticShift,
+        :RIGHT_SHIFT        => AST::RightLogicalShift
+      }
+      expr = additive_expression
+      while try_peek_token and nodes.keys.include? peek_token.type
+        expr = nodes[next_token.type].new left: expr, line: token.line, right: additive_expression
+      end
+      expr
+    end
+
+    def additive_expression
+      nodes = {
+        :PLUS         => AST::Addition,
+        :MINUS        => AST::Subtraction
+      }
+      expr = multiplicative_expression
+      while try_peek_token and nodes.keys.include? peek_token.type
+        expr = nodes[next_token.type].new left: expr, line: token.line, right: multiplicative_expression
+      end
+      expr
+    end
+    
+    def multiplicative_expression
+      nodes = {
+        :ASTERISK     => AST::Multiplication,
+        :SLASH        => AST::Division,
+        :MOD          => AST::Modulus
+      }
+      expr = unary_expression
+      while try_peek_token and nodes.keys.include? peek_token.type
+        expr = nodes[next_token.type].new left: expr, line: token.line, right: unary_expression
+      end
+      expr
+    end
+    
+    def unary_expression
+      case peek_token(true).type
+      when :NOT;    next_token; AST::Not.new line: token.line, value: unary_expression
+      when :TILDE;  next_token; AST::BinaryNot.new line: token.line, value: unary_expression
+      when :PLUS;   next_token; AST::UnaryPlus.new line: token.line, value: unary_expression
+      when :MINUS;  next_token; AST::Negation.new line: token.line, value: unary_expression
+      when :TYPEOF; next_token; AST::TypeOf.new line: token.line, value: unary_expression
+      when :VOID;   next_token; AST::Void.new line: token.line, value: unary_expression
+      when :DELETE; next_token; AST::Delete.new line: token.line, value: unary_expression
       else
-        expr
+        increment_expression
+      end
+    end
+    
+    def increment_expression
+      if peek_token(true).type == :INCREMENT
+        next_token(true)
+        return AST::PreIncrement.new line: token.line, value: increment_expression
+      end
+      if peek_token(true).type == :DECREMENT
+        next_token(true)
+        return AST::PreDecrement.new line: token.line, value: increment_expression
       end
       
-      if !no_comma && peek_token(false).type == :COMMA
+      expr = call_expression
+      
+      if peek_token.type == :INCREMENT
         next_token
-        AST::MultiExpression.new left: expr, right: expression
-      else
-        expr
-      end
-    end
-    
-    def expression_after_unary(no_comma = true, no_call = false)
-      expr = case peek_token.type
-      when :FUNCTION; function
-      when :STRING; string
-      when :NUMBER; number
-      when :REGEXP; regexp
-      when :THIS; this
-      when :NULL; null
-      when :TRUE; send :true
-      when :FALSE; send :false
-      when :NEW; send :new
-      when :DELETE; delete
-      when :BAREWORD; bareword
-      when :OPEN_PAREN; parens
-      when :OPEN_BRACE; object_literal
-      when :OPEN_BRACKET; array
-      when :NOT; send :not
-      when :TILDE; tilde
-      when :INCREMENT; pre_increment
-      when :DECREMENT; pre_decrement
-      when :VOID; void
-      when :PLUS; unary_plus
-      when :MINUS; unary_minus
-      when :TYPEOF; typeof
-      else error! "Unexpected #{peek_token.type}"
+        return AST::PostIncrement.new line: token.line, value: expr
       end
-      loop do
-        if !no_call && peek_token(false).type == :OPEN_PAREN
-          expr = call expr
-        elsif peek_token(false).type == :OPEN_BRACKET
-          expr = index expr
-        elsif peek_token(false).type == :MEMBER_ACCESS
+      if peek_token.type == :DECREMENT
+        next_token
+        return AST::PostDecrement.new line: token.line, value: expr
+      end
+      
+      expr
+    end
+    
+    def call_expression
+      expr = value_expression
+      while try_peek_token and [:MEMBER_ACCESS, :OPEN_BRACKET, :OPEN_PAREN].include? peek_token.type
+        if peek_token.type == :MEMBER_ACCESS
           expr = member_access expr
-        elsif !no_comma && peek_token(false).type == :COMMA
-          expr = comma(expr)
-        elsif peek_token(false).type == :INCREMENT
-          expr = post_increment expr
-        elsif peek_token(false).type == :DECREMENT
-          expr = post_decrement expr
-        else
-          return expr
+        elsif peek_token.type == :OPEN_BRACKET
+          expr = index expr
+        elsif peek_token.type == :OPEN_PAREN
+          expr = call expr
         end
       end
       expr
     end
     
-    def binop(left)
-      op = next_token.type
-      AST::UnsortedBinop.new left: left, op: op, right: expression(true, false, true)
+    def value_expression
+      case peek_token(true).type
+      when :FUNCTION;     function
+      when :STRING;       string
+      when :NUMBER;       number
+      when :REGEXP;       regexp
+      when :THIS;         this
+      when :NULL;         null
+      when :TRUE;         send :true
+      when :FALSE;        send :false
+      when :NEW;          new
+      when :BAREWORD;     bareword
+      when :OPEN_BRACKET; array
+      when :OPEN_BRACE;   object_literal
+      when :OPEN_PAREN;   parens
+      else error! "Unexpected #{peek_token.type}"
+      end
+    end
+
+    def new
+      assert_type next_token, :NEW
+      node = AST::New.new line: token.line
+      node.callee = new_call_expression
+      if try_peek_token && peek_token.type == :OPEN_PAREN
+        call = call node.callee
+        node.arguments = call.arguments
+      end
+      node
+    end
+    
+    def new_call_expression
+      expr = value_expression
+      while try_peek_token and [:MEMBER_ACCESS, :OPEN_BRACKET].include? peek_token.type
+        if peek_token.type == :MEMBER_ACCESS
+          expr = member_access expr
+        elsif peek_token.type == :OPEN_BRACKET
+          expr = index expr
+        end
+      end
+      expr
     end
     
     def body
       assert_type next_token, :OPEN_BRACE
-      body = AST::Body.new
+      body = AST::Body.new line: token.line
       while peek_token.type != :CLOSE_BRACE
         body.statements.push statement
       end
@@ -191,42 +362,33 @@ module Twostroke
     
     def this
       assert_type next_token, :THIS
-      AST::This.new
+      AST::This.new line: token.line
     end
     
     def null
       assert_type next_token, :NULL
-      AST::Null.new
+      AST::Null.new line: token.line
     end
     
     def true
       assert_type next_token, :TRUE
-      AST::True.new
+      AST::True.new line: token.line
     end
     
     def false
       assert_type next_token, :FALSE
-      AST::False.new
+      AST::False.new line: token.line
     end
     
     def bareword
       assert_type next_token, :BAREWORD
-      AST::Variable.new name: token.val
-    end
-    
-    def ternary(cond)
-      assert_type next_token, :QUESTION
-      ternary = AST::Ternary.new condition: cond
-      ternary.if_true = expression(true)
-      assert_type next_token, :COLON
-      ternary.if_false = expression(true)
-      ternary
+      AST::Variable.new line: token.line, name: token.val
     end
     
     def with
       assert_type next_token, :WITH
       assert_type next_token, :OPEN_PAREN
-      with = AST::With.new object: expression
+      with = AST::With.new line: token.line, object: expression
       assert_type next_token, :CLOSE_PAREN
       with.statement = statement
       with
@@ -235,7 +397,7 @@ module Twostroke
     def if
       assert_type next_token, :IF
       assert_type next_token, :OPEN_PAREN
-      node = AST::If.new condition: expression
+      node = AST::If.new line: token.line, condition: expression
       assert_type next_token, :CLOSE_PAREN
       node.then = statement
       if try_peek_token && peek_token.type == :ELSE
@@ -261,18 +423,18 @@ module Twostroke
       end
       load_state saved_state
       if for_in
-        # no luck parsing for(;;), reparse as for(..in..)        
+        # no luck parsing for(;;), reparse as for(..in..)
         if peek_token.type == :VAR
           next_token
           assert_type next_token, :BAREWORD
-          lval = AST::Declaration.new name: token.val
+          lval = AST::Declaration.new line: token.line, name: token.val
         else
-          lval = expression(false, true)
+          lval = shift_expression # shift_expression is the precedence level right below in's
         end
         assert_type next_token, :IN
         obj = expression
         assert_type next_token, :CLOSE_PAREN
-        AST::ForIn.new lval: lval, object: obj, body: statement
+        AST::ForIn.new line: token.line, lval: lval, object: obj, body: statement
       else
         initializer = statement(false) unless peek_token.type == :SEMICOLON
         assert_type next_token, :SEMICOLON
@@ -280,14 +442,14 @@ module Twostroke
         assert_type next_token, :SEMICOLON
         increment = statement(false) unless peek_token.type == :CLOSE_PAREN
         assert_type next_token, :CLOSE_PAREN
-        AST::ForLoop.new initializer: initializer, condition: condition, increment: increment, body: statement
+        AST::ForLoop.new line: token.line, initializer: initializer, condition: condition, increment: increment, body: statement
       end
     end
     
     def switch
       assert_type next_token, :SWITCH
       assert_type next_token, :OPEN_PAREN
-      sw = AST::Switch.new expression: expression
+      sw = AST::Switch.new line: token.line, expression: expression
       assert_type next_token, :CLOSE_PAREN
       assert_type next_token, :OPEN_BRACE
       current_case = nil
@@ -296,7 +458,7 @@ module Twostroke
         if peek_token.type == :CASE
           assert_type next_token, :CASE
           expr = expression
-          node = AST::Case.new expression: expr
+          node = AST::Case.new line: token.line, expression: expr
           assert_type next_token, :COLON
           sw.cases << node
           current_case = node.statements
@@ -304,7 +466,7 @@ module Twostroke
           assert_type next_token, :DEFAULT
           error! "only one default case allowed" if default
           default = true
-          node = AST::Case.new
+          node = AST::Case.new line: token.line
           assert_type next_token, :COLON
           sw.cases << node
           current_case = node.statements
@@ -320,7 +482,7 @@ module Twostroke
     def while
       assert_type next_token, :WHILE
       assert_type next_token, :OPEN_PAREN
-      node = AST::While.new condition: expression
+      node = AST::While.new line: token.line, condition: expression
       assert_type next_token, :CLOSE_PAREN
       node.body = statement
       node
@@ -328,16 +490,16 @@ module Twostroke
     
     def do
       assert_type next_token, :DO
-      node = AST::DoWhile.new body: body
+      node = AST::DoWhile.new line: token.line, body: body
       assert_type next_token, :WHILE
       assert_type next_token, :OPEN_PAREN
-      node.condition = expression(false)
+      node.condition = expression
       assert_type next_token, :CLOSE_PAREN
       node
     end
     
     def try
-      try = AST::Try.new try_statements: []
+      try = AST::Try.new line: token.line, try_statements: []
       assert_type next_token, :TRY
       assert_type next_token, :OPEN_BRACE
       while peek_token.type != :CLOSE_BRACE
@@ -372,34 +534,14 @@ module Twostroke
     def member_access(obj)
       assert_type next_token, :MEMBER_ACCESS
       assert_type next_token, :BAREWORD
-      access = AST::MemberAccess.new object: obj, member: token.val
-      if peek_token(false).type == :MEMBER_ACCESS
-        member_access access
-      elsif peek_token(false).type == :OPEN_PAREN
-        call access
-      elsif peek_token(false).type == :EQUALS
-        assignment access
-      else
-        access
-      end
-    end
-    
-    def new
-      assert_type next_token, :NEW
-      node = AST::New.new
-      node.callee = expression_after_unary(true, true)
-      if try_peek_token && peek_token.type == :OPEN_PAREN
-        call = call(node.callee)
-        node.arguments = call.arguments
-      end
-      node
+      AST::MemberAccess.new line: token.line, object: obj, member: token.val
     end
     
     def call(callee)
       assert_type next_token, :OPEN_PAREN
-      c = AST::Call.new callee: callee
-      while peek_token.type != :CLOSE_PAREN
-        c.arguments.push expression(true)
+      c = AST::Call.new line: token.line, callee: callee
+      while peek_token(true).type != :CLOSE_PAREN
+        c.arguments.push assignment_expression # one level below multi_expression which can separate by comma
         if peek_token.type == :COMMA
           next_token
           redo
@@ -413,33 +555,33 @@ module Twostroke
       assert_type next_token, :OPEN_BRACKET
       ind = expression
       assert_type next_token, :CLOSE_BRACKET
-      AST::Index.new object: obj, index: ind
+      AST::Index.new line: token.line, object: obj, index: ind
     end
     
     def return
       assert_type next_token, :RETURN
       expr = expression unless peek_token.type == :SEMICOLON || peek_token.type == :CLOSE_BRACE
-      AST::Return.new expression: expr
+      AST::Return.new line: token.line, expression: expr
     end
     
     def break
       assert_type next_token, :BREAK
-      AST::Break.new
+      AST::Break.new line: token.line
     end
     
     def continue
       assert_type next_token, :CONTINUE
-      AST::Continue.new
+      AST::Continue.new line: token.line
     end
     
     def throw
       assert_type next_token, :THROW
-      AST::Throw.new expression: expression
+      AST::Throw.new line: token.line, expression: expression
     end
     
     def delete
       assert_type next_token, :DELETE
-      AST::Delete.new expression: expression
+      AST::Delete.new line: token.line, expression: expression
     end
     
     def var
@@ -449,59 +591,49 @@ module Twostroke
     
     def var_rest
       assert_type next_token, :BAREWORD
-      decl = AST::Declaration.new(name: token.val)
+      decl = AST::Declaration.new line: token.line, name: token.val
       return decl if peek_token.type == :SEMICOLON || peek_token.type == :CLOSE_BRACE
       
       assert_type next_token, :COMMA, :EQUALS
       
       if token.type == :COMMA
-        AST::MultiExpression.new left: decl, right: var_rest
+        AST::MultiExpression.new line: token.line, left: decl, right: var_rest
       else
-        assignment = AST::Assignment.new left: decl, right: expression(true)
+        assignment = AST::Assignment.new line: token.line, left: decl, right: assignment_expression
         if peek_token.type == :SEMICOLON || peek_token.type == :CLOSE_BRACE
           assignment
         elsif peek_token.type == :COMMA
           next_token
-          AST::MultiExpression.new left: assignment, right: var_rest
+          AST::MultiExpression.new line: token.line, left: assignment, right: var_rest
         else
           error! "Unexpected #{peek_token.type}"
         end
       end
     end
     
-    def assignment(lval)
-      assert_type next_token, :EQUALS
-      AST::Assignment.new left: lval, right: expression
-    end
-    
-    def comma(left)
-      assert_type next_token, :COMMA
-      AST::MultiExpression.new left: left, right: expression
-    end
-    
     def number
       assert_type next_token, :NUMBER
-      AST::Number.new number: token.val
+      AST::Number.new line: token.line, number: token.val
     end
     
     def string
       assert_type next_token, :STRING
-      AST::String.new string: token.val
+      AST::String.new line: token.line, string: token.val
     end
     
     def regexp
       assert_type next_token, :REGEXP
-      AST::Regexp.new regexp: token.val
+      AST::Regexp.new line: token.line, regexp: token.val
     end
     
     def object_literal
       assert_type next_token, :OPEN_BRACE
-      obj = AST::ObjectLiteral.new
+      obj = AST::ObjectLiteral.new line: token.line
       while peek_token.type != :CLOSE_BRACE
         assert_type next_token, :BAREWORD, :STRING, :NUMBER
         key = token
         assert_type next_token, :COLON
-        obj.items.push [key, expression(true)]
+        obj.items.push [key, assignment_expression]
         if peek_token.type == :COMMA
           next_token
           redo
@@ -513,9 +645,9 @@ module Twostroke
     
     def array
       assert_type next_token, :OPEN_BRACKET
-      ary = AST::Array.new
-      while peek_token.type != :CLOSE_BRACKET
-        ary.items.push expression(true)
+      ary = AST::Array.new line: token.line
+      while peek_token(true).type != :CLOSE_BRACKET
+        ary.items.push assignment_expression
         if peek_token.type == :COMMA
           next_token
           redo
@@ -527,14 +659,14 @@ module Twostroke
     
     def parens
       assert_type next_token, :OPEN_PAREN
-      expr = AST::BracketedExpression.new value: expression
+      expr = AST::BracketedExpression.new line: token.line, value: expression
       assert_type next_token, :CLOSE_PAREN
       expr
     end
     
     def function
       assert_type next_token, :FUNCTION
-      fn = AST::Function.new arguments: [], statements: []
+      fn = AST::Function.new line: token.line, arguments: [], statements: []
       error! unless [:BAREWORD, :OPEN_PAREN].include? next_token.type
       if token.type == :BAREWORD
         fn.name = token.val
@@ -552,55 +684,5 @@ module Twostroke
       assert_type next_token, :CLOSE_BRACE
       fn
     end
-    
-    def not
-      assert_type next_token, :NOT
-      AST::Not.new value: expression_after_unary
-    end
-    
-    def tilde
-      assert_type next_token, :TILDE
-      AST::BinaryNot.new value: expression_after_unary
-    end
-    
-    def void
-      assert_type next_token, :VOID
-      AST::Void.new value: expression_after_unary
-    end
-    
-    def unary_plus
-      assert_type next_token, :PLUS
-      AST::UnaryPlus.new value: expression_after_unary
-    end
-    
-    def unary_minus
-      assert_type next_token, :MINUS
-      AST::Negation.new value: expression_after_unary
-    end
-    
-    def post_increment(obj)
-      assert_type next_token, :INCREMENT
-      AST::PostIncrement.new value: obj
-    end
-    
-    def post_decrement(obj)
-      assert_type next_token, :DECREMENT
-      AST::PostDecrement.new value: obj
-    end
-    
-    def pre_increment
-      assert_type next_token, :INCREMENT
-      AST::PreIncrement.new value: expression_after_unary
-    end
-    
-    def pre_decrement
-      assert_type next_token, :DECREMENT
-      AST::PreDecrement.new value: expression_after_unary
-    end
-    
-    def typeof
-      assert_type next_token, :TYPEOF
-      AST::TypeOf.new value: expression_after_unary
-    end
   end
 end