Merge branch 'main' into fix-19530

Author: noti0na1

community-build/community-projects/libretto

@@ -1602,15 +1602,17 @@ object desugar {
    *  skipping elements that are not convertible.
    */
   def patternsToParams(elems: List[Tree])(using Context): List[ValDef] =
-    def toParam(elem: Tree, tpt: Tree): Tree =
+    def toParam(elem: Tree, tpt: Tree, span: Span): Tree =
       elem match
-        case Annotated(elem1, _) => toParam(elem1, tpt)
-        case Typed(elem1, tpt1) => toParam(elem1, tpt1)
-        case Ident(id: TermName) => ValDef(id, tpt, EmptyTree).withFlags(Param)
+        case Annotated(elem1, _) => toParam(elem1, tpt, span)
+        case Typed(elem1, tpt1) => toParam(elem1, tpt1, span)
+        case Ident(id: TermName) => ValDef(id, tpt, EmptyTree).withFlags(Param).withSpan(span)
         case _ => EmptyTree
-    elems.map(param => toParam(param, TypeTree()).withSpan(param.span)).collect {
-      case vd: ValDef => vd
-    }
+    elems
+      .map: param =>
+        toParam(param, TypeTree(), param.span)
+      .collect:
+        case vd: ValDef => vd
 
   def makeContextualFunction(formals: List[Tree], paramNamesOrNil: List[TermName], body: Tree, erasedParams: List[Boolean])(using Context): Function = {
     val mods = Given

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

@@ -1074,7 +1074,7 @@ trait Implicits:
         if (argument.isEmpty) i"missing implicit parameter of type $pt after typer at phase ${ctx.phase.phaseName}"
         else i"type error: ${argument.tpe} does not conform to $pt${err.whyNoMatchStr(argument.tpe, pt)}")
 
-      val usableForInference = !pt.unusableForInference
+      val usableForInference = pt.exists && !pt.unusableForInference
         && (argument.isEmpty || !argument.tpe.unusableForInference)
 
       val result0 = if usableForInference then

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

@@ -383,17 +383,20 @@ object Inferencing {
   def isSkolemFree(tp: Type)(using Context): Boolean =
     !tp.existsPart(_.isInstanceOf[SkolemType])
 
-  /** The list of uninstantiated type variables bound by some prefix of type `T` which
-   *  occur in at least one formal parameter type of a prefix application.
+  /** The list of uninstantiated type variables bound by some prefix of type `T` or
+   *  by arguments of an application prefix, which occur at least once as a formal type parameter
+   *  of an application either from a prefix or an argument of an application node.
    *  Considered prefixes are:
    *    - The function `f` of an application node `f(e1, .., en)`
    *    - The function `f` of a type application node `f[T1, ..., Tn]`
    *    - The prefix `p` of a selection `p.f`.
    *    - The result expression `e` of a block `{s1; .. sn; e}`.
    */
   def tvarsInParams(tree: Tree, locked: TypeVars)(using Context): List[TypeVar] = {
-    @tailrec def boundVars(tree: Tree, acc: List[TypeVar]): List[TypeVar] = tree match {
-      case Apply(fn, _) => boundVars(fn, acc)
+    def boundVars(tree: Tree, acc: List[TypeVar]): List[TypeVar] = tree match {
+      case Apply(fn, args) =>
+        val argTpVars = args.flatMap(boundVars(_, Nil))
+        boundVars(fn, acc ++ argTpVars)
       case TypeApply(fn, targs) =>
         val tvars = targs.filter(_.isInstanceOf[InferredTypeTree]).tpes.collect {
           case tvar: TypeVar
@@ -406,16 +409,18 @@ object Inferencing {
       case Block(_, expr) => boundVars(expr, acc)
       case _ => acc
     }
-    @tailrec def occurring(tree: Tree, toTest: List[TypeVar], acc: List[TypeVar]): List[TypeVar] =
+    def occurring(tree: Tree, toTest: List[TypeVar], acc: List[TypeVar]): List[TypeVar] =
       if (toTest.isEmpty) acc
       else tree match {
-        case Apply(fn, _) =>
+        case Apply(fn, args) =>
+          val argsOcc = args.flatMap(occurring(_, toTest, Nil))
+          val argsNocc = toTest.filterNot(argsOcc.contains)
           fn.tpe.widen match {
             case mtp: MethodType =>
-              val (occ, nocc) = toTest.partition(tvar => mtp.paramInfos.exists(tvar.occursIn))
-              occurring(fn, nocc, occ ::: acc)
+              val (occ, nocc) = argsNocc.partition(tvar => mtp.paramInfos.exists(tvar.occursIn))
+              occurring(fn, nocc, occ ::: argsOcc ::: acc)
             case _ =>
-              occurring(fn, toTest, acc)
+              occurring(fn, argsNocc, argsOcc ::: acc)
           }
         case TypeApply(fn, targs) => occurring(fn, toTest, acc)
         case Select(pre, _) => occurring(pre, toTest, acc)

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

@@ -290,15 +290,25 @@ trait ParallelTesting extends RunnerOrchestration { self =>
 
     /** This callback is executed once the compilation of this test source finished */
     private final def onComplete(testSource: TestSource, reportersOrCrash: Try[Seq[TestReporter]], logger: LoggedRunnable): Unit =
-      reportersOrCrash match {
-        case TryFailure(exn) => onFailure(testSource, Nil, logger, Some(s"Fatal compiler crash when compiling: ${testSource.title}:\n${exn.getMessage}${exn.getStackTrace.map("\n\tat " + _).mkString}"))
-        case TrySuccess(reporters) if !reporters.exists(_.skipped) =>
-          maybeFailureMessage(testSource, reporters) match {
-            case Some(msg) => onFailure(testSource, reporters, logger, Option(msg).filter(_.nonEmpty))
-            case None => onSuccess(testSource, reporters, logger)
+      try
+        reportersOrCrash match
+          case TryFailure(exn) => onFailure(testSource, Nil, logger, Some(s"Fatal compiler crash when compiling: ${testSource.title}:\n${exn.getMessage}${exn.getStackTrace.map("\n\tat " + _).mkString}"))
+          case TrySuccess(reporters) if !reporters.exists(_.skipped) =>
+            maybeFailureMessage(testSource, reporters) match {
+              case Some(msg) => onFailure(testSource, reporters, logger, Option(msg).filter(_.nonEmpty))
+              case None => onSuccess(testSource, reporters, logger)
+            }
+          case _ =>
+      catch case ex: Throwable =>
+        echo(s"Exception thrown onComplete (probably by a reporter) in $testSource: ${ex.getClass}")
+        Try(ex.printStackTrace())
+          .recover{ _ =>
+            val trace = ex.getStackTrace.map(_.toString) // compute this first in case getStackTrace throws an exception
+            echo(s"${ex.getClass.getName} message could not be printed due to an exception while computing the message.")
+            if trace.nonEmpty then trace.foreach(echo) else echo(s"${ex.getClass.getName} stack trace is empty.")
           }
-        case _ =>
-      }
+          .getOrElse(echo(s"${ex.getClass.getName} stack trace could not be printed due to an exception while printing the stack trace."))
+        failTestSource(testSource)
 
     /**
      * Based on the reporters obtained after the compilation, determines if this test has failed.

compiler/test/dotty/tools/vulpix/ParallelTesting.scala

@@ -0,0 +1,15 @@
+//> using scala "3.3.1"
+//> using dep org.http4s::http4s-ember-client:1.0.0-M40
+//> using dep org.http4s::http4s-ember-server:1.0.0-M40
+//> using dep org.http4s::http4s-dsl:1.0.0-M40
+
+//import cats.effect.*
+//import cats.implicits.*
+
+class Concurrent[F[_]]
+
+class Test[F[_]: Concurren]: // error
+    def hello = ???
+
+object Test:
+    def apply[F[_]: Concurrent] = new Test[F]

tests/neg/i8984.check renamed to tests/disabled/neg/i8984.check

@@ -1,4 +1,4 @@
-//> using options -source 3.4-migration
+//> using options "-source:3.4-migration"
 
 trait Reader[T]
 def read[T: Reader](s: String, trace: Boolean = false): T = ???

tests/neg/i8984.scala renamed to tests/disabled/neg/i8984.scala

@@ -0,0 +1,17 @@
+
+trait Animal
+class Dog extends Animal
+
+trait Ev[T]
+
+given Ev[Dog] = ???
+given Ev[Animal] = ???
+given[T: Ev]: Ev[Set[T]] = ???
+
+def f[T: Ev](v: T): Unit = ???
+
+def main =
+	val s = Set(new Dog)
+	f(s) // Ok
+	f(Set(new Dog)) // Error before changes: Ambiguous given instances: both given instance given_Ev_Dog and given instance given_Ev_Animal match type Ev[T]
+

tests/neg/i19320.scala

@@ -0,0 +1,38 @@
+
+trait Nat
+case object Z extends Nat
+case class S[N <: Nat](pred: N) extends Nat
+
+type Z = Z.type
+given zero: Z = Z
+given succ[N <: Nat](using n: N): S[N] = S(n)
+
+case class Sum[N <: Nat, M <: Nat, R <: Nat](result: R)
+
+given sumZ[N <: Nat](using n: N): Sum[Z, N, N] = Sum(n)
+given sumS[N <: Nat, M <: Nat, R <: Nat](
+	using sum: Sum[N, M, R]
+): Sum[S[N], M, S[R]] = Sum(S(sum.result))
+
+def add[N <: Nat, M <: Nat, R <: Nat](n: N, m: M)(
+	using sum: Sum[N, M, R]
+): R = sum.result
+
+case class Prod[N <: Nat, M <: Nat, R <: Nat](result: R)
+
+
+@main def Test: Unit =
+
+	val n1: S[Z] = add(Z, S(Z))
+	summon[n1.type <:< S[Z]] // OK
+
+	val n3: S[S[S[Z]]] = add(S(S(Z)), S(Z))
+	summon[n3.type <:< S[S[S[Z]]]] // Ok
+
+	val m3_2 = add(S(Z), S(S(Z)))
+	summon[m3_2.type <:< S[S[S[Z]]]] // Error before changes: Cannot prove that (m3_2 : S[S[Nat]]) <:< S[S[S[Z]]]
+
+	val m4_2 = add(S(Z), S(S(S(Z))))
+	summon[m4_2.type <:< S[S[S[S[Z]]]]]
+
+