Remove synthetic record constructor if the user has written one manually

Co-authored-by: Guillaume Martres <[email protected]>

Author: TheElectronWill

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

@@ -688,6 +688,7 @@ class Definitions {
   @tu lazy val JavaCalendarClass: ClassSymbol = requiredClass("java.util.Calendar")
   @tu lazy val JavaDateClass: ClassSymbol = requiredClass("java.util.Date")
   @tu lazy val JavaFormattableClass: ClassSymbol = requiredClass("java.util.Formattable")
+  @tu lazy val JavaRecordClass: Symbol = getClassIfDefined("java.lang.Record")
 
   @tu lazy val JavaEnumClass: ClassSymbol = {
     val cls = requiredClass("java.lang.Enum")

compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala

@@ -852,7 +852,7 @@ object JavaParsers {
 
       // generate the canonical constructor
       val canonicalConstructor =
-        DefDef(nme.CONSTRUCTOR, joinParams(tparams, List(header)), TypeTree(), EmptyTree).withMods(Modifiers(Flags.JavaDefined, mods.privateWithin))
+        DefDef(nme.CONSTRUCTOR, joinParams(tparams, List(header)), TypeTree(), EmptyTree).withMods(Modifiers(Flags.JavaDefined | Flags.Synthetic, mods.privateWithin))
 
       // return the trees, probably with addCompanionObject (like classDecl)
       val recordTypeDef = atSpan(start, nameOffset) {
@@ -863,7 +863,7 @@ object JavaParsers {
             tparams = tparams,
             true
           )
-        )
+        ).withMods(mods)
       }
       addCompanionObject(statics, recordTypeDef)
     end recordDecl

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

@@ -879,10 +879,18 @@ class Namer { typer: Typer =>
             !sd.symbol.is(Deferred) && sd.matches(denot)))
 
       val isClashingSynthetic =
-        denot.is(Synthetic, butNot = ConstructorProxy)
-        && desugar.isRetractableCaseClassMethodName(denot.name)
-        && isCaseClassOrCompanion(denot.owner)
-        && (definesMember || inheritsConcreteMember)
+        denot.is(Synthetic, butNot = ConstructorProxy) &&
+        (
+          (desugar.isRetractableCaseClassMethodName(denot.name)
+            && isCaseClassOrCompanion(denot.owner)
+            && (definesMember || inheritsConcreteMember))
+          ||
+          // remove synthetic constructor of a java Record if it clashes with a non-synthetic constructor
+          (denot.isConstructor
+            && denot.owner.is(JavaDefined) && denot.owner.derivesFrom(defn.JavaRecordClass)
+            && denot.owner.unforcedDecls.lookupAll(denot.name).exists(c => c != denot.symbol && c.info.matches(denot.info))
+          )
+        )
 
       if isClashingSynthetic then
         typr.println(i"invalidating clashing $denot in ${denot.owner}")
@@ -1734,7 +1742,7 @@ class Namer { typer: Typer =>
   }
 
   /** The type signature of a DefDef with given symbol */
-  def defDefSig(ddef: DefDef, sym: Symbol, completer: Namer#Completer)(using Context): Type = {
+  def defDefSig(ddef: DefDef, sym: Symbol, completer: Namer#Completer)(using Context): ErrorType | Type = {
     // Beware: ddef.name need not match sym.name if sym was freshened!
     val isConstructor = sym.name == nme.CONSTRUCTOR
 
@@ -1776,7 +1784,18 @@ class Namer { typer: Typer =>
     if isConstructor then
       // set result type tree to unit, but take the current class as result type of the symbol
       typedAheadType(ddef.tpt, defn.UnitType)
-      wrapMethType(effectiveResultType(sym, paramSymss))
+      val res = wrapMethType(effectiveResultType(sym, paramSymss))
+      res
+/*      val unlink = sym.owner.is(JavaDefined) && sym.is(Synthetic) && sym.owner.derivesFrom(defn.JavaRecordClass) &&
+        sym.owner.unforcedDecls.lookupAll(sym.name).exists(c => c != sym && c.info.matches(res))
+
+      //println(s"sym: $sym, sym.owner ${sym.owner.flagsUNSAFE.flagsString}, sym ${sym.flagsUNSAFE.flagsString}")
+      //if sym.owner.is(JavaDefined) && sym.is(Synthetic) && sym.owner.derivesFrom(defn.JavaRecordClass) then
+      //  println(s"unlink: $unlink -- ${sym.owner.info.decl(sym.name).alternatives}")
+      if unlink then
+        sym.markAbsent()
+        NoType
+      else res*/
     else
       valOrDefDefSig(ddef, sym, paramSymss, wrapMethType)
   }

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

@@ -2360,7 +2360,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
 
   def typedDefDef(ddef: untpd.DefDef, sym: Symbol)(using Context): Tree = {
     if (!sym.info.exists) { // it's a discarded synthetic case class method, drop it
-      assert(sym.is(Synthetic) && desugar.isRetractableCaseClassMethodName(sym.name))
+      assert(sym.is(Synthetic) /*&& desugar.isRetractableCaseClassMethodName(sym.name)*/, s"$sym -- ${sym.flags.flagsString}")
       sym.owner.info.decls.openForMutations.unlink(sym)
       return EmptyTree
     }

tests/pos-java16+/java-records/R2.java

@@ -5,9 +5,9 @@ public int getInt() {
         }
 
         // Canonical constructor
-        // public R(int i, java.lang.String s) {
-        //     this.i = i;
-        //     this.s = s.intern();
-        // }
+        public R(int i, java.lang.String s) {
+            this.i = i;
+            this.s = s.intern();
+        }
     }
 }