Merge stable

.github/workflows/main.yml

@@ -32,11 +32,12 @@ jobs:
             os: ubuntu-22.04
             model: 32
             host_dmd: dmd
-          - job_name: Ubuntu 22.04 x86, DMD (coverage)
-            os: ubuntu-22.04
-            model: 32
-            host_dmd: dmd
-            coverage: true
+          # Disabled because of failure https://issues.dlang.org/show_bug.cgi?id=24518
+          # - job_name: Ubuntu 22.04 x86, DMD (coverage)
+          #   os: ubuntu-22.04
+          #   model: 32
+          #   host_dmd: dmd
+          #   coverage: true
           - job_name: Ubuntu 22.04 x86, DMD (bootstrap)
             os: ubuntu-22.04
             model: 32
@@ -52,10 +53,11 @@ jobs:
           - job_name: macOS 13 x64, DMD (latest)
             os: macos-13
             host_dmd: dmd
-          - job_name: macOS 13 x64, DMD (coverage)
-            os: macos-13
-            host_dmd: dmd
-            coverage: true
+          # Disabled because of failure https://issues.dlang.org/show_bug.cgi?id=24518
+          # - job_name: macOS 13 x64, DMD (coverage)
+          #   os: macos-13
+          #   host_dmd: dmd
+          #   coverage: true
           - job_name: macOS 12 x64, DMD (bootstrap)
             os: macos-12
             # de-facto bootstrap version on OSX

compiler/src/dmd/cparse.d

@@ -1919,6 +1919,14 @@
                 auto s = cparseFunctionDefinition(id, dt.isTypeFunction(), specifier);
                 typedefTab.setDim(typedefTabLengthSave);
                 symbols = symbolsSave;
+                if (specifier.mod & MOD.x__stdcall)
+                {
+                    // If this function is __stdcall, wrap it in a LinkDeclaration so that
+                    // it's extern(Windows) when imported in D.
+                    auto decls = new AST.Dsymbols(1);
+                    (*decls)[0] = s;
+                    s = new AST.LinkDeclaration(s.loc, LINK.windows, decls);
+                }
                 symbols.push(s);
                 return;
             }
@@ -2071,13 +2079,14 @@
                     }
                 }
                 s = applySpecifier(s, specifier);
-                if (level == LVL.local)
+                if (level == LVL.local || (specifier.mod & MOD.x__stdcall))
                 {
-                    // Wrap the declaration in `extern (C) { declaration }`
+                    // Wrap the declaration in `extern (C/Windows) { declaration }`
                     // Necessary for function pointers, but harmless to apply to all.
                     auto decls = new AST.Dsymbols(1);
                     (*decls)[0] = s;
-                    s = new AST.LinkDeclaration(s.loc, linkage, decls);
+                    const lkg = specifier.mod & MOD.x__stdcall ? LINK.windows : linkage;
+                    s = new AST.LinkDeclaration(s.loc, lkg, decls);
                 }
                 symbols.push(s);
             }
@@ -5860,27 +5869,38 @@
 
         const(char)* endp = &slice[length - 7];
 
+        AST.Dsymbols newSymbols;
+
         size_t[void*] defineTab;    // hash table of #define's turned into Symbol's
-                                    // indexed by Identifier, returns index into symbols[]
+                                    // indexed by Identifier, returns index into newSymbols[]
                                     // The memory for this is leaked
 
-        void addVar(AST.Dsymbol s)
+        void addSym(AST.Dsymbol s)
         {
-            //printf("addVar() %s\n", s.toChars());
+            //printf("addSym() %s\n", s.toChars());
             if (auto v = s.isVarDeclaration())
                 v.isCmacro(true);       // mark it as coming from a C #define
             /* If it's already defined, replace the earlier
              * definition
              */
             if (size_t* pd = cast(void*)s.ident in defineTab)
             {
-                //printf("replacing %s\n", v.toChars());
-                (*symbols)[*pd] = s;
+                //printf("replacing %s\n", s.toChars());
+                newSymbols[*pd] = s;
                 return;
             }
-            assert(symbols, "symbols is null");
-            defineTab[cast(void*)s.ident] = symbols.length;
-            symbols.push(s);
+            defineTab[cast(void*)s.ident] = newSymbols.length;
+            newSymbols.push(s);
+        }
+
+        void removeSym(Identifier ident)
+        {
+            //printf("removeSym() %s\n", ident.toChars());
+            if (size_t* pd = cast(void*)ident in defineTab)
+            {
+                //printf("removing %s\n", ident.toChars());
+                newSymbols[*pd] = null;
+            }
         }
 
         while (p < endp)
@@ -5924,7 +5944,7 @@
                                  */
                                 AST.Expression e = new AST.IntegerExp(scanloc, intvalue, t);
                                 auto v = new AST.VarDeclaration(scanloc, t, id, new AST.ExpInitializer(scanloc, e), STC.manifest);
-                                addVar(v);
+                                addSym(v);
                                 ++p;
                                 continue;
                             }
@@ -5947,7 +5967,7 @@
                                  */
                                 AST.Expression e = new AST.RealExp(scanloc, floatvalue, t);
                                 auto v = new AST.VarDeclaration(scanloc, t, id, new AST.ExpInitializer(scanloc, e), STC.manifest);
-                                addVar(v);
+                                addSym(v);
                                 ++p;
                                 continue;
                             }
@@ -5965,7 +5985,7 @@
                                  */
                                 AST.Expression e = new AST.StringExp(scanloc, str[0 .. len], len, 1, postfix);
                                 auto v = new AST.VarDeclaration(scanloc, null, id, new AST.ExpInitializer(scanloc, e), STC.manifest);
-                                addVar(v);
+                                addSym(v);
                                 ++p;
                                 continue;
                             }
@@ -6001,7 +6021,7 @@
                             AST.TemplateParameters* tpl = new AST.TemplateParameters();
                             AST.Expression constraint = null;
                             auto tempdecl = new AST.TemplateDeclaration(exp.loc, id, tpl, constraint, decldefs, false);
-                            addVar(tempdecl);
+                            addSym(tempdecl);
                             ++p;
                             continue;
                         }
@@ -6092,7 +6112,7 @@
                             AST.Dsymbols* decldefs = new AST.Dsymbols();
                             decldefs.push(fd);
                             auto tempdecl = new AST.TemplateDeclaration(exp.loc, id, tpl, null, decldefs, false);
-                            addVar(tempdecl);
+                            addSym(tempdecl);
 
                             ++p;
                             continue;
@@ -6103,13 +6123,31 @@
                     }
                 }
             }
+            else if (p[0 .. 6] == "#undef")
+            {
+                p += 6;
+                nextToken();
+                //printf("undef %s\n", token.toChars());
+                if (token.value == TOK.identifier)
+                    removeSym(token.ident);
+            }
             // scan to end of line
             while (*p)
                 ++p;
             ++p; // advance to start of next line
             scanloc.linnum = scanloc.linnum + 1;
         }
 
+        if (newSymbols.length)
+        {
+            assert(symbols, "symbols is null");
+            symbols.reserve(newSymbols.length);
+
+            foreach (sym; newSymbols)
+                if (sym) // undefined entries are null
+                    symbols.push(sym);
+        }
+
         scanloc = scanlocSave;
         eSink = save;
         defines = buf;

compiler/src/dmd/expressionsem.d

@@ -5335,7 +5335,8 @@ private extern (C++) final class ExpressionSemanticVisitor : Visitor
                 lowering = new DotIdExp(exp.loc, lowering, Id.object);
 
                 auto tbn = exp.type.nextOf();
-                while (tbn.ty == Tarray)
+                size_t i = nargs;
+                while (tbn.ty == Tarray && --i)
                     tbn = tbn.nextOf();
                 auto unqualTbn = tbn.unqualify(MODFlags.wild | MODFlags.const_ |
                     MODFlags.immutable_ | MODFlags.shared_);

compiler/src/dmd/initsem.d

@@ -868,11 +868,13 @@
                          * by the initializer syntax. if a CInitializer has a Designator, it is probably
                          * a nested anonymous struct
                          */
-                        if (cix.initializerList.length)
+                        int found;
+                        foreach (dix; cix.initializerList)
                         {
-                            DesigInit dix = cix.initializerList[0];
                             Designators* dlistx = dix.designatorList;
-                            if (dlistx && (*dlistx).length == 1 && (*dlistx)[0].ident)
+                            if (!dlistx)
+                                continue;
+                            if ((*dlistx).length == 1 && (*dlistx)[0].ident)
                             {
                                 auto id = (*dlistx)[0].ident;
                                 foreach (k, f; sd.fields[])         // linear search for now
@@ -883,11 +885,18 @@
                                         si.addInit(id, dix.initializer);
                                         ++fieldi;
                                         ++index;
-                                        continue Loop1;
+                                        ++found;
+                                        break;
                                     }
                                 }
                             }
+                            else {
+                                error(ci.loc, "only 1 designator currently allowed for C struct field initializer `%s`", toChars(ci));
+                            }
                         }
+
+                        if (found == cix.initializerList.length)
+                            continue Loop1;
                     }
 
                     VarDeclaration field;

compiler/src/dmd/traits.d

@@ -1246,7 +1246,7 @@ Expression semanticTraits(TraitsExp e, Scope* sc)
             // @@@DEPRECATION 2.100.2
             if (auto td = s.isTemplateDeclaration())
             {
-                if (td.overnext || td.overroot)
+                if (td.overnext)
                 {
                     deprecation(e.loc, "`__traits(getAttributes)` may only be used for individual functions, not the overload set `%s`", td.ident.toChars());
                     deprecationSupplemental(e.loc, "the result of `__traits(getOverloads)` may be used to select the desired function to extract attributes from");

compiler/test/compilable/imports/test24511_c.c

@@ -0,0 +1,17 @@
+typedef void (*CFunctionPointer)();
+typedef void (__stdcall *StdCallFunctionPointer)();
+
+void cFunction()
+{}
+
+void __stdcall stdcallFunction()
+{}
+
+void __stdcall takesCFunctionPointer(CFunctionPointer f)
+{}
+
+void takesStdCallFunctionPointer(StdCallFunctionPointer f)
+{}
+
+typedef void (__stdcall *StdCallFunctionPointerTakingCFunctionPointer)(CFunctionPointer f);
+typedef void (*CFunctionPointerTakingStdCallFunctionPointer)(StdCallFunctionPointer f);

compiler/test/compilable/test22727.c

@@ -6,6 +6,10 @@ __stdcall int foostdcall(int a) { return a; }
 
 int __stdcall foostdcall2(int a) { return a; }
 
+#if _MSC_VER
+int _stdcall foostdcall3(int a) { return a; } // test issue 24509
+#endif
+
 int __stdcall (*fp1)(int a) = &foostdcall;
 
 int (__stdcall *fp2)(int a) = &foostdcall2;

compiler/test/compilable/test24479.d

@@ -0,0 +1,35 @@
+// https://issues.dlang.org/show_bug.cgi?id=24479
+
+/*
+TEST_OUTPUT:
+---
+1
+2
+---
+*/
+
+struct S
+{
+    @1
+    S opBinary(string op: "-")(S rhs) const pure nothrow @nogc
+    {
+        return rhs;
+    }
+    @2
+    S opBinary(string op: "*")(S dur) const pure nothrow @nogc
+    {
+        return dur;
+    }
+}
+
+private enum hasExternalUDA(alias A) = is(A == External) || is(typeof(A) == External);
+
+void foo()
+{
+    static foreach (t; __traits(getOverloads, S, "opBinary", true))
+        static foreach(attr; __traits(getAttributes, t))
+            pragma(msg, attr);
+
+    static assert(__traits(getOverloads, S, "opBinary", true).length == 2);
+    alias A = __traits(getAttributes, __traits(getOverloads, S, "opBinary", true)[1]);
+}

compiler/test/compilable/test24505.c

@@ -0,0 +1,15 @@
+// https://issues.dlang.org/show_bug.cgi?id=24505
+
+// PERMUTE_ARGS:
+
+struct stat { int x; };
+
+void __stat(int x, int y);
+#define stat(x, y) __stat(x, y)
+
+// reversed order:
+#define stat2(x, y) __stat(x, y)
+struct stat2 { int x; };
+
+#undef stat
+#undef stat2

compiler/test/compilable/test24511.d

@@ -0,0 +1,28 @@
+// REQUIRED_ARGS: -os=windows
+// EXTRA_SOURCES: imports/test24511_c.c
+// DISABLED: osx
+// This is disabled on macOS because ld complains about _main being undefined
+// when clang attempts to preprocess the C file.
+
+import test24511_c;
+
+static assert(__traits(getLinkage, CFunctionPointer) == "C");
+static assert(__traits(getLinkage, StdCallFunctionPointer) == "Windows");
+static assert(__traits(getLinkage, cFunction) == "C");
+static assert(__traits(getLinkage, stdcallFunction) == "Windows");
+
+static assert(__traits(getLinkage, takesCFunctionPointer) == "Windows");
+static if (is(typeof(&takesCFunctionPointer) ParamsA == __parameters))
+    static assert(__traits(getLinkage, ParamsA[0]) == "C");
+
+static assert(__traits(getLinkage, takesStdCallFunctionPointer) == "C");
+static if (is(typeof(&takesStdCallFunctionPointer) ParamsB == __parameters))
+    static assert(__traits(getLinkage, ParamsB[0]) == "Windows");
+
+static assert(__traits(getLinkage, StdCallFunctionPointerTakingCFunctionPointer) == "Windows");
+static if (is(typeof(&StdCallFunctionPointerTakingCFunctionPointer) ParamsC == __parameters))
+    static assert(__traits(getLinkage, ParamsC[0]) == "C");
+
+static assert(__traits(getLinkage, CFunctionPointerTakingStdCallFunctionPointer) == "C");
+static if (is(typeof(&CFunctionPointerTakingStdCallFunctionPointer) ParamsD == __parameters))
+    static assert(__traits(getLinkage, ParamsD[0]) == "Windows");