Use the unwidened type when casting structural calls

So if the call is to a stable val, the call will have a stable type.

Author: dwijnand

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

@@ -235,14 +235,14 @@ trait Dynamic {
           if ValueClasses.isDerivedValueClass(tpe.classSymbol) && qual.tpe <:< defn.ReflectSelectableTypeRef then
             val genericUnderlying = ValueClasses.valueClassUnbox(tpe.classSymbol.asClass)
             val underlying = tpe.select(genericUnderlying).widen.resultType
-            New(tpe, tree.cast(underlying) :: Nil)
+            New(tpe.widen, tree.cast(underlying) :: Nil)
           else
             tree
         maybeBoxed.cast(tpe)
 
     fun.tpe.widen match {
       case tpe: ValueType =>
-        structuralCall(nme.selectDynamic, Nil).maybeBoxingCast(tpe)
+        structuralCall(nme.selectDynamic, Nil).maybeBoxingCast(fun.tpe)
 
       case tpe: MethodType =>
         def isDependentMethod(tpe: Type): Boolean = tpe match {

tests/pos/i18263.orig.scala

@@ -0,0 +1,16 @@
+sealed trait Scope
+sealed trait Domain extends Scope
+object Domain extends Domain
+
+trait Baz[T]
+def baz(using ck: Scope): Baz[ck.type] = ???
+
+class Foo extends scala.reflect.Selectable:
+  type TScope = Domain
+  final protected given TScope = Domain
+
+object ID:
+  val internal1 = new Foo:
+    val ii = new Foo:
+      val x = baz
+  val z = internal1.ii.x //error

tests/pos/i18263.scala

@@ -0,0 +1,15 @@
+final class Bar
+final class Inv[T]
+class Foo extends scala.reflect.Selectable:
+  type Boo = Bar
+  final given boo1: Boo = new Bar
+
+class Test:
+  def mkInv(using bar: Bar): Inv[bar.type] = new Inv()
+
+  def test: Unit =
+    val foo1     /* : Foo { val foo2: { z1 => Foo { val inv1: Inv[(z1.boo1 : z1.Boo)] }}} */ = new Foo:
+      val foo2   /* :                 { z1 => Foo { val inv1: Inv[(z1.boo1 : z1.Boo)] }}  */ = new Foo:
+        val inv1 /* :                                         Inv[(   boo1 :    Boo)]     */ = mkInv /* (this.boo1) */
+    val inv2 = foo1.foo2.inv1 // error
+    ()