First-class Java record pattern matching.

This adds Java records as a first-class citizen within Scala's
pattern matching.

Broadly, we synthesize an `inline unapply` on the companion module
which we later use to correlate with the bound variables within
the pattern matcher.

Author: yilinwei

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -869,13 +869,10 @@ object desugar {
 
         val unapplyRHS =
           if (arity == 0) Literal(Constant(true))
-          else tupleApply(
-            vParams.map(
-              param => Select(Ident(unapplyParam.name), param.name)
-            )
-          )
+          else Ident(unapplyParam.name)
 
         val unapplyResTp = if (arity == 0) Literal(Constant(true)) else TypeTree()
+
         val unapplyMeth = DefDef(
           nme.unapply,
           joinParams(derivedTparams, (unapplyParam :: Nil) :: Nil),

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -1636,6 +1636,7 @@ class Definitions {
   def isAbstractFunctionClass(cls: Symbol): Boolean = isVarArityClass(cls, str.AbstractFunction)
   def isTupleClass(cls: Symbol): Boolean = isVarArityClass(cls, str.Tuple)
   def isProductClass(cls: Symbol): Boolean = isVarArityClass(cls, str.Product)
+  def isJavaRecordClass(cls: Symbol): Boolean = cls.is(JavaDefined) && cls.derivesFrom(JavaRecordClass)
 
   def isBoxedUnitClass(cls: Symbol): Boolean =
     cls.isClass && (cls.owner eq ScalaRuntimePackageClass) && cls.name == tpnme.BoxedUnit

compiler/src/dotty/tools/dotc/core/SymUtils.scala

@@ -249,6 +249,10 @@ class SymUtils:
     def caseAccessors(using Context): List[Symbol] =
       self.info.decls.filter(_.is(CaseAccessor))
 
+    // TODO: Check if `Synthetic` is stamped properly
+    def javaRecordComponents(using Context): List[Symbol] =
+      self.info.decls.filter(sym => sym.is(Synthetic) && sym.is(Method) && !sym.isConstructor)
+
     def getter(using Context): Symbol =
       if (self.isGetter) self else accessorNamed(self.asTerm.name.getterName)
 

compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala

@@ -343,8 +343,28 @@ object PatternMatcher {
             .select(defn.RuntimeTuples_apply)
             .appliedTo(receiver, Literal(Constant(i)))
 
-        if (isSyntheticScala2Unapply(unapp.symbol) && caseAccessors.length == args.length)
-          def tupleSel(sym: Symbol) = ref(scrutinee).select(sym)
+        def resultTypeSym = unapp.symbol.info.resultType.typeSymbol
+
+        def isSyntheticJavaRecordUnapply(sym: Symbol) =
+          // Since the `unapply` symbol is marked as inline, the `Typer` wraps the body of the `unapply` in a separate
+          // anonymous class. The result type alone is not enough to distinguish that we're calling the synthesized unapply —
+          // we could have defined a separate `unapply` method returning a Java record somewhere, hence we resort to using
+          // the `coord`.
+          sym.is(Synthetic) && sym.isAnonymousClass && {
+            val resultSym = resultTypeSym
+            // TODO: Can a user define a separate unapply function in Java?
+            val unapplyFn = resultSym.linkedClass.info.decl(nme.unapply)
+            // TODO: This is nasty, can we add an attachment on the anonymous function for a prior link?
+            defn.isJavaRecordClass(resultSym) && unapplyFn.symbol.coord == sym.coord
+          }
+
+        def tupleSel(sym: Symbol) = ref(scrutinee).select(sym)
+        def recordSel(sym: Symbol) = tupleSel(sym).appliedToTermArgs(Nil)
+
+        if (isSyntheticJavaRecordUnapply(unapp.symbol.owner))
+          val components = resultTypeSym.javaRecordComponents.map(recordSel)
+          matchArgsPlan(components, args, onSuccess)
+        else if (isSyntheticScala2Unapply(unapp.symbol) && caseAccessors.length == args.length)
           val isGenericTuple = defn.isTupleClass(caseClass) &&
             !defn.isTupleNType(tree.tpe match { case tp: OrType => tp.join case tp => tp }) // widen even hard unions, to see if it's a union of tuples
           val components = if isGenericTuple then caseAccessors.indices.toList.map(tupleApp(_, ref(scrutinee))) else caseAccessors.map(tupleSel)

compiler/src/dotty/tools/dotc/transform/SyntheticMembers.scala

@@ -521,6 +521,7 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
     def computeFromCaseClass: (Type, List[Type]) =
       val (baseRef, baseInfo) =
         val rawRef = caseClass.typeRef
+        // TODO: HERE!!
         val rawInfo = caseClass.primaryConstructor.info
         optInfo match
           case Some(info) =>

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

@@ -49,6 +49,10 @@ object Applications {
     ref.info.widenExpr.annotatedToRepeated
   }
 
+  // TODO: Error here
+  def isJavaRecordMatch(tp: Type, numArgs: Int, errorPos: SrcPos = NoSourcePosition)(using Context): Boolean =
+    defn.isJavaRecordClass(tp.typeSymbol)
+
   /** Does `tp` fit the "product match" conditions as an unapply result type
    *  for a pattern with `numArgs` subpatterns?
    *  This is the case if `tp` has members `_1` to `_N` where `N == numArgs`.
@@ -108,6 +112,20 @@ object Applications {
     if (isValid) elemTp else NoType
   }
 
+  def javaRecordComponentTypes(tp: Type, errorPos: SrcPos)(using Context): List[Type] = {
+
+    val params = tp.typeSymbol.javaRecordComponents.map(_.info.resultType)
+
+    tp match
+    case tp: AppliedType =>
+      val argsIter = tp.args.iterator
+      for (param <- params) yield param match
+        case param if param.typeSymbol.isTypeParam => argsIter.next()
+        case param => param
+    case _ => params
+
+  }
+
   def productSelectorTypes(tp: Type, errorPos: SrcPos)(using Context): List[Type] = {
     val sels = for (n <- Iterator.from(0)) yield extractorMemberType(tp, nme.selectorName(n), errorPos)
     sels.takeWhile(_.exists).toList
@@ -192,6 +210,8 @@ object Applications {
           // which is better than the message in `fail`.
       else if unapplyResult.derivesFrom(defn.NonEmptyTupleClass) then
         foldApplyTupleType(unapplyResult)
+      else if (isJavaRecordMatch(unapplyResult, args.length, pos)) then
+        javaRecordComponentTypes(unapplyResult, pos)
       else fail
     }
   }

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

@@ -880,9 +880,6 @@ class Namer { typer: Typer =>
      */
     private def invalidateIfClashingSynthetic(denot: SymDenotation): Unit =
 
-      def isJavaRecord(owner: Symbol) =
-        owner.is(JavaDefined) && owner.derivesFrom(defn.JavaRecordClass)
-
       def isCaseClassOrCompanion(owner: Symbol) =
         owner.isClass && {
           if (owner.is(Module)) owner.linkedClass.is(CaseClass)
@@ -907,7 +904,7 @@ class Namer { typer: Typer =>
           )
           ||
           // remove synthetic constructor or method of a java Record if it clashes with a non-synthetic constructor
-          (isJavaRecord(denot.owner)
+          (defn.isJavaRecordClass(denot.owner)
             && denot.is(Method)
             && denot.owner.unforcedDecls.lookupAll(denot.name).exists(c => c != denot.symbol && c.info.matches(denot.info))
           )