kapusta 0.1.0

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Kapusta
+  module Compiler
+    module EmitterModules
+      module Expressions
+        private
+
+        def emit_expr(form, env, current_scope)
+          case form
+          when Sym then emit_sym(form, env)
+          when Vec then "[#{form.items.map { |item| emit_expr(item, env, current_scope) }.join(', ')}]"
+          when HashLit
+            "{#{form.pairs.map do |key, value|
+              "#{emit_hash_key(key, env, current_scope)} => #{emit_expr(value, env, current_scope)}"
+            end.join(', ')}}"
+          when List then emit_list(form, env, current_scope)
+          when String, Symbol, Numeric, true, false, nil then form.inspect
+          else
+            raise Error, "cannot emit form: #{form.inspect}"
+          end
+        end
+
+        def emit_hash_key(key, env, current_scope)
+          case key
+          when Sym, Vec, HashLit, List then emit_expr(key, env, current_scope)
+          else key.inspect
+          end
+        end
+
+        def emit_list(list, env, current_scope)
+          return 'nil' if list.empty?
+
+          head = list.head
+          args = list.rest
+          if head.is_a?(Sym)
+            return emit_special(head.name, args, env, current_scope) if special_form?(head.name)
+            return emit_multisym_call(head, args, env, current_scope) if head.dotted?
+            return emit_callable_call(env.lookup(head.name), args, env, current_scope) if env.defined?(head.name)
+
+            return emit_self_call(head.name, args, env, current_scope)
+          end
+
+          emit_callable_call(emit_expr(head, env, current_scope), args, env, current_scope)
+        end
+
+        def emit_special(name, args, env, current_scope)
+          case name
+          when 'fn', 'lambda', 'λ' then emit_fn(args, env, current_scope)
+          when 'let' then emit_let(args, env, current_scope)
+          when 'local', 'var' then emit_local_expr(args, env, current_scope)
+          when 'set' then emit_set_expr(args, env, current_scope)
+          when 'if' then emit_if(args, env, current_scope)
+          when 'case', 'match' then emit_case(args, env, current_scope)
+          when 'while' then emit_while(args, env, current_scope)
+          when 'for' then emit_for(args, env, current_scope)
+          when 'each' then emit_each(args, env, current_scope)
+          when 'do' then "begin\n#{indent(emit_sequence(args, env, current_scope,
+                                                        allow_method_definitions: false).first)}\nend"
+          when 'values' then "[#{args.map { |arg| emit_expr(arg, env, current_scope) }.join(', ')}]"
+          when 'icollect' then emit_icollect(args, env, current_scope)
+          when 'collect' then emit_collect(args, env, current_scope)
+          when 'fcollect' then emit_fcollect(args, env, current_scope)
+          when 'accumulate' then emit_accumulate(args, env, current_scope)
+          when 'faccumulate' then emit_faccumulate(args, env, current_scope)
+          when 'hashfn' then emit_hashfn(args, env, current_scope)
+          when '.' then emit_lookup(args, env, current_scope)
+          when '?.' then emit_safe_lookup(args, env, current_scope)
+          when ':' then emit_colon(args, env, current_scope)
+          when '..' then runtime_call(:concat, args.map do |arg|
+            emit_expr(arg, env, current_scope)
+          end)
+          when 'length' then "(#{emit_expr(args[0], env, current_scope)}).length"
+          when 'require' then emit_require(args[0], env, current_scope)
+          when 'module' then emit_module_expr(args, env)
+          when 'class' then emit_class_expr(args, env)
+          when 'try' then emit_try(args, env, current_scope)
+          when 'raise' then emit_raise(args, env, current_scope)
+          when 'ivar' then runtime_call(:get_ivar, 'self', args[0].name.inspect)
+          when 'cvar' then runtime_call(:get_cvar, 'self', args[0].name.inspect)
+          when 'gvar' then runtime_call(:get_gvar, args[0].name.inspect)
+          when 'ruby' then "Kernel.eval(#{emit_expr(args[0], env, current_scope)})"
+          when 'and' then emit_and(args, env, current_scope)
+          when 'or' then emit_or(args, env, current_scope)
+          when 'not' then "(!#{emit_expr(args[0], env, current_scope)})"
+          when '=' then emit_compare(args, env, current_scope, '==')
+          when 'not=' then "(!#{emit_special('=', args, env, current_scope)})"
+          when '<' then emit_compare(args, env, current_scope, '<')
+          when '<=' then emit_compare(args, env, current_scope, '<=')
+          when '>' then emit_compare(args, env, current_scope, '>')
+          when '>=' then emit_compare(args, env, current_scope, '>=')
+          when '+' then emit_reduce(args, env, current_scope, '0', :+)
+          when '-' then emit_minus(args, env, current_scope)
+          when '*' then emit_reduce(args, env, current_scope, '1', :*)
+          when '/' then emit_div(args, env, current_scope)
+          when '%' then args.map { |arg| parenthesize(emit_expr(arg, env, current_scope)) }.join(' % ')
+          when 'print' then runtime_call(:print_values, *args.map do |arg|
+            emit_expr(arg, env, current_scope)
+          end)
+          else
+            raise Error, "unknown special form: #{name}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,277 @@
+# frozen_string_literal: true
+
+module Kapusta
+  module Compiler
+    module EmitterModules
+      module Interop
+        private
+
+        def emit_lookup(args, env, current_scope)
+          object_code = emit_expr(args[0], env, current_scope)
+          keys = args[1..].map { |arg| emit_expr(arg, env, current_scope) }.join(', ')
+          runtime_call(:get_path, object_code, "[#{keys}]")
+        end
+
+        def emit_safe_lookup(args, env, current_scope)
+          object_code = emit_expr(args[0], env, current_scope)
+          keys = args[1..].map { |arg| emit_expr(arg, env, current_scope) }.join(', ')
+          runtime_call(:qget_path, object_code, "[#{keys}]")
+        end
+
+        def emit_colon(args, env, current_scope)
+          receiver = emit_expr(args[0], env, current_scope)
+          method_name = emit_method_name(args[1], env, current_scope)
+          positional, kwargs, block = split_call_args(args[2..], env, current_scope)
+          runtime_call(:send_call, receiver, method_name, positional, kwargs, block)
+        end
+
+        def emit_require(arg, env, current_scope)
+          path_code =
+            case arg
+            when Sym then arg.name.inspect
+            when Symbol then arg.to_s.inspect
+            when String then arg.inspect
+            else "(#{emit_expr(arg, env, current_scope)}).to_s"
+            end
+          "require #{path_code}"
+        end
+
+        def emit_module_expr(args, env)
+          emit_module_wrapper(args[0], emit_sequence(args[1..], env, :module, allow_method_definitions: true).first)
+        end
+
+        def emit_class_expr(args, env)
+          name_sym, supers, body_forms = split_class_args(args)
+          emit_class_wrapper(name_sym, supers, env,
+                             emit_sequence(body_forms, env, :class, allow_method_definitions: true).first)
+        end
+
+        def emit_module_wrapper(name_sym, body)
+          mod_var = temp('module')
+          <<~RUBY.chomp
+            (-> do
+              #{mod_var} = #{runtime_call(:ensure_module, 'self', name_sym.name.inspect)}
+              #{mod_var}.module_eval do
+                #{indent(body)}
+              end
+              #{mod_var}
+            end).call
+          RUBY
+        end
+
+        def emit_class_wrapper(name_sym, supers, env, body)
+          klass_var = temp('class')
+          super_code =
+            if supers.is_a?(Vec) && !supers.items.empty?
+              emit_expr(supers.items.first, env, :toplevel)
+            else
+              'Object'
+            end
+          <<~RUBY.chomp
+            (-> do
+              #{klass_var} = #{runtime_call(:ensure_class, 'self', name_sym.name.inspect, super_code)}
+              #{klass_var}.class_eval do
+                #{indent(body)}
+              end
+              #{klass_var}
+            end).call
+          RUBY
+        end
+
+        def emit_try(args, env, current_scope)
+          catches = []
+          finally_bodies = []
+          args[1..].each do |clause|
+            head = clause.head
+            if head.is_a?(Sym) && head.name == 'catch'
+              rest = clause.items[1..]
+              if rest[0].is_a?(Sym) && (rest[0].name.match?(/\A[A-Z]/) || rest[0].dotted?)
+                klass_form = rest[0]
+                bind_sym = rest[1]
+                body = rest[2..]
+              else
+                klass_form = nil
+                bind_sym = rest[0]
+                body = rest[1..]
+              end
+              catches << [klass_form, bind_sym, body]
+            elsif head.is_a?(Sym) && head.name == 'finally'
+              finally_bodies << clause.items[1..]
+            end
+          end
+
+          lines = ['begin', indent(emit_expr(args[0], env, current_scope))]
+          catches.each do |klass_form, bind_sym, body|
+            rescue_env = env.child
+            rescue_name = temp(sanitize_local(bind_sym.name))
+            rescue_env.define(bind_sym.name, rescue_name)
+            body_code, = emit_sequence(body, rescue_env, current_scope, allow_method_definitions: false)
+            rescue_line =
+              if klass_form
+                "rescue #{emit_expr(klass_form, env, current_scope)} => #{rescue_name}"
+              else
+                "rescue StandardError => #{rescue_name}"
+              end
+            lines << rescue_line
+            lines << indent(body_code)
+          end
+          unless finally_bodies.empty?
+            ensure_code = finally_bodies.map do |body|
+              emit_sequence(body, env, current_scope, allow_method_definitions: false).first
+            end.join("\n")
+            lines << 'ensure'
+            lines << indent(ensure_code)
+          end
+          lines << 'end'
+          lines.join("\n")
+        end
+
+        def emit_raise(args, env, current_scope)
+          return 'Kernel.raise' if args.empty?
+
+          "Kernel.raise(#{args.map { |arg| emit_expr(arg, env, current_scope) }.join(', ')})"
+        end
+
+        def emit_and(args, env, current_scope)
+          return 'true' if args.empty?
+
+          args.map { |arg| parenthesize(emit_expr(arg, env, current_scope)) }.join(' && ')
+        end
+
+        def emit_or(args, env, current_scope)
+          return 'nil' if args.empty?
+
+          args.map { |arg| parenthesize(emit_expr(arg, env, current_scope)) }.join(' || ')
+        end
+
+        def emit_compare(args, env, current_scope, operator)
+          values = args.map { |arg| emit_expr(arg, env, current_scope) }
+          return 'true' if values.length <= 1
+
+          (0...(values.length - 1)).map do |i|
+            "#{parenthesize(values[i])} #{operator} #{parenthesize(values[i + 1])}"
+          end.join(' && ')
+        end
+
+        def emit_reduce(args, env, current_scope, empty_value, operator)
+          return empty_value if args.empty?
+
+          args.map { |arg| parenthesize(emit_expr(arg, env, current_scope)) }.join(" #{operator} ")
+        end
+
+        def emit_minus(args, env, current_scope)
+          values = args.map { |arg| emit_expr(arg, env, current_scope) }
+          return '0' if values.empty?
+          return "(-#{values[0]})" if values.length == 1
+
+          values.map { |value| parenthesize(value) }.join(' - ')
+        end
+
+        def emit_div(args, env, current_scope)
+          values = args.map { |arg| emit_expr(arg, env, current_scope) }
+          return "(1.0 / #{parenthesize(values[0])})" if values.length == 1
+
+          values.map { |value| parenthesize(value) }.join(' / ')
+        end
+
+        def emit_callable_call(callee_code, args, env, current_scope)
+          positional, kwargs, block = split_call_args(args, env, current_scope)
+          runtime_call(:call, callee_code, "[#{positional.join(', ')}]", kwargs, block)
+        end
+
+        def emit_multisym_call(head, args, env, current_scope)
+          base_code, segments = multisym_base(head.segments, env)
+          if segments.empty?
+            emit_callable_call(base_code, args, env, current_scope)
+          else
+            receiver =
+              if segments.length == 1
+                base_code
+              else
+                runtime_call(:method_path_value, base_code, segments[0...-1].inspect)
+              end
+            method_name = Kapusta.kebab_to_snake(segments.last).to_sym.inspect
+            positional, kwargs, block = split_call_args(args, env, current_scope)
+            runtime_call(:send_call, receiver, method_name, positional, kwargs, block)
+          end
+        end
+
+        def emit_self_call(name, args, env, current_scope)
+          positional, kwargs, block = split_call_args(args, env, current_scope)
+          method_name = Kapusta.kebab_to_snake(name).to_sym.inspect
+          runtime_call(:invoke_self, 'self', method_name, positional, kwargs, block)
+        end
+
+        def split_call_args(args, env, current_scope)
+          block = nil
+          remaining = args
+          if !remaining.empty? && block_form?(remaining.last)
+            block = emit_expr(remaining.last, env, current_scope)
+            remaining = remaining[0...-1]
+          end
+
+          if !remaining.empty? && remaining.last.is_a?(HashLit) && remaining.last.all_sym_keys?
+            kwargs = emit_expr(remaining.last, env, current_scope)
+            positional = remaining[0...-1].map { |arg| emit_expr(arg, env, current_scope) }
+          else
+            kwargs = nil
+            positional = remaining.map { |arg| emit_expr(arg, env, current_scope) }
+          end
+          [positional, kwargs, block]
+        end
+
+        def emit_method_name(form, env, current_scope)
+          if form.is_a?(Symbol)
+            form.inspect
+          elsif form.is_a?(String)
+            form.to_sym.inspect
+          else
+            value = emit_expr(form, env, current_scope)
+            "(#{value}.is_a?(Symbol) ? #{value} : #{value}.to_s.to_sym)"
+          end
+        end
+
+        def emit_sym(sym, env)
+          name = sym.name
+          return 'self' if name == 'self'
+          return 'Float::INFINITY' if name == 'math.huge'
+          return env.lookup(name) if env.defined?(name)
+          return emit_multisym_value(sym, env) if sym.dotted?
+          return 'ARGV' if name == 'ARGV'
+          return name if name.match?(/\A[A-Z]/)
+
+          raise Error, "undefined symbol: #{name}"
+        end
+
+        def emit_multisym_value(sym, env)
+          base_code, segments = multisym_base(sym.segments, env)
+          return base_code if segments.empty?
+
+          runtime_call(:method_path_value, base_code, segments.inspect)
+        end
+
+        def multisym_base(segments, env)
+          if segments[0] == 'self'
+            ['self', segments[1..]]
+          elsif env.defined?(segments[0])
+            [env.lookup(segments[0]), segments[1..]]
+          else
+            idx = 0
+            const_path = []
+            while idx < segments.length && segments[idx].match?(/\A[A-Z]/)
+              const_path << segments[idx]
+              idx += 1
+            end
+            raise Error, "bad multisym: #{segments.join('.')}" if const_path.empty?
+
+            [const_path.join('::'), segments[idx..]]
+          end
+        end
+
+        def parenthesize(code)
+          "(#{code})"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Kapusta
+  module Compiler
+    module EmitterModules
+      module Patterns
+        private
+
+        def emit_pattern_bind(pattern, value_code, env)
+          if pattern.is_a?(Sym)
+            return ['nil', env] if pattern.name == '_'
+
+            ruby_name = temp(sanitize_local(pattern.name))
+            env.define(pattern.name, ruby_name)
+            ["#{ruby_name} = #{value_code}", env]
+          else
+            bindings_var = temp('bindings')
+            current_env = env
+            lines = [
+              "#{bindings_var} = #{runtime_call(:destructure, emit_pattern(pattern), value_code)}"
+            ]
+            pattern_names(pattern).each do |name|
+              ruby_name = temp(sanitize_local(name))
+              current_env.define(name, ruby_name)
+              lines << "#{ruby_name} = #{bindings_var}.fetch(#{name.inspect})"
+            end
+            [lines.join("\n"), current_env]
+          end
+        end
+
+        def emit_bindings_from_match(pattern, bindings_var, env)
+          current_env = env
+          lines = []
+          pattern_names(pattern).each do |name|
+            ruby_name = temp(sanitize_local(name))
+            current_env.define(name, ruby_name)
+            lines << "#{ruby_name} = #{bindings_var}.fetch(#{name.inspect})"
+          end
+          [lines.join("\n"), current_env]
+        end
+
+        def emit_pattern(pattern)
+          case pattern
+          when Sym
+            pattern.name == '_' ? '[:sym, "_"]' : "[:sym, #{pattern.name.inspect}]"
+          when Vec
+            parts = []
+            items = pattern.items
+            i = 0
+            while i < items.length
+              if items[i].is_a?(Sym) && items[i].name == '&'
+                parts << "[:rest, #{emit_pattern(items[i + 1])}]"
+                i += 2
+              else
+                parts << emit_pattern(items[i])
+                i += 1
+              end
+            end
+            "[:vec, [#{parts.join(', ')}]]"
+          when HashLit
+            pairs = pattern.pairs.map { |key, value| "[#{key.inspect}, #{emit_pattern(value)}]" }
+            "[:hash, [#{pairs.join(', ')}]]"
+          when nil
+            '[:nil]'
+          when Symbol, String, Numeric, true, false
+            "[:lit, #{pattern.inspect}]"
+          else
+            raise Error, "bad pattern: #{pattern.inspect}"
+          end
+        end
+
+        def pattern_names(pattern)
+          case pattern
+          when Sym
+            pattern.name == '_' ? [] : [pattern.name]
+          when Vec
+            names = []
+            items = pattern.items
+            i = 0
+            while i < items.length
+              if items[i].is_a?(Sym) && items[i].name == '&'
+                names.concat(pattern_names(items[i + 1]))
+                i += 2
+              else
+                names.concat(pattern_names(items[i]))
+                i += 1
+              end
+            end
+            names
+          when HashLit
+            pattern.pairs.flat_map { |_key, value| pattern_names(value) }
+          when List
+            where_pattern?(pattern) ? pattern_names(pattern.items[1]) : []
+          else
+            []
+          end
+        end
+
+        def where_pattern?(pattern)
+          pattern.is_a?(List) && pattern.head.is_a?(Sym) && pattern.head.name == 'where'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Kapusta
+  module Compiler
+    module EmitterModules
+      module Support
+        private
+
+        def emit_forms_with_headers(forms, env, current_scope)
+          i = 0
+          codes = []
+          while i < forms.length
+            form = forms[i]
+            if bodyless_header?(form)
+              codes << emit_bodyless_header(form, forms[(i + 1)..], env, current_scope)
+              break
+            else
+              code, env = emit_form_in_sequence(form, env, current_scope, allow_method_definitions: true)
+              codes << code
+              i += 1
+            end
+          end
+          codes.join("\n")
+        end
+
+        def bodyless_header?(form)
+          return false unless form.is_a?(List) && !form.empty? && form.head.is_a?(Sym)
+
+          case form.head.name
+          when 'module'
+            body = form.items[2..] || []
+            return true if body.empty?
+
+            body.length == 1 && bodyless_header?(body[0])
+          when 'class'
+            _, _, body = split_class_args(form.items[1..])
+            body.empty?
+          else
+            false
+          end
+        end
+
+        def emit_bodyless_header(form, remaining_forms, env, _current_scope)
+          head = form.head.name
+          name_sym = form.items[1]
+
+          if head == 'module'
+            inner = form.items[2..] || []
+            body =
+              if inner.length == 1 && bodyless_header?(inner[0])
+                emit_bodyless_header(inner[0], remaining_forms, env, :module)
+              else
+                emit_forms_with_headers(remaining_forms, env, :module)
+              end
+            emit_module_wrapper(name_sym, body)
+          else
+            name_sym, supers, = split_class_args(form.items[1..])
+            body = emit_forms_with_headers(remaining_forms, env, :class)
+            emit_class_wrapper(name_sym, supers, env, body)
+          end
+        end
+
+        def emit_form_in_sequence(form, env, current_scope, allow_method_definitions:)
+          if allow_method_definitions && method_definition_form?(form) && %i[module class].include?(current_scope)
+            [emit_method_definition(form, env), env]
+          elsif named_function_form?(form)
+            emit_named_fn_assignment(form, env, current_scope)
+          elsif local_form?(form)
+            emit_local_form(form, env, current_scope)
+          elsif do_form?(form)
+            emit_do_form(form.rest, env, current_scope)
+          elsif set_new_local_form?(form, env)
+            emit_set_form(form, env, current_scope)
+          else
+            [emit_expr(form, env, current_scope), env]
+          end
+        end
+
+        def emit_do_form(forms, env, current_scope)
+          body, new_env = emit_sequence(forms, env, current_scope, allow_method_definitions: false)
+          ["begin\n#{indent(body)}\nend", new_env]
+        end
+
+        def emit_sequence(forms, env, current_scope, allow_method_definitions:)
+          current_env = env
+          codes = []
+          forms.each do |form|
+            code, current_env = emit_form_in_sequence(form, current_env, current_scope,
+                                                      allow_method_definitions:)
+            codes << code
+          end
+          [codes.join("\n"), current_env]
+        end
+
+        def special_form?(name)
+          Compiler::SPECIAL_FORMS.include?(name)
+        end
+
+        def split_class_args(args)
+          name_sym = args[0]
+          if args[1].is_a?(Vec)
+            [name_sym, args[1], args[2..] || []]
+          else
+            [name_sym, nil, args[1..] || []]
+          end
+        end
+
+        def named_function_form?(form)
+          form.is_a?(List) && !form.empty? && form.head.is_a?(Sym) &&
+            %w[fn lambda λ].include?(form.head.name) && form.items[1].is_a?(Sym)
+        end
+
+        def method_definition_form?(form)
+          named_function_form?(form)
+        end
+
+        def block_form?(form)
+          form.is_a?(List) && form.head.is_a?(Sym) && %w[fn lambda λ hashfn].include?(form.head.name)
+        end
+
+        def local_form?(form)
+          form.is_a?(List) && form.head.is_a?(Sym) && %w[local var].include?(form.head.name)
+        end
+
+        def do_form?(form)
+          form.is_a?(List) && form.head.is_a?(Sym) && form.head.name == 'do'
+        end
+
+        def set_new_local_form?(form, env)
+          return false unless form.is_a?(List) && form.head.is_a?(Sym) && form.head.name == 'set'
+
+          target = form.items[1]
+          target.is_a?(Sym) && !target.dotted? && !env.defined?(target.name)
+        end
+
+        def indent(text, level = 1)
+          prefix = '  ' * level
+          text.lines.map { |line| line.strip.empty? ? line : "#{prefix}#{line}" }.join
+        end
+
+        def temp(prefix)
+          @temp_index += 1
+          "__kap_#{prefix}_#{@temp_index}"
+        end
+
+        def runtime_helper(name)
+          helper = name.to_sym
+          @runtime_helpers << helper unless @runtime_helpers.include?(helper)
+          Runtime.helper_name(helper)
+        end
+
+        def runtime_call(name, *args)
+          rendered_args = args.map do |arg|
+            arg.is_a?(Array) ? "[#{arg.join(', ')}]" : arg || 'nil'
+          end
+          "#{runtime_helper(name)}(#{rendered_args.join(', ')})"
+        end
+
+        def sanitize_local(name)
+          base = Kapusta.kebab_to_snake(name)
+          base = base.gsub('?', '_q').gsub('!', '_bang')
+          base = base.gsub(/[^a-zA-Z0-9_]/, '_')
+          base = "_#{base}" if base.empty? || base.match?(/\A\d/) || self.class::RUBY_KEYWORDS.include?(base)
+          base
+        end
+      end
+    end
+  end
+end