[rustc.git] / compiler / rustc_codegen_gcc / src / errors.rs

use rustc_errors::{DiagnosticArgValue, IntoDiagnosticArg};
use rustc_macros::Diagnostic;
use rustc_middle::ty::Ty;
use rustc_span::{Span, Symbol};
use std::borrow::Cow;

struct ExitCode(Option<i32>);

impl IntoDiagnosticArg for ExitCode {
    fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
        let ExitCode(exit_code) = self;
        match exit_code {
            Some(t) => t.into_diagnostic_arg(),
            None => DiagnosticArgValue::Str(Cow::Borrowed("<signal>")),
        }
    }
}

#[derive(Diagnostic)]
#[diag(codegen_gcc_invalid_monomorphization_basic_integer, code = "E0511")]
pub(crate) struct InvalidMonomorphizationBasicInteger<'a> {
    #[primary_span]
    pub span: Span,
    pub name: Symbol,
    pub ty: Ty<'a>,
}

#[derive(Diagnostic)]
#[diag(codegen_gcc_invalid_monomorphization_invalid_float_vector, code = "E0511")]
pub(crate) struct InvalidMonomorphizationInvalidFloatVector<'a> {
    #[primary_span]
    pub span: Span,
    pub name: Symbol,
    pub elem_ty: &'a str,
    pub vec_ty: Ty<'a>,
}

#[derive(Diagnostic)]
#[diag(codegen_gcc_invalid_monomorphization_not_float, code = "E0511")]
pub(crate) struct InvalidMonomorphizationNotFloat<'a> {
    #[primary_span]
    pub span: Span,
    pub name: Symbol,
    pub ty: Ty<'a>,
}

#[derive(Diagnostic)]
#[diag(codegen_gcc_invalid_monomorphization_unrecognized, code = "E0511")]
pub(crate) struct InvalidMonomorphizationUnrecognized {
    #[primary_span]
    pub span: Span,
    pub name: Symbol,
}

#[derive(Diagnostic)]
#[diag(codegen_gcc_invalid_monomorphization_expected_signed_unsigned, code = "E0511")]
pub(crate) struct InvalidMonomorphizationExpectedSignedUnsigned<'a> {
    #[primary_span]
    pub span: Span,
    pub name: Symbol,
    pub elem_ty: Ty<'a>,
    pub vec_ty: Ty<'a>,
}

#[derive(Diagnostic)]
#[diag(codegen_gcc_invalid_monomorphization_unsupported_element, code = "E0511")]
pub(crate) struct InvalidMonomorphizationUnsupportedElement<'a> {
    #[primary_span]
    pub span: Span,
    pub name: Symbol,
    pub in_ty: Ty<'a>,
    pub elem_ty: Ty<'a>,
    pub ret_ty: Ty<'a>,
}

#[derive(Diagnostic)]
#[diag(codegen_gcc_invalid_monomorphization_invalid_bitmask, code = "E0511")]
pub(crate) struct InvalidMonomorphizationInvalidBitmask<'a> {
    #[primary_span]
    pub span: Span,
    pub name: Symbol,
    pub ty: Ty<'a>,
    pub expected_int_bits: u64,
    pub expected_bytes: u64,
}

#[derive(Diagnostic)]
#[diag(codegen_gcc_invalid_monomorphization_simd_shuffle, code = "E0511")]
pub(crate) struct InvalidMonomorphizationSimdShuffle<'a> {
    #[primary_span]
    pub span: Span,
    pub name: Symbol,
    pub ty: Ty<'a>,
}

#[derive(Diagnostic)]
#[diag(codegen_gcc_invalid_monomorphization_expected_simd, code = "E0511")]
pub(crate) struct InvalidMonomorphizationExpectedSimd<'a> {
    #[primary_span]
    pub span: Span,
    pub name: Symbol,
    pub position: &'a str,
    pub found_ty: Ty<'a>,
}

#[derive(Diagnostic)]
#[diag(codegen_gcc_invalid_monomorphization_mask_type, code = "E0511")]
pub(crate) struct InvalidMonomorphizationMaskType<'a> {
    #[primary_span]
    pub span: Span,
    pub name: Symbol,
    pub ty: Ty<'a>,
}

#[derive(Diagnostic)]
#[diag(codegen_gcc_invalid_monomorphization_return_length, code = "E0511")]
pub(crate) struct InvalidMonomorphizationReturnLength<'a> {
    #[primary_span]
    pub span: Span,
    pub name: Symbol,
    pub in_len: u64,
    pub ret_ty: Ty<'a>,
    pub out_len: u64,
}

#[derive(Diagnostic)]
#[diag(codegen_gcc_invalid_monomorphization_return_length_input_type, code = "E0511")]
pub(crate) struct InvalidMonomorphizationReturnLengthInputType<'a> {
    #[primary_span]
    pub span: Span,
    pub name: Symbol,
    pub in_len: u64,
    pub in_ty: Ty<'a>,
    pub ret_ty: Ty<'a>,
    pub out_len: u64,
}

#[derive(Diagnostic)]
#[diag(codegen_gcc_invalid_monomorphization_return_element, code = "E0511")]
pub(crate) struct InvalidMonomorphizationReturnElement<'a> {
    #[primary_span]
    pub span: Span,
    pub name: Symbol,
    pub in_elem: Ty<'a>,
    pub in_ty: Ty<'a>,
    pub ret_ty: Ty<'a>,
    pub out_ty: Ty<'a>,
}

#[derive(Diagnostic)]
#[diag(codegen_gcc_invalid_monomorphization_return_type, code = "E0511")]
pub(crate) struct InvalidMonomorphizationReturnType<'a> {
    #[primary_span]
    pub span: Span,
    pub name: Symbol,
    pub in_elem: Ty<'a>,
    pub in_ty: Ty<'a>,
    pub ret_ty: Ty<'a>,
}

#[derive(Diagnostic)]
#[diag(codegen_gcc_invalid_monomorphization_inserted_type, code = "E0511")]
pub(crate) struct InvalidMonomorphizationInsertedType<'a> {
    #[primary_span]
    pub span: Span,
    pub name: Symbol,
    pub in_elem: Ty<'a>,
    pub in_ty: Ty<'a>,
    pub out_ty: Ty<'a>,
}

#[derive(Diagnostic)]
#[diag(codegen_gcc_invalid_monomorphization_return_integer_type, code = "E0511")]
pub(crate) struct InvalidMonomorphizationReturnIntegerType<'a> {
    #[primary_span]
    pub span: Span,
    pub name: Symbol,
    pub ret_ty: Ty<'a>,
    pub out_ty: Ty<'a>,
}

#[derive(Diagnostic)]
#[diag(codegen_gcc_invalid_monomorphization_mismatched_lengths, code = "E0511")]
pub(crate) struct InvalidMonomorphizationMismatchedLengths {
    #[primary_span]
    pub span: Span,
    pub name: Symbol,
    pub m_len: u64,
    pub v_len: u64,
}

#[derive(Diagnostic)]
#[diag(codegen_gcc_invalid_monomorphization_unsupported_cast, code = "E0511")]
pub(crate) struct InvalidMonomorphizationUnsupportedCast<'a> {
    #[primary_span]
    pub span: Span,
    pub name: Symbol,
    pub in_ty: Ty<'a>,
    pub in_elem: Ty<'a>,
    pub ret_ty: Ty<'a>,
    pub out_elem: Ty<'a>,
}

#[derive(Diagnostic)]
#[diag(codegen_gcc_invalid_monomorphization_unsupported_operation, code = "E0511")]
pub(crate) struct InvalidMonomorphizationUnsupportedOperation<'a> {
    #[primary_span]
    pub span: Span,
    pub name: Symbol,
    pub in_ty: Ty<'a>,
    pub in_elem: Ty<'a>,
}

#[derive(Diagnostic)]
#[diag(codegen_gcc_lto_not_supported)]
pub(crate) struct LTONotSupported;

#[derive(Diagnostic)]
#[diag(codegen_gcc_unwinding_inline_asm)]
pub(crate) struct UnwindingInlineAsm {
    #[primary_span]
    pub span: Span,
}

#[derive(Diagnostic)]
#[diag(codegen_gcc_invalid_minimum_alignment)]
pub(crate) struct InvalidMinimumAlignment {
    pub err: String,
}

#[derive(Diagnostic)]
#[diag(codegen_gcc_tied_target_features)]
#[help]
pub(crate) struct TiedTargetFeatures {
    #[primary_span]
    pub span: Span,
    pub features: String,
}
Commit	Line	Data
2b03887a FG	1	use rustc_errors::{DiagnosticArgValue, IntoDiagnosticArg};
	2	use rustc_macros::Diagnostic;
	3	use rustc_middle::ty::Ty;
	4	use rustc_span::{Span, Symbol};
	5	use std::borrow::Cow;
	6
	7	struct ExitCode(Option<i32>);
	8
	9	impl IntoDiagnosticArg for ExitCode {
	10	fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
	11	let ExitCode(exit_code) = self;
	12	match exit_code {
	13	Some(t) => t.into_diagnostic_arg(),
	14	None => DiagnosticArgValue::Str(Cow::Borrowed("<signal>")),
	15	}
	16	}
	17	}
	18
2b03887a FG	19	#[derive(Diagnostic)]
	20	#[diag(codegen_gcc_invalid_monomorphization_basic_integer, code = "E0511")]
	21	pub(crate) struct InvalidMonomorphizationBasicInteger<'a> {
	22	#[primary_span]
	23	pub span: Span,
	24	pub name: Symbol,
	25	pub ty: Ty<'a>,
	26	}
	27
	28	#[derive(Diagnostic)]
	29	#[diag(codegen_gcc_invalid_monomorphization_invalid_float_vector, code = "E0511")]
	30	pub(crate) struct InvalidMonomorphizationInvalidFloatVector<'a> {
	31	#[primary_span]
	32	pub span: Span,
	33	pub name: Symbol,
	34	pub elem_ty: &'a str,
	35	pub vec_ty: Ty<'a>,
	36	}
	37
	38	#[derive(Diagnostic)]
	39	#[diag(codegen_gcc_invalid_monomorphization_not_float, code = "E0511")]
	40	pub(crate) struct InvalidMonomorphizationNotFloat<'a> {
	41	#[primary_span]
	42	pub span: Span,
	43	pub name: Symbol,
	44	pub ty: Ty<'a>,
	45	}
	46
	47	#[derive(Diagnostic)]
	48	#[diag(codegen_gcc_invalid_monomorphization_unrecognized, code = "E0511")]
	49	pub(crate) struct InvalidMonomorphizationUnrecognized {
	50	#[primary_span]
	51	pub span: Span,
	52	pub name: Symbol,
	53	}
	54
	55	#[derive(Diagnostic)]
	56	#[diag(codegen_gcc_invalid_monomorphization_expected_signed_unsigned, code = "E0511")]
	57	pub(crate) struct InvalidMonomorphizationExpectedSignedUnsigned<'a> {
	58	#[primary_span]
	59	pub span: Span,
	60	pub name: Symbol,
	61	pub elem_ty: Ty<'a>,
	62	pub vec_ty: Ty<'a>,
	63	}
	64
	65	#[derive(Diagnostic)]
	66	#[diag(codegen_gcc_invalid_monomorphization_unsupported_element, code = "E0511")]
	67	pub(crate) struct InvalidMonomorphizationUnsupportedElement<'a> {
	68	#[primary_span]
	69	pub span: Span,
	70	pub name: Symbol,
	71	pub in_ty: Ty<'a>,
	72	pub elem_ty: Ty<'a>,
	73	pub ret_ty: Ty<'a>,
	74	}
	75
	76	#[derive(Diagnostic)]
	77	#[diag(codegen_gcc_invalid_monomorphization_invalid_bitmask, code = "E0511")]
	78	pub(crate) struct InvalidMonomorphizationInvalidBitmask<'a> {
	79	#[primary_span]
	80	pub span: Span,
	81	pub name: Symbol,
	82	pub ty: Ty<'a>,
83	pub expected_int_bits: u64,
84	pub expected_bytes: u64,
85	}
86
87	#[derive(Diagnostic)]
88	#[diag(codegen_gcc_invalid_monomorphization_simd_shuffle, code = "E0511")]
89	pub(crate) struct InvalidMonomorphizationSimdShuffle<'a> {
90	#[primary_span]
91	pub span: Span,
92	pub name: Symbol,
93	pub ty: Ty<'a>,
94	}
95
96	#[derive(Diagnostic)]
97	#[diag(codegen_gcc_invalid_monomorphization_expected_simd, code = "E0511")]
98	pub(crate) struct InvalidMonomorphizationExpectedSimd<'a> {
99	#[primary_span]
100	pub span: Span,
101	pub name: Symbol,
102	pub position: &'a str,
103	pub found_ty: Ty<'a>,
104	}
105
106	#[derive(Diagnostic)]
107	#[diag(codegen_gcc_invalid_monomorphization_mask_type, code = "E0511")]
108	pub(crate) struct InvalidMonomorphizationMaskType<'a> {
109	#[primary_span]
110	pub span: Span,
111	pub name: Symbol,
112	pub ty: Ty<'a>,
113	}
114
115	#[derive(Diagnostic)]
116	#[diag(codegen_gcc_invalid_monomorphization_return_length, code = "E0511")]
117	pub(crate) struct InvalidMonomorphizationReturnLength<'a> {
118	#[primary_span]
119	pub span: Span,
120	pub name: Symbol,
121	pub in_len: u64,
122	pub ret_ty: Ty<'a>,
123	pub out_len: u64,
124	}
125
126	#[derive(Diagnostic)]
127	#[diag(codegen_gcc_invalid_monomorphization_return_length_input_type, code = "E0511")]
128	pub(crate) struct InvalidMonomorphizationReturnLengthInputType<'a> {
129	#[primary_span]
130	pub span: Span,
131	pub name: Symbol,
132	pub in_len: u64,
133	pub in_ty: Ty<'a>,
134	pub ret_ty: Ty<'a>,
135	pub out_len: u64,
136	}
137
138	#[derive(Diagnostic)]
139	#[diag(codegen_gcc_invalid_monomorphization_return_element, code = "E0511")]
140	pub(crate) struct InvalidMonomorphizationReturnElement<'a> {
141	#[primary_span]
142	pub span: Span,
143	pub name: Symbol,
144	pub in_elem: Ty<'a>,
145	pub in_ty: Ty<'a>,
146	pub ret_ty: Ty<'a>,
147	pub out_ty: Ty<'a>,
148	}
149
150	#[derive(Diagnostic)]
151	#[diag(codegen_gcc_invalid_monomorphization_return_type, code = "E0511")]
152	pub(crate) struct InvalidMonomorphizationReturnType<'a> {
153	#[primary_span]
154	pub span: Span,
155	pub name: Symbol,
156	pub in_elem: Ty<'a>,
157	pub in_ty: Ty<'a>,
158	pub ret_ty: Ty<'a>,
159	}
160
161	#[derive(Diagnostic)]
162	#[diag(codegen_gcc_invalid_monomorphization_inserted_type, code = "E0511")]
163	pub(crate) struct InvalidMonomorphizationInsertedType<'a> {
164	#[primary_span]
165	pub span: Span,
166	pub name: Symbol,
167	pub in_elem: Ty<'a>,
168	pub in_ty: Ty<'a>,
169	pub out_ty: Ty<'a>,
170	}
171
172	#[derive(Diagnostic)]
173	#[diag(codegen_gcc_invalid_monomorphization_return_integer_type, code = "E0511")]
174	pub(crate) struct InvalidMonomorphizationReturnIntegerType<'a> {
175	#[primary_span]
176	pub span: Span,
177	pub name: Symbol,
178	pub ret_ty: Ty<'a>,
179	pub out_ty: Ty<'a>,
180	}
181
182	#[derive(Diagnostic)]
183	#[diag(codegen_gcc_invalid_monomorphization_mismatched_lengths, code = "E0511")]
184	pub(crate) struct InvalidMonomorphizationMismatchedLengths {
185	#[primary_span]
186	pub span: Span,
187	pub name: Symbol,
188	pub m_len: u64,
189	pub v_len: u64,
190	}
191
192	#[derive(Diagnostic)]
193	#[diag(codegen_gcc_invalid_monomorphization_unsupported_cast, code = "E0511")]
194	pub(crate) struct InvalidMonomorphizationUnsupportedCast<'a> {
195	#[primary_span]
196	pub span: Span,
197	pub name: Symbol,
198	pub in_ty: Ty<'a>,
199	pub in_elem: Ty<'a>,
200	pub ret_ty: Ty<'a>,
201	pub out_elem: Ty<'a>,
202	}
203
204	#[derive(Diagnostic)]
205	#[diag(codegen_gcc_invalid_monomorphization_unsupported_operation, code = "E0511")]
206	pub(crate) struct InvalidMonomorphizationUnsupportedOperation<'a> {
207	#[primary_span]
208	pub span: Span,
209	pub name: Symbol,
210	pub in_ty: Ty<'a>,
211	pub in_elem: Ty<'a>,
212	}
213
2b03887a FG	214	#[derive(Diagnostic)]
	215	#[diag(codegen_gcc_lto_not_supported)]
	216	pub(crate) struct LTONotSupported;
	217
	218	#[derive(Diagnostic)]
	219	#[diag(codegen_gcc_unwinding_inline_asm)]
	220	pub(crate) struct UnwindingInlineAsm {
	221	#[primary_span]
487cf647	222	pub span: Span,
2b03887a	223	}
353b0b11 FG	224
	225	#[derive(Diagnostic)]
	226	#[diag(codegen_gcc_invalid_minimum_alignment)]
	227	pub(crate) struct InvalidMinimumAlignment {
	228	pub err: String,
	229	}
	230
	231	#[derive(Diagnostic)]
	232	#[diag(codegen_gcc_tied_target_features)]
	233	#[help]
	234	pub(crate) struct TiedTargetFeatures {
	235	#[primary_span]
	236	pub span: Span,
	237	pub features: String,
	238	}