non-fatal overflow

Author: lcnr

compiler/rustc_codegen_llvm/src/intrinsic.rs

@@ -1745,19 +1745,23 @@ unsupported {} from `{}` with element `{}` of size `{}` to `{}`"#,
 
         match in_elem.kind() {
             ty::RawPtr(p) => {
-                let (metadata, check_sized) = p.ty.ptr_metadata_ty(bx.tcx, |ty| {
-                    bx.tcx.normalize_erasing_regions(ty::ParamEnv::reveal_all(), ty)
-                });
+                let (metadata, check_sized) =
+                    p.ty.ptr_metadata_ty(bx.tcx, |ty| {
+                        Ok(bx.tcx.normalize_erasing_regions(ty::ParamEnv::reveal_all(), ty))
+                    })
+                    .unwrap();
                 assert!(!check_sized); // we are in codegen, so we shouldn't see these types
                 require!(metadata.is_unit(), "cannot cast fat pointer `{}`", in_elem)
             }
             _ => return_error!("expected pointer, got `{}`", in_elem),
         }
         match out_elem.kind() {
             ty::RawPtr(p) => {
-                let (metadata, check_sized) = p.ty.ptr_metadata_ty(bx.tcx, |ty| {
-                    bx.tcx.normalize_erasing_regions(ty::ParamEnv::reveal_all(), ty)
-                });
+                let (metadata, check_sized) =
+                    p.ty.ptr_metadata_ty(bx.tcx, |ty| {
+                        Ok(bx.tcx.normalize_erasing_regions(ty::ParamEnv::reveal_all(), ty))
+                    })
+                    .unwrap();
                 assert!(!check_sized); // we are in codegen, so we shouldn't see these types
                 require!(metadata.is_unit(), "cannot cast to fat pointer `{}`", out_elem)
             }

compiler/rustc_const_eval/src/const_eval/valtrees.rs

@@ -177,15 +177,17 @@ fn get_info_on_unsized_field<'tcx>(
     tcx: TyCtxt<'tcx>,
 ) -> (Ty<'tcx>, usize) {
     let mut last_valtree = valtree;
-    let tail = tcx.struct_tail_with_normalize(
-        ty,
-        |ty| ty,
-        || {
-            let branches = last_valtree.unwrap_branch();
-            last_valtree = branches[branches.len() - 1];
-            debug!(?branches, ?last_valtree);
-        },
-    );
+    let tail = tcx
+        .struct_tail_with_normalize(
+            ty,
+            |ty| Ok(ty),
+            || {
+                let branches = last_valtree.unwrap_branch();
+                last_valtree = branches[branches.len() - 1];
+                debug!(?branches, ?last_valtree);
+            },
+        )
+        .unwrap();
     let unsized_inner_ty = match tail.kind() {
         ty::Slice(t) => *t,
         ty::Str => tail,

compiler/rustc_const_eval/src/transform/check_consts/check.rs

@@ -770,14 +770,14 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
                     }
 
                     match implsrc {
-                        Ok(Some(ImplSource::Param(_, ty::BoundConstness::ConstIfConst))) => {
+                        Ok(Ok(ImplSource::Param(_, ty::BoundConstness::ConstIfConst))) => {
                             debug!(
                                 "const_trait_impl: provided {:?} via where-clause in {:?}",
                                 trait_ref, param_env
                             );
                             return;
                         }
-                        Ok(Some(ImplSource::UserDefined(data))) => {
+                        Ok(Ok(ImplSource::UserDefined(data))) => {
                             let callee_name = tcx.item_name(callee);
                             if let Some(&did) = tcx
                                 .associated_item_def_ids(data.impl_def_id)

compiler/rustc_const_eval/src/transform/check_consts/ops.rs

@@ -160,7 +160,7 @@ impl<'tcx> NonConstOp<'tcx> for FnCallNonConst<'tcx> {
                     let mut selcx = SelectionContext::new(&infcx);
                     let implsrc = selcx.select(&obligation);
 
-                    if let Ok(Some(ImplSource::UserDefined(data))) = implsrc {
+                    if let Ok(Ok(ImplSource::UserDefined(data))) = implsrc {
                         let span = tcx.def_span(data.impl_def_id);
                         err.span_note(span, "impl defined here, but it is not `const`");
                     }

compiler/rustc_const_eval/src/transform/check_consts/qualifs.rs

@@ -170,7 +170,7 @@ impl Qualif for NeedsNonConstDrop {
 
         let infcx = cx.tcx.infer_ctxt().build();
         let mut selcx = SelectionContext::new(&infcx);
-        let Some(impl_src) = selcx.select(&obligation).ok().flatten() else {
+        let Ok(Ok(impl_src)) = selcx.select(&obligation) else {
             // If we couldn't select a const destruct candidate, then it's bad
             return true;
         };

compiler/rustc_data_structures/src/obligation_forest/mod.rs

@@ -107,6 +107,12 @@ pub trait ObligationProcessor {
         obligation: &mut Self::Obligation,
     ) -> ProcessResult<Self::Obligation, Self::Error>;
 
+    fn update_obligation_depth(
+        &mut self,
+        obligation: &Self::Obligation,
+        child: &mut Self::Obligation,
+    );
+
     /// As we do the cycle check, we invoke this callback when we
     /// encounter an actual cycle. `cycle` is an iterator that starts
     /// at the start of the cycle in the stack and walks **toward the
@@ -375,13 +381,16 @@ impl<O: ForestObligation> ObligationForest<O> {
     }
 
     /// Converts all remaining obligations to the given error.
-    pub fn to_errors<E: Clone>(&mut self, error: E) -> Vec<Error<O, E>> {
+    pub fn to_errors<E>(&mut self, mut mk_error: impl FnMut(&O) -> E) -> Vec<Error<O, E>> {
         let errors = self
             .nodes
             .iter()
             .enumerate()
             .filter(|(_index, node)| node.state.get() == NodeState::Pending)
-            .map(|(index, _node)| Error { error: error.clone(), backtrace: self.error_at(index) })
+            .map(|(index, node)| Error {
+                error: mk_error(&node.obligation),
+                backtrace: self.error_at(index),
+            })
             .collect();
 
         self.compress(|_| assert!(false));
@@ -447,11 +456,15 @@ impl<O: ForestObligation> ObligationForest<O> {
                     ProcessResult::Unchanged => {
                         // No change in state.
                     }
-                    ProcessResult::Changed(children) => {
+                    ProcessResult::Changed(mut children) => {
                         // We are not (yet) stalled.
                         has_changed = true;
                         node.state.set(NodeState::Success);
 
+                        for child in &mut children {
+                            processor.update_obligation_depth(&node.obligation, child);
+                        }
+
                         for child in children {
                             let st = self.register_obligation_at(child, Some(index));
                             if let Err(()) = st {

compiler/rustc_data_structures/src/obligation_forest/tests.rs

@@ -70,6 +70,8 @@ where
         true
     }
 
+    fn update_obligation_depth(&mut self, _: &Self::Obligation, _: &mut Self::Obligation) {}
+
     fn process_obligation(
         &mut self,
         obligation: &mut Self::Obligation,
@@ -256,7 +258,7 @@ fn to_errors_no_throw() {
     ));
     assert_eq!(ok.len(), 0);
     assert_eq!(err.len(), 0);
-    let errors = forest.to_errors(());
+    let errors = forest.to_errors(|_| ());
     assert_eq!(errors[0].backtrace, vec!["A.1", "A"]);
     assert_eq!(errors[1].backtrace, vec!["A.2", "A"]);
     assert_eq!(errors[2].backtrace, vec!["A.3", "A"]);
@@ -308,7 +310,7 @@ fn diamond() {
     assert_eq!(ok, vec!["A", "A.1", "A.2", "D"]);
     assert_eq!(err.len(), 0);
 
-    let errors = forest.to_errors(());
+    let errors = forest.to_errors(|_| ());
     assert_eq!(errors.len(), 0);
 
     forest.register_obligation("A'");
@@ -353,7 +355,7 @@ fn diamond() {
         vec![super::Error { error: "operation failed", backtrace: vec!["D'", "A'.1", "A'"] }]
     );
 
-    let errors = forest.to_errors(());
+    let errors = forest.to_errors(|_| ());
     assert_eq!(errors.len(), 0);
 }
 
@@ -446,7 +448,7 @@ fn orphan() {
     assert_eq!(ok.len(), 0);
     assert_eq!(err, vec![super::Error { error: "D is dead", backtrace: vec!["D"] }]);
 
-    let errors = forest.to_errors(());
+    let errors = forest.to_errors(|_| ());
     assert_eq!(errors.len(), 0);
 }
 

compiler/rustc_hir_analysis/src/impl_wf_check/min_specialization.rs

@@ -74,6 +74,7 @@ use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_infer::infer::outlives::env::OutlivesEnvironment;
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_infer::traits::specialization_graph::Node;
+use rustc_infer::traits::Overflow;
 use rustc_middle::ty::subst::{GenericArg, InternalSubsts, SubstsRef};
 use rustc_middle::ty::trait_def::TraitSpecializationKind;
 use rustc_middle::ty::{self, TyCtxt, TypeVisitable};
@@ -377,7 +378,9 @@ fn check_predicates<'tcx>(
             0,
             arg,
             span,
+            true,
         )
+        .unwrap_or_else(|Overflow| bug!("impossible non-fatal overflow"))
         .unwrap();
 
         assert!(!obligations.needs_infer());

compiler/rustc_hir_typeck/src/coercion.rs

@@ -671,7 +671,8 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
             };
             match selcx.select(&obligation.with(trait_pred)) {
                 // Uncertain or unimplemented.
-                Ok(None) => {
+                Ok(Err(true)) => self.err_ctxt().report_overflow_error(&obligation, true),
+                Ok(Err(false)) => {
                     if trait_pred.def_id() == unsize_did {
                         let trait_pred = self.resolve_vars_if_possible(trait_pred);
                         let self_ty = trait_pred.skip_binder().self_ty();
@@ -712,7 +713,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
                     // be silent, as it causes a type mismatch later.
                 }
 
-                Ok(Some(impl_source)) => queue.extend(impl_source.nested_obligations()),
+                Ok(Ok(impl_source)) => queue.extend(impl_source.nested_obligations()),
             }
         }
 

compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs

@@ -2159,7 +2159,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                             }),
                         );
                         match SelectionContext::new(&self).select(&obligation) {
-                            Ok(Some(traits::ImplSource::UserDefined(impl_source))) => {
+                            Ok(Ok(traits::ImplSource::UserDefined(impl_source))) => {
                                 Some(impl_source.impl_def_id)
                             }
                             _ => None,