diff --git a/VERSION b/VERSION
index d5aee89f2c..293e3e2891 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-v2.104.0
+v2.104.1-beta.1
diff --git a/compiler/src/dmd/canthrow.d b/compiler/src/dmd/canthrow.d
index 5ffa4260e4..89d5519b5d 100644
--- a/compiler/src/dmd/canthrow.d
+++ b/compiler/src/dmd/canthrow.d
@@ -118,7 +118,7 @@ extern (C++) /* CT */ BE canThrow(Expression e, FuncDeclaration func, bool mustN
                     {
                         auto sd = ts.sym;
                         const id = ce.f.ident;
-                        if (sd.postblit && isArrayConstructionOrAssign(id))
+                        if (sd.postblit && isArrayConstruction(id))
                         {
                             checkFuncThrows(ce, sd.postblit);
                             return;
diff --git a/compiler/src/dmd/dinterpret.d b/compiler/src/dmd/dinterpret.d
index 5b27a07339..ce7323f8d4 100644
--- a/compiler/src/dmd/dinterpret.d
+++ b/compiler/src/dmd/dinterpret.d
@@ -3890,7 +3890,7 @@ public:
             newval = copyLiteral(newval).copy();
             assignInPlace(oldval, newval);
         }
-        else if (wantCopy && e.op == EXP.assign)
+        else if (wantCopy && (e.op == EXP.assign || e.op == EXP.loweredAssignExp))
         {
             // Currently postblit/destructor calls on static array are done
             // in the druntime internal functions so they don't appear in AST.
@@ -4299,7 +4299,7 @@ public:
             rb.newval = newval;
             rb.refCopy = wantRef || cow;
             rb.needsPostblit = sd && sd.postblit && e.op != EXP.blit && e.e2.isLvalue();
-            rb.needsDtor = sd && sd.dtor && e.op == EXP.assign;
+            rb.needsDtor = sd && sd.dtor && (e.op == EXP.assign || e.op == EXP.loweredAssignExp);
             if (Expression ex = rb.assignTo(existingAE, cast(size_t)lowerbound, cast(size_t)upperbound))
                 return ex;
 
@@ -4773,12 +4773,11 @@ public:
                     result = CTFEExp.voidexp;
                 return;
             }
-            else if (isArrayConstructionOrAssign(fd.ident))
+            else if (isArrayConstruction(fd.ident))
             {
-                // In expressionsem.d, the following lowerings were performed:
-                // * `T[x] ea = eb;` to `_d_array{,set}ctor(ea[], eb[]);`.
-                // * `ea = eb` to `_d_array{,setassign,assign_l,assign_r}(ea[], eb)`.
-                // The following code will rewrite them back to `ea = eb` and
+                // In expressionsem.d, `T[x] ea = eb;` was lowered to:
+                // `_d_array{,set}ctor(ea[], eb[]);`.
+                // The following code will rewrite it back to `ea = eb` and
                 // then interpret that expression.
 
                 if (fd.ident == Id._d_arrayctor)
@@ -4791,17 +4790,14 @@ public:
                     ea = ea.isCastExp.e1;
 
                 Expression eb = (*e.arguments)[1];
-                if (eb.isCastExp() && fd.ident != Id._d_arraysetctor)
+                if (eb.isCastExp() && fd.ident == Id._d_arrayctor)
                     eb = eb.isCastExp.e1;
 
-                Expression rewrittenExp;
-                if (fd.ident == Id._d_arrayctor || fd.ident == Id._d_arraysetctor)
-                    rewrittenExp = new ConstructExp(e.loc, ea, eb);
-                else
-                    rewrittenExp = new AssignExp(e.loc, ea, eb);
+                ConstructExp ce = new ConstructExp(e.loc, ea, eb);
+                ce.type = ea.type;
 
-                rewrittenExp.type = ea.type;
-                result = interpret(rewrittenExp, istate);
+                ce.type = ea.type;
+                result = interpret(ce, istate);
 
                 return;
             }
diff --git a/compiler/src/dmd/escape.d b/compiler/src/dmd/escape.d
index c0dd17f2ea..f6e03821ab 100644
--- a/compiler/src/dmd/escape.d
+++ b/compiler/src/dmd/escape.d
@@ -93,22 +93,7 @@ bool checkMutableArguments(Scope* sc, FuncDeclaration fd, TypeFunction tf,
         bool isMutable;         // true if reference to mutable
     }
 
-    /* Store escapeBy as static data escapeByStorage so we can keep reusing the same
-     * arrays rather than reallocating them.
-     */
-    __gshared EscapeBy[] escapeByStorage;
-    auto escapeBy = escapeByStorage;
-    if (escapeBy.length < len)
-    {
-        auto newPtr = cast(EscapeBy*)mem.xrealloc(escapeBy.ptr, len * EscapeBy.sizeof);
-        // Clear the new section
-        memset(newPtr + escapeBy.length, 0, (len - escapeBy.length) * EscapeBy.sizeof);
-        escapeBy = newPtr[0 .. len];
-        escapeByStorage = escapeBy;
-    }
-    else
-        escapeBy = escapeBy[0 .. len];
-
+    auto escapeBy = new EscapeBy[len];
     const paramLength = tf.parameterList.length;
 
     // Fill in escapeBy[] with arguments[], ethis, and outerVars[]
@@ -228,13 +213,6 @@ bool checkMutableArguments(Scope* sc, FuncDeclaration fd, TypeFunction tf,
         escape(i, eb, false);
     }
 
-    /* Reset the arrays in escapeBy[] so we can reuse them next time through
-     */
-    foreach (ref eb; escapeBy)
-    {
-        eb.er.reset();
-    }
-
     return errors;
 }
 
@@ -2487,6 +2465,9 @@ bool isReferenceToMutable(Type t)
             }
             break;
 
+        case Tnull:
+            return false;
+
         default:
             assert(0);
     }
diff --git a/compiler/src/dmd/expression.d b/compiler/src/dmd/expression.d
index 440d0a520e..ae5746cf11 100644
--- a/compiler/src/dmd/expression.d
+++ b/compiler/src/dmd/expression.d
@@ -7425,23 +7425,20 @@ extern(D) Modifiable checkModifiable(Expression exp, Scope* sc, ModifyFlags flag
 }
 
 /**
- * Verify if the given identifier is any of
- * _d_array{ctor,setctor,setassign,assign_l, assign_r}.
+ * Verify if the given identifier is _d_array{,set}ctor.
  *
  * Params:
  *  id = the identifier to verify
  *
  * Returns:
- *  `true` if the identifier corresponds to a construction of assignement
- *  runtime hook, `false` otherwise.
+ *  `true` if the identifier corresponds to a construction runtime hook,
+ *  `false` otherwise.
  */
-bool isArrayConstructionOrAssign(const Identifier id)
+bool isArrayConstruction(const Identifier id)
 {
     import dmd.id : Id;
 
-    return id == Id._d_arrayctor || id == Id._d_arraysetctor ||
-        id == Id._d_arrayassign_l || id == Id._d_arrayassign_r ||
-        id == Id._d_arraysetassign;
+    return id == Id._d_arrayctor || id == Id._d_arraysetctor;
 }
 
 /******************************
diff --git a/compiler/src/dmd/expressionsem.d b/compiler/src/dmd/expressionsem.d
index 3121fdab54..73339de3ac 100644
--- a/compiler/src/dmd/expressionsem.d
+++ b/compiler/src/dmd/expressionsem.d
@@ -10362,6 +10362,9 @@ private extern (C++) final class ExpressionSemanticVisitor : Visitor
         if (global.params.verbose)
             message("lowered   %s =>\n          %s", ae.toChars(), res.toChars());
 
+        res = new LoweredAssignExp(ae, res);
+        res.type = ae.type;
+
         return res;
     }
 
diff --git a/compiler/src/dmd/opover.d b/compiler/src/dmd/opover.d
index 0e64d9c7c8..ea7915df78 100644
--- a/compiler/src/dmd/opover.d
+++ b/compiler/src/dmd/opover.d
@@ -416,9 +416,11 @@ Expression op_overload(Expression e, Scope* sc, EXP* pop = null)
                      *      op(e1.aliasthis)
                      */
                     //printf("att una %s e1 = %s\n", EXPtoString(op).ptr, this.e1.type.toChars());
-                    e.e1 = resolveAliasThis(sc, e.e1, true);
-                    if (e.e1)
+                    if (auto e1 = resolveAliasThis(sc, e.e1, true))
+                    {
+                        e.e1 = e1;
                         continue;
+                    }
                     break;
                 }
                 break;
diff --git a/compiler/test/compilable/stdcheaders.c b/compiler/test/compilable/stdcheaders.c
index ea193c36e4..d89bf72fff 100644
--- a/compiler/test/compilable/stdcheaders.c
+++ b/compiler/test/compilable/stdcheaders.c
@@ -65,10 +65,12 @@
 #ifndef __DMC__ // no tgmath.h
 #ifndef _MSC_VER // C:\Program Files (x86)\Windows Kits\10\include\10.0.22621.0\ucrt\tgmath.h(33): Error: no type for declarator before `)`
 #ifndef __APPLE__ // /Applications/Xcode-14.2.0.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/include/tgmath.h(39): Error: named parameter required before `...`
+#if !(defined(__linux__) && defined(__aarch64__)) // /tmp/clang/lib/clang/15.0.3/include/tgmath.h(34): Error: named parameter required before `...`
 #include <tgmath.h>
 #endif
 #endif
 #endif
+#endif
 
 #ifndef __DMC__
 #ifndef __linux__
diff --git a/compiler/test/compilable/test23978.d b/compiler/test/compilable/test23978.d
new file mode 100644
index 0000000000..cc30f728de
--- /dev/null
+++ b/compiler/test/compilable/test23978.d
@@ -0,0 +1,30 @@
+// REQUIRED_ARGS: -preview=dip1021 -lowmem
+// https://issues.dlang.org/show_bug.cgi?id=23978
+
+// Note: this is a memory corruption bug.
+// Memory returned by `GC.realloc` retains references to old memory in it,
+// mostly because of the smallarray optimization for `Array(T)`.
+// If this fails again, it might not be consistent, so try running it multiple times.
+
+class LUBench { }
+void lup(ulong , ulong , int , int = 1)
+{
+    new LUBench;
+}
+void lup_3200(ulong iters, ulong flops)
+{
+    lup(iters, flops, 3200);
+}
+void raytrace()
+{
+    struct V
+    {
+        float x, y, z;
+        auto normalize() { }
+        struct Tid { }
+        auto spawnLinked() { }
+        string[] namesByTid;
+        class MessageBox { }
+        auto cross() { }
+    }
+}
diff --git a/compiler/test/compilable/test23979.d b/compiler/test/compilable/test23979.d
new file mode 100644
index 0000000000..f7eb2c554e
--- /dev/null
+++ b/compiler/test/compilable/test23979.d
@@ -0,0 +1,17 @@
+// REQUIRED_ARGS: -o-
+// https://issues.dlang.org/show_bug.cgi?id=23979
+// Issue 23979 - ICE on failed alias this attempt on pointer expression
+
+class A {}
+
+void h()
+{
+    const auto classPtr = SPtr.init;
+    assert(!__traits(compiles, *classPtr));
+}
+
+struct SPtr
+{
+    A ptr() { return A.init; }
+    alias ptr this;
+}
diff --git a/compiler/test/compilable/test23986.d b/compiler/test/compilable/test23986.d
new file mode 100644
index 0000000000..6bbf1c2aea
--- /dev/null
+++ b/compiler/test/compilable/test23986.d
@@ -0,0 +1,11 @@
+// REQUIRED_ARGS: -preview=dip1021 -o-
+// https://issues.dlang.org/show_bug.cgi?id=23986
+// dip1021 asserts on `typeof(null)` parameter
+@safe:
+
+void f(typeof(null) obj, int* x) {}
+
+void g()
+{
+    f(null, null);
+}
diff --git a/compiler/test/fail_compilation/failcstuff4.i b/compiler/test/fail_compilation/failcstuff4b.i
similarity index 62%
rename from compiler/test/fail_compilation/failcstuff4.i
rename to compiler/test/fail_compilation/failcstuff4b.i
index df26647a5c..66ee757894 100644
--- a/compiler/test/fail_compilation/failcstuff4.i
+++ b/compiler/test/fail_compilation/failcstuff4b.i
@@ -1,6 +1,6 @@
 /* TEST_OUTPUT:
 ---
-fail_compilation/failcstuff4.i(605): Error: invalid flag for line marker directive
+fail_compilation/failcstuff4b.i(605): Error: invalid flag for line marker directive
 ---
 */
 
diff --git a/compiler/test/runnable/test23959.d b/compiler/test/runnable/test23959.d
new file mode 100644
index 0000000000..32883736d4
--- /dev/null
+++ b/compiler/test/runnable/test23959.d
@@ -0,0 +1,30 @@
+// https://issues.dlang.org/show_bug.cgi?id=23959;
+
+struct ST()
+{
+    int i;
+    this(this) {}
+}
+
+alias S = ST!();
+
+void poison()
+{
+    static S g;
+    auto s = g;
+}
+
+S[1] sa;
+
+void fun(S[] values...)
+{
+    sa[] = values;
+}
+
+int main()
+{
+    fun(S(1));
+    assert(sa[0].i);
+
+    return 0;
+}
diff --git a/druntime/src/importc.h b/druntime/src/importc.h
index 88cd1353bd..68443ba125 100644
--- a/druntime/src/importc.h
+++ b/druntime/src/importc.h
@@ -141,9 +141,11 @@
 // Ubuntu's assert.h uses this
 #define __PRETTY_FUNCTION__ __func__
 
+#ifndef __aarch64__
 #define _Float128 long double
 #define __float128 long double
 #endif
+#endif
 
 #if __APPLE__
 #undef __SIZEOF_INT128__