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

test/libsolidity/ASTJSON/assembly/slot_offset.json

@@ -187,6 +187,7 @@
                     "isOffset": true,
                     "isSlot": false,
                     "src": "106:8:1",
+                    "suffix": "offset",
                     "valueSize": 1
                   },
                   {
@@ -194,6 +195,7 @@
                     "isOffset": false,
                     "isSlot": true,
                     "src": "128:6:1",
+                    "suffix": "slot",
                     "valueSize": 1
                   }
                 ],

test/libsolidity/ASTJSON/assembly/slot_offset_legacy.json

@@ -180,6 +180,7 @@
                         "isOffset": true,
                         "isSlot": false,
                         "src": "106:8:1",
+                        "suffix": "offset",
                         "valueSize": 1
                       },
                       {
@@ -187,6 +188,7 @@
                         "isOffset": false,
                         "isSlot": true,
                         "src": "128:6:1",
+                        "suffix": "slot",
                         "valueSize": 1
                       }
                     ],

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

test/libsolidity/syntaxTests/functionTypes/external_library_function_to_external_function_type.sol

@@ -0,0 +1,14 @@
+library L {
+    function f(uint256 _a) external returns (uint256) {}
+}
+
+contract C {
+    function run(function(uint256) external returns (uint256) _operation) internal returns (uint256) {}
+    function test() public {
+        run(L.f);
+        function(uint256) external returns (uint256) _operation = L.f;
+    }
+}
+// ----
+// TypeError 9553: (230-233): Invalid type for argument in function call. Invalid implicit conversion from function (uint256) returns (uint256) to function (uint256) external returns (uint256) requested.
+// TypeError 9574: (244-305): Type function (uint256) returns (uint256) is not implicitly convertible to expected type function (uint256) external returns (uint256).

test/libsolidity/syntaxTests/inlineAssembly/invalid/calldata_array.sol

@@ -0,0 +1,9 @@
+contract C {
+    function f(uint[] calldata bytesAsCalldata) external {
+        assembly {
+            let x := bytesAsCalldata
+        }
+    }
+}
+// ----
+// TypeError 1397: (112-127): Call data elements cannot be accessed directly. Use ".offset" and ".length" to access the calldata offset and length of this array and then use "calldatacopy".

test/libsolidity/syntaxTests/inlineAssembly/invalid/calldata_array_offset.sol

@@ -0,0 +1,8 @@
+contract C {
+    function f(uint[] calldata bytesAsCalldata) external pure {
+        assembly {
+            let x := bytesAsCalldata.offset
+        }
+    }
+}
+// ----

test/libsolidity/syntaxTests/inlineAssembly/invalid/calldata_slot.sol

@@ -0,0 +1,9 @@
+contract C {
+    function f(bytes calldata bytesAsCalldata) external {
+        assembly {
+            let x := bytesAsCalldata.slot
+        }
+    }
+}
+// ----
+// TypeError 1536: (111-131): Calldata variables only support ".offset" and ".length".

test/libsolidity/syntaxTests/inlineAssembly/invalid/calldata_variables.sol

@@ -6,4 +6,4 @@ contract C {
     }
 }
 // ----
-// TypeError 2370: (111-126): Call data elements cannot be accessed directly. Copy to a local variable first or use "calldataload" or "calldatacopy" with manually determined offsets and sizes.
+// TypeError 1397: (111-126): Call data elements cannot be accessed directly. Use ".offset" and ".length" to access the calldata offset and length of this array and then use "calldatacopy".

test/libsolidity/syntaxTests/inlineAssembly/invalid/storage_assignment.sol

@@ -7,4 +7,4 @@ contract test {
     }
 }
 // ----
-// TypeError 1408: (89-90): Only local variables are supported. To access storage variables, use the .slot and .offset suffixes.
+// TypeError 1408: (89-90): Only local variables are supported. To access storage variables, use the ".slot" and ".offset" suffixes.

test/libsolidity/syntaxTests/inlineAssembly/invalid/storage_assignment_in_modifier.sol

@@ -10,4 +10,4 @@ contract test {
     }
 }
 // ----
-// TypeError 1408: (80-81): Only local variables are supported. To access storage variables, use the .slot and .offset suffixes.
+// TypeError 1408: (80-81): Only local variables are supported. To access storage variables, use the ".slot" and ".offset" suffixes.

test/libsolidity/syntaxTests/inlineAssembly/invalid/storage_nonslot.sol

@@ -0,0 +1,12 @@
+contract test {
+    uint x = 1;
+    function f() public {
+        assembly {
+            let t := x.length
+            x.length := 2
+        }
+    }
+}
+// ----
+// TypeError 4656: (98-106): State variables only support ".slot" and ".offset".
+// TypeError 4656: (119-127): State variables only support ".slot" and ".offset".

test/libsolidity/syntaxTests/inlineAssembly/invalid/unbalanced_two_stack_load.sol

@@ -5,4 +5,4 @@ contract c {
     }
 }
 // ----
-// TypeError 1408: (75-76): Only local variables are supported. To access storage variables, use the .slot and .offset suffixes.
+// TypeError 1408: (75-76): Only local variables are supported. To access storage variables, use the ".slot" and ".offset" suffixes.

test/libsolidity/syntaxTests/inlineAssembly/storage_reference.sol

@@ -8,4 +8,4 @@ contract C {
     }
 }
 // ----
-// TypeError 9068: (118-119): You have to use the .slot or .offset suffix to access storage reference variables.
+// TypeError 9068: (118-119): You have to use the ".slot" or ".offset" suffix to access storage reference variables.

test/libsolidity/syntaxTests/inlineAssembly/storage_reference_old.sol

@@ -9,5 +9,5 @@ contract C {
     }
 }
 // ----
-// DeclarationError 9467: (118-124): Identifier not found. Use ``.slot`` and ``.offset`` to access storage variables.
-// DeclarationError 9467: (142-150): Identifier not found. Use ``.slot`` and ``.offset`` to access storage variables.
+// DeclarationError 9467: (118-124): Identifier not found. Use ".slot" and ".offset" to access storage variables.
+// DeclarationError 9467: (142-150): Identifier not found. Use ".slot" and ".offset" to access storage variables.

test/libsolidity/syntaxTests/inlineAssembly/storage_reference_on_function.sol

@@ -6,4 +6,4 @@ contract C {
     }
 }
 // ----
-// TypeError 7944: (84-90): The suffixes .offset and .slot can only be used on storage variables.
+// TypeError 7944: (84-90): The suffixes ".offset", ".slot" and ".length" can only be used with variables.

test/libsolidity/syntaxTests/inlineAssembly/storage_reference_on_memory.sol

@@ -9,5 +9,5 @@ contract C {
     }
 }
 // ----
-// TypeError 3622: (117-123): The suffixes .offset and .slot can only be used on storage variables.
-// TypeError 3622: (141-149): The suffixes .offset and .slot can only be used on storage variables.
+// TypeError 3622: (117-123): The suffix ".slot" is not supported by this variable or type.
+// TypeError 3622: (141-149): The suffix ".offset" is not supported by this variable or type.

test/libsolidity/syntaxTests/inlineAssembly/two_stack_slot_access.sol

@@ -0,0 +1,10 @@
+contract C {
+    function f() pure external {
+        function() external two_stack_slots;
+        assembly {
+            let x :=  two_stack_slots
+        }
+    }
+}
+// ----
+// TypeError 9857: (132-147): Only types that use one stack slot are supported.

test/libsolidity/syntaxTests/nameAndTypeResolution/406_invalid_address_checksum.sol

@@ -5,4 +5,4 @@ contract C {
     }
 }
 // ----
-// SyntaxError 9429: (64-106): This looks like an address but has an invalid checksum. Correct checksummed address: "0xfA0bFc97E48458494Ccd857e1A85DC91F7F0046E". If this is not used as an address, please prepend '00'. For more information please see https://solidity.readthedocs.io/en/develop/types.html#address-literals
+// SyntaxError 9429: (64-106): This looks like an address but has an invalid checksum. Correct checksummed address: "0xfA0bFc97E48458494Ccd857e1A85DC91F7F0046E". If this is not used as an address, please prepend '00'. For more information please see https://docs.soliditylang.org/en/develop/types.html#address-literals

test/libsolidity/syntaxTests/nameAndTypeResolution/407_invalid_address_no_checksum.sol

@@ -5,4 +5,4 @@ contract C {
     }
 }
 // ----
-// SyntaxError 9429: (64-106): This looks like an address but has an invalid checksum. Correct checksummed address: "0xfA0bFc97E48458494Ccd857e1A85DC91F7F0046E". If this is not used as an address, please prepend '00'. For more information please see https://solidity.readthedocs.io/en/develop/types.html#address-literals
+// SyntaxError 9429: (64-106): This looks like an address but has an invalid checksum. Correct checksummed address: "0xfA0bFc97E48458494Ccd857e1A85DC91F7F0046E". If this is not used as an address, please prepend '00'. For more information please see https://docs.soliditylang.org/en/develop/types.html#address-literals

test/libsolidity/syntaxTests/nameAndTypeResolution/408_invalid_address_length_short.sol

@@ -5,4 +5,4 @@ contract C {
     }
 }
 // ----
-// SyntaxError 9429: (64-105): This looks like an address but is not exactly 40 hex digits. It is 39 hex digits. If this is not used as an address, please prepend '00'. For more information please see https://solidity.readthedocs.io/en/develop/types.html#address-literals
+// SyntaxError 9429: (64-105): This looks like an address but is not exactly 40 hex digits. It is 39 hex digits. If this is not used as an address, please prepend '00'. For more information please see https://docs.soliditylang.org/en/develop/types.html#address-literals

test/libsolidity/syntaxTests/nameAndTypeResolution/409_invalid_address_length_long.sol

@@ -5,4 +5,4 @@ contract C {
     }
 }
 // ----
-// SyntaxError 9429: (64-107): This looks like an address but is not exactly 40 hex digits. It is 41 hex digits. If this is not used as an address, please prepend '00'. For more information please see https://solidity.readthedocs.io/en/develop/types.html#address-literals
+// SyntaxError 9429: (64-107): This looks like an address but is not exactly 40 hex digits. It is 41 hex digits. If this is not used as an address, please prepend '00'. For more information please see https://docs.soliditylang.org/en/develop/types.html#address-literals

test/libsolidity/syntaxTests/types/address/contract_type_to_address.sol

@@ -0,0 +1,21 @@
+interface I {}
+
+library L {}
+
+contract C {
+    function f() public pure {
+        address(C);
+        address(I);
+        address(L); // This one is allowed
+
+        address(type(C));
+        address(type(I));
+        address(type(L));
+    }
+}
+// ----
+// TypeError 9640: (82-92): Explicit type conversion not allowed from "type(contract C)" to "address".
+// TypeError 9640: (102-112): Explicit type conversion not allowed from "type(contract I)" to "address".
+// TypeError 9640: (166-182): Explicit type conversion not allowed from "type(contract C)" to "address".
+// TypeError 9640: (192-208): Explicit type conversion not allowed from "type(contract I)" to "address".
+// TypeError 9640: (218-234): Explicit type conversion not allowed from "type(library L)" to "address".

test/libsolidity/syntaxTests/types/address/super_to_address.sol

@@ -0,0 +1,7 @@
+contract C {
+    function f() public pure {
+        address(super);
+    }
+}
+// ----
+// TypeError 9640: (52-66): Explicit type conversion not allowed from "contract super C" to "address".

test/libsolidity/syntaxTests/types/address/type_type_to_address.sol

@@ -0,0 +1,46 @@
+struct S {
+    uint x;
+}
+
+enum E {A, B, C}
+
+contract C {
+    function f() public pure {
+        address(uint);
+        address(bytes16);
+        address(bool);
+        address(address);
+        address(fixed);
+
+        address(S);
+        address(E);
+
+        address(uint[]);
+        address(uint[][]);
+        address(uint[5]);
+        address(string);
+        address(bytes);
+        address(S[]);
+        address(E[]);
+        address((uint, uint));
+
+        address(type(uint));
+    }
+}
+// ----
+// TypeError 9640: (96-109): Explicit type conversion not allowed from "type(uint256)" to "address".
+// TypeError 9640: (119-135): Explicit type conversion not allowed from "type(bytes16)" to "address".
+// TypeError 9640: (145-158): Explicit type conversion not allowed from "type(bool)" to "address".
+// TypeError 9640: (168-184): Explicit type conversion not allowed from "type(address)" to "address".
+// TypeError 9640: (194-208): Explicit type conversion not allowed from "type(fixed128x18)" to "address".
+// TypeError 9640: (219-229): Explicit type conversion not allowed from "type(struct S storage pointer)" to "address".
+// TypeError 9640: (239-249): Explicit type conversion not allowed from "type(enum E)" to "address".
+// TypeError 9640: (260-275): Explicit type conversion not allowed from "type(uint256[] memory)" to "address".
+// TypeError 9640: (285-302): Explicit type conversion not allowed from "type(uint256[] memory[] memory)" to "address".
+// TypeError 9640: (312-328): Explicit type conversion not allowed from "type(uint256[5] memory)" to "address".
+// TypeError 9640: (338-353): Explicit type conversion not allowed from "type(string storage pointer)" to "address".
+// TypeError 9640: (363-377): Explicit type conversion not allowed from "type(bytes storage pointer)" to "address".
+// TypeError 9640: (387-399): Explicit type conversion not allowed from "type(struct S memory[] memory)" to "address".
+// TypeError 9640: (409-421): Explicit type conversion not allowed from "type(enum E[] memory)" to "address".
+// TypeError 9640: (431-452): Explicit type conversion not allowed from "tuple(type(uint256),type(uint256))" to "address".
+// TypeError 9640: (463-482): Explicit type conversion not allowed from "type(uint256)" to "address".