kapusta 0.13.2 → 0.15.0

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

@@ -37,6 +37,7 @@ module Kapusta
           args = list.rest
           if head.is_a?(Sym)
             return emit_special(head.name, args, env, current_scope) if special_form?(head.name)
+            return emit_multihash_call(head, args, env, current_scope) if head.colonized?
             return emit_multisym_call(head, args, env, current_scope) if head.dotted?
             if (binding = env.lookup_if_defined(head.name))
               return emit_bound_call(binding, args, env, current_scope)
@@ -50,14 +51,29 @@ module Kapusta
             emit_error!(:cannot_call_literal, value: head.inspect)
           end
 
+          if (method_call = method_call_with_receiver_expression(head, args))
+            return emit_method_call(method_call, env, current_scope)
+          end
+
           emit_callable_call(emit_expr(head, env, current_scope), args, env, current_scope)
         end
 
+        def method_call_with_receiver_expression(head, args)
+          return unless head.is_a?(List)
+          return unless head.items.length == 3
+          return unless head.head.is_a?(Sym) && head.head.name == '.'
+
+          method = head.items[2]
+          return unless method.is_a?(Symbol) || method.is_a?(String)
+
+          [head.items[1], method, *args]
+        end
+
         def emit_special(name, args, env, current_scope)
           case name
-          when 'fn', 'lambda', 'λ' then emit_fn(args, env, current_scope)
+          when *Language::FUNCTION_HEADS then emit_fn(args, env, current_scope)
           when 'let' then emit_let(args, env, current_scope)
-          when 'local', 'var' then emit_local_expr(args, env, current_scope)
+          when 'local', 'var' then emit_local_expr(name, args, env, current_scope)
           when 'global' then emit_global_expr(args, env, current_scope)
           when 'set' then emit_set_expr(args, env, current_scope)
           when 'if' then emit_if(args, env, current_scope)
@@ -75,9 +91,9 @@ module Kapusta
           when 'accumulate' then emit_accumulate(args, env, current_scope)
           when 'faccumulate' then emit_faccumulate(args, env, current_scope)
           when 'hashfn' then emit_hashfn(args, env, current_scope)
-          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 emit_method_call(args, env, current_scope)
+          when '?:' then emit_safe_lookup(args, env, current_scope)
+          when ':' then emit_lookup(args, env, current_scope)
           when '..' then emit_concat(args, env, current_scope)
           when 'length' then "#{parenthesize(emit_expr(args[0], env, current_scope))}.length"
           when 'require' then emit_require(args[0], env, current_scope)

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

@@ -7,7 +7,7 @@ module Kapusta
         private
 
         def emit_lookup(args, env, current_scope)
-          emit_error!(:dot_no_args) if args.empty?
+          emit_error!(:dot_no_args) if args.length < 2
 
           object_code = emit_expr(args[0], env, current_scope)
           keys = args[1..].map { |arg| emit_expr(arg, env, current_scope) }
@@ -27,10 +27,12 @@ module Kapusta
         BINARY_OPERATOR_METHODS = %w[<=> ** << >> & | ^ === =~].freeze
         private_constant :BINARY_OPERATOR_METHODS
 
-        def emit_colon(args, env, current_scope)
+        def emit_method_call(args, env, current_scope)
+          emit_error!(:dot_no_args) if args.empty?
+
           receiver = emit_expr(args[0], env, current_scope)
           method_form = args[1]
-          positional, kwargs, block_form = split_call_args(args[2..], env, current_scope)
+          positional, kwargs, block_form = split_call_args(args[2..] || [], env, current_scope)
           literal_name = method_form if method_form.is_a?(Symbol) || method_form.is_a?(String)
           if literal_name && binary_operator_call?(literal_name.to_s, positional, kwargs, block_form)
             return emit_binary_operator_call(receiver, literal_name.to_s, positional[0])
@@ -56,6 +58,13 @@ module Kapusta
         end
 
         def emit_require(arg, env, current_scope)
+          if arg.is_a?(Symbol)
+            feature = arg.to_s.tr('.', '/')
+            return "require_relative #{feature.inspect}" if kapusta_feature_source?(feature)
+
+            return "require #{feature.inspect}"
+          end
+
           literal = require_path_literal(arg)
           if literal&.match?(%r{\A\.\.?/})
             cleaned = literal.delete_suffix('.kap').sub(%r{\A\./}, '')
@@ -71,6 +80,76 @@ module Kapusta
           "require #{path_code}"
         end
 
+        def kapusta_require_module_constant(form)
+          return unless form.is_a?(List)
+          return unless form.head.is_a?(Sym) && form.head.name == 'require'
+          return unless form.rest.length == 1
+
+          path = kapusta_require_source_path(form.rest[0])
+          return unless path
+
+          header = Reader.read_all(File.read(path)).first
+          return unless Language.header_form?(header)
+
+          segments = header_constant_segments(header)
+          segments&.join('::')
+        rescue Errno::ENOENT, Kapusta::Error
+          nil
+        end
+
+        def kapusta_require_source_path(arg)
+          return kapusta_feature_source_path(arg.to_s.tr('.', '/')) if arg.is_a?(Symbol)
+
+          literal = require_path_literal(arg)
+          return unless literal&.match?(%r{\A\.\.?/})
+
+          kapusta_local_source_path(literal)
+        end
+
+        def kapusta_feature_source?(feature)
+          !kapusta_feature_source_path(feature).nil?
+        end
+
+        def kapusta_feature_source_path(feature)
+          return if @path.nil? || @path.start_with?('(')
+
+          path = File.expand_path("#{feature}.kap", File.dirname(File.expand_path(@path)))
+          path if File.file?(path)
+        end
+
+        def kapusta_local_source?(feature)
+          !kapusta_local_source_path(feature).nil?
+        end
+
+        def kapusta_local_source_path(feature)
+          return if @path.nil? || @path.start_with?('(')
+
+          base = File.dirname(File.expand_path(@path))
+          path = File.absolute_path?(feature) ? feature : File.expand_path(feature, base)
+          candidates = File.extname(path).empty? ? ["#{path}.kap"] : [path]
+          candidates.find { |candidate| File.file?(candidate) && candidate.end_with?('.kap') }
+        end
+
+        def header_constant_segments(header)
+          parsed =
+            if header.head.name == 'module'
+              Language.parse_module_form(header)
+            else
+              Language.parse_class_form(header)
+            end
+          segments = constant_segments(parsed.name)
+          return unless segments
+
+          if header.head.name == 'module' &&
+             parsed.body.length == 1 &&
+             Language.bodyless_header?(parsed.body[0])
+            inner_segments = header_constant_segments(parsed.body[0])
+            return [*segments, *inner_segments] if inner_segments
+          end
+
+          segments
+        end
+
         def require_path_literal(arg)
           case arg
           when Sym then arg.name
@@ -80,18 +159,20 @@ module Kapusta
         end
 
         def emit_module_expr(args, env)
+          parsed = Language.parse_module_args(args)
           body = with_class_body do
-            emit_sequence(args[1..], env.child, :module, allow_method_definitions: true, result: false).first
+            emit_sequence(parsed.body, env.child, :module, allow_method_definitions: true, result: false).first
           end
-          emit_module_wrapper(args[0], body)
+          body = wrap_singleton(body) if parsed.singleton
+          emit_module_wrapper(parsed.name, body)
         end
 
         def emit_class_expr(args, env)
-          name_sym, supers, body_forms = split_class_args(args)
+          parsed = Language.parse_class_args(args)
           body = with_class_body do
-            emit_sequence(body_forms, env.child, :class, allow_method_definitions: true, result: false).first
+            emit_sequence(parsed.body, env.child, :class, allow_method_definitions: true, result: false).first
           end
-          emit_class_wrapper(name_sym, supers, env,
+          emit_class_wrapper(parsed.name, parsed.supers, env,
                              body)
         end
 
@@ -158,51 +239,32 @@ module Kapusta
         end
 
         def emit_try(args, env, current_scope)
-          catches = []
-          finally_bodies = []
-          args[1..].each do |clause|
-            head = clause.head
-            if head.is_a?(Sym) && head.name == 'catch'
-              rest = clause.items[1..]
-              if rest[0].is_a?(Sym) && (rest[0].name.match?(/\A[A-Z]/) || rest[0].dotted?)
-                klass_form = rest[0]
-                bind_sym = rest[1]
-                body = rest[2..]
-              else
-                klass_form = nil
-                bind_sym = rest[0]
-                body = rest[1..]
-              end
-              catches << [klass_form, bind_sym, body]
-            elsif head.is_a?(Sym) && head.name == 'finally'
-              finally_bodies << clause.items[1..]
-            end
-          end
-
-          body_form = args[0]
+          parsed = Language.parse_try_args(args)
+          body_form = parsed.body
           body_code =
-            if body_form.is_a?(List) && body_form.head.is_a?(Sym) && body_form.head.name == 'do'
+            if Language.do_form?(body_form)
               emit_sequence(body_form.rest, env, current_scope, allow_method_definitions: false).first
             else
               emit_expr(body_form, env, current_scope)
             end
           lines = ['begin', indent(body_code)]
-          catches.each do |klass_form, bind_sym, body|
+          parsed.clauses.grep(Language::CatchClause).each do |clause|
             rescue_env = env.child
-            rescue_name = define_local(rescue_env, bind_sym.name)
-            body_code, = emit_sequence(body, rescue_env, current_scope, allow_method_definitions: false)
+            rescue_name = define_local(rescue_env, clause.bind_sym.name)
+            body_code, = emit_sequence(clause.body, rescue_env, current_scope, allow_method_definitions: false)
             rescue_line =
-              if klass_form
-                "rescue #{emit_expr(klass_form, env, current_scope)} => #{rescue_name}"
+              if clause.klass
+                "rescue #{emit_expr(clause.klass, env, current_scope)} => #{rescue_name}"
               else
                 "rescue StandardError => #{rescue_name}"
               end
             lines << rescue_line
             lines << indent(body_code)
           end
-          unless finally_bodies.empty?
-            ensure_code = finally_bodies.map do |body|
-              emit_sequence(body, env, current_scope, allow_method_definitions: false).first
+          finally_clauses = parsed.clauses.grep(Language::FinallyClause)
+          unless finally_clauses.empty?
+            ensure_code = finally_clauses.map do |clause|
+              emit_sequence(clause.body, env, current_scope, allow_method_definitions: false).first
             end.join("\n")
             lines << 'ensure'
             lines << indent(ensure_code)
@@ -310,7 +372,7 @@ module Kapusta
         end
 
         def emit_self_method_binding_call(binding, args, env, current_scope)
-          positional = args.map { |arg| emit_expr(arg, env, current_scope) }
+          positional = emit_call_args(args, env, current_scope)
           emit_direct_self_method_call(binding.ruby_name, positional)
         end
 
@@ -341,6 +403,11 @@ module Kapusta
           end
         end
 
+        def emit_multihash_call(head, args, env, current_scope)
+          lookup_code = emit_multihash_value(head, env)
+          emit_callable_call(lookup_code, args, env, current_scope)
+        end
+
         def emit_method_path(base_code, segments)
           segments.reduce(base_code) do |acc, segment|
             snake = Kapusta.kebab_to_snake(segment)
@@ -366,6 +433,9 @@ module Kapusta
         def emit_self_call(name, args, env, current_scope)
           positional, kwargs, block_form = split_call_args(args, env, current_scope)
           snake = Kapusta.kebab_to_snake(name)
+          if Language.class_body_declaration?(snake) && kwargs.nil? && block_form.nil?
+            return positional.empty? ? snake : "#{snake} #{positional.join(', ')}"
+          end
           if direct_method_name?(snake)
             return emit_direct_self_call(snake, positional, kwargs, block_form, env, current_scope)
           end
@@ -394,27 +464,41 @@ module Kapusta
 
           if !remaining.empty? && remaining.last.is_a?(HashLit) && remaining.last.all_sym_keys?
             kwargs = emit_expr(remaining.last, env, current_scope)
-            positional = remaining[0...-1].map { |arg| emit_expr(arg, env, current_scope) }
+            positional = emit_call_args(remaining[0...-1], env, current_scope)
           else
             kwargs = nil
-            positional = remaining.map { |arg| emit_expr(arg, env, current_scope) }
+            positional = emit_call_args(remaining, env, current_scope)
           end
           [positional, kwargs, block_form]
         end
 
+        def emit_call_args(args, env, current_scope)
+          args.map.with_index do |arg, index|
+            code = emit_expr(arg, env, current_scope)
+            index == args.length - 1 && multi_value_call_arg?(arg, env) ? "*#{code}" : code
+          end
+        end
+
+        def multi_value_call_arg?(arg, env)
+          return true if Language.list_head?(arg, 'values')
+          return false unless arg.is_a?(List) && arg.head.is_a?(Sym)
+
+          binding = env.lookup_if_defined(arg.head.name)
+          callable_method_binding?(binding) && binding.multi_return
+        end
+
         def emit_block_proc(block_form, env, current_scope)
           block_form && emit_expr(block_form, env, current_scope)
         end
 
         def emit_attached_block(block_form, env, current_scope)
-          return unless block_form.is_a?(List) && block_form.head.is_a?(Sym)
-          return unless %w[fn lambda λ].include?(block_form.head.name)
+          parsed = Language.parse_function_form(block_form)
+          return unless parsed&.anonymous?
 
-          pattern = block_form.items[1]
+          pattern = parsed.params
           return unless pattern.is_a?(Vec) && simple_parameter_pattern?(pattern)
 
-          body = block_form.items[2..]
-          params, body_code = build_simple_block_parts(pattern, body, env, current_scope)
+          params, body_code = build_simple_block_parts(pattern, parsed.body, env, current_scope)
           header = params.empty? ? 'do' : "do |#{params.join(', ')}|"
           [header, indent(body_code), 'end'].join("\n")
         end
@@ -439,6 +523,7 @@ module Kapusta
           end
 
           emit_error!(:unexpected_vararg) if name == '...'
+          return emit_multihash_value(sym, env) if sym.colonized?
           return emit_multisym_value(sym, env) if sym.dotted?
           return 'ARGV' if name == 'ARGV'
           return name if name.match?(/\A[A-Z]/)
@@ -460,6 +545,33 @@ module Kapusta
           emit_method_path(base_code, segments)
         end
 
+        def emit_multihash_value(sym, env)
+          base_code, segments = multihash_base(sym.colon_segments, env)
+          emit_hash_lookup_path(base_code, segments)
+        end
+
+        def emit_hash_lookup_path(base_code, segments)
+          receiver = simple_expression?(base_code) ? base_code : parenthesize(base_code)
+          segments.reduce(receiver) do |acc, segment|
+            "#{acc}[#{Kapusta.kebab_to_snake(segment).to_sym.inspect}]"
+          end
+        end
+
+        def multihash_base(segments, env)
+          first = segments[0]
+          if first == 'self'
+            ['self', segments[1..]]
+          elsif (binding = env.lookup_if_defined(first))
+            [binding_value_code(binding), segments[1..]]
+          elsif first == 'ARGV'
+            ['ARGV', segments[1..]]
+          elsif first.match?(/\A[A-Z]/)
+            [first, segments[1..]]
+          else
+            emit_error!(:undefined_symbol, name: first)
+          end
+        end
+
         def multisym_base(segments, env)
           if segments[0] == 'self'
             ['self', segments[1..]]
@@ -472,12 +584,24 @@ module Kapusta
               const_path << segments[idx]
               idx += 1
             end
-            emit_error!(:bad_multisym, path: segments.join('.')) if const_path.empty?
+            emit_bad_multisym!(segments) if const_path.empty?
 
             [const_path.join('::'), segments[idx..]]
           end
         end
 
+        def emit_bad_multisym!(segments)
+          root = segments[0]
+          emit_error!(:bad_multisym,
+                      path: segments.join('.'),
+                      segment: root,
+                      suggestion: bad_multisym_suggestion(root))
+        end
+
+        def bad_multisym_suggestion(root)
+          "bind #{root} first, use a capitalized constant path, or call a method on an explicit receiver"
+        end
+
         def parenthesize(code)
           return code if simple_expression?(code)
 

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

@@ -23,7 +23,7 @@ module Kapusta
 
         def validate_binding_symbol!(sym)
           name = sym.name
-          emit_error!(:shadowed_special, name:) if Compiler::SPECIAL_FORMS.include?(name)
+          emit_error!(:shadowed_special, name:) if Language.special_form?(name)
           return unless sym.is_a?(MacroSym)
 
           emit_error!(:macro_unsafe_bind, name:)
@@ -42,8 +42,8 @@ module Kapusta
 
         def try_emit_native_pattern_bind(pattern, value_code, env)
           case pattern
-          when Vec
-            try_emit_native_vec_bind(pattern, value_code, env)
+          when Vec, List
+            try_emit_native_seq_bind(pattern, value_code, env)
           when HashLit
             try_emit_native_hash_bind(pattern, value_code, env)
           end
@@ -51,7 +51,7 @@ module Kapusta
           nil
         end
 
-        def try_emit_native_vec_bind(pattern, value_code, env)
+        def try_emit_native_seq_bind(pattern, value_code, env)
           validate_destructure_pattern!(pattern)
           parts = []
           deferred = []
@@ -256,7 +256,7 @@ module Kapusta
         def compile_compat_pin(pattern, value_code, env, mode:, allow_pins:, state:)
           raise PatternNotTranslatable unless allow_pins && mode == :case
 
-          name_sym = pattern.items[1]
+          name_sym = Language.parse_pin_pattern(pattern)&.name
           raise PatternNotTranslatable unless name_sym.is_a?(Sym)
 
           binding = env.lookup_if_defined(name_sym.name)
@@ -405,7 +405,7 @@ module Kapusta
         def compile_native_pin(pattern, env, mode:, allow_pins:)
           raise PatternNotTranslatable unless allow_pins && mode == :case
 
-          name_sym = pattern.items[1]
+          name_sym = Language.parse_pin_pattern(pattern)&.name
           raise PatternNotTranslatable unless name_sym.is_a?(Sym)
 
           binding = env.lookup_if_defined(name_sym.name)
@@ -418,7 +418,7 @@ module Kapusta
           initial_bound = state[:bound_names].dup
           initial_names = state[:binding_names].length
           initial_guards = state[:guards].length
-          variants = pattern.items[1..].map do |subpattern|
+          variants = Language.parse_or_pattern(pattern).alternatives.map do |subpattern|
             alt_state = {
               bound_names: initial_bound.dup,
               binding_names: state[:binding_names].dup,
@@ -446,25 +446,23 @@ module Kapusta
           when HashLit
             pattern.pairs.flat_map { |_key, value| pattern_names(value) }
           when List
-            where_pattern?(pattern) ? pattern_names(pattern.items[1]) : []
+            parsed = Language.parse_where_pattern(pattern)
+            parsed ? pattern_names(parsed.inner) : []
           else
             []
           end
         end
 
         def where_pattern?(pattern)
-          pattern.is_a?(List) && pattern.head.is_a?(Sym) && pattern.head.name == 'where'
+          !Language.parse_where_pattern(pattern).nil?
         end
 
         def pin_pattern?(pattern)
-          pattern.is_a?(List) &&
-            pattern.items.length == 2 &&
-            pattern.head.is_a?(Sym) &&
-            pattern.head.name == '='
+          !Language.parse_pin_pattern(pattern).nil?
         end
 
         def or_pattern?(pattern)
-          pattern.is_a?(List) && pattern.head.is_a?(Sym) && pattern.head.name == 'or'
+          !Language.parse_or_pattern(pattern).nil?
         end
 
         def nil_allowing_pattern_name?(name)