Do not return java outline dummy constructor in primaryConstructor (#22104)

Fixes #20052
Java outline parser phase for various reasons adds a dummy constructor
to java classes compiling simultenously from scalac. Since they provide
no information to the user and are overall misleading (with always
having the same fake flags and parameters), we filter them out and
return the first constructor that can be found in the source.
This is also what happened up to this point when running the macro with
a java classfile on the classpath instead, since those dummy
constructors cannot be found there.

Author: hamzaremmal

compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala

@@ -2822,7 +2822,26 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
           self.typeRef.info.decls.toList
 
         def paramSymss: List[List[Symbol]] = self.denot.paramSymss
-        def primaryConstructor: Symbol = self.denot.primaryConstructor
+        def primaryConstructor: Symbol =
+          val initialPrimary = self.denot.primaryConstructor
+          // Java outline parser creates a dummyConstructor. We want to avoid returning it here,
+          // instead returning the first non-dummy one, which is what happens when a java classfile
+          // is read from classpath instead of using the java outline parser.
+          // We check if the constructor is dummy if it has the same parameters as defined in JavaParsers.scala,
+          // incliding the private[this] flags and parameter shape with scala.Unit argument.
+          val isJavaDummyConstructor =
+            val paramSymss = initialPrimary.paramSymss
+            initialPrimary.flags.is(Flags.JavaDefined | Flags.Local | Flags.Method | Flags.Private | Flags.PrivateLocal)
+            && {
+              paramSymss match
+                case List(List(typeTree)) if self.typeRef.memberType(typeTree).typeSymbol == defn.UnitClass => true
+                case _ => false
+            }
+          if isJavaDummyConstructor then
+            declarations.filter(sym => sym != initialPrimary && sym.isConstructor).headOption.getOrElse(Symbol.noSymbol)
+          else
+            initialPrimary
+
         def allOverriddenSymbols: Iterator[Symbol] = self.denot.allOverriddenSymbols
         def overridingSymbol(ofclazz: Symbol): Symbol =
           if ofclazz.isClass then self.denot.overridingSymbol(ofclazz.asClass)

tests/run-macros/i20052.check

@@ -0,0 +1,5 @@
+method <init> (Flags.JavaDefined | Flags.Method) List(List((x$0,scala.Int)))
+method <init> (Flags.JavaDefined | Flags.Method) List(List())
+method <init> (Flags.JavaDefined | Flags.Method | Flags.Private) List(List())
+method <init> (Flags.JavaDefined | Flags.Method | Flags.Private) List(List())
+method <init> (Flags.JavaDefined | Flags.Method) List(List((A,_ >: scala.Nothing <: <special-ops>.<FromJavaObject>)), List((x$0,A)))

tests/run-macros/i20052/JavaClass.java

@@ -0,0 +1,4 @@
+public class JavaClass {
+  public JavaClass(int a) {}
+  public JavaClass(float a) {}
+}

tests/run-macros/i20052/JavaClassEmpty.java

@@ -0,0 +1 @@
+public class JavaClassEmpty {}

tests/run-macros/i20052/JavaClassParam.java

@@ -0,0 +1,3 @@
+public class JavaClassParam<A> {
+  public JavaClassParam(A a) {}
+}

tests/run-macros/i20052/JavaClassPrivate.java

@@ -0,0 +1,3 @@
+class JavaClassPrivate {
+  private JavaClassPrivate() {}
+}

tests/run-macros/i20052/JavaClassStartsWithPrivate.java

@@ -0,0 +1,4 @@
+class JavaClassStartsWithPrivate {
+  private JavaClassStartsWithPrivate() {}
+  public JavaClassStartsWithPrivate(int a) {}
+}

tests/run-macros/i20052/Macro.scala

@@ -0,0 +1,16 @@
+import scala.quoted.*
+
+object Macro {
+  inline def logPrimaryConstructor[A]: String = ${ logPrimaryConstructorImpl[A] }
+
+  def logPrimaryConstructorImpl[A](using Type[A], Quotes): Expr[String] = {
+    import quotes.reflect.*
+
+    val primaryConstructor = TypeRepr.of[A].typeSymbol.primaryConstructor
+    val flags = primaryConstructor.flags.show
+    val paramSymss = primaryConstructor.paramSymss
+    val clauses = paramSymss.map(_.map(param => (param.name, TypeRepr.of[A].memberType(param).show)))
+    val str = s"${primaryConstructor} (${primaryConstructor.flags.show}) ${clauses}"
+    Expr(str)
+  }
+}

tests/run-macros/i20052/Test_2.scala

@@ -0,0 +1,6 @@
+@main def Test() =
+  println(Macro.logPrimaryConstructor[JavaClass])
+  println(Macro.logPrimaryConstructor[JavaClassEmpty])
+  println(Macro.logPrimaryConstructor[JavaClassPrivate])
+  println(Macro.logPrimaryConstructor[JavaClassStartsWithPrivate])
+  println(Macro.logPrimaryConstructor[JavaClassParam[Int]])