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_crate_not_compiler_builtins)]
337pub struct CrateNotCompilerBuiltins {
338 pub crate_name: Symbol,
339}
340
341#[derive(Diagnostic)]
342#[diag(metadata_no_panic_strategy)]
343pub struct NoPanicStrategy {
344 pub crate_name: Symbol,
345 pub strategy: PanicStrategy,
346}
347
348#[derive(Diagnostic)]
349#[diag(metadata_not_profiler_runtime)]
350pub struct NotProfilerRuntime {
351 pub crate_name: Symbol,
352}
353
354#[derive(Diagnostic)]
355#[diag(metadata_no_multiple_global_alloc)]
356pub struct NoMultipleGlobalAlloc {
357 #[primary_span]
358 #[label]
359 pub span2: Span,
360 #[label(metadata_prev_global_alloc)]
361 pub span1: Span,
362}
363
364#[derive(Diagnostic)]
365#[diag(metadata_no_multiple_alloc_error_handler)]
366pub struct NoMultipleAllocErrorHandler {
367 #[primary_span]
368 #[label]
369 pub span2: Span,
370 #[label(metadata_prev_alloc_error_handler)]
371 pub span1: Span,
372}
373
374#[derive(Diagnostic)]
375#[diag(metadata_conflicting_global_alloc)]
376pub struct ConflictingGlobalAlloc {
377 pub crate_name: Symbol,
378 pub other_crate_name: Symbol,
379}
380
381#[derive(Diagnostic)]
382#[diag(metadata_conflicting_alloc_error_handler)]
383pub struct ConflictingAllocErrorHandler {
384 pub crate_name: Symbol,
385 pub other_crate_name: Symbol,
386}
387
388#[derive(Diagnostic)]
389#[diag(metadata_global_alloc_required)]
390pub struct GlobalAllocRequired;
391
392#[derive(Diagnostic)]
393#[diag(metadata_no_transitive_needs_dep)]
394pub struct NoTransitiveNeedsDep<'a> {
395 pub crate_name: Symbol,
396 pub needs_crate_name: &'a str,
397 pub deps_crate_name: Symbol,
398}
399
400#[derive(Diagnostic)]
401#[diag(metadata_failed_write_error)]
402pub struct FailedWriteError {
403 pub filename: PathBuf,
404 pub err: Error,
405}
406
407#[derive(Diagnostic)]
408#[diag(metadata_failed_copy_to_stdout)]
409pub struct FailedCopyToStdout {
410 pub filename: PathBuf,
411 pub err: Error,
412}
413
414#[derive(Diagnostic)]
415#[diag(metadata_binary_output_to_tty)]
416pub struct BinaryOutputToTty;
417
418#[derive(Diagnostic)]
419#[diag(metadata_missing_native_library)]
420pub struct MissingNativeLibrary<'a> {
421 libname: &'a str,
422 #[subdiagnostic]
423 suggest_name: Option<SuggestLibraryName<'a>>,
424}
425
426impl<'a> MissingNativeLibrary<'a> {
427 pub fn new(libname: &'a str, verbatim: bool) -> Self {
428 let suggested_name = if !verbatim {
431 if let Some(libname) = libname.strip_prefix("lib")
432 && let Some(libname) = libname.strip_suffix(".a")
433 {
434 Some(libname)
436 } else if let Some(libname) = libname.strip_suffix(".lib") {
437 Some(libname)
439 } else {
440 None
441 }
442 } else {
443 None
444 };
445
446 Self {
447 libname,
448 suggest_name: suggested_name
449 .map(|suggested_name| SuggestLibraryName { suggested_name }),
450 }
451 }
452}
453
454#[derive(Subdiagnostic)]
455#[help(metadata_only_provide_library_name)]
456pub struct SuggestLibraryName<'a> {
457 suggested_name: &'a str,
458}
459
460#[derive(Diagnostic)]
461#[diag(metadata_failed_create_tempdir)]
462pub struct FailedCreateTempdir {
463 pub err: Error,
464}
465
466#[derive(Diagnostic)]
467#[diag(metadata_failed_create_file)]
468pub struct FailedCreateFile<'a> {
469 pub filename: &'a Path,
470 pub err: Error,
471}
472
473#[derive(Diagnostic)]
474#[diag(metadata_failed_create_encoded_metadata)]
475pub struct FailedCreateEncodedMetadata {
476 pub err: Error,
477}
478
479#[derive(Diagnostic)]
480#[diag(metadata_non_ascii_name)]
481pub struct NonAsciiName {
482 #[primary_span]
483 pub span: Span,
484 pub crate_name: Symbol,
485}
486
487#[derive(Diagnostic)]
488#[diag(metadata_extern_location_not_exist)]
489pub struct ExternLocationNotExist<'a> {
490 #[primary_span]
491 pub span: Span,
492 pub crate_name: Symbol,
493 pub location: &'a Path,
494}
495
496#[derive(Diagnostic)]
497#[diag(metadata_extern_location_not_file)]
498pub struct ExternLocationNotFile<'a> {
499 #[primary_span]
500 pub span: Span,
501 pub crate_name: Symbol,
502 pub location: &'a Path,
503}
504
505pub(crate) struct MultipleCandidates {
506 pub span: Span,
507 pub flavor: CrateFlavor,
508 pub crate_name: Symbol,
509 pub candidates: Vec<PathBuf>,
510}
511
512impl<G: EmissionGuarantee> Diagnostic<'_, G> for MultipleCandidates {
513 fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
514 let mut diag = Diag::new(dcx, level, fluent::metadata_multiple_candidates);
515 diag.arg("crate_name", self.crate_name);
516 diag.arg("flavor", self.flavor);
517 diag.code(E0464);
518 diag.span(self.span);
519 for (i, candidate) in self.candidates.iter().enumerate() {
520 #[allow(rustc::untranslatable_diagnostic)]
522 diag.note(format!("candidate #{}: {}", i + 1, candidate.display()));
523 }
524 diag
525 }
526}
527
528#[derive(Diagnostic)]
529#[diag(metadata_symbol_conflicts_current, code = E0519)]
530pub struct SymbolConflictsCurrent {
531 #[primary_span]
532 pub span: Span,
533 pub crate_name: Symbol,
534}
535
536#[derive(Diagnostic)]
537#[diag(metadata_stable_crate_id_collision)]
538pub struct StableCrateIdCollision {
539 #[primary_span]
540 pub span: Span,
541 pub crate_name0: Symbol,
542 pub crate_name1: Symbol,
543}
544
545#[derive(Diagnostic)]
546#[diag(metadata_dl_error)]
547pub struct DlError {
548 #[primary_span]
549 pub span: Span,
550 pub path: String,
551 pub err: String,
552}
553
554#[derive(Diagnostic)]
555#[diag(metadata_newer_crate_version, code = E0460)]
556#[note]
557#[note(metadata_found_crate_versions)]
558pub struct NewerCrateVersion {
559 #[primary_span]
560 pub span: Span,
561 pub crate_name: Symbol,
562 pub add_info: String,
563 pub found_crates: String,
564}
565
566#[derive(Diagnostic)]
567#[diag(metadata_no_crate_with_triple, code = E0461)]
568#[note(metadata_found_crate_versions)]
569pub struct NoCrateWithTriple<'a> {
570 #[primary_span]
571 pub span: Span,
572 pub crate_name: Symbol,
573 pub locator_triple: &'a str,
574 pub add_info: String,
575 pub found_crates: String,
576}
577
578#[derive(Diagnostic)]
579#[diag(metadata_found_staticlib, code = E0462)]
580#[note(metadata_found_crate_versions)]
581#[help]
582pub struct FoundStaticlib {
583 #[primary_span]
584 pub span: Span,
585 pub crate_name: Symbol,
586 pub add_info: String,
587 pub found_crates: String,
588}
589
590#[derive(Diagnostic)]
591#[diag(metadata_incompatible_rustc, code = E0514)]
592#[note(metadata_found_crate_versions)]
593#[help]
594pub struct IncompatibleRustc {
595 #[primary_span]
596 pub span: Span,
597 pub crate_name: Symbol,
598 pub add_info: String,
599 pub found_crates: String,
600 pub rustc_version: String,
601}
602
603pub struct InvalidMetadataFiles {
604 pub span: Span,
605 pub crate_name: Symbol,
606 pub add_info: String,
607 pub crate_rejections: Vec<String>,
608}
609
610impl<G: EmissionGuarantee> Diagnostic<'_, G> for InvalidMetadataFiles {
611 #[track_caller]
612 fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
613 let mut diag = Diag::new(dcx, level, fluent::metadata_invalid_meta_files);
614 diag.arg("crate_name", self.crate_name);
615 diag.arg("add_info", self.add_info);
616 diag.code(E0786);
617 diag.span(self.span);
618 for crate_rejection in self.crate_rejections {
619 #[allow(rustc::untranslatable_diagnostic)]
621 diag.note(crate_rejection);
622 }
623 diag
624 }
625}
626
627pub struct CannotFindCrate {
628 pub span: Span,
629 pub crate_name: Symbol,
630 pub add_info: String,
631 pub missing_core: bool,
632 pub current_crate: String,
633 pub is_nightly_build: bool,
634 pub profiler_runtime: Symbol,
635 pub locator_triple: TargetTuple,
636 pub is_ui_testing: bool,
637}
638
639impl<G: EmissionGuarantee> Diagnostic<'_, G> for CannotFindCrate {
640 #[track_caller]
641 fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
642 let mut diag = Diag::new(dcx, level, fluent::metadata_cannot_find_crate);
643 diag.arg("crate_name", self.crate_name);
644 diag.arg("current_crate", self.current_crate);
645 diag.arg("add_info", self.add_info);
646 diag.arg("locator_triple", self.locator_triple.tuple());
647 diag.code(E0463);
648 diag.span(self.span);
649 if self.crate_name == sym::std || self.crate_name == sym::core {
650 if self.missing_core {
651 diag.note(fluent::metadata_target_not_installed);
652 } else {
653 diag.note(fluent::metadata_target_no_std_support);
654 }
655
656 if self.missing_core {
657 if env!("CFG_RELEASE_CHANNEL") == "dev" && !self.is_ui_testing {
658 diag.help(fluent::metadata_consider_adding_std);
660 } else {
661 diag.help(fluent::metadata_consider_downloading_target);
665 }
666 }
667
668 if !self.missing_core && self.span.is_dummy() {
673 diag.note(fluent::metadata_std_required);
674 }
675 if self.is_nightly_build {
676 diag.help(fluent::metadata_consider_building_std);
677 }
678 } else if self.crate_name == self.profiler_runtime {
679 diag.note(fluent::metadata_compiler_missing_profiler);
680 } else if self.crate_name.as_str().starts_with("rustc_") {
681 diag.help(fluent::metadata_install_missing_components);
682 }
683 diag.span_label(self.span, fluent::metadata_cant_find_crate);
684 diag
685 }
686}
687
688#[derive(Diagnostic)]
689#[diag(metadata_crate_location_unknown_type)]
690pub struct CrateLocationUnknownType<'a> {
691 #[primary_span]
692 pub span: Span,
693 pub path: &'a Path,
694 pub crate_name: Symbol,
695}
696
697#[derive(Diagnostic)]
698#[diag(metadata_lib_filename_form)]
699pub struct LibFilenameForm<'a> {
700 #[primary_span]
701 pub span: Span,
702 pub dll_prefix: &'a str,
703 pub dll_suffix: &'a str,
704}
705
706#[derive(Diagnostic)]
707#[diag(metadata_multiple_import_name_type)]
708pub struct MultipleImportNameType {
709 #[primary_span]
710 pub span: Span,
711}
712
713#[derive(Diagnostic)]
714#[diag(metadata_import_name_type_form)]
715pub struct ImportNameTypeForm {
716 #[primary_span]
717 pub span: Span,
718}
719
720#[derive(Diagnostic)]
721#[diag(metadata_import_name_type_x86)]
722pub struct ImportNameTypeX86 {
723 #[primary_span]
724 pub span: Span,
725}
726
727#[derive(Diagnostic)]
728#[diag(metadata_unknown_import_name_type)]
729pub struct UnknownImportNameType<'a> {
730 #[primary_span]
731 pub span: Span,
732 pub import_name_type: &'a str,
733}
734
735#[derive(Diagnostic)]
736#[diag(metadata_import_name_type_raw)]
737pub struct ImportNameTypeRaw {
738 #[primary_span]
739 pub span: Span,
740}
741
742#[derive(Diagnostic)]
743#[diag(metadata_wasm_c_abi)]
744pub(crate) struct WasmCAbi {
745 #[primary_span]
746 pub span: Span,
747}
748
749#[derive(Diagnostic)]
750#[diag(metadata_incompatible_target_modifiers)]
751#[help]
752#[note]
753#[help(metadata_incompatible_target_modifiers_help_fix)]
754#[help(metadata_incompatible_target_modifiers_help_allow)]
755pub struct IncompatibleTargetModifiers {
756 #[primary_span]
757 pub span: Span,
758 pub extern_crate: Symbol,
759 pub local_crate: Symbol,
760 pub flag_name: String,
761 pub flag_name_prefixed: String,
762 pub flag_local_value: String,
763 pub flag_extern_value: String,
764}
765
766#[derive(Diagnostic)]
767#[diag(metadata_unknown_target_modifier_unsafe_allowed)]
768pub struct UnknownTargetModifierUnsafeAllowed {
769 #[primary_span]
770 pub span: Span,
771 pub flag_name: String,
772}