loxxy 0.4.00 → 0.4.04

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 47c5d65fa1f3c2d0025013577f46edf741572df743d8986e238f49a08ea32702
-  data.tar.gz: 72a3beb6828362e6dc7c73072555ed6f87ed5bf57b4052ac55e06503b9582e29
+  metadata.gz: e321e9f44f39776e2684a1a2c2f2d032460847ff46cdea45791cf8724696d038
+  data.tar.gz: 1c455133b79cd26939998ebd791c5b39872de1ccf59fa6b8c8d4c7d819114021
 SHA512:
-  metadata.gz: e83ee511c1ead4592153bb1e8ed8167439894bfefa2bb54060100eb9d221d77c453b4bad3d3e4a36209f3761812a5b9b0aa98b02a53556314c022d1f0b605bca
-  data.tar.gz: 8d939d7ff60687dd64c4dc6e4beccffa512e3483f5b38042a83fffbc0a5cc83d218999f855b8765a47e24b8c0df7808ecd649e70cec11832a0591b5c141a659c
+  metadata.gz: '031899513309e2950fd9dcf9fc782a14299bed0337e6ca2383351b277c69e1e5afc865d82a9bfce030d4780b9c738de18f18db970d862b344ac98ad00f22a2a7'
+  data.tar.gz: 60938437329c31b76307ea181e5596191b5261d55aeca369365fd8076f08879e2adfb112ec8cbaf1fd9d365e9e13816b644e1b897dd4f7840e37d9d20cc89ac8

data/.rubocop.yml

@@ -50,6 +50,9 @@ Layout/IndentationConsistency:
 Layout/HeredocIndentation:
   Enabled: false
 
+Layout/LineEndStringConcatenationIndentation:
+  Enabled: true
+
 Layout/MultilineHashBraceLayout:
   Enabled: true
 
@@ -81,6 +84,9 @@ Layout/TrailingWhitespace:
 Lint/AmbiguousAssignment:
   Enabled: true
 
+Lint/AmbiguousRange:
+  Enabled: true
+
 Lint/DeprecatedConstants:
   Enabled: true
 
@@ -96,6 +102,9 @@ Lint/EmptyBlock:
 Lint/EmptyClass:
   Enabled: false
 
+Lint/EmptyInPattern:
+  Enabled: true
+
 Lint/LambdaWithoutLiteralBlock:
   Enabled: true
 
@@ -192,6 +201,9 @@ Naming/ClassAndModuleCamelCase:
 Naming/BlockParameterName:
   Enabled: true
 
+Naming/InclusiveLanguage:
+  Enabled: true
+
 Naming/MethodParameterName:
   Enabled: false
 
@@ -273,11 +285,17 @@ Style/HashTransformValues:
 Style/IfUnlessModifier:
   Enabled: false
 
+Style/InPatternThen:
+  Enabled: true
+
 Style/InverseMethods:
   Enabled: false
 
 Style/MissingRespondToMissing:
   Enabled: false
+  
+Style/MultilineInPatternThen:
+  Enabled: true  
 
 Style/NegatedIfElseCondition:
   Enabled: true
@@ -290,6 +308,9 @@ Style/NilLambda:
 
 Style/NumericLiterals:
   Enabled: false
+  
+Style/QuotedSymbols:
+  Enabled: true  
 
 Style/RaiseArgs:
   Enabled: true
@@ -302,6 +323,9 @@ Style/RedundantReturn:
 
 Style/RedundantSelf:
   Enabled: true
+  
+Style/RedundantSelfAssignmentBranch:
+  Enabled: true  
 
 Style/RegexpLiteral:
   Enabled: false

data/CHANGELOG.md

@@ -1,3 +1,33 @@
+## [0.4.04] - 2021-09-11
+- Grammar optimization (3 rules less, use of match_closest feature from `Rley`)
+
+### Changed
+- Method `Ast::AstBuilder#reduce_arguments` code re-styling: use shorthand &:
+- File `grammar.rb` use `match_closest` constraint from Rley to cope with dangling else statement
+
+## [0.4.02] - 2021-09-10
+- Fixes in`AST::AstBuilder` class to  cope with changes in Rley 0.8.03
+
+### Changed
+- File `loxxy.gemspec` forced dependency to Rley 0.8.03
+
+### Fixed
+- Method `Ast::AstBuilder#reduce_class_naming` fixed access to `IDENTIFER` in (LESS IDENTIFER)?
+- Method `Ast::AstBuilder#reduce_var_declaration` fixed access to `expression` in (EQUAL expression)?
+- Method `Ast::AstBuilder#reduce_assign_expr`fixed access to `call` in (call DOT)?
+- Method `Ast::AstBuilder#reduce_parameters`fixed access to `IDENTIFIER` in (COMMA IDENTIFIER)*
+- Method `Ast::AstBuilder#reduce_arguments`fixed access to `expression` in (COMMA expression)*
+
+
+
+## [0.4.01] - 2021-08-22
+- Grammar and AST::AstBuilder adapted to take profit of extended grammar notiation in Rley 0.8.01
+
+### Changed
+- Class `Ast::ASTBuilder` removal of methods made redundant with new Rley version
+- File `.rubocop.yml` added config for new cops
+- File `grammar.rb` changed rules to use new extended rule syntax in Rley
+
 ## [0.4.00] - 2021-05-24
 - Version bump. `Loxxy` is capable to run the LoxLox interpreter, an interpreter written in `Lox`.
 
@@ -45,14 +75,14 @@
 - Milestone: `Loxxy` passes all reference test suite.
 
 ### Fixed
-- Method `BackEnd::Resolver#before_variable_expr`: Standard `Lox` allows re-declaration of a variable at top-level scope 
+- Method `BackEnd::Resolver#before_variable_expr`: Standard `Lox` allows re-declaration of a variable at top-level scope
+
 
- 
 ## [0.2.06] - 2021-05-04
 - Nearly passing the 'official' test suite, fixing non-compliant behavior, specialized exceptions for errors
 
 ### New
-- Module `LoxFileTester` module that hosts methods that simplify the tests of `Lox` source file. 
+- Module `LoxFileTester` module that hosts methods that simplify the tests of `Lox` source file.
 
 ### Changed
 - Folder `test_suite` vastly reorganized. Sub-folder `baseline` contains spec files testing the `Lox` files from official implementation
@@ -62,7 +92,7 @@
 
 ### Fixed
 - `0/0` expression results in a ZeroDivisionError exception, in Lox this result to a NaN (Not a Number). Now, `Loxxy` is aligned to standard `Lox`
-- `FrontEnd::Scanner` now always treats expression like `-123` as the unary or binary minus operator applied to a positive number. 
+- `FrontEnd::Scanner` now always treats expression like `-123` as the unary or binary minus operator applied to a positive number.
 
 ## [0.2.05] - 2021-04-26
 - `Loxxy` now transforms for loops into while loops (desugaring), fix in Scanner class
@@ -89,7 +119,7 @@
 - Method `BackEnd::Resolver#after_for_stmt now accepts nil test expression
 
 ## [0.2.03] - 2021-04-24
-- Fixes for the set (field) expressions, `accept` methods for AST nodes are meta-programmed 
+- Fixes for the set (field) expressions, `accept` methods for AST nodes are meta-programmed
 
 ### New
 - Module `Ast::Visitee` provides the `define_accept` method that generate `accept` method with meta-programming
@@ -264,7 +294,7 @@
 - Fix and test suite for return statements
 
 ### CHANGED
-- `Loxxy` reports an error when a return statement occurs in top-level scope 
+- `Loxxy` reports an error when a return statement occurs in top-level scope
 
 ### Fixed
 - A return without explicit value genrated an exception in some cases.
@@ -288,7 +318,7 @@
 - Class `BackEnd::Environment`: added the attributes `predecessor` and `embedding` to support closures.
 - Class `BackeEnd::LoxFunction`: added the attribute `closure` that is equal to the environment where the function is declared.
 - Constructor `BackEnd::LoxFunction#new` now takes a `BackEnd::Engine`as its fourth parameter
-- Methods `BackEnd::SymbolTable#enter_environment`, `BackEnd::SymbolTable#leave_environment` take into account closures. 
+- Methods `BackEnd::SymbolTable#enter_environment`, `BackEnd::SymbolTable#leave_environment` take into account closures.
 
 ### Fixed
 - Method `Ast::AstBuilder#after_var_stmt` now takes into account the value from the top of stack
@@ -334,7 +364,7 @@
 
 ### Changed
 - File `console` renamed to `loxxy`. Very basic command-line interface.
-- Custom exception classes 
+- Custom exception classes
 - File `README.md` updated list of supported `Lox` keywords.
 
 
@@ -365,8 +395,8 @@
 - Method `Ast::ASTVisitor#visit_fun_stmt` for visiting an `Ast::LoxFunStmt` node
 - Method `Ast::LoxBlockStmt#empty?` returns true if the code block is empty
 - Method `BackEnd::Engine#after_fun_stmt`
-- Method `BackEnd::NativeFunction#call` 
-- Method `BackEnd::NativeFunction#to_str` 
+- Method `BackEnd::NativeFunction#call`
+- Method `BackEnd::NativeFunction#to_str`
 - Method `BackEnd::LoxFunction` runtime representation of a Lox function.
 
 ### Changed
@@ -435,7 +465,7 @@
 - Method `Ast::ASTBuilder#reduce_assign_expr` creates an `Ast::LoxAssignExpr` node
 - Method `Ast::ASTVisitor#visit_assign_expr` for visiting an `Ast::LoxAssignExpr` node
 - Method `BackEnd::Engine#after_assign_expr` implementation of the assignment
-- Method `BackEnd::Variable#assign` to assign a value to a variable 
+- Method `BackEnd::Variable#assign` to assign a value to a variable
 
 ## [0.0.23] - 2021-01-20
 - Fix for variables without explicit initialization.
@@ -705,4 +735,4 @@
 
 ## [0.0.1] - 2020-12-27
 ### Added
-- Initial Github commit
+- Initial Github commit

data/lib/loxxy/ast/ast_builder.rb

@@ -143,63 +143,36 @@ module Loxxy
       #  SEMANTIC ACTIONS
       #####################################
 
-      # rule('program' => 'EOF').as 'null_program'
-      def reduce_null_program(_production, _range, _tokens, _theChildren)
-        Ast::LoxNoopExpr.new(tokens[0].position)
-      end
-
-      # rule('program' => 'declaration_plus EOF').as ''
+      # rule('program' => 'declaration+ EOF').as ''
       def reduce_lox_program(_production, _range, tokens, theChildren)
-        LoxSeqDecl.new(tokens[0].position, theChildren[0])
-      end
-
-      # rule('declaration_plus' => 'declaration_plus declaration').as ''
-      def reduce_declaration_plus_more(_production, _range, _tokens, theChildren)
-        theChildren[0] << theChildren[1]
-      end
-
-      # rule('declaration_plus' => 'declaration')
-      def reduce_declaration_plus_end(_production, _range, _tokens, theChildren)
-        [theChildren[0]]
+        if theChildren[0].empty?
+          Ast::LoxNoopExpr.new(tokens[0].position)
+        else
+          LoxSeqDecl.new(tokens[0].position, theChildren[0])
+        end
       end
 
       # rule('classDecl' => 'CLASS classNaming class_body')
       def reduce_class_decl(_production, _range, _tokens, theChildren)
-        if theChildren[1].kind_of?(Array)
-          name = theChildren[1].first
-          parent = theChildren[1].last
-        else
-          name = theChildren[1]
-          parent = nil
-        end
+        name = theChildren[1].first
+        parent = theChildren[1].last
         Ast::LoxClassStmt.new(tokens[1].position, name, parent, theChildren[2])
       end
 
-      # rule('classNaming' => 'IDENTIFIER')
-      def reduce_class_name(_production, _range, _tokens, theChildren)
-        theChildren[0].token.lexeme
-      end
-
-      # rule('classNaming' => 'IDENTIFIER LESS IDENTIFIER')
-      def reduce_class_subclassing(_production, _range, _tokens, theChildren)
-        super_token = theChildren[2].token
-        super_var = LoxVariableExpr.new(super_token.position, super_token.lexeme)
+      # rule('classNaming' => 'IDENTIFIER (LESS IDENTIFIER)?')
+      def reduce_class_naming(_production, _range, _tokens, theChildren)
+        if theChildren[1].nil?
+          super_var = nil
+        else
+          super_token = theChildren[1].last.token
+          super_var = LoxVariableExpr.new(super_token.position, super_token.lexeme)
+        end
         [theChildren[0].token.lexeme, super_var]
       end
 
-      # rule('class_body' => 'LEFT_BRACE methods_opt RIGHT_BRACE')
+      # rule('class_body' => 'LEFT_BRACE function* RIGHT_BRACE')
       def reduce_class_body(_production, _range, _tokens, theChildren)
-        theChildren[1].nil? ? [] : theChildren[1]
-      end
-
-      # rule('method_plus' => 'method_plus function')
-      def reduce_method_plus_more(_production, _range, _tokens, theChildren)
-        theChildren[0] << theChildren[1]
-      end
-
-      # rule('method_plus' => 'function')
-      def reduce_method_plus_end(_production, _range, _tokens, theChildren)
-        theChildren
+        theChildren[1]
       end
 
       # rule('funDecl' => 'FUN function')
@@ -212,16 +185,11 @@ module Loxxy
       return_first_child(range, tokens, theChildren) # Discard the semicolon
       end
 
-      # rule('varDecl' => 'VAR IDENTIFIER SEMICOLON')
+      # rule('varDecl' => 'VAR IDENTIFIER (EQUAL expression)? SEMICOLON')
       def reduce_var_declaration(_production, _range, tokens, theChildren)
         var_name = theChildren[1].token.lexeme.dup
-        Ast::LoxVarStmt.new(tokens[1].position, var_name, nil)
-      end
-
-      # rule('varDecl' => 'VAR IDENTIFIER EQUAL expression SEMICOLON')
-      def reduce_var_initialization(_production, _range, tokens, theChildren)
-        var_name = theChildren[1].token.lexeme.dup
-        Ast::LoxVarStmt.new(tokens[1].position, var_name, theChildren[3])
+        init_val = theChildren[2] ? theChildren[2].last : nil
+        Ast::LoxVarStmt.new(tokens[1].position, var_name, init_val)
       end
 
       # rule('forStmt' => 'FOR LEFT_PAREN forControl RIGHT_PAREN statement')
@@ -248,7 +216,7 @@ module Loxxy
         for_stmt
       end
 
-      # rule('forControl' => 'forInitialization forTest forUpdate')
+      # rule('forControl' => 'forInitialization forTest expression?')
       def reduce_for_control(_production, _range, tokens, theChildren)
         (init, test, update) = theChildren
         if test.nil? && update
@@ -265,7 +233,7 @@ module Loxxy
         nil
       end
 
-      # rule('forTest' => 'expression_opt SEMICOLON')
+      # rule('forTest' => 'expression? SEMICOLON')
       def reduce_for_test(_production, range, tokens, theChildren)
         return_first_child(range, tokens, theChildren)
       end
@@ -292,7 +260,7 @@ module Loxxy
         Ast::LoxPrintStmt.new(tokens[1].position, theChildren[1])
       end
 
-      # rule('returnStmt' => 'RETURN expression_opt SEMICOLON')
+      # rule('returnStmt' => 'RETURN expression? SEMICOLON')
       def reduce_return_stmt(_production, _range, tokens, theChildren)
         Ast::LoxReturnStmt.new(tokens[1].position, theChildren[1])
       end
@@ -302,34 +270,31 @@ module Loxxy
         Ast::LoxWhileStmt.new(tokens[1].position, theChildren[2], theChildren[4])
       end
 
-      # rule('block' => 'LEFT_BRACE declaration_plus RIGHT_BRACE')
+      # rule('block' => 'LEFT_BRACE declaration* RIGHT_BRACE')
       def reduce_block_stmt(_production, _range, tokens, theChildren)
-        decls = LoxSeqDecl.new(tokens[1].position, theChildren[1])
-        Ast::LoxBlockStmt.new(tokens[1].position, decls)
-      end
-
-      # rule('block' => 'LEFT_BRACE RIGHT_BRACE').as 'block_empty'
-      def reduce_block_empty(_production, _range, tokens, _children)
-        Ast::LoxBlockStmt.new(tokens[0].position, nil)
+        decls = nil
+        if theChildren[1]
+          pos = tokens[1].position
+          decls = LoxSeqDecl.new(tokens[1].position, theChildren[1])
+        else
+          pos = tokens[0].position
+        end
+        Ast::LoxBlockStmt.new(pos, decls)
       end
 
-      # rule('assignment' => 'owner_opt IDENTIFIER EQUAL assignment')
+      # rule('assignment' => '(call DOT)? IDENTIFIER EQUAL assignment')
       def reduce_assign_expr(_production, _range, tokens, theChildren)
         name_assignee = theChildren[1].token.lexeme.dup
-        if theChildren[0].kind_of?(Ast::LoxSetExpr)
-          theChildren[0].property = name_assignee
-          theChildren[0].value = theChildren[3]
-          theChildren[0]
+        if theChildren[0]
+          set_expr = Ast::LoxSetExpr.new(tokens[1].position, theChildren[0].first)
+          set_expr.property = name_assignee
+          set_expr.value = theChildren[3]
+          set_expr
         else
           Ast::LoxAssignExpr.new(tokens[1].position, name_assignee, theChildren[3])
         end
       end
 
-      # rule('owner_opt' => 'call DOT')
-      def reduce_set_expr(_production, _range, tokens, theChildren)
-        Ast::LoxSetExpr.new(tokens[1].position, theChildren[0])
-      end
-
 
       # rule('comparisonTest_plus' => 'comparisonTest_plus comparisonTest term').as 'comparison_t_plus_more'
       # TODO: is it meaningful to implement this rule?
@@ -343,6 +308,7 @@ module Loxxy
 
       # rule('call' => 'primary refinement_plus').as 'call_expr'
       def reduce_call_expr(_production, _range, _tokens, theChildren)
+        # return theChildren[0] unless theChildren[1]
         members = theChildren.flatten
         call_expr = nil
         loop do
@@ -365,7 +331,7 @@ module Loxxy
         theChildren
       end
 
-      # rule('refinement' => 'LEFT_PAREN arguments_opt RIGHT_PAREN')
+      # rule('refinement' => 'LEFT_PAREN arguments? RIGHT_PAREN')
       def reduce_call_arglist(_production, _range, tokens, theChildren)
         args = theChildren[1] || []
         if args.size > 255
@@ -422,24 +388,21 @@ module Loxxy
         LoxFunStmt.new(pos, first_child.token.lexeme, theChildren[2], theChildren[4])
       end
 
-      # rule('parameters' => 'parameters COMMA IDENTIFIER')
-      def reduce_parameters_plus_more(_production, _range, _tokens, theChildren)
-        theChildren[0] << theChildren[2].token.lexeme
-      end
+      # rule('parameters' => 'IDENTIFIER (COMMA IDENTIFIER)*').as 'parameters'
+      def reduce_parameters(_production, _range, _tokens, theChildren)
+        first_lexeme = theChildren[0].token.lexeme
+        return [first_lexeme] unless theChildren[1]
 
-      # rule('parameters' => 'IDENTIFIER')
-      def reduce_parameters_plus_end(_production, _range, _tokens, theChildren)
-        [theChildren[0].token.lexeme]
+        successors = theChildren[1].map { |seq_node| seq_node.last.token.lexeme }
+        successors.unshift(first_lexeme)
       end
 
-      # rule('arguments' => 'arguments COMMA expression')
-      def reduce_arguments_plus_more(_production, _range, _tokens, theChildren)
-        theChildren[0] << theChildren[2]
-      end
+      # rule('arguments' => 'expression (COMMA expression)*')
+      def reduce_arguments(_production, _range, _tokens, theChildren)
+        return [theChildren[0]] unless theChildren[1]
 
-      # rule('arguments' => 'expression')
-      def reduce_arguments_plus_end(_production, _range, _tokens, theChildren)
-        theChildren
+        successors = theChildren[1].map(&:last)
+        successors.unshift(theChildren[0])
       end
     end # class
   end # module

data/lib/loxxy/ast/lox_node.rb

@@ -11,7 +11,7 @@ module Loxxy
       # Let nodes take `visitee` role as defined in the Visitor design pattern
       extend ASTVisitee
 
-      # return [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @return [Rley::Lexical::Position] Position of the entry in the input stream.
       attr_reader :position
 
       # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.

data/lib/loxxy/front_end/grammar.rb

@@ -7,9 +7,9 @@ module Loxxy
   module FrontEnd
     ########################################
     # Grammar for Lox language
-    # Authoritave grammar at:
+    # Authoritative grammar at:
     #   https://craftinginterpreters.com/appendix-i.html
-    builder = Rley::Syntax::GrammarBuilder.new do
+    builder = Rley::grammar_builder do
       # Punctuators, separators...
       add_terminals('LEFT_PAREN', 'RIGHT_PAREN', 'LEFT_BRACE', 'RIGHT_BRACE')
       add_terminals('COMMA', 'DOT', 'MINUS', 'PLUS')
@@ -26,34 +26,23 @@ module Loxxy
       add_terminals('EOF')
 
       # Top-level rule that matches an entire Lox program
-      rule('program' => 'EOF').as 'null_program'
-      rule('program' => 'declaration_plus EOF').as 'lox_program'
+      rule('program' => 'declaration* EOF').as 'lox_program'
 
       # Declarations: bind an identifier to something
-      rule('declaration_plus' => 'declaration_plus declaration').as 'declaration_plus_more'
-      rule('declaration_plus' => 'declaration').as 'declaration_plus_end'
       rule('declaration' => 'classDecl')
       rule('declaration' => 'funDecl')
       rule('declaration' => 'varDecl')
-      rule('declaration' => 'stmt')
+      rule('declaration' => 'statement')
 
       rule('classDecl' => 'CLASS classNaming class_body').as 'class_decl'
-      rule('classNaming' => 'IDENTIFIER LESS IDENTIFIER').as 'class_subclassing'
-      rule('classNaming' => 'IDENTIFIER').as 'class_name'
-      rule('class_body' => 'LEFT_BRACE methods_opt RIGHT_BRACE').as 'class_body'
-      rule('methods_opt' => 'method_plus')
-      rule('methods_opt' => [])
-      rule('method_plus' => 'method_plus function').as 'method_plus_more'
-      rule('method_plus' => 'function').as 'method_plus_end'
+      rule('classNaming' => 'IDENTIFIER (LESS IDENTIFIER)?').as 'class_naming'
+      rule('class_body' => 'LEFT_BRACE function* RIGHT_BRACE').as 'class_body'
 
       rule('funDecl' => 'FUN function').as 'fun_decl'
 
-      rule('varDecl' => 'VAR IDENTIFIER SEMICOLON').as 'var_declaration'
-      rule('varDecl' => 'VAR IDENTIFIER EQUAL expression SEMICOLON').as 'var_initialization'
+      rule('varDecl' => 'VAR IDENTIFIER (EQUAL expression)? SEMICOLON').as 'var_declaration'
 
       # Statements: produce side effects, but don't introduce bindings
-      rule('stmt' => 'statement')
-      rule('stmt' => 'unbalancedStmt') # Tweak to cope with "dangling else" problem
       rule('statement' => 'exprStmt')
       rule('statement' => 'forStmt')
       rule('statement' => 'ifStmt')
@@ -65,32 +54,25 @@ module Loxxy
       rule('exprStmt' => 'expression SEMICOLON').as 'exprStmt'
 
       rule('forStmt' => 'FOR LEFT_PAREN forControl RIGHT_PAREN statement').as 'for_stmt'
-      rule('forControl' => 'forInitialization forTest forUpdate').as 'for_control'
+      rule('forControl' => 'forInitialization forTest expression?').as 'for_control'
       rule('forInitialization' => 'varDecl')
       rule('forInitialization' => 'exprStmt')
       rule('forInitialization' => 'SEMICOLON').as 'empty_for_initialization'
-      rule('forTest' => 'expression_opt SEMICOLON').as 'for_test'
-      rule('forUpdate' => 'expression_opt')
+      rule('forTest' => 'expression? SEMICOLON').as 'for_test'
 
-      rule('ifStmt' => 'IF ifCondition statement ELSE statement').as 'if_else_stmt'
-      rule('unbalancedStmt' => 'IF ifCondition stmt').as 'if_stmt'
-      rule('unbalancedStmt' => 'IF ifCondition statement ELSE unbalancedStmt').as 'if_else_stmt'
+      rule('ifStmt' => 'IF ifCondition statement ELSE {match_closest: "IF"}  statement').as 'if_else_stmt'
+      rule('ifStmt' => 'IF ifCondition statement').as 'if_stmt'
       rule('ifCondition' => 'LEFT_PAREN expression RIGHT_PAREN').as 'keep_symbol2'
 
       rule('printStmt' => 'PRINT expression SEMICOLON').as 'print_stmt'
-      rule('returnStmt' => 'RETURN expression_opt SEMICOLON').as 'return_stmt'
+      rule('returnStmt' => 'RETURN expression? SEMICOLON').as 'return_stmt'
       rule('whileStmt' => 'WHILE LEFT_PAREN expression RIGHT_PAREN statement').as 'while_stmt'
-      rule('block' => 'LEFT_BRACE declaration_plus RIGHT_BRACE').as 'block_stmt'
-      rule('block' => 'LEFT_BRACE RIGHT_BRACE').as 'block_empty'
+      rule('block' => 'LEFT_BRACE declaration* RIGHT_BRACE').as 'block_stmt'
 
       # Expressions: produce values
-      rule('expression_opt' => 'expression')
-      rule('expression_opt' => [])
       rule('expression' => 'assignment')
-      rule('assignment' => 'owner_opt IDENTIFIER EQUAL assignment').as 'assign_expr'
+      rule('assignment' => '(call DOT)? IDENTIFIER EQUAL assignment').as 'assign_expr'
       rule('assignment' => 'logic_or')
-      rule('owner_opt' => 'call DOT').as 'set_expr'
-      rule('owner_opt' => [])
       rule('logic_or' => 'logic_and')
       rule('logic_or' => 'logic_and disjunct_plus').as 'logical_expr'
       rule('disjunct_plus' => 'disjunct_plus OR logic_and').as 'binary_plus_more'
@@ -130,10 +112,8 @@ module Loxxy
       rule('unaryOp' => 'BANG')
       rule('unaryOp' => 'MINUS')
       rule('call' => 'primary')
-      rule('call' => 'primary refinement_plus').as 'call_expr'
-      rule('refinement_plus' => 'refinement_plus refinement').as 'refinement_plus_more'
-      rule('refinement_plus' => 'refinement').as 'refinement_plus_end'
-      rule('refinement' => 'LEFT_PAREN arguments_opt RIGHT_PAREN').as 'call_arglist'
+      rule('call' => 'primary refinement+').as 'call_expr'
+      rule('refinement' => 'LEFT_PAREN arguments? RIGHT_PAREN').as 'call_arglist'
       rule('refinement' => 'DOT IDENTIFIER').as 'get_expr'
       rule('primary' => 'TRUE').as 'literal_expr'
       rule('primary' => 'FALSE').as 'literal_expr'
@@ -146,15 +126,9 @@ module Loxxy
       rule('primary' => 'SUPER DOT IDENTIFIER').as 'super_expr'
 
       # Utility rules
-      rule('function' => 'IDENTIFIER LEFT_PAREN params_opt RIGHT_PAREN block').as 'function'
-      rule('params_opt' => 'parameters')
-      rule('params_opt' => [])
-      rule('parameters' => 'parameters COMMA IDENTIFIER').as 'parameters_plus_more'
-      rule('parameters' => 'IDENTIFIER').as 'parameters_plus_end'
-      rule('arguments_opt' => 'arguments')
-      rule('arguments_opt' => [])
-      rule('arguments' => 'arguments COMMA expression').as 'arguments_plus_more'
-      rule('arguments' => 'expression').as 'arguments_plus_end'
+      rule('function' => 'IDENTIFIER LEFT_PAREN parameters? RIGHT_PAREN block').as 'function'
+      rule('parameters' => 'IDENTIFIER (COMMA IDENTIFIER)*').as 'parameters'
+      rule('arguments' => 'expression (COMMA expression)*').as 'arguments'
     end
 
     unless defined?(Grammar)

data/lib/loxxy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Loxxy
-  VERSION = '0.4.00'
+  VERSION = '0.4.04'
 end

data/loxxy.gemspec

@@ -48,7 +48,7 @@ Gem::Specification.new do |spec|
   DESCR_END
   spec.homepage      = 'https://github.com/famished-tiger/loxxy'
   spec.license       = 'MIT'
-  spec.required_ruby_version = '~> 2.4'
+  spec.required_ruby_version = '~> 2.5'
 
   spec.bindir        = 'bin'
   spec.executables   = ['loxxy']
@@ -58,7 +58,7 @@ Gem::Specification.new do |spec|
   PkgExtending.pkg_documentation(spec)
 
   # Runtime dependencies
-  spec.add_dependency 'rley', '~> 0.7.06'
+  spec.add_dependency 'rley', '~> 0.8.03'
 
   # Development dependencies
   spec.add_development_dependency 'bundler', '~> 2.0'

data/spec/front_end/raw_parser_spec.rb

@@ -26,7 +26,10 @@ module Loxxy
           #   program => declaration_star EOF
           #   where the declaration_star MUST be empty
           expect(aParseTree.root.symbol.name).to eq('program')
-          eof = aParseTree.root.subnodes.first
+          (decls, eof) = aParseTree.root.subnodes
+          expect(decls).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(decls.symbol.name).to eq('declaration_star')
+          expect(decls.subnodes).to be_empty
           expect(eof).to be_kind_of(Rley::PTree::TerminalNode)
           expect(eof.symbol.name).to eq('EOF')
         end
@@ -73,11 +76,12 @@ LOX_END
           expect(root.symbol.name).to eq('program')
           (decls, eof) = root.subnodes
           expect(decls).to be_kind_of(Rley::PTree::NonTerminalNode)
-          expect(decls.symbol.name).to eq('declaration_plus')
-          stmt = decls.subnodes[0].subnodes[0]
-          expect(stmt).to be_kind_of(Rley::PTree::NonTerminalNode)
-          expect(stmt.symbol.name).to eq('stmt')
-          statement = stmt.subnodes[0]
+          expect(decls.symbol.name).to eq('declaration_star')
+          expect(decls.subnodes[0]).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(decls.subnodes[0].symbol.name).to eq('declaration_star')
+          expect(decls.subnodes[1]).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(decls.subnodes[1].symbol.name).to eq('declaration')
+          statement = decls.subnodes[1].subnodes[0]
           expect(statement).to be_kind_of(Rley::PTree::NonTerminalNode)
           expect(statement.symbol.name).to eq('statement')
           prnt_stmt = statement.subnodes[0]

data/spec/spec_helper.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'rspec' # Use the RSpec framework
-require 'loxxy'
+require_relative '../lib/loxxy'
 
 RSpec.configure do |config|
   # Enable flags like --only-failures and --next-failure

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: loxxy
 version: !ruby/object:Gem::Version
-  version: 0.4.00
+  version: 0.4.04
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-24 00:00:00.000000000 Z
+date: 2021-09-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.7.06
+        version: 0.8.03
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.7.06
+        version: 0.8.03
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -173,7 +173,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - "~>"
     - !ruby/object:Gem::Version
-      version: '2.4'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="