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,6 +7,7 @@ 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 itertools::Itertools;
 use scarb_metadata::{
     CompilationUnitComponentDependencyMetadata, CompilationUnitComponentId, Metadata,
@@ -15,7 +16,9 @@ use scarb_metadata::{
 use smol_str::ToSmolStr;
 use tracing::{debug, error, warn};
 
+use super::builtin_plugins::BuiltinPlugin;
 use super::manifest_registry::member_config::MemberConfig;
+use crate::TRICKS;
 use crate::lang::db::AnalysisDatabase;
 use crate::project::crate_data::Crate;
 
@@ -150,15 +153,12 @@ pub fn extract_crates(metadata: &Metadata) -> Vec<Crate> {
                         .find(|component| component.id.as_ref() == Some(id));
 
                     if let Some(dependency_component) = dependency_component {
-                        Some((
-                            dependency_component.name.clone(),
-                            DependencySettings {
-                                discriminator: dependency_component
-                                    .discriminator
-                                    .as_ref()
-                                    .map(ToSmolStr::to_smolstr),
-                            },
-                        ))
+                        Some((dependency_component.name.clone(), DependencySettings {
+                            discriminator: dependency_component
+                                .discriminator
+                                .as_ref()
+                                .map(ToSmolStr::to_smolstr),
+                        }))
                     } else {
                         error!("component not found in metadata");
                         None
@@ -183,12 +183,56 @@ 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();
+
+            let tricks = TRICKS
+                .get_or_init(|| Default::default())
+                .extra_plugin_suites
+                .map(|provider| provider())
+                .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 = plugin_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
+                    },
+                );
+
             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 +284,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 +295,7 @@ pub fn extract_crates(metadata: &Metadata) -> Vec<Crate> {
             root,
             custom_main_file_stems: Some(custom_main_file_stems),
             settings,
+            builtin_plugins,
         });
     }