Fix refs to inner objects

A reference to an object from anywhere in its module class can be
established by the This of the module class. The previous behavior always
referenced the object as a term ref which might cause a reference to
the outer This which might not be available (since this is not tracked
by ExplicitOuter). Brings t3174.scala back from disabled.

1 files changed, 11 insertions, 10 deletions

diff --git a/src/dotty/tools/dotc/ast/tpd.scala b/src/dotty/tools/dotc/ast/tpd.scala
index e38de458a..d0a7942c5 100644
--- a/src/dotty/tools/dotc/ast/tpd.scala
+++ b/src/dotty/tools/dotc/ast/tpd.scala
@@ -326,23 +326,24 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def ref(tp: NamedType)(implicit ctx: Context): Tree =
     if (tp.isType) TypeTree(tp)
     else if (prefixIsElidable(tp)) Ident(tp)
+    else if (tp.symbol.is(Module) && ctx.owner.isContainedIn(tp.symbol.moduleClass))
+      correctForPath(This(tp.symbol.moduleClass.asClass))
     else tp.prefix match {
-      case pre: SingletonType =>
-        val prefix =
-          singleton(pre) match {
-            case t: This if ctx.erasedTypes && !(t.symbol == ctx.owner.enclosingClass || t.symbol.isStaticOwner) =>
-              // after erasure outer paths should be respected
-              new ExplicitOuter.OuterOps(ctx).path(t.tpe.widen.classSymbol)
-            case t =>
-              t
-          }
-        prefix.select(tp)
+      case pre: SingletonType => correctForPath(singleton(pre)).select(tp)
       case pre => SelectFromTypeTree(TypeTree(pre), tp)
     } // no checks necessary
 
   def ref(sym: Symbol)(implicit ctx: Context): Tree =
     ref(NamedType(sym.owner.thisType, sym.name, sym.denot))
 
+  private def correctForPath(t: Tree)(implicit ctx: Context) = t match {
+    case t: This if ctx.erasedTypes && !(t.symbol == ctx.owner.enclosingClass || t.symbol.isStaticOwner) =>
+      // after erasure outer paths should be respected
+      new ExplicitOuter.OuterOps(ctx).path(t.tpe.widen.classSymbol)
+    case t =>
+      t
+  }
+
   def singleton(tp: Type)(implicit ctx: Context): Tree = tp match {
     case tp: TermRef => ref(tp)
     case tp: ThisType => This(tp.cls)