Support for Scala 3

.github/workflows/actions.yml

@@ -2,6 +2,10 @@ name: ci
 
 on:
   push:
+    branches:
+      - master
+    tags:
+      - '*'
   pull_request:
     branches:
       - master

build.sc

@@ -1,21 +1,26 @@
 import mill._, scalalib._, scalajslib._, scalanativelib._, publish._
+import mill.scalalib.api.Util.isScala3
 import scalalib._
-import $ivy.`de.tototec::de.tobiasroeser.mill.vcs.version_mill0.9:0.1.1`
+import $ivy.`de.tototec::de.tobiasroeser.mill.vcs.version::0.1.4`
 import de.tobiasroeser.mill.vcs.version.VcsVersion
-import $ivy.`com.github.lolgab::mill-mima_mill0.9:0.0.4`
+import $ivy.`com.github.lolgab::mill-mima::0.0.9`
 import com.github.lolgab.mill.mima._
 
 val scala212 = "2.12.13"
 val scala213 = "2.13.4"
+val scala30 = "3.0.2"
+val scala31 = "3.1.1"
+
+val scala2Versions = List(scala212, scala213)
 
 val scalaJSVersions = for {
-  scalaV <- Seq(scala213, scala212)
-  scalaJSV <- Seq("1.4.0")
+  scalaV <- scala30 :: scala2Versions
+  scalaJSV <- Seq("1.5.1")
 } yield (scalaV, scalaJSV)
 
 val scalaNativeVersions = for {
-  scalaV <- Seq(scala213, scala212)
-  scalaNativeV <- Seq("0.4.0")
+  scalaV <- scala2Versions
+  scalaNativeV <- Seq("0.4.3")
 } yield (scalaV, scalaNativeV)
 
 trait MainArgsPublishModule extends PublishModule with CrossScalaModule with Mima {
@@ -26,6 +31,8 @@ trait MainArgsPublishModule extends PublishModule with CrossScalaModule with Mim
       .lastTag
       .getOrElse(throw new Exception("Missing last tag"))
   )
+  // Remove after Scala 3 artifacts are published
+  def mimaPreviousArtifacts = T{ if(isScala3(scalaVersion())) Seq() else super.mimaPreviousArtifacts() }
   def artifactName = "mainargs"
 
   def pomSettings = PomSettings(
@@ -39,54 +46,57 @@ trait MainArgsPublishModule extends PublishModule with CrossScalaModule with Mim
     )
   )
 
-  def scalacOptions = super.scalacOptions() ++ Seq("-P:acyclic:force")
+  def scalacOptions = super.scalacOptions() ++ (if (!isScala3(crossScalaVersion)) Seq("-P:acyclic:force") else Seq.empty)
 
-  def scalacPluginIvyDeps = super.scalacPluginIvyDeps() ++ Agg(ivy"com.lihaoyi::acyclic:0.2.0")
+  def scalacPluginIvyDeps = super.scalacPluginIvyDeps() ++ (if (!isScala3(crossScalaVersion)) Agg(ivy"com.lihaoyi::acyclic:0.2.0") else Agg.empty)
 
-  def compileIvyDeps = super.compileIvyDeps() ++ Agg(
-    ivy"com.lihaoyi::acyclic:0.2.0",
-    ivy"org.scala-lang:scala-reflect:$crossScalaVersion"
-  )
+  def compileIvyDeps = super.compileIvyDeps() ++ (if (!isScala3(crossScalaVersion)) Agg(
+      ivy"com.lihaoyi::acyclic:0.2.0",
+      ivy"org.scala-lang:scala-reflect:$crossScalaVersion"
+    ) else Agg.empty)
 
   def ivyDeps = Agg(
-    ivy"org.scala-lang.modules::scala-collection-compat::2.4.0"
-  )
+    ivy"org.scala-lang.modules::scala-collection-compat::2.4.4"
+  ) ++ Agg(ivy"com.lihaoyi::pprint:0.6.6")
 }
 
+def scalaMajor(scalaVersion: String) = if(isScala3(scalaVersion)) "3" else "2"
+
 trait Common extends CrossScalaModule {
   def millSourcePath = build.millSourcePath / "mainargs"
   def sources = T.sources(
     millSourcePath / "src",
-    millSourcePath / s"src-$platform"
+    millSourcePath / s"src-$platform",
+    millSourcePath / s"src-${scalaMajor(scalaVersion())}",
   )
   def platform: String
 }
 
-trait CommonTestModule extends ScalaModule with TestModule {
-  def ivyDeps = Agg(ivy"com.lihaoyi::utest::0.7.6")
-  def testFrameworks = Seq("utest.runner.Framework")
+trait CommonTestModule extends ScalaModule with TestModule.Utest {
+  def ivyDeps = Agg(ivy"com.lihaoyi::utest::0.7.11")
   def sources = T.sources(
     millSourcePath / "src",
-    millSourcePath / s"src-$platform"
+    millSourcePath / s"src-$platform",
+    millSourcePath / s"src-${scalaMajor(scalaVersion())}",
   )
   def platform: String
 }
 
 
 object mainargs extends Module {
-  object jvm extends Cross[JvmMainArgsModule](scala212, scala213)
+  object jvm extends Cross[JvmMainArgsModule](scala30 :: scala2Versions: _*)
   class JvmMainArgsModule(val crossScalaVersion: String)
     extends Common with ScalaModule with MainArgsPublishModule {
     def platform = "jvm"
     object test extends Tests with CommonTestModule{
       def platform = "jvm"
-      def ivyDeps = super.ivyDeps() ++ Agg(ivy"com.lihaoyi::os-lib:0.7.1")
+      def ivyDeps = super.ivyDeps() ++ Agg(ivy"com.lihaoyi::os-lib:0.7.8")
     }
   }
 
   object js extends Cross[JSMainArgsModule](scalaJSVersions: _*)
   class JSMainArgsModule(val crossScalaVersion: String, crossJSVersion: String)
-    extends Common with ScalaJSModule with MainArgsPublishModule {
+    extends Common with MainArgsPublishModule with ScalaJSModule {
     def platform = "js"
     def scalaJSVersion = crossJSVersion
     object test extends Tests with CommonTestModule{
@@ -96,7 +106,7 @@ object mainargs extends Module {
 
   object native extends Cross[NativeMainArgsModule](scalaNativeVersions: _*)
   class NativeMainArgsModule(val crossScalaVersion: String, crossScalaNativeVersion: String)
-    extends Common with ScalaNativeModule with MainArgsPublishModule {
+    extends Common with MainArgsPublishModule with ScalaNativeModule {
     def scalaNativeVersion = crossScalaNativeVersion
     def platform = "native"
     object test extends Tests with CommonTestModule{

mainargs/src-2/ParserForClassCompanionVersionSpecific.scala

@@ -0,0 +1,9 @@
+package mainargs
+
+import acyclic.skipped
+
+import scala.language.experimental.macros
+
+private[mainargs] trait ParserForClassCompanionVersionSpecific {
+  def apply[T]: ParserForClass[T] = macro Macros.parserForClass[T]
+}

mainargs/src-2/ParserForMethodsCompanionVersionSpecific.scala

@@ -0,0 +1,9 @@
+package mainargs
+
+import acyclic.skipped
+
+import scala.language.experimental.macros
+
+private[mainargs] trait ParserForMethodsCompanionVersionSpecific {
+  def apply[B](base: B): ParserForMethods[B] = macro Macros.parserForMethods[B]
+}

mainargs/src-3/Macros.scala

@@ -0,0 +1,152 @@
+package mainargs
+
+import scala.quoted._
+
+object Macros {
+  private def mainAnnotation(using Quotes) = quotes.reflect.Symbol.requiredClass("mainargs.main")
+  private def argAnnotation(using Quotes) = quotes.reflect.Symbol.requiredClass("mainargs.arg")
+  def parserForMethods[B](base: Expr[B])(using Quotes, Type[B]): Expr[ParserForMethods[B]] = {
+    import quotes.reflect._
+    val allMethods = TypeRepr.of[B].typeSymbol.memberMethods
+    val annotatedMethodsWithMainAnnotations = allMethods.flatMap { methodSymbol =>
+      methodSymbol.getAnnotation(mainAnnotation).map(methodSymbol -> _)
+    }.sortBy(_._1.pos.map(_.start))
+    val mainDatas = Expr.ofList(annotatedMethodsWithMainAnnotations.map { (annotatedMethod, mainAnnotationInstance) =>
+      createMainData[Any, B](annotatedMethod, mainAnnotationInstance)
+    })
+
+    '{
+      new ParserForMethods[B](
+        MethodMains[B]($mainDatas, () => $base)
+      )
+    }
+  }
+
+  def parserForClass[B](using Quotes, Type[B]): Expr[ParserForClass[B]] = {
+    import quotes.reflect._
+    val typeReprOfB = TypeRepr.of[B]
+    val companionModule = typeReprOfB match {
+      case TypeRef(a,b) => TermRef(a,b)
+    }
+    val typeSymbolOfB = typeReprOfB.typeSymbol
+    val companionModuleType = typeSymbolOfB.companionModule.tree.asInstanceOf[ValDef].tpt.tpe.asType
+    val companionModuleExpr = Ident(companionModule).asExpr
+    val mainAnnotationInstance = typeSymbolOfB.getAnnotation(mainAnnotation).getOrElse {
+      report.throwError(
+        s"cannot find @main annotation on ${companionModule.name}",
+        typeSymbolOfB.pos.get
+      )
+    }
+    val annotatedMethod = TypeRepr.of[B].typeSymbol.companionModule.memberMethod("apply").head
+    companionModuleType match
+      case '[bCompanion] =>
+        val mainData = createMainData[B, Any](annotatedMethod, mainAnnotationInstance)
+        '{
+          new ParserForClass[B](
+            ClassMains[B](${ mainData }, () => ${ Ident(companionModule).asExpr })
+          )
+        }
+  }
+
+  def createMainData[T: Type, B: Type](using Quotes)(method: quotes.reflect.Symbol, annotation: quotes.reflect.Term): Expr[MainData[T, B]] = {
+    import quotes.reflect.*
+    val params = method.paramSymss.headOption.getOrElse(report.throwError("Multiple parameter lists not supported"))
+    val defaultParams = getDefaultParams(method)
+    val argSigs = Expr.ofList(params.map { param =>
+      val paramTree = param.tree.asInstanceOf[ValDef]
+      val paramTpe = paramTree.tpt.tpe
+      val arg = param.getAnnotation(argAnnotation).map(_.asExprOf[mainargs.arg]).getOrElse('{ new mainargs.arg() })
+      val paramType = paramTpe.asType
+      paramType match
+        case '[t] =>
+          val defaultParam: Expr[Option[B => t]] = defaultParams.get(param) match {
+            case Some('{ $v: `t`}) => '{ Some(((_: B) => $v)) }
+            case None => '{ None }
+          }
+          val argReader = Expr.summon[mainargs.ArgReader[t]].getOrElse {
+            report.throwError(
+              s"No mainargs.ArgReader found for parameter ${param.name}",
+              param.pos.get
+            )
+          }
+          '{ (ArgSig.create[t, B](${ Expr(param.name) }, ${ arg }, ${ defaultParam })(using ${ argReader })).asInstanceOf[ArgSig[Any, B]] }
+    })
+
+    val invokeRaw: Expr[(B, Seq[Any]) => T] = {
+      def callOf(args: Expr[Seq[Any]]) = call(method, '{ Seq( ${ args }) }).asExprOf[T]
+      '{ ((b: B, params: Seq[Any]) => ${ callOf('{ params }) }) }
+    }
+    '{ MainData.create[T, B](${ Expr(method.name) }, ${ annotation.asExprOf[mainargs.main] }, ${ argSigs }, ${ invokeRaw }) }
+  }
+
+  /** Call a method given by its symbol.
+    *
+    * E.g.
+    *
+    * assuming:
+    *
+    *   def foo(x: Int, y: String)(z: Int)
+    *
+    *   val argss: List[List[Any]] = ???
+    *
+    * then:
+    *
+    *   call(<symbol of foo>, '{argss})
+    *
+    * will expand to:
+    *
+    *   foo(argss(0)(0), argss(0)(1))(argss(1)(0))
+    *
+    */
+  private def call(using Quotes)(
+    method: quotes.reflect.Symbol,
+    argss: Expr[Seq[Seq[Any]]]
+  ): Expr[_] = {
+    // Copy pasted from Cask.
+    // https://github.com/com-lihaoyi/cask/blob/65b9c8e4fd528feb71575f6e5ef7b5e2e16abbd9/cask/src-3/cask/router/Macros.scala#L106
+    import quotes.reflect._
+    val paramss = method.paramSymss
+
+    if (paramss.isEmpty) {
+      report.throwError("At least one parameter list must be declared.", method.pos.get)
+    }
+
+    val fct = Ref(method)
+
+    val accesses: List[List[Term]] = for (i <- paramss.indices.toList) yield {
+      for (j <- paramss(i).indices.toList) yield {
+        val tpe = paramss(i)(j).tree.asInstanceOf[ValDef].tpt.tpe
+        tpe.asType match
+          case '[t] => '{ $argss(${Expr(i)})(${Expr(j)}).asInstanceOf[t] }.asTerm
+      }
+    }
+
+    val base = Apply(fct, accesses.head)
+    val application: Apply = accesses.tail.foldLeft(base)((lhs, args) => Apply(lhs, args))
+    val expr = application.asExpr
+    expr
+  }
+
+
+  /** Lookup default values for a method's parameters. */
+  private def getDefaultParams(using Quotes)(method: quotes.reflect.Symbol): Map[quotes.reflect.Symbol, Expr[Any]] = {
+    // Copy pasted from Cask.
+    // https://github.com/com-lihaoyi/cask/blob/65b9c8e4fd528feb71575f6e5ef7b5e2e16abbd9/cask/src-3/cask/router/Macros.scala#L38
+    import quotes.reflect._
+
+    val params = method.paramSymss.flatten
+    val defaults = collection.mutable.Map.empty[Symbol, Expr[Any]]
+
+    val Name = (method.name + """\$default\$(\d+)""").r
+
+    val idents = method.owner.tree.asInstanceOf[ClassDef].body
+    idents.foreach{
+      case deff @ DefDef(Name(idx), _, _, _) =>
+        val expr = Ref(deff.symbol).asExpr
+        defaults += (params(idx.toInt - 1) -> expr)
+      case _ =>
+    }
+
+    defaults.toMap
+  }
+}

mainargs/src-3/ParserForClassCompanionVersionSpecific.scala

@@ -0,0 +1,7 @@
+package mainargs
+
+import scala.language.experimental.macros
+
+private [mainargs] trait ParserForClassCompanionVersionSpecific {
+  inline def apply[T]: ParserForClass[T] = ${ Macros.parserForClass[T] }
+}

mainargs/src-3/ParserForMethodsCompanionVersionSpecific.scala

@@ -0,0 +1,5 @@
+package mainargs
+
+private [mainargs] trait ParserForMethodsCompanionVersionSpecific {
+  inline def apply[B](base: B): ParserForMethods[B] = ${ Macros.parserForMethods[B]('base) }
+}

mainargs/src-3/acyclic.scala

@@ -0,0 +1,3 @@
+package acyclic
+
+def skipped = ???

mainargs/src/Parser.scala

@@ -1,9 +1,11 @@
 package mainargs
+
+import acyclic.skipped
+
 import scala.language.experimental.macros
 import java.io.PrintStream
-object ParserForMethods{
-  def apply[B](base: B): ParserForMethods[B] = macro Macros.parserForMethods[B]
-}
+
+object ParserForMethods extends ParserForMethodsCompanionVersionSpecific
 class ParserForMethods[B](val mains: MethodMains[B]){
   def helpText(totalWidth: Int = 100,
                docsOnNewLine: Boolean = false,
@@ -102,9 +104,7 @@ class ParserForMethods[B](val mains: MethodMains[B]){
   }
 }
 
-object ParserForClass{
-  def apply[T]: ParserForClass[T] = macro Macros.parserForClass[T]
-}
+object ParserForClass extends ParserForClassCompanionVersionSpecific
 class ParserForClass[T](val mains: ClassMains[T]) extends SubParser[T]{
   def helpText(totalWidth: Int = 100,
                docsOnNewLine: Boolean = false,

mainargs/src/TokensReader.scala

@@ -18,7 +18,7 @@ object TokensReader{
   implicit object FloatRead extends TokensReader[Float]("float", strs => tryEither(strs.last.toFloat))
   implicit object DoubleRead extends TokensReader[Double]("double", strs => tryEither(strs.last.toDouble))
 
-  implicit def OptionRead[T: TokensReader] = new TokensReader[Option[T]](
+  implicit def OptionRead[T: TokensReader]: TokensReader[Option[T]] = new TokensReader[Option[T]](
     implicitly[TokensReader[T]].shortName,
     strs => {
       strs.lastOption match{
@@ -31,7 +31,7 @@ object TokensReader{
     },
     allowEmpty = true
   )
-  implicit def SeqRead[C[_] <: Iterable[_], T: TokensReader](implicit factory: Factory[T, C[T]]) = new TokensReader[C[T]](
+  implicit def SeqRead[C[_] <: Iterable[_], T: TokensReader](implicit factory: Factory[T, C[T]]): TokensReader[C[T]] = new TokensReader[C[T]](
     implicitly[TokensReader[T]].shortName,
     strs => {
       strs
@@ -50,7 +50,7 @@ object TokensReader{
     alwaysRepeatable = true,
     allowEmpty = true
   )
-  implicit def MapRead[K: TokensReader, V: TokensReader] = new TokensReader[Map[K, V]](
+  implicit def MapRead[K: TokensReader, V: TokensReader]: TokensReader[Map[K, V]] = new TokensReader[Map[K, V]](
     "k=v",
     strs => {
       strs.foldLeft[Either[String, Map[K, V]]](Right(Map())){

mainargs/test/src-2/OldVarargsTests.scala

@@ -0,0 +1,17 @@
+package mainargs
+import utest._
+
+object OldVarargsTests extends VarargsTests {
+  object Base {
+
+    @main
+    def pureVariadic(nums: Int*) = nums.sum
+
+    @main
+    def mixedVariadic(@arg(short = 'f') first: Int, args: String*) =
+      first + args.mkString
+  }
+
+  val check = new Checker(ParserForMethods(Base), allowPositional = true)
+  val isNewVarargsTests = false
+}