Merge branch 'master' into adding_support_etherscan_v2

Author: grandizzy

crates/cast/src/args.rs

@@ -195,8 +195,19 @@ pub async fn run_command(args: CastArgs) -> Result<()> {
             let tokens = SimpleCast::calldata_decode(&sig, &calldata, true)?;
             print_tokens(&tokens);
         }
-        CastSubcommand::CalldataEncode { sig, args } => {
-            sh_println!("{}", SimpleCast::calldata_encode(sig, &args)?)?;
+        CastSubcommand::CalldataEncode { sig, args, file } => {
+            let final_args = if let Some(file_path) = file {
+                let contents = fs::read_to_string(file_path)?;
+                contents
+                    .lines()
+                    .map(str::trim)
+                    .filter(|line| !line.is_empty())
+                    .map(String::from)
+                    .collect()
+            } else {
+                args
+            };
+            sh_println!("{}", SimpleCast::calldata_encode(sig, &final_args)?)?;
         }
         CastSubcommand::DecodeString { data } => {
             let tokens = SimpleCast::calldata_decode("Any(string)", &data, true)?;

crates/cast/src/opts.rs

@@ -391,6 +391,10 @@ pub enum CastSubcommand {
         /// The arguments to encode.
         #[arg(allow_hyphen_values = true)]
         args: Vec<String>,
+
+        // Path to file containing arguments to encode.
+        #[arg(long, value_name = "PATH")]
+        file: Option<PathBuf>,
     },
 
     /// Get the symbolic name of the current chain.
@@ -1147,6 +1151,19 @@ mod tests {
         };
     }
 
+    #[test]
+    fn parse_call_data_with_file() {
+        let args: Cast = Cast::parse_from(["foundry-cli", "calldata", "f()", "--file", "test.txt"]);
+        match args.cmd {
+            CastSubcommand::CalldataEncode { sig, file, args } => {
+                assert_eq!(sig, "f()".to_string());
+                assert_eq!(file, Some(PathBuf::from("test.txt")));
+                assert!(args.is_empty());
+            }
+            _ => unreachable!(),
+        };
+    }
+
     // <https://github.com/foundry-rs/book/issues/1019>
     #[test]
     fn parse_signature() {

crates/forge/src/coverage.rs

@@ -1,6 +1,6 @@
 //! Coverage reports.
 
-use alloy_primitives::map::HashMap;
+use alloy_primitives::map::{HashMap, HashSet};
 use comfy_table::{modifiers::UTF8_ROUND_CORNERS, Attribute, Cell, Color, Row, Table};
 use evm_disassembler::disassemble_bytes;
 use foundry_common::fs;
@@ -118,6 +118,8 @@ impl CoverageReporter for LcovReporter {
             writeln!(out, "TN:")?;
             writeln!(out, "SF:{}", path.display())?;
 
+            let mut recorded_lines = HashSet::new();
+
             for item in items {
                 let line = item.loc.lines.start;
                 // `lines` is half-open, so we need to subtract 1 to get the last included line.
@@ -140,8 +142,11 @@ impl CoverageReporter for LcovReporter {
                             writeln!(out, "FNDA:{hits},{name}")?;
                         }
                     }
-                    CoverageItemKind::Line => {
-                        writeln!(out, "DA:{line},{hits}")?;
+                    // Add lines / statement hits only once.
+                    CoverageItemKind::Line | CoverageItemKind::Statement => {
+                        if recorded_lines.insert(line) {
+                            writeln!(out, "DA:{line},{hits}")?;
+                        }
                     }
                     CoverageItemKind::Branch { branch_id, path_id, .. } => {
                         writeln!(
@@ -150,9 +155,6 @@ impl CoverageReporter for LcovReporter {
                             if hits == 0 { "-".to_string() } else { hits.to_string() }
                         )?;
                     }
-                    // Statements are not in the LCOV format.
-                    // We don't add them in order to avoid doubling line hits.
-                    CoverageItemKind::Statement => {}
                 }
             }
 

crates/forge/tests/cli/coverage.rs

@@ -1845,6 +1845,72 @@ contract ArrayConditionTest is DSTest {
 "#]]);
 });
 
+// <https://github.com/foundry-rs/foundry/issues/10422>
+// Test that line hits are properly recorded in lcov report.
+forgetest!(do_while_lcov, |prj, cmd| {
+    prj.insert_ds_test();
+    prj.add_source(
+        "Counter.sol",
+        r#"
+contract Counter {
+    uint256 public number = 21;
+
+    function increment() public {
+        uint256 i = 0;
+        do {
+            number++;
+            if (number > 20) {
+                number -= 2;
+            }
+        } while (++i < 10);
+    }
+}
+    "#,
+    )
+    .unwrap();
+
+    prj.add_source(
+        "Counter.t.sol",
+        r#"
+import "./test.sol";
+import "./Counter.sol";
+
+contract CounterTest is DSTest {
+    function test_do_while() public {
+        Counter counter = new Counter();
+        counter.increment();
+    }
+}
+    "#,
+    )
+    .unwrap();
+
+    assert_lcov(
+        cmd.arg("coverage"),
+        str![[r#"
+TN:
+SF:src/Counter.sol
+DA:7,1
+FN:7,Counter.increment
+FNDA:1,Counter.increment
+DA:8,1
+DA:14,10
+DA:10,10
+DA:11,10
+BRDA:11,0,0,6
+DA:12,6
+FNF:1
+FNH:1
+LF:3
+LH:3
+BRF:1
+BRH:1
+end_of_record
+
+"#]],
+    );
+});
+
 #[track_caller]
 fn assert_lcov(cmd: &mut TestCommand, data: impl IntoData) {
     cmd.args(["--report=lcov", "--report-file"]).assert_file(data.into_data());