improve rule for distinguishing tuples (arg lists) from parenthesized…

… blocks

a parenthesized expression is a tuple when at least one of these is true:

- it is empty
- there is a comma
- it begins with `x...` and isn't just `(x...)`
- it begins with `(;` (corresponding to the positional part being empty)

anything beginning with `(x;` will be considered a block; you need a
comma (`(x,;)`) to get tuple parsing.

add line numbers to blocks written as `(a; b; c)`

src/julia-parser.scm

@@ -687,6 +687,9 @@
  (parse-Nary s down '(#\newline #\;) 'block
  (lambda (x) (memq x '(end else elseif catch finally))) #t))
 
+(define (parse-parenthesized-block s)
+ (parse-Nary s parse-eq '(#\;) 'block (lambda (x) (eqv? x #\) )) #t))
+
 ;; ";" at the top level produces a sequence of top level expressions
 (define (parse-stmts s)
  (let ((ex (parse-Nary s (lambda (s) (parse-docstring s parse-eq))
@@ -1928,19 +1931,15 @@
 ;; leading-semi? means we saw (; ...)
 ;; comma? means there was a comma after the first expression
 (define (arglist-to-tuple leading-semi? comma? args . first)
- (if (and (pair? first) (null? args) (not leading-semi?) (not comma?))
- `(block ,@first) ;; this case is (x;)
- (or (and (not comma?) (length= args 1) (pair? (car args)) (eq? (caar args) 'parameters)
- (let ((blk (parameters-to-block (car args))))
- (and blk (or (and (not leading-semi?)
- `(block ,@first ,@blk))
- (and (null? first) (null? blk)
- `(block)))))) ;; all semicolons inside ()
- (and (null? first) (null? args) (not comma?)
- `(block)) ;; this case is (;)
- (if (and (pair? args) (pair? (car args)) (eq? (caar args) 'parameters))
- `(tuple ,(car args) ,@first ,@(map kw-to-= (cdr args)))
- `(tuple ,@first ,@(map kw-to-= args))))))
+ (or (and leading-semi? (not comma?) (length= args 1) (pair? (car args)) (eq? (caar args) 'parameters)
+ (let ((blk (parameters-to-block (car args))))
+ (and blk (null? first) (null? blk)
+ `(block)))) ;; all semicolons inside ()
+ (and (null? first) (null? args) (not comma?)
+ `(block)) ;; this case is (;)
+ (if (and (pair? args) (pair? (car args)) (eq? (caar args) 'parameters))
+ `(tuple ,(car args) ,@first ,@(map kw-to-= (cdr args)))
+ `(tuple ,@first ,@(map kw-to-= args)))))
 
 (define (tuple-to-arglist e)
  (cond ((eq? (car e) 'tuple) (map =-to-kw (cdr e)))
@@ -1986,8 +1985,8 @@
  (take-token s) ;; take #\)
  '(|::| . #f))
  ((eqv? nxt #\;)
- (cons (arglist-to-tuple #t #f (parse-arglist s #\) ))
-  #t))
+ (let ((ex (arglist-to-tuple #t #f (parse-arglist s #\) ))))
+ (cons ex (eq? (car ex) 'tuple))))
  (else
  ;; here we parse the first subexpression separately, so
  ;; we can look for a comma to see if it's a tuple.
@@ -1997,7 +1996,7 @@
  (cond ((eqv? t #\) )
  (take-token s)
  ;; value in parentheses (x)
- (if (and (pair? ex) (eq? (car ex) '...))
+ (if (vararg? ex)
  (let ((lineno (input-port-line (ts:port s))))
  (if (or accept-dots-without-comma (eq? (with-bindings ((whitespace-newline #f))
  (peek-token s))
@@ -2008,6 +2007,26 @@
  (string "(" (deparse (cadr ex)) "...,)"))
  (cons `(tuple ,ex) #t))))
  (cons ex #f)))
+ ((eqv? t #\,)
+ ;; tuple (x,) (x,y) (x...) etc.
+ (take-token s)
+ (cons (arglist-to-tuple #f #t (parse-arglist s #\) ) ex)
+ #t))
+ ((eqv? t #\;)
+ (if (vararg? ex)
+ ;; consider `(x...; ` the start of an arglist, since it's not useful as a block
+ (cons (arglist-to-tuple #f #f (parse-arglist s #\) ) ex)
+ #t)
+ (begin
+ (take-token s)
+ (let ((blk (parse-parenthesized-block s)))
+ (if (eqv? (require-token s) #\) )
+ (take-token s)
+ (error "expected \")\""))
+ (cons (if (and (length= blk 2) (pair? (cadr blk)) (eq? (caadr blk) 'line))
+ `(block ,ex)
+ (list* 'block ex (cdr blk)))
+ #f)))))
  ((eq? t 'for)
  (expect-space-before s 'for)
  (take-token s)
@@ -2017,13 +2036,7 @@
  (error "expected \")\""))
  (cons gen #f)))
  (else
- ;; tuple (x,) (x,y) (x...) etc.
- (if (eqv? t #\, )
- (take-token s)
- (if (not (eqv? t #\;))
- (error "missing comma or ) in argument list")))
- (cons (arglist-to-tuple #f (eqv? t #\,) (parse-arglist s #\) ) ex)
- #t)))))))))
+ (error "missing comma or ) in argument list")))))))))
 
 (define (not-eof-for delim c)
  (if (eof-object? c)

src/julia-syntax.scm

@@ -1103,7 +1103,7 @@
  (set! a (cadr w))))
  #f))
  (argl (if (pair? a)
- (tuple-to-arglist a)
+ (tuple-to-arglist (filter (lambda (x) (not (and (pair? x) (eq? (car x) 'line)))) a))
  (list a)))
  ;; TODO: always use a specific special name like #anon# or _, then ignore
  ;; this as a local variable name.

test/syntax.jl

@@ -176,13 +176,20 @@ macro test999_str(args...); args; end
 @test_throws ParseError Meta.parse("(,)")
 @test_throws ParseError Meta.parse("(;,)")
 @test_throws ParseError Meta.parse("(,;)")
+@test_throws ParseError Meta.parse("(1;2,)")
+@test_throws ParseError Meta.parse("(1;2,;)")
+@test_throws ParseError Meta.parse("(1;2,;3)")
 @test Meta.parse("(x;)") == Expr(:block, :x)
 @test Meta.parse("(;x)") == Expr(:tuple, Expr(:parameters, :x))
 @test Meta.parse("(;x,)") == Expr(:tuple, Expr(:parameters, :x))
 @test Meta.parse("(x,)") == Expr(:tuple, :x)
 @test Meta.parse("(x,;)") == Expr(:tuple, Expr(:parameters), :x)
-@test Meta.parse("(x;y)") == Expr(:block, :x, :y)
-@test Meta.parse("(x=1;y=2)") == Expr(:block, Expr(:(=), :x, 1), Expr(:(=), :y, 2))
+@test Meta.parse("(x;y)") == Expr(:block, :x, LineNumberNode(1,:none), :y)
+@test Meta.parse("(x...;)") == Expr(:tuple, Expr(:parameters), Expr(:(...), :x))
+@test Meta.parse("(;x...)") == Expr(:tuple, Expr(:parameters, Expr(:(...), :x)))
+@test Meta.parse("(x...;y)") == Expr(:tuple, Expr(:parameters, :y), Expr(:(...), :x))
+@test Meta.parse("(x;y...)") == Expr(:block, :x, LineNumberNode(1,:none), Expr(:(...), :y))
+@test Meta.parse("(x=1;y=2)") == Expr(:block, Expr(:(=), :x, 1), LineNumberNode(1,:none), Expr(:(=), :y, 2))
 @test Meta.parse("(x,;y)") == Expr(:tuple, Expr(:parameters, :y), :x)
 @test Meta.parse("(x,;y=1)") == Expr(:tuple, Expr(:parameters, Expr(:kw, :y, 1)), :x)
 @test Meta.parse("(x,a;y=1)") == Expr(:tuple, Expr(:parameters, Expr(:kw, :y, 1)), :x, :a)
@@ -1310,13 +1317,24 @@ end
 # f(x) = x", 1)[1] === "x"
 
 # issue #26137
-@test Meta.parse("-()^2") == Expr(:call, :^, Expr(:call, :-), 2)
-@test Meta.parse("-(x)^2") == Expr(:call, :-, Expr(:call, :^, :x, 2))
-@test Meta.parse("-(x,)^2") == Expr(:call, :^, Expr(:call, :-, :x), 2)
-@test Meta.parse("-(x,y)^2") == Expr(:call, :^, Expr(:call, :-, :x, :y), 2)
-@test Meta.parse("+((1,2))") == Expr(:call, :+, Expr(:tuple, 1, 2))
-@test Meta.parse("-(x;y)^2") == Expr(:call, :^, Expr(:call, :-, Expr(:parameters, :y), :x), 2)
-@test Meta.parse("-(x...)^2") == Expr(:call, :^, Expr(:call, :-, Expr(:(...), :x)), 2)
+# cases where parens enclose argument lists
+@test Meta.parse("-()^2") == Expr(:call, :^, Expr(:call, :-), 2)
+@test Meta.parse("-(x,)^2") == Expr(:call, :^, Expr(:call, :-, :x), 2)
+@test Meta.parse("-(x,;)^2") == Expr(:call, :^, Expr(:call, :-, Expr(:parameters), :x), 2)
+@test Meta.parse("-(;x)^2") == Expr(:call, :^, Expr(:call, :-, Expr(:parameters, :x)), 2)
+@test Meta.parse("-(x,y)^2") == Expr(:call, :^, Expr(:call, :-, :x, :y), 2)
+@test Meta.parse("-(x...)^2") == Expr(:call, :^, Expr(:call, :-, Expr(:(...), :x)), 2)
+@test Meta.parse("-(x...;)^2") == Expr(:call, :^, Expr(:call, :-, Expr(:parameters), Expr(:(...), :x)), 2)
+@test Meta.parse("-(x...;)") == Expr(:call, :-, Expr(:parameters), Expr(:(...), :x))
+
+# cases where parens are just grouping
+@test Meta.parse("-(x)^2") == Expr(:call, :-, Expr(:call, :^, :x, 2))
+@test Meta.parse("-(a=1)^2") == Expr(:call, :-, Expr(:call, :^, Expr(:(=), :a, 1), 2))
+@test Meta.parse("-(x;y)^2") == Expr(:call, :-, Expr(:call, :^, Expr(:block, :x, LineNumberNode(1,:none), :y), 2))
+@test Meta.parse("-(;)^2") == Expr(:call, :-, Expr(:call, :^, Expr(:block), 2))
+@test Meta.parse("-(;;;;)^2") == Expr(:call, :-, Expr(:call, :^, Expr(:block), 2))
+@test Meta.parse("-(x;;;)^2") == Expr(:call, :-, Expr(:call, :^, Expr(:block, :x), 2))
+@test Meta.parse("+((1,2))") == Expr(:call, :+, Expr(:tuple, 1, 2))
 
 @test_throws ParseError("space before \"(\" not allowed in \"+ (\"") Meta.parse("1 -+ (a=1, b=2)")