From 98baa9b569b49162392ed4149dd435854fe941b8 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Wed, 12 Aug 2020 16:22:05 +0200 Subject: Rename ra_arena --- crates/ra_hir_def/src/item_tree.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'crates/ra_hir_def/src/item_tree.rs') diff --git a/crates/ra_hir_def/src/item_tree.rs b/crates/ra_hir_def/src/item_tree.rs index a67e75dac..fc05bb307 100644 --- a/crates/ra_hir_def/src/item_tree.rs +++ b/crates/ra_hir_def/src/item_tree.rs @@ -13,6 +13,7 @@ use std::{ sync::Arc, }; +use arena::{Arena, Idx, RawId}; use ast::{AstNode, AttrsOwner, NameOwner, StructKind}; use either::Either; use hir_expand::{ @@ -21,7 +22,6 @@ use hir_expand::{ name::{name, AsName, Name}, HirFileId, InFile, }; -use ra_arena::{Arena, Idx, RawId}; use ra_syntax::{ast, match_ast}; use rustc_hash::FxHashMap; use smallvec::SmallVec; -- cgit v1.2.3 From 208b7bd7ba687fb570feb1b89219f14c63712ce8 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Wed, 12 Aug 2020 16:32:36 +0200 Subject: Rename ra_prof -> profile --- crates/ra_hir_def/src/item_tree.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'crates/ra_hir_def/src/item_tree.rs') diff --git a/crates/ra_hir_def/src/item_tree.rs b/crates/ra_hir_def/src/item_tree.rs index fc05bb307..104966c7f 100644 --- a/crates/ra_hir_def/src/item_tree.rs +++ b/crates/ra_hir_def/src/item_tree.rs @@ -77,7 +77,7 @@ pub struct ItemTree { impl ItemTree { pub fn item_tree_query(db: &dyn DefDatabase, file_id: HirFileId) -> Arc { - let _p = ra_prof::profile("item_tree_query").detail(|| format!("{:?}", file_id)); + let _p = profile::span("item_tree_query").detail(|| format!("{:?}", file_id)); let syntax = if let Some(node) = db.parse_or_expand(file_id) { node } else { -- cgit v1.2.3 From a1c187eef3ba08076aedb5154929f7eda8d1b424 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Wed, 12 Aug 2020 18:26:51 +0200 Subject: Rename ra_syntax -> syntax --- crates/ra_hir_def/src/item_tree.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'crates/ra_hir_def/src/item_tree.rs') diff --git a/crates/ra_hir_def/src/item_tree.rs b/crates/ra_hir_def/src/item_tree.rs index 104966c7f..e14722cae 100644 --- a/crates/ra_hir_def/src/item_tree.rs +++ b/crates/ra_hir_def/src/item_tree.rs @@ -22,9 +22,9 @@ use hir_expand::{ name::{name, AsName, Name}, HirFileId, InFile, }; -use ra_syntax::{ast, match_ast}; use rustc_hash::FxHashMap; use smallvec::SmallVec; +use syntax::{ast, match_ast}; use test_utils::mark; use crate::{ -- cgit v1.2.3 From b28c54a2c239acd73f2eea80fda9ee3960d2c046 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Thu, 13 Aug 2020 16:28:27 +0200 Subject: Rename ra_hir_def -> hir_def --- crates/ra_hir_def/src/item_tree.rs | 754 ------------------------------------- 1 file changed, 754 deletions(-) delete mode 100644 crates/ra_hir_def/src/item_tree.rs (limited to 'crates/ra_hir_def/src/item_tree.rs') diff --git a/crates/ra_hir_def/src/item_tree.rs b/crates/ra_hir_def/src/item_tree.rs deleted file mode 100644 index e14722cae..000000000 --- a/crates/ra_hir_def/src/item_tree.rs +++ /dev/null @@ -1,754 +0,0 @@ -//! A simplified AST that only contains items. - -mod lower; -#[cfg(test)] -mod tests; - -use std::{ - any::type_name, - fmt::{self, Debug}, - hash::{Hash, Hasher}, - marker::PhantomData, - ops::{Index, Range}, - sync::Arc, -}; - -use arena::{Arena, Idx, RawId}; -use ast::{AstNode, AttrsOwner, NameOwner, StructKind}; -use either::Either; -use hir_expand::{ - ast_id_map::FileAstId, - hygiene::Hygiene, - name::{name, AsName, Name}, - HirFileId, InFile, -}; -use rustc_hash::FxHashMap; -use smallvec::SmallVec; -use syntax::{ast, match_ast}; -use test_utils::mark; - -use crate::{ - attr::Attrs, - db::DefDatabase, - generics::GenericParams, - path::{path, AssociatedTypeBinding, GenericArgs, ImportAlias, ModPath, Path, PathKind}, - type_ref::{Mutability, TypeBound, TypeRef}, - visibility::RawVisibility, -}; - -#[derive(Copy, Clone, Eq, PartialEq)] -pub struct RawVisibilityId(u32); - -impl RawVisibilityId { - pub const PUB: Self = RawVisibilityId(u32::max_value()); - pub const PRIV: Self = RawVisibilityId(u32::max_value() - 1); - pub const PUB_CRATE: Self = RawVisibilityId(u32::max_value() - 2); -} - -impl fmt::Debug for RawVisibilityId { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - let mut f = f.debug_tuple("RawVisibilityId"); - match *self { - Self::PUB => f.field(&"pub"), - Self::PRIV => f.field(&"pub(self)"), - Self::PUB_CRATE => f.field(&"pub(crate)"), - _ => f.field(&self.0), - }; - f.finish() - } -} - -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct GenericParamsId(u32); - -impl GenericParamsId { - pub const EMPTY: Self = GenericParamsId(u32::max_value()); -} - -/// The item tree of a source file. -#[derive(Debug, Eq, PartialEq)] -pub struct ItemTree { - top_level: SmallVec<[ModItem; 1]>, - attrs: FxHashMap, - inner_items: FxHashMap, SmallVec<[ModItem; 1]>>, - - data: Option>, -} - -impl ItemTree { - pub fn item_tree_query(db: &dyn DefDatabase, file_id: HirFileId) -> Arc { - let _p = profile::span("item_tree_query").detail(|| format!("{:?}", file_id)); - let syntax = if let Some(node) = db.parse_or_expand(file_id) { - node - } else { - return Arc::new(Self::empty()); - }; - - let hygiene = Hygiene::new(db.upcast(), file_id); - let ctx = lower::Ctx::new(db, hygiene.clone(), file_id); - let mut top_attrs = None; - let mut item_tree = match_ast! { - match syntax { - ast::SourceFile(file) => { - top_attrs = Some(Attrs::new(&file, &hygiene)); - ctx.lower_module_items(&file) - }, - ast::MacroItems(items) => { - ctx.lower_module_items(&items) - }, - // Macros can expand to expressions. We return an empty item tree in this case, but - // still need to collect inner items. - ast::Expr(e) => { - ctx.lower_inner_items(e.syntax()) - }, - _ => { - panic!("cannot create item tree from {:?}", syntax); - }, - } - }; - - if let Some(attrs) = top_attrs { - item_tree.attrs.insert(AttrOwner::TopLevel, attrs); - } - item_tree.shrink_to_fit(); - Arc::new(item_tree) - } - - fn empty() -> Self { - Self { - top_level: Default::default(), - attrs: Default::default(), - inner_items: Default::default(), - data: Default::default(), - } - } - - fn shrink_to_fit(&mut self) { - if let Some(data) = &mut self.data { - let ItemTreeData { - imports, - extern_crates, - functions, - structs, - fields, - unions, - enums, - variants, - consts, - statics, - traits, - impls, - type_aliases, - mods, - macro_calls, - exprs, - vis, - generics, - } = &mut **data; - - imports.shrink_to_fit(); - extern_crates.shrink_to_fit(); - functions.shrink_to_fit(); - structs.shrink_to_fit(); - fields.shrink_to_fit(); - unions.shrink_to_fit(); - enums.shrink_to_fit(); - variants.shrink_to_fit(); - consts.shrink_to_fit(); - statics.shrink_to_fit(); - traits.shrink_to_fit(); - impls.shrink_to_fit(); - type_aliases.shrink_to_fit(); - mods.shrink_to_fit(); - macro_calls.shrink_to_fit(); - exprs.shrink_to_fit(); - - vis.arena.shrink_to_fit(); - generics.arena.shrink_to_fit(); - } - } - - /// Returns an iterator over all items located at the top level of the `HirFileId` this - /// `ItemTree` was created from. - pub fn top_level_items(&self) -> &[ModItem] { - &self.top_level - } - - /// Returns the inner attributes of the source file. - pub fn top_level_attrs(&self) -> &Attrs { - self.attrs.get(&AttrOwner::TopLevel).unwrap_or(&Attrs::EMPTY) - } - - pub fn attrs(&self, of: AttrOwner) -> &Attrs { - self.attrs.get(&of).unwrap_or(&Attrs::EMPTY) - } - - /// Returns the lowered inner items that `ast` corresponds to. - /// - /// Most AST items are lowered to a single `ModItem`, but some (eg. `use` items) may be lowered - /// to multiple items in the `ItemTree`. - pub fn inner_items(&self, ast: FileAstId) -> &[ModItem] { - &self.inner_items[&ast] - } - - pub fn all_inner_items(&self) -> impl Iterator + '_ { - self.inner_items.values().flatten().copied() - } - - pub fn source(&self, db: &dyn DefDatabase, of: ItemTreeId) -> S::Source { - // This unwrap cannot fail, since it has either succeeded above, or resulted in an empty - // ItemTree (in which case there is no valid `FileItemTreeId` to call this method with). - let root = - db.parse_or_expand(of.file_id).expect("parse_or_expand failed on constructed ItemTree"); - - let id = self[of.value].ast_id(); - let map = db.ast_id_map(of.file_id); - let ptr = map.get(id); - ptr.to_node(&root) - } - - fn data(&self) -> &ItemTreeData { - self.data.as_ref().expect("attempted to access data of empty ItemTree") - } - - fn data_mut(&mut self) -> &mut ItemTreeData { - self.data.get_or_insert_with(Box::default) - } -} - -#[derive(Default, Debug, Eq, PartialEq)] -struct ItemVisibilities { - arena: Arena, -} - -impl ItemVisibilities { - fn alloc(&mut self, vis: RawVisibility) -> RawVisibilityId { - match &vis { - RawVisibility::Public => RawVisibilityId::PUB, - RawVisibility::Module(path) if path.segments.is_empty() => match &path.kind { - PathKind::Super(0) => RawVisibilityId::PRIV, - PathKind::Crate => RawVisibilityId::PUB_CRATE, - _ => RawVisibilityId(self.arena.alloc(vis).into_raw().into()), - }, - _ => RawVisibilityId(self.arena.alloc(vis).into_raw().into()), - } - } -} - -static VIS_PUB: RawVisibility = RawVisibility::Public; -static VIS_PRIV: RawVisibility = - RawVisibility::Module(ModPath { kind: PathKind::Super(0), segments: Vec::new() }); -static VIS_PUB_CRATE: RawVisibility = - RawVisibility::Module(ModPath { kind: PathKind::Crate, segments: Vec::new() }); - -#[derive(Default, Debug, Eq, PartialEq)] -struct GenericParamsStorage { - arena: Arena, -} - -impl GenericParamsStorage { - fn alloc(&mut self, params: GenericParams) -> GenericParamsId { - if params.types.is_empty() && params.where_predicates.is_empty() { - return GenericParamsId::EMPTY; - } - - GenericParamsId(self.arena.alloc(params).into_raw().into()) - } -} - -static EMPTY_GENERICS: GenericParams = - GenericParams { types: Arena::new(), where_predicates: Vec::new() }; - -#[derive(Default, Debug, Eq, PartialEq)] -struct ItemTreeData { - imports: Arena, - extern_crates: Arena, - functions: Arena, - structs: Arena, - fields: Arena, - unions: Arena, - enums: Arena, - variants: Arena, - consts: Arena, - statics: Arena, - traits: Arena, - impls: Arena, - type_aliases: Arena, - mods: Arena, - macro_calls: Arena, - exprs: Arena, - - vis: ItemVisibilities, - generics: GenericParamsStorage, -} - -#[derive(Debug, Eq, PartialEq, Hash)] -pub enum AttrOwner { - /// Attributes on an item. - ModItem(ModItem), - /// Inner attributes of the source file. - TopLevel, - - Variant(Idx), - Field(Idx), - // FIXME: Store variant and field attrs, and stop reparsing them in `attrs_query`. -} - -macro_rules! from_attrs { - ( $( $var:ident($t:ty) ),+ ) => { - $( - impl From<$t> for AttrOwner { - fn from(t: $t) -> AttrOwner { - AttrOwner::$var(t) - } - } - )+ - }; -} - -from_attrs!(ModItem(ModItem), Variant(Idx), Field(Idx)); - -/// Trait implemented by all item nodes in the item tree. -pub trait ItemTreeNode: Clone { - type Source: AstNode + Into; - - fn ast_id(&self) -> FileAstId; - - /// Looks up an instance of `Self` in an item tree. - fn lookup(tree: &ItemTree, index: Idx) -> &Self; - - /// Downcasts a `ModItem` to a `FileItemTreeId` specific to this type. - fn id_from_mod_item(mod_item: ModItem) -> Option>; - - /// Upcasts a `FileItemTreeId` to a generic `ModItem`. - fn id_to_mod_item(id: FileItemTreeId) -> ModItem; -} - -pub struct FileItemTreeId { - index: Idx, - _p: PhantomData, -} - -impl Clone for FileItemTreeId { - fn clone(&self) -> Self { - Self { index: self.index, _p: PhantomData } - } -} -impl Copy for FileItemTreeId {} - -impl PartialEq for FileItemTreeId { - fn eq(&self, other: &FileItemTreeId) -> bool { - self.index == other.index - } -} -impl Eq for FileItemTreeId {} - -impl Hash for FileItemTreeId { - fn hash(&self, state: &mut H) { - self.index.hash(state) - } -} - -impl fmt::Debug for FileItemTreeId { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - self.index.fmt(f) - } -} - -pub type ItemTreeId = InFile>; - -macro_rules! mod_items { - ( $( $typ:ident in $fld:ident -> $ast:ty ),+ $(,)? ) => { - #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] - pub enum ModItem { - $( - $typ(FileItemTreeId<$typ>), - )+ - } - - $( - impl From> for ModItem { - fn from(id: FileItemTreeId<$typ>) -> ModItem { - ModItem::$typ(id) - } - } - )+ - - $( - impl ItemTreeNode for $typ { - type Source = $ast; - - fn ast_id(&self) -> FileAstId { - self.ast_id - } - - fn lookup(tree: &ItemTree, index: Idx) -> &Self { - &tree.data().$fld[index] - } - - fn id_from_mod_item(mod_item: ModItem) -> Option> { - if let ModItem::$typ(id) = mod_item { - Some(id) - } else { - None - } - } - - fn id_to_mod_item(id: FileItemTreeId) -> ModItem { - ModItem::$typ(id) - } - } - - impl Index> for ItemTree { - type Output = $typ; - - fn index(&self, index: Idx<$typ>) -> &Self::Output { - &self.data().$fld[index] - } - } - )+ - }; -} - -mod_items! { - Import in imports -> ast::Use, - ExternCrate in extern_crates -> ast::ExternCrate, - Function in functions -> ast::Fn, - Struct in structs -> ast::Struct, - Union in unions -> ast::Union, - Enum in enums -> ast::Enum, - Const in consts -> ast::Const, - Static in statics -> ast::Static, - Trait in traits -> ast::Trait, - Impl in impls -> ast::Impl, - TypeAlias in type_aliases -> ast::TypeAlias, - Mod in mods -> ast::Module, - MacroCall in macro_calls -> ast::MacroCall, -} - -macro_rules! impl_index { - ( $($fld:ident: $t:ty),+ $(,)? ) => { - $( - impl Index> for ItemTree { - type Output = $t; - - fn index(&self, index: Idx<$t>) -> &Self::Output { - &self.data().$fld[index] - } - } - )+ - }; -} - -impl_index!(fields: Field, variants: Variant, exprs: Expr); - -impl Index for ItemTree { - type Output = RawVisibility; - fn index(&self, index: RawVisibilityId) -> &Self::Output { - match index { - RawVisibilityId::PRIV => &VIS_PRIV, - RawVisibilityId::PUB => &VIS_PUB, - RawVisibilityId::PUB_CRATE => &VIS_PUB_CRATE, - _ => &self.data().vis.arena[Idx::from_raw(index.0.into())], - } - } -} - -impl Index for ItemTree { - type Output = GenericParams; - - fn index(&self, index: GenericParamsId) -> &Self::Output { - match index { - GenericParamsId::EMPTY => &EMPTY_GENERICS, - _ => &self.data().generics.arena[Idx::from_raw(index.0.into())], - } - } -} - -impl Index> for ItemTree { - type Output = N; - fn index(&self, id: FileItemTreeId) -> &N { - N::lookup(self, id.index) - } -} - -/// A desugared `use` import. -#[derive(Debug, Clone, Eq, PartialEq)] -pub struct Import { - pub path: ModPath, - pub alias: Option, - pub visibility: RawVisibilityId, - pub is_glob: bool, - pub is_prelude: bool, - /// AST ID of the `use` or `extern crate` item this import was derived from. Note that many - /// `Import`s can map to the same `use` item. - pub ast_id: FileAstId, -} - -#[derive(Debug, Clone, Eq, PartialEq)] -pub struct ExternCrate { - pub path: ModPath, - pub alias: Option, - pub visibility: RawVisibilityId, - /// Whether this is a `#[macro_use] extern crate ...`. - pub is_macro_use: bool, - pub ast_id: FileAstId, -} - -#[derive(Debug, Clone, Eq, PartialEq)] -pub struct Function { - pub name: Name, - pub visibility: RawVisibilityId, - pub generic_params: GenericParamsId, - pub has_self_param: bool, - pub is_unsafe: bool, - pub params: Box<[TypeRef]>, - pub is_varargs: bool, - pub ret_type: TypeRef, - pub ast_id: FileAstId, -} - -#[derive(Debug, Clone, Eq, PartialEq)] -pub struct Struct { - pub name: Name, - pub visibility: RawVisibilityId, - pub generic_params: GenericParamsId, - pub fields: Fields, - pub ast_id: FileAstId, - pub kind: StructDefKind, -} - -#[derive(Debug, Clone, Eq, PartialEq)] -pub enum StructDefKind { - /// `struct S { ... }` - type namespace only. - Record, - /// `struct S(...);` - Tuple, - /// `struct S;` - Unit, -} - -#[derive(Debug, Clone, Eq, PartialEq)] -pub struct Union { - pub name: Name, - pub visibility: RawVisibilityId, - pub generic_params: GenericParamsId, - pub fields: Fields, - pub ast_id: FileAstId, -} - -#[derive(Debug, Clone, Eq, PartialEq)] -pub struct Enum { - pub name: Name, - pub visibility: RawVisibilityId, - pub generic_params: GenericParamsId, - pub variants: IdRange, - pub ast_id: FileAstId, -} - -#[derive(Debug, Clone, Eq, PartialEq)] -pub struct Const { - /// const _: () = (); - pub name: Option, - pub visibility: RawVisibilityId, - pub type_ref: TypeRef, - pub ast_id: FileAstId, -} - -#[derive(Debug, Clone, Eq, PartialEq)] -pub struct Static { - pub name: Name, - pub visibility: RawVisibilityId, - pub mutable: bool, - pub type_ref: TypeRef, - pub ast_id: FileAstId, -} - -#[derive(Debug, Clone, Eq, PartialEq)] -pub struct Trait { - pub name: Name, - pub visibility: RawVisibilityId, - pub generic_params: GenericParamsId, - pub auto: bool, - pub items: Box<[AssocItem]>, - pub ast_id: FileAstId, -} - -#[derive(Debug, Clone, Eq, PartialEq)] -pub struct Impl { - pub generic_params: GenericParamsId, - pub target_trait: Option, - pub target_type: TypeRef, - pub is_negative: bool, - pub items: Box<[AssocItem]>, - pub ast_id: FileAstId, -} - -#[derive(Debug, Clone, PartialEq, Eq)] -pub struct TypeAlias { - pub name: Name, - pub visibility: RawVisibilityId, - /// Bounds on the type alias itself. Only valid in trait declarations, eg. `type Assoc: Copy;`. - pub bounds: Box<[TypeBound]>, - pub generic_params: GenericParamsId, - pub type_ref: Option, - pub ast_id: FileAstId, -} - -#[derive(Debug, Clone, Eq, PartialEq)] -pub struct Mod { - pub name: Name, - pub visibility: RawVisibilityId, - pub kind: ModKind, - pub ast_id: FileAstId, -} - -#[derive(Debug, Clone, Eq, PartialEq)] -pub enum ModKind { - /// `mod m { ... }` - Inline { items: Box<[ModItem]> }, - - /// `mod m;` - Outline {}, -} - -#[derive(Debug, Clone, Eq, PartialEq)] -pub struct MacroCall { - /// For `macro_rules!` declarations, this is the name of the declared macro. - pub name: Option, - /// Path to the called macro. - pub path: ModPath, - /// Has `#[macro_export]`. - pub is_export: bool, - /// Has `#[macro_export(local_inner_macros)]`. - pub is_local_inner: bool, - /// Has `#[rustc_builtin_macro]`. - pub is_builtin: bool, - pub ast_id: FileAstId, -} - -// NB: There's no `FileAstId` for `Expr`. The only case where this would be useful is for array -// lengths, but we don't do much with them yet. -#[derive(Debug, Clone, Eq, PartialEq)] -pub struct Expr; - -macro_rules! impl_froms { - ($e:ident { $($v:ident ($t:ty)),* $(,)? }) => { - $( - impl From<$t> for $e { - fn from(it: $t) -> $e { - $e::$v(it) - } - } - )* - } -} - -impl ModItem { - pub fn as_assoc_item(&self) -> Option { - match self { - ModItem::Import(_) - | ModItem::ExternCrate(_) - | ModItem::Struct(_) - | ModItem::Union(_) - | ModItem::Enum(_) - | ModItem::Static(_) - | ModItem::Trait(_) - | ModItem::Impl(_) - | ModItem::Mod(_) => None, - ModItem::MacroCall(call) => Some(AssocItem::MacroCall(*call)), - ModItem::Const(konst) => Some(AssocItem::Const(*konst)), - ModItem::TypeAlias(alias) => Some(AssocItem::TypeAlias(*alias)), - ModItem::Function(func) => Some(AssocItem::Function(*func)), - } - } - - pub fn downcast(self) -> Option> { - N::id_from_mod_item(self) - } -} - -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub enum AssocItem { - Function(FileItemTreeId), - TypeAlias(FileItemTreeId), - Const(FileItemTreeId), - MacroCall(FileItemTreeId), -} - -impl_froms!(AssocItem { - Function(FileItemTreeId), - TypeAlias(FileItemTreeId), - Const(FileItemTreeId), - MacroCall(FileItemTreeId), -}); - -impl From for ModItem { - fn from(item: AssocItem) -> Self { - match item { - AssocItem::Function(it) => it.into(), - AssocItem::TypeAlias(it) => it.into(), - AssocItem::Const(it) => it.into(), - AssocItem::MacroCall(it) => it.into(), - } - } -} - -#[derive(Debug, Eq, PartialEq)] -pub struct Variant { - pub name: Name, - pub fields: Fields, -} - -pub struct IdRange { - range: Range, - _p: PhantomData, -} - -impl IdRange { - fn new(range: Range>) -> Self { - Self { range: range.start.into_raw().into()..range.end.into_raw().into(), _p: PhantomData } - } -} - -impl Iterator for IdRange { - type Item = Idx; - fn next(&mut self) -> Option { - self.range.next().map(|raw| Idx::from_raw(raw.into())) - } -} - -impl fmt::Debug for IdRange { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.debug_tuple(&format!("IdRange::<{}>", type_name::())).field(&self.range).finish() - } -} - -impl Clone for IdRange { - fn clone(&self) -> Self { - Self { range: self.range.clone(), _p: PhantomData } - } -} - -impl PartialEq for IdRange { - fn eq(&self, other: &Self) -> bool { - self.range == other.range - } -} - -impl Eq for IdRange {} - -#[derive(Debug, Clone, PartialEq, Eq)] -pub enum Fields { - Record(IdRange), - Tuple(IdRange), - Unit, -} - -/// A single field of an enum variant or struct -#[derive(Debug, Clone, PartialEq, Eq)] -pub struct Field { - pub name: Name, - pub type_ref: TypeRef, - pub visibility: RawVisibilityId, -} -- cgit v1.2.3