-#[cfg(feature = "in-rust-tree")]

-extern crate rustc_hashes;

-

-#[cfg(not(feature = "in-rust-tree"))]

-extern crate ra_ap_rustc_hashes as rustc_hashes;

-

-pub mod path;

-pub mod expander;

-pub mod lower;

-pub mod data;

-pub mod generics;

-use intern::Interned;

-mod pretty;

-use std::{

- hash::{Hash, Hasher},

- panic::{RefUnwindSafe, UnwindSafe},

-};

-use base_db::{

- impl_intern_key,

- ra_salsa::{self, InternValueTrivial},

- CrateId,

-};

- AstId, ExpandError, ExpandResult, ExpandTo, HirFileId, InFile, MacroCallId, MacroCallKind,

- MacroDefId, MacroDefKind,

-use span::{AstIdNode, Edition, FileAstId, SyntaxContextId};

-use syntax::{ast, AstNode};

-pub use hir_expand::{tt, Intern, Lookup};

- data::adt::VariantData,

-type FxIndexMap<K, V> =

- indexmap::IndexMap<K, V, std::hash::BuildHasherDefault<rustc_hash::FxHasher>>;

- impl_intern_key!($id);

- impl InternValueTrivial for $loc {}

-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]

-pub struct FunctionId(ra_salsa::InternId);

-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]

-pub struct StructId(ra_salsa::InternId);

-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]

-pub struct UnionId(ra_salsa::InternId);

-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]

-pub struct EnumId(ra_salsa::InternId);

-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]

-pub struct ConstId(ra_salsa::InternId);

-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]

-pub struct StaticId(ra_salsa::InternId);

-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]

-pub struct TraitId(ra_salsa::InternId);

-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]

-pub struct TraitAliasId(ra_salsa::InternId);

-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]

-pub struct TypeAliasId(ra_salsa::InternId);

-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]

-pub struct ImplId(ra_salsa::InternId);

-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]

-pub struct UseId(ra_salsa::InternId);

-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]

-pub struct ExternCrateId(ra_salsa::InternId);

-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]

-pub struct ExternBlockId(ra_salsa::InternId);

-pub struct EnumVariantId(ra_salsa::InternId);

-

-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]

-

-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]

-pub struct Macro2Id(ra_salsa::InternId);

-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]

-pub struct MacroRulesId(ra_salsa::InternId);

-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]

-pub struct ProcMacroId(ra_salsa::InternId);

-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]

-pub struct BlockId(ra_salsa::InternId);

-/// Id of the anonymous const block expression and patterns. This is very similar to `ClosureId` and

-/// shouldn't be a `DefWithBodyId` since its type inference is dependent on its parent.

-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]

-pub struct ConstBlockId(ra_salsa::InternId);

-impl_intern!(ConstBlockId, ConstBlockLoc, intern_anonymous_const, lookup_intern_anonymous_const);

-

-#[derive(Debug, Hash, PartialEq, Eq, Clone)]

-pub struct ConstBlockLoc {

- /// The parent of the anonymous const block.

- pub parent: DefWithBodyId,

- /// The root expression of this const block in the parent body.

- pub root: hir::ExprId,

-}

-

- krate: CrateId,

- pub fn krate(self) -> CrateId {

-impl From<CrateId> for CrateRootModuleId {

- fn from(krate: CrateId) -> Self {

- krate: CrateId,

- pub fn krate(self) -> CrateId {

- if *module_id == self.local_id {

- Some(name.clone())

- } else {

- None

- }

-pub type LocalFieldId = Idx<data::adt::FieldData>;

-

-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]

-impl InternValueTrivial for TypeOrConstParamId {}

-pub type LocalTypeOrConstParamId = Idx<generics::TypeOrConstParamData>;

-

-pub type LocalLifetimeParamId = Idx<generics::LifetimeParamData>;

-impl InternValueTrivial for LifetimeParamId {}

-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]

-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]

-/// Something that holds types, required for the current const arg lowering implementation as they

-/// need to be able to query where they are defined.

-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]

-pub enum TypeOwnerId {

- FunctionId(FunctionId),

- StaticId(StaticId),

- ConstId(ConstId),

- InTypeConstId(InTypeConstId),

- AdtId(AdtId),

- TraitId(TraitId),

- TraitAliasId(TraitAliasId),

- TypeAliasId(TypeAliasId),

- ImplId(ImplId),

- EnumVariantId(EnumVariantId),

-}

-

-impl TypeOwnerId {

- fn as_generic_def_id(self, db: &dyn DefDatabase) -> Option<GenericDefId> {

- Some(match self {

- TypeOwnerId::FunctionId(it) => GenericDefId::FunctionId(it),

- TypeOwnerId::ConstId(it) => GenericDefId::ConstId(it),

- TypeOwnerId::StaticId(it) => GenericDefId::StaticId(it),

- TypeOwnerId::AdtId(it) => GenericDefId::AdtId(it),

- TypeOwnerId::TraitId(it) => GenericDefId::TraitId(it),

- TypeOwnerId::TraitAliasId(it) => GenericDefId::TraitAliasId(it),

- TypeOwnerId::TypeAliasId(it) => GenericDefId::TypeAliasId(it),

- TypeOwnerId::ImplId(it) => GenericDefId::ImplId(it),

- TypeOwnerId::EnumVariantId(it) => {

- GenericDefId::AdtId(AdtId::EnumId(it.lookup(db).parent))

- }

- TypeOwnerId::InTypeConstId(_) => return None,

- })

- }

-}

-

-impl_from!(

- FunctionId,

- StaticId,

- ConstId,

- InTypeConstId,

- AdtId,

- TraitId,

- TraitAliasId,

- TypeAliasId,

- ImplId,

- EnumVariantId

- for TypeOwnerId

-);

-

-// Every `DefWithBodyId` is a type owner, since bodies can contain type (e.g. `{ let it: Type = _; }`)

-impl From<DefWithBodyId> for TypeOwnerId {

- fn from(value: DefWithBodyId) -> Self {

- match value {

- DefWithBodyId::FunctionId(it) => it.into(),

- DefWithBodyId::StaticId(it) => it.into(),

- DefWithBodyId::ConstId(it) => it.into(),

- DefWithBodyId::InTypeConstId(it) => it.into(),

- DefWithBodyId::VariantId(it) => it.into(),

- }

- }

-}

-

-impl From<GenericDefId> for TypeOwnerId {

- fn from(value: GenericDefId) -> Self {

- match value {

- GenericDefId::FunctionId(it) => it.into(),

- GenericDefId::AdtId(it) => it.into(),

- GenericDefId::TraitId(it) => it.into(),

- GenericDefId::TraitAliasId(it) => it.into(),

- GenericDefId::TypeAliasId(it) => it.into(),

- GenericDefId::ImplId(it) => it.into(),

- GenericDefId::ConstId(it) => it.into(),

- GenericDefId::StaticId(it) => it.into(),

- }

- }

-}

-

-// FIXME: This should not be a thing

-/// A thing that we want to store in interned ids, but we don't know its type in `hir-def`. This is

-/// currently only used in `InTypeConstId` for storing the type (which has type `Ty` defined in

-/// the `hir-ty` crate) of the constant in its id, which is a temporary hack so we may want

-/// to remove this after removing that.

-pub trait OpaqueInternableThing:

- std::any::Any + std::fmt::Debug + Sync + Send + UnwindSafe + RefUnwindSafe

-{

- fn as_any(&self) -> &dyn std::any::Any;

- fn box_any(&self) -> Box<dyn std::any::Any>;

- fn dyn_hash(&self, state: &mut dyn Hasher);

- fn dyn_eq(&self, other: &dyn OpaqueInternableThing) -> bool;

- fn dyn_clone(&self) -> Box<dyn OpaqueInternableThing>;

-}

-

-impl Hash for dyn OpaqueInternableThing {

- fn hash<H: Hasher>(&self, state: &mut H) {

- self.dyn_hash(state);

- }

-}

-

-impl PartialEq for dyn OpaqueInternableThing {

- fn eq(&self, other: &Self) -> bool {

- self.dyn_eq(other)

- }

-}

-

-impl Eq for dyn OpaqueInternableThing {}

-

-impl Clone for Box<dyn OpaqueInternableThing> {

- fn clone(&self) -> Self {

- self.dyn_clone()

- }

-}

-

-// FIXME(const-generic-body): Use an stable id for in type consts.

-//

-// The current id uses `AstId<ast::ConstArg>` which will be changed by every change in the code. Ideally

-// we should use an id which is relative to the type owner, so that every change will only invalidate the

-// id if it happens inside of the type owner.

-//

-// The solution probably is to have some query on `TypeOwnerId` to traverse its constant children and store

-// their `AstId` in a list (vector or arena), and use the index of that list in the id here. That query probably

-// needs name resolution, and might go far and handles the whole path lowering or type lowering for a `TypeOwnerId`.

-//

-// Whatever path the solution takes, it should answer 3 questions at the same time:

-// * Is the id stable enough?

-// * How to find a constant id using an ast node / position in the source code? This is needed when we want to

-// provide ide functionalities inside an in type const (which we currently don't support) e.g. go to definition

-// for a local defined there. A complex id might have some trouble in this reverse mapping.

-// * How to find the return type of a constant using its id? We have this data when we are doing type lowering

-// and the name of the struct that contains this constant is resolved, so a query that only traverses the

-// type owner by its syntax tree might have a hard time here.

-

-/// A constant in a type as a substitution for const generics (like `Foo<{ 2 + 2 }>`) or as an array

-/// length (like `[u8; 2 + 2]`). These constants are body owner and are a variant of `DefWithBodyId`. These

-/// are not called `AnonymousConstId` to prevent confusion with [`ConstBlockId`].

-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]

-pub struct InTypeConstId(ra_salsa::InternId);

-impl_intern!(InTypeConstId, InTypeConstLoc, intern_in_type_const, lookup_intern_in_type_const);

-

-// We would like to set `derive(PartialEq)`

-// but the compiler complains about that `.expected_ty` does not implement the `Copy` trait.

-#[allow(clippy::derived_hash_with_manual_eq)]

-#[derive(Debug, Hash, Eq, Clone)]

-pub struct InTypeConstLoc {

- pub id: AstId<ast::ConstArg>,

- /// The thing this const arg appears in

- pub owner: TypeOwnerId,

- // FIXME(const-generic-body): The expected type should not be

- pub expected_ty: Box<dyn OpaqueInternableThing>,

-}

-

-impl PartialEq for InTypeConstLoc {

- fn eq(&self, other: &Self) -> bool {

- self.id == other.id && self.owner == other.owner && *self.expected_ty == *other.expected_ty

- }

-}

-

-impl InTypeConstId {

- pub fn source(&self, db: &dyn DefDatabase) -> ast::ConstArg {

- let src = self.lookup(db).id;

- let file_id = src.file_id;

- let root = &db.parse_or_expand(file_id);

- db.ast_id_map(file_id).get(src.value).to_node(root)

- }

-}

-

-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]

- ConstBlockId(ConstBlockId),

- InTypeConstId(InTypeConstId),

-impl_from!(ConstId, StaticId, ConstBlockId, InTypeConstId for GeneralConstId);

- pub fn generic_def(self, db: &dyn DefDatabase) -> Option<GenericDefId> {

- GeneralConstId::ConstBlockId(it) => it.lookup(db).parent.as_generic_def_id(db),

- GeneralConstId::InTypeConstId(it) => it.lookup(db).owner.as_generic_def_id(db),

- db.static_data(it).name.display(db.upcast(), Edition::CURRENT).to_string()

- GeneralConstId::ConstId(const_id) => db

- .const_data(const_id)

- .name

- .as_ref()

- .map(|it| it.as_str())

- .unwrap_or("_")

- .to_owned(),

- GeneralConstId::ConstBlockId(id) => format!("{{anonymous const {id:?}}}"),

- GeneralConstId::InTypeConstId(id) => format!("{{in type const {id:?}}}"),

-/// The defs which have a body.

-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]

- InTypeConstId(InTypeConstId),

-

-impl_from!(FunctionId, ConstId, StaticId, InTypeConstId for DefWithBodyId);

- // FIXME: stable rust doesn't allow generics in constants, but we should

- // use `TypeOwnerId::as_generic_def_id` when it does.

- DefWithBodyId::InTypeConstId(_) => None,

-#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]

- def: impl for<'db> Lookup<Database<'db> = dyn DefDatabase + 'db, Data = Loc>,

-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]

-impl InternValueTrivial for CallableDefId {}

-

- pub fn krate(self, db: &dyn DefDatabase) -> CrateId {

-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]

- pub fn variant_data(self, db: &dyn DefDatabase) -> Arc<VariantData> {

- match self {

- VariantId::StructId(it) => db.struct_data(it).variant_data.clone(),

- VariantId::UnionId(it) => db.union_data(it).variant_data.clone(),

- VariantId::EnumVariantId(it) => db.enum_variant_data(it).variant_data.clone(),

- }

- fn krate(&self, db: &dyn DefDatabase) -> CrateId {

- ItemId: for<'db> Lookup<Database<'db> = dyn DefDatabase + 'db, Data = ItemLoc<N>> + Copy,

- id: impl Lookup<Database<'db> = dyn DefDatabase + 'db, Data = AssocItemLoc<impl ItemTreeNode>>,

-impl HasModule for TypeOwnerId {

- fn module(&self, db: &dyn DefDatabase) -> ModuleId {

- match *self {

- TypeOwnerId::FunctionId(it) => it.module(db),

- TypeOwnerId::StaticId(it) => it.module(db),

- TypeOwnerId::ConstId(it) => it.module(db),

- TypeOwnerId::AdtId(it) => it.module(db),

- TypeOwnerId::TraitId(it) => it.module(db),

- TypeOwnerId::TraitAliasId(it) => it.module(db),

- TypeOwnerId::TypeAliasId(it) => it.module(db),

- TypeOwnerId::ImplId(it) => it.module(db),

- TypeOwnerId::EnumVariantId(it) => it.module(db),

- TypeOwnerId::InTypeConstId(it) => it.lookup(db).owner.module(db),

- }

- }

-}

-

- DefWithBodyId::InTypeConstId(it) => it.lookup(db).owner.module(db),

-pub trait AsMacroCall {

- fn as_call_id(

- &self,

- db: &dyn ExpandDatabase,

- krate: CrateId,

- resolver: impl Fn(&path::ModPath) -> Option<MacroDefId> + Copy,

- ) -> Option<MacroCallId> {

- self.as_call_id_with_errors(db, krate, resolver).ok()?.value

- }

-

- krate: CrateId,

- resolver: impl Fn(&path::ModPath) -> Option<MacroDefId> + Copy,

- krate: CrateId,

- resolver: impl Fn(&path::ModPath) -> Option<MacroDefId> + Copy,

- let mod_path = path::ModPath::from_src(db, path, &mut |range| {

- path: Interned<path::ModPath>,

- fn new(

- file_id: HirFileId,

- ast_id: FileAstId<T>,

- path: Interned<path::ModPath>,

- ) -> AstIdWithPath<T> {

- call_site: SyntaxContextId,

- krate: CrateId,

- resolver: impl Fn(&path::ModPath) -> Option<MacroDefId> + Copy,

- path: &path::ModPath,

- call_site: SyntaxContextId,

- krate: CrateId,

- resolver: impl FnOnce(&path::ModPath) -> Option<MacroDefId>,

- eager_resolver: impl Fn(&path::ModPath) -> Option<MacroDefId>,

- pub path: hir_expand::mod_path::ModPath,