Relax assertEquals strictness about type equality.

docs/assertions.md

@@ -83,19 +83,18 @@ Comparing two values of different types is a compile error.
 assertEquals(1, "")
 ```
 
-The two types must match exactly, it's a type error to compare two values even
-if one value is a subtype of the other.
+The "expected" value (second argument) must be a subtype of the "obtained" value
+(first argument). It's a type error to compare two values even if one value is a
+subtype of the other.
 
-```scala mdoc:fail
-assertEquals(Some(1), Option(1))
+```scala mdoc
+assertEquals(Option(1), Some(1))
 ```
 
-Upcast the subtype using a type ascription `subtype: Supertype` when you want to
-compare a subtype with a supertype.
+It's a compile error if you swap the order of the arguments.
 
-```scala mdoc
-// OK
-assertEquals(Some(1): Option[Int], Option(1))
+```scala mdoc:fail
+assertEquals(Some(1), Option(1))
 ```
 
 ## `assertNotEquals()`

munit/shared/src/main/scala/munit/Assertions.scala

@@ -76,7 +76,7 @@ trait Assertions extends MacroCompat.CompileErrorMacro {
       obtained: A,
       expected: B,
       clue: => Any = "values are not the same"
-  )(implicit loc: Location, ev: A =:= B): Unit = {
+  )(implicit loc: Location, ev: B <:< A): Unit = {
     StackTraces.dropInside {
       if (obtained != expected) {
         Diffs.assertNoDiff(

tests/shared/src/test/scala/munit/AssertionsSuite.scala

@@ -47,4 +47,15 @@ class AssertionsSuite extends BaseSuite {
        |}
        |""".stripMargin
   )
+
+  test("subtype".tag(NoDotty)) {
+    assertEquals(Option(1), Some(1))
+    assertNoDiff(
+      compileErrors("assertEquals(Some(1), Option(1))"),
+      """|error: Cannot prove that Option[Int] <:< Some[Int].
+         |assertEquals(Some(1), Option(1))
+         |            ^
+         |""".stripMargin
+    )
+  }
 }