Add assertion + test case for #108

Author: hsutter

regression-tests/mixed-inspect-templates.cpp2

@@ -0,0 +1,41 @@
+#include <vector>
+#include <array>
+#include <string>
+
+template <typename A, typename B>
+struct my_type {};
+
+fun: (v : _) -> std::string = {
+    return inspect v -> std::string {
+        is std::vector  = "std::vector";
+        is std::array   = "std::array";
+        is std::variant = "std::variant";
+        is my_type      = "my_type";
+        is _ = "unknown";
+    };
+}
+
+fun2: (v : _) -> std::string = {
+    if v is std::vector  { return "std::vector";  }
+    if v is std::array   { return "std::array";   }
+    if v is std::variant { return "std::variant"; }
+    if v is my_type      { return "my_type";      }
+    return "unknown";
+}
+
+main: () -> int = {
+    vec : std::vector<int> = (1,2,3);
+    arr : std::array<int,4> = (1,2,3,4);
+    var : std::variant<int, double, std::string> = ("cpp2 rulez");
+    myt : my_type<int, double> = ();
+
+    std::cout << "inspected vec : (fun(vec))$" << std::endl;
+    std::cout << "inspected arr : (fun(arr))$" << std::endl;
+    std::cout << "inspected var : (fun(var))$" << std::endl;
+    std::cout << "inspected myt : (fun(myt))$" << std::endl;
+
+    std::cout << "inspected vec : (fun2(vec))$" << std::endl;
+    std::cout << "inspected arr : (fun2(arr))$" << std::endl;
+    std::cout << "inspected var : (fun2(var))$" << std::endl;
+    std::cout << "inspected myt : (fun2(myt))$" << std::endl;
+}

regression-tests/test-results/clang-12/mixed-inspect-templates.cpp.execution

@@ -0,0 +1,8 @@
+inspected vec : std::vector
+inspected arr : std::array
+inspected var : std::variant
+inspected myt : my_type
+inspected vec : std::vector
+inspected arr : std::array
+inspected var : std::variant
+inspected myt : my_type

regression-tests/test-results/clang-12/mixed-inspect-templates.cpp.output

@@ -0,0 +1,8 @@
+inspected vec : std::vector
+inspected arr : std::array
+inspected var : std::variant
+inspected myt : my_type
+inspected vec : std::vector
+inspected arr : std::array
+inspected var : std::variant
+inspected myt : my_type

regression-tests/test-results/gcc-10/mixed-inspect-templates.cpp.execution

@@ -0,0 +1,56 @@
+// ----- Cpp2 support -----
+#include "cpp2util.h"
+
+#line 1 "mixed-inspect-templates.cpp2"
+#include <vector>
+#include <array>
+#include <string>
+
+template <typename A, typename B>
+struct my_type {};
+
+[[nodiscard]] auto fun(auto const& v) -> std::string;
+#line 18 "mixed-inspect-templates.cpp2"
+[[nodiscard]] auto fun2(auto const& v) -> std::string;
+#line 26 "mixed-inspect-templates.cpp2"
+[[nodiscard]] auto main() -> int;
+
+//=== Cpp2 definitions ==========================================================
+
+#line 7 "mixed-inspect-templates.cpp2"
+
+[[nodiscard]] auto fun(auto const& v) -> std::string{
+    return [&] () -> std::string { auto&& __expr = v;
+        if (cpp2::is<std::vector>(__expr)) { if constexpr( requires{"std::vector";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("std::vector")),std::string> ) return "std::vector"; else return std::string{}; else return std::string{}; }
+        else if (cpp2::is<std::array>(__expr)) { if constexpr( requires{"std::array";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("std::array")),std::string> ) return "std::array"; else return std::string{}; else return std::string{}; }
+        else if (cpp2::is<std::variant>(__expr)) { if constexpr( requires{"std::variant";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("std::variant")),std::string> ) return "std::variant"; else return std::string{}; else return std::string{}; }
+        else if (cpp2::is<my_type>(__expr)) { if constexpr( requires{"my_type";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("my_type")),std::string> ) return "my_type"; else return std::string{}; else return std::string{}; }
+        else return "unknown"; }
+    (); 
+}
+
+[[nodiscard]] auto fun2(auto const& v) -> std::string{
+    if (cpp2::is<std::vector>(v)) {return "std::vector"; }
+    if (cpp2::is<std::array>(v)) {return "std::array"; }
+    if (cpp2::is<std::variant>(v)) {return "std::variant"; }
+    if (cpp2::is<my_type>(v)) {return "my_type";    }
+    return "unknown"; 
+}
+
+[[nodiscard]] auto main() -> int{
+    std::vector<int> vec { 1, 2, 3 }; 
+    std::array<int,4> arr { 1, 2, 3, 4 }; 
+    std::variant<int,double,std::string> var { "cpp2 rulez" }; 
+    my_type      <int, double> myt {  }; 
+
+    std::cout << "inspected vec : " + cpp2::to_string(fun(vec)) << std::endl;
+    std::cout << "inspected arr : " + cpp2::to_string(fun(arr)) << std::endl;
+    std::cout << "inspected var : " + cpp2::to_string(fun(var)) << std::endl;
+    std::cout << "inspected myt : " + cpp2::to_string(fun(myt)) << std::endl;
+
+    std::cout << "inspected vec : " + cpp2::to_string(fun2(vec)) << std::endl;
+    std::cout << "inspected arr : " + cpp2::to_string(fun2(arr)) << std::endl;
+    std::cout << "inspected var : " + cpp2::to_string(fun2(var)) << std::endl;
+    std::cout << "inspected myt : " + cpp2::to_string(fun2(myt)) << std::endl;
+}
+

regression-tests/test-results/gcc-10/mixed-inspect-templates.cpp.output

@@ -0,0 +1,2 @@
+mixed-inspect-templates.cpp2... ok (mixed Cpp1/Cpp2, Cpp2 code passes safety checks)
+

regression-tests/test-results/mixed-inspect-templates.cpp

@@ -0,0 +1,8 @@
+inspected vec : std::vector
+inspected arr : std::array
+inspected var : std::variant
+inspected myt : my_type
+inspected vec : std::vector
+inspected arr : std::array
+inspected var : std::variant
+inspected myt : my_type

regression-tests/test-results/mixed-inspect-templates.cpp2.output

@@ -0,0 +1 @@
+mixed-inspect-templates.cpp

regression-tests/test-results/msvc-2022/mixed-inspect-templates.cpp.execution

@@ -1789,6 +1789,7 @@ class cppfront
                 assert(i->op_close);
                 auto local_args = text_chunks_with_parens_position{{}, i->op->position(), i->op_close->position()};
 
+                assert (i->expr_list);
                 if (!i->expr_list->expressions.empty()) {
                     local_args.text_chunks = print_to_text_chunks(*i->expr_list);
                 }