Meta PR 2: fixes from running roundhouse over a large internal Rails codebase

docs/guide/check.md

@@ -246,6 +246,10 @@ roundhouse does not model it)* means the receiver comes from a gem the
 census lists as unknown. Skip these on a first read. They exist so the
 error count above means "findings", not "shadows of gaps".
 
+Unresolved source constants keep their error severity even when the
+gem census identifies a likely owner: their emitted expression is a
+refusal stub. Gem context is added without certifying runtime support.
+
 **The survey report** — printed only with `--continue`: every construct
 ingest skipped, bucketed by kind, most frequent first, with the files
 it occurred in. This is roundhouse's own to-do list for your app.

docs/guide/transpile.md

@@ -99,6 +99,11 @@ rather than dropping the callback or evaluating its producer per item.
 Existing literal blocks, local block variables and bound-method
 references retain their target-specific support and limitations.
 
+Roundhouse currently refuses generated enum `*_before_type_cast` readers.
+Rails returns the original input after an unsaved assignment and stored data
+after persistence; the compiler has only the stored enum slot. Negative enum
+scopes are supported. Source-defined readers keep their ordinary behavior.
+
 ## Apps that aren't fully covered yet
 
 By default, ingest is strict — the first construct roundhouse does not

docs/pipeline/analyze.md

@@ -77,19 +77,31 @@ registries:
   Roundhouse keeps compact answers keyed by source position and
   releases the Rubydex graph before its typing passes. A read that
   resolves to a class keeps the qualified class path in the IR, so the
-  read names the same class after ingest copies a concern method into
+  read names the same class or value after ingest copies a concern method into
   another class.
   `Analyzer::build_constant_registry` infers each constant's value
   type and stores it under the Rubydex declaration ID of its source
   definition. The ID comes from the source position, so a file-level
   constant that ingest moves into a class keeps its top-level ID. The
   rounds continue until no value changes, so a chain such as `B = A`
   resolves at any depth. A cycle stays unresolved.
+  Source snapshots and drains must preserve paths, text and order;
+  release builds enforce this identity and reject late registrations.
+  Prepared answers are reused only for the same ordered source contents.
+  Generated constants borrowing a real span carry an explicit origin bit;
+  missing Ruby documents or missing source-position answers cannot use
+  that fallback. Normal ingest persists `source_index_required`, and
+  clearing its source table triggers `source_index_missing`. Standalone
+  hand-built IR apps with no sources use exact modeled dispatch instead;
+  this API mode does not certify source indexing.
   Views and generated expressions have no Rubydex answer. A bare name
   there uses the typed local scope. A qualified name uses only the
   value declared at that full name.
 - The analyzer reports an error for an unresolved source constant.
-  It does not select another class by a matching name suffix.
+  This includes executable library methods, parameter defaults and
+  constant initializers; an unresolved constant cannot check clean and
+  emit an unsupported raise. It does not select another class by a matching
+  name suffix.
   `parse_module_constants` types literal constants in framework Ruby.
 
 Other inference gaps leave `Ty::Var(n)` or RBS `Ty::Untyped`.

runtime/ruby/active_support_ext.rb

@@ -817,6 +817,7 @@ def self.underscore(text)
   end
 
   def self.humanize(text)
+    raise NoMethodError, "undefined method 'humanize' for nil" if text.nil?
     s = text.to_s.tr("_", " ").lstrip
     s = s[0, s.length - 3].to_s if s.end_with?(" id")
     s = s.downcase
@@ -825,6 +826,7 @@ def self.humanize(text)
   end
 
   def self.titleize(text)
+    raise NoMethodError, "undefined method 'titleize' for nil" if text.nil?
     s = humanize(underscore(text))
     out = +""
     n = s.length

runtime/ruby/active_support_ext.rbs

@@ -103,6 +103,6 @@ module ActiveSupport
   def self.local_time: (Integer y, Integer mo, Integer d, Integer h, Integer mi, Integer s, Integer nsec) -> Time
   def self.number_delimited: (Integer | Float number) -> String
   def self.underscore: (String text) -> String
-  def self.humanize: (String text) -> String
-  def self.titleize: (String text) -> String
+  def self.humanize: (String? text) -> String
+  def self.titleize: (String? text) -> String
 end

src/analyze/attribution.rs

@@ -347,7 +347,7 @@ pub fn attribute_unknown_gems(diags: &mut [Diagnostic], app: &App) {
                         return Some((gem, Some(format!("matches the declared `{dsl}` surface in {}; runtime method availability is unverified", owner.0))));
                     }
                 }
-                match ancestry.as_ref()?.receiver_gem(recv_ty, &census) {
+                match ancestry.as_ref()?.receiver_gem(recv_ty, &census, &|gem, path| app.gem_boundary.declares_path(gem, path)) {
                     GemClaim::Known { gem, constant } => Some((gem, Some(format!(
                         "receiver ancestry reaches `{constant}`; method ownership is unverified"
                     )))),
@@ -363,7 +363,10 @@ pub fn attribute_unknown_gems(diags: &mut [Diagnostic], app: &App) {
             DiagnosticKind::Unsupported { construct, detail, .. }
                 if construct.as_str() == "constant" =>
             {
-                crate::gems::gem_owning_constant(&census, detail).map(|gem| (gem, None))
+                crate::gems::gem_owning_constant_with(&census, detail, &|gem, path| {
+                    app.gem_boundary.declares_path(gem, path)
+                })
+                .map(|gem| (gem, None))
             }
             _ => None,
         }
@@ -375,7 +378,16 @@ pub fn attribute_unknown_gems(diags: &mut [Diagnostic], app: &App) {
             &d.kind,
             DiagnosticKind::Unsupported { construct, .. } if construct.as_str() == "constant"
         );
-        if (!eligible(&d.kind) && !unknown_constant) || d.severity == Severity::Info {
+        if unknown_constant {
+            // Attribution cannot certify a constant whose emitted body
+            // is a refusal stub. Keep severity/kind/span and add context only.
+            if let Some((gem, _)) = gem_for(d) {
+                let context = format!(" — unmodeled gem `{gem}`; emitted constant availability is unverified");
+                if !d.message.ends_with(&context) { d.message.push_str(&context); }
+            }
+            continue;
+        }
+        if !eligible(&d.kind) || d.severity == Severity::Info {
             continue;
         }
         if let Some((gem, evidence)) = gem_for(d) {
@@ -592,7 +604,7 @@ mod tests {
     }
 
     #[test]
-    fn unknown_gem_constant_is_a_coverage_note_not_a_user_error() {
+    fn unknown_gem_constant_keeps_its_error_and_idempotent_context() {
         let mut app = App::new();
         app.gem_lock = Some(crate::gems::Lockfile::parse(
             "GEM\n  remote: https://rubygems.org/\n  specs:\n    acme-core (1.0.0)\n\nPLATFORMS\n  ruby\n\nDEPENDENCIES\n  acme-core\n",
@@ -602,9 +614,12 @@ mod tests {
             Diagnostic::unsupported(Span::synthetic(), None, "other construct", "AcmeCore::Client"),
         ];
         attribute_unknown_gems(&mut diags, &app);
-        assert_eq!(diags[0].severity, Severity::Info);
+        assert_eq!(diags[0].severity, Severity::Error);
         assert!(diags[0].message.contains("acme-core"));
         assert_eq!(diags[1].severity, Severity::Error);
+        let once = diags.clone();
+        attribute_unknown_gems(&mut diags, &app);
+        assert_eq!(diags, once);
     }
 
     #[test]

src/analyze/attribution/gem_ancestry.rs

@@ -3,7 +3,7 @@
 use std::collections::{BTreeMap, HashMap, HashSet};
 
 use crate::app::App;
-use crate::gems::{GemCensus, gems_owning_constant};
+use crate::gems::{GemCensus, gems_owning_constant_with};
 use crate::ident::{ClassId, Symbol};
 use crate::ty::Ty;
 
@@ -355,16 +355,16 @@ impl GemAncestry {
         }
     }
 
-    pub(super) fn receiver_gem<'a>(&self, ty: &Ty, census: &'a GemCensus) -> GemClaim<'a> {
+    pub(super) fn receiver_gem<'a>(&self, ty: &Ty, census: &'a GemCensus, declares: &dyn Fn(&str, &str) -> Option<bool>) -> GemClaim<'a> {
         match ty {
-            Ty::Class { id, .. } => self.class_gem(id, census),
+            Ty::Class { id, .. } => self.class_gem(id, census, declares),
             Ty::Union { variants } => {
                 let mut claim = GemClaim::Absent;
                 let mut missing = false;
                 // Match nullable dispatch: nil is not a concrete receiver arm.
                 // Every other arm must identify the same single gem.
                 for variant in variants.iter().filter(|ty| !matches!(ty, Ty::Nil)) {
-                    match self.receiver_gem(variant, census) {
+                    match self.receiver_gem(variant, census, declares) {
                         GemClaim::Absent => missing = true,
                         GemClaim::Uncertain => return GemClaim::Uncertain,
                         GemClaim::Known { gem, constant } => {
@@ -394,7 +394,7 @@ impl GemAncestry {
         }
     }
 
-    fn class_gem<'a>(&self, id: &ClassId, census: &'a GemCensus) -> GemClaim<'a> {
+    fn class_gem<'a>(&self, id: &ClassId, census: &'a GemCensus, declares: &dyn Fn(&str, &str) -> Option<bool>) -> GemClaim<'a> {
         let mut pending = vec![id.clone()];
         let mut seen = HashSet::new();
         let mut candidates = BTreeMap::new();
@@ -410,7 +410,7 @@ impl GemAncestry {
                     pending.push(target);
                 }
             } else {
-                for gem in gems_owning_constant(census, id.0.as_str()) {
+                for gem in gems_owning_constant_with(census, id.0.as_str(), declares) {
                     candidates
                         .entry(gem)
                         .and_modify(|witness: &mut String| {