Check call argument names against signatures

Author: olwang

src/checks/calls.rs

@@ -1,7 +1,7 @@
 use std::collections::{HashMap, HashSet};
 
 use crate::analyzer::Analyzer;
-use crate::diagnostic::{Diagnostic, code};
+use crate::diagnostic::{Diagnostic, Span, code};
 use crate::syntax::ast::{Block, CallArg, Callee, DataEffect, Expr, Item, LetKind, Stmt};
 
 pub(crate) fn check(analyzer: &mut Analyzer<'_>) {
@@ -53,8 +53,10 @@ fn check_block(analyzer: &mut Analyzer<'_>, block: &Block, locals: &HashSet<Stri
 
 fn check_expr(analyzer: &mut Analyzer<'_>, expr: &Expr, locals: &HashSet<String>) {
     match expr {
-        Expr::Call { callee, args, .. } => {
-            check_call_args(analyzer, callee, args, locals);
+        Expr::Call {
+            callee, args, span, ..
+        } => {
+            check_call_args(analyzer, callee, args, span, locals);
             for arg in args {
                 check_expr(analyzer, &arg.value, locals);
             }
@@ -72,6 +74,7 @@ fn check_call_args(
     analyzer: &mut Analyzer<'_>,
     callee: &Callee,
     args: &[CallArg],
+    call_span: &Span,
     locals: &HashSet<String>,
 ) {
     let call_name = callee_name(callee);
@@ -101,6 +104,7 @@ fn check_call_args(
     let Some(signature) = analyzer.resolve_callee(callee) else {
         return;
     };
+    let signature_params = signature.params.clone();
     let param_effects: HashMap<String, &'static str> = signature
         .params
         .iter()
@@ -111,6 +115,63 @@ fn check_call_args(
         })
         .collect();
     let retained_params = signature.retained_params.clone();
+    let param_names: HashSet<String> = signature_params
+        .iter()
+        .map(|param| param.name.clone())
+        .collect();
+
+    for arg in args {
+        let Some(name) = &arg.name else {
+            continue;
+        };
+        if !param_names.contains(name) {
+            analyzer.diagnostics.push(
+                Diagnostic::error(
+                    code::UNKNOWN_ARGUMENT,
+                    format!("call to `{call_name}` has no argument named `{name}`."),
+                    arg.span.clone(),
+                    "unknown argument",
+                )
+                .with_cause(format!(
+                    "`{call_name}` does not declare a parameter named `{name}`."
+                ))
+                .with_fix(
+                    "rename_argument",
+                    format!("Use one of: {}.", join_param_names(&signature_params)),
+                    "manual",
+                ),
+            );
+        }
+    }
+
+    if args.iter().all(|arg| arg.name.is_some()) {
+        let provided_names: HashSet<&str> =
+            args.iter().filter_map(|arg| arg.name.as_deref()).collect();
+        for param in &signature_params {
+            if !provided_names.contains(param.name.as_str()) {
+                analyzer.diagnostics.push(
+                    Diagnostic::error(
+                        code::MISSING_ARGUMENT,
+                        format!(
+                            "call to `{call_name}` is missing required argument `{}`.",
+                            param.name
+                        ),
+                        call_span.clone(),
+                        "missing argument",
+                    )
+                    .with_cause(format!(
+                        "`{call_name}` requires a named argument `{}`.",
+                        param.name
+                    ))
+                    .with_fix(
+                        "add_argument",
+                        format!("Add `{}: ...` to the call.", param.name),
+                        "manual",
+                    ),
+                );
+            }
+        }
+    }
 
     for arg in args {
         let Some(name) = &arg.name else {
@@ -178,6 +239,14 @@ fn is_enum_variant_call(name: &str) -> bool {
     matches!(name, "Ok" | "Err" | "Some" | "None" | "Result" | "Option")
 }
 
+fn join_param_names(params: &[crate::hir::ParamSig]) -> String {
+    params
+        .iter()
+        .map(|param| param.name.as_str())
+        .collect::<Vec<_>>()
+        .join(", ")
+}
+
 fn callee_name(callee: &Callee) -> String {
     match callee {
         Callee::Name(name) => name.clone(),

src/diagnostic.rs

@@ -8,6 +8,8 @@ pub mod code {
     pub const FILE_MODE_VIOLATION: &str = "RS0101";
     pub const UNNAMED_ARGUMENT: &str = "RS0201";
     pub const MISSING_DATA_EFFECT: &str = "RS0202";
+    pub const UNKNOWN_ARGUMENT: &str = "RS0203";
+    pub const MISSING_ARGUMENT: &str = "RS0204";
     pub const MANAGED_TO_LOCAL: &str = "RS0301";
     pub const USE_AFTER_MANAGE: &str = "RS0401";
     pub const LOCAL_VALUE_RETAINED: &str = "RS0501";
@@ -219,6 +221,16 @@ static DIAGNOSTIC_EXPLANATIONS: &[DiagnosticExplanation] = &[
         title: "missing call-site data effect",
         explanation: "Arguments for non-Copy parameters must use an explicit `read`, `mut`, or `take` effect matching the callee signature.",
     },
+    DiagnosticExplanation {
+        code: code::UNKNOWN_ARGUMENT,
+        title: "unknown named argument",
+        explanation: "Named call arguments must match the resolved callee signature. This catches misspellings and stale call sites after API changes.",
+    },
+    DiagnosticExplanation {
+        code: code::MISSING_ARGUMENT,
+        title: "missing required argument",
+        explanation: "Every parameter in the resolved callee signature must be supplied by name at the call site.",
+    },
     DiagnosticExplanation {
         code: code::MANAGED_TO_LOCAL,
         title: "managed-to-local conversion",

tests/fixtures/fail/builtin-missing-named-argument.rss

@@ -0,0 +1,11 @@
+// expect: RS0204
+mode: uses-local
+
+struct Image {
+    pixels: Buffer
+}
+
+fn bad_resize_missing_width(path: read Path) -> Unit {
+    local image = Image.load(path: read path)
+    Image.resize(image: mut image, height: 600)
+}

tests/fixtures/fail/builtin-unknown-named-argument.rss

@@ -0,0 +1,11 @@
+// expect: RS0203
+mode: uses-local
+
+struct Image {
+    pixels: Buffer
+}
+
+fn bad_resize_argument_name(path: read Path) -> Unit {
+    local image = Image.load(path: read path)
+    Image.resize(image: mut image, widt: 800, height: 600)
+}