Merge remote-tracking branch 'origin/develop' into breaking

test/libsolidity/semanticTests/constants/asm_address_constant_regression.sol

@@ -8,5 +8,7 @@ contract C {
   }
 }
 
+// ====
+// compileViaYul: also
 // ----
 // f() -> 0x00

test/libsolidity/semanticTests/freeFunctions/libraries_from_free.sol

@@ -16,6 +16,8 @@ contract C {
     return fu();
   }
 }
+// ====
+// compileViaYul: also
 // ----
 // library: L
-// f() -> 7, 8
+// f() -> 7, 8

test/libsolidity/semanticTests/inlineAssembly/calldata_array_assign.sol

@@ -0,0 +1,8 @@
+contract C {
+    function f(uint[2][] calldata x) public returns (uint[2][] memory r) {
+        assembly { x.offset := 0x44 x.length := 2 }
+        r = x;
+    }
+}
+// ----
+// f(uint256[2][]): 0x0, 1, 8, 7, 6, 5 -> 0x20, 2, 8, 7, 6, 5

test/libsolidity/semanticTests/inlineAssembly/calldata_array_read.sol

@@ -0,0 +1,12 @@
+contract C {
+    function f(uint[2][] calldata x) public returns (uint o, uint l, uint s) {
+        assembly { l := x.length o := x.offset }
+        uint[2] calldata t = x[1];
+        // statically-sized arrays only use one slot, so we read directly.
+        assembly { s := t }
+    }
+}
+// ====
+// compileViaYul: also
+// ----
+// f(uint256[2][]): 0x20, 2, 1, 2, 3, 4 -> 0x44, 2, 0x84

test/libsolidity/semanticTests/inlineAssembly/calldata_assign.sol

@@ -0,0 +1,10 @@
+contract C {
+    function f(bytes calldata x) public returns (bytes memory) {
+        assembly { x.offset := 1 x.length := 3 }
+        return x;
+    }
+}
+// ====
+// compileViaYul: also
+// ----
+// f(bytes): 0x20, 0, 0 -> 0x20, 3, 0x5754f80000000000000000000000000000000000000000000000000000000000

test/libsolidity/semanticTests/inlineAssembly/calldata_assign_from_nowhere.sol

@@ -0,0 +1,9 @@
+contract C {
+    function f() public pure returns (bytes calldata x) {
+        assembly { x.offset := 0 x.length := 4 }
+    }
+}
+// ====
+// compileViaYul: also
+// ----
+// f() -> 0x20, 4, 0x26121ff000000000000000000000000000000000000000000000000000000000

test/libsolidity/semanticTests/inlineAssembly/calldata_length_read.sol

@@ -0,0 +1,18 @@
+contract C {
+    function lenBytesRead(bytes calldata x) public returns (uint l) {
+        assembly { l := x.length }
+    }
+
+    function lenStringRead(string calldata x) public returns (uint l) {
+        assembly { l := x.length }
+    }
+}
+// ====
+// compileViaYul: also
+// ----
+// lenBytesRead(bytes): 0x20, 4, "abcd" -> 4
+// lenBytesRead(bytes): 0x20, 0, "abcd" -> 0x00
+// lenBytesRead(bytes): 0x20, 0x21, "abcd", "ef" -> 33
+// lenStringRead(string): 0x20, 4, "abcd" -> 4
+// lenStringRead(string): 0x20, 0, "abcd" -> 0x00
+// lenStringRead(string): 0x20, 0x21, "abcd", "ef" -> 33

test/libsolidity/semanticTests/inlineAssembly/calldata_offset_read.sol

@@ -0,0 +1,19 @@
+contract C {
+    function f(bytes calldata x) public returns (uint r) {
+        assembly { r := x.offset }
+    }
+
+    function f(uint, bytes calldata x, uint) public returns (uint r, uint v) {
+        assembly {
+            r := x.offset
+            v := x.length
+        }
+    }
+}
+// ====
+// compileViaYul: also
+// ----
+// f(bytes): 0x20, 0, 0 -> 0x44
+// f(bytes): 0x22, 0, 0, 0 -> 0x46
+// f(uint256,bytes,uint256): 7, 0x60, 8, 2, 0 -> 0x84, 2
+// f(uint256,bytes,uint256): 0, 0, 0 -> 0x24, 0x00

test/libsolidity/semanticTests/inlineAssembly/calldata_offset_read_write.sol

@@ -0,0 +1,18 @@
+contract C {
+    function f(uint, bytes calldata x, uint) public returns (uint r, uint v) {
+        assembly {
+            x.offset := 8
+            x.length := 20
+        }
+        assembly {
+            r := x.offset
+            v := x.length
+        }
+    }
+}
+
+// ====
+// compileViaYul: also
+// ----
+// f(uint256,bytes,uint256): 7, 0x60, 8, 2, 0 -> 8, 0x14
+// f(uint256,bytes,uint256): 0, 0, 0 -> 8, 0x14

test/libsolidity/semanticTests/inlineAssembly/constant_access.sol

@@ -14,5 +14,7 @@ contract C {
         }
     }
 }
+// ====
+// compileViaYul: also
 // ----
 // f() -> 2, left(0xabcd), left(0x616263), true, 0x1212121212121212121212121212121212121212

test/libsolidity/semanticTests/inlineAssembly/constant_access_referencing.sol

@@ -22,5 +22,7 @@ contract C {
         }
     }
 }
+// ====
+// compileViaYul: also
 // ----
 // f() -> 2, left(0xabcd), left(0x616263), true, 0x1212121212121212121212121212121212121212

test/libsolidity/semanticTests/inlineAssembly/slot_access.sol

@@ -25,6 +25,8 @@ contract C {
         return data().a;
     }
 }
+// ====
+// compileViaYul: also
 // ----
 // get() -> 0
 // mappingAccess(uint256): 1 -> 0, 0

test/libsolidity/semanticTests/libraries/external_call_with_function_pointer_parameter.sol

@@ -0,0 +1,26 @@
+library L {
+    function run(
+        function(uint256) external returns (uint256) _operation,
+        uint256 _a
+    )
+        external
+        returns (uint256)
+    {
+        return _operation(_a);
+    }
+}
+
+contract C {
+    function double(uint256 _a) external returns (uint256) {
+        return _a * _a;
+    }
+
+    function g(uint256 _value) external returns (uint256) {
+        return L.run(this.double, _value);
+    }
+}
+// ====
+// compileViaYul: also
+// ----
+// library: L
+// g(uint256): 4 -> 16

test/libsolidity/semanticTests/libraries/external_call_with_storage_array_parameter.sol

@@ -0,0 +1,19 @@
+library L {
+    function f(uint256[2] storage _a) external returns (uint256) {
+        return _a[0] * _a[1];
+    }
+}
+
+contract C {
+    uint256[2] x;
+
+    function g(uint256 _value) external returns (uint256) {
+        x[0] = x[1] = _value;
+        return L.f(x);
+    }
+}
+// ====
+// compileViaYul: also
+// ----
+// library: L
+// g(uint256): 4 -> 16

test/libsolidity/semanticTests/libraries/external_call_with_storage_mapping_parameter.sol

@@ -0,0 +1,17 @@
+library L {
+    function f(mapping(uint256 => uint256) storage _a) external returns (uint256) {
+        return _a[0] * _a[1];
+    }
+}
+
+contract C {
+    mapping(uint256 => uint256) x;
+
+    function g(uint256 _value) external returns (uint256) {
+        x[0] = x[1] = _value;
+        return L.f(x);
+    }
+}
+// ----
+// library: L
+// g(uint256): 4 -> 16

test/libsolidity/semanticTests/libraries/library_address_homestead.sol

@@ -12,6 +12,8 @@ contract C {
         return success;
     }
 }
+// ====
+// compileViaYul: also
 // ----
 // library: L
 // g(uint256,uint256): 1, 1 -> true

test/libsolidity/semanticTests/libraries/library_address_via_module.sol

@@ -0,0 +1,60 @@
+==== Source: a.sol ====
+
+import "a.sol" as M;
+
+library L {
+    function f(uint256 v) external pure returns (uint) {
+        return v * v;
+    }
+    function g(uint256 v) external returns (uint) {
+        return v * v;
+    }
+}
+contract C {
+    function addr() public view returns (bool) {
+        return address(M.L) == address(0);
+    }
+    function g(uint256 v) public view returns (uint256) {
+        return M.L.f(v);
+    }
+    function h(uint256 v) public returns (uint256) {
+        (bool success, bytes memory result) = address(M.L).delegatecall(abi.encodeWithSignature("f(uint256)", v));
+        assert(success);
+        return abi.decode(result, (uint256));
+    }
+    function i(uint256 v) public returns (uint256) {
+        (bool success, bytes memory result) = address(M.L).call(abi.encodeWithSignature("f(uint256)", v));
+        assert(success);
+        return abi.decode(result, (uint256));
+    }
+    function j(uint256 v) public returns (uint256) {
+        (bool success, bytes memory result) = address(M.L).delegatecall(abi.encodeWithSignature("g(uint256)", v));
+        assert(success);
+        return abi.decode(result, (uint256));
+    }
+    function k(uint256 v) public returns (uint256) {
+        (bool success, bytes memory result) = address(M.L).call(abi.encodeWithSignature("g(uint256)", v));
+        assert(success);
+        return abi.decode(result, (uint256));
+    }
+}
+// ====
+// EVMVersion: >=byzantium
+// ----
+// library: L
+// addr() -> false
+// g(uint256): 1 -> 1
+// g(uint256): 2 -> 4
+// g(uint256): 4 -> 16
+// h(uint256): 1 -> 1
+// h(uint256): 2 -> 4
+// h(uint256): 4 -> 16
+// i(uint256): 1 -> 1
+// i(uint256): 2 -> 4
+// i(uint256): 4 -> 16
+// j(uint256): 1 -> 1
+// j(uint256): 2 -> 4
+// j(uint256): 4 -> 16
+// k(uint256): 1 -> FAILURE
+// k(uint256): 2 -> FAILURE
+// k(uint256): 4 -> FAILURE

test/libsolidity/semanticTests/libraries/stub.sol

@@ -6,6 +6,8 @@ contract C {
         return L.f(v);
     }
 }
+// ====
+// compileViaYul: also
 // ----
 // library: L
 // g(uint256): 1 -> 1