580 lines
19 KiB
Rust
580 lines
19 KiB
Rust
use ide_db::SymbolKind;
|
|
use syntax::{
|
|
ast::{self, AttrsOwner, GenericParamsOwner, NameOwner},
|
|
match_ast, AstNode, AstToken, NodeOrToken, SourceFile, SyntaxNode, SyntaxToken, TextRange,
|
|
WalkEvent,
|
|
};
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct StructureNode {
|
|
pub parent: Option<usize>,
|
|
pub label: String,
|
|
pub navigation_range: TextRange,
|
|
pub node_range: TextRange,
|
|
pub kind: StructureNodeKind,
|
|
pub detail: Option<String>,
|
|
pub deprecated: bool,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
|
pub enum StructureNodeKind {
|
|
SymbolKind(SymbolKind),
|
|
Region,
|
|
}
|
|
|
|
// Feature: File Structure
|
|
//
|
|
// Provides a tree of the symbols defined in the file. Can be used to
|
|
//
|
|
// * fuzzy search symbol in a file (super useful)
|
|
// * draw breadcrumbs to describe the context around the cursor
|
|
// * draw outline of the file
|
|
//
|
|
// |===
|
|
// | Editor | Shortcut
|
|
//
|
|
// | VS Code | kbd:[Ctrl+Shift+O]
|
|
// |===
|
|
//
|
|
// image::https://user-images.githubusercontent.com/48062697/113020654-b42fc800-917a-11eb-8388-e7dc4d92b02e.gif[]
|
|
|
|
pub(crate) fn file_structure(file: &SourceFile) -> Vec<StructureNode> {
|
|
let mut res = Vec::new();
|
|
let mut stack = Vec::new();
|
|
|
|
for event in file.syntax().preorder_with_tokens() {
|
|
match event {
|
|
WalkEvent::Enter(NodeOrToken::Node(node)) => {
|
|
if let Some(mut symbol) = structure_node(&node) {
|
|
symbol.parent = stack.last().copied();
|
|
stack.push(res.len());
|
|
res.push(symbol);
|
|
}
|
|
}
|
|
WalkEvent::Leave(NodeOrToken::Node(node)) => {
|
|
if structure_node(&node).is_some() {
|
|
stack.pop().unwrap();
|
|
}
|
|
}
|
|
WalkEvent::Enter(NodeOrToken::Token(token)) => {
|
|
if let Some(mut symbol) = structure_token(token) {
|
|
symbol.parent = stack.last().copied();
|
|
stack.push(res.len());
|
|
res.push(symbol);
|
|
}
|
|
}
|
|
WalkEvent::Leave(NodeOrToken::Token(token)) => {
|
|
if structure_token(token).is_some() {
|
|
stack.pop().unwrap();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
res
|
|
}
|
|
|
|
fn structure_node(node: &SyntaxNode) -> Option<StructureNode> {
|
|
fn decl<N: NameOwner + AttrsOwner>(node: N, kind: StructureNodeKind) -> Option<StructureNode> {
|
|
decl_with_detail(&node, None, kind)
|
|
}
|
|
|
|
fn decl_with_type_ref<N: NameOwner + AttrsOwner>(
|
|
node: &N,
|
|
type_ref: Option<ast::Type>,
|
|
kind: StructureNodeKind,
|
|
) -> Option<StructureNode> {
|
|
let detail = type_ref.map(|type_ref| {
|
|
let mut detail = String::new();
|
|
collapse_ws(type_ref.syntax(), &mut detail);
|
|
detail
|
|
});
|
|
decl_with_detail(node, detail, kind)
|
|
}
|
|
|
|
fn decl_with_detail<N: NameOwner + AttrsOwner>(
|
|
node: &N,
|
|
detail: Option<String>,
|
|
kind: StructureNodeKind,
|
|
) -> Option<StructureNode> {
|
|
let name = node.name()?;
|
|
|
|
Some(StructureNode {
|
|
parent: None,
|
|
label: name.text().to_string(),
|
|
navigation_range: name.syntax().text_range(),
|
|
node_range: node.syntax().text_range(),
|
|
kind,
|
|
detail,
|
|
deprecated: node.attrs().filter_map(|x| x.simple_name()).any(|x| x == "deprecated"),
|
|
})
|
|
}
|
|
|
|
fn collapse_ws(node: &SyntaxNode, output: &mut String) {
|
|
let mut can_insert_ws = false;
|
|
node.text().for_each_chunk(|chunk| {
|
|
for line in chunk.lines() {
|
|
let line = line.trim();
|
|
if line.is_empty() {
|
|
if can_insert_ws {
|
|
output.push(' ');
|
|
can_insert_ws = false;
|
|
}
|
|
} else {
|
|
output.push_str(line);
|
|
can_insert_ws = true;
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
match_ast! {
|
|
match node {
|
|
ast::Fn(it) => {
|
|
let mut detail = String::from("fn");
|
|
if let Some(type_param_list) = it.generic_param_list() {
|
|
collapse_ws(type_param_list.syntax(), &mut detail);
|
|
}
|
|
if let Some(param_list) = it.param_list() {
|
|
collapse_ws(param_list.syntax(), &mut detail);
|
|
}
|
|
if let Some(ret_type) = it.ret_type() {
|
|
detail.push_str(" ");
|
|
collapse_ws(ret_type.syntax(), &mut detail);
|
|
}
|
|
|
|
decl_with_detail(&it, Some(detail), StructureNodeKind::SymbolKind(SymbolKind::Function))
|
|
},
|
|
ast::Struct(it) => decl(it, StructureNodeKind::SymbolKind(SymbolKind::Struct)),
|
|
ast::Union(it) => decl(it, StructureNodeKind::SymbolKind(SymbolKind::Union)),
|
|
ast::Enum(it) => decl(it, StructureNodeKind::SymbolKind(SymbolKind::Enum)),
|
|
ast::Variant(it) => decl(it, StructureNodeKind::SymbolKind(SymbolKind::Variant)),
|
|
ast::Trait(it) => decl(it, StructureNodeKind::SymbolKind(SymbolKind::Trait)),
|
|
ast::Module(it) => decl(it, StructureNodeKind::SymbolKind(SymbolKind::Module)),
|
|
ast::TypeAlias(it) => decl_with_type_ref(&it, it.ty(), StructureNodeKind::SymbolKind(SymbolKind::TypeAlias)),
|
|
ast::RecordField(it) => decl_with_type_ref(&it, it.ty(), StructureNodeKind::SymbolKind(SymbolKind::Field)),
|
|
ast::Const(it) => decl_with_type_ref(&it, it.ty(), StructureNodeKind::SymbolKind(SymbolKind::Const)),
|
|
ast::Static(it) => decl_with_type_ref(&it, it.ty(), StructureNodeKind::SymbolKind(SymbolKind::Static)),
|
|
ast::Impl(it) => {
|
|
let target_type = it.self_ty()?;
|
|
let target_trait = it.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().text_range(),
|
|
node_range: it.syntax().text_range(),
|
|
kind: StructureNodeKind::SymbolKind(SymbolKind::Impl),
|
|
detail: None,
|
|
deprecated: false,
|
|
};
|
|
Some(node)
|
|
},
|
|
ast::Macro(it) => decl(it, StructureNodeKind::SymbolKind(SymbolKind::Macro)),
|
|
_ => None,
|
|
}
|
|
}
|
|
}
|
|
|
|
fn structure_token(token: SyntaxToken) -> Option<StructureNode> {
|
|
if let Some(comment) = ast::Comment::cast(token) {
|
|
let text = comment.text().trim();
|
|
|
|
if let Some(region_name) = text.strip_prefix("// region:").map(str::trim) {
|
|
return Some(StructureNode {
|
|
parent: None,
|
|
label: region_name.to_string(),
|
|
navigation_range: comment.syntax().text_range(),
|
|
node_range: comment.syntax().text_range(),
|
|
kind: StructureNodeKind::Region,
|
|
detail: None,
|
|
deprecated: false,
|
|
});
|
|
}
|
|
}
|
|
|
|
None
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use expect_test::{expect, Expect};
|
|
|
|
use super::*;
|
|
|
|
fn check(ra_fixture: &str, expect: Expect) {
|
|
let file = SourceFile::parse(ra_fixture).ok().unwrap();
|
|
let structure = file_structure(&file);
|
|
expect.assert_debug_eq(&structure)
|
|
}
|
|
|
|
#[test]
|
|
fn test_file_structure() {
|
|
check(
|
|
r#"
|
|
struct Foo {
|
|
x: i32
|
|
}
|
|
|
|
mod m {
|
|
fn bar1() {}
|
|
fn bar2<T>(t: T) -> T {}
|
|
fn bar3<A,
|
|
B>(a: A,
|
|
b: B) -> Vec<
|
|
u32
|
|
> {}
|
|
}
|
|
|
|
enum E { X, Y(i32) }
|
|
type T = ();
|
|
static S: i32 = 92;
|
|
const C: i32 = 92;
|
|
|
|
impl E {}
|
|
|
|
impl fmt::Debug for E {}
|
|
|
|
macro_rules! mc {
|
|
() => {}
|
|
}
|
|
|
|
#[macro_export]
|
|
macro_rules! mcexp {
|
|
() => {}
|
|
}
|
|
|
|
/// Doc comment
|
|
macro_rules! mcexp {
|
|
() => {}
|
|
}
|
|
|
|
#[deprecated]
|
|
fn obsolete() {}
|
|
|
|
#[deprecated(note = "for awhile")]
|
|
fn very_obsolete() {}
|
|
|
|
// region: Some region name
|
|
// endregion
|
|
|
|
// region: dontpanic
|
|
mod m {
|
|
fn f() {}
|
|
// endregion
|
|
fn g() {}
|
|
}
|
|
"#,
|
|
expect![[r#"
|
|
[
|
|
StructureNode {
|
|
parent: None,
|
|
label: "Foo",
|
|
navigation_range: 8..11,
|
|
node_range: 1..26,
|
|
kind: SymbolKind(
|
|
Struct,
|
|
),
|
|
detail: None,
|
|
deprecated: false,
|
|
},
|
|
StructureNode {
|
|
parent: Some(
|
|
0,
|
|
),
|
|
label: "x",
|
|
navigation_range: 18..19,
|
|
node_range: 18..24,
|
|
kind: SymbolKind(
|
|
Field,
|
|
),
|
|
detail: Some(
|
|
"i32",
|
|
),
|
|
deprecated: false,
|
|
},
|
|
StructureNode {
|
|
parent: None,
|
|
label: "m",
|
|
navigation_range: 32..33,
|
|
node_range: 28..158,
|
|
kind: SymbolKind(
|
|
Module,
|
|
),
|
|
detail: None,
|
|
deprecated: false,
|
|
},
|
|
StructureNode {
|
|
parent: Some(
|
|
2,
|
|
),
|
|
label: "bar1",
|
|
navigation_range: 43..47,
|
|
node_range: 40..52,
|
|
kind: SymbolKind(
|
|
Function,
|
|
),
|
|
detail: Some(
|
|
"fn()",
|
|
),
|
|
deprecated: false,
|
|
},
|
|
StructureNode {
|
|
parent: Some(
|
|
2,
|
|
),
|
|
label: "bar2",
|
|
navigation_range: 60..64,
|
|
node_range: 57..81,
|
|
kind: SymbolKind(
|
|
Function,
|
|
),
|
|
detail: Some(
|
|
"fn<T>(t: T) -> T",
|
|
),
|
|
deprecated: false,
|
|
},
|
|
StructureNode {
|
|
parent: Some(
|
|
2,
|
|
),
|
|
label: "bar3",
|
|
navigation_range: 89..93,
|
|
node_range: 86..156,
|
|
kind: SymbolKind(
|
|
Function,
|
|
),
|
|
detail: Some(
|
|
"fn<A, B>(a: A, b: B) -> Vec< u32 >",
|
|
),
|
|
deprecated: false,
|
|
},
|
|
StructureNode {
|
|
parent: None,
|
|
label: "E",
|
|
navigation_range: 165..166,
|
|
node_range: 160..180,
|
|
kind: SymbolKind(
|
|
Enum,
|
|
),
|
|
detail: None,
|
|
deprecated: false,
|
|
},
|
|
StructureNode {
|
|
parent: Some(
|
|
6,
|
|
),
|
|
label: "X",
|
|
navigation_range: 169..170,
|
|
node_range: 169..170,
|
|
kind: SymbolKind(
|
|
Variant,
|
|
),
|
|
detail: None,
|
|
deprecated: false,
|
|
},
|
|
StructureNode {
|
|
parent: Some(
|
|
6,
|
|
),
|
|
label: "Y",
|
|
navigation_range: 172..173,
|
|
node_range: 172..178,
|
|
kind: SymbolKind(
|
|
Variant,
|
|
),
|
|
detail: None,
|
|
deprecated: false,
|
|
},
|
|
StructureNode {
|
|
parent: None,
|
|
label: "T",
|
|
navigation_range: 186..187,
|
|
node_range: 181..193,
|
|
kind: SymbolKind(
|
|
TypeAlias,
|
|
),
|
|
detail: Some(
|
|
"()",
|
|
),
|
|
deprecated: false,
|
|
},
|
|
StructureNode {
|
|
parent: None,
|
|
label: "S",
|
|
navigation_range: 201..202,
|
|
node_range: 194..213,
|
|
kind: SymbolKind(
|
|
Static,
|
|
),
|
|
detail: Some(
|
|
"i32",
|
|
),
|
|
deprecated: false,
|
|
},
|
|
StructureNode {
|
|
parent: None,
|
|
label: "C",
|
|
navigation_range: 220..221,
|
|
node_range: 214..232,
|
|
kind: SymbolKind(
|
|
Const,
|
|
),
|
|
detail: Some(
|
|
"i32",
|
|
),
|
|
deprecated: false,
|
|
},
|
|
StructureNode {
|
|
parent: None,
|
|
label: "impl E",
|
|
navigation_range: 239..240,
|
|
node_range: 234..243,
|
|
kind: SymbolKind(
|
|
Impl,
|
|
),
|
|
detail: None,
|
|
deprecated: false,
|
|
},
|
|
StructureNode {
|
|
parent: None,
|
|
label: "impl fmt::Debug for E",
|
|
navigation_range: 265..266,
|
|
node_range: 245..269,
|
|
kind: SymbolKind(
|
|
Impl,
|
|
),
|
|
detail: None,
|
|
deprecated: false,
|
|
},
|
|
StructureNode {
|
|
parent: None,
|
|
label: "mc",
|
|
navigation_range: 284..286,
|
|
node_range: 271..303,
|
|
kind: SymbolKind(
|
|
Macro,
|
|
),
|
|
detail: None,
|
|
deprecated: false,
|
|
},
|
|
StructureNode {
|
|
parent: None,
|
|
label: "mcexp",
|
|
navigation_range: 334..339,
|
|
node_range: 305..356,
|
|
kind: SymbolKind(
|
|
Macro,
|
|
),
|
|
detail: None,
|
|
deprecated: false,
|
|
},
|
|
StructureNode {
|
|
parent: None,
|
|
label: "mcexp",
|
|
navigation_range: 387..392,
|
|
node_range: 358..409,
|
|
kind: SymbolKind(
|
|
Macro,
|
|
),
|
|
detail: None,
|
|
deprecated: false,
|
|
},
|
|
StructureNode {
|
|
parent: None,
|
|
label: "obsolete",
|
|
navigation_range: 428..436,
|
|
node_range: 411..441,
|
|
kind: SymbolKind(
|
|
Function,
|
|
),
|
|
detail: Some(
|
|
"fn()",
|
|
),
|
|
deprecated: true,
|
|
},
|
|
StructureNode {
|
|
parent: None,
|
|
label: "very_obsolete",
|
|
navigation_range: 481..494,
|
|
node_range: 443..499,
|
|
kind: SymbolKind(
|
|
Function,
|
|
),
|
|
detail: Some(
|
|
"fn()",
|
|
),
|
|
deprecated: true,
|
|
},
|
|
StructureNode {
|
|
parent: None,
|
|
label: "Some region name",
|
|
navigation_range: 501..528,
|
|
node_range: 501..528,
|
|
kind: Region,
|
|
detail: None,
|
|
deprecated: false,
|
|
},
|
|
StructureNode {
|
|
parent: None,
|
|
label: "m",
|
|
navigation_range: 568..569,
|
|
node_range: 543..606,
|
|
kind: SymbolKind(
|
|
Module,
|
|
),
|
|
detail: None,
|
|
deprecated: false,
|
|
},
|
|
StructureNode {
|
|
parent: Some(
|
|
20,
|
|
),
|
|
label: "dontpanic",
|
|
navigation_range: 543..563,
|
|
node_range: 543..563,
|
|
kind: Region,
|
|
detail: None,
|
|
deprecated: false,
|
|
},
|
|
StructureNode {
|
|
parent: Some(
|
|
20,
|
|
),
|
|
label: "f",
|
|
navigation_range: 575..576,
|
|
node_range: 572..581,
|
|
kind: SymbolKind(
|
|
Function,
|
|
),
|
|
detail: Some(
|
|
"fn()",
|
|
),
|
|
deprecated: false,
|
|
},
|
|
StructureNode {
|
|
parent: Some(
|
|
20,
|
|
),
|
|
label: "g",
|
|
navigation_range: 598..599,
|
|
node_range: 582..604,
|
|
kind: SymbolKind(
|
|
Function,
|
|
),
|
|
detail: Some(
|
|
"fn()",
|
|
),
|
|
deprecated: false,
|
|
},
|
|
]
|
|
"#]],
|
|
);
|
|
}
|
|
}
|