Implement a command to dump impls for a given type

tritao · tritao · commit f76a8d867717 · 2025-08-18T12:16:10.000+01:00
This adds a new `--dump-impls` CLI command that can be used to dump all the recognized trait impls for a given type name. This also extends the compiler diagnostic system to allow the emission of info diagnostics, as previously we could only emit either warnings of errors, which did not fit this. 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.
@@ -1725,7 +1732,7 @@ pub fn compile(
             &handler,
             engines,
             source,
-            namespace,
+            namespace.clone(),
             Some(&sway_build_config),
             &pkg.name,
             None,
@@ -1755,6 +1762,15 @@ pub fn compile(
         return fail(handler);
     }
 
+    if let Some(typename) = &profile.dump.dump_impls {
+        let _ = sway_core::dump_trait_impls_for_typename(
+            &handler,
+            engines,
+            &typed_program.namespace,
+            typename,
+        );
+    }
+
     let asm_res = time_expr!(
         pkg.name,
         "compile ast to asm",
@@ -2110,6 +2126,7 @@ fn build_profile_from_opts(
         metrics_outfile,
         tests,
         error_on_warnings,
+        dump,
         ..
     } = build_options;
 
@@ -2130,6 +2147,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,112 @@ fn check_should_abort(
     Ok(())
 }
 
+pub fn dump_trait_impls_for_typename(
+    handler: &Handler,
+    engines: &Engines,
+    namespace: &namespace::Namespace,
+    typename: &str,
+) -> Result<(), ErrorEmitted> {
+    let path: Vec<&str> = typename.split("::").collect();
+    let mut call_path = CallPath::fullpath(&path);
+    call_path.callpath_type = CallPathType::Ambiguous;
+
+    let pkg_namespace = namespace.current_package_ref();
+    let mod_path = [pkg_namespace.root_module().name().clone()];
+
+    let resolve_handler = Handler::default();
+    let resolved = resolve_call_path(
+        &resolve_handler,
+        engines,
+        namespace,
+        &mod_path,
+        &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();
+
+        let mut impls = Vec::new();
+        find_trait_impls_for_type(engines, handler, namespace, struct_decl, module, &mut impls);
+
+        for ext_pkg in pkg_namespace.external_packages.iter() {
+            let ext_module = ext_pkg.1.root_module();
+            find_trait_impls_for_type(
+                engines,
+                handler,
+                namespace,
+                struct_decl,
+                ext_module,
+                &mut impls,
+            );
+        }
+
+        let unique_impls = impls
+            .iter()
+            .unique_by(|i| i.impl_span.clone())
+            .cloned()
+            .collect::<Vec<_>>();
+        handler.emit_info(CompileInfo {
+            span: resolved.span(engines),
+            content: Info::ImplTraitsForTypeName {
+                impls: unique_impls,
+            },
+        });
+    }
+
+    Ok(())
+}
+
+fn find_trait_impls_for_type(
+    engines: &Engines,
+    handler: &Handler,
+    namespace: &namespace::Namespace,
+    struct_decl: decl_engine::DeclId<ty::TyStructDecl>,
+    module: &namespace::Module,
+    impls: &mut Vec<CollectedTraitImpl>,
+) {
+    module.walk_scope_chain(|lexical_scope| {
+        module.submodules().iter().for_each(|(_, sub)| {
+            find_trait_impls_for_type(engines, handler, namespace, struct_decl, sub, impls);
+        });
+
+        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;
+                    }
+                };
+
+                let struct_decl2 = engines.de().get_struct(&struct_decl);
+                let trait_struct2 = engines.de().get_struct(&trait_struct);
+
+                if struct_decl2.span.source_id() == trait_struct2.span.source_id() {
+                    let trait_callpath = trait_entry.inner.key.name.to_fullpath(engines, namespace);
+                    impls.push(CollectedTraitImpl {
+                        impl_span: trait_entry.inner.value.impl_span.clone(),
+                        trait_name: engines.help_out(trait_callpath).to_string(),
+                    });
+                }
+            }
+        }
+    });
+}
+
 #[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.is_empty() {
+            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/sway-error/src/warning.rs b/sway-error/src/warning.rs
diff --git a/sway-lsp/src/capabilities/diagnostic.rs b/sway-lsp/src/capabilities/diagnostic.rs
diff --git a/test/src/ir_generation/mod.rs b/test/src/ir_generation/mod.rs
