rigortype 0.0.5 → 0.0.7

data/lib/rigor/inference/narrowing.rb

@@ -2,6 +2,7 @@
 
 require "prism"
 
+require_relative "../reflection"
 require_relative "../type"
 require_relative "../environment"
 require_relative "../rbs_extended"
@@ -285,6 +286,8 @@ module Rigor
           complement_integer_range(current_type, refinement_type)
         when Type::Intersection
           complement_intersection(current_type, refinement_type)
+        when Type::Refined
+          complement_refined(current_type, refinement_type)
         else
           current_type
         end
@@ -526,6 +529,38 @@ module Rigor
           Type::Combinator.union(*per_member)
         end
 
+        # v0.0.7 — complement of a `Refined[base, predicate]`
+        # refinement within `current_type`. Walks the current
+        # type's union members; parts that are disjoint from
+        # the refinement's base survive unchanged; parts equal
+        # to the refinement itself drop entirely (they were
+        # exactly the negated subset); parts that overlap the
+        # base contribute `Difference[part, refined]` so
+        # downstream narrowing knows the refinement subset is
+        # excluded.
+        #
+        # The result is sound but imprecise: without a
+        # complementary carrier (e.g. `mixed-case-string` for
+        # `~lowercase-string`) we cannot enumerate the surviving
+        # values. Difference is the carrier-of-last-resort, and
+        # the existing `Type::Difference` consumers already
+        # treat it correctly.
+        def complement_refined(current_type, refined)
+          base = refined.base
+          parts = current_type.is_a?(Type::Union) ? current_type.members : [current_type]
+
+          survivors = parts.map do |part|
+            next nil if part == refined
+            next part if base_disjoint?(base, part)
+
+            Type::Combinator.difference(part, refined)
+          end.compact
+
+          return current_type if survivors.empty?
+
+          Type::Combinator.union(*survivors)
+        end
+
         def falsey_value?(value)
           value.nil? || value == false
         end
@@ -1248,18 +1283,15 @@ module Rigor
         end
 
         def resolve_rbs_extended_method(node, scope)
-          loader = scope.environment.rbs_loader
-          return nil if loader.nil?
-
           receiver_type = scope.type_of(node.receiver)
           class_name = rbs_extended_class_name(receiver_type)
           return nil if class_name.nil?
-          return nil unless loader.class_known?(class_name)
+          return nil unless Rigor::Reflection.rbs_class_known?(class_name, scope: scope)
 
           if receiver_type.is_a?(Type::Singleton)
-            loader.singleton_method(class_name: class_name, method_name: node.name)
+            Rigor::Reflection.singleton_method_definition(class_name, node.name, scope: scope)
           else
-            loader.instance_method(class_name: class_name, method_name: node.name)
+            Rigor::Reflection.instance_method_definition(class_name, node.name, scope: scope)
           end
         rescue StandardError
           nil

data/lib/rigor/inference/statement_evaluator.rb

@@ -2,6 +2,7 @@
 
 require "prism"
 
+require_relative "../reflection"
 require_relative "../type"
 require_relative "../analysis/fact_store"
 require_relative "../source/node_walker"
@@ -838,7 +839,7 @@ module Rigor
         end
       end
 
-      def resolve_call_method(call_node, current_scope) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def resolve_call_method(call_node, current_scope) # rubocop:disable Metrics/PerceivedComplexity
         receiver_node = call_node.receiver
         receiver_type =
           if receiver_node
@@ -848,17 +849,14 @@ module Rigor
           end
         return nil if receiver_type.nil?
 
-        loader = current_scope.environment.rbs_loader
-        return nil if loader.nil?
-
         class_name = assertion_class_name(receiver_type)
         return nil if class_name.nil?
-        return nil unless loader.class_known?(class_name)
+        return nil unless Rigor::Reflection.rbs_class_known?(class_name, scope: current_scope)
 
         if receiver_type.is_a?(Type::Singleton)
-          loader.singleton_method(class_name: class_name, method_name: call_node.name)
+          Rigor::Reflection.singleton_method_definition(class_name, call_node.name, scope: current_scope)
         else
-          loader.instance_method(class_name: class_name, method_name: call_node.name)
+          Rigor::Reflection.instance_method_definition(class_name, call_node.name, scope: current_scope)
         end
       rescue StandardError
         nil

data/lib/rigor/reflection.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require_relative "type"
+
+module Rigor
+  # Read-side facade over Rigor's three reflection sources:
+  #
+  # 1. **`Rigor::Environment::ClassRegistry`** — Ruby `Class` /
+  #    `Module` objects (Integer, Float, Set, Pathname, …) registered
+  #    at boot. Static; never changes during a `rigor check` run.
+  # 2. **`Rigor::Environment::RbsLoader`** — RBS-side declarations
+  #    (instance / singleton methods, class hierarchy, constants).
+  #    Loaded on demand from the project's `sig/` directory + the
+  #    bundled stdlib RBS.
+  # 3. **`Rigor::Scope` discovered facts** — source-side discoveries
+  #    produced by `Rigor::Inference::ScopeIndexer` (user-defined
+  #    classes / modules, in-source constants, discovered method
+  #    nodes, class ivar / cvar declarations).
+  #
+  # This module is the **stable read shape** that v0.1.0's plugin
+  # API will be designed against. ADR-2 (`docs/adr/2-extension-api.md`)
+  # calls out a unified reflection layer as a prerequisite for the
+  # extension protocols, and `docs/design/20260505-v0.1.0-readiness.md`
+  # nominates this module as the highest-leverage cold-start slice.
+  #
+  # The facade is **read-only and additive**. Existing call sites
+  # that read directly from `Rigor::Scope` or
+  # `Rigor::Environment::RbsLoader` continue to work unchanged;
+  # they migrate to the facade at their own pace. The facade
+  # performs no caching beyond what the underlying sources already
+  # provide.
+  #
+  # ## Public surface (v0.0.7 first pass)
+  #
+  # - {.class_known?} — does any source recognise this class /
+  #   module name?
+  # - {.class_ordering} — `:equal` / `:subclass` / `:superclass` /
+  #   `:disjoint` / `:unknown` ordering between two class names.
+  # - {.nominal_for_name} — `Rigor::Type::Nominal` for the class
+  #   name, joining registry + RBS lookups.
+  # - {.singleton_for_name} — `Rigor::Type::Singleton` for the
+  #   class name's class object.
+  # - {.constant_type_for} — type of a constant (joins in-source
+  #   constants and RBS-side constants).
+  # - {.instance_method_definition} / {.singleton_method_definition}
+  #   — RBS-side `RBS::Definition::Method` for the method, or
+  #   `nil` when the method is not declared in RBS. Source-side
+  #   discovered methods are exposed through {.discovered_method?}
+  #   below until the unified `MethodDefinition` carrier ships.
+  # - {.discovered_class?} / {.discovered_method?} — has the
+  #   ScopeIndexer pass recorded the class / method as user-
+  #   defined in the analyzed sources?
+  #
+  # The provenance side of the API (which source family contributed
+  # each fact) is explicitly out of scope for the v0.0.7 first
+  # pass. v0.1.0's plugin API adds it as a separate concern.
+  module Reflection
+    module_function
+
+    # @param class_name [String, Symbol]
+    # @param scope [Rigor::Scope]
+    # @return [Boolean]
+    def class_known?(class_name, scope: Scope.empty)
+      return true if scope.discovered_classes.key?(class_name.to_s)
+
+      scope.environment.class_known?(class_name)
+    end
+
+    # RBS-only variant of {.class_known?}. Use when the caller
+    # needs to know specifically whether RBS has a definition
+    # for the class, independent of any source-discovered
+    # `class Foo; end` declarations. The diagnostic-rule code
+    # paths that walk RBS method tables to decide whether to
+    # flag a missing method use this variant; otherwise the
+    # source-discovered class would suppress the rule even
+    # when no RBS sig actually proves the method exists.
+    #
+    # The kwarg accepts either `scope:` or `environment:`. The
+    # latter is for call sites that don't carry a `Scope`
+    # (most are bottom-half dispatcher code paths called with
+    # only an environment).
+    def rbs_class_known?(class_name, scope: nil, environment: nil)
+      loader = rbs_loader_for(scope, environment)
+      return false if loader.nil?
+
+      loader.class_known?(class_name)
+    end
+
+    # @return [Symbol] one of `:equal`, `:subclass`, `:superclass`,
+    #   `:disjoint`, `:unknown`.
+    def class_ordering(lhs, rhs, scope: Scope.empty)
+      scope.environment.class_ordering(lhs, rhs)
+    end
+
+    # Returns the `Rigor::Type::Nominal` for the class name, or
+    # nil when no source knows the class.
+    def nominal_for_name(class_name, scope: Scope.empty)
+      scope.environment.nominal_for_name(class_name)
+    end
+
+    # Returns the `Rigor::Type::Singleton` for the class name's
+    # class object, or nil when no source knows the class.
+    def singleton_for_name(class_name, scope: Scope.empty)
+      scope.environment.singleton_for_name(class_name)
+    end
+
+    # Returns the type of the named constant. Joins in-source
+    # constants (recorded by `ScopeIndexer`) and RBS-side
+    # constants. In-source wins on collision because the user's
+    # source is the authoritative declaration.
+    def constant_type_for(constant_name, scope: Scope.empty)
+      key = constant_name.to_s
+      in_source = scope.in_source_constants[key]
+      return in_source if in_source
+
+      scope.environment.constant_for_name(constant_name)
+    end
+
+    # Returns the RBS `RBS::Definition::Method` for the instance
+    # method, or nil when the class or method is not in RBS. The
+    # source-side discovered-method facts are reachable through
+    # {.discovered_method?}; a future slice will unify the two
+    # under a `MethodDefinition` carrier.
+    def instance_method_definition(class_name, method_name, scope: nil, environment: nil)
+      loader = rbs_loader_for(scope, environment)
+      return nil if loader.nil?
+
+      loader.instance_method(class_name: class_name.to_s, method_name: method_name.to_sym)
+    end
+
+    # Returns the RBS `RBS::Definition::Method` for the singleton
+    # (class-side) method, or nil.
+    def singleton_method_definition(class_name, method_name, scope: nil, environment: nil)
+      loader = rbs_loader_for(scope, environment)
+      return nil if loader.nil?
+
+      loader.singleton_method(class_name: class_name.to_s, method_name: method_name.to_sym)
+    end
+
+    # Returns the full RBS instance-side class definition
+    # (`RBS::Definition`), used by callers that walk the method
+    # table or member list. Returns nil when the class is not in
+    # RBS or when the loader cannot build a definition (e.g.
+    # constant aliases, malformed signatures).
+    def instance_definition(class_name, scope: nil, environment: nil)
+      loader = rbs_loader_for(scope, environment)
+      return nil if loader.nil?
+
+      loader.instance_definition(class_name.to_s)
+    rescue StandardError
+      nil
+    end
+
+    # Returns the full RBS singleton-side class definition.
+    def singleton_definition(class_name, scope: nil, environment: nil)
+      loader = rbs_loader_for(scope, environment)
+      return nil if loader.nil?
+
+      loader.singleton_definition(class_name.to_s)
+    rescue StandardError
+      nil
+    end
+
+    # Returns the RBS-declared type parameter names for the
+    # class (e.g. `[:A]` for `Array[A]`), or `[]` when the class
+    # is non-generic / not in RBS. Used by the dispatcher when
+    # binding generic method types to a concrete receiver.
+    def class_type_param_names(class_name, scope: nil, environment: nil)
+      loader = rbs_loader_for(scope, environment)
+      return [] if loader.nil?
+
+      loader.class_type_param_names(class_name.to_s)
+    end
+
+    # Internal helper — resolves the RBS loader from either the
+    # `scope:` or the `environment:` kwarg, defaulting to the
+    # empty scope's environment when neither is given. Public
+    # methods document both spellings; the helper centralises
+    # the dispatch.
+    def rbs_loader_for(scope, environment)
+      return environment.rbs_loader if environment
+      return scope.environment.rbs_loader if scope
+
+      Scope.empty.environment.rbs_loader
+    end
+    private_class_method :rbs_loader_for
+
+    # @return [Boolean] true when the analyzed source contains a
+    #   class / module declaration for the given name. Does NOT
+    #   consult the RBS loader (use {.class_known?} for the union).
+    def discovered_class?(class_name, scope: Scope.empty)
+      scope.discovered_classes.key?(class_name.to_s)
+    end
+
+    # @param kind [:instance, :singleton]
+    # @return [Boolean] true when the ScopeIndexer recorded a
+    #   `def` for the given method on the given class with the
+    #   matching kind.
+    def discovered_method?(class_name, method_name, kind: :instance, scope: Scope.empty)
+      scope.discovered_method?(class_name, method_name, kind)
+    end
+  end
+end

data/lib/rigor/type/combinator.rb

@@ -219,9 +219,252 @@ module Rigor
         collapse_union(normalized_union_members(types))
       end
 
-      class << self
+      # `key_of[T]` type function — projects the type-level
+      # union of `T`'s known keys. Recognised shapes:
+      #
+      # - `Type::HashShape{a: A, b: B}` → `Constant<:a> | Constant<:b>`.
+      # - `Type::Tuple[A, B, C]` → `Constant<0> | Constant<1> | Constant<2>`.
+      # - `Type::Nominal["Hash", [K, V]]` → `K` (untyped if absent).
+      # - `Type::Nominal["Array", [E]]` → `non-negative-int`.
+      # - `Type::Constant` whose value is a Hash / Array / Range —
+      #   project through the literal's per-element keys.
+      #
+      # Other inputs (`Top`, `Dynamic`, untyped Nominals, `Union`,
+      # `Refined`, `Difference`, `Intersection`) project to `top`
+      # so the type function always returns a value — callers may
+      # narrow further when they know more.
+      def key_of(type)
+        case type
+        when HashShape then hash_shape_keys(type)
+        when Tuple then tuple_indices(type)
+        when Nominal then nominal_keys(type)
+        when Constant then constant_keys(type.value)
+        else top
+        end
+      end
+
+      # `value_of[T]` type function — projects the type-level
+      # union of `T`'s known values. Mirror of `key_of`:
+      #
+      # - `Type::HashShape{a: A, b: B}` → `A | B`.
+      # - `Type::Tuple[A, B, C]` → `A | B | C`.
+      # - `Type::Nominal["Hash", [K, V]]` → `V` (untyped if absent).
+      # - `Type::Nominal["Array", [E]]` → `E` (untyped if absent).
+      # - `Type::Constant` whose value is a Hash / Array / Range —
+      #   union of `Constant<…>` for each element.
+      def value_of(type)
+        case type
+        when HashShape then hash_shape_values(type)
+        when Tuple then tuple_values(type)
+        when Nominal then nominal_values(type)
+        when Constant then constant_values(type.value)
+        else top
+        end
+      end
+
+      # `int_mask[1, 2, 4]` type function — every Integer
+      # representable by a bitwise OR over the listed flags,
+      # including 0. The closure of `[1, 2, 4]` is
+      # `{0, 1, 2, 3, 4, 5, 6, 7}`. Returns a `Union[Constant…]`
+      # for small closures and a covering `IntegerRange` once
+      # the cardinality exceeds `INT_MASK_UNION_LIMIT`. Returns
+      # `nil` when the input is malformed (non-integer flag,
+      # negative flag, or too many flags to compute the closure
+      # cheaply).
+      INT_MASK_FLAG_LIMIT = 6
+      INT_MASK_UNION_LIMIT = 16
+      private_constant :INT_MASK_FLAG_LIMIT, :INT_MASK_UNION_LIMIT
+
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def int_mask(flags)
+        return nil unless flags.is_a?(Array) && flags.all?(Integer)
+        return nil if flags.any?(&:negative?)
+        return nil if flags.size > INT_MASK_FLAG_LIMIT
+
+        values = compute_int_mask_closure(flags)
+        return nil if values.nil?
+
+        if values.size <= INT_MASK_UNION_LIMIT
+          union(*values.map { |v| constant_of(v) })
+        else
+          integer_range(values.min, values.max)
+        end
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+      # `int_mask_of[T]` — derives the int_mask closure from
+      # a finite integer-literal type:
+      # `Constant<n>` (single flag), `Union[Constant…]` (every
+      # member must be a `Constant<Integer>`). Returns nil for
+      # incompatible inputs (Top, Dynamic, IntegerRange, mixed
+      # member shapes).
+      def int_mask_of(type)
+        flags = extract_constant_int_set(type)
+        return nil if flags.nil?
+
+        int_mask(flags)
+      end
+
+      # `T[K]` indexed-access type operator — extracts the type
+      # at index / key `K` from a structured `T`:
+      #
+      # - `Tuple[A, B, C][Constant<i>]` → `A` / `B` / `C` (out-of-
+      #   range indices return `Top` for safety).
+      # - `HashShape{a: A, b: B}[Constant<:a>]` → `A`.
+      # - `Nominal[Hash, [K, V]][_]` → `V` (untyped if absent).
+      # - `Nominal[Array, [E]][_]` → `E` (untyped if absent).
+      #
+      # Other shapes (`Top`, `Dynamic`, untyped Nominals,
+      # `Union`, `Refined`, `Difference`, `Intersection`)
+      # project to `Top`. The key argument is itself a
+      # `Type::t`; only `Type::Constant` keys produce a precise
+      # answer.
+      def indexed_access(type, key)
+        case type
+        when Tuple then tuple_indexed_access(type, key)
+        when HashShape then hash_shape_indexed_access(type, key)
+        when Nominal then nominal_indexed_access(type)
+        when Constant then constant_indexed_access(type.value, key)
+        else top
+        end
+      end
+
+      class << self # rubocop:disable Metrics/ClassLength
         private
 
+        def hash_shape_keys(shape)
+          return Bot.instance if shape.pairs.empty?
+
+          union(*shape.pairs.keys.map { |k| constant_of(k) })
+        end
+
+        def hash_shape_values(shape)
+          return Bot.instance if shape.pairs.empty?
+
+          union(*shape.pairs.values)
+        end
+
+        def tuple_indices(tuple)
+          return Bot.instance if tuple.elements.empty?
+
+          union(*tuple.elements.each_index.map { |i| constant_of(i) })
+        end
+
+        def tuple_values(tuple)
+          return Bot.instance if tuple.elements.empty?
+
+          union(*tuple.elements)
+        end
+
+        def nominal_keys(nominal)
+          case nominal.class_name
+          when "Hash"
+            nominal.type_args.first || untyped
+          when "Array"
+            non_negative_int
+          else
+            top
+          end
+        end
+
+        def nominal_values(nominal)
+          case nominal.class_name
+          when "Hash"
+            nominal.type_args[1] || untyped
+          when "Array"
+            nominal.type_args.first || untyped
+          else
+            top
+          end
+        end
+
+        # `Type::Constant` only carries scalar literals (Integer
+        # / Float / String / Symbol / Range / Rational / Complex
+        # / true / false / nil); Array and Hash literals become
+        # Tuple / HashShape carriers earlier in the typer. Range
+        # is the only scalar with meaningful key/value
+        # projections.
+        def compute_int_mask_closure(flags)
+          unique = flags.uniq
+          return [0] if unique.empty?
+
+          # Closure under bitwise OR over a set of non-negative
+          # integers is `0..(max_or_value)` only when the flags
+          # are bit-disjoint; otherwise it's a strict subset.
+          # Enumerate every subset's OR.
+          closure = Set.new([0])
+          unique.each do |flag|
+            closure |= closure.map { |c| c | flag }
+          end
+          closure.to_a.sort
+        end
+
+        def extract_constant_int_set(type)
+          case type
+          when Constant
+            type.value.is_a?(Integer) ? [type.value] : nil
+          when Union
+            type.members.all?(Constant) ? type.members.map(&:value).grep(Integer) : nil
+          end
+        end
+
+        def tuple_indexed_access(tuple, key)
+          return top unless key.is_a?(Constant) && key.value.is_a?(Integer)
+
+          index = key.value
+          return top if index.negative? || index >= tuple.elements.size
+
+          tuple.elements[index]
+        end
+
+        def hash_shape_indexed_access(shape, key)
+          return top unless key.is_a?(Constant)
+
+          shape.pairs[key.value] || top
+        end
+
+        def nominal_indexed_access(nominal)
+          case nominal.class_name
+          when "Hash" then nominal.type_args[1] || untyped
+          when "Array" then nominal.type_args.first || untyped
+          else top
+          end
+        end
+
+        def constant_indexed_access(value, key)
+          return top unless key.is_a?(Constant)
+
+          if value.is_a?(Range) && key.value.is_a?(Integer)
+            element = value.to_a[key.value]
+            return constant_of(element) unless element.nil?
+          end
+
+          top
+        end
+
+        def constant_keys(value)
+          return non_negative_int if value.is_a?(Range) && value.begin.is_a?(Integer)
+
+          top
+        end
+
+        def constant_values(value)
+          return range_value_of(value) if value.is_a?(Range)
+
+          top
+        end
+
+        def range_value_of(range)
+          beg = range.begin
+          en  = range.end
+          return top unless beg.is_a?(Integer) && en.is_a?(Integer)
+
+          upper = range.exclude_end? ? en - 1 : en
+          return Bot.instance if upper < beg
+
+          integer_range(beg, upper)
+        end
+
         def normalized_union_members(types)
           flattened = []
           types.each { |t| flatten_into(flattened, t) }

data/lib/rigor/type/constant.rb

@@ -22,6 +22,8 @@ module Rigor
         Range,
         Rational,
         Complex,
+        Regexp,
+        Pathname,
         TrueClass,
         FalseClass,
         NilClass

data/lib/rigor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rigor
-  VERSION = "0.0.5"
+  VERSION = "0.0.7"
 end

data/lib/rigor.rb

@@ -18,6 +18,7 @@ require_relative "rigor/inference/method_parameter_binder"
 require_relative "rigor/inference/closure_escape_analyzer"
 require_relative "rigor/inference/statement_evaluator"
 require_relative "rigor/scope"
+require_relative "rigor/reflection"
 require_relative "rigor/source"
 require_relative "rigor/inference/scope_indexer"
 require_relative "rigor/inference/coverage_scanner"

data/sig/rigor/reflection.rbs

@@ -0,0 +1,17 @@
+module Rigor
+  module Reflection
+    def self?.class_known?: (String | Symbol class_name, ?scope: Scope) -> bool
+    def self?.rbs_class_known?: (String | Symbol class_name, ?scope: Scope) -> bool
+    def self?.class_ordering: (String | Symbol lhs, String | Symbol rhs, ?scope: Scope) -> Symbol
+    def self?.nominal_for_name: (String | Symbol class_name, ?scope: Scope) -> Type::Nominal?
+    def self?.singleton_for_name: (String | Symbol class_name, ?scope: Scope) -> Type::Singleton?
+    def self?.constant_type_for: (String | Symbol constant_name, ?scope: Scope) -> Type::t?
+    def self?.instance_method_definition: (String | Symbol class_name, String | Symbol method_name, ?scope: Scope) -> untyped
+    def self?.singleton_method_definition: (String | Symbol class_name, String | Symbol method_name, ?scope: Scope) -> untyped
+    def self?.instance_definition: (String | Symbol class_name, ?scope: Scope) -> untyped
+    def self?.singleton_definition: (String | Symbol class_name, ?scope: Scope) -> untyped
+    def self?.class_type_param_names: (String | Symbol class_name, ?scope: Scope) -> Array[Symbol]
+    def self?.discovered_class?: (String | Symbol class_name, ?scope: Scope) -> bool
+    def self?.discovered_method?: (String | Symbol class_name, String | Symbol method_name, ?kind: Symbol, ?scope: Scope) -> bool
+  end
+end

data/sig/rigor/type.rbs

@@ -256,6 +256,11 @@ module Rigor
       def self?.tuple_of: (*Type::t elements) -> Tuple
       def self?.hash_shape_of: (?Hash[untyped, Type::t]? pairs, **untyped options) -> HashShape
       def self?.union: (*Type::t types) -> Type::t
+      def self?.key_of: (Type::t type) -> Type::t
+      def self?.value_of: (Type::t type) -> Type::t
+      def self?.int_mask: (Array[Integer] flags) -> Type::t?
+      def self?.int_mask_of: (Type::t type) -> Type::t?
+      def self?.indexed_access: (Type::t type, Type::t key) -> Type::t
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rigortype
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.7
 platform: ruby
 authors:
 - Rigor contributors
@@ -169,6 +169,7 @@ files:
 - data/builtins/ruby_core/hash.yml
 - data/builtins/ruby_core/io.yml
 - data/builtins/ruby_core/numeric.yml
+- data/builtins/ruby_core/pathname.yml
 - data/builtins/ruby_core/range.yml
 - data/builtins/ruby_core/rational.yml
 - data/builtins/ruby_core/set.yml
@@ -205,6 +206,7 @@ files:
 - lib/rigor/inference/builtins/hash_catalog.rb
 - lib/rigor/inference/builtins/method_catalog.rb
 - lib/rigor/inference/builtins/numeric_catalog.rb
+- lib/rigor/inference/builtins/pathname_catalog.rb
 - lib/rigor/inference/builtins/range_catalog.rb
 - lib/rigor/inference/builtins/rational_catalog.rb
 - lib/rigor/inference/builtins/set_catalog.rb
@@ -216,6 +218,7 @@ files:
 - lib/rigor/inference/fallback.rb
 - lib/rigor/inference/fallback_tracer.rb
 - lib/rigor/inference/method_dispatcher.rb
+- lib/rigor/inference/method_dispatcher/block_folding.rb
 - lib/rigor/inference/method_dispatcher/constant_folding.rb
 - lib/rigor/inference/method_dispatcher/file_folding.rb
 - lib/rigor/inference/method_dispatcher/iterator_dispatch.rb
@@ -230,6 +233,7 @@ files:
 - lib/rigor/inference/scope_indexer.rb
 - lib/rigor/inference/statement_evaluator.rb
 - lib/rigor/rbs_extended.rb
+- lib/rigor/reflection.rb
 - lib/rigor/scope.rb
 - lib/rigor/source.rb
 - lib/rigor/source/node_locator.rb
@@ -259,6 +263,7 @@ files:
 - sig/rigor/environment.rbs
 - sig/rigor/inference.rbs
 - sig/rigor/rbs_extended.rbs
+- sig/rigor/reflection.rbs
 - sig/rigor/scope.rbs
 - sig/rigor/source.rbs
 - sig/rigor/testing.rbs