transpile: Properly handle address-of static compound literals

[Rua]

• Fixes File-scope compound literal translated incorrectly, causing segfault on write #1582.
• Fixes Allow WithStmts in static initialisers to contain statements #1610.

This allows limited use of statements in translations of statics, only if the statements are Stmt::Item. This is then used to solve the original bug, by declaring a fresh static variable to take the address of.

This code doesn't currently account for situations in which the compound literal expression needs to be sectioned off for late initialisation, as that would have complicated the code a fair bit further.

[kkysen]

Suggested change

	/// If all statements in self.stmts are Item statements, returns the contained Items.
	/// Otherwise, returns None.
	/// If all statements in `self.stmts` are [`Item`]s, returns the contained [`Item`]s.
	/// Otherwise, returns [`None`].

[kkysen]

Can we wait to merge this until after #1643 merges, which has gotten pretty long? #1643 changes things like mk_linkage, "link_section", etc., so it's going to have conflicts here, and I'd like to review the changes here after it's rebased on that.

[kkysen]

Suggested change

	}
	pub fn new_unsafe(stmts: Vec<Stmt>, val: T) -> Self {
	WithStmts {
	stmts,
	val,
	is_unsafe: true,
	}
	}

I'm not sure why there aren't newlines between the functions here, but let's fix it for new functions.

[kkysen]

Also, I feel like these 4 functions would be better off as builder-like methods, like this:

    pub fn new_val(val: T) -> Self {
        WithStmts {
            stmts: vec![],
            val,
            is_unsafe: false,
        }
    }

    pub fn stmts(self, stmts: Vec<Stmt>) -> Self {
        Self { stmts, ..self }
    }

    pub fn is_unsafe(self, is_unsafe: bool) -> Self {
        Self { is_unsafe, ..self }
    }

[Rua]

WithStmts doesn't use the builder pattern anywhere, so converting it to one seems like a separate refactor that belongs in its own PR?

[kkysen]

Why do these need to be unsafe?

[Rua]

Hmm, I guess taking a raw pointer is not unsafe, only taking a regular reference is.

[Rua]

It seems that convert_address_of_common doesn't mark its expression as unsafe, and never did even before my refactorings? Even when it's taking the address of a static? How did it work before then?