Alexandrescus last review - deleted template attributes and added a test

that would not have passed with them.

Author: dukc

std/array.d

@@ -4002,7 +4002,7 @@ Params:
 
 Returns: A static array constructed from `a`.
 +/
-pragma(inline, true) T[n] staticArray(T, size_t n)(auto ref T[n] a) nothrow @safe pure @nogc
+pragma(inline, true) T[n] staticArray(T, size_t n)(auto ref T[n] a)
 {
     return a;
 }
@@ -4015,7 +4015,7 @@ nothrow pure @safe unittest
     assert(a == [0, 1]);
 }
 
-pragma(inline, true) U[n] staticArray(U, T, size_t n)(auto ref T[n] a) nothrow @safe pure @nogc
+pragma(inline, true) U[n] staticArray(U, T, size_t n)(auto ref T[n] a)
 if (!is(T == U) && is(T : U))
 {
     return a[].staticArray!(U[n]);
@@ -4056,41 +4056,40 @@ nothrow pure @safe unittest
 }
 
 /// ditto
-auto staticArray(size_t n, T)(T a)
+auto staticArray(size_t n, T)(scope T a)
 if (isInputRange!T)
 {
     alias U = ElementType!T;
     return staticArray!(U[n], U, n)(a);
 }
 
 /// ditto
-auto staticArray(size_t n, T)(T a, out size_t rangeLength)
+auto staticArray(size_t n, T)(scope T a, out size_t rangeLength)
 if (isInputRange!T)
 {
     alias U = ElementType!T;
     return staticArray!(U[n], U, n)(a, rangeLength);
 }
 
 /// ditto
-auto staticArray(Un : U[n], U, size_t n, T)(T a) nothrow
-if ((isInputRange!T) && is(ElementType!T : U))
+auto staticArray(Un : U[n], U, size_t n, T)(scope T a)
+if (isInputRange!T && is(ElementType!T : U))
 {
     size_t extraStackSpace;
     return staticArray!(Un, U, n)(a, extraStackSpace);
 }
 
 /// ditto
-auto staticArray(Un : U[n], U, size_t n, T)(T a, out size_t rangeLength)
-if ((isInputRange!T) && is(ElementType!T : U))
+auto staticArray(Un : U[n], U, size_t n, T)(scope T a, out size_t rangeLength)
+if (isInputRange!T && is(ElementType!T : U))
 {
     import std.algorithm.mutation : uninitializedFill;
     import std.range : take;
     import std.conv : emplaceRef;
 
-    size_t i;
-
     if (__ctfe)
     {
+        size_t i;
         // Compile-time version to avoid unchecked memory access.
         Unqual!U[n] ret;
         for (auto iter = a.take(n); !iter.empty; iter.popFront())
@@ -4109,20 +4108,20 @@ if ((isInputRange!T) && is(ElementType!T : U))
         return theArray;
     }());
 
-    static if (hasElaborateDestructor!U) scope (failure)
+    size_t i;
+    if (true)
     {
-        //without this, a destructor would be called on uninitialized memory
-        foreach (j; i .. n) emplace(result[j]);
-    }
+        // ret was void-initialized so let's initialize the unfilled part manually.
+        // also prevents destructors to be called on uninitialized memory if
+        // an exception is thrown
+        scope (exit) ret[i .. $].uninitializedFill(U.init);
 
-    for (auto iter = a.take(n); !iter.empty; iter.popFront())
-    {
-        emplaceRef!U(ret[i++], iter.front);
+        for (auto iter = a.take(n); !iter.empty; iter.popFront())
+        {
+            emplaceRef!U(ret[i++], iter.front);
+        }
     }
 
-    // ret was void-initialized so let's initialize the unfilled part manually.
-    ret[i .. $].uninitializedFill(U.init);
-
     rangeLength = i;
     return (() @trusted => cast(U[n]) ret)();
 }
@@ -4141,9 +4140,50 @@ nothrow pure @safe unittest
     assert(b == [0, 1, 2, 0]);
 }
 
-nothrow pure @safe unittest
+// Tests that code compiles when there is an elaborate destructor and exceptions
+// are thrown. Unfortunately can't test that memory is initialized
+// before having a destructor called on it.
+// @system required because of issue 18872.
+@system nothrow unittest
 {
+    // exists only to allow doing something in the destructor. Not tested
+    // at the end because value appears to depend on implementation of the.
+    // function.
+    static int preventersDestroyed = 0;
 
+    static struct CopyPreventer
+    {
+        bool on = false;
+        this(this)
+        {
+            if (on) throw new Exception("Thou shalt not copy past me!");
+        }
+
+        ~this()
+        {
+            preventersDestroyed++;
+        }
+    }
+    auto normalArray =
+    [
+        CopyPreventer(false),
+        CopyPreventer(false),
+        CopyPreventer(true),
+        CopyPreventer(false),
+        CopyPreventer(true),
+    ];
+
+    try
+    {
+        auto staticArray = normalArray.staticArray!5;
+        assert(false);
+    }
+    catch (Exception e){}
+}
+
+
+nothrow pure @safe unittest
+{
     auto a = [1, 2].staticArray;
     assert(is(typeof(a) == int[2]) && a == [1, 2]);
 
@@ -4168,16 +4208,14 @@ nothrow pure @system unittest
 auto staticArray(alias a)()
 if (isInputRange!(typeof(a)))
 {
-    // NOTE: without `cast`, getting error:
-    // cannot deduce function from argument types !(length)(Result)
-    return .staticArray!(cast(size_t) a.length)(a);
+    return .staticArray!(size_t(a.length))(a);
 }
 
 /// ditto
 auto staticArray(U, alias a)()
 if (isInputRange!(typeof(a)))
 {
-    return .staticArray!(U[cast(size_t) a.length])(a);
+    return .staticArray!(U[size_t(a.length)])(a);
 }
 
 /// static array from CT range