wip

Centril · Centril · commit ccc47fdb1958 · 2020-02-26T23:08:34.000+01:00
diff --git a/src/librustc_expand/expand.rs b/src/librustc_expand/expand.rs
@@ -892,7 +892,7 @@ pub fn parse_ast_fragment<'a>(
             let mut stmts = SmallVec::new();
             // Won't make progress on a `}`.
             while this.token != token::Eof && this.token != token::CloseDelim(token::Brace) {
-                if let Some(stmt) = this.parse_full_stmt()? {
+                if let Some(stmt) = this.parse_full_stmt(false)? {
                     stmts.push(stmt);
                 }
             }
diff --git a/src/librustc_parse/parser/module.rs b/src/librustc_parse/parser/module.rs
@@ -4,12 +4,15 @@ use super::Parser;
 
 use crate::{new_sub_parser_from_file, DirectoryOwnership};
 
-use rustc_errors::PResult;
-use rustc_span::source_map::{FileName, SourceMap, Span, DUMMY_SP};
+use rustc_ast_pretty::pprust;
+use rustc_errors::{Applicability, PResult};
+use rustc_span::source_map::{respan, FileName, MultiSpan, SourceMap, Span, DUMMY_SP};
 use rustc_span::symbol::sym;
 use syntax::ast::{self, Attribute, Crate, Ident, ItemKind, Mod};
 use syntax::attr;
+use syntax::ptr::P;
 use syntax::token::{self, TokenKind};
+use syntax::visit::Visitor;
 
 use std::path::{self, Path, PathBuf};
 
@@ -75,9 +78,12 @@ impl<'a> Parser<'a> {
     /// Given a termination token, parses all of the items in a module.
     fn parse_mod_items(&mut self, term: &TokenKind, inner_lo: Span) -> PResult<'a, Mod> {
         let mut items = vec![];
-        while let Some(item) = self.parse_item()? {
-            items.push(item);
-            self.maybe_consume_incorrect_semicolon(&items);
+        let mut stuck = false;
+        while let Some(res) = self.parse_item_in_mod(term, &mut stuck)? {
+            if let Some(item) = res {
+                items.push(item);
+                self.maybe_consume_incorrect_semicolon(&items);
+            }
         }
 
         if !self.eat(term) {
@@ -95,6 +101,135 @@ impl<'a> Parser<'a> {
         Ok(Mod { inner: inner_lo.to(hi), items, inline: true })
     }
 
+    fn parse_item_in_mod(
+        &mut self,
+        term: &TokenKind,
+        stuck: &mut bool,
+    ) -> PResult<'a, Option<Option<P<ast::Item>>>> {
+        match self.parse_item()? {
+            // We just made progress and we might have statements following this item.
+            i @ Some(_) => {
+                *stuck = false;
+                Ok(Some(i))
+            }
+            // No progress and the previous attempt at statements failed, so terminate the loop.
+            None if *stuck => Ok(None),
+            None => Ok(self.recover_stmts_as_item(term, stuck)?.then_some(None)),
+        }
+    }
+
+    /// Parse a contiguous list of statements until we reach the terminating token or EOF.
+    /// When any statements were parsed, perform recovery and suggest wrapping the statements
+    /// inside a function. If `stuck` becomes `true`, then this method should not be called
+    /// unless we have advanced the cursor.
+    fn recover_stmts_as_item(&mut self, term: &TokenKind, stuck: &mut bool) -> PResult<'a, bool> {
+        let lo = self.token.span;
+        let mut stmts = vec![];
+        while ![term, &token::Eof].contains(&&self.token.kind) {
+            let old_expected = std::mem::take(&mut self.expected_tokens);
+            let snapshot = self.clone();
+            let stmt = self.parse_full_stmt(true);
+            self.expected_tokens = old_expected; // Restore expected tokens to before recovery.
+            match stmt {
+                Ok(None) => break,
+                Ok(Some(stmt)) => stmts.push(stmt),
+                Err(mut err) => {
+                    // We couldn't parse as a statement. Rewind to the last one we could for.
+                    // Also notify the caller that we made no progress, meaning that the method
+                    // should not be called again to avoid non-termination.
+                    err.cancel();
+                    *self = snapshot;
+                    *stuck = true;
+                    break;
+                }
+            }
+        }
+
+        let recovered = !stmts.is_empty();
+        if recovered {
+            // We parsed some statements and have recovered, so let's emit an error.
+            self.error_stmts_as_item_suggest_fn(lo, stmts);
+        }
+        Ok(recovered)
+    }
+
+    fn error_stmts_as_item_suggest_fn(&self, lo: Span, stmts: Vec<ast::Stmt>) {
+        use syntax::ast::*;
+
+        let span = lo.to(self.prev_span);
+        let spans: MultiSpan = match &*stmts {
+            [] | [_] => span.into(),
+            [x, .., y] => vec![x.span, y.span].into(),
+        };
+
+        // Perform coarse grained inference about returns.
+        // We use this to tell whether `main` is an acceptable name
+        // and if `-> _` or `-> Result<_, _>` should be used instead of defaulting to unit.
+        #[derive(Default)]
+        struct RetInfer(bool, bool, bool);
+        let RetInfer(has_ret_unit, has_ret_expr, has_try_expr) = {
+            impl Visitor<'_> for RetInfer {
+                fn visit_expr_post(&mut self, expr: &Expr) {
+                    match expr.kind {
+                        ExprKind::Ret(None) => self.0 = true,    // `return`
+                        ExprKind::Ret(Some(_)) => self.1 = true, // `return $expr`
+                        ExprKind::Try(_) => self.2 = true,       // `expr?`
+                        _ => {}
+                    }
+                }
+            }
+            let mut visitor = RetInfer::default();
+            for stmt in &stmts {
+                visitor.visit_stmt(stmt);
+            }
+            if let StmtKind::Expr(_) = &stmts.last().unwrap().kind {
+                visitor.1 = true; // The tail expression.
+            }
+            visitor
+        };
+
+        // For the function name, use `main` if we are in `main.rs`, and `my_function` otherwise.
+        let use_main = (has_ret_unit || has_try_expr)
+            && self.directory.path.file_stem() == Some(std::ffi::OsStr::new("main"));
+        let ident = Ident::from_str_and_span(if use_main { "main" } else { "my_function" }, span);
+
+        // Construct the return type; either default, `-> _`, or `-> Result<_, _>`.
+        let output = match (has_ret_unit, has_ret_expr, has_try_expr) {
+            (true, _, _) | (false, false, false) => FnRetTy::Default(span),
+            (_, _, true) => {
+                let arg = GenericArg::Type(self.mk_ty(span, TyKind::Infer));
+                let args = [arg.clone(), arg].to_vec();
+                let args = AngleBracketedArgs { span, constraints: vec![], args };
+                let mut path = Path::from_ident(Ident::from_str_and_span("Result", span));
+                path.segments[0].args = Some(P(GenericArgs::AngleBracketed(args)));
+                FnRetTy::Ty(self.mk_ty(span, TyKind::Path(None, path)))
+            }
+            (_, true, _) => FnRetTy::Ty(self.mk_ty(span, TyKind::Infer)),
+        };
+
+        // Finalize the AST for the function item.
+        let sig = FnSig { header: FnHeader::default(), decl: P(FnDecl { inputs: vec![], output }) };
+        let body = self.mk_block(stmts, BlockCheckMode::Default, span);
+        let kind = ItemKind::Fn(Defaultness::Final, sig, Generics::default(), Some(body));
+        let vis = respan(span, VisibilityKind::Inherited);
+        let item = Item { span, ident, vis, kind, attrs: vec![], id: DUMMY_NODE_ID, tokens: None };
+
+        // Emit the error with a suggestion to wrap the statements in the function.
+        let mut err = self.struct_span_err(spans, "statements cannot reside in modules");
+        err.span_suggestion_verbose(
+            span,
+            "consider moving the statements into a function",
+            pprust::item_to_string(&item),
+            Applicability::HasPlaceholders,
+        );
+        err.note("the program entry point starts in `fn main() { ... }`, defined in `main.rs`");
+        err.note(
+            "for more on functions and how to structure your program, \
+                see https://doc.rust-lang.org/book/ch03-03-how-functions-work.html",
+        );
+        err.emit();
+    }
+
     fn submod_path(
         &mut self,
         id: ast::Ident,
diff --git a/src/librustc_parse/parser/stmt.rs b/src/librustc_parse/parser/stmt.rs
@@ -22,14 +22,14 @@ impl<'a> Parser<'a> {
     /// Parses a statement. This stops just before trailing semicolons on everything but items.
     /// e.g., a `StmtKind::Semi` parses to a `StmtKind::Expr`, leaving the trailing `;` unconsumed.
     pub fn parse_stmt(&mut self) -> PResult<'a, Option<Stmt>> {
-        Ok(self.parse_stmt_without_recovery().unwrap_or_else(|mut e| {
+        Ok(self.parse_stmt_without_recovery(false).unwrap_or_else(|mut e| {
             e.emit();
             self.recover_stmt_(SemiColonMode::Break, BlockMode::Ignore);
             None
         }))
     }
 
-    fn parse_stmt_without_recovery(&mut self) -> PResult<'a, Option<Stmt>> {
+    fn parse_stmt_without_recovery(&mut self, module_stmt: bool) -> PResult<'a, Option<Stmt>> {
         maybe_whole!(self, NtStmt, |x| Some(x));
 
         let attrs = self.parse_outer_attributes()?;
@@ -56,7 +56,10 @@ impl<'a> Parser<'a> {
             // that starts like a path (1 token), but it fact not a path.
             // Also, we avoid stealing syntax from `parse_item_`.
             self.parse_stmt_path_start(lo, attrs)?
-        } else if let Some(item) = self.parse_stmt_item(attrs.clone())? {
+        } else if let Some(item) =
+            // When parsing the statement as a module (recovery), avoid parsing items.
+            if module_stmt { None } else { self.parse_stmt_item(attrs.clone())? }
+        {
             // FIXME: Bad copy of attrs
             self.mk_stmt(lo.to(item.span), StmtKind::Item(P(item)))
         } else if self.token == token::Semi {
@@ -275,7 +278,7 @@ impl<'a> Parser<'a> {
         //      bar;
         //
         // which is valid in other languages, but not Rust.
-        match self.parse_stmt_without_recovery() {
+        match self.parse_stmt_without_recovery(true) {
             Ok(Some(stmt)) => {
                 if self.look_ahead(1, |t| t == &token::OpenDelim(token::Brace))
                     || do_not_suggest_help
@@ -334,7 +337,7 @@ impl<'a> Parser<'a> {
             if self.token == token::Eof {
                 break;
             }
-            let stmt = match self.parse_full_stmt() {
+            let stmt = match self.parse_full_stmt(false) {
                 Err(mut err) => {
                     self.maybe_annotate_with_ascription(&mut err, false);
                     err.emit();
@@ -354,20 +357,23 @@ impl<'a> Parser<'a> {
     }
 
     /// Parses a statement, including the trailing semicolon.
-    pub fn parse_full_stmt(&mut self) -> PResult<'a, Option<Stmt>> {
+    pub fn parse_full_stmt(&mut self, module_stmt: bool) -> PResult<'a, Option<Stmt>> {
         // Skip looking for a trailing semicolon when we have an interpolated statement.
         maybe_whole!(self, NtStmt, |x| Some(x));
 
-        let mut stmt = match self.parse_stmt_without_recovery()? {
+        let mut stmt = match self.parse_stmt_without_recovery(module_stmt)? {
             Some(stmt) => stmt,
             None => return Ok(None),
         };
 
         let mut eat_semi = true;
         match stmt.kind {
-            // Expression without semicolon.
             StmtKind::Expr(ref expr)
-                if self.token != token::Eof && classify::expr_requires_semi_to_be_stmt(expr) =>
+                // Expression without semicolon.
+                if self.token != token::Eof
+                    && classify::expr_requires_semi_to_be_stmt(expr)
+                    // Do not error here if in `module_stmt` recovery mode.
+                    && !module_stmt =>
             {
                 // Just check for errors and recover; do not eat semicolon yet.
                 if let Err(mut e) =
diff --git a/src/test/ui/issues/issue-49040.rs b/src/test/ui/issues/issue-49040.rs
@@ -1,3 +1,3 @@
-#![allow(unused_variables)]; //~ ERROR expected item, found `;`
+#![allow(unused_variables)]; //~ ERROR statements cannot reside in modules
 //~^ ERROR `main` function
 fn foo() {}
diff --git a/src/test/ui/issues/issue-49040.stderr b/src/test/ui/issues/issue-49040.stderr
@@ -1,16 +1,23 @@
-error: expected item, found `;`
+error: statements cannot reside in modules
   --> $DIR/issue-49040.rs:1:28
    |
 LL | #![allow(unused_variables)];
-   |                            ^ help: remove this semicolon
+   |                            ^
+   |
+   = note: the program entry point starts in `fn main() { ... }`, defined in `main.rs`
+   = note: for more on functions and how to structure your program, see https://doc.rust-lang.org/book/ch03-03-how-functions-work.html
+help: consider moving the statements into a function
+   |
+LL | #![allow(unused_variables)]fn my_function() { }
+   |                            ^^^^^^^^^^^^^^^^^^^^
 
 error[E0601]: `main` function not found in crate `issue_49040`
   --> $DIR/issue-49040.rs:1:1
    |
 LL | / #![allow(unused_variables)];
 LL | |
 LL | | fn foo() {}
-   | |__^ consider adding a `main` function to `$DIR/issue-49040.rs`
+   | |___________^ consider adding a `main` function to `$DIR/issue-49040.rs`
 
 error: aborting due to 2 previous errors
 
diff --git a/src/test/ui/issues/issue-62554.stderr b/src/test/ui/issues/issue-62554.stderr
@@ -60,12 +60,6 @@ LL | fn foo(u: u8) { if u8 macro_rules! u8 { (u6) => { fn uuuuuuuuuuu() { use s
    |                 --    ^^^^^^^^^^^ expected `{`
    |                 |
    |                 this `if` expression has a condition, but no block
-   |
-help: try placing this code inside a block
-   |
-LL | fn foo(u: u8) { if u8 { macro_rules! u8 { (u6) => { fn uuuuuuuuuuu() { use s loo mod u8 {
-LL |  }
-   |
 
 error: aborting due to 6 previous errors
 
diff --git a/src/test/ui/parser/issue-62913.rs b/src/test/ui/parser/issue-62913.rs
@@ -1,4 +1,5 @@
 "\u\\"
 //~^ ERROR incorrect unicode escape sequence
 //~| ERROR invalid trailing slash in literal
-//~| ERROR expected item, found `"\u\\"`
+//~| ERROR statements cannot reside in modules
+//~| ERROR `main` function not found
diff --git a/src/test/ui/parser/issue-62913.stderr b/src/test/ui/parser/issue-62913.stderr
@@ -12,11 +12,25 @@ error: invalid trailing slash in literal
 LL | "\u\"
    |     ^
 
-error: expected item, found `"\u\"`
+error: statements cannot reside in modules
   --> $DIR/issue-62913.rs:1:1
    |
 LL | "\u\"
-   | ^^^^^^ expected item
+   | ^^^^^^
+   |
+   = note: the program entry point starts in `fn main() { ... }`, defined in `main.rs`
+   = note: for more on functions and how to structure your program, see https://doc.rust-lang.org/book/ch03-03-how-functions-work.html
+help: consider moving the statements into a function
+   |
+LL | fn my_function() -> _ { "\u\" }
+   |
+
+error[E0601]: `main` function not found in crate `issue_62913`
+  --> $DIR/issue-62913.rs:1:1
+   |
+LL | "\u\"
+   | ^^^^^^ consider adding a `main` function to `$DIR/issue-62913.rs`
 
-error: aborting due to 3 previous errors
+error: aborting due to 4 previous errors
 
+For more information about this error, try `rustc --explain E0601`.
diff --git a/src/test/ui/parser/module-statement-recovery/main.rs b/src/test/ui/parser/module-statement-recovery/main.rs
@@ -0,0 +1,17 @@
+fn main() {}
+
+fn foo() {}
+
+let x = 0; //~ ERROR statements cannot reside in modules
+x;
+x;
+x;
+x;
+x;
+x;
+foo()?;
+Ok(42u16)
+
+struct X;
+
+if true {} //~ ERROR statements cannot reside in modules
diff --git a/src/test/ui/parser/module-statement-recovery/main.stderr b/src/test/ui/parser/module-statement-recovery/main.stderr
@@ -0,0 +1,36 @@
+error: statements cannot reside in modules
+  --> $DIR/main.rs:5:1
+   |
+LL | let x = 0;
+   | ^^^^^^^^^^
+...
+LL | Ok(42u16)
+   | ^^^^^^^^^
+   |
+   = note: the program entry point starts in `fn main() { ... }`, defined in `main.rs`
+   = note: for more on functions and how to structure your program, see https://doc.rust-lang.org/book/ch03-03-how-functions-work.html
+help: consider moving the statements into a function
+   |
+LL | fn my_function() -> Result<_, _> {
+LL |     let x = 0;
+LL |     x;
+LL |     x;
+LL |     x;
+LL |     x;
+ ...
+
+error: statements cannot reside in modules
+  --> $DIR/main.rs:17:1
+   |
+LL | if true {}
+   | ^^^^^^^^^^
+   |
+   = note: the program entry point starts in `fn main() { ... }`, defined in `main.rs`
+   = note: for more on functions and how to structure your program, see https://doc.rust-lang.org/book/ch03-03-how-functions-work.html
+help: consider moving the statements into a function
+   |
+LL | fn my_function() -> _ { if true { } }
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
diff --git a/src/test/ui/parser/module-statement-recovery/recover-statements-not-main.rs b/src/test/ui/parser/module-statement-recovery/recover-statements-not-main.rs
diff --git a/src/test/ui/parser/module-statement-recovery/recover-statements-not-main.stderr b/src/test/ui/parser/module-statement-recovery/recover-statements-not-main.stderr
diff --git a/src/test/ui/pub/pub-restricted-error-fn.rs b/src/test/ui/pub/pub-restricted-error-fn.rs
diff --git a/src/test/ui/pub/pub-restricted-error-fn.stderr b/src/test/ui/pub/pub-restricted-error-fn.stderr

Original file line number	Diff line number	Diff line change
`@@ -892,7 +892,7 @@ pub fn parse_ast_fragment<'a>(`
`892`	`892`	`let mut stmts = SmallVec::new();`
`893`	`893`	// Won't make progress on a `}`.
`894`	`894`	`while this.token != token::Eof && this.token != token::CloseDelim(token::Brace) {`
`895`		`- if let Some(stmt) = this.parse_full_stmt()? {`
	`895`	`+ if let Some(stmt) = this.parse_full_stmt(false)? {`
`896`	`896`	`stmts.push(stmt);`
`897`	`897`	`}`
`898`	`898`	`}`