RFC: Allow macrocall as function sig

@KristofferC requested that `function @main(args) end` should work.
This is currently a parse error. This PR makes it work as expected
by allowing macrocall as a valid signature in function (needs
to exapand to a call expr). Note that this is only the flisp changes.
If this PR is accepted, an equivalent change would need to be made
in JuliaSyntax.

Author: Keno

base/client.jl

@@ -580,7 +580,7 @@ The `@main` macro may be used standalone or as part of the function definition,
 case, parentheses are required. In particular, the following are equivalent:
 
 ```
-function (@main)(args)
+function @main(args)
     println("Hello World")
 end
 ```
@@ -599,7 +599,7 @@ imported into `Main`, it will be treated as an entrypoint in `Main`:
 ```
 module MyApp
     export main
-    (@main)(args) = println("Hello World")
+    @main(args) = println("Hello World")
 end
 using .MyApp
 # `julia` Will execute MyApp.main at the conclusion of script execution
@@ -609,7 +609,7 @@ Note that in particular, the semantics do not attach to the method
 or the name:
 ```
 module MyApp
-    (@main)(args) = println("Hello World")
+    @main(args) = println("Hello World")
 end
 const main = MyApp.main
 # `julia` Will *NOT* execute MyApp.main unless there is a separate `@main` annotation in `Main`
@@ -619,9 +619,6 @@ const main = MyApp.main
 ```
 """
 macro main(args...)
-    if !isempty(args)
-        error("USAGE: `@main` is expected to be used as `(@main)` without macro arguments.")
-    end
     if isdefined(__module__, :main)
         if Base.binding_module(__module__, :main) !== __module__
             error("USAGE: Symbol `main` is already a resolved import in module $(__module__). `@main` must be used in the defining module.")
@@ -632,5 +629,9 @@ macro main(args...)
         global main
         global var"#__main_is_entrypoint__#"::Bool = true
     end)
-    esc(:main)
+    if !isempty(args)
+        Expr(:call, esc(:main), map(esc, args)...)
+    else
+        esc(:main)
+    end
 end

src/julia-parser.scm

@@ -1154,18 +1154,20 @@
         (parse-atom s))))
 
 (define (parse-def s is-func anon)
-  (let* ((ex  (parse-unary-prefix s))
-         (sig (if (or (and is-func (reserved-word? ex)) (initial-reserved-word? ex))
-                  (error (string "invalid name \"" ex "\""))
-                  (parse-call-chain s ex #f)))
-         (decl-sig
-          (if (and is-func (eq? (peek-token s) '|::|))
-              (begin (take-token s)
-                     `(|::| ,sig ,(parse-call s)))
-              sig)))
-    (if (eq? (peek-token s) 'where)
-        (parse-where-chain s decl-sig)
-        decl-sig)))
+  (let ((ex  (parse-unary-prefix s)))
+    (if (and (pair? ex) (eq? (car ex) 'macrocall))
+      ex
+      (let* ((sig (if (or (and is-func (reserved-word? ex)) (initial-reserved-word? ex))
+                      (error (string "invalid name \"" ex "\""))
+                      (parse-call-chain s ex #f)))
+            (decl-sig
+              (if (and is-func (eq? (peek-token s) '|::|))
+                  (begin (take-token s)
+                        `(|::| ,sig ,(parse-call s)))
+                  sig)))
+        (if (eq? (peek-token s) 'where)
+            (parse-where-chain s decl-sig)
+            decl-sig)))))
 
 (define (disallowed-space-error lno ex t)
   (error (string "space before \"" t "\" not allowed in \""
@@ -1329,7 +1331,8 @@
 
 (define (valid-func-sig? paren sig)
   (and (pair? sig)
-       (or (eq? (car sig) 'call)
+       (or (eq? (car sig) 'macrocall)
+           (eq? (car sig) 'call)
            (eq? (car sig) 'tuple)
            (and paren (eq? (car sig) 'block))
            (and paren (eq? (car sig) '...))