use methods to find companion class

src/dotty/tools/dotc/ast/Desugar.scala

@@ -361,9 +361,11 @@ object desugar {
         }
         companionDefs(parent, applyMeths ::: unapplyMeth :: defaultGetters)
       }
-      else if (defaultGetters.nonEmpty)
-        companionDefs(anyRef, defaultGetters)
-      else Nil
+      else {
+        if (defaultGetters.nonEmpty)
+          companionDefs(anyRef, defaultGetters)
+        else Nil
+      }
 
     // For an implicit class C[Ts](p11: T11, ..., p1N: T1N) ... (pM1: TM1, .., pMN: TMN), the method
     //     synthetic implicit C[Ts](p11: T11, ..., p1N: T1N) ... (pM1: TM1, ..., pMN: TMN): C[Ts] =
@@ -409,6 +411,8 @@ object desugar {
     flatTree(cdef1 :: companions ::: implicitWrappers)
   }
 
+  val AccessOrSynthetic = AccessFlags | Synthetic
+
   /** Expand
    *
    *    object name extends parents { self => body }
@@ -436,7 +440,7 @@ object desugar {
         .withPos(tmpl.self.pos orElse tmpl.pos.startPos)
       val clsTmpl = cpy.Template(tmpl)(self = clsSelf, body = tmpl.body)
       val cls = TypeDef(clsName, clsTmpl)
-        .withMods(mods.toTypeFlags & AccessFlags | ModuleClassCreationFlags)
+        .withMods(mods.toTypeFlags & AccessOrSynthetic | ModuleClassCreationFlags)
       Thicket(modul, classDef(cls))
     }
   }

src/dotty/tools/dotc/core/Denotations.scala

@@ -611,7 +611,10 @@ object Denotations {
         val current = symbol.current
         // println(s"installing $this after $phase/${phase.id}, valid = ${current.validFor}")
         // printPeriods(current)
-        this.nextInRun = current.nextInRun
+        if (current.nextInRun ne current)
+          this.nextInRun = current.nextInRun
+        else
+          this.nextInRun = this
         this.validFor = Period(ctx.runId, targetId, current.validFor.lastPhaseId)
         if (current.validFor.firstPhaseId == targetId) {
           // replace current with this denotation
@@ -622,6 +625,7 @@ object Denotations {
         } else {
           // insert this denotation after current
           current.validFor = Period(ctx.runId, current.validFor.firstPhaseId, targetId - 1)
+          this.nextInRun = current.nextInRun
           current.nextInRun = this
         }
       // printPeriods(this)

src/dotty/tools/dotc/core/StdNames.scala

@@ -83,8 +83,8 @@ object StdNames {
     final val HASHkw: N      = kw("#")
     final val ATkw: N        = kw("@")
 
-    val ANON_CLASS: N            = "$anon"
-    val ANON_FUN: N              = "$anonfun"
+    val ANON_CLASS: N                 = "$anon"
+    val ANON_FUN: N                   = "$anonfun"
     val BITMAP_PREFIX: N              = "bitmap$"
     val BITMAP_NORMAL: N              = BITMAP_PREFIX         // initialization bitmap for public/protected lazy vals
     val BITMAP_TRANSIENT: N           = BITMAP_PREFIX + "trans$"    // initialization bitmap for transient lazy vals
@@ -117,13 +117,15 @@ object StdNames {
     val PROTECTED_PREFIX: N           = "protected$"
     val PROTECTED_SET_PREFIX: N       = PROTECTED_PREFIX + "set"
     val ROOT: N                       = "<root>"
-    val SHADOWED: N                  = "(shadowed)"  // tag to be used until we have proper name kinds
+    val SHADOWED: N                   = "(shadowed)"  // tag to be used until we have proper name kinds
     val SINGLETON_SUFFIX: N           = ".type"
     val SPECIALIZED_SUFFIX: N         = "$sp"
     val SUPER_PREFIX: N               = "super$"
     val WHILE_PREFIX: N               = "while$"
     val DEFAULT_EXCEPTION_NAME: N     = "ex$"
     val INITIALIZER_PREFIX: N         = "initial$"
+    val COMPANION_MODULE_METHOD: N    = "companion$module"
+    val COMPANION_CLASS_METHOD: N     = "compaion$class"
 
     // value types (and AnyRef) are all used as terms as well
     // as (at least) arguments to the @specialize annotation.

src/dotty/tools/dotc/core/SymDenotations.scala

@@ -773,11 +773,31 @@ object SymDenotations {
         companionNamed(effectiveName.moduleClassName).sourceModule
 
     /** The class with the same (type-) name as this module or module class,
-     *  and which is also defined in the same scope and compilation unit.
-     *  NoSymbol if this class does not exist.
-     */
-    final def companionClass(implicit ctx: Context): Symbol =
-      companionNamed(effectiveName.toTypeName)
+      *  and which is also defined in the same scope and compilation unit.
+      *  NoSymbol if this class does not exist.
+      */
+    final def companionClass(implicit ctx: Context): Symbol = {
+      val companionMethod = info.decls.denotsNamed(nme.COMPANION_CLASS_METHOD, selectPrivate).first
+
+      if (companionMethod.exists)
+        companionMethod.info.resultType.classSymbol
+      else {
+        /*
+        val scalac = companionNamed(effectiveName.toTypeName)
+
+        if (scalac.exists) {
+          println(s"scalac returned companion class for $this to be $scalac")
+        }
+        */
+        NoSymbol
+      }
+    }
+
+    final def scalacLinkedClass(implicit ctx: Context): Symbol =
+      if (this is ModuleClass) companionNamed(effectiveName.toTypeName)
+      else if (this.isClass) companionModule.moduleClass
+      else NoSymbol
+
 
     /** Find companion class symbol with given name, or NoSymbol if none exists.
      *  Three alternative strategies:

src/dotty/tools/dotc/core/SymbolLoaders.scala

@@ -229,7 +229,7 @@ class ClassfileLoader(val classfile: AbstractFile) extends SymbolLoader {
   def description = "class file "+ classfile.toString
 
   def rootDenots(rootDenot: ClassDenotation)(implicit ctx: Context): (ClassDenotation, ClassDenotation) = {
-    val linkedDenot = rootDenot.linkedClass.denot match {
+    val linkedDenot = rootDenot.scalacLinkedClass.denot match {
       case d: ClassDenotation => d
       case d =>
         // this can happen if the companion if shadowed by a val or type

src/dotty/tools/dotc/core/Symbols.scala

@@ -161,6 +161,15 @@ trait Symbols { this: Context =>
           owner.thisType, modcls, parents, decls, TermRef.withSymAndName(owner.thisType, module, name)),
         privateWithin, coord, assocFile)
 
+  def synthesizeCompanionMethod(name: TermName, ret: SymDenotation, owner: SymDenotation)(implicit ctx: Context) = {
+    if(owner.exists && ret.exists) ctx.newSymbol(
+      owner = owner.symbol,
+      name = name,
+      flags = Flags.Synthetic | Flags.Private,
+      info = ExprType(ret.typeRef))
+    else NoSymbol
+  }
+
   /** Create a package symbol with associated package class
    *  from its non-info fields and a lazy type for loading the package's members.
    */

src/dotty/tools/dotc/core/pickling/ClassfileParser.scala

@@ -130,10 +130,15 @@ class ClassfileParser(
     for (i <- 0 until in.nextChar) parseMember(method = true)
     classInfo = parseAttributes(classRoot.symbol, classInfo)
     if (isAnnotation) addAnnotationConstructor(classInfo)
+    val companionClassMethod = ctx.synthesizeCompanionMethod(nme.COMPANION_CLASS_METHOD, classRoot, moduleRoot)
+    if (companionClassMethod.exists) companionClassMethod.entered
+
+
     setClassInfo(classRoot, classInfo)
     setClassInfo(moduleRoot, staticInfo)
   }
 
+
   /** Add type parameters of enclosing classes */
   def addEnclosingTParams()(implicit ctx: Context): Unit = {
     var sym = classRoot.owner

src/dotty/tools/dotc/core/pickling/UnPickler.scala

@@ -118,6 +118,13 @@ object UnPickler {
         denot.owner.thisType select denot.sourceModule
       else selfInfo
     if (!(denot.flagsUNSAFE is JavaModule)) ensureConstructor(denot.symbol.asClass, decls)
+    if (denot.flagsUNSAFE is Module) {
+      val scalacCompanion = denot.classSymbol.scalacLinkedClass
+      val companionClassMethod = ctx.synthesizeCompanionMethod(nme.COMPANION_CLASS_METHOD, scalacCompanion, denot.classSymbol)
+      if (companionClassMethod.exists)
+        companionClassMethod.entered
+    }
+
     denot.info = ClassInfo(denot.owner.thisType, denot.classSymbol, parentRefs, decls, ost)
   }
 }

src/dotty/tools/dotc/transform/FirstTransform.scala

@@ -19,6 +19,7 @@ import DenotTransformers._
 import typer.Checking
 import Names.Name
 import NameOps._
+import StdNames._
 
 
 /** The first tree transform
@@ -72,10 +73,13 @@ class FirstTransform extends MiniPhaseTransform with IdentityDenotTransformer wi
       case Nil => Nil
     }
 
-    def newCompanion(name: TermName): Thicket = {
+    def newCompanion(name: TermName, forClass: Symbol): Thicket = {
       val modul = ctx.newCompleteModuleSymbol(ctx.owner, name, Synthetic, Synthetic,
         defn.ObjectClass.typeRef :: Nil, Scopes.newScope)
+      val mc = modul.moduleClass
       if (ctx.owner.isClass) modul.enteredAfter(thisTransformer)
+      ctx.synthesizeCompanionMethod(nme.COMPANION_CLASS_METHOD, forClass, mc).enteredAfter(thisTransformer)
+      ctx.synthesizeCompanionMethod(nme.COMPANION_MODULE_METHOD, mc, forClass).enteredAfter(thisTransformer)
       ModuleDef(modul, Nil)
     }
 
@@ -89,7 +93,7 @@ class FirstTransform extends MiniPhaseTransform with IdentityDenotTransformer wi
             false
         }
         val uniqueName = if (nameClash) objName.avoidClashName else objName
-        Thicket(stat :: newCompanion(uniqueName).trees)
+        Thicket(stat :: newCompanion(uniqueName, stat.symbol).trees)
       case stat => stat
     }
 

src/dotty/tools/dotc/typer/Checking.scala

@@ -232,7 +232,8 @@ trait Checking {
 
   /** Check that type `tp` is stable. */
   def checkStable(tp: Type, pos: Position)(implicit ctx: Context): Unit =
-    if (!tp.isStable) ctx.error(d"$tp is not stable", pos)
+    if (!tp.isStable)
+      ctx.error(d"$tp is not stable", pos)
 
   /** Check that type `tp` is a legal prefix for '#'.
    *  @return The type itself

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

@@ -395,32 +395,64 @@ class Namer { typer: Typer =>
   /** Create top-level symbols for statements and enter them into symbol table */
   def index(stats: List[Tree])(implicit ctx: Context): Context = {
 
+    val classDef  = mutable.Map[TypeName, TypeDef]()
+    val moduleDef = mutable.Map[TypeName, TypeDef]()
+
     /** Merge the definitions of a synthetic companion generated by a case class
      *  and the real companion, if both exist.
      */
     def mergeCompanionDefs() = {
-      val classDef = mutable.Map[TypeName, TypeDef]()
       for (cdef @ TypeDef(name, _) <- stats)
-        if (cdef.isClassDef) classDef(name) = cdef
-      for (mdef @ ModuleDef(name, _) <- stats)
+        if (cdef.isClassDef) {
+          classDef(name) = cdef
+          cdef.attachmentOrElse(ExpandedTree, cdef) match {
+            case Thicket(cls :: mval :: (mcls @ TypeDef(_, _: Template)) :: crest) =>
+              moduleDef(name) = mcls
+            case _ =>
+          }
+        }
+      for (mdef @ ModuleDef(name, _) <- stats if !mdef.mods.is(Flags.Package)) {
+        val typName = name.toTypeName
+        val Thicket(vdef :: (mcls @ TypeDef(_, impl: Template)) :: Nil) = mdef.attachment(ExpandedTree)
+        moduleDef(typName) = mcls
         classDef get name.toTypeName match {
           case Some(cdef) =>
-            val Thicket(vdef :: (mcls @ TypeDef(_, impl: Template)) :: Nil) = mdef.attachment(ExpandedTree)
             cdef.attachmentOrElse(ExpandedTree, cdef) match {
               case Thicket(cls :: mval :: TypeDef(_, compimpl: Template) :: crest) =>
                 val mcls1 = cpy.TypeDef(mcls)(
                     rhs = cpy.Template(impl)(body = compimpl.body ++ impl.body))
                 mdef.putAttachment(ExpandedTree, Thicket(vdef :: mcls1 :: Nil))
+                moduleDef(typName) = mcls1
                 cdef.putAttachment(ExpandedTree, Thicket(cls :: crest))
               case _ =>
             }
           case none =>
         }
+      }
+    }
+
+    def createLinks(classTree: TypeDef, moduleTree: TypeDef)(implicit ctx: Context) = {
+      val claz = ctx.denotNamed(classTree.name.encode).symbol
+      val modl = ctx.denotNamed(moduleTree.name.encode).symbol
+      ctx.synthesizeCompanionMethod(nme.COMPANION_CLASS_METHOD, claz, modl).entered
+      ctx.synthesizeCompanionMethod(nme.COMPANION_MODULE_METHOD, modl, claz).entered
+    }
+
+    def createCompanionLinks(implicit ctx: Context): Unit = {
+      for (cdef @ TypeDef(name, _) <- classDef.values) {
+        moduleDef.getOrElse(name, EmptyTree) match {
+          case t: TypeDef =>
+            createLinks(cdef, t)
+          case EmptyTree =>
+        }
+      }
     }
 
     stats foreach expand
     mergeCompanionDefs()
-    (ctx /: stats) ((ctx, stat) => indexExpanded(stat)(ctx))
+    val ctxWithStats = (ctx /: stats) ((ctx, stat) => indexExpanded(stat)(ctx))
+    createCompanionLinks(ctxWithStats)
+    ctxWithStats
   }
 
   /** The completer of a symbol defined by a member def or import (except ClassSymbols) */

src/dotty/tools/dotc/typer/RefChecks.scala

@@ -395,7 +395,8 @@ object RefChecks {
 
         for (member <- missing) {
           val memberSym = member.symbol
-          def undefined(msg: String) = abstractClassError(false, member.showDcl + " is not defined" + msg)
+          def undefined(msg: String) =
+            abstractClassError(false, member.showDcl + " is not defined" + msg)
           val underlying = memberSym.underlyingSymbol
 
           // Give a specific error message for abstract vars based on why it fails:

src/dotty/tools/dotc/typer/Typer.scala

@@ -963,7 +963,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     val packageContext =
       if (pkg is Package) ctx.fresh.setOwner(pkg.moduleClass).setTree(tree)
       else {
-        ctx.error(d"$pkg is not a packge", tree.pos)
+        ctx.error(d"$pkg is not a package", tree.pos)
         ctx
       }
     val stats1 = typedStats(tree.stats, pkg.moduleClass)(packageContext)

test/dotc/tests.scala

@@ -149,7 +149,7 @@ class tests extends CompilerTest {
 
   @Test def dotc_printing = compileDir(dotcDir + "tools/dotc/printing")
 
-  @Test def dotc_reporting = compileDir(dotcDir + "tools/dotc/reporting", twice)
+  @Test def dotc_reporting = compileDir(dotcDir + "tools/dotc/reporting")
 
   @Test def dotc_typer = compileDir(dotcDir + "tools/dotc/typer", failedOther)
     // error: error while loading Checking$$anon$2$,