kapusta 0.1.3 → 0.1.5

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

@@ -36,7 +36,7 @@ module Kapusta
           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_bound_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
@@ -68,9 +68,7 @@ module Kapusta
           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 '..' then emit_concat(args, env, current_scope)
           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)
@@ -79,7 +77,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)
@@ -95,13 +93,31 @@ module Kapusta
           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)
+          when 'print' then emit_print(args, env, current_scope)
           else
             raise Error, "unknown special form: #{name}"
           end
         end
+
+        def emit_concat(args, env, current_scope)
+          return '""' if args.empty?
+
+          args.map { |arg| emit_string_part(arg, env, current_scope) }.join(' + ')
+        end
+
+        def emit_print(args, env, current_scope)
+          return '$stdout.puts("")' if args.empty?
+
+          values = args.map { |arg| emit_string_part(arg, env, current_scope) }
+          output = values.length == 1 ? values.first : "[#{values.join(', ')}].join(\"\\t\")"
+          "$stdout.puts(#{output})"
+        end
+
+        def emit_string_part(arg, env, current_scope)
+          return arg.inspect if arg.is_a?(String)
+
+          runtime_call(:stringify, emit_expr(arg, env, current_scope))
+        end
       end
     end
   end

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 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 unless const_name && supers.nil?
+
+          [
+            "class #{const_name}",
+            indent(body),
+            'end',
+            const_name
+          ].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/)
+
+          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,33 @@ 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_bound_call(binding, args, env, current_scope)
+          return emit_self_method_binding_call(binding, args, env, current_scope) if method_binding?(binding)
+
+          emit_callable_call(binding, args, env, current_scope)
+        end
+
+        def emit_self_method_binding_call(binding, args, env, current_scope)
+          positional = args.map { |arg| emit_expr(arg, env, current_scope) }
+          emit_direct_self_method_call(binding.ruby_name, positional)
+        end
+
+        def emit_direct_self_method_call(method_name, positional)
+          args = positional.join(', ')
+          args.empty? ? "#{method_name}()" : "#{method_name}(#{args})"
+        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 +247,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
@@ -235,7 +301,7 @@ module Kapusta
           name = sym.name
           return 'self' if name == 'self'
           return 'Float::INFINITY' if name == 'math.huge'
-          return env.lookup(name) if env.defined?(name)
+          return binding_value_code(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]/)
@@ -243,6 +309,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?
@@ -254,7 +327,7 @@ module Kapusta
           if segments[0] == 'self'
             ['self', segments[1..]]
           elsif env.defined?(segments[0])
-            [env.lookup(segments[0]), segments[1..]]
+            [binding_value_code(env.lookup(segments[0])), segments[1..]]
           else
             idx = 0
             const_path = []
@@ -269,8 +342,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,8 +19,7 @@ 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]
@@ -32,8 +30,7 @@ module Kapusta
           current_env = env
           lines = []
           binding_names.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]
@@ -94,7 +91,7 @@ module Kapusta
           if state[:bound_names].key?(name)
             "[:ref, #{name.inspect}]"
           elsif prefer_pin && mode == :match && env.defined?(name)
-            "[:pin, #{env.lookup(name)}]"
+            "[:pin, #{binding_value_code(env.lookup(name))}]"
           else
             state[:bound_names][name] = true
             state[:binding_names] << name
@@ -124,7 +121,7 @@ module Kapusta
           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)}]"
+          "[:pin, #{binding_value_code(env.lookup(name_sym.name))}]"
         end
 
         def emit_or_match_pattern(pattern, env, mode:, allow_pins:, state:)

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

@@ -6,7 +6,7 @@ module Kapusta
       module Support
         private
 
-        def emit_forms_with_headers(forms, env, current_scope)
+        def emit_forms_with_headers(forms, env, current_scope, result: true)
           i = 0
           codes = []
           while i < forms.length
@@ -15,7 +15,9 @@ module Kapusta
               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)
+              code, env = emit_form_in_sequence(form, env, current_scope,
+                                                allow_method_definitions: true,
+                                                result_needed: result && i == forms.length - 1)
               codes << code
               i += 1
             end
@@ -50,25 +52,34 @@ module Kapusta
               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)
+                emit_forms_with_headers(remaining_forms, env, :module, result: false)
               end
-            emit_module_wrapper(name_sym, body)
+            emit_direct_module_header(name_sym, body) || 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)
+            body = emit_forms_with_headers(remaining_forms, env, :class, result: false)
+            emit_direct_class_header(name_sym, supers, body) || 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)
+        def emit_form_in_sequence(form, env, current_scope, allow_method_definitions:, result_needed: true)
+          if allow_method_definitions &&
+             method_definition_form?(form) &&
+             %i[toplevel module class].include?(current_scope)
+            code, env = emit_definition_form(form, env, current_scope)
+            return [code, env] if code
+          end
+
+          if named_function_form?(form)
             emit_named_fn_assignment(form, env, current_scope)
           elsif local_form?(form)
-            emit_local_form(form, env, current_scope)
+            code, env = emit_local_form(form, env, current_scope)
+            code = code.delete_suffix("\nnil") unless result_needed
+            [code, env]
           elsif do_form?(form)
-            emit_do_form(form.rest, env, current_scope)
+            emit_do_form(form.rest, env, current_scope, result_needed:)
+          elsif sequence_statement_form?(form)
+            emit_sequence_statement_form(form, env, current_scope, result_needed:)
           elsif set_new_local_form?(form, env)
             emit_set_form(form, env, current_scope)
           else
@@ -76,22 +87,51 @@ module Kapusta
           end
         end
 
-        def emit_do_form(forms, env, current_scope)
-          body, new_env = emit_sequence(forms, env, current_scope, allow_method_definitions: false)
+        def emit_do_form(forms, env, current_scope, result_needed: true)
+          body, new_env = emit_sequence(forms, env, current_scope,
+                                        allow_method_definitions: false,
+                                        result: result_needed)
+          return [body, new_env] unless result_needed
+
           ["begin\n#{indent(body)}\nend", new_env]
         end
 
-        def emit_sequence(forms, env, current_scope, allow_method_definitions:)
+        def emit_sequence(forms, env, current_scope, allow_method_definitions:, result: true)
           current_env = env
           codes = []
-          forms.each do |form|
+          forms.each_with_index do |form, index|
             code, current_env = emit_form_in_sequence(form, current_env, current_scope,
-                                                      allow_method_definitions:)
+                                                      allow_method_definitions:,
+                                                      result_needed: result && index == forms.length - 1)
             codes << code
           end
           [codes.join("\n"), current_env]
         end
 
+        def sequence_statement_form?(form)
+          return false unless form.is_a?(List) && form.head.is_a?(Sym)
+
+          %w[let while for each].include?(form.head.name)
+        end
+
+        def emit_sequence_statement_form(form, env, current_scope, result_needed:)
+          case form.head.name
+          when 'let'
+            return [emit_let_statement(form.rest, env, current_scope), env] unless result_needed
+          when 'while'
+            return [emit_while_statement(form.rest, env, current_scope), env]
+          when 'for'
+            return [emit_for_statement(form.rest, env, current_scope), env]
+          when 'each'
+            code = emit_each_statement(form.rest, env, current_scope)
+            return ["#{code}\nnil", env] if result_needed
+
+            return [code, env]
+          end
+
+          [emit_expr(form, env, current_scope), env]
+        end
+
         def special_form?(name)
           Compiler::SPECIAL_FORMS.include?(name)
         end
@@ -140,7 +180,35 @@ module Kapusta
 
         def temp(prefix)
           @temp_index += 1
-          "__kap_#{prefix}_#{@temp_index}"
+          "kap_#{prefix}_#{@temp_index}"
+        end
+
+        def define_local(env, source_name, shadow: false)
+          ruby_name = local_name(source_name, env, shadow:)
+          env.define(source_name, ruby_name)
+          ruby_name
+        end
+
+        def local_name(source_name, env, shadow:)
+          base = sanitize_local(source_name)
+          base = "user_#{base}" if reserved_generated_name?(base)
+          return base unless ruby_name_defined?(env, base, shadow:)
+
+          index = 2
+          loop do
+            candidate = "#{base}_#{index}"
+            return candidate unless ruby_name_defined?(env, candidate, shadow:)
+
+            index += 1
+          end
+        end
+
+        def ruby_name_defined?(env, name, shadow:)
+          shadow ? env.local_ruby_name_defined?(name) : env.ruby_name_defined?(name)
+        end
+
+        def reserved_generated_name?(name)
+          name.start_with?('kap_', '__kap_')
         end
 
         def runtime_helper(name)
@@ -156,11 +224,18 @@ module Kapusta
           "#{runtime_helper(name)}(#{rendered_args.join(', ')})"
         end
 
+        def method_binding?(binding)
+          binding.is_a?(Env::MethodBinding)
+        end
+
+        def binding_value_code(binding)
+          method_binding?(binding) ? "method(#{binding.ruby_name.to_sym.inspect})" : binding
+        end
+
         def parse_counted_for_bindings(bindings, env, current_scope)
           name_sym = bindings[0]
-          ruby_name = temp(sanitize_local(name_sym.name))
           loop_env = env.child
-          loop_env.define(name_sym.name, ruby_name)
+          ruby_name = define_local(loop_env, name_sym.name)
           start_code = emit_expr(bindings[1], env, current_scope)
           finish_code = emit_expr(bindings[2], env, current_scope)
           step_code = '1'
@@ -184,24 +259,25 @@ module Kapusta
           step_var = temp('step')
           cmp_var = temp('cmp')
           until_code = until_form ? "break if #{emit_expr(until_form, loop_env, current_scope)}" : nil
-          <<~RUBY.chomp
-            #{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
-          RUBY
+          body = [until_code, body_code, "#{ruby_name} += #{step_var}"].compact.reject(&:empty?).join("\n")
+          [
+            "#{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})",
+            indent(body),
+            'end'
+          ].join("\n")
         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)
+          if base.empty? || base.match?(/\A\d/) || base.match?(/\A[A-Z]/) || self.class::RUBY_KEYWORDS.include?(base)
+            base = "_#{base}"
+          end
           base
         end
       end

data/lib/kapusta/compiler/normalizer.rb

@@ -74,7 +74,7 @@ module Kapusta
       end
 
       def wrap_do(forms)
-        return nil if forms.empty?
+        return if forms.empty?
         return forms.first if forms.length == 1
 
         List.new([Sym.new('do'), *forms])