Class: Rigor::Scope

Inherits:
Object
  • Object
show all
Defined in:
lib/rigor/scope.rb,
lib/rigor/scope/discovery_index.rb,
sig/rigor/scope.rbs

Overview

Immutable analyzer scope: holds local-variable bindings and a reference to the surrounding Environment. State changes return new scopes through explicit transition methods (#with_local). The central query is #type_of(node), the Rigor counterpart of PHPStan's $scope->getType($node).

See docs/internal-spec/inference-engine.md for the binding contract. rubocop:disable Metrics/ClassLength,Metrics/ParameterLists

Defined Under Namespace

Classes: ChainKey, DiscoveryIndex, IndexedKey

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(environment:, locals:, fact_store: Analysis::FactStore.empty, self_type: nil, ivars: EMPTY_VAR_BINDINGS, cvars: EMPTY_VAR_BINDINGS, globals: EMPTY_VAR_BINDINGS, discovery: DiscoveryIndex::EMPTY, indexed_narrowings: EMPTY_INDEXED_NARROWINGS, method_chain_narrowings: EMPTY_CHAIN_NARROWINGS, declaration_sourced: EMPTY_DECLARATION_SOURCED, source_path: nil, struct_fold_safe_locals: EMPTY_FOLD_SAFE, dynamic_origins: {}.compare_by_identity, local_origins: EMPTY_ORIGINS, ivar_origins: EMPTY_ORIGINS, void_origins: {}.compare_by_identity, optimistic_origins: {}.compare_by_identity, optimistic_locals: EMPTY_ORIGINS, optimistic_ivars: EMPTY_ORIGINS) ⇒ Scope

Returns a new instance of Scope.

Parameters:

  • environment: (Environment)
  • locals: (Hash[Symbol, Type::t])
  • fact_store: (Analysis::FactStore) (defaults to: Analysis::FactStore.empty)
  • self_type: (Type::t, nil) (defaults to: nil)
  • ivars: (Hash[Symbol, Type::t]) (defaults to: EMPTY_VAR_BINDINGS)
  • cvars: (Hash[Symbol, Type::t]) (defaults to: EMPTY_VAR_BINDINGS)
  • globals: (Hash[Symbol, Type::t]) (defaults to: EMPTY_VAR_BINDINGS)
  • discovery: (DiscoveryIndex) (defaults to: DiscoveryIndex::EMPTY)
  • source_path: (String, nil) (defaults to: nil)
  • dynamic_origins: (Hash[untyped, Symbol]) (defaults to: {}.compare_by_identity) 


137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
 
# File 'lib/rigor/scope.rb', line 137

def initialize(
  environment:, locals:,
  fact_store: Analysis::FactStore.empty,
  self_type: nil,
  ivars: EMPTY_VAR_BINDINGS,
  cvars: EMPTY_VAR_BINDINGS,
  globals: EMPTY_VAR_BINDINGS,
  discovery: DiscoveryIndex::EMPTY,
  indexed_narrowings: EMPTY_INDEXED_NARROWINGS,
  method_chain_narrowings: EMPTY_CHAIN_NARROWINGS,
  declaration_sourced: EMPTY_DECLARATION_SOURCED,
  source_path: nil,
  struct_fold_safe_locals: EMPTY_FOLD_SAFE,
  dynamic_origins: {}.compare_by_identity,
  local_origins: EMPTY_ORIGINS,
  ivar_origins: EMPTY_ORIGINS,
  void_origins: {}.compare_by_identity,
  optimistic_origins: {}.compare_by_identity,
  optimistic_locals: EMPTY_ORIGINS,
  optimistic_ivars: EMPTY_ORIGINS
)
  @environment = environment
  @locals = locals
  @fact_store = fact_store
  @self_type = self_type
  @ivars = ivars
  @cvars = cvars
  @globals = globals
  @discovery = discovery
  @indexed_narrowings = indexed_narrowings
  @method_chain_narrowings = method_chain_narrowings
  @declaration_sourced = declaration_sourced
  @source_path = source_path
  @struct_fold_safe_locals = struct_fold_safe_locals
  @dynamic_origins = dynamic_origins
  @local_origins = local_origins
  @ivar_origins = ivar_origins
  @void_origins = void_origins
  @optimistic_origins = optimistic_origins
  @optimistic_locals = optimistic_locals
  @optimistic_ivars = optimistic_ivars
  freeze
end

Instance Attribute Details

#cvars ⇒ Hash[Symbol, Type::t] (readonly)

Returns the value of attribute cvars.

Returns:

  • (Hash[Symbol, Type::t]) 


21
22
23
 
# File 'lib/rigor/scope.rb', line 21

def cvars
  @cvars
end

#declaration_sourced ⇒ Set[[Symbol, Symbol]] (readonly)

Returns the value of attribute declaration_sourced.

Returns:

  • (Set[[Symbol, Symbol]]) 


21
22
23
 
# File 'lib/rigor/scope.rb', line 21

def declaration_sourced
  @declaration_sourced
end

#discovery ⇒ DiscoveryIndex (readonly)

Returns the value of attribute discovery.

Returns:



21
22
23
 
# File 'lib/rigor/scope.rb', line 21

def discovery
  @discovery
end

#dynamic_origins ⇒ Hash[untyped, Symbol] (readonly)

Returns the value of attribute dynamic_origins.

Returns:

  • (Hash[untyped, Symbol]) 


21
22
23
 
# File 'lib/rigor/scope.rb', line 21

def dynamic_origins
  @dynamic_origins
end

#environment ⇒ Environment (readonly)

Returns the value of attribute environment.

Returns:



21
22
23
 
# File 'lib/rigor/scope.rb', line 21

def environment
  @environment
end

#fact_store ⇒ Analysis::FactStore (readonly)

Returns the value of attribute fact_store.

Returns:



21
22
23
 
# File 'lib/rigor/scope.rb', line 21

def fact_store
  @fact_store
end

#globals ⇒ Hash[Symbol, Type::t] (readonly)

Returns the value of attribute globals.

Returns:

  • (Hash[Symbol, Type::t]) 


21
22
23
 
# File 'lib/rigor/scope.rb', line 21

def globals
  @globals
end

#indexed_narrowings ⇒ Hash[IndexedKey, Type::t] (readonly)

Returns the value of attribute indexed_narrowings.

Returns:



21
22
23
 
# File 'lib/rigor/scope.rb', line 21

def indexed_narrowings
  @indexed_narrowings
end

#ivar_origins ⇒ Hash[Symbol, Symbol] (readonly)

Returns the value of attribute ivar_origins.

Returns:

  • (Hash[Symbol, Symbol]) 


21
22
23
 
# File 'lib/rigor/scope.rb', line 21

def ivar_origins
  @ivar_origins
end

#ivars ⇒ Hash[Symbol, Type::t] (readonly)

Returns the value of attribute ivars.

Returns:

  • (Hash[Symbol, Type::t]) 


21
22
23
 
# File 'lib/rigor/scope.rb', line 21

def ivars
  @ivars
end

#local_origins ⇒ Hash[Symbol, Symbol] (readonly)

Returns the value of attribute local_origins.

Returns:

  • (Hash[Symbol, Symbol]) 


21
22
23
 
# File 'lib/rigor/scope.rb', line 21

def local_origins
  @local_origins
end

#locals ⇒ Hash[Symbol, Type::t] (readonly)

Returns the value of attribute locals.

Returns:

  • (Hash[Symbol, Type::t]) 


21
22
23
 
# File 'lib/rigor/scope.rb', line 21

def locals
  @locals
end

#method_chain_narrowings ⇒ Hash[ChainKey, Type::t] (readonly)

Returns the value of attribute method_chain_narrowings.

Returns:



21
22
23
 
# File 'lib/rigor/scope.rb', line 21

def method_chain_narrowings
  @method_chain_narrowings
end

#optimistic_ivars ⇒ Hash[Symbol, Symbol] (readonly)

Returns the value of attribute optimistic_ivars.

Returns:

  • (Hash[Symbol, Symbol]) 


21
22
23
 
# File 'lib/rigor/scope.rb', line 21

def optimistic_ivars
  @optimistic_ivars
end

#optimistic_locals ⇒ Hash[Symbol, Symbol] (readonly)

Returns the value of attribute optimistic_locals.

Returns:

  • (Hash[Symbol, Symbol]) 


21
22
23
 
# File 'lib/rigor/scope.rb', line 21

def optimistic_locals
  @optimistic_locals
end

#optimistic_origins ⇒ Hash[untyped, Symbol] (readonly)

Returns the value of attribute optimistic_origins.

Returns:

  • (Hash[untyped, Symbol]) 


21
22
23
 
# File 'lib/rigor/scope.rb', line 21

def optimistic_origins
  @optimistic_origins
end

#self_type ⇒ Type::t? (readonly)

Returns the value of attribute self_type.

Returns:

  • (Type::t, nil) 


21
22
23
 
# File 'lib/rigor/scope.rb', line 21

def self_type
  @self_type
end

#source_path ⇒ String? (readonly)

Returns the value of attribute source_path.

Returns:

  • (String, nil) 


21
22
23
 
# File 'lib/rigor/scope.rb', line 21

def source_path
  @source_path
end

#struct_fold_safe_locals ⇒ Set[Symbol] (readonly)

Returns the value of attribute struct_fold_safe_locals.

Returns:

  • (Set[Symbol]) 


21
22
23
 
# File 'lib/rigor/scope.rb', line 21

def struct_fold_safe_locals
  @struct_fold_safe_locals
end

#void_origins ⇒ Hash[untyped, Inference::VoidOrigin] (readonly)

Returns the value of attribute void_origins.

Returns:



21
22
23
 
# File 'lib/rigor/scope.rb', line 21

def void_origins
  @void_origins
end

Class Method Details

.empty(environment: Environment.default, source_path: nil) ⇒ Scope

Parameters:

  • environment: (Environment) (defaults to: Environment.default)
  • source_path: (String, nil) (defaults to: nil)

Returns:



116
117
118
119
 
# File 'lib/rigor/scope.rb', line 116

def empty(environment: Environment.default, source_path: nil)
  new(environment: environment, locals: {}.freeze,
      fact_store: Analysis::FactStore.empty, source_path: source_path)
end

Instance Method Details

#==(other) ⇒ Boolean Also known as: eql?

Parameters:

  • other (Object)

Returns:

  • (Boolean) 


729
730
731
732
733
734
735
736
737
738
739
740
741
 
# File 'lib/rigor/scope.rb', line 729

def ==(other)
  other.is_a?(Scope) &&
    environment.equal?(other.environment) &&
    @locals == other.locals &&
    fact_store == other.fact_store &&
    self_type == other.self_type &&
    @ivars == other.ivars &&
    @cvars == other.cvars &&
    @globals == other.globals &&
    @indexed_narrowings == other.indexed_narrowings &&
    @method_chain_narrowings == other.method_chain_narrowings &&
    @declaration_sourced == other.declaration_sourced
end

#class_cvars ⇒ Hash[String, Hash[Symbol, Type::t]]

Returns:

  • (Hash[String, Hash[Symbol, Type::t]]) 


39
 
# File 'lib/rigor/scope.rb', line 39

def class_cvars = @discovery.class_cvars

#class_cvars_for(class_name) ⇒ Hash[Symbol, Type::t]

Slice 7 phase 6 — class-level cvar accumulator (same shape as class_ivars but populated from Prism::ClassVariableWriteNode writes, and seeded on BOTH instance and singleton method bodies because Ruby cvars are visible from each).

Parameters:

  • class_name (String, Symbol, nil)

Returns:

  • (Hash[Symbol, Type::t]) 


419
420
421
422
423
 
# File 'lib/rigor/scope.rb', line 419

def class_cvars_for(class_name)
  return EMPTY_VAR_BINDINGS if class_name.nil?

  @discovery.class_cvars[class_name.to_s] || EMPTY_VAR_BINDINGS
end

#class_ivars ⇒ Hash[String, Hash[Symbol, Type::t]]

Returns:

  • (Hash[String, Hash[Symbol, Type::t]]) 


38
 
# File 'lib/rigor/scope.rb', line 38

def class_ivars = @discovery.class_ivars

#class_ivars_for(class_name) ⇒ Hash[Symbol, Type::t]

Slice 7 phase 2 — class-level ivar accumulator. Keyed by the qualified class name (e.g. "Rigor::Scope"); the value is a Hash[Symbol, Type::t] of every ivar that appears as a write target inside any def body of that class. StatementEvaluator#build_method_entry_scope seeds the method body's ivars map from this table so a def get; @x; end reads the type written in a sibling def init; @x = 1; end.

ScopeIndexer populates the table once at index time through a separate pre-pass over the program. The map is frozen and shared by structural reference across every derived scope.

Parameters:

  • class_name (String, Symbol, nil)

Returns:

  • (Hash[Symbol, Type::t]) 


410
411
412
413
414
 
# File 'lib/rigor/scope.rb', line 410

def class_ivars_for(class_name)
  return EMPTY_VAR_BINDINGS if class_name.nil?

  @discovery.class_ivars[class_name.to_s] || EMPTY_VAR_BINDINGS
end

#cvar(name) ⇒ Type::t?

Parameters:

  • name (String, Symbol)

Returns:

  • (Type::t, nil) 


298
299
300
 
# File 'lib/rigor/scope.rb', line 298

def cvar(name)
  @cvars[name.to_sym]
end

#data_member_layout(class_name) ⇒ Array[Symbol]?

ADR-48 — per-class table mapping a fully qualified class name to its ordered Data.define / Struct.new member-name list. Populated by ScopeIndexer for both the constant-assigned form (Point = Data.define(:x, :y)) and the named-subclass form (class Point < Data.define(:x, :y)). Consumed by Inference::MethodDispatcher::DataFolding so Point.new(...) on a Singleton[Point] receiver materialises a precise member instance. Returns nil when the class has no recorded layout.

Parameters:

  • class_name (String, Symbol)

Returns:

  • (Array[Symbol], nil) 


563
564
565
566
567
568
569
 
# File 'lib/rigor/scope.rb', line 563

def data_member_layout(class_name)
  layout = @discovery.data_member_layouts[class_name.to_s]
  # Record the ancestry dependency only on a hit — DataFolding consults this for every `Singleton[*].new`,
  # and a miss (the common case: an ordinary class) must not manufacture a spurious cross-file edge.
  record_class_dependency(class_name) if layout && Analysis::DependencyRecorder.active?
  layout
end

#data_member_layouts ⇒ Hash[String, Array[Symbol]]

Returns:

  • (Hash[String, Array[Symbol]]) 


52
 
# File 'lib/rigor/scope.rb', line 52

def data_member_layouts = @discovery.data_member_layouts

#declaration_sourced?(kind, name) ⇒ Boolean

ADR-58 WD1 — true when (kind, name)'s binding optionality is purely declaration-sourced (no flow-live write/narrowing has touched it).

Parameters:

  • kind (Symbol)
  • name (String, Symbol)

Returns:

  • (Boolean) 


344
345
346
 
# File 'lib/rigor/scope.rb', line 344

def declaration_sourced?(kind, name)
  @declaration_sourced.include?([kind.to_sym, name.to_sym])
end

#declared_types ⇒ Hash[untyped, Type::t]

ADR-53 Track A — the seed-time discovery tables live on the DiscoveryIndex; Scope keeps per-table readers as delegates.

Returns:

  • (Hash[untyped, Type::t]) 


37
 
# File 'lib/rigor/scope.rb', line 37

def declared_types = @discovery.declared_types

#discovered_class_sources ⇒ Hash[String, Set[String]]

Returns:

  • (Hash[String, Set[String]]) 


51
 
# File 'lib/rigor/scope.rb', line 51

def discovered_class_sources = @discovery.discovered_class_sources

#discovered_classes ⇒ Hash[String, Type::Singleton]

Returns:



41
 
# File 'lib/rigor/scope.rb', line 41

def discovered_classes = @discovery.discovered_classes

#discovered_def_nodes ⇒ Hash[String, Hash[Symbol, untyped]]

Returns:

  • (Hash[String, Hash[Symbol, untyped]]) 


44
 
# File 'lib/rigor/scope.rb', line 44

def discovered_def_nodes = @discovery.discovered_def_nodes

#discovered_def_sources ⇒ Hash[String, Hash[Symbol, String]]

Returns:

  • (Hash[String, Hash[Symbol, String]]) 


46
 
# File 'lib/rigor/scope.rb', line 46

def discovered_def_sources = @discovery.discovered_def_sources

#discovered_includes ⇒ Hash[String, Array[String]]

Returns:

  • (Hash[String, Array[String]]) 


50
 
# File 'lib/rigor/scope.rb', line 50

def discovered_includes = @discovery.discovered_includes

#discovered_method?(class_name, method_name, kind) ⇒ Boolean

Slice 7 phase 12 — in-source method discovery. Maps a qualified class name to a Hash[Symbol, Symbol] of method_name => :instance | :singleton. Populated by ScopeIndexer from every Prism::DefNode and recognised define_method invocation inside class/module bodies. The rigor check undefined-method and wrong-arity rules consult this map to suppress diagnostics for methods the user has defined dynamically, even when no RBS sig describes them. A name defined on both sides of one class records Rigor::Scope::DiscoveryIndex::METHOD_KIND_BOTH and matches either kind.

Parameters:

  • class_name (String, Symbol)
  • method_name (String, Symbol)
  • kind (Symbol)

Returns:

  • (Boolean) 


431
432
433
434
435
436
437
 
# File 'lib/rigor/scope.rb', line 431

def discovered_method?(class_name, method_name, kind)
  table = @discovery.discovered_methods[class_name.to_s]
  return false unless table

  recorded = table[method_name.to_sym]
  recorded == kind || recorded == DiscoveryIndex::METHOD_KIND_BOTH
end

#discovered_method_visibilities ⇒ Hash[String, Hash[Symbol, Symbol]]

Returns:

  • (Hash[String, Hash[Symbol, Symbol]]) 


48
 
# File 'lib/rigor/scope.rb', line 48

def discovered_method_visibilities = @discovery.discovered_method_visibilities

#discovered_method_visibility(class_name, method_name) ⇒ Symbol?

v0.1.2 — per-class table mapping method_name (Symbol) → :public | :private | :protected. Populated by ScopeIndexer for every def it sees inside a class body, with the visibility taken from the surrounding private / protected / public modifier state plus any post-hoc private :name, ... named-argument calls. Consumed by the def.method-visibility-mismatch rule so explicit-non-self calls to a private method surface a diagnostic.

Parameters:

  • class_name (String, Symbol)
  • method_name (String, Symbol)

Returns:

  • (Symbol, nil) 


610
611
612
613
614
615
 
# File 'lib/rigor/scope.rb', line 610

def discovered_method_visibility(class_name, method_name)
  table = @discovery.discovered_method_visibilities[class_name.to_s]
  return nil unless table

  table[method_name.to_sym]
end

#discovered_methods ⇒ Hash[String, Hash[Symbol, Symbol]]

Returns:

  • (Hash[String, Hash[Symbol, Symbol]]) 


43
 
# File 'lib/rigor/scope.rb', line 43

def discovered_methods = @discovery.discovered_methods

#discovered_singleton_def_nodes ⇒ Hash[String, Hash[Symbol, untyped]]

Returns:

  • (Hash[String, Hash[Symbol, untyped]]) 


45
 
# File 'lib/rigor/scope.rb', line 45

def discovered_singleton_def_nodes = @discovery.discovered_singleton_def_nodes

#discovered_singleton_def_sources ⇒ Hash[String, Hash[Symbol, String]]

Returns:

  • (Hash[String, Hash[Symbol, String]]) 


47
 
# File 'lib/rigor/scope.rb', line 47

def discovered_singleton_def_sources = @discovery.discovered_singleton_def_sources

#discovered_superclasses ⇒ Hash[String, String]

Returns:

  • (Hash[String, String]) 


49
 
# File 'lib/rigor/scope.rb', line 49

def discovered_superclasses = @discovery.discovered_superclasses

#evaluate(node, tracer: nil) ⇒ [Type::t, Scope]

Statement-level evaluation: returns the pair [type, scope'] where type is what the node produces and scope' is the scope observable after the node has run. The receiver scope is never mutated. See Inference::StatementEvaluator for the catalogue of nodes that thread scope; everything else defers to #type_of and returns the receiver scope unchanged.

Parameters:

Returns:



706
707
708
 
# File 'lib/rigor/scope.rb', line 706

def evaluate(node, tracer: nil)
  Inference::StatementEvaluator.new(scope: self, tracer: tracer).evaluate(node)
end

#facts_for(target: nil, bucket: nil) ⇒ Array[Analysis::FactStore::Fact]

Parameters:

Returns:



682
683
684
 
# File 'lib/rigor/scope.rb', line 682

def facts_for(target: nil, bucket: nil)
  fact_store.facts_for(target: target, bucket: bucket)
end

#forget_match_globals ⇒ Scope

Returns:



397
398
399
400
401
 
# File 'lib/rigor/scope.rb', line 397

def forget_match_globals
  return self unless @globals.keys.any? { |k| MATCH_DATA_GLOBALS.include?(k) }

  rebuild(globals: @globals.except(*MATCH_DATA_GLOBALS).freeze)
end

#global(name) ⇒ Type::t?

Parameters:

  • name (String, Symbol)

Returns:

  • (Type::t, nil) 


302
303
304
 
# File 'lib/rigor/scope.rb', line 302

def global(name)
  @globals[name.to_sym]
end

#hash ⇒ Integer

Returns:

  • (Integer) 


744
745
746
 
# File 'lib/rigor/scope.rb', line 744

def hash
  [Scope, environment.object_id, @locals, fact_store, self_type, @ivars, @cvars, @globals].hash
end

#in_source_constants ⇒ Hash[String, Type::t]

Returns:

  • (Hash[String, Type::t]) 


42
 
# File 'lib/rigor/scope.rb', line 42

def in_source_constants = @discovery.in_source_constants

#includes_of(class_name) ⇒ Array[String]

ADR-24 slice 2 — per-class/module table mapping a fully qualified user class or module to the list of module names it includes / prepends, AS WRITTEN at the mixin call. Populated by ScopeIndexer (per-file plus the cross-file pre-pass) and consumed by ExpressionTyper#resolve_user_def_through_ancestors so an implicit-self call resolves against an included module's defs, not just the superclass chain. As-written names are resolved to qualified classes at walk time.

Parameters:

  • class_name (String, Symbol)

Returns:

  • (Array[String]) 


587
588
589
590
 
# File 'lib/rigor/scope.rb', line 587

def includes_of(class_name)
  record_class_dependency(class_name) if Analysis::DependencyRecorder.active?
  @discovery.discovered_includes[class_name.to_s] || []
end

#indexed_narrowing(receiver_kind, receiver_name, key) ⇒ Type::t?

Closes the "params[:f] ||= []; params[:f] << x" precision gap (ROADMAP § Type-language / engine — indexed-collection narrowing through Hash[k] ||= default). After receiver[key] ||= default, the next read at receiver[key] is known non-nil; recording the post-||= type keyed on (receiver_kind, receiver_name, literal_key) lets the ExpressionTyper's [] dispatch hand back the narrowed type. Receiver-rebind and []=/mutator invalidation rules are documented at the call sites in Inference::StatementEvaluator.

Parameters:

  • receiver_kind (Symbol)
  • receiver_name (String, Symbol)
  • key (Object)

Returns:

  • (Type::t, nil) 


623
624
625
 
# File 'lib/rigor/scope.rb', line 623

def indexed_narrowing(receiver_kind, receiver_name, key)
  @indexed_narrowings[indexed_key(receiver_kind, receiver_name, key)]
end

#inferred_param?(name) ⇒ Boolean

ADR-67 WD6b — true when name's local binding is a pristine inferred parameter (the call-site union seeded at method entry, untouched by a flow-live write). The guard predicate the negative in-body rules consult.

Parameters:

  • name (String, Symbol)

Returns:

  • (Boolean) 


377
378
379
 
# File 'lib/rigor/scope.rb', line 377

def inferred_param?(name)
  @declaration_sourced.include?([:inferred_param, name.to_sym])
end

#ivar(name) ⇒ Type::t?

Slice 7 phase 1 — instance/class/global variable bindings. ivar(name) / cvar(name) / global(name) return the type currently bound for the named variable, or nil when the variable has not been written in the analyzed slice of the program. The first cut tracks bindings only within a single method body (each def enters with a fresh binding map), so reads in other methods of the same class fall through to Dynamic[Top]. Cross-method ivar/cvar inference is a follow-up slice.

Parameters:

  • name (String, Symbol)

Returns:

  • (Type::t, nil) 


294
295
296
 
# File 'lib/rigor/scope.rb', line 294

def ivar(name)
  @ivars[name.to_sym]
end

#ivar_origin(name) ⇒ Symbol?

Parameters:

  • name (String, Symbol)

Returns:

  • (Symbol, nil) 


209
 
# File 'lib/rigor/scope.rb', line 209

def ivar_origin(name) = @ivar_origins[name.to_sym]

#join(other) ⇒ Scope

Joins this scope with another at a control-flow merge point. The joined scope is bound to every local that BOTH branches bind, with the type widened to the union of both sides. Names bound in only one branch are dropped from the joined scope; the eventual statement-level evaluator (Slice 3 phase 2) is responsible for nil-injecting half-bound names where the language semantics demand it. The two scopes MUST share the same Environment.

Parameters:

Returns:

Raises:

  • (ArgumentError) 


715
716
717
718
719
720
721
722
723
724
725
726
727
 
# File 'lib/rigor/scope.rb', line 715

def join(other)
  raise ArgumentError, "join requires a Rigor::Scope, got #{other.class}" unless other.is_a?(Scope)

  unless environment.equal?(other.environment)
    raise ArgumentError, "join requires both scopes to share the same Environment"
  end

  joined_locals = join_bindings(locals, other.locals)
  joined_ivars = join_bindings(ivars, other.ivars)
  joined_cvars = join_bindings(cvars, other.cvars)
  joined_globals = join_bindings(globals, other.globals)
  build_joined_scope(joined_locals, joined_ivars, joined_cvars, joined_globals, other)
end

#local(name) ⇒ Type::t?

Parameters:

  • name (String, Symbol)

Returns:

  • (Type::t, nil) 


225
226
227
 
# File 'lib/rigor/scope.rb', line 225

def local(name)
  @locals[name.to_sym]
end

#local_facts(name, bucket: nil) ⇒ Array[Analysis::FactStore::Fact]

Parameters:

  • name (String, Symbol)
  • bucket: (Symbol, nil) (defaults to: nil)

Returns:



686
687
688
 
# File 'lib/rigor/scope.rb', line 686

def local_facts(name, bucket: nil)
  facts_for(target: Analysis::FactStore::Target.local(name), bucket: bucket)
end

#local_origin(name) ⇒ Symbol?

ADR-82 WD1 — the propagated origin of the Dynamic value currently bound to a local / instance variable, or nil when none is tracked. Consulted by Inference::ProtectionScanner when a dispatch's receiver is a bare x / @x read whose own node carries no origin.

Parameters:

  • name (String, Symbol)

Returns:

  • (Symbol, nil) 


208
 
# File 'lib/rigor/scope.rb', line 208

def local_origin(name) = @local_origins[name.to_sym]

#method_chain_narrowing(receiver_kind, receiver_name, method_name) ⇒ Type::t?

Closes the "stable receiver method-chain narrowing" gap (ROADMAP § Future cycles / Type-language / engine — "Method-call receiver narrowing across stable receivers"; 2026-05-28 Redmine survey). After if x.last.is_a?(Array) the dominated body's x.last reads MUST observe the truthy-narrowed type; the same chain reaching the falsey edge observes the negative narrowing.

Address shape mirrors #indexed_narrowing: stable root variable + no-arg single-hop method name. See ChainKey for the precise contract.

Parameters:

  • receiver_kind (Symbol)
  • receiver_name (String, Symbol)
  • method_name (String, Symbol)

Returns:

  • (Type::t, nil) 


656
657
658
 
# File 'lib/rigor/scope.rb', line 656

def method_chain_narrowing(receiver_kind, receiver_name, method_name)
  @method_chain_narrowings[chain_key(receiver_kind, receiver_name, method_name)]
end

#optimistic_ivar(name) ⇒ Symbol?

Parameters:

  • name (String, Symbol)

Returns:

  • (Symbol, nil) 


191
 
# File 'lib/rigor/scope.rb', line 191

def optimistic_ivar(name) = @optimistic_ivars[name.to_sym]

#optimistic_local(name) ⇒ Symbol?

Parameters:

  • name (String, Symbol)

Returns:

  • (Symbol, nil) 


190
 
# File 'lib/rigor/scope.rb', line 190

def optimistic_local(name) = @optimistic_locals[name.to_sym]

#param_inferred_types ⇒ Hash[[String, Symbol, Symbol], Hash[Symbol, Type::t]]

ADR-67 WD3 — call-site-inferred parameter types, keyed by [class_name, method_name, kind]. build_method_entry_scope consults this to seed an undeclared def parameter with the union of its resolved call-site argument types (precision-additive; an RBS-declared parameter always wins). Empty unless a collection pass seeded it.

Returns:

  • (Hash[[String, Symbol, Symbol], Hash[Symbol, Type::t]]) 


58
59
60
 
# File 'lib/rigor/scope.rb', line 58

def param_inferred_types = @discovery.param_inferred_types
# ADR-84 WD2 — the per-run identity token the user-method return memo buckets on (nil outside runner-seeded
# scopes; the memo then falls back to the per-file `discovered_def_nodes` identity).

#program_globals ⇒ Hash[Symbol, Type::t]

Returns:

  • (Hash[Symbol, Type::t]) 


40
 
# File 'lib/rigor/scope.rb', line 40

def program_globals = @discovery.program_globals

#record_dynamic_origin(node, cause) ⇒ Scope

Parameters:

  • node (Object)
  • cause (Symbol)

Returns:



122
123
124
125
 
# File 'lib/rigor/scope.rb', line 122

def record_dynamic_origin(node, cause)
  @dynamic_origins[node] = cause
  self
end

#record_optimistic_origin(node, cause) ⇒ Scope

Issue #286 — the Inference::OptimisticOrigin cause attached to a call node whose result is nil-free only because RbsDispatch reads past %a{implicitly-returns-nil}, or nil when the value's nil-freeness is a property of its class. Mirrors #dynamic_origins / #void_origins: advisory metadata, ignored by == / hash, and never varying a flow decision on its own.

Parameters:

  • node (Object)
  • cause (Symbol)

Returns:



185
186
187
188
 
# File 'lib/rigor/scope.rb', line 185

def record_optimistic_origin(node, cause)
  @optimistic_origins[node] = cause
  self
end

#record_void_origin(node, origin) ⇒ Scope

ADR-100 WD3 — records that the value introduced at node (a call node) is a top recovered from an author-declared -> void return, keyed by the origin site (origin, an Inference::VoidOrigin). The value-context check rule static.value-use.void consumes this table. Mirrors #record_dynamic_origin exactly: identity-keyed advisory metadata, mutated in place on the shared table (threaded by reference through #join / #rebuild), excluded from == / hash, so it never forks a flow-dedup or cache key.

Parameters:

Returns:



132
133
134
135
 
# File 'lib/rigor/scope.rb', line 132

def record_void_origin(node, origin)
  @void_origins[node] = origin
  self
end

#run_generation ⇒ Object?

ADR-84 WD2 — the per-run identity token the user-method return memo buckets on (nil outside runner-seeded scopes; the memo then falls back to the per-file discovered_def_nodes identity).

Returns:

  • (Object, nil) 


61
 
# File 'lib/rigor/scope.rb', line 61

def run_generation = @discovery.run_generation

#seed_declaration_sourced_ivar(name, type) ⇒ Scope

ADR-58 WD1 — used by the method-entry seed to mark an ivar whose only provenance is the class-ivar index. Unlike with_ivar this binds the type AND records the declaration-sourced mark in one transition.

Parameters:

  • name (String, Symbol)
  • type (Type::t)

Returns:



322
323
324
325
 
# File 'lib/rigor/scope.rb', line 322

def seed_declaration_sourced_ivar(name, type)
  rebuild(ivars: @ivars.merge(name.to_sym => type).freeze,
          declaration_sourced: add_declaration_sourced(:ivar, name))
end

#singleton_def_for(class_name, method_name) ⇒ Object?

Module-singleton call resolution (ADR-57 follow-up) — companion of #user_def_for for SINGLETON-side defs (def self.x, def Foo.x, class << self bodies, and module_function defs). Returns the Prism::DefNode for class_name.method_name invoked on the module/class constant itself, or nil. The discovered_def_nodes table is deliberately instance-side only (its ancestor walk binds self as Nominal), so singleton bodies live in a parallel table the ScopeIndexer populates alongside it. Records the same cross-file dependency edge as the instance path (ADR-46).

Parameters:

  • class_name (String, Symbol)
  • method_name (String, Symbol)

Returns:

  • (Object, nil) 


469
470
471
472
473
474
 
# File 'lib/rigor/scope.rb', line 469

def singleton_def_for(class_name, method_name)
  table = @discovery.discovered_singleton_def_nodes[class_name.to_s]
  entry = table && table[method_name.to_sym] # live node or DefHandle (ADR-85 WD3)
  record_cross_file_method(class_name, method_name, entry, singleton: true) if Analysis::DependencyRecorder.active?
  Inference::DefNodeResolver.resolve(entry)
end

#struct_fold_safe?(name) ⇒ Boolean

True when name's Struct member reads are fold-safe in this body (the local is provably never mutated / aliased / escaped).

Parameters:

  • name (String, Symbol)

Returns:

  • (Boolean) 


279
280
281
 
# File 'lib/rigor/scope.rb', line 279

def struct_fold_safe?(name)
  @struct_fold_safe_locals.include?(name.to_sym)
end

#struct_member_layout(class_name) ⇒ { members: Array[Symbol], keyword_init: bool }?

ADR-48 Struct follow-up — the { members:, keyword_init: } layout recorded for a Struct.new(...)-defined class, in the constant form (Point = Struct.new(:x, :y)) and the named-subclass form (class Point < Struct.new(:x, :y)). Consumed by Inference::MethodDispatcher::StructFolding so Point.new(...) on a Singleton[Point] receiver materialises a member instance. Returns nil when the class has no recorded struct layout. Mirrors #data_member_layout's dependency-recording contract.

Parameters:

  • class_name (String, Symbol)

Returns:

  • ({ members: Array[Symbol], keyword_init: bool }, nil) 


576
577
578
579
580
 
# File 'lib/rigor/scope.rb', line 576

def struct_member_layout(class_name)
  layout = @discovery.struct_member_layouts[class_name.to_s]
  record_class_dependency(class_name) if layout && Analysis::DependencyRecorder.active?
  layout
end

#struct_member_layouts ⇒ Hash[String, { members: Array[Symbol], keyword_init: bool }]

Returns:

  • (Hash[String, { members: Array[Symbol], keyword_init: bool }]) 


53
54
55
56
57
 
# File 'lib/rigor/scope.rb', line 53

def struct_member_layouts = @discovery.struct_member_layouts
# ADR-67 WD3 — call-site-inferred parameter types, keyed by `[class_name, method_name, kind]`.
# `build_method_entry_scope` consults this to seed an undeclared `def` parameter with the union of its resolved
# call-site argument types (precision-additive; an RBS-declared parameter always wins). Empty unless a
# collection pass seeded it.

#superclass_of(class_name) ⇒ String?

ADR-24 slice 2 — per-class table mapping a fully qualified user-class name to its superclass name AS WRITTEN at the class Foo < Bar declaration ("Bar", possibly a qualified "A::B"). Populated by ScopeIndexer — per-file plus the cross-file project pre-pass — and consumed by ExpressionTyper#try_user_method_inference to walk the superclass chain when an implicit-self call does not resolve against the enclosing class's own defs. The as-written name is resolved to a qualified class at walk time against the call's lexical nesting.

Parameters:

  • class_name (String, Symbol)

Returns:

  • (String, nil) 


553
554
555
556
 
# File 'lib/rigor/scope.rb', line 553

def superclass_of(class_name)
  record_class_dependency(class_name) if Analysis::DependencyRecorder.active?
  @discovery.discovered_superclasses[class_name.to_s]
end

#top_level_def_for(method_name) ⇒ Object?

v0.0.3 A — top-level def lookup for implicit-self calls. Returns the Prism::DefNode for a top-level (or DSL-block-nested, outside any class body) def <method_name> in the file, or nil. The sentinel key is owned by Inference::ScopeIndexer::TOP_LEVEL_DEF_KEY; consumers should treat its presence as an opaque implementation detail and go through this accessor.

Parameters:

  • method_name (String, Symbol)

Returns:

  • (Object, nil) 


501
502
503
504
505
506
 
# File 'lib/rigor/scope.rb', line 501

def top_level_def_for(method_name)
  table = @discovery.discovered_def_nodes[Inference::ScopeIndexer::TOP_LEVEL_DEF_KEY]
  entry = table && table[method_name.to_sym] # live node or DefHandle (ADR-85 WD3)
  record_cross_file_toplevel(method_name, entry) if Analysis::DependencyRecorder.active?
  Inference::DefNodeResolver.resolve(entry)
end

#toplevel? ⇒ Boolean

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 — the same nil-self_type signal ADR-24's self-call return adoption historically keyed on before ADR-57 opened the gate unconditionally). 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.

Returns:

  • (Boolean) 


445
446
447
 
# File 'lib/rigor/scope.rb', line 445

def toplevel?
  @self_type.nil?
end

#type_of(node, tracer: nil) ⇒ Type::t

Parameters:

Returns:

  • (Type::t) 


690
691
692
 
# File 'lib/rigor/scope.rb', line 690

def type_of(node, tracer: nil)
  Inference::ExpressionTyper.new(scope: self, tracer: tracer).type_of(node)
end

#user_def_for(class_name, method_name) ⇒ Object?

v0.0.2 #5 — per-class table mapping method_name (Symbol) → Prism::DefNode. Populated by ScopeIndexer alongside discovered_methods for instance-side defs only (singleton-side and define_method-introduced methods do not contribute a static body the engine can re-type). Consumed by ExpressionTyper to do inter-procedural return-type inference when the receiver class is user-defined and has no RBS sig.

Parameters:

  • class_name (String, Symbol)
  • method_name (String, Symbol)

Returns:

  • (Object, nil) 


453
454
455
456
457
458
459
460
461
 
# File 'lib/rigor/scope.rb', line 453

def user_def_for(class_name, method_name)
  table = @discovery.discovered_def_nodes[class_name.to_s]
  # ADR-85 WD3 — the value is either a live `Prism::DefNode` (cold / re-walked file) or a `DefHandle`
  # (unchanged file, bundle-rebuilt index). Dependency recording keys on the table's PRESENCE (both are
  # truthy), so it is sound regardless of resolution; only the returned node is resolved lazily.
  entry = table && table[method_name.to_sym]
  record_cross_file_method(class_name, method_name, entry) if Analysis::DependencyRecorder.active?
  Inference::DefNodeResolver.resolve(entry)
end

#user_def_site_for(class_name, method_name) ⇒ String?

Companion to #user_def_for: returns the "path:line" where the project defines class_name#method_name (instance-side), or nil. Populated only by the cross-file project pre-pass (Inference::ScopeIndexer.discovered_def_index_for_paths) — a Prism::Location hides its source file, so the site is recorded at scan time. CheckRules#undefined_method_diagnostic consults this to name the defining file when a project monkey-patch on a core/stdlib/gem class is called cross-file, so the diagnostic can point at pre_eval: (ADR-17) instead of reading as a bare unresolved call.

Parameters:

  • class_name (String, Symbol)
  • method_name (String, Symbol)

Returns:

  • (String, nil) 


533
534
535
536
537
538
539
540
541
542
543
544
545
 
# File 'lib/rigor/scope.rb', line 533

def user_def_site_for(class_name, method_name)
  table = @discovery.discovered_def_sources[class_name.to_s]
  site = table && table[method_name.to_sym]
  # ADR-88 WD3 — record the SAME instance-side cross-file method edge {#user_def_for} records at :378, so a
  # move / body-edit of `class_name#method_name`'s definition re-checks the consumer that named the
  # defining file. `CheckRules#undefined_method_diagnostic` reads this to set `project_definition_site`
  # (`"path:line"`) on a `call.undefined-method` for a project monkey-patch; without the edge, a line-shift
  # in the defining file left the cached diagnostic pointing at a stale line (the ADR-46 symbol-granularity
  # closure never re-checked the caller). Recording keys on the source-entry PRESENCE (truthy `site`),
  # sound whether or not the caller also went through {#user_def_for}.
  record_cross_file_method(class_name, method_name, site) if Analysis::DependencyRecorder.active?
  site
end

#user_method_return(def_node, receiver, arg_types) ⇒ Type::t?

ADR-89 WD2 — the inferred return type of def_node called with receiver / arg_types, computed against THIS scope's discovery index (so cross-file dispatches in the body resolve). The incremental session re-drives a declaration-stable changed callee at each previously-observed call key to prove its return is unchanged before skipping its symbol dependents.

Parameters:

  • def_node (Object)
  • receiver (Type::t)
  • arg_types (Array[Type::t])

Returns:

  • (Type::t, nil) 


698
699
700
 
# File 'lib/rigor/scope.rb', line 698

def user_method_return(def_node, receiver, arg_types)
  Inference::ExpressionTyper.new(scope: self).return_type_for(def_node, receiver, arg_types)
end

#with_cvar(name, type) ⇒ Scope

Parameters:

  • name (String, Symbol)
  • type (Type::t)

Returns:



381
382
383
 
# File 'lib/rigor/scope.rb', line 381

def with_cvar(name, type)
  rebuild(cvars: @cvars.merge(name.to_sym => type).freeze)
end

#with_declaration_sourced_local(name, type) ⇒ Scope

ADR-58 WD1 — a local assignment r = @right whose RHS is a pure read of a declaration-sourced ivar inherits the mark, so the survey's exact rotation/traversal shape (r = @right; r.key) does not fire. Binds the type and stamps the local's mark in one transition (the plain with_local would have dropped it).

Parameters:

  • name (String, Symbol)
  • type (Type::t)

Returns:



330
331
332
333
 
# File 'lib/rigor/scope.rb', line 330

def with_declaration_sourced_local(name, type)
  written = with_local(name, type)
  written.with_local_declaration_mark(name)
end

#with_discovery(index) ⇒ Scope

ADR-53 Track A — swaps the whole discovery index in one transition. The sole seeding path; the per-table writers it replaced are derived off-Scope through scope.discovery.with(table_name: table).

Parameters:

Returns:



285
286
287
 
# File 'lib/rigor/scope.rb', line 285

def with_discovery(index)
  rebuild(discovery: index)
end

#with_fact(fact) ⇒ Scope

Parameters:

Returns:



253
254
255
 
# File 'lib/rigor/scope.rb', line 253

def with_fact(fact)
  rebuild(fact_store: fact_store.with_fact(fact))
end

#with_global(name, type) ⇒ Scope

Parameters:

  • name (String, Symbol)
  • type (Type::t)

Returns:



385
386
387
 
# File 'lib/rigor/scope.rb', line 385

def with_global(name, type)
  rebuild(globals: @globals.merge(name.to_sym => type).freeze)
end

#with_indexed_narrowing(receiver_kind, receiver_name, key, type) ⇒ Scope

Parameters:

  • receiver_kind (Symbol)
  • receiver_name (String, Symbol)
  • key (Object)
  • type (Type::t)

Returns:



627
628
629
630
631
632
 
# File 'lib/rigor/scope.rb', line 627

def with_indexed_narrowing(receiver_kind, receiver_name, key, type)
  new_table = @indexed_narrowings.merge(
    indexed_key(receiver_kind, receiver_name, key) => type
  ).freeze
  rebuild(indexed_narrowings: new_table)
end

#with_inferred_param_mark(name) ⇒ Scope

ADR-67 WD6b — stamp the "inferred, not declared" provenance mark on a parameter local seeded from the call-site parameter-inference table (Inference::ParameterInferenceCollector). Rides the ADR-58 WD1 declaration-sourced side-mark machinery under a distinct :inferred_param kind (never a carrier field, so the displayed type is unchanged) so the negative in-body rules can decline on a receiver / argument whose type is an open-call-site lower bound — firing against a lower bound is a false positive by construction (the ADR-67 WD1 reasoning at the parameter boundary, carried one hop into the body). The distinct kind keeps the inferred-param sites separable from ADR-58's ivar-copy :local mark, which a later un-guarding slice (WD6b) needs. with_local drops it on any flow-live rewrite of the local (drop_local_declaration_marks), so only the pristine parameter binding carries it.

Parameters:

  • name (String, Symbol)

Returns:



357
358
359
 
# File 'lib/rigor/scope.rb', line 357

def with_inferred_param_mark(name)
  rebuild(declaration_sourced: add_declaration_sourced(:inferred_param, name))
end

#with_ivar(name, type) ⇒ Scope

Parameters:

  • name (String, Symbol)
  • type (Type::t)

Returns:



306
307
308
309
310
311
312
313
314
315
316
317
318
 
# File 'lib/rigor/scope.rb', line 306

def with_ivar(name, type)
  new_indexed_narrowings = drop_indexed_narrowings_for(:ivar, name)
  new_chain_narrowings = drop_chain_narrowings_for(:ivar, name)
  # ADR-58 WD1 — a method-local ivar write or narrowing is flow-live: drop any declaration-sourced mark so
  # subsequent reads of `@name` observe flow-live provenance and fire as before. The seed path uses
  # `seed_declaration_sourced_ivar` to (re-)establish the mark.
  rebuild(ivars: @ivars.merge(name.to_sym => type).freeze,
          indexed_narrowings: new_indexed_narrowings,
          method_chain_narrowings: new_chain_narrowings,
          declaration_sourced: drop_declaration_sourced_for(:ivar, name),
          ivar_origins: drop_origin(@ivar_origins, name),
          optimistic_ivars: drop_origin(@optimistic_ivars, name))
end

#with_ivar_origin(name, cause) ⇒ Scope

Parameters:

  • name (String, Symbol)
  • cause (Symbol, nil)

Returns:



219
220
221
222
223
 
# File 'lib/rigor/scope.rb', line 219

def with_ivar_origin(name, cause)
  return self if cause.nil?

  rebuild(ivar_origins: @ivar_origins.merge(name.to_sym => cause).freeze)
end

#with_local(name, type) ⇒ Scope

Parameters:

  • name (String, Symbol)
  • type (Type::t)

Returns:



229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
 
# File 'lib/rigor/scope.rb', line 229

def with_local(name, type)
  # `rigor trace` — the moment a local enters the scope.
  Inference::FlowTracer.bind(name, type) if Inference::FlowTracer.active?
  new_locals = @locals.merge(name.to_sym => type).freeze
  new_fact_store = fact_store.invalidate_target(Analysis::FactStore::Target.local(name))
  # Rebinding `name` invalidates every "after `receiver[key] ||= default`" narrowing keyed on it — the slot at
  # `name[*]` is reachable through the old binding only, so the next read against the new binding does not
  # inherit the earlier non-nil guarantee. The same logic applies to method-chain narrowings: `x.last` after
  # `x = something_new` is a call on the new binding and any prior `is_a?`-driven narrowing keyed on
  # `(local, :x, :last)` no longer holds.
  new_indexed_narrowings = drop_indexed_narrowings_for(:local, name)
  new_chain_narrowings = drop_chain_narrowings_for(:local, name)
  # ADR-58 WD1 — rebinding a local is a flow-live touch: any prior declaration-sourced mark on `name` no
  # longer holds (the new value may carry a method-local nil). `with_declaration_sourced_local` re-establishes
  # the mark afterward when the RHS is a pure copy of a declaration-sourced ivar read; the default is to drop
  # it.
  rebuild(locals: new_locals, fact_store: new_fact_store,
          indexed_narrowings: new_indexed_narrowings,
          method_chain_narrowings: new_chain_narrowings,
          declaration_sourced: drop_declaration_sourced_for(:local, name),
          local_origins: drop_origin(@local_origins, name),
          optimistic_locals: drop_origin(@optimistic_locals, name))
end

#with_local_declaration_mark(name) ⇒ Scope

ADR-58 WD1 — re-stamp the local mark on a scope produced by with_local (which always drops it). Public so the sibling with_declaration_sourced_local can call it across the new post-write receiver without reaching into a private method.

Parameters:

  • name (String, Symbol)

Returns:



338
339
340
 
# File 'lib/rigor/scope.rb', line 338

def with_local_declaration_mark(name)
  rebuild(declaration_sourced: add_declaration_sourced(:local, name))
end

#with_local_origin(name, cause) ⇒ Scope

Records the cause of the Dynamic value being bound to name. A nil cause is a no-op (the common case — most bindings are concrete or have no recorded origin), so callers need not pre-check.

Parameters:

  • name (String, Symbol)
  • cause (Symbol, nil)

Returns:



213
214
215
216
217
 
# File 'lib/rigor/scope.rb', line 213

def with_local_origin(name, cause)
  return self if cause.nil?

  rebuild(local_origins: @local_origins.merge(name.to_sym => cause).freeze)
end

#with_method_chain_narrowing(receiver_kind, receiver_name, method_name, type) ⇒ Scope

Parameters:

  • receiver_kind (Symbol)
  • receiver_name (String, Symbol)
  • method_name (String, Symbol)
  • type (Type::t)

Returns:



660
661
662
663
664
665
 
# File 'lib/rigor/scope.rb', line 660

def with_method_chain_narrowing(receiver_kind, receiver_name, method_name, type)
  new_table = @method_chain_narrowings.merge(
    chain_key(receiver_kind, receiver_name, method_name) => type
  ).freeze
  rebuild(method_chain_narrowings: new_table)
end

#with_optimistic_ivar(name, cause) ⇒ Scope

Parameters:

  • name (String, Symbol)
  • cause (Symbol, nil)

Returns:



199
200
201
202
203
 
# File 'lib/rigor/scope.rb', line 199

def with_optimistic_ivar(name, cause)
  return self if cause.nil?

  rebuild(optimistic_ivars: @optimistic_ivars.merge(name.to_sym => cause).freeze)
end

#with_optimistic_local(name, cause) ⇒ Scope

Parameters:

  • name (String, Symbol)
  • cause (Symbol, nil)

Returns:



193
194
195
196
197
 
# File 'lib/rigor/scope.rb', line 193

def with_optimistic_local(name, cause)
  return self if cause.nil?

  rebuild(optimistic_locals: @optimistic_locals.merge(name.to_sym => cause).freeze)
end

#with_self_type(type) ⇒ Scope

Slice A-engine. Returns a scope with self_type set to type, preserving locals and facts. StatementEvaluator injects this at class-body and method-body boundaries; ExpressionTyper consults it when typing Prism::SelfNode and implicit-self Prism::CallNode receivers.

Parameters:

  • type (Type::t, nil)

Returns:



260
261
262
 
# File 'lib/rigor/scope.rb', line 260

def with_self_type(type)
  rebuild(self_type: type)
end

#with_source_path(path) ⇒ Scope

ADR-28 / ADR-52 slice 5a — per-file source path carried on the scope. The analyzer stamps the current file's path onto the seed scope; nested rebuilds propagate it so plugin rules (dynamic_return's file_methods: gate, sigil checks) can resolve "which file does this call site belong to?" without thread-locals.

Parameters:

  • path (String, nil)

Returns:



267
268
269
 
# File 'lib/rigor/scope.rb', line 267

def with_source_path(path)
  rebuild(source_path: path)
end

#with_struct_fold_safe(locals) ⇒ Scope

ADR-48 Struct slice 3 — installs the per-body fold-safe-local set (Inference::StructFoldSafety). Set once at body entry; inherited unchanged through subsequent flow transitions.

Parameters:

  • locals (Set[Symbol])

Returns:



273
274
275
 
# File 'lib/rigor/scope.rb', line 273

def with_struct_fold_safe(locals)
  rebuild(struct_fold_safe_locals: locals)
end

#without_indexed_narrowing(receiver_kind, receiver_name, key) ⇒ Scope

Parameters:

  • receiver_kind (Symbol)
  • receiver_name (String, Symbol)
  • key (Object)

Returns:



634
635
636
637
638
639
640
 
# File 'lib/rigor/scope.rb', line 634

def without_indexed_narrowing(receiver_kind, receiver_name, key)
  lookup = indexed_key(receiver_kind, receiver_name, key)
  return self unless @indexed_narrowings.key?(lookup)

  new_table = @indexed_narrowings.reject { |k, _| k == lookup }.freeze
  rebuild(indexed_narrowings: new_table)
end

#without_indexed_narrowings_for(receiver_kind, receiver_name) ⇒ Scope

Parameters:

  • receiver_kind (Symbol)
  • receiver_name (String, Symbol)

Returns:



642
643
644
645
646
647
 
# File 'lib/rigor/scope.rb', line 642

def without_indexed_narrowings_for(receiver_kind, receiver_name)
  new_table = drop_indexed_narrowings_for(receiver_kind, receiver_name)
  return self if new_table.equal?(@indexed_narrowings)

  rebuild(indexed_narrowings: new_table)
end

#without_inferred_param_mark(name) ⇒ Scope

ADR-67 WD6b — explicitly clear the inferred-parameter taint on name. The mark is deliberately STICKY: with_local (used by both narrowing and reassignment) does NOT drop it, so it survives the narrowing / join transitions between a lower-bound value's definition and its use (v = param[i]-1; if 0<=v and v<n — the and narrows v between the two comparisons). It is cleared only at a genuine source-level local write whose RHS does not derive from an inferred parameter (StatementEvaluator#eval_local_write), so a local rebound to an independent value stops being treated as a lower bound. Over-retention (a mark that outlives a rebind the write-path did not catch) only ever suppresses a diagnostic — the FP-safe direction — so stickiness is the conservative choice. Zero-alloc when no mark is present.

Parameters:

  • name (String, Symbol)

Returns:



369
370
371
372
 
# File 'lib/rigor/scope.rb', line 369

def without_inferred_param_mark(name)
  dropped = drop_declaration_sourced_for(:inferred_param, name)
  dropped.equal?(@declaration_sourced) ? self : rebuild(declaration_sourced: dropped)
end

#without_method_chain_narrowing(receiver_kind, receiver_name, method_name) ⇒ Scope

Parameters:

  • receiver_kind (Symbol)
  • receiver_name (String, Symbol)
  • method_name (String, Symbol)

Returns:



667
668
669
670
671
672
673
 
# File 'lib/rigor/scope.rb', line 667

def without_method_chain_narrowing(receiver_kind, receiver_name, method_name)
  lookup = chain_key(receiver_kind, receiver_name, method_name)
  return self unless @method_chain_narrowings.key?(lookup)

  new_table = @method_chain_narrowings.reject { |k, _| k == lookup }.freeze
  rebuild(method_chain_narrowings: new_table)
end

#without_method_chain_narrowings_for(receiver_kind, receiver_name) ⇒ Scope

Parameters:

  • receiver_kind (Symbol)
  • receiver_name (String, Symbol)

Returns:



675
676
677
678
679
680
 
# File 'lib/rigor/scope.rb', line 675

def without_method_chain_narrowings_for(receiver_kind, receiver_name)
  new_table = drop_chain_narrowings_for(receiver_kind, receiver_name)
  return self if new_table.equal?(@method_chain_narrowings)

  rebuild(method_chain_narrowings: new_table)
end