Avoid crash by relaxing TyperState assertion

Flushing a reporter might force error messages (in particular when a
StoreReporter is flushed into a non-StoreReporter), and the TyperState
of the context captured in an error message might already be committed
at this point. In ea6449f I tried to
deal with this by flushing before committing but that's not sufficient
since the reporter we're flushing might contain error messages from a
more deeply nested TyperState. So this commit just relaxes the assertion
(ideally we would also check that only TyperStates created in a
committed TyperState can be committed in one, but keeping track of that
would require an extra field in TyperState).

Author: smarter

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

@@ -143,7 +143,7 @@ class TyperState() {
     reporter.flush()
     setCommittable(false)
     val targetState = ctx.typerState
-    assert(!targetState.isCommitted, s"Attempt to commit $this into already committed $targetState")
+    assert(!targetState.isCommitted || ctx.reporter.errorsReported, s"Attempt to commit $this into already committed $targetState")
     if constraint ne targetState.constraint then
       Stats.record("typerState.commit.new constraint")
       constr.println(i"committing $this to $targetState, fromConstr = $constraint, toConstr = ${targetState.constraint}")

tests/neg/i13101.scala

@@ -0,0 +1,24 @@
+trait Vehicle
+trait Car extends Vehicle
+
+trait Encoder[A]
+object Encoder {
+  implicit val encodeVehicle: Encoder[Vehicle] = ???
+  implicit val encodeCar: Encoder[Car] = ???
+}
+
+trait Route
+trait Printer
+trait Marshaller[-A]  // must be contravariant
+
+object Test {
+  implicit def marshaller[A: Encoder](implicit p: Printer = ???): Marshaller[A] = ???
+    // the `Printer` implicit arg seems to be necessary, either with default value, or no implicit in scope
+
+  def foo[A](v: A)(implicit m: Marshaller[A]): Route = ???
+
+  val route: Route = identity {
+    val f: (Car => Route) => Route = ???  // ok if s/Car/Vehicle/
+    f(vehicle => foo(vehicle)) // error: ambiguous implicit
+  }
+}