Cannot take address of a temporary

[randomPoison]

Currently when translating json-c and zstd we are producing code that doesn't compile because it's attempting to take the address of a temporary:

json-c: cargo.transpile(tests/json-c/cargo.transpile.gen.sh)...... FAIL
error[E0745]: cannot take address of a temporary
   --> src/json_object.rs:731:24
    |
731 |               &raw const ::core::mem::transmute::<
    |  ________________________^
732 | |                 [u8; 58],
733 | |                 [::core::ffi::c_char; 58],
734 | |             >(*b"struct json_object *json_object_get(struct json_object *)\0")
    | |______________________________________________________________________________^ temporary value

Note that this made it onto master because there is also a bug in CI that's causing CI to not report when tests fail.

cc @Rua

[Rua]

It looks like it is generating a transmute for a string literal (the usual translation), when it should be just casting it to a pointer:

c2rust/c2rust-transpile/src/translator/pointers.rs

Lines 129 to 145 in 6f9628e

	if let (
	Some(&CExprKind::Literal(literal_cty, CLiteral::String(ref bytes, element_size @ 1))),
	false,
	) = (arg_expr_kind, arg_is_macro)
	{
	let bytes_padded = self.string_literal_bytes(literal_cty.ctype, bytes, element_size);
	let len = bytes_padded.len();
	val = WithStmts::new_val(mk().lit_expr(bytes_padded));
	if is_array_decay {
	ref_cast_pointee_ty = Some(mk().ident_ty("u8"));
	} else {
	ref_cast_pointee_ty =
	Some(mk().array_ty(mk().ident_ty("u8"), mk().lit_expr(len as u128)));
	}
	needs_cast = true;
	}

The condition for that if must not be being met, but I can't tell what's wrong without knowing the C code that it's trying to translate and/or the AST of it. Whatever it is, the snapshot tests must not be testing for it yet.

[randomPoison]

Confirming this was introduced in #1355

[randomPoison]

Huh, it looks like the code that fails to compile comes from asserts that c2rust is inserting? Or at least I can't tell how these asserts are coming from the source C. Source function:

extern struct json_object* json_object_get(struct json_object *jso)
{
	if (!jso) return jso;

#if defined(HAVE_ATOMIC_BUILTINS) && defined(ENABLE_THREADING)
	__sync_add_and_fetch(&jso->_ref_count, 1);
#else
	++jso->_ref_count;
#endif        

	return jso;
}

Translation:

pub unsafe extern "C" fn json_object_get(mut jso: *mut json_object) -> *mut json_object {
    if jso.is_null() {
        return jso;
    }
    if (*jso)._ref_count < 4294967295 as uint32_t {} else {
        __assert_fail(
            b"jso->_ref_count < UINT32_MAX\0" as *const u8 as *const ::core::ffi::c_char,
            b"json_object.c\0" as *const u8 as *const ::core::ffi::c_char,
            174 as ::core::ffi::c_uint,
            &raw const ::core::mem::transmute::<
                [u8; 58],
                [::core::ffi::c_char; 58],
            >(*b"struct json_object *json_object_get(struct json_object *)\0")
                as *const ::core::ffi::c_char,
        );
    }
    'c_421: {
        if (*jso)._ref_count < 4294967295 as uint32_t {} else {
            __assert_fail(
                b"jso->_ref_count < UINT32_MAX\0" as *const u8
                    as *const ::core::ffi::c_char,
                b"json_object.c\0" as *const u8 as *const ::core::ffi::c_char,
                174 as ::core::ffi::c_uint,
                &raw const ::core::mem::transmute::<
                    [u8; 58],
                    [::core::ffi::c_char; 58],
                >(*b"struct json_object *json_object_get(struct json_object *)\0")
                    as *const ::core::ffi::c_char,
            );
        }
    };
    (*jso)._ref_count = (*jso)._ref_count.wrapping_add(1);
    return jso;
}

[randomPoison]

🤦 I was looking at the wrong version of json-c, turns out we also have one in examples. The version in the test suite has an assert:

assert(jso->_ref_count < UINT32_MAX);

[randomPoison]

The offending code post-preprocessor:

(
     (void) sizeof ((jso->_ref_count < (4294967295U)) ? 1 : 0),
     __extension__ ({
          if (jso->_ref_count < (4294967295U)) ;
          else __assert_fail (
               "jso->_ref_count < UINT32_MAX",
               "json_object.c",
               174,
               __extension__ __PRETTY_FUNCTION__
          );
     })
);

So looks like __extension__ __PRETTY_FUNCTION__ is getting handled weirdly.

[randomPoison]

Oh, it's probably the arg_is_macro check in the code @Rua pointed to, that's likely coming back as true for __PRETTY_FUNCTION__.

[Rua]

If it's a macro, how would it making it through the preprocessor unscathed? Also, arg_is_macro is only supposed to be true if c2rust has successfully converted the value into a const, which doesn't appear to have happened here.

Anyway, having the expanded code let me try it out, and I noticed that it's the __extension__ expression that's throwing a spanner in the works here. Rather than being ImplicitCast/ArrayToPointerDecay > Predefined > Literal, the sequence here is ImplicitCast/ArrayToPointerDecay > Unary/Extension > Predefined > Literal. So this is a case that was missed by #1481.