kapusta 0.2.4 → 0.4.1

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

@@ -45,13 +45,13 @@ module Kapusta
               emit_sequence_value_assignment(acc_var, body)
             end
           end
-          <<~RUBY.chomp
-            (-> do
-              #{acc_var} = #{emit_expr(bindings[1], env, current_scope)}
-              #{iter_code}
-              #{acc_var}
-            end).call
-          RUBY
+          [
+            '(-> do',
+            indent("#{acc_var} = #{emit_expr(bindings[1], env, current_scope)}"),
+            indent(iter_code),
+            indent(acc_var),
+            'end).call'
+          ].join("\n")
         end
 
         def emit_faccumulate(args, env, current_scope)
@@ -73,29 +73,43 @@ module Kapusta
             current_scope:,
             body_code: accumulating_body
           )
-          <<~RUBY.chomp
-            (-> do
-              #{acc_var} = #{emit_expr(bindings[1], env, current_scope)}
-              #{indent(loop_code)}
-              #{acc_var}
-            end).call
-          RUBY
+          [
+            '(-> do',
+            indent("#{acc_var} = #{emit_expr(bindings[1], env, current_scope)}"),
+            indent(loop_code),
+            indent(acc_var),
+            'end).call'
+          ].join("\n")
         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}]")
+          if needs_explicit_args?(args[0])
+            args_var = temp('args')
+            hash_env = env.child
+            hash_env.define('$', "#{args_var}[0]")
+            (1..9).each { |i| hash_env.define("$#{i}", "#{args_var}[#{i - 1}]") }
+            hash_env.define('$...', args_var)
+            body_code = emit_expr(args[0], hash_env, current_scope)
+            ["->(*#{args_var}) do", indent(body_code), 'end'].join("\n")
+          else
+            hash_env = env.child
+            hash_env.define('$', '_1')
+            (1..9).each { |i| hash_env.define("$#{i}", "_#{i}") }
+            body_code = emit_expr(args[0], hash_env, current_scope)
+            ['proc do', indent(body_code), 'end'].join("\n")
           end
-          hash_env.define('$...', args_var)
-          body_code = emit_expr(args[0], hash_env, current_scope)
-          <<~RUBY.chomp
-            ->(*#{args_var}) do
-              #{body_code}
+        end
+
+        def needs_explicit_args?(form)
+          case form
+          when Sym then form.name == '$...'
+          when List, Vec then form.items.any? { |item| needs_explicit_args?(item) }
+          when HashLit
+            form.entries.any? do |entry|
+              entry.is_a?(Array) ? entry.any? { |item| needs_explicit_args?(item) } : needs_explicit_args?(entry)
             end
-          RUBY
+          else false
+          end
         end
 
         def emit_iteration(bindings_vec, env, current_scope)
@@ -108,11 +122,16 @@ module Kapusta
             when 'ipairs'
               body_env = env.child
               value_var, value_bind = bind_iteration_param(binding_pats[1], 'value', body_env)
+              coll_code = emit_expr(iter_expr.items[1], env, current_scope)
+              if ignored_pattern?(binding_pats[0])
+                bind_code = value_bind || ''
+                body_code = yield(body_env)
+                return iteration_block("#{coll_code}.each do |#{value_var}|", bind_code, body_code)
+              end
               index_var, index_bind = bind_iteration_param(binding_pats[0], 'index', body_env)
               bind_code = [index_bind, value_bind].compact.join("\n")
               body_code = yield(body_env)
-              header = "#{emit_expr(iter_expr.items[1], env, current_scope)}" \
-                       ".each_with_index do |#{value_var}, #{index_var}|"
+              header = "#{coll_code}.each_with_index do |#{value_var}, #{index_var}|"
               return iteration_block(header, bind_code, body_code)
             when 'pairs'
               body_env = env.child
@@ -141,6 +160,10 @@ module Kapusta
           end
         end
 
+        def ignored_pattern?(pattern)
+          pattern.is_a?(Sym) && !pattern.dotted? && pattern.name == '_'
+        end
+
         def bind_iteration_param(pattern, fallback_name, env)
           if pattern.is_a?(Sym) && !pattern.dotted?
             ruby_name = pattern.name == '_' ? '_' : define_local(env, pattern.name)
@@ -168,35 +191,36 @@ module Kapusta
         end
 
         def emit_collection_result(result_var, initial_code, iter_code)
-          <<~RUBY.chomp
-            (-> do
-              #{result_var} = #{initial_code}
-              #{indent(iter_code)}
-              #{result_var}
-            end).call
-          RUBY
+          [
+            '(-> do',
+            indent("#{result_var} = #{initial_code}"),
+            indent(iter_code),
+            indent(result_var),
+            'end).call'
+          ].join("\n")
         end
 
         def emit_array_collection_step(result_var, body_code)
           value_var = temp('value')
-          <<~RUBY.chomp
-            #{emit_sequence_value_assignment(value_var, body_code)}
-            #{result_var} << #{value_var} unless #{value_var}.nil?
-          RUBY
+          [
+            emit_sequence_value_assignment(value_var, body_code),
+            "#{result_var} << #{value_var} unless #{value_var}.nil?"
+          ].join("\n")
         end
 
         def emit_hash_collection_step(result_var, body_code)
           pair_var = temp('pair')
-          <<~RUBY.chomp
-            #{emit_sequence_value_assignment(pair_var, body_code)}
-            if #{pair_var}.is_a?(Array) && #{pair_var}.length == 2 && !#{pair_var}[0].nil? && !#{pair_var}[1].nil?
-              #{result_var}[#{pair_var}[0]] = #{pair_var}[1]
-            end
-          RUBY
+          [
+            emit_sequence_value_assignment(pair_var, body_code),
+            "if #{pair_var}.is_a?(Array) && #{pair_var}.length == 2 && " \
+            "!#{pair_var}[0].nil? && !#{pair_var}[1].nil?",
+            indent("#{result_var}[#{pair_var}[0]] = #{pair_var}[1]"),
+            'end'
+          ].join("\n")
         end
 
         def emit_sequence_value_assignment(target_var, body_code)
-          return "#{target_var} = #{body_code}" unless body_code.include?("\n")
+          return emit_assignment(target_var, body_code) unless body_code.include?("\n")
 
           ["#{target_var} = begin", indent(body_code), 'end'].join("\n")
         end

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

@@ -16,6 +16,8 @@ module Kapusta
 
           cond = emit_expr(args[0], env, current_scope)
           truthy = emit_if_branch(args[1], env, current_scope)
+          return "#{truthy} if #{cond}" if args.length == 2 && !truthy.include?("\n") && !cond.include?("\n")
+
           lines = ["if #{cond}", indent(truthy)]
           append_else_lines(lines, args[2..], env, current_scope)
           lines << 'end'
@@ -57,81 +59,52 @@ module Kapusta
 
         def emit_case(args, env, current_scope, mode)
           value_var = temp('case_value')
-          body = build_case_clauses(value_var, args[1..], env, current_scope, mode)
-          <<~RUBY.chomp
-            (-> do
-              #{value_var} = #{emit_expr(args[0], env, current_scope)}
-              #{body}
-            end).call
-          RUBY
+          body = try_emit_native_case(value_var, args[1..], env, current_scope, mode)
+          emit_error!('case/match clauses use patterns this compiler cannot translate') unless body
+          [
+            '(-> do',
+            indent("#{value_var} = #{emit_expr(args[0], env, current_scope)}"),
+            indent(body),
+            'end).call'
+          ].join("\n")
         end
 
-        def build_case_clauses(value_var, clauses, env, current_scope, mode)
-          return 'nil' if clauses.empty?
-
-          pattern = clauses[0]
-          body = clauses[1]
-          else_code = build_case_clauses(value_var, clauses[2..], env, current_scope, mode)
-          emit_case_clause(value_var, pattern, body, else_code, env, current_scope, mode)
-        end
+        def try_emit_native_case(value_var, clauses, env, current_scope, mode)
+          arms = []
+          i = 0
+          while i < clauses.length
+            pattern = clauses[i]
+            body = clauses[i + 1]
+            inner, where_guards = if where_pattern?(pattern)
+                                    [pattern.items[1], pattern.items[2..]]
+                                  else
+                                    [pattern, []]
+                                  end
+            sub_patterns = or_pattern?(inner) ? inner.items[1..] : [inner]
+            sub_arms = sub_patterns.map do |sub|
+              try_native_arm(sub, body, where_guards, env, current_scope, mode)
+            end
+            return if sub_arms.any?(&:nil?)
 
-        def emit_case_clause(value_var, pattern, body, else_code, env, current_scope, mode)
-          if where_pattern?(pattern)
-            emit_guarded_case_clause(value_var, pattern, body, else_code, env, current_scope, mode)
-          else
-            emit_simple_case_clause(value_var, pattern, body, else_code, env, current_scope, mode)
+            arms.concat(sub_arms)
+            i += 2
           end
+          arms << ['else', indent('nil')].join("\n")
+          ["case #{value_var}", *arms, 'end'].join("\n")
         end
 
-        def emit_simple_case_clause(value_var, pattern, body, else_code, env, current_scope, mode)
-          match_var = temp('match')
-          bindings_var = temp('bindings')
-          plan = pattern_match_plan(pattern, env, mode:, allow_pins: false)
-          arm_env = env.child
-          assign_code, arm_env = emit_bindings_from_match(plan[:bindings], bindings_var, arm_env)
-          body_code = emit_expr(body, arm_env, current_scope)
-          arm_body = [assign_code, body_code].reject(&:empty?).join("\n")
-          <<~RUBY.chomp
-            #{match_var} = #{runtime_call(:match_pattern, plan[:pattern], value_var)}
-            if #{match_var}[0]
-              #{bindings_var} = #{match_var}[1]
-              #{arm_body}
-            else
-              #{indent(else_code)}
-            end
-          RUBY
-        end
+        def try_native_arm(pattern, body, where_guards, env, current_scope, mode)
+          allow_pins = !where_guards.empty? && mode == :case
+          plan = native_pattern_plan(pattern, env, mode:, allow_pins:)
+          return unless plan
 
-        def emit_guarded_case_clause(value_var, pattern, body, else_code, env, current_scope, mode)
-          inner = pattern.items[1]
-          guards = pattern.items[2..]
-          match_var = temp('match')
-          bindings_var = temp('bindings')
-          plan = pattern_match_plan(inner, env, mode:, allow_pins: mode == :case)
           arm_env = env.child
-          assign_code, arm_env = emit_bindings_from_match(plan[:bindings], bindings_var, arm_env)
-          guard_code = emit_case_guards(guards, arm_env, current_scope)
+          plan[:bindings].each { |name| arm_env.define(name, sanitize_local(name)) }
+          guard_codes = plan[:guards] +
+                        where_guards.map { |g| emit_expr(g, arm_env, current_scope) }
+          guard_clause = guard_codes.empty? ? '' : " if #{guard_codes.join(' && ')}"
           body_code = emit_expr(body, arm_env, current_scope)
-          bindings_line = assign_code.empty? ? '' : "\n  #{assign_code}"
-          <<~RUBY.chomp
-            #{match_var} = #{runtime_call(:match_pattern, plan[:pattern], value_var)}
-            if #{match_var}[0]
-              #{bindings_var} = #{match_var}[1]#{bindings_line}
-              if #{guard_code}
-                #{body_code}
-              else
-                #{indent(else_code, 2)}
-              end
-            else
-              #{indent(else_code)}
-            end
-          RUBY
-        end
-
-        def emit_case_guards(guards, env, current_scope)
-          return 'true' if guards.empty?
-
-          guards.map { |guard| parenthesize(emit_expr(guard, env, current_scope)) }.join(' && ')
+          ["in #{plan[:pattern]}#{guard_clause}", indent(body_code)].join("\n")
         end
 
         def emit_while(args, env, current_scope)

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

@@ -96,11 +96,45 @@ module Kapusta
           when '/' then emit_div(args, env, current_scope)
           when '%' then args.map { |arg| parenthesize(emit_expr(arg, env, current_scope)) }.join(' % ')
           when 'print' then emit_print(args, env, current_scope)
+          when 'quasi-sym' then "Kapusta::Sym.new(#{emit_expr(args[0], env, current_scope)})"
+          when 'quasi-list' then "Kapusta::List.new([#{args.map { |a| emit_expr(a, env, current_scope) }.join(', ')}])"
+          when 'quasi-list-tail' then emit_quasi_list_tail(args, env, current_scope)
+          when 'quasi-vec' then "Kapusta::Vec.new([#{args.map { |a| emit_expr(a, env, current_scope) }.join(', ')}])"
+          when 'quasi-vec-tail' then emit_quasi_vec_tail(args, env, current_scope)
+          when 'quasi-hash' then emit_quasi_hash(args, env, current_scope)
+          when 'quasi-gensym' then emit_quasi_gensym(args[0], env, current_scope)
+          when 'macro', 'macros', 'import-macros'
+            emit_error!("#{name} must appear at the top level and is consumed by the macro expander")
           else
             emit_error!("unknown special form: #{name}")
           end
         end
 
+        def emit_quasi_list_tail(args, env, current_scope)
+          head_items = args[0]
+          tail_expr = emit_expr(args[1], env, current_scope)
+          head_code = head_items.items.map { |item| emit_expr(item, env, current_scope) }.join(', ')
+          "Kapusta::List.new([#{head_code}, *#{parenthesize(tail_expr)}])"
+        end
+
+        def emit_quasi_vec_tail(args, env, current_scope)
+          head_items = args[0]
+          tail_expr = emit_expr(args[1], env, current_scope)
+          head_code = head_items.items.map { |item| emit_expr(item, env, current_scope) }.join(', ')
+          "Kapusta::Vec.new([#{head_code}, *#{parenthesize(tail_expr)}])"
+        end
+
+        def emit_quasi_gensym(arg, env, current_scope)
+          "Kapusta::Compiler::MacroExpander.fresh_gensym(#{emit_expr(arg, env, current_scope)})"
+        end
+
+        def emit_quasi_hash(args, env, current_scope)
+          pairs = args.each_slice(2).map do |key, value|
+            "[#{emit_expr(key, env, current_scope)}, #{emit_expr(value, env, current_scope)}]"
+          end
+          "Kapusta::HashLit.new([#{pairs.join(', ')}])"
+        end
+
         def emit_concat(args, env, current_scope)
           return '""' if args.empty?
 

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

@@ -17,8 +17,9 @@ module Kapusta
 
         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}]")
+          keys = args[1..].map { |arg| emit_expr(arg, env, current_scope) }
+          receiver = simple_expression?(object_code) ? object_code : parenthesize(object_code)
+          keys.reduce(receiver) { |acc, key| "#{acc}&.[](#{key})" }
         end
 
         BINARY_OPERATOR_METHODS = %w[<=> ** << >> & | ^ === =~].freeze
@@ -53,35 +54,27 @@ module Kapusta
         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
-          if kapusta_require?(arg)
-            return [
-              'unless defined?(Kapusta)',
-              indent('require "kapusta"'),
-              'end',
-              "Kapusta.require(#{path_code}, relative_to: #{@path.inspect})"
-            ].join("\n")
+          literal = require_path_literal(arg)
+          if literal&.match?(%r{\A\.\.?/})
+            cleaned = literal.delete_suffix('.kap').sub(%r{\A\./}, '')
+            return "require_relative #{cleaned.inspect}"
           end
 
+          path_code =
+            if literal
+              literal.inspect
+            else
+              "(#{emit_expr(arg, env, current_scope)}).to_s"
+            end
           "require #{path_code}"
         end
 
-        def kapusta_require?(arg)
-          path =
-            case arg
-            when Sym then arg.name
-            when Symbol then arg.to_s
-            when String then arg
-            end
-          return false unless path
-
-          path.end_with?('.kap') || path.start_with?('./', '../') || File.absolute_path?(path)
+        def require_path_literal(arg)
+          case arg
+          when Sym then arg.name
+          when Symbol then arg.to_s
+          when String then arg
+          end
         end
 
         def emit_module_expr(args, env)
@@ -97,65 +90,65 @@ module Kapusta
         end
 
         def emit_module_wrapper(name_sym, body)
-          mod_var = temp('module')
-          [
-            '(-> do',
-            indent("#{mod_var} = #{runtime_call(:ensure_module, 'self', name_sym.name.inspect)}"),
-            indent("#{mod_var}.module_eval do"),
-            indent(body, 2),
-            indent('end'),
-            indent(mod_var),
-            'end).call'
-          ].join("\n")
+          segments = constant_segments(name_sym)
+          emit_error!("invalid module name: #{name_sym.name}") unless segments
+          inner = build_nested_module(segments, body)
+          ['(-> do', indent(inner), indent(segments.join('::')), 'end).call'].join("\n")
         end
 
         def emit_direct_module_header(name_sym, body)
-          const_name = simple_constant_name(name_sym)
-          return unless const_name
+          segments = constant_segments(name_sym)
+          return unless segments
 
-          [
-            "module #{const_name}",
-            indent(body),
-            'end',
-            const_name
-          ].join("\n")
+          [build_nested_module(segments, body), segments.join('::')].join("\n")
         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
-          [
-            '(-> do',
-            indent("#{klass_var} = #{runtime_call(:ensure_class, 'self', name_sym.name.inspect, super_code)}"),
-            indent("#{klass_var}.class_eval do"),
-            indent(body, 2),
-            indent('end'),
-            indent(klass_var),
-            'end).call'
-          ].join("\n")
+          segments = constant_segments(name_sym)
+          emit_error!("invalid class name: #{name_sym.name}") unless segments
+          super_code = class_super_code(supers, env)
+          inner = build_nested_class(segments, super_code, body)
+          ['(-> do', indent(inner), indent(segments.join('::')), 'end).call'].join("\n")
         end
 
-        def emit_direct_class_header(name_sym, supers, body)
-          const_name = simple_constant_name(name_sym)
-          return unless const_name && supers.nil?
+        def emit_direct_class_header(name_sym, supers, body, env)
+          segments = constant_segments(name_sym)
+          return unless segments
 
-          [
-            "class #{const_name}",
-            indent(body),
-            'end',
-            const_name
-          ].join("\n")
+          super_code = class_super_code(supers, env)
+          [build_nested_class(segments, super_code, body), segments.join('::')].join("\n")
         end
 
-        def simple_constant_name(name_sym)
-          return unless name_sym.is_a?(Sym) && name_sym.name.match?(/\A[A-Z]\w*\z/)
+        def constant_segments(name_sym)
+          return unless name_sym.is_a?(Sym)
 
-          name_sym.name
+          segments = name_sym.dotted? ? name_sym.segments : [name_sym.name]
+          return unless segments.all? { |s| s.match?(/\A[A-Z]\w*\z/) }
+
+          segments
+        end
+
+        def class_super_code(supers, env)
+          return unless supers.is_a?(Vec) && !supers.items.empty?
+
+          emit_expr(supers.items.first, env, :toplevel)
+        end
+
+        def build_nested_module(segments, body)
+          inner = ["module #{segments.last}", indent(body), 'end'].join("\n")
+          wrap_in_modules(segments[0...-1], inner)
+        end
+
+        def build_nested_class(segments, super_code, body)
+          header = super_code ? "class #{segments.last} < #{super_code}" : "class #{segments.last}"
+          inner = [header, indent(body), 'end'].join("\n")
+          wrap_in_modules(segments[0...-1], inner)
+        end
+
+        def wrap_in_modules(parents, inner)
+          parents.reverse.reduce(inner) do |acc, mod_name|
+            ["module #{mod_name}", indent(acc), 'end'].join("\n")
+          end
         end
 
         def emit_try(args, env, current_scope)