[DNM] Fix wide-string override_ty

c2rust-transpile/Cargo.toml

@@ -18,6 +18,7 @@ c2rust-ast-printer = { path = "../c2rust-ast-printer", version = "0.22.1" }
 c2rust-bitfields = { path = "../c2rust-bitfields", version = "0.22.1" }
 c2rust-rust-tools = { path = "../c2rust-rust-tools", version = "0.22.1" }
 colored = "2.0"
+dashmap = "4.0"
 dtoa = "1.0"
 failure = "0.1.5"
 fern = { version = "0.6", features = ["colored"] }

c2rust-transpile/src/c_ast/mod.rs

@@ -47,7 +47,7 @@ pub type CEnumConstantId = CDeclId; // Enum's need to point to child 'DeclKind::
 pub struct TypedAstContext {
     main_file: PathBuf,
 
-    c_types: HashMap<CTypeId, CType>,
+    c_types: dashmap::DashMap<CTypeId, CType>,
     c_exprs: HashMap<CExprId, CExpr>,
     c_stmts: HashMap<CStmtId, CStmt>,
 
@@ -716,9 +716,26 @@ impl TypedAstContext {
     }
 
     pub fn type_for_kind(&self, kind: &CTypeKind) -> Option<CTypeId> {
-        self.c_types
+        let ro = self.c_types.clone().into_read_only();
+        if let Some(ty) = ro
             .iter()
             .find_map(|(id, k)| if kind == &k.kind { Some(*id) } else { None })
+        {
+            return Some(ty);
+        }
+        let max_type_id = ro
+            .keys()
+            .max_by_key(|id| id.0)
+            .expect("expected non-empty AstContext::c_types");
+        let new_id = CTypeId(max_type_id.0 + 1);
+        self.c_types.insert(
+            new_id,
+            Located {
+                loc: None,
+                kind: kind.clone(),
+            },
+        );
+        Some(new_id)
     }
 
     pub fn resolve_type_id(&self, typ: CTypeId) -> CTypeId {
@@ -1050,11 +1067,16 @@ impl TypedAstContext {
                 use SomeId::*;
                 match some_id {
                     Type(type_id) => {
-                        if let CTypeKind::Elaborated(decl_type_id) = self.c_types[&type_id].kind {
+                        if let CTypeKind::Elaborated(decl_type_id) =
+                            self.c_types.get(&type_id).unwrap().kind
+                        {
                             // This is a reference to a previously declared type.  If we look
                             // through it we should(?) get something that looks like a declaration,
                             // which we can mark as wanted.
-                            let decl_id = self.c_types[&decl_type_id]
+                            let decl_id = self
+                                .c_types
+                                .get(&decl_type_id)
+                                .unwrap()
                                 .kind
                                 .as_decl_or_typedef()
                                 .expect("target of CTypeKind::Elaborated isn't a decl?");
@@ -1388,7 +1410,7 @@ impl Index<CTypeId> for TypedAstContext {
     fn index(&self, index: CTypeId) -> &CType {
         match self.c_types.get(&index) {
             None => panic!("Could not find {:?} in TypedAstContext", index),
-            Some(ty) => ty,
+            Some(ty) => Box::leak(Box::new(ty.clone())),
         }
     }
 }

c2rust-transpile/src/c_ast/print.rs

@@ -697,10 +697,10 @@ impl<W: Write> Printer<W> {
         let ty = context
             .c_types
             .get(&type_id)
-            .map(|l| &l.kind)
+            .map(|l| l.kind.clone())
             .unwrap_or_else(|| panic!("Could not find type with ID {:?}", type_id));
         use CTypeKind::*;
-        match ty {
+        match &ty {
             Pointer(ref qual_ty) => {
                 self.print_qtype(*qual_ty, None, context)?;
                 self.writer.write_all(b"*")?;

c2rust-transpile/src/translator/mod.rs

@@ -3778,10 +3778,41 @@ impl<'c> Translation<'c> {
                             return self.convert_expr(ctx, expr, override_ty);
                         }
                     }
+                    if kind == CastKind::ArrayToPointerDecay && override_ty.is_some() {
+                        let target_elem = match &self
+                            .ast_context
+                            .resolve_type(override_ty.unwrap().ctype)
+                            .kind
+                        {
+                            CTypeKind::Pointer(qtype) => qtype.ctype,
+                            k => panic!("ArrayToPointerDecay producing non-pointer type {k:?}"),
+                        };
+                        let new_array_override_ty_kind =
+                            match &self.ast_context.resolve_type(source_ty.ctype).kind {
+                                CTypeKind::ConstantArray(_elem, len) => {
+                                    CTypeKind::ConstantArray(target_elem, *len)
+                                }
+                                CTypeKind::VariableArray(_elem, len) => {
+                                    CTypeKind::VariableArray(target_elem, *len)
+                                }
+                                k => panic!("ArrayToPointerDecay on non-array type {k:?}"),
+                            };
+                        //
+                        //           && Some(source_ty.ctype) != override_ty.map(|x| x.ctype)
+                        let new_array_override_ty = self
+                            .ast_context
+                            .type_for_kind(&new_array_override_ty_kind)
+                            .expect(&format!(
+                                "type id did not already exist for {:?}",
+                                new_array_override_ty_kind
+                            ));
+
+                        self.convert_expr(ctx, expr, Some(CQualTypeId::new(new_array_override_ty)))?
+                    }
                     // LValueToRValue casts don't actually change the type, so it still makes sense
                     // to translate their inner expression with the expected type from outside the
                     // cast.
-                    if kind == CastKind::LValueToRValue
+                    else if kind == CastKind::LValueToRValue
                         && Some(source_ty.ctype) != override_ty.map(|x| x.ctype)
                     {
                         self.convert_expr(ctx, expr, override_ty)?