Properly report clashes between classes and objects

compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala

@@ -168,7 +168,8 @@ enum ErrorMessageID extends java.lang.Enum[ErrorMessageID] {
     CannotExtendJavaEnumID,
     InvalidReferenceInImplicitNotFoundAnnotationID,
     TraitMayNotDefineNativeMethodID,
-    JavaEnumParentArgsID
+    JavaEnumParentArgsID,
+    AlreadyDefinedID
 
   def errorNumber = ordinal - 2
 }

compiler/src/dotty/tools/dotc/reporting/messages.scala

@@ -1847,6 +1847,19 @@ import transform.SymUtils._
     def explain = ""
   }
 
+  class AlreadyDefined(name: Name, owner: Symbol, conflicting: Symbol)(using Context) extends NamingMsg(AlreadyDefinedID):
+    private def where: String =
+      if conflicting.effectiveOwner.is(Package) && conflicting.associatedFile != null then
+        i" in ${conflicting.associatedFile}"
+      else if conflicting.owner == owner then ""
+      else i" in ${conflicting.owner}"
+    def msg =
+      if conflicting.isTerm != name.isTermName then
+        em"$name clashes with $conflicting$where; the two must be defined together"
+      else
+        em"$name is already defined as $conflicting$where"
+    def explain = ""
+
   class PackageNameAlreadyDefined(pkg: Symbol)(using Context) extends NamingMsg(PackageNameAlreadyDefinedID) {
     lazy val (where, or) =
       if pkg.associatedFile == null then ("", "")

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

@@ -746,6 +746,17 @@ trait Checking {
         em"Implementation restriction: ${path.tpe.classSymbol} is not a valid prefix " +
           "for a wildcard export, as it is a package.", path.srcPos)
 
+  /** Check that module `sym` does not clash with a class of the same name
+   *  that is concurrently compiled in another source file.
+   */
+  def checkNoModuleClash(sym: Symbol)(using Context): Unit =
+    if sym.effectiveOwner.is(Package)
+       && sym.owner.info.member(sym.name.moduleClassName).symbol.isAbsent()
+    then
+      val conflicting = sym.owner.info.member(sym.name.toTypeName).symbol
+      if conflicting.exists then
+        report.error(AlreadyDefined(sym.name, sym.owner, conflicting), sym.srcPos)
+
  /**  Check that `tp` is a class type.
   *   Also, if `traitReq` is true, check that `tp` is a trait.
   *   Also, if `stablePrefixReq` is true and phase is not after RefChecks,
@@ -1266,6 +1277,7 @@ trait ReChecking extends Checking {
   override def checkEnumCaseRefsLegal(cdef: TypeDef, enumCtx: Context)(using Context): Unit = ()
   override def checkAnnotApplicable(annot: Tree, sym: Symbol)(using Context): Boolean = true
   override def checkMatchable(tp: Type, pos: SrcPos, pattern: Boolean)(using Context): Unit = ()
+  override def checkNoModuleClash(sym: Symbol)(using Context) = ()
 }
 
 trait NoChecking extends ReChecking {

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

@@ -136,11 +136,10 @@ class Namer { typer: Typer =>
     var conflictsDetected = false
 
     def conflict(conflicting: Symbol) =
-      val where: String =
-        if conflicting.owner == owner then ""
-        else if conflicting.owner.isPackageObject then i" in ${conflicting.associatedFile}"
-        else i" in ${conflicting.owner}"
-      report.error(i"$name is already defined as $conflicting$where", ctx.source.atSpan(span))
+      val other =
+        if conflicting.is(ConstructorProxy) then conflicting.companionClass
+        else conflicting
+      report.error(AlreadyDefined(name, owner, other), ctx.source.atSpan(span))
       conflictsDetected = true
 
     def checkNoConflictIn(owner: Symbol) =

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

@@ -1979,6 +1979,7 @@ class Typer extends Namer
     val ValDef(name, tpt, _) = vdef
     completeAnnotations(vdef, sym)
     if (sym.isOneOf(GivenOrImplicit)) checkImplicitConversionDefOK(sym)
+    if sym.is(Module) then checkNoModuleClash(sym)
     val tpt1 = checkSimpleKinded(typedType(tpt))
     val rhs1 = vdef.rhs match {
       case rhs @ Ident(nme.WILDCARD) => rhs withType tpt1.tpe

tests/neg/i9472a.check

@@ -0,0 +1,4 @@
+-- [E161] Naming Error: tests/neg/i9472a/B.scala:3:0 -------------------------------------------------------------------
+3 |object Reproduction // error
+  |^
+  |Reproduction clashes with class Reproduction in tests/neg/i9472a/A.scala; the two must be defined together

tests/neg/i9472a/A.scala

@@ -0,0 +1,4 @@
+package example.reproduction
+
+class Reproduction
+

tests/neg/i9472a/B.scala

@@ -0,0 +1,5 @@
+package example.reproduction
+
+object Reproduction // error
+
+

tests/neg/i9472b.check

@@ -0,0 +1,4 @@
+-- [E161] Naming Error: tests/neg/i9472b/A.scala:3:0 -------------------------------------------------------------------
+3 |object Reproduction // error
+  |^
+  |Reproduction clashes with class Reproduction in tests/neg/i9472b/B.scala; the two must be defined together

tests/neg/i9472b/A.scala

@@ -0,0 +1,4 @@
+package example.reproduction
+
+object Reproduction // error
+

tests/neg/i9472b/B.scala

@@ -0,0 +1,4 @@
+package example.reproduction
+
+class Reproduction
+

tests/neg/trailingCommas.scala

@@ -7,9 +7,9 @@ trait ArgumentExprs2 { validMethod(23, "bar")(Ev0, Ev1, ) } // error // error
 trait ArgumentExprs3 { new ValidClass(23, "bar", )(Ev0, Ev1) } // error // error
 trait ArgumentExprs4 { new ValidClass(23, "bar")(Ev0, Ev1, ) } // error // error
 
-trait Params1 { def f(foo: Int, bar: String, )(implicit ev0: Ev0, ev1: Ev1, ) = 1 } // error // error // error
+trait Params1 { def f(foo: Int, bar: String, )(implicit ev0: Ev0, ev1: Ev1, ) = 1 } // error // error
 
-trait Params2 { def f(foo: Int, bar: String, )(implicit ev0: Ev0, ev1: Ev1, ) = 1 } // error // error // error
+trait Params2 { def f(foo: Int, bar: String, )(implicit ev0: Ev0, ev1: Ev1, ) = 1 } // error // error
 
 trait ClassParams1 { final class C(foo: Int, bar: String, )(implicit ev0: Ev0, ev1: Ev1) } // error
 trait ClassParams2 { final class C(foo: Int, bar: String)(implicit ev0: Ev0, ev1: Ev1, ) } // error