Move isLvalue to expressionsem.d

Author: thewilsonator

compiler/src/dmd/canthrow.d

@@ -23,7 +23,7 @@ import dmd.dsymbol;
 import dmd.dsymbolsem : include;
 import dmd.errorsink;
 import dmd.expression;
-import dmd.expressionsem : errorSupplementalInferredAttr;
+import dmd.expressionsem : errorSupplementalInferredAttr, isLvalue;
 import dmd.func;
 import dmd.globals;
 import dmd.init;

compiler/src/dmd/cxxfrontend.d

@@ -291,6 +291,12 @@ bool fill(StructDeclaration sd, Loc loc,
     return dmd.expressionsem.fill(sd, loc, elements, ctorinit);
 }
 
+bool isLvalue(Expression e)
+{
+    import dmd.expressionsem;
+    return dmd.expressionsem.isLvalue(e);
+}
+
 /***********************************************************
  * func.d
  */

compiler/src/dmd/dtemplate.d

@@ -57,7 +57,7 @@ import dmd.dsymbolsem : dsymbolSemantic, aliasSemantic, search, oneMembers;
 import dmd.errors;
 import dmd.errorsink;
 import dmd.expression;
-import dmd.expressionsem : resolveLoc, expressionSemantic, resolveProperties, checkValue;
+import dmd.expressionsem : resolveLoc, expressionSemantic, resolveProperties, checkValue, isLvalue;
 import dmd.func;
 import dmd.funcsem : functionSemantic, overloadApply;
 import dmd.globals;

compiler/src/dmd/e2ir.d

@@ -40,7 +40,7 @@ import dmd.dsymbol;
 import dmd.dsymbolsem : include, _isZeroInit;
 import dmd.dtemplate;
 import dmd.expression;
-import dmd.expressionsem : fill;
+import dmd.expressionsem : fill, isLvalue;
 import dmd.func;
 import dmd.glue;
 import dmd.hdrgen;

compiler/src/dmd/expression.d

@@ -21,7 +21,7 @@ import dmd.aggregate;
 import dmd.arraytypes;
 import dmd.astenums;
 import dmd.ast_node;
-import dmd.dcast : implicitConvTo;
+import dmd.dcast : implicitConvTo /*toStringExp*/;
 import dmd.dclass;
 import dmd.declaration;
 import dmd.dimport;
@@ -49,7 +49,7 @@ import dmd.root.string;
 import dmd.root.utf;
 import dmd.target;
 import dmd.tokens;
-import dmd.typesem : toHeadMutable, size, mutableOf, unSharedOf;
+import dmd.typesem : toHeadMutable, size /*getFieldIndex*/;
 import dmd.visitor;
 
 enum LOGSEMANTIC = false;
@@ -506,14 +506,6 @@ extern (C++) abstract class Expression : ASTNode
         return null;
     }
 
-    /***************************************
-     * Return !=0 if expression is an lvalue.
-     */
-    bool isLvalue()
-    {
-        return false;
-    }
-
     /****************************************
      * Check that the expression has a valid type.
      * If not, generates an error "... has no type".
@@ -1197,11 +1189,6 @@ extern (C++) class IdentifierExp : Expression
         return new IdentifierExp(loc, ident);
     }
 
-    override final bool isLvalue()
-    {
-        return !this.rvalue;
-    }
-
     override void accept(Visitor v)
     {
         v.visit(this);
@@ -1241,11 +1228,6 @@ extern (C++) final class DsymbolExp : Expression
         this.hasOverloads = hasOverloads;
     }
 
-    override bool isLvalue()
-    {
-        return !rvalue;
-    }
-
     override void accept(Visitor v)
     {
         v.visit(this);
@@ -1286,12 +1268,6 @@ extern (C++) class ThisExp : Expression
         return typeof(return)(true);
     }
 
-    override final bool isLvalue()
-    {
-        // Class `this` should be an rvalue; struct `this` should be an lvalue.
-        return !rvalue && type.toBasetype().ty != Tclass;
-    }
-
     override void accept(Visitor v)
     {
         v.visit(this);
@@ -1672,14 +1648,6 @@ extern (C++) final class StringExp : Expression
         return typeof(return)(true);
     }
 
-    override bool isLvalue()
-    {
-        /* string literal is rvalue in default, but
-         * conversion to reference of static array is only allowed.
-         */
-        return !rvalue && (type && type.toBasetype().ty == Tsarray);
-    }
-
     /********************************
      * Convert string contents to a 0 terminated string,
      * allocated by mem.xmalloc().
@@ -2361,11 +2329,6 @@ extern (C++) final class TemplateExp : Expression
         this.fd = fd;
     }
 
-    override bool isLvalue()
-    {
-        return fd !is null;
-    }
-
     override bool checkType()
     {
         error(loc, "%s `%s` has no type", td.kind(), toChars());
@@ -2558,13 +2521,6 @@ extern (C++) final class VarExp : SymbolExp
         return false;
     }
 
-    override bool isLvalue()
-    {
-        if (rvalue || var.storage_class & (STC.lazy_ | STC.rvalue | STC.manifest))
-            return false;
-        return true;
-    }
-
     override void accept(Visitor v)
     {
         v.visit(this);
@@ -2586,11 +2542,6 @@ extern (C++) final class OverExp : Expression
         type = Type.tvoid;
     }
 
-    override bool isLvalue()
-    {
-        return true;
-    }
-
     override void accept(Visitor v)
     {
         v.visit(this);
@@ -2906,11 +2857,6 @@ extern (C++) class BinAssignExp : BinExp
         super(loc, op, e1, e2);
     }
 
-    override final bool isLvalue()
-    {
-        return !rvalue;
-    }
-
     override void accept(Visitor v)
     {
         v.visit(this);
@@ -3104,16 +3050,6 @@ extern (C++) final class DotVarExp : UnaExp
         this.hasOverloads = hasOverloads;
     }
 
-    override bool isLvalue()
-    {
-        if (rvalue)
-            return false;
-        if (e1.op != EXP.structLiteral)
-            return true;
-        auto vd = var.isVarDeclaration();
-        return !(vd && vd.isField());
-    }
-
     override void accept(Visitor v)
     {
         v.visit(this);
@@ -3328,24 +3264,6 @@ extern (C++) final class CallExp : UnaExp
         return new CallExp(loc, e1.syntaxCopy(), arraySyntaxCopy(arguments), names ? names.copy() : null);
     }
 
-    override bool isLvalue()
-    {
-        if (rvalue)
-            return false;
-        Type tb = e1.type.toBasetype();
-        if (tb.ty == Tdelegate || tb.ty == Tpointer)
-            tb = tb.nextOf();
-        auto tf = tb.isTypeFunction();
-        if (tf && tf.isRef)
-        {
-            if (auto dve = e1.isDotVarExp())
-                if (dve.var.isCtorDeclaration())
-                    return false;
-            return true; // function returns a reference
-        }
-        return false;
-    }
-
     override void accept(Visitor v)
     {
         v.visit(this);
@@ -3447,11 +3365,6 @@ extern (C++) final class PtrExp : UnaExp
         type = t;
     }
 
-    override bool isLvalue()
-    {
-        return !rvalue;
-    }
-
     override void accept(Visitor v)
     {
         v.visit(this);
@@ -3576,16 +3489,6 @@ extern (C++) final class CastExp : UnaExp
         return to ? new CastExp(loc, e1.syntaxCopy(), to.syntaxCopy()) : new CastExp(loc, e1.syntaxCopy(), mod);
     }
 
-    override bool isLvalue()
-    {
-        //printf("e1.type = %s, to.type = %s\n", e1.type.toChars(), to.toChars());
-        if (rvalue || !e1.isLvalue())
-            return false;
-        return (to.ty == Tsarray && (e1.type.ty == Tvector || e1.type.ty == Tsarray)) ||
-            (to.ty == Taarray && e1.type.ty == Taarray) ||
-            e1.type.mutableOf.unSharedOf().equals(to.mutableOf().unSharedOf());
-    }
-
     override void accept(Visitor v)
     {
         v.visit(this);
@@ -3635,11 +3538,6 @@ extern (C++) final class VectorArrayExp : UnaExp
         super(loc, EXP.vectorArray, e1);
     }
 
-    override bool isLvalue()
-    {
-        return !rvalue && e1.isLvalue();
-    }
-
     override void accept(Visitor v)
     {
         v.visit(this);
@@ -3689,14 +3587,6 @@ extern (C++) final class SliceExp : UnaExp
         return se;
     }
 
-    override bool isLvalue()
-    {
-        /* slice expression is rvalue in default, but
-         * conversion to reference of static array is only allowed.
-         */
-        return !rvalue && (type && type.toBasetype().ty == Tsarray);
-    }
-
     override Optional!bool toBool()
     {
         return e1.toBool();
@@ -3757,15 +3647,6 @@ extern (C++) final class ArrayExp : UnaExp
         return ae;
     }
 
-    override bool isLvalue()
-    {
-        if (rvalue)
-            return false;
-        if (type && type.toBasetype().ty == Tvoid)
-            return false;
-        return true;
-    }
-
     override void accept(Visitor v)
     {
         v.visit(this);
@@ -3817,11 +3698,6 @@ extern (C++) final class CommaExp : BinExp
         originalExp = oe;
     }
 
-    override bool isLvalue()
-    {
-        return !rvalue && e2.isLvalue();
-    }
-
     override Optional!bool toBool()
     {
         return e2.toBool();
@@ -3892,11 +3768,6 @@ extern (C++) final class DelegatePtrExp : UnaExp
         super(loc, EXP.delegatePointer, e1);
     }
 
-    override bool isLvalue()
-    {
-        return !rvalue && e1.isLvalue();
-    }
-
     override void accept(Visitor v)
     {
         v.visit(this);
@@ -3915,11 +3786,6 @@ extern (C++) final class DelegateFuncptrExp : UnaExp
         super(loc, EXP.delegateFunctionPointer, e1);
     }
 
-    override bool isLvalue()
-    {
-        return !rvalue && e1.isLvalue();
-    }
-
     override void accept(Visitor v)
     {
         v.visit(this);
@@ -3955,19 +3821,6 @@ extern (C++) final class IndexExp : BinExp
         return ie;
     }
 
-    override bool isLvalue()
-    {
-        if (rvalue)
-            return false;
-        auto t1b = e1.type.toBasetype();
-        if (t1b.isTypeAArray() || t1b.isTypeSArray() ||
-            (e1.isIndexExp() && t1b != t1b.isTypeDArray()))
-        {
-            return e1.isLvalue();
-        }
-        return true;
-    }
-
     override void accept(Visitor v)
     {
         v.visit(this);
@@ -4036,17 +3889,6 @@ extern (C++) class AssignExp : BinExp
         super(loc, tok, e1, e2);
     }
 
-    override final bool isLvalue()
-    {
-        // Array-op 'x[] = y[]' should make an rvalue.
-        // Setting array length 'x.length = v' should make an rvalue.
-        if (e1.op == EXP.slice || e1.op == EXP.arrayLength)
-        {
-            return false;
-        }
-        return !rvalue;
-    }
-
     override void accept(Visitor v)
     {
         v.visit(this);
@@ -4770,11 +4612,6 @@ extern (C++) final class CondExp : BinExp
         return new CondExp(loc, econd.syntaxCopy(), e1.syntaxCopy(), e2.syntaxCopy());
     }
 
-    override bool isLvalue()
-    {
-        return !rvalue && e1.isLvalue() && e2.isLvalue();
-    }
-
     override void accept(Visitor v)
     {
         v.visit(this);