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