kapusta 0.3.0 → 0.5.0

data/lib/kapusta/compiler/macro_expander.rb

@@ -0,0 +1,286 @@
+# frozen_string_literal: true
+
+module Kapusta
+  module Compiler
+    class MacroExpander
+      class Error < Kapusta::Error; end
+
+      @gensym_counter = 0
+
+      class << self
+        def fresh_gensym(prefix)
+          @gensym_counter += 1
+          GeneratedSym.new("#{prefix}_g#{@gensym_counter}", @gensym_counter)
+        end
+
+        def fresh_local_gensym(prefix)
+          @gensym_counter += 1
+          GeneratedSym.new("#{prefix}_local_#{@gensym_counter}", @gensym_counter)
+        end
+      end
+
+      def initialize(path: nil)
+        @macros = {}
+        @path = path
+      end
+
+      def expand_all(forms)
+        forms.flat_map { |form| expand_top(form) }
+      end
+
+      private
+
+      def expand_top(form)
+        if form.is_a?(List) && form.head.is_a?(Sym)
+          case form.head.name
+          when 'macro'
+            register_macro_form(form.rest)
+            return []
+          when 'macros'
+            register_macros_form(form.rest)
+            return []
+          when 'import-macros'
+            raise macro_error(:import_macros_unsupported, form)
+          end
+        end
+        [expand(form)]
+      end
+
+      def macro_error(code, form, **args)
+        line = form.respond_to?(:line) ? form.line : nil
+        column = form.respond_to?(:column) ? form.column : nil
+        Error.new(Kapusta::Errors.format(code, **args), path: @path, line:, column:)
+      end
+
+      def expand(form)
+        case form
+        when List then expand_list(form)
+        when Vec then copy_position(Vec.new(form.items.map { |item| expand(item) }), form)
+        when HashLit
+          copy_position(
+            HashLit.new(form.entries.map do |entry|
+              entry.is_a?(Array) ? [expand(entry[0]), expand(entry[1])] : entry
+            end),
+            form
+          )
+        else
+          form
+        end
+      end
+
+      def copy_position(target, source)
+        return target unless target.respond_to?(:line=) && source.respond_to?(:line)
+
+        target.line ||= source.line
+        target.column ||= source.column
+        target
+      end
+
+      def expand_list(list)
+        return list if list.empty?
+
+        head = list.head
+        if head.is_a?(Sym) && !head.is_a?(AutoGensym)
+          name = head.name
+          case name
+          when 'macro'
+            register_macro_form(list.rest)
+            return List.new([Sym.new('do')])
+          when 'macros'
+            register_macros_form(list.rest)
+            return List.new([Sym.new('do')])
+          end
+
+          key = lookup_key(name)
+          if @macros.key?(key)
+            args = list.rest
+            result = invoke_macro(key, args)
+            return copy_position(expand(result), list)
+          end
+        end
+
+        copy_position(List.new(list.items.map { |item| expand(item) }), list)
+      end
+
+      def lookup_key(name)
+        Kapusta.kebab_to_snake(name).to_sym
+      end
+
+      def register_macro_form(args)
+        name_sym, params, *body = args
+        raise macro_error(:macro_name_must_be_symbol, name_sym) unless name_sym.is_a?(Sym)
+        raise macro_error(:macro_params_must_be_vector, params) unless params.is_a?(Vec)
+
+        register(name_sym.name, params, body)
+      end
+
+      def register_macros_form(args)
+        hash_lit = args[0]
+        raise macro_error(:macros_expects_hash, hash_lit) unless hash_lit.is_a?(HashLit)
+
+        hash_lit.pairs.each do |key, value|
+          raise macro_error(:macros_entry_must_be_fn, value, form: value.inspect) unless fn_form?(value)
+
+          name = key.to_s
+          params = value.items[1]
+          body = value.items[2..]
+          raise macro_error(:macros_entry_params_must_be_vector, params) unless params.is_a?(Vec)
+
+          register(name, params, body)
+        end
+      end
+
+      def fn_form?(value)
+        value.is_a?(List) && value.head.is_a?(Sym) && %w[fn lambda λ].include?(value.head.name)
+      end
+
+      def register(source_name, params, body)
+        proc_obj = compile_macro(source_name, params, body)
+        @macros[lookup_key(source_name)] = proc_obj
+      end
+
+      def compile_macro(name, params, body)
+        lowering = Lowering.new
+        lowered_body = body.map { |form| lowering.lower(form) }
+        gensym_locals = lowering.collected_gensyms
+
+        wrapped =
+          if gensym_locals.empty?
+            List.new([Sym.new('fn'), params, *lowered_body])
+          else
+            let_bindings = gensym_locals.flat_map do |gensym_sym, prefix|
+              [gensym_sym, List.new([Sym.new('quasi-gensym'), prefix])]
+            end
+            inner = lowered_body.length == 1 ? lowered_body.first : List.new([Sym.new('do'), *lowered_body])
+            List.new([Sym.new('fn'), params, List.new([Sym.new('let'), Vec.new(let_bindings), inner])])
+          end
+
+        macro_path = @path || "(macro #{name})"
+        ruby = Compiler.compile_forms([wrapped], path: macro_path)
+        TOPLEVEL_BINDING.eval(ruby, macro_path, 1)
+      end
+
+      def invoke_macro(key, args)
+        proc_obj = @macros[key]
+        proc_obj.call(*args)
+      end
+
+      class Lowering
+        def initialize
+          @gensyms = {}
+        end
+
+        def collected_gensyms
+          @gensyms.map { |prefix, sym| [sym, prefix] }
+        end
+
+        def lower(form)
+          case form
+          when Quasiquote then copy_position(lower_quasi(form.form), form)
+          when Unquote, UnquoteSplice
+            raise Error, Kapusta::Errors.format(:unquote_outside_quasiquote)
+          when AutoGensym
+            raise Error, Kapusta::Errors.format(:auto_gensym_outside_quasiquote, name: form.name)
+          when List then copy_position(List.new(form.items.map { |item| lower(item) }), form)
+          when Vec then copy_position(Vec.new(form.items.map { |item| lower(item) }), form)
+          when HashLit
+            copy_position(
+              HashLit.new(form.entries.map do |entry|
+                entry.is_a?(Array) ? [lower(entry[0]), lower(entry[1])] : entry
+              end),
+              form
+            )
+          else
+            form
+          end
+        end
+
+        def copy_position(target, source)
+          return target unless target.respond_to?(:line=) && source.respond_to?(:line)
+
+          target.line ||= source.line
+          target.column ||= source.column
+          target
+        end
+
+        def lower_quasi(form)
+          case form
+          when AutoGensym then gensym_local_for(form.name)
+          when Sym then List.new([Sym.new('quasi-sym'), form.name])
+          when List then lower_quasi_list(form)
+          when Vec then lower_quasi_vec(form)
+          when HashLit then lower_quasi_hash(form)
+          when Unquote then lower(form.form)
+          when UnquoteSplice
+            raise Error, Kapusta::Errors.format(:unquote_splice_outside_list)
+          when Quasiquote
+            raise Error, Kapusta::Errors.format(:nested_quasiquote)
+          else
+            form
+          end
+        end
+
+        def lower_quasi_list(list)
+          items = list.items
+          return List.new([Sym.new('quasi-list')]) if items.empty?
+
+          if (tail_expr = splice_tail(items))
+            head_items = items[0...-1].map { |item| lower_quasi(item) }
+            return List.new([Sym.new('quasi-list-tail'), Vec.new(head_items), tail_expr])
+          end
+
+          lowered_items = items.map { |item| lower_quasi_item(item) }
+          List.new([Sym.new('quasi-list'), *lowered_items])
+        end
+
+        def lower_quasi_vec(vec)
+          items = vec.items
+          if (tail_expr = splice_tail(items))
+            head_items = items[0...-1].map { |item| lower_quasi(item) }
+            return List.new([Sym.new('quasi-vec-tail'), Vec.new(head_items), tail_expr])
+          end
+
+          lowered_items = items.map { |item| lower_quasi_item(item) }
+          List.new([Sym.new('quasi-vec'), *lowered_items])
+        end
+
+        def lower_quasi_hash(hash)
+          parts = []
+          hash.entries.each do |entry|
+            next unless entry.is_a?(Array)
+
+            key, value = entry
+            parts << lower_quasi(key) << lower_quasi(value)
+          end
+          List.new([Sym.new('quasi-hash'), *parts])
+        end
+
+        def lower_quasi_item(item)
+          if item.is_a?(Unquote) && unpack_call?(item.form)
+            inner = lower(item.form.items[1])
+            List.new([Sym.new('.'), inner, 0])
+          else
+            lower_quasi(item)
+          end
+        end
+
+        def splice_tail(items)
+          last = items.last
+          return unless last
+          return lower(last.form) if last.is_a?(UnquoteSplice)
+          return lower(last.form.items[1]) if last.is_a?(Unquote) && unpack_call?(last.form)
+
+          nil
+        end
+
+        def unpack_call?(form)
+          form.is_a?(List) && form.head.is_a?(Sym) && form.head.name == 'unpack'
+        end
+
+        def gensym_local_for(prefix)
+          @gensyms[prefix] ||= MacroExpander.fresh_local_gensym(prefix)
+        end
+      end
+    end
+  end
+end

data/lib/kapusta/compiler/normalizer.rb

@@ -10,9 +10,12 @@ module Kapusta
       def normalize(form)
         case form
         when List then normalize_list(form)
-        when Vec then Vec.new(form.items.map { |item| normalize(item) })
+        when Vec then inherit_position(Vec.new(form.items.map { |item| normalize(item) }), form)
         when HashLit
-          HashLit.new(form.pairs.map { |key, value| [normalize_hash_key(key), normalize(value)] })
+          inherit_position(
+            HashLit.new(form.pairs.map { |key, value| [normalize_hash_key(key), normalize(value)] }),
+            form
+          )
         else
           form
         end
@@ -32,19 +35,28 @@ module Kapusta
 
         head = list.head
         items = list.items.map { |item| normalize(item) }
-        return List.new(items) unless head.is_a?(Sym)
+        return inherit_position(List.new(items), list) unless head.is_a?(Sym)
 
         case head.name
         when 'when'
+          raise compiler_error(:when_no_body, list, form: head.name) if items[2..].empty?
+
           cond = items[1]
           body = wrap_do(items[2..])
-          List.new([Sym.new('if'), cond, body])
+          inherit_position(List.new([Sym.new('if'), cond, body]), list)
         when 'unless'
+          raise compiler_error(:when_no_body, list, form: head.name) if items[2..].empty?
+
           cond = items[1]
           body = wrap_do(items[2..])
-          List.new([Sym.new('if'), List.new([Sym.new('not'), cond]), body])
+          inherit_position(List.new([Sym.new('if'), List.new([Sym.new('not'), cond]), body]), list)
         when 'tset'
-          List.new([Sym.new('set'), List.new([Sym.new('.'), items[1], items[2]]), items[3]])
+          raise compiler_error(:tset_no_value, list) if items.length < 4
+
+          inherit_position(
+            List.new([Sym.new('set'), List.new([Sym.new('.'), items[1], items[2]]), items[3]]),
+            list
+          )
         when 'pcall'
           fn = items[1]
           args = items[2..]
@@ -65,14 +77,28 @@ module Kapusta
                                List.new([Sym.new('values'), false, List.new([handler, Sym.new('e')])])])
                    ])
         when '->', '->>', '-?>', '-?>>'
-          normalize(thread(items[1..], head.name))
+          inherit_position(normalize(thread(items[1..], head.name)), list)
         when 'doto'
-          normalize(doto(items[1..]))
+          inherit_position(normalize(doto(items[1..])), list)
         else
-          List.new(items)
+          inherit_position(List.new(items), list)
         end
       end
 
+      def inherit_position(target, source)
+        return target unless target.respond_to?(:line=) && source.respond_to?(:line)
+
+        target.line ||= source.line
+        target.column ||= source.column
+        target
+      end
+
+      def compiler_error(code, form, **args)
+        line = form.respond_to?(:line) ? form.line : nil
+        column = form.respond_to?(:column) ? form.column : nil
+        Compiler::Error.new(Kapusta::Errors.format(code, **args), line:, column:)
+      end
+
       def wrap_do(forms)
         return if forms.empty?
         return forms.first if forms.length == 1

data/lib/kapusta/compiler.rb

@@ -3,12 +3,13 @@
 require_relative 'error'
 require_relative 'compiler/normalizer'
 require_relative 'compiler/emitter'
+require_relative 'compiler/macro_expander'
 
 module Kapusta
   module Compiler
     class Error < Kapusta::Error; end
     SPECIAL_FORMS = %w[
-      fn lambda λ let local var set if when unless case match
+      fn lambda λ let local var global set if when unless case match
       while for each do values
       -> ->> -?> -?>> doto
       icollect collect fcollect accumulate faccumulate
@@ -27,12 +28,23 @@ module Kapusta
       = not= < <= > >=
       + - * / %
       print
+      macro macros import-macros
+      quasi-sym quasi-list quasi-list-tail quasi-vec quasi-vec-tail quasi-hash quasi-gensym
     ].freeze
 
     def self.compile(source, path: '(kapusta)')
       forms = Reader.read_all(source)
+      expanded = MacroExpander.new(path:).expand_all(forms)
+      compile_forms(expanded, path:)
+    rescue Kapusta::Error => e
+      raise e.with_defaults(path:)
+    end
+
+    def self.compile_forms(forms, path: '(kapusta)')
       normalized = Normalizer.new.normalize_all(forms)
       Emitter.new(path:).emit_file(normalized)
+    rescue Kapusta::Error => e
+      raise e.with_defaults(path:)
     end
 
     def self.run(source, path: '(kapusta)')

data/lib/kapusta/error.rb

@@ -1,5 +1,29 @@
 # frozen_string_literal: true
 
 module Kapusta
-  class Error < StandardError; end
+  class Error < StandardError
+    attr_reader :path, :line, :column, :reason
+
+    def initialize(reason, path: nil, line: nil, column: nil)
+      @reason = reason
+      @path = path
+      @line = line
+      @column = column
+      super(formatted)
+    end
+
+    def formatted
+      prefix = [path, line, column].compact.join(':')
+      prefix.empty? ? reason : "#{prefix}: #{reason}"
+    end
+
+    def with_defaults(path: nil, line: nil, column: nil)
+      copy = self.class.new(@reason,
+                            path: @path || path,
+                            line: @line || line,
+                            column: @column || column)
+      copy.set_backtrace(backtrace) if backtrace
+      copy
+    end
+  end
 end

data/lib/kapusta/errors.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Kapusta
+  # rubocop:disable Style/FormatStringToken
+  module Errors
+    MESSAGES = {
+      accumulate_no_iterator: 'expected initial value and iterator binding table',
+      auto_gensym_outside_quasiquote: 'auto-gensym %{name}# outside quasiquote',
+      bad_multisym: 'bad multisym: %{path}',
+      bad_set_target: 'bad set target: %{target}',
+      bad_shorthand: 'bad shorthand',
+      bind_table_dots: 'unable to bind table ...',
+      cannot_call_literal: 'cannot call literal value %{value}',
+      cannot_emit_form: 'cannot emit form: %{form}',
+      cannot_set_method_binding: 'cannot set method binding: %{name}',
+      case_no_patterns: 'expected at least one pattern/body pair',
+      case_odd_patterns: 'expected even number of pattern/body pairs',
+      case_unsupported: 'case/match clauses use patterns this compiler cannot translate',
+      could_not_destructure_literal: 'could not destructure literal',
+      could_not_read_number: 'could not read number "%{token}"',
+      counted_no_range: 'expected range to include start and stop',
+      destructure_unsupported: 'destructure pattern this compiler cannot translate: %{pattern}',
+      dot_no_args: 'expected table argument',
+      each_no_binding: 'expected binding table',
+      empty_call: 'expected a function, macro, or special to call',
+      empty_token: 'empty token',
+      expected_var: 'expected var %{name}',
+      fn_no_params: 'expected parameters table',
+      global_arity: 'expected name and value',
+      global_non_symbol_name: 'unable to bind %{type} %{value}',
+      icollect_no_iterator: 'expected iterator binding table',
+      if_no_body: 'expected condition and body',
+      import_macros_unsupported: 'import-macros is not yet supported',
+      invalid_class_name: 'invalid class name: %{name}',
+      invalid_module_name: 'invalid module name: %{name}',
+      let_no_body: 'expected body expression',
+      let_odd_bindings: 'expected even number of name/value bindings',
+      local_arity: '%{form}: expected name and value',
+      macro_name_must_be_symbol: 'macro name must be a symbol',
+      macro_params_must_be_vector: 'macro params must be a vector',
+      macro_unsafe_bind: 'macro tried to bind %{name} without gensym',
+      macros_entry_must_be_fn: 'macros entry value must be a fn form, got %{form}',
+      macros_entry_params_must_be_vector: 'macros entry params must be a vector',
+      macros_expects_hash: 'macros expects a hash literal',
+      nested_quasiquote: 'nested quasiquote is not supported',
+      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',
+      special_must_be_toplevel: '%{name} must appear at the top level and is consumed by the macro expander',
+      tset_no_value: 'tset: expected table, key, and value arguments',
+      unclosed_delimiter: "unclosed opening delimiter '%{char}'",
+      undefined_symbol: 'undefined symbol: %{name}',
+      unexpected_closing_delimiter: "unexpected closing delimiter '%{char}'",
+      unexpected_eof: 'unexpected eof',
+      unknown_special_form: 'unknown special form: %{name}',
+      unquote_outside_quasiquote: 'unquote outside quasiquote',
+      unquote_splice_outside_list: 'unquote-splice must appear inside a quoted list/vec',
+      unterminated_string: 'unterminated string',
+      vararg_with_operator: 'tried to use vararg with operator',
+      when_no_body: '%{form}: expected body'
+    }.freeze
+
+    def self.format(code, **args)
+      template = MESSAGES.fetch(code) { raise ArgumentError, "unknown error code: #{code.inspect}" }
+      args.empty? ? template.dup : (template % args)
+    end
+  end
+  # rubocop:enable Style/FormatStringToken
+end