kapusta 0.5.0 → 0.8.0

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
@@ -57,25 +59,8 @@ module Kapusta
             List.new([Sym.new('set'), List.new([Sym.new('.'), items[1], items[2]]), items[3]]),
             list
           )
-        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')])])])
-                   ])
+        when *LuaCompat::SPECIAL_FORMS
+          normalize_lua_compat_form(head.name, items)
         when '->', '->>', '-?>', '-?>>'
           inherit_position(normalize(thread(items[1..], head.name)), list)
         when 'doto'

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,7 +9,7 @@ require_relative 'compiler/macro_expander'
 module Kapusta
   module Compiler
     class Error < Kapusta::Error; end
-    SPECIAL_FORMS = %w[
+    CORE_SPECIAL_FORMS = %w[
       fn lambda λ let local var global set if when unless case match
       while for each do values
       -> ->> -?> -?>> doto
@@ -23,7 +24,7 @@ module Kapusta
       raise
       ivar cvar gvar
       ruby
-      tset pcall xpcall
+      tset
       and or not
       = not= < <= > >=
       + - * / %
@@ -31,6 +32,7 @@ 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)

data/lib/kapusta/errors.rb

@@ -14,6 +14,7 @@ module Kapusta
       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',
@@ -23,14 +24,18 @@ module Kapusta
       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',
+      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',
@@ -46,16 +51,17 @@ module Kapusta
       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',
+      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

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 = []

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