Support proc macro crate fingerprint in PMS (#2892)

software-mansion/cairols#775

Author: Draggu

scarb/src/compiler/incremental/fingerprint.rs

@@ -151,7 +151,7 @@ impl UnitComponentsFingerprint {
                 ),
                 ToFingerprint::Plugin(plugin) => (
                     plugin.component_dependency_id.clone(),
-                    PluginFingerprint::try_from_plugin(plugin, unit, ws)
+                    PluginFingerprint::try_from_plugin(plugin, ws)
                         .await
                         .map(ComponentFingerprint::Plugin),
                 ),
@@ -233,7 +233,6 @@ impl ComponentFingerprint {
 impl PluginFingerprint {
     pub async fn try_from_plugin(
         component: &CompilationUnitCairoPlugin,
-        _unit: &CairoCompilationUnit,
         ws: &Workspace<'_>,
     ) -> Result<Self> {
         let component_discriminator = component
@@ -299,6 +298,14 @@ impl PluginFingerprint {
     }
 
     pub fn digest(&self) -> String {
+        self.prepare_hasher().finish_as_short_hash()
+    }
+
+    pub fn digest_u64(&self) -> u64 {
+        self.prepare_hasher().finish()
+    }
+
+    fn prepare_hasher(&self) -> StableHasher {
         let mut hasher = StableHasher::new();
         self.component_discriminator.hash(&mut hasher);
         self.is_builtin.hash(&mut hasher);
@@ -322,7 +329,7 @@ impl PluginFingerprint {
                 .unwrap_or_default()
                 .hash(&mut hasher);
         }
-        hasher.finish_as_short_hash()
+        hasher
     }
 }
 

scarb/src/compiler/incremental/mod.rs

@@ -7,3 +7,5 @@ pub use compilation::{
     IncrementalContext, load_incremental_artifacts, save_incremental_artifacts,
     warmup_incremental_cache,
 };
+
+pub use fingerprint::PluginFingerprint;

scarb/src/compiler/plugin/collection.rs

@@ -10,6 +10,7 @@ use smol_str::SmolStr;
 use std::vec::IntoIter;
 
 use super::proc_macro::{DeclaredProcMacroInstances, ProcMacroHostPlugin, ProcMacroInstance};
+use crate::compiler::incremental::PluginFingerprint;
 use crate::compiler::plugin::CairoPlugin;
 use crate::core::PackageId;
 use crate::{
@@ -27,12 +28,17 @@ impl PluginsForComponents {
     pub fn collect(workspace: &Workspace<'_>, unit: &CairoCompilationUnit) -> Result<Self> {
         let mut plugins = collect_builtin_plugins(workspace, unit)?;
 
-        let proc_macros = collect_proc_macros(workspace, unit)?
+        let proc_macros = collect_proc_macros(workspace, unit, false)?
             .into_iter()
             .map(|(component_id, instances)| {
                 Ok((
                     component_id,
-                    ComponentProcMacroHost::try_from_instances(instances)?,
+                    ComponentProcMacroHost::try_from_instances(
+                        instances
+                            .into_iter()
+                            .map(|(instance, _hash)| instance)
+                            .collect(),
+                    )?,
                 ))
             })
             .collect::<Result<HashMap<_, _>>>()?;
@@ -65,6 +71,8 @@ pub struct WorkspaceProcMacros {
     /// each mapped to a [`ProcMacroHostPlugin`] which contains
     /// **all proc macro dependencies of the package** collected from **all compilation units it appears in**.
     pub macros_for_components: HashMap<CompilationUnitComponent, Arc<Vec<ProcMacroHostPlugin>>>,
+    /// Mapping from package id to fingerprint hash.
+    pub instance_to_hash: HashMap<PackageId, u64>,
 }
 
 impl WorkspaceProcMacros {
@@ -76,7 +84,7 @@ impl WorkspaceProcMacros {
         let mut macros_for_components = HashMap::<_, Vec<_>>::new();
 
         for &unit in compilation_units {
-            for (component_id, mut macro_instances) in collect_proc_macros(workspace, unit)? {
+            for (component_id, mut macro_instances) in collect_proc_macros(workspace, unit, true)? {
                 let component: CompilationUnitComponent = unit
                     .components
                     .iter()
@@ -91,11 +99,18 @@ impl WorkspaceProcMacros {
             }
         }
 
+        let instance_to_hash: HashMap<_, _> = macros_for_components
+            .values()
+            .flatten()
+            .map(|(key, value)| (key.package_id(), *value))
+            .collect();
+
         let macros_for_components = macros_for_components
             .into_iter()
             .map(|(component, macro_instances)| {
                 let deduplicated_instances: Vec<Arc<ProcMacroInstance>> = macro_instances
                     .into_iter()
+                    .map(|(instance, _hash)| instance)
                     .unique_by(|instance| instance.package_id())
                     .collect();
                 let proc_macros =
@@ -107,6 +122,7 @@ impl WorkspaceProcMacros {
 
         Ok(Self {
             macros_for_components,
+            instance_to_hash,
         })
     }
 
@@ -189,12 +205,15 @@ impl PluginSuiteAssembler {
     }
 }
 
+type InstanceAndHash = (Arc<ProcMacroInstance>, u64);
+
 /// Collects [`ProcMacroInstances`]s for each component of the [`CairoCompilationUnit`],
 /// according to the dependencies on procedural macros.
 fn collect_proc_macros(
     workspace: &Workspace<'_>,
     unit: &CairoCompilationUnit,
-) -> Result<HashMap<CompilationUnitComponentId, Vec<Arc<ProcMacroInstance>>>> {
+    include_hash: bool,
+) -> Result<HashMap<CompilationUnitComponentId, Vec<InstanceAndHash>>> {
     let mut proc_macros_for_components = HashMap::new();
 
     for component in unit.components.iter() {
@@ -215,7 +234,19 @@ fn collect_proc_macros(
                 continue;
             }
 
-            component_proc_macro_instances.push(plugin.instantiate(workspace.config())?);
+            // We have to disable it in regular scarb in order to `--no-proc-macros` flag work correctly
+            let hash = if include_hash {
+                workspace
+                    .config()
+                    .tokio_handle()
+                    .block_on(PluginFingerprint::try_from_plugin(plugin, workspace))?
+                    .digest_u64()
+            } else {
+                // This value will be ignored, it does not matter
+                0
+            };
+
+            component_proc_macro_instances.push((plugin.instantiate(workspace.config())?, hash));
         }
 
         proc_macros_for_components.insert(component.id.clone(), component_proc_macro_instances);

scarb/src/compiler/plugin/proc_macro/host.rs

@@ -1,5 +1,6 @@
 use crate::compiler::plugin::proc_macro::{ExpansionQuery, ProcMacroInstance};
 use crate::compiler::plugin::{ProcMacroApiVersion, proc_macro};
+use crate::core::PackageId;
 use anyhow::Result;
 use cairo_lang_semantic::db::SemanticGroup;
 use cairo_lang_semantic::plugin::PluginSuite;
@@ -76,48 +77,69 @@ pub trait DeclaredProcMacroInstances {
         })
     }
 
-    // NOTE: Required for proc macro server. `<ProcMacroHostPlugin as MacroPlugin>::declared_attributes`
-    // returns attributes **and** executables. In PMS, we only need the former because the latter is handled separately.
-    fn declared_attributes_without_executables(&self) -> Vec<String> {
+    fn declared_inline_macros(&self) -> Vec<String> {
         self.instances()
             .iter()
-            .flat_map(|instance| instance.declared_attributes())
+            .flat_map(|instance| instance.inline_macros())
             .collect()
     }
 
-    fn declared_inline_macros(&self) -> Vec<String> {
+    fn declared_derives(&self) -> Vec<String> {
         self.instances()
             .iter()
-            .flat_map(|instance| instance.inline_macros())
+            .flat_map(|m| m.declared_derives())
             .collect()
     }
 
-    fn declared_derives(&self) -> Vec<String> {
+    fn executable_attributes(&self) -> Vec<String> {
         self.instances()
             .iter()
-            .flat_map(|m| m.declared_derives())
+            .flat_map(|m| m.executable_attributes())
             .collect()
     }
 
-    fn declared_derives_snake_case(&self) -> Vec<String> {
+    fn declared_attributes(&self) -> Vec<String> {
         self.instances()
             .iter()
-            .flat_map(|m| m.declared_derives_snake_case())
+            .flat_map(|m| m.declared_attributes_and_executables())
+            .chain(vec![FULL_PATH_MARKER_KEY.to_string()])
             .collect()
     }
 
-    fn executable_attributes(&self) -> Vec<String> {
+    // NOTE: Required for proc macro server. `<ProcMacroHostPlugin as MacroPlugin>::declared_attributes`
+    // returns attributes **and** executables. In PMS, we only need the former because the latter is handled separately.
+    fn declared_attributes_without_executables_with_package(&self) -> Vec<(String, PackageId)> {
         self.instances()
             .iter()
-            .flat_map(|m| m.executable_attributes())
+            .flat_map(|instance| {
+                instance
+                    .declared_attributes()
+                    .into_iter()
+                    .map(|name| (name, instance.package_id()))
+            })
             .collect()
     }
 
-    fn declared_attributes(&self) -> Vec<String> {
+    fn declared_inline_macros_with_package(&self) -> Vec<(String, PackageId)> {
         self.instances()
             .iter()
-            .flat_map(|m| m.declared_attributes_and_executables())
-            .chain(vec![FULL_PATH_MARKER_KEY.to_string()])
+            .flat_map(|instance| {
+                instance
+                    .inline_macros()
+                    .into_iter()
+                    .map(|name| (name, instance.package_id()))
+            })
+            .collect()
+    }
+
+    fn declared_derives_snake_case_with_package(&self) -> Vec<(String, PackageId)> {
+        self.instances()
+            .iter()
+            .flat_map(|m| {
+                m.declared_derives_snake_case()
+                    .into_iter()
+                    .map(|name| (name, m.package_id()))
+            })
             .collect()
     }
 }

scarb/src/compiler/plugin/proc_macro/instance.rs

@@ -8,6 +8,7 @@ use camino::{Utf8Path, Utf8PathBuf};
 use serde::{Deserialize, Serialize};
 use smol_str::SmolStr;
 use std::fmt::Debug;
+use std::hash::Hash;
 use tracing::trace;
 
 #[derive(

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

@@ -4,7 +4,7 @@ use anyhow::Result;
 use camino::Utf8Path;
 use itertools::Itertools;
 use scarb_proc_macro_server_types::methods::defined_macros::{
-    CompilationUnitComponentMacros, DebugInfo, DefinedMacros, DefinedMacrosResponse,
+    CompilationUnitComponentMacros, DebugInfo, DefinedMacros, DefinedMacrosResponse, MacroWithHash,
 };
 
 use crate::{
@@ -94,9 +94,30 @@ fn get_macros_for_components(
             plugin
                 .iter()
                 .map(|plugin| {
-                    let attributes = plugin.declared_attributes_without_executables();
-                    let inline_macros = plugin.declared_inline_macros();
-                    let derives = plugin.declared_derives_snake_case();
+                    let attributes = plugin
+                        .declared_attributes_without_executables_with_package()
+                        .into_iter()
+                        .map(|(name, package)| MacroWithHash {
+                            name,
+                            hash: *workspace_macros.instance_to_hash.get(&package).unwrap(),
+                        })
+                        .collect();
+                    let inline_macros = plugin
+                        .declared_inline_macros_with_package()
+                        .into_iter()
+                        .map(|(name, package)| MacroWithHash {
+                            name,
+                            hash: *workspace_macros.instance_to_hash.get(&package).unwrap(),
+                        })
+                        .collect();
+                    let derives = plugin
+                        .declared_derives_snake_case_with_package()
+                        .into_iter()
+                        .map(|(name, package)| MacroWithHash {
+                            name,
+                            hash: *workspace_macros.instance_to_hash.get(&package).unwrap(),
+                        })
+                        .collect();
                     let executables = plugin.executable_attributes();
                     let source_packages = plugin
                         .instances()

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

@@ -9,8 +9,7 @@ use scarb_proc_macro_server_types::methods::{ProcMacroResult, expand::ExpandAttr
 use super::{Handler, interface_code_mapping_from_cairo};
 use crate::compiler::plugin::proc_macro::v2::generate_code_mappings;
 use crate::compiler::plugin::proc_macro::{
-    DeclaredProcMacroInstances, ExpansionKind, ExpansionQuery, ProcMacroApiVersion,
-    ProcMacroInstance,
+    ExpansionKind, ExpansionQuery, ProcMacroApiVersion, ProcMacroInstance,
 };
 use crate::core::Config;
 use crate::ops::store::ProcMacroStore;
@@ -29,34 +28,37 @@ impl Handler for ExpandAttribute {
             adapted_call_site,
         } = params;
         let expansion = ExpansionQuery::with_expansion_name(&attr, ExpansionKind::Attr);
-        let plugins = proc_macros.lock().unwrap().get_plugins(&context);
-        let proc_macro_instance = plugins
-            .as_ref()
-            .and_then(|v| {
-                v.iter()
-                    .filter_map(|plugin| plugin.find_instance_with_expansion(&expansion))
-                    .next()
-            })
+        let (proc_macro_instance, hash) = proc_macros
+            .lock()
+            .unwrap()
+            .get_instance_and_hash(&context, &expansion)
             .with_context(|| {
                 format!("No \"{attr}\" attribute macros found in scope: {context:?}")
             })?;
 
         match proc_macro_instance.api_version() {
             ProcMacroApiVersion::V1 => expand_attribute_v1(
-                proc_macro_instance,
+                &proc_macro_instance,
+                hash,
                 attr,
                 token_stream_v2_to_v1(&args),
                 token_stream_v2_to_v1(&item),
             ),
-            ProcMacroApiVersion::V2 => {
-                expand_attribute_v2(proc_macro_instance, attr, adapted_call_site, args, item)
-            }
+            ProcMacroApiVersion::V2 => expand_attribute_v2(
+                &proc_macro_instance,
+                hash,
+                attr,
+                adapted_call_site,
+                args,
+                item,
+            ),
         }
     }
 }
 
 fn expand_attribute_v1(
     proc_macro_instance: &Arc<ProcMacroInstance>,
+    fingerprint: u64,
     attr: String,
     args: TokenStreamV1,
     item: TokenStreamV1,
@@ -69,11 +71,13 @@ fn expand_attribute_v1(
         token_stream: result.token_stream,
         diagnostics: result.diagnostics.iter().map(diagnostic_v1_to_v2).collect(),
         code_mappings: None,
+        fingerprint,
     })
 }
 
 fn expand_attribute_v2(
     proc_macro_instance: &Arc<ProcMacroInstance>,
+    fingerprint: u64,
     attr: String,
     adapted_call_site: TextSpan,
     args: TokenStreamV2,
@@ -96,5 +100,6 @@ fn expand_attribute_v2(
                 .map(interface_code_mapping_from_cairo)
                 .collect(),
         ),
+        fingerprint,
     })
 }