1use std::io::Error;
2use std::path::{Path, PathBuf};
3
4use rustc_errors::codes::*;
5use rustc_errors::{Diag, DiagCtxtHandle, Diagnostic, EmissionGuarantee, Level};
6use rustc_macros::{Diagnostic, Subdiagnostic};
7use rustc_span::{Span, Symbol, sym};
8use rustc_target::spec::{PanicStrategy, TargetTuple};
9
10use crate::fluent_generated as fluent;
11use crate::locator::CrateFlavor;
12
13#[derive(Diagnostic)]
14#[diag(metadata_rlib_required)]
15pub struct RlibRequired {
16 pub crate_name: Symbol,
17}
18
19#[derive(Diagnostic)]
20#[diag(metadata_lib_required)]
21pub struct LibRequired<'a> {
22 pub crate_name: Symbol,
23 pub kind: &'a str,
24}
25
26#[derive(Diagnostic)]
27#[diag(metadata_rustc_lib_required)]
28#[help]
29pub struct RustcLibRequired<'a> {
30 pub crate_name: Symbol,
31 pub kind: &'a str,
32}
33
34#[derive(Diagnostic)]
35#[diag(metadata_crate_dep_multiple)]
36#[help]
37pub struct CrateDepMultiple {
38 pub crate_name: Symbol,
39 #[subdiagnostic]
40 pub non_static_deps: Vec<NonStaticCrateDep>,
41 #[subdiagnostic]
42 pub rustc_driver_help: Option<RustcDriverHelp>,
43}
44
45#[derive(Subdiagnostic)]
46#[note(metadata_crate_dep_not_static)]
47pub struct NonStaticCrateDep {
48 pub crate_name: Symbol,
49}
50
51#[derive(Subdiagnostic)]
52#[help(metadata_crate_dep_rustc_driver)]
53pub struct RustcDriverHelp;
54
55#[derive(Diagnostic)]
56#[diag(metadata_two_panic_runtimes)]
57pub struct TwoPanicRuntimes {
58 pub prev_name: Symbol,
59 pub cur_name: Symbol,
60}
61
62#[derive(Diagnostic)]
63#[diag(metadata_bad_panic_strategy)]
64pub struct BadPanicStrategy {
65 pub runtime: Symbol,
66 pub strategy: PanicStrategy,
67}
68
69#[derive(Diagnostic)]
70#[diag(metadata_required_panic_strategy)]
71pub struct RequiredPanicStrategy {
72 pub crate_name: Symbol,
73 pub found_strategy: PanicStrategy,
74 pub desired_strategy: PanicStrategy,
75}
76
77#[derive(Diagnostic)]
78#[diag(metadata_incompatible_panic_in_drop_strategy)]
79pub struct IncompatiblePanicInDropStrategy {
80 pub crate_name: Symbol,
81 pub found_strategy: PanicStrategy,
82 pub desired_strategy: PanicStrategy,
83}
84
85#[derive(Diagnostic)]
86#[diag(metadata_multiple_names_in_link)]
87pub struct MultipleNamesInLink {
88 #[primary_span]
89 pub span: Span,
90}
91
92#[derive(Diagnostic)]
93#[diag(metadata_multiple_kinds_in_link)]
94pub struct MultipleKindsInLink {
95 #[primary_span]
96 pub span: Span,
97}
98
99#[derive(Diagnostic)]
100#[diag(metadata_link_name_form)]
101pub struct LinkNameForm {
102 #[primary_span]
103 pub span: Span,
104}
105
106#[derive(Diagnostic)]
107#[diag(metadata_link_kind_form)]
108pub struct LinkKindForm {
109 #[primary_span]
110 pub span: Span,
111}
112
113#[derive(Diagnostic)]
114#[diag(metadata_link_modifiers_form)]
115pub struct LinkModifiersForm {
116 #[primary_span]
117 pub span: Span,
118}
119
120#[derive(Diagnostic)]
121#[diag(metadata_link_cfg_form)]
122pub struct LinkCfgForm {
123 #[primary_span]
124 pub span: Span,
125}
126
127#[derive(Diagnostic)]
128#[diag(metadata_wasm_import_form)]
129pub struct WasmImportForm {
130 #[primary_span]
131 pub span: Span,
132}
133
134#[derive(Diagnostic)]
135#[diag(metadata_empty_link_name, code = E0454)]
136pub struct EmptyLinkName {
137 #[primary_span]
138 #[label]
139 pub span: Span,
140}
141
142#[derive(Diagnostic)]
143#[diag(metadata_link_framework_apple, code = E0455)]
144pub struct LinkFrameworkApple {
145 #[primary_span]
146 pub span: Span,
147}
148
149#[derive(Diagnostic)]
150#[diag(metadata_raw_dylib_only_windows, code = E0455)]
151pub struct RawDylibOnlyWindows {
152 #[primary_span]
153 pub span: Span,
154}
155
156#[derive(Diagnostic)]
157#[diag(metadata_unknown_link_kind, code = E0458)]
158pub struct UnknownLinkKind<'a> {
159 #[primary_span]
160 #[label]
161 pub span: Span,
162 pub kind: &'a str,
163}
164
165#[derive(Diagnostic)]
166#[diag(metadata_multiple_link_modifiers)]
167pub struct MultipleLinkModifiers {
168 #[primary_span]
169 pub span: Span,
170}
171
172#[derive(Diagnostic)]
173#[diag(metadata_multiple_cfgs)]
174pub struct MultipleCfgs {
175 #[primary_span]
176 pub span: Span,
177}
178
179#[derive(Diagnostic)]
180#[diag(metadata_link_cfg_single_predicate)]
181pub struct LinkCfgSinglePredicate {
182 #[primary_span]
183 pub span: Span,
184}
185
186#[derive(Diagnostic)]
187#[diag(metadata_multiple_wasm_import)]
188pub struct MultipleWasmImport {
189 #[primary_span]
190 pub span: Span,
191}
192
193#[derive(Diagnostic)]
194#[diag(metadata_unexpected_link_arg)]
195pub struct UnexpectedLinkArg {
196 #[primary_span]
197 pub span: Span,
198}
199
200#[derive(Diagnostic)]
201#[diag(metadata_invalid_link_modifier)]
202pub struct InvalidLinkModifier {
203 #[primary_span]
204 pub span: Span,
205}
206
207#[derive(Diagnostic)]
208#[diag(metadata_multiple_modifiers)]
209pub struct MultipleModifiers<'a> {
210 #[primary_span]
211 pub span: Span,
212 pub modifier: &'a str,
213}
214
215#[derive(Diagnostic)]
216#[diag(metadata_bundle_needs_static)]
217pub struct BundleNeedsStatic {
218 #[primary_span]
219 pub span: Span,
220}
221
222#[derive(Diagnostic)]
223#[diag(metadata_whole_archive_needs_static)]
224pub struct WholeArchiveNeedsStatic {
225 #[primary_span]
226 pub span: Span,
227}
228
229#[derive(Diagnostic)]
230#[diag(metadata_as_needed_compatibility)]
231pub struct AsNeededCompatibility {
232 #[primary_span]
233 pub span: Span,
234}
235
236#[derive(Diagnostic)]
237#[diag(metadata_unknown_link_modifier)]
238pub struct UnknownLinkModifier<'a> {
239 #[primary_span]
240 pub span: Span,
241 pub modifier: &'a str,
242}
243
244#[derive(Diagnostic)]
245#[diag(metadata_incompatible_wasm_link)]
246pub struct IncompatibleWasmLink {
247 #[primary_span]
248 pub span: Span,
249}
250
251#[derive(Diagnostic)]
252#[diag(metadata_link_requires_name, code = E0459)]
253pub struct LinkRequiresName {
254 #[primary_span]
255 #[label]
256 pub span: Span,
257}
258
259#[derive(Diagnostic)]
260#[diag(metadata_raw_dylib_no_nul)]
261pub struct RawDylibNoNul {
262 #[primary_span]
263 pub span: Span,
264}
265
266#[derive(Diagnostic)]
267#[diag(metadata_link_ordinal_raw_dylib)]
268pub struct LinkOrdinalRawDylib {
269 #[primary_span]
270 pub span: Span,
271}
272
273#[derive(Diagnostic)]
274#[diag(metadata_lib_framework_apple)]
275pub struct LibFrameworkApple;
276
277#[derive(Diagnostic)]
278#[diag(metadata_empty_renaming_target)]
279pub struct EmptyRenamingTarget<'a> {
280 pub lib_name: &'a str,
281}
282
283#[derive(Diagnostic)]
284#[diag(metadata_renaming_no_link)]
285pub struct RenamingNoLink<'a> {
286 pub lib_name: &'a str,
287}
288
289#[derive(Diagnostic)]
290#[diag(metadata_multiple_renamings)]
291pub struct MultipleRenamings<'a> {
292 pub lib_name: &'a str,
293}
294
295#[derive(Diagnostic)]
296#[diag(metadata_no_link_mod_override)]
297pub struct NoLinkModOverride {
298 #[primary_span]
299 pub span: Option<Span>,
300}
301
302#[derive(Diagnostic)]
303#[diag(metadata_unsupported_abi_i686)]
304pub struct UnsupportedAbiI686 {
305 #[primary_span]
306 pub span: Span,
307}
308
309#[derive(Diagnostic)]
310#[diag(metadata_unsupported_abi)]
311pub struct UnsupportedAbi {
312 #[primary_span]
313 pub span: Span,
314}
315
316#[derive(Diagnostic)]
317#[diag(metadata_fail_create_file_encoder)]
318pub struct FailCreateFileEncoder {
319 pub err: Error,
320}
321
322#[derive(Diagnostic)]
323#[diag(metadata_fail_write_file)]
324pub struct FailWriteFile<'a> {
325 pub path: &'a Path,
326 pub err: Error,
327}
328
329#[derive(Diagnostic)]
330#[diag(metadata_crate_not_panic_runtime)]
331pub struct CrateNotPanicRuntime {
332 pub crate_name: Symbol,
333}
334
335#[derive(Diagnostic)]
336#[diag(metadata_no_panic_strategy)]
337pub struct NoPanicStrategy {
338 pub crate_name: Symbol,
339 pub strategy: PanicStrategy,
340}
341
342#[derive(Diagnostic)]
343#[diag(metadata_not_profiler_runtime)]
344pub struct NotProfilerRuntime {
345 pub crate_name: Symbol,
346}
347
348#[derive(Diagnostic)]
349#[diag(metadata_no_multiple_global_alloc)]
350pub struct NoMultipleGlobalAlloc {
351 #[primary_span]
352 #[label]
353 pub span2: Span,
354 #[label(metadata_prev_global_alloc)]
355 pub span1: Span,
356}
357
358#[derive(Diagnostic)]
359#[diag(metadata_no_multiple_alloc_error_handler)]
360pub struct NoMultipleAllocErrorHandler {
361 #[primary_span]
362 #[label]
363 pub span2: Span,
364 #[label(metadata_prev_alloc_error_handler)]
365 pub span1: Span,
366}
367
368#[derive(Diagnostic)]
369#[diag(metadata_conflicting_global_alloc)]
370pub struct ConflictingGlobalAlloc {
371 pub crate_name: Symbol,
372 pub other_crate_name: Symbol,
373}
374
375#[derive(Diagnostic)]
376#[diag(metadata_conflicting_alloc_error_handler)]
377pub struct ConflictingAllocErrorHandler {
378 pub crate_name: Symbol,
379 pub other_crate_name: Symbol,
380}
381
382#[derive(Diagnostic)]
383#[diag(metadata_global_alloc_required)]
384pub struct GlobalAllocRequired;
385
386#[derive(Diagnostic)]
387#[diag(metadata_no_transitive_needs_dep)]
388pub struct NoTransitiveNeedsDep<'a> {
389 pub crate_name: Symbol,
390 pub needs_crate_name: &'a str,
391 pub deps_crate_name: Symbol,
392}
393
394#[derive(Diagnostic)]
395#[diag(metadata_failed_write_error)]
396pub struct FailedWriteError {
397 pub filename: PathBuf,
398 pub err: Error,
399}
400
401#[derive(Diagnostic)]
402#[diag(metadata_failed_copy_to_stdout)]
403pub struct FailedCopyToStdout {
404 pub filename: PathBuf,
405 pub err: Error,
406}
407
408#[derive(Diagnostic)]
409#[diag(metadata_binary_output_to_tty)]
410pub struct BinaryOutputToTty;
411
412#[derive(Diagnostic)]
413#[diag(metadata_missing_native_library)]
414pub struct MissingNativeLibrary<'a> {
415 libname: &'a str,
416 #[subdiagnostic]
417 suggest_name: Option<SuggestLibraryName<'a>>,
418}
419
420impl<'a> MissingNativeLibrary<'a> {
421 pub fn new(libname: &'a str, verbatim: bool) -> Self {
422 let suggested_name = if !verbatim {
425 if let Some(libname) = libname.strip_prefix("lib")
426 && let Some(libname) = libname.strip_suffix(".a")
427 {
428 Some(libname)
430 } else if let Some(libname) = libname.strip_suffix(".lib") {
431 Some(libname)
433 } else {
434 None
435 }
436 } else {
437 None
438 };
439
440 Self {
441 libname,
442 suggest_name: suggested_name
443 .map(|suggested_name| SuggestLibraryName { suggested_name }),
444 }
445 }
446}
447
448#[derive(Subdiagnostic)]
449#[help(metadata_only_provide_library_name)]
450pub struct SuggestLibraryName<'a> {
451 suggested_name: &'a str,
452}
453
454#[derive(Diagnostic)]
455#[diag(metadata_failed_create_tempdir)]
456pub struct FailedCreateTempdir {
457 pub err: Error,
458}
459
460#[derive(Diagnostic)]
461#[diag(metadata_failed_create_file)]
462pub struct FailedCreateFile<'a> {
463 pub filename: &'a Path,
464 pub err: Error,
465}
466
467#[derive(Diagnostic)]
468#[diag(metadata_failed_create_encoded_metadata)]
469pub struct FailedCreateEncodedMetadata {
470 pub err: Error,
471}
472
473#[derive(Diagnostic)]
474#[diag(metadata_non_ascii_name)]
475pub struct NonAsciiName {
476 #[primary_span]
477 pub span: Span,
478 pub crate_name: Symbol,
479}
480
481#[derive(Diagnostic)]
482#[diag(metadata_extern_location_not_exist)]
483pub struct ExternLocationNotExist<'a> {
484 #[primary_span]
485 pub span: Span,
486 pub crate_name: Symbol,
487 pub location: &'a Path,
488}
489
490#[derive(Diagnostic)]
491#[diag(metadata_extern_location_not_file)]
492pub struct ExternLocationNotFile<'a> {
493 #[primary_span]
494 pub span: Span,
495 pub crate_name: Symbol,
496 pub location: &'a Path,
497}
498
499pub(crate) struct MultipleCandidates {
500 pub span: Span,
501 pub flavor: CrateFlavor,
502 pub crate_name: Symbol,
503 pub candidates: Vec<PathBuf>,
504}
505
506impl<G: EmissionGuarantee> Diagnostic<'_, G> for MultipleCandidates {
507 fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
508 let mut diag = Diag::new(dcx, level, fluent::metadata_multiple_candidates);
509 diag.arg("crate_name", self.crate_name);
510 diag.arg("flavor", self.flavor);
511 diag.code(E0464);
512 diag.span(self.span);
513 for (i, candidate) in self.candidates.iter().enumerate() {
514 #[allow(rustc::untranslatable_diagnostic)]
516 diag.note(format!("candidate #{}: {}", i + 1, candidate.display()));
517 }
518 diag
519 }
520}
521
522#[derive(Diagnostic)]
523#[diag(metadata_symbol_conflicts_current, code = E0519)]
524pub struct SymbolConflictsCurrent {
525 #[primary_span]
526 pub span: Span,
527 pub crate_name: Symbol,
528}
529
530#[derive(Diagnostic)]
531#[diag(metadata_stable_crate_id_collision)]
532pub struct StableCrateIdCollision {
533 #[primary_span]
534 pub span: Span,
535 pub crate_name0: Symbol,
536 pub crate_name1: Symbol,
537}
538
539#[derive(Diagnostic)]
540#[diag(metadata_dl_error)]
541pub struct DlError {
542 #[primary_span]
543 pub span: Span,
544 pub path: String,
545 pub err: String,
546}
547
548#[derive(Diagnostic)]
549#[diag(metadata_newer_crate_version, code = E0460)]
550#[note]
551#[note(metadata_found_crate_versions)]
552pub struct NewerCrateVersion {
553 #[primary_span]
554 pub span: Span,
555 pub crate_name: Symbol,
556 pub add_info: String,
557 pub found_crates: String,
558}
559
560#[derive(Diagnostic)]
561#[diag(metadata_no_crate_with_triple, code = E0461)]
562#[note(metadata_found_crate_versions)]
563pub struct NoCrateWithTriple<'a> {
564 #[primary_span]
565 pub span: Span,
566 pub crate_name: Symbol,
567 pub locator_triple: &'a str,
568 pub add_info: String,
569 pub found_crates: String,
570}
571
572#[derive(Diagnostic)]
573#[diag(metadata_found_staticlib, code = E0462)]
574#[note(metadata_found_crate_versions)]
575#[help]
576pub struct FoundStaticlib {
577 #[primary_span]
578 pub span: Span,
579 pub crate_name: Symbol,
580 pub add_info: String,
581 pub found_crates: String,
582}
583
584#[derive(Diagnostic)]
585#[diag(metadata_incompatible_rustc, code = E0514)]
586#[note(metadata_found_crate_versions)]
587#[help]
588pub struct IncompatibleRustc {
589 #[primary_span]
590 pub span: Span,
591 pub crate_name: Symbol,
592 pub add_info: String,
593 pub found_crates: String,
594 pub rustc_version: String,
595}
596
597pub struct InvalidMetadataFiles {
598 pub span: Span,
599 pub crate_name: Symbol,
600 pub add_info: String,
601 pub crate_rejections: Vec<String>,
602}
603
604impl<G: EmissionGuarantee> Diagnostic<'_, G> for InvalidMetadataFiles {
605 #[track_caller]
606 fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
607 let mut diag = Diag::new(dcx, level, fluent::metadata_invalid_meta_files);
608 diag.arg("crate_name", self.crate_name);
609 diag.arg("add_info", self.add_info);
610 diag.code(E0786);
611 diag.span(self.span);
612 for crate_rejection in self.crate_rejections {
613 #[allow(rustc::untranslatable_diagnostic)]
615 diag.note(crate_rejection);
616 }
617 diag
618 }
619}
620
621pub struct CannotFindCrate {
622 pub span: Span,
623 pub crate_name: Symbol,
624 pub add_info: String,
625 pub missing_core: bool,
626 pub current_crate: String,
627 pub is_nightly_build: bool,
628 pub profiler_runtime: Symbol,
629 pub locator_triple: TargetTuple,
630 pub is_ui_testing: bool,
631}
632
633impl<G: EmissionGuarantee> Diagnostic<'_, G> for CannotFindCrate {
634 #[track_caller]
635 fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
636 let mut diag = Diag::new(dcx, level, fluent::metadata_cannot_find_crate);
637 diag.arg("crate_name", self.crate_name);
638 diag.arg("current_crate", self.current_crate);
639 diag.arg("add_info", self.add_info);
640 diag.arg("locator_triple", self.locator_triple.tuple());
641 diag.code(E0463);
642 diag.span(self.span);
643 if self.crate_name == sym::std || self.crate_name == sym::core {
644 if self.missing_core {
645 diag.note(fluent::metadata_target_not_installed);
646 } else {
647 diag.note(fluent::metadata_target_no_std_support);
648 }
649
650 if self.missing_core {
651 if env!("CFG_RELEASE_CHANNEL") == "dev" && !self.is_ui_testing {
652 diag.help(fluent::metadata_consider_adding_std);
654 } else {
655 diag.help(fluent::metadata_consider_downloading_target);
659 }
660 }
661
662 if !self.missing_core && self.span.is_dummy() {
667 diag.note(fluent::metadata_std_required);
668 }
669 if self.is_nightly_build {
670 diag.help(fluent::metadata_consider_building_std);
671 }
672 } else if self.crate_name == self.profiler_runtime {
673 diag.note(fluent::metadata_compiler_missing_profiler);
674 } else if self.crate_name.as_str().starts_with("rustc_") {
675 diag.help(fluent::metadata_install_missing_components);
676 }
677 diag.span_label(self.span, fluent::metadata_cant_find_crate);
678 diag
679 }
680}
681
682#[derive(Diagnostic)]
683#[diag(metadata_crate_location_unknown_type)]
684pub struct CrateLocationUnknownType<'a> {
685 #[primary_span]
686 pub span: Span,
687 pub path: &'a Path,
688 pub crate_name: Symbol,
689}
690
691#[derive(Diagnostic)]
692#[diag(metadata_lib_filename_form)]
693pub struct LibFilenameForm<'a> {
694 #[primary_span]
695 pub span: Span,
696 pub dll_prefix: &'a str,
697 pub dll_suffix: &'a str,
698}
699
700#[derive(Diagnostic)]
701#[diag(metadata_multiple_import_name_type)]
702pub struct MultipleImportNameType {
703 #[primary_span]
704 pub span: Span,
705}
706
707#[derive(Diagnostic)]
708#[diag(metadata_import_name_type_form)]
709pub struct ImportNameTypeForm {
710 #[primary_span]
711 pub span: Span,
712}
713
714#[derive(Diagnostic)]
715#[diag(metadata_import_name_type_x86)]
716pub struct ImportNameTypeX86 {
717 #[primary_span]
718 pub span: Span,
719}
720
721#[derive(Diagnostic)]
722#[diag(metadata_unknown_import_name_type)]
723pub struct UnknownImportNameType<'a> {
724 #[primary_span]
725 pub span: Span,
726 pub import_name_type: &'a str,
727}
728
729#[derive(Diagnostic)]
730#[diag(metadata_import_name_type_raw)]
731pub struct ImportNameTypeRaw {
732 #[primary_span]
733 pub span: Span,
734}
735
736#[derive(Diagnostic)]
737#[diag(metadata_wasm_c_abi)]
738pub(crate) struct WasmCAbi {
739 #[primary_span]
740 pub span: Span,
741}
742
743#[derive(Diagnostic)]
744#[diag(metadata_incompatible_target_modifiers)]
745#[help]
746#[note]
747#[help(metadata_incompatible_target_modifiers_help_fix)]
748#[help(metadata_incompatible_target_modifiers_help_allow)]
749pub struct IncompatibleTargetModifiers {
750 #[primary_span]
751 pub span: Span,
752 pub extern_crate: Symbol,
753 pub local_crate: Symbol,
754 pub flag_name: String,
755 pub flag_name_prefixed: String,
756 pub flag_local_value: String,
757 pub flag_extern_value: String,
758}
759
760#[derive(Diagnostic)]
761#[diag(metadata_unknown_target_modifier_unsafe_allowed)]
762pub struct UnknownTargetModifierUnsafeAllowed {
763 #[primary_span]
764 pub span: Span,
765 pub flag_name: String,
766}