1use crate::{CollectionColumns, Type};
2use serde::{Deserialize, Serialize};
3use std::fmt::Display;
4
5#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
13pub enum SyntaxShape {
14 Any,
16
17 Custom(Box<str>),
20
21 Binary,
23
24 Block,
26
27 Boolean,
29
30 CellPath,
32
33 Closure(Option<Vec<SyntaxShape>>),
35
36 DateTime,
38
39 Directory,
41
42 Duration,
44
45 Error,
47
48 Expression,
50
51 ExternalArgument,
56
57 Filepath,
59
60 Filesize,
62
63 Float,
65
66 FullCellPath,
70
71 GlobPattern,
73
74 Int,
76
77 ImportPattern,
79
80 Keyword(Vec<u8>, Box<SyntaxShape>),
82
83 List(Box<SyntaxShape>),
85
86 MathExpression,
88
89 MatchBlock,
91
92 Nothing,
94
95 Number,
97
98 OneOf(Vec<SyntaxShape>),
102
103 Operator,
105
106 Range,
108
109 Record(CollectionColumns<SyntaxShape>),
111
112 RowCondition,
115
116 Signature,
118
119 ExternalSignature,
121
122 String,
124
125 Table(CollectionColumns<SyntaxShape>),
127
128 VarWithOptType,
130}
131
132impl SyntaxShape {
133 pub fn to_type(&self) -> Type {
144 match self {
145 SyntaxShape::Any => Type::Any,
146 SyntaxShape::Custom(name) => Type::Custom(name.clone()),
147 SyntaxShape::Block => Type::Block,
148 SyntaxShape::Closure(_) => Type::Closure,
149 SyntaxShape::Binary => Type::Binary,
150 SyntaxShape::CellPath => Type::CellPath,
151 SyntaxShape::DateTime => Type::Date,
152 SyntaxShape::Duration => Type::Duration,
153 SyntaxShape::Expression => Type::Any,
154 SyntaxShape::ExternalArgument => Type::Any,
155 SyntaxShape::Filepath => Type::String,
156 SyntaxShape::Directory => Type::String,
157 SyntaxShape::Float => Type::Float,
158 SyntaxShape::Filesize => Type::Filesize,
159 SyntaxShape::FullCellPath => Type::Any,
160 SyntaxShape::GlobPattern => Type::Glob,
161 SyntaxShape::Error => Type::Error,
162 SyntaxShape::ImportPattern => Type::Any,
163 SyntaxShape::Int => Type::Int,
164 SyntaxShape::List(x) => {
165 let contents = x.to_type();
166 Type::List(Box::new(contents))
167 }
168 SyntaxShape::Keyword(_, expr) => expr.to_type(),
169 SyntaxShape::MatchBlock => Type::Any,
170 SyntaxShape::MathExpression => Type::Any,
171 SyntaxShape::Nothing => Type::Nothing,
172 SyntaxShape::Number => Type::Number,
173 SyntaxShape::OneOf(types) => Type::one_of(types.iter().map(SyntaxShape::to_type)),
174 SyntaxShape::Operator => Type::Any,
175 SyntaxShape::Range => Type::Range,
176 SyntaxShape::Record(entries) => Type::Record(entries.map(SyntaxShape::to_type)),
177 SyntaxShape::RowCondition => Type::Bool,
178 SyntaxShape::Boolean => Type::Bool,
179 SyntaxShape::Signature | SyntaxShape::ExternalSignature => Type::Any,
180 SyntaxShape::String => Type::String,
181 SyntaxShape::Table(columns) => Type::Table(columns.map(SyntaxShape::to_type)),
182 SyntaxShape::VarWithOptType => Type::Any,
183 }
184 }
185
186 pub fn record() -> Self {
187 Self::Record(Default::default())
188 }
189
190 pub fn table() -> Self {
191 Self::Table(Default::default())
192 }
193}
194
195impl Display for SyntaxShape {
196 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
197 match self {
198 SyntaxShape::Keyword(kw, shape) => {
199 write!(f, "\"{}\" {}", String::from_utf8_lossy(kw), shape)
200 }
201 SyntaxShape::Any => write!(f, "any"),
202 SyntaxShape::Custom(name) => write!(f, "{name}"),
203 SyntaxShape::String => write!(f, "string"),
204 SyntaxShape::CellPath => write!(f, "cell-path"),
205 SyntaxShape::FullCellPath => write!(f, "cell-path"),
206 SyntaxShape::Number => write!(f, "number"),
207 SyntaxShape::Range => write!(f, "range"),
208 SyntaxShape::Int => write!(f, "int"),
209 SyntaxShape::Float => write!(f, "float"),
210 SyntaxShape::Filepath => write!(f, "path"),
211 SyntaxShape::Directory => write!(f, "directory"),
212 SyntaxShape::GlobPattern => write!(f, "glob"),
213 SyntaxShape::ImportPattern => write!(f, "import"),
214 SyntaxShape::Block => write!(f, "block"),
215 SyntaxShape::Closure(args) => {
216 if let Some(args) = args {
217 let arg_vec: Vec<_> = args.iter().map(|x| x.to_string()).collect();
218 let arg_string = arg_vec.join(", ");
219 write!(f, "closure({arg_string})")
220 } else {
221 write!(f, "closure()")
222 }
223 }
224 SyntaxShape::Binary => write!(f, "binary"),
225 SyntaxShape::List(x) => write!(f, "list<{x}>"),
226 SyntaxShape::Table(columns) => write!(f, "table{columns}"),
227 SyntaxShape::Record(columns) => write!(f, "record{columns}"),
228 SyntaxShape::Filesize => write!(f, "filesize"),
229 SyntaxShape::Duration => write!(f, "duration"),
230 SyntaxShape::DateTime => write!(f, "datetime"),
231 SyntaxShape::Operator => write!(f, "operator"),
232 SyntaxShape::RowCondition => write!(
233 f,
234 "oneof<condition, {}>",
235 SyntaxShape::Closure(Some(vec![SyntaxShape::Any]))
236 ),
237 SyntaxShape::MathExpression => write!(f, "variable"),
238 SyntaxShape::VarWithOptType => write!(f, "vardecl"),
239 SyntaxShape::Signature => write!(f, "signature"),
240 SyntaxShape::ExternalSignature => write!(f, "external-signature"),
241 SyntaxShape::MatchBlock => write!(f, "match-block"),
242 SyntaxShape::Expression => write!(f, "expression"),
243 SyntaxShape::ExternalArgument => write!(f, "external-argument"),
244 SyntaxShape::Boolean => write!(f, "bool"),
245 SyntaxShape::Error => write!(f, "error"),
246 SyntaxShape::OneOf(list) => {
247 write!(f, "oneof")?;
248 let [first, rest @ ..] = &**list else {
249 return Ok(());
250 };
251 write!(f, "<{first}")?;
252 for t in rest {
253 write!(f, ", {t}")?;
254 }
255 f.write_str(">")
256 }
257 SyntaxShape::Nothing => write!(f, "nothing"),
258 }
259 }
260}