Rename lint and cleanup implementation

Author: Aaron1011

compiler/rustc_expand/src/base.rs

@@ -347,7 +347,6 @@ pub trait TTMacroExpander {
         ecx: &'cx mut ExtCtxt<'_>,
         span: Span,
         input: TokenStream,
-        nearest_parent: NodeId,
     ) -> Box<dyn MacResult + 'cx>;
 }
 
@@ -363,7 +362,6 @@ where
         ecx: &'cx mut ExtCtxt<'_>,
         span: Span,
         input: TokenStream,
-        _nearest_parent: NodeId,
     ) -> Box<dyn MacResult + 'cx> {
         self(ecx, span, input)
     }

compiler/rustc_expand/src/expand.rs

@@ -721,11 +721,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
                 SyntaxExtensionKind::LegacyBang(expander) => {
                     let prev = self.cx.current_expansion.prior_type_ascription;
                     self.cx.current_expansion.prior_type_ascription = mac.prior_type_ascription;
-                    // FIXME - this is imprecise. We should try to lint as close to the macro call
-                    // as possible (we cannot take attributes from the macro call itself).
-                    let nearest_parent = self.cx.resolver.lint_node_id(invoc.expansion_data.id);
-                    let tok_result =
-                        expander.expand(self.cx, span, mac.args.inner_tokens(), nearest_parent);
+                    let tok_result = expander.expand(self.cx, span, mac.args.inner_tokens());
                     let result = if let Some(result) = fragment_kind.make_from(tok_result) {
                         result
                     } else {

compiler/rustc_expand/src/mbe/macro_rules.rs

@@ -18,7 +18,7 @@ use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::sync::Lrc;
 use rustc_errors::{Applicability, DiagnosticBuilder};
 use rustc_feature::Features;
-use rustc_lint_defs::builtin::MACRO_TRAILING_SEMICOLON;
+use rustc_lint_defs::builtin::SEMICOLON_IN_EXPRESSIONS_FROM_MACROS;
 use rustc_parse::parser::Parser;
 use rustc_session::parse::ParseSess;
 use rustc_session::Session;
@@ -39,7 +39,7 @@ crate struct ParserAnyMacro<'a> {
     site_span: Span,
     /// The ident of the macro we're parsing
     macro_ident: Ident,
-    nearest_parent: NodeId,
+    lint_node_id: NodeId,
     arm_span: Span,
 }
 
@@ -113,7 +113,7 @@ fn emit_frag_parse_err(
 
 impl<'a> ParserAnyMacro<'a> {
     crate fn make(mut self: Box<ParserAnyMacro<'a>>, kind: AstFragmentKind) -> AstFragment {
-        let ParserAnyMacro { site_span, macro_ident, ref mut parser, nearest_parent, arm_span } =
+        let ParserAnyMacro { site_span, macro_ident, ref mut parser, lint_node_id, arm_span } =
             *self;
         let snapshot = &mut parser.clone();
         let fragment = match parse_ast_fragment(parser, kind) {
@@ -129,9 +129,9 @@ impl<'a> ParserAnyMacro<'a> {
         // but `m!()` is allowed in expression positions (cf. issue #34706).
         if kind == AstFragmentKind::Expr && parser.token == token::Semi {
             parser.sess.buffer_lint(
-                MACRO_TRAILING_SEMICOLON,
+                SEMICOLON_IN_EXPRESSIONS_FROM_MACROS,
                 parser.token.span,
-                nearest_parent,
+                lint_node_id,
                 "trailing semicolon in macro used in expression position",
             );
             parser.bump();
@@ -159,7 +159,6 @@ impl TTMacroExpander for MacroRulesMacroExpander {
         cx: &'cx mut ExtCtxt<'_>,
         sp: Span,
         input: TokenStream,
-        nearest_parent: NodeId,
     ) -> Box<dyn MacResult + 'cx> {
         if !self.valid {
             return DummyResult::any(sp);
@@ -171,7 +170,6 @@ impl TTMacroExpander for MacroRulesMacroExpander {
             self.name,
             self.transparency,
             input,
-            nearest_parent,
             &self.lhses,
             &self.rhses,
         )
@@ -199,7 +197,6 @@ fn generic_extension<'cx>(
     name: Ident,
     transparency: Transparency,
     arg: TokenStream,
-    nearest_parent: NodeId,
     lhses: &[mbe::TokenTree],
     rhses: &[mbe::TokenTree],
 ) -> Box<dyn MacResult + 'cx> {
@@ -289,6 +286,7 @@ fn generic_extension<'cx>(
 
                 let mut p = Parser::new(sess, tts, false, None);
                 p.last_type_ascription = cx.current_expansion.prior_type_ascription;
+                let lint_node_id = cx.resolver.lint_node_id(cx.current_expansion.id);
 
                 // Let the context choose how to interpret the result.
                 // Weird, but useful for X-macros.
@@ -300,7 +298,7 @@ fn generic_extension<'cx>(
                     // macro leaves unparsed tokens.
                     site_span: sp,
                     macro_ident: name,
-                    nearest_parent,
+                    lint_node_id,
                     arm_span,
                 });
             }

compiler/rustc_lint_defs/src/builtin.rs

@@ -2835,13 +2835,14 @@ declare_lint! {
 }
 
 declare_lint! {
-    /// The `macro_trailing_semicolon` lint detects trailing semicolons
+    /// The `semicolon_in_expressions_from_macros` lint detects trailing semicolons
     /// in macro bodies when the macro is invoked in expression position.
     /// This was previous accepted, but is being phased out.
     ///
     /// ### Example
     ///
-    /// ```rust
+    /// ```rust,compile-fail
+    /// #![deny(semicolon_in_expressions_from_macros)]
     /// macro_rules! foo {
     ///     () => { true; }
     /// }
@@ -2854,6 +2855,8 @@ declare_lint! {
     /// }
     /// ```
     ///
+    /// {{produces}}
+    ///
     /// ### Explanation
     ///
     /// Previous, Rust ignored trailing semicolon in a macro
@@ -2868,7 +2871,7 @@ declare_lint! {
     ///
     /// [issue #79813]: https://github.com/rust-lang/rust/issues/79813
     /// [future-incompatible]: ../index.md#future-incompatible-lints
-    pub MACRO_TRAILING_SEMICOLON,
+    pub SEMICOLON_IN_EXPRESSIONS_FROM_MACROS,
     Allow,
     "trailing semicolon in macro body used as expression",
     @future_incompatible = FutureIncompatibleInfo {
@@ -2964,7 +2967,7 @@ declare_lint_pass! {
         USELESS_DEPRECATED,
         UNSUPPORTED_NAKED_FUNCTIONS,
         MISSING_ABI,
-        MACRO_TRAILING_SEMICOLON,
+        SEMICOLON_IN_EXPRESSIONS_FROM_MACROS,
     ]
 }
 

compiler/rustc_resolve/src/macros.rs

@@ -344,6 +344,8 @@ impl<'a> ResolverExpand for Resolver<'a> {
     }
 
     fn lint_node_id(&mut self, expn_id: ExpnId) -> NodeId {
+        // FIXME - make this more precise. This currently returns the NodeId of the
+        // nearest closing item - we should try to return the closest parent of the ExpnId
         self.invocation_parents
             .get(&expn_id)
             .map_or(ast::CRATE_NODE_ID, |id| self.def_id_to_node_id[*id])

src/bootstrap/bootstrap.py

@@ -833,7 +833,7 @@ def build_bootstrap(self):
         target_linker = self.get_toml("linker", build_section)
         if target_linker is not None:
             env["RUSTFLAGS"] += " -C linker=" + target_linker
-        # cfg(bootstrap): Add `-Wmacro_trailing_semicolon` after the next beta bump
+        # cfg(bootstrap): Add `-Wsemicolon_in_expressions_from_macros` after the next beta bump
         env["RUSTFLAGS"] += " -Wrust_2018_idioms -Wunused_lifetimes"
         if self.get_toml("deny-warnings", "rust") != "false":
             env["RUSTFLAGS"] += " -Dwarnings"

src/bootstrap/builder.rs

@@ -1254,7 +1254,7 @@ impl<'a> Builder<'a> {
             // This is currently disabled for the stage1 libstd, since build scripts
             // will end up using the bootstrap compiler (which doesn't yet support this lint)
             if compiler.stage != 0 && mode != Mode::Std {
-                lint_flags.push("-Wmacro_trailing_semicolon");
+                lint_flags.push("-Wsemicolon_in_expressions_from_macros");
             }
 
             if self.config.deny_warnings {

src/test/ui/lint/macro-trailing-semicolon/allow-macro-trailing-semicolon.rs renamed to src/test/ui/lint/semicolon-in-expressions-from-macros/allow-semicolon-in-expressions-from-macros.rs

@@ -1,5 +1,5 @@
 // check-pass
-#![warn(macro_trailing_semicolon)]
+#![warn(semicolon_in_expressions_from_macros)]
 
 #[allow(dead_code)]
 macro_rules! foo {
@@ -13,17 +13,17 @@ macro_rules! foo {
 
 fn main() {
     // This `allow` doesn't work
-    #[allow(macro_trailing_semicolon)]
+    #[allow(semicolon_in_expressions_from_macros)]
     let _ = {
         foo!(first)
     };
 
     // This 'allow' doesn't work either
-    #[allow(macro_trailing_semicolon)]
+    #[allow(semicolon_in_expressions_from_macros)]
     let _ = foo!(second);
 
     // But this 'allow' does
-    #[allow(macro_trailing_semicolon)]
+    #[allow(semicolon_in_expressions_from_macros)]
     fn inner() {
         let _ = foo!(third);
     }

src/test/ui/lint/macro-trailing-semicolon/macro-trailing-semicolon.rs renamed to src/test/ui/lint/semicolon-in-expressions-from-macros/semicolon-in-expressions-from-macros.rs

@@ -1,5 +1,5 @@
 warning: trailing semicolon in macro used in expression position
-  --> $DIR/macro-trailing-semicolon.rs:7:13
+  --> $DIR/semicolon-in-expressions-from-macros.rs:7:13
    |
 LL |         true;
    |             ^
@@ -8,16 +8,16 @@ LL |         foo!(first)
    |         ----------- in this macro invocation
    |
 note: the lint level is defined here
-  --> $DIR/macro-trailing-semicolon.rs:2:9
+  --> $DIR/semicolon-in-expressions-from-macros.rs:2:9
    |
-LL | #![warn(macro_trailing_semicolon)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^
+LL | #![warn(semicolon_in_expressions_from_macros)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #79813 <https://github.com/rust-lang/rust/issues/79813>
    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 
 warning: trailing semicolon in macro used in expression position
-  --> $DIR/macro-trailing-semicolon.rs:7:13
+  --> $DIR/semicolon-in-expressions-from-macros.rs:7:13
    |
 LL |         true;
    |             ^