From 06eee798f581ffa21dc4a69974315a7c2bc7abe1 Mon Sep 17 00:00:00 2001
From: Jason Zaugg <jzaugg@gmail.com>
Date: Tue, 31 Jan 2017 10:59:59 -0700
Subject: Refactor implementation of lookupCompanion

  - Check for module class up front to use sourceModule
  - Consolidate most of the logic in Contexts
---
 src/reflect/scala/reflect/internal/Scopes.scala | 33 +++++++++++--------------
 1 file changed, 14 insertions(+), 19 deletions(-)

(limited to 'src/reflect')

diff --git a/src/reflect/scala/reflect/internal/Scopes.scala b/src/reflect/scala/reflect/internal/Scopes.scala
index 51fb31d36d..0435a2c1cf 100644
--- a/src/reflect/scala/reflect/internal/Scopes.scala
+++ b/src/reflect/scala/reflect/internal/Scopes.scala
@@ -291,25 +291,6 @@ trait Scopes extends api.Scopes { self: SymbolTable =>
       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 companion 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
@@ -345,6 +326,20 @@ trait Scopes extends api.Scopes { self: SymbolTable =>
       e
     }
 
+    final def lookupNameInSameScopeAs(original: Symbol, companionName: Name): Symbol = {
+      lookupSymbolEntry(original) match {
+        case null =>
+        case entry =>
+          var e = lookupEntry(companionName)
+          while (e != null) {
+            if (e.owner eq entry.owner) return e.sym
+            e = lookupNextEntry(e)
+          }
+      }
+      NoSymbol
+    }
+
+
     /** TODO - we can test this more efficiently than checking isSubScope
      *  in both directions. However the size test might be enough to quickly
      *  rule out most failures.
-- 
cgit v1.2.3