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_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        // if it looks like the user has provided a complete filename rather just the bare lib name,
429        // then provide a note that they might want to try trimming the name
430        let suggested_name = if !verbatim {
431            if let Some(libname) = libname.strip_prefix("lib")
432                && let Some(libname) = libname.strip_suffix(".a")
433            {
434                // this is a unix style filename so trim prefix & suffix
435                Some(libname)
436            } else if let Some(libname) = libname.strip_suffix(".lib") {
437                // this is a Windows style filename so just trim the suffix
438                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            // FIXME: make this translatable
521            #[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            // FIXME: make this translatable
620            #[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                    // Note: Emits the nicer suggestion only for the dev channel.
659                    diag.help(fluent::metadata_consider_adding_std);
660                } else {
661                    // NOTE: this suggests using rustup, even though the user may not have it installed.
662                    // That's because they could choose to install it; or this may give them a hint which
663                    // target they need to install from their distro.
664                    diag.help(fluent::metadata_consider_downloading_target);
665                }
666            }
667
668            // Suggest using #![no_std]. #[no_core] is unstable and not really supported anyway.
669            // NOTE: this is a dummy span if `extern crate std` was injected by the compiler.
670            // If it's not a dummy, that means someone added `extern crate std` explicitly and
671            // `#![no_std]` won't help.
672            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 local_value: String,
763    pub extern_value: String,
764}
765
766#[derive(Diagnostic)]
767#[diag(metadata_incompatible_target_modifiers_l_missed)]
768#[help]
769#[note]
770#[help(metadata_incompatible_target_modifiers_help_fix_l_missed)]
771#[help(metadata_incompatible_target_modifiers_help_allow)]
772pub struct IncompatibleTargetModifiersLMissed {
773    #[primary_span]
774    pub span: Span,
775    pub extern_crate: Symbol,
776    pub local_crate: Symbol,
777    pub flag_name: String,
778    pub flag_name_prefixed: String,
779    pub extern_value: String,
780}
781
782#[derive(Diagnostic)]
783#[diag(metadata_incompatible_target_modifiers_r_missed)]
784#[help]
785#[note]
786#[help(metadata_incompatible_target_modifiers_help_fix_r_missed)]
787#[help(metadata_incompatible_target_modifiers_help_allow)]
788pub struct IncompatibleTargetModifiersRMissed {
789    #[primary_span]
790    pub span: Span,
791    pub extern_crate: Symbol,
792    pub local_crate: Symbol,
793    pub flag_name: String,
794    pub flag_name_prefixed: String,
795    pub local_value: String,
796}
797
798#[derive(Diagnostic)]
799#[diag(metadata_unknown_target_modifier_unsafe_allowed)]
800pub struct UnknownTargetModifierUnsafeAllowed {
801    #[primary_span]
802    pub span: Span,
803    pub flag_name: String,
804}