1use std::num::NonZero;
2
3use rustc_ast::token;
4use rustc_ast::util::literal::LitError;
5use rustc_errors::codes::*;
6use rustc_errors::{
7 Diag, DiagCtxtHandle, DiagMessage, Diagnostic, EmissionGuarantee, ErrorGuaranteed, Level,
8 MultiSpan,
9};
10use rustc_macros::{Diagnostic, Subdiagnostic};
11use rustc_span::{Span, Symbol};
12use rustc_target::spec::{SplitDebuginfo, StackProtector, TargetTuple};
13
14use crate::config::CrateType;
15use crate::parse::ParseSess;
16
17pub(crate) struct FeatureGateError {
18 pub(crate) span: MultiSpan,
19 pub(crate) explain: DiagMessage,
20}
21
22impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for FeatureGateError {
23 #[track_caller]
24 fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
25 Diag::new(dcx, level, self.explain).with_span(self.span).with_code(E0658)
26 }
27}
28
29#[derive(Subdiagnostic)]
30#[note(session_feature_diagnostic_for_issue)]
31pub(crate) struct FeatureDiagnosticForIssue {
32 pub(crate) n: NonZero<u32>,
33}
34
35#[derive(Subdiagnostic)]
36#[note(session_feature_suggest_upgrade_compiler)]
37pub(crate) struct SuggestUpgradeCompiler {
38 date: &'static str,
39}
40
41impl SuggestUpgradeCompiler {
42 pub(crate) fn ui_testing() -> Self {
43 Self { date: "YYYY-MM-DD" }
44 }
45
46 pub(crate) fn new() -> Option<Self> {
47 let date = option_env!("CFG_VER_DATE")?;
48
49 Some(Self { date })
50 }
51}
52
53#[derive(Subdiagnostic)]
54#[help(session_feature_diagnostic_help)]
55pub(crate) struct FeatureDiagnosticHelp {
56 pub(crate) feature: Symbol,
57}
58
59#[derive(Subdiagnostic)]
60#[suggestion(
61 session_feature_diagnostic_suggestion,
62 applicability = "maybe-incorrect",
63 code = "#![feature({feature})]\n"
64)]
65pub struct FeatureDiagnosticSuggestion {
66 pub feature: Symbol,
67 #[primary_span]
68 pub span: Span,
69}
70
71#[derive(Subdiagnostic)]
72#[help(session_cli_feature_diagnostic_help)]
73pub(crate) struct CliFeatureDiagnosticHelp {
74 pub(crate) feature: Symbol,
75}
76
77#[derive(Diagnostic)]
78#[diag(session_not_circumvent_feature)]
79pub(crate) struct NotCircumventFeature;
80
81#[derive(Diagnostic)]
82#[diag(session_linker_plugin_lto_windows_not_supported)]
83pub(crate) struct LinkerPluginToWindowsNotSupported;
84
85#[derive(Diagnostic)]
86#[diag(session_profile_use_file_does_not_exist)]
87pub(crate) struct ProfileUseFileDoesNotExist<'a> {
88 pub(crate) path: &'a std::path::Path,
89}
90
91#[derive(Diagnostic)]
92#[diag(session_profile_sample_use_file_does_not_exist)]
93pub(crate) struct ProfileSampleUseFileDoesNotExist<'a> {
94 pub(crate) path: &'a std::path::Path,
95}
96
97#[derive(Diagnostic)]
98#[diag(session_target_requires_unwind_tables)]
99pub(crate) struct TargetRequiresUnwindTables;
100
101#[derive(Diagnostic)]
102#[diag(session_instrumentation_not_supported)]
103pub(crate) struct InstrumentationNotSupported {
104 pub(crate) us: String,
105}
106
107#[derive(Diagnostic)]
108#[diag(session_sanitizer_not_supported)]
109pub(crate) struct SanitizerNotSupported {
110 pub(crate) us: String,
111}
112
113#[derive(Diagnostic)]
114#[diag(session_sanitizers_not_supported)]
115pub(crate) struct SanitizersNotSupported {
116 pub(crate) us: String,
117}
118
119#[derive(Diagnostic)]
120#[diag(session_cannot_mix_and_match_sanitizers)]
121pub(crate) struct CannotMixAndMatchSanitizers {
122 pub(crate) first: String,
123 pub(crate) second: String,
124}
125
126#[derive(Diagnostic)]
127#[diag(session_cannot_enable_crt_static_linux)]
128pub(crate) struct CannotEnableCrtStaticLinux;
129
130#[derive(Diagnostic)]
131#[diag(session_sanitizer_cfi_requires_lto)]
132pub(crate) struct SanitizerCfiRequiresLto;
133
134#[derive(Diagnostic)]
135#[diag(session_sanitizer_cfi_requires_single_codegen_unit)]
136pub(crate) struct SanitizerCfiRequiresSingleCodegenUnit;
137
138#[derive(Diagnostic)]
139#[diag(session_sanitizer_cfi_canonical_jump_tables_requires_cfi)]
140pub(crate) struct SanitizerCfiCanonicalJumpTablesRequiresCfi;
141
142#[derive(Diagnostic)]
143#[diag(session_sanitizer_cfi_generalize_pointers_requires_cfi)]
144pub(crate) struct SanitizerCfiGeneralizePointersRequiresCfi;
145
146#[derive(Diagnostic)]
147#[diag(session_sanitizer_cfi_normalize_integers_requires_cfi)]
148pub(crate) struct SanitizerCfiNormalizeIntegersRequiresCfi;
149
150#[derive(Diagnostic)]
151#[diag(session_sanitizer_kcfi_requires_panic_abort)]
152pub(crate) struct SanitizerKcfiRequiresPanicAbort;
153
154#[derive(Diagnostic)]
155#[diag(session_split_lto_unit_requires_lto)]
156pub(crate) struct SplitLtoUnitRequiresLto;
157
158#[derive(Diagnostic)]
159#[diag(session_unstable_virtual_function_elimination)]
160pub(crate) struct UnstableVirtualFunctionElimination;
161
162#[derive(Diagnostic)]
163#[diag(session_unsupported_dwarf_version)]
164#[help(session_unsupported_dwarf_version_help)]
165pub(crate) struct UnsupportedDwarfVersion {
166 pub(crate) dwarf_version: u32,
167}
168
169#[derive(Diagnostic)]
170#[diag(session_embed_source_insufficient_dwarf_version)]
171pub(crate) struct EmbedSourceInsufficientDwarfVersion {
172 pub(crate) dwarf_version: u32,
173}
174
175#[derive(Diagnostic)]
176#[diag(session_embed_source_requires_debug_info)]
177pub(crate) struct EmbedSourceRequiresDebugInfo;
178
179#[derive(Diagnostic)]
180#[diag(session_target_stack_protector_not_supported)]
181pub(crate) struct StackProtectorNotSupportedForTarget<'a> {
182 pub(crate) stack_protector: StackProtector,
183 pub(crate) target_triple: &'a TargetTuple,
184}
185
186#[derive(Diagnostic)]
187#[diag(session_target_small_data_threshold_not_supported)]
188pub(crate) struct SmallDataThresholdNotSupportedForTarget<'a> {
189 pub(crate) target_triple: &'a TargetTuple,
190}
191
192#[derive(Diagnostic)]
193#[diag(session_branch_protection_requires_aarch64)]
194pub(crate) struct BranchProtectionRequiresAArch64;
195
196#[derive(Diagnostic)]
197#[diag(session_split_debuginfo_unstable_platform)]
198pub(crate) struct SplitDebugInfoUnstablePlatform {
199 pub(crate) debuginfo: SplitDebuginfo,
200}
201
202#[derive(Diagnostic)]
203#[diag(session_file_is_not_writeable)]
204pub(crate) struct FileIsNotWriteable<'a> {
205 pub(crate) file: &'a std::path::Path,
206}
207
208#[derive(Diagnostic)]
209#[diag(session_file_write_fail)]
210pub(crate) struct FileWriteFail<'a> {
211 pub(crate) path: &'a std::path::Path,
212 pub(crate) err: String,
213}
214
215#[derive(Diagnostic)]
216#[diag(session_crate_name_empty)]
217pub(crate) struct CrateNameEmpty {
218 #[primary_span]
219 pub(crate) span: Option<Span>,
220}
221
222#[derive(Diagnostic)]
223#[diag(session_invalid_character_in_crate_name)]
224pub(crate) struct InvalidCharacterInCrateName {
225 #[primary_span]
226 pub(crate) span: Option<Span>,
227 pub(crate) character: char,
228 pub(crate) crate_name: Symbol,
229 #[help]
230 pub(crate) help: Option<()>,
231}
232
233#[derive(Subdiagnostic)]
234#[multipart_suggestion(session_expr_parentheses_needed, applicability = "machine-applicable")]
235pub struct ExprParenthesesNeeded {
236 #[suggestion_part(code = "(")]
237 left: Span,
238 #[suggestion_part(code = ")")]
239 right: Span,
240}
241
242impl ExprParenthesesNeeded {
243 pub fn surrounding(s: Span) -> Self {
244 ExprParenthesesNeeded { left: s.shrink_to_lo(), right: s.shrink_to_hi() }
245 }
246}
247
248#[derive(Diagnostic)]
249#[diag(session_skipping_const_checks)]
250pub(crate) struct SkippingConstChecks {
251 #[subdiagnostic]
252 pub(crate) unleashed_features: Vec<UnleashedFeatureHelp>,
253}
254
255#[derive(Subdiagnostic)]
256pub(crate) enum UnleashedFeatureHelp {
257 #[help(session_unleashed_feature_help_named)]
258 Named {
259 #[primary_span]
260 span: Span,
261 gate: Symbol,
262 },
263 #[help(session_unleashed_feature_help_unnamed)]
264 Unnamed {
265 #[primary_span]
266 span: Span,
267 },
268}
269
270#[derive(Diagnostic)]
271#[diag(session_invalid_literal_suffix)]
272struct InvalidLiteralSuffix<'a> {
273 #[primary_span]
274 #[label]
275 span: Span,
276 kind: &'a str,
278 suffix: Symbol,
279}
280
281#[derive(Diagnostic)]
282#[diag(session_invalid_int_literal_width)]
283#[help]
284struct InvalidIntLiteralWidth {
285 #[primary_span]
286 span: Span,
287 width: String,
288}
289
290#[derive(Diagnostic)]
291#[diag(session_invalid_num_literal_base_prefix)]
292#[note]
293struct InvalidNumLiteralBasePrefix {
294 #[primary_span]
295 #[suggestion(applicability = "maybe-incorrect", code = "{fixed}")]
296 span: Span,
297 fixed: String,
298}
299
300#[derive(Diagnostic)]
301#[diag(session_invalid_num_literal_suffix)]
302#[help]
303struct InvalidNumLiteralSuffix {
304 #[primary_span]
305 #[label]
306 span: Span,
307 suffix: String,
308}
309
310#[derive(Diagnostic)]
311#[diag(session_invalid_float_literal_width)]
312#[help]
313struct InvalidFloatLiteralWidth {
314 #[primary_span]
315 span: Span,
316 width: String,
317}
318
319#[derive(Diagnostic)]
320#[diag(session_invalid_float_literal_suffix)]
321#[help]
322struct InvalidFloatLiteralSuffix {
323 #[primary_span]
324 #[label]
325 span: Span,
326 suffix: String,
327}
328
329#[derive(Diagnostic)]
330#[diag(session_int_literal_too_large)]
331#[note]
332struct IntLiteralTooLarge {
333 #[primary_span]
334 span: Span,
335 limit: String,
336}
337
338#[derive(Diagnostic)]
339#[diag(session_hexadecimal_float_literal_not_supported)]
340struct HexadecimalFloatLiteralNotSupported {
341 #[primary_span]
342 #[label(session_not_supported)]
343 span: Span,
344}
345
346#[derive(Diagnostic)]
347#[diag(session_octal_float_literal_not_supported)]
348struct OctalFloatLiteralNotSupported {
349 #[primary_span]
350 #[label(session_not_supported)]
351 span: Span,
352}
353
354#[derive(Diagnostic)]
355#[diag(session_binary_float_literal_not_supported)]
356struct BinaryFloatLiteralNotSupported {
357 #[primary_span]
358 #[label(session_not_supported)]
359 span: Span,
360}
361
362#[derive(Diagnostic)]
363#[diag(session_unsupported_crate_type_for_target)]
364pub(crate) struct UnsupportedCrateTypeForTarget<'a> {
365 pub(crate) crate_type: CrateType,
366 pub(crate) target_triple: &'a TargetTuple,
367}
368
369pub fn report_lit_error(
370 psess: &ParseSess,
371 err: LitError,
372 lit: token::Lit,
373 span: Span,
374) -> ErrorGuaranteed {
375 fn looks_like_width_suffix(first_chars: &[char], s: &str) -> bool {
377 s.len() > 1 && s.starts_with(first_chars) && s[1..].chars().all(|c| c.is_ascii_digit())
378 }
379
380 fn fix_base_capitalisation(prefix: &str, suffix: &str) -> Option<String> {
382 let mut chars = suffix.chars();
383
384 let base_char = chars.next().unwrap();
385 let base = match base_char {
386 'B' => 2,
387 'O' => 8,
388 'X' => 16,
389 _ => return None,
390 };
391
392 let valid = prefix == "0"
394 && chars
395 .filter(|c| *c != '_')
396 .take_while(|c| *c != 'i' && *c != 'u')
397 .all(|c| c.to_digit(base).is_some());
398
399 valid.then(|| format!("0{}{}", base_char.to_ascii_lowercase(), &suffix[1..]))
400 }
401
402 let dcx = psess.dcx();
403 match err {
404 LitError::InvalidSuffix(suffix) => {
405 dcx.emit_err(InvalidLiteralSuffix { span, kind: lit.kind.descr(), suffix })
406 }
407 LitError::InvalidIntSuffix(suffix) => {
408 let suf = suffix.as_str();
409 if looks_like_width_suffix(&['i', 'u'], suf) {
410 dcx.emit_err(InvalidIntLiteralWidth { span, width: suf[1..].into() })
412 } else if let Some(fixed) = fix_base_capitalisation(lit.symbol.as_str(), suf) {
413 dcx.emit_err(InvalidNumLiteralBasePrefix { span, fixed })
414 } else {
415 dcx.emit_err(InvalidNumLiteralSuffix { span, suffix: suf.to_string() })
416 }
417 }
418 LitError::InvalidFloatSuffix(suffix) => {
419 let suf = suffix.as_str();
420 if looks_like_width_suffix(&['f'], suf) {
421 dcx.emit_err(InvalidFloatLiteralWidth { span, width: suf[1..].to_string() })
423 } else {
424 dcx.emit_err(InvalidFloatLiteralSuffix { span, suffix: suf.to_string() })
425 }
426 }
427 LitError::NonDecimalFloat(base) => match base {
428 16 => dcx.emit_err(HexadecimalFloatLiteralNotSupported { span }),
429 8 => dcx.emit_err(OctalFloatLiteralNotSupported { span }),
430 2 => dcx.emit_err(BinaryFloatLiteralNotSupported { span }),
431 _ => unreachable!(),
432 },
433 LitError::IntTooLarge(base) => {
434 let max = u128::MAX;
435 let limit = match base {
436 2 => format!("{max:#b}"),
437 8 => format!("{max:#o}"),
438 16 => format!("{max:#x}"),
439 _ => format!("{max}"),
440 };
441 dcx.emit_err(IntLiteralTooLarge { span, limit })
442 }
443 }
444}
445
446#[derive(Diagnostic)]
447#[diag(session_incompatible_linker_flavor)]
448#[note]
449pub(crate) struct IncompatibleLinkerFlavor {
450 pub(crate) flavor: &'static str,
451 pub(crate) compatible_list: String,
452}
453
454#[derive(Diagnostic)]
455#[diag(session_function_return_requires_x86_or_x86_64)]
456pub(crate) struct FunctionReturnRequiresX86OrX8664;
457
458#[derive(Diagnostic)]
459#[diag(session_function_return_thunk_extern_requires_non_large_code_model)]
460pub(crate) struct FunctionReturnThunkExternRequiresNonLargeCodeModel;
461
462#[derive(Diagnostic)]
463#[diag(session_unsupported_regparm)]
464pub(crate) struct UnsupportedRegparm {
465 pub(crate) regparm: u32,
466}
467
468#[derive(Diagnostic)]
469#[diag(session_unsupported_regparm_arch)]
470pub(crate) struct UnsupportedRegparmArch;
471
472#[derive(Diagnostic)]
473#[diag(session_unsupported_reg_struct_return_arch)]
474pub(crate) struct UnsupportedRegStructReturnArch;
475
476#[derive(Diagnostic)]
477#[diag(session_failed_to_create_profiler)]
478pub(crate) struct FailedToCreateProfiler {
479 pub(crate) err: String,
480}
481
482#[derive(Diagnostic)]
483#[diag(session_soft_float_ignored)]
484#[note]
485pub(crate) struct SoftFloatIgnored;
486
487#[derive(Diagnostic)]
488#[diag(session_soft_float_deprecated)]
489#[note]
490#[note(session_soft_float_deprecated_issue)]
491pub(crate) struct SoftFloatDeprecated;