Fix code bloat regressions wrt. core.internal.lifetime.emplaceInitializer

This partially reverts #2883. The problem is that for every template
instantiation, i.e., emplaced type, 2 new structs are generated, each of
which comes with its TypeInfo etc. And that includes all types, incl.
primitive types and zero-initialized ones.

So as before that PR, try to handle the trivial cases first, and only
use a (simplified) union version if that's not possible. [The union
version in #2883 is probably an improvement over the previously used
static constant.]

And as Suleyman mentioned that it's code copied from object.d, I went
the other way and use emplaceInitializer in object.d to get rid of
needless code duplication.

Author: kinke

src/core/internal/lifetime.d

@@ -84,23 +84,44 @@ if (is(UT == core.internal.traits.Unqual!UT))
     emplaceRef!(UT, UT)(chunk, forward!args);
 }
 
-//emplace helper functions
-private nothrow pure @trusted
+/+
+Emplaces T.init.
+In contrast to `emplaceRef(chunk)`, there are no checks for disabled default
+constructors etc.
++/
+nothrow pure @trusted
 void emplaceInitializer(T)(scope ref T chunk)
 {
-    // Emplace T.init.
-    // Previously, an immutable static and memcpy were used to hold an initializer.
-    // With improved unions, this is no longer needed.
-    union UntypedInit
+    import core.internal.traits : hasElaborateAssign;
+
+    static if (!hasElaborateAssign!T && __traits(compiles, chunk = T.init))
     {
-        T dummy;
+        chunk = T.init;
     }
-    static struct UntypedStorage
+    else
     {
-        align(T.alignof) void[T.sizeof] dummy;
-    }
+        static if (__traits(isZeroInit, T))
+        {
+            static if (is(T U == shared U))
+                alias Unshared = U;
+            else
+                alias Unshared = T;
 
-    () @trusted {
-        *cast(UntypedStorage*) &chunk = cast(UntypedStorage) UntypedInit.init;
-    } ();
+            import core.stdc.string : memset;
+            memset(cast(Unshared*) &chunk, 0, T.sizeof);
+        }
+        else
+        {
+            // emplace T.init (an rvalue) without extra variable (and according destruction)
+            alias RawBytes = void[T.sizeof];
+
+            static union U
+            {
+                T dummy = T.init; // U.init corresponds to T.init
+                RawBytes data;
+            }
+
+            *cast(RawBytes*) &chunk = U.init.data;
+        }
+    }
 }

src/object.d

@@ -3394,21 +3394,8 @@ void destroy(bool initialize = true, T)(ref T obj) if (is(T == struct))
 
     static if (initialize)
     {
-        // We need to re-initialize `obj`.  Previously, an immutable static
-        // and memcpy were used to hold an initializer. With improved unions, this is no longer
-        // needed.
-        union UntypedInit
-        {
-            T dummy;
-        }
-        static struct UntypedStorage
-        {
-            align(T.alignof) void[T.sizeof] dummy;
-        }
-
-        () @trusted {
-            *cast(UntypedStorage*) &obj = cast(UntypedStorage) UntypedInit.init;
-        } ();
+        import core.internal.lifetime : emplaceInitializer;
+        emplaceInitializer(obj); // emplace T.init
     }
 }