loxxy 0.1.06 → 0.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 293bf5f6fb0eb5a1daf2723484a2867909c03cc99b20270e562d288d334f0bdc
-  data.tar.gz: 9e26854c6d4334f9869d0cd420ebd4365c0f978666e7ede8310d25e600cf5834
+  metadata.gz: aee9fb6c5101bc39682ab401ffc0434aea9e6c4115f74a4f641d0df2d68a03ad
+  data.tar.gz: ccc11c428ef206db9129fabbb97526df3477e03c5dce0b1b5a2f758425c8f9cb
 SHA512:
-  metadata.gz: 2ac692f16a41b162001fee869d426abf634f1a2bb82bf17eac26d8c35939a8ca63234246a6ff88cc04db3833057b445e2650773652ce102a0dcc4f3aa90182e8
-  data.tar.gz: 2764cb3d1703fdc948180cb2060f93a0ef72148f2877f5b711ecacd17d2ba52a9d3b9f7736eb53130850635cb0d127f2a5161a8361cb4a2268fc6275d15a6b1c
+  metadata.gz: dbb1a28eb85868636b304aa3ec3c2fb71f3f37f5c573740bd7d577ed4e88374ce1fea5446e39429168228e68bedbddfccd554bc6c88ec7996621956e11a42a3c
+  data.tar.gz: 3b4c1d6b0996a351cfd7dae5d8f80683fcbdd1eeecc17c3a7932b0675285700dfecdabecc31f505243ffaf2f1bbc1bd8babb604c154f53dad0019c4ad96b007a

data/CHANGELOG.md

@@ -1,3 +1,64 @@
+## [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` implementation 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
+
+### Changed
+- Class `BackEnd::Resolver` Added attribute `current_function` to know whether the visited parse node is located inside a function
+
+
+## [0.1.09] - 2021-03-28
+- Fix and test suite for return statements
+
+### Changed
+- `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.
+
+## [0.1.08] - 2021-03-27
+- `Loxxy` implements variable resolving and binding as described in Chapter 11 of "Crafting Interpreters" book.
+
+### New
+- Class `BackEnd::Resolver` implements the variable resolution (whenever a variable is in use, locate the declaration of that variable)
+
+### 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.
+
+## [0.1.07] - 2021-03-14
+- `Loxxy` now supports nested functions and closures
+
+### Changed
+- Method `Ast::AstBuilder#reduce_call_expr` now supports nested call expressions (e.g. `getCallback()();` )
+- 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. 
+
+### Fixed
+- Method `Ast::AstBuilder#after_var_stmt` now takes into account the value from the top of stack
+
+
 ## [0.1.06] - 2021-03-06
 - Parameters/arguments checks in function declaration and call
 
@@ -69,9 +130,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` implementation of a function object.
 
 ### Changed
 - Method `BackEnd::Engine#after_call_expr`

data/README.md

@@ -4,7 +4,7 @@
 
 ### What is loxxy?
 A Ruby implementation of the [Lox programming language](https://craftinginterpreters.com/the-lox-language.html ),
-a simple language used in Bob Nystrom's online book [Crafting Interpreters](https://craftinginterpreters.com/ ).
+a simple language defined in Bob Nystrom's online book [Crafting Interpreters](https://craftinginterpreters.com/ ).
 
 ### Purpose of this project:
 - To deliver an open source example of a programming language fully implemented in Ruby  
@@ -13,12 +13,9 @@ a simple language used in Bob Nystrom's online book [Crafting Interpreters](http
   a Lox interpreter written in Lox.
 
 ### Current status
-The project is still in inception and the interpreter is being implemented...  
-Currently it can execute all allowed __Lox__ expressions and statements except:
-- Closures,  
-- Classes and objects.
-
-These will be implemented soon.
+The interpreter currently can execute all allowed __Lox__ expressions and statements except  
+object-oriented feaures (classes and objects).
+The goal is to implement these missing features in Q2 2021.
 
 
 ## What's the fuss about Lox?

data/lib/loxxy/ast/all_lox_nodes.rb

@@ -17,4 +17,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]
+      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]
@@ -260,13 +285,26 @@ module Loxxy
 
       # rule('call' => 'primary refinement_plus').as 'call_expr'
       def reduce_call_expr(_production, _range, _tokens, theChildren)
-        theChildren[1].callee = theChildren[0]
-        theChildren[1]
+        members = theChildren.flatten
+        call_expr = nil
+        loop do
+          (callee, call_expr) = members.shift(2)
+          call_expr.callee = callee
+          members.unshift(call_expr)
+          break if members.size == 1
+        end
+
+        call_expr
+      end
+
+      # rule('refinement_plus' => 'refinement_plus refinement')
+      def reduce_refinement_plus_more(_production, _range, _tokens, theChildren)
+        theChildren[0] << theChildren[1]
       end
 
       # rule('refinement_plus' => 'refinement').
       def reduce_refinement_plus_end(_production, _range, _tokens, theChildren)
-        theChildren[0]
+        theChildren
       end
 
       # rule('refinement' => 'LEFT_PAREN arguments_opt RIGHT_PAREN')

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 aXlassStmt [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)
@@ -120,7 +128,7 @@ module Loxxy
       def visit_assign_expr(anAssignExpr)
         broadcast(:before_assign_expr, anAssignExpr)
         traverse_subnodes(anAssignExpr)
-        broadcast(:after_assign_expr, anAssignExpr)
+        broadcast(:after_assign_expr, anAssignExpr, self)
       end
 
       # Visit event. The visitor is about to visit a logical expression.
@@ -194,7 +202,7 @@ module Loxxy
       # Visit event. The visitor is about to visit a function statement node.
       # @param aFunStmt [AST::LoxFunStmt] function declaration to visit
       def visit_fun_stmt(aFunStmt)
-        broadcast(:before_fun_stmt, aFunStmt)
+        broadcast(:before_fun_stmt, aFunStmt, self)
         traverse_subnodes(aFunStmt)
         broadcast(:after_fun_stmt, aFunStmt, self)
       end

data/lib/loxxy/ast/lox_block_stmt.rb

@@ -20,8 +20,6 @@ module Loxxy
       def accept(visitor)
         visitor.visit_block_stmt(self)
       end
-
-      alias operands subnodes
     end # class
   end # module
 end # module

data/lib/loxxy/ast/lox_class_stmt.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'lox_compound_expr'
+
+module Loxxy
+  module Ast
+    class LoxClassStmt < LoxCompoundExpr
+      attr_reader :name
+
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param condExpr [Loxxy::Ast::LoxNode] iteration condition
+      # @param theBody [Loxxy::Ast::LoxNode]
+      def initialize(aPosition, aName, theMethods)
+        super(aPosition, theMethods)
+        @name = aName.dup
+      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
+
+      alias body subnodes
+    end # class
+  end # module
+end # module

data/lib/loxxy/ast/lox_fun_stmt.rb

@@ -16,7 +16,7 @@ module Loxxy
       # @param body [Ast::LoxBlockStmt]
       def initialize(aPosition, aName, paramList, aBody)
         super(aPosition, [])
-        @name = aName
+        @name = aName.dup
         @params = paramList
         @body = aBody
       end
@@ -26,8 +26,6 @@ module Loxxy
       def accept(visitor)
         visitor.visit_fun_stmt(self)
       end
-
-      alias operands subnodes
     end # class
     # rubocop: enable Style/AccessorGrouping
   end # module

data/lib/loxxy/ast/lox_grouping_expr.rb

@@ -16,8 +16,6 @@ module Loxxy
       def accept(visitor)
         visitor.visit_grouping_expr(self)
       end
-
-      alias operands subnodes
     end # class
   end # module
 end # module

data/lib/loxxy/ast/lox_return_stmt.rb

@@ -8,7 +8,8 @@ module Loxxy
       # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
       # @param anExpression [Ast::LoxNode] expression to return
       def initialize(aPosition, anExpression)
-        super(aPosition, [anExpression])
+        expr = anExpression || Datatype::Nil.instance
+        super(aPosition, [expr])
       end
 
       # Part of the 'visitee' role in Visitor design pattern.

data/lib/loxxy/ast/lox_seq_decl.rb

@@ -10,8 +10,6 @@ module Loxxy
       def accept(visitor)
         visitor.visit_seq_decl(self)
       end
-
-      alias operands subnodes
     end # class
   end # module
 end # module

data/lib/loxxy/ast/lox_var_stmt.rb

@@ -13,8 +13,8 @@ module Loxxy
       # @param aName [String] name of the variable
       # @param aValue [Loxxy::Ast::LoxNode, NilClass] initial value for the variable
       def initialize(aPosition, aName, aValue)
-        initial_value = aValue ? [aValue] : [Datatype::Nil.instance]
-        super(aPosition, initial_value)
+        initial_value = aValue || Datatype::Nil.instance
+        super(aPosition, [initial_value])
         @name = aName
       end
 

data/lib/loxxy/back_end/engine.rb

@@ -3,7 +3,9 @@
 # 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'
 require_relative 'unary_operator'
 
@@ -11,7 +13,6 @@ module Loxxy
   module BackEnd
     # An instance of this class executes the statements as when they
     # occur during the abstract syntax tree walking.
-    # @note WIP: very crude implementation.
     class Engine
       # @return [Hash] A set of configuration options
       attr_reader :config
@@ -28,6 +29,9 @@ module Loxxy
       # @return [Hash { Symbol => BinaryOperator}]
       attr_reader :binary_operators
 
+      # @return [BackEnd::Resolver]
+      attr_reader :resolver
+
       # @param theOptions [Hash]
       def initialize(theOptions)
         @config = theOptions
@@ -47,6 +51,10 @@ module Loxxy
       # @param aVisitor [AST::ASTVisitor]
       # @return [Loxxy::Datatype::BuiltinDatatype]
       def execute(aVisitor)
+        # Do variable resolution pass first
+        @resolver = BackEnd::Resolver.new
+        resolver.analyze(aVisitor)
+
         aVisitor.subscribe(self)
         aVisitor.start
         aVisitor.unsubscribe(self)
@@ -61,11 +69,26 @@ module Loxxy
         # Do nothing, subnodes were already evaluated
       end
 
-      def after_var_stmt(aVarStmt)
-        new_var = Variable.new(aVarStmt.name, aVarStmt.subnodes[0])
+      def after_class_stmt(aClassStmt, _visitor)
+        klass = LoxClass.new(aClassStmt.name, aClassStmt.methods, 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)
       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)
+      end
+
       def before_for_stmt(aForStmt)
         before_block_stmt(aForStmt)
       end
@@ -121,14 +144,13 @@ module Loxxy
         symbol_table.leave_environment
       end
 
-      def after_assign_expr(anAssignExpr)
+      def after_assign_expr(anAssignExpr, _visitor)
         var_name = anAssignExpr.name
-        variable = symbol_table.lookup(var_name)
+        variable = variable_lookup(anAssignExpr)
         raise StandardError, "Unknown variable #{var_name}" unless variable
 
-        value = stack.pop
+        value = stack.last # ToS remains since an assignment produces a value
         variable.assign(value)
-        stack.push value # An expression produces a value
       end
 
       def after_logical_expr(aLogicalExpr, visitor)
@@ -217,10 +239,10 @@ module Loxxy
 
       def after_variable_expr(aVarExpr, aVisitor)
         var_name = aVarExpr.name
-        var = symbol_table.lookup(var_name)
+        var = variable_lookup(aVarExpr)
         raise StandardError, "Unknown variable #{var_name}" unless var
 
-        var.value.accept(aVisitor) # Evaluate the variable value
+        var.value.accept(aVisitor) # Evaluate variable value then push on stack
       end
 
       # @param literalExpr [Ast::LoxLiteralExpr]
@@ -234,13 +256,26 @@ module Loxxy
       end
 
       def after_fun_stmt(aFunStmt, _visitor)
-        function = LoxFunction.new(aFunStmt.name, aFunStmt.params, aFunStmt.body, stack)
+        function = LoxFunction.new(aFunStmt.name, aFunStmt.params, aFunStmt.body, self)
         new_var = Variable.new(aFunStmt.name, function)
         symbol_table.insert(new_var)
       end
 
       private
 
+      def variable_lookup(aVarNode)
+        env = nil
+        offset = resolver.locals[aVarNode]
+        if offset.nil?
+          env = symbol_table.root
+        else
+          env = symbol_table.current_env
+          offset.times { env = env.enclosing }
+        end
+
+        env.defns[aVarNode.name]
+      end
+
       NativeFunction = Struct.new(:callable, :interp) do
         def accept(_visitor)
           interp.stack.push self

data/lib/loxxy/back_end/environment.rb

@@ -9,10 +9,17 @@ module Loxxy
     # of a relation or a relation definition.
     # It contains a map of names to the objects they name (e.g. logical var)
     class Environment
-      # The  enclosing (parent) environment.
+      # The enclosing (parent) environment.
       # @return [Environment, NilClass]
       attr_accessor :enclosing
 
+      # The previous environment in the environment chain.
+      # @return [Environment, NilClass]
+      attr_accessor :predecessor
+
+      # @return [Boolean] true if this environment is part of a closure (contains an embedded function)
+      attr_accessor :embedding
+
       # Mapping from user-defined name to related definition
       #  (say, a variable object)
       # @return [Hash{String => Variable}] Pairs of the kind

data/lib/loxxy/back_end/lox_class.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative '../datatype/all_datatypes'
+
+module Loxxy
+  module BackEnd
+    # Representation of a Lox class.
+    class LoxClass
+      # @return [String] The name of the class
+      attr_reader :name
+
+      # @return [Array<>] the list of methods
+      attr_reader :methods
+      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
+        @methods = theMethods
+        @stack = anEngine.stack
+      end
+
+      def accept(_visitor)
+        stack.push self
+      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 function
+      def to_str
+        name
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/back_end/lox_function.rb

@@ -6,24 +6,25 @@ 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]
+      # @return [String] The name of the function (if any)
       attr_reader :name
 
       # @return [Array<>] the parameters
       attr_reader :parameters
       attr_reader :body
       attr_reader :stack
+      attr_reader :closure
 
-      # Create a variable with given name and initial value
-      # @param aName [String] The name of the variable
-      # @param aValue [Datatype::BuiltinDatatype] the initial assigned value
-      def initialize(aName, parameterList, aBody, aStack)
+      # Create a function with given name
+      # @param aName [String] The name of the function
+      def initialize(aName, parameterList, aBody, anEngine)
         @name = aName.dup
         @parameters = parameterList
         @body = aBody.kind_of?(Ast::LoxNoopExpr) ? aBody : aBody.subnodes[0]
-        @stack = aStack
+        @stack = anEngine.stack
+        @closure = anEngine.symbol_table.current_env
+        anEngine.symbol_table.current_env.embedding = true
       end
 
       def arity
@@ -35,7 +36,8 @@ module Loxxy
       end
 
       def call(engine, aVisitor)
-        new_env = Environment.new(engine.symbol_table.current_env)
+        # new_env = Environment.new(engine.symbol_table.current_env)
+        new_env = Environment.new(closure)
         engine.symbol_table.enter_environment(new_env)
 
         parameters&.each do |param_name|

data/lib/loxxy/back_end/resolver.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+# Load all the classes implementing AST nodes
+require_relative '../ast/all_lox_nodes'
+require_relative 'binary_operator'
+require_relative 'lox_function'
+require_relative 'symbol_table'
+require_relative 'unary_operator'
+
+module Loxxy
+  module BackEnd
+    # A class aimed to perform variable resolution when it visits the parse tree.
+    # Resolving means retrieve the declaration of a variable/function everywhere it
+    # is referenced.
+    class Resolver
+      # A stack of Hashes of the form String => Boolean
+      # @return [Array<Hash{String => Boolean}>]
+      attr_reader :scopes
+
+      # A map from a LoxNode involving a variable and the number of enclosing scopes
+      # where it is declared.
+      # @return [Hash {LoxNode => Integer}]
+      attr_reader :locals
+
+      # An indicator that tells we're in the middle of a function declaration
+      # @return [Symbol] must be one of: :none, :function
+      attr_reader :current_function
+
+      def initialize
+        @scopes = []
+        @locals = {}
+        @current_function = :none
+      end
+
+      # Given an abstract syntax parse tree visitor, launch the visit
+      # and execute the visit events in the output stream.
+      # @param aVisitor [AST::ASTVisitor]
+      # @return [Loxxy::Datatype::BuiltinDatatype]
+      def analyze(aVisitor)
+        begin_scope
+        aVisitor.subscribe(self)
+        aVisitor.start
+        aVisitor.unsubscribe(self)
+        end_scope
+      end
+
+      # block statement introduces a new scope
+      def before_block_stmt(_aBlockStmt)
+        begin_scope
+      end
+
+      def after_block_stmt(_aBlockStmt)
+        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, _visitor)
+        define(aClassStmt.name)
+      end
+
+      def before_for_stmt(aForStmt)
+        before_block_stmt(aForStmt)
+      end
+
+      def after_for_stmt(aForStmt, aVisitor)
+        aForStmt.test_expr.accept(aVisitor)
+        aForStmt.body_stmt.accept(aVisitor)
+        aForStmt.update_expr&.accept(aVisitor)
+        after_block_stmt(aForStmt)
+      end
+
+      def after_if_stmt(anIfStmt, aVisitor)
+        anIfStmt.then_stmt.accept(aVisitor)
+        anIfStmt.else_stmt&.accept(aVisitor)
+      end
+
+      def before_return_stmt(_returnStmt)
+        if scopes.size < 2
+          msg = "Error at 'return': Can't return from top-level code."
+          raise StandardError, msg
+        end
+
+        if current_function == :none
+          msg = "Error at 'return': Can't return from outside a function."
+          raise StandardError, msg
+        end
+      end
+
+      def after_while_stmt(aWhileStmt, aVisitor)
+        aWhileStmt.body.accept(aVisitor)
+        aWhileStmt.condition.accept(aVisitor)
+      end
+
+      # A variable declaration adds a new variable to current scope
+      def before_var_stmt(aVarStmt)
+        declare(aVarStmt.name)
+      end
+
+      def after_var_stmt(aVarStmt)
+        define(aVarStmt.name)
+      end
+
+      # Assignment expressions require their variables resolved
+      def after_assign_expr(anAssignExpr, aVisitor)
+        resolve_local(anAssignExpr, aVisitor)
+      end
+
+      # Variable expressions require their variables resolved
+      def before_variable_expr(aVarExpr)
+        var_name = aVarExpr.name
+        if !scopes.empty? && (scopes.last[var_name] == false)
+          raise StandardError, "Can't read variable #{var_name} in its own initializer"
+        end
+      end
+
+      def after_variable_expr(aVarExpr, aVisitor)
+        resolve_local(aVarExpr, aVisitor)
+      end
+
+      def after_call_expr(aCallExpr, aVisitor)
+        # Evaluate callee part
+        aCallExpr.callee.accept(aVisitor)
+        aCallExpr.arguments.reverse_each { |arg| arg.accept(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)
+      end
+
+      private
+
+      def begin_scope
+        scopes.push({})
+      end
+
+      def end_scope
+        scopes.pop
+      end
+
+      def declare(aVarName)
+        return if scopes.empty?
+
+        curr_scope = scopes.last
+        if curr_scope.include?(aVarName)
+          msg = "Error at '#{aVarName}': Already variable with this name in this scope."
+          raise StandardError, msg
+        end
+
+        # The initializer is not yet processed.
+        # Mark the variable as 'not yet ready' = exists but may not be referenced yet
+        curr_scope[aVarName] = false
+      end
+
+      def define(aVarName)
+        return if scopes.empty?
+
+        curr_scope = scopes.last
+
+        # The initializer (if any) was processed.
+        # Mark the variable as alive (= can be referenced in an expression)
+        curr_scope[aVarName] = true
+      end
+
+      def resolve_local(aVarExpr, _visitor)
+        max_i = i = scopes.size - 1
+        scopes.reverse_each do |scp|
+          if scp.include?(aVarExpr.name)
+            # Keep track of the difference of nesting levels between current scope
+            # and the scope where the variable is declared
+            @locals[aVarExpr] = max_i - i
+            break
+          end
+          i -= 1
+        end
+      end
+
+      def resolve_function(aFunStmt, funVisitState, aVisitor)
+        enclosing_function = current_function
+        @current_function = funVisitState
+        begin_scope
+
+        aFunStmt.params&.each do |param_name|
+          declare(param_name)
+          define(param_name)
+        end
+
+        body = aFunStmt.body
+        unless body.nil? || body.kind_of?(Ast::LoxNoopExpr)
+          body.subnodes.first&.accept(aVisitor)
+        end
+
+        end_scope
+        @current_function = enclosing_function
+      end
+    end # class
+  end # mmodule
+end # module

data/lib/loxxy/back_end/symbol_table.rb

@@ -44,23 +44,33 @@ module Loxxy
       # to be a child of current environment and to be itself the new current environment.
       # @param anEnv [BackEnd::Environment] the Environment that
       def enter_environment(anEnv)
-        anEnv.enclosing = current_env
+        if anEnv.enclosing && (anEnv.enclosing != current_env)
+          anEnv.predecessor = current_env
+        else
+          anEnv.enclosing = current_env
+        end
         @current_env = anEnv
       end
 
       def leave_environment
-        current_env.defns.each_pair do |nm, _item|
-          environments = name2envs[nm]
-          if environments.size == 1
-            name2envs.delete(nm)
-          else
-            environments.pop
-            name2envs[nm] = environments
+        unless current_env.embedding
+          current_env.defns.each_pair do |nm, _item|
+            environments = name2envs[nm]
+            if environments.size == 1
+              name2envs.delete(nm)
+            else
+              environments.pop
+              name2envs[nm] = environments
+            end
           end
         end
         raise StandardError, 'Cannot remove root environment.' if current_env == root
 
-        @current_env = current_env.enclosing
+        if current_env.predecessor
+          @current_env = current_env.predecessor
+        else
+          @current_env = current_env.enclosing
+        end
       end
 
       # Add an entry with given name to current environment.

data/lib/loxxy/front_end/grammar.rb

@@ -37,12 +37,14 @@ module Loxxy
       rule('declaration' => 'varDecl')
       rule('declaration' => 'statement')
 
-      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'
 
@@ -127,7 +129,7 @@ module Loxxy
       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_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')

data/lib/loxxy/version.rb

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

data/spec/back_end/engine_spec.rb

@@ -34,8 +34,18 @@ 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)
+
           expect { subject.after_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)

data/spec/interpreter_spec.rb

@@ -53,15 +53,6 @@ module Loxxy
     end # context
 
     context 'Evaluating Lox code:' do
-      let(:hello_world) do
-        lox = <<-LOX_END
-        var greeting = "Hello"; // Declaring a variable
-        print greeting + ", " + "world!"; // ... Playing with concatenation
-LOX_END
-
-        lox
-      end
-
       it 'should evaluate core data types' do
         result = subject.evaluate('true; // Not false')
         expect(result).to be_kind_of(Loxxy::Datatype::True)
@@ -269,9 +260,9 @@ LOX_END
 
       it 'should accept variable mention' do
         program = <<-LOX_END
-        var foo = "bar";
-        print foo; // => bar
-LOX_END
+          var foo = "bar";
+          print foo; // => bar
+        LOX_END
         expect { subject.evaluate(program) }.not_to raise_error
         expect(sample_cfg[:ostream].string).to eq('bar')
       end
@@ -438,18 +429,52 @@ LOX_END
         expect(result).to eq(3)
       end
 
-      it 'should print the hello world message' do
-        expect { subject.evaluate(hello_world) }.not_to raise_error
-        expect(sample_cfg[:ostream].string).to eq('Hello, world!')
+      # rubocop: disable Style/StringConcatenation
+      it 'should support local functions and closures' do
+        program = <<-LOX_END
+          fun makeCounter() {
+            var i = 0;
+            fun count() {
+              i = i + 1;
+              print i;
+            }
+
+            return count;
+          }
+
+          var counter = makeCounter();
+          counter(); // "1".
+          counter(); // "2".
+        LOX_END
+        expect { subject.evaluate(program) }.not_to raise_error
+        expect(sample_cfg[:ostream].string).to eq('1' + '2')
+      end
+      # rubocop: enable Style/StringConcatenation
+
+      it 'should support class declaration' do
+        program = <<-LOX_END
+          class Duck {
+            noise() {
+              quack();
+            }
+
+            quack() {
+              print "quack";
+            }
+          }
+          print Duck;
+        LOX_END
+        expect { subject.evaluate(program) }.not_to raise_error
+        expect(sample_cfg[:ostream].string).to eq('Duck')
       end
-    end # context
 
-    context 'Test suite:' do
-      it "should complain if one argument isn't a number" do
-        source = '1 + nil;'
-        err = Loxxy::RuntimeError
-        err_msg = 'Operands must be two numbers or two strings.'
-        expect { subject.evaluate(source) }.to raise_error(err, err_msg)
+      it 'should print the hello world message' do
+        program = <<-LOX_END
+          var greeting = "Hello"; // Declaring a variable
+          print greeting + ", " + "world!"; // ... Playing with concatenation
+        LOX_END
+        expect { subject.evaluate(program) }.not_to raise_error
+        expect(sample_cfg[:ostream].string).to eq('Hello, world!')
       end
     end # context
   end # describe

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: loxxy
 version: !ruby/object:Gem::Version
-  version: 0.1.06
+  version: 0.1.11
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-03-06 00:00:00.000000000 Z
+date: 2021-04-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -93,6 +93,7 @@ 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
@@ -113,7 +114,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/resolver.rb
 - lib/loxxy/back_end/symbol_table.rb
 - lib/loxxy/back_end/unary_operator.rb
 - lib/loxxy/back_end/variable.rb