Upgrade frontend & libs to v2.106

CHANGELOG.md

@@ -1,6 +1,8 @@
 # LDC master
 
 #### Big news
+- Frontend, druntime and Phobos are at version [2.106.0](https://dlang.org/changelog/2.106.0.html). (#4522)
+- New command-line options `-fno-{exceptions,moduleinfo,rtti}` to selectively enable some `-betterC` effects. (#4522)
 
 #### Platform support
 

CMakeLists.txt

@@ -117,10 +117,10 @@ include(GetLinuxDistribution)
 #
 
 # Version information
-set(LDC_VERSION "1.35.0") # May be overridden by git hash tag
+set(LDC_VERSION "1.36.0") # May be overridden by git hash tag
 set(DMDFE_MAJOR_VERSION   2)
-set(DMDFE_MINOR_VERSION   105)
-set(DMDFE_PATCH_VERSION   3)
+set(DMDFE_MINOR_VERSION   106)
+set(DMDFE_PATCH_VERSION   0)
 
 set(DMD_VERSION ${DMDFE_MAJOR_VERSION}.${DMDFE_MINOR_VERSION}.${DMDFE_PATCH_VERSION})
 

dmd/README.md

@@ -31,7 +31,8 @@ Note that these groups have no strict meaning, the category assignments are a bi
 
 | File                                                                        | Purpose                                                               |
 |-----------------------------------------------------------------------------|-----------------------------------------------------------------------|
-| [mars.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/mars.d)           | The entry point. Contains `main`.                                     |
+| [main.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/main.d)           | The entry point. Contains `main`.                                     |
+| [mars.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/mars.d)           | Argument parsing, path manipulation.                                  |
 | [cli.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/cli.d)             | Define the command line interface                                     |
 | [dmdparams.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/dmdparams.d) | DMD-specific parameters                                               |
 | [globals.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/globals.d)     | Define a structure storing command line options                       |
@@ -83,6 +84,7 @@ Note that these groups have no strict meaning, the category assignments are a bi
 | [astcodegen.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/astcodegen.d)     | Namespace of AST nodes of a AST ready for code generation   |
 | [astenums.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/astenums.d)         | Enums common to DMD and AST                                 |
 | [expression.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/expression.d)     | Define expression AST nodes                                 |
+| [rootobject.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/rootobject.d)     | Define an abstract root class                           |
 | [statement.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/statement.d)       | Define statement AST nodes                                  |
 | [staticassert.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/staticassert.d) | Define a `static assert` AST node                           |
 | [aggregate.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/aggregate.d)       | Define an aggregate (`struct`, `union` or `class`) AST node |

dmd/access.d

@@ -20,8 +20,8 @@ import dmd.dmodule;
 import dmd.dscope;
 import dmd.dstruct;
 import dmd.dsymbol;
+import dmd.errors;
 import dmd.expression;
-import dmd.globals;
 import dmd.location;
 import dmd.tokens;
 
@@ -48,7 +48,7 @@ bool checkAccess(AggregateDeclaration ad, Loc loc, Scope* sc, Dsymbol smember)
 
     if (!symbolIsVisible(sc, smember))
     {
-        ad.error(loc, "%s `%s` is not accessible", smember.kind(), smember.toChars());
+        error(loc, "%s `%s` %s `%s` is not accessible", ad.kind(), ad.toPrettyChars(), smember.kind(), smember.toChars());
         //printf("smember = %s %s, vis = %d, semanticRun = %d\n",
         //        smember.kind(), smember.toPrettyChars(), smember.visible() smember.semanticRun);
         return true;

dmd/aggregate.d

@@ -31,6 +31,7 @@ import dmd.errors;
 import dmd.expression;
 import dmd.func;
 import dmd.globals;
+import dmd.hdrgen;
 import dmd.id;
 import dmd.identifier;
 import dmd.location;
@@ -64,7 +65,7 @@ enum ClassKind : ubyte
  * Returns:
  *     0-terminated string for `c`
  */
-const(char)* toChars(ClassKind c)
+const(char)* toChars(ClassKind c) @safe
 {
     final switch (c)
     {
@@ -191,7 +192,7 @@ extern (C++) abstract class AggregateDeclaration : ScopeDsymbol
      * Returns:
      *      The total number of fields minus the number of hidden fields.
      */
-    final size_t nonHiddenFields()
+    extern (D) final size_t nonHiddenFields()
     {
         return fields.length - isNested() - (vthis2 !is null);
     }
@@ -201,7 +202,7 @@ extern (C++) abstract class AggregateDeclaration : ScopeDsymbol
      * Returns:
      *      false if failed to determine the size.
      */
-    final bool determineSize(const ref Loc loc)
+    extern (D) final bool determineSize(const ref Loc loc)
     {
         //printf("AggregateDeclaration::determineSize() %s, sizeok = %d\n", toChars(), sizeok);
 
@@ -213,7 +214,7 @@ extern (C++) abstract class AggregateDeclaration : ScopeDsymbol
 
         if (!members)
         {
-            error(loc, "unknown size");
+            .error(loc, "%s `%s` unknown size", kind, toPrettyChars);
             return false;
         }
 
@@ -243,7 +244,7 @@ extern (C++) abstract class AggregateDeclaration : ScopeDsymbol
     Lfail:
         // There's unresolvable forward reference.
         if (type != Type.terror)
-            error(loc, "no size because of forward reference");
+            error(loc, "%s `%s` no size because of forward reference", kind, toPrettyChars);
         // Don't cache errors from speculative semantic, might be resolvable later.
         // https://issues.dlang.org/show_bug.cgi?id=16574
         if (!global.gag)
@@ -337,7 +338,7 @@ extern (C++) abstract class AggregateDeclaration : ScopeDsymbol
                 else if (v2._init && i < j)
                 {
                     .error(v2.loc, "union field `%s` with default initialization `%s` must be before field `%s`",
-                        v2.toChars(), v2._init.toChars(), vd.toChars());
+                        v2.toChars(), dmd.hdrgen.toChars(v2._init), vd.toChars());
                     errors = true;
                 }
             }
@@ -452,7 +453,7 @@ extern (C++) abstract class AggregateDeclaration : ScopeDsymbol
                     assert(!vx._init.isVoidInitializer());
                     if (vx.inuse)   // https://issues.dlang.org/show_bug.cgi?id=18057
                     {
-                        vx.error(loc, "recursive initialization of field");
+                        .error(loc, "%s `%s` recursive initialization of field", vx.kind(), vx.toPrettyChars());
                         errors = true;
                     }
                     else
@@ -500,90 +501,6 @@ extern (C++) abstract class AggregateDeclaration : ScopeDsymbol
         return !errors;
     }
 
-    /****************************
-     * Do byte or word alignment as necessary.
-     * Align sizes of 0, as we may not know array sizes yet.
-     * Params:
-     *   alignment = struct alignment that is in effect
-     *   memalignsize = natural alignment of field
-     *   poffset = pointer to offset to be aligned
-     */
-    extern (D) static void alignmember(structalign_t alignment, uint memalignsize, uint* poffset) pure nothrow @safe
-    {
-        //debug printf("alignment = %u %d, size = %u, offset = %u\n", alignment.get(), alignment.isPack(), memalignsize, *poffset);
-        uint alignvalue;
-
-        if (alignment.isDefault())
-        {
-            // Alignment in Target::fieldalignsize must match what the
-            // corresponding C compiler's default alignment behavior is.
-            alignvalue = memalignsize;
-        }
-        else if (alignment.isPack())    // #pragma pack semantics
-        {
-            alignvalue = alignment.get();
-            if (memalignsize < alignvalue)
-                alignvalue = memalignsize;      // align to min(memalignsize, alignment)
-        }
-        else if (alignment.get() > 1)
-        {
-            // Align on alignment boundary, which must be a positive power of 2
-            alignvalue = alignment.get();
-        }
-        else
-            return;
-
-        assert(alignvalue > 0 && !(alignvalue & (alignvalue - 1)));
-        *poffset = (*poffset + alignvalue - 1) & ~(alignvalue - 1);
-    }
-
-    /****************************************
-     * Place a field (mem) into an aggregate (agg), which can be a struct, union or class
-     * Params:
-     *    nextoffset    = location just past the end of the previous field in the aggregate.
-     *                    Updated to be just past the end of this field to be placed, i.e. the future nextoffset
-     *    memsize       = size of field
-     *    memalignsize  = natural alignment of field
-     *    alignment     = alignment in effect for this field
-     *    paggsize      = size of aggregate (updated)
-     *    paggalignsize = alignment of aggregate (updated)
-     *    isunion       = the aggregate is a union
-     * Returns:
-     *    aligned offset to place field at
-     *
-     */
-    extern (D) static uint placeField(uint* nextoffset, uint memsize, uint memalignsize,
-        structalign_t alignment, uint* paggsize, uint* paggalignsize, bool isunion)
-    {
-        uint ofs = *nextoffset;
-
-        const uint actualAlignment =
-            alignment.isDefault() || alignment.isPack() && memalignsize < alignment.get()
-                        ? memalignsize : alignment.get();
-
-        // Ensure no overflow
-        bool overflow;
-        const sz = addu(memsize, actualAlignment, overflow);
-        addu(ofs, sz, overflow);
-        if (overflow) assert(0);
-
-        // Skip no-op for noreturn without custom aligment
-        if (memalignsize != 0 || !alignment.isDefault())
-            alignmember(alignment, memalignsize, &ofs);
-
-        uint memoffset = ofs;
-        ofs += memsize;
-        if (ofs > *paggsize)
-            *paggsize = ofs;
-        if (!isunion)
-            *nextoffset = ofs;
-
-        if (*paggalignsize < actualAlignment)
-            *paggalignsize = actualAlignment;
-
-        return memoffset;
-    }
-
     override final Type getType()
     {
         /* Apply storage classes to forward references. (Issue 22254)
@@ -608,7 +525,7 @@ extern (C++) abstract class AggregateDeclaration : ScopeDsymbol
     }
 
     /// Flag this aggregate as deprecated
-    final void setDeprecated()
+    extern (D) final void setDeprecated()
     {
         this.storage_class |= STC.deprecated_;
     }
@@ -744,7 +661,7 @@ extern (C++) abstract class AggregateDeclaration : ScopeDsymbol
     /*******************************************
      * Look for constructor declaration.
      */
-    final Dsymbol searchCtor()
+    extern (D) final Dsymbol searchCtor()
     {
         auto s = search(Loc.initial, Id.ctor);
         if (s)
@@ -753,7 +670,7 @@ extern (C++) abstract class AggregateDeclaration : ScopeDsymbol
                   s.isTemplateDeclaration() ||
                   s.isOverloadSet()))
             {
-                s.error("is not a constructor; identifiers starting with `__` are reserved for the implementation");
+                .error(s.loc, "%s `%s` is not a constructor; identifiers starting with `__` are reserved for the implementation", s.kind(), s.toPrettyChars());
                 errors = true;
                 s = null;
             }
@@ -846,3 +763,103 @@ int apply(Dsymbol symbol, int function(Dsymbol, void*) fp, void* ctx)
 
     return fp(symbol, ctx);
 }
+
+/****************************
+ * Do byte or word alignment as necessary.
+ * Align sizes of 0, as we may not know array sizes yet.
+ * Params:
+ *   alignment = struct alignment that is in effect
+ *   memalignsize = natural alignment of field
+ *   offset = offset to be aligned
+ * Returns:
+ *   aligned offset
+ */
+public uint alignmember(structalign_t alignment, uint memalignsize, uint offset) pure nothrow @safe
+{
+    //debug printf("alignment = %u %d, size = %u, offset = %u\n", alignment.get(), alignment.isPack(), memalignsize, offset);
+    uint alignvalue;
+
+    if (alignment.isDefault())
+    {
+        // Alignment in Target::fieldalignsize must match what the
+        // corresponding C compiler's default alignment behavior is.
+        alignvalue = memalignsize;
+    }
+    else if (alignment.isPack())    // #pragma pack semantics
+    {
+        alignvalue = alignment.get();
+        if (memalignsize < alignvalue)
+            alignvalue = memalignsize;      // align to min(memalignsize, alignment)
+    }
+    else if (alignment.get() > 1)
+    {
+        // Align on alignment boundary, which must be a positive power of 2
+        alignvalue = alignment.get();
+    }
+    else
+        return offset;
+
+    assert(alignvalue && !(alignvalue & (alignvalue - 1))); // non-zero and power of 2
+    return (offset + alignvalue - 1) & ~(alignvalue - 1);
+}
+
+/****************************************
+ * Place a field (mem) into an aggregate (agg), which can be a struct, union or class
+ * Params:
+ *    nextoffset    = location just past the end of the previous field in the aggregate.
+ *                    Updated to be just past the end of this field to be placed, i.e. the future nextoffset
+ *    memsize       = size of field
+ *    memalignsize  = natural alignment of field
+ *    alignment     = alignment in effect for this field
+ *    aggsize       = size of aggregate (updated)
+ *    aggalignsize  = alignment of aggregate (updated)
+ *    isunion       = the aggregate is a union
+ * Returns:
+ *    aligned offset to place field at
+ *
+ */
+public uint placeField(ref uint nextoffset, uint memsize, uint memalignsize,
+    structalign_t alignment, ref uint aggsize, ref uint aggalignsize, bool isunion) @safe pure nothrow
+{
+    static if (0)
+    {
+        printf("placeField() nextoffset:   %u\n", nextoffset);
+        printf(":            memsize:      %u\n", memsize);
+        printf(":            memalignsize: %u\n", memalignsize);
+        printf(":            alignment:    %u\n", alignment.get());
+        printf(":            aggsize:      %u\n", aggsize);
+        printf(":            aggalignsize: %u\n", aggalignsize);
+        printf(":            isunion:      %d\n", isunion);
+    }
+
+    uint ofs = nextoffset;
+
+    const uint actualAlignment =
+        alignment.isDefault() || alignment.isPack() && memalignsize < alignment.get()
+                    ? memalignsize : alignment.get();
+
+    // Ensure no overflow for (memsize + actualAlignment + ofs)
+    bool overflow;
+    const sz = addu(memsize, actualAlignment, overflow);
+    addu(ofs, sz, overflow);
+    if (overflow) assert(0);
+
+    // Skip no-op for noreturn without custom aligment
+    if (memalignsize != 0 || !alignment.isDefault())
+        ofs = alignmember(alignment, memalignsize, ofs);
+
+    uint memoffset = ofs;
+    ofs += memsize;
+    if (ofs > aggsize)
+        aggsize = ofs;
+    if (!isunion)
+    {
+        nextoffset = ofs;
+        //printf("     revised nextoffset:   %u\n", ofs);
+    }
+
+    if (aggalignsize < actualAlignment)
+        aggalignsize = actualAlignment;
+
+    return memoffset;
+}

dmd/aggregate.h

@@ -114,17 +114,13 @@ class AggregateDeclaration : public ScopeDsymbol
 
     virtual Scope *newScope(Scope *sc);
     void setScope(Scope *sc) override final;
-    size_t nonHiddenFields();
-    bool determineSize(const Loc &loc);
     virtual void finalizeSize() = 0;
     uinteger_t size(const Loc &loc) override final;
     bool fill(const Loc &loc, Expressions &elements, bool ctorinit);
     Type *getType() override final;
     bool isDeprecated() const override final; // is aggregate deprecated?
-    void setDeprecated();
     bool isNested() const;
     bool isExport() const override final;
-    Dsymbol *searchCtor();
 
     Visibility visible() override final;
 
@@ -289,19 +285,16 @@ class ClassDeclaration : public AggregateDeclaration
     const char *toPrettyChars(bool QualifyTypes = false) override;
     ClassDeclaration *syntaxCopy(Dsymbol *s) override;
     Scope *newScope(Scope *sc) override;
-    bool isBaseOf2(ClassDeclaration *cd);
 
     #define OFFSET_RUNTIME 0x76543210
     #define OFFSET_FWDREF 0x76543211
     virtual bool isBaseOf(ClassDeclaration *cd, int *poffset);
 
     bool isBaseInfoComplete();
     Dsymbol *search(const Loc &loc, Identifier *ident, int flags = SearchLocalsOnly) override final;
-    ClassDeclaration *searchBase(Identifier *ident);
     void finalizeSize() override;
     bool hasMonitor();
     bool isFuncHidden(FuncDeclaration *fd);
-    FuncDeclaration *findFunc(Identifier *ident, TypeFunction *tf);
     bool isCOMclass() const;
     virtual bool isCOMinterface() const;
     bool isCPPclass() const;