use hir::Semantics;
use ide_db::{
- base_db::FilePosition,
- defs::{Definition, NameClass, NameRefClass},
+ base_db::{FileId, FilePosition},
+ defs::Definition,
helpers::{for_each_break_expr, for_each_tail_expr, node_ext::walk_expr, pick_best_token},
- search::{FileReference, ReferenceAccess, SearchScope},
+ search::{FileReference, ReferenceCategory, SearchScope},
RootDatabase,
};
use rustc_hash::FxHashSet;
use syntax::{
- ast::{self, LoopBodyOwner},
+ ast::{self, HasLoopBody},
match_ast, AstNode,
SyntaxKind::IDENT,
- SyntaxNode, SyntaxToken, TextRange, TextSize, T,
+ SyntaxNode, SyntaxToken, TextRange, T,
};
-use crate::{display::TryToNav, references, NavigationTarget};
+use crate::{references, NavigationTarget, TryToNav};
#[derive(PartialEq, Eq, Hash)]
pub struct HighlightedRange {
pub range: TextRange,
- pub access: Option<ReferenceAccess>,
+ // FIXME: This needs to be more precise. Reference category makes sense only
+ // for references, but we also have defs. And things like exit points are
+ // neither.
+ pub category: Option<ReferenceCategory>,
}
#[derive(Default, Clone)]
pub(crate) fn highlight_related(
sema: &Semantics<RootDatabase>,
config: HighlightRelatedConfig,
- position: FilePosition,
+ FilePosition { offset, file_id }: FilePosition,
) -> Option<Vec<HighlightedRange>> {
let _p = profile::span("highlight_related");
- let syntax = sema.parse(position.file_id).syntax().clone();
+ let syntax = sema.parse(file_id).syntax().clone();
- let token = pick_best_token(syntax.token_at_offset(position.offset), |kind| match kind {
+ let token = pick_best_token(syntax.token_at_offset(offset), |kind| match kind {
T![?] => 4, // prefer `?` when the cursor is sandwiched like in `await$0?`
T![->] => 3,
kind if kind.is_keyword() => 2,
highlight_break_points(token)
}
T![break] | T![loop] | T![while] if config.break_points => highlight_break_points(token),
- _ if config.references => highlight_references(sema, &syntax, position),
+ _ if config.references => highlight_references(sema, &syntax, token, file_id),
_ => None,
}
}
fn highlight_references(
sema: &Semantics<RootDatabase>,
- syntax: &SyntaxNode,
- FilePosition { offset, file_id }: FilePosition,
+ node: &SyntaxNode,
+ token: SyntaxToken,
+ file_id: FileId,
) -> Option<Vec<HighlightedRange>> {
- let defs = find_defs(sema, syntax, offset);
+ let defs = find_defs(sema, token.clone());
let usages = defs
.iter()
.filter_map(|&d| {
.remove(&file_id)
})
.flatten()
- .map(|FileReference { access, range, .. }| HighlightedRange { range, access });
+ .map(|FileReference { category: access, range, .. }| HighlightedRange {
+ range,
+ category: access,
+ });
let declarations = defs.iter().flat_map(|def| {
match def {
- &Definition::ModuleDef(hir::ModuleDef::Module(module)) => {
+ &Definition::Module(module) => {
Some(NavigationTarget::from_module_to_decl(sema.db, module))
}
def => def.try_to_nav(sema.db),
.filter(|decl| decl.file_id == file_id)
.and_then(|decl| {
let range = decl.focus_range?;
- let access = references::decl_access(&def, syntax, range);
- Some(HighlightedRange { range, access })
+ let category =
+ references::decl_mutability(&def, node, range).then(|| ReferenceCategory::Write);
+ Some(HighlightedRange { range, category })
})
});
walk_expr(&body, &mut |expr| match expr {
ast::Expr::ReturnExpr(expr) => {
if let Some(token) = expr.return_token() {
- highlights.push(HighlightedRange { access: None, range: token.text_range() });
+ highlights.push(HighlightedRange { category: None, range: token.text_range() });
}
}
ast::Expr::TryExpr(try_) => {
if let Some(token) = try_.question_mark_token() {
- highlights.push(HighlightedRange { access: None, range: token.text_range() });
+ highlights.push(HighlightedRange { category: None, range: token.text_range() });
}
}
ast::Expr::MethodCallExpr(_) | ast::Expr::CallExpr(_) | ast::Expr::MacroCall(_) => {
if sema.type_of_expr(&expr).map_or(false, |ty| ty.original.is_never()) {
- highlights
- .push(HighlightedRange { access: None, range: expr.syntax().text_range() });
+ highlights.push(HighlightedRange {
+ category: None,
+ range: expr.syntax().text_range(),
+ });
}
}
_ => (),
.map_or_else(|| tail.syntax().text_range(), |tok| tok.text_range()),
_ => tail.syntax().text_range(),
};
- highlights.push(HighlightedRange { access: None, range })
+ highlights.push(HighlightedRange { category: None, range })
});
}
Some(highlights)
token.map(|tok| tok.text_range()),
label.as_ref().map(|it| it.syntax().text_range()),
);
- highlights.extend(range.map(|range| HighlightedRange { access: None, range }));
+ highlights.extend(range.map(|range| HighlightedRange { category: None, range }));
for_each_break_expr(label, body, &mut |break_| {
let range = cover_range(
break_.break_token().map(|it| it.text_range()),
break_.lifetime().map(|it| it.syntax().text_range()),
);
- highlights.extend(range.map(|range| HighlightedRange { access: None, range }));
+ highlights.extend(range.map(|range| HighlightedRange { category: None, range }));
});
Some(highlights)
}
body: Option<ast::Expr>,
) -> Option<Vec<HighlightedRange>> {
let mut highlights =
- vec![HighlightedRange { access: None, range: async_token?.text_range() }];
+ vec![HighlightedRange { category: None, range: async_token?.text_range() }];
if let Some(body) = body {
walk_expr(&body, &mut |expr| {
if let ast::Expr::AwaitExpr(expr) = expr {
if let Some(token) = expr.await_token() {
highlights
- .push(HighlightedRange { access: None, range: token.text_range() });
+ .push(HighlightedRange { category: None, range: token.text_range() });
}
}
});
}
}
-fn find_defs(
- sema: &Semantics<RootDatabase>,
- syntax: &SyntaxNode,
- offset: TextSize,
-) -> FxHashSet<Definition> {
- sema.find_nodes_at_offset_with_descend(syntax, offset)
- .flat_map(|name_like| {
- Some(match name_like {
- ast::NameLike::NameRef(name_ref) => {
- match NameRefClass::classify(sema, &name_ref)? {
- NameRefClass::Definition(def) => vec![def],
- NameRefClass::FieldShorthand { local_ref, field_ref } => {
- vec![Definition::Local(local_ref), Definition::Field(field_ref)]
- }
- }
- }
- ast::NameLike::Name(name) => match NameClass::classify(sema, &name)? {
- NameClass::Definition(it) | NameClass::ConstReference(it) => vec![it],
- NameClass::PatFieldShorthand { local_def, field_ref } => {
- vec![Definition::Local(local_def), Definition::Field(field_ref)]
- }
- },
- ast::NameLike::Lifetime(lifetime) => {
- NameRefClass::classify_lifetime(sema, &lifetime)
- .and_then(|class| match class {
- NameRefClass::Definition(it) => Some(it),
- _ => None,
- })
- .or_else(|| {
- NameClass::classify_lifetime(sema, &lifetime)
- .and_then(NameClass::defined)
- })
- .map(|it| vec![it])?
- }
- })
- })
- .flatten()
+fn find_defs(sema: &Semantics<RootDatabase>, token: SyntaxToken) -> FxHashSet<Definition> {
+ sema.descend_into_macros(token)
+ .into_iter()
+ .flat_map(|token| Definition::from_token(sema, &token))
.collect()
}
fn check_with_config(ra_fixture: &str, config: HighlightRelatedConfig) {
let (analysis, pos, annotations) = fixture::annotations(ra_fixture);
- let hls = analysis.highlight_related(config, pos).unwrap().unwrap_or(Vec::default());
+ let hls = analysis.highlight_related(config, pos).unwrap().unwrap_or_default();
let mut expected = annotations
.into_iter()
.map(|hl| {
(
hl.range,
- hl.access.map(|it| {
+ hl.category.map(|it| {
match it {
- ReferenceAccess::Read => "read",
- ReferenceAccess::Write => "write",
+ ReferenceCategory::Read => "read",
+ ReferenceCategory::Write => "write",
}
.to_string()
}),