Move str to libcore.

Author: eddyb

src/libcore/str/mod.rs

@@ -26,10 +26,20 @@ pub mod pattern;
 #[allow(missing_docs)]
 pub mod lossy;
 
-// HACK(eddyb) private and not named `str` to avoid changing name resolution.
-#[cfg(not(bootstrap))]
-#[lang = "str"]
-struct Str([u8]);
+mod sealed {
+    // HACK(eddyb) sealed away and not named `str` to avoid changing name resolution.
+    // Only `pub` to avoid the privacy checker producing errors.
+    #[cfg(not(bootstrap))]
+    #[lang = "str"]
+    #[stable(feature = "rust1", since = "1.0.0")]
+    pub struct Str([u8]);
+
+    #[unstable(feature = "structural_match", issue = "31434")]
+    impl crate::marker::StructuralPartialEq for str {}
+
+    #[unstable(feature = "structural_match", issue = "31434")]
+    impl crate::marker::StructuralEq for str {}
+}
 
 /// Parse a value from a string
 ///

src/librustc_codegen_llvm/debuginfo/metadata.rs

@@ -573,7 +573,9 @@ pub fn type_metadata(cx: &CodegenCx<'ll, 'tcx>, t: Ty<'tcx>, usage_site_span: Sp
 
     let ptr_metadata = |ty: Ty<'tcx>| match ty.kind {
         ty::Slice(typ) => Ok(vec_slice_metadata(cx, t, typ, unique_type_id, usage_site_span)),
-        ty::Str => Ok(vec_slice_metadata(cx, t, cx.tcx.types.u8, unique_type_id, usage_site_span)),
+        ty::Adt(def, _) if def.is_str() => {
+            Ok(vec_slice_metadata(cx, t, cx.tcx.types.u8, unique_type_id, usage_site_span))
+        }
         ty::Dynamic(..) => Ok(MetadataCreationResult::new(
             trait_pointer_metadata(cx, ty, Some(t), unique_type_id),
             false,
@@ -601,7 +603,9 @@ pub fn type_metadata(cx: &CodegenCx<'ll, 'tcx>, t: Ty<'tcx>, usage_site_span: Sp
         ty::Array(typ, _) | ty::Slice(typ) => {
             fixed_vec_metadata(cx, unique_type_id, t, typ, usage_site_span)
         }
-        ty::Str => fixed_vec_metadata(cx, unique_type_id, t, cx.tcx.types.i8, usage_site_span),
+        ty::Adt(def, _) if def.is_str() => {
+            fixed_vec_metadata(cx, unique_type_id, t, cx.tcx.types.i8, usage_site_span)
+        }
         ty::Dynamic(..) => {
             MetadataCreationResult::new(trait_pointer_metadata(cx, t, None, unique_type_id), false)
         }

src/librustc_codegen_llvm/type_of.rs

@@ -58,8 +58,7 @@ fn uncached_llvm_type<'a, 'tcx>(
         // FIXME(eddyb) producing readable type names for trait objects can result
         // in problematically distinct types due to HRTB and subtyping (see #47638).
         // ty::Dynamic(..) |
-        ty::Foreign(..) |
-        ty::Str => {
+        ty::Foreign(..) => {
             let mut name = String::with_capacity(32);
             let printer = DefPathBasedNames::new(cx.tcx, true, true);
             printer.push_type_name(layout.ty, &mut name, false);

src/librustc_codegen_ssa/debuginfo/type_names.rs

@@ -36,7 +36,7 @@ pub fn push_debuginfo_type_name<'tcx>(
     match t.kind {
         ty::Bool => output.push_str("bool"),
         ty::Char => output.push_str("char"),
-        ty::Str => output.push_str("str"),
+        ty::Adt(def, _) if def.is_str() => output.push_str("str"),
         ty::Never => output.push_str("!"),
         ty::Int(int_ty) => output.push_str(int_ty.name_str()),
         ty::Uint(uint_ty) => output.push_str(uint_ty.name_str()),

src/librustc_codegen_ssa/glue.rs

@@ -25,7 +25,7 @@ pub fn size_and_align_of_dst<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
             let vtable = info.unwrap();
             (meth::SIZE.get_usize(bx, vtable), meth::ALIGN.get_usize(bx, vtable))
         }
-        ty::Slice(_) | ty::Str => {
+        ty::Slice(_) => {
             let unit = layout.field(bx, 0);
             // The info in this case is the length of the str, so the size is that
             // times the unit size.

src/librustc_codegen_ssa/mir/place.rs

@@ -125,7 +125,7 @@ impl<'a, 'tcx, V: CodegenObject> PlaceRef<'tcx, V> {
                 return simple();
             }
             _ if !field.is_unsized() => return simple(),
-            ty::Slice(..) | ty::Str | ty::Foreign(..) => return simple(),
+            ty::Slice(..) | ty::Foreign(..) => return simple(),
             ty::Adt(def, _) => {
                 if def.repr.packed() {
                     // FIXME(eddyb) generalize the adjustment when we

src/librustc_codegen_ssa/traits/type_.rs

@@ -86,7 +86,7 @@ pub trait DerivedTypeMethods<'tcx>: BaseTypeMethods<'tcx> + MiscMethods<'tcx> {
         let tail = self.tcx().struct_tail_erasing_lifetimes(ty, param_env);
         match tail.kind {
             ty::Foreign(..) => false,
-            ty::Str | ty::Slice(..) | ty::Dynamic(..) => true,
+            ty::Slice(..) | ty::Dynamic(..) => true,
             _ => bug!("unexpected unsized tail: {:?}", tail),
         }
     }

src/librustc_infer/infer/canonical/canonicalizer.rs

@@ -403,7 +403,6 @@ impl<'cx, 'tcx> TypeFolder<'tcx> for Canonicalizer<'cx, 'tcx> {
             | ty::Uint(..)
             | ty::Float(..)
             | ty::Adt(..)
-            | ty::Str
             | ty::Error
             | ty::Array(..)
             | ty::Slice(..)

src/librustc_infer/infer/freshen.rs

@@ -194,7 +194,6 @@ impl<'a, 'tcx> TypeFolder<'tcx> for TypeFreshener<'a, 'tcx> {
             | ty::Uint(..)
             | ty::Float(..)
             | ty::Adt(..)
-            | ty::Str
             | ty::Error
             | ty::Array(..)
             | ty::Slice(..)

src/librustc_lint/types.rs

@@ -617,6 +617,12 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
         }
 
         match ty.kind {
+            ty::Adt(def, _) if def.is_str() => FfiUnsafe {
+                ty,
+                reason: "string slices have no C equivalent",
+                help: Some("consider using `*const u8` and a length instead"),
+            },
+
             ty::Adt(def, substs) => {
                 if def.is_phantom_data() {
                     return FfiPhantom(ty);
@@ -822,12 +828,6 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
                 FfiUnsafe { ty, reason: "trait objects have no C equivalent", help: None }
             }
 
-            ty::Str => FfiUnsafe {
-                ty,
-                reason: "string slices have no C equivalent",
-                help: Some("consider using `*const u8` and a length instead"),
-            },
-
             ty::Tuple(..) => FfiUnsafe {
                 ty,
                 reason: "tuples have unspecified layout",