Add remove simple dbg stmt for remove_dbg

Remove only contain literals dbg statement

```rust
fn foo() {
    let n = 2;
    $0dbg!(3);
    dbg!(2.6);
    dbg!(1, 2.5);
    dbg!('x');
    dbg!(&n);
    dbg!(n);
    // needless comment
    dbg!("foo");$0
}
```
->
```rust
fn foo() {
    // needless comment
}
```
Old:
```rust
fn foo() {
    3;
    2.6;
    (1, 2.5);
    'x';
    &n;
    n;
    // needless comment
    "foo";
}
```

Author: A4-Tacks

crates/ide-assists/src/handlers/remove_dbg.rs

@@ -112,6 +112,16 @@ fn compute_dbg_replacement(
                 }
             }
         }
+        // dbg!(2, 'x', &x, x, ...);
+        exprs if ast::ExprStmt::can_cast(parent.kind()) && exprs.iter().all(pure_expr) => {
+            let mut replace = vec![parent.clone().into()];
+            if let Some(prev_sibling) = parent.prev_sibling_or_token()
+                && prev_sibling.kind() == syntax::SyntaxKind::WHITESPACE
+            {
+                replace.push(prev_sibling);
+            }
+            (replace, None)
+        }
         // dbg!(expr0)
         [expr] => {
             // dbg!(expr, &parent);
@@ -163,6 +173,20 @@ fn compute_dbg_replacement(
     })
 }
 
+fn pure_expr(expr: &ast::Expr) -> bool {
+    match_ast! {
+        match (expr.syntax()) {
+            ast::Literal(_) => true,
+            ast::RefExpr(it) => {
+                matches!(it.expr(), Some(ast::Expr::PathExpr(p))
+                    if p.path().and_then(|p| p.as_single_name_ref()).is_some())
+            },
+            ast::PathExpr(it) => it.path().and_then(|it| it.as_single_name_ref()).is_some(),
+            _ => false,
+        }
+    }
+}
+
 fn replace_nested_dbgs(expanded: ast::Expr) -> ast::Expr {
     if let ast::Expr::MacroExpr(mac) = &expanded {
         // Special-case when `expanded` itself is `dbg!()` since we cannot replace the whole tree
@@ -231,6 +255,32 @@ mod tests {
         check("dbg!{$01 + 1}", "1 + 1");
     }
 
+    #[test]
+    fn test_remove_simple_dbg_statement() {
+        check_assist(
+            remove_dbg,
+            r#"
+fn foo() {
+    let n = 2;
+    $0dbg!(3);
+    dbg!(2.6);
+    dbg!(1, 2.5);
+    dbg!('x');
+    dbg!(&n);
+    dbg!(n);
+    // needless comment
+    dbg!("foo");$0
+}
+"#,
+            r#"
+fn foo() {
+    let n = 2;
+    // needless comment
+}
+"#,
+        );
+    }
+
     #[test]
     fn test_remove_dbg_not_applicable() {
         check_assist_not_applicable(remove_dbg, "fn main() {$0vec![1, 2, 3]}");