rigortype 0.4.6 → 0.4.8

data/plugins/rigor-sorbet/lib/rigor/plugin/sorbet/catalog.rb

@@ -15,11 +15,32 @@ module Rigor
         # Hash on every `mixins_for` query.
         EMPTY_MIXINS = { include: [].freeze, extend: [].freeze }.freeze
 
+        # Issue #2541 — the sorbet-runtime struct roots whose `prop` / `const` calls define accessors
+        # (`T::Props::ClassMethods#prop` → `T::Props::Decorator#add_prop_definition` defines the reader,
+        # and the writer for `prop` only; `const` is `prop(..., immutable: true)`). `T::ImmutableStruct`
+        # overrides `prop` to raise, so a writer is never answered under it.
+        STRUCT_ROOTS = %w[T::Struct T::InexactStruct T::ImmutableStruct].freeze
+        IMMUTABLE_STRUCT_ROOT = "T::ImmutableStruct"
+
         def initialize
           @entries = {}
           # ADR-11 slice 8 — per-class mixin declarations collected by `CatalogWalker`. Lookup-time chain
           # traversal lifts sigs declared on a mixed-in module to call sites on the host class.
           @mixins = {}
+          # Issue #2541 — `prop` / `const` accessors recorded per declaring class, the lexical superclass of
+          # every `class X < Y` the walker saw, and the instance methods each class body `def`s itself. A
+          # struct accessor answers only when the declaring class reaches a {STRUCT_ROOTS} root through
+          # `@superclasses`, and a class's own `def` of the same name shadows it (Ruby: the later `def`
+          # replaces the generated accessor; a subclass `def` overrides it).
+          @struct_props = {}
+          @struct_prop_types = {}
+          @struct_nesting = {}
+          @namespaces = {}
+          @constants = {}
+          @struct_includes = {}
+          @mixes_in = {}
+          @superclasses = {}
+          @defined_methods = {}
           @frozen_after_build = false
         end
 
@@ -42,8 +63,153 @@ module Rigor
           list << module_name unless list.include?(module_name)
         end
 
+        # @param signature — a {MethodSignature} for a `prop` / `const` reader or a `prop` writer.
+        # @param certain — false for a call nested under a conditional or a block, which never displaces
+        #   an accessor already recorded for the name; a certain one replaces whatever is there.
+        # @param type_source — the source text of the macro's type argument, re-translated at lookup with
+        #   its constants resolved against `nesting` ({#struct_prop_type}); nil when the accessor is untyped.
+        # @param nesting — the declaring class's lexical nesting, outermost first, its own name last.
+        def record_struct_prop(signature, certain: true, type_source: nil, nesting: [])
+          raise "Catalog already finalised" if @frozen_after_build
+
+          props = (@struct_props[signature.class_name] ||= {})
+          return unless certain || !props.key?(signature.method_name)
+
+          props[signature.method_name] = signature
+          @struct_prop_types[[signature.class_name, signature.method_name]] = type_source
+          @struct_nesting[signature.class_name] ||= nesting.dup.freeze
+        end
+
+        # Issue #2541 — every class and module name the walk declared, so a struct accessor's relative
+        # constant resolves to a project class the RBS environment may not know.
+        def record_namespace(name)
+          raise "Catalog already finalised" if @frozen_after_build
+
+          @namespaces[name] = true
+        end
+
+        def namespace?(name)
+          @namespaces.key?(name)
+        end
+
+        # A constant the walk saw assigned (`Thing = Other`) rather than declared as a class or module.
+        def record_constant(name)
+          raise "Catalog already finalised" if @frozen_after_build
+
+          @constants[name] = true
+        end
+
+        def constant?(name)
+          @constants.key?(name)
+        end
+
+        def record_struct_include(class_name, module_name)
+          raise "Catalog already finalised" if @frozen_after_build
+
+          list = (@struct_includes[class_name] ||= [])
+          list << module_name unless list.include?(module_name)
+        end
+
+        def record_mixes_in(class_name)
+          raise "Catalog already finalised" if @frozen_after_build
+
+          @mixes_in[class_name] = true
+        end
+
+        # Issue #2541 — whether any class on `class_name`'s walked superclass chain, itself included,
+        # `include`s or `prepend`s a module.
+        def mixes_in_ancestry?(class_name)
+          chain = []
+          current = class_name.to_s.delete_prefix("::")
+          until current.nil? || chain.include?(current) || STRUCT_ROOTS.include?(current)
+            return true if @mixes_in.key?(current)
+
+            chain << current
+            current = resolve_superclass(current)
+          end
+          false
+        end
+
+        # Every walked class and module name and every assigned constant name, for the plugin's check that
+        # no other `*::<name>` could shadow a top-level constant.
+        def declared_constant_names
+          @namespaces.keys + @constants.keys
+        end
+
+        # Issue #2541 — the classes whose constants a struct body's relative constant could reach through
+        # ancestry: the class itself, its walked superclasses below the struct root, and the modules each of
+        # them `include`s (as written).
+        def constant_ancestry(class_name)
+          chain = []
+          current = class_name.to_s.delete_prefix("::")
+          until current.nil? || chain.include?(current) || STRUCT_ROOTS.include?(current)
+            chain << current
+            current = resolve_superclass(current)
+          end
+          chain + chain.flat_map { |name| @struct_includes.fetch(name, []).map { |mod| mod.delete_prefix("::") } }
+        end
+
+        # @return the type source and the nesting for the accessor `signature` names, or nil when it has no type
+        #   source (a conditional or type-less macro).
+        def struct_prop_type(signature)
+          source = @struct_prop_types[[signature.class_name, signature.method_name]]
+          return nil if source.nil?
+
+          [source, @struct_nesting.fetch(signature.class_name, [])]
+        end
+
+        # @param written — the superclass expression as written (`"T::Struct"`, `"Base"`, `"::Foo::Base"`).
+        # @param lexical_prefix — the enclosing namespace names, outermost first, that Ruby resolves a
+        #   relative `written` against.
+        def record_superclass(class_name:, written:, lexical_prefix:)
+          raise "Catalog already finalised" if @frozen_after_build
+
+          @superclasses[class_name] ||= [written, lexical_prefix.dup.freeze].freeze
+        end
+
+        def record_defined_method(class_name:, method_name:)
+          raise "Catalog already finalised" if @frozen_after_build
+
+          list = (@defined_methods[class_name] ||= [])
+          list << method_name unless list.include?(method_name)
+        end
+
+        # Issue #2541 — the signature a `prop` / `const` accessor contributes to `class_name#method_name`,
+        # walking the lexical superclass chain the way Ruby's method lookup does. A class on the way that
+        # `def`s the name itself (or declares it with `attr_*`) stops the walk with nil, leaving the user's
+        # method to the sig lookup and the engine's own tiers. Returns nil unless the declaring class descends from a {STRUCT_ROOTS} root, so a
+        # project DSL that happens to be named `prop` is never read as Sorbet's.
+        def lookup_struct_prop(class_name:, method_name:)
+          return nil if @struct_props.empty?
+
+          current = class_name.to_s.delete_prefix("::")
+          visited = []
+          while current && !visited.include?(current)
+            visited << current
+            return nil if @defined_methods[current]&.include?(method_name)
+
+            signature = @struct_props.dig(current, method_name)
+            return struct_answer(signature, current) if signature
+
+            current = resolve_superclass(current)
+          end
+          nil
+        end
+
         def freeze!
           @frozen_after_build = true
+          @struct_props.each_value(&:freeze)
+          @struct_props.freeze
+          @struct_prop_types.freeze
+          @struct_nesting.freeze
+          @namespaces.freeze
+          @constants.freeze
+          @struct_includes.each_value(&:freeze)
+          @struct_includes.freeze
+          @mixes_in.freeze
+          @superclasses.freeze
+          @defined_methods.each_value(&:freeze)
+          @defined_methods.freeze
           @entries.freeze
           @mixins.each_value do |bucket|
             bucket.each_value(&:freeze)
@@ -57,14 +223,14 @@ module Rigor
           @entries[key_for(class_name, method_name, kind)]
         end
 
-        # @return frozen mapping `{ include: [...], extend: [...] }`.
+        # @return frozen `:include` / `:extend` buckets of mixed-in module names.
         #   Returns {EMPTY_MIXINS} when no mixins were recorded.
         def mixins_for(class_name)
           @mixins[class_name] || EMPTY_MIXINS
         end
 
         def empty?
-          @entries.empty?
+          @entries.empty? && @struct_props.empty?
         end
 
         # ADR-52 slice 4 — the distinct method names the catalog carries at least one signature for,
@@ -74,7 +240,9 @@ module Rigor
         # Computed fresh per call — the plugin memoises the resolved set, and `freeze!` freezes the
         # catalog itself so a lazy memo ivar here would raise.
         def method_names
-          @entries.keys.map { |key| key[1] }.uniq
+          names = @entries.keys.map { |key| key[1] }
+          @struct_props.each_value { |props| names.concat(props.keys) }
+          names.uniq
         end
 
         def size
@@ -83,6 +251,45 @@ module Rigor
 
         private
 
+        def struct_answer(signature, declaring_class)
+          root = struct_root(declaring_class)
+          return nil if root.nil?
+          return nil if root == IMMUTABLE_STRUCT_ROOT && signature.method_name.end_with?("=")
+
+          signature
+        end
+
+        def struct_root(class_name)
+          current = class_name
+          visited = []
+          while current && !visited.include?(current)
+            return current if STRUCT_ROOTS.include?(current)
+
+            visited << current
+            current = resolve_superclass(current)
+          end
+          nil
+        end
+
+        # Resolves the superclass expression recorded for `class_name` the way Ruby's lexical constant lookup
+        # would, as far as the walked sources can tell: a rooted `::Foo` is absolute; a relative `Foo` is tried
+        # under each enclosing namespace, innermost first, against the classes the walk saw, then as written.
+        def resolve_superclass(class_name)
+          written, prefix = @superclasses[class_name]
+          return nil if written.nil?
+          return written.delete_prefix("::") if written.start_with?("::")
+
+          prefix.size.downto(1) do |depth|
+            candidate = "#{prefix.first(depth).join('::')}::#{written}"
+            return candidate if known_class?(candidate)
+          end
+          written
+        end
+
+        def known_class?(name)
+          @superclasses.key?(name) || @struct_props.key?(name)
+        end
+
         def key_for(class_name, method_name, kind)
           [class_name.to_s, method_name.to_sym, kind]
         end

data/plugins/rigor-sorbet/lib/rigor/plugin/sorbet/catalog_walker.rb

@@ -29,16 +29,20 @@ module Rigor
         # @param root — the file's program node.
         # @param catalog — mutable; signatures are recorded into it.
         # @param path — file path used for diagnostic provenance.
+        # @param struct_catalog — where the `T::Struct`-family accessors, superclasses, and own `def`s are
+        #   recorded (issue #2541). Defaults to `catalog`; the plugin passes the per-run catalog here even
+        #   when `catalog` is the discard catalog of an unenforced-sigil file, because sorbet-runtime defines
+        #   a struct's accessors whatever the file's `# typed:` level.
         # @return errors observed during the walk; empty when the file is sig-clean.
-        def walk(root:, catalog:, path:)
-          state = State.new(catalog: catalog, path: path)
+        def walk(root:, catalog:, path:, struct_catalog: catalog)
+          state = State.new(catalog: catalog, path: path, struct_catalog: struct_catalog)
           walk_node(root, state, lexical_path: [], in_singleton_class: false)
           state.errors
         end
 
-        State = Struct.new(:catalog, :path, :errors, keyword_init: true) do
-          def initialize(catalog:, path:)
-            super(catalog: catalog, path: path, errors: [])
+        State = Struct.new(:catalog, :path, :errors, :struct_catalog, keyword_init: true) do
+          def initialize(catalog:, path:, struct_catalog: catalog)
+            super(catalog: catalog, path: path, errors: [], struct_catalog: struct_catalog)
           end
 
           def record_error(kind, node)
@@ -50,7 +54,9 @@ module Rigor
           return unless node.is_a?(Prism::Node)
 
           case node
-          when Prism::ClassNode, Prism::ModuleNode
+          when Prism::ClassNode
+            descend_class(node, state, lexical_path)
+          when Prism::ModuleNode
             descend_class_or_module(node, state, lexical_path)
           when Prism::SingletonClassNode
             descend_singleton_class(node, state, lexical_path)
@@ -59,6 +65,20 @@ module Rigor
           when Prism::DefNode
             # A `def` not preceded by a `sig` is fine; we just don't record anything for it. The
             # interesting case is in `walk_statements`, which pairs sig+def.
+          when Prism::CallNode
+            # Issue #2541 — any `include` / `prepend` in a class (whatever its arguments) opens the class's
+            # ancestry, so a struct accessor's constant is no longer answered from the top level.
+            if node.receiver.nil? && %i[include prepend].include?(node.name) && !lexical_path.empty?
+              state.struct_catalog.record_mixes_in(lexical_path.join("::"))
+            end
+            node.rigor_each_child do |child|
+              walk_node(child, state, lexical_path: lexical_path, in_singleton_class: in_singleton_class)
+            end
+          when Prism::ConstantWriteNode
+            # Issue #2541 — `Thing = Other` makes `Thing` a constant that is not a class declaration, so a
+            # struct accessor's type naming it is not read as any class.
+            state.struct_catalog.record_constant((lexical_path + [node.name.to_s]).join("::"))
+            walk_node(node.value, state, lexical_path: lexical_path, in_singleton_class: in_singleton_class)
           else
             node.rigor_each_child do |child|
               walk_node(child, state, lexical_path: lexical_path, in_singleton_class: in_singleton_class)
@@ -66,8 +86,25 @@ module Rigor
           end
         end
 
+        # Issue #2541 — a `class` records its superclass, and only its body's own top-level statements,
+        # which certainly run at class definition, may declare `prop` / `const` accessors.
+        def descend_class(node, state, lexical_path)
+          name = qualified_name_for(node.constant_path)
+          return descend_class_or_module(node, state, lexical_path) unless name
+
+          record_superclass(node, name, state, lexical_path)
+          state.struct_catalog.record_namespace((lexical_path + [name]).join("::"))
+          if node.body.is_a?(Prism::StatementsNode)
+            walk_statements(node.body, state, lexical_path: lexical_path + [name], in_singleton_class: false,
+                                              class_body: true)
+          else
+            descend_class_or_module(node, state, lexical_path)
+          end
+        end
+
         def descend_class_or_module(node, state, lexical_path)
           name = qualified_name_for(node.constant_path)
+          state.struct_catalog.record_namespace((lexical_path + [name]).join("::")) if name
           if name && node.body
             child_prefix = lexical_path + [name]
             walk_node(node.body, state, lexical_path: child_prefix, in_singleton_class: false)
@@ -88,10 +125,13 @@ module Rigor
         # `sig` call, it remembers it and consumes the very next `def` / `def self.foo` as the target.
         # Anything between a sig and its def (a comment is fine — comments aren't AST nodes — but a
         # method call would be a problem) leaves the sig dangling.
-        def walk_statements(statements, state, lexical_path:, in_singleton_class:)
+        def walk_statements(statements, state, lexical_path:, in_singleton_class:, class_body: false)
           pending_sig = nil
 
           statements.body.each do |child|
+            record_defined_method(child, state, lexical_path) unless in_singleton_class
+            record_struct_prop_call(child, state, lexical_path, certain: class_body) unless in_singleton_class
+
             if pending_sig && def_node?(child)
               record_def_with_sig(child, pending_sig, state, lexical_path, in_singleton_class)
               pending_sig = nil
@@ -153,9 +193,108 @@ module Rigor
             state.catalog.record_mixin(
               class_name: class_name, kind: kind, module_name: module_name
             )
+            # Issue #2541 — an included module's constants shadow a top-level one for the class body.
+            state.struct_catalog.record_struct_include(class_name, module_name) if kind == :include
+          end
+        end
+
+        # Issue #2541 — `class X < Y`: the superclass as written plus the enclosing namespaces, so the
+        # catalog can follow `X`'s chain to a `T::Struct`-family root. `lexical_path` holds the enclosing
+        # names (a nested `class A::B` element counts as one namespace step, as Ruby's cref does).
+        def record_superclass(node, name, state, lexical_path)
+          written = qualified_name_for(node.superclass)
+          return if written.nil?
+
+          state.struct_catalog.record_superclass(
+            class_name: (lexical_path + [name]).join("::"), written: written, lexical_prefix: lexical_path
+          )
+        end
+
+        # The instance methods a class body defines itself — `def foo`, `private def foo`, `attr_reader :foo` /
+        # `attr_writer` / `attr_accessor` — so a struct accessor of the same name yields to them.
+        def record_defined_method(node, state, lexical_path)
+          return if lexical_path.empty?
+
+          class_name = lexical_path.join("::")
+          defined_method_names(node).each do |method_name|
+            state.struct_catalog.record_defined_method(class_name: class_name, method_name: method_name)
+          end
+        end
+
+        def defined_method_names(node)
+          target = visibility_wrapped_def(node) || node
+          if def_node?(target)
+            target.receiver.nil? ? [target.name] : []
+          elsif attr_macro_call?(target)
+            attr_method_names(target)
+          else
+            []
           end
         end
 
+        def attr_method_names(attr_node)
+          attr_node.arguments.arguments.flat_map do |arg|
+            name = arg.unescaped
+            case attr_node.name
+            when :attr_reader then [name.to_sym]
+            when :attr_writer then [:"#{name}="]
+            else [name.to_sym, :"#{name}="]
+            end
+          end
+        end
+
+        STRUCT_PROP_MACROS = %i[prop const].freeze
+
+        # Issue #2541 — `prop :name, Type, **rules` / `const :name, Type, **rules` in a class body. Records
+        # the reader (both macros) and the writer (`prop` only); the catalog decides at lookup whether the
+        # class is a `T::Struct`-family class at all. At the body's top level (`certain:`) the accessor is
+        # typed by the translated `Type`. Nested under an `if`, a `begin`, or a block in the body, the call
+        # may not run, so the accessor is recorded as possible: typed `Dynamic[top]`, which keeps a call
+        # to it quiet without claiming its type. A name that is not a literal Symbol records nothing
+        # (`T::Props` takes a Symbol).
+        def record_struct_prop_call(node, state, lexical_path, certain:)
+          return if lexical_path.empty?
+          return unless node.is_a?(Prism::CallNode) && node.receiver.nil?
+          return unless STRUCT_PROP_MACROS.include?(node.name)
+
+          args = node.arguments&.arguments
+          return if args.nil? || args.empty?
+
+          return unless args.first.is_a?(Prism::SymbolNode)
+
+          name = args.first.unescaped
+
+          type_node = args[1] unless args[1].is_a?(Prism::KeywordHashNode)
+          # The constants in the type resolve at lookup, against the classes every file declares, so only
+          # the source text is kept; the signature's own type is the placeholder until then.
+          type_source = type_node&.slice if certain
+          class_name = lexical_path.join("::")
+          record_struct_accessor(state, class_name, name.to_sym, type_source, lexical_path, certain)
+          return unless node.name == :prop && !immutable_rule?(args)
+
+          record_struct_accessor(state, class_name, :"#{name}=", type_source, lexical_path, certain)
+        end
+
+        # `prop :x, T, immutable: true` is the long form of `const`: no writer.
+        def immutable_rule?(args)
+          args.any? do |arg|
+            arg.is_a?(Prism::KeywordHashNode) && arg.elements.any? do |element|
+              element.is_a?(Prism::AssocNode) && element.key.is_a?(Prism::SymbolNode) &&
+                element.key.unescaped == "immutable" && element.value.is_a?(Prism::TrueNode)
+            end
+          end
+        end
+
+        def record_struct_accessor(state, class_name, method_name, type_source, nesting, certain)
+          state.struct_catalog.record_struct_prop(
+            MethodSignature.new(
+              class_name: class_name, method_name: method_name, kind: :instance,
+              params: {}, return_type: Rigor::Type::Combinator.untyped, modifiers: []
+            ),
+            certain: certain, type_source: type_source, nesting: nesting
+          )
+        end
+
         def sig_call?(node)
           node.is_a?(Prism::CallNode) &&
             node.name == :sig &&

data/plugins/rigor-sorbet/lib/rigor/plugin/sorbet/sig_parser.rb

@@ -22,8 +22,8 @@ module Rigor
       #
       # The parser walks the chain right-to-left, gathering whatever it recognises (`params` / `returns` /
       # `void` / `abstract` / `override` / `overridable` / `final` / `type_parameters` / `checked` /
-      # `on_failure`) into a frozen result hash stored in {MethodSignature}. Modifiers and
-      # `type_parameters` are recorded but not yet acted on.
+      # `on_failure`) into a frozen result hash stored in {MethodSignature}. Modifiers are recorded but not
+      # yet acted on; `type_parameters` is recognised and its payload discarded.
       #
       # The parser is intentionally tolerant — unknown chain nodes degrade to "the rest of the chain is
       # opaque" rather than raising. The plugin emits a diagnostic (`plugin.sorbet.parse-error`) only when

data/plugins/rigor-sorbet/lib/rigor/plugin/sorbet/type_translator.rb

@@ -52,28 +52,33 @@ module Rigor
 
         module_function
 
+        # @param resolve — optional callable mapping an unrooted constant name as written (`"Thing"`,
+        #   `"Foo::Bar"`) to the class it names, or to nil when that is not certain, in which case the
+        #   constant degrades to `Dynamic[top]`. Issue #2541 passes it for `T::Struct` accessor types; without
+        #   it (every sig) a constant becomes `Nominal[<as written>]`, as before. The `T::` vocabulary is
+        #   never handed to it.
         # @return never `nil`; unrecognised forms degrade to `Type::Combinator.untyped`.
-        def translate(node)
+        def translate(node, resolve = nil)
           return Rigor::Type::Combinator.untyped if node.nil?
 
           case node
-          when Prism::ConstantReadNode then translate_constant_read(node)
-          when Prism::ConstantPathNode then translate_constant_path(node)
-          when Prism::CallNode then translate_call(node)
-          when Prism::ArrayNode then translate_tuple(node)
-          when Prism::HashNode then translate_shape(node)
+          when Prism::ConstantReadNode then translate_constant_read(node, resolve)
+          when Prism::ConstantPathNode then translate_constant_path(node, resolve)
+          when Prism::CallNode then translate_call(node, resolve)
+          when Prism::ArrayNode then translate_tuple(node, resolve)
+          when Prism::HashNode then translate_shape(node, resolve)
           else degraded
           end
         end
 
-        def translate_constant_read(node)
-          name = node.name.to_s
-          return Rigor::Type::Combinator.untyped if name.empty?
+        def translate_constant_read(node, resolve = nil)
+          name = resolved_name(node.name.to_s, resolve)
+          return Rigor::Type::Combinator.untyped if name.nil? || name.empty?
 
           Rigor::Type::Combinator.nominal_of(name)
         end
 
-        def translate_constant_path(node)
+        def translate_constant_path(node, resolve = nil)
           name = constant_path_name(node)
           return degraded if name.nil?
 
@@ -81,9 +86,20 @@ module Rigor
           # type alias.
           return boolean_type if name == "T::Boolean"
 
+          name = resolved_name(name, resolve)
+          return degraded if name.nil?
+
           Rigor::Type::Combinator.nominal_of(name)
         end
 
+        # The constant `name` as `resolve` reads it (a rooted `::Foo` included); `name` itself when there is
+        # no resolver.
+        def resolved_name(name, resolve)
+          return name if resolve.nil?
+
+          resolve.call(name)
+        end
+
         # `Prism::CallNode` covers three distinct surfaces:
         #
         # 1. `T.something(...)` — `untyped` / `anything` / `noreturn` / `nilable` / `any` / `all` /
@@ -96,58 +112,59 @@ module Rigor
         #    instantiation intact (the unwrap-site receiver a plugin like rigor-mangrove reads `type_args`
         #    from). Without this branch such forms degraded to `untyped`, silently dropping the
         #    receiver's generic arguments.
-        def translate_call(node)
-          return translate_t_method(node) if sorbet_t_namespaced?(node.receiver)
-          return translate_t_subscript(node) if sorbet_subscript?(node)
-          return translate_user_subscript(node) if user_generic_subscript?(node)
+        def translate_call(node, resolve = nil)
+          return translate_t_method(node, resolve) if sorbet_t_namespaced?(node.receiver)
+          return translate_t_subscript(node, resolve) if sorbet_subscript?(node)
+          return translate_user_subscript(node, resolve) if user_generic_subscript?(node)
 
           degraded
         end
 
         # Handles the `T.foo(...)` family.
-        def translate_t_method(node)
+        def translate_t_method(node, resolve = nil)
           case node.name
           when :untyped then Rigor::Type::Combinator.untyped
           when :anything then Rigor::Type::Combinator.top
           when :noreturn then Rigor::Type::Combinator.bot
-          when :nilable then translate_nilable(node)
-          when :any then translate_any(node)
-          when :all then translate_all(node)
-          when :class_of then translate_class_of(node)
+          when :nilable then translate_nilable(node, resolve)
+          when :any then translate_any(node, resolve)
+          when :all then translate_all(node, resolve)
+          when :class_of then translate_class_of(node, resolve)
           else degraded
           end
         end
 
-        def translate_nilable(node)
+        def translate_nilable(node, resolve = nil)
           inner = first_argument(node)
           return degraded if inner.nil?
 
           Rigor::Type::Combinator.union(
-            translate(inner), Rigor::Type::Combinator.constant_of(nil)
+            translate(inner, resolve), Rigor::Type::Combinator.constant_of(nil)
           )
         end
 
-        def translate_any(node)
+        def translate_any(node, resolve = nil)
           args = call_arguments(node)
           return degraded if args.empty?
 
-          Rigor::Type::Combinator.union(*args.map { |arg| translate(arg) })
+          Rigor::Type::Combinator.union(*args.map { |arg| translate(arg, resolve) })
         end
 
-        def translate_all(node)
+        def translate_all(node, resolve = nil)
           args = call_arguments(node)
           return degraded if args.empty?
 
-          Rigor::Type::Combinator.intersection(*args.map { |arg| translate(arg) })
+          Rigor::Type::Combinator.intersection(*args.map { |arg| translate(arg, resolve) })
         end
 
         # `T.class_of(C)` — singleton-class type for a single constant. Sorbet docs note
         # `T.class_of(MyInterface)` rarely means what users expect (it's the singleton class of
         # `MyInterface`, not "any class implementing the interface"); we honour the literal meaning here
         # and translate to `Singleton[C]`.
-        def translate_class_of(node)
+        def translate_class_of(node, resolve = nil)
           target = first_argument(node)
           name = constant_path_name(target)
+          name = resolved_name(name, resolve) unless name.nil?
           return degraded if name.nil?
 
           Rigor::Type::Combinator.singleton_of(name)
@@ -157,9 +174,9 @@ module Rigor
         # `CallNode` whose receiver is the `T::Array` `ConstantPathNode` and whose `name` is `:[]`.
         # `T::Class[T]` lands here too; we collapse it to `Singleton[name]` (a deliberate narrowing —
         # `T::Class` is structurally generic in Sorbet, but Rigor's `Singleton` carries class identity only).
-        def translate_t_subscript(node)
+        def translate_t_subscript(node, resolve = nil)
           base_name = sorbet_subscript_base(node.receiver)
-          args = call_arguments(node).map { |arg| translate(arg) }
+          args = call_arguments(node).map { |arg| translate(arg, resolve) }
           mapped = T_GENERIC_CLASSES[base_name]
 
           if mapped
@@ -188,13 +205,14 @@ module Rigor
           !sorbet_t_qualified?(receiver)
         end
 
-        def translate_user_subscript(node)
+        def translate_user_subscript(node, resolve = nil)
           # Parity with translate_constant_path: the constant's rendered name (carrying a leading `::` for
           # absolute paths) becomes the nominal class name.
           name = constant_path_name(node.receiver)
+          name = resolved_name(name, resolve) unless name.nil?
           return degraded if name.nil?
 
-          args = call_arguments(node).map { |arg| translate(arg) }
+          args = call_arguments(node).map { |arg| translate(arg, resolve) }
           Rigor::Type::Combinator.nominal_of(name, type_args: args)
         end
 
@@ -214,21 +232,21 @@ module Rigor
 
         # Tuple types in `sig` position appear as bare array literals: `sig { returns([String, Integer]) }`.
         # Each element is itself a type expression we translate recursively.
-        def translate_tuple(node)
-          elements = node.elements.map { |element| translate(element) }
+        def translate_tuple(node, resolve = nil)
+          elements = node.elements.map { |element| translate(element, resolve) }
           Rigor::Type::Combinator.tuple_of(*elements)
         end
 
         # Shape types in `sig` position appear as bare hash literals with symbol keys:
         # `sig { returns({a: Integer, b: String}) }`. Each value is a type expression; the resulting
         # `HashShape` is closed (no extra keys allowed).
-        def translate_shape(node)
+        def translate_shape(node, resolve = nil)
           pairs = []
           node.elements.each do |element|
             next unless element.is_a?(Prism::AssocNode)
             next unless element.key.is_a?(Prism::SymbolNode)
 
-            pairs << [element.key.unescaped.to_sym, translate(element.value)]
+            pairs << [element.key.unescaped.to_sym, translate(element.value, resolve)]
           end
           # `.to_h`: `hash_shape_of` validates its argument is a Hash and raises `ArgumentError` on the
           # array-of-pairs form, so `sig { returns({name: String}) }` degraded to `Dynamic[top]` through