kapusta 0.8.0 → 0.10.0

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/interop.rb

@@ -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,6 +25,10 @@ module Kapusta
           (@form_stack ||= []).last
         end
 
+        def mruby_target?
+          @target == :mruby
+        end
+
         def positionable?(form)
           form.respond_to?(:line) && form.respond_to?(:column)
         end
@@ -97,7 +101,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 +141,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 +157,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

@@ -104,19 +104,29 @@ module Kapusta
       end
 
       def thread_short(forms, position)
-        forms[1..].reduce(forms.first) do |memo, form|
-          temp = thread_temp
-          List.new([
-                     Sym.new('let'),
-                     Vec.new([temp, memo]),
-                     List.new([
-                                Sym.new('if'),
-                                List.new([Sym.new('='), temp, nil]),
-                                nil,
-                                thread_step(temp, form, position)
-                              ])
-                   ])
+        steps = forms[1..]
+        return forms.first if steps.empty?
+
+        prev_temp = thread_temp
+        binding_items = [prev_temp, forms.first]
+        body = nil
+        last_index = steps.length - 1
+        steps.each_with_index do |form, i|
+          guarded = List.new([
+                               Sym.new('if'),
+                               List.new([Sym.new('='), prev_temp, nil]),
+                               nil,
+                               thread_step(prev_temp, form, position)
+                             ])
+          if i == last_index
+            body = guarded
+          else
+            temp = thread_temp
+            binding_items.push(temp, guarded)
+            prev_temp = temp
+          end
         end
+        List.new([Sym.new('let'), Vec.new(binding_items), body])
       end
 
       def thread_step(memo, form, position)

data/lib/kapusta/compiler.rb

@@ -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

data/lib/kapusta/errors.rb

@@ -10,6 +10,7 @@ module Kapusta
       bad_set_target: 'bad set target: %{target}',
       bad_shorthand: 'bad shorthand',
       bind_table_dots: 'unable to bind table ...',
+      cannot_call_constant: 'cannot call constant %{name}; reference it without parentheses',
       cannot_call_literal: 'cannot call literal value %{value}',
       cannot_emit_form: 'cannot emit form: %{form}',
       cannot_set_method_binding: 'cannot set method binding: %{name}',
@@ -51,6 +52,7 @@ module Kapusta
       odd_forms_in_hash: 'odd number of forms in hash',
       rest_not_last: 'expected rest argument before last parameter',
       shadowed_special: 'local %{name} was overshadowed by a special form or macro',
+      target_requires_compile: '--target requires --compile',
       tset_no_value: 'tset: expected table, key, and value arguments',
       unclosed_delimiter: "unclosed opening delimiter '%{char}'",
       undefined_symbol: 'undefined symbol: %{name}',
@@ -58,6 +60,7 @@ module Kapusta
       unexpected_eof: 'unexpected eof',
       unexpected_vararg: 'unexpected vararg',
       unknown_special_form: 'unknown special form: %{name}',
+      unknown_target: 'unknown target %{target}; only mruby is supported',
       unquote_outside_quasiquote: 'unquote outside quasiquote',
       unquote_splice_outside_list: 'unquote-splice must appear inside a quoted list/vec',
       unterminated_string: 'unterminated string',

data/lib/kapusta/formatter.rb

@@ -178,7 +178,7 @@ module Kapusta
 
       case form
       when Comment then form.text
-      when List then render_list(form, indent, top_level:)
+      when List then form.sigil ? render_sigil(form) : render_list(form, indent, top_level:)
       when Vec then render_vec(form, indent, layout:, top_level:, force_expand:)
       when HashLit then render_hash(form, indent)
       when Quasiquote then render_prefix('`', form.form, indent, force_expand:)
@@ -189,6 +189,13 @@ module Kapusta
       end
     end
 
+    SIGIL_PREFIXES = { ivar: '@', cvar: '@@', gvar: '$' }.freeze
+    private_constant :SIGIL_PREFIXES
+
+    def render_sigil(list)
+      "#{SIGIL_PREFIXES.fetch(list.sigil)}#{list.items[1].name}"
+    end
+
     def render_prefix(prefix, inner, indent, force_expand: false)
       rendered = render(inner, indent + prefix.length, force_expand:)
       lines = rendered.lines(chomp: true)
@@ -221,6 +228,7 @@ module Kapusta
 
         "{#{rendered.join(' ')}}"
       when List
+        return render_sigil(form) if form.sigil
         return if contains_comments?(form.items)
         return "##{flat_render(semantic_items(form.items)[1])}" if hashfn_literal?(form)
         return if multiline_in_source?(form)
@@ -649,7 +657,6 @@ module Kapusta
 
     def render_let_bindings(bindings, indent)
       return render(bindings, indent + '(let '.length, force_expand: true) if contains_comments?(bindings.items)
-      return render(bindings, indent + '(let '.length, layout: :pairwise) if bindings.items.length <= 2
 
       hanging = render_hanging_pairwise_vec(bindings)
       hanging || render(bindings, indent + '(let '.length, layout: :pairwise)

data/lib/kapusta/lsp/scope_walker.rb

@@ -16,7 +16,7 @@ module Kapusta
         end
       end
 
-      SKIPPED_HEADS = %w[macros ivar cvar gvar quasi-sym quasi-list
+      SKIPPED_HEADS = %w[macros quasi-sym quasi-list
                          quasi-list-tail quasi-vec quasi-vec-tail quasi-hash quasi-gensym].freeze
 
       DISPATCHERS = {
@@ -42,7 +42,10 @@ module Kapusta
         'class' => :walk_module_class,
         'hashfn' => :walk_hashfn,
         'macro' => :walk_macro_def,
-        'import-macros' => :walk_import_macros
+        'import-macros' => :walk_import_macros,
+        'ivar' => :walk_sigil_form,
+        'cvar' => :walk_sigil_form,
+        'gvar' => :walk_sigil_form
       }.freeze
 
       attr_reader :bindings, :references, :root_scope
@@ -58,7 +61,9 @@ module Kapusta
         @references = []
         @scope_seq = 0
         @root_scope = make_scope(nil, :file)
+        @gvar_scope = make_scope(nil, :gvars)
         @in_module_or_class = 0
+        @sigil_scope_stack = [make_sigil_scopes]
       end
 
       def walk_top(forms)
@@ -132,7 +137,7 @@ module Kapusta
           name_sym, supers, = split_class_args(form.items[1..] || [])
           supers&.items&.each { |item| walk_form(item, scope) }
           add_constant_binding(name_sym, scope, :class) if name_sym.is_a?(Sym)
-          inside_module_or_class do
+          inside_class do
             remaining_forms.each { |item| walk_form(item, scope) }
           end
         end
@@ -154,6 +159,21 @@ module Kapusta
         @in_module_or_class -= 1
       end
 
+      def inside_class
+        inside_module_or_class do
+          @sigil_scope_stack.push(make_sigil_scopes)
+          begin
+            yield
+          ensure
+            @sigil_scope_stack.pop
+          end
+        end
+      end
+
+      def make_sigil_scopes
+        { ivar: make_scope(nil, :ivars), cvar: make_scope(nil, :cvars) }
+      end
+
       def walk_form(form, scope)
         case form
         when List then walk_list(form, scope)
@@ -291,6 +311,10 @@ module Kapusta
         target = list.items[1]
         value = list.items[2]
         walk_form(value, scope) if value
+        if target.is_a?(List)
+          walk_form(target, scope)
+          return
+        end
         return unless target.is_a?(Sym) && !target.dotted?
 
         existing = scope.lookup(target.name)
@@ -301,6 +325,29 @@ module Kapusta
         end
       end
 
+      def walk_sigil_form(list, _scope)
+        return if list.items.length < 2
+
+        inner = list.items[1]
+        return unless inner.is_a?(Sym)
+
+        kind = list.head.name.to_sym
+        target_scope = sigil_target_scope(kind)
+        existing = target_scope.bindings[inner.name]
+        if existing
+          add_reference(inner, target_scope, existing)
+        else
+          add_binding(inner, target_scope, kind)
+        end
+      end
+
+      def sigil_target_scope(kind)
+        case kind
+        when :ivar, :cvar then @sigil_scope_stack.last.fetch(kind)
+        when :gvar then @gvar_scope
+        end
+      end
+
       def walk_fn(list, scope)
         items = list.items
         if items[1].is_a?(Vec)
@@ -472,8 +519,11 @@ module Kapusta
 
         add_constant_binding(name_sym, scope, kind) if name_sym.is_a?(Sym)
 
-        inside_module_or_class do
-          list.items[body_start..]&.each { |form| walk_form(form, scope) }
+        body = list.items[body_start..] || []
+        if kind == :class
+          inside_class { body.each { |form| walk_form(form, scope) } }
+        else
+          inside_module_or_class { body.each { |form| walk_form(form, scope) } }
         end
       end