mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

move symbols to ra_analysis

Browse Source
This commit is contained in:
Aleksey Kladov 2019-01-02 16:29:08 +03:00
parent e4ffd7b317
commit a4b4fd7dc5
6 changed files with 255 additions and 256 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
crates/ra_analysis/src/imp.rs
View File

@ -10,7 +10,7 @@ use hir::{
self, FnSignatureInfo, Problem, source_binder,
};
use ra_db::{FilesDatabase, SourceRoot, SourceRootId, SyntaxDatabase};
use ra_editor::{self, FileSymbol, find_node_at_offset, LineIndex, LocalEdit, Severity};
use ra_editor::{self, find_node_at_offset, LineIndex, LocalEdit, Severity};
use ra_syntax::{
algo::find_covering_node,
ast::{self, ArgListOwner, Expr, FnDef, NameOwner},
@ -25,7 +25,7 @@ use crate::{
completion::{CompletionItem, completions},
CrateId, db, Diagnostic, FileId, FilePosition, FileRange, FileSystemEdit,
Query, ReferenceResolution, RootChange, SourceChange, SourceFileEdit,
symbol_index::{LibrarySymbolsQuery, SymbolIndex, SymbolsDatabase},
symbol_index::{LibrarySymbolsQuery, SymbolIndex, SymbolsDatabase, FileSymbol},
};
#[derive(Debug, Default)]

5
crates/ra_analysis/src/lib.rs
View File

@ -36,10 +36,11 @@ use crate::{
pub use crate::{
completion::{CompletionItem, CompletionItemKind, InsertText},
runnables::{Runnable, RunnableKind}
runnables::{Runnable, RunnableKind},
symbol_index::FileSymbol,
};
pub use ra_editor::{
FileSymbol, Fold, FoldKind, HighlightedRange, LineIndex, StructureNode, Severity
Fold, FoldKind, HighlightedRange, LineIndex, StructureNode, Severity
};
pub use hir::FnSignatureInfo;

123
crates/ra_analysis/src/symbol_index.rs
View File

@ -4,10 +4,11 @@ use std::{
};
use fst::{self, Streamer};
use ra_editor::{self, FileSymbol};
use ra_syntax::{
SourceFileNode,
AstNode, SyntaxNodeRef, SourceFileNode, SmolStr, TextRange,
algo::visit::{visitor, Visitor},
SyntaxKind::{self, *},
ast::{self, NameOwner, DocCommentsOwner},
};
use ra_db::{SyntaxDatabase, SourceRootId};
use rayon::prelude::*;
@ -65,8 +66,9 @@ impl SymbolIndex {
) -> SymbolIndex {
let mut symbols = files
.flat_map(|(file_id, file)| {
ra_editor::file_symbols(&file)
.into_iter()
file.syntax()
.descendants()
.filter_map(to_symbol)
.map(move |symbol| (symbol.name.as_str().to_lowercase(), (file_id, symbol)))
.collect::<Vec<_>>()
})
@ -121,3 +123,116 @@ fn is_type(kind: SyntaxKind) -> bool {
_ => false,
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct FileSymbol {
pub name: SmolStr,
pub node_range: TextRange,
pub kind: SyntaxKind,
}
impl FileSymbol {
pub fn docs(&self, file: &SourceFileNode) -> Option<String> {
file.syntax()
.descendants()
.filter(|node| node.kind() == self.kind && node.range() == self.node_range)
.filter_map(|node: SyntaxNodeRef| {
fn doc_comments<'a, N: DocCommentsOwner<'a>>(node: N) -> Option<String> {
let comments = node.doc_comment_text();
if comments.is_empty() {
None
} else {
Some(comments)
}
}
visitor()
.visit(doc_comments::<ast::FnDef>)
.visit(doc_comments::<ast::StructDef>)
.visit(doc_comments::<ast::EnumDef>)
.visit(doc_comments::<ast::TraitDef>)
.visit(doc_comments::<ast::Module>)
.visit(doc_comments::<ast::TypeDef>)
.visit(doc_comments::<ast::ConstDef>)
.visit(doc_comments::<ast::StaticDef>)
.accept(node)?
})
.nth(0)
}
/// Get a description of this node.
///
/// e.g. `struct Name`, `enum Name`, `fn Name`
pub fn description(&self, file: &SourceFileNode) -> Option<String> {
// TODO: After type inference is done, add type information to improve the output
file.syntax()
.descendants()
.filter(|node| node.kind() == self.kind && node.range() == self.node_range)
.filter_map(|node: SyntaxNodeRef| {
// TODO: Refactor to be have less repetition
visitor()
.visit(|node: ast::FnDef| {
let mut string = "fn ".to_string();
node.name()?.syntax().text().push_to(&mut string);
Some(string)
})
.visit(|node: ast::StructDef| {
let mut string = "struct ".to_string();
node.name()?.syntax().text().push_to(&mut string);
Some(string)
})
.visit(|node: ast::EnumDef| {
let mut string = "enum ".to_string();
node.name()?.syntax().text().push_to(&mut string);
Some(string)
})
.visit(|node: ast::TraitDef| {
let mut string = "trait ".to_string();
node.name()?.syntax().text().push_to(&mut string);
Some(string)
})
.visit(|node: ast::Module| {
let mut string = "mod ".to_string();
node.name()?.syntax().text().push_to(&mut string);
Some(string)
})
.visit(|node: ast::TypeDef| {
let mut string = "type ".to_string();
node.name()?.syntax().text().push_to(&mut string);
Some(string)
})
.visit(|node: ast::ConstDef| {
let mut string = "const ".to_string();
node.name()?.syntax().text().push_to(&mut string);
Some(string)
})
.visit(|node: ast::StaticDef| {
let mut string = "static ".to_string();
node.name()?.syntax().text().push_to(&mut string);
Some(string)
})
.accept(node)?
})
.nth(0)
}
}
fn to_symbol(node: SyntaxNodeRef) -> Option<FileSymbol> {
fn decl<'a, N: NameOwner<'a>>(node: N) -> Option<FileSymbol> {
let name = node.name()?;
Some(FileSymbol {
name: name.text(),
node_range: node.syntax().range(),
kind: node.syntax().kind(),
})
}
visitor()
.visit(decl::<ast::FnDef>)
.visit(decl::<ast::StructDef>)
.visit(decl::<ast::EnumDef>)
.visit(decl::<ast::TraitDef>)
.visit(decl::<ast::Module>)
.visit(decl::<ast::TypeDef>)
.visit(decl::<ast::ConstDef>)
.visit(decl::<ast::StaticDef>)
.accept(node)?
}

4
crates/ra_editor/src/lib.rs
View File

@ -3,7 +3,7 @@ mod extend_selection;
mod folding_ranges;
mod line_index;
mod line_index_utils;
mod symbols;
mod structure;
#[cfg(test)]
mod test_utils;
mod typing;
@ -15,7 +15,7 @@ pub use self::{
folding_ranges::{folding_ranges, Fold, FoldKind},
line_index::{LineCol, LineIndex},
line_index_utils::translate_offset_with_edit,
symbols::{file_structure, file_symbols, FileSymbol, StructureNode},
structure::{file_structure, StructureNode},
typing::{join_lines, on_enter, on_eq_typed},
diagnostics::diagnostics
};

129
crates/ra_editor/src/structure.rs Normal file
View File

@ -0,0 +1,129 @@
use crate::TextRange;
use ra_syntax::{
algo::visit::{visitor, Visitor},
ast::{self, NameOwner},
AstNode, SourceFileNode, SyntaxKind, SyntaxNodeRef, WalkEvent,
};
#[derive(Debug, Clone)]
pub struct StructureNode {
pub parent: Option<usize>,
pub label: String,
pub navigation_range: TextRange,
pub node_range: TextRange,
pub kind: SyntaxKind,
}
pub fn file_structure(file: &SourceFileNode) -> Vec<StructureNode> {
let mut res = Vec::new();
let mut stack = Vec::new();
for event in file.syntax().preorder() {
match event {
WalkEvent::Enter(node) => {
if let Some(mut symbol) = structure_node(node) {
symbol.parent = stack.last().map(|&n| n);
stack.push(res.len());
res.push(symbol);
}
}
WalkEvent::Leave(node) => {
if structure_node(node).is_some() {
stack.pop().unwrap();
}
}
}
}
res
}
fn structure_node(node: SyntaxNodeRef) -> Option<StructureNode> {
fn decl<'a, N: NameOwner<'a>>(node: N) -> Option<StructureNode> {
let name = node.name()?;
Some(StructureNode {
parent: None,
label: name.text().to_string(),
navigation_range: name.syntax().range(),
node_range: node.syntax().range(),
kind: node.syntax().kind(),
})
}
visitor()
.visit(decl::<ast::FnDef>)
.visit(decl::<ast::StructDef>)
.visit(decl::<ast::NamedFieldDef>)
.visit(decl::<ast::EnumDef>)
.visit(decl::<ast::TraitDef>)
.visit(decl::<ast::Module>)
.visit(decl::<ast::TypeDef>)
.visit(decl::<ast::ConstDef>)
.visit(decl::<ast::StaticDef>)
.visit(|im: ast::ImplItem| {
let target_type = im.target_type()?;
let target_trait = im.target_trait();
let label = match target_trait {
None => format!("impl {}", target_type.syntax().text()),
Some(t) => format!(
"impl {} for {}",
t.syntax().text(),
target_type.syntax().text(),
),
};
let node = StructureNode {
parent: None,
label,
navigation_range: target_type.syntax().range(),
node_range: im.syntax().range(),
kind: im.syntax().kind(),
};
Some(node)
})
.accept(node)?
}
#[cfg(test)]
mod tests {
use super::*;
use test_utils::assert_eq_dbg;
#[test]
fn test_file_structure() {
let file = SourceFileNode::parse(
r#"
struct Foo {
x: i32
}
mod m {
fn bar() {}
}
enum E { X, Y(i32) }
type T = ();
static S: i32 = 92;
const C: i32 = 92;
impl E {}
impl fmt::Debug for E {}
"#,
);
let structure = file_structure(&file);
assert_eq_dbg(
r#"[StructureNode { parent: None, label: "Foo", navigation_range: [8; 11), node_range: [1; 26), kind: STRUCT_DEF },
StructureNode { parent: Some(0), label: "x", navigation_range: [18; 19), node_range: [18; 24), kind: NAMED_FIELD_DEF },
StructureNode { parent: None, label: "m", navigation_range: [32; 33), node_range: [28; 53), kind: MODULE },
StructureNode { parent: Some(2), label: "bar", navigation_range: [43; 46), node_range: [40; 51), kind: FN_DEF },
StructureNode { parent: None, label: "E", navigation_range: [60; 61), node_range: [55; 75), kind: ENUM_DEF },
StructureNode { parent: None, label: "T", navigation_range: [81; 82), node_range: [76; 88), kind: TYPE_DEF },
StructureNode { parent: None, label: "S", navigation_range: [96; 97), node_range: [89; 108), kind: STATIC_DEF },
StructureNode { parent: None, label: "C", navigation_range: [115; 116), node_range: [109; 127), kind: CONST_DEF },
StructureNode { parent: None, label: "impl E", navigation_range: [134; 135), node_range: [129; 138), kind: IMPL_ITEM },
StructureNode { parent: None, label: "impl fmt::Debug for E", navigation_range: [160; 161), node_range: [140; 164), kind: IMPL_ITEM }]"#,
&structure,
)
}
}

246
crates/ra_editor/src/symbols.rs
View File

@ -1,246 +0,0 @@
use crate::TextRange;
use ra_syntax::{
algo::visit::{visitor, Visitor},
ast::{self, DocCommentsOwner, NameOwner},
AstNode, SourceFileNode, SmolStr, SyntaxKind, SyntaxNodeRef, WalkEvent,
};
#[derive(Debug, Clone)]
pub struct StructureNode {
pub parent: Option<usize>,
pub label: String,
pub navigation_range: TextRange,
pub node_range: TextRange,
pub kind: SyntaxKind,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct FileSymbol {
pub name: SmolStr,
pub node_range: TextRange,
pub kind: SyntaxKind,
}
impl FileSymbol {
pub fn docs(&self, file: &SourceFileNode) -> Option<String> {
file.syntax()
.descendants()
.filter(|node| node.kind() == self.kind && node.range() == self.node_range)
.filter_map(|node: SyntaxNodeRef| {
fn doc_comments<'a, N: DocCommentsOwner<'a>>(node: N) -> Option<String> {
let comments = node.doc_comment_text();
if comments.is_empty() {
None
} else {
Some(comments)
}
}
visitor()
.visit(doc_comments::<ast::FnDef>)
.visit(doc_comments::<ast::StructDef>)
.visit(doc_comments::<ast::EnumDef>)
.visit(doc_comments::<ast::TraitDef>)
.visit(doc_comments::<ast::Module>)
.visit(doc_comments::<ast::TypeDef>)
.visit(doc_comments::<ast::ConstDef>)
.visit(doc_comments::<ast::StaticDef>)
.accept(node)?
})
.nth(0)
}
/// Get a description of this node.
///
/// e.g. `struct Name`, `enum Name`, `fn Name`
pub fn description(&self, file: &SourceFileNode) -> Option<String> {
// TODO: After type inference is done, add type information to improve the output
file.syntax()
.descendants()
.filter(|node| node.kind() == self.kind && node.range() == self.node_range)
.filter_map(|node: SyntaxNodeRef| {
// TODO: Refactor to be have less repetition
visitor()
.visit(|node: ast::FnDef| {
let mut string = "fn ".to_string();
node.name()?.syntax().text().push_to(&mut string);
Some(string)
})
.visit(|node: ast::StructDef| {
let mut string = "struct ".to_string();
node.name()?.syntax().text().push_to(&mut string);
Some(string)
})
.visit(|node: ast::EnumDef| {
let mut string = "enum ".to_string();
node.name()?.syntax().text().push_to(&mut string);
Some(string)
})
.visit(|node: ast::TraitDef| {
let mut string = "trait ".to_string();
node.name()?.syntax().text().push_to(&mut string);
Some(string)
})
.visit(|node: ast::Module| {
let mut string = "mod ".to_string();
node.name()?.syntax().text().push_to(&mut string);
Some(string)
})
.visit(|node: ast::TypeDef| {
let mut string = "type ".to_string();
node.name()?.syntax().text().push_to(&mut string);
Some(string)
})
.visit(|node: ast::ConstDef| {
let mut string = "const ".to_string();
node.name()?.syntax().text().push_to(&mut string);
Some(string)
})
.visit(|node: ast::StaticDef| {
let mut string = "static ".to_string();
node.name()?.syntax().text().push_to(&mut string);
Some(string)
})
.accept(node)?
})
.nth(0)
}
}
pub fn file_symbols(file: &SourceFileNode) -> Vec<FileSymbol> {
file.syntax().descendants().filter_map(to_symbol).collect()
}
fn to_symbol(node: SyntaxNodeRef) -> Option<FileSymbol> {
fn decl<'a, N: NameOwner<'a>>(node: N) -> Option<FileSymbol> {
let name = node.name()?;
Some(FileSymbol {
name: name.text(),
node_range: node.syntax().range(),
kind: node.syntax().kind(),
})
}
visitor()
.visit(decl::<ast::FnDef>)
.visit(decl::<ast::StructDef>)
.visit(decl::<ast::EnumDef>)
.visit(decl::<ast::TraitDef>)
.visit(decl::<ast::Module>)
.visit(decl::<ast::TypeDef>)
.visit(decl::<ast::ConstDef>)
.visit(decl::<ast::StaticDef>)
.accept(node)?
}
pub fn file_structure(file: &SourceFileNode) -> Vec<StructureNode> {
let mut res = Vec::new();
let mut stack = Vec::new();
for event in file.syntax().preorder() {
match event {
WalkEvent::Enter(node) => {
if let Some(mut symbol) = structure_node(node) {
symbol.parent = stack.last().map(|&n| n);
stack.push(res.len());
res.push(symbol);
}
}
WalkEvent::Leave(node) => {
if structure_node(node).is_some() {
stack.pop().unwrap();
}
}
}
}
res
}
fn structure_node(node: SyntaxNodeRef) -> Option<StructureNode> {
fn decl<'a, N: NameOwner<'a>>(node: N) -> Option<StructureNode> {
let name = node.name()?;
Some(StructureNode {
parent: None,
label: name.text().to_string(),
navigation_range: name.syntax().range(),
node_range: node.syntax().range(),
kind: node.syntax().kind(),
})
}
visitor()
.visit(decl::<ast::FnDef>)
.visit(decl::<ast::StructDef>)
.visit(decl::<ast::NamedFieldDef>)
.visit(decl::<ast::EnumDef>)
.visit(decl::<ast::TraitDef>)
.visit(decl::<ast::Module>)
.visit(decl::<ast::TypeDef>)
.visit(decl::<ast::ConstDef>)
.visit(decl::<ast::StaticDef>)
.visit(|im: ast::ImplItem| {
let target_type = im.target_type()?;
let target_trait = im.target_trait();
let label = match target_trait {
None => format!("impl {}", target_type.syntax().text()),
Some(t) => format!(
"impl {} for {}",
t.syntax().text(),
target_type.syntax().text(),
),
};
let node = StructureNode {
parent: None,
label,
navigation_range: target_type.syntax().range(),
node_range: im.syntax().range(),
kind: im.syntax().kind(),
};
Some(node)
})
.accept(node)?
}
#[cfg(test)]
mod tests {
use super::*;
use test_utils::assert_eq_dbg;
#[test]
fn test_file_structure() {
let file = SourceFileNode::parse(
r#"
struct Foo {
x: i32
}
mod m {
fn bar() {}
}
enum E { X, Y(i32) }
type T = ();
static S: i32 = 92;
const C: i32 = 92;
impl E {}
impl fmt::Debug for E {}
"#,
);
let symbols = file_structure(&file);
assert_eq_dbg(
r#"[StructureNode { parent: None, label: "Foo", navigation_range: [8; 11), node_range: [1; 26), kind: STRUCT_DEF },
StructureNode { parent: Some(0), label: "x", navigation_range: [18; 19), node_range: [18; 24), kind: NAMED_FIELD_DEF },
StructureNode { parent: None, label: "m", navigation_range: [32; 33), node_range: [28; 53), kind: MODULE },
StructureNode { parent: Some(2), label: "bar", navigation_range: [43; 46), node_range: [40; 51), kind: FN_DEF },
StructureNode { parent: None, label: "E", navigation_range: [60; 61), node_range: [55; 75), kind: ENUM_DEF },
StructureNode { parent: None, label: "T", navigation_range: [81; 82), node_range: [76; 88), kind: TYPE_DEF },
StructureNode { parent: None, label: "S", navigation_range: [96; 97), node_range: [89; 108), kind: STATIC_DEF },
StructureNode { parent: None, label: "C", navigation_range: [115; 116), node_range: [109; 127), kind: CONST_DEF },
StructureNode { parent: None, label: "impl E", navigation_range: [134; 135), node_range: [129; 138), kind: IMPL_ITEM },
StructureNode { parent: None, label: "impl fmt::Debug for E", navigation_range: [160; 161), node_range: [140; 164), kind: IMPL_ITEM }]"#,
&symbols,
)
}
}