Drop unnecessary code in transformSym

The only time a nested object class could have a self type with a non-empty
capture set is when it declared in the current compilation unit. Then that
capture set is a Var that gets installed via an updateInfo. But then we do
also an updateInfo of the module val, so no need to do the same thing in
transformSym.

Author: odersky

compiler/src/dotty/tools/dotc/cc/Setup.scala

@@ -125,12 +125,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
         symd.copySymDenotation(info = fluidify(sym.info))
       else if symd.owner.isTerm || symd.is(CaptureChecked) || symd.owner.is(CaptureChecked) then
         val newFlags = newFlagsFor(symd)
-        var newInfo = mappedInfo
-        if sym.is(ModuleVal) && !sym.isStatic then
-          val selfType1 = transformSelfType(sym.moduleClass)
-          if selfType1.exists then
-            newInfo = newInfo.capturing(selfType1.captureSet)
-            sym.termRef.invalidateCaches()
+        val newInfo = mappedInfo
         if sym.isClass then
           sym.thisType.asInstanceOf[ThisType].invalidateCaches()
         if newFlags != symd.flags || (newInfo ne sym.info)
@@ -140,12 +135,6 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
     else symd
   end transformSym
 
-  def transformSelfType(sym: Symbol)(using Context) = (sym.info: @unchecked) match
-    case ClassInfo(_, cls, _, _, selfInfo: Type) =>
-      inContext(ctx.withOwner(cls)):
-        transformExplicitType(selfInfo, rootTarget = ctx.owner)
-    case _ => NoType
-
   /** If `tp` is an unboxed capturing type or a function returning an unboxed capturing type,
    *  convert it to be boxed.
    */

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

@@ -2411,7 +2411,6 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
   /** The least upper bound of two types
    *  @param canConstrain  If true, new constraints might be added to simplify the lub.
    *  @param isSoft        If the lub is a union, this determines whether it's a soft union.
-   *  @note  We do not admit singleton types in or-types as lubs.
    */
   def lub(tp1: Type, tp2: Type, canConstrain: Boolean = false, isSoft: Boolean = true): Type = /*>|>*/ trace(s"lub(${tp1.show}, ${tp2.show}, canConstrain=$canConstrain, isSoft=$isSoft)", subtyping, show = true) /*<|<*/ {
     if (tp1 eq tp2) tp1