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    /// It's different from `crate_name` in main Diagnostic.
49    pub crate_name_: Symbol,
50}
51
52#[derive(Subdiagnostic)]
53#[help(metadata_crate_dep_rustc_driver)]
54pub struct RustcDriverHelp;
55
56#[derive(Diagnostic)]
57#[diag(metadata_two_panic_runtimes)]
58pub struct TwoPanicRuntimes {
59    pub prev_name: Symbol,
60    pub cur_name: Symbol,
61}
62
63#[derive(Diagnostic)]
64#[diag(metadata_bad_panic_strategy)]
65pub struct BadPanicStrategy {
66    pub runtime: Symbol,
67    pub strategy: PanicStrategy,
68}
69
70#[derive(Diagnostic)]
71#[diag(metadata_required_panic_strategy)]
72pub struct RequiredPanicStrategy {
73    pub crate_name: Symbol,
74    pub found_strategy: PanicStrategy,
75    pub desired_strategy: PanicStrategy,
76}
77
78#[derive(Diagnostic)]
79#[diag(metadata_incompatible_panic_in_drop_strategy)]
80pub struct IncompatiblePanicInDropStrategy {
81    pub crate_name: Symbol,
82    pub found_strategy: PanicStrategy,
83    pub desired_strategy: PanicStrategy,
84}
85
86#[derive(Diagnostic)]
87#[diag(metadata_multiple_names_in_link)]
88pub struct MultipleNamesInLink {
89    #[primary_span]
90    pub span: Span,
91}
92
93#[derive(Diagnostic)]
94#[diag(metadata_multiple_kinds_in_link)]
95pub struct MultipleKindsInLink {
96    #[primary_span]
97    pub span: Span,
98}
99
100#[derive(Diagnostic)]
101#[diag(metadata_link_name_form)]
102pub struct LinkNameForm {
103    #[primary_span]
104    pub span: Span,
105}
106
107#[derive(Diagnostic)]
108#[diag(metadata_link_kind_form)]
109pub struct LinkKindForm {
110    #[primary_span]
111    pub span: Span,
112}
113
114#[derive(Diagnostic)]
115#[diag(metadata_link_modifiers_form)]
116pub struct LinkModifiersForm {
117    #[primary_span]
118    pub span: Span,
119}
120
121#[derive(Diagnostic)]
122#[diag(metadata_link_cfg_form)]
123pub struct LinkCfgForm {
124    #[primary_span]
125    pub span: Span,
126}
127
128#[derive(Diagnostic)]
129#[diag(metadata_wasm_import_form)]
130pub struct WasmImportForm {
131    #[primary_span]
132    pub span: Span,
133}
134
135#[derive(Diagnostic)]
136#[diag(metadata_empty_link_name, code = E0454)]
137pub struct EmptyLinkName {
138    #[primary_span]
139    #[label]
140    pub span: Span,
141}
142
143#[derive(Diagnostic)]
144#[diag(metadata_link_framework_apple, code = E0455)]
145pub struct LinkFrameworkApple {
146    #[primary_span]
147    pub span: Span,
148}
149
150#[derive(Diagnostic)]
151#[diag(metadata_raw_dylib_only_windows, code = E0455)]
152pub struct RawDylibOnlyWindows {
153    #[primary_span]
154    pub span: Span,
155}
156
157#[derive(Diagnostic)]
158#[diag(metadata_unknown_link_kind, code = E0458)]
159pub struct UnknownLinkKind<'a> {
160    #[primary_span]
161    #[label]
162    pub span: Span,
163    pub kind: &'a str,
164}
165
166#[derive(Diagnostic)]
167#[diag(metadata_multiple_link_modifiers)]
168pub struct MultipleLinkModifiers {
169    #[primary_span]
170    pub span: Span,
171}
172
173#[derive(Diagnostic)]
174#[diag(metadata_multiple_cfgs)]
175pub struct MultipleCfgs {
176    #[primary_span]
177    pub span: Span,
178}
179
180#[derive(Diagnostic)]
181#[diag(metadata_link_cfg_single_predicate)]
182pub struct LinkCfgSinglePredicate {
183    #[primary_span]
184    pub span: Span,
185}
186
187#[derive(Diagnostic)]
188#[diag(metadata_multiple_wasm_import)]
189pub struct MultipleWasmImport {
190    #[primary_span]
191    pub span: Span,
192}
193
194#[derive(Diagnostic)]
195#[diag(metadata_unexpected_link_arg)]
196pub struct UnexpectedLinkArg {
197    #[primary_span]
198    pub span: Span,
199}
200
201#[derive(Diagnostic)]
202#[diag(metadata_invalid_link_modifier)]
203pub struct InvalidLinkModifier {
204    #[primary_span]
205    pub span: Span,
206}
207
208#[derive(Diagnostic)]
209#[diag(metadata_multiple_modifiers)]
210pub struct MultipleModifiers<'a> {
211    #[primary_span]
212    pub span: Span,
213    pub modifier: &'a str,
214}
215
216#[derive(Diagnostic)]
217#[diag(metadata_bundle_needs_static)]
218pub struct BundleNeedsStatic {
219    #[primary_span]
220    pub span: Span,
221}
222
223#[derive(Diagnostic)]
224#[diag(metadata_whole_archive_needs_static)]
225pub struct WholeArchiveNeedsStatic {
226    #[primary_span]
227    pub span: Span,
228}
229
230#[derive(Diagnostic)]
231#[diag(metadata_as_needed_compatibility)]
232pub struct AsNeededCompatibility {
233    #[primary_span]
234    pub span: Span,
235}
236
237#[derive(Diagnostic)]
238#[diag(metadata_unknown_link_modifier)]
239pub struct UnknownLinkModifier<'a> {
240    #[primary_span]
241    pub span: Span,
242    pub modifier: &'a str,
243}
244
245#[derive(Diagnostic)]
246#[diag(metadata_incompatible_wasm_link)]
247pub struct IncompatibleWasmLink {
248    #[primary_span]
249    pub span: Span,
250}
251
252#[derive(Diagnostic)]
253#[diag(metadata_link_requires_name, code = E0459)]
254pub struct LinkRequiresName {
255    #[primary_span]
256    #[label]
257    pub span: Span,
258}
259
260#[derive(Diagnostic)]
261#[diag(metadata_raw_dylib_no_nul)]
262pub struct RawDylibNoNul {
263    #[primary_span]
264    pub span: Span,
265}
266
267#[derive(Diagnostic)]
268#[diag(metadata_link_ordinal_raw_dylib)]
269pub struct LinkOrdinalRawDylib {
270    #[primary_span]
271    pub span: Span,
272}
273
274#[derive(Diagnostic)]
275#[diag(metadata_lib_framework_apple)]
276pub struct LibFrameworkApple;
277
278#[derive(Diagnostic)]
279#[diag(metadata_empty_renaming_target)]
280pub struct EmptyRenamingTarget<'a> {
281    pub lib_name: &'a str,
282}
283
284#[derive(Diagnostic)]
285#[diag(metadata_renaming_no_link)]
286pub struct RenamingNoLink<'a> {
287    pub lib_name: &'a str,
288}
289
290#[derive(Diagnostic)]
291#[diag(metadata_multiple_renamings)]
292pub struct MultipleRenamings<'a> {
293    pub lib_name: &'a str,
294}
295
296#[derive(Diagnostic)]
297#[diag(metadata_no_link_mod_override)]
298pub struct NoLinkModOverride {
299    #[primary_span]
300    pub span: Option<Span>,
301}
302
303#[derive(Diagnostic)]
304#[diag(metadata_raw_dylib_unsupported_abi)]
305pub struct RawDylibUnsupportedAbi {
306    #[primary_span]
307    pub span: Span,
308}
309
310#[derive(Diagnostic)]
311#[diag(metadata_fail_create_file_encoder)]
312pub struct FailCreateFileEncoder {
313    pub err: Error,
314}
315
316#[derive(Diagnostic)]
317#[diag(metadata_fail_write_file)]
318pub struct FailWriteFile<'a> {
319    pub path: &'a Path,
320    pub err: Error,
321}
322
323#[derive(Diagnostic)]
324#[diag(metadata_crate_not_panic_runtime)]
325pub struct CrateNotPanicRuntime {
326    pub crate_name: Symbol,
327}
328
329#[derive(Diagnostic)]
330#[diag(metadata_crate_not_compiler_builtins)]
331pub struct CrateNotCompilerBuiltins {
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        // if it looks like the user has provided a complete filename rather just the bare lib name,
423        // then provide a note that they might want to try trimming the name
424        let suggested_name = if !verbatim {
425            if let Some(libname) = libname.strip_prefix("lib")
426                && let Some(libname) = libname.strip_suffix(".a")
427            {
428                // this is a unix style filename so trim prefix & suffix
429                Some(libname)
430            } else if let Some(libname) = libname.strip_suffix(".lib") {
431                // this is a Windows style filename so just trim the suffix
432                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            // FIXME: make this translatable
515            #[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_full_metadata_not_found)]
524pub(crate) struct FullMetadataNotFound {
525    #[primary_span]
526    pub span: Span,
527    pub flavor: CrateFlavor,
528    pub crate_name: Symbol,
529}
530
531#[derive(Diagnostic)]
532#[diag(metadata_symbol_conflicts_current, code = E0519)]
533pub struct SymbolConflictsCurrent {
534    #[primary_span]
535    pub span: Span,
536    pub crate_name: Symbol,
537}
538
539#[derive(Diagnostic)]
540#[diag(metadata_stable_crate_id_collision)]
541pub struct StableCrateIdCollision {
542    #[primary_span]
543    pub span: Span,
544    pub crate_name0: Symbol,
545    pub crate_name1: Symbol,
546}
547
548#[derive(Diagnostic)]
549#[diag(metadata_dl_error)]
550pub struct DlError {
551    #[primary_span]
552    pub span: Span,
553    pub path: String,
554    pub err: String,
555}
556
557#[derive(Diagnostic)]
558#[diag(metadata_newer_crate_version, code = E0460)]
559#[note]
560#[note(metadata_found_crate_versions)]
561pub struct NewerCrateVersion {
562    #[primary_span]
563    pub span: Span,
564    pub crate_name: Symbol,
565    pub add_info: String,
566    pub found_crates: String,
567}
568
569#[derive(Diagnostic)]
570#[diag(metadata_no_crate_with_triple, code = E0461)]
571#[note(metadata_found_crate_versions)]
572pub struct NoCrateWithTriple<'a> {
573    #[primary_span]
574    pub span: Span,
575    pub crate_name: Symbol,
576    pub locator_triple: &'a str,
577    pub add_info: String,
578    pub found_crates: String,
579}
580
581#[derive(Diagnostic)]
582#[diag(metadata_found_staticlib, code = E0462)]
583#[note(metadata_found_crate_versions)]
584#[help]
585pub struct FoundStaticlib {
586    #[primary_span]
587    pub span: Span,
588    pub crate_name: Symbol,
589    pub add_info: String,
590    pub found_crates: String,
591}
592
593#[derive(Diagnostic)]
594#[diag(metadata_incompatible_rustc, code = E0514)]
595#[note(metadata_found_crate_versions)]
596#[help]
597pub struct IncompatibleRustc {
598    #[primary_span]
599    pub span: Span,
600    pub crate_name: Symbol,
601    pub add_info: String,
602    pub found_crates: String,
603    pub rustc_version: String,
604}
605
606pub struct InvalidMetadataFiles {
607    pub span: Span,
608    pub crate_name: Symbol,
609    pub add_info: String,
610    pub crate_rejections: Vec<String>,
611}
612
613impl<G: EmissionGuarantee> Diagnostic<'_, G> for InvalidMetadataFiles {
614    #[track_caller]
615    fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
616        let mut diag = Diag::new(dcx, level, fluent::metadata_invalid_meta_files);
617        diag.arg("crate_name", self.crate_name);
618        diag.arg("add_info", self.add_info);
619        diag.code(E0786);
620        diag.span(self.span);
621        for crate_rejection in self.crate_rejections {
622            // FIXME: make this translatable
623            #[allow(rustc::untranslatable_diagnostic)]
624            diag.note(crate_rejection);
625        }
626        diag
627    }
628}
629
630pub struct CannotFindCrate {
631    pub span: Span,
632    pub crate_name: Symbol,
633    pub add_info: String,
634    pub missing_core: bool,
635    pub current_crate: String,
636    pub is_nightly_build: bool,
637    pub profiler_runtime: Symbol,
638    pub locator_triple: TargetTuple,
639    pub is_ui_testing: bool,
640}
641
642impl<G: EmissionGuarantee> Diagnostic<'_, G> for CannotFindCrate {
643    #[track_caller]
644    fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
645        let mut diag = Diag::new(dcx, level, fluent::metadata_cannot_find_crate);
646        diag.arg("crate_name", self.crate_name);
647        diag.arg("current_crate", self.current_crate);
648        diag.arg("add_info", self.add_info);
649        diag.arg("locator_triple", self.locator_triple.tuple());
650        diag.code(E0463);
651        diag.span(self.span);
652        if self.crate_name == sym::std || self.crate_name == sym::core {
653            if self.missing_core {
654                diag.note(fluent::metadata_target_not_installed);
655            } else {
656                diag.note(fluent::metadata_target_no_std_support);
657            }
658
659            if self.missing_core {
660                if env!("CFG_RELEASE_CHANNEL") == "dev" && !self.is_ui_testing {
661                    // Note: Emits the nicer suggestion only for the dev channel.
662                    diag.help(fluent::metadata_consider_adding_std);
663                } else {
664                    // NOTE: this suggests using rustup, even though the user may not have it installed.
665                    // That's because they could choose to install it; or this may give them a hint which
666                    // target they need to install from their distro.
667                    diag.help(fluent::metadata_consider_downloading_target);
668                }
669            }
670
671            // Suggest using #![no_std]. #[no_core] is unstable and not really supported anyway.
672            // NOTE: this is a dummy span if `extern crate std` was injected by the compiler.
673            // If it's not a dummy, that means someone added `extern crate std` explicitly and
674            // `#![no_std]` won't help.
675            if !self.missing_core && self.span.is_dummy() {
676                diag.note(fluent::metadata_std_required);
677            }
678            if self.is_nightly_build {
679                diag.help(fluent::metadata_consider_building_std);
680            }
681        } else if self.crate_name == self.profiler_runtime {
682            diag.note(fluent::metadata_compiler_missing_profiler);
683        } else if self.crate_name.as_str().starts_with("rustc_") {
684            diag.help(fluent::metadata_install_missing_components);
685        }
686        diag.span_label(self.span, fluent::metadata_cant_find_crate);
687        diag
688    }
689}
690
691#[derive(Diagnostic)]
692#[diag(metadata_crate_location_unknown_type)]
693pub struct CrateLocationUnknownType<'a> {
694    #[primary_span]
695    pub span: Span,
696    pub path: &'a Path,
697    pub crate_name: Symbol,
698}
699
700#[derive(Diagnostic)]
701#[diag(metadata_lib_filename_form)]
702pub struct LibFilenameForm<'a> {
703    #[primary_span]
704    pub span: Span,
705    pub dll_prefix: &'a str,
706    pub dll_suffix: &'a str,
707}
708
709#[derive(Diagnostic)]
710#[diag(metadata_multiple_import_name_type)]
711pub struct MultipleImportNameType {
712    #[primary_span]
713    pub span: Span,
714}
715
716#[derive(Diagnostic)]
717#[diag(metadata_import_name_type_form)]
718pub struct ImportNameTypeForm {
719    #[primary_span]
720    pub span: Span,
721}
722
723#[derive(Diagnostic)]
724#[diag(metadata_import_name_type_x86)]
725pub struct ImportNameTypeX86 {
726    #[primary_span]
727    pub span: Span,
728}
729
730#[derive(Diagnostic)]
731#[diag(metadata_unknown_import_name_type)]
732pub struct UnknownImportNameType<'a> {
733    #[primary_span]
734    pub span: Span,
735    pub import_name_type: &'a str,
736}
737
738#[derive(Diagnostic)]
739#[diag(metadata_import_name_type_raw)]
740pub struct ImportNameTypeRaw {
741    #[primary_span]
742    pub span: Span,
743}
744
745#[derive(Diagnostic)]
746#[diag(metadata_wasm_c_abi)]
747pub(crate) struct WasmCAbi {
748    #[primary_span]
749    pub span: Span,
750}
751
752#[derive(Diagnostic)]
753#[diag(metadata_incompatible_target_modifiers)]
754#[help]
755#[note]
756#[help(metadata_incompatible_target_modifiers_help_fix)]
757#[help(metadata_incompatible_target_modifiers_help_allow)]
758pub struct IncompatibleTargetModifiers {
759    #[primary_span]
760    pub span: Span,
761    pub extern_crate: Symbol,
762    pub local_crate: Symbol,
763    pub flag_name: String,
764    pub flag_name_prefixed: String,
765    pub local_value: String,
766    pub extern_value: String,
767}
768
769#[derive(Diagnostic)]
770#[diag(metadata_incompatible_target_modifiers_l_missed)]
771#[help]
772#[note]
773#[help(metadata_incompatible_target_modifiers_help_fix_l_missed)]
774#[help(metadata_incompatible_target_modifiers_help_allow)]
775pub struct IncompatibleTargetModifiersLMissed {
776    #[primary_span]
777    pub span: Span,
778    pub extern_crate: Symbol,
779    pub local_crate: Symbol,
780    pub flag_name: String,
781    pub flag_name_prefixed: String,
782    pub extern_value: String,
783}
784
785#[derive(Diagnostic)]
786#[diag(metadata_incompatible_target_modifiers_r_missed)]
787#[help]
788#[note]
789#[help(metadata_incompatible_target_modifiers_help_fix_r_missed)]
790#[help(metadata_incompatible_target_modifiers_help_allow)]
791pub struct IncompatibleTargetModifiersRMissed {
792    #[primary_span]
793    pub span: Span,
794    pub extern_crate: Symbol,
795    pub local_crate: Symbol,
796    pub flag_name: String,
797    pub flag_name_prefixed: String,
798    pub local_value: String,
799}
800
801#[derive(Diagnostic)]
802#[diag(metadata_unknown_target_modifier_unsafe_allowed)]
803pub struct UnknownTargetModifierUnsafeAllowed {
804    #[primary_span]
805    pub span: Span,
806    pub flag_name: String,
807}
808
809#[derive(Diagnostic)]
810#[diag(metadata_async_drop_types_in_dependency)]
811#[help]
812pub struct AsyncDropTypesInDependency {
813    #[primary_span]
814    pub span: Span,
815    pub extern_crate: Symbol,
816    pub local_crate: Symbol,
817}