[scarb-doc] Initial markdown

Cargo.toml

@@ -136,7 +136,7 @@ zip = { version = "0.6", default-features = false, features = ["deflate"] }
 zstd = "0.13"
 
 [profile.release]
-lto = true
+#lto = true
 
 [profile.ci]
 inherits = "test"

extensions/scarb-doc/Cargo.toml

@@ -15,6 +15,7 @@ clap.workspace = true
 cairo-lang-compiler.workspace = true
 cairo-lang-defs.workspace = true
 cairo-lang-semantic.workspace = true
+cairo-lang-starknet.workspace = true
 cairo-lang-syntax.workspace = true
 cairo-lang-filesystem.workspace = true
 cairo-lang-utils.workspace = true

extensions/scarb-doc/src/compilation.rs

@@ -9,21 +9,20 @@ use cairo_lang_filesystem::cfg::{Cfg, CfgSet};
 use cairo_lang_filesystem::db::{CrateSettings, Edition, ExperimentalFeaturesConfig};
 use cairo_lang_filesystem::ids::Directory;
 use cairo_lang_utils::ordered_hash_map::OrderedHashMap;
+use itertools::Itertools;
 
 const LIB_TARGET_KIND: &str = "lib";
+const STARKNET_TARGET_KIND: &str = "starknet-contract";
 const CORELIB_CRATE_NAME: &str = "core";
 
 pub fn get_project_config(
     metadata: &Metadata,
     package_metadata: &PackageMetadata,
 ) -> ProjectConfig {
-    let compilation_unit_metadata =
-        package_lib_compilation_unit(metadata, package_metadata.id.clone())
-            .expect("failed to find compilation unit for package");
+    let compilation_unit_metadata = package_compilation_unit(metadata, package_metadata.id.clone());
     let corelib = get_corelib(compilation_unit_metadata);
     let dependencies = get_dependencies(compilation_unit_metadata);
     let crates_config = get_crates_config(metadata, compilation_unit_metadata);
-
     ProjectConfig {
         base_path: package_metadata.root.clone().into(),
         corelib: Some(Directory::Real(corelib.source_root().into())),
@@ -34,14 +33,25 @@ pub fn get_project_config(
     }
 }
 
-fn package_lib_compilation_unit(
+fn package_compilation_unit(
     metadata: &Metadata,
     package_id: PackageId,
-) -> Option<&CompilationUnitMetadata> {
-    metadata
+) -> &CompilationUnitMetadata {
+    let relevant_cus = metadata
         .compilation_units
         .iter()
-        .find(|m| m.package == package_id && m.target.kind == LIB_TARGET_KIND)
+        .filter(|m| m.package == package_id)
+        .collect_vec();
+
+    relevant_cus
+        .iter()
+        .find(|m| m.target.kind == LIB_TARGET_KIND)
+        .or_else(|| {
+            relevant_cus
+                .iter()
+                .find(|m| m.target.kind == STARKNET_TARGET_KIND)
+        })
+        .expect("failed to find compilation unit for package")
 }
 
 fn get_corelib(

extensions/scarb-doc/src/main.rs

@@ -7,18 +7,26 @@ use scarb_ui::args::PackagesFilter;
 use cairo_lang_compiler::db::RootDatabase;
 use cairo_lang_filesystem::db::FilesGroup;
 use cairo_lang_filesystem::ids::CrateLongId;
+use cairo_lang_starknet::starknet_plugin_suite;
 
 use compilation::get_project_config;
 use types::Crate;
 
+use std::path::PathBuf;
+
 mod compilation;
+mod render;
 mod types;
 
 #[derive(Parser, Debug)]
 #[command(version, about, long_about = None)]
 struct Args {
     #[command(flatten)]
     packages_filter: PackagesFilter,
+
+    /// Generate the documentation.
+    #[arg(long)]
+    save: bool,
 }
 
 macro_rules! print_names {
@@ -42,19 +50,27 @@ fn main() -> Result<()> {
     let db = &mut {
         let mut b = RootDatabase::builder();
         b.with_project_config(project_config);
+        b.with_plugin_suite(starknet_plugin_suite());
         b.build()?
     };
 
     let main_crate_id = db.intern_crate(CrateLongId::Real(package_metadata.name.clone().into()));
     let crate_ = Crate::new(db, main_crate_id);
 
     print_module(&crate_.root_module);
+    println!("{crate_:?}");
+
+    if args.save {
+        let path = PathBuf::from(crate_.root_module.name.as_str());
+        let doc_path = PathBuf::from("doc").join(path);
+        crate_.root_module.save_to_file_recursive(&doc_path)?;
+    }
 
     Ok(())
 }
 
 fn print_module(module: &types::Module) {
-    println!("Module: {}", module.full_path);
+    println!("Module: {:?}", module.full_path);
     println!(
         "Submodules      : {:?}",
         module
@@ -67,11 +83,34 @@ fn print_module(module: &types::Module) {
     print_names!("Uses            ", module.uses);
     print_names!("Free Functions  ", module.free_functions);
     print_names!("Structs         ", module.structs);
+    for st in module.structs.iter() {
+        println!("    Struct {:?}", st.item_data.name);
+        print_names!("        Members", st.members);
+    }
+
     print_names!("Enums           ", module.enums);
+    for enu in module.enums.iter() {
+        println!("    Enum {:?}", enu.item_data.name);
+        print_names!("        Variants", enu.variants);
+    }
     print_names!("Type Aliases    ", module.type_aliases);
     print_names!("Impl Aliases    ", module.impl_aliases);
+
     print_names!("Traits          ", module.traits);
+    for tr in module.traits.iter() {
+        println!("    Trait {:?}", tr.item_data.name);
+        print_names!("        Trait constants", tr.trait_constants);
+        print_names!("        Trait types    ", tr.trait_types);
+        print_names!("        Trait functions", tr.trait_functions);
+    }
+
     print_names!("Impls           ", module.impls);
+    for imp in module.impls.iter() {
+        println!("    Impl {:?}", imp.item_data.name);
+        print_names!("        Impl types     ", imp.impl_types);
+        print_names!("        Impl constants ", imp.impl_constants);
+        print_names!("        Impl functions ", imp.impl_functions);
+    }
     print_names!("Extern Types    ", module.extern_types);
     print_names!("Extern Functions", module.extern_functions);