feat(ast_codegen): add alignment and size data to the schema.

Author: rzvxa

crates/oxc_ast/src/generated/assert_layouts.rs

@@ -37,6 +37,8 @@ pub mod syntax_directed_operations;
 mod trivia;
 
 mod generated {
+    #[cfg(debug_assertions)]
+    pub mod assert_layouts;
     pub mod ast_builder;
     pub mod ast_kind;
     pub mod span;

crates/oxc_ast/src/lib.rs

@@ -1,5 +1,5 @@
 use super::{REnum, RStruct, RType};
-use crate::{schema::Inherit, util::TypeExt, TypeName};
+use crate::{layout::KnownLayout, schema::Inherit, util::TypeExt, TypeName};
 use quote::ToTokens;
 use serde::Serialize;
 
@@ -9,11 +9,24 @@ pub enum TypeDef {
     Enum(EnumDef),
 }
 
+impl TypeDef {
+    pub fn name(&self) -> &String {
+        match self {
+            Self::Struct(it) => &it.name,
+            Self::Enum(it) => &it.name,
+        }
+    }
+}
+
 #[derive(Debug, Serialize)]
 pub struct StructDef {
     pub name: TypeName,
     pub fields: Vec<FieldDef>,
     pub has_lifetime: bool,
+    pub size_64: usize,
+    pub align_64: usize,
+    pub size_32: usize,
+    pub align_32: usize,
 }
 
 #[derive(Debug, Serialize)]
@@ -23,6 +36,10 @@ pub struct EnumDef {
     /// For `@inherits` inherited enum variants
     pub inherits: Vec<EnumInheritDef>,
     pub has_lifetime: bool,
+    pub size_64: usize,
+    pub align_64: usize,
+    pub size_32: usize,
+    pub align_32: usize,
 }
 
 #[derive(Debug, Serialize)]
@@ -57,21 +74,47 @@ impl From<&RType> for Option<TypeDef> {
 
 impl From<&REnum> for EnumDef {
     fn from(it @ REnum { item, meta }: &REnum) -> Self {
+        let (size_64, align_64) = meta
+            .layout_64
+            .layout()
+            .map_or_else(|| panic!("Uncalculated layout on {}!", item.ident), KnownLayout::unpack);
+        let (size_32, align_32) = meta
+            .layout_32
+            .layout()
+            .map_or_else(|| panic!("Uncalculated layout on {}!", item.ident), KnownLayout::unpack);
         Self {
             name: it.ident().to_string(),
             variants: item.variants.iter().map(Into::into).collect(),
-            has_lifetime: item.generics.lifetimes().count() > 0,
             inherits: meta.inherits.iter().map(Into::into).collect(),
+            has_lifetime: item.generics.lifetimes().count() > 0,
+
+            size_64,
+            align_64,
+            size_32,
+            align_32,
         }
     }
 }
 
 impl From<&RStruct> for StructDef {
-    fn from(it @ RStruct { item, .. }: &RStruct) -> Self {
+    fn from(it @ RStruct { item, meta }: &RStruct) -> Self {
+        let (size_64, align_64) = meta
+            .layout_64
+            .layout()
+            .map_or_else(|| panic!("Uncalculated layout on {}!", item.ident), KnownLayout::unpack);
+        let (size_32, align_32) = meta
+            .layout_32
+            .layout()
+            .map_or_else(|| panic!("Uncalculated layout on {}!", item.ident), KnownLayout::unpack);
         Self {
             name: it.ident().to_string(),
             fields: item.fields.iter().map(Into::into).collect(),
             has_lifetime: item.generics.lifetimes().count() > 0,
+
+            size_64,
+            align_64,
+            size_32,
+            align_32,
         }
     }
 }

tasks/ast_codegen/src/defs.rs

@@ -0,0 +1,72 @@
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{parse_quote, PathArguments, Type};
+
+use crate::{
+    defs::{EnumDef, StructDef, TypeDef},
+    output, CodegenCtx, Generator, GeneratorOutput,
+};
+
+use super::generated_header;
+
+pub struct AssertLayouts;
+
+impl Generator for AssertLayouts {
+    fn name(&self) -> &'static str {
+        stringify!(AssertLayouts)
+    }
+
+    fn generate(&mut self, ctx: &CodegenCtx) -> GeneratorOutput {
+        let (assertions_64, assertions_32) = ctx
+            .schema
+            .definitions
+            .iter()
+            .map(|def| {
+                let typ =
+                    ctx.find(def.name()).and_then(|ty| ty.borrow().as_type()).map(|mut ty| {
+                        if let Type::Path(ty) = &mut ty {
+                            if let Some(seg) = ty.path.segments.first_mut() {
+                                if let PathArguments::AngleBracketed(args) = &mut seg.arguments {
+                                    *args = parse_quote!(<'static>);
+                                }
+                            }
+                        }
+                        ty
+                    });
+                match def {
+                    TypeDef::Struct(StructDef { size_64, align_64, size_32, align_32, .. })
+                    | TypeDef::Enum(EnumDef { size_64, align_64, size_32, align_32, .. }) => (
+                        quote! {
+                            assert!(size_of::<#typ>() == #size_64);
+                            assert!(align_of::<#typ>() == #align_64);
+                        },
+                        quote! {
+                            assert!(size_of::<#typ>() == #size_32);
+                            assert!(align_of::<#typ>() == #align_32);
+                        },
+                    ),
+                }
+            })
+            .collect::<(Vec<TokenStream>, Vec<TokenStream>)>();
+
+        let header = generated_header!();
+
+        GeneratorOutput::Stream((
+            output(crate::AST_CRATE, "assert_layouts.rs"),
+            quote! {
+                #header
+
+                use crate::ast::*;
+
+                endl!();
+
+                #[cfg(target_pointer_width = "64")]
+                const _: () = { #(#assertions_64)* };
+                #[cfg(target_pointer_width = "32")]
+                const _: () = { #(#assertions_32)* };
+                #[cfg(not(any(target_pointer_width = "64", target_pointer_width = "32")))]
+                const _: () = panic!("Platforms with pointer width other than 64 or 32 bit are not supported");
+            },
+        ))
+    }
+}

tasks/ast_codegen/src/generators/assert_layouts.rs

@@ -1,3 +1,4 @@
+mod assert_layouts;
 mod ast_builder;
 mod ast_kind;
 mod impl_get_span;
@@ -39,6 +40,7 @@ macro_rules! generated_header {
 pub(crate) use generated_header;
 pub(crate) use insert;
 
+pub use assert_layouts::AssertLayouts;
 pub use ast_builder::AstBuilderGenerator;
 pub use ast_kind::AstKindGenerator;
 pub use impl_get_span::ImplGetSpanGenerator;