code_transpiler/
signature.rs1use 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
153pub 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}