Record failures to adapt application arguments

dwijnand · dwijnand · commit 8b8177e95909 · 2023-07-24T15:34:17.000+01:00
diff --git a/compiler/src/dotty/tools/dotc/core/OrderingConstraint.scala b/compiler/src/dotty/tools/dotc/core/OrderingConstraint.scala
@@ -344,7 +344,8 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
       if newSet.isEmpty then deps.remove(referenced)
       else deps.updated(referenced, newSet)
 
-    def traverse(t: Type) = t match
+    def traverse(t: Type) = try
+      t match
       case param: TypeParamRef =>
         if hasBounds(param) then
           if variance >= 0 then coDeps = update(coDeps, param)
@@ -356,6 +357,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
           seen += tp
           traverse(tp.ref)
       case _ => traverseChildren(t)
+    catch case ex: Throwable => handleRecursive("adjust", t.show, ex)
   end Adjuster
 
   /** Adjust dependencies to account for the delta of previous entry `prevEntry`
diff --git a/compiler/src/dotty/tools/dotc/typer/Applications.scala b/compiler/src/dotty/tools/dotc/typer/Applications.scala
@@ -779,7 +779,9 @@ trait Applications extends Compatibility {
     init()
 
     def addArg(arg: Tree, formal: Type): Unit =
-      typedArgBuf += adapt(arg, formal.widenExpr)
+      val arg1 = adapt(arg, formal.widenExpr)
+      typedArgBuf += arg1
+      ok = ok && !arg1.tpe.isError
 
     def makeVarArg(n: Int, elemFormal: Type): Unit = {
       val args = typedArgBuf.takeRight(n).toList
diff --git a/tests/neg/enum-values.check b/tests/neg/enum-values.check
@@ -24,8 +24,8 @@
    |
    |                                             failed with:
    |
-   |                                                 Found:    Array[example.Tag[?]]
-   |                                                 Required: Array[example.ListLike[?]]
+   |                                                 Found:    example.ListLike.type
+   |                                                 Required: Nothing
 -- [E008] Not Found Error: tests/neg/enum-values.scala:34:52 -----------------------------------------------------------
 34 |  val typeCtorsK: Array[TypeCtorsK[?]] = TypeCtorsK.values // error
    |                                         ^^^^^^^^^^^^^^^^^
@@ -38,8 +38,8 @@
    |
    |                                             failed with:
    |
-   |                                                 Found:    Array[example.Tag[?]]
-   |                                                 Required: Array[example.TypeCtorsK[?[_$1]]]
+   |                                                 Found:    example.TypeCtorsK.type
+   |                                                 Required: Nothing
 -- [E008] Not Found Error: tests/neg/enum-values.scala:36:6 ------------------------------------------------------------
 36 |  Tag.valueOf("Int") // error
    |  ^^^^^^^^^^^
diff --git a/tests/neg/enumsAccess.scala b/tests/neg/enumsAccess.scala
@@ -63,7 +63,7 @@ object test5 {
   enum E5[T](x: T) {
     case C3() extends E5[INT](defaultX)// error: illegal reference  // error: illegal reference
     case C4 extends E5[INT](defaultX) // error: illegal reference  // error: illegal reference
-    case C5 extends E5[E5[_]](E5.this) // error: type mismatch
+    case C5 extends E5[E5[_]](E5.this) // error: cannot be instantiated // error: conflicting base types // error: type mismatch
   }
 
   object E5 {
diff --git a/tests/neg/i1430.scala b/tests/neg/i1430.scala
@@ -5,7 +5,7 @@ object Test {
 
   val y: List[List[String]] = List(List(1)) // error: found Int(1), expected: String
 
-  val z: (List[String], List[Int]) = (List(1), List("a")) // error: found Int(1), expected: String // error: found String(a), expected: Int
+  val z: (List[String], List[Int]) = (List(1), List("a")) // error: found Int(1), expected: String
 
   val a: Inv[String] = new Inv(new Inv(1)) // error: found Inv[T], expected: String ... where  T  ...
 
diff --git a/tests/neg/i15525.scala b/tests/neg/i15525.scala
@@ -40,14 +40,14 @@ def element22(
 def test22 =
   Resolution(
     element22(
-      Resolution(element0), Resolution(element0), // error // error
-      Resolution(element0), Resolution(element0), // error // error
-      Resolution(element0), Resolution(element0), // error // error
-      Resolution(element0), Resolution(element0), // error // error
-      Resolution(element0), Resolution(element0), // error // error
-      Resolution(element0), Resolution(element0), // error // error
-      Resolution(element0), Resolution(element0), // error // error
-      Resolution(element0), Resolution(element0), // error // error
-      Resolution(element0), Resolution(element0), // error // error
-      Resolution(element0), Resolution(element0), // error // error
-      Resolution(element0), Resolution(element0)))// error // error
+      Resolution(element0), Resolution(element0), // error
+      Resolution(element0), Resolution(element0),
+      Resolution(element0), Resolution(element0),
+      Resolution(element0), Resolution(element0),
+      Resolution(element0), Resolution(element0),
+      Resolution(element0), Resolution(element0),
+      Resolution(element0), Resolution(element0),
+      Resolution(element0), Resolution(element0),
+      Resolution(element0), Resolution(element0),
+      Resolution(element0), Resolution(element0),
+      Resolution(element0), Resolution(element0)))
diff --git a/tests/neg/i3083.scala b/tests/neg/i3083.scala
@@ -11,7 +11,7 @@
 
       def expression(adder: Addition) = {
         import adder.*
-        add(num(1), num(2)) // error // error (not found: num)
+        add(num(1), num(2)) // error (not found: num)
         }
       }
 
diff --git a/tests/neg/i6779.check b/tests/neg/i6779.check
@@ -11,7 +11,7 @@
    |                             value f is not a member of T.
    |                             An extension method was tried, but could not be fully constructed:
    |
-   |                                 Test.f[G[T]](x)(given_Stuff)
+   |                                 Test.f[G[T]](x)
    |
    |                                 failed with:
    |
diff --git a/tests/neg/i9160.scala b/tests/neg/i9160.scala
@@ -11,10 +11,10 @@ object Test {
     e10: F[T], e11: F[T], e12: F[T],
   ) = ???
   f("foo")(
-    F, F, F, // error // error // error
-    F, F, F, // error // error // error
-    F, F, F, // error // error // error
-    F, F, F, // error // error // error
+    F, F, F, // error
+    F, F, F,
+    F, F, F,
+    F, F, F,
   )
 }
 
@@ -128,4 +128,4 @@ trait Implicits {
   given g98 [T1: F, T2: F, T3: F, T4: F, T5: F, T6: F, T7: F, T8: F, T9: F, T10: F, T11: F, T12: F, T13: F, T14: F, T15: F, T16: F, T17: F, T18: F, T19: F, T20: F, T21: F, T22: F]: G[Int] = ???
   given g99 [T1: F, T2: F, T3: F, T4: F, T5: F, T6: F, T7: F, T8: F, T9: F, T10: F, T11: F, T12: F, T13: F, T14: F, T15: F, T16: F, T17: F, T18: F, T19: F, T20: F, T21: F, T22: F]: G[Int] = ???
   given g100 [T1: F, T2: F, T3: F, T4: F, T5: F, T6: F, T7: F, T8: F, T9: F, T10: F, T11: F, T12: F, T13: F, T14: F, T15: F, T16: F, T17: F, T18: F, T19: F, T20: F, T21: F, T22: F]: G[Int] = ???
-}
+}
diff --git a/tests/neg/recursive-lower-constraint.scala b/tests/neg/recursive-lower-constraint.scala
@@ -3,5 +3,5 @@ class Bar extends Foo[Bar]
 
 class A {
   def foo[T <: Foo[T], U >: Foo[T] <: T](x: T): T = x
-  foo(new Bar) // error
+  foo(new Bar) // error // error
 }
diff --git a/tests/neg/syntax-error-recovery.check b/tests/neg/syntax-error-recovery.check
@@ -94,12 +94,6 @@
    |          Not found: bam
    |
    | longer explanation available when compiling with `-explain`
--- [E006] Not Found Error: tests/neg/syntax-error-recovery.scala:61:10 -------------------------------------------------
-61 |  println(bam) // error
-   |          ^^^
-   |          Not found: bam
-   |
-   | longer explanation available when compiling with `-explain`
 -- [E129] Potential Issue Warning: tests/neg/syntax-error-recovery.scala:7:2 -------------------------------------------
 6 |        2
 7 |  }
diff --git a/tests/neg/syntax-error-recovery.scala b/tests/neg/syntax-error-recovery.scala
@@ -58,5 +58,5 @@ object Test2:
   def foo5(x: Int) =
     foo2(foo2(,) // error // error
 
-  println(bam) // error
+  println(bam)
 // error
diff --git a/tests/pos/i18163.orig.scala b/tests/pos/i18163.orig.scala
@@ -0,0 +1,40 @@
+import scala.language.implicitConversions
+
+// We do have 2 `contramap` functions, one provided via `LoggerSyntax` other via `Contravariant.Ops`
+// `ContravariantMonoidal` given instances are not used, and they do not match our type. Code fails when we have at least 2 instances of them
+// Removal of `import catsSyntax._` allow to compile code
+// Removal of `import odinSyntax.LoggerSyntax` and remaining `catsSyntax` would fail to compile the `def fails`
+
+trait Foo[A]
+trait Bar[A]
+
+trait WriterT[F[_]: Contravariant, L, V]:
+  def contramap[Z](fn: Z => V): WriterT[F, L, Z] = ???
+trait Logger[F[_]]
+class WriterTLogger[F[_]] extends Logger[[G] =>> WriterT[F, List[String], G]]
+
+trait ContravariantMonoidal[F[_]] extends Invariant[F] with Contravariant[F]
+trait Invariant[F[_]]
+object Invariant:
+  given ContravariantMonoidal[Foo] = ???
+  given ContravariantMonoidal[Bar] = ???
+
+trait Contravariant[F[_]] extends Invariant[F]
+object Contravariant:
+  trait Ops[F[_], A]:
+    def contramap[B](f: B => A): F[B] = ???
+
+object catsSyntax:
+  implicit def toContravariantOps[F[_]: Contravariant, A](target: F[A]): Contravariant.Ops[F, A] = ???
+
+object odinSyntax:
+  implicit class LoggerSyntax[F[_]](logger: Logger[F]):
+    def contramap(f: String => String): Logger[F] = ???
+
+import catsSyntax._
+import odinSyntax.LoggerSyntax
+
+class Test:
+  def fails = new WriterTLogger[Option].contramap(identity)
+  def works = LoggerSyntax(new WriterTLogger[Option]).contramap(identity)
+
diff --git a/tests/pos/i18163.scala b/tests/pos/i18163.scala
@@ -0,0 +1,21 @@
+import scala.language.implicitConversions
+
+trait Foo[A]
+trait Bar[B]
+trait Qux[C]
+class Log[K[_]]
+
+trait Inv[F[_]]
+object Inv:
+  given monFoo: Inv[Foo] = ???
+  given monBar: Inv[Bar] = ???
+
+trait InvOps[H[_], D] { def desc(s: String): H[D] = ??? }
+trait LogOps[L[_]]    { def desc(s: String): Log[L] = ??? }
+
+class Test:
+  implicit def LogOps[Q[_]](l: Log[Q]): LogOps[Q] = ???
+  implicit def InvOps[J[_], E](j11: J[E])(implicit z: Inv[J]): InvOps[J, E] = ???
+
+  def fails = new Log[Qux].desc("fails")
+  def works = LogOps[Qux](new Log[Qux]).desc("works")

Original file line number	Diff line number	Diff line change
`@@ -24,8 +24,8 @@`
`24`	`24`	`\|`
`25`	`25`	`\| failed with:`
`26`	`26`	`\|`
`27`		`- \| Found: Array[example.Tag[?]]`
`28`		`- \| Required: Array[example.ListLike[?]]`
	`27`	`+ \| Found: example.ListLike.type`
	`28`	`+ \| Required: Nothing`
`29`	`29`	`-- [E008] Not Found Error: tests/neg/enum-values.scala:34:52 -----------------------------------------------------------`
`30`	`30`	`34 \| val typeCtorsK: Array[TypeCtorsK[?]] = TypeCtorsK.values // error`
`31`	`31`	`\| ^^^^^^^^^^^^^^^^^`
`@@ -38,8 +38,8 @@`
`38`	`38`	`\|`
`39`	`39`	`\| failed with:`
`40`	`40`	`\|`
`41`		`- \| Found: Array[example.Tag[?]]`
`42`		`- \| Required: Array[example.TypeCtorsK[?[_$1]]]`
	`41`	`+ \| Found: example.TypeCtorsK.type`
	`42`	`+ \| Required: Nothing`
`43`	`43`	`-- [E008] Not Found Error: tests/neg/enum-values.scala:36:6 ------------------------------------------------------------`
`44`	`44`	`36 \| Tag.valueOf("Int") // error`
`45`	`45`	`\| ^^^^^^^^^^^`
Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ object test5 {`
`63`	`63`	`enum E5[T](x: T) {`
`64`	`64`	`case C3() extends E5[INT](defaultX)// error: illegal reference // error: illegal reference`
`65`	`65`	`case C4 extends E5[INT](defaultX) // error: illegal reference // error: illegal reference`
`66`		`- case C5 extends E5[E5[_]](E5.this) // error: type mismatch`
	`66`	`+ case C5 extends E5[E5[_]](E5.this) // error: cannot be instantiated // error: conflicting base types // error: type mismatch`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`object E5 {`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@`
`11`	`11`
`12`	`12`	`def expression(adder: Addition) = {`
`13`	`13`	`import adder.*`
`14`		`- add(num(1), num(2)) // error // error (not found: num)`
	`14`	`+ add(num(1), num(2)) // error (not found: num)`
`15`	`15`	`}`
`16`	`16`	`}`
`17`	`17`
Original file line number	Diff line number	Diff line change
`@@ -3,5 +3,5 @@ class Bar extends Foo[Bar]`
`3`	`3`
`4`	`4`	`class A {`
`5`	`5`	`def foo[T <: Foo[T], U >: Foo[T] <: T](x: T): T = x`
`6`		`- foo(new Bar) // error`
	`6`	`+ foo(new Bar) // error // error`
`7`	`7`	`}`