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 let suggested_name = if !verbatim {
424 if let Some(libname) = libname.strip_prefix("lib")
425 && let Some(libname) = libname.strip_suffix(".a")
426 {
427 Some(libname)
429 } else if let Some(libname) = libname.strip_suffix(".lib") {
430 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 #[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 #[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 diag.help(fluent::metadata_consider_adding_std);
662 } else {
663 diag.help(fluent::metadata_consider_downloading_target);
667 }
668 }
669
670 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}