rigortype 0.1.8 → 0.1.10

data/lib/rigor/plugin/protocol_contract.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Plugin
+    # ADR-28 declaration: "every instance/singleton method named
+    # `method_name`, defined in a source file matching `path_glob`,
+    # is implicitly required to satisfy the declared parameter +
+    # return-type protocol."
+    #
+    # Authored on a plugin manifest:
+    #
+    #   manifest(
+    #     id: "web",
+    #     version: "0.1.0",
+    #     protocol_contracts: [
+    #       Rigor::Plugin::ProtocolContract.new(
+    #         path_glob: "lib/controller/**/*.rb",
+    #         method_name: :get,
+    #         param_types: [{ index: 0, type_name: "Rack::Request" }],
+    #         return_type_name: "Rack::Response"
+    #       )
+    #     ]
+    #   )
+    #
+    # The contract drives two distinct engine behaviours (ADR-28
+    # § "provide-and-check"):
+    #
+    # - **provide** — when the inference engine binds the parameter
+    #   list of a matching `def`, {Rigor::Inference::MethodParameterBinder}
+    #   substitutes the declared `param_types` for the usual
+    #   `Dynamic[Top]` fallback, so the method body is analysed as
+    #   if the parameter carried its protocol type.
+    # - **check** — the contributing plugin's `#diagnostics_for_file`
+    #   hook confirms the method exists and its inferred return type
+    #   conforms to `return_type_name`.
+    #
+    # ## Fields
+    #
+    # - `path_glob` — `File.fnmatch` glob (String) selecting the
+    #   source files the contract applies to, relative to the
+    #   analysed project root (e.g. `"lib/controller/**/*.rb"`).
+    # - `method_name` — Symbol; the instance (or singleton) method
+    #   the contract constrains.
+    # - `singleton` — Boolean; `true` constrains `def self.<name>`,
+    #   `false` (default) constrains instance methods.
+    # - `param_types` — Array of `ParamType` (positional index →
+    #   fully-qualified type name). The type names resolve against
+    #   the analysed project's environment lazily, at consumption
+    #   time, so the contract value object stays independent of
+    #   environment construction order.
+    # - `return_type_name` — fully-qualified type name (String) the
+    #   method's inferred return type must conform to.
+    # - `severity` — Symbol diagnostic severity for contract
+    #   violations (`:error` default).
+    #
+    # ## Ractor-shareability
+    #
+    # Every field is frozen at construction (ADR-15 Phase 1); the
+    # nested `ParamType` is a frozen `Data`. `Ractor.shareable?`
+    # returns true after `#initialize`, so the contract survives
+    # `Plugin::Registry.materialize` into a worker Ractor.
+    class ProtocolContract
+      VALID_SEVERITIES = %i[error warning info].freeze
+
+      # One positional-parameter provision: the zero-based index of
+      # the parameter and the fully-qualified name of the type it
+      # carries under the protocol.
+      ParamType = Data.define(:index, :type_name)
+
+      attr_reader :path_glob, :method_name, :singleton, :param_types, :return_type_name, :severity
+
+      def initialize(path_glob:, method_name:, return_type_name: nil, param_types: [], singleton: false,
+                     severity: :error)
+        validate_path_glob!(path_glob)
+        validate_method_name!(method_name)
+        validate_return_type_name!(return_type_name)
+        validate_severity!(severity)
+
+        @path_glob = path_glob.dup.freeze
+        @method_name = method_name.to_sym
+        @singleton = singleton ? true : false
+        @param_types = coerce_param_types(param_types)
+        @return_type_name = return_type_name.nil? ? nil : return_type_name.dup.freeze
+        @severity = severity.to_sym
+        freeze
+      end
+
+      # Returns a copy with `path_glob` replaced. Plugins use this to
+      # honour a per-project config override of the convention path
+      # without rebuilding the whole contract by hand.
+      def with_path_glob(glob)
+        ProtocolContract.new(
+          path_glob: glob,
+          method_name: method_name,
+          return_type_name: return_type_name,
+          param_types: param_types.map { |pt| { index: pt.index, type_name: pt.type_name } },
+          singleton: singleton,
+          severity: severity
+        )
+      end
+
+      def to_h
+        {
+          "path_glob" => path_glob,
+          "method_name" => method_name.to_s,
+          "singleton" => singleton,
+          "param_types" => param_types.map { |pt| { "index" => pt.index, "type_name" => pt.type_name } },
+          "return_type_name" => return_type_name,
+          "severity" => severity.to_s
+        }
+      end
+
+      def ==(other)
+        other.is_a?(ProtocolContract) && to_h == other.to_h
+      end
+      alias eql? ==
+
+      def hash
+        to_h.hash
+      end
+
+      private
+
+      def validate_path_glob!(value)
+        return if value.is_a?(String) && !value.empty?
+
+        raise ArgumentError,
+              "Plugin::ProtocolContract#path_glob must be a non-empty String, got #{value.inspect}"
+      end
+
+      def validate_method_name!(value)
+        return if value.is_a?(Symbol) || (value.is_a?(String) && !value.empty?)
+
+        raise ArgumentError,
+              "Plugin::ProtocolContract#method_name must be a Symbol/non-empty String, got #{value.inspect}"
+      end
+
+      def validate_return_type_name!(value)
+        return if value.nil?
+        return if value.is_a?(String) && !value.empty?
+
+        raise ArgumentError,
+              "Plugin::ProtocolContract#return_type_name must be a non-empty String or nil, got #{value.inspect}"
+      end
+
+      def validate_severity!(value)
+        return if VALID_SEVERITIES.include?(value.to_sym)
+
+        raise ArgumentError,
+              "Plugin::ProtocolContract#severity must be one of #{VALID_SEVERITIES.inspect}, got #{value.inspect}"
+      rescue NoMethodError
+        raise ArgumentError,
+              "Plugin::ProtocolContract#severity must be one of #{VALID_SEVERITIES.inspect}, got #{value.inspect}"
+      end
+
+      def coerce_param_types(param_types)
+        unless param_types.is_a?(Array)
+          raise ArgumentError,
+                "Plugin::ProtocolContract#param_types must be an Array, got #{param_types.inspect}"
+        end
+
+        param_types.map { |entry| coerce_param_type(entry) }.freeze
+      end
+
+      def coerce_param_type(entry)
+        return entry if entry.is_a?(ParamType)
+
+        unless entry.is_a?(Hash)
+          raise ArgumentError,
+                "Plugin::ProtocolContract param_types entry must be a Hash or ParamType, got #{entry.inspect}"
+        end
+
+        index = entry[:index] || entry["index"]
+        type_name = entry[:type_name] || entry["type_name"]
+        unless index.is_a?(Integer) && index >= 0 && type_name.is_a?(String) && !type_name.empty?
+          raise ArgumentError,
+                "Plugin::ProtocolContract param_types entry needs an Integer index >= 0 and a " \
+                "non-empty String type_name, got #{entry.inspect}"
+        end
+
+        ParamType.new(index: index, type_name: type_name.dup.freeze)
+      end
+    end
+  end
+end

data/lib/rigor/plugin/registry.rb

@@ -104,7 +104,94 @@ module Rigor
         Inference::HktRegistry.new(registrations: registrations, definitions: definitions)
       end
 
+      # ADR-25 — flat, ordered list of every loaded plugin's
+      # resolved RBS signature directories (absolute paths), in
+      # plugin registration order. `Environment.for_project`
+      # merges these into the signature-path set fed to
+      # `RbsLoader`, alongside the configuration's `signature_paths:`
+      # and the `bundler:` / `rbs_collection:` discovery output.
+      def signature_paths
+        plugins.flat_map(&:signature_paths)
+      end
+
+      # ADR-26 — the aggregate set of "open" receiver class names
+      # declared across loaded plugins (manifest `open_receivers:`).
+      # A class is open when a plugin vouches that it responds
+      # beyond its RBS-declared method surface. `open_receiver?`
+      # is the membership predicate `Analysis::CheckRules` consults
+      # to skip the `call.undefined-method` rule for such a class.
+      def open_receivers
+        plugins.flat_map { |plugin| plugin.manifest.open_receivers }
+      end
+
+      def open_receiver?(class_name)
+        return false if class_name.nil?
+
+        open_receivers.include?(class_name.to_s)
+      end
+
+      # ADR-28 — flat, ordered list of every loaded plugin's
+      # path-scoped method-protocol contracts, in plugin
+      # registration order. Read from each plugin's
+      # `#protocol_contracts` (which the manifest backs by default
+      # but a plugin MAY override to fold in per-project config).
+      # Consumed by `Inference::MethodParameterBinder` (the
+      # parameter-type provision) and by contributing plugins'
+      # `#diagnostics_for_file` hooks (the presence + return-type
+      # check).
+      def protocol_contracts
+        plugins.flat_map(&:protocol_contracts)
+      end
+
+      # ADR-28 — the subset of `protocol_contracts` whose
+      # `path_glob` matches `path`. Contract globs are authored
+      # project-root-relative (`lib/controller/**/*.rb`); the
+      # analyzer may hand this method either a project-relative
+      # path (`rigor check` run from the project root) or an
+      # absolute one (run from elsewhere, or a spec tmpdir), so the
+      # glob is matched both directly and as a `**/`-prefixed path
+      # suffix. `File::FNM_PATHNAME` keeps `*` from crossing `/`;
+      # `File::FNM_EXTGLOB` enables `{a,b}` groups. Returns `[]` for
+      # a nil path so the binder can call this unconditionally.
+      def contracts_for_path(path)
+        return [] if path.nil?
+
+        path_s = path.to_s
+        protocol_contracts.select { |contract| path_matches_glob?(contract.path_glob, path_s) }
+      end
+
+      # ADR-32 WD4 + WD5 — flat ordered list of
+      # `[plugin, callable]` pairs for every loaded plugin that
+      # declares a `source_rbs_synthesizer:` in its manifest. The
+      # engine invokes each callable once per analysed Ruby source
+      # file at env-build time; non-nil return strings are merged
+      # into the RBS environment as virtual signature sources.
+      # The full plugin instance is carried alongside the
+      # callable so the engine's cache layer (WD5) can compose
+      # `plugin.plugin_entry` into its per-file descriptor — a
+      # config change to the plugin (e.g. flipping
+      # `require_magic_comment:`) invalidates the dependent
+      # synthesizer cache without any plugin-side bookkeeping.
+      def source_rbs_synthesizers
+        plugins.filter_map do |plugin|
+          synthesizer = plugin.manifest.source_rbs_synthesizer
+          next nil if synthesizer.nil?
+
+          [plugin, synthesizer]
+        end
+      end
+
+      FNMATCH_FLAGS = File::FNM_PATHNAME | File::FNM_EXTGLOB
+      private_constant :FNMATCH_FLAGS
+
       EMPTY = new.freeze
+
+      private
+
+      def path_matches_glob?(glob, path)
+        File.fnmatch?(glob, path, FNMATCH_FLAGS) ||
+          File.fnmatch?(File.join("**", glob), path, FNMATCH_FLAGS)
+      end
     end
   end
 end

data/lib/rigor/plugin/source_rbs_synthesis_reporter.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Plugin
+    # ADR-32 WD6 — per-run accumulator for failures encountered by
+    # a plugin's `Manifest#source_rbs_synthesizer` callable. The
+    # synthesizer returns `[:error, message]` on parse failure
+    # (per its contract); `Environment.for_project` routes the
+    # tuple through `#record` here. `Analysis::Runner` queries
+    # `#entries` after analysis and emits one
+    # `source-rbs-synthesis-failed` `:info` diagnostic per
+    # entry so the user sees which files contributed nothing
+    # and why.
+    #
+    # Empty by default. The Runner only emits diagnostics when
+    # at least one entry is recorded — projects without
+    # synthesizer-emitting plugins pay zero cost.
+    #
+    # Thread-/Ractor-safety: this reporter is per-`WorkerSession`
+    # in pool mode, so concurrent writes from one Ractor's
+    # `collect_virtual_rbs` loop are serialised by the worker
+    # body itself. The sequential path shares a single reporter
+    # across the run; entries are appended one at a time during
+    # env build (before any per-file analysis runs), so no
+    # locking is needed.
+    class SourceRbsSynthesisReporter
+      Entry = Data.define(:plugin_id, :path, :message)
+
+      def initialize
+        @entries = []
+      end
+
+      def record(plugin_id:, path:, message:)
+        @entries << Entry.new(
+          plugin_id: plugin_id.to_s.dup.freeze,
+          path: path.to_s.dup.freeze,
+          message: message.to_s.dup.freeze
+        )
+        nil
+      end
+
+      def entries
+        @entries.dup.freeze
+      end
+
+      def empty?
+        @entries.empty?
+      end
+    end
+  end
+end

data/lib/rigor/sig_gen/generator.rb

@@ -7,6 +7,7 @@ require_relative "../environment"
 require_relative "../scope"
 require_relative "../reflection"
 require_relative "../type"
+require_relative "../inference/def_return_typer"
 require_relative "../inference/scope_indexer"
 require_relative "../inference/rbs_type_translator"
 
@@ -118,7 +119,8 @@ module Rigor
         candidates_from_defs = defs.filter_map do |def_node, class_name, kind|
           classify_def(path, def_node, class_name, kind, scope_index)
         end
-        candidates_from_defs + collect_attr_candidates(parse_result.value, path, scope_index)
+        obs_ivar_map = build_observed_ivar_map(parse_result.value)
+        candidates_from_defs + collect_attr_candidates(parse_result.value, path, scope_index, obs_ivar_map)
       end
 
       # Walks the AST collecting `(def_node, class_name, kind)`
@@ -501,73 +503,11 @@ module Rigor
       # `V | nil` via `return nil unless ...`). The walk
       # excludes nested `DefNode` / lambda / block scopes
       # whose returns belong to different methods.
+      # Delegates to {Rigor::Inference::DefReturnTyper} — the same
+      # body-typing + explicit-return-union the `rigor annotate`
+      # def-line annotator uses.
       def infer_return_type(def_node, scope_index)
-        body = def_node.body
-        return nil if body.nil?
-
-        last = body_last_expression(body)
-        return nil if last.nil?
-
-        inner_scope = scope_index[last] || scope_index[body] || scope_index[def_node]
-        return nil if inner_scope.nil?
-
-        last_type = inner_scope.type_of(last)
-        union_with_explicit_returns(body, last_type, scope_index)
-      rescue StandardError
-        nil
-      end
-
-      def body_last_expression(body)
-        case body
-        when Prism::StatementsNode then body.body.last
-        when Prism::BeginNode then body_last_expression(body.statements)
-        else body
-        end
-      end
-
-      def union_with_explicit_returns(body, last_type, scope_index)
-        return_types = []
-        collect_return_types(body, scope_index, return_types)
-        return last_type if return_types.empty?
-
-        Type::Combinator.union(last_type, *return_types)
-      end
-
-      RETURN_BARRIER_NODES = [Prism::DefNode, Prism::LambdaNode, Prism::BlockNode].freeze
-      private_constant :RETURN_BARRIER_NODES
-
-      def collect_return_types(node, scope_index, out)
-        return unless node.is_a?(Prism::Node)
-        return if RETURN_BARRIER_NODES.any? { |klass| node.is_a?(klass) }
-
-        type_return_node(node, scope_index, out) if node.is_a?(Prism::ReturnNode)
-        node.compact_child_nodes.each { |c| collect_return_types(c, scope_index, out) }
-      end
-
-      def type_return_node(return_node, scope_index, out)
-        args = return_node.arguments&.arguments || []
-        if args.empty?
-          out << Type::Combinator.constant_of(nil)
-          return
-        end
-
-        scope = scope_index[return_node] || scope_index[args.first]
-        return if scope.nil?
-
-        # `return a, b` packs into a Tuple at runtime; the MVP
-        # only handles the single-value form. Multi-arg returns
-        # contribute no type to keep the implementation
-        # focused.
-        return unless args.size == 1
-
-        type = safe_return_type_of(scope, args.first)
-        out << type unless type.nil?
-      end
-
-      def safe_return_type_of(scope, node)
-        scope.type_of(node)
-      rescue StandardError
-        nil
+        Inference::DefReturnTyper.call(def_node, scope_index)
       end
 
       def dynamic_top?(type)
@@ -746,7 +686,7 @@ module Rigor
       def computed_literal_tightening?(inferred, def_node)
         return false unless inferred.is_a?(Type::Constant)
 
-        last = body_last_expression(def_node.body)
+        last = Inference::DefReturnTyper.body_last_expression(def_node.body)
         !direct_literal_node?(last)
       end
 
@@ -898,11 +838,15 @@ module Rigor
 
       # Per-file context the attr_* walker threads through its
       # recursive descent. Keeps parameter lists in check.
-      AttrWalkContext = Struct.new(:path, :scope_index, :out, keyword_init: true)
+      # `obs_ivar_map` carries the observation-derived fallback types
+      # built by {#build_observed_ivar_map}; it is empty when sig-gen
+      # is invoked without `--params=observed`.
+      AttrWalkContext = Struct.new(:path, :scope_index, :obs_ivar_map, :out, keyword_init: true)
       private_constant :AttrWalkContext
 
-      def collect_attr_candidates(root, path, scope_index)
-        ctx = AttrWalkContext.new(path: path, scope_index: scope_index, out: [])
+      def collect_attr_candidates(root, path, scope_index, obs_ivar_map = {})
+        ctx = AttrWalkContext.new(path: path, scope_index: scope_index,
+                                  obs_ivar_map: obs_ivar_map, out: [])
         walk_attr_calls(root, [], false, ctx)
         ctx.out
       end
@@ -941,7 +885,7 @@ module Rigor
         symbol_names = extract_symbol_arguments(call_node)
         return if symbol_names.empty?
 
-        ivar_lookup = ivar_type_lookup(ctx.scope_index, class_name)
+        ivar_lookup = ivar_type_lookup(ctx.scope_index, class_name, ctx.obs_ivar_map)
         symbol_names.each do |attr_name|
           ivar_type = ivar_lookup.call(attr_name)
           ctx.out.concat(build_attr_candidates(call_node.name, class_name, attr_name, ivar_type, ctx))
@@ -961,12 +905,143 @@ module Rigor
       # before any statement evaluation runs, so the lookup
       # works even when attr_* declarations come before the
       # corresponding ivar writes lexically.
-      def ivar_type_lookup(scope_index, class_name)
+      #
+      # When `obs_ivar_map` is non-empty (i.e. `--params=observed`
+      # was used), it acts as a fallback: if the ivar pre-pass
+      # resolved the type to `nil` or `Dynamic[top]` — typically
+      # because `@ivar = param` inside `initialize` typed the param
+      # as `untyped` — the observation-derived type is substituted.
+      # This lets `attr_reader :name` emit a concrete type when
+      # `ClassName.new("alice")` call sites are visible to the
+      # observation scan.
+      def ivar_type_lookup(scope_index, class_name, obs_ivar_map = {})
         any_scope = scope_index.each_value.first
         return ->(_) {} if any_scope.nil?
 
-        ivars = any_scope.class_ivars_for(class_name)
-        ->(attr_name) { ivars[:"@#{attr_name}"] }
+        ivars     = any_scope.class_ivars_for(class_name)
+        obs_ivars = obs_ivar_map[class_name] || {}
+        lambda do |attr_name|
+          type = ivars[:"@#{attr_name}"]
+          type.nil? || dynamic_top?(type) ? obs_ivars[attr_name] : type
+        end
+      end
+
+      # Build a { class_name => { attr_name_sym => Type } } map that
+      # records observation-derived types for ivars assigned directly
+      # from `def initialize` parameters. Only populated when
+      # `@observations` is non-empty (i.e. `--params=observed` was
+      # supplied). Matches the pattern `@ivar_name = param_name` where
+      # `param_name` is a required / optional positional or keyword
+      # parameter of `initialize`.
+      def build_observed_ivar_map(root)
+        return {} if @observations.empty?
+
+        result = {}
+        collect_init_ivar_obs(root, [], result)
+        result
+      end
+
+      def collect_init_ivar_obs(node, prefix, result)
+        return unless node.is_a?(Prism::Node)
+
+        case node
+        when Prism::ClassNode, Prism::ModuleNode
+          name = qualified_constant_path(node.constant_path)
+          if name
+            collect_init_ivar_obs(node.body, prefix + [name], result) if node.body
+            return
+          end
+        when Prism::DefNode
+          if node.name == :initialize && !prefix.empty?
+            class_name = prefix.join("::")
+            map = ivar_obs_from_initialize(class_name, node)
+            result[class_name] = (result[class_name] || {}).merge(map) unless map.empty?
+          end
+          return
+        end
+
+        node.compact_child_nodes.each { |c| collect_init_ivar_obs(c, prefix, result) }
+      end
+
+      # Derive { attr_name_sym => Type } for a single `def initialize`
+      # by matching `@ivar = param_name` assignments against the
+      # available `[class_name, :initialize]` observations.
+      def ivar_obs_from_initialize(class_name, def_node)
+        obs_list = @observations[[class_name, :initialize]]
+        return {} if obs_list.nil? || obs_list.empty?
+        return {} if def_node.body.nil? || def_node.parameters.nil?
+
+        param_index = build_init_param_index(def_node.parameters)
+        return {} if param_index.empty?
+
+        ivar_to_param = {}
+        scan_ivar_param_assignments(def_node.body, param_index.keys.to_set, ivar_to_param)
+        build_ivar_obs_type_map(ivar_to_param, param_index, obs_list)
+      end
+
+      # Map `{ ivar_name => param_name }` → `{ attr_name_sym => Type }`
+      # by looking up each param's observation types and unioning them.
+      def build_ivar_obs_type_map(ivar_to_param, param_index, obs_list)
+        ivar_to_param.filter_map do |ivar_name, param_name|
+          types = collect_param_obs_types(obs_list, param_name, param_index[param_name])
+          next if types.empty?
+
+          attr_name = ivar_name.to_s.delete_prefix("@").to_sym
+          [attr_name, types.reduce { |acc, t| Type::Combinator.union(acc, t) }]
+        end.to_h
+      end
+
+      # Collect observed argument types for a single parameter across all
+      # call-site observations. Returns an array of Type objects (may be empty).
+      def collect_param_obs_types(obs_list, param_name, param_info)
+        case param_info[:kind]
+        when :positional then obs_list.filter_map { |obs| obs.positional[param_info[:index]] }
+        when :keyword    then obs_list.filter_map { |obs| obs.keyword[param_name] }
+        else []
+        end
+      end
+
+      # Map param_name_sym → { kind: :positional, index: N } or
+      # { kind: :keyword } for required / optional positionals and
+      # required / optional keywords of a ParametersNode.
+      def build_init_param_index(parameters)
+        index  = {}
+        offset = 0
+
+        (parameters.requireds || []).each_with_index do |p, i|
+          index[p.name] = { kind: :positional, index: offset + i } if p.respond_to?(:name)
+        end
+        offset += parameters.requireds&.size || 0
+
+        (parameters.optionals || []).each_with_index do |p, i|
+          index[p.name] = { kind: :positional, index: offset + i } if p.respond_to?(:name)
+        end
+
+        (parameters.keywords || []).each do |kw|
+          index[kw.name] = { kind: :keyword } if kw.respond_to?(:name)
+        end
+
+        index
+      end
+
+      # Walk a def body for direct `@ivar = local_var` assignments
+      # where `local_var` is one of the listed parameter names.
+      # Records ivar_name (Symbol with `@` prefix) → param_name.
+      # Does not recurse into nested defs / classes / modules.
+      def scan_ivar_param_assignments(node, param_names, result)
+        return unless node.is_a?(Prism::Node)
+
+        if node.is_a?(Prism::InstanceVariableWriteNode) &&
+           node.value.is_a?(Prism::LocalVariableReadNode) &&
+           param_names.include?(node.value.name)
+          result[node.name] ||= node.value.name
+        end
+
+        return if node.is_a?(Prism::DefNode) ||
+                  node.is_a?(Prism::ClassNode) ||
+                  node.is_a?(Prism::ModuleNode)
+
+        node.compact_child_nodes.each { |c| scan_ivar_param_assignments(c, param_names, result) }
       end
 
       def build_attr_candidates(call_name, class_name, attr_name, ivar_type, ctx)

data/lib/rigor/triage/catalogue.rb

@@ -122,8 +122,8 @@ module Rigor
           diagnostic_count: matched.size,
           summary: "undefined-method on core classes (#{top_methods(matched)}) — " \
                    "ActiveSupport monkey-patches these",
-          action: "Wire the rigor-activesupport-core-ext RBS bundle via " \
-                  "`signature_paths:` in .rigor.yml."
+          action: "Add rigor-activesupport-core-ext to `plugins:` in .rigor.yml " \
+                  "(it is an RBS-bundle plugin — ADR-25)."
         ), matched]
       end
 

data/lib/rigor/type/combinator.rb

@@ -256,6 +256,63 @@ module Rigor
           refined.base.class_name == "String"
       end
 
+      # Returns true when `type` is statically known to be a
+      # non-empty String — i.e. its value can never be `""`.
+      # Used at String binary-operator dispatch sites to propagate
+      # the non-empty guarantee through `+` and `*`.
+      #
+      # - `Constant[s]` where `s != ""` — a concrete non-empty literal.
+      # - `Difference[Nominal[String], Constant[""]]` — the canonical
+      #   `non-empty-string` carrier.
+      # - `Intersection[…]` — any member suffices (set-theoretic subset).
+      # - `Union[…]` — all members must qualify (the join may include "").
+      def non_empty_string_compatible?(type)
+        case type
+        when Constant then type.value.is_a?(String) && !type.value.empty?
+        when Difference then non_empty_string_difference?(type)
+        when Intersection then type.members.any? { |m| non_empty_string_compatible?(m) }
+        when Union then !type.members.empty? && type.members.all? { |m| non_empty_string_compatible?(m) }
+        else false
+        end
+      end
+
+      def non_empty_string_difference?(diff)
+        return false unless diff.base.is_a?(Nominal) && diff.base.class_name == "String"
+        return false unless diff.removed.is_a?(Constant)
+
+        diff.removed.value == ""
+      end
+
+      # Returns true when `type` is statically known to be a
+      # non-zero Integer — i.e. its value can never be `0`.
+      # Used at Integer arithmetic dispatch sites to propagate
+      # the non-zero guarantee through `*` and identity methods.
+      #
+      # - `Constant[n]` where `n != 0` — a concrete non-zero literal.
+      # - `Difference[Nominal[Integer], Constant[0]]` — the canonical
+      #   `non-zero-int` carrier.
+      # - `IntegerRange` that does not cover 0 — both `positive-int`
+      #   ([1,+∞)) and `negative-int` ([-∞,-1]) qualify.
+      # - `Intersection[…]` — any member suffices.
+      # - `Union[…]` — all members must qualify.
+      def non_zero_int_compatible?(type)
+        case type
+        when Constant then type.value.is_a?(Integer) && !type.value.zero?
+        when Difference then non_zero_int_difference?(type)
+        when IntegerRange then !type.covers?(0)
+        when Intersection then type.members.any? { |m| non_zero_int_compatible?(m) }
+        when Union then !type.members.empty? && type.members.all? { |m| non_zero_int_compatible?(m) }
+        else false
+        end
+      end
+
+      def non_zero_int_difference?(diff)
+        return false unless diff.base.is_a?(Nominal) && diff.base.class_name == "Integer"
+        return false unless diff.removed.is_a?(Constant)
+
+        diff.removed.value.zero?
+      end
+
       # Normalised intersection. Flattens nested Intersections,
       # drops `Top` members, collapses to `Bot` if any member is
       # `Bot`, deduplicates structurally-equal members, sorts the