Refine infoDependsOnPrefix

infoDependsOnPrefix now also considers non-final term members. Before
8d65f19 it only considered abstract types. Constructors were classified
as non-final, which caused regression. We now exclude constructors
specifically. Maybe we should instead classify them as effectively final.

Fixes #18160

Author: odersky

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -2537,6 +2537,7 @@ object Types {
           (symd.isAbstractType
             || symd.isTerm
                 && !symd.flagsUNSAFE.isOneOf(Module | Final | Param)
+                && !symd.isConstructor
                 && !symd.maybeOwner.isEffectivelyFinal)
           && prefix.sameThis(symd.maybeOwner.thisType)
           && refines(givenSelfTypeOrCompleter(prefix.cls), symd.name)

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

@@ -544,7 +544,7 @@ object TreeChecker {
       val TypeDef(_, impl @ Template(constr, _, _, _)) = cdef: @unchecked
       assert(cdef.symbol == cls)
       assert(impl.symbol.owner == cls)
-      assert(constr.symbol.owner == cls)
+      assert(constr.symbol.owner == cls, i"constr ${constr.symbol} in $cdef has wrong owner; should be $cls but is ${constr.symbol.owner}")
       assert(cls.primaryConstructor == constr.symbol, i"mismatch, primary constructor ${cls.primaryConstructor}, in tree = ${constr.symbol}")
       checkOwner(impl)
       checkOwner(impl.constr)

tests/pos/i18160/Test_2.scala

@@ -0,0 +1,11 @@
+class SynchronizedReevaluation
+class SynchronizedReevaluationApi[Api <: RescalaInterface](val api: Api){
+  import api._
+
+  def SynchronizedReevaluation[A](evt: Event[A])(implicit
+      turnSource: CreationTicket
+  ): (SynchronizedReevaluation, Event[A]) = {
+    val sync = new SynchronizedReevaluation
+    (sync, evt.map(identity)(turnSource))
+  }
+}

tests/pos/i18160/repro_1.scala

@@ -0,0 +1,25 @@
+object core {
+  final class CreationTicket[State[_]]
+}
+
+trait ReadAs[S[_], +A] { type State[V] = S[V] }
+
+trait EventCompatBundle {
+  bundle: Operators =>
+
+  trait EventCompat[+T] extends ReadAs[State, Option[T]] {
+    selfType: Event[T] =>
+    final inline def map[B](inline expression: T => B)(implicit ticket: CreationTicket): Event[B] =  ???
+  }
+}
+
+trait EventBundle extends EventCompatBundle { self: Operators =>
+  trait Event[+T] extends EventCompat[T]:
+    final override type State[V] = self.State[V]
+}
+trait Operators extends EventBundle {
+  type State[_]
+  type CreationTicket = core.CreationTicket[State]
+}
+trait RescalaInterface extends Operators
+