rustc_metadata/
errors.rs

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_raw_dylib_unsupported_abi)]
304pub struct RawDylibUnsupportedAbi {
305    #[primary_span]
306    pub span: Span,
307}
308
309#[derive(Diagnostic)]
310#[diag(metadata_fail_create_file_encoder)]
311pub struct FailCreateFileEncoder {
312    pub err: Error,
313}
314
315#[derive(Diagnostic)]
316#[diag(metadata_fail_write_file)]
317pub struct FailWriteFile<'a> {
318    pub path: &'a Path,
319    pub err: Error,
320}
321
322#[derive(Diagnostic)]
323#[diag(metadata_crate_not_panic_runtime)]
324pub struct CrateNotPanicRuntime {
325    pub crate_name: Symbol,
326}
327
328#[derive(Diagnostic)]
329#[diag(metadata_crate_not_compiler_builtins)]
330pub struct CrateNotCompilerBuiltins {
331    pub crate_name: Symbol,
332}
333
334#[derive(Diagnostic)]
335#[diag(metadata_no_panic_strategy)]
336pub struct NoPanicStrategy {
337    pub crate_name: Symbol,
338    pub strategy: PanicStrategy,
339}
340
341#[derive(Diagnostic)]
342#[diag(metadata_not_profiler_runtime)]
343pub struct NotProfilerRuntime {
344    pub crate_name: Symbol,
345}
346
347#[derive(Diagnostic)]
348#[diag(metadata_no_multiple_global_alloc)]
349pub struct NoMultipleGlobalAlloc {
350    #[primary_span]
351    #[label]
352    pub span2: Span,
353    #[label(metadata_prev_global_alloc)]
354    pub span1: Span,
355}
356
357#[derive(Diagnostic)]
358#[diag(metadata_no_multiple_alloc_error_handler)]
359pub struct NoMultipleAllocErrorHandler {
360    #[primary_span]
361    #[label]
362    pub span2: Span,
363    #[label(metadata_prev_alloc_error_handler)]
364    pub span1: Span,
365}
366
367#[derive(Diagnostic)]
368#[diag(metadata_conflicting_global_alloc)]
369pub struct ConflictingGlobalAlloc {
370    pub crate_name: Symbol,
371    pub other_crate_name: Symbol,
372}
373
374#[derive(Diagnostic)]
375#[diag(metadata_conflicting_alloc_error_handler)]
376pub struct ConflictingAllocErrorHandler {
377    pub crate_name: Symbol,
378    pub other_crate_name: Symbol,
379}
380
381#[derive(Diagnostic)]
382#[diag(metadata_global_alloc_required)]
383pub struct GlobalAllocRequired;
384
385#[derive(Diagnostic)]
386#[diag(metadata_no_transitive_needs_dep)]
387pub struct NoTransitiveNeedsDep<'a> {
388    pub crate_name: Symbol,
389    pub needs_crate_name: &'a str,
390    pub deps_crate_name: Symbol,
391}
392
393#[derive(Diagnostic)]
394#[diag(metadata_failed_write_error)]
395pub struct FailedWriteError {
396    pub filename: PathBuf,
397    pub err: Error,
398}
399
400#[derive(Diagnostic)]
401#[diag(metadata_failed_copy_to_stdout)]
402pub struct FailedCopyToStdout {
403    pub filename: PathBuf,
404    pub err: Error,
405}
406
407#[derive(Diagnostic)]
408#[diag(metadata_binary_output_to_tty)]
409pub struct BinaryOutputToTty;
410
411#[derive(Diagnostic)]
412#[diag(metadata_missing_native_library)]
413pub struct MissingNativeLibrary<'a> {
414    libname: &'a str,
415    #[subdiagnostic]
416    suggest_name: Option<SuggestLibraryName<'a>>,
417}
418
419impl<'a> MissingNativeLibrary<'a> {
420    pub fn new(libname: &'a str, verbatim: bool) -> Self {
421        // if it looks like the user has provided a complete filename rather just the bare lib name,
422        // then provide a note that they might want to try trimming the name
423        let suggested_name = if !verbatim {
424            if let Some(libname) = libname.strip_prefix("lib")
425                && let Some(libname) = libname.strip_suffix(".a")
426            {
427                // this is a unix style filename so trim prefix & suffix
428                Some(libname)
429            } else if let Some(libname) = libname.strip_suffix(".lib") {
430                // this is a Windows style filename so just trim the suffix
431                Some(libname)
432            } else {
433                None
434            }
435        } else {
436            None
437        };
438
439        Self {
440            libname,
441            suggest_name: suggested_name
442                .map(|suggested_name| SuggestLibraryName { suggested_name }),
443        }
444    }
445}
446
447#[derive(Subdiagnostic)]
448#[help(metadata_only_provide_library_name)]
449pub struct SuggestLibraryName<'a> {
450    suggested_name: &'a str,
451}
452
453#[derive(Diagnostic)]
454#[diag(metadata_failed_create_tempdir)]
455pub struct FailedCreateTempdir {
456    pub err: Error,
457}
458
459#[derive(Diagnostic)]
460#[diag(metadata_failed_create_file)]
461pub struct FailedCreateFile<'a> {
462    pub filename: &'a Path,
463    pub err: Error,
464}
465
466#[derive(Diagnostic)]
467#[diag(metadata_failed_create_encoded_metadata)]
468pub struct FailedCreateEncodedMetadata {
469    pub err: Error,
470}
471
472#[derive(Diagnostic)]
473#[diag(metadata_non_ascii_name)]
474pub struct NonAsciiName {
475    #[primary_span]
476    pub span: Span,
477    pub crate_name: Symbol,
478}
479
480#[derive(Diagnostic)]
481#[diag(metadata_extern_location_not_exist)]
482pub struct ExternLocationNotExist<'a> {
483    #[primary_span]
484    pub span: Span,
485    pub crate_name: Symbol,
486    pub location: &'a Path,
487}
488
489#[derive(Diagnostic)]
490#[diag(metadata_extern_location_not_file)]
491pub struct ExternLocationNotFile<'a> {
492    #[primary_span]
493    pub span: Span,
494    pub crate_name: Symbol,
495    pub location: &'a Path,
496}
497
498pub(crate) struct MultipleCandidates {
499    pub span: Span,
500    pub flavor: CrateFlavor,
501    pub crate_name: Symbol,
502    pub candidates: Vec<PathBuf>,
503}
504
505impl<G: EmissionGuarantee> Diagnostic<'_, G> for MultipleCandidates {
506    fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
507        let mut diag = Diag::new(dcx, level, fluent::metadata_multiple_candidates);
508        diag.arg("crate_name", self.crate_name);
509        diag.arg("flavor", self.flavor);
510        diag.code(E0464);
511        diag.span(self.span);
512        for (i, candidate) in self.candidates.iter().enumerate() {
513            // FIXME: make this translatable
514            #[allow(rustc::untranslatable_diagnostic)]
515            diag.note(format!("candidate #{}: {}", i + 1, candidate.display()));
516        }
517        diag
518    }
519}
520
521#[derive(Diagnostic)]
522#[diag(metadata_full_metadata_not_found)]
523pub(crate) struct FullMetadataNotFound {
524    #[primary_span]
525    pub span: Span,
526    pub flavor: CrateFlavor,
527    pub crate_name: Symbol,
528}
529
530#[derive(Diagnostic)]
531#[diag(metadata_symbol_conflicts_current, code = E0519)]
532pub struct SymbolConflictsCurrent {
533    #[primary_span]
534    pub span: Span,
535    pub crate_name: Symbol,
536}
537
538#[derive(Diagnostic)]
539#[diag(metadata_stable_crate_id_collision)]
540pub struct StableCrateIdCollision {
541    #[primary_span]
542    pub span: Span,
543    pub crate_name0: Symbol,
544    pub crate_name1: Symbol,
545}
546
547#[derive(Diagnostic)]
548#[diag(metadata_dl_error)]
549pub struct DlError {
550    #[primary_span]
551    pub span: Span,
552    pub path: String,
553    pub err: String,
554}
555
556#[derive(Diagnostic)]
557#[diag(metadata_newer_crate_version, code = E0460)]
558#[note]
559#[note(metadata_found_crate_versions)]
560pub struct NewerCrateVersion {
561    #[primary_span]
562    pub span: Span,
563    pub crate_name: Symbol,
564    pub add_info: String,
565    pub found_crates: String,
566}
567
568#[derive(Diagnostic)]
569#[diag(metadata_no_crate_with_triple, code = E0461)]
570#[note(metadata_found_crate_versions)]
571pub struct NoCrateWithTriple<'a> {
572    #[primary_span]
573    pub span: Span,
574    pub crate_name: Symbol,
575    pub locator_triple: &'a str,
576    pub add_info: String,
577    pub found_crates: String,
578}
579
580#[derive(Diagnostic)]
581#[diag(metadata_found_staticlib, code = E0462)]
582#[note(metadata_found_crate_versions)]
583#[help]
584pub struct FoundStaticlib {
585    #[primary_span]
586    pub span: Span,
587    pub crate_name: Symbol,
588    pub add_info: String,
589    pub found_crates: String,
590}
591
592#[derive(Diagnostic)]
593#[diag(metadata_incompatible_rustc, code = E0514)]
594#[note(metadata_found_crate_versions)]
595#[help]
596pub struct IncompatibleRustc {
597    #[primary_span]
598    pub span: Span,
599    pub crate_name: Symbol,
600    pub add_info: String,
601    pub found_crates: String,
602    pub rustc_version: String,
603}
604
605pub struct InvalidMetadataFiles {
606    pub span: Span,
607    pub crate_name: Symbol,
608    pub add_info: String,
609    pub crate_rejections: Vec<String>,
610}
611
612impl<G: EmissionGuarantee> Diagnostic<'_, G> for InvalidMetadataFiles {
613    #[track_caller]
614    fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
615        let mut diag = Diag::new(dcx, level, fluent::metadata_invalid_meta_files);
616        diag.arg("crate_name", self.crate_name);
617        diag.arg("add_info", self.add_info);
618        diag.code(E0786);
619        diag.span(self.span);
620        for crate_rejection in self.crate_rejections {
621            // FIXME: make this translatable
622            #[allow(rustc::untranslatable_diagnostic)]
623            diag.note(crate_rejection);
624        }
625        diag
626    }
627}
628
629pub struct CannotFindCrate {
630    pub span: Span,
631    pub crate_name: Symbol,
632    pub add_info: String,
633    pub missing_core: bool,
634    pub current_crate: String,
635    pub is_nightly_build: bool,
636    pub profiler_runtime: Symbol,
637    pub locator_triple: TargetTuple,
638    pub is_ui_testing: bool,
639}
640
641impl<G: EmissionGuarantee> Diagnostic<'_, G> for CannotFindCrate {
642    #[track_caller]
643    fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
644        let mut diag = Diag::new(dcx, level, fluent::metadata_cannot_find_crate);
645        diag.arg("crate_name", self.crate_name);
646        diag.arg("current_crate", self.current_crate);
647        diag.arg("add_info", self.add_info);
648        diag.arg("locator_triple", self.locator_triple.tuple());
649        diag.code(E0463);
650        diag.span(self.span);
651        if self.crate_name == sym::std || self.crate_name == sym::core {
652            if self.missing_core {
653                diag.note(fluent::metadata_target_not_installed);
654            } else {
655                diag.note(fluent::metadata_target_no_std_support);
656            }
657
658            if self.missing_core {
659                if env!("CFG_RELEASE_CHANNEL") == "dev" && !self.is_ui_testing {
660                    // Note: Emits the nicer suggestion only for the dev channel.
661                    diag.help(fluent::metadata_consider_adding_std);
662                } else {
663                    // NOTE: this suggests using rustup, even though the user may not have it installed.
664                    // That's because they could choose to install it; or this may give them a hint which
665                    // target they need to install from their distro.
666                    diag.help(fluent::metadata_consider_downloading_target);
667                }
668            }
669
670            // Suggest using #![no_std]. #[no_core] is unstable and not really supported anyway.
671            // NOTE: this is a dummy span if `extern crate std` was injected by the compiler.
672            // If it's not a dummy, that means someone added `extern crate std` explicitly and
673            // `#![no_std]` won't help.
674            if !self.missing_core && self.span.is_dummy() {
675                diag.note(fluent::metadata_std_required);
676            }
677            if self.is_nightly_build {
678                diag.help(fluent::metadata_consider_building_std);
679            }
680        } else if self.crate_name == self.profiler_runtime {
681            diag.note(fluent::metadata_compiler_missing_profiler);
682        } else if self.crate_name.as_str().starts_with("rustc_") {
683            diag.help(fluent::metadata_install_missing_components);
684        }
685        diag.span_label(self.span, fluent::metadata_cant_find_crate);
686        diag
687    }
688}
689
690#[derive(Diagnostic)]
691#[diag(metadata_crate_location_unknown_type)]
692pub struct CrateLocationUnknownType<'a> {
693    #[primary_span]
694    pub span: Span,
695    pub path: &'a Path,
696    pub crate_name: Symbol,
697}
698
699#[derive(Diagnostic)]
700#[diag(metadata_lib_filename_form)]
701pub struct LibFilenameForm<'a> {
702    #[primary_span]
703    pub span: Span,
704    pub dll_prefix: &'a str,
705    pub dll_suffix: &'a str,
706}
707
708#[derive(Diagnostic)]
709#[diag(metadata_multiple_import_name_type)]
710pub struct MultipleImportNameType {
711    #[primary_span]
712    pub span: Span,
713}
714
715#[derive(Diagnostic)]
716#[diag(metadata_import_name_type_form)]
717pub struct ImportNameTypeForm {
718    #[primary_span]
719    pub span: Span,
720}
721
722#[derive(Diagnostic)]
723#[diag(metadata_import_name_type_x86)]
724pub struct ImportNameTypeX86 {
725    #[primary_span]
726    pub span: Span,
727}
728
729#[derive(Diagnostic)]
730#[diag(metadata_unknown_import_name_type)]
731pub struct UnknownImportNameType<'a> {
732    #[primary_span]
733    pub span: Span,
734    pub import_name_type: &'a str,
735}
736
737#[derive(Diagnostic)]
738#[diag(metadata_import_name_type_raw)]
739pub struct ImportNameTypeRaw {
740    #[primary_span]
741    pub span: Span,
742}
743
744#[derive(Diagnostic)]
745#[diag(metadata_wasm_c_abi)]
746pub(crate) struct WasmCAbi {
747    #[primary_span]
748    pub span: Span,
749}
750
751#[derive(Diagnostic)]
752#[diag(metadata_incompatible_target_modifiers)]
753#[help]
754#[note]
755#[help(metadata_incompatible_target_modifiers_help_fix)]
756#[help(metadata_incompatible_target_modifiers_help_allow)]
757pub struct IncompatibleTargetModifiers {
758    #[primary_span]
759    pub span: Span,
760    pub extern_crate: Symbol,
761    pub local_crate: Symbol,
762    pub flag_name: String,
763    pub flag_name_prefixed: String,
764    pub local_value: String,
765    pub extern_value: String,
766}
767
768#[derive(Diagnostic)]
769#[diag(metadata_incompatible_target_modifiers_l_missed)]
770#[help]
771#[note]
772#[help(metadata_incompatible_target_modifiers_help_fix_l_missed)]
773#[help(metadata_incompatible_target_modifiers_help_allow)]
774pub struct IncompatibleTargetModifiersLMissed {
775    #[primary_span]
776    pub span: Span,
777    pub extern_crate: Symbol,
778    pub local_crate: Symbol,
779    pub flag_name: String,
780    pub flag_name_prefixed: String,
781    pub extern_value: String,
782}
783
784#[derive(Diagnostic)]
785#[diag(metadata_incompatible_target_modifiers_r_missed)]
786#[help]
787#[note]
788#[help(metadata_incompatible_target_modifiers_help_fix_r_missed)]
789#[help(metadata_incompatible_target_modifiers_help_allow)]
790pub struct IncompatibleTargetModifiersRMissed {
791    #[primary_span]
792    pub span: Span,
793    pub extern_crate: Symbol,
794    pub local_crate: Symbol,
795    pub flag_name: String,
796    pub flag_name_prefixed: String,
797    pub local_value: String,
798}
799
800#[derive(Diagnostic)]
801#[diag(metadata_unknown_target_modifier_unsafe_allowed)]
802pub struct UnknownTargetModifierUnsafeAllowed {
803    #[primary_span]
804    pub span: Span,
805    pub flag_name: String,
806}
807
808#[derive(Diagnostic)]
809#[diag(metadata_async_drop_types_in_dependency)]
810#[help]
811pub struct AsyncDropTypesInDependency {
812    #[primary_span]
813    pub span: Span,
814    pub extern_crate: Symbol,
815    pub local_crate: Symbol,
816}