debug trait and its auto implementation

Author: xunilrj

forc-test/src/execute.rs

@@ -6,14 +6,12 @@ use forc_pkg::PkgTestEntry;
 use fuel_tx::{self as tx, output::contract::Contract, Chargeable, Finalizable};
 use fuel_vm::error::InterpreterError;
 use fuel_vm::fuel_asm;
+use fuel_vm::interpreter::EcalHandler;
 use fuel_vm::prelude::Instruction;
 use fuel_vm::prelude::RegId;
 use fuel_vm::{
-    self as vm,
-    checked_transaction::builder::TransactionBuilderExt,
-    interpreter::{Interpreter, NotSupportedEcal},
-    prelude::SecretKey,
-    storage::MemoryStorage,
+    self as vm, checked_transaction::builder::TransactionBuilderExt, interpreter::Interpreter,
+    prelude::SecretKey, storage::MemoryStorage,
 };
 use rand::{Rng, SeedableRng};
 
@@ -23,10 +21,49 @@ use vm::interpreter::{InterpreterParams, MemoryInstance};
 use vm::state::DebugEval;
 use vm::state::ProgramState;
 
+#[derive(Debug, Clone, Default)]
+pub struct EcalState {}
+
+impl EcalHandler for EcalState {
+    fn ecal<M, S, Tx>(
+        vm: &mut Interpreter<M, S, Tx, Self>,
+        a: RegId,
+        b: RegId,
+        c: RegId,
+        d: RegId,
+    ) -> fuel_vm::error::SimpleResult<()>
+    where
+        M: fuel_vm::prelude::Memory,
+    {
+        let regs = vm.registers();
+        match regs[a.to_u8() as usize] {
+            1000 => {
+                let addr = regs[c.to_u8() as usize];
+                let count = regs[d.to_u8() as usize];
+
+                let s = vm.memory().read(addr, count).unwrap();
+                let s = std::str::from_utf8(s).unwrap();
+
+                use std::io::Write;
+                use std::os::fd::FromRawFd;
+                let fd = regs[b.to_u8() as usize];
+
+                let mut f = unsafe { std::fs::File::from_raw_fd(fd as i32) };
+                write!(&mut f, "{}", s).unwrap();
+
+                // Dont close the fd
+                std::mem::forget(f);
+            }
+            _ => todo!(),
+        }
+        Ok(())
+    }
+}
+
 /// An interface for executing a test within a VM [Interpreter] instance.
 #[derive(Debug, Clone)]
 pub struct TestExecutor {
-    pub interpreter: Interpreter<MemoryInstance, MemoryStorage, tx::Script, NotSupportedEcal>,
+    pub interpreter: Interpreter<MemoryInstance, MemoryStorage, tx::Script, EcalState>,
     pub tx: vm::checked_transaction::Ready<tx::Script>,
     pub test_entry: PkgTestEntry,
     pub name: String,

sway-core/src/semantic_analysis/ast_node/declaration/auto_impl/abi_encoding.rs

@@ -190,7 +190,7 @@ where
     }
 
     // Auto implements AbiEncode and AbiDecode for structs and returns their `AstNode`s.
-    fn auto_impl_struct(
+    fn abi_encode_and_decode_auto_impl_struct(
         &mut self,
         engines: &Engines,
         decl: &TyDecl,
@@ -225,7 +225,7 @@ where
         Some((abi_encode_node.ok(), abi_decode_node.ok()))
     }
 
-    fn auto_impl_enum(
+    fn abi_encode_and_decode_auto_impl_enum(
         &mut self,
         engines: &Engines,
         decl: &TyDecl,
@@ -266,8 +266,12 @@ where
         decl: &ty::TyDecl,
     ) -> (Option<TyAstNode>, Option<TyAstNode>) {
         match decl {
-            TyDecl::StructDecl(_) => self.auto_impl_struct(engines, decl).unwrap_or((None, None)),
-            TyDecl::EnumDecl(_) => self.auto_impl_enum(engines, decl).unwrap_or((None, None)),
+            TyDecl::StructDecl(_) => self
+                .abi_encode_and_decode_auto_impl_struct(engines, decl)
+                .unwrap_or((None, None)),
+            TyDecl::EnumDecl(_) => self
+                .abi_encode_and_decode_auto_impl_enum(engines, decl)
+                .unwrap_or((None, None)),
             _ => (None, None),
         }
     }

sway-core/src/semantic_analysis/ast_node/declaration/auto_impl/debug.rs

@@ -0,0 +1,99 @@
+use sway_error::handler::Handler;
+use sway_types::{BaseIdent, Named, Spanned};
+
+use crate::{
+    decl_engine::DeclEngineGet,
+    language::ty::{self, TyAstNode, TyDecl, TyStructDecl},
+    Engines, TypeParameter,
+};
+
+use super::abi_encoding::AbiEncodingAutoImplInfo;
+
+pub type DebugAutoImplContext<'a, 'b> = super::AutoImplContext<'a, 'b, AbiEncodingAutoImplInfo>;
+
+impl<'a, 'b> DebugAutoImplContext<'a, 'b>
+where
+    'a: 'b,
+{
+    pub fn generate_debug_impl(
+        &mut self,
+        engines: &Engines,
+        decl: &ty::TyDecl,
+    ) -> Option<TyAstNode> {
+        match decl {
+            TyDecl::StructDecl(_) => self.debug_auto_impl_struct(engines, decl).unwrap_or(None),
+            TyDecl::EnumDecl(_) => None,
+            _ => None,
+        }
+    }
+
+    // Auto implements AbiEncode and AbiDecode for structs and returns their `AstNode`s.
+    fn debug_auto_impl_struct(
+        &mut self,
+        engines: &Engines,
+        decl: &TyDecl,
+    ) -> Option<Option<TyAstNode>> {
+        if self.ctx.namespace.current_package_name().as_str() == "core" {
+            return Some(None);
+        }
+
+        let implementing_for_decl_id = decl.to_struct_decl(&Handler::default(), engines).unwrap();
+        let struct_decl = self.ctx.engines().de().get(&implementing_for_decl_id);
+
+        let program_id = struct_decl.span().source_id().map(|sid| sid.program_id());
+
+        let abi_encode_body = self.generate_fmt_struct_body(engines, &struct_decl);
+        let abi_encode_code = self.generate_fmt_code(
+            struct_decl.name(),
+            &struct_decl.type_parameters,
+            abi_encode_body,
+        );
+        let abi_encode_node =
+            self.parse_impl_trait_to_ty_ast_node(engines, program_id, &abi_encode_code);
+
+        Some(abi_encode_node.ok())
+    }
+
+    fn generate_fmt_code(
+        &self,
+        name: &BaseIdent,
+        type_parameters: &[TypeParameter],
+        body: String,
+    ) -> String {
+        let type_parameters_declaration =
+            self.generate_type_parameters_declaration_code(type_parameters);
+        let type_parameters_constraints =
+            self.generate_type_parameters_constraints_code(type_parameters, "Debug");
+
+        let name = name.as_str();
+
+        if body.is_empty() {
+            format!("#[allow(dead_code)] impl{type_parameters_declaration} Debug for {name}{type_parameters_declaration}{type_parameters_constraints} {{
+                #[allow(dead_code)]
+                fn fmt(self, ref mut f: Formatter) {{ }}
+            }}")
+        } else {
+            format!("#[allow(dead_code)] impl{type_parameters_declaration} Debug for {name}{type_parameters_declaration}{type_parameters_constraints} {{
+                #[allow(dead_code)]
+                fn fmt(self, ref mut f: Formatter) {{
+                    f.debug_struct(\"{name}\")
+                        {body}
+                        .finish();
+                }}
+            }}")
+        }
+    }
+
+    fn generate_fmt_struct_body(&self, _engines: &Engines, decl: &TyStructDecl) -> String {
+        let mut code = String::new();
+
+        for f in decl.fields.iter() {
+            code.push_str(&format!(
+                ".field(\"{field_name}\", self.{field_name})\n",
+                field_name = f.name.as_str(),
+            ));
+        }
+
+        code
+    }
+}

sway-core/src/semantic_analysis/ast_node/declaration/auto_impl/mod.rs

@@ -1,5 +1,6 @@
 //! This module contains common infrastructure for generating and parsing auto-generated code.
 pub mod abi_encoding;
+pub mod debug;
 pub mod marker_traits;
 
 use crate::{

sway-core/src/semantic_analysis/module.rs

@@ -28,7 +28,8 @@ use crate::{
 
 use super::{
     declaration::auto_impl::{
-        abi_encoding::AbiEncodingAutoImplContext, marker_traits::MarkerTraitsAutoImplContext,
+        abi_encoding::AbiEncodingAutoImplContext, debug::DebugAutoImplContext,
+        marker_traits::MarkerTraitsAutoImplContext,
     },
     symbol_collection_context::SymbolCollectionContext,
 };
@@ -542,20 +543,29 @@ impl ty::TyModule {
         let all_abiencode_impls = Self::get_all_impls(ctx.by_ref(), nodes, |decl| {
             decl.trait_name.suffix.as_str() == "AbiEncode"
         });
+        let all_debug_impls = Self::get_all_impls(ctx.by_ref(), nodes, |decl| {
+            decl.trait_name.suffix.as_str() == "Debug"
+        });
 
         let mut typed_nodes = vec![];
         for node in nodes {
-            // Check if the encoding traits are explicitly implemented.
-            let auto_impl_encoding_traits = match &node.content {
+            // Check if the encoding and debug traits are explicitly implemented.
+            let (auto_impl_encoding_traits, auto_impl_debug_traits) = match &node.content {
                 AstNodeContent::Declaration(Declaration::StructDeclaration(decl_id)) => {
                     let decl = ctx.engines().pe().get_struct(decl_id);
-                    !all_abiencode_impls.contains_key(&decl.name)
+                    (
+                        !all_abiencode_impls.contains_key(&decl.name),
+                        !all_debug_impls.contains_key(&decl.name),
+                    )
                 }
                 AstNodeContent::Declaration(Declaration::EnumDeclaration(decl_id)) => {
                     let decl = ctx.engines().pe().get_enum(decl_id);
-                    !all_abiencode_impls.contains_key(&decl.name)
+                    (
+                        !all_abiencode_impls.contains_key(&decl.name),
+                        !all_debug_impls.contains_key(&decl.name),
+                    )
                 }
-                _ => false,
+                _ => (false, false),
             };
 
             let Ok(node) = ty::TyAstNode::type_check(handler, ctx.by_ref(), node) else {
@@ -581,6 +591,19 @@ impl ty::TyModule {
                 };
             }
 
+            // Auto impl debug traits only if they are not explicitly implemented
+            if auto_impl_debug_traits {
+                match &node.content {
+                    TyAstNodeContent::Declaration(decl @ TyDecl::StructDecl(_))
+                    | TyAstNodeContent::Declaration(decl @ TyDecl::EnumDecl(_)) => {
+                        let mut ctx = DebugAutoImplContext::new(&mut ctx);
+                        let a = ctx.generate_debug_impl(engines, decl);
+                        generated.extend(a);
+                    }
+                    _ => {}
+                }
+            }
+
             // Always auto impl marker traits. If an explicit implementation exists, that will be
             // reported as an error when type-checking trait impls.
             if ctx.experimental.error_type {