rigortype 0.4.6 → 0.4.8

data/lib/rigor/language_server/diagnostic_publisher.rb

@@ -4,6 +4,7 @@ require "tempfile"
 
 require_relative "uri"
 require_relative "publish_batcher"
+require_relative "config_warning_announcer"
 require_relative "../analysis/runner"
 require_relative "../analysis/buffer_binding"
 
@@ -19,7 +20,7 @@ module Rigor
     # buffers' debounce timers elapse around the same moment, the `PublishBatcher` coalesces them into one
     # `#publish_many` round dispatched across the fork-based worker pool (issue #142) instead of N
     # independent, GVL-serialized `Runner` calls.
-    class DiagnosticPublisher
+    class DiagnosticPublisher # rubocop:disable Metrics/ClassLength
       # Maps Rigor severity symbols to LSP DiagnosticSeverity
       # integers per spec § "Diagnostic":
       #   1 = Error, 2 = Warning, 3 = Information, 4 = Hint.
@@ -51,6 +52,7 @@ module Rigor
         @project_context = project_context
         @debouncer = debouncer
         @debounce_seconds = debounce_seconds
+        @config_warning_announcer = ConfigWarningAnnouncer.new(writer: writer, project_context: project_context)
         @round_lock = Mutex.new
         @round_running = false
         @round_pending = false
@@ -130,6 +132,9 @@ module Rigor
         notify(uri, [])
       end
 
+      # Issue #2231 — shows the configuration warnings the editor has not seen yet ({ConfigWarningAnnouncer}).
+      def announce_config_warnings = @config_warning_announcer.announce
+
       # Cancels every in-flight debounced task. Called from `Server#handle_shutdown` so pending publishes
       # don't fire against a closed STDOUT.
       def cancel_pending
@@ -167,8 +172,7 @@ module Rigor
 
       # True when a save arrived mid-round and the loop should run once more. Releases ownership otherwise.
       # `next`, not `break`: inside `Mutex#synchronize`'s block, `break` returns from the SYNCHRONIZE call, so
-      # a `break` written here would leave the caller's `loop` spinning forever — which is exactly what it did
-      # before this was split out.
+      # a `break` here would leave the caller's `loop` spinning forever.
       def consume_pending
         @round_lock.synchronize do
           next(@round_running = false) unless @round_pending
@@ -185,6 +189,7 @@ module Rigor
       def execute_project_round(saved_uri)
         generation = @project_context.generation
         diagnostics = @project_context.project_diagnostics
+        announce_config_warnings # the round re-read the configuration; the reload stands even if the result does not
         return if generation != @project_context.generation
 
         by_path = diagnostics.group_by(&:path)

data/lib/rigor/language_server/document_symbol_provider.rb

@@ -30,7 +30,7 @@ module Rigor
         @project_context = project_context
       end
 
-      # @return LSP `DocumentSymbol[]` for the
+      # @return LSP document symbols for the
       #   buffer at `uri`. Returns nil when the URI isn't open or
       #   doesn't parse cleanly enough to surface symbols — LSP
       #   clients fall back to no-outline in that case.

data/lib/rigor/language_server/folding_range_provider.rb

@@ -23,8 +23,7 @@ module Rigor
         @project_context = project_context
       end
 
-      # @return LSP `FoldingRange[]` for the
-      #   buffer, or nil when the URI isn't open / parseable.
+      # @return LSP folding ranges for the buffer, or nil when the URI isn't open / parseable.
       def provide(uri)
         path, entry = buffer_for(uri)
         return nil if entry.nil?

data/lib/rigor/language_server/hover_provider.rb

@@ -44,7 +44,7 @@ module Rigor
         node = locate_node(source: entry.bytes, root: parse_result.value, line: line + 1, character: character + 1)
         return nil if node.nil?
 
-        scope = base_scope(path)
+        scope = @project_context.seeded_scope_for(path: path, bytes: entry.bytes)
         index = Inference::ScopeIndexer.index(parse_result.value, default_scope: scope)
         node_scope = index[node]
         type = node_scope.type_of(node)
@@ -59,12 +59,6 @@ module Rigor
       rescue Source::NodeLocator::OutOfRangeError
         nil
       end
-
-      def base_scope(_path)
-        # Pulls the Environment from the cached ProjectContext so each hover avoids repeating the RBS-load
-        # build.
-        Scope.empty(environment: @project_context.environment)
-      end
     end
   end
 end

data/lib/rigor/language_server/hover_renderer.rb

@@ -60,9 +60,8 @@ module Rigor
       end
 
       # Renders a `CallNode` hover when the receiver's type can be mapped to a known RBS class and the method
-      # is declared there. Returns nil for shapes the slice-A1 floor doesn't handle (implicit `self`, Union /
-      # Refined / Shape receivers — those land in slices A2-A4 and slice 7); the caller falls back to the
-      # default body.
+      # is declared there. Returns nil for shapes this renderer does not handle (implicit `self`, Union /
+      # Refined / Shape receivers); the caller falls back to the default body.
       def render_call(call_node, return_type, node_scope_lookup)
         receiver_node = call_node.receiver
         return nil if receiver_node.nil?
@@ -133,17 +132,16 @@ module Rigor
         body << "#{return_type.describe}\n"
         body << "```"
         if (doc = rbs_documentation(definition))
-          # Close the code fence first so the comment text renders as prose, then a fresh fenced block isn't
-          # necessary — plain markdown below the code reads better in clients.
+          # The fence is already closed, so the RBS comment renders as plain markdown below the code.
           body << "\n\n---\n\n#{doc}"
         end
         body
       end
 
       # Returns the concatenated text of every RBS comment attached to the method definition, or nil when no
-      # comments exist. `RBS::Definition::Method#comments` is an Array<AST::Comment> with each entry's
-      # `.string` carrying the raw text (newline-terminated `# foo` lines). Multiple comments are joined with a
-      # blank line so each upstream `# Foo bar` paragraph is preserved.
+      # comments exist. `RBS::Definition::Method#comments` is a list of `AST::Comment`s, each with its raw text
+      # in `.string` (newline-terminated `# foo` lines). Multiple comments are joined with a blank line so each
+      # upstream `# Foo bar` paragraph is preserved.
       def rbs_documentation(definition)
         comments = definition.respond_to?(:comments) ? definition.comments : nil
         return nil if comments.nil? || comments.empty?

data/lib/rigor/language_server/project_context.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "tempfile"
+
 require_relative "../environment"
 require_relative "../project_environment"
 require_relative "../cache/store"
@@ -9,6 +11,7 @@ require_relative "../cache/incremental_snapshot"
 require_relative "../effects/identity"
 require_relative "../analysis/path_expansion"
 require_relative "../protection/discovery_seed"
+require_relative "../config_audit"
 
 module Rigor
   module LanguageServer
@@ -68,6 +71,24 @@ module Rigor
         @project_scan = nil
         @incremental_session = nil
         @session_primed = false
+        @announced_config_warnings = Set.new
+        @announce_lock = Mutex.new
+      end
+
+      # Issue #2231 — the {ConfigAudit} warnings for the configuration as last loaded that the editor has not been
+      # shown yet, or an empty array. `rigor check` prints these on every run; the server is one long run, so it
+      # announces each warning once: at `initialized` for the configuration it started with, and after a later reload
+      # (every save round re-reads `.rigor.yml`) only the warnings that were not in the previous reload's set. The
+      # comparison is by message, not by order, so reordering entries announces nothing, and fixing one of two
+      # warnings does not show the other again. A warning that was fixed and then comes back is new and is shown.
+      # Called from the dispatch thread and the save round's thread alike, hence the lock.
+      def unannounced_config_warnings
+        @announce_lock.synchronize do
+          warnings = ConfigAudit.warnings(@configuration)
+          fresh = warnings.reject { |warning| @announced_config_warnings.include?(warning.message) }
+          @announced_config_warnings = warnings.to_set(&:message)
+          fresh
+        end
       end
 
       # Returns the cached `Rigor::Environment` for this session, building it on first access. The build
@@ -132,6 +153,22 @@ module Rigor
                                                     buffer: buffer, constant_sources: true)
       end
 
+      # Issue #2282 — the base scope an editor query (hover, completion, signature help) probes with: the same
+      # cross-file discovery seed the diagnostic publisher hands its `Runner` ({#discovery_seed_for}), so a constant
+      # or method another file defines answers what `rigor check` would. The seed fold reads the buffer through a
+      # {Analysis::BufferBinding}, so `bytes` is staged in a tempfile for the call. An empty seed (no configured
+      # files, or nothing discovered) leaves the bare single-file scope every query used before.
+      def seeded_scope_for(path:, bytes:)
+        seed = Tempfile.create(["rigor-lsp-query-", ".rb"]) do |tmp|
+          # Staged as the publisher stages them; the seed's job is to withhold the stale on-disk declarations of
+          # this file, so an empty-bytes stage is not observable by design.
+          tmp.write(bytes)
+          tmp.flush
+          discovery_seed_for(Analysis::BufferBinding.new(logical_path: path, physical_path: tmp.path))
+        end
+        Protection::DiscoverySeed.seeded_scope(environment: environment, seed: seed)
+      end
+
       # Builds what {#discovery_seed_for} reads once per generation, so a fork batch's children inherit it instead
       # of each walking the project.
       def prepare_discovery_seed
@@ -251,7 +288,8 @@ module Rigor
       def reload_configuration
         return unless @configuration_loader
 
-        @configuration = @configuration_loader.call
+        loaded = @configuration_loader.call
+        @announce_lock.synchronize { @configuration = loaded }
       rescue StandardError
         nil
       end

data/lib/rigor/language_server/publish_batcher.rb

@@ -15,10 +15,9 @@ module Rigor
     # dropped. The same claim/consume shape `DiagnosticPublisher#run_project_round` already uses for the
     # whole-project save round (#246), generalised to an arbitrary key type and an arbitrary batch action.
     class PublishBatcher
-      # @param on_batch — `(keys) -> void`, called with the deduplicated Array of keys pending at the
-      #   start of one round. May be called more than once in a row when keys keep arriving while a round
-      #   runs.
-      # @param on_error — `(exception) -> void`, called when `on_batch` raises. A round must
+      # @param on_batch — called with the deduplicated keys pending at the start of one round. May be called
+      #   more than once in a row when keys keep arriving while a round runs.
+      # @param on_error — called with the exception when `on_batch` raises. A round must
       #   never wedge the coalescing lock for every future `#enqueue` call — ownership is always released
       #   before this fires. Whatever was mid-flight when the round raised is lost; anything enqueued by a
       #   concurrent `#enqueue` call after this round's drain but before the rescue stays pending and rides

data/lib/rigor/language_server/selection_range_provider.rb

@@ -20,10 +20,8 @@ module Rigor
         @project_context = project_context
       end
 
-      # @param positions — LSP `Position[]` — each
-      #   `{ line:, character: }` 0-based.
-      # @return one `SelectionRange` per
-      #   position, or nil when the URI / buffer isn't resolvable.
+      # @param positions — LSP positions, each `{ line:, character: }` 0-based.
+      # @return one `SelectionRange` per position, or nil when the URI / buffer isn't resolvable.
       def provide(uri, positions)
         path, entry = buffer_for(uri)
         return nil if entry.nil?

data/lib/rigor/language_server/server.rb

@@ -194,7 +194,12 @@ module Rigor
 
       # `initialized` is a notification — no response body. Nothing is registered here yet: the server handles
       # `workspace/didChangeWatchedFiles` when a client sends it, but does not register for it dynamically.
+      #
+      # Issue #2231 — the configuration the server started with is audited here, the first point at which the
+      # client is listening, so a `.rigor.yml` key that does nothing is named in the editor as `rigor check`
+      # names it on STDERR.
       def handle_initialized
+        @publisher&.announce_config_warnings
         nil
       end
 
@@ -267,8 +272,7 @@ module Rigor
 
       # textDocument/hover REQUEST. Slice 5 returns either a `Hover` payload (markdown contents wrapping type
       # + erased-RBS info) or nil when no expression is at the queried position. Nil maps to `result: null`
-      # per LSP spec; clients suppress the popup. Returns `MethodNotFound` when no hover_provider is wired
-      # (slice 1-4 behaviour).
+      # per LSP spec; clients suppress the popup. Returns `MethodNotFound` when no hover_provider is wired.
       def handle_hover(params)
         return method_not_found("textDocument/hover") unless @hover_provider
 
@@ -351,7 +355,7 @@ module Rigor
         )
       end
 
-      # textDocument/documentSymbol REQUEST. Returns the `DocumentSymbol[]` outline for the buffer at the
+      # textDocument/documentSymbol REQUEST. Returns the document-symbol outline for the buffer at the
       # requested URI. Returns `MethodNotFound` when no provider is wired.
       def handle_document_symbol(params)
         return method_not_found("textDocument/documentSymbol") unless @document_symbol_provider

data/lib/rigor/language_server/signature_help_provider.rb

@@ -25,7 +25,7 @@ module Rigor
     # parses the buffer, locates the enclosing `CallNode`, infers the receiver's type, and returns the
     # method's first overload as a `SignatureInformation`.
     #
-    # Slice C1 (this commit) ships:
+    # Slice C1 ships:
     # - Sentinel patching for `obj.foo(|` so Prism's parse succeeds (mirrors `CompletionProvider`'s slice B4
     #   pattern).
     # - First-overload signature only.
@@ -111,7 +111,7 @@ module Rigor
       end
 
       def build_signature(call_node, root, path, bytes, line, character)
-        scope_index = build_scope_index(root, path)
+        scope_index = build_scope_index(root, path, bytes)
         receiver_node = call_node.receiver
         return nil if receiver_node.nil?
 
@@ -197,8 +197,8 @@ module Rigor
         end
       end
 
-      def build_scope_index(root, _path)
-        scope = Scope.empty(environment: @project_context.environment)
+      def build_scope_index(root, path, bytes)
+        scope = @project_context.seeded_scope_for(path: path, bytes: bytes)
         Inference::ScopeIndexer.index(root, default_scope: scope)
       end
 

data/lib/rigor/lens/claims/comparison.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative "../../environment/member_consistency"
+
+module Rigor
+  module Lens
+    class Claims
+      # The deliberately small proof fragment of lens-claims.md. Unknown is not a failed subtype check.
+      class Comparison
+        def initialize(loader, relative_conflict:)
+          @loader = loader
+          @proof = Environment::MemberConsistency::RbsProof.new(loader)
+          @relative_conflict = relative_conflict
+        end
+
+        def call(sub, sup)
+          included = sub.map do |arm|
+            match = sup.filter_map do |other|
+              (rule = inclusion(arm, other)) && evidence(rule, arm, other.display)
+            end.first
+            match
+          end
+          return ["compatible", "proven_inclusion", included] if included.none?(nil)
+
+          sub.each do |arm|
+            rules = sup.map { |other| disjoint(arm, other) }
+            next if rules.any?(nil)
+
+            return ["conflict", "proven_disjoint_arm", [evidence(rules.first, arm, sup.map(&:display).join(" | "))]]
+          end
+          ["unknown", "unproven", []]
+        end
+
+        private
+
+        def evidence(rule, arm, against)
+          { "rule" => rule, "arm" => arm.display, "against" => against }
+        end
+
+        def inclusion(sub, sup)
+          return "equal" if sub.identity == sup.identity
+          return nil unless sup.kind == :class && sup.arguments.empty?
+          return nil unless @loader.class_type_param_names(sup.value).empty?
+
+          name = sub.kind == :literal ? sub.value.class.name : sub.value
+          unreliable = Environment::MemberConsistency::RbsProof::UNRELIABLE_ANCESTRY
+          return nil if unreliable.include?(name) || unreliable.include?(sup.value)
+          return nil unless @loader.ancestor_names_for(name).include?(sup.value)
+
+          sub.kind == :literal ? "literal_class_ancestor" : "class_ancestor"
+        end
+
+        def disjoint(left, right)
+          return nil if !@relative_conflict && (left.relative || right.relative)
+          return "distinct_literals" if left.kind == :literal && right.kind == :literal && !left.value.eql?(right.value)
+
+          disjoint_classes(left, right)
+        end
+
+        def disjoint_classes(left, right)
+          left_name = left.kind == :literal ? left.value.class.name : left.value
+          right_name = right.kind == :literal ? right.value.class.name : right.value
+          left_ancestors = @proof.class_ancestors(left_name)
+          right_ancestors = @proof.class_ancestors(right_name)
+          return nil if left_ancestors.nil? || right_ancestors.nil?
+
+          if left.kind == :literal
+            "literal_outside_class" unless left_ancestors.include?(right_name)
+          elsif right.kind == :literal
+            "literal_outside_class" unless right_ancestors.include?(left_name)
+          elsif !left_ancestors.include?(right_name) && !right_ancestors.include?(left_name)
+            "unrelated_classes"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rigor/lens/claims/request.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Rigor
+  module Lens
+    class Claims
+      class IntegrityError < StandardError; end
+
+      # Validates transport and source identity before the incremental session is started.
+      class Request
+        attr_reader :claims, :digest, :paths
+
+        def self.read(path, root:, arguments:)
+          bytes = File.binread(path).force_encoding(Encoding::UTF_8)
+          raise IntegrityError, "claims request is not UTF-8" unless bytes.valid_encoding?
+
+          new(JSON.parse(bytes), digest: Lens.digest(bytes), root: root, arguments: arguments)
+        rescue SystemCallError, JSON::ParserError => e
+          raise IntegrityError, "cannot read claims request: #{e.message}"
+        end
+
+        def initialize(data, digest:, root:, arguments:)
+          @digest = digest
+          @root = root
+          @arguments = arguments.map { |argument| File.expand_path(argument, root) }
+          validate_header(data)
+          @claims = data.fetch("claims")
+          @files = data.fetch("files")
+          @paths = {}
+          @readable_paths = Set.new
+          @preflight = true
+          @files.each { |file| validate_file(file) }
+          ids = []
+          @claims.each do |claim|
+            validate_claim(claim)
+            ids << claim.fetch("id")
+          end
+          require_value(ids.uniq.size == ids.size, "duplicate claim id")
+          verify_sources!
+          @preflight = false
+        end
+
+        def verify_sources!(targets = [])
+          @files.each do |file|
+            absolute = @paths.fetch(file.fetch("path"))
+            bytes = readable(absolute)
+            target = targets.find { |entry| entry.absolute == absolute }
+            require_value(bytes || (!@readable_paths.include?(absolute) && !target&.reader),
+                          "source became unreadable during analysis: #{file['path']}")
+            @readable_paths << absolute if @preflight && bytes
+            next unless bytes
+
+            require_value(Lens.digest(bytes) == file.fetch("digest"), "stale claims digest: #{file['path']}")
+            if target&.reader
+              require_value(target.reader.digest == file.fetch("digest"),
+                            "source changed during analysis: #{file['path']}")
+            end
+            verify_spans(file, bytes.bytesize)
+          end
+        end
+
+        private
+
+        def verify_spans(file, size)
+          @claims.select { |claim| claim.fetch("file") == file.fetch("path") }.each do |claim|
+            %w[declaration tag].each do |field|
+              require_value(claim.fetch(field).fetch("span").fetch("end_offset") <= size,
+                            "#{field} span outside #{file['path']}")
+            end
+          end
+        end
+
+        def validate_header(data)
+          require_value(data.is_a?(Hash), "claims request must be an object")
+          require_value(data["schema"] == "lens-claims-request/v0", "unsupported claims schema")
+          require_value(data["revision"].is_a?(Integer) && data["revision"] == 1, "unsupported claims revision")
+          require_value(data["grammar"] == "rbs", "unsupported claims grammar")
+          %w[files claims].each { |field| require_value(data[field].is_a?(Array), "#{field} must be an array") }
+        end
+
+        def validate_file(file)
+          strings(file, %w[path digest])
+          path = file.fetch("path")
+          absolute = File.expand_path(path, @root)
+          relative = Pathname(absolute).relative_path_from(Pathname(@root)).to_s
+          require_value(path == relative, "file path must be root-relative: #{path}")
+          require_value(@arguments.include?(absolute), "claims file is not a target: #{path}")
+          require_value(!@paths.key?(path), "duplicate claims file: #{path}")
+          require_value(file.fetch("digest").match?(/\Axxh3-64:[0-9a-f]{16}\z/), "invalid claims file digest")
+          @paths[path] = absolute
+        end
+
+        def validate_claim(claim)
+          strings(claim, %w[id file claim])
+          require_value(@paths.key?(claim.fetch("file")), "claim file is missing from files")
+          declaration = claim["declaration"]
+          strings(declaration, %w[kind owner scope name])
+          tag = claim["tag"]
+          strings(tag, %w[name])
+          require_value(tag.key?("subject") && (tag["subject"].nil? || tag["subject"].is_a?(String)),
+                        "tag subject must be a string or null")
+          [declaration, tag].each { |entry| validate_span(entry["span"]) }
+        end
+
+        def validate_span(span)
+          require_value(span.is_a?(Hash), "span must be an object")
+          start = span["start_offset"]
+          finish = span["end_offset"]
+          require_value(start.is_a?(Integer) && finish.is_a?(Integer) && start >= 0 && finish >= start,
+                        "invalid byte span")
+        end
+
+        def strings(object, fields)
+          require_value(object.is_a?(Hash), "claims entry must be an object")
+          fields.each { |field| require_value(object[field].is_a?(String), "#{field} must be a string") }
+        end
+
+        def require_value(condition, message)
+          raise IntegrityError, message unless condition
+        end
+
+        def readable(path)
+          File.binread(path) if File.file?(path)
+        rescue SystemCallError
+          nil
+        end
+      end
+    end
+  end
+end