Merge pull request #4962 from ldc-developers/merge-2.112

Merge upstream stable

Author: kinke

CHANGELOG.md

@@ -1,7 +1,7 @@
 # LDC master
 
 #### Big news
-- Frontend, druntime and Phobos are at version ~[2.112.0](https://dlang.org/changelog/2.112.0.html). (#4949)
+- Frontend, druntime and Phobos are at version ~[2.112.0](https://dlang.org/changelog/2.112.0.html), incl. new command-line options `-extI`, `-dllimport=externalOnly` and `-edition`. (#4949, #4962)
 - **Breaking change for dcompute**: The special `@kernel` UDA is now a function and _**requires**_ parentheses as in `@kernel() void foo(){}`. Optionally you can provide launch dimensions, `@kernel([2,4,8])`, to specify to the compute runtime how the kernel is intended to be launched. 
 
 #### Platform support

dmd/README.md

@@ -170,9 +170,10 @@ Note that these groups have no strict meaning, the category assignments are a bi
 
 | File                                                                    | Purpose                                   |
 |-------------------------------------------------------------------------|-------------------------------------------|
-| [iasm.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/iasm.d)       | Inline assembly depending on the compiler |
-| [iasmdmd.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/iasmdmd.d) | Inline assembly for DMD                   |
-| [iasmgcc.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/iasmgcc.d) | Inline assembly for GDC                   |
+| [iasm/package.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/iasm/package.d)       | Inline assembly depending on the compiler |
+| [iasm/dmdx86.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/iasm/dmd.d) | Inline assembly for DMD X86_64            |
+| [iasm/dmdaarch64.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/iasm/aarch64.d) | Inline assembly for DMD AArch64   |
+| [iasm/gcc.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/iasm/gcc.d) | Inline assembly for GDC                   |
 
 **Other**
 

dmd/aggregate.d

@@ -25,7 +25,7 @@ import dmd.declaration;
 import dmd.dscope;
 import dmd.dstruct;
 import dmd.dsymbol;
-import dmd.dsymbolsem : dsymbolSemantic, determineFields, search, determineSize, include;
+import dmd.dsymbolsem : dsymbolSemantic, determineSize, include;
 import dmd.dtemplate;
 import dmd.errors;
 import dmd.expression;
@@ -37,7 +37,6 @@ import dmd.identifier;
 import dmd.location;
 import dmd.mtype;
 import dmd.tokens;
-import dmd.typesem : defaultInit, addMod, size;
 import dmd.visitor;
 
 /**
@@ -195,86 +194,6 @@ extern (C++) abstract class AggregateDeclaration : ScopeDsymbol
         return ok ? structsize : SIZE_INVALID;
     }
 
-    /***************************************
-     * Calculate field[i].overlapped and overlapUnsafe, and check that all of explicit
-     * field initializers have unique memory space on instance.
-     * Returns:
-     *      true if any errors happen.
-     */
-    extern (D) final bool checkOverlappedFields()
-    {
-        //printf("AggregateDeclaration::checkOverlappedFields() %s\n", toChars());
-        assert(sizeok == Sizeok.done);
-        size_t nfields = fields.length;
-        if (isNested())
-        {
-            auto cd = isClassDeclaration();
-            if (!cd || !cd.baseClass || !cd.baseClass.isNested())
-                nfields--;
-            if (vthis2 && !(cd && cd.baseClass && cd.baseClass.vthis2))
-                nfields--;
-        }
-        bool errors = false;
-
-        // Fill in missing any elements with default initializers
-        foreach (i; 0 .. nfields)
-        {
-            auto vd = fields[i];
-            if (vd.errors)
-            {
-                errors = true;
-                continue;
-            }
-
-            const vdIsVoidInit = vd._init && vd._init.isVoidInitializer();
-
-            // Find overlapped fields with the hole [vd.offset .. vd.offset.size()].
-            foreach (j; 0 .. nfields)
-            {
-                if (i == j)
-                    continue;
-                auto v2 = fields[j];
-                if (v2.errors)
-                {
-                    errors = true;
-                    continue;
-                }
-                if (!vd.isOverlappedWith(v2))
-                    continue;
-
-                // vd and v2 are overlapping.
-                vd.overlapped = true;
-                v2.overlapped = true;
-
-                if (!MODimplicitConv(vd.type.mod, v2.type.mod))
-                    v2.overlapUnsafe = true;
-                if (!MODimplicitConv(v2.type.mod, vd.type.mod))
-                    vd.overlapUnsafe = true;
-
-                if (i > j)
-                    continue;
-
-                if (!v2._init)
-                    continue;
-
-                if (v2._init.isVoidInitializer())
-                    continue;
-
-                if (vd._init && !vdIsVoidInit && v2._init)
-                {
-                    .error(loc, "overlapping default initialization for field `%s` and `%s`", v2.toChars(), vd.toChars());
-                    errors = true;
-                }
-                else if (v2._init && i < j)
-                {
-                    .error(v2.loc, "union field `%s` with default initialization `%s` must be before field `%s`",
-                        v2.toChars(), dmd.hdrgen.toChars(v2._init), vd.toChars());
-                    errors = true;
-                }
-            }
-        }
-        return errors;
-    }
 
     override final Type getType()
     {
@@ -433,46 +352,6 @@ extern (C++) abstract class AggregateDeclaration : ScopeDsymbol
         return visibility.kind == Visibility.Kind.export_;
     }
 
-    /*******************************************
-     * Look for constructor declaration.
-     */
-    extern (D) final Dsymbol searchCtor()
-    {
-        auto s = this.search(Loc.initial, Id.ctor);
-        if (s)
-        {
-            if (!(s.isCtorDeclaration() ||
-                  s.isTemplateDeclaration() ||
-                  s.isOverloadSet()))
-            {
-                error(s.loc, "%s name `__ctor` is not allowed", s.kind);
-                errorSupplemental(s.loc, "identifiers starting with `__` are reserved for internal use");
-                errors = true;
-                s = null;
-            }
-        }
-        if (s && s.toParent() != this)
-            s = null; // search() looks through ancestor classes
-        if (s)
-        {
-            // Finish all constructors semantics to determine this.noDefaultCtor.
-            static int searchCtor(Dsymbol s, void*)
-            {
-                auto f = s.isCtorDeclaration();
-                if (f && f.semanticRun == PASS.initial)
-                    f.dsymbolSemantic(null);
-                return 0;
-            }
-
-            for (size_t i = 0; i < members.length; i++)
-            {
-                auto sm = (*members)[i];
-                sm.apply(&searchCtor, null);
-            }
-        }
-        return s;
-    }
-
     override final Visibility visible() pure nothrow @nogc @safe
     {
         return visibility;

dmd/astenums.d

@@ -19,12 +19,12 @@ enum Sizeok : ubyte
 }
 
 /// D Language version
-enum Edition : ubyte
+enum Edition : ushort
 {
-    none,
-    legacy,          /// Before the introduction of editions
-    v2024,           /// Experimental first new edition
-    latest = v2024   /// Newest edition that this compiler knows of
+    v2023 = 2023,    /// Edition.min for default edition
+    v2024,           /// first Edition
+    v2025,           /// next Edition
+                     /// use Edition.max for latest edition
 }
 
 enum Baseok : ubyte
@@ -77,9 +77,10 @@ enum STC : ulong  // transfer changes to declaration.h
     ref_                = 0x4_0000,   /// `ref`
     scope_              = 0x8_0000,   /// `scope`
 
-    scopeinferred       = 0x20_0000,   /// `scope` has been inferred and should not be part of mangling, `scope_` must also be set
-    return_             = 0x40_0000,   /// 'return ref' or 'return scope' for function parameters
-    returnScope         = 0x80_0000,   /// if `ref return scope` then resolve to `ref` and `return scope`
+    scopeinferred       = 0x10_0000,   /// `scope` has been inferred and should not be part of mangling, `scope_` must also be set
+    return_             = 0x20_0000,   /// 'return ref' or 'return scope' for function parameters
+    returnScope         = 0x40_0000,   /// if `ref return scope` then resolve to `ref` and `return scope`
+    returnRef           = 0x80_0000,   /// if `return ref`
 
     returninferred      = 0x100_0000,   /// `return` has been inferred and should not be part of mangling, `return_` must also be set
     immutable_          = 0x200_0000,   /// `immutable`

dmd/attrib.d

@@ -32,7 +32,6 @@ import dmd.declaration;
 import dmd.dmodule;
 import dmd.dscope;
 import dmd.dsymbol;
-import dmd.dsymbolsem : include;
 import dmd.expression;
 import dmd.func;
 import dmd.globals;

dmd/cli.d

@@ -343,14 +343,19 @@ dmd -cov -unittest myprog.d
             (only imports).`,
         ),
         Option("dllimport=<value>",
-            "Windows only: select symbols to dllimport (none/defaultLibsOnly/all)",
-            `Which global variables to dllimport implicitly if not defined in a root module
+            "Windows only: select symbols to dllimport (none/defaultLibsOnly/externalOnly/all)",
+            `Which symbols to dllimport implicitly if not defined in a module that is being compiled
             $(UL
                 $(LI $(I none): None)
-                $(LI $(I defaultLibsOnly): Only druntime/Phobos symbols)
+                $(LI $(I defaultLibsOnly): Only druntime/Phobos symbols and any from a module that is marked as external to binary)
+                $(LI $(I externalOnly): Only symbols found from a module that is marked as external to binary)
                 $(LI $(I all): All)
             )`,
         ),
+        Option("edition[=<NNNN>G[<filename>]]",
+            "set language edition to edition year, apply to <filename>",
+            "set edition to default, to a particular year NNNN, apply only to a particular $(I filename)"
+        ),
         Option("extern-std=<standard>",
             "set C++ name mangling compatibility with <standard>",
             "Standards supported are:
@@ -468,6 +473,9 @@ dmd -cov -unittest myprog.d
         Option("I=<directory>",
             "look for imports also in directory"
         ),
+        Option("extI=<directory>",
+            "look for imports that are out of the currently compiling binary, used to set the module as DllImport"
+        ),
         Option("i[=<pattern>]",
             "include imported modules in the compilation",
             q"{$(P Enables "include imports" mode, where the compiler will include imported

dmd/common/bitfields.d

@@ -10,14 +10,18 @@
  */
 module dmd.common.bitfields;
 
+//version = Has_Bitfields; // does not work (yet) because hashOf doesn't work on bitfields
+version(Has_Bitfields)
+    version = Debugger_friendly; // without Has_Bitfields, this uses more space by using S
+
 /**
  * Generate code for bit fields inside a struct/class body
  * Params:
  *   S = type of a struct with only boolean fields, which should become bit fields
  *   T = type of bit fields variable, must have enough bits to store all booleans
  * Returns: D code with a bit fields variable and getter / setter functions
  */
-extern (D) string generateBitFields(S, T)()
+extern (D) string generateBitFields(S, T, int ID = __LINE__)()
 if (__traits(isUnsigned, T))
 {
     import core.bitop: bsr;
@@ -55,22 +59,57 @@ if (__traits(isUnsigned, T))
     static assert(bitInfo.totalSize <= T.sizeof * 8,
         "sum of bit field size "~toString!(bitInfo.totalSize)~" exceeds storage type `"~T.stringof~"`");
 
+    version(Debugger_friendly)
+    {
+        // unique name needed to allow same name as in base class using `alias`, but without overloading
+        string bitfieldsName = "bitfields" ~ toString!(ID);
+        string bitfieldsRead = T.stringof~" "~bitfieldsName~"() const pure { return 0";
+        string bitfieldsWrite = "void "~bitfieldsName~"("~T.stringof~" v) {\n";
+    }
+
     foreach (size_t i, mem; __traits(allMembers, S))
     {
         enum typeName = typeof(__traits(getMember, S, mem)).stringof;
         enum shift = toString!(bitInfo.offset[i]);
         enum sizeMask = toString!((1 << bitInfo.size[i]) - 1); // 0x01 for bool, 0xFF for ubyte etc.
-        result ~= "
-        "~typeName~" "~mem~"() const scope { return cast("~typeName~") ((bitFields >>> "~shift~") & "~sizeMask~"); }
-        "~typeName~" "~mem~"("~typeName~" v) scope
+        version(Debugger_friendly)
+        {
+            string memacc = mem;
+            bitfieldsRead ~= "\n| (cast("~T.stringof~")("~memacc~" & "~sizeMask~") << "~shift~")";
+            bitfieldsWrite ~= memacc~" = cast("~typeName~")((v >> "~shift~") & "~sizeMask~");\n";
+            result ~= typeName~" "~mem;
+            version(Has_Bitfields)
+                result ~= " : "~toString!(bitInfo.size[i]);
+            enum meminit = __traits(getMember, S.init, mem);
+            result ~= " = "~meminit.stringof~";\n";
+        }
+        else
         {
-            bitFields &= ~("~sizeMask~" << "~shift~");
-            bitFields |= v << "~shift~";
-            return v;
-        }";
+            result ~= "
+                "~typeName~" "~mem~"() const scope { return cast("~typeName~") ((bitFields >>> "~shift~") & "~sizeMask~"); }
+            "~typeName~" "~mem~"("~typeName~" v) scope
+            {
+                bitFields &= ~("~sizeMask~" << "~shift~");
+                bitFields |= v << "~shift~";
+                return v;
+            }";
+        }
+    }
+    version(Debugger_friendly)
+    {
+        bitfieldsRead ~= ";\n}\n";
+        bitfieldsWrite ~= "}\n";
+        result ~= "alias bitFields = "~bitfieldsName~";\n";
+        result ~= bitfieldsRead ~ bitfieldsWrite;
+        result ~= "\n}\n";
+        return result;
+    }
+    else
+    {
+        result ~= "\n}\n";
+        enum TP initVal = bitInfo.initialValue;
+        return result ~ " private "~T.stringof~" bitFields = " ~ toString!(initVal) ~ ";\n";
     }
-    enum TP initVal = bitInfo.initialValue;
-    return result ~ "\n}\n private "~T.stringof~" bitFields = " ~ toString!(initVal) ~ ";\n";
 }
 
 ///