feat(slang): complete modules and free functions

solidity.yaml

@@ -2696,7 +2696,8 @@ entries:
         version: '>=0.4.12'
       module_from_ternary_expression.sol:
         hash: '0xc1560929c43117f8d19e6ab15ecf4cdb'
-        enabled: true
+        enabled: false
+        comment: Module conditionals are rejected by Slang
         version: '>=0.6.11'
       tuple_from_ternary_expression.sol:
         hash: '0xeb7fb8021a1150d98f082fbd659dec97'

solx-mlir/tests/lit/enum_variant.sol

@@ -9,6 +9,10 @@
 // CHECK:   sol.constant 2 : ui256
 // CHECK:   sol.enum_cast %{{.*}} : ui256 to !sol.enum<2>
 
+// CHECK: sol.func @{{.*interface_variant.*}}-> !sol.enum<2>
+// CHECK:   sol.constant 1 : ui256
+// CHECK:   sol.enum_cast %{{.*}} : ui256 to !sol.enum<2>
+
 // CHECK: sol.func @{{.*type_min.*}}-> !sol.enum<2>
 // CHECK:   sol.constant 0 : ui256
 // CHECK:   sol.enum_cast %{{.*}} : ui256 to !sol.enum<2>
@@ -17,6 +21,10 @@
 // CHECK:   sol.constant 2 : ui256
 // CHECK:   sol.enum_cast %{{.*}} : ui256 to !sol.enum<2>
 
+interface I {
+    enum E { First, Second, Third }
+}
+
 contract C {
     enum E { First, Second, Third }
 
@@ -28,6 +36,10 @@ contract C {
         return C.E.Third;
     }
 
+    function interface_variant() public pure returns (I.E) {
+        return I.E.Second;
+    }
+
     function type_min() public pure returns (E) {
         return type(E).min;
     }

solx-mlir/tests/lit/free_function_operator_reached.sol

@@ -0,0 +1,27 @@
+// RUN: solx --emit-mlir=sol %s | FileCheck %s
+
+// Free functions reached only via a user-defined operator binding: solc's print-init calls
+// @add yet never lowers it or its helper, so this is solx-only.
+
+// CHECK: sol.func @{{.*}}f{{.*}}(%{{.*}}: si32, %{{.*}}: si32) -> si32
+// CHECK:   sol.call @"add(T,T)_[[ADD:[0-9]+]]"(%{{.*}}, %{{.*}}) : (si32, si32) -> si32
+// CHECK: sol.func @"add(T,T)_[[ADD]]"(%{{.*}}: si32, %{{.*}}: si32) -> si32
+// CHECK:   sol.call @"helper(T)_[[HELPER:[0-9]+]]"(%{{.*}}) : (si32) -> si32
+// CHECK: sol.func @"helper(T)_[[HELPER]]"(%{{.*}}: si32) -> si32
+
+type T is int32;
+using {add as +} for T global;
+
+function helper(T x) pure returns (T) {
+    return x;
+}
+
+function add(T x, T y) pure returns (T) {
+    return helper(x);
+}
+
+contract C {
+    function f(T x, T y) public pure returns (T) {
+        return x + y;
+    }
+}

solx-mlir/tests/lit/free_function_pointer.sol

@@ -0,0 +1,25 @@
+// RUN: solx --emit-mlir=sol %s | FileCheck %s
+// RUN: solc --mlir-action=print-init %s 2>/dev/null | FileCheck %s
+
+// CHECK: sol.func @{{.*invoke.*}}(%{{.*}}: !sol.func_ref<(ui256) -> ui256>, %{{.*}}: ui256) -> ui256
+// CHECK: sol.func @{{.*run.*}}(%{{.*}}: ui256) -> ui256 attributes {{.*}}selector = -1538984471 : i32
+// CHECK:   %[[F:.*]] = sol.func_constant @{{.*increment.*}} : !sol.func_ref<(ui256) -> ui256>
+// CHECK:   %[[R:.*]] = sol.call @{{.*invoke.*}}(%[[F]], %{{.*}}) : (!sol.func_ref<(ui256) -> ui256>, ui256) -> ui256
+// CHECK:   sol.return %[[R]] : ui256
+
+function increment(uint256 a) pure returns (uint256) {
+    return a + 1;
+}
+
+contract C {
+    function invoke(
+        function(uint256) pure returns (uint256) f,
+        uint256 x
+    ) internal pure returns (uint256) {
+        return f(x);
+    }
+
+    function run(uint256 x) public pure returns (uint256) {
+        return invoke(increment, x);
+    }
+}

solx-mlir/tests/lit/free_function_using_for.sol

@@ -0,0 +1,22 @@
+// RUN: solx --emit-mlir=sol %s | FileCheck %s
+
+// solc's print-init drops the receiver from a using-for free-function call, calling
+// `@double() : ()`, while legacy forwards it, so this is solx-only.
+
+// CHECK: sol.func @{{.*}}f{{.*}}(%{{.*}}: ui256) -> ui256
+// CHECK:   %[[R:.*]] = sol.call @"double(uint256)_[[D:[0-9]+]]"(%{{.*}}) : (ui256) -> ui256
+// CHECK:   sol.return %[[R]] : ui256
+// CHECK: sol.func @"double(uint256)_[[D]]"(%{{.*}}: ui256) -> ui256
+// CHECK:   sol.cmul
+
+function double(uint256 a) pure returns (uint256) {
+    return a * 2;
+}
+
+contract C {
+    using {double} for uint256;
+
+    function f(uint256 x) public pure returns (uint256) {
+        return x.double();
+    }
+}

solx-mlir/tests/lit/lit.cfg.py

@@ -6,7 +6,7 @@
 config.suffixes = [".sol"]
 
 config_dir = os.path.dirname(os.path.abspath(__file__))
-solx_root = os.path.join(config_dir, "..", "..", "..")
+solx_root = os.path.normpath(os.path.join(config_dir, "..", "..", ".."))
 solx_bin_dir = os.path.join(solx_root, "target", os.environ.get("SOLX_LIT_TARGET", ""), "debug")
 solc_bin_dir = os.path.join(solx_root, "solx-solidity", "build", "solc")
 
@@ -20,6 +20,15 @@
 config.substitutions.append(
     ("%for_loop", os.path.join(solx_root, "tests", "solidity", "simple", "loop", "for").replace("\\", "/"))
 )
+config.substitutions.append(
+    ("%qualifier_module", os.path.join(solx_root, "tests", "solidity", "complex", "qualifier_module").replace("\\", "/"))
+)
+config.substitutions.append(
+    ("%qualifier_type_name", os.path.join(solx_root, "tests", "solidity", "complex", "qualifier_type_name").replace("\\", "/"))
+)
+config.substitutions.append(
+    ("%qualifier_library_external", os.path.join(solx_root, "tests", "solidity", "complex", "qualifier_library_external").replace("\\", "/"))
+)
 
 config.test_source_root = config_dir
 config.test_exec_root = os.path.join(config_dir, "Output")

solx-mlir/tests/lit/module_members.sol

@@ -0,0 +1,101 @@
+// RUN: solx --emit-mlir=sol %s | FileCheck %s
+// RUN: solc --mlir-action=print-init %s 2>/dev/null | FileCheck %s
+
+// CHECK: sol.func @{{.*chained.*}}() -> ui256 attributes {{.*}}selector = 1955792327 : i32
+// CHECK:   %[[CK:.*]] = sol.constant 11 : ui8
+// CHECK:   %[[CV:.*]] = sol.cast %[[CK]] : ui8 to ui256
+// CHECK:   sol.return %[[CV]] : ui256
+
+// CHECK: sol.func @{{.*renamed.*}}() -> ui256 attributes {{.*}}selector = -1753621920 : i32
+// CHECK:   %[[RA:.*]] = sol.cast %{{.*}} : ui8 to ui256
+// CHECK:   %[[RC:.*]] = sol.call @{{.*freeTriple.*}}(%[[RA]]) : (ui256) -> ui256
+// CHECK:   sol.return %[[RC]] : ui256
+
+// CHECK: sol.func @{{.*starred.*}}() -> ui256 attributes {{.*}}selector = -1638182610 : i32
+// CHECK:   %[[SK:.*]] = sol.constant 11 : ui8
+// CHECK:   %[[SV:.*]] = sol.cast %[[SK]] : ui8 to ui256
+// CHECK:   sol.return %[[SV]] : ui256
+
+// CHECK: sol.func @{{.*plainCall.*}}() -> ui256 attributes {{.*}}selector = 1887173101 : i32
+// CHECK:   %[[PA:.*]] = sol.cast %{{.*}} : ui8 to ui256
+// CHECK:   %[[PC:.*]] = sol.call @{{.*freeTriple.*}}(%[[PA]]) : (ui256) -> ui256
+// CHECK:   sol.return %[[PC]] : ui256
+
+// CHECK: sol.func @{{.*chainedCall.*}}() -> ui256 attributes {{.*}}selector = -1246699396 : i32
+// CHECK:   %[[CA:.*]] = sol.cast %{{.*}} : ui8 to ui256
+// CHECK:   %[[CC:.*]] = sol.call @{{.*freeTriple.*}}(%[[CA]]) : (ui256) -> ui256
+// CHECK:   sol.return %[[CC]] : ui256
+
+// CHECK: sol.func @{{.*starredCall.*}}() -> ui256 attributes {{.*}}selector = -548888477 : i32
+// CHECK:   %[[SA:.*]] = sol.cast %{{.*}} : ui8 to ui256
+// CHECK:   %[[SC:.*]] = sol.call @{{.*freeTriple.*}}(%[[SA]]) : (ui256) -> ui256
+// CHECK:   sol.return %[[SC]] : ui256
+
+// CHECK: sol.func @{{.*parenthesized.*}}() -> ui256 attributes {{.*}}selector = -923061170 : i32
+// CHECK:   %[[NK:.*]] = sol.constant 11 : ui8
+// CHECK:   %[[NV:.*]] = sol.cast %[[NK]] : ui8 to ui256
+// CHECK:   sol.return %[[NV]] : ui256
+
+// CHECK: sol.func @{{.*qualified.*}}() -> ui256 attributes {{.*}}selector = -228858638 : i32
+// CHECK:   %[[QA:.*]] = sol.cast %{{.*}} : ui8 to ui256
+// CHECK:   %[[QC:.*]] = sol.call @{{.*halve.*}}(%[[QA]]) : (ui256) -> ui256
+// CHECK:   sol.return %[[QC]] : ui256
+
+// CHECK: sol.func @{{.*wrapped.*}}() -> ui256 attributes {{.*}}selector = 1357319496 : i32
+// CHECK:   %[[WK:.*]] = sol.constant 6 : ui8
+// CHECK:   %[[WV:.*]] = sol.cast %[[WK]] : ui8 to ui256
+// CHECK:   sol.return %[[WV]] : ui256
+
+import "./module_members.sol" as M;
+import {FREE_K as RENAMED_K, freeTriple} from "./module_members.sol";
+import * as S from "./module_members.sol";
+
+uint256 constant FREE_K = 11;
+
+type Cost is uint256;
+
+function freeTriple(uint256 x) pure returns (uint256) {
+    return x * 3;
+}
+
+contract ModuleMembers {
+    function chained() public pure returns (uint256) {
+        return M.M.M.FREE_K;
+    }
+
+    function renamed() public pure returns (uint256) {
+        return freeTriple(RENAMED_K);
+    }
+
+    function starred() public pure returns (uint256) {
+        return S.FREE_K;
+    }
+
+    function plainCall() public pure returns (uint256) {
+        return M.freeTriple(4);
+    }
+
+    function chainedCall() public pure returns (uint256) {
+        return M.M.freeTriple(4);
+    }
+
+    function starredCall() public pure returns (uint256) {
+        return S.freeTriple(4);
+    }
+
+    function parenthesized() public pure returns (uint256) {
+        return (M).FREE_K;
+    }
+
+    function qualified() public pure returns (uint256) {
+        return M.ModuleMembers.halve(6);
+    }
+
+    function wrapped() public pure returns (uint256) {
+        return Cost.unwrap(M.Cost.wrap(6));
+    }
+
+    function halve(uint256 x) internal pure returns (uint256) {
+        return x / 2;
+    }
+}

solx-mlir/tests/lit/names_discarded.sol

@@ -0,0 +1,45 @@
+// RUN: solx --emit-mlir=sol %s | FileCheck %s
+
+// solc's print-init crashes on a discarded struct, error, or event name, so this is solx-only.
+
+// CHECK: sol.func @{{.*structs.*}}()
+// CHECK-NEXT:   sol.return
+
+// CHECK: sol.func @{{.*errors.*}}()
+// CHECK-NEXT:   sol.return
+
+// CHECK: sol.func @{{.*events.*}}()
+// CHECK-NEXT:   sol.return
+
+struct Pair {
+    uint256 first;
+}
+
+error Missing(uint256 code);
+
+event Logged(uint256 code);
+
+contract C {
+    struct Inner {
+        uint256 value;
+    }
+
+    error Absent(uint256 code);
+
+    event Traced(uint256 code);
+
+    function structs() public pure {
+        Pair;
+        Inner;
+    }
+
+    function errors() public pure {
+        Missing;
+        Absent;
+    }
+
+    function events() public pure {
+        Logged;
+        Traced;
+    }
+}