loxxy 0.1.07 → 0.1.08

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f171f0046ff95784ed21b369751ca65d25e0ff757d1b2dccc534087a4b9c4a8d
-  data.tar.gz: 579badf6a30436962cb18e63dfee1ed361cfd152e9fecf54f2bfd25395db086b
+  metadata.gz: 1724fce16b30fe2328ba31a725e92cc03f43ac7dee60fd54c68642c5a5639471
+  data.tar.gz: 0f045add2ebf55375ee63e94f3a7316984588d0133200f3f4ce45de3ae118157
 SHA512:
-  metadata.gz: 0470f022b121ceaff279f75024e07b78a218c3baa4d44e6f9bf54f4ebddf18341b27f697fe68c727eb2d61add2c55e7c102fbf73bfd29ef4fb3965024247f747
-  data.tar.gz: 320dbb075351069f624103f1d93aadf903ec6a5b7bb685871f53227b496760ac67ae9fa1dae85491efd9b94cfeb90eac8f66e104b4f70eaac9b0da081dfde567
+  metadata.gz: 5e4a67161f2d6f6a89b237bdda4e1d096df1183eeb3a9b8ff4f1506d8b053bae265de73857faf82a225b77fad5d32faddfe07873d74e0e71a2839f113659c61b
+  data.tar.gz: 29d09adcb56231c4f7b7c911c16b978e4ec3e0608f754e8b80b971293b99ea96fcf2bb6cd55dec62a8acac00bde0fb9b93e86cc37ee11024faea8e8eb0a70d3f

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+## [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
 
@@ -12,8 +23,6 @@
 - 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
 

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,11 +13,10 @@ 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:
-- Classes and objects.
+The interpreter currently it can execute all allowed __Lox__ expressions and statements except  
+object-oriented feaures (classes and objects).
 
-These will be implemented soon.
+Our intent is implement to these missing features in Q2 2021.
 
 
 ## What's the fuss about Lox?

data/lib/loxxy/ast/ast_visitor.rb

@@ -120,7 +120,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 +194,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_fun_stmt.rb

@@ -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_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

@@ -4,6 +4,7 @@
 require_relative '../ast/all_lox_nodes'
 require_relative 'binary_operator'
 require_relative 'lox_function'
+require_relative 'resolver'
 require_relative 'symbol_table'
 require_relative 'unary_operator'
 
@@ -11,7 +12,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 +28,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 +50,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 +68,20 @@ module Loxxy
         # Do nothing, subnodes were already evaluated
       end
 
-      def after_var_stmt(aVarStmt)
-        new_var = Variable.new(aVarStmt.name, stack.pop)
+      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,9 +137,9 @@ 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.last # ToS remains since an assignment produces a value
@@ -216,10 +232,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]
@@ -240,6 +256,19 @@ module Loxxy
 
       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/resolver.rb

@@ -0,0 +1,171 @@
+# 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
+
+      def initialize
+        @scopes = []
+        @locals = {}
+      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
+
+      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 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, 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
+
+        # 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, aVisitor)
+        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
+      end
+    end # class
+  end # mmodule
+end # module

data/lib/loxxy/version.rb

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

data/spec/back_end/engine_spec.rb

@@ -34,10 +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)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: loxxy
 version: !ruby/object:Gem::Version
-  version: 0.1.07
+  version: 0.1.08
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-03-14 00:00:00.000000000 Z
+date: 2021-03-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -114,6 +114,7 @@ files:
 - lib/loxxy/back_end/entry.rb
 - lib/loxxy/back_end/environment.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