Skip to main content

code_transpiler/
signature.rs

1use crate::matrix::SparseMatrix;
2use std::collections::{BTreeMap, BTreeSet};
3
4pub const EXACT_SIGNATURE_CAPABILITY: &str = "function.signature.exact.v1";
5
6#[derive(Debug, Clone, PartialEq, Eq)]
7pub struct SignatureParameter {
8    pub name: String,
9    pub passing: String,
10    pub has_default: bool,
11}
12#[derive(Debug, Clone, PartialEq, Eq, Default)]
13pub struct SignatureArgument {
14    pub name: String,
15    pub spread: bool,
16}
17#[derive(Debug, Clone, PartialEq)]
18pub struct SignatureBinding {
19    pub parameter_arguments: SparseMatrix,
20    pub use_defaults: Vec<usize>,
21    pub argument_counts: Vec<usize>,
22}
23
24pub fn bind_signature(
25    parameters: &[SignatureParameter],
26    arguments: &[SignatureArgument],
27) -> Result<SignatureBinding, String> {
28    let rank: BTreeMap<&str, usize> = [
29        ("positional_only", 0),
30        ("positional_or_keyword", 1),
31        ("variadic_positional", 2),
32        ("keyword_only", 3),
33        ("variadic_keyword", 4),
34    ]
35    .into_iter()
36    .collect();
37    let mut names = BTreeMap::<String, usize>::new();
38    let mut positional = Vec::<usize>::new();
39    let mut var_pos: Option<usize> = None;
40    let mut var_kw: Option<usize> = None;
41    let mut last_rank = 0usize;
42    let mut seen_any = false;
43    let mut optional_pos = false;
44    for (i, p) in parameters.iter().enumerate() {
45        let order = *rank
46            .get(p.passing.as_str())
47            .ok_or_else(|| format!("invalid signature parameter {i}"))?;
48        if p.name.is_empty() {
49            return Err(format!("invalid signature parameter {i}"));
50        }
51        if names.insert(p.name.clone(), i).is_some() {
52            return Err(format!("duplicate parameter {:?}", p.name));
53        }
54        if seen_any && order < last_rank {
55            return Err(format!("parameter {:?} has invalid mode order", p.name));
56        }
57        seen_any = true;
58        last_rank = order;
59        match p.passing.as_str() {
60            "positional_only" | "positional_or_keyword" => {
61                if optional_pos && !p.has_default {
62                    return Err("required positional parameter after default".into());
63                }
64                optional_pos |= p.has_default;
65                positional.push(i);
66            }
67            "variadic_positional" => {
68                if var_pos.is_some() || p.has_default {
69                    return Err("invalid variadic positional parameter".into());
70                }
71                var_pos = Some(i);
72            }
73            "variadic_keyword" => {
74                if var_kw.is_some() || p.has_default {
75                    return Err("invalid variadic keyword parameter".into());
76                }
77                var_kw = Some(i);
78            }
79            "keyword_only" => {}
80            _ => unreachable!(),
81        }
82    }
83
84    let mut binding = SignatureBinding {
85        parameter_arguments: SparseMatrix::new(parameters.len(), arguments.len()),
86        use_defaults: vec![0; parameters.len()],
87        argument_counts: vec![0; parameters.len()],
88    };
89    let mut next_pos = 0usize;
90    let mut keywords = BTreeSet::<String>::new();
91    for (col, arg) in arguments.iter().enumerate() {
92        if arg.spread {
93            return Err(format!("argument {col} requires runtime spread expansion"));
94        }
95        let row = if arg.name.is_empty() {
96            if next_pos < positional.len() {
97                let r = Some(positional[next_pos]);
98                next_pos += 1;
99                r
100            } else {
101                var_pos
102            }
103        } else {
104            if !keywords.insert(arg.name.clone()) {
105                return Err(format!("duplicate keyword {:?}", arg.name));
106            }
107            match names.get(&arg.name).copied() {
108                Some(i)
109                    if matches!(
110                        parameters[i].passing.as_str(),
111                        "positional_or_keyword" | "keyword_only"
112                    ) =>
113                {
114                    Some(i)
115                }
116                _ => var_kw,
117            }
118        }
119        .ok_or_else(|| format!("argument {col} has no accepting parameter"))?;
120        binding.parameter_arguments.set(row, col, 1.0);
121    }
122    for (i, p) in parameters.iter().enumerate() {
123        let count = (0..arguments.len())
124            .filter(|&c| binding.parameter_arguments.at(i, c) != 0.0)
125            .count();
126        binding.argument_counts[i] = count;
127        if matches!(
128            p.passing.as_str(),
129            "variadic_positional" | "variadic_keyword"
130        ) {
131            continue;
132        }
133        if count > 1 {
134            return Err(format!("parameter {:?} supplied more than once", p.name));
135        }
136        if count == 0 {
137            if !p.has_default {
138                return Err(format!("missing required parameter {:?}", p.name));
139            }
140            binding.use_defaults[i] = 1;
141        }
142    }
143    Ok(binding)
144}
145
146#[derive(Debug, Clone, PartialEq, Eq)]
147pub struct FunctionSignatureContract {
148    pub binding: String,
149    pub default_evaluation: String,
150    pub parameters: Vec<SignatureParameter>,
151}
152
153/// Validate the optional exact_v1 named/default argument contract.
154pub fn validate_signature_contract(
155    contract: &FunctionSignatureContract,
156    evaluation: &str,
157) -> Result<bool, String> {
158    if contract.binding.is_empty() {
159        if !contract.default_evaluation.is_empty() {
160            return Err("default evaluation requires an explicit function binding contract".into());
161        }
162        if contract.parameters.iter().any(|p| !p.passing.is_empty()) {
163            return Err("parameter modes require exact binding".into());
164        }
165        return Ok(false);
166    }
167    if contract.binding != "exact_v1" {
168        if contract.default_evaluation.is_empty() {
169            if contract.parameters.iter().any(|p| !p.passing.is_empty()) {
170                return Err("parameter modes require exact binding".into());
171            }
172            return Ok(false);
173        }
174        return Err("unsupported function binding/default contract".into());
175    }
176    if !matches!(contract.default_evaluation.as_str(), "definition" | "call") {
177        return Err("unsupported function binding/default contract".into());
178    }
179    let args = contract
180        .parameters
181        .iter()
182        .filter_map(|p| match p.passing.as_str() {
183            "positional_only" | "positional_or_keyword" => Some(SignatureArgument::default()),
184            "keyword_only" => Some(SignatureArgument {
185                name: p.name.clone(),
186                spread: false,
187            }),
188            "variadic_positional" | "variadic_keyword" => None,
189            _ => Some(SignatureArgument::default()),
190        })
191        .collect::<Vec<_>>();
192    bind_signature(&contract.parameters, &args)?;
193    if evaluation != "eager_left_to_right" {
194        return Err("exact signatures currently require explicit eager evaluation".into());
195    }
196    Ok(true)
197}