annotate more of phobos with return and scope

Author: dkorpel

std/algorithm/mutation.d

@@ -1074,7 +1074,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`:
@@ -1244,7 +1244,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)(ref return scope T target, ref scope T source)
 {
     import std.traits : hasElaborateDestructor;
 
@@ -1257,10 +1257,10 @@ 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)
+private T moveImpl(T)(ref return scope T source)
 {
     // Properly infer safety from moveEmplaceImpl as the implementation below
     // might void-initialize pointers in result and hence needs to be @trusted
@@ -1269,10 +1269,10 @@ private T moveImpl(T)(ref T source)
     return trustedMoveImpl(source);
 }
 
-private T trustedMoveImpl(T)(ref T source) @trusted
+private T trustedMoveImpl(T)(ref return scope T source) @trusted
 {
     T result = void;
-    moveEmplaceImpl(source, result);
+    moveEmplaceImpl(result, source);
     return result;
 }
 
@@ -1415,7 +1415,7 @@ private T trustedMoveImpl(T)(ref T source) @trusted
     move(x, x);
 }
 
-private void moveEmplaceImpl(T)(ref T source, ref T target)
+private void moveEmplaceImpl(T)(ref return scope T target, ref scope T source)
 {
     import core.stdc.string : memcpy, memset;
     import std.traits : hasAliasing, hasElaborateAssign,
@@ -1486,7 +1486,7 @@ private void moveEmplaceImpl(T)(ref T source, ref T target)
  */
 void moveEmplace(T)(ref T source, ref T target) pure @system
 {
-    moveEmplaceImpl(source, target);
+    moveEmplaceImpl(target, source);
 }
 
 ///

std/bigint.d

@@ -246,7 +246,7 @@ public:
      * Implements assignment operators from built-in integers of the form
      * `BigInt op= integer`.
      */
-    BigInt opOpAssign(string op, T)(T y) pure nothrow @safe return
+    BigInt opOpAssign(string op, T)(T y) pure nothrow @safe return scope
         if ((op=="+" || op=="-" || op=="*" || op=="/" || op=="%"
           || op==">>" || op=="<<" || op=="^^" || op=="|" || op=="&" || op=="^") && isIntegral!T)
     {
@@ -1351,16 +1351,16 @@ public:
 
     // for backwards compatibility, see unittest below
     /// ditto
-    void toString(scope void delegate(const(char)[]) sink, string formatString) const
+    void toString(scope void delegate(scope const(char)[]) sink, string formatString) const
     {
-        toString!(void delegate(const(char)[]))(sink, formatString);
+        toString!(void delegate(scope const(char)[]))(sink, formatString);
     }
 
     // for backwards compatibility, see unittest below
     /// ditto
-    void toString(scope void delegate(const(char)[]) sink, scope const ref FormatSpec!char f) const
+    void toString(scope void delegate(scope const(char)[]) sink, scope const ref FormatSpec!char f) const
     {
-        toString!(void delegate(const(char)[]))(sink, f);
+        toString!(void delegate(scope const(char)[]))(sink, f);
     }
 
     // Backwards compatibility test

std/conv.d

@@ -4758,7 +4758,7 @@ if (T.length > 0) { return textImpl!dstring(args); }
     assert(dtext(cs, ' ', ws, " ", ds) == "今日は 여보세요 Здравствуйте"d);
 }
 
-private S textImpl(S, U...)(U args)
+private S textImpl(S, U...)(scope U args)
 {
     static if (U.length == 0)
     {

std/getopt.d

@@ -1106,7 +1106,7 @@ private struct configuration
 private bool optMatch(string arg, scope string optPattern, ref string value,
     configuration cfg) @safe
 {
-    import std.array : split;
+    import std.algorithm : splitter;
     import std.string : indexOf;
     import std.uni : toUpper;
     //writeln("optMatch:\n  ", arg, "\n  ", optPattern, "\n  ", value);
@@ -1148,8 +1148,7 @@ private bool optMatch(string arg, scope string optPattern, ref string value,
     }
     //writeln("Arg: ", arg, " pattern: ", optPattern, " value: ", value);
     // Split the option
-    const variants = split(optPattern, "|");
-    foreach (v ; variants)
+    foreach (v ; splitter(optPattern, "|"))
     {
         //writeln("Trying variant: ", v, " against ", arg);
         if (arg == v || !cfg.caseSensitive && toUpper(arg) == toUpper(v))

std/internal/cstring.d

@@ -269,7 +269,7 @@ private:
     static TempCStringBuffer trustedVoidInit() { TempCStringBuffer res = void; return res; }
 }
 
-private To[] trustedRealloc(To)(scope To[] buf, size_t strLength, bool bufIsOnStack)
+private To[] trustedRealloc(To)(return scope To[] buf, size_t strLength, bool bufIsOnStack)
     @trusted @nogc pure nothrow
 {
     pragma(inline, false);  // because it's rarely called

std/internal/math/biguintcore.d

@@ -245,7 +245,7 @@ private:
 
     immutable(BigDigit) [] data = ZERO;
 
-    this(immutable(BigDigit) [] x) pure nothrow @nogc @safe scope
+    this(return scope immutable(BigDigit) [] x) pure nothrow @nogc @safe
     {
        data = x;
     }
@@ -710,7 +710,7 @@ public:
     // All of these member functions create a new BigUint.
 
     // return x >> y
-    BigUint opBinary(string op, Tulong)(Tulong y) pure nothrow @safe const
+    BigUint opBinary(string op, Tulong)(Tulong y) pure nothrow @safe const return scope
         if (op == ">>" && is (Tulong == ulong))
     {
         assert(y > 0, "Can not right shift BigUint by 0");
@@ -1498,7 +1498,7 @@ private int slowHighestPowerBelowUintMax(uint x) pure nothrow @safe
  * Returns:
  *    unique memory
  */
-BigDigit [] sub(const BigDigit [] x, const BigDigit [] y, bool *negative)
+BigDigit [] sub(const scope BigDigit [] x, const scope BigDigit [] y, bool *negative)
 pure nothrow @safe
 {
     if (x.length == y.length)
@@ -1558,7 +1558,7 @@ pure nothrow @safe
  * Returns:
  *    unique memory
  */
-BigDigit [] add(const BigDigit [] a, const BigDigit [] b) pure nothrow @safe
+BigDigit [] add(const scope BigDigit [] a, const scope BigDigit [] b) pure nothrow @safe
 {
     const(BigDigit) [] x, y;
     if (a.length < b.length)

std/internal/memory.d

@@ -42,7 +42,7 @@ void* enforceCalloc()(size_t nmemb, size_t size) @nogc nothrow pure @safe
 }
 
 // ditto
-void* enforceRealloc()(void* ptr, size_t size) @nogc nothrow pure @system
+void* enforceRealloc()(return scope void* ptr, size_t size) @nogc nothrow pure @system
 {
     auto result = fakePureRealloc(ptr, size);
     if (!result) mixin(allocationFailed);
@@ -54,5 +54,5 @@ extern (C) @nogc nothrow pure private
 {
     pragma(mangle, "malloc") void* fakePureMalloc(size_t) @safe;
     pragma(mangle, "calloc") void* fakePureCalloc(size_t nmemb, size_t size) @safe;
-    pragma(mangle, "realloc") void* fakePureRealloc(void* ptr, size_t size) @system;
+    pragma(mangle, "realloc") void* fakePureRealloc(return scope void* ptr, size_t size) @system;
 }

std/path.d

@@ -565,7 +565,7 @@ if (isRandomAccessRange!R && hasSlicing!R && hasLength!R && isSomeChar!(ElementT
 }
 
 /// ditto
-auto dirName(C)(C[] path)
+auto dirName(C)(return scope C[] path)
 if (isSomeChar!C)
 {
     return _dirName(path);
@@ -662,7 +662,7 @@ if (isSomeChar!C)
     //static assert(dirName("dir/file".byChar).array == "dir");
 }
 
-private auto _dirName(R)(R path)
+private auto _dirName(R)(return scope R path)
 {
     static auto result(bool dot, typeof(path[0 .. 1]) p)
     {
@@ -1448,7 +1448,7 @@ private auto _withDefaultExtension(R, C)(R path, C[] ext)
     Returns: The assembled path.
 */
 immutable(ElementEncodingType!(ElementType!Range))[]
-    buildPath(Range)(Range segments)
+    buildPath(Range)(scope Range segments)
     if (isInputRange!Range && !isInfinite!Range && isSomeString!(ElementType!Range))
 {
     if (segments.empty) return null;
@@ -1622,7 +1622,7 @@ if (isSomeChar!C)
  * See_Also:
  *      $(LREF buildPath)
  */
-auto chainPath(R1, R2, Ranges...)(R1 r1, R2 r2, Ranges ranges)
+auto chainPath(R1, R2, Ranges...)(return scope R1 r1, return scope R2 r2, Ranges ranges) @safe
 if ((isRandomAccessRange!R1 && hasSlicing!R1 && hasLength!R1 && isSomeChar!(ElementType!R1) ||
     isNarrowString!R1 &&
     !isConvertibleToString!R1) &&

std/range/package.d

@@ -886,7 +886,7 @@ Returns:
 
 See_Also: $(LREF only) to chain values to a range
  */
-auto chain(Ranges...)(Ranges rs)
+auto chain(Ranges...)(return scope Ranges rs)
 if (Ranges.length > 0 &&
     allSatisfy!(isInputRange, staticMap!(Unqual, Ranges)) &&
     !is(CommonType!(staticMap!(ElementType, staticMap!(Unqual, Ranges))) == void))
@@ -930,9 +930,11 @@ if (Ranges.length > 0 &&
             // TODO: use a vtable (or more) instead of linear iteration
 
         public:
-            this(R input)
+            this(return scope R input)
             {
-                foreach (i, v; input)
+                // this has to be static foreach instead of just foreach, otherwise
+                // "scope variable `v` assigned to `this` with longer lifetime"
+                static foreach (i, v; input)
                 {
                     source[i] = v;
                 }

std/typecons.d

@@ -3010,7 +3010,7 @@ struct Nullable(T)
      * Params:
      *     value = A value of type `T` to assign to this `Nullable`.
      */
-    void opAssign()(T value)
+    void opAssign()(return scope T value)
     {
         import std.algorithm.mutation : moveEmplace, move;
 
@@ -3025,7 +3025,7 @@ struct Nullable(T)
         }
         else
         {
-            move(copy.payload, _value.payload);
+            () @trusted { move(copy.payload, _value.payload); }();
         }
         _isNull = false;
     }