8 files changed, 263 insertions, 36 deletions

diff --git a/crates/ra_assists/src/assists/fill_match_arms.rs b/crates/ra_assists/src/assists/fill_match_arms.rs
index b75bd44eb..99d80998c 100644
--- a/crates/ra_assists/src/assists/fill_match_arms.rs
+++ b/crates/ra_assists/src/assists/fill_match_arms.rs
@@ -46,19 +46,24 @@ pub(crate) fn fill_match_arms(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist
     };
 
     let expr = match_expr.expr()?;
-    let enum_def = {
+    let (enum_def, module) = {
         let analyzer = ctx.source_analyzer(expr.syntax(), None);
-        resolve_enum_def(ctx.db, &analyzer, &expr)?
+        (resolve_enum_def(ctx.db, &analyzer, &expr)?, analyzer.module()?)
     };
-    let variant_list = enum_def.variant_list()?;
+    let variants = enum_def.variants(ctx.db);
+    if variants.is_empty() {
+        return None;
+    }
+
+    let db = ctx.db;
 
     ctx.add_assist(AssistId("fill_match_arms"), "fill match arms", |edit| {
         let indent_level = IndentLevel::from_node(match_arm_list.syntax());
 
         let new_arm_list = {
-            let variants = variant_list.variants();
             let arms = variants
-                .filter_map(build_pat)
+                .into_iter()
+                .filter_map(|variant| build_pat(db, module, variant))
                 .map(|pat| make::match_arm(iter::once(pat), make::expr_unit()));
             indent_level.increase_indent(make::match_arm_list(arms))
         };
@@ -80,23 +85,25 @@ fn resolve_enum_def(
     db: &impl HirDatabase,
     analyzer: &hir::SourceAnalyzer,
     expr: &ast::Expr,
-) -> Option<ast::EnumDef> {
+) -> Option<hir::Enum> {
     let expr_ty = analyzer.type_of(db, &expr)?;
 
-    let res = expr_ty.autoderef(db).find_map(|ty| match ty.as_adt() {
-        Some(Adt::Enum(e)) => Some(e.source(db).value),
+    let result = expr_ty.autoderef(db).find_map(|ty| match ty.as_adt() {
+        Some(Adt::Enum(e)) => Some(e),
         _ => None,
     });
-    res
+    result
 }
 
-fn build_pat(var: ast::EnumVariant) -> Option<ast::Pat> {
-    let path = make::path_qualified(
-        make::path_from_name_ref(make::name_ref(&var.parent_enum().name()?.syntax().to_string())),
-        make::name_ref(&var.name()?.syntax().to_string()),
-    );
+fn build_pat(
+    db: &impl HirDatabase,
+    module: hir::Module,
+    var: hir::EnumVariant,
+) -> Option<ast::Pat> {
+    let path = crate::ast_transform::path_to_ast(module.find_use_path(db, var.into())?);
 
-    let pat: ast::Pat = match var.kind() {
+    // FIXME: use HIR for this; it doesn't currently expose struct vs. tuple vs. unit variants though
+    let pat: ast::Pat = match var.source(db).value.kind() {
         ast::StructKind::Tuple(field_list) => {
             let pats =
                 iter::repeat(make::placeholder_pat().into()).take(field_list.fields().count());
@@ -106,7 +113,7 @@ fn build_pat(var: ast::EnumVariant) -> Option<ast::Pat> {
             let pats = field_list.fields().map(|f| make::bind_pat(f.name().unwrap()).into());
             make::record_pat(path, pats).into()
         }
-        ast::StructKind::Unit => make::path_pat(path).into(),
+        ast::StructKind::Unit => make::path_pat(path),
     };
 
     Some(pat)
@@ -252,4 +259,32 @@ mod tests {
             "#,
         );
     }
+
+    #[test]
+    fn fill_match_arms_qualifies_path() {
+        check_assist(
+            fill_match_arms,
+            r#"
+            mod foo { pub enum E { X, Y } }
+            use foo::E::X;
+
+            fn main() {
+                match X {
+                    <|>
+                }
+            }
+            "#,
+            r#"
+            mod foo { pub enum E { X, Y } }
+            use foo::E::X;
+
+            fn main() {
+                match <|>X {
+                    X => (),
+                    foo::E::Y => (),
+                }
+            }
+            "#,
+        );
+    }
 }
diff --git a/crates/ra_assists/src/ast_transform.rs b/crates/ra_assists/src/ast_transform.rs
index cbddc50ac..eac2903d1 100644
--- a/crates/ra_assists/src/ast_transform.rs
+++ b/crates/ra_assists/src/ast_transform.rs
@@ -173,7 +173,7 @@ impl<'a, DB: HirDatabase> AstTransform<'a> for QualifyPaths<'a, DB> {
     }
 }
 
-fn path_to_ast(path: hir::ModPath) -> ast::Path {
+pub(crate) fn path_to_ast(path: hir::ModPath) -> ast::Path {
     let parse = ast::SourceFile::parse(&path.to_string());
     parse.tree().syntax().descendants().find_map(ast::Path::cast).unwrap()
 }
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index df9c151e5..a177cebca 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -26,10 +26,11 @@ use hir_ty::{
 };
 use ra_db::{CrateId, Edition, FileId};
 use ra_prof::profile;
-use ra_syntax::ast;
+use ra_syntax::ast::{self, AttrsOwner};
 
 use crate::{
     db::{DefDatabase, HirDatabase},
+    has_source::HasSource,
     CallableDef, HirDisplay, InFile, Name,
 };
 
@@ -805,6 +806,27 @@ impl ImplBlock {
     pub fn krate(&self, db: &impl DefDatabase) -> Crate {
         Crate { id: self.module(db).id.krate }
     }
+
+    pub fn is_builtin_derive(&self, db: &impl DefDatabase) -> Option<InFile<ast::Attr>> {
+        let src = self.source(db);
+        let item = src.file_id.is_builtin_derive(db)?;
+        let hygenic = hir_expand::hygiene::Hygiene::new(db, item.file_id);
+
+        let attr = item
+            .value
+            .attrs()
+            .filter_map(|it| {
+                let path = hir_def::path::ModPath::from_src(it.path()?, &hygenic)?;
+                if path.as_ident()?.to_string() == "derive" {
+                    Some(it)
+                } else {
+                    None
+                }
+            })
+            .last()?;
+
+        Some(item.with_value(attr))
+    }
 }
 
 #[derive(Clone, PartialEq, Eq, Debug)]
diff --git a/crates/ra_hir_expand/src/lib.rs b/crates/ra_hir_expand/src/lib.rs
index 51c5f9623..7cf3b59a7 100644
--- a/crates/ra_hir_expand/src/lib.rs
+++ b/crates/ra_hir_expand/src/lib.rs
@@ -112,6 +112,21 @@ impl HirFileId {
             }
         }
     }
+
+    /// Indicate it is macro file generated for builtin derive
+    pub fn is_builtin_derive(&self, db: &dyn db::AstDatabase) -> Option<InFile<ast::ModuleItem>> {
+        match self.0 {
+            HirFileIdRepr::FileId(_) => None,
+            HirFileIdRepr::MacroFile(macro_file) => {
+                let loc: MacroCallLoc = db.lookup_intern_macro(macro_file.macro_call_id);
+                let item = match loc.def.kind {
+                    MacroDefKind::BuiltInDerive(_) => loc.kind.node(db),
+                    _ => return None,
+                };
+                Some(item.with_value(ast::ModuleItem::cast(item.value.clone())?))
+            }
+        }
+    }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
diff --git a/crates/ra_ide/src/display/navigation_target.rs b/crates/ra_ide/src/display/navigation_target.rs
index f2e45fa31..b2af3479c 100644
--- a/crates/ra_ide/src/display/navigation_target.rs
+++ b/crates/ra_ide/src/display/navigation_target.rs
@@ -251,7 +251,11 @@ impl ToNav for hir::Module {
 impl ToNav for hir::ImplBlock {
     fn to_nav(&self, db: &RootDatabase) -> NavigationTarget {
         let src = self.source(db);
-        let frange = original_range(db, src.as_ref().map(|it| it.syntax()));
+        let frange = if let Some(item) = self.is_builtin_derive(db) {
+            original_range(db, item.syntax())
+        } else {
+            original_range(db, src.as_ref().map(|it| it.syntax()))
+        };
 
         NavigationTarget::from_syntax(
             frange.file_id,
diff --git a/crates/ra_ide/src/extend_selection.rs b/crates/ra_ide/src/extend_selection.rs
index 1ec41a117..70b6fde82 100644
--- a/crates/ra_ide/src/extend_selection.rs
+++ b/crates/ra_ide/src/extend_selection.rs
@@ -4,20 +4,27 @@ use ra_db::SourceDatabase;
 use ra_syntax::{
     algo::find_covering_element,
     ast::{self, AstNode, AstToken},
-    Direction, NodeOrToken,
+    Direction, NodeOrToken, SyntaxElement,
     SyntaxKind::{self, *},
     SyntaxNode, SyntaxToken, TextRange, TextUnit, TokenAtOffset, T,
 };
 
-use crate::{db::RootDatabase, FileRange};
+use crate::{db::RootDatabase, expand::descend_into_macros, FileId, FileRange};
+use hir::db::AstDatabase;
+use std::iter::successors;
 
-// FIXME: restore macro support
 pub(crate) fn extend_selection(db: &RootDatabase, frange: FileRange) -> TextRange {
-    let parse = db.parse(frange.file_id);
-    try_extend_selection(parse.tree().syntax(), frange.range).unwrap_or(frange.range)
+    let src = db.parse(frange.file_id).tree();
+    try_extend_selection(db, src.syntax(), frange).unwrap_or(frange.range)
 }
 
-fn try_extend_selection(root: &SyntaxNode, range: TextRange) -> Option<TextRange> {
+fn try_extend_selection(
+    db: &RootDatabase,
+    root: &SyntaxNode,
+    frange: FileRange,
+) -> Option<TextRange> {
+    let range = frange.range;
+
     let string_kinds = [COMMENT, STRING, RAW_STRING, BYTE_STRING, RAW_BYTE_STRING];
     let list_kinds = [
         RECORD_FIELD_PAT_LIST,
@@ -72,12 +79,21 @@ fn try_extend_selection(root: &SyntaxNode, range: TextRange) -> Option<TextRange
         }
         NodeOrToken::Node(node) => node,
     };
+
+    // if we are in single token_tree, we maybe live in macro or attr
+    if node.kind() == TOKEN_TREE {
+        if let Some(macro_call) = node.ancestors().find_map(ast::MacroCall::cast) {
+            if let Some(range) = extend_tokens_from_range(db, frange.file_id, macro_call, range) {
+                return Some(range);
+            }
+        }
+    }
+
     if node.text_range() != range {
         return Some(node.text_range());
     }
 
-    // Using shallowest node with same range allows us to traverse siblings.
-    let node = node.ancestors().take_while(|n| n.text_range() == node.text_range()).last().unwrap();
+    let node = shallowest_node(&node.into()).unwrap();
 
     if node.parent().map(|n| list_kinds.contains(&n.kind())) == Some(true) {
         if let Some(range) = extend_list_item(&node) {
@@ -88,6 +104,94 @@ fn try_extend_selection(root: &SyntaxNode, range: TextRange) -> Option<TextRange
     node.parent().map(|it| it.text_range())
 }
 
+fn extend_tokens_from_range(
+    db: &RootDatabase,
+    file_id: FileId,
+    macro_call: ast::MacroCall,
+    original_range: TextRange,
+) -> Option<TextRange> {
+    let src = find_covering_element(&macro_call.syntax(), original_range);
+    let (first_token, last_token) = match src {
+        NodeOrToken::Node(it) => (it.first_token()?, it.last_token()?),
+        NodeOrToken::Token(it) => (it.clone(), it),
+    };
+
+    let mut first_token = skip_whitespace(first_token, Direction::Next)?;
+    let mut last_token = skip_whitespace(last_token, Direction::Prev)?;
+
+    while !first_token.text_range().is_subrange(&original_range) {
+        first_token = skip_whitespace(first_token.next_token()?, Direction::Next)?;
+    }
+    while !last_token.text_range().is_subrange(&original_range) {
+        last_token = skip_whitespace(last_token.prev_token()?, Direction::Prev)?;
+    }
+
+    // compute original mapped token range
+    let expanded = {
+        let first_node = descend_into_macros(db, file_id, first_token.clone());
+        let first_node = first_node.map(|it| it.text_range());
+
+        let last_node = descend_into_macros(db, file_id, last_token.clone());
+        if last_node.file_id == file_id.into() || first_node.file_id != last_node.file_id {
+            return None;
+        }
+        first_node.map(|it| union_range(it, last_node.value.text_range()))
+    };
+
+    // Compute parent node range
+    let src = db.parse_or_expand(expanded.file_id)?;
+    let parent = shallowest_node(&find_covering_element(&src, expanded.value))?.parent()?;
+
+    let validate = |token: SyntaxToken| {
+        let node = descend_into_macros(db, file_id, token.clone());
+        if node.file_id == expanded.file_id
+            && node.value.text_range().is_subrange(&parent.text_range())
+        {
+            Some(token)
+        } else {
+            None
+        }
+    };
+
+    // Find the first and last text range under expanded parent
+    let first = successors(Some(first_token), |token| {
+        validate(skip_whitespace(token.prev_token()?, Direction::Prev)?)
+    })
+    .last()?;
+    let last = successors(Some(last_token), |token| {
+        validate(skip_whitespace(token.next_token()?, Direction::Next)?)
+    })
+    .last()?;
+
+    let range = union_range(first.text_range(), last.text_range());
+    if original_range.is_subrange(&range) && original_range != range {
+        Some(range)
+    } else {
+        None
+    }
+}
+
+fn skip_whitespace(mut token: SyntaxToken, direction: Direction) -> Option<SyntaxToken> {
+    while token.kind() == WHITESPACE {
+        token = match direction {
+            Direction::Next => token.next_token()?,
+            Direction::Prev => token.prev_token()?,
+        }
+    }
+    Some(token)
+}
+
+fn union_range(range: TextRange, r: TextRange) -> TextRange {
+    let start = range.start().min(r.start());
+    let end = range.end().max(r.end());
+    TextRange::from_to(start, end)
+}
+
+/// Find the shallowest node with same range, which allows us to traverse siblings.
+fn shallowest_node(node: &SyntaxElement) -> Option<SyntaxNode> {
+    node.ancestors().take_while(|n| n.text_range() == node.text_range()).last()
+}
+
 fn extend_single_word_in_comment_or_string(
     leaf: &SyntaxToken,
     offset: TextUnit,
@@ -227,18 +331,19 @@ fn adj_comments(comment: &ast::Comment, dir: Direction) -> ast::Comment {
 
 #[cfg(test)]
 mod tests {
-    use ra_syntax::{AstNode, SourceFile};
-    use test_utils::extract_offset;
-
     use super::*;
+    use crate::mock_analysis::single_file;
+    use test_utils::extract_offset;
 
     fn do_check(before: &str, afters: &[&str]) {
         let (cursor, before) = extract_offset(before);
-        let parse = SourceFile::parse(&before);
-        let mut range = TextRange::offset_len(cursor, 0.into());
+        let (analysis, file_id) = single_file(&before);
+        let range = TextRange::offset_len(cursor, 0.into());
+        let mut frange = FileRange { file_id: file_id, range };
+
         for &after in afters {
-            range = try_extend_selection(parse.tree().syntax(), range).unwrap();
-            let actual = &before[range];
+            frange.range = analysis.extend_selection(frange).unwrap();
+            let actual = &before[frange.range];
             assert_eq!(after, actual);
         }
     }
@@ -503,4 +608,37 @@ fn main() { let var = (
             ],
         );
     }
+
+    #[test]
+    fn extend_selection_inside_macros() {
+        do_check(
+            r#"macro_rules! foo { ($item:item) => {$item} }
+                foo!{fn hello(na<|>me:usize){}}"#,
+            &[
+                "name",
+                "name:usize",
+                "(name:usize)",
+                "fn hello(name:usize){}",
+                "{fn hello(name:usize){}}",
+                "foo!{fn hello(name:usize){}}",
+            ],
+        );
+    }
+
+    #[test]
+    fn extend_selection_inside_recur_macros() {
+        do_check(
+            r#" macro_rules! foo2 { ($item:item) => {$item} }
+                macro_rules! foo { ($item:item) => {foo2!($item);} }
+                foo!{fn hello(na<|>me:usize){}}"#,
+            &[
+                "name",
+                "name:usize",
+                "(name:usize)",
+                "fn hello(name:usize){}",
+                "{fn hello(name:usize){}}",
+                "foo!{fn hello(name:usize){}}",
+            ],
+        );
+    }
 }
diff --git a/crates/ra_ide/src/impls.rs b/crates/ra_ide/src/impls.rs
index 9b165ee2a..31195036e 100644
--- a/crates/ra_ide/src/impls.rs
+++ b/crates/ra_ide/src/impls.rs
@@ -203,4 +203,16 @@ mod tests {
             ],
         );
     }
+
+    #[test]
+    fn goto_implementation_to_builtin_derive() {
+        check_goto(
+            "
+            //- /lib.rs
+            #[derive(Copy)]
+            struct Foo<|>;            
+            ",
+            &["impl IMPL_BLOCK FileId(1) [0; 15)"],
+        );
+    }
 }
diff --git a/crates/ra_syntax/src/ast/make.rs b/crates/ra_syntax/src/ast/make.rs
index 9781b748f..eef45090d 100644
--- a/crates/ra_syntax/src/ast/make.rs
+++ b/crates/ra_syntax/src/ast/make.rs
@@ -117,10 +117,11 @@ pub fn record_pat(path: ast::Path, pats: impl IntoIterator<Item = ast::Pat>) ->
     }
 }
 
-pub fn path_pat(path: ast::Path) -> ast::PathPat {
+/// Returns a `BindPat` if the path has just one segment, a `PathPat` otherwise.
+pub fn path_pat(path: ast::Path) -> ast::Pat {
     let path_str = path.syntax().text().to_string();
     return from_text(path_str.as_str());
-    fn from_text(text: &str) -> ast::PathPat {
+    fn from_text(text: &str) -> ast::Pat {
         ast_from_text(&format!("fn f({}: ())", text))
     }
 }