Mirrors/rust-analyzer
2
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer synced 2024-12-27 05:23:24 +00:00
Code Issues Projects Releases Packages Wiki Activity

internal: Filter out opaque tokens in some of IDE feature macro descensions

Browse source
This commit is contained in:
Lukas Wirth 2024-10-04 11:08:11 +02:00
parent ac4edbf9dc
commit 24d65bb7cf
11 changed files with 114 additions and 70 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

17
crates/hir-expand/src/db.rs
View file

@ -16,7 +16,10 @@ use crate::{
cfg_process, cfg_process,
declarative::DeclarativeMacroExpander, declarative::DeclarativeMacroExpander,
fixup::{self, SyntaxFixupUndoInfo}, fixup::{self, SyntaxFixupUndoInfo},
hygiene::{span_with_call_site_ctxt, span_with_def_site_ctxt, span_with_mixed_site_ctxt}, hygiene::{
span_with_call_site_ctxt, span_with_def_site_ctxt, span_with_mixed_site_ctxt,
SyntaxContextExt as _,
},
proc_macro::ProcMacros, proc_macro::ProcMacros,
span_map::{RealSpanMap, SpanMap, SpanMapRef}, span_map::{RealSpanMap, SpanMap, SpanMapRef},
tt, AstId, BuiltinAttrExpander, BuiltinDeriveExpander, BuiltinFnLikeExpander, tt, AstId, BuiltinAttrExpander, BuiltinDeriveExpander, BuiltinFnLikeExpander,
@ -300,14 +303,16 @@ pub fn expand_speculative(
token_tree_to_syntax_node(&speculative_expansion.value, expand_to, loc.def.edition); token_tree_to_syntax_node(&speculative_expansion.value, expand_to, loc.def.edition);
let syntax_node = node.syntax_node(); let syntax_node = node.syntax_node();
let token = rev_tmap let (token, _) = rev_tmap
.ranges_with_span(span_map.span_for_range(token_to_map.text_range())) .ranges_with_span(span_map.span_for_range(token_to_map.text_range()))
.filter_map(|range| syntax_node.covering_element(range).into_token()) .filter_map(|(range, ctx)| syntax_node.covering_element(range).into_token().zip(Some(ctx)))
.min_by_key(|t| { .min_by_key(|(t, ctx)| {
// prefer tokens of the same kind and text // prefer tokens of the same kind and text, as well as non opaque marked ones
// Note the inversion of the score here, as we want to prefer the first token in case // Note the inversion of the score here, as we want to prefer the first token in case
// of all tokens having the same score // of all tokens having the same score
(t.kind() != token_to_map.kind()) as u8 + 2 * ((t.text() != token_to_map.text()) as u8) ctx.is_opaque(db) as u8
+ 2 * (t.kind() != token_to_map.kind()) as u8
+ 4 * ((t.text() != token_to_map.text()) as u8)
})?; })?;
Some((node.syntax_node(), token)) Some((node.syntax_node(), token))
} }

4
crates/hir-expand/src/hygiene.rs
View file

@ -151,6 +151,7 @@ pub trait SyntaxContextExt {
fn remove_mark(&mut self, db: &dyn ExpandDatabase) -> (Option<MacroCallId>, Transparency); fn remove_mark(&mut self, db: &dyn ExpandDatabase) -> (Option<MacroCallId>, Transparency);
fn outer_mark(self, db: &dyn ExpandDatabase) -> (Option<MacroCallId>, Transparency); fn outer_mark(self, db: &dyn ExpandDatabase) -> (Option<MacroCallId>, Transparency);
fn marks(self, db: &dyn ExpandDatabase) -> Vec<(MacroCallId, Transparency)>; fn marks(self, db: &dyn ExpandDatabase) -> Vec<(MacroCallId, Transparency)>;
fn is_opaque(self, db: &dyn ExpandDatabase) -> bool;
} }
impl SyntaxContextExt for SyntaxContextId { impl SyntaxContextExt for SyntaxContextId {
@ -177,6 +178,9 @@ impl SyntaxContextExt for SyntaxContextId {
marks.reverse(); marks.reverse();
marks marks
} }
fn is_opaque(self, db: &dyn ExpandDatabase) -> bool {
!self.is_root() && db.lookup_intern_syntax_context(self).outer_transparency.is_opaque()
}
} }
// FIXME: Make this a SyntaxContextExt method once we have RPIT // FIXME: Make this a SyntaxContextExt method once we have RPIT

24
crates/hir-expand/src/lib.rs
View file

@ -25,6 +25,7 @@ mod prettify_macro_expansion_;
use attrs::collect_attrs; use attrs::collect_attrs;
use rustc_hash::FxHashMap; use rustc_hash::FxHashMap;
use stdx::TupleExt;
use triomphe::Arc; use triomphe::Arc;
use std::hash::Hash; use std::hash::Hash;
@ -772,14 +773,15 @@ impl ExpansionInfo {
/// Maps the passed in file range down into a macro expansion if it is the input to a macro call. /// Maps the passed in file range down into a macro expansion if it is the input to a macro call.
/// ///
/// Note this does a linear search through the entire backing vector of the spanmap. /// Note this does a linear search through the entire backing vector of the spanmap.
// FIXME: Consider adding a reverse map to ExpansionInfo to get rid of the linear search which
// potentially results in quadratic look ups (notably this might improve semantic highlighting perf)
pub fn map_range_down_exact( pub fn map_range_down_exact(
&self, &self,
span: Span, span: Span,
) -> Option<InMacroFile<impl Iterator<Item = SyntaxToken> + '_>> { ) -> Option<InMacroFile<impl Iterator<Item = (SyntaxToken, SyntaxContextId)> + '_>> {
let tokens = self let tokens = self.exp_map.ranges_with_span_exact(span).flat_map(move |(range, ctx)| {
.exp_map self.expanded.value.covering_element(range).into_token().zip(Some(ctx))
.ranges_with_span_exact(span) });
.flat_map(move |range| self.expanded.value.covering_element(range).into_token());
Some(InMacroFile::new(self.expanded.file_id, tokens)) Some(InMacroFile::new(self.expanded.file_id, tokens))
} }
@ -791,11 +793,10 @@ impl ExpansionInfo {
pub fn map_range_down( pub fn map_range_down(
&self, &self,
span: Span, span: Span,
) -> Option<InMacroFile<impl Iterator<Item = SyntaxToken> + '_>> { ) -> Option<InMacroFile<impl Iterator<Item = (SyntaxToken, SyntaxContextId)> + '_>> {
let tokens = self let tokens = self.exp_map.ranges_with_span(span).flat_map(move |(range, ctx)| {
.exp_map self.expanded.value.covering_element(range).into_token().zip(Some(ctx))
.ranges_with_span(span) });
.flat_map(move |range| self.expanded.value.covering_element(range).into_token());
Some(InMacroFile::new(self.expanded.file_id, tokens)) Some(InMacroFile::new(self.expanded.file_id, tokens))
} }
@ -845,7 +846,8 @@ impl ExpansionInfo {
self.arg.file_id, self.arg.file_id,
arg_map arg_map
.ranges_with_span_exact(span) .ranges_with_span_exact(span)
.filter(|range| range.intersect(arg_range).is_some()) .filter(|(range, _)| range.intersect(arg_range).is_some())
.map(TupleExt::head)
.collect(), .collect(),
) )
} }

100
crates/hir/src/semantics.rs
View file

@ -24,6 +24,7 @@ use hir_expand::{
builtin::{BuiltinFnLikeExpander, EagerExpander}, builtin::{BuiltinFnLikeExpander, EagerExpander},
db::ExpandDatabase, db::ExpandDatabase,
files::InRealFile, files::InRealFile,
hygiene::SyntaxContextExt as _,
inert_attr_macro::find_builtin_attr_idx, inert_attr_macro::find_builtin_attr_idx,
name::AsName, name::AsName,
FileRange, InMacroFile, MacroCallId, MacroFileId, MacroFileIdExt, FileRange, InMacroFile, MacroCallId, MacroFileId, MacroFileIdExt,
@ -32,7 +33,7 @@ use intern::Symbol;
use itertools::Itertools; use itertools::Itertools;
use rustc_hash::{FxHashMap, FxHashSet}; use rustc_hash::{FxHashMap, FxHashSet};
use smallvec::{smallvec, SmallVec}; use smallvec::{smallvec, SmallVec};
use span::{EditionedFileId, FileId, HirFileIdRepr}; use span::{EditionedFileId, FileId, HirFileIdRepr, SyntaxContextId};
use stdx::TupleExt; use stdx::TupleExt;
use syntax::{ use syntax::{
algo::skip_trivia_token, algo::skip_trivia_token,
@ -608,7 +609,7 @@ impl<'db> SemanticsImpl<'db> {
let quote = string.open_quote_text_range()?; let quote = string.open_quote_text_range()?;
let token = self.wrap_token_infile(string.syntax().clone()).into_real_file().ok()?; let token = self.wrap_token_infile(string.syntax().clone()).into_real_file().ok()?;
self.descend_into_macros_breakable(token, |token| { self.descend_into_macros_breakable(token, |token, _| {
(|| { (|| {
let token = token.value; let token = token.value;
let string = ast::String::cast(token)?; let string = ast::String::cast(token)?;
@ -655,7 +656,7 @@ impl<'db> SemanticsImpl<'db> {
let original_string = ast::String::cast(original_token.clone())?; let original_string = ast::String::cast(original_token.clone())?;
let original_token = self.wrap_token_infile(original_token).into_real_file().ok()?; let original_token = self.wrap_token_infile(original_token).into_real_file().ok()?;
let quote = original_string.open_quote_text_range()?; let quote = original_string.open_quote_text_range()?;
self.descend_into_macros_breakable(original_token, |token| { self.descend_into_macros_breakable(original_token, |token, _| {
(|| { (|| {
let token = token.value; let token = token.value;
self.resolve_offset_in_format_args( self.resolve_offset_in_format_args(
@ -718,7 +719,7 @@ impl<'db> SemanticsImpl<'db> {
// node is just the token, so descend the token // node is just the token, so descend the token
self.descend_into_macros_impl( self.descend_into_macros_impl(
InRealFile::new(file_id, first), InRealFile::new(file_id, first),
&mut |InFile { value, .. }| { &mut |InFile { value, .. }, _ctx| {
if let Some(node) = value if let Some(node) = value
.parent_ancestors() .parent_ancestors()
.take_while(|it| it.text_range() == value.text_range()) .take_while(|it| it.text_range() == value.text_range())
@ -732,7 +733,7 @@ impl<'db> SemanticsImpl<'db> {
} else { } else {
// Descend first and last token, then zip them to look for the node they belong to // Descend first and last token, then zip them to look for the node they belong to
let mut scratch: SmallVec<[_; 1]> = smallvec![]; let mut scratch: SmallVec<[_; 1]> = smallvec![];
self.descend_into_macros_impl(InRealFile::new(file_id, first), &mut |token| { self.descend_into_macros_impl(InRealFile::new(file_id, first), &mut |token, _ctx| {
scratch.push(token); scratch.push(token);
CONTINUE_NO_BREAKS CONTINUE_NO_BREAKS
}); });
@ -740,7 +741,7 @@ impl<'db> SemanticsImpl<'db> {
let mut scratch = scratch.into_iter(); let mut scratch = scratch.into_iter();
self.descend_into_macros_impl( self.descend_into_macros_impl(
InRealFile::new(file_id, last), InRealFile::new(file_id, last),
&mut |InFile { value: last, file_id: last_fid }| { &mut |InFile { value: last, file_id: last_fid }, _ctx| {
if let Some(InFile { value: first, file_id: first_fid }) = scratch.next() { if let Some(InFile { value: first, file_id: first_fid }) = scratch.next() {
if first_fid == last_fid { if first_fid == last_fid {
if let Some(p) = first.parent() { if let Some(p) = first.parent() {
@ -763,7 +764,9 @@ impl<'db> SemanticsImpl<'db> {
res res
} }
fn is_inside_macro_call(token: &SyntaxToken) -> bool { // FIXME: This isn't quite right wrt to inner attributes
/// Does a syntactic traversal to check whether this token might be inside a macro call
pub fn might_be_inside_macro_call(&self, token: &SyntaxToken) -> bool {
token.parent_ancestors().any(|ancestor| { token.parent_ancestors().any(|ancestor| {
if ast::MacroCall::can_cast(ancestor.kind()) { if ast::MacroCall::can_cast(ancestor.kind()) {
return true; return true;
@ -781,25 +784,14 @@ impl<'db> SemanticsImpl<'db> {
}) })
} }
pub fn descend_into_macros_exact_if_in_macro(
&self,
token: SyntaxToken,
) -> SmallVec<[SyntaxToken; 1]> {
if Self::is_inside_macro_call(&token) {
self.descend_into_macros_exact(token)
} else {
smallvec![token]
}
}
pub fn descend_into_macros_cb( pub fn descend_into_macros_cb(
&self, &self,
token: SyntaxToken, token: SyntaxToken,
mut cb: impl FnMut(InFile<SyntaxToken>), mut cb: impl FnMut(InFile<SyntaxToken>, SyntaxContextId),
) { ) {
if let Ok(token) = self.wrap_token_infile(token).into_real_file() { if let Ok(token) = self.wrap_token_infile(token).into_real_file() {
self.descend_into_macros_impl(token, &mut |t| { self.descend_into_macros_impl(token, &mut |t, ctx| {
cb(t); cb(t, ctx);
CONTINUE_NO_BREAKS CONTINUE_NO_BREAKS
}); });
} }
@ -808,7 +800,7 @@ impl<'db> SemanticsImpl<'db> {
pub fn descend_into_macros(&self, token: SyntaxToken) -> SmallVec<[SyntaxToken; 1]> { pub fn descend_into_macros(&self, token: SyntaxToken) -> SmallVec<[SyntaxToken; 1]> {
let mut res = smallvec![]; let mut res = smallvec![];
if let Ok(token) = self.wrap_token_infile(token.clone()).into_real_file() { if let Ok(token) = self.wrap_token_infile(token.clone()).into_real_file() {
self.descend_into_macros_impl(token, &mut |t| { self.descend_into_macros_impl(token, &mut |t, _ctx| {
res.push(t.value); res.push(t.value);
CONTINUE_NO_BREAKS CONTINUE_NO_BREAKS
}); });
@ -819,10 +811,27 @@ impl<'db> SemanticsImpl<'db> {
res res
} }
pub fn descend_into_macros_no_opaque(&self, token: SyntaxToken) -> SmallVec<[SyntaxToken; 1]> {
let mut res = smallvec![];
if let Ok(token) = self.wrap_token_infile(token.clone()).into_real_file() {
self.descend_into_macros_impl(token, &mut |t, ctx| {
if !ctx.is_opaque(self.db.upcast()) {
// Don't descend into opaque contexts
res.push(t.value);
}
CONTINUE_NO_BREAKS
});
}
if res.is_empty() {
res.push(token);
}
res
}
pub fn descend_into_macros_breakable<T>( pub fn descend_into_macros_breakable<T>(
&self, &self,
token: InRealFile<SyntaxToken>, token: InRealFile<SyntaxToken>,
mut cb: impl FnMut(InFile<SyntaxToken>) -> ControlFlow<T>, mut cb: impl FnMut(InFile<SyntaxToken>, SyntaxContextId) -> ControlFlow<T>,
) -> Option<T> { ) -> Option<T> {
self.descend_into_macros_impl(token.clone(), &mut cb) self.descend_into_macros_impl(token.clone(), &mut cb)
} }
@ -834,10 +843,12 @@ impl<'db> SemanticsImpl<'db> {
let text = token.text(); let text = token.text();
let kind = token.kind(); let kind = token.kind();
self.descend_into_macros_cb(token.clone(), |InFile { value, file_id: _ }| { self.descend_into_macros_cb(token.clone(), |InFile { value, file_id: _ }, ctx| {
let mapped_kind = value.kind(); let mapped_kind = value.kind();
let any_ident_match = || kind.is_any_identifier() && value.kind().is_any_identifier(); let any_ident_match = || kind.is_any_identifier() && value.kind().is_any_identifier();
let matches = (kind == mapped_kind || any_ident_match()) && text == value.text(); let matches = (kind == mapped_kind || any_ident_match())
&& text == value.text()
&& !ctx.is_opaque(self.db.upcast());
if matches { if matches {
r.push(value); r.push(value);
} }
@ -854,17 +865,21 @@ impl<'db> SemanticsImpl<'db> {
let text = token.text(); let text = token.text();
let kind = token.kind(); let kind = token.kind();
if let Ok(token) = self.wrap_token_infile(token.clone()).into_real_file() { if let Ok(token) = self.wrap_token_infile(token.clone()).into_real_file() {
self.descend_into_macros_breakable(token.clone(), |InFile { value, file_id: _ }| { self.descend_into_macros_breakable(
let mapped_kind = value.kind(); token.clone(),
let any_ident_match = |InFile { value, file_id: _ }, _ctx| {
|| kind.is_any_identifier() && value.kind().is_any_identifier(); let mapped_kind = value.kind();
let matches = (kind == mapped_kind || any_ident_match()) && text == value.text(); let any_ident_match =
if matches { || kind.is_any_identifier() && value.kind().is_any_identifier();
ControlFlow::Break(value) let matches =
} else { (kind == mapped_kind || any_ident_match()) && text == value.text();
ControlFlow::Continue(()) if matches {
} ControlFlow::Break(value)
}) } else {
ControlFlow::Continue(())
}
},
)
} else { } else {
None None
} }
@ -874,7 +889,7 @@ impl<'db> SemanticsImpl<'db> {
fn descend_into_macros_impl<T>( fn descend_into_macros_impl<T>(
&self, &self,
InRealFile { value: token, file_id }: InRealFile<SyntaxToken>, InRealFile { value: token, file_id }: InRealFile<SyntaxToken>,
f: &mut dyn FnMut(InFile<SyntaxToken>) -> ControlFlow<T>, f: &mut dyn FnMut(InFile<SyntaxToken>, SyntaxContextId) -> ControlFlow<T>,
) -> Option<T> { ) -> Option<T> {
let _p = tracing::info_span!("descend_into_macros_impl").entered(); let _p = tracing::info_span!("descend_into_macros_impl").entered();
let (sa, span, file_id) = token let (sa, span, file_id) = token
@ -898,7 +913,8 @@ impl<'db> SemanticsImpl<'db> {
// These are tracked to know which macro calls we still have to look into // These are tracked to know which macro calls we still have to look into
// the tokens themselves aren't that interesting as the span that is being used to map // the tokens themselves aren't that interesting as the span that is being used to map
// things down never changes. // things down never changes.
let mut stack: Vec<(_, SmallVec<[_; 2]>)> = vec![(file_id, smallvec![token])]; let mut stack: Vec<(_, SmallVec<[_; 2]>)> =
vec![(file_id, smallvec![(token, SyntaxContextId::ROOT)])];
// Process the expansion of a call, pushing all tokens with our span in the expansion back onto our stack // Process the expansion of a call, pushing all tokens with our span in the expansion back onto our stack
let process_expansion_for_token = |stack: &mut Vec<_>, macro_file| { let process_expansion_for_token = |stack: &mut Vec<_>, macro_file| {
@ -921,11 +937,11 @@ impl<'db> SemanticsImpl<'db> {
// Filters out all tokens that contain the given range (usually the macro call), any such // Filters out all tokens that contain the given range (usually the macro call), any such
// token is redundant as the corresponding macro call has already been processed // token is redundant as the corresponding macro call has already been processed
let filter_duplicates = |tokens: &mut SmallVec<_>, range: TextRange| { let filter_duplicates = |tokens: &mut SmallVec<_>, range: TextRange| {
tokens.retain(|t: &mut SyntaxToken| !range.contains_range(t.text_range())) tokens.retain(|(t, _): &mut (SyntaxToken, _)| !range.contains_range(t.text_range()))
}; };
while let Some((expansion, ref mut tokens)) = stack.pop() { while let Some((expansion, ref mut tokens)) = stack.pop() {
while let Some(token) = tokens.pop() { while let Some((token, ctx)) = tokens.pop() {
let was_not_remapped = (|| { let was_not_remapped = (|| {
// First expand into attribute invocations // First expand into attribute invocations
let containing_attribute_macro_call = self.with_ctx(|ctx| { let containing_attribute_macro_call = self.with_ctx(|ctx| {
@ -1036,7 +1052,7 @@ impl<'db> SemanticsImpl<'db> {
let text_range = attr.syntax().text_range(); let text_range = attr.syntax().text_range();
// remove any other token in this macro input, all their mappings are the // remove any other token in this macro input, all their mappings are the
// same as this // same as this
tokens.retain(|t| { tokens.retain(|(t, _)| {
!text_range.contains_range(t.text_range()) !text_range.contains_range(t.text_range())
}); });
return process_expansion_for_token( return process_expansion_for_token(
@ -1093,7 +1109,7 @@ impl<'db> SemanticsImpl<'db> {
.is_none(); .is_none();
if was_not_remapped { if was_not_remapped {
if let ControlFlow::Break(b) = f(InFile::new(expansion, token)) { if let ControlFlow::Break(b) = f(InFile::new(expansion, token), ctx) {
return Some(b); return Some(b);
} }
} }

10
crates/ide-db/src/search.rs
View file

@ -529,9 +529,13 @@ impl<'a> FindUsages<'a> {
}) })
.into_iter() .into_iter()
.flat_map(move |token| { .flat_map(move |token| {
sema.descend_into_macros_exact_if_in_macro(token) if sema.might_be_inside_macro_call(&token) {
.into_iter() sema.descend_into_macros_exact(token)
.filter_map(|it| it.parent()) } else {
<_>::from([token])
}
.into_iter()
.filter_map(|it| it.parent())
}) })
} }

2
crates/ide/src/goto_declaration.rs
View file

@ -29,7 +29,7 @@ pub(crate) fn goto_declaration(
.find(|it| matches!(it.kind(), IDENT | T![self] | T![super] | T![crate] | T![Self]))?; .find(|it| matches!(it.kind(), IDENT | T![self] | T![super] | T![crate] | T![Self]))?;
let range = original_token.text_range(); let range = original_token.text_range();
let info: Vec<NavigationTarget> = sema let info: Vec<NavigationTarget> = sema
.descend_into_macros(original_token) .descend_into_macros_no_opaque(original_token)
.iter() .iter()
.filter_map(|token| { .filter_map(|token| {
let parent = token.parent()?; let parent = token.parent()?;

2
crates/ide/src/goto_definition.rs
View file

@ -83,7 +83,7 @@ pub(crate) fn goto_definition(
} }
let navs = sema let navs = sema
.descend_into_macros(original_token.clone()) .descend_into_macros_no_opaque(original_token.clone())
.into_iter() .into_iter()
.filter_map(|token| { .filter_map(|token| {
let parent = token.parent()?; let parent = token.parent()?;

2
crates/ide/src/goto_type_definition.rs
View file

@ -69,7 +69,7 @@ pub(crate) fn goto_type_definition(
} }
let range = token.text_range(); let range = token.text_range();
sema.descend_into_macros(token) sema.descend_into_macros_no_opaque(token)
.into_iter() .into_iter()
.filter_map(|token| { .filter_map(|token| {
let ty = sema let ty = sema

3
crates/ide/src/syntax_highlighting.rs
View file

@ -409,7 +409,8 @@ fn traverse(
let mut r = 0; let mut r = 0;
sema.descend_into_macros_breakable( sema.descend_into_macros_breakable(
InRealFile::new(file_id, token.clone()), InRealFile::new(file_id, token.clone()),
|tok| { |tok, _ctx| {
// FIXME: Consider checking ctx transparency for being opaque?
let tok = tok.value; let tok = tok.value;
let tok_kind = tok.kind(); let tok_kind = tok.kind();

9
crates/span/src/hygiene.rs
View file

@ -142,3 +142,12 @@ pub enum Transparency {
/// Def-site spans in procedural macros, identifiers from `macro` by default use this. /// Def-site spans in procedural macros, identifiers from `macro` by default use this.
Opaque, Opaque,
} }
impl Transparency {
/// Returns `true` if the transparency is [`Opaque`].
///
/// [`Opaque`]: Transparency::Opaque
pub fn is_opaque(&self) -> bool {
matches!(self, Self::Opaque)
}
}

11
crates/span/src/map.rs
View file

@ -55,7 +55,10 @@ where
/// Returns all [`TextRange`]s that correspond to the given span. /// Returns all [`TextRange`]s that correspond to the given span.
/// ///
/// Note this does a linear search through the entire backing vector. /// Note this does a linear search through the entire backing vector.
pub fn ranges_with_span_exact(&self, span: SpanData<S>) -> impl Iterator<Item = TextRange> + '_ pub fn ranges_with_span_exact(
&self,
span: SpanData<S>,
) -> impl Iterator<Item = (TextRange, S)> + '_
where where
S: Copy, S: Copy,
{ {
@ -64,14 +67,14 @@ where
return None; return None;
} }
let start = idx.checked_sub(1).map_or(TextSize::new(0), |prev| self.spans[prev].0); let start = idx.checked_sub(1).map_or(TextSize::new(0), |prev| self.spans[prev].0);
Some(TextRange::new(start, end)) Some((TextRange::new(start, end), s.ctx))
}) })
} }
/// Returns all [`TextRange`]s whose spans contain the given span. /// Returns all [`TextRange`]s whose spans contain the given span.
/// ///
/// Note this does a linear search through the entire backing vector. /// Note this does a linear search through the entire backing vector.
pub fn ranges_with_span(&self, span: SpanData<S>) -> impl Iterator<Item = TextRange> + '_ pub fn ranges_with_span(&self, span: SpanData<S>) -> impl Iterator<Item = (TextRange, S)> + '_
where where
S: Copy, S: Copy,
{ {
@ -83,7 +86,7 @@ where
return None; return None;
} }
let start = idx.checked_sub(1).map_or(TextSize::new(0), |prev| self.spans[prev].0); let start = idx.checked_sub(1).map_or(TextSize::new(0), |prev| self.spans[prev].0);
Some(TextRange::new(start, end)) Some((TextRange::new(start, end), s.ctx))
}) })
} }