Migrate rustc_ty_utils to use SessionDiagnostic

4 files changed, 158 insertions, 94 deletions

diff --git a/compiler/rustc_ty_utils/src/consts.rs b/compiler/rustc_ty_utils/src/consts.rs
index e8ce8e6f23e..16c4d429129 100644
--- a/compiler/rustc_ty_utils/src/consts.rs
+++ b/compiler/rustc_ty_utils/src/consts.rs
@@ -11,6 +11,8 @@ use rustc_target::abi::VariantIdx;
 
 use std::iter;
 
+use crate::errors::{GenericConstantTooComplex, GenericConstantTooComplexSub};
+
 /// Destructures array, ADT or tuple constants into the constants
 /// of their fields.
 pub(crate) fn destructure_const<'tcx>(
@@ -93,26 +95,25 @@ impl<'a, 'tcx> AbstractConstBuilder<'a, 'tcx> {
         self.body.exprs[self.body_id].span
     }
 
-    fn error(&mut self, span: Span, msg: &str) -> Result<!, ErrorGuaranteed> {
-        let reported = self
-            .tcx
-            .sess
-            .struct_span_err(self.root_span(), "overly complex generic constant")
-            .span_label(span, msg)
-            .help("consider moving this anonymous constant into a `const` function")
-            .emit();
+    fn error(&mut self, sub: GenericConstantTooComplexSub) -> Result<!, ErrorGuaranteed> {
+        let reported = self.tcx.sess.emit_err(GenericConstantTooComplex {
+            span: self.root_span(),
+            maybe_supported: None,
+            sub,
+        });
 
         Err(reported)
     }
-    fn maybe_supported_error(&mut self, span: Span, msg: &str) -> Result<!, ErrorGuaranteed> {
-        let reported = self
-            .tcx
-            .sess
-            .struct_span_err(self.root_span(), "overly complex generic constant")
-            .span_label(span, msg)
-            .help("consider moving this anonymous constant into a `const` function")
-            .note("this operation may be supported in the future")
-            .emit();
+
+    fn maybe_supported_error(
+        &mut self,
+        sub: GenericConstantTooComplexSub,
+    ) -> Result<!, ErrorGuaranteed> {
+        let reported = self.tcx.sess.emit_err(GenericConstantTooComplex {
+            span: self.root_span(),
+            maybe_supported: Some(()),
+            sub,
+        });
 
         Err(reported)
     }
@@ -243,22 +244,23 @@ impl<'a, 'tcx> AbstractConstBuilder<'a, 'tcx> {
             &ExprKind::Scope { value, .. } => self.recurse_build(value)?,
             &ExprKind::PlaceTypeAscription { source, .. }
             | &ExprKind::ValueTypeAscription { source, .. } => self.recurse_build(source)?,
-            &ExprKind::Literal { lit, neg} => {
+            &ExprKind::Literal { lit, neg } => {
                 let sp = node.span;
-                let constant =
-                    match self.tcx.at(sp).lit_to_const(LitToConstInput { lit: &lit.node, ty: node.ty, neg }) {
-                        Ok(c) => c,
-                        Err(LitToConstError::Reported) => {
-                            self.tcx.const_error(node.ty)
-                        }
-                        Err(LitToConstError::TypeError) => {
-                            bug!("encountered type error in lit_to_const")
-                        }
-                    };
+                let constant = match self.tcx.at(sp).lit_to_const(LitToConstInput {
+                    lit: &lit.node,
+                    ty: node.ty,
+                    neg,
+                }) {
+                    Ok(c) => c,
+                    Err(LitToConstError::Reported) => self.tcx.const_error(node.ty),
+                    Err(LitToConstError::TypeError) => {
+                        bug!("encountered type error in lit_to_const")
+                    }
+                };
 
                 self.nodes.push(Node::Leaf(constant))
             }
-            &ExprKind::NonHirLiteral { lit , user_ty: _} => {
+            &ExprKind::NonHirLiteral { lit, user_ty: _ } => {
                 let val = ty::ValTree::from_scalar_int(lit);
                 self.nodes.push(Node::Leaf(ty::Const::from_value(self.tcx, val, node.ty)))
             }
@@ -269,19 +271,17 @@ impl<'a, 'tcx> AbstractConstBuilder<'a, 'tcx> {
             &ExprKind::NamedConst { def_id, substs, user_ty: _ } => {
                 let uneval = ty::Unevaluated::new(ty::WithOptConstParam::unknown(def_id), substs);
 
-                let constant = self.tcx.mk_const(ty::ConstS {
-                                kind: ty::ConstKind::Unevaluated(uneval),
-                                ty: node.ty,
-                            });
+                let constant = self
+                    .tcx
+                    .mk_const(ty::ConstS { kind: ty::ConstKind::Unevaluated(uneval), ty: node.ty });
 
                 self.nodes.push(Node::Leaf(constant))
             }
 
-            ExprKind::ConstParam {param, ..} => {
-                let const_param = self.tcx.mk_const(ty::ConstS {
-                        kind: ty::ConstKind::Param(*param),
-                        ty: node.ty,
-                    });
+            ExprKind::ConstParam { param, .. } => {
+                let const_param = self
+                    .tcx
+                    .mk_const(ty::ConstS { kind: ty::ConstKind::Param(*param), ty: node.ty });
                 self.nodes.push(Node::Leaf(const_param))
             }
 
@@ -312,13 +312,13 @@ impl<'a, 'tcx> AbstractConstBuilder<'a, 'tcx> {
             // }
             // ```
             ExprKind::Block { block } => {
-                if let thir::Block { stmts: box [], expr: Some(e), .. } = &self.body.blocks[*block] {
+                if let thir::Block { stmts: box [], expr: Some(e), .. } = &self.body.blocks[*block]
+                {
                     self.recurse_build(*e)?
                 } else {
-                    self.maybe_supported_error(
+                    self.maybe_supported_error(GenericConstantTooComplexSub::BlockNotSupported(
                         node.span,
-                        "blocks are not supported in generic constant",
-                    )?
+                    ))?
                 }
             }
             // `ExprKind::Use` happens when a `hir::ExprKind::Cast` is a
@@ -332,7 +332,7 @@ impl<'a, 'tcx> AbstractConstBuilder<'a, 'tcx> {
                 let arg = self.recurse_build(source)?;
                 self.nodes.push(Node::Cast(CastKind::As, arg, node.ty))
             }
-            ExprKind::Borrow{ arg, ..} => {
+            ExprKind::Borrow { arg, .. } => {
                 let arg_node = &self.body.exprs[*arg];
 
                 // Skip reborrows for now until we allow Deref/Borrow/AddressOf
@@ -341,76 +341,69 @@ impl<'a, 'tcx> AbstractConstBuilder<'a, 'tcx> {
                 if let ExprKind::Deref { arg } = arg_node.kind {
                     self.recurse_build(arg)?
                 } else {
-                    self.maybe_supported_error(
+                    self.maybe_supported_error(GenericConstantTooComplexSub::BorrowNotSupported(
                         node.span,
-                        "borrowing is not supported in generic constants",
-                    )?
+                    ))?
                 }
             }
             // FIXME(generic_const_exprs): We may want to support these.
-            ExprKind::AddressOf { .. } | ExprKind::Deref {..}=> self.maybe_supported_error(
-                node.span,
-                "dereferencing or taking the address is not supported in generic constants",
+            ExprKind::AddressOf { .. } | ExprKind::Deref { .. } => self.maybe_supported_error(
+                GenericConstantTooComplexSub::AddressAndDerefNotSupported(node.span),
             )?,
-            ExprKind::Repeat { .. } | ExprKind::Array { .. } =>  self.maybe_supported_error(
-                node.span,
-                "array construction is not supported in generic constants",
+            ExprKind::Repeat { .. } | ExprKind::Array { .. } => self.maybe_supported_error(
+                GenericConstantTooComplexSub::ArrayNotSupported(node.span),
             )?,
             ExprKind::NeverToAny { .. } => self.maybe_supported_error(
-                node.span,
-                "converting nevers to any is not supported in generic constant",
+                GenericConstantTooComplexSub::NeverToAnyNotSupported(node.span),
             )?,
             ExprKind::Tuple { .. } => self.maybe_supported_error(
-                node.span,
-                "tuple construction is not supported in generic constants",
+                GenericConstantTooComplexSub::TupleNotSupported(node.span),
             )?,
             ExprKind::Index { .. } => self.maybe_supported_error(
-                node.span,
-                "indexing is not supported in generic constant",
+                GenericConstantTooComplexSub::IndexNotSupported(node.span),
             )?,
             ExprKind::Field { .. } => self.maybe_supported_error(
-                node.span,
-                "field access is not supported in generic constant",
+                GenericConstantTooComplexSub::FieldNotSupported(node.span),
             )?,
             ExprKind::ConstBlock { .. } => self.maybe_supported_error(
-                node.span,
-                "const blocks are not supported in generic constant",
-            )?,
-            ExprKind::Adt(_) => self.maybe_supported_error(
-                node.span,
-                "struct/enum construction is not supported in generic constants",
+                GenericConstantTooComplexSub::ConstBlockNotSupported(node.span),
             )?,
+            ExprKind::Adt(_) => self
+                .maybe_supported_error(GenericConstantTooComplexSub::AdtNotSupported(node.span))?,
             // dont know if this is correct
-            ExprKind::Pointer { .. } =>
-                self.error(node.span, "pointer casts are not allowed in generic constants")?,
-            ExprKind::Yield { .. } =>
-                self.error(node.span, "generator control flow is not allowed in generic constants")?,
-            ExprKind::Continue { .. } | ExprKind::Break { .. } | ExprKind::Loop { .. } => self
-                .error(
-                    node.span,
-                    "loops and loop control flow are not supported in generic constants",
-                )?,
-            ExprKind::Box { .. } =>
-                self.error(node.span, "allocations are not allowed in generic constants")?,
+            ExprKind::Pointer { .. } => {
+                self.error(GenericConstantTooComplexSub::PointerNotSupported(node.span))?
+            }
+            ExprKind::Yield { .. } => {
+                self.error(GenericConstantTooComplexSub::YieldNotSupported(node.span))?
+            }
+            ExprKind::Continue { .. } | ExprKind::Break { .. } | ExprKind::Loop { .. } => {
+                self.error(GenericConstantTooComplexSub::LoopNotSupported(node.span))?
+            }
+            ExprKind::Box { .. } => {
+                self.error(GenericConstantTooComplexSub::BoxNotSupported(node.span))?
+            }
 
             ExprKind::Unary { .. } => unreachable!(),
             // we handle valid unary/binary ops above
-            ExprKind::Binary { .. } =>
-                self.error(node.span, "unsupported binary operation in generic constants")?,
-            ExprKind::LogicalOp { .. } =>
-                self.error(node.span, "unsupported operation in generic constants, short-circuiting operations would imply control flow")?,
+            ExprKind::Binary { .. } => {
+                self.error(GenericConstantTooComplexSub::BinaryNotSupported(node.span))?
+            }
+            ExprKind::LogicalOp { .. } => {
+                self.error(GenericConstantTooComplexSub::LogicalOpNotSupported(node.span))?
+            }
             ExprKind::Assign { .. } | ExprKind::AssignOp { .. } => {
-                self.error(node.span, "assignment is not supported in generic constants")?
+                self.error(GenericConstantTooComplexSub::AssignNotSupported(node.span))?
+            }
+            ExprKind::Closure { .. } | ExprKind::Return { .. } => {
+                self.error(GenericConstantTooComplexSub::ClosureAndReturnNotSupported(node.span))?
             }
-            ExprKind::Closure { .. } | ExprKind::Return { .. } => self.error(
-                node.span,
-                "closures and function keywords are not supported in generic constants",
-            )?,
             // let expressions imply control flow
-            ExprKind::Match { .. } | ExprKind::If { .. } | ExprKind::Let { .. } =>
-                self.error(node.span, "control flow is not supported in generic constants")?,
+            ExprKind::Match { .. } | ExprKind::If { .. } | ExprKind::Let { .. } => {
+                self.error(GenericConstantTooComplexSub::ControlFlowNotSupported(node.span))?
+            }
             ExprKind::InlineAsm { .. } => {
-                self.error(node.span, "assembly is not supported in generic constants")?
+                self.error(GenericConstantTooComplexSub::InlineAsmNotSupported(node.span))?
             }
 
             // we dont permit let stmts so `VarRef` and `UpvarRef` cant happen
@@ -418,7 +411,7 @@ impl<'a, 'tcx> AbstractConstBuilder<'a, 'tcx> {
             | ExprKind::UpvarRef { .. }
             | ExprKind::StaticRef { .. }
             | ExprKind::ThreadLocalRef(_) => {
-                self.error(node.span, "unsupported operation in generic constant")?
+                self.error(GenericConstantTooComplexSub::OperationNotSupported(node.span))?
             }
         })
     }
diff --git a/compiler/rustc_ty_utils/src/errors.rs b/compiler/rustc_ty_utils/src/errors.rs
new file mode 100644
index 00000000000..3a8ef96c991
--- /dev/null
+++ b/compiler/rustc_ty_utils/src/errors.rs
@@ -0,0 +1,69 @@
+//! Errors emitted by ty_utils
+
+use rustc_macros::{SessionDiagnostic, SessionSubdiagnostic};
+use rustc_middle::ty::Ty;
+use rustc_span::Span;
+
+#[derive(SessionDiagnostic)]
+#[diag(ty_utils::needs_drop_overflow)]
+pub struct NeedsDropOverflow<'tcx> {
+    pub query_ty: Ty<'tcx>,
+}
+
+#[derive(SessionDiagnostic)]
+#[diag(ty_utils::generic_constant_too_complex)]
+#[help]
+pub struct GenericConstantTooComplex {
+    #[primary_span]
+    pub span: Span,
+    #[note(ty_utils::maybe_supported)]
+    pub maybe_supported: Option<()>,
+    #[subdiagnostic]
+    pub sub: GenericConstantTooComplexSub,
+}
+
+#[derive(SessionSubdiagnostic)]
+pub enum GenericConstantTooComplexSub {
+    #[label(ty_utils::borrow_not_supported)]
+    BorrowNotSupported(#[primary_span] Span),
+    #[label(ty_utils::address_and_deref_not_supported)]
+    AddressAndDerefNotSupported(#[primary_span] Span),
+    #[label(ty_utils::array_not_supported)]
+    ArrayNotSupported(#[primary_span] Span),
+    #[label(ty_utils::block_not_supported)]
+    BlockNotSupported(#[primary_span] Span),
+    #[label(ty_utils::never_to_any_not_supported)]
+    NeverToAnyNotSupported(#[primary_span] Span),
+    #[label(ty_utils::tuple_not_supported)]
+    TupleNotSupported(#[primary_span] Span),
+    #[label(ty_utils::index_not_supported)]
+    IndexNotSupported(#[primary_span] Span),
+    #[label(ty_utils::field_not_supported)]
+    FieldNotSupported(#[primary_span] Span),
+    #[label(ty_utils::const_block_not_supported)]
+    ConstBlockNotSupported(#[primary_span] Span),
+    #[label(ty_utils::adt_not_supported)]
+    AdtNotSupported(#[primary_span] Span),
+    #[label(ty_utils::pointer_not_supported)]
+    PointerNotSupported(#[primary_span] Span),
+    #[label(ty_utils::yield_not_supported)]
+    YieldNotSupported(#[primary_span] Span),
+    #[label(ty_utils::loop_not_supported)]
+    LoopNotSupported(#[primary_span] Span),
+    #[label(ty_utils::box_not_supported)]
+    BoxNotSupported(#[primary_span] Span),
+    #[label(ty_utils::binary_not_supported)]
+    BinaryNotSupported(#[primary_span] Span),
+    #[label(ty_utils::logical_op_not_supported)]
+    LogicalOpNotSupported(#[primary_span] Span),
+    #[label(ty_utils::assign_not_supported)]
+    AssignNotSupported(#[primary_span] Span),
+    #[label(ty_utils::closure_and_return_not_supported)]
+    ClosureAndReturnNotSupported(#[primary_span] Span),
+    #[label(ty_utils::control_flow_not_supported)]
+    ControlFlowNotSupported(#[primary_span] Span),
+    #[label(ty_utils::inline_asm_not_supported)]
+    InlineAsmNotSupported(#[primary_span] Span),
+    #[label(ty_utils::operation_not_supported)]
+    OperationNotSupported(#[primary_span] Span),
+}
diff --git a/compiler/rustc_ty_utils/src/lib.rs b/compiler/rustc_ty_utils/src/lib.rs
index 55d82693994..6931b15b1ba 100644
--- a/compiler/rustc_ty_utils/src/lib.rs
+++ b/compiler/rustc_ty_utils/src/lib.rs
@@ -10,6 +10,8 @@
 #![feature(never_type)]
 #![feature(box_patterns)]
 #![recursion_limit = "256"]
+#![deny(rustc::untranslatable_diagnostic)]
+#![deny(rustc::diagnostic_outside_of_impl)]
 
 #[macro_use]
 extern crate rustc_middle;
@@ -21,6 +23,7 @@ use rustc_middle::ty::query::Providers;
 mod assoc;
 mod common_traits;
 mod consts;
+mod errors;
 mod implied_bounds;
 pub mod instance;
 mod needs_drop;
diff --git a/compiler/rustc_ty_utils/src/needs_drop.rs b/compiler/rustc_ty_utils/src/needs_drop.rs
index 9ad44d14d61..ab5a3d8ae48 100644
--- a/compiler/rustc_ty_utils/src/needs_drop.rs
+++ b/compiler/rustc_ty_utils/src/needs_drop.rs
@@ -9,6 +9,8 @@ use rustc_middle::ty::{self, EarlyBinder, Ty, TyCtxt};
 use rustc_session::Limit;
 use rustc_span::{sym, DUMMY_SP};
 
+use crate::errors::NeedsDropOverflow;
+
 type NeedsDropResult<T> = Result<T, AlwaysRequiresDrop>;
 
 fn needs_drop_raw<'tcx>(tcx: TyCtxt<'tcx>, query: ty::ParamEnvAnd<'tcx, Ty<'tcx>>) -> bool {
@@ -90,10 +92,7 @@ where
             if !self.recursion_limit.value_within_limit(level) {
                 // Not having a `Span` isn't great. But there's hopefully some other
                 // recursion limit error as well.
-                tcx.sess.span_err(
-                    DUMMY_SP,
-                    &format!("overflow while checking whether `{}` requires drop", self.query_ty),
-                );
+                tcx.sess.emit_err(NeedsDropOverflow { query_ty: self.query_ty });
                 return Some(Err(AlwaysRequiresDrop));
             }