Add CppCompat.ULong32, CppCompat.LongLong64 and CppCompat.ULongLong64 (#6386)

This extends #6364 to allow having:
* `Cpp.unsigned_long` as a distinct type when `unsigned long` is 32
bits.
* `Cpp.long_long` and `Cpp.unsigned_long_long` as distinct types when
`long` and `unsigned long` are 64 bits.

Similarly to #6364, we only support implicit conversions from the
matching literal type (`u32`, `i64` and `u64`).

See #6275 for rationale.

Part of #5263.

Author: bricknerb

core/prelude/types/cpp/int.carbon

@@ -7,20 +7,32 @@ package Core library "prelude/types/cpp/int";
 import library "prelude/operators";
 import library "prelude/types/int";
 import library "prelude/types/int_literal";
+import library "prelude/types/uint";
 
 namespace CppCompat;
 
-// TODO: Add ULong32, LongLong64, ULongLong64.
 class CppCompat.Long32 {
   adapt i32;
 }
 
+class CppCompat.ULong32 {
+  adapt u32;
+}
+
+class CppCompat.LongLong64 {
+  adapt i64;
+}
+
+class CppCompat.ULongLong64 {
+  adapt u64;
+}
+
 // TODO: Copy.
 
 // Conversions.
 
-// TODO: ImplicitAs from IntLiteral to Long32.
-// TODO: ImplicitAs from Long32 to IntLiteral.
+// TODO: ImplicitAs from IntLiteral to Long32, ULong32, LongLong64, ULongLong64.
+// TODO: ImplicitAs from Long32, ULong32, LongLong64, ULongLong64 to IntLiteral.
 
 // TODO: ImplicitAs from Int(N) to Long32 if N < 32.
 impl i32 as ImplicitAs(CppCompat.Long32) {
@@ -32,7 +44,43 @@ final impl CppCompat.Long32 as ImplicitAs(i32) {
   fn Convert[self: Self]() -> i32 = "int.convert";
 }
 
+// TODO: ImplicitAs from UInt(N) to ULong32 if N < 32.
+impl u32 as ImplicitAs(CppCompat.ULong32) {
+  fn Convert[self: Self]() -> CppCompat.ULong32 = "int.convert_checked";
+}
+
+// TODO: ImplicitAs from ULong32 to UInt(N) if N > 32.
+final impl CppCompat.ULong32 as ImplicitAs(u32) {
+  fn Convert[self: Self]() -> u32 = "int.convert";
+}
+
+// TODO: ImplicitAs from Int(N) to LongLong64 if N < 64.
+impl i64 as ImplicitAs(CppCompat.LongLong64) {
+  fn Convert[self: Self]() -> CppCompat.LongLong64 = "int.convert_checked";
+}
+
+// TODO: ImplicitAs from LongLong64 to Int(N) if N > 64.
+final impl CppCompat.LongLong64 as ImplicitAs(i64) {
+  fn Convert[self: Self]() -> i64 = "int.convert";
+}
+
+// TODO: ImplicitAs from UInt(N) to ULongLong64 if N < 64.
+impl u64 as ImplicitAs(CppCompat.ULongLong64) {
+  fn Convert[self: Self]() -> CppCompat.ULongLong64 = "int.convert_checked";
+}
+
+// TODO: ImplicitAs from ULongLong64 to UInt(N) if N > 64.
+final impl CppCompat.ULongLong64 as ImplicitAs(u64) {
+  fn Convert[self: Self]() -> u64 = "int.convert";
+}
+
 // TODO: As from Long32 to Int(N) if N < 32.
+// TODO: As from ULong32 to UInt(N) if N < 32.
+// TODO: As from LongLong64 to Int(N) if N < 64.
+// TODO: As from ULongLong64 to UInt(N) if N < 64.
 // TODO: As from Int(N) to Long32 if N > 32.
+// TODO: As from UInt(N) to ULong32 if N > 32.
+// TODO: As from Int(N) to LongLong64 if N > 64.
+// TODO: As from UInt(N) to ULongLong64 if N > 64.
 
-// TODO: Operations on Long32.
+// TODO: Operations on Long32, ULong32, LongLong64, ULongLong64.

toolchain/check/cpp/import.cpp

@@ -1088,6 +1088,19 @@ static auto MakeCppCompatType(Context& context, SemIR::LocId loc_id,
                     LookupNameInCore(context, loc_id, {"CppCompat", name}));
 }
 
+// Maps a C++ builtin integer type to a Carbon `Core.CppCompat` type.
+static auto MapBuiltinCppCompatIntegerType(Context& context,
+                                           unsigned int cpp_width,
+                                           unsigned int carbon_width,
+                                           llvm::StringRef cpp_compat_name)
+    -> TypeExpr {
+  if (cpp_width != carbon_width) {
+    return TypeExpr::None;
+  }
+
+  return MakeCppCompatType(context, Parse::NodeId::None, cpp_compat_name);
+}
+
 // Maps a C++ builtin integer type to a Carbon type.
 // TODO: Handle integer types that map to named aliases.
 static auto MapBuiltinIntegerType(Context& context, SemIR::LocId loc_id,
@@ -1114,9 +1127,18 @@ static auto MapBuiltinIntegerType(Context& context, SemIR::LocId loc_id,
     return ExprAsType(context, Parse::NodeId::None,
                       MakeCharTypeLiteral(context, Parse::NodeId::None));
   }
-  if (clang::ASTContext::hasSameType(qual_type, ast_context.LongTy) &&
-      width == 32) {
-    return MakeCppCompatType(context, loc_id, "Long32");
+  if (clang::ASTContext::hasSameType(qual_type, ast_context.LongTy)) {
+    return MapBuiltinCppCompatIntegerType(context, width, 32, "Long32");
+  }
+  if (clang::ASTContext::hasSameType(qual_type, ast_context.UnsignedLongTy)) {
+    return MapBuiltinCppCompatIntegerType(context, width, 32, "ULong32");
+  }
+  if (clang::ASTContext::hasSameType(qual_type, ast_context.LongLongTy)) {
+    return MapBuiltinCppCompatIntegerType(context, width, 64, "LongLong64");
+  }
+  if (clang::ASTContext::hasSameType(qual_type,
+                                     ast_context.UnsignedLongLongTy)) {
+    return MapBuiltinCppCompatIntegerType(context, width, 64, "ULongLong64");
   }
   return TypeExpr::None;
 }

toolchain/check/cpp/type_mapping.cpp

@@ -122,6 +122,17 @@ static auto LookupCppType(
                    : clang::QualType();
 }
 
+// Returns the given integer type if its width is as expected. Otherwise returns
+// the null type.
+static auto VerifyIntegerTypeWidth(Context& context, clang::QualType type,
+                                   unsigned int expected_width)
+    -> clang::QualType {
+  if (context.ast_context().getIntWidth(type) == expected_width) {
+    return type;
+  }
+  return clang::QualType();
+}
+
 // Maps a Carbon class type to a C++ type. Returns a null `QualType` if the
 // type is not supported.
 static auto TryMapClassType(Context& context, SemIR::ClassType class_type)
@@ -175,10 +186,17 @@ static auto TryMapClassType(Context& context, SemIR::ClassType class_type)
       return ast_context.CharTy;
     }
     case SemIR::RecognizedTypeInfo::CppLong32: {
-      if (ast_context.getIntWidth(ast_context.LongTy) == 32) {
-        return ast_context.LongTy;
-      }
-      break;
+      return VerifyIntegerTypeWidth(context, ast_context.LongTy, 32);
+    }
+    case SemIR::RecognizedTypeInfo::CppULong32: {
+      return VerifyIntegerTypeWidth(context, ast_context.UnsignedLongTy, 32);
+    }
+    case SemIR::RecognizedTypeInfo::CppLongLong64: {
+      return VerifyIntegerTypeWidth(context, ast_context.LongLongTy, 64);
+    }
+    case SemIR::RecognizedTypeInfo::CppULongLong64: {
+      return VerifyIntegerTypeWidth(context, ast_context.UnsignedLongLongTy,
+                                    64);
     }
     case SemIR::RecognizedTypeInfo::CppNullptrT: {
       return ast_context.NullPtrTy;