[rustc.git] / src / tools / rust-analyzer / crates / hir-def / src / db.rs

//! Defines database & queries for name resolution.
use std::sync::Arc;

use base_db::{salsa, CrateId, SourceDatabase, Upcast};
use either::Either;
use hir_expand::{db::AstDatabase, HirFileId};
use la_arena::ArenaMap;
use syntax::{ast, AstPtr, SmolStr};

use crate::{
    adt::{EnumData, StructData},
    attr::{Attrs, AttrsWithOwner},
    body::{scope::ExprScopes, Body, BodySourceMap},
    data::{
        ConstData, FunctionData, ImplData, Macro2Data, MacroRulesData, ProcMacroData, StaticData,
        TraitData, TypeAliasData,
    },
    generics::GenericParams,
    import_map::ImportMap,
    intern::Interned,
    item_tree::{AttrOwner, ItemTree},
    lang_item::{LangItemTarget, LangItems},
    nameres::{diagnostics::DefDiagnostic, DefMap},
    visibility::{self, Visibility},
    AttrDefId, BlockId, BlockLoc, ConstId, ConstLoc, DefWithBodyId, EnumId, EnumLoc, ExternBlockId,
    ExternBlockLoc, FunctionId, FunctionLoc, GenericDefId, ImplId, ImplLoc, LocalEnumVariantId,
    LocalFieldId, Macro2Id, Macro2Loc, MacroRulesId, MacroRulesLoc, ProcMacroId, ProcMacroLoc,
    StaticId, StaticLoc, StructId, StructLoc, TraitId, TraitLoc, TypeAliasId, TypeAliasLoc,
    UnionId, UnionLoc, VariantId,
};

#[salsa::query_group(InternDatabaseStorage)]
pub trait InternDatabase: SourceDatabase {
    #[salsa::interned]
    fn intern_function(&self, loc: FunctionLoc) -> FunctionId;
    #[salsa::interned]
    fn intern_struct(&self, loc: StructLoc) -> StructId;
    #[salsa::interned]
    fn intern_union(&self, loc: UnionLoc) -> UnionId;
    #[salsa::interned]
    fn intern_enum(&self, loc: EnumLoc) -> EnumId;
    #[salsa::interned]
    fn intern_const(&self, loc: ConstLoc) -> ConstId;
    #[salsa::interned]
    fn intern_static(&self, loc: StaticLoc) -> StaticId;
    #[salsa::interned]
    fn intern_trait(&self, loc: TraitLoc) -> TraitId;
    #[salsa::interned]
    fn intern_type_alias(&self, loc: TypeAliasLoc) -> TypeAliasId;
    #[salsa::interned]
    fn intern_impl(&self, loc: ImplLoc) -> ImplId;
    #[salsa::interned]
    fn intern_extern_block(&self, loc: ExternBlockLoc) -> ExternBlockId;
    #[salsa::interned]
    fn intern_block(&self, loc: BlockLoc) -> BlockId;
    #[salsa::interned]
    fn intern_macro2(&self, loc: Macro2Loc) -> Macro2Id;
    #[salsa::interned]
    fn intern_proc_macro(&self, loc: ProcMacroLoc) -> ProcMacroId;
    #[salsa::interned]
    fn intern_macro_rules(&self, loc: MacroRulesLoc) -> MacroRulesId;
}

#[salsa::query_group(DefDatabaseStorage)]
pub trait DefDatabase: InternDatabase + AstDatabase + Upcast<dyn AstDatabase> {
    #[salsa::input]
    fn enable_proc_attr_macros(&self) -> bool;

    #[salsa::invoke(ItemTree::file_item_tree_query)]
    fn file_item_tree(&self, file_id: HirFileId) -> Arc<ItemTree>;

    #[salsa::invoke(crate_def_map_wait)]
    #[salsa::transparent]
    fn crate_def_map(&self, krate: CrateId) -> Arc<DefMap>;

    #[salsa::invoke(DefMap::crate_def_map_query)]
    fn crate_def_map_query(&self, krate: CrateId) -> Arc<DefMap>;

    /// Computes the block-level `DefMap`, returning `None` when `block` doesn't contain any inner
    /// items directly.
    ///
    /// For example:
    ///
    /// ```
    /// fn f() { // (0)
    ///     { // (1)
    ///         fn inner() {}
    ///     }
    /// }
    /// ```
    ///
    /// The `block_def_map` for block 0 would return `None`, while `block_def_map` of block 1 would
    /// return a `DefMap` containing `inner`.
    #[salsa::invoke(DefMap::block_def_map_query)]
    fn block_def_map(&self, block: BlockId) -> Option<Arc<DefMap>>;

    #[salsa::invoke(StructData::struct_data_query)]
    fn struct_data(&self, id: StructId) -> Arc<StructData>;

    #[salsa::invoke(StructData::union_data_query)]
    fn union_data(&self, id: UnionId) -> Arc<StructData>;

    #[salsa::invoke(EnumData::enum_data_query)]
    fn enum_data(&self, e: EnumId) -> Arc<EnumData>;

    #[salsa::invoke(ImplData::impl_data_query)]
    fn impl_data(&self, e: ImplId) -> Arc<ImplData>;

    #[salsa::invoke(ImplData::impl_data_with_diagnostics_query)]
    fn impl_data_with_diagnostics(&self, e: ImplId) -> (Arc<ImplData>, Arc<Vec<DefDiagnostic>>);

    #[salsa::invoke(TraitData::trait_data_query)]
    fn trait_data(&self, e: TraitId) -> Arc<TraitData>;

    #[salsa::invoke(TraitData::trait_data_with_diagnostics_query)]
    fn trait_data_with_diagnostics(&self, tr: TraitId)
        -> (Arc<TraitData>, Arc<Vec<DefDiagnostic>>);

    #[salsa::invoke(TypeAliasData::type_alias_data_query)]
    fn type_alias_data(&self, e: TypeAliasId) -> Arc<TypeAliasData>;

    #[salsa::invoke(FunctionData::fn_data_query)]
    fn function_data(&self, func: FunctionId) -> Arc<FunctionData>;

    #[salsa::invoke(ConstData::const_data_query)]
    fn const_data(&self, konst: ConstId) -> Arc<ConstData>;

    #[salsa::invoke(StaticData::static_data_query)]
    fn static_data(&self, konst: StaticId) -> Arc<StaticData>;

    #[salsa::invoke(Macro2Data::macro2_data_query)]
    fn macro2_data(&self, makro: Macro2Id) -> Arc<Macro2Data>;

    #[salsa::invoke(MacroRulesData::macro_rules_data_query)]
    fn macro_rules_data(&self, makro: MacroRulesId) -> Arc<MacroRulesData>;

    #[salsa::invoke(ProcMacroData::proc_macro_data_query)]
    fn proc_macro_data(&self, makro: ProcMacroId) -> Arc<ProcMacroData>;

    #[salsa::invoke(Body::body_with_source_map_query)]
    fn body_with_source_map(&self, def: DefWithBodyId) -> (Arc<Body>, Arc<BodySourceMap>);

    #[salsa::invoke(Body::body_query)]
    fn body(&self, def: DefWithBodyId) -> Arc<Body>;

    #[salsa::invoke(ExprScopes::expr_scopes_query)]
    fn expr_scopes(&self, def: DefWithBodyId) -> Arc<ExprScopes>;

    #[salsa::invoke(GenericParams::generic_params_query)]
    fn generic_params(&self, def: GenericDefId) -> Interned<GenericParams>;

    #[salsa::invoke(Attrs::variants_attrs_query)]
    fn variants_attrs(&self, def: EnumId) -> Arc<ArenaMap<LocalEnumVariantId, Attrs>>;

    #[salsa::invoke(Attrs::fields_attrs_query)]
    fn fields_attrs(&self, def: VariantId) -> Arc<ArenaMap<LocalFieldId, Attrs>>;

    #[salsa::invoke(crate::attr::variants_attrs_source_map)]
    fn variants_attrs_source_map(
        &self,
        def: EnumId,
    ) -> Arc<ArenaMap<LocalEnumVariantId, AstPtr<ast::Variant>>>;

    #[salsa::invoke(crate::attr::fields_attrs_source_map)]
    fn fields_attrs_source_map(
        &self,
        def: VariantId,
    ) -> Arc<ArenaMap<LocalFieldId, Either<AstPtr<ast::TupleField>, AstPtr<ast::RecordField>>>>;

    #[salsa::invoke(AttrsWithOwner::attrs_query)]
    fn attrs(&self, def: AttrDefId) -> AttrsWithOwner;

    #[salsa::invoke(LangItems::crate_lang_items_query)]
    fn crate_lang_items(&self, krate: CrateId) -> Arc<LangItems>;

    #[salsa::invoke(LangItems::lang_item_query)]
    fn lang_item(&self, start_crate: CrateId, item: SmolStr) -> Option<LangItemTarget>;

    #[salsa::invoke(ImportMap::import_map_query)]
    fn import_map(&self, krate: CrateId) -> Arc<ImportMap>;

    #[salsa::invoke(visibility::field_visibilities_query)]
    fn field_visibilities(&self, var: VariantId) -> Arc<ArenaMap<LocalFieldId, Visibility>>;

    // FIXME: unify function_visibility and const_visibility?
    #[salsa::invoke(visibility::function_visibility_query)]
    fn function_visibility(&self, def: FunctionId) -> Visibility;

    #[salsa::invoke(visibility::const_visibility_query)]
    fn const_visibility(&self, def: ConstId) -> Visibility;

    #[salsa::transparent]
    fn crate_limits(&self, crate_id: CrateId) -> CrateLimits;

    fn crate_supports_no_std(&self, crate_id: CrateId) -> bool;
}

fn crate_def_map_wait(db: &dyn DefDatabase, krate: CrateId) -> Arc<DefMap> {
    let _p = profile::span("crate_def_map:wait");
    db.crate_def_map_query(krate)
}

pub struct CrateLimits {
    /// The maximum depth for potentially infinitely-recursive compile-time operations like macro expansion or auto-dereference.
    pub recursion_limit: u32,
}

fn crate_limits(db: &dyn DefDatabase, crate_id: CrateId) -> CrateLimits {
    let def_map = db.crate_def_map(crate_id);

    CrateLimits {
        // 128 is the default in rustc.
        recursion_limit: def_map.recursion_limit().unwrap_or(128),
    }
}

fn crate_supports_no_std(db: &dyn DefDatabase, crate_id: CrateId) -> bool {
    let file = db.crate_graph()[crate_id].root_file_id;
    let item_tree = db.file_item_tree(file.into());
    let attrs = item_tree.raw_attrs(AttrOwner::TopLevel);
    for attr in &**attrs {
        match attr.path().as_ident().and_then(|id| id.as_text()) {
            Some(ident) if ident == "no_std" => return true,
            Some(ident) if ident == "cfg_attr" => {}
            _ => continue,
        }

        // This is a `cfg_attr`; check if it could possibly expand to `no_std`.
        // Syntax is: `#[cfg_attr(condition(cfg, style), attr0, attr1, <...>)]`
        let tt = match attr.token_tree_value() {
            Some(tt) => &tt.token_trees,
            None => continue,
        };

        let segments = tt.split(|tt| match tt {
            tt::TokenTree::Leaf(tt::Leaf::Punct(p)) if p.char == ',' => true,
            _ => false,
        });
        for output in segments.skip(1) {
            match output {
                [tt::TokenTree::Leaf(tt::Leaf::Ident(ident))] if ident.text == "no_std" => {
                    return true
                }
                _ => {}
            }
        }
    }

    false
}
Commit	Line	Data
064997fb FG	1	//! Defines database & queries for name resolution.
	2	use std::sync::Arc;
	3
	4	use base_db::{salsa, CrateId, SourceDatabase, Upcast};
	5	use either::Either;
	6	use hir_expand::{db::AstDatabase, HirFileId};
	7	use la_arena::ArenaMap;
	8	use syntax::{ast, AstPtr, SmolStr};
	9
	10	use crate::{
	11	adt::{EnumData, StructData},
	12	attr::{Attrs, AttrsWithOwner},
	13	body::{scope::ExprScopes, Body, BodySourceMap},
	14	data::{
	15	ConstData, FunctionData, ImplData, Macro2Data, MacroRulesData, ProcMacroData, StaticData,
	16	TraitData, TypeAliasData,
	17	},
	18	generics::GenericParams,
	19	import_map::ImportMap,
	20	intern::Interned,
	21	item_tree::{AttrOwner, ItemTree},
	22	lang_item::{LangItemTarget, LangItems},
f2b60f7d	23	nameres::{diagnostics::DefDiagnostic, DefMap},
064997fb FG	24	visibility::{self, Visibility},
	25	AttrDefId, BlockId, BlockLoc, ConstId, ConstLoc, DefWithBodyId, EnumId, EnumLoc, ExternBlockId,
	26	ExternBlockLoc, FunctionId, FunctionLoc, GenericDefId, ImplId, ImplLoc, LocalEnumVariantId,
	27	LocalFieldId, Macro2Id, Macro2Loc, MacroRulesId, MacroRulesLoc, ProcMacroId, ProcMacroLoc,
	28	StaticId, StaticLoc, StructId, StructLoc, TraitId, TraitLoc, TypeAliasId, TypeAliasLoc,
	29	UnionId, UnionLoc, VariantId,
	30	};
	31
	32	#[salsa::query_group(InternDatabaseStorage)]
	33	pub trait InternDatabase: SourceDatabase {
	34	#[salsa::interned]
	35	fn intern_function(&self, loc: FunctionLoc) -> FunctionId;
	36	#[salsa::interned]
	37	fn intern_struct(&self, loc: StructLoc) -> StructId;
	38	#[salsa::interned]
	39	fn intern_union(&self, loc: UnionLoc) -> UnionId;
	40	#[salsa::interned]
	41	fn intern_enum(&self, loc: EnumLoc) -> EnumId;
	42	#[salsa::interned]
	43	fn intern_const(&self, loc: ConstLoc) -> ConstId;
	44	#[salsa::interned]
	45	fn intern_static(&self, loc: StaticLoc) -> StaticId;
	46	#[salsa::interned]
	47	fn intern_trait(&self, loc: TraitLoc) -> TraitId;
	48	#[salsa::interned]
	49	fn intern_type_alias(&self, loc: TypeAliasLoc) -> TypeAliasId;
	50	#[salsa::interned]
	51	fn intern_impl(&self, loc: ImplLoc) -> ImplId;
	52	#[salsa::interned]
	53	fn intern_extern_block(&self, loc: ExternBlockLoc) -> ExternBlockId;
	54	#[salsa::interned]
	55	fn intern_block(&self, loc: BlockLoc) -> BlockId;
	56	#[salsa::interned]
	57	fn intern_macro2(&self, loc: Macro2Loc) -> Macro2Id;
	58	#[salsa::interned]
	59	fn intern_proc_macro(&self, loc: ProcMacroLoc) -> ProcMacroId;
	60	#[salsa::interned]
	61	fn intern_macro_rules(&self, loc: MacroRulesLoc) -> MacroRulesId;
	62	}
	63
	64	#[salsa::query_group(DefDatabaseStorage)]
	65	pub trait DefDatabase: InternDatabase + AstDatabase + Upcast<dyn AstDatabase> {
	66	#[salsa::input]
	67	fn enable_proc_attr_macros(&self) -> bool;
	68
	69	#[salsa::invoke(ItemTree::file_item_tree_query)]
	70	fn file_item_tree(&self, file_id: HirFileId) -> Arc<ItemTree>;
	71
	72	#[salsa::invoke(crate_def_map_wait)]
	73	#[salsa::transparent]
	74	fn crate_def_map(&self, krate: CrateId) -> Arc<DefMap>;
	75
	76	#[salsa::invoke(DefMap::crate_def_map_query)]
	77	fn crate_def_map_query(&self, krate: CrateId) -> Arc<DefMap>;
	78
	79	/// Computes the block-level `DefMap`, returning `None` when `block` doesn't contain any inner
	80	/// items directly.
	81	///
	82	/// For example:
	83	///
	84	/// ```
	85	/// fn f() { // (0)
	86	/// { // (1)
	87	/// fn inner() {}
88	/// }
89	/// }
90	/// ```
91	///
92	/// The `block_def_map` for block 0 would return `None`, while `block_def_map` of block 1 would
93	/// return a `DefMap` containing `inner`.
94	#[salsa::invoke(DefMap::block_def_map_query)]
95	fn block_def_map(&self, block: BlockId) -> Option<Arc<DefMap>>;
96
97	#[salsa::invoke(StructData::struct_data_query)]
98	fn struct_data(&self, id: StructId) -> Arc<StructData>;
99
100	#[salsa::invoke(StructData::union_data_query)]
101	fn union_data(&self, id: UnionId) -> Arc<StructData>;
102
103	#[salsa::invoke(EnumData::enum_data_query)]
104	fn enum_data(&self, e: EnumId) -> Arc<EnumData>;
105
106	#[salsa::invoke(ImplData::impl_data_query)]
107	fn impl_data(&self, e: ImplId) -> Arc<ImplData>;
108
f2b60f7d FG	109	#[salsa::invoke(ImplData::impl_data_with_diagnostics_query)]
	110	fn impl_data_with_diagnostics(&self, e: ImplId) -> (Arc<ImplData>, Arc<Vec<DefDiagnostic>>);
	111
064997fb FG	112	#[salsa::invoke(TraitData::trait_data_query)]
	113	fn trait_data(&self, e: TraitId) -> Arc<TraitData>;
	114
f2b60f7d FG	115	#[salsa::invoke(TraitData::trait_data_with_diagnostics_query)]
	116	fn trait_data_with_diagnostics(&self, tr: TraitId)
	117	-> (Arc<TraitData>, Arc<Vec<DefDiagnostic>>);
	118
064997fb FG	119	#[salsa::invoke(TypeAliasData::type_alias_data_query)]
	120	fn type_alias_data(&self, e: TypeAliasId) -> Arc<TypeAliasData>;
	121
	122	#[salsa::invoke(FunctionData::fn_data_query)]
	123	fn function_data(&self, func: FunctionId) -> Arc<FunctionData>;
	124
	125	#[salsa::invoke(ConstData::const_data_query)]
	126	fn const_data(&self, konst: ConstId) -> Arc<ConstData>;
	127
	128	#[salsa::invoke(StaticData::static_data_query)]
	129	fn static_data(&self, konst: StaticId) -> Arc<StaticData>;
	130
	131	#[salsa::invoke(Macro2Data::macro2_data_query)]
	132	fn macro2_data(&self, makro: Macro2Id) -> Arc<Macro2Data>;
	133
	134	#[salsa::invoke(MacroRulesData::macro_rules_data_query)]
	135	fn macro_rules_data(&self, makro: MacroRulesId) -> Arc<MacroRulesData>;
	136
	137	#[salsa::invoke(ProcMacroData::proc_macro_data_query)]
	138	fn proc_macro_data(&self, makro: ProcMacroId) -> Arc<ProcMacroData>;
	139
	140	#[salsa::invoke(Body::body_with_source_map_query)]
	141	fn body_with_source_map(&self, def: DefWithBodyId) -> (Arc<Body>, Arc<BodySourceMap>);
	142
	143	#[salsa::invoke(Body::body_query)]
	144	fn body(&self, def: DefWithBodyId) -> Arc<Body>;
	145
	146	#[salsa::invoke(ExprScopes::expr_scopes_query)]
	147	fn expr_scopes(&self, def: DefWithBodyId) -> Arc<ExprScopes>;
	148
	149	#[salsa::invoke(GenericParams::generic_params_query)]
	150	fn generic_params(&self, def: GenericDefId) -> Interned<GenericParams>;
	151
	152	#[salsa::invoke(Attrs::variants_attrs_query)]
	153	fn variants_attrs(&self, def: EnumId) -> Arc<ArenaMap<LocalEnumVariantId, Attrs>>;
	154
	155	#[salsa::invoke(Attrs::fields_attrs_query)]
	156	fn fields_attrs(&self, def: VariantId) -> Arc<ArenaMap<LocalFieldId, Attrs>>;
	157
	158	#[salsa::invoke(crate::attr::variants_attrs_source_map)]
	159	fn variants_attrs_source_map(
	160	&self,
	161	def: EnumId,
	162	) -> Arc<ArenaMap<LocalEnumVariantId, AstPtr<ast::Variant>>>;
	163
	164	#[salsa::invoke(crate::attr::fields_attrs_source_map)]
	165	fn fields_attrs_source_map(
	166	&self,
	167	def: VariantId,
	168	) -> Arc<ArenaMap<LocalFieldId, Either<AstPtr<ast::TupleField>, AstPtr<ast::RecordField>>>>;
	169
	170	#[salsa::invoke(AttrsWithOwner::attrs_query)]
	171	fn attrs(&self, def: AttrDefId) -> AttrsWithOwner;
	172
	173	#[salsa::invoke(LangItems::crate_lang_items_query)]
	174	fn crate_lang_items(&self, krate: CrateId) -> Arc<LangItems>;
	175
	176	#[salsa::invoke(LangItems::lang_item_query)]
	177	fn lang_item(&self, start_crate: CrateId, item: SmolStr) -> Option<LangItemTarget>;
	178
	179	#[salsa::invoke(ImportMap::import_map_query)]
	180	fn import_map(&self, krate: CrateId) -> Arc<ImportMap>;
	181
	182	#[salsa::invoke(visibility::field_visibilities_query)]
183	fn field_visibilities(&self, var: VariantId) -> Arc<ArenaMap<LocalFieldId, Visibility>>;
184
185	// FIXME: unify function_visibility and const_visibility?
186	#[salsa::invoke(visibility::function_visibility_query)]
187	fn function_visibility(&self, def: FunctionId) -> Visibility;
188
189	#[salsa::invoke(visibility::const_visibility_query)]
190	fn const_visibility(&self, def: ConstId) -> Visibility;
191
192	#[salsa::transparent]
193	fn crate_limits(&self, crate_id: CrateId) -> CrateLimits;
194
195	fn crate_supports_no_std(&self, crate_id: CrateId) -> bool;
196	}
197
198	fn crate_def_map_wait(db: &dyn DefDatabase, krate: CrateId) -> Arc<DefMap> {
199	let _p = profile::span("crate_def_map:wait");
200	db.crate_def_map_query(krate)
201	}
202
203	pub struct CrateLimits {
204	/// The maximum depth for potentially infinitely-recursive compile-time operations like macro expansion or auto-dereference.
205	pub recursion_limit: u32,
206	}
207
208	fn crate_limits(db: &dyn DefDatabase, crate_id: CrateId) -> CrateLimits {
209	let def_map = db.crate_def_map(crate_id);
210
211	CrateLimits {
212	// 128 is the default in rustc.
213	recursion_limit: def_map.recursion_limit().unwrap_or(128),
214	}
215	}
216
217	fn crate_supports_no_std(db: &dyn DefDatabase, crate_id: CrateId) -> bool {
218	let file = db.crate_graph()[crate_id].root_file_id;
219	let item_tree = db.file_item_tree(file.into());
220	let attrs = item_tree.raw_attrs(AttrOwner::TopLevel);
221	for attr in &**attrs {
222	match attr.path().as_ident().and_then(\|id\| id.as_text()) {
223	Some(ident) if ident == "no_std" => return true,
224	Some(ident) if ident == "cfg_attr" => {}
225	_ => continue,
226	}
227
228	// This is a `cfg_attr`; check if it could possibly expand to `no_std`.
229	// Syntax is: `#[cfg_attr(condition(cfg, style), attr0, attr1, <...>)]`
230	let tt = match attr.token_tree_value() {
231	Some(tt) => &tt.token_trees,
232	None => continue,
233	};
234
235	let segments = tt.split(\|tt\| match tt {
236	tt::TokenTree::Leaf(tt::Leaf::Punct(p)) if p.char == ',' => true,
237	_ => false,
238	});
239	for output in segments.skip(1) {
240	match output {
241	[tt::TokenTree::Leaf(tt::Leaf::Ident(ident))] if ident.text == "no_std" => {
242	return true
243	}
244	_ => {}
245	}
246	}
247	}
248
249	false
250	}