add __rvalue(expression) builtin (dlang#17050)

Author: WalterBright

.gitignore

@@ -1,7 +1,11 @@
 *.[oa]
 *.deps
+*.lst
+log*
 .B*
 *~
+/compiler/src/dmd/lwv
+/compiler/src/dmd/new
 /compiler/src/bug2
 /compiler/test/test_results
 /compiler/test/trace.def
@@ -12,7 +16,6 @@ generated/
 -.DS_Store
 -trace.def
 -trace.log
-*.lst
 .dub
 dub.selections.json
 

changelog/dmd.rvalue.dd

@@ -0,0 +1,23 @@
+Add primary expression of the form `__rvalue(expression)` which causes `expression` to be treated as an rvalue, even if it is an lvalue.
+
+Overloads on `ref`:
+```
+foo(S s); // selected if `s` is an rvalue
+foo(ref S s); // selected if argument `s` is an lvalue
+
+S s;
+S bar();
+...
+foo(s); // selects foo(ref S)
+foo(bar()); // selects foo(S)
+```
+With this change,
+```
+foo(__rvalue(s)); // selects foo(S)
+```
+This also applies to constructors and assignments, meaning move constructors and
+move assignments are enabled. Moving instead of copying can be much more resource
+efficient, as, say, a string can be moved rather than copied/deleted.
+
+A moved object can still be destructed, so take that into account when moving
+a field - set it to a benign value that can be destructed.

compiler/src/dmd/astbase.d

@@ -4548,6 +4548,7 @@ struct ASTBase
         EXP op;
         ubyte size;
         ubyte parens;
+        ubyte rvalue;              // consider this an rvalue, even if it is an lvalue
         Type type;
         Loc loc;
 

compiler/src/dmd/clone.d

@@ -1610,13 +1610,15 @@ private Statement generateCopyCtorBody(StructDeclaration sd)
  * Params:
  *  sd = the `struct` for which the copy constructor is generated
  *  hasCpCtor = set to true if a copy constructor is already present
+ *  hasMoveCtor = set to true if a move constructor is already present
  *
  * Returns:
  *  `true` if one needs to be generated
  *  `false` otherwise
  */
-bool needCopyCtor(StructDeclaration sd, out bool hasCpCtor)
+bool needCopyCtor(StructDeclaration sd, out bool hasCpCtor, out bool hasMoveCtor)
 {
+    //printf("needCopyCtor() %s\n", sd.toChars());
     if (global.errors)
         return false;
 
@@ -1648,14 +1650,17 @@ bool needCopyCtor(StructDeclaration sd, out bool hasCpCtor)
             return 0;
         }
 
-        if (isRvalueConstructor(sd, ctorDecl))
+        if (ctorDecl.isMoveCtor)
             rvalueCtor = ctorDecl;
         return 0;
     });
 
+    if (rvalueCtor)
+        hasMoveCtor = true;
+
     if (cpCtor)
     {
-        if (rvalueCtor)
+        if (0 && rvalueCtor)
         {
             .error(sd.loc, "`struct %s` may not define both a rvalue constructor and a copy constructor", sd.toChars());
             errorSupplemental(rvalueCtor.loc,"rvalue constructor defined here");
@@ -1710,17 +1715,18 @@ LcheckFields:
  * Params:
  *  sd = the `struct` for which the copy constructor is generated
  *  sc = the scope where the copy constructor is generated
+ *  hasMoveCtor = set to true when a move constructor is also detected
  *
  * Returns:
  *  `true` if `struct` sd defines a copy constructor (explicitly or generated),
  *  `false` otherwise.
  * References:
  *   https://dlang.org/spec/struct.html#struct-copy-constructor
  */
-bool buildCopyCtor(StructDeclaration sd, Scope* sc)
+bool buildCopyCtor(StructDeclaration sd, Scope* sc, out bool hasMoveCtor)
 {
     bool hasCpCtor;
-    if (!needCopyCtor(sd, hasCpCtor))
+    if (!needCopyCtor(sd, hasCpCtor, hasMoveCtor))
         return hasCpCtor;
 
     //printf("generating copy constructor for %s\n", sd.toChars());

compiler/src/dmd/declaration.h

@@ -782,6 +782,7 @@ class CtorDeclaration final : public FuncDeclaration
 {
 public:
     d_bool isCpCtor;
+    d_bool isMoveCtor;
     CtorDeclaration *syntaxCopy(Dsymbol *) override;
     const char *kind() const override;
     const char *toChars() const override;

compiler/src/dmd/dscope.d

@@ -24,6 +24,7 @@ import dmd.dclass;
 import dmd.declaration;
 import dmd.dmodule;
 import dmd.doc;
+import dmd.dstruct;
 import dmd.dsymbol;
 import dmd.dsymbolsem;
 import dmd.dtemplate;
@@ -146,6 +147,7 @@ extern (C++) struct Scope
 
     AliasDeclaration aliasAsg; /// if set, then aliasAsg is being assigned a new value,
                                /// do not set wasRead for it
+    StructDeclaration argStruct;    /// elimiate recursion when looking for rvalue construction
 
     extern (D) __gshared Scope* freelist;
 

compiler/src/dmd/dstruct.d

@@ -101,6 +101,7 @@ extern (C++) class StructDeclaration : AggregateDeclaration
         bool hasIdentityEquals;     // true if has identity opEquals
         bool hasNoFields;           // has no fields
         bool hasCopyCtor;           // copy constructor
+        bool hasMoveCtor;           // move constructor
         bool hasPointerField;       // members with indirections
         bool hasVoidInitPointers;   // void-initialized unsafe fields
         bool hasUnsafeBitpatterns;  // @system members, pointers, bool
@@ -321,11 +322,16 @@ extern (C++) class StructDeclaration : AggregateDeclaration
         import dmd.clone;
 
         bool hasCpCtorLocal;
-        needCopyCtor(this, hasCpCtorLocal);
+        bool hasMoveCtorLocal;
+        needCopyCtor(this, hasCpCtorLocal, hasMoveCtorLocal);
 
         if (enclosing                      || // is nested
             search(this, loc, Id.postblit) || // has postblit
             search(this, loc, Id.dtor)     || // has destructor
+            /* This is commented out because otherwise buildkite vibe.d:
+               `canCAS!Task` fails to compile
+             */
+            //hasMoveCtorLocal               || // has move constructor
             hasCpCtorLocal)                   // has copy constructor
         {
             ispod = ThreeState.no;

compiler/src/dmd/dsymbolsem.d

@@ -256,6 +256,10 @@ Return:
 */
 bool checkHasBothRvalueAndCpCtor(StructDeclaration sd, CtorDeclaration ctor, TemplateInstance ti)
 {
+    //printf("checkHasBothRvalueAndCpCtor() sd: %s ctor: %s ti: %s\n", sd.toChars(), ctor.toChars(), ti.toChars());
+    /* cannot use ctor.isMoveCtor because semantic pass may not have been run yet,
+     * so use isRvalueConstructor()
+     */
     if (sd && sd.hasCopyCtor && isRvalueConstructor(sd, ctor))
     {
         .error(ctor.loc, "cannot define both an rvalue constructor and a copy constructor for `struct %s`", sd.toChars());
@@ -280,6 +284,7 @@ bool checkHasBothRvalueAndCpCtor(StructDeclaration sd, CtorDeclaration ctor, Tem
  */
 bool isRvalueConstructor(StructDeclaration sd, CtorDeclaration ctor)
 {
+    // note commonality with setting isMoveCtor in the semantic code for CtorDeclaration
     auto tf = ctor.type.isTypeFunction();
     const dim = tf.parameterList.length;
     if (dim == 1 || (dim > 1 && tf.parameterList[1].defaultArg))
@@ -306,6 +311,7 @@ bool isRvalueConstructor(StructDeclaration sd, CtorDeclaration ctor)
  */
 Expression resolveAliasThis(Scope* sc, Expression e, bool gag = false, bool findOnly = false)
 {
+    //printf("resolveAliasThis() %s\n", toChars(e));
     import dmd.typesem : dotExp;
     for (AggregateDeclaration ad = isAggregate(e.type); ad;)
     {
@@ -2399,7 +2405,7 @@ private extern(C++) final class DsymbolSemanticVisitor : Visitor
 
     override void visit(CtorDeclaration ctd)
     {
-        //printf("CtorDeclaration::semantic() %s\n", toChars());
+        //printf("CtorDeclaration::semantic() %p %s\n", ctd, ctd.toChars());
         if (ctd.semanticRun >= PASS.semanticdone)
             return;
         if (ctd._scope)
@@ -2500,12 +2506,15 @@ private extern(C++) final class DsymbolSemanticVisitor : Visitor
             }
             else if ((dim == 1 || (dim > 1 && tf.parameterList[1].defaultArg)))
             {
-                //printf("tf: %s\n", tf.toChars());
+                //printf("tf: %s\n", toChars(tf));
                 auto param = tf.parameterList[0];
-                if (param.storageClass & STC.ref_ && param.type.mutableOf().unSharedOf() == sd.type.mutableOf().unSharedOf())
+                if (param.type.mutableOf().unSharedOf() == sd.type.mutableOf().unSharedOf())
                 {
-                    //printf("copy constructor\n");
-                    ctd.isCpCtor = true;
+                    //printf("copy constructor %p\n", ctd);
+                    if (param.storageClass & STC.ref_)
+                        ctd.isCpCtor = true;            // copy constructor
+                    else
+                        ctd.isMoveCtor = true;          // move constructor
                 }
             }
         }
@@ -2996,7 +3005,10 @@ private extern(C++) final class DsymbolSemanticVisitor : Visitor
 
         buildDtors(sd, sc2);
 
-        sd.hasCopyCtor = buildCopyCtor(sd, sc2);
+        bool hasMoveCtor;
+        sd.hasCopyCtor = buildCopyCtor(sd, sc2, hasMoveCtor);
+        sd.hasMoveCtor = hasMoveCtor;
+
         sd.postblit = buildPostBlit(sd, sc2);
 
         buildOpAssign(sd, sc2);

compiler/src/dmd/e2ir.d

@@ -5532,6 +5532,8 @@ elem *callfunc(const ref Loc loc,
                     v = ve.var.isVarDeclaration();
                 bool copy = !(v && (v.isArgDtorVar || v.storage_class & STC.rvalue)); // copy unless the destructor is going to be run on it
                                                     // then assume the frontend took care of the copying and pass it by ref
+                if (arg.rvalue)                     // marked with __rvalue
+                    copy = false;
 
                 elems[i] = addressElem(ea, arg.type, copy);
                 continue;