kapusta 0.7.0 → 0.9.0

data/lib/kapusta/compiler/macro_lowerer.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require_relative 'macro_gensym'
+
+module Kapusta
+  module Compiler
+    class MacroLowerer
+      FN_HEADS = %w[fn lambda λ].freeze
+
+      def self.compile(params:, body:, path:, error_class:)
+        callable = new(error_class:).callable_form(params, body)
+        ruby = Compiler.compile_forms([callable], path:)
+        TOPLEVEL_BINDING.eval(ruby, path, 1)
+      end
+
+      def self.lower_module_form(form, error_class:)
+        new(error_class:).lower_module_form(form)
+      end
+
+      def initialize(error_class:)
+        @error_class = error_class
+        @gensyms = {}
+      end
+
+      def callable_form(params, body)
+        List.new([Sym.new('fn'), params, *lowered_body_with_gensyms(body)])
+      end
+
+      def lower_module_form(form)
+        return lower_fn_form(form) if fn_form?(form)
+
+        lower(form)
+      end
+
+      def lower(form)
+        case form
+        when Quasiquote then copy_position(lower_quasi(form.form), form)
+        when Unquote, UnquoteSplice
+          raise @error_class, Kapusta::Errors.format(:unquote_outside_quasiquote)
+        when AutoGensym
+          raise @error_class, 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
+
+      private
+
+      def lower_fn_form(form)
+        items = form.items
+        if items[1].is_a?(Sym) && items[2].is_a?(Vec)
+          name_sym = items[1]
+          params = items[2]
+          body = items[3..] || []
+        elsif items[1].is_a?(Vec)
+          name_sym = nil
+          params = items[1]
+          body = items[2..] || []
+        else
+          return form
+        end
+
+        head_items = name_sym ? [form.head, name_sym, params] : [form.head, params]
+        List.new(head_items + lowered_body_with_gensyms(body))
+      end
+
+      def lowered_body_with_gensyms(body)
+        lowered_body = body.map { |item| lower(item) }
+        wrap_gensyms(collected_gensyms, lowered_body)
+      end
+
+      def collected_gensyms
+        @gensyms.map { |prefix, sym| [sym, prefix] }
+      end
+
+      def wrap_gensyms(gensyms, body)
+        return body if gensyms.empty?
+
+        bindings = gensyms.flat_map { |sym, prefix| [sym, List.new([Sym.new('quasi-gensym'), prefix])] }
+        wrapped = body.length == 1 ? body[0] : List.new([Sym.new('do'), *body])
+        [List.new([Sym.new('let'), Vec.new(bindings), wrapped])]
+      end
+
+      def fn_form?(form)
+        form.is_a?(List) && form.head.is_a?(Sym) && FN_HEADS.include?(form.head.name)
+      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_class, Kapusta::Errors.format(:unquote_splice_outside_list)
+        when Quasiquote
+          raise @error_class, 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] ||= MacroGensym.fresh_local_gensym(prefix)
+      end
+    end
+  end
+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/errors.rb

@@ -30,7 +30,12 @@ module Kapusta
       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',
+      import_macros_cycle: 'import-macros cycle detected for module %{module}',
+      import_macros_destructure_invalid: 'import-macros expects a hash literal as first argument',
+      import_macros_macro_not_found: 'import-macros: macro %{macro} not exported by module %{module}',
+      import_macros_module_invalid: 'import-macros expects a symbol or string module name',
+      import_macros_module_no_exports: 'import-macros: module %{module} has no export table',
+      import_macros_module_not_found: 'import-macros: module %{module} not found',
       invalid_class_name: 'invalid class name: %{name}',
       invalid_module_name: 'invalid module name: %{name}',
       let_no_body: 'expected body expression',

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)

data/lib/kapusta/lsp/definition.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative 'rename'
+
+module Kapusta
+  class LSP
+    module Definition
+      module_function
+
+      def find(uri, text, line_zero, character, workspace_index:)
+        target = Rename.locate(text, line_zero, character)
+        return unless target
+
+        case target.kind
+        when :local, :toplevel_fn, :constant
+          location_for_binding(uri, target.binding) if target.binding
+        when :macro
+          locations_for_macro(uri, target.binding, workspace_index)
+        when :free_toplevel
+          locations_for_toplevel(target.name, workspace_index)
+        when :free_constant
+          locations_for_constant(target.segment_prefix, workspace_index)
+        end
+      end
+
+      def locations_for_macro(uri, binding, workspace_index)
+        return unless binding
+
+        case binding.kind
+        when :macro
+          location_for_binding(uri, binding)
+        when :macro_import
+          def_uri, def_binding = workspace_index.find_macro_definition(
+            uri, binding.import_module, binding.import_key
+          )
+          location_for_binding(def_uri, def_binding) if def_uri && def_binding
+        end
+      end
+
+      def location_for_binding(uri, binding)
+        { uri:, range: binding_range(binding) }
+      end
+
+      def locations_for_toplevel(name, workspace_index)
+        defs = workspace_index.toplevel_fn_definitions(name)
+        return if defs.empty?
+
+        defs.map { |uri, b| { uri:, range: binding_range(b) } }
+      end
+
+      def locations_for_constant(prefix, workspace_index)
+        defs = workspace_index.constant_definitions_with_prefix(prefix)
+        return if defs.empty?
+
+        defs.map { |uri, b| { uri:, range: binding_range(b) } }
+      end
+
+      def binding_range(binding)
+        line = binding.line - 1
+        {
+          start: { line:, character: binding.column - 1 },
+          end: { line:, character: binding.end_column - 1 }
+        }
+      end
+    end
+  end
+end

data/lib/kapusta/lsp/diagnostics.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Kapusta
+  class LSP
+    module Diagnostics
+      SEVERITY_ERROR = 1
+
+      module_function
+
+      def collect(text, path)
+        Kapusta.compile(text, path: path || '(buffer)')
+        []
+      rescue Kapusta::Error => e
+        [diagnostic_from(e, text)]
+      end
+
+      def diagnostic_from(error, text)
+        line = [(error.line || 1) - 1, 0].max
+        column = [(error.column || 1) - 1, 0].max
+
+        {
+          range: {
+            start: { line:, character: column },
+            end: { line:, character: column + token_length(text, line, column) }
+          },
+          severity: SEVERITY_ERROR,
+          source: 'kapusta-ls',
+          message: error.reason
+        }
+      end
+
+      def token_length(text, line, column)
+        source_line = text.lines[line]
+        return 1 unless source_line
+
+        tail = source_line[column..] || ''
+        match = tail.match(/\A[^\s()\[\]{}";`,]+/)
+        match && match[0].length.positive? ? match[0].length : 1
+      end
+    end
+  end
+end

data/lib/kapusta/lsp/formatting.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative '../formatter'
+
+module Kapusta
+  class LSP
+    module Formatting
+      module_function
+
+      def text_edits(text, path)
+        formatted = Kapusta::Formatter.format(text, path:)
+        return [] if formatted == text
+
+        [{ range: full_range(text), newText: formatted }]
+      rescue Kapusta::Error
+        []
+      end
+
+      def full_range(text)
+        lines = text.split("\n", -1)
+        end_line = [lines.length - 1, 0].max
+        end_character = lines.last ? lines.last.length : 0
+        {
+          start: { line: 0, character: 0 },
+          end: { line: end_line, character: end_character }
+        }
+      end
+    end
+  end
+end

data/lib/kapusta/lsp/identifier.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative '../compiler'
+
+module Kapusta
+  class LSP
+    module Identifier
+      DELIM_CHARS = '()[]{}";`,'
+
+      module_function
+
+      def valid_local?(name)
+        return false if name.nil? || name.empty?
+        return false if name.match?(/\s/)
+        return false if name.match?(/[#{Regexp.escape(DELIM_CHARS)}]/o)
+        return false if name.match?(/\A-?\d/)
+        return false if name.include?('.')
+        return false if Kapusta::Compiler::SPECIAL_FORMS.include?(name)
+
+        true
+      end
+
+      def valid_constant_segment?(segment)
+        !segment.nil? && segment.match?(/\A[A-Z]\w*\z/)
+      end
+    end
+  end
+end