Merge pull request #23553 from JuliaLang/jb/parselet

parse `let` the same as `for`. part of #21774

NEWS.md

@@ -42,6 +42,10 @@ Language changes
   * Nested `if` expressions that arise from the keyword `elseif` now use `elseif`
     as their expression head instead of `if` ([#21774]).
 
+  * `let` blocks now parse the same as `for` loops; the first argument is either an
+    assignment or `block` of assignments, and the second argument is a block of
+    statements ([#21774]).
+
   * Parsed and lowered forms of type definitions have been synchronized with their
     new keywords ([#23157]). Expression heads are renamed as follows:
 

base/broadcast.jl

@@ -564,8 +564,8 @@ function __dot__(x::Expr)
         Expr(:., dotargs[1], Expr(:tuple, dotargs[2:end]...))
     elseif x.head == :$
         x.args[1]
-    elseif x.head == :let # don't add dots to "let x=... assignments
-        Expr(:let, dotargs[1], map(undot, dotargs[2:end])...)
+    elseif x.head == :let # don't add dots to `let x=...` assignments
+        Expr(:let, undot(dotargs[1]), dotargs[2])
     elseif x.head == :for # don't add dots to for x=... assignments
         Expr(:for, undot(dotargs[1]), dotargs[2])
     elseif (x.head == :(=) || x.head == :function || x.head == :macro) &&

base/distributed/macros.jl

@@ -123,7 +123,7 @@ function extract_imports!(imports, ex::Expr)
     if Meta.isexpr(ex, (:import, :using))
         return push!(imports, ex.args[1])
     elseif Meta.isexpr(ex, :let)
-        return extract_imports!(imports, ex.args[1])
+        return extract_imports!(imports, ex.args[2])
     elseif Meta.isexpr(ex, (:toplevel, :block))
         for i in eachindex(ex.args)
             extract_imports!(imports, ex.args[i])

base/printf.jl

@@ -1188,7 +1188,7 @@ function _printf(macroname, io, fmt, args)
     end
 
     unshift!(blk.args, :(out = $io))
-    Expr(:let, blk)
+    Expr(:let, Expr(:block), blk)
 end
 
 """
@@ -1241,7 +1241,7 @@ macro sprintf(args...)
     isa(args[1], AbstractString) || is_str_expr(args[1]) ||
         throw(ArgumentError("@sprintf: first argument must be a format string"))
     letexpr = _printf("@sprintf", :(IOBuffer()), args[1], args[2:end])
-    push!(letexpr.args[1].args, :(String(take!(out))))
+    push!(letexpr.args[2].args, :(String(take!(out))))
     letexpr
 end
 

base/show.jl

@@ -959,7 +959,7 @@ function show_unquoted(io::IO, ex::Expr, indent::Int, prec::Int)
         print(io, "function ", args[1], " end")
 
     # block with argument
-    elseif head in (:for,:while,:function,:if,:elseif) && nargs==2
+    elseif head in (:for,:while,:function,:if,:elseif,:let) && nargs==2
         show_block(io, head, args[1], args[2], indent)
         print(io, "end")
 
@@ -1043,9 +1043,6 @@ function show_unquoted(io::IO, ex::Expr, indent::Int, prec::Int)
         end
         print(io, "end")
 
-    elseif head === :let && nargs >= 1
-        show_block(io, "let", args[2:end], args[1], indent); print(io, "end")
-
     elseif head === :block || head === :body
         show_block(io, "begin", ex, indent); print(io, "end")
 

base/subarray.jl

@@ -422,7 +422,7 @@ function replace_ref_end_!(ex, withex)
             if used_S && S !== ex.args[1]
                 S0 = ex.args[1]
                 ex.args[1] = S
-                ex = Expr(:let, ex, :($S = $S0))
+                ex = Expr(:let, :($S = $S0), ex)
             end
         else
             # recursive search
@@ -471,8 +471,8 @@ macro view(ex)
         if Meta.isexpr(ex, :ref)
             ex = Expr(:call, view, ex.args...)
         else # ex replaced by let ...; foo[...]; end
-            assert(Meta.isexpr(ex, :let) && Meta.isexpr(ex.args[1], :ref))
-            ex.args[1] = Expr(:call, view, ex.args[1].args...)
+            assert(Meta.isexpr(ex, :let) && Meta.isexpr(ex.args[2], :ref))
+            ex.args[2] = Expr(:call, view, ex.args[2].args...)
         end
         Expr(:&&, true, esc(ex))
     else
@@ -532,12 +532,13 @@ function _views(ex::Expr)
             end
 
             Expr(:let,
+                 Expr(:block,
+                      :($a = $(_views(lhs.args[1]))),
+                      [:($(i[k]) = $(_views(lhs.args[k+1]))) for k=1:length(i)]...),
                  Expr(first(h) == '.' ? :(.=) : :(=), :($a[$(I...)]),
                       Expr(:call, Symbol(h[1:end-1]),
                            :($maybeview($a, $(I...))),
-                           _views.(ex.args[2:end])...)),
-                 :($a = $(_views(lhs.args[1]))),
-                 [:($(i[k]) = $(_views(lhs.args[k+1]))) for k=1:length(i)]...)
+                           _views.(ex.args[2:end])...)))
         else
             Expr(ex.head, _views.(ex.args)...)
         end

doc/src/devdocs/ast.md

@@ -486,7 +486,8 @@ they are parsed as a block: `(for (block (= v1 iter1) (= v2 iter2)) body)`.
 
 `break` and `continue` are parsed as 0-argument expressions `(break)` and `(continue)`.
 
-`let` is parsed as `(let body (= var1 val1) (= var2 val2) ...)`.
+`let` is parsed as `(let (= var val) body)` or `(let (block (= var1 val1) (= var2 val2) ...) body)`,
+like `for` loops.
 
 A basic function definition is parsed as `(function (call f x) body)`. A more complex example:
 

src/julia-parser.scm

@@ -1303,6 +1303,21 @@
           `(for ,(if (length= ranges 1) (car ranges) (cons 'block ranges))
                 ,body)))
 
+       ((let)
+        (let ((binds (if (memv (peek-token s) '(#\newline #\;))
+                         '()
+                         (parse-comma-separated-assignments s))))
+          (if (not (or (eof-object? (peek-token s))
+                       (memv (peek-token s) '(#\newline #\; end))))
+              (error "let variables should end in \";\" or newline"))
+          (let* ((ex (begin0 (parse-block s)
+                             (expect-end s word)))
+                 (ex (if (and (length= ex 2) (pair? (cadr ex)) (eq? (caadr ex) 'line))
+                         `(block)  ;; don't need line info in an empty let block
+                         ex)))
+            `(let ,(if (length= binds 1) (car binds) (cons 'block binds))
+               ,ex))))
+
        ((if elseif)
         (if (newline? (peek-token s))
             (error (string "missing condition in \"if\" at " current-filename
@@ -1331,19 +1346,6 @@
              (begin0 (list word test then (parse-block s))
                      (expect-end s 'if)))
             (else      (error (string "unexpected \"" nxt "\""))))))
-       ((let)
-        (let ((binds (if (memv (peek-token s) '(#\newline #\;))
-                         '()
-                         (parse-comma-separated-assignments s))))
-          (if (not (or (eof-object? (peek-token s))
-                       (memv (peek-token s) '(#\newline #\; end))))
-              (error "let variables should end in \";\" or newline"))
-          (let ((ex (parse-block s)))
-            (expect-end s word)
-            ;; don't need line info in an empty let block
-            (if (and (length= ex 2) (pair? (cadr ex)) (eq? (caadr ex) 'line))
-                `(let (block) ,@binds)
-                `(let ,ex ,@binds)))))
 
        ((global local)
         (let* ((const (and (eq? (peek-token s) 'const)

src/julia-syntax.scm

@@ -359,9 +359,9 @@
 (define (scopenest names vals expr)
   (if (null? names)
       expr
-      `(let (block
-             ,(scopenest (cdr names) (cdr vals) expr))
-         (= ,(car names) ,(car vals)))))
+      `(let (= ,(car names) ,(car vals))
+         (block
+          ,(scopenest (cdr names) (cdr vals) expr)))))
 
 (define empty-vector-any '(call (core AnyVector) 0))
 
@@ -1120,9 +1120,23 @@
                    `(call ,name ,@argl))
               ,body)))))
 
+(define (let-binds e)
+  (if (and (pair? (cadr e))
+           (eq? (car (cadr e)) 'block))
+      (cdr (cadr e))
+      (list (cadr e))))
+
 (define (expand-let e)
-  (let ((ex (cadr e))
-        (binds (cddr e)))
+  (if (length= e 2)
+      (begin (deprecation-message (string "The form `Expr(:let, ex)` is deprecated. "
+                                          "Use `Expr(:let, Expr(:block), ex)` instead." #\newline))
+             (return (expand-let `(let (block) ,(cadr e))))))
+  (if (length> e 3)
+      (begin (deprecation-message (string "The form `Expr(:let, ex, binds...)` is deprecated. "
+                                          "Use `Expr(:let, Expr(:block, binds...), ex)` instead." #\newline))
+             (return (expand-let `(let (block ,@(cddr e)) ,(cadr e))))))
+  (let ((ex    (caddr e))
+        (binds (let-binds e)))
     (expand-forms
      (if
       (null? binds)
@@ -1803,7 +1817,7 @@
                                                  `(fuse _ ,(cdadr (cadr arg)))
                                                  oldarg))
                                  fargs args)))
-        (let ,fbody ,@(reverse (fuse-lets fargs args '()))))))
+        (let (block ,@(reverse (fuse-lets fargs args '()))) ,fbody))))
   (define (dot-to-fuse e) ; convert e == (. f (tuple args)) to (fuse f args)
     (define (make-fuse f args) ; check for nested (fuse f args) exprs and combine
       (define (split-kwargs args) ; return (cons keyword-args positional-args) extracted from args
@@ -1891,8 +1905,8 @@
 (define (expand-where body var)
   (let* ((bounds (analyze-typevar var))
          (v  (car bounds)))
-    `(let (call (core UnionAll) ,v ,body)
-       (= ,v ,(bounds-to-TypeVar bounds)))))
+    `(let (= ,v ,(bounds-to-TypeVar bounds))
+       (call (core UnionAll) ,v ,body))))
 
 (define (expand-wheres body vars)
   (if (null? vars)

src/macroexpand.scm

@@ -92,8 +92,8 @@
                    (cons 'varlist (typevar-names vars)))
 
    ;; let
-   (pattern-lambda (let ex . binds)
-                   (let loop ((binds binds)
+   (pattern-lambda (let binds ex)
+                   (let loop ((binds (let-binds __))
                               (vars  '()))
                      (if (null? binds)
                          (cons 'varlist vars)
@@ -360,19 +360,21 @@
 
            ((let)
             (let* ((newenv (new-expansion-env-for e env))
-                   (body   (resolve-expansion-vars- (cadr e) newenv m parent-scope inarg)))
-              `(let ,body
-                 ,@(map
-                    (lambda (bind)
-                      (if (assignment? bind)
-                          (make-assignment
-                           ;; expand binds in old env with dummy RHS
-                           (cadr (resolve-expansion-vars- (make-assignment (cadr bind) 0)
-                                                          newenv m parent-scope inarg))
-                           ;; expand initial values in old env
-                           (resolve-expansion-vars- (caddr bind) env m parent-scope inarg))
-                          bind))
-                    (cddr e)))))
+                   (body   (resolve-expansion-vars- (caddr e) newenv m parent-scope inarg))
+                   (binds  (let-binds e)))
+              `(let (block
+                     ,@(map
+                        (lambda (bind)
+                          (if (assignment? bind)
+                              (make-assignment
+                               ;; expand binds in old env with dummy RHS
+                               (cadr (resolve-expansion-vars- (make-assignment (cadr bind) 0)
+                                                              newenv m parent-scope inarg))
+                               ;; expand initial values in old env
+                               (resolve-expansion-vars- (caddr bind) env m parent-scope inarg))
+                              bind))
+                        binds))
+                 ,body)))
            ((hygienic-scope) ; TODO: move this lowering to resolve-scopes, instead of reimplementing it here badly
              (let ((parent-scope (cons (list env m) parent-scope))
                    (body (cadr e))

test/parse.jl

@@ -514,7 +514,7 @@ let b = IOBuffer("""
                  end
                  f()
                  """)
-    @test Base.parse_input_line(b) == Expr(:let, Expr(:block, LineNumberNode(2, :none), :x), Expr(:(=), :x, :x))
+    @test Base.parse_input_line(b) == Expr(:let, Expr(:(=), :x, :x), Expr(:block, LineNumberNode(2, :none), :x))
     @test Base.parse_input_line(b) == Expr(:call, :f)
     @test Base.parse_input_line(b) === nothing
 end