Update implementation of newMain annotation

Author: nicolasstucki

compiler/src/dotty/tools/dotc/ast/MainProxies.scala

@@ -11,6 +11,12 @@ import NameKinds.DefaultGetterName
 import Annotations.Annotation
 
 object MainProxies {
+
+  /** Generate proxy classes for @main functions and @myMain functions where myMain <:< MainAnnotation */
+  def proxies(stats: List[tpd.Tree])(using Context): List[untpd.Tree] = {
+    mainAnnotationProxies(stats) ++ mainProxies(stats)
+  }
+
   /** Generate proxy classes for @main functions.
    *  A function like
    *
@@ -29,7 +35,7 @@ object MainProxies {
    *         catch case err: ParseError => showError(err)
    *       }
    */
-  def mainProxiesOld(stats: List[tpd.Tree])(using Context): List[untpd.Tree] = {
+  private def mainProxies(stats: List[tpd.Tree])(using Context): List[untpd.Tree] = {
     import tpd._
     def mainMethods(stats: List[Tree]): List[Symbol] = stats.flatMap {
       case stat: DefDef if stat.symbol.hasAnnotation(defn.MainAnnot) =>
@@ -39,11 +45,11 @@ object MainProxies {
       case _ =>
         Nil
     }
-    mainMethods(stats).flatMap(mainProxyOld)
+    mainMethods(stats).flatMap(mainProxy)
   }
 
   import untpd._
-  def mainProxyOld(mainFun: Symbol)(using Context): List[TypeDef] = {
+  private def mainProxy(mainFun: Symbol)(using Context): List[TypeDef] = {
     val mainAnnotSpan = mainFun.getAnnotation(defn.MainAnnot).get.tree.span
     def pos = mainFun.sourcePos
     val argsRef = Ident(nme.args)
@@ -165,7 +171,7 @@ object MainProxies {
    *       }
    *     }
    */
-  def mainProxies(stats: List[tpd.Tree])(using Context): List[untpd.Tree] = {
+  private def mainAnnotationProxies(stats: List[tpd.Tree])(using Context): List[untpd.Tree] = {
     import tpd._
 
     /**
@@ -188,12 +194,12 @@ object MainProxies {
     def mainMethods(scope: Tree, stats: List[Tree]): List[(Symbol, ParameterAnnotationss, DefaultValueSymbols, Option[Comment])] = stats.flatMap {
       case stat: DefDef =>
         val sym = stat.symbol
-        sym.annotations.filter(_.matches(defn.MainAnnot)) match {
+        sym.annotations.filter(_.matches(defn.MainAnnotationClass)) match {
           case Nil =>
             Nil
           case _ :: Nil =>
             val paramAnnotations = stat.paramss.flatMap(_.map(
-              valdef => valdef.symbol.annotations.filter(_.matches(defn.MainAnnotParameterAnnotation))
+              valdef => valdef.symbol.annotations.filter(_.matches(defn.MainAnnotationParameterAnnotation))
             ))
             (sym, paramAnnotations.toVector, defaultValueSymbols(scope, sym), stat.rawComment) :: Nil
           case mainAnnot :: others =>
@@ -207,7 +213,7 @@ object MainProxies {
     }
 
     // Assuming that the top-level object was already generated, all main methods will have a scope
-    mainMethods(EmptyTree, stats).flatMap(mainProxy)
+    mainMethods(EmptyTree, stats).flatMap(mainAnnotationProxy)
   }
 
   private def mainAnnotationProxy(mainFun: Symbol, paramAnnotations: ParameterAnnotationss, defaultValueSymbols: DefaultValueSymbols, docComment: Option[Comment])(using Context): Option[TypeDef] = {
@@ -361,7 +367,7 @@ object MainProxies {
             case tree => super.transform(tree)
       }
       val annots = mainFun.annotations
-        .filterNot(_.matches(defn.MainAnnot))
+        .filterNot(_.matches(defn.MainAnnotationClass))
         .map(annot => insertTypeSplices.transform(annot.tree))
       val mainMeth = DefDef(nme.main, (mainArg :: Nil) :: Nil, TypeTree(defn.UnitType), body)
         .withFlags(JavaStatic)

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -954,6 +954,7 @@ class Definitions {
   @tu lazy val InlineParamAnnot: ClassSymbol = requiredClass("scala.annotation.internal.InlineParam")
   @tu lazy val ErasedParamAnnot: ClassSymbol = requiredClass("scala.annotation.internal.ErasedParam")
   @tu lazy val InvariantBetweenAnnot: ClassSymbol = requiredClass("scala.annotation.internal.InvariantBetween")
+  @tu lazy val MainAnnot: ClassSymbol = requiredClass("scala.main")
   @tu lazy val MigrationAnnot: ClassSymbol = requiredClass("scala.annotation.migration")
   @tu lazy val NowarnAnnot: ClassSymbol = requiredClass("scala.annotation.nowarn")
   @tu lazy val TransparentTraitAnnot: ClassSymbol = requiredClass("scala.annotation.transparentTrait")

compiler/src/dotty/tools/dotc/typer/Checking.scala

@@ -1382,9 +1382,10 @@ trait Checking {
   /** check that annotation `annot` is applicable to symbol `sym` */
   def checkAnnotApplicable(annot: Tree, sym: Symbol)(using Context): Boolean =
     !ctx.reporter.reportsErrorsFor {
+      val annotCls = Annotations.annotClass(annot)
       val concreteAnnot = Annotations.ConcreteAnnotation(annot)
       val pos = annot.srcPos
-      if (concreteAnnot.matches(defn.MainAnnot)) {
+      if (annotCls == defn.MainAnnot || concreteAnnot.matches(defn.MainAnnotationClass)) {
         if (!sym.isRealMethod)
           report.error(em"main annotation cannot be applied to $sym", pos)
         if (!sym.owner.is(Module) || !sym.owner.isStatic)

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -2626,7 +2626,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           pkg.moduleClass.info.decls.lookup(topLevelClassName).ensureCompleted()
           var stats1 = typedStats(tree.stats, pkg.moduleClass)._1
           if (!ctx.isAfterTyper)
-            stats1 = stats1 ++ typedBlockStats(MainProxies.mainProxies(stats1))._1
+            stats1 = stats1 ++ typedBlockStats(MainProxies.proxies(stats1))._1
           cpy.PackageDef(tree)(pid1, stats1).withType(pkg.termRef)
         }
       case _ =>