rigortype 0.4.2 → 0.4.4

data/lib/rigor/inference/untyped_rejoin.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "../type"
+require_relative "../source/node_walker"
+require_relative "captured_locals"
+
+module Rigor
+  module Inference
+    # Issue #1840 — a branch merge that re-joins the narrowed edges of an untyped local gives it back its
+    # untyped binding.
+    #
+    # Flow narrowing concretizes a `Dynamic[top]` receiver (ADR-83): `x.nil?` splits it into `nil` and
+    # `Dynamic[top]`, and `when String` into `String` and `Dynamic[top]`. `Scope#join` unions the edges, so
+    # after both merges the local reads `Dynamic[top] | String | nil`. That union is not wrong as a set, but
+    # every member is a narrowing of the one untyped value, so it says nothing the pre-branch binding did
+    # not. It does, however, hold `nil` beside a nameable class, and `call.possible-nil-receiver` reports
+    # `x + "a"` on correct code although neither narrowing alone did.
+    #
+    # The rule: at a merge, a local whose pre-branch binding is exactly `Dynamic[top]`, that no merged arm
+    # writes, and whose joined binding is a union still carrying a `Dynamic` member, is bound to
+    # `Dynamic[top]` again.
+    #
+    # - The write test keeps a nil the program puts there: `x = nil if c` writes `x`, so the join stays
+    #   `Dynamic[top] | nil` and still reports. It is syntactic, over every local-write form under the arms
+    #   (a pattern capture and a block's write to the outer local included), so a doubtful arm keeps today's
+    #   join. It does not see a written nil that a `nil?` edge stripped before the merge (`x = nil if c; if
+    #   x.nil? … elsif x.is_a?(String) … end`): that merge's entry is exactly `Dynamic[top]`, and the outer
+    #   join's `Dynamic[top] | nil` is one the possible-nil gate declines anyway (#1876).
+    # - The `Dynamic`-member test keeps a narrowing whose surviving arms no longer cover the untyped value:
+    #   `case x when String then … when Integer then … else raise end` leaves `Integer | String`, which is
+    #   what `x` is past it.
+    # - Only the `Dynamic[top]` facet: a faceted `Dynamic[T]` carries static knowledge of its own (a
+    #   plugin's or a signature's `T`), so a `nil` its narrowing leaves may be one the facet promised. Those
+    #   keep today's join.
+    #
+    # Restoring `Dynamic[top]` is always sound, since every narrowed edge is a subset of it; what it drops
+    # is only the nameable arms, which an untyped union never needed to dispatch.
+    module UntypedRejoin
+      module_function
+
+      # `joined` with each qualifying local rebound to its `entry` binding. `arms` are the nodes whose
+      # evaluation produced the merged scopes (`nil` entries are skipped).
+      def apply(joined, entry, arms)
+        candidates = nil
+        joined.locals.each do |name, type|
+          next unless candidate?(entry.locals[name], type)
+
+          (candidates ||= []) << name
+        end
+        return joined if candidates.nil?
+
+        written = written_locals(arms)
+        kept = candidates.reject { |name| written.include?(name) }
+        return joined if kept.empty?
+
+        joined.with_rejoined_locals(kept.to_h { |name| [name, entry.locals[name]] })
+      end
+
+      def candidate?(entry_type, joined_type)
+        entry_type.is_a?(Type::Dynamic) && entry_type.static_facet.is_a?(Type::Top) &&
+          joined_type.is_a?(Type::Union) && joined_type.members.any?(Type::Dynamic)
+      end
+
+      def written_locals(arms)
+        names = Set.new
+        arms.each do |arm|
+          Source::NodeWalker.each(arm) do |node|
+            names << node.name if CapturedLocals::LOCAL_WRITE_NODES.include?(node.class)
+          end
+        end
+        names
+      end
+    end
+  end
+end

data/lib/rigor/language_server/project_context.rb

@@ -6,6 +6,7 @@ require_relative "../cache/store"
 require_relative "../analysis/runner"
 require_relative "../analysis/incremental_session"
 require_relative "../cache/incremental_snapshot"
+require_relative "../effects/identity"
 
 module Rigor
   module LanguageServer
@@ -24,6 +25,10 @@ module Rigor
     # are small (the per-publish path is already ≈2ms once Environment is warm).
     #
     # Invalidation:
+    # - Every whole-project round (`#project_diagnostics`) re-reads the configuration and compares the
+    #   incremental snapshot fingerprint and the `effects:` identity with the ones its session was primed with,
+    #   re-baselining on any change — so no file watcher or `didChangeConfiguration` is needed for
+    #   `.rigor.yml`, `sig/`, `pre_eval:` or lockfile edits (#1613).
     # - `#invalidate!` drops the cached environment AND project scan + bumps the generation counter; the next
     #   reader rebuilds. Watched-file changes (`workspace/didChangeWatchedFiles`) and configuration refreshes
     #   (`workspace/didChangeConfiguration`) both trigger this — the next publish observes the new project
@@ -44,8 +49,13 @@ module Rigor
       # invalidated never reach the editor.
       attr_reader :configuration, :generation
 
-      def initialize(configuration:)
+      # `configuration_loader` re-reads the configuration (e.g. `-> { Configuration.load(path) }`); a save round
+      # calls it so an edit to `.rigor.yml` (or a file it `includes:`) reaches the server without a restart. Nil
+      # keeps the configuration the context was built with.
+      def initialize(configuration:, configuration_loader: nil)
         @configuration = configuration
+        @configuration_loader = configuration_loader
+        @primed_key = nil
         @buffer_sources = {}
         @disk_feature_files = nil
         @environment_features = nil
@@ -110,16 +120,31 @@ module Rigor
       # The session is never persisted. Its state lives as long as this context, which is what a long-running
       # server needs, and writing it would race exactly the way the read-only {#cache_store} exists to avoid.
       # Seeding is therefore one-directional: the terminal warms the server, not the reverse.
+      #
+      # Every round recomputes {Cache::IncrementalSnapshot.fingerprint} (the function the CLI's `--incremental`
+      # keys its snapshot on — one input list) and compares it with the one the session was primed with. A
+      # session's recheck only sees source-file digests, so an edit to a `pre_eval:` file, an auto-detected
+      # `sig/*.rbs`, a lockfile or `.rigor.yml` would otherwise keep serving answers computed from the old
+      # inputs until the server restarts (#1613). A change — including a fingerprint that newly cannot be
+      # computed — drops the session and the world built from the old inputs and re-baselines, so the round equals
+      # a cold run. The `effects:` identity rides along because `Configuration#to_h` omits `effects:`, so the
+      # fingerprint alone does not move on an `effects:` edit. A fingerprint that was ALREADY uncomputable at
+      # priming is not a change: that session keeps rechecking.
+      # {#generation} is deliberately NOT bumped: the round that notices the change is itself computed from the
+      # new inputs, and the publisher discards a round whose generation moved.
       def project_diagnostics
+        reload_configuration
+        fingerprint = current_fingerprint
+        key = [fingerprint, Effects::Identity.digest(configuration: @configuration)]
+        rebaseline if @session_primed && key != @primed_key
         session = (@incremental_session ||= build_incremental_session)
         return session.recheck.diagnostics if @session_primed
 
         @session_primed = true
+        @primed_key = key
         diagnostics, = session.run_incremental(
           snapshot: Cache::IncrementalSnapshot.new(root: @configuration.cache_path),
-          fingerprint: Cache::IncrementalSnapshot.fingerprint(
-            configuration: @configuration, roots: @configuration.paths
-          ),
+          fingerprint: fingerprint,
           persist: false
         )
         diagnostics
@@ -153,6 +178,13 @@ module Rigor
       # `workspace/didChangeConfiguration`.
       def invalidate!
         @generation += 1
+        reset_world
+      end
+
+      private
+
+      # Drops what was built from the previous inputs, without touching {#generation}.
+      def reset_world
         @environment = nil
         @environment_features = nil
         @disk_feature_files = nil
@@ -161,12 +193,31 @@ module Rigor
         # outlive them. The next save round primes a fresh one.
         @incremental_session = nil
         @session_primed = false
+        @primed_key = nil
         # Cache store stays — it's content-addressed; a stale env build won't be served because the file
         # digest mixed into the cache key has changed.
         nil
       end
 
-      private
+      # A changed configuration may also move `cache_path`, so the store goes too (unlike {#invalidate!}).
+      def rebaseline
+        reset_world
+        @cache_store = nil
+      end
+
+      def current_fingerprint
+        Cache::IncrementalSnapshot.fingerprint(configuration: @configuration, roots: @configuration.paths)
+      end
+
+      # A load that raises (a half-typed `.rigor.yml`) keeps the previous configuration: the editor must not
+      # lose its diagnostics to a transient parse error, and the next round retries.
+      def reload_configuration
+        return unless @configuration_loader
+
+        @configuration = @configuration_loader.call
+      rescue StandardError
+        nil
+      end
 
       # The session shares this context's warm Environment, so a round does not rebuild the RBS universe. It
       # deliberately does NOT share the prebuilt ProjectScan: a round runs after a save, i.e. after the file

data/lib/rigor/lens/anchor.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require_relative "../hashing/xxh3"
+
+module Rigor
+  module Lens
+    # A site's anchor and contract-comment span (docs/internal-spec/lens.md § Anchors). The hashed material is the
+    # contract comment lines above the declaration (`#:`, `@rbs`, `@extrbs` and their continuation lines), the
+    # declaration's own bytes, and a `#:` comment trailing its last line. Documentation prose is not part of it.
+    class Anchor
+      Result = Data.define(:token, :line, :contract_comments)
+
+      # rbs-inline's annotation grammar (`#:`, `#[`, `#\s*@rbs`) plus `@extrbs`, matched from the `#`.
+      CONTRACT_COMMENT = /\A#(?::|\[|\s*@rbs\b|\s*@extrbs\b)/
+      # A `#:nodoc:`-style RDoc directive, which the rbs-inline plugin neutralises rather than reads.
+      RDOC_DIRECTIVE = /\A#:[a-z_][\w-]*:/
+      # A kept line that later comment lines may continue, with the spaces between its `#` and the tag.
+      CONTINUED_TAG = /\A#( *)@(?:rbs|extrbs)\b/
+
+      # @param source — the file's bytes (binary String)
+      # @param comments — the file's `Prism::Comment` list
+      def initialize(source, comments)
+        @source = source.b
+        @line_starts = [0]
+        @source.each_byte.with_index { |byte, index| @line_starts << (index + 1) if byte == 10 }
+        @comment_by_line = {}
+        comments.each do |comment|
+          next unless comment.is_a?(Prism::InlineComment)
+
+          @comment_by_line[comment.location.start_line] = comment
+        end
+      end
+
+      # The anchor of the declaration spanning bytes `start_offset...end_offset` and lines `start_line..end_line`.
+      def for_span(start_offset, end_offset, start_line, end_line, leading: true, trailing: true)
+        leading = leading ? leading_contract_comments(start_line) : []
+        trailing = trailing ? trailing_contract_comment(end_line, end_offset) : nil
+        material = +"".b
+        leading.each { |comment| material << line_text_from(comment.location.start_offset) << "\n" }
+        material << @source.byteslice(start_offset, end_offset - start_offset)
+        material << "\n" << line_text_from(trailing.location.start_offset) if trailing
+        line = leading.empty? ? start_line : leading.first.location.start_line
+        Result.new(token: "#{line}:#{Hashing::XXH3.anchor_hash(material)}", line: line,
+                   contract_comments: leading + [trailing].compact)
+      end
+
+      private
+
+      # The contract comments among the contiguous comment-only lines directly above `start_line`, in file order,
+      # with rbs-inline's continuation lines below a kept `@rbs` / `@extrbs` line.
+      def leading_contract_comments(start_line)
+        run = []
+        line = start_line - 1
+        while line >= 1 && (comment = comment_only_line(line))
+          run.unshift(comment)
+          line -= 1
+        end
+        kept = []
+        tag_indent = nil
+        run.each do |comment|
+          text = comment_text(comment)
+          if tag_indent && hash_indent(text) > tag_indent
+            kept << comment
+            next
+          end
+
+          tag_indent = nil
+          next unless contract_comment?(text)
+
+          kept << comment
+          continued = text.match(CONTINUED_TAG)
+          tag_indent = continued && continued[1].size
+        end
+        kept
+      end
+
+      def trailing_contract_comment(end_line, end_offset)
+        comment = @comment_by_line[end_line]
+        return nil if comment.nil? || comment.location.start_offset < end_offset
+
+        text = comment_text(comment)
+        contract_comment?(text) && text.start_with?("#:") ? comment : nil
+      end
+
+      def contract_comment?(text)
+        text.match?(CONTRACT_COMMENT) && !text.match?(RDOC_DIRECTIVE)
+      end
+
+      # The spaces between a comment's `#` and its first non-space byte.
+      def hash_indent(text)
+        text[/\A#( *)/, 1].size
+      end
+
+      # The comment on `line` when nothing but whitespace precedes it.
+      def comment_only_line(line)
+        comment = @comment_by_line[line]
+        return nil if comment.nil?
+
+        prefix = @source.byteslice(@line_starts[line - 1], comment.location.start_offset - @line_starts[line - 1])
+        prefix.match?(/\A[ \t]*\z/) ? comment : nil
+      end
+
+      # The comment's text from its `#`, without a line terminator.
+      def comment_text(comment)
+        comment.location.slice.b.chomp.delete_suffix("\r")
+      end
+
+      # The bytes from `offset` to the end of its line, without the line terminator.
+      def line_text_from(offset)
+        line_end = @source.index("\n", offset) || @source.bytesize
+        @source.byteslice(offset, line_end - offset).delete_suffix("\r")
+      end
+    end
+  end
+end

data/lib/rigor/lens/contract_reader.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require_relative "slot"
+require_relative "../reflection"
+
+module Rigor
+  module Lens
+    # Reads a member's own RBS declaration into overloads with per-slot provenance (docs/internal-spec/lens.md
+    # § Members). A declaration the member inherits is not its contract; one written for its own class is, whether
+    # it comes from `sig/`, an inline comment, a plugin or a library.
+    class ContractReader
+      INFERRED_RETURN = "rigor:v1:inferred-return"
+      INFERRED_SIGNATURE = "rigor:v1:inferred-signature"
+
+      # `overloads` hold `{rbs, params, block, return}`; a return the contract leaves to inference is nil there,
+      # with `return_inferred` set. `buffers` are the declaring buffer names.
+      Contract = Data.define(:overloads, :provenance, :path, :return_inferred, :buffers)
+
+      def initialize(provenance)
+        @provenance = provenance
+      end
+
+      # The member's contract, or nil when it has none of its own. `name` is the Ruby method name.
+      def read(owner, scope, name, lookup_scope)
+        method = lookup(owner, scope, name, lookup_scope)
+        defs = method ? method.defs.select { |definition| definition.defined_in.to_s.delete_prefix("::") == owner } : []
+        return nil if defs.empty?
+
+        annotations = annotations_of(method, defs)
+        return nil if annotations.include?(INFERRED_SIGNATURE)
+
+        contract(defs, annotations)
+      rescue StandardError
+        unreadable("definition_build_failed", [])
+      end
+
+      # The declared type of the constant `name` (qualified), as a slot with its declaration's provenance, or nil
+      # when no RBS or inline declaration names it.
+      def read_constant(name, environment)
+        declaration = environment&.rbs_loader&.constant_declaration(name)
+        return nil if declaration.nil?
+
+        type, buffer = declaration
+        provenance, path = @provenance.classify(buffer)
+        return Slot.unavailable("not_computed") if provenance.nil?
+
+        Slot.from_rbs(type, provenance, path)
+      rescue StandardError
+        Slot.unavailable("not_computed")
+      end
+
+      private
+
+      def contract(defs, annotations)
+        buffers = defs.map { |definition| buffer_name(definition) }
+        classified = buffers.map { |buffer| @provenance.classify(buffer) }
+        return unreadable("not_computed", buffers) if classified.include?(nil)
+
+        return_inferred = annotations.include?(INFERRED_RETURN)
+        authored = annotations.select do |string|
+          string.start_with?("rigor:v1:") && !string.start_with?(INFERRED_RETURN)
+        end
+        # Each overload carries the provenance of the declaration it came from: a `sig/` overload extending a
+        # library declaration reads `sig`, the library one `library`.
+        overloads = defs.zip(classified).map do |definition, (provenance, path)|
+          overload(definition.type, provenance, path, return_inferred, authored)
+        end
+        provenance, path = classified.first
+        Contract.new(overloads: overloads, provenance: provenance, path: path,
+                     return_inferred: return_inferred, buffers: buffers)
+      end
+
+      # The method's and its own declarations' annotation strings: the plugin's defaulted-slot marks and authored
+      # `%a{…}`.
+      def annotations_of(method, defs)
+        strings = method.annotations.map(&:string) + defs.flat_map { |definition| definition.annotations.map(&:string) }
+        strings.map(&:strip).uniq
+      end
+
+      def buffer_name(definition)
+        location = definition.member&.location
+        location ? location.buffer&.name.to_s : ""
+      end
+
+      def lookup(owner, scope, name, lookup_scope)
+        if scope == :singleton
+          Reflection.singleton_method_definition(owner, name.to_sym, scope: lookup_scope)
+        else
+          Reflection.instance_method_definition(owner, name.to_sym, scope: lookup_scope)
+        end
+      end
+
+      # A declaration Rigor cannot read: its buffer name did not survive the environment cache
+      # (`not_computed`), or building the member's definition failed (`definition_build_failed`). The member has a
+      # contract, so it is not inferred; every slot is unavailable, and so are its parameters (`params: null`).
+      def unreadable(reason, buffers)
+        Contract.new(overloads: [{ "rbs" => nil, "params" => nil, "block" => nil,
+                                   "return" => Slot.unavailable(reason) }],
+                     provenance: nil, path: nil, return_inferred: false, buffers: buffers)
+      end
+
+      def overload(method_type, provenance, path, return_inferred, annotations)
+        function = method_type.type
+        params = function.respond_to?(:required_positionals) ? params_of(function, provenance, path) : nil
+        block = method_type.block && { "required" => method_type.block.required,
+                                       "type" => Slot.from_rbs(method_type.block.type.to_s, provenance, path) }
+        prefix = annotations.map { |string| "%a{#{string}} " }.join
+        return_slot = return_inferred ? nil : Slot.from_rbs(function.return_type.to_s, provenance, path)
+        { "rbs" => "#{prefix}#{method_type}", "params" => params, "block" => block, "return" => return_slot,
+          "return_rbs" => function.return_type.to_s }
+      end
+
+      def params_of(function, provenance, path)
+        (positional_params(function) + keyword_params(function)).map do |kind, name, param|
+          { "name" => name&.to_s, "kind" => kind, "type" => Slot.from_rbs(param.type.to_s, provenance, path) }
+        end
+      end
+
+      def positional_params(function)
+        function.required_positionals.map { |param| ["required", param.name, param] } +
+          function.optional_positionals.map { |param| ["optional", param.name, param] } +
+          [function.rest_positionals].compact.map { |param| ["rest", param.name, param] } +
+          function.trailing_positionals.map { |param| ["post", param.name, param] }
+      end
+
+      def keyword_params(function)
+        function.required_keywords.map { |name, param| ["keyreq", name, param] } +
+          function.optional_keywords.map { |name, param| ["key", name, param] } +
+          [function.rest_keywords].compact.map { |param| ["keyrest", param.name, param] }
+      end
+    end
+  end
+end

data/lib/rigor/lens/document.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "json"
+
+require_relative "../version"
+require_relative "../cache/engine_source"
+require_relative "../analysis/run_cache_key"
+
+module Rigor
+  module Lens
+    # Assembles the `lens/v0` document (docs/internal-spec/lens.md § Document) from a {Run::Outcome}.
+    class Document
+      SITE_FIELDS = %w[key kind name owner scope attribute members module_function builder ordinal span contract_span
+                       anchor visibility contract params block body_return value alias_of].freeze
+
+      def initialize(outcome:, configuration:, root:, config_path:)
+        @outcome = outcome
+        @configuration = configuration
+        @root = root
+        @config_path = config_path
+      end
+
+      def to_h
+        { "schema" => SCHEMA, "revision" => REVISION, "producer" => producer, "context" => context,
+          "capabilities" => CAPABILITIES, "files" => @outcome.targets.map { |target| file(target) },
+          "members" => @outcome.member_rows }
+      end
+
+      private
+
+      def producer
+        identity = begin
+          Cache::EngineSource.process_identity
+        rescue StandardError
+          "unknown"
+        end
+        { "name" => "rigor", "version" => Rigor::VERSION, "engine_source" => identity }
+      end
+
+      def context
+        fields = {
+          "config" => @config_path && relative(File.expand_path(@config_path)),
+          "target_ruby" => @configuration.target_ruby,
+          "rbs_version" => rbs_version,
+          "signature_roots" => signature_roots.map { |root| relative(root) },
+          "signature_digest" => signature_digest,
+          "plugins" => @outcome.plugins,
+          "lockfiles" => lockfiles
+        }
+        fields.merge("digest" => Lens.digest(JSON.generate(fields)))
+      end
+
+      def rbs_version
+        require "rbs"
+        RBS::VERSION
+      end
+
+      def signature_roots
+        Environment.project_signature_roots(@configuration.signature_paths).map { |path| File.expand_path(path.to_s) }
+      end
+
+      def signature_digest
+        listing = signature_roots.flat_map { |root| Dir.glob(File.join(root, "**", "*.rbs")) }.sort.map do |path|
+          "#{relative(path)}\t#{Lens.digest(File.binread(path))}\n"
+        end
+        Lens.digest(listing.join)
+      end
+
+      def lockfiles
+        Analysis::RunCacheKey.resolved_lockfile_paths(@configuration).compact.filter_map do |path|
+          absolute = File.expand_path(path.to_s)
+          next unless File.file?(absolute)
+
+          { "path" => relative(absolute), "digest" => Lens.digest(File.binread(absolute)) }
+        end
+      end
+
+      # Every field is present; those that apply only to some statuses are null elsewhere (lens.md § Files).
+      def file(target)
+        read = %w[ok parse_error].include?(target.status)
+        head = { "argument" => target.argument, "path" => target.status == "not_found" ? nil : target.path,
+                 "status" => target.status, "reason" => target.status == "ok" ? nil : target.reason,
+                 "digest" => file_digest(target, read) }
+        head.merge(analysed_fields(target.status == "ok" ? target : nil))
+            .merge("diagnostics" => read ? target.diagnostics.map { |diagnostic| diagnostic_row(diagnostic) } : nil)
+            .merge("inputs" => target.status == "ok" ? target.inputs : nil)
+      end
+
+      # The digest of the bytes the analysis read; a file that did not parse is read once more.
+      def file_digest(target, read)
+        return nil unless read
+        return target.reader.digest if target.reader
+
+        Lens.digest(File.binread(target.absolute))
+      end
+
+      def analysed_fields(target)
+        reader = target&.reader
+        { "complete" => reader && reader.omissions.empty?, "omissions" => reader&.omissions,
+          "sites" => reader&.sites&.map { |site| site.data.slice(*SITE_FIELDS) } }
+      end
+
+      def diagnostic_row(diagnostic)
+        { "rule" => diagnostic.qualified_rule, "severity" => diagnostic.severity.to_s,
+          "message" => diagnostic.message, "line" => diagnostic.line, "column" => diagnostic.column }
+      end
+
+      def relative(absolute)
+        Pathname(absolute).relative_path_from(Pathname(@root)).to_s
+      end
+    end
+  end
+end