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_rustc_lib_required)]
  29 #[help]
  30 pub struct RustcLibRequired<'a> {
  31     pub crate_name: Symbol,
  32     pub kind: &'a str,
  33 }
  34
  35 #[derive(Diagnostic)]
  36 #[diag(metadata_crate_dep_multiple)]
  37 #[help]
  38 pub struct CrateDepMultiple {
  39     pub crate_name: Symbol,
  40 }
  41
  42 #[derive(Diagnostic)]
  43 #[diag(metadata_two_panic_runtimes)]
  44 pub struct TwoPanicRuntimes {
  45     pub prev_name: Symbol,
  46     pub cur_name: Symbol,
  47 }
  48
  49 #[derive(Diagnostic)]
  50 #[diag(metadata_bad_panic_strategy)]
  51 pub struct BadPanicStrategy {
  52     pub runtime: Symbol,
  53     pub strategy: PanicStrategy,
  54 }
  55
  56 #[derive(Diagnostic)]
  57 #[diag(metadata_required_panic_strategy)]
  58 pub struct RequiredPanicStrategy {
  59     pub crate_name: Symbol,
  60     pub found_strategy: PanicStrategy,
  61     pub desired_strategy: PanicStrategy,
  62 }
  63
  64 #[derive(Diagnostic)]
  65 #[diag(metadata_incompatible_panic_in_drop_strategy)]
  66 pub struct IncompatiblePanicInDropStrategy {
  67     pub crate_name: Symbol,
  68     pub found_strategy: PanicStrategy,
  69     pub desired_strategy: PanicStrategy,
  70 }
  71
  72 #[derive(Diagnostic)]
  73 #[diag(metadata_multiple_names_in_link)]
  74 pub struct MultipleNamesInLink {
  75     #[primary_span]
  76     pub span: Span,
  77 }
  78
  79 #[derive(Diagnostic)]
  80 #[diag(metadata_multiple_kinds_in_link)]
  81 pub struct MultipleKindsInLink {
  82     #[primary_span]
  83     pub span: Span,
  84 }
  85
  86 #[derive(Diagnostic)]
  87 #[diag(metadata_link_name_form)]
  88 pub struct LinkNameForm {
  89     #[primary_span]
  90     pub span: Span,
  91 }
  92
  93 #[derive(Diagnostic)]
  94 #[diag(metadata_link_kind_form)]
  95 pub struct LinkKindForm {
  96     #[primary_span]
  97     pub span: Span,
  98 }
  99
 100 #[derive(Diagnostic)]
 101 #[diag(metadata_link_modifiers_form)]
 102 pub struct LinkModifiersForm {
 103     #[primary_span]
 104     pub span: Span,
 105 }
 106
 107 #[derive(Diagnostic)]
 108 #[diag(metadata_link_cfg_form)]
 109 pub struct LinkCfgForm {
 110     #[primary_span]
 111     pub span: Span,
 112 }
 113
 114 #[derive(Diagnostic)]
 115 #[diag(metadata_wasm_import_form)]
 116 pub struct WasmImportForm {
 117     #[primary_span]
 118     pub span: Span,
 119 }
 120
 121 #[derive(Diagnostic)]
 122 #[diag(metadata_empty_link_name, code = "E0454")]
 123 pub struct EmptyLinkName {
 124     #[primary_span]
 125     #[label]
 126     pub span: Span,
 127 }
 128
 129 #[derive(Diagnostic)]
 130 #[diag(metadata_link_framework_apple, code = "E0455")]
 131 pub struct LinkFrameworkApple {
 132     #[primary_span]
 133     pub span: Span,
 134 }
 135
 136 #[derive(Diagnostic)]
 137 #[diag(metadata_framework_only_windows, code = "E0455")]
 138 pub struct FrameworkOnlyWindows {
 139     #[primary_span]
 140     pub span: Span,
 141 }
 142
 143 #[derive(Diagnostic)]
 144 #[diag(metadata_unknown_link_kind, code = "E0458")]
 145 pub struct UnknownLinkKind<'a> {
 146     #[primary_span]
 147     #[label]
 148     pub span: Span,
 149     pub kind: &'a str,
 150 }
 151
 152 #[derive(Diagnostic)]
 153 #[diag(metadata_multiple_link_modifiers)]
 154 pub struct MultipleLinkModifiers {
 155     #[primary_span]
 156     pub span: Span,
 157 }
 158
 159 #[derive(Diagnostic)]
 160 #[diag(metadata_multiple_cfgs)]
 161 pub struct MultipleCfgs {
 162     #[primary_span]
 163     pub span: Span,
 164 }
 165
 166 #[derive(Diagnostic)]
 167 #[diag(metadata_link_cfg_single_predicate)]
 168 pub struct LinkCfgSinglePredicate {
 169     #[primary_span]
 170     pub span: Span,
 171 }
 172
 173 #[derive(Diagnostic)]
 174 #[diag(metadata_multiple_wasm_import)]
 175 pub struct MultipleWasmImport {
 176     #[primary_span]
 177     pub span: Span,
 178 }
 179
 180 #[derive(Diagnostic)]
 181 #[diag(metadata_unexpected_link_arg)]
 182 pub struct UnexpectedLinkArg {
 183     #[primary_span]
 184     pub span: Span,
 185 }
 186
 187 #[derive(Diagnostic)]
 188 #[diag(metadata_invalid_link_modifier)]
 189 pub struct InvalidLinkModifier {
 190     #[primary_span]
 191     pub span: Span,
 192 }
 193
 194 #[derive(Diagnostic)]
 195 #[diag(metadata_multiple_modifiers)]
 196 pub struct MultipleModifiers<'a> {
 197     #[primary_span]
 198     pub span: Span,
 199     pub modifier: &'a str,
 200 }
 201
 202 #[derive(Diagnostic)]
 203 #[diag(metadata_bundle_needs_static)]
 204 pub struct BundleNeedsStatic {
 205     #[primary_span]
 206     pub span: Span,
 207 }
 208
 209 #[derive(Diagnostic)]
 210 #[diag(metadata_whole_archive_needs_static)]
 211 pub struct WholeArchiveNeedsStatic {
 212     #[primary_span]
 213     pub span: Span,
 214 }
 215
 216 #[derive(Diagnostic)]
 217 #[diag(metadata_as_needed_compatibility)]
 218 pub struct AsNeededCompatibility {
 219     #[primary_span]
 220     pub span: Span,
 221 }
 222
 223 #[derive(Diagnostic)]
 224 #[diag(metadata_unknown_link_modifier)]
 225 pub struct UnknownLinkModifier<'a> {
 226     #[primary_span]
 227     pub span: Span,
 228     pub modifier: &'a str,
 229 }
 230
 231 #[derive(Diagnostic)]
 232 #[diag(metadata_incompatible_wasm_link)]
 233 pub struct IncompatibleWasmLink {
 234     #[primary_span]
 235     pub span: Span,
 236 }
 237
 238 #[derive(Diagnostic)]
 239 #[diag(metadata_link_requires_name, code = "E0459")]
 240 pub struct LinkRequiresName {
 241     #[primary_span]
 242     #[label]
 243     pub span: Span,
 244 }
 245
 246 #[derive(Diagnostic)]
 247 #[diag(metadata_raw_dylib_no_nul)]
 248 pub struct RawDylibNoNul {
 249     #[primary_span]
 250     pub span: Span,
 251 }
 252
 253 #[derive(Diagnostic)]
 254 #[diag(metadata_link_ordinal_raw_dylib)]
 255 pub struct LinkOrdinalRawDylib {
 256     #[primary_span]
 257     pub span: Span,
 258 }
 259
 260 #[derive(Diagnostic)]
 261 #[diag(metadata_lib_framework_apple)]
 262 pub struct LibFrameworkApple;
 263
 264 #[derive(Diagnostic)]
 265 #[diag(metadata_empty_renaming_target)]
 266 pub struct EmptyRenamingTarget<'a> {
 267     pub lib_name: &'a str,
 268 }
 269
 270 #[derive(Diagnostic)]
 271 #[diag(metadata_renaming_no_link)]
 272 pub struct RenamingNoLink<'a> {
 273     pub lib_name: &'a str,
 274 }
 275
 276 #[derive(Diagnostic)]
 277 #[diag(metadata_multiple_renamings)]
 278 pub struct MultipleRenamings<'a> {
 279     pub lib_name: &'a str,
 280 }
 281
 282 #[derive(Diagnostic)]
 283 #[diag(metadata_no_link_mod_override)]
 284 pub struct NoLinkModOverride {
 285     #[primary_span]
 286     pub span: Option<Span>,
 287 }
 288
 289 #[derive(Diagnostic)]
 290 #[diag(metadata_unsupported_abi_i686)]
 291 pub struct UnsupportedAbiI686 {
 292     #[primary_span]
 293     pub span: Span,
 294 }
 295
 296 #[derive(Diagnostic)]
 297 #[diag(metadata_unsupported_abi)]
 298 pub struct UnsupportedAbi {
 299     #[primary_span]
 300     pub span: Span,
 301 }
 302
 303 #[derive(Diagnostic)]
 304 #[diag(metadata_fail_create_file_encoder)]
 305 pub struct FailCreateFileEncoder {
 306     pub err: Error,
 307 }
 308
 309 #[derive(Diagnostic)]
 310 #[diag(metadata_fail_seek_file)]
 311 pub struct FailSeekFile {
 312     pub err: Error,
 313 }
 314
 315 #[derive(Diagnostic)]
 316 #[diag(metadata_fail_write_file)]
 317 pub struct FailWriteFile {
 318     pub err: Error,
 319 }
 320
 321 #[derive(Diagnostic)]
 322 #[diag(metadata_crate_not_panic_runtime)]
 323 pub struct CrateNotPanicRuntime {
 324     pub crate_name: Symbol,
 325 }
 326
 327 #[derive(Diagnostic)]
 328 #[diag(metadata_no_panic_strategy)]
 329 pub struct NoPanicStrategy {
 330     pub crate_name: Symbol,
 331     pub strategy: PanicStrategy,
 332 }
 333
 334 #[derive(Diagnostic)]
 335 #[diag(metadata_profiler_builtins_needs_core)]
 336 pub struct ProfilerBuiltinsNeedsCore;
 337
 338 #[derive(Diagnostic)]
 339 #[diag(metadata_not_profiler_runtime)]
 340 pub struct NotProfilerRuntime {
 341     pub crate_name: Symbol,
 342 }
 343
 344 #[derive(Diagnostic)]
 345 #[diag(metadata_no_multiple_global_alloc)]
 346 pub struct NoMultipleGlobalAlloc {
 347     #[primary_span]
 348     #[label]
 349     pub span2: Span,
 350     #[label(metadata_prev_global_alloc)]
 351     pub span1: Span,
 352 }
 353
 354 #[derive(Diagnostic)]
 355 #[diag(metadata_no_multiple_alloc_error_handler)]
 356 pub struct NoMultipleAllocErrorHandler {
 357     #[primary_span]
 358     #[label]
 359     pub span2: Span,
 360     #[label(metadata_prev_alloc_error_handler)]
 361     pub span1: Span,
 362 }
 363
 364 #[derive(Diagnostic)]
 365 #[diag(metadata_conflicting_global_alloc)]
 366 pub struct ConflictingGlobalAlloc {
 367     pub crate_name: Symbol,
 368     pub other_crate_name: Symbol,
 369 }
 370
 371 #[derive(Diagnostic)]
 372 #[diag(metadata_conflicting_alloc_error_handler)]
 373 pub struct ConflictingAllocErrorHandler {
 374     pub crate_name: Symbol,
 375     pub other_crate_name: Symbol,
 376 }
 377
 378 #[derive(Diagnostic)]
 379 #[diag(metadata_global_alloc_required)]
 380 pub struct GlobalAllocRequired;
 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!(E0464));
 498         diag.set_span(self.span);
 499         for (i, candidate) in self.candidates.iter().enumerate() {
 500             diag.note(&format!("candidate #{}: {}", i + 1, candidate.display()));
 501         }
 502         diag
 503     }
 504 }
 505
 506 #[derive(Diagnostic)]
 507 #[diag(metadata_symbol_conflicts_current, code = "E0519")]
 508 pub struct SymbolConflictsCurrent {
 509     #[primary_span]
 510     pub span: Span,
 511     pub crate_name: Symbol,
 512 }
 513
 514 #[derive(Diagnostic)]
 515 #[diag(metadata_symbol_conflicts_others, code = "E0523")]
 516 pub struct SymbolConflictsOthers {
 517     #[primary_span]
 518     pub span: Span,
 519     pub crate_name: Symbol,
 520 }
 521
 522 #[derive(Diagnostic)]
 523 #[diag(metadata_stable_crate_id_collision)]
 524 pub struct StableCrateIdCollision {
 525     #[primary_span]
 526     pub span: Span,
 527     pub crate_name0: Symbol,
 528     pub crate_name1: Symbol,
 529 }
 530
 531 #[derive(Diagnostic)]
 532 #[diag(metadata_dl_error)]
 533 pub struct DlError {
 534     #[primary_span]
 535     pub span: Span,
 536     pub err: String,
 537 }
 538
 539 #[derive(Diagnostic)]
 540 #[diag(metadata_newer_crate_version, code = "E0460")]
 541 #[note]
 542 #[note(metadata_found_crate_versions)]
 543 pub struct NewerCrateVersion {
 544     #[primary_span]
 545     pub span: Span,
 546     pub crate_name: Symbol,
 547     pub add_info: String,
 548     pub found_crates: String,
 549 }
 550
 551 #[derive(Diagnostic)]
 552 #[diag(metadata_no_crate_with_triple, code = "E0461")]
 553 #[note(metadata_found_crate_versions)]
 554 pub struct NoCrateWithTriple<'a> {
 555     #[primary_span]
 556     pub span: Span,
 557     pub crate_name: Symbol,
 558     pub locator_triple: &'a str,
 559     pub add_info: String,
 560     pub found_crates: String,
 561 }
 562
 563 #[derive(Diagnostic)]
 564 #[diag(metadata_found_staticlib, code = "E0462")]
 565 #[note(metadata_found_crate_versions)]
 566 #[help]
 567 pub struct FoundStaticlib {
 568     #[primary_span]
 569     pub span: Span,
 570     pub crate_name: Symbol,
 571     pub add_info: String,
 572     pub found_crates: String,
 573 }
 574
 575 #[derive(Diagnostic)]
 576 #[diag(metadata_incompatible_rustc, code = "E0514")]
 577 #[note(metadata_found_crate_versions)]
 578 #[help]
 579 pub struct IncompatibleRustc {
 580     #[primary_span]
 581     pub span: Span,
 582     pub crate_name: Symbol,
 583     pub add_info: String,
 584     pub found_crates: String,
 585     pub rustc_version: String,
 586 }
 587
 588 pub struct InvalidMetadataFiles {
 589     pub span: Span,
 590     pub crate_name: Symbol,
 591     pub add_info: String,
 592     pub crate_rejections: Vec<String>,
 593 }
 594
 595 impl IntoDiagnostic<'_> for InvalidMetadataFiles {
 596     #[track_caller]
 597     fn into_diagnostic(
 598         self,
 599         handler: &'_ rustc_errors::Handler,
 600     ) -> rustc_errors::DiagnosticBuilder<'_, ErrorGuaranteed> {
 601         let mut diag = handler.struct_err(rustc_errors::fluent::metadata_invalid_meta_files);
 602         diag.set_arg("crate_name", self.crate_name);
 603         diag.set_arg("add_info", self.add_info);
 604         diag.code(error_code!(E0786));
 605         diag.set_span(self.span);
 606         for crate_rejection in self.crate_rejections {
 607             diag.note(crate_rejection);
 608         }
 609         diag
 610     }
 611 }
 612
 613 pub struct CannotFindCrate {
 614     pub span: Span,
 615     pub crate_name: Symbol,
 616     pub add_info: String,
 617     pub missing_core: bool,
 618     pub current_crate: String,
 619     pub is_nightly_build: bool,
 620     pub profiler_runtime: Symbol,
 621     pub locator_triple: TargetTriple,
 622 }
 623
 624 impl IntoDiagnostic<'_> for CannotFindCrate {
 625     #[track_caller]
 626     fn into_diagnostic(
 627         self,
 628         handler: &'_ rustc_errors::Handler,
 629     ) -> rustc_errors::DiagnosticBuilder<'_, ErrorGuaranteed> {
 630         let mut diag = handler.struct_err(rustc_errors::fluent::metadata_cannot_find_crate);
 631         diag.set_arg("crate_name", self.crate_name);
 632         diag.set_arg("current_crate", self.current_crate);
 633         diag.set_arg("add_info", self.add_info);
 634         diag.set_arg("locator_triple", self.locator_triple.triple());
 635         diag.code(error_code!(E0463));
 636         diag.set_span(self.span);
 637         if (self.crate_name == sym::std || self.crate_name == sym::core)
 638             && self.locator_triple != TargetTriple::from_triple(config::host_triple())
 639         {
 640             if self.missing_core {
 641                 diag.note(rustc_errors::fluent::metadata_target_not_installed);
 642             } else {
 643                 diag.note(rustc_errors::fluent::metadata_target_no_std_support);
 644             }
 645             // NOTE: this suggests using rustup, even though the user may not have it installed.
 646             // That's because they could choose to install it; or this may give them a hint which
 647             // target they need to install from their distro.
 648             if self.missing_core {
 649                 diag.help(rustc_errors::fluent::metadata_consider_downloading_target);
 650             }
 651             // Suggest using #![no_std]. #[no_core] is unstable and not really supported anyway.
 652             // NOTE: this is a dummy span if `extern crate std` was injected by the compiler.
 653             // If it's not a dummy, that means someone added `extern crate std` explicitly and
 654             // `#![no_std]` won't help.
 655             if !self.missing_core && self.span.is_dummy() {
 656                 diag.note(rustc_errors::fluent::metadata_std_required);
 657             }
 658             if self.is_nightly_build {
 659                 diag.help(rustc_errors::fluent::metadata_consider_building_std);
 660             }
 661         } else if self.crate_name == self.profiler_runtime {
 662             diag.note(rustc_errors::fluent::metadata_compiler_missing_profiler);
 663         } else if self.crate_name.as_str().starts_with("rustc_") {
 664             diag.help(rustc_errors::fluent::metadata_install_missing_components);
 665         }
 666         diag.span_label(self.span, rustc_errors::fluent::metadata_cant_find_crate);
 667         diag
 668     }
 669 }
 670
 671 #[derive(Diagnostic)]
 672 #[diag(metadata_no_dylib_plugin, code = "E0457")]
 673 pub struct NoDylibPlugin {
 674     #[primary_span]
 675     pub span: Span,
 676     pub crate_name: Symbol,
 677 }
 678
 679 #[derive(Diagnostic)]
 680 #[diag(metadata_crate_location_unknown_type)]
 681 pub struct CrateLocationUnknownType<'a> {
 682     #[primary_span]
 683     pub span: Span,
 684     pub path: &'a Path,
 685     pub crate_name: Symbol,
 686 }
 687
 688 #[derive(Diagnostic)]
 689 #[diag(metadata_lib_filename_form)]
 690 pub struct LibFilenameForm<'a> {
 691     #[primary_span]
 692     pub span: Span,
 693     pub dll_prefix: &'a str,
 694     pub dll_suffix: &'a str,
 695 }
 696
 697 #[derive(Diagnostic)]
 698 #[diag(metadata_multiple_import_name_type)]
 699 pub struct MultipleImportNameType {
 700     #[primary_span]
 701     pub span: Span,
 702 }
 703
 704 #[derive(Diagnostic)]
 705 #[diag(metadata_import_name_type_form)]
 706 pub struct ImportNameTypeForm {
 707     #[primary_span]
 708     pub span: Span,
 709 }
 710
 711 #[derive(Diagnostic)]
 712 #[diag(metadata_import_name_type_x86)]
 713 pub struct ImportNameTypeX86 {
 714     #[primary_span]
 715     pub span: Span,
 716 }
 717
 718 #[derive(Diagnostic)]
 719 #[diag(metadata_unknown_import_name_type)]
 720 pub struct UnknownImportNameType<'a> {
 721     #[primary_span]
 722     pub span: Span,
 723     pub import_name_type: &'a str,
 724 }
 725
 726 #[derive(Diagnostic)]
 727 #[diag(metadata_import_name_type_raw)]
 728 pub struct ImportNameTypeRaw {
 729     #[primary_span]
 730     pub span: Span,
 731 }