kapusta 0.1.0

data/lib/kapusta/cli.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative '../kapusta'
+require 'optparse'
+
+module Kapusta
+  class CLI
+    Options = Struct.new(:compile, :help, keyword_init: true)
+
+    def self.start(argv = ARGV)
+      args = argv.dup
+      options = parse_options(args)
+
+      if options.help
+        $stdout.puts usage
+        return
+      end
+
+      if options.compile
+        compile_file(args)
+      else
+        run_file(args)
+      end
+    end
+
+    def self.parse_options(args)
+      options = Options.new(compile: false, help: false)
+
+      OptionParser.new do |parser|
+        parser.banner = usage
+        parser.on('-c', '--compile', 'Compile .kap to Ruby') { options.compile = true }
+        parser.on('-h', '--help', 'Show this help') { options.help = true }
+      end.order!(args)
+
+      options
+    end
+
+    def self.compile_file(args)
+      path = args.shift
+      abort usage unless path
+      abort usage unless args.empty?
+
+      $stdout.write(Kapusta.compile(File.read(path), path:))
+    end
+
+    def self.run_file(args)
+      path = args.shift
+      abort usage unless path
+
+      previous_argv = ARGV.dup
+      ARGV.replace(args)
+      Kapusta.dofile(path)
+    ensure
+      ARGV.replace(previous_argv) if previous_argv
+    end
+
+    def self.usage
+      'usage: kapusta [--compile|-c] <file.kap> | kapusta <file.kap> [args...]'
+    end
+  end
+end

data/lib/kapusta/compiler/emitter/bindings.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module Kapusta
+  module Compiler
+    module EmitterModules
+      module Bindings
+        private
+
+        def emit_fn(args, env, current_scope)
+          if args[0].is_a?(Vec)
+            emit_lambda(args[0], args[1..], env, current_scope)
+          else
+            name_sym = args[0]
+            pattern = args[1]
+            body = args[2..]
+            ruby_name = temp(sanitize_local(name_sym.name))
+            fn_env = env.child
+            fn_env.define(name_sym.name, ruby_name)
+            <<~RUBY.chomp
+              (-> do
+                #{ruby_name} = nil
+                #{ruby_name} = #{emit_lambda(pattern, body, fn_env, current_scope)}
+                #{ruby_name}
+              end).call
+            RUBY
+          end
+        end
+
+        def emit_lambda(pattern, body, env, current_scope)
+          args_var = temp('args')
+          body_env = env.child
+          bindings_code, body_env = emit_pattern_bind(pattern, args_var, body_env)
+          body_code, = emit_sequence(body, body_env, current_scope, allow_method_definitions: false)
+          <<~RUBY.chomp
+            ->(*#{args_var}) do
+              #{bindings_code}
+              #{body_code}
+            end
+          RUBY
+        end
+
+        def emit_named_fn_assignment(form, env, current_scope)
+          name_sym = form.items[1]
+          ruby_name = temp(sanitize_local(name_sym.name))
+          env.define(name_sym.name, ruby_name)
+          fn_env = env.child
+          fn_env.define(name_sym.name, ruby_name)
+          lambda_code = emit_lambda(form.items[2], form.items[3..], fn_env, current_scope)
+          ["#{ruby_name} = nil\n#{ruby_name} = #{lambda_code}", env]
+        end
+
+        def emit_method_definition(form, env)
+          name_sym = form.items[1]
+          pattern = form.items[2]
+          body = form.items[3..]
+          method_env = env.child
+          args_var = temp('args')
+          bindings_code, body_env = emit_pattern_bind(pattern, args_var, method_env)
+          body_code, = emit_sequence(body, body_env, :toplevel, allow_method_definitions: false)
+
+          if name_sym.name.start_with?('self.')
+            ruby_name = Kapusta.kebab_to_snake(name_sym.name.delete_prefix('self.')).to_sym.inspect
+            <<~RUBY.chomp
+              define_singleton_method(#{ruby_name}) do |*#{args_var}|
+                #{bindings_code}
+                #{body_code}
+              end
+            RUBY
+          else
+            ruby_name = Kapusta.kebab_to_snake(name_sym.name).to_sym.inspect
+            <<~RUBY.chomp
+              define_method(#{ruby_name}) do |*#{args_var}|
+                #{bindings_code}
+                #{body_code}
+              end
+            RUBY
+          end
+        end
+
+        def emit_let(args, env, current_scope)
+          bindings = args[0]
+          body = args[1..]
+          child_env = env.child
+          binding_codes = []
+          items = bindings.items
+          i = 0
+          while i < items.length
+            pattern = items[i]
+            value_code = emit_expr(items[i + 1], child_env, current_scope)
+            bind_code, child_env = emit_pattern_bind(pattern, value_code, child_env)
+            binding_codes << bind_code
+            i += 2
+          end
+          body_code, = emit_sequence(body, child_env, current_scope, allow_method_definitions: false)
+          <<~RUBY.chomp
+            (-> do
+              #{binding_codes.join("\n")}
+              #{body_code}
+            end).call
+          RUBY
+        end
+
+        def emit_local_form(form, env, current_scope)
+          target = form.items[1]
+          value_code = emit_expr(form.items[2], env, current_scope)
+
+          if target.is_a?(Sym)
+            ruby_name = temp(sanitize_local(target.name))
+            env.define(target.name, ruby_name)
+            ["#{ruby_name} = #{value_code}\nnil", env]
+          else
+            bind_code, env = emit_pattern_bind(target, value_code, env)
+            ["#{bind_code}\nnil", env]
+          end
+        end
+
+        def emit_local_expr(args, env, current_scope)
+          code, = emit_local_form(List.new([Sym.new('local'), *args]), env.child, current_scope)
+          "(-> do\n#{indent(code)}\nend).call"
+        end
+
+        def emit_set_form(form, env, current_scope)
+          target = form.items[1]
+          value_code = emit_expr(form.items[2], env, current_scope)
+
+          if target.is_a?(Sym) && !target.dotted?
+            ruby_name =
+              if env.defined?(target.name)
+                env.lookup(target.name)
+              else
+                fresh = temp(sanitize_local(target.name))
+                env.define(target.name, fresh)
+                fresh
+              end
+            ["#{ruby_name} = #{value_code}", env]
+          else
+            [emit_set_target(target, value_code, env, current_scope), env]
+          end
+        end
+
+        def emit_set_expr(args, env, current_scope)
+          target = args[0]
+          value_code = emit_expr(args[1], env, current_scope)
+          emit_set_target(target, value_code, env, current_scope)
+        end
+
+        def emit_set_target(target, value_code, env, current_scope)
+          case target
+          when Sym
+            if target.dotted?
+              base_code, segments = multisym_base(target.segments, env)
+              runtime_call(:set_method_path, base_code, segments.inspect, value_code)
+            else
+              "#{env.lookup(target.name)} = #{value_code}"
+            end
+          when List
+            head = target.head
+            if head.is_a?(Sym) && head.name == '.'
+              object_code = emit_expr(target.items[1], env, current_scope)
+              keys_code = "[#{target.items[2..].map { |item| emit_expr(item, env, current_scope) }.join(', ')}]"
+              runtime_call(:set_path, object_code, keys_code, value_code)
+            elsif head.is_a?(Sym) && head.name == 'ivar'
+              runtime_call(:set_ivar, 'self', target.items[1].name.inspect, value_code)
+            elsif head.is_a?(Sym) && head.name == 'cvar'
+              runtime_call(:set_cvar, 'self', target.items[1].name.inspect, value_code)
+            elsif head.is_a?(Sym) && head.name == 'gvar'
+              runtime_call(:set_gvar, target.items[1].name.inspect, value_code)
+            else
+              raise Error, "bad set target: #{target.inspect}"
+            end
+          else
+            raise Error, "bad set target: #{target.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kapusta/compiler/emitter/collections.rb

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+
+module Kapusta
+  module Compiler
+    module EmitterModules
+      module Collections
+        private
+
+        def emit_icollect(args, env, current_scope)
+          result_var = temp('result')
+          iter_code = emit_iteration(args[0], env, current_scope) do |iter_env|
+            body = emit_sequence(args[1..], iter_env, current_scope, allow_method_definitions: false).first
+            <<~RUBY.chomp
+              __kap_value = begin
+              #{indent(body)}
+              end
+              #{result_var} << __kap_value unless __kap_value.nil?
+            RUBY
+          end
+          <<~RUBY.chomp
+            (-> do
+              #{result_var} = []
+              #{iter_code}
+              #{result_var}
+            end).call
+          RUBY
+        end
+
+        def emit_collect(args, env, current_scope)
+          result_var = temp('result')
+          iter_code = emit_iteration(args[0], env, current_scope) do |iter_env|
+            body = emit_sequence(args[1..], iter_env, current_scope, allow_method_definitions: false).first
+            <<~RUBY.chomp
+              __kap_pair = begin
+              #{indent(body)}
+              end
+              if __kap_pair.is_a?(Array) && __kap_pair.length == 2 && !__kap_pair[0].nil? && !__kap_pair[1].nil?
+                #{result_var}[__kap_pair[0]] = __kap_pair[1]
+              end
+            RUBY
+          end
+          <<~RUBY.chomp
+            (-> do
+              #{result_var} = {}
+              #{iter_code}
+              #{result_var}
+            end).call
+          RUBY
+        end
+
+        def emit_fcollect(args, env, current_scope)
+          result_var = temp('result')
+          bindings = args[0].items
+          ruby_name = temp(sanitize_local(bindings[0].name))
+          loop_env = env.child
+          loop_env.define(bindings[0].name, ruby_name)
+          start_code = emit_expr(bindings[1], env, current_scope)
+          finish_code = emit_expr(bindings[2], env, current_scope)
+          step_code = '1'
+          until_form = nil
+          i = 3
+          while i < bindings.length
+            if bindings[i].is_a?(Sym) && bindings[i].name == '&until'
+              until_form = bindings[i + 1]
+              i += 2
+            else
+              step_code = emit_expr(bindings[i], env, current_scope)
+              i += 1
+            end
+          end
+          body_code, = emit_sequence(args[1..], loop_env, current_scope, allow_method_definitions: false)
+          until_code = until_form ? "break if #{emit_expr(until_form, loop_env, current_scope)}" : nil
+          finish_var = temp('finish')
+          step_var = temp('step')
+          cmp_var = temp('cmp')
+          <<~RUBY.chomp
+            (-> do
+              #{result_var} = []
+              #{ruby_name} = #{start_code}
+              #{finish_var} = #{finish_code}
+              #{step_var} = #{step_code}
+              #{cmp_var} = #{step_var} >= 0 ? :<= : :>=
+              while #{ruby_name}.public_send(#{cmp_var}, #{finish_var})
+                #{until_code}
+                __kap_value = begin
+                #{indent(body_code)}
+                end
+                #{result_var} << __kap_value unless __kap_value.nil?
+                #{ruby_name} += #{step_var}
+              end
+              #{result_var}
+            end).call
+          RUBY
+        end
+
+        def emit_accumulate(args, env, current_scope)
+          bindings = args[0].items
+          acc_name = bindings[0]
+          acc_var = temp(sanitize_local(acc_name.name))
+          iter_bindings = Vec.new(bindings[2..])
+          loop_env = env.child
+          loop_env.define(acc_name.name, acc_var)
+          iter_code = emit_iteration(iter_bindings, loop_env, current_scope) do |iter_env|
+            iter_env.define(acc_name.name, acc_var)
+            emit_sequence(args[1..], iter_env, current_scope, allow_method_definitions: false).first.then do |body|
+              "#{acc_var} = begin\n#{indent(body)}\nend"
+            end
+          end
+          <<~RUBY.chomp
+            (-> do
+              #{acc_var} = #{emit_expr(bindings[1], env, current_scope)}
+              #{iter_code}
+              #{acc_var}
+            end).call
+          RUBY
+        end
+
+        def emit_faccumulate(args, env, current_scope)
+          bindings = args[0].items
+          acc_name = bindings[0]
+          acc_var = temp(sanitize_local(acc_name.name))
+          loop_name = bindings[2]
+          loop_var = temp(sanitize_local(loop_name.name))
+          loop_env = env.child
+          loop_env.define(acc_name.name, acc_var)
+          loop_env.define(loop_name.name, loop_var)
+          start_code = emit_expr(bindings[3], env, current_scope)
+          finish_code = emit_expr(bindings[4], env, current_scope)
+          step_code = bindings[5] ? emit_expr(bindings[5], env, current_scope) : '1'
+          body_code, = emit_sequence(args[1..], loop_env, current_scope, allow_method_definitions: false)
+          finish_var = temp('finish')
+          step_var = temp('step')
+          cmp_var = temp('cmp')
+          <<~RUBY.chomp
+            (-> do
+              #{acc_var} = #{emit_expr(bindings[1], env, current_scope)}
+              #{loop_var} = #{start_code}
+              #{finish_var} = #{finish_code}
+              #{step_var} = #{step_code}
+              #{cmp_var} = #{step_var} >= 0 ? :<= : :>=
+              while #{loop_var}.public_send(#{cmp_var}, #{finish_var})
+                #{acc_var} = begin
+                #{indent(body_code)}
+                end
+                #{loop_var} += #{step_var}
+              end
+              #{acc_var}
+            end).call
+          RUBY
+        end
+
+        def emit_hashfn(args, env, current_scope)
+          args_var = temp('args')
+          hash_env = env.child
+          hash_env.define('$', "#{args_var}[0]")
+          (1..9).each do |index|
+            hash_env.define("$#{index}", "#{args_var}[#{index - 1}]")
+          end
+          hash_env.define('$...', args_var)
+          body_code = emit_expr(args[0], hash_env, current_scope)
+          <<~RUBY.chomp
+            ->(*#{args_var}) do
+              #{body_code}
+            end
+          RUBY
+        end
+
+        def emit_iteration(bindings_vec, env, current_scope)
+          items = bindings_vec.items
+          iter_expr = items.last
+          binding_pats = items[0...-1]
+
+          if iter_expr.is_a?(List) && iter_expr.head.is_a?(Sym)
+            case iter_expr.head.name
+            when 'ipairs'
+              value_var = temp('value')
+              index_var = temp('index')
+              body_env = env.child
+              bind_code, body_env = emit_iteration_bindings(
+                [[binding_pats[0], index_var], [binding_pats[1], value_var]], body_env
+              )
+              body_code = yield(body_env)
+              return <<~RUBY.chomp
+                #{emit_expr(iter_expr.items[1], env, current_scope)}.each_with_index do |#{value_var}, #{index_var}|
+                  #{bind_code}
+                  #{body_code}
+                end
+              RUBY
+            when 'pairs'
+              key_var = temp('key')
+              value_var = temp('value')
+              body_env = env.child
+              bind_code, body_env = emit_iteration_bindings([[binding_pats[0], key_var], [binding_pats[1], value_var]],
+                                                            body_env)
+              body_code = yield(body_env)
+              return <<~RUBY.chomp
+                #{emit_expr(iter_expr.items[1], env, current_scope)}.each do |#{key_var}, #{value_var}|
+                  #{bind_code}
+                  #{body_code}
+                end
+              RUBY
+            end
+          end
+
+          coll_code = emit_expr(iter_expr, env, current_scope)
+          if binding_pats.length == 1
+            value_var = temp('value')
+            body_env = env.child
+            bind_code, body_env = emit_iteration_bindings([[binding_pats[0], value_var]], body_env)
+            body_code = yield(body_env)
+            <<~RUBY.chomp
+              #{coll_code}.each do |#{value_var}|
+                #{bind_code}
+                #{body_code}
+              end
+            RUBY
+          else
+            parts_var = temp('parts')
+            body_env = env.child
+            pairs = binding_pats.each_with_index.map { |pattern, i| [pattern, "#{parts_var}[#{i}]"] }
+            bind_code, body_env = emit_iteration_bindings(pairs, body_env)
+            body_code = yield(body_env)
+            <<~RUBY.chomp
+              #{coll_code}.each do |*#{parts_var}|
+                #{bind_code}
+                #{body_code}
+              end
+            RUBY
+          end
+        end
+
+        def emit_iteration_bindings(pairs, env)
+          current_env = env
+          codes = pairs.compact.map do |pattern, value_code|
+            next nil unless pattern
+
+            code, current_env = emit_pattern_bind(pattern, value_code, current_env)
+            code
+          end.compact
+          [codes.join("\n"), current_env]
+        end
+      end
+    end
+  end
+end

data/lib/kapusta/compiler/emitter/control_flow.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module Kapusta
+  module Compiler
+    module EmitterModules
+      module ControlFlow
+        private
+
+        def emit_if(args, env, current_scope)
+          build_if(args, env, current_scope)
+        end
+
+        def build_if(args, env, current_scope)
+          return 'nil' if args.empty?
+          return emit_expr(args[0], env, current_scope) if args.length == 1
+
+          cond = emit_expr(args[0], env, current_scope)
+          truthy = emit_expr(args[1], env, current_scope)
+          falsy = build_if(args[2..], env, current_scope)
+          <<~RUBY.chomp
+            if #{cond}
+              #{truthy}
+            else
+              #{indent(falsy)}
+            end
+          RUBY
+        end
+
+        def emit_case(args, env, current_scope)
+          value_var = temp('case_value')
+          body = build_case_clauses(value_var, args[1..], env, current_scope)
+          <<~RUBY.chomp
+            (-> do
+              #{value_var} = #{emit_expr(args[0], env, current_scope)}
+              #{body}
+            end).call
+          RUBY
+        end
+
+        def build_case_clauses(value_var, clauses, env, current_scope)
+          return 'nil' if clauses.empty?
+
+          pattern = clauses[0]
+          body = clauses[1]
+          else_code = build_case_clauses(value_var, clauses[2..], env, current_scope)
+          emit_case_clause(value_var, pattern, body, else_code, env, current_scope)
+        end
+
+        def emit_case_clause(value_var, pattern, body, else_code, env, current_scope)
+          if where_pattern?(pattern)
+            emit_guarded_case_clause(value_var, pattern, body, else_code, env, current_scope)
+          else
+            emit_simple_case_clause(value_var, pattern, body, else_code, env, current_scope)
+          end
+        end
+
+        def emit_simple_case_clause(value_var, pattern, body, else_code, env, current_scope)
+          match_var = temp('match')
+          bindings_var = temp('bindings')
+          arm_env = env.child
+          assign_code, arm_env = emit_bindings_from_match(pattern, bindings_var, arm_env)
+          body_code = emit_expr(body, arm_env, current_scope)
+          <<~RUBY.chomp
+            #{match_var} = #{runtime_call(:match_pattern, emit_pattern(pattern), value_var)}
+            if #{match_var}[0]
+              #{bindings_var} = #{match_var}[1]
+              #{assign_code}
+              #{body_code}
+            else
+              #{indent(else_code)}
+            end
+          RUBY
+        end
+
+        def emit_guarded_case_clause(value_var, pattern, body, else_code, env, current_scope)
+          inner = pattern.items[1]
+          guard = pattern.items[2]
+          match_var = temp('match')
+          bindings_var = temp('bindings')
+          arm_env = env.child
+          assign_code, arm_env = emit_bindings_from_match(inner, bindings_var, arm_env)
+          guard_code = emit_expr(guard, arm_env, current_scope)
+          body_code = emit_expr(body, arm_env, current_scope)
+          <<~RUBY.chomp
+            #{match_var} = #{runtime_call(:match_pattern, emit_pattern(inner), value_var)}
+            if #{match_var}[0]
+              #{bindings_var} = #{match_var}[1]
+              #{assign_code}
+              if #{guard_code}
+                #{body_code}
+              else
+                #{indent(else_code, 2)}
+              end
+            else
+              #{indent(else_code)}
+            end
+          RUBY
+        end
+
+        def emit_while(args, env, current_scope)
+          body_code, = emit_sequence(args[1..], env, current_scope, allow_method_definitions: false)
+          <<~RUBY.chomp
+            (-> do
+              while #{emit_expr(args[0], env, current_scope)}
+                #{indent(body_code)}
+              end
+              nil
+            end).call
+          RUBY
+        end
+
+        def emit_for(args, env, current_scope)
+          bindings = args[0].items
+          name = bindings[0]
+          start_code = emit_expr(bindings[1], env, current_scope)
+          finish_code = emit_expr(bindings[2], env, current_scope)
+          step_code = '1'
+          until_form = nil
+          i = 3
+          while i < bindings.length
+            if bindings[i].is_a?(Sym) && bindings[i].name == '&until'
+              until_form = bindings[i + 1]
+              i += 2
+            else
+              step_code = emit_expr(bindings[i], env, current_scope)
+              i += 1
+            end
+          end
+
+          loop_env = env.child
+          ruby_name = temp(sanitize_local(name.name))
+          loop_env.define(name.name, ruby_name)
+          body_code, = emit_sequence(args[1..], loop_env, current_scope, allow_method_definitions: false)
+          until_code = until_form ? "break if #{emit_expr(until_form, loop_env, current_scope)}" : nil
+          cmp_var = temp('cmp')
+          step_var = temp('step')
+          finish_var = temp('finish')
+          <<~RUBY.chomp
+            (-> do
+              #{ruby_name} = #{start_code}
+              #{finish_var} = #{finish_code}
+              #{step_var} = #{step_code}
+              #{cmp_var} = #{step_var} >= 0 ? :<= : :>=
+              while #{ruby_name}.public_send(#{cmp_var}, #{finish_var})
+                #{until_code}
+                #{indent(body_code)}
+                #{ruby_name} += #{step_var}
+              end
+              nil
+            end).call
+          RUBY
+        end
+
+        def emit_each(args, env, current_scope)
+          iter_code = emit_iteration(args[0], env, current_scope) do |iter_env|
+            emit_sequence(args[1..], iter_env, current_scope, allow_method_definitions: false).first
+          end
+          <<~RUBY.chomp
+            (-> do
+              #{iter_code}
+              nil
+            end).call
+          RUBY
+        end
+      end
+    end
+  end
+end