rigortype 0.1.19 → 0.2.0

data/lib/rigor/inference/scope_indexer.rb

@@ -4,9 +4,11 @@ require "prism"
 
 require_relative "../scope"
 require_relative "../type"
+require_relative "../source/constant_path"
 require_relative "mutation_widening"
 require_relative "narrowing"
 require_relative "statement_evaluator"
+require_relative "struct_fold_safety"
 
 module Rigor
   module Inference
@@ -114,12 +116,8 @@ module Rigor
         # recognised `define_method` calls and records the
         # introduced method names. `rigor check` consults the
         # table to suppress false positives for methods the
-        # user has defined but no RBS sig describes.
-        # Merged UNDER any cross-file pre-pass seed (like the def-node
-        # / include tables below) so a method `def`/`attr_reader`-
-        # declared in one file suppresses a false `undefined-method`
-        # for a call in another — `rigor check` seeds the project-wide
-        # table via `Runner#seed_project_scope`.
+        # user has defined but no RBS sig describes. Merged
+        # UNDER the cross-file pre-pass seed; details: merge_project_method_indexes.
         discovered_methods = deep_merge_class_methods(
           default_scope.discovered_methods, build_discovered_methods(root)
         )
@@ -150,6 +148,10 @@ module Rigor
         # `table[node]` to type predicates; the second pass's
         # entry is the one that reflects all flow-derived
         # rebinds, so it MUST overwrite the first.
+        # ADR-48 Struct slice 3 — install the top-level fold-safe-local set so
+        # a member read off a mutation-free top-level struct binding folds.
+        seeded_scope = seed_struct_fold_safe(seeded_scope, root)
+
         on_enter = ->(node, scope) { table[node] = scope }
         StatementEvaluator.new(scope: seeded_scope, on_enter: on_enter,
                                converged_loop_recording: converged_loop_recording).evaluate(root)
@@ -158,6 +160,17 @@ module Rigor
         table
       end
 
+      # ADR-48 Struct slice 3 — installs the top-level fold-safe-local set
+      # ({Inference::StructFoldSafety}). Struct member layouts of constant
+      # receivers are resolved through the side-table the seeded scope carries.
+      def seed_struct_fold_safe(seeded_scope, root)
+        seeded_scope.with_struct_fold_safe(
+          StructFoldSafety.fold_safe_locals(
+            root, ->(name) { seeded_scope.struct_member_layout(name)&.[](:members) }
+          )
+        )
+      end
+
       # v0.0.2 #5 + ADR-24 slice 2 — seeds the three
       # project-method indexes onto `seeded_scope`: the
       # per-instance-method def-node table, the class ->
@@ -185,11 +198,9 @@ module Rigor
         method_visibilities = default_scope.discovered_method_visibilities.merge(
           build_discovered_method_visibilities(root)
         ) { |_class, cross_file, per_file| cross_file.merge(per_file) }
-        # ADR-48 — per-file Data member layouts merged OVER the cross-file
-        # seed (same-file declaration is authoritative for its own classes).
-        data_member_layouts = default_scope.data_member_layouts.merge(
-          build_data_member_layouts(root)
-        )
+        # ADR-48 — per-file Data + Struct member layouts merged OVER the
+        # cross-file seed (same-file declaration is authoritative).
+        data_member_layouts, struct_member_layouts = merge_member_layouts(default_scope, root)
 
         seeded_scope.with_discovery(
           seeded_scope.discovery.with(
@@ -198,11 +209,23 @@ module Rigor
             discovered_superclasses: superclasses,
             discovered_includes: includes,
             discovered_method_visibilities: method_visibilities,
-            data_member_layouts: data_member_layouts
+            data_member_layouts: data_member_layouts,
+            struct_member_layouts: struct_member_layouts
           )
         )
       end
 
+      # ADR-48 — the per-file Data + Struct member-layout tables, each merged
+      # OVER the cross-file seed so a same-file declaration wins for its own
+      # classes. Returned as a pair to keep {#merge_project_method_indexes}
+      # under the method-size budget.
+      def merge_member_layouts(default_scope, root)
+        [
+          default_scope.data_member_layouts.merge(build_data_member_layouts(root)),
+          default_scope.struct_member_layouts.merge(build_struct_member_layouts(root))
+        ]
+      end
+
       # Slice 7 phase 2. Builds the class-level ivar accumulator
       # by walking every `Prism::ClassNode` / `Prism::ModuleNode`
       # body, descending into each nested `Prism::DefNode`, and
@@ -357,7 +380,7 @@ module Rigor
 
         case node
         when Prism::ClassNode, Prism::ModuleNode
-          name = qualified_name_for(node.constant_path)
+          name = Source::ConstantPath.qualified_name(node.constant_path)
           if name
             child_prefix = qualified_prefix + [name]
             if node.body
@@ -841,7 +864,7 @@ module Rigor
 
         case root
         when Prism::ClassNode, Prism::ModuleNode
-          name = qualified_name_for(root.constant_path)
+          name = Source::ConstantPath.qualified_name(root.constant_path)
           if name && root.body
             child = prefix + [name]
             collect_class_method_defs(root.body, child, acc)
@@ -1251,7 +1274,7 @@ module Rigor
 
         case node
         when Prism::ClassNode, Prism::ModuleNode
-          name = qualified_name_for(node.constant_path)
+          name = Source::ConstantPath.qualified_name(node.constant_path)
           if name
             child_prefix = qualified_prefix + [name]
             walk_class_cvars(node.body, child_prefix, default_scope, accumulator) if node.body
@@ -1337,7 +1360,7 @@ module Rigor
 
         case node
         when Prism::ClassNode, Prism::ModuleNode
-          name = qualified_name_for(node.constant_path)
+          name = Source::ConstantPath.qualified_name(node.constant_path)
           if name
             child_prefix = qualified_prefix + [name]
             walk_constant_writes(node.body, child_prefix, default_scope, accumulator) if node.body
@@ -1347,7 +1370,7 @@ module Rigor
           record_constant_write(node, qualified_prefix, default_scope, accumulator, node.name.to_s)
           return
         when Prism::ConstantPathWriteNode
-          full = qualified_name_for(node.target)
+          full = Source::ConstantPath.qualified_name(node.target)
           record_constant_write(node, [], default_scope, accumulator, full) if full
           return
         end
@@ -1413,7 +1436,7 @@ module Rigor
 
         case node
         when Prism::ClassNode, Prism::ModuleNode
-          name = qualified_name_for(node.constant_path)
+          name = Source::ConstantPath.qualified_name(node.constant_path)
           if name
             child_prefix = qualified_prefix + [name]
             record_meta_superclass_members(node, child_prefix, accumulator) if node.is_a?(Prism::ClassNode)
@@ -1466,7 +1489,7 @@ module Rigor
         when Prism::SelfNode
           qualified_prefix
         when Prism::ConstantReadNode, Prism::ConstantPathNode
-          rendered = qualified_name_for(node.expression)
+          rendered = Source::ConstantPath.qualified_name(node.expression)
           return nil unless rendered
 
           if !qualified_prefix.empty? && qualified_prefix.last == rendered
@@ -1573,7 +1596,7 @@ module Rigor
         when Prism::ConstantReadNode
           receiver.name.to_s == qualified_prefix.last
         when Prism::ConstantPathNode
-          rendered = render_constant_path(receiver)
+          rendered = Source::ConstantPath.render(receiver)
           return false unless rendered
 
           path = rendered.split("::")
@@ -1605,7 +1628,7 @@ module Rigor
 
         case node
         when Prism::ClassNode, Prism::ModuleNode
-          name = qualified_name_for(node.constant_path)
+          name = Source::ConstantPath.qualified_name(node.constant_path)
           if name
             child_prefix = qualified_prefix + [name]
             walk_def_nodes(node.body, child_prefix, false, accumulator) if node.body
@@ -1681,7 +1704,7 @@ module Rigor
 
         case node
         when Prism::ClassNode, Prism::ModuleNode
-          name = qualified_name_for(node.constant_path)
+          name = Source::ConstantPath.qualified_name(node.constant_path)
           if name
             walk_singleton_body(node.body, qualified_prefix + [name], false, accumulator) if node.body
             return
@@ -1810,16 +1833,16 @@ module Rigor
 
         case node
         when Prism::ClassNode
-          name = qualified_name_for(node.constant_path)
+          name = Source::ConstantPath.qualified_name(node.constant_path)
           if name
             full = (qualified_prefix + [name]).join("::")
-            superclass = node.superclass && qualified_name_for(node.superclass)
+            superclass = node.superclass && Source::ConstantPath.qualified_name(node.superclass)
             accumulator[full] = superclass if superclass
             walk_class_superclasses(node.body, qualified_prefix + [name], accumulator) if node.body
             return
           end
         when Prism::ModuleNode
-          name = qualified_name_for(node.constant_path)
+          name = Source::ConstantPath.qualified_name(node.constant_path)
           if name
             walk_class_superclasses(node.body, qualified_prefix + [name], accumulator) if node.body
             return
@@ -1851,14 +1874,14 @@ module Rigor
 
         case node
         when Prism::ClassNode
-          name = qualified_name_for(node.constant_path)
+          name = Source::ConstantPath.qualified_name(node.constant_path)
           if name
             record_data_member_layout(accumulator, qualified_prefix + [name], node.superclass)
             walk_data_member_layouts(node.body, qualified_prefix + [name], accumulator) if node.body
             return
           end
         when Prism::ModuleNode
-          name = qualified_name_for(node.constant_path)
+          name = Source::ConstantPath.qualified_name(node.constant_path)
           if name
             walk_data_member_layouts(node.body, qualified_prefix + [name], accumulator) if node.body
             return
@@ -1883,6 +1906,74 @@ module Rigor
         accumulator[qualified_parts.join("::")] = members.freeze
       end
 
+      # ADR-48 Struct follow-up — the `Struct.new(...)` sibling of
+      # {#build_data_member_layouts}. A separate, additive table so the
+      # existing `Data.define` value-shape contract (a bare `[Symbol]`) is
+      # untouched: a Struct entry carries `{ members:, keyword_init: }`
+      # because the dispatcher needs the flag to fold the matching `.new`
+      # call form (positional vs keyword) without manufacturing a wrong map.
+      def build_struct_member_layouts(root)
+        accumulator = {}
+        walk_struct_member_layouts(root, [], accumulator)
+        accumulator.freeze
+      end
+
+      def walk_struct_member_layouts(node, qualified_prefix, accumulator)
+        return unless node.is_a?(Prism::Node)
+
+        case node
+        when Prism::ClassNode
+          name = Source::ConstantPath.qualified_name(node.constant_path)
+          if name
+            record_struct_member_layout(accumulator, qualified_prefix + [name], node.superclass)
+            walk_struct_member_layouts(node.body, qualified_prefix + [name], accumulator) if node.body
+            return
+          end
+        when Prism::ModuleNode
+          name = Source::ConstantPath.qualified_name(node.constant_path)
+          if name
+            walk_struct_member_layouts(node.body, qualified_prefix + [name], accumulator) if node.body
+            return
+          end
+        when Prism::ConstantWriteNode
+          record_struct_member_layout(accumulator, qualified_prefix + [node.name.to_s], node.value)
+        end
+
+        node.compact_child_nodes.each do |child|
+          walk_struct_member_layouts(child, qualified_prefix, accumulator)
+        end
+      end
+
+      # Records `qualified -> { members:, keyword_init: }` when `expr` is a
+      # `Struct.new(*Symbol [, keyword_init: <bool>])` call with at least one
+      # literal-Symbol member.
+      def record_struct_member_layout(accumulator, qualified_parts, expr)
+        return unless struct_new_call?(expr)
+
+        members = meta_member_names(expr)
+        return if members.empty?
+
+        accumulator[qualified_parts.join("::")] = {
+          members: members.freeze,
+          keyword_init: struct_new_keyword_init?(expr)
+        }.freeze
+      end
+
+      # True when a `Struct.new` call carries `keyword_init: true` as a
+      # literal in its trailing keyword hash. A non-literal value (or its
+      # absence) reads as `false` — the conservative positional default.
+      def struct_new_keyword_init?(call_node)
+        args = call_node.arguments&.arguments || []
+        last = args.last
+        return false unless last.is_a?(Prism::KeywordHashNode)
+
+        last.elements.any? do |assoc|
+          assoc.is_a?(Prism::AssocNode) &&
+            assoc.key.is_a?(Prism::SymbolNode) && assoc.key.unescaped == "keyword_init" &&
+            assoc.value.is_a?(Prism::TrueNode)
+        end
+      end
+
       MIXIN_CALL_NAMES = %i[include prepend].freeze
 
       # ADR-24 slice 2 — per-class/module table mapping a fully
@@ -1906,7 +1997,7 @@ module Rigor
 
         case node
         when Prism::ClassNode, Prism::ModuleNode
-          name = qualified_name_for(node.constant_path)
+          name = Source::ConstantPath.qualified_name(node.constant_path)
           if name
             full = (qualified_prefix + [name]).join("::")
             walk_class_includes(node.body, qualified_prefix + [name], full, accumulator) if node.body
@@ -1926,7 +2017,7 @@ module Rigor
         return unless MIXIN_CALL_NAMES.include?(node.name)
 
         node.arguments&.arguments&.each do |arg|
-          mod = qualified_name_for(arg)
+          mod = Source::ConstantPath.qualified_name(arg)
           (accumulator[current_class] ||= []) << mod if mod
         end
       end
@@ -1966,7 +2057,7 @@ module Rigor
 
         case node
         when Prism::ClassNode, Prism::ModuleNode
-          name = qualified_name_for(node.constant_path)
+          name = Source::ConstantPath.qualified_name(node.constant_path)
           if name
             child_prefix = qualified_prefix + [name]
             walk_method_visibilities(node.body, child_prefix, false, :public, accumulator) if node.body
@@ -2104,7 +2195,7 @@ module Rigor
 
         case node
         when Prism::ClassNode, Prism::ModuleNode
-          name = qualified_name_for(node.constant_path)
+          name = Source::ConstantPath.qualified_name(node.constant_path)
           if name
             collect_class_alias_map(node.body, qualified_prefix + [name], accumulator) if node.body
             return accumulator
@@ -2252,7 +2343,8 @@ module Rigor
       #   `{ def_nodes:, def_sources:, superclasses:, includes:, class_sources: }`
       def discovered_def_index_for_paths(paths, buffer: nil)
         acc = { def_nodes: {}, singleton_def_nodes: {}, def_sources: {}, superclasses: {}, includes: {},
-                method_visibilities: {}, methods: {}, class_sources: {}, data_member_layouts: {} }
+                method_visibilities: {}, methods: {}, class_sources: {}, data_member_layouts: {},
+                struct_member_layouts: {} }
         paths.each do |path|
           physical = buffer ? buffer.resolve(path) : path
           root = Prism.parse(File.read(physical), filepath: path).value
@@ -2306,6 +2398,7 @@ module Rigor
         record_class_sources(acc[:class_sources], path, root, superclasses, includes)
         merge_class_keyed_index_tables(acc, root)
         acc[:data_member_layouts].merge!(build_data_member_layouts(root))
+        acc[:struct_member_layouts].merge!(build_struct_member_layouts(root))
       end
 
       # Folds the per-class method-visibility and method-existence tables of
@@ -2364,14 +2457,14 @@ module Rigor
 
         case node
         when Prism::ClassNode
-          name = qualified_name_for(node.constant_path)
+          name = Source::ConstantPath.qualified_name(node.constant_path)
           if name
             full = (qualified_prefix + [name]).join("::")
             accumulator[full] = Type::Combinator.singleton_of(full)
             return collect_class_decls(node.body, qualified_prefix + [name], accumulator) if node.body
           end
         when Prism::ModuleNode
-          name = qualified_name_for(node.constant_path)
+          name = Source::ConstantPath.qualified_name(node.constant_path)
           return collect_class_decls(node.body, qualified_prefix + [name], accumulator) if name && node.body
         when Prism::ConstantWriteNode
           record_class_new_constant_decl(node, qualified_prefix, accumulator)
@@ -2417,7 +2510,7 @@ module Rigor
         arg = call_node.arguments&.arguments&.first
         return nil if arg.nil?
 
-        raw = qualified_name_for(arg)
+        raw = Source::ConstantPath.qualified_name(arg)
         return nil if raw.nil?
 
         prefix = qualified_prefix.dup
@@ -2462,7 +2555,7 @@ module Rigor
       end
 
       def record_class_or_module?(node, qualified_prefix, identity_table, discovered)
-        name = qualified_name_for(node.constant_path)
+        name = Source::ConstantPath.qualified_name(node.constant_path)
         return false unless name
 
         full = (qualified_prefix + [name]).join("::")
@@ -2574,25 +2667,6 @@ module Rigor
         end
       end
 
-      def qualified_name_for(constant_path_node)
-        case constant_path_node
-        when Prism::ConstantReadNode
-          constant_path_node.name.to_s
-        when Prism::ConstantPathNode
-          render_constant_path(constant_path_node)
-        end
-      end
-
-      def render_constant_path(node)
-        prefix =
-          case node.parent
-          when Prism::ConstantReadNode then "#{node.parent.name}::"
-          when Prism::ConstantPathNode then "#{render_constant_path(node.parent)}::"
-          else ""
-          end
-        "#{prefix}#{node.name}"
-      end
-
       # Walks `node`'s subtree DFS and fills in scope entries for every
       # Prism node the StatementEvaluator did not visit (i.e. expression-
       # interior nodes like the receiver/args of a CallNode). Those