This should fix the compilation error of no_std crates that depends on that macro. This error probably comes because panic handler included twice during compilation.

#[panic_handler]
fn panic(_: &core::panic::PanicInfo) -> ! {
    loop {}
}

error[E0152]: found duplicate lang item `panic_impl`
  --> src\main.rs:35:1
   |
35 | fn panic(_: &core::panic::PanicInfo) -> ! {
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: the lang item is first defined in crate `std` (which `const_utf16` depends on)
   = note: first definition in `std` loaded from \\?\C:\Users\alex\.rustup\toolchains\nightly-x86_64-pc-windows-msvc\lib\rustlib\x86_64-pc-windows-msvc\lib\std-09e4abccd169ee6e.dll, \\?\C:\Users\alex\.rustup\toolchains\nightly-x86_64-pc-windows-msvc\lib\rustlib\x86_64-pc-windows-msvc\lib\libstd-09e4abccd169ee6e.rlib

Here's the code from my tweet in text form, if you'd prefer not to retype it.

const fn utf16_len(s: &str) -> usize {
    s.len() // Obviously incorrect.
}

macro_rules! encode {
    ($s:literal) => {{
        const LEN: usize = utf16_len($s);
        const fn utf16_encode() -> [u16; LEN] {
            let mut buffer = [0; LEN];
            let mut idx = 0;
            // Obviously incorrect.
            while idx < LEN {
                buffer[idx] = $s.as_bytes()[idx] as u16;
                idx += 1;
            }
            buffer
        }
        const BUFFER: [u16; LEN] = utf16_encode();
        &BUFFER
    }}
}

const FOO: &[u16] = encode!("foo");

fn main() {
    println!("{:?}", FOO);
}

In the Windows world UTF-16 strings are not only encountered when interfacing with APIs, but also in a few on-disk structures (e.g. NT registry hives or NTFS filesystems). This complicates interoperability with Rust's UTF-8 world, especially in no_std environments.

My current approach when writing a parser for such an on-disk structure is as follows:

• I define my own Utf16ByteString type that just wraps a &[u8].
• All parser functions that output a string just return the byte slice encompassing that string in a Utf16ByteString. This has zero cost.
• For users with alloc or std, my Utf16ByteString provides a to_string function that uses char::decode_utf16(bytes.chunks_exact(2).map(|two_bytes| u16::from_le_bytes(two_bytes.try_into().unwrap()))) internally. Apart from the required allocations, this function also comes with decoding overhead.

Of course, I like to avoid using to_string, and a frequent case where this should be possible are (case-sensitive) comparisons. Currently, I have to create the comparison byte buffers by hand though, e.g. let hello = &[b'H', 0, b'e', 0, b'l', 0, b'l', 0, b'o', 0]. Latest const-utf16 is no help here, as its encode! only outputs a &[u16]. I could transmute my &[u8] to a &[u16], but that would be an unsafe hack and prone to endian problems.

Could const-utf16 therefore be extended to alternatively output a UTF-16LE &[u8] slice for such comparisons? Or am I missing a zero-cost alternative here?