kapusta 0.4.1 → 0.5.0

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

@@ -7,6 +7,8 @@ module Kapusta
         private
 
         def emit_lookup(args, env, current_scope)
+          emit_error!(:dot_no_args) if args.empty?
+
           object_code = emit_expr(args[0], env, current_scope)
           keys = args[1..].map { |arg| emit_expr(arg, env, current_scope) }
           return object_code if keys.empty?
@@ -91,7 +93,7 @@ module Kapusta
 
         def emit_module_wrapper(name_sym, body)
           segments = constant_segments(name_sym)
-          emit_error!("invalid module name: #{name_sym.name}") unless segments
+          emit_error!(:invalid_module_name, name: name_sym.name) unless segments
           inner = build_nested_module(segments, body)
           ['(-> do', indent(inner), indent(segments.join('::')), 'end).call'].join("\n")
         end
@@ -105,7 +107,7 @@ module Kapusta
 
         def emit_class_wrapper(name_sym, supers, env, body)
           segments = constant_segments(name_sym)
-          emit_error!("invalid class name: #{name_sym.name}") unless segments
+          emit_error!(:invalid_class_name, name: name_sym.name) unless segments
           super_code = class_super_code(supers, env)
           inner = build_nested_class(segments, super_code, body)
           ['(-> do', indent(inner), indent(segments.join('::')), 'end).call'].join("\n")
@@ -434,7 +436,7 @@ module Kapusta
           return 'ARGV' if name == 'ARGV'
           return name if name.match?(/\A[A-Z]/)
 
-          emit_error!("undefined symbol: #{name}")
+          emit_error!(:undefined_symbol, name:)
         end
 
         def emit_gvar(sym)
@@ -458,7 +460,7 @@ module Kapusta
               const_path << segments[idx]
               idx += 1
             end
-            emit_error!("bad multisym: #{segments.join('.')}") if const_path.empty?
+            emit_error!(:bad_multisym, path: segments.join('.')) if const_path.empty?
 
             [const_path.join('::'), segments[idx..]]
           end

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

@@ -10,6 +10,7 @@ module Kapusta
           if pattern.is_a?(Sym)
             return ['', env] if pattern.name == '_'
 
+            validate_binding_symbol!(pattern)
             ruby_name = define_local(env, pattern)
             return ["#{ruby_name} = #{value_code}", env]
           end
@@ -17,7 +18,26 @@ module Kapusta
           native = try_emit_native_pattern_bind(pattern, value_code, env)
           return native if native
 
-          emit_error!("destructure pattern this compiler cannot translate: #{pattern.inspect}")
+          emit_error!(:destructure_unsupported, pattern: pattern.inspect)
+        end
+
+        def validate_binding_symbol!(sym)
+          name = sym.name
+          emit_error!(:shadowed_special, name:) if Compiler::SPECIAL_FORMS.include?(name)
+          return unless sym.is_a?(MacroSym)
+
+          emit_error!(:macro_unsafe_bind, name:)
+        end
+
+        def validate_destructure_pattern!(pattern)
+          items = pattern.items
+          items.each_with_index do |item, idx|
+            emit_error!(:bind_table_dots) if item.is_a?(Sym) && item.name == '...'
+            next unless item.is_a?(Sym) && item.name == '&'
+
+            emit_error!(:rest_not_last) if idx + 2 < items.length
+            emit_error!(:rest_not_last) if idx + 1 >= items.length
+          end
         end
 
         def try_emit_native_pattern_bind(pattern, value_code, env)
@@ -32,6 +52,7 @@ module Kapusta
         end
 
         def try_emit_native_vec_bind(pattern, value_code, env)
+          validate_destructure_pattern!(pattern)
           parts = []
           deferred = []
           current_env = env

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

@@ -6,8 +6,27 @@ module Kapusta
       module Support
         private
 
-        def emit_error!(message)
-          raise Error, "#{@path}: #{message}"
+        def emit_error!(code, **args)
+          form = current_form
+          line = form.respond_to?(:line) ? form.line : nil
+          column = form.respond_to?(:column) ? form.column : nil
+          raise Error.new(Kapusta::Errors.format(code, **args), path: @path, line:, column:)
+        end
+
+        def with_current_form(form)
+          @form_stack ||= []
+          @form_stack.push(form) if positionable?(form)
+          yield
+        ensure
+          @form_stack.pop if positionable?(form)
+        end
+
+        def current_form
+          (@form_stack ||= []).last
+        end
+
+        def positionable?(form)
+          form.respond_to?(:line) && form.respond_to?(:column)
         end
 
         def emit_forms_with_headers(forms, env, current_scope, result: true)
@@ -67,27 +86,29 @@ module Kapusta
         end
 
         def emit_form_in_sequence(form, env, current_scope, allow_method_definitions:, result_needed: true)
-          if allow_method_definitions &&
-             method_definition_form?(form) &&
-             %i[toplevel module class].include?(current_scope)
-            code, env = emit_definition_form(form, env, current_scope)
-            return [code, env] if code
-          end
+          with_current_form(form) do
+            if allow_method_definitions &&
+               method_definition_form?(form) &&
+               %i[toplevel module class].include?(current_scope)
+              code, env = emit_definition_form(form, env, current_scope)
+              return [code, env] if code
+            end
 
-          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 = code.delete_suffix("\nnil") unless result_needed
-            [code, env]
-          elsif do_form?(form)
-            emit_do_form(form.rest, env, current_scope, result_needed:)
-          elsif sequence_statement_form?(form)
-            emit_sequence_statement_form(form, env, current_scope, result_needed:)
-          elsif set_new_local_form?(form, env)
-            emit_set_form(form, env, current_scope)
-          else
-            [emit_expr(form, env, current_scope), env]
+            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 = code.delete_suffix("\nnil") unless result_needed
+              [code, env]
+            elsif do_form?(form)
+              emit_do_form(form.rest, env, current_scope, result_needed:)
+            elsif sequence_statement_form?(form)
+              emit_sequence_statement_form(form, env, current_scope, result_needed:)
+            elsif set_new_local_form?(form, env)
+              emit_set_form(form, env, current_scope)
+            else
+              [emit_expr(form, env, current_scope), env]
+            end
           end
         end
 
@@ -228,6 +249,7 @@ module Kapusta
         end
 
         def parse_counted_for_bindings(bindings, env, current_scope)
+          emit_error!(:counted_no_range) if bindings.length < 3
           name_sym = bindings[0]
           loop_env = env.child
           ruby_name = define_local(loop_env, name_sym.name)

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?
 
@@ -77,11 +95,11 @@ module Kapusta
           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 +108,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 +155,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 +176,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 +212,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

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

@@ -9,7 +9,7 @@ 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
@@ -34,13 +34,17 @@ module Kapusta
 
     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,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

data/lib/kapusta/formatter.rb

@@ -27,7 +27,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 +49,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 +104,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 +115,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)