Merge pull request dlang#22228 from dlang/stable

dkorpel · web-flow · commit 87e60f539393 · 2025-12-12T16:00:58.000+01:00
Merge stable
diff --git a/VERSION b/VERSION
@@ -1 +1 @@
-v2.112.0-beta.1
+v2.112.0
diff --git a/compiler/src/dmd/aggregate.h b/compiler/src/dmd/aggregate.h
@@ -171,7 +171,6 @@ class StructDeclaration : public AggregateDeclaration
     static StructDeclaration *create(Loc loc, Identifier *id, bool inObject);
     StructDeclaration *syntaxCopy(Dsymbol *s) override;
     const char *kind() const override;
-    bool isPOD();
     bool zeroInit() const;          // !=0 if initialize with 0 fill
     bool zeroInit(bool v);
     bool hasIdentityAssign() const; // true if has identity opAssign
diff --git a/compiler/src/dmd/cxxfrontend.d b/compiler/src/dmd/cxxfrontend.d
@@ -512,6 +512,12 @@ PURE isPure(FuncDeclaration fd)
     return dmd.funcsem.isPure(fd);
 }
 
+bool needsClosure(FuncDeclaration fd)
+{
+    import dmd.funcsem;
+    return dmd.funcsem.needsClosure(fd);
+}
+
 /***********************************************************
  * hdrgen.d
  */
diff --git a/compiler/src/dmd/declaration.h b/compiler/src/dmd/declaration.h
@@ -37,11 +37,12 @@ namespace dmd
     bool checkClosure(FuncDeclaration* fd);
     MATCH leastAsSpecialized(FuncDeclaration *f, FuncDeclaration *g, ArgumentLabels *names);
     PURE isPure(FuncDeclaration *f);
+    bool needsClosure(FuncDeclaration *fd);
     FuncDeclaration *genCfunc(Parameters *args, Type *treturn, const char *name, StorageClass stc=0);
     FuncDeclaration *genCfunc(Parameters *args, Type *treturn, Identifier *id, StorageClass stc=0);
     bool isAbstract(ClassDeclaration *cd);
     bool overloadInsert(Dsymbol *ds, Dsymbol *s);
-    bool equals(const Dsymbol *ds, const Dsymbol *s);
+    bool equals(const Dsymbol * const ds, const Dsymbol * const s);
 }
 
 //enum STC : ulong from astenums.d:
@@ -719,7 +720,6 @@ class FuncDeclaration : public Declaration
     virtual bool addPreInvariant();
     virtual bool addPostInvariant();
     const char *kind() const override;
-    bool needsClosure();
     bool hasNestedFrameRefs();
     ParameterList getParameterList();
 
diff --git a/compiler/src/dmd/dsymbolsem.d b/compiler/src/dmd/dsymbolsem.d
@@ -3864,24 +3864,6 @@ private extern(C++) final class DsymbolSemanticVisitor : Visitor
         sc.stc &= ~STC.static_; // not a static constructor
 
         funcDeclarationSemantic(sc, ctd);
-        // Check short constructor: this() => expr;
-        if (ctd.fbody)
-        {
-            if (auto s = ctd.fbody.isExpStatement())
-            {
-                if (s.exp)
-                {
-                    auto ce = s.exp.isCallExp();
-                    // check this/super before semantic
-                    if (!ce || (!ce.e1.isThisExp() && !ce.e1.isSuperExp()))
-                    {
-                        s.exp = s.exp.expressionSemantic(sc);
-                        if (s.exp.type.ty != Tvoid)
-                            error(s.loc, "can only return void expression, `this` call or `super` call from constructor");
-                    }
-                }
-            }
-        }
 
         sc.pop();
 
@@ -9397,7 +9379,7 @@ bool isAbstract(ClassDeclaration cd)
         static int virtualSemantic(Dsymbol s, void*)
         {
             auto fd = s.isFuncDeclaration();
-            if (fd && !(fd.storage_class & STC.static_) && !fd.isUnitTestDeclaration())
+            if (fd && !(fd.storage_class & STC.static_) && !fd.isUnitTestDeclaration() && !fd.isCtorDeclaration())
                 fd.dsymbolSemantic(null);
             return 0;
         }
diff --git a/compiler/src/dmd/globals.h b/compiler/src/dmd/globals.h
@@ -328,6 +328,7 @@ struct CompileEnv
     d_bool transitionIn;
     d_bool ddocOutput;
     d_bool masm;
+    DString switchPrefix;
     IdentifierCharLookup cCharLookupTable;
     IdentifierCharLookup dCharLookupTable;
 };
diff --git a/compiler/src/dmd/parse.d b/compiler/src/dmd/parse.d
@@ -5332,10 +5332,7 @@ class Parser(AST, Lexer = dmd.lexer.Lexer) : Lexer
                 error("missing `do { ... }` after `in` or `out`");
             const returnloc = token.loc;
             nextToken();
-            if (f.isCtorDeclaration)
-                f.fbody = new AST.ExpStatement(returnloc, parseExpression());
-            else
-                f.fbody = new AST.ReturnStatement(returnloc, parseExpression());
+            f.fbody = new AST.ReturnStatement(returnloc, parseExpression());
             f.endloc = token.loc;
             check(TOK.semicolon);
             break;
diff --git a/compiler/src/dmd/semantic3.d b/compiler/src/dmd/semantic3.d
@@ -1458,6 +1458,10 @@ private extern(C++) final class Semantic3Visitor : Visitor
         if (ctor.semanticRun >= PASS.semantic3)
             return;
 
+        if (!ctor.fbody)
+            return visit(cast(FuncDeclaration)ctor);
+
+
         /* If any of the fields of the aggregate have a destructor, add
          *   scope (failure) { this.fieldDtor(); }
          * as the first statement of the constructor (unless the constructor
@@ -1468,7 +1472,7 @@ private extern(C++) final class Semantic3Visitor : Visitor
          * https://issues.dlang.org/show_bug.cgi?id=14246
          */
         AggregateDeclaration ad = ctor.isMemberDecl();
-        if (!ctor.fbody || !ad || !ad.fieldDtor ||
+        if (!ad || !ad.fieldDtor ||
             global.params.dtorFields == FeatureState.disabled || !global.params.useExceptions || ctor.type.toTypeFunction.isNothrow)
             return visit(cast(FuncDeclaration)ctor);
 
@@ -1541,7 +1545,6 @@ private extern(C++) final class Semantic3Visitor : Visitor
         visit(cast(FuncDeclaration)ctor);
     }
 
-
     override void visit(Nspace ns)
     {
         if (ns.semanticRun >= PASS.semantic3)
diff --git a/compiler/src/dmd/statementsem.d b/compiler/src/dmd/statementsem.d
@@ -2545,16 +2545,44 @@ Statement statementSemanticVisit(Statement s, Scope* sc)
 
         if (fd.isCtorDeclaration())
         {
-            if (rs.exp)
+            // Constructors implicitly do:
+            //      return this;
+            auto ctorReturn = new ThisExp(Loc.initial);
+            ctorReturn.type = tret;
+
+            bool isConstructorCall(Expression e)
             {
-                error(rs.loc, "cannot return expression from constructor");
-                errors = true;
+                auto ce = e.isCallExp();
+                if (!ce)
+                    return false;
+
+                auto dve = ce.e1.isDotVarExp();
+                if (!dve)
+                    return false;
+
+                return dve.var.isThis !is null;
             }
 
-            // Constructors implicitly do:
-            //      return this;
-            rs.exp = new ThisExp(Loc.initial);
-            rs.exp.type = tret;
+            if (rs.exp)
+            {
+                rs.exp = rs.exp.expressionSemantic(sc);
+
+                if (rs.exp.type.ty != Tvoid && !isConstructorCall(rs.exp))
+                {
+
+                    error(rs.loc, "can only return void expression, `this` call or `super` call from constructor");
+                    errors = true;
+                    rs.exp = ErrorExp.get();
+                }
+                else
+                {
+                    rs.exp = new CommaExp(rs.loc, rs.exp, ctorReturn).expressionSemantic(sc);
+                }
+            }
+            else
+            {
+                rs.exp = ctorReturn;
+            }
         }
         else if (rs.exp)
         {
diff --git a/compiler/test/compilable/shortened_methods.d b/compiler/test/compilable/shortened_methods.d
@@ -22,6 +22,8 @@ class A {
 class B : A{
     // short syntax also overrides the same as long syntax
     override bool isNull() => this !is null;
+
+    this(float y) => super(y);
 }
 
 static assert((new A).x == 34);
@@ -46,6 +48,11 @@ struct T
     void inc() {}
     this(this) => inc();
 
+    // https://github.com/dlang/dmd/issues/21576
+    this(int) => inc();
+
+    this(byte) { return inc(); }
+
     void free() {}
     ~this() => free();
 }
diff --git a/compiler/test/fail_compilation/fail12901.d b/compiler/test/fail_compilation/fail12901.d
diff --git a/compiler/test/fail_compilation/fail_contracts5.d b/compiler/test/fail_compilation/fail_contracts5.d
@@ -0,0 +1,34 @@
+
+/*
+TEST_OUTPUT:
+---
+fail_compilation/fail_contracts5.d(13): Error: constructor `fail_contracts5.S.this` `in` and `out` contracts can only appear without a body when they are virtual interface functions or abstract
+---
+*/
+
+// bugzilla 12901
+struct S
+{
+    int a;
+    this(int n)
+    in { a = n; }
+    // no body
+}
+
+/*
+TEST_OUTPUT:
+---
+fail_compilation/fail_contracts5.d(33): Error: function `fail_contracts5.C2.foo` `in` and `out` contracts can only appear without a body when they are virtual interface functions or abstract
+fail_compilation/fail_contracts5.d(32): Error: constructor `fail_contracts5.C2.this` `in` and `out` contracts can only appear without a body when they are virtual interface functions or abstract
+---
+*/
+// https://github.com/dlang/dmd/issues/21403
+abstract class C1 {}
+
+class C2 : C1
+{
+    bool member;
+
+    this() out (member) {}
+    final void foo() out (member) {}
+}
diff --git a/compiler/test/fail_compilation/failexpression3.d b/compiler/test/fail_compilation/failexpression3.d
diff --git a/compiler/test/fail_compilation/failexpression4.d b/compiler/test/fail_compilation/failexpression4.d
diff --git a/druntime/src/core/internal/cast_.d b/druntime/src/core/internal/cast_.d
