3 files changed, 54 insertions, 5 deletions
diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
index 8f0625e58c..fde2f7bb03 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)
+      }
+    }
+
+    /** 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 b445bc5837..395bda234b 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 */
@@ -1953,10 +1956,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)
     }
   }
 
diff --git a/src/reflect/scala/reflect/internal/Scopes.scala b/src/reflect/scala/reflect/internal/Scopes.scala
index a7bb127506..32ce02bdd6 100644
--- a/src/reflect/scala/reflect/internal/Scopes.scala
+++ b/src/reflect/scala/reflect/internal/Scopes.scala
@@ -282,6 +282,34 @@ trait Scopes extends api.Scopes { self: SymbolTable =>
       }
     }
 
+    final def lookupSymbolEntry(sym: Symbol): ScopeEntry = {
+      var e = lookupEntry(sym.name)
+      while (e ne null) {
+        if (e.sym == sym) return e
+        e = lookupNextEntry(e)
+      }
+      null
+    }
+
+    final def lookupCompanion(original: Symbol): Symbol = {
+      lookupSymbolEntry(original) match {
+        case null =>
+        case entry =>
+          var e = lookupEntry(original.name.companionName)
+          while (e != null) {
+            // 1) Must be owned by the same Scope, to ensure that in
+            //   `{ class C; { ...; object C } }`, the class is not seen as a comaniopn of the object.
+            // 2) Must be a class and module symbol, so that `{ class C; def C }` or `{ type T; object T }` are not companions.
+            def isClassAndModule(sym1: Symbol, sym2: Symbol) = sym1.isClass && sym2.isModule
+            if ((e.owner eq entry.owner) && (isClassAndModule(original, e.sym) || isClassAndModule(e.sym, original))) {
+              return if (e.sym.isCoDefinedWith(original)) e.sym else NoSymbol
+            }
+            e = lookupNextEntry(e)
+          }
+      }
+      NoSymbol
+    }
+
     /** lookup a symbol entry matching given name.
      *  @note from Martin: I believe this is a hotspot or will be one
      *  in future versions of the type system. I have reverted the previous