gccrs: Introduce CStr language item

gcc/rust/ChangeLog:
	* util/rust-lang-item.h(LangItem::Kind): New CSTR kind.
	* util/rust-lang-item.cc(LangItem::lang_items): Ditto.
	* backend/rust-compile-type.cc(visit(TyTy::ReferenceType)): Add specific record
	type for CStr.
	* typecheck/rust-hir-type-check-base.cc(resolve_literal): Update C_STRING case to
	resolve to the CStr language item instead.

gcc/testsuite/ChangeLog:
	* rust/compile/c_string.rs: Add CStr language item definition.
	* rust/compile/c_string_null_byte_check.rs: Ditto.

Signed-Off-By: Yap Zhi Heng <yapzhhg@gmail.com>

Author: Polygonalr

gcc/rust/backend/rust-compile-type.cc

@@ -685,6 +685,41 @@ TyTyResolveCompile::visit (const TyTy::ReferenceType &type)
       return;
     }
 
+  // Check for CStr, create a specific record for it
+  do
+    {
+      if (type.get_base ()->get_kind () != TyTy::TypeKind::ADT)
+	break;
+
+      const TyTy::ADTType *adt
+	= static_cast<const TyTy::ADTType *> (type.get_base ());
+      auto &mappings = Analysis::Mappings::get ();
+      auto cstr_item = mappings.lookup_lang_item (LangItem::Kind::CSTR);
+      if (!cstr_item.has_value ())
+	break;
+
+      HirId cstr_hirid = mappings.lookup_defid (cstr_item.value ())
+			   .value ()
+			   ->get_mappings ()
+			   .get_hirid ();
+
+      if (cstr_hirid != adt->get_ref ())
+	break;
+
+      // &CStr is a fat pointer: { *const u8, usize }
+      // Reuse the c_char (u8) slice fat-pointer layout
+      TyTy::BaseType *u8 = nullptr;
+      ctx->get_tyctx ()->lookup_builtin ("u8", &u8);
+      // Create a synthetic SliceType over u8 and use that record layout
+      TyTy::SliceType synthetic_slice (adt->get_ref (), adt->get_ident ().locus,
+				       TyTy::TyVar (u8->get_ref ()));
+      tree type_record = create_slice_type_record (synthetic_slice);
+      translated
+	= Backend::named_type ("&CStr", type_record, adt->get_ident ().locus);
+      return;
+    }
+  while (false);
+
   tree base_compiled_type
     = TyTyResolveCompile::compile (ctx, type.get_base (), trait_object_mode);
   if (type.is_mutable ())

gcc/rust/typecheck/rust-hir-type-check-base.cc

@@ -397,24 +397,28 @@ TypeCheckBase::resolve_literal (const Analysis::NodeMapping &expr_mappings,
 	    break;
 	  }
 
-	/* This is a pointer to a null-terminated byte slice (&[u8]). */
-	TyTy::BaseType *u8;
-	auto ok = context->lookup_builtin ("u8", &u8);
-	rust_assert (ok);
+	auto lang_item_defined
+	  = mappings.lookup_lang_item (LangItem::Kind::CSTR);
 
-	auto crate_num = mappings.get_current_crate ();
-	Analysis::NodeMapping slice_mapping (crate_num, UNKNOWN_NODEID,
-					     mappings.get_next_hir_id (
-					       crate_num),
-					     UNKNOWN_LOCAL_DEFID);
+	if (!lang_item_defined)
+	  {
+	    rust_error_at (locus, "unable to find lang item: %<c_str%>");
+	    infered = new TyTy::ErrorType (expr_mappings.get_hirid (), locus);
+	    break;
+	  }
 
-	TyTy::SliceType *slice
-	  = new TyTy::SliceType (slice_mapping.get_hirid (), locus,
-				 TyTy::TyVar (u8->get_ref ()));
-	context->insert_type (slice_mapping, slice);
+	DefId cstr_defid = lang_item_defined.value ();
+	HIR::Item *item = mappings.lookup_defid (cstr_defid).value ();
+
+	TyTy::BaseType *item_type = nullptr;
+	bool ok = context->lookup_type (item->get_mappings ().get_hirid (),
+					&item_type);
+
+	rust_assert (ok);
+	rust_assert (item_type->get_kind () == TyTy::TypeKind::ADT);
 
 	infered = new TyTy::ReferenceType (expr_mappings.get_hirid (),
-					   TyTy::TyVar (slice->get_ref ()),
+					   TyTy::TyVar (item_type->get_ref ()),
 					   Mutability::Imm,
 					   TyTy::Region::make_static ());
       }

gcc/rust/util/rust-lang-item.cc

@@ -92,6 +92,7 @@ const BiMap<std::string, LangItem::Kind> Rust::LangItem::lang_items = {{
   {"slice_u8", Kind::SLICE_U8},
   {"slice", Kind::SLICE},
   {"str", Kind::STR},
+  {"CStr", Kind::CSTR},
   {"f32_runtime", Kind::F32_RUNTIME},
   {"f64_runtime", Kind::F64_RUNTIME},
 

gcc/rust/util/rust-lang-item.h

@@ -125,6 +125,7 @@ class LangItem
     SLICE_U8,
     SLICE,
     STR,
+    CSTR,
     F32_RUNTIME,
     F64_RUNTIME,
 

gcc/testsuite/rust/compile/c_string.rs

@@ -1,15 +1,28 @@
 // { dg-additional-options "-frust-c-style-string-literals" }
 // { dg-output "gccrs\n" }
-#![feature(no_core)]
+#![feature(no_core, lang_items)]
 #![no_core]
 
 extern "C" {
-    fn printf(s: *const i8, ...);
+    fn printf(s: *const u8, ...);
+}
+
+type c_char = u8;
+
+#[lang = "CStr"]
+pub struct CStr {
+    inner: [c_char]
+}
+
+impl CStr {
+    pub const fn to_ptr(&self) -> *const c_char {
+        &self.inner as *const [c_char] as *const c_char
+    }
 }
 
 pub fn main() {
     let a = c"gccrs";
     unsafe {
-        printf(a as *const [u8] as *const i8); // TODO change `as *const [u8]` to `.as_ptr()` when C strings are compiled to their own CStr type
+        printf(a.to_ptr());
     }
 }

gcc/testsuite/rust/compile/c_string_null_byte_check.rs

@@ -1,7 +1,20 @@
 // { dg-additional-options "-frust-c-style-string-literals" }
-#![feature(no_core)]
+#![feature(no_core, lang_items)]
 #![no_core]
 
+type c_char = u8;
+
+#[lang = "CStr"]
+pub struct CStr {
+    inner: [c_char]
+}
+
+impl CStr {
+    pub const fn to_ptr(&self) -> *const c_char {
+        &self.inner as *const [c_char] as *const c_char
+    }
+}
+
 pub fn main() {
     let _fail = c"gc\0crs";
     // { dg-error "null characters in C string literals are not supported" "" { target *-*-* } .-1 }