jade-lang 0.9.0 → 0.10.0

data/lib/jade/interop/boundary.rb

@@ -11,6 +11,50 @@ module Jade
     # Result wrap/unwrap that user-level Decode.from_value uses is dead
     # weight at the boundary because failure always raises anyway. Skipping
     # it removes one allocation per arg per Ruby→Jade call.
+      # Names the argument a failure came from. Costs nothing until one
+      # does: Ruby only pays for a rescue that fires.
+      def arg(where)
+        yield
+      rescue DecodeError => e
+        raise e.under(where)
+      end
+      alias at arg
+
+      # Finding the element costs a second pass, which only a failure pays
+      # for: the map stays a map.
+      def elements(array, where = nil)
+        array.map { yield(it) }
+      rescue DecodeError => e
+        raise e.under("#{where}[#{failing_index(array) { yield(it) }}]")
+      end
+
+      def failing_index(array)
+        array.each_with_index do |element, index|
+          yield(element)
+        rescue DecodeError
+          return index
+        end
+      end
+
+      # An absent key reads as nil to the field decoder, which then blames
+      # the type it wanted. The path says which key that was, so a struct
+      # can check whether it was ever there.
+      def blame(error, hash, label)
+        key = error.where.to_s[/\A\.([^.\[]+)/, 1]
+        return error if key.nil? || hash.key?(key)
+
+        symbol_keys!(label, hash)
+        error.as(Jade::Decode::MissingField[key])
+      end
+
+      # Mixed keys are a real shape mismatch; the per-field errors say more
+      # than a guess about intent would.
+      def symbol_keys!(label, hash)
+        return if hash.empty? || hash.keys.any?(::String)
+
+        hash.keys.grep(::Symbol).then { raise SymbolKeys.new(label, it) unless it.empty? }
+      end
+
       def decode_or_raise(decoder, value)
         Jade::Decode::Runner.run!(decoder, value) do |error|
           raise Jade::Interop::DecodeError.new(error, value)
@@ -21,54 +65,50 @@ module Jade
       # argument types in place of the generic `decode_or_raise` path —
       # avoids constructing a Decoder descriptor and walking the
       # interpreter for primitives.
-      def integer(label, v)
-        ::Integer === v ? v : type_error!(label, v)
+      def integer(label, v, where = nil)
+        ::Integer === v ? v : type_error!(label, v, where)
       end
 
-      def string(label, v)
-        ::String === v ? v.dup : type_error!(label, v)
+      def string(label, v, where = nil)
+        ::String === v ? v.dup : type_error!(label, v, where)
       end
 
-      def bool(label, v)
-        v == true || v == false ? v : type_error!(label, v)
+      def bool(label, v, where = nil)
+        v == true || v == false ? v : type_error!(label, v, where)
       end
 
-      def float(label, v)
-        ::Numeric === v ? v.to_f : type_error!(label, v)
+      def float(label, v, where = nil)
+        ::Numeric === v ? v.to_f : type_error!(label, v, where)
       end
 
-      def list_of(klass, label, v)
-        v.is_a?(::Array) && v.all? { klass === _1 } ? v : type_error!(label, v)
+      # Copied, because the caller keeps its array and Jade values do not
+      # change. The copy is under 1% of the check that precedes it.
+      def list_of(klass, label, v, where = nil)
+        v.is_a?(::Array) && v.all? { klass === _1 } ? v.dup : type_error!(label, v, where)
       end
 
       # Validates that v is an Array but doesn't check element types — used
       # when the per-element decoder isn't a simple `is_a?` (e.g. nested
       # structs). The caller maps a decoder over the result.
-      def array(label, v)
-        v.is_a?(::Array) ? v : type_error!(label, v)
+      def array(label, v, where = nil)
+        v.is_a?(::Array) ? v : type_error!(label, v, where)
       end
 
+      # Symbol keys are not checked here: every field would then be
+      # missing, and the rescue around the fields catches that for free.
       def hash(label, v)
         case v
-        when ::Hash then string_keyed!(label, v)
+        when ::Hash then v
         when ::Data then v.to_h.transform_keys(&:to_s)
-        else type_error!(label, v)
+        else type_error!(label, v, nil)
         end
       end
 
-      # Mixed keys are a real shape mismatch; the per-field errors say more
-      # than a guess about intent would.
-      def string_keyed!(label, v)
-        return v if v.empty? || v.keys.any?(::String)
-
-        v.keys.grep(::Symbol)
-          .then { it.empty? ? v : raise(Jade::Interop::SymbolKeys.new(label, it)) }
-      end
-
-      def type_error!(label, v)
+      def type_error!(label, v, where)
         raise Jade::Interop::DecodeError.new(
           Jade::Decode::WrongType[label, Jade::Decode.type_name(v)],
           v,
+          where:,
         )
       end
     end

data/lib/jade/interop/error.rb

@@ -54,36 +54,48 @@ module Jade
     end
 
     class DecodeError < Error
-      attr_reader :decode_error, :value, :source
+      attr_reader :decode_error, :value, :source, :where
 
       SUBJECTS = {
         argument: 'Ruby passed a value that failed to decode',
         port_return: 'Port returned a value that failed to decode',
       }.freeze
 
-      def initialize(decode_error, value, source: :argument)
+      # Ruby has no null.
+      TYPE_NAMES = { 'null' => 'nil' }.freeze
+
+      def initialize(decode_error, value, source: :argument, where: nil)
         @decode_error = decode_error
         @value = value
         @source = source
+        @where = where
         super(format(decode_error, value))
       end
 
+      # Frames unwind innermost first, so each one puts itself in front of
+      # the path the frames below it built.
+      def under(segment)
+        self.class.new(decode_error, value, source:, where: "#{segment}#{where}")
+      end
+
+      def as(error)
+        self.class.new(error, value, source:, where:)
+      end
+
       private
 
       def format(error, value)
         path, leaf = unwind(error)
-        location = path.empty? ? "value" : path.join
-        subject = SUBJECTS.fetch(@source)
 
         case leaf
         in Jade::Decode::WrongType[expected, got]
-          "#{subject} at #{location}: expected #{expected}, got #{got} (#{value.inspect})"
+          "#{subject(path)}: expected #{expected}, got #{type_name(got)}#{seen(value)}"
 
         in Jade::Decode::MissingField[key]
-          "#{subject} at #{location}: missing field `#{key}` (#{value.inspect})"
+          "#{subject(path)}: missing field `#{key}`#{seen(value)}"
 
         in Jade::Decode::Custom[msg]
-          "#{subject} at #{location}: #{msg} (#{value.inspect})"
+          "#{subject(path)}: #{msg}#{seen(value)}"
 
         in Jade::Decode::Multiple[errors]
           errors
@@ -92,6 +104,22 @@ module Jade
         end
       end
 
+      # `Shop.price(item).cents` when the caller said where it was, and the
+      # old sentence when it did not.
+      def subject(path)
+        return "#{SUBJECTS.fetch(@source)} at #{path.empty? ? 'value' : path.join}" unless @where
+
+        "#{@where}#{path.join}"
+      end
+
+      def type_name(got)
+        TYPE_NAMES.fetch(got.to_s, got)
+      end
+
+      def seen(value)
+        value.nil? ? '' : " (#{value.inspect})"
+      end
+
       def unwind(error, path = [])
         case error
         in Jade::Decode::AtField[key, inner] then unwind(inner, path + [".#{key}"])

data/lib/jade/interop/lowering.rb

@@ -21,8 +21,9 @@ module Jade
         in Symbol::FunctionType
           [FunctionError.new('inline function type')]
 
-        in Symbol::TypeApplication(args:)
-          args.flat_map { validate(it, registry, entry) }
+        in Symbol::TypeApplication(constructor:, args:)
+          validate(constructor, registry, entry) +
+            args.flat_map { validate(it, registry, entry) }
 
         in Symbol::RecordType(fields:)
           fields.values.flat_map { validate(it, registry, entry) }
@@ -34,6 +35,11 @@ module Jade
           lookup_type(symbol, registry, entry)
             &.then { validate(it, registry, entry) } || []
 
+        # An alias is its body here as everywhere else, so a function type
+        # behind one is still a function type that cannot be lowered.
+        in Symbol::Alias(body:)
+          body ? validate(body, registry, entry) : []
+
         else
           []
         end

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