make as_ambig_ty/ct explicitly fallible

Author: BoxyUwU

compiler/rustc_ast_lowering/src/lib.rs

@@ -1110,16 +1110,16 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 
                                 let ct =
                                     self.lower_const_path_to_const_arg(path, res, ty.id, ty.span);
-                                return GenericArg::Const(ct.as_ambig_ct());
+                                return GenericArg::Const(ct.try_as_ambig_ct().unwrap());
                             }
                         }
                     }
                     _ => {}
                 }
-                GenericArg::Type(self.lower_ty(ty, itctx).as_ambig_ty())
+                GenericArg::Type(self.lower_ty(ty, itctx).try_as_ambig_ty().unwrap())
             }
             ast::GenericArg::Const(ct) => {
-                GenericArg::Const(self.lower_anon_const_to_const_arg(ct).as_ambig_ct())
+                GenericArg::Const(self.lower_anon_const_to_const_arg(ct).try_as_ambig_ct().unwrap())
             }
         }
     }

compiler/rustc_ast_lowering/src/path.rs

@@ -526,7 +526,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             FnRetTy::Default(_) => self.arena.alloc(self.ty_tup(*span, &[])),
         };
         let args = smallvec![GenericArg::Type(
-            self.arena.alloc(self.ty_tup(*inputs_span, inputs)).as_ambig_ty()
+            self.arena.alloc(self.ty_tup(*inputs_span, inputs)).try_as_ambig_ty().unwrap()
         )];
 
         // If we have a bound like `async Fn() -> T`, make sure that we mark the

compiler/rustc_hir/src/hir.rs

@@ -280,14 +280,16 @@ impl<'hir> ConstArg<'hir, AmbigArg> {
 }
 
 impl<'hir> ConstArg<'hir> {
-    pub fn as_ambig_ct(&self) -> &ConstArg<'hir, AmbigArg> {
-        assert!(!matches!(self.kind, ConstArgKind::Infer(_, ())));
+    pub fn try_as_ambig_ct(&self) -> Option<&ConstArg<'hir, AmbigArg>> {
+        if let ConstArgKind::Infer(_, ()) = self.kind {
+            return None;
+        }
 
         // SAFETY: `ConstArg` is `repr(C)` and `ConstArgKind` is marked `repr(u8)` so that the layout is
         // the same across different ZST type arguments. We also asserted that the `self` is
         // not a `ConstArgKind::Infer` so there is no risk of transmuting a `()` to `AmbigArg`.
         let ptr = self as *const ConstArg<'hir> as *const ConstArg<'hir, AmbigArg>;
-        unsafe { &*ptr }
+        Some(unsafe { &*ptr })
     }
 }
 
@@ -2912,14 +2914,16 @@ impl<'hir> Ty<'hir, AmbigArg> {
 }
 
 impl<'hir> Ty<'hir> {
-    pub fn as_ambig_ty(&self) -> &Ty<'hir, AmbigArg> {
-        assert!(!matches!(self.kind, TyKind::Infer(())));
+    pub fn try_as_ambig_ty(&self) -> Option<&Ty<'hir, AmbigArg>> {
+        if let TyKind::Infer(()) = self.kind {
+            return None;
+        }
 
         // SAFETY: `Ty` is `repr(C)` and `TyKind` is marked `repr(u8)` so that the layout is
         // the same across different ZST type arguments. We also asserted that the `self` is
         // not a `TyKind::Infer` so there is no risk of transmuting a `()` to `AmbigArg`.
         let ptr = self as *const Ty<'hir> as *const Ty<'hir, AmbigArg>;
-        unsafe { &*ptr }
+        Some(unsafe { &*ptr })
     }
 }
 

compiler/rustc_hir/src/intravisit.rs

@@ -901,12 +901,13 @@ pub fn walk_generic_arg<'v, V: Visitor<'v>>(
 }
 
 pub fn walk_unambig_ty<'v, V: Visitor<'v>>(visitor: &mut V, typ: &'v Ty<'v>) -> V::Result {
-    if let TyKind::Infer(()) = typ.kind {
-        try_visit!(visitor.visit_id(typ.hir_id));
-        return visitor.visit_shared_ty_const(typ.hir_id, typ.span, InferKind::Ty(typ));
+    match typ.try_as_ambig_ty() {
+        Some(ambig_ty) => visitor.visit_ty(ambig_ty),
+        None => {
+            try_visit!(visitor.visit_id(typ.hir_id));
+            visitor.visit_shared_ty_const(typ.hir_id, typ.span, InferKind::Ty(typ))
+        }
     }
-
-    visitor.visit_ty(typ.as_ambig_ty())
 }
 
 pub fn walk_ty<'v, V: Visitor<'v>>(visitor: &mut V, typ: &'v Ty<'v, AmbigArg>) -> V::Result {
@@ -964,12 +965,17 @@ pub fn walk_const_arg<'v, V: Visitor<'v>>(
     visitor: &mut V,
     const_arg: &'v ConstArg<'v>,
 ) -> V::Result {
-    if let ConstArgKind::Infer(sp, ()) = const_arg.kind {
-        try_visit!(visitor.visit_id(const_arg.hir_id));
-        return visitor.visit_shared_ty_const(const_arg.hir_id, sp, InferKind::Const(const_arg));
+    match const_arg.try_as_ambig_ct() {
+        Some(ambig_ct) => visitor.visit_const_arg(ambig_ct),
+        None => {
+            try_visit!(visitor.visit_id(const_arg.hir_id));
+            visitor.visit_shared_ty_const(
+                const_arg.hir_id,
+                const_arg.span(),
+                InferKind::Const(const_arg),
+            )
+        }
     }
-
-    visitor.visit_const_arg(const_arg.as_ambig_ct())
 }
 
 pub fn walk_ambig_const_arg<'v, V: Visitor<'v>>(

compiler/rustc_trait_selection/src/error_reporting/infer/nice_region_error/trait_impl_difference.rs

@@ -3,7 +3,7 @@
 use rustc_errors::ErrorGuaranteed;
 use rustc_hir::def::{Namespace, Res};
 use rustc_hir::def_id::DefId;
-use rustc_hir::intravisit::Visitor;
+use rustc_hir::intravisit::{Visitor, walk_ty};
 use rustc_hir::{self as hir, AmbigArg};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::traits::ObligationCauseCode;
@@ -141,9 +141,8 @@ impl<'tcx> Visitor<'tcx> for TypeParamSpanVisitor<'tcx> {
         match arg.kind {
             hir::TyKind::Ref(_, ref mut_ty) => {
                 // We don't want to suggest looking into borrowing `&T` or `&Self`.
-                match mut_ty.ty.kind {
-                    hir::TyKind::Infer(()) => (),
-                    _ => hir::intravisit::walk_ty(self, mut_ty.ty.as_ambig_ty()),
+                if let Some(ambig_ty) = mut_ty.ty.try_as_ambig_ty() {
+                    walk_ty(self, ambig_ty);
                 }
                 return;
             }