rigortype 0.0.5 → 0.0.7

data/lib/rigor/analysis/check_rules.rb

@@ -2,6 +2,7 @@
 
 require "prism"
 
+require_relative "../reflection"
 require_relative "../source/node_walker"
 require_relative "../type"
 require_relative "diagnostic"
@@ -172,9 +173,7 @@ module Rigor
           kind = receiver_type.is_a?(Type::Singleton) ? :singleton : :instance
           return nil if scope.discovered_method?(class_name, call_node.name, kind)
 
-          loader = scope.environment.rbs_loader
-          return nil if loader.nil?
-          return nil unless loader.class_known?(class_name)
+          return nil unless Rigor::Reflection.rbs_class_known?(class_name, scope: scope)
 
           # When the loader cannot build a class definition for a
           # name it nominally knows (constant-decl aliases such
@@ -182,9 +181,9 @@ module Rigor
           # malformed signatures), we cannot enumerate methods
           # so we MUST NOT emit a false positive. Skip the rule
           # in that case.
-          return nil unless definition_available?(loader, receiver_type, class_name)
+          return nil unless definition_available?(receiver_type, class_name, scope)
 
-          method_def = lookup_method(loader, receiver_type, class_name, call_node.name)
+          method_def = lookup_method(receiver_type, class_name, call_node.name, scope)
           return nil if method_def
 
           build_undefined_method_diagnostic(path, call_node, receiver_type)
@@ -219,27 +218,29 @@ module Rigor
           nil
         end
 
-        def definition_available?(loader, receiver_type, class_name)
+        def definition_available?(receiver_type, class_name, scope)
           if receiver_type.is_a?(Type::Singleton)
-            !loader.singleton_definition(class_name).nil?
+            !Rigor::Reflection.singleton_definition(class_name, scope: scope).nil?
           else
-            !loader.instance_definition(class_name).nil?
+            !Rigor::Reflection.instance_definition(class_name, scope: scope).nil?
           end
-        rescue StandardError
-          false
         end
 
-        def lookup_method(loader, receiver_type, class_name, method_name)
+        def lookup_method(receiver_type, class_name, method_name, scope)
           if receiver_type.is_a?(Type::Singleton)
-            loader.singleton_method(class_name: class_name, method_name: method_name)
+            Rigor::Reflection.singleton_method_definition(class_name, method_name, scope: scope)
           else
-            loader.instance_method(class_name: class_name, method_name: method_name)
+            Rigor::Reflection.instance_method_definition(class_name, method_name, scope: scope)
           end
         rescue StandardError
-          # The loader is best-effort and may raise on malformed
-          # RBS. Treat any failure as "method exists" so we do
-          # NOT emit a false positive when our knowledge of the
-          # receiver class is structurally incomplete.
+          # The Reflection facade catches loader exceptions and
+          # returns nil. The wrapper here treats failures as
+          # "method exists" so we do NOT emit a false positive
+          # when our knowledge of the receiver class is
+          # structurally incomplete (Reflection's own rescue
+          # already returns nil; this catch is a defensive
+          # double-net for any future call shape that might
+          # raise).
           true
         end
 
@@ -271,12 +272,10 @@ module Rigor
           kind = receiver_type.is_a?(Type::Singleton) ? :singleton : :instance
           return nil if scope.discovered_method?(class_name, call_node.name, kind)
 
-          loader = scope.environment.rbs_loader
-          return nil if loader.nil?
-          return nil unless loader.class_known?(class_name)
-          return nil unless definition_available?(loader, receiver_type, class_name)
+          return nil unless Rigor::Reflection.rbs_class_known?(class_name, scope: scope)
+          return nil unless definition_available?(receiver_type, class_name, scope)
 
-          method_def = lookup_method(loader, receiver_type, class_name, call_node.name)
+          method_def = lookup_method(receiver_type, class_name, call_node.name, scope)
           return nil if method_def.nil? || method_def == true
 
           arity_envelope = compute_arity_envelope(method_def)
@@ -383,12 +382,14 @@ module Rigor
           receiver_type = scope.type_of(call_node.receiver)
           return nil unless receiver_type.is_a?(Type::Union)
 
-          loader = scope.environment.rbs_loader
-          return nil if loader.nil?
+          # The rule only fires when the analyzer has access to
+          # an RBS loader; without it, the per-member method-
+          # presence checks below cannot rule out a sound call.
+          return nil unless Rigor::Reflection.rbs_class_known?("NilClass", scope: scope)
 
           return nil unless union_contains_nil?(receiver_type)
-          return nil unless union_method_present_on_non_nil?(receiver_type, call_node.name, loader, scope)
-          return nil if nil_class_has_method?(call_node.name, loader)
+          return nil unless union_method_present_on_non_nil?(receiver_type, call_node.name, scope)
+          return nil if nil_class_has_method?(call_node.name, scope)
 
           build_nil_receiver_diagnostic(path, call_node)
         end
@@ -409,27 +410,25 @@ module Rigor
         # that are unsound on the non-nil branch — that is the
         # `undefined_method_diagnostic` rule's job, and we want
         # exactly one diagnostic per offending call site.
-        def union_method_present_on_non_nil?(union, method_name, loader, scope)
+        def union_method_present_on_non_nil?(union, method_name, scope)
           non_nil_members = union.members.reject { |m| nil_member?(m) }
           return false if non_nil_members.empty?
 
-          non_nil_members.all? { |m| method_present_anywhere?(m, method_name, loader, scope) }
+          non_nil_members.all? { |m| method_present_anywhere?(m, method_name, scope) }
         end
 
-        def method_present_anywhere?(member, method_name, loader, scope)
+        def method_present_anywhere?(member, method_name, scope)
           class_name = concrete_class_name(member)
           return true if class_name.nil? # Dynamic / Top / Bot — be permissive.
           return true if scope.discovered_method?(class_name, method_name, :instance)
-          return true unless loader.class_known?(class_name)
-          return true unless definition_available?(loader, member, class_name)
+          return true unless Rigor::Reflection.rbs_class_known?(class_name, scope: scope)
+          return true unless definition_available?(member, class_name, scope)
 
-          !lookup_method(loader, member, class_name, method_name).nil?
+          !lookup_method(member, class_name, method_name, scope).nil?
         end
 
-        def nil_class_has_method?(method_name, loader)
-          return false unless loader.class_known?("NilClass")
-
-          definition = loader.instance_definition("NilClass")
+        def nil_class_has_method?(method_name, scope)
+          definition = Rigor::Reflection.instance_definition("NilClass", scope: scope)
           return false if definition.nil?
 
           !definition.methods[method_name.to_sym].nil?
@@ -684,12 +683,10 @@ module Rigor
           # supplies BOTH a `def` and an RBS sig, the sig is
           # the authoritative parameter contract and we
           # should validate calls against it.
-          loader = scope.environment.rbs_loader
-          return nil if loader.nil?
-          return nil unless loader.class_known?(class_name)
-          return nil unless definition_available?(loader, receiver_type, class_name)
+          return nil unless Rigor::Reflection.rbs_class_known?(class_name, scope: scope)
+          return nil unless definition_available?(receiver_type, class_name, scope)
 
-          method_def = lookup_method(loader, receiver_type, class_name, call_node.name)
+          method_def = lookup_method(receiver_type, class_name, call_node.name, scope)
           return nil if method_def.nil? || method_def == true
           return nil unless method_def.method_types.size == 1
 

data/lib/rigor/builtins/imported_refinements.rb

@@ -78,6 +78,41 @@ module Rigor
           return nil unless args.size == 2
 
           Type::Combinator.non_empty_hash(args[0], args[1])
+        },
+        # v0.0.7 — `key_of[T]` and `value_of[T]` type functions.
+        # Each takes a single type argument and projects the
+        # known-keys (resp. known-values) union out of `T`. See
+        # `Type::Combinator.key_of` for the per-shape projection
+        # rules. Use `lower_snake` per the
+        # imported-built-in-types.md type-function naming rule.
+        "key_of" => lambda { |args|
+          return nil unless args.size == 1
+
+          Type::Combinator.key_of(args.first)
+        },
+        "value_of" => lambda { |args|
+          return nil unless args.size == 1
+
+          Type::Combinator.value_of(args.first)
+        },
+        # `int_mask[1, 2, 4]` — every integer representable by
+        # a bitwise OR over the listed flags. Each arg must be a
+        # `Constant<Integer>`; the parser wraps integer literals
+        # for this purpose. Builder declines on any non-integer
+        # arg.
+        "int_mask" => lambda { |args|
+          flags = args.map { |arg| arg.is_a?(Type::Constant) && arg.value.is_a?(Integer) ? arg.value : nil }
+          return nil if flags.any?(&:nil?)
+
+          Type::Combinator.int_mask(flags)
+        },
+        # `int_mask_of[T]` — derives the closure from a finite
+        # integer literal type (single Constant<Integer> or a
+        # Union of them).
+        "int_mask_of" => lambda { |args|
+          return nil unless args.size == 1
+
+          Type::Combinator.int_mask_of(args.first)
         }
       }.freeze
       private_constant :PARAMETERISED_TYPE_BUILDERS
@@ -145,7 +180,7 @@ module Rigor
       # soft (returns `nil` from `parse`) on any deviation so the
       # `RBS::Extended` directive site can fall back to the
       # RBS-declared type rather than crash on a typo.
-      class Parser
+      class Parser # rubocop:disable Metrics/ClassLength
         def initialize(input)
           @scanner = StringScanner.new(input.strip)
         end
@@ -153,6 +188,12 @@ module Rigor
         def parse
           type = parse_type
           return nil if type.nil?
+
+          # v0.0.7 — trailing `[K]` indexed-access projects
+          # into the parsed type. Multiple `[K]` segments
+          # chain (`Tuple[A, B, C][1][0]`).
+          type = parse_indexed_access_chain(type)
+          return nil if type.nil?
           return nil unless @scanner.eos?
 
           type
@@ -160,12 +201,21 @@ module Rigor
 
         private
 
-        SIMPLE_NAME = /[a-z][a-z0-9-]*/
+        # Refinement names use kebab-case (`non-empty-string`),
+        # type-function names use lower_snake (`key_of`,
+        # `value_of`, `int_mask`). The regex accepts both shapes;
+        # the registry lookup decides which family the name
+        # belongs to.
+        SIMPLE_NAME = /[a-z][a-z0-9_-]*/
         CLASS_NAME = /[A-Z][A-Za-z0-9_]*(?:::[A-Z][A-Za-z0-9_]*)*/
         SIGNED_INT = /-?\d+/
         private_constant :SIMPLE_NAME, :CLASS_NAME, :SIGNED_INT
 
         def parse_type
+          if (class_name = @scanner.scan(CLASS_NAME))
+            return parse_class_arg_tail(class_name)
+          end
+
           name = @scanner.scan(SIMPLE_NAME)
           return nil if name.nil?
 
@@ -176,6 +226,25 @@ module Rigor
           end
         end
 
+        # `T[K]` — keep applying `[K]` indexes until no more
+        # opening brackets are present. Each index consumes one
+        # type argument; multi-arg `[K1, K2]` fails (the spec
+        # specifies a single key).
+        def parse_indexed_access_chain(type)
+          loop do
+            skip_ws
+            break unless @scanner.peek(1) == "["
+
+            @scanner.getch
+            args = parse_type_arg_list
+            return nil if args.nil? || args.size != 1
+            return nil unless @scanner.getch == "]"
+
+            type = Type::Combinator.indexed_access(type, args.first)
+          end
+          type
+        end
+
         def parse_parametric_type_args(name)
           builder = PARAMETERISED_TYPE_BUILDERS[name]
           return nil if builder.nil?
@@ -227,12 +296,33 @@ module Rigor
         def parse_type_arg
           skip_ws
           if (class_name = @scanner.scan(CLASS_NAME))
-            Type::Combinator.nominal_of(class_name)
+            parse_class_arg_tail(class_name)
+          elsif (literal = @scanner.scan(SIGNED_INT))
+            # Integer-literal arg, used by `int_mask[1, 2, 4]`.
+            # Wrapped as `Constant<Integer>` so type-arg builders
+            # see a uniform `Array<Type::t>`.
+            Type::Combinator.constant_of(Integer(literal))
           else
             parse_type
           end
         end
 
+        # Class-name-headed type argument with optional `[T_1,
+        # …]` type-args tail. Used so `key_of[Hash[Symbol,
+        # Integer]]` parses as the projection of a parameterised
+        # nominal carrier rather than rejecting the inner
+        # brackets.
+        def parse_class_arg_tail(class_name)
+          return Type::Combinator.nominal_of(class_name) unless @scanner.peek(1) == "["
+
+          @scanner.getch # consume '['
+          args = parse_type_arg_list
+          return nil if args.nil?
+          return nil unless @scanner.getch == "]"
+
+          Type::Combinator.nominal_of(class_name, type_args: args)
+        end
+
         def parse_int_bound
           skip_ws
           literal = @scanner.scan(SIGNED_INT)

data/lib/rigor/inference/builtins/pathname_catalog.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "method_catalog"
+
+module Rigor
+  module Inference
+    module Builtins
+      # `Pathname` catalog. Singleton — load once, consult during
+      # dispatch.
+      #
+      # TODO(blocklist curation): read
+      # `data/builtins/ruby_core/pathname.yml` and add per-method
+      # blocklist entries for any `:leaf` classifications that are
+      # actually mutators or otherwise unsafe to fold. Each entry
+      # SHOULD carry a one-line comment naming the indirect mutator
+      # helper that triggered the false positive (see
+      # `string_catalog.rb`, `array_catalog.rb`, `time_catalog.rb`
+      # for the canonical shape).
+      PATHNAME_CATALOG = MethodCatalog.new(
+        path: File.expand_path(
+          "../../../../data/builtins/ruby_core/pathname.yml",
+          __dir__
+        ),
+        mutating_selectors: {
+          "Pathname" => Set[
+          # initialize_copy is blocklisted by convention so a
+          # hypothetical future `Constant<Pathname>` carrier
+          # cannot fold an aliasing copy through the catalog.
+          :initialize_copy
+          ]
+        }
+      )
+    end
+  end
+end