adjust return scope detection (dlang#21369)

WalterBright · web-flow · commit a010245cb0b3 · 2025-05-27T00:19:43.000+02:00
diff --git a/compiler/src/dmd/astenums.d b/compiler/src/dmd/astenums.d
@@ -77,9 +77,10 @@ enum STC : ulong  // transfer changes to declaration.h
     ref_                = 0x4_0000,   /// `ref`
     scope_              = 0x8_0000,   /// `scope`
 
-    scopeinferred       = 0x20_0000,   /// `scope` has been inferred and should not be part of mangling, `scope_` must also be set
-    return_             = 0x40_0000,   /// 'return ref' or 'return scope' for function parameters
-    returnScope         = 0x80_0000,   /// if `ref return scope` then resolve to `ref` and `return scope`
+    scopeinferred       = 0x10_0000,   /// `scope` has been inferred and should not be part of mangling, `scope_` must also be set
+    return_             = 0x20_0000,   /// 'return ref' or 'return scope' for function parameters
+    returnScope         = 0x40_0000,   /// if `ref return scope` then resolve to `ref` and `return scope`
+    returnRef           = 0x80_0000,   /// if `return ref`
 
     returninferred      = 0x100_0000,   /// `return` has been inferred and should not be part of mangling, `return_` must also be set
     immutable_          = 0x200_0000,   /// `immutable`
diff --git a/compiler/src/dmd/declaration.h b/compiler/src/dmd/declaration.h
@@ -71,9 +71,10 @@ namespace dmd
     #define STCref                0x40000ULL    /// `ref`
     #define STCscope              0x80000ULL    /// `scope`
 
-    #define STCscopeinferred      0x200000ULL    /// `scope` has been inferred and should not be part of mangling, `scope` must also be set
-    #define STCreturn             0x400000ULL    /// 'return ref' or 'return scope' for function parameters
-    #define STCreturnScope        0x800000ULL    /// if `ref return scope` then resolve to `ref` and `return scope`
+    #define STCscopeinferred      0x100000ULL    /// `scope` has been inferred and should not be part of mangling, `scope` must also be set
+    #define STCreturn             0x200000ULL    /// 'return ref' or 'return scope' for function parameters
+    #define STCreturnScope        0x400000ULL    /// if `ref return scope` then resolve to `ref` and `return scope`
+    #define STCreturnRef          0x800000ULL,   /// if `return ref`
 
     #define STCreturninferred     0x1000000ULL    /// `return` has been inferred and should not be part of mangling, `return` must also be set
     #define STCimmutable          0x2000000ULL    /// `immutable`
diff --git a/compiler/src/dmd/expressionsem.d b/compiler/src/dmd/expressionsem.d
@@ -2373,7 +2373,7 @@ private bool checkNogc(FuncDeclaration f, ref Loc loc, Scope* sc)
  *   t = struct type, or static array of struct type to check
  *   loc = error message location
  *   sc = scope in which attributes are checked
- * Returns: true if there's an error
+ * Returns: true if there is an error
  */
 private bool checkPostblit(Type t, ref Loc loc, Scope* sc)
 {
@@ -15531,7 +15531,7 @@ Expression addDtorHook(Expression e, Scope* sc)
 /*******************************
  * Try to convert an expression to be an lvalue.
  *
- * Give error if we're not an lvalue.
+ * Give error if we are not an lvalue.
  * Params:
  *     _this = expression to convert
  *     sc = scope
@@ -15546,6 +15546,7 @@ Expression toLvalue(Expression _this, Scope* sc, const(char)* action)
 // e = original un-lowered expression for error messages, in case of recursive calls
 private Expression toLvalueImpl(Expression _this, Scope* sc, const(char)* action, Expression e)
 {
+    //printf("toLvalueImpl() %s\n", _this.toChars());
     if (!action)
         action = "create lvalue of";
 
@@ -15643,7 +15644,7 @@ private Expression toLvalueImpl(Expression _this, Scope* sc, const(char)* action
     {
         auto e1 = _this.e1;
         auto var = _this.var;
-        //printf("DotVarExp::toLvalue(%s)\n", toChars());
+        //printf("DotVarExp::toLvalue(%s)\n", _this.toChars());
         if (sc && sc.inCfile)
         {
             /* C11 6.5.2.3-3: A postfix expression followed by the '.' or '->' operator
diff --git a/compiler/src/dmd/frontend.h b/compiler/src/dmd/frontend.h
@@ -772,9 +772,10 @@ enum class STC : uint64_t
     templateparameter = 131072LLU,
     ref_ = 262144LLU,
     scope_ = 524288LLU,
-    scopeinferred = 2097152LLU,
-    return_ = 4194304LLU,
-    returnScope = 8388608LLU,
+    scopeinferred = 1048576LLU,
+    return_ = 2097152LLU,
+    returnScope = 4194304LLU,
+    returnRef = 8388608LLU,
     returninferred = 16777216LLU,
     immutable_ = 33554432LLU,
     manifest = 134217728LLU,
@@ -809,9 +810,9 @@ enum class STC : uint64_t
     IOR = 333824LLU,
     TYPECTOR = 42983227396LLU,
     FUNCATTR = 4575000774574080LLU,
-    visibleStorageClasses = 7954966262857631LLU,
+    visibleStorageClasses = 7954966260760479LLU,
     flowThruAggregate = 962072674304LLU,
-    flowThruFunction = 18446742978991225440LLU,
+    flowThruFunction = 18446742978993322592LLU,
 };
 
 template <typename T>
diff --git a/compiler/src/dmd/hdrgen.d b/compiler/src/dmd/hdrgen.d
@@ -1814,7 +1814,7 @@ void toCBuffer(Dsymbol s, ref OutBuffer buf, ref HdrGenState hgs)
 
         // https://issues.dlang.org/show_bug.cgi?id=24891
         // return/scope storage classes are printed as part of function type
-        if (stcToBuffer(buf, f.storage_class & ~(STC.scope_ | STC.return_ | STC.returnScope)))
+        if (stcToBuffer(buf, f.storage_class & ~(STC.scope_ | STC.return_ | STC.returnScope | STC.returnRef)))
             buf.writeByte(' ');
         typeToBuffer(f.type, f.ident, buf, hgs);
         auto tf = f.type.isTypeFunction();
diff --git a/compiler/src/dmd/objc_glue.d b/compiler/src/dmd/objc_glue.d
@@ -1617,7 +1617,7 @@ void xoffOrNull(ref DtBuilder dtb, Symbol* symbol) @safe
  *  given buffer `buffer`
  */
 const(char)* toStringz(size_t maxLength = 4095)(in const(char)[] str,
-    scope return void[] buffer = alloca(maxLength + 1)[0 .. maxLength + 1]) pure
+    return scope void[] buffer = alloca(maxLength + 1)[0 .. maxLength + 1]) pure
 in
 {
     assert(maxLength >= str.length);
diff --git a/compiler/src/dmd/parse.d b/compiler/src/dmd/parse.d
@@ -1286,6 +1286,38 @@ class Parser(AST, Lexer = dmd.lexer.Lexer) : Lexer
             return orig;
         }
 
+        if (0) // replace this with -preview=return in next PR
+            switch (orig & (STC.out_ | STC.ref_ | STC.scope_ | STC.return_))
+            {
+                case STC.return_ | STC.ref_:
+                    if (!(orig & STC.returnRef))
+                        error("`return` `ref` attribute pair must be written as '`return ref`'");
+                    break;
+
+                case STC.return_ | STC.out_:
+                    if (!(orig & STC.returnRef))
+                        error("`return` `out` attribute pair must be written as '`return out`'");
+                    break;
+
+                case STC.return_ | STC.scope_:
+                    if (!(orig & STC.returnScope))
+                        error("`return` `scope` attribute pair must be written as '`return scope`'");
+                    break;
+
+                case STC.return_ | STC.ref_ | STC.scope_:
+                    if (!(orig & (STC.returnRef | STC.returnScope)))
+                        error("`return` `ref` `scope` attribute triple must be written as '`return ref`' and '`scope`' or '`return scope`' and '`ref`'");
+                    break;
+
+                case STC.return_ | STC.out_ | STC.scope_:
+                    if (!(orig & (STC.returnRef | STC.returnScope)))
+                        error("`return` `out` `scope` attribute triple must be written as '`return out`' and '`scope`' or '`return scope`' and '`out`'");
+                    break;
+
+                default:
+                    break;
+            }
+
         checkConflictSTCGroup(STC.const_ | STC.immutable_ | STC.manifest);
         checkConflictSTCGroup(STC.gshared | STC.shared_);
         checkConflictSTCGroup!true(STC.safeGroup);
@@ -1397,6 +1429,7 @@ class Parser(AST, Lexer = dmd.lexer.Lexer) : Lexer
      */
     private STC parsePostfix(STC storageClass, AST.Expressions** pudas)
     {
+        const STC prefix = storageClass;
         while (1)
         {
             STC stc;
@@ -1427,10 +1460,23 @@ class Parser(AST, Lexer = dmd.lexer.Lexer) : Lexer
                 break;
 
             case TOK.return_:
+            {
                 stc = STC.return_;
-                if (peekNext() == TOK.scope_)
-                    stc |= STC.returnScope;     // recognize `return scope`
+                TOK next = peekNext();
+                if (next == TOK.scope_)     // recognize the `return scope` pair
+                {
+                    stc |= STC.scope_ | STC.returnScope;
+                    nextToken();            // consume it
+                }
+                else if (next == TOK.ref_)  // recognize the `return ref` pair
+                {
+                    stc |= STC.ref_ | STC.returnRef;
+                    nextToken();            // consume it
+                }
+                else if (prefix & STC.ref_) // https://dlang.org/spec/function.html#struct-return-methods
+                    stc |= STC.returnRef;   // treat member function `ref int fp() return;` as `int fp() return ref;`
                 break;
+            }
 
             case TOK.scope_:
                 stc = STC.scope_;
@@ -1469,6 +1515,14 @@ class Parser(AST, Lexer = dmd.lexer.Lexer) : Lexer
                     nextToken();
                     continue;
                 }
+
+                /* This is so we can enforce `return ref`, but not foul things up with an extra `ref`
+                 * which is not accounted for in the semantic routines. The problem comes about because
+                 * there's no way to attach `return ref` to the implicit `this` parameter but not the return value.
+                 */
+                if (!(prefix & STC.ref_) && storageClass & STC.ref_ && storageClass & STC.returnRef)
+                    storageClass &= ~STC.ref_;
+
                 return storageClass;
             }
             storageClass = appendStorageClass(storageClass, stc);
@@ -2813,7 +2867,7 @@ class Parser(AST, Lexer = dmd.lexer.Lexer) : Lexer
         STC varargsStc;
 
         // Attributes allowed for ...
-        enum VarArgsStc = STC.const_ | STC.immutable_ | STC.shared_ | STC.scope_ | STC.return_ | STC.returnScope;
+        enum VarArgsStc = STC.const_ | STC.immutable_ | STC.shared_ | STC.scope_ | STC.return_ | STC.returnScope | STC.returnRef;
 
         check(TOK.leftParenthesis);
         while (1)
@@ -2924,10 +2978,26 @@ class Parser(AST, Lexer = dmd.lexer.Lexer) : Lexer
                     goto L2;
 
                 case TOK.return_:
+                {
                     stc = STC.return_;
-                    if (peekNext() == TOK.scope_)
-                        stc |= STC.returnScope;
+                    TOK next = peekNext();
+                    if (next == TOK.scope_)    // recognize the `return scope` pair
+                    {
+                        stc |= STC.scope_ | STC.returnScope;
+                        nextToken();           // consume it
+                    }
+                    else if (next == TOK.ref_) // recognize the `return ref` pair
+                    {
+                        stc |= STC.ref_ | STC.returnRef;
+                        nextToken();           // consume it
+                    }
+                    else if (next == TOK.out_) // recognize the `return out` pair
+                    {
+                        stc |= STC.out_ | STC.returnRef;
+                        nextToken();           // consume it
+                    }
                     goto L2;
+                }
                 L2:
                     storageClass = appendStorageClass(storageClass, stc);
                     continue;
diff --git a/compiler/test/compilable/extra-files/header1.d b/compiler/test/compilable/extra-files/header1.d
@@ -566,7 +566,7 @@ struct SafeS
 {
     this(int[1] x) scope {}
 	this(int[2] x) return scope {}
-	this(int[3] x) scope return {}
+	this(int[3] x) return ref scope {}
 	this(int[4] x) return {}
 
 @safe:
diff --git a/compiler/test/compilable/shared.d b/compiler/test/compilable/shared.d
@@ -5,7 +5,7 @@ pure nothrow @nogc ref @safe shared(C1)(return ref shared(C1) c)
 pure nothrow @nogc ref @safe shared(int)(return ref shared(C3) c)
 ---
 */
-ref shared(int) f(return shared ref int y)
+ref shared(int) f(return ref shared int y)
 {
     return y;
 }
@@ -97,7 +97,7 @@ shared(C2)* test_dotvarexp_4(return ref shared C3 c)
     return &c.c2;
 }
 
-ref shared(int) test_dotvarexp_5(return shared ref C3 c)
+ref shared(int) test_dotvarexp_5(return ref shared C3 c)
 {
     return c.c1.c1.value;
 }
diff --git a/compiler/test/compilable/test23169.d b/compiler/test/compilable/test23169.d
@@ -5,7 +5,7 @@ struct Ptr
 {
 	int* impl;
 	void* fun0() return scope {return impl;}
-	void* fun1() scope return {return impl;}
+	void* fun1() scope return ref {return impl;}
 	void* fun2() return {return &this;}
 }
 
diff --git a/compiler/test/compilable/testsctreturn.d b/compiler/test/compilable/testsctreturn.d
@@ -27,7 +27,7 @@ struct S
     int i;
     int* ptr;
 
-    int* wannabeReturnRef() scope return
+    int* wannabeReturnRef() return ref scope
     {
         return &i;
     }
diff --git a/compiler/test/fail_compilation/fix22108.d b/compiler/test/fail_compilation/fix22108.d
@@ -7,7 +7,7 @@ fail_compilation/fix22108.d(12): Error: returning scope variable `p` is not allo
 
 // https://issues.dlang.org/show_bug.cgi?id=22108
 
-@safe ref int test(ref scope return int* p)
+@safe ref int test(return ref scope int* p)
 {
     return *p;
 }
diff --git a/compiler/test/fail_compilation/pull12941.d b/compiler/test/fail_compilation/pull12941.d
@@ -18,11 +18,11 @@ fail_compilation/pull12941.d(105):        `pull12941.abc(return ref int* p)` dec
 
 #line 100
 
-int* foo(ref scope return int* p);
-int* foo(out scope return int* p);
+int* foo(return ref scope int* p);
+int* foo(return out scope int* p);
 
-int* bar(scope return int* p);
-int* abc(ref return int* p);
+int* bar(return scope int* p);
+int* abc(return ref int* p);
 
 void test()
 {
diff --git a/compiler/test/fail_compilation/retscope2.d b/compiler/test/fail_compilation/retscope2.d
@@ -130,7 +130,7 @@ fail_compilation/retscope2.d(721): Error: returning `s.get1()` escapes a referen
 
 struct S700
 {
-    @safe S700* get1() scope return
+    @safe S700* get1() return ref scope
     {
         return &this;
     }
diff --git a/compiler/test/fail_compilation/shared.d b/compiler/test/fail_compilation/shared.d
@@ -153,13 +153,13 @@ shared(int)* test_dotvarexp_3(return shared C1* c)
 }
 
 // First level DotVarExp dereferencing
-ref shared(int) test_dotvarexp_4(return shared ref C2 c)
+ref shared(int) test_dotvarexp_4(return ref shared C2 c)
 {
     return c.c1.value;
 }
 
 // Second level DotVarExp dereferencing
-ref shared(int) test_dotvarexp_5(return shared ref C3 c)
+ref shared(int) test_dotvarexp_5(return ref shared C3 c)
 {
     return c.c1.c1.value;
 }
@@ -201,7 +201,7 @@ ref shared(K1) test_newexp_1()
 // Inference tests
 
 // Fails because no `ref`
-auto test_inference_1(return shared ref C3 c)
+auto test_inference_1(return ref shared C3 c)
 {
     return c;
 }
@@ -221,7 +221,7 @@ auto ref test_inference_3()
 }
 
 // Fails because `const` conversion
-auto ref Object test_inference_4(const return shared ref Object a)
+auto ref Object test_inference_4(const return ref shared Object a)
 {
     return a;
 }
diff --git a/compiler/test/fail_compilation/test15191.d b/compiler/test/fail_compilation/test15191.d
@@ -25,8 +25,8 @@ int* bar(return ref int s)
     return &foo(s);
 }
 
-ref int identity(ref return int x) {return x;}
-ref int* identityPtr(ref return int* x) {return x;}
+ref int identity(return ref int x) {return x;}
+ref int* identityPtr(return ref int* x) {return x;}
 
 int* addrOfRefEscape()
 {
diff --git a/compiler/test/fail_compilation/test20881.d b/compiler/test/fail_compilation/test20881.d
@@ -17,7 +17,7 @@ struct S
 
     auto borrowA() return /*scope inferred*/ { return ptr; }
     int* borrowB() return { return ptr; }
-    int* borrowC() scope return { return ptr; }
+    int* borrowC() scope return ref { return ptr; }
 }
 
 void main()
diff --git a/compiler/test/fail_compilation/varargsstc.d b/compiler/test/fail_compilation/varargsstc.d
@@ -7,6 +7,6 @@ fail_compilation/varargsstc.d(103): Error: variadic parameter cannot have attrib
 
 #line 100
 
-int printf(const(char)*, const scope shared return ...);
-int printf(const(char)*, ref out scope immutable shared return ...);
-int printf(const(char)*, ref scope immutable shared return ...);
+int printf(const(char)*, const return scope shared ...);
+int printf(const(char)*, return ref out scope immutable shared ...);
+int printf(const(char)*, return ref scope immutable shared ...);
diff --git a/compiler/test/runnable/testscope2.d b/compiler/test/runnable/testscope2.d
@@ -18,7 +18,7 @@ struct SS
     ref ulong foo1(return ref int* delegate() return p) return;
     ref int foo2(return ref int delegate() p);
     ref int foo3(inout ref int* p);
-    ref int foo4(return inout ref int* p);
+    ref int foo4(return ref inout int* p);
 }
 
 pragma(msg, "foo1 ", typeof(&SS.foo1));
diff --git a/druntime/src/core/internal/array/duplication.d b/druntime/src/core/internal/array/duplication.d
@@ -362,7 +362,7 @@ U[] _dup(T, U)(T[] a) if (!__traits(isPOD, T))
 // https://issues.dlang.org/show_bug.cgi?id=24453
 @safe unittest
 {
-    static inout(char)[] foo(ref scope return inout(char)[] s)
+    static inout(char)[] foo(return ref scope inout(char)[] s)
     {
         auto bla = s.idup;
         return s;
diff --git a/druntime/src/core/stdcpp/string.d b/druntime/src/core/stdcpp/string.d

Original file line number	Diff line number	Diff line change
`@@ -1617,7 +1617,7 @@ void xoffOrNull(ref DtBuilder dtb, Symbol* symbol) @safe`
`1617`	`1617`	* given buffer `buffer`
`1618`	`1618`	`*/`
`1619`	`1619`	`const(char)* toStringz(size_t maxLength = 4095)(in const(char)[] str,`
`1620`		`- scope return void[] buffer = alloca(maxLength + 1)[0 .. maxLength + 1]) pure`
	`1620`	`+ return scope void[] buffer = alloca(maxLength + 1)[0 .. maxLength + 1]) pure`
`1621`	`1621`	`in`
`1622`	`1622`	`{`
`1623`	`1623`	`assert(maxLength >= str.length);`
Original file line number	Diff line number	Diff line change
`@@ -566,7 +566,7 @@ struct SafeS`
`566`	`566`	`{`
`567`	`567`	`this(int[1] x) scope {}`
`568`	`568`	`this(int[2] x) return scope {}`
`569`		`- this(int[3] x) scope return {}`
	`569`	`+ this(int[3] x) return ref scope {}`
`570`	`570`	`this(int[4] x) return {}`
`571`	`571`
`572`	`572`	`@safe:`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ pure nothrow @nogc ref @safe shared(C1)(return ref shared(C1) c)`
`5`	`5`	`pure nothrow @nogc ref @safe shared(int)(return ref shared(C3) c)`
`6`	`6`	`---`
`7`	`7`	`*/`
`8`		`-ref shared(int) f(return shared ref int y)`
	`8`	`+ref shared(int) f(return ref shared int y)`
`9`	`9`	`{`
`10`	`10`	`return y;`
`11`	`11`	`}`
`@@ -97,7 +97,7 @@ shared(C2)* test_dotvarexp_4(return ref shared C3 c)`
`97`	`97`	`return &c.c2;`
`98`	`98`	`}`
`99`	`99`
`100`		`-ref shared(int) test_dotvarexp_5(return shared ref C3 c)`
	`100`	`+ref shared(int) test_dotvarexp_5(return ref shared C3 c)`
`101`	`101`	`{`
`102`	`102`	`return c.c1.c1.value;`
`103`	`103`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ struct Ptr`
`5`	`5`	`{`
`6`	`6`	`int* impl;`
`7`	`7`	`void* fun0() return scope {return impl;}`
`8`		`- void* fun1() scope return {return impl;}`
	`8`	`+ void* fun1() scope return ref {return impl;}`
`9`	`9`	`void* fun2() return {return &this;}`
`10`	`10`	`}`
`11`	`11`