Rename treat_byte_string_as_slice to make its new usage clear

Author: oli-obk

compiler/rustc_hir_typeck/src/pat.rs

@@ -549,7 +549,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             {
                 let tcx = self.tcx;
                 trace!(?hir_id.local_id, "polymorphic byte string lit");
-                self.typeck_results.borrow_mut().treat_byte_string_as_slice.insert(hir_id.local_id);
+                self.typeck_results.borrow_mut().lit_pat_type_adjusted.insert(hir_id.local_id);
                 pat_ty =
                     Ty::new_imm_ref(tcx, tcx.lifetimes.re_static, Ty::new_slice(tcx, tcx.types.u8));
             }
@@ -562,7 +562,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         {
             let tcx = self.tcx;
             let expected = self.resolve_vars_if_possible(expected);
-            self.typeck_results.borrow_mut().treat_byte_string_as_slice.insert(hir_id.local_id);
+            self.typeck_results.borrow_mut().lit_pat_type_adjusted.insert(hir_id.local_id);
             pat_ty = match expected.kind() {
                 ty::Adt(def, _) if tcx.is_lang_item(def.did(), LangItem::String) => expected,
                 ty::Str => Ty::new_static_str(tcx),

compiler/rustc_hir_typeck/src/writeback.rs

@@ -79,8 +79,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         debug!("used_trait_imports({:?}) = {:?}", item_def_id, used_trait_imports);
         wbcx.typeck_results.used_trait_imports = used_trait_imports;
 
-        wbcx.typeck_results.treat_byte_string_as_slice =
-            mem::take(&mut self.typeck_results.borrow_mut().treat_byte_string_as_slice);
+        wbcx.typeck_results.lit_pat_type_adjusted =
+            mem::take(&mut self.typeck_results.borrow_mut().lit_pat_type_adjusted);
 
         debug!("writeback: typeck results for {:?} are {:#?}", item_def_id, wbcx.typeck_results);
 

compiler/rustc_middle/src/ty/typeck_results.rs

@@ -199,11 +199,13 @@ pub struct TypeckResults<'tcx> {
     /// formatting modified file tests/ui/coroutine/retain-resume-ref.rs
     pub coroutine_stalled_predicates: FxIndexSet<(ty::Predicate<'tcx>, ObligationCause<'tcx>)>,
 
-    /// We sometimes treat byte string literals (which are of type `&[u8; N]`)
-    /// as `&[u8]`, depending on the pattern in which they are used.
+    /// We sometimes treat
+    /// * byte string literals (which are of type `&[u8; N]`)
+    ///   as `&[u8]`, depending on the pattern in which they are used.
+    /// * string literals (which are of type `&str`) as `String`
     /// This hashset records all instances where we behave
     /// like this to allow `const_to_pat` to reliably handle this situation.
-    pub treat_byte_string_as_slice: ItemLocalSet,
+    pub lit_pat_type_adjusted: ItemLocalSet,
 
     /// Contains the data for evaluating the effect of feature `capture_disjoint_fields`
     /// on closure size.
@@ -239,7 +241,7 @@ impl<'tcx> TypeckResults<'tcx> {
             closure_fake_reads: Default::default(),
             rvalue_scopes: Default::default(),
             coroutine_stalled_predicates: Default::default(),
-            treat_byte_string_as_slice: Default::default(),
+            lit_pat_type_adjusted: Default::default(),
             closure_size_eval: Default::default(),
             offset_of_data: Default::default(),
         }

compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs

@@ -58,7 +58,7 @@ struct ConstToPat<'tcx> {
     span: Span,
     id: hir::HirId,
 
-    treat_byte_string_as_slice: bool,
+    lit_pat_type_adjusted: bool,
 
     c: ty::Const<'tcx>,
 }
@@ -71,9 +71,9 @@ impl<'tcx> ConstToPat<'tcx> {
             typing_env: pat_ctxt.typing_env,
             span,
             id,
-            treat_byte_string_as_slice: pat_ctxt
+            lit_pat_type_adjusted: pat_ctxt
                 .typeck_results
-                .treat_byte_string_as_slice
+                .lit_pat_type_adjusted
                 .contains(&id.local_id),
             c,
         }
@@ -108,7 +108,7 @@ impl<'tcx> ConstToPat<'tcx> {
         uv: ty::UnevaluatedConst<'tcx>,
         ty: Ty<'tcx>,
     ) -> Box<Pat<'tcx>> {
-        trace!(self.treat_byte_string_as_slice);
+        trace!(self.lit_pat_type_adjusted);
 
         // It's not *technically* correct to be revealing opaque types here as borrowcheck has
         // not run yet. However, CTFE itself uses `TypingMode::PostAnalysis` unconditionally even
@@ -220,7 +220,7 @@ impl<'tcx> ConstToPat<'tcx> {
         let tcx = self.tcx;
         let kind = match ty.kind() {
             ty::Adt(adt_def, _)
-                if self.treat_byte_string_as_slice
+                if self.lit_pat_type_adjusted
                     && tcx.is_lang_item(adt_def.did(), LangItem::String) =>
             {
                 let ty = Ty::new_imm_ref(tcx, tcx.lifetimes.re_erased, tcx.types.str_);
@@ -320,7 +320,7 @@ impl<'tcx> ConstToPat<'tcx> {
                         // has no negative effects on pattern matching, even if we're actually matching on
                         // arrays.
                         let pointee_ty = match *pointee_ty.kind() {
-                            ty::Array(elem_ty, _) if self.treat_byte_string_as_slice => {
+                            ty::Array(elem_ty, _) if self.lit_pat_type_adjusted => {
                                 Ty::new_slice(tcx, elem_ty)
                             }
                             _ => *pointee_ty,