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,
},
]
"#]],
);
}
}