rigortype 0.3.7 → 0.3.9

data/lib/rigor/inference/fork_map.rb

@@ -22,10 +22,10 @@ module Rigor
     module ForkMap
       module_function
 
-      # @param items [Array] work items (file paths, or `[path, ast]` pairs), in caller order.
-      # @param workers [Integer] resolved worker count (≤1, empty items, or no `fork` → sequential).
-      # @yield [Array] a contiguous slice of `items`; must return a **marshalable** object.
-      # @return [Array] the per-slice block results, in original slice order.
+      # @param items — work items (file paths, or `[path, ast]` pairs), in caller order.
+      # @param workers — resolved worker count (≤1, empty items, or no `fork` → sequential).
+      # @yield a contiguous slice of `items`; must return a **marshalable** object.
+      # @return the per-slice block results, in original slice order.
       def call(items:, workers:, &block)
         worker_count = [workers, items.size].min
         return [block.call(items)] unless parallel?(worker_count) && !items.empty?
@@ -55,8 +55,6 @@ module Rigor
       # The directory check is the belt to {.run_worker}'s braces: the offer is only worth taking while the
       # parent still has the directory open, and answering `nil` once it is gone degrades to `Dir.tmpdir`
       # instead of raising `Errno::ENOENT` somewhere far from here.
-      #
-      # @return [String, nil]
       def child_scratch_dir
         return nil unless @child_scratch_dir && File.directory?(@child_scratch_dir)
 
@@ -120,7 +118,7 @@ module Rigor
         end
       end
 
-      # @return [Hash{value: Object}, nil] the child's payload wrapped so a legitimately-nil block result is
+      # @return the child's payload wrapped so a legitimately-nil block result is
       #   distinguishable from an abnormal exit. `Marshal.load` is safe: the blob was written by our own
       #   forked child to a temp file we created.
       def worker_payload(status, out_path)

data/lib/rigor/inference/hkt_reducer.rb

@@ -41,10 +41,9 @@ module Rigor
 
       # Reduce `app` against the registry.
       #
-      # @param app [Rigor::Type::App]
-      # @param fuel [Integer] reduction-step budget (default 64 per ADR-20 WD3). Each visited
+      # @param fuel — reduction-step budget (default 64 per ADR-20 WD3). Each visited
       #   body node costs one unit. On exhaustion the reduction returns `app.bound`.
-      # @return [Rigor::Type] the reduced type, or `app.bound` when reduction is impossible (URI
+      # @return the reduced type, or `app.bound` when reduction is impossible (URI
       #   not defined, arity mismatch, body_tree absent, fuel exhausted).
       def reduce(app, fuel: DEFAULT_FUEL)
         raise ArgumentError, "expected a Rigor::Type::App, got #{app.class}" unless app.is_a?(Type::App)

data/lib/rigor/inference/hkt_registry.rb

@@ -99,8 +99,6 @@ module Rigor
 
       attr_reader :registrations, :definitions
 
-      # @param registrations [Array<Registration>]
-      # @param definitions [Array<Definition>]
       def initialize(registrations: [], definitions: [])
         @registrations = registrations.to_h { |r| [r.uri, r] }.freeze
         @definitions = definitions.to_h { |d| [d.uri, d] }.freeze
@@ -123,7 +121,7 @@ module Rigor
         @definitions[uri]
       end
 
-      # @return [HktRegistry] a new registry whose entries are the union of this registry's and
+      # @return a new registry whose entries are the union of this registry's and
       #   `other`'s. On URI collisions `other`'s entries win (last-write-wins; OQ3 tentative).
       def merge(other)
         raise ArgumentError, "merge target must be an HktRegistry, got #{other.class}" unless other.is_a?(HktRegistry)
@@ -150,16 +148,18 @@ module Rigor
       # loaded RBS env, parse them via {Rigor::RbsExtended::HktDirectives}, and return a new
       # registry that is the union of `base` and every parsed entry. Last-write-wins on URI
       # collisions per {#merge}'s contract. Fail-soft on per-annotation parse errors (the reporter
-      # records an `:info` entry; the other annotations still apply).
+      # records an entry the run surfaces as one `dynamic.rbs-extended.hkt-directive-invalid` `:info`
+      # diagnostic; the other annotations still apply). That claim was false until issue #785: the
+      # production reporter has no `#record`, so every declined directive was dropped silently.
       #
-      # @param rbs_loader [Rigor::Environment::RbsLoader]
-      # @param base [HktRegistry] starting registry (typically the bundled
+      # @param base — starting registry (typically the bundled
       #   `Rigor::Builtins::HktBuiltins.registry`).
-      # @param name_scope [Rigor::Environment::NameScope, nil] threaded through to the bound
+      # @param name_scope — threaded through to the bound
       #   resolver for class-name lookups; safe to omit during scanning since hkt bounds are
       #   typically `untyped` or stdlib classes.
-      # @param reporter [#record, nil] same fail-soft reporter contract the other RBS-extended
-      #   parsers use.
+      # @param reporter — same fail-soft reporter contract
+      #   the other RBS-extended parsers use; a collecting double that responds only to `#record` /
+      #   `#<<` still works (see {Rigor::RbsExtended::HktDirectives.record_hkt_error}).
 
       # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/BlockLength
       def self.scan_rbs_loader(rbs_loader, base: EMPTY, name_scope: nil, reporter: nil)
@@ -198,7 +198,16 @@ module Rigor
             params = decl.type_params.map(&:name)
             params_set = params.to_set
 
-            translator = HktSugarTranslator.new(uri: uri, params_set: params_set, name_scope: name_scope)
+            # No rescue around this translate. HktSugarTranslator degrades every alias shape it
+            # cannot model (a non-recursive alias, a malformed self-reference) to a leaf, so a
+            # parseable `type` alias never raises here — that is the fix for issue #776, where an
+            # unknown keyword aborted this shared, memoised build and turned every file into an
+            # `internal analyzer error`. An exception that still reaches this point is an analyzer
+            # bug and MUST propagate rather than silently dropping the alias, matching
+            # RbsLoader#each_known_class_name's fail-soft contract. It propagates to the seam in
+            # `Environment#hkt_registry` (issue #784), which records it and degrades to the pre-scan
+            # registry so it surfaces once per run instead of reaching every file's analysis.
+            translator = HktSugarTranslator.new(uri: uri, params_set: params_set)
             body_tree = translator.translate(decl.type)
 
             next unless translator.recursive

data/lib/rigor/inference/hkt_sugar_translator.rb

@@ -6,39 +6,28 @@ require_relative "hkt_body"
 module Rigor
   module Inference
     class HktSugarTranslator
-      class << self
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
-        def translate(rbs_type, uri:, params_set:, name_scope:)
-          new(uri: uri, params_set: params_set, name_scope: name_scope).translate(rbs_type)
-        end
-      end
-
       attr_reader :recursive
 
-      def initialize(uri:, params_set:, name_scope:)
+      def initialize(uri:, params_set:)
         @uri = uri
         @params_set = params_set
-        @name_scope = name_scope
         @recursive = false
       end
 
+      # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
       def translate(type)
         case type
         when RBS::Types::Alias
-          if type.name.to_s.sub(/\A::/, "") == @uri.to_s
+          if type.name.to_s.sub(/\A::/, "") == @uri.to_s && !type.args.empty?
             @recursive = true
             args = type.args.map { |a| translate(a) }
             HktBody::AppRef.new(uri: @uri, args: args)
           else
-            # Re-wrap other aliases as NominalApp or TypeLeaf?
-            # Actually, we can just translate them to TypeLeaf if they have no args,
-            # but Rigor handles aliases via RbsLoader.
-            # If we don't expand them here, they will just be RbsTypeTranslator.translate'd later?
-            # Wait, HktBody doesn't have an AliasRef node. HktBody uses NominalApp for things with args,
-            # or TypeLeaf for concrete Rigor::Type.
-
-            # Since Rigor doesn't support generic aliases outside of HKT AppRef,
-            # we can just translate to TypeLeaf.
+            # Everything else degrades to a concrete leaf: HktBody has no AliasRef node and Rigor
+            # resolves non-HKT aliases through RbsLoader. A bare self-reference with no type
+            # arguments (`type Foo::x[T] = ... | Foo::x`) lands here too — it is malformed for a
+            # parameterized alias (`rbs validate` rejects it), so it must not build an empty-args
+            # `AppRef`, which `HktBody` rejects.
             fallback_to_type_leaf(type)
           end
         when RBS::Types::ClassInstance
@@ -72,17 +61,22 @@ module Rigor
           fallback_to_type_leaf(type)
         end
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
       private
 
+      # The `else` arm and the unbound-variable / non-recursive-alias arms all degrade a subterm the
+      # HKT body grammar has no node for to a concrete `Rigor::Type` leaf. `RbsTypeTranslator` has no
+      # name-scope parameter — it never resolves relative names — and the alias decls this walk reads
+      # come off a `resolve_type_names`-d environment, so names arrive already absolute and there is
+      # nothing a scope would do here. `alias_expander: nil` is deliberate too: a nested alias reached
+      # in this fallback degrades to `Dynamic[Top]` rather than pulling a second alias body into an
+      # HKT definition.
       def fallback_to_type_leaf(type)
         require_relative "rbs_type_translator" unless defined?(RbsTypeTranslator)
         rigor_type = RbsTypeTranslator.translate(
           type,
           alias_expander: nil,
           type_vars: {},
-          name_scope: @name_scope,
           self_type: Rigor::Type::Combinator.untyped,
           instance_type: Rigor::Type::Combinator.untyped
         )

data/lib/rigor/inference/index_write_widening.rb

@@ -27,7 +27,6 @@ module Rigor
 
       module_function
 
-      # @param node [Prism::Node]
       def index_write?(node)
         NODE_CLASSES.any? { |klass| node.is_a?(klass) }
       end
@@ -36,10 +35,7 @@ module Rigor
       # the widening joins the stored value into the carrier's content evidence exactly as a real `[]=` does
       # (issue #560). Empty means "no evidence" and widens without joining.
       #
-      # @param node          [Prism::Node] one of {NODE_CLASSES}
-      # @param current_scope [Rigor::Scope]
-      # @param arg_types     [Array<Rigor::Type::Base>]
-      # @return              [Rigor::Scope]
+      # @param node — one of {NODE_CLASSES}
       def widen(node:, current_scope:, arg_types: MutationWidening::NO_ARG_TYPES)
         MutationWidening.widen_receiver_aliases(node.receiver, MUTATOR, current_scope, arg_types: arg_types)
       end

data/lib/rigor/inference/macro_block_self_type.rb

@@ -28,10 +28,7 @@ module Rigor
     module MacroBlockSelfType
       module_function
 
-      # @param scope         [Rigor::Scope]
-      # @param call_node     [Prism::CallNode]
-      # @param receiver_type [Rigor::Type, nil]
-      # @return [Rigor::Type, nil] the narrowed self-type, or
+      # @return the narrowed self-type, or
       #   `nil` when no registered entry matches the call shape.
       def narrow_self_type_for(scope:, call_node:, receiver_type:)
         return nil if receiver_type.nil?

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

@@ -46,13 +46,8 @@ module Rigor
         # a finitely-sized receiver it is `Constant[size]`.
         COUNT_METHOD = :count
 
-        # @param receiver    [Rigor::Type, nil]
-        # @param method_name [Symbol]
-        # @param args        [Array<Rigor::Type>]
-        # @param block_type  [Rigor::Type, nil] inferred return type of
-        #   the call's block. `nil` means "no block at the call site"
-        #   and disqualifies every rule here.
-        # @return [Rigor::Type, nil]
+        # `context.block_type` is the inferred return type of the call's block; `nil` means "no block at the
+        # call site" and disqualifies every rule here.
         def try_dispatch(context)
           receiver = context.receiver
           method_name = context.method_name
@@ -135,7 +130,6 @@ module Rigor
           end
         end
 
-        # @return [:always_true, :always_false, :bool, nil]
         # rubocop:disable-next Metrics/CyclomaticComplexity
         def predicate_decision(method_name, truthiness, emptiness)
           case method_name
@@ -167,7 +161,6 @@ module Rigor
           )
         end
 
-        # @return [:empty, :non_empty, :unknown]
         def receiver_emptiness(receiver)
           case receiver
           when Type::Tuple

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

@@ -55,7 +55,7 @@ module Rigor
 
         module_function
 
-        # @return [Rigor::Type, nil] folded result, or nil to defer.
+        # @return folded result, or nil to defer.
         def try_dispatch(context)
           receiver = context.receiver
           method_name = context.method_name