Properly bubble up ambiguity in normalize query

Author: compiler-errors

compiler/rustc_middle/src/traits/query.rs

@@ -109,6 +109,33 @@ impl<'tcx> From<TypeError<'tcx>> for NoSolution {
     }
 }
 
+#[derive(Copy, Clone, Debug, HashStable)]
+pub enum NoSolutionOrAmbiguous {
+    NoSolution,
+    Ambiguous,
+}
+
+impl NoSolutionOrAmbiguous {
+    pub fn expect_unambiguous(self) -> NoSolution {
+        match self {
+            NoSolutionOrAmbiguous::NoSolution => NoSolution,
+            NoSolutionOrAmbiguous::Ambiguous => bug!("unexpected ambiguity"),
+        }
+    }
+}
+
+impl From<NoSolution> for NoSolutionOrAmbiguous {
+    fn from(_: NoSolution) -> NoSolutionOrAmbiguous {
+        NoSolutionOrAmbiguous::NoSolution
+    }
+}
+
+impl<'tcx> From<TypeError<'tcx>> for NoSolutionOrAmbiguous {
+    fn from(_: TypeError<'tcx>) -> NoSolutionOrAmbiguous {
+        NoSolutionOrAmbiguous::NoSolution
+    }
+}
+
 #[derive(Clone, Debug, Default, HashStable, TypeFoldable, TypeVisitable, Lift)]
 pub struct DropckOutlivesResult<'tcx> {
     pub kinds: Vec<GenericArg<'tcx>>,

compiler/rustc_trait_selection/src/traits/query/normalize.rs

@@ -17,12 +17,12 @@ use rustc_middle::ty::{self, Ty, TyCtxt, TypeVisitor};
 
 use std::ops::ControlFlow;
 
-use super::NoSolution;
+use super::NoSolutionOrAmbiguous;
 
 pub use rustc_middle::traits::query::NormalizationResult;
 
 pub trait AtExt<'tcx> {
-    fn normalize<T>(&self, value: T) -> Result<Normalized<'tcx, T>, NoSolution>
+    fn normalize<T>(&self, value: T) -> Result<Normalized<'tcx, T>, NoSolutionOrAmbiguous>
     where
         T: TypeFoldable<'tcx>;
 }
@@ -41,7 +41,7 @@ impl<'cx, 'tcx> AtExt<'tcx> for At<'cx, 'tcx> {
     /// normalizing, but for now should be used only when we actually
     /// know that normalization will succeed, since error reporting
     /// and other details are still "under development".
-    fn normalize<T>(&self, value: T) -> Result<Normalized<'tcx, T>, NoSolution>
+    fn normalize<T>(&self, value: T) -> Result<Normalized<'tcx, T>, NoSolutionOrAmbiguous>
     where
         T: TypeFoldable<'tcx>,
     {
@@ -96,7 +96,7 @@ impl<'cx, 'tcx> AtExt<'tcx> for At<'cx, 'tcx> {
             std::any::type_name::<T>(),
             normalizer.obligations,
         );
-        result.map(|value| Normalized { value, obligations: normalizer.obligations })
+        Ok(Normalized { value: result?, obligations: normalizer.obligations })
     }
 }
 
@@ -163,7 +163,7 @@ struct QueryNormalizer<'cx, 'tcx> {
 }
 
 impl<'cx, 'tcx> FallibleTypeFolder<'tcx> for QueryNormalizer<'cx, 'tcx> {
-    type Error = NoSolution;
+    type Error = NoSolutionOrAmbiguous;
 
     fn tcx<'c>(&'c self) -> TyCtxt<'tcx> {
         self.infcx.tcx
@@ -253,7 +253,7 @@ impl<'cx, 'tcx> FallibleTypeFolder<'tcx> for QueryNormalizer<'cx, 'tcx> {
                 let result = tcx.normalize_projection_ty(c_data)?;
                 // We don't expect ambiguity.
                 if result.is_ambiguous() {
-                    bug!("unexpected ambiguity: {:?} {:?}", c_data, result);
+                    return Err(NoSolutionOrAmbiguous::Ambiguous);
                 }
                 let InferOk { value: result, obligations } =
                     self.infcx.instantiate_query_response_and_region_obligations(
@@ -296,7 +296,7 @@ impl<'cx, 'tcx> FallibleTypeFolder<'tcx> for QueryNormalizer<'cx, 'tcx> {
                 let result = tcx.normalize_projection_ty(c_data)?;
                 // We don't expect ambiguity.
                 if result.is_ambiguous() {
-                    bug!("unexpected ambiguity: {:?} {:?}", c_data, result);
+                    return Err(NoSolutionOrAmbiguous::Ambiguous);
                 }
                 let InferOk { value: result, obligations } =
                     self.infcx.instantiate_query_response_and_region_obligations(

compiler/rustc_traits/src/dropck_outlives.rs

@@ -131,8 +131,8 @@ fn dropck_outlives<'tcx>(
 
                 // We don't actually expect to fail to normalize.
                 // That implies a WF error somewhere else.
-                Err(NoSolution) => {
-                    return Err(NoSolution);
+                Err(err) => {
+                    return Err(err.expect_unambiguous());
                 }
             }
         }

compiler/rustc_traits/src/normalize_erasing_regions.rs

@@ -48,7 +48,7 @@ fn try_normalize_after_erasing_regions<'tcx, T: TypeFoldable<'tcx> + PartialEq +
             debug_assert!(!erased.needs_infer(), "{:?}", erased);
             Ok(erased)
         }
-        Err(NoSolution) => Err(NoSolution),
+        Err(err) => Err(err.expect_unambiguous()),
     }
 }
 

compiler/rustc_traits/src/type_op.rs

@@ -218,8 +218,10 @@ where
     T: fmt::Debug + TypeFoldable<'tcx> + Lift<'tcx>,
 {
     let (param_env, Normalize { value }) = key.into_parts();
-    let Normalized { value, obligations } =
-        infcx.at(&ObligationCause::dummy(), param_env).normalize(value)?;
+    let Normalized { value, obligations } = infcx
+        .at(&ObligationCause::dummy(), param_env)
+        .normalize(value)
+        .map_err(|err| err.expect_unambiguous())?;
     fulfill_cx.register_predicate_obligations(infcx, obligations);
     Ok(value)
 }

src/test/rustdoc/issue-102835.rs

@@ -0,0 +1,21 @@
+// compile-flags: -Znormalize-docs
+
+#![feature(type_alias_impl_trait)]
+
+trait Allocator {
+    type Buffer;
+}
+
+struct DefaultAllocator;
+
+impl<T> Allocator for DefaultAllocator {
+    type Buffer = ();
+}
+
+type A = impl Fn(<DefaultAllocator as Allocator>::Buffer);
+
+fn foo() -> A {
+    |_| ()
+}
+
+fn main() {}