fix(analyser): pin vec call to exact-subtype scalar overload when one exists 🎯

The vec path only used find_function_candidates (loose compatibility),
so calls like `Tuple<Int, Int> - Tuple<Int, Int>` collected both
`-(Int, Int)` and `-(Number, Number)` as candidates and the analyser
LUB'd them into `Tuple<Number, Number>`. Scalar dispatch avoids this
by trying find_function (exact subtype match) first.

Mirror that step for vec: track `vec_exact` across the scope walk, and
when no scalar competes, prefer the exact-subtype match over loose
compatibles. Restores the precision the user expected.

The Any-args case (no scalar accepts Any) still falls to Dynamic with
multiple vec candidates and LUBs across their returns — that's the
"interesting" Tuple<Number, Number> behaviour the user signed off on.

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

Author: timfennis

ndc_analyser/src/scope.rs

@@ -417,6 +417,7 @@ impl ScopeTree {
         let mut env_scopes: Vec<usize> = Vec::default();
         let mut loose_candidates: Option<Vec<ResolvedVar>> = None;
         let mut loose_vec_candidates: Option<Vec<ResolvedVar>> = None;
+        let mut vec_exact: Option<ResolvedVar> = None;
         let mut all_by_name: Vec<ResolvedVar> = Vec::new();
 
         loop {
@@ -429,6 +430,16 @@ impl ScopeTree {
                 )));
             }
 
+            // 1b. Vec exact subtype match — record but keep walking, because a
+            //     scalar exact match in an outer scope still wins. First scope
+            //     to produce one takes priority (same shadowing rule as scalar).
+            if vec_exact.is_none()
+                && let Some(synthetic) = &vec_sig
+                && let Some(slot) = self.scopes[scope_ptr].find_function(ident, synthetic)
+            {
+                vec_exact = Some(self.resolve_found_local(ident, slot, &env_scopes));
+            }
+
             // 2. Upvalues with matching name — collect as candidates but continue
             //    walking, because the upvalue may be a different overload (e.g.
             //    different arity) and the exact match could be in a parent scope.
@@ -496,6 +507,13 @@ impl ScopeTree {
                     }
                 }
 
+                if vec_exact.is_none()
+                    && let Some(synthetic) = &vec_sig
+                    && let Some(slot) = self.global_scope.find_function(ident, synthetic)
+                {
+                    vec_exact = Some(ResolvedVar::Global { slot });
+                }
+
                 if loose_vec_candidates.is_none()
                     && let Some(synthetic) = &vec_sig
                 {
@@ -524,9 +542,16 @@ impl ScopeTree {
         let scalars = loose_candidates.unwrap_or_default();
         let vecs = loose_vec_candidates.unwrap_or_default();
 
-        // Statically pinnable vec call: no scalar competes and a single vec match.
-        if scalars.is_empty() && vecs.len() == 1 {
-            return Binding::Resolved(Candidate::vec(vecs[0]));
+        // Statically pinnable vec call: no scalar competes, and either the
+        // synthetic sig has an exact subtype match (mirroring scalar's
+        // find_function precedence) or only one loose vec candidate remains.
+        if scalars.is_empty() {
+            if let Some(exact) = vec_exact {
+                return Binding::Resolved(Candidate::vec(exact));
+            }
+            if vecs.len() == 1 {
+                return Binding::Resolved(Candidate::vec(vecs[0]));
+            }
         }
 
         if !scalars.is_empty() || !vecs.is_empty() {

tests/functional/programs/013_vector_math/009_vector_exact_match_precision.ndc

@@ -0,0 +1,25 @@
+// Vec dispatch should pick the most specific scalar overload by subtype
+// (mirroring scalar dispatch's `find_function` precedence), not collapse
+// to the LUB of every compatible overload. `Tuple<Int, Int> - Tuple<Int,
+// Int>` must infer as `Tuple<Int, Int>`, not `Tuple<Number, Number>`.
+let a: Tuple<Int, Int> = (1, 2);
+let b: Tuple<Int, Int> = (3, 4);
+let c: Tuple<Int, Int> = a - b;
+let d: Tuple<Int, Int> = c * c;
+assert_eq(d, (4, 4));
+
+// Chained: `+` keeps the precise element type through several operators.
+let e: Tuple<Int, Int> = a + b;
+let f: Tuple<Int, Int> = e + (10, 20);
+assert_eq(f, (14, 26));
+
+// Any args fall to LUB (no scalar `-(Any, Any)` exists, so vec dispatch
+// can't pin a single overload at compile time): `Tuple<Any, Any> -
+// Tuple<Any, Any>` infers as `Tuple<Number, Number>`, the LUB across
+// every numeric overload's return type.
+let l: List<Int> = [1, 2];
+let p: Tuple<Any, Any> = (l.first, l.first);
+let q: Tuple<Any, Any> = (l.last, l.last);
+let r: Tuple<Number, Number> = p - q;
+let s: Tuple<Number, Number> = r * r;
+assert_eq(s, (1, 1));