rigortype 0.1.9 → 0.1.10

data/lib/rigor/environment.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "digest"
+
 require_relative "environment/class_registry"
 require_relative "environment/rbs_loader"
 require_relative "environment/reflection"
@@ -24,7 +26,7 @@ module Rigor
   # constant-folding tiers cannot answer.
   #
   # See docs/internal-spec/inference-engine.md for the binding contract.
-  class Environment
+  class Environment # rubocop:disable Metrics/ClassLength
     DEFAULT_PROJECT_SIG_DIR = "sig"
     private_constant :DEFAULT_PROJECT_SIG_DIR
 
@@ -87,6 +89,7 @@ module Rigor
     def initialize(class_registry: ClassRegistry.default, rbs_loader: nil, # rubocop:disable Metrics/ParameterLists
                    plugin_registry: nil, dependency_source_index: nil,
                    rbs_extended_reporter: nil, boundary_cross_reporter: nil,
+                   source_rbs_synthesis_reporter: nil,
                    synthetic_method_index: nil, project_patched_methods: nil,
                    hkt_registry: nil)
       @class_registry = class_registry
@@ -100,7 +103,8 @@ module Rigor
       # accessors below preserve the public lookup shape.
       @reporters = Reporters.new(
         rbs_extended: rbs_extended_reporter,
-        boundary_cross: boundary_cross_reporter
+        boundary_cross: boundary_cross_reporter,
+        source_rbs_synthesis: source_rbs_synthesis_reporter
       )
       @synthetic_method_index = synthetic_method_index || Inference::SyntheticMethodIndex::EMPTY
       @project_patched_methods = project_patched_methods || Inference::ProjectPatchedMethods::EMPTY
@@ -159,6 +163,17 @@ module Rigor
       @reporters.boundary_cross
     end
 
+    # ADR-32 WD6 — the per-run accumulator for synthesizer
+    # failure events. `Environment.for_project` records
+    # `[:error, message]` returns from a plugin's
+    # `source_rbs_synthesizer` here so the Runner can emit
+    # `source-rbs-synthesis-failed` `:info` diagnostics after
+    # analysis completes. Nil when no plugin contributes a
+    # synthesizer.
+    def source_rbs_synthesis_reporter
+      @reporters.source_rbs_synthesis
+    end
+
     # Replaces the env's per-run reporter slots. Intended for
     # long-lived integrations (LSP `ProjectContext`) that share one
     # Environment instance across many `Runner.run` calls: each call
@@ -210,10 +225,12 @@ module Rigor
       def for_project(root: Dir.pwd, libraries: [], signature_paths: nil, cache_store: nil,
                       plugin_registry: nil, dependency_source_index: nil,
                       rbs_extended_reporter: nil, boundary_cross_reporter: nil,
+                      source_rbs_synthesis_reporter: nil,
                       bundler_bundle_path: nil, bundler_auto_detect: false,
                       bundler_lockfile: nil,
                       rbs_collection_lockfile: nil, rbs_collection_auto_detect: false,
-                      synthetic_method_index: nil, project_patched_methods: nil)
+                      synthetic_method_index: nil, project_patched_methods: nil,
+                      source_files: [])
         resolved_paths = signature_paths || default_signature_paths(root)
         # O4 MVP — append per-gem `sig/` directories discovered
         # under the target project's bundler install root. Empty
@@ -262,10 +279,29 @@ module Rigor
         plugin_sig_paths = plugin_registry ? plugin_registry.signature_paths.map(&:to_s) : []
         loader_signature_paths = resolved_paths + plugin_sig_paths + gem_sig_paths + collection_paths
         merged_libraries = (DEFAULT_LIBRARIES + libraries.map(&:to_s)).uniq
+        # ADR-32 WD4 + WD5 — invoke each loaded plugin's
+        # `source_rbs_synthesizer` once per project source file
+        # and collect non-nil `[filename, rbs_source]` pairs.
+        # The synthesizer-emitting plugin (currently only
+        # `rigor-rbs-inline`) is responsible for its own
+        # fail-soft on parse errors per WD6; this loop only
+        # filters `nil` returns.
+        #
+        # When a `cache_store` is supplied, each synthesizer
+        # invocation is memoised per
+        # `(file path + content SHA, plugin id + version + config_hash)`
+        # — WD5's cache key — so a second run with unchanged
+        # source skips the rbs-inline parse cost. The empty
+        # string is the sentinel for "no contribution" so the
+        # Store (which treats `nil` as cache miss) can persist
+        # the no-contribution decision too.
+        virtual_rbs = collect_virtual_rbs(plugin_registry, source_files, cache_store,
+                                          source_rbs_synthesis_reporter)
         loader = RbsLoader.new(
           libraries: merged_libraries,
           signature_paths: loader_signature_paths,
-          cache_store: cache_store
+          cache_store: cache_store,
+          virtual_rbs: virtual_rbs
         )
         # ADR-20 slice 2c + 2e — seed hkt_registry with the
         # bundled builtins. The Environment's `#hkt_registry`
@@ -282,6 +318,7 @@ module Rigor
           dependency_source_index: dependency_source_index,
           rbs_extended_reporter: rbs_extended_reporter,
           boundary_cross_reporter: boundary_cross_reporter,
+          source_rbs_synthesis_reporter: source_rbs_synthesis_reporter,
           synthetic_method_index: synthetic_method_index,
           project_patched_methods: project_patched_methods,
           hkt_registry: Builtins::HktBuiltins.registry
@@ -295,6 +332,124 @@ module Rigor
         sig = Pathname(root) / DEFAULT_PROJECT_SIG_DIR
         sig.directory? ? [sig] : []
       end
+
+      # ADR-32 WD4 + WD5 — for each project source file, invoke
+      # every plugin-registered synthesizer once and collect
+      # non-nil returns. The returned array is `[[virtual_filename,
+      # rbs_source], ...]`; the loader threads it through to
+      # `RbsLoader.new(virtual_rbs: ...)`.
+      #
+      # `virtual_filename` is the source file path prefixed with
+      # the plugin id so RBS parse errors point back to the
+      # contributing plugin in their diagnostic location string.
+      #
+      # When no plugin declares a synthesizer (the common case),
+      # the registry's `source_rbs_synthesizers` is empty and
+      # this method short-circuits to `[]` without walking the
+      # file list.
+      #
+      # WD5 — when `cache_store` is supplied, each (file, plugin)
+      # synthesizer call is memoised through `Cache::Store`. The
+      # cache key composes the file's content SHA with the
+      # plugin's `PluginEntry` (id + version + config_hash) so a
+      # config change or content change invalidates the entry
+      # automatically.
+      def collect_virtual_rbs(plugin_registry, source_files, cache_store, reporter)
+        return [] if plugin_registry.nil?
+
+        synthesizers = plugin_registry.source_rbs_synthesizers
+        return [] if synthesizers.empty?
+        return [] if source_files.nil? || source_files.empty?
+
+        result = []
+        source_files.each do |path|
+          synthesizers.each do |plugin, callable|
+            outcome = synthesizer_output_for(plugin, callable, path, cache_store)
+            outcome = interpret_synthesizer_outcome(outcome, plugin, path, reporter)
+            next if outcome.nil? || outcome.empty?
+
+            virtual_name = "virtual:#{plugin.manifest.id}:#{path}"
+            result << [virtual_name, outcome]
+          end
+        end
+        result
+      end
+
+      # ADR-32 WD5 — cache wrapper around a single (plugin,
+      # file) invocation. The cache stores the empty string
+      # `""` as the "no contribution" sentinel because
+      # `Cache::Store` treats `nil` as a cache miss. Error
+      # tuples are stored as the canonical
+      # `[:error, message_string]` Array so the same wrapper
+      # short-circuits subsequent runs against unchanged broken
+      # input.
+      def synthesizer_output_for(plugin, callable, path, cache_store)
+        return invoke_synthesizer_safely(callable, path) if cache_store.nil?
+        return invoke_synthesizer_safely(callable, path) unless File.file?(path)
+
+        descriptor = build_synthesizer_cache_descriptor(plugin, path)
+        cache_store.fetch_or_compute(
+          producer_id: SYNTHESIZER_CACHE_PRODUCER_ID,
+          params: {},
+          descriptor: descriptor
+        ) { invoke_synthesizer_safely(callable, path) || "" }
+      end
+
+      # ADR-32 WD6 — route a synthesizer return value through
+      # the per-run failure reporter. The synthesizer's contract
+      # (declared in `plugins/rigor-rbs-inline/lib/rigor/plugin/rbs_inline.rb`)
+      # admits three return shapes:
+      #   - `String` (non-empty) → successful RBS source
+      #   - `nil` / `""`         → no contribution
+      #   - `[:error, message]`  → parse failed
+      # The error tuple is converted into a reporter entry +
+      # treated as "no contribution" so the analysis pipeline
+      # continues. Reporter is `nil` for callers that don't care
+      # (legacy Environment.new, tests).
+      def interpret_synthesizer_outcome(outcome, plugin, path, reporter)
+        return outcome unless outcome.is_a?(Array) && outcome[0] == :error
+
+        reporter&.record(
+          plugin_id: plugin.manifest.id,
+          path: path,
+          message: outcome[1].to_s
+        )
+        nil
+      end
+
+      SYNTHESIZER_CACHE_PRODUCER_ID = "plugin.source_rbs_synthesizer"
+      private_constant :SYNTHESIZER_CACHE_PRODUCER_ID
+
+      def build_synthesizer_cache_descriptor(plugin, path)
+        Cache::Descriptor.new(
+          files: [Cache::Descriptor::FileEntry.new(
+            path: path.to_s,
+            comparator: :digest,
+            value: synthesizer_input_digest(path)
+          )],
+          plugins: [plugin.plugin_entry]
+        )
+      end
+
+      def synthesizer_input_digest(path)
+        Digest::SHA256.hexdigest(File.binread(path))
+      rescue ::SystemCallError
+        # Unreadable file → key on the path alone; the
+        # synthesizer's File.file?/File.read will see the same
+        # failure and return nil.
+        Digest::SHA256.hexdigest(path.to_s)
+      end
+
+      def invoke_synthesizer_safely(callable, path)
+        callable.call(path.to_s)
+      rescue StandardError
+        # WD6 fail-soft — a synthesizer that raises does NOT
+        # crash analysis. Slice 2b will turn this into a
+        # `source-rbs-synthesis-failed` info diagnostic; for now
+        # the contract is "no analysis crash on a misbehaving
+        # synthesizer".
+        nil
+      end
     end
 
     # Resolves a constant name to a Rigor::Type::Nominal (the *instance*

data/lib/rigor/inference/def_return_typer.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../type"
+
+module Rigor
+  module Inference
+    # Returns the inferred return type of a `Prism::DefNode`, or nil
+    # when no type can be derived (empty body, scope-lookup miss,
+    # or any failure during inference — caller surfaces "no
+    # annotation" on a nil).
+    #
+    # The inferred type is the union of:
+    #
+    # - the body's last-statement type, and
+    # - the type of every explicit `return value` reachable in the
+    #   body. Nested `def` / lambda / block bodies are return
+    #   barriers — their `return`s do not bubble up to the enclosing
+    #   method.
+    #
+    # Extracted from `Rigor::SigGen::Generator#infer_return_type` so
+    # `LineTypeCollector` (`rigor annotate`'s def-line annotator)
+    # and the sig-generator share one source of truth.
+    module DefReturnTyper
+      RETURN_BARRIER_NODES = [Prism::DefNode, Prism::LambdaNode, Prism::BlockNode].freeze
+      private_constant :RETURN_BARRIER_NODES
+
+      module_function
+
+      def call(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 = safe_type_of(inner_scope, last)
+        return nil if last_type.nil?
+
+        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
+
+      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_type_of(scope, args.first)
+        out << type unless type.nil?
+      end
+
+      def safe_type_of(scope, node)
+        scope.type_of(node)
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/rigor/inference/expression_typer.rb

@@ -8,6 +8,7 @@ require_relative "block_parameter_binder"
 require_relative "fallback"
 require_relative "macro_block_self_type"
 require_relative "method_dispatcher"
+require_relative "narrowing"
 
 module Rigor
   module Inference
@@ -660,16 +661,26 @@ module Rigor
       end
 
       # Returns `:truthy`, `:falsey`, or `nil` for an arbitrary
-      # predicate expression. Only `Type::Constant` answers
-      # decisively — `Union[true, false]`, `Nominal[bool]`, and
-      # `Dynamic[T]` keep both branches live.
+      # predicate expression under three-valued logic. Uses the
+      # same {Narrowing} probe as `StatementEvaluator#eval_if`:
+      # the predicate is truthy when its falsey fragment is `Bot`,
+      # falsey when its truthy fragment is `Bot`. So
+      # `Nominal[Integer]` (always truthy in Ruby), `Constant[nil]`,
+      # and `Constant[false]` fold one branch; `Union[true, false]`,
+      # `Dynamic[T]`, and `Top` keep both branches live.
       def constant_predicate_polarity(predicate)
         return nil if predicate.nil?
 
         type = type_of(predicate)
-        return nil unless type.is_a?(Type::Constant)
+        return nil if type.nil? || type.is_a?(Type::Bot)
 
-        type.value ? :truthy : :falsey
+        truthy_bot = Narrowing.narrow_truthy(type).is_a?(Type::Bot)
+        falsey_bot = Narrowing.narrow_falsey(type).is_a?(Type::Bot)
+
+        return :falsey if truthy_bot && !falsey_bot
+        return :truthy if !truthy_bot && falsey_bot
+
+        nil
       end
 
       def type_of_else(node)
@@ -712,15 +723,135 @@ module Rigor
         type.value ? :truthy : :falsey
       end
 
+      # Three-valued evaluation of `case predicate when pattern`
+      # dispatch. For each `when` clause we ask: under static types,
+      # does `pattern === predicate` definitely match (`:yes`),
+      # definitely not match (`:no`), or possibly match (`:maybe`)?
+      # Walking in source order:
+      #
+      # - `:yes` — this branch fires, subsequent branches are
+      #   unreachable. Result = union(prior `:maybe` branches, this
+      #   `:yes` branch).
+      # - `:no`  — branch dropped.
+      # - `:maybe` — branch is a candidate, continue.
+      #
+      # If no `:yes` was reached, the else clause (or `Constant[nil]`
+      # when absent) is added to the candidate set.
+      #
+      # The `case ... in` pattern-matching form (`CaseMatchNode`) and
+      # the predicate-less form (`case; when c1; ...`) bypass the
+      # `===` analysis: pattern matching has richer semantics, and a
+      # predicate-less `case` reduces to a `if c1; ...; elsif c2`
+      # chain that statement-level narrowing already handles.
       def type_of_case(node)
-        branch_types = node.conditions.map { |branch| type_of(branch) }
-        else_type =
-          if node.else_clause
-            type_of(node.else_clause)
-          else
-            Type::Combinator.constant_of(nil)
+        return type_of_case_simple_union(node) if node.is_a?(Prism::CaseMatchNode) || node.predicate.nil?
+
+        subject_type = type_of(node.predicate)
+        candidates = []
+        reached_yes = false
+
+        node.conditions.each do |when_node|
+          case case_when_branch_certainty(subject_type, when_node)
+          when :yes
+            candidates << type_of(when_node)
+            reached_yes = true
+            break
+          when :maybe
+            candidates << type_of(when_node)
+            # :no — drop the branch
           end
-        Type::Combinator.union(*branch_types, else_type)
+        end
+
+        candidates << type_of_case_else(node) unless reached_yes
+        Type::Combinator.union(*candidates)
+      end
+
+      def type_of_case_simple_union(node)
+        branch_types = node.conditions.map { |branch| type_of(branch) }
+        Type::Combinator.union(*branch_types, type_of_case_else(node))
+      end
+
+      def type_of_case_else(node)
+        return Type::Combinator.constant_of(nil) if node.else_clause.nil?
+
+        type_of(node.else_clause)
+      end
+
+      # Combines per-pattern certainty across a `when` clause's
+      # conditions (`when a, b, c` ≡ `a === s || b === s || c === s`).
+      # `:yes` if any pattern is `:yes`; `:no` if all are `:no`;
+      # `:maybe` otherwise.
+      def case_when_branch_certainty(subject_type, when_node)
+        return :maybe unless when_node.respond_to?(:conditions)
+
+        results = when_node.conditions.map { |c| case_when_pattern_certainty(subject_type, c) }
+        return :maybe if results.empty?
+        return :yes if results.include?(:yes)
+        return :no if results.all?(:no)
+
+        :maybe
+      end
+
+      # Static three-valued certainty for `pattern === subject`.
+      # Specialises two pattern shapes:
+      #
+      # - **Class / Module reference** (`Integer`, `Foo::Bar`):
+      #   reduce to `subject.is_a?(class)` via
+      #   `Narrowing.narrow_class` / `narrow_not_class`. A Bot
+      #   truthy fragment means no inhabitant matches (`:no`); a
+      #   Bot falsey fragment means every inhabitant matches
+      #   (`:yes`).
+      # - **Value-equality literal** (numeric / String / Symbol /
+      #   true / false / nil) against a `Constant[c]` subject:
+      #   the static comparison `pattern_value === c` is exact.
+      #   Other subject carriers stay `:maybe` because the
+      #   runtime value isn't pinned.
+      #
+      # Other pattern shapes (Range, Regexp, custom `===`) stay
+      # `:maybe` — the existing union fallback handles them.
+      def case_when_pattern_certainty(subject_type, pattern_node)
+        class_name = build_constant_path_name(pattern_node)
+        return class_pattern_certainty(subject_type, class_name) if class_name
+
+        literal = literal_pattern_value(pattern_node)
+        return literal_pattern_certainty(subject_type, literal[:value]) if literal
+
+        :maybe
+      end
+
+      def class_pattern_certainty(subject_type, class_name)
+        env = scope.environment
+        truthy_bot = Narrowing.narrow_class(subject_type, class_name, environment: env).is_a?(Type::Bot)
+        falsey_bot = Narrowing.narrow_not_class(subject_type, class_name, environment: env).is_a?(Type::Bot)
+
+        return :no if truthy_bot && !falsey_bot
+        return :yes if !truthy_bot && falsey_bot
+
+        :maybe
+      end
+
+      VALUE_EQUALITY_CLASSES = [Integer, Float, Rational, Complex, String, Symbol,
+                                TrueClass, FalseClass, NilClass].freeze
+      private_constant :VALUE_EQUALITY_CLASSES
+
+      # Returns `{ value: v }` when `pattern_node` types to a
+      # `Constant[v]` of a value-equality-safe class (so `===`
+      # reduces to `==`), else nil. Wrapped in a hash so a literal
+      # `nil` / `false` value doesn't collide with the "no literal"
+      # signal.
+      def literal_pattern_value(pattern_node)
+        type = type_of(pattern_node)
+        return nil unless type.is_a?(Type::Constant)
+        return nil unless VALUE_EQUALITY_CLASSES.any? { |klass| type.value.is_a?(klass) }
+
+        { value: type.value }
+      end
+
+      def literal_pattern_certainty(subject_type, pattern_value)
+        return :maybe unless subject_type.is_a?(Type::Constant)
+        return :maybe unless VALUE_EQUALITY_CLASSES.any? { |klass| subject_type.value.is_a?(klass) }
+
+        pattern_value == subject_type.value ? :yes : :no
       end
 
       # `when` clauses for `case` and `in` clauses for `case ... in` have

data/lib/rigor/inference/method_dispatcher/constant_folding.rb

@@ -988,6 +988,11 @@ module Rigor
           magnitude: :range_unary_abs,
           "-@": :range_unary_negate,
           "+@": :range_unary_identity,
+          # `Integer#to_i` / `Integer#to_int` are identity operations —
+          # they return `self` — so the IntegerRange carrier is preserved.
+          # `positive-int.to_i → positive-int`, etc.
+          to_i: :range_unary_identity,
+          to_int: :range_unary_identity,
           bit_length: :range_unary_bit_length
         }.freeze
         private_constant :UNARY_RANGE_DIRECT

data/lib/rigor/inference/method_dispatcher/literal_string_folding.rb

@@ -65,6 +65,11 @@ module Rigor
         # == ""`); the carrier collapses from `non-empty-literal-string`
         # down to plain `literal-string`.
         LITERAL_PRESERVING_METHODS = %i[strip lstrip rstrip chomp chop scrub].freeze
+        # Methods that preserve literal-bearing AND non-empty-string-ness.
+        # Unlike `LITERAL_PRESERVING_METHODS` (strip/chomp/etc.) these do
+        # not reduce the string — they transform characters without
+        # removing any, so a non-empty receiver stays non-empty.
+        NON_EMPTY_LITERAL_PRESERVING_METHODS = %i[upcase downcase capitalize swapcase reverse].freeze
         # v0.1.1 Track 1 slice 5c — width-padding methods. `center`
         # / `ljust` / `rjust` take a `width` Integer plus an
         # optional literal padding `String`. When the receiver
@@ -72,28 +77,32 @@ module Rigor
         # literal-bearing, the result is literal-bearing too.
         WIDTH_PADDING_METHODS = %i[center ljust rjust].freeze
         private_constant :CONCAT_METHODS, :FORMAT_METHODS,
-                         :LITERAL_PRESERVING_METHODS, :WIDTH_PADDING_METHODS
+                         :LITERAL_PRESERVING_METHODS, :NON_EMPTY_LITERAL_PRESERVING_METHODS,
+                         :WIDTH_PADDING_METHODS
 
         def try_dispatch(receiver:, method_name:, args:, **)
           return fold_array_join(receiver, args) if method_name == :join
           return fold_format(args) if FORMAT_METHODS.include?(method_name)
-
           return nil unless Type::Combinator.literal_string_compatible?(receiver)
-
           return fold_string_percent(args) if method_name == :%
-          if args.empty?
-            return LITERAL_PRESERVING_METHODS.include?(method_name) ? Type::Combinator.literal_string : nil
-          end
+          return fold_no_arg(receiver, method_name) if args.empty?
           return fold_width_pad(args) if WIDTH_PADDING_METHODS.include?(method_name)
           return nil unless args.size == 1
 
           if CONCAT_METHODS.include?(method_name)
-            fold_concat(args.first)
+            fold_concat(receiver, args.first)
           elsif method_name == :*
-            fold_repeat(args.first)
+            fold_repeat(receiver, args.first)
           end
         end
 
+        def fold_no_arg(receiver, method_name)
+          return Type::Combinator.literal_string if LITERAL_PRESERVING_METHODS.include?(method_name)
+          return non_empty_literal_result(receiver) if NON_EMPTY_LITERAL_PRESERVING_METHODS.include?(method_name)
+
+          nil
+        end
+
         # `String#center` / `#ljust` / `#rjust` — first argument is
         # the target width (Integer-typed), optional second
         # argument is the padding string (must be literal-bearing
@@ -111,19 +120,39 @@ module Rigor
           Type::Combinator.literal_string
         end
 
-        def fold_concat(arg_type)
-          return nil unless Type::Combinator.literal_string_compatible?(arg_type)
+        def fold_concat(receiver, arg)
+          return nil unless Type::Combinator.literal_string_compatible?(arg)
+
+          if Type::Combinator.non_empty_string_compatible?(receiver) ||
+             Type::Combinator.non_empty_string_compatible?(arg)
+            return Type::Combinator.non_empty_literal_string
+          end
 
           Type::Combinator.literal_string
         end
 
-        def fold_repeat(arg_type)
-          return nil unless integer_typed?(arg_type)
-          return nil if known_negative_integer?(arg_type)
+        def fold_repeat(receiver, arg)
+          return nil unless integer_typed?(arg)
+          return nil if known_negative_integer?(arg)
+          return Type::Combinator.constant_of("") if known_zero_integer?(arg)
+
+          if Type::Combinator.non_empty_string_compatible?(receiver) && known_positive_integer?(arg)
+            return Type::Combinator.non_empty_literal_string
+          end
 
           Type::Combinator.literal_string
         end
 
+        # Returns `non_empty_literal_string` when the receiver is provably
+        # non-empty; otherwise collapses to plain `literal_string`.
+        def non_empty_literal_result(receiver)
+          if Type::Combinator.non_empty_string_compatible?(receiver)
+            Type::Combinator.non_empty_literal_string
+          else
+            Type::Combinator.literal_string
+          end
+        end
+
         # `[lit, lit].join(sep)` — receiver must be a Tuple
         # whose every element is literal-bearing; separator
         # (when given) must be literal-bearing too. Multi-arg
@@ -205,9 +234,27 @@ module Rigor
           type.is_a?(Type::Constant) && type.value.is_a?(Integer) && type.value.negative?
         end
 
-        private_class_method :fold_concat, :fold_repeat, :fold_array_join,
+        def known_zero_integer?(type)
+          case type
+          when Type::Constant then type.value.is_a?(Integer) && type.value.zero?
+          when Type::IntegerRange then type.lower.zero? && type.upper.zero?
+          else false
+          end
+        end
+
+        def known_positive_integer?(type)
+          case type
+          when Type::Constant then type.value.is_a?(Integer) && type.value.positive?
+          when Type::IntegerRange then type.lower >= 1
+          else false
+          end
+        end
+
+        private_class_method :fold_no_arg, :fold_concat, :fold_repeat, :fold_array_join,
                              :fold_format, :fold_string_percent, :fold_width_pad,
-                             :literal_or_constant?, :integer_typed?
+                             :non_empty_literal_result, :literal_or_constant?,
+                             :integer_typed?, :known_negative_integer?,
+                             :known_zero_integer?, :known_positive_integer?
       end
     end
   end