1 //! A simplified AST that only contains items.
3 //! This is the primary IR used throughout `hir_def`. It is the input to the name resolution
4 //! algorithm, as well as to the queries defined in `adt.rs`, `data.rs`, and most things in
7 //! `ItemTree`s are built per `HirFileId`, from the syntax tree of the parsed file. This means that
8 //! they are crate-independent: they don't know which `#[cfg]`s are active or which module they
9 //! belong to, since those concepts don't exist at this level (a single `ItemTree` might be part of
10 //! multiple crates, or might be included into the same crate twice via `#[path]`).
12 //! One important purpose of this layer is to provide an "invalidation barrier" for incremental
13 //! computations: when typing inside an item body, the `ItemTree` of the modified file is typically
14 //! unaffected, so we don't have to recompute name resolution results or item data (see `data.rs`).
16 //! The `ItemTree` for the currently open file can be displayed by using the VS Code command
17 //! "Rust Analyzer: Debug ItemTree".
19 //! Compared to rustc's architecture, `ItemTree` has properties from both rustc's AST and HIR: many
20 //! syntax-level Rust features are already desugared to simpler forms in the `ItemTree`, but name
21 //! resolution has not yet been performed. `ItemTree`s are per-file, while rustc's AST and HIR are
22 //! per-crate, because we are interested in incrementally computing it.
24 //! The representation of items in the `ItemTree` should generally mirror the surface syntax: it is
25 //! usually a bad idea to desugar a syntax-level construct to something that is structurally
26 //! different here. Name resolution needs to be able to process attributes and expand macros
27 //! (including attribute macros), and having a 1-to-1 mapping between syntax and the `ItemTree`
28 //! avoids introducing subtle bugs.
30 //! In general, any item in the `ItemTree` stores its `AstId`, which allows mapping it back to its
47 use ast::{AstNode, NameOwner, StructKind};
51 ast_id_map::FileAstId,
53 name::{name, AsName, Name},
54 FragmentKind, HirFileId, InFile,
56 use la_arena::{Arena, Idx, RawIdx};
58 use rustc_hash::FxHashMap;
59 use smallvec::SmallVec;
60 use syntax::{ast, match_ast, SyntaxKind};
63 attr::{Attrs, RawAttrs},
65 generics::GenericParams,
67 path::{path, AssociatedTypeBinding, GenericArgs, ImportAlias, ModPath, Path, PathKind},
68 type_ref::{Mutability, TraitRef, TypeBound, TypeRef},
69 visibility::RawVisibility,
72 #[derive(Copy, Clone, Eq, PartialEq)]
73 pub struct RawVisibilityId(u32);
75 impl RawVisibilityId {
76 pub const PUB: Self = RawVisibilityId(u32::max_value());
77 pub const PRIV: Self = RawVisibilityId(u32::max_value() - 1);
78 pub const PUB_CRATE: Self = RawVisibilityId(u32::max_value() - 2);
81 impl fmt::Debug for RawVisibilityId {
82 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
83 let mut f = f.debug_tuple("RawVisibilityId");
85 Self::PUB => f.field(&"pub"),
86 Self::PRIV => f.field(&"pub(self)"),
87 Self::PUB_CRATE => f.field(&"pub(crate)"),
88 _ => f.field(&self.0),
94 /// The item tree of a source file.
95 #[derive(Debug, Default, Eq, PartialEq)]
99 top_level: SmallVec<[ModItem; 1]>,
100 attrs: FxHashMap<AttrOwner, RawAttrs>,
102 data: Option<Box<ItemTreeData>>,
106 pub(crate) fn file_item_tree_query(db: &dyn DefDatabase, file_id: HirFileId) -> Arc<ItemTree> {
107 let _p = profile::span("item_tree_query").detail(|| format!("{:?}", file_id));
108 let syntax = if let Some(node) = db.parse_or_expand(file_id) {
109 if node.kind() == SyntaxKind::ERROR {
110 // FIXME: not 100% sure why these crop up, but return an empty tree to avoid a panic
111 return Default::default();
115 return Default::default();
118 let hygiene = Hygiene::new(db.upcast(), file_id);
119 let ctx = lower::Ctx::new(db, hygiene.clone(), file_id);
120 let mut top_attrs = None;
121 let mut item_tree = match_ast! {
123 ast::SourceFile(file) => {
124 top_attrs = Some(RawAttrs::new(db, &file, &hygiene));
125 ctx.lower_module_items(&file)
127 ast::MacroItems(items) => {
128 ctx.lower_module_items(&items)
130 ast::MacroStmts(stmts) => {
131 // The produced statements can include items, which should be added as top-level
133 ctx.lower_macro_stmts(stmts)
136 // FIXME: This occurs because macros in pattern position are treated as inner
137 // items and expanded during block DefMap computation
138 return Default::default();
141 // Types can contain inner items. We return an empty item tree in this case, but
142 // still need to collect inner items.
143 ctx.lower_inner_items(ty.syntax())
146 // Macros can expand to expressions. We return an empty item tree in this case, but
147 // still need to collect inner items.
148 ctx.lower_inner_items(e.syntax())
151 panic!("cannot create item tree from {:?} {}", syntax, syntax);
156 if let Some(attrs) = top_attrs {
157 item_tree.attrs.insert(AttrOwner::TopLevel, attrs);
159 item_tree.shrink_to_fit();
163 fn shrink_to_fit(&mut self) {
164 if let Some(data) = &mut self.data {
189 imports.shrink_to_fit();
190 extern_crates.shrink_to_fit();
191 extern_blocks.shrink_to_fit();
192 functions.shrink_to_fit();
193 params.shrink_to_fit();
194 structs.shrink_to_fit();
195 fields.shrink_to_fit();
196 unions.shrink_to_fit();
197 enums.shrink_to_fit();
198 variants.shrink_to_fit();
199 consts.shrink_to_fit();
200 statics.shrink_to_fit();
201 traits.shrink_to_fit();
202 impls.shrink_to_fit();
203 type_aliases.shrink_to_fit();
204 mods.shrink_to_fit();
205 macro_calls.shrink_to_fit();
206 macro_rules.shrink_to_fit();
207 macro_defs.shrink_to_fit();
209 vis.arena.shrink_to_fit();
211 inner_items.shrink_to_fit();
215 /// Returns an iterator over all items located at the top level of the `HirFileId` this
216 /// `ItemTree` was created from.
217 pub fn top_level_items(&self) -> &[ModItem] {
221 /// Returns the inner attributes of the source file.
222 pub fn top_level_attrs(&self, db: &dyn DefDatabase, krate: CrateId) -> Attrs {
223 self.attrs.get(&AttrOwner::TopLevel).unwrap_or(&RawAttrs::EMPTY).clone().filter(db, krate)
226 pub(crate) fn raw_attrs(&self, of: AttrOwner) -> &RawAttrs {
227 self.attrs.get(&of).unwrap_or(&RawAttrs::EMPTY)
230 pub fn attrs(&self, db: &dyn DefDatabase, krate: CrateId, of: AttrOwner) -> Attrs {
231 self.raw_attrs(of).clone().filter(db, krate)
234 pub fn inner_items_of_block(&self, block: FileAstId<ast::BlockExpr>) -> &[ModItem] {
236 Some(data) => data.inner_items.get(&block).map(|it| &**it).unwrap_or(&[]),
241 pub fn pretty_print(&self) -> String {
242 pretty::print_item_tree(self)
245 fn data(&self) -> &ItemTreeData {
246 self.data.as_ref().expect("attempted to access data of empty ItemTree")
249 fn data_mut(&mut self) -> &mut ItemTreeData {
250 self.data.get_or_insert_with(Box::default)
254 #[derive(Default, Debug, Eq, PartialEq)]
255 struct ItemVisibilities {
256 arena: Arena<RawVisibility>,
259 impl ItemVisibilities {
260 fn alloc(&mut self, vis: RawVisibility) -> RawVisibilityId {
262 RawVisibility::Public => RawVisibilityId::PUB,
263 RawVisibility::Module(path) if path.segments().is_empty() => match &path.kind {
264 PathKind::Super(0) => RawVisibilityId::PRIV,
265 PathKind::Crate => RawVisibilityId::PUB_CRATE,
266 _ => RawVisibilityId(self.arena.alloc(vis).into_raw().into()),
268 _ => RawVisibilityId(self.arena.alloc(vis).into_raw().into()),
273 static VIS_PUB: RawVisibility = RawVisibility::Public;
274 static VIS_PRIV: RawVisibility = RawVisibility::Module(ModPath::from_kind(PathKind::Super(0)));
275 static VIS_PUB_CRATE: RawVisibility = RawVisibility::Module(ModPath::from_kind(PathKind::Crate));
277 #[derive(Default, Debug, Eq, PartialEq)]
278 struct ItemTreeData {
279 imports: Arena<Import>,
280 extern_crates: Arena<ExternCrate>,
281 extern_blocks: Arena<ExternBlock>,
282 functions: Arena<Function>,
283 params: Arena<Param>,
284 structs: Arena<Struct>,
285 fields: Arena<Field>,
286 unions: Arena<Union>,
288 variants: Arena<Variant>,
289 consts: Arena<Const>,
290 statics: Arena<Static>,
291 traits: Arena<Trait>,
293 type_aliases: Arena<TypeAlias>,
295 macro_calls: Arena<MacroCall>,
296 macro_rules: Arena<MacroRules>,
297 macro_defs: Arena<MacroDef>,
299 vis: ItemVisibilities,
301 inner_items: FxHashMap<FileAstId<ast::BlockExpr>, SmallVec<[ModItem; 1]>>,
304 #[derive(Debug, Eq, PartialEq, Hash)]
306 /// Attributes on an item.
308 /// Inner attributes of the source file.
311 Variant(Idx<Variant>),
316 macro_rules! from_attrs {
317 ( $( $var:ident($t:ty) ),+ ) => {
319 impl From<$t> for AttrOwner {
320 fn from(t: $t) -> AttrOwner {
328 from_attrs!(ModItem(ModItem), Variant(Idx<Variant>), Field(Idx<Field>), Param(Idx<Param>));
330 /// Trait implemented by all item nodes in the item tree.
331 pub trait ItemTreeNode: Clone {
332 type Source: AstNode + Into<ast::Item>;
334 fn ast_id(&self) -> FileAstId<Self::Source>;
336 /// Looks up an instance of `Self` in an item tree.
337 fn lookup(tree: &ItemTree, index: Idx<Self>) -> &Self;
339 /// Downcasts a `ModItem` to a `FileItemTreeId` specific to this type.
340 fn id_from_mod_item(mod_item: ModItem) -> Option<FileItemTreeId<Self>>;
342 /// Upcasts a `FileItemTreeId` to a generic `ModItem`.
343 fn id_to_mod_item(id: FileItemTreeId<Self>) -> ModItem;
346 pub struct FileItemTreeId<N: ItemTreeNode> {
351 impl<N: ItemTreeNode> Clone for FileItemTreeId<N> {
352 fn clone(&self) -> Self {
353 Self { index: self.index, _p: PhantomData }
356 impl<N: ItemTreeNode> Copy for FileItemTreeId<N> {}
358 impl<N: ItemTreeNode> PartialEq for FileItemTreeId<N> {
359 fn eq(&self, other: &FileItemTreeId<N>) -> bool {
360 self.index == other.index
363 impl<N: ItemTreeNode> Eq for FileItemTreeId<N> {}
365 impl<N: ItemTreeNode> Hash for FileItemTreeId<N> {
366 fn hash<H: Hasher>(&self, state: &mut H) {
367 self.index.hash(state)
371 impl<N: ItemTreeNode> fmt::Debug for FileItemTreeId<N> {
372 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
378 pub struct ItemTreeId<N: ItemTreeNode> {
380 pub value: FileItemTreeId<N>,
383 impl<N: ItemTreeNode> ItemTreeId<N> {
384 pub fn new(file: HirFileId, idx: FileItemTreeId<N>) -> Self {
385 Self { file, value: idx }
388 pub fn file_id(self) -> HirFileId {
392 pub fn item_tree(self, db: &dyn DefDatabase) -> Arc<ItemTree> {
393 db.file_item_tree(self.file)
397 impl<N: ItemTreeNode> Copy for ItemTreeId<N> {}
398 impl<N: ItemTreeNode> Clone for ItemTreeId<N> {
399 fn clone(&self) -> Self {
404 impl<N: ItemTreeNode> PartialEq for ItemTreeId<N> {
405 fn eq(&self, other: &Self) -> bool {
406 self.file == other.file && self.value == other.value
410 impl<N: ItemTreeNode> Eq for ItemTreeId<N> {}
412 impl<N: ItemTreeNode> Hash for ItemTreeId<N> {
413 fn hash<H: Hasher>(&self, state: &mut H) {
414 self.file.hash(state);
415 self.value.hash(state);
419 macro_rules! mod_items {
420 ( $( $typ:ident in $fld:ident -> $ast:ty ),+ $(,)? ) => {
421 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
424 $typ(FileItemTreeId<$typ>),
429 impl From<FileItemTreeId<$typ>> for ModItem {
430 fn from(id: FileItemTreeId<$typ>) -> ModItem {
437 impl ItemTreeNode for $typ {
440 fn ast_id(&self) -> FileAstId<Self::Source> {
444 fn lookup(tree: &ItemTree, index: Idx<Self>) -> &Self {
445 &tree.data().$fld[index]
448 fn id_from_mod_item(mod_item: ModItem) -> Option<FileItemTreeId<Self>> {
449 if let ModItem::$typ(id) = mod_item {
456 fn id_to_mod_item(id: FileItemTreeId<Self>) -> ModItem {
461 impl Index<Idx<$typ>> for ItemTree {
464 fn index(&self, index: Idx<$typ>) -> &Self::Output {
465 &self.data().$fld[index]
473 Import in imports -> ast::Use,
474 ExternCrate in extern_crates -> ast::ExternCrate,
475 ExternBlock in extern_blocks -> ast::ExternBlock,
476 Function in functions -> ast::Fn,
477 Struct in structs -> ast::Struct,
478 Union in unions -> ast::Union,
479 Enum in enums -> ast::Enum,
480 Const in consts -> ast::Const,
481 Static in statics -> ast::Static,
482 Trait in traits -> ast::Trait,
483 Impl in impls -> ast::Impl,
484 TypeAlias in type_aliases -> ast::TypeAlias,
485 Mod in mods -> ast::Module,
486 MacroCall in macro_calls -> ast::MacroCall,
487 MacroRules in macro_rules -> ast::MacroRules,
488 MacroDef in macro_defs -> ast::MacroDef,
491 macro_rules! impl_index {
492 ( $($fld:ident: $t:ty),+ $(,)? ) => {
494 impl Index<Idx<$t>> for ItemTree {
497 fn index(&self, index: Idx<$t>) -> &Self::Output {
498 &self.data().$fld[index]
505 impl_index!(fields: Field, variants: Variant, params: Param);
507 impl Index<RawVisibilityId> for ItemTree {
508 type Output = RawVisibility;
509 fn index(&self, index: RawVisibilityId) -> &Self::Output {
511 RawVisibilityId::PRIV => &VIS_PRIV,
512 RawVisibilityId::PUB => &VIS_PUB,
513 RawVisibilityId::PUB_CRATE => &VIS_PUB_CRATE,
514 _ => &self.data().vis.arena[Idx::from_raw(index.0.into())],
519 impl<N: ItemTreeNode> Index<FileItemTreeId<N>> for ItemTree {
521 fn index(&self, id: FileItemTreeId<N>) -> &N {
522 N::lookup(self, id.index)
526 /// A desugared `use` import.
527 #[derive(Debug, Clone, Eq, PartialEq)]
529 pub path: Interned<ModPath>,
530 pub alias: Option<ImportAlias>,
531 pub visibility: RawVisibilityId,
533 /// AST ID of the `use` item this import was derived from. Note that many `Import`s can map to
534 /// the same `use` item.
535 pub ast_id: FileAstId<ast::Use>,
536 /// Index of this `Import` when the containing `Use` is visited via `ModPath::expand_use_item`.
538 /// This can be used to get the `UseTree` this `Import` corresponds to and allows emitting
539 /// precise diagnostics.
543 #[derive(Debug, Clone, Eq, PartialEq)]
544 pub struct ExternCrate {
546 pub alias: Option<ImportAlias>,
547 pub visibility: RawVisibilityId,
548 pub ast_id: FileAstId<ast::ExternCrate>,
551 #[derive(Debug, Clone, Eq, PartialEq)]
552 pub struct ExternBlock {
553 pub abi: Option<Interned<str>>,
554 pub ast_id: FileAstId<ast::ExternBlock>,
555 pub children: Box<[ModItem]>,
558 #[derive(Debug, Clone, Eq, PartialEq)]
559 pub struct Function {
561 pub visibility: RawVisibilityId,
562 pub generic_params: Interned<GenericParams>,
563 pub abi: Option<Interned<str>>,
564 pub params: IdRange<Param>,
565 pub ret_type: Interned<TypeRef>,
566 pub ast_id: FileAstId<ast::Fn>,
567 pub(crate) flags: FnFlags,
570 #[derive(Debug, Clone, Eq, PartialEq)]
572 Normal(Interned<TypeRef>),
576 #[derive(Debug, Clone, Copy, Eq, PartialEq, Default)]
577 pub(crate) struct FnFlags {
581 pub(crate) const HAS_SELF_PARAM: u8 = 1 << 0;
582 pub(crate) const HAS_BODY: u8 = 1 << 1;
583 pub(crate) const IS_DEFAULT: u8 = 1 << 2;
584 pub(crate) const IS_CONST: u8 = 1 << 3;
585 pub(crate) const IS_ASYNC: u8 = 1 << 4;
586 pub(crate) const IS_UNSAFE: u8 = 1 << 5;
587 /// Whether the function is located in an `extern` block (*not* whether it is an
588 /// `extern "abi" fn`).
589 pub(crate) const IS_IN_EXTERN_BLOCK: u8 = 1 << 6;
590 pub(crate) const IS_VARARGS: u8 = 1 << 7;
593 #[derive(Debug, Clone, Eq, PartialEq)]
596 pub visibility: RawVisibilityId,
597 pub generic_params: Interned<GenericParams>,
599 pub ast_id: FileAstId<ast::Struct>,
602 #[derive(Debug, Clone, Eq, PartialEq)]
605 pub visibility: RawVisibilityId,
606 pub generic_params: Interned<GenericParams>,
608 pub ast_id: FileAstId<ast::Union>,
611 #[derive(Debug, Clone, Eq, PartialEq)]
614 pub visibility: RawVisibilityId,
615 pub generic_params: Interned<GenericParams>,
616 pub variants: IdRange<Variant>,
617 pub ast_id: FileAstId<ast::Enum>,
620 #[derive(Debug, Clone, Eq, PartialEq)]
622 /// const _: () = ();
623 pub name: Option<Name>,
624 pub visibility: RawVisibilityId,
625 pub type_ref: Interned<TypeRef>,
626 pub ast_id: FileAstId<ast::Const>,
629 #[derive(Debug, Clone, Eq, PartialEq)]
632 pub visibility: RawVisibilityId,
634 /// Whether the static is in an `extern` block.
636 pub type_ref: Interned<TypeRef>,
637 pub ast_id: FileAstId<ast::Static>,
640 #[derive(Debug, Clone, Eq, PartialEq)]
643 pub visibility: RawVisibilityId,
644 pub generic_params: Interned<GenericParams>,
647 pub bounds: Box<[TypeBound]>,
648 pub items: Box<[AssocItem]>,
649 pub ast_id: FileAstId<ast::Trait>,
652 #[derive(Debug, Clone, Eq, PartialEq)]
654 pub generic_params: Interned<GenericParams>,
655 pub target_trait: Option<Interned<TraitRef>>,
656 pub self_ty: Interned<TypeRef>,
657 pub is_negative: bool,
658 pub items: Box<[AssocItem]>,
659 pub ast_id: FileAstId<ast::Impl>,
662 #[derive(Debug, Clone, PartialEq, Eq)]
663 pub struct TypeAlias {
665 pub visibility: RawVisibilityId,
666 /// Bounds on the type alias itself. Only valid in trait declarations, eg. `type Assoc: Copy;`.
667 pub bounds: Box<[TypeBound]>,
668 pub generic_params: Interned<GenericParams>,
669 pub type_ref: Option<Interned<TypeRef>>,
671 pub ast_id: FileAstId<ast::TypeAlias>,
674 #[derive(Debug, Clone, Eq, PartialEq)]
677 pub visibility: RawVisibilityId,
679 pub ast_id: FileAstId<ast::Module>,
682 #[derive(Debug, Clone, Eq, PartialEq)]
685 Inline { items: Box<[ModItem]> },
691 #[derive(Debug, Clone, Eq, PartialEq)]
692 pub struct MacroCall {
693 /// Path to the called macro.
694 pub path: Interned<ModPath>,
695 pub ast_id: FileAstId<ast::MacroCall>,
696 pub fragment: FragmentKind,
699 #[derive(Debug, Clone, Eq, PartialEq)]
700 pub struct MacroRules {
701 /// The name of the declared macro.
703 pub ast_id: FileAstId<ast::MacroRules>,
706 /// "Macros 2.0" macro definition.
707 #[derive(Debug, Clone, Eq, PartialEq)]
708 pub struct MacroDef {
710 pub visibility: RawVisibilityId,
711 pub ast_id: FileAstId<ast::MacroDef>,
714 macro_rules! impl_froms {
715 ($e:ident { $($v:ident ($t:ty)),* $(,)? }) => {
717 impl From<$t> for $e {
718 fn from(it: $t) -> $e {
727 pub fn as_assoc_item(&self) -> Option<AssocItem> {
730 | ModItem::ExternCrate(_)
731 | ModItem::ExternBlock(_)
739 | ModItem::MacroRules(_)
740 | ModItem::MacroDef(_) => None,
741 ModItem::MacroCall(call) => Some(AssocItem::MacroCall(*call)),
742 ModItem::Const(konst) => Some(AssocItem::Const(*konst)),
743 ModItem::TypeAlias(alias) => Some(AssocItem::TypeAlias(*alias)),
744 ModItem::Function(func) => Some(AssocItem::Function(*func)),
748 pub fn downcast<N: ItemTreeNode>(self) -> Option<FileItemTreeId<N>> {
749 N::id_from_mod_item(self)
752 pub fn ast_id(&self, tree: &ItemTree) -> FileAstId<ast::Item> {
754 ModItem::Import(it) => tree[it.index].ast_id().upcast(),
755 ModItem::ExternCrate(it) => tree[it.index].ast_id().upcast(),
756 ModItem::ExternBlock(it) => tree[it.index].ast_id().upcast(),
757 ModItem::Function(it) => tree[it.index].ast_id().upcast(),
758 ModItem::Struct(it) => tree[it.index].ast_id().upcast(),
759 ModItem::Union(it) => tree[it.index].ast_id().upcast(),
760 ModItem::Enum(it) => tree[it.index].ast_id().upcast(),
761 ModItem::Const(it) => tree[it.index].ast_id().upcast(),
762 ModItem::Static(it) => tree[it.index].ast_id().upcast(),
763 ModItem::Trait(it) => tree[it.index].ast_id().upcast(),
764 ModItem::Impl(it) => tree[it.index].ast_id().upcast(),
765 ModItem::TypeAlias(it) => tree[it.index].ast_id().upcast(),
766 ModItem::Mod(it) => tree[it.index].ast_id().upcast(),
767 ModItem::MacroCall(it) => tree[it.index].ast_id().upcast(),
768 ModItem::MacroRules(it) => tree[it.index].ast_id().upcast(),
769 ModItem::MacroDef(it) => tree[it.index].ast_id().upcast(),
774 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
776 Function(FileItemTreeId<Function>),
777 TypeAlias(FileItemTreeId<TypeAlias>),
778 Const(FileItemTreeId<Const>),
779 MacroCall(FileItemTreeId<MacroCall>),
782 impl_froms!(AssocItem {
783 Function(FileItemTreeId<Function>),
784 TypeAlias(FileItemTreeId<TypeAlias>),
785 Const(FileItemTreeId<Const>),
786 MacroCall(FileItemTreeId<MacroCall>),
789 impl From<AssocItem> for ModItem {
790 fn from(item: AssocItem) -> Self {
792 AssocItem::Function(it) => it.into(),
793 AssocItem::TypeAlias(it) => it.into(),
794 AssocItem::Const(it) => it.into(),
795 AssocItem::MacroCall(it) => it.into(),
800 #[derive(Debug, Eq, PartialEq)]
806 /// A range of densely allocated ItemTree IDs.
807 pub struct IdRange<T> {
813 fn new(range: Range<Idx<T>>) -> Self {
814 Self { range: range.start.into_raw().into()..range.end.into_raw().into(), _p: PhantomData }
817 fn is_empty(&self) -> bool {
818 self.range.is_empty()
822 impl<T> Iterator for IdRange<T> {
824 fn next(&mut self) -> Option<Self::Item> {
825 self.range.next().map(|raw| Idx::from_raw(raw.into()))
829 impl<T> DoubleEndedIterator for IdRange<T> {
830 fn next_back(&mut self) -> Option<Self::Item> {
831 self.range.next_back().map(|raw| Idx::from_raw(raw.into()))
835 impl<T> fmt::Debug for IdRange<T> {
836 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
837 f.debug_tuple(&format!("IdRange::<{}>", type_name::<T>())).field(&self.range).finish()
841 impl<T> Clone for IdRange<T> {
842 fn clone(&self) -> Self {
843 Self { range: self.range.clone(), _p: PhantomData }
847 impl<T> PartialEq for IdRange<T> {
848 fn eq(&self, other: &Self) -> bool {
849 self.range == other.range
853 impl<T> Eq for IdRange<T> {}
855 #[derive(Debug, Clone, PartialEq, Eq)]
857 Record(IdRange<Field>),
858 Tuple(IdRange<Field>),
862 /// A single field of an enum variant or struct
863 #[derive(Debug, Clone, PartialEq, Eq)]
866 pub type_ref: Interned<TypeRef>,
867 pub visibility: RawVisibilityId,