loxxy 0.1.10 → 0.1.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1fc5399ac3346487808eeb40403b3324cca384e3c6820d965b75f2e320759d2c
-  data.tar.gz: f9b6497d87036f6c88ed09a72113a1ea004df9db8fd9bb945672c370993f7fde
+  metadata.gz: c3994a3225b7dbc4a39d24cc646c20e4a7a19b074e85fe2dd9bc87d9ca1d61cb
+  data.tar.gz: 965c328057f51fb7d13886255955e782e51b1f030f3053a6f5f6f4534962855b
 SHA512:
-  metadata.gz: 0b0fa0313a0b37882d0398238a65f10b6ea8ab4325447e1f4690ea7100bdb85dead8cb15d8e1e56b422741697d636c7e2c114cf17ad43781dc23462ab51c93af
-  data.tar.gz: b93b3d01a0e80def496ecfeb955e64000cc88149229ceb97e2743ccda863ec23677958aad9423dd0ca433d72451e120be6fa40247db7cbc49710ac8c17ea8987
+  metadata.gz: 9db05948e45f7903ca71d7d0e3722f3c9b1fd3f50931e17b6bb1666c34cf03e1dc7f6cf32abee461dd6e6ec6824cd89b8ef5b2b56ae41fcd40068228d8cbaba2
+  data.tar.gz: eaa762982bd89f2b4cb85e8d6831017e702b87501b7c29132f25f79fa592bf804ec95736f518d304f43caf814aa55eeadd5041ffcba1afa3aaaed631d23027af

data/CHANGELOG.md

@@ -1,3 +1,90 @@
+## [0.1.15] - 2021-04-08
+- Fixed the `dangling else`by tweaking the grammar rules
+
+### Changed
+- Method `Ast::ASTBuilder#reduce_if__else_stmt` parse action specific for if with else branch
+
+### Fixed
+- File `grammar.rb` changed rules to cope with `dangling else` issue
+
+### Changed
+- Method `Ast::ASTBuilder#reduce_if_stmt` parse action for if without else branch
+- File `README.md` removed the section about the `dangling else` issue.
+
+
+## [0.1.14] - 2021-04-05
+- `Loxxy` now implements the 'this' keyword
+
+### New
+- Class `Ast::LoxThisExpr` a syntax node that represents an occurrence of the `this` keyword
+- Method `Ast::ASTBuilder#reduce_this_expr` parse action for this keyword
+- Method `Ast::Visitor#visit_this_expr` visit of an `Ast::LoxThisExpr` node
+- Method `BackEnd::Engine#after_this_expr` runtime action for this keyword (i.e. refers to current instance)
+- Method `BackEnd::LoxFunction#bind` implementation of bound method
+
+### Changed
+- Class `BackEnd::Resolver` implementing semantic actions for `this` keyword
+- File `grammar.rb` added name to a syntax rule
+
+## [0.1.13] - 2021-04-05
+- `Loxxy` now implements method calls
+
+### New
+- Class `Ast::LoxGetExpr` a syntax node that represents a read access to an object property
+- Class `Ast::LoxSetExpr` a syntax node that represents a write access to an object property
+- Method `Ast::ASTBuilder#reduce_set_expr` parse action for write access to an object property
+- Method `Ast::ASTBuilder#reduce_get_expr` parse action for read access to an object property
+- Method `Ast::Visitor#visit_set_expr` visit of an `Ast::LoxSetExpr` node
+- Method `Ast::Visitor#visit_get_expr` visit of an `Ast::LoxGetExpr` node
+- Method `BackEnd::Engine#after_set_expr` runtime action for property setting
+- Method `BackEnd::Engine#after_get_expr` runtime action for property getting
+- Method `BackEnd::LoxInstance#set` implementation of write accessor
+- Method `BackEnd::LoxInstance#get` implementation of read accessor
+- Method `BackEnd::Resolver#after_set_expr` resolve action for property setting
+- Method `BackEnd::Resolver#after_get_expr` resolve action for property getting
+
+### Changed
+- Method `Ast::ASTBuilder#reduce_assign_expr` expanded to support write access to an object property
+- Class `LoxClassStmt`: methods are now aggregate under the `body` attribute
+- Class `LoxFunStmt`: has a new attribute `is_method` and inherits from `Ast::LoxNode`
+- Method `BackEnd::Engine#after_class_stmt` methods are aggregated into the classes
+- Method `BackEnd::Engine#after_fun_stmt` extension for method
+- File `grammar.rb` added names to two syntax rules
+
+
+## [0.1.12] - 2021-04-03
+- Intermediate version: `Loxxy` does instance creation (default constructor)
+
+### New
+- Method `BackEnd::LoxClass#call` made class callable (for invoking the constructor)
+- Class `BackEnd::LoxInstance` runtime representation of a Lox instance (object).
+
+### Changed
+- Method `BackEnd::Engine#after_call_expr` Added Lox class as callable thing.
+
+### Fixed
+- Method `Ast::ASTBuilder#reduce_class_body` couldn't handle properly empty classes
+
+## [0.1.11] - 2021-04-03
+- Intermediate version: `Loxxy` does class declarations
+
+### New
+- Class `Ast::LoxClassStmt` a syntax node that represents a class declaration
+- Method `Ast::ASTBuilder#reduce_class_decl` creates a `LoxClassStmt` instance
+- Method `Ast::ASTBuilder#reduce_class_name`
+- Method `Ast::ASTBuilder#reduce_reduce_class_body` collect the methods of the class
+- Method `Ast::ASTBuilder#reduce_method_plus_more` for dealing with methods
+- Method `Ast::ASTBuilder#reduce_method_plus_end`
+- Method `Ast::ASTVisitor#visit_class_stmt` for visiting an `Ast::LoxClassStmt` node
+- Method `Ast::LoxBlockStmt#empty?` returns true if the code block is empty
+- Method `BackEnd::Engine#after_class_stmt`
+- Method `BackEnd::Resolver#after_class_stmt`
+- Method `BackEnd::Resolver#before_class_stmt`
+- Class `BackEnd::LoxClass` runtime representation of a Lox class.
+
+### Changed
+- File `grammar.rb` refactoring of class declaration syntax rules
+
 ## [0.1.10] - 2021-03-31
 - Flag return statements occurring outside functions as an error
 
@@ -8,7 +95,7 @@
 ## [0.1.09] - 2021-03-28
 - Fix and test suite for return statements
 
-### Changed
+### CHANGED
 - `Loxxy` reports an error when a return statement occurs in top-level scope 
 
 ### Fixed
@@ -20,7 +107,7 @@
 ### New
 - Class `BackEnd::Resolver` implements the variable resolution (whenever a variable is in use, locate the declaration of that variable)
 
-### Changed
+### CHANGED
 - Class `Ast::Visitor` changes in some method signatures
 - Class `BackEnd::Engine` new attribute `resolver` that points to a `BackEnd::Resolver` instance
 - Class `BackEnd::Engine` several methods dealing with variables have been adapted to take the resolver into account.
@@ -110,9 +197,9 @@
 - 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::Function` implementation of a function object.
+- Method `BackEnd::NativeFunction#call` 
+- Method `BackEnd::NativeFunction#to_str` 
+- Method `BackEnd::LoxFunction` runtime representation of a Lox function.
 
 ### Changed
 - Method `BackEnd::Engine#after_call_expr`

data/README.md

@@ -177,8 +177,8 @@ Loxxy supports single line C-style comments.
 ### Keywords
 Loxxy implements the following __Lox__ reserved keywords:
 ```lang-none
-and, else, false, for, fun, if,
-nil, or, print, true, var, while
+and, class, else, false, for, fun, if,
+nil, or, print, return, this, true, var, while
 ```
 
 ### Datatypes
@@ -331,30 +331,6 @@ print "else-branch";
 ```
 
 As for other languages, the `else` part is optional.
-##### Warning: nested `if`...`else`
-Call it a bug ... Nested `if` `else` control flow structure aren't yet supported by __Loxxy__.  
-The culprit has a name: [the dangling else](https://en.wikipedia.org/wiki/Dangling_else). 
-
-The problem in a nutshell: in a nested if ... else ... statement like this:
-``` javascript
-'if (true) if (false) print "bad"; else print "good";
-```
-... there is an ambiguity.  
-Indeed, according to the __Lox__ grammar, the `else` could be bound 
-either to the first `if` or to the second one.
-This ambiguity is usually lifted by applying an ad-hoc rule: an `else` is aways bound to the most 
-recent (rightmost) `if`.  
-Being a generic parsing library, `Rley` doesn't apply any of these supplemental rules.  
-As a consequence,it complains about the found ambiguity and stops the parsing...
-Although `Rley` can cope with ambiguities, this requires the use of an advanced data structure
-called `Shared Packed Parse Forest (SPPF)`.
-SPPF are much more complex to handle than the "common" parse trees present in most compiler or interpreter books.
-Therefore, a future version of `Rley` will incorporate the capability to define disambuiguation rules.  
-
-In the meantime, the `Loxxy` will progress on other __Lox__ features like:
-- Block structures...
-- Iteration structures (`for` and `while` loops)
-
 
 ####  Print Statement
 

data/lib/loxxy/ast/all_lox_nodes.rb

@@ -1,14 +1,17 @@
 # frozen_string_literal: true
 
 require_relative 'lox_fun_stmt'
+require_relative 'lox_this_expr'
 require_relative 'lox_variable_expr'
 require_relative 'lox_literal_expr'
 require_relative 'lox_noop_expr'
+require_relative 'lox_get_expr'
 require_relative 'lox_call_expr'
 require_relative 'lox_grouping_expr'
 require_relative 'lox_unary_expr'
 require_relative 'lox_binary_expr'
 require_relative 'lox_logical_expr'
+require_relative 'lox_set_expr'
 require_relative 'lox_assign_expr'
 require_relative 'lox_block_stmt'
 require_relative 'lox_while_stmt'
@@ -17,4 +20,5 @@ require_relative 'lox_print_stmt'
 require_relative 'lox_if_stmt'
 require_relative 'lox_for_stmt'
 require_relative 'lox_var_stmt'
+require_relative 'lox_class_stmt'
 require_relative 'lox_seq_decl'

data/lib/loxxy/ast/ast_builder.rb

@@ -163,6 +163,31 @@ module Loxxy
         [theChildren[0]]
       end
 
+      # rule('classDecl' => 'CLASS classNaming class_body')
+      def reduce_class_decl(_production, _range, _tokens, theChildren)
+        Ast::LoxClassStmt.new(tokens[1].position, theChildren[1], theChildren[2])
+      end
+
+      # rule('classNaming' => 'IDENTIFIER')
+      def reduce_class_name(_production, _range, _tokens, theChildren)
+        theChildren[0].token.lexeme
+      end
+
+      # rule('class_body' => 'LEFT_BRACE methods_opt 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
+      end
+
       # rule('funDecl' => 'FUN function')
       def reduce_fun_decl(_production, _range, _tokens, theChildren)
         theChildren[1]
@@ -208,11 +233,20 @@ module Loxxy
         return_first_child(range, tokens, theChildren)
       end
 
-      # rule('ifStmt' => 'IF ifCondition statement elsePart_opt')
+      # rule('ifStmt' => 'IF ifCondition statement ELSE statement')
+      # rule('unbalancedStmt' => 'IF ifCondition statement ELSE unbalancedStmt')
+      def reduce_if_else_stmt(_production, _range, tokens, theChildren)
+        condition = theChildren[1]
+        then_stmt = theChildren[2]
+        else_stmt = theChildren[4]
+        LoxIfStmt.new(tokens[0].position, condition, then_stmt, else_stmt)
+      end
+
+      # rule('unbalancedStmt' => 'IF ifCondition stmt').as ''
       def reduce_if_stmt(_production, _range, tokens, theChildren)
         condition = theChildren[1]
         then_stmt = theChildren[2]
-        else_stmt = theChildren[3]
+        else_stmt = nil
         LoxIfStmt.new(tokens[0].position, condition, then_stmt, else_stmt)
       end
 
@@ -244,10 +278,22 @@ module Loxxy
 
       # rule('assignment' => 'owner_opt IDENTIFIER EQUAL assignment')
       def reduce_assign_expr(_production, _range, tokens, theChildren)
-        var_name = theChildren[1].token.lexeme.dup
-        Ast::LoxAssignExpr.new(tokens[1].position, var_name, theChildren[3])
+        name_assignee = theChildren[1].token.lexeme.dup
+        if theChildren[0].kind_of?(Ast::LoxSetExpr)
+          theChildren[0].property = name_assignee
+          theChildren[0].subnodes << theChildren[3]
+          theChildren[0]
+        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?
 
@@ -292,6 +338,11 @@ module Loxxy
         LoxCallExpr.new(tokens[0].position, args)
       end
 
+      # rule('refinement' => 'DOT IDENTIFIER').as 'get_expr'
+      def reduce_get_expr(_production, _range, tokens, theChildren)
+        LoxGetExpr.new(tokens[0].position, theChildren[1].token.lexeme)
+      end
+
       # rule('primary' => 'LEFT_PAREN expression RIGHT_PAREN')
       def reduce_grouping_expr(_production, _range, tokens, theChildren)
         subexpr = theChildren[1]
@@ -312,6 +363,11 @@ module Loxxy
         LoxVariableExpr.new(tokens[0].position, var_name)
       end
 
+      # rule('primary' => 'THIS')
+      def reduce_this_expr(_production, _range, tokens, _children)
+        LoxThisExpr.new(tokens[0].position)
+      end
+
       # rule('function' => 'IDENTIFIER LEFT_PAREN params_opt RIGHT_PAREN block').as 'function'
       def reduce_function(_production, _range, _tokens, theChildren)
         first_child = theChildren.first

data/lib/loxxy/ast/ast_visitor.rb

@@ -67,6 +67,14 @@ module Loxxy
         broadcast(:after_var_stmt, aVarStmt)
       end
 
+      # Visit event. The visitor is about to visit a class declaration.
+      # @param aClassStmt [AST::LOXClassStmt] the for statement node to visit
+      def visit_class_stmt(aClassStmt)
+        broadcast(:before_class_stmt, aClassStmt)
+        traverse_subnodes(aClassStmt) # The methods are visited here...
+        broadcast(:after_class_stmt, aClassStmt, self)
+      end
+
       # Visit event. The visitor is about to visit a for statement.
       # @param aForStmt [AST::LOXForStmt] the for statement node to visit
       def visit_for_stmt(aForStmt)
@@ -123,6 +131,13 @@ module Loxxy
         broadcast(:after_assign_expr, anAssignExpr, self)
       end
 
+      # @param aSetExpr [AST::LOXGetExpr] the get expression node to visit
+      def visit_set_expr(aSetExpr)
+        broadcast(:before_set_expr, aSetExpr)
+        traverse_subnodes(aSetExpr)
+        broadcast(:after_set_expr, aSetExpr, self)
+      end
+
       # Visit event. The visitor is about to visit a logical expression.
       # Since logical expressions may take shorcuts by not evaluating all their
       # sub-expressiosns, they are responsible for visiting or not their children.
@@ -161,6 +176,12 @@ module Loxxy
         broadcast(:after_call_expr, aCallExpr, self)
       end
 
+      # @param aGetExpr [AST::LOXGetExpr] the get expression node to visit
+      def visit_get_expr(aGetExpr)
+        broadcast(:before_get_expr, aGetExpr)
+        broadcast(:after_get_expr, aGetExpr, self)
+      end
+
       # Visit event. The visitor is about to visit a grouping expression.
       # @param aGroupingExpr [AST::LoxGroupingExpr] grouping expression to visit
       def visit_grouping_expr(aGroupingExpr)
@@ -184,6 +205,13 @@ module Loxxy
         broadcast(:after_variable_expr, aVariableExpr, self)
       end
 
+      # Visit event. The visitor is about to visit the this keyword.
+      # @param aThisExpr [Ast::LoxThisExpr] this expression
+      def visit_this_expr(aThisExpr)
+        broadcast(:before_this_expr, aThisExpr)
+        broadcast(:after_this_expr, aThisExpr, self)
+      end
+
       # Visit event. The visitor is about to visit the given terminal datatype value.
       # @param aValue [Ast::BuiltinDattype] the built-in datatype value
       def visit_builtin(aValue)
@@ -195,7 +223,6 @@ module Loxxy
       # @param aFunStmt [AST::LoxFunStmt] function declaration to visit
       def visit_fun_stmt(aFunStmt)
         broadcast(:before_fun_stmt, aFunStmt, self)
-        traverse_subnodes(aFunStmt)
         broadcast(:after_fun_stmt, aFunStmt, self)
       end
 

data/lib/loxxy/ast/lox_class_stmt.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'lox_compound_expr'
+
+module Loxxy
+  module Ast
+    class LoxClassStmt < LoxCompoundExpr
+      # @return [String] the class name
+      attr_reader :name
+
+      # @return [Array<Ast::LoxFunStmt>] the methods
+      attr_reader :body
+
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param condExpr [Loxxy::Ast::LoxNode] iteration condition
+      # @param theBody [Array<Loxxy::Ast::LoxNode>]
+      def initialize(aPosition, aName, theMethods)
+        super(aPosition, [])
+        @name = aName.dup
+        @body = theMethods
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [Ast::ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_class_stmt(self)
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/ast/lox_fun_stmt.rb

@@ -1,24 +1,26 @@
 # frozen_string_literal: true
 
-require_relative 'lox_compound_expr'
+require_relative 'lox_node'
 
 module Loxxy
   module Ast
     # rubocop: disable Style/AccessorGrouping
-    class LoxFunStmt < LoxCompoundExpr
+    class LoxFunStmt < LoxNode
       attr_reader :name
       attr_reader :params
       attr_reader :body
+      attr_accessor :is_method
 
       # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
       # @param aName [String]
       # @param arguments [Array<String>]
       # @param body [Ast::LoxBlockStmt]
       def initialize(aPosition, aName, paramList, aBody)
-        super(aPosition, [])
-        @name = aName
+        super(aPosition)
+        @name = aName.dup
         @params = paramList
         @body = aBody
+        @is_method = false
       end
 
       # Part of the 'visitee' role in Visitor design pattern.

data/lib/loxxy/ast/lox_get_expr.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'lox_node'
+
+module Loxxy
+  module Ast
+    class LoxGetExpr < LoxNode
+      # @return [Ast::LoxNode] the object to which the property belongs to
+      attr_accessor :object
+
+      # @return [String] Name of an object property
+      attr_reader :property
+
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param aPropertyName [String] Name of an object property
+      def initialize(aPosition, aPropertyName)
+        super(aPosition)
+        @property = aPropertyName
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_get_expr(self)
+      end
+
+      alias callee= object=
+    end # class
+  end # module
+end # module

data/lib/loxxy/ast/lox_set_expr.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'lox_compound_expr'
+
+module Loxxy
+  module Ast
+    class LoxSetExpr < LoxCompoundExpr
+      # @return [Ast::LoxNode] the object to which the property belongs to
+      attr_reader :object
+
+      # @return [String] Name of an object property
+      attr_accessor :property
+
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param anObject [Ast::LoxNode] The object which the given property is being set
+      def initialize(aPosition, anObject)
+        super(aPosition, [])
+        @object = anObject
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_set_expr(self)
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/ast/lox_this_expr.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'lox_node'
+
+module Loxxy
+  module Ast
+    # A node in a parse tree that represents the occurrence of 'this' keyword.
+    class LoxThisExpr < LoxNode
+      # Duck-typing: behaves like a LoxVarExpr
+      # @return [String] return the this keyword
+      def name
+        'this'
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param _visitor [LoxxyTreeVisitor] the visitor
+      def accept(aVisitor)
+        aVisitor.visit_this_expr(self)
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/back_end/engine.rb

@@ -3,6 +3,7 @@
 # Load all the classes implementing AST nodes
 require_relative '../ast/all_lox_nodes'
 require_relative 'binary_operator'
+require_relative 'lox_class'
 require_relative 'lox_function'
 require_relative 'resolver'
 require_relative 'symbol_table'
@@ -68,6 +69,19 @@ module Loxxy
         # Do nothing, subnodes were already evaluated
       end
 
+      def after_class_stmt(aClassStmt, aVisitor)
+        # Convert LoxFunStmt into LoxFunction
+        meths = aClassStmt.body.map do |func_node|
+          func_node.is_method = true
+          func_node.accept(aVisitor)
+          stack.pop
+        end
+
+        klass = LoxClass.new(aClassStmt.name, meths, self)
+        new_var = Variable.new(aClassStmt.name, klass)
+        symbol_table.insert(new_var)
+      end
+
       def before_var_stmt(aVarStmt)
         new_var = Variable.new(aVarStmt.name, Datatype::Nil.instance)
         symbol_table.insert(new_var)
@@ -146,6 +160,18 @@ module Loxxy
         variable.assign(value)
       end
 
+      def after_set_expr(aSetExpr, aVisitor)
+        value = stack.pop
+        # Evaluate object part
+        aSetExpr.object.accept(aVisitor)
+        assignee = stack.pop
+        unless assignee.kind_of?(LoxInstance)
+          raise StandardError, 'Only instances have fields.'
+        end
+
+        assignee.set(aSetExpr.property, value)
+      end
+
       def after_logical_expr(aLogicalExpr, visitor)
         op = aLogicalExpr.operator
         operand1 = stack.pop # only first operand was evaluated
@@ -221,11 +247,23 @@ module Loxxy
             raise Loxxy::RuntimeError, msg
           end
           callee.call(self, aVisitor)
+        when LoxClass
+          callee.call(self, aVisitor)
         else
           raise Loxxy::RuntimeError, 'Can only call functions and classes.'
         end
       end
 
+      def after_get_expr(aGetExpr, aVisitor)
+        aGetExpr.object.accept(aVisitor)
+        instance = stack.pop
+        unless instance.kind_of?(LoxInstance)
+          raise StandardError, 'Only instances have properties.'
+        end
+
+        stack.push instance.get(aGetExpr.property)
+      end
+
       def after_grouping_expr(_groupingExpr)
         # Do nothing: work was already done by visiting /evaluating the subexpression
       end
@@ -233,7 +271,7 @@ module Loxxy
       def after_variable_expr(aVarExpr, aVisitor)
         var_name = aVarExpr.name
         var = variable_lookup(aVarExpr)
-        raise StandardError, "Unknown variable #{var_name}" unless var
+        raise StandardError, "Undefined variable '#{var_name}'." unless var
 
         var.value.accept(aVisitor) # Evaluate variable value then push on stack
       end
@@ -243,6 +281,11 @@ module Loxxy
         stack.push(literalExpr.literal)
       end
 
+      def after_this_expr(aThisExpr, aVisitor)
+        var = variable_lookup(aThisExpr)
+        var.value.accept(aVisitor) # Evaluate this value then push on stack
+      end
+
       # @param aValue [Ast::BuiltinDattype] the built-in datatype value
       def before_visit_builtin(aValue)
         stack.push(aValue)
@@ -250,8 +293,12 @@ module Loxxy
 
       def after_fun_stmt(aFunStmt, _visitor)
         function = LoxFunction.new(aFunStmt.name, aFunStmt.params, aFunStmt.body, self)
-        new_var = Variable.new(aFunStmt.name, function)
-        symbol_table.insert(new_var)
+        if aFunStmt.is_method
+          stack.push function
+        else
+          new_var = Variable.new(aFunStmt.name, function)
+          symbol_table.insert(new_var)
+        end
       end
 
       private

data/lib/loxxy/back_end/environment.rb

@@ -37,7 +37,6 @@ module Loxxy
       # @return [BackEnd::Variable] the variable
       def insert(anEntry)
         e = validated_entry(anEntry)
-        # e.suffix = default_suffix if e.kind_of?(BackEnd::Variable)
         defns[e.name] = e
 
         e

data/lib/loxxy/back_end/lox_class.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative '../datatype/all_datatypes'
+require_relative 'lox_instance'
+
+module Loxxy
+  module BackEnd
+    # Runtime representation of a Lox class.
+    class LoxClass
+      # @return [String] The name of the class
+      attr_reader :name
+
+      # @return [Hash{String => LoxFunction}] the list of methods
+      attr_reader :meths
+      attr_reader :stack
+
+      # Create a class with given name
+      # @param aName [String] The name of the class
+      def initialize(aName, theMethods, anEngine)
+        @name = aName.dup
+        @meths = {}
+        theMethods.each do |func|
+          meths[func.name] = func
+        end
+        @stack = anEngine.stack
+      end
+
+      def accept(_visitor)
+        stack.push self
+      end
+
+      def arity
+        0
+      end
+
+      def call(engine, _visitor)
+        instance = LoxInstance.new(self, engine)
+        engine.stack.push(instance)
+      end
+
+      # @param aName [String] the method name to search for
+      def find_method(aName)
+        meths[aName]
+      end
+
+      # Logical negation.
+      # As a function is a truthy thing, its negation is thus false.
+      # @return [Datatype::False]
+      def !
+        Datatype::False.instance
+      end
+
+      # Text representation of a Lox class
+      def to_str
+        name
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/back_end/lox_function.rb

@@ -6,7 +6,6 @@ module Loxxy
   module BackEnd
     # rubocop: disable Style/AccessorGrouping
     # Representation of a Lox function.
-    # It is a named slot that can be associated with a value at the time.
     class LoxFunction
       # @return [String] The name of the function (if any)
       attr_reader :name
@@ -18,7 +17,7 @@ module Loxxy
       attr_reader :closure
 
       # Create a function with given name
-      # @param aName [String] The name of the variable
+      # @param aName [String] The name of the function
       def initialize(aName, parameterList, aBody, anEngine)
         @name = aName.dup
         @parameters = parameterList
@@ -37,7 +36,6 @@ module Loxxy
       end
 
       def call(engine, aVisitor)
-        # new_env = Environment.new(engine.symbol_table.current_env)
         new_env = Environment.new(closure)
         engine.symbol_table.enter_environment(new_env)
 
@@ -54,6 +52,16 @@ module Loxxy
         engine.symbol_table.leave_environment
       end
 
+      def bind(anInstance)
+        new_env = Environment.new(closure)
+        this = Variable.new('this', anInstance)
+        new_env.insert(this)
+        bound_method = dup
+        bound_method.instance_variable_set(:@closure, new_env)
+
+        bound_method
+      end
+
       # Logical negation.
       # As a function is a truthy thing, its negation is thus false.
       # @return [Datatype::False]

data/lib/loxxy/back_end/lox_instance.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative '../datatype/all_datatypes'
+
+module Loxxy
+  module BackEnd
+    # Runtime representation of a Lox object (instance).
+    class LoxInstance
+      # @return BackEnd::LoxClass] the class that this object is an instance of
+      attr_reader :klass
+
+      attr_reader :engine
+
+      # @return [Hash{String => BuiltinDatatype | LoxFunction | LoxInstance }]
+      attr_reader :fields
+
+      # Create an instance from given class
+      # @param aClass [BackEnd::LoxClass] the class this this object belong
+      def initialize(aClass, anEngine)
+        @klass = aClass
+        @engine = anEngine
+        @fields = {}
+      end
+
+      def accept(_visitor)
+        engine.stack.push self
+      end
+
+      # Text representation of a Lox instance
+      def to_str
+        "#{klass.to_str} instance"
+      end
+
+      # Look up the value of property with given name
+      # aName [String] name of object property
+      def get(aName)
+        return fields[aName] if fields.include? aName
+
+        method = klass.find_method(aName)
+        unless method
+          raise StandardError, "Undefined property '#{aName}'."
+        end
+
+        method.bind(self)
+      end
+
+      # Set the value of property with given name
+      # aName [String] name of object property
+      def set(aName, aValue)
+        unless fields.include? aName
+          raise StandardError, "Undefined property '#{aName}'."
+        end
+
+        fields[aName] = aValue
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/back_end/resolver.rb

@@ -26,10 +26,15 @@ module Loxxy
       # @return [Symbol] must be one of: :none, :function
       attr_reader :current_function
 
+      # An indicator that tells we're in the middle of a class declaration
+      # @return [Symbol] must be one of: :none, :class
+      attr_reader :current_class
+
       def initialize
         @scopes = []
         @locals = {}
         @current_function = :none
+        @current_class = :none
       end
 
       # Given an abstract syntax parse tree visitor, launch the visit
@@ -53,6 +58,24 @@ module Loxxy
         end_scope
       end
 
+      # A class declaration adds a new variable to current scope
+      def before_class_stmt(aClassStmt)
+        declare(aClassStmt.name)
+      end
+
+      def after_class_stmt(aClassStmt, aVisitor)
+        previous_class = current_class
+        @current_class = :class
+        define(aClassStmt.name)
+        begin_scope
+        define('this')
+        aClassStmt.body.each do |fun_stmt|
+          resolve_function(fun_stmt, :method, aVisitor)
+        end
+        end_scope
+        @current_class = previous_class
+      end
+
       def before_for_stmt(aForStmt)
         before_block_stmt(aForStmt)
       end
@@ -100,6 +123,11 @@ module Loxxy
         resolve_local(anAssignExpr, aVisitor)
       end
 
+      def after_set_expr(aSetExpr, aVisitor)
+        # Evaluate object part
+        aSetExpr.object.accept(aVisitor)
+      end
+
       # Variable expressions require their variables resolved
       def before_variable_expr(aVarExpr)
         var_name = aVarExpr.name
@@ -118,11 +146,28 @@ module Loxxy
         aCallExpr.arguments.reverse_each { |arg| arg.accept(aVisitor) }
       end
 
+      def after_get_expr(aGetExpr, aVisitor)
+        # Evaluate object part
+        aGetExpr.object.accept(aVisitor)
+      end
+
+      def before_this_expr(_thisExpr)
+        if current_class == :none
+          msg = "Error at 'this': Can't use 'this' outside of a class."
+          raise StandardError, msg
+        end
+      end
+
+      def after_this_expr(aThisExpr, aVisitor)
+        # 'this' behaves closely to a local variable
+        resolve_local(aThisExpr, aVisitor)
+      end
+
       # function declaration creates a new scope for its body & binds its parameters for that scope
       def before_fun_stmt(aFunStmt, aVisitor)
         declare(aFunStmt.name)
         define(aFunStmt.name)
-        resolve_function(aFunStmt, :function ,aVisitor)
+        resolve_function(aFunStmt, :function, aVisitor)
       end
 
       private

data/lib/loxxy/front_end/grammar.rb

@@ -35,14 +35,16 @@ module Loxxy
       rule('declaration' => 'classDecl')
       rule('declaration' => 'funDecl')
       rule('declaration' => 'varDecl')
-      rule('declaration' => 'statement')
+      rule('declaration' => 'stmt')
 
-      rule('classDecl' => 'CLASS classNaming class_body')
+      rule('classDecl' => 'CLASS classNaming class_body').as 'class_decl'
       rule('classNaming' => 'IDENTIFIER LESS IDENTIFIER')
-      rule('classNaming' => 'IDENTIFIER')
-      rule('class_body' => 'LEFT_BRACE function_star RIGHT_BRACE')
-      rule('function_star' => 'function_star function')
-      rule('function_star' => [])
+      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('funDecl' => 'FUN function').as 'fun_decl'
 
@@ -50,6 +52,8 @@ module Loxxy
       rule('varDecl' => 'VAR IDENTIFIER EQUAL expression SEMICOLON').as 'var_initialization'
 
       # 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')
@@ -68,10 +72,10 @@ module Loxxy
       rule('forTest' => 'expression_opt SEMICOLON').as 'for_test'
       rule('forUpdate' => 'expression_opt')
 
-      rule('ifStmt' => 'IF ifCondition statement elsePart_opt').as 'if_stmt'
+      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('ifCondition' => 'LEFT_PAREN expression RIGHT_PAREN').as 'keep_symbol2'
-      rule('elsePart_opt' => 'ELSE statement').as 'keep_symbol2'
-      rule('elsePart_opt' => [])
 
       rule('printStmt' => 'PRINT expression SEMICOLON').as 'print_stmt'
       rule('returnStmt' => 'RETURN expression_opt SEMICOLON').as 'return_stmt'
@@ -85,7 +89,7 @@ module Loxxy
       rule('expression' => 'assignment')
       rule('assignment' => 'owner_opt IDENTIFIER EQUAL assignment').as 'assign_expr'
       rule('assignment' => 'logic_or')
-      rule('owner_opt' => 'call DOT')
+      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'
@@ -130,11 +134,11 @@ module Loxxy
       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('refinement' => 'DOT IDENTIFIER')
+      rule('refinement' => 'DOT IDENTIFIER').as 'get_expr'
       rule('primary' => 'TRUE').as 'literal_expr'
       rule('primary' => 'FALSE').as 'literal_expr'
       rule('primary' => 'NIL').as 'literal_expr'
-      rule('primary' => 'THIS')
+      rule('primary' => 'THIS').as 'this_expr'
       rule('primary' => 'NUMBER').as 'literal_expr'
       rule('primary' => 'STRING').as 'literal_expr'
       rule('primary' => 'IDENTIFIER').as 'variable_expr'

data/lib/loxxy/version.rb

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

data/spec/front_end/parser_spec.rb

@@ -305,6 +305,83 @@ LOX_END
           expect(expr.operands[1].operands[1].literal.value).to eq(5)
         end
       end # context
+
+      context 'Object orientation:' do
+        it 'should parse object property get access' do
+          input = 'print someObject.someProperty;'
+          ptree = subject.parse(input)
+          expr = ptree.root.subnodes[0]
+          expect(expr).to be_kind_of(Ast::LoxPrintStmt)
+          get_expr = expr.subnodes[0]
+          expect(get_expr).to be_kind_of(Ast::LoxGetExpr)
+          expect(get_expr.object.name).to eq('someObject')
+          expect(get_expr.property).to eq('someProperty')
+        end
+
+        it 'should parse nested call expressions' do
+          input = 'print egg.scramble(3).with(cheddar);'
+          # From section 12.3.1, one expects something like:
+          # LoxCallExpr
+          # +- arguments = ['cheddar']
+          # +- callee = LoxGetExpr
+          #    +- property = 'with'
+          #    +- object = LoxCallExpr
+          #       +- arguments = [3]
+          #       +- callee = LoxGetExpr
+          #          +- property = 'scramble'
+          #          +- object = variable 'egg'
+          ptree = subject.parse(input)
+          print_stmt = ptree.root.subnodes[0]
+          expect(print_stmt).to be_kind_of(Ast::LoxPrintStmt)
+          outer_call = print_stmt.subnodes[0]
+          expect(outer_call).to be_kind_of(Ast::LoxCallExpr)
+          expect(outer_call.arguments[0].name).to eq('cheddar')
+          expect(outer_call.callee).to be_kind_of(Ast::LoxGetExpr)
+          expect(outer_call.callee.property).to eq('with')
+          inner_call = outer_call.callee.object
+          expect(inner_call).to be_kind_of(Ast::LoxCallExpr)
+          expect(inner_call.arguments[0].literal).to eq(3)
+          expect(inner_call.callee).to be_kind_of(Ast::LoxGetExpr)
+          expect(inner_call.callee.property).to eq('scramble')
+          expect(inner_call.callee.object.name).to eq('egg')
+        end
+
+        it 'should parse object property set access' do
+          input = 'someObject.someProperty = value;'
+          ptree = subject.parse(input)
+          expr = ptree.root.subnodes[0]
+          expect(expr).to be_kind_of(Ast::LoxSetExpr)
+          expect(expr.object.name).to eq('someObject')
+          expect(expr.property).to eq('someProperty')
+          expect(expr.subnodes[0]).to be_kind_of(Ast::LoxVariableExpr)
+          expect(expr.subnodes[0].name).to eq('value')
+        end
+
+        it 'should parse complex set access' do
+          input = 'breakfast.omelette.filling.meat = ham;'
+          # From section 12.3.2, one expects something like:
+          # LoxSetExpr
+          # +- property = 'meat'
+          # +- subnodes[0] = LoxVariableExpr 'ham'
+          # +- object = LoxGetExpr
+          #    +- property = 'filling'
+          #    +- object = LoxGetExpr
+          #       +- property = 'omelette'
+          #       +- object = LoxVariableExpr 'breakfast'
+          ptree = subject.parse(input)
+          expr = ptree.root.subnodes[0]
+          expect(expr).to be_kind_of(Ast::LoxSetExpr)
+          expect(expr.property).to eq('meat')
+          expect(expr.subnodes[0]).to be_kind_of(Ast::LoxVariableExpr)
+          expect(expr.subnodes[0].name).to eq('ham')
+          expect(expr.object).to be_kind_of(Ast::LoxGetExpr)
+          expect(expr.object.property).to eq('filling')
+          expect(expr.object.object).to be_kind_of(Ast::LoxGetExpr)
+          expect(expr.object.object.property).to eq('omelette')
+          expect(expr.object.object.object).to be_kind_of(Ast::LoxVariableExpr)
+          expect(expr.object.object.object.name).to eq('breakfast')
+        end
+      end # context
     end # describe
   end # module
 end # module

data/spec/front_end/raw_parser_spec.rb

@@ -76,8 +76,11 @@ LOX_END
           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('statement')
-          prnt_stmt = stmt.subnodes[0]
+          expect(stmt.symbol.name).to eq('stmt')
+          statement = stmt.subnodes[0]
+          expect(statement).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(statement.symbol.name).to eq('statement')
+          prnt_stmt = statement.subnodes[0]
           expect(prnt_stmt).to be_kind_of(Rley::PTree::NonTerminalNode)
           expect(prnt_stmt.subnodes.size).to eq(3)
           expect(prnt_stmt.subnodes[0]).to be_kind_of(Rley::PTree::TerminalNode)

data/spec/interpreter_spec.rb

@@ -227,19 +227,20 @@ module Loxxy
           # Evaluate the 'then' expression if the condition is true.
           ['if (true) print "then-branch";', 'then-branch'],
           ['if (false) print "ignored";', ''],
-          # TODO: test with then block body
-          # TODO: test with assignment in if condition
+          ['if (nil) print "ignored";', ''],
+          ['if (true) { print "block"; }', 'block'],
+          ['var a = false; if (a = true) print a;', 'true'],
 
           # Evaluate the 'else' expression if the condition is false.
           ['if (true) print "then-branch"; else print "else-branch";', 'then-branch'],
           ['if (false) print "then-branch"; else print "else-branch";', 'else-branch'],
           ['if (0) print "then-branch"; else print "else-branch";', 'then-branch'],
-          ['if (nil) print "then-branch"; else print "else-branch";', 'else-branch']
-          # TODO: test with else block body
+          ['if (nil) print "then-branch"; else print "else-branch";', 'else-branch'],
+          ['if (false) nil; else { print "else-branch"; }', 'else-branch'],
 
-          # TODO: A dangling else binds to the right-most if.
-          # ['if (true) if (false) print "bad"; else print "good";', 'good'],
-          # ['if (false) if (true) print "bad"; else print "worse";', 'bad']
+          # A dangling else binds to the right-most if.
+          ['if (true) if (false) print "bad"; else print "good";', 'good'],
+          ['if (false) if (true) print "bad"; else print "worse";', '']
         ].each do |(source, predicted)|
           io = StringIO.new
           cfg = { ostream: io }
@@ -460,6 +461,71 @@ LOX_END
         expect(sample_cfg[:ostream].string).to eq('Hello, world!')
       end
     end # context
+
+    context 'Object orientation:' do
+      let(:duck_class) do
+        snippet = <<-LOX_END
+          class Duck {
+            noise() {
+              this.quack();
+            }
+
+            quack() {
+              print "quack";
+            }
+          }
+        LOX_END
+
+        snippet
+      end
+
+      it 'should support class declaration' do
+        program = <<-LOX_END
+          #{duck_class}
+
+          print Duck; // Class names can appear in statements
+        LOX_END
+        expect { subject.evaluate(program) }.not_to raise_error
+        expect(sample_cfg[:ostream].string).to eq('Duck')
+      end
+
+      it 'should support default instance creation' do
+        program = <<-LOX_END
+          #{duck_class}
+
+          var daffy = Duck(); // Default constructor
+          print daffy;
+        LOX_END
+        expect { subject.evaluate(program) }.not_to raise_error
+        expect(sample_cfg[:ostream].string).to eq('Duck instance')
+      end
+
+      it 'should support calls to method' do
+        program = <<-LOX_END
+          #{duck_class}
+
+          var daffy = Duck(); // Default constructor
+          daffy.quack();
+        LOX_END
+        expect { subject.evaluate(program) }.not_to raise_error
+        expect(sample_cfg[:ostream].string).to eq('quack')
+      end
+
+      it "should support the 'this' keyword" do
+        program = <<-LOX_END
+          class Egotist {
+            speak() {
+              print this;
+            }
+          }
+
+          var method = Egotist().speak;
+          method(); // Output: Egotist instance
+        LOX_END
+        expect { subject.evaluate(program) }.not_to raise_error
+        expect(sample_cfg[:ostream].string).to eq('Egotist instance')
+      end
+    end # context
   end # describe
   # rubocop: enable Metrics/BlockLength
 end # module

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: loxxy
 version: !ruby/object:Gem::Version
-  version: 0.1.10
+  version: 0.1.15
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-03-31 00:00:00.000000000 Z
+date: 2021-04-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -93,9 +93,11 @@ files:
 - lib/loxxy/ast/lox_binary_expr.rb
 - lib/loxxy/ast/lox_block_stmt.rb
 - lib/loxxy/ast/lox_call_expr.rb
+- lib/loxxy/ast/lox_class_stmt.rb
 - lib/loxxy/ast/lox_compound_expr.rb
 - lib/loxxy/ast/lox_for_stmt.rb
 - lib/loxxy/ast/lox_fun_stmt.rb
+- lib/loxxy/ast/lox_get_expr.rb
 - lib/loxxy/ast/lox_grouping_expr.rb
 - lib/loxxy/ast/lox_if_stmt.rb
 - lib/loxxy/ast/lox_literal_expr.rb
@@ -105,6 +107,8 @@ files:
 - lib/loxxy/ast/lox_print_stmt.rb
 - lib/loxxy/ast/lox_return_stmt.rb
 - lib/loxxy/ast/lox_seq_decl.rb
+- lib/loxxy/ast/lox_set_expr.rb
+- lib/loxxy/ast/lox_this_expr.rb
 - lib/loxxy/ast/lox_unary_expr.rb
 - lib/loxxy/ast/lox_var_stmt.rb
 - lib/loxxy/ast/lox_variable_expr.rb
@@ -113,7 +117,9 @@ files:
 - lib/loxxy/back_end/engine.rb
 - lib/loxxy/back_end/entry.rb
 - lib/loxxy/back_end/environment.rb
+- lib/loxxy/back_end/lox_class.rb
 - lib/loxxy/back_end/lox_function.rb
+- lib/loxxy/back_end/lox_instance.rb
 - lib/loxxy/back_end/resolver.rb
 - lib/loxxy/back_end/symbol_table.rb
 - lib/loxxy/back_end/unary_operator.rb