Detect double toplevel definitions in separate files

Flag as error if two separate files contain toplevel definitions with
the same name.

Author: odersky

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

@@ -302,21 +302,45 @@ class Namer { typer: Typer =>
 
     typr.println(i"creating symbol for $tree in ${ctx.mode}")
 
-    def checkNoConflict(name: Name): Name = {
-      def errorName(msg: => String) = {
-        ctx.error(msg, tree.sourcePos)
-        name.freshened
-      }
+    def checkNoConflict(name: Name, isPrivate: Boolean): Name =
+      val owner = ctx.owner
+      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}"
+        ctx.error(i"$name is already defined as $conflicting$where", tree.sourcePos)
+        conflictsDetected = true
+
+      def checkNoConflictWith(preExisting: Symbol) =
+        if (preExisting.isDefinedInCurrentRun || preExisting.is(Package))
+           && (!preExisting.is(Private) || preExisting.owner.is(Package))
+        then conflict(preExisting)
+
+      def checkNoConflictIn(owner: Symbol) =
+        checkNoConflictWith( owner.unforcedDecls.lookup(name))
+
+      def pkgObjs(pkg: Symbol) =
+        pkg.denot.asInstanceOf[PackageClassDenotation].packageObjs.map(_.symbol)
+
       def preExisting = ctx.effectiveScope.lookup(name)
-      if (ctx.owner.is(PackageClass))
-        if (preExisting.isDefinedInCurrentRun)
-          errorName(s"${preExisting.showLocated} has already been compiled once during this run")
-        else name
+      if owner.is(PackageClass) then
+        checkNoConflictWith(preExisting)
+        return name
+        for pkgObj <- pkgObjs(owner) do
+          checkNoConflictIn(pkgObj)
       else
-        if ((!ctx.owner.isClass || name.isTypeName) && preExisting.exists)
-          errorName(i"$name is already defined as $preExisting")
-        else name
-    }
+        if (!owner.isClass || name.isTypeName) && preExisting.exists then
+          conflict(preExisting)
+        else if owner.isPackageObject && !isPrivate && name != nme.CONSTRUCTOR then
+          checkNoConflictIn(owner.owner)
+          for pkgObj <- pkgObjs(owner.owner) if pkgObj != owner do
+            checkNoConflictIn(pkgObj)
+
+      if conflictsDetected then name.freshened else name
+    end checkNoConflict
 
     /** Create new symbol or redefine existing symbol under lateCompile. */
     def createOrRefine[S <: Symbol](
@@ -348,17 +372,17 @@ class Namer { typer: Typer =>
 
     tree match {
       case tree: TypeDef if tree.isClassDef =>
-        val name = checkNoConflict(tree.name).asTypeName
         val flags = checkFlags(tree.mods.flags &~ GivenOrImplicit)
+        val name = checkNoConflict(tree.name, flags.is(Private)).asTypeName
         val cls =
           createOrRefine[ClassSymbol](tree, name, flags, ctx.owner,
             cls => adjustIfModule(new ClassCompleter(cls, tree)(ctx), tree),
             ctx.newClassSymbol(ctx.owner, name, _, _, _, tree.nameSpan, ctx.source.file))
         cls.completer.asInstanceOf[ClassCompleter].init()
         cls
       case tree: MemberDef =>
-        val name = checkNoConflict(tree.name)
         var flags = checkFlags(tree.mods.flags)
+        val name = checkNoConflict(tree.name, flags.is(Private))
         tree match
           case tree: ValOrDefDef =>
             if tree.unforcedRhs == EmptyTree

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

@@ -1875,10 +1875,10 @@ class Typer extends Namer
     assignType(cpy.Import(imp)(expr1, selectors1), sym)
   }
 
-  def typedPackageDef(tree: untpd.PackageDef)(implicit ctx: Context): Tree = {
+  def typedPackageDef(tree: untpd.PackageDef)(implicit ctx: Context): Tree =
     val pid1 = typedExpr(tree.pid, AnySelectionProto)(ctx.addMode(Mode.InPackageClauseName))
     val pkg = pid1.symbol
-    pid1 match {
+    pid1 match
       case pid1: RefTree if pkg.is(Package) =>
         val packageCtx = ctx.packageContext(tree, pkg)
         var stats1 = typedStats(tree.stats, pkg.moduleClass)(packageCtx)._1
@@ -1890,8 +1890,7 @@ class Typer extends Namer
         errorTree(tree,
           if pkg.exists then PackageNameAlreadyDefined(pkg)
           else i"package ${tree.pid.name} does not exist")
-    }
-  }
+  end typedPackageDef
 
   def typedAnnotated(tree: untpd.Annotated, pt: Type)(implicit ctx: Context): Tree = {
     val annot1 = typedExpr(tree.annot, defn.AnnotationClass.typeRef)

tests/neg/toplevel-doubledef/defs_1.scala

@@ -0,0 +1,2 @@
+def hello(x: String): Unit =
+  println(s"hello: $x")

tests/neg/toplevel-doubledef/moredefs_1.scala

@@ -0,0 +1,2 @@
+def hello(x: String): Unit = // error: has already been compiled
+  println(s"hi, $x")

tests/neg/toplevel-overload/defs_1.scala

@@ -0,0 +1,5 @@
+trait A
+
+def f(x: A) = s"A"
+
+def g(): Unit = ()

tests/neg/toplevel-overload/moredefs_1.scala

@@ -0,0 +1,5 @@
+trait B
+
+def f(x: B) = s"B" // error: has already been compiled
+
+private def g(): Unit = () // OK, since it is private

tests/neg/toplevel-package/defs_1.scala

@@ -0,0 +1,6 @@
+package foo
+package bar
+  class C
+  def hello(x: String): Unit =
+    println(s"hello: $x")
+

tests/neg/toplevel-package/moredefs_2.scala

@@ -0,0 +1,2 @@
+package foo
+def bar = 2  // error: bar is a package

tests/run/toplevel-mixed/B_1.scala

@@ -9,5 +9,5 @@ object X2 {
   def bar = "hi"
 }
 
-class X3
+class X4