annotate pure functions with return/scope

dkorpel · dlang-bot · commit 309fdb13e85a · 2021-05-28T11:27:07.000+02:00
diff --git a/src/core/atomic.d b/src/core/atomic.d
@@ -66,7 +66,7 @@ enum MemoryOrder
  * Returns:
  *  The value of 'val'.
  */
-T atomicLoad(MemoryOrder ms = MemoryOrder.seq, T)(ref const T val) pure nothrow @nogc @trusted
+T atomicLoad(MemoryOrder ms = MemoryOrder.seq, T)(return ref const T val) pure nothrow @nogc @trusted
     if (!is(T == shared U, U) && !is(T == shared inout U, U) && !is(T == shared const U, U))
 {
     static if (__traits(isFloating, T))
@@ -80,7 +80,7 @@ T atomicLoad(MemoryOrder ms = MemoryOrder.seq, T)(ref const T val) pure nothrow
 }
 
 /// Ditto
-T atomicLoad(MemoryOrder ms = MemoryOrder.seq, T)(ref shared const T val) pure nothrow @nogc @trusted
+T atomicLoad(MemoryOrder ms = MemoryOrder.seq, T)(return ref shared const T val) pure nothrow @nogc @trusted
     if (!hasUnsharedIndirections!T)
 {
     import core.internal.traits : hasUnsharedIndirections;
@@ -162,7 +162,7 @@ void atomicStore(MemoryOrder ms = MemoryOrder.seq, T, V)(ref shared T val, share
  * Returns:
  *  The value held previously by `val`.
  */
-T atomicFetchAdd(MemoryOrder ms = MemoryOrder.seq, T)(ref T val, size_t mod) pure nothrow @nogc @trusted
+T atomicFetchAdd(MemoryOrder ms = MemoryOrder.seq, T)(return ref T val, size_t mod) pure nothrow @nogc @trusted
     if ((__traits(isIntegral, T) || is(T == U*, U)) && !is(T == shared))
 in (atomicValueIsProperlyAligned(val))
 {
@@ -173,7 +173,7 @@ in (atomicValueIsProperlyAligned(val))
 }
 
 /// Ditto
-T atomicFetchAdd(MemoryOrder ms = MemoryOrder.seq, T)(ref shared T val, size_t mod) pure nothrow @nogc @trusted
+T atomicFetchAdd(MemoryOrder ms = MemoryOrder.seq, T)(return ref shared T val, size_t mod) pure nothrow @nogc @trusted
     if (__traits(isIntegral, T) || is(T == U*, U))
 in (atomicValueIsProperlyAligned(val))
 {
@@ -191,7 +191,7 @@ in (atomicValueIsProperlyAligned(val))
  * Returns:
  *  The value held previously by `val`.
  */
-T atomicFetchSub(MemoryOrder ms = MemoryOrder.seq, T)(ref T val, size_t mod) pure nothrow @nogc @trusted
+T atomicFetchSub(MemoryOrder ms = MemoryOrder.seq, T)(return ref T val, size_t mod) pure nothrow @nogc @trusted
     if ((__traits(isIntegral, T) || is(T == U*, U)) && !is(T == shared))
 in (atomicValueIsProperlyAligned(val))
 {
@@ -202,7 +202,7 @@ in (atomicValueIsProperlyAligned(val))
 }
 
 /// Ditto
-T atomicFetchSub(MemoryOrder ms = MemoryOrder.seq, T)(ref shared T val, size_t mod) pure nothrow @nogc @trusted
+T atomicFetchSub(MemoryOrder ms = MemoryOrder.seq, T)(return ref shared T val, size_t mod) pure nothrow @nogc @trusted
     if (__traits(isIntegral, T) || is(T == U*, U))
 in (atomicValueIsProperlyAligned(val))
 {
diff --git a/src/core/demangle.d b/src/core/demangle.d
@@ -2036,7 +2036,7 @@ pure @safe:
  *  The demangled name or the original string if the name is not a mangled D
  *  name.
  */
-char[] demangle( const(char)[] buf, char[] dst = null ) nothrow pure @safe
+char[] demangle(return scope const(char)[] buf, return scope char[] dst = null ) nothrow pure @safe
 {
     auto d = Demangle!()(buf, dst);
     // fast path (avoiding throwing & catching exception) for obvious
@@ -2075,7 +2075,7 @@ char[] demangleType( const(char)[] buf, char[] dst = null ) nothrow pure @safe
 * Returns:
 *  The mangled name with deduplicated identifiers
 */
-char[] reencodeMangled(const(char)[] mangled) nothrow pure @safe
+char[] reencodeMangled(return scope const(char)[] mangled) nothrow pure @safe
 {
     static struct PrependHooks
     {
@@ -2247,7 +2247,7 @@ char[] reencodeMangled(const(char)[] mangled) nothrow pure @safe
  *  The mangled name for a symbols of type T and the given fully
  *  qualified name.
  */
-char[] mangle(T)(const(char)[] fqn, char[] dst = null) @safe pure nothrow
+char[] mangle(T)(return scope const(char)[] fqn, return scope char[] dst = null) @safe pure nothrow
 {
     import core.internal.string : numDigits, unsignedToTempString;
 
@@ -2264,13 +2264,13 @@ char[] mangle(T)(const(char)[] fqn, char[] dst = null) @safe pure nothrow
             return i == -1 ? s[0 .. $] : s[0 .. i];
         }
 
-        void popFront()
+        void popFront() scope
         {
             immutable i = indexOfDot();
             s = i == -1 ? s[$ .. $] : s[i+1 .. $];
         }
 
-        private ptrdiff_t indexOfDot() const
+        private ptrdiff_t indexOfDot() const scope
         {
             foreach (i, c; s) if (c == '.') return i;
             return -1;
@@ -2337,7 +2337,7 @@ char[] mangle(T)(const(char)[] fqn, char[] dst = null) @safe pure nothrow
  *  The mangled name for a function with function pointer type T and
  *  the given fully qualified name.
  */
-char[] mangleFunc(T:FT*, FT)(const(char)[] fqn, char[] dst = null) @safe pure nothrow if (is(FT == function))
+char[] mangleFunc(T:FT*, FT)(return scope const(char)[] fqn, return scope char[] dst = null) @safe pure nothrow if (is(FT == function))
 {
     static if (isExternD!FT)
     {
@@ -2601,7 +2601,7 @@ unittest
     {
         char[] buf = new char[i];
         auto ds = demangle(s, buf);
-        assert(ds == "pure nothrow @safe char[] core.demangle.demangle(const(char)[], char[])");
+        assert(ds == "pure nothrow @safe char[] core.demangle.demangle(scope return const(char)[], scope return char[])");
     }
 }
 
diff --git a/src/core/gc/gcinterface.d b/src/core/gc/gcinterface.d
@@ -86,7 +86,7 @@ interface GC
     /*
      *
      */
-    BlkInfo qalloc(size_t size, uint bits, const TypeInfo ti) nothrow;
+    BlkInfo qalloc(size_t size, uint bits, const scope TypeInfo ti) nothrow;
 
     /*
      *
diff --git a/src/core/internal/array/appending.d b/src/core/internal/array/appending.d
@@ -10,7 +10,7 @@
 module core.internal.array.appending;
 
 /// See $(REF _d_arrayappendcTX, rt,lifetime,_d_arrayappendcTX)
-private extern (C) byte[] _d_arrayappendcTX(const TypeInfo ti, ref byte[] px, size_t n) @trusted pure nothrow;
+private extern (C) byte[] _d_arrayappendcTX(const TypeInfo ti, ref return scope byte[] px, size_t n) @trusted pure nothrow;
 
 private enum isCopyingNothrow(T) = __traits(compiles, (ref T rhs) nothrow { T lhs = rhs; });
 
diff --git a/src/core/internal/array/casting.d b/src/core/internal/array/casting.d
@@ -72,7 +72,7 @@ Params:
 Returns:
     `from` reinterpreted as `TTo[]`
  */
-TTo[] __ArrayCast(TFrom, TTo)(TFrom[] from) @nogc pure @trusted
+TTo[] __ArrayCast(TFrom, TTo)(return scope TFrom[] from) @nogc pure @trusted
 {
     const fromSize = from.length * TFrom.sizeof;
     const toLength = fromSize / TTo.sizeof;
diff --git a/src/core/internal/array/concatenation.d b/src/core/internal/array/concatenation.d
@@ -9,7 +9,7 @@
 module core.internal.array.concatenation;
 
 /// See $(REF _d_arraycatnTX, rt,lifetime)
-private extern (C) void[] _d_arraycatnTX(const TypeInfo ti, byte[][] arrs) pure nothrow;
+private extern (C) void[] _d_arraycatnTX(const TypeInfo ti, scope byte[][] arrs) pure nothrow;
 
 /// Implementation of `_d_arraycatnTX` and `_d_arraycatnTXTrace`
 template _d_arraycatnTXImpl(Tarr : ResultArrT[], ResultArrT : T[], T)
diff --git a/src/core/internal/convert.d b/src/core/internal/convert.d
@@ -33,7 +33,7 @@ private ubyte[] ctfe_alloc(size_t n)
 }
 
 @trusted pure nothrow @nogc
-const(ubyte)[] toUbyte(T)(const ref T val) if (__traits(isFloating, T) && (is(T : real) || is(T : ireal)))
+const(ubyte)[] toUbyte(T)(const scope ref T val) if (__traits(isFloating, T) && (is(T : real) || is(T : ireal)))
 {
     if (__ctfe)
     {
@@ -645,13 +645,13 @@ package template floatSize(T) if (is(T:real) || is(T:ireal))
 
 //  all toUbyte functions must be evaluable at compile time
 @trusted pure nothrow @nogc
-const(ubyte)[] toUbyte(T)(const T[] arr) if (T.sizeof == 1)
+const(ubyte)[] toUbyte(T)(return scope const T[] arr) if (T.sizeof == 1)
 {
     return cast(const(ubyte)[])arr;
 }
 
 @trusted pure nothrow @nogc
-const(ubyte)[] toUbyte(T)(const T[] arr) if (T.sizeof > 1)
+const(ubyte)[] toUbyte(T)(return scope const T[] arr) if (T.sizeof > 1)
 {
     if (__ctfe)
     {
@@ -683,7 +683,7 @@ const(ubyte)[] toUbyte(T)(const T[] arr) if (T.sizeof > 1)
 }
 
 @trusted pure nothrow @nogc
-const(ubyte)[] toUbyte(T)(const ref T val) if (__traits(isIntegral, T) && !is(T == enum) && !is(T == __vector))
+const(ubyte)[] toUbyte(T)(const ref scope T val) if (__traits(isIntegral, T) && !is(T == enum) && !is(T == __vector))
 {
     static if (T.sizeof == 1)
     {
@@ -720,7 +720,7 @@ const(ubyte)[] toUbyte(T)(const ref T val) if (__traits(isIntegral, T) && !is(T
 }
 
 @trusted pure nothrow @nogc
-const(ubyte)[] toUbyte(T)(const ref T val) if (is(T == __vector))
+const(ubyte)[] toUbyte(T)(const ref scope T val) if (is(T == __vector))
 {
     if (!__ctfe)
         return (cast(const ubyte*) &val)[0 .. T.sizeof];
@@ -744,7 +744,7 @@ const(ubyte)[] toUbyte(T)(const ref T val) if (is(T == __vector))
 // @@@DEPRECATED_2022-02@@@
 deprecated
 @trusted pure nothrow @nogc
-const(ubyte)[] toUbyte(T)(const ref T val) if (__traits(isFloating, T) && is(T : creal))
+const(ubyte)[] toUbyte(T)(const ref return scope T val) if (__traits(isFloating, T) && is(T : creal))
 {
     if (__ctfe)
     {
@@ -764,7 +764,7 @@ const(ubyte)[] toUbyte(T)(const ref T val) if (__traits(isFloating, T) && is(T :
 }
 
 @trusted pure nothrow @nogc
-const(ubyte)[] toUbyte(T)(const ref T val) if (is(T == enum))
+const(ubyte)[] toUbyte(T)(const ref return scope T val) if (is(T == enum))
 {
     if (__ctfe)
     {
diff --git a/src/core/internal/gc/impl/conservative/gc.d b/src/core/internal/gc/impl/conservative/gc.d
@@ -398,7 +398,7 @@ class ConservativeGC : GC
     }
 
 
-    BlkInfo qalloc( size_t size, uint bits, const TypeInfo ti) nothrow
+    BlkInfo qalloc( size_t size, uint bits, const scope TypeInfo ti) nothrow
     {
 
         if (!size)
diff --git a/src/core/internal/gc/impl/manual/gc.d b/src/core/internal/gc/impl/manual/gc.d
@@ -111,7 +111,7 @@ class ManualGC : GC
         return p;
     }
 
-    BlkInfo qalloc(size_t size, uint bits, const TypeInfo ti) nothrow
+    BlkInfo qalloc(size_t size, uint bits, const scope TypeInfo ti) nothrow
     {
         BlkInfo retval;
         retval.base = malloc(size, bits, ti);
diff --git a/src/core/internal/gc/impl/proto/gc.d b/src/core/internal/gc/impl/proto/gc.d
@@ -18,13 +18,13 @@ private
     extern (C) void gc_enable() nothrow;
     extern (C) void gc_disable() nothrow;
 
-    extern (C) void*    gc_malloc( size_t sz, uint ba = 0, const TypeInfo = null ) pure nothrow;
-    extern (C) void*    gc_calloc( size_t sz, uint ba = 0, const TypeInfo = null ) pure nothrow;
-    extern (C) BlkInfo gc_qalloc( size_t sz, uint ba = 0, const TypeInfo = null ) pure nothrow;
-    extern (C) void*    gc_realloc( void* p, size_t sz, uint ba = 0, const TypeInfo = null ) pure nothrow;
+    extern (C) void*    gc_malloc( size_t sz, uint ba = 0, const scope TypeInfo = null ) pure nothrow;
+    extern (C) void*    gc_calloc( size_t sz, uint ba = 0, const scope TypeInfo = null ) pure nothrow;
+    extern (C) BlkInfo  gc_qalloc( size_t sz, uint ba = 0, const scope TypeInfo = null ) pure nothrow;
+    extern (C) void*    gc_realloc(return scope void* p, size_t sz, uint ba = 0, const scope TypeInfo = null ) pure nothrow;
     extern (C) size_t   gc_reserve( size_t sz ) nothrow;
 
-    extern (C) void gc_addRange(const void* p, size_t sz, const TypeInfo ti = null ) nothrow @nogc;
+    extern (C) void gc_addRange(const void* p, size_t sz, const scope TypeInfo ti = null ) nothrow @nogc;
     extern (C) void gc_addRoot(const void* p ) nothrow @nogc;
 }
 
@@ -99,31 +99,31 @@ class ProtoGC : GC
         return 0;
     }
 
-    void* malloc(size_t size, uint bits, const TypeInfo ti) nothrow
+    void* malloc(size_t size, uint bits, const scope TypeInfo ti) nothrow
     {
         .gc_init_nothrow();
         return .gc_malloc(size, bits, ti);
     }
 
-    BlkInfo qalloc(size_t size, uint bits, const TypeInfo ti) nothrow
+    BlkInfo qalloc(size_t size, uint bits, const scope TypeInfo ti) nothrow
     {
         .gc_init_nothrow();
         return .gc_qalloc(size, bits, ti);
     }
 
-    void* calloc(size_t size, uint bits, const TypeInfo ti) nothrow
+    void* calloc(size_t size, uint bits, const scope TypeInfo ti) nothrow
     {
         .gc_init_nothrow();
         return .gc_calloc(size, bits, ti);
     }
 
-    void* realloc(void* p, size_t size, uint bits, const TypeInfo ti) nothrow
+    void* realloc(void* p, size_t size, uint bits, const scope TypeInfo ti) nothrow
     {
         .gc_init_nothrow();
         return .gc_realloc(p, size, bits, ti);
     }
 
-    size_t extend(void* p, size_t minsize, size_t maxsize, const TypeInfo ti) nothrow
+    size_t extend(void* p, size_t minsize, size_t maxsize, const scope TypeInfo ti) nothrow
     {
         return 0;
     }
diff --git a/src/core/internal/gc/proxy.d b/src/core/internal/gc/proxy.d
@@ -157,27 +157,27 @@ extern (C)
         return instance.clrAttr(p, a);
     }
 
-    void* gc_malloc( size_t sz, uint ba = 0, const TypeInfo ti = null ) nothrow
+    void* gc_malloc( size_t sz, uint ba = 0, const scope TypeInfo ti = null ) nothrow
     {
         return instance.malloc(sz, ba, ti);
     }
 
-    BlkInfo gc_qalloc( size_t sz, uint ba = 0, const TypeInfo ti = null ) nothrow
+    BlkInfo gc_qalloc( size_t sz, uint ba = 0, const scope TypeInfo ti = null ) nothrow
     {
         return instance.qalloc( sz, ba, ti );
     }
 
-    void* gc_calloc( size_t sz, uint ba = 0, const TypeInfo ti = null ) nothrow
+    void* gc_calloc( size_t sz, uint ba = 0, const scope TypeInfo ti = null ) nothrow
     {
         return instance.calloc( sz, ba, ti );
     }
 
-    void* gc_realloc( void* p, size_t sz, uint ba = 0, const TypeInfo ti = null ) nothrow
+    void* gc_realloc( void* p, size_t sz, uint ba = 0, const scope TypeInfo ti = null ) nothrow
     {
         return instance.realloc( p, sz, ba, ti );
     }
 
-    size_t gc_extend( void* p, size_t mx, size_t sz, const TypeInfo ti = null ) nothrow
+    size_t gc_extend( void* p, size_t mx, size_t sz, const scope TypeInfo ti = null ) nothrow
     {
         return instance.extend( p, mx, sz,ti );
     }
diff --git a/src/core/lifetime.d b/src/core/lifetime.d
@@ -1764,7 +1764,7 @@ Params:
 */
 void move(T)(ref T source, ref T target)
 {
-    moveImpl(source, target);
+    moveImpl(target, source);
 }
 
 /// For non-struct types, `move` just performs `target = source`:
@@ -1915,7 +1915,7 @@ pure nothrow @safe @nogc unittest
     static assert(is(typeof({ S s; move(s, s); }) == T));
 }
 
-private void moveImpl(T)(ref T source, ref T target)
+private void moveImpl(T)(scope ref T target, return ref T source)
 {
     import core.internal.traits : hasElaborateDestructor;
 
@@ -1927,7 +1927,7 @@ private void moveImpl(T)(ref T source, ref T target)
         static if (hasElaborateDestructor!T) target.__xdtor();
     }
     // move and emplace source into target
-    moveEmplaceImpl(source, target);
+    moveEmplaceImpl(target, source);
 }
 
 private T moveImpl(T)(ref T source)
@@ -1942,7 +1942,7 @@ private T moveImpl(T)(ref T source)
 private T trustedMoveImpl(T)(ref T source) @trusted
 {
     T result = void;
-    moveEmplaceImpl(source, result);
+    moveEmplaceImpl(result, source);
     return result;
 }
 
@@ -2083,7 +2083,8 @@ private T trustedMoveImpl(T)(ref T source) @trusted
     move(x, x);
 }
 
-private void moveEmplaceImpl(T)(ref T source, ref T target)
+// target must be first-parameter, because in void-functions DMD + dip1000 allows it to take the place of a return-scope
+private void moveEmplaceImpl(T)(scope ref T target, return scope ref T source)
 {
     import core.stdc.string : memcpy, memset;
     import core.internal.traits;
@@ -2152,7 +2153,7 @@ private void moveEmplaceImpl(T)(ref T source, ref T target)
  */
 void moveEmplace(T)(ref T source, ref T target) @system
 {
-    moveEmplaceImpl(source, target);
+    moveEmplaceImpl(target, source);
 }
 
 ///
diff --git a/src/core/memory.d b/src/core/memory.d
diff --git a/src/object.d b/src/object.d
diff --git a/src/rt/lifetime.d b/src/rt/lifetime.d
diff --git a/src/rt/tracegc.d b/src/rt/tracegc.d
diff --git a/test/hash/src/test_hash.d b/test/hash/src/test_hash.d
diff --git a/test/init_fini/src/custom_gc.d b/test/init_fini/src/custom_gc.d

Original file line number	Diff line number	Diff line change
`@@ -66,7 +66,7 @@ enum MemoryOrder`
`66`	`66`	`* Returns:`
`67`	`67`	`* The value of 'val'.`
`68`	`68`	`*/`
`69`		`-T atomicLoad(MemoryOrder ms = MemoryOrder.seq, T)(ref const T val) pure nothrow @nogc @trusted`
	`69`	`+T atomicLoad(MemoryOrder ms = MemoryOrder.seq, T)(return ref const T val) pure nothrow @nogc @trusted`
`70`	`70`	`if (!is(T == shared U, U) && !is(T == shared inout U, U) && !is(T == shared const U, U))`
`71`	`71`	`{`
`72`	`72`	`static if (__traits(isFloating, T))`
`@@ -80,7 +80,7 @@ T atomicLoad(MemoryOrder ms = MemoryOrder.seq, T)(ref const T val) pure nothrow`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`/// Ditto`
`83`		`-T atomicLoad(MemoryOrder ms = MemoryOrder.seq, T)(ref shared const T val) pure nothrow @nogc @trusted`
	`83`	`+T atomicLoad(MemoryOrder ms = MemoryOrder.seq, T)(return ref shared const T val) pure nothrow @nogc @trusted`
`84`	`84`	`if (!hasUnsharedIndirections!T)`
`85`	`85`	`{`
`86`	`86`	`import core.internal.traits : hasUnsharedIndirections;`
`@@ -162,7 +162,7 @@ void atomicStore(MemoryOrder ms = MemoryOrder.seq, T, V)(ref shared T val, share`
`162`	`162`	`* Returns:`
`163`	`163`	* The value held previously by `val`.
`164`	`164`	`*/`
`165`		`-T atomicFetchAdd(MemoryOrder ms = MemoryOrder.seq, T)(ref T val, size_t mod) pure nothrow @nogc @trusted`
	`165`	`+T atomicFetchAdd(MemoryOrder ms = MemoryOrder.seq, T)(return ref T val, size_t mod) pure nothrow @nogc @trusted`
`166`	`166`	`if ((__traits(isIntegral, T) \|\| is(T == U*, U)) && !is(T == shared))`
`167`	`167`	`in (atomicValueIsProperlyAligned(val))`
`168`	`168`	`{`
`@@ -173,7 +173,7 @@ in (atomicValueIsProperlyAligned(val))`
`173`	`173`	`}`
`174`	`174`
`175`	`175`	`/// Ditto`
`176`		`-T atomicFetchAdd(MemoryOrder ms = MemoryOrder.seq, T)(ref shared T val, size_t mod) pure nothrow @nogc @trusted`
	`176`	`+T atomicFetchAdd(MemoryOrder ms = MemoryOrder.seq, T)(return ref shared T val, size_t mod) pure nothrow @nogc @trusted`
`177`	`177`	`if (__traits(isIntegral, T) \|\| is(T == U*, U))`
`178`	`178`	`in (atomicValueIsProperlyAligned(val))`
`179`	`179`	`{`
`@@ -191,7 +191,7 @@ in (atomicValueIsProperlyAligned(val))`
`191`	`191`	`* Returns:`
`192`	`192`	* The value held previously by `val`.
`193`	`193`	`*/`
`194`		`-T atomicFetchSub(MemoryOrder ms = MemoryOrder.seq, T)(ref T val, size_t mod) pure nothrow @nogc @trusted`
	`194`	`+T atomicFetchSub(MemoryOrder ms = MemoryOrder.seq, T)(return ref T val, size_t mod) pure nothrow @nogc @trusted`
`195`	`195`	`if ((__traits(isIntegral, T) \|\| is(T == U*, U)) && !is(T == shared))`
`196`	`196`	`in (atomicValueIsProperlyAligned(val))`
`197`	`197`	`{`
`@@ -202,7 +202,7 @@ in (atomicValueIsProperlyAligned(val))`
`202`	`202`	`}`
`203`	`203`
`204`	`204`	`/// Ditto`
`205`		`-T atomicFetchSub(MemoryOrder ms = MemoryOrder.seq, T)(ref shared T val, size_t mod) pure nothrow @nogc @trusted`
	`205`	`+T atomicFetchSub(MemoryOrder ms = MemoryOrder.seq, T)(return ref shared T val, size_t mod) pure nothrow @nogc @trusted`
`206`	`206`	`if (__traits(isIntegral, T) \|\| is(T == U*, U))`
`207`	`207`	`in (atomicValueIsProperlyAligned(val))`
`208`	`208`	`{`
Original file line number	Diff line number	Diff line change
`@@ -2036,7 +2036,7 @@ pure @safe:`
`2036`	`2036`	`* The demangled name or the original string if the name is not a mangled D`
`2037`	`2037`	`* name.`
`2038`	`2038`	`*/`
`2039`		`-char[] demangle( const(char)[] buf, char[] dst = null ) nothrow pure @safe`
	`2039`	`+char[] demangle(return scope const(char)[] buf, return scope char[] dst = null ) nothrow pure @safe`
`2040`	`2040`	`{`
`2041`	`2041`	`auto d = Demangle!()(buf, dst);`
`2042`	`2042`	`// fast path (avoiding throwing & catching exception) for obvious`
`@@ -2075,7 +2075,7 @@ char[] demangleType( const(char)[] buf, char[] dst = null ) nothrow pure @safe`
`2075`	`2075`	`* Returns:`
`2076`	`2076`	`* The mangled name with deduplicated identifiers`
`2077`	`2077`	`*/`
`2078`		`-char[] reencodeMangled(const(char)[] mangled) nothrow pure @safe`
	`2078`	`+char[] reencodeMangled(return scope const(char)[] mangled) nothrow pure @safe`
`2079`	`2079`	`{`
`2080`	`2080`	`static struct PrependHooks`
`2081`	`2081`	`{`
`@@ -2247,7 +2247,7 @@ char[] reencodeMangled(const(char)[] mangled) nothrow pure @safe`
`2247`	`2247`	`* The mangled name for a symbols of type T and the given fully`
`2248`	`2248`	`* qualified name.`
`2249`	`2249`	`*/`
`2250`		`-char[] mangle(T)(const(char)[] fqn, char[] dst = null) @safe pure nothrow`
	`2250`	`+char[] mangle(T)(return scope const(char)[] fqn, return scope char[] dst = null) @safe pure nothrow`
`2251`	`2251`	`{`
`2252`	`2252`	`import core.internal.string : numDigits, unsignedToTempString;`
`2253`	`2253`
`@@ -2264,13 +2264,13 @@ char[] mangle(T)(const(char)[] fqn, char[] dst = null) @safe pure nothrow`
`2264`	`2264`	`return i == -1 ? s[0 .. $] : s[0 .. i];`
`2265`	`2265`	`}`
`2266`	`2266`
`2267`		`- void popFront()`
	`2267`	`+ void popFront() scope`
`2268`	`2268`	`{`
`2269`	`2269`	`immutable i = indexOfDot();`
`2270`	`2270`	`s = i == -1 ? s[$ .. $] : s[i+1 .. $];`
`2271`	`2271`	`}`
`2272`	`2272`
`2273`		`- private ptrdiff_t indexOfDot() const`
	`2273`	`+ private ptrdiff_t indexOfDot() const scope`
`2274`	`2274`	`{`
`2275`	`2275`	`foreach (i, c; s) if (c == '.') return i;`
`2276`	`2276`	`return -1;`
`@@ -2337,7 +2337,7 @@ char[] mangle(T)(const(char)[] fqn, char[] dst = null) @safe pure nothrow`
`2337`	`2337`	`* The mangled name for a function with function pointer type T and`
`2338`	`2338`	`* the given fully qualified name.`
`2339`	`2339`	`*/`
`2340`		`-char[] mangleFunc(T:FT*, FT)(const(char)[] fqn, char[] dst = null) @safe pure nothrow if (is(FT == function))`
	`2340`	`+char[] mangleFunc(T:FT*, FT)(return scope const(char)[] fqn, return scope char[] dst = null) @safe pure nothrow if (is(FT == function))`
`2341`	`2341`	`{`
`2342`	`2342`	`static if (isExternD!FT)`
`2343`	`2343`	`{`
`@@ -2601,7 +2601,7 @@ unittest`
`2601`	`2601`	`{`
`2602`	`2602`	`char[] buf = new char[i];`
`2603`	`2603`	`auto ds = demangle(s, buf);`
`2604`		`- assert(ds == "pure nothrow @safe char[] core.demangle.demangle(const(char)[], char[])");`
	`2604`	`+ assert(ds == "pure nothrow @safe char[] core.demangle.demangle(scope return const(char)[], scope return char[])");`
`2605`	`2605`	`}`
`2606`	`2606`	`}`
`2607`	`2607`
Original file line number	Diff line number	Diff line change
`@@ -86,7 +86,7 @@ interface GC`
`86`	`86`	`/*`
`87`	`87`	`*`
`88`	`88`	`*/`
`89`		`- BlkInfo qalloc(size_t size, uint bits, const TypeInfo ti) nothrow;`
	`89`	`+ BlkInfo qalloc(size_t size, uint bits, const scope TypeInfo ti) nothrow;`
`90`	`90`
`91`	`91`	`/*`
`92`	`92`	`*`
Original file line number	Diff line number	Diff line change
`@@ -72,7 +72,7 @@ Params:`
`72`	`72`	`Returns:`
`73`	`73`	`from` reinterpreted as `TTo[]`
`74`	`74`	`*/`
`75`		`-TTo[] __ArrayCast(TFrom, TTo)(TFrom[] from) @nogc pure @trusted`
	`75`	`+TTo[] __ArrayCast(TFrom, TTo)(return scope TFrom[] from) @nogc pure @trusted`
`76`	`76`	`{`
`77`	`77`	`const fromSize = from.length * TFrom.sizeof;`
`78`	`78`	`const toLength = fromSize / TTo.sizeof;`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ private ubyte[] ctfe_alloc(size_t n)`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`@trusted pure nothrow @nogc`
`36`		`-const(ubyte)[] toUbyte(T)(const ref T val) if (__traits(isFloating, T) && (is(T : real) \|\| is(T : ireal)))`
	`36`	`+const(ubyte)[] toUbyte(T)(const scope ref T val) if (__traits(isFloating, T) && (is(T : real) \|\| is(T : ireal)))`
`37`	`37`	`{`
`38`	`38`	`if (__ctfe)`
`39`	`39`	`{`
`@@ -645,13 +645,13 @@ package template floatSize(T) if (is(T:real) \|\| is(T:ireal))`
`645`	`645`
`646`	`646`	`// all toUbyte functions must be evaluable at compile time`
`647`	`647`	`@trusted pure nothrow @nogc`
`648`		`-const(ubyte)[] toUbyte(T)(const T[] arr) if (T.sizeof == 1)`
	`648`	`+const(ubyte)[] toUbyte(T)(return scope const T[] arr) if (T.sizeof == 1)`
`649`	`649`	`{`
`650`	`650`	`return cast(const(ubyte)[])arr;`
`651`	`651`	`}`
`652`	`652`
`653`	`653`	`@trusted pure nothrow @nogc`
`654`		`-const(ubyte)[] toUbyte(T)(const T[] arr) if (T.sizeof > 1)`
	`654`	`+const(ubyte)[] toUbyte(T)(return scope const T[] arr) if (T.sizeof > 1)`
`655`	`655`	`{`
`656`	`656`	`if (__ctfe)`
`657`	`657`	`{`
`@@ -683,7 +683,7 @@ const(ubyte)[] toUbyte(T)(const T[] arr) if (T.sizeof > 1)`
`683`	`683`	`}`
`684`	`684`
`685`	`685`	`@trusted pure nothrow @nogc`
`686`		`-const(ubyte)[] toUbyte(T)(const ref T val) if (__traits(isIntegral, T) && !is(T == enum) && !is(T == __vector))`
	`686`	`+const(ubyte)[] toUbyte(T)(const ref scope T val) if (__traits(isIntegral, T) && !is(T == enum) && !is(T == __vector))`
`687`	`687`	`{`
`688`	`688`	`static if (T.sizeof == 1)`
`689`	`689`	`{`
`@@ -720,7 +720,7 @@ const(ubyte)[] toUbyte(T)(const ref T val) if (__traits(isIntegral, T) && !is(T`
`720`	`720`	`}`
`721`	`721`
`722`	`722`	`@trusted pure nothrow @nogc`
`723`		`-const(ubyte)[] toUbyte(T)(const ref T val) if (is(T == __vector))`
	`723`	`+const(ubyte)[] toUbyte(T)(const ref scope T val) if (is(T == __vector))`
`724`	`724`	`{`
`725`	`725`	`if (!__ctfe)`
`726`	`726`	`return (cast(const ubyte*) &val)[0 .. T.sizeof];`
`@@ -744,7 +744,7 @@ const(ubyte)[] toUbyte(T)(const ref T val) if (is(T == __vector))`
`744`	`744`	`// @@@DEPRECATED_2022-02@@@`
`745`	`745`	`deprecated`
`746`	`746`	`@trusted pure nothrow @nogc`
`747`		`-const(ubyte)[] toUbyte(T)(const ref T val) if (__traits(isFloating, T) && is(T : creal))`
	`747`	`+const(ubyte)[] toUbyte(T)(const ref return scope T val) if (__traits(isFloating, T) && is(T : creal))`
`748`	`748`	`{`
`749`	`749`	`if (__ctfe)`
`750`	`750`	`{`
`@@ -764,7 +764,7 @@ const(ubyte)[] toUbyte(T)(const ref T val) if (__traits(isFloating, T) && is(T :`
`764`	`764`	`}`
`765`	`765`
`766`	`766`	`@trusted pure nothrow @nogc`
`767`		`-const(ubyte)[] toUbyte(T)(const ref T val) if (is(T == enum))`
	`767`	`+const(ubyte)[] toUbyte(T)(const ref return scope T val) if (is(T == enum))`
`768`	`768`	`{`
`769`	`769`	`if (__ctfe)`
`770`	`770`	`{`
Original file line number	Diff line number	Diff line change
`@@ -398,7 +398,7 @@ class ConservativeGC : GC`
`398`	`398`	`}`
`399`	`399`
`400`	`400`
`401`		`- BlkInfo qalloc( size_t size, uint bits, const TypeInfo ti) nothrow`
	`401`	`+ BlkInfo qalloc( size_t size, uint bits, const scope TypeInfo ti) nothrow`
`402`	`402`	`{`
`403`	`403`
`404`	`404`	`if (!size)`
Original file line number	Diff line number	Diff line change
`@@ -111,7 +111,7 @@ class ManualGC : GC`
`111`	`111`	`return p;`
`112`	`112`	`}`
`113`	`113`
`114`		`- BlkInfo qalloc(size_t size, uint bits, const TypeInfo ti) nothrow`
	`114`	`+ BlkInfo qalloc(size_t size, uint bits, const scope TypeInfo ti) nothrow`
`115`	`115`	`{`
`116`	`116`	`BlkInfo retval;`
`117`	`117`	`retval.base = malloc(size, bits, ti);`
Original file line number	Diff line number	Diff line change
`@@ -18,13 +18,13 @@ private`
`18`	`18`	`extern (C) void gc_enable() nothrow;`
`19`	`19`	`extern (C) void gc_disable() nothrow;`
`20`	`20`
`21`		`- extern (C) void* gc_malloc( size_t sz, uint ba = 0, const TypeInfo = null ) pure nothrow;`
`22`		`- extern (C) void* gc_calloc( size_t sz, uint ba = 0, const TypeInfo = null ) pure nothrow;`
`23`		`- extern (C) BlkInfo gc_qalloc( size_t sz, uint ba = 0, const TypeInfo = null ) pure nothrow;`
`24`		`- extern (C) void* gc_realloc( void* p, size_t sz, uint ba = 0, const TypeInfo = null ) pure nothrow;`
	`21`	`+ extern (C) void* gc_malloc( size_t sz, uint ba = 0, const scope TypeInfo = null ) pure nothrow;`
	`22`	`+ extern (C) void* gc_calloc( size_t sz, uint ba = 0, const scope TypeInfo = null ) pure nothrow;`
	`23`	`+ extern (C) BlkInfo gc_qalloc( size_t sz, uint ba = 0, const scope TypeInfo = null ) pure nothrow;`
	`24`	`+ extern (C) void* gc_realloc(return scope void* p, size_t sz, uint ba = 0, const scope TypeInfo = null ) pure nothrow;`
`25`	`25`	`extern (C) size_t gc_reserve( size_t sz ) nothrow;`
`26`	`26`
`27`		`- extern (C) void gc_addRange(const void* p, size_t sz, const TypeInfo ti = null ) nothrow @nogc;`
	`27`	`+ extern (C) void gc_addRange(const void* p, size_t sz, const scope TypeInfo ti = null ) nothrow @nogc;`
`28`	`28`	`extern (C) void gc_addRoot(const void* p ) nothrow @nogc;`
`29`	`29`	`}`
`30`	`30`
`@@ -99,31 +99,31 @@ class ProtoGC : GC`
`99`	`99`	`return 0;`
`100`	`100`	`}`
`101`	`101`
`102`		`- void* malloc(size_t size, uint bits, const TypeInfo ti) nothrow`
	`102`	`+ void* malloc(size_t size, uint bits, const scope TypeInfo ti) nothrow`
`103`	`103`	`{`
`104`	`104`	`.gc_init_nothrow();`
`105`	`105`	`return .gc_malloc(size, bits, ti);`
`106`	`106`	`}`
`107`	`107`
`108`		`- BlkInfo qalloc(size_t size, uint bits, const TypeInfo ti) nothrow`
	`108`	`+ BlkInfo qalloc(size_t size, uint bits, const scope TypeInfo ti) nothrow`
`109`	`109`	`{`
`110`	`110`	`.gc_init_nothrow();`
`111`	`111`	`return .gc_qalloc(size, bits, ti);`
`112`	`112`	`}`
`113`	`113`
`114`		`- void* calloc(size_t size, uint bits, const TypeInfo ti) nothrow`
	`114`	`+ void* calloc(size_t size, uint bits, const scope TypeInfo ti) nothrow`
`115`	`115`	`{`
`116`	`116`	`.gc_init_nothrow();`
`117`	`117`	`return .gc_calloc(size, bits, ti);`
`118`	`118`	`}`
`119`	`119`
`120`		`- void* realloc(void* p, size_t size, uint bits, const TypeInfo ti) nothrow`
	`120`	`+ void* realloc(void* p, size_t size, uint bits, const scope TypeInfo ti) nothrow`
`121`	`121`	`{`
`122`	`122`	`.gc_init_nothrow();`
`123`	`123`	`return .gc_realloc(p, size, bits, ti);`
`124`	`124`	`}`
`125`	`125`
`126`		`- size_t extend(void* p, size_t minsize, size_t maxsize, const TypeInfo ti) nothrow`
	`126`	`+ size_t extend(void* p, size_t minsize, size_t maxsize, const scope TypeInfo ti) nothrow`
`127`	`127`	`{`
`128`	`128`	`return 0;`
`129`	`129`	`}`