Cairo plugin reexports (#2000)

fixes #2004

- **Fix duplicated component dependency on itself**
- **Cairo plugin reexports**

Author: maciektr

scarb/src/core/manifest/summary.rs

@@ -24,6 +24,8 @@ pub struct SummaryInner {
     pub package_id: PackageId,
     #[builder(default)]
     pub dependencies: Vec<ManifestDependency>,
+    #[builder(default)]
+    pub re_export_cairo_plugins: Vec<PackageName>,
     #[builder(default = false)]
     pub no_core: bool,
     #[builder(default)]

scarb/src/core/manifest/toml_manifest.rs

@@ -203,6 +203,7 @@ pub struct TomlPackage {
     pub no_core: Option<bool>,
     pub cairo_version: Option<MaybeWorkspaceField<VersionReq>>,
     pub experimental_features: Option<Vec<SmolStr>>,
+    pub re_export_cairo_plugins: Option<Vec<PackageName>>,
 }
 
 #[derive(Clone, Debug, Serialize, Eq, PartialEq)]
@@ -490,9 +491,12 @@ impl TomlManifest {
 
         let publish = package.publish.unwrap_or(true);
 
+        let re_export_cairo_plugins = package.re_export_cairo_plugins.clone().unwrap_or_default();
+
         let summary = Summary::builder()
             .package_id(package_id)
             .dependencies(dependencies)
+            .re_export_cairo_plugins(re_export_cairo_plugins)
             .no_core(no_core)
             .build();
 

scarb/src/core/publishing/manifest_normalization.rs

@@ -81,6 +81,7 @@ fn generate_package(pkg: &Package) -> Box<TomlPackage> {
         no_core: summary.no_core.then_some(true),
         cairo_version: metadata.cairo_version.clone().map(MaybeWorkspace::Defined),
         experimental_features: pkg.manifest.experimental_features.clone(),
+        re_export_cairo_plugins: Some(pkg.manifest.summary.re_export_cairo_plugins.clone()),
     })
 }
 

scarb/src/ops/resolve.rs

@@ -59,13 +59,50 @@ impl WorkspaceResolve {
         &self,
         package_id: PackageId,
         target_kind: &TargetKind,
-    ) -> Vec<Package> {
+    ) -> Result<Vec<Package>> {
         assert!(self.packages.contains_key(&package_id));
-        self.resolve
+        let dependencies = self
+            .resolve
             .package_dependencies_for_target_kind(package_id, target_kind)
             .iter()
             .map(|id| self.packages[id].clone())
-            .collect_vec()
+            .collect_vec();
+
+        let re_exported = dependencies
+            .iter()
+            .flat_map(|dependency| {
+                let package_dependencies = self
+                    .resolve
+                    .package_dependencies_for_target_kind(dependency.id, target_kind);
+                dependency
+                    .manifest
+                    .summary
+                    .re_export_cairo_plugins
+                    .iter()
+                    .map(move |plugin_name| {
+                        package_dependencies
+                            .iter()
+                            .find(|id| id.name == *plugin_name)
+                            .map(|id| {
+                                self.packages.get(id).expect("workspace resolve packages must include all dependency graph nodes").clone()
+                            })
+                            .filter(|package| package.is_cairo_plugin())
+                            .map(Ok)
+                            .unwrap_or_else(|| {
+                                bail!(
+                                "package `{}` cannot re-export cairo plugin `{plugin_name}` which is not a dependency of `{}`",
+                                dependency.id.name, dependency.id.name)
+                            })
+                    })
+
+            })
+            .collect_vec();
+
+        dependencies
+            .into_iter()
+            .map(Ok)
+            .chain(re_exported)
+            .collect::<Result<Vec<Package>>>()
     }
 
     /// Get all dependencies with allowed prebuilt macros for a given package.
@@ -517,21 +554,23 @@ fn cairo_compilation_unit_for_target(
         .iter()
         .find(|component| component.package.id == member.id)
         .unwrap();
-    let mut test_package_deps = solution.component_dependencies(member_component, &components);
-    test_package_deps.push(CompilationUnitDependency::Library(
-        member_component.id.clone(),
-    ));
+    let mut test_package_deps = solution.component_dependencies(member_component, &components)?;
+    if is_integration_test {
+        test_package_deps.push(CompilationUnitDependency::Library(
+            member_component.id.clone(),
+        ));
+    }
 
     let dependencies_for_components: Vec<_> = components
         .iter()
         .map(|component| {
-            if component.package.id == test_package_id {
+            Ok(if component.package.id == test_package_id {
                 test_package_deps.clone()
             } else {
-                solution.component_dependencies(component, &components)
-            }
+                solution.component_dependencies(component, &components)?
+            })
         })
-        .collect();
+        .collect::<Result<Vec<_>>>()?;
 
     for (component, dependencies) in zip(&mut components, dependencies_for_components) {
         component.dependencies = dependencies;
@@ -727,14 +766,14 @@ impl<'a> PackageSolutionCollector<'a> {
         &self,
         component: &CompilationUnitComponent,
         components: &[CompilationUnitComponent],
-    ) -> Vec<CompilationUnitDependency> {
+    ) -> Result<Vec<CompilationUnitDependency>> {
         let package_id = component.id.package_id;
         let component_target_kind = self.target_kind.as_ref().unwrap();
 
         // Those are direct dependencies of the component.
         let dependencies_packages = self
             .resolve
-            .package_dependencies(package_id, component_target_kind);
+            .package_dependencies(package_id, component_target_kind)?;
 
         // We iterate over all the compilation unit components to get dependency's version.
         let mut dependencies: Vec<_> = components
@@ -760,10 +799,8 @@ impl<'a> PackageSolutionCollector<'a> {
             dependencies.push(CompilationUnitDependency::Library(component.id.clone()));
         }
 
-        let plugin_dependencies = self
-            .resolve
-            .package_dependencies(package_id, component_target_kind)
-            .into_iter()
+        let plugin_dependencies = dependencies_packages
+            .iter()
             .filter(|package| package.is_cairo_plugin())
             .map(|package| {
                 CompilationUnitDependency::Plugin(CompilationUnitComponentId {
@@ -773,7 +810,7 @@ impl<'a> PackageSolutionCollector<'a> {
             .collect::<Vec<_>>();
 
         dependencies.extend(plugin_dependencies);
-        dependencies
+        Ok(dependencies)
     }
 
     pub fn show_warnings(self) {

scarb/tests/build_cairo_plugin.rs

@@ -1559,3 +1559,69 @@ fn can_expand_impl_inner_func_attrr() {
 
         "#});
 }
+
+#[test]
+fn can_be_used_through_re_export() {
+    let temp = TempDir::new().unwrap();
+    let t = temp.child("some");
+    CairoPluginProjectBuilder::default()
+        .lib_rs(indoc! {r##"
+            use cairo_lang_macro::{ProcMacroResult, TokenStream, attribute_macro};
+
+            #[attribute_macro]
+            pub fn some(_attr: TokenStream, token_stream: TokenStream) -> ProcMacroResult {
+                let token_stream = TokenStream::new(
+                    token_stream
+                        .to_string()
+                        .replace("12", "34")
+                );
+                ProcMacroResult::new(token_stream)
+            }
+        "##})
+        .build(&t);
+    let dep = temp.child("dep");
+    ProjectBuilder::start()
+        .name("dep")
+        .version("1.0.0")
+        .dep("some", &t)
+        .manifest_package_extra(indoc! {r#"
+            re-export-cairo-plugins = ["some"]
+        "#})
+        .build(&dep);
+    let project = temp.child("hello");
+    ProjectBuilder::start()
+        .name("hello")
+        .version("1.0.0")
+        .dep("dep", &dep)
+        .lib_cairo(indoc! {r#"
+            #[some]
+            fn main() -> felt252 { 12 }
+        "#})
+        .build(&project);
+
+    Scarb::quick_snapbox()
+        .arg("expand")
+        // Disable output from Cargo.
+        .env("CARGO_TERM_QUIET", "true")
+        .current_dir(&project)
+        .assert()
+        .success();
+
+    assert_eq!(
+        project.child("target/dev").files(),
+        vec!["hello.expanded.cairo"]
+    );
+    let expanded = project
+        .child("target/dev/hello.expanded.cairo")
+        .read_to_string();
+    snapbox::assert_eq(
+        indoc! {r#"
+            mod hello {
+                fn main() -> felt252 {
+                    34
+                }
+            }
+        "#},
+        expanded,
+    );
+}