Refactor: expose canElideCopy to C++ with saner default parameters

Author: limepoutine

compiler/src/dmd/cxxfrontend.d

@@ -430,6 +430,12 @@ bool isLvalue(Expression exp)
     return dmd.expressionsem.isLvalue(exp);
 }
 
+bool canElideCopy(Expression exp, Type to, bool checkMod)
+{
+    import dmd.expressionsem;
+    return dmd.expressionsem.canElideCopy(exp, to, checkMod);
+}
+
 int getFieldIndex(ClassReferenceExp cre, Type fieldtype, uint fieldoffset)
 {
     import dmd.expressionsem;

compiler/src/dmd/expression.h

@@ -62,6 +62,7 @@ namespace dmd
     bool isIdentical(const Expression *exp, const Expression *e);
     bool equals(const Expression *exp, const Expression *e);
     bool isLvalue(Expression *exp);
+    bool canElideCopy(Expression *exp, Type *to, bool checkMod = false);
     int32_t getFieldIndex(ClassReferenceExp *cre, Type *fieldtype, uint32_t fieldoffset);
     void fillTupleExpExps(TupleExp *te, TupleDeclaration *tup);
     Optional<bool> toBool(Expression *exp);

compiler/src/dmd/expressionsem.d

@@ -761,8 +761,13 @@ bool isLvalue(Expression _this)
  * Determine if copy elision is allowed when copying an expression to
  * a typed storage. This basically elides a restricted subset of so-called
  * "pure" rvalues, i.e. expressions with no reference semantics.
+ *
+ * Note: Please avoid using `checkMod` parameter because `canElideCopy()`
+ * essentially defines a value category and should eventually be merged with
+ * `isLvalue()` to return [isLvalue, allowEmplacement].
+ * Checking type compatibility here is only a stopgap measure.
  */
-bool canElideCopy(Expression e, Type to, bool checkMod = true)
+bool canElideCopy(Expression e, Type to, bool checkMod = false)
 {
     if (checkMod && !MODimplicitConv(e.type.mod, to.mod))
         return false;
@@ -791,7 +796,7 @@ bool canElideCopy(Expression e, Type to, bool checkMod = true)
             return false;
 
         // If an aggregate can be elided, so are its fields
-        return canElideCopy(e.e1, e.e1.type, false);
+        return canElideCopy(e.e1, e.e1.type);
     }
 
     switch (e.op)
@@ -1920,7 +1925,7 @@ extern (D) Expression doCopyOrMove(Scope* sc, Expression e, Type t, bool nrvo, b
     {
         e = callCpCtor(sc, e, t, nrvo);
     }
-    else if (move && sd && sd.hasMoveCtor && !canElideCopy(e, t ? t : e.type, false))
+    else if (move && sd && sd.hasMoveCtor && !canElideCopy(e, t ? t : e.type))
     {
         // #move
         /* Rewrite as:

compiler/src/dmd/glue/e2ir.d

@@ -5518,7 +5518,7 @@ elem* callfunc(Loc loc,
                 bool hasDtor = v && (v.isArgDtorVar || v.storage_class & STC.rvalue);
 
                 /* Also do not copy __rvalue expressions or temporaries that can be elided. */
-                bool copy = !(hasDtor || arg.rvalue || (param && canElideCopy(arg, param.type)));
+                bool copy = !(hasDtor || arg.rvalue || (param && canElideCopy(arg, param.type, true)));
 
                 elems[i] = addressElem(ea, arg.type, copy);
                 continue;

compiler/src/dmd/inline.d

@@ -403,7 +403,7 @@ public:
             auto tf = ids.fd.type.isTypeFunction();
 
             if (exp.type.ty == Tstruct && !tf.isRef &&
-                !ids.fd.isCtorDeclaration() && !canElideCopy(s.exp, tf.nextOf()))
+                !ids.fd.isCtorDeclaration() && !canElideCopy(s.exp, tf.nextOf(), true))
             {
                 /* If the inlined function returns a copy of a struct,
                  * and then the return value is used subsequently as an

compiler/src/dmd/semantic3.d

@@ -974,7 +974,7 @@ private extern(C++) final class Semantic3Visitor : Visitor
                         if (funcdecl.vresult)
                         {
                             // Create: return vresult = exp;
-                            if (canElideCopy(exp, funcdecl.vresult.type, false))
+                            if (canElideCopy(exp, funcdecl.vresult.type))
                                 exp = new ConstructExp(rs.loc, funcdecl.vresult, exp);
                             else
                                 exp = new BlitExp(rs.loc, funcdecl.vresult, exp);

compiler/src/tests/cxxfrontend.cc

@@ -1773,6 +1773,7 @@ void expression_h(Expression *e, Scope *sc, Type *t, Loc loc, Expressions *es)
     dmd::expandTuples(es);
     dmd::optimize(e, 0);
     dmd::isLvalue(e);
+    dmd::canElideCopy(e, t);
 }
 
 void hdrgen_h(Module *m, OutBuffer &buf, Modules &ms, ParameterList pl,