transpile: Prefix c_ast::{BinOp, UnOp, UnTypeOp} with C to disambiguate better

Author: Rua

c2rust-transpile/src/c_ast/c_expr.rs

@@ -25,18 +25,18 @@ pub enum CExprKind {
     Literal(CQualTypeId, CLiteral),
 
     /// Unary operator.
-    Unary(CQualTypeId, UnOp, CExprId, LRValue),
+    Unary(CQualTypeId, CUnOp, CExprId, LRValue),
 
     /// Unary type operator.
-    UnaryType(CQualTypeId, UnTypeOp, Option<CExprId>, CQualTypeId),
+    UnaryType(CQualTypeId, CUnTypeOp, Option<CExprId>, CQualTypeId),
 
     /// `offsetof` expression.
     OffsetOf(CQualTypeId, OffsetOfKind),
 
     /// Binary operator.
     Binary(
         CQualTypeId,
-        BinOp,
+        CBinOp,
         CExprId,
         CExprId,
         Option<CQualTypeId>,
@@ -307,7 +307,7 @@ impl CastKind {
 
 /// Represents a unary operator in C (6.5.3 Unary operators) and GNU C extensions
 #[derive(Debug, Clone, Copy)]
-pub enum UnOp {
+pub enum CUnOp {
     AddressOf,     // &x
     Deref,         // *x
     Plus,          // +x
@@ -324,9 +324,9 @@ pub enum UnOp {
     Coawait,       // [C++ Coroutines] co_await x
 }
 
-impl UnOp {
+impl CUnOp {
     pub fn as_str(&self) -> &'static str {
-        use UnOp::*;
+        use CUnOp::*;
         match self {
             AddressOf => "&",
             Deref => "*",
@@ -351,7 +351,7 @@ impl UnOp {
         ast_context: &TypedAstContext,
         arg_type: CQualTypeId,
     ) -> Option<CQualTypeId> {
-        use UnOp::*;
+        use CUnOp::*;
         let resolved_ty = ast_context.resolve_type(arg_type.ctype);
         Some(match self {
             // We could construct CTypeKind::Pointer here, but it is not guaranteed to have a
@@ -382,23 +382,23 @@ impl UnOp {
     }
 }
 
-impl Display for UnOp {
+impl Display for CUnOp {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{}", self.as_str())
     }
 }
 
 /// Represents a unary type operator in C
 #[derive(Debug, Clone, Copy)]
-pub enum UnTypeOp {
+pub enum CUnTypeOp {
     SizeOf,
     AlignOf,
     PreferredAlignOf,
 }
 
-impl UnTypeOp {
+impl CUnTypeOp {
     pub fn as_str(&self) -> &'static str {
-        use UnTypeOp::*;
+        use CUnTypeOp::*;
         match self {
             SizeOf => "sizeof",
             AlignOf => "alignof",
@@ -407,22 +407,22 @@ impl UnTypeOp {
     }
 }
 
-impl Display for UnTypeOp {
+impl Display for CUnTypeOp {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{}", self.as_str())
     }
 }
 
-impl UnOp {
+impl CUnOp {
     /// Check is the operator is rendered before or after is operand.
     pub fn is_prefix(&self) -> bool {
-        !matches!(*self, UnOp::PostIncrement | UnOp::PostDecrement)
+        !matches!(*self, CUnOp::PostIncrement | CUnOp::PostDecrement)
     }
 }
 
 /// Represents a binary operator in C (6.5.5 Multiplicative operators - 6.5.14 Logical OR operator)
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum BinOp {
+pub enum CBinOp {
     Multiply,     // *
     Divide,       // /
     Modulus,      // %
@@ -457,9 +457,9 @@ pub enum BinOp {
     Comma,  // ,
 }
 
-impl BinOp {
+impl CBinOp {
     pub fn as_str(&self) -> &'static str {
-        use BinOp::*;
+        use CBinOp::*;
         match self {
             Multiply => "*",
             Divide => "/",
@@ -499,7 +499,7 @@ impl BinOp {
     /// Does the rust equivalent of this operator have type (T, T) -> U?
     #[rustfmt::skip]
     pub fn input_types_same(&self) -> bool {
-        use BinOp::*;
+        use CBinOp::*;
         self.all_types_same() || matches!(self,
             Less | Greater | LessEqual | GreaterEqual | EqualEqual | NotEqual
             | And | Or
@@ -512,27 +512,27 @@ impl BinOp {
     /// Does the rust equivalent of this operator have type (T, T) -> T?
     /// This ignores cases where one argument is a pointer and we translate to `.offset()`.
     pub fn all_types_same(&self) -> bool {
-        use BinOp::*;
+        use CBinOp::*;
         matches!(
             self,
             Multiply | Divide | Modulus | Add | Subtract | BitAnd | BitXor | BitOr
         )
     }
 }
 
-impl Display for BinOp {
+impl Display for CBinOp {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{}", self.as_str())
     }
 }
 
-impl BinOp {
+impl CBinOp {
     /// Maps compound assignment operators to operator underlying them, and returns `None` for all
     /// other operators.
     ///
     /// For example, `AssignAdd` maps to `Some(Add)` but `Add` maps to `None`.
-    pub fn underlying_assignment(&self) -> Option<BinOp> {
-        use BinOp::*;
+    pub fn underlying_assignment(&self) -> Option<CBinOp> {
+        use CBinOp::*;
         Some(match *self {
             AssignAdd => Add,
             AssignSubtract => Subtract,
@@ -623,7 +623,7 @@ impl TypedAstContext {
 
     /// Returns the expression inside an `__extension__` operator.
     pub fn resolve_extension(&self, expr_id: CExprId) -> CExprId {
-        if let CExprKind::Unary(_, UnOp::Extension, subexpr, _) = self.index(expr_id).kind {
+        if let CExprKind::Unary(_, CUnOp::Extension, subexpr, _) = self.index(expr_id).kind {
             subexpr
         } else {
             expr_id
@@ -730,11 +730,11 @@ impl TypedAstContext {
             ShuffleVector(..) |
             ConvertVector(..) |
             Call(..) |
-            Unary(_, UnOp::PreIncrement, _, _) |
-            Unary(_, UnOp::PostIncrement, _, _) |
-            Unary(_, UnOp::PreDecrement, _, _) |
-            Unary(_, UnOp::PostDecrement, _, _) |
-            Binary(_, BinOp::Assign, _, _, _, _) |
+            Unary(_, CUnOp::PreIncrement, _, _) |
+            Unary(_, CUnOp::PostIncrement, _, _) |
+            Unary(_, CUnOp::PreDecrement, _, _) |
+            Unary(_, CUnOp::PostDecrement, _, _) |
+            Binary(_, CBinOp::Assign, _, _, _, _) |
             InitList { .. } |
             ImplicitValueInit { .. } |
             Predefined(..) |
@@ -810,8 +810,8 @@ impl TypedAstContext {
             UnaryType(_, _, expr, _) => expr.map_or(true, is_const),
             // Not sure what a `OffsetOfKind::Variable` means.
             OffsetOf(_, _) => true,
-            // `ptr::offset` (ptr `BinOp::Add`) was `const` stabilized in `1.61.0`.
-            // `ptr::offset_from` (ptr `BinOp::Subtract`) was `const` stabilized in `1.65.0`.
+            // `ptr::offset` (ptr `CBinOp::Add`) was `const` stabilized in `1.61.0`.
+            // `ptr::offset_from` (ptr `CBinOp::Subtract`) was `const` stabilized in `1.65.0`.
             // TODO `f128` is not yet handled, as we should eventually
             // switch to the (currently unstable) `f128` primitive type (#1262).
             Binary(_, _, lhs, rhs, _, _) => is_const(lhs) && is_const(rhs),

c2rust-transpile/src/c_ast/conversion.rs

@@ -1,7 +1,7 @@
 use crate::c_ast::c_decl::{CDecl, CDeclId, CDeclKind};
 use crate::c_ast::c_expr::{
-    BinOp, CExpr, CExprId, CExprKind, CLiteral, CastKind, ConstIntExpr, Designator, IntBase,
-    MemberKind, OffsetOfKind, UnOp, UnTypeOp,
+    CBinOp, CExpr, CExprId, CExprKind, CLiteral, CUnOp, CUnTypeOp, CastKind, ConstIntExpr,
+    Designator, IntBase, MemberKind, OffsetOfKind,
 };
 use crate::c_ast::c_stmt::{AsmOperand, CStmt, CStmtId, CStmtKind};
 use crate::c_ast::c_type::{CQualTypeId, CType, CTypeId, CTypeKind, Qualifiers};
@@ -1376,30 +1376,30 @@ impl ConversionContext {
                         .expect("Expected operator")
                         .as_str()
                     {
-                        "&" => UnOp::AddressOf,
-                        "*" => UnOp::Deref,
-                        "+" => UnOp::Plus,
-                        "-" => UnOp::Negate,
-                        "~" => UnOp::Complement,
-                        "!" => UnOp::Not,
+                        "&" => CUnOp::AddressOf,
+                        "*" => CUnOp::Deref,
+                        "+" => CUnOp::Plus,
+                        "-" => CUnOp::Negate,
+                        "~" => CUnOp::Complement,
+                        "!" => CUnOp::Not,
                         "++" => {
                             if prefix {
-                                UnOp::PreIncrement
+                                CUnOp::PreIncrement
                             } else {
-                                UnOp::PostIncrement
+                                CUnOp::PostIncrement
                             }
                         }
                         "--" => {
                             if prefix {
-                                UnOp::PreDecrement
+                                CUnOp::PreDecrement
                             } else {
-                                UnOp::PostDecrement
+                                CUnOp::PostDecrement
                             }
                         }
-                        "__real" => UnOp::Real,
-                        "__imag" => UnOp::Imag,
-                        "__extension__" => UnOp::Extension,
-                        "co_await" => UnOp::Coawait,
+                        "__real" => CUnOp::Real,
+                        "__imag" => CUnOp::Imag,
+                        "__extension__" => CUnOp::Extension,
+                        "co_await" => CUnOp::Coawait,
                         o => panic!("Unexpected operator: {}", o),
                     };
 
@@ -1505,36 +1505,36 @@ impl ConversionContext {
                         .expect("Expected operator")
                         .as_str()
                     {
-                        "*" => BinOp::Multiply,
-                        "/" => BinOp::Divide,
-                        "%" => BinOp::Modulus,
-                        "+" => BinOp::Add,
-                        "-" => BinOp::Subtract,
-                        "<<" => BinOp::ShiftLeft,
-                        ">>" => BinOp::ShiftRight,
-                        "<" => BinOp::Less,
-                        ">" => BinOp::Greater,
-                        "<=" => BinOp::LessEqual,
-                        ">=" => BinOp::GreaterEqual,
-                        "==" => BinOp::EqualEqual,
-                        "!=" => BinOp::NotEqual,
-                        "&" => BinOp::BitAnd,
-                        "^" => BinOp::BitXor,
-                        "|" => BinOp::BitOr,
-                        "&&" => BinOp::And,
-                        "||" => BinOp::Or,
-                        "+=" => BinOp::AssignAdd,
-                        "-=" => BinOp::AssignSubtract,
-                        "*=" => BinOp::AssignMultiply,
-                        "/=" => BinOp::AssignDivide,
-                        "%=" => BinOp::AssignModulus,
-                        "^=" => BinOp::AssignBitXor,
-                        "<<=" => BinOp::AssignShiftLeft,
-                        ">>=" => BinOp::AssignShiftRight,
-                        "|=" => BinOp::AssignBitOr,
-                        "&=" => BinOp::AssignBitAnd,
-                        "=" => BinOp::Assign,
-                        "," => BinOp::Comma,
+                        "*" => CBinOp::Multiply,
+                        "/" => CBinOp::Divide,
+                        "%" => CBinOp::Modulus,
+                        "+" => CBinOp::Add,
+                        "-" => CBinOp::Subtract,
+                        "<<" => CBinOp::ShiftLeft,
+                        ">>" => CBinOp::ShiftRight,
+                        "<" => CBinOp::Less,
+                        ">" => CBinOp::Greater,
+                        "<=" => CBinOp::LessEqual,
+                        ">=" => CBinOp::GreaterEqual,
+                        "==" => CBinOp::EqualEqual,
+                        "!=" => CBinOp::NotEqual,
+                        "&" => CBinOp::BitAnd,
+                        "^" => CBinOp::BitXor,
+                        "|" => CBinOp::BitOr,
+                        "&&" => CBinOp::And,
+                        "||" => CBinOp::Or,
+                        "+=" => CBinOp::AssignAdd,
+                        "-=" => CBinOp::AssignSubtract,
+                        "*=" => CBinOp::AssignMultiply,
+                        "/=" => CBinOp::AssignDivide,
+                        "%=" => CBinOp::AssignModulus,
+                        "^=" => CBinOp::AssignBitXor,
+                        "<<=" => CBinOp::AssignShiftLeft,
+                        ">>=" => CBinOp::AssignShiftRight,
+                        "|=" => CBinOp::AssignBitOr,
+                        "&=" => CBinOp::AssignBitAnd,
+                        "=" => CBinOp::Assign,
+                        "," => CBinOp::Comma,
                         _ => unimplemented!(),
                     };
 
@@ -1639,9 +1639,9 @@ impl ConversionContext {
                     let kind_name =
                         from_value::<String>(node.extras[0].clone()).expect("expected kind");
                     let kind = match kind_name.as_str() {
-                        "sizeof" => UnTypeOp::SizeOf,
-                        "alignof" => UnTypeOp::AlignOf,
-                        "preferredalignof" => UnTypeOp::PreferredAlignOf,
+                        "sizeof" => CUnTypeOp::SizeOf,
+                        "alignof" => CUnTypeOp::AlignOf,
+                        "preferredalignof" => CUnTypeOp::PreferredAlignOf,
                         str => panic!("Unsupported operation: {}", str),
                     };
 

c2rust-transpile/src/c_ast/mod.rs

@@ -1,5 +1,5 @@
 use crate::c_ast::c_decl::{CDecl, CDeclId, CDeclKind};
-use crate::c_ast::c_expr::{BinOp, CExpr, CExprId, CExprKind, UnTypeOp};
+use crate::c_ast::c_expr::{CBinOp, CExpr, CExprId, CExprKind, CUnTypeOp};
 use crate::c_ast::c_stmt::{CLabelId, CStmt, CStmtId};
 use crate::c_ast::c_type::{CQualTypeId, CType, CTypeId, CTypeKind};
 use crate::c_ast::iterators::{immediate_children_all_types, DFNodes, NodeVisitor, SomeId};
@@ -498,7 +498,7 @@ impl TypedAstContext {
                             } else {
                                 Some(rhs_type_id)
                             }
-                        } else if op == BinOp::ShiftLeft || op == BinOp::ShiftRight {
+                        } else if op == CBinOp::ShiftLeft || op == CBinOp::ShiftRight {
                             Some(lhs_type_id)
                         } else {
                             return;
@@ -510,11 +510,11 @@ impl TypedAstContext {
                     ),
                     CExprKind::Paren(_ty, e) => self.ast_context.c_exprs[&e].kind.get_qual_type(),
                     CExprKind::UnaryType(_, op, _, _) => {
-                        // All of these `UnTypeOp`s should return `size_t`.
+                        // All of these `CUnTypeOp`s should return `size_t`.
                         let kind = match op {
-                            UnTypeOp::SizeOf => CTypeKind::Size,
-                            UnTypeOp::AlignOf => CTypeKind::Size,
-                            UnTypeOp::PreferredAlignOf => CTypeKind::Size,
+                            CUnTypeOp::SizeOf => CTypeKind::Size,
+                            CUnTypeOp::AlignOf => CTypeKind::Size,
+                            CUnTypeOp::PreferredAlignOf => CTypeKind::Size,
                         };
                         let ty = self
                             .ast_context

c2rust-transpile/src/c_ast/print.rs

@@ -1,5 +1,5 @@
 use crate::c_ast::c_decl::{CDeclId, CDeclKind};
-use crate::c_ast::c_expr::{BinOp, CExprId, CExprKind, CLiteral, MemberKind, OffsetOfKind, UnOp};
+use crate::c_ast::c_expr::{CBinOp, CExprId, CExprKind, CLiteral, CUnOp, MemberKind, OffsetOfKind};
 use crate::c_ast::c_stmt::{CStmtId, CStmtKind};
 use crate::c_ast::c_type::{CQualTypeId, CTypeId, CTypeKind, Qualifiers};
 use crate::c_ast::TypedAstContext;
@@ -291,11 +291,11 @@ impl<W: Write> Printer<W> {
         Ok(())
     }
 
-    pub fn print_unop(&mut self, op: &UnOp, _context: &TypedAstContext) -> Result<()> {
+    pub fn print_unop(&mut self, op: &CUnOp, _context: &TypedAstContext) -> Result<()> {
         self.writer.write_all(op.as_str().as_bytes())
     }
 
-    pub fn print_binop(&mut self, op: &BinOp, _context: &TypedAstContext) -> Result<()> {
+    pub fn print_binop(&mut self, op: &CBinOp, _context: &TypedAstContext) -> Result<()> {
         self.writer.write_all(op.as_str().as_bytes())
     }