Merge pull request #197 from scala/backport-lts-3.3-22356

Backport "Only check logicalOwners for methods, and not for classes, when looking for proxies" to 3.3 LTS

Author: tgodzik

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

@@ -127,6 +127,16 @@ class TypeUtils:
       case mt: MethodType => mt.isImplicitMethod || mt.resType.takesImplicitParams
       case _ => false
 
+   /** Is this a type deriving only from transparent classes?
+     *  @param traitOnly  if true, all class symbols must be transparent traits
+     */
+    def isTransparent(traitOnly: Boolean = false)(using Context): Boolean = self match
+      case AndType(tp1, tp2) =>
+        tp1.isTransparent(traitOnly) && tp2.isTransparent(traitOnly)
+      case _ =>
+        val cls = self.underlyingClassRef(refinementOK = false).typeSymbol
+        cls.isTransparentClass && (!traitOnly || cls.is(Trait))
+
     /** The constructors of this type that are applicable to `argTypes`, without needing
      *  an implicit conversion. Curried constructors are always excluded.
      *  @param adaptVarargs   if true, allow a constructor with just a varargs argument to

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

@@ -29,7 +29,7 @@ abstract class Dependencies(root: ast.tpd.Tree, @constructorOnly rootContext: Co
   def tracked: Iterable[Symbol] = free.keys
 
   /** The outermost class that captures all free variables of a function
-   *  that are captured by enclosinh classes (this means that the function could
+   *  that are captured by enclosing classes (this means that the function could
    *  be placed in that class without having to add more environment parameters)
    */
   def logicalOwner: collection.Map[Symbol, Symbol] = logicOwner

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

@@ -127,7 +127,9 @@ object LambdaLift:
 
     private def proxy(sym: Symbol)(using Context): Symbol = {
       def liftedEnclosure(sym: Symbol) =
-        deps.logicalOwner.getOrElse(sym, sym.enclosure)
+        if sym.is(Method)
+        then deps.logicalOwner.getOrElse(sym, sym.enclosure)
+        else sym.enclosure
       def searchIn(enclosure: Symbol): Symbol = {
         if (!enclosure.exists) {
           def enclosures(encl: Symbol): List[Symbol] =

compiler/test/dotc/neg-best-effort-pickling.excludelist

@@ -141,3 +141,6 @@ hylolib
 
 # typecheckErrors method unpickling
 i21415.scala
+
+# LTS specific
+i21390.TrieMap.scala

compiler/test/dotc/neg-best-effort-unpickling.excludelist

@@ -107,7 +107,7 @@ object HoverProvider:
         case (symbol, tpe, _) :: _
             if symbol.name == nme.selectDynamic || symbol.name == nme.applyDynamic =>
           fallbackToDynamics(path, printer, contentType)
-        case symbolTpes @ ((symbol, tpe, None) :: _) =>
+        case symbolTpes @ ((symbol, tpe, _) :: _) =>
           val exprTpw = tpe.widenTermRefExpr.deepDealias
           val hoverString =
             tpw match
@@ -153,21 +153,6 @@ object HoverProvider:
             case _ =>
               ju.Optional.empty().nn
           end match
-        case (_, tpe, Some(namedTupleArg)) :: _ =>
-          val exprTpw = tpe.widenTermRefExpr.deepDealias
-          printer.expressionType(exprTpw) match
-            case Some(tpe) =>
-              ju.Optional.of(
-                new ScalaHover(
-                  expressionType = Some(tpe),
-                  symbolSignature = Some(s"$namedTupleArg: $tpe"),
-                  docstring = None,
-                  forceExpressionType = false,
-                  contextInfo = printer.getUsedRenamesInfo,
-                  contentType = contentType
-                )
-              ).nn
-            case _ => ju.Optional.empty().nn
       end match
     end if
   end hover
@@ -183,7 +168,7 @@ object HoverProvider:
     case SelectDynamicExtractor(sel, n, name, rest) =>
       def findRefinement(tp: Type): Option[HoverSignature] =
         tp match
-          case RefinedType(_, refName, tpe) if (name == refName.toString() || refName.toString() == nme.Fields.toString()) =>
+          case RefinedType(_, refName, tpe) if name == refName.toString() =>
             val resultType =
               rest match
                 case Select(_, asInstanceOf) :: TypeApply(_, List(tpe)) :: _ if asInstanceOf == nme.asInstanceOfPM =>
@@ -196,8 +181,7 @@ object HoverProvider:
               else printer.tpe(resultType)
 
             val valOrDef =
-              if refName.toString() == nme.Fields.toString() then ""
-              else if n == nme.selectDynamic && !tpe.isInstanceOf[ExprType]
+              if n == nme.selectDynamic && !tpe.isInstanceOf[ExprType]
               then "val "
               else "def "
 

compiler/test/dotc/pos-test-pickling.blacklist

@@ -203,20 +203,6 @@ object MetalsInteractive:
           case _ =>
             Nil
 
-      // Handle select on named tuples
-      case (Apply(Apply(TypeApply(fun, List(t1, t2)), List(ddef)), List(Literal(Constant(i: Int))))) :: _
-        if fun.symbol.exists && fun.symbol.name == nme.apply &&
-            fun.symbol.owner.exists && fun.symbol.owner == getModuleIfDefined("scala.NamedTuple").moduleClass =>
-        def getIndex(t: Tree): Option[Type] =
-          t.tpe.dealias match
-            case AppliedType(_, args) => args.get(i)
-            case _ => None
-        val name = getIndex(t1) match
-          case Some(c: ConstantType) => c.value.stringValue
-          case _ => ""
-        val tpe = getIndex(t2).getOrElse(NoType)
-        List((ddef.symbol, tpe, Some(name)))
-
       case path @ head :: tail =>
         if head.symbol.is(Exported) then
           val sym = head.symbol.sourceSymbol