Fix-#1723: Avoid private leaks on completion

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -733,11 +733,7 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table, posUnpickle
         // no longer necessary.
       goto(end)
       setPos(start, tree)
-
-      // This is also done in PostTyper but needs to be redone here
-      if (!sym.is(SyntheticOrPrivate) && sym.owner.isClass) {
-        sym.info = Checking.checkNoPrivateLeaks(sym, tree.pos)
-      }
+      sym.info = ta.avoidPrivateLeaks(sym, tree.pos)
       tree
     }
 

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

@@ -107,12 +107,6 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer  { thisTran
     private def transformMemberDef(tree: MemberDef)(implicit ctx: Context): Unit = {
       val sym = tree.symbol
       sym.transformAnnotations(transformAnnot)
-      // Has to be redone in TreeUnpickler
-      if (!sym.is(SyntheticOrPrivate) && sym.owner.isClass) {
-        val info1 = Checking.checkNoPrivateLeaks(sym, tree.pos)
-        if (info1 ne sym.info)
-          sym.copySymDenotation(info = info1).installAfter(thisTransformer)
-      }
     }
 
     private def transformSelect(tree: Select, targs: List[Tree])(implicit ctx: Context): Tree = {

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

@@ -668,13 +668,15 @@ class Namer { typer: Typer =>
      *  to pick up the context at the point where the completer was created.
      */
     def completeInCreationContext(denot: SymDenotation): Unit = {
+      val sym = denot.symbol
       original match {
-        case original: MemberDef => addAnnotations(denot.symbol, original)
+        case original: MemberDef => addAnnotations(sym, original)
         case _ =>
       }
       addInlineInfo(denot)
-      denot.info = typeSig(denot.symbol)
-      Checking.checkWellFormed(denot.symbol)
+      denot.info = typeSig(sym)
+      Checking.checkWellFormed(sym)
+      denot.info = avoidPrivateLeaks(sym, sym.pos)
     }
   }
 
@@ -854,6 +856,7 @@ class Namer { typer: Typer =>
       if (isDerivedValueClass(cls)) cls.setFlag(Final)
       cls.setApplicableFlags(
         (NoInitsInterface /: impl.body)((fs, stat) => fs & defKind(stat)))
+      cls.info = avoidPrivateLeaks(cls, cls.pos)
     }
   }
 

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

@@ -132,6 +132,11 @@ trait TypeAssigner {
   def avoidingType(expr: Tree, bindings: List[Tree])(implicit ctx: Context): Type =
     avoid(expr.tpe, localSyms(bindings).filter(_.isTerm))
 
+  def avoidPrivateLeaks(sym: Symbol, pos: Position)(implicit ctx: Context): Type =
+    if (!sym.is(SyntheticOrPrivate) && sym.owner.isClass)
+      Checking.checkNoPrivateLeaks(sym, pos)
+    else sym.info
+
   def seqToRepeated(tree: Tree)(implicit ctx: Context): Tree =
     Typed(tree, TypeTree(tree.tpe.widen.translateParameterized(defn.SeqClass, defn.RepeatedParamClass)))
 

tests/pos/i1723.scala

@@ -0,0 +1,8 @@
+class A {
+  private val x: List[Int] = List(1)
+  def foo = x.head // foo inferred type is this.x.scala$collection$immutable$List$$A
+}
+
+class B extends A {
+  foo
+}