What is the Main object when running a Scala script? - scala

Question

For example the following code:
object Test extends App {
val x = 100
println(Main.x+" "+x)
}
Seems invalid since it won't compile given there is no Main object define anywhere.
And effectively it doesn't compile in Scastie nor using a standard scalac compiler (version 2.13.4), nor if you run this code directly on the REPL.
However, if you save it to a file and then you run it using the scala command (same version as before); like a script, it runs without problems and produces the following output:
100 100
What is that Main object? When and why it was added?

Answer 1

From what I see scriptBody() is responsible for this behavior:
/** This is the parse entry point for code which is not self-contained, e.g.
* a script which is a series of template statements. They will be
* swaddled in Trees until the AST is equivalent to the one returned
* by compilationUnit().
*/
def scriptBody(): Tree = {
// remain backwards-compatible if -Xscript was set but not reasonably
settings.script.value match {
case null | "" => settings.script.value = "Main"
case _ =>
}
...
// pick up object specified by `-Xscript Main`
def mainModule: Tree = settings.script.valueSetByUser.map(name => searchForMain(TermName(name))).getOrElse(EmptyTree)
/* Here we are building an AST representing the following source fiction,
* where `moduleName` is from -Xscript (defaults to "Main") and <stmts> are
* the result of parsing the script file.
*
* {{{
* object moduleName {
* def main(args: Array[String]): Unit =
* new AnyRef {
* stmts
* }
* }
* }}}
*/
def repackaged: Tree = {
...
Basically your script body is forcefully rewritten into something that is
object Main {
// must contain main
}
We can confirm that -Xscript appearing in these methods indeed controls this behavior:
// test.scala
object Test extends App {
val x = 100
println(Main.x+" "+x)
println(Main.getClass)
new Exception().printStackTrace()
}
With defaults we see that "Main" is used and that code is rewritten to have Main as starting point (code reused existing object Test extends App to create it):
> scala test.scala
warning: 1 deprecation (since 2.13.0); re-run with -deprecation for details
100 100
class Main$
java.lang.Exception
at Main$.delayedEndpoint$Main$1(test.scala:5)
at Main$delayedInit$body.apply(test.scala:1)
at scala.Function0.apply$mcV$sp(Function0.scala:39)
at scala.Function0.apply$mcV$sp$(Function0.scala:39)
at scala.runtime.AbstractFunction0.apply$mcV$sp(AbstractFunction0.scala:17)
at scala.App.$anonfun$main$1(App.scala:76)
at scala.App.$anonfun$main$1$adapted(App.scala:76)
at scala.collection.IterableOnceOps.foreach(IterableOnce.scala:563)
at scala.collection.IterableOnceOps.foreach$(IterableOnce.scala:561)
at scala.collection.AbstractIterable.foreach(Iterable.scala:919)
at scala.App.main(App.scala:76)
at scala.App.main$(App.scala:74)
at Main$.main(test.scala:1)
at Main.main(test.scala)
...
If we specify Test as our main, Main is not generated and compilation fails
> scala -Xscript Test test.scala
test.scala:3: error: not found: value Main
println(Main.x+" "+x)
^
test.scala:4: error: not found: value Main
println(Main.getClass)
Behavior of e.g. Scastie is different as Scastie defines its own main and put your code into it, so this synthetic Main is never created (though Test was still tampered with).