Implement C++ to Rust transpiler

Cargo.toml

@@ -1,15 +1,24 @@
 [package]
 name = "cppshift"
-version = "0.1.0"
+version = "0.1.1"
 authors = ["Jérémy HERGAULT", "Enzo PASQUALINI"]
 description = "CPP parser and transpiler"
 repository = "https://github.com/worldline/cppshift"
 edition = "2024"
 license = "Apache-2.0"
 
+[features]
+default = ["transpiler"]
+ast = []
+transpiler = ["ast", "dep:serde", "dep:syn", "dep:quote", "dep:proc-macro2"]
+
 [dependencies]
 miette = { version = "7", features = ["fancy"] }
 thiserror = "2"
+serde = { version = "1", features = ["derive"], optional = true }
+syn = { version = "2", features = ["full", "extra-traits", "printing"], optional = true }
+quote = { version = "1", optional = true }
+proc-macro2 = { version = "1", optional = true }
 
 [dev-dependencies]
 tokio = { version = "1", features = ["macros"] }

src/ast/expr.rs

@@ -3,6 +3,7 @@
 //! Analogous to `syn::Expr`.
 
 use crate::SourceSpan;
+use crate::ast::ty::{FundamentalKind, Type};
 
 use super::item::{Ident, Path};
 use super::punct::Punctuated;
@@ -16,6 +17,49 @@ pub enum LitKind {
     Char,
 }
 
+impl LitKind {
+    /// Check if the fundamental kind matches the literal kind
+    pub fn match_fundamental(&self, kind: FundamentalKind) -> bool {
+        match self {
+            LitKind::Integer => matches!(
+                kind,
+                FundamentalKind::Short
+                    | FundamentalKind::Int
+                    | FundamentalKind::Long
+                    | FundamentalKind::LongLong
+                    | FundamentalKind::SignedChar
+                    | FundamentalKind::UnsignedChar
+                    | FundamentalKind::UnsignedShort
+                    | FundamentalKind::UnsignedInt
+                    | FundamentalKind::UnsignedLong
+                    | FundamentalKind::UnsignedLongLong
+            ),
+            LitKind::Float => matches!(
+                kind,
+                FundamentalKind::Float | FundamentalKind::Double | FundamentalKind::LongDouble
+            ),
+            LitKind::Char => matches!(
+                kind,
+                FundamentalKind::Char
+                    | FundamentalKind::Wchar
+                    | FundamentalKind::Char8
+                    | FundamentalKind::Char16
+                    | FundamentalKind::Char32
+            ),
+            _ => false,
+        }
+    }
+
+    /// Check if the literal kind matches the type
+    pub fn match_type(&self, ty: &Type) -> bool {
+        match ty {
+            Type::Fundamental(fund) => self.match_fundamental(fund.kind),
+            Type::Qualified(qualified) => self.match_type(&qualified.ty),
+            _ => false,
+        }
+    }
+}
+
 /// Unary operator.
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum UnaryOp {