Improve the usage of inclusive language

Changes:
- blacklist -> excludelist

Discussion:
- #21988

Author: Linyxus

Diff for: compiler/test/dotc/neg-best-effort-pickling.blacklist renamed to compiler/test/dotc/neg-best-effort-pickling.excludelist

@@ -12,65 +12,65 @@ object TestSources {
 
   // pos tests lists
 
-  def posFromTastyBlacklistFile: String = "compiler/test/dotc/pos-from-tasty.blacklist"
-  def posTestPicklingBlacklistFile: String = "compiler/test/dotc/pos-test-pickling.blacklist"
+  def posFromTastyExcludelistFile: String = "compiler/test/dotc/pos-from-tasty.excludelist"
+  def posTestPicklingExcludelistFile: String = "compiler/test/dotc/pos-test-pickling.excludelist"
   def posTestRecheckExcludesFile: String = "compiler/test/dotc/pos-test-recheck.excludes"
   def posLazyValsAllowlistFile: String = "compiler/test/dotc/pos-lazy-vals-tests.allowlist"
   def posLintingAllowlistFile: String = "compiler/test/dotc/pos-linting.allowlist"
-  def posInitGlobalScala2LibraryTastyBlacklistFile: String = "compiler/test/dotc/pos-init-global-scala2-library-tasty.blacklist"
+  def posInitGlobalScala2LibraryTastyExcludelistFile: String = "compiler/test/dotc/pos-init-global-scala2-library-tasty.excludelist"
 
-  def posFromTastyBlacklisted: List[String] = loadList(posFromTastyBlacklistFile)
-  def posTestPicklingBlacklisted: List[String] = loadList(posTestPicklingBlacklistFile)
+  def posFromTastyExcludelisted: List[String] = loadList(posFromTastyExcludelistFile)
+  def posTestPicklingExcludelisted: List[String] = loadList(posTestPicklingExcludelistFile)
   def posTestRecheckExcluded: List[String] = loadList(posTestRecheckExcludesFile)
   def posLazyValsAllowlist: List[String] = loadList(posLazyValsAllowlistFile)
   def posLintingAllowlist: List[String] = loadList(posLintingAllowlistFile)
-  def posInitGlobalScala2LibraryTastyBlacklisted: List[String] =
-    if Properties.usingScalaLibraryTasty then loadList(posInitGlobalScala2LibraryTastyBlacklistFile)
+  def posInitGlobalScala2LibraryTastyExcludelisted: List[String] =
+    if Properties.usingScalaLibraryTasty then loadList(posInitGlobalScala2LibraryTastyExcludelistFile)
     else Nil
 
   // run tests lists
 
-  def runFromTastyBlacklistFile: String = "compiler/test/dotc/run-from-tasty.blacklist"
-  def runTestPicklingBlacklistFile: String = "compiler/test/dotc/run-test-pickling.blacklist"
+  def runFromTastyExcludelistFile: String = "compiler/test/dotc/run-from-tasty.excludelist"
+  def runTestPicklingExcludelistFile: String = "compiler/test/dotc/run-test-pickling.excludelist"
   def runTestRecheckExcludesFile: String = "compiler/test/dotc/run-test-recheck.excludes"
   def runLazyValsAllowlistFile: String = "compiler/test/dotc/run-lazy-vals-tests.allowlist"
-  def runMacrosScala2LibraryTastyBlacklistFile: String = "compiler/test/dotc/run-macros-scala2-library-tasty.blacklist"
+  def runMacrosScala2LibraryTastyExcludelistFile: String = "compiler/test/dotc/run-macros-scala2-library-tasty.excludelist"
 
-  def runFromTastyBlacklisted: List[String] = loadList(runFromTastyBlacklistFile)
-  def runTestPicklingBlacklisted: List[String] = loadList(runTestPicklingBlacklistFile)
+  def runFromTastyExcludelisted: List[String] = loadList(runFromTastyExcludelistFile)
+  def runTestPicklingExcludelisted: List[String] = loadList(runTestPicklingExcludelistFile)
   def runTestRecheckExcluded: List[String] = loadList(runTestRecheckExcludesFile)
   def runLazyValsAllowlist: List[String] = loadList(runLazyValsAllowlistFile)
-  def runMacrosScala2LibraryTastyBlacklisted: List[String] =
-    if Properties.usingScalaLibraryTasty then loadList(runMacrosScala2LibraryTastyBlacklistFile)
+  def runMacrosScala2LibraryTastyExcludelisted: List[String] =
+    if Properties.usingScalaLibraryTasty then loadList(runMacrosScala2LibraryTastyExcludelistFile)
     else Nil
 
   // neg tests lists
 
-  def negScala2LibraryTastyBlacklistFile: String = "compiler/test/dotc/neg-scala2-library-tasty.blacklist"
-  def negInitGlobalScala2LibraryTastyBlacklistFile: String = "compiler/test/dotc/neg-init-global-scala2-library-tasty.blacklist"
+  def negScala2LibraryTastyExcludelistFile: String = "compiler/test/dotc/neg-scala2-library-tasty.excludelist"
+  def negInitGlobalScala2LibraryTastyExcludelistFile: String = "compiler/test/dotc/neg-init-global-scala2-library-tasty.excludelist"
 
-  def negScala2LibraryTastyBlacklisted: List[String] =
-    if Properties.usingScalaLibraryTasty then loadList(negScala2LibraryTastyBlacklistFile)
+  def negScala2LibraryTastyExcludelisted: List[String] =
+    if Properties.usingScalaLibraryTasty then loadList(negScala2LibraryTastyExcludelistFile)
     else Nil
-  def negInitGlobalScala2LibraryTastyBlacklisted: List[String] =
-    if Properties.usingScalaLibraryTasty then loadList(negInitGlobalScala2LibraryTastyBlacklistFile)
+  def negInitGlobalScala2LibraryTastyExcludelisted: List[String] =
+    if Properties.usingScalaLibraryTasty then loadList(negInitGlobalScala2LibraryTastyExcludelistFile)
     else Nil
 
   // patmat tests lists
 
-  def patmatExhaustivityScala2LibraryTastyBlacklistFile: String = "compiler/test/dotc/patmat-exhaustivity-scala2-library-tasty.blacklist"
+  def patmatExhaustivityScala2LibraryTastyExcludelistFile: String = "compiler/test/dotc/patmat-exhaustivity-scala2-library-tasty.excludelist"
 
-  def patmatExhaustivityScala2LibraryTastyBlacklisted: List[String] =
-    if Properties.usingScalaLibraryTasty then loadList(patmatExhaustivityScala2LibraryTastyBlacklistFile)
+  def patmatExhaustivityScala2LibraryTastyExcludelisted: List[String] =
+    if Properties.usingScalaLibraryTasty then loadList(patmatExhaustivityScala2LibraryTastyExcludelistFile)
     else Nil
 
   // neg best effort tests lists
 
-  def negBestEffortPicklingBlacklistFile: String = "compiler/test/dotc/neg-best-effort-pickling.blacklist"
-  def negBestEffortUnpicklingBlacklistFile: String = "compiler/test/dotc/neg-best-effort-unpickling.blacklist"
+  def negBestEffortPicklingExcludelistFile: String = "compiler/test/dotc/neg-best-effort-pickling.excludelist"
+  def negBestEffortUnpicklingExcludelistFile: String = "compiler/test/dotc/neg-best-effort-unpickling.excludelist"
 
-  def negBestEffortPicklingBlacklisted: List[String] = loadList(negBestEffortPicklingBlacklistFile)
-  def negBestEffortUnpicklingBlacklisted: List[String] = loadList(negBestEffortUnpicklingBlacklistFile)
+  def negBestEffortPicklingExcludelisted: List[String] = loadList(negBestEffortPicklingExcludelistFile)
+  def negBestEffortUnpicklingExcludelisted: List[String] = loadList(negBestEffortUnpicklingExcludelistFile)
 
   // load lists
 

Diff for: compiler/test/dotc/neg-best-effort-unpickling.blacklist renamed to compiler/test/dotc/neg-best-effort-unpickling.excludelist

@@ -28,8 +28,8 @@ class BestEffortOptionsTests {
 
     implicit val testGroup: TestGroup = TestGroup("negTestFromBestEffortTasty")
     compileBestEffortTastyInDir(s"tests${JFile.separator}neg", bestEffortBaselineOptions,
-      picklingFilter = FileFilter.exclude(TestSources.negBestEffortPicklingBlacklisted),
-      unpicklingFilter = FileFilter.exclude(TestSources.negBestEffortUnpicklingBlacklisted)
+      picklingFilter = FileFilter.exclude(TestSources.negBestEffortPicklingExcludelisted),
+      unpicklingFilter = FileFilter.exclude(TestSources.negBestEffortUnpicklingExcludelisted)
     ).checkNoCrash()
   }
 

Diff for: compiler/test/dotc/neg-init-global-scala2-library-tasty.blacklist renamed to compiler/test/dotc/neg-init-global-scala2-library-tasty.excludelist

@@ -113,7 +113,7 @@ class BootstrappedOnlyCompilationTests {
 
   @Test def runMacros: Unit = {
     implicit val testGroup: TestGroup = TestGroup("runMacros")
-    compileFilesInDir("tests/run-macros", defaultOptions.and("-Xcheck-macros"), FileFilter.exclude(TestSources.runMacrosScala2LibraryTastyBlacklisted))
+    compileFilesInDir("tests/run-macros", defaultOptions.and("-Xcheck-macros"), FileFilter.exclude(TestSources.runMacrosScala2LibraryTastyExcludelisted))
       .checkRuns()
   }
 

Diff for: compiler/test/dotc/neg-scala2-library-tasty.blacklist renamed to compiler/test/dotc/neg-scala2-library-tasty.excludelist

@@ -139,7 +139,7 @@ class CompilationTests {
   @Test def negAll: Unit = {
     implicit val testGroup: TestGroup = TestGroup("compileNeg")
     aggregateTests(
-      compileFilesInDir("tests/neg", defaultOptions, FileFilter.exclude(TestSources.negScala2LibraryTastyBlacklisted)),
+      compileFilesInDir("tests/neg", defaultOptions, FileFilter.exclude(TestSources.negScala2LibraryTastyExcludelisted)),
       compileFilesInDir("tests/neg-deep-subtype", allowDeepSubtypes),
       compileFilesInDir("tests/neg-custom-args/captures", defaultOptions.and("-language:experimental.captureChecking")),
       compileFile("tests/neg-custom-args/sourcepath/outer/nested/Test1.scala", defaultOptions.and("-sourcepath", "tests/neg-custom-args/sourcepath")),
@@ -182,8 +182,8 @@ class CompilationTests {
   @Test def pickling: Unit = {
     implicit val testGroup: TestGroup = TestGroup("testPickling")
     aggregateTests(
-      compileFilesInDir("tests/pos", picklingOptions, FileFilter.exclude(TestSources.posTestPicklingBlacklisted)),
-      compileFilesInDir("tests/run", picklingOptions, FileFilter.exclude(TestSources.runTestPicklingBlacklisted))
+      compileFilesInDir("tests/pos", picklingOptions, FileFilter.exclude(TestSources.posTestPicklingExcludelisted)),
+      compileFilesInDir("tests/run", picklingOptions, FileFilter.exclude(TestSources.runTestPicklingExcludelisted))
     ).checkCompile()
   }
 
@@ -228,8 +228,8 @@ class CompilationTests {
   // initialization tests
   @Test def checkInitGlobal: Unit = {
     implicit val testGroup: TestGroup = TestGroup("checkInitGlobal")
-    compileFilesInDir("tests/init-global/warn", defaultOptions.and("-Ysafe-init-global"), FileFilter.exclude(TestSources.negInitGlobalScala2LibraryTastyBlacklisted)).checkWarnings()
-    compileFilesInDir("tests/init-global/pos", defaultOptions.and("-Ysafe-init-global", "-Xfatal-warnings"), FileFilter.exclude(TestSources.posInitGlobalScala2LibraryTastyBlacklisted)).checkCompile()
+    compileFilesInDir("tests/init-global/warn", defaultOptions.and("-Ysafe-init-global"), FileFilter.exclude(TestSources.negInitGlobalScala2LibraryTastyExcludelisted)).checkWarnings()
+    compileFilesInDir("tests/init-global/pos", defaultOptions.and("-Ysafe-init-global", "-Xfatal-warnings"), FileFilter.exclude(TestSources.posInitGlobalScala2LibraryTastyExcludelisted)).checkCompile()
   }
 
   // initialization tests

Diff for: compiler/test/dotc/patmat-exhaustivity-scala2-library-tasty.blacklist renamed to compiler/test/dotc/patmat-exhaustivity-scala2-library-tasty.excludelist

@@ -23,7 +23,7 @@ class FromTastyTests {
 
     implicit val testGroup: TestGroup = TestGroup("posTestFromTasty")
     compileTastyInDir(s"tests${JFile.separator}pos", defaultOptions,
-      fromTastyFilter = FileFilter.exclude(TestSources.posFromTastyBlacklisted)
+      fromTastyFilter = FileFilter.exclude(TestSources.posFromTastyExcludelisted)
     ).checkCompile()
   }
 
@@ -35,7 +35,7 @@ class FromTastyTests {
 
     implicit val testGroup: TestGroup = TestGroup("runTestFromTasty")
     compileTastyInDir(s"tests${JFile.separator}run", defaultOptions,
-      fromTastyFilter = FileFilter.exclude(TestSources.runFromTastyBlacklisted)
+      fromTastyFilter = FileFilter.exclude(TestSources.runFromTastyExcludelisted)
     ).checkRuns()
   }
 }

Diff for: compiler/test/dotc/pos-from-tasty.blacklist renamed to compiler/test/dotc/pos-from-tasty.excludelist

@@ -10,7 +10,7 @@ import org.junit.Test
 
 class ScannerTest extends DottyTest {
 
-  val blackList = List(
+  val excluded = List(
       "/scaladoc/scala/tools/nsc/doc/html/page/Index.scala",
       "/scaladoc/scala/tools/nsc/doc/html/page/Template.scala"
     )
@@ -33,13 +33,13 @@ class ScannerTest extends DottyTest {
   def scanDir(path: String): Unit = scanDir(Directory(path))
 
   def scanDir(dir: Directory): Unit = {
-    if (blackList exists (dir.jpath.toString endsWith _))
-      println(s"blacklisted package: ${dir.toAbsolute.jpath}")
+    if (excluded exists (dir.jpath.toString endsWith _))
+      println(s"excluded package: ${dir.toAbsolute.jpath}")
     else
       for (f <- dir.files)
         if (f.name.endsWith(".scala"))
-          if (blackList exists (f.jpath.toString endsWith _))
-            println(s"blacklisted file: ${f.toAbsolute.jpath}")
+          if (excluded exists (f.jpath.toString endsWith _))
+            println(s"excluded file: ${f.toAbsolute.jpath}")
           else
             scan(new PlainFile(f))
     for (d <- dir.dirs)

Diff for: compiler/test/dotc/pos-init-global-scala2-library-tasty.blacklist renamed to compiler/test/dotc/pos-init-global-scala2-library-tasty.excludelist

@@ -63,14 +63,14 @@ class PatmatExhaustivityTest {
 
   @Test
   def patmatExhaustivity: Unit = {
-    val blacklisted = TestSources.patmatExhaustivityScala2LibraryTastyBlacklisted.toSet
+    val excluded = TestSources.patmatExhaustivityScala2LibraryTastyExcludelisted.toSet
     val res = Directory(testsDir).list.toList
       .filter(f => f.ext.isScala || f.isDirectory)
       .filter { f =>
         val path = if f.isDirectory then f.path + "/" else f.path
         Properties.testsFilter.isEmpty || Properties.testsFilter.exists(path.contains)
       }
-      .filterNot(f => blacklisted.contains(f.name))
+      .filterNot(f => excluded.contains(f.name))
       .map(f => if f.isDirectory then compileDir(f.jpath) else compileFile(f.jpath))
 
     val failed = res.filter(!_)

Diff for: compiler/test/dotc/pos-test-pickling.blacklist renamed to compiler/test/dotc/pos-test-pickling.excludelist

@@ -11,8 +11,8 @@ object FileFilter {
     exclude(file :: files.toList)
 
   def exclude(files: List[String]): FileFilter = new FileFilter {
-    private val blackList = files.toSet
-    def accept(file: String): Boolean = !blackList.contains(file)
+    private val excluded = files.toSet
+    def accept(file: String): Boolean = !excluded.contains(file)
   }
 
   def include(files: List[String]): FileFilter = new FileFilter {

Diff for: compiler/test/dotc/run-from-tasty.blacklist renamed to compiler/test/dotc/run-from-tasty.excludelist

@@ -1579,7 +1579,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
             |
             |  sbt "testCompilation --from-tasty $file"
             |
-            |This tests can be disabled by adding `${file.getName}` to `compiler${JFile.separator}test${JFile.separator}dotc${JFile.separator}$runOrPos-$listName.blacklist`
+            |This tests can be disabled by adding `${file.getName}` to `compiler${JFile.separator}test${JFile.separator}dotc${JFile.separator}$runOrPos-$listName.excludelist`
             |
             |""".stripMargin
       }
@@ -1634,7 +1634,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
             |
             |  sbt "scalac $bestEffortFlag $semanticDbFlag $file"
             |
-            |These tests can be disabled by adding `${file.getName}` to `compiler${JFile.separator}test${JFile.separator}dotc${JFile.separator}neg-best-effort-pickling.blacklist`
+            |These tests can be disabled by adding `${file.getName}` to `compiler${JFile.separator}test${JFile.separator}dotc${JFile.separator}neg-best-effort-pickling.excludelist`
             |""".stripMargin
       }
     }
@@ -1661,7 +1661,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
             |  sbt "scalac -Ybest-effort $file"
             |  sbt "scalac --from-tasty -Ywith-best-effort-tasty $beTastyFilesString"
             |
-            |These tests can be disabled by adding `${file.getName}` to `compiler${JFile.separator}test${JFile.separator}dotc${JFile.separator}neg-best-effort-unpickling.blacklist`
+            |These tests can be disabled by adding `${file.getName}` to `compiler${JFile.separator}test${JFile.separator}dotc${JFile.separator}neg-best-effort-unpickling.excludelist`
             |
             |""".stripMargin
       }

Diff for: compiler/test/dotc/run-macros-scala2-library-tasty.blacklist renamed to compiler/test/dotc/run-macros-scala2-library-tasty.excludelist

@@ -87,5 +87,5 @@ the previously created Best Effort TASTy, with `-Yread-tasty` and `-Ywith-best-e
 TreeUnpickler for those Best Effort TASTy files.
 
 One of the goals of this feature is to keep the maintainance cost low, and to not let this feature hinder the pace of the
-overall development of the compiler. Because of that, the tests can be freely disabled in `compiler/neg-best-effort.blacklist`
-(testing TreePickler) and `compiler/neg-best-effort-from-tasty.blacklist` (testing TreeUnpickler).
+overall development of the compiler. Because of that, the tests can be freely disabled in `compiler/neg-best-effort.excludelist`
+(testing TreePickler) and `compiler/neg-best-effort-from-tasty.excludelist` (testing TreeUnpickler).

Diff for: compiler/test/dotc/run-test-pickling.blacklist renamed to compiler/test/dotc/run-test-pickling.excludelist

@@ -1708,7 +1708,7 @@ object Build {
         )
       },
 
-      // A first blacklist of tests for those that do not compile or do not link
+      // A first excludelist of tests for those that do not compile or do not link
       (Test / managedSources) ++= {
         val dir = fetchScalaJSSource.value / "test-suite"