Add alias pretty-print visualization

Author: hsutter

regression-tests/pure2-print.cpp2

@@ -3,6 +3,8 @@
 
 outer: @print type = {
 
+    object_alias: <T> T requires true == 42;
+
     mytype: final type =
     {
         protected f: () -> int = 42;
@@ -62,14 +64,21 @@ outer: @print type = {
     }
 
     test: () = {
+        namespace_alias: namespace == ::std;
+
+        type_alias: type == std::array<int,10>;
+
+        object_alias_1: i8 == 42;
+        object_alias_2: == 42;
+
+
         var: ::outer::mytype = ();
         std::cout << var.g(42) << "\n";
 
-        std::cout << inspect var.g(42) -> std::string {
+        std::cout << inspect var.g(42) -> namespace_alias::string {
             is 43 = "forty-and-three";
             is _  = "default case";
         } << "\n";
-
     }
 
     x: <Ts...: type> type = {

regression-tests/test-results/pure2-print.cpp

@@ -19,24 +19,29 @@ class outer;
 #line 4 "pure2-print.cpp2"
 class outer {
 
+    public: template<typename T> 
+CPP2_REQUIRES_ (true)
+#line 6 "pure2-print.cpp2"
+    T static constexpr object_alias = 42;
+
     public: class mytype final
      {
         protected: [[nodiscard]] static auto f() -> int;
 
         public: [[nodiscard]] virtual auto g(cpp2::in<int> i) const& -> int;
 
 
-#line 27 "pure2-print.cpp2"
+#line 29 "pure2-print.cpp2"
         private: [[nodiscard]] static auto h(cpp2::in<std::string> s, std::map<int const,std::string>& m) -> std::string;
             struct values__ret { int offset; std::string name; };
 
 
 
-#line 50 "pure2-print.cpp2"
+#line 52 "pure2-print.cpp2"
         public: template<typename T> [[nodiscard]] auto values(T const& t) const& -> values__ret;
 
 
-#line 55 "pure2-print.cpp2"
+#line 57 "pure2-print.cpp2"
         public: explicit mytype();
 
         public: mytype([[maybe_unused]] mytype const& that);
@@ -49,31 +54,31 @@ class outer {
     public: static auto test() -> void;
 
 
-#line 75 "pure2-print.cpp2"
+#line 84 "pure2-print.cpp2"
     public: template<typename ...Ts> class x {
         private: std::tuple<Ts...> tup {}; 
         public: x() = default;
         public: x(x const&) = delete; /* No 'that' constructor, suppress copy */
         public: auto operator=(x const&) -> void = delete;
 
-#line 77 "pure2-print.cpp2"
+#line 86 "pure2-print.cpp2"
     };
 
     public: template<typename ...Args> static auto print(std::ostream& out, Args const& ...args) -> void
 CPP2_REQUIRES_ (cpp2::cmp_greater_eq(sizeof(Args)...,0))
-#line 79 "pure2-print.cpp2"
+#line 88 "pure2-print.cpp2"
     ;
 
 
-#line 83 "pure2-print.cpp2"
+#line 92 "pure2-print.cpp2"
     public: template<typename ...Args> [[nodiscard]] static auto all(Args const& ...args) -> bool;
 
     public: outer() = default;
     public: outer(outer const&) = delete; /* No 'that' constructor, suppress copy */
     public: auto operator=(outer const&) -> void = delete;
 
 
-#line 86 "pure2-print.cpp2"
+#line 95 "pure2-print.cpp2"
 };
 
 auto main() -> int;
@@ -82,7 +87,7 @@ auto main() -> int;
 //=== Cpp2 function definitions =================================================
 
 
-#line 8 "pure2-print.cpp2"
+#line 10 "pure2-print.cpp2"
         [[nodiscard]] auto outer::mytype::f() -> int { return 42;  }
 
         [[nodiscard]] auto outer::mytype::g(cpp2::in<int> i) const& -> int{
@@ -104,11 +109,11 @@ auto main() -> int;
 
         [[nodiscard]] auto outer::mytype::h(cpp2::in<std::string> s, std::map<int const,std::string>& m) -> std::string
 
-#line 30 "pure2-print.cpp2"
+#line 32 "pure2-print.cpp2"
         {
             cpp2::Default.expects(CPP2_UFCS_0(empty, m) == false || false, "");
             cpp2::Bounds.expects([_0 = 0, _1 = CPP2_UFCS_0(ssize, m), _2 = 100]{ return cpp2::cmp_less(_0,_1) && cpp2::cmp_less(_1,_2); }() && true != false, "");
-#line 31 "pure2-print.cpp2"
+#line 33 "pure2-print.cpp2"
             auto a {[]() -> void{}}; 
             auto b {[]() -> void{}}; 
             auto c {[]() -> void{}}; 
@@ -118,10 +123,10 @@ auto main() -> int;
             do {} while ( CPP2_UFCS_0(empty, s) && [&]{ b() ; return true; }() );
 
             for ( [[maybe_unused]] auto const& param1 : m ) {
-#line 39 "pure2-print.cpp2"
-             { do {goto CONTINUE_39_13; } while (false); c(); } CPP2_CONTINUE_BREAK(39_13) }
-
 #line 41 "pure2-print.cpp2"
+             { do {goto CONTINUE_41_13; } while (false); c(); } CPP2_CONTINUE_BREAK(41_13) }
+
+#line 43 "pure2-print.cpp2"
             if (cpp2::is(!(CPP2_UFCS_0(empty, s)), (true))) {std::move(a)(); }
             else {if (!(CPP2_UFCS_0(empty, m))) {std::move(b)(); }
             else {std::move(c)(); }}
@@ -134,7 +139,7 @@ auto main() -> int;
         template<typename T> [[nodiscard]] auto outer::mytype::values(T const& t) const& -> values__ret{
                 cpp2::deferred_init<int> offset;
                 cpp2::deferred_init<std::string> name;
-#line 51 "pure2-print.cpp2"
+#line 53 "pure2-print.cpp2"
             offset.construct(53);
             name.construct("plugh");
         return  { std::move(offset.value()), std::move(name.value()) }; }
@@ -147,30 +152,37 @@ auto main() -> int;
 
         auto outer::mytype::variadic(auto const& ...x) -> void{}
 
-#line 64 "pure2-print.cpp2"
+#line 66 "pure2-print.cpp2"
     auto outer::test() -> void{
+        namespace namespace_alias = ::std;
+
+        using type_alias = std::array<int,10>;
+
+        cpp2::i8 const& object_alias_1 = 42;
+        auto const& object_alias_2 = 42;
+
+#line 75 "pure2-print.cpp2"
         ::outer::mytype var {}; 
         std::cout << CPP2_UFCS(g, var, 42) << "\n";
 
-        std::cout << [&] () -> std::string { auto&& __expr = CPP2_UFCS(g, std::move(var), 42);
-            if (cpp2::is(__expr, 43)) { if constexpr( requires{"forty-and-three";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("forty-and-three")),std::string> ) return "forty-and-three"; else return std::string{}; else return std::string{}; }
+        std::cout << [&] () -> namespace_alias::string { auto&& __expr = CPP2_UFCS(g, std::move(var), 42);
+            if (cpp2::is(__expr, 43)) { if constexpr( requires{"forty-and-three";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF(("forty-and-three")),namespace_alias::string> ) return "forty-and-three"; else return namespace_alias::string{}; else return namespace_alias::string{}; }
             else return "default case"; }
         () << "\n";
-
     }
 
-#line 79 "pure2-print.cpp2"
+#line 88 "pure2-print.cpp2"
     template<typename ...Args> auto outer::print(std::ostream& out, Args const& ...args) -> void
 requires (cpp2::cmp_greater_eq(sizeof(Args)...,0))
-#line 79 "pure2-print.cpp2"
+#line 88 "pure2-print.cpp2"
     {
         (out << ... << args);
     }
 
     template<typename ...Args> [[nodiscard]] auto outer::all(Args const& ...args) -> bool { 
         return (... && args);  }
 
-#line 88 "pure2-print.cpp2"
+#line 97 "pure2-print.cpp2"
 auto main() -> int{
     outer::test();
 }

regression-tests/test-results/pure2-print.cpp2.output

@@ -2,6 +2,7 @@ pure2-print.cpp2...
 
 outer: type = 
 {
+    object_alias: <T: type > T requires (true) == 42;
     mytype: final type = 
     {
         protected f:() -> move int = 42;
@@ -115,9 +116,13 @@ outer: type =
 
     test:() = 
     {
+        namespace_alias: namespace == ::std;
+        type_alias: type == std::array<int, 10>;
+        object_alias_1: i8 == 42;
+        object_alias_2: == 42;
         var: ::outer::mytype = ();
         std::cout << var.g(42) << "\n";
-        std::cout << inspect var.g(42) -> std::string {
+        std::cout << inspect var.g(42) -> namespace_alias::string {
             is 43 = "forty-and-three";
             is _ = "default case";
         } << "\n";

source/parse.h

@@ -4604,33 +4604,31 @@ auto pretty_print_visualize(declaration_node const& n, int indent, bool include_
 
         auto object_type_id = std::string{};
         if (a->type_id) {
-            object_type_id += pretty_print_visualize(*a->type_id, indent) + " ";
+            object_type_id += " " + pretty_print_visualize(*a->type_id, indent);
         }
 
         ret += template_params;
         if (a->is_type_alias()) {
             auto& t = std::get<alias_node::a_type>(a->initializer);
-            ret += template_params
-                + "type"
+            ret += " type"
                 + requires_clause
-                + "== "
+                + " == "
                 + pretty_print_visualize(*t, indent)
                 + ";";
         }
         else if (a->is_namespace_alias()) {
             auto& id = std::get<alias_node::a_namespace>(a->initializer);
             assert(id);
-            ret += "== "
+            ret += " namespace == "
                 + pretty_print_visualize(*id, indent)
                 + ";";
         }
         else if (a->is_object_alias()) {
             auto& expr = std::get<alias_node::an_object>(a->initializer);
             assert(expr);
-            ret += template_params
-                + object_type_id
+            ret += object_type_id
                 + requires_clause
-                + "== "
+                + " == "
                 + pretty_print_visualize(*expr, indent)
                 + ";";
         }