From 698f8c2f01ea549d77d7dc3338a12e04c11057b9 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Wed, 17 Apr 2024 14:02:58 +0200 Subject: Adding upstream version 1.64.0+dfsg1. Signed-off-by: Daniel Baumann --- compiler/rustc_hir/src/arena.rs | 55 + compiler/rustc_hir/src/def.rs | 749 ++++++ compiler/rustc_hir/src/def_path_hash_map.rs | 37 + compiler/rustc_hir/src/definitions.rs | 440 ++++ compiler/rustc_hir/src/diagnostic_items.rs | 17 + compiler/rustc_hir/src/hir.rs | 3506 +++++++++++++++++++++++++++ compiler/rustc_hir/src/hir_id.rs | 89 + compiler/rustc_hir/src/intravisit.rs | 1232 ++++++++++ compiler/rustc_hir/src/lang_items.rs | 339 +++ compiler/rustc_hir/src/lib.rs | 47 + compiler/rustc_hir/src/pat_util.rs | 157 ++ compiler/rustc_hir/src/stable_hash_impls.rs | 143 ++ compiler/rustc_hir/src/target.rs | 188 ++ compiler/rustc_hir/src/tests.rs | 36 + compiler/rustc_hir/src/weak_lang_items.rs | 47 + 15 files changed, 7082 insertions(+) create mode 100644 compiler/rustc_hir/src/arena.rs create mode 100644 compiler/rustc_hir/src/def.rs create mode 100644 compiler/rustc_hir/src/def_path_hash_map.rs create mode 100644 compiler/rustc_hir/src/definitions.rs create mode 100644 compiler/rustc_hir/src/diagnostic_items.rs create mode 100644 compiler/rustc_hir/src/hir.rs create mode 100644 compiler/rustc_hir/src/hir_id.rs create mode 100644 compiler/rustc_hir/src/intravisit.rs create mode 100644 compiler/rustc_hir/src/lang_items.rs create mode 100644 compiler/rustc_hir/src/lib.rs create mode 100644 compiler/rustc_hir/src/pat_util.rs create mode 100644 compiler/rustc_hir/src/stable_hash_impls.rs create mode 100644 compiler/rustc_hir/src/target.rs create mode 100644 compiler/rustc_hir/src/tests.rs create mode 100644 compiler/rustc_hir/src/weak_lang_items.rs (limited to 'compiler/rustc_hir/src') diff --git a/compiler/rustc_hir/src/arena.rs b/compiler/rustc_hir/src/arena.rs new file mode 100644 index 000000000..44335b7f4 --- /dev/null +++ b/compiler/rustc_hir/src/arena.rs @@ -0,0 +1,55 @@ +/// This higher-order macro declares a list of types which can be allocated by `Arena`. +/// +/// Specifying the `decode` modifier will add decode impls for `&T` and `&[T]`, +/// where `T` is the type listed. These impls will appear in the implement_ty_decoder! macro. +#[macro_export] +macro_rules! arena_types { + ($macro:path) => ( + $macro!([ + // HIR types + [] hir_krate: rustc_hir::Crate<'tcx>, + [] arm: rustc_hir::Arm<'tcx>, + [] asm_operand: (rustc_hir::InlineAsmOperand<'tcx>, rustc_span::Span), + [] asm_template: rustc_ast::InlineAsmTemplatePiece, + [] attribute: rustc_ast::Attribute, + [] closure: rustc_hir::Closure<'tcx>, + [] block: rustc_hir::Block<'tcx>, + [] bare_fn_ty: rustc_hir::BareFnTy<'tcx>, + [] body: rustc_hir::Body<'tcx>, + [] generics: rustc_hir::Generics<'tcx>, + [] generic_arg: rustc_hir::GenericArg<'tcx>, + [] generic_args: rustc_hir::GenericArgs<'tcx>, + [] generic_bound: rustc_hir::GenericBound<'tcx>, + [] generic_param: rustc_hir::GenericParam<'tcx>, + [] expr: rustc_hir::Expr<'tcx>, + [] impl_: rustc_hir::Impl<'tcx>, + [] let_expr: rustc_hir::Let<'tcx>, + [] expr_field: rustc_hir::ExprField<'tcx>, + [] pat_field: rustc_hir::PatField<'tcx>, + [] fn_decl: rustc_hir::FnDecl<'tcx>, + [] foreign_item: rustc_hir::ForeignItem<'tcx>, + [] foreign_item_ref: rustc_hir::ForeignItemRef, + [] impl_item: rustc_hir::ImplItem<'tcx>, + [] impl_item_ref: rustc_hir::ImplItemRef, + [] item: rustc_hir::Item<'tcx>, + [] inline_asm: rustc_hir::InlineAsm<'tcx>, + [] local: rustc_hir::Local<'tcx>, + [] mod_: rustc_hir::Mod<'tcx>, + [] owner_info: rustc_hir::OwnerInfo<'tcx>, + [] param: rustc_hir::Param<'tcx>, + [] pat: rustc_hir::Pat<'tcx>, + [] path: rustc_hir::Path<'tcx>, + [] path_segment: rustc_hir::PathSegment<'tcx>, + [] poly_trait_ref: rustc_hir::PolyTraitRef<'tcx>, + [] qpath: rustc_hir::QPath<'tcx>, + [] stmt: rustc_hir::Stmt<'tcx>, + [] field_def: rustc_hir::FieldDef<'tcx>, + [] trait_item: rustc_hir::TraitItem<'tcx>, + [] trait_item_ref: rustc_hir::TraitItemRef, + [] ty: rustc_hir::Ty<'tcx>, + [] type_binding: rustc_hir::TypeBinding<'tcx>, + [] variant: rustc_hir::Variant<'tcx>, + [] where_predicate: rustc_hir::WherePredicate<'tcx>, + ]); + ) +} diff --git a/compiler/rustc_hir/src/def.rs b/compiler/rustc_hir/src/def.rs new file mode 100644 index 000000000..be5b7eccb --- /dev/null +++ b/compiler/rustc_hir/src/def.rs @@ -0,0 +1,749 @@ +use crate::hir; + +use rustc_ast as ast; +use rustc_ast::NodeId; +use rustc_macros::HashStable_Generic; +use rustc_span::def_id::{DefId, LocalDefId}; +use rustc_span::hygiene::MacroKind; +use rustc_span::Symbol; + +use std::array::IntoIter; +use std::fmt::Debug; + +/// Encodes if a `DefKind::Ctor` is the constructor of an enum variant or a struct. +#[derive(Clone, Copy, PartialEq, Eq, Encodable, Decodable, Hash, Debug)] +#[derive(HashStable_Generic)] +pub enum CtorOf { + /// This `DefKind::Ctor` is a synthesized constructor of a tuple or unit struct. + Struct, + /// This `DefKind::Ctor` is a synthesized constructor of a tuple or unit variant. + Variant, +} + +/// What kind of constructor something is. +#[derive(Clone, Copy, PartialEq, Eq, Encodable, Decodable, Hash, Debug)] +#[derive(HashStable_Generic)] +pub enum CtorKind { + /// Constructor function automatically created by a tuple struct/variant. + Fn, + /// Constructor constant automatically created by a unit struct/variant. + Const, + /// Unusable name in value namespace created by a struct variant. + Fictive, +} + +/// An attribute that is not a macro; e.g., `#[inline]` or `#[rustfmt::skip]`. +#[derive(Clone, Copy, PartialEq, Eq, Encodable, Decodable, Hash, Debug)] +#[derive(HashStable_Generic)] +pub enum NonMacroAttrKind { + /// Single-segment attribute defined by the language (`#[inline]`) + Builtin(Symbol), + /// Multi-segment custom attribute living in a "tool module" (`#[rustfmt::skip]`). + Tool, + /// Single-segment custom attribute registered by a derive macro (`#[serde(default)]`). + DeriveHelper, + /// Single-segment custom attribute registered by a derive macro + /// but used before that derive macro was expanded (deprecated). + DeriveHelperCompat, + /// Single-segment custom attribute registered with `#[register_attr]`. + Registered, +} + +/// What kind of definition something is; e.g., `mod` vs `struct`. +#[derive(Clone, Copy, PartialEq, Eq, Encodable, Decodable, Hash, Debug)] +#[derive(HashStable_Generic)] +pub enum DefKind { + // Type namespace + Mod, + /// Refers to the struct itself, [`DefKind::Ctor`] refers to its constructor if it exists. + Struct, + Union, + Enum, + /// Refers to the variant itself, [`DefKind::Ctor`] refers to its constructor if it exists. + Variant, + Trait, + /// Type alias: `type Foo = Bar;` + TyAlias, + /// Type from an `extern` block. + ForeignTy, + /// Trait alias: `trait IntIterator = Iterator;` + TraitAlias, + /// Associated type: `trait MyTrait { type Assoc; }` + AssocTy, + /// Type parameter: the `T` in `struct Vec { ... }` + TyParam, + + // Value namespace + Fn, + Const, + /// Constant generic parameter: `struct Foo { ... }` + ConstParam, + Static(ast::Mutability), + /// Refers to the struct or enum variant's constructor. + /// + /// The reason `Ctor` exists in addition to [`DefKind::Struct`] and + /// [`DefKind::Variant`] is because structs and enum variants exist + /// in the *type* namespace, whereas struct and enum variant *constructors* + /// exist in the *value* namespace. + /// + /// You may wonder why enum variants exist in the type namespace as opposed + /// to the value namespace. Check out [RFC 2593] for intuition on why that is. + /// + /// [RFC 2593]: https://github.com/rust-lang/rfcs/pull/2593 + Ctor(CtorOf, CtorKind), + /// Associated function: `impl MyStruct { fn associated() {} }` + /// or `trait Foo { fn associated() {} }` + AssocFn, + /// Associated constant: `trait MyTrait { const ASSOC: usize; }` + AssocConst, + + // Macro namespace + Macro(MacroKind), + + // Not namespaced (or they are, but we don't treat them so) + ExternCrate, + Use, + /// An `extern` block. + ForeignMod, + /// Anonymous constant, e.g. the `1 + 2` in `[u8; 1 + 2]` + AnonConst, + /// An inline constant, e.g. `const { 1 + 2 }` + InlineConst, + /// Opaque type, aka `impl Trait`. + OpaqueTy, + Field, + /// Lifetime parameter: the `'a` in `struct Foo<'a> { ... }` + LifetimeParam, + /// A use of `global_asm!`. + GlobalAsm, + Impl, + Closure, + Generator, +} + +impl DefKind { + pub fn descr(self, def_id: DefId) -> &'static str { + match self { + DefKind::Fn => "function", + DefKind::Mod if def_id.is_crate_root() && !def_id.is_local() => "crate", + DefKind::Mod => "module", + DefKind::Static(..) => "static", + DefKind::Enum => "enum", + DefKind::Variant => "variant", + DefKind::Ctor(CtorOf::Variant, CtorKind::Fn) => "tuple variant", + DefKind::Ctor(CtorOf::Variant, CtorKind::Const) => "unit variant", + DefKind::Ctor(CtorOf::Variant, CtorKind::Fictive) => "struct variant", + DefKind::Struct => "struct", + DefKind::Ctor(CtorOf::Struct, CtorKind::Fn) => "tuple struct", + DefKind::Ctor(CtorOf::Struct, CtorKind::Const) => "unit struct", + DefKind::Ctor(CtorOf::Struct, CtorKind::Fictive) => { + panic!("impossible struct constructor") + } + DefKind::OpaqueTy => "opaque type", + DefKind::TyAlias => "type alias", + DefKind::TraitAlias => "trait alias", + DefKind::AssocTy => "associated type", + DefKind::Union => "union", + DefKind::Trait => "trait", + DefKind::ForeignTy => "foreign type", + DefKind::AssocFn => "associated function", + DefKind::Const => "constant", + DefKind::AssocConst => "associated constant", + DefKind::TyParam => "type parameter", + DefKind::ConstParam => "const parameter", + DefKind::Macro(macro_kind) => macro_kind.descr(), + DefKind::LifetimeParam => "lifetime parameter", + DefKind::Use => "import", + DefKind::ForeignMod => "foreign module", + DefKind::AnonConst => "constant expression", + DefKind::InlineConst => "inline constant", + DefKind::Field => "field", + DefKind::Impl => "implementation", + DefKind::Closure => "closure", + DefKind::Generator => "generator", + DefKind::ExternCrate => "extern crate", + DefKind::GlobalAsm => "global assembly block", + } + } + + /// Gets an English article for the definition. + pub fn article(&self) -> &'static str { + match *self { + DefKind::AssocTy + | DefKind::AssocConst + | DefKind::AssocFn + | DefKind::Enum + | DefKind::OpaqueTy + | DefKind::Impl + | DefKind::Use + | DefKind::InlineConst + | DefKind::ExternCrate => "an", + DefKind::Macro(macro_kind) => macro_kind.article(), + _ => "a", + } + } + + pub fn ns(&self) -> Option { + match self { + DefKind::Mod + | DefKind::Struct + | DefKind::Union + | DefKind::Enum + | DefKind::Variant + | DefKind::Trait + | DefKind::OpaqueTy + | DefKind::TyAlias + | DefKind::ForeignTy + | DefKind::TraitAlias + | DefKind::AssocTy + | DefKind::TyParam => Some(Namespace::TypeNS), + + DefKind::Fn + | DefKind::Const + | DefKind::ConstParam + | DefKind::Static(..) + | DefKind::Ctor(..) + | DefKind::AssocFn + | DefKind::AssocConst => Some(Namespace::ValueNS), + + DefKind::Macro(..) => Some(Namespace::MacroNS), + + // Not namespaced. + DefKind::AnonConst + | DefKind::InlineConst + | DefKind::Field + | DefKind::LifetimeParam + | DefKind::ExternCrate + | DefKind::Closure + | DefKind::Generator + | DefKind::Use + | DefKind::ForeignMod + | DefKind::GlobalAsm + | DefKind::Impl => None, + } + } + + #[inline] + pub fn is_fn_like(self) -> bool { + match self { + DefKind::Fn | DefKind::AssocFn | DefKind::Closure | DefKind::Generator => true, + _ => false, + } + } + + /// Whether `query get_codegen_attrs` should be used with this definition. + pub fn has_codegen_attrs(self) -> bool { + match self { + DefKind::Fn + | DefKind::AssocFn + | DefKind::Ctor(..) + | DefKind::Closure + | DefKind::Generator + | DefKind::Static(_) => true, + DefKind::Mod + | DefKind::Struct + | DefKind::Union + | DefKind::Enum + | DefKind::Variant + | DefKind::Trait + | DefKind::TyAlias + | DefKind::ForeignTy + | DefKind::TraitAlias + | DefKind::AssocTy + | DefKind::Const + | DefKind::AssocConst + | DefKind::Macro(..) + | DefKind::Use + | DefKind::ForeignMod + | DefKind::OpaqueTy + | DefKind::Impl + | DefKind::Field + | DefKind::TyParam + | DefKind::ConstParam + | DefKind::LifetimeParam + | DefKind::AnonConst + | DefKind::InlineConst + | DefKind::GlobalAsm + | DefKind::ExternCrate => false, + } + } +} + +/// The resolution of a path or export. +/// +/// For every path or identifier in Rust, the compiler must determine +/// what the path refers to. This process is called name resolution, +/// and `Res` is the primary result of name resolution. +/// +/// For example, everything prefixed with `/* Res */` in this example has +/// an associated `Res`: +/// +/// ``` +/// fn str_to_string(s: & /* Res */ str) -> /* Res */ String { +/// /* Res */ String::from(/* Res */ s) +/// } +/// +/// /* Res */ str_to_string("hello"); +/// ``` +/// +/// The associated `Res`s will be: +/// +/// - `str` will resolve to [`Res::PrimTy`]; +/// - `String` will resolve to [`Res::Def`], and the `Res` will include the [`DefId`] +/// for `String` as defined in the standard library; +/// - `String::from` will also resolve to [`Res::Def`], with the [`DefId`] +/// pointing to `String::from`; +/// - `s` will resolve to [`Res::Local`]; +/// - the call to `str_to_string` will resolve to [`Res::Def`], with the [`DefId`] +/// pointing to the definition of `str_to_string` in the current crate. +// +#[derive(Clone, Copy, PartialEq, Eq, Encodable, Decodable, Hash, Debug)] +#[derive(HashStable_Generic)] +pub enum Res { + /// Definition having a unique ID (`DefId`), corresponds to something defined in user code. + /// + /// **Not bound to a specific namespace.** + Def(DefKind, DefId), + + // Type namespace + /// A primitive type such as `i32` or `str`. + /// + /// **Belongs to the type namespace.** + PrimTy(hir::PrimTy), + /// The `Self` type, optionally with the [`DefId`] of the trait it belongs to and + /// optionally with the [`DefId`] of the item introducing the `Self` type alias. + /// + /// **Belongs to the type namespace.** + /// + /// Examples: + /// ``` + /// struct Bar(Box); + /// // `Res::SelfTy { trait_: None, alias_of: Some(Bar) }` + /// + /// trait Foo { + /// fn foo() -> Box; + /// // `Res::SelfTy { trait_: Some(Foo), alias_of: None }` + /// } + /// + /// impl Bar { + /// fn blah() { + /// let _: Self; + /// // `Res::SelfTy { trait_: None, alias_of: Some(::{impl#0}) }` + /// } + /// } + /// + /// impl Foo for Bar { + /// fn foo() -> Box { + /// // `Res::SelfTy { trait_: Some(Foo), alias_of: Some(::{impl#1}) }` + /// let _: Self; + /// // `Res::SelfTy { trait_: Some(Foo), alias_of: Some(::{impl#1}) }` + /// + /// todo!() + /// } + /// } + /// ``` + /// + /// *See also [`Res::SelfCtor`].* + /// + /// ----- + /// + /// HACK(min_const_generics): self types also have an optional requirement to **not** mention + /// any generic parameters to allow the following with `min_const_generics`: + /// ``` + /// # struct Foo; + /// impl Foo { fn test() -> [u8; std::mem::size_of::()] { todo!() } } + /// + /// struct Bar([u8; baz::()]); + /// const fn baz() -> usize { 10 } + /// ``` + /// We do however allow `Self` in repeat expression even if it is generic to not break code + /// which already works on stable while causing the `const_evaluatable_unchecked` future compat lint: + /// ``` + /// fn foo() { + /// let _bar = [1_u8; std::mem::size_of::<*mut T>()]; + /// } + /// ``` + // FIXME(generic_const_exprs): Remove this bodge once that feature is stable. + SelfTy { + /// The trait this `Self` is a generic arg for. + trait_: Option, + /// The item introducing the `Self` type alias. Can be used in the `type_of` query + /// to get the underlying type. Additionally whether the `Self` type is disallowed + /// from mentioning generics (i.e. when used in an anonymous constant). + alias_to: Option<(DefId, bool)>, + }, + /// A tool attribute module; e.g., the `rustfmt` in `#[rustfmt::skip]`. + /// + /// **Belongs to the type namespace.** + ToolMod, + + // Value namespace + /// The `Self` constructor, along with the [`DefId`] + /// of the impl it is associated with. + /// + /// **Belongs to the value namespace.** + /// + /// *See also [`Res::SelfTy`].* + SelfCtor(DefId), + /// A local variable or function parameter. + /// + /// **Belongs to the value namespace.** + Local(Id), + + // Macro namespace + /// An attribute that is *not* implemented via macro. + /// E.g., `#[inline]` and `#[rustfmt::skip]`, which are essentially directives, + /// as opposed to `#[test]`, which is a builtin macro. + /// + /// **Belongs to the macro namespace.** + NonMacroAttr(NonMacroAttrKind), // e.g., `#[inline]` or `#[rustfmt::skip]` + + // All namespaces + /// Name resolution failed. We use a dummy `Res` variant so later phases + /// of the compiler won't crash and can instead report more errors. + /// + /// **Not bound to a specific namespace.** + Err, +} + +/// The result of resolving a path before lowering to HIR, +/// with "module" segments resolved and associated item +/// segments deferred to type checking. +/// `base_res` is the resolution of the resolved part of the +/// path, `unresolved_segments` is the number of unresolved +/// segments. +/// +/// ```text +/// module::Type::AssocX::AssocY::MethodOrAssocType +/// ^~~~~~~~~~~~ ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +/// base_res unresolved_segments = 3 +/// +/// ::AssocX::AssocY::MethodOrAssocType +/// ^~~~~~~~~~~~~~ ^~~~~~~~~~~~~~~~~~~~~~~~~ +/// base_res unresolved_segments = 2 +/// ``` +#[derive(Copy, Clone, Debug)] +pub struct PartialRes { + base_res: Res, + unresolved_segments: usize, +} + +impl PartialRes { + #[inline] + pub fn new(base_res: Res) -> Self { + PartialRes { base_res, unresolved_segments: 0 } + } + + #[inline] + pub fn with_unresolved_segments(base_res: Res, mut unresolved_segments: usize) -> Self { + if base_res == Res::Err { + unresolved_segments = 0 + } + PartialRes { base_res, unresolved_segments } + } + + #[inline] + pub fn base_res(&self) -> Res { + self.base_res + } + + #[inline] + pub fn unresolved_segments(&self) -> usize { + self.unresolved_segments + } +} + +/// Different kinds of symbols can coexist even if they share the same textual name. +/// Therefore, they each have a separate universe (known as a "namespace"). +#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)] +pub enum Namespace { + /// The type namespace includes `struct`s, `enum`s, `union`s, `trait`s, and `mod`s + /// (and, by extension, crates). + /// + /// Note that the type namespace includes other items; this is not an + /// exhaustive list. + TypeNS, + /// The value namespace includes `fn`s, `const`s, `static`s, and local variables (including function arguments). + ValueNS, + /// The macro namespace includes `macro_rules!` macros, declarative `macro`s, + /// procedural macros, attribute macros, `derive` macros, and non-macro attributes + /// like `#[inline]` and `#[rustfmt::skip]`. + MacroNS, +} + +impl Namespace { + /// The English description of the namespace. + pub fn descr(self) -> &'static str { + match self { + Self::TypeNS => "type", + Self::ValueNS => "value", + Self::MacroNS => "macro", + } + } +} + +/// Just a helper ‒ separate structure for each namespace. +#[derive(Copy, Clone, Default, Debug)] +pub struct PerNS { + pub value_ns: T, + pub type_ns: T, + pub macro_ns: T, +} + +impl PerNS { + pub fn map U>(self, mut f: F) -> PerNS { + PerNS { value_ns: f(self.value_ns), type_ns: f(self.type_ns), macro_ns: f(self.macro_ns) } + } + + pub fn into_iter(self) -> IntoIter { + [self.value_ns, self.type_ns, self.macro_ns].into_iter() + } + + pub fn iter(&self) -> IntoIter<&T, 3> { + [&self.value_ns, &self.type_ns, &self.macro_ns].into_iter() + } +} + +impl ::std::ops::Index for PerNS { + type Output = T; + + fn index(&self, ns: Namespace) -> &T { + match ns { + Namespace::ValueNS => &self.value_ns, + Namespace::TypeNS => &self.type_ns, + Namespace::MacroNS => &self.macro_ns, + } + } +} + +impl ::std::ops::IndexMut for PerNS { + fn index_mut(&mut self, ns: Namespace) -> &mut T { + match ns { + Namespace::ValueNS => &mut self.value_ns, + Namespace::TypeNS => &mut self.type_ns, + Namespace::MacroNS => &mut self.macro_ns, + } + } +} + +impl PerNS> { + /// Returns `true` if all the items in this collection are `None`. + pub fn is_empty(&self) -> bool { + self.type_ns.is_none() && self.value_ns.is_none() && self.macro_ns.is_none() + } + + /// Returns an iterator over the items which are `Some`. + pub fn present_items(self) -> impl Iterator { + [self.type_ns, self.value_ns, self.macro_ns].into_iter().flatten() + } +} + +impl CtorKind { + pub fn from_ast(vdata: &ast::VariantData) -> CtorKind { + match *vdata { + ast::VariantData::Tuple(..) => CtorKind::Fn, + ast::VariantData::Unit(..) => CtorKind::Const, + ast::VariantData::Struct(..) => CtorKind::Fictive, + } + } + + pub fn from_hir(vdata: &hir::VariantData<'_>) -> CtorKind { + match *vdata { + hir::VariantData::Tuple(..) => CtorKind::Fn, + hir::VariantData::Unit(..) => CtorKind::Const, + hir::VariantData::Struct(..) => CtorKind::Fictive, + } + } +} + +impl NonMacroAttrKind { + pub fn descr(self) -> &'static str { + match self { + NonMacroAttrKind::Builtin(..) => "built-in attribute", + NonMacroAttrKind::Tool => "tool attribute", + NonMacroAttrKind::DeriveHelper | NonMacroAttrKind::DeriveHelperCompat => { + "derive helper attribute" + } + NonMacroAttrKind::Registered => "explicitly registered attribute", + } + } + + pub fn article(self) -> &'static str { + match self { + NonMacroAttrKind::Registered => "an", + _ => "a", + } + } + + /// Users of some attributes cannot mark them as used, so they are considered always used. + pub fn is_used(self) -> bool { + match self { + NonMacroAttrKind::Tool + | NonMacroAttrKind::DeriveHelper + | NonMacroAttrKind::DeriveHelperCompat => true, + NonMacroAttrKind::Builtin(..) | NonMacroAttrKind::Registered => false, + } + } +} + +impl Res { + /// Return the `DefId` of this `Def` if it has an ID, else panic. + pub fn def_id(&self) -> DefId + where + Id: Debug, + { + self.opt_def_id() + .unwrap_or_else(|| panic!("attempted .def_id() on invalid res: {:?}", self)) + } + + /// Return `Some(..)` with the `DefId` of this `Res` if it has a ID, else `None`. + pub fn opt_def_id(&self) -> Option { + match *self { + Res::Def(_, id) => Some(id), + + Res::Local(..) + | Res::PrimTy(..) + | Res::SelfTy { .. } + | Res::SelfCtor(..) + | Res::ToolMod + | Res::NonMacroAttr(..) + | Res::Err => None, + } + } + + /// Return the `DefId` of this `Res` if it represents a module. + pub fn mod_def_id(&self) -> Option { + match *self { + Res::Def(DefKind::Mod, id) => Some(id), + _ => None, + } + } + + /// A human readable name for the res kind ("function", "module", etc.). + pub fn descr(&self) -> &'static str { + match *self { + Res::Def(kind, def_id) => kind.descr(def_id), + Res::SelfCtor(..) => "self constructor", + Res::PrimTy(..) => "builtin type", + Res::Local(..) => "local variable", + Res::SelfTy { .. } => "self type", + Res::ToolMod => "tool module", + Res::NonMacroAttr(attr_kind) => attr_kind.descr(), + Res::Err => "unresolved item", + } + } + + /// Gets an English article for the `Res`. + pub fn article(&self) -> &'static str { + match *self { + Res::Def(kind, _) => kind.article(), + Res::NonMacroAttr(kind) => kind.article(), + Res::Err => "an", + _ => "a", + } + } + + pub fn map_id(self, mut map: impl FnMut(Id) -> R) -> Res { + match self { + Res::Def(kind, id) => Res::Def(kind, id), + Res::SelfCtor(id) => Res::SelfCtor(id), + Res::PrimTy(id) => Res::PrimTy(id), + Res::Local(id) => Res::Local(map(id)), + Res::SelfTy { trait_, alias_to } => Res::SelfTy { trait_, alias_to }, + Res::ToolMod => Res::ToolMod, + Res::NonMacroAttr(attr_kind) => Res::NonMacroAttr(attr_kind), + Res::Err => Res::Err, + } + } + + pub fn apply_id(self, mut map: impl FnMut(Id) -> Result) -> Result, E> { + Ok(match self { + Res::Def(kind, id) => Res::Def(kind, id), + Res::SelfCtor(id) => Res::SelfCtor(id), + Res::PrimTy(id) => Res::PrimTy(id), + Res::Local(id) => Res::Local(map(id)?), + Res::SelfTy { trait_, alias_to } => Res::SelfTy { trait_, alias_to }, + Res::ToolMod => Res::ToolMod, + Res::NonMacroAttr(attr_kind) => Res::NonMacroAttr(attr_kind), + Res::Err => Res::Err, + }) + } + + #[track_caller] + pub fn expect_non_local(self) -> Res { + self.map_id( + #[track_caller] + |_| panic!("unexpected `Res::Local`"), + ) + } + + pub fn macro_kind(self) -> Option { + match self { + Res::Def(DefKind::Macro(kind), _) => Some(kind), + Res::NonMacroAttr(..) => Some(MacroKind::Attr), + _ => None, + } + } + + /// Returns `None` if this is `Res::Err` + pub fn ns(&self) -> Option { + match self { + Res::Def(kind, ..) => kind.ns(), + Res::PrimTy(..) | Res::SelfTy { .. } | Res::ToolMod => Some(Namespace::TypeNS), + Res::SelfCtor(..) | Res::Local(..) => Some(Namespace::ValueNS), + Res::NonMacroAttr(..) => Some(Namespace::MacroNS), + Res::Err => None, + } + } + + /// Always returns `true` if `self` is `Res::Err` + pub fn matches_ns(&self, ns: Namespace) -> bool { + self.ns().map_or(true, |actual_ns| actual_ns == ns) + } + + /// Returns whether such a resolved path can occur in a tuple struct/variant pattern + pub fn expected_in_tuple_struct_pat(&self) -> bool { + matches!(self, Res::Def(DefKind::Ctor(_, CtorKind::Fn), _) | Res::SelfCtor(..)) + } + + /// Returns whether such a resolved path can occur in a unit struct/variant pattern + pub fn expected_in_unit_struct_pat(&self) -> bool { + matches!(self, Res::Def(DefKind::Ctor(_, CtorKind::Const), _) | Res::SelfCtor(..)) + } +} + +/// Resolution for a lifetime appearing in a type. +#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] +pub enum LifetimeRes { + /// Successfully linked the lifetime to a generic parameter. + Param { + /// Id of the generic parameter that introduced it. + param: LocalDefId, + /// Id of the introducing place. That can be: + /// - an item's id, for the item's generic parameters; + /// - a TraitRef's ref_id, identifying the `for<...>` binder; + /// - a BareFn type's id. + /// + /// This information is used for impl-trait lifetime captures, to know when to or not to + /// capture any given lifetime. + binder: NodeId, + }, + /// Created a generic parameter for an anonymous lifetime. + Fresh { + /// Id of the generic parameter that introduced it. + /// + /// Creating the associated `LocalDefId` is the responsibility of lowering. + param: NodeId, + /// Id of the introducing place. See `Param`. + binder: NodeId, + }, + /// This variant is used for anonymous lifetimes that we did not resolve during + /// late resolution. Those lifetimes will be inferred by typechecking. + Infer, + /// Explicit `'static` lifetime. + Static, + /// Resolution failure. + Error, + /// HACK: This is used to recover the NodeId of an elided lifetime. + ElidedAnchor { start: NodeId, end: NodeId }, +} diff --git a/compiler/rustc_hir/src/def_path_hash_map.rs b/compiler/rustc_hir/src/def_path_hash_map.rs new file mode 100644 index 000000000..8bfb47af2 --- /dev/null +++ b/compiler/rustc_hir/src/def_path_hash_map.rs @@ -0,0 +1,37 @@ +use rustc_data_structures::fingerprint::Fingerprint; +use rustc_span::def_id::{DefIndex, DefPathHash}; + +#[derive(Clone, Default)] +pub struct Config; + +impl odht::Config for Config { + type Key = DefPathHash; + type Value = DefIndex; + + type EncodedKey = [u8; 16]; + type EncodedValue = [u8; 4]; + + type H = odht::UnHashFn; + + #[inline] + fn encode_key(k: &DefPathHash) -> [u8; 16] { + k.0.to_le_bytes() + } + + #[inline] + fn encode_value(v: &DefIndex) -> [u8; 4] { + v.as_u32().to_le_bytes() + } + + #[inline] + fn decode_key(k: &[u8; 16]) -> DefPathHash { + DefPathHash(Fingerprint::from_le_bytes(*k)) + } + + #[inline] + fn decode_value(v: &[u8; 4]) -> DefIndex { + DefIndex::from_u32(u32::from_le_bytes(*v)) + } +} + +pub type DefPathHashMap = odht::HashTableOwned; diff --git a/compiler/rustc_hir/src/definitions.rs b/compiler/rustc_hir/src/definitions.rs new file mode 100644 index 000000000..c2c551e78 --- /dev/null +++ b/compiler/rustc_hir/src/definitions.rs @@ -0,0 +1,440 @@ +//! For each definition, we track the following data. A definition +//! here is defined somewhat circularly as "something with a `DefId`", +//! but it generally corresponds to things like structs, enums, etc. +//! There are also some rather random cases (like const initializer +//! expressions) that are mostly just leftovers. + +pub use crate::def_id::DefPathHash; +use crate::def_id::{CrateNum, DefIndex, LocalDefId, StableCrateId, CRATE_DEF_INDEX, LOCAL_CRATE}; +use crate::def_path_hash_map::DefPathHashMap; + +use rustc_data_structures::fx::FxHashMap; +use rustc_data_structures::stable_hasher::StableHasher; +use rustc_index::vec::IndexVec; +use rustc_span::symbol::{kw, sym, Symbol}; + +use std::fmt::{self, Write}; +use std::hash::Hash; +use tracing::debug; + +/// The `DefPathTable` maps `DefIndex`es to `DefKey`s and vice versa. +/// Internally the `DefPathTable` holds a tree of `DefKey`s, where each `DefKey` +/// stores the `DefIndex` of its parent. +/// There is one `DefPathTable` for each crate. +#[derive(Clone, Default, Debug)] +pub struct DefPathTable { + index_to_key: IndexVec, + def_path_hashes: IndexVec, + def_path_hash_to_index: DefPathHashMap, +} + +impl DefPathTable { + fn allocate(&mut self, key: DefKey, def_path_hash: DefPathHash) -> DefIndex { + let index = { + let index = DefIndex::from(self.index_to_key.len()); + debug!("DefPathTable::insert() - {:?} <-> {:?}", key, index); + self.index_to_key.push(key); + index + }; + self.def_path_hashes.push(def_path_hash); + debug_assert!(self.def_path_hashes.len() == self.index_to_key.len()); + + // Check for hash collisions of DefPathHashes. These should be + // exceedingly rare. + if let Some(existing) = self.def_path_hash_to_index.insert(&def_path_hash, &index) { + let def_path1 = DefPath::make(LOCAL_CRATE, existing, |idx| self.def_key(idx)); + let def_path2 = DefPath::make(LOCAL_CRATE, index, |idx| self.def_key(idx)); + + // Continuing with colliding DefPathHashes can lead to correctness + // issues. We must abort compilation. + // + // The likelihood of such a collision is very small, so actually + // running into one could be indicative of a poor hash function + // being used. + // + // See the documentation for DefPathHash for more information. + panic!( + "found DefPathHash collision between {:?} and {:?}. \ + Compilation cannot continue.", + def_path1, def_path2 + ); + } + + // Assert that all DefPathHashes correctly contain the local crate's + // StableCrateId + #[cfg(debug_assertions)] + if let Some(root) = self.def_path_hashes.get(CRATE_DEF_INDEX) { + assert!(def_path_hash.stable_crate_id() == root.stable_crate_id()); + } + + index + } + + #[inline(always)] + pub fn def_key(&self, index: DefIndex) -> DefKey { + self.index_to_key[index] + } + + #[inline(always)] + pub fn def_path_hash(&self, index: DefIndex) -> DefPathHash { + let hash = self.def_path_hashes[index]; + debug!("def_path_hash({:?}) = {:?}", index, hash); + hash + } + + pub fn enumerated_keys_and_path_hashes( + &self, + ) -> impl Iterator + ExactSizeIterator + '_ { + self.index_to_key + .iter_enumerated() + .map(move |(index, key)| (index, key, &self.def_path_hashes[index])) + } +} + +/// The definition table containing node definitions. +/// It holds the `DefPathTable` for `LocalDefId`s/`DefPath`s. +/// It also stores mappings to convert `LocalDefId`s to/from `HirId`s. +#[derive(Clone, Debug)] +pub struct Definitions { + table: DefPathTable, + next_disambiguator: FxHashMap<(LocalDefId, DefPathData), u32>, + + /// The [StableCrateId] of the local crate. + stable_crate_id: StableCrateId, +} + +/// A unique identifier that we can use to lookup a definition +/// precisely. It combines the index of the definition's parent (if +/// any) with a `DisambiguatedDefPathData`. +#[derive(Copy, Clone, PartialEq, Debug, Encodable, Decodable)] +pub struct DefKey { + /// The parent path. + pub parent: Option, + + /// The identifier of this node. + pub disambiguated_data: DisambiguatedDefPathData, +} + +impl DefKey { + pub(crate) fn compute_stable_hash(&self, parent: DefPathHash) -> DefPathHash { + let mut hasher = StableHasher::new(); + + parent.hash(&mut hasher); + + let DisambiguatedDefPathData { ref data, disambiguator } = self.disambiguated_data; + + std::mem::discriminant(data).hash(&mut hasher); + if let Some(name) = data.get_opt_name() { + // Get a stable hash by considering the symbol chars rather than + // the symbol index. + name.as_str().hash(&mut hasher); + } + + disambiguator.hash(&mut hasher); + + let local_hash: u64 = hasher.finish(); + + // Construct the new DefPathHash, making sure that the `crate_id` + // portion of the hash is properly copied from the parent. This way the + // `crate_id` part will be recursively propagated from the root to all + // DefPathHashes in this DefPathTable. + DefPathHash::new(parent.stable_crate_id(), local_hash) + } + + #[inline] + pub fn get_opt_name(&self) -> Option { + self.disambiguated_data.data.get_opt_name() + } +} + +/// A pair of `DefPathData` and an integer disambiguator. The integer is +/// normally `0`, but in the event that there are multiple defs with the +/// same `parent` and `data`, we use this field to disambiguate +/// between them. This introduces some artificial ordering dependency +/// but means that if you have, e.g., two impls for the same type in +/// the same module, they do get distinct `DefId`s. +#[derive(Copy, Clone, PartialEq, Debug, Encodable, Decodable)] +pub struct DisambiguatedDefPathData { + pub data: DefPathData, + pub disambiguator: u32, +} + +impl DisambiguatedDefPathData { + pub fn fmt_maybe_verbose(&self, writer: &mut impl Write, verbose: bool) -> fmt::Result { + match self.data.name() { + DefPathDataName::Named(name) => { + if verbose && self.disambiguator != 0 { + write!(writer, "{}#{}", name, self.disambiguator) + } else { + writer.write_str(name.as_str()) + } + } + DefPathDataName::Anon { namespace } => { + write!(writer, "{{{}#{}}}", namespace, self.disambiguator) + } + } + } +} + +impl fmt::Display for DisambiguatedDefPathData { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + self.fmt_maybe_verbose(f, true) + } +} + +#[derive(Clone, Debug, Encodable, Decodable)] +pub struct DefPath { + /// The path leading from the crate root to the item. + pub data: Vec, + + /// The crate root this path is relative to. + pub krate: CrateNum, +} + +impl DefPath { + pub fn make(krate: CrateNum, start_index: DefIndex, mut get_key: FN) -> DefPath + where + FN: FnMut(DefIndex) -> DefKey, + { + let mut data = vec![]; + let mut index = Some(start_index); + loop { + debug!("DefPath::make: krate={:?} index={:?}", krate, index); + let p = index.unwrap(); + let key = get_key(p); + debug!("DefPath::make: key={:?}", key); + match key.disambiguated_data.data { + DefPathData::CrateRoot => { + assert!(key.parent.is_none()); + break; + } + _ => { + data.push(key.disambiguated_data); + index = key.parent; + } + } + } + data.reverse(); + DefPath { data, krate } + } + + /// Returns a string representation of the `DefPath` without + /// the crate-prefix. This method is useful if you don't have + /// a `TyCtxt` available. + pub fn to_string_no_crate_verbose(&self) -> String { + let mut s = String::with_capacity(self.data.len() * 16); + + for component in &self.data { + write!(s, "::{}", component).unwrap(); + } + + s + } + + /// Returns a filename-friendly string of the `DefPath`, without + /// the crate-prefix. This method is useful if you don't have + /// a `TyCtxt` available. + pub fn to_filename_friendly_no_crate(&self) -> String { + let mut s = String::with_capacity(self.data.len() * 16); + + let mut opt_delimiter = None; + for component in &self.data { + s.extend(opt_delimiter); + opt_delimiter = Some('-'); + write!(s, "{}", component).unwrap(); + } + + s + } +} + +#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Encodable, Decodable)] +pub enum DefPathData { + // Root: these should only be used for the root nodes, because + // they are treated specially by the `def_path` function. + /// The crate root (marker). + CrateRoot, + + // Different kinds of items and item-like things: + /// An impl. + Impl, + /// An `extern` block. + ForeignMod, + /// A `use` item. + Use, + /// A global asm item. + GlobalAsm, + /// Something in the type namespace. + TypeNs(Symbol), + /// Something in the value namespace. + ValueNs(Symbol), + /// Something in the macro namespace. + MacroNs(Symbol), + /// Something in the lifetime namespace. + LifetimeNs(Symbol), + /// A closure expression. + ClosureExpr, + + // Subportions of items: + /// Implicit constructor for a unit or tuple-like struct or enum variant. + Ctor, + /// A constant expression (see `{ast,hir}::AnonConst`). + AnonConst, + /// An `impl Trait` type node. + ImplTrait, +} + +impl Definitions { + pub fn def_path_table(&self) -> &DefPathTable { + &self.table + } + + /// Gets the number of definitions. + pub fn def_index_count(&self) -> usize { + self.table.index_to_key.len() + } + + #[inline] + pub fn def_key(&self, id: LocalDefId) -> DefKey { + self.table.def_key(id.local_def_index) + } + + #[inline(always)] + pub fn def_path_hash(&self, id: LocalDefId) -> DefPathHash { + self.table.def_path_hash(id.local_def_index) + } + + /// Returns the path from the crate root to `index`. The root + /// nodes are not included in the path (i.e., this will be an + /// empty vector for the crate root). For an inlined item, this + /// will be the path of the item in the external crate (but the + /// path will begin with the path to the external crate). + pub fn def_path(&self, id: LocalDefId) -> DefPath { + DefPath::make(LOCAL_CRATE, id.local_def_index, |index| { + self.def_key(LocalDefId { local_def_index: index }) + }) + } + + /// Adds a root definition (no parent) and a few other reserved definitions. + pub fn new(stable_crate_id: StableCrateId) -> Definitions { + let key = DefKey { + parent: None, + disambiguated_data: DisambiguatedDefPathData { + data: DefPathData::CrateRoot, + disambiguator: 0, + }, + }; + + let parent_hash = DefPathHash::new(stable_crate_id, 0); + let def_path_hash = key.compute_stable_hash(parent_hash); + + // Create the root definition. + let mut table = DefPathTable::default(); + let root = LocalDefId { local_def_index: table.allocate(key, def_path_hash) }; + assert_eq!(root.local_def_index, CRATE_DEF_INDEX); + + Definitions { table, next_disambiguator: Default::default(), stable_crate_id } + } + + /// Adds a definition with a parent definition. + pub fn create_def(&mut self, parent: LocalDefId, data: DefPathData) -> LocalDefId { + // We can't use `Debug` implementation for `LocalDefId` here, since it tries to acquire a + // reference to `Definitions` and we're already holding a mutable reference. + debug!( + "create_def(parent={}, data={data:?})", + self.def_path(parent).to_string_no_crate_verbose(), + ); + + // The root node must be created with `create_root_def()`. + assert!(data != DefPathData::CrateRoot); + + // Find the next free disambiguator for this key. + let disambiguator = { + let next_disamb = self.next_disambiguator.entry((parent, data)).or_insert(0); + let disambiguator = *next_disamb; + *next_disamb = next_disamb.checked_add(1).expect("disambiguator overflow"); + disambiguator + }; + let key = DefKey { + parent: Some(parent.local_def_index), + disambiguated_data: DisambiguatedDefPathData { data, disambiguator }, + }; + + let parent_hash = self.table.def_path_hash(parent.local_def_index); + let def_path_hash = key.compute_stable_hash(parent_hash); + + debug!("create_def: after disambiguation, key = {:?}", key); + + // Create the definition. + LocalDefId { local_def_index: self.table.allocate(key, def_path_hash) } + } + + pub fn iter_local_def_id(&self) -> impl Iterator + '_ { + self.table.def_path_hashes.indices().map(|local_def_index| LocalDefId { local_def_index }) + } + + #[inline(always)] + pub fn local_def_path_hash_to_def_id( + &self, + hash: DefPathHash, + err: &mut dyn FnMut() -> !, + ) -> LocalDefId { + debug_assert!(hash.stable_crate_id() == self.stable_crate_id); + self.table + .def_path_hash_to_index + .get(&hash) + .map(|local_def_index| LocalDefId { local_def_index }) + .unwrap_or_else(|| err()) + } + + pub fn def_path_hash_to_def_index_map(&self) -> &DefPathHashMap { + &self.table.def_path_hash_to_index + } +} + +#[derive(Copy, Clone, PartialEq, Debug)] +pub enum DefPathDataName { + Named(Symbol), + Anon { namespace: Symbol }, +} + +impl DefPathData { + pub fn get_opt_name(&self) -> Option { + use self::DefPathData::*; + match *self { + TypeNs(name) | ValueNs(name) | MacroNs(name) | LifetimeNs(name) => Some(name), + + Impl | ForeignMod | CrateRoot | Use | GlobalAsm | ClosureExpr | Ctor | AnonConst + | ImplTrait => None, + } + } + + pub fn name(&self) -> DefPathDataName { + use self::DefPathData::*; + match *self { + TypeNs(name) | ValueNs(name) | MacroNs(name) | LifetimeNs(name) => { + DefPathDataName::Named(name) + } + // Note that this does not show up in user print-outs. + CrateRoot => DefPathDataName::Anon { namespace: kw::Crate }, + Impl => DefPathDataName::Anon { namespace: kw::Impl }, + ForeignMod => DefPathDataName::Anon { namespace: kw::Extern }, + Use => DefPathDataName::Anon { namespace: kw::Use }, + GlobalAsm => DefPathDataName::Anon { namespace: sym::global_asm }, + ClosureExpr => DefPathDataName::Anon { namespace: sym::closure }, + Ctor => DefPathDataName::Anon { namespace: sym::constructor }, + AnonConst => DefPathDataName::Anon { namespace: sym::constant }, + ImplTrait => DefPathDataName::Anon { namespace: sym::opaque }, + } + } +} + +impl fmt::Display for DefPathData { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self.name() { + DefPathDataName::Named(name) => f.write_str(name.as_str()), + // FIXME(#70334): this will generate legacy {{closure}}, {{impl}}, etc + DefPathDataName::Anon { namespace } => write!(f, "{{{{{}}}}}", namespace), + } + } +} diff --git a/compiler/rustc_hir/src/diagnostic_items.rs b/compiler/rustc_hir/src/diagnostic_items.rs new file mode 100644 index 000000000..243014b00 --- /dev/null +++ b/compiler/rustc_hir/src/diagnostic_items.rs @@ -0,0 +1,17 @@ +use crate::def_id::DefId; +use rustc_data_structures::fx::FxHashMap; +use rustc_data_structures::stable_hasher::{HashStable, StableHasher}; +use rustc_span::Symbol; + +#[derive(Debug, Default)] +pub struct DiagnosticItems { + pub id_to_name: FxHashMap, + pub name_to_id: FxHashMap, +} + +impl HashStable for DiagnosticItems { + #[inline] + fn hash_stable(&self, ctx: &mut CTX, hasher: &mut StableHasher) { + self.name_to_id.hash_stable(ctx, hasher); + } +} diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs new file mode 100644 index 000000000..617433a98 --- /dev/null +++ b/compiler/rustc_hir/src/hir.rs @@ -0,0 +1,3506 @@ +use crate::def::{CtorKind, DefKind, Res}; +use crate::def_id::DefId; +pub(crate) use crate::hir_id::{HirId, ItemLocalId}; +use crate::intravisit::FnKind; +use crate::LangItem; + +use rustc_ast as ast; +use rustc_ast::util::parser::ExprPrecedence; +use rustc_ast::{Attribute, FloatTy, IntTy, Label, LitKind, TraitObjectSyntax, UintTy}; +pub use rustc_ast::{BorrowKind, ImplPolarity, IsAuto}; +pub use rustc_ast::{CaptureBy, Movability, Mutability}; +use rustc_ast::{InlineAsmOptions, InlineAsmTemplatePiece}; +use rustc_data_structures::fingerprint::Fingerprint; +use rustc_data_structures::fx::FxHashMap; +use rustc_data_structures::sorted_map::SortedMap; +use rustc_error_messages::MultiSpan; +use rustc_index::vec::IndexVec; +use rustc_macros::HashStable_Generic; +use rustc_span::hygiene::MacroKind; +use rustc_span::source_map::Spanned; +use rustc_span::symbol::{kw, sym, Ident, Symbol}; +use rustc_span::{def_id::LocalDefId, BytePos, Span, DUMMY_SP}; +use rustc_target::asm::InlineAsmRegOrRegClass; +use rustc_target::spec::abi::Abi; + +use smallvec::SmallVec; +use std::fmt; + +#[derive(Debug, Copy, Clone, Encodable, HashStable_Generic)] +pub struct Lifetime { + pub hir_id: HirId, + pub span: Span, + + /// Either "`'a`", referring to a named lifetime definition, + /// or "``" (i.e., `kw::Empty`), for elision placeholders. + /// + /// HIR lowering inserts these placeholders in type paths that + /// refer to type definitions needing lifetime parameters, + /// `&T` and `&mut T`, and trait objects without `... + 'a`. + pub name: LifetimeName, +} + +#[derive(Debug, Clone, PartialEq, Eq, Encodable, Hash, Copy)] +#[derive(HashStable_Generic)] +pub enum ParamName { + /// Some user-given name like `T` or `'x`. + Plain(Ident), + + /// Synthetic name generated when user elided a lifetime in an impl header. + /// + /// E.g., the lifetimes in cases like these: + /// ```ignore (fragment) + /// impl Foo for &u32 + /// impl Foo<'_> for u32 + /// ``` + /// in that case, we rewrite to + /// ```ignore (fragment) + /// impl<'f> Foo for &'f u32 + /// impl<'f> Foo<'f> for u32 + /// ``` + /// where `'f` is something like `Fresh(0)`. The indices are + /// unique per impl, but not necessarily continuous. + Fresh, + + /// Indicates an illegal name was given and an error has been + /// reported (so we should squelch other derived errors). Occurs + /// when, e.g., `'_` is used in the wrong place. + Error, +} + +impl ParamName { + pub fn ident(&self) -> Ident { + match *self { + ParamName::Plain(ident) => ident, + ParamName::Fresh | ParamName::Error => Ident::with_dummy_span(kw::UnderscoreLifetime), + } + } + + pub fn normalize_to_macros_2_0(&self) -> ParamName { + match *self { + ParamName::Plain(ident) => ParamName::Plain(ident.normalize_to_macros_2_0()), + param_name => param_name, + } + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Encodable, Hash, Copy)] +#[derive(HashStable_Generic)] +pub enum LifetimeName { + /// User-given names or fresh (synthetic) names. + Param(LocalDefId, ParamName), + + /// Implicit lifetime in a context like `dyn Foo`. This is + /// distinguished from implicit lifetimes elsewhere because the + /// lifetime that they default to must appear elsewhere within the + /// enclosing type. This means that, in an `impl Trait` context, we + /// don't have to create a parameter for them. That is, `impl + /// Trait` expands to an opaque type like `type + /// Foo<'a> = impl Trait`, but `impl Trait` expands to `type Foo = impl Trait`. The latter uses `ImplicitObjectLifetimeDefault` so + /// that surrounding code knows not to create a lifetime + /// parameter. + ImplicitObjectLifetimeDefault, + + /// Indicates an error during lowering (usually `'_` in wrong place) + /// that was already reported. + Error, + + /// User wrote an anonymous lifetime, either `'_` or nothing. + /// The semantics of this lifetime should be inferred by typechecking code. + Infer, + + /// User wrote `'static`. + Static, +} + +impl LifetimeName { + pub fn ident(&self) -> Ident { + match *self { + LifetimeName::ImplicitObjectLifetimeDefault | LifetimeName::Error => Ident::empty(), + LifetimeName::Infer => Ident::with_dummy_span(kw::UnderscoreLifetime), + LifetimeName::Static => Ident::with_dummy_span(kw::StaticLifetime), + LifetimeName::Param(_, param_name) => param_name.ident(), + } + } + + pub fn is_anonymous(&self) -> bool { + match *self { + LifetimeName::ImplicitObjectLifetimeDefault + | LifetimeName::Infer + | LifetimeName::Param(_, ParamName::Fresh) + | LifetimeName::Error => true, + LifetimeName::Static | LifetimeName::Param(..) => false, + } + } + + pub fn is_elided(&self) -> bool { + match self { + LifetimeName::ImplicitObjectLifetimeDefault | LifetimeName::Infer => true, + + // It might seem surprising that `Fresh` counts as + // *not* elided -- but this is because, as far as the code + // in the compiler is concerned -- `Fresh` variants act + // equivalently to "some fresh name". They correspond to + // early-bound regions on an impl, in other words. + LifetimeName::Error | LifetimeName::Param(..) | LifetimeName::Static => false, + } + } + + fn is_static(&self) -> bool { + self == &LifetimeName::Static + } + + pub fn normalize_to_macros_2_0(&self) -> LifetimeName { + match *self { + LifetimeName::Param(def_id, param_name) => { + LifetimeName::Param(def_id, param_name.normalize_to_macros_2_0()) + } + lifetime_name => lifetime_name, + } + } +} + +impl fmt::Display for Lifetime { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + self.name.ident().fmt(f) + } +} + +impl Lifetime { + pub fn is_elided(&self) -> bool { + self.name.is_elided() + } + + pub fn is_static(&self) -> bool { + self.name.is_static() + } +} + +/// A `Path` is essentially Rust's notion of a name; for instance, +/// `std::cmp::PartialEq`. It's represented as a sequence of identifiers, +/// along with a bunch of supporting information. +#[derive(Debug, HashStable_Generic)] +pub struct Path<'hir> { + pub span: Span, + /// The resolution for the path. + pub res: Res, + /// The segments in the path: the things separated by `::`. + pub segments: &'hir [PathSegment<'hir>], +} + +impl Path<'_> { + pub fn is_global(&self) -> bool { + !self.segments.is_empty() && self.segments[0].ident.name == kw::PathRoot + } +} + +/// A segment of a path: an identifier, an optional lifetime, and a set of +/// types. +#[derive(Debug, HashStable_Generic)] +pub struct PathSegment<'hir> { + /// The identifier portion of this path segment. + pub ident: Ident, + // `id` and `res` are optional. We currently only use these in save-analysis, + // any path segments without these will not have save-analysis info and + // therefore will not have 'jump to def' in IDEs, but otherwise will not be + // affected. (In general, we don't bother to get the defs for synthesized + // segments, only for segments which have come from the AST). + pub hir_id: Option, + pub res: Option, + + /// Type/lifetime parameters attached to this path. They come in + /// two flavors: `Path` and `Path(A,B) -> C`. Note that + /// this is more than just simple syntactic sugar; the use of + /// parens affects the region binding rules, so we preserve the + /// distinction. + pub args: Option<&'hir GenericArgs<'hir>>, + + /// Whether to infer remaining type parameters, if any. + /// This only applies to expression and pattern paths, and + /// out of those only the segments with no type parameters + /// to begin with, e.g., `Vec::new` is `>::new::<..>`. + pub infer_args: bool, +} + +impl<'hir> PathSegment<'hir> { + /// Converts an identifier to the corresponding segment. + pub fn from_ident(ident: Ident) -> PathSegment<'hir> { + PathSegment { ident, hir_id: None, res: None, infer_args: true, args: None } + } + + pub fn invalid() -> Self { + Self::from_ident(Ident::empty()) + } + + pub fn args(&self) -> &GenericArgs<'hir> { + if let Some(ref args) = self.args { + args + } else { + const DUMMY: &GenericArgs<'_> = &GenericArgs::none(); + DUMMY + } + } +} + +#[derive(Encodable, Debug, HashStable_Generic)] +pub struct ConstArg { + pub value: AnonConst, + pub span: Span, +} + +#[derive(Encodable, Debug, HashStable_Generic)] +pub struct InferArg { + pub hir_id: HirId, + pub span: Span, +} + +impl InferArg { + pub fn to_ty(&self) -> Ty<'_> { + Ty { kind: TyKind::Infer, span: self.span, hir_id: self.hir_id } + } +} + +#[derive(Debug, HashStable_Generic)] +pub enum GenericArg<'hir> { + Lifetime(Lifetime), + Type(Ty<'hir>), + Const(ConstArg), + Infer(InferArg), +} + +impl GenericArg<'_> { + pub fn span(&self) -> Span { + match self { + GenericArg::Lifetime(l) => l.span, + GenericArg::Type(t) => t.span, + GenericArg::Const(c) => c.span, + GenericArg::Infer(i) => i.span, + } + } + + pub fn id(&self) -> HirId { + match self { + GenericArg::Lifetime(l) => l.hir_id, + GenericArg::Type(t) => t.hir_id, + GenericArg::Const(c) => c.value.hir_id, + GenericArg::Infer(i) => i.hir_id, + } + } + + pub fn is_synthetic(&self) -> bool { + matches!(self, GenericArg::Lifetime(lifetime) if lifetime.name.ident() == Ident::empty()) + } + + pub fn descr(&self) -> &'static str { + match self { + GenericArg::Lifetime(_) => "lifetime", + GenericArg::Type(_) => "type", + GenericArg::Const(_) => "constant", + GenericArg::Infer(_) => "inferred", + } + } + + pub fn to_ord(&self) -> ast::ParamKindOrd { + match self { + GenericArg::Lifetime(_) => ast::ParamKindOrd::Lifetime, + GenericArg::Type(_) => ast::ParamKindOrd::Type, + GenericArg::Const(_) => ast::ParamKindOrd::Const, + GenericArg::Infer(_) => ast::ParamKindOrd::Infer, + } + } + + pub fn is_ty_or_const(&self) -> bool { + match self { + GenericArg::Lifetime(_) => false, + GenericArg::Type(_) | GenericArg::Const(_) | GenericArg::Infer(_) => true, + } + } +} + +#[derive(Debug, HashStable_Generic)] +pub struct GenericArgs<'hir> { + /// The generic arguments for this path segment. + pub args: &'hir [GenericArg<'hir>], + /// Bindings (equality constraints) on associated types, if present. + /// E.g., `Foo`. + pub bindings: &'hir [TypeBinding<'hir>], + /// Were arguments written in parenthesized form `Fn(T) -> U`? + /// This is required mostly for pretty-printing and diagnostics, + /// but also for changing lifetime elision rules to be "function-like". + pub parenthesized: bool, + /// The span encompassing arguments and the surrounding brackets `<>` or `()` + /// Foo Fn(T, U, V) -> W + /// ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^ + /// Note that this may be: + /// - empty, if there are no generic brackets (but there may be hidden lifetimes) + /// - dummy, if this was generated while desugaring + pub span_ext: Span, +} + +impl<'hir> GenericArgs<'hir> { + pub const fn none() -> Self { + Self { args: &[], bindings: &[], parenthesized: false, span_ext: DUMMY_SP } + } + + pub fn inputs(&self) -> &[Ty<'hir>] { + if self.parenthesized { + for arg in self.args { + match arg { + GenericArg::Lifetime(_) => {} + GenericArg::Type(ref ty) => { + if let TyKind::Tup(ref tys) = ty.kind { + return tys; + } + break; + } + GenericArg::Const(_) => {} + GenericArg::Infer(_) => {} + } + } + } + panic!("GenericArgs::inputs: not a `Fn(T) -> U`"); + } + + #[inline] + pub fn has_type_params(&self) -> bool { + self.args.iter().any(|arg| matches!(arg, GenericArg::Type(_))) + } + + pub fn has_err(&self) -> bool { + self.args.iter().any(|arg| match arg { + GenericArg::Type(ty) => matches!(ty.kind, TyKind::Err), + _ => false, + }) || self.bindings.iter().any(|arg| match arg.kind { + TypeBindingKind::Equality { term: Term::Ty(ty) } => matches!(ty.kind, TyKind::Err), + _ => false, + }) + } + + #[inline] + pub fn num_type_params(&self) -> usize { + self.args.iter().filter(|arg| matches!(arg, GenericArg::Type(_))).count() + } + + #[inline] + pub fn num_lifetime_params(&self) -> usize { + self.args.iter().filter(|arg| matches!(arg, GenericArg::Lifetime(_))).count() + } + + #[inline] + pub fn has_lifetime_params(&self) -> bool { + self.args.iter().any(|arg| matches!(arg, GenericArg::Lifetime(_))) + } + + #[inline] + pub fn num_generic_params(&self) -> usize { + self.args.iter().filter(|arg| !matches!(arg, GenericArg::Lifetime(_))).count() + } + + /// The span encompassing the text inside the surrounding brackets. + /// It will also include bindings if they aren't in the form `-> Ret` + /// Returns `None` if the span is empty (e.g. no brackets) or dummy + pub fn span(&self) -> Option { + let span_ext = self.span_ext()?; + Some(span_ext.with_lo(span_ext.lo() + BytePos(1)).with_hi(span_ext.hi() - BytePos(1))) + } + + /// Returns span encompassing arguments and their surrounding `<>` or `()` + pub fn span_ext(&self) -> Option { + Some(self.span_ext).filter(|span| !span.is_empty()) + } + + pub fn is_empty(&self) -> bool { + self.args.is_empty() + } +} + +/// A modifier on a bound, currently this is only used for `?Sized`, where the +/// modifier is `Maybe`. Negative bounds should also be handled here. +#[derive(Copy, Clone, PartialEq, Eq, Encodable, Hash, Debug)] +#[derive(HashStable_Generic)] +pub enum TraitBoundModifier { + None, + Maybe, + MaybeConst, +} + +/// The AST represents all type param bounds as types. +/// `typeck::collect::compute_bounds` matches these against +/// the "special" built-in traits (see `middle::lang_items`) and +/// detects `Copy`, `Send` and `Sync`. +#[derive(Clone, Debug, HashStable_Generic)] +pub enum GenericBound<'hir> { + Trait(PolyTraitRef<'hir>, TraitBoundModifier), + // FIXME(davidtwco): Introduce `PolyTraitRef::LangItem` + LangItemTrait(LangItem, Span, HirId, &'hir GenericArgs<'hir>), + Outlives(Lifetime), +} + +impl GenericBound<'_> { + pub fn trait_ref(&self) -> Option<&TraitRef<'_>> { + match self { + GenericBound::Trait(data, _) => Some(&data.trait_ref), + _ => None, + } + } + + pub fn span(&self) -> Span { + match self { + GenericBound::Trait(t, ..) => t.span, + GenericBound::LangItemTrait(_, span, ..) => *span, + GenericBound::Outlives(l) => l.span, + } + } +} + +pub type GenericBounds<'hir> = &'hir [GenericBound<'hir>]; + +#[derive(Copy, Clone, PartialEq, Eq, Encodable, Debug, HashStable_Generic)] +pub enum LifetimeParamKind { + // Indicates that the lifetime definition was explicitly declared (e.g., in + // `fn foo<'a>(x: &'a u8) -> &'a u8 { x }`). + Explicit, + + // Indication that the lifetime was elided (e.g., in both cases in + // `fn foo(x: &u8) -> &'_ u8 { x }`). + Elided, + + // Indication that the lifetime name was somehow in error. + Error, +} + +#[derive(Debug, HashStable_Generic)] +pub enum GenericParamKind<'hir> { + /// A lifetime definition (e.g., `'a: 'b + 'c + 'd`). + Lifetime { + kind: LifetimeParamKind, + }, + Type { + default: Option<&'hir Ty<'hir>>, + synthetic: bool, + }, + Const { + ty: &'hir Ty<'hir>, + /// Optional default value for the const generic param + default: Option, + }, +} + +#[derive(Debug, HashStable_Generic)] +pub struct GenericParam<'hir> { + pub hir_id: HirId, + pub name: ParamName, + pub span: Span, + pub pure_wrt_drop: bool, + pub kind: GenericParamKind<'hir>, + pub colon_span: Option, +} + +impl<'hir> GenericParam<'hir> { + /// Synthetic type-parameters are inserted after normal ones. + /// In order for normal parameters to be able to refer to synthetic ones, + /// scans them first. + pub fn is_impl_trait(&self) -> bool { + matches!(self.kind, GenericParamKind::Type { synthetic: true, .. }) + } + + /// This can happen for `async fn`, e.g. `async fn f<'_>(&'_ self)`. + /// + /// See `lifetime_to_generic_param` in `rustc_ast_lowering` for more information. + pub fn is_elided_lifetime(&self) -> bool { + matches!(self.kind, GenericParamKind::Lifetime { kind: LifetimeParamKind::Elided }) + } +} + +#[derive(Default)] +pub struct GenericParamCount { + pub lifetimes: usize, + pub types: usize, + pub consts: usize, + pub infer: usize, +} + +/// Represents lifetimes and type parameters attached to a declaration +/// of a function, enum, trait, etc. +#[derive(Debug, HashStable_Generic)] +pub struct Generics<'hir> { + pub params: &'hir [GenericParam<'hir>], + pub predicates: &'hir [WherePredicate<'hir>], + pub has_where_clause_predicates: bool, + pub where_clause_span: Span, + pub span: Span, +} + +impl<'hir> Generics<'hir> { + pub const fn empty() -> &'hir Generics<'hir> { + const NOPE: Generics<'_> = Generics { + params: &[], + predicates: &[], + has_where_clause_predicates: false, + where_clause_span: DUMMY_SP, + span: DUMMY_SP, + }; + &NOPE + } + + pub fn get_named(&self, name: Symbol) -> Option<&GenericParam<'hir>> { + for param in self.params { + if name == param.name.ident().name { + return Some(param); + } + } + None + } + + pub fn spans(&self) -> MultiSpan { + if self.params.is_empty() { + self.span.into() + } else { + self.params.iter().map(|p| p.span).collect::>().into() + } + } + + /// If there are generic parameters, return where to introduce a new one. + pub fn span_for_param_suggestion(&self) -> Option { + if self.params.iter().any(|p| self.span.contains(p.span)) { + // `fn foo(t: impl Trait)` + // ^ suggest `, T: Trait` here + let span = self.span.with_lo(self.span.hi() - BytePos(1)).shrink_to_lo(); + Some(span) + } else { + None + } + } + + /// `Span` where further predicates would be suggested, accounting for trailing commas, like + /// in `fn foo(t: T) where T: Foo,` so we don't suggest two trailing commas. + pub fn tail_span_for_predicate_suggestion(&self) -> Span { + let end = self.where_clause_span.shrink_to_hi(); + if self.has_where_clause_predicates { + self.predicates + .iter() + .filter(|p| p.in_where_clause()) + .last() + .map_or(end, |p| p.span()) + .shrink_to_hi() + .to(end) + } else { + end + } + } + + pub fn add_where_or_trailing_comma(&self) -> &'static str { + if self.has_where_clause_predicates { + "," + } else if self.where_clause_span.is_empty() { + " where" + } else { + // No where clause predicates, but we have `where` token + "" + } + } + + pub fn bounds_for_param( + &self, + param_def_id: LocalDefId, + ) -> impl Iterator> { + self.predicates.iter().filter_map(move |pred| match pred { + WherePredicate::BoundPredicate(bp) if bp.is_param_bound(param_def_id.to_def_id()) => { + Some(bp) + } + _ => None, + }) + } + + pub fn outlives_for_param( + &self, + param_def_id: LocalDefId, + ) -> impl Iterator> { + self.predicates.iter().filter_map(move |pred| match pred { + WherePredicate::RegionPredicate(rp) if rp.is_param_bound(param_def_id) => Some(rp), + _ => None, + }) + } + + pub fn bounds_span_for_suggestions(&self, param_def_id: LocalDefId) -> Option { + self.bounds_for_param(param_def_id).flat_map(|bp| bp.bounds.iter().rev()).find_map( + |bound| { + // We include bounds that come from a `#[derive(_)]` but point at the user's code, + // as we use this method to get a span appropriate for suggestions. + let bs = bound.span(); + if bs.can_be_used_for_suggestions() { Some(bs.shrink_to_hi()) } else { None } + }, + ) + } + + pub fn span_for_predicate_removal(&self, pos: usize) -> Span { + let predicate = &self.predicates[pos]; + let span = predicate.span(); + + if !predicate.in_where_clause() { + // + // ^^^^^^^^ + return span; + } + + // We need to find out which comma to remove. + if pos < self.predicates.len() - 1 { + let next_pred = &self.predicates[pos + 1]; + if next_pred.in_where_clause() { + // where T: ?Sized, Foo: Bar, + // ^^^^^^^^^^^ + return span.until(next_pred.span()); + } + } + + if pos > 0 { + let prev_pred = &self.predicates[pos - 1]; + if prev_pred.in_where_clause() { + // where Foo: Bar, T: ?Sized, + // ^^^^^^^^^^^ + return prev_pred.span().shrink_to_hi().to(span); + } + } + + // This is the only predicate in the where clause. + // where T: ?Sized + // ^^^^^^^^^^^^^^^ + self.where_clause_span + } + + pub fn span_for_bound_removal(&self, predicate_pos: usize, bound_pos: usize) -> Span { + let predicate = &self.predicates[predicate_pos]; + let bounds = predicate.bounds(); + + if bounds.len() == 1 { + return self.span_for_predicate_removal(predicate_pos); + } + + let span = bounds[bound_pos].span(); + if bound_pos == 0 { + // where T: ?Sized + Bar, Foo: Bar, + // ^^^^^^^^^ + span.to(bounds[1].span().shrink_to_lo()) + } else { + // where T: Bar + ?Sized, Foo: Bar, + // ^^^^^^^^^ + bounds[bound_pos - 1].span().shrink_to_hi().to(span) + } + } +} + +/// A single predicate in a where-clause. +#[derive(Debug, HashStable_Generic)] +pub enum WherePredicate<'hir> { + /// A type binding (e.g., `for<'c> Foo: Send + Clone + 'c`). + BoundPredicate(WhereBoundPredicate<'hir>), + /// A lifetime predicate (e.g., `'a: 'b + 'c`). + RegionPredicate(WhereRegionPredicate<'hir>), + /// An equality predicate (unsupported). + EqPredicate(WhereEqPredicate<'hir>), +} + +impl<'hir> WherePredicate<'hir> { + pub fn span(&self) -> Span { + match self { + WherePredicate::BoundPredicate(p) => p.span, + WherePredicate::RegionPredicate(p) => p.span, + WherePredicate::EqPredicate(p) => p.span, + } + } + + pub fn in_where_clause(&self) -> bool { + match self { + WherePredicate::BoundPredicate(p) => p.origin == PredicateOrigin::WhereClause, + WherePredicate::RegionPredicate(p) => p.in_where_clause, + WherePredicate::EqPredicate(_) => false, + } + } + + pub fn bounds(&self) -> GenericBounds<'hir> { + match self { + WherePredicate::BoundPredicate(p) => p.bounds, + WherePredicate::RegionPredicate(p) => p.bounds, + WherePredicate::EqPredicate(_) => &[], + } + } +} + +#[derive(Copy, Clone, Debug, HashStable_Generic, PartialEq, Eq)] +pub enum PredicateOrigin { + WhereClause, + GenericParam, + ImplTrait, +} + +/// A type bound (e.g., `for<'c> Foo: Send + Clone + 'c`). +#[derive(Debug, HashStable_Generic)] +pub struct WhereBoundPredicate<'hir> { + pub span: Span, + /// Origin of the predicate. + pub origin: PredicateOrigin, + /// Any generics from a `for` binding. + pub bound_generic_params: &'hir [GenericParam<'hir>], + /// The type being bounded. + pub bounded_ty: &'hir Ty<'hir>, + /// Trait and lifetime bounds (e.g., `Clone + Send + 'static`). + pub bounds: GenericBounds<'hir>, +} + +impl<'hir> WhereBoundPredicate<'hir> { + /// Returns `true` if `param_def_id` matches the `bounded_ty` of this predicate. + pub fn is_param_bound(&self, param_def_id: DefId) -> bool { + self.bounded_ty.as_generic_param().map_or(false, |(def_id, _)| def_id == param_def_id) + } +} + +/// A lifetime predicate (e.g., `'a: 'b + 'c`). +#[derive(Debug, HashStable_Generic)] +pub struct WhereRegionPredicate<'hir> { + pub span: Span, + pub in_where_clause: bool, + pub lifetime: Lifetime, + pub bounds: GenericBounds<'hir>, +} + +impl<'hir> WhereRegionPredicate<'hir> { + /// Returns `true` if `param_def_id` matches the `lifetime` of this predicate. + pub fn is_param_bound(&self, param_def_id: LocalDefId) -> bool { + match self.lifetime.name { + LifetimeName::Param(id, _) => id == param_def_id, + _ => false, + } + } +} + +/// An equality predicate (e.g., `T = int`); currently unsupported. +#[derive(Debug, HashStable_Generic)] +pub struct WhereEqPredicate<'hir> { + pub hir_id: HirId, + pub span: Span, + pub lhs_ty: &'hir Ty<'hir>, + pub rhs_ty: &'hir Ty<'hir>, +} + +/// HIR node coupled with its parent's id in the same HIR owner. +/// +/// The parent is trash when the node is a HIR owner. +#[derive(Clone, Debug)] +pub struct ParentedNode<'tcx> { + pub parent: ItemLocalId, + pub node: Node<'tcx>, +} + +/// Attributes owned by a HIR owner. +#[derive(Debug)] +pub struct AttributeMap<'tcx> { + pub map: SortedMap, + pub hash: Fingerprint, +} + +impl<'tcx> AttributeMap<'tcx> { + pub const EMPTY: &'static AttributeMap<'static> = + &AttributeMap { map: SortedMap::new(), hash: Fingerprint::ZERO }; + + #[inline] + pub fn get(&self, id: ItemLocalId) -> &'tcx [Attribute] { + self.map.get(&id).copied().unwrap_or(&[]) + } +} + +/// Map of all HIR nodes inside the current owner. +/// These nodes are mapped by `ItemLocalId` alongside the index of their parent node. +/// The HIR tree, including bodies, is pre-hashed. +pub struct OwnerNodes<'tcx> { + /// Pre-computed hash of the full HIR. + pub hash_including_bodies: Fingerprint, + /// Pre-computed hash of the item signature, sithout recursing into the body. + pub hash_without_bodies: Fingerprint, + /// Full HIR for the current owner. + // The zeroth node's parent should never be accessed: the owner's parent is computed by the + // hir_owner_parent query. It is set to `ItemLocalId::INVALID` to force an ICE if accidentally + // used. + pub nodes: IndexVec>>, + /// Content of local bodies. + pub bodies: SortedMap>, + /// Non-owning definitions contained in this owner. + pub local_id_to_def_id: SortedMap, +} + +impl<'tcx> OwnerNodes<'tcx> { + pub fn node(&self) -> OwnerNode<'tcx> { + use rustc_index::vec::Idx; + let node = self.nodes[ItemLocalId::new(0)].as_ref().unwrap().node; + let node = node.as_owner().unwrap(); // Indexing must ensure it is an OwnerNode. + node + } +} + +impl fmt::Debug for OwnerNodes<'_> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("OwnerNodes") + .field("node", &self.nodes[ItemLocalId::from_u32(0)]) + .field("bodies", &self.bodies) + .field("local_id_to_def_id", &self.local_id_to_def_id) + .field("hash_without_bodies", &self.hash_without_bodies) + .field("hash_including_bodies", &self.hash_including_bodies) + .finish() + } +} + +/// Full information resulting from lowering an AST node. +#[derive(Debug, HashStable_Generic)] +pub struct OwnerInfo<'hir> { + /// Contents of the HIR. + pub nodes: OwnerNodes<'hir>, + /// Map from each nested owner to its parent's local id. + pub parenting: FxHashMap, + /// Collected attributes of the HIR nodes. + pub attrs: AttributeMap<'hir>, + /// Map indicating what traits are in scope for places where this + /// is relevant; generated by resolve. + pub trait_map: FxHashMap>, +} + +impl<'tcx> OwnerInfo<'tcx> { + #[inline] + pub fn node(&self) -> OwnerNode<'tcx> { + self.nodes.node() + } +} + +#[derive(Copy, Clone, Debug, HashStable_Generic)] +pub enum MaybeOwner { + Owner(T), + NonOwner(HirId), + /// Used as a placeholder for unused LocalDefId. + Phantom, +} + +impl MaybeOwner { + pub fn as_owner(self) -> Option { + match self { + MaybeOwner::Owner(i) => Some(i), + MaybeOwner::NonOwner(_) | MaybeOwner::Phantom => None, + } + } + + pub fn map(self, f: impl FnOnce(T) -> U) -> MaybeOwner { + match self { + MaybeOwner::Owner(i) => MaybeOwner::Owner(f(i)), + MaybeOwner::NonOwner(hir_id) => MaybeOwner::NonOwner(hir_id), + MaybeOwner::Phantom => MaybeOwner::Phantom, + } + } + + pub fn unwrap(self) -> T { + match self { + MaybeOwner::Owner(i) => i, + MaybeOwner::NonOwner(_) | MaybeOwner::Phantom => panic!("Not a HIR owner"), + } + } +} + +/// The top-level data structure that stores the entire contents of +/// the crate currently being compiled. +/// +/// For more details, see the [rustc dev guide]. +/// +/// [rustc dev guide]: https://rustc-dev-guide.rust-lang.org/hir.html +#[derive(Debug)] +pub struct Crate<'hir> { + pub owners: IndexVec>>, + pub hir_hash: Fingerprint, +} + +#[derive(Debug, HashStable_Generic)] +pub struct Closure<'hir> { + pub binder: ClosureBinder, + pub capture_clause: CaptureBy, + pub bound_generic_params: &'hir [GenericParam<'hir>], + pub fn_decl: &'hir FnDecl<'hir>, + pub body: BodyId, + pub fn_decl_span: Span, + pub movability: Option, +} + +/// A block of statements `{ .. }`, which may have a label (in this case the +/// `targeted_by_break` field will be `true`) and may be `unsafe` by means of +/// the `rules` being anything but `DefaultBlock`. +#[derive(Debug, HashStable_Generic)] +pub struct Block<'hir> { + /// Statements in a block. + pub stmts: &'hir [Stmt<'hir>], + /// An expression at the end of the block + /// without a semicolon, if any. + pub expr: Option<&'hir Expr<'hir>>, + #[stable_hasher(ignore)] + pub hir_id: HirId, + /// Distinguishes between `unsafe { ... }` and `{ ... }`. + pub rules: BlockCheckMode, + pub span: Span, + /// If true, then there may exist `break 'a` values that aim to + /// break out of this block early. + /// Used by `'label: {}` blocks and by `try {}` blocks. + pub targeted_by_break: bool, +} + +impl<'hir> Block<'hir> { + pub fn innermost_block(&self) -> &Block<'hir> { + let mut block = self; + while let Some(Expr { kind: ExprKind::Block(inner_block, _), .. }) = block.expr { + block = inner_block; + } + block + } +} + +#[derive(Debug, HashStable_Generic)] +pub struct Pat<'hir> { + #[stable_hasher(ignore)] + pub hir_id: HirId, + pub kind: PatKind<'hir>, + pub span: Span, + // Whether to use default binding modes. + // At present, this is false only for destructuring assignment. + pub default_binding_modes: bool, +} + +impl<'hir> Pat<'hir> { + // FIXME(#19596) this is a workaround, but there should be a better way + fn walk_short_(&self, it: &mut impl FnMut(&Pat<'hir>) -> bool) -> bool { + if !it(self) { + return false; + } + + use PatKind::*; + match self.kind { + Wild | Lit(_) | Range(..) | Binding(.., None) | Path(_) => true, + Box(s) | Ref(s, _) | Binding(.., Some(s)) => s.walk_short_(it), + Struct(_, fields, _) => fields.iter().all(|field| field.pat.walk_short_(it)), + TupleStruct(_, s, _) | Tuple(s, _) | Or(s) => s.iter().all(|p| p.walk_short_(it)), + Slice(before, slice, after) => { + before.iter().chain(slice).chain(after.iter()).all(|p| p.walk_short_(it)) + } + } + } + + /// Walk the pattern in left-to-right order, + /// short circuiting (with `.all(..)`) if `false` is returned. + /// + /// Note that when visiting e.g. `Tuple(ps)`, + /// if visiting `ps[0]` returns `false`, + /// then `ps[1]` will not be visited. + pub fn walk_short(&self, mut it: impl FnMut(&Pat<'hir>) -> bool) -> bool { + self.walk_short_(&mut it) + } + + // FIXME(#19596) this is a workaround, but there should be a better way + fn walk_(&self, it: &mut impl FnMut(&Pat<'hir>) -> bool) { + if !it(self) { + return; + } + + use PatKind::*; + match self.kind { + Wild | Lit(_) | Range(..) | Binding(.., None) | Path(_) => {} + Box(s) | Ref(s, _) | Binding(.., Some(s)) => s.walk_(it), + Struct(_, fields, _) => fields.iter().for_each(|field| field.pat.walk_(it)), + TupleStruct(_, s, _) | Tuple(s, _) | Or(s) => s.iter().for_each(|p| p.walk_(it)), + Slice(before, slice, after) => { + before.iter().chain(slice).chain(after.iter()).for_each(|p| p.walk_(it)) + } + } + } + + /// Walk the pattern in left-to-right order. + /// + /// If `it(pat)` returns `false`, the children are not visited. + pub fn walk(&self, mut it: impl FnMut(&Pat<'hir>) -> bool) { + self.walk_(&mut it) + } + + /// Walk the pattern in left-to-right order. + /// + /// If you always want to recurse, prefer this method over `walk`. + pub fn walk_always(&self, mut it: impl FnMut(&Pat<'_>)) { + self.walk(|p| { + it(p); + true + }) + } +} + +/// A single field in a struct pattern. +/// +/// Patterns like the fields of Foo `{ x, ref y, ref mut z }` +/// are treated the same as` x: x, y: ref y, z: ref mut z`, +/// except `is_shorthand` is true. +#[derive(Debug, HashStable_Generic)] +pub struct PatField<'hir> { + #[stable_hasher(ignore)] + pub hir_id: HirId, + /// The identifier for the field. + pub ident: Ident, + /// The pattern the field is destructured to. + pub pat: &'hir Pat<'hir>, + pub is_shorthand: bool, + pub span: Span, +} + +/// Explicit binding annotations given in the HIR for a binding. Note +/// that this is not the final binding *mode* that we infer after type +/// inference. +#[derive(Copy, Clone, PartialEq, Encodable, Debug, HashStable_Generic)] +pub enum BindingAnnotation { + /// No binding annotation given: this means that the final binding mode + /// will depend on whether we have skipped through a `&` reference + /// when matching. For example, the `x` in `Some(x)` will have binding + /// mode `None`; if you do `let Some(x) = &Some(22)`, it will + /// ultimately be inferred to be by-reference. + /// + /// Note that implicit reference skipping is not implemented yet (#42640). + Unannotated, + + /// Annotated with `mut x` -- could be either ref or not, similar to `None`. + Mutable, + + /// Annotated as `ref`, like `ref x` + Ref, + + /// Annotated as `ref mut x`. + RefMut, +} + +#[derive(Copy, Clone, PartialEq, Encodable, Debug, HashStable_Generic)] +pub enum RangeEnd { + Included, + Excluded, +} + +impl fmt::Display for RangeEnd { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str(match self { + RangeEnd::Included => "..=", + RangeEnd::Excluded => "..", + }) + } +} + +#[derive(Debug, HashStable_Generic)] +pub enum PatKind<'hir> { + /// Represents a wildcard pattern (i.e., `_`). + Wild, + + /// A fresh binding `ref mut binding @ OPT_SUBPATTERN`. + /// The `HirId` is the canonical ID for the variable being bound, + /// (e.g., in `Ok(x) | Err(x)`, both `x` use the same canonical ID), + /// which is the pattern ID of the first `x`. + Binding(BindingAnnotation, HirId, Ident, Option<&'hir Pat<'hir>>), + + /// A struct or struct variant pattern (e.g., `Variant {x, y, ..}`). + /// The `bool` is `true` in the presence of a `..`. + Struct(QPath<'hir>, &'hir [PatField<'hir>], bool), + + /// A tuple struct/variant pattern `Variant(x, y, .., z)`. + /// If the `..` pattern fragment is present, then `Option` denotes its position. + /// `0 <= position <= subpats.len()` + TupleStruct(QPath<'hir>, &'hir [Pat<'hir>], Option), + + /// An or-pattern `A | B | C`. + /// Invariant: `pats.len() >= 2`. + Or(&'hir [Pat<'hir>]), + + /// A path pattern for a unit struct/variant or a (maybe-associated) constant. + Path(QPath<'hir>), + + /// A tuple pattern (e.g., `(a, b)`). + /// If the `..` pattern fragment is present, then `Option` denotes its position. + /// `0 <= position <= subpats.len()` + Tuple(&'hir [Pat<'hir>], Option), + + /// A `box` pattern. + Box(&'hir Pat<'hir>), + + /// A reference pattern (e.g., `&mut (a, b)`). + Ref(&'hir Pat<'hir>, Mutability), + + /// A literal. + Lit(&'hir Expr<'hir>), + + /// A range pattern (e.g., `1..=2` or `1..2`). + Range(Option<&'hir Expr<'hir>>, Option<&'hir Expr<'hir>>, RangeEnd), + + /// A slice pattern, `[before_0, ..., before_n, (slice, after_0, ..., after_n)?]`. + /// + /// Here, `slice` is lowered from the syntax `($binding_mode $ident @)? ..`. + /// If `slice` exists, then `after` can be non-empty. + /// + /// The representation for e.g., `[a, b, .., c, d]` is: + /// ```ignore (illustrative) + /// PatKind::Slice([Binding(a), Binding(b)], Some(Wild), [Binding(c), Binding(d)]) + /// ``` + Slice(&'hir [Pat<'hir>], Option<&'hir Pat<'hir>>, &'hir [Pat<'hir>]), +} + +#[derive(Copy, Clone, PartialEq, Encodable, Debug, HashStable_Generic)] +pub enum BinOpKind { + /// The `+` operator (addition). + Add, + /// The `-` operator (subtraction). + Sub, + /// The `*` operator (multiplication). + Mul, + /// The `/` operator (division). + Div, + /// The `%` operator (modulus). + Rem, + /// The `&&` operator (logical and). + And, + /// The `||` operator (logical or). + Or, + /// The `^` operator (bitwise xor). + BitXor, + /// The `&` operator (bitwise and). + BitAnd, + /// The `|` operator (bitwise or). + BitOr, + /// The `<<` operator (shift left). + Shl, + /// The `>>` operator (shift right). + Shr, + /// The `==` operator (equality). + Eq, + /// The `<` operator (less than). + Lt, + /// The `<=` operator (less than or equal to). + Le, + /// The `!=` operator (not equal to). + Ne, + /// The `>=` operator (greater than or equal to). + Ge, + /// The `>` operator (greater than). + Gt, +} + +impl BinOpKind { + pub fn as_str(self) -> &'static str { + match self { + BinOpKind::Add => "+", + BinOpKind::Sub => "-", + BinOpKind::Mul => "*", + BinOpKind::Div => "/", + BinOpKind::Rem => "%", + BinOpKind::And => "&&", + BinOpKind::Or => "||", + BinOpKind::BitXor => "^", + BinOpKind::BitAnd => "&", + BinOpKind::BitOr => "|", + BinOpKind::Shl => "<<", + BinOpKind::Shr => ">>", + BinOpKind::Eq => "==", + BinOpKind::Lt => "<", + BinOpKind::Le => "<=", + BinOpKind::Ne => "!=", + BinOpKind::Ge => ">=", + BinOpKind::Gt => ">", + } + } + + pub fn is_lazy(self) -> bool { + matches!(self, BinOpKind::And | BinOpKind::Or) + } + + pub fn is_shift(self) -> bool { + matches!(self, BinOpKind::Shl | BinOpKind::Shr) + } + + pub fn is_comparison(self) -> bool { + match self { + BinOpKind::Eq + | BinOpKind::Lt + | BinOpKind::Le + | BinOpKind::Ne + | BinOpKind::Gt + | BinOpKind::Ge => true, + BinOpKind::And + | BinOpKind::Or + | BinOpKind::Add + | BinOpKind::Sub + | BinOpKind::Mul + | BinOpKind::Div + | BinOpKind::Rem + | BinOpKind::BitXor + | BinOpKind::BitAnd + | BinOpKind::BitOr + | BinOpKind::Shl + | BinOpKind::Shr => false, + } + } + + /// Returns `true` if the binary operator takes its arguments by value. + pub fn is_by_value(self) -> bool { + !self.is_comparison() + } +} + +impl Into for BinOpKind { + fn into(self) -> ast::BinOpKind { + match self { + BinOpKind::Add => ast::BinOpKind::Add, + BinOpKind::Sub => ast::BinOpKind::Sub, + BinOpKind::Mul => ast::BinOpKind::Mul, + BinOpKind::Div => ast::BinOpKind::Div, + BinOpKind::Rem => ast::BinOpKind::Rem, + BinOpKind::And => ast::BinOpKind::And, + BinOpKind::Or => ast::BinOpKind::Or, + BinOpKind::BitXor => ast::BinOpKind::BitXor, + BinOpKind::BitAnd => ast::BinOpKind::BitAnd, + BinOpKind::BitOr => ast::BinOpKind::BitOr, + BinOpKind::Shl => ast::BinOpKind::Shl, + BinOpKind::Shr => ast::BinOpKind::Shr, + BinOpKind::Eq => ast::BinOpKind::Eq, + BinOpKind::Lt => ast::BinOpKind::Lt, + BinOpKind::Le => ast::BinOpKind::Le, + BinOpKind::Ne => ast::BinOpKind::Ne, + BinOpKind::Ge => ast::BinOpKind::Ge, + BinOpKind::Gt => ast::BinOpKind::Gt, + } + } +} + +pub type BinOp = Spanned; + +#[derive(Copy, Clone, PartialEq, Encodable, Debug, HashStable_Generic)] +pub enum UnOp { + /// The `*` operator (dereferencing). + Deref, + /// The `!` operator (logical negation). + Not, + /// The `-` operator (negation). + Neg, +} + +impl UnOp { + pub fn as_str(self) -> &'static str { + match self { + 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::Neg | Self::Not) + } +} + +/// A statement. +#[derive(Debug, HashStable_Generic)] +pub struct Stmt<'hir> { + pub hir_id: HirId, + pub kind: StmtKind<'hir>, + pub span: Span, +} + +/// The contents of a statement. +#[derive(Debug, HashStable_Generic)] +pub enum StmtKind<'hir> { + /// A local (`let`) binding. + Local(&'hir Local<'hir>), + + /// An item binding. + Item(ItemId), + + /// An expression without a trailing semi-colon (must have unit type). + Expr(&'hir Expr<'hir>), + + /// An expression with a trailing semi-colon (may have any type). + Semi(&'hir Expr<'hir>), +} + +/// Represents a `let` statement (i.e., `let : = ;`). +#[derive(Debug, HashStable_Generic)] +pub struct Local<'hir> { + pub pat: &'hir Pat<'hir>, + /// Type annotation, if any (otherwise the type will be inferred). + pub ty: Option<&'hir Ty<'hir>>, + /// Initializer expression to set the value, if any. + pub init: Option<&'hir Expr<'hir>>, + /// Else block for a `let...else` binding. + pub els: Option<&'hir Block<'hir>>, + pub hir_id: HirId, + pub span: Span, + /// Can be `ForLoopDesugar` if the `let` statement is part of a `for` loop + /// desugaring. Otherwise will be `Normal`. + pub source: LocalSource, +} + +/// Represents a single arm of a `match` expression, e.g. +/// ` (if ) => `. +#[derive(Debug, HashStable_Generic)] +pub struct Arm<'hir> { + #[stable_hasher(ignore)] + pub hir_id: HirId, + pub span: Span, + /// If this pattern and the optional guard matches, then `body` is evaluated. + pub pat: &'hir Pat<'hir>, + /// Optional guard clause. + pub guard: Option>, + /// The expression the arm evaluates to if this arm matches. + pub body: &'hir Expr<'hir>, +} + +/// Represents a `let [: ] = ` expression (not a Local), occurring in an `if-let` or +/// `let-else`, evaluating to a boolean. Typically the pattern is refutable. +/// +/// In an if-let, imagine it as `if (let = ) { ... }`; in a let-else, it is part of the +/// desugaring to if-let. Only let-else supports the type annotation at present. +#[derive(Debug, HashStable_Generic)] +pub struct Let<'hir> { + pub hir_id: HirId, + pub span: Span, + pub pat: &'hir Pat<'hir>, + pub ty: Option<&'hir Ty<'hir>>, + pub init: &'hir Expr<'hir>, +} + +#[derive(Debug, HashStable_Generic)] +pub enum Guard<'hir> { + If(&'hir Expr<'hir>), + IfLet(&'hir Let<'hir>), +} + +impl<'hir> Guard<'hir> { + /// Returns the body of the guard + /// + /// In other words, returns the e in either of the following: + /// + /// - `if e` + /// - `if let x = e` + pub fn body(&self) -> &'hir Expr<'hir> { + match self { + Guard::If(e) | Guard::IfLet(Let { init: e, .. }) => e, + } + } +} + +#[derive(Debug, HashStable_Generic)] +pub struct ExprField<'hir> { + #[stable_hasher(ignore)] + pub hir_id: HirId, + pub ident: Ident, + pub expr: &'hir Expr<'hir>, + pub span: Span, + pub is_shorthand: bool, +} + +#[derive(Copy, Clone, PartialEq, Encodable, Debug, HashStable_Generic)] +pub enum BlockCheckMode { + DefaultBlock, + UnsafeBlock(UnsafeSource), +} + +#[derive(Copy, Clone, PartialEq, Encodable, Debug, HashStable_Generic)] +pub enum UnsafeSource { + CompilerGenerated, + UserProvided, +} + +#[derive(Copy, Clone, PartialEq, Eq, Encodable, Decodable, Hash, Debug)] +pub struct BodyId { + pub hir_id: HirId, +} + +/// The body of a function, closure, or constant value. In the case of +/// a function, the body contains not only the function body itself +/// (which is an expression), but also the argument patterns, since +/// those are something that the caller doesn't really care about. +/// +/// # Examples +/// +/// ``` +/// fn foo((x, y): (u32, u32)) -> u32 { +/// x + y +/// } +/// ``` +/// +/// Here, the `Body` associated with `foo()` would contain: +/// +/// - an `params` array containing the `(x, y)` pattern +/// - a `value` containing the `x + y` expression (maybe wrapped in a block) +/// - `generator_kind` would be `None` +/// +/// All bodies have an **owner**, which can be accessed via the HIR +/// map using `body_owner_def_id()`. +#[derive(Debug, HashStable_Generic)] +pub struct Body<'hir> { + pub params: &'hir [Param<'hir>], + pub value: Expr<'hir>, + pub generator_kind: Option, +} + +impl<'hir> Body<'hir> { + pub fn id(&self) -> BodyId { + BodyId { hir_id: self.value.hir_id } + } + + pub fn generator_kind(&self) -> Option { + self.generator_kind + } +} + +/// The type of source expression that caused this generator to be created. +#[derive(Clone, PartialEq, PartialOrd, Eq, Hash, Debug, Copy)] +#[derive(HashStable_Generic, Encodable, Decodable)] +pub enum GeneratorKind { + /// An explicit `async` block or the body of an async function. + Async(AsyncGeneratorKind), + + /// A generator literal created via a `yield` inside a closure. + Gen, +} + +impl fmt::Display for GeneratorKind { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + GeneratorKind::Async(k) => fmt::Display::fmt(k, f), + GeneratorKind::Gen => f.write_str("generator"), + } + } +} + +impl GeneratorKind { + pub fn descr(&self) -> &'static str { + match self { + GeneratorKind::Async(ask) => ask.descr(), + GeneratorKind::Gen => "generator", + } + } +} + +/// In the case of a generator created as part of an async construct, +/// which kind of async construct caused it to be created? +/// +/// This helps error messages but is also used to drive coercions in +/// type-checking (see #60424). +#[derive(Clone, PartialEq, PartialOrd, Eq, Hash, Debug, Copy)] +#[derive(HashStable_Generic, Encodable, Decodable)] +pub enum AsyncGeneratorKind { + /// An explicit `async` block written by the user. + Block, + + /// An explicit `async` closure written by the user. + Closure, + + /// The `async` block generated as the body of an async function. + Fn, +} + +impl fmt::Display for AsyncGeneratorKind { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str(match self { + AsyncGeneratorKind::Block => "`async` block", + AsyncGeneratorKind::Closure => "`async` closure body", + AsyncGeneratorKind::Fn => "`async fn` body", + }) + } +} + +impl AsyncGeneratorKind { + pub fn descr(&self) -> &'static str { + match self { + AsyncGeneratorKind::Block => "`async` block", + AsyncGeneratorKind::Closure => "`async` closure body", + AsyncGeneratorKind::Fn => "`async fn` body", + } + } +} + +#[derive(Copy, Clone, Debug)] +pub enum BodyOwnerKind { + /// Functions and methods. + Fn, + + /// Closures + Closure, + + /// Constants and associated constants. + Const, + + /// Initializer of a `static` item. + Static(Mutability), +} + +impl BodyOwnerKind { + pub fn is_fn_or_closure(self) -> bool { + match self { + BodyOwnerKind::Fn | BodyOwnerKind::Closure => true, + BodyOwnerKind::Const | BodyOwnerKind::Static(_) => false, + } + } +} + +/// The kind of an item that requires const-checking. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum ConstContext { + /// A `const fn`. + ConstFn, + + /// A `static` or `static mut`. + Static(Mutability), + + /// A `const`, associated `const`, or other const context. + /// + /// Other contexts include: + /// - Array length expressions + /// - Enum discriminants + /// - Const generics + /// + /// For the most part, other contexts are treated just like a regular `const`, so they are + /// lumped into the same category. + Const, +} + +impl ConstContext { + /// A description of this const context that can appear between backticks in an error message. + /// + /// E.g. `const` or `static mut`. + pub fn keyword_name(self) -> &'static str { + match self { + Self::Const => "const", + Self::Static(Mutability::Not) => "static", + Self::Static(Mutability::Mut) => "static mut", + Self::ConstFn => "const fn", + } + } +} + +/// A colloquial, trivially pluralizable description of this const context for use in error +/// messages. +impl fmt::Display for ConstContext { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match *self { + Self::Const => write!(f, "constant"), + Self::Static(_) => write!(f, "static"), + Self::ConstFn => write!(f, "constant function"), + } + } +} + +// NOTE: `IntoDiagnosticArg` impl for `ConstContext` lives in `rustc_errors` +// due to a cyclical dependency between hir that crate. + +/// A literal. +pub type Lit = Spanned; + +#[derive(Copy, Clone, PartialEq, Eq, Encodable, Debug, HashStable_Generic)] +pub enum ArrayLen { + Infer(HirId, Span), + Body(AnonConst), +} + +impl ArrayLen { + pub fn hir_id(&self) -> HirId { + match self { + &ArrayLen::Infer(hir_id, _) | &ArrayLen::Body(AnonConst { hir_id, body: _ }) => hir_id, + } + } +} + +/// A constant (expression) that's not an item or associated item, +/// but needs its own `DefId` for type-checking, const-eval, etc. +/// These are usually found nested inside types (e.g., array lengths) +/// or expressions (e.g., repeat counts), and also used to define +/// explicit discriminant values for enum variants. +/// +/// You can check if this anon const is a default in a const param +/// `const N: usize = { ... }` with `tcx.hir().opt_const_param_default_param_hir_id(..)` +#[derive(Copy, Clone, PartialEq, Eq, Encodable, Debug, HashStable_Generic)] +pub struct AnonConst { + pub hir_id: HirId, + pub body: BodyId, +} + +/// An expression. +#[derive(Debug)] +pub struct Expr<'hir> { + pub hir_id: HirId, + pub kind: ExprKind<'hir>, + pub span: Span, +} + +impl Expr<'_> { + pub fn precedence(&self) -> ExprPrecedence { + match self.kind { + ExprKind::Box(_) => ExprPrecedence::Box, + ExprKind::ConstBlock(_) => ExprPrecedence::ConstBlock, + ExprKind::Array(_) => ExprPrecedence::Array, + ExprKind::Call(..) => ExprPrecedence::Call, + ExprKind::MethodCall(..) => ExprPrecedence::MethodCall, + ExprKind::Tup(_) => ExprPrecedence::Tup, + ExprKind::Binary(op, ..) => ExprPrecedence::Binary(op.node.into()), + ExprKind::Unary(..) => ExprPrecedence::Unary, + ExprKind::Lit(_) => ExprPrecedence::Lit, + ExprKind::Type(..) | ExprKind::Cast(..) => ExprPrecedence::Cast, + ExprKind::DropTemps(ref expr, ..) => expr.precedence(), + ExprKind::If(..) => ExprPrecedence::If, + ExprKind::Let(..) => ExprPrecedence::Let, + ExprKind::Loop(..) => ExprPrecedence::Loop, + ExprKind::Match(..) => ExprPrecedence::Match, + ExprKind::Closure { .. } => ExprPrecedence::Closure, + ExprKind::Block(..) => ExprPrecedence::Block, + ExprKind::Assign(..) => ExprPrecedence::Assign, + ExprKind::AssignOp(..) => ExprPrecedence::AssignOp, + ExprKind::Field(..) => ExprPrecedence::Field, + ExprKind::Index(..) => ExprPrecedence::Index, + ExprKind::Path(..) => ExprPrecedence::Path, + ExprKind::AddrOf(..) => ExprPrecedence::AddrOf, + ExprKind::Break(..) => ExprPrecedence::Break, + ExprKind::Continue(..) => ExprPrecedence::Continue, + ExprKind::Ret(..) => ExprPrecedence::Ret, + ExprKind::InlineAsm(..) => ExprPrecedence::InlineAsm, + ExprKind::Struct(..) => ExprPrecedence::Struct, + ExprKind::Repeat(..) => ExprPrecedence::Repeat, + ExprKind::Yield(..) => ExprPrecedence::Yield, + ExprKind::Err => ExprPrecedence::Err, + } + } + + // Whether this looks like a place expr, without checking for deref + // adjustments. + // This will return `true` in some potentially surprising cases such as + // `CONSTANT.field`. + pub fn is_syntactic_place_expr(&self) -> bool { + self.is_place_expr(|_| true) + } + + /// Whether this is a place expression. + /// + /// `allow_projections_from` should return `true` if indexing a field or index expression based + /// on the given expression should be considered a place expression. + pub fn is_place_expr(&self, mut allow_projections_from: impl FnMut(&Self) -> bool) -> bool { + match self.kind { + ExprKind::Path(QPath::Resolved(_, ref path)) => { + matches!(path.res, Res::Local(..) | Res::Def(DefKind::Static(_), _) | Res::Err) + } + + // Type ascription inherits its place expression kind from its + // operand. See: + // 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::Deref, _) => true, + + ExprKind::Field(ref base, _) | ExprKind::Index(ref base, _) => { + allow_projections_from(base) || base.is_place_expr(allow_projections_from) + } + + // Lang item paths cannot currently be local variables or statics. + ExprKind::Path(QPath::LangItem(..)) => false, + + // Partially qualified paths in expressions can only legally + // refer to associated items which are always rvalues. + ExprKind::Path(QPath::TypeRelative(..)) + | ExprKind::Call(..) + | ExprKind::MethodCall(..) + | ExprKind::Struct(..) + | ExprKind::Tup(..) + | ExprKind::If(..) + | ExprKind::Match(..) + | ExprKind::Closure { .. } + | ExprKind::Block(..) + | ExprKind::Repeat(..) + | ExprKind::Array(..) + | ExprKind::Break(..) + | ExprKind::Continue(..) + | ExprKind::Ret(..) + | ExprKind::Let(..) + | ExprKind::Loop(..) + | ExprKind::Assign(..) + | ExprKind::InlineAsm(..) + | ExprKind::AssignOp(..) + | ExprKind::Lit(_) + | ExprKind::ConstBlock(..) + | ExprKind::Unary(..) + | ExprKind::Box(..) + | ExprKind::AddrOf(..) + | ExprKind::Binary(..) + | ExprKind::Yield(..) + | ExprKind::Cast(..) + | ExprKind::DropTemps(..) + | ExprKind::Err => false, + } + } + + /// If `Self.kind` is `ExprKind::DropTemps(expr)`, drill down until we get a non-`DropTemps` + /// `Expr`. This is used in suggestions to ignore this `ExprKind` as it is semantically + /// silent, only signaling the ownership system. By doing this, suggestions that check the + /// `ExprKind` of any given `Expr` for presentation don't have to care about `DropTemps` + /// beyond remembering to call this function before doing analysis on it. + pub fn peel_drop_temps(&self) -> &Self { + let mut expr = self; + while let ExprKind::DropTemps(inner) = &expr.kind { + expr = inner; + } + expr + } + + pub fn peel_blocks(&self) -> &Self { + let mut expr = self; + while let ExprKind::Block(Block { expr: Some(inner), .. }, _) = &expr.kind { + expr = inner; + } + expr + } + + pub fn can_have_side_effects(&self) -> bool { + match self.peel_drop_temps().kind { + ExprKind::Path(_) | ExprKind::Lit(_) => false, + ExprKind::Type(base, _) + | ExprKind::Unary(_, base) + | ExprKind::Field(base, _) + | ExprKind::Index(base, _) + | ExprKind::AddrOf(.., base) + | ExprKind::Cast(base, _) => { + // This isn't exactly true for `Index` and all `Unary`, but we are using this + // method exclusively for diagnostics and there's a *cultural* pressure against + // them being used only for its side-effects. + base.can_have_side_effects() + } + ExprKind::Struct(_, fields, init) => fields + .iter() + .map(|field| field.expr) + .chain(init.into_iter()) + .all(|e| e.can_have_side_effects()), + + ExprKind::Array(args) + | ExprKind::Tup(args) + | ExprKind::Call( + Expr { + kind: + ExprKind::Path(QPath::Resolved( + None, + Path { res: Res::Def(DefKind::Ctor(_, CtorKind::Fn), _), .. }, + )), + .. + }, + args, + ) => args.iter().all(|arg| arg.can_have_side_effects()), + ExprKind::If(..) + | ExprKind::Match(..) + | ExprKind::MethodCall(..) + | ExprKind::Call(..) + | ExprKind::Closure { .. } + | ExprKind::Block(..) + | ExprKind::Repeat(..) + | ExprKind::Break(..) + | ExprKind::Continue(..) + | ExprKind::Ret(..) + | ExprKind::Let(..) + | ExprKind::Loop(..) + | ExprKind::Assign(..) + | ExprKind::InlineAsm(..) + | ExprKind::AssignOp(..) + | ExprKind::ConstBlock(..) + | ExprKind::Box(..) + | ExprKind::Binary(..) + | ExprKind::Yield(..) + | ExprKind::DropTemps(..) + | ExprKind::Err => true, + } + } + + // To a first-order approximation, is this a pattern + pub fn is_approximately_pattern(&self) -> bool { + match &self.kind { + ExprKind::Box(_) + | ExprKind::Array(_) + | ExprKind::Call(..) + | ExprKind::Tup(_) + | ExprKind::Lit(_) + | ExprKind::Path(_) + | ExprKind::Struct(..) => true, + _ => false, + } + } + + pub fn method_ident(&self) -> Option { + match self.kind { + ExprKind::MethodCall(receiver_method, ..) => Some(receiver_method.ident), + ExprKind::Unary(_, expr) | ExprKind::AddrOf(.., expr) => expr.method_ident(), + _ => None, + } + } +} + +/// Checks if the specified expression is a built-in range literal. +/// (See: `LoweringContext::lower_expr()`). +pub fn is_range_literal(expr: &Expr<'_>) -> bool { + match expr.kind { + // All built-in range literals but `..=` and `..` desugar to `Struct`s. + ExprKind::Struct(ref qpath, _, _) => matches!( + **qpath, + QPath::LangItem( + LangItem::Range + | LangItem::RangeTo + | LangItem::RangeFrom + | LangItem::RangeFull + | LangItem::RangeToInclusive, + .. + ) + ), + + // `..=` desugars into `::std::ops::RangeInclusive::new(...)`. + ExprKind::Call(ref func, _) => { + matches!(func.kind, ExprKind::Path(QPath::LangItem(LangItem::RangeInclusiveNew, ..))) + } + + _ => false, + } +} + +#[derive(Debug, HashStable_Generic)] +pub enum ExprKind<'hir> { + /// A `box x` expression. + Box(&'hir Expr<'hir>), + /// Allow anonymous constants from an inline `const` block + ConstBlock(AnonConst), + /// An array (e.g., `[a, b, c, d]`). + Array(&'hir [Expr<'hir>]), + /// A function call. + /// + /// The first field resolves to the function itself (usually an `ExprKind::Path`), + /// and the second field is the list of arguments. + /// This also represents calling the constructor of + /// tuple-like ADTs such as tuple structs and enum variants. + Call(&'hir Expr<'hir>, &'hir [Expr<'hir>]), + /// A method call (e.g., `x.foo::<'static, Bar, Baz>(a, b, c, d)`). + /// + /// The `PathSegment` represents the method name and its generic arguments + /// (within the angle brackets). + /// The first element of the `&[Expr]` is the expression that evaluates + /// to the object on which the method is being called on (the receiver), + /// and the remaining elements are the rest of the arguments. + /// Thus, `x.foo::(a, b, c, d)` is represented as + /// `ExprKind::MethodCall(PathSegment { foo, [Bar, Baz] }, [x, a, b, c, d], span)`. + /// The final `Span` represents the span of the function and arguments + /// (e.g. `foo::(a, b, c, d)` in `x.foo::(a, b, c, d)` + /// + /// To resolve the called method to a `DefId`, call [`type_dependent_def_id`] with + /// the `hir_id` of the `MethodCall` node itself. + /// + /// [`type_dependent_def_id`]: ../../rustc_middle/ty/struct.TypeckResults.html#method.type_dependent_def_id + MethodCall(&'hir PathSegment<'hir>, &'hir [Expr<'hir>], Span), + /// A tuple (e.g., `(a, b, c, d)`). + Tup(&'hir [Expr<'hir>]), + /// A binary operation (e.g., `a + b`, `a * b`). + Binary(BinOp, &'hir Expr<'hir>, &'hir Expr<'hir>), + /// A unary operation (e.g., `!x`, `*x`). + Unary(UnOp, &'hir Expr<'hir>), + /// A literal (e.g., `1`, `"foo"`). + Lit(Lit), + /// A cast (e.g., `foo as f64`). + Cast(&'hir Expr<'hir>, &'hir Ty<'hir>), + /// A type reference (e.g., `Foo`). + Type(&'hir Expr<'hir>, &'hir Ty<'hir>), + /// Wraps the expression in a terminating scope. + /// This makes it semantically equivalent to `{ let _t = expr; _t }`. + /// + /// This construct only exists to tweak the drop order in HIR lowering. + /// An example of that is the desugaring of `for` loops. + DropTemps(&'hir Expr<'hir>), + /// A `let $pat = $expr` expression. + /// + /// These are not `Local` and only occur as expressions. + /// The `let Some(x) = foo()` in `if let Some(x) = foo()` is an example of `Let(..)`. + Let(&'hir Let<'hir>), + /// An `if` block, with an optional else block. + /// + /// I.e., `if { } else { }`. + If(&'hir Expr<'hir>, &'hir Expr<'hir>, Option<&'hir Expr<'hir>>), + /// A conditionless loop (can be exited with `break`, `continue`, or `return`). + /// + /// I.e., `'label: loop { }`. + /// + /// The `Span` is the loop header (`for x in y`/`while let pat = expr`). + Loop(&'hir Block<'hir>, Option, D}`. + Enum(EnumDef<'hir>, &'hir Generics<'hir>), + /// A struct definition, e.g., `struct Foo {x: A}`. + Struct(VariantData<'hir>, &'hir Generics<'hir>), + /// A union definition, e.g., `union Foo {x: A, y: B}`. + Union(VariantData<'hir>, &'hir Generics<'hir>), + /// A trait definition. + Trait(IsAuto, Unsafety, &'hir Generics<'hir>, GenericBounds<'hir>, &'hir [TraitItemRef]), + /// A trait alias. + TraitAlias(&'hir Generics<'hir>, GenericBounds<'hir>), + + /// An implementation, e.g., `impl Trait for Foo { .. }`. + Impl(&'hir Impl<'hir>), +} + +#[derive(Debug, HashStable_Generic)] +pub struct Impl<'hir> { + pub unsafety: Unsafety, + pub polarity: ImplPolarity, + pub defaultness: Defaultness, + // We do not put a `Span` in `Defaultness` because it breaks foreign crate metadata + // decoding as `Span`s cannot be decoded when a `Session` is not available. + pub defaultness_span: Option, + pub constness: Constness, + pub generics: &'hir Generics<'hir>, + + /// The trait being implemented, if any. + pub of_trait: Option>, + + pub self_ty: &'hir Ty<'hir>, + pub items: &'hir [ImplItemRef], +} + +impl ItemKind<'_> { + pub fn generics(&self) -> Option<&Generics<'_>> { + Some(match *self { + ItemKind::Fn(_, ref generics, _) + | ItemKind::TyAlias(_, ref generics) + | ItemKind::OpaqueTy(OpaqueTy { ref generics, .. }) + | ItemKind::Enum(_, ref generics) + | ItemKind::Struct(_, ref generics) + | ItemKind::Union(_, ref generics) + | ItemKind::Trait(_, _, ref generics, _, _) + | ItemKind::TraitAlias(ref generics, _) + | ItemKind::Impl(Impl { ref generics, .. }) => generics, + _ => return None, + }) + } + + pub fn descr(&self) -> &'static str { + match self { + ItemKind::ExternCrate(..) => "extern crate", + ItemKind::Use(..) => "`use` import", + ItemKind::Static(..) => "static item", + ItemKind::Const(..) => "constant item", + ItemKind::Fn(..) => "function", + ItemKind::Macro(..) => "macro", + ItemKind::Mod(..) => "module", + ItemKind::ForeignMod { .. } => "extern block", + ItemKind::GlobalAsm(..) => "global asm item", + ItemKind::TyAlias(..) => "type alias", + ItemKind::OpaqueTy(..) => "opaque type", + ItemKind::Enum(..) => "enum", + ItemKind::Struct(..) => "struct", + ItemKind::Union(..) => "union", + ItemKind::Trait(..) => "trait", + ItemKind::TraitAlias(..) => "trait alias", + ItemKind::Impl(..) => "implementation", + } + } +} + +/// A reference from an trait to one of its associated items. This +/// contains the item's id, naturally, but also the item's name and +/// some other high-level details (like whether it is an associated +/// type or method, and whether it is public). This allows other +/// passes to find the impl they want without loading the ID (which +/// means fewer edges in the incremental compilation graph). +#[derive(Encodable, Debug, HashStable_Generic)] +pub struct TraitItemRef { + pub id: TraitItemId, + pub ident: Ident, + pub kind: AssocItemKind, + pub span: Span, +} + +/// A reference from an impl to one of its associated items. This +/// contains the item's ID, naturally, but also the item's name and +/// some other high-level details (like whether it is an associated +/// type or method, and whether it is public). This allows other +/// passes to find the impl they want without loading the ID (which +/// means fewer edges in the incremental compilation graph). +#[derive(Debug, HashStable_Generic)] +pub struct ImplItemRef { + pub id: ImplItemId, + pub ident: Ident, + pub kind: AssocItemKind, + pub span: Span, + /// When we are in a trait impl, link to the trait-item's id. + pub trait_item_def_id: Option, +} + +#[derive(Copy, Clone, PartialEq, Encodable, Debug, HashStable_Generic)] +pub enum AssocItemKind { + Const, + Fn { has_self: bool }, + Type, +} + +// 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, PartialEq, Eq, Encodable, Decodable, Debug, HashStable_Generic)] +pub struct ForeignItemId { + pub def_id: LocalDefId, +} + +impl ForeignItemId { + #[inline] + 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 +/// contains the item's ID, naturally, but also the item's name and +/// some other high-level details (like whether it is an associated +/// type or method, and whether it is public). This allows other +/// passes to find the impl they want without loading the ID (which +/// means fewer edges in the incremental compilation graph). +#[derive(Debug, HashStable_Generic)] +pub struct ForeignItemRef { + pub id: ForeignItemId, + pub ident: Ident, + pub span: Span, +} + +#[derive(Debug, HashStable_Generic)] +pub struct ForeignItem<'hir> { + pub ident: Ident, + pub kind: ForeignItemKind<'hir>, + pub def_id: LocalDefId, + pub span: Span, + pub vis_span: Span, +} + +impl ForeignItem<'_> { + #[inline] + 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> { + /// A foreign function. + Fn(&'hir FnDecl<'hir>, &'hir [Ident], &'hir Generics<'hir>), + /// A foreign static item (`static ext: u8`). + Static(&'hir Ty<'hir>, Mutability), + /// A foreign type. + Type, +} + +/// A variable captured by a closure. +#[derive(Debug, Copy, Clone, Encodable, HashStable_Generic)] +pub struct Upvar { + // First span where it is accessed (there can be multiple). + pub span: Span, +} + +// The TraitCandidate's import_ids is empty if the trait is defined in the same module, and +// has length > 0 if the trait is found through an chain of imports, starting with the +// import/use statement in the scope where the trait is used. +#[derive(Encodable, Decodable, Clone, Debug, HashStable_Generic)] +pub struct TraitCandidate { + pub def_id: DefId, + pub import_ids: SmallVec<[LocalDefId; 1]>, +} + +#[derive(Copy, Clone, Debug, HashStable_Generic)] +pub enum OwnerNode<'hir> { + Item(&'hir Item<'hir>), + ForeignItem(&'hir ForeignItem<'hir>), + TraitItem(&'hir TraitItem<'hir>), + ImplItem(&'hir ImplItem<'hir>), + Crate(&'hir Mod<'hir>), +} + +impl<'hir> OwnerNode<'hir> { + pub fn ident(&self) -> Option { + match self { + OwnerNode::Item(Item { ident, .. }) + | OwnerNode::ForeignItem(ForeignItem { ident, .. }) + | OwnerNode::ImplItem(ImplItem { ident, .. }) + | OwnerNode::TraitItem(TraitItem { ident, .. }) => Some(*ident), + OwnerNode::Crate(..) => None, + } + } + + pub fn span(&self) -> Span { + match self { + OwnerNode::Item(Item { span, .. }) + | OwnerNode::ForeignItem(ForeignItem { span, .. }) + | OwnerNode::ImplItem(ImplItem { span, .. }) + | OwnerNode::TraitItem(TraitItem { span, .. }) => *span, + OwnerNode::Crate(Mod { spans: ModSpans { inner_span, .. }, .. }) => *inner_span, + } + } + + pub fn fn_decl(&self) -> Option<&FnDecl<'hir>> { + match self { + OwnerNode::TraitItem(TraitItem { kind: TraitItemKind::Fn(fn_sig, _), .. }) + | OwnerNode::ImplItem(ImplItem { kind: ImplItemKind::Fn(fn_sig, _), .. }) + | OwnerNode::Item(Item { kind: ItemKind::Fn(fn_sig, _, _), .. }) => Some(fn_sig.decl), + OwnerNode::ForeignItem(ForeignItem { + kind: ForeignItemKind::Fn(fn_decl, _, _), + .. + }) => Some(fn_decl), + _ => None, + } + } + + pub fn body_id(&self) -> Option { + match self { + OwnerNode::TraitItem(TraitItem { + kind: TraitItemKind::Fn(_, TraitFn::Provided(body_id)), + .. + }) + | OwnerNode::ImplItem(ImplItem { kind: ImplItemKind::Fn(_, body_id), .. }) + | OwnerNode::Item(Item { kind: ItemKind::Fn(.., body_id), .. }) => Some(*body_id), + _ => None, + } + } + + pub fn generics(self) -> Option<&'hir Generics<'hir>> { + Node::generics(self.into()) + } + + pub fn def_id(self) -> LocalDefId { + match self { + OwnerNode::Item(Item { def_id, .. }) + | OwnerNode::TraitItem(TraitItem { def_id, .. }) + | OwnerNode::ImplItem(ImplItem { def_id, .. }) + | OwnerNode::ForeignItem(ForeignItem { def_id, .. }) => *def_id, + OwnerNode::Crate(..) => crate::CRATE_HIR_ID.owner, + } + } + + pub fn expect_item(self) -> &'hir Item<'hir> { + match self { + OwnerNode::Item(n) => n, + _ => panic!(), + } + } + + pub fn expect_foreign_item(self) -> &'hir ForeignItem<'hir> { + match self { + OwnerNode::ForeignItem(n) => n, + _ => panic!(), + } + } + + pub fn expect_impl_item(self) -> &'hir ImplItem<'hir> { + match self { + OwnerNode::ImplItem(n) => n, + _ => panic!(), + } + } + + pub fn expect_trait_item(self) -> &'hir TraitItem<'hir> { + match self { + OwnerNode::TraitItem(n) => n, + _ => panic!(), + } + } +} + +impl<'hir> Into> for &'hir Item<'hir> { + fn into(self) -> OwnerNode<'hir> { + OwnerNode::Item(self) + } +} + +impl<'hir> Into> for &'hir ForeignItem<'hir> { + fn into(self) -> OwnerNode<'hir> { + OwnerNode::ForeignItem(self) + } +} + +impl<'hir> Into> for &'hir ImplItem<'hir> { + fn into(self) -> OwnerNode<'hir> { + OwnerNode::ImplItem(self) + } +} + +impl<'hir> Into> for &'hir TraitItem<'hir> { + fn into(self) -> OwnerNode<'hir> { + OwnerNode::TraitItem(self) + } +} + +impl<'hir> Into> for OwnerNode<'hir> { + fn into(self) -> Node<'hir> { + match self { + OwnerNode::Item(n) => Node::Item(n), + OwnerNode::ForeignItem(n) => Node::ForeignItem(n), + OwnerNode::ImplItem(n) => Node::ImplItem(n), + OwnerNode::TraitItem(n) => Node::TraitItem(n), + OwnerNode::Crate(n) => Node::Crate(n), + } + } +} + +#[derive(Copy, Clone, Debug, HashStable_Generic)] +pub enum Node<'hir> { + Param(&'hir Param<'hir>), + Item(&'hir Item<'hir>), + ForeignItem(&'hir ForeignItem<'hir>), + TraitItem(&'hir TraitItem<'hir>), + ImplItem(&'hir ImplItem<'hir>), + Variant(&'hir Variant<'hir>), + Field(&'hir FieldDef<'hir>), + AnonConst(&'hir AnonConst), + Expr(&'hir Expr<'hir>), + Stmt(&'hir Stmt<'hir>), + PathSegment(&'hir PathSegment<'hir>), + Ty(&'hir Ty<'hir>), + TypeBinding(&'hir TypeBinding<'hir>), + TraitRef(&'hir TraitRef<'hir>), + Pat(&'hir Pat<'hir>), + Arm(&'hir Arm<'hir>), + Block(&'hir Block<'hir>), + Local(&'hir Local<'hir>), + + /// `Ctor` refers to the constructor of an enum variant or struct. Only tuple or unit variants + /// with synthesized constructors. + Ctor(&'hir VariantData<'hir>), + + Lifetime(&'hir Lifetime), + GenericParam(&'hir GenericParam<'hir>), + + Crate(&'hir Mod<'hir>), + + Infer(&'hir InferArg), +} + +impl<'hir> Node<'hir> { + /// Get the identifier of this `Node`, if applicable. + /// + /// # Edge cases + /// + /// Calling `.ident()` on a [`Node::Ctor`] will return `None` + /// because `Ctor`s do not have identifiers themselves. + /// Instead, call `.ident()` on the parent struct/variant, like so: + /// + /// ```ignore (illustrative) + /// ctor + /// .ctor_hir_id() + /// .and_then(|ctor_id| tcx.hir().find(tcx.hir().get_parent_node(ctor_id))) + /// .and_then(|parent| parent.ident()) + /// ``` + pub fn ident(&self) -> Option { + match self { + Node::TraitItem(TraitItem { ident, .. }) + | Node::ImplItem(ImplItem { ident, .. }) + | Node::ForeignItem(ForeignItem { ident, .. }) + | Node::Field(FieldDef { ident, .. }) + | Node::Variant(Variant { ident, .. }) + | Node::Item(Item { ident, .. }) + | Node::PathSegment(PathSegment { ident, .. }) => Some(*ident), + Node::Lifetime(lt) => Some(lt.name.ident()), + Node::GenericParam(p) => Some(p.name.ident()), + Node::TypeBinding(b) => Some(b.ident), + Node::Param(..) + | Node::AnonConst(..) + | Node::Expr(..) + | Node::Stmt(..) + | Node::Block(..) + | Node::Ctor(..) + | Node::Pat(..) + | Node::Arm(..) + | Node::Local(..) + | Node::Crate(..) + | Node::Ty(..) + | Node::TraitRef(..) + | Node::Infer(..) => None, + } + } + + pub fn fn_decl(&self) -> Option<&'hir FnDecl<'hir>> { + match self { + Node::TraitItem(TraitItem { kind: TraitItemKind::Fn(fn_sig, _), .. }) + | Node::ImplItem(ImplItem { kind: ImplItemKind::Fn(fn_sig, _), .. }) + | Node::Item(Item { kind: ItemKind::Fn(fn_sig, _, _), .. }) => Some(fn_sig.decl), + Node::ForeignItem(ForeignItem { kind: ForeignItemKind::Fn(fn_decl, _, _), .. }) => { + Some(fn_decl) + } + _ => None, + } + } + + pub fn fn_sig(&self) -> Option<&'hir FnSig<'hir>> { + match self { + Node::TraitItem(TraitItem { kind: TraitItemKind::Fn(fn_sig, _), .. }) + | Node::ImplItem(ImplItem { kind: ImplItemKind::Fn(fn_sig, _), .. }) + | Node::Item(Item { kind: ItemKind::Fn(fn_sig, _, _), .. }) => Some(fn_sig), + _ => None, + } + } + + pub fn body_id(&self) -> Option { + match self { + Node::TraitItem(TraitItem { + kind: TraitItemKind::Fn(_, TraitFn::Provided(body_id)), + .. + }) + | Node::ImplItem(ImplItem { kind: ImplItemKind::Fn(_, body_id), .. }) + | Node::Item(Item { kind: ItemKind::Fn(.., body_id), .. }) => Some(*body_id), + _ => None, + } + } + + pub fn generics(self) -> Option<&'hir Generics<'hir>> { + match self { + Node::ForeignItem(ForeignItem { + kind: ForeignItemKind::Fn(_, _, generics), .. + }) + | Node::TraitItem(TraitItem { generics, .. }) + | Node::ImplItem(ImplItem { generics, .. }) => Some(generics), + Node::Item(item) => item.kind.generics(), + _ => None, + } + } + + pub fn as_owner(self) -> Option> { + match self { + Node::Item(i) => Some(OwnerNode::Item(i)), + Node::ForeignItem(i) => Some(OwnerNode::ForeignItem(i)), + Node::TraitItem(i) => Some(OwnerNode::TraitItem(i)), + Node::ImplItem(i) => Some(OwnerNode::ImplItem(i)), + Node::Crate(i) => Some(OwnerNode::Crate(i)), + _ => None, + } + } + + pub fn fn_kind(self) -> Option> { + match self { + Node::Item(i) => match i.kind { + ItemKind::Fn(ref sig, ref generics, _) => { + Some(FnKind::ItemFn(i.ident, generics, sig.header)) + } + _ => None, + }, + Node::TraitItem(ti) => match ti.kind { + TraitItemKind::Fn(ref sig, TraitFn::Provided(_)) => { + Some(FnKind::Method(ti.ident, sig)) + } + _ => None, + }, + Node::ImplItem(ii) => match ii.kind { + ImplItemKind::Fn(ref sig, _) => Some(FnKind::Method(ii.ident, sig)), + _ => None, + }, + Node::Expr(e) => match e.kind { + ExprKind::Closure { .. } => Some(FnKind::Closure), + _ => None, + }, + _ => None, + } + } + + /// Get the fields for the tuple-constructor, + /// if this node is a tuple constructor, otherwise None + pub fn tuple_fields(&self) -> Option<&'hir [FieldDef<'hir>]> { + if let Node::Ctor(&VariantData::Tuple(fields, _)) = self { Some(fields) } else { None } + } +} + +// Some nodes are used a lot. Make sure they don't unintentionally get bigger. +#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))] +mod size_asserts { + use super::*; + // These are in alphabetical order, which is easy to maintain. + rustc_data_structures::static_assert_size!(Block<'static>, 48); + rustc_data_structures::static_assert_size!(Expr<'static>, 56); + rustc_data_structures::static_assert_size!(ForeignItem<'static>, 72); + rustc_data_structures::static_assert_size!(GenericBound<'_>, 48); + rustc_data_structures::static_assert_size!(Generics<'static>, 56); + rustc_data_structures::static_assert_size!(ImplItem<'static>, 88); + rustc_data_structures::static_assert_size!(Impl<'static>, 80); + rustc_data_structures::static_assert_size!(Item<'static>, 80); + rustc_data_structures::static_assert_size!(Pat<'static>, 88); + rustc_data_structures::static_assert_size!(QPath<'static>, 24); + rustc_data_structures::static_assert_size!(TraitItem<'static>, 96); + rustc_data_structures::static_assert_size!(Ty<'static>, 72); +} diff --git a/compiler/rustc_hir/src/hir_id.rs b/compiler/rustc_hir/src/hir_id.rs new file mode 100644 index 000000000..346ac9e96 --- /dev/null +++ b/compiler/rustc_hir/src/hir_id.rs @@ -0,0 +1,89 @@ +use crate::def_id::{LocalDefId, CRATE_DEF_ID}; +use std::fmt; + +/// Uniquely identifies a node in the HIR of the current crate. It is +/// composed of the `owner`, which is the `LocalDefId` of the directly enclosing +/// `hir::Item`, `hir::TraitItem`, or `hir::ImplItem` (i.e., the closest "item-like"), +/// and the `local_id` which is unique within the given owner. +/// +/// This two-level structure makes for more stable values: One can move an item +/// around within the source code, or add or remove stuff before it, without +/// the `local_id` part of the `HirId` changing, which is a very useful property in +/// incremental compilation where we have to persist things through changes to +/// the code base. +#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)] +#[derive(Encodable, Decodable, HashStable_Generic)] +#[rustc_pass_by_value] +pub struct HirId { + pub owner: LocalDefId, + pub local_id: ItemLocalId, +} + +impl HirId { + #[inline] + pub fn expect_owner(self) -> LocalDefId { + assert_eq!(self.local_id.index(), 0); + self.owner + } + + #[inline] + pub fn as_owner(self) -> Option { + if self.local_id.index() == 0 { Some(self.owner) } else { None } + } + + #[inline] + pub fn is_owner(self) -> bool { + self.local_id.index() == 0 + } + + #[inline] + pub fn make_owner(owner: LocalDefId) -> Self { + Self { owner, local_id: ItemLocalId::from_u32(0) } + } + + pub fn index(self) -> (usize, usize) { + (rustc_index::vec::Idx::index(self.owner), rustc_index::vec::Idx::index(self.local_id)) + } +} + +impl fmt::Display for HirId { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{:?}", self) + } +} + +impl Ord for HirId { + fn cmp(&self, other: &Self) -> std::cmp::Ordering { + (self.index()).cmp(&(other.index())) + } +} + +impl PartialOrd for HirId { + fn partial_cmp(&self, other: &Self) -> Option { + Some(self.cmp(&other)) + } +} + +rustc_data_structures::define_id_collections!(HirIdMap, HirIdSet, HirId); +rustc_data_structures::define_id_collections!(ItemLocalMap, ItemLocalSet, ItemLocalId); + +rustc_index::newtype_index! { + /// An `ItemLocalId` uniquely identifies something within a given "item-like"; + /// that is, within a `hir::Item`, `hir::TraitItem`, or `hir::ImplItem`. There is no + /// guarantee that the numerical value of a given `ItemLocalId` corresponds to + /// the node's position within the owning item in any way, but there is a + /// guarantee that the `LocalItemId`s within an owner occupy a dense range of + /// integers starting at zero, so a mapping that maps all or most nodes within + /// an "item-like" to something else can be implemented by a `Vec` instead of a + /// tree or hash map. + #[derive(HashStable_Generic)] + pub struct ItemLocalId { .. } +} + +impl ItemLocalId { + /// Signal local id which should never be used. + pub const INVALID: ItemLocalId = ItemLocalId::MAX; +} + +/// The `HirId` corresponding to `CRATE_NODE_ID` and `CRATE_DEF_ID`. +pub const CRATE_HIR_ID: HirId = HirId { owner: CRATE_DEF_ID, local_id: ItemLocalId::from_u32(0) }; diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs new file mode 100644 index 000000000..e676acebe --- /dev/null +++ b/compiler/rustc_hir/src/intravisit.rs @@ -0,0 +1,1232 @@ +//! HIR walker for walking the contents of nodes. +//! +//! Here are the three available patterns for the visitor strategy, +//! in roughly the order of desirability: +//! +//! 1. **Shallow visit**: Get a simple callback for every item (or item-like thing) in the HIR. +//! - Example: find all items with a `#[foo]` attribute on them. +//! - How: Use the `hir_crate_items` or `hir_module_items` query to traverse over item-like ids +//! (ItemId, TraitItemId, etc.) and use tcx.def_kind and `tcx.hir().item*(id)` to filter and +//! access actual item-like thing, respectively. +//! - Pro: Efficient; just walks the lists of item ids and gives users control whether to access +//! the hir_owners themselves or not. +//! - Con: Don't get information about nesting +//! - Con: Don't have methods for specific bits of HIR, like "on +//! every expr, do this". +//! 2. **Deep visit**: Want to scan for specific kinds of HIR nodes within +//! an item, but don't care about how item-like things are nested +//! within one another. +//! - Example: Examine each expression to look for its type and do some check or other. +//! - How: Implement `intravisit::Visitor` and override the `NestedFilter` type to +//! `nested_filter::OnlyBodies` (and implement `nested_visit_map`), and use +//! `tcx.hir().visit_all_item_likes_in_crate(&mut visitor)`. Within your +//! `intravisit::Visitor` impl, implement methods like `visit_expr()` (don't forget to invoke +//! `intravisit::walk_expr()` to keep walking the subparts). +//! - Pro: Visitor methods for any kind of HIR node, not just item-like things. +//! - Pro: Integrates well into dependency tracking. +//! - Con: Don't get information about nesting between items +//! 3. **Nested visit**: Want to visit the whole HIR and you care about the nesting between +//! item-like things. +//! - Example: Lifetime resolution, which wants to bring lifetimes declared on the +//! impl into scope while visiting the impl-items, and then back out again. +//! - How: Implement `intravisit::Visitor` and override the `NestedFilter` type to +//! `nested_filter::All` (and implement `nested_visit_map`). Walk your crate with +//! `tcx.hir().walk_toplevel_module(visitor)` invoked on `tcx.hir().krate()`. +//! - Pro: Visitor methods for any kind of HIR node, not just item-like things. +//! - Pro: Preserves nesting information +//! - Con: Does not integrate well into dependency tracking. +//! +//! If you have decided to use this visitor, here are some general +//! notes on how to do so: +//! +//! Each overridden visit method has full control over what +//! happens with its node, it can do its own traversal of the node's children, +//! call `intravisit::walk_*` to apply the default traversal algorithm, or prevent +//! deeper traversal by doing nothing. +//! +//! When visiting the HIR, the contents of nested items are NOT visited +//! by default. This is different from the AST visitor, which does a deep walk. +//! Hence this module is called `intravisit`; see the method `visit_nested_item` +//! for more details. +//! +//! Note: it is an important invariant that the default visitor walks +//! the body of a function in "execution order" - more concretely, if +//! we consider the reverse post-order (RPO) of the CFG implied by the HIR, +//! then a pre-order traversal of the HIR is consistent with the CFG RPO +//! on the *initial CFG point* of each HIR node, while a post-order traversal +//! of the HIR is consistent with the CFG RPO on each *final CFG point* of +//! each CFG node. +//! +//! One thing that follows is that if HIR node A always starts/ends executing +//! before HIR node B, then A appears in traversal pre/postorder before B, +//! respectively. (This follows from RPO respecting CFG domination). +//! +//! This order consistency is required in a few places in rustc, for +//! example generator inference, and possibly also HIR borrowck. + +use crate::hir::*; +use rustc_ast::walk_list; +use rustc_ast::{Attribute, Label}; +use rustc_span::symbol::{Ident, Symbol}; +use rustc_span::Span; + +pub trait IntoVisitor<'hir> { + type Visitor: Visitor<'hir>; + fn into_visitor(&self) -> Self::Visitor; +} + +#[derive(Copy, Clone, Debug)] +pub enum FnKind<'a> { + /// `#[xxx] pub async/const/extern "Abi" fn foo()` + ItemFn(Ident, &'a Generics<'a>, FnHeader), + + /// `fn foo(&self)` + Method(Ident, &'a FnSig<'a>), + + /// `|x, y| {}` + Closure, +} + +impl<'a> FnKind<'a> { + pub fn header(&self) -> Option<&FnHeader> { + match *self { + FnKind::ItemFn(_, _, ref header) => Some(header), + FnKind::Method(_, ref sig) => Some(&sig.header), + FnKind::Closure => None, + } + } + + pub fn constness(self) -> Constness { + self.header().map_or(Constness::NotConst, |header| header.constness) + } + + pub fn asyncness(self) -> IsAsync { + self.header().map_or(IsAsync::NotAsync, |header| header.asyncness) + } +} + +/// An abstract representation of the HIR `rustc_middle::hir::map::Map`. +pub trait Map<'hir> { + /// Retrieves the `Node` corresponding to `id`, returning `None` if cannot be found. + fn find(&self, hir_id: HirId) -> Option>; + fn body(&self, id: BodyId) -> &'hir Body<'hir>; + fn item(&self, id: ItemId) -> &'hir Item<'hir>; + fn trait_item(&self, id: TraitItemId) -> &'hir TraitItem<'hir>; + fn impl_item(&self, id: ImplItemId) -> &'hir ImplItem<'hir>; + fn foreign_item(&self, id: ForeignItemId) -> &'hir ForeignItem<'hir>; +} + +// Used when no map is actually available, forcing manual implementation of nested visitors. +impl<'hir> Map<'hir> for ! { + fn find(&self, _: HirId) -> Option> { + *self; + } + fn body(&self, _: BodyId) -> &'hir Body<'hir> { + *self; + } + fn item(&self, _: ItemId) -> &'hir Item<'hir> { + *self; + } + fn trait_item(&self, _: TraitItemId) -> &'hir TraitItem<'hir> { + *self; + } + fn impl_item(&self, _: ImplItemId) -> &'hir ImplItem<'hir> { + *self; + } + fn foreign_item(&self, _: ForeignItemId) -> &'hir ForeignItem<'hir> { + *self; + } +} + +pub mod nested_filter { + use super::Map; + + /// Specifies what nested things a visitor wants to visit. By "nested + /// things", we are referring to bits of HIR that are not directly embedded + /// within one another but rather indirectly, through a table in the crate. + /// This is done to control dependencies during incremental compilation: the + /// non-inline bits of HIR can be tracked and hashed separately. + /// + /// The most common choice is `OnlyBodies`, which will cause the visitor to + /// visit fn bodies for fns that it encounters, and closure bodies, but + /// skip over nested item-like things. + /// + /// See the comments on `ItemLikeVisitor` for more details on the overall + /// visit strategy. + pub trait NestedFilter<'hir> { + type Map: Map<'hir>; + + /// Whether the visitor visits nested "item-like" things. + /// E.g., item, impl-item. + const INTER: bool; + /// Whether the visitor visits "intra item-like" things. + /// E.g., function body, closure, `AnonConst` + const INTRA: bool; + } + + /// Do not visit any nested things. When you add a new + /// "non-nested" thing, you will want to audit such uses to see if + /// they remain valid. + /// + /// Use this if you are only walking some particular kind of tree + /// (i.e., a type, or fn signature) and you don't want to thread a + /// HIR map around. + pub struct None(()); + impl NestedFilter<'_> for None { + type Map = !; + const INTER: bool = false; + const INTRA: bool = false; + } +} + +use nested_filter::NestedFilter; + +/// Each method of the Visitor trait is a hook to be potentially +/// overridden. Each method's default implementation recursively visits +/// the substructure of the input via the corresponding `walk` method; +/// e.g., the `visit_mod` method by default calls `intravisit::walk_mod`. +/// +/// Note that this visitor does NOT visit nested items by default +/// (this is why the module is called `intravisit`, to distinguish it +/// from the AST's `visit` module, which acts differently). If you +/// simply want to visit all items in the crate in some order, you +/// should call `tcx.hir().visit_all_item_likes_in_crate`. Otherwise, see the comment +/// on `visit_nested_item` for details on how to visit nested items. +/// +/// If you want to ensure that your code handles every variant +/// explicitly, you need to override each method. (And you also need +/// to monitor future changes to `Visitor` in case a new method with a +/// new default implementation gets introduced.) +pub trait Visitor<'v>: Sized { + // this type should not be overridden, it exists for convenient usage as `Self::Map` + type Map: Map<'v> = >::Map; + + /////////////////////////////////////////////////////////////////////////// + // Nested items. + + /// Override this type to control which nested HIR are visited; see + /// [`NestedFilter`] for details. If you override this type, you + /// must also override [`nested_visit_map`](Self::nested_visit_map). + /// + /// **If for some reason you want the nested behavior, but don't + /// have a `Map` at your disposal:** then override the + /// `visit_nested_XXX` methods. If a new `visit_nested_XXX` variant is + /// added in the future, it will cause a panic which can be detected + /// and fixed appropriately. + type NestedFilter: NestedFilter<'v> = nested_filter::None; + + /// If `type NestedFilter` is set to visit nested items, this method + /// must also be overridden to provide a map to retrieve nested items. + fn nested_visit_map(&mut self) -> Self::Map { + panic!( + "nested_visit_map must be implemented or consider using \ + `type NestedFilter = nested_filter::None` (the default)" + ); + } + + /// Invoked when a nested item is encountered. By default, when + /// `Self::NestedFilter` is `nested_filter::None`, this method does + /// nothing. **You probably don't want to override this method** -- + /// instead, override [`Self::NestedFilter`] or use the "shallow" or + /// "deep" visit patterns described on + /// `itemlikevisit::ItemLikeVisitor`. The only reason to override + /// this method is if you want a nested pattern but cannot supply a + /// [`Map`]; see `nested_visit_map` for advice. + fn visit_nested_item(&mut self, id: ItemId) { + if Self::NestedFilter::INTER { + let item = self.nested_visit_map().item(id); + self.visit_item(item); + } + } + + /// Like `visit_nested_item()`, but for trait items. See + /// `visit_nested_item()` for advice on when to override this + /// method. + fn visit_nested_trait_item(&mut self, id: TraitItemId) { + if Self::NestedFilter::INTER { + let item = self.nested_visit_map().trait_item(id); + self.visit_trait_item(item); + } + } + + /// Like `visit_nested_item()`, but for impl items. See + /// `visit_nested_item()` for advice on when to override this + /// method. + fn visit_nested_impl_item(&mut self, id: ImplItemId) { + if Self::NestedFilter::INTER { + let item = self.nested_visit_map().impl_item(id); + self.visit_impl_item(item); + } + } + + /// Like `visit_nested_item()`, but for foreign items. See + /// `visit_nested_item()` for advice on when to override this + /// method. + fn visit_nested_foreign_item(&mut self, id: ForeignItemId) { + if Self::NestedFilter::INTER { + let item = self.nested_visit_map().foreign_item(id); + self.visit_foreign_item(item); + } + } + + /// Invoked to visit the body of a function, method or closure. Like + /// `visit_nested_item`, does nothing by default unless you override + /// `Self::NestedFilter`. + fn visit_nested_body(&mut self, id: BodyId) { + if Self::NestedFilter::INTRA { + let body = self.nested_visit_map().body(id); + self.visit_body(body); + } + } + + fn visit_param(&mut self, param: &'v Param<'v>) { + walk_param(self, param) + } + + /// Visits the top-level item and (optionally) nested items / impl items. See + /// `visit_nested_item` for details. + fn visit_item(&mut self, i: &'v Item<'v>) { + walk_item(self, i) + } + + fn visit_body(&mut self, b: &'v Body<'v>) { + walk_body(self, b); + } + + /////////////////////////////////////////////////////////////////////////// + + fn visit_id(&mut self, _hir_id: HirId) { + // Nothing to do. + } + fn visit_name(&mut self, _span: Span, _name: Symbol) { + // Nothing to do. + } + fn visit_ident(&mut self, ident: Ident) { + walk_ident(self, ident) + } + fn visit_mod(&mut self, m: &'v Mod<'v>, _s: Span, n: HirId) { + walk_mod(self, m, n) + } + fn visit_foreign_item(&mut self, i: &'v ForeignItem<'v>) { + walk_foreign_item(self, i) + } + fn visit_local(&mut self, l: &'v Local<'v>) { + walk_local(self, l) + } + fn visit_block(&mut self, b: &'v Block<'v>) { + walk_block(self, b) + } + fn visit_stmt(&mut self, s: &'v Stmt<'v>) { + walk_stmt(self, s) + } + fn visit_arm(&mut self, a: &'v Arm<'v>) { + walk_arm(self, a) + } + fn visit_pat(&mut self, p: &'v Pat<'v>) { + walk_pat(self, p) + } + fn visit_array_length(&mut self, len: &'v ArrayLen) { + walk_array_len(self, len) + } + fn visit_anon_const(&mut self, c: &'v AnonConst) { + walk_anon_const(self, c) + } + fn visit_expr(&mut self, ex: &'v Expr<'v>) { + walk_expr(self, ex) + } + fn visit_let_expr(&mut self, lex: &'v Let<'v>) { + walk_let_expr(self, lex) + } + fn visit_ty(&mut self, t: &'v Ty<'v>) { + walk_ty(self, t) + } + fn visit_generic_param(&mut self, p: &'v GenericParam<'v>) { + walk_generic_param(self, p) + } + fn visit_const_param_default(&mut self, _param: HirId, ct: &'v AnonConst) { + walk_const_param_default(self, ct) + } + fn visit_generics(&mut self, g: &'v Generics<'v>) { + walk_generics(self, g) + } + fn visit_where_predicate(&mut self, predicate: &'v WherePredicate<'v>) { + walk_where_predicate(self, predicate) + } + fn visit_fn_decl(&mut self, fd: &'v FnDecl<'v>) { + walk_fn_decl(self, fd) + } + fn visit_fn(&mut self, fk: FnKind<'v>, fd: &'v FnDecl<'v>, b: BodyId, s: Span, id: HirId) { + walk_fn(self, fk, fd, b, s, id) + } + fn visit_use(&mut self, path: &'v Path<'v>, hir_id: HirId) { + walk_use(self, path, hir_id) + } + fn visit_trait_item(&mut self, ti: &'v TraitItem<'v>) { + walk_trait_item(self, ti) + } + fn visit_trait_item_ref(&mut self, ii: &'v TraitItemRef) { + walk_trait_item_ref(self, ii) + } + fn visit_impl_item(&mut self, ii: &'v ImplItem<'v>) { + walk_impl_item(self, ii) + } + fn visit_foreign_item_ref(&mut self, ii: &'v ForeignItemRef) { + walk_foreign_item_ref(self, ii) + } + fn visit_impl_item_ref(&mut self, ii: &'v ImplItemRef) { + walk_impl_item_ref(self, ii) + } + fn visit_trait_ref(&mut self, t: &'v TraitRef<'v>) { + walk_trait_ref(self, t) + } + fn visit_param_bound(&mut self, bounds: &'v GenericBound<'v>) { + walk_param_bound(self, bounds) + } + fn visit_poly_trait_ref(&mut self, t: &'v PolyTraitRef<'v>, m: TraitBoundModifier) { + walk_poly_trait_ref(self, t, m) + } + fn visit_variant_data( + &mut self, + s: &'v VariantData<'v>, + _: Symbol, + _: &'v Generics<'v>, + _parent_id: HirId, + _: Span, + ) { + walk_struct_def(self, s) + } + fn visit_field_def(&mut self, s: &'v FieldDef<'v>) { + walk_field_def(self, s) + } + fn visit_enum_def( + &mut self, + enum_definition: &'v EnumDef<'v>, + generics: &'v Generics<'v>, + item_id: HirId, + _: Span, + ) { + walk_enum_def(self, enum_definition, generics, item_id) + } + fn visit_variant(&mut self, v: &'v Variant<'v>, g: &'v Generics<'v>, item_id: HirId) { + walk_variant(self, v, g, item_id) + } + fn visit_label(&mut self, label: &'v Label) { + walk_label(self, label) + } + fn visit_infer(&mut self, inf: &'v InferArg) { + walk_inf(self, inf); + } + fn visit_generic_arg(&mut self, generic_arg: &'v GenericArg<'v>) { + match generic_arg { + GenericArg::Lifetime(lt) => self.visit_lifetime(lt), + GenericArg::Type(ty) => self.visit_ty(ty), + GenericArg::Const(ct) => self.visit_anon_const(&ct.value), + GenericArg::Infer(inf) => self.visit_infer(inf), + } + } + fn visit_lifetime(&mut self, lifetime: &'v Lifetime) { + walk_lifetime(self, lifetime) + } + fn visit_qpath(&mut self, qpath: &'v QPath<'v>, id: HirId, span: Span) { + walk_qpath(self, qpath, id, span) + } + fn visit_path(&mut self, path: &'v Path<'v>, _id: HirId) { + walk_path(self, path) + } + fn visit_path_segment(&mut self, path_span: Span, path_segment: &'v PathSegment<'v>) { + walk_path_segment(self, path_span, path_segment) + } + fn visit_generic_args(&mut self, path_span: Span, generic_args: &'v GenericArgs<'v>) { + walk_generic_args(self, path_span, generic_args) + } + fn visit_assoc_type_binding(&mut self, type_binding: &'v TypeBinding<'v>) { + walk_assoc_type_binding(self, type_binding) + } + fn visit_attribute(&mut self, _attr: &'v Attribute) {} + fn visit_associated_item_kind(&mut self, kind: &'v AssocItemKind) { + walk_associated_item_kind(self, kind); + } + fn visit_defaultness(&mut self, defaultness: &'v Defaultness) { + walk_defaultness(self, defaultness); + } + fn visit_inline_asm(&mut self, asm: &'v InlineAsm<'v>, id: HirId) { + walk_inline_asm(self, asm, id); + } +} + +pub fn walk_mod<'v, V: Visitor<'v>>(visitor: &mut V, module: &'v Mod<'v>, mod_hir_id: HirId) { + visitor.visit_id(mod_hir_id); + for &item_id in module.item_ids { + visitor.visit_nested_item(item_id); + } +} + +pub fn walk_body<'v, V: Visitor<'v>>(visitor: &mut V, body: &'v Body<'v>) { + walk_list!(visitor, visit_param, body.params); + visitor.visit_expr(&body.value); +} + +pub fn walk_local<'v, V: Visitor<'v>>(visitor: &mut V, local: &'v Local<'v>) { + // Intentionally visiting the expr first - the initialization expr + // dominates the local's definition. + walk_list!(visitor, visit_expr, &local.init); + visitor.visit_id(local.hir_id); + visitor.visit_pat(&local.pat); + if let Some(els) = local.els { + visitor.visit_block(els); + } + walk_list!(visitor, visit_ty, &local.ty); +} + +pub fn walk_ident<'v, V: Visitor<'v>>(visitor: &mut V, ident: Ident) { + visitor.visit_name(ident.span, ident.name); +} + +pub fn walk_label<'v, V: Visitor<'v>>(visitor: &mut V, label: &'v Label) { + visitor.visit_ident(label.ident); +} + +pub fn walk_lifetime<'v, V: Visitor<'v>>(visitor: &mut V, lifetime: &'v Lifetime) { + visitor.visit_id(lifetime.hir_id); + match lifetime.name { + LifetimeName::Param(_, ParamName::Plain(ident)) => { + visitor.visit_ident(ident); + } + LifetimeName::Param(_, ParamName::Fresh) + | LifetimeName::Param(_, ParamName::Error) + | LifetimeName::Static + | LifetimeName::Error + | LifetimeName::ImplicitObjectLifetimeDefault + | LifetimeName::Infer => {} + } +} + +pub fn walk_poly_trait_ref<'v, V: Visitor<'v>>( + visitor: &mut V, + trait_ref: &'v PolyTraitRef<'v>, + _modifier: TraitBoundModifier, +) { + walk_list!(visitor, visit_generic_param, trait_ref.bound_generic_params); + visitor.visit_trait_ref(&trait_ref.trait_ref); +} + +pub fn walk_trait_ref<'v, V: Visitor<'v>>(visitor: &mut V, trait_ref: &'v TraitRef<'v>) { + visitor.visit_id(trait_ref.hir_ref_id); + visitor.visit_path(&trait_ref.path, trait_ref.hir_ref_id) +} + +pub fn walk_param<'v, V: Visitor<'v>>(visitor: &mut V, param: &'v Param<'v>) { + visitor.visit_id(param.hir_id); + visitor.visit_pat(¶m.pat); +} + +pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item<'v>) { + visitor.visit_ident(item.ident); + match item.kind { + ItemKind::ExternCrate(orig_name) => { + visitor.visit_id(item.hir_id()); + if let Some(orig_name) = orig_name { + visitor.visit_name(item.span, orig_name); + } + } + ItemKind::Use(ref path, _) => { + visitor.visit_use(path, item.hir_id()); + } + ItemKind::Static(ref typ, _, body) | ItemKind::Const(ref typ, body) => { + visitor.visit_id(item.hir_id()); + visitor.visit_ty(typ); + visitor.visit_nested_body(body); + } + ItemKind::Fn(ref sig, ref generics, body_id) => visitor.visit_fn( + FnKind::ItemFn(item.ident, generics, sig.header), + &sig.decl, + body_id, + item.span, + item.hir_id(), + ), + ItemKind::Macro(..) => { + visitor.visit_id(item.hir_id()); + } + ItemKind::Mod(ref module) => { + // `visit_mod()` takes care of visiting the `Item`'s `HirId`. + visitor.visit_mod(module, item.span, item.hir_id()) + } + ItemKind::ForeignMod { abi: _, items } => { + visitor.visit_id(item.hir_id()); + walk_list!(visitor, visit_foreign_item_ref, items); + } + ItemKind::GlobalAsm(asm) => { + visitor.visit_id(item.hir_id()); + visitor.visit_inline_asm(asm, item.hir_id()); + } + ItemKind::TyAlias(ref ty, ref generics) => { + visitor.visit_id(item.hir_id()); + visitor.visit_ty(ty); + visitor.visit_generics(generics) + } + ItemKind::OpaqueTy(OpaqueTy { ref generics, bounds, .. }) => { + visitor.visit_id(item.hir_id()); + walk_generics(visitor, generics); + walk_list!(visitor, visit_param_bound, bounds); + } + ItemKind::Enum(ref enum_definition, ref generics) => { + visitor.visit_generics(generics); + // `visit_enum_def()` takes care of visiting the `Item`'s `HirId`. + visitor.visit_enum_def(enum_definition, generics, item.hir_id(), item.span) + } + ItemKind::Impl(Impl { + unsafety: _, + defaultness: _, + polarity: _, + constness: _, + defaultness_span: _, + ref generics, + ref of_trait, + ref self_ty, + items, + }) => { + visitor.visit_id(item.hir_id()); + visitor.visit_generics(generics); + walk_list!(visitor, visit_trait_ref, of_trait); + visitor.visit_ty(self_ty); + walk_list!(visitor, visit_impl_item_ref, *items); + } + ItemKind::Struct(ref struct_definition, ref generics) + | ItemKind::Union(ref struct_definition, ref generics) => { + visitor.visit_generics(generics); + visitor.visit_id(item.hir_id()); + visitor.visit_variant_data( + struct_definition, + item.ident.name, + generics, + item.hir_id(), + item.span, + ); + } + ItemKind::Trait(.., ref generics, bounds, trait_item_refs) => { + visitor.visit_id(item.hir_id()); + visitor.visit_generics(generics); + walk_list!(visitor, visit_param_bound, bounds); + walk_list!(visitor, visit_trait_item_ref, trait_item_refs); + } + ItemKind::TraitAlias(ref generics, bounds) => { + visitor.visit_id(item.hir_id()); + visitor.visit_generics(generics); + walk_list!(visitor, visit_param_bound, bounds); + } + } +} + +pub fn walk_inline_asm<'v, V: Visitor<'v>>(visitor: &mut V, asm: &'v InlineAsm<'v>, id: HirId) { + for (op, op_sp) in asm.operands { + match op { + InlineAsmOperand::In { expr, .. } | InlineAsmOperand::InOut { expr, .. } => { + visitor.visit_expr(expr) + } + InlineAsmOperand::Out { expr, .. } => { + if let Some(expr) = expr { + visitor.visit_expr(expr); + } + } + InlineAsmOperand::SplitInOut { in_expr, out_expr, .. } => { + visitor.visit_expr(in_expr); + if let Some(out_expr) = out_expr { + visitor.visit_expr(out_expr); + } + } + InlineAsmOperand::Const { anon_const, .. } + | InlineAsmOperand::SymFn { anon_const, .. } => visitor.visit_anon_const(anon_const), + InlineAsmOperand::SymStatic { path, .. } => visitor.visit_qpath(path, id, *op_sp), + } + } +} + +pub fn walk_use<'v, V: Visitor<'v>>(visitor: &mut V, path: &'v Path<'v>, hir_id: HirId) { + visitor.visit_id(hir_id); + visitor.visit_path(path, hir_id); +} + +pub fn walk_enum_def<'v, V: Visitor<'v>>( + visitor: &mut V, + enum_definition: &'v EnumDef<'v>, + generics: &'v Generics<'v>, + item_id: HirId, +) { + visitor.visit_id(item_id); + walk_list!(visitor, visit_variant, enum_definition.variants, generics, item_id); +} + +pub fn walk_variant<'v, V: Visitor<'v>>( + visitor: &mut V, + variant: &'v Variant<'v>, + generics: &'v Generics<'v>, + parent_item_id: HirId, +) { + visitor.visit_ident(variant.ident); + visitor.visit_id(variant.id); + visitor.visit_variant_data( + &variant.data, + variant.ident.name, + generics, + parent_item_id, + variant.span, + ); + walk_list!(visitor, visit_anon_const, &variant.disr_expr); +} + +pub fn walk_ty<'v, V: Visitor<'v>>(visitor: &mut V, typ: &'v Ty<'v>) { + visitor.visit_id(typ.hir_id); + + match typ.kind { + TyKind::Slice(ref ty) => visitor.visit_ty(ty), + TyKind::Ptr(ref mutable_type) => visitor.visit_ty(&mutable_type.ty), + TyKind::Rptr(ref lifetime, ref mutable_type) => { + visitor.visit_lifetime(lifetime); + visitor.visit_ty(&mutable_type.ty) + } + TyKind::Never => {} + TyKind::Tup(tuple_element_types) => { + walk_list!(visitor, visit_ty, tuple_element_types); + } + TyKind::BareFn(ref function_declaration) => { + walk_list!(visitor, visit_generic_param, function_declaration.generic_params); + visitor.visit_fn_decl(&function_declaration.decl); + } + TyKind::Path(ref qpath) => { + visitor.visit_qpath(qpath, typ.hir_id, typ.span); + } + TyKind::OpaqueDef(item_id, lifetimes) => { + visitor.visit_nested_item(item_id); + walk_list!(visitor, visit_generic_arg, lifetimes); + } + TyKind::Array(ref ty, ref length) => { + visitor.visit_ty(ty); + visitor.visit_array_length(length) + } + TyKind::TraitObject(bounds, ref lifetime, _syntax) => { + for bound in bounds { + visitor.visit_poly_trait_ref(bound, TraitBoundModifier::None); + } + visitor.visit_lifetime(lifetime); + } + TyKind::Typeof(ref expression) => visitor.visit_anon_const(expression), + TyKind::Infer | TyKind::Err => {} + } +} + +pub fn walk_inf<'v, V: Visitor<'v>>(visitor: &mut V, inf: &'v InferArg) { + visitor.visit_id(inf.hir_id); +} + +pub fn walk_qpath<'v, V: Visitor<'v>>( + visitor: &mut V, + qpath: &'v QPath<'v>, + id: HirId, + span: Span, +) { + match *qpath { + QPath::Resolved(ref maybe_qself, ref path) => { + walk_list!(visitor, visit_ty, maybe_qself); + visitor.visit_path(path, id) + } + QPath::TypeRelative(ref qself, ref segment) => { + visitor.visit_ty(qself); + visitor.visit_path_segment(span, segment); + } + QPath::LangItem(..) => {} + } +} + +pub fn walk_path<'v, V: Visitor<'v>>(visitor: &mut V, path: &'v Path<'v>) { + for segment in path.segments { + visitor.visit_path_segment(path.span, segment); + } +} + +pub fn walk_path_segment<'v, V: Visitor<'v>>( + visitor: &mut V, + path_span: Span, + segment: &'v PathSegment<'v>, +) { + visitor.visit_ident(segment.ident); + walk_list!(visitor, visit_id, segment.hir_id); + if let Some(ref args) = segment.args { + visitor.visit_generic_args(path_span, args); + } +} + +pub fn walk_generic_args<'v, V: Visitor<'v>>( + visitor: &mut V, + _path_span: Span, + generic_args: &'v GenericArgs<'v>, +) { + walk_list!(visitor, visit_generic_arg, generic_args.args); + walk_list!(visitor, visit_assoc_type_binding, generic_args.bindings); +} + +pub fn walk_assoc_type_binding<'v, V: Visitor<'v>>( + visitor: &mut V, + type_binding: &'v TypeBinding<'v>, +) { + visitor.visit_id(type_binding.hir_id); + visitor.visit_ident(type_binding.ident); + visitor.visit_generic_args(type_binding.span, type_binding.gen_args); + match type_binding.kind { + TypeBindingKind::Equality { ref term } => match term { + Term::Ty(ref ty) => visitor.visit_ty(ty), + Term::Const(ref c) => visitor.visit_anon_const(c), + }, + TypeBindingKind::Constraint { bounds } => walk_list!(visitor, visit_param_bound, bounds), + } +} + +pub fn walk_pat<'v, V: Visitor<'v>>(visitor: &mut V, pattern: &'v Pat<'v>) { + visitor.visit_id(pattern.hir_id); + match pattern.kind { + PatKind::TupleStruct(ref qpath, children, _) => { + visitor.visit_qpath(qpath, pattern.hir_id, pattern.span); + walk_list!(visitor, visit_pat, children); + } + PatKind::Path(ref qpath) => { + visitor.visit_qpath(qpath, pattern.hir_id, pattern.span); + } + PatKind::Struct(ref qpath, fields, _) => { + visitor.visit_qpath(qpath, pattern.hir_id, pattern.span); + for field in fields { + visitor.visit_id(field.hir_id); + visitor.visit_ident(field.ident); + visitor.visit_pat(&field.pat) + } + } + PatKind::Or(pats) => walk_list!(visitor, visit_pat, pats), + PatKind::Tuple(tuple_elements, _) => { + walk_list!(visitor, visit_pat, tuple_elements); + } + PatKind::Box(ref subpattern) | PatKind::Ref(ref subpattern, _) => { + visitor.visit_pat(subpattern) + } + PatKind::Binding(_, _hir_id, ident, ref optional_subpattern) => { + visitor.visit_ident(ident); + walk_list!(visitor, visit_pat, optional_subpattern); + } + PatKind::Lit(ref expression) => visitor.visit_expr(expression), + PatKind::Range(ref lower_bound, ref upper_bound, _) => { + walk_list!(visitor, visit_expr, lower_bound); + walk_list!(visitor, visit_expr, upper_bound); + } + PatKind::Wild => (), + PatKind::Slice(prepatterns, ref slice_pattern, postpatterns) => { + walk_list!(visitor, visit_pat, prepatterns); + walk_list!(visitor, visit_pat, slice_pattern); + walk_list!(visitor, visit_pat, postpatterns); + } + } +} + +pub fn walk_foreign_item<'v, V: Visitor<'v>>(visitor: &mut V, foreign_item: &'v ForeignItem<'v>) { + visitor.visit_id(foreign_item.hir_id()); + visitor.visit_ident(foreign_item.ident); + + match foreign_item.kind { + ForeignItemKind::Fn(ref function_declaration, param_names, ref generics) => { + visitor.visit_generics(generics); + visitor.visit_fn_decl(function_declaration); + for ¶m_name in param_names { + visitor.visit_ident(param_name); + } + } + ForeignItemKind::Static(ref typ, _) => visitor.visit_ty(typ), + ForeignItemKind::Type => (), + } +} + +pub fn walk_param_bound<'v, V: Visitor<'v>>(visitor: &mut V, bound: &'v GenericBound<'v>) { + match *bound { + GenericBound::Trait(ref typ, modifier) => { + visitor.visit_poly_trait_ref(typ, modifier); + } + GenericBound::LangItemTrait(_, span, hir_id, args) => { + visitor.visit_id(hir_id); + visitor.visit_generic_args(span, args); + } + GenericBound::Outlives(ref lifetime) => visitor.visit_lifetime(lifetime), + } +} + +pub fn walk_generic_param<'v, V: Visitor<'v>>(visitor: &mut V, param: &'v GenericParam<'v>) { + visitor.visit_id(param.hir_id); + match param.name { + ParamName::Plain(ident) => visitor.visit_ident(ident), + ParamName::Error | ParamName::Fresh => {} + } + match param.kind { + GenericParamKind::Lifetime { .. } => {} + GenericParamKind::Type { ref default, .. } => walk_list!(visitor, visit_ty, default), + GenericParamKind::Const { ref ty, ref default } => { + visitor.visit_ty(ty); + if let Some(ref default) = default { + visitor.visit_const_param_default(param.hir_id, default); + } + } + } +} + +pub fn walk_const_param_default<'v, V: Visitor<'v>>(visitor: &mut V, ct: &'v AnonConst) { + visitor.visit_anon_const(ct) +} + +pub fn walk_generics<'v, V: Visitor<'v>>(visitor: &mut V, generics: &'v Generics<'v>) { + walk_list!(visitor, visit_generic_param, generics.params); + walk_list!(visitor, visit_where_predicate, generics.predicates); +} + +pub fn walk_where_predicate<'v, V: Visitor<'v>>( + visitor: &mut V, + predicate: &'v WherePredicate<'v>, +) { + match *predicate { + WherePredicate::BoundPredicate(WhereBoundPredicate { + ref bounded_ty, + bounds, + bound_generic_params, + .. + }) => { + visitor.visit_ty(bounded_ty); + walk_list!(visitor, visit_param_bound, bounds); + walk_list!(visitor, visit_generic_param, bound_generic_params); + } + WherePredicate::RegionPredicate(WhereRegionPredicate { ref lifetime, bounds, .. }) => { + visitor.visit_lifetime(lifetime); + walk_list!(visitor, visit_param_bound, bounds); + } + WherePredicate::EqPredicate(WhereEqPredicate { + hir_id, ref lhs_ty, ref rhs_ty, .. + }) => { + visitor.visit_id(hir_id); + visitor.visit_ty(lhs_ty); + visitor.visit_ty(rhs_ty); + } + } +} + +pub fn walk_fn_ret_ty<'v, V: Visitor<'v>>(visitor: &mut V, ret_ty: &'v FnRetTy<'v>) { + if let FnRetTy::Return(ref output_ty) = *ret_ty { + visitor.visit_ty(output_ty) + } +} + +pub fn walk_fn_decl<'v, V: Visitor<'v>>(visitor: &mut V, function_declaration: &'v FnDecl<'v>) { + for ty in function_declaration.inputs { + visitor.visit_ty(ty) + } + walk_fn_ret_ty(visitor, &function_declaration.output) +} + +pub fn walk_fn_kind<'v, V: Visitor<'v>>(visitor: &mut V, function_kind: FnKind<'v>) { + match function_kind { + FnKind::ItemFn(_, generics, ..) => { + visitor.visit_generics(generics); + } + FnKind::Closure | FnKind::Method(..) => {} + } +} + +pub fn walk_fn<'v, V: Visitor<'v>>( + visitor: &mut V, + function_kind: FnKind<'v>, + function_declaration: &'v FnDecl<'v>, + body_id: BodyId, + _span: Span, + id: HirId, +) { + visitor.visit_id(id); + visitor.visit_fn_decl(function_declaration); + walk_fn_kind(visitor, function_kind); + visitor.visit_nested_body(body_id) +} + +pub fn walk_trait_item<'v, V: Visitor<'v>>(visitor: &mut V, trait_item: &'v TraitItem<'v>) { + // N.B., deliberately force a compilation error if/when new fields are added. + let TraitItem { ident, generics, ref defaultness, ref kind, span, def_id: _ } = *trait_item; + let hir_id = trait_item.hir_id(); + visitor.visit_ident(ident); + visitor.visit_generics(&generics); + visitor.visit_defaultness(&defaultness); + match *kind { + TraitItemKind::Const(ref ty, default) => { + visitor.visit_id(hir_id); + visitor.visit_ty(ty); + walk_list!(visitor, visit_nested_body, default); + } + TraitItemKind::Fn(ref sig, TraitFn::Required(param_names)) => { + visitor.visit_id(hir_id); + visitor.visit_fn_decl(&sig.decl); + for ¶m_name in param_names { + visitor.visit_ident(param_name); + } + } + TraitItemKind::Fn(ref sig, TraitFn::Provided(body_id)) => { + visitor.visit_fn(FnKind::Method(ident, sig), &sig.decl, body_id, span, hir_id); + } + TraitItemKind::Type(bounds, ref default) => { + visitor.visit_id(hir_id); + walk_list!(visitor, visit_param_bound, bounds); + walk_list!(visitor, visit_ty, default); + } + } +} + +pub fn walk_trait_item_ref<'v, V: Visitor<'v>>(visitor: &mut V, trait_item_ref: &'v TraitItemRef) { + // N.B., deliberately force a compilation error if/when new fields are added. + let TraitItemRef { id, ident, ref kind, span: _ } = *trait_item_ref; + visitor.visit_nested_trait_item(id); + visitor.visit_ident(ident); + visitor.visit_associated_item_kind(kind); +} + +pub fn walk_impl_item<'v, V: Visitor<'v>>(visitor: &mut V, impl_item: &'v ImplItem<'v>) { + // N.B., deliberately force a compilation error if/when new fields are added. + let ImplItem { + def_id: _, + ident, + ref generics, + ref kind, + ref defaultness, + span: _, + vis_span: _, + } = *impl_item; + + visitor.visit_ident(ident); + visitor.visit_generics(generics); + visitor.visit_defaultness(defaultness); + match *kind { + ImplItemKind::Const(ref ty, body) => { + visitor.visit_id(impl_item.hir_id()); + visitor.visit_ty(ty); + visitor.visit_nested_body(body); + } + ImplItemKind::Fn(ref sig, body_id) => { + visitor.visit_fn( + FnKind::Method(impl_item.ident, sig), + &sig.decl, + body_id, + impl_item.span, + impl_item.hir_id(), + ); + } + ImplItemKind::TyAlias(ref ty) => { + visitor.visit_id(impl_item.hir_id()); + visitor.visit_ty(ty); + } + } +} + +pub fn walk_foreign_item_ref<'v, V: Visitor<'v>>( + visitor: &mut V, + foreign_item_ref: &'v ForeignItemRef, +) { + // N.B., deliberately force a compilation error if/when new fields are added. + let ForeignItemRef { id, ident, span: _ } = *foreign_item_ref; + visitor.visit_nested_foreign_item(id); + visitor.visit_ident(ident); +} + +pub fn walk_impl_item_ref<'v, V: Visitor<'v>>(visitor: &mut V, impl_item_ref: &'v ImplItemRef) { + // N.B., deliberately force a compilation error if/when new fields are added. + let ImplItemRef { id, ident, ref kind, span: _, trait_item_def_id: _ } = *impl_item_ref; + visitor.visit_nested_impl_item(id); + visitor.visit_ident(ident); + visitor.visit_associated_item_kind(kind); +} + +pub fn walk_struct_def<'v, V: Visitor<'v>>( + visitor: &mut V, + struct_definition: &'v VariantData<'v>, +) { + walk_list!(visitor, visit_id, struct_definition.ctor_hir_id()); + walk_list!(visitor, visit_field_def, struct_definition.fields()); +} + +pub fn walk_field_def<'v, V: Visitor<'v>>(visitor: &mut V, field: &'v FieldDef<'v>) { + visitor.visit_id(field.hir_id); + visitor.visit_ident(field.ident); + visitor.visit_ty(&field.ty); +} + +pub fn walk_block<'v, V: Visitor<'v>>(visitor: &mut V, block: &'v Block<'v>) { + visitor.visit_id(block.hir_id); + walk_list!(visitor, visit_stmt, block.stmts); + walk_list!(visitor, visit_expr, &block.expr); +} + +pub fn walk_stmt<'v, V: Visitor<'v>>(visitor: &mut V, statement: &'v Stmt<'v>) { + visitor.visit_id(statement.hir_id); + match statement.kind { + StmtKind::Local(ref local) => visitor.visit_local(local), + StmtKind::Item(item) => visitor.visit_nested_item(item), + StmtKind::Expr(ref expression) | StmtKind::Semi(ref expression) => { + visitor.visit_expr(expression) + } + } +} + +pub fn walk_array_len<'v, V: Visitor<'v>>(visitor: &mut V, len: &'v ArrayLen) { + match len { + &ArrayLen::Infer(hir_id, _span) => visitor.visit_id(hir_id), + ArrayLen::Body(c) => visitor.visit_anon_const(c), + } +} + +pub fn walk_anon_const<'v, V: Visitor<'v>>(visitor: &mut V, constant: &'v AnonConst) { + visitor.visit_id(constant.hir_id); + visitor.visit_nested_body(constant.body); +} + +pub fn walk_let_expr<'v, V: Visitor<'v>>(visitor: &mut V, let_expr: &'v Let<'v>) { + // match the visit order in walk_local + visitor.visit_expr(let_expr.init); + visitor.visit_id(let_expr.hir_id); + visitor.visit_pat(let_expr.pat); + walk_list!(visitor, visit_ty, let_expr.ty); +} + +pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr<'v>) { + visitor.visit_id(expression.hir_id); + match expression.kind { + ExprKind::Box(ref subexpression) => visitor.visit_expr(subexpression), + ExprKind::Array(subexpressions) => { + walk_list!(visitor, visit_expr, subexpressions); + } + ExprKind::ConstBlock(ref anon_const) => visitor.visit_anon_const(anon_const), + ExprKind::Repeat(ref element, ref count) => { + visitor.visit_expr(element); + visitor.visit_array_length(count) + } + ExprKind::Struct(ref qpath, fields, ref optional_base) => { + visitor.visit_qpath(qpath, expression.hir_id, expression.span); + for field in fields { + visitor.visit_id(field.hir_id); + visitor.visit_ident(field.ident); + visitor.visit_expr(&field.expr) + } + walk_list!(visitor, visit_expr, optional_base); + } + ExprKind::Tup(subexpressions) => { + walk_list!(visitor, visit_expr, subexpressions); + } + ExprKind::Call(ref callee_expression, arguments) => { + visitor.visit_expr(callee_expression); + walk_list!(visitor, visit_expr, arguments); + } + ExprKind::MethodCall(ref segment, arguments, _) => { + visitor.visit_path_segment(expression.span, segment); + walk_list!(visitor, visit_expr, arguments); + } + ExprKind::Binary(_, ref left_expression, ref right_expression) => { + visitor.visit_expr(left_expression); + visitor.visit_expr(right_expression) + } + ExprKind::AddrOf(_, _, ref subexpression) | ExprKind::Unary(_, ref subexpression) => { + visitor.visit_expr(subexpression) + } + ExprKind::Cast(ref subexpression, ref typ) | ExprKind::Type(ref subexpression, ref typ) => { + visitor.visit_expr(subexpression); + visitor.visit_ty(typ) + } + ExprKind::DropTemps(ref subexpression) => { + visitor.visit_expr(subexpression); + } + ExprKind::Let(ref let_expr) => visitor.visit_let_expr(let_expr), + ExprKind::If(ref cond, ref then, ref else_opt) => { + visitor.visit_expr(cond); + visitor.visit_expr(then); + walk_list!(visitor, visit_expr, else_opt); + } + ExprKind::Loop(ref block, ref opt_label, _, _) => { + walk_list!(visitor, visit_label, opt_label); + visitor.visit_block(block); + } + ExprKind::Match(ref subexpression, arms, _) => { + visitor.visit_expr(subexpression); + walk_list!(visitor, visit_arm, arms); + } + ExprKind::Closure(&Closure { + binder: _, + bound_generic_params, + fn_decl, + body, + capture_clause: _, + fn_decl_span: _, + movability: _, + }) => { + walk_list!(visitor, visit_generic_param, bound_generic_params); + visitor.visit_fn(FnKind::Closure, fn_decl, body, expression.span, expression.hir_id) + } + ExprKind::Block(ref block, ref opt_label) => { + walk_list!(visitor, visit_label, opt_label); + visitor.visit_block(block); + } + ExprKind::Assign(ref lhs, ref rhs, _) => { + visitor.visit_expr(rhs); + visitor.visit_expr(lhs) + } + ExprKind::AssignOp(_, ref left_expression, ref right_expression) => { + visitor.visit_expr(right_expression); + visitor.visit_expr(left_expression); + } + ExprKind::Field(ref subexpression, ident) => { + visitor.visit_expr(subexpression); + visitor.visit_ident(ident); + } + ExprKind::Index(ref main_expression, ref index_expression) => { + visitor.visit_expr(main_expression); + visitor.visit_expr(index_expression) + } + ExprKind::Path(ref qpath) => { + visitor.visit_qpath(qpath, expression.hir_id, expression.span); + } + ExprKind::Break(ref destination, ref opt_expr) => { + walk_list!(visitor, visit_label, &destination.label); + walk_list!(visitor, visit_expr, opt_expr); + } + ExprKind::Continue(ref destination) => { + walk_list!(visitor, visit_label, &destination.label); + } + ExprKind::Ret(ref optional_expression) => { + walk_list!(visitor, visit_expr, optional_expression); + } + ExprKind::InlineAsm(ref asm) => { + visitor.visit_inline_asm(asm, expression.hir_id); + } + ExprKind::Yield(ref subexpression, _) => { + visitor.visit_expr(subexpression); + } + ExprKind::Lit(_) | ExprKind::Err => {} + } +} + +pub fn walk_arm<'v, V: Visitor<'v>>(visitor: &mut V, arm: &'v Arm<'v>) { + visitor.visit_id(arm.hir_id); + visitor.visit_pat(&arm.pat); + if let Some(ref g) = arm.guard { + match g { + Guard::If(ref e) => visitor.visit_expr(e), + Guard::IfLet(ref l) => { + visitor.visit_let_expr(l); + } + } + } + visitor.visit_expr(&arm.body); +} + +pub fn walk_associated_item_kind<'v, V: Visitor<'v>>(_: &mut V, _: &'v AssocItemKind) { + // No visitable content here: this fn exists so you can call it if + // the right thing to do, should content be added in the future, + // would be to walk it. +} + +pub fn walk_defaultness<'v, V: Visitor<'v>>(_: &mut V, _: &'v Defaultness) { + // No visitable content here: this fn exists so you can call it if + // the right thing to do, should content be added in the future, + // would be to walk it. +} diff --git a/compiler/rustc_hir/src/lang_items.rs b/compiler/rustc_hir/src/lang_items.rs new file mode 100644 index 000000000..c337be12a --- /dev/null +++ b/compiler/rustc_hir/src/lang_items.rs @@ -0,0 +1,339 @@ +//! Defines language items. +//! +//! Language items are items that represent concepts intrinsic to the language +//! itself. Examples are: +//! +//! * Traits that specify "kinds"; e.g., `Sync`, `Send`. +//! * Traits that represent operators; e.g., `Add`, `Sub`, `Index`. +//! * Functions called by the compiler itself. + +use crate::def_id::DefId; +use crate::{MethodKind, Target}; + +use rustc_ast as ast; +use rustc_data_structures::fx::FxIndexMap; +use rustc_data_structures::stable_hasher::{HashStable, StableHasher}; +use rustc_macros::HashStable_Generic; +use rustc_span::symbol::{kw, sym, Symbol}; +use rustc_span::Span; + +use std::sync::LazyLock; + +pub enum LangItemGroup { + Op, + Fn, +} + +const NUM_GROUPS: usize = 2; + +macro_rules! expand_group { + () => { + None + }; + ($group:expr) => { + Some($group) + }; +} + +// The actual lang items defined come at the end of this file in one handy table. +// So you probably just want to nip down to the end. +macro_rules! language_item_table { + ( + $( $(#[$attr:meta])* $variant:ident $($group:expr)?, $module:ident :: $name:ident, $method:ident, $target:expr, $generics:expr; )* + ) => { + + enum_from_u32! { + /// A representation of all the valid language items in Rust. + #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Encodable, Decodable)] + pub enum LangItem { + $( + #[doc = concat!("The `", stringify!($name), "` lang item.")] + /// + $(#[$attr])* + $variant, + )* + } + } + + impl LangItem { + /// Returns the `name` symbol in `#[lang = "$name"]`. + /// For example, [`LangItem::PartialEq`]`.name()` + /// would result in [`sym::eq`] since it is `#[lang = "eq"]`. + pub fn name(self) -> Symbol { + match self { + $( LangItem::$variant => $module::$name, )* + } + } + + /// The [group](LangItemGroup) that this lang item belongs to, + /// or `None` if it doesn't belong to a group. + pub fn group(self) -> Option { + use LangItemGroup::*; + match self { + $( LangItem::$variant => expand_group!($($group)*), )* + } + } + + pub fn required_generics(&self) -> GenericRequirement { + match self { + $( LangItem::$variant => $generics, )* + } + } + } + + /// All of the language items, defined or not. + /// Defined lang items can come from the current crate or its dependencies. + #[derive(HashStable_Generic, Debug)] + pub struct LanguageItems { + /// Mappings from lang items to their possibly found [`DefId`]s. + /// The index corresponds to the order in [`LangItem`]. + pub items: Vec>, + /// Lang items that were not found during collection. + pub missing: Vec, + /// Mapping from [`LangItemGroup`] discriminants to all + /// [`DefId`]s of lang items in that group. + pub groups: [Vec; NUM_GROUPS], + } + + impl LanguageItems { + /// Construct an empty collection of lang items and no missing ones. + pub fn new() -> Self { + fn init_none(_: LangItem) -> Option { None } + const EMPTY: Vec = Vec::new(); + + Self { + items: vec![$(init_none(LangItem::$variant)),*], + missing: Vec::new(), + groups: [EMPTY; NUM_GROUPS], + } + } + + /// Returns the mappings to the possibly found `DefId`s for each lang item. + pub fn items(&self) -> &[Option] { + &*self.items + } + + /// Requires that a given `LangItem` was bound and returns the corresponding `DefId`. + /// If it wasn't bound, e.g. due to a missing `#[lang = ""]`, + /// returns an error message as a string. + pub fn require(&self, it: LangItem) -> Result { + self.items[it as usize].ok_or_else(|| format!("requires `{}` lang_item", it.name())) + } + + /// Returns the [`DefId`]s of all lang items in a group. + pub fn group(&self, group: LangItemGroup) -> &[DefId] { + self.groups[group as usize].as_ref() + } + + $( + #[doc = concat!("Returns the [`DefId`] of the `", stringify!($name), "` lang item if it is defined.")] + pub fn $method(&self) -> Option { + self.items[LangItem::$variant as usize] + } + )* + } + + /// A mapping from the name of the lang item to its order and the form it must be of. + pub static ITEM_REFS: LazyLock> = LazyLock::new(|| { + let mut item_refs = FxIndexMap::default(); + $( item_refs.insert($module::$name, (LangItem::$variant as usize, $target)); )* + item_refs + }); + +// End of the macro + } +} + +impl HashStable for LangItem { + fn hash_stable(&self, _: &mut CTX, hasher: &mut StableHasher) { + ::std::hash::Hash::hash(self, hasher); + } +} + +/// Extracts the first `lang = "$name"` out of a list of attributes. +/// The attributes `#[panic_handler]` and `#[alloc_error_handler]` +/// are also extracted out when found. +pub fn extract(attrs: &[ast::Attribute]) -> Option<(Symbol, Span)> { + attrs.iter().find_map(|attr| { + Some(match attr { + _ if attr.has_name(sym::lang) => (attr.value_str()?, attr.span), + _ if attr.has_name(sym::panic_handler) => (sym::panic_impl, attr.span), + _ if attr.has_name(sym::alloc_error_handler) => (sym::oom, attr.span), + _ => return None, + }) + }) +} + +language_item_table! { +// Variant name, Name, Method name, Target Generic requirements; + Sized, sym::sized, sized_trait, Target::Trait, GenericRequirement::Exact(0); + Unsize, sym::unsize, unsize_trait, Target::Trait, GenericRequirement::Minimum(1); + /// Trait injected by `#[derive(PartialEq)]`, (i.e. "Partial EQ"). + StructuralPeq, sym::structural_peq, structural_peq_trait, Target::Trait, GenericRequirement::None; + /// Trait injected by `#[derive(Eq)]`, (i.e. "Total EQ"; no, I will not apologize). + StructuralTeq, sym::structural_teq, structural_teq_trait, Target::Trait, GenericRequirement::None; + Copy, sym::copy, copy_trait, Target::Trait, GenericRequirement::Exact(0); + Clone, sym::clone, clone_trait, Target::Trait, GenericRequirement::None; + Sync, sym::sync, sync_trait, Target::Trait, GenericRequirement::Exact(0); + DiscriminantKind, sym::discriminant_kind, discriminant_kind_trait, Target::Trait, GenericRequirement::None; + /// The associated item of the [`DiscriminantKind`] trait. + Discriminant, sym::discriminant_type, discriminant_type, Target::AssocTy, GenericRequirement::None; + + PointeeTrait, sym::pointee_trait, pointee_trait, Target::Trait, GenericRequirement::None; + Metadata, sym::metadata_type, metadata_type, Target::AssocTy, GenericRequirement::None; + DynMetadata, sym::dyn_metadata, dyn_metadata, Target::Struct, GenericRequirement::None; + + Freeze, sym::freeze, freeze_trait, Target::Trait, GenericRequirement::Exact(0); + + Drop, sym::drop, drop_trait, Target::Trait, GenericRequirement::None; + Destruct, sym::destruct, destruct_trait, Target::Trait, GenericRequirement::None; + + CoerceUnsized, sym::coerce_unsized, coerce_unsized_trait, Target::Trait, GenericRequirement::Minimum(1); + DispatchFromDyn, sym::dispatch_from_dyn, dispatch_from_dyn_trait, Target::Trait, GenericRequirement::Minimum(1); + + // language items relating to transmutability + TransmuteTrait, sym::transmute_trait, transmute_trait, Target::Trait, GenericRequirement::Exact(6); + + Add(Op), sym::add, add_trait, Target::Trait, GenericRequirement::Exact(1); + Sub(Op), sym::sub, sub_trait, Target::Trait, GenericRequirement::Exact(1); + Mul(Op), sym::mul, mul_trait, Target::Trait, GenericRequirement::Exact(1); + Div(Op), sym::div, div_trait, Target::Trait, GenericRequirement::Exact(1); + Rem(Op), sym::rem, rem_trait, Target::Trait, GenericRequirement::Exact(1); + Neg(Op), sym::neg, neg_trait, Target::Trait, GenericRequirement::Exact(0); + Not(Op), sym::not, not_trait, Target::Trait, GenericRequirement::Exact(0); + BitXor(Op), sym::bitxor, bitxor_trait, Target::Trait, GenericRequirement::Exact(1); + BitAnd(Op), sym::bitand, bitand_trait, Target::Trait, GenericRequirement::Exact(1); + BitOr(Op), sym::bitor, bitor_trait, Target::Trait, GenericRequirement::Exact(1); + Shl(Op), sym::shl, shl_trait, Target::Trait, GenericRequirement::Exact(1); + Shr(Op), sym::shr, shr_trait, Target::Trait, GenericRequirement::Exact(1); + AddAssign(Op), sym::add_assign, add_assign_trait, Target::Trait, GenericRequirement::Exact(1); + SubAssign(Op), sym::sub_assign, sub_assign_trait, Target::Trait, GenericRequirement::Exact(1); + MulAssign(Op), sym::mul_assign, mul_assign_trait, Target::Trait, GenericRequirement::Exact(1); + DivAssign(Op), sym::div_assign, div_assign_trait, Target::Trait, GenericRequirement::Exact(1); + RemAssign(Op), sym::rem_assign, rem_assign_trait, Target::Trait, GenericRequirement::Exact(1); + BitXorAssign(Op), sym::bitxor_assign, bitxor_assign_trait, Target::Trait, GenericRequirement::Exact(1); + BitAndAssign(Op), sym::bitand_assign, bitand_assign_trait, Target::Trait, GenericRequirement::Exact(1); + BitOrAssign(Op), sym::bitor_assign, bitor_assign_trait, Target::Trait, GenericRequirement::Exact(1); + ShlAssign(Op), sym::shl_assign, shl_assign_trait, Target::Trait, GenericRequirement::Exact(1); + ShrAssign(Op), sym::shr_assign, shr_assign_trait, Target::Trait, GenericRequirement::Exact(1); + Index(Op), sym::index, index_trait, Target::Trait, GenericRequirement::Exact(1); + IndexMut(Op), sym::index_mut, index_mut_trait, Target::Trait, GenericRequirement::Exact(1); + + UnsafeCell, sym::unsafe_cell, unsafe_cell_type, Target::Struct, GenericRequirement::None; + VaList, sym::va_list, va_list, Target::Struct, GenericRequirement::None; + + Deref, sym::deref, deref_trait, Target::Trait, GenericRequirement::Exact(0); + DerefMut, sym::deref_mut, deref_mut_trait, Target::Trait, GenericRequirement::Exact(0); + DerefTarget, sym::deref_target, deref_target, Target::AssocTy, GenericRequirement::None; + Receiver, sym::receiver, receiver_trait, Target::Trait, GenericRequirement::None; + + Fn(Fn), kw::Fn, fn_trait, Target::Trait, GenericRequirement::Exact(1); + FnMut(Fn), sym::fn_mut, fn_mut_trait, Target::Trait, GenericRequirement::Exact(1); + FnOnce(Fn), sym::fn_once, fn_once_trait, Target::Trait, GenericRequirement::Exact(1); + + FnOnceOutput, sym::fn_once_output, fn_once_output, Target::AssocTy, GenericRequirement::None; + + Future, sym::future_trait, future_trait, Target::Trait, GenericRequirement::Exact(0); + GeneratorState, sym::generator_state, gen_state, Target::Enum, GenericRequirement::None; + Generator, sym::generator, gen_trait, Target::Trait, GenericRequirement::Minimum(1); + GeneratorReturn, sym::generator_return, generator_return, Target::AssocTy, GenericRequirement::None; + Unpin, sym::unpin, unpin_trait, Target::Trait, GenericRequirement::None; + Pin, sym::pin, pin_type, Target::Struct, GenericRequirement::None; + + PartialEq(Op), sym::eq, eq_trait, Target::Trait, GenericRequirement::Exact(1); + PartialOrd(Op), sym::partial_ord, partial_ord_trait, Target::Trait, GenericRequirement::Exact(1); + + // A number of panic-related lang items. The `panic` item corresponds to divide-by-zero and + // various panic cases with `match`. The `panic_bounds_check` item is for indexing arrays. + // + // The `begin_unwind` lang item has a predefined symbol name and is sort of a "weak lang item" + // in the sense that a crate is not required to have it defined to use it, but a final product + // is required to define it somewhere. Additionally, there are restrictions on crates that use + // a weak lang item, but do not have it defined. + Panic, sym::panic, panic_fn, Target::Fn, GenericRequirement::Exact(0); + PanicFmt, sym::panic_fmt, panic_fmt, Target::Fn, GenericRequirement::None; + PanicDisplay, sym::panic_display, panic_display, Target::Fn, GenericRequirement::None; + ConstPanicFmt, sym::const_panic_fmt, const_panic_fmt, Target::Fn, GenericRequirement::None; + PanicBoundsCheck, sym::panic_bounds_check, panic_bounds_check_fn, Target::Fn, GenericRequirement::Exact(0); + PanicInfo, sym::panic_info, panic_info, Target::Struct, GenericRequirement::None; + PanicLocation, sym::panic_location, panic_location, Target::Struct, GenericRequirement::None; + PanicImpl, sym::panic_impl, panic_impl, Target::Fn, GenericRequirement::None; + PanicNoUnwind, sym::panic_no_unwind, panic_no_unwind, Target::Fn, GenericRequirement::Exact(0); + /// libstd panic entry point. Necessary for const eval to be able to catch it + BeginPanic, sym::begin_panic, begin_panic_fn, Target::Fn, GenericRequirement::None; + + ExchangeMalloc, sym::exchange_malloc, exchange_malloc_fn, Target::Fn, GenericRequirement::None; + BoxFree, sym::box_free, box_free_fn, Target::Fn, GenericRequirement::Minimum(1); + DropInPlace, sym::drop_in_place, drop_in_place_fn, Target::Fn, GenericRequirement::Minimum(1); + Oom, sym::oom, oom, Target::Fn, GenericRequirement::None; + AllocLayout, sym::alloc_layout, alloc_layout, Target::Struct, GenericRequirement::None; + ConstEvalSelect, sym::const_eval_select, const_eval_select, Target::Fn, GenericRequirement::Exact(4); + ConstConstEvalSelect, sym::const_eval_select_ct,const_eval_select_ct, Target::Fn, GenericRequirement::Exact(4); + + Start, sym::start, start_fn, Target::Fn, GenericRequirement::Exact(1); + + EhPersonality, sym::eh_personality, eh_personality, Target::Fn, GenericRequirement::None; + EhCatchTypeinfo, sym::eh_catch_typeinfo, eh_catch_typeinfo, Target::Static, GenericRequirement::None; + + OwnedBox, sym::owned_box, owned_box, Target::Struct, GenericRequirement::Minimum(1); + + PhantomData, sym::phantom_data, phantom_data, Target::Struct, GenericRequirement::Exact(1); + + ManuallyDrop, sym::manually_drop, manually_drop, Target::Struct, GenericRequirement::None; + + MaybeUninit, sym::maybe_uninit, maybe_uninit, Target::Union, GenericRequirement::None; + + /// Align offset for stride != 1; must not panic. + AlignOffset, sym::align_offset, align_offset_fn, Target::Fn, GenericRequirement::None; + + Termination, sym::termination, termination, Target::Trait, GenericRequirement::None; + + Try, sym::Try, try_trait, Target::Trait, GenericRequirement::None; + + SliceLen, sym::slice_len_fn, slice_len_fn, Target::Method(MethodKind::Inherent), GenericRequirement::None; + + // Language items from AST lowering + TryTraitFromResidual, sym::from_residual, from_residual_fn, Target::Method(MethodKind::Trait { body: false }), GenericRequirement::None; + TryTraitFromOutput, sym::from_output, from_output_fn, Target::Method(MethodKind::Trait { body: false }), GenericRequirement::None; + TryTraitBranch, sym::branch, branch_fn, Target::Method(MethodKind::Trait { body: false }), GenericRequirement::None; + TryTraitFromYeet, sym::from_yeet, from_yeet_fn, Target::Fn, GenericRequirement::None; + + PollReady, sym::Ready, poll_ready_variant, Target::Variant, GenericRequirement::None; + PollPending, sym::Pending, poll_pending_variant, Target::Variant, GenericRequirement::None; + + FromGenerator, sym::from_generator, from_generator_fn, Target::Fn, GenericRequirement::None; + GetContext, sym::get_context, get_context_fn, Target::Fn, GenericRequirement::None; + + FuturePoll, sym::poll, future_poll_fn, Target::Method(MethodKind::Trait { body: false }), GenericRequirement::None; + + FromFrom, sym::from, from_fn, Target::Method(MethodKind::Trait { body: false }), GenericRequirement::None; + + OptionSome, sym::Some, option_some_variant, Target::Variant, GenericRequirement::None; + OptionNone, sym::None, option_none_variant, Target::Variant, GenericRequirement::None; + + ResultOk, sym::Ok, result_ok_variant, Target::Variant, GenericRequirement::None; + ResultErr, sym::Err, result_err_variant, Target::Variant, GenericRequirement::None; + + ControlFlowContinue, sym::Continue, cf_continue_variant, Target::Variant, GenericRequirement::None; + ControlFlowBreak, sym::Break, cf_break_variant, Target::Variant, GenericRequirement::None; + + IntoFutureIntoFuture, sym::into_future, into_future_fn, Target::Method(MethodKind::Trait { body: false }), GenericRequirement::None; + IntoIterIntoIter, sym::into_iter, into_iter_fn, Target::Method(MethodKind::Trait { body: false }), GenericRequirement::None; + IteratorNext, sym::next, next_fn, Target::Method(MethodKind::Trait { body: false}), GenericRequirement::None; + + PinNewUnchecked, sym::new_unchecked, new_unchecked_fn, Target::Method(MethodKind::Inherent), GenericRequirement::None; + + RangeFrom, sym::RangeFrom, range_from_struct, Target::Struct, GenericRequirement::None; + RangeFull, sym::RangeFull, range_full_struct, Target::Struct, GenericRequirement::None; + RangeInclusiveStruct, sym::RangeInclusive, range_inclusive_struct, Target::Struct, GenericRequirement::None; + RangeInclusiveNew, sym::range_inclusive_new, range_inclusive_new_method, Target::Method(MethodKind::Inherent), GenericRequirement::None; + Range, sym::Range, range_struct, Target::Struct, GenericRequirement::None; + RangeToInclusive, sym::RangeToInclusive, range_to_inclusive_struct, Target::Struct, GenericRequirement::None; + RangeTo, sym::RangeTo, range_to_struct, Target::Struct, GenericRequirement::None; +} + +pub enum GenericRequirement { + None, + Minimum(usize), + Exact(usize), +} diff --git a/compiler/rustc_hir/src/lib.rs b/compiler/rustc_hir/src/lib.rs new file mode 100644 index 000000000..0f9e6fa7b --- /dev/null +++ b/compiler/rustc_hir/src/lib.rs @@ -0,0 +1,47 @@ +//! HIR datatypes. See the [rustc dev guide] for more info. +//! +//! [rustc dev guide]: https://rustc-dev-guide.rust-lang.org/hir.html + +#![feature(associated_type_defaults)] +#![feature(closure_track_caller)] +#![feature(const_btree_new)] +#![feature(let_else)] +#![feature(once_cell)] +#![feature(min_specialization)] +#![feature(never_type)] +#![feature(rustc_attrs)] +#![recursion_limit = "256"] + +#[macro_use] +extern crate rustc_macros; + +#[macro_use] +extern crate rustc_data_structures; + +extern crate self as rustc_hir; + +mod arena; +pub mod def; +pub mod def_path_hash_map; +pub mod definitions; +pub mod diagnostic_items; +pub use rustc_span::def_id; +mod hir; +pub mod hir_id; +pub mod intravisit; +pub mod lang_items; +pub mod pat_util; +mod stable_hash_impls; +mod target; +pub mod weak_lang_items; + +#[cfg(test)] +mod tests; + +pub use hir::*; +pub use hir_id::*; +pub use lang_items::{LangItem, LanguageItems}; +pub use stable_hash_impls::HashStableContext; +pub use target::{MethodKind, Target}; + +arena_types!(rustc_arena::declare_arena); diff --git a/compiler/rustc_hir/src/pat_util.rs b/compiler/rustc_hir/src/pat_util.rs new file mode 100644 index 000000000..93112199b --- /dev/null +++ b/compiler/rustc_hir/src/pat_util.rs @@ -0,0 +1,157 @@ +use crate::def::{CtorOf, DefKind, Res}; +use crate::def_id::DefId; +use crate::hir::{self, HirId, PatKind}; +use rustc_data_structures::fx::FxHashSet; +use rustc_span::hygiene::DesugaringKind; +use rustc_span::symbol::Ident; +use rustc_span::Span; + +use std::iter::{Enumerate, ExactSizeIterator}; + +pub struct EnumerateAndAdjust { + enumerate: Enumerate, + gap_pos: usize, + gap_len: usize, +} + +impl Iterator for EnumerateAndAdjust +where + I: Iterator, +{ + type Item = (usize, ::Item); + + fn next(&mut self) -> Option<(usize, ::Item)> { + self.enumerate + .next() + .map(|(i, elem)| (if i < self.gap_pos { i } else { i + self.gap_len }, elem)) + } + + fn size_hint(&self) -> (usize, Option) { + self.enumerate.size_hint() + } +} + +pub trait EnumerateAndAdjustIterator { + fn enumerate_and_adjust( + self, + expected_len: usize, + gap_pos: Option, + ) -> EnumerateAndAdjust + where + Self: Sized; +} + +impl EnumerateAndAdjustIterator for T { + fn enumerate_and_adjust( + self, + expected_len: usize, + gap_pos: Option, + ) -> EnumerateAndAdjust + where + Self: Sized, + { + let actual_len = self.len(); + EnumerateAndAdjust { + enumerate: self.enumerate(), + gap_pos: gap_pos.unwrap_or(expected_len), + gap_len: expected_len - actual_len, + } + } +} + +impl hir::Pat<'_> { + /// Call `f` on every "binding" in a pattern, e.g., on `a` in + /// `match foo() { Some(a) => (), None => () }` + pub fn each_binding(&self, mut f: impl FnMut(hir::BindingAnnotation, HirId, Span, Ident)) { + self.walk_always(|p| { + if let PatKind::Binding(binding_mode, _, ident, _) = p.kind { + f(binding_mode, p.hir_id, p.span, ident); + } + }); + } + + /// Call `f` on every "binding" in a pattern, e.g., on `a` in + /// `match foo() { Some(a) => (), None => () }`. + /// + /// When encountering an or-pattern `p_0 | ... | p_n` only `p_0` will be visited. + pub fn each_binding_or_first( + &self, + f: &mut impl FnMut(hir::BindingAnnotation, HirId, Span, Ident), + ) { + self.walk(|p| match &p.kind { + PatKind::Or(ps) => { + ps[0].each_binding_or_first(f); + false + } + PatKind::Binding(bm, _, ident, _) => { + f(*bm, p.hir_id, p.span, *ident); + true + } + _ => true, + }) + } + + pub fn simple_ident(&self) -> Option { + match self.kind { + PatKind::Binding( + hir::BindingAnnotation::Unannotated | hir::BindingAnnotation::Mutable, + _, + ident, + None, + ) => Some(ident), + _ => None, + } + } + + /// Returns variants that are necessary to exist for the pattern to match. + pub fn necessary_variants(&self) -> Vec { + let mut variants = vec![]; + self.walk(|p| match &p.kind { + PatKind::Or(_) => false, + PatKind::Path(hir::QPath::Resolved(_, path)) + | PatKind::TupleStruct(hir::QPath::Resolved(_, path), ..) + | PatKind::Struct(hir::QPath::Resolved(_, path), ..) => { + if let Res::Def(DefKind::Variant | DefKind::Ctor(CtorOf::Variant, ..), id) = + path.res + { + variants.push(id); + } + true + } + _ => true, + }); + // We remove duplicates by inserting into a `FxHashSet` to avoid re-ordering + // the bounds + let mut duplicates = FxHashSet::default(); + variants.retain(|def_id| duplicates.insert(*def_id)); + variants + } + + /// Checks if the pattern contains any `ref` or `ref mut` bindings, and if + /// yes whether it contains mutable or just immutables ones. + // + // FIXME(tschottdorf): this is problematic as the HIR is being scraped, but + // ref bindings are be implicit after #42640 (default match binding modes). See issue #44848. + pub fn contains_explicit_ref_binding(&self) -> Option { + let mut result = None; + self.each_binding(|annotation, _, _, _| match annotation { + hir::BindingAnnotation::Ref => match result { + None | Some(hir::Mutability::Not) => result = Some(hir::Mutability::Not), + _ => {} + }, + hir::BindingAnnotation::RefMut => result = Some(hir::Mutability::Mut), + _ => {} + }); + result + } + + /// If the pattern is `Some()` from a desugared for loop, returns the inner pattern + pub fn for_loop_some(&self) -> Option<&Self> { + if self.span.desugaring_kind() == Some(DesugaringKind::ForLoop) { + if let hir::PatKind::Struct(_, [pat_field], _) = self.kind { + return Some(pat_field.pat); + } + } + None + } +} diff --git a/compiler/rustc_hir/src/stable_hash_impls.rs b/compiler/rustc_hir/src/stable_hash_impls.rs new file mode 100644 index 000000000..8ccd59e8e --- /dev/null +++ b/compiler/rustc_hir/src/stable_hash_impls.rs @@ -0,0 +1,143 @@ +use rustc_data_structures::stable_hasher::{HashStable, StableHasher, ToStableHashKey}; + +use crate::hir::{ + AttributeMap, BodyId, Crate, Expr, ForeignItemId, ImplItemId, ItemId, OwnerNodes, TraitItemId, + Ty, +}; +use crate::hir_id::{HirId, ItemLocalId}; +use rustc_span::def_id::DefPathHash; + +/// Requirements for a `StableHashingContext` to be used in this crate. +/// This is a hack to allow using the `HashStable_Generic` derive macro +/// instead of implementing everything in `rustc_middle`. +pub trait HashStableContext: + rustc_ast::HashStableContext + rustc_target::HashStableContext +{ + fn hash_body_id(&mut self, _: BodyId, hasher: &mut StableHasher); + fn hash_hir_expr(&mut self, _: &Expr<'_>, hasher: &mut StableHasher); + fn hash_hir_ty(&mut self, _: &Ty<'_>, hasher: &mut StableHasher); +} + +impl ToStableHashKey for HirId { + type KeyType = (DefPathHash, ItemLocalId); + + #[inline] + fn to_stable_hash_key(&self, hcx: &HirCtx) -> (DefPathHash, ItemLocalId) { + let def_path_hash = self.owner.to_stable_hash_key(hcx); + (def_path_hash, self.local_id) + } +} + +impl ToStableHashKey for ItemLocalId { + type KeyType = ItemLocalId; + + #[inline] + fn to_stable_hash_key(&self, _: &HirCtx) -> ItemLocalId { + *self + } +} + +impl ToStableHashKey for BodyId { + type KeyType = (DefPathHash, ItemLocalId); + + #[inline] + fn to_stable_hash_key(&self, hcx: &HirCtx) -> (DefPathHash, ItemLocalId) { + let BodyId { hir_id } = *self; + hir_id.to_stable_hash_key(hcx) + } +} + +impl ToStableHashKey for ItemId { + type KeyType = DefPathHash; + + #[inline] + fn to_stable_hash_key(&self, hcx: &HirCtx) -> DefPathHash { + self.def_id.to_stable_hash_key(hcx) + } +} + +impl ToStableHashKey for TraitItemId { + type KeyType = DefPathHash; + + #[inline] + fn to_stable_hash_key(&self, hcx: &HirCtx) -> DefPathHash { + self.def_id.to_stable_hash_key(hcx) + } +} + +impl ToStableHashKey for ImplItemId { + type KeyType = DefPathHash; + + #[inline] + fn to_stable_hash_key(&self, hcx: &HirCtx) -> DefPathHash { + self.def_id.to_stable_hash_key(hcx) + } +} + +impl ToStableHashKey for ForeignItemId { + type KeyType = DefPathHash; + + #[inline] + fn to_stable_hash_key(&self, hcx: &HirCtx) -> DefPathHash { + self.def_id.to_stable_hash_key(hcx) + } +} + +impl HashStable for BodyId { + fn hash_stable(&self, hcx: &mut HirCtx, hasher: &mut StableHasher) { + hcx.hash_body_id(*self, hasher) + } +} + +// The following implementations of HashStable for `ItemId`, `TraitItemId`, and +// `ImplItemId` deserve special attention. Normally we do not hash `NodeId`s within +// the HIR, since they just signify a HIR nodes own path. But `ItemId` et al +// are used when another item in the HIR is *referenced* and we certainly +// want to pick up on a reference changing its target, so we hash the NodeIds +// in "DefPath Mode". + +impl HashStable for Expr<'_> { + fn hash_stable(&self, hcx: &mut HirCtx, hasher: &mut StableHasher) { + hcx.hash_hir_expr(self, hasher) + } +} + +impl HashStable for Ty<'_> { + fn hash_stable(&self, hcx: &mut HirCtx, hasher: &mut StableHasher) { + hcx.hash_hir_ty(self, hasher) + } +} + +impl<'tcx, HirCtx: crate::HashStableContext> HashStable for OwnerNodes<'tcx> { + fn hash_stable(&self, hcx: &mut HirCtx, hasher: &mut StableHasher) { + // We ignore the `nodes` and `bodies` fields since these refer to information included in + // `hash` which is hashed in the collector and used for the crate hash. + // `local_id_to_def_id` is also ignored because is dependent on the body, then just hashing + // the body satisfies the condition of two nodes being different have different + // `hash_stable` results. + let OwnerNodes { + hash_including_bodies, + hash_without_bodies: _, + nodes: _, + bodies: _, + local_id_to_def_id: _, + } = *self; + hash_including_bodies.hash_stable(hcx, hasher); + } +} + +impl<'tcx, HirCtx: crate::HashStableContext> HashStable for AttributeMap<'tcx> { + fn hash_stable(&self, hcx: &mut HirCtx, hasher: &mut StableHasher) { + // We ignore the `map` since it refers to information included in `hash` which is hashed in + // the collector and used for the crate hash. + let AttributeMap { hash, map: _ } = *self; + hash.hash_stable(hcx, hasher); + } +} + +impl HashStable for Crate<'_> { + fn hash_stable(&self, hcx: &mut HirCtx, hasher: &mut StableHasher) { + let Crate { owners: _, hir_hash } = self; + hir_hash.hash_stable(hcx, hasher) + } +} diff --git a/compiler/rustc_hir/src/target.rs b/compiler/rustc_hir/src/target.rs new file mode 100644 index 000000000..6236dea10 --- /dev/null +++ b/compiler/rustc_hir/src/target.rs @@ -0,0 +1,188 @@ +//! This module implements some validity checks for attributes. +//! In particular it verifies that `#[inline]` and `#[repr]` attributes are +//! attached to items that actually support them and if there are +//! conflicts between multiple such attributes attached to the same +//! item. + +use crate::hir; +use crate::{Item, ItemKind, TraitItem, TraitItemKind}; + +use crate::def::DefKind; +use std::fmt::{self, Display}; + +#[derive(Copy, Clone, PartialEq, Debug)] +pub enum GenericParamKind { + Type, + Lifetime, + Const, +} + +#[derive(Copy, Clone, PartialEq, Debug)] +pub enum MethodKind { + Trait { body: bool }, + Inherent, +} + +#[derive(Copy, Clone, PartialEq, Debug)] +pub enum Target { + ExternCrate, + Use, + Static, + Const, + Fn, + Closure, + Mod, + ForeignMod, + GlobalAsm, + TyAlias, + OpaqueTy, + Enum, + Variant, + Struct, + Field, + Union, + Trait, + TraitAlias, + Impl, + Expression, + Statement, + Arm, + AssocConst, + Method(MethodKind), + AssocTy, + ForeignFn, + ForeignStatic, + ForeignTy, + GenericParam(GenericParamKind), + MacroDef, + Param, +} + +impl Display for Target { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{}", Self::name(*self)) + } +} + +impl Target { + pub fn from_item(item: &Item<'_>) -> Target { + match item.kind { + ItemKind::ExternCrate(..) => Target::ExternCrate, + ItemKind::Use(..) => Target::Use, + ItemKind::Static(..) => Target::Static, + ItemKind::Const(..) => Target::Const, + ItemKind::Fn(..) => Target::Fn, + ItemKind::Macro(..) => Target::MacroDef, + ItemKind::Mod(..) => Target::Mod, + ItemKind::ForeignMod { .. } => Target::ForeignMod, + ItemKind::GlobalAsm(..) => Target::GlobalAsm, + ItemKind::TyAlias(..) => Target::TyAlias, + ItemKind::OpaqueTy(..) => Target::OpaqueTy, + ItemKind::Enum(..) => Target::Enum, + ItemKind::Struct(..) => Target::Struct, + ItemKind::Union(..) => Target::Union, + ItemKind::Trait(..) => Target::Trait, + ItemKind::TraitAlias(..) => Target::TraitAlias, + ItemKind::Impl { .. } => Target::Impl, + } + } + + // FIXME: For now, should only be used with def_kinds from ItemIds + pub fn from_def_kind(def_kind: DefKind) -> Target { + match def_kind { + DefKind::ExternCrate => Target::ExternCrate, + DefKind::Use => Target::Use, + DefKind::Static(..) => Target::Static, + DefKind::Const => Target::Const, + DefKind::Fn => Target::Fn, + DefKind::Macro(..) => Target::MacroDef, + DefKind::Mod => Target::Mod, + DefKind::ForeignMod => Target::ForeignMod, + DefKind::GlobalAsm => Target::GlobalAsm, + DefKind::TyAlias => Target::TyAlias, + DefKind::OpaqueTy => Target::OpaqueTy, + DefKind::Enum => Target::Enum, + DefKind::Struct => Target::Struct, + DefKind::Union => Target::Union, + DefKind::Trait => Target::Trait, + DefKind::TraitAlias => Target::TraitAlias, + DefKind::Impl => Target::Impl, + _ => panic!("impossible case reached"), + } + } + + pub fn from_trait_item(trait_item: &TraitItem<'_>) -> Target { + match trait_item.kind { + TraitItemKind::Const(..) => Target::AssocConst, + TraitItemKind::Fn(_, hir::TraitFn::Required(_)) => { + Target::Method(MethodKind::Trait { body: false }) + } + TraitItemKind::Fn(_, hir::TraitFn::Provided(_)) => { + Target::Method(MethodKind::Trait { body: true }) + } + TraitItemKind::Type(..) => Target::AssocTy, + } + } + + pub fn from_foreign_item(foreign_item: &hir::ForeignItem<'_>) -> Target { + match foreign_item.kind { + hir::ForeignItemKind::Fn(..) => Target::ForeignFn, + hir::ForeignItemKind::Static(..) => Target::ForeignStatic, + hir::ForeignItemKind::Type => Target::ForeignTy, + } + } + + pub fn from_generic_param(generic_param: &hir::GenericParam<'_>) -> Target { + match generic_param.kind { + hir::GenericParamKind::Type { .. } => Target::GenericParam(GenericParamKind::Type), + hir::GenericParamKind::Lifetime { .. } => { + Target::GenericParam(GenericParamKind::Lifetime) + } + hir::GenericParamKind::Const { .. } => Target::GenericParam(GenericParamKind::Const), + } + } + + pub fn name(self) -> &'static str { + match self { + Target::ExternCrate => "extern crate", + Target::Use => "use", + Target::Static => "static item", + Target::Const => "constant item", + Target::Fn => "function", + Target::Closure => "closure", + Target::Mod => "module", + Target::ForeignMod => "foreign module", + Target::GlobalAsm => "global asm", + Target::TyAlias => "type alias", + Target::OpaqueTy => "opaque type", + Target::Enum => "enum", + Target::Variant => "enum variant", + Target::Struct => "struct", + Target::Field => "struct field", + Target::Union => "union", + Target::Trait => "trait", + Target::TraitAlias => "trait alias", + Target::Impl => "implementation block", + Target::Expression => "expression", + Target::Statement => "statement", + Target::Arm => "match arm", + Target::AssocConst => "associated const", + Target::Method(kind) => match kind { + MethodKind::Inherent => "inherent method", + MethodKind::Trait { body: false } => "required trait method", + MethodKind::Trait { body: true } => "provided trait method", + }, + Target::AssocTy => "associated type", + Target::ForeignFn => "foreign function", + Target::ForeignStatic => "foreign static item", + Target::ForeignTy => "foreign type", + Target::GenericParam(kind) => match kind { + GenericParamKind::Type => "type parameter", + GenericParamKind::Lifetime => "lifetime parameter", + GenericParamKind::Const => "const parameter", + }, + Target::MacroDef => "macro def", + Target::Param => "function param", + } + } +} diff --git a/compiler/rustc_hir/src/tests.rs b/compiler/rustc_hir/src/tests.rs new file mode 100644 index 000000000..4636d5152 --- /dev/null +++ b/compiler/rustc_hir/src/tests.rs @@ -0,0 +1,36 @@ +use crate::definitions::{DefKey, DefPathData, DisambiguatedDefPathData}; +use rustc_span::def_id::{DefPathHash, StableCrateId}; + +#[test] +fn def_path_hash_depends_on_crate_id() { + // This test makes sure that *both* halves of a DefPathHash depend on + // the crate-id of the defining crate. This is a desirable property + // because the crate-id can be more easily changed than the DefPath + // of an item, so, in the case of a crate-local DefPathHash collision, + // the user can simply "role the dice again" for all DefPathHashes in + // the crate by changing the crate disambiguator (e.g. via bumping the + // crate's version number). + + let id0 = StableCrateId::new("foo", false, vec!["1".to_string()]); + let id1 = StableCrateId::new("foo", false, vec!["2".to_string()]); + + let h0 = mk_test_hash(id0); + let h1 = mk_test_hash(id1); + + assert_ne!(h0.stable_crate_id(), h1.stable_crate_id()); + assert_ne!(h0.local_hash(), h1.local_hash()); + + fn mk_test_hash(stable_crate_id: StableCrateId) -> DefPathHash { + let parent_hash = DefPathHash::new(stable_crate_id, 0); + + let key = DefKey { + parent: None, + disambiguated_data: DisambiguatedDefPathData { + data: DefPathData::CrateRoot, + disambiguator: 0, + }, + }; + + key.compute_stable_hash(parent_hash) + } +} diff --git a/compiler/rustc_hir/src/weak_lang_items.rs b/compiler/rustc_hir/src/weak_lang_items.rs new file mode 100644 index 000000000..b6a85c047 --- /dev/null +++ b/compiler/rustc_hir/src/weak_lang_items.rs @@ -0,0 +1,47 @@ +//! Validity checking for weak lang items + +use crate::def_id::DefId; +use crate::{lang_items, LangItem, LanguageItems}; + +use rustc_ast as ast; +use rustc_data_structures::fx::FxIndexMap; +use rustc_span::symbol::{sym, Symbol}; + +use std::sync::LazyLock; + +macro_rules! weak_lang_items { + ($($name:ident, $item:ident, $sym:ident;)*) => ( + +pub static WEAK_ITEMS_REFS: LazyLock> = LazyLock::new(|| { + let mut map = FxIndexMap::default(); + $(map.insert(sym::$name, LangItem::$item);)* + map +}); + +pub fn link_name(attrs: &[ast::Attribute]) -> Option +{ + lang_items::extract(attrs).and_then(|(name, _)| { + $(if name == sym::$name { + Some(sym::$sym) + } else)* { + None + } + }) +} + +impl LanguageItems { + pub fn is_weak_lang_item(&self, item_def_id: DefId) -> bool { + let did = Some(item_def_id); + + $(self.$name() == did)||* + } +} + +) } + +weak_lang_items! { + panic_impl, PanicImpl, rust_begin_unwind; + eh_personality, EhPersonality, rust_eh_personality; + eh_catch_typeinfo, EhCatchTypeinfo, rust_eh_catch_typeinfo; + oom, Oom, rust_oom; +} -- cgit v1.2.3