cairo_lang_syntax_codegen/
generator.rs

1use std::fs;
2use std::path::PathBuf;
3
4use genco::prelude::*;
5use xshell::Shell;
6
7use crate::cairo_spec::get_spec;
8use crate::spec::{Member, Node, NodeKind, Variant, Variants};
9
10pub fn project_root() -> PathBuf {
11    // This is the directory of Cargo.toml of the syntax_codegen crate.
12    let dir = env!("CARGO_MANIFEST_DIR");
13    // Pop the "/crates/cairo-lang-syntax-codegen" suffix.
14    let res = PathBuf::from(dir).parent().unwrap().parent().unwrap().to_owned();
15    assert!(res.join("Cargo.toml").exists(), "Could not find project root directory.");
16    res
17}
18
19pub fn ensure_file_content(filename: PathBuf, content: String) {
20    if let Ok(old_contents) = fs::read_to_string(&filename)
21        && old_contents == content
22    {
23        return;
24    }
25
26    fs::write(&filename, content).unwrap();
27}
28
29pub fn get_codes() -> Vec<(String, String)> {
30    vec![
31        (
32            "crates/cairo-lang-syntax/src/node/ast.rs".into(),
33            reformat_rust_code(generate_ast_code().to_string().unwrap()),
34        ),
35        (
36            "crates/cairo-lang-syntax/src/node/kind.rs".into(),
37            reformat_rust_code(generate_kinds_code().to_string().unwrap()),
38        ),
39        (
40            "crates/cairo-lang-syntax/src/node/key_fields.rs".into(),
41            reformat_rust_code(generate_key_fields_code().to_string().unwrap()),
42        ),
43    ]
44}
45
46pub fn reformat_rust_code(text: String) -> String {
47    // Since rustfmt is used with nightly features, it takes 2 runs to reach a fixed point.
48    reformat_rust_code_inner(reformat_rust_code_inner(text))
49}
50pub fn reformat_rust_code_inner(text: String) -> String {
51    let sh = Shell::new().unwrap();
52    let cmd = sh.cmd("rustfmt").env("RUSTUP_TOOLCHAIN", "nightly-2025-11-17");
53    let cmd_with_args = cmd.arg("--config-path").arg(project_root().join("rustfmt.toml"));
54    let mut stdout = cmd_with_args.stdin(text).read().unwrap();
55    if !stdout.ends_with('\n') {
56        stdout.push('\n');
57    }
58    stdout
59}
60
61fn generate_kinds_code() -> rust::Tokens {
62    let spec = get_spec();
63    let mut tokens = quote! {
64        $("// Autogenerated file. To regenerate, please run `cargo run --bin generate-syntax`.")
65        use core::fmt;
66        use serde::{Deserialize, Serialize};
67    };
68
69    // SyntaxKind.
70    let kinds = name_tokens(&spec, |k| !matches!(k, NodeKind::Enum { .. }));
71    let token_kinds = name_tokens(&spec, |k| matches!(k, NodeKind::Token { .. }));
72    let keyword_token_kinds =
73        name_tokens(&spec, |k| matches!(k, NodeKind::Token { is_keyword } if *is_keyword));
74    let terminal_kinds = name_tokens(&spec, |k| matches!(k, NodeKind::Terminal { .. }));
75    let keyword_terminal_kinds =
76        name_tokens(&spec, |k| matches!(k, NodeKind::Terminal { is_keyword, .. } if *is_keyword));
77
78    tokens.extend(quote! {
79        #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq, Serialize, Deserialize, salsa::Update)]
80        pub enum SyntaxKind {
81            $(for t in kinds => $t,)
82        }
83        impl SyntaxKind {
84            pub fn is_token(&self) -> bool {
85                matches!(
86                    *self,
87                    $(for t in token_kinds join ( | ) => SyntaxKind::$t)
88                )
89            }
90            pub fn is_terminal(&self) -> bool {
91                matches!(
92                    *self,
93                    $(for t in terminal_kinds join ( | ) => SyntaxKind::$t)
94                )
95            }
96            pub fn is_keyword_token(&self) -> bool {
97                matches!(
98                    *self,
99                    $(for t in keyword_token_kinds join ( | ) => SyntaxKind::$t)
100                )
101            }
102            pub fn is_keyword_terminal(&self) -> bool {
103                matches!(
104                    *self,
105                    $(for t in keyword_terminal_kinds join ( | ) => SyntaxKind::$t)
106                )
107            }
108        }
109        impl fmt::Display for SyntaxKind {
110            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
111                write!(f, "{self:?}")
112            }
113        }
114    });
115    tokens
116}
117
118/// Returns an iterator to the names of the tokens matching `predicate`.
119fn name_tokens(spec: &[Node], predicate: impl Fn(&NodeKind) -> bool) -> impl Iterator<Item = &str> {
120    spec.iter().filter(move |n| predicate(&n.kind)).map(|n| n.name.as_str())
121}
122
123fn generate_key_fields_code() -> rust::Tokens {
124    let spec = get_spec();
125    let mut arms = rust::Tokens::new();
126
127    for Node { name, kind } in spec {
128        match kind {
129            NodeKind::Struct { members } | NodeKind::Terminal { members, .. } => {
130                let mut fields = rust::Tokens::new();
131                let mut key_fields_range = 0..0;
132                for (i, member) in members.into_iter().enumerate() {
133                    let field_name = member.name;
134                    if member.key {
135                        if key_fields_range.is_empty() {
136                            key_fields_range = i..(i + 1);
137                        } else {
138                            assert_eq!(key_fields_range.end, i, "Key fields must be contiguous.");
139                            key_fields_range.end = i + 1;
140                        }
141                        if !fields.is_empty() {
142                            fields.extend(quote! { $(", ") });
143                        }
144                        fields.extend(quote!($field_name));
145                    }
146                }
147                if !fields.is_empty() {
148                    arms.extend(quote! {
149                        $("\n// Key fields:") $fields.$("\n")
150                    });
151                }
152                let key_fields_range =
153                    format!("{}..{}", key_fields_range.start, key_fields_range.end);
154                arms.extend(quote! {
155                    SyntaxKind::$name => $key_fields_range,
156                });
157            }
158            NodeKind::List { .. } | NodeKind::SeparatedList { .. } | NodeKind::Token { .. } => {
159                arms.extend(quote! {
160                    SyntaxKind::$name => 0..0,
161                });
162            }
163            NodeKind::Enum { .. } => {}
164        }
165    }
166    let tokens = quote! {
167        $("// Autogenerated file. To regenerate, please run `cargo run --bin generate-syntax`.")
168        use super::kind::SyntaxKind;
169        $("/// Gets the vector of children ids that are the indexing key for this SyntaxKind.")
170        $("///")
171        $("/// Each SyntaxKind has some children that are defined in the spec to be its indexing key")
172        $("/// for its stable pointer. See [super::stable_ptr].")
173        pub fn key_fields_range(kind: SyntaxKind) -> core::ops::Range<usize> {
174            match kind {
175                $arms
176            }
177        }
178    };
179    tokens
180}
181
182fn generate_ast_code() -> rust::Tokens {
183    let spec = get_spec();
184    let mut tokens = quote! {
185        $("// Autogenerated file. To regenerate, please run `cargo run --bin generate-syntax`.")
186        #![allow(clippy::match_single_binding)]
187        #![allow(clippy::too_many_arguments)]
188        #![allow(dead_code)]
189        #![allow(unused_variables)]
190        use std::ops::Deref;
191
192        use cairo_lang_filesystem::span::TextWidth;
193        use cairo_lang_filesystem::ids::SmolStrId;
194        use cairo_lang_utils::{extract_matches, Intern};
195        use salsa::Database;
196
197        use super::element_list::ElementList;
198        use super::green::GreenNodeDetails;
199        use super::kind::SyntaxKind;
200        use super::{
201            GreenId, GreenNode, SyntaxNode, SyntaxStablePtrId, Terminal, Token, TypedStablePtr,
202            TypedSyntaxNode,
203        };
204        #[path = "ast_ext.rs"]
205        mod ast_ext;
206    };
207    let spec_clone = spec.clone();
208    let all_tokens: Vec<_> =
209        spec_clone.iter().filter(|node| matches!(node.kind, NodeKind::Terminal { .. })).collect();
210    for Node { name, kind } in spec {
211        tokens.extend(match kind {
212            NodeKind::Enum { variants, missing_variant } => {
213                let variants_list = match variants {
214                    Variants::List(variants) => variants,
215                    Variants::AllTokens => all_tokens
216                        .iter()
217                        .map(|node| Variant { name: node.name.clone(), kind: node.name.clone() })
218                        .collect(),
219                };
220                gen_enum_code(name, variants_list, missing_variant)
221            }
222            NodeKind::Struct { members } => gen_struct_code(name, members, false),
223            NodeKind::Terminal { members, .. } => gen_struct_code(name, members, true),
224            NodeKind::Token { .. } => gen_token_code(name),
225            NodeKind::List { element_type } => gen_list_code(name, element_type),
226            NodeKind::SeparatedList { element_type, separator_type } => {
227                gen_separated_list_code(name, element_type, separator_type)
228            }
229        });
230    }
231    tokens
232}
233
234fn gen_list_code(name: String, element_type: String) -> rust::Tokens {
235    // TODO(spapini): Change Deref to Borrow.
236    let ptr_name = format!("{name}Ptr");
237    let green_name = format!("{name}Green");
238    let element_green_name = format!("{element_type}Green");
239    let common_code = gen_common_list_code(&name, &green_name, &ptr_name);
240    quote! {
241        #[derive(Clone, Debug, Eq, Hash, PartialEq, salsa::Update)]
242        pub struct $(&name)<'db>(ElementList<'db, $(&element_type)<'db>, 1>);
243        impl<'db> Deref for $(&name)<'db>{
244            type Target = ElementList<'db, $(&element_type)<'db>, 1>;
245            fn deref(&self) -> &Self::Target {
246                &self.0
247            }
248        }
249        impl<'db> $(&name)<'db>{
250            pub fn new_green(
251                db: &'db dyn Database, children: &[$(&element_green_name)<'db>]
252            ) -> $(&green_name)<'db> {
253                let width = children.iter().map(|id|
254                    id.0.long(db).width(db)).sum();
255                $(&green_name)(GreenNode {
256                    kind: SyntaxKind::$(&name),
257                    details: GreenNodeDetails::Node {
258                        children: children.iter().map(|x| x.0).collect(),
259                        width,
260                    },
261                }.intern(db))
262            }
263        }
264        #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, salsa::Update)]
265        pub struct $(&ptr_name)<'db>(pub SyntaxStablePtrId<'db>);
266        impl<'db> TypedStablePtr<'db> for $(&ptr_name)<'db> {
267            type SyntaxNode = $(&name)<'db>;
268            fn untyped(self) -> SyntaxStablePtrId<'db> {
269                self.0
270            }
271            fn lookup(&self, db: &'db dyn Database) -> $(&name)<'db> {
272                $(&name)::from_syntax_node(db, self.0.lookup(db))
273            }
274        }
275        impl<'db> From<$(&ptr_name)<'db>> for SyntaxStablePtrId<'db> {
276            fn from(ptr: $(&ptr_name)<'db>) -> Self {
277                ptr.untyped()
278            }
279        }
280        $common_code
281    }
282}
283
284fn gen_separated_list_code(
285    name: String,
286    element_type: String,
287    separator_type: String,
288) -> rust::Tokens {
289    // TODO(spapini): Change Deref to Borrow.
290    let ptr_name = format!("{name}Ptr");
291    let green_name = format!("{name}Green");
292    let element_or_separator_green_name = format!("{name}ElementOrSeparatorGreen");
293    let element_green_name = format!("{element_type}Green");
294    let separator_green_name = format!("{separator_type}Green");
295    let common_code = gen_common_list_code(&name, &green_name, &ptr_name);
296    quote! {
297        #[derive(Clone, Debug, Eq, Hash, PartialEq, salsa::Update)]
298        pub struct $(&name)<'db>(ElementList<'db, $(&element_type)<'db>, 2>);
299        impl<'db> Deref for $(&name)<'db>{
300            type Target = ElementList<'db, $(&element_type)<'db>, 2>;
301            fn deref(&self) -> &Self::Target {
302                &self.0
303            }
304        }
305        impl<'db> $(&name)<'db>{
306            pub fn new_green(
307                db: &'db dyn Database, children: &[$(&element_or_separator_green_name)<'db>]
308            ) -> $(&green_name)<'db> {
309                let width = children.iter().map(|id|
310                    id.id().long(db).width(db)).sum();
311                $(&green_name)(GreenNode {
312                    kind: SyntaxKind::$(&name),
313                    details: GreenNodeDetails::Node {
314                        children: children.iter().map(|x| x.id()).collect(),
315                        width,
316                    },
317                }.intern(db))
318            }
319        }
320        #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, salsa::Update)]
321        pub struct $(&ptr_name)<'db>(pub SyntaxStablePtrId<'db>);
322        impl<'db> TypedStablePtr<'db> for $(&ptr_name)<'db> {
323            type SyntaxNode = $(&name)<'db>;
324            fn untyped(self) -> SyntaxStablePtrId<'db> {
325                self.0
326            }
327            fn lookup(&self, db: &'db dyn Database) -> $(&name)<'db> {
328                $(&name)::from_syntax_node(db, self.0.lookup(db))
329            }
330        }
331        impl<'db> From<$(&ptr_name)<'db>> for SyntaxStablePtrId<'db> {
332            fn from(ptr: $(&ptr_name)<'db>) -> Self {
333                ptr.untyped()
334            }
335        }
336        #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, salsa::Update)]
337        pub enum $(&element_or_separator_green_name)<'db> {
338            Separator($(&separator_green_name)<'db>),
339            Element($(&element_green_name)<'db>),
340        }
341        impl<'db> From<$(&separator_green_name)<'db>> for $(&element_or_separator_green_name)<'db> {
342            fn from(value: $(&separator_green_name)<'db>) -> Self {
343                $(&element_or_separator_green_name)::Separator(value)
344            }
345        }
346        impl<'db> From<$(&element_green_name)<'db>> for $(&element_or_separator_green_name)<'db> {
347            fn from(value: $(&element_green_name)<'db>) -> Self {
348                $(&element_or_separator_green_name)::Element(value)
349            }
350        }
351        impl<'db> $(&element_or_separator_green_name)<'db> {
352            fn id(&self) -> GreenId<'db> {
353                match self {
354                    $(&element_or_separator_green_name)::Separator(green) => green.0,
355                    $(&element_or_separator_green_name)::Element(green) => green.0,
356                }
357            }
358        }
359        $common_code
360    }
361}
362
363fn gen_common_list_code(name: &str, green_name: &str, ptr_name: &str) -> rust::Tokens {
364    quote! {
365        #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, salsa::Update)]
366        pub struct $green_name<'db>(pub GreenId<'db>);
367        impl<'db> TypedSyntaxNode<'db> for $name<'db> {
368            const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::$name);
369            type StablePtr = $ptr_name<'db>;
370            type Green = $green_name<'db>;
371            fn missing(db: &'db dyn Database) -> Self::Green {
372                $green_name(
373                    GreenNode {
374                        kind: SyntaxKind::$name,
375                        details: GreenNodeDetails::Node { children: [].into(), width: TextWidth::default() },
376                    }.intern(db)
377                )
378            }
379            fn from_syntax_node(db: &'db dyn Database, node: SyntaxNode<'db>) -> Self {
380                Self(ElementList::new(node))
381            }
382            fn cast(db: &'db dyn Database, node: SyntaxNode<'db>) -> Option<Self> {
383                if node.kind(db) == SyntaxKind::$name {
384                    Some(Self(ElementList::new(node)))
385                } else {
386                    None
387                }
388            }
389            fn as_syntax_node(&self) -> SyntaxNode<'db> {
390                self.node
391            }
392            fn stable_ptr(&self, db: &'db dyn Database) -> Self::StablePtr {
393                $ptr_name(self.node.stable_ptr(db))
394            }
395        }
396    }
397}
398
399fn gen_enum_code(
400    name: String,
401    variants: Vec<Variant>,
402    missing_variant: Option<Variant>,
403) -> rust::Tokens {
404    let ptr_name = format!("{name}Ptr");
405    let green_name = format!("{name}Green");
406    let mut enum_body = quote! {};
407    let mut from_node_body = quote! {};
408    let mut cast_body = quote! {};
409    let mut ptr_conversions = quote! {};
410    let mut green_conversions = quote! {};
411    for variant in &variants {
412        let n = &variant.name;
413        let k = &variant.kind;
414
415        enum_body.extend(quote! {
416            $n($k<'db>),
417        });
418        from_node_body.extend(quote! {
419            SyntaxKind::$k => $(&name)::$n($k::from_syntax_node(db, node)),
420        });
421        cast_body.extend(quote! {
422            SyntaxKind::$k => Some($(&name)::$n($k::from_syntax_node(db, node))),
423        });
424        let variant_ptr = format!("{k}Ptr");
425        ptr_conversions.extend(quote! {
426            impl<'db> From<$(&variant_ptr)<'db>> for $(&ptr_name)<'db> {
427                fn from(value: $(&variant_ptr)<'db>) -> Self {
428                    Self(value.0)
429                }
430            }
431        });
432        let variant_green = format!("{k}Green");
433        green_conversions.extend(quote! {
434            impl<'db> From<$(&variant_green)<'db>> for $(&green_name)<'db> {
435                fn from(value: $(&variant_green)<'db>) -> Self {
436                    Self(value.0)
437                }
438            }
439        });
440    }
441    let missing_body = match missing_variant {
442        Some(missing) => quote! {
443            $(&green_name)($(missing.kind)::missing(db).0)
444        },
445        None => quote! {
446            panic!("No missing variant.");
447        },
448    };
449    quote! {
450        #[derive(Clone, Debug, Eq, Hash, PartialEq, salsa::Update)]
451        pub enum $(&name)<'db>{
452            $enum_body
453        }
454        #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, salsa::Update)]
455        pub struct $(&ptr_name)<'db>(pub SyntaxStablePtrId<'db>);
456        impl<'db> TypedStablePtr<'db> for $(&ptr_name)<'db> {
457            type SyntaxNode = $(&name)<'db>;
458            fn untyped(self) -> SyntaxStablePtrId<'db> {
459                self.0
460            }
461            fn lookup(&self, db: &'db dyn Database) -> Self::SyntaxNode {
462                $(&name)::from_syntax_node(db, self.0.lookup(db))
463            }
464        }
465        impl<'db> From<$(&ptr_name)<'db>> for SyntaxStablePtrId<'db> {
466            fn from(ptr: $(&ptr_name)<'db>) -> Self {
467                ptr.untyped()
468            }
469        }
470        $ptr_conversions
471        $green_conversions
472        #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, salsa::Update)]
473        pub struct $(&green_name)<'db>(pub GreenId<'db>);
474        impl<'db> TypedSyntaxNode<'db> for $(&name)<'db>{
475            const OPTIONAL_KIND: Option<SyntaxKind> = None;
476            type StablePtr = $(&ptr_name)<'db>;
477            type Green = $(&green_name)<'db>;
478            fn missing(db: &'db dyn Database) -> Self::Green {
479                $missing_body
480            }
481            fn from_syntax_node(db: &'db dyn Database, node: SyntaxNode<'db>) -> Self {
482                let kind = node.kind(db);
483                match kind{
484                    $from_node_body
485                    _ => panic!(
486                        "Unexpected syntax kind {:?} when constructing {}.",
487                        kind,
488                        $[str]($[const](&name))),
489                }
490            }
491            fn cast(db: &'db dyn Database, node: SyntaxNode<'db>) -> Option<Self> {
492                let kind = node.kind(db);
493                match kind {
494                    $cast_body
495                    _ => None,
496                }
497            }
498            fn as_syntax_node(&self) -> SyntaxNode<'db> {
499                match self {
500                    $(for v in &variants => $(&name)::$(&v.name)(x) => x.as_syntax_node(),)
501                }
502            }
503            fn stable_ptr(&self, db: &'db dyn Database) -> Self::StablePtr {
504                $(&ptr_name)(self.as_syntax_node().stable_ptr(db))
505            }
506        }
507        impl<'db> $(&name)<'db> {
508            $("/// Checks if a kind of a variant of [")$(&name)$("].")
509            pub fn is_variant(kind: SyntaxKind) -> bool {
510                matches!(kind, $(for v in &variants join (|) => SyntaxKind::$(&v.kind)))
511            }
512        }
513    }
514}
515
516fn gen_token_code(name: String) -> rust::Tokens {
517    let green_name = format!("{name}Green");
518    let ptr_name = format!("{name}Ptr");
519
520    quote! {
521        #[derive(Clone, Debug, Eq, Hash, PartialEq, salsa::Update)]
522        pub struct $(&name)<'db> {
523            node: SyntaxNode<'db>,
524        }
525        impl<'db> Token<'db> for $(&name)<'db> {
526            fn new_green(db: &'db dyn Database, text: SmolStrId<'db>) -> Self::Green {
527                $(&green_name)(GreenNode {
528                    kind: SyntaxKind::$(&name),
529                    details: GreenNodeDetails::Token(text),
530                }.intern(db))
531            }
532            fn text(&self, db: &'db dyn Database) -> SmolStrId<'db> {
533                *extract_matches!(&self.node.green_node(db).details,
534                    GreenNodeDetails::Token)
535            }
536        }
537        #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, salsa::Update)]
538        pub struct $(&ptr_name)<'db>(pub SyntaxStablePtrId<'db>);
539        impl<'db> TypedStablePtr<'db> for $(&ptr_name)<'db> {
540            type SyntaxNode = $(&name)<'db>;
541            fn untyped(self) -> SyntaxStablePtrId<'db> {
542                self.0
543            }
544            fn lookup(&self, db: &'db dyn Database) -> $(&name)<'db> {
545                $(&name)::from_syntax_node(db, self.0.lookup(db))
546            }
547        }
548        impl<'db> From<$(&ptr_name)<'db>> for SyntaxStablePtrId<'db> {
549            fn from(ptr: $(&ptr_name)<'db>) -> Self {
550                ptr.untyped()
551            }
552        }
553        #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, salsa::Update)]
554        pub struct $(&green_name)<'db>(pub GreenId<'db>);
555        impl<'db> $(&green_name)<'db> {
556            pub fn text(&self, db: &'db dyn Database) -> SmolStrId<'db> {
557                *extract_matches!(&self.0.long(db).details, GreenNodeDetails::Token)
558            }
559        }
560        impl<'db> TypedSyntaxNode<'db> for $(&name)<'db>{
561            const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::$(&name));
562            type StablePtr = $(&ptr_name)<'db>;
563            type Green = $(&green_name)<'db>;
564            fn missing(db: &'db dyn Database) -> Self::Green {
565                $(&green_name)(GreenNode {
566                    kind: SyntaxKind::TokenMissing,
567                    details: GreenNodeDetails::Token(SmolStrId::from(db, "")),
568                }.intern(db))
569            }
570            fn from_syntax_node(db: &'db dyn Database, node: SyntaxNode<'db>) -> Self {
571                match node.green_node(db).details {
572                    GreenNodeDetails::Token(_) => Self { node },
573                    GreenNodeDetails::Node { .. } => panic!(
574                        "Expected a token {:?}, not an internal node",
575                        SyntaxKind::$(&name)
576                    ),
577                }
578            }
579            fn cast(db: &'db dyn Database, node: SyntaxNode<'db>) -> Option<Self> {
580                match node.green_node(db).details {
581                    GreenNodeDetails::Token(_) => Some(Self { node }),
582                    GreenNodeDetails::Node { .. } => None,
583                }
584            }
585            fn as_syntax_node(&self) -> SyntaxNode<'db> {
586                self.node
587            }
588            fn stable_ptr(&self, db: &'db dyn Database) -> Self::StablePtr {
589                $(&ptr_name)(self.node.stable_ptr(db))
590            }
591        }
592    }
593}
594
595fn gen_struct_code(name: String, members: Vec<Member>, is_terminal: bool) -> rust::Tokens {
596    let green_name = format!("{name}Green");
597    let mut body = rust::Tokens::new();
598    let mut field_indices = quote! {};
599    let mut args = quote! {};
600    let mut params = quote! {};
601    let mut args_for_missing = quote! {};
602    let mut ptr_getters = quote! {};
603    let mut key_field_index: usize = 0;
604    for (i, Member { name, kind, key }) in members.iter().enumerate() {
605        let index_name = format!("INDEX_{}", name.to_uppercase());
606        field_indices.extend(quote! {
607            pub const $index_name : usize = $i;
608        });
609        let key_name_green = format!("{name}_green");
610        args.extend(quote! {$name.0,});
611        // TODO(spapini): Validate that children SyntaxKinds are as expected.
612
613        let child_green = format!("{kind}Green");
614        params.extend(quote! {$name: $(&child_green)<'db>,});
615        body.extend(quote! {
616            pub fn $name(&self, db: &'db dyn Database) -> $kind<'db> {
617                $kind::from_syntax_node(db, self.node.get_children(db)[$i])
618            }
619        });
620        args_for_missing.extend(quote! {$kind::missing(db).0,});
621
622        if *key {
623            ptr_getters.extend(quote! {
624                pub fn $(&key_name_green)(self, db: &'db dyn Database) -> $(&child_green)<'db> {
625                    $(&child_green)(self.0.0.key_fields(db)[$key_field_index])
626                }
627            });
628            key_field_index += 1;
629        }
630    }
631    let ptr_name = format!("{name}Ptr");
632    let new_green_impl = if is_terminal {
633        let token_name = name.replace("Terminal", "Token");
634        quote! {
635            impl<'db> Terminal<'db> for $(&name)<'db> {
636                const KIND: SyntaxKind = SyntaxKind::$(&name);
637                type TokenType = $(&token_name)<'db>;
638                fn new_green(
639                    db: &'db dyn Database,
640                    leading_trivia: TriviaGreen<'db>,
641                    token: <<$(&name)<'db> as Terminal<'db>>::TokenType as TypedSyntaxNode<'db>>::Green,
642                    trailing_trivia: TriviaGreen<'db>
643                ) -> Self::Green {
644                    let children = [$args];
645                    let width =
646                        children.into_iter().map(|id: GreenId<'_>| id.long(db).width(db)).sum();
647                    $(&green_name)(GreenNode {
648                        kind: SyntaxKind::$(&name),
649                        details: GreenNodeDetails::Node { children: children.into(), width },
650                    }.intern(db))
651                }
652                fn text(&self, db: &'db dyn Database) -> SmolStrId<'db> {
653                    let GreenNodeDetails::Node{children,..} = &self.node.green_node(db).details else {
654                        unreachable!("Expected a node, not a token");
655                    };
656                    *extract_matches!(&children[1].long(db).details, GreenNodeDetails::Token)
657                }
658            }
659        }
660    } else {
661        quote! {
662            impl<'db> $(&name)<'db> {
663                $field_indices
664                pub fn new_green(db: &'db dyn Database, $params) -> $(&green_name)<'db> {
665                    let children = [$args];
666                    let width =
667                        children.into_iter().map(|id: GreenId<'_>| id.long(db).width(db)).sum();
668                    $(&green_name)(GreenNode {
669                        kind: SyntaxKind::$(&name),
670                        details: GreenNodeDetails::Node { children: children.into(), width },
671                    }.intern(db))
672                }
673            }
674        }
675    };
676    quote! {
677        #[derive(Clone, Debug, Eq, Hash, PartialEq, salsa::Update)]
678        pub struct $(&name)<'db> {
679            node: SyntaxNode<'db>,
680        }
681        $new_green_impl
682        impl<'db> $(&name)<'db> {
683            $body
684        }
685        #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, salsa::Update)]
686        pub struct $(&ptr_name)<'db>(pub SyntaxStablePtrId<'db>);
687        impl<'db> $(&ptr_name)<'db> {
688            $ptr_getters
689        }
690        impl<'db> TypedStablePtr<'db> for $(&ptr_name)<'db> {
691            type SyntaxNode = $(&name)<'db>;
692            fn untyped(self) -> SyntaxStablePtrId<'db> {
693                self.0
694            }
695            fn lookup(&self, db: &'db dyn Database) -> $(&name)<'db> {
696                $(&name)::from_syntax_node(db, self.0.lookup(db))
697            }
698        }
699        impl<'db> From<$(&ptr_name)<'db>> for SyntaxStablePtrId<'db> {
700            fn from(ptr: $(&ptr_name)<'db>) -> Self {
701                ptr.untyped()
702            }
703        }
704        #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, salsa::Update)]
705        pub struct $(&green_name)<'db>(pub GreenId<'db>);
706        impl<'db> TypedSyntaxNode<'db> for $(&name)<'db> {
707            const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::$(&name));
708            type StablePtr = $(&ptr_name)<'db>;
709            type Green = $(&green_name)<'db>;
710            fn missing(db: &'db dyn Database) -> Self::Green {
711                // Note: A missing syntax element should result in an internal green node
712                // of width 0, with as much structure as possible.
713                $(&green_name)(GreenNode {
714                    kind: SyntaxKind::$(&name),
715                    details: GreenNodeDetails::Node {
716                        children: [$args_for_missing].into(),
717                        width: TextWidth::default(),
718                    },
719                }.intern(db))
720            }
721            fn from_syntax_node(db: &'db dyn Database, node: SyntaxNode<'db>) -> Self {
722                let kind = node.kind(db);
723                assert_eq!(kind, SyntaxKind::$(&name), "Unexpected SyntaxKind {:?}. Expected {:?}.", kind, SyntaxKind::$(&name));
724                Self { node }
725            }
726            fn cast(db: &'db dyn Database, node: SyntaxNode<'db>) -> Option<Self> {
727                let kind = node.kind(db);
728                if kind == SyntaxKind::$(&name) {
729                    Some(Self::from_syntax_node(db, node))
730                } else {
731                    None
732                }
733            }
734            fn as_syntax_node(&self) -> SyntaxNode<'db> {
735                self.node
736            }
737            fn stable_ptr(&self, db: &'db dyn Database) -> Self::StablePtr {
738                $(&ptr_name)(self.node.stable_ptr(db))
739            }
740        }
741    }
742}
cairo_lang_syntax_codegen/generator.rs

cairo_lang_syntax_codegen/
generator.rs
