fix(analyser): walk back scope.rs incompat filter to preserve runtime narrowing 🔄

The previous push pushed the incompat-Dynamic check from the analyser
down to scope.rs, returning Binding::None for calls where no overload's
params accepted the call's args. That works for trivially broken calls
(returns_int("…") etc.) but breaks code that relies on the static type
being wider than the runtime value — e.g. the common
`for line in lines { line = line.split(...); line.remove(0); }` shape,
where `line`'s static type widens to `Sequence<String>` via LUB even
though the runtime value is always a `List<String>`. The stricter
analyser dropped `remove(List, Int)` for being incompatible with
`Sequence<String>`, blocking valid runtime-dispatchable code (see
issue #143 for the underlying inference limitation).

Move the check back to the analyser's Dynamic-LUB path: candidates
still get filtered before contributing to the inferred return type
(so we don't synthesise a misleading concrete return for a doomed
call), but the candidate list flows through to the compiler/runtime
intact so runtime narrowing still has a chance to succeed.

Also reverts the `Map<Any, ()>` → `Map<Any, Any>` empty-value default
since it was tied to the same overly-strict story. The default-value
folding into `value_type` stays — strictly sound and orthogonal.

Test updates: bug0022 now expects "mismatched types: found Any but
expected String" (the call result widens to Any rather than blocking
the call); 013_002 substring reverted to the runtime-side wording.

Co-Authored-By: Claude Opus 4.7 (1M context) <[email protected]>

Author: timfennis

ndc_analyser/src/analyser.rs

@@ -1,7 +1,7 @@
 use std::collections::HashMap;
 use std::fmt::Debug;
 
-use crate::scope::{ScopeTree, TypeBinding};
+use crate::scope::{ScopeTree, TypeBinding, synthetic_vec_sig};
 use itertools::{Itertools, izip};
 use ndc_core::{StaticType, TypeSignature};
 use ndc_lexer::Span;
@@ -464,16 +464,15 @@ impl Analyser {
                 }
 
                 if let Some(default) = default {
-                    // The default value's type is what `map[missing]` returns,
-                    // so it contributes to the value type just like a regular
-                    // entry would.
+                    // The default is what `map[missing]` returns, so it
+                    // contributes to the value type just like a regular entry.
                     let default_type = self.analyse_or_any(default);
                     Self::fold_lub(&mut value_type, default_type);
                 }
 
                 Ok(StaticType::Map {
                     key: Box::new(key_type.unwrap_or(StaticType::Any)),
-                    value: Box::new(value_type.unwrap_or(StaticType::Any)),
+                    value: Box::new(value_type.unwrap_or_else(StaticType::unit)),
                 })
             }
             Expression::Return { value } => {
@@ -542,20 +541,29 @@ impl Analyser {
                 }
             }
             Binding::Dynamic(candidates) => {
-                // Runtime decides which candidate fires. LUB across every
-                // candidate's inferred return type — scalars contribute their
-                // declared return, vecs contribute `Tuple<elem_return; max_len>`.
-                // `LUB(Tuple<...>, scalar) = Any` in the type lattice, so the
-                // mixed case naturally falls to Any; pure-scalar Dynamic
-                // recovers the precision PR #140 had to pessimise.
-                // `resolve_function_binding` filters the all_by_name fallback
-                // by signature compatibility, so by the time we get here
-                // every candidate could plausibly accept the call's args.
-                let return_type = candidates
+                // Runtime decides which candidate fires. When every candidate
+                // is statically compatible with the call's args, LUB across
+                // their inferred returns — scalars contribute their declared
+                // return, vecs contribute `Tuple<elem_return; max_len>`. When
+                // any candidate isn't compat (this Dynamic came from the
+                // all_by_name fallback where a same-named binding exists but
+                // its signature doesn't match), widen to Any so we don't
+                // synthesise a precise return for a call that's likely to
+                // fail at runtime. Runtime narrowing of supertype args may
+                // still succeed; the imprecise Any keeps soundness without
+                // rejecting code the runtime can dispatch.
+                let all_compat = candidates
                     .iter()
-                    .map(|c| candidate_return(&self.scope_tree, c, argument_types))
-                    .reduce(|a, b| a.lub(&b))
-                    .unwrap_or(StaticType::Any);
+                    .all(|c| candidate_is_compat(&self.scope_tree, c, argument_types));
+                let return_type = if all_compat {
+                    candidates
+                        .iter()
+                        .map(|c| candidate_return(&self.scope_tree, c, argument_types))
+                        .reduce(|a, b| a.lub(&b))
+                        .unwrap_or(StaticType::Any)
+                } else {
+                    StaticType::Any
+                };
                 StaticType::Function {
                     parameters: None,
                     return_type: Box::new(return_type),
@@ -934,6 +942,44 @@ fn static_vec_axis_len(sig: &[StaticType]) -> Option<usize> {
     })
 }
 
+/// Whether a candidate's parameter types could accept the call's argument
+/// types. Used to gate the Dynamic-LUB so we don't synthesise a precise
+/// return for an all_by_name fallback that won't dispatch.
+///
+/// Examples (with `fn typed(s: String) -> Int` registered as `typed`):
+/// - scalar candidate for `typed`, call args `[Int]` → `false`
+/// - scalar candidate for `typed`, call args `[Any]` → `true`
+/// - scalar candidate for `+(Int, Int)`, call args `[Int]` → `false`
+///   (arity mismatch)
+fn candidate_is_compat(
+    scope_tree: &ScopeTree,
+    candidate: &Candidate,
+    argument_types: &[StaticType],
+) -> bool {
+    let StaticType::Function {
+        parameters: Some(params),
+        ..
+    } = scope_tree.get_type(candidate.var)
+    else {
+        return false;
+    };
+    if params.len() != argument_types.len() {
+        return false;
+    }
+    let check_sig = if candidate.vectorized {
+        match synthetic_vec_sig(argument_types) {
+            Some(s) => s,
+            None => return false,
+        }
+    } else {
+        argument_types.to_vec()
+    };
+    params
+        .iter()
+        .zip(check_sig.iter())
+        .all(|(p, a)| !p.is_incompatible_with(a))
+}
+
 #[derive(thiserror::Error, Debug)]
 #[error("{text}")]
 pub struct AnalysisError {

ndc_analyser/src/scope.rs

@@ -9,7 +9,7 @@ use std::fmt::{Debug, Formatter};
 /// contributes the LUB of its elements; scalar and `Any` positions pass
 /// through unchanged so the candidate lookup stays permissive enough that
 /// runtime values which turn out to be tuples can still vec.
-fn synthetic_vec_sig(sig: &[StaticType]) -> Option<Vec<StaticType>> {
+pub(crate) fn synthetic_vec_sig(sig: &[StaticType]) -> Option<Vec<StaticType>> {
     let mut axis: Option<usize> = None;
     let mut vec_possible = false;
     for arg in sig {
@@ -563,36 +563,8 @@ impl ScopeTree {
             return Binding::Dynamic(combined);
         }
 
-        // Filter the all_by_name fallback by signature compatibility:
-        // a concrete `Function<...>` slot whose parameters are
-        // incompatible with the call's args is guaranteed to fail
-        // dispatch at runtime, so leaving it in would let the analyser
-        // synthesise a misleading concrete return for a doomed call.
-        // `Any`-typed and variadic (`parameters: None`) slots stay — we
-        // can't statically tell what those would accept.
-        let filtered: Vec<ResolvedVar> = all_by_name
-            .into_iter()
-            .filter(|var| match self.get_type(*var) {
-                StaticType::Function {
-                    parameters: Some(params),
-                    ..
-                } => {
-                    params.len() == sig.len()
-                        && params
-                            .iter()
-                            .zip(sig)
-                            .all(|(p, a)| !p.is_incompatible_with(a))
-                }
-                StaticType::Function {
-                    parameters: None, ..
-                }
-                | StaticType::Any => true,
-                _ => false,
-            })
-            .collect();
-
-        if !filtered.is_empty() {
-            return Binding::Dynamic(filtered.into_iter().map(Candidate::scalar).collect());
+        if !all_by_name.is_empty() {
+            return Binding::Dynamic(all_by_name.into_iter().map(Candidate::scalar).collect());
         }
         Binding::None
     }

tests/functional/programs/013_vector_math/002_vector_error.ndc

@@ -1,2 +1,2 @@
-// expect-error: No function called '+' found that matches the arguments
+// expect-error: no function called '+' found matches the arguments
 (1,2) + (5,3,2)

tests/functional/programs/900_bugs/bug0022_incompat_dynamic_misinferred.ndc

@@ -1,11 +1,10 @@
-// expect-error: No function called 'returns_int' found that matches the arguments 'Int'
+// expect-error: mismatched types: found Any but expected String
 // `returns_int(42)` has no compatible overload — the only `returns_int`
-// declared takes a `String`. Before the fix, `resolve_function_binding`
-// fell back to all-by-name and emitted `Binding::Dynamic([returns_int])`
-// despite the type mismatch; the analyser then LUB'd its declared return
-// (`Int`) and reported "found Int but expected …" at downstream
-// assignments, masking the real bug. Now the fallback filters concrete-
-// Function slots whose params don't match the call, leaving the binding
-// empty so the call surfaces at compile time as "no function found".
+// declared takes a `String`. Before the fix, the analyser LUB'd every
+// candidate's declared return regardless of compatibility, so this call
+// was inferred as `Int` and the assignment errored with the misleading
+// "found Int but expected String". The Dynamic-LUB now drops to Any
+// when any candidate's params can't accept the call's args, so the
+// type mismatch surfaces against `Any` instead.
 fn returns_int(s: String) -> Int { 1 };
 let x: String = returns_int(42);