loxxy 0.1.17 → 0.2.00

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2c7d720e2638407882bfd3f34384748a872086e1b1f7a3849f0e029e8672fc1c
-  data.tar.gz: c3aa7ebe4a625ef1b0a257cc750430b9a0aa404bb39dab900b409b2987e09dea
+  metadata.gz: 6a071e03ebadb94c255a118d3bebd75227a2d36c535495a79ad2525e4fc2bf7c
+  data.tar.gz: 35aa1fc822287f7b86628acac39e5c3ca1c12c478cbb330d302705597ff2f13b
 SHA512:
-  metadata.gz: 1eb8bb6575dd39834c55ce3ad359fbdb9a2129f91d25bc39ea093c5a4ca2aa38300ab28e673b39991678c304aea64ffda473707f9d317980b976c8f98fc3a55f
-  data.tar.gz: d3dd5baae665ab27a60a13b7392e9d57ef32ff72a37892d8f08e314888a1bfcc3db9ceeb071a28c00dda44f4bce7afed6aadf6c33c411a93d561a30fef833edd
+  metadata.gz: 51b1a4622ee11c20582fa9ffa72f499a64b280c0092b82a8f07d922309c800f787409e8c273a5316d09de594d82026af0d979e2ad7f52ee6d3eb02233549ebf5
+  data.tar.gz: 2649d33c23f73351f9ecb3b9b4b9899541398c94fa4effa8ca4f4c766589df575b1f68685a039f595ca1efb83a515d0a3620afa3721a0604e187b321449b9716

data/CHANGELOG.md

@@ -1,8 +1,14 @@
 ## [0.1.17] - 2021-04-11
-- TODO
+- `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
-- TODO
+- 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.

data/lib/loxxy/ast/all_lox_nodes.rb

@@ -1,6 +1,7 @@
 # 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'

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]
@@ -368,6 +382,11 @@ module Loxxy
         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

@@ -212,6 +212,13 @@ module Loxxy
         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/back_end/engine.rb

@@ -70,6 +70,21 @@ 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
@@ -79,7 +94,12 @@ module Loxxy
           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
@@ -280,6 +300,20 @@ module Loxxy
         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/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
@@ -47,7 +53,12 @@ module Loxxy
 
       # @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/resolver.rb

@@ -67,6 +67,16 @@ module Loxxy
         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|
@@ -74,6 +84,7 @@ module Loxxy
           resolve_function(fun_stmt, mth_type, aVisitor)
         end
         end_scope
+        end_scope if aClassStmt.superclass
         @current_class = previous_class
       end
 
@@ -169,6 +180,25 @@ module Loxxy
         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/front_end/grammar.rb

@@ -38,7 +38,7 @@ module Loxxy
       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')
@@ -143,7 +143,7 @@ module Loxxy
       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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Loxxy
-  VERSION = '0.1.17'
+  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/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.
@@ -591,7 +592,34 @@ LOX_END
         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.17
+  version: 0.2.00
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-11 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,7 @@ 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
@@ -178,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