rigortype 0.1.14 → 0.1.16

data/lib/rigor/inference/budget_trace.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Inference
+    # Opt-in counters for the hard-coded inference cutoffs — the
+    # "budget" guards that silently return `Dynamic[top]` / `nil` /
+    # a fallback bound rather than emitting a diagnostic. These are
+    # the *operative* cutoffs in the engine today (the configurable
+    # `budgets:` table in docs/type-specification/inference-budgets.md
+    # is not yet wired); counting how often each fires on a real
+    # project is the only way to see where inference actually stops.
+    #
+    # Three categories, one per guard site:
+    #
+    # - {RECURSION_GUARD} — `ExpressionTyper#infer_user_method_return`
+    #   detected a `(receiver, method)` cycle and returned
+    #   `Dynamic[top]` (the de-facto recursion-depth budget, effective
+    #   depth 1).
+    # - {ANCESTOR_WALK_LIMIT} — `resolve_user_def_through_ancestors`
+    #   hit the 100-node BFS cap and gave up resolving the self-call.
+    # - {HKT_FUEL_EXHAUSTED} — `HktReducer` ran out of its reduction
+    #   fuel budget and unwound to `app.bound`.
+    #
+    # Enabled only when `RIGOR_BUDGET_TRACE` is set (to any non-empty
+    # value) in the environment, or via {enable!} in tests. When
+    # disabled, {hit} is a single boolean check and returns
+    # immediately, so normal runs pay nothing.
+    #
+    # Counters are process-global (Mutex-guarded) so they aggregate
+    # across threads, but they do NOT cross `fork` boundaries — run
+    # `rigor check --workers 0` to keep all inference in one process
+    # when collecting a trace.
+    module BudgetTrace
+      RECURSION_GUARD = :recursion_guard
+      ANCESTOR_WALK_LIMIT = :ancestor_walk_limit
+      HKT_FUEL_EXHAUSTED = :hkt_fuel_exhausted
+
+      CATEGORIES = [RECURSION_GUARD, ANCESTOR_WALK_LIMIT, HKT_FUEL_EXHAUSTED].freeze
+
+      # Distribution (histogram) categories — read-only observations of
+      # a value's size at a site, used to choose budget defaults from an
+      # observed tail rather than a guess (ADR-41 WD3 / Slice 2a). No cap
+      # is enforced; these only record. `UNION_ARITY` is the member count
+      # of every `Type::Union` that `Combinator.union` produces — the
+      # distribution the `union_size` budget default should be set from.
+      UNION_ARITY = :union_arity
+
+      DISTRIBUTION_CATEGORIES = [UNION_ARITY].freeze
+
+      @enabled = !ENV["RIGOR_BUDGET_TRACE"].to_s.empty?
+      @mutex = Mutex.new
+      @counts = Hash.new(0)
+      @distributions = Hash.new { |h, k| h[k] = Hash.new(0) }
+
+      module_function
+
+      def enabled?
+        @enabled
+      end
+
+      # Test / programmatic toggles. Production enablement is the
+      # `RIGOR_BUDGET_TRACE` env var read once at load time.
+      def enable!
+        @enabled = true
+      end
+
+      def disable!
+        @enabled = false
+      end
+
+      # Records one firing of `category`. No-op (one boolean check)
+      # when tracing is disabled.
+      def hit(category)
+        return unless @enabled
+
+        @mutex.synchronize { @counts[category] += 1 }
+      end
+
+      # Frozen snapshot of the current counts, every known category
+      # present (zero-filled) so consumers can render a stable table.
+      def snapshot
+        @mutex.synchronize do
+          CATEGORIES.to_h { |category| [category, @counts[category]] }.freeze
+        end
+      end
+
+      # Records one observation of `value` (an Integer size) into
+      # `category`'s histogram. No-op (one boolean check) when disabled.
+      def observe(category, value)
+        return unless @enabled
+
+        @mutex.synchronize { @distributions[category][value] += 1 }
+      end
+
+      # Frozen `{value => count}` histogram for a distribution category.
+      def distribution(category)
+        @mutex.synchronize { @distributions[category].dup.freeze }
+      end
+
+      # Summary of a distribution category: total observation count, max
+      # observed value, selected percentiles, and how many observations
+      # met or exceeded each threshold in `over`. Percentiles use the
+      # nearest-rank method over the expanded sample.
+      def summarize(category, over: [])
+        hist = distribution(category)
+        total = hist.values.sum
+        return { count: 0, max: 0, percentiles: {}, over: over.to_h { |t| [t, 0] } } if total.zero?
+
+        sorted = hist.keys.sort
+        { count: total,
+          max: sorted.last,
+          percentiles: { p50: percentile(hist, total, 0.50), p90: percentile(hist, total, 0.90),
+                         p99: percentile(hist, total, 0.99) },
+          over: over.to_h { |t| [t, hist.sum { |value, n| value >= t ? n : 0 }] } }
+      end
+
+      # Nearest-rank percentile over a `{value => count}` histogram
+      # without materialising the full sample.
+      def percentile(hist, total, fraction)
+        rank = (fraction * total).ceil
+        cumulative = 0
+        hist.keys.sort.each do |value|
+          cumulative += hist[value]
+          return value if cumulative >= rank
+        end
+        hist.keys.max
+      end
+
+      def reset
+        @mutex.synchronize do
+          @counts.clear
+          @distributions.clear
+        end
+      end
+    end
+  end
+end

data/lib/rigor/inference/expression_typer.rb

@@ -5,6 +5,7 @@ require "prism"
 require_relative "../type"
 require_relative "../ast"
 require_relative "block_parameter_binder"
+require_relative "budget_trace"
 require_relative "fallback"
 require_relative "indexed_narrowing"
 require_relative "macro_block_self_type"
@@ -1358,7 +1359,10 @@ module Rigor
 
           seen[current] = true
           visited += 1
-          return nil if visited > ANCESTOR_WALK_LIMIT
+          if visited > ANCESTOR_WALK_LIMIT
+            BudgetTrace.hit(BudgetTrace::ANCESTOR_WALK_LIMIT)
+            return nil
+          end
 
           found = scope.user_def_for(current, method_name)
           return found if found
@@ -1432,7 +1436,10 @@ module Rigor
         # carrier for top-level / DSL-block defs) printable.
         signature = [receiver.describe(:short), def_node.name]
         stack = (Thread.current[INFERENCE_GUARD_KEY] ||= [])
-        return Type::Combinator.untyped if stack.include?(signature)
+        if stack.include?(signature)
+          BudgetTrace.hit(BudgetTrace::RECURSION_GUARD)
+          return Type::Combinator.untyped
+        end
 
         stack.push(signature)
         begin

data/lib/rigor/inference/hkt_reducer.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "hkt_body"
+require_relative "budget_trace"
 
 module Rigor
   module Inference
@@ -71,6 +72,7 @@ module Rigor
             walk(definition.body_tree, bindings: bindings_for(definition, app.args), state: state) || app.bound
           end
         rescue FuelExhausted
+          BudgetTrace.hit(BudgetTrace::HKT_FUEL_EXHAUSTED)
           app.bound
         end
       end

data/lib/rigor/inference/method_dispatcher/overload_selector.rb

@@ -115,14 +115,31 @@ module Rigor
           # overload-list position.
           overloads = ReceiverAffinity.reorder(overloads, self_type: self_type, environment: environment)
 
-          match = run_selection_passes(
-            overloads, arg_types: arg_types, self_type: self_type, instance_type: instance_type,
-                       type_vars: type_vars, block_required: block_required, param_overrides: param_overrides
-          )
+          passes = lambda do |require_block|
+            run_selection_passes(
+              overloads, arg_types: arg_types, self_type: self_type, instance_type: instance_type,
+                         type_vars: type_vars, block_required: require_block, param_overrides: param_overrides
+            )
+          end
+
+          match = passes.call(block_required)
           return match if match
-          return overloads.find { |mt| overload_has_block?(mt) } if block_required
 
-          # No block at the call site: prefer an overload that does
+          # A block at the call site that no block-declaring overload
+          # matched: Ruby ignores a block handed to a method that never
+          # yields it, so retry treating the block as ignorable rather
+          # than failing the dispatch. Without this, a block-bearing
+          # call to a method whose RBS declares no block (e.g.
+          # `define_command(:x) do … end` against
+          # `def define_command: (Symbol) -> Symbol`) degraded to
+          # `Dynamic[Top]` — and on a self-send suppressed the whole
+          # method's return type.
+          if block_required
+            match = passes.call(false)
+            return match if match
+          end
+
+          # No (usable) block at the call site: prefer an overload that does
           # not REQUIRE a block over `overloads.first`. Methods like
           # `Array#filter` / `Enumerable#map` declare the block-
           # bearing overload first (`() { ... } -> Array[Elem]`) and

data/lib/rigor/inference/method_dispatcher/rbs_dispatch.rb

@@ -64,6 +64,19 @@ module Rigor
       module RbsDispatch
         module_function
 
+        # ADR-43 — ancestor classes whose RBS is authoritative and
+        # COMPLETE, so a call a subclass makes that the ancestor's RBS
+        # does not declare is a genuine mistake rather than a gap.
+        # Membership unlocks inherited-method resolution (and thus
+        # `call.undefined-method`) for Ruby-source subclasses of these
+        # classes; every other RBS ancestor stays on the Dynamic
+        # fallback. Seeded with the plugin contract base — this repo
+        # owns both the class and `sig/rigor/plugin/base.rbs`, and the
+        # `lib` self-check keeps them in lock-step. NOT a place for
+        # third-party/core classes whose objects answer to methods
+        # their RBS omits (`ActionController::Base`, `Hash`, …).
+        ALLOWED_RBS_COMPLETE_ANCESTORS = ["Rigor::Plugin::Base"].freeze
+
         # @param receiver [Rigor::Type]
         # @param method_name [Symbol]
         # @param args [Array<Rigor::Type>]
@@ -94,8 +107,19 @@ module Rigor
         # @return [Rigor::Type, nil] inferred return type, or `nil`
         #   when no rule resolves (no class name, no method, dispatch
         #   on a Top/Dynamic[Top] receiver, etc.).
-        def try_dispatch(receiver:, method_name:, args:, environment:, block_type: nil, self_type_override: nil,
-                         public_only: false)
+        # @param scope [Rigor::Scope, nil] when supplied, enables
+        #   ADR-43 RBS-complete-ancestor resolution: a call on a
+        #   Ruby-source subclass not known to RBS, whose discovered
+        #   superclass chain reaches an allow-listed RBS-complete
+        #   ancestor (e.g. `Rigor::Plugin::Base`), resolves against
+        #   that ancestor's RBS. `nil` (the default for every caller
+        #   that does not thread a scope) keeps the legacy behaviour —
+        #   such an inherited call stays unresolved and degrades to
+        #   `Dynamic[Top]`, which is the false-positive-safe default
+        #   for the open hierarchies (`< ActionController::Base`, …)
+        #   the allow-list deliberately excludes.
+        def try_dispatch(receiver:, method_name:, args:, environment:, block_type: nil, self_type_override: nil, # rubocop:disable Metrics/ParameterLists
+                         public_only: false, scope: nil)
           return nil if environment.nil?
           return nil unless environment.rbs_loader
 
@@ -106,7 +130,8 @@ module Rigor
             environment: environment,
             block_type: block_type,
             self_type_override: self_type_override,
-            public_only: public_only
+            public_only: public_only,
+            scope: scope
           )
         end
 
@@ -148,37 +173,37 @@ module Rigor
         class << self
           private
 
-          def dispatch_for(receiver:, method_name:, args:, environment:, block_type:, self_type_override: nil,
-                           public_only: false)
+          def dispatch_for(receiver:, method_name:, args:, environment:, block_type:, self_type_override: nil, # rubocop:disable Metrics/ParameterLists
+                           public_only: false, scope: nil)
             args ||= []
             case receiver
             when Type::Union
               dispatch_union(receiver, method_name, args, environment, block_type, self_type_override,
-                             public_only: public_only)
+                             public_only: public_only, scope: scope)
             else
               dispatch_one(receiver, method_name, args, environment, block_type, self_type_override,
-                           public_only: public_only)
+                           public_only: public_only, scope: scope)
             end
           end
 
-          def dispatch_union(receiver, method_name, args, environment, block_type, self_type_override = nil,
-                             public_only: false)
+          def dispatch_union(receiver, method_name, args, environment, block_type, self_type_override = nil, # rubocop:disable Metrics/ParameterLists
+                             public_only: false, scope: nil)
             results = receiver.members.map do |member|
               dispatch_one(member, method_name, args, environment, block_type, self_type_override,
-                           public_only: public_only)
+                           public_only: public_only, scope: scope)
             end
             return nil if results.any?(&:nil?)
 
             Type::Combinator.union(*results)
           end
 
-          def dispatch_one(receiver, method_name, args, environment, block_type, self_type_override = nil,
-                           public_only: false)
+          def dispatch_one(receiver, method_name, args, environment, block_type, self_type_override = nil, # rubocop:disable Metrics/ParameterLists
+                           public_only: false, scope: nil)
             descriptor = receiver_descriptor(receiver)
             return nil unless descriptor
 
             class_name, kind, receiver_args = descriptor
-            method_definition = lookup_method(environment, class_name, kind, method_name)
+            method_definition = lookup_method(environment, class_name, kind, method_name, scope)
             return nil unless method_definition
             return nil if public_only && method_private?(method_definition)
 
@@ -267,7 +292,26 @@ module Rigor
               method_definition.accessibility == :private
           end
 
-          def lookup_method(environment, class_name, kind, method_name)
+          def lookup_method(environment, class_name, kind, method_name, scope = nil)
+            direct = lookup_method_on(environment, class_name, kind, method_name)
+            return direct if direct
+
+            # ADR-43 — scoped inherited-method resolution. The direct
+            # lookup misses when `class_name` is a Ruby-source subclass
+            # absent from RBS (so no ancestor walk runs). If its
+            # discovered superclass chain reaches an allow-listed
+            # RBS-complete ancestor, resolve the method there so
+            # inherited contract calls (`self.manifest` on a plugin)
+            # resolve and the normal call rules apply. Bounded to the
+            # allow-list, so open hierarchies stay on the Dynamic
+            # fallback (no false positive on `< ActionController::Base`).
+            ancestor = allowed_rbs_complete_ancestor(environment, class_name, scope)
+            return nil unless ancestor
+
+            lookup_method_on(environment, ancestor, kind, method_name)
+          end
+
+          def lookup_method_on(environment, class_name, kind, method_name)
             case kind
             when :instance
               Rigor::Reflection.instance_method_definition(class_name, method_name, environment: environment)
@@ -276,6 +320,29 @@ module Rigor
             end
           end
 
+          # The first allow-listed, RBS-complete ancestor reachable from
+          # `class_name` through `scope.discovered_superclasses`, or nil.
+          # Returns nil when no scope is threaded, when `class_name` is
+          # itself RBS-known (the direct lookup already had authority),
+          # or when the discovered chain reaches no allow-listed class.
+          # The walk carries a visited set so a malformed cyclic
+          # `A < B < A` source cannot loop.
+          def allowed_rbs_complete_ancestor(environment, class_name, scope)
+            return nil if scope.nil?
+            return nil if Rigor::Reflection.rbs_class_known?(class_name, environment: environment)
+
+            supers = scope.discovered_superclasses
+            seen = {}
+            current = supers[class_name.to_s]
+            until current.nil? || seen[current]
+              return current if ALLOWED_RBS_COMPLETE_ANCESTORS.include?(current)
+
+              seen[current] = true
+              current = supers[current]
+            end
+            nil
+          end
+
           # Slice 4 phase 2d substitution map. Zips the class's
           # declared type-parameter names against the receiver's
           # `type_args`. Returns an empty hash when either side is

data/lib/rigor/inference/method_dispatcher.rb

@@ -71,7 +71,7 @@ module Rigor
       # @param environment [Rigor::Environment, nil] required for
       #   RBS-backed dispatch; when nil only constant folding can fire.
       # @return [Rigor::Type, nil] inferred result type, or `nil` for "no rule".
-      def dispatch(receiver_type:, method_name:, arg_types:, # rubocop:disable Metrics/MethodLength
+      def dispatch(receiver_type:, method_name:, arg_types:, # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
                    block_type: nil, environment: nil,
                    call_node: nil, scope: nil)
         return nil if receiver_type.nil?
@@ -94,7 +94,7 @@ module Rigor
         # consults the registry when both `call_node` and `scope`
         # are supplied — the dispatcher's own internal callers
         # (per-element block fold, etc.) skip this tier.
-        plugin_result = try_plugin_contribution(call_node, scope)
+        plugin_result = try_plugin_contribution(call_node, scope, receiver_type)
         return plugin_result if plugin_result
 
         # ADR-20 slice 3 — Rigor-bundled HKT-builtin return-
@@ -125,7 +125,7 @@ module Rigor
 
         rbs_result = RbsDispatch.try_dispatch(
           receiver: receiver_type, method_name: method_name, args: arg_types,
-          environment: environment, block_type: block_type
+          environment: environment, block_type: block_type, scope: scope
         )
         if rbs_result
           record_boundary_cross_if_applicable(receiver_type, method_name, rbs_result, environment)
@@ -187,6 +187,19 @@ module Rigor
         discovered_result = try_discovered_method(receiver_type, method_name, scope)
         return discovered_result if discovered_result
 
+        # ADR-5 robustness — synthesized-stub-type tier. When the
+        # receiver is a type Rigor invented to make an otherwise-
+        # unbuildable project signature resolve (a missing-namespace
+        # module, or a stub for a referenced-but-undeclared type like
+        # an unavailable `DRb::DRbServer`), the stub carries no methods,
+        # so an unresolved call against it would otherwise mis-fire
+        # `call.undefined-method`. Resolve it to `Dynamic[Top]` instead
+        # — the same no-false-positive contract as the dependency-
+        # source tier. Sits below every real resolution tier so a
+        # genuine signature always wins.
+        stub_result = try_synthesized_stub_type(receiver_type, environment)
+        return stub_result if stub_result
+
         # Slice 7 phase 10 — user-class ancestor fallback. When
         # the receiver is `Nominal[T]` or `Singleton[T]` for a
         # class not in the RBS environment (typically a
@@ -253,6 +266,31 @@ module Rigor
         end
       end
 
+      # ADR-5 robustness — returns `Dynamic[Top]` when the receiver is
+      # an instance or singleton of a type Rigor synthesized (a
+      # missing-namespace module or a referenced-type stub). The stub
+      # has no methods, so the call would otherwise reach the
+      # user-class fallback and surface `call.undefined-method`; the
+      # honest answer for a type Rigor invented is "unknown shape",
+      # i.e. `Dynamic[Top]`. Returns nil (declines) for any real type.
+      def try_synthesized_stub_type(receiver_type, environment)
+        return nil if environment.nil?
+
+        loader = environment.rbs_loader
+        return nil if loader.nil? || !loader.respond_to?(:synthesized_type_names)
+
+        names = loader.synthesized_type_names
+        return nil if names.empty?
+
+        class_name =
+          case receiver_type
+          when Type::Nominal, Type::Singleton then receiver_type.class_name.to_s.sub(/\A::/, "")
+          end
+        return nil unless class_name && names.include?(class_name)
+
+        Type::Combinator.untyped
+      end
+
       # ADR-2 § "Flow Contribution Bundle" / v0.1.1 Track 2
       # slice 7. Walks every loaded plugin's
       # `#flow_contribution_for(call_node:, scope:)` hook,
@@ -340,13 +378,13 @@ module Rigor
         end
       end
 
-      def try_plugin_contribution(call_node, scope)
+      def try_plugin_contribution(call_node, scope, receiver_type)
         return nil if call_node.nil? || scope.nil?
 
         registry = scope.environment&.plugin_registry
         return nil if registry.nil? || registry.empty?
 
-        contributions = collect_plugin_contributions(registry, call_node, scope)
+        contributions = collect_plugin_contributions(registry, call_node, scope, receiver_type)
         return nil if contributions.empty?
 
         FlowContribution::Merger.merge(contributions).return_type
@@ -622,12 +660,21 @@ module Rigor
         end
       end
 
-      def collect_plugin_contributions(registry, call_node, scope)
-        registry.plugins.filter_map do |plugin|
-          contribution = plugin.flow_contribution_for(call_node: call_node, scope: scope)
-          contribution.is_a?(FlowContribution) ? contribution : nil
+      # ADR-37 slice 2 — gathers each plugin's return-type contribution
+      # from BOTH the narrow `dynamic_return` DSL (receiver-gated, wrapped
+      # as a return-only `FlowContribution`) and the legacy
+      # `flow_contribution_for` escape valve, so migrated and unmigrated
+      # plugins compose through the same merger.
+      def collect_plugin_contributions(registry, call_node, scope, receiver_type)
+        registry.plugins.flat_map do |plugin|
+          contributions = []
+          legacy = plugin.flow_contribution_for(call_node: call_node, scope: scope)
+          contributions << legacy if legacy.is_a?(FlowContribution)
+          dynamic = plugin.dynamic_return_type(call_node: call_node, scope: scope, receiver_type: receiver_type)
+          contributions << FlowContribution.new(return_type: dynamic) if dynamic
+          contributions
         rescue StandardError
-          nil
+          []
         end
       end
 

data/lib/rigor/inference/precision_scanner.rb

@@ -10,7 +10,11 @@ module Rigor
     # engine recognises an AST node class (that is `CoverageScanner`'s job),
     # but whether the type it produces carries useful static information.
     #
-    # Each visited node is classified into one of eight precision tiers:
+    # Each visited *expression* node is classified into one of eight
+    # precision tiers (non-expression syntax nodes — argument /
+    # parameter lists, parameter declarations, hash pairs, statement
+    # wrappers, clause headers — are skipped; see
+    # {NON_EXPRESSION_NODE_TYPES}):
     #
     #   :constant         — Constant[T]: literal value known exactly
     #   :nominal          — Nominal/Singleton: class identity known
@@ -33,6 +37,59 @@ module Rigor
         dynamic_specific dynamic_top top
       ].freeze
 
+      # Prism node classes that do not denote a value-producing
+      # expression, so typing them is meaningless — they have no
+      # runtime value to carry a type. Counting them (they always fall
+      # to the `dynamic_top` fallback) silently diluted the precision
+      # ratio: on a real survey target (shugo/textbringer) they were
+      # ~49% of every "opaque" node, dragging the headline number ~13
+      # points below the true expression-level precision. We exclude
+      # them from BOTH numerator and denominator so the ratio measures
+      # what it claims to — the type quality of actual expressions.
+      #
+      # The set is deliberately CONSERVATIVE: only nodes that are
+      # unambiguously non-expressions in Ruby's grammar are listed —
+      # argument / parameter list containers and the parameter
+      # declarations inside them; the `key => value` pair node (its key
+      # and value are themselves walked and counted); the program /
+      # statements sequence wrappers (their value is the last child,
+      # already counted — listing them avoids double-counting); and the
+      # clause-header nodes whose body, not the header, carries the
+      # value. Anything that *could* be a value expression (`BlockNode`,
+      # `BeginNode`, `ImplicitNode`, `ParenthesesNode`, splats, …) is
+      # left in so a genuine inference gap stays visible.
+      #
+      # Compared by class NAME so a Prism version that lacks one of the
+      # newer node classes does not break loading.
+      NON_EXPRESSION_NODE_TYPES = %w[
+        Prism::ProgramNode
+        Prism::StatementsNode
+        Prism::ArgumentsNode
+        Prism::BlockArgumentNode
+        Prism::ParametersNode
+        Prism::BlockParametersNode
+        Prism::NumberedParametersNode
+        Prism::ItParametersNode
+        Prism::KeywordHashNode
+        Prism::RequiredParameterNode
+        Prism::OptionalParameterNode
+        Prism::RestParameterNode
+        Prism::KeywordRestParameterNode
+        Prism::BlockParameterNode
+        Prism::RequiredKeywordParameterNode
+        Prism::OptionalKeywordParameterNode
+        Prism::ForwardingParameterNode
+        Prism::NoKeywordsParameterNode
+        Prism::ImplicitRestNode
+        Prism::AssocNode
+        Prism::AssocSplatNode
+        Prism::WhenNode
+        Prism::InNode
+        Prism::ElseNode
+        Prism::EnsureNode
+        Prism::RescueNode
+      ].to_set.freeze
+
       TIER_RANK = TIERS.each_with_index.to_h.freeze
       private_constant :TIER_RANK
 
@@ -87,6 +144,8 @@ module Rigor
         total = 0
 
         Source::NodeWalker.each(root) do |node|
+          next if NON_EXPRESSION_NODE_TYPES.include?(node.class.name)
+
           type = scope_index[node].type_of(node)
           tier = classify(type)
           tier_counts[tier] += 1