rigortype 0.3.5 → 0.3.7

data/lib/rigor/sig_gen/generator.rb

@@ -41,7 +41,7 @@ module Rigor
       UnrenderableMethod = Data.define(:path, :class_name, :method_name, :rbs, :error)
 
       # @return [Array<UnrenderableMethod>] empty on a healthy run; read after {#run}.
-      attr_reader :unrenderable
+      attr_reader :unrenderable, :unresolvable_superclasses
 
       # @param configuration [Rigor::Configuration]
       # @param paths [Array<String>] files / directories to scan.
@@ -65,6 +65,10 @@ module Rigor
         @meta_layouts = {}
         # Whole-run, NOT per-file: a rendering defect is reported once at the end of the run.
         @unrenderable = []
+        # Issue #735 — whole-run too: `{ class name => the superclass token that resolves nowhere }`.
+        @unresolvable_superclasses = {}
+        # Issue #722 — whole-run: `{ class name => the lexical nesting its header is written in }`.
+        @superclass_nestings = {}
       end
 
       # Lifts legacy plain-`Array[Type]` observation entries into {ObservedCall} carriers. Specs from the
@@ -80,11 +84,229 @@ module Rigor
       def run
         @environment = build_environment
         resolved = resolve_paths(@paths)
-        resolved.flat_map { |path| analyse_file(path, @environment) }
+        candidates = resolved.flat_map { |path| analyse_file(path, @environment) }
+        demote_overridden_base_methods(
+          demote_unresolvable_superclasses(resolve_superclass_spellings(candidates))
+        )
       end
 
       private
 
+      # Issue #744 — a base class's method is NOT emitted when a project subclass overrides it and the
+      # override is not emitted itself.
+      #
+      # RBS resolves an undeclared subclass method through its ancestors, so a precise return written for
+      # the base becomes the subclass's answer. redmine's `FieldFormat::Base#target_class` honestly returns
+      # `nil`; `RecordList#target_class` overrides it with a real lookup that sig-gen could not type, and
+      # the emitted `def target_class: () -> nil` then produced four `undefined method … for nil` on the
+      # subclass's own working code, plus a `def.return-type-mismatch` telling the user their correct
+      # override was wrong.
+      #
+      # Emitting nothing puts both classes back on source inference, which answers correctly for each. The
+      # base keeps its signature whenever nothing overrides the method, and whenever the override IS
+      # emitted with a type of its own — the declaration is only dangerous when it is the only one.
+      #
+      # Whether an inherited declaration SHOULD outrank a class's own source `def` is a separate question
+      # (#744 half 2) and is not decided here: this pass only stops sig-gen manufacturing the conflict.
+      def demote_overridden_base_methods(candidates)
+        superclasses = candidates.each_with_object({}) do |candidate, acc|
+          (candidate.class_superclasses || {}).each { |name, sup| acc[name] = sup.sub(/\[.*\]\z/, "") }
+        end
+        return candidates if superclasses.empty?
+
+        overridden = unsigned_override_ancestors(candidates, superclasses)
+        return candidates if overridden.empty?
+
+        candidates.map do |candidate|
+          next candidate unless Classification::EMITTABLE.include?(candidate.classification)
+          next candidate unless overridden.include?([candidate.class_name, candidate.method_name])
+
+          demoted_candidate(candidate, :overridden_by_unsigned_subclass)
+        end
+      end
+
+      # `[class name, method name]` pairs an UNSIGNED override shadows: for every candidate that will not
+      # be emitted, every ancestor of its class paired with its method name.
+      def unsigned_override_ancestors(candidates, superclasses)
+        candidates.each_with_object(Set.new) do |candidate, acc|
+          next if Classification::EMITTABLE.include?(candidate.classification)
+          next if candidate.class_name.nil?
+
+          each_ancestor(candidate.class_name, superclasses) { |name| acc << [name, candidate.method_name] }
+        end
+      end
+
+      def each_ancestor(class_name, superclasses)
+        seen = {}
+        current = class_name
+        while (parent = superclasses[current]) && !seen[parent]
+          seen[parent] = true
+          yield parent
+          current = parent
+        end
+      end
+
+      def demoted_candidate(candidate, reason)
+        MethodCandidate.new(
+          path: candidate.path, class_name: candidate.class_name, method_name: candidate.method_name,
+          kind: candidate.kind, classification: Classification::SKIPPED, skip_reason: reason,
+          inferred_return: candidate.inferred_return, declared_return_rbs: candidate.declared_return_rbs,
+          namespace_kinds: candidate.namespace_kinds, class_shells: candidate.class_shells,
+          class_superclasses: candidate.class_superclasses
+        )
+      end
+
+      # Issue #722 — resolves each recorded superclass token to the class Ruby means by it, and rewrites the
+      # emitted spelling when the two differ.
+      #
+      # `record_superclass` kept the source token verbatim on the reasoning that "RBS resolves it relative to
+      # the emitted namespace, matching Ruby's lexical scope". That holds only while the emitted namespace
+      # equals the source nesting, and sig-gen FLATTENS: `module Admin; class Record2 < Record` is written
+      # out as the compact `class Admin::Record2 < Record`, and RBS resolves a compact header's superclass at
+      # the TOP level (verified against the rbs gem), so the emitted token silently re-points at `::Record`
+      # where the program means `Admin::Record`. The checker resolves the same declaration correctly, so the
+      # generated sidecar contradicted the analyzer that wrote it.
+      #
+      # Candidate order is Ruby's own for the superclass expression: the header's nesting innermost-first,
+      # then the bare name — the reading `Scope#ancestor_name_candidates` owns for the analyzer's class
+      # graph. The question here is about the EMITTED tree, so the "is this a class" test is this run's
+      # declarations plus the RBS environment rather than the discovery tables; keep the two orders in step.
+      def resolve_superclass_spellings(candidates)
+        return candidates if @superclass_nestings.empty?
+
+        known = candidates.each_with_object(Set.new) do |candidate, acc|
+          acc << candidate.class_name if candidate.class_name
+          acc.merge(candidate.class_shells || [])
+        end
+        rewrites = superclass_rewrites(known)
+        return candidates if rewrites.empty?
+
+        candidates.map do |candidate|
+          overlap = rewrites.slice(*candidate.class_superclasses.keys)
+          next candidate if overlap.empty?
+
+          rebuild_with_superclasses(candidate, candidate.class_superclasses.merge(overlap))
+        end
+      end
+
+      def superclass_rewrites(known)
+        @superclass_nestings.each_with_object({}) do |(full, (nesting, token)), acc|
+          next if token.nil? || nesting.empty?
+
+          resolved = resolve_superclass_token(token, nesting, known)
+          acc[full] = resolved if resolved && resolved != token
+        end
+      end
+
+      # The first candidate spelling that names a class this run declares or the RBS environment knows, or
+      # nil when none does — an unresolvable superclass is #735's business, not this pass's.
+      def resolve_superclass_token(token, nesting, known)
+        base = token.sub(/\[.*\]\z/, "")
+        args = token[base.length..] || ""
+        nesting.length.downto(1) do |i|
+          candidate = "#{nesting[0, i].join('::')}::#{base}"
+          return "#{candidate}#{args}" if known.include?(candidate) ||
+                                          Reflection.rbs_class_known?(candidate, environment: @environment)
+        end
+        token
+      end
+
+      def rebuild_with_superclasses(candidate, superclasses)
+        MethodCandidate.new(
+          path: candidate.path, class_name: candidate.class_name, method_name: candidate.method_name,
+          kind: candidate.kind, classification: candidate.classification,
+          inferred_return: candidate.inferred_return, declared_return_rbs: candidate.declared_return_rbs,
+          rbs: candidate.rbs, skip_reason: candidate.skip_reason,
+          namespace_kinds: candidate.namespace_kinds, class_shells: candidate.class_shells,
+          class_superclasses: superclasses
+        )
+      end
+
+      # Issue #735 — a generated declaration whose superclass chain does not terminate in a class the RBS
+      # environment knows is DROPPED rather than emitted.
+      #
+      # `record_superclass` is right that a subclass declaration must carry its superclass: without it the
+      # sidecar misrepresents the class and dispatch degrades. But emitting one the environment cannot
+      # resolve is worse than either — `RBS::NoSuperclassFoundError` collapses the class, so every call into
+      # it reads `Dynamic[top]` and the whole declaration is a liability. On redmine, `class Principal <
+      # ApplicationRecord` (nothing declares `ApplicationRecord`, and nothing could: the chain ends at
+      # `ActiveRecord::Base`, which no RBS in the environment carries) collapsed 98 classes on the very next
+      # run. A chain that LOOPS is dropped for the same reason, and is the shape that made an
+      # `AncestorBuilder` walk recurse until `SystemStackError` (#609).
+      #
+      # Dropping is the conservative end: no declaration leaves the class exactly as it was before sig-gen
+      # ran — source discovery and the plugins still type it. Emitting the class with the superclass merely
+      # OMITTED would be the harmful middle: the class becomes RBS-known with only the emitted methods, so
+      # every inherited call fires `call.undefined-method`.
+      def demote_unresolvable_superclasses(candidates)
+        superclasses = candidates.each_with_object({}) do |candidate, acc|
+          (candidate.class_superclasses || {}).each { |name, sup| acc[name] = sup }
+        end
+        # Everything this run declares, superclass or not: a chain that reaches `class Record` — emitted
+        # here, with no superclass of its own — terminates in a class the next run WILL know.
+        emitted = candidates.each_with_object(Set.new) do |candidate, acc|
+          acc << candidate.class_name if candidate.class_name
+          acc.merge(candidate.class_shells || [])
+        end
+        unresolvable = superclasses.each_with_object({}) do |(name, _sup), acc|
+          root = unresolved_superclass_root(name, superclasses, emitted)
+          acc[name] = root if root
+        end
+        return candidates if unresolvable.empty?
+
+        candidates.map do |candidate|
+          owner = unresolvable_for(candidate.class_name, unresolvable)
+          next candidate if owner.nil?
+
+          record_unresolvable_superclass(candidate, owner)
+        end
+      end
+
+      # A nested class or module goes with its wrapper. `WikiPage::Webhookable`'s declaration is emitted
+      # INSIDE `class WikiPage < ApplicationRecord`, so keeping the inner one while dropping the outer emits
+      # the unresolvable header anyway — the wrapper is not a candidate of its own and carries no methods,
+      # so nothing else would have demoted it.
+      def unresolvable_for(class_name, unresolvable)
+        return nil if class_name.nil?
+        return [class_name, unresolvable[class_name]] if unresolvable.key?(class_name)
+
+        unresolvable.each do |name, root|
+          return [name, root] if class_name.start_with?("#{name}::")
+        end
+        nil
+      end
+
+      # The first superclass token on `name`'s recorded chain that neither the RBS environment knows nor this
+      # run emits, or nil when the chain terminates in a known class. A chain that revisits a class returns
+      # that class's own superclass token — a cycle resolves nowhere.
+      def unresolved_superclass_root(name, superclasses, emitted, seen = {})
+        superclass = superclasses[name]
+        return nil if superclass.nil?
+        return superclass if seen[name]
+
+        seen[name] = true
+        # The recorded spelling may carry the type arguments {#generic_superclass_spelling} added; the
+        # resolvability question is about the class, so it is asked of the bare name.
+        base = superclass.sub(/\[.*\]\z/, "")
+        return nil if Reflection.rbs_class_known?(base, environment: @environment)
+        return superclass unless emitted.include?(base)
+
+        unresolved_superclass_root(base, superclasses, emitted, seen)
+      end
+
+      def record_unresolvable_superclass(candidate, owner)
+        class_name, root = owner
+        @unresolvable_superclasses[class_name] ||= root
+        MethodCandidate.new(
+          path: candidate.path, class_name: candidate.class_name, method_name: candidate.method_name,
+          kind: candidate.kind, classification: Classification::SKIPPED,
+          skip_reason: :unresolvable_superclass, inferred_return: candidate.inferred_return,
+          declared_return_rbs: candidate.declared_return_rbs,
+          namespace_kinds: candidate.namespace_kinds, class_shells: candidate.class_shells,
+          class_superclasses: candidate.class_superclasses
+        )
+      end
+
       def build_environment
         Environment.for_project(
           libraries: @configuration.libraries,
@@ -193,7 +415,7 @@ module Rigor
 
         full = (prefix + [name]).join("::")
         @namespace_kinds[full] = node.is_a?(Prism::ClassNode) ? :class : :module
-        record_superclass(node, full)
+        record_superclass(node, full, prefix)
         walk_namespace_body(node, prefix + [name], out)
         true
       end
@@ -207,11 +429,38 @@ module Rigor
       # superclass (`Class.new`, any other `CallNode`) is left unrecorded — a `Data.define` / `Struct.new` one is
       # already carried by {#register_meta_classes}, and the rest are un-representable, where guessing would
       # misfold.
-      def record_superclass(node, full)
+      def record_superclass(node, full, prefix)
         return unless node.is_a?(Prism::ClassNode)
 
         superclass = qualified_constant_path(node.superclass)
-        @class_superclasses[full] = superclass if superclass
+        return if superclass.nil?
+
+        # Issue #722 — the nesting the header is WRITTEN in, kept whole-run (not per-file scratch) because
+        # the name it resolves to may be a class another file declares. Resolved once every file has been
+        # walked, in {#resolve_superclass_spellings}.
+        spelling = generic_superclass_spelling(superclass)
+        # The token rides along because `@class_superclasses` is per-FILE scratch, reset before the next
+        # file, while this table is whole-run.
+        @superclass_nestings[full] = [prefix.dup, spelling]
+        @class_superclasses[full] = spelling
+      end
+
+      # Issue #735 — a GENERIC superclass has to be written with its arguments. `class Entries < Array`
+      # yields `RBS::InvalidTypeApplicationError: ::Array expects parameters [unchecked out E], but given
+      # args []`, which fails the build for that class exactly as an unresolvable superclass does — redmine
+      # subclasses `Array` five times. The element type is not something this pass can infer, so it is
+      # `untyped`: the subclass's OWN methods are what sig-gen is here to record, and `Array[untyped]` keeps
+      # the inherited surface resolving instead of collapsing the class.
+      def generic_superclass_spelling(superclass)
+        loader = @environment&.rbs_loader
+        return superclass if loader.nil?
+
+        arity = loader.class_type_param_names(superclass).size
+        return superclass if arity.zero?
+
+        "#{superclass}[#{(['untyped'] * arity).join(', ')}]"
+      rescue StandardError
+        superclass
       end
 
       # The ADR-48 member layouts for this file, in one table keyed by qualified class name. Reading the engine's

data/lib/rigor/sig_gen/renderer.rb

@@ -40,13 +40,8 @@ module Rigor
 
       private
 
-      EMITTABLE = [Classification::NEW_FILE,
-                   Classification::NEW_METHOD,
-                   Classification::TIGHTER_RETURN].freeze
-      private_constant :EMITTABLE
-
       def filter(candidates, selection)
-        active = selection.empty? ? EMITTABLE : selection
+        active = selection.empty? ? Classification::EMITTABLE : selection
         candidates.select { |c| active.include?(c.classification) }
       end
 

data/lib/rigor/sig_gen/writer.rb

@@ -90,6 +90,9 @@ module Rigor
         target.exist? ? update_existing(source_path, target, candidates) : create_new(source_path, target, candidates)
       end
 
+      # Deliberately NARROWER than {Classification::EMITTABLE}: the write path has never produced a
+      # `:new_file` row (the generator does not classify one), and admitting it here would let a
+      # classification with no writer behind it decide that a target file must be created.
       EMITTABLE = [Classification::NEW_METHOD, Classification::TIGHTER_RETURN].freeze
       private_constant :EMITTABLE
 

data/lib/rigor/source/constant_path.rb

@@ -14,8 +14,18 @@ module Rigor
     # * {.qualified_name_or_nil} is STRICT — a dynamic base anywhere in the chain yields `nil`, so a caller
     #   that statically names constants can treat the path as opaque rather than guessing.
     #
-    # A leading `::` (absolute root, `::Foo`) renders as `"Foo"` under both policies. A node that is neither
-    # a `ConstantReadNode` nor a `ConstantPathNode` yields `nil` under both.
+    # A leading `::` (absolute root, `::Foo`) renders as `"Foo"` under both policies: the discovered-constant
+    # tables are keyed by un-rooted names, so a rendered `"::Foo"` would miss every one of them. The root
+    # marker is therefore carried OUT OF BAND by {.rooted?}, which a caller performing Ruby's lexical constant
+    # lookup MUST consult — `::Foo` names the top-level `Foo` and never a lexically nearer shadow
+    # ([#614](https://github.com/rigortype/rigor/issues/614)). A node that is neither a `ConstantReadNode`
+    # nor a `ConstantPathNode` yields `nil` under both policies.
+    #
+    # A `class` / `module` HEADER is a constant path too, and it has to consult the same marker — which is why
+    # {.declaration_prefix} and {.pushed_nesting} live here rather than in each of the two dozen walks that
+    # used to append the rendered name to their own prefix. `::` re-anchors a header at the top level exactly
+    # as it re-anchors a reference; reading only the rendered name filed `class ::Foo` inside `module MyApp`
+    # under `MyApp::Foo` ([#708](https://github.com/rigortype/rigor/issues/708)).
     module ConstantPath
       module_function
 
@@ -53,6 +63,73 @@ module Rigor
           "#{parent_name}::#{node.name}"
         end
       end
+
+      # True when the reference is written with a leading `::` — `::Foo`, `::Foo::Bar`. Prism spells the
+      # root as a `ConstantPathNode` with a nil `parent`, so the answer lives at the LEFTMOST segment of the
+      # chain and the walk has to reach it: `::Foo::Bar` is a path node whose parent is itself a path node.
+      # A `ConstantReadNode` is a bare name and is never rooted; a dynamic base (`expr::Bar`) is not a root
+      # either, so the recursion stops at any non-constant parent.
+      def rooted?(node)
+        return false unless node.is_a?(Prism::ConstantPathNode)
+
+        parent = node.parent
+        return true if parent.nil?
+
+        rooted?(parent)
+      end
+
+      # The qualified prefix a `class` / `module` header contributes to the body it opens, given the prefix of
+      # the body the header is WRITTEN in. `class Bar` inside `module Outer` is `Outer::Bar`; the compact
+      # `class Outer::Bar` written at the top level is the same name through one keyword instead of two.
+      #
+      # A ROOTED header RESETS the prefix. `class ::Rooted::Bar` names `Rooted::Bar` wherever it is written —
+      # Ruby's `::` re-anchors the header at the top level exactly as it does a reference — so the enclosing
+      # prefix is DROPPED rather than kept. Keeping it filed the class under `Outer::Rooted::Bar`, a name no
+      # caller writes, and the single-segment `class ::Foo` inside `module MyApp` became `MyApp::Foo`: not
+      # merely mis-keyed but undiscoverable, so a call on `Foo` typed opaque and reported nothing at all
+      # ([#708](https://github.com/rigortype/rigor/issues/708), [#638](https://github.com/rigortype/rigor/issues/638)).
+      #
+      # nil when the header names no constant — the same refusal {.qualified_name} makes, propagated so a
+      # caller keeps its own prefix rather than qualifying under a name it could not render.
+      def declaration_prefix(outer_prefix, constant_path)
+        name = qualified_name(constant_path)
+        return nil if name.nil?
+
+        rooted?(constant_path) ? [name] : outer_prefix + [name]
+      end
+
+      # Ruby's `Module.nesting` inside the body a `class` / `module` header opens, given the nesting of the
+      # body the header is written in. ONE entry per declaration keyword, qualified against the entry already
+      # on top, so a compact `class A::B` contributes the single `"A::B"` where `module A; class B` contributes
+      # two — the whole difference between the two spellings, and unrecoverable from the `"A::B"` they share
+      # afterwards ([#652](https://github.com/rigortype/rigor/issues/652)). This is the ONLY thing that pushes
+      # an entry: a `def`, a block, and a `class << expr` body each inherit the chain unchanged, because none
+      # of them pushes a cref in Ruby.
+      #
+      # A ROOTED header pushes its name UNQUALIFIED and leaves the enclosing entries beneath it, which is the
+      # one place this differs from {.declaration_prefix}: Ruby's nesting inside `class ::Rooted::Bar` written
+      # in `module Outer` is `[Rooted::Bar, Outer]`, so the class's own name resets while `Outer` stays on the
+      # ladder as a live rung ([#708](https://github.com/rigortype/rigor/issues/708)).
+      #
+      # The header is rendered by the LENIENT {.qualified_name}, which is total over every header Ruby parses —
+      # `class` and `module` require a constant path, so the only dynamic base the grammar admits is `self`, and
+      # `class self::Thing` inside `module Outer` renders `"Thing"` and records `["Outer::Thing", "Outer"]`,
+      # which is what Ruby's nesting is there. So there is no unnameable-header case to refuse, and the `nil`
+      # guards below are reachable only for a non-constant node (which a `ClassNode` / `ModuleNode` header
+      # never is) and for the nil chain a caller may thread in.
+      #
+      # Both nesting walks call THIS function — `Inference::StatementEvaluator`'s declaration walk and
+      # `Inference::ScopeIndexer`'s def-node walk — so a callee re-walk answers what the body's own walk
+      # answers by construction rather than by two mirrored implementations staying in step.
+      def pushed_nesting(nesting, constant_path)
+        return nil if nesting.nil?
+
+        name = qualified_name(constant_path)
+        return nil if name.nil?
+
+        outer = rooted?(constant_path) ? nil : nesting.first
+        [outer ? "#{outer}::#{name}" : name, *nesting].freeze
+      end
     end
   end
 end

data/lib/rigor/triage/catalogue.rb

@@ -327,7 +327,7 @@ module Rigor
           parser == :toplevel ? d.method_name : parse_undefined_method(d)&.fetch(:method)
         end
         names.tally.sort_by { |method, count| [-count, method] }
-                   .first(limit).map { |method, count| "#{method}×#{count}" }.join(" ")
+             .first(limit).map { |method, count| "#{method}×#{count}" }.join(" ")
       end
 
       def rule_of(diag)

data/lib/rigor/type/combinator.rb

@@ -369,6 +369,16 @@ module Rigor
         StructInstance.new(members, class_name)
       end
 
+      # ADR-3 amendment (ADR-20 slice 4) — generic Result[T, E] carrier constructor.
+      def result_of(ok_type, err_type)
+        Result.new(ok_type, err_type)
+      end
+
+      # ADR-3 amendment (ADR-20 slice 4) — generic Maybe[T] carrier constructor.
+      def maybe_of(value_type)
+        Maybe.new(value_type)
+      end
+
       # Normalized union. Flattens nested Unions, deduplicates structurally equal members, drops Bot, and
       # collapses 0/1-member results.
       def union(*types)

data/lib/rigor/type/maybe.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "../trinary"
+require_relative "../value_semantics"
+require_relative "acceptance_router"
+require_relative "plain_lattice"
+
+module Rigor
+  module Type
+    # A generic Maybe carrier representing an optional value that either contains a value of type
+    # `value_type` or nothing.
+    #
+    # Models `Maybe[T]` (e.g. `Dry::Monads::Maybe[T]`).
+    #
+    # Subtyping is covariant: `Maybe[T1] <: Maybe[T2]` iff `T1 <: T2`.
+    class Maybe
+      attr_reader :value_type
+
+      def initialize(value_type)
+        raise ArgumentError, "value_type must not be nil" if value_type.nil?
+
+        @value_type = value_type
+        freeze
+      end
+
+      def describe(verbosity = :short)
+        "Maybe[#{value_type.describe(verbosity)}]"
+      end
+
+      def erase_to_rbs
+        "::Dry::Monads::Maybe[#{value_type.erase_to_rbs}]"
+      end
+
+      include Rigor::Type::PlainLattice
+
+      include Rigor::Type::AcceptanceRouter
+
+      include Rigor::ValueSemantics
+
+      value_fields :value_type
+
+      def inspect
+        "#<Rigor::Type::Maybe #{describe(:short)}>"
+      end
+    end
+  end
+end

data/lib/rigor/type/refined.rb

@@ -77,14 +77,13 @@ module Rigor
       # Recognises a Ruby value against this carrier's predicate. The trinary return is intentional:
       # `true` / `false` when the predicate registry decides, `nil` when the predicate is unknown to the
       # registry, so callers (today {Inference::Acceptance}) can fall through to gradual-mode `:maybe`.
-      # rubocop:disable Style/ReturnNilInPredicateMethodDefinition
+      # rubocop:disable-next Style/ReturnNilInPredicateMethodDefinition
       def matches?(value)
         recogniser = PREDICATES[predicate_id]
         return nil if recogniser.nil?
 
         !!recogniser.call(value)
       end
-      # rubocop:enable Style/ReturnNilInPredicateMethodDefinition
 
       # `predicate_id => recogniser` table. The recogniser is called with a Ruby value (typically the
       # inner `value` of a `Constant`) and returns truthy when the value satisfies the predicate. The

data/lib/rigor/type/result.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "../trinary"
+require_relative "../value_semantics"
+require_relative "acceptance_router"
+require_relative "plain_lattice"
+
+module Rigor
+  module Type
+    # A generic Result carrier representing a computation that either succeeded with a value of type
+    # `ok_type` or failed with an error of type `err_type`.
+    #
+    # Models `Result[T, E]` (e.g. `Dry::Monads::Result[T, E]`).
+    #
+    # Subtyping is covariant in both positions: `Result[T1, E1] <: Result[T2, E2]` iff `T1 <: T2` and
+    # `E1 <: E2`.
+    class Result
+      attr_reader :ok_type, :err_type
+
+      alias success_type ok_type
+      alias failure_type err_type
+
+      def initialize(ok_type, err_type)
+        raise ArgumentError, "ok_type must not be nil" if ok_type.nil?
+        raise ArgumentError, "err_type must not be nil" if err_type.nil?
+
+        @ok_type = ok_type
+        @err_type = err_type
+        freeze
+      end
+
+      def describe(verbosity = :short)
+        "Result[#{ok_type.describe(verbosity)}, #{err_type.describe(verbosity)}]"
+      end
+
+      def erase_to_rbs
+        "::Dry::Monads::Result[#{ok_type.erase_to_rbs}, #{err_type.erase_to_rbs}]"
+      end
+
+      include Rigor::Type::PlainLattice
+
+      include Rigor::Type::AcceptanceRouter
+
+      include Rigor::ValueSemantics
+
+      value_fields :ok_type, :err_type
+
+      def inspect
+        "#<Rigor::Type::Result #{describe(:short)}>"
+      end
+    end
+  end
+end

data/lib/rigor/type.rb

@@ -28,6 +28,8 @@ require_relative "type/difference"
 require_relative "type/refined"
 require_relative "type/intersection"
 require_relative "type/app"
+require_relative "type/result"
+require_relative "type/maybe"
 require_relative "type/bound_method"
 require_relative "type/accepts_result"
 require_relative "type/combinator"

data/lib/rigor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rigor
-  VERSION = "0.3.5"
+  VERSION = "0.3.7"
 end

data/plugins/rigor-actioncable/lib/rigor/plugin/actioncable/analyzer.rb

@@ -56,7 +56,9 @@ module Rigor
           # not ActionCable — pass through silently to avoid flagging unrelated `broadcast_to` methods.
           return [] unless class_name.end_with?("Channel")
 
-          entry = channel_index.find(class_name) || channel_index.find("::#{class_name}")
+          # `ChannelIndex#find` de-roots the query itself (#621) — a `::ChatChannel.broadcast_to` receiver
+          # and a plain `ChatChannel.broadcast_to` reach the same entry with no retry arm here.
+          entry = channel_index.find(class_name)
           return [unknown_channel_violation(class_name, channel_index)] if entry.nil?
 
           [broadcast_target_info(entry)]