test: split off "deducible parameters" unit test

Author: JohelEGP

regression-tests/pure2-bugfix-for-deducible-parameters.cpp2

@@ -0,0 +1,27 @@
+// Dependent, non-deducible parameters
+// are wrapped like non-dependent parameters.
+init: <T> (out x: std::integral_constant<i32, T::value>) = { x = (); }
+init: <T> (out x: std::integral_constant<i32, T::value>, _: T) = { x = (); }
+id: <T> (x: std::integral_constant<i32, T::value>) -> forward _ = x;
+id: <T> (x: std::integral_constant<i32, T::value>, y: T) = { [[assert: x& == y&]] }
+
+main: () = {
+  zero: type == std::integral_constant<i32, 0>;
+
+  z: zero;
+  init<zero>(out z);
+  [[assert: id<zero>(z)& == z&]]
+
+  // Deducible parameters.
+  _ = :v = 0;
+  _ = :<T> (x: std::vector<T>) = {}(:std::vector<i32> = ());
+  _ = :<T> (x: std::vector<std::vector<T>>) = {}(:std::vector<std::vector<i32>> = ());
+  // Uncomment once `typename` is supported for template arguments.
+  // _ = :<T, U> (x: std::pair<T, typename U::value_type>, y: U) = {}(:std::pair = (0, 0), z);
+  init(out z, z);
+  id(z, z);
+}
+
+v: <T> type = {
+  operator=: (out this, x: T) = { }
+}

regression-tests/pure2-bugfix-for-dependent-types-and-deducible-parameters.cpp2 renamed to regression-tests/pure2-bugfix-for-dependent-types.cpp2

@@ -51,31 +51,9 @@ t: @ struct <T: type> type = {
   x: T::value_type = 0;
 }
 
-// Dependent, non-deducible parameters
-// are wrapped like non-dependent parameters.
-init: <T> (out x: std::integral_constant<i32, T::value>) = { x = (); }
-init: <T> (out x: std::integral_constant<i32, T::value>, _: T) = { x = (); }
-id: <T> (x: std::integral_constant<i32, T::value>) -> forward _ = x;
-id: <T> (x: std::integral_constant<i32, T::value>, y: T) = { [[assert: x& == y&]] }
-
 main: () = {
   zero: type == std::integral_constant<i32, 0>;
-
   _ = f<zero, 0>(0);
-  _ = :t<zero>::u = ();
-
-  z: zero;
-  init<zero>(out z);
-  [[assert: id<zero>(z)& == z&]]
-
-  // Deducible parameters.
-  _ = :v = 0;
-  _ = :<T> (x: std::vector<T>) = {}(:std::vector<i32> = ());
-  _ = :<T> (x: std::vector<std::vector<T>>) = {}(:std::vector<std::vector<i32>> = ());
-  // Uncomment once `typename` is supported for template arguments.
-  // _ = :<T, U> (x: std::pair<T, typename U::value_type>, y: U) = {}(:std::pair = (0, 0), z);
-  init(out z, z);
-  id(z, z);
 
   // Nesting is irrelevant.
   _ = :<T> () = { _ = :T::value_type = (); };
@@ -104,7 +82,3 @@ main: () = {
     }
   }(0);
 }
-
-v: <T> type = {
-  operator=: (out this, x: T) = { }
-}

regression-tests/test-results/gcc-13/pure2-bugfix-for-dependent-types-and-deducible-parameters.cpp.execution renamed to regression-tests/test-results/gcc-13/pure2-bugfix-for-deducible-parameters.cpp.execution

@@ -0,0 +1,72 @@
+
+#define CPP2_USE_MODULES         Yes
+
+//=== Cpp2 type declarations ====================================================
+
+
+#include "cpp2util.h"
+
+
+#line 25 "pure2-bugfix-for-deducible-parameters.cpp2"
+template<typename T> class v;
+  
+
+//=== Cpp2 type definitions and function declarations ===========================
+
+// Dependent, non-deducible parameters
+// are wrapped like non-dependent parameters.
+#line 3 "pure2-bugfix-for-deducible-parameters.cpp2"
+template<typename T> auto init(cpp2::out<std::integral_constant<cpp2::i32,T::value>> x) -> void;
+template<typename T> auto init(cpp2::out<std::integral_constant<cpp2::i32,T::value>> x, T const& _) -> void;
+template<typename T> [[nodiscard]] auto id(cpp2::in<std::integral_constant<cpp2::i32,T::value>> x) -> auto&&;
+template<typename T> auto id(cpp2::in<std::integral_constant<cpp2::i32,T::value>> x, T const& y) -> void;
+
+auto main() -> int;
+  
+
+#line 25 "pure2-bugfix-for-deducible-parameters.cpp2"
+template<typename T> class v {
+  public: explicit v(T const& x);
+#line 26 "pure2-bugfix-for-deducible-parameters.cpp2"
+  public: auto operator=(T const& x) -> v& ;
+
+  public: v(v const&) = delete; /* No 'that' constructor, suppress copy */
+  public: auto operator=(v const&) -> void = delete;
+#line 27 "pure2-bugfix-for-deducible-parameters.cpp2"
+};
+
+
+//=== Cpp2 function definitions =================================================
+
+
+#line 3 "pure2-bugfix-for-deducible-parameters.cpp2"
+template<typename T> auto init(cpp2::out<std::integral_constant<cpp2::i32,T::value>> x) -> void{x.construct(); }
+template<typename T> auto init(cpp2::out<std::integral_constant<cpp2::i32,T::value>> x, T const& _) -> void{x.construct(); }
+template<typename T> [[nodiscard]] auto id(cpp2::in<std::integral_constant<cpp2::i32,T::value>> x) -> auto&& { return x;  }
+template<typename T> auto id(cpp2::in<std::integral_constant<cpp2::i32,T::value>> x, T const& y) -> void{cpp2::Default.expects(&x==&y, ""); }
+
+auto main() -> int{
+  using zero = std::integral_constant<cpp2::i32,0>;
+
+  cpp2::deferred_init<zero> z; 
+  init<zero>(cpp2::out(&z));
+  cpp2::Default.expects(&id<zero>(z.value())==&z.value(), "");
+
+  // Deducible parameters.
+  (void) v{0};
+  (void) []<typename T>(std::vector<T> const& x) -> void{}(std::vector<cpp2::i32>{});
+  (void) []<typename T>(std::vector<std::vector<T>> const& x) -> void{}(std::vector<std::vector<cpp2::i32>>{});
+  // Uncomment once `typename` is supported for template arguments.
+  // _ = :<T, U> (x: std::pair<T, typename U::value_type>, y: U) = {}(:std::pair = (0, 0), z);
+  init(cpp2::out(&z.value()), z.value());
+  id(z.value(), std::move(z.value()));
+}
+
+#line 26 "pure2-bugfix-for-deducible-parameters.cpp2"
+  template <typename T> v<T>::v(T const& x){}
+#line 26 "pure2-bugfix-for-deducible-parameters.cpp2"
+  template <typename T> auto v<T>::operator=(T const& x) -> v& {
+                                  return *this;
+#line 26 "pure2-bugfix-for-deducible-parameters.cpp2"
+  }
+

regression-tests/test-results/gcc-13/pure2-bugfix-for-dependent-types-and-deducible-parameters.cpp.output renamed to regression-tests/test-results/gcc-13/pure2-bugfix-for-deducible-parameters.cpp.output

@@ -0,0 +1,2 @@
+pure2-bugfix-for-deducible-parameters.cpp2... ok (all Cpp2, passes safety checks)
+

regression-tests/test-results/gcc-13/pure2-bugfix-for-dependent-types.cpp.execution

@@ -7,60 +7,37 @@
 #include "cpp2util.h"
 
 
-#line 46 "pure2-bugfix-for-dependent-types-and-deducible-parameters.cpp2"
+#line 46 "pure2-bugfix-for-dependent-types.cpp2"
 template<typename T> class t;
 
 
-#line 108 "pure2-bugfix-for-dependent-types-and-deducible-parameters.cpp2"
-template<typename T> class v;
-  
-
 //=== Cpp2 type definitions and function declarations ===========================
 
-#line 1 "pure2-bugfix-for-dependent-types-and-deducible-parameters.cpp2"
+#line 1 "pure2-bugfix-for-dependent-types.cpp2"
 template<typename T> using identity = T;
 
 template<typename T, T::value_type V> [[nodiscard]] auto f(cpp2::in<typename T::value_type> x) -> T::value_type;
 
 
-#line 46 "pure2-bugfix-for-dependent-types-and-deducible-parameters.cpp2"
+#line 46 "pure2-bugfix-for-dependent-types.cpp2"
 template<typename T> class t {
 struct u_x_as_base { T::value_type x; };
 
-#line 47 "pure2-bugfix-for-dependent-types-and-deducible-parameters.cpp2"
+#line 47 "pure2-bugfix-for-dependent-types.cpp2"
   public: class u: public u_x_as_base, public T::type {
 
-#line 50 "pure2-bugfix-for-dependent-types-and-deducible-parameters.cpp2"
+#line 50 "pure2-bugfix-for-dependent-types.cpp2"
   };
   public: T::value_type x {0}; 
 };
 
-// Dependent, non-deducible parameters
-// are wrapped like non-dependent parameters.
-template<typename T> auto init(cpp2::out<std::integral_constant<cpp2::i32,T::value>> x) -> void;
-template<typename T> auto init(cpp2::out<std::integral_constant<cpp2::i32,T::value>> x, T const& _) -> void;
-template<typename T> [[nodiscard]] auto id(cpp2::in<std::integral_constant<cpp2::i32,T::value>> x) -> auto&&;
-template<typename T> auto id(cpp2::in<std::integral_constant<cpp2::i32,T::value>> x, T const& y) -> void;
-
 auto main() -> int;
 
 
-#line 108 "pure2-bugfix-for-dependent-types-and-deducible-parameters.cpp2"
-template<typename T> class v {
-  public: explicit v(T const& x);
-#line 109 "pure2-bugfix-for-dependent-types-and-deducible-parameters.cpp2"
-  public: auto operator=(T const& x) -> v& ;
-
-  public: v(v const&) = delete; /* No 'that' constructor, suppress copy */
-  public: auto operator=(v const&) -> void = delete;
-#line 110 "pure2-bugfix-for-dependent-types-and-deducible-parameters.cpp2"
-};
-
-
 //=== Cpp2 function definitions =================================================
 
 
-#line 3 "pure2-bugfix-for-dependent-types-and-deducible-parameters.cpp2"
+#line 3 "pure2-bugfix-for-dependent-types.cpp2"
 template<typename T, T::value_type V> [[nodiscard]] auto f(cpp2::in<typename T::value_type> x) -> T::value_type{
   cpp2::Default.expects(cpp2::is<typename T::value_type>(x), "");
   cpp2::deferred_init<typename T::value_type> y; 
@@ -104,30 +81,10 @@ template<typename T, T::value_type V> [[nodiscard]] auto f(cpp2::in<typename T::
   }
 }
 
-#line 56 "pure2-bugfix-for-dependent-types-and-deducible-parameters.cpp2"
-template<typename T> auto init(cpp2::out<std::integral_constant<cpp2::i32,T::value>> x) -> void{x.construct(); }
-template<typename T> auto init(cpp2::out<std::integral_constant<cpp2::i32,T::value>> x, T const& _) -> void{x.construct(); }
-template<typename T> [[nodiscard]] auto id(cpp2::in<std::integral_constant<cpp2::i32,T::value>> x) -> auto&& { return x;  }
-template<typename T> auto id(cpp2::in<std::integral_constant<cpp2::i32,T::value>> x, T const& y) -> void{cpp2::Default.expects(&x==&y, ""); }
-
+#line 54 "pure2-bugfix-for-dependent-types.cpp2"
 auto main() -> int{
   using zero = std::integral_constant<cpp2::i32,0>;
-
   (void) f<zero,0>(0);
-  (void) t<zero>::u{};
-
-  cpp2::deferred_init<zero> z; 
-  init<zero>(cpp2::out(&z));
-  cpp2::Default.expects(&id<zero>(z.value())==&z.value(), "");
-
-  // Deducible parameters.
-  (void) v{0};
-  (void) []<typename T>(std::vector<T> const& x) -> void{}(std::vector<cpp2::i32>{});
-  (void) []<typename T>(std::vector<std::vector<T>> const& x) -> void{}(std::vector<std::vector<cpp2::i32>>{});
-  // Uncomment once `typename` is supported for template arguments.
-  // _ = :<T, U> (x: std::pair<T, typename U::value_type>, y: U) = {}(:std::pair = (0, 0), z);
-  init(cpp2::out(&z.value()), z.value());
-  id(z.value(), std::move(z.value()));
 
   // Nesting is irrelevant.
   (void) []<typename T>() -> void{(void) typename T::value_type{}; };
@@ -157,11 +114,3 @@ auto main() -> int{
   }(0);
 }
 
-#line 109 "pure2-bugfix-for-dependent-types-and-deducible-parameters.cpp2"
-  template <typename T> v<T>::v(T const& x){}
-#line 109 "pure2-bugfix-for-dependent-types-and-deducible-parameters.cpp2"
-  template <typename T> auto v<T>::operator=(T const& x) -> v& {
-                                  return *this;
-#line 109 "pure2-bugfix-for-dependent-types-and-deducible-parameters.cpp2"
-  }
-

regression-tests/test-results/gcc-13/pure2-bugfix-for-dependent-types.cpp.output

@@ -0,0 +1,2 @@
+pure2-bugfix-for-dependent-types.cpp2... ok (all Cpp2, passes safety checks)
+