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"] }

README.md

@@ -32,3 +32,11 @@ To parse a C++ source file and inspect the AST decomposition, run the _ast_ exam
 ```bash
 cargo run --example ast -- <source_path>
 ```
+
+## Transpiler
+
+The transpiler contains all trait implementations for C++ to Rust transpilation.
+There are no examples available.
+
+You need to configure all the settings in the `Transpiler`.
+After that, you will be able to transpile any C++ structure you have.

src/ast/expr.rs

@@ -2,7 +2,10 @@
 //!
 //! Analogous to `syn::Expr`.
 
-use crate::SourceSpan;
+use std::str::FromStr;
+
+use crate::ast::ty::{FundamentalKind, Type};
+use crate::{SourceCodeSpan, SourceSpan};
 
 use super::item::{Ident, Path};
 use super::punct::Punctuated;
@@ -16,6 +19,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 {
@@ -143,13 +189,44 @@ pub enum Expr<'de> {
     InitList(ExprInitList<'de>),
 }
 
+impl<'de> SourceCodeSpan<'de> for Expr<'de> {
+    fn span(&self) -> Option<SourceSpan<'de>> {
+        match self {
+            Expr::Lit(ExprLit { span, .. })
+            | Expr::Bool(ExprBool { span, .. })
+            | Expr::Nullptr(ExprNullptr { span, .. })
+            | Expr::This(ExprThis { span, .. }) => Some(*span),
+            Expr::Ident(ExprIdent { ident }) => Some(ident.span),
+            Expr::Paren(expr_paren) => expr_paren.expr.span(),
+            Expr::Unary(expr_unary) => expr_unary.span(),
+            Expr::Binary(expr_binary) => expr_binary.span(),
+            Expr::Conditional(expr_conditional) => expr_conditional.span(),
+            Expr::Call(expr_call) => expr_call.span(),
+            Expr::Sizeof(expr_sizeof) => expr_sizeof.operand.span(),
+            Expr::Alignof(expr_alignof) => expr_alignof.ty.span(),
+            Expr::Typeid(expr_typeid) => expr_typeid.operand.span(),
+            _ => None,
+        }
+    }
+}
+
 /// Literal expression: numbers, strings, chars.
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct ExprLit<'de> {
     pub span: SourceSpan<'de>,
     pub kind: LitKind,
 }
 
+impl<'de> ExprLit<'de> {
+    /// Parse the literal value from the source span as the specified type.
+    pub fn parse<F>(&self) -> Result<F, F::Err>
+    where
+        F: FromStr,
+    {
+        self.span.src().parse::<F>()
+    }
+}
+
 /// Simple identifier expression.
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct ExprIdent<'de> {
@@ -194,6 +271,12 @@ pub struct ExprUnary<'de> {
     pub operand: Box<Expr<'de>>,
 }
 
+impl<'de> SourceCodeSpan<'de> for ExprUnary<'de> {
+    fn span(&self) -> Option<SourceSpan<'de>> {
+        self.operand.span()
+    }
+}
+
 /// Binary expression: `lhs op rhs`.
 #[derive(Debug, Clone, PartialEq)]
 pub struct ExprBinary<'de> {
@@ -202,6 +285,18 @@ pub struct ExprBinary<'de> {
     pub rhs: Box<Expr<'de>>,
 }
 
+impl<'de> SourceCodeSpan<'de> for ExprBinary<'de> {
+    fn span(&self) -> Option<SourceSpan<'de>> {
+        self.lhs.span().map(|l| {
+            if let Some(r) = self.rhs.span() {
+                l.extend(r)
+            } else {
+                l
+            }
+        })
+    }
+}
+
 /// Ternary conditional: `condition ? then_expr : else_expr`.
 #[derive(Debug, Clone, PartialEq)]
 pub struct ExprConditional<'de> {
@@ -210,6 +305,20 @@ pub struct ExprConditional<'de> {
     pub else_expr: Box<Expr<'de>>,
 }
 
+impl<'de> SourceCodeSpan<'de> for ExprConditional<'de> {
+    fn span(&self) -> Option<SourceSpan<'de>> {
+        self.condition.span().map(|c| {
+            if let Some(e) = self.else_expr.span() {
+                c.extend(e)
+            } else if let Some(t) = self.then_expr.span() {
+                c.extend(t)
+            } else {
+                c
+            }
+        })
+    }
+}
+
 /// Function call: `callee(args...)`.
 ///
 /// Analogous to `syn::ExprCall`.
@@ -219,6 +328,20 @@ pub struct ExprCall<'de> {
     pub args: Punctuated<'de, Expr<'de>>,
 }
 
+impl<'de> SourceCodeSpan<'de> for ExprCall<'de> {
+    fn span(&self) -> Option<SourceSpan<'de>> {
+        if let Some(func_span) = self.func.span() {
+            if let Some(args_span) = self.args.span() {
+                Some(func_span.extend(args_span))
+            } else {
+                Some(func_span)
+            }
+        } else {
+            self.args.span()
+        }
+    }
+}
+
 /// Method call: `receiver.method(args...)`.
 ///
 /// Analogous to `syn::ExprMethodCall`.
@@ -347,6 +470,15 @@ pub enum TypeidOperand<'de> {
     Expr(Box<Expr<'de>>),
 }
 
+impl<'de> SourceCodeSpan<'de> for TypeidOperand<'de> {
+    fn span(&self) -> Option<SourceSpan<'de>> {
+        match &self {
+            TypeidOperand::Type(op_type) => op_type.span(),
+            TypeidOperand::Expr(op_expr) => op_expr.span(),
+        }
+    }
+}
+
 /// Braced initializer list: `{1, 2, 3}`.
 #[derive(Debug, Clone, PartialEq)]
 pub struct ExprInitList<'de> {