rigortype 0.0.2 → 0.0.4

data/lib/rigor/analysis/check_rules.rb

@@ -53,6 +53,7 @@ module Rigor
       RULE_NIL_RECEIVER = "possible-nil-receiver"
       RULE_DUMP_TYPE = "dump-type"
       RULE_ASSERT_TYPE = "assert-type"
+      RULE_ALWAYS_RAISES = "always-raises"
 
       ALL_RULES = [
         RULE_UNDEFINED_METHOD,
@@ -60,7 +61,8 @@ module Rigor
         RULE_ARGUMENT_TYPE,
         RULE_NIL_RECEIVER,
         RULE_DUMP_TYPE,
-        RULE_ASSERT_TYPE
+        RULE_ASSERT_TYPE,
+        RULE_ALWAYS_RAISES
       ].freeze
 
       module_function
@@ -97,6 +99,9 @@ module Rigor
 
           assert_diagnostic = assert_type_diagnostic(path, node, scope_index)
           diagnostics << assert_diagnostic if assert_diagnostic
+
+          raises_diagnostic = always_raises_diagnostic(path, node, scope_index)
+          diagnostics << raises_diagnostic if raises_diagnostic
         end
         filter_suppressed(diagnostics, comments: comments, disabled_rules: disabled_rules)
       end
@@ -333,6 +338,13 @@ module Rigor
         end
 
         def arity_eligible?(function)
+          # `RBS::Types::UntypedFunction` (used for `(?) ->`
+          # untyped sigs) does not expose the per-arity
+          # accessors. Treating it as ineligible is the
+          # correct conservative move: an untyped function
+          # has no static arity to enforce.
+          return false unless function.respond_to?(:required_keywords)
+
           function.required_keywords.empty? && function.trailing_positionals.empty?
         end
 
@@ -562,6 +574,74 @@ module Rigor
           )
         end
 
+        # Diagnoses calls that the analyzer can prove will always
+        # raise. Today the only triggering shape is integer
+        # division/modulo by a literal zero divisor:
+        #
+        #   5 / 0          # => ZeroDivisionError
+        #   x.modulo(0)    # => ZeroDivisionError when x: Integer
+        #   xs.size % 0    # same — non_negative_int / Constant[0]
+        #
+        # Float divmod by zero returns Infinity/NaN at runtime, so
+        # the rule restricts to Integer-rooted receivers (`Constant`,
+        # `IntegerRange`, `Nominal[Integer]`). The argument MUST be a
+        # `Constant<Integer>` whose value is exactly zero — a
+        # `Union[Constant[0], Constant[2]]` divisor "may" raise,
+        # which we surface separately (future slice).
+        INTEGER_RAISING_OPERATORS = %i[/ % div modulo divmod].freeze
+        private_constant :INTEGER_RAISING_OPERATORS
+
+        def always_raises_diagnostic(path, call_node, scope_index)
+          return nil unless integer_zero_division?(call_node, scope_index)
+
+          build_always_raises_diagnostic(path, call_node)
+        end
+
+        def integer_zero_division?(call_node, scope_index)
+          return false unless raising_call_shape?(call_node)
+
+          scope = scope_index[call_node]
+          return false if scope.nil?
+          return false unless integer_rooted_for_diagnostic?(scope.type_of(call_node.receiver))
+
+          arg = single_argument(call_node)
+          arg && integer_zero_constant?(scope.type_of(arg))
+        end
+
+        def raising_call_shape?(call_node)
+          !call_node.receiver.nil? && INTEGER_RAISING_OPERATORS.include?(call_node.name)
+        end
+
+        def single_argument(call_node)
+          args = call_node.arguments&.arguments || []
+          args.size == 1 ? args.first : nil
+        end
+
+        def integer_rooted_for_diagnostic?(type)
+          case type
+          when Type::Constant then type.value.is_a?(Integer)
+          when Type::IntegerRange then true
+          when Type::Nominal then type.class_name == "Integer" && type.type_args.empty?
+          else false
+          end
+        end
+
+        def integer_zero_constant?(type)
+          type.is_a?(Type::Constant) && type.value.is_a?(Integer) && type.value.zero?
+        end
+
+        def build_always_raises_diagnostic(path, call_node)
+          location = call_node.message_loc || call_node.location
+          Diagnostic.new(
+            rule: RULE_ALWAYS_RAISES,
+            path: path,
+            line: location.start_line,
+            column: location.start_column + 1,
+            message: "always raises ZeroDivisionError: `#{call_node.name}' by zero on Integer receiver",
+            severity: :error
+          )
+        end
+
         # v0.0.2 #4 — argument-type-mismatch diagnostic.
         # Walks a call's positional arguments and checks each
         # against the matching parameter's RBS type via
@@ -613,14 +693,16 @@ module Rigor
           return nil if method_def.nil? || method_def == true
           return nil unless method_def.method_types.size == 1
 
-          mismatch = first_argument_mismatch(method_def.method_types.first, call_node, scope)
+          param_overrides = Rigor::RbsExtended.param_type_override_map(method_def)
+          mismatch = first_argument_mismatch(method_def.method_types.first, call_node, scope, param_overrides)
           return nil if mismatch.nil?
 
           build_argument_type_diagnostic(path, call_node, class_name, mismatch)
         end
         # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/AbcSize
 
-        def first_argument_mismatch(method_type, call_node, scope) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/AbcSize
+        def first_argument_mismatch(method_type, call_node, scope, param_overrides)
           function = method_type.type
           return nil unless argument_check_eligible?(function)
 
@@ -630,7 +712,12 @@ module Rigor
             param = params[index]
             next if param.nil? # arity mismatch is the wrong-arity rule's concern.
 
-            param_type = translate_param_type(param.type, scope.environment)
+            # `rigor:v1:param: <name> <refinement>` annotations
+            # tighten the RBS-declared parameter type. The
+            # override is the authoritative contract when
+            # present; otherwise we translate the RBS type as
+            # before.
+            param_type = param_overrides[param.name] || translate_param_type(param.type, scope.environment)
             next if param_type.is_a?(Type::Dynamic) || param_type.is_a?(Type::Top)
 
             arg_type = scope.type_of(arg)
@@ -641,8 +728,14 @@ module Rigor
           end
           nil
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/AbcSize
 
         def argument_check_eligible?(function)
+          # See `arity_eligible?`: `UntypedFunction` lacks
+          # the per-arity accessors. Treat it as ineligible
+          # for argument-type-mismatch diagnostics.
+          return false unless function.respond_to?(:required_keywords)
+
           function.rest_positionals.nil? &&
             function.required_keywords.empty? &&
             function.optional_keywords.empty? &&

data/lib/rigor/analysis/runner.rb

@@ -6,6 +6,7 @@ require_relative "../environment"
 require_relative "../scope"
 require_relative "../inference/coverage_scanner"
 require_relative "../inference/scope_indexer"
+require_relative "../inference/method_dispatcher/file_folding"
 require_relative "check_rules"
 require_relative "diagnostic"
 require_relative "result"
@@ -29,6 +30,9 @@ module Rigor
       # is built once at run start through `Environment.for_project`
       # so all files share the same RBS load.
       def run(paths = @configuration.paths)
+        Inference::MethodDispatcher::FileFolding.fold_platform_specific_paths =
+          @configuration.fold_platform_specific_paths
+
         environment = Environment.for_project(
           libraries: @configuration.libraries,
           signature_paths: @configuration.signature_paths

data/lib/rigor/builtins/imported_refinements.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+require "strscan"
+
+require_relative "../type"
+
+module Rigor
+  module Builtins
+    # Canonical-name registry for the imported-built-in
+    # refinement catalogue. See `imported-built-in-types.md`
+    # in `docs/type-specification/` for the full catalogue
+    # rationale and the kebab-case naming rule.
+    #
+    # Maps kebab-case names (`non-empty-string`, `positive-int`,
+    # `non-empty-array`, …) to the Rigor type each name denotes.
+    # The registry is the single integration point for:
+    #
+    # - The `rigor:v1:return:` RBS::Extended directive
+    #   ([`Rigor::RbsExtended.read_return_type_override`](../rbs_extended.rb)),
+    #   which overrides a method's RBS-declared return type
+    #   with a refinement carrier.
+    # - Future `RBS::Extended` directives that accept a
+    #   refinement name in any type position (`param:`,
+    #   `assert: x is non-empty-string`, …).
+    # - The display side: `Type::Difference#describe` already
+    #   recognises the same shapes and prints the kebab-case
+    #   spelling without consulting the registry.
+    #
+    # Names not in the registry resolve to `nil`; callers
+    # decide whether to fall back to the RBS-declared type or
+    # raise a parse error.
+    #
+    # The registry covers two surfaces:
+    #
+    # - **No-argument refinement names** (`non-empty-string`,
+    #   `non-zero-int`, `lowercase-string`, …) live in `REGISTRY`
+    #   and resolve through `lookup(name)`.
+    # - **Parameterised refinement payloads** (`non-empty-array[Integer]`,
+    #   `non-empty-hash[Symbol, Integer]`, `int<5, 10>`) are
+    #   accepted by `parse(payload)`. The full grammar is documented
+    #   on `Parser`. The two surfaces share `REGISTRY` for the
+    #   no-arg head names; the parameterised head names live in
+    #   `PARAMETERISED_TYPE_BUILDERS` (square-bracket form, type
+    #   args) and `PARAMETERISED_INT_BUILDERS` (angle-bracket form,
+    #   integer bounds).
+    module ImportedRefinements
+      REGISTRY = {
+        "non-empty-string" => -> { Type::Combinator.non_empty_string },
+        "non-zero-int" => -> { Type::Combinator.non_zero_int },
+        "non-empty-array" => -> { Type::Combinator.non_empty_array },
+        "non-empty-hash" => -> { Type::Combinator.non_empty_hash },
+        "positive-int" => -> { Type::Combinator.positive_int },
+        "non-negative-int" => -> { Type::Combinator.non_negative_int },
+        "negative-int" => -> { Type::Combinator.negative_int },
+        "non-positive-int" => -> { Type::Combinator.non_positive_int },
+        "lowercase-string" => -> { Type::Combinator.lowercase_string },
+        "uppercase-string" => -> { Type::Combinator.uppercase_string },
+        "numeric-string" => -> { Type::Combinator.numeric_string },
+        "decimal-int-string" => -> { Type::Combinator.decimal_int_string },
+        "octal-int-string" => -> { Type::Combinator.octal_int_string },
+        "hex-int-string" => -> { Type::Combinator.hex_int_string },
+        "non-empty-lowercase-string" => -> { Type::Combinator.non_empty_lowercase_string },
+        "non-empty-uppercase-string" => -> { Type::Combinator.non_empty_uppercase_string }
+      }.freeze
+      private_constant :REGISTRY
+
+      # `name[T]` / `name[K, V]` — type-arg parameterised
+      # refinements. Each builder takes an `Array<Rigor::Type>`
+      # and returns a `Rigor::Type` (or `nil` on arity / shape
+      # mismatch so the caller surfaces a parse failure).
+      PARAMETERISED_TYPE_BUILDERS = {
+        "non-empty-array" => lambda { |args|
+          return nil unless args.size == 1
+
+          Type::Combinator.non_empty_array(args.first)
+        },
+        "non-empty-hash" => lambda { |args|
+          return nil unless args.size == 2
+
+          Type::Combinator.non_empty_hash(args[0], args[1])
+        }
+      }.freeze
+      private_constant :PARAMETERISED_TYPE_BUILDERS
+
+      # `name<min, max>` — integer-bound parameterised
+      # refinements. Each builder takes an `Array<Integer>` and
+      # returns a `Rigor::Type` (or `nil`). Bounds are signed
+      # integer literals; `min` MUST be ≤ `max` for the carrier
+      # to construct successfully (`Type::IntegerRange` enforces
+      # the invariant).
+      PARAMETERISED_INT_BUILDERS = {
+        "int" => lambda { |bounds|
+          return nil unless bounds.size == 2
+
+          Type::Combinator.integer_range(bounds[0], bounds[1])
+        }
+      }.freeze
+      private_constant :PARAMETERISED_INT_BUILDERS
+
+      module_function
+
+      # @param name [String] kebab-case refinement name.
+      # @return [Rigor::Type, nil] the matching refinement
+      #   carrier, or `nil` if the name is not registered.
+      def lookup(name)
+        builder = REGISTRY[name.to_s]
+        builder&.call
+      end
+
+      # @param payload [String] the trailing payload of a
+      #   `rigor:v1:return:` (or sibling) directive. Accepts
+      #   the bare-name forms `lookup` already handles plus the
+      #   parameterised forms documented on {Parser}.
+      # @return [Rigor::Type, nil] the resolved refinement
+      #   carrier, or `nil` when the payload is unparseable or
+      #   names a refinement / class not in the registry.
+      def parse(payload)
+        Parser.new(payload.to_s).parse
+      end
+
+      def known?(name)
+        REGISTRY.key?(name.to_s) ||
+          PARAMETERISED_TYPE_BUILDERS.key?(name.to_s) ||
+          PARAMETERISED_INT_BUILDERS.key?(name.to_s)
+      end
+
+      def known_names
+        REGISTRY.keys + PARAMETERISED_TYPE_BUILDERS.keys + PARAMETERISED_INT_BUILDERS.keys
+      end
+
+      # Recursive-descent parser for the refinement-payload
+      # grammar:
+      #
+      #   type        := simple_name | parametric
+      #   simple_name := /[a-z][a-z0-9-]*/
+      #   parametric  := simple_name '[' type_arg_list ']'
+      #                | simple_name '<' int_bound_list '>'
+      #   type_arg_list := type_arg (',' type_arg)*
+      #   type_arg    := type | class_name
+      #   class_name  := /[A-Z][A-Za-z0-9_]*(?:::[A-Z][A-Za-z0-9_]*)*/
+      #   int_bound_list := signed_int (',' signed_int)*
+      #   signed_int  := /-?\d+/
+      #
+      # Whitespace between tokens is ignored. The parser fails
+      # 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
+        def initialize(input)
+          @scanner = StringScanner.new(input.strip)
+        end
+
+        def parse
+          type = parse_type
+          return nil if type.nil?
+          return nil unless @scanner.eos?
+
+          type
+        end
+
+        private
+
+        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
+          name = @scanner.scan(SIMPLE_NAME)
+          return nil if name.nil?
+
+          case @scanner.peek(1)
+          when "[" then parse_parametric_type_args(name)
+          when "<" then parse_parametric_int_bounds(name)
+          else          ImportedRefinements.lookup(name)
+          end
+        end
+
+        def parse_parametric_type_args(name)
+          builder = PARAMETERISED_TYPE_BUILDERS[name]
+          return nil if builder.nil?
+
+          @scanner.getch # consume '['
+          args = parse_type_arg_list
+          return nil if args.nil?
+          return nil unless @scanner.getch == "]"
+
+          builder.call(args)
+        end
+
+        def parse_parametric_int_bounds(name)
+          builder = PARAMETERISED_INT_BUILDERS[name]
+          return nil if builder.nil?
+
+          @scanner.getch # consume '<'
+          bounds = parse_int_bound_list
+          return nil if bounds.nil?
+          return nil unless @scanner.getch == ">"
+
+          builder.call(bounds)
+        end
+
+        def parse_type_arg_list
+          collect_separated_list { parse_type_arg }
+        end
+
+        def parse_int_bound_list
+          collect_separated_list { parse_int_bound }
+        end
+
+        def collect_separated_list
+          items = []
+          loop do
+            skip_ws
+            item = yield
+            return nil if item.nil?
+
+            items << item
+            skip_ws
+            break unless @scanner.peek(1) == ","
+
+            @scanner.getch # consume ','
+          end
+          items
+        end
+
+        def parse_type_arg
+          skip_ws
+          if (class_name = @scanner.scan(CLASS_NAME))
+            Type::Combinator.nominal_of(class_name)
+          else
+            parse_type
+          end
+        end
+
+        def parse_int_bound
+          skip_ws
+          literal = @scanner.scan(SIGNED_INT)
+          return nil if literal.nil?
+
+          Integer(literal)
+        end
+
+        def skip_ws
+          @scanner.skip(/\s+/)
+        end
+      end
+      private_constant :Parser
+    end
+  end
+end

data/lib/rigor/configuration.rb

@@ -12,13 +12,14 @@ module Rigor
       "disable" => [],
       "libraries" => [],
       "signature_paths" => nil,
+      "fold_platform_specific_paths" => false,
       "cache" => {
         "path" => ".rigor/cache"
       }
     }.freeze
 
     attr_reader :target_ruby, :paths, :plugins, :cache_path, :disabled_rules,
-                :libraries, :signature_paths
+                :libraries, :signature_paths, :fold_platform_specific_paths
 
     def self.load(path = DEFAULT_PATH)
       data = if File.exist?(path)
@@ -40,6 +41,9 @@ module Rigor
       @libraries = Array(data.fetch("libraries", DEFAULTS.fetch("libraries"))).map(&:to_s).freeze
       sig_paths = data.fetch("signature_paths", DEFAULTS.fetch("signature_paths"))
       @signature_paths = sig_paths.nil? ? nil : Array(sig_paths).map(&:to_s).freeze
+      @fold_platform_specific_paths = data.fetch(
+        "fold_platform_specific_paths", DEFAULTS.fetch("fold_platform_specific_paths")
+      ) == true
       @cache_path = cache.fetch("path").to_s
     end
 
@@ -51,6 +55,7 @@ module Rigor
         "disable" => disabled_rules,
         "libraries" => libraries,
         "signature_paths" => signature_paths,
+        "fold_platform_specific_paths" => fold_platform_specific_paths,
         "cache" => {
           "path" => cache_path
         }