Add support for defining top-level main functions with nested commands

Previously this was not supported since the macro needs to handle this
case specially. The reason is bit subtle, but basically boils down
differences in how top-level classes and methods are encoded:

- classes are declared in a package
- methods are declared in a synthetically-generated 'package class'
  (presumably, because java bytecode supports only top-level class
  declarations)

This means that if a main method looks up annotated command classes in
`this`, then the lookup paths need to be handled differently depending
on whether or not the main method is top-level. There are also some
differences in instantiating the command class.

Author: jodersky

CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 0.19.1
+
+- Add support for defining top-level main functions with nested commands.
+
 ## 0.19.0
 
 - Add error handling and output printing to the annotation API.

argparse/sandbox/src/example.scala

@@ -8,23 +8,21 @@ object api
 
   override def defaultHelpFlags = Seq("-h")
 
-object app:
-
-  /**
-    * Hello world
-    *
-    * @param base the base value
-    */
+/**
+  * Hello world
+  *
+  * @param base the base value
+  */
+@api.command()
+class wrapper(base: Int):
   @api.command()
-  class wrapper(base: Int):
-    @api.command()
-    def add(x: Int) = println(base + x)
+  def add(x: Int) = println(base + x)
 
-    /** A nested command */
+  /** A nested command */
+  @api.command()
+  def nested(y: Int = 2) = foo(y)
+  class foo(y: Int):
     @api.command()
-    def nested(y: Int = 2) = foo(y)
-    class foo(y: Int):
-      @api.command()
-      def ok() = println("ok")
+    def ok() = println("ok")
 
-  def main(args: Array[String]): Unit = argparse.main(this, args)
+def main(args: Array[String]): Unit = argparse.main(this, args)

argparse/src-3/argparse/core/Command.scala

@@ -43,8 +43,17 @@ object CommandMacros:
     import qctx.reflect.*
     val CommandAnnot = TypeRepr.of[MacroApi#command]
 
-    val methods = TypeRepr.of[Container].typeSymbol.memberMethods
-    val classes = TypeRepr.of[Container].typeSymbol.memberTypes.filter(_.isClassDef)
+    val containerTpe = TypeRepr.of[Container].typeSymbol
+
+    // need to handle the case where `findImpl` is called from a top-level
+    // function, but commands are wrapped in a top-level annotated class
+    val isTopLevel = containerTpe.owner.isPackageDef && containerTpe.name.endsWith("$package$")
+
+    val methods = containerTpe.memberMethods
+    val classes = if isTopLevel then
+      containerTpe.owner.memberTypes.filter(_.isClassDef)
+    else
+      containerTpe.memberTypes.filter(_.isClassDef)
 
     for
       sym <- (methods ++ classes)
@@ -65,7 +74,7 @@ object CommandMacros:
 
       apiType.asType match
         case '[t] if TypeRepr.of[t] <:< TypeRepr.of[MacroApi] =>
-          makeCommand[Container, MacroApi](api.asExprOf[MacroApi], method, sym.name, doc)
+          makeCommand[Container, MacroApi](api.asExprOf[MacroApi], method, sym.name, doc, isTopLevel)
         case '[t] =>
           report.error(s"wrong API ${Type.show[t]}")
           '{???}
@@ -112,7 +121,8 @@ object CommandMacros:
     api: Expr[Api],
     method: qctx.reflect.Symbol,
     name: String, // name is separate because method name is not always representative (e.g. if method is class constructor)
-    doc: DocComment
+    doc: DocComment,
+    isTopLevel: Boolean
   ): Expr[Command[Container]] =
     import qctx.reflect.*
 
@@ -165,7 +175,7 @@ object CommandMacros:
                   Implicits.search(readerType) match
                     case iss: ImplicitSearchSuccess => iss.tree
                     case other =>
-                      report.error( s"No ${readerType.show} available for parameter ${param.name}.", param.pos.get)
+                      report.error(s"No ${readerType.show} available for parameter ${param.name}.", param.pos.get)
                       '{???}.asTerm
 
                 paramTpe match
@@ -251,18 +261,28 @@ object CommandMacros:
         }
 
         def callOrInstantiate() = try
-          val outer = instance()
           val results = args.map(_.map(_()))
           ${
-            if method.isClassConstructor then
+            if method.isClassConstructor && isTopLevel then
               call(using qctx)(
-                New(TypeSelect('{outer}.asTerm, rtpe.typeSymbol.name)).select(method),
+                New(method.tree.asInstanceOf[DefDef].returnTpt).select(method),
                 ptpes,
                 'results
               ).asExpr
+            else if method.isClassConstructor && !isTopLevel then
+              '{
+                val outer = instance()
+                ${
+                  call(using qctx)(
+                    New(TypeSelect('{outer}.asTerm, rtpe.typeSymbol.name)).select(method),
+                    ptpes,
+                    'results
+                  ).asExpr
+                }
+              }
             else
               call(using qctx)(
-                Select('{outer}.asTerm, method),
+                Select('{instance()}.asTerm, method),
                 ptpes,
                 'results
               ).asExpr

examples/annotation-commands/src/main.scala

@@ -1,22 +1,20 @@
 import argparse.default as ap
 
-object Main:
+@ap.command()
+class app():
 
   @ap.command()
-  class app:
+  def version() = println(s"v1000")
 
-    @ap.command()
-    def version() = println(s"v1000")
+  @ap.command()
+  class op(factor: Double = 1.0):
 
     @ap.command()
-    class op(factor: Double = 1.0):
+    def showFactor() = println(s"the factor is $factor")
 
-      @ap.command()
-      def showFactor() = println(s"the factor is $factor")
-
-      @ap.command()
-      def multiply(operand: Double) = println(s"result is: ${factor * operand}")
+    @ap.command()
+    def multiply(operand: Double) = println(s"result is: ${factor * operand}")
 
-  // this is boilerplate for now; it will become obsolete once macro-annotations
-  // are released
-  def main(args: Array[String]) = argparse.main(this, args)
+// this is boilerplate for now; it will become obsolete once macro-annotations
+// are released
+def main(args: Array[String]): Unit = argparse.main(this, args)