clippy: Use if lets and remove redundant returns

crates/ra_editor/src/folding_ranges.rs

@@ -38,12 +38,12 @@ pub fn folding_ranges(file: &File) -> Vec<Fold> {
             continue;
         }
         if node.kind() == COMMENT {
-            contiguous_range_for_comment(node, &mut visited_comments).map(|range| {
+            if let Some(range) = contiguous_range_for_comment(node, &mut visited_comments) {
                 res.push(Fold {
                     range,
                     kind: FoldKind::Comment,
                 })
-            });
+            }
         }
     }
 

crates/ra_editor/src/line_index.rs

@@ -29,10 +29,10 @@ impl LineIndex {
         let line = self.newlines.upper_bound(&offset) - 1;
         let line_start_offset = self.newlines[line];
         let col = offset - line_start_offset;
-        return LineCol {
+        LineCol {
             line: line as u32,
             col,
-        };
+        }
     }
 
     pub fn offset(&self, line_col: LineCol) -> TextUnit {

crates/ra_editor/src/symbols.rs

@@ -54,15 +54,15 @@ pub fn file_structure(file: &File) -> Vec<StructureNode> {
     let mut res = Vec::new();
     let mut stack = Vec::new();
 
+
     for event in file.syntax().preorder() {
         match event {
-            WalkEvent::Enter(node) => match structure_node(node) {
-                Some(mut symbol) => {
+            WalkEvent::Enter(node) => {
+                if let Some(mut symbol) = structure_node(node) {
                     symbol.parent = stack.last().map(|&n| n);
                     stack.push(res.len());
                     res.push(symbol);
                 }
-                None => (),
             },
             WalkEvent::Leave(node) => {
                 if structure_node(node).is_some() {

crates/ra_lsp_server/src/server_world.rs

@@ -73,9 +73,7 @@ impl ServerWorldState {
             events
                 .into_iter()
                 .map(|event| {
-                    let text = match event.kind {
-                        FileEventKind::Add(text) => text,
-                    };
+                    let FileEventKind::Add(text) = event.kind;
                     (event.path, text)
                 })
                 .map(|(path, text)| (pm.get_or_insert(path, Root::Lib), text))

crates/ra_syntax/src/algo/mod.rs

@@ -30,7 +30,8 @@ pub fn find_leaf_at_offset(node: SyntaxNodeRef, offset: TextUnit) -> LeafAtOffse
     let left = children.next().unwrap();
     let right = children.next();
     assert!(children.next().is_none());
-    return if let Some(right) = right {
+
+    if let Some(right) = right {
         match (
             find_leaf_at_offset(left, offset),
             find_leaf_at_offset(right, offset),
@@ -42,7 +43,7 @@ pub fn find_leaf_at_offset(node: SyntaxNodeRef, offset: TextUnit) -> LeafAtOffse
         }
     } else {
         find_leaf_at_offset(left, offset)
-    };
+    }
 }
 
 #[derive(Clone, Copy, Debug)]

crates/ra_syntax/src/ast/mod.rs

@@ -259,9 +259,8 @@ impl<'a, N: AstNode<'a>> Iterator for AstChildren<'a, N> {
     type Item = N;
     fn next(&mut self) -> Option<N> {
         loop {
-            match N::cast(self.inner.next()?) {
-                Some(n) => return Some(n),
-                None => (),
+            if let Some(n) = N::cast(self.inner.next()?) {
+                return Some(n);
             }
         }
     }

crates/ra_syntax/src/grammar/expressions/atom.rs

@@ -62,9 +62,8 @@ pub(super) const ATOM_EXPR_FIRST: TokenSet = token_set_union![
 const EXPR_RECOVERY_SET: TokenSet = token_set![LET_KW];
 
 pub(super) fn atom_expr(p: &mut Parser, r: Restrictions) -> Option<CompletedMarker> {
-    match literal(p) {
-        Some(m) => return Some(m),
-        None => (),
+    if let Some(m) = literal(p) {
+        return Some(m);
     }
     if paths::is_path_start(p) || p.at(L_ANGLE) {
         return Some(path_expr(p, r));

crates/ra_syntax/src/grammar/items/mod.rs

@@ -352,7 +352,7 @@ fn macro_call(p: &mut Parser) -> BlockLike {
 pub(super) fn macro_call_after_excl(p: &mut Parser) -> BlockLike {
     p.expect(EXCL);
     p.eat(IDENT);
-    let flavor = match p.current() {
+    match p.current() {
         L_CURLY => {
             token_tree(p);
             BlockLike::Block
@@ -365,9 +365,7 @@ pub(super) fn macro_call_after_excl(p: &mut Parser) -> BlockLike {
             p.error("expected `{`, `[`, `(`");
             BlockLike::NotBlock
         }
-    };
-
-    flavor
+    }
 }
 
 pub(crate) fn token_tree(p: &mut Parser) {

crates/ra_syntax/src/grammar/patterns.rs

@@ -49,9 +49,8 @@ fn atom_pat(p: &mut Parser, recovery_set: TokenSet) -> Option<CompletedMarker> {
     //         "hello" => (),
     //     }
     // }
-    match expressions::literal(p) {
-        Some(m) => return Some(m),
-        None => (),
+    if let Some(m) = expressions::literal(p) {
+        return Some(m);
     }
 
     let m = match la0 {

crates/ra_syntax/src/utils.rs

@@ -42,7 +42,7 @@ pub fn dump_tree(syntax: SyntaxNodeRef) -> String {
         writeln!(buf, "err: `{}`", err.msg).unwrap();
     }
 
-    return buf;
+    buf
 }
 
 pub fn check_fuzz_invariants(text: &str) {

crates/tools/src/main.rs

@@ -112,9 +112,8 @@ fn existing_tests(dir: &Path) -> Result<HashMap<String, (PathBuf, Test)>> {
             name: name.clone(),
             text,
         };
-        match res.insert(name, (path, test)) {
-            Some(old) => println!("Duplicate test: {:?}", old),
-            None => (),
+        if let Some(old) = res.insert(name, (path, test)) {
+            println!("Duplicate test: {:?}", old);
         }
     }
     Ok(res)