Relax assertion in TyperState#commit If there's nothing to commit

If the added test case is run with `-Yforce-sbt-phases`, a LazyRef (created in
the LazyRef case of TypeMap#mapOver) captures a Context. Later, that LazyRef is
forced, but at that point the TyperState of the captured Context is already
committed, so we're not allowed to commit anything in it anymore. But forcing
the LazyRef ends up calling `isFullyDefined` which unconditionally creates a
temporary TyperState and commit it, thus triggering the assertion.

We fix this by relaxing the assertion to allow committing into a TyperState if
there's nothing to commit. This should handle all LazyRefs since they never wrap
uninstantiated type variables in practice.

Fixes #14907.

Author: smarter

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

@@ -141,18 +141,21 @@ class TyperState() {
     Stats.record("typerState.commit")
     assert(isCommittable, s"$this is not committable")
     assert(!isCommitted, s"$this is already committed")
-    reporter.flush()
-    setCommittable(false)
     val targetState = ctx.typerState
 
-    // Committing into an already committed TyperState usually doesn't make
-    // sense since it means the constraints we're committing won't be propagated
-    // further, but it can happen if the targetState gets captured in a reported
-    // Message, because forcing that Message might involve creating and
-    // committing new TyperStates into the captured one after its been committed.
-    assert(!targetState.isCommitted || targetState.reporter.hasErrors || targetState.reporter.hasWarnings,
+    val nothingToCommit = (constraint eq targetState.constraint) && !reporter.hasUnreportedMessages
+    assert(!targetState.isCommitted || nothingToCommit ||
+       // Committing into an already committed TyperState usually doesn't make
+       // sense since it means the constraints and messages we're committing won't be propagated
+       // further, but it can happen if the targetState gets captured in a reported
+       // Message, because forcing that Message might involve creating and
+       // committing new TyperStates into the captured one after it's been committed.
+        targetState.reporter.hasErrors || targetState.reporter.hasWarnings,
       s"Attempt to commit $this into already committed $targetState")
 
+    reporter.flush()
+    setCommittable(false)
+
     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/pos/i14907.scala

@@ -0,0 +1,11 @@
+object Module {
+  class Fun[N <: Int]()
+  type Fill[N <: Int] = N match {
+    case 0 => EmptyTuple
+    case 1 => Any *: Fill[0]
+  }
+  extension[N <: Int] (f: Fun[N])
+    def apply: Fill[N] => Any = ???
+
+  Fun[1]()(???)
+}