opal 0.3.41 → 0.3.42

data/lib/opal/grammar.y

@@ -591,6 +591,11 @@ aref_args:
     {
       result = val[0]
     }
+  | args ',' assocs trailer
+    {
+      val[0] << s(:hash, *val[2])
+      result = val[0]
+    }
   | assocs trailer
     {
       result = s(:array, s(:hash, *val[0]))
@@ -776,6 +781,15 @@ primary:
     {
       result = s(:defined, val[3])
     }
+  | NOT '(' expr ')'
+    {
+      result = s(:not, val[2])
+      result.line = val[2].line
+    }
+  | NOT '(' ')'
+    {
+      result = s(:not, s(:nil))
+    }
   | operation brace_block
     {
       result = val[1]
@@ -1014,6 +1028,10 @@ block_var_args:
     {
       result = new_block_args val[0], nil, val[2], val[3]
     }
+  | f_arg ','
+    {
+      result = new_block_args val[0], nil, nil, nil
+    }
   | f_arg opt_f_block_arg
     {
       result = new_block_args val[0], nil, nil, val[1]
@@ -1448,6 +1466,9 @@ var_lhs:
 
 backref:
     NTH_REF
+    {
+      result = s(:nth_ref, val[0])
+    }
   | BACK_REF
 
 superclass:

data/lib/opal/grammar_helpers.rb

@@ -0,0 +1,360 @@
+module Opal
+  class Grammar < Racc::Parser
+
+    def new_block(stmt = nil)
+      s = s(:block)
+      s << stmt if stmt
+      s
+    end
+
+    def new_compstmt(block)
+      if block.size == 1
+        nil
+      elsif block.size == 2
+        block[1]
+      else
+        block.line = block[1].line
+        block
+      end
+    end
+
+    def new_body(compstmt, res, els, ens)
+      s = compstmt || s(:block)
+      s.line = compstmt.line if compstmt
+
+      if res
+        s = s(:rescue, s)
+        res.each { |r| s << r }
+        s << els if els
+      end
+
+      ens ? s(:ensure, s, ens) : s
+    end
+
+    def new_defn(line, name, args, body)
+      body = s(:block, body) if body[0] != :block
+      scope = s(:scope, body)
+      body << s(:nil) if body.size == 1
+      scope.line = body.line
+      args.line = line
+      s = s(:defn, name.to_sym, args, scope)
+      s.line = line
+      s.end_line = @line
+      s
+    end
+
+    def new_defs(line, recv, name, args, body)
+      scope = s(:scope, body)
+      scope.line = body.line
+      s = s(:defs, recv, name.to_sym, args, scope)
+      s.line = line
+      s.end_line = @line
+      s
+    end
+
+    def new_class(path, sup, body)
+      scope = s(:scope)
+      scope << body unless body.size == 1
+      scope.line = body.line
+      s = s(:class, path, sup, scope)
+      s
+    end
+
+    def new_sclass(expr, body)
+      scope = s(:scope)
+      scope << body #unless body.size == 1
+      scope.line = body.line
+      s = s(:sclass, expr, scope)
+      s
+    end
+
+    def new_module(path, body)
+      scope = s(:scope)
+      scope << body unless body.size == 1
+      scope.line = body.line
+      s = s(:module, path, scope)
+      s
+    end
+
+    def new_iter(call, args, body)
+      s = s(:iter, call, args)
+      s << body if body
+      s.end_line = @line
+      s
+    end
+
+    def new_if(expr, stmt, tail)
+      s = s(:if, expr, stmt, tail)
+      s.line = expr.line
+      s.end_line = @line
+      s
+    end
+
+    def new_args(norm, opt, rest, block)
+      res = s(:args)
+
+      if norm
+        norm.each do |arg|
+          @scope.add_local arg
+          res << arg
+        end
+      end
+
+      if opt
+        opt[1..-1].each do |_opt|
+          res << _opt[1]
+        end
+      end
+
+      if rest
+        res << rest
+        rest_str = rest.to_s[1..-1]
+        @scope.add_local rest_str.to_sym unless rest_str.empty?
+      end
+
+      if block
+        res << block
+        @scope.add_local block.to_s[1..-1].to_sym
+      end
+
+      res << opt if opt
+
+      res
+    end
+
+    def new_block_args(norm, opt, rest, block)
+      res = s(:array)
+
+      if norm
+        norm.each do |arg|
+          @scope.add_local arg
+          res << s(:lasgn, arg)
+        end
+      end
+
+      if opt
+        opt[1..-1].each do |_opt|
+          res << s(:lasgn, _opt[1])
+        end
+      end
+
+      if rest
+        r = rest.to_s[1..-1].to_sym
+        res << s(:splat, s(:lasgn, r))
+        @scope.add_local r
+      end
+
+      if block
+        b = block.to_s[1..-1].to_sym
+        res << s(:block_pass, s(:lasgn, b))
+        @scope.add_local b
+      end
+
+      res << opt if opt
+
+      res.size == 2 && norm ? res[1] : s(:masgn, res)
+    end
+
+    def new_call(recv, meth, args = nil)
+      call = s(:call, recv, meth)
+      args = s(:arglist) unless args
+      args[0] = :arglist if args[0] == :array
+      call << args
+
+      if recv
+        call.line = recv.line
+      elsif args[1]
+        call.line = args[1].line
+      end
+
+      # fix arglist spilling over into next line if no args
+      if args.length == 1
+        args.line = call.line
+      else
+        args.line = args[1].line
+      end
+
+      call
+    end
+
+    def add_block_pass(arglist, block)
+      arglist << block if block
+      arglist
+    end
+
+    def new_op_asgn(op, lhs, rhs)
+      case op
+      when :"||"
+        result = s(:op_asgn_or, new_gettable(lhs))
+        result << (lhs << rhs)
+      when :"&&"
+        result = s(:op_asgn_and, new_gettable(lhs))
+        result << (lhs << rhs)
+      else
+        result = lhs
+        result << new_call(new_gettable(lhs), op, s(:arglist, rhs))
+
+      end
+
+      result.line = lhs.line
+      result
+    end
+
+    def new_assign(lhs, rhs)
+      case lhs[0]
+      when :iasgn, :cdecl, :lasgn, :gasgn, :cvdecl, :nth_ref
+        lhs << rhs
+        lhs
+      when :call, :attrasgn
+        lhs.last << rhs
+        lhs
+      else
+        raise "Bad lhs for new_assign: #{lhs[0]}"
+      end
+    end
+
+    def new_assignable(ref)
+      case ref[0]
+      when :ivar
+        ref[0] = :iasgn
+      when :const
+        ref[0] = :cdecl
+      when :identifier
+        @scope.add_local ref[1] unless @scope.has_local? ref[1]
+        ref[0] = :lasgn
+      when :gvar
+        ref[0] = :gasgn
+      when :cvar
+        ref[0] = :cvdecl
+      else
+        raise "Bad new_assignable type: #{ref[0]}"
+      end
+
+      ref
+    end
+
+    def new_gettable(ref)
+      res = case ref[0]
+            when :lasgn
+              s(:lvar, ref[1])
+            when :iasgn
+              s(:ivar, ref[1])
+            when :gasgn
+              s(:gvar, ref[1])
+            when :cvdecl
+              s(:cvar, ref[1])
+            else
+              raise "Bad new_gettable ref: #{ref[0]}"
+            end
+
+      res.line = ref.line
+      res
+    end
+
+    def new_var_ref(ref)
+      case ref[0]
+      when :self, :nil, :true, :false, :line, :file
+        ref
+      when :const
+        ref
+      when :ivar, :gvar, :cvar
+        ref
+      when :lit
+        # this is when we passed __LINE__ which is converted into :lit
+        ref
+      when :str
+        # returns for __FILE__ as it is converted into str
+        ref
+      when :identifier
+        if @scope.has_local? ref[1]
+          s(:lvar, ref[1])
+        else
+          s(:call, nil, ref[1], s(:arglist))
+        end
+      else
+        raise "Bad var_ref type: #{ref[0]}"
+      end
+    end
+
+    def new_super(args)
+      args = (args || s(:arglist))[1..-1]
+      s(:super, *args)
+    end
+
+    def new_yield(args)
+      args = (args || s(:arglist))[1..-1]
+      s(:yield, *args)
+    end
+
+    def new_xstr(str)
+      return s(:xstr, '') unless str
+      case str[0]
+      when :str   then str[0] = :xstr
+      when :dstr  then str[0] = :dxstr
+      when :evstr then str = s(:dxstr, '', str)
+      end
+
+      str
+    end
+
+    def new_dsym(str)
+      return s(:nil) unless str
+      case str[0]
+      when :str
+        str[0] = :lit
+        str[1] = str[1].to_sym
+      when :dstr
+        str[0] = :dsym
+      end
+
+      str
+    end
+
+    def new_str(str)
+      # cover empty strings
+      return s(:str, "") unless str
+      # catch s(:str, "", other_str)
+      if str.size == 3 and str[1] == "" and str[0] == :str
+        return str[2]
+      # catch s(:str, "content", more_content)
+      elsif str[0] == :str && str.size > 3
+        str[0] = :dstr
+        str
+      # top level evstr should be a dstr
+      elsif str[0] == :evstr
+        s(:dstr, "", str)
+      else
+        str
+      end
+    end
+
+    def new_regexp(reg, ending)
+      return s(:lit, //) unless reg
+      case reg[0]
+      when :str
+        s(:lit, Regexp.new(reg[1], ending))
+      when :evstr
+        s(:dregx, "", reg)
+      when :dstr
+        reg[0] = :dregx
+        reg
+      end
+    end
+
+    def str_append(str, str2)
+      return str2 unless str
+      return str unless str2
+
+      if str.first == :evstr
+        str = s(:dstr, "", str)
+      elsif str.first == :str
+        str = s(:dstr, str[1])
+      else
+        #puts str.first
+      end
+      str << str2
+      str
+    end
+  end
+end
+

data/lib/opal/lexer.rb

@@ -1,11 +1,9 @@
+require 'opal/core_ext'
 require 'opal/grammar'
+require 'opal/grammar_helpers'
+require 'opal/lexer_scope'
 require 'strscan'
 
-class Array
-  attr_accessor :line
-  attr_accessor :end_line
-end
-
 module Opal
 
   class Grammar < Racc::Parser
@@ -39,34 +37,7 @@ module Opal
     end
 
     def on_error(t, val, vstack)
-      raise "parse error on value #{val.inspect} :#{@file}:#{@line}"
-    end
-
-    # LexerScope is used during lexing to keep track of local variables
-    # created inside a scope. A lexer scope can be asked if it has a local
-    # variable defined, and it can also check its parent scope if applicable.
-    #
-    # A LexerScope is created automatically as a new scope is entered during
-    # the lexing stage.
-    class LexerScope
-      attr_reader :locals
-      attr_accessor :parent
-
-      def initialize(type)
-        @block  = type == :block
-        @locals = []
-        @parent = nil
-      end
-
-      def add_local(local)
-        @locals << local
-      end
-
-      def has_local?(local)
-        return true if @locals.include? local
-        return @parent.has_local?(local) if @parent and @block
-        false
-      end
+      raise "parse error on value #{val.inspect} (#{token_to_str(t) || '?'}) :#{@file}:#{@line}"
     end
 
     def push_scope(type = nil)
@@ -82,360 +53,6 @@ module Opal
       @scope = @scopes.last
     end
 
-    def new_block(stmt = nil)
-      s = s(:block)
-      s << stmt if stmt
-      s
-    end
-
-    def new_compstmt(block)
-      if block.size == 1
-        nil
-      elsif block.size == 2
-        block[1]
-      else
-        block.line = block[1].line
-        block
-      end
-    end
-
-    def new_body(compstmt, res, els, ens)
-      s = compstmt || s(:block)
-      s.line = compstmt.line if compstmt
-
-      if res
-        s = s(:rescue, s)
-        res.each { |r| s << r }
-        s << els if els
-      end
-
-      ens ? s(:ensure, s, ens) : s
-    end
-
-    def new_defn(line, name, args, body)
-      body = s(:block, body) if body[0] != :block
-      scope = s(:scope, body)
-      body << s(:nil) if body.size == 1
-      scope.line = body.line
-      args.line = line
-      s = s(:defn, name.to_sym, args, scope)
-      s.line = line
-      s.end_line = @line
-      s
-    end
-
-    def new_defs(line, recv, name, args, body)
-      scope = s(:scope, body)
-      scope.line = body.line
-      s = s(:defs, recv, name.to_sym, args, scope)
-      s.line = line
-      s.end_line = @line
-      s
-    end
-
-    def new_class(path, sup, body)
-      scope = s(:scope)
-      scope << body unless body.size == 1
-      scope.line = body.line
-      s = s(:class, path, sup, scope)
-      s
-    end
-
-    def new_sclass(expr, body)
-      scope = s(:scope)
-      scope << body #unless body.size == 1
-      scope.line = body.line
-      s = s(:sclass, expr, scope)
-      s
-    end
-
-    def new_module(path, body)
-      scope = s(:scope)
-      scope << body unless body.size == 1
-      scope.line = body.line
-      s = s(:module, path, scope)
-      s
-    end
-
-    def new_iter(call, args, body)
-      s = s(:iter, call, args)
-      s << body if body
-      s.end_line = @line
-      s
-    end
-
-    def new_if(expr, stmt, tail)
-      s = s(:if, expr, stmt, tail)
-      s.line = expr.line
-      s.end_line = @line
-      s
-    end
-
-    def new_args(norm, opt, rest, block)
-      res = s(:args)
-
-      if norm
-        norm.each do |arg|
-          @scope.add_local arg
-          res << arg
-        end
-      end
-
-      if opt
-        opt[1..-1].each do |_opt|
-          res << _opt[1]
-        end
-      end
-
-      if rest
-        res << rest
-        rest_str = rest.to_s[1..-1]
-        @scope.add_local rest_str.to_sym unless rest_str.empty?
-      end
-
-      if block
-        res << block
-        @scope.add_local block.to_s[1..-1].to_sym
-      end
-
-      res << opt if opt
-
-      res
-    end
-
-    def new_block_args(norm, opt, rest, block)
-      res = s(:array)
-
-      if norm
-        norm.each do |arg|
-          @scope.add_local arg
-          res << s(:lasgn, arg)
-        end
-      end
-
-      if opt
-        opt[1..-1].each do |_opt|
-          res << s(:lasgn, _opt[1])
-        end
-      end
-
-      if rest
-        r = rest.to_s[1..-1].to_sym
-        res << s(:splat, s(:lasgn, r))
-        @scope.add_local r
-      end
-
-      if block
-        b = block.to_s[1..-1].to_sym
-        res << s(:block_pass, s(:lasgn, b))
-        @scope.add_local b
-      end
-
-      res << opt if opt
-
-      res.size == 2 && norm ? res[1] : s(:masgn, res)
-    end
-
-    def new_call(recv, meth, args = nil)
-      call = s(:call, recv, meth)
-      args = s(:arglist) unless args
-      args[0] = :arglist if args[0] == :array
-      call << args
-
-      if recv
-        call.line = recv.line
-      elsif args[1]
-        call.line = args[1].line
-      end
-
-      # fix arglist spilling over into next line if no args
-      if args.length == 1
-        args.line = call.line
-      else
-        args.line = args[1].line
-      end
-
-      call
-    end
-
-    def add_block_pass(arglist, block)
-      arglist << block if block
-      arglist
-    end
-
-    def new_op_asgn(op, lhs, rhs)
-      case op
-      when :"||"
-        result = s(:op_asgn_or, new_gettable(lhs))
-        result << (lhs << rhs)
-      when :"&&"
-        result = s(:op_asgn_and, new_gettable(lhs))
-        result << (lhs << rhs)
-      else
-        result = lhs
-        result << new_call(new_gettable(lhs), op, s(:arglist, rhs))
-        
-      end
-
-      result.line = lhs.line
-      result 
-    end
-
-    def new_assign(lhs, rhs)
-      case lhs[0]
-      when :iasgn, :cdecl, :lasgn, :gasgn, :cvdecl
-        lhs << rhs
-        lhs
-      when :call, :attrasgn
-        lhs.last << rhs
-        lhs
-      else
-        raise "Bad lhs for new_assign: #{lhs[0]}"
-      end
-    end
-
-    def new_assignable(ref)
-      case ref[0]
-      when :ivar
-        ref[0] = :iasgn
-      when :const
-        ref[0] = :cdecl
-      when :identifier
-        @scope.add_local ref[1] unless @scope.has_local? ref[1]
-        ref[0] = :lasgn
-      when :gvar
-        ref[0] = :gasgn
-      when :cvar
-        ref[0] = :cvdecl
-      else
-        raise "Bad new_assignable type: #{ref[0]}"
-      end
-
-      ref
-    end
-
-    def new_gettable(ref)
-      res = case ref[0]
-            when :lasgn
-              s(:lvar, ref[1])
-            when :iasgn
-              s(:ivar, ref[1])
-            when :gasgn
-              s(:gvar, ref[1])
-            when :cvdecl
-              s(:cvar, ref[1])
-            else
-              raise "Bad new_gettable ref: #{ref[0]}"
-            end
-
-      res.line = ref.line
-      res
-    end
-
-    def new_var_ref(ref)
-      case ref[0]
-      when :self, :nil, :true, :false, :line, :file
-        ref
-      when :const
-        ref
-      when :ivar, :gvar, :cvar
-        ref
-      when :lit
-        # this is when we passed __LINE__ which is converted into :lit
-        ref
-      when :str
-        # returns for __FILE__ as it is converted into str
-        ref
-      when :identifier
-        if @scope.has_local? ref[1]
-          s(:lvar, ref[1])
-        else
-          s(:call, nil, ref[1], s(:arglist))
-        end
-      else
-        raise "Bad var_ref type: #{ref[0]}"
-      end
-    end
-
-    def new_super(args)
-      args = (args || s(:arglist))[1..-1]
-      s(:super, *args)
-    end
-
-    def new_yield(args)
-      args = (args || s(:arglist))[1..-1]
-      s(:yield, *args)
-    end
-
-    def new_xstr(str)
-      return s(:xstr, '') unless str
-      case str[0]
-      when :str   then str[0] = :xstr
-      when :dstr  then str[0] = :dxstr
-      when :evstr then str = s(:dxstr, '', str)
-      end
-
-      str
-    end
-
-    def new_dsym(str)
-      return s(:nil) unless str
-      case str[0]
-      when :str
-        str[0] = :lit
-        str[1] = str[1].to_sym
-      when :dstr
-        str[0] = :dsym
-      end
-
-      str
-    end
-
-    def new_str(str)
-      # cover empty strings
-      return s(:str, "") unless str
-      # catch s(:str, "", other_str)
-      if str.size == 3 and str[1] == "" and str[0] == :str
-        return str[2]
-      # catch s(:str, "content", more_content)
-      elsif str[0] == :str && str.size > 3
-        str[0] = :dstr
-        str
-      # top level evstr should be a dstr
-      elsif str[0] == :evstr
-        s(:dstr, "", str)
-      else
-        str
-      end
-    end
-
-    def new_regexp(reg, ending)
-      return s(:lit, //) unless reg
-      case reg[0]
-      when :str
-        s(:lit, Regexp.new(reg[1], ending))
-      when :evstr
-        res = s(:dregx, "", reg)
-      when :dstr
-        reg[0] = :dregx
-        reg
-      end
-    end
-
-    def str_append(str, str2)
-      return str2 unless str
-      return str unless str2
-
-      if str.first == :evstr
-        str = s(:dstr, "", str)
-      elsif str.first == :str
-        str = s(:dstr, str[1])
-      else
-        #puts str.first
-      end
-      str << str2
-      str
-    end
 
     def cond_push(n)
       @cond = (@cond << 1) | (n & 1)
@@ -495,19 +112,17 @@ module Opal
         end
         @string_parse = nil
 
-        # return :SPACE, ' ' if words && space
-
-        # if in %Q{, we should balance { with } before ending.
         if str_parse[:balance]
           if str_parse[:nesting] == 0
             @lex_state = :expr_end
+
+            if str_parse[:regexp]
+              return :REGEXP_END, scanner.matched
+            end
             return :STRING_END, scanner.matched
           else
-            #puts "nesting not 0!"
-            #puts str_parse[:nesting]
             str_buffer << scanner.matched
             str_parse[:nesting] -= 1
-            # make sure we carry on string parse (its set to nil above)
             @string_parse = str_parse
           end
 
@@ -519,7 +134,7 @@ module Opal
           @lex_state = :expr_end
           return :STRING_END, scanner.matched
 
-        elsif str_parse[:beg] == '/'
+        elsif str_parse[:beg] == '/' || str_parse[:regexp]
           result = scanner.scan(/\w+/)
           @lex_state = :expr_end
           return :REGEXP_END, result
@@ -533,7 +148,6 @@ module Opal
       return :SPACE, ' ' if space
 
       if str_parse[:balance] and scanner.scan Regexp.new(Regexp.escape(str_parse[:beg]))
-        #puts "matced beg balance!"
         str_buffer << scanner.matched
         str_parse[:nesting] += 1
       elsif scanner.check(/#[@$]/)
@@ -616,6 +230,8 @@ module Opal
               "\r"
             elsif scanner.scan(/\n/)
               "\n"
+            elsif scanner.scan(/t/)
+              "\t"
             else
               # escaped char doesnt need escaping, so just return it
               scanner.scan(/./)
@@ -719,6 +335,12 @@ module Opal
           @string_parse = { :beg => start_word, :end => end_word, :balance => true, :nesting => 0, :interpolate => true }
           return :XSTRING_BEG, scanner.matched
 
+        elsif scanner.scan(/\%r/)
+          start_word = scanner.scan(/./)
+          end_word   = { '(' => ')', '[' => ']', '{' => '}' }[start_word] || start_word
+          @string_parse = { :beg => start_word, :end => end_word, :regexp => true, :balance => true, :nesting => 0, :interpolate => true }
+          return :REGEXP_BEG, scanner.matched
+
         elsif scanner.scan(/\//)
           if [:expr_beg, :expr_mid].include? @lex_state
             @string_parse = { :beg => '/', :end => '/', :interpolate => true, :regexp => true }
@@ -743,10 +365,26 @@ module Opal
           if scanner.scan(/\=/)
             @lex_state = :expr_beg
             return :OP_ASGN, '%'
+          elsif scanner.check(/[^\s]/)
+            if @lex_state == :expr_beg or (@lex_state == :expr_arg && space_seen)
+              interpolate = true
+              start_word  = scanner.scan(/./)
+              end_word    = { '(' => ')', '[' => ']', '{' => '}' }[start_word] || start_word
+              @string_parse = { :beg => start_word, :end => end_word, :balance => true, :nesting => 0, :interpolate => interpolate }
+              return :STRING_BEG, scanner.matched
+            end
           end
           @lex_state = @lex_state == :expr_fname ? :expr_end : :expr_beg
           return '%', '%'
 
+        elsif scanner.scan(/\\/)
+          if scanner.scan(/\r?\n/)
+            space_seen = true
+            next
+          end
+
+          raise SyntaxError, "backslash must appear before newline :#{@file}:#{@line}"
+
         elsif scanner.scan(/\(/)
           result = scanner.matched
           if [:expr_beg, :expr_mid].include? @lex_state
@@ -1113,9 +751,24 @@ module Opal
           @lex_state = :expr_beg
           return '~', '~'
 
-        elsif scanner.scan(/\$[\+\'\`\&!@\"~*$?\/\\:;=.,<>_]/)
-          @lex_state = :expr_end
-          return :GVAR, scanner.matched
+        elsif scanner.check(/\$/)
+          if scanner.scan(/\$([1-9]\d*)/)
+            @lex_state = :expr_end
+            return :NTH_REF, scanner.matched.sub('$', '')
+
+          elsif scanner.scan(/(\$_)(\w+)/)
+            @lex_state = :expr_end
+            return :GVAR, scanner.matched
+
+          elsif scanner.scan(/\$[\+\'\`\&!@\"~*$?\/\\:;=.,<>_]/)
+            @lex_state = :expr_end
+            return :GVAR, scanner.matched
+          elsif scanner.scan(/\$\w+/)
+            @lex_state = :expr_end
+            return :GVAR, scanner.matched
+          else
+            raise "Bad gvar name: #{scanner.peek(5).inspect}"
+          end
 
         elsif scanner.scan(/\$\w+/)
           @lex_state = :expr_end
@@ -1158,8 +811,8 @@ module Opal
             return [:FLOAT, scanner.matched.gsub(/_/, '').to_f]
           elsif scanner.scan(/[\d_]+\b/)
             return [:INTEGER, scanner.matched.gsub(/_/, '').to_i]
-          elsif scanner.scan(/0(x|X)(\d|[a-f]|[A-F])+/)
-            return [:INTEGER, scanner.matched.to_i]
+          elsif scanner.scan(/0(x|X)(\d|[a-f]|[A-F]|_)+/)
+            return [:INTEGER, scanner.matched.to_i(16)]
           else
             raise "Lexing error on numeric type: `#{scanner.peek 5}`"
           end
@@ -1307,7 +960,7 @@ module Opal
             return :AND, matched
 
           when 'not'
-            @lex_state = :expr_beg
+            @lex_state = :expr_arg
             return :NOT, matched
 
           when 'return'
@@ -1341,6 +994,7 @@ module Opal
             return :SUPER, matched
 
           when 'then'
+            @lex_state = :expr_beg
             return :THEN, matched
 
           when 'while'