kapusta 0.9.0 → 0.11.0

data/lib/kapusta/cli.rb

@@ -5,7 +5,7 @@ require 'optparse'
 
 module Kapusta
   class CLI
-    Options = Struct.new(:compile, :help, :version, keyword_init: true)
+    Options = Struct.new(:compile, :target, :help, :version, keyword_init: true)
 
     def self.start(argv = ARGV)
       args = argv.dup
@@ -21,8 +21,10 @@ module Kapusta
         return
       end
 
+      raise Kapusta::Error, Kapusta::Errors.format(:target_requires_compile) if options.target && !options.compile
+
       if options.compile
-        compile_file(args)
+        compile_file(args, target: options.target)
       else
         run_file(args)
       end
@@ -32,11 +34,14 @@ module Kapusta
     end
 
     def self.parse_options(args)
-      options = Options.new(compile: false, help: false, version: false)
+      options = Options.new(compile: false, target: nil, help: false, version: false)
 
       OptionParser.new do |parser|
         parser.banner = usage
         parser.on('-c', '--compile', 'Compile .kap to Ruby') { options.compile = true }
+        parser.on('--target=TARGET', 'Compile for mruby') do |target|
+          options.target = Kapusta::Compiler.normalize_target(target)
+        end
         parser.on('-h', '--help', 'Show this help') { options.help = true }
         parser.on('-v', '--version', 'Show version') { options.version = true }
       end.order!(args)
@@ -44,12 +49,12 @@ module Kapusta
       options
     end
 
-    def self.compile_file(args)
+    def self.compile_file(args, target:)
       path = args.shift
       abort usage unless path
       abort usage unless args.empty?
 
-      $stdout.write(Kapusta.compile(File.read(path), path:))
+      $stdout.write(Kapusta.compile(File.read(path), path:, target:))
     end
 
     def self.run_file(args)
@@ -64,7 +69,7 @@ module Kapusta
     end
 
     def self.usage
-      'usage: kapusta [--compile|-c] <file.kap> | kapusta <file.kap> [args...]'
+      'usage: kapusta [--compile|-c] [--target=mruby] <file.kap> | kapusta <file.kap> [args...]'
     end
   end
 end

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

@@ -181,6 +181,14 @@ module Kapusta
 
         def emit_toplevel_method_bridge(ruby_name)
           method_name = ruby_name.to_sym.inspect
+          if mruby_target?
+            return [
+              "define_singleton_method(#{method_name}) do |*args|",
+              indent("Object.instance_method(#{method_name}).bind(self).call(*args)"),
+              'end'
+            ].join("\n")
+          end
+
           "define_singleton_method(#{method_name}, Object.instance_method(#{method_name}).bind(self))"
         end
 
@@ -229,8 +237,14 @@ module Kapusta
 
           binding = env.lookup_if_defined(name)
           return false if binding.nil?
+          return false if method_binding?(binding)
+          return false if constant_binding?(binding)
+
+          true
+        end
 
-          !method_binding?(binding)
+        def constant_binding?(binding)
+          binding.is_a?(String) && binding.match?(/\A[A-Z][A-Z0-9_]*\z/)
         end
 
         def emit_let(args, env, current_scope)
@@ -277,7 +291,7 @@ module Kapusta
           chunks.reject(&:empty?).join("\n")
         end
 
-        def emit_local_form(form, env, current_scope)
+        def emit_local_form(form, env, current_scope, allow_constant: false)
           emit_error!(:local_arity, form: form.head.name) unless form.items.length == 3
 
           target = form.items[1]
@@ -285,6 +299,12 @@ module Kapusta
 
           if target.is_a?(Sym)
             validate_binding_symbol!(target)
+            if allow_constant && form.head.name == 'local' && (constant_name = constant_name_for(target.name))
+              env.define(target.name, constant_name)
+              mark_mutability(env, target.name, mutable: false)
+              return ["#{constant_name} = #{value_code}\nnil", env]
+            end
+
             ruby_name = define_local(env, target.name)
             mark_mutability(env, target.name, mutable: form.head.name == 'var')
             ["#{ruby_name} = #{value_code}\nnil", env]
@@ -294,6 +314,11 @@ module Kapusta
           end
         end
 
+        def constant_name_for(source_name)
+          candidate = source_name.tr('-', '_').upcase
+          candidate if candidate.match?(/\A[A-Z][A-Z0-9_]*\z/)
+        end
+
         def check_destructure_value!(pattern, value_form)
           return unless pattern.is_a?(Vec) || pattern.is_a?(HashLit)
 

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

@@ -57,6 +57,25 @@ module Kapusta
         end
 
         def emit_case(args, env, current_scope, mode)
+          value_code, value_var, body = build_case_parts(args, env, current_scope, mode)
+          return body unless value_var
+
+          [
+            '(-> do',
+            indent("#{value_var} = #{value_code}"),
+            indent(body),
+            'end).call'
+          ].join("\n")
+        end
+
+        def emit_case_statement(args, env, current_scope, mode)
+          value_code, value_var, body = build_case_parts(args, env, current_scope, mode)
+          return body unless value_var
+
+          "#{value_var} = #{value_code}\n#{body}"
+        end
+
+        def build_case_parts(args, env, current_scope, mode)
           emit_error!(:case_no_subject) if args.empty?
 
           clauses = args[1..]
@@ -65,20 +84,22 @@ module Kapusta
 
           value_code = emit_expr(args[0], env, current_scope)
           if simple_case_subject?(args[0]) && simple_expression?(value_code)
-            body = try_emit_native_case(value_code, clauses, env, current_scope, mode)
+            body = emit_case_body(value_code, clauses, env, current_scope, mode)
             emit_error!(:case_unsupported) unless body
-            return body
+            return [value_code, nil, body]
           end
 
           value_var = temp('case_value')
-          body = try_emit_native_case(value_var, clauses, env, current_scope, mode)
+          body = emit_case_body(value_var, clauses, env, current_scope, mode)
           emit_error!(:case_unsupported) unless body
-          [
-            '(-> do',
-            indent("#{value_var} = #{value_code}"),
-            indent(body),
-            'end).call'
-          ].join("\n")
+          [value_code, value_var, body]
+        end
+
+        def emit_case_body(value_var, clauses, env, current_scope, mode)
+          return try_emit_compat_case(value_var, clauses, env, current_scope, mode) if mruby_target?
+
+          try_emit_native_case(value_var, clauses, env, current_scope, mode) ||
+            try_emit_compat_case(value_var, clauses, env, current_scope, mode)
         end
 
         def simple_case_subject?(form)
@@ -113,11 +134,6 @@ module Kapusta
           ["case #{value_var}", *arms, 'end'].join("\n")
         end
 
-        def wildcard_last?(clauses)
-          last_pattern = clauses[-2]
-          last_pattern.is_a?(Sym) && last_pattern.name == '_'
-        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:)
@@ -132,6 +148,73 @@ module Kapusta
           ["in #{plan[:pattern]}#{guard_clause}", indent(body_code)].join("\n")
         end
 
+        def try_emit_compat_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_compat_arm(sub, body, where_guards, value_var, env, current_scope, mode)
+            end
+            return if sub_arms.any?(&:nil?)
+
+            arms.concat(sub_arms)
+            i += 2
+          end
+          emit_compat_case_lines(arms)
+        end
+
+        def wildcard_last?(clauses)
+          last_pattern = clauses[-2]
+          last_pattern.is_a?(Sym) && last_pattern.name == '_'
+        end
+
+        def try_compat_arm(pattern, body, where_guards, value_var, env, current_scope, mode)
+          allow_pins = !where_guards.empty? && mode == :case
+          arm_env = env.child
+          plan = compat_pattern_plan(pattern, value_var, env, arm_env, mode:, allow_pins:)
+          return unless plan
+
+          where_guard_codes = where_guards.map { |g| emit_expr(g, arm_env, current_scope) }
+          if where_guard_codes.empty?
+            guard_codes = plan[:conditions]
+            prelude     = plan[:prelude]
+          else
+            prelude_guards = plan[:prelude].map { |line| "begin #{line}; true end" }
+            guard_codes = plan[:conditions] + prelude_guards + where_guard_codes
+            prelude     = []
+          end
+          body_code = emit_expr(body, arm_env, current_scope)
+          [guard_codes, prelude, body_code]
+        end
+
+        def emit_compat_case_lines(arms)
+          last_idx = arms.length - 1
+          has_unconditional = arms.any? { |conditions, _prelude, _body_code| conditions.empty? }
+          lines = ['case']
+          arms.each_with_index do |(conditions, prelude, body_code), idx|
+            lines << if conditions.empty?
+                       idx == last_idx ? 'else' : 'when true'
+                     else
+                       "when #{conditions.join(' && ')}"
+                     end
+            lines << indent([*prelude, body_code].join("\n"))
+          end
+          unless has_unconditional
+            lines << 'else'
+            lines << indent('nil')
+          end
+          lines << 'end'
+          lines.join("\n")
+        end
+
         def emit_while(args, env, current_scope)
           <<~RUBY.chomp
             (-> do

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

@@ -83,6 +83,7 @@ module Kapusta
           when 'require' then emit_require(args[0], env, current_scope)
           when 'module' then emit_module_expr(args, env)
           when 'class' then emit_class_expr(args, env)
+          when 'end' then emit_error!(:end_outside_header)
           when 'try' then emit_try(args, env, current_scope)
           when 'raise' then emit_raise(args, env, current_scope)
           when 'ivar' then "@#{Kapusta.kebab_to_snake(args[0].name)}"

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

@@ -102,7 +102,7 @@ module Kapusta
           segments = constant_segments(name_sym)
           return unless segments
 
-          [build_nested_module(segments, body), segments.join('::')].join("\n")
+          build_nested_module(segments, body)
         end
 
         def emit_class_wrapper(name_sym, supers, env, body)
@@ -118,7 +118,7 @@ module Kapusta
           return unless segments
 
           super_code = class_super_code(supers, env)
-          [build_nested_class(segments, super_code, body), segments.join('::')].join("\n")
+          build_nested_class(segments, super_code, body)
         end
 
         def constant_segments(name_sym)
@@ -300,6 +300,8 @@ module Kapusta
         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_error!(:cannot_call_constant, name: binding) if constant_binding?(binding)
+
           emit_callable_call(binding, args, env, current_scope)
         end
 

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

@@ -161,6 +161,131 @@ module Kapusta
 
         class PatternNotTranslatable < StandardError; end
 
+        def compat_pattern_plan(pattern, value_code, env, arm_env, mode:, allow_pins:)
+          state = { bound_names: {}, conditions: [], prelude: [] }
+          compile_compat_pattern(pattern, value_code, env, arm_env, mode:, allow_pins:, state:)
+          { conditions: state[:conditions], prelude: state[:prelude] }
+        rescue PatternNotTranslatable
+          nil
+        end
+
+        def compile_compat_pattern(pattern, value_code, env, arm_env, mode:, allow_pins:, state:)
+          case pattern
+          when Sym
+            compile_compat_symbol(pattern, value_code, env, arm_env, mode:, state:)
+          when Vec
+            compile_compat_sequence(pattern.items, value_code, env, arm_env, mode:, allow_pins:, state:)
+          when HashLit
+            compile_compat_hash(pattern, value_code, env, arm_env, mode:, allow_pins:, state:)
+          when List
+            if pin_pattern?(pattern)
+              compile_compat_pin(pattern, value_code, env, mode:, allow_pins:, state:)
+            elsif or_pattern?(pattern)
+              raise PatternNotTranslatable
+            else
+              compile_compat_sequence(pattern.items, value_code, env, arm_env, mode:, allow_pins:, state:)
+            end
+          when nil
+            state[:conditions] << "#{value_code}.nil?"
+          when Symbol, String, Numeric, true, false
+            state[:conditions] << "#{value_code} == #{pattern.inspect}"
+          else
+            raise PatternNotTranslatable
+          end
+        end
+
+        def compile_compat_symbol(pattern, value_code, env, arm_env, mode:, state:)
+          name = pattern.name
+          return if name == '_'
+
+          if nil_allowing_pattern_name?(name)
+            raise PatternNotTranslatable if state[:bound_names].key?(name)
+
+            ruby = define_local(arm_env, name)
+            state[:bound_names][name] = true
+            state[:prelude] << "#{ruby} = #{value_code}"
+            return
+          end
+
+          binding = mode == :match ? env.lookup_if_defined(name) : nil
+          if state[:bound_names].key?(name)
+            raise PatternNotTranslatable
+          elsif binding
+            state[:conditions] << "#{value_code} == #{binding_value_code(binding)}"
+          else
+            ruby = define_local(arm_env, name)
+            state[:bound_names][name] = true
+            state[:conditions] << "(#{ruby} = #{value_code}) != nil"
+          end
+        end
+
+        def compile_compat_sequence(items, value_code, env, arm_env, mode:, allow_pins:, state:)
+          min_length = compat_sequence_min_length(items)
+          state[:conditions] << "#{value_code}.is_a?(Array)"
+          state[:conditions] << "#{value_code}.length >= #{min_length}"
+
+          index = 0
+          i = 0
+          while i < items.length
+            if rest_pattern_marker?(items, i)
+              sub = items[i + 1]
+              raise PatternNotTranslatable unless sub.is_a?(Sym)
+
+              unless sub.name == '_'
+                ruby = define_local(arm_env, sub.name)
+                state[:prelude] << "#{ruby} = #{value_code}[#{index}..]"
+              end
+              i += 2
+            else
+              compile_compat_pattern(items[i], "#{value_code}[#{index}]", env, arm_env,
+                                     mode:, allow_pins:, state:)
+              index += 1
+              i += 1
+            end
+          end
+        end
+
+        def compat_sequence_min_length(items)
+          count = 0
+          i = 0
+          while i < items.length
+            if rest_pattern_marker?(items, i)
+              i += 2
+            else
+              count += 1
+              i += 1
+            end
+          end
+          count
+        end
+
+        def compile_compat_hash(pattern, value_code, env, arm_env, mode:, allow_pins:, state:)
+          state[:conditions] << "#{value_code}.is_a?(Hash)"
+          pattern.pairs.each do |key, value|
+            lookup = "#{value_code}[#{compile_compat_hash_key(key)}]"
+            compile_compat_pattern(value, lookup, env, arm_env, mode:, allow_pins:, state:)
+          end
+        end
+
+        def compile_compat_hash_key(key)
+          case key
+          when Symbol, String, Numeric, true, false, nil then key.inspect
+          else raise PatternNotTranslatable
+          end
+        end
+
+        def compile_compat_pin(pattern, value_code, env, mode:, allow_pins:, state:)
+          raise PatternNotTranslatable unless allow_pins && mode == :case
+
+          name_sym = pattern.items[1]
+          raise PatternNotTranslatable unless name_sym.is_a?(Sym)
+
+          binding = env.lookup_if_defined(name_sym.name)
+          raise PatternNotTranslatable unless binding
+
+          state[:conditions] << "#{value_code} == #{binding_value_code(binding)}"
+        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:)

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

@@ -25,27 +25,61 @@ module Kapusta
           (@form_stack ||= []).last
         end
 
+        def mruby_target?
+          @target == :mruby
+        end
+
         def positionable?(form)
           form.respond_to?(:line) && form.respond_to?(:column)
         end
 
         def emit_forms_with_headers(forms, env, current_scope, result: true)
-          i = 0
+          _ = result
+          code, _next = emit_form_run(forms, 0, env, current_scope)
+          code
+        end
+
+        def emit_form_run(forms, start, env, current_scope, header_form: nil)
+          i = start
           codes = []
           while i < forms.length
             form = forms[i]
+            if end_form?(form)
+              validate_end_form!(form)
+              with_current_form(form) { emit_error!(:end_outside_header) } unless header_form
+              return [codes.join("\n"), i + 1]
+            end
+
             if bodyless_header?(form)
-              codes << emit_bodyless_header(form, forms[(i + 1)..], env, current_scope)
-              break
-            else
-              code, env = emit_form_in_sequence(form, env, current_scope,
-                                                allow_method_definitions: true,
-                                                result_needed: result && i == forms.length - 1)
-              codes << code
-              i += 1
+              header_code, i = emit_bodyless_header(form, forms, i + 1, env)
+              codes << header_code
+              next
             end
+
+            code, env = emit_form_in_sequence(form, env, current_scope,
+                                              allow_method_definitions: true,
+                                              result_needed: false)
+            codes << code
+            i += 1
           end
-          codes.join("\n")
+          with_current_form(header_form) { emit_error!(:unclosed_header) } if header_form
+          [codes.join("\n"), i]
+        end
+
+        def end_form?(form)
+          form.is_a?(List) && !form.empty? && form.head.is_a?(Sym) && form.head.name == 'end'
+        end
+
+        def validate_end_form!(form)
+          with_current_form(form) { emit_error!(:end_with_args) } if form.items.length > 1
+        end
+
+        def validate_header_name!(form, head)
+          name_sym = head == 'module' ? form.items[1] : split_class_args(form.items[1..])[0]
+          return if constant_segments(name_sym)
+
+          code = head == 'module' ? :invalid_module_name : :invalid_class_name
+          emit_error!(code, name: name_sym.respond_to?(:name) ? name_sym.name : name_sym.inspect)
         end
 
         def bodyless_header?(form)
@@ -65,23 +99,25 @@ module Kapusta
           end
         end
 
-        def emit_bodyless_header(form, remaining_forms, env, _current_scope)
+        def emit_bodyless_header(form, forms, body_start, env)
           head = form.head.name
-          name_sym = form.items[1]
-
+          validate_header_name!(form, head)
           if head == 'module'
+            name_sym = form.items[1]
             inner = form.items[2..] || []
-            body =
-              if inner.length == 1 && bodyless_header?(inner[0])
-                emit_bodyless_header(inner[0], remaining_forms, env, :module)
-              else
-                emit_forms_with_headers(remaining_forms, env, :module, result: false)
-              end
-            emit_direct_module_header(name_sym, body) || emit_module_wrapper(name_sym, body)
+            if inner.length == 1 && bodyless_header?(inner[0])
+              inner_code, next_i = emit_bodyless_header(inner[0], forms, body_start, env)
+              [emit_direct_module_header(name_sym, inner_code) || emit_module_wrapper(name_sym, inner_code), next_i]
+            else
+              body, next_i = emit_form_run(forms, body_start, env, :module, header_form: form)
+              [emit_direct_module_header(name_sym, body) || emit_module_wrapper(name_sym, body), next_i]
+            end
           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, env) || emit_class_wrapper(name_sym, supers, env, body)
+            body, next_i = emit_form_run(forms, body_start, env, :class, header_form: form)
+            code = emit_direct_class_header(name_sym, supers, body, env) ||
+                   emit_class_wrapper(name_sym, supers, env, body)
+            [code, next_i]
           end
         end
 
@@ -97,7 +133,8 @@ module Kapusta
             if named_function_form?(form)
               emit_named_fn_assignment(form, env, current_scope)
             elsif local_form?(form)
-              code, env = emit_local_form(form, env, current_scope)
+              code, env = emit_local_form(form, env, current_scope,
+                                          allow_constant: allow_method_definitions)
               code = code.delete_suffix("\nnil") unless result_needed
               [code, env]
             elsif do_form?(form)
@@ -136,7 +173,7 @@ module Kapusta
         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)
+          %w[let while for each case match].include?(form.head.name)
         end
 
         def emit_sequence_statement_form(form, env, current_scope, result_needed:)
@@ -152,6 +189,8 @@ module Kapusta
             return ["#{code}\nnil", env] if result_needed && current_scope != :toplevel
 
             return [code, env]
+          when 'case', 'match'
+            return [emit_case_statement(form.rest, env, current_scope, form.head.name.to_sym), env] unless result_needed
           end
 
           [emit_expr(form, env, current_scope), env]

data/lib/kapusta/compiler/emitter.rb

@@ -24,8 +24,9 @@ module Kapusta
       include EmitterModules::Interop
       include EmitterModules::Patterns
 
-      def initialize(path:)
+      def initialize(path:, target: nil)
         @path = path
+        @target = target
         @temp_index = 0
       end
 

data/lib/kapusta/compiler/normalizer.rb

@@ -40,6 +40,12 @@ module Kapusta
         return inherit_position(List.new(items), list) unless head.is_a?(Sym)
 
         case head.name
+        when 'defn'
+          name_sym = items[1]
+          raise compiler_error(:fn_no_params, list) unless name_sym.is_a?(Sym)
+
+          self_name = inherit_position(Sym.new("self.#{name_sym.name}"), name_sym)
+          inherit_position(List.new([inherit_position(Sym.new('fn'), head), self_name, *items[2..]]), list)
         when 'when'
           raise compiler_error(:when_no_body, list, form: head.name) if items[2..].empty?
 

data/lib/kapusta/compiler.rb

@@ -10,7 +10,7 @@ module Kapusta
   module Compiler
     class Error < Kapusta::Error; end
     CORE_SPECIAL_FORMS = %w[
-      fn lambda λ let local var global set if when unless case match
+      fn defn lambda λ let local var global set if when unless case match
       while for each do values
       -> ->> -?> -?>> doto
       icollect collect fcollect accumulate faccumulate
@@ -19,7 +19,7 @@ module Kapusta
       ..
       length
       require
-      module class
+      module class end
       try catch finally
       raise
       ivar cvar gvar
@@ -34,17 +34,17 @@ module Kapusta
     ].freeze
     SPECIAL_FORMS = (CORE_SPECIAL_FORMS + LuaCompat::SPECIAL_FORMS).freeze
 
-    def self.compile(source, path: '(kapusta)')
+    def self.compile(source, path: '(kapusta)', target: nil)
       forms = Reader.read_all(source)
       expanded = MacroExpander.new(path:).expand_all(forms)
-      compile_forms(expanded, path:)
+      compile_forms(expanded, path:, target:)
     rescue Kapusta::Error => e
       raise e.with_defaults(path:)
     end
 
-    def self.compile_forms(forms, path: '(kapusta)')
+    def self.compile_forms(forms, path: '(kapusta)', target: nil)
       normalized = Normalizer.new.normalize_all(forms)
-      Emitter.new(path:).emit_file(normalized)
+      Emitter.new(path:, target: normalize_target(target)).emit_file(normalized)
     rescue Kapusta::Error => e
       raise e.with_defaults(path:)
     end
@@ -57,5 +57,14 @@ module Kapusta
     def self.run_file(path)
       run(File.read(path), path:)
     end
+
+    def self.normalize_target(target)
+      case target
+      when nil then nil
+      when :mruby, 'mruby' then :mruby
+      else
+        raise Error, Kapusta::Errors.format(:unknown_target, target: target.inspect)
+      end
+    end
   end
 end