transpile: Add panicking variant of TypedAstContext::type_for_kind

Author: Rua

c2rust-transpile/src/c_ast/conversion.rs

@@ -511,7 +511,7 @@ impl ConversionContext {
         for (_decl_id, located_kind) in self.typed_context.c_decls.iter() {
             if let kind @ CDeclKind::Function { .. } = &located_kind.kind {
                 let new_kind = self.typed_context.fn_decl_ty_with_declared_args(kind);
-                if self.typed_context.type_for_kind(&new_kind).is_none() {
+                if self.typed_context.try_type_for_kind(&new_kind).is_none() {
                     // Create and insert fn type
                     let new_id = CTypeId(self.id_mapper.fresh_id());
                     self.typed_context
@@ -2203,9 +2203,7 @@ impl ConversionContext {
                                 }
                             };
                             log::trace!("Selected kind {kind} for typedef {name}");
-                            Some(CQualTypeId::new(
-                                self.typed_context.type_for_kind(&kind).unwrap(),
-                            ))
+                            Some(CQualTypeId::new(self.typed_context.type_for_kind(&kind)))
                         })
                         .unwrap_or(typ);
 
@@ -2248,9 +2246,7 @@ impl ConversionContext {
                             }
                         };
                         log::trace!("Selected kind {kind} for typedef {name}");
-                        Some(CQualTypeId::new(
-                            self.typed_context.type_for_kind(&kind).unwrap(),
-                        ))
+                        Some(CQualTypeId::new(self.typed_context.type_for_kind(&kind)))
                     };
                     let file = self
                         .typed_context

c2rust-transpile/src/c_ast/mod.rs

@@ -771,12 +771,17 @@ impl TypedAstContext {
         ty.map(|ty| (expr_id, ty))
     }
 
-    pub fn type_for_kind(&self, kind: &CTypeKind) -> Option<CTypeId> {
+    pub fn try_type_for_kind(&self, kind: &CTypeKind) -> Option<CTypeId> {
         self.c_types
             .iter()
             .find_map(|(id, k)| if kind == &k.kind { Some(*id) } else { None })
     }
 
+    pub fn type_for_kind(&self, kind: &CTypeKind) -> CTypeId {
+        self.try_type_for_kind(kind)
+            .expect("could not find type for CTypeKind::{kind:?}")
+    }
+
     pub fn resolve_type_id(&self, typ: CTypeId) -> CTypeId {
         use CTypeKind::*;
         let ty = match self.index(typ).kind {
@@ -875,9 +880,7 @@ impl TypedAstContext {
     pub fn fn_declref_ty_with_declared_args(&self, func_expr: CExprId) -> Option<CQualTypeId> {
         if let Some(func_decl @ CDeclKind::Function { .. }) = self.fn_declref_decl(func_expr) {
             let kind_with_declared_args = self.fn_decl_ty_with_declared_args(func_decl);
-            let specific_typ = self
-                .type_for_kind(&kind_with_declared_args)
-                .unwrap_or_else(|| panic!("no type for kind {kind_with_declared_args:?}"));
+            let specific_typ = self.type_for_kind(&kind_with_declared_args);
             return Some(CQualTypeId::new(specific_typ));
         }
         None
@@ -1344,10 +1347,7 @@ impl TypedAstContext {
                             CUnTypeOp::AlignOf => CTypeKind::Size,
                             CUnTypeOp::PreferredAlignOf => CTypeKind::Size,
                         };
-                        let ty = self
-                            .ast_context
-                            .type_for_kind(&kind)
-                            .expect("CTypeKind::Size should be size_t");
+                        let ty = self.ast_context.type_for_kind(&kind);
                         Some(CQualTypeId::new(ty))
                     }
                     _ => return,
@@ -2062,7 +2062,7 @@ impl CUnOp {
             }
             Not => {
                 return ast_context
-                    .type_for_kind(&CTypeKind::Int)
+                    .try_type_for_kind(&CTypeKind::Int)
                     .map(CQualTypeId::new)
             }
             Real | Imag => {

c2rust-transpile/src/translator/mod.rs

@@ -3149,7 +3149,7 @@ impl<'c> Translation<'c> {
 
                                 if let Some(ty) = self
                                     .ast_context
-                                    .type_for_kind(&kind_with_declared_args)
+                                    .try_type_for_kind(&kind_with_declared_args)
                                     .map(CQualTypeId::new)
                                 {
                                     let ty = self.convert_type(ty.ctype)?;
@@ -3334,14 +3334,10 @@ impl<'c> Translation<'c> {
                     // but the function's declaration will.
                     let kind_with_declared_args =
                         self.ast_context.fn_decl_ty_with_declared_args(func_decl);
-                    let func_ty = self
-                        .ast_context
-                        .type_for_kind(&kind_with_declared_args)
-                        .unwrap_or_else(|| panic!("no type for kind {kind_with_declared_args:?}"));
+                    let func_ty = self.ast_context.type_for_kind(&kind_with_declared_args);
                     let func_ptr_ty = self
                         .ast_context
-                        .type_for_kind(&CTypeKind::Pointer(CQualTypeId::new(func_ty)))
-                        .unwrap_or_else(|| panic!("no type for kind {kind_with_declared_args:?}"));
+                        .type_for_kind(&CTypeKind::Pointer(CQualTypeId::new(func_ty)));
 
                     CQualTypeId::new(func_ptr_ty)
                 } else {

c2rust-transpile/src/translator/operators.rs

@@ -642,11 +642,7 @@ impl<'c> Translation<'c> {
 
         let one_type_id =
             if let CTypeKind::Pointer(..) = self.ast_context.resolve_type(arg_type.ctype).kind {
-                CQualTypeId::new(
-                    self.ast_context
-                        .type_for_kind(&CTypeKind::Int)
-                        .ok_or_else(|| format_err!("couldn't find type for CTypeKind::Int"))?,
-                )
+                CQualTypeId::new(self.ast_context.type_for_kind(&CTypeKind::Int))
             } else {
                 arg_type
             };