use std::mem;
-use algo::find_covering_element;
use hir::Semantics;
use ide_db::{
base_db::{AnchoredPathBuf, FileId, FileRange},
self.sema.find_node_at_offset_with_descend(self.source_file.syntax(), self.offset())
}
pub(crate) fn covering_element(&self) -> SyntaxElement {
- find_covering_element(self.source_file.syntax(), self.frange.range)
+ self.source_file.syntax().covering_element(self.frange.range)
}
// FIXME: remove
pub(crate) fn covering_node_for_range(&self, range: TextRange) -> SyntaxElement {
- find_covering_element(self.source_file.syntax(), range)
+ self.source_file.syntax().covering_element(range)
}
}
use ide_db::base_db::{FilePosition, SourceDatabase};
use ide_db::{call_info::ActiveParameter, RootDatabase};
use syntax::{
- algo::{find_covering_element, find_node_at_offset},
- ast, match_ast, AstNode, NodeOrToken,
- SyntaxKind::*,
- SyntaxNode, SyntaxToken, TextRange, TextSize,
+ algo::find_node_at_offset, ast, match_ast, AstNode, NodeOrToken, SyntaxKind::*, SyntaxNode,
+ SyntaxToken, TextRange, TextSize,
};
use test_utils::mark;
use text_edit::Indel;
}
fn find_node_with_range<N: AstNode>(syntax: &SyntaxNode, range: TextRange) -> Option<N> {
- find_covering_element(syntax, range).ancestors().find_map(N::cast)
+ syntax.covering_element(range).ancestors().find_map(N::cast)
}
fn is_node<N: AstNode>(node: &SyntaxNode) -> bool {
parse_macro_with_arg(db, macro_file, Some(std::sync::Arc::new((tt, tmap_1)))).value?;
let token_id = macro_def.0.map_id_down(token_id);
let range = tmap_2.range_by_token(token_id)?.by_kind(token_to_map.kind())?;
- let token = syntax::algo::find_covering_element(&node.syntax_node(), range).into_token()?;
+ let token = node.syntax_node().covering_element(range).into_token()?;
Some((node.syntax_node(), token))
}
use base_db::{impl_intern_key, salsa, CrateId, FileId, FileRange};
use syntax::{
- algo::{self, skip_trivia_token},
+ algo::skip_trivia_token,
ast::{self, AstNode},
Direction, SyntaxNode, SyntaxToken, TextRange, TextSize,
};
let range = self.exp_map.range_by_token(token_id)?.by_kind(token.value.kind())?;
- let token = algo::find_covering_element(&self.expanded.value, range).into_token()?;
+ let token = self.expanded.value.covering_element(range).into_token()?;
Some(self.expanded.with_value(token))
}
};
let range = token_map.range_by_token(token_id)?.by_kind(token.value.kind())?;
- let token = algo::find_covering_element(&tt.value, range + tt.value.text_range().start())
- .into_token()?;
+ let token =
+ tt.value.covering_element(range + tt.value.text_range().start()).into_token()?;
Some((tt.with_value(token), origin))
}
}
use hir::Semantics;
use ide_db::RootDatabase;
use syntax::{
- algo::{self, find_covering_element, skip_trivia_token},
+ algo::{self, skip_trivia_token},
ast::{self, AstNode, AstToken},
Direction, NodeOrToken,
SyntaxKind::{self, *},
};
return Some(leaf_range);
};
- let node = match find_covering_element(root, range) {
+ let node = match root.covering_element(range) {
NodeOrToken::Token(token) => {
if token.text_range() != range {
return Some(token.text_range());
macro_call: ast::MacroCall,
original_range: TextRange,
) -> Option<TextRange> {
- let src = find_covering_element(¯o_call.syntax(), original_range);
+ let src = macro_call.syntax().covering_element(original_range);
let (first_token, last_token) = match src {
NodeOrToken::Node(it) => (it.first_token()?, it.last_token()?),
NodeOrToken::Token(it) => (it.clone(), it),
use assists::utils::extract_trivial_expression;
use itertools::Itertools;
use syntax::{
- algo::{find_covering_element, non_trivia_sibling},
+ algo::non_trivia_sibling,
ast::{self, AstNode, AstToken},
Direction, NodeOrToken, SourceFile,
SyntaxKind::{self, USE_TREE, WHITESPACE},
range
};
- let node = match find_covering_element(file.syntax(), range) {
+ let node = match file.syntax().covering_element(range) {
NodeOrToken::Node(node) => node,
NodeOrToken::Token(token) => token.parent(),
};
use ide_db::base_db::{FileId, SourceDatabase};
use ide_db::RootDatabase;
use syntax::{
- algo, AstNode, NodeOrToken, SourceFile, SyntaxKind::STRING, SyntaxToken, TextRange, TextSize,
+ AstNode, NodeOrToken, SourceFile, SyntaxKind::STRING, SyntaxToken, TextRange, TextSize,
};
// Feature: Show Syntax Tree
) -> String {
let parse = db.parse(file_id);
if let Some(text_range) = text_range {
- let node = match algo::find_covering_element(parse.tree().syntax(), text_range) {
+ let node = match parse.tree().syntax().covering_element(text_range) {
NodeOrToken::Node(node) => node,
NodeOrToken::Token(token) => {
if let Some(tree) = syntax_tree_for_string(&token, text_range) {
}
pub fn find_node_at_range<N: AstNode>(syntax: &SyntaxNode, range: TextRange) -> Option<N> {
- find_covering_element(syntax, range).ancestors().find_map(N::cast)
+ syntax.covering_element(range).ancestors().find_map(N::cast)
}
/// Skip to next non `trivia` token
}
}
-pub fn find_covering_element(root: &SyntaxNode, range: TextRange) -> SyntaxElement {
- root.covering_element(range)
-}
-
pub fn least_common_ancestor(u: &SyntaxNode, v: &SyntaxNode) -> Option<SyntaxNode> {
if u == v {
return Some(u.clone());
use text_edit::Indel;
use crate::{
- algo,
parsing::{
lexer::{lex_single_syntax_kind, tokenize, Token},
text_token_source::TextTokenSource,
root: &'node SyntaxNode,
edit: &Indel,
) -> Option<(GreenNode, Vec<SyntaxError>, TextRange)> {
- let prev_token = algo::find_covering_element(root, edit.delete).as_token()?.clone();
+ let prev_token = root.covering_element(edit.delete).as_token()?.clone();
let prev_token_kind = prev_token.kind();
match prev_token_kind {
WHITESPACE | COMMENT | IDENT | STRING => {
}
fn find_reparsable_node(node: &SyntaxNode, range: TextRange) -> Option<(SyntaxNode, Reparser)> {
- let node = algo::find_covering_element(node, range);
+ let node = node.covering_element(range);
let mut ancestors = match node {
NodeOrToken::Token(it) => it.parent().ancestors(),