jade-lang 0.8.0 → 0.10.0

data/lib/jade/lsp/converters.rb

@@ -33,6 +33,7 @@ module Jade
         enum_member: 22,
         struct: 23,
         interface: 11,
+        type_parameter: 26,
       }.freeze
 
       HOVERABLE_SYMBOLS = [
@@ -44,6 +45,7 @@ module Jade
         Jade::Symbol::Variant,
         Jade::Symbol::Union,
         Jade::Symbol::Struct,
+        Jade::Symbol::Alias,
       ].freeze
 
       # LSP CompletionItemKind values we use.
@@ -66,8 +68,8 @@ module Jade
         nil
       end
 
-      def completion_items
-        Snippets::ALL.map do |snippet|
+      def completion_items(module_name = nil)
+        Snippets.for_module(module_name).map do |snippet|
           {
             label: snippet.label,
             kind: COMPLETION_KIND_SNIPPET,
@@ -104,6 +106,21 @@ module Jade
         end
       end
 
+      # Enter and `end` are the two moments an editor can indent from what
+      # is already written, without the parse it will not get mid-typing.
+      def on_type_edits(text, line, character, typed)
+        text
+          .lines
+          .map(&:chomp)
+          .then do |lines|
+            case typed
+            in "\n" then indent_edit(lines, line, indent_after(lines, line))
+            in "d" then closing_edit(lines, line, character)
+            else []
+            end
+          end
+      end
+
       def whole_document_edit(source, new_text)
         last_line = source.line_starts.size - 1
         {
@@ -162,6 +179,9 @@ module Jade
         in AST::StructDeclaration(name:, range:)
           document_symbol(name, :struct, source, range)
 
+        in AST::TypeAliasDeclaration(name:, range:)
+          document_symbol(name, :type_parameter, source, range)
+
         in AST::InterfaceDeclaration(name:, range:, functions:)
           document_symbol(
             name, :interface, source, range,
@@ -374,8 +394,12 @@ module Jade
 
       def hover_body(symbol, registry)
         case symbol
+        in Jade::Symbol::Alias
+          render_alias(symbol, registry)
+
         in Jade::Symbol::Union | Jade::Symbol::Struct
           render_type(symbol, registry)
+
         else
           render_value(symbol, registry)
         end
@@ -404,6 +428,21 @@ module Jade
         )
       end
 
+      # Expansion erases the name everywhere else, so this is the only place
+      # left that says what an alias stands for.
+      def render_alias(symbol, registry)
+        Jade::Type
+          .from_symbol(symbol.body, registry, Frontend::TypeChecking::VarGen.new)
+          .first
+          .then { "type alias #{symbol.name}#{alias_params(symbol)} = #{it}" }
+      end
+
+      def alias_params(symbol)
+        symbol.type_params.empty? ?
+          '' :
+          "(#{symbol.type_params.map(&:name).join(', ')})"
+      end
+
       def render_type(symbol, registry)
         impls_for(symbol, registry)
           .then { it.empty? ? '' : "\n\nimplements #{it.join(', ')}" }
@@ -471,6 +510,7 @@ module Jade
         in AST::VariableReference | AST::ConstructorReference |
            AST::QualifiedAccess | AST::FunctionDeclaration |
            AST::TypeDeclaration | AST::StructDeclaration |
+           AST::TypeAliasDeclaration |
            AST::InterfaceDeclaration | AST::VariantDeclaration
           node.symbol.then { resolve_ref(it, registry) }
 
@@ -518,6 +558,47 @@ module Jade
         document_symbol(fn.name, :function, source, fn.range)
       end
 
+      INDENT = 2
+
+      # A block opens on a header, on a keyword that ends one, or on an
+      # unclosed bracket. `in` is a branch head: it sits with its `case`.
+      OPENS = /(\A(def|case|implements|interface|uses|if)\b)|((\bthen|\bwith|\belse|[({\[])\z)/
+
+      def indent_after(lines, line)
+        previous(lines, line)
+          .then { it ? indent_of(it) + (OPENS.match?(it.strip) ? INDENT : 0) : 0 }
+      end
+
+      # `end` closes the block its opener began, so it lands where the
+      # opener sits: one level out from the body above it.
+      def closing_edit(lines, line, character)
+        return [] unless lines[line].to_s[0...character].strip == 'end'
+
+        previous(lines, line)
+          .then { it ? [indent_of(it) - INDENT, 0].max : 0 }
+          .then { indent_edit(lines, line, it) }
+      end
+
+      def previous(lines, line)
+        lines[0...line].reverse.find { !it.strip.empty? }
+      end
+
+      def indent_edit(lines, line, width)
+        return [] if indent_of(lines[line].to_s) == width
+
+        [{
+          range: {
+            start: { line:, character: 0 },
+            end: { line:, character: indent_of(lines[line].to_s) },
+          },
+          newText: ' ' * width,
+        }]
+      end
+
+      def indent_of(line)
+        line[/\A */].length
+      end
+
       def diagnostic_message(diagnostic)
         [
           diagnostic.message,

data/lib/jade/lsp/handlers.rb

@@ -24,6 +24,7 @@ module Jade
         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)
+        when 'textDocument/onTypeFormatting' then on_type_formatting(state, message)
         else on_unknown(state, message)
         end
       end
@@ -39,9 +40,13 @@ module Jade
 
       def on_initialize(state, message)
         params = (message['params'] || {})
-        root = params
+        # The editor's root is the project root, not the source root the
+        # compiler names modules from. Reading the manifest also loads the
+        # extension gems a project imports.
+        project = params
           .then { it['rootUri'] || it.dig('workspaceFolders', 0, 'uri') }
           .then { it ? it.sub(%r{\Afile://}, '') : Dir.pwd }
+          .then { [Project.find(it), it] }
 
         {
           capabilities: {
@@ -55,10 +60,14 @@ module Jade
             renameProvider: { prepareProvider: true },
             inlayHintProvider: true,
             documentFormattingProvider: true,
+            documentOnTypeFormattingProvider: {
+              firstTriggerCharacter: "\n",
+              moreTriggerCharacter: ['d'],
+            },
           },
           serverInfo: { name: 'jade-lsp', version: '0.1.0' },
         }
-          .then { [state.with_root(root), [respond(message['id'], it)]] }
+          .then { [state.with_project(*project), [respond(message['id'], it)]] }
       end
 
       def negotiate_encoding(params)
@@ -70,7 +79,7 @@ module Jade
       def on_did_open(state, params)
         params['textDocument']
           .then { state.put_buffer(it['uri'], it['text']) }
-          .then { recompile_and_publish(it) }
+          .then { recompile_and_publish(it, scope: :project) }
       end
 
       def on_did_change(state, params)
@@ -83,7 +92,7 @@ module Jade
 
       def on_did_close(state, params)
         params['textDocument']['uri']
-          .then { recompile_and_publish(state.close(it), extra_uris: [it]) }
+          .then { recompile_and_publish(state.close(it), extra_uris: [it], scope: :project) }
       end
 
       def on_document_symbol(state, message)
@@ -116,7 +125,18 @@ module Jade
       end
 
       def on_completion(state, message)
-        [state, [respond(message['id'], Converters.completion_items)]]
+        message
+          .dig('params', 'textDocument', 'uri')
+          .then { module_name_for(it, state.source_root) }
+          .then { [state, [respond(message['id'], Converters.completion_items(it))]] }
+      end
+
+      def module_name_for(uri, source_root)
+        return nil unless uri && source_root
+
+        Converters
+          .relative_path(uri, source_root)
+          .then { Source.module_name_for(it) }
       end
 
       def on_prepare_rename(state, message)
@@ -148,6 +168,23 @@ module Jade
         [state, [respond(message['id'], edits)]]
       end
 
+      def on_type_formatting(state, message)
+        params = message['params']
+        state
+          .buffers[params.dig('textDocument', 'uri')]
+          .then { it ? on_type_edits(it, params) : [] }
+          .then { [state, [respond(message['id'], it)]] }
+      end
+
+      def on_type_edits(text, params)
+        Converters.on_type_edits(
+          text,
+          params.dig('position', 'line'),
+          params.dig('position', 'character'),
+          params['ch'],
+        )
+      end
+
       def formatting_edits_for(state, uri)
         text = state.buffers[uri]
         return nil unless text
@@ -261,43 +298,103 @@ module Jade
       # 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
+      def recompile_and_publish(state, extra_uris: [], scope: :buffers)
+        return [state, extra_uris.map { publish_for(it, []) }] if state.source_root.nil?
 
         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)
+        diagnostics_by_uri, registry =
+          compile_each(state, overlays, entries(state, overlays, scope))
 
-        uris = (diagnostics_by_uri.keys + state.buffers.keys + extra_uris).uniq
+        uris = (diagnostics_by_uri.keys + state.buffers.keys + state.published + extra_uris).uniq
         messages = uris.map { publish_for(it, diagnostics_by_uri[it] || []) }
 
-        next_state = registry ? state.set_registry(registry) : state
+        next_state = (registry ? state.set_registry(registry) : state)
+          .with_published(diagnostics_by_uri.keys)
         [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
+      # Typing recompiles what is open; opening and closing sweep.
+      def entries(state, overlays, scope)
+        return overlays.keys if scope == :buffers
+
+        Dir
+          .glob('**/*.jd', base: state.source_root)
+          .sort
+          .then { imported_last(it, state.registry) }
       end
 
-      def compile(source_root, entry_path, overlays)
+      # Compiling a module compiles what it imports, so the modules nothing
+      # imports cover the project in one pass. A file the last compile never
+      # saw goes first, since it may be the new root.
+      def imported_last(paths, registry)
+        return paths unless registry
+
+        [imported(registry), module_names(registry)]
+          .then { |names, by_path| paths.partition { !names.include?(by_path[it]) } }
+          .flatten
+      end
+
+      def imported(registry)
+        registry.dependency_graph.nodes.values.flatten.to_set
+      end
+
+      def module_names(registry)
+        registry
+          .modules
+          .each_value
+          .filter_map { [it.source.uri, it.name] if it.source }
+          .to_h
+      end
+
+      def compile_each(state, overlays, entries)
+        entries
+          .reduce([{}, nil, []]) { |acc, entry| compile_unless_seen(acc, state, overlays, entry) }
+          .first(2)
+      end
+
+      def compile_unless_seen((diagnostics, registry, seen), state, overlays, entry)
+        return [diagnostics, registry, seen] if seen.include?(entry)
+
+        compile(state, entry, overlays)
+          .then { |(compiled, found)| [diagnostics.merge(found), compiled || registry, seen + compiled_paths(compiled)] }
+      end
+
+      def compiled_paths(registry)
+        return [] unless registry
+
+        registry
+          .modules
+          .each_value
+          .reject { Stdlib.is_stdlib?(it) }
+          .filter_map { it.source&.uri }
+      end
+
+      def compile(state, entry_path, overlays)
         ModuleLoader
-          .load(source_root, entry_path, tolerant: true, overlays:)
-          .then { [it, collect_diagnostics(it, source_root)] }
+          .load(state.source_root, entry_path, cache_dir: state.cache_dir, tolerant: true, overlays:)
+          .then { [it, collect_diagnostics(it, state.source_root)] }
       rescue Jade::CompilationError => e
-        [nil, diagnostics_by_uri(e.diagnostics, source_root)]
+        [nil, diagnostics_by_uri(e.diagnostics, state.source_root)]
       rescue StandardError => e
         $stderr.puts "[jade-lsp] compile crash: #{e.class}: #{e.message}"
         $stderr.puts e.backtrace.first(20).join("\n")
-        [nil, {}]
+        [nil, crash_diagnostic(state.source_root, entry_path, overlays, e)]
+      end
+
+      # Publishing nothing renders a crashed compile as a clean file.
+      def crash_diagnostic(source_root, entry_path, overlays, error)
+        Jade::Source
+          .new(uri: entry_path, text: overlays[entry_path] || '')
+          .then { Jade::Diagnostics::Label[it, 0...0, nil] }
+          .then do
+            Jade::Diagnostics::Diagnostic.error(
+              "jade-lsp crashed compiling this file: #{error.class}: #{error.message}",
+              primary: it,
+            )
+          end
+          .then { { Converters.lsp_uri(entry_path, source_root) => [it] } }
       end
 
       def collect_diagnostics(registry, source_root)

data/lib/jade/lsp/snippets.rb

@@ -105,6 +105,18 @@ module Jade
 
       module_function
 
+      # The compiler requires the name to match the path, so a placeholder
+      # here offers a decision with one right answer.
+      def for_module(module_name)
+        return ALL unless module_name
+
+        ALL.map do
+          next it unless it.label == 'module'
+
+          it.with(body: "module #{module_name} exposing (${0})")
+        end
+      end
+
       # Every form, as plain Jade — what `jade q syntax` serves.
       def catalog
         ALL.map { { form: it.label, detail: it.detail, source: it.source } }

data/lib/jade/lsp/state.rb

@@ -1,12 +1,14 @@
 module Jade
   module LSP
-    State = Data.define(:source_root, :buffers, :registry) do
+    State = Data.define(:source_root, :cache_dir, :buffers, :registry, :published) do
       def self.empty
-        new(source_root: nil, buffers: {}, registry: nil)
+        new(source_root: nil, cache_dir: nil, buffers: {}, registry: nil, published: [])
       end
 
-      def with_root(root)
-        with(source_root: root)
+      # No manifest means no cache directory to share with the CLI, and
+      # every compile starts from nothing.
+      def with_project(project, root)
+        with(source_root: project&.source_root || root, cache_dir: project&.cache_path)
       end
 
       def put_buffer(uri, text)
@@ -20,6 +22,11 @@ module Jade
       def set_registry(reg)
         with(registry: reg)
       end
+
+      # Cleared next round, whether or not the file is still open.
+      def with_published(uris)
+        with(published: uris)
+      end
     end
   end
 end

data/lib/jade/module_loader/build.rb

@@ -0,0 +1,36 @@
+require 'fileutils'
+
+require 'jade/module_loader/cache'
+
+module Jade
+  module ModuleLoader
+    # The emitted Ruby, as opposed to `Cache`, which holds compiled
+    # modules. Generated code calls the runtime by name, so a build left
+    # by another version of the compiler can call a helper this one no
+    # longer has. Sources are untouched in that case, so mtimes say
+    # nothing: keep the fingerprint next to the build and drop the build
+    # when it does not match.
+    module Build
+      extend self
+
+      FINGERPRINT = '.fingerprint'
+
+      def discard_foreign(root)
+        return unless File.exist?(root)
+        return if fingerprint(root) == Cache.compiler_fingerprint
+
+        FileUtils.rm_rf(root)
+      end
+
+      def stamp(root)
+        File.write(File.join(root, FINGERPRINT), Cache.compiler_fingerprint)
+      end
+
+      private
+
+      def fingerprint(root)
+        File.join(root, FINGERPRINT).then { File.read(it) if File.exist?(it) }
+      end
+    end
+  end
+end

data/lib/jade/module_loader.rb

@@ -6,6 +6,7 @@ require 'jade/ast'
 require 'jade/registry'
 require 'jade/frontend'
 require 'jade/codegen'
+require 'jade/module_loader/build'
 require 'jade/module_loader/cache'
 require 'jade/module_loader/dependency_resolver'
 require 'jade/module_loader/dependency_graph'

data/lib/jade/parsing/combinators.rb

@@ -166,6 +166,26 @@ module Jade
         end
       end
 
+      # A word that only reads as a keyword in one position, so it stays
+      # usable as an ordinary name everywhere else.
+      def contextual(word)
+        (@contextuals ||= {})[word] ||= P.new do |state|
+          type(:identifier).call(state).and_then do |(token, next_state)|
+            next Ok[[token, next_state]] if token.value == word
+
+            Err[[
+              Parsing::UnexpectedTokenError.new(
+                entry:    state.entry,
+                span:     token.range,
+                actual:   token,
+                expected: word,
+              ),
+              state,
+            ]]
+          end
+        end
+      end
+
       def lazy(&block)
         P.new do |input|
           block.call.call(input)
@@ -216,6 +236,13 @@ module Jade
           with(diagnostics: diagnostics.add(diagnostic))
         end
 
+        # Is the token here on the same line as the one before it?
+        def continues_line?
+          return true if eof? || position.zero?
+
+          same_line?(tokens[position - 1].range.begin, current.range.begin)
+        end
+
         def skip_until(sync_types)
           (position...tokens.length)
             .find { sync_types.include?(tokens[it].type) }
@@ -228,6 +255,12 @@ module Jade
           @fn = block
         end
 
+        def stalled?(error, state)
+          return state.eof? if error.span.nil?
+
+          error.span.begin == state.current&.range&.begin
+        end
+
         def call(tokens)
           @fn.call(tokens)
         end
@@ -282,8 +315,51 @@ module Jade
           map_error(&:commit)
         end
 
-        def context(name)
-          map_error { |err| err.with_context(name) }
+        # A stalled alternation reports whichever branch it tried last, so
+        # say what the position wanted instead. One that got somewhere is
+        # already reporting the useful error.
+        def expecting(what)
+          P.new do |state|
+            call(state).map_error do |(err, err_state)|
+              [!err.committed? && stalled?(err, state) ? err.copy(expected: what) : err, err_state]
+            end
+          end
+        end
+
+        # A `(` opening a new line starts a statement, it does not continue
+        # the expression above it: `(x, y) = p` is a binding, not a call on
+        # whatever the line before ended with.
+        def on_same_line
+          P.new do |state|
+            next Err[[
+              Parsing::UnexpectedTokenError.new(
+                entry: state.entry,
+                span: state.current.range,
+                actual: state.current,
+                expected: 'the same line',
+              ),
+              state,
+            ]] unless state.continues_line?
+
+            call(state)
+          end
+        end
+
+        def parsing(name)
+          map_error { |err| err.copy(context: [name, *err.context]) }
+        end
+
+        # Opens an empty body's span out to the construct it belongs to.
+        # The innermost one gets there first; past that the span is wider
+        # than the marker `body` left, so an enclosing construct skips it.
+        def spanning_empty_body
+          P.new do |state|
+            call(state).map_error do |(err, err_state)|
+              next [err, err_state] unless err.is_a?(MissingBodyError) && err.span.size == 1
+
+              [err.copy(span: state.current.range.begin...err.actual.range.end), err_state]
+            end
+          end
         end
       end
     end

data/lib/jade/parsing/error.rb

@@ -21,14 +21,15 @@ module Jade
         self
       end
 
-      def with_context(name)
+      def copy(**changes)
         self.class.new(
-          entry:     @entry,
-          span:      @span,
-          actual:    @actual,
-          expected:  @expected,
+          entry: @entry,
+          span: @span,
+          actual: @actual,
+          expected: @expected,
           committed: @committed,
-          context:   [name, *@context],
+          context: @context,
+          **changes,
         )
       end
 
@@ -152,6 +153,42 @@ module Jade
       end
     end
 
+    # `in 0..limit`. Rejecting it is right — coverage is decided before
+    # `limit` exists — but the reader needs to be told that, not sent to
+    # look at their `then`.
+    class NonLiteralRangeBoundError < Error
+      def message
+        "#{context_prefix}A range pattern's bounds have to be literals, and " \
+          "#{@actual.value.inspect} is a value. Which integers a branch " \
+          "covers is settled when the code is compiled, so a bound the " \
+          "compiler cannot see cannot be checked."
+      end
+
+      def label
+        'range bound is not a literal'
+      end
+
+      def notes
+        [
+          Jade::Diagnostics::Annotation[
+            :help,
+            'match `_` and compare in the body, or use `if` — either way the ' \
+              'branch is no longer something exhaustiveness can account for',
+          ],
+        ]
+      end
+    end
+
+    class MissingBodyError < UnexpectedTokenError
+      def hint
+        '(a body has to produce a value)'
+      end
+
+      def label
+        'missing body'
+      end
+    end
+
     class InvalidOperatorError < Error
       HINTS = {
         '/=' => 'Use `!=` for inequality.',

data/lib/jade/parsing/type.rb

@@ -5,7 +5,9 @@ module Jade
     module Type
       extend Combinators::Dsl
 
-      parser(:type_expression) { type_function | type_atom | type_record }
+      parser(:type_expression) {
+        (type_function | type_atom | type_record).expecting('a type')
+      }
 
       parser(:type_atom) {
         type_application | type_var | type_tuple | grouped(lazy { type_function })
@@ -65,8 +67,8 @@ module Jade
         no_args = [Combinators::CommaList.empty, nil]
 
         (
-          (type_name >> optional(type_application_args, default: no_args)) |
-          (type_var  >> type_application_args)
+          (type_name >> optional(type_application_args.on_same_line, default: no_args)) |
+          (type_var  >> type_application_args.on_same_line)
         ).map(&AST.type_application)
       }