rigortype 0.4.6 → 0.4.7

data/lib/rigor/environment/member_consistency/comparator.rb

@@ -14,7 +14,7 @@ module Rigor
       # declared types. See {MemberConsistency} for the rule; this class holds the type work.
       #
       # A contradiction is reported only where it is PROVEN: no value, and no call, satisfies both sides.
-      # Everything short of a proof is undecided. Four places carry that burden:
+      # Everything short of a proof is undecided. Five places carry that burden:
       #
       # - {#disjoint?} proves two types share no value, from the RBS hierarchy of Ruby core and stdlib
       #   classes ({RbsProof}) only: two such classes neither of which is an RBS ancestor of the other, or a
@@ -103,6 +103,7 @@ module Rigor
         #   `:inline` (the inline side is more precise), `:contradiction` or `:undecided`; `detail` names the
         #   deciding position for the two reported outcomes and is nil otherwise.
         def compare(signature_member, inline_member, method_name)
+          return compare_variables(signature_member, inline_member) if variable?(signature_member)
           return EQUAL if same_declaration?(signature_member, inline_member)
           return SIGNATURE_MORE_PRECISE if inferred_signature?(inline_member)
 
@@ -174,6 +175,22 @@ module Rigor
           member_annotation_strings(member).include?(INFERRED_SIGNATURE_DIRECTIVE)
         end
 
+        def variable?(member)
+          member.is_a?(::RBS::AST::Members::InstanceVariable) ||
+            member.is_a?(::RBS::AST::Members::ClassInstanceVariable)
+        end
+
+        # Issue #2440 — an instance variable (or class instance variable) declared on both sides. Two
+        # declarations of one type are equal and merge silently. Any other pair is undecided, never ranked
+        # and never a contradiction: `sig/` binds and the inline declaration is reported at `:info`. A
+        # variable has no call to satisfy, so "more precise" has no reader to favour, and the committed
+        # `.rbs` (typically `rbs-inline --output`'s own) is the declaration the project's other tools read.
+        def compare_variables(signature_member, inline_member)
+          return EQUAL if signature_member.type == inline_member.type
+
+          [:undecided, "the type is `#{signature_member.type}` in `sig/` and `#{inline_member.type}` inline"]
+        end
+
         def compare_aliases(signature_member, inline_member)
           both = signature_member.is_a?(::RBS::AST::Members::Alias) && inline_member.is_a?(::RBS::AST::Members::Alias)
           return EQUAL if both && signature_member.old_name == inline_member.old_name

data/lib/rigor/environment/member_consistency.rb

@@ -59,6 +59,9 @@ module Rigor
       NO_RECORDS = [].freeze
       private_constant :NO_RECORDS
 
+      # The key kinds {.member_keys} gives a variable member.
+      VARIABLE_KINDS = %i[instance_variable class_instance_variable].freeze
+
       # What a disjointness proof may lean on (ADR-112 WD5, #1075): the RBS class hierarchy the analysis
       # itself uses, restricted to classes Ruby core and the stdlib declare. Never Ruby constants loaded in
       # the analyzer process — those depend on which libraries happen to be required, and rbs and Ruby
@@ -115,8 +118,8 @@ module Rigor
       class << self
         # @param signature_members — `{[class, method, kind] => [signature_path, member, visibility]}`, the
         #   first project `.rbs` member declaring each key, with its effective visibility.
-        # @param inline_members — `[[virtual_name, class_name, member, visibility], ...]`, every member the
-        #   inline sources declare.
+        # @param inline_members — `[[virtual_name, class_name, member, visibility, nesting], ...]`, every member
+        #   the inline sources declare, with the lexical nesting {.member_keys} keys a mixin by.
         # @param shadowable — the first segment of every class / module name the project's inputs declare
         #   ({Comparator#initialize}).
         # @param proof — an {RbsProof} for the reported rows, or nil for the environment build.
@@ -131,9 +134,9 @@ module Rigor
 
           state = { comparator: Comparator.new(shadowable, proof: proof), records: [], inline: Set.new,
                     signature: Hash.new { |hash, file| hash[file] = Set.new }, checked: {}.compare_by_identity }
-          inline_members.each do |virtual_name, class_name, member, visibility|
+          inline_members.each do |virtual_name, class_name, member, visibility, nesting|
             state[:records].concat(refinement_records(state, class_name, member, nil, virtual_name))
-            resolve_member(state, signature_members, [virtual_name, class_name, member, visibility])
+            resolve_member(state, signature_members, [virtual_name, class_name, member, visibility, nesting])
           end
           Resolution.new(
             records: state[:records].uniq.sort_by { |r| record_sort_key(r) }.freeze,
@@ -159,11 +162,57 @@ module Rigor
           end
         end
 
+        # Issue #2440 — every key one RBS member contributes to a definition build: its method keys
+        # ({.member_method_keys}) and, for an instance variable (`@x: T`) or a class instance variable
+        # (`self.@x: T`), `[:@x, :instance_variable]` / `[:@x, :class_instance_variable]`. rbs 4.2 raises
+        # `InstanceVariableDuplicationError` / `ClassInstanceVariableDuplicationError` for two of those in one
+        # class even when the types agree, so a `sig/` and an inline declaration of one has to be reconciled
+        # like a method. A method name never starts with `@`, so the two key spaces cannot meet. A class
+        # variable (`@@x`) contributes nothing: rbs does not reject a duplicate. Neither does an attribute's
+        # implied instance variable, which rbs lets an explicit `@x` declaration override.
+        #
+        # A mixin (`include M`, `extend M`, `prepend M`) is keyed by the lexical nesting of the declaration
+        # it sits in and the module and type arguments exactly as written, `[:"A/C|M[String]", :include]`:
+        # rbs 4.2 counts every instance variable `M` declares once per declaration of the class that mixes it
+        # in, so the same `include M` in `sig/` and inline raises `InstanceVariableDuplicationError ... in ::M`
+        # for the class. A relative name resolves through the nesting it is written in, so `include M` inside
+        # `module A; class C` (`A::M` when that exists) and inside `class A::C` (`::M`) are different mixins,
+        # and so are `M` and `::M`; only an identical spelling in an identical nesting is the same member and
+        # stands down. `rbs-inline --output` mirrors the Ruby file's nesting, so its committed output still
+        # pairs with the inline buffer. A mixin with different arguments keys differently and is left alone.
+        # Two members sharing a mixin key declare no method types to compare, so they read as equal.
+        #
+        # `nesting` is the declaration names as written, outermost first, joined by `/`
+        # ({RbsLoader.each_declared_member}); nil keys a mixin by its spelling alone.
+        #
+        # Kept apart from {.member_method_keys} on purpose: the plugin-signature plans key collisions by
+        # method only, and this rule is the inline-vs-`sig/` one.
+        def member_keys(member, nesting = nil)
+          case member
+          when ::RBS::AST::Members::InstanceVariable then [[member.name, :instance_variable]]
+          when ::RBS::AST::Members::ClassInstanceVariable then [[member.name, :class_instance_variable]]
+          when ::RBS::AST::Members::Include then [[mixin_key(member, nesting), :include]]
+          when ::RBS::AST::Members::Extend then [[mixin_key(member, nesting), :extend]]
+          when ::RBS::AST::Members::Prepend then [[mixin_key(member, nesting), :prepend]]
+          else member_method_keys(member)
+          end
+        end
+
+        # Whether a key `kind` names a variable rather than a method.
+        def variable_kind?(kind)
+          VARIABLE_KINDS.include?(kind)
+        end
+
         private
 
+        def mixin_key(member, nesting)
+          args = member.args.empty? ? "" : "[#{member.args.join(', ')}]"
+          :"#{nesting}|#{member.name}#{args}"
+        end
+
         def resolve_member(state, signature_members, inline)
-          _virtual_name, class_name, member, = inline
-          overlapping = member_method_keys(member).filter_map do |method_name, kind|
+          _virtual_name, class_name, member, _visibility, nesting = inline
+          overlapping = member_keys(member, nesting).filter_map do |method_name, kind|
             key = [class_name, method_name, kind]
             owner = signature_members[key]
             owner && [key, *owner]
@@ -235,7 +284,7 @@ module Rigor
         end
 
         def full_keys(class_name, member)
-          member_method_keys(member).map { |method_name, kind| [class_name, method_name, kind] }
+          member_keys(member).map { |method_name, kind| [class_name, method_name, kind] }
         end
 
         # The `.rbs` line is read only for an outcome that reports it: asking an `RBS::Buffer` for a line

data/lib/rigor/environment/missing_gem_constant_index.rb

@@ -107,8 +107,9 @@ module Rigor
       # difference is worth stating because the two look like the same problem. There, a stale
       # `bundler/gems/` directory left behind by a gem that moved to a released version made the loader
       # load the WRONG SIGNATURES, collapsing the RBS environment. Here the index's whole output is a gem
-      # NAME, so reading a stale checkout of the same gem yields the same answer; and the rubygems lookup
-      # is consulted FIRST in {.build}, so a gem now installed from RubyGems never reaches this map at all.
+      # NAME, so reading a stale checkout of the same gem yields the same answer; and the RubyGems-layout
+      # bundle directory is consulted FIRST in {.build}, so a gem installed from RubyGems at its locked
+      # version never reaches this map.
       def git_gem_dirs(bundle_path)
         return {} if bundle_path.nil?
 

data/lib/rigor/environment/project_path_gems.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require_relative "../analysis/path_expansion"
+
+module Rigor
+  class Environment
+    # Issue #2441 — the locked gems that ARE the analysed project: a `PATH` stanza whose directory Rigor analyses
+    # as project source. `rbs collection install` still fetches community RBS for such a gem (its generator skips
+    # only a `gemspec` source), and the project's `sig/` declares the same classes, so the collection copy would
+    # double-declare every member. The same gem is not `:missing` RBS either, so it must not make an ADR-72
+    # overlay or a WD9 missing-gem index entry eligible.
+    #
+    # "Analysed as project source" means the gem's directory is at or under one of the configured `paths:`
+    # entries, or contains one: rails lists `actionpack/lib` in `paths:` and locks `actionpack` from
+    # `PATH remote: actionpack`. A `PATH` gem no `paths:` entry reaches — a vendored `vendor/gems/foo`, a sibling
+    # checkout — is a dependency and keeps its collection RBS.
+    #
+    # #2592 — a reached gem counts only when the file walker would analyse at least one of its Ruby files: some
+    # `**/*.rb` under the part of the gem a `paths:` entry covers survives `Analysis::PathExpansion.reject_excluded`.
+    # A gem whose Ruby the configuration's `exclude:` patterns all leave out — `vendor/**`, `vendor/**/*.rb`, or
+    # `vendor/gems/foo/lib/**` when `lib/` holds all of it — keeps its collection RBS, and so does a reached
+    # directory with no Ruby at all. A `paths:` entry naming one `.rb` file inside the gem counts that file. The
+    # overlap is found on real paths, so a symlinked spelling of the same directory matches, but the files are
+    # walked and matched against `exclude:` through the `paths:` entry as written, as the walker matches them.
+    module ProjectPathGems
+      module_function
+
+      # @param locked — `{name => LockfileResolver::LockedGem}`.
+      # @param paths — the configured `paths:` entries; relative ones resolve against `root`.
+      # @param exclude_patterns — the configuration's `exclude_patterns`, matched against `exclude_base`.
+      # @return frozen set of gem names. Empty when `paths` is nil or empty.
+      def names(locked, paths:, root: Dir.pwd, exclude_patterns: [], exclude_base: root)
+        entries = Array(paths).map do |path|
+          logical = File.expand_path(path.to_s, root.to_s)
+          [logical, real(logical)]
+        end.uniq
+        return Set.new.freeze if entries.empty?
+
+        locked.each_value.filter_map do |gem|
+          dir = gem.path_source
+          next unless dir
+
+          dir = real(dir)
+          covered = entries.filter_map { |logical, real_entry| covered_part(dir, logical, real_entry) }
+          gem.name if covered.uniq.any? { |part| analysed_ruby?(part, Array(exclude_patterns), exclude_base.to_s) }
+        end.to_set.freeze
+      end
+
+      # The part of the gem at real directory `dir` that the `paths:` entry covers, spelled through the entry as
+      # written (`logical`), as the file walker spells the files it matches `exclude:` against: the entry itself
+      # when it lies at or under the gem, or the gem's directory reached through the entry when the gem lies under
+      # it. Nil when they do not overlap.
+      def covered_part(dir, logical, real_entry)
+        return logical if at_or_under?(real_entry, dir)
+        return unless at_or_under?(dir, real_entry)
+
+        rest = dir.byteslice(real_entry.bytesize..).delete_prefix("/")
+        rest.empty? ? logical : File.join(logical, rest)
+      end
+
+      # True when `path` is `dir` or lies under it. Joined with a `/` only when `dir` does not already end in one,
+      # so `/` reaches everything without spelling `//`, and `/proj/lib2` is not under `/proj/lib`.
+      def at_or_under?(path, dir)
+        return true if path == dir
+
+        path.start_with?(dir.end_with?("/") ? dir : "#{dir}/")
+      end
+
+      # Files are matched in slices as the walk finds them, so a large gem stops at the first slice holding a
+      # surviving file instead of listing its whole tree first (`Dir.glob` with a block still builds the list).
+      EXCLUDE_SLICE = 64
+      private_constant :EXCLUDE_SLICE
+
+      # True when the file walker ({Analysis::PathExpansion.ruby_files}) would analyse some `.rb` file of `part`:
+      # the `.rb` file itself when `part` names one, else a `**/*.rb` under the directory, that survives `patterns`.
+      def analysed_ruby?(part, patterns, base)
+        return surviving?([part], patterns, base) if File.file?(part)
+        return false unless File.directory?(part)
+
+        slice = []
+        found = each_ruby_file(part) do |file|
+          slice << file
+          next false if slice.size < EXCLUDE_SLICE
+
+          hit = surviving?(slice, patterns, base)
+          slice = []
+          hit
+        end
+        found || surviving?(slice, patterns, base)
+      end
+
+      # Walks `dir` as `Dir.glob("dir/**/*.rb")` matches: sorted, no dot-named entries, no descent through a
+      # symlinked directory. Stops and returns true as soon as the block returns true.
+      def each_ruby_file(dir, &)
+        Dir.children(dir).sort.each do |name|
+          next if name.start_with?(".")
+
+          path = File.join(dir, name)
+          if name.end_with?(".rb") && !File.directory?(path)
+            return true if File.exist?(path) && yield(path)
+          elsif File.directory?(path) && !File.symlink?(path)
+            return true if each_ruby_file(path, &)
+          end
+        end
+        false
+      rescue SystemCallError
+        false
+      end
+
+      def surviving?(files, patterns, base)
+        return false if files.empty?
+        return files.any? { |file| file.end_with?(".rb") } if patterns.empty?
+
+        Analysis::PathExpansion.reject_excluded(files, patterns, base: base).any? { |file| file.end_with?(".rb") }
+      end
+
+      def real(path)
+        File.realpath(path)
+      rescue SystemCallError
+        File.expand_path(path)
+      end
+    end
+  end
+end

data/lib/rigor/environment/rbs_hierarchy.rb

@@ -41,21 +41,12 @@ module Rigor
         end
       end
 
-      # Issue #696 review, second pass — the ancestry lookup moved to {RbsLoader#ancestor_names_for}, and
-      # what moved with it is the reason.
-      #
-      # This method used to fetch `Cache::RbsClassAncestorTable` DIRECTLY, bypassing the loader's own
-      # accessor, and branch on `loader.cache_store`: a whole-universe table build with a store, a
-      # single-class demand without one. Same project, same question, three different answers to "which
-      # classes failed to build" — 504 on a cold store, 0 on a warm one, 2 with no store. On the DEFAULT
-      # `--workers=0` path nothing pre-warms the store, so the cold answer was the one written into the
-      # run-result cache and replayed until a file changed.
-      #
-      # The cache-state branch still exists — it is worth 50x on the warm path — but it lives behind the
-      # loader now, where both of its sides are marked as RIGOR'S OWN demand. Ordering two classes is not
-      # the analysis asking whether either one's methods resolve, so neither side reaches the diagnostic,
-      # and the answer is identical on both (the table's producer computes exactly this, keyed the same
-      # way). What this method keeps is its own per-name memo, which is about repeated comparisons.
+      # Issue #696 review, second pass — the ancestry lookup lives in {RbsLoader#ancestor_names_for}.
+      # Read directly from `Cache::RbsClassAncestorTable`, the same question gave 504 failed classes on a
+      # cold store, 0 on a warm one and 2 with no store, and the cold answer was cached into the run result.
+      # Through the loader, both cache states are marked as Rigor's own demand, so ordering two classes
+      # never reaches the "which classes failed to build" diagnostic. The cache-state branch stays behind
+      # the loader (it is worth 50x on the warm path); this method keeps only its per-name memo.
       def ancestor_names(class_name)
         key = normalize_name(class_name)
         return @ancestor_names_cache[key] if @ancestor_names_cache.key?(key)