Flag inferred terms containing skolems as errors

They would crash in the pickler otherwise.

Author: odersky

compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala

@@ -150,7 +150,7 @@ enum ErrorMessageID extends java.lang.Enum[ErrorMessageID] {
     UnknownNamedEnclosingClassOrObjectID,
     IllegalCyclicTypeReferenceID,
     MissingTypeParameterInTypeAppID,
-    UNUSED_ImplicitTypesCanOnlyBeFunctionTypesID,
+    SkolemInInferredID,
     ErasedTypesCanOnlyBeFunctionTypesID,
     CaseClassMissingNonImplicitParamListID,
     EnumerationsShouldNotBeEmptyID,

compiler/src/dotty/tools/dotc/reporting/messages.scala

@@ -1244,6 +1244,24 @@ import transform.SymUtils._
            |""".stripMargin
   }
 
+  class SkolemInInferred(tree: tpd.Tree, pt: Type, argument: tpd.Tree)(using Context)
+  extends TypeMsg(SkolemInInferredID):
+    private def argStr =
+      if argument.isEmpty then ""
+      else i" from argument of type ${argument.tpe.widen}"
+    def msg =
+      em"""Failure to generate given instance for type $pt$argStr)
+          |
+          |I found: $tree
+          |But the part corresponding to `<skolem>` is not a reference that can be generated.
+          |This might be because resolution yielded as given instance a function that is not known to be pure."""
+    def explain =
+      em"""The part of given resolution that corresponds to `<skolem>` produced a term that
+          |is not a stable reference. Therefore a given instance could not be generated.
+          |
+          |To trouble-shoot the problem, try to supply an explicit expression instead of
+          |relying on implicit search at this point."""
+
   class SuperQualMustBeParent(qual: untpd.Ident, cls: ClassSymbol)(using Context)
   extends ReferenceMsg(SuperQualMustBeParentID) {
     def msg = em"""|$qual does not name a parent of $cls"""

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

@@ -917,6 +917,19 @@ trait Implicits:
       implicits.println(i"Eql witness found for $ltp / $rtp: $res: ${res.tpe}")
     }
 
+  object hasSkolem extends TreeAccumulator[Boolean]:
+    def apply(x: Boolean, tree: Tree)(using Context): Boolean =
+      x || {
+        tree match
+          case tree: Ident => tree.symbol.isSkolem
+          case Select(qual, _) => apply(x, qual)
+          case Apply(fn, _) => apply(x, fn)
+          case TypeApply(fn, _) => apply(x, fn)
+          case tree: Applications.IntegratedTypeArgs => apply(x, tree.app)
+          case _: This => false
+          case _ => foldOver(x, tree)
+      }
+
   /** Find an implicit parameter or conversion.
    *  @param pt              The expected type of the parameter or conversion.
    *  @param argument        If an implicit conversion is searched, the argument to which
@@ -940,6 +953,8 @@ trait Implicits:
           case result: SearchSuccess =>
             result.tstate.commit()
             ctx.gadt.restore(result.gstate)
+            if hasSkolem(false, result.tree) then
+              report.error(SkolemInInferred(result.tree, pt, argument), ctx.source.atSpan(span))
             implicits.println(i"success: $result")
             implicits.println(i"committing ${result.tstate.constraint} yielding ${ctx.typerState.constraint} in ${ctx.typerState}")
             result

tests/neg/i8623.check

@@ -0,0 +1,10 @@
+-- [E142] Type Error: tests/neg/i8623.scala:11:2 -----------------------------------------------------------------------
+11 |  unseal.pos  // error
+   |  ^^^^^^
+   |  Failure to generate given instance for type ?{ pos: ? } from argument of type ?1.tasty.Tree)
+   |
+   |  I found: <skolem>.tasty.pos(unseal(given_QC[Any]))
+   |  But the part corresponding to `<skolem>` is not a reference that can be generated.
+   |  This might be because resolution yielded as given instance a function that is not known to be pure.
+
+longer explanation available when compiling with `-explain`

tests/neg/i8623.scala

@@ -0,0 +1,12 @@
+
+trait QC:
+  object tasty:
+    type Tree
+    extension (tree: Tree)
+      def pos: Tree = ???
+
+def test =
+  given [T] as QC = ???
+  def unseal(using qctx: QC): qctx.tasty.Tree = ???
+  unseal.pos  // error
+