eof: Semantic tests update

test/libsolidity/semanticTests/builtinFunctions/eof/keccak256_packed_complex_types.sol

@@ -0,0 +1,17 @@
+contract C {
+    uint120[3] x;
+    function f() public returns (bytes32 hash1, bytes32 hash2, bool hash3NonZero) {
+        uint120[] memory y = new uint120[](3);
+        x[0] = y[0] = uint120(type(uint).max - 1);
+        x[1] = y[1] = uint120(type(uint).max - 2);
+        x[2] = y[2] = uint120(type(uint).max - 3);
+        hash1 = keccak256(abi.encodePacked(x));
+        hash2 = keccak256(abi.encodePacked(y));
+        hash3NonZero = bytes32(0) != keccak256(abi.encodePacked(this.f));
+    }
+}
+// ====
+// EVMVersion: >=prague
+// bytecodeFormat: >=EOFv1
+// ----
+// f() -> 0xba4f20407251e4607cd66b90bfea19ec6971699c03e4a4f3ea737d5818ac27ae, 0xba4f20407251e4607cd66b90bfea19ec6971699c03e4a4f3ea737d5818ac27ae, true

test/libsolidity/semanticTests/builtinFunctions/keccak256_packed_complex_types.sol

@@ -10,5 +10,7 @@ contract C {
         hash3 = keccak256(abi.encodePacked(this.f));
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // f() -> 0xba4f20407251e4607cd66b90bfea19ec6971699c03e4a4f3ea737d5818ac27ae, 0xba4f20407251e4607cd66b90bfea19ec6971699c03e4a4f3ea737d5818ac27ae, 0x0e9229fb1d2cd02cee4b6c9f25497777014a8766e3479666d1c619066d2887ec

test/libsolidity/semanticTests/constructor/callvalue_check.sol

@@ -29,6 +29,7 @@ contract C {
 }
 // ====
 // EVMVersion: >homestead
+// bytecodeFormat: legacy
 // ----
 // f(uint256), 2000 ether: 0 -> true
 // f(uint256), 2000 ether: 100 -> false

test/libsolidity/semanticTests/constructor/eof/no_callvalue_check.sol

@@ -0,0 +1,28 @@
+contract A1 {}
+contract B1 is A1 { constructor() payable {} }
+
+contract A2 { constructor() {} }
+contract B2 is A2 { constructor() payable {} }
+
+contract B3 { constructor() payable {} }
+
+contract C {
+	function f() public payable returns (bool) {
+		// Make sure none of these revert.
+		new B1{value: 10, salt: hex"00"}();
+		new B2{value: 10, salt: hex"01"}();
+		new B3{value: 10, salt: hex"02"}();
+		return true;
+	}
+}
+// ====
+// bytecodeFormat: >=EOFv1
+// EVMVersion: >=prague
+// ----
+// f(), 2000 ether -> true
+// gas irOptimized: 117623
+// gas irOptimized code: 1800
+// gas legacy: 117821
+// gas legacy code: 4800
+// gas legacyOptimized: 117690
+// gas legacyOptimized code: 4800

test/libsolidity/semanticTests/constructor/no_callvalue_check.sol

@@ -15,6 +15,8 @@ contract C {
 		return true;
 	}
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // f(), 2000 ether -> true
 // gas irOptimized: 117623

test/libsolidity/semanticTests/deployedCodeExclusion/bound_function.sol

@@ -36,5 +36,7 @@ contract C {
         return x < data.length;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // test() -> true

test/libsolidity/semanticTests/deployedCodeExclusion/library_function.sol

@@ -30,5 +30,7 @@ contract C {
         return x < data.length;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // test() -> true

test/libsolidity/semanticTests/deployedCodeExclusion/module_function.sol

@@ -32,5 +32,7 @@ contract C {
         return x < data.length;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // test() -> true

test/libsolidity/semanticTests/deployedCodeExclusion/static_base_function.sol

@@ -31,5 +31,7 @@ contract C is S {
         return x < data.length;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // test() -> true

test/libsolidity/semanticTests/deployedCodeExclusion/subassembly_deduplication.sol

@@ -37,5 +37,7 @@ contract C {
             x < 2 * type(A).creationCode.length;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // test() -> true

test/libsolidity/semanticTests/deployedCodeExclusion/super_function.sol

@@ -31,5 +31,7 @@ contract C is S {
         return x < data.length;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // test() -> true

test/libsolidity/semanticTests/deployedCodeExclusion/virtual_function.sol

@@ -35,5 +35,7 @@ contract C is X {
         return x < data.length;
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // test() -> true

test/libsolidity/semanticTests/eof/interface_inheritance_conversions.sol

@@ -0,0 +1,47 @@
+interface Parent {
+    function parentFun() external returns (uint256);
+}
+
+interface SubA is Parent {
+    function subAFun() external returns (uint256);
+}
+
+interface SubB is Parent {
+    function subBFun() external returns (uint256);
+}
+
+contract Impl is SubA, SubB {
+    function parentFun() override external returns (uint256) { return 1; }
+    function subAFun() override external returns (uint256) { return 2; }
+    function subBFun() override external returns (uint256) { return 3; }
+}
+
+contract C {
+    function convertParent() public returns (uint256) {
+        Parent p = new Impl();
+        return p.parentFun();
+    }
+
+    function convertSubA() public returns (uint256, uint256) {
+        bytes32 s = 0x0000000000000000000000000000000000000000000000000000000000000001;
+        SubA sa = new Impl{salt: s}();
+        return (sa.parentFun(), sa.subAFun());
+    }
+
+    function convertSubB() public returns (uint256, uint256) {
+        bytes32 s = 0x0000000000000000000000000000000000000000000000000000000000000002;
+        SubB sb = new Impl{salt: s}();
+        return (sb.parentFun(), sb.subBFun());
+    }
+}
+// ====
+// bytecodeFormat: legacy
+// ----
+// convertParent() -> 1
+// gas irOptimized: 85524
+// convertSubA() -> 1, 2
+// gas irOptimized: 86155
+// gas legacy: 99047
+// convertSubB() -> 1, 3
+// gas irOptimized: 86098
+// gas legacy: 98981

test/libsolidity/semanticTests/errors/eof/errors_by_parameter_type.sol

@@ -0,0 +1,46 @@
+pragma abicoder v2;
+
+struct S {
+    uint256 a;
+    bool b;
+    string s;
+}
+
+error E();
+error E1(uint256);
+error E2(string);
+error E3(S);
+error E4(address);
+error E5(function() external pure);
+
+contract C {
+    function a() external pure {
+        require(false, E());
+    }
+    function b() external pure {
+        require(false, E1(1));
+    }
+    function c() external pure {
+        require(false, E2("string literal"));
+    }
+    function d() external pure {
+        require(false, E3(S(1, true, "string literal")));
+    }
+    function e() external view {
+        require(false, E4(address(0x6AfCA7D4Df015A0Ba25dA0d02D175603a5fB40E6)));
+    }
+    function f(function() external pure x) external view {
+        require(false, E5(x));
+    }
+}
+
+// ====
+// EVMVersion: >=prague
+// bytecodeFormat: >=EOFv1
+// ----
+// a() -> FAILURE, hex"92bbf6e8"
+// b() -> FAILURE, hex"47e26897", hex"0000000000000000000000000000000000000000000000000000000000000001"
+// c() -> FAILURE, hex"8f372c34", hex"0000000000000000000000000000000000000000000000000000000000000020", hex"000000000000000000000000000000000000000000000000000000000000000e", hex"737472696e67206c69746572616c000000000000000000000000000000000000"
+// d() -> FAILURE, hex"5717173e", hex"0000000000000000000000000000000000000000000000000000000000000020", hex"0000000000000000000000000000000000000000000000000000000000000001", hex"0000000000000000000000000000000000000000000000000000000000000001", hex"0000000000000000000000000000000000000000000000000000000000000060", hex"000000000000000000000000000000000000000000000000000000000000000e", hex"737472696e67206c69746572616c000000000000000000000000000000000000"
+// e() -> FAILURE, hex"7efef9ea", hex"0000000000000000000000006afca7d4df015a0ba25da0d02d175603a5fb40e6"
+// f(function): left(0x6afca7d4df015a0ba25da0d02d175603a5fb40e60dbe671f0000000000000000) -> FAILURE, hex"0c3f12eb", hex"6afca7d4df015a0ba25da0d02d175603a5fb40e60dbe671f0000000000000000"

test/libsolidity/semanticTests/errors/eof/require_error_function_pointer_parameter.sol

@@ -0,0 +1,16 @@
+error CustomError(function(uint256) external pure returns (uint256));
+
+contract C
+{
+    function f(function(uint256) external pure returns (uint256) x) external view
+    {
+        // more than one stack slot
+        require(false, CustomError(x));
+    }
+}
+
+// ====
+// EVMVersion: >=prague
+// bytecodeFormat: >=EOFv1
+// ----
+// f(function): left(0xa4dc3b5fce39438ce512c732ccb22e3212856bb6f37cdc8e0000000000000000) -> FAILURE, hex"271b1dfa", hex"a4dc3b5fce39438ce512c732ccb22e3212856bb6f37cdc8e0000000000000000"

test/libsolidity/semanticTests/errors/errors_by_parameter_type.sol

@@ -36,6 +36,7 @@ contract C {
 
 // ====
 // compileViaYul: true
+// bytecodeFormat: legacy
 // ----
 // a() -> FAILURE, hex"92bbf6e8"
 // b() -> FAILURE, hex"47e26897", hex"0000000000000000000000000000000000000000000000000000000000000001"

test/libsolidity/semanticTests/errors/require_error_function_pointer_parameter.sol

@@ -14,5 +14,7 @@ contract C
     }
 }
 
+// ====
+// bytecodeFormat: legacy
 // ----
 // f() -> FAILURE, hex"271b1dfa", hex"c06afe3a8444fc0004668591e8306bfb9968e79ef37cdc8e0000000000000000"

test/libsolidity/semanticTests/events/eof/event_indexed_function.sol

@@ -0,0 +1,12 @@
+contract C {
+    event Test(function() external indexed);
+    function f(function() external x) public {
+        emit Test(x);
+    }
+}
+// ====
+// EVMVersion: >=prague
+// bytecodeFormat: >=EOFv1
+// ----
+// f(function): left(0x8f8cc95dcbe7358c1cf1409d3a7ad079e89576bb26121ff00000000000000000) ->
+// ~ emit Test(function): #0x8f8cc95dcbe7358c1cf1409d3a7ad079e89576bb26121ff00000000000000000

test/libsolidity/semanticTests/events/eof/event_indexed_function2.sol

@@ -0,0 +1,18 @@
+contract C {
+    event TestA(function() external indexed);
+    event TestB(function(uint256) external indexed);
+    function f1(function() external x) public {
+        emit TestA(x);
+    }
+    function f2(function(uint256) external x) public {
+        emit TestB(x);
+    }
+}
+// ====
+// EVMVersion: >=prague
+// bytecodeFormat: >=EOFv1
+// ----
+// f1(function): left(0x347eaa94e3f63220b1f27af5888d33325ddbd4dec27fc3050000000000000000) ->
+// ~ emit TestA(function): #0x347eaa94e3f63220b1f27af5888d33325ddbd4dec27fc3050000000000000000
+// f2(function): left(0x347eaa94e3f63220b1f27af5888d33325ddbd4debf3724af0000000000000000) ->
+// ~ emit TestB(function): #0x347eaa94e3f63220b1f27af5888d33325ddbd4debf3724af0000000000000000

test/libsolidity/semanticTests/events/event_emit_from_other_contract.sol

@@ -13,6 +13,8 @@ contract C {
         d.deposit(_id);
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // constructor() ->
 // gas irOptimized: 113970

test/libsolidity/semanticTests/events/event_indexed_function.sol

@@ -4,6 +4,8 @@ contract C {
         emit Test(this.f);
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // f() ->
 // ~ emit Test(function): #0xc06afe3a8444fc0004668591e8306bfb9968e79e26121ff00000000000000000

test/libsolidity/semanticTests/events/event_indexed_function2.sol

@@ -8,6 +8,8 @@ contract C {
         emit TestB(this.f2);
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // f1() ->
 // ~ emit TestA(function): #0xc06afe3a8444fc0004668591e8306bfb9968e79ec27fc3050000000000000000

test/libsolidity/semanticTests/experimental/stub.sol

@@ -92,6 +92,7 @@ contract C {
 // EVMVersion: >=constantinople
 // ====
 // compileViaYul: true
+// bytecodeFormat: legacy
 // ----
 // (): 0 -> 0
 // (): 1 -> 544

test/libsolidity/semanticTests/experimental/type_class.sol

@@ -63,5 +63,6 @@ contract C {
 // ====
 // EVMVersion: >=constantinople
 // compileViaYul: true
+// bytecodeFormat: legacy
 // ----
 // () -> 1, 0

test/libsolidity/semanticTests/externalContracts/deposit_contract.sol

@@ -174,6 +174,8 @@ contract DepositContract is IDepositContract, ERC165 {
         ret[7] = bytesValue[0];
     }
 }
+// ====
+// bytecodeFormat: legacy
 // ----
 // constructor()
 // gas irOptimized: 809570