loxxy 0.1.13 → 0.2.00

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 172ec5df8e553332b497968f7b910383cb38314aabbdb84fdb42fba6986841ea
-  data.tar.gz: 3d72fd4f13f507f88e9e735e1ebdd0d63fd603b771f9cfb552b9aa38b5b3ca6a
+  metadata.gz: 6a071e03ebadb94c255a118d3bebd75227a2d36c535495a79ad2525e4fc2bf7c
+  data.tar.gz: 35aa1fc822287f7b86628acac39e5c3ca1c12c478cbb330d302705597ff2f13b
 SHA512:
-  metadata.gz: 61073737ef6c069e6e1177fa79cdac543253e06ea63d2ca1b00517c08a06f46948fe7d51257308935d92579152793b4fe60bc0f5b901a1c931e5eafab9f35ecd
-  data.tar.gz: 57c87936451c3015511740d7d44f01d8f032a06e597bdfd1d133119413c227a61df11847f86a4be3a2b3440cc1f614a43b1144cceef05a58ade56ca1fa3c598b
+  metadata.gz: 51b1a4622ee11c20582fa9ffa72f499a64b280c0092b82a8f07d922309c800f787409e8c273a5316d09de594d82026af0d979e2ad7f52ee6d3eb02233549ebf5
+  data.tar.gz: 2649d33c23f73351f9ecb3b9b4b9899541398c94fa4effa8ca4f4c766589df575b1f68685a039f595ca1efb83a515d0a3620afa3721a0604e187b321449b9716

data/CHANGELOG.md

@@ -1,7 +1,56 @@
+## [0.1.17] - 2021-04-11
+- `Loxxy` now support custom initializer.
+
+### Changed
+- Method `BackEnd::Class#call` updated for custom initializer.
+- Class `BackEnd::LoxFunction` added an attribute `is_initializer`
+- Class `BackEnd::Resolver#before_return_stmt` added a check that return in initializer may not return a value
+
+### Fixed
+- Method `BackEnd::Engine#after_call_expr` now does arity checking also for initalizer.
+- Method `BackEnd::LoxInstance#set` removed the check of field existence that prevented the creation of ... fields
+
+## [0.1.16] - 2021-04-10
+- Fixed an issue in name lookup. All the `this` test suite is passing.
+
+### Changed
+- Method `BackEnd::Engine#after_var_stmt` now it creates the variable and pouts it in the symbol table
+
+### Removed
+- Method `BackEnd::Engine#before_var_stmt` it generated bug when assigning a value to a var, when that var name occurred elsewhere
+
+## [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
+### 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
@@ -11,11 +60,11 @@
 - 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#getr` implementation of read 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
+### 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`

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,6 +1,8 @@
 # frozen_string_literal: true
 
 require_relative 'lox_fun_stmt'
+require_relative 'lox_super_expr'
+require_relative 'lox_this_expr'
 require_relative 'lox_variable_expr'
 require_relative 'lox_literal_expr'
 require_relative 'lox_noop_expr'

data/lib/loxxy/ast/ast_builder.rb

@@ -165,7 +165,14 @@ module Loxxy
 
       # rule('classDecl' => 'CLASS classNaming class_body')
       def reduce_class_decl(_production, _range, _tokens, theChildren)
-        Ast::LoxClassStmt.new(tokens[1].position, theChildren[1], theChildren[2])
+        if theChildren[1].kind_of?(Array)
+          name = theChildren[1].first
+          parent = theChildren[1].last
+        else
+          name = theChildren[1]
+          parent = nil
+        end
+        Ast::LoxClassStmt.new(tokens[1].position, name, parent, theChildren[2])
       end
 
       # rule('classNaming' => 'IDENTIFIER')
@@ -173,6 +180,13 @@ module Loxxy
         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)
+        [theChildren[0].token.lexeme, super_var]
+      end
+
       # rule('class_body' => 'LEFT_BRACE methods_opt RIGHT_BRACE')
       def reduce_class_body(_production, _range, _tokens, theChildren)
         theChildren[1].nil? ? [] : theChildren[1]
@@ -233,11 +247,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
 
@@ -354,6 +377,16 @@ 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('primary' => 'SUPER DOT IDENTIFIER')
+      def reduce_super_expr(_production, _range, _tokens, theChildren)
+        LoxSuperExpr.new(theChildren[0].token.position, theChildren[2].token.lexeme)
+      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

@@ -205,6 +205,20 @@ 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 super keyword.
+      # @param aSuperExpr [Ast::LoxSuperExpr] super expression
+      def visit_super_expr(aSuperExpr)
+        broadcast(:before_super_expr, aSuperExpr)
+        broadcast(:after_super_expr, aSuperExpr, 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)

data/lib/loxxy/ast/lox_class_stmt.rb

@@ -8,15 +8,19 @@ module Loxxy
       # @return [String] the class name
       attr_reader :name
 
+      # @return [Ast::LoxVariableExpr] variable referencing the superclass (if any)
+      attr_reader :superclass
+
       # @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)
+      def initialize(aPosition, aName, aSuperclassName, theMethods)
         super(aPosition, [])
         @name = aName.dup
+        @superclass = aSuperclassName
         @body = theMethods
       end
 

data/lib/loxxy/ast/lox_super_expr.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'lox_node'
+
+module Loxxy
+  module Ast
+    class LoxSuperExpr < LoxNode
+      # @return [Ast::LoxNode] the object to which the property belongs to
+      attr_accessor :object
+
+      # @return [String] Name of a method name
+      attr_reader :property
+
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param aMethodName [String] Name of a method
+      def initialize(aPosition, aMethodName)
+        super(aPosition)
+        @property = aMethodName
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_super_expr(self)
+      end
+
+      # Quack like a LoxVariableExpr
+      # @return [String] the `super` keyword
+      def name
+        'super'
+      end
+      alias callee= object=
+    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

@@ -70,30 +70,46 @@ module Loxxy
       end
 
       def after_class_stmt(aClassStmt, aVisitor)
+        if aClassStmt.superclass
+          aClassStmt.superclass.accept(aVisitor)
+          parent = stack.pop
+          unless parent.kind_of?(LoxClass)
+            raise StandardError, 'Superclass must be a class.'
+          end
+        else
+          parent = nil
+        end
+
+        if parent # Create an environment specific for 'super'
+          super_env = Environment.new(symbol_table.current_env)
+          symbol_table.enter_environment(super_env)
+        end
+
         # Convert LoxFunStmt into LoxFunction
         meths = aClassStmt.body.map do |func_node|
           func_node.is_method = true
           func_node.accept(aVisitor)
-          stack.pop
+          mth = stack.pop
+          mth.is_initializer = true if mth.name == 'init'
+          mth
         end
 
-        klass = LoxClass.new(aClassStmt.name, meths, self)
+        klass = LoxClass.new(aClassStmt.name, parent, meths, self)
+        if parent
+          super_var = Variable.new('super', klass)
+          symbol_table.insert(super_var)
+          symbol_table.leave_environment
+        end
         new_var = Variable.new(aClassStmt.name, klass)
         symbol_table.insert(new_var)
       end
 
-      def before_var_stmt(aVarStmt)
+      def after_var_stmt(aVarStmt)
         new_var = Variable.new(aVarStmt.name, Datatype::Nil.instance)
         symbol_table.insert(new_var)
-      end
-
-      def after_var_stmt(aVarStmt)
-        var_name = aVarStmt.name
-        variable = symbol_table.lookup(var_name)
-        raise StandardError, "Unknown variable #{var_name}" unless variable
 
         value = stack.pop
-        variable.assign(value)
+        new_var.assign(value)
       end
 
       def before_for_stmt(aForStmt)
@@ -240,15 +256,13 @@ module Loxxy
         case callee
         when NativeFunction
           stack.push callee.call # Pass arguments
-        when LoxFunction
+        when LoxFunction, LoxClass
           arg_count = aCallExpr.arguments.size
           if arg_count != callee.arity
             msg = "Expected #{callee.arity} arguments but got #{arg_count}."
             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
@@ -281,6 +295,25 @@ 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
+
+      def after_super_expr(aSuperExpr, aVisitor)
+        offset = resolver.locals[aSuperExpr]
+        env = symbol_table.current_env
+        (offset - 1).times { env = env.enclosing }
+        instance = env.defns['this'].value.accept(aVisitor)[0]
+        superklass = variable_lookup(aSuperExpr).value.superclass
+        method = superklass.find_method(aSuperExpr.property)
+        unless method
+          raise StandardError, "Undefined property '#{aSuperExpr.property}'."
+        end
+
+        stack.push method.bind(instance)
+      end
+
       # @param aValue [Ast::BuiltinDattype] the built-in datatype value
       def before_visit_builtin(aValue)
         stack.push(aValue)

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

@@ -7,17 +7,23 @@ module Loxxy
   module BackEnd
     # Runtime representation of a Lox class.
     class LoxClass
+      # rubocop: disable Style/AccessorGrouping
+
       # @return [String] The name of the class
       attr_reader :name
+      attr_reader :superclass
 
       # @return [Hash{String => LoxFunction}] the list of methods
       attr_reader :meths
       attr_reader :stack
 
+      # rubocop: enable Style/AccessorGrouping
+
       # Create a class with given name
       # @param aName [String] The name of the class
-      def initialize(aName, theMethods, anEngine)
+      def initialize(aName, aSuperclass, theMethods, anEngine)
         @name = aName.dup
+        @superclass = aSuperclass
         @meths = {}
         theMethods.each do |func|
           meths[func.name] = func
@@ -30,17 +36,29 @@ module Loxxy
       end
 
       def arity
-        0
+        initializer = find_method('init')
+        initializer ? initializer.arity : 0
       end
 
-      def call(engine, _visitor)
+      def call(engine, visitor)
         instance = LoxInstance.new(self, engine)
+        initializer = find_method('init')
+        if initializer
+          constructor = initializer.bind(instance)
+          constructor.call(engine, visitor)
+        end
+
         engine.stack.push(instance)
       end
 
       # @param aName [String] the method name to search for
       def find_method(aName)
-        meths[aName]
+        found = meths[aName]
+        unless found || superclass.nil?
+          found = superclass.find_method(aName)
+        end
+
+        found
       end
 
       # Logical negation.

data/lib/loxxy/back_end/lox_function.rb

@@ -15,6 +15,7 @@ module Loxxy
       attr_reader :body
       attr_reader :stack
       attr_reader :closure
+      attr_accessor :is_initializer
 
       # Create a function with given name
       # @param aName [String] The name of the function
@@ -24,6 +25,7 @@ module Loxxy
         @body = aBody.kind_of?(Ast::LoxNoopExpr) ? aBody : aBody.subnodes[0]
         @stack = anEngine.stack
         @closure = anEngine.symbol_table.current_env
+        @is_initializer = false
         anEngine.symbol_table.current_env.embedding = true
       end
 
@@ -48,10 +50,24 @@ module Loxxy
           (body.nil? || body.kind_of?(Ast::LoxNoopExpr)) ? Datatype::Nil.instance : body.accept(aVisitor)
           throw(:return)
         end
+        if is_initializer
+          enclosing_env = engine.symbol_table.current_env.enclosing
+          engine.stack.push(enclosing_env.defns['this'].value)
+        end
 
         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

@@ -9,7 +9,7 @@ module Loxxy
       # @return BackEnd::LoxClass] the class that this object is an instance of
       attr_reader :klass
 
-      attr_reader :stack
+      attr_reader :engine
 
       # @return [Hash{String => BuiltinDatatype | LoxFunction | LoxInstance }]
       attr_reader :fields
@@ -18,12 +18,12 @@ module Loxxy
       # @param aClass [BackEnd::LoxClass] the class this this object belong
       def initialize(aClass, anEngine)
         @klass = aClass
-        @stack = anEngine.stack
+        @engine = anEngine
         @fields = {}
       end
 
       def accept(_visitor)
-        stack.push self
+        engine.stack.push self
       end
 
       # Text representation of a Lox instance
@@ -41,16 +41,12 @@ module Loxxy
           raise StandardError, "Undefined property '#{aName}'."
         end
 
-        method
+        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

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
@@ -59,10 +64,28 @@ module Loxxy
       end
 
       def after_class_stmt(aClassStmt, aVisitor)
+        previous_class = current_class
+        @current_class = :class
         define(aClassStmt.name)
+        if aClassStmt.superclass
+          if aClassStmt.name == aClassStmt.superclass.name
+            raise StandardError, "'A class can't inherit from itself."
+          end
+
+          @current_class = :subclass
+          aClassStmt.superclass.accept(aVisitor)
+          begin_scope
+          define('super')
+        end
+        begin_scope
+        define('this')
         aClassStmt.body.each do |fun_stmt|
-          resolve_function(fun_stmt, :method, aVisitor)
+          mth_type = fun_stmt.name == 'init' ? :initializer : :method
+          resolve_function(fun_stmt, mth_type, aVisitor)
         end
+        end_scope
+        end_scope if aClassStmt.superclass
+        @current_class = previous_class
       end
 
       def before_for_stmt(aForStmt)
@@ -81,7 +104,7 @@ module Loxxy
         anIfStmt.else_stmt&.accept(aVisitor)
       end
 
-      def before_return_stmt(_returnStmt)
+      def before_return_stmt(returnStmt)
         if scopes.size < 2
           msg = "Error at 'return': Can't return from top-level code."
           raise StandardError, msg
@@ -91,6 +114,11 @@ module Loxxy
           msg = "Error at 'return': Can't return from outside a function."
           raise StandardError, msg
         end
+
+        if current_function == :initializer
+          msg = "Error at 'return': Can't return a value from an initializer."
+          raise StandardError, msg unless returnStmt.subnodes[0].kind_of?(Datatype::Nil)
+        end
       end
 
       def after_while_stmt(aWhileStmt, aVisitor)
@@ -140,6 +168,37 @@ module Loxxy
         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
+
+      # rubocop: disable Style/CaseLikeIf
+      # rubocop: disable Style/StringConcatenation
+      def after_super_expr(aSuperExpr, aVisitor)
+        msg_prefix = "Error at 'super': Can't use 'super' "
+        if current_class == :none
+          err_msg = msg_prefix + 'outside of a class.'
+          raise StandardError, err_msg
+
+        elsif current_class == :class
+          err_msg = msg_prefix + 'in a class without superclass.'
+          raise StandardError, err_msg
+
+        end
+        # 'super' behaves closely to a local variable
+        resolve_local(aSuperExpr, aVisitor)
+      end
+      # rubocop: enable Style/StringConcatenation
+      # rubocop: enable Style/CaseLikeIf
+
       # function declaration creates a new scope for its body & binds its parameters for that scope
       def before_fun_stmt(aFunStmt, aVisitor)
         declare(aFunStmt.name)

data/lib/loxxy/back_end/symbol_table.rb

@@ -85,7 +85,7 @@ module Loxxy
           name2envs[name] = [current_env]
         end
 
-        anEntry.name # anEntry.i_name
+        anEntry.name
       end
 
       # Search for the object with the given name
@@ -99,23 +99,6 @@ module Loxxy
         sc.defns[aName]
       end
 
-      # Search for the object with the given i_name
-      # @param anIName [String]
-      # @return [BackEnd::Variable]
-      # def lookup_i_name(anIName)
-        # found = nil
-        # environment = current_env
-
-        # begin
-          # found = environment.defns.values.find { |e| e.i_name == anIName }
-          # break if found
-
-          # environment = environment.parent
-        # end while environment
-
-        # found
-      # end
-
       # Return all variables defined in the current .. root chain.
       # Variables are sorted top-down and left-to-right.
       def all_variables

data/lib/loxxy/front_end/grammar.rb

@@ -35,10 +35,10 @@ module Loxxy
       rule('declaration' => 'classDecl')
       rule('declaration' => 'funDecl')
       rule('declaration' => 'varDecl')
-      rule('declaration' => 'statement')
+      rule('declaration' => 'stmt')
 
       rule('classDecl' => 'CLASS classNaming class_body').as 'class_decl'
-      rule('classNaming' => 'IDENTIFIER LESS IDENTIFIER')
+      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')
@@ -52,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')
@@ -70,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'
@@ -136,12 +138,12 @@ module Loxxy
       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'
       rule('primary' => 'LEFT_PAREN expression RIGHT_PAREN').as 'grouping_expr'
-      rule('primary' => 'SUPER DOT IDENTIFIER')
+      rule('primary' => 'SUPER DOT IDENTIFIER').as 'super_expr'
 
       # Utility rules
       rule('function' => 'IDENTIFIER LEFT_PAREN params_opt RIGHT_PAREN block').as 'function'

data/lib/loxxy/interpreter.rb

@@ -24,6 +24,15 @@ module Loxxy
     # @param lox_input [String] Lox program to evaluate
     # @return [Loxxy::Datatype::BuiltinDatatype]
     def evaluate(lox_input)
+      raw_evaluate(lox_input).first
+    end
+
+    # Evaluate the given Lox program.
+    # Return the pair [result, a BackEnd::Engine instance]
+    #   where result is the value of the last executed expression (if any)
+    # @param lox_input [String] Lox program to evaluate
+    # @return Loxxy::Datatype::BuiltinDatatype, Loxxy::BackEnd::Engine]
+    def raw_evaluate(lox_input)
       # Front-end scans, parses the input and blurps an AST...
       parser = FrontEnd::Parser.new
 
@@ -34,7 +43,9 @@ module Loxxy
       # Back-end launches the tree walking & responds to visit events
       # by executing the code determined by the visited AST node.
       engine = BackEnd::Engine.new(config)
-      engine.execute(visitor)
+      result = engine.execute(visitor)
+
+      [result, engine]
     end
   end # class
 end # module

data/lib/loxxy/version.rb

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

data/loxxy.gemspec

@@ -40,8 +40,8 @@ Gem::Specification.new do |spec|
   spec.version       = Loxxy::VERSION
   spec.authors       = ['Dimitri Geshef']
   spec.email         = ['famished.tiger@yahoo.com']
-  spec.summary       = 'An implementation of the Lox programming language. WIP'
-  spec.description   = 'An implementation of the Lox programming language. WIP'
+  spec.summary       = 'An implementation of the Lox programming language.'
+  spec.description   = 'An implementation of the Lox programming language.'
   spec.homepage      = 'https://github.com/famished-tiger/loxxy'
   spec.license       = 'MIT'
   spec.required_ruby_version = '~> 2.4'

data/spec/back_end/engine_spec.rb

@@ -34,15 +34,7 @@ module Loxxy
         let(:var_decl) { Ast::LoxVarStmt.new(sample_pos, 'greeting', greeting) }
         let(:lit_expr) { Ast::LoxLiteralExpr.new(sample_pos, greeting) }
 
-        it "should react to 'before_var_stmt' event" do
-          expect { subject.before_var_stmt(var_decl) }.not_to raise_error
-          current_env = subject.symbol_table.current_env
-          expect(current_env.defns['greeting']).to be_kind_of(Variable)
-        end
-
         it "should react to 'after_var_stmt' event" do
-          # Precondition: `before_var_stmt` is called...
-          expect { subject.before_var_stmt(var_decl) }.not_to raise_error
           # Precondition: value to assign is on top of stack
           subject.stack.push(greeting)
 

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

@@ -6,6 +6,7 @@ require 'stringio'
 # Load the class under test
 require_relative '../lib/loxxy/interpreter'
 
+# rubocop: disable Metrics/ModuleLength
 module Loxxy
   # This spec contains the bare bones test for the Interpreter class.
   # The execution of Lox code is tested elsewhere.
@@ -227,19 +228,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 }
@@ -466,7 +468,7 @@ LOX_END
         snippet = <<-LOX_END
           class Duck {
             noise() {
-              quack();
+              this.quack();
             }
 
             quack() {
@@ -509,7 +511,115 @@ 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
+
+      it 'should support a closure nested in a method' do
+        lox_snippet = <<-LOX_END
+        class Foo {
+          getClosure() {
+            fun closure() {
+              return this.toString();
+            }
+            return closure;
+          }
+
+          toString() { return "foo"; }
+        }
+
+        var closure = Foo().getClosure();
+        closure;
+        LOX_END
+        # Expected result: Backend::LoxFunction('closure')
+        # Expected function's closure (environment layout):
+        # Environment('global')
+        #   defns
+        #   +- ['clock'] => BackEnd::Engine::NativeFunction
+        #   *- ['Foo'] => BackEnd::LoxClass
+        # Environment
+        #   defns
+        #   ['this'] => BackEnd::LoxInstance
+        # Environment
+        #   defns
+        #   +- ['closure'] => Backend::LoxFunction
+        result = subject.evaluate(lox_snippet)
+        expect(result).to be_kind_of(BackEnd::LoxFunction)
+        expect(result.name).to eq('closure')
+        closure = result.closure
+        expect(closure).to be_kind_of(Loxxy::BackEnd::Environment)
+        expect(closure.defns['closure'].value).to eq(result)
+        expect(closure.enclosing).to be_kind_of(Loxxy::BackEnd::Environment)
+        expect(closure.enclosing.defns['this'].value).to be_kind_of(Loxxy::BackEnd::LoxInstance)
+        global_env = closure.enclosing.enclosing
+        expect(global_env).to be_kind_of(Loxxy::BackEnd::Environment)
+        expect(global_env.defns['clock'].value).to be_kind_of(BackEnd::Engine::NativeFunction)
+        expect(global_env.defns['Foo'].value).to be_kind_of(BackEnd::LoxClass)
+      end
+
+      it 'should support custom initializer' do
+        lox_snippet = <<-LOX_END
+          // From section 3.9.5
+          class Breakfast {
+            init(meat, bread) {
+              this.meat = meat;
+              this.bread = bread;
+            }
+
+            serve(who) {
+              print "Enjoy your " + this.meat + " and " +
+                  this.bread + ", " + who + ".";
+            }
+          }
+
+          var baconAndToast = Breakfast("bacon", "toast");
+          baconAndToast.serve("Dear Reader");
+          // Output: "Enjoy your bacon and toast, Dear Reader."
+        LOX_END
+        expect { subject.evaluate(lox_snippet) }.not_to raise_error
+        predicted = 'Enjoy your bacon and toast, Dear Reader.'
+        expect(sample_cfg[:ostream].string).to eq(predicted)
+      end
+
+      it 'should support class inheritance and super keyword' do
+        lox_snippet = <<-LOX_END
+          class A {
+            method() {
+              print "A method";
+            }
+          }
+
+          class B < A {
+            method() {
+              print "B method";
+            }
+
+            test() {
+              super.method();
+            }
+          }
+
+          class C < B {}
+
+          C().test();
+        LOX_END
+        expect { subject.evaluate(lox_snippet) }.not_to raise_error
+        expect(sample_cfg[:ostream].string).to eq('A method')
+      end
     end # context
   end # describe
   # rubocop: enable Metrics/BlockLength
 end # module
+# rubocop: enable Metrics/ModuleLength

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: loxxy
 version: !ruby/object:Gem::Version
-  version: 0.1.13
+  version: 0.2.00
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-05 00:00:00.000000000 Z
+date: 2021-04-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -66,7 +66,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
-description: An implementation of the Lox programming language. WIP
+description: An implementation of the Lox programming language.
 email:
 - famished.tiger@yahoo.com
 executables:
@@ -108,6 +108,8 @@ files:
 - 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_super_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
@@ -177,7 +179,7 @@ requirements: []
 rubygems_version: 3.1.4
 signing_key:
 specification_version: 4
-summary: An implementation of the Lox programming language. WIP
+summary: An implementation of the Lox programming language.
 test_files:
 - spec/back_end/engine_spec.rb
 - spec/back_end/environment_spec.rb