Rework some more

Author: kinke

src/dmd/ctorflow.d

@@ -97,7 +97,7 @@ struct CtorFlow
             {
                 auto fi = &fieldinit[i];
                 fi.csx |= u.csx;
-                if (fi.loc == Loc.init)
+                if (fi.loc is Loc.init)
                     fi.loc = u.loc;
             }
         }

src/dmd/dscope.d

@@ -292,7 +292,7 @@ struct Scope
                 bool mustInit = (v.storage_class & STC.nodefaultctor || v.type.needsNested());
                 auto fieldInit = &this.ctorflow.fieldinit[i];
                 const fiesCurrent = fies[i];
-                if (fieldInit.loc == Loc.init)
+                if (fieldInit.loc is Loc.init)
                     fieldInit.loc = fiesCurrent.loc;
                 if (!mergeFieldInit(this.ctorflow.fieldinit[i].csx, fiesCurrent.csx) && mustInit)
                 {

src/dmd/globals.d

@@ -462,28 +462,42 @@ nothrow:
         return buf.extractString();
     }
 
+    /* Checks for equivalence,
+     * a) comparing the filename contents (not the pointer), case-
+     *    insensitively on Windows, and
+     * b) ignoring charnum if `global.params.showColumns` is false.
+     */
     extern (C++) bool equals(ref const(Loc) loc) const
     {
         return (!global.params.showColumns || charnum == loc.charnum) &&
                linnum == loc.linnum &&
                FileName.equals(filename, loc.filename);
     }
 
-    extern (D) bool opEquals(Loc loc) const pure
+    /* opEquals() / toHash() for AA key usage:
+     *
+     * Compare filename contents (case-sensitively on Windows too), not
+     * the pointer - a static foreach loop repeatedly mixing in a mixin
+     * may lead to multiple equivalent filenames (`foo.d-mixin-<line>`),
+     * e.g., for test/runnable/test18880.d.
+     */
+    extern (D) bool opEquals(ref const(Loc) loc) const @trusted pure nothrow @nogc
     {
+        import core.stdc.string : strcmp;
+
         return charnum == loc.charnum &&
                linnum == loc.linnum &&
-               FileName.equals(filename, loc.filename);
+               (filename == loc.filename ||
+                (filename && loc.filename && strcmp(filename, loc.filename) == 0));
     }
 
-    extern (D) hash_t toHash() const pure
+    extern (D) size_t toHash() const @trusted pure nothrow
     {
-        import dmd.root.hash;
-        import dmd.utils;
+        import dmd.utils : toDString;
 
         auto hash = hashOf(linnum);
-        hash = mixHash(hash, hashOf(charnum));
-        hash = mixHash(hash, hashOf(filename.toDString));
+        hash = hashOf(charnum, hash);
+        hash = hashOf(filename.toDString, hash);
         return hash;
     }
 

src/dmd/identifier.d

@@ -163,25 +163,42 @@ nothrow:
         idBuf.print(loc.charnum);
 
         /**
-         * Make sure the identifiers are unique per module. See issues
+         * Make sure the identifiers are unique per filename, i.e., per module/mixin
+         * (`path/to/foo.d` and `path/to/foo.d-mixin-<line>`). See issues
          * https://issues.dlang.org/show_bug.cgi?id=16995
          * https://issues.dlang.org/show_bug.cgi?id=18097
          * https://issues.dlang.org/show_bug.cgi?id=18111
          * https://issues.dlang.org/show_bug.cgi?id=18880
          * https://issues.dlang.org/show_bug.cgi?id=18868
-         * https://issues.dlang.org/show_bug.cgi?id=19058.
+         * https://issues.dlang.org/show_bug.cgi?id=19058
          */
         static struct Key { Loc loc; string prefix; }
         __gshared uint[Key] counters;
 
-        const key = Key(loc, prefix);
-        if (auto pCounter = key in counters)
+        static if (__traits(compiles, counters.update(Key.init, () => 0u, (ref uint a) => 0u)))
         {
-            idBuf.writestring("_");
-            idBuf.print((*pCounter)++);
+            // 2.082+
+            counters.update(Key(loc, prefix),
+                () => 1u,          // insertion
+                (ref uint counter) // update
+                {
+                    idBuf.writestring("_");
+                    idBuf.print(counter);
+                    return counter + 1;
+                }
+            );
         }
         else
-            counters[key] = 1;
+        {
+            const key = Key(loc, prefix);
+            if (auto pCounter = key in counters)
+            {
+                idBuf.writestring("_");
+                idBuf.print((*pCounter)++);
+            }
+            else
+                counters[key] = 1;
+        }
 
         return idPool(idBuf.peekSlice());
     }