Check @main annotations for applicability

Check applicability of annotations only once they are completed

Author: odersky

compiler/src/dotty/tools/dotc/reporting/Reporter.scala

@@ -250,6 +250,14 @@ abstract class Reporter extends interfaces.ReporterResult {
    */
   def errorsReported: Boolean = hasErrors
 
+  /** Run `op` and return `true` if errors were reported by this reporter.
+   */
+  def reportsErrorsFor(op: given Context => Unit) given Context : Boolean = {
+    val initial = errorCount
+    op
+    errorCount > initial
+  }
+
   private[this] var reportedFeaturesUseSites = Set[Symbol]()
 
   def isReportedFeatureUseSite(featureTrait: Symbol): Boolean =

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

@@ -1136,6 +1136,19 @@ trait Checking {
     }
   }
 
+  /** check that annotation `annot` is applicable to symbol `sym` */
+  def checkAnnotApplicable(annot: Tree, sym: Symbol) given (ctx: Context): Boolean =
+    !ctx.reporter.reportsErrorsFor {
+      val pos = annot.sourcePos
+      if (annot.symbol == defn.MainAnnot) {
+        if (!sym.isRealMethod)
+          ctx.error(em"@main annotation cannot be applied to $sym", pos)
+        if (!sym.owner.is(Module) || !sym.owner.isStatic)
+          ctx.error(em"$sym cannot be a @main method since it cannot be accessed statically", pos)
+      }
+      // TODO: Add more checks here
+    }
+
   /** Check that symbol's external name does not clash with symbols defined in the same scope */
   def checkNoAlphaConflict(stats: List[Tree])(implicit ctx: Context): Unit = {
     var seen = Set[Name]()
@@ -1157,6 +1170,7 @@ trait ReChecking extends Checking {
   override def checkEnum(cdef: untpd.TypeDef, cls: Symbol, firstParent: Symbol)(implicit ctx: Context): Unit = ()
   override def checkRefsLegal(tree: tpd.Tree, badOwner: Symbol, allowed: (Name, Symbol) => Boolean, where: String)(implicit ctx: Context): Unit = ()
   override def checkEnumCaseRefsLegal(cdef: TypeDef, enumCtx: Context)(implicit ctx: Context): Unit = ()
+  override def checkAnnotApplicable(annot: Tree, sym: Symbol) given (ctx: Context): Boolean = true
 }
 
 trait NoChecking extends ReChecking {

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

@@ -1458,7 +1458,8 @@ class Typer extends Namer
     sym.annotations.foreach(_.ensureCompleted)
     lazy val annotCtx = annotContext(mdef, sym)
     // necessary in order to mark the typed ahead annotations as definitely typed:
-    untpd.modsDeco(mdef).mods.annotations.foreach(typedAnnotation(_)(annotCtx))
+    for annot <- untpd.modsDeco(mdef).mods.annotations do
+      checkAnnotApplicable(typedAnnotation(annot)(annotCtx), sym)
   }
 
   def typedAnnotation(annot: untpd.Tree)(implicit ctx: Context): Tree = track("typedAnnotation") {

tests/neg/main-functions.scala

@@ -1,15 +1,4 @@
+class TC
 object Test1 {
-  @main def f(x: Foo) = () // error: no implicit argument of type util.FromString[Foo] was found
+  @main def f(x: TC) = () // error: no implicit argument of type util.FromString[TC] was found
 }
-
-object Test2 {
-  @main val x = 2  // does nothing, should this be made an error?
-}
-
-class Foo {
-  @main def f = () // does nothing, should this be made an error?
-}
-
-@main def g(x: Int*)(y: Int*) = () // error: varargs parameter of @main method must come last
-
-@main def h[T: util.FromString](x: T) = () // error: @main method cannot have type parameters