1use std::path::{Path, PathBuf};
2
3use rustc_macros::Diagnostic;
4use rustc_span::{Ident, Span, Symbol};
5
6#[derive(const _: () =
{
impl<'_sess, G> rustc_errors::Diagnostic<'_sess, G> for
UnrecognizedDepNode where G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
UnrecognizedDepNode { span: __binding_0, name: __binding_1 }
=> {
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_unrecognized_depnode);
;
diag.arg("name", __binding_1);
diag.span(__binding_0);
diag
}
}
}
}
};Diagnostic)]
7#[diag(incremental_unrecognized_depnode)]
8pub(crate) struct UnrecognizedDepNode {
9 #[primary_span]
10 pub span: Span,
11 pub name: Symbol,
12}
13
14#[derive(const _: () =
{
impl<'_sess, G> rustc_errors::Diagnostic<'_sess, G> for MissingDepNode
where G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
MissingDepNode { span: __binding_0 } => {
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_missing_depnode);
;
diag.span(__binding_0);
diag
}
}
}
}
};Diagnostic)]
15#[diag(incremental_missing_depnode)]
16pub(crate) struct MissingDepNode {
17 #[primary_span]
18 pub span: Span,
19}
20
21#[derive(const _: () =
{
impl<'_sess, G> rustc_errors::Diagnostic<'_sess, G> for
MissingIfThisChanged where G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
MissingIfThisChanged { span: __binding_0 } => {
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_missing_if_this_changed);
;
diag.span(__binding_0);
diag
}
}
}
}
};Diagnostic)]
22#[diag(incremental_missing_if_this_changed)]
23pub(crate) struct MissingIfThisChanged {
24 #[primary_span]
25 pub span: Span,
26}
27
28#[derive(const _: () =
{
impl<'_sess, G> rustc_errors::Diagnostic<'_sess, G> for Ok where
G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
Ok { span: __binding_0 } => {
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_ok);
;
diag.span(__binding_0);
diag
}
}
}
}
};Diagnostic)]
29#[diag(incremental_ok)]
30pub(crate) struct Ok {
31 #[primary_span]
32 pub span: Span,
33}
34
35#[derive(const _: () =
{
impl<'_sess, G> rustc_errors::Diagnostic<'_sess, G> for NoPath where
G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
NoPath {
span: __binding_0, target: __binding_1, source: __binding_2
} => {
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_no_path);
;
diag.arg("target", __binding_1);
diag.arg("source", __binding_2);
diag.span(__binding_0);
diag
}
}
}
}
};Diagnostic)]
36#[diag(incremental_no_path)]
37pub(crate) struct NoPath {
38 #[primary_span]
39 pub span: Span,
40 pub target: Symbol,
41 pub source: String,
42}
43
44#[derive(const _: () =
{
impl<'_sess, 'a, G> rustc_errors::Diagnostic<'_sess, G> for
AssertionAuto<'a> where G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
AssertionAuto {
span: __binding_0, name: __binding_1, e: __binding_2 } => {
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_assertion_auto);
;
diag.arg("name", __binding_1);
diag.arg("e", __binding_2);
diag.span(__binding_0);
diag
}
}
}
}
};Diagnostic)]
45#[diag(incremental_assertion_auto)]
46pub(crate) struct AssertionAuto<'a> {
47 #[primary_span]
48 pub span: Span,
49 pub name: &'a str,
50 pub e: &'a str,
51}
52
53#[derive(const _: () =
{
impl<'_sess, G> rustc_errors::Diagnostic<'_sess, G> for
UndefinedCleanDirtyItem where G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
UndefinedCleanDirtyItem {
span: __binding_0, kind: __binding_1 } => {
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_undefined_clean_dirty_assertions_item);
;
diag.arg("kind", __binding_1);
diag.span(__binding_0);
diag
}
}
}
}
};Diagnostic)]
54#[diag(incremental_undefined_clean_dirty_assertions_item)]
55pub(crate) struct UndefinedCleanDirtyItem {
56 #[primary_span]
57 pub span: Span,
58 pub kind: String,
59}
60
61#[derive(const _: () =
{
impl<'_sess, G> rustc_errors::Diagnostic<'_sess, G> for
UndefinedCleanDirty where G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
UndefinedCleanDirty { span: __binding_0, kind: __binding_1 }
=> {
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_undefined_clean_dirty_assertions);
;
diag.arg("kind", __binding_1);
diag.span(__binding_0);
diag
}
}
}
}
};Diagnostic)]
62#[diag(incremental_undefined_clean_dirty_assertions)]
63pub(crate) struct UndefinedCleanDirty {
64 #[primary_span]
65 pub span: Span,
66 pub kind: String,
67}
68
69#[derive(const _: () =
{
impl<'_sess, 'a, G> rustc_errors::Diagnostic<'_sess, G> for
RepeatedDepNodeLabel<'a> where G: rustc_errors::EmissionGuarantee
{
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
RepeatedDepNodeLabel { span: __binding_0, label: __binding_1
} => {
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_repeated_depnode_label);
;
diag.arg("label", __binding_1);
diag.span(__binding_0);
diag
}
}
}
}
};Diagnostic)]
70#[diag(incremental_repeated_depnode_label)]
71pub(crate) struct RepeatedDepNodeLabel<'a> {
72 #[primary_span]
73 pub span: Span,
74 pub label: &'a str,
75}
76
77#[derive(const _: () =
{
impl<'_sess, 'a, G> rustc_errors::Diagnostic<'_sess, G> for
UnrecognizedDepNodeLabel<'a> where
G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
UnrecognizedDepNodeLabel {
span: __binding_0, label: __binding_1 } => {
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_unrecognized_depnode_label);
;
diag.arg("label", __binding_1);
diag.span(__binding_0);
diag
}
}
}
}
};Diagnostic)]
78#[diag(incremental_unrecognized_depnode_label)]
79pub(crate) struct UnrecognizedDepNodeLabel<'a> {
80 #[primary_span]
81 pub span: Span,
82 pub label: &'a str,
83}
84
85#[derive(const _: () =
{
impl<'_sess, 'a, G> rustc_errors::Diagnostic<'_sess, G> for
NotDirty<'a> where G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
NotDirty { span: __binding_0, dep_node_str: __binding_1 } =>
{
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_not_dirty);
;
diag.arg("dep_node_str", __binding_1);
diag.span(__binding_0);
diag
}
}
}
}
};Diagnostic)]
86#[diag(incremental_not_dirty)]
87pub(crate) struct NotDirty<'a> {
88 #[primary_span]
89 pub span: Span,
90 pub dep_node_str: &'a str,
91}
92
93#[derive(const _: () =
{
impl<'_sess, 'a, G> rustc_errors::Diagnostic<'_sess, G> for
NotClean<'a> where G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
NotClean { span: __binding_0, dep_node_str: __binding_1 } =>
{
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_not_clean);
;
diag.arg("dep_node_str", __binding_1);
diag.span(__binding_0);
diag
}
}
}
}
};Diagnostic)]
94#[diag(incremental_not_clean)]
95pub(crate) struct NotClean<'a> {
96 #[primary_span]
97 pub span: Span,
98 pub dep_node_str: &'a str,
99}
100
101#[derive(const _: () =
{
impl<'_sess, 'a, G> rustc_errors::Diagnostic<'_sess, G> for
NotLoaded<'a> where G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
NotLoaded { span: __binding_0, dep_node_str: __binding_1 }
=> {
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_not_loaded);
;
diag.arg("dep_node_str", __binding_1);
diag.span(__binding_0);
diag
}
}
}
}
};Diagnostic)]
102#[diag(incremental_not_loaded)]
103pub(crate) struct NotLoaded<'a> {
104 #[primary_span]
105 pub span: Span,
106 pub dep_node_str: &'a str,
107}
108
109#[derive(const _: () =
{
impl<'_sess, G> rustc_errors::Diagnostic<'_sess, G> for
UnknownRustcCleanArgument where G: rustc_errors::EmissionGuarantee
{
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
UnknownRustcCleanArgument { span: __binding_0 } => {
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_unknown_rustc_clean_argument);
;
diag.span(__binding_0);
diag
}
}
}
}
};Diagnostic)]
110#[diag(incremental_unknown_rustc_clean_argument)]
111pub(crate) struct UnknownRustcCleanArgument {
112 #[primary_span]
113 pub span: Span,
114}
115
116#[derive(const _: () =
{
impl<'_sess, G> rustc_errors::Diagnostic<'_sess, G> for NoCfg where
G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
NoCfg { span: __binding_0 } => {
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_no_cfg);
;
diag.span(__binding_0);
diag
}
}
}
}
};Diagnostic)]
117#[diag(incremental_no_cfg)]
118pub(crate) struct NoCfg {
119 #[primary_span]
120 pub span: Span,
121}
122
123#[derive(const _: () =
{
impl<'_sess, G> rustc_errors::Diagnostic<'_sess, G> for
AssociatedValueExpectedFor where
G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
AssociatedValueExpectedFor {
span: __binding_0, ident: __binding_1 } => {
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_associated_value_expected_for);
;
diag.arg("ident", __binding_1);
diag.span(__binding_0);
diag
}
}
}
}
};Diagnostic)]
124#[diag(incremental_associated_value_expected_for)]
125pub(crate) struct AssociatedValueExpectedFor {
126 #[primary_span]
127 pub span: Span,
128 pub ident: Ident,
129}
130
131#[derive(const _: () =
{
impl<'_sess, G> rustc_errors::Diagnostic<'_sess, G> for
AssociatedValueExpected where G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
AssociatedValueExpected { span: __binding_0 } => {
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_associated_value_expected);
;
diag.span(__binding_0);
diag
}
}
}
}
};Diagnostic)]
132#[diag(incremental_associated_value_expected)]
133pub(crate) struct AssociatedValueExpected {
134 #[primary_span]
135 pub span: Span,
136}
137
138#[derive(const _: () =
{
impl<'_sess, G> rustc_errors::Diagnostic<'_sess, G> for UncheckedClean
where G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
UncheckedClean { span: __binding_0 } => {
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_unchecked_clean);
;
diag.span(__binding_0);
diag
}
}
}
}
};Diagnostic)]
139#[diag(incremental_unchecked_clean)]
140pub(crate) struct UncheckedClean {
141 #[primary_span]
142 pub span: Span,
143}
144
145#[derive(const _: () =
{
impl<'_sess, 'a, G> rustc_errors::Diagnostic<'_sess, G> for
DeleteOld<'a> where G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
DeleteOld {
name: __binding_0, path: __binding_1, err: __binding_2 } =>
{
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_delete_old);
;
diag.arg("name", __binding_0);
diag.arg("path", __binding_1);
diag.arg("err", __binding_2);
diag
}
}
}
}
};Diagnostic)]
146#[diag(incremental_delete_old)]
147pub(crate) struct DeleteOld<'a> {
148 pub name: &'a str,
149 pub path: PathBuf,
150 pub err: std::io::Error,
151}
152
153#[derive(const _: () =
{
impl<'_sess, 'a, G> rustc_errors::Diagnostic<'_sess, G> for
CreateNew<'a> where G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
CreateNew {
name: __binding_0, path: __binding_1, err: __binding_2 } =>
{
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_create_new);
;
diag.arg("name", __binding_0);
diag.arg("path", __binding_1);
diag.arg("err", __binding_2);
diag
}
}
}
}
};Diagnostic)]
154#[diag(incremental_create_new)]
155pub(crate) struct CreateNew<'a> {
156 pub name: &'a str,
157 pub path: PathBuf,
158 pub err: std::io::Error,
159}
160
161#[derive(const _: () =
{
impl<'_sess, 'a, G> rustc_errors::Diagnostic<'_sess, G> for
WriteNew<'a> where G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
WriteNew {
name: __binding_0, path: __binding_1, err: __binding_2 } =>
{
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_write_new);
;
diag.arg("name", __binding_0);
diag.arg("path", __binding_1);
diag.arg("err", __binding_2);
diag
}
}
}
}
};Diagnostic)]
162#[diag(incremental_write_new)]
163pub(crate) struct WriteNew<'a> {
164 pub name: &'a str,
165 pub path: PathBuf,
166 pub err: std::io::Error,
167}
168
169#[derive(const _: () =
{
impl<'_sess, G> rustc_errors::Diagnostic<'_sess, G> for
CanonicalizePath where G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
CanonicalizePath { path: __binding_0, err: __binding_1 } =>
{
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_canonicalize_path);
;
diag.arg("path", __binding_0);
diag.arg("err", __binding_1);
diag
}
}
}
}
};Diagnostic)]
170#[diag(incremental_canonicalize_path)]
171pub(crate) struct CanonicalizePath {
172 pub path: PathBuf,
173 pub err: std::io::Error,
174}
175
176#[derive(const _: () =
{
impl<'_sess, 'a, G> rustc_errors::Diagnostic<'_sess, G> for
CreateIncrCompDir<'a> where G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
CreateIncrCompDir {
tag: __binding_0, path: __binding_1, err: __binding_2 } => {
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_create_incr_comp_dir);
;
diag.arg("tag", __binding_0);
diag.arg("path", __binding_1);
diag.arg("err", __binding_2);
diag
}
}
}
}
};Diagnostic)]
177#[diag(incremental_create_incr_comp_dir)]
178pub(crate) struct CreateIncrCompDir<'a> {
179 pub tag: &'a str,
180 pub path: &'a Path,
181 pub err: std::io::Error,
182}
183
184#[derive(const _: () =
{
impl<'_sess, 'a, G> rustc_errors::Diagnostic<'_sess, G> for
CreateLock<'a> where G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
CreateLock {
lock_err: __binding_0,
session_dir: __binding_1,
is_unsupported_lock: __binding_2,
is_cargo: __binding_3 } => {
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_create_lock);
;
diag.arg("lock_err", __binding_0);
diag.arg("session_dir", __binding_1);
if __binding_2 {
diag.note(crate::fluent_generated::incremental_lock_unsupported);
}
if __binding_3 {
diag.help(crate::fluent_generated::incremental_cargo_help_1);
}
if __binding_3 {
diag.help(crate::fluent_generated::incremental_cargo_help_2);
}
diag
}
}
}
}
};Diagnostic)]
185#[diag(incremental_create_lock)]
186pub(crate) struct CreateLock<'a> {
187 pub lock_err: std::io::Error,
188 pub session_dir: &'a Path,
189 #[note(incremental_lock_unsupported)]
190 pub is_unsupported_lock: bool,
191 #[help(incremental_cargo_help_1)]
192 #[help(incremental_cargo_help_2)]
193 pub is_cargo: bool,
194}
195
196#[derive(const _: () =
{
impl<'_sess, 'a, G> rustc_errors::Diagnostic<'_sess, G> for
DeleteLock<'a> where G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
DeleteLock { path: __binding_0, err: __binding_1 } => {
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_delete_lock);
;
diag.arg("path", __binding_0);
diag.arg("err", __binding_1);
diag
}
}
}
}
};Diagnostic)]
197#[diag(incremental_delete_lock)]
198pub(crate) struct DeleteLock<'a> {
199 pub path: &'a Path,
200 pub err: std::io::Error,
201}
202
203#[derive(const _: () =
{
impl<'_sess, 'a, G> rustc_errors::Diagnostic<'_sess, G> for
HardLinkFailed<'a> where G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
HardLinkFailed { path: __binding_0 } => {
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_hard_link_failed);
;
diag.arg("path", __binding_0);
diag
}
}
}
}
};Diagnostic)]
204#[diag(incremental_hard_link_failed)]
205pub(crate) struct HardLinkFailed<'a> {
206 pub path: &'a Path,
207}
208
209#[derive(const _: () =
{
impl<'_sess, 'a, G> rustc_errors::Diagnostic<'_sess, G> for
DeletePartial<'a> where G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
DeletePartial { path: __binding_0, err: __binding_1 } => {
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_delete_partial);
;
diag.arg("path", __binding_0);
diag.arg("err", __binding_1);
diag
}
}
}
}
};Diagnostic)]
210#[diag(incremental_delete_partial)]
211pub(crate) struct DeletePartial<'a> {
212 pub path: &'a Path,
213 pub err: std::io::Error,
214}
215
216#[derive(const _: () =
{
impl<'_sess, 'a, G> rustc_errors::Diagnostic<'_sess, G> for
DeleteFull<'a> where G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
DeleteFull { path: __binding_0, err: __binding_1 } => {
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_delete_full);
;
diag.arg("path", __binding_0);
diag.arg("err", __binding_1);
diag
}
}
}
}
};Diagnostic)]
217#[diag(incremental_delete_full)]
218pub(crate) struct DeleteFull<'a> {
219 pub path: &'a Path,
220 pub err: std::io::Error,
221}
222
223#[derive(const _: () =
{
impl<'_sess, 'a, G> rustc_errors::Diagnostic<'_sess, G> for
Finalize<'a> where G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
Finalize { path: __binding_0, err: __binding_1 } => {
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_finalize);
;
diag.arg("path", __binding_0);
diag.arg("err", __binding_1);
diag
}
}
}
}
};Diagnostic)]
224#[diag(incremental_finalize)]
225pub(crate) struct Finalize<'a> {
226 pub path: &'a Path,
227 pub err: std::io::Error,
228}
229
230#[derive(const _: () =
{
impl<'_sess, 'a, G> rustc_errors::Diagnostic<'_sess, G> for
InvalidGcFailed<'a> where G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
InvalidGcFailed { path: __binding_0, err: __binding_1 } => {
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_invalid_gc_failed);
;
diag.arg("path", __binding_0);
diag.arg("err", __binding_1);
diag
}
}
}
}
};Diagnostic)]
231#[diag(incremental_invalid_gc_failed)]
232pub(crate) struct InvalidGcFailed<'a> {
233 pub path: &'a Path,
234 pub err: std::io::Error,
235}
236
237#[derive(const _: () =
{
impl<'_sess, 'a, G> rustc_errors::Diagnostic<'_sess, G> for
FinalizedGcFailed<'a> where G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
FinalizedGcFailed { path: __binding_0, err: __binding_1 } =>
{
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_finalized_gc_failed);
;
diag.arg("path", __binding_0);
diag.arg("err", __binding_1);
diag
}
}
}
}
};Diagnostic)]
238#[diag(incremental_finalized_gc_failed)]
239pub(crate) struct FinalizedGcFailed<'a> {
240 pub path: &'a Path,
241 pub err: std::io::Error,
242}
243
244#[derive(const _: () =
{
impl<'_sess, 'a, G> rustc_errors::Diagnostic<'_sess, G> for
SessionGcFailed<'a> where G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
SessionGcFailed { path: __binding_0, err: __binding_1 } => {
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_session_gc_failed);
;
diag.arg("path", __binding_0);
diag.arg("err", __binding_1);
diag
}
}
}
}
};Diagnostic)]
245#[diag(incremental_session_gc_failed)]
246pub(crate) struct SessionGcFailed<'a> {
247 pub path: &'a Path,
248 pub err: std::io::Error,
249}
250
251#[derive(const _: () =
{
impl<'_sess, G> rustc_errors::Diagnostic<'_sess, G> for
AssertNotLoaded where G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
AssertNotLoaded => {
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_assert_not_loaded);
;
diag
}
}
}
}
};Diagnostic)]
252#[diag(incremental_assert_not_loaded)]
253pub(crate) struct AssertNotLoaded;
254
255#[derive(const _: () =
{
impl<'_sess, G> rustc_errors::Diagnostic<'_sess, G> for AssertLoaded
where G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
AssertLoaded => {
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_assert_loaded);
;
diag
}
}
}
}
};Diagnostic)]
256#[diag(incremental_assert_loaded)]
257pub(crate) struct AssertLoaded;
258
259#[derive(const _: () =
{
impl<'_sess, G> rustc_errors::Diagnostic<'_sess, G> for
DeleteIncompatible where G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
DeleteIncompatible { path: __binding_0, err: __binding_1 }
=> {
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_delete_incompatible);
;
diag.arg("path", __binding_0);
diag.arg("err", __binding_1);
diag
}
}
}
}
};Diagnostic)]
260#[diag(incremental_delete_incompatible)]
261pub(crate) struct DeleteIncompatible {
262 pub path: PathBuf,
263 pub err: std::io::Error,
264}
265
266#[derive(const _: () =
{
impl<'_sess, G> rustc_errors::Diagnostic<'_sess, G> for LoadDepGraph
where G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
LoadDepGraph { path: __binding_0, err: __binding_1 } => {
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_load_dep_graph);
;
diag.arg("path", __binding_0);
diag.arg("err", __binding_1);
diag
}
}
}
}
};Diagnostic)]
267#[diag(incremental_load_dep_graph)]
268pub(crate) struct LoadDepGraph {
269 pub path: PathBuf,
270 pub err: std::io::Error,
271}
272
273#[derive(const _: () =
{
impl<'_sess, 'a, G> rustc_errors::Diagnostic<'_sess, G> for
MoveDepGraph<'a> where G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
MoveDepGraph {
from: __binding_0, to: __binding_1, err: __binding_2 } => {
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_move_dep_graph);
;
diag.arg("from", __binding_0);
diag.arg("to", __binding_1);
diag.arg("err", __binding_2);
diag
}
}
}
}
};Diagnostic)]
274#[diag(incremental_move_dep_graph)]
275pub(crate) struct MoveDepGraph<'a> {
276 pub from: &'a Path,
277 pub to: &'a Path,
278 pub err: std::io::Error,
279}
280
281#[derive(const _: () =
{
impl<'_sess, 'a, G> rustc_errors::Diagnostic<'_sess, G> for
CreateDepGraph<'a> where G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
CreateDepGraph { path: __binding_0, err: __binding_1 } => {
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_create_dep_graph);
;
diag.arg("path", __binding_0);
diag.arg("err", __binding_1);
diag
}
}
}
}
};Diagnostic)]
282#[diag(incremental_create_dep_graph)]
283pub(crate) struct CreateDepGraph<'a> {
284 pub path: &'a Path,
285 pub err: std::io::Error,
286}
287
288#[derive(const _: () =
{
impl<'_sess, 'a, G> rustc_errors::Diagnostic<'_sess, G> for
CopyWorkProductToCache<'a> where
G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
CopyWorkProductToCache {
from: __binding_0, to: __binding_1, err: __binding_2 } => {
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_copy_workproduct_to_cache);
;
diag.arg("from", __binding_0);
diag.arg("to", __binding_1);
diag.arg("err", __binding_2);
diag
}
}
}
}
};Diagnostic)]
289#[diag(incremental_copy_workproduct_to_cache)]
290pub(crate) struct CopyWorkProductToCache<'a> {
291 pub from: &'a Path,
292 pub to: &'a Path,
293 pub err: std::io::Error,
294}
295
296#[derive(const _: () =
{
impl<'_sess, 'a, G> rustc_errors::Diagnostic<'_sess, G> for
DeleteWorkProduct<'a> where G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
DeleteWorkProduct { path: __binding_0, err: __binding_1 } =>
{
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_delete_workproduct);
;
diag.arg("path", __binding_0);
diag.arg("err", __binding_1);
diag
}
}
}
}
};Diagnostic)]
297#[diag(incremental_delete_workproduct)]
298pub(crate) struct DeleteWorkProduct<'a> {
299 pub path: &'a Path,
300 pub err: std::io::Error,
301}
302
303#[derive(const _: () =
{
impl<'_sess, 'a, G> rustc_errors::Diagnostic<'_sess, G> for
CorruptFile<'a> where G: rustc_errors::EmissionGuarantee {
#[track_caller]
fn into_diag(self, dcx: rustc_errors::DiagCtxtHandle<'_sess>,
level: rustc_errors::Level) -> rustc_errors::Diag<'_sess, G> {
match self {
CorruptFile { path: __binding_0 } => {
let mut diag =
rustc_errors::Diag::new(dcx, level,
crate::fluent_generated::incremental_corrupt_file);
;
diag.arg("path", __binding_0);
diag
}
}
}
}
};Diagnostic)]
304#[diag(incremental_corrupt_file)]
305pub(crate) struct CorruptFile<'a> {
306 pub path: &'a Path,
307}