Renamer: Add infrastructure for Checking Uniqueness of Generated Names (#941)

After #938, the `RenamerTests` do not check that the names are actually
unique.
This adds assertions checking that every `Id` only occurs in one
definition-like construct.

(note that
4cf2371
is intentionally wrong to show it failing on shadowing :) )

Author: marzipankaiser

effekt/jvm/src/test/scala/effekt/core/RenamerTests.scala

@@ -1,5 +1,7 @@
 package effekt.core
 
+import scala.collection.mutable
+
 /**
  * This is testing the main/core.Renamer using the test/core.TestRenamer.
  */
@@ -17,6 +19,59 @@ class RenamerTests extends CoreTests {
     assertAlphaEquivalent(obtained, pInput, clue)
   }
 
+  def assertDefsUnique(in: ModuleDecl,
+                       clue: => Any = "Duplicate definition") = {
+    val seen = mutable.HashSet.empty[Id]
+
+    def isFresh(id: Id): Unit = {
+      assert(!seen.contains(id), clue)
+      seen.add(id)
+    }
+
+    object check extends Tree.Query[Unit, Unit] {
+      override def empty = ()
+
+      override def combine = (_, _) => ()
+
+      override def visit[T](t: T)(visitor: Unit ?=> T => Unit)(using Unit): Unit = {
+        visitor(t)
+        t match {
+          case m: ModuleDecl =>
+            m.definitions.foreach { d => isFresh(d.id) }
+          case d: Def => isFresh(d.id)
+          case v: Val => isFresh(v.id)
+          case l: Let => isFresh(l.id)
+          case d: Declaration => isFresh(d.id)
+          case e: Extern.Def =>
+            isFresh(e.id)
+            e.tparams.foreach(isFresh);
+            e.vparams.foreach { p => isFresh(p.id) }
+            e.bparams.foreach { p => isFresh(p.id) };
+            e.cparams.foreach { p => isFresh(p) }
+          case b: BlockLit =>
+            b.tparams.foreach(isFresh);
+            b.cparams.foreach(isFresh)
+            b.vparams.foreach { p => isFresh(p.id) };
+            b.bparams.foreach { p => isFresh(p.id) }
+          case i: Implementation =>
+            i.operations.foreach { o =>
+              o.vparams.foreach { p => isFresh(p.id) }; o.bparams.foreach { p => isFresh(p.id) }
+            }
+          case _ => ()
+        }
+      }
+    }
+    check.query(in)(using ())
+  }
+  def assertRenamingMakesDefsUnique(input: String,
+                                    clue: => Any = "Duplicate definition",
+                                    names: Names = Names(defaultNames))(using munit.Location) = {
+    val pInput = parse(input, "input", names)
+    val renamer = new Renamer(names, "renamed")
+    val obtained = renamer(pInput)
+    assertDefsUnique(obtained, clue)
+  }
+
   test("No bound local variables"){
     val code =
       """module main
@@ -26,6 +81,7 @@ class RenamerTests extends CoreTests {
         |}
         |""".stripMargin
     assertRenamingPreservesAlpha(code)
+    assertRenamingMakesDefsUnique(code)
   }
 
   test("val binding"){
@@ -38,6 +94,7 @@ class RenamerTests extends CoreTests {
         |}
         |""".stripMargin
     assertRenamingPreservesAlpha(code)
+    assertRenamingMakesDefsUnique(code)
   }
 
   test("var binding"){
@@ -50,6 +107,7 @@ class RenamerTests extends CoreTests {
         |}
         |""".stripMargin
     assertRenamingPreservesAlpha(code)
+    assertRenamingMakesDefsUnique(code)
   }
 
   test("function (value) parameters"){
@@ -61,6 +119,7 @@ class RenamerTests extends CoreTests {
         |}
         |""".stripMargin
     assertRenamingPreservesAlpha(code)
+    assertRenamingMakesDefsUnique(code)
   }
 
   test("match clauses"){
@@ -75,6 +134,7 @@ class RenamerTests extends CoreTests {
         |}
         |""".stripMargin
     assertRenamingPreservesAlpha(code)
+    assertRenamingMakesDefsUnique(code)
   }
 
   test("type parameters"){
@@ -86,6 +146,7 @@ class RenamerTests extends CoreTests {
         |}
         |""".stripMargin
     assertRenamingPreservesAlpha(code)
+    assertRenamingMakesDefsUnique(code)
   }
 
   test("pseudo recursive"){
@@ -100,6 +161,7 @@ class RenamerTests extends CoreTests {
         | }
         |""".stripMargin
     assertRenamingPreservesAlpha(code)
+    assertRenamingMakesDefsUnique(code)
   }
   test("shadowing let bindings"){
     val code =
@@ -112,5 +174,6 @@ class RenamerTests extends CoreTests {
         | }
         |""".stripMargin
     assertRenamingPreservesAlpha(code)
+    assertRenamingMakesDefsUnique(code)
   }
 }

effekt/shared/src/main/scala/effekt/core/Tree.scala

@@ -432,6 +432,7 @@ object Tree {
         case (id, lit) => query(lit)
     }
     def query(b: ExternBody)(using Ctx): Res = structuralQuery(b, externBody)
+    def query(m: ModuleDecl)(using Ctx) = structuralQuery(m, PartialFunction.empty)
   }
 
   class Rewrite extends Structural {