Use correct context for val RHS

Author: milessabin

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

@@ -55,7 +55,7 @@ trait Deriving { this: Typer =>
         // derived instance at the summoning site.
 
         val (lazyOrMethod, rhsType) = info match {
-          case ExprType(rhsType) => (Lazy, rhsType)
+          case ExprType(rhsType) => (Final | Lazy | StableRealizable, rhsType)
           case _ => (Method, info)
         }
 
@@ -177,7 +177,7 @@ trait Deriving { this: Typer =>
           typed(rhs, resultType)
         }
 
-      def typeclassValInstance(sym: Symbol): Tree = {
+      def typeclassValInstance(sym: Symbol)(implicit ctx: Context): Tree = {
         val rhsType = sym.info
         val module = untpd.ref(companionRef(rhsType)).withSpan(sym.span)
         val rhs = untpd.Select(module, nme.derived)
@@ -193,11 +193,12 @@ trait Deriving { this: Typer =>
       }
 
       def syntheticDef(sym: Symbol): Tree = {
+        val localCtx = ctx.fresh.setOwner(sym).setNewScope
         sym.info match {
           case _: MethodicType =>
-            tpd.polyDefDef(sym.asTerm, typeclassDefInstance(sym)(ctx.fresh.setOwner(sym).setNewScope))
+            tpd.polyDefDef(sym.asTerm, typeclassDefInstance(sym)(localCtx))
           case _ =>
-            typeclassValInstance(sym)
+            typeclassValInstance(sym)(localCtx)
         }
       }
 

tests/run/lazy-derives.scala

@@ -1,8 +1,8 @@
 import scala.deriving._
 
 object Test extends App {
-  case class Mono(i: Int) derives Foo, Bar
-  case class Poly[T](t: T) derives Foo, Bar, Baz
+  case class Mono(i: Int) derives Foo, Bar, Inline
+  case class Poly[T](t: T) derives Foo, Bar, Baz, Inline
 
   trait Quux[T]
   object Quux {
@@ -26,13 +26,21 @@ object Test extends App {
     def derived[F[_]] given (m: Mirror { type MirroredType = F }): Baz[F] = new Baz[F] {}
   }
 
+  trait Inline[T]
+  object Inline {
+    given as Inline[Int] {}
+    inline def derived[T] given (m: Mirror.Of[T]): Inline[T] = new Inline[T] {}
+  }
+
   // Unfortunately these tests doesn't distinguish a lazy val
   // from a cached def
   assert(the[Foo[Mono]] eq the[Foo[Mono]])
   assert(the[Bar[Mono]] eq the[Bar[Mono]])
   assert(the[Baz[Poly]] eq the[Baz[Poly]])
+  assert(the[Inline[Mono]] eq the[Inline[Mono]])
 
   // These have term arguments so should be distinct
   assert(the[Foo[Poly[Int]]] ne the[Foo[Poly[Int]]])
   assert(the[Bar[Poly[Int]]] ne the[Bar[Poly[Int]]])
+  assert(the[Inline[Poly[Int]]] ne the[Inline[Poly[Int]]])
 }