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-12-05");
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    // Definition of 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, cairo_lang_proc_macros::HeapSize)]
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 cairo_lang_proc_macros::HeapSize;
196
197        use salsa::Database;
198
199        use super::element_list::ElementList;
200        use super::green::GreenNodeDetails;
201        use super::kind::SyntaxKind;
202        use super::{
203            GreenId, GreenNode, SyntaxNode, SyntaxStablePtrId, Terminal, Token, TypedStablePtr,
204            TypedSyntaxNode,
205        };
206        #[path = "ast_ext.rs"]
207        mod ast_ext;
208    };
209    let spec_clone = spec.clone();
210    let all_tokens: Vec<_> =
211        spec_clone.iter().filter(|node| matches!(node.kind, NodeKind::Terminal { .. })).collect();
212    for Node { name, kind } in spec {
213        tokens.extend(match kind {
214            NodeKind::Enum { variants, missing_variant } => {
215                let variants_list = match variants {
216                    Variants::List(variants) => variants,
217                    Variants::AllTokens => all_tokens
218                        .iter()
219                        .map(|node| Variant { name: node.name.clone(), kind: node.name.clone() })
220                        .collect(),
221                };
222                gen_enum_code(name, variants_list, missing_variant)
223            }
224            NodeKind::Struct { members } => gen_struct_code(name, members, false),
225            NodeKind::Terminal { members, .. } => gen_struct_code(name, members, true),
226            NodeKind::Token { .. } => gen_token_code(name),
227            NodeKind::List { element_type } => gen_list_code(name, element_type),
228            NodeKind::SeparatedList { element_type, separator_type } => {
229                gen_separated_list_code(name, element_type, separator_type)
230            }
231        });
232    }
233    tokens
234}
235
236fn gen_list_code(name: String, element_type: String) -> rust::Tokens {
237    // TODO(spapini): Change Deref to Borrow.
238    let ptr_name = format!("{name}Ptr");
239    let green_name = format!("{name}Green");
240    let element_green_name = format!("{element_type}Green");
241    let common_code = gen_common_list_code(&name, &green_name, &ptr_name);
242    quote! {
243        #[derive(Clone, Debug, Eq, Hash, PartialEq, salsa::Update)]
244        pub struct $(&name)<'db>(ElementList<'db, $(&element_type)<'db>, 1>);
245        impl<'db> Deref for $(&name)<'db>{
246            type Target = ElementList<'db, $(&element_type)<'db>, 1>;
247            fn deref(&self) -> &Self::Target {
248                &self.0
249            }
250        }
251        impl<'db> $(&name)<'db>{
252            pub fn new_green(
253                db: &'db dyn Database, children: &[$(&element_green_name)<'db>]
254            ) -> $(&green_name)<'db> {
255                let width = children.iter().map(|id|
256                    id.0.long(db).width(db)).sum();
257                $(&green_name)(GreenNode {
258                    kind: SyntaxKind::$(&name),
259                    details: GreenNodeDetails::Node {
260                        children: children.iter().map(|x| x.0).collect(),
261                        width,
262                    },
263                }.intern(db))
264            }
265        }
266        #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, salsa::Update, HeapSize)]
267        pub struct $(&ptr_name)<'db>(pub SyntaxStablePtrId<'db>);
268        impl<'db> TypedStablePtr<'db> for $(&ptr_name)<'db> {
269            type SyntaxNode = $(&name)<'db>;
270            fn untyped(self) -> SyntaxStablePtrId<'db> {
271                self.0
272            }
273            fn lookup(&self, db: &'db dyn Database) -> $(&name)<'db> {
274                $(&name)::from_syntax_node(db, self.0.lookup(db))
275            }
276        }
277        impl<'db> From<$(&ptr_name)<'db>> for SyntaxStablePtrId<'db> {
278            fn from(ptr: $(&ptr_name)<'db>) -> Self {
279                ptr.untyped()
280            }
281        }
282        $common_code
283    }
284}
285
286fn gen_separated_list_code(
287    name: String,
288    element_type: String,
289    separator_type: String,
290) -> rust::Tokens {
291    // TODO(spapini): Change Deref to Borrow.
292    let ptr_name = format!("{name}Ptr");
293    let green_name = format!("{name}Green");
294    let element_or_separator_green_name = format!("{name}ElementOrSeparatorGreen");
295    let element_green_name = format!("{element_type}Green");
296    let separator_green_name = format!("{separator_type}Green");
297    let common_code = gen_common_list_code(&name, &green_name, &ptr_name);
298    quote! {
299        #[derive(Clone, Debug, Eq, Hash, PartialEq, salsa::Update)]
300        pub struct $(&name)<'db>(ElementList<'db, $(&element_type)<'db>, 2>);
301        impl<'db> Deref for $(&name)<'db>{
302            type Target = ElementList<'db, $(&element_type)<'db>, 2>;
303            fn deref(&self) -> &Self::Target {
304                &self.0
305            }
306        }
307        impl<'db> $(&name)<'db>{
308            pub fn new_green(
309                db: &'db dyn Database, children: &[$(&element_or_separator_green_name)<'db>]
310            ) -> $(&green_name)<'db> {
311                let width = children.iter().map(|id|
312                    id.id().long(db).width(db)).sum();
313                $(&green_name)(GreenNode {
314                    kind: SyntaxKind::$(&name),
315                    details: GreenNodeDetails::Node {
316                        children: children.iter().map(|x| x.id()).collect(),
317                        width,
318                    },
319                }.intern(db))
320            }
321        }
322        #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, salsa::Update, HeapSize)]
323        pub struct $(&ptr_name)<'db>(pub SyntaxStablePtrId<'db>);
324        impl<'db> TypedStablePtr<'db> for $(&ptr_name)<'db> {
325            type SyntaxNode = $(&name)<'db>;
326            fn untyped(self) -> SyntaxStablePtrId<'db> {
327                self.0
328            }
329            fn lookup(&self, db: &'db dyn Database) -> $(&name)<'db> {
330                $(&name)::from_syntax_node(db, self.0.lookup(db))
331            }
332        }
333        impl<'db> From<$(&ptr_name)<'db>> for SyntaxStablePtrId<'db> {
334            fn from(ptr: $(&ptr_name)<'db>) -> Self {
335                ptr.untyped()
336            }
337        }
338        #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, salsa::Update)]
339        pub enum $(&element_or_separator_green_name)<'db> {
340            Separator($(&separator_green_name)<'db>),
341            Element($(&element_green_name)<'db>),
342        }
343        impl<'db> From<$(&separator_green_name)<'db>> for $(&element_or_separator_green_name)<'db> {
344            fn from(value: $(&separator_green_name)<'db>) -> Self {
345                $(&element_or_separator_green_name)::Separator(value)
346            }
347        }
348        impl<'db> From<$(&element_green_name)<'db>> for $(&element_or_separator_green_name)<'db> {
349            fn from(value: $(&element_green_name)<'db>) -> Self {
350                $(&element_or_separator_green_name)::Element(value)
351            }
352        }
353        impl<'db> $(&element_or_separator_green_name)<'db> {
354            fn id(&self) -> GreenId<'db> {
355                match self {
356                    $(&element_or_separator_green_name)::Separator(green) => green.0,
357                    $(&element_or_separator_green_name)::Element(green) => green.0,
358                }
359            }
360        }
361        $common_code
362    }
363}
364
365fn gen_common_list_code(name: &str, green_name: &str, ptr_name: &str) -> rust::Tokens {
366    quote! {
367        #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, salsa::Update)]
368        pub struct $green_name<'db>(pub GreenId<'db>);
369        impl<'db> TypedSyntaxNode<'db> for $name<'db> {
370            const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::$name);
371            type StablePtr = $ptr_name<'db>;
372            type Green = $green_name<'db>;
373            fn missing(db: &'db dyn Database) -> Self::Green {
374                $green_name(
375                    GreenNode {
376                        kind: SyntaxKind::$name,
377                        details: GreenNodeDetails::Node { children: [].into(), width: TextWidth::default() },
378                    }.intern(db)
379                )
380            }
381            fn from_syntax_node(db: &'db dyn Database, node: SyntaxNode<'db>) -> Self {
382                Self(ElementList::new(node))
383            }
384            fn cast(db: &'db dyn Database, node: SyntaxNode<'db>) -> Option<Self> {
385                if node.kind(db) == SyntaxKind::$name {
386                    Some(Self(ElementList::new(node)))
387                } else {
388                    None
389                }
390            }
391            fn as_syntax_node(&self) -> SyntaxNode<'db> {
392                self.node
393            }
394            fn stable_ptr(&self, db: &'db dyn Database) -> Self::StablePtr {
395                $ptr_name(self.node.stable_ptr(db))
396            }
397        }
398    }
399}
400
401fn gen_enum_code(
402    name: String,
403    variants: Vec<Variant>,
404    missing_variant: Option<Variant>,
405) -> rust::Tokens {
406    let ptr_name = format!("{name}Ptr");
407    let green_name = format!("{name}Green");
408    let mut enum_body = quote! {};
409    let mut from_node_body = quote! {};
410    let mut cast_body = quote! {};
411    let mut ptr_conversions = quote! {};
412    let mut green_conversions = quote! {};
413    for variant in &variants {
414        let n = &variant.name;
415        let k = &variant.kind;
416
417        enum_body.extend(quote! {
418            $n($k<'db>),
419        });
420        from_node_body.extend(quote! {
421            SyntaxKind::$k => $(&name)::$n($k::from_syntax_node(db, node)),
422        });
423        cast_body.extend(quote! {
424            SyntaxKind::$k => Some($(&name)::$n($k::from_syntax_node(db, node))),
425        });
426        let variant_ptr = format!("{k}Ptr");
427        ptr_conversions.extend(quote! {
428            impl<'db> From<$(&variant_ptr)<'db>> for $(&ptr_name)<'db> {
429                fn from(value: $(&variant_ptr)<'db>) -> Self {
430                    Self(value.0)
431                }
432            }
433        });
434        let variant_green = format!("{k}Green");
435        green_conversions.extend(quote! {
436            impl<'db> From<$(&variant_green)<'db>> for $(&green_name)<'db> {
437                fn from(value: $(&variant_green)<'db>) -> Self {
438                    Self(value.0)
439                }
440            }
441        });
442    }
443    let missing_body = match missing_variant {
444        Some(missing) => quote! {
445            $(&green_name)($(missing.kind)::missing(db).0)
446        },
447        None => quote! {
448            panic!("No missing variant.");
449        },
450    };
451    quote! {
452        #[derive(Clone, Debug, Eq, Hash, PartialEq, salsa::Update)]
453        pub enum $(&name)<'db>{
454            $enum_body
455        }
456        #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, salsa::Update, HeapSize)]
457        pub struct $(&ptr_name)<'db>(pub SyntaxStablePtrId<'db>);
458        impl<'db> TypedStablePtr<'db> for $(&ptr_name)<'db> {
459            type SyntaxNode = $(&name)<'db>;
460            fn untyped(self) -> SyntaxStablePtrId<'db> {
461                self.0
462            }
463            fn lookup(&self, db: &'db dyn Database) -> Self::SyntaxNode {
464                $(&name)::from_syntax_node(db, self.0.lookup(db))
465            }
466        }
467        impl<'db> From<$(&ptr_name)<'db>> for SyntaxStablePtrId<'db> {
468            fn from(ptr: $(&ptr_name)<'db>) -> Self {
469                ptr.untyped()
470            }
471        }
472        $ptr_conversions
473        $green_conversions
474        #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, salsa::Update)]
475        pub struct $(&green_name)<'db>(pub GreenId<'db>);
476        impl<'db> TypedSyntaxNode<'db> for $(&name)<'db>{
477            const OPTIONAL_KIND: Option<SyntaxKind> = None;
478            type StablePtr = $(&ptr_name)<'db>;
479            type Green = $(&green_name)<'db>;
480            fn missing(db: &'db dyn Database) -> Self::Green {
481                $missing_body
482            }
483            fn from_syntax_node(db: &'db dyn Database, node: SyntaxNode<'db>) -> Self {
484                let kind = node.kind(db);
485                match kind{
486                    $from_node_body
487                    _ => panic!(
488                        "Unexpected syntax kind {:?} when constructing {}.",
489                        kind,
490                        $[str]($[const](&name))),
491                }
492            }
493            fn cast(db: &'db dyn Database, node: SyntaxNode<'db>) -> Option<Self> {
494                let kind = node.kind(db);
495                match kind {
496                    $cast_body
497                    _ => None,
498                }
499            }
500            fn as_syntax_node(&self) -> SyntaxNode<'db> {
501                match self {
502                    $(for v in &variants => $(&name)::$(&v.name)(x) => x.as_syntax_node(),)
503                }
504            }
505            fn stable_ptr(&self, db: &'db dyn Database) -> Self::StablePtr {
506                $(&ptr_name)(self.as_syntax_node().stable_ptr(db))
507            }
508        }
509        impl<'db> $(&name)<'db> {
510            $("/// Checks if a kind of a variant of [")$(&name)$("].")
511            pub fn is_variant(kind: SyntaxKind) -> bool {
512                matches!(kind, $(for v in &variants join (|) => SyntaxKind::$(&v.kind)))
513            }
514        }
515    }
516}
517
518fn gen_token_code(name: String) -> rust::Tokens {
519    let green_name = format!("{name}Green");
520    let ptr_name = format!("{name}Ptr");
521
522    quote! {
523        #[derive(Clone, Debug, Eq, Hash, PartialEq, salsa::Update)]
524        pub struct $(&name)<'db> {
525            node: SyntaxNode<'db>,
526        }
527        impl<'db> Token<'db> for $(&name)<'db> {
528            fn new_green(db: &'db dyn Database, text: SmolStrId<'db>) -> Self::Green {
529                $(&green_name)(GreenNode {
530                    kind: SyntaxKind::$(&name),
531                    details: GreenNodeDetails::Token(text),
532                }.intern(db))
533            }
534            fn text(&self, db: &'db dyn Database) -> SmolStrId<'db> {
535                *extract_matches!(&self.node.green_node(db).details,
536                    GreenNodeDetails::Token)
537            }
538        }
539        #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, salsa::Update, HeapSize)]
540        pub struct $(&ptr_name)<'db>(pub SyntaxStablePtrId<'db>);
541        impl<'db> TypedStablePtr<'db> for $(&ptr_name)<'db> {
542            type SyntaxNode = $(&name)<'db>;
543            fn untyped(self) -> SyntaxStablePtrId<'db> {
544                self.0
545            }
546            fn lookup(&self, db: &'db dyn Database) -> $(&name)<'db> {
547                $(&name)::from_syntax_node(db, self.0.lookup(db))
548            }
549        }
550        impl<'db> From<$(&ptr_name)<'db>> for SyntaxStablePtrId<'db> {
551            fn from(ptr: $(&ptr_name)<'db>) -> Self {
552                ptr.untyped()
553            }
554        }
555        #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, salsa::Update)]
556        pub struct $(&green_name)<'db>(pub GreenId<'db>);
557        impl<'db> $(&green_name)<'db> {
558            pub fn text(&self, db: &'db dyn Database) -> SmolStrId<'db> {
559                *extract_matches!(&self.0.long(db).details, GreenNodeDetails::Token)
560            }
561        }
562        impl<'db> TypedSyntaxNode<'db> for $(&name)<'db>{
563            const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::$(&name));
564            type StablePtr = $(&ptr_name)<'db>;
565            type Green = $(&green_name)<'db>;
566            fn missing(db: &'db dyn Database) -> Self::Green {
567                $(&green_name)(GreenNode {
568                    kind: SyntaxKind::TokenMissing,
569                    details: GreenNodeDetails::Token(SmolStrId::from(db, "")),
570                }.intern(db))
571            }
572            fn from_syntax_node(db: &'db dyn Database, node: SyntaxNode<'db>) -> Self {
573                match node.green_node(db).details {
574                    GreenNodeDetails::Token(_) => Self { node },
575                    GreenNodeDetails::Node { .. } => panic!(
576                        "Expected a token {:?}, not an internal node",
577                        SyntaxKind::$(&name)
578                    ),
579                }
580            }
581            fn cast(db: &'db dyn Database, node: SyntaxNode<'db>) -> Option<Self> {
582                match node.green_node(db).details {
583                    GreenNodeDetails::Token(_) => Some(Self { node }),
584                    GreenNodeDetails::Node { .. } => None,
585                }
586            }
587            fn as_syntax_node(&self) -> SyntaxNode<'db> {
588                self.node
589            }
590            fn stable_ptr(&self, db: &'db dyn Database) -> Self::StablePtr {
591                $(&ptr_name)(self.node.stable_ptr(db))
592            }
593        }
594    }
595}
596
597fn gen_struct_code(name: String, members: Vec<Member>, is_terminal: bool) -> rust::Tokens {
598    let green_name = format!("{name}Green");
599    let mut body = rust::Tokens::new();
600    let mut field_indices = quote! {};
601    let mut args = quote! {};
602    let mut params = quote! {};
603    let mut args_for_missing = quote! {};
604    let mut ptr_getters = quote! {};
605    let mut key_field_index: usize = 0;
606    for (i, Member { name, kind, key }) in members.iter().enumerate() {
607        let index_name = format!("INDEX_{}", name.to_uppercase());
608        field_indices.extend(quote! {
609            pub const $index_name : usize = $i;
610        });
611        let key_name_green = format!("{name}_green");
612        args.extend(quote! {$name.0,});
613        // TODO(spapini): Validate that children SyntaxKinds are as expected.
614
615        let child_green = format!("{kind}Green");
616        params.extend(quote! {$name: $(&child_green)<'db>,});
617        body.extend(quote! {
618            pub fn $name(&self, db: &'db dyn Database) -> $kind<'db> {
619                $kind::from_syntax_node(db, self.node.get_children(db)[$i])
620            }
621        });
622        args_for_missing.extend(quote! {$kind::missing(db).0,});
623
624        if *key {
625            ptr_getters.extend(quote! {
626                pub fn $(&key_name_green)(self, db: &'db dyn Database) -> $(&child_green)<'db> {
627                    $(&child_green)(self.0.0.key_fields(db)[$key_field_index])
628                }
629            });
630            key_field_index += 1;
631        }
632    }
633    let ptr_name = format!("{name}Ptr");
634    let new_green_impl = if is_terminal {
635        let token_name = name.replace("Terminal", "Token");
636        quote! {
637            impl<'db> Terminal<'db> for $(&name)<'db> {
638                const KIND: SyntaxKind = SyntaxKind::$(&name);
639                type TokenType = $(&token_name)<'db>;
640                fn new_green(
641                    db: &'db dyn Database,
642                    leading_trivia: TriviaGreen<'db>,
643                    token: <<$(&name)<'db> as Terminal<'db>>::TokenType as TypedSyntaxNode<'db>>::Green,
644                    trailing_trivia: TriviaGreen<'db>
645                ) -> Self::Green {
646                    let children = [$args];
647                    let width =
648                        children.into_iter().map(|id: GreenId<'_>| id.long(db).width(db)).sum();
649                    $(&green_name)(GreenNode {
650                        kind: SyntaxKind::$(&name),
651                        details: GreenNodeDetails::Node { children: children.into(), width },
652                    }.intern(db))
653                }
654                fn text(&self, db: &'db dyn Database) -> SmolStrId<'db> {
655                    let GreenNodeDetails::Node{children,..} = &self.node.green_node(db).details else {
656                        unreachable!("Expected a node, not a token");
657                    };
658                    *extract_matches!(&children[1].long(db).details, GreenNodeDetails::Token)
659                }
660            }
661        }
662    } else {
663        quote! {
664            impl<'db> $(&name)<'db> {
665                $field_indices
666                pub fn new_green(db: &'db dyn Database, $params) -> $(&green_name)<'db> {
667                    let children = [$args];
668                    let width =
669                        children.into_iter().map(|id: GreenId<'_>| id.long(db).width(db)).sum();
670                    $(&green_name)(GreenNode {
671                        kind: SyntaxKind::$(&name),
672                        details: GreenNodeDetails::Node { children: children.into(), width },
673                    }.intern(db))
674                }
675            }
676        }
677    };
678    quote! {
679        #[derive(Clone, Debug, Eq, Hash, PartialEq, salsa::Update)]
680        pub struct $(&name)<'db> {
681            node: SyntaxNode<'db>,
682        }
683        $new_green_impl
684        impl<'db> $(&name)<'db> {
685            $body
686        }
687        #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, salsa::Update, HeapSize)]
688        pub struct $(&ptr_name)<'db>(pub SyntaxStablePtrId<'db>);
689        impl<'db> $(&ptr_name)<'db> {
690            $ptr_getters
691        }
692        impl<'db> TypedStablePtr<'db> for $(&ptr_name)<'db> {
693            type SyntaxNode = $(&name)<'db>;
694            fn untyped(self) -> SyntaxStablePtrId<'db> {
695                self.0
696            }
697            fn lookup(&self, db: &'db dyn Database) -> $(&name)<'db> {
698                $(&name)::from_syntax_node(db, self.0.lookup(db))
699            }
700        }
701        impl<'db> From<$(&ptr_name)<'db>> for SyntaxStablePtrId<'db> {
702            fn from(ptr: $(&ptr_name)<'db>) -> Self {
703                ptr.untyped()
704            }
705        }
706        #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, salsa::Update)]
707        pub struct $(&green_name)<'db>(pub GreenId<'db>);
708        impl<'db> TypedSyntaxNode<'db> for $(&name)<'db> {
709            const OPTIONAL_KIND: Option<SyntaxKind> = Some(SyntaxKind::$(&name));
710            type StablePtr = $(&ptr_name)<'db>;
711            type Green = $(&green_name)<'db>;
712            fn missing(db: &'db dyn Database) -> Self::Green {
713                // Note: A missing syntax element should result in an internal green node
714                // of width 0, with as much structure as possible.
715                $(&green_name)(GreenNode {
716                    kind: SyntaxKind::$(&name),
717                    details: GreenNodeDetails::Node {
718                        children: [$args_for_missing].into(),
719                        width: TextWidth::default(),
720                    },
721                }.intern(db))
722            }
723            fn from_syntax_node(db: &'db dyn Database, node: SyntaxNode<'db>) -> Self {
724                let kind = node.kind(db);
725                assert_eq!(kind, SyntaxKind::$(&name), "Unexpected SyntaxKind {:?}. Expected {:?}.", kind, SyntaxKind::$(&name));
726                Self { node }
727            }
728            fn cast(db: &'db dyn Database, node: SyntaxNode<'db>) -> Option<Self> {
729                let kind = node.kind(db);
730                if kind == SyntaxKind::$(&name) {
731                    Some(Self::from_syntax_node(db, node))
732                } else {
733                    None
734                }
735            }
736            fn as_syntax_node(&self) -> SyntaxNode<'db> {
737                self.node
738            }
739            fn stable_ptr(&self, db: &'db dyn Database) -> Self::StablePtr {
740                $(&ptr_name)(self.node.stable_ptr(db))
741            }
742        }
743    }
744}
cairo_lang_syntax_codegen/generator.rs

cairo_lang_syntax_codegen/
generator.rs
