Refactor ASSERT(a && b) -> ASSERT(a); ASSERT(b);

Convert conjunctive assertions into separate assertions. This ought to be correctness preserving. I ran the stress tests and didn't notice anything unusual. While I have confidence in it, if you are the slightest bit suspicious of this, please roll it back.

Found instances with `ASSERT(\([^(|]*\) && \([^)|]*\))`
Manually inspected each instance.

1 files changed, 8 insertions, 4 deletions

diff --git a/crawl-ref/source/fineff.cc b/crawl-ref/source/fineff.cc
index b7355270b8..7f11b58b79 100644
--- a/crawl-ref/source/fineff.cc
+++ b/crawl-ref/source/fineff.cc
@@ -95,7 +95,8 @@ void mirror_damage_fineff::merge(const final_effect &fe)
 {
     const mirror_damage_fineff *mdfe =
         dynamic_cast<const mirror_damage_fineff *>(&fe);
-    ASSERT(mdfe && mergeable(*mdfe));
+    ASSERT(mdfe);
+    ASSERT(mergeable(*mdfe));
     damage += mdfe->damage;
 }
 
@@ -103,14 +104,16 @@ void trj_spawn_fineff::merge(const final_effect &fe)
 {
     const trj_spawn_fineff *trjfe =
         dynamic_cast<const trj_spawn_fineff *>(&fe);
-    ASSERT(trjfe && mergeable(*trjfe));
+    ASSERT(trjfe);
+    ASSERT(mergeable(*trjfe));
     damage += trjfe->damage;
 }
 
 void blood_fineff::merge(const final_effect &fe)
 {
     const blood_fineff *bfe = dynamic_cast<const blood_fineff *>(&fe);
-    ASSERT(bfe && mergeable(*bfe));
+    ASSERT(bfe);
+    ASSERT(mergeable(*bfe));
     blood += bfe->blood;
 }
 
@@ -118,7 +121,8 @@ void deferred_damage_fineff::merge(const final_effect &fe)
 {
     const deferred_damage_fineff *ddamfe =
         dynamic_cast<const deferred_damage_fineff *>(&fe);
-    ASSERT(ddamfe && mergeable(*ddamfe));
+    ASSERT(ddamfe);
+    ASSERT(mergeable(*ddamfe));
     damage += ddamfe->damage;
 }