Ensure main classes from .sc inputs take precedence before main classes found in JARs added to the classpath

Author: Gedochao

modules/build/src/main/scala/scala/build/Build.scala

@@ -120,30 +120,65 @@ object Build {
           case Sources.InMemory(_, _, _, Some(wrapperParams)) =>
             wrapperParams.mainClass
         }
-
-      val filteredMainClasses =
+          .filter(mainClasses.contains(_))
+      val rawInputInferredMainClasses =
         mainClasses
           .filterNot(scriptInferredMainClasses.contains(_))
           .filterNot(mainClassesFoundOnExtraClasspath.contains(_))
           .filterNot(mainClassesFoundInUserExtraDependencies.contains(_))
-      if filteredMainClasses.length == 1 then {
-        val pickedMainClass = filteredMainClasses.head
-        if (scriptInferredMainClasses.nonEmpty) {
-          val firstScript   = scriptInferredMainClasses.head
-          val scriptsString = scriptInferredMainClasses.mkString(", ")
+      val extraClasspathInferredMainClasses =
+        mainClassesFoundOnExtraClasspath.filter(mainClasses.contains(_))
+      val userExtraDependenciesInferredMainClasses =
+        mainClassesFoundInUserExtraDependencies.filter(mainClasses.contains(_))
+
+      def logMessageOnLesserPriorityMainClasses(
+        pickedMainClass: String,
+        mainClassDescriptor: String,
+        lesserPriorityMainClasses: Seq[String]
+      ): Unit =
+        if lesserPriorityMainClasses.nonEmpty then {
+          val first          = lesserPriorityMainClasses.head
+          val completeString = lesserPriorityMainClasses.mkString(", ")
           logger.message(
-            s"Running $pickedMainClass. Also detected script main classes: $scriptsString"
+            s"""Running $pickedMainClass. Also detected $mainClassDescriptor: $completeString
+               |You can run any one of them by passing option --main-class, i.e. --main-class $first
+               |All available main classes can always be listed by passing option --list-main-classes""".stripMargin
           )
-          logger.message(
-            s"You can run any one of them by passing option --main-class, i.e. --main-class $firstScript"
+        }
+
+      (
+        rawInputInferredMainClasses,
+        scriptInferredMainClasses,
+        extraClasspathInferredMainClasses,
+        userExtraDependenciesInferredMainClasses
+      ) match {
+        case (Seq(pickedMainClass), scriptInferredMainClasses, _, _) =>
+          logMessageOnLesserPriorityMainClasses(
+            pickedMainClass = pickedMainClass,
+            mainClassDescriptor = "script main classes",
+            lesserPriorityMainClasses = scriptInferredMainClasses
           )
-          logger.message(
-            "All available main classes can always be listed by passing option --list-main-classes"
+          Right(pickedMainClass)
+        case (rawMcs, scriptMcs, extraCpMcs, userExtraDepsMcs) if rawMcs.length > 1 =>
+          Left(rawMcs ++ scriptMcs ++ extraCpMcs ++ userExtraDepsMcs)
+        case (Nil, Seq(pickedMainClass), _, _) => Right(pickedMainClass)
+        case (Nil, scriptMcs, extraCpMcs, userExtraDepsMcs) if scriptMcs.length > 1 =>
+          Left(scriptMcs ++ extraCpMcs ++ userExtraDepsMcs)
+        case (Nil, Nil, Seq(pickedMainClass), userExtraDepsMcs) =>
+          logMessageOnLesserPriorityMainClasses(
+            pickedMainClass = pickedMainClass,
+            mainClassDescriptor = "other main classes in dependencies",
+            lesserPriorityMainClasses = userExtraDepsMcs
           )
-        }
-        Right(pickedMainClass)
+          Right(pickedMainClass)
+        case (Nil, Nil, extraCpMcs, userExtraDepsMcs) if extraCpMcs.length > 1 =>
+          Left(extraCpMcs ++ userExtraDepsMcs)
+        case (Nil, Nil, Nil, Seq(pickedMainClass)) => Right(pickedMainClass)
+        case (Nil, Nil, Nil, userExtraDepsMcs) if userExtraDepsMcs.length > 1 =>
+          Left(userExtraDepsMcs)
+        case (rawMcs, scriptMcs, extraCpMcs, userExtraDepsMcs) =>
+          Left(rawMcs ++ scriptMcs ++ extraCpMcs ++ userExtraDepsMcs)
       }
-      else Left(mainClasses)
     }
     def retainedMainClassOpt(
       mainClasses: Seq[String],

modules/integration/src/test/scala/scala/cli/integration/RunTestDefinitions.scala

@@ -2304,36 +2304,54 @@ abstract class RunTestDefinitions
       }
   }
 
-  test(
-    "prioritise main class in a .scala file over main classes in dependencies on the classpath"
-  ) {
-    val expectedMessage = "Main"
-    TestInputs(
-      os.rel / "Main.scala" -> s"""object Main extends App { println("$expectedMessage") }"""
-    )
-      .fromRoot { root =>
-        val localCache        = root / "local-cache"
-        val dependencyVersion = "42.7.4"
-        val csRes = os.proc(
-          TestUtil.cs,
-          "fetch",
-          "--cache",
-          localCache,
-          s"org.postgresql:postgresql:$dependencyVersion"
+  {
+    val expectedMessage = "Hello"
+    for {
+      (actualInputPath, inputPathToCall, inputs) <- {
+        val scalaInputPath  = os.rel / "Main.scala"
+        val scriptInputPath = os.rel / "script.sc"
+        val scalaInputs = TestInputs(
+          scalaInputPath -> s"""object Main extends App { println("$expectedMessage") }"""
         )
-          .call(cwd = root)
-        val dependencyJar = csRes.out.trim().linesIterator.toSeq.head
-
-        // pass classpath via -cp
-        val res = os.proc(TestUtil.cli, "run", ".", extraOptions, "-cp", dependencyJar)
-          .call(cwd = root)
-        expect(res.out.trim() == expectedMessage)
-
-        // pass classpath via args file
-        os.write(root / "args.txt", s"-cp $dependencyJar")
-        val res2 = os.proc(TestUtil.cli, "run", ".", extraOptions, "@args.txt")
-          .call(cwd = root)
-        expect(res2.out.trim() == expectedMessage)
+        val scriptInputs = TestInputs(scriptInputPath -> s"""println("$expectedMessage")""")
+        Seq(
+          (scalaInputPath, ".", scalaInputs),
+          (scalaInputPath, scalaInputPath.toString, scalaInputs),
+          (scriptInputPath, ".", scriptInputs),
+          (scriptInputPath, scriptInputPath.toString, scriptInputs)
+        )
+      }
+      inputExtension = "." + actualInputPath.last.split('.').last
+    }
+      test(
+        s"prioritise main class in a $inputExtension file passed as $inputPathToCall over main classes in dependencies on the classpath"
+      ) {
+        inputs.fromRoot { root =>
+          val localCache        = root / "local-cache"
+          val dependencyVersion = "42.7.4"
+          val csRes = os.proc(
+            TestUtil.cs,
+            "fetch",
+            "--cache",
+            localCache,
+            s"org.postgresql:postgresql:$dependencyVersion"
+          )
+            .call(cwd = root)
+          val dependencyJar = csRes.out.trim().linesIterator.toSeq.head
+
+          // pass classpath via -cp
+          val res =
+            os.proc(TestUtil.cli, "run", inputPathToCall, extraOptions, "-cp", dependencyJar)
+              .call(cwd = root)
+          expect(res.out.trim() == expectedMessage)
+
+          // pass classpath via args file
+          val argsFileName = "args.txt"
+          os.write(root / argsFileName, s"-cp $dependencyJar")
+          val res2 = os.proc(TestUtil.cli, "run", inputPathToCall, extraOptions, s"@$argsFileName")
+            .call(cwd = root)
+          expect(res2.out.trim() == expectedMessage)
+        }
       }
   }
 }