Introduced the new per-crate plugin logic

extensions/scarb-doc/src/db.rs

@@ -1,5 +1,5 @@
 use cairo_lang_compiler::project::{update_crate_roots_from_project_config, ProjectConfig};
-use cairo_lang_defs::db::{try_ext_as_virtual_impl, DefsDatabase, DefsGroup};
+use cairo_lang_defs::db::{init_defs_group, try_ext_as_virtual_impl, DefsDatabase, DefsGroup};
 use cairo_lang_doc::db::{DocDatabase, DocGroup};
 use cairo_lang_filesystem::cfg::{Cfg, CfgSet};
 use cairo_lang_filesystem::db::{
@@ -8,7 +8,9 @@ use cairo_lang_filesystem::db::{
 use cairo_lang_filesystem::ids::VirtualFile;
 use cairo_lang_lowering::db::{LoweringDatabase, LoweringGroup};
 use cairo_lang_parser::db::{ParserDatabase, ParserGroup};
-use cairo_lang_semantic::db::{SemanticDatabase, SemanticGroup};
+use cairo_lang_semantic::db::{
+    init_semantic_group, PluginSuiteInput, SemanticDatabase, SemanticGroup,
+};
 use cairo_lang_semantic::inline_macros::get_default_plugin_suite;
 use cairo_lang_semantic::plugin::PluginSuite;
 use cairo_lang_starknet::starknet_plugin_suite;
@@ -44,10 +46,13 @@ impl ScarbDocDatabase {
         };
 
         init_files_group(&mut db);
+        init_defs_group(&mut db);
+        init_semantic_group(&mut db);
 
         db.set_cfg_set(Self::initial_cfg_set().into());
 
-        db.apply_plugin_suite(plugin_suite);
+        let interned_plugin_suite = db.intern_plugin_suite(plugin_suite);
+        db.set_default_plugins_from_suite(interned_plugin_suite);
 
         if let Some(config) = project_config {
             db.apply_project_config(config);
@@ -60,12 +65,6 @@ impl ScarbDocDatabase {
         CfgSet::from_iter([Cfg::name("doc")])
     }
 
-    fn apply_plugin_suite(&mut self, plugin_suite: PluginSuite) {
-        self.set_macro_plugins(plugin_suite.plugins);
-        self.set_inline_macro_plugins(plugin_suite.inline_macro_plugins.into());
-        self.set_analyzer_plugins(plugin_suite.analyzer_plugins);
-    }
-
     fn apply_project_config(&mut self, config: ProjectConfig) {
         update_crate_roots_from_project_config(self, &config);
     }

scarb/src/compiler/compilers/lib.rs

@@ -2,6 +2,9 @@ use anyhow::{Context, Result};
 use cairo_lang_compiler::db::RootDatabase;
 use cairo_lang_compiler::CompilerConfig;
 use cairo_lang_defs::db::DefsGroup;
+use cairo_lang_defs::plugin::MacroPlugin;
+use cairo_lang_filesystem::db::FilesGroup;
+use cairo_lang_filesystem::ids::CrateLongId;
 use cairo_lang_sierra::program::VersionedProgram;
 use cairo_lang_sierra_to_casm::compiler::SierraToCasmConfig;
 use cairo_lang_sierra_to_casm::metadata::{calc_metadata, calc_metadata_ap_change_only};
@@ -142,15 +145,22 @@ fn validate_compiler_config(
     unit: &CairoCompilationUnit,
     ws: &Workspace<'_>,
 ) {
+    let main_component = unit.main_component();
+    let main_crate_id = db.intern_crate(CrateLongId::Real {
+        name: main_component.target_name(),
+        discriminator: main_component.id.to_discriminator(),
+    });
+
     // Generally, lib target compilation should be driven by a certain objective (e.g. cairo-run,
     // test framework, etc.), expressed by the plugin set with executables definition.
     // This does not apply to debug build (expressed by `replace_ids` flag),
     // which is a goal by itself.
     // See starkware-libs/cairo#5440 for more context.
-    let executable_plugin = db
-        .macro_plugins()
-        .iter()
-        .any(|plugin| !plugin.executable_attributes().is_empty());
+    let executable_plugin = db.crate_macro_plugins(main_crate_id).iter().any(|&plugin| {
+        !db.lookup_intern_macro_plugin(plugin)
+            .executable_attributes()
+            .is_empty()
+    });
     if !executable_plugin && !compiler_config.replace_ids {
         ws.config().ui().warn(formatdoc! {r#"
             artefacts produced by this build may be hard to utilize due to the build configuration

scarb/src/compiler/db.rs

@@ -58,13 +58,13 @@ fn load_plugins(
             let package_id = plugin_info.package.id;
             let plugin = ws.config().cairo_plugins().fetch(package_id)?;
             let instance = plugin.instantiate()?;
-            builder.with_plugin_suite(instance.plugin_suite());
+            builder.with_default_plugin_suite(instance.plugin_suite());
         } else {
             proc_macros.register(plugin_info.package.clone(), ws.config())?;
         }
     }
     let macro_host = Arc::new(proc_macros.into_plugin()?);
-    builder.with_plugin_suite(ProcMacroHostPlugin::build_plugin_suite(macro_host.clone()));
+    builder.with_default_plugin_suite(ProcMacroHostPlugin::build_plugin_suite(macro_host.clone()));
     Ok(macro_host)
 }
 
@@ -198,10 +198,15 @@ fn build_project_config(unit: &CairoCompilationUnit) -> Result<ProjectConfig> {
     Ok(project_config)
 }
 
-pub(crate) fn has_starknet_plugin(db: &RootDatabase) -> bool {
-    db.macro_plugins()
+pub(crate) fn has_starknet_plugin(db: &RootDatabase, component: &CompilationUnitComponent) -> bool {
+    let crate_id = db.intern_crate(CrateLongId::Real {
+        name: component.target_name(),
+        discriminator: component.id.to_discriminator(),
+    });
+
+    db.crate_macro_plugins(crate_id)
         .iter()
-        .any(|plugin| is_starknet_plugin(&**plugin))
+        .any(|&plugin| is_starknet_plugin(&db.lookup_intern_macro_plugin(plugin)))
 }
 
 fn is_starknet_plugin(plugin: &dyn MacroPlugin) -> bool {

scarb/src/ops/compile.rs

@@ -302,7 +302,7 @@ fn check_starknet_dependency(
     //   I think we can get away with emitting false positives for users who write raw contracts
     //   without using Starknet code generators. Such people shouldn't do what they do 😁
     if unit.main_component().target_kind() == TargetKind::STARKNET_CONTRACT
-        && !has_starknet_plugin(db)
+        && !has_starknet_plugin(db, unit.main_component())
     {
         ws.config().ui().warn(formatdoc! {
             r#"

scarb/src/ops/proc_macro_server/methods/defined_macros.rs

@@ -1,8 +1,10 @@
 use std::sync::Arc;
 
 use anyhow::Result;
+use cairo_lang_utils::ordered_hash_map::OrderedHashMap;
+use itertools::Itertools;
 use scarb_proc_macro_server_types::methods::defined_macros::{
-    DefinedMacros, DefinedMacrosResponse,
+    DefinedMacros, DefinedMacrosCrateInfo, DefinedMacrosResponse,
 };
 
 use super::Handler;
@@ -13,37 +15,52 @@ impl Handler for DefinedMacros {
         proc_macro_host: Arc<ProcMacroHost>,
         _params: Self::Params,
     ) -> Result<Self::Response> {
-        let mut response = proc_macro_host
+        let crate_macro_info = proc_macro_host
             .macros()
             .iter()
-            .map(|e| DefinedMacrosResponse {
-                attributes: e.declared_attributes(),
-                inline_macros: e.inline_macros(),
-                derives: e.declared_derives(),
-                executables: e.executable_attributes(),
-            })
-            .reduce(|mut acc, defined_macros| {
-                acc.attributes.extend(defined_macros.attributes);
-                acc.inline_macros.extend(defined_macros.inline_macros);
-                acc.derives.extend(defined_macros.derives);
-                acc.executables.extend(defined_macros.executables);
+            .map(|macro_instance| {
+                let attributes = macro_instance
+                    .declared_attributes()
+                    .into_iter()
+                    .sorted()
+                    .dedup()
+                    .collect();
 
-                acc
-            })
-            .unwrap_or_default();
+                let inline_macros = macro_instance
+                    .inline_macros()
+                    .into_iter()
+                    .sorted()
+                    .dedup()
+                    .collect();
 
-        response.attributes.sort();
-        response.attributes.dedup();
+                let derives = macro_instance
+                    .declared_attributes()
+                    .into_iter()
+                    .sorted()
+                    .dedup()
+                    .collect();
 
-        response.inline_macros.sort();
-        response.inline_macros.dedup();
+                let executables = macro_instance
+                    .executable_attributes()
+                    .into_iter()
+                    .sorted()
+                    .dedup()
+                    .collect();
 
-        response.derives.sort();
-        response.derives.dedup();
+                let package_name = macro_instance.package_id().name.to_smol_str();
 
-        response.executables.sort();
-        response.executables.dedup();
+                (
+                    package_name,
+                    DefinedMacrosCrateInfo {
+                        attributes,
+                        inline_macros,
+                        derives,
+                        executables,
+                    },
+                )
+            })
+            .collect::<OrderedHashMap<_, _>>();
 
-        Ok(response)
+        Ok(DefinedMacrosResponse { crate_macro_info })
     }
 }

scarb/tests/proc_macro_server.rs

@@ -37,11 +37,17 @@ fn defined_macros() {
     let response = proc_macro_server
         .request_and_wait::<DefinedMacros>(DefinedMacrosParams {})
         .unwrap();
+    let response = response.crate_macro_info;
 
-    assert_eq!(response.attributes, vec!["some".to_string()]);
-    assert_eq!(response.derives, vec!["some_derive".to_string()]);
-    assert_eq!(response.inline_macros, vec!["inline_some".to_string()]);
-    assert_eq!(response.executables, vec!["some_executable".to_string()]);
+    let packages = response.keys().collect::<Vec<_>>();
+    assert_eq!(packages.len(), 1);
+    assert_eq!(packages[0], "test_package");
+
+    let crate_macros = &response["test_package"];
+    assert_eq!(&crate_macros.attributes, &["some".to_string()]);
+    assert_eq!(&crate_macros.derives, &["some_derive".to_string()]);
+    assert_eq!(&crate_macros.inline_macros, &["inline_some".to_string()]);
+    assert_eq!(&crate_macros.executables, &["some_executable".to_string()]);
 }
 
 #[test]

utils/scarb-proc-macro-server-types/Cargo.toml

@@ -11,5 +11,7 @@ repository.workspace = true
 
 [dependencies]
 cairo-lang-macro = { version = "0.1", features = ["serde"] }
+cairo-lang-utils.workspace = true
 serde.workspace = true
 serde_json.workspace = true
+smol_str.workspace = true

utils/scarb-proc-macro-server-types/src/methods/defined_macros.rs

@@ -1,11 +1,19 @@
 use super::Method;
+use cairo_lang_utils::ordered_hash_map::OrderedHashMap;
 use serde::{Deserialize, Serialize};
+use smol_str::SmolStr;
+
+/// Response structure containing a mapping from package names to the information about the macros they use.
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct DefinedMacrosResponse {
+    pub crate_macro_info: OrderedHashMap<SmolStr, DefinedMacrosCrateInfo>,
+}
 
 /// Response structure containing lists of all defined macros supported.
 ///
 /// Details the types of macros that can be expanded, such as attributes, inline macros, and derives.
 #[derive(Debug, Default, Serialize, Deserialize)]
-pub struct DefinedMacrosResponse {
+pub struct DefinedMacrosCrateInfo {
     /// List of attribute macro names available.
     pub attributes: Vec<String>,
     /// List of inline macro names available.