fix: sum over empty [Float] returns Float 0.0, not Int 0

The in-memory knot_relation_sum had no way to know whether it was
summing Floats or Ints, so it always returned Int(0) on empty —
diverging from the SQL-pushdown path and corrupting show/toJson output.

Fix: add knot_relation_sum_typed(db, f, rel, is_float) for fully-applied
calls. Inference records the span and result type of each full sum f rel
application, exports spans whose result is Float as SumFloatSpans.
Codegen special-cases fully-applied sum to call knot_relation_sum_typed
with the is_float flag from that span.

The old 3-arg knot_relation_sum keeps its Int 0 fallback for
first-class/partially-applied sum (no static type at the call site).

5 runtime tests + 1 end-to-end test. Full workspace green.

Author: ilyakooo0

crates/knot-compiler/src/codegen.rs

@@ -311,6 +311,11 @@ pub struct Codegen {
     // here, so the string from inference is the only carrier of the unit into
     // the emitted code.
     show_unit_strings: crate::infer::ShowUnitStrings,
+
+    // Spans of full `sum f rel` calls whose result is a Float. Passed to the
+    // runtime as `is_float` so an EMPTY relation sums to `Float 0.0` rather
+    // than `Int 0`. See `infer::SumFloatSpans`.
+    sum_float_spans: crate::infer::SumFloatSpans,
 }
 
 /// A top-level constant declared as a signature with no body
@@ -609,6 +614,7 @@ pub fn compile(
     elem_pushdown_ok: &crate::infer::ElemPushdownOk,
     trait_call_targets: &crate::infer::TraitCallTargets,
     show_unit_strings: &crate::infer::ShowUnitStrings,
+    sum_float_spans: &crate::infer::SumFloatSpans,
     compile_time_overrides: &HashMap<String, String>,
 ) -> Result<Vec<u8>, Vec<knot::diagnostic::Diagnostic>> {
     crate::stack::grow(|| {
@@ -624,6 +630,7 @@ pub fn compile(
             elem_pushdown_ok,
             trait_call_targets,
             show_unit_strings,
+            sum_float_spans,
             compile_time_overrides,
         )
     })
@@ -642,6 +649,7 @@ fn compile_inner(
     elem_pushdown_ok: &crate::infer::ElemPushdownOk,
     trait_call_targets: &crate::infer::TraitCallTargets,
     show_unit_strings: &crate::infer::ShowUnitStrings,
+    sum_float_spans: &crate::infer::SumFloatSpans,
     compile_time_overrides: &HashMap<String, String>,
 ) -> Result<Vec<u8>, Vec<knot::diagnostic::Diagnostic>> {
     let mut cg = Codegen::new();
@@ -677,6 +685,7 @@ fn compile_inner(
     cg.from_json_targets = from_json_targets.clone();
     cg.elem_pushdown_ok = elem_pushdown_ok.clone();
     cg.show_unit_strings = show_unit_strings.clone();
+    cg.sum_float_spans = sum_float_spans.clone();
     cg.source_refinements = type_env.source_refinements.clone();
     for (name, fields) in &type_env.constructors {
         let field_strs: Vec<(String, String)> = fields
@@ -948,6 +957,7 @@ impl Codegen {
             from_json_targets: HashMap::new(),
             elem_pushdown_ok: crate::infer::ElemPushdownOk::default(),
             show_unit_strings: HashMap::new(),
+            sum_float_spans: crate::infer::SumFloatSpans::new(),
         }
     }
 
@@ -1160,6 +1170,7 @@ impl Codegen {
         self.declare_rt("knot_relation_diff", &[p, p, p], &[p]);
         self.declare_rt("knot_relation_inter", &[p, p, p], &[p]);
         self.declare_rt("knot_relation_sum", &[p, p, p], &[p]);
+        self.declare_rt("knot_relation_sum_typed", &[p, p, p, types::I64], &[p]);
         self.declare_rt("knot_relation_avg", &[p, p, p], &[p]);
         self.declare_rt("knot_relation_min", &[p, p, p], &[p]);
         self.declare_rt("knot_relation_max", &[p, p, p], &[p]);
@@ -6536,6 +6547,30 @@ impl Codegen {
                     );
                 }
 
+        // Special case: `sum f rel` that did not push down to SQL above — pass
+        // the statically inferred numeric type so an EMPTY relation sums to the
+        // right zero. The runtime otherwise takes the type from the summands,
+        // of which there are none, and returns `Int 0` even for a `[Float]`
+        // (the SQL pushdown paths pass the same `is_float` flag, derived from
+        // the column type). Inference records the span only when the result is
+        // a Float; a user-defined `sum` skips this and dispatches normally.
+        if let ast::ExprKind::Var(name) = &func_expr.node
+            && name == "sum"
+                && args.len() == 2
+                && !user_shadows_special {
+                    let f_val = self.compile_expr(builder, args[0], env, db);
+                    let rel_val = self.compile_expr(builder, args[1], env, db);
+                    let is_float = builder.ins().iconst(
+                        types::I64,
+                        self.sum_float_spans.contains(&expr.span) as i64,
+                    );
+                    return self.call_rt(
+                        builder,
+                        "knot_relation_sum_typed",
+                        &[db, f_val, rel_val, is_float],
+                    );
+                }
+
         let compiled_args: Vec<Value> = args
             .iter()
             .map(|a| self.compile_arg_expr(builder, a, env, db))

crates/knot-compiler/src/infer.rs

@@ -144,6 +144,13 @@ pub struct FromJsonTarget {
 /// Maps parseJson call-site spans to their resolved target info.
 pub type FromJsonTargets = HashMap<Span, FromJsonTarget>;
 
+/// Spans of full `sum f rel` applications (including the `rel |> sum f` pipe
+/// form) whose result type is a Float. Codegen passes this as an `is_float`
+/// flag to the runtime, which needs it ONLY for an EMPTY relation: with no
+/// summands there is nothing to take the numeric type from, so `sum` over an
+/// empty `[Float]` would otherwise return `Int 0` instead of `Float 0.0`.
+pub type SumFloatSpans = HashSet<Span>;
+
 /// Spans of `elem needle haystack` haystack arguments whose element type is a
 /// SQL-pushable scalar (peeling aliases & refined types). Codegen consults these
 /// sets to decide whether to push an `elem` down to SQL.
@@ -595,6 +602,10 @@ struct Infer {
     /// `monad_info` entry keyed by the call span so codegen can tell the
     /// runtime which applicative's `pure []` an EMPTY input must produce.
     traverse_calls: Vec<(Span, TyVar, TyVar)>,
+    /// Full `sum f rel` applications: (call span, result type var).
+    /// Post-inference, calls whose result is a Float land in `SumFloatSpans`
+    /// so codegen can tell the runtime which zero an EMPTY relation sums to.
+    sum_calls: Vec<(Span, TyVar)>,
 
     /// Tracks `parseJson` application sites for compile-time FromJSON dispatch.
     /// Each entry records (app_span, return_type_var).
@@ -783,6 +794,7 @@ impl Infer {
             result_markers: Vec::new(),
             unify_depth: 0,
             traverse_calls: Vec::new(),
+            sum_calls: Vec::new(),
             from_json_calls: Vec::new(),
             trait_call_vars: Vec::new(),
             show_calls: Vec::new(),
@@ -4974,6 +4986,16 @@ impl Infer {
                             self.traverse_calls.push((expr.span, *res_v, cont_v));
                         }
 
+                // Track full `sum f rel` applications: the resolved result type
+                // says whether this is a Float sum, which codegen hands to the
+                // runtime to pick the zero for an EMPTY relation (no summand
+                // there to infer the numeric type from).
+                if let ast::ExprKind::App { func: inner_f, .. } = &func.node
+                    && matches!(&inner_f.node, ast::ExprKind::Var(n) if n == "sum")
+                        && let Ty::Var(res_v) = &result_ty {
+                            self.sum_calls.push((expr.span, *res_v));
+                        }
+
                 // Track `elem needle haystack` haystack types for SQL pushdown.
                 // Curried: outer App's func is `App(Var("elem"), needle)`,
                 // outer App's arg is the haystack. Record only when the
@@ -5973,6 +5995,13 @@ impl Infer {
                     Box::new(result_ty.clone()),
                 );
                 self.unify(&rhs_ty, &fun_ty, span);
+                // `rel |> sum f` reaches codegen as an application carrying
+                // this pipe's span, so record it like the `sum f rel` form.
+                if let ast::ExprKind::App { func: inner_f, .. } = &rhs.node
+                    && matches!(&inner_f.node, ast::ExprKind::Var(n) if n == "sum")
+                        && let Ty::Var(res_v) = &result_ty {
+                            self.sum_calls.push((span, *res_v));
+                        }
                 result_ty
             }
         }
@@ -10378,6 +10407,24 @@ fn value_references_source_inner(
 
 // ── Public API ────────────────────────────────────────────────────
 
+/// What `check` hands to the later passes: diagnostics, the inferred types
+/// themselves, and the span-keyed facts codegen cannot re-derive on its own
+/// (monad kinds, refine/parseJson targets, `elem` pushdown eligibility, `show`
+/// units, `sum`'s numeric result type).
+pub type CheckOutput = (
+    Vec<Diagnostic>,
+    MonadInfo,
+    TypeInfo,
+    LocalTypeInfo,
+    RefineTargets,
+    RefinedTypeInfoMap,
+    FromJsonTargets,
+    ElemPushdownOk,
+    TraitCallTargets,
+    ShowUnitStrings,
+    SumFloatSpans,
+);
+
 /// Run type inference on a parsed module. Returns diagnostics,
 /// resolved monad info for desugared do-blocks, and inferred type info
 /// mapping declaration names to their display type strings.
@@ -10390,11 +10437,11 @@ fn value_references_source_inner(
 ///
 /// Runs on a grown stack: a desugared `do` block nests one `__bind` per
 /// statement, and `infer_expr` recurses through every level.
-pub fn check(module: &mut ast::Module) -> (Vec<Diagnostic>, MonadInfo, TypeInfo, LocalTypeInfo, RefineTargets, RefinedTypeInfoMap, FromJsonTargets, ElemPushdownOk, TraitCallTargets, ShowUnitStrings) {
+pub fn check(module: &mut ast::Module) -> CheckOutput {
     crate::stack::grow(|| check_inner(module))
 }
 
-fn check_inner(module: &mut ast::Module) -> (Vec<Diagnostic>, MonadInfo, TypeInfo, LocalTypeInfo, RefineTargets, RefinedTypeInfoMap, FromJsonTargets, ElemPushdownOk, TraitCallTargets, ShowUnitStrings) {
+fn check_inner(module: &mut ast::Module) -> CheckOutput {
     let mut infer = Infer::new();
 
     // Phase 1: Collect type aliases, data types, constructors
@@ -10659,6 +10706,21 @@ fn check_inner(module: &mut ast::Module) -> (Vec<Diagnostic>, MonadInfo, TypeInf
         monad_info.entry(*span).or_insert(kind);
     }
 
+    // Phase 5c: Resolve the numeric type of each full `sum f rel` call, keyed
+    // by the call span. Codegen passes it to the runtime, which uses it ONLY
+    // for the EMPTY-input result: no summands means no value to take the type
+    // from, and the zero must still be the one the program was checked against
+    // (`Float 0.0`, not `Int 0`).
+    let mut sum_float_spans = SumFloatSpans::new();
+    for (span, res_v) in &infer.sum_calls {
+        if matches!(
+            infer.apply(&Ty::Var(*res_v)).peel_alias(),
+            Ty::Float | Ty::FloatUnit(_)
+        ) {
+            sum_float_spans.insert(*span);
+        }
+    }
+
     // Export refined type predicates for codegen
     let refined_type_info: RefinedTypeInfoMap = infer
         .refined_types
@@ -10722,7 +10784,7 @@ fn check_inner(module: &mut ast::Module) -> (Vec<Diagnostic>, MonadInfo, TypeInf
     let local_type_info = infer.extract_local_type_info();
     let elem_pushdown_ok = infer.elem_pushdown_ok.clone();
 
-    (infer.to_diagnostics(), monad_info, type_info, local_type_info, refine_targets, refined_type_info, from_json_targets, elem_pushdown_ok, trait_call_targets, show_unit_strings)
+    (infer.to_diagnostics(), monad_info, type_info, local_type_info, refine_targets, refined_type_info, from_json_targets, elem_pushdown_ok, trait_call_targets, show_unit_strings, sum_float_spans)
 }
 
 
@@ -11158,14 +11220,14 @@ mod tests {
     fn check_src(src: &str) -> Vec<Diagnostic> {
         let mut module = parse(src);
         crate::desugar::desugar(&mut module);
-        let (diags, _monad_info, _type_info, _local_types, _refine_targets, _refined_types, _from_json, _elem_pushdown, _trait_calls, _show_units) = check(&mut module);
+        let (diags, _monad_info, _type_info, _local_types, _refine_targets, _refined_types, _from_json, _elem_pushdown, _trait_calls, _show_units, _sum_floats) = check(&mut module);
         diags
     }
 
     fn type_info_for(src: &str) -> TypeInfo {
         let mut module = parse(src);
         crate::desugar::desugar(&mut module);
-        let (_diags, _monad_info, type_info, _local_types, _refine_targets, _refined_types, _from_json, _elem_pushdown, _trait_calls, _show_units) = check(&mut module);
+        let (_diags, _monad_info, type_info, _local_types, _refine_targets, _refined_types, _from_json, _elem_pushdown, _trait_calls, _show_units, _sum_floats) = check(&mut module);
         type_info
     }
 

crates/knot-compiler/src/main.rs

@@ -377,7 +377,7 @@ fn cmd_build(source_file: &str, output_override: Option<&std::path::Path>, overr
     let type_env = types::TypeEnv::from_module(&module);
 
     // Type inference
-    let (infer_diags, monad_info, type_info, _local_types, refine_targets, refined_types, from_json_targets, elem_pushdown_ok, trait_call_targets, show_unit_strings) = infer::check(&mut module);
+    let (infer_diags, monad_info, type_info, _local_types, refine_targets, refined_types, from_json_targets, elem_pushdown_ok, trait_call_targets, show_unit_strings, sum_float_spans) = infer::check(&mut module);
     if !infer_diags.is_empty() {
         for diag in &infer_diags {
             eprintln!("{}", diag.render(&source, &filename));
@@ -440,7 +440,7 @@ fn cmd_build(source_file: &str, output_override: Option<&std::path::Path>, overr
     }
 
     // Code generation
-    let obj_bytes = match codegen::compile(&module, &type_env, source_file, &monad_info, &refine_targets, &refined_types, &from_json_targets, &type_info, &elem_pushdown_ok, &trait_call_targets, &show_unit_strings, overrides) {
+    let obj_bytes = match codegen::compile(&module, &type_env, source_file, &monad_info, &refine_targets, &refined_types, &from_json_targets, &type_info, &elem_pushdown_ok, &trait_call_targets, &show_unit_strings, &sum_float_spans, overrides) {
         Ok(bytes) => bytes,
         Err(diags) => {
             for diag in &diags {

crates/knot-compiler/tests/regress_analysis_fixes.rs

@@ -34,7 +34,7 @@ fn parse(src: &str) -> knot::ast::Module {
 fn check_src(src: &str) -> Vec<Diagnostic> {
     let mut module = parse(src);
     knot_compiler::desugar::desugar(&mut module);
-    let (diags, _monad, _type_info, _local, _refine, _refined, _json, _elem, _trait_calls, _show_units) =
+    let (diags, _monad, _type_info, _local, _refine, _refined, _json, _elem, _trait_calls, _show_units, _sum_floats) =
         knot_compiler::infer::check(&mut module);
     diags
 }

crates/knot-compiler/tests/regress_deep_do.rs

@@ -115,7 +115,7 @@ fn deep_do_block_reaches_codegen_without_overflow() {
     knot_compiler::desugar::desugar(&mut module);
 
     let type_env = knot_compiler::types::TypeEnv::from_module(&module);
-    let (diags, monad_info, type_info, _local, refine_targets, refined, from_json, elem, trait_calls, show_units) =
+    let (diags, monad_info, type_info, _local, refine_targets, refined, from_json, elem, trait_calls, show_units, sum_floats) =
         knot_compiler::infer::check(&mut module);
     assert!(errors(&diags).is_empty(), "{:?}", errors(&diags));
 
@@ -131,6 +131,7 @@ fn deep_do_block_reaches_codegen_without_overflow() {
         &elem,
         &trait_calls,
         &show_units,
+        &sum_floats,
         &std::collections::HashMap::new(),
     )
     .expect("codegen should succeed on a deep do block");

crates/knot-compiler/tests/regress_infer.rs

@@ -22,7 +22,7 @@ fn check_full(
 ) -> (Vec<Diagnostic>, knot_compiler::infer::RefineTargets) {
     let mut module = parse(src);
     knot_compiler::desugar::desugar(&mut module);
-    let (diags, _monad, _type_info, _local, refine_targets, _refined, _json, _elem, _trait_calls, _show_units) =
+    let (diags, _monad, _type_info, _local, refine_targets, _refined, _json, _elem, _trait_calls, _show_units, _sum_floats) =
         knot_compiler::infer::check(&mut module);
     (diags, refine_targets)
 }

crates/knot-compiler/tests/regress_infer_fixes.rs

@@ -26,7 +26,7 @@ fn parse(src: &str) -> knot::ast::Module {
 fn check_src(src: &str) -> Vec<Diagnostic> {
     let mut module = parse(src);
     knot_compiler::desugar::desugar(&mut module);
-    let (diags, _monad, _type_info, _local, _targets, _refined, _json, _elem, _trait_calls, _show_units) =
+    let (diags, _monad, _type_info, _local, _targets, _refined, _json, _elem, _trait_calls, _show_units, _sum_floats) =
         knot_compiler::infer::check(&mut module);
     diags
 }

crates/knot-compiler/tests/regress_infer_fixes2.rs

@@ -41,7 +41,7 @@ fn check_src(src: &str) -> Vec<Diagnostic> {
     let mut module = parse(src);
     knot_compiler::base::inject_prelude(&mut module);
     knot_compiler::desugar::desugar(&mut module);
-    let (diags, _monad, _type_info, _local, _targets, _refined, _json, _elem, _trait_calls, _show_units) =
+    let (diags, _monad, _type_info, _local, _targets, _refined, _json, _elem, _trait_calls, _show_units, _sum_floats) =
         knot_compiler::infer::check(&mut module);
     diags
 }

crates/knot-compiler/tests/regress_infer_fixes3.rs

@@ -25,7 +25,7 @@ fn check_src(src: &str) -> Vec<Diagnostic> {
     let mut module = parse(src);
     knot_compiler::base::inject_prelude(&mut module);
     knot_compiler::desugar::desugar(&mut module);
-    let (diags, _monad, _type_info, _local, _targets, _refined, _json, _elem, _trait_calls, _show_units) =
+    let (diags, _monad, _type_info, _local, _targets, _refined, _json, _elem, _trait_calls, _show_units, _sum_floats) =
         knot_compiler::infer::check(&mut module);
     diags
 }

crates/knot-compiler/tests/regress_infer_fixes4.rs

@@ -28,7 +28,7 @@ fn check_src(src: &str) -> Vec<Diagnostic> {
     let mut module = parse(src);
     knot_compiler::base::inject_prelude(&mut module);
     knot_compiler::desugar::desugar(&mut module);
-    let (diags, _monad, _type_info, _local, _targets, _refined, _json, _elem, _trait_calls, _show_units) =
+    let (diags, _monad, _type_info, _local, _targets, _refined, _json, _elem, _trait_calls, _show_units, _sum_floats) =
         knot_compiler::infer::check(&mut module);
     diags
 }