rigortype 0.0.4 → 0.0.5

data/lib/rigor/inference/scope_indexer.rb

@@ -4,6 +4,7 @@ require "prism"
 
 require_relative "../scope"
 require_relative "../type"
+require_relative "narrowing"
 require_relative "statement_evaluator"
 
 module Rigor
@@ -475,16 +476,9 @@ module Rigor
 
         case node
         when Prism::ModuleNode, Prism::ClassNode
-          name = qualified_name_for(node.constant_path)
-          if name
-            full = (qualified_prefix + [name]).join("::")
-            singleton = Type::Combinator.singleton_of(full)
-            identity_table[node.constant_path] = singleton
-            discovered[full] = singleton
-            child_prefix = qualified_prefix + [name]
-            record_declarations(node.body, child_prefix, identity_table, discovered) if node.body
-            return
-          end
+          return if record_class_or_module?(node, qualified_prefix, identity_table, discovered)
+        when Prism::ConstantWriteNode
+          return if record_data_define_constant?(node, qualified_prefix, identity_table, discovered)
         end
 
         node.compact_child_nodes.each do |child|
@@ -492,6 +486,60 @@ module Rigor
         end
       end
 
+      def record_class_or_module?(node, qualified_prefix, identity_table, discovered)
+        name = qualified_name_for(node.constant_path)
+        return false unless name
+
+        full = (qualified_prefix + [name]).join("::")
+        singleton = Type::Combinator.singleton_of(full)
+        identity_table[node.constant_path] = singleton
+        discovered[full] = singleton
+        child_prefix = qualified_prefix + [name]
+        record_declarations(node.body, child_prefix, identity_table, discovered) if node.body
+        true
+      end
+
+      # Recognises `Const = Data.define(*Symbol) [do ... end]` and registers
+      # `Const` (qualified by the surrounding class/module path) as a
+      # discovered class. `Const.new(...)` then resolves to a fresh
+      # `Nominal[Const]` via `meta_new`, instead of the un-narrowed
+      # `Dynamic[top]` returned by the default `Class#new` envelope.
+      #
+      # The Data.define block body, if present, is recursed into so any
+      # nested class/module declarations in the override block (rare but
+      # legal) still feed the discovered table.
+      def record_data_define_constant?(node, qualified_prefix, identity_table, discovered)
+        return false unless data_define_call?(node.value)
+
+        full = (qualified_prefix + [node.name.to_s]).join("::")
+        discovered[full] = Type::Combinator.singleton_of(full)
+        record_declarations(node.value, qualified_prefix, identity_table, discovered)
+        true
+      end
+
+      # Recognises `Data.define(*Symbol)` and `Data.define(*Symbol) do ... end`
+      # at constant-write rvalue position. The receiver MUST be the bare
+      # `Data` constant (or `::Data`); other receivers (a local variable, a
+      # method call return) are rejected because their identity is not
+      # statically known.
+      def data_define_call?(node)
+        return false unless node.is_a?(Prism::CallNode)
+        return false unless node.name == :define
+        return false unless data_constant_receiver?(node.receiver)
+
+        args = node.arguments&.arguments || []
+        args.all?(Prism::SymbolNode)
+      end
+
+      def data_constant_receiver?(node)
+        case node
+        when Prism::ConstantReadNode
+          node.name == :Data
+        when Prism::ConstantPathNode
+          node.parent.nil? && node.name == :Data
+        end
+      end
+
       def qualified_name_for(constant_path_node)
         case constant_path_node
         when Prism::ConstantReadNode
@@ -515,6 +563,13 @@ module Rigor
       # Prism node the StatementEvaluator did not visit (i.e. expression-
       # interior nodes like the receiver/args of a CallNode). Those
       # nodes inherit their nearest recorded ancestor's scope.
+      #
+      # `IfNode` / `UnlessNode` are special-cased: the truthy and falsey
+      # branches each get their predicate's narrowed scope before
+      # recursing. This handles expression-position conditionals
+      # (e.g. `cache[k] = if cond; t; else; e; end` and conditionals
+      # nested as call arguments) which are typed by ExpressionTyper
+      # without going through `eval_if`'s narrowing path.
       def propagate(node, table, parent_scope)
         return unless node.is_a?(Prism::Node)
 
@@ -526,7 +581,28 @@ module Rigor
             parent_scope
           end
 
-        node.compact_child_nodes.each { |child| propagate(child, table, current_scope) }
+        case node
+        when Prism::IfNode
+          propagate_if_branches(node, table, current_scope)
+        when Prism::UnlessNode
+          propagate_unless_branches(node, table, current_scope)
+        else
+          node.compact_child_nodes.each { |child| propagate(child, table, current_scope) }
+        end
+      end
+
+      def propagate_if_branches(node, table, current_scope)
+        truthy_scope, falsey_scope = Narrowing.predicate_scopes(node.predicate, current_scope)
+        propagate(node.predicate, table, current_scope) if node.predicate
+        propagate(node.statements, table, truthy_scope) if node.statements
+        propagate(node.subsequent, table, falsey_scope) if node.subsequent
+      end
+
+      def propagate_unless_branches(node, table, current_scope)
+        truthy_scope, falsey_scope = Narrowing.predicate_scopes(node.predicate, current_scope)
+        propagate(node.predicate, table, current_scope) if node.predicate
+        propagate(node.statements, table, falsey_scope) if node.statements
+        propagate(node.else_clause, table, truthy_scope) if node.else_clause
       end
     end
     # rubocop:enable Metrics/ModuleLength

data/lib/rigor/inference/statement_evaluator.rb

@@ -894,7 +894,11 @@ module Rigor
       end
 
       def narrow_for_assert_effect(current_type, effect, environment)
-        return effect.refinement_type if effect.refinement?
+        if effect.refinement?
+          return Narrowing.narrow_not_refinement(current_type, effect.refinement_type) if effect.negative?
+
+          return effect.refinement_type
+        end
 
         if effect.negative?
           Narrowing.narrow_not_class(current_type, effect.class_name, exact: false, environment: environment)

data/lib/rigor/rbs_extended.rb

@@ -124,8 +124,8 @@ module Rigor
       \s+
       (?<target>self|[a-z_][a-zA-Z0-9_]*)
       \s+is\s+
+      (?<negation>~?)
       (?:
-        (?<negation>~?)
         (?<class_name>(?:::)?[A-Z][A-Za-z0-9_]*(?:::[A-Z][A-Za-z0-9_]*)*)
         |
         (?<refinement>[a-z][a-z0-9-]*(?:[\[<][^\]>]*[\]>])?)
@@ -181,8 +181,8 @@ module Rigor
       \s+
       (?<target>self|[a-z_][a-zA-Z0-9_]*)
       \s+is\s+
+      (?<negation>~?)
       (?:
-        (?<negation>~?)
         (?<class_name>(?:::)?[A-Z][A-Za-z0-9_]*(?:::[A-Z][A-Za-z0-9_]*)*)
         |
         (?<refinement>[a-z][a-z0-9-]*(?:[\[<][^\]>]*[\]>])?)
@@ -231,14 +231,19 @@ module Rigor
     #   nil, `negative` reflects the optional `~` prefix.
     # - Refinement arm matched: `class_name` is nil,
     #   `refinement_type` is the resolved `Rigor::Type`,
-    #   `negative` is `false` (refinement-form directives do
-    #   not support `~` negation in v0.0.4).
+    #   `negative` reflects the `~` prefix. v0.0.5 supports
+    #   refinement-form negation for the `Difference[base,
+    #   Constant]` shape (the narrowing tier computes the
+    #   complement decomposition); other refinement carriers
+    #   under negation fall back to the conservative
+    #   "current_type unchanged" answer.
     # - Refinement payload unparseable: returns
     #   `[nil, nil, false]` so callers can drop the directive
     #   silently (fail-soft policy).
     def resolve_directive_rhs(match)
+      negative = match[:negation].to_s == "~"
       class_capture = match[:class_name]
-      return [class_capture.to_s.sub(/\A::/, ""), nil, match[:negation].to_s == "~"] if class_capture
+      return [class_capture.to_s.sub(/\A::/, ""), nil, negative] if class_capture
 
       refinement_capture = match[:refinement]
       return [nil, nil, false] if refinement_capture.nil?
@@ -246,7 +251,7 @@ module Rigor
       type = Builtins::ImportedRefinements.parse(refinement_capture)
       return [nil, nil, false] if type.nil?
 
-      [nil, type, false]
+      [nil, type, negative]
     end
 
     def target_fields(target)

data/lib/rigor/type/integer_range.rb

@@ -65,11 +65,13 @@ module Rigor
       # `:neg_infinity`). Use this in arithmetic comparisons; never compare
       # `:neg_infinity` directly with an `Integer`.
       def lower
-        min == NEG_INFINITY ? -Float::INFINITY : min
+        m = min
+        m.is_a?(Symbol) ? -Float::INFINITY : m
       end
 
       def upper
-        max == POS_INFINITY ? Float::INFINITY : max
+        m = max
+        m.is_a?(Symbol) ? Float::INFINITY : m
       end
 
       ALIAS_NAMES = {

data/lib/rigor/version.rb

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

data/sig/rigor/environment.rbs

@@ -38,15 +38,13 @@ module Rigor
 
       def initialize: (?libraries: Array[String], ?signature_paths: Array[String | _ToPath]) -> void
       def class_known?: (String | Symbol name) -> bool
-      def instance_definition: (String | Symbol class_name) -> untyped
-      def instance_method: (class_name: String | Symbol, method_name: String | Symbol) -> untyped
-      def singleton_definition: (String | Symbol class_name) -> untyped
-      def singleton_method: (class_name: String | Symbol, method_name: String | Symbol) -> untyped
+      def instance_definition: (String | Symbol class_name) -> untyped?
+      def instance_method: (class_name: String | Symbol, method_name: String | Symbol) -> untyped?
+      def singleton_definition: (String | Symbol class_name) -> untyped?
+      def singleton_method: (class_name: String | Symbol, method_name: String | Symbol) -> untyped?
       def class_type_param_names: (String | Symbol class_name) -> Array[Symbol]
       def class_ordering: (String | Symbol lhs, String | Symbol rhs) -> ordering
       def constant_type: (String name) -> Type::t?
-      def instance_definition: (String | Symbol class_name) -> untyped?
-      def singleton_definition: (String | Symbol class_name) -> untyped?
     end
 
     class RbsHierarchy

data/sig/rigor/inference.rbs

@@ -85,6 +85,7 @@ module Rigor
       def self?.narrow_not_equal: (Type::t type, untyped literal) -> Type::t
       def self?.narrow_class: (Type::t type, String class_name, ?exact: bool, ?environment: Environment) -> Type::t
       def self?.narrow_not_class: (Type::t type, String class_name, ?exact: bool, ?environment: Environment) -> Type::t
+      def self?.narrow_not_refinement: (Type::t current_type, Type::t refinement_type) -> Type::t
       def self?.predicate_scopes: (untyped node, Scope scope) -> [Scope, Scope]
       def self?.case_when_scopes: (untyped subject, Array[untyped] conditions, Scope scope) -> [Scope, Scope]
       def self?.analyse: (untyped node, Scope scope) -> untyped
@@ -131,7 +132,7 @@ module Rigor
     module ScopeIndexer
       def self?.index: (untyped root, default_scope: Scope) -> Hash[untyped, Scope]
       def self?.build_declaration_overrides: (untyped root) -> Hash[untyped, Type::t]
-      def self?.record_declarations: (untyped node, Array[String] qualified_prefix, Hash[untyped, Type::t] table) -> void
+      def self?.record_declarations: (untyped node, Array[String] qualified_prefix, Hash[untyped, Type::t] identity_table, Hash[String, Type::t] discovered) -> void
       def self?.qualified_name_for: (untyped constant_path_node) -> String?
       def self?.render_constant_path: (untyped node) -> String
       def self?.propagate: (untyped node, Hash[untyped, Scope] table, Scope parent_scope) -> void

data/sig/rigor/type.rbs

@@ -8,9 +8,9 @@ module Rigor
       def self.instance: () -> Top
       def describe: (?Symbol verbosity) -> String
       def erase_to_rbs: () -> String
-      def top: () -> Top
-      def bot: () -> Bot
-      def dynamic: () -> Dynamic
+      def top: () -> Trinary
+      def bot: () -> Trinary
+      def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
       def hash: () -> Integer
@@ -21,9 +21,9 @@ module Rigor
       def self.instance: () -> Bot
       def describe: (?Symbol verbosity) -> String
       def erase_to_rbs: () -> String
-      def top: () -> Top
-      def bot: () -> Bot
-      def dynamic: () -> Dynamic
+      def top: () -> Trinary
+      def bot: () -> Trinary
+      def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
       def hash: () -> Integer
@@ -35,9 +35,9 @@ module Rigor
       def initialize: (Type::t static_facet) -> void
       def describe: (?Symbol verbosity) -> String
       def erase_to_rbs: () -> String
-      def top: () -> Top
-      def bot: () -> Bot
-      def dynamic: () -> Dynamic
+      def top: () -> Trinary
+      def bot: () -> Trinary
+      def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
       def hash: () -> Integer
@@ -49,9 +49,9 @@ module Rigor
       def initialize: (untyped value) -> void
       def describe: (?Symbol verbosity) -> String
       def erase_to_rbs: () -> String
-      def top: () -> Top
-      def bot: () -> Bot
-      def dynamic: () -> Dynamic
+      def top: () -> Trinary
+      def bot: () -> Trinary
+      def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
       def hash: () -> Integer
@@ -68,14 +68,14 @@ module Rigor
       def finite?: () -> bool
       def cardinality: () -> (Integer | Float)
       def covers?: (untyped value) -> bool
-      def lower: () -> Numeric
-      def upper: () -> Numeric
+      def lower: () -> (Integer | Float)
+      def upper: () -> (Integer | Float)
       def describe: (?Symbol verbosity) -> String
       def generic_description: () -> String
       def erase_to_rbs: () -> String
-      def top: () -> Top
-      def bot: () -> Bot
-      def dynamic: () -> Dynamic
+      def top: () -> Trinary
+      def bot: () -> Trinary
+      def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
       def hash: () -> Integer
@@ -88,9 +88,9 @@ module Rigor
       def initialize: (String class_name, ?Array[Type::t] type_args) -> void
       def describe: (?Symbol verbosity) -> String
       def erase_to_rbs: () -> String
-      def top: () -> Top
-      def bot: () -> Bot
-      def dynamic: () -> Dynamic
+      def top: () -> Trinary
+      def bot: () -> Trinary
+      def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
       def hash: () -> Integer
@@ -102,9 +102,9 @@ module Rigor
       def initialize: (String class_name) -> void
       def describe: (?Symbol verbosity) -> String
       def erase_to_rbs: () -> String
-      def top: () -> Top
-      def bot: () -> Bot
-      def dynamic: () -> Dynamic
+      def top: () -> Trinary
+      def bot: () -> Trinary
+      def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
       def hash: () -> Integer
@@ -116,9 +116,9 @@ module Rigor
       def initialize: (Array[Type::t] members) -> void
       def describe: (?Symbol verbosity) -> String
       def erase_to_rbs: () -> String
-      def top: () -> Top
-      def bot: () -> Bot
-      def dynamic: () -> Dynamic
+      def top: () -> Trinary
+      def bot: () -> Trinary
+      def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
       def hash: () -> Integer
@@ -131,9 +131,9 @@ module Rigor
       def initialize: (Type::t base, Type::t removed) -> void
       def describe: (?Symbol verbosity) -> String
       def erase_to_rbs: () -> String
-      def top: () -> Top
-      def bot: () -> Bot
-      def dynamic: () -> Dynamic
+      def top: () -> Trinary
+      def bot: () -> Trinary
+      def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
       def hash: () -> Integer
@@ -146,9 +146,9 @@ module Rigor
       def initialize: (Type::t base, Symbol predicate_id) -> void
       def describe: (?Symbol verbosity) -> String
       def erase_to_rbs: () -> String
-      def top: () -> Top
-      def bot: () -> Bot
-      def dynamic: () -> Dynamic
+      def top: () -> Trinary
+      def bot: () -> Trinary
+      def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def matches?: (untyped value) -> bool?
       def ==: (untyped other) -> bool
@@ -161,9 +161,9 @@ module Rigor
       def initialize: (Array[Type::t] members) -> void
       def describe: (?Symbol verbosity) -> String
       def erase_to_rbs: () -> String
-      def top: () -> Top
-      def bot: () -> Bot
-      def dynamic: () -> Dynamic
+      def top: () -> Trinary
+      def bot: () -> Trinary
+      def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
       def hash: () -> Integer
@@ -175,9 +175,9 @@ module Rigor
       def initialize: (Array[Type::t] elements) -> void
       def describe: (?Symbol verbosity) -> String
       def erase_to_rbs: () -> String
-      def top: () -> Top
-      def bot: () -> Bot
-      def dynamic: () -> Dynamic
+      def top: () -> Trinary
+      def bot: () -> Trinary
+      def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
       def hash: () -> Integer
@@ -198,9 +198,9 @@ module Rigor
       def required_key?: (untyped key) -> bool
       def optional_key?: (untyped key) -> bool
       def read_only_key?: (untyped key) -> bool
-      def top: () -> Top
-      def bot: () -> Bot
-      def dynamic: () -> Dynamic
+      def top: () -> Trinary
+      def bot: () -> Trinary
+      def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
       def hash: () -> Integer

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rigortype
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Rigor contributors
@@ -161,11 +161,16 @@ files:
 - LICENSE
 - README.md
 - data/builtins/ruby_core/array.yml
+- data/builtins/ruby_core/comparable.yml
+- data/builtins/ruby_core/complex.yml
+- data/builtins/ruby_core/date.yml
+- data/builtins/ruby_core/enumerable.yml
 - data/builtins/ruby_core/file.yml
 - data/builtins/ruby_core/hash.yml
 - data/builtins/ruby_core/io.yml
 - data/builtins/ruby_core/numeric.yml
 - data/builtins/ruby_core/range.yml
+- data/builtins/ruby_core/rational.yml
 - data/builtins/ruby_core/set.yml
 - data/builtins/ruby_core/string.yml
 - data/builtins/ruby_core/time.yml
@@ -193,10 +198,15 @@ files:
 - lib/rigor/inference/acceptance.rb
 - lib/rigor/inference/block_parameter_binder.rb
 - lib/rigor/inference/builtins/array_catalog.rb
+- lib/rigor/inference/builtins/comparable_catalog.rb
+- lib/rigor/inference/builtins/complex_catalog.rb
+- lib/rigor/inference/builtins/date_catalog.rb
+- lib/rigor/inference/builtins/enumerable_catalog.rb
 - 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/range_catalog.rb
+- lib/rigor/inference/builtins/rational_catalog.rb
 - lib/rigor/inference/builtins/set_catalog.rb
 - lib/rigor/inference/builtins/string_catalog.rb
 - lib/rigor/inference/builtins/time_catalog.rb
@@ -209,6 +219,7 @@ files:
 - lib/rigor/inference/method_dispatcher/constant_folding.rb
 - lib/rigor/inference/method_dispatcher/file_folding.rb
 - lib/rigor/inference/method_dispatcher/iterator_dispatch.rb
+- lib/rigor/inference/method_dispatcher/kernel_dispatch.rb
 - lib/rigor/inference/method_dispatcher/overload_selector.rb
 - lib/rigor/inference/method_dispatcher/rbs_dispatch.rb
 - lib/rigor/inference/method_dispatcher/shape_dispatch.rb