Add an ItemTree pretty-printer
This commit is contained in:
Jonas Schievink
parent
01df4c04d1
commit
8d13864440
@ -1,6 +1,9 @@
|
|||||||
//! A simplified AST that only contains items.
|
//! A simplified AST that only contains items.
|
||||||
|
|
||||||
mod lower;
|
mod lower;
|
||||||
|
mod pretty;
|
||||||
|
#[cfg(test)]
|
||||||
|
mod tests;
|
||||||
|
|
||||||
use std::{
|
use std::{
|
||||||
any::type_name,
|
any::type_name,
|
||||||
@ -205,6 +208,10 @@ pub fn inner_items_of_block(&self, block: FileAstId<ast::BlockExpr>) -> &[ModIte
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
pub fn pretty_print(&self) -> String {
|
||||||
|
pretty::print_item_tree(self)
|
||||||
|
}
|
||||||
|
|
||||||
fn data(&self) -> &ItemTreeData {
|
fn data(&self) -> &ItemTreeData {
|
||||||
self.data.as_ref().expect("attempted to access data of empty ItemTree")
|
self.data.as_ref().expect("attempted to access data of empty ItemTree")
|
||||||
}
|
}
|
||||||
@ -776,6 +783,10 @@ impl<T> IdRange<T> {
|
|||||||
fn new(range: Range<Idx<T>>) -> Self {
|
fn new(range: Range<Idx<T>>) -> Self {
|
||||||
Self { range: range.start.into_raw().into()..range.end.into_raw().into(), _p: PhantomData }
|
Self { range: range.start.into_raw().into()..range.end.into_raw().into(), _p: PhantomData }
|
||||||
}
|
}
|
||||||
|
|
||||||
|
fn is_empty(&self) -> bool {
|
||||||
|
self.range.is_empty()
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<T> Iterator for IdRange<T> {
|
impl<T> Iterator for IdRange<T> {
|
||||||
|
|||||||
525
crates/hir_def/src/item_tree/pretty.rs
Normal file
525
crates/hir_def/src/item_tree/pretty.rs
Normal file
@ -0,0 +1,525 @@
|
|||||||
|
//! `ItemTree` debug printer.
|
||||||
|
|
||||||
|
use std::fmt::{self, Write};
|
||||||
|
|
||||||
|
use crate::{attr::RawAttrs, visibility::RawVisibility};
|
||||||
|
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
pub(super) fn print_item_tree(tree: &ItemTree) -> String {
|
||||||
|
let mut p = Printer { tree, buf: String::new(), indent_level: 0, needs_indent: true };
|
||||||
|
|
||||||
|
if let Some(attrs) = tree.attrs.get(&AttrOwner::TopLevel) {
|
||||||
|
p.print_attrs(attrs, true);
|
||||||
|
}
|
||||||
|
p.blank();
|
||||||
|
|
||||||
|
for item in tree.top_level_items() {
|
||||||
|
p.print_mod_item(*item);
|
||||||
|
}
|
||||||
|
|
||||||
|
let mut s = p.buf.trim_end_matches('\n').to_string();
|
||||||
|
s.push('\n');
|
||||||
|
s
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! w {
|
||||||
|
($dst:expr, $($arg:tt)*) => {
|
||||||
|
drop(write!($dst, $($arg)*))
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! wln {
|
||||||
|
($dst:expr) => {
|
||||||
|
drop(writeln!($dst))
|
||||||
|
};
|
||||||
|
($dst:expr, $($arg:tt)*) => {
|
||||||
|
drop(writeln!($dst, $($arg)*))
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
struct Printer<'a> {
|
||||||
|
tree: &'a ItemTree,
|
||||||
|
buf: String,
|
||||||
|
indent_level: usize,
|
||||||
|
needs_indent: bool,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'a> Printer<'a> {
|
||||||
|
fn indented(&mut self, f: impl FnOnce(&mut Self)) {
|
||||||
|
self.indent_level += 1;
|
||||||
|
wln!(self);
|
||||||
|
f(self);
|
||||||
|
self.indent_level -= 1;
|
||||||
|
self.buf = self.buf.trim_end_matches('\n').to_string();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Ensures that a blank line is output before the next text.
|
||||||
|
fn blank(&mut self) {
|
||||||
|
let mut iter = self.buf.chars().rev().fuse();
|
||||||
|
match (iter.next(), iter.next()) {
|
||||||
|
(Some('\n'), Some('\n')) | (Some('\n'), None) | (None, None) => {}
|
||||||
|
(Some('\n'), Some(_)) => {
|
||||||
|
self.buf.push('\n');
|
||||||
|
}
|
||||||
|
(Some(_), _) => {
|
||||||
|
self.buf.push('\n');
|
||||||
|
self.buf.push('\n');
|
||||||
|
}
|
||||||
|
(None, Some(_)) => unreachable!(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn print_attrs(&mut self, attrs: &RawAttrs, inner: bool) {
|
||||||
|
let inner = if inner { "!" } else { "" };
|
||||||
|
for attr in &**attrs {
|
||||||
|
wln!(
|
||||||
|
self,
|
||||||
|
"#{}[{}{}] // {:?}",
|
||||||
|
inner,
|
||||||
|
attr.path,
|
||||||
|
attr.input.as_ref().map(|it| it.to_string()).unwrap_or_default(),
|
||||||
|
attr.id,
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn print_attrs_of(&mut self, of: impl Into<AttrOwner>) {
|
||||||
|
if let Some(attrs) = self.tree.attrs.get(&of.into()) {
|
||||||
|
self.print_attrs(attrs, false);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn print_visibility(&mut self, vis: RawVisibilityId) {
|
||||||
|
match &self.tree[vis] {
|
||||||
|
RawVisibility::Module(path) => w!(self, "pub({}) ", path),
|
||||||
|
RawVisibility::Public => w!(self, "pub "),
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
fn print_fields(&mut self, fields: &Fields) {
|
||||||
|
match fields {
|
||||||
|
Fields::Record(fields) => {
|
||||||
|
w!(self, " {{");
|
||||||
|
self.indented(|this| {
|
||||||
|
for field in fields.clone() {
|
||||||
|
let Field { visibility, name, type_ref } = &this.tree[field];
|
||||||
|
this.print_attrs_of(field);
|
||||||
|
this.print_visibility(*visibility);
|
||||||
|
w!(this, "{}: ", name);
|
||||||
|
this.print_type_ref(type_ref);
|
||||||
|
wln!(this, ",");
|
||||||
|
}
|
||||||
|
});
|
||||||
|
w!(self, "}}");
|
||||||
|
}
|
||||||
|
Fields::Tuple(fields) => {
|
||||||
|
w!(self, "(");
|
||||||
|
self.indented(|this| {
|
||||||
|
for field in fields.clone() {
|
||||||
|
let Field { visibility, name, type_ref } = &this.tree[field];
|
||||||
|
this.print_attrs_of(field);
|
||||||
|
this.print_visibility(*visibility);
|
||||||
|
w!(this, "{}: ", name);
|
||||||
|
this.print_type_ref(type_ref);
|
||||||
|
wln!(this, ",");
|
||||||
|
}
|
||||||
|
});
|
||||||
|
w!(self, ")");
|
||||||
|
}
|
||||||
|
Fields::Unit => {}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn print_mod_item(&mut self, item: ModItem) {
|
||||||
|
self.print_attrs_of(item);
|
||||||
|
|
||||||
|
match item {
|
||||||
|
ModItem::Import(it) => {
|
||||||
|
let Import { visibility, path, is_glob, alias, ast_id: _, index } = &self.tree[it];
|
||||||
|
self.print_visibility(*visibility);
|
||||||
|
w!(self, "use {}", path);
|
||||||
|
if *is_glob {
|
||||||
|
w!(self, "::*");
|
||||||
|
}
|
||||||
|
if let Some(alias) = alias {
|
||||||
|
w!(self, " as {}", alias);
|
||||||
|
}
|
||||||
|
wln!(self, "; // {}", index);
|
||||||
|
}
|
||||||
|
ModItem::ExternCrate(it) => {
|
||||||
|
let ExternCrate { name, alias, visibility, ast_id: _ } = &self.tree[it];
|
||||||
|
self.print_visibility(*visibility);
|
||||||
|
w!(self, "extern crate {}", name);
|
||||||
|
if let Some(alias) = alias {
|
||||||
|
w!(self, " as {}", alias);
|
||||||
|
}
|
||||||
|
wln!(self, ";");
|
||||||
|
}
|
||||||
|
ModItem::ExternBlock(it) => {
|
||||||
|
let ExternBlock { abi, ast_id: _, children } = &self.tree[it];
|
||||||
|
w!(self, "extern ");
|
||||||
|
if let Some(abi) = abi {
|
||||||
|
w!(self, "\"{}\" ", abi);
|
||||||
|
}
|
||||||
|
w!(self, "{{");
|
||||||
|
self.indented(|this| {
|
||||||
|
for child in &**children {
|
||||||
|
this.print_mod_item(*child);
|
||||||
|
}
|
||||||
|
});
|
||||||
|
wln!(self, "}}");
|
||||||
|
}
|
||||||
|
ModItem::Function(it) => {
|
||||||
|
let Function {
|
||||||
|
name,
|
||||||
|
visibility,
|
||||||
|
generic_params: _, // FIXME print these somehow
|
||||||
|
abi,
|
||||||
|
params,
|
||||||
|
ret_type,
|
||||||
|
ast_id: _,
|
||||||
|
flags,
|
||||||
|
} = &self.tree[it];
|
||||||
|
if flags.bits != 0 {
|
||||||
|
wln!(self, "// flags = 0x{:X}", flags.bits);
|
||||||
|
}
|
||||||
|
self.print_visibility(*visibility);
|
||||||
|
if let Some(abi) = abi {
|
||||||
|
w!(self, "extern \"{}\" ", abi);
|
||||||
|
}
|
||||||
|
w!(self, "fn {}(", name);
|
||||||
|
if !params.is_empty() {
|
||||||
|
self.indented(|this| {
|
||||||
|
for param in params.clone() {
|
||||||
|
this.print_attrs_of(param);
|
||||||
|
match &this.tree[param] {
|
||||||
|
Param::Normal(ty) => {
|
||||||
|
w!(this, "_: ");
|
||||||
|
this.print_type_ref(ty);
|
||||||
|
wln!(this, ",");
|
||||||
|
}
|
||||||
|
Param::Varargs => {
|
||||||
|
wln!(this, "...");
|
||||||
|
}
|
||||||
|
};
|
||||||
|
}
|
||||||
|
});
|
||||||
|
}
|
||||||
|
w!(self, ") -> ");
|
||||||
|
self.print_type_ref(ret_type);
|
||||||
|
wln!(self, ";");
|
||||||
|
}
|
||||||
|
ModItem::Struct(it) => {
|
||||||
|
let Struct { visibility, name, fields, generic_params: _, ast_id: _ } =
|
||||||
|
&self.tree[it];
|
||||||
|
self.print_visibility(*visibility);
|
||||||
|
w!(self, "struct {}", name);
|
||||||
|
self.print_fields(fields);
|
||||||
|
if matches!(fields, Fields::Record(_)) {
|
||||||
|
wln!(self);
|
||||||
|
} else {
|
||||||
|
wln!(self, ";");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
ModItem::Union(it) => {
|
||||||
|
let Union { name, visibility, fields, generic_params: _, ast_id: _ } =
|
||||||
|
&self.tree[it];
|
||||||
|
self.print_visibility(*visibility);
|
||||||
|
w!(self, "union {}", name);
|
||||||
|
self.print_fields(fields);
|
||||||
|
if matches!(fields, Fields::Record(_)) {
|
||||||
|
wln!(self);
|
||||||
|
} else {
|
||||||
|
wln!(self, ";");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
ModItem::Enum(it) => {
|
||||||
|
let Enum { name, visibility, variants, generic_params: _, ast_id: _ } =
|
||||||
|
&self.tree[it];
|
||||||
|
self.print_visibility(*visibility);
|
||||||
|
w!(self, "enum {} {{", name);
|
||||||
|
self.indented(|this| {
|
||||||
|
for variant in variants.clone() {
|
||||||
|
let Variant { name, fields } = &this.tree[variant];
|
||||||
|
this.print_attrs_of(variant);
|
||||||
|
w!(this, "{}", name);
|
||||||
|
this.print_fields(fields);
|
||||||
|
wln!(this, ",");
|
||||||
|
}
|
||||||
|
});
|
||||||
|
wln!(self, "}}");
|
||||||
|
}
|
||||||
|
ModItem::Const(it) => {
|
||||||
|
let Const { name, visibility, type_ref, ast_id: _ } = &self.tree[it];
|
||||||
|
self.print_visibility(*visibility);
|
||||||
|
w!(self, "const ");
|
||||||
|
match name {
|
||||||
|
Some(name) => w!(self, "{}", name),
|
||||||
|
None => w!(self, "_"),
|
||||||
|
}
|
||||||
|
w!(self, ": ");
|
||||||
|
self.print_type_ref(type_ref);
|
||||||
|
wln!(self, " = _;");
|
||||||
|
}
|
||||||
|
ModItem::Static(it) => {
|
||||||
|
let Static { name, visibility, mutable, is_extern, type_ref, ast_id: _ } =
|
||||||
|
&self.tree[it];
|
||||||
|
self.print_visibility(*visibility);
|
||||||
|
w!(self, "static ");
|
||||||
|
if *mutable {
|
||||||
|
w!(self, "mut ");
|
||||||
|
}
|
||||||
|
w!(self, "{}: ", name);
|
||||||
|
self.print_type_ref(type_ref);
|
||||||
|
w!(self, " = _;");
|
||||||
|
if *is_extern {
|
||||||
|
w!(self, " // extern");
|
||||||
|
}
|
||||||
|
wln!(self);
|
||||||
|
}
|
||||||
|
ModItem::Trait(it) => {
|
||||||
|
let Trait {
|
||||||
|
name,
|
||||||
|
visibility,
|
||||||
|
is_auto,
|
||||||
|
is_unsafe,
|
||||||
|
bounds,
|
||||||
|
items,
|
||||||
|
generic_params: _,
|
||||||
|
ast_id: _,
|
||||||
|
} = &self.tree[it];
|
||||||
|
self.print_visibility(*visibility);
|
||||||
|
if *is_unsafe {
|
||||||
|
w!(self, "unsafe ");
|
||||||
|
}
|
||||||
|
if *is_auto {
|
||||||
|
w!(self, "auto ");
|
||||||
|
}
|
||||||
|
w!(self, "trait {}", name);
|
||||||
|
if !bounds.is_empty() {
|
||||||
|
w!(self, ": ");
|
||||||
|
self.print_type_bounds(bounds);
|
||||||
|
}
|
||||||
|
w!(self, " {{");
|
||||||
|
self.indented(|this| {
|
||||||
|
for item in &**items {
|
||||||
|
this.print_mod_item((*item).into());
|
||||||
|
}
|
||||||
|
});
|
||||||
|
wln!(self, "}}");
|
||||||
|
}
|
||||||
|
ModItem::Impl(it) => {
|
||||||
|
let Impl {
|
||||||
|
target_trait,
|
||||||
|
self_ty,
|
||||||
|
is_negative,
|
||||||
|
items,
|
||||||
|
generic_params: _,
|
||||||
|
ast_id: _,
|
||||||
|
} = &self.tree[it];
|
||||||
|
w!(self, "impl ");
|
||||||
|
if *is_negative {
|
||||||
|
w!(self, "!");
|
||||||
|
}
|
||||||
|
if let Some(tr) = target_trait {
|
||||||
|
self.print_path(&tr.path);
|
||||||
|
w!(self, " for ");
|
||||||
|
}
|
||||||
|
self.print_type_ref(self_ty);
|
||||||
|
w!(self, " {{");
|
||||||
|
self.indented(|this| {
|
||||||
|
for item in &**items {
|
||||||
|
this.print_mod_item((*item).into());
|
||||||
|
}
|
||||||
|
});
|
||||||
|
wln!(self, "}}");
|
||||||
|
}
|
||||||
|
ModItem::TypeAlias(it) => {
|
||||||
|
let TypeAlias {
|
||||||
|
name,
|
||||||
|
visibility,
|
||||||
|
bounds,
|
||||||
|
type_ref,
|
||||||
|
is_extern,
|
||||||
|
generic_params: _,
|
||||||
|
ast_id: _,
|
||||||
|
} = &self.tree[it];
|
||||||
|
self.print_visibility(*visibility);
|
||||||
|
w!(self, "type {}", name);
|
||||||
|
if !bounds.is_empty() {
|
||||||
|
w!(self, ": ");
|
||||||
|
self.print_type_bounds(bounds);
|
||||||
|
}
|
||||||
|
if let Some(ty) = type_ref {
|
||||||
|
w!(self, " = ");
|
||||||
|
self.print_type_ref(ty);
|
||||||
|
}
|
||||||
|
w!(self, ";");
|
||||||
|
if *is_extern {
|
||||||
|
w!(self, " // extern");
|
||||||
|
}
|
||||||
|
wln!(self);
|
||||||
|
}
|
||||||
|
ModItem::Mod(it) => {
|
||||||
|
let Mod { name, visibility, kind, ast_id: _ } = &self.tree[it];
|
||||||
|
self.print_visibility(*visibility);
|
||||||
|
w!(self, "mod {}", name);
|
||||||
|
match kind {
|
||||||
|
ModKind::Inline { items } => {
|
||||||
|
w!(self, " {{");
|
||||||
|
self.indented(|this| {
|
||||||
|
for item in &**items {
|
||||||
|
this.print_mod_item((*item).into());
|
||||||
|
}
|
||||||
|
});
|
||||||
|
wln!(self, "}}");
|
||||||
|
}
|
||||||
|
ModKind::Outline {} => {
|
||||||
|
wln!(self, ";");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
ModItem::MacroCall(it) => {
|
||||||
|
let MacroCall { path, ast_id: _, fragment: _ } = &self.tree[it];
|
||||||
|
wln!(self, "{}!(...);", path);
|
||||||
|
}
|
||||||
|
ModItem::MacroRules(it) => {
|
||||||
|
let MacroRules { name, ast_id: _ } = &self.tree[it];
|
||||||
|
wln!(self, "macro_rules! {} {{ ... }}", name);
|
||||||
|
}
|
||||||
|
ModItem::MacroDef(it) => {
|
||||||
|
let MacroDef { name, visibility, ast_id: _ } = &self.tree[it];
|
||||||
|
self.print_visibility(*visibility);
|
||||||
|
wln!(self, "macro {} {{ ... }}", name);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
self.blank();
|
||||||
|
}
|
||||||
|
|
||||||
|
fn print_type_ref(&mut self, type_ref: &TypeRef) {
|
||||||
|
// FIXME: deduplicate with `HirDisplay` impl
|
||||||
|
match type_ref {
|
||||||
|
TypeRef::Never => w!(self, "!"),
|
||||||
|
TypeRef::Placeholder => w!(self, "_"),
|
||||||
|
TypeRef::Tuple(fields) => {
|
||||||
|
w!(self, "(");
|
||||||
|
for (i, field) in fields.iter().enumerate() {
|
||||||
|
if i != 0 {
|
||||||
|
w!(self, ", ");
|
||||||
|
}
|
||||||
|
self.print_type_ref(field);
|
||||||
|
}
|
||||||
|
w!(self, ")");
|
||||||
|
}
|
||||||
|
TypeRef::Path(path) => self.print_path(path),
|
||||||
|
TypeRef::RawPtr(pointee, mtbl) => {
|
||||||
|
let mtbl = match mtbl {
|
||||||
|
Mutability::Shared => "*const",
|
||||||
|
Mutability::Mut => "*mut",
|
||||||
|
};
|
||||||
|
w!(self, "{} ", mtbl);
|
||||||
|
self.print_type_ref(pointee);
|
||||||
|
}
|
||||||
|
TypeRef::Reference(pointee, lt, mtbl) => {
|
||||||
|
let mtbl = match mtbl {
|
||||||
|
Mutability::Shared => "",
|
||||||
|
Mutability::Mut => "mut ",
|
||||||
|
};
|
||||||
|
w!(self, "&");
|
||||||
|
if let Some(lt) = lt {
|
||||||
|
w!(self, "{} ", lt.name);
|
||||||
|
}
|
||||||
|
w!(self, "{}", mtbl);
|
||||||
|
self.print_type_ref(pointee);
|
||||||
|
}
|
||||||
|
TypeRef::Array(elem, len) => {
|
||||||
|
w!(self, "[");
|
||||||
|
self.print_type_ref(elem);
|
||||||
|
w!(self, "; {}]", len);
|
||||||
|
}
|
||||||
|
TypeRef::Slice(elem) => {
|
||||||
|
w!(self, "[");
|
||||||
|
self.print_type_ref(elem);
|
||||||
|
w!(self, "]");
|
||||||
|
}
|
||||||
|
TypeRef::Fn(args_and_ret, varargs) => {
|
||||||
|
let (ret, args) =
|
||||||
|
args_and_ret.split_last().expect("TypeRef::Fn is missing return type");
|
||||||
|
w!(self, "fn(");
|
||||||
|
for (i, arg) in args.iter().enumerate() {
|
||||||
|
if i != 0 {
|
||||||
|
w!(self, ", ");
|
||||||
|
}
|
||||||
|
self.print_type_ref(arg);
|
||||||
|
}
|
||||||
|
if *varargs {
|
||||||
|
if !args.is_empty() {
|
||||||
|
w!(self, ", ");
|
||||||
|
}
|
||||||
|
w!(self, "...");
|
||||||
|
}
|
||||||
|
w!(self, ") -> ");
|
||||||
|
self.print_type_ref(ret);
|
||||||
|
}
|
||||||
|
TypeRef::Macro(_ast_id) => {
|
||||||
|
w!(self, "<macro>");
|
||||||
|
}
|
||||||
|
TypeRef::Error => drop(write!(self, "{{unknown}}")),
|
||||||
|
TypeRef::ImplTrait(bounds) => {
|
||||||
|
w!(self, "impl ");
|
||||||
|
self.print_type_bounds(bounds);
|
||||||
|
}
|
||||||
|
TypeRef::DynTrait(bounds) => {
|
||||||
|
w!(self, "dyn ");
|
||||||
|
self.print_type_bounds(bounds);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn print_type_bounds(&mut self, bounds: &[TypeBound]) {
|
||||||
|
for (i, bound) in bounds.iter().enumerate() {
|
||||||
|
if i != 0 {
|
||||||
|
w!(self, " + ");
|
||||||
|
}
|
||||||
|
|
||||||
|
match bound {
|
||||||
|
TypeBound::Path(path) => self.print_path(path),
|
||||||
|
TypeBound::Lifetime(lt) => w!(self, "{}", lt.name),
|
||||||
|
TypeBound::Error => w!(self, "{{unknown}}"),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn print_path(&mut self, path: &Path) {
|
||||||
|
if path.type_anchor().is_none()
|
||||||
|
&& path.segments().iter().all(|seg| seg.args_and_bindings.is_none())
|
||||||
|
{
|
||||||
|
w!(self, "{}", path.mod_path());
|
||||||
|
} else {
|
||||||
|
// too complicated, just use `Debug`
|
||||||
|
w!(self, "{:?}", path);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'a> Write for Printer<'a> {
|
||||||
|
fn write_str(&mut self, s: &str) -> fmt::Result {
|
||||||
|
for line in s.split_inclusive('\n') {
|
||||||
|
if self.needs_indent {
|
||||||
|
match self.buf.chars().last() {
|
||||||
|
Some('\n') | None => {}
|
||||||
|
_ => self.buf.push('\n'),
|
||||||
|
}
|
||||||
|
self.buf.push_str(&" ".repeat(self.indent_level));
|
||||||
|
self.needs_indent = false;
|
||||||
|
}
|
||||||
|
|
||||||
|
self.buf.push_str(line);
|
||||||
|
self.needs_indent = line.ends_with('\n');
|
||||||
|
}
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
||||||
244
crates/hir_def/src/item_tree/tests.rs
Normal file
244
crates/hir_def/src/item_tree/tests.rs
Normal file
@ -0,0 +1,244 @@
|
|||||||
|
use base_db::fixture::WithFixture;
|
||||||
|
use expect_test::{expect, Expect};
|
||||||
|
|
||||||
|
use crate::{db::DefDatabase, test_db::TestDB};
|
||||||
|
|
||||||
|
fn check(ra_fixture: &str, expect: Expect) {
|
||||||
|
let (db, file_id) = TestDB::with_single_file(ra_fixture);
|
||||||
|
let item_tree = db.file_item_tree(file_id.into());
|
||||||
|
let pretty = item_tree.pretty_print();
|
||||||
|
expect.assert_eq(&pretty);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn imports() {
|
||||||
|
check(
|
||||||
|
r#"
|
||||||
|
//! file comment
|
||||||
|
#![no_std]
|
||||||
|
//! another file comment
|
||||||
|
|
||||||
|
extern crate self as renamed;
|
||||||
|
pub(super) extern crate bli;
|
||||||
|
|
||||||
|
pub use crate::path::{nested, items as renamed, Trait as _};
|
||||||
|
use globs::*;
|
||||||
|
|
||||||
|
/// docs on import
|
||||||
|
use crate::{A, B};
|
||||||
|
"#,
|
||||||
|
expect![[r##"
|
||||||
|
#![doc = " file comment"] // AttrId { is_doc_comment: true, ast_index: 0 }
|
||||||
|
#![no_std] // AttrId { is_doc_comment: false, ast_index: 0 }
|
||||||
|
#![doc = " another file comment"] // AttrId { is_doc_comment: true, ast_index: 1 }
|
||||||
|
|
||||||
|
pub(self) extern crate self as renamed;
|
||||||
|
|
||||||
|
pub(super) extern crate bli;
|
||||||
|
|
||||||
|
pub use crate::path::nested; // 0
|
||||||
|
|
||||||
|
pub use crate::path::items as renamed; // 1
|
||||||
|
|
||||||
|
pub use crate::path::Trait as _; // 2
|
||||||
|
|
||||||
|
pub(self) use globs::*; // 0
|
||||||
|
|
||||||
|
#[doc = " docs on import"] // AttrId { is_doc_comment: true, ast_index: 0 }
|
||||||
|
pub(self) use crate::A; // 0
|
||||||
|
|
||||||
|
#[doc = " docs on import"] // AttrId { is_doc_comment: true, ast_index: 0 }
|
||||||
|
pub(self) use crate::B; // 1
|
||||||
|
"##]],
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn extern_blocks() {
|
||||||
|
check(
|
||||||
|
r#"
|
||||||
|
#[on_extern_block]
|
||||||
|
extern "C" {
|
||||||
|
#[on_extern_type]
|
||||||
|
type ExType;
|
||||||
|
|
||||||
|
#[on_extern_static]
|
||||||
|
static EX_STATIC: u8;
|
||||||
|
|
||||||
|
#[on_extern_fn]
|
||||||
|
fn ex_fn();
|
||||||
|
}
|
||||||
|
"#,
|
||||||
|
expect![[r##"
|
||||||
|
#[on_extern_block] // AttrId { is_doc_comment: false, ast_index: 0 }
|
||||||
|
extern "C" {
|
||||||
|
#[on_extern_type] // AttrId { is_doc_comment: false, ast_index: 0 }
|
||||||
|
pub(self) type ExType; // extern
|
||||||
|
|
||||||
|
#[on_extern_static] // AttrId { is_doc_comment: false, ast_index: 0 }
|
||||||
|
pub(self) static EX_STATIC: u8 = _; // extern
|
||||||
|
|
||||||
|
#[on_extern_fn] // AttrId { is_doc_comment: false, ast_index: 0 }
|
||||||
|
// flags = 0x60
|
||||||
|
pub(self) fn ex_fn() -> ();
|
||||||
|
}
|
||||||
|
"##]],
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn adts() {
|
||||||
|
check(
|
||||||
|
r#"
|
||||||
|
struct Unit;
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
struct Struct {
|
||||||
|
/// fld docs
|
||||||
|
fld: (),
|
||||||
|
}
|
||||||
|
|
||||||
|
struct Tuple(#[attr] u8);
|
||||||
|
|
||||||
|
union Ize {
|
||||||
|
a: (),
|
||||||
|
b: (),
|
||||||
|
}
|
||||||
|
|
||||||
|
enum E {
|
||||||
|
/// comment on Unit
|
||||||
|
Unit,
|
||||||
|
/// comment on Tuple
|
||||||
|
Tuple(u8),
|
||||||
|
Struct {
|
||||||
|
/// comment on a: u8
|
||||||
|
a: u8,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
"#,
|
||||||
|
expect![[r##"
|
||||||
|
pub(self) struct Unit;
|
||||||
|
|
||||||
|
#[derive(Debug)] // AttrId { is_doc_comment: false, ast_index: 0 }
|
||||||
|
pub(self) struct Struct {
|
||||||
|
#[doc = " fld docs"] // AttrId { is_doc_comment: true, ast_index: 0 }
|
||||||
|
pub(self) fld: (),
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(self) struct Tuple(
|
||||||
|
#[attr] // AttrId { is_doc_comment: false, ast_index: 0 }
|
||||||
|
pub(self) 0: u8,
|
||||||
|
);
|
||||||
|
|
||||||
|
pub(self) union Ize {
|
||||||
|
pub(self) a: (),
|
||||||
|
pub(self) b: (),
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(self) enum E {
|
||||||
|
#[doc = " comment on Unit"] // AttrId { is_doc_comment: true, ast_index: 0 }
|
||||||
|
Unit,
|
||||||
|
#[doc = " comment on Tuple"] // AttrId { is_doc_comment: true, ast_index: 0 }
|
||||||
|
Tuple(
|
||||||
|
pub(self) 0: u8,
|
||||||
|
),
|
||||||
|
Struct {
|
||||||
|
#[doc = " comment on a: u8"] // AttrId { is_doc_comment: true, ast_index: 0 }
|
||||||
|
pub(self) a: u8,
|
||||||
|
},
|
||||||
|
}
|
||||||
|
"##]],
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn misc() {
|
||||||
|
check(
|
||||||
|
r#"
|
||||||
|
pub static mut ST: () = ();
|
||||||
|
|
||||||
|
const _: Anon = ();
|
||||||
|
|
||||||
|
#[attr]
|
||||||
|
fn f(#[attr] arg: u8, _: ()) {
|
||||||
|
#![inner_attr_in_fn]
|
||||||
|
}
|
||||||
|
|
||||||
|
trait Tr: SuperTrait + 'lifetime {
|
||||||
|
type Assoc: AssocBound = Default;
|
||||||
|
fn method(&self);
|
||||||
|
}
|
||||||
|
"#,
|
||||||
|
expect![[r##"
|
||||||
|
pub static mut ST: () = _;
|
||||||
|
|
||||||
|
pub(self) const _: Anon = _;
|
||||||
|
|
||||||
|
#[attr] // AttrId { is_doc_comment: false, ast_index: 0 }
|
||||||
|
#[inner_attr_in_fn] // AttrId { is_doc_comment: false, ast_index: 1 }
|
||||||
|
// flags = 0x2
|
||||||
|
pub(self) fn f(
|
||||||
|
#[attr] // AttrId { is_doc_comment: false, ast_index: 0 }
|
||||||
|
_: u8,
|
||||||
|
_: (),
|
||||||
|
) -> ();
|
||||||
|
|
||||||
|
pub(self) trait Tr: SuperTrait + 'lifetime {
|
||||||
|
pub(self) type Assoc: AssocBound = Default;
|
||||||
|
|
||||||
|
// flags = 0x1
|
||||||
|
pub(self) fn method(
|
||||||
|
_: &Self,
|
||||||
|
) -> ();
|
||||||
|
}
|
||||||
|
"##]],
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn modules() {
|
||||||
|
check(
|
||||||
|
r#"
|
||||||
|
/// outer
|
||||||
|
mod inline {
|
||||||
|
//! inner
|
||||||
|
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
fn fn_in_module() {}
|
||||||
|
}
|
||||||
|
"#,
|
||||||
|
expect![[r##"
|
||||||
|
#[doc = " outer"] // AttrId { is_doc_comment: true, ast_index: 0 }
|
||||||
|
#[doc = " inner"] // AttrId { is_doc_comment: true, ast_index: 1 }
|
||||||
|
pub(self) mod inline {
|
||||||
|
pub(self) use super::*; // 0
|
||||||
|
|
||||||
|
// flags = 0x2
|
||||||
|
pub(self) fn fn_in_module() -> ();
|
||||||
|
}
|
||||||
|
"##]],
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn macros() {
|
||||||
|
check(
|
||||||
|
r#"
|
||||||
|
macro_rules! m {
|
||||||
|
() => {};
|
||||||
|
}
|
||||||
|
|
||||||
|
pub macro m2() {}
|
||||||
|
|
||||||
|
m!();
|
||||||
|
"#,
|
||||||
|
expect![[r#"
|
||||||
|
macro_rules! m { ... }
|
||||||
|
|
||||||
|
pub macro m2 { ... }
|
||||||
|
|
||||||
|
m!(...);
|
||||||
|
"#]],
|
||||||
|
);
|
||||||
|
}
|
||||||
Loading…
Reference in New Issue
Block a user