syntax: don't fake a block around closures' bodies during parsing.

eddyb · eddyb · commit 49772fbf5dc1 · 2016-11-10T01:44:45.000+02:00
diff --git a/src/librustc/lint/context.rs b/src/librustc/lint/context.rs
@@ -994,10 +994,10 @@ impl<'a> ast_visit::Visitor for EarlyContext<'a> {
     }
 
     fn visit_fn(&mut self, fk: ast_visit::FnKind, decl: &ast::FnDecl,
-                body: &ast::Block, span: Span, id: ast::NodeId) {
-        run_lints!(self, check_fn, early_passes, fk, decl, body, span, id);
-        ast_visit::walk_fn(self, fk, decl, body, span);
-        run_lints!(self, check_fn_post, early_passes, fk, decl, body, span, id);
+                span: Span, id: ast::NodeId) {
+        run_lints!(self, check_fn, early_passes, fk, decl, span, id);
+        ast_visit::walk_fn(self, fk, decl, span);
+        run_lints!(self, check_fn_post, early_passes, fk, decl, span, id);
     }
 
     fn visit_variant_data(&mut self,
diff --git a/src/librustc/lint/mod.rs b/src/librustc/lint/mod.rs
@@ -200,9 +200,9 @@ pub trait EarlyLintPass: LintPass {
     fn check_ty(&mut self, _: &EarlyContext, _: &ast::Ty) { }
     fn check_generics(&mut self, _: &EarlyContext, _: &ast::Generics) { }
     fn check_fn(&mut self, _: &EarlyContext,
-        _: ast_visit::FnKind, _: &ast::FnDecl, _: &ast::Block, _: Span, _: ast::NodeId) { }
+        _: ast_visit::FnKind, _: &ast::FnDecl, _: Span, _: ast::NodeId) { }
     fn check_fn_post(&mut self, _: &EarlyContext,
-        _: ast_visit::FnKind, _: &ast::FnDecl, _: &ast::Block, _: Span, _: ast::NodeId) { }
+        _: ast_visit::FnKind, _: &ast::FnDecl, _: Span, _: ast::NodeId) { }
     fn check_trait_item(&mut self, _: &EarlyContext, _: &ast::TraitItem) { }
     fn check_trait_item_post(&mut self, _: &EarlyContext, _: &ast::TraitItem) { }
     fn check_impl_item(&mut self, _: &EarlyContext, _: &ast::ImplItem) { }
diff --git a/src/librustc_passes/hir_stats.rs b/src/librustc_passes/hir_stats.rs
@@ -295,11 +295,10 @@ impl<'v> ast_visit::Visitor for StatCollector<'v> {
     fn visit_fn(&mut self,
                 fk: ast_visit::FnKind,
                 fd: &ast::FnDecl,
-                b: &ast::Block,
                 s: Span,
                 _: NodeId) {
         self.record("FnDecl", Id::None, fd);
-        ast_visit::walk_fn(self, fk, fd, b, s)
+        ast_visit::walk_fn(self, fk, fd, s)
     }
 
     fn visit_trait_item(&mut self, ti: &ast::TraitItem) {
diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs
@@ -596,21 +596,52 @@ impl<'a> Visitor for Resolver<'a> {
     fn visit_fn(&mut self,
                 function_kind: FnKind,
                 declaration: &FnDecl,
-                block: &Block,
                 _: Span,
                 node_id: NodeId) {
         let rib_kind = match function_kind {
             FnKind::ItemFn(_, generics, ..) => {
                 self.visit_generics(generics);
                 ItemRibKind
             }
-            FnKind::Method(_, sig, _) => {
+            FnKind::Method(_, sig, _, _) => {
                 self.visit_generics(&sig.generics);
                 MethodRibKind(!sig.decl.has_self())
             }
-            FnKind::Closure => ClosureRibKind(node_id),
+            FnKind::Closure(_) => ClosureRibKind(node_id),
         };
-        self.resolve_function(rib_kind, declaration, block);
+
+        // Create a value rib for the function.
+        self.value_ribs.push(Rib::new(rib_kind));
+
+        // Create a label rib for the function.
+        self.label_ribs.push(Rib::new(rib_kind));
+
+        // Add each argument to the rib.
+        let mut bindings_list = FxHashMap();
+        for argument in &declaration.inputs {
+            self.resolve_pattern(&argument.pat, PatternSource::FnParam, &mut bindings_list);
+
+            self.visit_ty(&argument.ty);
+
+            debug!("(resolving function) recorded argument");
+        }
+        visit::walk_fn_ret_ty(self, &declaration.output);
+
+        // Resolve the function body.
+        match function_kind {
+            FnKind::ItemFn(.., body) |
+            FnKind::Method(.., body) => {
+                self.visit_block(body);
+            }
+            FnKind::Closure(body) => {
+                self.visit_expr(body);
+            }
+        };
+
+        debug!("(resolving function) leaving function");
+
+        self.label_ribs.pop();
+        self.value_ribs.pop();
     }
 }
 
@@ -1856,36 +1887,6 @@ impl<'a> Resolver<'a> {
         self.value_ribs.pop();
     }
 
-    fn resolve_function(&mut self,
-                        rib_kind: RibKind<'a>,
-                        declaration: &FnDecl,
-                        block: &Block) {
-        // Create a value rib for the function.
-        self.value_ribs.push(Rib::new(rib_kind));
-
-        // Create a label rib for the function.
-        self.label_ribs.push(Rib::new(rib_kind));
-
-        // Add each argument to the rib.
-        let mut bindings_list = FxHashMap();
-        for argument in &declaration.inputs {
-            self.resolve_pattern(&argument.pat, PatternSource::FnParam, &mut bindings_list);
-
-            self.visit_ty(&argument.ty);
-
-            debug!("(resolving function) recorded argument");
-        }
-        visit::walk_fn_ret_ty(self, &declaration.output);
-
-        // Resolve the function body.
-        self.visit_block(block);
-
-        debug!("(resolving function) leaving function");
-
-        self.label_ribs.pop();
-        self.value_ribs.pop();
-    }
-
     fn resolve_trait_reference(&mut self,
                                id: NodeId,
                                trait_path: &Path,
diff --git a/src/librustc_save_analysis/dump_visitor.rs b/src/librustc_save_analysis/dump_visitor.rs
@@ -1414,7 +1414,7 @@ impl<'l, 'tcx: 'l, 'll, D: Dump +'ll> Visitor for DumpVisitor<'l, 'tcx, 'll, D>
                 }
 
                 // walk the body
-                self.nest(ex.id, |v| v.visit_block(&body));
+                self.nest(ex.id, |v| v.visit_expr(body));
             }
             ast::ExprKind::ForLoop(ref pattern, ref subexpression, ref block, _) |
             ast::ExprKind::WhileLet(ref pattern, ref subexpression, ref block, _) => {
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
@@ -1017,10 +1017,10 @@ pub enum ExprKind {
     Loop(P<Block>, Option<SpannedIdent>),
     /// A `match` block.
     Match(P<Expr>, Vec<Arm>),
-    /// A closure (for example, `move |a, b, c| {a + b + c}`)
+    /// A closure (for example, `move |a, b, c| a + b + c`)
     ///
     /// The final span is the span of the argument block `|...|`
-    Closure(CaptureBy, P<FnDecl>, P<Block>, Span),
+    Closure(CaptureBy, P<FnDecl>, P<Expr>, Span),
     /// A block (`{ ... }`)
     Block(P<Block>),
 
diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
@@ -198,17 +198,13 @@ pub trait AstBuilder {
     fn lambda_fn_decl(&self,
                       span: Span,
                       fn_decl: P<ast::FnDecl>,
-                      blk: P<ast::Block>,
+                      body: P<ast::Expr>,
                       fn_decl_span: Span)
                       -> P<ast::Expr>;
 
-    fn lambda(&self, span: Span, ids: Vec<ast::Ident>, blk: P<ast::Block>) -> P<ast::Expr>;
-    fn lambda0(&self, span: Span, blk: P<ast::Block>) -> P<ast::Expr>;
-    fn lambda1(&self, span: Span, blk: P<ast::Block>, ident: ast::Ident) -> P<ast::Expr>;
-
-    fn lambda_expr(&self, span: Span, ids: Vec<ast::Ident> , blk: P<ast::Expr>) -> P<ast::Expr>;
-    fn lambda_expr_0(&self, span: Span, expr: P<ast::Expr>) -> P<ast::Expr>;
-    fn lambda_expr_1(&self, span: Span, expr: P<ast::Expr>, ident: ast::Ident) -> P<ast::Expr>;
+    fn lambda(&self, span: Span, ids: Vec<ast::Ident>, body: P<ast::Expr>) -> P<ast::Expr>;
+    fn lambda0(&self, span: Span, body: P<ast::Expr>) -> P<ast::Expr>;
+    fn lambda1(&self, span: Span, body: P<ast::Expr>, ident: ast::Ident) -> P<ast::Expr>;
 
     fn lambda_stmts(&self, span: Span, ids: Vec<ast::Ident>,
                     blk: Vec<ast::Stmt>) -> P<ast::Expr>;
@@ -940,19 +936,19 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
     fn lambda_fn_decl(&self,
                       span: Span,
                       fn_decl: P<ast::FnDecl>,
-                      blk: P<ast::Block>,
+                      body: P<ast::Expr>,
                       fn_decl_span: Span) // span of the `|...|` part
                       -> P<ast::Expr> {
         self.expr(span, ast::ExprKind::Closure(ast::CaptureBy::Ref,
                                                fn_decl,
-                                               blk,
+                                               body,
                                                fn_decl_span))
     }
 
     fn lambda(&self,
               span: Span,
               ids: Vec<ast::Ident>,
-              blk: P<ast::Block>)
+              body: P<ast::Expr>)
               -> P<ast::Expr> {
         let fn_decl = self.fn_decl(
             ids.iter().map(|id| self.arg(span, *id, self.ty_infer(span))).collect(),
@@ -962,41 +958,30 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
         // part of the lambda, but it probably (maybe?) corresponds to
         // the entire lambda body. Probably we should extend the API
         // here, but that's not entirely clear.
-        self.expr(span, ast::ExprKind::Closure(ast::CaptureBy::Ref, fn_decl, blk, span))
-    }
-
-    fn lambda0(&self, span: Span, blk: P<ast::Block>) -> P<ast::Expr> {
-        self.lambda(span, Vec::new(), blk)
+        self.expr(span, ast::ExprKind::Closure(ast::CaptureBy::Ref, fn_decl, body, span))
     }
 
-    fn lambda1(&self, span: Span, blk: P<ast::Block>, ident: ast::Ident) -> P<ast::Expr> {
-        self.lambda(span, vec![ident], blk)
+    fn lambda0(&self, span: Span, body: P<ast::Expr>) -> P<ast::Expr> {
+        self.lambda(span, Vec::new(), body)
     }
 
-    fn lambda_expr(&self, span: Span, ids: Vec<ast::Ident>,
-                   expr: P<ast::Expr>) -> P<ast::Expr> {
-        self.lambda(span, ids, self.block_expr(expr))
-    }
-    fn lambda_expr_0(&self, span: Span, expr: P<ast::Expr>) -> P<ast::Expr> {
-        self.lambda0(span, self.block_expr(expr))
-    }
-    fn lambda_expr_1(&self, span: Span, expr: P<ast::Expr>, ident: ast::Ident) -> P<ast::Expr> {
-        self.lambda1(span, self.block_expr(expr), ident)
+    fn lambda1(&self, span: Span, body: P<ast::Expr>, ident: ast::Ident) -> P<ast::Expr> {
+        self.lambda(span, vec![ident], body)
     }
 
     fn lambda_stmts(&self,
                     span: Span,
                     ids: Vec<ast::Ident>,
                     stmts: Vec<ast::Stmt>)
                     -> P<ast::Expr> {
-        self.lambda(span, ids, self.block(span, stmts))
+        self.lambda(span, ids, self.expr_block(self.block(span, stmts)))
     }
     fn lambda_stmts_0(&self, span: Span, stmts: Vec<ast::Stmt>) -> P<ast::Expr> {
-        self.lambda0(span, self.block(span, stmts))
+        self.lambda0(span, self.expr_block(self.block(span, stmts)))
     }
     fn lambda_stmts_1(&self, span: Span, stmts: Vec<ast::Stmt>,
                       ident: ast::Ident) -> P<ast::Expr> {
-        self.lambda1(span, self.block(span, stmts), ident)
+        self.lambda1(span, self.expr_block(self.block(span, stmts)), ident)
     }
 
     fn arg(&self, span: Span, ident: ast::Ident, ty: P<ast::Ty>) -> ast::Arg {
diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs
@@ -1228,12 +1228,11 @@ impl<'a> Visitor for PostExpansionVisitor<'a> {
     fn visit_fn(&mut self,
                 fn_kind: FnKind,
                 fn_decl: &ast::FnDecl,
-                block: &ast::Block,
                 span: Span,
                 _node_id: NodeId) {
         // check for const fn declarations
         match fn_kind {
-            FnKind::ItemFn(_, _, _, Spanned { node: ast::Constness::Const, .. }, _, _) => {
+            FnKind::ItemFn(_, _, _, Spanned { node: ast::Constness::Const, .. }, _, _, _) => {
                 gate_feature_post!(&self, const_fn, span, "const fn is unstable");
             }
             _ => {
@@ -1245,13 +1244,13 @@ impl<'a> Visitor for PostExpansionVisitor<'a> {
         }
 
         match fn_kind {
-            FnKind::ItemFn(_, _, _, _, abi, _) |
-            FnKind::Method(_, &ast::MethodSig { abi, .. }, _) => {
+            FnKind::ItemFn(_, _, _, _, abi, _, _) |
+            FnKind::Method(_, &ast::MethodSig { abi, .. }, _, _) => {
                 self.check_abi(abi, span);
             }
             _ => {}
         }
-        visit::walk_fn(self, fn_kind, fn_decl, block, span);
+        visit::walk_fn(self, fn_kind, fn_decl, span);
     }
 
     fn visit_trait_item(&mut self, ti: &ast::TraitItem) {
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
@@ -1201,7 +1201,7 @@ pub fn noop_fold_expr<T: Folder>(Expr {id, node, span, attrs}: Expr, folder: &mu
             ExprKind::Closure(capture_clause, decl, body, span) => {
                 ExprKind::Closure(capture_clause,
                                   folder.fold_fn_decl(decl),
-                                  folder.fold_block(body),
+                                  folder.fold_expr(body),
                                   folder.new_span(span))
             }
             ExprKind::Block(blk) => ExprKind::Block(folder.fold_block(blk)),
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
@@ -3162,25 +3162,12 @@ impl<'a> Parser<'a> {
         let decl = self.parse_fn_block_decl()?;
         let decl_hi = self.prev_span.hi;
         let body = match decl.output {
-            FunctionRetTy::Default(_) => {
-                // If no explicit return type is given, parse any
-                // expr and wrap it up in a dummy block:
-                let body_expr = self.parse_expr()?;
-                P(ast::Block {
-                    id: ast::DUMMY_NODE_ID,
-                    span: body_expr.span,
-                    stmts: vec![Stmt {
-                        span: body_expr.span,
-                        node: StmtKind::Expr(body_expr),
-                        id: ast::DUMMY_NODE_ID,
-                    }],
-                    rules: BlockCheckMode::Default,
-                })
-            }
+            FunctionRetTy::Default(_) => self.parse_expr()?,
             _ => {
                 // If an explicit return type is given, require a
                 // block to appear (RFC 968).
-                self.parse_block()?
+                let body_lo = self.span.lo;
+                self.parse_block_expr(body_lo, BlockCheckMode::Default, ThinVec::new())?
             }
         };
 
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
@@ -2128,26 +2128,8 @@ impl<'a> State<'a> {
 
                 try!(self.print_fn_block_args(&decl));
                 try!(space(&mut self.s));
-
-                let default_return = match decl.output {
-                    ast::FunctionRetTy::Default(..) => true,
-                    _ => false
-                };
-
-                match body.stmts.last().map(|stmt| &stmt.node) {
-                    Some(&ast::StmtKind::Expr(ref i_expr)) if default_return &&
-                                                              body.stmts.len() == 1 => {
-                        // we extract the block, so as not to create another set of boxes
-                        if let ast::ExprKind::Block(ref blk) = i_expr.node {
-                            try!(self.print_block_unclosed_with_attrs(&blk, &i_expr.attrs));
-                        } else {
-                            // this is a bare expression
-                            try!(self.print_expr(&i_expr));
-                            try!(self.end()); // need to close a box
-                        }
-                    }
-                    _ => try!(self.print_block_unclosed(&body)),
-                }
+                try!(self.print_expr(body));
+                try!(self.end()); // need to close a box
 
                 // a box will be closed by print_expr, but we didn't want an overall
                 // wrapper so we closed the corresponding opening. so create an
diff --git a/src/libsyntax/util/node_count.rs b/src/libsyntax/util/node_count.rs
@@ -75,9 +75,9 @@ impl Visitor for NodeCounter {
         self.count += 1;
         walk_generics(self, g)
     }
-    fn visit_fn(&mut self, fk: FnKind, fd: &FnDecl, b: &Block, s: Span, _: NodeId) {
+    fn visit_fn(&mut self, fk: FnKind, fd: &FnDecl, s: Span, _: NodeId) {
         self.count += 1;
-        walk_fn(self, fk, fd, b, s)
+        walk_fn(self, fk, fd, s)
     }
     fn visit_trait_item(&mut self, ti: &TraitItem) {
         self.count += 1;
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
diff --git a/src/libsyntax_ext/deriving/decodable.rs b/src/libsyntax_ext/deriving/decodable.rs
diff --git a/src/libsyntax_ext/deriving/encodable.rs b/src/libsyntax_ext/deriving/encodable.rs
diff --git a/src/test/parse-fail/closure-return-syntax.rs b/src/test/parse-fail/closure-return-syntax.rs

Original file line number	Diff line number	Diff line change
`@@ -994,10 +994,10 @@ impl<'a> ast_visit::Visitor for EarlyContext<'a> {`
`994`	`994`	`}`
`995`	`995`
`996`	`996`	`fn visit_fn(&mut self, fk: ast_visit::FnKind, decl: &ast::FnDecl,`
`997`		`- body: &ast::Block, span: Span, id: ast::NodeId) {`
`998`		`- run_lints!(self, check_fn, early_passes, fk, decl, body, span, id);`
`999`		`- ast_visit::walk_fn(self, fk, decl, body, span);`
`1000`		`- run_lints!(self, check_fn_post, early_passes, fk, decl, body, span, id);`
	`997`	`+ span: Span, id: ast::NodeId) {`
	`998`	`+ run_lints!(self, check_fn, early_passes, fk, decl, span, id);`
	`999`	`+ ast_visit::walk_fn(self, fk, decl, span);`
	`1000`	`+ run_lints!(self, check_fn_post, early_passes, fk, decl, span, id);`
`1001`	`1001`	`}`
`1002`	`1002`
`1003`	`1003`	`fn visit_variant_data(&mut self,`
Original file line number	Diff line number	Diff line change
`@@ -1414,7 +1414,7 @@ impl<'l, 'tcx: 'l, 'll, D: Dump +'ll> Visitor for DumpVisitor<'l, 'tcx, 'll, D>`
`1414`	`1414`	`}`
`1415`	`1415`
`1416`	`1416`	`// walk the body`
`1417`		`- self.nest(ex.id, \|v\| v.visit_block(&body));`
	`1417`	`+ self.nest(ex.id, \|v\| v.visit_expr(body));`
`1418`	`1418`	`}`
`1419`	`1419`	`ast::ExprKind::ForLoop(ref pattern, ref subexpression, ref block, _) \|`
`1420`	`1420`	`ast::ExprKind::WhileLet(ref pattern, ref subexpression, ref block, _) => {`
Original file line number	Diff line number	Diff line change
`@@ -1228,12 +1228,11 @@ impl<'a> Visitor for PostExpansionVisitor<'a> {`
`1228`	`1228`	`fn visit_fn(&mut self,`
`1229`	`1229`	`fn_kind: FnKind,`
`1230`	`1230`	`fn_decl: &ast::FnDecl,`
`1231`		`- block: &ast::Block,`
`1232`	`1231`	`span: Span,`
`1233`	`1232`	`_node_id: NodeId) {`
`1234`	`1233`	`// check for const fn declarations`
`1235`	`1234`	`match fn_kind {`
`1236`		`- FnKind::ItemFn(_, _, _, Spanned { node: ast::Constness::Const, .. }, _, _) => {`
	`1235`	`+ FnKind::ItemFn(_, _, _, Spanned { node: ast::Constness::Const, .. }, _, _, _) => {`
`1237`	`1236`	`gate_feature_post!(&self, const_fn, span, "const fn is unstable");`
`1238`	`1237`	`}`
`1239`	`1238`	`_ => {`
`@@ -1245,13 +1244,13 @@ impl<'a> Visitor for PostExpansionVisitor<'a> {`
`1245`	`1244`	`}`
`1246`	`1245`
`1247`	`1246`	`match fn_kind {`
`1248`		`- FnKind::ItemFn(_, _, _, _, abi, _) \|`
`1249`		`- FnKind::Method(_, &ast::MethodSig { abi, .. }, _) => {`
	`1247`	`+ FnKind::ItemFn(_, _, _, _, abi, _, _) \|`
	`1248`	`+ FnKind::Method(_, &ast::MethodSig { abi, .. }, _, _) => {`
`1250`	`1249`	`self.check_abi(abi, span);`
`1251`	`1250`	`}`
`1252`	`1251`	`_ => {}`
`1253`	`1252`	`}`
`1254`		`- visit::walk_fn(self, fn_kind, fn_decl, block, span);`
	`1253`	`+ visit::walk_fn(self, fn_kind, fn_decl, span);`
`1255`	`1254`	`}`
`1256`	`1255`
`1257`	`1256`	`fn visit_trait_item(&mut self, ti: &ast::TraitItem) {`
Original file line number	Diff line number	Diff line change
`@@ -1201,7 +1201,7 @@ pub fn noop_fold_expr<T: Folder>(Expr {id, node, span, attrs}: Expr, folder: &mu`
`1201`	`1201`	`ExprKind::Closure(capture_clause, decl, body, span) => {`
`1202`	`1202`	`ExprKind::Closure(capture_clause,`
`1203`	`1203`	`folder.fold_fn_decl(decl),`
`1204`		`- folder.fold_block(body),`
	`1204`	`+ folder.fold_expr(body),`
`1205`	`1205`	`folder.new_span(span))`
`1206`	`1206`	`}`
`1207`	`1207`	`ExprKind::Block(blk) => ExprKind::Block(folder.fold_block(blk)),`
Original file line number	Diff line number	Diff line change
`@@ -75,9 +75,9 @@ impl Visitor for NodeCounter {`
`75`	`75`	`self.count += 1;`
`76`	`76`	`walk_generics(self, g)`
`77`	`77`	`}`
`78`		`- fn visit_fn(&mut self, fk: FnKind, fd: &FnDecl, b: &Block, s: Span, _: NodeId) {`
	`78`	`+ fn visit_fn(&mut self, fk: FnKind, fd: &FnDecl, s: Span, _: NodeId) {`
`79`	`79`	`self.count += 1;`
`80`		`- walk_fn(self, fk, fd, b, s)`
	`80`	`+ walk_fn(self, fk, fd, s)`
`81`	`81`	`}`
`82`	`82`	`fn visit_trait_item(&mut self, ti: &TraitItem) {`
`83`	`83`	`self.count += 1;`