Provide aliases instead of Cpp1 multi-word keywords, and require them

For example, `ushort` instead of `unsigned short int`
With a good diagnostic that encourages using fixed-width types instead
Sample diagnostic:

```
test.cpp2(7,8): error: 'signed char' - did you mean 'i8' (usually best) or '__schar'?
test.cpp2(7,8): error: 'signed char' is an old-style C/C++ multi-word keyword type
    - most such types should be used only for interoperability with older code
    - using those when you need them is fine, but name them with these short names instead:
        ushort, uint, ulong, longlong, ulonglong, __schar, __uchar
    - see also cpp2util.h > "Convenience names for integer types"```

Author: hsutter

include/cpp2util.h

@@ -223,13 +223,15 @@ namespace cpp2 {
 
 //-----------------------------------------------------------------------
 //
-//  Convenience names for fixed-width integer types
+//  Convenience names for fundamental 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
 //
 //-----------------------------------------------------------------------
 //
+
+//  Encouraged by default: Fixed-precision names
 using i8        = std::int8_t        ;
 using i16       = std::int16_t       ;
 using i32       = std::int32_t       ;
@@ -239,6 +241,7 @@ using u16       = std::uint16_t      ;
 using u32       = std::uint32_t      ;
 using u64       = std::uint64_t      ;
 
+//  Rarely, when really needed for speed optimization: Fastest type with at least N bits
 using i8_fast   = std::int_fast8_t   ;
 using i16_fast  = std::int_fast16_t  ;
 using i32_fast  = std::int_fast32_t  ;
@@ -248,6 +251,7 @@ using u16_fast  = std::uint_fast16_t ;
 using u32_fast  = std::uint_fast32_t ;
 using u64_fast  = std::uint_fast64_t ;
 
+//  Rarely, when really needed for space optimization: Smallest type with at least N bits
 using i8_small  = std::int_least8_t  ;
 using i16_small = std::int_least16_t ;
 using i32_small = std::int_least32_t ;
@@ -257,6 +261,20 @@ using u16_small = std::uint_least16_t;
 using u32_small = std::uint_least32_t;
 using u64_small = std::uint_least64_t;
 
+//  Discouraged: Variable precision names
+//                short
+using ushort    = unsigned short;
+//                int
+using ulong     = unsigned long;
+//                long
+using longlong  = long long;
+using ulonglong = unsigned long long;
+using longdouble = long double;
+
+//  Strongly discouraged, for compatibility/interop only
+using __schar   = signed char;      // normally use i8 instead
+using __uchar   = unsigned char;    // normally use u8 instead
+
 
 //-----------------------------------------------------------------------
 //

regression-tests/pure2-cpp1-multitoken-fundamental-types.cpp2 renamed to regression-tests/pure2-cpp1-multitoken-fundamental-types-error.cpp2

@@ -0,0 +1,32 @@
+pure2-cpp1-multitoken-fundamental-types-error.cpp2...
+pure2-cpp1-multitoken-fundamental-types-error.cpp2(3,8): error: 'signed short int' - did you mean 'short'?
+pure2-cpp1-multitoken-fundamental-types-error.cpp2(3,8): error: 'signed short int' is an old-style C/C++ multi-word keyword type
+    - most such types should be used only for interoperability with older code
+    - using those when you need them is fine, but name them with these short names instead:
+        ushort, uint, ulong, longlong, ulonglong, __schar, __uchar
+    - see also cpp2util.h > "Convenience names for integer types"
+pure2-cpp1-multitoken-fundamental-types-error.cpp2(4,8): error: 'short int signed' - did you mean 'short'?
+pure2-cpp1-multitoken-fundamental-types-error.cpp2(4,8): error: 'short int signed' is an old-style C/C++ multi-word keyword type
+    - most such types should be used only for interoperability with older code
+    - using those when you need them is fine, but name them with these short names instead:
+        ushort, uint, ulong, longlong, ulonglong, __schar, __uchar
+    - see also cpp2util.h > "Convenience names for integer types"
+pure2-cpp1-multitoken-fundamental-types-error.cpp2(5,8): error: 'long long unsigned int' - did you mean 'ulonglong'?
+pure2-cpp1-multitoken-fundamental-types-error.cpp2(5,8): error: 'long long unsigned int' is an old-style C/C++ multi-word keyword type
+    - most such types should be used only for interoperability with older code
+    - using those when you need them is fine, but name them with these short names instead:
+        ushort, uint, ulong, longlong, ulonglong, __schar, __uchar
+    - see also cpp2util.h > "Convenience names for integer types"
+pure2-cpp1-multitoken-fundamental-types-error.cpp2(6,8): error: 'long double' - did you mean 'long'?
+pure2-cpp1-multitoken-fundamental-types-error.cpp2(6,8): error: 'long double' is an old-style C/C++ multi-word keyword type
+    - most such types should be used only for interoperability with older code
+    - using those when you need them is fine, but name them with these short names instead:
+        ushort, uint, ulong, longlong, ulonglong, __schar, __uchar
+    - see also cpp2util.h > "Convenience names for integer types"
+pure2-cpp1-multitoken-fundamental-types-error.cpp2(7,8): error: 'unsigned char' - did you mean 'u8' (usually best) or '__uchar'?
+pure2-cpp1-multitoken-fundamental-types-error.cpp2(7,8): error: 'unsigned char' is an old-style C/C++ multi-word keyword type
+    - most such types should be used only for interoperability with older code
+    - using those when you need them is fine, but name them with these short names instead:
+        ushort, uint, ulong, longlong, ulonglong, __schar, __uchar
+    - see also cpp2util.h > "Convenience names for integer types"
+

regression-tests/test-results/pure2-cpp1-multitoken-fundamental-types-error.cpp2.output

@@ -350,13 +350,34 @@ auto lex_line(
 
         assert(tokens.back().type() == lexeme::Cpp1MultiKeyword);
         auto pos = tokens.back().position();
-        generated_text.push_back( tokens.back().to_string(true) );
-        tokens.pop_back();
 
-        while( !tokens.empty() && tokens.back().type() == lexeme::Cpp1MultiKeyword) {
-            generated_text.back() = tokens.back().to_string(true) + " " + generated_text.back();
+        auto num_merged_tokens = 0;
+        auto is_char           = 0;
+        auto is_short          = 0;
+        auto is_int            = 0;
+        auto is_long           = 0;
+        auto is_double         = 0;
+        auto is_signed         = 0;
+        auto is_unsigned       = 0;
+        generated_text.push_back( "" );
+        while( !tokens.empty() && tokens.back().type() == lexeme::Cpp1MultiKeyword)
+        {
+            auto text = tokens.back().to_string(true);
+            if (text == "char"    ) { ++is_char    ; }
+            if (text == "short"   ) { ++is_short   ; }
+            if (text == "int"     ) { ++is_int     ; }
+            if (text == "long"    ) { ++is_long    ; }
+            if (text == "double"  ) { ++is_double  ; }
+            if (text == "signed"  ) { ++is_signed  ; }
+            if (text == "unsigned") { ++is_unsigned; }
+
+            if (num_merged_tokens > 0) {
+                generated_text.back() = " " + generated_text.back();
+            }
+            generated_text.back() = text + generated_text.back();
             pos = tokens.back().position();
             tokens.pop_back();
+            ++num_merged_tokens;
         }
 
         tokens.push_back({
@@ -366,6 +387,37 @@ auto lex_line(
             lexeme::Keyword
             });
 
+        if (num_merged_tokens > 1)
+        {
+            auto alt = std::string{};
+            if      (is_char      &&  is_signed)   { alt = "'i8' (usually best) or '__schar'"; }
+            else if (is_char      &&  is_unsigned) { alt = "'u8' (usually best) or '__uchar'"; }
+            else if (is_short     && !is_unsigned) { alt = "'short'"      ; }
+            else if (is_short     &&  is_unsigned) { alt = "'ushort'"     ; }
+            else if (is_long == 1 && !is_unsigned) { alt = "'long'"       ; }
+            else if (is_long == 1 &&  is_unsigned) { alt = "'ulong'"      ; }
+            else if (is_long >  1 && !is_unsigned) { alt = "'longlong'"   ; }
+            else if (is_long >  1 &&  is_unsigned) { alt = "'ulonglong'"  ; }
+            else if (is_int       && !is_unsigned) { alt = "'int'"        ; }
+            else if (is_int       &&  is_unsigned) { alt = "'uint'"       ; }
+            else if (is_double    &&  is_long)     { alt = "'longdouble'" ; }
+
+            if (std::ssize(alt) > 0) {
+                errors.emplace_back(
+                    pos,
+                    "'" + tokens.back().to_string(true) + "' - did you mean " + alt + "?"
+                );
+            }
+            errors.emplace_back(
+                pos,
+                "'" + tokens.back().to_string(true) + "' is an old-style C/C++ multi-word keyword type\n"
+                "    - most such types should be used only for interoperability with older code\n"
+                "    - using those when you need them is fine, but name them with these short names instead:\n"
+                "        ushort, uint, ulong, longlong, ulonglong, __schar, __uchar\n"
+                "    - see also cpp2util.h > \"Convenience names for integer types\""
+            );
+        }
+
         tokens.push_back(last_token);
     };