jade-lang 0.1.0

data/lib/jade/lsp/handlers.rb

@@ -0,0 +1,340 @@
+require 'pathname'
+
+module Jade
+  module LSP
+    module Handlers
+      extend self
+
+      def dispatch(state, message)
+        case message['method']
+        when 'initialize' then on_initialize(state, message)
+        when 'initialized' then [state, []]
+        when 'shutdown' then [state, [respond(message['id'], nil)]]
+        when 'exit' then [state, []]
+        when 'textDocument/didOpen' then on_did_open(state, message['params'])
+        when 'textDocument/didChange' then on_did_change(state, message['params'])
+        when 'textDocument/didSave' then [state, []]
+        when 'textDocument/didClose' then on_did_close(state, message['params'])
+        when 'textDocument/documentSymbol' then on_document_symbol(state, message)
+        when 'textDocument/hover' then on_hover(state, message)
+        when 'textDocument/definition' then on_definition(state, message)
+        when 'textDocument/references' then on_references(state, message)
+        when 'textDocument/completion' then on_completion(state, message)
+        when 'textDocument/prepareRename' then on_prepare_rename(state, message)
+        when 'textDocument/rename' then on_rename(state, message)
+        when 'textDocument/inlayHint' then on_inlay_hint(state, message)
+        when 'textDocument/formatting' then on_formatting(state, message)
+        else on_unknown(state, message)
+        end
+      end
+
+      private
+
+      def on_unknown(state, message)
+        return [state, []] unless message['id']
+
+        error = respond_error(message['id'], -32601, "method not found: #{message['method']}")
+        [state, [error]]
+      end
+
+      def on_initialize(state, message)
+        params = (message['params'] || {})
+        root = params
+          .then { it['rootUri'] || it.dig('workspaceFolders', 0, 'uri') }
+          .then { it ? it.sub(%r{\Afile://}, '') : Dir.pwd }
+
+        {
+          capabilities: {
+            textDocumentSync: { openClose: true, change: 1 },
+            positionEncoding: negotiate_encoding(params),
+            documentSymbolProvider: true,
+            hoverProvider: true,
+            definitionProvider: true,
+            referencesProvider: true,
+            completionProvider: { resolveProvider: false },
+            renameProvider: { prepareProvider: true },
+            inlayHintProvider: true,
+            documentFormattingProvider: true,
+          },
+          serverInfo: { name: 'jade-lsp', version: '0.1.0' },
+        }
+          .then { [state.with_root(root), [respond(message['id'], it)]] }
+      end
+
+      def negotiate_encoding(params)
+        params
+          .dig('capabilities', 'general', 'positionEncodings')
+          &.include?('utf-8') ? 'utf-8' : 'utf-16'
+      end
+
+      def on_did_open(state, params)
+        params['textDocument']
+          .then { state.put_buffer(it['uri'], it['text']) }
+          .then { recompile_and_publish(it) }
+      end
+
+      def on_did_change(state, params)
+        doc = params['textDocument']
+        latest = params['contentChanges'].last
+        state
+          .put_buffer(doc['uri'], latest['text'])
+          .then { recompile_and_publish(it) }
+      end
+
+      def on_did_close(state, params)
+        params['textDocument']['uri']
+          .then { recompile_and_publish(state.close(it), extra_uris: [it]) }
+      end
+
+      def on_document_symbol(state, message)
+        symbols = message
+          .dig('params', 'textDocument', 'uri')
+          .then { document_symbols_for(state, it) }
+        [state, [respond(message['id'], symbols)]]
+      end
+
+      def on_hover(state, message)
+        message['params']
+          .then { hover_for(state, it['textDocument']['uri'], it['position']) }
+          .then { [state, [respond(message['id'], it)]] }
+      end
+
+      def on_definition(state, message)
+        message['params']
+          .then { definition_for(state, it['textDocument']['uri'], it['position']) }
+          .then { [state, [respond(message['id'], it)]] }
+      end
+
+      def on_references(state, message)
+        params = message['params']
+        references_for(
+          state,
+          params['textDocument']['uri'],
+          params['position'],
+          include_declaration: params.dig('context', 'includeDeclaration'),
+        ).then { [state, [respond(message['id'], it)]] }
+      end
+
+      def on_completion(state, message)
+        [state, [respond(message['id'], Converters.completion_items)]]
+      end
+
+      def on_prepare_rename(state, message)
+        message['params']
+          .then { prepare_rename_for(state, it['textDocument']['uri'], it['position']) }
+          .then { [state, [respond(message['id'], it)]] }
+      end
+
+      def on_rename(state, message)
+        params = message['params']
+        rename_for(
+          state,
+          params['textDocument']['uri'],
+          params['position'],
+          params['newName'],
+        ).then { [state, [respond(message['id'], it)]] }
+      end
+
+      def on_inlay_hint(state, message)
+        params = message['params']
+        inlay_hints_for(
+          state, params['textDocument']['uri'], params['range'],
+        ).then { [state, [respond(message['id'], it)]] }
+      end
+
+      def on_formatting(state, message)
+        uri = message.dig('params', 'textDocument', 'uri')
+        edits = formatting_edits_for(state, uri)
+        [state, [respond(message['id'], edits)]]
+      end
+
+      def formatting_edits_for(state, uri)
+        text = state.buffers[uri]
+        return nil unless text
+
+        Converters.format_edits(text)
+      end
+
+      def inlay_hints_for(state, uri, lsp_range)
+        return [] unless state.registry
+
+        rel = Converters.relative_path(uri, state.source_root)
+        entry = state.registry.modules.each_value.find { it.source&.uri == rel }
+        return [] unless entry
+
+        start_offset = Converters.position_to_offset(
+          entry.source, lsp_range['start']['line'], lsp_range['start']['character'],
+        )
+        end_offset = Converters.position_to_offset(
+          entry.source, lsp_range['end']['line'], lsp_range['end']['character'],
+        )
+
+        Converters.inlay_hints_for(entry, start_offset..end_offset)
+      end
+
+      def prepare_rename_for(state, uri, position)
+        return nil unless state.registry
+
+        rel = Converters.relative_path(uri, state.source_root)
+        entry = state.registry.modules.each_value.find { it.source&.uri == rel }
+        return nil unless entry
+
+        offset = Converters.position_to_offset(
+          entry.source, position['line'], position['character']
+        )
+        Converters.prepare_rename_for_path(
+          entry.ast.find_at_path(offset), state.registry, entry, offset,
+        )
+      end
+
+      def rename_for(state, uri, position, new_name)
+        return nil unless state.registry
+
+        rel = Converters.relative_path(uri, state.source_root)
+        entry = state.registry.modules.each_value.find { it.source&.uri == rel }
+        return nil unless entry
+
+        Converters
+          .position_to_offset(entry.source, position['line'], position['character'])
+          .then { entry.ast.find_at_path(it) }
+          .then do |path|
+            Converters.rename_for_path(
+              path, state.registry, entry, state.source_root, new_name,
+            )
+          end
+      end
+
+      def references_for(state, uri, position, include_declaration:)
+        return nil unless state.registry
+
+        rel = Converters.relative_path(uri, state.source_root)
+        entry = state.registry.modules.each_value.find { it.source&.uri == rel }
+        return nil unless entry
+
+        Converters
+          .position_to_offset(entry.source, position['line'], position['character'])
+          .then { entry.ast.find_at_path(it) }
+          .then do |path|
+            Converters.references_for_path(
+              path, state.registry, entry, state.source_root,
+              include_declaration:,
+            )
+          end
+      end
+
+      def definition_for(state, uri, position)
+        return nil unless state.registry
+
+        rel = Converters.relative_path(uri, state.source_root)
+        entry = state.registry.modules.each_value.find { it.source&.uri == rel }
+        return nil unless entry
+
+        Converters
+          .position_to_offset(entry.source, position['line'], position['character'])
+          .then { entry.ast.find_at_path(it) }
+          .then { Converters.definition_for_path(it, state.registry, entry, state.source_root) }
+      end
+
+      def hover_for(state, uri, position)
+        return nil unless state.registry
+
+        rel = Converters.relative_path(uri, state.source_root)
+        entry = state.registry.modules.each_value.find { it.source&.uri == rel }
+        return nil unless entry
+
+        Converters
+          .position_to_offset(entry.source, position['line'], position['character'])
+          .then { Converters.hover_for_path(entry.ast.find_at_path(it), state.registry, entry) }
+      end
+
+      def document_symbols_for(state, uri)
+        return [] unless state.registry
+
+        rel = Converters.relative_path(uri, state.source_root)
+        entry = state.registry.modules.each_value.find { it.source&.uri == rel }
+        return [] unless entry
+
+        entry.ast.body.expressions
+          .filter_map { Converters.to_document_symbol(it, entry.source) }
+      end
+
+      # extra_uris always receive a publishDiagnostics, but compile output
+      # wins: if a real diagnostic came back for the URI, we send that, not
+      # an empty clear.
+      def recompile_and_publish(state, extra_uris: [])
+        if state.buffers.empty? || state.source_root.nil?
+          return [state, extra_uris.map { publish_for(it, []) }]
+        end
+
+        overlays = state.buffers
+          .to_h { |uri, text| [Converters.relative_path(uri, state.source_root), text] }
+
+        diagnostics_by_uri, registry = compile_each(state.source_root, overlays)
+
+        uris = (diagnostics_by_uri.keys + state.buffers.keys + extra_uris).uniq
+        messages = uris.map { publish_for(it, diagnostics_by_uri[it] || []) }
+
+        next_state = registry ? state.set_registry(registry) : state
+        [next_state, messages]
+      end
+
+      # Compile from each open buffer so unrelated modules still produce
+      # diagnostics. The same module reached twice yields identical
+      # diagnostics (deterministic over overlays), so Hash#merge is safe.
+      def compile_each(source_root, overlays)
+        overlays.keys.reduce([{}, nil]) do |(diag_acc, reg_acc), entry|
+          registry, diagnostics = compile(source_root, entry, overlays)
+          [diag_acc.merge(diagnostics), registry || reg_acc]
+        end
+      end
+
+      def compile(source_root, entry_path, overlays)
+        ModuleLoader
+          .load(source_root, entry_path, tolerant: true, overlays:)
+          .then { [it, collect_diagnostics(it, source_root)] }
+      rescue Jade::CompilationError => e
+        [nil, diagnostics_by_uri(e.diagnostics, source_root)]
+      rescue StandardError => e
+        $stderr.puts "[jade-lsp] compile crash: #{e.class}: #{e.message}"
+        $stderr.puts e.backtrace.first(20).join("\n")
+        [nil, {}]
+      end
+
+      def collect_diagnostics(registry, source_root)
+        registry
+          .modules
+          .each_value
+          .reject { Stdlib.is_stdlib?(it) }
+          .reject { it.source.nil? || it.diagnostics.items.empty? }
+          .reduce({}) do |acc, entry|
+            acc.merge(Converters.lsp_uri(entry.source.uri, source_root) => entry.diagnostics.items)
+          end
+      end
+
+      def diagnostics_by_uri(list, source_root)
+        list.items
+          .group_by { it.primary.source.uri }
+          .transform_keys { Converters.lsp_uri(it, source_root) }
+      end
+
+      def publish_for(uri, items)
+        notify('textDocument/publishDiagnostics', {
+          uri:,
+          diagnostics: items.map { Converters.diagnostic_to_lsp(it) },
+        })
+      end
+
+      def respond(id, result)
+        { jsonrpc: '2.0', id:, result: }
+      end
+
+      def respond_error(id, code, message)
+        { jsonrpc: '2.0', id:, error: { code:, message: } }
+      end
+
+      def notify(method, params)
+        { jsonrpc: '2.0', method:, params: }
+      end
+    end
+  end
+end

data/lib/jade/lsp/server.rb

@@ -0,0 +1,63 @@
+require 'json'
+
+module Jade
+  module LSP
+    class Server
+      def initialize(input: $stdin, output: $stdout)
+        @input = input
+        @output = output
+        @input.binmode
+        @output.binmode
+        @output.sync = true
+      end
+
+      def run
+        state = State.empty
+        loop do
+          message = read_message
+          break unless message
+
+          state, outbound = safe_dispatch(state, message)
+          outbound.each { write_message(it) }
+          break if message['method'] == 'exit'
+        end
+      end
+
+      private
+
+      def safe_dispatch(state, message)
+        Handlers.dispatch(state, message)
+      rescue StandardError => e
+        $stderr.puts "[jade-lsp] handler crash: #{e.class}: #{e.message}"
+        $stderr.puts e.backtrace.first(20).join("\n")
+        [state, []]
+      end
+
+      def read_message
+        headers = read_headers or return nil
+        length = headers['Content-Length'].to_i
+        JSON.parse(@input.read(length))
+      rescue JSON::ParserError => e
+        $stderr.puts "[jade-lsp] bad json: #{e.message}"
+        nil
+      end
+
+      def read_headers
+        headers = {}
+        while (line = @input.gets("\r\n"))
+          stripped = line.chomp("\r\n")
+          return headers if stripped.empty?
+
+          k, _, v = stripped.partition(': ')
+          headers[k] = v
+        end
+        nil
+      end
+
+      def write_message(message)
+        body = JSON.generate(message)
+        @output.write("Content-Length: #{body.bytesize}\r\n\r\n#{body}")
+      end
+    end
+  end
+end

data/lib/jade/lsp/snippets.rb

@@ -0,0 +1,100 @@
+module Jade
+  module LSP
+    module Snippets
+      Snippet = Data.define(:label, :detail, :body)
+
+      ALL = [
+        Snippet.new(
+          label: 'def',
+          detail: 'function declaration',
+          body: <<~SNIP.chomp,
+            def ${1:name}(${2:params}) -> ${3:Type}
+              ${0:body}
+            end
+          SNIP
+        ),
+        Snippet.new(
+          label: 'type',
+          detail: 'union type',
+          body: <<~SNIP.chomp,
+            type ${1:Name}
+              = ${2:Variant1}
+              | ${0:Variant2}
+          SNIP
+        ),
+        Snippet.new(
+          label: 'struct',
+          detail: 'struct declaration',
+          body: <<~SNIP.chomp,
+            struct ${1:Name} = {
+              ${2:field}: ${0:Type}
+            }
+          SNIP
+        ),
+        Snippet.new(
+          label: 'case',
+          detail: 'case expression with else fallback',
+          body: <<~SNIP.chomp,
+            case ${1:expr}
+            in ${2:pattern} then ${3:result}
+            else ${0:fallback}
+            end
+          SNIP
+        ),
+        Snippet.new(
+          label: 'if',
+          detail: 'if/then/else block',
+          body: <<~SNIP.chomp,
+            if ${1:cond} then
+              ${2:then_branch}
+            else
+              ${0:else_branch}
+            end
+          SNIP
+        ),
+        Snippet.new(
+          label: 'module',
+          detail: 'module header',
+          body: 'module ${1:Name} exposing (${0})',
+        ),
+        Snippet.new(
+          label: 'import',
+          detail: 'import declaration',
+          body: 'import ${1:Module} exposing (${0:Name})',
+        ),
+        Snippet.new(
+          label: 'interface',
+          detail: 'interface declaration',
+          body: <<~SNIP.chomp,
+            interface ${1:Name}(${2:a}) with
+              ${3:fn} : ${4:args} -> ${0:Return}
+            end
+          SNIP
+        ),
+        Snippet.new(
+          label: 'implements',
+          detail: 'interface implementation',
+          body: <<~SNIP.chomp,
+            implements ${1:Interface}(${2:Type}) with
+              ${3:method}: ${0:fn_name}
+            end
+          SNIP
+        ),
+        Snippet.new(
+          label: 'uses',
+          detail: 'interop import',
+          body: <<~SNIP.chomp,
+            uses ${1:Module} with
+              ${2:fn} : ${3:args} -> ${0:Return}
+            end
+          SNIP
+        ),
+        Snippet.new(
+          label: 'lambda',
+          detail: 'anonymous function',
+          body: '(${1:args}) -> { ${0:body} }',
+        ),
+      ].freeze
+    end
+  end
+end

data/lib/jade/lsp/state.rb

@@ -0,0 +1,25 @@
+module Jade
+  module LSP
+    State = Data.define(:source_root, :buffers, :registry) do
+      def self.empty
+        new(source_root: nil, buffers: {}, registry: nil)
+      end
+
+      def with_root(root)
+        with(source_root: root)
+      end
+
+      def put_buffer(uri, text)
+        with(buffers: buffers.merge(uri => text))
+      end
+
+      def close(uri)
+        with(buffers: buffers.except(uri))
+      end
+
+      def set_registry(reg)
+        with(registry: reg)
+      end
+    end
+  end
+end

data/lib/jade/lsp.rb

@@ -0,0 +1,16 @@
+require 'json'
+require 'pathname'
+
+require 'jade'
+require 'jade/formatter'
+require 'jade/frontend/comment_attacher'
+require 'jade/lsp/snippets'
+require 'jade/lsp/converters'
+require 'jade/lsp/state'
+require 'jade/lsp/handlers'
+require 'jade/lsp/server'
+
+module Jade
+  module LSP
+  end
+end

data/lib/jade/module_loader/cache.rb

@@ -0,0 +1,56 @@
+require 'digest'
+require 'fileutils'
+
+module Jade
+  module ModuleLoader
+    module Cache
+      extend self
+
+      MAGIC = 'jade-cache-v2'
+
+      def read(cache_dir, module_name, key)
+        path = path_for(cache_dir, module_name)
+        return nil unless File.exist?(path)
+
+        Marshal.load(File.binread(path)) => [MAGIC, ^key, interface_digest, entry]
+        [entry, interface_digest]
+      rescue StandardError, NoMatchingPatternError
+        nil
+      end
+
+      def write(cache_dir, module_name, entry, key, interface_digest)
+        path = path_for(cache_dir, module_name)
+        FileUtils.mkdir_p(File.dirname(path))
+
+        tmp = "#{path}.#{Process.pid}.tmp"
+        File.binwrite(tmp, Marshal.dump([MAGIC, key, interface_digest, entry]))
+        File.rename(tmp, path)
+      end
+
+      def clean(cache_dir)
+        FileUtils.rm_rf(cache_dir)
+      end
+
+      def compute_key(entry, dep_digests)
+        Digest::SHA256.hexdigest(
+          [compiler_fingerprint, entry.source.text, dep_digests.sort.inspect]
+            .join("\n")
+        )
+      end
+
+      def compiler_fingerprint
+        @compiler_fingerprint ||=
+          Dir[File.expand_path('../**/*.rb', __dir__)]
+            .sort
+            .map { Digest::SHA256.file(it).hexdigest }
+            .then { Digest::SHA256.hexdigest(it.join) }
+      end
+
+      private
+
+      def path_for(cache_dir, module_name)
+        File.join(cache_dir, "#{module_name.tr('.', '/')}.entry")
+      end
+    end
+  end
+end

data/lib/jade/module_loader/dependency_graph.rb

@@ -0,0 +1,23 @@
+module Jade
+  module ModuleLoader
+    DependencyGraph = Data.define(:nodes) do
+      def initialize(nodes: {})
+        super
+      end
+
+      def size
+        nodes.size
+      end
+
+      def empty?
+        nodes.empty?
+      end
+
+      def add(node, imports)
+        nodes
+          .merge(node => imports.to_set.to_a)
+          .then { with(nodes: it) }
+      end
+    end
+  end
+end

data/lib/jade/module_loader/dependency_resolver.rb

@@ -0,0 +1,48 @@
+module Jade
+  module ModuleLoader
+    module DependencyResolver
+      extend self
+
+      def resolve(entry, registry)
+        case entry.ast
+        in AST::Module(body:)
+          resolve_body(body, entry, registry)
+
+        in AST::Body
+          resolve_body(entry.ast, entry, registry)
+        end
+      end
+
+      private
+
+      def resolve_body(body, entry, registry)
+         body => AST::Body(expressions:)
+
+        expressions
+          .reduce([registry, []]) do |(acc_registry, acc_imports), ast_node|
+            case ast_node
+            in AST::ImportDeclaration(module_name:) if stdlib?(module_name, acc_registry)
+              [acc_registry, acc_imports]
+
+            in AST::ImportDeclaration(module_name:)
+              # TODO: [ModuleLoaderRefactor] This is more of DependencyLoader
+              [
+                ModuleLoader.load_import(module_name, acc_registry),
+                acc_imports + [module_name],
+              ]
+
+            else
+              [acc_registry, acc_imports]
+            end
+          end
+          .then { |registry, imports| registry.add_dependencies(entry, imports) }
+      end
+
+      def stdlib?(module_name, registry)
+        registry
+          .get(module_name)
+          .then { it && Stdlib.is_stdlib?(it) }
+      end
+    end
+  end
+end