7 files changed, 89 insertions, 59 deletions

diff --git a/crates/ra_assists/src/assist_ctx.rs b/crates/ra_assists/src/assist_ctx.rs
index 1908bdec9..0ea84d548 100644
--- a/crates/ra_assists/src/assist_ctx.rs
+++ b/crates/ra_assists/src/assist_ctx.rs
@@ -1,6 +1,5 @@
 //! This module defines `AssistCtx` -- the API surface that is exposed to assists.
-
-use hir::db::HirDatabase;
+use hir::{db::HirDatabase, SourceAnalyzer};
 use ra_db::FileRange;
 use ra_fmt::{leading_indent, reindent};
 use ra_syntax::{
@@ -113,6 +112,13 @@ impl<'a, DB: HirDatabase> AssistCtx<'a, DB> {
     pub(crate) fn covering_element(&self) -> SyntaxElement {
         find_covering_element(self.source_file.syntax(), self.frange.range)
     }
+    pub(crate) fn source_analyzer(
+        &self,
+        node: &SyntaxNode,
+        offset: Option<TextUnit>,
+    ) -> SourceAnalyzer {
+        SourceAnalyzer::new(self.db, hir::Source::new(self.frange.file_id.into(), node), offset)
+    }
 
     pub(crate) fn covering_node_for_range(&self, range: TextRange) -> SyntaxElement {
         find_covering_element(self.source_file.syntax(), range)
diff --git a/crates/ra_assists/src/assists/add_explicit_type.rs b/crates/ra_assists/src/assists/add_explicit_type.rs
index ddda1a0f2..562a09685 100644
--- a/crates/ra_assists/src/assists/add_explicit_type.rs
+++ b/crates/ra_assists/src/assists/add_explicit_type.rs
@@ -40,7 +40,7 @@ pub(crate) fn add_explicit_type(ctx: AssistCtx<impl HirDatabase>) -> Option<Assi
     }
     // Infer type
     let db = ctx.db;
-    let analyzer = hir::SourceAnalyzer::new(db, ctx.frange.file_id, stmt.syntax(), None);
+    let analyzer = ctx.source_analyzer(stmt.syntax(), None);
     let ty = analyzer.type_of(db, &expr)?;
     // Assist not applicable if the type is unknown
     if is_unknown(&ty) {
diff --git a/crates/ra_assists/src/assists/add_missing_impl_members.rs b/crates/ra_assists/src/assists/add_missing_impl_members.rs
index 41de23921..91af161ee 100644
--- a/crates/ra_assists/src/assists/add_missing_impl_members.rs
+++ b/crates/ra_assists/src/assists/add_missing_impl_members.rs
@@ -100,8 +100,7 @@ fn add_missing_impl_members_inner(
     let impl_item_list = impl_node.item_list()?;
 
     let trait_def = {
-        let file_id = ctx.frange.file_id;
-        let analyzer = hir::SourceAnalyzer::new(ctx.db, file_id, impl_node.syntax(), None);
+        let analyzer = ctx.source_analyzer(impl_node.syntax(), None);
 
         resolve_target_trait_def(ctx.db, &analyzer, &impl_node)?
     };
diff --git a/crates/ra_assists/src/assists/add_new.rs b/crates/ra_assists/src/assists/add_new.rs
index a8839cfba..2038afdc6 100644
--- a/crates/ra_assists/src/assists/add_new.rs
+++ b/crates/ra_assists/src/assists/add_new.rs
@@ -158,9 +158,12 @@ fn find_struct_impl(
         let same_ty = blk.target_ty(db) == struct_ty;
         let not_trait_impl = blk.target_trait(db).is_none();
 
-        found_new_fn = has_new_fn(impl_blk);
+        if !(same_ty && not_trait_impl) {
+            return false;
+        }
 
-        same_ty && not_trait_impl
+        found_new_fn = has_new_fn(impl_blk);
+        true
     });
 
     if found_new_fn {
@@ -186,9 +189,10 @@ fn has_new_fn(imp: &ast::ImplBlock) -> bool {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use crate::helpers::{check_assist, check_assist_not_applicable, check_assist_target};
 
+    use super::*;
+
     #[test]
     #[rustfmt::skip]
     fn test_add_new() {
@@ -345,7 +349,7 @@ struct Foo {<|>}
 impl Foo {
     fn new() -> Self {
         Self
-    }    
+    }
 }",
         );
 
@@ -357,7 +361,7 @@ struct Foo {<|>}
 impl Foo {
     fn New() -> Self {
         Self
-    }    
+    }
 }",
         );
     }
@@ -376,4 +380,59 @@ struct EvenMoreIrrelevant;
 struct Foo<'a, T: Foo<'a>> {}",
         );
     }
+
+    #[test]
+    fn test_unrelated_new() {
+        check_assist(
+            add_new,
+            r##"
+pub struct AstId<N: AstNode> {
+    file_id: HirFileId,
+    file_ast_id: FileAstId<N>,
+}
+
+impl<N: AstNode> AstId<N> {
+    pub fn new(file_id: HirFileId, file_ast_id: FileAstId<N>) -> AstId<N> {
+        AstId { file_id, file_ast_id }
+    }
+}
+
+pub struct Source<T> {
+    pub file_id: HirFileId,<|>
+    pub ast: T,
+}
+
+impl<T> Source<T> {
+    pub fn map<F: FnOnce(T) -> U, U>(self, f: F) -> Source<U> {
+        Source { file_id: self.file_id, ast: f(self.ast) }
+    }
+}
+"##,
+            r##"
+pub struct AstId<N: AstNode> {
+    file_id: HirFileId,
+    file_ast_id: FileAstId<N>,
+}
+
+impl<N: AstNode> AstId<N> {
+    pub fn new(file_id: HirFileId, file_ast_id: FileAstId<N>) -> AstId<N> {
+        AstId { file_id, file_ast_id }
+    }
+}
+
+pub struct Source<T> {
+    pub file_id: HirFileId,
+    pub ast: T,
+}
+
+impl<T> Source<T> {
+    pub fn new(file_id: HirFileId, ast: T) -> Self { Self { file_id, ast } }<|>
+
+    pub fn map<F: FnOnce(T) -> U, U>(self, f: F) -> Source<U> {
+        Source { file_id: self.file_id, ast: f(self.ast) }
+    }
+}
+"##,
+        );
+    }
 }
diff --git a/crates/ra_assists/src/assists/fill_match_arms.rs b/crates/ra_assists/src/assists/fill_match_arms.rs
index 2b74f355c..b851c2082 100644
--- a/crates/ra_assists/src/assists/fill_match_arms.rs
+++ b/crates/ra_assists/src/assists/fill_match_arms.rs
@@ -47,8 +47,7 @@ pub(crate) fn fill_match_arms(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist
 
     let expr = match_expr.expr()?;
     let enum_def = {
-        let file_id = ctx.frange.file_id;
-        let analyzer = hir::SourceAnalyzer::new(ctx.db, file_id, expr.syntax(), None);
+        let analyzer = ctx.source_analyzer(expr.syntax(), None);
         resolve_enum_def(ctx.db, &analyzer, &expr)?
     };
     let variant_list = enum_def.variant_list()?;
diff --git a/crates/ra_assists/src/assists/inline_local_variable.rs b/crates/ra_assists/src/assists/inline_local_variable.rs
index a7fd9b6d2..18a34502c 100644
--- a/crates/ra_assists/src/assists/inline_local_variable.rs
+++ b/crates/ra_assists/src/assists/inline_local_variable.rs
@@ -45,7 +45,7 @@ pub(crate) fn inline_local_varialbe(ctx: AssistCtx<impl HirDatabase>) -> Option<
     } else {
         let_stmt.syntax().text_range()
     };
-    let analyzer = hir::SourceAnalyzer::new(ctx.db, ctx.frange.file_id, bind_pat.syntax(), None);
+    let analyzer = ctx.source_analyzer(bind_pat.syntax(), None);
     let refs = analyzer.find_all_refs(&bind_pat);
 
     let mut wrap_in_parens = vec![true; refs.len()];
diff --git a/crates/ra_assists/src/assists/raw_string.rs b/crates/ra_assists/src/assists/raw_string.rs
index 58f7157ae..93912a470 100644
--- a/crates/ra_assists/src/assists/raw_string.rs
+++ b/crates/ra_assists/src/assists/raw_string.rs
@@ -1,9 +1,9 @@
 use hir::db::HirDatabase;
 use ra_syntax::{
+    ast, AstToken,
     SyntaxKind::{RAW_STRING, STRING},
-    TextRange, TextUnit,
+    TextUnit,
 };
-use rustc_lexer;
 
 use crate::{Assist, AssistCtx, AssistId};
 
@@ -23,32 +23,16 @@ use crate::{Assist, AssistCtx, AssistId};
 // }
 // ```
 pub(crate) fn make_raw_string(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
-    let token = ctx.find_token_at_offset(STRING)?;
-    let text = token.text().as_str();
-    let usual_string_range = find_usual_string_range(text)?;
-    let start_of_inside = usual_string_range.start().to_usize() + 1;
-    let end_of_inside = usual_string_range.end().to_usize();
-    let inside_str = &text[start_of_inside..end_of_inside];
-    let mut unescaped = String::with_capacity(inside_str.len());
-    let mut error = Ok(());
-    rustc_lexer::unescape::unescape_str(
-        inside_str,
-        &mut |_, unescaped_char| match unescaped_char {
-            Ok(c) => unescaped.push(c),
-            Err(_) => error = Err(()),
-        },
-    );
-    if error.is_err() {
-        return None;
-    }
+    let token = ctx.find_token_at_offset(STRING).and_then(ast::String::cast)?;
+    let value = token.value()?;
     ctx.add_assist(AssistId("make_raw_string"), "make raw string", |edit| {
-        edit.target(token.text_range());
-        let max_hash_streak = count_hashes(&unescaped);
+        edit.target(token.syntax().text_range());
+        let max_hash_streak = count_hashes(&value);
         let mut hashes = String::with_capacity(max_hash_streak + 1);
         for _ in 0..hashes.capacity() {
             hashes.push('#');
         }
-        edit.replace(token.text_range(), format!("r{}\"{}\"{}", hashes, unescaped, hashes));
+        edit.replace(token.syntax().text_range(), format!("r{}\"{}\"{}", hashes, value, hashes));
     })
 }
 
@@ -68,17 +52,13 @@ pub(crate) fn make_raw_string(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist
 // }
 // ```
 pub(crate) fn make_usual_string(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
-    let token = ctx.find_token_at_offset(RAW_STRING)?;
-    let text = token.text().as_str();
-    let usual_string_range = find_usual_string_range(text)?;
+    let token = ctx.find_token_at_offset(RAW_STRING).and_then(ast::RawString::cast)?;
+    let value = token.value()?;
     ctx.add_assist(AssistId("make_usual_string"), "make usual string", |edit| {
-        edit.target(token.text_range());
+        edit.target(token.syntax().text_range());
         // parse inside string to escape `"`
-        let start_of_inside = usual_string_range.start().to_usize() + 1;
-        let end_of_inside = usual_string_range.end().to_usize();
-        let inside_str = &text[start_of_inside..end_of_inside];
-        let escaped = inside_str.escape_default().to_string();
-        edit.replace(token.text_range(), format!("\"{}\"", escaped));
+        let escaped = value.escape_default().to_string();
+        edit.replace(token.syntax().text_range(), format!("\"{}\"", escaped));
     })
 }
 
@@ -132,6 +112,7 @@ pub(crate) fn remove_hash(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
         edit.target(token.text_range());
         let result = &text[2..text.len() - 1];
         let result = if result.starts_with('\"') {
+            // FIXME: this logic is wrong, not only the last has has to handled specially
             // no more hash, escape
             let internal_str = &result[1..result.len() - 1];
             format!("\"{}\"", internal_str.escape_default().to_string())
@@ -154,20 +135,6 @@ fn count_hashes(s: &str) -> usize {
     max_hash_streak
 }
 
-fn find_usual_string_range(s: &str) -> Option<TextRange> {
-    let left_quote = s.find('"')?;
-    let right_quote = s.rfind('"')?;
-    if left_quote == right_quote {
-        // `s` only contains one quote
-        None
-    } else {
-        Some(TextRange::from_to(
-            TextUnit::from(left_quote as u32),
-            TextUnit::from(right_quote as u32),
-        ))
-    }
-}
-
 #[cfg(test)]
 mod test {
     use super::*;