Implement assert & assume properly.

TODO: ===

Author: liufengyun

scalactic/src/main/scala/org/scalactic/BooleanMacro.scala

@@ -865,6 +865,7 @@ object BooleanMacro {
   def parse(condition: Expr[Boolean], prettifier: Expr[Prettifier])(implicit refl: Reflection): Expr[Bool] = {
     import refl._
     import quoted.Toolbox.Default._
+    import util._
 
     def exprStr: String = condition.show
     def defaultCase = '(Bool.simpleMacroBool(~condition, ~exprStr.toExpr, ~prettifier))
@@ -883,88 +884,8 @@ object BooleanMacro {
     }
 
     condition.unseal.underlyingArgument match {
-      case Term.Apply(Term.Select(lhs, op), rhs :: Nil) =>
+      case Term.Apply(Term.IsSelect(sel @ Term.Select(lhs, op)), rhs :: Nil) =>
         op match {
-          case "==" =>
-            val left = lhs.seal[Any]
-            val right = rhs.seal[Any]
-            '{
-              val _left   = ~left
-              val _right  = ~right
-              val _result = _left == _right
-              Bool.binaryMacroBool(_left, ~op.toExpr, _right, _result, ~prettifier)
-            }
-          case "!=" =>
-            val left = lhs.seal[Any]
-            val right = rhs.seal[Any]
-            '{
-              val _left   = ~left
-              val _right  = ~right
-              val _result = _left != _right
-              Bool.binaryMacroBool(_left, ~op.toExpr, _right, _result, ~prettifier)
-            }
-          case ">" =>
-            // blocked by tasty constructors
-            // https://github.com/lampepfl/dotty/issues/5567
-            val left = lhs.seal[Int]
-            val right = rhs.seal[Int]
-            '{
-              val _left   = ~left
-              val _right  = ~right
-              val _result = _left > _right
-              Bool.binaryMacroBool(_left, ~op.toExpr, _right, _result, ~prettifier)
-            }
-          case "<" =>
-            // blocked by tasty constructors
-            // https://github.com/lampepfl/dotty/issues/5567
-            val left = lhs.seal[Int]
-            val right = rhs.seal[Int]
-            '{
-              val _left   = ~left
-              val _right  = ~right
-              val _result = _left < _right
-              Bool.binaryMacroBool(_left, ~op.toExpr, _right, _result, ~prettifier)
-            }
-          case ">=" =>
-            // blocked by tasty constructors
-            // https://github.com/lampepfl/dotty/issues/5567
-            val left = lhs.seal[Int]
-            val right = rhs.seal[Int]
-            '{
-              val _left   = ~left
-              val _right  = ~right
-              val _result = _left >= _right
-              Bool.binaryMacroBool(_left, ~op.toExpr, _right, _result, ~prettifier)
-            }
-          case "<=" =>
-            // blocked by tasty constructors
-            // https://github.com/lampepfl/dotty/issues/5567
-            val left = lhs.seal[Int]
-            val right = rhs.seal[Int]
-            '{
-              val _left   = ~left
-              val _right  = ~right
-              val _result = _left <= _right
-              Bool.binaryMacroBool(_left, ~op.toExpr, _right, _result, ~prettifier)
-            }
-          case "eq" =>
-            val left = lhs.seal[AnyRef]
-            val right = rhs.seal[AnyRef]
-            '{
-              val _left   = ~left
-              val _right  = ~right
-              val _result = _left `eq` _right
-              Bool.binaryMacroBool(_left, ~op.toExpr, _right, _result, ~prettifier)
-            }
-          case "ne" =>
-            val left = lhs.seal[AnyRef]
-            val right = rhs.seal[AnyRef]
-            '{
-              val _left   = ~left
-              val _right  = ~right
-              val _result = _left `ne` _right
-              Bool.binaryMacroBool(_left, ~op.toExpr, _right, _result, ~prettifier)
-            }
           case "||" =>
             val left = parse(lhs.seal[Boolean], prettifier)
             val right = parse(rhs.seal[Boolean], prettifier)
@@ -982,7 +903,22 @@ object BooleanMacro {
             val right = parse(rhs.seal[Boolean], prettifier)
             '(~left & ~right)
           case _ =>
-            defaultCase
+            sel.tpe.widen match {
+              case Type.MethodType(_, Type.ByNameType(_) :: Nil, _) =>
+                defaultCase
+              case _ =>
+                let(lhs) { left =>
+                  let(rhs) { right =>
+                    let(Term.Apply(Term.Select.copy(sel)(left, op), right :: Nil)) { result =>
+                      val l = left.seal[Any]
+                      val r = right.seal[Any]
+                      val b = result.seal[Boolean]
+                      val code = '{ Bool.binaryMacroBool(~l, ~op.toExpr, ~r, ~b, ~prettifier) }
+                      code.unseal
+                    }
+                  }
+                }.seal[Bool]
+            }
         }
       // case TripleEqual(fn, lhs, op, rhs, Some(eq)) =>
       //   val fun = fn.seal[Any => TripleEqualsSupport#Equalizer[_]]