rigortype 0.1.19 → 0.2.1

data/lib/rigor/sig_gen/writer.rb

@@ -46,6 +46,11 @@ module Rigor
       def initialize(path_mapper:, overwrite: false)
         @path_mapper = path_mapper
         @overwrite = overwrite
+        # Run-level (cross-file) namespace-kind view, populated
+        # per `#write_all` from every candidate's per-file map.
+        # Empty until then so the single-target `#write` path
+        # falls back to per-candidate kinds only.
+        @global_namespace_kinds = {}
       end
 
       # Process the full candidate list by resolving each
@@ -65,6 +70,7 @@ module Rigor
         emittable = candidates.select { |c| EMITTABLE.include?(c.classification) }
         return [] if emittable.empty?
 
+        @global_namespace_kinds = build_namespace_kinds(candidates)
         emittable.group_by { |c| @path_mapper.target_for(c.path, class_name: c.class_name) }
                  .map { |target, group| write_target(target, group) }
       end
@@ -161,13 +167,45 @@ module Rigor
       end
 
       def merged_namespace_kinds(candidates)
-        merged = {}
+        merged = @global_namespace_kinds.dup
         candidates.each do |c|
-          (c.namespace_kinds || {}).each { |k, v| merged[k] = v }
+          (c.namespace_kinds || {}).each { |k, v| apply_namespace_kind(merged, k, v) }
         end
         merged
       end
 
+      # Folds every candidate's per-file namespace-kind map
+      # into one run-level view so a `class Foo` recorded
+      # while scanning `foo.rb` governs the wrapper keyword
+      # emitted for `Foo` in a *sibling* file's target — e.g.
+      # `foo/bar.rb` declaring `class Foo::Bar`, whose compact
+      # constant path never names `Foo`, so the walker records
+      # no kind for it. Without this view that sibling target
+      # wraps the nested class in `module Foo` while `foo.rbs`
+      # declares `class Foo`; loading both raises
+      # `RBS::DuplicatedDeclarationError`, aborting the whole
+      # RBS env build.
+      def build_namespace_kinds(candidates)
+        candidates.each_with_object({}) do |candidate, acc|
+          (candidate.namespace_kinds || {}).each { |name, kind| apply_namespace_kind(acc, name, kind) }
+        end
+      end
+
+      # A `class` declaration is authoritative and MUST win
+      # over the `:module` wrapper default: a compact
+      # `class Foo::Bar` never names `Foo`, so the only signal
+      # for `Foo`'s kind is an actual `class Foo` (or
+      # `Const = Data.define(...)` shell) seen elsewhere. This
+      # guarantees the generated tree never mixes `class` /
+      # `module` for the same constant.
+      def apply_namespace_kind(map, key, kind)
+        if kind == :class
+          map[key] = :class
+        else
+          map[key] ||= :module
+        end
+      end
+
       # Tree node: { name:, children: Hash{String => node},
       # methods: Array<MethodCandidate>, shell: Boolean }.
       # `shell` flags nodes that came in via `class_shells`

data/lib/rigor/signature_path_audit.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Rigor
+  # Classifies each configured `signature_paths:` entry by what it
+  # actually contributes to the RBS environment, so a caller can warn
+  # when a configured path resolves to nothing.
+  #
+  # The failure this guards against is silent. {Environment::RbsLoader}
+  # `add`s a `signature_paths:` entry only when `path.directory?`, and
+  # only the `.rbs` files under it carry signatures — so a typo'd or
+  # moved path (or a directory holding no `.rbs`) loads zero signatures
+  # with no trace on stderr or in the run summary. The downstream symptom
+  # is the most authoritative diagnostics: every call into the extensions
+  # the missing RBS was meant to describe fires `call.undefined-method` at
+  # `evidence_tier: high`. A one-character path typo can manufacture
+  # hundreds of plausible-looking false positives; surfacing the empty
+  # entry makes the real cause visible.
+  #
+  # The audit deliberately mirrors the loader's own acceptance test
+  # (`path.directory?` + a recursive `**/*.rbs` glob) so a `:ok` verdict
+  # means the loader did load from it and a warning means it did not.
+  module SignaturePathAudit
+    # One configured `signature_paths:` entry's resolution status.
+    #
+    # `status` is one of:
+    # - `:ok`            — a directory containing at least one `.rbs`.
+    # - `:missing`       — the path does not exist.
+    # - `:not_directory` — the path exists but is not a directory (the
+    #   loader only `add`s directories, so a `.rbs` file passed directly
+    #   is silently ignored).
+    # - `:empty`         — a directory with no `.rbs` file (recursive).
+    Entry = Data.define(:path, :status, :rbs_file_count) do
+      def ok?
+        status == :ok
+      end
+
+      def warning?
+        !ok?
+      end
+
+      # One-line, human-facing reason. The wording matches the loader's
+      # actual behaviour ("loaded nothing from it") rather than the
+      # filesystem error, so the message points at the consequence.
+      def message
+        case status
+        when :missing
+          "signature_paths: #{path.inspect} does not exist (no signatures loaded from it)"
+        when :not_directory
+          "signature_paths: #{path.inspect} is not a directory (no signatures loaded from it)"
+        when :empty
+          "signature_paths: #{path.inspect} matched 0 signature files"
+        else
+          "signature_paths: #{path.inspect} loaded #{rbs_file_count} signature file(s)"
+        end
+      end
+
+      def to_h
+        { "path" => path, "status" => status.to_s, "rbs_file_count" => rbs_file_count, "message" => message }
+      end
+    end
+
+    # Audits each configured entry. `signature_paths` is the
+    # {Configuration#signature_paths} array (absolute paths, already
+    # resolved against the config file's directory). Pass `nil` — the
+    # unset default, where Rigor auto-detects `<root>/sig` — to get an
+    # empty result: an absent auto-detected `sig/` is a normal setup, not
+    # a misconfiguration, so it is never audited.
+    #
+    # @param signature_paths [Array<String, Pathname>, nil]
+    # @return [Array<Entry>]
+    def self.audit(signature_paths)
+      Array(signature_paths).map { |path| classify(path.to_s) }
+    end
+
+    # The subset of {audit} that resolved to nothing — the entries worth
+    # warning about.
+    #
+    # @param signature_paths [Array<String, Pathname>, nil]
+    # @return [Array<Entry>]
+    def self.warnings(signature_paths)
+      audit(signature_paths).select(&:warning?)
+    end
+
+    def self.classify(path)
+      return Entry.new(path: path, status: :missing, rbs_file_count: 0) unless File.exist?(path)
+      return Entry.new(path: path, status: :not_directory, rbs_file_count: 0) unless File.directory?(path)
+
+      count = Dir.glob(File.join(path, "**", "*.rbs")).size
+      Entry.new(path: path, status: count.zero? ? :empty : :ok, rbs_file_count: count)
+    end
+  end
+end

data/lib/rigor/source/constant_path.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Source
+    # Flattens a Prism constant-reference node (`ConstantReadNode` /
+    # `ConstantPathNode`) to its source-qualified `"A::B::C"` string.
+    #
+    # Two nil policies for the one edge case that distinguishes the call
+    # sites — a constant path rooted in a *dynamic* base (`expr::Bar`, where
+    # the left side is a runtime expression rather than a constant):
+    #
+    # * {.qualified_name} / {.render} are LENIENT — they drop the dynamic
+    #   segment and render the trailing constant names (`expr::Bar` => "Bar").
+    #   The scope indexer and statement evaluator feed only genuine
+    #   class/module path nodes and want a best-effort name.
+    # * {.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.
+    module ConstantPath
+      module_function
+
+      # Lenient dispatch over a constant-reference node.
+      def qualified_name(node)
+        case node
+        when Prism::ConstantReadNode then node.name.to_s
+        when Prism::ConstantPathNode then render(node)
+        end
+      end
+
+      # Lenient render of a `ConstantPathNode`; never nil for a path node.
+      def render(node)
+        prefix =
+          case node.parent
+          when Prism::ConstantReadNode then "#{node.parent.name}::"
+          when Prism::ConstantPathNode then "#{render(node.parent)}::"
+          else ""
+          end
+        "#{prefix}#{node.name}"
+      end
+
+      # Strict dispatch: a dynamic base anywhere in the path yields nil.
+      def qualified_name_or_nil(node)
+        case node
+        when Prism::ConstantReadNode
+          node.name.to_s
+        when Prism::ConstantPathNode
+          parent = node.parent
+          return node.name.to_s if parent.nil?
+
+          parent_name = qualified_name_or_nil(parent)
+          return nil if parent_name.nil?
+
+          "#{parent_name}::#{node.name}"
+        end
+      end
+    end
+  end
+end

data/lib/rigor/source.rb

@@ -14,3 +14,4 @@ end
 require_relative "source/node_locator"
 require_relative "source/node_walker"
 require_relative "source/literals"
+require_relative "source/constant_path"

data/lib/rigor/type/bound_method.rb

@@ -3,6 +3,7 @@
 require_relative "../trinary"
 require_relative "../value_semantics"
 require_relative "acceptance_router"
+require_relative "plain_lattice"
 
 module Rigor
   module Type
@@ -46,17 +47,7 @@ module Rigor
         "Method"
       end
 
-      def top
-        Trinary.no
-      end
-
-      def bot
-        Trinary.no
-      end
-
-      def dynamic
-        Trinary.no
-      end
+      include Rigor::Type::PlainLattice
 
       include Rigor::Type::AcceptanceRouter
 

data/lib/rigor/type/combinator.rb

@@ -405,6 +405,21 @@ module Rigor
         DataInstance.new(members, class_name)
       end
 
+      # ADR-48 Struct follow-up — the class object produced by
+      # `Struct.new(:x, :y)`. `members` is the ordered Symbol member-name
+      # list; `keyword_init` records the `keyword_init:` flag; `class_name`
+      # tags the class when known (the named-subclass form).
+      def struct_class_of(members:, class_name: nil, keyword_init: false)
+        StructClass.new(members, class_name, keyword_init: keyword_init)
+      end
+
+      # ADR-48 Struct follow-up — a `Struct.new` value instance. `members`
+      # is the ordered member-name -> value-type map; `class_name` tags the
+      # instance's class when known.
+      def struct_instance_of(members:, class_name: nil)
+        StructInstance.new(members, class_name)
+      end
+
       # Normalized union. Flattens nested Unions, deduplicates structurally
       # equal members, drops Bot, and collapses 0/1-member results.
       def union(*types)
@@ -929,9 +944,7 @@ module Rigor
         end
       end
 
-      # ADR-15 Phase 4b.x — eager-allocate the singleton
-      # `Dynamic[Top]` carrier on the main Ractor at load time.
-      # The `untyped` reader above just returns this ivar.
+      # Eager-allocated at load time; see `untyped` method comment above.
       @untyped = Dynamic.new(Top.instance)
     end
   end

data/lib/rigor/type/constant.rb

@@ -3,6 +3,7 @@
 require "date"
 require_relative "../trinary"
 require_relative "acceptance_router"
+require_relative "plain_lattice"
 
 module Rigor
   module Type
@@ -100,17 +101,7 @@ module Rigor
         end
       end
 
-      def top
-        Trinary.no
-      end
-
-      def bot
-        Trinary.no
-      end
-
-      def dynamic
-        Trinary.no
-      end
+      include Rigor::Type::PlainLattice
 
       include Rigor::Type::AcceptanceRouter
 

data/lib/rigor/type/data_class.rb

@@ -3,6 +3,7 @@
 require_relative "../trinary"
 require_relative "../value_semantics"
 require_relative "acceptance_router"
+require_relative "plain_lattice"
 
 module Rigor
   module Type
@@ -54,17 +55,7 @@ module Rigor
         "singleton(#{class_name || 'Data'})"
       end
 
-      def top
-        Trinary.no
-      end
-
-      def bot
-        Trinary.no
-      end
-
-      def dynamic
-        Trinary.no
-      end
+      include Rigor::Type::PlainLattice
 
       include Rigor::Type::AcceptanceRouter
 

data/lib/rigor/type/data_instance.rb

@@ -3,6 +3,7 @@
 require_relative "../trinary"
 require_relative "../value_semantics"
 require_relative "acceptance_router"
+require_relative "plain_lattice"
 
 module Rigor
   module Type
@@ -74,17 +75,7 @@ module Rigor
         name
       end
 
-      def top
-        Trinary.no
-      end
-
-      def bot
-        Trinary.no
-      end
-
-      def dynamic
-        Trinary.no
-      end
+      include Rigor::Type::PlainLattice
 
       include Rigor::Type::AcceptanceRouter
 

data/lib/rigor/type/hash_shape.rb

@@ -3,6 +3,7 @@
 require_relative "../trinary"
 require_relative "../value_semantics"
 require_relative "acceptance_router"
+require_relative "plain_lattice"
 
 module Rigor
   module Type
@@ -96,17 +97,7 @@ module Rigor
         read_only_keys.include?(key)
       end
 
-      def top
-        Trinary.no
-      end
-
-      def bot
-        Trinary.no
-      end
-
-      def dynamic
-        Trinary.no
-      end
+      include Rigor::Type::PlainLattice
 
       include Rigor::Type::AcceptanceRouter
 

data/lib/rigor/type/integer_range.rb

@@ -3,6 +3,7 @@
 require_relative "../trinary"
 require_relative "../value_semantics"
 require_relative "acceptance_router"
+require_relative "plain_lattice"
 
 module Rigor
   module Type
@@ -103,17 +104,7 @@ module Rigor
         "Integer"
       end
 
-      def top
-        Trinary.no
-      end
-
-      def bot
-        Trinary.no
-      end
-
-      def dynamic
-        Trinary.no
-      end
+      include Rigor::Type::PlainLattice
 
       include Rigor::Type::AcceptanceRouter
 

data/lib/rigor/type/intersection.rb

@@ -3,6 +3,7 @@
 require_relative "../trinary"
 require_relative "../value_semantics"
 require_relative "acceptance_router"
+require_relative "plain_lattice"
 
 module Rigor
   module Type
@@ -62,17 +63,7 @@ module Rigor
         members.first.erase_to_rbs
       end
 
-      def top
-        Trinary.no
-      end
-
-      def bot
-        Trinary.no
-      end
-
-      def dynamic
-        Trinary.no
-      end
+      include Rigor::Type::PlainLattice
 
       include Rigor::Type::AcceptanceRouter
 

data/lib/rigor/type/nominal.rb

@@ -3,6 +3,7 @@
 require_relative "../trinary"
 require_relative "../value_semantics"
 require_relative "acceptance_router"
+require_relative "plain_lattice"
 
 module Rigor
   module Type
@@ -52,17 +53,7 @@ module Rigor
         "#{class_name}[#{rendered}]"
       end
 
-      def top
-        Trinary.no
-      end
-
-      def bot
-        Trinary.no
-      end
-
-      def dynamic
-        Trinary.no
-      end
+      include Rigor::Type::PlainLattice
 
       include Rigor::Type::AcceptanceRouter
 

data/lib/rigor/type/plain_lattice.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "../trinary"
+
+module Rigor
+  module Type
+    # Supplies the lattice-membership trio for the "plain" carriers — the
+    # concrete value types that are neither a lattice extreme (`Top` /
+    # `Bot` / `Dynamic`) nor a wrapper that computes membership from an
+    # inner type.
+    #
+    # Every such carrier answers `top` / `bot` / `dynamic` with the same
+    # `Trinary.no` ("this value is not that lattice point"), so the trio
+    # lived as a byte-identical copy in a dozen carriers. The extremes
+    # override the relevant member (`Top#top` / `Bot#bot` /
+    # `Dynamic#dynamic` answer `Trinary.yes`) and the delegators (`App`,
+    # `Difference`, `Refined`, `Union`) compute `dynamic` from their inner
+    # type(s); none of those include this module.
+    #
+    # Mirrors the existing {AcceptanceRouter} / `ValueSemantics` mixins —
+    # narrow trait sharing, never carrier inheritance (which the type-object
+    # contract forbids).
+    module PlainLattice
+      def top
+        Trinary.no
+      end
+
+      def bot
+        Trinary.no
+      end
+
+      def dynamic
+        Trinary.no
+      end
+    end
+  end
+end

data/lib/rigor/type/refined.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "prism"
+
 require_relative "../trinary"
 require_relative "../value_semantics"
 require_relative "acceptance_router"
@@ -104,18 +106,31 @@ module Rigor
       # so callers can pass any `Constant#value` without a
       # type-prefilter.
       #
-      # Plugin-contributed predicates land here once ADR-2 is
-      # in flight; today the table is closed over the v0.0.4
-      # built-in catalogue.
+      # Plugin-contributed predicates are not yet wired; today
+      # the table covers the built-in catalogue.
       #
       # Recogniser policy:
       #
-      # - `:numeric` is deliberately conservative — only decimal
-      #   integer and plain-decimal-fraction strings are
-      #   recognised, mirroring `imported-built-in-types.md`'s
-      #   "Rigor's numeric-string predicate" wording. Looser
-      #   forms (scientific, hex, rational) MAY join later
-      #   without breaking the registry contract.
+      # - `:numeric` recognises a string that is a *single Ruby
+      #   numeric literal* — exactly the syntax that, written in
+      #   Ruby source, evaluates to an `Integer` / `Float` /
+      #   `Rational` / `Complex`. The recogniser delegates to the
+      #   real Ruby parser ({Refined.ruby_numeric_literal?} via
+      #   Prism), so it tracks Ruby's grammar precisely: decimal /
+      #   `0x` hex / `0o` (or leading-zero) octal / `0b` binary /
+      #   `0d` decimal integers, underscore digit separators
+      #   (`1_000`), decimal fractions and scientific floats
+      #   (`1.5`, `1E-5`), and the `r` rational / `i` imaginary
+      #   suffixes (`1r`, `2i`, `0xffr`). A single leading sign is
+      #   folded into the literal (`-1`, `+1.5`), but a doubled
+      #   sign (`--1`, `++1`) parses as a unary-operator chain — a
+      #   `CallNode`, not a literal — and is rejected, as are
+      #   multi-dot junk (`1.2.3`), partial literals (`0x`, `1_`),
+      #   whitespace-padded strings, and — crucially — non-ASCII
+      #   "digits" (full-width `１`, superscript `²`, other Unicode
+      #   number characters): Ruby's lexer only accepts `[0-9]` in
+      #   a numeric literal, so those are `CallNode`s too. The
+      #   stricter base-N predicates below remain proper subsets.
       # - `:decimal_int` is "what `Integer(s, 10)` would parse
       #   without remainder" — one or more decimal digits,
       #   optional leading sign, no whitespace, no fractional
@@ -127,20 +142,64 @@ module Rigor
       #   not octal-int-string. This matches the typical user
       #   intent — a refinement marks a string that "looks like
       #   octal", not "happens to be base-8 valid".
-      NUMERIC_STRING_PATTERN = /\A-?\d+(?:\.\d+)?\z/
       DECIMAL_INT_STRING_PATTERN = /\A-?\d+\z/
       OCTAL_INT_STRING_PATTERN = /\A-?(?:0[oO][0-7]+|0[0-7]+)\z/
       HEX_INT_STRING_PATTERN = /\A-?0[xX][0-9a-fA-F]+\z/
-      private_constant :NUMERIC_STRING_PATTERN, :DECIMAL_INT_STRING_PATTERN,
+      private_constant :DECIMAL_INT_STRING_PATTERN,
                        :OCTAL_INT_STRING_PATTERN, :HEX_INT_STRING_PATTERN
 
+      # Prism node classes that represent a numeric literal. A
+      # string is a numeric-string exactly when the parser reduces
+      # the whole input to a single one of these (the leading sign
+      # is already folded into the literal by the parser).
+      NUMERIC_LITERAL_NODES = [
+        Prism::IntegerNode,
+        Prism::FloatNode,
+        Prism::RationalNode,
+        Prism::ImaginaryNode
+      ].freeze
+      private_constant :NUMERIC_LITERAL_NODES
+
+      # Cheap pre-filter applied before invoking the parser: every
+      # Ruby numeric literal starts with an ASCII digit, optionally
+      # preceded by exactly one sign. Strings that fail this never
+      # reach Prism (the common non-numeric case stays allocation-
+      # and parse-free).
+      NUMERIC_LITERAL_PREFIX = /\A[+-]?\d/
+      private_constant :NUMERIC_LITERAL_PREFIX
+
+      # @param value [Object] typically a `Constant#value`
+      # @return [Boolean] true when `value` is a String that is a
+      #   single, complete Ruby numeric literal. Total over
+      #   arbitrary input — never raises (Prism reports malformed
+      #   input through `errors`, it does not throw).
+      def self.ruby_numeric_literal?(value)
+        return false unless value.is_a?(String)
+        return false if value.empty?
+        # A numeric literal carries no whitespace; reject any
+        # leading / trailing / interior space so the *whole* string
+        # must be the literal (Prism would otherwise accept a
+        # trailing-space `"1 "`).
+        return false if value.match?(/\s/)
+        return false unless value.match?(NUMERIC_LITERAL_PREFIX)
+
+        result = Prism.parse(value)
+        return false unless result.errors.empty?
+
+        body = result.value.statements&.body
+        return false unless body && body.size == 1
+
+        node = body.first
+        NUMERIC_LITERAL_NODES.any? { |klass| node.is_a?(klass) }
+      end
+
       PREDICATES = {
         lowercase: ->(v) { v.is_a?(String) && v == v.downcase },
         not_lowercase: ->(v) { v.is_a?(String) && v != v.downcase },
         uppercase: ->(v) { v.is_a?(String) && v == v.upcase },
         not_uppercase: ->(v) { v.is_a?(String) && v != v.upcase },
-        numeric: ->(v) { v.is_a?(String) && NUMERIC_STRING_PATTERN.match?(v) },
-        not_numeric: ->(v) { v.is_a?(String) && !NUMERIC_STRING_PATTERN.match?(v) },
+        numeric: ->(v) { ruby_numeric_literal?(v) },
+        not_numeric: ->(v) { v.is_a?(String) && !ruby_numeric_literal?(v) },
         decimal_int: ->(v) { v.is_a?(String) && DECIMAL_INT_STRING_PATTERN.match?(v) },
         octal_int: ->(v) { v.is_a?(String) && OCTAL_INT_STRING_PATTERN.match?(v) },
         hex_int: ->(v) { v.is_a?(String) && HEX_INT_STRING_PATTERN.match?(v) },

data/lib/rigor/type/singleton.rb

@@ -3,6 +3,7 @@
 require_relative "../trinary"
 require_relative "../value_semantics"
 require_relative "acceptance_router"
+require_relative "plain_lattice"
 
 module Rigor
   module Type
@@ -34,17 +35,7 @@ module Rigor
         "singleton(#{class_name})"
       end
 
-      def top
-        Trinary.no
-      end
-
-      def bot
-        Trinary.no
-      end
-
-      def dynamic
-        Trinary.no
-      end
+      include Rigor::Type::PlainLattice
 
       include Rigor::Type::AcceptanceRouter