Render matched macro arm on hover of macro calls

Author: Veykril

crates/hir-expand/src/db.rs

@@ -313,16 +313,18 @@ fn parse_macro_expansion(
 let loc = db.lookup_intern_macro_call(macro_file.macro_call_id);
 let edition = loc.def.edition;
 let expand_to = loc.expand_to();
-let mbe::ValueResult{value: tt, err } = macro_expand(db, macro_file.macro_call_id, loc);
+let mbe::ValueResult{value:(tt, matched_arm), err } =
+macro_expand(db, macro_file.macro_call_id, loc);
 
-let(parse, rev_token_map) = token_tree_to_syntax_node(
+let(parse,mutrev_token_map) = token_tree_to_syntax_node(
 match&tt {
 CowArc::Arc(it) => it,
 CowArc::Owned(it) => it,
 },
  expand_to,
  edition,
 );
+ rev_token_map.matched_arm = matched_arm;
 
 ExpandResult{value:(parse,Arc::new(rev_token_map)), err }
 }
@@ -544,11 +546,13 @@ fn macro_expand(
 db:&dynExpandDatabase,
 macro_call_id:MacroCallId,
 loc:MacroCallLoc,
-) -> ExpandResult<CowArc<tt::Subtree>>{
+) -> ExpandResult<(CowArc<tt::Subtree>,Option<u32>)>{
 let _p = tracing::span!(tracing::Level::INFO,"macro_expand").entered();
 
-let(ExpandResult{value: tt, err }, span) = match loc.def.kind{
-MacroDefKind::ProcMacro(..) => return db.expand_proc_macro(macro_call_id).map(CowArc::Arc),
+let(ExpandResult{value:(tt, matched_arm), err }, span) = match loc.def.kind{
+MacroDefKind::ProcMacro(..) => {
+return db.expand_proc_macro(macro_call_id).map(CowArc::Arc).zip_val(None)
+}
  _ => {
 let(macro_arg, undo_info, span) =
  db.macro_arg_considering_derives(macro_call_id,&loc.kind);
@@ -560,10 +564,10 @@ fn macro_expand(
 .decl_macro_expander(loc.def.krate, id)
 .expand(db, arg.clone(), macro_call_id, span),
 MacroDefKind::BuiltIn(it, _) => {
- it.expand(db, macro_call_id, arg, span).map_err(Into::into)
+ it.expand(db, macro_call_id, arg, span).map_err(Into::into).zip_val(None)
 }
 MacroDefKind::BuiltInDerive(it, _) => {
- it.expand(db, macro_call_id, arg, span).map_err(Into::into)
+ it.expand(db, macro_call_id, arg, span).map_err(Into::into).zip_val(None)
 }
 MacroDefKind::BuiltInEager(it, _) => {
 // This might look a bit odd, but we do not expand the inputs to eager macros here.
@@ -574,7 +578,8 @@ fn macro_expand(
 // As such we just return the input subtree here.
 let eager = match&loc.kind{
 MacroCallKind::FnLike{eager:None, .. } => {
-returnExpandResult::ok(CowArc::Arc(macro_arg.clone()));
+returnExpandResult::ok(CowArc::Arc(macro_arg.clone()))
+.zip_val(None);
 }
 MacroCallKind::FnLike{eager:Some(eager), .. } => Some(&**eager),
  _ => None,
@@ -586,12 +591,12 @@ fn macro_expand(
 // FIXME: We should report both errors!
  res.err = error.clone().or(res.err);
 }
- res
+ res.zip_val(None)
 }
 MacroDefKind::BuiltInAttr(it, _) => {
 letmut res = it.expand(db, macro_call_id, arg, span);
  fixup::reverse_fixups(&mut res.value,&undo_info);
- res
+ res.zip_val(None)
 }
  _ => unreachable!(),
 };
@@ -603,16 +608,18 @@ fn macro_expand(
 if !loc.def.is_include(){
 // Set a hard limit for the expanded tt
 ifletErr(value) = check_tt_count(&tt){
-return value.map(|()| {
-CowArc::Owned(tt::Subtree{
-delimiter: tt::Delimiter::invisible_spanned(span),
-token_trees:Box::new([]),
+return value
+.map(|()| {
+CowArc::Owned(tt::Subtree{
+delimiter: tt::Delimiter::invisible_spanned(span),
+token_trees:Box::new([]),
+})
 })
-});
+.zip_val(matched_arm);
 }
 }
 
-ExpandResult{value:CowArc::Owned(tt), err }
+ExpandResult{value:(CowArc::Owned(tt), matched_arm), err }
 }
 
 fnproc_macro_span(db:&dynExpandDatabase,ast:AstId<ast::Fn>) -> Span{

crates/hir-expand/src/declarative.rs

@@ -3,6 +3,7 @@ use std::sync::OnceLock;
 
 use base_db::{CrateId,VersionReq};
 use span::{Edition,MacroCallId,Span,SyntaxContextId};
+use stdx::TupleExt;
 use syntax::{ast,AstNode};
 use triomphe::Arc;
 
@@ -30,7 +31,7 @@ impl DeclarativeMacroExpander {
 tt: tt::Subtree,
 call_id:MacroCallId,
 span:Span,
-) -> ExpandResult<tt::Subtree>{
+) -> ExpandResult<(tt::Subtree,Option<u32>)>{
 let loc = db.lookup_intern_macro_call(call_id);
 let toolchain = db.toolchain(loc.def.krate);
 let new_meta_vars = toolchain.as_ref().map_or(false, |version| {
@@ -46,7 +47,7 @@ impl DeclarativeMacroExpander {
 });
 matchself.mac.err(){
 Some(_) => ExpandResult::new(
- tt::Subtree::empty(tt::DelimSpan{open: span,close: span }),
+(tt::Subtree::empty(tt::DelimSpan{open: span,close: span }),None),
 ExpandError::MacroDefinition,
 ),
 None => self
@@ -90,6 +91,7 @@ impl DeclarativeMacroExpander {
 None => self
 .mac
 .expand(&tt, |_| (), new_meta_vars, call_site, def_site_edition)
+.map(TupleExt::head)
 .map_err(Into::into),
 }
 }

crates/hir/src/semantics.rs

@@ -1246,6 +1246,17 @@ impl<'db> SemanticsImpl<'db> {
 .map_or(false, |m| matches!(m.id,MacroId::ProcMacroId(..)))
 }
 
+pubfnresolve_macro_call_arm(&self,macro_call:&ast::MacroCall) -> Option<u32>{
+let sa = self.analyze(macro_call.syntax())?;
+self.db
+.parse_macro_expansion(
+ sa.expand(self.db,self.wrap_node_infile(macro_call.clone()).as_ref())?,
+)
+.value
+.1
+.matched_arm
+}
+
 pubfnis_unsafe_macro_call(&self,macro_call:&ast::MacroCall) -> bool{
 let sa = matchself.analyze(macro_call.syntax()){
 Some(it) => it,

crates/ide/src/hover.rs

@@ -14,7 +14,7 @@ use ide_db::{
  helpers::pick_best_token,
 FxIndexSet,RootDatabase,
 };
-use itertools::Itertools;
+use itertools::{multizip,Itertools};
 use syntax::{ast, match_ast,AstNode,AstToken,SyntaxKind::*,SyntaxNode,T};
 
 usecrate::{
@@ -149,7 +149,7 @@ fn hover_simple(
 ifletSome(doc_comment) = token_as_doc_comment(&original_token){
  cov_mark::hit!(no_highlight_on_comment_hover);
 return doc_comment.get_definition_with_descend_at(sema, offset, |def, node, range| {
-let res = hover_for_definition(sema, file_id, def,&node, config);
+let res = hover_for_definition(sema, file_id, def,&node,None,config);
 Some(RangeInfo::new(range, res))
 });
 }
@@ -162,6 +162,7 @@ fn hover_simple(
  file_id,
 Definition::from(resolution?),
 &original_token.parent()?,
+None,
  config,
 );
 returnSome(RangeInfo::new(range, res));
@@ -196,6 +197,29 @@ fn hover_simple(
 descended()
 .filter_map(|token| {
 let node = token.parent()?;
+
+// special case macro calls, we wanna render the invoked arm index
+ifletSome(name) = ast::NameRef::cast(node.clone()){
+ifletSome(path_seg) =
+ name.syntax().parent().and_then(ast::PathSegment::cast)
+{
+ifletSome(macro_call) = path_seg
+.parent_path()
+.syntax()
+.parent()
+.and_then(ast::MacroCall::cast)
+{
+ifletSome(macro_) = sema.resolve_macro_call(&macro_call){
+returnSome(vec![(
+Definition::Macro(macro_),
+ sema.resolve_macro_call_arm(&macro_call),
+ node,
+)]);
+}
+}
+}
+}
+
 matchIdentClass::classify_node(sema,&node)? {
 // It's better for us to fall back to the keyword hover here,
 // rendering poll is very confusing
@@ -204,20 +228,19 @@ fn hover_simple(
 IdentClass::NameRefClass(NameRefClass::ExternCrateShorthand{
  decl,
  ..
-}) => Some(vec![(Definition::ExternCrateDecl(decl), node)]),
+}) => Some(vec![(Definition::ExternCrateDecl(decl),None,node)]),
 
  class => Some(
- class
-.definitions()
-.into_iter()
-.zip(iter::repeat(node))
+multizip((class.definitions(), iter::repeat(None), iter::repeat(node)))
 .collect::<Vec<_>>(),
 ),
 }
 })
 .flatten()
-.unique_by(|&(def, _)| def)
-.map(|(def, node)| hover_for_definition(sema, file_id, def,&node, config))
+.unique_by(|&(def, _, _)| def)
+.map(|(def, macro_arm, node)| {
+hover_for_definition(sema, file_id, def,&node, macro_arm, config)
+})
 .reduce(|mutacc:HoverResult,HoverResult{ markup, actions }| {
  acc.actions.extend(actions);
  acc.markup = Markup::from(format!("{}\n---\n{markup}", acc.markup));
@@ -374,6 +397,7 @@ pub(crate) fn hover_for_definition(
 file_id:FileId,
 def:Definition,
 scope_node:&SyntaxNode,
+macro_arm:Option<u32>,
 config:&HoverConfig,
 ) -> HoverResult{
 let famous_defs = match&def {
@@ -398,7 +422,8 @@ pub(crate) fn hover_for_definition(
 };
 let notable_traits = def_ty.map(|ty| notable_traits(db,&ty)).unwrap_or_default();
 
-let markup = render::definition(sema.db, def, famous_defs.as_ref(),&notable_traits, config);
+let markup =
+ render::definition(sema.db, def, famous_defs.as_ref(),&notable_traits, macro_arm, config);
 HoverResult{
 markup: render::process_markup(sema.db, def,&markup, config),
 actions:[

crates/ide/src/hover/render.rs

@@ -403,6 +403,7 @@ pub(super) fn definition(
 def:Definition,
 famous_defs:Option<&FamousDefs<'_,'_>>,
 notable_traits:&[(Trait,Vec<(Option<Type>,Name)>)],
+macro_arm:Option<u32>,
 config:&HoverConfig,
 ) -> Markup{
 let mod_path = definition_mod_path(db,&def);
@@ -413,6 +414,13 @@ pub(super) fn definition(
 Definition::Adt(Adt::Struct(struct_)) => {
  struct_.display_limited(db, config.max_struct_field_count).to_string()
 }
+Definition::Macro(it) => {
+letmut label = it.display(db).to_string();
+ifletSome(macro_arm) = macro_arm {
+format_to!(label," // matched arm #{}", macro_arm);
+}
+ label
+}
  _ => def.label(db),
 };
 let docs = def.docs(db, famous_defs);

crates/ide/src/hover/tests.rs

@@ -1560,21 +1560,21 @@ fn y() {
 fntest_hover_macro_invocation(){
 check(
 r#"
-macro_rules! foo { () => {} }
+macro_rules! foo { (a) => {}; () => {} }
 
 fn f() { fo$0o!(); }
 "#,
 expect![[r#"
-*foo*
+ *foo*
 
-```rust
-test
-```
+ ```rust
+ test
+ ```
 
-```rust
- macro_rules! foo
-```
-"#]],
+ ```rust
+macro_rules! foo // matched arm #1
+ ```
+ "#]],
 )
 }
 
@@ -1590,22 +1590,22 @@ macro foo() {}
 fn f() { fo$0o!(); }
 "#,
 expect![[r#"
-*foo*
+ *foo*
 
-```rust
-test
-```
+ ```rust
+ test
+ ```
 
-```rust
- macro foo
-```
+ ```rust
+macro foo // matched arm #0
+ ```
 
----
+ ---
 
-foo bar
+ foo bar
 
-foo bar baz
-"#]],
+ foo bar baz
+ "#]],
 )
 }
 

crates/ide/src/static_index.rs

@@ -188,7 +188,14 @@ impl StaticIndex<'_> {
 }else{
 let it = self.tokens.insert(TokenStaticData{
 documentation:documentation_for_definition(&sema, def,&node),
-hover:Some(hover_for_definition(&sema, file_id, def,&node,&hover_config)),
+hover:Some(hover_for_definition(
+&sema,
+ file_id,
+ def,
+&node,
+None,
+&hover_config,
+)),
 definition: def.try_to_nav(self.db).map(UpmappingResult::call_site).map(|it| {
 FileRange{file_id: it.file_id,range: it.focus_or_full_range()}
 }),

crates/mbe/src/benchmark.rs

@@ -48,7 +48,7 @@ fn benchmark_expand_macro_rules() {
 .map(|(id, tt)| {
 let res = rules[&id].expand(&tt, |_| (),true,DUMMY,Edition::CURRENT);
 assert!(res.err.is_none());
- res.value.token_trees.len()
+ res.value.0.token_trees.len()
 })
 .sum()
 };