kapusta 0.4.1 → 0.7.0

data/lib/kapusta/compiler/lua_compat.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Kapusta
+  module Compiler
+    module LuaCompat
+      SPECIAL_FORMS = %w[pcall xpcall].freeze
+      ITERATOR_FORMS = %w[ipairs pairs].freeze
+
+      def self.special_form?(name)
+        SPECIAL_FORMS.include?(name)
+      end
+
+      def self.iterator_form?(name)
+        ITERATOR_FORMS.include?(name)
+      end
+
+      module Normalization
+        private
+
+        def normalize_lua_compat_form(name, items)
+          case name
+          when 'pcall' then normalize_lua_pcall(items)
+          when 'xpcall' then normalize_lua_xpcall(items)
+          end
+        end
+
+        def normalize_lua_pcall(items)
+          fn = items[1]
+          args = items[2..]
+          List.new([
+                     Sym.new('try'),
+                     List.new([Sym.new('values'), true, List.new([fn, *args])]),
+                     List.new([Sym.new('catch'), Sym.new('StandardError'), Sym.new('e'),
+                               List.new([Sym.new('values'), false, Sym.new('e')])])
+                   ])
+        end
+
+        def normalize_lua_xpcall(items)
+          fn = items[1]
+          handler = items[2]
+          args = items[3..]
+          List.new([
+                     Sym.new('try'),
+                     List.new([Sym.new('values'), true, List.new([fn, *args])]),
+                     List.new([Sym.new('catch'), Sym.new('StandardError'), Sym.new('e'),
+                               List.new([Sym.new('values'), false, List.new([handler, Sym.new('e')])])])
+                   ])
+        end
+      end
+
+      module Emission
+        private
+
+        def emit_lua_compat_inject(iter_expr, binding_pats, body_env, env, current_scope, acc_var,
+                                   init_code, body_forms)
+          return unless lua_iterator_expr?(iter_expr)
+
+          case iter_expr.head.name
+          when 'ipairs'
+            emit_lua_ipairs_inject(iter_expr, binding_pats, body_env, env, current_scope,
+                                   acc_var, init_code, body_forms)
+          when 'pairs'
+            emit_lua_pairs_inject(iter_expr, binding_pats, body_env, env, current_scope,
+                                  acc_var, init_code, body_forms)
+          end
+        end
+
+        def emit_lua_compat_iteration(iter_expr, binding_pats, env, current_scope, method:,
+                                      extra_block_param: nil, &block)
+          return unless lua_iterator_expr?(iter_expr)
+
+          case iter_expr.head.name
+          when 'ipairs'
+            emit_lua_ipairs_iteration(iter_expr, binding_pats, env, current_scope,
+                                      method:, extra_block_param:, &block)
+          when 'pairs'
+            emit_lua_pairs_iteration(iter_expr, binding_pats, env, current_scope,
+                                     method:, extra_block_param:, &block)
+          end
+        end
+
+        def lua_iterator_expr?(expr)
+          expr.is_a?(List) && expr.head.is_a?(Sym) && LuaCompat.iterator_form?(expr.head.name)
+        end
+
+        def emit_lua_ipairs_inject(iter_expr, binding_pats, body_env, env, current_scope, acc_var,
+                                   init_code, body_forms)
+          coll_code = emit_expr(iter_expr.items[1], env, current_scope)
+          value_var, value_bind = bind_iteration_param(binding_pats[1], 'value', body_env)
+          if ignored_pattern?(binding_pats[0])
+            body_code, = emit_sequence(body_forms, body_env, current_scope, allow_method_definitions: false)
+            return inject_block(coll_code, "#{acc_var}, #{value_var}", init_code, value_bind || '', body_code)
+          end
+
+          index_var, index_bind = bind_iteration_param(binding_pats[0], 'index', body_env)
+          bind_code = [index_bind, value_bind].compact.join("\n")
+          body_code, = emit_sequence(body_forms, body_env, current_scope, allow_method_definitions: false)
+          inject_block("#{coll_code}.each_with_index", "#{acc_var}, (#{value_var}, #{index_var})",
+                       init_code, bind_code, body_code)
+        end
+
+        def emit_lua_pairs_inject(iter_expr, binding_pats, body_env, env, current_scope, acc_var,
+                                  init_code, body_forms)
+          key_var, key_bind = bind_iteration_param(binding_pats[0], 'key', body_env)
+          value_var, value_bind = bind_iteration_param(binding_pats[1], 'value', body_env)
+          bind_code = [key_bind, value_bind].compact.join("\n")
+          body_code, = emit_sequence(body_forms, body_env, current_scope, allow_method_definitions: false)
+          coll_code = emit_expr(iter_expr.items[1], env, current_scope)
+          inject_block(coll_code, "#{acc_var}, (#{key_var}, #{value_var})",
+                       init_code, bind_code, body_code)
+        end
+
+        def emit_lua_ipairs_iteration(iter_expr, binding_pats, env, current_scope, method:,
+                                      extra_block_param: nil, &block)
+          body_env = env.child
+          value_var, value_bind = bind_iteration_param(binding_pats[1], 'value', body_env)
+          coll_code = emit_expr(iter_expr.items[1], env, current_scope)
+          if ignored_pattern?(binding_pats[0])
+            bind_code = value_bind || ''
+            body_code = block.call(body_env)
+            params = extra_block_param ? "#{value_var}, #{extra_block_param}" : value_var
+            return iteration_block("#{coll_code}.#{method} do |#{params}|", bind_code, body_code)
+          end
+
+          index_var, index_bind = bind_iteration_param(binding_pats[0], 'index', body_env)
+          bind_code = [index_bind, value_bind].compact.join("\n")
+          body_code = block.call(body_env)
+          receiver = method == 'each' ? "#{coll_code}.each_with_index" : "#{coll_code}.each_with_index.#{method}"
+          inner_params = "#{value_var}, #{index_var}"
+          params = extra_block_param ? "(#{inner_params}), #{extra_block_param}" : inner_params
+          iteration_block("#{receiver} do |#{params}|", bind_code, body_code)
+        end
+
+        def emit_lua_pairs_iteration(iter_expr, binding_pats, env, current_scope, method:,
+                                     extra_block_param: nil, &block)
+          body_env = env.child
+          key_var, key_bind = bind_iteration_param(binding_pats[0], 'key', body_env)
+          value_var, value_bind = bind_iteration_param(binding_pats[1], 'value', body_env)
+          bind_code = [key_bind, value_bind].compact.join("\n")
+          body_code = block.call(body_env)
+          coll_code = emit_expr(iter_expr.items[1], env, current_scope)
+          inner_params = "#{key_var}, #{value_var}"
+          params = extra_block_param ? "(#{inner_params}), #{extra_block_param}" : inner_params
+          iteration_block("#{coll_code}.#{method} do |#{params}|", bind_code, body_code)
+        end
+      end
+    end
+  end
+end

data/lib/kapusta/compiler/macro_expander.rb

@@ -19,8 +19,9 @@ module Kapusta
         end
       end
 
-      def initialize
+      def initialize(path: nil)
         @macros = {}
+        @path = path
       end
 
       def expand_all(forms)
@@ -39,25 +40,42 @@ module Kapusta
             register_macros_form(form.rest)
             return []
           when 'import-macros'
-            raise Error, 'import-macros is not yet supported'
+            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 Vec.new(form.items.map { |item| expand(item) })
+        when Vec then copy_position(Vec.new(form.items.map { |item| expand(item) }), form)
         when HashLit
-          HashLit.new(form.entries.map do |entry|
-            entry.is_a?(Array) ? [expand(entry[0]), expand(entry[1])] : entry
-          end)
+          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?
 
@@ -71,17 +89,19 @@ module Kapusta
           when 'macros'
             register_macros_form(list.rest)
             return List.new([Sym.new('do')])
+          when 'import-macros'
+            raise macro_error(:import_macros_unsupported, list)
           end
 
           key = lookup_key(name)
           if @macros.key?(key)
             args = list.rest
             result = invoke_macro(key, args)
-            return expand(result)
+            return copy_position(expand(result), list)
           end
         end
 
-        List.new(list.items.map { |item| expand(item) })
+        copy_position(List.new(list.items.map { |item| expand(item) }), list)
       end
 
       def lookup_key(name)
@@ -90,23 +110,23 @@ module Kapusta
 
       def register_macro_form(args)
         name_sym, params, *body = args
-        raise Error, 'macro name must be a symbol' unless name_sym.is_a?(Sym)
-        raise Error, 'macro params must be a vector' unless params.is_a?(Vec)
+        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 Error, 'macros expects a hash literal' unless hash_lit.is_a?(HashLit)
+        raise macro_error(:macros_expects_hash, hash_lit) unless hash_lit.is_a?(HashLit)
 
         hash_lit.pairs.each do |key, value|
-          raise Error, "macros entry value must be a fn form, got #{value.inspect}" unless fn_form?(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 Error, 'macros entry params must be a vector' unless params.is_a?(Vec)
+          raise macro_error(:macros_entry_params_must_be_vector, params) unless params.is_a?(Vec)
 
           register(name, params, body)
         end
@@ -137,8 +157,9 @@ module Kapusta
             List.new([Sym.new('fn'), params, List.new([Sym.new('let'), Vec.new(let_bindings), inner])])
           end
 
-        ruby = Compiler.compile_forms([wrapped], path: "(macro #{name})")
-        TOPLEVEL_BINDING.eval(ruby, "(macro #{name})", 1)
+        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)
@@ -157,22 +178,33 @@ module Kapusta
 
         def lower(form)
           case form
-          when Quasiquote then lower_quasi(form.form)
+          when Quasiquote then copy_position(lower_quasi(form.form), form)
           when Unquote, UnquoteSplice
-            raise Error, 'unquote outside quasiquote'
+            raise Error, Kapusta::Errors.format(:unquote_outside_quasiquote)
           when AutoGensym
-            raise Error, "auto-gensym #{form.name}# outside quasiquote"
-          when List then List.new(form.items.map { |item| lower(item) })
-          when Vec then Vec.new(form.items.map { |item| lower(item) })
+            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
-            HashLit.new(form.entries.map do |entry|
-              entry.is_a?(Array) ? [lower(entry[0]), lower(entry[1])] : entry
-            end)
+            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)
@@ -182,9 +214,9 @@ module Kapusta
           when HashLit then lower_quasi_hash(form)
           when Unquote then lower(form.form)
           when UnquoteSplice
-            raise Error, 'unquote-splice must appear inside a quoted list/vec'
+            raise Error, Kapusta::Errors.format(:unquote_splice_outside_list)
           when Quasiquote
-            raise Error, 'nested quasiquote is not supported'
+            raise Error, Kapusta::Errors.format(:nested_quasiquote)
           else
             form
           end

data/lib/kapusta/compiler/normalizer.rb

@@ -3,6 +3,8 @@
 module Kapusta
   module Compiler
     class Normalizer
+      include LuaCompat::Normalization
+
       def normalize_all(forms)
         forms.map { |form| normalize(form) }
       end
@@ -10,9 +12,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,47 +37,53 @@ 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]])
-        when 'pcall'
-          fn = items[1]
-          args = items[2..]
-          List.new([
-                     Sym.new('try'),
-                     List.new([Sym.new('values'), true, List.new([fn, *args])]),
-                     List.new([Sym.new('catch'), Sym.new('StandardError'), Sym.new('e'),
-                               List.new([Sym.new('values'), false, Sym.new('e')])])
-                   ])
-        when 'xpcall'
-          fn = items[1]
-          handler = items[2]
-          args = items[3..]
-          List.new([
-                     Sym.new('try'),
-                     List.new([Sym.new('values'), true, List.new([fn, *args])]),
-                     List.new([Sym.new('catch'), Sym.new('StandardError'), Sym.new('e'),
-                               List.new([Sym.new('values'), false, List.new([handler, Sym.new('e')])])])
-                   ])
+          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 *LuaCompat::SPECIAL_FORMS
+          normalize_lua_compat_form(head.name, items)
         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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'error'
+require_relative 'compiler/lua_compat'
 require_relative 'compiler/normalizer'
 require_relative 'compiler/emitter'
 require_relative 'compiler/macro_expander'
@@ -8,8 +9,8 @@ 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
+    CORE_SPECIAL_FORMS = %w[
+      fn lambda λ let local var global set if when unless case match
       while for each do values
       -> ->> -?> -?>> doto
       icollect collect fcollect accumulate faccumulate
@@ -23,7 +24,7 @@ module Kapusta
       raise
       ivar cvar gvar
       ruby
-      tset pcall xpcall
+      tset
       and or not
       = not= < <= > >=
       + - * / %
@@ -31,16 +32,21 @@ module Kapusta
       macro macros import-macros
       quasi-sym quasi-list quasi-list-tail quasi-vec quasi-vec-tail quasi-hash quasi-gensym
     ].freeze
+    SPECIAL_FORMS = (CORE_SPECIAL_FORMS + LuaCompat::SPECIAL_FORMS).freeze
 
     def self.compile(source, path: '(kapusta)')
       forms = Reader.read_all(source)
-      expanded = MacroExpander.new.expand_all(forms)
+      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,70 @@
+# 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_no_subject: 'missing subject',
+      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',
+      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',
+      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',
+      unexpected_vararg: 'unexpected vararg',
+      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_not_last: 'expected vararg as last parameter',
+      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

data/lib/kapusta/formatter.rb

@@ -10,6 +10,10 @@ module Kapusta
 
     PIPELINE_FORMS = %w[-> ->> -?> -?>> doto].freeze
 
+    def self.format(source, path: nil)
+      new([]).send(:format_source, source, path)
+    end
+
     def initialize(argv)
       @mode = :stdout
       @files = []
@@ -27,7 +31,8 @@ module Kapusta
 
       formatted = @files.map do |path|
         original = read_source(path)
-        [path, original, format_source(original)]
+        validate_kapusta_source(original, path)
+        [path, original, format_source(original, path)]
       end
 
       case @mode
@@ -48,13 +53,17 @@ module Kapusta
       end
 
       0
-    rescue Error => e
-      warn e.message
+    rescue Kapusta::Error => e
+      warn e.formatted
       1
     end
 
     private
 
+    def validate_kapusta_source(source, path)
+      Kapusta::Compiler.compile(source, path:)
+    end
+
     def parse_args(argv)
       argv.each do |arg|
         case arg
@@ -99,7 +108,7 @@ module Kapusta
       $stdin.read
     end
 
-    def format_source(source)
+    def format_source(source, path = nil)
       forms = Reader.read_all(source, preserve_comments: true)
       entries = top_level_entries(forms)
       return '' if entries.empty?
@@ -110,8 +119,10 @@ module Kapusta
         output << render_top_level_entry(entry)
       end
       output << "\n"
+    rescue Kapusta::Error => e
+      raise e.with_defaults(path:)
     rescue StandardError => e
-      raise Error, e.message
+      raise Error.new(e.message, path:)
     end
 
     def separator_for(_previous, _current)