Prevent failed declaration diagnostic cascades

Retain failed global, local, and awaited declarations as semantic poison bindings so later references preserve navigation without producing unrelated unknown-variable or type errors. Propagate the poison through contextual typing and common expression forms while keeping strict compilation and code generation blocked by the original diagnostics.

Author: CryZe

TODO.md

@@ -55,8 +55,7 @@ or behavioral parity.
   compiler revision for future campaigns as provenance, not because this
   campaign used a different compiler.
 - [ ] Continue refreshing the ASL migration catalog and cookbook for
-  non-lifecycle misunderstandings found by the campaign. Suppress predictable
-  follow-on errors after a missing member or failed declaration. Do not add
+  non-lifecycle misunderstandings found by the campaign. Do not add
   compatibility aliases.
 - [ ] Use those maintained ports to decide each next implementation slice.
   Exercise the existing fixed-array search, `Set<String>`, and explicit native
@@ -155,11 +154,6 @@ or behavioral parity.
   straightforward to model process names, 32/64-bit memory, modules, failed
   reads, settings snapshots, timer state, attach/detach/restart, and bounded
   async polling. A compile-only port is never labelled faithful.
-- [ ] Improve missing-member recovery so one unknown method does not create
-  unrelated unknown-local cascades. The corpus-proven immutable `String`
-  surface now includes explicit ASCII normalization, fallible numeric parsing,
-  raw UTF-8 byte inspection, and Unicode `char` inspection under one
-  byte-index policy; add further operations only from maintained-port evidence.
 - [ ] Add an explicit `f32`/`f64` bit-pattern construction form and expose the
   exact rounded bits for decimal literals in tooling. Decimal exponent syntax,
   representable subnormal lowering, formatter preservation, and target-width

docs/ROADMAP_ARCHIVE.md

@@ -1,5 +1,21 @@
 # SplitScript roadmap
 
+## 2026-08-09: cascade-free failed-declaration recovery
+
+- Failed global, local, and suspending `let` initializers now retain their
+  declared source identity with an internal poison type. Later references no
+  longer become misleading unknown-variable errors merely because the
+  initializer already produced a focused diagnostic.
+- The poison type absorbs contextual unification and capability requirements,
+  and propagates through member access, indexing, calls, and operators without
+  inventing secondary type errors. Strict compilation still fails and the
+  poison type can never reach code generation.
+- Preserved editor navigation through invalid code: go to definition and rename
+  continue to resolve a failed binding while inlay hints hide its deliberately
+  unknown type. Regression coverage includes globals, ordinary locals, and
+  awaited declarations plus chained members, indexes, calls, comparisons, and
+  generic `Display` consumers.
+
 ## 2026-08-09: Unicode characters and explicit UTF-8 string inspection
 
 - Added the nominal `char` type and single-quoted literals for exactly one

src/inference.rs

@@ -285,6 +285,20 @@ impl InferenceContext {
         &self.types
     }
 
+    /// Produces the semantic poison type used after an already-diagnosed
+    /// expression failure. It preserves declaration identity for later editor
+    /// queries without making the failed program eligible for code generation.
+    pub(crate) fn error_type(&mut self) -> Type {
+        Type::Known(self.types.id_for_error())
+    }
+
+    pub(crate) fn is_error_type(&mut self, ty: Type) -> bool {
+        matches!(
+            self.shallow(ty),
+            Type::Known(id) if matches!(self.types.kind(id), TypeKind::Error)
+        )
+    }
+
     pub(crate) fn standard_type(&self, ty: Type) -> Option<StdlibTypeId> {
         let Type::Known(id) = ty else {
             return None;
@@ -526,6 +540,9 @@ impl InferenceContext {
     pub(crate) fn unify(&mut self, left: Type, right: Type) -> Result<Type, InferenceError> {
         let left = self.shallow(left);
         let right = self.shallow(right);
+        if self.is_error_type(left) || self.is_error_type(right) {
+            return Ok(self.error_type());
+        }
         match (left, right) {
             (Type::Variable(left), Type::Variable(right)) => self.unify_variables(left, right),
             (Type::Variable(variable), ty) | (ty, Type::Variable(variable)) => {
@@ -580,7 +597,11 @@ impl InferenceContext {
         ty: Type,
         requirements: Requirements,
     ) -> Result<(), InferenceError> {
-        match self.shallow(ty) {
+        let ty = self.shallow(ty);
+        if self.is_error_type(ty) {
+            return Ok(());
+        }
+        match ty {
             Type::Variable(variable) => {
                 let variable = self.root(variable);
                 let combined =
@@ -1347,6 +1368,12 @@ fn type_meets_requirements(
     if matches!(ty, Type::Variable(_)) {
         return true;
     }
+    if matches!(
+        ty,
+        Type::Known(id) if matches!(types.kind(id), TypeKind::Error)
+    ) {
+        return true;
+    }
     requirements
         .0
         .iter()

src/typeck.rs

@@ -325,6 +325,9 @@ impl Checker {
         };
         let expected = self.shallow_type(expected);
         let actual_shallow = self.shallow_type(actual);
+        if self.is_error_type(actual_shallow) || self.is_error_type(expected) {
+            return Some(self.error_type());
+        }
         let none = self.core_type(crate::stdlib::CoreTypeId::None);
         let nested_wrapper_lift = match (expected, actual_shallow) {
             (Type::Option(option), Type::Result(_)) => matches!(
@@ -417,6 +420,14 @@ impl Checker {
         self.inference.shallow(ty)
     }
 
+    fn error_type(&mut self) -> Type {
+        self.inference.error_type()
+    }
+
+    fn is_error_type(&mut self, ty: Type) -> bool {
+        self.inference.is_error_type(ty)
+    }
+
     fn unify(&mut self, left: Type, right: Type, span: Span) -> Option<Type> {
         match self.inference.unify(left, right) {
             Ok(ty) => Some(ty),

src/typeck/body_pass.rs

@@ -59,43 +59,44 @@ fn check_global_initializers(checker: &mut Checker, program: &Program) {
         );
         let run_scoped_initializer = checker.semantics.standard_library_item(global.value.id)
             == Some(crate::stdlib::StdlibItemId::SetNew);
-        if !constant_initializer && !run_scoped_initializer {
+        let initializer_checked = inferred.is_some();
+        if initializer_checked && !constant_initializer && !run_scoped_initializer {
             checker.error(
                 "global initializers must be literal values composed from None, numbers, booleans, strings, payload-free enums, records, or arrays, or a run-scoped Set.new value",
                 global.value.span,
             );
         }
-        if let Some(ty) = inferred {
-            let unsupported_standard = checker.standard_type_id(ty).is_some_and(|standard| {
-                standard != StdlibTypeId::String
-                    && !checker
-                        .standard_library
-                        .type_decl(standard)
-                        .value_usage
-                        .global_variable
-            });
-            if unsupported_standard
-                || matches!(ty, Type::Result(_))
-                || matches!(ty, Type::Option(_))
-                    && !matches!(global.value.kind, crate::ast::ExprKind::None)
-            {
-                let ty = checker.type_name(ty);
-                checker.error(
-                    format!("global variables cannot currently store `{ty}`"),
-                    global.span,
-                );
-            }
-            checker.semantics.resolve_value_type(global.id, ty);
-            checker.declarations.globals.insert(
-                global.name.clone(),
-                Binding {
-                    id: Some(global.id),
-                    ty,
-                    mutable: global.mutable,
-                    debug_only: global.debug_only,
-                },
+        let mut ty = inferred.unwrap_or_else(|| checker.error_type());
+        let unsupported_standard = checker.standard_type_id(ty).is_some_and(|standard| {
+            standard != StdlibTypeId::String
+                && !checker
+                    .standard_library
+                    .type_decl(standard)
+                    .value_usage
+                    .global_variable
+        });
+        if unsupported_standard
+            || matches!(ty, Type::Result(_))
+            || matches!(ty, Type::Option(_))
+                && !matches!(global.value.kind, crate::ast::ExprKind::None)
+        {
+            let name = checker.type_name(ty);
+            checker.error(
+                format!("global variables cannot currently store `{name}`"),
+                global.span,
             );
+            ty = checker.error_type();
         }
+        checker.semantics.resolve_value_type(global.id, ty);
+        checker.declarations.globals.insert(
+            global.name.clone(),
+            Binding {
+                id: Some(global.id),
+                ty,
+                mutable: global.mutable,
+                debug_only: global.debug_only,
+            },
+        );
     }
 }
 

src/typeck/call_resolution.rs

@@ -372,6 +372,12 @@ impl Checker {
                 }
                 let (method, receiver_path) = callee.split_last().unwrap();
                 let receiver = self.path(receiver_path, span, None)?;
+                if self.is_error_type(receiver.ty) {
+                    for argument in args {
+                        self.expr(argument, None);
+                    }
+                    return self.expect_expression(expression, receiver.ty, expected, span);
+                }
                 let receiver_value = receiver
                     .value
                     .expect("method receiver paths resolve to a declaration or snapshot value");
@@ -500,6 +506,12 @@ impl Checker {
         let standard_library = self.standard_library.clone();
         let base_type = self.expr(written_receiver, None)?;
         let base_type = self.shallow_type(base_type);
+        if self.is_error_type(base_type) {
+            for argument in args {
+                self.expr(argument, None);
+            }
+            return self.expect_expression(expression, base_type, expected, span);
+        }
         let method = callee.last().expect("postfix calls name a method");
         let (receiver_type, receiver_members) =
             self.resolve_members(base_type, &callee[..callee.len() - 1], span)?;
@@ -1231,6 +1243,9 @@ impl Checker {
         if fields.is_empty() {
             return Some((ty, Some(Vec::new())));
         }
+        if self.is_error_type(ty) {
+            return Some((ty, None));
+        }
         if matches!(self.shallow_type(ty), Type::Variable(_))
             && let Some(expression) = expression
         {

src/typeck/expressions.rs

@@ -749,6 +749,10 @@ impl Checker {
                 bracket_span,
             } => {
                 let receiver_ty = self.expr(receiver, None)?;
+                if self.is_error_type(receiver_ty) {
+                    self.expr(index, None);
+                    return self.expect_expression(expr.id, receiver_ty, expected, expr.span);
+                }
                 let element = match self.shallow_type(receiver_ty) {
                     Type::Array(array) => self.inference.array_element(array),
                     Type::Known(id) => match self.inference.type_store().kind(id) {
@@ -1018,6 +1022,15 @@ impl Checker {
         };
         let operand_ty = self.unify(left_ty, right_ty, span)?;
 
+        if self.is_error_type(operand_ty) {
+            let result = if result_is_bool {
+                self.core_type(crate::stdlib::CoreTypeId::Bool)
+            } else {
+                operand_ty
+            };
+            return self.expect_expression(expression, result, expected, span);
+        }
+
         if let Some(result) =
             self.resolve_binary_operator(op, operand_ty, expression, left.id, span)
         {

src/typeck/statements.rs

@@ -303,7 +303,8 @@ impl Checker {
                         self.unify(result, expected, value.span)
                     })
                 });
-                if let (Some(binding), Some(ty)) = (binding, result) {
+                if let Some(binding) = binding {
+                    let ty = result.unwrap_or_else(|| self.error_type());
                     let duplicate = self
                         .scopes
                         .iter()
@@ -397,33 +398,34 @@ impl Checker {
             );
         }
         let expected = variable.annotation.map(|ty| self.syntax_type(ty));
-        if let Some(ty) = self.expr(&variable.value, expected) {
-            let unsupported_standard = self.standard_type_id(ty).is_some_and(|standard| {
-                !self
-                    .standard_library
-                    .type_decl(standard)
-                    .value_usage
-                    .local_variable
-            });
-            if unsupported_standard {
-                let ty = self.type_name(ty);
-                self.error(
-                    format!("local variables cannot currently store `{ty}`"),
-                    variable.span,
-                );
-                return;
-            }
-            self.semantics.resolve_value_type(variable.id, ty);
-            self.scopes.last_mut().unwrap().insert(
-                variable.name.clone(),
-                Binding {
-                    id: Some(variable.id),
-                    ty,
-                    mutable: variable.mutable,
-                    debug_only: self.debug_context.is_debug() || variable.debug_only,
-                },
+        let mut ty = self
+            .expr(&variable.value, expected)
+            .unwrap_or_else(|| self.error_type());
+        let unsupported_standard = self.standard_type_id(ty).is_some_and(|standard| {
+            !self
+                .standard_library
+                .type_decl(standard)
+                .value_usage
+                .local_variable
+        });
+        if unsupported_standard {
+            let name = self.type_name(ty);
+            self.error(
+                format!("local variables cannot currently store `{name}`"),
+                variable.span,
             );
+            ty = self.error_type();
         }
+        self.semantics.resolve_value_type(variable.id, ty);
+        self.scopes.last_mut().unwrap().insert(
+            variable.name.clone(),
+            Binding {
+                id: Some(variable.id),
+                ty,
+                mutable: variable.mutable,
+                debug_only: self.debug_context.is_debug() || variable.debug_only,
+            },
+        );
     }
 
     pub(super) fn binding(&self, name: &str) -> Option<Binding> {