Make parameterless givens lazy vals

We used to represent them as defs and converted some of them to lazy
vals later, in CacheAliasImplicits.

But that means a parameterless given value is never a stable prefix, so
we cannot use it as a qualifier for an abstract type.

We now change the scheme so that parameterless givens start out as lazy vals
and some of them are changed to defs later in CacheAliasImplicits.

This is not a uniform improvement, since lazy vals have the restriction
that their types must be realizable. See i9103.scala, where we had to
change a type field to a trait to keep it working.

But I think overall this is an improvement to what we had before.

Author: odersky

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

@@ -3536,13 +3536,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/transform/CacheAliasImplicits.scala

@@ -46,19 +46,36 @@ class CacheAliasImplicits extends MiniPhase with IdentityDenotTransformer { this
 
   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 +88,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

@@ -737,7 +737,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 = {
@@ -750,10 +750,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 _ =>
     }

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