Suppress the "read-modify-write" error if type is a struct or a class

changelog/no-readmodify-error-if-struct-class.dd

@@ -0,0 +1,23 @@
+Suppress the "read-modify-write" error if type is a struct or a class
+
+If a struct or class with shared type implements the opUnary or opOpAssign
+operator then it is possible to perform "read-modify-write" operations
+because the operator's implementation is supposed to perform atomic operations.
+
+The purpose of this modification is to allow the creation of wrappers
+(with structs or classes) to run atomic operations silently, for example:
+
+---
+shared struct Atomic {
+    int a;
+
+    int opUnary(string s)() if (s == "++")
+    {
+        import core.atomic : atomicOp;
+        return atomicOp!"+="(a, 1);
+    }
+}
+
+Atomic atomicvar;
+atomicvar++; // Safe! Atomic struct implements opUnary
+---

src/dmd/expression.d

@@ -1353,7 +1353,7 @@ extern (C++) abstract class Expression : ASTNode
     extern (D) final bool checkReadModifyWrite(TOK rmwOp, Expression ex = null)
     {
         //printf("Expression::checkReadModifyWrite() %s %s", toChars(), ex ? ex.toChars() : "");
-        if (!type || !type.isShared())
+        if (!type || !type.isShared() || type.isTypeStruct() || type.isTypeClass())
             return false;
 
         // atomicOp uses opAssign (+=/-=) rather than opOp (++/--) for the CT string literal.

test/compilable/readmodify_structclass.d

@@ -0,0 +1,35 @@
+/*
+REQUIRED_ARGS:
+TEST_OUTPUT:
+---
+---
+*/
+shared struct S
+{
+    int x = 0;
+
+    int opUnary(string s)() if (s == "++")
+    {
+        import core.atomic : atomicOp;
+        return atomicOp!"+="(x, 1);
+    }
+}
+
+shared class C
+{
+    int x = 0;
+
+    int opUnary(string s)() if (s == "++")
+    {
+        import core.atomic : atomicOp;
+        return atomicOp!"+="(x, 1);
+    }
+}
+
+void main()
+{
+    S s;
+    s++;
+    shared(C) c = new C();
+    c++;
+}