Store plugins in the Crate structure

commit-id:988401af

src/project/crate_data.rs

@@ -7,13 +7,14 @@ use cairo_lang_filesystem::db::{
     FilesGroupEx,
 };
 use cairo_lang_filesystem::ids::{CrateId, CrateLongId, Directory};
+use cairo_lang_semantic::plugin::PluginSuite;
 use cairo_lang_utils::{Intern, LookupIntern};
 use smol_str::SmolStr;
 
 use crate::lang::db::AnalysisDatabase;
 
 /// A complete set of information needed to set up a real crate in the analysis database.
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug)]
 pub struct Crate {
     /// Crate name.
     pub name: SmolStr,
@@ -36,6 +37,10 @@ pub struct Crate {
 
     /// Crate settings.
     pub settings: CrateSettings,
+
+    /// Built-in plugins required by the crate.
+    #[allow(dead_code)] // TODO: remove. The field is used later in the stack
+    pub builtin_plugins: PluginSuite,
 }
 
 impl Crate {
@@ -61,6 +66,8 @@ impl Crate {
         if let Some(file_stems) = &self.custom_main_file_stems {
             inject_virtual_wrapper_lib(db, crate_id, file_stems);
         }
+
+        // TODO (later in the stack): Intern the plugin suite and set as override.
     }
 
     /// Construct a [`Crate`] from data already applied to the [`AnalysisDatabase`].
@@ -79,7 +86,18 @@ impl Crate {
 
         let custom_main_file_stems = extract_custom_file_stems(db, crate_id);
 
-        Some(Self { name, discriminator, root, custom_main_file_stems, settings })
+        // TODO (later in the stack): Extract plugins associated with this crate
+        // from db and store it in this suite.
+        let plugins = PluginSuite::default();
+
+        Some(Self {
+            name,
+            discriminator,
+            root,
+            custom_main_file_stems,
+            settings,
+            builtin_plugins: plugins,
+        })
     }
 
     /// States whether this is the `core` crate.

src/project/scarb.rs

@@ -7,15 +7,22 @@ use cairo_lang_filesystem::cfg::CfgSet;
 use cairo_lang_filesystem::db::{
     CrateSettings, DependencySettings, Edition, ExperimentalFeaturesConfig,
 };
+use cairo_lang_semantic::inline_macros::get_default_plugin_suite;
+use cairo_lang_semantic::plugin::PluginSuite;
+use cairo_lang_test_plugin::{test_assert_suite, test_plugin_suite};
 use itertools::Itertools;
 use scarb_metadata::{
-    CompilationUnitComponentDependencyMetadata, CompilationUnitComponentId, Metadata,
-    PackageMetadata,
+    CompilationUnitCairoPluginMetadata, CompilationUnitComponentDependencyMetadata,
+    CompilationUnitComponentId, Metadata, PackageMetadata,
 };
 use smol_str::ToSmolStr;
 use tracing::{debug, error, warn};
 
+use super::builtin_plugins::BuiltinPlugin;
 use super::manifest_registry::member_config::MemberConfig;
+use crate::TRICKS;
+#[cfg(doc)]
+use crate::Tricks;
 use crate::lang::db::AnalysisDatabase;
 use crate::project::crate_data::Crate;
 
@@ -183,12 +190,41 @@ pub fn extract_crates(metadata: &Metadata) -> Vec<Crate> {
 
             let custom_main_file_stems = (file_stem != "lib").then_some(vec![file_stem.into()]);
 
+            let plugin_dependencies = component
+                .dependencies
+                .as_ref()
+                .map(|dependencies| {
+                    dependencies
+                        .iter()
+                        .filter_map(|dependency| {
+                            compilation_unit.cairo_plugins.iter().find(|plugin| {
+                                match plugin.component_dependency_id {
+                                    Some(ref id) => id == &dependency.id,
+                                    None => false,
+                                }
+                            })
+                        })
+                        .collect_vec()
+                })
+                .unwrap_or_default();
+
+            // We collect and instantiate only the built-in plugins.
+            // Procedural macros are handled separately in the `proc_macro_controller`.
+
+            let builtin_plugins = if package.map(|p| p.name == "core").unwrap_or_default() {
+                // Corelib is a special case because it is described by `cairo_project.toml`.
+                plugin_suite_for_corelib()
+            } else {
+                plugin_suite_from_dependencies(metadata, &plugin_dependencies)
+            };
+
             let cr = Crate {
                 name: crate_name.into(),
                 discriminator: component.discriminator.as_ref().map(ToSmolStr::to_smolstr),
                 root: root.into(),
                 custom_main_file_stems,
                 settings,
+                builtin_plugins,
             };
 
             if compilation_unit.package == component.package {
@@ -240,6 +276,8 @@ pub fn extract_crates(metadata: &Metadata) -> Vec<Crate> {
         let name = first_crate.name.clone();
         let discriminator = first_crate.discriminator.clone();
 
+        let builtin_plugins = first_crate.builtin_plugins.clone();
+
         let custom_main_file_stems =
             crs.into_iter().flat_map(|cr| cr.custom_main_file_stems.unwrap()).collect();
 
@@ -249,6 +287,7 @@ pub fn extract_crates(metadata: &Metadata) -> Vec<Crate> {
             root,
             custom_main_file_stems: Some(custom_main_file_stems),
             settings,
+            builtin_plugins,
         });
     }
 
@@ -348,3 +387,46 @@ fn scarb_package_experimental_features(
         coupons: contains("coupons"),
     }
 }
+
+/// Returns the extra [`PluginSuite`]s injected as [`Tricks`].
+fn tricks() -> Vec<PluginSuite> {
+    TRICKS
+        .get_or_init(Default::default)
+        .extra_plugin_suites
+        .map(|provider| provider())
+        .unwrap_or_default()
+}
+
+/// Returns all plugins required by the `core` crate.
+fn plugin_suite_for_corelib() -> PluginSuite {
+    [get_default_plugin_suite(), test_plugin_suite(), test_assert_suite()]
+        .into_iter()
+        .chain(tricks().into_iter()) // All crates should receive the `Tricks`.
+        .fold(PluginSuite::default(), |mut acc, suite| {
+            acc.add(suite);
+            acc
+        })
+}
+
+/// Returns all built-in plugins described by `dependencies`.
+fn plugin_suite_from_dependencies(
+    metadata: &Metadata,
+    dependencies: &[&CompilationUnitCairoPluginMetadata],
+) -> PluginSuite {
+    dependencies
+        .into_iter()
+        .filter_map(|plugin_metadata| {
+            let builtin_plugin =
+                BuiltinPlugin::from_plugin_metadata(metadata, plugin_metadata)?;
+
+            Some(builtin_plugin.suite())
+        })
+        .chain(tricks().into_iter()) // All crates should receive the `Tricks`.
+        .fold(
+            get_default_plugin_suite(), // All crates have basic plugins set by default.
+            |mut acc, suite| {
+                acc.add(suite);
+                acc
+            },
+        )
+}