merge stable

VERSION

@@ -1 +1 @@
-v2.112.0
+v2.112.1

compiler/src/dmd/common/charactertables.d

@@ -185,6 +185,13 @@ bool c_isalnum(const int c)
         ( c >= 'A' && c <= 'Z'));
 }
 
+///
+bool isAlphaASCII(const dchar c)
+{
+    return (( c >= 'a' && c <= 'z') ||
+        ( c >= 'A' && c <= 'Z'));
+}
+
 extern(D) private:
 
 // originally from dmd.root.utf

compiler/src/dmd/expressionsem.d

@@ -6992,8 +6992,11 @@ private extern (C++) final class ExpressionSemanticVisitor : Visitor
 
             if (!global.params.useGC && sc.needsCodegen())
             {
-                error(exp.loc, "expression `%s` allocates with the GC and cannot be used with switch `-%s`", exp.toErrMsg(), SwitchVariadic.ptr);
-                return setError();
+                if (sc.func)
+                {
+                    sc.func.skipCodegen = true; // same net result as calling checkGC
+                    goto LskipNewArrayLowering; // not checked in sc.needsCodegen() !?
+                }
             }
 
             if (!sc.needsCodegen())
@@ -8516,7 +8519,7 @@ private extern (C++) final class ExpressionSemanticVisitor : Visitor
             {
                 exp.type = tf.next;
                 auto casted_exp = exp.castTo(sc, t);
-                if (auto cex = casted_exp.isCastExp())
+                if (auto cex = lastComma(casted_exp).isCastExp())
                 {
                     lowerCastExp(cex, sc);
                 }
@@ -10933,7 +10936,7 @@ private extern (C++) final class ExpressionSemanticVisitor : Visitor
             }
         }
 
-        if (auto cex = ex.isCastExp())
+        if (auto cex = lastComma(ex).isCastExp())
         {
             lowerCastExp(cex, sc);
         }
@@ -15079,12 +15082,14 @@ private extern (C++) final class ExpressionSemanticVisitor : Visitor
             return;
         }
 
-        // When array comparison is not lowered to `__equals`, `memcmp` is used, but
-        // GC checks occur before the expression is lowered to `memcmp` in e2ir.d.
-        // Thus, we will consider the literal arrays as on-stack arrays to avoid issues
-        // during GC checks.
+        // Remaining array comparisons are trivially memcmp-able.
+        // Allocate array-literal operands on the stack, since they don't
+        // escape during the comparison; enabling @nogc for these.
         if (isArrayComparison)
         {
+            exp.e1 = exp.e1.optimize(WANTvalue);
+            exp.e2 = exp.e2.optimize(WANTvalue);
+
             if (auto ale1 = exp.e1.isArrayLiteralExp())
             {
                 ale1.onstack = true;
@@ -19745,12 +19750,12 @@ private Expression buildAAIndexRValueX(Type t, Expression eaa, Expression ekey,
     auto call = new CallExp(loc, func, arguments);
     e0 = Expression.combine(e0, call);
 
-    if (arrayBoundsCheck(sc.func))
+    if (sc.func && arrayBoundsCheck(sc.func))
     {
         // __aaget = _d_aaGetRvalueX(aa, key), __aaget ? __aaget : onRangeError(__FILE__, __LINE__)
         auto ei = new ExpInitializer(loc, e0);
-        auto vartmp = Identifier.generateId("__aaget");
-        auto vardecl = new VarDeclaration(loc, null, vartmp, ei, STC.exptemp);
+        auto id = Identifier.generateId("__aaget");
+        auto vardecl = new VarDeclaration(loc, null, id, ei, STC.exptemp);
         auto declexp = new DeclarationExp(loc, vardecl);
 
         //Expression idrange = new IdentifierExp(loc, Identifier.idPool("_d_arraybounds"));
@@ -19760,9 +19765,9 @@ private Expression buildAAIndexRValueX(Type t, Expression eaa, Expression ekey,
         auto locargs = new Expressions(new FileInitExp(loc, EXP.file), new LineInitExp(loc));
         auto ex = new CallExp(loc, idrange, locargs);
 
-        auto idvar1 = new IdentifierExp(loc, vartmp);
-        auto idvar2 = new IdentifierExp(loc, vartmp);
-        auto cond = new CondExp(loc, idvar1, idvar2, ex);
+        auto ve1 = new VarExp(loc, vardecl);
+        auto ve2 = new VarExp(loc, vardecl);
+        auto cond = new CondExp(loc, ve1, ve2, ex);
         auto comma = new CommaExp(loc, declexp, cond);
         return comma;
     }
@@ -19795,6 +19800,26 @@ Expression revertIndexAssignToRvalues(IndexExp ie, Scope* sc)
     return lowerAAIndexRead(ie, sc);
 }
 
+// Ditto, but traverses DotVarExp from `alias this` rewrites.
+private Expression revertModifiableAAIndexReads(Expression e, Scope* sc)
+{
+    // Recurse through dot-accesses (alias this produces DotVarExp on an inner IndexExp)
+    if (auto dve = e.isDotVarExp())
+    {
+        dve.e1 = revertModifiableAAIndexReads(dve.e1, sc);
+        return e;
+    }
+    if (auto ie = e.isIndexExp())
+    {
+        // Recurse first to handle deeper nesting
+        ie.e1 = revertModifiableAAIndexReads(ie.e1, sc);
+        // Lower a modifiable AA IndexExp to an rvalue read
+        if (ie.modifiable && ie.e1.type.isTypeAArray())
+            return lowerAAIndexRead(ie, sc);
+    }
+    return e;
+}
+
 // helper for rewriteAAIndexAssign
 private Expression implicitConvertToStruct(Expression ev, StructDeclaration sd, Scope* sc)
 {
@@ -19845,6 +19870,7 @@ private Expression rewriteAAIndexAssign(BinExp exp, Scope* sc, ref Type[2] alias
     // find the AA of multi dimensional access
     for (auto ieaa = ie.e1.isIndexExp(); ieaa && ieaa.e1.type.isTypeAArray(); ieaa = ieaa.e1.isIndexExp())
         eaa = ieaa.e1;
+    eaa = revertModifiableAAIndexReads(eaa, sc);
     eaa = extractSideEffect(sc, "__aatmp", e0, eaa);
     // collect all keys of multi dimensional access
     Expressions ekeys;
@@ -19883,7 +19909,7 @@ private Expression rewriteAAIndexAssign(BinExp exp, Scope* sc, ref Type[2] alias
         auto tiargs = new Objects(taa.index, taa.next);
         func = new DotTemplateInstanceExp(loc, func, hook, tiargs);
 
-        auto arguments = new Expressions(eaa, ekeys[i-1], new IdentifierExp(loc, idfound));
+        auto arguments = new Expressions(eaa, ekeys[i-1], new VarExp(loc, varfound));
         eaa = new CallExp(loc, func, arguments);
         if (i > 1)
         {
@@ -19940,7 +19966,7 @@ private Expression rewriteAAIndexAssign(BinExp exp, Scope* sc, ref Type[2] alias
                 ex = new CastExp(ex.loc, ex, Type.tvoid);
                 ey = new CastExp(ey.loc, ey, Type.tvoid);
             }
-            Expression condfound = new IdentifierExp(loc, idfound);
+            Expression condfound = new VarExp(loc, varfound);
             ex = new CondExp(loc, condfound, ex, ey);
             ex = Expression.combine(e0, ex);
             ex.isCommaExp().originalExp = exp;

compiler/src/dmd/frontend.h

@@ -7979,6 +7979,8 @@ extern bool c_isxdigit(const int32_t c);
 
 extern bool c_isalnum(const int32_t c);
 
+extern bool isAlphaASCII(const char32_t c);
+
 extern void error(Loc loc, const char* format, ...);
 
 extern void error(const char* filename, uint32_t linnum, uint32_t charnum, const char* format, ...);

compiler/src/dmd/glue/toobj.d

@@ -1348,17 +1348,13 @@ private void ClassInfoToDt(ref DtBuilder dtb, ClassDeclaration cd, Symbol* sinit
 Louter:
     for (ClassDeclaration pc = cd; pc; pc = pc.baseClass)
     {
-        if (pc.members)
+        foreach (vd; pc.fields)
         {
-            for (size_t i = 0; i < pc.members.length; i++)
+            //printf("vd = %s %s\n", vd.kind(), vd.toChars());
+            if (vd.hasPointers())
             {
-                Dsymbol sm = (*pc.members)[i];
-                //printf("sm = %s %s\n", sm.kind(), sm.toChars());
-                if (sm.hasPointers())
-                {
-                    flags &= ~ClassFlags.noPointers;  // not no-how, not no-way
-                    break Louter;
-                }
+                flags &= ~ClassFlags.noPointers;  // not no-how, not no-way
+                break Louter;
             }
         }
     }

compiler/src/dmd/initsem.d

@@ -1468,6 +1468,22 @@ Expression initializerToExpression(Initializer init, Type itype = null, const bo
             }
         }
 
+        // enforce the element type only if the dimensions match, otherwise the value
+        // might be used as an initializer for the whole array at another dimension
+        Type isTypeArray(Type tn)
+        {
+            auto ty = tn ? tn.ty : Tnone;
+            return ty == Tarray || ty == Tsarray || ty == Taarray || ty == Tvector ? tn : null;
+        }
+        Type tnext = isTypeArray(itype);
+        auto initn = init;
+        while (tnext && initn)
+        {
+            tnext = isTypeArray(tnext.nextOf());
+            initn = initn.value.length ? initn.value[0].isArrayInitializer() : null;
+        }
+        Type telem = itype && !tnext && !initn ? itype.nextOf() : null;
+
         auto elements = new Expressions(edim);
         elements.zero();
         size_t j = 0;
@@ -1478,7 +1494,7 @@ Expression initializerToExpression(Initializer init, Type itype = null, const bo
             assert(j < edim);
             if (Initializer iz = init.value[i])
             {
-                if (Expression ex = iz.initializerToExpression(null, isCfile))
+                if (Expression ex = iz.initializerToExpression(telem, isCfile))
                 {
                     (*elements)[j] = ex;
                     ++j;

compiler/src/dmd/lexer.d

@@ -62,7 +62,11 @@ struct CompileEnv
  */
 class Lexer
 {
-    private __gshared OutBuffer stringbuffer;
+    private __gshared
+    {
+        OutBuffer stringbuffer;
+        OutBuffer stringbuffersecondary; // functions that use stringbuffer can call scan that needs this.
+    }
 
     BaseLoc* baseLoc;       // Used to generate `scanloc`, which is just an index into this data structure
     Loc scanloc;            // for error messages
@@ -1431,7 +1435,7 @@ class Lexer
                     p++;
                     break;
                 default:
-                    if (isalpha(*p) || (p != idstart && isdigit(*p)))
+                    if (isAlphaASCII(*p) || (p != idstart && isdigit(*p)))
                         continue;
                     error(loc, "unterminated named entity &%.*s;", cast(int)(p - idstart + 1), idstart);
                     c = '?';
@@ -1766,7 +1770,7 @@ class Lexer
         uint blankrol = 0;
         uint startline = 0;
         p++;
-        stringbuffer.setsize(0);
+        stringbuffersecondary.setsize(0);
         while (1)
         {
             const s = p;
@@ -1785,7 +1789,7 @@ class Lexer
                 }
                 if (hereid)
                 {
-                    stringbuffer.writeUTF8(c);
+                    stringbuffersecondary.writeUTF8(c);
                     continue;
                 }
                 break;
@@ -1825,7 +1829,7 @@ class Lexer
                     delimright = ']';
                 else if (c == '<')
                     delimright = '>';
-                else if (isalpha(c) || c == '_' || (c >= 0x80 && charLookup.isStart(c)))
+                else if (isAlphaASCII(c) || c == '_' || (c >= 0x80 && charLookup.isStart(c)))
                 {
                     // Start of identifier; must be a heredoc
                     Token tok;
@@ -1875,7 +1879,7 @@ class Lexer
                     goto Ldone;
 
                 // we're looking for a new identifier token
-                if (startline && (isalpha(c) || c == '_' || (c >= 0x80 && charLookup.isStart(c))) && hereid)
+                if (startline && (isAlphaASCII(c) || c == '_' || (c >= 0x80 && charLookup.isStart(c))) && hereid)
                 {
                     Token tok;
                     auto psave = p;
@@ -1890,7 +1894,7 @@ class Lexer
                     }
                     p = psave;
                 }
-                stringbuffer.writeUTF8(c);
+                stringbuffersecondary.writeUTF8(c);
                 startline = 0;
             }
         }
@@ -1903,7 +1907,7 @@ class Lexer
             error("delimited string must end in `\"`");
         else
             error(token.loc, "delimited string must end in `%c\"`", delimright);
-        result.setString(stringbuffer);
+        result.setString(stringbuffersecondary);
         stringPostfix(result);
     }
 
@@ -2404,7 +2408,7 @@ class Lexer
             case '.':
                 if (p[1] == '.')
                     goto Ldone; // if ".."
-                if (isalpha(p[1]) || p[1] == '_' || p[1] & 0x80)
+                if (isAlphaASCII(p[1]) || p[1] == '_' || p[1] & 0x80)
                 {
                     if (Ccompile && (p[1] == 'f' || p[1] == 'F' || p[1] == 'l' || p[1] == 'L'))
                         goto Lreal;  // if `0.f` or `0.L`
@@ -2477,7 +2481,7 @@ class Lexer
             case '.':
                 if (p[1] == '.')
                     goto Ldone; // if ".."
-                if (base <= 10 && n > 0 && (isalpha(p[1]) || p[1] == '_' || p[1] & 0x80))
+                if (base <= 10 && n > 0 && (isAlphaASCII(p[1]) || p[1] == '_' || p[1] & 0x80))
                 {
                     if (Ccompile && base == 10 &&
                         (p[1] == 'e' || p[1] == 'E' || p[1] == 'f' || p[1] == 'F' || p[1] == 'l' || p[1] == 'L'))

compiler/src/dmd/link.d

@@ -962,9 +962,13 @@ public int runPreprocessor(Loc loc, const(char)[] cpp, const(char)[] filename, c
     version (Windows)
     {
         // generate unique temporary file name for preprocessed output
-        const(char)* tmpname = tmpnam(null);
-        assert(tmpname);
-        const(char)[] ifilename = tmpname[0 .. strlen(tmpname) + 1];
+        char[MAX_PATH] tempDir = void;
+        char[MAX_PATH] tempFile = void;
+        if (GetTempPathA(MAX_PATH, tempDir.ptr) == 0)
+            return STATUS_FAILED;
+        if (GetTempFileNameA(tempDir.ptr, "dmd", 0, tempFile.ptr) == 0)
+            return STATUS_FAILED;
+        const(char)[] ifilename = tempFile[0 .. strlen(tempFile.ptr) + 1];
         ifilename = xarraydup(ifilename);
         const(char)[] output = ifilename;
 

compiler/test/compilable/imports/test22480b.d

@@ -0,0 +1,13 @@
+module immports.test22480b;
+
+auto parseAA()
+{
+	bool[string] aa;
+	aa["key"] = true;
+	assert("key" in aa);
+	assert(aa["key"]);
+	assert(aa.length == 1);
+	assert(aa == aa);
+	aa.rehash();
+	return true;
+}

compiler/test/compilable/test22480.d

@@ -0,0 +1,9 @@
+import imports.test22480b;
+
+@nogc nothrow:
+enum a = parseAA();
+
+extern(C) int main()
+{
+	return 0;
+}

compiler/test/compilable/test22501.d

@@ -0,0 +1,12 @@
+// https://github.com/dlang/dmd/issues/22501
+
+struct A {
+    ubyte[16] bytes;
+
+    enum something = A(cast(ubyte[16])[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]);
+
+    @nogc nothrow pure
+    bool isB() const {
+        return bytes[0..12] == something.bytes[0..12];
+    }
+}

compiler/test/compilable/test22543.d

@@ -0,0 +1,11 @@
+// https://github.com/dlang/dmd/issues/22543
+
+enum int[string] aa = [
+    "a": 42,
+];
+
+int i = aa["a"];
+
+void foo() {
+    static int j = aa["a"];
+}

compiler/test/compilable/test22544.d

@@ -0,0 +1,11 @@
+// https://github.com/dlang/dmd/issues/22544
+
+struct S {
+    int bar() { return 1; }
+}
+
+void foo(string key) {
+    int[string] aa;
+    with (S())
+        aa[key] = bar();
+}

compiler/test/compilable/test24295.d

@@ -0,0 +1,11 @@
+// REQUIRED_ARGS: -betterC
+
+int f()
+{
+   int[] overlaps = new int[1];
+   overlaps[0] = 3;
+   return overlaps[0];
+}
+
+enum res_f = f();
+static assert(res_f == 3);