feat: add log type info collection for test entries to enable log decoding at forc-test

forc-pkg/src/pkg.rs

@@ -31,7 +31,9 @@ use std::{
     str::FromStr,
     sync::{atomic::AtomicBool, Arc},
 };
+use sway_core::language::ty::{TyAstNodeContent, TyExpressionVariant};
 pub use sway_core::Programs;
+use sway_core::TypeInfo;
 use sway_core::{
     abi_generation::{
         evm_abi,
@@ -51,7 +53,7 @@ use sway_core::{
 };
 use sway_error::{error::CompileError, handler::Handler, warning::CompileWarning};
 use sway_types::constants::{CORE, PRELUDE, STD};
-use sway_types::{Ident, Span, Spanned};
+use sway_types::{Ident, SourceId, Span, Spanned};
 use sway_utils::{constants, time_expr, PerformanceData, PerformanceMetric};
 use tracing::{debug, info};
 
@@ -162,6 +164,7 @@ pub struct PkgTestEntry {
     pub pass_condition: TestPassCondition,
     pub span: Span,
     pub file_path: Arc<PathBuf>,
+    pub log_params: Vec<(SourceId, Arc<TypeInfo>)>,
 }
 
 /// The result of successfully compiling a workspace.
@@ -2011,16 +2014,43 @@ impl PkgTestEntry {
             bail!("Invalid test argument(s) for test: {test_name}.")
         }?;
 
+        let mut log_params = Vec::new();
+        for ast_node in test_function_decl.body.contents.iter() {
+            if let TyAstNodeContent::Expression(expr) = &ast_node.content {
+                if let TyExpressionVariant::FunctionApplication {
+                    call_path,
+                    arguments,
+                    ..
+                } = &expr.expression
+                {
+                    let suffix = call_path.suffix.to_string();
+                    if suffix == "log" {
+                        let arg_type = arguments
+                            .iter()
+                            .map(|(_, arg_expr)| arg_expr.return_type)
+                            .map(|type_id| engines.te().get(type_id))
+                            .next();
+                        if let (Some(source_id), Some(arg_type)) = (expr.span.source_id(), arg_type)
+                        {
+                            log_params.push((*source_id, arg_type));
+                        }
+                    }
+                }
+            }
+        }
+
         let file_path = Arc::new(
             engines.se().get_path(
                 span.source_id()
                     .ok_or_else(|| anyhow::anyhow!("Missing span for test function"))?,
             ),
         );
+
         Ok(Self {
             pass_condition,
             span,
             file_path,
+            log_params,
         })
     }
 }
@@ -2775,7 +2805,7 @@ mod test {
         let manifest_dir = PathBuf::from(current_dir)
             .parent()
             .unwrap()
-            .join("test/src/e2e_vm_tests/test_programs/should_pass/forc/workspace_building/");
+            .join("test/src/e2e_vm_tests/test_programs/should_pass/forc/workspace_building");
         let manifest_file = ManifestFile::from_dir(manifest_dir).unwrap();
         let member_manifests = manifest_file.member_manifests().unwrap();
         let lock_path = manifest_file.lock_path().unwrap();
@@ -2789,6 +2819,105 @@ mod test {
         .unwrap()
     }
 
+    fn get_test_entry_logs(entry_name: &str) -> Vec<Arc<TypeInfo>> {
+        let current_dir = env!("CARGO_MANIFEST_DIR");
+        let manifest_dir = format!("{current_dir}/tests/test_pkg_entry");
+        let build_opts = BuildOpts {
+            pkg: PkgOpts {
+                path: Some(manifest_dir),
+                ..Default::default()
+            },
+            build_target: BuildTarget::Fuel,
+            tests: true,
+            experimental: ExperimentalFlags { new_encoding: true },
+            ..Default::default()
+        };
+        let built_pkgs = build_with_options(build_opts).unwrap();
+        let built_pkg = built_pkgs.expect_pkg().unwrap();
+        let pkg_entry = built_pkg
+            .bytecode
+            .entries
+            .iter()
+            .filter(|pkg_entry| pkg_entry.finalized.fn_name == entry_name)
+            .find_map(|entry| {
+                if let PkgEntryKind::Test(test_entry) = &entry.kind {
+                    Some(test_entry)
+                } else {
+                    None
+                }
+            })
+            .unwrap();
+
+        pkg_entry
+            .log_params
+            .iter()
+            .map(|(_, type_info)| type_info)
+            .cloned()
+            .collect()
+    }
+
+    #[test]
+    fn collect_test_entry_log_unsigned_int() {
+        let log_types = get_test_entry_logs("log_unsigned_int");
+        assert_eq!(log_types.len(), 1);
+        assert!(matches!(*log_types[0], TypeInfo::Numeric,))
+    }
+
+    #[test]
+    fn collect_test_entry_log_bool() {
+        let log_types = get_test_entry_logs("log_bool");
+        assert_eq!(log_types.len(), 1);
+        assert!(matches!(*log_types[0], TypeInfo::Boolean))
+    }
+
+    #[test]
+    fn collect_test_entry_log_string_slice() {
+        let log_types = get_test_entry_logs("log_string_slice");
+        assert_eq!(log_types.len(), 1);
+        assert!(matches!(*log_types[0], TypeInfo::StringSlice))
+    }
+
+    #[test]
+    fn collect_test_entry_log_array() {
+        let log_types = get_test_entry_logs("log_array");
+        assert_eq!(log_types.len(), 1);
+        assert!(matches!(*log_types[0], TypeInfo::Array(_, _)))
+    }
+
+    #[test]
+    fn collect_test_entry_log_tuple() {
+        let log_types = get_test_entry_logs("log_tuple");
+        assert_eq!(log_types.len(), 1);
+        assert!(matches!(*log_types[0], TypeInfo::Tuple(_)))
+    }
+
+    #[test]
+    fn collect_test_entry_log_struct() {
+        let log_types = get_test_entry_logs("log_struct");
+        assert_eq!(log_types.len(), 1);
+        assert!(matches!(*log_types[0], TypeInfo::Struct(_)))
+    }
+
+    #[test]
+    fn collect_test_entry_log_enum() {
+        let log_types = get_test_entry_logs("log_enum");
+        assert_eq!(log_types.len(), 1);
+        assert!(matches!(*log_types[0], TypeInfo::Enum(_)))
+    }
+
+    #[test]
+    fn collect_test_entry_multiple_log() {
+        let log_types = get_test_entry_logs("log_multiple");
+        assert_eq!(log_types.len(), 7);
+        assert!(matches!(*log_types[0], TypeInfo::Numeric));
+        assert!(matches!(*log_types[1], TypeInfo::Boolean));
+        assert!(matches!(*log_types[2], TypeInfo::StringSlice));
+        assert!(matches!(*log_types[3], TypeInfo::Array(_, _)));
+        assert!(matches!(*log_types[4], TypeInfo::Tuple(_)));
+        assert!(matches!(*log_types[5], TypeInfo::Struct(_)));
+        assert!(matches!(*log_types[6], TypeInfo::Enum(_)));
+    }
+
     #[test]
     fn test_root_pkg_order() {
         let build_plan = setup_build_plan();

forc-pkg/tests/test_pkg_entry/.gitignore

@@ -0,0 +1,2 @@
+out
+target

forc-pkg/tests/test_pkg_entry/Forc.lock

@@ -0,0 +1,13 @@
+[[package]]
+name = "core"
+source = "path+from-root-9F43309F1982F720"
+
+[[package]]
+name = "std"
+source = "path+from-root-9F43309F1982F720"
+dependencies = ["core"]
+
+[[package]]
+name = "test_pkg_entry"
+source = "member"
+dependencies = ["std"]

forc-pkg/tests/test_pkg_entry/Forc.toml

@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "lib.sw"
+license = "Apache-2.0"
+name = "test_pkg_entry"
+
+[dependencies]
+std = { path = "../../../sway-lib-std/" }

forc-pkg/tests/test_pkg_entry/src/lib.sw

@@ -0,0 +1,81 @@
+library;
+
+#[test]
+fn log_unsigned_int() {
+  let a = 10;
+  log(a);
+}
+
+#[test]
+fn log_bool() {
+  let a = true;
+  log(a);
+}
+
+#[test]
+fn log_string_slice() {
+  let a = "test";
+  log(a);
+}
+
+#[test]
+fn log_array() {
+  let a: [u8; 5] = [1, 2, 3, 4, 5];
+  log(a);
+  let b: [u8; 5] = [1, 2, 3, 4, 5];
+}
+
+#[test]
+fn log_tuple() {
+  let a = (1,2);
+  log(a);
+  let b = (1,2);
+}
+
+struct Foo {
+    f1: u32,
+}
+
+#[test]
+fn log_struct() {
+  let a = Foo {
+  	f1: 1,
+  };
+
+  log(a);
+  let b = Foo {
+  	f1: 1,
+  };
+}
+
+
+enum Bar {
+  Foo: (),
+}
+
+#[test]
+fn log_enum() {
+  let a: Bar = Bar::Foo;
+  log(a);
+}
+
+
+#[test]
+fn log_multiple() {
+  let a = 10;
+  log(a);
+  let a = true;
+  log(a);
+  let a = "test";
+  log(a);
+  let a: [u8; 5] = [1, 2, 3, 4, 5];
+  log(a);
+  let a = (1,2);
+  log(a);
+  let a = Foo {
+  	f1: 1,
+  };
+  log(a);
+  let a: Bar = Bar::Foo;
+  log(a);
+}