Unnormalized migration: struct_tail takes fn taking Unnormalized

khyperia · lcnr · commit 57b3e84ed4ad · 2026-05-12T20:45:13.000+02:00
diff --git a/compiler/rustc_borrowck/src/type_check/canonical.rs b/compiler/rustc_borrowck/src/type_check/canonical.rs
@@ -183,15 +183,15 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
         );
     }
 
-    pub(super) fn normalize<T>(&mut self, value: T, location: impl NormalizeLocation) -> T
+    pub(super) fn normalize<T>(
+        &mut self,
+        value: Unnormalized<'tcx, T>,
+        location: impl NormalizeLocation,
+    ) -> T
     where
         T: type_op::normalize::Normalizable<'tcx> + fmt::Display + Copy + 'tcx,
     {
-        self.normalize_with_category(
-            Unnormalized::new_wip(value),
-            location,
-            ConstraintCategory::Boring,
-        )
+        self.normalize_with_category(value, location, ConstraintCategory::Boring)
     }
 
     pub(super) fn deeply_normalize<T>(&mut self, value: T, location: impl NormalizeLocation) -> T
@@ -242,7 +242,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
 
         let mut normalize = |ty| self.normalize(ty, location);
         let tail = tcx.struct_tail_raw(ty, &cause, &mut normalize, || {});
-        normalize(tail)
+        normalize(Unnormalized::new_wip(tail))
     }
 
     #[instrument(skip(self), level = "debug")]
@@ -287,7 +287,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
         // hack in `equate_inputs_and_outputs` which does have associated test cases.
         let mir_ty = match self.infcx.next_trait_solver() {
             true => mir_ty,
-            false => self.normalize(mir_ty, Locations::All(span)),
+            false => self.normalize(Unnormalized::new_wip(mir_ty), Locations::All(span)),
         };
 
         let cause = ObligationCause::dummy_with_span(span);
diff --git a/compiler/rustc_borrowck/src/type_check/input_output.rs b/compiler/rustc_borrowck/src/type_check/input_output.rs
@@ -235,7 +235,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
         if let Err(_) =
             self.eq_types(a, b, Locations::All(span), ConstraintCategory::BoringNoLocation)
         {
-            let b = self.normalize(b, Locations::All(span));
+            let b = self.normalize(ty::Unnormalized::new(b), Locations::All(span));
             self.eq_types(a, b, Locations::All(span), ConstraintCategory::BoringNoLocation)
                 .unwrap_or_else(|terr| {
                     span_mirbug!(
diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs
@@ -480,7 +480,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
             let projected_ty = curr_projected_ty.projection_ty_core(
                 tcx,
                 proj,
-                |ty| self.normalize(ty, locations),
+                |ty| self.normalize(ty::Unnormalized::new_wip(ty), locations),
                 |ty, variant_index, field, ()| PlaceTy::field_ty(tcx, ty, variant_index, field),
                 |_| unreachable!(),
             );
@@ -490,8 +490,8 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
 
         // Need to renormalize `a` as typecheck may have failed to normalize
         // higher-ranked aliases if normalization was ambiguous due to inference.
-        let a = self.normalize(a, locations);
-        let ty = self.normalize(curr_projected_ty.ty, locations);
+        let a = self.normalize(ty::Unnormalized::new_wip(a), locations);
+        let ty = self.normalize(ty::Unnormalized::new_wip(curr_projected_ty.ty), locations);
         self.relate_types(ty, v.xform(ty::Contravariant), a, locations, category)?;
 
         Ok(())
@@ -639,11 +639,11 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
 
                 let place_ty = place.ty(self.body, tcx).ty;
                 debug!(?place_ty);
-                let place_ty = self.normalize(place_ty, location);
+                let place_ty = self.normalize(ty::Unnormalized::new_wip(place_ty), location);
                 debug!("place_ty normalized: {:?}", place_ty);
                 let rv_ty = rv.ty(self.body, tcx);
                 debug!(?rv_ty);
-                let rv_ty = self.normalize(rv_ty, location);
+                let rv_ty = self.normalize(ty::Unnormalized::new_wip(rv_ty), location);
                 debug!("normalized rv_ty: {:?}", rv_ty);
                 if let Err(terr) =
                     self.sub_types(rv_ty, place_ty, location.to_locations(), category)
@@ -1082,7 +1082,8 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                                 },
                             );
 
-                            let src_ty = self.normalize(src_ty, location);
+                            let src_ty =
+                                self.normalize(ty::Unnormalized::new_wip(src_ty), location);
                             if let Err(terr) = self.sub_types(
                                 src_ty,
                                 *ty,
@@ -1124,7 +1125,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                         // function definition. When we extract the
                         // signature, it comes from the `fn_sig` query,
                         // and hence may contain unnormalized results.
-                        let src_ty = self.normalize(src_ty, location);
+                        let src_ty = self.normalize(ty::Unnormalized::new_wip(src_ty), location);
                         if let Err(terr) = self.sub_types(
                             src_ty,
                             *ty,
@@ -1190,7 +1191,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                         // function definition. When we extract the
                         // signature, it comes from the `fn_sig` query,
                         // and hence may contain unnormalized results.
-                        let fn_sig = self.normalize(fn_sig, location);
+                        let fn_sig = self.normalize(ty::Unnormalized::new_wip(fn_sig), location);
 
                         let ty_fn_ptr_from = tcx.safe_to_unsafe_fn_ty(fn_sig);
 
@@ -1786,8 +1787,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                     );
                 }
             } else if let Some(static_def_id) = constant.check_static_ptr(tcx) {
-                let unnormalized_ty =
-                    tcx.type_of(static_def_id).instantiate_identity().skip_norm_wip();
+                let unnormalized_ty = tcx.type_of(static_def_id).instantiate_identity();
                 let normalized_ty = self.normalize(unnormalized_ty, locations);
                 let literal_ty = constant.const_.ty().builtin_deref(true).unwrap();
 
@@ -1876,9 +1876,9 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
             | ProjectionElem::Subslice { .. }
             | ProjectionElem::Downcast(..) => {}
             ProjectionElem::Field(field, fty) => {
-                let fty = self.normalize(fty, location);
+                let fty = self.normalize(ty::Unnormalized::new_wip(fty), location);
                 let ty = PlaceTy::field_ty(tcx, base_ty.ty, base_ty.variant_index, field);
-                let ty = self.normalize(ty, location);
+                let ty = self.normalize(ty::Unnormalized::new_wip(ty), location);
                 debug!(?fty, ?ty);
 
                 if let Err(terr) = self.relate_types(
@@ -1892,7 +1892,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                 }
             }
             ProjectionElem::OpaqueCast(ty) => {
-                let ty = self.normalize(ty, location);
+                let ty = self.normalize(ty::Unnormalized::new_wip(ty), location);
                 self.relate_types(
                     ty,
                     context.ambient_variance(),
@@ -1945,7 +1945,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
             }
         } else {
             let dest_ty = destination.ty(self.body, tcx).ty;
-            let dest_ty = self.normalize(dest_ty, term_location);
+            let dest_ty = self.normalize(ty::Unnormalized::new_wip(dest_ty), term_location);
             let category = match destination.as_local() {
                 Some(RETURN_PLACE) => {
                     if let DefiningTy::Const(def_id, _) | DefiningTy::InlineConst(def_id, _) =
@@ -2030,7 +2030,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
         for (n, (fn_arg, op_arg)) in iter::zip(sig.inputs(), args).enumerate() {
             let op_arg_ty = op_arg.node.ty(self.body, self.tcx());
 
-            let op_arg_ty = self.normalize(op_arg_ty, term_location);
+            let op_arg_ty = self.normalize(ty::Unnormalized::new_wip(op_arg_ty), term_location);
             let category = if call_source.from_hir_call() {
                 ConstraintCategory::CallArgument(Some(
                     self.infcx.tcx.erase_and_anonymize_regions(func_ty),
@@ -2198,7 +2198,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                 let variant = &def.variant(variant_index);
                 let adj_field_index = active_field_index.unwrap_or(field_index);
                 if let Some(field) = variant.fields.get(adj_field_index) {
-                    Ok(self.normalize(field.ty(tcx, args), location))
+                    Ok(self.normalize(ty::Unnormalized::new_wip(field.ty(tcx, args)), location))
                 } else {
                     Err(FieldAccessError::OutOfRange { field_count: variant.fields.len() })
                 }
@@ -2302,7 +2302,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                 }
             };
             let operand_ty = operand.ty(self.body, tcx);
-            let operand_ty = self.normalize(operand_ty, location);
+            let operand_ty = self.normalize(ty::Unnormalized::new_wip(operand_ty), location);
 
             if let Err(terr) = self.sub_types(
                 operand_ty,
diff --git a/compiler/rustc_codegen_gcc/src/intrinsic/simd.rs b/compiler/rustc_codegen_gcc/src/intrinsic/simd.rs
@@ -16,7 +16,7 @@ use rustc_codegen_ssa::traits::{BaseTypeCodegenMethods, BuilderMethods};
 use rustc_hir as hir;
 use rustc_middle::mir::BinOp;
 use rustc_middle::ty::layout::HasTyCtxt;
-use rustc_middle::ty::{self, Ty, Unnormalized};
+use rustc_middle::ty::{self, Ty};
 use rustc_span::{Span, Symbol, sym};
 
 use crate::builder::Builder;
@@ -539,10 +539,7 @@ pub fn generic_simd_intrinsic<'a, 'gcc, 'tcx>(
         match *in_elem.kind() {
             ty::RawPtr(p_ty, _) => {
                 let metadata = p_ty.ptr_metadata_ty(bx.tcx, |ty| {
-                    bx.tcx.normalize_erasing_regions(
-                        ty::TypingEnv::fully_monomorphized(),
-                        Unnormalized::new_wip(ty),
-                    )
+                    bx.tcx.normalize_erasing_regions(ty::TypingEnv::fully_monomorphized(), ty)
                 });
                 require!(
                     metadata.is_unit(),
@@ -556,10 +553,7 @@ pub fn generic_simd_intrinsic<'a, 'gcc, 'tcx>(
         match *out_elem.kind() {
             ty::RawPtr(p_ty, _) => {
                 let metadata = p_ty.ptr_metadata_ty(bx.tcx, |ty| {
-                    bx.tcx.normalize_erasing_regions(
-                        ty::TypingEnv::fully_monomorphized(),
-                        Unnormalized::new_wip(ty),
-                    )
+                    bx.tcx.normalize_erasing_regions(ty::TypingEnv::fully_monomorphized(), ty)
                 });
                 require!(
                     metadata.is_unit(),
diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs
@@ -18,9 +18,7 @@ use rustc_hir::find_attr;
 use rustc_middle::mir::BinOp;
 use rustc_middle::ty::layout::{FnAbiOf, HasTyCtxt, HasTypingEnv, LayoutOf};
 use rustc_middle::ty::offload_meta::OffloadMetadata;
-use rustc_middle::ty::{
-    self, GenericArgsRef, Instance, SimdAlign, Ty, TyCtxt, TypingEnv, Unnormalized,
-};
+use rustc_middle::ty::{self, GenericArgsRef, Instance, SimdAlign, Ty, TyCtxt, TypingEnv};
 use rustc_middle::{bug, span_bug};
 use rustc_session::config::CrateType;
 use rustc_session::errors::feature_err;
@@ -3053,7 +3051,7 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
         match in_elem.kind() {
             ty::RawPtr(p_ty, _) => {
                 let metadata = p_ty.ptr_metadata_ty(bx.tcx, |ty| {
-                    bx.tcx.normalize_erasing_regions(bx.typing_env(), Unnormalized::new_wip(ty))
+                    bx.tcx.normalize_erasing_regions(bx.typing_env(), ty)
                 });
                 require!(
                     metadata.is_unit(),
@@ -3067,7 +3065,7 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
         match out_elem.kind() {
             ty::RawPtr(p_ty, _) => {
                 let metadata = p_ty.ptr_metadata_ty(bx.tcx, |ty| {
-                    bx.tcx.normalize_erasing_regions(bx.typing_env(), Unnormalized::new_wip(ty))
+                    bx.tcx.normalize_erasing_regions(bx.typing_env(), ty)
                 });
                 require!(
                     metadata.is_unit(),
diff --git a/compiler/rustc_const_eval/src/const_eval/valtrees.rs b/compiler/rustc_const_eval/src/const_eval/valtrees.rs
@@ -202,7 +202,7 @@ fn reconstruct_place_meta<'tcx>(
     let tail = tcx.struct_tail_raw(
         layout.ty,
         &ObligationCause::dummy(),
-        |ty| ty,
+        |ty| ty.skip_normalization(),
         || {
             let branches = last_valtree.to_branch();
             last_valtree = branches.last().unwrap().to_value().valtree;
diff --git a/compiler/rustc_const_eval/src/interpret/call.rs b/compiler/rustc_const_eval/src/interpret/call.rs
@@ -9,7 +9,7 @@ use rustc_abi::{self as abi, ExternAbi, FieldIdx, Integer, VariantIdx};
 use rustc_hir::def_id::DefId;
 use rustc_hir::find_attr;
 use rustc_middle::ty::layout::{IntegerExt, TyAndLayout};
-use rustc_middle::ty::{self, AdtDef, Instance, Ty, Unnormalized, VariantDef};
+use rustc_middle::ty::{self, AdtDef, Instance, Ty, VariantDef};
 use rustc_middle::{bug, mir, span_bug};
 use rustc_target::callconv::{ArgAbi, FnAbi};
 use tracing::field::Empty;
@@ -218,9 +218,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 // Even if `ty` is normalized, the search for the unsized tail will project
                 // to fields, which can yield non-normalized types. So we need to provide a
                 // normalization function.
-                let normalize = |ty| {
-                    self.tcx.normalize_erasing_regions(self.typing_env, Unnormalized::new_wip(ty))
-                };
+                let normalize = |ty| self.tcx.normalize_erasing_regions(self.typing_env, ty);
                 ty.ptr_metadata_ty(*self.tcx, normalize)
             };
             return interp_ok(meta_ty(caller) == meta_ty(callee));
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -1314,7 +1314,7 @@ pub(crate) fn check_static_item<'tcx>(
             let tail = tcx.struct_tail_raw(
                 item_ty,
                 &ObligationCause::dummy(),
-                |ty| wfcx.deeply_normalize(span, loc, Unnormalized::new_wip(ty)),
+                |ty| wfcx.deeply_normalize(span, loc, ty),
                 || {},
             );
 
diff --git a/compiler/rustc_hir_typeck/src/expectation.rs b/compiler/rustc_hir_typeck/src/expectation.rs
@@ -81,7 +81,7 @@ impl<'a, 'tcx> Expectation<'tcx> {
         let cause = ObligationCause::misc(span, fcx.body_id);
 
         // FIXME: This is not right, even in the old solver...
-        match fcx.tcx.struct_tail_raw(ty, &cause, |ty| ty, || {}).kind() {
+        match fcx.tcx.struct_tail_raw(ty, &cause, |ty| ty.skip_normalization(), || {}).kind() {
             ty::Slice(_) | ty::Str | ty::Dynamic(..) => ExpectRvalueLikeUnsized(ty),
             _ => ExpectHasType(ty),
         }
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
@@ -473,7 +473,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             let tail = self.tcx.struct_tail_raw(
                 ty,
                 &self.misc(span),
-                |ty| self.normalize(span, Unnormalized::new_wip(ty)),
+                |ty| self.normalize(span, ty),
                 || {},
             );
             // Sized types have static alignment, and so do slices.
diff --git a/compiler/rustc_middle/src/ty/layout.rs b/compiler/rustc_middle/src/ty/layout.rs
@@ -392,9 +392,7 @@ impl<'tcx> SizeSkeleton<'tcx> {
                 let tail = tcx.struct_tail_raw(
                     pointee,
                     &ObligationCause::dummy(),
-                    |ty| match tcx
-                        .try_normalize_erasing_regions(typing_env, Unnormalized::new_wip(ty))
-                    {
+                    |ty| match tcx.try_normalize_erasing_regions(typing_env, ty) {
                         Ok(ty) => ty,
                         Err(e) => Ty::new_error_with_message(
                             tcx,
diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs
@@ -1730,7 +1730,7 @@ impl<'tcx> Ty<'tcx> {
     pub fn ptr_metadata_ty_or_tail(
         self,
         tcx: TyCtxt<'tcx>,
-        normalize: impl FnMut(Ty<'tcx>) -> Ty<'tcx>,
+        normalize: impl FnMut(Unnormalized<'tcx, Ty<'tcx>>) -> Ty<'tcx>,
     ) -> Result<Ty<'tcx>, Ty<'tcx>> {
         let tail = tcx.struct_tail_raw(self, &ObligationCause::dummy(), normalize, || {});
         match tail.kind() {
@@ -1789,7 +1789,7 @@ impl<'tcx> Ty<'tcx> {
     pub fn ptr_metadata_ty(
         self,
         tcx: TyCtxt<'tcx>,
-        normalize: impl FnMut(Ty<'tcx>) -> Ty<'tcx>,
+        normalize: impl FnMut(Unnormalized<'tcx, Ty<'tcx>>) -> Ty<'tcx>,
     ) -> Ty<'tcx> {
         match self.ptr_metadata_ty_or_tail(tcx, normalize) {
             Ok(metadata) => metadata,
@@ -1815,7 +1815,7 @@ impl<'tcx> Ty<'tcx> {
         if pointee_ty.has_trivial_sizedness(tcx, SizedTraitKind::Sized) {
             tcx.types.unit
         } else {
-            match pointee_ty.ptr_metadata_ty_or_tail(tcx, |x| x) {
+            match pointee_ty.ptr_metadata_ty_or_tail(tcx, |x| x.skip_normalization()) {
                 Ok(metadata_ty) => metadata_ty,
                 Err(tail_ty) => {
                     let metadata_def_id = tcx.require_lang_item(LangItem::Metadata, DUMMY_SP);
diff --git a/compiler/rustc_middle/src/ty/util.rs b/compiler/rustc_middle/src/ty/util.rs
@@ -220,7 +220,7 @@ impl<'tcx> TyCtxt<'tcx> {
         tcx.struct_tail_raw(
             ty,
             &ObligationCause::dummy(),
-            |ty| tcx.normalize_erasing_regions(typing_env, Unnormalized::new_wip(ty)),
+            |ty| tcx.normalize_erasing_regions(typing_env, ty),
             || {},
         )
     }
@@ -255,7 +255,7 @@ impl<'tcx> TyCtxt<'tcx> {
         self,
         mut ty: Ty<'tcx>,
         cause: &ObligationCause<'tcx>,
-        mut normalize: impl FnMut(Ty<'tcx>) -> Ty<'tcx>,
+        mut normalize: impl FnMut(Unnormalized<'tcx, Ty<'tcx>>) -> Ty<'tcx>,
         // This is currently used to allow us to walk a ValTree
         // in lockstep with the type in order to get the ValTree branch that
         // corresponds to an unsized field.
@@ -302,7 +302,7 @@ impl<'tcx> TyCtxt<'tcx> {
                 }
 
                 ty::Alias(..) => {
-                    let normalized = normalize(ty);
+                    let normalized = normalize(Unnormalized::new(ty));
                     if ty == normalized {
                         return ty;
                     } else {
diff --git a/compiler/rustc_trait_selection/src/traits/project.rs b/compiler/rustc_trait_selection/src/traits/project.rs
@@ -1067,7 +1067,7 @@ fn assemble_candidates_from_impls<'cx, 'tcx>(
                                     obligation.param_env,
                                     obligation.cause.clone(),
                                     obligation.recursion_depth + 1,
-                                    ty,
+                                    ty.skip_norm_wip(),
                                 )
                                 .value
                             },
@@ -1506,13 +1506,13 @@ fn confirm_builtin_candidate<'cx, 'tcx>(
         assert_eq!(metadata_def_id, item_def_id);
 
         let mut obligations = PredicateObligations::new();
-        let normalize = |ty| {
+        let normalize = |ty: ty::Unnormalized<'tcx, Ty<'tcx>>| {
             normalize_with_depth_to(
                 selcx,
                 obligation.param_env,
                 obligation.cause.clone(),
                 obligation.recursion_depth + 1,
-                ty,
+                ty.skip_norm_wip(),
                 &mut obligations,
             )
         };
diff --git a/compiler/rustc_ty_utils/src/layout.rs b/compiler/rustc_ty_utils/src/layout.rs
@@ -439,7 +439,7 @@ fn layout_of_uncached<'tcx>(
                             Unnormalized::new_wip(tcx.struct_tail_raw(
                                 pointee,
                                 &ObligationCause::dummy(),
-                                |ty| ty,
+                                |ty| ty.skip_norm_wip(),
                                 || {},
                             )),
                         ) {
diff --git a/compiler/rustc_ty_utils/src/ty.rs b/compiler/rustc_ty_utils/src/ty.rs

Original file line number	Diff line number	Diff line change
`@@ -235,7 +235,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {`
`235`	`235`	`if let Err(_) =`
`236`	`236`	`self.eq_types(a, b, Locations::All(span), ConstraintCategory::BoringNoLocation)`
`237`	`237`	`{`
`238`		`- let b = self.normalize(b, Locations::All(span));`
	`238`	`+ let b = self.normalize(ty::Unnormalized::new(b), Locations::All(span));`
`239`	`239`	`self.eq_types(a, b, Locations::All(span), ConstraintCategory::BoringNoLocation)`
`240`	`240`	`.unwrap_or_else(\|terr\| {`
`241`	`241`	`span_mirbug!(`
Original file line number	Diff line number	Diff line change
`@@ -81,7 +81,7 @@ impl<'a, 'tcx> Expectation<'tcx> {`
`81`	`81`	`let cause = ObligationCause::misc(span, fcx.body_id);`
`82`	`82`
`83`	`83`	`// FIXME: This is not right, even in the old solver...`
`84`		`- match fcx.tcx.struct_tail_raw(ty, &cause, \|ty\| ty, \|\| {}).kind() {`
	`84`	`+ match fcx.tcx.struct_tail_raw(ty, &cause, \|ty\| ty.skip_normalization(), \|\| {}).kind() {`
`85`	`85`	`ty::Slice(_) \| ty::Str \| ty::Dynamic(..) => ExpectRvalueLikeUnsized(ty),`
`86`	`86`	`_ => ExpectHasType(ty),`
`87`	`87`	`}`