Struct MatchFinder 

pub struct MatchFinder<'db> {
    pub(crate) sema: Semantics<'db, RootDatabase>,
    pub(crate) rules: Vec<ResolvedRule<'db>>,
    pub(crate) resolution_scope: ResolutionScope<'db>,
    pub(crate) restrict_ranges: Vec<FileRange>,
}

Searches a crate for pattern matches and possibly replaces them with something else.

Fields

sema: Semantics<'db, RootDatabase>

Our source of information about the user’s code.

rules: Vec<ResolvedRule<'db>>

resolution_scope: ResolutionScope<'db>

restrict_ranges: Vec<FileRange>

Implementations

impl<'db> MatchFinder<'db>

pub(crate) fn find_matches_for_rule( &self, rule: &ResolvedRule<'db>, usage_cache: &mut UsageCache, matches_out: &mut Vec<Match>, )

Adds all matches for rule to matches_out. Matches may overlap in ways that make replacement impossible, so further processing is required in order to properly nest matches and remove overlapping matches. This is done in the nesting module.

fn find_matches_for_pattern_tree( &self, rule: &ResolvedRule<'db>, pattern: &ResolvedPattern<'db>, usage_cache: &mut UsageCache, matches_out: &mut Vec<Match>, )

fn find_nodes_to_match( &self, resolved_path: &ResolvedPath, file_range: FileRange, ) -> Vec<SyntaxNode>

fn find_usages<'a>( &self, usage_cache: &'a mut UsageCache, definition: Definition, ) -> &'a UsageSearchResult

fn search_scope(&self) -> SearchScope

Returns the scope within which we want to search. We don’t want un unrestricted search scope, since we don’t want to find references in external dependencies.

fn slow_scan(&self, rule: &ResolvedRule<'db>, matches_out: &mut Vec<Match>)

fn search_files_do(&self, callback: impl FnMut(FileId))

fn slow_scan_node( &self, code: &SyntaxNode, rule: &ResolvedRule<'db>, restrict_range: &Option<FileRange>, matches_out: &mut Vec<Match>, )

fn try_add_match( &self, rule: &ResolvedRule<'db>, code: &SyntaxNode, restrict_range: &Option<FileRange>, matches_out: &mut Vec<Match>, )

fn within_range_restrictions(&self, code: &SyntaxNode) -> bool

Returns whether code is within one of our range restrictions if we have any. No range restrictions is considered unrestricted and always returns true.

impl<'db> MatchFinder<'db>

pub fn in_context( db: &'db RootDatabase, lookup_context: FilePosition, restrict_ranges: Vec<FileRange>, ) -> Result<MatchFinder<'db>, SsrError>

Constructs a new instance where names will be looked up as if they appeared at lookup_context.

pub fn at_first_file( db: &'db RootDatabase, ) -> Result<MatchFinder<'db>, SsrError>

Constructs an instance using the start of the first file in db as the lookup context.

pub fn add_rule(&mut self, rule: SsrRule) -> Result<(), SsrError>

Adds a rule to be applied. The order in which rules are added matters. Earlier rules take precedence. If a node is matched by an earlier rule, then later rules won’t be permitted to match to it.

pub fn edits(&self) -> FxHashMap<FileId, TextEdit>

Finds matches for all added rules and returns edits for all found matches.

pub fn add_search_pattern( &mut self, pattern: SsrPattern, ) -> Result<(), SsrError>

Adds a search pattern. For use if you intend to only call find_matches_in_file. If you intend to do replacement, use add_rule instead.

pub fn matches(&self) -> SsrMatches

Returns matches for all added rules.

pub fn debug_where_text_equal( &self, file_id: EditionedFileId, snippet: &str, ) -> Vec<MatchDebugInfo>

Finds all nodes in file_id whose text is exactly equal to snippet and attempts to match them, while recording reasons why they don’t match. This API is useful for command line-based debugging where providing a range is difficult.

pub(crate) fn output_debug_for_nodes_at_range( &self, node: &SyntaxNode, range: FileRange, restrict_range: &Option<FileRange>, out: &mut Vec<MatchDebugInfo>, )