compiler/rustc_metadata/src/errors.rs

   1 use std::{
   2     io::Error,
   3     path::{Path, PathBuf},
   4 };
   5
   6 use rustc_errors::{error_code, ErrorGuaranteed, IntoDiagnostic};
   7 use rustc_macros::Diagnostic;
   8 use rustc_session::config;
   9 use rustc_span::{sym, Span, Symbol};
  10 use rustc_target::spec::{PanicStrategy, TargetTriple};
  11
  12 use crate::locator::CrateFlavor;
  13
  14 #[derive(Diagnostic)]
  15 #[diag(metadata_rlib_required)]
  16 pub struct RlibRequired {
  17     pub crate_name: Symbol,
  18 }
  19
  20 #[derive(Diagnostic)]
  21 #[diag(metadata_lib_required)]
  22 pub struct LibRequired<'a> {
  23     pub crate_name: Symbol,
  24     pub kind: &'a str,
  25 }
  26
  27 #[derive(Diagnostic)]
  28 #[diag(metadata_crate_dep_multiple)]
  29 #[help]
  30 pub struct CrateDepMultiple {
  31     pub crate_name: Symbol,
  32 }
  33
  34 #[derive(Diagnostic)]
  35 #[diag(metadata_two_panic_runtimes)]
  36 pub struct TwoPanicRuntimes {
  37     pub prev_name: Symbol,
  38     pub cur_name: Symbol,
  39 }
  40
  41 #[derive(Diagnostic)]
  42 #[diag(metadata_bad_panic_strategy)]
  43 pub struct BadPanicStrategy {
  44     pub runtime: Symbol,
  45     pub strategy: PanicStrategy,
  46 }
  47
  48 #[derive(Diagnostic)]
  49 #[diag(metadata_required_panic_strategy)]
  50 pub struct RequiredPanicStrategy {
  51     pub crate_name: Symbol,
  52     pub found_strategy: PanicStrategy,
  53     pub desired_strategy: PanicStrategy,
  54 }
  55
  56 #[derive(Diagnostic)]
  57 #[diag(metadata_incompatible_panic_in_drop_strategy)]
  58 pub struct IncompatiblePanicInDropStrategy {
  59     pub crate_name: Symbol,
  60     pub found_strategy: PanicStrategy,
  61     pub desired_strategy: PanicStrategy,
  62 }
  63
  64 #[derive(Diagnostic)]
  65 #[diag(metadata_multiple_names_in_link)]
  66 pub struct MultipleNamesInLink {
  67     #[primary_span]
  68     pub span: Span,
  69 }
  70
  71 #[derive(Diagnostic)]
  72 #[diag(metadata_multiple_kinds_in_link)]
  73 pub struct MultipleKindsInLink {
  74     #[primary_span]
  75     pub span: Span,
  76 }
  77
  78 #[derive(Diagnostic)]
  79 #[diag(metadata_link_name_form)]
  80 pub struct LinkNameForm {
  81     #[primary_span]
  82     pub span: Span,
  83 }
  84
  85 #[derive(Diagnostic)]
  86 #[diag(metadata_link_kind_form)]
  87 pub struct LinkKindForm {
  88     #[primary_span]
  89     pub span: Span,
  90 }
  91
  92 #[derive(Diagnostic)]
  93 #[diag(metadata_link_modifiers_form)]
  94 pub struct LinkModifiersForm {
  95     #[primary_span]
  96     pub span: Span,
  97 }
  98
  99 #[derive(Diagnostic)]
 100 #[diag(metadata_link_cfg_form)]
 101 pub struct LinkCfgForm {
 102     #[primary_span]
 103     pub span: Span,
 104 }
 105
 106 #[derive(Diagnostic)]
 107 #[diag(metadata_wasm_import_form)]
 108 pub struct WasmImportForm {
 109     #[primary_span]
 110     pub span: Span,
 111 }
 112
 113 #[derive(Diagnostic)]
 114 #[diag(metadata_empty_link_name, code = "E0454")]
 115 pub struct EmptyLinkName {
 116     #[primary_span]
 117     #[label]
 118     pub span: Span,
 119 }
 120
 121 #[derive(Diagnostic)]
 122 #[diag(metadata_link_framework_apple, code = "E0455")]
 123 pub struct LinkFrameworkApple {
 124     #[primary_span]
 125     pub span: Span,
 126 }
 127
 128 #[derive(Diagnostic)]
 129 #[diag(metadata_framework_only_windows, code = "E0455")]
 130 pub struct FrameworkOnlyWindows {
 131     #[primary_span]
 132     pub span: Span,
 133 }
 134
 135 #[derive(Diagnostic)]
 136 #[diag(metadata_unknown_link_kind, code = "E0458")]
 137 pub struct UnknownLinkKind<'a> {
 138     #[primary_span]
 139     #[label]
 140     pub span: Span,
 141     pub kind: &'a str,
 142 }
 143
 144 #[derive(Diagnostic)]
 145 #[diag(metadata_multiple_link_modifiers)]
 146 pub struct MultipleLinkModifiers {
 147     #[primary_span]
 148     pub span: Span,
 149 }
 150
 151 #[derive(Diagnostic)]
 152 #[diag(metadata_multiple_cfgs)]
 153 pub struct MultipleCfgs {
 154     #[primary_span]
 155     pub span: Span,
 156 }
 157
 158 #[derive(Diagnostic)]
 159 #[diag(metadata_link_cfg_single_predicate)]
 160 pub struct LinkCfgSinglePredicate {
 161     #[primary_span]
 162     pub span: Span,
 163 }
 164
 165 #[derive(Diagnostic)]
 166 #[diag(metadata_multiple_wasm_import)]
 167 pub struct MultipleWasmImport {
 168     #[primary_span]
 169     pub span: Span,
 170 }
 171
 172 #[derive(Diagnostic)]
 173 #[diag(metadata_unexpected_link_arg)]
 174 pub struct UnexpectedLinkArg {
 175     #[primary_span]
 176     pub span: Span,
 177 }
 178
 179 #[derive(Diagnostic)]
 180 #[diag(metadata_invalid_link_modifier)]
 181 pub struct InvalidLinkModifier {
 182     #[primary_span]
 183     pub span: Span,
 184 }
 185
 186 #[derive(Diagnostic)]
 187 #[diag(metadata_multiple_modifiers)]
 188 pub struct MultipleModifiers<'a> {
 189     #[primary_span]
 190     pub span: Span,
 191     pub modifier: &'a str,
 192 }
 193
 194 #[derive(Diagnostic)]
 195 #[diag(metadata_bundle_needs_static)]
 196 pub struct BundleNeedsStatic {
 197     #[primary_span]
 198     pub span: Span,
 199 }
 200
 201 #[derive(Diagnostic)]
 202 #[diag(metadata_whole_archive_needs_static)]
 203 pub struct WholeArchiveNeedsStatic {
 204     #[primary_span]
 205     pub span: Span,
 206 }
 207
 208 #[derive(Diagnostic)]
 209 #[diag(metadata_as_needed_compatibility)]
 210 pub struct AsNeededCompatibility {
 211     #[primary_span]
 212     pub span: Span,
 213 }
 214
 215 #[derive(Diagnostic)]
 216 #[diag(metadata_unknown_link_modifier)]
 217 pub struct UnknownLinkModifier<'a> {
 218     #[primary_span]
 219     pub span: Span,
 220     pub modifier: &'a str,
 221 }
 222
 223 #[derive(Diagnostic)]
 224 #[diag(metadata_incompatible_wasm_link)]
 225 pub struct IncompatibleWasmLink {
 226     #[primary_span]
 227     pub span: Span,
 228 }
 229
 230 #[derive(Diagnostic)]
 231 #[diag(metadata_link_requires_name, code = "E0459")]
 232 pub struct LinkRequiresName {
 233     #[primary_span]
 234     #[label]
 235     pub span: Span,
 236 }
 237
 238 #[derive(Diagnostic)]
 239 #[diag(metadata_raw_dylib_no_nul)]
 240 pub struct RawDylibNoNul {
 241     #[primary_span]
 242     pub span: Span,
 243 }
 244
 245 #[derive(Diagnostic)]
 246 #[diag(metadata_link_ordinal_raw_dylib)]
 247 pub struct LinkOrdinalRawDylib {
 248     #[primary_span]
 249     pub span: Span,
 250 }
 251
 252 #[derive(Diagnostic)]
 253 #[diag(metadata_lib_framework_apple)]
 254 pub struct LibFrameworkApple;
 255
 256 #[derive(Diagnostic)]
 257 #[diag(metadata_empty_renaming_target)]
 258 pub struct EmptyRenamingTarget<'a> {
 259     pub lib_name: &'a str,
 260 }
 261
 262 #[derive(Diagnostic)]
 263 #[diag(metadata_renaming_no_link)]
 264 pub struct RenamingNoLink<'a> {
 265     pub lib_name: &'a str,
 266 }
 267
 268 #[derive(Diagnostic)]
 269 #[diag(metadata_multiple_renamings)]
 270 pub struct MultipleRenamings<'a> {
 271     pub lib_name: &'a str,
 272 }
 273
 274 #[derive(Diagnostic)]
 275 #[diag(metadata_no_link_mod_override)]
 276 pub struct NoLinkModOverride {
 277     #[primary_span]
 278     pub span: Option<Span>,
 279 }
 280
 281 #[derive(Diagnostic)]
 282 #[diag(metadata_unsupported_abi_i686)]
 283 pub struct UnsupportedAbiI686 {
 284     #[primary_span]
 285     pub span: Span,
 286 }
 287
 288 #[derive(Diagnostic)]
 289 #[diag(metadata_unsupported_abi)]
 290 pub struct UnsupportedAbi {
 291     #[primary_span]
 292     pub span: Span,
 293 }
 294
 295 #[derive(Diagnostic)]
 296 #[diag(metadata_fail_create_file_encoder)]
 297 pub struct FailCreateFileEncoder {
 298     pub err: Error,
 299 }
 300
 301 #[derive(Diagnostic)]
 302 #[diag(metadata_fail_seek_file)]
 303 pub struct FailSeekFile {
 304     pub err: Error,
 305 }
 306
 307 #[derive(Diagnostic)]
 308 #[diag(metadata_fail_write_file)]
 309 pub struct FailWriteFile {
 310     pub err: Error,
 311 }
 312
 313 #[derive(Diagnostic)]
 314 #[diag(metadata_crate_not_panic_runtime)]
 315 pub struct CrateNotPanicRuntime {
 316     pub crate_name: Symbol,
 317 }
 318
 319 #[derive(Diagnostic)]
 320 #[diag(metadata_no_panic_strategy)]
 321 pub struct NoPanicStrategy {
 322     pub crate_name: Symbol,
 323     pub strategy: PanicStrategy,
 324 }
 325
 326 #[derive(Diagnostic)]
 327 #[diag(metadata_profiler_builtins_needs_core)]
 328 pub struct ProfilerBuiltinsNeedsCore;
 329
 330 #[derive(Diagnostic)]
 331 #[diag(metadata_not_profiler_runtime)]
 332 pub struct NotProfilerRuntime {
 333     pub crate_name: Symbol,
 334 }
 335
 336 #[derive(Diagnostic)]
 337 #[diag(metadata_no_multiple_global_alloc)]
 338 pub struct NoMultipleGlobalAlloc {
 339     #[primary_span]
 340     #[label]
 341     pub span2: Span,
 342     #[label(metadata_prev_global_alloc)]
 343     pub span1: Span,
 344 }
 345
 346 #[derive(Diagnostic)]
 347 #[diag(metadata_no_multiple_alloc_error_handler)]
 348 pub struct NoMultipleAllocErrorHandler {
 349     #[primary_span]
 350     #[label]
 351     pub span2: Span,
 352     #[label(metadata_prev_alloc_error_handler)]
 353     pub span1: Span,
 354 }
 355
 356 #[derive(Diagnostic)]
 357 #[diag(metadata_conflicting_global_alloc)]
 358 pub struct ConflictingGlobalAlloc {
 359     pub crate_name: Symbol,
 360     pub other_crate_name: Symbol,
 361 }
 362
 363 #[derive(Diagnostic)]
 364 #[diag(metadata_conflicting_alloc_error_handler)]
 365 pub struct ConflictingAllocErrorHandler {
 366     pub crate_name: Symbol,
 367     pub other_crate_name: Symbol,
 368 }
 369
 370 #[derive(Diagnostic)]
 371 #[diag(metadata_global_alloc_required)]
 372 pub struct GlobalAllocRequired;
 373
 374 #[derive(Diagnostic)]
 375 #[diag(metadata_alloc_func_required)]
 376 pub struct AllocFuncRequired;
 377
 378 #[derive(Diagnostic)]
 379 #[diag(metadata_missing_alloc_error_handler)]
 380 pub struct MissingAllocErrorHandler;
 381
 382 #[derive(Diagnostic)]
 383 #[diag(metadata_no_transitive_needs_dep)]
 384 pub struct NoTransitiveNeedsDep<'a> {
 385     pub crate_name: Symbol,
 386     pub needs_crate_name: &'a str,
 387     pub deps_crate_name: Symbol,
 388 }
 389
 390 #[derive(Diagnostic)]
 391 #[diag(metadata_failed_write_error)]
 392 pub struct FailedWriteError {
 393     pub filename: PathBuf,
 394     pub err: Error,
 395 }
 396
 397 #[derive(Diagnostic)]
 398 #[diag(metadata_missing_native_library)]
 399 pub struct MissingNativeLibrary<'a> {
 400     libname: &'a str,
 401     #[subdiagnostic]
 402     suggest_name: Option<SuggestLibraryName<'a>>,
 403 }
 404
 405 impl<'a> MissingNativeLibrary<'a> {
 406     pub fn new(libname: &'a str, verbatim: bool) -> Self {
 407         // if it looks like the user has provided a complete filename rather just the bare lib name,
 408         // then provide a note that they might want to try trimming the name
 409         let suggested_name = if !verbatim {
 410             if let Some(libname) = libname.strip_prefix("lib") && let Some(libname) = libname.strip_suffix(".a") {
 411                 // this is a unix style filename so trim prefix & suffix
 412                 Some(libname)
 413             } else if let Some(libname) = libname.strip_suffix(".lib") {
 414                 // this is a Windows style filename so just trim the suffix
 415                 Some(libname)
 416             } else {
 417                 None
 418             }
 419         } else {
 420             None
 421         };
 422
 423         Self {
 424             libname,
 425             suggest_name: suggested_name
 426                 .map(|suggested_name| SuggestLibraryName { suggested_name }),
 427         }
 428     }
 429 }
 430
 431 #[derive(Subdiagnostic)]
 432 #[help(metadata_only_provide_library_name)]
 433 pub struct SuggestLibraryName<'a> {
 434     suggested_name: &'a str,
 435 }
 436
 437 #[derive(Diagnostic)]
 438 #[diag(metadata_failed_create_tempdir)]
 439 pub struct FailedCreateTempdir {
 440     pub err: Error,
 441 }
 442
 443 #[derive(Diagnostic)]
 444 #[diag(metadata_failed_create_file)]
 445 pub struct FailedCreateFile<'a> {
 446     pub filename: &'a Path,
 447     pub err: Error,
 448 }
 449
 450 #[derive(Diagnostic)]
 451 #[diag(metadata_failed_create_encoded_metadata)]
 452 pub struct FailedCreateEncodedMetadata {
 453     pub err: Error,
 454 }
 455
 456 #[derive(Diagnostic)]
 457 #[diag(metadata_non_ascii_name)]
 458 pub struct NonAsciiName {
 459     #[primary_span]
 460     pub span: Span,
 461     pub crate_name: Symbol,
 462 }
 463
 464 #[derive(Diagnostic)]
 465 #[diag(metadata_extern_location_not_exist)]
 466 pub struct ExternLocationNotExist<'a> {
 467     #[primary_span]
 468     pub span: Span,
 469     pub crate_name: Symbol,
 470     pub location: &'a Path,
 471 }
 472
 473 #[derive(Diagnostic)]
 474 #[diag(metadata_extern_location_not_file)]
 475 pub struct ExternLocationNotFile<'a> {
 476     #[primary_span]
 477     pub span: Span,
 478     pub crate_name: Symbol,
 479     pub location: &'a Path,
 480 }
 481
 482 pub(crate) struct MultipleCandidates {
 483     pub span: Span,
 484     pub flavor: CrateFlavor,
 485     pub crate_name: Symbol,
 486     pub candidates: Vec<PathBuf>,
 487 }
 488
 489 impl IntoDiagnostic<'_> for MultipleCandidates {
 490     fn into_diagnostic(
 491         self,
 492         handler: &'_ rustc_errors::Handler,
 493     ) -> rustc_errors::DiagnosticBuilder<'_, ErrorGuaranteed> {
 494         let mut diag = handler.struct_err(rustc_errors::fluent::metadata_multiple_candidates);
 495         diag.set_arg("crate_name", self.crate_name);
 496         diag.set_arg("flavor", self.flavor);
 497         diag.code(error_code!(E0465));
 498         diag.set_span(self.span);
 499         for (i, candidate) in self.candidates.iter().enumerate() {
 500             diag.span_note(self.span, &format!("candidate #{}: {}", i + 1, candidate.display()));
 501         }
 502         diag
 503     }
 504 }
 505
 506 #[derive(Diagnostic)]
 507 #[diag(metadata_multiple_matching_crates, code = "E0464")]
 508 #[note]
 509 pub struct MultipleMatchingCrates {
 510     #[primary_span]
 511     pub span: Span,
 512     pub crate_name: Symbol,
 513     pub candidates: String,
 514 }
 515
 516 #[derive(Diagnostic)]
 517 #[diag(metadata_symbol_conflicts_current, code = "E0519")]
 518 pub struct SymbolConflictsCurrent {
 519     #[primary_span]
 520     pub span: Span,
 521     pub crate_name: Symbol,
 522 }
 523
 524 #[derive(Diagnostic)]
 525 #[diag(metadata_symbol_conflicts_others, code = "E0523")]
 526 pub struct SymbolConflictsOthers {
 527     #[primary_span]
 528     pub span: Span,
 529     pub crate_name: Symbol,
 530 }
 531
 532 #[derive(Diagnostic)]
 533 #[diag(metadata_stable_crate_id_collision)]
 534 pub struct StableCrateIdCollision {
 535     #[primary_span]
 536     pub span: Span,
 537     pub crate_name0: Symbol,
 538     pub crate_name1: Symbol,
 539 }
 540
 541 #[derive(Diagnostic)]
 542 #[diag(metadata_dl_error)]
 543 pub struct DlError {
 544     #[primary_span]
 545     pub span: Span,
 546     pub err: String,
 547 }
 548
 549 #[derive(Diagnostic)]
 550 #[diag(metadata_newer_crate_version, code = "E0460")]
 551 #[note]
 552 #[note(metadata_found_crate_versions)]
 553 pub struct NewerCrateVersion {
 554     #[primary_span]
 555     pub span: Span,
 556     pub crate_name: Symbol,
 557     pub add_info: String,
 558     pub found_crates: String,
 559 }
 560
 561 #[derive(Diagnostic)]
 562 #[diag(metadata_no_crate_with_triple, code = "E0461")]
 563 #[note(metadata_found_crate_versions)]
 564 pub struct NoCrateWithTriple<'a> {
 565     #[primary_span]
 566     pub span: Span,
 567     pub crate_name: Symbol,
 568     pub locator_triple: &'a str,
 569     pub add_info: String,
 570     pub found_crates: String,
 571 }
 572
 573 #[derive(Diagnostic)]
 574 #[diag(metadata_found_staticlib, code = "E0462")]
 575 #[note(metadata_found_crate_versions)]
 576 #[help]
 577 pub struct FoundStaticlib {
 578     #[primary_span]
 579     pub span: Span,
 580     pub crate_name: Symbol,
 581     pub add_info: String,
 582     pub found_crates: String,
 583 }
 584
 585 #[derive(Diagnostic)]
 586 #[diag(metadata_incompatible_rustc, code = "E0514")]
 587 #[note(metadata_found_crate_versions)]
 588 #[help]
 589 pub struct IncompatibleRustc {
 590     #[primary_span]
 591     pub span: Span,
 592     pub crate_name: Symbol,
 593     pub add_info: String,
 594     pub found_crates: String,
 595     pub rustc_version: String,
 596 }
 597
 598 pub struct InvalidMetadataFiles {
 599     pub span: Span,
 600     pub crate_name: Symbol,
 601     pub add_info: String,
 602     pub crate_rejections: Vec<String>,
 603 }
 604
 605 impl IntoDiagnostic<'_> for InvalidMetadataFiles {
 606     #[track_caller]
 607     fn into_diagnostic(
 608         self,
 609         handler: &'_ rustc_errors::Handler,
 610     ) -> rustc_errors::DiagnosticBuilder<'_, ErrorGuaranteed> {
 611         let mut diag = handler.struct_err(rustc_errors::fluent::metadata_invalid_meta_files);
 612         diag.set_arg("crate_name", self.crate_name);
 613         diag.set_arg("add_info", self.add_info);
 614         diag.code(error_code!(E0786));
 615         diag.set_span(self.span);
 616         for crate_rejection in self.crate_rejections {
 617             diag.note(crate_rejection);
 618         }
 619         diag
 620     }
 621 }
 622
 623 pub struct CannotFindCrate {
 624     pub span: Span,
 625     pub crate_name: Symbol,
 626     pub add_info: String,
 627     pub missing_core: bool,
 628     pub current_crate: String,
 629     pub is_nightly_build: bool,
 630     pub profiler_runtime: Symbol,
 631     pub locator_triple: TargetTriple,
 632 }
 633
 634 impl IntoDiagnostic<'_> for CannotFindCrate {
 635     #[track_caller]
 636     fn into_diagnostic(
 637         self,
 638         handler: &'_ rustc_errors::Handler,
 639     ) -> rustc_errors::DiagnosticBuilder<'_, ErrorGuaranteed> {
 640         let mut diag = handler.struct_err(rustc_errors::fluent::metadata_cannot_find_crate);
 641         diag.set_arg("crate_name", self.crate_name);
 642         diag.set_arg("current_crate", self.current_crate);
 643         diag.set_arg("add_info", self.add_info);
 644         diag.set_arg("locator_triple", self.locator_triple.triple());
 645         diag.code(error_code!(E0463));
 646         diag.set_span(self.span);
 647         if (self.crate_name == sym::std || self.crate_name == sym::core)
 648             && self.locator_triple != TargetTriple::from_triple(config::host_triple())
 649         {
 650             if self.missing_core {
 651                 diag.note(rustc_errors::fluent::metadata_target_not_installed);
 652             } else {
 653                 diag.note(rustc_errors::fluent::metadata_target_no_std_support);
 654             }
 655             // NOTE: this suggests using rustup, even though the user may not have it installed.
 656             // That's because they could choose to install it; or this may give them a hint which
 657             // target they need to install from their distro.
 658             if self.missing_core {
 659                 diag.help(rustc_errors::fluent::metadata_consider_downloading_target);
 660             }
 661             // Suggest using #![no_std]. #[no_core] is unstable and not really supported anyway.
 662             // NOTE: this is a dummy span if `extern crate std` was injected by the compiler.
 663             // If it's not a dummy, that means someone added `extern crate std` explicitly and
 664             // `#![no_std]` won't help.
 665             if !self.missing_core && self.span.is_dummy() {
 666                 diag.note(rustc_errors::fluent::metadata_std_required);
 667             }
 668             if self.is_nightly_build {
 669                 diag.help(rustc_errors::fluent::metadata_consider_building_std);
 670             }
 671         } else if self.crate_name == self.profiler_runtime {
 672             diag.note(rustc_errors::fluent::metadata_compiler_missing_profiler);
 673         } else if self.crate_name.as_str().starts_with("rustc_") {
 674             diag.help(rustc_errors::fluent::metadata_install_missing_components);
 675         }
 676         diag.span_label(self.span, rustc_errors::fluent::metadata_cant_find_crate);
 677         diag
 678     }
 679 }
 680
 681 #[derive(Diagnostic)]
 682 #[diag(metadata_no_dylib_plugin, code = "E0457")]
 683 pub struct NoDylibPlugin {
 684     #[primary_span]
 685     pub span: Span,
 686     pub crate_name: Symbol,
 687 }
 688
 689 #[derive(Diagnostic)]
 690 #[diag(metadata_crate_location_unknown_type)]
 691 pub struct CrateLocationUnknownType<'a> {
 692     #[primary_span]
 693     pub span: Span,
 694     pub path: &'a Path,
 695     pub crate_name: Symbol,
 696 }
 697
 698 #[derive(Diagnostic)]
 699 #[diag(metadata_lib_filename_form)]
 700 pub struct LibFilenameForm<'a> {
 701     #[primary_span]
 702     pub span: Span,
 703     pub dll_prefix: &'a str,
 704     pub dll_suffix: &'a str,
 705 }
 706
 707 #[derive(Diagnostic)]
 708 #[diag(metadata_multiple_import_name_type)]
 709 pub struct MultipleImportNameType {
 710     #[primary_span]
 711     pub span: Span,
 712 }
 713
 714 #[derive(Diagnostic)]
 715 #[diag(metadata_import_name_type_form)]
 716 pub struct ImportNameTypeForm {
 717     #[primary_span]
 718     pub span: Span,
 719 }
 720
 721 #[derive(Diagnostic)]
 722 #[diag(metadata_import_name_type_x86)]
 723 pub struct ImportNameTypeX86 {
 724     #[primary_span]
 725     pub span: Span,
 726 }
 727
 728 #[derive(Diagnostic)]
 729 #[diag(metadata_unknown_import_name_type)]
 730 pub struct UnknownImportNameType<'a> {
 731     #[primary_span]
 732     pub span: Span,
 733     pub import_name_type: &'a str,
 734 }
 735
 736 #[derive(Diagnostic)]
 737 #[diag(metadata_import_name_type_raw)]
 738 pub struct ImportNameTypeRaw {
 739     #[primary_span]
 740     pub span: Span,
 741 }