kapusta 0.2.3 → 0.3.0

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)
@@ -491,7 +484,7 @@ module Kapusta
             code.match?(/\A\$[a-zA-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-?\d+(?:\.\d+)?\z/) ||
             code.match?(/\A[a-z_]\w*(?:\.[a-z_]\w*[!?=]?(?:\([^()\n]*\))?|\[[^\[\]]*\])+\z/) ||
             code.match?(/\A[A-Z]\w*(?:::[A-Z]\w*)*(?:\.[a-z_]\w*[!?=]?(?:\([^()\n]*\))?|\[[^\[\]]*\])+\z/) ||
             code.match?(/\A:[a-zA-Z_]\w*[!?=]?\z/) ||

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

@@ -11,174 +11,261 @@ module Kapusta
             return ['', env] if pattern.name == '_'
 
             ruby_name = define_local(env, pattern)
-            ["#{ruby_name} = #{value_code}", env]
+            return ["#{ruby_name} = #{value_code}", env]
+          end
+
+          native = try_emit_native_pattern_bind(pattern, value_code, env)
+          return native if native
+
+          emit_error!("destructure pattern this compiler cannot translate: #{pattern.inspect}")
+        end
+
+        def try_emit_native_pattern_bind(pattern, value_code, env)
+          case pattern
+          when Vec
+            try_emit_native_vec_bind(pattern, value_code, env)
+          when HashLit
+            try_emit_native_hash_bind(pattern, value_code, env)
+          end
+        rescue PatternNotTranslatable
+          nil
+        end
+
+        def try_emit_native_vec_bind(pattern, value_code, env)
+          parts = []
+          deferred = []
+          current_env = env
+          items = pattern.items
+          i = 0
+          while i < items.length
+            if items[i].is_a?(Sym) && items[i].name == '&'
+              sub = items[i + 1]
+              raise PatternNotTranslatable unless sub.is_a?(Sym)
+
+              parts << native_rest_target(sub, current_env)
+              i += 2
+            else
+              code, current_env, follow_up = native_destructure_target(items[i], current_env, allow_follow_up: true)
+              parts << code
+              deferred << follow_up if follow_up
+              i += 1
+            end
+          end
+          if deferred.empty?
+            ["#{parts.join(', ')} = #{value_code}", current_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 = define_local(current_env, name)
-              lines << "#{ruby_name} = #{bindings_var}.fetch(#{name.inspect})"
+            arr_var = simple_expression?(value_code) ? value_code : temp('array')
+            lines = []
+            lines << "#{arr_var} = #{value_code}" unless arr_var == value_code
+            lines << "#{parts.join(', ')} = #{arr_var}"
+            deferred.each do |follow_up|
+              sub_code, current_env = follow_up.call(current_env)
+              lines << sub_code
             end
             [lines.join("\n"), current_env]
           end
         end
 
-        def emit_bindings_from_match(binding_names, bindings_var, env)
-          current_env = env
+        def try_emit_native_hash_bind(pattern, value_code, env)
+          pairs = pattern.pairs
+          raise PatternNotTranslatable if pairs.empty?
+
+          temp_var = simple_expression?(value_code) ? value_code : temp('hash')
           lines = []
-          binding_names.each do |name|
-            ruby_name = define_local(current_env, name)
-            lines << "#{ruby_name} = #{bindings_var}.fetch(#{name.inspect})"
+          lines << "#{temp_var} = #{value_code}" unless temp_var == value_code
+          current_env = env
+          pairs.each do |key, sub|
+            access = "#{temp_var}[#{key.inspect}]"
+            if sub.is_a?(Sym)
+              raise PatternNotTranslatable if sub.name == '_'
+
+              bind_name = sub.name.start_with?('?') ? sub.name.delete_prefix('?') : sub.name
+              ruby_name = define_local(current_env, bind_name)
+              lines << "#{ruby_name} = #{access}"
+            else
+              sub_code, current_env = try_emit_native_pattern_bind(sub, access, current_env) ||
+                                      raise(PatternNotTranslatable)
+              lines << sub_code
+            end
           end
           [lines.join("\n"), current_env]
         end
 
-        def pattern_match_plan(pattern, env, mode:, allow_pins:)
-          state = { bound_names: {}, binding_names: [] }
+        def native_destructure_target(pattern, env, allow_follow_up: false)
+          case pattern
+          when Sym
+            return ['_', env, nil] if pattern.name == '_'
+
+            bind_name = pattern.name.start_with?('?') ? pattern.name.delete_prefix('?') : pattern.name
+            ruby_name = define_local(env, bind_name)
+            [ruby_name, env, nil]
+          when Vec
+            inner = []
+            current = env
+            deferred = []
+            items = pattern.items
+            i = 0
+            while i < items.length
+              if items[i].is_a?(Sym) && items[i].name == '&'
+                inner << native_rest_target(items[i + 1], current)
+                i += 2
+              else
+                code, current, follow_up = native_destructure_target(items[i], current)
+                inner << code
+                deferred << follow_up if follow_up
+                i += 1
+              end
+            end
+            raise PatternNotTranslatable unless deferred.empty?
+
+            ["(#{inner.join(', ')})", current, nil]
+          when HashLit
+            raise PatternNotTranslatable unless allow_follow_up
+
+            slot = temp('slot')
+            follow_up = lambda do |outer_env|
+              try_emit_native_hash_bind(pattern, slot, outer_env) || raise(PatternNotTranslatable)
+            end
+            [slot, env, follow_up]
+          else
+            raise PatternNotTranslatable
+          end
+        end
+
+        def native_rest_target(sym, env)
+          raise PatternNotTranslatable unless sym.is_a?(Sym)
+
+          return '*' if sym.name == '_'
+
+          bind_name = sym.name.start_with?('?') ? sym.name.delete_prefix('?') : sym.name
+          "*#{define_local(env, bind_name)}"
+        end
+
+        class PatternNotTranslatable < StandardError; end
+
+        def native_pattern_plan(pattern, env, mode:, allow_pins:)
+          state = { bound_names: {}, binding_names: [], guards: [] }
+          ruby_pattern = compile_native_pattern(pattern, env, mode:, allow_pins:, state:)
           {
-            pattern: emit_match_pattern(pattern, env, mode:, allow_pins:, state:),
+            pattern: ruby_pattern,
+            guards: state[:guards],
             bindings: state[:binding_names]
           }
+        rescue PatternNotTranslatable
+          nil
         end
 
-        def emit_match_pattern(pattern, env, mode:, allow_pins:, state:)
+        def compile_native_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 Sym then compile_native_symbol(pattern, env, mode:, state:)
+          when Vec then compile_native_sequence(pattern.items, env, mode:, allow_pins:, state:)
+          when HashLit then compile_native_hash(pattern, env, mode:, allow_pins:, state:)
           when List
             if pin_pattern?(pattern)
-              emit_pin_match_pattern(pattern, env, mode:, allow_pins:)
+              compile_native_pin(pattern, env, mode:, allow_pins:)
             elsif or_pattern?(pattern)
-              emit_or_match_pattern(pattern, env, mode:, allow_pins:, state:)
-            elsif where_pattern?(pattern)
-              emit_error!('`where` is only valid as a case/match clause head')
+              compile_native_or(pattern, env, mode:, allow_pins:, state:)
             else
-              emit_sequence_match_pattern(pattern.items, env, mode:, allow_pins:, state:)
+              compile_native_sequence(pattern.items, env, mode:, allow_pins:, state:)
             end
-          when nil
-            '[:lit, nil]'
-          when Symbol, String, Numeric, true, false
-            "[:lit, #{pattern.inspect}]"
-          else
-            emit_error!("bad pattern: #{pattern.inspect}")
+          when nil then 'nil'
+          when Symbol, String, Numeric, true, false then pattern.inspect
+          else raise PatternNotTranslatable
           end
         end
 
-        def emit_symbol_match_pattern(pattern, env, mode:, state:)
+        def compile_native_symbol(pattern, env, mode:, state:)
           name = pattern.name
+          return '_' if name == '_'
 
-          if name == '_'
-            '[:wild]'
-          elsif nil_allowing_pattern_name?(name)
+          if 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
+            raise PatternNotTranslatable if state[:bound_names].key?(bind_name)
 
-        def emit_named_match_pattern(name, env, mode:, state:, allow_nil:, prefer_pin:)
-          binding = prefer_pin && mode == :match ? env.lookup_if_defined(name) : nil
-          if state[:bound_names].key?(name)
-            "[:ref, #{name.inspect}]"
-          elsif binding
-            "[:pin, #{binding_value_code(binding)}]"
+            state[:bound_names][bind_name] = true
+            state[:binding_names] << bind_name
+            sanitize_local(bind_name)
           else
-            state[:bound_names][name] = true
-            state[:binding_names] << name
-            "[:bind, #{name.inspect}, #{allow_nil}]"
+            binding = mode == :match ? env.lookup_if_defined(name) : nil
+            if state[:bound_names].key?(name)
+              raise PatternNotTranslatable
+            elsif binding
+              "^(#{binding_value_code(binding)})"
+            else
+              state[:bound_names][name] = true
+              state[:binding_names] << name
+              ruby = sanitize_local(name)
+              state[:guards] << "!#{ruby}.nil?"
+              ruby
+            end
           end
         end
 
-        def emit_sequence_match_pattern(items, env, mode:, allow_pins:, state:)
+        def compile_native_sequence(items, env, mode:, allow_pins:, state:)
           parts = []
+          has_rest = false
           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:)}]"
+              has_rest = true
+              sub = items[i + 1]
+              raise PatternNotTranslatable unless sub.is_a?(Sym)
+
+              if sub.name == '_'
+                parts << '*'
+              else
+                state[:bound_names][sub.name] = true
+                state[:binding_names] << sub.name
+                parts << "*#{sanitize_local(sub.name)}"
+              end
               i += 2
             else
-              parts << emit_match_pattern(items[i], env, mode:, allow_pins:, state:)
+              parts << compile_native_pattern(items[i], env, mode:, allow_pins:, state:)
               i += 1
             end
           end
-          "[:vec, [#{parts.join(', ')}]]"
+          parts << '*' unless has_rest
+          "[#{parts.join(', ')}]"
         end
 
-        def emit_pin_match_pattern(pattern, env, mode:, allow_pins:)
-          emit_error!('pin patterns are only supported inside `case` guards') unless allow_pins && mode == :case
+        def compile_native_hash(pattern, env, mode:, allow_pins:, state:)
+          pairs = pattern.pairs.map do |key, value|
+            raise PatternNotTranslatable unless key.is_a?(Symbol)
+
+            "#{key}: #{compile_native_pattern(value, env, mode:, allow_pins:, state:)}"
+          end
+          "{#{pairs.join(', ')}}"
+        end
+
+        def compile_native_pin(pattern, env, mode:, allow_pins:)
+          raise PatternNotTranslatable unless allow_pins && mode == :case
 
           name_sym = pattern.items[1]
-          emit_error!("bad pin pattern: #{pattern.inspect}") unless name_sym.is_a?(Sym)
+          raise PatternNotTranslatable unless name_sym.is_a?(Sym)
 
           binding = env.lookup_if_defined(name_sym.name)
-          emit_error!("cannot pin undefined name: #{name_sym.name}") unless binding
+          raise PatternNotTranslatable unless binding
 
-          "[:pin, #{binding_value_code(binding)}]"
+          "^(#{binding_value_code(binding)})"
         end
 
-        def emit_or_match_pattern(pattern, env, mode:, allow_pins:, state:)
-          initial_names = state[:binding_names].length
+        def compile_native_or(pattern, env, mode:, allow_pins:, state:)
           initial_bound = state[:bound_names].dup
-          canonical_names = nil
+          initial_names = state[:binding_names].length
+          initial_guards = state[:guards].length
           variants = pattern.items[1..].map do |subpattern|
             alt_state = {
               bound_names: initial_bound.dup,
-              binding_names: state[:binding_names].dup
+              binding_names: state[:binding_names].dup,
+              guards: state[:guards].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
-            emit_error!('all `or` patterns must bind the same names') if canonical_names.sort != alt_names.sort
+            compiled = compile_native_pattern(subpattern, env, mode:, allow_pins:, state: alt_state)
+            raise PatternNotTranslatable if alt_state[:binding_names].length > initial_names
+            raise PatternNotTranslatable if alt_state[:guards].length > initial_guards
 
             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
-            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
-            emit_error!("bad pattern: #{pattern.inspect}")
-          end
+          "(#{variants.join(' | ')})"
         end
 
         def pattern_names(pattern)

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

@@ -62,7 +62,7 @@ module Kapusta
           else
             name_sym, supers, = split_class_args(form.items[1..])
             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)
+            emit_direct_class_header(name_sym, supers, body, env) || emit_class_wrapper(name_sym, supers, env, body)
           end
         end
 
@@ -128,7 +128,7 @@ module Kapusta
             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}\nnil", env] if result_needed && current_scope != :toplevel
 
             return [code, env]
           end
@@ -219,19 +219,6 @@ module Kapusta
           source_name.is_a?(GeneratedSym)
         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 method_binding?(binding)
           binding.is_a?(Env::MethodBinding)
         end

data/lib/kapusta/compiler/emitter.rb

@@ -27,14 +27,12 @@ module Kapusta
       def initialize(path:)
         @path = path
         @temp_index = 0
-        @runtime_helpers = []
       end
 
       def emit_file(forms)
         env = Env.new
         body = emit_forms_with_headers(forms, env, :toplevel)
-        helpers = Runtime.helper_source(@runtime_helpers)
-        [helpers, body].reject(&:empty?).join("\n\n") << "\n"
+        "#{body}\n"
       end
     end
   end

data/lib/kapusta/compiler/normalizer.rb

@@ -121,12 +121,12 @@ module Kapusta
       end
 
       def thread_temp
-        gensym('kap_thread')
+        gensym('thread')
       end
 
       def doto(forms)
         value = forms.first
-        temp = gensym('kap_doto')
+        temp = gensym('doto')
         body = forms[1..].map do |form|
           if form.is_a?(List)
             List.new([form.items[0], temp, *form.items[1..]])

data/lib/kapusta/compiler.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require_relative 'error'
-require_relative 'compiler/runtime'
 require_relative 'compiler/normalizer'
 require_relative 'compiler/emitter'
 

data/lib/kapusta/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kapusta
-  VERSION = '0.2.3'
+  VERSION = '0.3.0'
 end