kapusta 0.1.2 → 0.1.4

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

@@ -16,19 +16,40 @@ module Kapusta
 
           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
+          lines = ["if #{cond}", indent(truthy)]
+          append_else_lines(lines, args[2..], env, current_scope)
+          lines << 'end'
+          lines.join("\n")
+        end
+
+        def append_else_lines(lines, args, env, current_scope)
+          return if args.empty?
+
+          if args.length == 1 && if_form?(args[0])
+            append_elsif_lines(lines, args[0].rest, env, current_scope)
+          elsif args.length >= 2
+            append_elsif_lines(lines, args, env, current_scope)
+          else
+            lines << 'else'
+            lines << indent(emit_expr(args[0], env, current_scope))
+          end
+        end
+
+        def append_elsif_lines(lines, args, env, current_scope)
+          return append_else_lines(lines, args, env, current_scope) if args.length < 2
+
+          lines << "elsif #{emit_expr(args[0], env, current_scope)}"
+          lines << indent(emit_expr(args[1], env, current_scope))
+          append_else_lines(lines, args[2..], env, current_scope)
         end
 
-        def emit_case(args, env, current_scope)
+        def if_form?(form)
+          form.is_a?(List) && form.head.is_a?(Sym) && form.head.name == 'if'
+        end
+
+        def emit_case(args, env, current_scope, mode)
           value_var = temp('case_value')
-          body = build_case_clauses(value_var, args[1..], env, current_scope)
+          body = build_case_clauses(value_var, args[1..], env, current_scope, mode)
           <<~RUBY.chomp
             (-> do
               #{value_var} = #{emit_expr(args[0], env, current_scope)}
@@ -37,31 +58,32 @@ module Kapusta
           RUBY
         end
 
-        def build_case_clauses(value_var, clauses, env, current_scope)
+        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)
-          emit_case_clause(value_var, pattern, body, else_code, env, current_scope)
+          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 emit_case_clause(value_var, pattern, body, else_code, env, current_scope)
+        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)
+            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)
+            emit_simple_case_clause(value_var, pattern, body, else_code, env, current_scope, mode)
           end
         end
 
-        def emit_simple_case_clause(value_var, pattern, body, else_code, env, current_scope)
+        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(pattern, bindings_var, arm_env)
+          assign_code, arm_env = emit_bindings_from_match(plan[:bindings], 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)}
+            #{match_var} = #{runtime_call(:match_pattern, plan[:pattern], value_var)}
             if #{match_var}[0]
               #{bindings_var} = #{match_var}[1]
               #{assign_code}
@@ -72,17 +94,18 @@ module Kapusta
           RUBY
         end
 
-        def emit_guarded_case_clause(value_var, pattern, body, else_code, env, current_scope)
+        def emit_guarded_case_clause(value_var, pattern, body, else_code, env, current_scope, mode)
           inner = pattern.items[1]
-          guard = pattern.items[2]
+          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(inner, bindings_var, arm_env)
-          guard_code = emit_expr(guard, arm_env, current_scope)
+          assign_code, arm_env = emit_bindings_from_match(plan[:bindings], bindings_var, arm_env)
+          guard_code = emit_case_guards(guards, 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)}
+            #{match_var} = #{runtime_call(:match_pattern, plan[:pattern], value_var)}
             if #{match_var}[0]
               #{bindings_var} = #{match_var}[1]
               #{assign_code}
@@ -97,64 +120,33 @@ module Kapusta
           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(' && ')
+        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
+              #{indent(emit_while_statement(args, env, current_scope))}
               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')
+          loop_code = emit_for_statement(args, env, current_scope)
           <<~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
+              #{indent(loop_code)}
               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
+          iter_code = emit_each_statement(args, env, current_scope)
           <<~RUBY.chomp
             (-> do
               #{iter_code}
@@ -162,6 +154,33 @@ module Kapusta
             end).call
           RUBY
         end
+
+        def emit_while_statement(args, env, current_scope)
+          body_code, = emit_sequence(args[1..], env, current_scope,
+                                     allow_method_definitions: false,
+                                     result: false)
+          [
+            "while #{emit_expr(args[0], env, current_scope)}",
+            indent(body_code),
+            'end'
+          ].join("\n")
+        end
+
+        def emit_for_statement(args, env, current_scope)
+          parsed = parse_counted_for_bindings(args[0].items, env, current_scope)
+          body_code, = emit_sequence(args[1..], parsed[:loop_env], current_scope,
+                                     allow_method_definitions: false,
+                                     result: false)
+          emit_counted_loop(**parsed, current_scope:, body_code:)
+        end
+
+        def emit_each_statement(args, env, current_scope)
+          emit_iteration(args[0], env, current_scope) do |iter_env|
+            emit_sequence(args[1..], iter_env, current_scope,
+                          allow_method_definitions: false,
+                          result: false).first
+          end
+        end
       end
     end
   end

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

@@ -51,7 +51,8 @@ module Kapusta
           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 'case' then emit_case(args, env, current_scope, :case)
+          when 'match' then emit_case(args, env, current_scope, :match)
           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)
@@ -78,7 +79,7 @@ module Kapusta
           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 'gvar' then emit_gvar(args[0])
           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)

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

@@ -37,26 +37,40 @@ module Kapusta
         end
 
         def emit_module_expr(args, env)
-          emit_module_wrapper(args[0], emit_sequence(args[1..], env, :module, allow_method_definitions: true).first)
+          body = emit_sequence(args[1..], env, :module, allow_method_definitions: true, result: false).first
+          emit_module_wrapper(args[0], body)
         end
 
         def emit_class_expr(args, env)
           name_sym, supers, body_forms = split_class_args(args)
+          body = emit_sequence(body_forms, env, :class, allow_method_definitions: true, result: false).first
           emit_class_wrapper(name_sym, supers, env,
-                             emit_sequence(body_forms, env, :class, allow_method_definitions: true).first)
+                             body)
         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
+          [
+            '(-> 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")
+        end
+
+        def emit_direct_module_header(name_sym, body)
+          const_name = simple_constant_name(name_sym)
+          return nil unless const_name
+
+          [
+            "module #{const_name}",
+            indent(body),
+            'end',
+            const_name
+          ].join("\n")
         end
 
         def emit_class_wrapper(name_sym, supers, env, body)
@@ -67,15 +81,33 @@ module Kapusta
             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
+          [
+            '(-> 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")
+        end
+
+        def emit_direct_class_header(name_sym, supers, body)
+          const_name = simple_constant_name(name_sym)
+          return nil unless const_name && supers.nil?
+
+          [
+            "class #{const_name}",
+            indent(body),
+            'end',
+            const_name
+          ].join("\n")
+        end
+
+        def simple_constant_name(name_sym)
+          return nil unless name_sym.is_a?(Sym) && name_sym.name.match?(/\A[A-Z]\w*\z/)
+
+          name_sym.name
         end
 
         def emit_try(args, env, current_scope)
@@ -103,8 +135,7 @@ module Kapusta
           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)
+            rescue_name = define_local(rescue_env, bind_sym.name)
             body_code, = emit_sequence(body, rescue_env, current_scope, allow_method_definitions: false)
             rescue_line =
               if klass_form
@@ -176,9 +207,17 @@ module Kapusta
 
         def emit_callable_call(callee_code, args, env, current_scope)
           positional, kwargs, block = split_call_args(args, env, current_scope)
+          return emit_direct_callable_call(callee_code, positional) unless kwargs || block
+
           runtime_call(:call, callee_code, "[#{positional.join(', ')}]", kwargs, block)
         end
 
+        def emit_direct_callable_call(callee_code, positional)
+          rendered_args = positional.join(', ')
+          suffix = rendered_args.empty? ? '.call' : ".call(#{rendered_args})"
+          "#{parenthesize(callee_code)}#{suffix}"
+        end
+
         def emit_multisym_call(head, args, env, current_scope)
           base_code, segments = multisym_base(head.segments, env)
           if segments.empty?
@@ -192,10 +231,21 @@ module Kapusta
               end
             method_name = Kapusta.kebab_to_snake(segments.last).to_sym.inspect
             positional, kwargs, block = split_call_args(args, env, current_scope)
+            if segments.length == 1 && !kwargs && !block && direct_method_name?(segments.last)
+              return emit_direct_method_call(receiver, Kapusta.kebab_to_snake(segments.last), positional)
+            end
+
             runtime_call(:send_call, receiver, method_name, positional, kwargs, block)
           end
         end
 
+        def emit_direct_method_call(receiver, method_name, positional)
+          args = positional.join(', ')
+          rendered_receiver = simple_expression?(receiver) ? receiver : parenthesize(receiver)
+          suffix = args.empty? ? method_name : "#{method_name}(#{args})"
+          "#{rendered_receiver}.#{suffix}"
+        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
@@ -243,6 +293,13 @@ module Kapusta
           raise Error, "undefined symbol: #{name}"
         end
 
+        def emit_gvar(sym)
+          ruby_name = global_name(sym.name)
+          return "$#{ruby_name}" if direct_global_name?(ruby_name)
+
+          runtime_call(:get_gvar, sym.name.inspect)
+        end
+
         def emit_multisym_value(sym, env)
           base_code, segments = multisym_base(sym.segments, env)
           return base_code if segments.empty?
@@ -269,8 +326,34 @@ module Kapusta
         end
 
         def parenthesize(code)
+          return code if simple_expression?(code)
+
           "(#{code})"
         end
+
+        def direct_method_name?(name)
+          Kapusta.kebab_to_snake(name).match?(/\A[a-z_]\w*[!?=]?\z/)
+        end
+
+        def direct_global_name?(name)
+          name.match?(/\A[a-z_]\w*\z/)
+        end
+
+        def global_name(name)
+          Kapusta.kebab_to_snake(name).gsub(/[^a-zA-Z0-9_]/, '_')
+        end
+
+        def simple_expression?(code)
+          code.match?(/\A[a-z_]\w*\z/) ||
+            code.match?(/\A[A-Z]\w*(?:::[A-Z]\w*)*\z/) ||
+            code.match?(/\A[a-z_]\w*[!?=]?\([^()\n]*\)\z/) ||
+            code.match?(/\A\d+(?:\.\d+)?\z/) ||
+            code.match?(/\A[a-z_]\w*(?:\.[a-z_]\w*[!?=]?(?:\([^()\n]*\))?)+\z/) ||
+            code.match?(/\A:[a-zA-Z_]\w*[!?=]?\z/) ||
+            code.match?(/\A"(?:[^"\\]|\\.)*"\z/) ||
+            code.match?(/\A'(?:[^'\\]|\\.)*'\z/) ||
+            %w[nil true false self].include?(code)
+        end
       end
     end
   end

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

@@ -10,8 +10,7 @@ module Kapusta
           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 = define_local(env, pattern.name)
             ["#{ruby_name} = #{value_code}", env]
           else
             bindings_var = temp('bindings')
@@ -20,25 +19,135 @@ module Kapusta
               "#{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)
+              ruby_name = define_local(current_env, 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)
+        def emit_bindings_from_match(binding_names, 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)
+          binding_names.each do |name|
+            ruby_name = define_local(current_env, name)
             lines << "#{ruby_name} = #{bindings_var}.fetch(#{name.inspect})"
           end
           [lines.join("\n"), current_env]
         end
 
+        def pattern_match_plan(pattern, env, mode:, allow_pins:)
+          state = { bound_names: {}, binding_names: [] }
+          {
+            pattern: emit_match_pattern(pattern, env, mode:, allow_pins:, state:),
+            bindings: state[:binding_names]
+          }
+        end
+
+        def emit_match_pattern(pattern, env, mode:, allow_pins:, state:)
+          case pattern
+          when Sym
+            emit_symbol_match_pattern(pattern, env, mode:, state:)
+          when Vec
+            emit_sequence_match_pattern(pattern.items, env, mode:, allow_pins:, state:)
+          when HashLit
+            pairs = pattern.pairs.map do |key, value|
+              "[#{key.inspect}, #{emit_match_pattern(value, env, mode:, allow_pins:, state:)}]"
+            end
+            "[:hash, [#{pairs.join(', ')}]]"
+          when List
+            if pin_pattern?(pattern)
+              emit_pin_match_pattern(pattern, env, mode:, allow_pins:)
+            elsif or_pattern?(pattern)
+              emit_or_match_pattern(pattern, env, mode:, allow_pins:, state:)
+            elsif where_pattern?(pattern)
+              raise Error, '`where` is only valid as a case/match clause head'
+            else
+              emit_sequence_match_pattern(pattern.items, env, mode:, allow_pins:, state:)
+            end
+          when nil
+            '[:lit, nil]'
+          when Symbol, String, Numeric, true, false
+            "[:lit, #{pattern.inspect}]"
+          else
+            raise Error, "bad pattern: #{pattern.inspect}"
+          end
+        end
+
+        def emit_symbol_match_pattern(pattern, env, mode:, state:)
+          name = pattern.name
+
+          if name == '_'
+            '[:wild]'
+          elsif nil_allowing_pattern_name?(name)
+            bind_name = name.start_with?('?') ? name.delete_prefix('?') : name
+            emit_named_match_pattern(bind_name, env, mode:, state:, allow_nil: true, prefer_pin: false)
+          else
+            emit_named_match_pattern(name, env, mode:, state:, allow_nil: false, prefer_pin: true)
+          end
+        end
+
+        def emit_named_match_pattern(name, env, mode:, state:, allow_nil:, prefer_pin:)
+          if state[:bound_names].key?(name)
+            "[:ref, #{name.inspect}]"
+          elsif prefer_pin && mode == :match && env.defined?(name)
+            "[:pin, #{env.lookup(name)}]"
+          else
+            state[:bound_names][name] = true
+            state[:binding_names] << name
+            "[:bind, #{name.inspect}, #{allow_nil}]"
+          end
+        end
+
+        def emit_sequence_match_pattern(items, env, mode:, allow_pins:, state:)
+          parts = []
+          i = 0
+          while i < items.length
+            if rest_pattern_marker?(items, i)
+              parts << "[:rest, #{emit_match_pattern(items[i + 1], env, mode:, allow_pins:, state:)}]"
+              i += 2
+            else
+              parts << emit_match_pattern(items[i], env, mode:, allow_pins:, state:)
+              i += 1
+            end
+          end
+          "[:vec, [#{parts.join(', ')}]]"
+        end
+
+        def emit_pin_match_pattern(pattern, env, mode:, allow_pins:)
+          raise Error, 'pin patterns are only supported inside `case` guards' unless allow_pins && mode == :case
+
+          name_sym = pattern.items[1]
+          raise Error, "bad pin pattern: #{pattern.inspect}" unless name_sym.is_a?(Sym)
+          raise Error, "cannot pin undefined name: #{name_sym.name}" unless env.defined?(name_sym.name)
+
+          "[:pin, #{env.lookup(name_sym.name)}]"
+        end
+
+        def emit_or_match_pattern(pattern, env, mode:, allow_pins:, state:)
+          initial_names = state[:binding_names].length
+          initial_bound = state[:bound_names].dup
+          canonical_names = nil
+          variants = pattern.items[1..].map do |subpattern|
+            alt_state = {
+              bound_names: initial_bound.dup,
+              binding_names: state[:binding_names].dup
+            }
+            compiled = emit_match_pattern(subpattern, env, mode:, allow_pins:, state: alt_state)
+            alt_names = alt_state[:binding_names][initial_names..]
+            canonical_names ||= alt_names
+            raise Error, 'all `or` patterns must bind the same names' if canonical_names.sort != alt_names.sort
+
+            compiled
+          end
+
+          canonical_names.each do |name|
+            state[:bound_names][name] = true
+            state[:binding_names] << name
+          end
+          "[:or, [#{variants.join(', ')}]]"
+        end
+
         def emit_pattern(pattern)
           case pattern
           when Sym
@@ -99,6 +208,25 @@ module Kapusta
         def where_pattern?(pattern)
           pattern.is_a?(List) && pattern.head.is_a?(Sym) && pattern.head.name == 'where'
         end
+
+        def pin_pattern?(pattern)
+          pattern.is_a?(List) &&
+            pattern.items.length == 2 &&
+            pattern.head.is_a?(Sym) &&
+            pattern.head.name == '='
+        end
+
+        def or_pattern?(pattern)
+          pattern.is_a?(List) && pattern.head.is_a?(Sym) && pattern.head.name == 'or'
+        end
+
+        def nil_allowing_pattern_name?(name)
+          name.length > 1 && (name.start_with?('?') || name.start_with?('_'))
+        end
+
+        def rest_pattern_marker?(items, index)
+          items[index].is_a?(Sym) && items[index].name == '&'
+        end
       end
     end
   end