Implemented type/expression differentiation for C sizeof

Author: IsaacShelton

src/c/ast/mod.rs

@@ -262,6 +262,7 @@ impl TypeSpecifierQualifier {
 pub struct SpecifierQualifierList {
     pub attributes: Vec<Attribute>,
     pub type_specifier_qualifiers: Vec<TypeSpecifierQualifier>,
+    pub source: Source,
 }
 
 #[derive(Clone, Debug)]
@@ -317,6 +318,7 @@ pub enum AlignmentSpecifierKind {
 pub struct DeclarationSpecifiers {
     pub specifiers: Vec<DeclarationSpecifier>,
     pub attributes: Vec<Attribute>,
+    pub source: Source,
 }
 
 impl From<&SpecifierQualifierList> for DeclarationSpecifiers {
@@ -330,6 +332,7 @@ impl From<&SpecifierQualifierList> for DeclarationSpecifiers {
         Self {
             attributes: value.attributes.clone(),
             specifiers,
+            source: value.source,
         }
     }
 }

src/c/parser/expr.rs

@@ -8,11 +8,10 @@ use crate::{
         parser::speculate::speculate,
         punctuator::Punctuator,
         token::CTokenKind,
-        translate::TranslateCtx,
+        translate::{types::get_type, TranslateCtx},
     },
     source_files::Source,
 };
-use ignore::types::TypesBuilder;
 
 // Implements expression parsing for the C parser
 impl<'input, 'diagnostics> Parser<'input, 'diagnostics> {
@@ -269,12 +268,21 @@ impl<'input, 'diagnostics> Parser<'input, 'diagnostics> {
             CTokenKind::SizeofKeyword => {
                 self.input.advance();
 
-                #[allow(unused)]
                 if let Ok(type_name) = speculate!(self.input, self.parse_type_in_parens()) {
-                    let ctx =
+                    let mut ctx =
                         TranslateCtx::new(&mut self.ast_file, &mut self.typedefs, self.diagnostics);
-                    let mut type_builder = TypesBuilder::new();
-                    return todo!("handle parsed sizeof(type)");
+                    let specifier_qualifiers = &type_name.specifier_qualifiers;
+
+                    let ty = get_type(
+                        &mut ctx,
+                        type_name.abstract_declarator.as_ref(),
+                        &specifier_qualifiers.into(),
+                        false,
+                    );
+
+                    if let Ok(ty) = ty {
+                        return todo!("handle parsed sizeof(type) - {:?}", ty);
+                    }
                 }
 
                 let _inner = self.parse_expr_primary_base()?;

src/c/parser/mod.rs

@@ -187,6 +187,7 @@ impl<'input, 'diagnostics> Parser<'input, 'diagnostics> {
     }
 
     fn parse_declaration_specifiers(&mut self) -> Result<DeclarationSpecifiers, ParseError> {
+        let source = self.here();
         let mut specifiers = vec![];
 
         while let Ok(specifier) = speculate!(self.input, self.parse_declaration_specifier()) {
@@ -197,6 +198,7 @@ impl<'input, 'diagnostics> Parser<'input, 'diagnostics> {
         Ok(DeclarationSpecifiers {
             specifiers,
             attributes,
+            source,
         })
     }
 
@@ -748,6 +750,7 @@ impl<'input, 'diagnostics> Parser<'input, 'diagnostics> {
     }
 
     fn parse_specifier_qualifier_list(&mut self) -> Result<SpecifierQualifierList, ParseError> {
+        let source = self.here();
         let mut type_specifier_qualifiers = vec![];
 
         while let Ok(qualifier) = speculate!(self.input, self.parse_type_specifier_qualifier()) {
@@ -759,6 +762,7 @@ impl<'input, 'diagnostics> Parser<'input, 'diagnostics> {
         Ok(SpecifierQualifierList {
             attributes,
             type_specifier_qualifiers,
+            source,
         })
     }
 

src/c/translate/mod.rs

@@ -2,7 +2,7 @@ mod eval;
 mod expr;
 mod function;
 mod parameters;
-mod types;
+pub mod types;
 
 use self::types::get_name_and_type;
 pub use self::{expr::translate_expr, function::declare_function};

src/c/translate/types/mod.rs

@@ -207,10 +207,47 @@ pub fn get_name_and_type(
     for_parameter: bool,
 ) -> Result<DeclaratorInfo, ParseError> {
     let (name, decorators) = get_name_and_decorators(ctx, declarator)?;
-    let type_base = get_type_base(ctx, declaration_specifiers, declarator.source)?;
+    let type_base = get_type_base(ctx, declaration_specifiers, declaration_specifiers.source)?;
+    let ast_type = apply_decorators(ctx, &decorators, type_base.ast_type, for_parameter)?;
 
-    let mut ast_type = type_base.ast_type;
+    Ok(DeclaratorInfo {
+        name,
+        ast_type,
+        specifiers: type_base.specifiers,
+    })
+}
+
+#[derive(Clone, Debug)]
+pub struct AbstractDeclaratorInfo {
+    pub ast_type: Type,
+    pub specifiers: TypeBaseSpecifiers,
+}
+
+pub fn get_type(
+    ctx: &mut TranslateCtx,
+    abstract_declarator: Option<&AbstractDeclarator>,
+    declaration_specifiers: &DeclarationSpecifiers,
+    for_parameter: bool,
+) -> Result<AbstractDeclaratorInfo, ParseError> {
+    let decorators = abstract_declarator
+        .map(|abstract_declarator| get_decorators(ctx, abstract_declarator))
+        .transpose()?
+        .unwrap_or_default();
+    let type_base = get_type_base(ctx, declaration_specifiers, declaration_specifiers.source)?;
+    let ast_type = apply_decorators(ctx, &decorators, type_base.ast_type, for_parameter)?;
+
+    Ok(AbstractDeclaratorInfo {
+        ast_type,
+        specifiers: type_base.specifiers,
+    })
+}
 
+fn apply_decorators(
+    ctx: &mut TranslateCtx,
+    decorators: &Decorators,
+    mut ast_type: Type,
+    for_parameter: bool,
+) -> Result<Type, ParseError> {
     for decorator in decorators.iter() {
         match decorator {
             Decorator::Pointer(pointer) => {
@@ -223,14 +260,10 @@ pub fn get_name_and_type(
             Decorator::Function(function) => {
                 ast_type = decorate_function(ast_type, function, decorator.source())?;
             }
-        }
+        };
     }
 
-    Ok(DeclaratorInfo {
-        name,
-        ast_type,
-        specifiers: type_base.specifiers,
-    })
+    Ok(ast_type)
 }
 
 fn get_name_and_decorators(