rigortype 0.4.3 → 0.4.5

data/lib/rigor/inference/unthreaded_rebinds.rb

@@ -23,7 +23,9 @@ module Rigor
     # - a statement, and the body of `(…)`, `begin` / `rescue` / `else` / `ensure`;
     # - an assignment's value — every variable-write form, and an index `||=` / `&&=` / `op=`, but not its
     #   receiver or index arguments;
-    # - an `if` / `unless` / `case` predicate and every branch, but not a `when` condition or an `in` guard;
+    # - an `if` / `unless` / `case` predicate and every branch, but not a `when` condition or an `in` guard (since
+    #   issue #1963 the evaluator threads a `when` test that runs code in a `case` with a subject; the scan does
+    #   not admit it yet, which floors a name needlessly rather than letting a pin through);
     # - both operands of `&&` / `||`;
     # - a `while` / `until` predicate and body, a `for` index, collection and body;
     # - a multi-assign value and its local and instance-variable targets, and the LOCAL a `rescue => e`

data/lib/rigor/lens/anchor.rb

@@ -32,9 +32,9 @@ module Rigor
       end
 
       # The anchor of the declaration spanning bytes `start_offset...end_offset` and lines `start_line..end_line`.
-      def for_span(start_offset, end_offset, start_line, end_line)
-        leading = leading_contract_comments(start_line)
-        trailing = trailing_contract_comment(end_line, end_offset)
+      def for_span(start_offset, end_offset, start_line, end_line, leading: true, trailing: true)
+        leading = leading ? leading_contract_comments(start_line) : []
+        trailing = trailing ? trailing_contract_comment(end_line, end_offset) : nil
         material = +"".b
         leading.each { |comment| material << line_text_from(comment.location.start_offset) << "\n" }
         material << @source.byteslice(start_offset, end_offset - start_offset)

data/lib/rigor/lens/contract_reader.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "slot"
+require_relative "parameters"
 require_relative "../reflection"
 
 module Rigor
@@ -34,6 +35,41 @@ module Rigor
         unreadable("definition_build_failed", [])
       end
 
+      # The block an otherwise defaulted inline declaration (`rigor:v1:inferred-signature`) declares, as a
+      # `{required, type}` slot, or nil. The rbs-inline plugin defaults an unannotated `&block` to `?{ (?) ->
+      # untyped }`, so any other block came from a `# @rbs &block:` annotation, and `check` binds the block's
+      # parameters from it. A block spelled like the default carries nothing either way.
+      def read_defaulted_block(owner, scope, name, lookup_scope)
+        method = lookup(owner, scope, name, lookup_scope)
+        defs = method ? method.defs.select { |definition| definition.defined_in.to_s.delete_prefix("::") == owner } : []
+        return nil unless defs.size == 1 && annotations_of(method, defs).include?(INFERRED_SIGNATURE)
+
+        block = defs.first.type.block
+        return nil if block.nil? || default_block?(block)
+
+        provenance, path = @provenance.classify(buffer_name(defs.first))
+        return nil if provenance.nil?
+
+        { "required" => block.required, "type" => Slot.from_rbs(block_type(block), provenance, path) }
+      rescue StandardError
+        nil
+      end
+
+      # The declared type of the constant `name` (qualified), as a slot with its declaration's provenance, or nil
+      # when no RBS or inline declaration names it.
+      def read_constant(name, environment)
+        declaration = environment&.rbs_loader&.constant_declaration(name)
+        return nil if declaration.nil?
+
+        type, buffer = declaration
+        provenance, path = @provenance.classify(buffer)
+        return Slot.unavailable("not_computed") if provenance.nil?
+
+        Slot.from_rbs(type, provenance, path)
+      rescue StandardError
+        Slot.unavailable("not_computed")
+      end
+
       private
 
       def contract(defs, annotations)
@@ -87,14 +123,36 @@ module Rigor
       def overload(method_type, provenance, path, return_inferred, annotations)
         function = method_type.type
         params = function.respond_to?(:required_positionals) ? params_of(function, provenance, path) : nil
-        block = method_type.block && { "required" => method_type.block.required,
-                                       "type" => Slot.from_rbs(method_type.block.type.to_s, provenance, path) }
+        partly_defaulted = return_inferred && provenance == "inline"
+        block = method_type.block && block_slot(method_type.block, provenance, path, partly_defaulted)
         prefix = annotations.map { |string| "%a{#{string}} " }.join
         return_slot = return_inferred ? nil : Slot.from_rbs(function.return_type.to_s, provenance, path)
         { "rbs" => "#{prefix}#{method_type}", "params" => params, "block" => block, "return" => return_slot,
           "return_rbs" => function.return_type.to_s }
       end
 
+      # A block's function type as `RBS::MethodType#to_s` spells it inside the braces (`(Integer) -> void`, with a
+      # `[self: T]` binding when declared). Neither `RBS::Types::Function` nor `UntypedFunction` has a `to_s`.
+      def block_type(block)
+        self_binding = ::RBS::Types::SelfTypeBindingHelper.self_type_binding_to_s(block.self_type)
+        "(#{block.type.param_to_s}) #{self_binding}-> #{block.type.return_to_s}"
+      end
+
+      # Under an inline declaration the rbs-inline plugin defaulted in part (`partly_defaulted`), a block shaped
+      # like its default was not written: it reads as an undeclared block does.
+      def block_slot(block, provenance, path, partly_defaulted)
+        if partly_defaulted && default_block?(block)
+          return { "required" => false, "type" => Slot.dynamic("inferred", Parameters::UNDECLARED) }
+        end
+
+        { "required" => block.required, "type" => Slot.from_rbs(block_type(block), provenance, path) }
+      end
+
+      def default_block?(block)
+        !block.required && block.type.is_a?(::RBS::Types::UntypedFunction) && block.self_type.nil? &&
+          block.type.return_type.is_a?(::RBS::Types::Bases::Any)
+      end
+
       def params_of(function, provenance, path)
         (positional_params(function) + keyword_params(function)).map do |kind, name, param|
           { "name" => name&.to_s, "kind" => kind, "type" => Slot.from_rbs(param.type.to_s, provenance, path) }

data/lib/rigor/lens/document.rb

@@ -5,13 +5,14 @@ require "json"
 require_relative "../version"
 require_relative "../cache/engine_source"
 require_relative "../analysis/run_cache_key"
+require_relative "../rooted_glob"
 
 module Rigor
   module Lens
     # Assembles the `lens/v0` document (docs/internal-spec/lens.md § Document) from a {Run::Outcome}.
     class Document
-      SITE_FIELDS = %w[key kind name owner scope attribute members ordinal span contract_span anchor visibility
-                       contract params block body_return].freeze
+      SITE_FIELDS = %w[key kind name owner scope attribute members module_function builder ordinal span contract_span
+                       anchor visibility contract params block body_return value alias_of].freeze
 
       def initialize(outcome:, configuration:, root:, config_path:)
         @outcome = outcome
@@ -60,7 +61,7 @@ module Rigor
       end
 
       def signature_digest
-        listing = signature_roots.flat_map { |root| Dir.glob(File.join(root, "**", "*.rbs")) }.sort.map do |path|
+        listing = signature_roots.flat_map { |root| RootedGlob.glob(root, "**/*.rbs") }.sort.map do |path|
           "#{relative(path)}\t#{Lens.digest(File.binread(path))}\n"
         end
         Lens.digest(listing.join)