pub struct ModuleItems {
// Use BTreeSets here so items are in the same order as in the
// list of all items in Crate
- pub items: BTreeSet<HirId>,
+ pub items: BTreeSet<ItemId>,
pub trait_items: BTreeSet<TraitItemId>,
pub impl_items: BTreeSet<ImplItemId>,
pub foreign_items: BTreeSet<ForeignItemId>,
// does, because it can affect the order in which errors are
// detected, which in turn can make UI tests yield
// slightly different results.
- pub items: BTreeMap<HirId, Item<'hir>>,
+ pub items: BTreeMap<ItemId, Item<'hir>>,
pub trait_items: BTreeMap<TraitItemId, TraitItem<'hir>>,
pub impl_items: BTreeMap<ImplItemId, ImplItem<'hir>>,
/// A list of modules written out in the order in which they
/// appear in the crate. This includes the main crate module.
- pub modules: BTreeMap<HirId, ModuleItems>,
+ pub modules: BTreeMap<LocalDefId, ModuleItems>,
/// A list of proc macro HirIds, written out in the order in which
/// they are declared in the static array generated by proc_macro_harness.
pub proc_macros: Vec<HirId>,
}
impl Crate<'hir> {
- pub fn item(&self, id: HirId) -> &Item<'hir> {
+ pub fn item(&self, id: ItemId) -> &Item<'hir> {
&self.items[&id]
}
#[derive(Copy, Clone, PartialEq, Encodable, Debug, HashStable_Generic)]
pub enum UnOp {
/// The `*` operator (deferencing).
- UnDeref,
+ Deref,
/// The `!` operator (logical negation).
- UnNot,
+ Not,
/// The `-` operator (negation).
- UnNeg,
+ Neg,
}
impl UnOp {
pub fn as_str(self) -> &'static str {
match self {
- Self::UnDeref => "*",
- Self::UnNot => "!",
- Self::UnNeg => "-",
+ Self::Deref => "*",
+ Self::Not => "!",
+ Self::Neg => "-",
}
}
/// Returns `true` if the unary operator takes its argument by value.
pub fn is_by_value(self) -> bool {
- matches!(self, Self::UnNeg | Self::UnNot)
+ matches!(self, Self::Neg | Self::Not)
}
}
pub span: Span,
}
-// `Expr` is used a lot. Make sure it doesn't unintentionally get bigger.
-#[cfg(target_arch = "x86_64")]
-rustc_data_structures::static_assert_size!(Expr<'static>, 72);
-
impl Expr<'_> {
pub fn precedence(&self) -> ExprPrecedence {
match self.kind {
// https://github.com/rust-lang/rfcs/blob/master/text/0803-type-ascription.md#type-ascription-and-temporaries
ExprKind::Type(ref e, _) => e.is_place_expr(allow_projections_from),
- ExprKind::Unary(UnOp::UnDeref, _) => true,
+ ExprKind::Unary(UnOp::Deref, _) => true,
ExprKind::Field(ref base, _) | ExprKind::Index(ref base, _) => {
allow_projections_from(base) || base.is_place_expr(allow_projections_from)
// so it can fetched later.
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Encodable, Debug)]
pub struct TraitItemId {
- pub hir_id: HirId,
+ pub def_id: LocalDefId,
+}
+
+impl TraitItemId {
+ pub fn hir_id(&self) -> HirId {
+ // Items are always HIR owners.
+ HirId::make_owner(self.def_id)
+ }
}
/// Represents an item declaration within a trait declaration,
#[derive(Debug)]
pub struct TraitItem<'hir> {
pub ident: Ident,
- pub hir_id: HirId,
+ pub def_id: LocalDefId,
pub attrs: &'hir [Attribute],
pub generics: Generics<'hir>,
pub kind: TraitItemKind<'hir>,
pub span: Span,
}
+impl TraitItem<'_> {
+ pub fn hir_id(&self) -> HirId {
+ // Items are always HIR owners.
+ HirId::make_owner(self.def_id)
+ }
+
+ pub fn trait_item_id(&self) -> TraitItemId {
+ TraitItemId { def_id: self.def_id }
+ }
+}
+
/// Represents a trait method's body (or just argument names).
#[derive(Encodable, Debug, HashStable_Generic)]
pub enum TraitFn<'hir> {
// so it can fetched later.
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Encodable, Debug)]
pub struct ImplItemId {
- pub hir_id: HirId,
+ pub def_id: LocalDefId,
+}
+
+impl ImplItemId {
+ pub fn hir_id(&self) -> HirId {
+ // Items are always HIR owners.
+ HirId::make_owner(self.def_id)
+ }
}
/// Represents anything within an `impl` block.
#[derive(Debug)]
pub struct ImplItem<'hir> {
pub ident: Ident,
- pub hir_id: HirId,
+ pub def_id: LocalDefId,
pub vis: Visibility<'hir>,
pub defaultness: Defaultness,
pub attrs: &'hir [Attribute],
pub span: Span,
}
+impl ImplItem<'_> {
+ pub fn hir_id(&self) -> HirId {
+ // Items are always HIR owners.
+ HirId::make_owner(self.def_id)
+ }
+
+ pub fn impl_item_id(&self) -> ImplItemId {
+ ImplItemId { def_id: self.def_id }
+ }
+}
+
/// Represents various kinds of content within an `impl`.
#[derive(Debug, HashStable_Generic)]
pub enum ImplItemKind<'hir> {
}
impl PrimTy {
+ /// All of the primitive types
+ pub const ALL: [Self; 17] = [
+ // any changes here should also be reflected in `PrimTy::from_name`
+ Self::Int(IntTy::I8),
+ Self::Int(IntTy::I16),
+ Self::Int(IntTy::I32),
+ Self::Int(IntTy::I64),
+ Self::Int(IntTy::I128),
+ Self::Int(IntTy::Isize),
+ Self::Uint(UintTy::U8),
+ Self::Uint(UintTy::U16),
+ Self::Uint(UintTy::U32),
+ Self::Uint(UintTy::U64),
+ Self::Uint(UintTy::U128),
+ Self::Uint(UintTy::Usize),
+ Self::Float(FloatTy::F32),
+ Self::Float(FloatTy::F64),
+ Self::Bool,
+ Self::Char,
+ Self::Str,
+ ];
+
pub fn name_str(self) -> &'static str {
match self {
PrimTy::Int(i) => i.name_str(),
PrimTy::Char => sym::char,
}
}
+
+ /// Returns the matching `PrimTy` for a `Symbol` such as "str" or "i32".
+ /// Returns `None` if no matching type is found.
+ pub fn from_name(name: Symbol) -> Option<Self> {
+ let ty = match name {
+ // any changes here should also be reflected in `PrimTy::ALL`
+ sym::i8 => Self::Int(IntTy::I8),
+ sym::i16 => Self::Int(IntTy::I16),
+ sym::i32 => Self::Int(IntTy::I32),
+ sym::i64 => Self::Int(IntTy::I64),
+ sym::i128 => Self::Int(IntTy::I128),
+ sym::isize => Self::Int(IntTy::Isize),
+ sym::u8 => Self::Uint(UintTy::U8),
+ sym::u16 => Self::Uint(UintTy::U16),
+ sym::u32 => Self::Uint(UintTy::U32),
+ sym::u64 => Self::Uint(UintTy::U64),
+ sym::u128 => Self::Uint(UintTy::U128),
+ sym::usize => Self::Uint(UintTy::Usize),
+ sym::f32 => Self::Float(FloatTy::F32),
+ sym::f64 => Self::Float(FloatTy::F64),
+ sym::bool => Self::Bool,
+ sym::char => Self::Char,
+ sym::str => Self::Str,
+ _ => return None,
+ };
+ Some(ty)
+ }
}
#[derive(Debug, HashStable_Generic)]
// The bodies for items are stored "out of line", in a separate
// hashmap in the `Crate`. Here we just record the hir-id of the item
// so it can fetched later.
-#[derive(Copy, Clone, Encodable, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Encodable, Debug, Hash)]
pub struct ItemId {
- pub id: HirId,
+ pub def_id: LocalDefId,
+}
+
+impl ItemId {
+ pub fn hir_id(&self) -> HirId {
+ // Items are always HIR owners.
+ HirId::make_owner(self.def_id)
+ }
}
/// An item
#[derive(Debug)]
pub struct Item<'hir> {
pub ident: Ident,
- pub hir_id: HirId,
+ pub def_id: LocalDefId,
pub attrs: &'hir [Attribute],
pub kind: ItemKind<'hir>,
pub vis: Visibility<'hir>,
pub span: Span,
}
+impl Item<'_> {
+ pub fn hir_id(&self) -> HirId {
+ // Items are always HIR owners.
+ HirId::make_owner(self.def_id)
+ }
+
+ pub fn item_id(&self) -> ItemId {
+ ItemId { def_id: self.def_id }
+ }
+}
+
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
#[derive(Encodable, Decodable, HashStable_Generic)]
pub enum Unsafety {
// so it can fetched later.
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Encodable, Debug)]
pub struct ForeignItemId {
- pub hir_id: HirId,
+ pub def_id: LocalDefId,
+}
+
+impl ForeignItemId {
+ pub fn hir_id(&self) -> HirId {
+ // Items are always HIR owners.
+ HirId::make_owner(self.def_id)
+ }
}
/// A reference from a foreign block to one of its items. This
pub vis: Visibility<'hir>,
}
-#[derive(Debug, HashStable_Generic)]
+#[derive(Debug)]
pub struct ForeignItem<'hir> {
- #[stable_hasher(project(name))]
pub ident: Ident,
pub attrs: &'hir [Attribute],
pub kind: ForeignItemKind<'hir>,
- pub hir_id: HirId,
+ pub def_id: LocalDefId,
pub span: Span,
pub vis: Visibility<'hir>,
}
+impl ForeignItem<'_> {
+ pub fn hir_id(&self) -> HirId {
+ // Items are always HIR owners.
+ HirId::make_owner(self.def_id)
+ }
+
+ pub fn foreign_item_id(&self) -> ForeignItemId {
+ ForeignItemId { def_id: self.def_id }
+ }
+}
+
/// An item within an `extern` block.
#[derive(Debug, HashStable_Generic)]
pub enum ForeignItemKind<'hir> {
pub fn hir_id(&self) -> Option<HirId> {
match self {
- Node::Item(Item { hir_id, .. })
- | Node::ForeignItem(ForeignItem { hir_id, .. })
- | Node::TraitItem(TraitItem { hir_id, .. })
- | Node::ImplItem(ImplItem { hir_id, .. })
- | Node::Field(StructField { hir_id, .. })
+ Node::Item(Item { def_id, .. })
+ | Node::TraitItem(TraitItem { def_id, .. })
+ | Node::ImplItem(ImplItem { def_id, .. })
+ | Node::ForeignItem(ForeignItem { def_id, .. }) => Some(HirId::make_owner(*def_id)),
+ Node::Field(StructField { hir_id, .. })
| Node::AnonConst(AnonConst { hir_id, .. })
| Node::Expr(Expr { hir_id, .. })
| Node::Stmt(Stmt { hir_id, .. })
}
}
}
+
+// Some nodes are used a lot. Make sure they don't unintentionally get bigger.
+#[cfg(target_arch = "x86_64")]
+mod size_asserts {
+ rustc_data_structures::static_assert_size!(super::Block<'static>, 48);
+ rustc_data_structures::static_assert_size!(super::Expr<'static>, 72);
+ rustc_data_structures::static_assert_size!(super::Pat<'static>, 88);
+ rustc_data_structures::static_assert_size!(super::QPath<'static>, 24);
+ rustc_data_structures::static_assert_size!(super::Ty<'static>, 72);
+
+ rustc_data_structures::static_assert_size!(super::Item<'static>, 200);
+ rustc_data_structures::static_assert_size!(super::TraitItem<'static>, 144);
+ rustc_data_structures::static_assert_size!(super::ImplItem<'static>, 168);
+ rustc_data_structures::static_assert_size!(super::ForeignItem<'static>, 152);
+}
projects / rust.git / blobdiff