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