Added AST and ASG support for unnamed function parameters

Author: IsaacShelton

Diff for: src/asg/func.rs

@@ -46,13 +46,17 @@ impl Display for Params {
 
 #[derive(Clone, Debug, Hash, Eq)]
 pub struct Param {
-    pub name: String,
+    pub name: Option<String>,
     pub ty: Type,
 }
 
 impl Display for Param {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{} {}", self.name, self.ty)
+        if let Some(name) = &self.name {
+            write!(f, "{} {}", name, self.ty)
+        } else {
+            write!(f, "{}", self.ty)
+        }
     }
 }
 

Diff for: src/ast/func/params.rs

@@ -17,12 +17,19 @@ impl Params {
 
 #[derive(Clone, Debug)]
 pub struct Param {
-    pub name: String,
+    pub name: Option<String>,
     pub ast_type: Type,
 }
 
 impl Param {
-    pub fn new(name: String, ast_type: Type) -> Self {
+    pub fn new(name: Option<String>, ast_type: Type) -> Self {
         Self { name, ast_type }
     }
+
+    pub fn named(name: String, ast_type: Type) -> Self {
+        Self {
+            name: Some(name),
+            ast_type,
+        }
+    }
 }

Diff for: src/c/parser/mod.rs

@@ -169,7 +169,7 @@ pub struct ArrayQualifier {
 
 #[derive(Clone, Debug)]
 pub struct FunctionQualifier {
-    pub parameters: Vec<Param>,
+    pub params: Vec<Param>,
     pub is_cstyle_variadic: bool,
     pub source: Source,
 }
@@ -1552,7 +1552,7 @@ impl<'a> Parser<'a> {
             ));
         }
 
-        todo!();
+        todo!("parse compound statement");
 
         if !self.eat_punctuator(Punctuator::CloseCurly) {
             return Err(ParseError::new(

Diff for: src/c/translation/expr/caster.rs

@@ -34,14 +34,14 @@ pub fn get_caster_type(
 
     let base = builder.build()?;
 
-    if base.storage_class.is_some() {
+    if base.specifiers.storage_class.is_some() {
         return Err(ParseError::message(
             "Storage class specifier cannot be used on cast",
             caster.source,
         ));
     }
 
-    if base.function_specifier.is_some() {
+    if base.specifiers.function_specifier.is_some() {
         return Err(ParseError::message(
             "Storage class specifier cannot be used on cast",
             caster.source,

Diff for: src/c/translation/function.rs

@@ -22,24 +22,23 @@ pub fn declare_function(
     c_file_type: CFileType,
 ) -> Result<(), ParseError> {
     let source = declarator.source;
-    let (name, return_type, storage_class, function_specifier, _is_thread_local) =
-        get_name_and_type(
-            ast_file,
-            typedefs,
-            declarator,
-            declaration_specifiers,
-            false,
-            diagnostics,
-        )?;
+    let func_info = get_name_and_type(
+        ast_file,
+        typedefs,
+        declarator,
+        declaration_specifiers,
+        false,
+        diagnostics,
+    )?;
     let mut required = vec![];
 
-    if function_specifier.is_some() {
+    if func_info.specifiers.function_specifier.is_some() {
         return Err(ParseErrorKind::Misc("Function specifiers are not supported yet").at(source));
     }
 
     if has_parameters(parameter_type_list) {
         for param in parameter_type_list.parameter_declarations.iter() {
-            let (name, ast_type, storage_class, function_specifier, _) = match &param.core {
+            let param_info = match &param.core {
                 ParameterDeclarationCore::Declarator(declarator) => get_name_and_type(
                     ast_file,
                     typedefs,
@@ -52,33 +51,33 @@ pub fn declare_function(
                 ParameterDeclarationCore::Nothing => todo!(),
             };
 
-            if storage_class.is_some() {
+            if param_info.specifiers.storage_class.is_some() {
                 return Err(
                     ParseErrorKind::Misc("Storage classes not support on typedef").at(param.source),
                 );
             }
 
-            if function_specifier.is_some() {
+            if param_info.specifiers.function_specifier.is_some() {
                 return Err(
                     ParseErrorKind::Misc("Function specifiers cannot be used on typedef")
                         .at(source),
                 );
             }
 
-            required.push(Param { name, ast_type });
+            required.push(Param::new(Some(param_info.name), param_info.ast_type));
         }
     }
 
-    match storage_class {
+    match func_info.specifiers.storage_class {
         Some(StorageClassSpecifier::Typedef) => {
             let ast_type = ast::TypeKind::FuncPtr(ast::FuncPtr {
                 parameters: required,
-                return_type: Box::new(return_type),
+                return_type: Box::new(func_info.ast_type),
                 is_cstyle_variadic: parameter_type_list.is_variadic,
             })
             .at(declarator.source);
 
-            typedefs.insert(name, CTypedef { ast_type });
+            typedefs.insert(func_info.name, CTypedef { ast_type });
             return Ok(());
         }
         Some(_) => {
@@ -90,14 +89,14 @@ pub fn declare_function(
     }
 
     let head = FuncHead {
-        name,
+        name: func_info.name,
         type_params: TypeParams::default(),
         givens: vec![],
         params: Params {
             required,
             is_cstyle_vararg: parameter_type_list.is_variadic,
         },
-        return_type,
+        return_type: func_info.ast_type,
         is_foreign: true,
         source,
         abide_abi: true,

Diff for: src/c/translation/mod.rs

@@ -24,7 +24,7 @@ pub fn declare_named_declaration(
     diagnostics: &Diagnostics,
     c_file_type: CFileType,
 ) -> Result<(), ParseError> {
-    let (name, ast_type, storage_class, function_specifier, is_thread_local) = get_name_and_type(
+    let decl_info = get_name_and_type(
         ast_file,
         typedefs,
         declarator,
@@ -33,8 +33,8 @@ pub fn declare_named_declaration(
         diagnostics,
     )?;
 
-    if let Some(StorageClassSpecifier::Typedef) = storage_class {
-        if let Some(function_specifier) = function_specifier {
+    if let Some(StorageClassSpecifier::Typedef) = decl_info.specifiers.storage_class {
+        if let Some(function_specifier) = decl_info.specifiers.function_specifier {
             diagnostics.push(WarningDiagnostic::new(
                 format!(
                     "Function specifier '{}' does nothing on typedef",
@@ -45,21 +45,26 @@ pub fn declare_named_declaration(
         }
 
         ast_file.type_aliases.push(ast::TypeAlias {
-            name: name.clone(),
+            name: decl_info.name.clone(),
             params: TypeParams::default(),
-            value: ast_type.clone(),
+            value: decl_info.ast_type.clone(),
             source: declarator.source,
             privacy: c_file_type.privacy(),
         });
 
-        typedefs.insert(name, CTypedef { ast_type });
+        typedefs.insert(
+            decl_info.name,
+            CTypedef {
+                ast_type: decl_info.ast_type,
+            },
+        );
         return Ok(());
     }
 
-    if let None | Some(StorageClassSpecifier::Extern) = storage_class {
-        let is_foreign = storage_class.is_some();
+    if let None | Some(StorageClassSpecifier::Extern) = decl_info.specifiers.storage_class {
+        let is_foreign = decl_info.specifiers.storage_class.is_some();
 
-        if let Some(function_specifier) = function_specifier {
+        if let Some(function_specifier) = decl_info.specifiers.function_specifier {
             diagnostics.push(WarningDiagnostic::new(
                 format!(
                     "Function specifier '{}' on functions is not respected yet",
@@ -70,11 +75,11 @@ pub fn declare_named_declaration(
         }
 
         ast_file.global_variables.push(ast::GlobalVar {
-            name,
-            ast_type,
+            name: decl_info.name,
+            ast_type: decl_info.ast_type,
             source: declarator.source,
             is_foreign,
-            is_thread_local,
+            is_thread_local: decl_info.specifiers.is_thread_local,
             privacy: c_file_type.privacy(),
             exposure: ast::Exposure::Exposed,
         });

Diff for: src/c/translation/types/composite.rs

@@ -54,36 +54,33 @@ pub fn make_composite(
                         for member_declarator in member.member_declarators.iter() {
                             match member_declarator {
                                 MemberDeclarator::Declarator(declarator) => {
-                                    let (name, ast_type, storage_class, function_specifier, _) =
-                                        get_name_and_type(
-                                            ast_file,
-                                            typedefs,
-                                            declarator,
-                                            &DeclarationSpecifiers::from(
-                                                &member.specifier_qualifiers,
-                                            ),
-                                            false,
-                                            diagnostics,
-                                        )?;
+                                    let member_info = get_name_and_type(
+                                        ast_file,
+                                        typedefs,
+                                        declarator,
+                                        &DeclarationSpecifiers::from(&member.specifier_qualifiers),
+                                        false,
+                                        diagnostics,
+                                    )?;
 
-                                    if storage_class.is_some() {
+                                    if member_info.specifiers.storage_class.is_some() {
                                         return Err(ParseErrorKind::Misc(
                                             "Storage classes not supported here",
                                         )
                                         .at(declarator.source));
                                     }
 
-                                    if function_specifier.is_some() {
+                                    if member_info.specifiers.function_specifier.is_some() {
                                         return Err(ParseErrorKind::Misc(
                                             "Function specifiers cannot be used here",
                                         )
                                         .at(declarator.source));
                                     }
 
                                     fields.insert(
-                                        name.clone(),
+                                        member_info.name.clone(),
                                         Field {
-                                            ast_type,
+                                            ast_type: member_info.ast_type.clone(),
                                             privacy: Privacy::Public,
                                             source: declarator.source,
                                         },

Diff for: src/c/translation/types/decorate.rs

@@ -70,7 +70,7 @@ pub fn decorate_function(
     source: Source,
 ) -> Result<Type, ParseError> {
     Ok(TypeKind::FuncPtr(FuncPtr {
-        parameters: function.parameters.clone(),
+        parameters: function.params.clone(),
         return_type: Box::new(ast_type),
         is_cstyle_variadic: function.is_cstyle_variadic,
     })