Remove support for expr-only yield!

Author: eholk

compiler/rustc_builtin_macros/src/iter.rs

@@ -1,8 +1,6 @@
 use rustc_ast::ptr::P;
 use rustc_ast::tokenstream::TokenStream;
-use rustc_ast::{
-    CaptureBy, ClosureBinder, Const, CoroutineKind, DUMMY_NODE_ID, Expr, ExprKind, ast, token,
-};
+use rustc_ast::{CoroutineKind, DUMMY_NODE_ID, Expr, ast, token};
 use rustc_errors::PResult;
 use rustc_expand::base::{self, DummyResult, ExpandResult, ExtCtxt, MacroExpanderResult};
 use rustc_span::Span;
@@ -27,52 +25,29 @@ fn parse_closure<'a>(
     span: Span,
     stream: TokenStream,
 ) -> PResult<'a, P<Expr>> {
-    let mut parser = cx.new_parser_from_tts(stream);
-    let mut closure_parser = parser.clone();
+    let mut closure_parser = cx.new_parser_from_tts(stream);
 
     let coroutine_kind = Some(CoroutineKind::Gen {
         span,
         closure_id: DUMMY_NODE_ID,
         return_impl_trait_id: DUMMY_NODE_ID,
     });
 
-    match closure_parser.parse_expr() {
-        Ok(mut closure) => {
-            if let ast::ExprKind::Closure(c) = &mut closure.kind {
-                if let Some(kind) = c.coroutine_kind {
-                    cx.dcx().span_err(kind.span(), "only plain closures allowed in `iter!`");
-                }
-                c.coroutine_kind = coroutine_kind;
-                if closure_parser.token != token::Eof {
-                    closure_parser.unexpected()?;
-                }
-                return Ok(closure);
+    let mut closure = closure_parser.parse_expr()?;
+    match &mut closure.kind {
+        ast::ExprKind::Closure(c) => {
+            if let Some(kind) = c.coroutine_kind {
+                cx.dcx().span_err(kind.span(), "only plain closures allowed in `iter!`");
             }
+            c.coroutine_kind = coroutine_kind;
+            if closure_parser.token != token::Eof {
+                closure_parser.unexpected()?;
+            }
+            Ok(closure)
+        }
+        _ => {
+            cx.dcx().span_err(closure.span, "`iter!` body must be a closure");
+            Err(closure_parser.unexpected().unwrap_err())
         }
-        Err(diag) => diag.cancel(),
-    }
-
-    let lo = parser.token.span.shrink_to_lo();
-    let block = parser.parse_block_tail(
-        lo,
-        ast::BlockCheckMode::Default,
-        rustc_parse::parser::AttemptLocalParseRecovery::No,
-    )?;
-    let fn_decl = cx.fn_decl(Default::default(), ast::FnRetTy::Default(span));
-    let closure = ast::Closure {
-        binder: ClosureBinder::NotPresent,
-        capture_clause: CaptureBy::Ref,
-        constness: Const::No,
-        coroutine_kind,
-        movability: ast::Movability::Movable,
-        fn_decl,
-        body: cx.expr_block(block),
-        fn_decl_span: span,
-        fn_arg_span: span,
-    };
-    if parser.token != token::Eof {
-        parser.unexpected()?;
     }
-    let span = lo.to(parser.token.span);
-    Ok(cx.expr(span, ExprKind::Closure(Box::new(closure))))
 }

tests/ui/iterators/generator.rs

@@ -5,12 +5,12 @@
 use std::iter::iter;
 
 fn main() {
-    let i = iter! {
+    let i = iter! { || {
         yield 0;
         for x in 5..10 {
             yield x * 2;
         }
-    };
+    } };
     let mut i = i();
     assert_eq!(i.next(), Some(0));
     assert_eq!(i.next(), Some(10));

tests/ui/iterators/generator_capture_fail.rs

@@ -5,12 +5,12 @@ use std::iter::iter;
 fn main() {
     let i = {
         let s = String::new();
-        iter! {
-            yield s.len(); //~ ERROR `s` does not live long enough
+        iter! { || { //~ ERROR `s` does not live long enough
+            yield s.len();
             for x in 5..10 {
                 yield x * 2;
             }
-        }
+        } }
     };
     let mut i = i();
     assert_eq!(i.next(), Some(0));

tests/ui/iterators/generator_capture_fail.stderr

@@ -1,15 +1,17 @@
 error[E0597]: `s` does not live long enough
-  --> $DIR/generator_capture_fail.rs:9:13
+  --> $DIR/generator_capture_fail.rs:8:17
    |
 LL |       let i = {
    |           - borrow later stored here
-...
-LL | /             yield s.len();
+LL |           let s = String::new();
+LL |           iter! { || {
+   |  _________________^
+LL | |             yield s.len();
 LL | |             for x in 5..10 {
 LL | |                 yield x * 2;
 LL | |             }
-   | |_____________^ borrowed value does not live long enough
-LL |           }
+LL | |         } }
+   | |_________^ borrowed value does not live long enough
 LL |       };
    |       - `s` dropped here while still borrowed
 

tests/ui/iterators/generator_returned_from_fn.rs

@@ -3,12 +3,12 @@
 use std::iter::iter;
 
 fn plain() -> impl Fn() -> impl Iterator<Item = u32> {
-    iter! {
+    iter! { || {
         yield 0;
         for x in 5..10 {
             yield x * 2;
         }
-    }
+    } }
 }
 
 fn arg() -> impl Fn(u32) -> impl Iterator<Item = u32> {