cairo_lang_defs/
db.rs

1use std::collections::VecDeque;
2use std::sync::Arc;
3
4use cairo_lang_diagnostics::{
5    DiagnosticNote, Maybe, MaybeAsRef, PluginFileDiagnosticNotes, ToMaybe, skip_diagnostic,
6};
7use cairo_lang_filesystem::db::{ExtAsVirtual, FilesGroup, files_group_input};
8use cairo_lang_filesystem::ids::{
9    CrateId, CrateInput, Directory, FileId, FileKind, FileLongId, SmolStrId, Tracked, VirtualFile,
10};
11use cairo_lang_parser::db::ParserGroup;
12use cairo_lang_syntax::attribute::consts::{
13    ALLOW_ATTR, ALLOW_ATTR_ATTR, DEPRECATED_ATTR, FEATURE_ATTR, FMT_SKIP_ATTR,
14    IMPLICIT_PRECEDENCE_ATTR, INLINE_ATTR, INTERNAL_ATTR, MUST_USE_ATTR, PATH_ATTR, PHANTOM_ATTR,
15    STARKNET_INTERFACE_ATTR, UNSTABLE_ATTR,
16};
17use cairo_lang_syntax::attribute::structured::AttributeStructurize;
18use cairo_lang_syntax::node::ast::MaybeModuleBody;
19use cairo_lang_syntax::node::helpers::QueryAttrs;
20use cairo_lang_syntax::node::ids::SyntaxStablePtrId;
21use cairo_lang_syntax::node::{Terminal, TypedStablePtr, TypedSyntaxNode, ast};
22use cairo_lang_utils::Intern;
23use cairo_lang_utils::ordered_hash_map::OrderedHashMap;
24use cairo_lang_utils::ordered_hash_set::OrderedHashSet;
25use itertools::{Itertools, chain};
26use salsa::{Database, Setter};
27
28use crate::cache::{DefCacheLoadingData, load_cached_crate_modules};
29use crate::ids::*;
30use crate::plugin::{DynGeneratedFileAuxData, MacroPlugin, MacroPluginMetadata, PluginDiagnostic};
31use crate::plugin_utils::try_extract_unnamed_arg;
32
33#[salsa::input]
34pub struct DefsGroupInput {
35    #[returns(ref)]
36    pub default_macro_plugins: Option<Vec<MacroPluginLongId>>,
37    #[returns(ref)]
38    pub macro_plugin_overrides: Option<OrderedHashMap<CrateInput, Arc<[MacroPluginLongId]>>>,
39    #[returns(ref)]
40    pub default_inline_macro_plugins: Option<OrderedHashMap<String, InlineMacroExprPluginLongId>>,
41    #[returns(ref)]
42    pub inline_macro_plugin_overrides: Option<
43        OrderedHashMap<CrateInput, Arc<OrderedHashMap<String, InlineMacroExprPluginLongId>>>,
44    >,
45}
46
47/// Returns a reference to the inputs of [DefsGroup].
48/// The reference is also used to set the inputs to new values.
49#[salsa::tracked(returns(ref))]
50pub fn defs_group_input(db: &dyn Database) -> DefsGroupInput {
51    DefsGroupInput::new(db, None, None, None, None)
52}
53
54/// Salsa database interface.
55/// See [`super::ids`] for further details.
56pub trait DefsGroup: Database {
57    fn default_macro_plugins_input(&self) -> &[MacroPluginLongId] {
58        defs_group_input(self.as_dyn_database()).default_macro_plugins(self).as_ref().unwrap()
59    }
60
61    fn macro_plugin_overrides_input(
62        &self,
63    ) -> &OrderedHashMap<CrateInput, Arc<[MacroPluginLongId]>> {
64        defs_group_input(self.as_dyn_database()).macro_plugin_overrides(self).as_ref().unwrap()
65    }
66
67    fn inline_macro_plugin_overrides_input(
68        &self,
69    ) -> &OrderedHashMap<CrateInput, Arc<OrderedHashMap<String, InlineMacroExprPluginLongId>>> {
70        defs_group_input(self.as_dyn_database())
71            .inline_macro_plugin_overrides(self)
72            .as_ref()
73            .unwrap()
74    }
75
76    fn default_inline_macro_plugins_input(
77        &self,
78    ) -> &OrderedHashMap<String, InlineMacroExprPluginLongId> {
79        defs_group_input(self.as_dyn_database())
80            .default_inline_macro_plugins(self)
81            .as_ref()
82            .unwrap()
83    }
84
85    // Plugins.
86    // ========
87
88    /// Interned version of `default_macro_plugins_input`.
89    fn default_macro_plugins<'db>(&'db self) -> &'db [MacroPluginId<'db>] {
90        default_macro_plugins(self.as_dyn_database())
91    }
92
93    /// Interned version of `macro_plugin_overrides_input`.
94    fn macro_plugin_overrides<'db>(
95        &'db self,
96    ) -> &'db OrderedHashMap<CrateId<'db>, Vec<MacroPluginId<'db>>> {
97        macro_plugin_overrides(self.as_dyn_database())
98    }
99
100    /// Returns [`MacroPluginId`]s of the plugins set for the crate with [`CrateId`].
101    /// Provides an override if it has been set with
102    /// [`DefsGroupEx::set_override_crate_macro_plugins`] or the default
103    /// ([`DefsGroup::default_macro_plugins`]) otherwise.
104    fn crate_macro_plugins<'db>(&'db self, crate_id: CrateId<'db>) -> &'db [MacroPluginId<'db>] {
105        crate_macro_plugins(self.as_dyn_database(), crate_id)
106    }
107
108    /// Interned version of `default_inline_macro_plugins_input`.
109    fn default_inline_macro_plugins<'db>(
110        &'db self,
111    ) -> &'db OrderedHashMap<String, InlineMacroExprPluginId<'db>> {
112        default_inline_macro_plugins(self.as_dyn_database())
113    }
114
115    /// Interned version of `inline_macro_plugin_overrides_input`.
116    fn inline_macro_plugin_overrides<'db>(
117        &'db self,
118    ) -> &'db OrderedHashMap<CrateId<'db>, OrderedHashMap<String, InlineMacroExprPluginId<'db>>>
119    {
120        inline_macro_plugin_overrides(self.as_dyn_database())
121    }
122
123    /// Returns [`InlineMacroExprPluginId`]s of the plugins set for the crate with [`CrateId`].
124    /// Provides an override if it has been set with
125    /// [`DefsGroupEx::set_override_crate_inline_macro_plugins`] or the default
126    /// ([`DefsGroup::default_inline_macro_plugins`]) otherwise.
127    fn crate_inline_macro_plugins<'db>(
128        &'db self,
129        crate_id: CrateId<'db>,
130    ) -> &'db OrderedHashMap<String, InlineMacroExprPluginId<'db>> {
131        crate_inline_macro_plugins(self.as_dyn_database(), crate_id)
132    }
133
134    /// Returns the set of attributes allowed anywhere.
135    /// An attribute on any item that is not in this set will be handled as an unknown attribute.
136    fn allowed_attributes<'db>(
137        &'db self,
138        crate_id: CrateId<'db>,
139    ) -> &'db OrderedHashSet<SmolStrId<'db>> {
140        allowed_attributes(self.as_dyn_database(), crate_id)
141    }
142
143    /// Returns the set of attributes allowed on statements.
144    /// An attribute on a statement that is not in this set will be handled as an unknown attribute.
145    fn allowed_statement_attributes<'db>(&'db self) -> &'db OrderedHashSet<SmolStrId<'db>> {
146        allowed_statement_attributes(self.as_dyn_database())
147    }
148
149    /// Returns the set of `derive` that were declared as by a plugin.
150    /// A derive that is not in this set will be handled as an unknown derive.
151    fn declared_derives<'db>(
152        &'db self,
153        crate_id: CrateId<'db>,
154    ) -> &'db OrderedHashSet<SmolStrId<'db>> {
155        declared_derives(self.as_dyn_database(), crate_id)
156    }
157
158    /// Returns the set of attributes that were declared as phantom type attributes by a plugin,
159    /// i.e. a type marked with this attribute is considered a phantom type.
160    fn declared_phantom_type_attributes<'db>(
161        &'db self,
162        crate_id: CrateId<'db>,
163    ) -> &'db OrderedHashSet<SmolStrId<'db>> {
164        declared_phantom_type_attributes(self.as_dyn_database(), crate_id)
165    }
166
167    /// Checks whether the submodule is defined as inline.
168    fn is_submodule_inline<'db>(&self, submodule_id: SubmoduleId<'db>) -> bool {
169        is_submodule_inline(self.as_dyn_database(), submodule_id)
170    }
171
172    // Module to syntax.
173    /// Gets the main file of the module.
174    /// A module might have more virtual files generated by plugins.
175    fn module_main_file<'db>(&'db self, module_id: ModuleId<'db>) -> Maybe<FileId<'db>> {
176        module_main_file(self.as_dyn_database(), module_id)
177    }
178    /// Gets all the files of a module - main files and generated virtual files.
179    fn module_files<'db>(&'db self, module_id: ModuleId<'db>) -> Maybe<&'db [FileId<'db>]> {
180        module_files(self.as_dyn_database(), module_id)
181    }
182    /// Gets the directory of a module.
183    fn module_dir<'db>(&'db self, module_id: ModuleId<'db>) -> Maybe<&'db Directory<'db>> {
184        module_dir(self.as_dyn_database(), module_id)
185    }
186
187    // File to module.
188    fn crate_modules<'db>(&'db self, crate_id: CrateId<'db>) -> &'db [ModuleId<'db>] {
189        crate_modules(self.as_dyn_database(), crate_id)
190    }
191    fn file_modules<'db>(&'db self, file_id: FileId<'db>) -> Maybe<&'db [ModuleId<'db>]> {
192        file_modules(self.as_dyn_database(), file_id)
193    }
194
195    /// Returns the [ModuleData] of all modules in the crate's cache, and the loading data of the
196    /// [DefsGroup] in the crate.
197    fn cached_crate_modules<'db>(
198        &'db self,
199        crate_id: CrateId<'db>,
200    ) -> Option<ModuleDataCacheAndLoadingData<'db>> {
201        cached_crate_modules(self.as_dyn_database(), crate_id)
202    }
203    fn module_submodules_ids<'db>(
204        &'db self,
205        module_id: ModuleId<'db>,
206    ) -> Maybe<&'db [SubmoduleId<'db>]> {
207        module_submodules_ids(self.as_dyn_database(), module_id)
208    }
209    fn module_constants_ids<'db>(
210        &'db self,
211        module_id: ModuleId<'db>,
212    ) -> Maybe<&'db [ConstantId<'db>]> {
213        module_constants_ids(self.as_dyn_database(), module_id)
214    }
215    fn module_constant_by_id<'db>(
216        &'db self,
217        constant_data: ConstantId<'db>,
218    ) -> Maybe<ast::ItemConstant<'db>> {
219        module_constant_by_id(self.as_dyn_database(), constant_data)
220    }
221    fn module_free_functions_ids<'db>(
222        &'db self,
223        module_id: ModuleId<'db>,
224    ) -> Maybe<&'db [FreeFunctionId<'db>]> {
225        module_free_functions_ids(self.as_dyn_database(), module_id)
226    }
227    fn module_free_function_by_id<'db>(
228        &'db self,
229        free_function_id: FreeFunctionId<'db>,
230    ) -> Maybe<ast::FunctionWithBody<'db>> {
231        module_free_function_by_id(self.as_dyn_database(), free_function_id)
232    }
233    /// Returns the stable ptr of the name of a module item.
234    fn module_item_name_stable_ptr<'db>(
235        &'db self,
236        module_id: ModuleId<'db>,
237        item_id: ModuleItemId<'db>,
238    ) -> Maybe<SyntaxStablePtrId<'db>> {
239        module_item_name_stable_ptr(self.as_dyn_database(), module_id, item_id)
240    }
241    fn module_uses_ids<'db>(&'db self, module_id: ModuleId<'db>) -> Maybe<&'db [UseId<'db>]> {
242        module_uses_ids(self.as_dyn_database(), module_id)
243    }
244    fn module_use_by_id<'db>(&'db self, use_id: UseId<'db>) -> Maybe<ast::UsePathLeaf<'db>> {
245        module_use_by_id(self.as_dyn_database(), use_id)
246    }
247    fn module_global_use_by_id<'db>(
248        &'db self,
249        global_use_id: GlobalUseId<'db>,
250    ) -> Maybe<ast::UsePathStar<'db>> {
251        module_global_use_by_id(self.as_dyn_database(), global_use_id)
252    }
253    fn module_structs_ids<'db>(&'db self, module_id: ModuleId<'db>) -> Maybe<&'db [StructId<'db>]> {
254        module_structs_ids(self.as_dyn_database(), module_id)
255    }
256    fn module_struct_by_id<'db>(
257        &'db self,
258        struct_id: StructId<'db>,
259    ) -> Maybe<ast::ItemStruct<'db>> {
260        module_struct_by_id(self.as_dyn_database(), struct_id)
261    }
262    fn module_enums_ids<'db>(&'db self, module_id: ModuleId<'db>) -> Maybe<&'db [EnumId<'db>]> {
263        module_enums_ids(self.as_dyn_database(), module_id)
264    }
265    fn module_enum_by_id<'db>(&'db self, enum_id: EnumId<'db>) -> Maybe<ast::ItemEnum<'db>> {
266        module_enum_by_id(self.as_dyn_database(), enum_id)
267    }
268    fn module_type_aliases_ids<'db>(
269        &'db self,
270        module_id: ModuleId<'db>,
271    ) -> Maybe<&'db [ModuleTypeAliasId<'db>]> {
272        module_type_aliases_ids(self.as_dyn_database(), module_id)
273    }
274    fn module_type_alias_by_id<'db>(
275        &'db self,
276        module_type_alias_id: ModuleTypeAliasId<'db>,
277    ) -> Maybe<ast::ItemTypeAlias<'db>> {
278        module_type_alias_by_id(self.as_dyn_database(), module_type_alias_id)
279    }
280    fn module_impl_aliases_ids<'db>(
281        &'db self,
282        module_id: ModuleId<'db>,
283    ) -> Maybe<&'db [ImplAliasId<'db>]> {
284        module_impl_aliases_ids(self.as_dyn_database(), module_id)
285    }
286    fn module_impl_alias_by_id<'db>(
287        &'db self,
288        impl_alias_id: ImplAliasId<'db>,
289    ) -> Maybe<ast::ItemImplAlias<'db>> {
290        module_impl_alias_by_id(self.as_dyn_database(), impl_alias_id)
291    }
292    fn module_traits_ids<'db>(&'db self, module_id: ModuleId<'db>) -> Maybe<&'db [TraitId<'db>]> {
293        module_traits_ids(self.as_dyn_database(), module_id)
294    }
295    fn module_trait_by_id<'db>(&'db self, trait_id: TraitId<'db>) -> Maybe<ast::ItemTrait<'db>> {
296        module_trait_by_id(self.as_dyn_database(), trait_id)
297    }
298    fn module_impls_ids<'db>(&'db self, module_id: ModuleId<'db>) -> Maybe<&'db [ImplDefId<'db>]> {
299        module_impls_ids(self.as_dyn_database(), module_id)
300    }
301    fn module_impl_by_id<'db>(&'db self, impl_id: ImplDefId<'db>) -> Maybe<ast::ItemImpl<'db>> {
302        module_impl_by_id(self.as_dyn_database(), impl_id)
303    }
304    fn module_extern_types_ids<'db>(
305        &'db self,
306        module_id: ModuleId<'db>,
307    ) -> Maybe<&'db [ExternTypeId<'db>]> {
308        module_extern_types_ids(self.as_dyn_database(), module_id)
309    }
310    fn module_extern_type_by_id<'db>(
311        &'db self,
312        extern_type_id: ExternTypeId<'db>,
313    ) -> Maybe<ast::ItemExternType<'db>> {
314        module_extern_type_by_id(self.as_dyn_database(), extern_type_id)
315    }
316    fn module_extern_functions_ids<'db>(
317        &'db self,
318        module_id: ModuleId<'db>,
319    ) -> Maybe<&'db [ExternFunctionId<'db>]> {
320        module_extern_functions_ids(self.as_dyn_database(), module_id)
321    }
322    fn module_extern_function_by_id<'db>(
323        &'db self,
324        extern_function_id: ExternFunctionId<'db>,
325    ) -> Maybe<ast::ItemExternFunction<'db>> {
326        module_extern_function_by_id(self.as_dyn_database(), extern_function_id)
327    }
328
329    /// Returns the IDs of the macro declarations in the module.
330    fn module_macro_declarations_ids<'db>(
331        &'db self,
332        module_id: ModuleId<'db>,
333    ) -> Maybe<&'db [MacroDeclarationId<'db>]> {
334        module_macro_declarations_ids(self.as_dyn_database(), module_id)
335    }
336    /// Returns the macro declaration by its ID.
337    fn module_macro_declaration_by_id<'db>(
338        &'db self,
339        macro_declaration_id: MacroDeclarationId<'db>,
340    ) -> Maybe<ast::ItemMacroDeclaration<'db>> {
341        module_macro_declaration_by_id(self.as_dyn_database(), macro_declaration_id)
342    }
343
344    /// Returns the IDs of the macro calls in the module.
345    fn module_macro_calls_ids<'db>(
346        &'db self,
347        module_id: ModuleId<'db>,
348    ) -> Maybe<&'db [MacroCallId<'db>]> {
349        module_macro_calls_ids(self.as_dyn_database(), module_id)
350    }
351    /// Returns the macro call by its ID.
352    fn module_macro_call_by_id<'db>(
353        &'db self,
354        macro_call_id: MacroCallId<'db>,
355    ) -> Maybe<ast::ItemInlineMacro<'db>> {
356        module_macro_call_by_id(self.as_dyn_database(), macro_call_id)
357    }
358    /// Returns the ancestors of a module.
359    fn module_ancestors<'db>(
360        &'db self,
361        module_id: ModuleId<'db>,
362    ) -> &'db OrderedHashSet<ModuleId<'db>> {
363        module_ancestors_helper(self.as_dyn_database(), (), module_id)
364    }
365    /// Returns the module that the module is perceives as.
366    /// Specifically if this is a macro call, it returns the module that the macro call was called
367    /// from, including recursive calls.
368    fn module_perceived_module<'db>(&'db self, module_id: ModuleId<'db>) -> ModuleId<'db> {
369        module_perceived_module_helper(self.as_dyn_database(), (), module_id)
370    }
371}
372
373impl<T: Database + ?Sized> DefsGroup for T {}
374
375/// Initializes the [`DefsGroup`] database to a proper state.
376pub fn init_defs_group(db: &mut dyn Database) {
377    defs_group_input(db).set_macro_plugin_overrides(db).to(Some(OrderedHashMap::default()));
378    defs_group_input(db).set_inline_macro_plugin_overrides(db).to(Some(OrderedHashMap::default()));
379}
380
381#[salsa::tracked(returns(ref))]
382fn default_macro_plugins_helper<'db>(db: &'db dyn Database) -> Vec<MacroPluginId<'db>> {
383    db.default_macro_plugins_input()
384        .iter()
385        .map(|plugin| MacroPluginId::new(db, plugin.clone()))
386        .collect()
387}
388
389pub fn default_macro_plugins<'db>(db: &'db dyn Database) -> &'db [MacroPluginId<'db>] {
390    default_macro_plugins_helper(db)
391}
392
393#[salsa::tracked(returns(ref))]
394pub fn macro_plugin_overrides<'db>(
395    db: &'db dyn Database,
396) -> OrderedHashMap<CrateId<'db>, Vec<MacroPluginId<'db>>> {
397    let inp = db.macro_plugin_overrides_input();
398    inp.iter()
399        .map(|(crate_id, plugins)| {
400            (
401                crate_id.clone().into_crate_long_id(db).intern(db),
402                plugins.iter().map(|plugin| plugin.clone().intern(db)).collect(),
403            )
404        })
405        .collect()
406}
407
408#[salsa::tracked(returns(ref))]
409pub fn inline_macro_plugin_overrides<'db>(
410    db: &'db dyn Database,
411) -> OrderedHashMap<CrateId<'db>, OrderedHashMap<String, InlineMacroExprPluginId<'db>>> {
412    let inp = db.inline_macro_plugin_overrides_input();
413    inp.iter()
414        .map(|(crate_id, plugins)| {
415            (
416                crate_id.clone().into_crate_long_id(db).intern(db),
417                plugins
418                    .iter()
419                    .map(|(name, plugin)| (name.clone(), plugin.clone().intern(db)))
420                    .collect(),
421            )
422        })
423        .collect()
424}
425
426#[salsa::tracked(returns(ref))]
427pub fn default_inline_macro_plugins<'db>(
428    db: &'db dyn Database,
429) -> OrderedHashMap<String, InlineMacroExprPluginId<'db>> {
430    let inp = db.default_inline_macro_plugins_input();
431    inp.iter().map(|(name, plugin)| (name.clone(), plugin.clone().intern(db))).collect()
432}
433
434fn crate_macro_plugins<'db>(
435    db: &'db dyn Database,
436    crate_id: CrateId<'db>,
437) -> &'db [MacroPluginId<'db>] {
438    macro_plugin_overrides(db).get(&crate_id).unwrap_or_else(|| default_macro_plugins_helper(db))
439}
440
441fn crate_inline_macro_plugins<'db>(
442    db: &'db dyn Database,
443    crate_id: CrateId<'db>,
444) -> &'db OrderedHashMap<String, InlineMacroExprPluginId<'db>> {
445    db.inline_macro_plugin_overrides()
446        .get(&crate_id)
447        .unwrap_or_else(|| db.default_inline_macro_plugins())
448}
449
450#[salsa::tracked(returns(ref))]
451fn allowed_attributes<'db>(
452    db: &'db dyn Database,
453    crate_id: CrateId<'db>,
454) -> OrderedHashSet<SmolStrId<'db>> {
455    let base_attrs = [
456        INLINE_ATTR,
457        MUST_USE_ATTR,
458        UNSTABLE_ATTR,
459        DEPRECATED_ATTR,
460        INTERNAL_ATTR,
461        ALLOW_ATTR,
462        ALLOW_ATTR_ATTR,
463        FEATURE_ATTR,
464        PHANTOM_ATTR,
465        IMPLICIT_PRECEDENCE_ATTR,
466        FMT_SKIP_ATTR,
467        PATH_ATTR,
468        // TODO(orizi): Remove this once `starknet` is removed from corelib.
469        STARKNET_INTERFACE_ATTR,
470    ];
471
472    let crate_plugins = db.crate_macro_plugins(crate_id);
473
474    OrderedHashSet::from_iter(chain!(
475        base_attrs.map(|attr| SmolStrId::from(db, attr)),
476        crate_plugins.iter().flat_map(|plugin| plugin.long(db).declared_attributes(db))
477    ))
478}
479
480// TODO(eytan-starkware): Untrack this
481#[salsa::tracked(returns(ref))]
482fn allowed_statement_attributes<'db>(db: &'db dyn Database) -> OrderedHashSet<SmolStrId<'db>> {
483    let all_attributes = [FMT_SKIP_ATTR, ALLOW_ATTR, FEATURE_ATTR];
484    OrderedHashSet::from_iter(all_attributes.map(|attr| SmolStrId::from(db, attr)))
485}
486
487#[salsa::tracked(returns(ref))]
488fn declared_derives<'db>(
489    db: &'db dyn Database,
490    crate_id: CrateId<'db>,
491) -> OrderedHashSet<SmolStrId<'db>> {
492    OrderedHashSet::from_iter(
493        db.crate_macro_plugins(crate_id)
494            .iter()
495            .flat_map(|plugin| plugin.long(db).declared_derives(db)),
496    )
497}
498
499#[salsa::tracked(returns(ref))]
500fn declared_phantom_type_attributes<'db>(
501    db: &'db dyn Database,
502    crate_id: CrateId<'db>,
503) -> OrderedHashSet<SmolStrId<'db>> {
504    let crate_plugins = db.crate_macro_plugins(crate_id);
505
506    OrderedHashSet::from_iter(chain!(
507        [SmolStrId::from(db, PHANTOM_ATTR)],
508        crate_plugins.iter().flat_map(|plugin| plugin.long(db).phantom_type_attributes(db))
509    ))
510}
511
512#[salsa::tracked]
513fn is_submodule_inline<'db>(db: &'db dyn Database, submodule_id: SubmoduleId<'db>) -> bool {
514    match submodule_id.stable_ptr(db).lookup(db).body(db) {
515        MaybeModuleBody::Some(_) => true,
516        MaybeModuleBody::None(_) => false,
517    }
518}
519
520#[salsa::tracked]
521fn module_main_file_helper<'db>(
522    db: &'db dyn Database,
523    _tracked: Tracked,
524    module_id: ModuleId<'db>,
525) -> Maybe<FileId<'db>> {
526    Ok(match module_id {
527        ModuleId::CrateRoot(crate_id) => {
528            db.crate_config(crate_id).to_maybe()?.root.file(db, "lib.cairo")
529        }
530        ModuleId::Submodule(submodule_id) => {
531            let parent = submodule_id.parent_module(db);
532            if db.is_submodule_inline(submodule_id) {
533                // This is an inline module, we return the file where the inline module was
534                // defined. It can be either the file of the parent module
535                // or a plugin-generated virtual file.
536                submodule_id.stable_ptr(db).untyped().file_id(db)
537            } else if let Some(path_override) = submodule_path_override(db, submodule_id) {
538                path_override
539            } else {
540                db.module_dir(parent)?
541                    .file(db, &format!("{}.cairo", submodule_id.name(db).long(db)))
542            }
543        }
544        // This is a macro-generated module, so the main file is the generated file.
545        ModuleId::MacroCall { generated_file_id, .. } => generated_file_id,
546    })
547}
548
549fn module_main_file<'db>(db: &'db dyn Database, module_id: ModuleId<'db>) -> Maybe<FileId<'db>> {
550    module_main_file_helper(db, (), module_id)
551}
552
553fn module_files<'db>(db: &'db dyn Database, module_id: ModuleId<'db>) -> Maybe<&'db [FileId<'db>]> {
554    Ok(module_id.module_data(db)?.files(db))
555}
556
557// TODO(eytan-starkware): This doesn't really need to be tracked.
558#[salsa::tracked(returns(ref))]
559fn module_dir_helper<'db>(
560    db: &'db dyn Database,
561    _tracked: Tracked,
562    module_id: ModuleId<'db>,
563) -> Maybe<Directory<'db>> {
564    match module_id {
565        ModuleId::CrateRoot(crate_id) => {
566            db.crate_config(crate_id).to_maybe().map(|config| config.root.clone())
567        }
568        ModuleId::Submodule(submodule_id) => {
569            let parent = submodule_id.parent_module(db);
570            let name = submodule_id.name(db);
571            Ok(db.module_dir(parent)?.subdir(name.long(db)))
572        }
573        // This is a macro call, we return the directory for the file that contained the macro
574        // call, as it is considered the location of the macro itself.
575        ModuleId::MacroCall { id, .. } => db.module_dir(id.parent_module(db)).cloned(),
576    }
577}
578
579/// Extracts an override path from a `#[path("...")]` attribute on the submodule declaration, if
580/// any. The returned string can be a relative path (resolved against the parent module directory)
581/// or an absolute path.
582fn submodule_path_override<'db>(
583    db: &'db dyn Database,
584    submodule_id: SubmoduleId<'db>,
585) -> Option<FileId<'db>> {
586    // Get the parent module's AST for this submodule.
587    let parent = submodule_id.parent_module(db);
588    let parent_data = parent.module_data(db).ok()?;
589    let item_module_ast = parent_data.submodules(db).get(&submodule_id)?.clone();
590
591    let attr_ast = item_module_ast.find_attr(db, PATH_ATTR)?;
592    let terminal = extract_path_arg(db, &attr_ast.arguments(db))?;
593    let path = terminal.string_value(db)?;
594    /// Find the module where the parents of this module is defined.
595    fn find_base<'db>(db: &'db dyn Database, module_id: ModuleId<'db>) -> ModuleId<'db> {
596        match module_id {
597            ModuleId::CrateRoot(crate_id) => ModuleId::CrateRoot(crate_id),
598            ModuleId::Submodule(submodule_id) => submodule_id.parent_module(db),
599            ModuleId::MacroCall { id, .. } => find_base(db, id.parent_module(db)),
600        }
601    }
602    let base = find_base(db, parent);
603    Some(db.module_dir(base).ok()?.file(db, &path))
604}
605
606fn module_dir<'db>(db: &'db dyn Database, module_id: ModuleId<'db>) -> Maybe<&'db Directory<'db>> {
607    module_dir_helper(db, (), module_id).maybe_as_ref()
608}
609
610/// Appends all the modules under the given module, including nested modules.
611fn collect_modules_under<'db>(
612    db: &'db dyn Database,
613    modules: &mut Vec<ModuleId<'db>>,
614    module_id: ModuleId<'db>,
615) {
616    modules.push(module_id);
617    if let Ok(submodule_ids) = db.module_submodules_ids(module_id) {
618        for submodule_module_id in submodule_ids.iter().copied() {
619            collect_modules_under(db, modules, ModuleId::Submodule(submodule_module_id));
620        }
621    }
622}
623
624/// Returns all the modules in the crate, including recursively.
625#[salsa::tracked(returns(ref))]
626fn crate_modules<'db>(db: &'db dyn Database, crate_id: CrateId<'db>) -> Vec<ModuleId<'db>> {
627    let mut modules = Vec::new();
628    collect_modules_under(db, &mut modules, ModuleId::CrateRoot(crate_id));
629    modules
630}
631
632/// Returns a mapping from file IDs to the modules that contain them.
633#[salsa::tracked(returns(ref))]
634fn file_to_module_mapping<'db>(
635    db: &'db dyn Database,
636) -> OrderedHashMap<FileId<'db>, Vec<ModuleId<'db>>> {
637    let mut mapping = OrderedHashMap::<FileId<'db>, Vec<ModuleId<'db>>>::default();
638    for crate_id in db.crates() {
639        for module_id in db.crate_modules(*crate_id).iter().copied() {
640            if let Ok(files) = db.module_files(module_id) {
641                for file_id in files.iter().copied() {
642                    match mapping.get_mut(&file_id) {
643                        Some(file_modules) => {
644                            file_modules.push(module_id);
645                        }
646                        None => {
647                            mapping.insert(file_id, vec![module_id]);
648                        }
649                    }
650                }
651            }
652        }
653    }
654    mapping
655}
656
657fn file_modules<'db>(db: &'db dyn Database, file_id: FileId<'db>) -> Maybe<&'db [ModuleId<'db>]> {
658    Ok(file_to_module_mapping(db).get(&file_id).to_maybe()?)
659}
660
661#[salsa::tracked]
662pub struct ModuleData<'db> {
663    /// The list of IDs of all items in the module. Each ID here is guaranteed to be a key in one
664    /// of the specific-item-kind maps.
665    #[returns(ref)]
666    pub items: Vec<ModuleItemId<'db>>,
667
668    // Splitting into parts to avoid overly large tuples in salsa, which fails to compile.
669    /// Data for type items.
670    #[returns(ref)]
671    types_data: ModuleTypesData<'db>,
672    /// Data for non-type named items.
673    #[returns(ref)]
674    named_items_data: ModuleNamedItemsData<'db>,
675    /// Data for unnamed items.
676    #[returns(ref)]
677    unnamed_items_data: ModuleUnnamedItemsData<'db>,
678    /// Data for files.
679    #[returns(ref)]
680    files_data: ModuleFilesData<'db>,
681}
682
683#[salsa::tracked]
684pub struct ModuleTypesData<'db> {
685    /// All the structs of the given module.
686    #[returns(ref)]
687    structs: OrderedHashMap<StructId<'db>, ast::ItemStruct<'db>>,
688    /// All the enums of the given module.
689    #[returns(ref)]
690    enums: OrderedHashMap<EnumId<'db>, ast::ItemEnum<'db>>,
691    /// All the type aliases of the given module.
692    #[returns(ref)]
693    type_aliases: OrderedHashMap<ModuleTypeAliasId<'db>, ast::ItemTypeAlias<'db>>,
694    /// All the extern types of the given module.
695    #[returns(ref)]
696    extern_types: OrderedHashMap<ExternTypeId<'db>, ast::ItemExternType<'db>>,
697}
698
699#[salsa::tracked]
700pub struct ModuleNamedItemsData<'db> {
701    /// All the constants of the given module.
702    #[returns(ref)]
703    constants: OrderedHashMap<ConstantId<'db>, ast::ItemConstant<'db>>,
704    /// All the *direct* submodules of the given module - including those generated by
705    /// macro plugins. To get all the submodules including nested modules, use
706    /// [`collect_modules_under`].
707    #[returns(ref)]
708    submodules: OrderedHashMap<SubmoduleId<'db>, ast::ItemModule<'db>>,
709    /// All the uses of the given module.
710    #[returns(ref)]
711    uses: OrderedHashMap<UseId<'db>, ast::UsePathLeaf<'db>>,
712    #[returns(ref)]
713    free_functions: OrderedHashMap<FreeFunctionId<'db>, ast::FunctionWithBody<'db>>,
714    /// All the impl aliases of the given module.
715    #[returns(ref)]
716    impl_aliases: OrderedHashMap<ImplAliasId<'db>, ast::ItemImplAlias<'db>>,
717    /// All the traits of the given module.
718    #[returns(ref)]
719    traits: OrderedHashMap<TraitId<'db>, ast::ItemTrait<'db>>,
720    /// All the impls of the given module.
721    #[returns(ref)]
722    impls: OrderedHashMap<ImplDefId<'db>, ast::ItemImpl<'db>>,
723    /// All the extern functions of the given module.
724    #[returns(ref)]
725    extern_functions: OrderedHashMap<ExternFunctionId<'db>, ast::ItemExternFunction<'db>>,
726    /// All the macro declarations of the given module.
727    #[returns(ref)]
728    macro_declarations: OrderedHashMap<MacroDeclarationId<'db>, ast::ItemMacroDeclaration<'db>>,
729}
730#[salsa::tracked]
731pub struct ModuleUnnamedItemsData<'db> {
732    /// All the global uses of the given module.
733    #[returns(ref)]
734    global_uses: OrderedHashMap<GlobalUseId<'db>, ast::UsePathStar<'db>>,
735    /// Calls to inline macros in the module (only those that were not handled by plugins).
736    #[returns(ref)]
737    macro_calls: OrderedHashMap<MacroCallId<'db>, ast::ItemInlineMacro<'db>>,
738}
739
740#[salsa::tracked]
741pub struct ModuleFilesData<'db> {
742    #[returns(ref)]
743    files: Vec<FileId<'db>>,
744    /// Generation info for each file. Virtual files have Some. Other files have None.
745    #[returns(ref)]
746    generated_file_aux_data: OrderedHashMap<FileId<'db>, Option<DynGeneratedFileAuxData>>,
747    #[returns(ref)]
748    plugin_diagnostics: Vec<(ModuleId<'db>, PluginDiagnostic<'db>)>,
749    /// Diagnostic notes for diagnostics originating in the plugin generated files identified by
750    /// [`FileId`].
751    /// Diagnostic notes are added with `note: ` prefix at the end of diagnostic display.
752    #[returns(ref)]
753    diagnostics_notes: PluginFileDiagnosticNotes<'db>,
754}
755
756impl<'db> ModuleData<'db> {
757    /// All the constants of the given module.
758    pub fn constants(
759        &self,
760        db: &'db dyn Database,
761    ) -> &'db OrderedHashMap<ConstantId<'db>, ast::ItemConstant<'db>> {
762        self.named_items_data(db).constants(db)
763    }
764    /// All the submodules of the given module.
765    pub fn submodules(
766        &self,
767        db: &'db dyn Database,
768    ) -> &'db OrderedHashMap<SubmoduleId<'db>, ast::ItemModule<'db>> {
769        self.named_items_data(db).submodules(db)
770    }
771    /// All the uses of the given module.
772    pub fn uses(
773        &self,
774        db: &'db dyn Database,
775    ) -> &'db OrderedHashMap<UseId<'db>, ast::UsePathLeaf<'db>> {
776        self.named_items_data(db).uses(db)
777    }
778    /// All the free functions of the given module.
779    pub fn free_functions(
780        &self,
781        db: &'db dyn Database,
782    ) -> &'db OrderedHashMap<FreeFunctionId<'db>, ast::FunctionWithBody<'db>> {
783        self.named_items_data(db).free_functions(db)
784    }
785    /// All the structs of the given module.
786    pub fn structs(
787        &self,
788        db: &'db dyn Database,
789    ) -> &'db OrderedHashMap<StructId<'db>, ast::ItemStruct<'db>> {
790        self.types_data(db).structs(db)
791    }
792
793    /// All the enums of the given module.
794    pub fn enums(
795        &self,
796        db: &'db dyn Database,
797    ) -> &'db OrderedHashMap<EnumId<'db>, ast::ItemEnum<'db>> {
798        self.types_data(db).enums(db)
799    }
800
801    /// All the type aliases of the given module.
802    pub fn type_aliases(
803        &self,
804        db: &'db dyn Database,
805    ) -> &'db OrderedHashMap<ModuleTypeAliasId<'db>, ast::ItemTypeAlias<'db>> {
806        self.types_data(db).type_aliases(db)
807    }
808
809    /// All the impl aliases of the given module.
810    pub fn impl_aliases(
811        &self,
812        db: &'db dyn Database,
813    ) -> &'db OrderedHashMap<ImplAliasId<'db>, ast::ItemImplAlias<'db>> {
814        self.named_items_data(db).impl_aliases(db)
815    }
816    /// All the traits of the given module.
817    pub fn traits(
818        &self,
819        db: &'db dyn Database,
820    ) -> &'db OrderedHashMap<TraitId<'db>, ast::ItemTrait<'db>> {
821        self.named_items_data(db).traits(db)
822    }
823    /// All the impls of the given module.
824    pub fn impls(
825        &self,
826        db: &'db dyn Database,
827    ) -> &'db OrderedHashMap<ImplDefId<'db>, ast::ItemImpl<'db>> {
828        self.named_items_data(db).impls(db)
829    }
830    /// All the extern types of the given module.
831    pub fn extern_types(
832        &self,
833        db: &'db dyn Database,
834    ) -> &'db OrderedHashMap<ExternTypeId<'db>, ast::ItemExternType<'db>> {
835        self.types_data(db).extern_types(db)
836    }
837    /// All the extern functions of the given module.
838    pub fn extern_functions(
839        &self,
840        db: &'db dyn Database,
841    ) -> &'db OrderedHashMap<ExternFunctionId<'db>, ast::ItemExternFunction<'db>> {
842        self.named_items_data(db).extern_functions(db)
843    }
844    /// All the macro declarations of the given module.
845    pub fn macro_declarations(
846        &self,
847        db: &'db dyn Database,
848    ) -> &'db OrderedHashMap<MacroDeclarationId<'db>, ast::ItemMacroDeclaration<'db>> {
849        self.named_items_data(db).macro_declarations(db)
850    }
851    /// All the global uses of the given module.
852    pub fn global_uses(
853        &self,
854        db: &'db dyn Database,
855    ) -> &'db OrderedHashMap<GlobalUseId<'db>, ast::UsePathStar<'db>> {
856        self.unnamed_items_data(db).global_uses(db)
857    }
858    /// Calls to inline macros in the module (only those that were not handled by plugins).
859    pub fn macro_calls(
860        &self,
861        db: &'db dyn Database,
862    ) -> &'db OrderedHashMap<MacroCallId<'db>, ast::ItemInlineMacro<'db>> {
863        self.unnamed_items_data(db).macro_calls(db)
864    }
865
866    /// All the files of the given module.
867    pub fn files(&self, db: &'db dyn Database) -> &'db Vec<FileId<'db>> {
868        self.files_data(db).files(db)
869    }
870
871    /// Generation info for each file. Virtual files have Some. Other files have None.
872    pub fn generated_file_aux_data(
873        &self,
874        db: &'db dyn Database,
875    ) -> &'db OrderedHashMap<FileId<'db>, Option<DynGeneratedFileAuxData>> {
876        self.files_data(db).generated_file_aux_data(db)
877    }
878
879    pub fn plugin_diagnostics(
880        &self,
881        db: &'db dyn Database,
882    ) -> &'db Vec<(ModuleId<'db>, PluginDiagnostic<'db>)> {
883        self.files_data(db).plugin_diagnostics(db)
884    }
885
886    /// Diagnostic notes for diagnostics originating in the plugin generated files identified by
887    /// [`FileId`].
888    /// Diagnostic notes are added with `note: ` prefix at the end of diagnostic display.
889    pub fn diagnostics_notes(&self, db: &'db dyn Database) -> &'db PluginFileDiagnosticNotes<'db> {
890        self.files_data(db).diagnostics_notes(db)
891    }
892}
893
894/// Information about generated files from running on a module file.
895#[derive(Clone, Debug, Eq, PartialEq, salsa::Update)]
896pub struct PrivModuleSubFiles<'db> {
897    /// The files generated by plugins running on items.
898    files: OrderedHashMap<FileId<'db>, VirtualFile<'db>>,
899    /// The aux data per such file.
900    aux_data: OrderedHashMap<FileId<'db>, Option<DynGeneratedFileAuxData>>,
901    /// The items not filtered out by plugins.
902    items: Vec<ast::ModuleItem<'db>>,
903    /// The diagnostics generated by the plugins.
904    plugin_diagnostics: Vec<PluginDiagnostic<'db>>,
905    /// Diagnostic notes for diagnostics originating in the plugin generated files identified by
906    /// [`FileId`].
907    /// Diagnostic notes are added with `note: ` prefix at the end of diagnostic display.
908    diagnostics_notes: PluginFileDiagnosticNotes<'db>,
909}
910
911#[salsa::tracked]
912fn priv_module_data_helper<'db>(
913    db: &'db dyn Database,
914    _tracked: Tracked,
915    module_id: ModuleId<'db>,
916) -> Maybe<ModuleData<'db>> {
917    let crate_id = module_id.owning_crate(db);
918
919    if let Some((map, _)) = db.cached_crate_modules(crate_id) {
920        if let Some(module_data) = map.get(&module_id) {
921            return Ok(*module_data);
922        } else {
923            panic!("module not found in cached modules_data {:?}", module_id.name(db));
924        }
925    };
926
927    let module_file = db.module_main_file(module_id)?;
928    let main_file_aux_data = if let ModuleId::Submodule(submodule_id) = module_id {
929        let parent_module_data = submodule_id.module_data(db)?;
930        let item_module_ast = &parent_module_data.submodules(db)[&submodule_id];
931        if matches!(item_module_ast.body(db), MaybeModuleBody::Some(_)) {
932            // TODO(spapini): Diagnostics in this module that get mapped to parent module
933            // should lie in that modules ModuleData, or somehow collected by its
934            // diagnostics collector function.
935
936            // If this is an inline module, copy its generation file info from the parent
937            // module, from the file where this submodule was defined.
938            parent_module_data.generated_file_aux_data(db)
939                [&item_module_ast.stable_ptr(db).untyped().file_id(db)]
940                .clone()
941        } else {
942            None
943        }
944    } else {
945        None
946    };
947    let mut file_queue = VecDeque::new();
948    file_queue.push_back(module_file);
949    let mut constants = OrderedHashMap::default();
950    let mut submodules = OrderedHashMap::default();
951    let mut uses = OrderedHashMap::default();
952    let mut free_functions = OrderedHashMap::default();
953    let mut structs = OrderedHashMap::default();
954    let mut enums = OrderedHashMap::default();
955    let mut type_aliases = OrderedHashMap::default();
956    let mut impl_aliases = OrderedHashMap::default();
957    let mut traits = OrderedHashMap::default();
958    let mut impls = OrderedHashMap::default();
959    let mut extern_types = OrderedHashMap::default();
960    let mut extern_functions = OrderedHashMap::default();
961    let mut macro_declarations = OrderedHashMap::default();
962    let mut macro_calls = OrderedHashMap::default();
963    let mut global_uses = OrderedHashMap::default();
964    let mut aux_data = OrderedHashMap::default();
965    let mut files = Vec::new();
966    let mut plugin_diagnostics = Vec::new();
967    let mut diagnostics_notes = OrderedHashMap::default();
968
969    let mut items = vec![];
970    aux_data.insert(module_file, main_file_aux_data);
971    while let Some(file_id) = file_queue.pop_front() {
972        files.push(file_id);
973
974        let priv_module_data = module_sub_files(db, module_id, file_id).maybe_as_ref()?;
975        diagnostics_notes.extend(priv_module_data.diagnostics_notes.clone().into_iter());
976        file_queue.extend(priv_module_data.files.keys().copied());
977        for diag in &priv_module_data.plugin_diagnostics {
978            plugin_diagnostics.push((module_id, diag.clone()));
979        }
980        aux_data.extend(
981            priv_module_data.aux_data.iter().map(|(file, aux_data)| (*file, aux_data.clone())),
982        );
983        for item_ast in &priv_module_data.items {
984            match item_ast.clone() {
985                ast::ModuleItem::Constant(constant) => {
986                    let item_id = ConstantLongId(module_id, constant.stable_ptr(db)).intern(db);
987                    constants.insert(item_id, constant);
988                    items.push(ModuleItemId::Constant(item_id));
989                }
990                ast::ModuleItem::Module(module) => {
991                    let item_id = SubmoduleLongId(module_id, module.stable_ptr(db)).intern(db);
992                    submodules.insert(item_id, module);
993                    items.push(ModuleItemId::Submodule(item_id));
994                }
995                ast::ModuleItem::Use(us) => {
996                    for leaf in get_all_path_leaves(db, &us) {
997                        let id = UseLongId(module_id, leaf.stable_ptr(db)).intern(db);
998                        uses.insert(id, leaf);
999                        items.push(ModuleItemId::Use(id));
1000                    }
1001                    for star in get_all_path_stars(db, &us) {
1002                        let id = GlobalUseLongId(module_id, star.stable_ptr(db)).intern(db);
1003                        global_uses.insert(id, star);
1004                    }
1005                }
1006                ast::ModuleItem::FreeFunction(function) => {
1007                    let item_id = FreeFunctionLongId(module_id, function.stable_ptr(db)).intern(db);
1008                    free_functions.insert(item_id, function);
1009                    items.push(ModuleItemId::FreeFunction(item_id));
1010                }
1011                ast::ModuleItem::ExternFunction(extern_function) => {
1012                    let item_id =
1013                        ExternFunctionLongId(module_id, extern_function.stable_ptr(db)).intern(db);
1014                    extern_functions.insert(item_id, extern_function);
1015                    items.push(ModuleItemId::ExternFunction(item_id));
1016                }
1017                ast::ModuleItem::ExternType(extern_type) => {
1018                    let item_id =
1019                        ExternTypeLongId(module_id, extern_type.stable_ptr(db)).intern(db);
1020                    extern_types.insert(item_id, extern_type);
1021                    items.push(ModuleItemId::ExternType(item_id));
1022                }
1023                ast::ModuleItem::Trait(trt) => {
1024                    let item_id = TraitLongId(module_id, trt.stable_ptr(db)).intern(db);
1025                    traits.insert(item_id, trt);
1026                    items.push(ModuleItemId::Trait(item_id));
1027                }
1028                ast::ModuleItem::Impl(imp) => {
1029                    let item_id = ImplDefLongId(module_id, imp.stable_ptr(db)).intern(db);
1030                    impls.insert(item_id, imp);
1031                    items.push(ModuleItemId::Impl(item_id));
1032                }
1033                ast::ModuleItem::Struct(structure) => {
1034                    let item_id = StructLongId(module_id, structure.stable_ptr(db)).intern(db);
1035                    structs.insert(item_id, structure);
1036                    items.push(ModuleItemId::Struct(item_id));
1037                }
1038                ast::ModuleItem::Enum(enm) => {
1039                    let item_id = EnumLongId(module_id, enm.stable_ptr(db)).intern(db);
1040                    enums.insert(item_id, enm);
1041                    items.push(ModuleItemId::Enum(item_id));
1042                }
1043                ast::ModuleItem::TypeAlias(type_alias) => {
1044                    let item_id =
1045                        ModuleTypeAliasLongId(module_id, type_alias.stable_ptr(db)).intern(db);
1046                    type_aliases.insert(item_id, type_alias);
1047                    items.push(ModuleItemId::TypeAlias(item_id));
1048                }
1049                ast::ModuleItem::ImplAlias(impl_alias) => {
1050                    let item_id = ImplAliasLongId(module_id, impl_alias.stable_ptr(db)).intern(db);
1051                    impl_aliases.insert(item_id, impl_alias);
1052                    items.push(ModuleItemId::ImplAlias(item_id));
1053                }
1054                ast::ModuleItem::MacroDeclaration(macro_declaration) => {
1055                    let item_id =
1056                        MacroDeclarationLongId(module_id, macro_declaration.stable_ptr(db))
1057                            .intern(db);
1058                    macro_declarations.insert(item_id, macro_declaration);
1059                    items.push(ModuleItemId::MacroDeclaration(item_id));
1060                }
1061                ast::ModuleItem::InlineMacro(inline_macro_ast) => {
1062                    let item_id =
1063                        MacroCallLongId(module_id, inline_macro_ast.stable_ptr(db)).intern(db);
1064                    macro_calls.insert(item_id, inline_macro_ast.clone());
1065                }
1066                ast::ModuleItem::HeaderDoc(_) => {}
1067                ast::ModuleItem::Missing(_) => {}
1068            }
1069        }
1070    }
1071    let types_data = ModuleTypesData::new(db, structs, enums, type_aliases, extern_types);
1072    let named_items_data = ModuleNamedItemsData::new(
1073        db,
1074        constants,
1075        submodules,
1076        uses,
1077        free_functions,
1078        impl_aliases,
1079        traits,
1080        impls,
1081        extern_functions,
1082        macro_declarations,
1083    );
1084    let unnamed_items_data = ModuleUnnamedItemsData::new(db, global_uses, macro_calls);
1085    let files_data =
1086        ModuleFilesData::new(db, files, aux_data, plugin_diagnostics, diagnostics_notes);
1087    Ok(ModuleData::new(db, items, types_data, named_items_data, unnamed_items_data, files_data))
1088}
1089
1090pub(crate) fn module_data<'db>(
1091    db: &'db dyn Database,
1092    module_id: ModuleId<'db>,
1093) -> Maybe<ModuleData<'db>> {
1094    priv_module_data_helper(db, (), module_id)
1095}
1096
1097pub type ModuleDataCacheAndLoadingData<'db> =
1098    (Arc<OrderedHashMap<ModuleId<'db>, ModuleData<'db>>>, Arc<DefCacheLoadingData<'db>>);
1099
1100#[salsa::tracked]
1101fn cached_crate_modules<'db>(
1102    db: &'db dyn Database,
1103    crate_id: CrateId<'db>,
1104) -> Option<ModuleDataCacheAndLoadingData<'db>> {
1105    load_cached_crate_modules(db, crate_id)
1106}
1107
1108pub fn init_external_files<T: DefsGroup>(db: &mut T) {
1109    let ext_as_virtual_impl: ExtAsVirtual =
1110        Arc::new(|db: &dyn Database, external_id: salsa::Id| ext_as_virtual_impl(db, external_id));
1111    files_group_input(db).set_ext_as_virtual_obj(db).to(Some(ext_as_virtual_impl));
1112}
1113
1114/// Returns the `VirtualFile` matching the given external id.
1115pub fn ext_as_virtual_impl<'db>(
1116    db: &'db dyn Database,
1117    external_id: salsa::Id,
1118) -> &'db VirtualFile<'db> {
1119    let long_id = PluginGeneratedFileId::from_intern_id(external_id).long(db);
1120    let file_id = FileLongId::External(external_id).intern(db);
1121    let data =
1122        module_sub_files(db, long_id.module_id, long_id.stable_ptr.file_id(db)).as_ref().unwrap();
1123    &data.files[&file_id]
1124}
1125
1126#[salsa::tracked(returns(ref))]
1127/// Returns the information about sub-files generated by the file in the module.
1128fn module_sub_files<'db>(
1129    db: &'db dyn Database,
1130    module_id: ModuleId<'db>,
1131    file_id: FileId<'db>,
1132) -> Maybe<PrivModuleSubFiles<'db>> {
1133    let module_main_file = db.module_main_file(module_id)?;
1134    let file_syntax = db.file_module_syntax(file_id)?;
1135    let item_asts = if module_main_file == file_id {
1136        if let ModuleId::Submodule(submodule_id) = module_id {
1137            let data = submodule_id.module_data(db)?;
1138            if let MaybeModuleBody::Some(body) = data.submodules(db)[&submodule_id].body(db) {
1139                Some(body.items(db))
1140            } else {
1141                None
1142            }
1143        } else {
1144            None
1145        }
1146    } else {
1147        None
1148    }
1149    .unwrap_or_else(|| file_syntax.items(db));
1150
1151    let crate_id = module_id.owning_crate(db);
1152
1153    let allowed_attributes = db.allowed_attributes(crate_id);
1154    // TODO(orizi): Actually extract the allowed features per module.
1155    let allowed_features = Default::default();
1156
1157    let cfg_set = db
1158        .crate_config(crate_id)
1159        .and_then(|cfg| cfg.settings.cfg_set.as_ref())
1160        .unwrap_or(db.cfg_set());
1161    let edition = db
1162        .crate_config(module_id.owning_crate(db))
1163        .map(|cfg| cfg.settings.edition)
1164        .unwrap_or_default();
1165    let metadata = MacroPluginMetadata {
1166        cfg_set,
1167        declared_derives: db.declared_derives(crate_id),
1168        allowed_features: &allowed_features,
1169        edition,
1170    };
1171
1172    let mut files = OrderedHashMap::<_, _>::default();
1173    let mut aux_data = OrderedHashMap::default();
1174    let mut items = Vec::new();
1175    let mut plugin_diagnostics = Vec::new();
1176    let mut diagnostics_notes = OrderedHashMap::default();
1177    for item_ast in item_asts.elements(db) {
1178        let mut remove_original_item = false;
1179        // Iterate the plugins by their order. The first one to change something (either
1180        // generate new code, remove the original code, or both), breaks the loop. If more
1181        // plugins might have act on the item, they can do it on the generated code.
1182        for plugin_id in db.crate_macro_plugins(crate_id).iter() {
1183            let plugin = plugin_id.long(db);
1184
1185            let result = plugin.generate_code(db, item_ast.clone(), &metadata);
1186            plugin_diagnostics.extend(result.diagnostics);
1187            if result.remove_original_item {
1188                remove_original_item = true;
1189            }
1190
1191            if let Some(generated) = result.code {
1192                let generated_file_id = FileLongId::External(
1193                    PluginGeneratedFileLongId {
1194                        module_id,
1195                        stable_ptr: item_ast.stable_ptr(db).untyped(),
1196                        name: generated.name.clone(),
1197                    }
1198                    .intern(db)
1199                    .as_intern_id(),
1200                )
1201                .intern(db);
1202                if let Some(text) = generated.diagnostics_note {
1203                    diagnostics_notes
1204                        .insert(generated_file_id, DiagnosticNote { text, location: None });
1205                }
1206                files.insert(
1207                    generated_file_id,
1208                    VirtualFile {
1209                        parent: Some(file_id),
1210                        name: SmolStrId::from(db, generated.name),
1211                        content: SmolStrId::from(db, generated.content),
1212                        code_mappings: generated.code_mappings.into(),
1213                        kind: FileKind::Module,
1214                        original_item_removed: remove_original_item,
1215                    },
1216                );
1217                aux_data.insert(generated_file_id, generated.aux_data);
1218            }
1219            if remove_original_item {
1220                break;
1221            }
1222        }
1223        if remove_original_item {
1224            // Don't add the original item to the module data.
1225            continue;
1226        }
1227        validate_attributes(db, allowed_attributes, &item_ast, &mut plugin_diagnostics);
1228        items.push(item_ast);
1229    }
1230    Ok(PrivModuleSubFiles { files, aux_data, items, plugin_diagnostics, diagnostics_notes })
1231}
1232
1233/// Collects attributes allowed by `allow_attr` attribute.
1234fn collect_extra_allowed_attributes<'db>(
1235    db: &'db dyn Database,
1236    item: &impl QueryAttrs<'db>,
1237    plugin_diagnostics: &mut Vec<PluginDiagnostic<'db>>,
1238) -> OrderedHashSet<SmolStrId<'db>> {
1239    let mut extra_allowed_attributes = OrderedHashSet::default();
1240    for attr in item.query_attr(db, ALLOW_ATTR_ATTR) {
1241        let args = attr.clone().structurize(db).args;
1242        if args.is_empty() {
1243            plugin_diagnostics.push(PluginDiagnostic::error(
1244                attr.stable_ptr(db),
1245                "Expected arguments.".to_string(),
1246            ));
1247            continue;
1248        }
1249        for arg in args {
1250            if let Some(ast::Expr::Path(path)) = try_extract_unnamed_arg(db, &arg.arg)
1251                && let Some([ast::PathSegment::Simple(segment)]) =
1252                    path.segments(db).elements(db).collect_array()
1253            {
1254                extra_allowed_attributes.insert(segment.ident(db).text(db));
1255                continue;
1256            }
1257            plugin_diagnostics.push(PluginDiagnostic::error(
1258                arg.arg.stable_ptr(db),
1259                "Expected simple identifier.".to_string(),
1260            ));
1261        }
1262    }
1263    extra_allowed_attributes
1264}
1265
1266/// Validates that all attributes on the given item are in the allowed set or adds diagnostics.
1267pub fn validate_attributes_flat<'db, Item: QueryAttrs<'db> + TypedSyntaxNode<'db>>(
1268    db: &'db dyn Database,
1269    allowed_attributes: &OrderedHashSet<SmolStrId<'db>>,
1270    extra_allowed_attributes: &OrderedHashSet<SmolStrId<'db>>,
1271    item: &Item,
1272    plugin_diagnostics: &mut Vec<PluginDiagnostic<'db>>,
1273) {
1274    let local_extra_attributes = collect_extra_allowed_attributes(db, item, plugin_diagnostics);
1275    for attr in item.attributes_elements(db) {
1276        let attr_text = attr.attr(db).as_syntax_node().get_text_without_trivia(db);
1277        if !(allowed_attributes.contains(&attr_text)
1278            || extra_allowed_attributes.contains(&attr_text)
1279            || local_extra_attributes.contains(&attr_text))
1280        {
1281            plugin_diagnostics.push(PluginDiagnostic::error(
1282                attr.stable_ptr(db),
1283                "Unsupported attribute.".to_string(),
1284            ));
1285        }
1286    }
1287
1288    // Additional semantic validation for `#[path("...")]` attribute.
1289    for attr in item.query_attr(db, PATH_ATTR) {
1290        let node = item.as_syntax_node();
1291        let Some(item_module) = ast::ItemModule::cast(db, node) else {
1292            plugin_diagnostics.push(PluginDiagnostic::error(
1293                attr.stable_ptr(db),
1294                "`#[path(..)]` is only allowed on module declarations.".to_string(),
1295            ));
1296            continue;
1297        };
1298        // Must be file-based (`mod name;`), not inline.
1299        if matches!(item_module.body(db), MaybeModuleBody::Some(_)) {
1300            plugin_diagnostics.push(PluginDiagnostic::error(
1301                attr.stable_ptr(db),
1302                "`#[path(..)]` requires a file-based module: use `mod name;` with a semicolon."
1303                    .to_string(),
1304            ));
1305            continue;
1306        }
1307
1308        let args = attr.arguments(db);
1309        if extract_path_arg(db, &args).is_none() {
1310            plugin_diagnostics.push(PluginDiagnostic::error(
1311                args.stable_ptr(db),
1312                "`#[path(..)]` expects exactly one string literal argument.".to_string(),
1313            ));
1314        }
1315    }
1316}
1317
1318/// Extracts the path argument from the given attribute arguments.
1319fn extract_path_arg<'db>(
1320    db: &'db dyn Database,
1321    args: &ast::OptionArgListParenthesized<'db>,
1322) -> Option<ast::TerminalString<'db>> {
1323    match args {
1324        ast::OptionArgListParenthesized::Empty(_) => None,
1325        ast::OptionArgListParenthesized::ArgListParenthesized(args) => {
1326            let [arg] = args.arguments(db).elements(db).collect_array()?;
1327            if let ast::Expr::String(path) = try_extract_unnamed_arg(db, &arg)? {
1328                Some(path)
1329            } else {
1330                None
1331            }
1332        }
1333    }
1334}
1335
1336/// Validates that all attributes on all items in the given element list are in the allowed set or
1337/// adds diagnostics.
1338fn validate_attributes_element_list<'db, Item: QueryAttrs<'db> + TypedSyntaxNode<'db>>(
1339    db: &'db dyn Database,
1340    allowed_attributes: &OrderedHashSet<SmolStrId<'db>>,
1341    extra_allowed_attributes: &OrderedHashSet<SmolStrId<'db>>,
1342    items: impl Iterator<Item = Item>,
1343    plugin_diagnostics: &mut Vec<PluginDiagnostic<'db>>,
1344) {
1345    for item in items {
1346        validate_attributes_flat(
1347            db,
1348            allowed_attributes,
1349            extra_allowed_attributes,
1350            &item,
1351            plugin_diagnostics,
1352        );
1353    }
1354}
1355
1356/// Validates that all attributes on an item and on items contained within it are in the allowed set
1357/// or adds diagnostics.
1358fn validate_attributes<'db>(
1359    db: &'db dyn Database,
1360    allowed_attributes: &OrderedHashSet<SmolStrId<'db>>,
1361    item_ast: &ast::ModuleItem<'db>,
1362    plugin_diagnostics: &mut Vec<PluginDiagnostic<'db>>,
1363) {
1364    let extra_allowed_attributes =
1365        collect_extra_allowed_attributes(db, item_ast, plugin_diagnostics);
1366    validate_attributes_flat(
1367        db,
1368        allowed_attributes,
1369        &extra_allowed_attributes,
1370        item_ast,
1371        plugin_diagnostics,
1372    );
1373
1374    match item_ast {
1375        ast::ModuleItem::Trait(item) => {
1376            if let ast::MaybeTraitBody::Some(body) = item.body(db) {
1377                validate_attributes_element_list(
1378                    db,
1379                    allowed_attributes,
1380                    &extra_allowed_attributes,
1381                    body.items(db).elements(db),
1382                    plugin_diagnostics,
1383                );
1384            }
1385        }
1386        ast::ModuleItem::Impl(item) => {
1387            if let ast::MaybeImplBody::Some(body) = item.body(db) {
1388                validate_attributes_element_list(
1389                    db,
1390                    allowed_attributes,
1391                    &extra_allowed_attributes,
1392                    body.items(db).elements(db),
1393                    plugin_diagnostics,
1394                );
1395            }
1396        }
1397        ast::ModuleItem::Struct(item) => {
1398            validate_attributes_element_list(
1399                db,
1400                allowed_attributes,
1401                &extra_allowed_attributes,
1402                item.members(db).elements(db),
1403                plugin_diagnostics,
1404            );
1405        }
1406        ast::ModuleItem::Enum(item) => {
1407            validate_attributes_element_list(
1408                db,
1409                allowed_attributes,
1410                &extra_allowed_attributes,
1411                item.variants(db).elements(db),
1412                plugin_diagnostics,
1413            );
1414        }
1415        _ => {}
1416    }
1417}
1418
1419/// Returns all the path leaves under a given use item.
1420pub fn get_all_path_leaves<'db>(
1421    db: &'db dyn Database,
1422    use_item: &ast::ItemUse<'db>,
1423) -> Vec<ast::UsePathLeaf<'db>> {
1424    let mut res = vec![];
1425    let mut stack = vec![use_item.use_path(db)];
1426    while let Some(use_path) = stack.pop() {
1427        match use_path {
1428            ast::UsePath::Leaf(use_path) => res.push(use_path),
1429            ast::UsePath::Single(use_path) => stack.push(use_path.use_path(db)),
1430            ast::UsePath::Multi(use_path) => {
1431                stack.extend(use_path.use_paths(db).elements(db).rev())
1432            }
1433            ast::UsePath::Star(_) => {}
1434        }
1435    }
1436    res
1437}
1438
1439/// Returns all the path stars under a given use item.
1440pub fn get_all_path_stars<'db>(
1441    db: &'db dyn Database,
1442    use_item: &ast::ItemUse<'db>,
1443) -> Vec<ast::UsePathStar<'db>> {
1444    let mut res = vec![];
1445    let mut stack = vec![use_item.use_path(db)];
1446    while let Some(use_path) = stack.pop() {
1447        match use_path {
1448            ast::UsePath::Leaf(_) => {}
1449            ast::UsePath::Single(use_path) => stack.push(use_path.use_path(db)),
1450            ast::UsePath::Multi(use_path) => {
1451                stack.extend(use_path.use_paths(db).elements(db).rev())
1452            }
1453            ast::UsePath::Star(use_path) => res.push(use_path),
1454        }
1455    }
1456    res
1457}
1458
1459#[salsa::tracked(returns(ref))]
1460fn module_constants_ids_helper<'db>(
1461    db: &'db dyn Database,
1462    module_data: ModuleData<'db>,
1463) -> Vec<ConstantId<'db>> {
1464    module_data.constants(db).keys().copied().collect_vec()
1465}
1466
1467pub fn module_constants_ids<'db>(
1468    db: &'db dyn Database,
1469    module_id: ModuleId<'db>,
1470) -> Maybe<&'db [ConstantId<'db>]> {
1471    Ok(module_constants_ids_helper(db, module_id.module_data(db)?))
1472}
1473
1474pub fn module_constant_by_id<'db>(
1475    db: &'db dyn Database,
1476    constant_id: ConstantId<'db>,
1477) -> Maybe<ast::ItemConstant<'db>> {
1478    let module_constants = constant_id.module_data(db)?.constants(db);
1479    module_constants.get(&constant_id).cloned().ok_or_else(skip_diagnostic)
1480}
1481
1482#[salsa::tracked(returns(ref))]
1483fn module_submodules_ids_helper<'db>(
1484    db: &'db dyn Database,
1485    module_data: ModuleData<'db>,
1486) -> Vec<SubmoduleId<'db>> {
1487    module_data.submodules(db).keys().copied().collect_vec()
1488}
1489
1490fn module_submodules_ids<'db>(
1491    db: &'db dyn Database,
1492    module_id: ModuleId<'db>,
1493) -> Maybe<&'db [SubmoduleId<'db>]> {
1494    Ok(module_submodules_ids_helper(db, module_id.module_data(db)?))
1495}
1496
1497pub fn module_submodule_by_id<'db>(
1498    db: &'db dyn Database,
1499    submodule_id: SubmoduleId<'db>,
1500) -> Maybe<ast::ItemModule<'db>> {
1501    let module_submodules = submodule_id.module_data(db)?.submodules(db);
1502    module_submodules.get(&submodule_id).cloned().ok_or_else(skip_diagnostic)
1503}
1504
1505#[salsa::tracked(returns(ref))]
1506fn module_free_functions_ids_helper<'db>(
1507    db: &'db dyn Database,
1508    module_data: ModuleData<'db>,
1509) -> Vec<FreeFunctionId<'db>> {
1510    module_data.free_functions(db).keys().copied().collect_vec()
1511}
1512
1513pub fn module_free_functions_ids<'db>(
1514    db: &'db dyn Database,
1515    module_id: ModuleId<'db>,
1516) -> Maybe<&'db [FreeFunctionId<'db>]> {
1517    Ok(module_free_functions_ids_helper(db, module_id.module_data(db)?))
1518}
1519pub fn module_free_function_by_id<'db>(
1520    db: &'db dyn Database,
1521    free_function_id: FreeFunctionId<'db>,
1522) -> Maybe<ast::FunctionWithBody<'db>> {
1523    let module_free_functions = free_function_id.module_data(db)?.free_functions(db);
1524    module_free_functions.get(&free_function_id).cloned().ok_or_else(skip_diagnostic)
1525}
1526
1527#[salsa::tracked(returns(ref))]
1528fn module_uses_ids_helper<'db>(
1529    db: &'db dyn Database,
1530    module_data: ModuleData<'db>,
1531) -> Vec<UseId<'db>> {
1532    module_data.uses(db).keys().copied().collect_vec()
1533}
1534pub fn module_uses_ids<'db>(
1535    db: &'db dyn Database,
1536    module_id: ModuleId<'db>,
1537) -> Maybe<&'db [UseId<'db>]> {
1538    Ok(module_uses_ids_helper(db, module_id.module_data(db)?))
1539}
1540pub fn module_use_by_id<'db>(
1541    db: &'db dyn Database,
1542    use_id: UseId<'db>,
1543) -> Maybe<ast::UsePathLeaf<'db>> {
1544    let module_uses = use_id.module_data(db)?.uses(db);
1545    module_uses.get(&use_id).cloned().ok_or_else(skip_diagnostic)
1546}
1547
1548/// Returns the `use *` of the given module, by its ID.
1549pub fn module_global_use_by_id<'db>(
1550    db: &'db dyn Database,
1551    global_use_id: GlobalUseId<'db>,
1552) -> Maybe<ast::UsePathStar<'db>> {
1553    let module_global_uses = global_use_id.module_data(db)?.global_uses(db);
1554    module_global_uses.get(&global_use_id).cloned().ok_or_else(skip_diagnostic)
1555}
1556
1557#[salsa::tracked(returns(ref))]
1558fn module_structs_ids_helper<'db>(
1559    db: &'db dyn Database,
1560    module_data: ModuleData<'db>,
1561) -> Vec<StructId<'db>> {
1562    module_data.structs(db).keys().copied().collect_vec()
1563}
1564
1565pub fn module_structs_ids<'db>(
1566    db: &'db dyn Database,
1567    module_id: ModuleId<'db>,
1568) -> Maybe<&'db [StructId<'db>]> {
1569    Ok(module_structs_ids_helper(db, module_id.module_data(db)?))
1570}
1571
1572pub fn module_struct_by_id<'db>(
1573    db: &'db dyn Database,
1574    struct_id: StructId<'db>,
1575) -> Maybe<ast::ItemStruct<'db>> {
1576    let module_structs = struct_id.module_data(db)?.structs(db);
1577    module_structs.get(&struct_id).cloned().ok_or_else(skip_diagnostic)
1578}
1579
1580#[salsa::tracked(returns(ref))]
1581fn module_enums_ids_helper<'db>(
1582    db: &'db dyn Database,
1583    module_data: ModuleData<'db>,
1584) -> Vec<EnumId<'db>> {
1585    module_data.enums(db).keys().copied().collect_vec()
1586}
1587
1588pub fn module_enums_ids<'db>(
1589    db: &'db dyn Database,
1590    module_id: ModuleId<'db>,
1591) -> Maybe<&'db [EnumId<'db>]> {
1592    Ok(module_enums_ids_helper(db, module_id.module_data(db)?))
1593}
1594
1595pub fn module_enum_by_id<'db>(
1596    db: &'db dyn Database,
1597    enum_id: EnumId<'db>,
1598) -> Maybe<ast::ItemEnum<'db>> {
1599    let module_enums = enum_id.module_data(db)?.enums(db);
1600    module_enums.get(&enum_id).cloned().ok_or_else(skip_diagnostic)
1601}
1602
1603#[salsa::tracked(returns(ref))]
1604fn module_type_aliases_ids_helper<'db>(
1605    db: &'db dyn Database,
1606    module_data: ModuleData<'db>,
1607) -> Vec<ModuleTypeAliasId<'db>> {
1608    module_data.type_aliases(db).keys().copied().collect_vec()
1609}
1610
1611pub fn module_type_aliases_ids<'db>(
1612    db: &'db dyn Database,
1613    module_id: ModuleId<'db>,
1614) -> Maybe<&'db [ModuleTypeAliasId<'db>]> {
1615    Ok(module_type_aliases_ids_helper(db, module_id.module_data(db)?))
1616}
1617
1618pub fn module_type_alias_by_id<'db>(
1619    db: &'db dyn Database,
1620    module_type_alias_id: ModuleTypeAliasId<'db>,
1621) -> Maybe<ast::ItemTypeAlias<'db>> {
1622    let module_type_aliases = module_type_alias_id.module_data(db)?.type_aliases(db);
1623    module_type_aliases.get(&module_type_alias_id).cloned().ok_or_else(skip_diagnostic)
1624}
1625
1626#[salsa::tracked(returns(ref))]
1627fn module_impl_aliases_ids_helper<'db>(
1628    db: &'db dyn Database,
1629    module_data: ModuleData<'db>,
1630) -> Vec<ImplAliasId<'db>> {
1631    module_data.impl_aliases(db).keys().copied().collect_vec()
1632}
1633
1634pub fn module_impl_aliases_ids<'db>(
1635    db: &'db dyn Database,
1636    module_id: ModuleId<'db>,
1637) -> Maybe<&'db [ImplAliasId<'db>]> {
1638    Ok(module_impl_aliases_ids_helper(db, module_id.module_data(db)?))
1639}
1640
1641pub fn module_impl_alias_by_id<'db>(
1642    db: &'db dyn Database,
1643    impl_alias_id: ImplAliasId<'db>,
1644) -> Maybe<ast::ItemImplAlias<'db>> {
1645    let module_impl_aliases = impl_alias_id.module_data(db)?.impl_aliases(db);
1646    module_impl_aliases.get(&impl_alias_id).cloned().ok_or_else(skip_diagnostic)
1647}
1648
1649#[salsa::tracked(returns(ref))]
1650fn module_traits_ids_helper<'db>(
1651    db: &'db dyn Database,
1652    module_data: ModuleData<'db>,
1653) -> Vec<TraitId<'db>> {
1654    module_data.traits(db).keys().copied().collect_vec()
1655}
1656
1657pub fn module_traits_ids<'db>(
1658    db: &'db dyn Database,
1659    module_id: ModuleId<'db>,
1660) -> Maybe<&'db [TraitId<'db>]> {
1661    Ok(module_traits_ids_helper(db, module_id.module_data(db)?))
1662}
1663
1664pub fn module_trait_by_id<'db>(
1665    db: &'db dyn Database,
1666    trait_id: TraitId<'db>,
1667) -> Maybe<ast::ItemTrait<'db>> {
1668    let module_traits = trait_id.module_data(db)?.traits(db);
1669    module_traits.get(&trait_id).cloned().ok_or_else(skip_diagnostic)
1670}
1671
1672#[salsa::tracked(returns(ref))]
1673fn module_impls_ids_helper<'db>(
1674    db: &'db dyn Database,
1675    module_data: ModuleData<'db>,
1676) -> Vec<ImplDefId<'db>> {
1677    module_data.impls(db).keys().copied().collect_vec()
1678}
1679
1680pub fn module_impls_ids<'db>(
1681    db: &'db dyn Database,
1682    module_id: ModuleId<'db>,
1683) -> Maybe<&'db [ImplDefId<'db>]> {
1684    Ok(module_impls_ids_helper(db, module_id.module_data(db)?))
1685}
1686pub fn module_impl_by_id<'db>(
1687    db: &'db dyn Database,
1688    impl_def_id: ImplDefId<'db>,
1689) -> Maybe<ast::ItemImpl<'db>> {
1690    let module_impls = impl_def_id.module_data(db)?.impls(db);
1691    module_impls.get(&impl_def_id).cloned().ok_or_else(skip_diagnostic)
1692}
1693
1694#[salsa::tracked(returns(ref))]
1695fn module_extern_types_ids_helper<'db>(
1696    db: &'db dyn Database,
1697    module_data: ModuleData<'db>,
1698) -> Vec<ExternTypeId<'db>> {
1699    module_data.extern_types(db).keys().copied().collect_vec()
1700}
1701pub fn module_extern_types_ids<'db>(
1702    db: &'db dyn Database,
1703    module_id: ModuleId<'db>,
1704) -> Maybe<&'db [ExternTypeId<'db>]> {
1705    Ok(module_extern_types_ids_helper(db, module_id.module_data(db)?))
1706}
1707pub fn module_extern_type_by_id<'db>(
1708    db: &'db dyn Database,
1709    extern_type_id: ExternTypeId<'db>,
1710) -> Maybe<ast::ItemExternType<'db>> {
1711    let module_extern_types = extern_type_id.module_data(db)?.extern_types(db);
1712    module_extern_types.get(&extern_type_id).cloned().ok_or_else(skip_diagnostic)
1713}
1714
1715#[salsa::tracked(returns(ref))]
1716fn module_macro_declarations_ids_helper<'db>(
1717    db: &'db dyn Database,
1718    module_data: ModuleData<'db>,
1719) -> Vec<MacroDeclarationId<'db>> {
1720    module_data.macro_declarations(db).keys().copied().collect_vec()
1721}
1722
1723/// Returns all the ids of the macro declarations of the given module.
1724pub fn module_macro_declarations_ids<'db>(
1725    db: &'db dyn Database,
1726    module_id: ModuleId<'db>,
1727) -> Maybe<&'db [MacroDeclarationId<'db>]> {
1728    Ok(module_macro_declarations_ids_helper(db, module_id.module_data(db)?))
1729}
1730/// Returns the macro declaration of the given id.
1731pub fn module_macro_declaration_by_id<'db>(
1732    db: &'db dyn Database,
1733    macro_declaration_id: MacroDeclarationId<'db>,
1734) -> Maybe<ast::ItemMacroDeclaration<'db>> {
1735    let module_macro_declarations = macro_declaration_id.module_data(db)?.macro_declarations(db);
1736    module_macro_declarations.get(&macro_declaration_id).cloned().ok_or_else(skip_diagnostic)
1737}
1738
1739#[salsa::tracked(returns(ref))]
1740fn module_macro_calls_ids_helper<'db>(
1741    db: &'db dyn Database,
1742    module_data: ModuleData<'db>,
1743) -> Vec<MacroCallId<'db>> {
1744    module_data.macro_calls(db).keys().copied().collect_vec()
1745}
1746
1747pub fn module_macro_calls_ids<'db>(
1748    db: &'db dyn Database,
1749    module_id: ModuleId<'db>,
1750) -> Maybe<&'db [MacroCallId<'db>]> {
1751    Ok(module_macro_calls_ids_helper(db, module_id.module_data(db)?))
1752}
1753/// Query implementation of [DefsGroup::module_macro_call_by_id].
1754fn module_macro_call_by_id<'db>(
1755    db: &'db dyn Database,
1756    macro_call_id: MacroCallId<'db>,
1757) -> Maybe<ast::ItemInlineMacro<'db>> {
1758    let module_macro_calls = macro_call_id.module_data(db)?.macro_calls(db);
1759    module_macro_calls.get(&macro_call_id).cloned().ok_or_else(skip_diagnostic)
1760}
1761
1762#[salsa::tracked(returns(ref))]
1763fn module_extern_functions_ids_helper<'db>(
1764    db: &'db dyn Database,
1765    module_data: ModuleData<'db>,
1766) -> Vec<ExternFunctionId<'db>> {
1767    module_data.extern_functions(db).keys().copied().collect_vec()
1768}
1769
1770pub fn module_extern_functions_ids<'db>(
1771    db: &'db dyn Database,
1772    module_id: ModuleId<'db>,
1773) -> Maybe<&'db [ExternFunctionId<'db>]> {
1774    Ok(module_extern_functions_ids_helper(db, module_id.module_data(db)?))
1775}
1776pub fn module_extern_function_by_id<'db>(
1777    db: &'db dyn Database,
1778    extern_function_id: ExternFunctionId<'db>,
1779) -> Maybe<ast::ItemExternFunction<'db>> {
1780    let module_extern_functions = extern_function_id.module_data(db)?.extern_functions(db);
1781    module_extern_functions.get(&extern_function_id).cloned().ok_or_else(skip_diagnostic)
1782}
1783
1784#[salsa::tracked(returns(ref))]
1785fn module_ancestors_helper<'db>(
1786    db: &'db dyn Database,
1787    _tracked: Tracked,
1788    module_id: ModuleId<'db>,
1789) -> OrderedHashSet<ModuleId<'db>> {
1790    let mut current = module_id;
1791    let mut ancestors = OrderedHashSet::default();
1792    loop {
1793        match current {
1794            ModuleId::CrateRoot(_) => {
1795                ancestors.insert(current);
1796                return ancestors;
1797            }
1798            ModuleId::Submodule(submodule_id) => {
1799                ancestors.insert(current);
1800                current = submodule_id.parent_module(db);
1801            }
1802            ModuleId::MacroCall { id, .. } => {
1803                current = id.parent_module(db);
1804            }
1805        }
1806    }
1807}
1808
1809#[salsa::tracked]
1810fn module_perceived_module_helper<'db>(
1811    db: &'db dyn Database,
1812    _tracked: Tracked,
1813    mut module_id: ModuleId<'db>,
1814) -> ModuleId<'db> {
1815    while let ModuleId::MacroCall { id, .. } = module_id {
1816        module_id = id.parent_module(db);
1817    }
1818    module_id
1819}
1820
1821fn module_item_name_stable_ptr<'db>(
1822    db: &'db dyn Database,
1823    module_id: ModuleId<'db>,
1824    item_id: ModuleItemId<'db>,
1825) -> Maybe<SyntaxStablePtrId<'db>> {
1826    let data = module_id.module_data(db)?;
1827    Ok(match &item_id {
1828        ModuleItemId::Constant(id) => data.constants(db)[id].name(db).stable_ptr(db).untyped(),
1829        ModuleItemId::Submodule(id) => data.submodules(db)[id].name(db).stable_ptr(db).untyped(),
1830        ModuleItemId::Use(id) => data.uses(db)[id].name_stable_ptr(db),
1831        ModuleItemId::FreeFunction(id) => {
1832            data.free_functions(db)[id].declaration(db).name(db).stable_ptr(db).untyped()
1833        }
1834        ModuleItemId::Struct(id) => data.structs(db)[id].name(db).stable_ptr(db).untyped(),
1835        ModuleItemId::Enum(id) => data.enums(db)[id].name(db).stable_ptr(db).untyped(),
1836        ModuleItemId::TypeAlias(id) => data.type_aliases(db)[id].name(db).stable_ptr(db).untyped(),
1837        ModuleItemId::ImplAlias(id) => data.impl_aliases(db)[id].name(db).stable_ptr(db).untyped(),
1838        ModuleItemId::Trait(id) => data.traits(db)[id].name(db).stable_ptr(db).untyped(),
1839        ModuleItemId::Impl(id) => data.impls(db)[id].name(db).stable_ptr(db).untyped(),
1840        ModuleItemId::ExternType(id) => data.extern_types(db)[id].name(db).stable_ptr(db).untyped(),
1841        ModuleItemId::ExternFunction(id) => {
1842            data.extern_functions(db)[id].declaration(db).name(db).stable_ptr(db).untyped()
1843        }
1844        ModuleItemId::MacroDeclaration(id) => {
1845            data.macro_declarations(db)[id].name(db).stable_ptr(db).untyped()
1846        }
1847    })
1848}
1849
1850pub trait DefsGroupEx: DefsGroup {
1851    /// Overrides the default macro plugins available for [`CrateId`] with `plugins`.
1852    ///
1853    /// *Note*: Sets the following Salsa input: `DefsGroup::macro_plugin_overrides`.
1854    fn set_override_crate_macro_plugins<'db>(
1855        &mut self,
1856        crate_id: CrateId<'db>,
1857        plugins: Arc<Vec<MacroPluginId<'db>>>,
1858    ) {
1859        let crate_input = self.crate_input(crate_id);
1860        let mut overrides = self.macro_plugin_overrides_input().clone();
1861        let plugins = plugins.iter().map(|plugin| plugin.long(self).clone()).collect();
1862        overrides.insert(crate_input.clone(), plugins);
1863        defs_group_input(self.as_dyn_database())
1864            .set_macro_plugin_overrides(self)
1865            .to(Some(overrides));
1866    }
1867
1868    /// Overrides the default inline macro plugins available for [`CrateId`] with `plugins`.
1869    ///
1870    /// *Note*: Sets the following Salsa input: `DefsGroup::inline_macro_plugin_overrides`.
1871    fn set_override_crate_inline_macro_plugins<'db>(
1872        &mut self,
1873        crate_id: CrateId<'db>,
1874        plugins: Arc<OrderedHashMap<String, InlineMacroExprPluginId<'db>>>,
1875    ) {
1876        let crate_input = self.crate_input(crate_id);
1877        let mut overrides = self.inline_macro_plugin_overrides_input().clone();
1878        let plugins = Arc::new(
1879            plugins
1880                .iter()
1881                .map(|(name, plugin)| (name.clone(), plugin.long(self).clone()))
1882                .collect(),
1883        );
1884        overrides.insert(crate_input.clone(), plugins);
1885        defs_group_input(self.as_dyn_database())
1886            .set_inline_macro_plugin_overrides(self)
1887            .to(Some(overrides));
1888    }
1889}
1890
1891impl<T: DefsGroup + ?Sized> DefsGroupEx for T {}
cairo_lang_defs/db.rs

cairo_lang_defs/
db.rs
