Merge pull request #10371 from dotty-staging/fix-#8623

Author: smarter

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

@@ -166,6 +166,7 @@ object desugar {
     val mods = vdef.mods
 
     val valName = normalizeName(vdef, tpt).asTermName
+    val vdef1 = cpy.ValDef(vdef)(name = valName)
 
     if (isSetterNeeded(vdef)) {
       // TODO: copy of vdef as getter needed?
@@ -182,9 +183,9 @@ object desugar {
         tpt      = TypeTree(defn.UnitType),
         rhs      = setterRhs
       ).withMods((mods | Accessor) &~ (CaseAccessor | GivenOrImplicit | Lazy))
-      Thicket(vdef, setter)
+      Thicket(vdef1, setter)
     }
-    else vdef
+    else vdef1
   }
 
   def makeImplicitParameters(tpts: List[Tree], implicitFlag: FlagSet, forPrimaryConstructor: Boolean = false)(using Context): List[ValDef] =

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -3533,13 +3533,18 @@ object Parsers {
           then paramClauses(givenOnly = true)
           else Nil
         newLinesOpt()
-        if !name.isEmpty || !tparams.isEmpty || !vparamss.isEmpty then
+        val noParams = tparams.isEmpty && vparamss.isEmpty
+        if !(name.isEmpty && noParams) then
           accept(nme.as)
         val parents = constrApps(commaOK = true, templateCanFollow = true)
         if in.token == EQUALS && parents.length == 1 && parents.head.isType then
           accept(EQUALS)
           mods1 |= Final
-          DefDef(name, tparams, vparamss, parents.head, subExpr())
+          if noParams && !mods.is(Inline) then
+            mods1 |= Lazy
+            ValDef(name, parents.head, subExpr())
+          else
+            DefDef(name, tparams, vparamss, parents.head, subExpr())
         else
           possibleTemplateStart()
           val tparams1 = tparams.map(tparam => tparam.withMods(tparam.mods | PrivateLocal))

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,25 @@ 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 total and side-effect free."""
+    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/transform/CacheAliasImplicits.scala

@@ -18,47 +18,56 @@ object CacheAliasImplicits {
 
   /** Flags that disable caching */
   val NoCacheFlags =
-    StableRealizable |  // It's a simple forwarder, leave it as one
-    Exported            // Export forwarders are never cached
+    StableRealizable  // It's a simple forwarder, leave it as one
+    | Exported        // Export forwarders are never cached
 }
 
 /** This phase ensures that the right hand side of parameterless alias implicits
- *  is cached. It applies to all alias implicits that have neither type parameters
- *  nor a given clause. Example: The alias
+ *  is cached if necessary. Dually, it optimizes lazy vak alias implicit to be uncached
+ *  if that does not change runtime behavior.
  *
- *      TC = rhs
+ *  A definition does not need to be cached if its right hand side has a stable type
+ *  and is of one of them forms
  *
- *  is expanded before this phase to:
- *
- *      implicit def a: TC = rhs
- *
- *  It is then expanded further as follows:
- *
- *  1. If `rhs` is a simple name `x` (possibly with a `this.` prefix) that
- *     refers to a value, leave it as is.
- *
- *  2. Otherwise, replace the definition with
- *
- *      lazy implicit val a: TC = rhs
+ *    this
+ *    this.y
+ *    y
  */
 class CacheAliasImplicits extends MiniPhase with IdentityDenotTransformer { thisPhase =>
   import tpd._
 
   override def phaseName: String = CacheAliasImplicits.name
 
+  private def needsCache(sym: Symbol, rhs: Tree)(using Context): Boolean = rhs.tpe match
+    case rhsTpe @ TermRef(NoPrefix, _)
+    if rhsTpe.isStable => false
+    case rhsTpe @ TermRef(pre: ThisType, _)
+    if rhsTpe.isStable && pre.cls == sym.owner.enclosingClass => false
+    case rhsTpe: ThisType => false
+    case _ => true
+
+  /** Transform
+   *
+   *    given def x = rhs
+   *
+   *  to
+   *
+   *    lazy val x = rhs
+   *
+   *  unless `rhs` has a stable type and is of one of them forms
+   *
+   *    this
+   *    this.y
+   *    y
+   *
+   *  Parameterless given defs are generated during typeclass derivation.
+   */
   override def transformDefDef(tree: DefDef)(using Context): Tree = {
     val sym = tree.symbol
     val isCached = !sym.is(Inline) && {
       sym.info match {
         case ExprType(resTpe) if sym.is(Given, butNot = CacheAliasImplicits.NoCacheFlags) =>
-          tree.rhs.tpe match {
-            case rhsTpe @ TermRef(NoPrefix, _)
-            if rhsTpe.isStable => false
-            case rhsTpe @ TermRef(pre: ThisType, _)
-            if rhsTpe.isStable && pre.cls == sym.owner.enclosingClass => false
-            case rhsTpe: ThisType => false
-            case _ => true
-          }
+          needsCache(sym, tree.rhs)
         case _ => false
       }
     }
@@ -71,6 +80,30 @@ class CacheAliasImplicits extends MiniPhase with IdentityDenotTransformer { this
     }
     else tree
   }
+
+  /** Transform
+   *
+   *    lazy given val x = rhs
+   *
+   *  to
+   *
+   *    def x = rhs
+   *
+   *  provided `rhs` has a stable type and is of one of them forms
+   *
+   *    this
+   *    this.y
+   *    y
+   */
+  override def transformValDef(tree: ValDef)(using Context): Tree =
+    val sym = tree.symbol
+    if sym.isAllOf(Given, Lazy) && !needsCache(sym, tree.rhs) then
+      sym.copySymDenotation(
+        initFlags = sym.flags &~ Lazy | Method,
+        info = ExprType(sym.info))
+      .installAfter(thisPhase)
+      cpy.DefDef(tree)(tree.name, Nil, Nil, tree.tpt, tree.rhs)
+    else tree
 }
 
 

compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala

@@ -353,7 +353,7 @@ object ExplicitOuter {
    */
   class OuterOps(val ictx: Context) extends AnyVal {
     /** The context of all operations of this class */
-    given Context = ictx
+    given [Dummy] as Context = ictx
 
     /** If `cls` has an outer parameter add one to the method type `tp`. */
     def addParam(cls: ClassSymbol, tp: Type): Type =

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

@@ -742,7 +742,7 @@ trait Checking {
         defn.ObjectType
     }
 
-  /** If `sym` is an implicit conversion, check that implicit conversions are enabled.
+  /** If `sym` is an old-style implicit conversion, check that implicit conversions are enabled.
    *  @pre  sym.is(GivenOrImplicit)
    */
   def checkImplicitConversionDefOK(sym: Symbol)(using Context): Unit = {
@@ -755,10 +755,7 @@ trait Checking {
 
     sym.info.stripPoly match {
       case mt @ MethodType(_ :: Nil)
-      if !mt.isImplicitMethod && !sym.is(Synthetic) => // it's a conversion
-        check()
-      case AppliedType(tycon, _)
-      if tycon.derivesFrom(defn.ConversionClass) && !sym.is(Synthetic) =>
+      if !mt.isImplicitMethod && !sym.is(Synthetic) => // it's an old-styleconversion
         check()
       case _ =>
     }

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

@@ -917,6 +917,19 @@ trait Implicits:
       implicits.println(i"CanEqual 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

compiler/test/dotty/tools/repl/ReplCompilerTests.scala

@@ -155,7 +155,7 @@ class ReplCompilerTests extends ReplTest {
     fromInitialState { implicit state => run("given Int = 10") }
     .andThen         { implicit state =>
       assertEquals(
-        "def given_Int: Int",
+        "lazy val given_Int: Int",
         storedOutput().trim
       )
       run("implicitly[Int]")

tests/neg-macros/i7048e.scala

@@ -9,31 +9,31 @@ abstract class Test {
 
   def foo(using Quotes): Expr[Any] = {
 
-    val r = '{Option.empty[T]} // error: is not stable
+    val r = '{Option.empty[T]} // works
 
     {
       val t: Test = this
       import t.given
       println(Type.show[t.T])
-      // val r = '{Option.empty[t.T]} // access to value t from wrong staging level
+      val r = '{Option.empty[t.T]} // works
       val r2 = '{Option.empty[t.T.Underlying]} // works
     }
 
     {
       val r1 = '{Option.empty[T.Underlying]} // works
       val r2 = '{Option.empty[List[T.Underlying]]} // works
-      val r3 = '{summon[Type[T.Underlying]]} // error: is not stable
-      val r4 = '{summon[T.Underlying <:< Any]} // error: is not stable
+      val r3 = '{summon[Type[T.Underlying]]} // error: access to value t from wrong staging level
+      val r4 = '{summon[T.Underlying <:< Any]} // works
     }
 
     {
       val s = '{Option.empty[T.Underlying]} // works
       val r = '{identity($s)} // works
-      val r2 = '{identity(${s: Expr[Option[T]]})} // error // error : is not stable
+      val r2 = '{identity(${s: Expr[Option[T]]})} //works
     }
 
     r
   }
 }
 
-@main def main = ()
+@main def tester = ()

tests/neg/i8623.check

@@ -0,0 +1,11 @@
+-- [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 total and side-effect free.
+
+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
+

tests/neg/i8623a.scala

@@ -0,0 +1,19 @@
+object Test {
+  trait A {
+    type X = String
+  }
+  trait B {
+    type X = Int
+  }
+
+  def foo: A & B = o
+  given o as (A & B) = foo
+
+  def xToString(x: o.X): String = x  // error
+
+  def intToString(i: Int): String = xToString(i)
+
+  def main(args: Array[String]): Unit = {
+    val z: String = intToString(1)
+  }
+}

tests/pos/i8623.scala

@@ -0,0 +1,17 @@
+
+trait QC:
+  object tasty:
+    type Tree
+    extension (tree: Tree)
+      def pos: Tree = ???
+
+def test1 =
+  given QC = ???
+  def unseal(using qctx: QC): qctx.tasty.Tree = ???
+  unseal.pos
+
+def test2 =
+  given QC
+  def unseal(using qctx: QC): qctx.tasty.Tree = ???
+  unseal.pos
+

tests/pos/i9103.scala

@@ -1,5 +1,5 @@
 object a:
-  type Foo[T]
+  trait Foo[T]
   given Foo[Unit] = ???
 
 val b = a