3 files changed, 24 insertions, 10 deletions
diff --git a/src/dotty/tools/dotc/core/Flags.scala b/src/dotty/tools/dotc/core/Flags.scala
index 5f400a3c8..d60bc5041 100644
--- a/src/dotty/tools/dotc/core/Flags.scala
+++ b/src/dotty/tools/dotc/core/Flags.scala
@@ -186,7 +186,7 @@ object Flags {
 
   /** A value or class implementing a module */
   final val Module = commonFlag(10, "module")
-  final val ModuleObj = Module.toTermFlags
+  final val ModuleVal = Module.toTermFlags
   final val ModuleClass = Module.toTypeFlags
 
   /** Labeled with `implicit` modifier (implicit value) */
@@ -198,7 +198,7 @@ object Flags {
   /** A case class or its companion object */
   final val Case = commonFlag(13, "case")
   final val CaseClass = Case.toTypeFlags
-  final val CaseObj = Case.toTermFlags
+  final val CaseVal = Case.toTermFlags
 
   /** Labeled with `lazy` (a lazy val). */
   final val Lazy = termFlag(14, "lazy")
@@ -213,9 +213,14 @@ object Flags {
 
   /** A value or class representing a package */
   final val Package = commonFlag(16, "<package>")
-  final val PackageObj = Package.toTermFlags
+  final val PackageVal = Package.toTermFlags
   final val PackageClass = Package.toTypeFlags
 
+  /** A package object or its module class */
+  final val PackageObject = commonFlag(???, "package")
+  final val PackageObjectVal = PackageObject.toTermFlags
+  final val PackageObjectClass = PackageObject.toTypeFlags
+
   /** A by-name parameter !!! needed? */
   final val ByNameParam = termFlag(17, "<by-name>")
 
diff --git a/src/dotty/tools/dotc/core/SymDenotations.scala b/src/dotty/tools/dotc/core/SymDenotations.scala
index 7600ff0e4..0a1138e46 100644
--- a/src/dotty/tools/dotc/core/SymDenotations.scala
+++ b/src/dotty/tools/dotc/core/SymDenotations.scala
@@ -62,10 +62,10 @@ object SymDenotations {
      *  flags.
      */
     final def isModule = _flags is Module
-    final def isModuleObj = _flags is ModuleObj
+    final def isModuleVal = _flags is ModuleVal
     final def isModuleClass = _flags is ModuleClass
     final def isPackage = _flags is Package
-    final def isPackageObj = _flags is PackageObj
+    final def isPackageVal = _flags is PackageVal
     final def isPackageClass = _flags is PackageClass
 
     /** is this denotation a method? */
@@ -108,7 +108,7 @@ object SymDenotations {
     override protected def copy(s: Symbol, i: Type): SingleDenotation = new UniqueRefDenotation(s, i, validFor)
 
     def moduleClass(implicit ctx: Context): Symbol =
-      if (this.isModuleObj) info.typeSymbol else NoSymbol
+      if (this.isModuleVal) info.typeSymbol else NoSymbol
 
     /** Desire to re-use the field in ClassSymbol which stores the source
      *  file to also store the classfile, but without changing the behavior
@@ -121,6 +121,8 @@ object SymDenotations {
     private def binaryFileOnly(file: AbstractFile): AbstractFile =
       if ((file eq null) || !(file.path endsWith ".class")) null else file
 
+    final def effectiveOwner(implicit ctx: Context) = owner.skipPackageObject
+
     final def topLevelClass(implicit ctx: Context): Symbol =
       if (!(owner.isPackageClass)) owner.topLevelClass
       else if (isClass) symbol
@@ -165,8 +167,8 @@ object SymDenotations {
       info.baseClasses.tail.iterator map overriddenSymbol filter (_.exists)
 
     def isCoDefinedWith(that: Symbol)(implicit ctx: Context) =
-      (this.owner == that.owner) &&
-      (  !(this.owner.isPackageClass)
+      (this.effectiveOwner == that.effectiveOwner) &&
+      (  !(this.effectiveOwner.isPackageClass)
       || (this.sourceFile == null)
       || (that.sourceFile == null)
       || (this.sourceFile.path == that.sourceFile.path)  // Cheap possibly wrong check, then expensive normalization
diff --git a/src/dotty/tools/dotc/core/Symbols.scala b/src/dotty/tools/dotc/core/Symbols.scala
index fc971b686..74c29802d 100644
--- a/src/dotty/tools/dotc/core/Symbols.scala
+++ b/src/dotty/tools/dotc/core/Symbols.scala
@@ -63,10 +63,10 @@ object Symbols {
      *  flags.
      */
     def isModule(implicit ctx: Context) = denot.isModule
-    def isModuleObj(implicit ctx: Context) = denot.isModuleObj
+    def isModuleObj(implicit ctx: Context) = denot.isModuleVal
     def isModuleClass(implicit ctx: Context) = denot.isModuleClass
     def isPackage(implicit ctx: Context) = denot.isPackage
-    def isPackageObj(implicit ctx: Context) = denot.isPackageObj
+    def isPackageObj(implicit ctx: Context) = denot.isPackageVal
     def isPackageClass(implicit ctx: Context) = denot.isPackageClass
 
     /** The current owner of this symbol */
@@ -96,6 +96,13 @@ object Symbols {
     /** Same as `ownersIterator contains sym` but more efficient. */
     final def hasTransOwner(sym: Symbol)(implicit ctx: Context): Boolean = denot.hasTransOwner(sym)
 
+    /** The owner, skipping package objects. */
+    def effectiveOwner(implicit ctx: Context) = denot.effectiveOwner
+
+    /** If this is a package object or its implementing class, its owner: otherwise this.
+     */
+    def skipPackageObject(implicit ctx: Context): Symbol = if (this is PackageObject) owner else this
+
     /** The top-level class containing this symbol, except for a toplevel module
      *  its module class
      */