Fixing "toStringz"

[monarch_dodra]

I'm looking for advice on fixing "toStringz". The current 
implementation that accepts "immutable(char)[]" is:

immutable(char)* toStringz(string s) pure nothrow
{
     if (s.empty) return "".ptr;
     /* Peek past end of s[], if it's 0, no conversion necessary.
      * Note that the compiler will put a 0 past the end of static
      * strings, and the storage allocator will put a 0 past the 
end
      * of newly allocated char[]'s.
      */
     immutable p = s.ptr + s.length;
     // Is p dereferenceable? A simple test: if the p points to an
     // address multiple of 4, then conservatively assume the 
pointer
     // might be pointing to a new block of memory, which might be
     // unreadable. Otherwise, it's definitely pointing to valid
     // memory.
     if ((cast(size_t) p & 3) && *p == 0)
         return s.ptr;
     return toStringz(cast(const char[]) s);
}

The explanation is clear enough (I think). The problem with this 
approach is that nothing guarantees that, say, the current string 
is allocator allocated from a very large buffer, and the "past 
the end" \0 is not actually immutable (and will be changed when 
allocator allocates a new string).

Long story short, the function operates under wrong assumptions.

Since "being correct" > "performance", this needs to be 
corrected. I'm looking for ideas though on being able to detect 
if a string *is* a manifest constant string?

The solution doesn't necessarily have to work on all platforms, 
but if we can get something to work on some platforms, that would 
already be good.

ideas?