rigortype 0.1.12 → 0.1.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 182bad9de02b3b4579fe1c385fa740e30f2df85cad36d8c21647dfb09004b9eb
-  data.tar.gz: 398d4ebc670530522696122117592bd59b60d7f899ae0a8cd58b11c8506ec608
+  metadata.gz: b1dbcd9b168a06cc8d5f26e0a096f19496c3cebdc8864fb56d966741b8a42577
+  data.tar.gz: 39e428c763e8d8cac6d9743d40d5d654bfaec56362d41e338a6dac974dff27cf
 SHA512:
-  metadata.gz: abd25775ea4973023dc7ef7132669a0bf556604c7378caef60aa3c2fbae4ef79bc2651cd3499cecb8046507214dbdc4cb56bdb953c301ec42b0ebb86291202b6
-  data.tar.gz: 9281f16a4b2d39847aaaf408844920dfb9f2e6a914df3544182d6d3832f28f03ca63d8a19aa54ca80977f3431351717a59d7ba704f3361ee92697be21d6193ab
+  metadata.gz: 6cd6a4d0b52fcd2e1e2bacddd6120154ccbe075ef86615c38d7e6d1d942ea158f55abaeb03f01c0a23315a187076912315af98ce74faa4c174c4f6c5c98eac74
+  data.tar.gz: 1d7b600e3dd97a38bf1ac08231a7aa07635210723adf349c014d9100ccc2b0a868deb8a6479d99207e1c0b5e4cf07c158f0f0cb3bda325ec5c7d143e4f5ae90b

data/README.md

@@ -49,8 +49,18 @@ Rigor is a tool, not a library — install it independently, **not** in
 your project's `Gemfile`. It runs on Ruby 4.0, regardless of which Ruby
 version your project targets.
 
-The recommended setup uses [`mise`](https://mise.jdx.dev/), which
-provisions both Ruby 4.0 and Rigor pinned per project:
+**Using an AI coding agent?** Hand it this prompt and it will detect
+your environment, install Rigor, and kick off the project-init Skill
+automatically:
+
+```
+Install Rigor in this project by following the instructions at
+https://raw.githubusercontent.com/rigortype/rigor/refs/heads/master/docs/install.md
+```
+
+**Manual install** — the recommended path uses
+[`mise`](https://mise.jdx.dev/), which provisions both Ruby 4.0 and
+Rigor pinned per project:
 
 ```sh
 mise use ruby@4.0

data/lib/rigor/analysis/check_rules.rb

@@ -57,6 +57,7 @@ module Rigor
       # system; new rules MUST register here so user configuration
       # can refer to them.
       RULE_UNDEFINED_METHOD = "call.undefined-method"
+      RULE_UNRESOLVED_TOPLEVEL = "call.unresolved-toplevel"
       RULE_WRONG_ARITY = "call.wrong-arity"
       RULE_ARGUMENT_TYPE = "call.argument-type-mismatch"
       RULE_NIL_RECEIVER = "call.possible-nil-receiver"
@@ -72,6 +73,7 @@ module Rigor
 
       ALL_RULES = [
         RULE_UNDEFINED_METHOD,
+        RULE_UNRESOLVED_TOPLEVEL,
         RULE_WRONG_ARITY,
         RULE_ARGUMENT_TYPE,
         RULE_NIL_RECEIVER,
@@ -162,6 +164,7 @@ module Rigor
       def call_node_diagnostics(path, node, scope_index)
         [
           undefined_method_diagnostic(path, node, scope_index),
+          unresolved_toplevel_diagnostic(path, node, scope_index),
           wrong_arity_diagnostic(path, node, scope_index),
           argument_type_diagnostic(path, node, scope_index),
           nil_receiver_diagnostic(path, node, scope_index),
@@ -365,10 +368,14 @@ module Rigor
           return nil if open_receiver?(class_name, scope)
 
           # Slice 7 phase 12 — suppress when the user has
-          # declared the method in source (instance `def`,
-          # `def self.foo`, or recognised `define_method`).
+          # declared the method in source (`def` /
+          # `define_method`) OR in a `pre_eval:` monkey-patch
+          # file (ADR-17). Both paths are project-side method
+          # contributions the dispatcher already resolved; the
+          # rule must not surface a false `undefined-method`
+          # for them.
           kind = receiver_type.is_a?(Type::Singleton) ? :singleton : :instance
-          return nil if scope.discovered_method?(class_name, call_node.name, kind)
+          return nil if source_declared_method?(scope, class_name, call_node.name, kind)
 
           return nil unless Rigor::Reflection.rbs_class_known?(class_name, scope: scope)
 
@@ -404,6 +411,92 @@ module Rigor
           scope.environment.rbs_module?(receiver_type.class_name)
         end
 
+        # Combined suppression probe for `undefined-method` /
+        # `unresolved-toplevel`. Returns true when the method is
+        # declared by any project-side contributor the dispatcher
+        # already resolves: an in-source `def` / `define_method`
+        # (`scope.discovered_method?`) OR an ADR-17 `pre_eval:`
+        # monkey-patch (`Environment#project_patched_methods`).
+        # Both paths sit at the same dispatcher precedence; the
+        # check must hold them together so neither rule fires a
+        # false positive.
+        def source_declared_method?(scope, class_name, method_name, kind)
+          return true if scope.discovered_method?(class_name, method_name, kind)
+
+          project_patched_method?(scope, class_name, method_name, kind)
+        end
+
+        # ADR-17 § "Inference contract" — consults
+        # `Environment#project_patched_methods` so a `def` declared
+        # in a `pre_eval:` file suppresses the diagnostic at the
+        # same dispatcher precedence the registry holds for type
+        # inference (between plugins and dependency-source).
+        # Returns false when the environment carries no registry
+        # (legacy path) or the lookup misses.
+        def project_patched_method?(scope, class_name, method_name, kind)
+          environment = scope.environment
+          registry = environment&.project_patched_methods
+          return false if registry.nil? || registry.empty?
+
+          !registry.lookup(class_name: class_name.to_s, method_name: method_name.to_sym, kind: kind).nil?
+        end
+
+        # ADR-34 — `call.unresolved-toplevel`. Fires on an
+        # implicit-self call (no explicit receiver) at toplevel
+        # scope (`scope.toplevel?`, i.e. outside any class /
+        # module body) whose name does not resolve against:
+        #
+        # 1. A same-file toplevel `def` via
+        #    {Scope#top_level_def_for}.
+        # 2. The ADR-17 `ProjectPatchedMethods` registry under
+        #    `(Object, name, :instance)` — projects declare
+        #    their toplevel-injecting monkey-patches in
+        #    `.rigor.yml`'s `pre_eval:` array as the canonical
+        #    opt-out per ADR-34 WD2.
+        # 3. The standard `Kernel` / `Object` private-method
+        #    surface (`puts`, `p`, `require`, `loop`, `raise`,
+        #    …) drawn from the loaded RBS environment.
+        #
+        # The rule deliberately does NOT generalise to
+        # implicit-self calls inside `def` / `class` / `module`
+        # bodies — ADR-24 WD3's lenient-on-unresolved default
+        # stays in force there. ADR-24 WD4's gated class-body
+        # diagnostic is a separate decision this ADR does not
+        # open.
+        #
+        # Authored severity is `:warning`; the severity profile
+        # remaps it (`strict` → `:error`, `balanced` →
+        # `:warning`, `lenient` → `:off` / suppressed).
+        def unresolved_toplevel_diagnostic(path, call_node, scope_index)
+          return nil unless call_node.receiver.nil?
+
+          scope = scope_index[call_node]
+          return nil if scope.nil?
+          return nil unless scope.toplevel?
+
+          name = call_node.name
+          return nil if scope.top_level_def_for(name)
+          return nil if source_declared_method?(scope, "Object", name, :instance)
+          return nil if Rigor::Reflection.instance_method_definition("Object", name, scope: scope)
+
+          build_unresolved_toplevel_diagnostic(path, call_node)
+        end
+
+        def build_unresolved_toplevel_diagnostic(path, call_node)
+          location = call_node.message_loc || call_node.location
+          Diagnostic.new(
+            path: path,
+            line: location.start_line,
+            column: location.start_column + 1,
+            message: "unresolved toplevel call to `#{call_node.name}`. " \
+                     "If a project file defines `#{call_node.name}` via a toplevel " \
+                     "`def` or a monkey-patch on Object/Kernel, list that file in " \
+                     "`.rigor.yml`'s `pre_eval:` (ADR-17) so the analyzer sees it.",
+            severity: :warning,
+            rule: RULE_UNRESOLVED_TOPLEVEL
+          )
+        end
+
         # Returns a qualified class name for the in-scope check.
         # Nominal / Singleton carry a single-class identity
         # directly. Constant projects to its value's class.

data/lib/rigor/cli/skill_command.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module Rigor
+  class CLI
+    # `rigor skill` — discover and print the SKILL.md files
+    # bundled with the `rigortype` gem.
+    #
+    # Rigor ships a small set of Agent Skills under `skills/` that
+    # walk an AI coding agent through onboarding (`rigor-project-init`),
+    # baseline reduction (`rigor-baseline-reduce`), and authoring a
+    # plugin (`rigor-plugin-author`). When Rigor is installed via
+    # `mise` / `gem install` / etc. the SKILL files live inside the
+    # gem checkout — the project being analysed has no copy, so an
+    # AI agent has no a priori way to find them.
+    #
+    # This command exposes the bundled skills via three subcommands:
+    #
+    # - `rigor skill list`         — table of name + absolute path.
+    # - `rigor skill print <name>` — short header (paths + how to use)
+    #                                followed by the SKILL.md body. This
+    #                                is the form AI agents should call;
+    #                                the inline body plus the header's
+    #                                absolute paths together let the
+    #                                agent act with or without a file
+    #                                reading tool.
+    # - `rigor skill path <name>`  — one-line absolute path, suitable
+    #                                as input to a Read tool.
+    #
+    # `rigor skill` with no subcommand is an alias for `list`.
+    class SkillCommand
+      USAGE = <<~USAGE
+        Usage: rigor skill <subcommand> [args]
+
+        Subcommands:
+          list                  List bundled skills (default when no subcommand given)
+          print <name>          Print the SKILL.md body for <name> to stdout, with a header
+          path  <name>          Print the absolute path of the SKILL.md file for <name>
+
+        Examples:
+          rigor skill list
+          rigor skill print rigor-project-init
+          rigor skill path  rigor-baseline-reduce
+      USAGE
+
+      # The bundled skills live at `<gem_root>/skills/`. From
+      # `lib/rigor/cli/skill_command.rb` that is three directories up.
+      SKILLS_ROOT = File.expand_path("../../../skills", __dir__)
+
+      def initialize(argv:, out: $stdout, err: $stderr)
+        @argv = argv
+        @out = out
+        @err = err
+      end
+
+      # @return [Integer] CLI exit status.
+      def run
+        subcommand = @argv.shift || "list"
+
+        case subcommand
+        when "list" then run_list
+        when "print" then run_print
+        when "path" then run_path
+        when "-h", "--help", "help"
+          print_usage(@out)
+          0
+        else
+          @err.puts("Unknown subcommand: #{subcommand}")
+          print_usage(@err)
+          Rigor::CLI::EXIT_USAGE
+        end
+      end
+
+      private
+
+      def run_list
+        skills = discover_skills
+        if skills.empty?
+          @err.puts("No bundled skills found under #{SKILLS_ROOT}")
+          return 1
+        end
+
+        width = skills.map { |s| s.fetch(:name).length }.max
+        skills.each do |skill|
+          @out.puts(format("%-#{width}s  %s", skill.fetch(:name), skill.fetch(:path)))
+        end
+        0
+      end
+
+      def run_print
+        name = @argv.shift
+        return usage_error("`print` requires a skill name") if name.nil?
+
+        skill = find_skill(name)
+        return name_error(name) if skill.nil?
+
+        @out.puts(render_print_header(skill))
+        @out.puts
+        @out.write(File.read(skill.fetch(:path)))
+        0
+      end
+
+      def run_path
+        name = @argv.shift
+        return usage_error("`path` requires a skill name") if name.nil?
+
+        skill = find_skill(name)
+        return name_error(name) if skill.nil?
+
+        @out.puts(skill.fetch(:path))
+        0
+      end
+
+      # The header that precedes the SKILL.md body when an agent
+      # runs `rigor skill print <name>`. Kept as `# `-prefixed
+      # comment lines so the combined output remains parseable as
+      # markdown — anything below `---` (the SKILL frontmatter
+      # marker) is unchanged.
+      def render_print_header(skill)
+        references_dir = File.join(File.dirname(skill.fetch(:path)), "references")
+        ref_line = if File.directory?(references_dir)
+                     "# References: #{references_dir}/  (read referenced `references/NN-*.md` files from here)"
+                   else
+                     "# References: (none)"
+                   end
+        <<~HEADER.chomp
+          # Rigor skill: #{skill.fetch(:name)}
+          # Source:     #{skill.fetch(:path)}
+          #{ref_line}
+          #
+          # The body below is the canonical SKILL definition shipped with
+          # rigortype #{Rigor::VERSION}. Follow its instructions.
+        HEADER
+      end
+
+      def discover_skills
+        return [] unless File.directory?(SKILLS_ROOT)
+
+        Dir.children(SKILLS_ROOT).sort.filter_map do |name|
+          skill_md = File.join(SKILLS_ROOT, name, "SKILL.md")
+          next unless File.file?(skill_md)
+
+          { name: name, path: skill_md }
+        end
+      end
+
+      def find_skill(name)
+        discover_skills.find { |s| s.fetch(:name) == name }
+      end
+
+      def name_error(name)
+        @err.puts("Unknown skill: #{name}")
+        @err.puts("Available skills:")
+        discover_skills.each { |s| @err.puts("  #{s.fetch(:name)}") }
+        1
+      end
+
+      def usage_error(message)
+        @err.puts(message)
+        print_usage(@err)
+        Rigor::CLI::EXIT_USAGE
+      end
+
+      def print_usage(io)
+        io.puts(USAGE)
+      end
+    end
+  end
+end

data/lib/rigor/cli.rb

@@ -33,7 +33,8 @@ module Rigor
       "triage" => :run_triage,
       "coverage" => :run_coverage,
       "plugins" => :run_plugins,
-      "playground" => :run_playground
+      "playground" => :run_playground,
+      "skill" => :run_skill
     }.freeze
 
     def self.start(argv = ARGV, out: $stdout, err: $stderr)
@@ -635,6 +636,12 @@ module Rigor
       Rigor::CLI::PlaygroundCommand.new(@argv[1..], @out, @err).run
     end
 
+    def run_skill
+      require_relative "cli/skill_command"
+
+      CLI::SkillCommand.new(argv: @argv, out: @out, err: @err).run
+    end
+
     def write_result(result, format)
       case format
       when "json"
@@ -682,6 +689,7 @@ module Rigor
           coverage   Report type-precision coverage (precise vs Dynamic ratio)
           plugins    Report activation status of every configured plugin
           playground Start the browser playground (requires rigor-playground gem)
+          skill      List or print bundled Agent Skills (rigor-project-init, ...)
           version    Print the Rigor version
           help       Print this help
       HELP

data/lib/rigor/configuration/severity_profile.rb

@@ -39,6 +39,7 @@ module Rigor
       PROFILES = {
         lenient: {
           "call.undefined-method" => :error,
+          "call.unresolved-toplevel" => :off,
           "call.wrong-arity" => :error,
           "call.argument-type-mismatch" => :warning,
           "call.possible-nil-receiver" => :warning,
@@ -54,6 +55,7 @@ module Rigor
         }.freeze,
         balanced: {
           "call.undefined-method" => :error,
+          "call.unresolved-toplevel" => :warning,
           "call.wrong-arity" => :error,
           "call.argument-type-mismatch" => :error,
           "call.possible-nil-receiver" => :error,
@@ -69,6 +71,7 @@ module Rigor
         }.freeze,
         strict: {
           "call.undefined-method" => :error,
+          "call.unresolved-toplevel" => :error,
           "call.wrong-arity" => :error,
           "call.argument-type-mismatch" => :error,
           "call.possible-nil-receiver" => :error,

data/lib/rigor/environment/rbs_collection_discovery.rb

@@ -34,6 +34,20 @@ module Rigor
       # `sig/`), and `local` (a user-managed RBS dir) — all
       # produce a directory under the collection root and are
       # admitted.
+      #
+      # The `source.type` filter alone is NOT sufficient: gems
+      # that were extracted from Ruby's stdlib into standalone
+      # default gems (e.g. `cgi`, `logger`, `base64`, `csv`,
+      # `bigdecimal`) are published in `ruby/gem_rbs_collection`
+      # under a `git` source type, yet rigor ALSO loads them
+      # from its bundled stdlib via `DEFAULT_LIBRARIES`. Loading
+      # both copies triggers the very
+      # `RBS::DuplicatedDeclarationError` this module exists to
+      # avoid (observed on a Rails 8 app: `.gem_rbs_collection/
+      # cgi/0.5/` vs the bundled `stdlib/cgi`). The
+      # `skip_gem_names:` parameter lets the caller pass the set
+      # of library names rigor already loads so those gems are
+      # dropped regardless of `source.type`.
       SKIPPED_SOURCE_TYPES = Set["stdlib"].freeze
 
       DEFAULT_COLLECTION_PATH = ".gem_rbs_collection"
@@ -47,14 +61,21 @@ module Rigor
       # @param auto_detect [Boolean] when true and
       #   `lockfile_path:` is nil, look for
       #   `<project_root>/rbs_collection.lock.yaml`.
+      # @param skip_gem_names [Array<String>, Set<String>] gem
+      #   names rigor already loads from its bundled stdlib (the
+      #   merged `DEFAULT_LIBRARIES + libraries:` set). Entries
+      #   whose `name` is in this set are dropped regardless of
+      #   `source.type` to avoid `RBS::DuplicatedDeclarationError`
+      #   on stdlib-extracted default gems. Defaults to empty.
       # @return [Array<Pathname>] every
       #   `<collection_path>/<gem-name>/<gem-version>/`
       #   directory listed in the lockfile whose entry has a
-      #   non-skipped source type and whose directory exists on
-      #   disk. Returns `[]` when no lockfile is resolvable,
-      #   when the YAML is unreadable, or when the collection
-      #   path doesn't exist.
-      def self.discover(lockfile_path:, project_root: Dir.pwd, auto_detect: true)
+      #   non-skipped source type, whose `name` is not in
+      #   `skip_gem_names:`, and whose directory exists on disk.
+      #   Returns `[]` when no lockfile is resolvable, when the
+      #   YAML is unreadable, or when the collection path
+      #   doesn't exist.
+      def self.discover(lockfile_path:, project_root: Dir.pwd, auto_detect: true, skip_gem_names: [])
         resolved = resolve_lockfile_path(
           lockfile_path: lockfile_path,
           project_root: project_root,
@@ -68,7 +89,7 @@ module Rigor
         collection_root = resolve_collection_root(resolved, data)
         return [] unless collection_root.directory?
 
-        gem_paths_from(collection_root, data)
+        gem_paths_from(collection_root, data, skip_gem_names.to_set)
       end
 
       # Returns the resolved lockfile path (`Pathname`) or `nil`
@@ -105,7 +126,7 @@ module Rigor
       end
       private_class_method :resolve_collection_root
 
-      def self.gem_paths_from(collection_root, data)
+      def self.gem_paths_from(collection_root, data, skip_gem_names)
         Array(data["gems"]).filter_map do |entry|
           next unless entry.is_a?(Hash)
 
@@ -115,6 +136,7 @@ module Rigor
           name = entry["name"]
           version = entry["version"]
           next if name.nil? || version.nil?
+          next if skip_gem_names.include?(name.to_s)
 
           gem_root = collection_root + name.to_s + version.to_s
           gem_root if gem_root.directory?

data/lib/rigor/environment/rbs_loader.rb

@@ -122,6 +122,23 @@ module Rigor
             Pathname(File.join(VENDORED_GEM_SIGS_ROOT, gem_dir))
           end
         end
+
+        # Gem names whose RBS ships under
+        # `data/vendored_gem_sigs/<gem>/`. The directory walk is
+        # the source of truth (the `README.md` sibling is not a
+        # gem and is excluded). Callers building the RBS env use
+        # this set to drop the matching `rbs collection install`
+        # directory before it double-declares against the
+        # vendored copy — the same hazard `DEFAULT_LIBRARIES`
+        # creates for stdlib-extracted gems. See
+        # `RbsCollectionDiscovery`'s `skip_gem_names:`.
+        def vendored_gem_names
+          return [] unless File.directory?(VENDORED_GEM_SIGS_ROOT)
+
+          Dir.children(VENDORED_GEM_SIGS_ROOT).reject do |child|
+            File.file?(File.join(VENDORED_GEM_SIGS_ROOT, child))
+          end
+        end
       end
 
       attr_reader :libraries, :signature_paths, :cache_store, :virtual_rbs

data/lib/rigor/environment.rb

@@ -263,11 +263,22 @@ module Rigor
         # resulting `rbs_collection.lock.yaml` and feed each
         # gem's `<collection_path>/<name>/<version>/` directory
         # into `signature_paths:`. Stdlib-typed entries are
-        # skipped (already covered by `DEFAULT_LIBRARIES`).
+        # skipped (already covered by `DEFAULT_LIBRARIES`), as
+        # are gems whose RBS rigor already loads from another
+        # source — stdlib-extracted default gems (`cgi`,
+        # `logger`, …, shipped by the collection under a `git`
+        # source) and the `data/vendored_gem_sigs/` bundle
+        # (`redis`, `nokogiri`, `pg`, …). `skip_gem_names:`
+        # passes both sets so the collection copy doesn't
+        # double-declare against rigor's bundled RBS (the
+        # `RBS::DuplicatedDeclarationError` hazard).
+        merged_libraries = (DEFAULT_LIBRARIES + libraries.map(&:to_s)).uniq
+        skip_gem_names = merged_libraries + RbsLoader.vendored_gem_names
         collection_paths = RbsCollectionDiscovery.discover(
           lockfile_path: rbs_collection_lockfile,
           project_root: root,
-          auto_detect: rbs_collection_auto_detect
+          auto_detect: rbs_collection_auto_detect,
+          skip_gem_names: skip_gem_names
         ).map(&:to_s)
         # ADR-25 — RBS signature directories contributed by loaded
         # plugins via their manifest `signature_paths:`. Resolved
@@ -278,7 +289,6 @@ module Rigor
         # degrades through the same O7 failure-memo path.
         plugin_sig_paths = plugin_registry ? plugin_registry.signature_paths.map(&:to_s) : []
         loader_signature_paths = resolved_paths + plugin_sig_paths + gem_sig_paths + collection_paths
-        merged_libraries = (DEFAULT_LIBRARIES + libraries.map(&:to_s)).uniq
         # ADR-32 WD4 + WD5 — invoke each loaded plugin's
         # `source_rbs_synthesizer` once per project source file
         # and collect non-nil `[filename, rbs_source]` pairs.

data/lib/rigor/scope.rb

@@ -309,6 +309,20 @@ module Rigor
       table[method_name.to_sym] == kind
     end
 
+    # ADR-34 § "Decision" — predicate identifying a toplevel-shaped
+    # scope (no enclosing `class` / `module` body). True at the top
+    # of a file AND inside a top-level `def` body (since toplevel
+    # defs leave `self_type` nil per the existing scope-construction
+    # contract, mirroring how ADR-24's `adoptable_self_call_result?`
+    # also keys on `self_type.nil?` for the same context). Used by
+    # `CheckRules#unresolved_toplevel_diagnostic` to gate the
+    # `call.unresolved-toplevel` rule so it fires only outside
+    # class / module bodies, where Rails-DSL metaprogramming
+    # leniency (ADR-24 WD3 → WD4) does not apply.
+    def toplevel?
+      @self_type.nil?
+    end
+
     def with_discovered_methods(table)
       rebuild(discovered_methods: table)
     end

data/lib/rigor/version.rb

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

data/sig/rigor/environment.rbs

@@ -51,6 +51,7 @@ module Rigor
       def self.reset_default!: () -> void
       def self.build_env_for: (libraries: Array[String], signature_paths: Array[String | _ToPath]) -> untyped
       def self.vendored_gem_sig_paths: () -> Array[Pathname]
+      def self.vendored_gem_names: () -> Array[String]
 
       def initialize: (?libraries: Array[String], ?signature_paths: Array[String | _ToPath], ?cache_store: untyped?) -> void
       def class_known?: (String | Symbol name) -> bool

data/sig/rigor/scope.rbs

@@ -58,6 +58,7 @@ module Rigor
     def with_discovered_def_nodes: (Hash[String, Hash[Symbol, untyped]] table) -> Scope
     def user_def_for: (String | Symbol class_name, String | Symbol method_name) -> untyped?
     def top_level_def_for: (String | Symbol method_name) -> untyped?
+    def toplevel?: () -> bool
     def with_discovered_method_visibilities: (Hash[String, Hash[Symbol, Symbol]] table) -> Scope
     def discovered_method_visibility: (String | Symbol class_name, String | Symbol method_name) -> Symbol?
     def superclass_of: (String | Symbol class_name) -> String?