move Type.isAssignable to typesem.d (#21602)

Author: thewilsonator

compiler/src/dmd/arrayop.d

@@ -31,6 +31,7 @@ import dmd.location;
 import dmd.mtype;
 import dmd.common.outbuffer;
 import dmd.tokens;
+import dmd.typesem : isAssignable;
 import dmd.visitor;
 
 /**********************************************

compiler/src/dmd/frontend.h

@@ -2126,7 +2126,6 @@ class Type : public ASTNode
     virtual bool isUnsigned();
     virtual bool isScopeClass();
     virtual bool isString();
-    virtual bool isAssignable();
     virtual bool isBoolean();
     bool isConst() const;
     bool isImmutable() const;
@@ -4588,7 +4587,6 @@ class TypeEnum final : public Type
     bool isUnsigned() override;
     bool isBoolean() override;
     bool isString() override;
-    bool isAssignable() override;
     bool needsDestruction() override;
     bool needsCopyOrPostblit() override;
     bool needsNested() override;
@@ -4857,7 +4855,6 @@ class TypeStruct final : public Type
     TypeStruct* syntaxCopy() override;
     structalign_t alignment() override;
     Expression* defaultInitLiteral(Loc loc) override;
-    bool isAssignable() override;
     bool isBoolean() override;
     bool needsDestruction() override;
     bool needsCopyOrPostblit() override;

compiler/src/dmd/mtype.d

@@ -30,7 +30,6 @@ import dmd.dtemplate;
 import dmd.enumsem;
 import dmd.errors;
 import dmd.expression;
-import dmd.dsymbolsem : determineSize;
 import dmd.hdrgen;
 import dmd.id;
 import dmd.identifier;
@@ -687,19 +686,6 @@ extern (C++) abstract class Type : ASTNode
         return false;
     }
 
-    /**************************
-     * When T is mutable,
-     * Given:
-     *      T a, b;
-     * Can we bitwise assign:
-     *      a = b;
-     * ?
-     */
-    bool isAssignable()
-    {
-        return true;
-    }
-
     /**************************
      * Returns true if T can be converted to boolean value.
      */
@@ -3061,45 +3047,6 @@ extern (C++) final class TypeStruct : Type
         return structinit;
     }
 
-    override bool isAssignable()
-    {
-        bool assignable = true;
-        uint offset = ~0; // dead-store initialize to prevent spurious warning
-
-        sym.determineSize(sym.loc);
-
-        /* If any of the fields are const or immutable,
-         * then one cannot assign this struct.
-         */
-        for (size_t i = 0; i < sym.fields.length; i++)
-        {
-            VarDeclaration v = sym.fields[i];
-            //printf("%s [%d] v = (%s) %s, v.offset = %d, v.parent = %s\n", sym.toChars(), i, v.kind(), v.toChars(), v.offset, v.parent.kind());
-            if (i == 0)
-            {
-            }
-            else if (v.offset == offset)
-            {
-                /* If any fields of anonymous union are assignable,
-                 * then regard union as assignable.
-                 * This is to support unsafe things like Rebindable templates.
-                 */
-                if (assignable)
-                    continue;
-            }
-            else
-            {
-                if (!assignable)
-                    return false;
-            }
-            assignable = v.type.isMutable() && v.type.isAssignable();
-            offset = v.offset;
-            //printf(" -> assignable = %d\n", assignable);
-        }
-
-        return assignable;
-    }
-
     override bool isBoolean()
     {
         return false;
@@ -3261,11 +3208,6 @@ extern (C++) final class TypeEnum : Type
         return memType().isString();
     }
 
-    override bool isAssignable()
-    {
-        return memType().isAssignable();
-    }
-
     override bool needsDestruction()
     {
         return memType().needsDestruction();

compiler/src/dmd/mtype.h

@@ -238,7 +238,6 @@ class Type : public ASTNode
     virtual bool isUnsigned();
     virtual bool isScopeClass();
     virtual bool isString();
-    virtual bool isAssignable();
     virtual bool isBoolean();
     bool isConst() const       { return (mod & MODconst) != 0; }
     bool isImmutable() const   { return (mod & MODimmutable) != 0; }
@@ -692,7 +691,6 @@ class TypeStruct final : public Type
     TypeStruct *syntaxCopy() override;
     structalign_t alignment() override;
     Expression *defaultInitLiteral(Loc loc) override;
-    bool isAssignable() override;
     bool isBoolean() override;
     bool needsDestruction() override;
     bool needsCopyOrPostblit() override;
@@ -723,7 +721,6 @@ class TypeEnum final : public Type
     bool isUnsigned() override;
     bool isBoolean() override;
     bool isString() override;
-    bool isAssignable() override;
     bool needsDestruction() override;
     bool needsCopyOrPostblit() override;
     bool needsNested() override;

compiler/src/dmd/typesem.d

@@ -476,6 +476,60 @@ bool isCopyable(Type t)
     return true;
 }
 
+/**************************
+ * When T is mutable,
+ * Given:
+ *      T a, b;
+ * Can we bitwise assign:
+ *      a = b;
+ * ?
+ */
+bool isAssignable(Type t)
+{
+    if (auto te = t.isTypeEnum())
+        t = te.memType();
+    TypeStruct ts = t.isTypeStruct();
+    if (!ts)
+        return true;
+
+    bool assignable = true;
+    uint offset = ~0; // dead-store initialize to prevent spurious warning
+
+    auto sym = ts.sym;
+    sym.determineSize(sym.loc);
+
+    /* If any of the fields are const or immutable,
+     * then one cannot assign this struct.
+     */
+    for (size_t i = 0; i < sym.fields.length; i++)
+    {
+        VarDeclaration v = sym.fields[i];
+        //printf("%s [%d] v = (%s) %s, v.offset = %d, v.parent = %s\n", sym.toChars(), i, v.kind(), v.toChars(), v.offset, v.parent.kind());
+        if (i == 0)
+        {
+        }
+        else if (v.offset == offset)
+        {
+            /* If any fields of anonymous union are assignable,
+             * then regard union as assignable.
+             * This is to support unsafe things like Rebindable templates.
+             */
+            if (assignable)
+                continue;
+        }
+        else
+        {
+            if (!assignable)
+                return false;
+        }
+        assignable = v.type.isMutable() && v.type.isAssignable();
+        offset = v.offset;
+        //printf(" -> assignable = %d\n", assignable);
+    }
+
+    return assignable;
+}
+
 /************************************
  * Determine mutability of indirections in (ref) t.
  *