Permit declarations of the form f(x::Vararg{Any})

Fixes up the expanded ast so that jl_is_rest_arg, as called from
emit_function (step 2), works properly and avoids a later segfault.

Author: timholy

src/alloc.c

@@ -96,6 +96,7 @@ jl_sym_t *boundscheck_sym; jl_sym_t *copyast_sym;
 jl_sym_t *fastmath_sym;
 jl_sym_t *simdloop_sym; jl_sym_t *meta_sym;
 jl_sym_t *arrow_sym;  jl_sym_t *inert_sym;
+jl_sym_t *vararg_sym;
 
 typedef struct {
     int64_t a;

src/ast.c

@@ -750,7 +750,11 @@ int jl_is_rest_arg(jl_value_t *ex)
     if (((jl_expr_t*)ex)->head != colons_sym) return 0;
     jl_expr_t *atype = (jl_expr_t*)jl_exprarg(ex,1);
     if (!jl_is_expr(atype)) return 0;
-    return ((jl_expr_t*)atype)->head == dots_sym;
+    if (((jl_expr_t*)atype)->head == dots_sym)
+        return 1;
+    if (atype->head != call_sym || jl_array_len(atype->args) < 3 || jl_array_len(atype->args) > 4)
+         return 0;
+    return ((jl_sym_t*)jl_exprarg(atype,1)) == vararg_sym;
 }
 
 static jl_value_t *copy_ast(jl_value_t *expr, jl_svec_t *sp, int do_sp)

src/jltypes.c

@@ -3096,7 +3096,8 @@ void jl_init_types(void)
 
     jl_svec_t *tv;
     tv = jl_svec2(tvar("T"), tvar("N"));
-    jl_vararg_type = jl_new_abstracttype((jl_value_t*)jl_symbol("Vararg"), jl_any_type, tv);
+    vararg_sym = jl_symbol("Vararg");
+    jl_vararg_type = jl_new_abstracttype((jl_value_t*)vararg_sym, jl_any_type, tv);
 
     jl_anytuple_type = jl_new_datatype(jl_symbol("Tuple"), jl_any_type, jl_emptysvec,
                                        jl_emptysvec, jl_emptysvec, 0, 0, 0);

src/julia-syntax.scm

@@ -110,7 +110,9 @@
          (bad-formal-argument v))
         (else
          (case (car v)
-           ((...)         `(... ,(decl-type (cadr v))))
+           ((...) (if (eq? (length v) 3)
+                      `(... ,(decl-type (cadr v)) ,(caddr v))
+                      `(... ,(decl-type (cadr v)))))
            ((|::|)
             (if (not (symbol? (cadr v)))
                 (bad-formal-argument (cadr v)))
@@ -399,9 +401,13 @@
 ;; except for rest arg
 (define (method-lambda-expr argl body)
   (let ((argl (map (lambda (x)
-                     (if (and (pair? x) (eq? (car x) '...))
+                     (if (vararg? x)
                          (make-decl (arg-name x) (arg-type x))
-                         (arg-name x)))
+                         (if (varargexpr? x)
+                             (if (pair? (caddr x))
+                                 x
+                                 `(|::| ,(arg-name x) (curly Vararg Any)))
+                         (arg-name x))))
                    argl)))
     `(lambda ,argl
        (scope-block ,body))))
@@ -484,6 +490,15 @@
                     ,body ,isstaged))))))
 
 (define (vararg? x) (and (pair? x) (eq? (car x) '...)))
+(define (varargexpr? x) (and
+                         (pair? x)
+                         (eq? (car x) '::)
+                         (or
+                          (eq? (caddr x) 'Vararg)
+                          (and
+                           (pair? (caddr x))
+                           (length> (caddr x) 1)
+                           (eq? (cadr (caddr x)) 'Vararg)))))
 (define (trans?  x) (and (pair? x) (eq? (car x) '|.'|)))
 (define (ctrans? x) (and (pair? x) (eq? (car x) '|'|)))
 

src/julia.h

@@ -457,7 +457,7 @@ DLLEXPORT extern jl_value_t *jl_nothing;
 // some important symbols
 extern jl_sym_t *call_sym;
 extern jl_sym_t *call1_sym;
-extern jl_sym_t *dots_sym;
+extern jl_sym_t *dots_sym;    extern jl_sym_t *vararg_sym;
 extern jl_sym_t *quote_sym;   extern jl_sym_t *newvar_sym;
 extern jl_sym_t *top_sym;     extern jl_sym_t *dot_sym;
 extern jl_sym_t *line_sym;    extern jl_sym_t *toplevel_sym;

test/core.jl

@@ -518,6 +518,17 @@ begin
     @test firstlast(Val{false}) == "Last"
 end
 
+# x::Vararg{Any} declarations
+begin
+    local f1, f2, f3
+    f1(x...) = [x...]
+    f2(x::Vararg{Any}) = [x...]
+    f3(x::Vararg) = [x...]
+    @test f1(1,2,3) == [1,2,3]
+    @test f2(1,2,3) == [1,2,3]
+    @test f3(1,2,3) == [1,2,3]
+end
+
 # try/finally
 begin
     after = 0