kapusta 0.5.0 → 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

@@ -89,6 +89,8 @@ 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)

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,7 +24,6 @@ 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',
@@ -46,16 +46,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.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'uri'
+require_relative '../kapusta'
+require_relative 'formatter'
+
+module Kapusta
+  class LSP
+    NOT_INITIALIZED = -32_002
+    METHOD_NOT_FOUND = -32_601
+    SEVERITY_ERROR = 1
+    FULL_SYNC = 1
+
+    def self.start(input: $stdin, output: $stdout, log: $stderr)
+      new(input:, output:, log:).run
+    end
+
+    def initialize(input:, output:, log:)
+      @input = input.binmode
+      @output = output.binmode
+      @log = log
+      @sources = {}
+      @initialized = false
+      @shutdown = false
+    end
+
+    def run
+      until (message = read_message).nil?
+        handle(message)
+      end
+    end
+
+    private
+
+    def read_message
+      headers = read_headers
+      return if headers.nil?
+
+      raw_length = headers['Content-Length']
+      return if raw_length.nil?
+
+      length = Integer(raw_length, 10, exception: false)
+      return if length.nil? || length.negative?
+
+      body = @input.read(length)
+      return if body.nil?
+
+      JSON.parse(body.force_encoding(Encoding::UTF_8))
+    rescue JSON::ParserError => e
+      log("parse error: #{e.message}")
+      nil
+    end
+
+    def read_headers
+      headers = {}
+      loop do
+        line = @input.gets
+        return if line.nil?
+        break if line.chomp.empty?
+
+        name, value = line.chomp.split(': ', 2)
+        headers[name] = value if name && value
+      end
+      headers
+    end
+
+    def write_message(payload)
+      body = JSON.generate(payload)
+      @output.write("Content-Length: #{body.bytesize}\r\n\r\n#{body}")
+      @output.flush
+    end
+
+    def handle(message)
+      method = message['method']
+      id = message['id']
+      params = message['params'] || {}
+
+      return handle_pre_init(method, id, params) unless @initialized || method == 'initialize' || method == 'exit'
+
+      dispatch(method, id, params)
+    rescue StandardError => e
+      log("#{e.class}: #{e.message}")
+      log(e.backtrace.first(5).join("\n"))
+      reply_error(id, METHOD_NOT_FOUND, e.message)
+    end
+
+    def handle_pre_init(method, id, _params)
+      return if id.nil?
+
+      reply_error(id, NOT_INITIALIZED, "received #{method} before initialize")
+    end
+
+    def dispatch(method, id, params)
+      case method
+      when 'initialize'
+        @initialized = true
+        reply(id, initialize_result)
+      when 'initialized' then nil
+      when 'shutdown'
+        @shutdown = true
+        reply(id, nil)
+      when 'exit' then exit(@shutdown ? 0 : 1)
+      when 'textDocument/didOpen' then on_did_open(params)
+      when 'textDocument/didChange' then on_did_change(params)
+      when 'textDocument/didSave' then on_did_save(params)
+      when 'textDocument/didClose' then on_did_close(params)
+      when 'textDocument/formatting' then reply(id, formatting(params))
+      else
+        reply_error(id, METHOD_NOT_FOUND, "method not found: #{method}")
+      end
+    end
+
+    def reply(id, result)
+      return if id.nil?
+
+      write_message(jsonrpc: '2.0', id:, result:)
+    end
+
+    def reply_error(id, code, message)
+      return if id.nil?
+
+      write_message(jsonrpc: '2.0', id:, error: { code:, message: })
+    end
+
+    def notify(method, params)
+      write_message(jsonrpc: '2.0', method:, params:)
+    end
+
+    def initialize_result
+      {
+        capabilities: {
+          textDocumentSync: { openClose: true, change: FULL_SYNC, save: { includeText: false } },
+          documentFormattingProvider: true
+        },
+        serverInfo: { name: 'kapusta-ls', version: Kapusta::VERSION }
+      }
+    end
+
+    def on_did_open(params)
+      doc = params['textDocument'] || {}
+      uri = doc['uri']
+      return unless uri
+
+      version = doc['version']
+      text = doc['text'] || ''
+      store(uri, text, version)
+      publish_diagnostics(uri, text, version)
+    end
+
+    def on_did_change(params)
+      uri = params.dig('textDocument', 'uri')
+      version = params.dig('textDocument', 'version')
+      changes = params['contentChanges'] || []
+      return if uri.nil? || changes.empty?
+
+      text = changes.last['text']
+      store(uri, text, version)
+      publish_diagnostics(uri, text, version)
+    end
+
+    def on_did_save(params)
+      uri = params.dig('textDocument', 'uri')
+      entry = @sources[uri]
+      return unless entry
+
+      publish_diagnostics(uri, entry[:text], entry[:version])
+    end
+
+    def on_did_close(params)
+      uri = params.dig('textDocument', 'uri')
+      return unless uri
+
+      @sources.delete(uri)
+      notify('textDocument/publishDiagnostics', { uri:, diagnostics: [] })
+    end
+
+    def formatting(params)
+      uri = params.dig('textDocument', 'uri')
+      entry = @sources[uri]
+      return [] unless entry
+
+      formatted = Kapusta::Formatter.format(entry[:text], path: uri_to_path(uri))
+      return [] if formatted == entry[:text]
+
+      [{ range: full_range(entry[:text]), newText: formatted }]
+    rescue Kapusta::Error
+      []
+    end
+
+    def store(uri, text, version)
+      @sources[uri] = { text:, version: }
+    end
+
+    def publish_diagnostics(uri, text, version)
+      diagnostics = collect_diagnostics(text, uri_to_path(uri))
+      params = { uri:, diagnostics: }
+      params[:version] = version unless version.nil?
+      notify('textDocument/publishDiagnostics', params)
+    end
+
+    def collect_diagnostics(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
+
+    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
+
+    def uri_to_path(uri)
+      return unless uri
+
+      parsed = URI.parse(uri)
+      return URI::DEFAULT_PARSER.unescape(parsed.path) if parsed.scheme == 'file'
+
+      uri
+    rescue URI::InvalidURIError
+      uri
+    end
+
+    def log(message)
+      @log.puts "kapusta-ls: #{message}"
+    end
+  end
+end

data/lib/kapusta/reader.rb

@@ -270,8 +270,6 @@ module Kapusta
       start = @pos
       advance until delim?(peek)
       token = @src[start...@pos]
-      raise reader_error(:empty_token, position) if token.empty?
-
       parse_atom(token, position)
     end
 

data/lib/kapusta/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kapusta
-  VERSION = '0.5.0'
+  VERSION = '0.7.0'
 end