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

Author: MartinNowak

.circleci/run.sh

@@ -87,7 +87,7 @@ setup_repos()
         git merge -m "Automatic merge" $current_branch
     fi
 
-    for proj in dmd druntime phobos ; do
+    for proj in dmd phobos ; do
         if [ $base_branch != master ] && [ $base_branch != stable ] &&
             ! git ls-remote --exit-code --heads https://github.com/dlang/$proj.git $base_branch > /dev/null; then
             # use master as fallback for other repos to test feature branches

articles/const-faq.dd

@@ -211,7 +211,7 @@ $(ITEM cpp-const, How does const differ in C++?)
 
 $(ITEM invariant-strings, Why are strings immutable?)
 
-        $(P $(LINK2 http://drdobbs.com/blogs/architecture-and-design/228700475, Immutable Strings)
+        $(P $(LINK2 https://www.digitalmars.com/articles/b01.html, Immutable Strings)
         )
 
 $(ITEM const-parameters, Why aren't function parameters const by default?)

articles/d-array-article.dd

@@ -28,7 +28,7 @@ arr[0] = 4; /* sets the first element of the array 'arr' to 4 */
 x = arr[1]; /* retrieves the second element of the array 'arr' into x */
 ------
 
-$(P Everything else (length, appending, allocation, destruction) is left up to library functions and assumption/documentation.  So what is so wrong with this concept?  One of the largest problems with C arrays is the ability to access any data via the pointer, even data that doesn't belong to the array.  You can even use negative indexes!  Not to mention that the array uses the exact same type as a pointer to a single item.  When you get a pointer as a parameter to a function, that could be an array, or it could be just a pointer to a single item.  Cue buffer overflow attacks.  You can read more about this in Walter Bright's article, $(LINK2 http://drdobbs.com/blogs/cpp/228701625, "C's biggest mistake")
+$(P Everything else (length, appending, allocation, destruction) is left up to library functions and assumption/documentation.  So what is so wrong with this concept?  One of the largest problems with C arrays is the ability to access any data via the pointer, even data that doesn't belong to the array.  You can even use negative indexes!  Not to mention that the array uses the exact same type as a pointer to a single item.  When you get a pointer as a parameter to a function, that could be an array, or it could be just a pointer to a single item.  Cue buffer overflow attacks.  You can read more about this in Walter Bright's article, $(LINK2 https://digitalmars.com/articles/C-biggest-mistake.html, "C's biggest mistake")
 )
 
 $(H2 $(LNAME2 introducing-slices, Introducing Slices))

articles/d-floating-point.dd

@@ -66,7 +66,7 @@ $(P Why does NaN exist? It serves a valuable role: it $(I eradicates undefined b
 
 $(P Subnormals are necessary to prevent certain anomalies, and preserve important relationships such as: "x - y == 0 if and only if x == y".)
 
-$(P Since $(INFIN) can be produced by overflow, both +$(INFIN) and -$(INFIN) are required. Both +0 and -0 are required in order to preserve identities such as: if $(D x>0), then $(D 1/(1/x) > 0). In almost all other cases, however, there is no difference between +0 and -0.)
+$(P Since $(INFIN) can be produced by overflow, both +$(INFIN) and -$(INFIN) are required. Both +0 and -0 are required in order to ensure $(D x) and $(D 1/(1/x)) always have the same sign bit. In almost all other cases, however, there is no difference between +0 and -0.)
 
 $(P It's worth noting that these $(SINGLEQUOTE special values) are usually not very efficient. On x86 machines, for example, a multiplication involving a NaN, an infinity, or a subnormal can be twenty to fifty times slower than an operation on normal numbers. If your numerical code is unexpectedly slow, it's possible that you are inadvertently creating many of these special values. Enabling floating-point exception trapping, described later, is a quick way to confirm this.)
 

book/build.d

@@ -16,13 +16,18 @@ void compileToPath(string compileThis, string outputPath, string extraFiles, boo
     if(outputPath.indexOf("cozum") == -1)
     {
         //We need to build a little .ddoc file to set the right predefined build macros - these are context dependant.
-        
+
         const cozumHtml = outputPath.baseName.replace(".html", ".cozum.html");
         contextMacros["COZUM_HTML"] = cozumHtml;
         //exit(0);
     }
     auto macroOut = File("contextMacros.ddoc", "w");
-    
+    scope(exit)
+    {
+        import std.file : remove; // conflicts with `core.stdc.stdio.remove` otherwise
+        remove("contextMacros.ddoc");
+    }
+
     foreach(key, value; contextMacros)
     {
         macroOut.writefln!"%s = %s"(key, value);
@@ -33,10 +38,10 @@ void compileToPath(string compileThis, string outputPath, string extraFiles, boo
     if(loud)
         writefln!"%s:%s |> %s"(compileThis, outputPath, compileString);
     const res = executeShell(compileString);
-    
+
     if(res.status != 0) {
         write(res.output);
-        
+
         exit(0);
     }
 }

book/contextMacros.ddoc

@@ -509,7 +509,7 @@ Alignment is needed for CPU performance or requirements, because accessing misal
 $(H6 $(IX .alignof) The $(C .alignof) property)
 
 $(P
-$(IX classInstanceAlignment) The $(C .alignof) property of a type is its default alignment value. For classes, $(C .alignof) is the alignment of the class variable, not the class object. The alignment of a class object is obtained by $(C std.traits.classInstanceAlignment).
+$(IX classInstanceAlignment) The $(C .alignof) property of a type is its default alignment value. For classes, $(C .alignof) is the alignment of the class variable, not the class object. The alignment of a class object is obtained by $(C __traits(classInstanceAlignment)).
 )
 
 $(P
@@ -549,7 +549,7 @@ void main() {
     foreach (Type; Types) {
         static if (is (Type == class)) {
             size_t size = __traits(classInstanceSize, Type);
-            size_t alignment = $(HILITE classInstanceAlignment!Type);
+            size_t alignment = $(HILITE __traits(classInstanceAlignment, Type));
 
         } else {
             size_t size = Type.sizeof;
@@ -636,8 +636,7 @@ $(CODE_NAME nextAlignedAddress)T * nextAlignedAddress(T)(T * candidateAddr) {
     import std.traits;
 
     static if (is (T == class)) {
-        const alignment = classInstanceAlignment!T;
-
+        const alignment = __traits(classInstanceAlignment, T);
     } else {
         const alignment = T.alignof;
     }
@@ -1314,7 +1313,7 @@ $(LI $(C GC.calloc) and other functions reserve memory, $(C GC.realloc) extends
 
 $(LI It is possible to mark the allocated memory by attributes like $(C GC.BlkAttr.NO_SCAN), $(C GC.BlkAttr.NO_INTERIOR), etc.)
 
-$(LI The $(C .alignof) property is the default memory alignment of a type. Alignment must be obtained by $(C classInstanceAlignment) for class $(I objects).)
+$(LI The $(C .alignof) property is the default memory alignment of a type. Alignment must be obtained by $(C __traits(classInstanceAlignment)) for class $(I objects).)
 
 $(LI The $(C .offsetof) property is the number of bytes a member is from the beginning of the object that it is a part of.)
 

book/d.en/memory.d

@@ -355,7 +355,7 @@ use exceptions, including `@nogc` and BetterC code.
 
 $(P
 For more information, see
-$(LINK https://github.com/dlang/DIPs/blob/master/DIPs/accepted/DIP1038.md, DIP 1038).
+$(LINK2 https://github.com/dlang/DIPs/blob/master/DIPs/accepted/DIP1038.md, DIP 1038).
 )
 )
 

changelog/2.100.0.dd

@@ -3,29 +3,25 @@ Ddoc
 $(D_S $(TITLE),
 
 $(UL
-    $(LI New release are published every $(I two) months, on the first day of every uneven month.)
+    $(LI New release are published every $(I two) months, on the first day of every even month.)
     $(LI Two weeks before a new release `master` is merged into `stable` and a first beta is released.)
     $(LI Point releases are published unscheduled when important issues or regressions get fixed.)
 )
 
-$(P The release schedule for 2021 is as follows:)
+$(P The release schedule for 2022 is as follows:)
 
     $(DIVC release-schedule,
         $(TABLE
-            $(BETA_RELEASE 2020-12-15, 2.095.0)
-            $(MINOR_RELEASE 2021-01-01, 2.095.0)
-            $(BETA_RELEASE 2021-02-15, 2.096.0)
-            $(MINOR_RELEASE 2021-03-01, 2.096.0)
-            $(BETA_RELEASE 2021-04-15, 2.097.0)
-            $(MINOR_RELEASE 2021-05-01, 2.097.0)
-            $(BETA_RELEASE 2021-06-15, 2.098.0)
-            $(MINOR_RELEASE 2021-07-01, 2.098.0)
-            $(BETA_RELEASE 2021-08-15, 2.099.0)
-            $(MINOR_RELEASE 2021-09-01, 2.099.0)
-            $(BETA_RELEASE 2021-10-15, 2.100.0)
-            $(MINOR_RELEASE 2021-11-01, 2.100.0)
-            $(BETA_RELEASE 2021-12-15, 2.101.0)
-            $(MINOR_RELEASE 2022-01-01, 2.101.0)
+            $(BETA_RELEASE 2022-02-15, 2.099.0)
+            $(BETA_RELEASE 2022-03-01, 2.099.0)
+            $(BETA_RELEASE 2022-04-15, 2.100.0)
+            $(MINOR_RELEASE 2022-05-01, 2.100.0)
+            $(BETA_RELEASE 2022-07-15, 2.101.0)
+            $(MINOR_RELEASE 2022-08-01, 2.101.0)
+            $(BETA_RELEASE 2022-09-15, 2.102.0)
+            $(MINOR_RELEASE 2022-10-01, 2.102.0)
+            $(BETA_RELEASE 2022-11-15, 2.103.0)
+            $(MINOR_RELEASE 2022-12-01, 2.103.0)
         )
     )
 )

changelog/release-schedule.dd

@@ -77,8 +77,8 @@ performs these steps automatically.
 
 $(CONSOLE
 C:\Documents and Settings\Your Name>cd \
-C:\>unzip dmd.zip
-C:\>unzip dmc.zip
+C:\\>unzip dmd.zip
+C:\\>unzip dmc.zip
 )
     )
     $(LINUX