Implement SIP-67: strictEquality pattern matching (fixes #22732) (#23803)

Hi,

this is my attempt at implementing the
[SIP-67](https://github.com/mberndt123/improvement-proposals/blob/strictEquality-pattern-matching/content/strict-equality-pattern-matching.md)
specification. Thanks to @noti0na1 and @dwijnand for the hints you gave
in #22732. Sorry it took so long, please let me know what you think.

Author: odersky

compiler/src/dotty/tools/dotc/config/Feature.scala

@@ -28,6 +28,7 @@ object Feature:
 
   val dependent = experimental("dependent")
   val erasedDefinitions = experimental("erasedDefinitions")
+  val strictEqualityPatternMatching = experimental("strictEqualityPatternMatching")
   val symbolLiterals = deprecated("symbolLiterals")
   val saferExceptions = experimental("saferExceptions")
   val pureFunctions = experimental("pureFunctions")
@@ -59,6 +60,7 @@ object Feature:
     (scala2macros, "Allow Scala 2 macros"),
     (dependent, "Allow dependent method types"),
     (erasedDefinitions, "Allow erased definitions"),
+    (strictEqualityPatternMatching, "relaxed CanEqual checks for ADT pattern matching"),
     (symbolLiterals, "Allow symbol literals"),
     (saferExceptions, "Enable safer exceptions"),
     (pureFunctions, "Enable pure functions for capture checking"),

compiler/src/dotty/tools/dotc/typer/Applications.scala

@@ -1365,7 +1365,7 @@ trait Applications extends Compatibility {
           case Apply(fn @ Select(left, _), right :: Nil) if fn.hasType =>
             val op = fn.symbol
             if (op == defn.Any_== || op == defn.Any_!=)
-              checkCanEqual(left.tpe.widen, right.tpe.widen, app.span)
+              checkCanEqual(left, right.tpe.widen, app.span)
           case _ =>
         }
         app

compiler/src/dotty/tools/dotc/typer/Implicits.scala

@@ -84,6 +84,9 @@ object Implicits:
   def strictEquality(using Context): Boolean =
     ctx.mode.is(Mode.StrictEquality) || Feature.enabled(nme.strictEquality)
 
+  def strictEqualityPatternMatching(using Context): Boolean =
+    Feature.enabled(Feature.strictEqualityPatternMatching)
+
 
   /** A common base class of contextual implicits and of-type implicits which
    *  represents a set of references to implicit definitions.
@@ -1038,8 +1041,9 @@ trait Implicits:
    *   - if one of T, U is an error type, or
    *   - if one of T, U is a subtype of the lifted version of the other,
    *     unless strict equality is set.
+   *   - if strictEqualityPatternMatching is set and the necessary conditions are met
    */
-  def assumedCanEqual(ltp: Type, rtp: Type)(using Context) = {
+  def assumedCanEqual(ltp: Type, rtp: Type, leftTree: Tree = EmptyTree)(using Context): Boolean = {
     // Map all non-opaque abstract types to their upper bound.
     // This is done to check whether such types might plausibly be comparable to each other.
     val lift = new TypeMap {
@@ -1062,15 +1066,23 @@ trait Implicits:
 
     ltp.isError
     || rtp.isError
-    || !strictEquality && (ltp <:< lift(rtp) || rtp <:< lift(ltp))
+    || locally:
+      if strictEquality then
+        strictEqualityPatternMatching &&
+          (leftTree.symbol.isAllOf(Flags.EnumValue) || leftTree.symbol.isAllOf(Flags.Module | Flags.Case)) &&
+          ltp <:< lift(rtp)
+      else
+        ltp <:< lift(rtp) || rtp <:< lift(ltp)
   }
 
-  /** Check that equality tests between types `ltp` and `rtp` make sense */
-  def checkCanEqual(ltp: Type, rtp: Type, span: Span)(using Context): Unit =
-    if (!ctx.isAfterTyper && !assumedCanEqual(ltp, rtp)) {
+  /** Check that equality tests between types `ltp` and `left.tpe` make sense.
+   * `left` is required to check for the condition for language.strictEqualityPatternMatching.
+   */
+  def checkCanEqual(left: Tree, rtp: Type, span: Span)(using Context): Unit =
+    val ltp = left.tpe.widen
+    if !ctx.isAfterTyper && !assumedCanEqual(ltp, rtp, left) then
       val res = implicitArgTree(defn.CanEqualClass.typeRef.appliedTo(ltp, rtp), span)
       implicits.println(i"CanEqual witness found for $ltp / $rtp: $res: ${res.tpe}")
-    }
 
   object hasSkolem extends TreeAccumulator[Boolean]:
     def apply(x: Boolean, tree: Tree)(using Context): Boolean =

compiler/src/dotty/tools/dotc/typer/ReTyper.scala

@@ -175,7 +175,7 @@ class ReTyper(nestingLevel: Int = 0) extends Typer(nestingLevel) with ReChecking
 
   override def inferView(from: Tree, to: Type)(using Context): Implicits.SearchResult =
     Implicits.NoMatchingImplicitsFailure
-  override def checkCanEqual(ltp: Type, rtp: Type, span: Span)(using Context): Unit = ()
+  override def checkCanEqual(left: Tree, rtp: Type, span: Span)(using Context): Unit = ()
 
   override def widenEnumCase(tree: Tree, pt: Type)(using Context): Tree = tree
 

compiler/test/dotty/tools/dotc/typer/SIP67Tests.scala

@@ -0,0 +1,44 @@
+package dotty.tools.dotc.typer
+
+import dotty.tools.DottyTest
+import dotty.tools.dotc.core.Contexts.*
+
+import org.junit.Test
+import org.junit.Assert.fail
+
+class SIP67Tests extends DottyTest:
+
+  private def checkNoErrors(source: String): Unit =
+    val ctx = checkCompile("typer", source)((_, _) => ())
+    if ctx.reporter.hasErrors then
+      fail("Unexpected compilation errors were reported")
+  
+  @Test
+  def sip67test1: Unit =
+    checkNoErrors:
+      """
+      import scala.language.strictEquality
+      import scala.language.experimental.strictEqualityPatternMatching
+      enum Foo:
+        case Bar
+
+      val _ =
+        (??? : Foo) match
+          case Foo.Bar =>
+      """
+  @Test
+  def sip67test2: Unit =
+    checkNoErrors:
+      """
+      import scala.language.strictEquality
+      import scala.language.experimental.strictEqualityPatternMatching
+
+      sealed trait Foo
+
+      object Foo:
+        case object Bar extends Foo
+
+      val _ =
+        (??? : Foo) match
+          case Foo.Bar =>
+      """

library/src/scala/language.scala

@@ -243,6 +243,13 @@ object language {
     @compileTimeOnly("`erasedDefinitions` can only be used at compile time in import statements")
     object erasedDefinitions
 
+    /** Experimental support for relaxed CanEqual checks for ADT pattern matching
+     *
+     * @see [[https://github.com/scala/improvement-proposals/pull/97]]
+     */
+    @compileTimeOnly("`strictEqualityPatternMatching` can only be used at compile time in import statements")
+    object strictEqualityPatternMatching
+
     /** Experimental support for using indentation for arguments
      */
     @compileTimeOnly("`fewerBraces` can only be used at compile time in import statements")

library/src/scala/runtime/stdLibPatches/language.scala

@@ -50,6 +50,13 @@ object language:
     @compileTimeOnly("`erasedDefinitions` can only be used at compile time in import statements")
     object erasedDefinitions
 
+    /** Experimental support for relaxed CanEqual checks for ADT pattern matching
+     *
+     * @see [[https://github.com/scala/improvement-proposals/pull/97]]
+     */
+    @compileTimeOnly("`strictEqualityPatternMatching` can only be used at compile time in import statements")
+    object strictEqualityPatternMatching
+
     /** Experimental support for using indentation for arguments
      */
     @compileTimeOnly("`fewerBraces` can only be used at compile time in import statements")