Add basic support for inheritance

A base type subobject is declared the same as any member object, but with the name `this`. See test case example in this commit, pasted below for convenience

Note that `:` continues to be pronounces "is a"... e.g., `f: () -> int` is pronounced as "f is a function returning int," `v: vector<int>` as "v is a vector<int>", `this: Shape` as "this object is a Shape."

This is consistent because in Cpp2 I'm pursuing the experiment of making inheritance be always `public` and therefore inheritance should always model IS-A substitutability.
- Why not protected inheritance? Because the only theoretical use of that I know of is to enable IS-A substitutability only for code within the same class hierarchy, and I know of no actual use of that feature.
- Why not private inheritance? Because it is anti-recommended, nearly always that should be a private data member instead, and the main reason to use a private base is to make that data member outlive a base class object... which is already covered in Cpp2 because all subobjects (bases and members) can be declared in any order. In this initial checkin, if there are any non-base subobjects (ordinary data members) that are declared before base subobjects (base classes), as an implementation detail those non-bases are emitted as private base classes via a helper wrapper that prevents their interface (functions) from leaking into the type.

If a type has base classes, I don't generate assignment from construction. This is because polymorphic types usually don't want (nonvirtual) assignment, and so base classes generally don't provide assignment so a generated memberwise assignment wouldn't work anyway. However, as of this commit, I don't currently ban a user explicitly writing their own assignment operator if they want to, which will be fine as long as `Base::operator=` memberwise calls are available.

Abstract virtual functions are simply virtual functions that have no initializer. (All other functions in Cpp2 must have an initializer.)

Also corrected the namespace alias representation to use id-expression

### Test case (pasted for convenience)

```
Human: type = {
    operator=: (out this) = {}
    speak:     (virtual this);
}

N: namespace = {
    Machine: type = {
        operator=: (out this, id: std::string) = {}
        work:      (virtual this);
    }
}

Cyborg: type = {
    name: std::string;
    this: Human = ();
    this: N::Machine;

    operator=: (out this, n: std::string) = {
        name = n;
        N::Machine = "Acme Corp. engineer tech";
        std::cout << "(name)$ checks in for the day's shift\n";
    }

    speak: (override this) =
        std::cout << "(name)$ cracks a few jokes with a coworker\n";

    work: (override this) =
        std::cout << "(name)$ carries some half-tonne crates of Fe2O3 to cold storage\n";

    operator=: (move this) =
        std::cout << "Tired but satisfied after another successful day, (name)$ checks out and goes home to their family\n";
}

make_speak: ( h: Human ) = {
    std::cout << "-> [vcall: make_speak] ";
    h.speak();
}

do_work: ( m: N::Machine ) = {
    std::cout << "-> [vcall: do_work] ";
    m.work();
}

main: () = {
    c: Cyborg = "Parsnip";
    c.make_speak();
    c.do_work();
}
```

Output:

```
Parsnip checks in for the day's shift
-> [vcall: make_speak] Parsnip cracks a few jokes with a coworker
-> [vcall: do_work] Parsnip carries some half-tonne crates of Fe2O3 to cold storage
Tired but satisfied after another successful day, Parsnip checks out and goes home to their family
```

Author: hsutter

include/cpp2util.h

@@ -363,7 +363,7 @@ auto assert_not_null(auto&& p CPP2_SOURCE_LOCATION_PARAM_WITH_DEFAULT) -> declty
     //        doesn't guarantee that using == and != will reliably report whether an
     //        STL iterator has the default-constructed value
     Null.expects(p != CPP2_TYPEOF(p){}, "dynamic null dereference attempt detected" CPP2_SOURCE_LOCATION_ARG);
-    return std::forward<decltype(p)>(p);
+    return CPP2_FORWARD(p);
 }
 
 //  Subscript bounds checking
@@ -373,14 +373,14 @@ auto assert_in_bounds(auto&& x, auto&& arg CPP2_SOURCE_LOCATION_PARAM_WITH_DEFAU
              requires { std::ssize(x); x[arg]; })
 {
     Bounds.expects(0 <= arg && arg < std::ssize(x), "out of bounds access attempt detected" CPP2_SOURCE_LOCATION_ARG);
-    return std::forward<decltype(x)>(x) [ std::forward<decltype(arg)>(arg) ];
+    return CPP2_FORWARD(x) [ CPP2_FORWARD(arg) ];
 }
 
 auto assert_in_bounds(auto&& x, auto&& arg CPP2_SOURCE_LOCATION_PARAM_WITH_DEFAULT) -> decltype(auto)
     requires (!(std::is_integral_v<CPP2_TYPEOF(arg)> &&
              requires { std::ssize(x); x[arg]; }))
 {
-    return std::forward<decltype(x)>(x) [ std::forward<decltype(arg)>(arg) ];
+    return CPP2_FORWARD(x) [ CPP2_FORWARD(arg) ];
 }
 
 
@@ -468,20 +468,20 @@ auto Typeid() -> decltype(auto) {
 struct {
     template<typename T>
     [[nodiscard]] auto cpp2_new(auto&& ...args) const -> std::unique_ptr<T> {
-        return std::make_unique<T>(std::forward<decltype(args)>(args)...);
+        return std::make_unique<T>(CPP2_FORWARD(args)...);
     }
 } unique;
 
 [[maybe_unused]] struct {
     template<typename T>
     [[nodiscard]] auto cpp2_new(auto&& ...args) const -> std::shared_ptr<T> {
-        return std::make_shared<T>(std::forward<decltype(args)>(args)...);
+        return std::make_shared<T>(CPP2_FORWARD(args)...);
     }
 } shared;
 
 template<typename T>
 [[nodiscard]] auto cpp2_new(auto&& ...args) -> std::unique_ptr<T> {
-    return unique.cpp2_new<T>(std::forward<decltype(args)>(args)...);
+    return unique.cpp2_new<T>(CPP2_FORWARD(args)...);
 }
 
 
@@ -504,10 +504,12 @@ using in =
 //
 //  Initialization: These are closely related...
 //
-//  deferred_init<T>    For deferred-initialized local or member variable
+//  deferred_init<T>    For deferred-initialized local object
 //
 //  out<T>              For out parameter
 //
+//  store_as_base<T>    For member object declared before a base object
+//
 //-----------------------------------------------------------------------
 //
 template<typename T>
@@ -527,10 +529,11 @@ class deferred_init {
    ~deferred_init() noexcept       { destroy(); }
     auto value()    noexcept -> T& { Default.expects(init);  return t(); }
 
-    auto construct     (auto&& ...args) -> void { Default.expects(!init);  new (&data) T(std::forward<decltype(args)>(args)...);  init = true; }
-    auto construct_list(auto&& ...args) -> void { Default.expects(!init);  new (&data) T{std::forward<decltype(args)>(args)...};  init = true; }
+    auto construct     (auto&& ...args) -> void { Default.expects(!init);  new (&data) T(CPP2_FORWARD(args)...);  init = true; }
+    auto construct_list(auto&& ...args) -> void { Default.expects(!init);  new (&data) T{CPP2_FORWARD(args)...};  init = true; }
 };
 
+
 template<typename T>
 class out {
     //  Not going to bother with std::variant here
@@ -572,15 +575,15 @@ class out {
     auto construct(auto&& ...args) -> void {
         if (has_t || called_construct()) {
             Default.expects( t );
-            *t = T(std::forward<decltype(args)>(args)...);
+            *t = T(CPP2_FORWARD(args)...);
         }
         else {
             Default.expects( dt );
             if (dt->init) {
-                dt->value() = T(std::forward<decltype(args)>(args)...);
+                dt->value() = T(CPP2_FORWARD(args)...);
             }
             else {
-                dt->construct(std::forward<decltype(args)>(args)...);
+                dt->construct(CPP2_FORWARD(args)...);
                 called_construct() = true;
             }
         }
@@ -589,15 +592,15 @@ class out {
     auto construct_list(auto&& ...args) -> void {
         if (has_t || called_construct()) {
             Default.expects( t );
-            *t = T{std::forward<decltype(args)>(args)...};
+            *t = T{CPP2_FORWARD(args)...};
         }
         else {
             Default.expects( dt );
             if (dt->init) {
-                dt->value() = T{std::forward<decltype(args)>(args)...};
+                dt->value() = T{CPP2_FORWARD(args)...};
             }
             else {
-                dt->construct_list(std::forward<decltype(args)>(args)...);
+                dt->construct_list(CPP2_FORWARD(args)...);
                 called_construct() = true;
             }
         }
@@ -616,6 +619,18 @@ class out {
 };
 
 
+template<typename T>
+struct store_as_base : private T
+{
+    store_as_base( T const& t    ) : T{t}                  { }
+    store_as_base( T     && t    ) : T{std::move(t)}       { }
+    store_as_base( auto  && args ) : T{CPP2_FORWARD(args)} { }
+
+    auto value__()       -> T      & { return *this; }
+    auto value__() const -> T const& { return *this; }
+};
+
+
 //-----------------------------------------------------------------------
 //
 //  CPP2_UFCS: Variadic macro generating a variadic lamba, oh my...
@@ -635,39 +650,39 @@ class out {
 
 #define CPP2_UFCS(FUNCNAME,PARAM1,...) \
 [&](auto&& obj, auto&& ...params) CPP2_FORCE_INLINE_LAMBDA -> decltype(auto) { \
-    if constexpr (requires{ std::forward<decltype(obj)>(obj).FUNCNAME(std::forward<decltype(params)>(params)...); }) { \
-        return std::forward<decltype(obj)>(obj).FUNCNAME(std::forward<decltype(params)>(params)...); \
+    if constexpr (requires{ CPP2_FORWARD(obj).FUNCNAME(CPP2_FORWARD(params)...); }) { \
+        return CPP2_FORWARD(obj).FUNCNAME(CPP2_FORWARD(params)...); \
     } else { \
-        return FUNCNAME(std::forward<decltype(obj)>(obj), std::forward<decltype(params)>(params)...); \
+        return FUNCNAME(CPP2_FORWARD(obj), CPP2_FORWARD(params)...); \
     } \
 }(PARAM1, __VA_ARGS__)
 
 #define CPP2_UFCS_0(FUNCNAME,PARAM1) \
 [&](auto&& obj) CPP2_FORCE_INLINE_LAMBDA -> decltype(auto) { \
-    if constexpr (requires{ std::forward<decltype(obj)>(obj).FUNCNAME(); }) { \
-        return std::forward<decltype(obj)>(obj).FUNCNAME(); \
+    if constexpr (requires{ CPP2_FORWARD(obj).FUNCNAME(); }) { \
+        return CPP2_FORWARD(obj).FUNCNAME(); \
     } else { \
-        return FUNCNAME(std::forward<decltype(obj)>(obj)); \
+        return FUNCNAME(CPP2_FORWARD(obj)); \
     } \
 }(PARAM1)
 
 #define CPP2_UFCS_REMPARENS(...) __VA_ARGS__
 
 #define CPP2_UFCS_TEMPLATE(FUNCNAME,TEMPARGS,PARAM1,...) \
 [&](auto&& obj, auto&& ...params) CPP2_FORCE_INLINE_LAMBDA -> decltype(auto) { \
-    if constexpr (requires{ std::forward<decltype(obj)>(obj).template FUNCNAME CPP2_UFCS_REMPARENS TEMPARGS (std::forward<decltype(params)>(params)...); }) { \
-        return std::forward<decltype(obj)>(obj).template FUNCNAME CPP2_UFCS_REMPARENS TEMPARGS (std::forward<decltype(params)>(params)...); \
+    if constexpr (requires{ CPP2_FORWARD(obj).template FUNCNAME CPP2_UFCS_REMPARENS TEMPARGS (CPP2_FORWARD(params)...); }) { \
+        return CPP2_FORWARD(obj).template FUNCNAME CPP2_UFCS_REMPARENS TEMPARGS (CPP2_FORWARD(params)...); \
     } else { \
-        return FUNCNAME CPP2_UFCS_REMPARENS TEMPARGS (std::forward<decltype(obj)>(obj), std::forward<decltype(params)>(params)...); \
+        return FUNCNAME CPP2_UFCS_REMPARENS TEMPARGS (CPP2_FORWARD(obj), CPP2_FORWARD(params)...); \
     } \
 }(PARAM1, __VA_ARGS__)
 
 #define CPP2_UFCS_TEMPLATE_0(FUNCNAME,TEMPARGS,PARAM1) \
 [&](auto&& obj) CPP2_FORCE_INLINE_LAMBDA -> decltype(auto) { \
-    if constexpr (requires{ std::forward<decltype(obj)>(obj).template FUNCNAME CPP2_UFCS_REMPARENS TEMPARGS (); }) { \
-        return std::forward<decltype(obj)>(obj).template FUNCNAME CPP2_UFCS_REMPARENS TEMPARGS (); \
+    if constexpr (requires{ CPP2_FORWARD(obj).template FUNCNAME CPP2_UFCS_REMPARENS TEMPARGS (); }) { \
+        return CPP2_FORWARD(obj).template FUNCNAME CPP2_UFCS_REMPARENS TEMPARGS (); \
     } else { \
-        return FUNCNAME CPP2_UFCS_REMPARENS TEMPARGS (std::forward<decltype(obj)>(obj)); \
+        return FUNCNAME CPP2_UFCS_REMPARENS TEMPARGS (CPP2_FORWARD(obj)); \
     } \
 }(PARAM1)
 
@@ -676,37 +691,37 @@ class out {
 
 #define CPP2_UFCS_NONLOCAL(FUNCNAME,PARAM1,...) \
 [](auto&& obj, auto&& ...params) CPP2_FORCE_INLINE_LAMBDA -> decltype(auto) { \
-    if constexpr (requires{ std::forward<decltype(obj)>(obj).FUNCNAME(std::forward<decltype(params)>(params)...); }) { \
-        return std::forward<decltype(obj)>(obj).FUNCNAME(std::forward<decltype(params)>(params)...); \
+    if constexpr (requires{ CPP2_FORWARD(obj).FUNCNAME(CPP2_FORWARD(params)...); }) { \
+        return CPP2_FORWARD(obj).FUNCNAME(CPP2_FORWARD(params)...); \
     } else { \
-        return FUNCNAME(std::forward<decltype(obj)>(obj), std::forward<decltype(params)>(params)...); \
+        return FUNCNAME(CPP2_FORWARD(obj), CPP2_FORWARD(params)...); \
     } \
 }(PARAM1, __VA_ARGS__)
 
 #define CPP2_UFCS_0_NONLOCAL(FUNCNAME,PARAM1) \
 [](auto&& obj) CPP2_FORCE_INLINE_LAMBDA -> decltype(auto) { \
-    if constexpr (requires{ std::forward<decltype(obj)>(obj).FUNCNAME(); }) { \
-        return std::forward<decltype(obj)>(obj).FUNCNAME(); \
+    if constexpr (requires{ CPP2_FORWARD(obj).FUNCNAME(); }) { \
+        return CPP2_FORWARD(obj).FUNCNAME(); \
     } else { \
-        return FUNCNAME(std::forward<decltype(obj)>(obj)); \
+        return FUNCNAME(CPP2_FORWARD(obj)); \
     } \
 }(PARAM1)
 
 #define CPP2_UFCS_TEMPLATE_NONLOCAL(FUNCNAME,TEMPARGS,PARAM1,...) \
 [](auto&& obj, auto&& ...params) CPP2_FORCE_INLINE_LAMBDA -> decltype(auto) { \
-    if constexpr (requires{ std::forward<decltype(obj)>(obj).template FUNCNAME CPP2_UFCS_REMPARENS TEMPARGS (std::forward<decltype(params)>(params)...); }) { \
-        return std::forward<decltype(obj)>(obj).template FUNCNAME CPP2_UFCS_REMPARENS TEMPARGS (std::forward<decltype(params)>(params)...); \
+    if constexpr (requires{ CPP2_FORWARD(obj).template FUNCNAME CPP2_UFCS_REMPARENS TEMPARGS (CPP2_FORWARD(params)...); }) { \
+        return CPP2_FORWARD(obj).template FUNCNAME CPP2_UFCS_REMPARENS TEMPARGS (CPP2_FORWARD(params)...); \
     } else { \
-        return FUNCNAME CPP2_UFCS_REMPARENS TEMPARGS (std::forward<decltype(obj)>(obj), std::forward<decltype(params)>(params)...); \
+        return FUNCNAME CPP2_UFCS_REMPARENS TEMPARGS (CPP2_FORWARD(obj), CPP2_FORWARD(params)...); \
     } \
 }(PARAM1, __VA_ARGS__)
 
 #define CPP2_UFCS_TEMPLATE_0_NONLOCAL(FUNCNAME,TEMPARGS,PARAM1) \
 [](auto&& obj) CPP2_FORCE_INLINE_LAMBDA -> decltype(auto) { \
-    if constexpr (requires{ std::forward<decltype(obj)>(obj).template FUNCNAME CPP2_UFCS_REMPARENS TEMPARGS (); }) { \
-        return std::forward<decltype(obj)>(obj).template FUNCNAME CPP2_UFCS_REMPARENS TEMPARGS (); \
+    if constexpr (requires{ CPP2_FORWARD(obj).template FUNCNAME CPP2_UFCS_REMPARENS TEMPARGS (); }) { \
+        return CPP2_FORWARD(obj).template FUNCNAME CPP2_UFCS_REMPARENS TEMPARGS (); \
     } else { \
-        return FUNCNAME CPP2_UFCS_REMPARENS TEMPARGS (std::forward<decltype(obj)>(obj)); \
+        return FUNCNAME CPP2_UFCS_REMPARENS TEMPARGS (CPP2_FORWARD(obj)); \
     } \
 }(PARAM1)
 
@@ -937,7 +952,7 @@ auto as( X const& x ) -> auto
 template< typename C, typename X >
     requires std::is_base_of_v<C, X>
 auto as( X&& x ) -> C&& {
-    return std::forward<X>(x);
+    return CPP2_FORWARD(x);
 }
 
 template< typename C, typename X >
@@ -1315,10 +1330,9 @@ class final_action_success
     bool invoke = true;
 };
 
-template <class F>
-[[nodiscard]] auto finally_success(F&& f) noexcept
+[[nodiscard]] auto finally_success(auto&& f) noexcept
 {
-    return final_action_success<std::remove_cvref_t<F>>{std::forward<F>(f)};
+    return final_action_success<CPP2_TYPEOF(f)>{CPP2_FORWARD(f)};
 }
 
 
@@ -1348,10 +1362,9 @@ class final_action
     bool invoke = true;
 };
 
-template <class F>
-[[nodiscard]] auto finally(F&& f) noexcept
+[[nodiscard]] auto finally(auto&& f) noexcept
 {
-    return final_action<std::remove_cvref_t<F>>{std::forward<F>(f)};
+    return final_action<CPP2_TYPEOF(f)>{CPP2_FORWARD(f)};
 }
 
 

regression-tests/pure2-types-basics.cpp2

@@ -39,7 +39,7 @@ myclass : type = {
         std::cout << "myclass: destructor\n";
     }
 
-    f: (virtual this, x: int) = {
+    f: (this, x: int) = {
         std::cout << "N::myclass::f with (x)$\n";
     }
 

regression-tests/pure2-types-inheritance.cpp2

@@ -0,0 +1,49 @@
+
+Human: type = {
+    operator=: (out this) = {}
+    speak:     (virtual this);
+}
+
+N: namespace = {
+    Machine: type = {
+        operator=: (out this, id: std::string) = {}
+        work:      (virtual this);
+    }
+}
+
+Cyborg: type = {
+    name: std::string;
+    this: Human = ();
+    this: N::Machine;
+
+    operator=: (out this, n: std::string) = {
+        name = n;
+        N::Machine = "Acme Corp. engineer tech";
+        std::cout << "(name)$ checks in for the day's shift\n";
+    }
+
+    speak: (override this) =
+        std::cout << "(name)$ cracks a few jokes with a coworker\n";
+
+    work: (override this) =
+        std::cout << "(name)$ carries some half-tonne crates of Fe2O3 to cold storage\n";
+
+    operator=: (move this) =
+        std::cout << "Tired but satisfied after another successful day, (name)$ checks out and goes home to their family\n";
+}
+
+make_speak: ( h: Human ) = {
+    std::cout << "-> [vcall: make_speak] ";
+    h.speak();
+}
+
+do_work: ( m: N::Machine ) = {
+    std::cout << "-> [vcall: do_work] ";
+    m.work();
+}
+
+main: () = {
+    c: Cyborg = "Parsnip";
+    c.make_speak();
+    c.do_work();
+}

regression-tests/pure2-types-order-independence-and-nesting.cpp2

@@ -34,7 +34,7 @@ X: type = {
     //  X::exx member function description here
     exx: (this, count: int) = {
         //  Exercise '_' anonymous objects too while we're at it
-        _ := cpp2::finally( :()= std::cout << "leaving call to 'why((count)$)'\n"; );
+        _ := finally( :()= std::cout << "leaving call to 'why((count)$)'\n"; );
         if count < 5 {
             py*.why( count+1 );     // use Y object from X
         }

regression-tests/test-results/clang-12/pure2-types-inheritance.cpp.execution

@@ -0,0 +1,4 @@
+Parsnip checks in for the day's shift
+-> [vcall: make_speak] Parsnip cracks a few jokes with a coworker
+-> [vcall: do_work] Parsnip carries some half-tonne crates of Fe2O3 to cold storage
+Tired but satisfied after another successful day, Parsnip checks out and goes home to their family

regression-tests/test-results/clang-12/pure2-types-inheritance.cpp.output

@@ -0,0 +1,4 @@
+Parsnip checks in for the day's shift
+-> [vcall: make_speak] Parsnip cracks a few jokes with a coworker
+-> [vcall: do_work] Parsnip carries some half-tonne crates of Fe2O3 to cold storage
+Tired but satisfied after another successful day, Parsnip checks out and goes home to their family

regression-tests/test-results/gcc-10/pure2-types-inheritance.cpp.execution

@@ -0,0 +1,4 @@
+Parsnip checks in for the day's shift
+-> [vcall: make_speak] Parsnip cracks a few jokes with a coworker
+-> [vcall: do_work] Parsnip carries some half-tonne crates of Fe2O3 to cold storage
+Tired but satisfied after another successful day, Parsnip checks out and goes home to their family

regression-tests/test-results/gcc-10/pure2-types-inheritance.cpp.output

@@ -0,0 +1 @@
+pure2-types-inheritance.cpp

regression-tests/test-results/msvc-2022/pure2-types-inheritance.cpp.execution

@@ -45,7 +45,7 @@ class myclass {
     public: ~myclass();
 
 #line 42 "pure2-types-basics.cpp2"
-    public: virtual auto f(cpp2::in<int> x) const -> void;
+    public: auto f(cpp2::in<int> x) const -> void;
 
 #line 46 "pure2-types-basics.cpp2"
     private: int data {42 * 12};