Merge remote-tracking branch 'upstream/master' into stable

.dscanner.ini

@@ -512,3 +512,5 @@ trust_too_much="-std.regex,-std.stdio,-std.uni,-std.internal.cstring"
 ; Checks for if statements whose 'then' block is the same as the 'else' block
 ; Temporarily disable until https://github.com/dlang-community/D-Scanner/issues/593 is fixed
 if_else_same_check="-std.typecons"
+; Disable checks for generated unicode tables
+long_line_check="-std.internal.unicode_decomp,-std.internal.unicode_comp,-std.internal.unicode_grapheme,-std.internal.unicode_norm,-std.internal.unicode_tables"

CODEOWNERS

@@ -14,6 +14,7 @@
 circleci.sh @CyberShadow @MartinNowak @wilzbach
 etc/c/* @CyberShadow
 posix.mak @CyberShadow @MartinNowak @wilzbach
+# tools/unicode_table_generator.d
 std/* @andralex
 std/algorithm/* @andralex @JackStouffer @wilzbach @PetarKirov
 std/array.d @JackStouffer @wilzbach @PetarKirov

changelog/log_float_double_implementations.dd

@@ -0,0 +1,15 @@
+Single- and double-precision implementations for log function families
+
+New `float` and `double` overloads of $(REF log, std, math, exponential),
+$(REF log10, std, math, exponential), $(REF log1p, std, math, exponential),
+ $(REF log2, std, math, exponential), and $(REF logb, std, math, exponential)
+have been added to Phobos with proper 'software' implementations in the
+corresponding precision. Furthermore, $(REF logb, std, math, exponential) is
+now `pure`.
+
+While this may result in a slowdown in some cases for DMD, the overall speed-up
+factor for GDC and LDC is over 3x, for both `double` and `float`.
+
+This also implies less precise results, especially in single-precision,
+so if your code depended on more accurate results via 80-bit intermediate
+precision, you'll have to cast the argument(s) explicitly now.

changelog/unicode_properties_c.dd

@@ -0,0 +1,24 @@
+The Unicode property "C" aka "Other" has had the wrong properties associated with it.
+
+If you use `unicode.c` or `unicode.Other` (case insensitive) from `std.uni`, you should mitigate or fix your codebase.
+
+This change makes it match the [Unicode Techical Report #44](https://www.unicode.org/reports/tr44/). Unfortunately if you are already using it with its previous wrong values, this will break your code, below is a function which reflects the original values that you can use to mitigate against any breakage.
+
+---
+@property auto loadPropertyOriginal(string name)() pure
+{
+    import std.uni : unicode;
+
+    static if (name == "C" || name == "c" || name == "other" || name == "Other")
+    {
+        auto target = unicode.Co;
+        target |= unicode.Lo;
+        target |= unicode.No;
+        target |= unicode.So;
+        target |= unicode.Po;
+        return target;
+    }
+    else
+        return unicode.opDispatch!name;
+}
+---

changelog/unicode_table_generator.dd

@@ -0,0 +1,5 @@
+Unicode table generator is now in Phobos, tables are updated to version 15.
+
+It is likely that this change will result in breakage in code and program usage.
+This is due to a number of factors, the tables being updated so significantly and the table generator not having all its changes commited throughout the years.
+

changelog/unique-struct-dtor.dd

@@ -0,0 +1,28 @@
+`std.typecons.Unique` now calls `destroy` on struct types
+
+When Unique goes out of scope, any destructor will now be called.
+Previously the destructor was not called then.
+
+$(RUNNABLE_EXAMPLE
+---
+static int i;
+
+struct S
+{
+    ~this()
+    {
+        i++;
+    }
+}
+{
+    Unique!S u = new S;
+    // S.~this now called here
+}
+assert(i == 1);
+---
+)
+
+$(B Note:) Above, the struct destructor will also be called by the GC just
+before the memory for `new S` is reclaimed. Take care that any struct
+destructor used will handle being called again on the struct `.init`
+value.

etc/c/zlib/osx.mak

@@ -3,6 +3,10 @@
 CC=gcc
 LD=link
 CFLAGS=-I. -O -g -DHAVE_UNISTD_H -DHAVE_STDARG_H
+ifeq (64,$(MODEL))
+	CFLAGS+=--target=x86_64-darwin-apple  # ARM cpu is not supported by dmd
+endif
+
 LDFLAGS=
 O=.o
 

posix.mak

@@ -135,6 +135,12 @@ else
 		endif
 	endif
 endif
+ifeq (osx,$(OS))
+	ifeq (64,$(MODEL))
+		CFLAGS+=--target=x86_64-darwin-apple  # ARM cpu is not supported by dmd
+	endif
+endif
+
 
 # Set DFLAGS
 DFLAGS=

std/algorithm/iteration.d

@@ -7737,8 +7737,9 @@ if (isInputRange!R &&
 
 // uniq
 /**
-Lazily iterates unique consecutive elements of the given range (functionality
-akin to the $(HTTP wikipedia.org/wiki/_Uniq, _uniq) system
+Lazily iterates unique consecutive elements of the given range, which is
+assumed to be sorted (functionality akin to the
+$(HTTP wikipedia.org/wiki/_Uniq, _uniq) system
 utility). Equivalence of elements is assessed by using the predicate
 `pred`, by default `"a == b"`. The predicate is passed to
 $(REF binaryFun, std,functional), and can either accept a string, or any callable

std/algorithm/mutation.d

@@ -573,7 +573,7 @@ $(LINK2 http://en.cppreference.com/w/cpp/algorithm/copy_backward, STL's `copy_ba
 Assigns `value` to each element of input range `range`.
 
 Alternatively, instead of using a single `value` to fill the `range`,
-a `filter` $(REF_ALTTEXT forward range, isForwardRange, std,range,primitives)
+a `filler` $(REF_ALTTEXT forward range, isForwardRange, std,range,primitives)
 can be provided. The length of `filler` and `range` do not need to match, but
 `filler` must not be empty.
 
@@ -1943,6 +1943,7 @@ if (Offset.length >= 1 && allSatisfy!(isValidIntegralTuple, Offset))
     return removeImpl!s(range, offset);
 }
 
+/// ditto
 deprecated("Use of non-integral tuples is deprecated. Use remove(tuple(start, end).")
 Range remove
 (SwapStrategy s = SwapStrategy.stable, Range, Offset ...)

std/algorithm/sorting.d

@@ -3946,7 +3946,7 @@ if (isRandomAccessRange!(Range1) && hasLength!Range1 &&
     {
         foreach (T2; ReferenceRanges)
         {
-            import std.array;
+            import std.array : array;
 
             T1 A;
             T2 B;

std/array.d

@@ -169,8 +169,8 @@ if (isIterable!Range && !isAutodecodableString!Range && !isInfinite!Range)
 }
 
 /// ditto
-ForeachType!(PointerTarget!Range)[] array(Range)(Range r)
-if (isPointer!Range && isIterable!(PointerTarget!Range) && !isAutodecodableString!Range && !isInfinite!Range)
+ForeachType!(typeof((*Range).init))[] array(Range)(Range r)
+if (is(Range : U*, U) && isIterable!U && !isAutodecodableString!Range && !isInfinite!Range)
 {
     return array(*r);
 }
@@ -586,7 +586,7 @@ if (isInputRange!Range)
     static assert(isMutable!ValueType, "assocArray: value type must be mutable");
 
     ValueType[KeyType] aa;
-    foreach (t; r)
+    foreach (ref t; r)
         aa[t[0]] = t[1];
     return aa;
 }
@@ -3416,7 +3416,8 @@ do
 Implements an output range that appends data to an array. This is
 recommended over $(D array ~= data) when appending many elements because it is more
 efficient. `Appender` maintains its own array metadata locally, so it can avoid
-global locking for each append where $(LREF capacity) is non-zero.
+the $(DDSUBLINK spec/arrays, capacity-reserve, performance hit of looking up slice `capacity`)
+for each append.
 
 Params:
     A = the array type to simulate.
@@ -3587,7 +3588,7 @@ if (isDynamicArray!A)
     private template canPutItem(U)
     {
         enum bool canPutItem =
-            isImplicitlyConvertible!(Unqual!U, Unqual!T) ||
+            is(Unqual!U : Unqual!T) ||
             isSomeChar!T && isSomeChar!U;
     }
     private template canPutConstRange(Range)
@@ -4676,6 +4677,7 @@ nothrow pure @safe @nogc unittest
     assert(a == [0, 1]);
 }
 
+/// ditto
 pragma(inline, true) U[n] staticArray(U, T, size_t n)(auto ref T[n] a)
 if (!is(T == U) && is(T : U))
 {

std/ascii.d

@@ -187,7 +187,8 @@ else
   +/
 bool isAlphaNum(dchar c) @safe pure nothrow @nogc
 {
-    return c <= 'z' && c >= '0' && (c <= '9' || c >= 'a' || (c >= 'A' && c <= 'Z'));
+    const hc = c | 0x20;
+    return ('0' <= c && c <= '9') || ('a' <= hc && hc <= 'z');
 }
 
 ///
@@ -377,7 +378,8 @@ bool isOctalDigit(dchar c) @safe pure nothrow @nogc
   +/
 bool isHexDigit(dchar c) @safe pure nothrow @nogc
 {
-    return c <= 'f' && c >= '0' && (c <= '9' || c >= 'a' || (c >= 'A' && c <= 'F'));
+    const hc = c | 0x20;
+    return ('0' <= c && c <= '9') || ('a' <= hc && hc <= 'f');
 }
 
 ///

std/base64.d

@@ -639,7 +639,7 @@ template Base64Impl(char Map62th, char Map63th, char Padding = '=')
          */
         void popFront()
         {
-            enforce(!empty, new Base64Exception("Cannot call popFront on Encoder with no data remaining"));
+            assert(!empty, "Cannot call popFront on Encoder with no data remaining");
 
             range_.popFront();
 
@@ -757,7 +757,7 @@ template Base64Impl(char Map62th, char Map63th, char Padding = '=')
          */
         void popFront()
         {
-            enforce(!empty, new Base64Exception("Cannot call popFront on Encoder with no data remaining"));
+            assert(!empty, "Cannot call popFront on Encoder with no data remaining");
 
             static if (Padding != NoPadding)
                 if (padding)
@@ -1414,7 +1414,7 @@ template Base64Impl(char Map62th, char Map63th, char Padding = '=')
          */
         void popFront()
         {
-            enforce(!empty, new Base64Exception("Cannot call popFront on Decoder with no data remaining."));
+            assert(!empty, "Cannot call popFront on Decoder with no data remaining.");
 
             range_.popFront();