Fix: handle accesses to private aliases from inlined code

Dealias them and try again.

Author: odersky

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

@@ -26,6 +26,7 @@ import ErrorReporting.errorTree
 import collection.mutable
 import transform.TypeUtils._
 import reporting.trace
+import util.Positions.Position
 
 object Inliner {
   import tpd._
@@ -91,26 +92,26 @@ object Inliner {
       def addAccessor(tree: Tree, refPart: Tree, targs: List[Tree], argss: List[List[Tree]],
                       accessedType: Type, rhs: (Tree, List[Type], List[List[Tree]]) => Tree)(implicit ctx: Context): Tree = {
         val qual = qualifier(refPart)
-        
+
         def refIsLocal = qual match {
           case qual: This => qual.symbol == refPart.symbol.owner
           case _ => false
         }
-        
+
         def addAcc(accessorDef: MemberDef) = {
           accessors += accessorDef
           inlining.println(i"added inline accessor: $accessorDef")
         }
-        
+
         if (refPart.symbol.isStatic || refIsLocal) {
           // Easy case: Reference to a static symbol or a symbol referenced via `this.`
           val accessorType = accessedType.ensureMethodic
           val accessor = accessorSymbol(tree, accessorType).asTerm
-          
+
           addAcc(
             polyDefDef(accessor, tps => argss =>
               rhs(refPart, tps, argss).withPos(tree.pos.focus)))
-              
+
           ref(accessor).appliedToTypeTrees(targs).appliedToArgss(argss).withPos(tree.pos)
         }
         else {
@@ -150,7 +151,7 @@ object Inliner {
             polyDefDef(accessor, tps => argss =>
               rhs(argss.head.head.select(refPart.symbol), tps.drop(localRefs.length), argss.tail)
                 .withPos(tree.pos.focus)))
-                
+
           ref(accessor)
             .appliedToTypeTrees(localRefs.map(TypeTree(_)) ++ targs)
             .appliedToArgss((qual :: Nil) :: argss)
@@ -547,6 +548,18 @@ class Inliner(call: tpd.Tree, rhs: tpd.Tree)(implicit ctx: Context) {
 
     var retainedInlineables = Set[Symbol]()
 
+    override def ensureAccessible(tpe: Type, superAccess: Boolean, pos: Position)(implicit ctx: Context): Type = {
+      tpe match {
+        case tpe @ TypeRef(pre, _) if !tpe.symbol.isAccessibleFrom(pre, superAccess) =>
+          tpe.info match {
+            case TypeAlias(alias) => return ensureAccessible(alias, superAccess, pos)
+            case _ =>
+          }
+        case _ =>
+      }
+      super.ensureAccessible(tpe, superAccess, pos)
+    }
+
     override def typedIdent(tree: untpd.Ident, pt: Type)(implicit ctx: Context) =
       tree.asInstanceOf[tpd.Tree] match {
         case InlineableArg(rhs) => inlining.println(i"inline arg $tree -> $rhs"); rhs

tests/pos/inlineAccesses.scala

@@ -0,0 +1,22 @@
+trait T {
+  object O
+}
+
+class C {
+  private type T = C
+  private var x = 0
+
+  inline def f = {
+    x += 1
+    x = x + 1
+    x
+  }
+  inline def dup = new T
+}
+
+object Test {
+
+  val c = new C
+  c.f
+  c.dup
+}