1 files changed, 40 insertions, 46 deletions

diff --git a/crates/ra_assists/src/assists/add_new.rs b/crates/ra_assists/src/assists/add_new.rs
index 8f68bd5fb..b2f946fac 100644
--- a/crates/ra_assists/src/assists/add_new.rs
+++ b/crates/ra_assists/src/assists/add_new.rs
@@ -1,5 +1,5 @@
 use format_buf::format;
-use hir::{db::HirDatabase, FromSource};
+use hir::{db::HirDatabase, FromSource, InFile};
 use join_to_string::join;
 use ra_syntax::{
     ast::{
@@ -56,42 +56,39 @@ pub(crate) fn add_new(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
         let vis = vis.as_ref().map(String::as_str).unwrap_or("");
         write!(&mut buf, "    {}fn new(", vis).unwrap();
 
-        join(field_list.fields().map(|f| {
-            format!(
-                "{}: {}",
-                f.name().unwrap().syntax().text(),
-                f.ascribed_type().unwrap().syntax().text()
-            )
+        join(field_list.fields().filter_map(|f| {
+            Some(format!("{}: {}", f.name()?.syntax().text(), f.ascribed_type()?.syntax().text()))
         }))
         .separator(", ")
         .to_buf(&mut buf);
 
         buf.push_str(") -> Self { Self {");
 
-        join(field_list.fields().map(|f| f.name().unwrap().syntax().text()))
+        join(field_list.fields().filter_map(|f| Some(f.name()?.syntax().text())))
             .separator(", ")
             .surround_with(" ", " ")
             .to_buf(&mut buf);
 
         buf.push_str("} }");
 
-        let (start_offset, end_offset) = if let Some(impl_block) = impl_block {
-            buf.push('\n');
-            let start = impl_block
-                .syntax()
-                .descendants_with_tokens()
-                .find(|t| t.kind() == T!['{'])
-                .unwrap()
-                .text_range()
-                .end();
-
-            (start, TextUnit::from_usize(1))
-        } else {
-            buf = generate_impl_text(&strukt, &buf);
-            let start = strukt.syntax().text_range().end();
-
-            (start, TextUnit::from_usize(3))
-        };
+        let (start_offset, end_offset) = impl_block
+            .and_then(|impl_block| {
+                buf.push('\n');
+                let start = impl_block
+                    .syntax()
+                    .descendants_with_tokens()
+                    .find(|t| t.kind() == T!['{'])?
+                    .text_range()
+                    .end();
+
+                Some((start, TextUnit::from_usize(1)))
+            })
+            .unwrap_or_else(|| {
+                buf = generate_impl_text(&strukt, &buf);
+                let start = strukt.syntax().text_range().end();
+
+                (start, TextUnit::from_usize(3))
+            });
 
         edit.set_cursor(start_offset + TextUnit::of_str(&buf) - end_offset);
         edit.insert(start_offset, buf);
@@ -141,44 +138,41 @@ fn find_struct_impl(
     })?;
 
     let struct_ty = {
-        let src = hir::Source { file_id: ctx.frange.file_id.into(), value: strukt.clone() };
-        hir::Struct::from_source(db, src).unwrap().ty(db)
+        let src = InFile { file_id: ctx.frange.file_id.into(), value: strukt.clone() };
+        hir::Struct::from_source(db, src)?.ty(db)
     };
 
-    let mut found_new_fn = false;
-
-    let block = module.descendants().filter_map(ast::ImplBlock::cast).find(|impl_blk| {
-        if found_new_fn {
-            return false;
-        }
-
-        let src = hir::Source { file_id: ctx.frange.file_id.into(), value: impl_blk.clone() };
-        let blk = hir::ImplBlock::from_source(db, src).unwrap();
+    let block = module.descendants().filter_map(ast::ImplBlock::cast).find_map(|impl_blk| {
+        let src = InFile { file_id: ctx.frange.file_id.into(), value: impl_blk.clone() };
+        let blk = hir::ImplBlock::from_source(db, src)?;
 
         let same_ty = blk.target_ty(db) == struct_ty;
         let not_trait_impl = blk.target_trait(db).is_none();
 
         if !(same_ty && not_trait_impl) {
-            return false;
+            None
+        } else {
+            Some(impl_blk)
         }
-
-        found_new_fn = has_new_fn(impl_blk);
-        true
     });
 
-    if found_new_fn {
-        None
-    } else {
-        Some(block)
+    if let Some(ref impl_blk) = block {
+        if has_new_fn(impl_blk) {
+            return None;
+        }
     }
+
+    Some(block)
 }
 
 fn has_new_fn(imp: &ast::ImplBlock) -> bool {
     if let Some(il) = imp.item_list() {
         for item in il.impl_items() {
             if let ast::ImplItem::FnDef(f) = item {
-                if f.name().unwrap().text().eq_ignore_ascii_case("new") {
-                    return true;
+                if let Some(name) = f.name() {
+                    if name.text().eq_ignore_ascii_case("new") {
+                        return true;
+                    }
                 }
             }
         }