Merge pull request #4476 from kinke/merge-2.105

Upgrade frontend & libs to v2.105.1
ldc-developers · Sep 11, 2023 · d70f676 · d70f676
2 parents 16b3c7e + 7ed24a6
commit d70f676
Show file tree

Hide file tree

Showing 331 changed files with 12,443 additions and 1,891 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,6 +1,7 @@
 # LDC master
 
 #### Big news
+- Frontend, druntime and Phobos are at version [2.105.1+](https://dlang.org/changelog/2.105.0.html). (#4476)
 
 #### Platform support
 

diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -117,10 +117,10 @@ include(GetLinuxDistribution)
 #
 
 # Version information
-set(LDC_VERSION "1.34.0") # May be overridden by git hash tag
+set(LDC_VERSION "1.35.0") # May be overridden by git hash tag
 set(DMDFE_MAJOR_VERSION   2)
-set(DMDFE_MINOR_VERSION   104)
-set(DMDFE_PATCH_VERSION   2)
+set(DMDFE_MINOR_VERSION   105)
+set(DMDFE_PATCH_VERSION   1)
 
 set(DMD_VERSION ${DMDFE_MAJOR_VERSION}.${DMDFE_MINOR_VERSION}.${DMDFE_PATCH_VERSION})
 

diff --git a/dmd/README.md b/dmd/README.md
@@ -19,7 +19,7 @@ this license for that file.
 | Folder                                                                   | Purpose                                                                                                                                                                                                       |
 |--------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
 | [dmd/](https://github.com/dlang/dmd/tree/master/compiler/src/dmd)                 | The dmd driver and front-end                                                                                                                                                                                  |
-| [dmd/backend/](https://github.com/dlang/dmd/tree/master/compiler/src/dmd/backend) | Code generation for x86 or x86-64. Shared by the [Digital Mars C compiler](https://github.com/DigitalMars/Compiler/), but not [LDC](https://github.com/ldc-developers/ldc) or [GDC](https://gdcproject.org/). |
+| [dmd/backend/](https://github.com/dlang/dmd/tree/master/compiler/src/dmd/backend) | Code generation for x86 or x86-64. Based on [DMC](https://github.com/DigitalMars/Compiler/)'s backend, but not kept in sync anymore. Not used by [LDC](https://github.com/ldc-developers/ldc) or [GDC](https://gdcproject.org/). |
 | [dmd/common/](https://github.com/dlang/dmd/tree/master/compiler/src/dmd/common)   | Code shared by the front-end and back-end                                                                                                                                                                     |
 | [dmd/root/](https://github.com/dlang/dmd/tree/master/compiler/src/dmd/root)       | Meant as a portable utility library, but ["it wasn't very good and the only project left using it is dmd"](https://github.com/dlang/dmd/pull/9844#issuecomment-498479516).                                    |
 
@@ -99,7 +99,7 @@ Note that these groups have no strict meaning, the category assignments are a bi
 | [strictvisitor.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/strictvisitor.d)                       | Visitor that forces derived classes to implement `visit` for every possible node |
 | [visitor.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/visitor.d)                                   | A visitor implementing `visit` for all nodes present in the compiler             |
 | [transitivevisitor.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/transitivevisitor.d)               | Provide a mixin template with visit methods for the parse time AST               |
-| [apply.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/apply.d)                                       | Depth-first expression visitor                                                   |
+| [postordervisitor.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/postordervisitor.d)                                       | Depth-first expression visitor                                                   |
 | [sapply.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/sapply.d)                                     | Depth-first statement visitor                                                    |
 | [statement_rewrite_walker.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/statement_rewrite_walker.d) | Statement visitor that allows replacing the currently visited node               |
 
@@ -174,7 +174,6 @@ Note that these groups have no strict meaning, the category assignments are a bi
 | [cond.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/cond.d)              | Evaluate `static if`, `version` `debug `                                                    |
 | [staticcond.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/staticcond.d)  | Lazily evaluate static conditions for `static if`, `static assert` and template constraints |
 | [delegatize.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/delegatize.d)  | Converts expression to delegates for `lazy` parameters                                      |
-| [eh.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/eh.d)                  | Generate tables for exception handling                                                      |
 | [nspace.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/nspace.d)          | Namespace for `extern (C++, Module)`                                                        |
 | [intrange.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/intrange.d)      | [Value range propagation](https://digitalmars.com/articles/b62.html)                        |
 | [dimport.d](https://github.com/dlang/dmd/blob/master/compiler/src/dmd/dimport.d)        | Renamed imports (`import aliasSymbol = pkg1.pkg2.symbol`)                                   |

diff --git a/dmd/access.d b/dmd/access.d
@@ -16,17 +16,13 @@ module dmd.access;
 import dmd.aggregate;
 import dmd.astenums;
 import dmd.dclass;
-import dmd.declaration;
 import dmd.dmodule;
 import dmd.dscope;
 import dmd.dstruct;
 import dmd.dsymbol;
-import dmd.errors;
 import dmd.expression;
-import dmd.func;
 import dmd.globals;
 import dmd.location;
-import dmd.mtype;
 import dmd.tokens;
 
 private enum LOG = false;

diff --git a/dmd/aggregate.d b/dmd/aggregate.d
@@ -18,7 +18,6 @@ import core.stdc.stdio;
 import core.checkedint;
 
 import dmd.aliasthis;
-import dmd.apply;
 import dmd.arraytypes;
 import dmd.astenums;
 import dmd.attrib;
@@ -764,21 +763,18 @@ extern (C++) abstract class AggregateDeclaration : ScopeDsymbol
         if (s)
         {
             // Finish all constructors semantics to determine this.noDefaultCtor.
-            struct SearchCtor
+            static int searchCtor(Dsymbol s, void*)
             {
-                extern (C++) static int fp(Dsymbol s, void* ctxt)
-                {
-                    auto f = s.isCtorDeclaration();
-                    if (f && f.semanticRun == PASS.initial)
-                        f.dsymbolSemantic(null);
-                    return 0;
-                }
+                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.fp, null);
+                sm.apply(&searchCtor, null);
             }
         }
         return s;
@@ -817,3 +813,36 @@ version (IN_LLVM) {} else
         v.visit(this);
     }
 }
+
+/*********************************
+ * Iterate this dsymbol or members of this scoped dsymbol, then
+ * call `fp` with the found symbol and `params`.
+ * Params:
+ *  symbol = the dsymbol or parent of members to call fp on
+ *  fp = function pointer to process the iterated symbol.
+ *       If it returns nonzero, the iteration will be aborted.
+ *  ctx = context parameter passed to fp.
+ * Returns:
+ *  nonzero if the iteration is aborted by the return value of fp,
+ *  or 0 if it's completed.
+ */
+int apply(Dsymbol symbol, int function(Dsymbol, void*) fp, void* ctx)
+{
+    if (auto nd = symbol.isNspace())
+    {
+        return nd.members.foreachDsymbol( (s) { return s && s.apply(fp, ctx); } );
+    }
+    if (auto ad = symbol.isAttribDeclaration())
+    {
+        return ad.include(ad._scope).foreachDsymbol( (s) { return s && s.apply(fp, ctx); } );
+    }
+    if (auto tm = symbol.isTemplateMixin())
+    {
+        if (tm._scope) // if fwd reference
+            dsymbolSemantic(tm, null); // try to resolve it
+
+        return tm.members.foreachDsymbol( (s) { return s && s.apply(fp, ctx); } );
+    }
+
+    return fp(symbol, ctx);
+}
diff --git a/dmd/asttypename.d b/dmd/asttypename.d
@@ -35,7 +35,6 @@ import dmd.mtype;
 import dmd.typinf;
 import dmd.identifier;
 import dmd.init;
-import dmd.doc;
 import dmd.root.complex;
 import dmd.root.rootobject;
 import dmd.statement;

diff --git a/dmd/attrib.d b/dmd/attrib.d
@@ -653,7 +653,8 @@ extern (C++) final class VisibilityDeclaration : AttribDeclaration
         {
             Module m = sc._module;
 
-            // While isAncestorPackageOf does an equality check, the fix for issue 17441 adds a check to see if
+            // https://issues.dlang.org/show_bug.cgi?id=17441
+            // While isAncestorPackageOf does an equality check, the fix for the issue adds a check to see if
             // each package's .isModule() properites are equal.
             //
             // Properties generated from `package(foo)` i.e. visibility.pkg have .isModule() == null.

diff --git a/dmd/canthrow.d b/dmd/canthrow.d
@@ -14,7 +14,6 @@
 module dmd.canthrow;
 
 import dmd.aggregate;
-import dmd.apply;
 import dmd.arraytypes;
 import dmd.attrib;
 import dmd.astenums;
@@ -26,6 +25,7 @@ import dmd.func;
 import dmd.globals;
 import dmd.init;
 import dmd.mtype;
+import dmd.postordervisitor;
 import dmd.root.rootobject;
 import dmd.tokens;
 import dmd.visitor;
@@ -80,7 +80,7 @@ extern (C++) /* CT */ BE canThrow(Expression e, FuncDeclaration func, bool mustN
                     if (!f.isDtorDeclaration())
                         errorSupplementalInferredAttr(f, 10, false, STC.nothrow_);
 
-                    e.checkOverridenDtor(null, f, dd => dd.type.toTypeFunction().isnothrow, "not nothrow");
+                    e.checkOverriddenDtor(null, f, dd => dd.type.toTypeFunction().isnothrow, "not nothrow");
                 }
                 else if (func)
                 {
@@ -133,16 +133,9 @@ extern (C++) /* CT */ BE canThrow(Expression e, FuncDeclaration func, bool mustN
              */
             if (ce.f && ce.f == func)
                 return;
-            Type t = ce.e1.type.toBasetype();
-            auto tf = t.isTypeFunction();
+            const tf = ce.calledFunctionType();
             if (tf && tf.isnothrow)
                 return;
-            else
-            {
-                auto td = t.isTypeDelegate();
-                if (td && td.nextOf().isTypeFunction().isnothrow)
-                    return;
-            }
 
             if (ce.f)
                 checkFuncThrows(ce, ce.f);

diff --git a/dmd/chkformat.d b/dmd/chkformat.d
@@ -177,6 +177,8 @@ bool checkPrintfFormat(ref const Loc loc, scope const char[] format, scope Expre
                         errorMsg(null, e, (c_longsize == 4 ? "uint" : "ulong"), t);
                     else
                         errorMsg(null, e, (c_longsize == 4 ? "int" : "long"), t);
+                    if (t.isintegral() && t.size() != c_longsize)
+                        errorSupplemental(e.loc, "C `long` is %d bytes on your system", c_longsize);
                 }
                 break;
 

diff --git a/dmd/cli.d b/dmd/cli.d
@@ -220,7 +220,7 @@ version (IN_LLVM) {} else
                     $(LI $(B in): in contracts)
                     $(LI $(B invariant): class/struct invariants)
                     $(LI $(B out): out contracts)
-                    $(LI $(B switch): finalswitch failure checking)
+                    $(LI $(B switch): $(D final switch) failure checking)
                 )
                 $(UL
                     $(LI $(B on) or not specified: specified check is enabled.)
@@ -232,8 +232,8 @@ version (IN_LLVM) {} else
         ),
         Option("checkaction=[D|C|halt|context]",
             "behavior on assert/boundscheck/finalswitch failure",
-            `Sets behavior when an assert fails, and array boundscheck fails,
-             or a final switch errors.
+            `Sets behavior when an assert or an array bounds check fails,
+             or a $(D final switch) errors.
                 $(UL
                     $(LI $(B D): Default behavior, which throws an unrecoverable $(D AssertError).)
                     $(LI $(B C): Calls the C runtime library assert failure function.)
@@ -400,7 +400,7 @@ dmd -cov -unittest myprog.d
         ),
         Option("Hd=<directory>",
             "write 'header' file to directory",
-            `Write D interface file to $(I dir) directory. $(SWLINK -op)
+            `Write D interface file to $(I directory). $(SWLINK -op)
             can be used if the original package hierarchy should
             be retained.`,
         ),
@@ -435,7 +435,7 @@ dmd -cov -unittest myprog.d
             q"{$(P Enables "include imports" mode, where the compiler will include imported
              modules in the compilation, as if they were given on the command line. By default, when
              this option is enabled, all imported modules are included except those in
-             druntime/phobos. This behavior can be overriden by providing patterns via `-i=<pattern>`.
+             druntime/phobos. This behavior can be overridden by providing patterns via `-i=<pattern>`.
              A pattern of the form `-i=<package>` is an "inclusive pattern", whereas a pattern
              of the form `-i=-<package>` is an "exclusive pattern". Inclusive patterns will include
              all module's whose names match the pattern, whereas exclusive patterns will exclude them.
@@ -445,14 +445,14 @@ dmd -cov -unittest myprog.d
 
              $(P The default behavior of excluding druntime/phobos is accomplished by internally adding a
              set of standard exclusions, namely, `-i=-std -i=-core -i=-etc -i=-object`. Note that these
-             can be overriden with `-i=std -i=core -i=etc -i=object`.)
+             can be overridden with `-i=std -i=core -i=etc -i=object`.)
 
              $(P When a module matches multiple patterns, matches are prioritized by their component length, where
              a match with more components takes priority (i.e. pattern `foo.bar.baz` has priority over `foo.bar`).)
 
              $(P By default modules that don't match any pattern will be included. However, if at
              least one inclusive pattern is given, then modules not matching any pattern will
-             be excluded. This behavior can be overriden by usig `-i=.` to include by default or `-i=-.` to
+             be excluded. This behavior can be overridden by usig `-i=.` to include by default or `-i=-.` to
              exclude by default.)
 
              $(P Note that multiple `-i=...` options are allowed, each one adds a pattern.)}"
@@ -826,6 +826,11 @@ dmd -cov -unittest myprog.d
             `Enable $(LINK2 $(ROOT_DIR)articles/warnings.html, informational warnings (i.e. compilation
             still proceeds normally))`,
         ),
+        Option("wo",
+            "warnings about use of obsolete features (compilation will continue)",
+            `Enable warnings about use of obsolete features that may be problematic (compilation
+            still proceeds normally)`,
+        ),
         Option("X",
             "generate JSON file"
         ),
@@ -1033,8 +1038,8 @@ version (IN_LLVM) {} else
     /// Options supported by -HC
     enum hcUsage = "Available header generation modes:
   =[h|help|?]           List information on all available choices
-  =silent               Silently ignore non-exern(C[++]) declarations
-  =verbose              Add a comment for ignored non-exern(C[++]) declarations
+  =silent               Silently ignore non-extern(C[++]) declarations
+  =verbose              Add a comment for ignored non-extern(C[++]) declarations
 ";
 
     /// Options supported by -gdwarf

diff --git a/dmd/clone.d b/dmd/clone.d
@@ -106,18 +106,18 @@ FuncDeclaration hasIdentityOpAssign(AggregateDeclaration ad, Scope* sc)
         scope er = new NullExp(ad.loc, ad.type);    // dummy rvalue
         scope el = new IdentifierExp(ad.loc, Id.p); // dummy lvalue
         el.type = ad.type;
-        auto a = Expressions(1);
+        auto a = new Expressions(1);
         const errors = global.startGagging(); // Do not report errors, even if the template opAssign fbody makes it.
         sc = sc.push();
         sc.tinst = null;
         sc.minst = null;
 
-        a[0] = er;
-        auto f = resolveFuncCall(ad.loc, sc, assign, null, ad.type, ArgumentList(&a), FuncResolveFlag.quiet);
+        (*a)[0] = er;
+        auto f = resolveFuncCall(ad.loc, sc, assign, null, ad.type, ArgumentList(a), FuncResolveFlag.quiet);
         if (!f)
         {
-            a[0] = el;
-            f = resolveFuncCall(ad.loc, sc, assign, null, ad.type, ArgumentList(&a), FuncResolveFlag.quiet);
+            (*a)[0] = el;
+            f = resolveFuncCall(ad.loc, sc, assign, null, ad.type, ArgumentList(a), FuncResolveFlag.quiet);
         }
 
         sc = sc.pop();
@@ -465,7 +465,7 @@ private FuncDeclaration hasIdentityOpEquals(AggregateDeclaration ad, Scope* sc)
          */
         scope er = new NullExp(ad.loc, null); // dummy rvalue
         scope el = new IdentifierExp(ad.loc, Id.p); // dummy lvalue
-        auto a = Expressions(1);
+        auto a = new Expressions(1);
 
         bool hasIt(Type tthis)
         {
@@ -476,9 +476,9 @@ private FuncDeclaration hasIdentityOpEquals(AggregateDeclaration ad, Scope* sc)
 
             FuncDeclaration rfc(Expression e)
             {
-                a[0] = e;
-                a[0].type = tthis;
-                return resolveFuncCall(ad.loc, sc, eq, null, tthis, ArgumentList(&a), FuncResolveFlag.quiet);
+                (*a)[0] = e;
+                (*a)[0].type = tthis;
+                return resolveFuncCall(ad.loc, sc, eq, null, tthis, ArgumentList(a), FuncResolveFlag.quiet);
             }
 
             f = rfc(er);
@@ -1126,7 +1126,7 @@ private DtorDeclaration buildExternDDtor(AggregateDeclaration ad, Scope* sc)
         return null;
 
     // Generate shim only when ABI incompatible on target platform
-    if (ad.classKind != ClassKind.cpp || !target.cpp.wrapDtorInExternD)
+    if (dtor._linkage != LINK.cpp || !target.cpp.wrapDtorInExternD)
         return dtor;
 
     // generate member function that adjusts calling convention

diff --git a/dmd/compiler.d b/dmd/compiler.d
@@ -275,7 +275,7 @@ private struct MatcherNode
  * -i=-foo // include everything except modules that match "foo*"
  * -i=foo  // only include modules that match "foo*" (exclude everything else)
  * ---
- * Note that this default behavior can be overriden using the '.' module pattern. i.e.
+ * Note that this default behavior can be overridden using the '.' module pattern. i.e.
  * ---
  * -i=-foo,-.  // this excludes everything
  * -i=foo,.    // this includes everything except the default exclusions (-std,-core,-etc.-object)
@@ -402,7 +402,7 @@ private void parseModulePattern(const(char)* modulePattern, MatcherNode* dst, us
                 if (*modulePattern == '.')
                 {
                     assert(modulePattern > idStart, "empty module pattern");
-                    *dst = MatcherNode(Identifier.idPool(idStart, cast(uint)(modulePattern - idStart)));
+                    *dst = MatcherNode(Identifier.idPool(idStart[0 .. modulePattern - idStart]));
                     modulePattern++;
                     idStart = modulePattern;
                     break;
@@ -414,7 +414,7 @@ private void parseModulePattern(const(char)* modulePattern, MatcherNode* dst, us
             if (*modulePattern == '\0')
             {
                 assert(modulePattern > idStart, "empty module pattern");
-                *lastNode = MatcherNode(Identifier.idPool(idStart, cast(uint)(modulePattern - idStart)));
+                *lastNode = MatcherNode(Identifier.idPool(idStart[0 .. modulePattern - idStart]));
                 break;
             }
         }