Implement a command to dump impls for a given type

tritao · tritao · commit 2b84e0145f55 · 2025-08-11T14:06:00.000+01:00
Closes #7286.
diff --git a/forc-pkg/src/manifest/build_profile.rs b/forc-pkg/src/manifest/build_profile.rs
@@ -1,6 +1,8 @@
 use serde::{Deserialize, Serialize};
 use sway_core::{Backtrace, OptLevel, PrintAsm, PrintIr};
 
+use crate::DumpOpts;
+
 /// Parameters to pass through to the `sway_core::BuildConfig` during compilation.
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
 #[serde(rename_all = "kebab-case")]
@@ -11,6 +13,7 @@ pub struct BuildProfile {
     pub print_ast: bool,
     pub print_dca_graph: Option<String>,
     pub print_dca_graph_url_format: Option<String>,
+    pub dump: DumpOpts,
     #[serde(default)]
     pub print_ir: PrintIr,
     #[serde(default)]
@@ -47,6 +50,7 @@ impl BuildProfile {
     pub fn debug() -> Self {
         Self {
             name: Self::DEBUG.into(),
+            dump: DumpOpts::default(),
             print_ast: false,
             print_dca_graph: None,
             print_dca_graph_url_format: None,
@@ -69,6 +73,7 @@ impl BuildProfile {
     pub fn release() -> Self {
         Self {
             name: Self::RELEASE.to_string(),
+            dump: DumpOpts::default(),
             print_ast: false,
             print_dca_graph: None,
             print_dca_graph_url_format: None,
diff --git a/forc-pkg/src/pkg.rs b/forc-pkg/src/pkg.rs
@@ -279,12 +279,19 @@ pub struct MinifyOpts {
 /// Represents a compiled contract ID as a pub const in a contract.
 type ContractIdConst = String;
 
+#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, Eq)]
+pub struct DumpOpts {
+    /// Dump all trait implementations for the given type name.
+    pub dump_impls: Option<String>,
+}
+
 /// The set of options provided to the `build` functions.
 #[derive(Default, Clone)]
 pub struct BuildOpts {
     pub pkg: PkgOpts,
     pub print: PrintOpts,
     pub minify: MinifyOpts,
+    pub dump: DumpOpts,
     /// If set, generates a JSON file containing the hex-encoded script binary.
     pub hex_outfile: Option<String>,
     /// If set, outputs a binary file representing the script bytes.
@@ -1724,7 +1731,7 @@ pub fn compile(
             &handler,
             engines,
             source,
-            namespace,
+            namespace.clone(),
             Some(&sway_build_config),
             &pkg.name,
             None,
@@ -1754,6 +1761,10 @@ pub fn compile(
         return fail(handler);
     }
 
+    if let Some(typename) = &profile.dump.dump_impls {
+        sway_core::check_dump_impls(engines, &namespace, typename);
+    }
+
     let asm_res = time_expr!(
         pkg.name,
         "compile ast to asm",
@@ -2108,6 +2119,7 @@ fn build_profile_from_opts(
         metrics_outfile,
         tests,
         error_on_warnings,
+        dump,
         ..
     } = build_options;
 
@@ -2128,6 +2140,7 @@ fn build_profile_from_opts(
             BuildProfile::default()
         });
     profile.name = selected_profile_name.into();
+    profile.dump = dump.clone();
     profile.print_ast |= print.ast;
     if profile.print_dca_graph.is_none() {
         profile.print_dca_graph.clone_from(&print.dca_graph);
diff --git a/forc-plugins/forc-client/src/op/deploy.rs b/forc-plugins/forc-client/src/op/deploy.rs
@@ -12,7 +12,7 @@ use crate::{
     },
 };
 use anyhow::{bail, Context, Result};
-use forc_pkg::{self as pkg, PackageManifestFile};
+use forc_pkg::{self as pkg, DumpOpts, PackageManifestFile};
 use forc_pkg::{manifest::GenericManifestFile, MemberFilter};
 use forc_tracing::{println_action_green, println_warning};
 use forc_util::default_output_directory;
@@ -814,6 +814,7 @@ fn build_opts_from_cmd(cmd: &cmd::Deploy, member_filter: pkg::MemberFilter) -> p
             ir: cmd.print.ir(),
             reverse_order: cmd.print.reverse_order,
         },
+        dump: DumpOpts::default(),
         time_phases: cmd.print.time_phases,
         profile: cmd.print.profile,
         metrics_outfile: cmd.print.metrics_outfile.clone(),
diff --git a/forc-plugins/forc-client/src/op/run/mod.rs b/forc-plugins/forc-client/src/op/run/mod.rs
@@ -8,7 +8,7 @@ use crate::{
     },
 };
 use anyhow::{anyhow, bail, Context, Result};
-use forc_pkg::{self as pkg, fuel_core_not_running, PackageManifestFile};
+use forc_pkg::{self as pkg, fuel_core_not_running, DumpOpts, PackageManifestFile};
 use forc_tracing::println_warning;
 use forc_util::tx_utils::format_log_receipts;
 use fuel_core_client::client::FuelClient;
@@ -256,6 +256,7 @@ fn build_opts_from_cmd(cmd: &cmd::Run) -> pkg::BuildOpts {
             json_abi: cmd.minify.json_abi,
             json_storage_slots: cmd.minify.json_storage_slots,
         },
+        dump: DumpOpts::default(),
         build_target: BuildTarget::default(),
         build_profile: cmd.build_profile.build_profile.clone(),
         release: cmd.build_profile.release,
diff --git a/forc-test/src/lib.rs b/forc-test/src/lib.rs
@@ -7,7 +7,7 @@ use crate::setup::{
     ContractDeploymentSetup, ContractTestSetup, DeploymentSetup, ScriptTestSetup, TestSetup,
 };
 use ecal::EcalSyscallHandler;
-use forc_pkg::{self as pkg, BuildOpts};
+use forc_pkg::{self as pkg, BuildOpts, DumpOpts};
 use forc_util::tx_utils::RevertInfo;
 use fuel_abi_types::abi::program::ProgramABI;
 use fuel_tx as tx;
@@ -452,6 +452,7 @@ impl From<TestOpts> for pkg::BuildOpts {
             pkg: val.pkg,
             print: val.print,
             minify: val.minify,
+            dump: DumpOpts::default(),
             binary_outfile: val.binary_outfile,
             debug_outfile: val.debug_outfile,
             hex_outfile: val.hex_outfile,
@@ -477,6 +478,7 @@ impl TestOpts {
             pkg: self.pkg,
             print: self.print,
             minify: self.minify,
+            dump: DumpOpts::default(),
             binary_outfile: self.binary_outfile,
             debug_outfile: self.debug_outfile,
             hex_outfile: self.hex_outfile,
diff --git a/forc/src/cli/commands/check.rs b/forc/src/cli/commands/check.rs
@@ -45,6 +45,10 @@ pub struct Command {
     #[clap(long)]
     pub ipfs_node: Option<IPFSNode>,
 
+    /// Dump all trait implementations for the given type name.
+    #[clap(long = "dump-impls", value_name = "TYPE")]
+    pub dump_impls: Option<String>,
+
     #[clap(flatten)]
     pub experimental: sway_features::CliFields,
 }
diff --git a/forc/src/cli/shared.rs b/forc/src/cli/shared.rs
@@ -91,6 +91,8 @@ pub struct Build {
     /// Build target to use for code generation.
     #[clap(long, value_enum, default_value_t = BuildTarget::default(), alias="target")]
     pub build_target: BuildTarget,
+    #[clap(flatten)]
+    pub dump: Dump,
 }
 
 /// Build output file options.
@@ -126,6 +128,14 @@ pub struct BuildProfile {
     pub error_on_warnings: bool,
 }
 
+/// Dump options.
+#[derive(Args, Debug, Default)]
+pub struct Dump {
+    /// Dump all trait implementations for the given type name.
+    #[clap(long = "dump-impls", value_name = "TYPE")]
+    pub dump_impls: Option<String>,
+}
+
 /// Options related to printing stages of compiler output.
 #[derive(Args, Debug, Default)]
 pub struct Print {
diff --git a/forc/src/ops/forc_build.rs b/forc/src/ops/forc_build.rs
@@ -29,6 +29,9 @@ fn opts_from_cmd(cmd: BuildCommand) -> pkg::BuildOpts {
             ir: cmd.build.print.ir(),
             reverse_order: cmd.build.print.reverse_order,
         },
+        dump: pkg::DumpOpts {
+            dump_impls: cmd.build.dump.dump_impls,
+        },
         time_phases: cmd.build.print.time_phases,
         profile: cmd.build.print.profile,
         metrics_outfile: cmd.build.print.metrics_outfile,
diff --git a/forc/src/ops/forc_contract_id.rs b/forc/src/ops/forc_contract_id.rs
@@ -1,6 +1,6 @@
 use crate::cli::ContractIdCommand;
 use anyhow::{bail, Result};
-use forc_pkg::{self as pkg, build_with_options};
+use forc_pkg::{self as pkg, build_with_options, DumpOpts};
 use forc_tracing::println_green;
 use sway_core::{fuel_prelude::fuel_tx, BuildTarget};
 use tracing::info;
@@ -63,6 +63,7 @@ fn build_opts_from_cmd(cmd: &ContractIdCommand) -> pkg::BuildOpts {
             ir: cmd.print.ir(),
             reverse_order: cmd.print.reverse_order,
         },
+        dump: DumpOpts::default(),
         time_phases: cmd.print.time_phases,
         profile: cmd.print.profile,
         metrics_outfile: cmd.print.metrics_outfile.clone(),
diff --git a/forc/src/ops/forc_predicate_root.rs b/forc/src/ops/forc_predicate_root.rs
@@ -1,6 +1,6 @@
 use crate::cli::PredicateRootCommand;
 use anyhow::Result;
-use forc_pkg::{self as pkg, build_with_options};
+use forc_pkg::{self as pkg, build_with_options, DumpOpts};
 use sway_core::BuildTarget;
 
 pub fn predicate_root(command: PredicateRootCommand) -> Result<()> {
@@ -32,6 +32,7 @@ fn build_opts_from_cmd(cmd: PredicateRootCommand) -> pkg::BuildOpts {
             ir: cmd.print.ir(),
             reverse_order: cmd.print.reverse_order,
         },
+        dump: DumpOpts::default(),
         time_phases: cmd.print.time_phases,
         profile: cmd.print.profile,
         metrics_outfile: cmd.print.metrics_outfile,
diff --git a/sway-core/src/language/call_path.rs b/sway-core/src/language/call_path.rs
@@ -518,9 +518,9 @@ impl<T: Clone> CallPath<T> {
             }
             CallPathType::Ambiguous => {
                 if self.prefixes.is_empty() {
-                    // 		    // Given a path to a symbol that has no prefixes, discover the path to the symbol as a
-                    // 		    // combination of the package name in which the symbol is defined and the path to the
-                    // 		    // current submodule.
+                    // Given a path to a symbol that has no prefixes, discover the path to the symbol as a
+                    // combination of the package name in which the symbol is defined and the path to the
+                    // current submodule.
                     CallPath {
                         prefixes: mod_path.clone(),
                         suffix: self.suffix.clone(),
diff --git a/sway-core/src/lib.rs b/sway-core/src/lib.rs
@@ -27,7 +27,9 @@ pub mod transform;
 pub mod type_system;
 
 use crate::ir_generation::check_function_purity;
+use crate::language::{CallPath, CallPathType};
 use crate::query_engine::ModuleCacheEntry;
+use crate::semantic_analysis::type_resolve::{resolve_call_path, VisibilityCheck};
 use crate::source_map::SourceMap;
 pub use asm_generation::from_ir::compile_ir_context_to_finalized_asm;
 use asm_generation::FinalizedAsm;
@@ -1462,6 +1464,93 @@ fn check_should_abort(
     Ok(())
 }
 
+pub fn check_dump_impls(
+    engines: &Engines,
+    pkg_namespace: &namespace::Package,
+    typename: &String,
+) -> Result<(), ErrorEmitted> {
+    // eprintln!("{:?}", typename);
+    // engines.
+    // namespace.current_package().root_module().name()
+    // eprintln!("{:?}", namespace.root_module().name());
+
+    // for pkg in namespace.external_packages.iter() {
+    //     eprintln!(" {:?}", pkg.0);
+    // }
+
+    let handler = Handler::default();
+    let namespace =
+        namespace::Namespace::new(&handler, engines, pkg_namespace.clone(), false).unwrap();
+
+    let path: Vec<&str> = typename.split("::").collect();
+    let mut call_path = CallPath::fullpath(&path);
+    call_path.callpath_type = CallPathType::Ambiguous;
+
+    let mod_path = [pkg_namespace.root_module().name().clone()];
+    // eprintln!("mod_path {:?}", mod_path);
+    // eprintln!("call_path {:?}", call_path);
+
+    // eprintln!("resolve_call_path {:?} {:?} {:?}{:?}", ret);
+
+    let mut resolved = resolve_call_path(
+        &handler,
+        engines,
+        &namespace,
+        &mod_path,
+        &call_path,
+        None,
+        VisibilityCheck::No,
+    );
+
+    if resolved.is_err() {
+        resolved = resolve_call_path(
+            &handler,
+            engines,
+            &namespace,
+            &[],
+            &call_path,
+            None,
+            VisibilityCheck::No,
+        );
+    }
+
+    if let Ok(resolved) = resolved {
+        let struct_decl = resolved.to_struct_decl(&handler, engines)?.expect_typed();
+        let struct_decl = struct_decl.to_struct_decl(&handler, engines)?;
+
+        let module = &pkg_namespace.root_module();
+        module.walk_scope_chain(|lexical_scope| {
+            let trait_map = &lexical_scope.items.implemented_traits;
+
+            for key in trait_map.trait_impls.keys() {
+                for trait_entry in trait_map.trait_impls[key].iter() {
+                    let trait_type = engines.te().get(trait_entry.inner.key.type_id);
+                    if !trait_type.is_struct() {
+                        continue;
+                    }
+
+                    let trait_struct =
+                        match trait_type.expect_struct(&handler, engines, &Span::dummy()) {
+                            Ok(struct_decl) => struct_decl,
+                            Err(_) => {
+                                continue;
+                            }
+                        };
+
+                    if struct_decl.inner() == trait_struct.inner() {
+                        eprintln!(
+                            "===> Found impl {:?}",
+                            engines.help_out(trait_entry.inner.key.trait_decl_span.clone())
+                        );
+                    }
+                }
+            }
+        });
+    }
+
+    Ok(())
+}
+
 #[test]
 fn test_basic_prog() {
     let handler = Handler::default();
diff --git a/sway-core/src/semantic_analysis/namespace/namespace.rs b/sway-core/src/semantic_analysis/namespace/namespace.rs
@@ -174,7 +174,11 @@ impl Namespace {
     }
 
     pub fn module_from_absolute_path(&self, path: &[Ident]) -> Option<&Module> {
-        self.current_package.module_from_absolute_path(path)
+        if path.len() == 0 {
+            return None;
+        } else {
+            self.current_package.module_from_absolute_path(path)
+        }
     }
 
     // Like module_from_absolute_path, but throws an error if the module is not found
diff --git a/sway-core/src/semantic_analysis/type_resolve.rs b/sway-core/src/semantic_analysis/type_resolve.rs
diff --git a/test/src/ir_generation/mod.rs b/test/src/ir_generation/mod.rs
