Modified C parser to have access to translation context during parsing

Author: IsaacShelton

src/c/parser/expr.rs

@@ -8,14 +8,14 @@ use crate::{
         parser::speculate::speculate,
         punctuator::Punctuator,
         token::CTokenKind,
-        translate::get_decorators,
+        translate::TranslateCtx,
     },
     source_files::Source,
 };
 use ignore::types::TypesBuilder;
 
 // Implements expression parsing for the C parser
-impl<'a> Parser<'a> {
+impl<'input, 'diagnostics> Parser<'input, 'diagnostics> {
     pub fn parse_expr_singular(&mut self) -> Result<Expr, ParseError> {
         let primary = self.parse_expr_primary()?;
         self.parse_operator_expr(0, primary)
@@ -269,7 +269,10 @@ impl<'a> Parser<'a> {
             CTokenKind::SizeofKeyword => {
                 self.input.advance();
 
+                #[allow(unused)]
                 if let Ok(type_name) = speculate!(self.input, self.parse_type_in_parens()) {
+                    let ctx =
+                        TranslateCtx::new(&mut self.ast_file, &mut self.typedefs, self.diagnostics);
                     let mut type_builder = TypesBuilder::new();
                     return todo!("handle parsed sizeof(type)");
                 }

src/c/parser/mod.rs

@@ -34,26 +34,21 @@ use crate::{
 };
 use std::collections::HashMap;
 
-pub struct Parser<'a> {
-    input: Input<'a>,
-    typedefs: HashMap<String, CTypedef>,
+pub struct Parser<'input, 'diagnostics> {
+    input: Input<'input>,
+    pub ast_file: AstFile,
+    pub typedefs: HashMap<String, CTypedef>,
+    pub diagnostics: &'diagnostics Diagnostics<'diagnostics>,
     enum_constants: HashMap<String, Integer>,
-    diagnostics: &'a Diagnostics<'a>,
     c_file_type: CFileType,
 }
 
-impl Parser<'_> {
-    pub fn typedefs(&self) -> &HashMap<String, CTypedef> {
-        &self.typedefs
-    }
-
-    pub fn typedefs_mut(&mut self) -> &mut HashMap<String, CTypedef> {
-        &mut self.typedefs
-    }
-}
-
-impl<'a> Parser<'a> {
-    pub fn new(input: Input<'a>, diagnostics: &'a Diagnostics<'a>, c_file_type: CFileType) -> Self {
+impl<'input, 'diagnostics> Parser<'input, 'diagnostics> {
+    pub fn new(
+        input: Input<'input>,
+        diagnostics: &'diagnostics Diagnostics<'diagnostics>,
+        c_file_type: CFileType,
+    ) -> Self {
         let mut typedefs = HashMap::default();
 
         diagnostics.push(WarningDiagnostic::new(
@@ -72,6 +67,7 @@ impl<'a> Parser<'a> {
         );
 
         Self {
+            ast_file: AstFile::new(),
             input,
             typedefs,
             enum_constants: HashMap::default(),
@@ -84,7 +80,7 @@ impl<'a> Parser<'a> {
         self.input.switch_input(tokens);
     }
 
-    pub fn parse(&mut self) -> Result<AstFile, ParseError> {
+    pub fn parse(&mut self) -> Result<(), ParseError> {
         let mut ast_file = AstFile::new();
 
         while !self.input.peek().is_end_of_file() {
@@ -141,7 +137,7 @@ impl<'a> Parser<'a> {
             }
         }
 
-        Ok(ast_file)
+        Ok(())
     }
 
     fn parse_external_declaration(&mut self) -> Result<ExternalDeclaration, ParseError> {

src/c/translate/mod.rs

@@ -15,14 +15,29 @@ use crate::{
     workspace::compile::c_code::CFileType,
 };
 use std::collections::HashMap;
-pub use types::get_decorators;
 
 pub struct TranslateCtx<'ast, 'typedefs, 'diagnostics, 'source_files> {
     pub ast_file: &'ast mut AstFile,
     pub typedefs: &'typedefs mut HashMap<String, CTypedef>,
     pub diagnostics: &'diagnostics Diagnostics<'source_files>,
 }
 
+impl<'ast, 'typedefs, 'diagnostics, 'source_files>
+    TranslateCtx<'ast, 'typedefs, 'diagnostics, 'source_files>
+{
+    pub fn new<'input>(
+        ast_file: &'ast mut AstFile,
+        typedefs: &'typedefs mut HashMap<String, CTypedef>,
+        diagnostics: &'diagnostics Diagnostics<'source_files>,
+    ) -> Self {
+        Self {
+            ast_file,
+            typedefs,
+            diagnostics,
+        }
+    }
+}
+
 pub fn declare_named_declaration(
     ctx: &mut TranslateCtx,
     declarator: &Declarator,

src/workspace/compile/c_code.rs

@@ -48,7 +48,7 @@ pub fn c_code(
         c_file_type,
     );
 
-    let mut ast_file = parser.parse().map_err(into_show)?;
+    parser.parse().map_err(into_show)?;
 
     // Translate preprocessor #define object macros
     for (define_name, define) in &defines {
@@ -59,14 +59,14 @@ pub fn c_code(
                 if let Ok(value) = parser.parse_expr_singular().and_then(|expr| {
                     translate_expr(
                         &mut TranslateCtx {
-                            ast_file: &mut ast_file,
-                            typedefs: parser.typedefs_mut(),
+                            ast_file: &mut parser.ast_file,
+                            typedefs: &mut parser.typedefs,
                             diagnostics: compiler.diagnostics,
                         },
                         &expr,
                     )
                 }) {
-                    ast_file.helper_exprs.push(ast::HelperExpr {
+                    parser.ast_file.helper_exprs.push(ast::HelperExpr {
                         name: define_name.clone(),
                         value,
                         source: define.source,
@@ -79,5 +79,5 @@ pub fn c_code(
         }
     }
 
-    Ok(ast_file)
+    Ok(parser.ast_file)
 }