derive DFApp arg type names from values and just ignore non-supported typed arguments instead of forbidding them

Author: Oron Port

lib/src/main/scala/dfhdl/app/DFApp.scala

@@ -41,7 +41,6 @@ trait DFApp:
       _topScalaPath: String,
       top: dfhdl.top,
       argNames: List[String],
-      argTypes: List[String],
       argValues: List[Any],
       argDescs: List[String]
   ): Unit =
@@ -52,7 +51,7 @@ trait DFApp:
     printerOptions = top.printerOptions
     linterOptions = top.linterOptions
     appOptions = top.appOptions
-    designArgs = DesignArgs(argNames, argTypes, argValues, argDescs)
+    designArgs = DesignArgs(argNames, argValues, argDescs)
   end setInitials
   final protected def setDsn(d: => core.Design): Unit = dsn = () => d
   private def elaborate: core.Design =

lib/src/main/scala/dfhdl/app/DesignArgs.scala

@@ -1,9 +1,23 @@
 package dfhdl.app
 import dfhdl.*
+import dfhdl.compiler.ir
 import core.{DFValAny, asValAny}
 import scala.collection.immutable.ListMap
 
-case class DesignArg(name: String, typeName: String, value: Any, desc: String)(using DFC):
+case class DesignArg(name: String, value: Any, desc: String)(using DFC):
+  val typeName =
+    value match
+      case _: String  => "String"
+      case _: Int     => "Int"
+      case _: Double  => "Double"
+      case _: Boolean => "Boolean"
+      case _: BigInt  => "Int"
+      case dfConst: DFValAny =>
+        dfConst.asIR.dfType match
+          case ir.DFBit | ir.DFBool => "Boolean"
+          case ir.DFInt32           => "Int"
+          case _                    => ""
+      case _ => ""
   def getScalaValue: Any =
     val data = value match
       case dfConst: DFValAny =>
@@ -29,13 +43,12 @@ object DesignArgs:
   def empty: DesignArgs = ListMap.empty
   def apply(
       argNames: List[String],
-      argTypes: List[String],
       argValues: List[Any],
       argDescs: List[String]
   ): DesignArgs =
     ListMap.from(
-      argNames.lazyZip(argTypes).lazyZip(argValues).lazyZip(argDescs).map(
-        (name, typeName, value, desc) => name -> DesignArg(name, typeName, value, desc)
+      argNames.lazyZip(argValues).lazyZip(argDescs).map((name, value, desc) =>
+        name -> DesignArg(name, value, desc)
       )
     )
   def apply(iter: Iterable[(String, DesignArg)]): DesignArgs = ListMap.from(iter)

lib/src/main/scala/dfhdl/app/ParsedCommandLine.scala

@@ -136,21 +136,22 @@ class ParsedCommandLine(
   exitHandler = code => exitCodeOption = Some(code)
   private lazy val designArgOptionGroup = group("Design arguments:")
   private val designArgOptions =
-    for (designArg <- designArgs.values)
-      yield
+    designArgs.view.values.collect {
+      case designArg if designArg.typeName.nonEmpty =>
         val conv = designArg.typeName match
-          case "String"          => summon[ValueConverter[String]]
-          case "Int"             => summon[ValueConverter[Int]]
-          case "Double"          => summon[ValueConverter[Double]]
-          case "Boolean" | "Bit" => summon[ValueConverter[Boolean]]
-          case _                 => ???
-        opt[Any](
+          case "String"  => summon[ValueConverter[String]]
+          case "Int"     => summon[ValueConverter[Int]]
+          case "Double"  => summon[ValueConverter[Double]]
+          case "Boolean" => summon[ValueConverter[Boolean]]
+        designArg.name -> opt[Any](
           name = designArg.name, descr = designArg.desc, argName = designArg.typeName,
           default = Some(designArg.getScalaValue), noshort = true, group = designArgOptionGroup
         )(conv.asInstanceOf[ValueConverter[Any]])
-  lazy val updatedDesignArgs: DesignArgs = DesignArgs(designArgs.lazyZip(designArgOptions).map {
-    case ((argName, designArg), opt) =>
-      (argName, designArg.updateScalaValue(opt.toOption.get))
+    }.toMap
+  lazy val updatedDesignArgs: DesignArgs = DesignArgs(designArgs.map { case (argName, designArg) =>
+    designArgOptions.get(argName) match
+      case None      => argName -> designArg
+      case Some(opt) => argName -> designArg.updateScalaValue(opt.toOption.get)
   })
 
   addSubcommand(Mode.elaborate)

plugin/src/main/scala/plugin/TopAnnotPhase.scala

@@ -79,25 +79,6 @@ class TopAnnotPhase(setting: Setting) extends CommonPhase:
                 val paramVDs =
                   template.constr.paramss.flatten.collect { case vd: ValDef => vd }
                 val dsnArgNames = mkList(paramVDs.map(vd => Literal(Constant(vd.name.toString))))
-                extension (vd: Type)
-                  def argType: Option[String] =
-                    if (vd <:< defn.IntType || vd <:< dfConstInt32Tpe) Some("Int")
-                    else if (vd <:< defn.StringType) Some("String")
-                    else if (vd <:< defn.DoubleType) Some("Double")
-                    else if (vd <:< defn.BooleanType || vd <:< dfConstBoolTpe) Some("Boolean")
-                    else if (vd <:< dfConstBitTpe) Some("Bit")
-                    else None
-
-                val dsnArgTypes = mkList(paramVDs.map { vd =>
-                  vd.tpt.tpe.argType match
-                    case Some(value) => Literal(Constant(value))
-                    case _ =>
-                      report.error(
-                        "Unsupported argument's type for top-level design with a default app entry point.\nEither use a supported type or disable the app entry point generation with `@top(false)`.",
-                        vd.srcPos
-                      )
-                      EmptyTree
-                })
                 val defaultMap = mutable.Map.empty[Int, Tree]
                 rest match
                   case (_: ValDef) :: (compSym @ TypeDef(_, compTemplate: Template)) :: _
@@ -125,8 +106,8 @@ class TopAnnotPhase(setting: Setting) extends CommonPhase:
                   mkList(paramVDs.map(vd => Literal(Constant(vd.symbol.docString.getOrElse("")))))
                 val setInitials = This(moduleCls).select("setInitials".toTermName).appliedToArgs(
                   List(
-                    designNameTree, topScalaPathTree, topAnnotTree, dsnArgNames, dsnArgTypes,
-                    dsnArgValues, dsnArgDescs
+                    designNameTree, topScalaPathTree, topAnnotTree, dsnArgNames, dsnArgValues,
+                    dsnArgDescs
                   )
                 )
                 val dsnInstArgs = paramVDs.map(vd =>