Added semicolon_outside_block lint

Author: 1c3t3a

CHANGELOG.md

@@ -2905,6 +2905,7 @@ Released 2018-09-13
 [`self_named_constructors`]: https://rust-lang.github.io/rust-clippy/master/index.html#self_named_constructors
 [`semicolon_if_nothing_returned`]: https://rust-lang.github.io/rust-clippy/master/index.html#semicolon_if_nothing_returned
 [`semicolon_inside_block`]: https://rust-lang.github.io/rust-clippy/master/index.html#semicolon_inside_block
+[`semicolon_outside_block`]: https://rust-lang.github.io/rust-clippy/master/index.html#semicolon_outside_block
 [`serde_api_misuse`]: https://rust-lang.github.io/rust-clippy/master/index.html#serde_api_misuse
 [`shadow_reuse`]: https://rust-lang.github.io/rust-clippy/master/index.html#shadow_reuse
 [`shadow_same`]: https://rust-lang.github.io/rust-clippy/master/index.html#shadow_same

clippy_lints/src/lib.rs

@@ -332,6 +332,7 @@ mod self_assignment;
 mod self_named_constructors;
 mod semicolon_if_nothing_returned;
 mod semicolon_inside_block;
+mod semicolon_outside_block;
 mod serde_api;
 mod shadow;
 mod single_component_path_imports;
@@ -905,6 +906,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         self_named_constructors::SELF_NAMED_CONSTRUCTORS,
         semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED,
         semicolon_inside_block::SEMICOLON_INSIDE_BLOCK,
+        semicolon_outside_block::SEMICOLON_OUTSIDE_BLOCK,
         serde_api::SERDE_API_MISUSE,
         shadow::SHADOW_REUSE,
         shadow::SHADOW_SAME,
@@ -1136,6 +1138,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(ref_option_ref::REF_OPTION_REF),
         LintId::of(semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED),
         LintId::of(semicolon_inside_block::SEMICOLON_INSIDE_BLOCK),
+        LintId::of(semicolon_outside_block::SEMICOLON_OUTSIDE_BLOCK),
         LintId::of(shadow::SHADOW_UNRELATED),
         LintId::of(strings::STRING_ADD_ASSIGN),
         LintId::of(trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS),
@@ -2092,6 +2095,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box float_equality_without_abs::FloatEqualityWithoutAbs);
     store.register_late_pass(|| box semicolon_if_nothing_returned::SemicolonIfNothingReturned);
     store.register_late_pass(|| box semicolon_inside_block::SemicolonInsideBlock);
+    store.register_late_pass(|| box semicolon_outside_block::SemicolonOutsideBlock);
     store.register_late_pass(|| box async_yields_async::AsyncYieldsAsync);
     let disallowed_methods = conf.disallowed_methods.iter().cloned().collect::<FxHashSet<_>>();
     store.register_late_pass(move || box disallowed_method::DisallowedMethod::new(&disallowed_methods));

clippy_lints/src/semicolon_outside_block.rs

@@ -0,0 +1,102 @@
+use crate::rustc_lint::LintContext;
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::in_macro;
+use clippy_utils::source::snippet_with_macro_callsite;
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::ExprKind;
+use rustc_hir::{Block, StmtKind, ItemKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::BytePos;
+use rustc_span::Span;
+use std::ops::Add;
+
+declare_clippy_lint! {
+    /// **What it does:** For () returning expressions, check that the semicolon is outside the block.
+    ///
+    /// **Why is this bad?** For consistency it's best to have the semicolon inside/outside the block. Either way is fine and this lint suggests outside the block.
+    /// Take a look at `semicolon_inside_block` for the other alternative.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// unsafe { f(x); }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// unsafe { f(x) };
+    /// ```
+    pub SEMICOLON_OUTSIDE_BLOCK,
+    pedantic,
+    "add a semicolon outside the block"
+}
+
+declare_lint_pass!(SemicolonOutsideBlock => [SEMICOLON_OUTSIDE_BLOCK]);
+
+impl LateLintPass<'_> for SemicolonOutsideBlock {
+    fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'tcx>) {
+        if_chain! {
+            if !in_macro(block.span);
+            if block.expr.is_none();
+            if let Some(last) = block.stmts.last();
+            if let StmtKind::Semi(expr) = last.kind;
+            let t_expr = cx.typeck_results().expr_ty(expr);
+            if t_expr.is_unit();
+
+            // make sure that the block does not belong to a function
+            let parent_item_id = cx.tcx.hir().get_parent_item(block.hir_id);
+            let parent_item = cx.tcx.hir().expect_item(parent_item_id);
+            if let ItemKind::Fn(_, _, body_id) = parent_item.kind;
+            let item_body = cx.tcx.hir().body(body_id);
+            if let ExprKind::Block(fn_block, _) = item_body.value.kind;
+            if fn_block.hir_id != block.hir_id;
+            then {
+                // filter out other blocks and the desugared for loop
+                if let ExprKind::Block(..) | ExprKind::DropTemps(..) = expr.kind { return }
+
+                // make sure we're also having the semicolon at the end of the expression...
+                let expr_w_sem = expand_span_to_semicolon(cx, expr.span);
+                let expr_snip = snippet_with_macro_callsite(cx, expr_w_sem, "..");
+                let mut expr_sugg = expr_snip.to_string();
+                expr_sugg.pop();
+
+                // and the block
+                let block_w_sem = expand_span_to_semicolon(cx, block.span);
+                let mut block_snip: String = snippet_with_macro_callsite(cx, block_w_sem, "..").to_string();
+                if block_snip.ends_with('\n') {
+                    block_snip.pop();
+                }
+
+                // retrieve the suggestion
+                let suggestion = if block_snip.ends_with(';') {
+                    block_snip.replace(expr_snip.as_ref(), &format!("{}", expr_sugg.as_str()))
+                } else {
+                    format!("{};", block_snip.replace(expr_snip.as_ref(), &format!("{}", expr_sugg.as_str())))
+                };
+
+                span_lint_and_sugg(
+                    cx,
+                    SEMICOLON_OUTSIDE_BLOCK,
+                    if block_snip.ends_with(';') {
+                        block_w_sem
+                    } else {
+                        block.span
+                    },
+                    "consider moving the `;` outside the block for consistent formatting",
+                    "put the `;` outside the block",
+                    suggestion,
+                    Applicability::MaybeIncorrect,
+                );
+            }
+        }
+    }
+}
+
+/// Takes a span and extzends it until after a semicolon in the last line of the span.
+fn expand_span_to_semicolon<'tcx>(cx: &LateContext<'tcx>, expr_span: Span) -> Span {
+    let expr_span_with_sem = cx.sess().source_map().span_extend_to_next_char(expr_span, ';', false);
+    expr_span_with_sem.with_hi(expr_span_with_sem.hi().add(BytePos(1)))
+}

tests/ui/semicolon_outside_block.rs

@@ -0,0 +1,63 @@
+#![warn(clippy::semicolon_outside_block)]
+
+unsafe fn f(arg: u32) {}
+
+#[rustfmt::skip]
+fn main() {
+    let x = 32;
+
+    unsafe { f(x); }
+}
+
+fn foo() {
+    let x = 32;
+
+    unsafe {
+        f(x);
+    }
+}
+
+fn bar() {
+    let x = 32;
+
+    unsafe {
+        let _this = 1;
+        let _is = 2;
+        let _a = 3;
+        let _long = 4;
+        let _list = 5;
+        let _of = 6;
+        let _variables = 7;
+        f(x);
+    };
+}
+
+fn get_unit() {}
+
+fn moin() {
+    {
+        let _u = get_unit();
+        println!("Hello");
+    }
+}
+
+#[rustfmt::skip]
+fn closure_error() {
+    let _d = || {
+        get_unit();
+    };
+}
+
+fn my_own_block() {
+    let x: i32;
+    {
+        let y = 42;
+        x = y + 1;
+        get_unit();
+    }
+    assert_eq!(43, 43)
+}
+
+fn just_get_unit() {
+    get_unit();
+}

tests/ui/semicolon_outside_block.stderr

@@ -0,0 +1,82 @@
+error: consider moving the `;` outside the block for consistent formatting
+  --> $DIR/semicolon_outside_block.rs:9:5
+   |
+LL |     unsafe { f(x); }
+   |     ^^^^^^^^^^^^^^^^ help: put the `;` outside the block: `unsafe { f(x) };`
+   |
+   = note: `-D clippy::semicolon-outside-block` implied by `-D warnings`
+
+error: consider moving the `;` outside the block for consistent formatting
+  --> $DIR/semicolon_outside_block.rs:15:5
+   |
+LL | /     unsafe {
+LL | |         f(x);
+LL | |     }
+   | |_____^
+   |
+help: put the `;` outside the block
+   |
+LL |     unsafe {
+LL |         f(x)
+LL |     };
+   |
+
+error: consider moving the `;` outside the block for consistent formatting
+  --> $DIR/semicolon_outside_block.rs:23:5
+   |
+LL | /     unsafe {
+LL | |         let _this = 1;
+LL | |         let _is = 2;
+LL | |         let _a = 3;
+...  |
+LL | |         f(x);
+LL | |     };
+   | |______^
+   |
+help: put the `;` outside the block
+   |
+LL |     unsafe {
+LL |         let _this = 1;
+LL |         let _is = 2;
+LL |         let _a = 3;
+LL |         let _long = 4;
+LL |         let _list = 5;
+ ...
+
+error: consider moving the `;` outside the block for consistent formatting
+  --> $DIR/semicolon_outside_block.rs:46:17
+   |
+LL |       let _d = || {
+   |  _________________^
+LL | |         get_unit();
+LL | |     };
+   | |______^
+   |
+help: put the `;` outside the block
+   |
+LL |     let _d = || {
+LL |         get_unit()
+LL |     };
+   |
+
+error: consider moving the `;` outside the block for consistent formatting
+  --> $DIR/semicolon_outside_block.rs:53:5
+   |
+LL | /     {
+LL | |         let y = 42;
+LL | |         x = y + 1;
+LL | |         get_unit();
+LL | |     }
+   | |_____^
+   |
+help: put the `;` outside the block
+   |
+LL |     {
+LL |         let y = 42;
+LL |         x = y + 1;
+LL |         get_unit()
+LL |     };
+   |
+
+error: aborting due to 5 previous errors
+