Add support for fixed-width integer type aliases (i32, u64, etc.)

Note these are not reserved words, because that would conflict with existing code. Unqualified `i32` means `cpp2::i32`, but it's fine a program to have its own `i32` identifier and use it via namespace-qualification disambiguation.

The naming pattern is:
- `u` or `i` (unsigned or signed)
- `8`, `16`, `32`, or `64` (bit width... I'm open to adding more as they can be portably supported)
- (optional) `_fast` or `_small` (following `<cstdint>`'s `_fast` and `_least`)

Author: hsutter

include/cpp2util.h

@@ -207,6 +207,7 @@
     #include <cstddef>
     #include <utility>
     #include <cstdio>
+    #include <cstdint>
 
     #if defined(CPP2_USE_SOURCE_LOCATION)
         #include <source_location>
@@ -220,6 +221,43 @@
 
 namespace cpp2 {
 
+//-----------------------------------------------------------------------
+//
+//  Convenience names for fixed-width integer types
+//
+//  Note: De jure, some of these are optional per the C and C++ standards
+//        De facto, all of these are supported in all implementations I know of
+//
+//-----------------------------------------------------------------------
+//
+using i8        = std::int8_t        ;
+using i16       = std::int16_t       ;
+using i32       = std::int32_t       ;
+using i64       = std::int64_t       ;
+using u8        = std::uint8_t       ;
+using u16       = std::uint16_t      ;
+using u32       = std::uint32_t      ;
+using u64       = std::uint64_t      ;
+
+using i8_fast   = std::int_fast8_t   ;
+using i16_fast  = std::int_fast16_t  ;
+using i32_fast  = std::int_fast32_t  ;
+using i64_fast  = std::int_fast64_t  ;
+using u8_fast   = std::uint_fast8_t  ;
+using u16_fast  = std::uint_fast16_t ;
+using u32_fast  = std::uint_fast32_t ;
+using u64_fast  = std::uint_fast64_t ;
+
+using i8_small  = std::int_least8_t  ;
+using i16_small = std::int_least16_t ;
+using i32_small = std::int_least32_t ;
+using i64_small = std::int_least64_t ;
+using u8_small  = std::uint_least8_t ;
+using u16_small = std::uint_least16_t;
+using u32_small = std::uint_least32_t;
+using u64_small = std::uint_least64_t;
+
+
 //-----------------------------------------------------------------------
 //
 //  contract_group

regression-tests/mixed-fixed-type-aliases.cpp2

@@ -0,0 +1,21 @@
+#include <typeinfo>
+#include <iostream>
+
+namespace my {
+    using u16 = float;
+}
+
+test: (x:_) = {
+    std::cout
+        << std::boolalpha
+        << std::is_floating_point_v<CPP2_TYPEOF(x)>
+        << "\n";
+}
+
+main: (argc: int, argv: **char) -> int = {
+    y: my::u16 = 42;
+    test(y);
+
+    z: u16 = 42;
+    test(z);
+}

regression-tests/test-results/clang-12/mixed-fixed-type-aliases.cpp.execution

@@ -0,0 +1,2 @@
+true
+false

regression-tests/test-results/clang-12/mixed-fixed-type-aliases.cpp.output

@@ -0,0 +1,2 @@
+true
+false

regression-tests/test-results/gcc-10/mixed-fixed-type-aliases.cpp.execution

@@ -0,0 +1,34 @@
+// ----- Cpp2 support -----
+#include "cpp2util.h"
+
+#line 1 "mixed-fixed-type-aliases.cpp2"
+#include <typeinfo>
+#include <iostream>
+
+namespace my {
+    using u16 = float;
+}
+
+auto test(auto const& x) -> void;
+#line 15 "mixed-fixed-type-aliases.cpp2"
+[[nodiscard]] auto main(cpp2::in<int> argc, cpp2::in<char**> argv) -> int;
+
+//=== Cpp2 definitions ==========================================================
+
+#line 7 "mixed-fixed-type-aliases.cpp2"
+
+auto test(auto const& x) -> void{
+    std::cout 
+        << std::boolalpha 
+        << std::is_floating_point_v<CPP2_TYPEOF(x)> 
+        << "\n";
+}
+
+[[nodiscard]] auto main(cpp2::in<int> argc, cpp2::in<char**> argv) -> int{
+    my::u16 y { 42 }; 
+    test(std::move(y));
+
+    cpp2::u16 z { 42 }; 
+    test(std::move(z));
+}
+

regression-tests/test-results/gcc-10/mixed-fixed-type-aliases.cpp.output

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

regression-tests/test-results/mixed-fixed-type-aliases.cpp

@@ -0,0 +1,2 @@
+true
+false

regression-tests/test-results/mixed-fixed-type-aliases.cpp2.output

@@ -0,0 +1 @@
+mixed-fixed-type-aliases.cpp

regression-tests/test-results/msvc-2022/mixed-fixed-type-aliases.cpp.execution

@@ -1068,8 +1068,14 @@ class cppfront
 
     //-----------------------------------------------------------------------
     //
-    auto emit(token const& n) -> void
+    auto emit(token const& n, bool is_qualified = false) -> void
     {
+        //  Implicit "cpp2::" qualification of Cpp2 fixed-width type aliases
+        if (!is_qualified && n.type() == lexeme::Cpp2FixedType)
+        {
+            printer.print_cpp2("cpp2::", n.position());
+        }
+
         if (n == "new") {
             printer.print_cpp2("cpp2_new", n.position());
         }
@@ -1089,7 +1095,8 @@ class cppfront
     auto emit(
         unqualified_id_node const& n,
         bool in_synthesized_multi_return = false,
-        bool is_local_name = true
+        bool is_local_name = true,
+        bool is_qualified = false
     )
         -> void
     {
@@ -1118,7 +1125,7 @@ class cppfront
         }
 
         assert(n.identifier);
-        emit(*n.identifier);
+        emit(*n.identifier, is_qualified);  // inform the identifier if we know this is qualified
 
         if (!n.template_args.empty()) {
             printer.print_cpp2("<", n.open_angle);
@@ -1182,7 +1189,7 @@ class cppfront
             if (id.scope_op) {
                 emit(*id.scope_op);
             }
-            emit(*id.id);
+            emit(*id.id, false, true, true);    // inform the unqualified-id that it's qualified
         }
 
         printer.emit_to_string();
@@ -1194,8 +1201,8 @@ class cppfront
     //
     auto emit(type_id_node const& n) -> void
     {
-        try_emit<type_id_node::qualified  >(n.id);
         try_emit<type_id_node::unqualified>(n.id, false, false);
+        try_emit<type_id_node::qualified  >(n.id);
         try_emit<type_id_node::keyword    >(n.id);
 
         for (auto i = n.pc_qualifiers.rbegin(); i != n.pc_qualifiers.rend(); ++i) {

regression-tests/test-results/msvc-2022/mixed-fixed-type-aliases.cpp.output

@@ -95,6 +95,7 @@ enum class lexeme : std::int8_t {
     CharacterLiteral,
     Keyword,
     Cpp1MultiKeyword,
+    Cpp2FixedType,
     Identifier
 };
 
@@ -178,6 +179,7 @@ auto as(lexeme l)
     break;case lexeme::CharacterLiteral:    return "CharacterLiteral";
     break;case lexeme::Keyword:             return "Keyword";
     break;case lexeme::Cpp1MultiKeyword:    return "Cpp1MultiKeyword";
+    break;case lexeme::Cpp2FixedType:       return "Cpp2FixedType";
     break;case lexeme::Identifier:          return "Identifier";
     break;default:                          return "INTERNAL-ERROR";
     }
@@ -480,6 +482,17 @@ auto lex_line(
         return do_is_keyword(keys);
     };
 
+    auto peek_is_cpp2_fundamental_type_keyword = [&]()
+    {
+        const auto keys = std::regex(
+            "^i8_fast|^i16_fast|^i32_fast|^i64_fast|^u8_fast|^u16_fast|^u32_fast|^u64_fast|"
+            "^i8_least|^i16_least|^i32_least|^i64_least|^u8_least|^u16_least|^u32_least|^u64_least|"
+            "^i8|^i16|^i32|^i64|^u8|^u16|^u32|^u64"
+        );
+
+        return do_is_keyword(keys);
+    };
+
     auto peek_is_cpp1_multi_token_fundamental_keyword = [&]()
     {
         const auto multi_keys = std::regex(
@@ -889,12 +902,18 @@ auto lex_line(
                     }
                 }
 
-                //  Cpp2 multi-token fundamental type keyword
+                //  Cpp1 multi-token fundamental type keyword
                 //
                 else if (auto j = peek_is_cpp1_multi_token_fundamental_keyword()) {
                     store(j, lexeme::Cpp1MultiKeyword);
                 }
 
+                //  Cpp2 fixed-width type alias keyword
+                //
+                else if (auto j = peek_is_cpp2_fundamental_type_keyword()) {
+                    store(j, lexeme::Cpp2FixedType);
+                }
+
                 //  Other keyword
                 //
                 else if (auto j = peek_is_keyword()) {

source/cppfront.cpp

@@ -2075,7 +2075,7 @@ class parser
             assert (n->id.index() == type_id_node::unqualified);
             return n;
         }
-        if (curr().type() == lexeme::Keyword) {
+        if (curr().type() == lexeme::Keyword || curr().type() == lexeme::Cpp2FixedType) {
             n->pos = curr().position();
             n->id  = &curr();
             next();
@@ -2178,12 +2178,17 @@ class parser
     //G template-argument:
     //G     # note: < > << >> are not allowed in expressions until new ( is opened
     //G     expression
-    //G     id-expression
+    //G     type-id
     //G
     auto unqualified_id() -> std::unique_ptr<unqualified_id_node>
     {
         //  Handle the identifier
-        if (curr().type() != lexeme::Identifier) {
+        if (
+            curr().type() != lexeme::Identifier &&
+            curr().type() != lexeme::Keyword    &&
+            curr().type() != lexeme::Cpp2FixedType
+            )
+        {
             return {};
         }