transpile: Compute and store override_tys ahead of time

Author: Rua

c2rust-transpile/src/c_ast/c_expr.rs

@@ -1,5 +1,5 @@
 use crate::c_ast::c_decl::{CDeclId, CDeclKind, CFieldId};
-use crate::c_ast::c_stmt::CStmtId;
+use crate::c_ast::c_stmt::{CStmtId, CStmtKind};
 use crate::c_ast::c_type::{CQualTypeId, CTypeId, CTypeKind};
 use crate::c_ast::{Located, SomeId, TypedAstContext};
 use c2rust_ast_exporter::clang_ast::LRValue;
@@ -698,6 +698,18 @@ impl TypedAstContext {
         }
     }
 
+    /// Same as the `Index` trait, but doesn't bypass `Paren`.
+    pub fn index_expr_raw(&self, index: CExprId) -> &CExpr {
+        static BADEXPR: CExpr = Located {
+            loc: None,
+            kind: CExprKind::BadExpr,
+        };
+        match self.c_exprs.get(&index) {
+            None => &BADEXPR,
+            Some(e) => e,
+        }
+    }
+
     pub fn is_null_expr(&self, expr_id: CExprId) -> bool {
         use CExprKind::*;
         match self[expr_id].kind {
@@ -953,6 +965,53 @@ impl TypedAstContext {
             BadExpr => false,
         }
     }
+
+    /// Returns whether `expr` is within a conditional context, meaning that it is in a context
+    /// where a Rust `bool` will be expected.
+    pub fn expr_is_condition(&self, expr: CExprId) -> bool {
+        let parent = match self.parent(expr) {
+            Some(parent) => parent,
+            None => return false,
+        };
+
+        match parent {
+            SomeId::Stmt(parent_stmt) => match self.c_stmts[&parent_stmt].kind {
+                CStmtKind::If {
+                    scrutinee: condition,
+                    ..
+                }
+                | CStmtKind::While { condition, .. }
+                | CStmtKind::DoWhile { condition, .. }
+                | CStmtKind::ForLoop {
+                    condition: Some(condition),
+                    ..
+                } => expr == condition,
+                _ => false,
+            },
+
+            SomeId::Expr(parent_expr) => match self.c_exprs[&parent_expr].kind {
+                CExprKind::Paren(..) => self.expr_is_condition(parent_expr),
+                CExprKind::Unary(_, CUnOp::Not, arg, _) => expr == arg,
+                CExprKind::Binary(_, CBinOp::And | CBinOp::Or, lhs, rhs, _, _) => {
+                    expr == lhs || expr == rhs
+                }
+                CExprKind::Conditional(_, condition, _, _)
+                | CExprKind::BinaryConditional(_, condition, _) => expr == condition,
+                CExprKind::ImplicitCast(_, arg, kind, _, _)
+                | CExprKind::ExplicitCast(_, arg, kind, _, _) => {
+                    matches!(
+                        kind,
+                        CastKind::IntegralToBoolean
+                            | CastKind::FloatingToBoolean
+                            | CastKind::PointerToBoolean
+                    ) && expr == arg
+                }
+                _ => false,
+            },
+
+            _ => false,
+        }
+    }
 }
 
 impl Index<CExprId> for TypedAstContext {

c2rust-transpile/src/c_ast/mod.rs

@@ -243,6 +243,18 @@ impl TypedAstContext {
             .and_then(|parent| T::try_from(parent).ok())
     }
 
+    /// If `child` is inside a function, returns its `CDeclId`.
+    pub fn parent_function(&self, child: impl Into<SomeId>) -> Option<CDeclId> {
+        match self.parent(child)? {
+            SomeId::Stmt(stmt) => self.parent_function(stmt),
+            SomeId::Expr(expr) => self.parent_function(expr),
+            SomeId::Decl(decl) => {
+                matches!(self[decl].kind, CDeclKind::Function { .. }).then_some(decl)
+            }
+            SomeId::Type(ty) => self.parent_function(ty),
+        }
+    }
+
     pub fn display_loc(&self, loc: &Option<SrcSpan>) -> Option<DisplaySrcSpan> {
         loc.as_ref().map(|loc| DisplaySrcSpan {
             file: self.files[self.file_map[loc.fileid as usize]].path.clone(),