feat(ast_codegen): add ImplGetSpanGenerator.

Author: rzvxa

tasks/ast_codegen/schema.json

@@ -0,0 +1,62 @@
+use itertools::Itertools;
+use proc_macro2::TokenStream;
+use syn::{parse_quote, Item, ItemImpl, ItemStruct, Variant};
+
+use crate::{
+    schema::{REnum, RStruct, RType},
+    CodegenCtx, Generator, GeneratorOutput,
+};
+
+pub struct ImplGetSpanGenerator;
+
+impl Generator for ImplGetSpanGenerator {
+    fn name(&self) -> &'static str {
+        "ImplGetSpanGenerator"
+    }
+
+    fn generate(&mut self, ctx: &CodegenCtx) -> GeneratorOutput {
+        let impls: Vec<ItemImpl> = ctx
+            .ty_table
+            .iter()
+            .filter_map(|maybe_kind| match &*maybe_kind.borrow() {
+                RType::Enum(it) => Some(impl_enum(it)),
+                RType::Struct(it) => Some(impl_struct(it)),
+                _ => None,
+            })
+            .collect();
+
+        GeneratorOutput::One(parse_quote!(#(#impls)*))
+    }
+}
+
+fn impl_enum(it @ REnum { item, .. }: &REnum) -> ItemImpl {
+    let typ = it.as_type();
+    let generics = &item.generics;
+    let matches: Vec<TokenStream> = item
+        .variants
+        .iter()
+        .map(|Variant { ident, .. }| parse_quote!(Self :: #ident(it) => it.span()))
+        .collect_vec();
+
+    parse_quote! {
+        impl #generics GetSpan for #typ {
+            fn span(&self) -> Span {
+                match self {
+                    #(#matches),*
+                }
+            }
+        }
+    }
+}
+
+fn impl_struct(it @ RStruct { item, .. }: &RStruct) -> ItemImpl {
+    let typ = it.as_type();
+    let generics = &item.generics;
+    parse_quote! {
+        impl #generics GetSpan for #typ {
+            fn span(&self) -> Span {
+                self.span
+            }
+        }
+    }
+}

tasks/ast_codegen/src/generators/impl_get_span.rs

@@ -1,5 +1,7 @@
 mod ast;
 mod ast_kind;
+mod impl_get_span;
 
 pub use ast::AstGenerator;
 pub use ast_kind::AstKindGenerator;
+pub use impl_get_span::ImplGetSpanGenerator;

tasks/ast_codegen/src/generators/mod.rs

@@ -6,6 +6,25 @@ pub trait Linker<'a> {
     fn link(&'a self, linker: impl FnMut(&mut RType, &'a Self) -> Result<bool>) -> Result<&'a ()>;
 }
 
+pub trait Unresolved {
+    fn unresolved(&self) -> bool;
+    fn resolved(&self) -> bool {
+        !self.unresolved()
+    }
+}
+
+impl Unresolved for Inherit {
+    fn unresolved(&self) -> bool {
+        matches!(self, Self::Unlinked(_))
+    }
+}
+
+impl Unresolved for Vec<Inherit> {
+    fn unresolved(&self) -> bool {
+        self.iter().any(Unresolved::unresolved)
+    }
+}
+
 impl<'a> Linker<'a> for CodegenCtx {
     fn link(
         &'a self,
@@ -43,25 +62,33 @@ pub fn linker(ty: &mut RType, ctx: &CodegenCtx) -> Result<bool> {
         return Ok(true);
     }
 
-    ty.meta.inherits = ty
+    let inherits = ty
         .meta
         .inherits
         .drain(..)
         .map(|it| match it {
-            Inherit::Unlinked(it) => {
-                let linkee = ctx.find(&Cow::Owned(it.to_string())).unwrap();
+            Inherit::Unlinked(ref sup) => {
+                let linkee = ctx.find(&Cow::Owned(sup.to_string())).unwrap();
                 let variants = match &*linkee.borrow() {
-                    RType::Enum(enum_) => enum_.item.variants.clone(),
+                    RType::Enum(enum_) => {
+                        if enum_.meta.inherits.unresolved() {
+                            return Err(it);
+                        }
+                        enum_.item.variants.clone()
+                    }
                     _ => {
                         panic!("invalid inheritance, you can only inherit from enums and in enums.")
                     }
                 };
                 ty.item.variants.extend(variants.clone());
-                Inherit::Linked { super_: it.clone(), variants }
+                Ok(Inherit::Linked { super_: sup.clone(), variants })
             }
-            Inherit::Linked { .. } => it,
+            Inherit::Linked { .. } => Ok(it),
         })
-        .collect_vec();
+        .collect::<Vec<std::result::Result<Inherit, Inherit>>>();
+    let unresolved = inherits.iter().any(|it| it.is_err());
+
+    ty.meta.inherits = inherits.into_iter().map(|it| it.unwrap_or_else(|it| it)).collect();
 
-    Ok(true)
+    Ok(!unresolved)
 }

tasks/ast_codegen/src/linker.rs

@@ -16,6 +16,8 @@ use generators::{AstGenerator, AstKindGenerator};
 use linker::{linker, Linker};
 use schema::{Inherit, Module, REnum, RStruct, RType, Schema};
 
+use crate::generators::ImplGetSpanGenerator;
+
 type Result<R> = std::result::Result<R, String>;
 type TypeId = usize;
 type TypeName = String;
@@ -133,12 +135,26 @@ fn files() -> std::array::IntoIter<String, 4> {
 
 #[allow(clippy::print_stdout)]
 fn main() -> Result<()> {
-    let CodegenResult { schema, .. } = files()
+    let CodegenResult { schema, outputs } = files()
         .fold(AstCodegen::default(), AstCodegen::add_file)
         .with(AstGenerator)
         .with(AstKindGenerator)
+        .with(ImplGetSpanGenerator)
         .generate()?;
 
+    // NOTE: Print Impl GetSpan
+    println!(
+        "{}",
+        outputs
+            .into_iter()
+            .find(|it| it.0 == ImplGetSpanGenerator.name())
+            .map(|(_, output)| {
+                let GeneratorOutput::One(result) = output else { unreachable!() };
+                prettyplease::unparse(&parse_file(result.to_string().as_str()).unwrap())
+            })
+            .unwrap()
+    );
+
     // NOTE: Print AstKind
     // println!(
     //     "{}",
@@ -175,7 +191,7 @@ fn main() -> Result<()> {
     //         .unwrap()
     // );
 
-    let schema = serde_json::to_string_pretty(&schema).map_err(|e| e.to_string())?;
-    println!("{schema}");
+    // let schema = serde_json::to_string_pretty(&schema).map_err(|e| e.to_string())?;
+    // println!("{schema}");
     Ok(())
 }

tasks/ast_codegen/src/main.rs

@@ -55,6 +55,12 @@ impl REnum {
     pub fn ident(&self) -> &Ident {
         &self.item.ident
     }
+
+    pub fn as_type(&self) -> Type {
+        let ident = self.ident();
+        let generics = &self.item.generics;
+        parse_quote!(#ident #generics)
+    }
 }
 
 impl From<ItemEnum> for REnum {
@@ -77,6 +83,12 @@ impl RStruct {
     pub fn ident(&self) -> &Ident {
         &self.item.ident
     }
+
+    pub fn as_type(&self) -> Type {
+        let ident = self.ident();
+        let generics = &self.item.generics;
+        parse_quote!(#ident #generics)
+    }
 }
 
 impl From<ItemStruct> for RStruct {
@@ -121,12 +133,10 @@ impl RType {
     }
 
     pub fn as_type(&self) -> Option<Type> {
-        if let RType::Enum(REnum { item: ItemEnum { ident, generics, .. }, .. })
-        | RType::Struct(RStruct { item: ItemStruct { ident, generics, .. }, .. }) = self
-        {
-            Some(parse_quote!(#ident #generics))
-        } else {
-            None
+        match self {
+            RType::Enum(it) => Some(it.as_type()),
+            RType::Struct(it) => Some(it.as_type()),
+            _ => None,
         }
     }
 }