Forge fmt new backtraces tests

Author: grandizzy

crates/forge/tests/cli/backtrace.rs

@@ -37,7 +37,7 @@ Backtrace:
 ...
 Backtrace:
   at DelegateTarget.compute (src/DelegateCall.sol:11:84)
-  at DelegateCaller.delegateCompute (src/DelegateCall.sol:33:20)
+  at DelegateCaller.delegateCompute (src/DelegateCall.sol:32:101)
   at BacktraceTest.testDelegateCallRequire (test/Backtrace.t.sol:82:57)
 
 [FAIL: Delegate call failed] testDelegateCallRevert() ([GAS])
@@ -84,7 +84,7 @@ Backtrace:
 ...
 Backtrace:
   at StaticTarget.compute (src/StaticCall.sol:11:77)
-  at StaticCaller.staticCompute (src/StaticCall.sol:32:20)
+  at StaticCaller.staticCompute (src/StaticCall.sol:30:124)
   at BacktraceTest.testStaticCallRequire (test/Backtrace.t.sol:92:60)
 
 [FAIL: Static call reverted] testStaticCallRevert() ([GAS])
@@ -464,7 +464,7 @@ Ran 5 tests for test/ForkBacktrace.t.sol:ForkBacktraceTest
 Backtrace:
   at 0x43506849D7C04F9138D1A2050bbF3A0c054402dd.transfer
   at 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48.transfer
-  at ForkBacktraceTest.testDirectOnChainRevert (test/ForkBacktrace.t.sol:38:20)
+  at ForkBacktraceTest.testDirectOnChainRevert (test/ForkBacktrace.t.sol:36:126)
 
 [FAIL: ERC20: transfer amount exceeds balance] testNestedFailure() ([GAS])
 ...

crates/forge/tests/fixtures/backtraces/DelegateCall.sol

@@ -6,7 +6,7 @@ contract DelegateTarget {
     function fail() public pure {
         revert("Delegate target failed");
     }
-    
+
     function compute(uint256 a, uint256 b) public pure returns (uint256) {
         require(a > 0, "a must be positive");
         require(b > 0, "b must be positive");
@@ -16,21 +16,20 @@ contract DelegateTarget {
 
 contract DelegateCaller {
     address public target;
-    
+
     constructor(address _target) {
         target = _target;
     }
-    
+
     function delegateFail() public {
         (bool success,) = target.delegatecall(abi.encodeWithSignature("fail()"));
         require(success, "Delegate call failed");
     }
-    
+
     function delegateCompute(uint256 a, uint256 b) public returns (uint256) {
-        (bool success, bytes memory data) = target.delegatecall(
-            abi.encodeWithSignature("compute(uint256,uint256)", a, b)
-        );
+        (bool success, bytes memory data) =
+            target.delegatecall(abi.encodeWithSignature("compute(uint256,uint256)", a, b));
         require(success, "Delegate compute failed");
         return abi.decode(data, (uint256));
     }
-}
+}

crates/forge/tests/fixtures/backtraces/ForkBacktrace.t.sol

@@ -32,9 +32,7 @@ contract ForkBacktraceTest is DSTest {
 
     function testDirectOnChainRevert() public {
         // Try to call transfer directly on USDC without having balance
-        (bool success,) = USDC.call(
-            abi.encodeWithSignature("transfer(address,uint256)", address(0xdead), 1000000)
-        );
+        (bool success,) = USDC.call(abi.encodeWithSignature("transfer(address,uint256)", address(0xdead), 1000000));
         require(success, "USDC transfer failed");
     }
 }

crates/forge/tests/fixtures/backtraces/ForkedERC20Wrapper.sol

@@ -30,4 +30,4 @@ contract ForkedERC20Wrapper {
     function internalCall() internal {
         transferWithoutBalance(address(0xdead), 1000000);
     }
-}
+}

crates/forge/tests/fixtures/backtraces/LibraryBacktrace.t.sol

@@ -10,65 +10,65 @@ contract LibraryBacktraceTest is DSTest {
     Vm constant vm = Vm(HEVM_ADDRESS);
     LibraryConsumer consumer;
     address constant EXTERNAL_LIB_ADDRESS = 0x1234567890123456789012345678901234567890;
-    
+
     function setUp() public {
         // Deploy the external library at the configured address
         bytes memory libraryBytecode = type(ExternalMathLib).runtimeCode;
         vm.etch(EXTERNAL_LIB_ADDRESS, libraryBytecode);
-        
+
         // Deploy consumer contract
         consumer = new LibraryConsumer();
     }
-    
+
     // Internal library tests (should show inlined source locations)
-    
+
     /// @notice Test division by zero in internal library
     function testInternalDivisionByZero() public {
         consumer.internalDivide(100, 0);
     }
-    
+
     /// @notice Test underflow in internal library
     function testInternalUnderflow() public {
         consumer.internalSubtract(10, 20);
     }
-    
+
     /// @notice Test overflow in internal library
     function testInternalOverflow() public {
         consumer.internalMultiply(type(uint256).max, 2);
     }
-    
+
     /// @notice Test require in internal library
     function testInternalRequire() public {
         consumer.internalCheckPositive(0);
     }
-    
+
     // External library tests (should show delegatecall to library address)
-    
+
     /// @notice Test division by zero in external library
     function testExternalDivisionByZero() public {
         consumer.externalDivide(100, 0);
     }
-    
+
     /// @notice Test underflow in external library
     function testExternalUnderflow() public {
         consumer.externalSubtract(10, 20);
     }
-    
+
     /// @notice Test overflow in external library
     function testExternalOverflow() public {
         consumer.externalMultiply(type(uint256).max, 2);
     }
-    
+
     /// @notice Test require in external library
     function testExternalRequire() public {
         consumer.externalCheckPositive(0);
     }
-    
+
     // Mixed library usage test
-    
+
     /// @notice Test mixed library usage with failure in external library
     function testMixedLibraryFailure() public {
         // This will fail at the external library division step (50 - 50 = 0, then divide by 0)
         consumer.mixedCalculation(50, 50, 0);
     }
-}
+}

crates/forge/tests/fixtures/backtraces/LibraryConsumer.sol

@@ -7,63 +7,63 @@ import "./libraries/ExternalMathLib.sol";
 /// @title LibraryConsumer - A contract that uses both internal and external libraries
 contract LibraryConsumer {
     using InternalMathLib for uint256;
-    
+
     uint256 public result;
-    
+
     // Internal library functions (inlined into contract bytecode)
-    
+
     /// @notice Perform division using internal library
     function internalDivide(uint256 a, uint256 b) public returns (uint256) {
         result = a.div(b);
         return result;
     }
-    
+
     /// @notice Perform multiplication using internal library
     function internalMultiply(uint256 a, uint256 b) public returns (uint256) {
         result = a.mul(b);
         return result;
     }
-    
+
     /// @notice Perform subtraction using internal library
     function internalSubtract(uint256 a, uint256 b) public returns (uint256) {
         result = a.sub(b);
         return result;
     }
-    
+
     /// @notice Check positive value using internal library
     function internalCheckPositive(uint256 value) public returns (uint256) {
         result = InternalMathLib.requirePositive(value);
         return result;
     }
-    
+
     // External library functions (delegatecall to deployed library)
-    
+
     /// @notice Perform division using external library
     function externalDivide(uint256 a, uint256 b) public returns (uint256) {
         result = ExternalMathLib.div(a, b);
         return result;
     }
-    
+
     /// @notice Perform multiplication using external library
     function externalMultiply(uint256 a, uint256 b) public returns (uint256) {
         result = ExternalMathLib.mul(a, b);
         return result;
     }
-    
+
     /// @notice Perform subtraction using external library
     function externalSubtract(uint256 a, uint256 b) public returns (uint256) {
         result = ExternalMathLib.sub(a, b);
         return result;
     }
-    
+
     /// @notice Check positive value using external library
     function externalCheckPositive(uint256 value) public returns (uint256) {
         result = ExternalMathLib.requirePositive(value);
         return result;
     }
-    
+
     // Mixed usage example
-    
+
     /// @notice Complex calculation using both libraries
     function mixedCalculation(uint256 a, uint256 b, uint256 c) public returns (uint256) {
         // First use internal library
@@ -74,4 +74,4 @@ contract LibraryConsumer {
         result = step2.mul(10);
         return result;
     }
-}
+}

crates/forge/tests/fixtures/backtraces/MultipleLibraryBacktrace.t.sol

@@ -6,28 +6,28 @@ import "../src/MultipleLibraryConsumer.sol";
 
 contract MultipleLibraryBacktraceTest is DSTest {
     MultipleLibraryConsumer consumer;
-    
+
     function setUp() public {
         consumer = new MultipleLibraryConsumer();
     }
-    
+
     /// @notice Test that FirstMathLib shows correctly in backtrace
     function testFirstLibraryError() public {
         consumer.useFirstLib(10, 0); // Division by zero in FirstMathLib
     }
-    
+
     /// @notice Test that SecondMathLib shows correctly in backtrace
     function testSecondLibraryError() public {
         consumer.useSecondLib(5, 10); // Underflow in SecondMathLib
     }
-    
+
     /// @notice Test that ThirdMathLib shows correctly in backtrace
     function testThirdLibraryError() public {
         consumer.useThirdLib(10, 0); // Modulo by zero in ThirdMathLib
     }
-    
+
     /// @notice Test complex failure in the first library
     function testAllLibrariesFirstFails() public {
         consumer.useAllLibraries(10, 0, 5); // Division by zero in FirstMathLib
     }
-}
+}

crates/forge/tests/fixtures/backtraces/MultipleLibraryConsumer.sol

@@ -8,32 +8,32 @@ contract MultipleLibraryConsumer {
     using FirstMathLib for uint256;
     using SecondMathLib for uint256;
     using ThirdMathLib for uint256;
-    
+
     uint256 public result;
-    
+
     /// @notice Test division from FirstMathLib
     function useFirstLib(uint256 a, uint256 b) public returns (uint256) {
-        result = a.divide(b);  // Should show FirstMathLib in backtrace
+        result = a.divide(b); // Should show FirstMathLib in backtrace
         return result;
     }
-    
+
     /// @notice Test subtraction from SecondMathLib
     function useSecondLib(uint256 a, uint256 b) public returns (uint256) {
-        result = a.subtract(b);  // Should show SecondMathLib in backtrace
+        result = a.subtract(b); // Should show SecondMathLib in backtrace
         return result;
     }
-    
+
     /// @notice Test modulo from ThirdMathLib
     function useThirdLib(uint256 a, uint256 b) public returns (uint256) {
-        result = a.modulo(b);  // Should show ThirdMathLib in backtrace
+        result = a.modulo(b); // Should show ThirdMathLib in backtrace
         return result;
     }
-    
+
     /// @notice Complex calculation using all three libraries
     function useAllLibraries(uint256 a, uint256 b, uint256 c) public returns (uint256) {
-        uint256 step1 = a.divide(b);    // FirstMathLib
-        uint256 step2 = step1.add(c);   // SecondMathLib  
-        result = step2.modulo(10);      // ThirdMathLib
+        uint256 step1 = a.divide(b); // FirstMathLib
+        uint256 step2 = step1.add(c); // SecondMathLib
+        result = step2.modulo(10); // ThirdMathLib
         return result;
     }
-}
+}

crates/forge/tests/fixtures/backtraces/SimpleRevert.sol

@@ -6,18 +6,18 @@ contract SimpleRevert {
     function doRevert(string memory reason) public pure {
         revert(reason);
     }
-    
+
     function doRequire(uint256 value) public pure {
         require(value > 0, "Value must be greater than zero");
     }
-    
+
     function doAssert() public pure {
         assert(false);
     }
-    
+
     error CustomError(uint256 code, address sender);
-    
+
     function doCustomError() public view {
         revert CustomError(42, msg.sender);
     }
-}
+}

crates/forge/tests/fixtures/backtraces/StaticCall.sol

@@ -6,7 +6,7 @@ contract StaticTarget {
     function viewFail() public pure {
         revert("Static call failed");
     }
-    
+
     function compute(uint256 value) public pure returns (uint256) {
         require(value > 0, "Value must be positive");
         return value * 2;
@@ -15,21 +15,19 @@ contract StaticTarget {
 
 contract StaticCaller {
     address public target;
-    
+
     constructor(address _target) {
         target = _target;
     }
-    
+
     function staticCallFail() public view {
         (bool success,) = target.staticcall(abi.encodeWithSignature("viewFail()"));
         require(success, "Static call reverted");
     }
-    
+
     function staticCompute(uint256 value) public view returns (uint256) {
-        (bool success, bytes memory data) = target.staticcall(
-            abi.encodeWithSignature("compute(uint256)", value)
-        );
+        (bool success, bytes memory data) = target.staticcall(abi.encodeWithSignature("compute(uint256)", value));
         require(success, "Static compute failed");
         return abi.decode(data, (uint256));
     }
-}
+}