Started working on support for C static_assert statement

IsaacShelton · IsaacShelton · commit d6b364949799 · 2025-03-23T21:36:37.000-05:00
diff --git a/src/ast/expr/kind.rs b/src/ast/expr/kind.rs
@@ -39,6 +39,7 @@ pub enum ExprKind {
     Break,
     Continue,
     IntegerPromote(Box<Expr>),
+    StaticAssert(Box<Expr>, Option<String>),
 }
 
 impl ExprKind {
diff --git a/src/ast/expr/mod.rs b/src/ast/expr/mod.rs
@@ -12,6 +12,7 @@ mod struct_literal;
 mod unary;
 mod while_loop;
 
+use super::{Stmt, StmtKind};
 use crate::source_files::Source;
 pub use array_access::*;
 pub use binary::*;
@@ -38,6 +39,11 @@ impl Expr {
     pub fn new(kind: ExprKind, source: Source) -> Self {
         Self { kind, source }
     }
+
+    pub fn stmt(self) -> Stmt {
+        let source = self.source;
+        return StmtKind::Expr(self).at(source);
+    }
 }
 
 // Make sure ExprKind doesn't accidentally become huge
diff --git a/src/c/lexer/error.rs b/src/c/lexer/error.rs
@@ -1,6 +1,20 @@
+use std::fmt::Display;
+
 #[derive(Clone, Debug, PartialEq)]
 pub enum LexError {
     UniversalCharacterNameNotSupported,
     UnrecognizedSymbol,
     UnrepresentableInteger,
 }
+
+impl Display for LexError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            LexError::UniversalCharacterNameNotSupported => {
+                write!(f, "unsupported universal character name")
+            }
+            LexError::UnrecognizedSymbol => write!(f, "unrecognized symbol"),
+            LexError::UnrepresentableInteger => write!(f, "unrepresentable integer literal"),
+        }
+    }
+}
diff --git a/src/c/parser/error.rs b/src/c/parser/error.rs
@@ -1,4 +1,5 @@
 use crate::{
+    c::token::CTokenKind,
     show::Show,
     source_files::{Source, SourceFiles},
 };
@@ -49,6 +50,7 @@ pub enum ParseErrorKind {
     UndeclaredVariable(String),
     UndeclaredType(String),
     CannotContainNulInNullTerminatedString,
+    MiscGot(&'static str, CTokenKind),
     Misc(&'static str),
 }
 
@@ -85,6 +87,9 @@ impl Display for ParseErrorKind {
             ParseErrorKind::CannotContainNulInNullTerminatedString => {
                 write!(f, "Cannot contain NUL byte in C-String'")
             }
+            ParseErrorKind::MiscGot(message, got) => {
+                write!(f, "{}, got {}", message, got)
+            }
             ParseErrorKind::Misc(message) => f.write_str(message),
         }
     }
diff --git a/src/c/parser/mod.rs b/src/c/parser/mod.rs
@@ -895,7 +895,36 @@ impl<'input, 'diagnostics> Parser<'input, 'diagnostics> {
             return Err(self.error("Expected 'static_assert' keyword to begin static assert"));
         }
 
-        todo!("parse_static_assert")
+        if !self.eat_open_paren() {
+            return Err(self.error("Expected '(' after 'static_assert' keyword"));
+        }
+
+        let condition = self.parse_constant_expression()?;
+
+        let message = if self.eat_punctuator(Punctuator::Comma) {
+            let token = self.input.advance();
+
+            let CTokenKind::StringLiteral(_encoding, string) = &token.kind else {
+                return Err(ParseError::message(
+                    "Expected message for 'static_assert'",
+                    token.source,
+                ));
+            };
+
+            Some(string.clone())
+        } else {
+            None
+        };
+
+        if !self.eat_punctuator(Punctuator::CloseParen) {
+            return Err(self.error("Expected ')' to close 'static_assert' statement"));
+        }
+
+        if !self.eat_punctuator(Punctuator::Semicolon) {
+            return Err(self.error("Expected ';' after 'static_assert' statement"));
+        }
+
+        Ok(StaticAssertDeclaration { condition, message })
     }
 
     fn parse_declaration(&mut self) -> Result<Declaration, ParseError> {
@@ -1067,12 +1096,18 @@ impl<'input, 'diagnostics> Parser<'input, 'diagnostics> {
 
             let source = self.here();
 
-            if let Ok(declaration) = speculate!(self.input, self.parse_declaration()) {
-                statements.push(BlockItem {
-                    kind: declaration.into(),
-                    source,
-                });
-                continue;
+            match speculate!(self.input, self.parse_declaration()) {
+                Ok(declaration) => {
+                    statements.push(BlockItem {
+                        kind: declaration.into(),
+                        source,
+                    });
+                    continue;
+                }
+                Err(error) if self.input.peek().is_static_assert_keyword() => {
+                    return Err(error);
+                }
+                _ => (),
             }
 
             if let Ok(unlabeled_statement) =
@@ -1093,7 +1128,11 @@ impl<'input, 'diagnostics> Parser<'input, 'diagnostics> {
                 continue;
             }
 
-            return Err(self.error("Expected '}' to end compound statement"));
+            return Err(ParseErrorKind::MiscGot(
+                "Expected '}' to end compound statement",
+                self.input.peek().kind.clone(),
+            )
+            .at(self.here()));
         }
 
         Ok(CompoundStatement { statements })
diff --git a/src/c/token.rs b/src/c/token.rs
@@ -2,6 +2,7 @@ use super::{encoding::Encoding, lexer::LexError, punctuator::Punctuator};
 use crate::{inflow::InflowEnd, source_files::Source};
 use derive_more::{Deref, IsVariant, Unwrap};
 use num_bigint::BigInt;
+use std::fmt::Display;
 
 #[derive(Clone, Debug, PartialEq, IsVariant, Unwrap)]
 pub enum CTokenKind {
@@ -201,3 +202,72 @@ impl InflowEnd for CToken {
         matches!(&self.kind, CTokenKind::EndOfFile)
     }
 }
+
+impl Display for CTokenKind {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            CTokenKind::EndOfFile => write!(f, "<end-of-file>"),
+            CTokenKind::LexError(lex_error) => lex_error.fmt(f),
+            CTokenKind::Identifier(identifier) => write!(f, "identifier '{}'", identifier),
+            CTokenKind::Punctuator(punctuator) => write!(f, "'{}'", punctuator),
+            CTokenKind::Integer(_) => write!(f, "integer literal"),
+            CTokenKind::Float(_, _) => write!(f, "floating-point literal"),
+            CTokenKind::CharacterConstant(_, _) => write!(f, "character literal"),
+            CTokenKind::StringLiteral(_, _) => write!(f, "string literal"),
+            CTokenKind::AlignasKeyword => write!(f, "'alignas' keyword"),
+            CTokenKind::AlignofKeyword => write!(f, "'alignof' keyword"),
+            CTokenKind::AutoKeyword => write!(f, "'auto' keyword"),
+            CTokenKind::BoolKeyword => write!(f, "'bool' keyword"),
+            CTokenKind::BreakKeyword => write!(f, "'break' keyword"),
+            CTokenKind::CaseKeyword => write!(f, "'case' keyword"),
+            CTokenKind::CharKeyword => write!(f, "'char' keyword"),
+            CTokenKind::ConstKeyword => write!(f, "'const' keyword"),
+            CTokenKind::ConstexprKeyword => write!(f, "'constexpr' keyword"),
+            CTokenKind::ContinueKeyword => write!(f, "'continue' keyword"),
+            CTokenKind::DefaultKeyword => write!(f, "'default' keyword"),
+            CTokenKind::DoKeyword => write!(f, "'do' keyword"),
+            CTokenKind::DoubleKeyword => write!(f, "'double' keyword"),
+            CTokenKind::ElseKeyword => write!(f, "'else' keyword"),
+            CTokenKind::EnumKeyword => write!(f, "'enum' keyword"),
+            CTokenKind::ExternKeyword => write!(f, "'extern' keyword"),
+            CTokenKind::FalseKeyword => write!(f, "'false' keyword"),
+            CTokenKind::FloatKeyword => write!(f, "'float' keyword"),
+            CTokenKind::ForKeyword => write!(f, "'for' keyword"),
+            CTokenKind::GotoKeyword => write!(f, "'goto' keyword"),
+            CTokenKind::IfKeyword => write!(f, "'if' keyword"),
+            CTokenKind::InlineKeyword => write!(f, "'inline' keyword"),
+            CTokenKind::IntKeyword => write!(f, "'int' keyword"),
+            CTokenKind::LongKeyword => write!(f, "'long' keyword"),
+            CTokenKind::NullptrKeyword => write!(f, "'nullptr' keyword"),
+            CTokenKind::RegisterKeyword => write!(f, "'register' keyword"),
+            CTokenKind::RestrictKeyword => write!(f, "'restrict' keyword"),
+            CTokenKind::ReturnKeyword => write!(f, "'return' keyword"),
+            CTokenKind::ShortKeyword => write!(f, "'short' keyword"),
+            CTokenKind::SignedKeyword => write!(f, "'signed' keyword"),
+            CTokenKind::SizeofKeyword => write!(f, "'sizeof' keyword"),
+            CTokenKind::StaticKeyword => write!(f, "'static' keyword"),
+            CTokenKind::StaticAssertKeyword => write!(f, "'static_assert' keyword"),
+            CTokenKind::StructKeyword => write!(f, "'struct' keyword"),
+            CTokenKind::SwitchKeyword => write!(f, "'switch' keyword"),
+            CTokenKind::ThreadLocalKeyword => write!(f, "'thread_local' keyword"),
+            CTokenKind::TrueKeyword => write!(f, "'true' keyword"),
+            CTokenKind::TypedefKeyword => write!(f, "'typedef' keyword"),
+            CTokenKind::TypeofKeyword => write!(f, "'typeof' keyword"),
+            CTokenKind::TypeofUnqualKeyword => write!(f, "'typeof_unqual' keyword"),
+            CTokenKind::UnionKeyword => write!(f, "'union' keyword"),
+            CTokenKind::UnsignedKeyword => write!(f, "'unsigned' keyword"),
+            CTokenKind::VoidKeyword => write!(f, "'void' keyword"),
+            CTokenKind::VolatileKeyword => write!(f, "'volatile' keyword"),
+            CTokenKind::WhileKeyword => write!(f, "'while' keyword"),
+            CTokenKind::AtomicKeyword => write!(f, "'_Atomic' keyword"),
+            CTokenKind::BitIntKeyword => write!(f, "'_BitInt' keyword"),
+            CTokenKind::ComplexKeyword => write!(f, "'_Complex' keyword"),
+            CTokenKind::Decimal128Keyword => write!(f, "'_Decimal128' keyword"),
+            CTokenKind::Decimal32Keyword => write!(f, "'_Decimal32' keyword"),
+            CTokenKind::Decimal64Keyword => write!(f, "'_Decimal64' keyword"),
+            CTokenKind::GenericKeyword => write!(f, "'_Generic' keyword"),
+            CTokenKind::ImaginaryKeyword => write!(f, "'_Imaginary' keyword"),
+            CTokenKind::NoreturnKeyword => write!(f, "'_Noreturn' keyword"),
+        }
+    }
+}
diff --git a/src/c/translate/function.rs b/src/c/translate/function.rs
@@ -4,7 +4,7 @@ use crate::{
     ast::{self, Func, FuncHead, Param, Params},
     c::{
         ast::{
-            Attribute, BlockItem, BlockItemKind, CTypedef, CompoundStatement,
+            Attribute, BlockItem, BlockItemKind, CTypedef, CompoundStatement, Declaration,
             DeclarationSpecifiers, Declarator, ExprStatement, JumpStatement,
             ParameterDeclarationCore, ParameterTypeList, StorageClassSpecifier, UnlabeledStatement,
         },
@@ -135,7 +135,16 @@ fn translate_block_item(
     block_item: &BlockItem,
 ) -> Result<ast::Stmt, ParseError> {
     match &block_item.kind {
-        BlockItemKind::Declaration(_) => todo!("translate_block_item declaration"),
+        BlockItemKind::Declaration(declaration) => match declaration {
+            Declaration::Common(_) => todo!("translate_block_item common declaration"),
+            Declaration::StaticAssert(static_assert) => Ok(ast::ExprKind::StaticAssert(
+                Box::new(translate_expr(ctx, &static_assert.condition.value)?),
+                static_assert.message.clone(),
+            )
+            .at(block_item.source)
+            .stmt()),
+            Declaration::Attribute(_) => todo!("translate_block_item attribute declaration"),
+        },
         BlockItemKind::UnlabeledStatement(unlabeled_statement) => {
             translate_unlabeled_statement(ctx, unlabeled_statement, block_item.source)
         }
diff --git a/src/resolve/expr/mod.rs b/src/resolve/expr/mod.rs
@@ -512,6 +512,13 @@ pub fn resolve_expr(
 
             return Ok(inner);
         }
+        ast::ExprKind::StaticAssert(_condition, _message) => {
+            todo!(
+                "resolve_expr - static_assert - {:?} {:?}",
+                _condition,
+                _message
+            )
+        }
     }?;
 
     match initialized {

Original file line number	Diff line number	Diff line change
`@@ -39,6 +39,7 @@ pub enum ExprKind {`
`39`	`39`	`Break,`
`40`	`40`	`Continue,`
`41`	`41`	`IntegerPromote(Box<Expr>),`
	`42`	`+ StaticAssert(Box<Expr>, Option<String>),`
`42`	`43`	`}`
`43`	`44`
`44`	`45`	`impl ExprKind {`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`use crate::{`
	`2`	`+ c::token::CTokenKind,`
`2`	`3`	`show::Show,`
`3`	`4`	`source_files::{Source, SourceFiles},`
`4`	`5`	`};`
`@@ -49,6 +50,7 @@ pub enum ParseErrorKind {`
`49`	`50`	`UndeclaredVariable(String),`
`50`	`51`	`UndeclaredType(String),`
`51`	`52`	`CannotContainNulInNullTerminatedString,`
	`53`	`+ MiscGot(&'static str, CTokenKind),`
`52`	`54`	`Misc(&'static str),`
`53`	`55`	`}`
`54`	`56`
`@@ -85,6 +87,9 @@ impl Display for ParseErrorKind {`
`85`	`87`	`ParseErrorKind::CannotContainNulInNullTerminatedString => {`
`86`	`88`	`write!(f, "Cannot contain NUL byte in C-String'")`
`87`	`89`	`}`
	`90`	`+ ParseErrorKind::MiscGot(message, got) => {`
	`91`	`+ write!(f, "{}, got {}", message, got)`
	`92`	`+ }`
`88`	`93`	`ParseErrorKind::Misc(message) => f.write_str(message),`
`89`	`94`	`}`
`90`	`95`	`}`