From 37037fe70651eee7a1e8a77a2f8b6e74968836b6 Mon Sep 17 00:00:00 2001
From: Jason Zaugg <jzaugg@gmail.com>
Date: Thu, 17 Nov 2016 12:49:59 +1000
Subject: SI-3772 Fix detection of term-owned companions

Companion detection consults the scopes of enclosing Contexts during
typechecking to avoid the cycles that would ensue if we had to look
at into the info of enclosing class symbols. For example, this used
to typecheck:

    object CC { val outer = 42 }
    if ("".isEmpty) {
      case class CC(c: Int)
      CC.outer
    }

This logic was not suitably hardened to find companions in exactly
the same nesting level.

After fixing this problem, a similar problem in `Namer::inCurrentScope`
could be solved to be more selective about synthesizing a companion
object. In particular, if a manually defined companion trails after
the case class, don't create an addiotional synthetic comanpanion object.
---
 .../scala/tools/nsc/typechecker/Contexts.scala      | 21 +++++++++++++++++++++
 .../scala/tools/nsc/typechecker/Namers.scala        | 10 +++++-----
 2 files changed, 26 insertions(+), 5 deletions(-)

(limited to 'src/compiler')

diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
index c73ea54c3d..cbe9e522a2 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
@@ -1192,6 +1192,27 @@ trait Contexts { self: Analyzer =>
       }
       res
     }
+
+    final def lookupCompanionOf(original: Symbol): Symbol = {
+      lookupScopeEntry(original) match {
+        case null => NoSymbol
+        case entry => entry.owner.lookupCompanion(original).filter(_.isCoDefinedWith(original))
+      }
+    }
+
+    /** Search scopes in current and enclosing contexts for the definition of `symbol` */
+    private def lookupScopeEntry(symbol: Symbol): ScopeEntry = {
+      var res: ScopeEntry = null
+      var ctx = this
+      while (res == null && ctx.outer != ctx) {
+        val s = ctx.scope lookupSymbolEntry symbol
+        if (s != null)
+          res = s
+        else
+          ctx = ctx.outer
+      }
+      res
+    }
   } //class Context
 
   /** A `Context` focussed on an `Import` tree */
diff --git a/src/compiler/scala/tools/nsc/typechecker/Namers.scala b/src/compiler/scala/tools/nsc/typechecker/Namers.scala
index 78e8c8c073..60bda3ff9f 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Namers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Namers.scala
@@ -220,7 +220,10 @@ trait Namers extends MethodSynthesis {
 
     private def inCurrentScope(m: Symbol): Boolean = {
       if (owner.isClass) owner == m.owner
-      else m.owner.isClass && context.scope == m.owner.info.decls
+      else context.scope.lookupSymbolEntry(m) match {
+        case null => false
+        case entry => entry.owner eq context.scope
+      }
     }
 
     /** Enter symbol into context's scope and return symbol itself */
@@ -1923,10 +1926,7 @@ trait Namers extends MethodSynthesis {
     //         use the lower-level scan through the current Context as a fall back.
     if (!currentRun.compiles(owner)) owner.initialize
     original.companionSymbol orElse {
-      ctx.lookup(original.name.companionName, owner).suchThat(sym =>
-        (original.isTerm || sym.hasModuleFlag) &&
-        (sym isCoDefinedWith original)
-      )
+      ctx.lookupCompanionOf(original)
     }
   }
 
-- 
cgit v1.2.3