Merge pull request #6243 from dotty-staging/fix/i6236

Fix #6236: drop @Repeated when inferring type args, return types

Author: abgruszecki

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

@@ -277,6 +277,9 @@ trait ConstraintHandling[AbstractContext] {
    *      of `scala.Singleton`, widen `tp`.
    *   2. If `tp` is a union type, yet upper bound is not a union type,
    *      approximate the union type from above by an intersection of all common base types.
+   *
+   * At this point we also drop the @Repeated annotation to avoid inferring type arguments with it,
+   * as those could leak the annotation to users (see run/inferred-repeated-result).
    */
   def widenInferred(tp: Type, bound: Type)(implicit actx: AbstractContext): Type = {
     def isMultiSingleton(tp: Type): Boolean = tp.stripAnnots match {
@@ -302,7 +305,7 @@ trait ConstraintHandling[AbstractContext] {
       if (isMultiSingleton(tp) && !isMultiSingleton(bound) &&
           !isSubTypeWhenFrozen(bound, defn.SingletonType)) tp.widen
       else tp
-    widenOr(widenSingle(tp))
+    widenOr(widenSingle(tp)).dropRepeatedAnnot
   }
 
   /** The instance type of `param` in the current constraint (which contains `param`).

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

@@ -1485,6 +1485,13 @@ object Types {
      */
     def signature(implicit ctx: Context): Signature = Signature.NotAMethod
 
+    def dropRepeatedAnnot(implicit ctx: Context): Type = this match {
+      case AnnotatedType(parent, annot) if annot.symbol eq defn.RepeatedAnnot => parent
+      case tp @ AnnotatedType(parent, annot) =>
+        tp.derivedAnnotatedType(parent.dropRepeatedAnnot, annot)
+      case tp => tp
+    }
+
     def annotatedToRepeated(implicit ctx: Context): Type = this match {
       case tp @ ExprType(tp1) => tp.derivedExprType(tp1.annotatedToRepeated)
       case AnnotatedType(tp, annot) if annot matches defn.RepeatedAnnot =>

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

@@ -1320,10 +1320,15 @@ class Namer { typer: Typer =>
       // Widen rhs type and eliminate `|' but keep ConstantTypes if
       // definition is inline (i.e. final in Scala2) and keep module singleton types
       // instead of widening to the underlying module class types.
-      def widenRhs(tp: Type): Type = tp.widenTermRefExpr match {
-        case ctp: ConstantType if isInlineVal => ctp
-        case ref: TypeRef if ref.symbol.is(ModuleClass) => tp
-        case _ => tp.widen.widenUnion
+      // We also drop the @Repeated annotation here to avoid leaking it in method result types
+      // (see run/inferred-repeated-result).
+      def widenRhs(tp: Type): Type = {
+        val tp1 = tp.widenTermRefExpr match {
+          case ctp: ConstantType if isInlineVal => ctp
+          case ref: TypeRef if ref.symbol.is(ModuleClass) => tp
+          case _ => tp.widen.widenUnion
+        }
+        tp1.dropRepeatedAnnot
       }
 
       // Replace aliases to Unit by Unit itself. If we leave the alias in

tests/run/inferred-repeated-result.check

@@ -0,0 +1,4 @@
+C.bar1 : scala.Option[scala.collection.Seq[scala.Predef.String]]
+C.bar2 : scala.Option[scala.collection.Seq[scala.Predef.String]]
+C.foo1 : scala.collection.Seq[scala.Predef.String]
+C.foo2 : scala.collection.Seq[scala.Predef.String]

tests/run/inferred-repeated-result/test_1.scala

@@ -0,0 +1,21 @@
+object Macros {
+  import scala.quoted._
+  import scala.quoted.autolift._
+  import scala.tasty._
+
+  inline def go[T](t: => T) = ${ impl('t) }
+  def impl[T](expr: Expr[T])(implicit reflect: Reflection): Expr[Unit] = {
+    import reflect._
+
+    val tree = expr.unseal
+
+    val methods =
+      tree.tpe.classSymbol.get.classMethods.map { m =>
+        val name = m.showCode
+        val returnType = m.tree.returnTpt.tpe.showCode
+        s"$name : $returnType"
+      }.sorted
+
+    methods.foldLeft('{}) { (res, m) => '{ $res; println(${m}) } }
+  }
+}

tests/run/inferred-repeated-result/test_2.scala

@@ -0,0 +1,19 @@
+class C {
+  def foo1(s: String*) = s
+  def foo2(s: String*) = {
+    val s1 = s
+    s
+  }
+
+  def bar1(s: String*) = Option(s)
+  def bar2(s: String*) = {
+    val o = Option(s)
+    o
+  }
+}
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    Macros.go(new C)
+  }
+}