//! Errors emitted by codegen_ssa use crate::assert_module_sources::CguReuse; use crate::back::command::Command; use crate::fluent_generated as fluent; use rustc_errors::{ DiagnosticArgValue, DiagnosticBuilder, ErrorGuaranteed, Handler, IntoDiagnostic, IntoDiagnosticArg, }; use rustc_macros::Diagnostic; use rustc_middle::ty::layout::LayoutError; use rustc_middle::ty::Ty; use rustc_span::{Span, Symbol}; use rustc_type_ir::FloatTy; use std::borrow::Cow; use std::io::Error; use std::path::{Path, PathBuf}; use std::process::ExitStatus; #[derive(Diagnostic)] #[diag(codegen_ssa_incorrect_cgu_reuse_type)] pub struct IncorrectCguReuseType<'a> { #[primary_span] pub span: Span, pub cgu_user_name: &'a str, pub actual_reuse: CguReuse, pub expected_reuse: CguReuse, pub at_least: u8, } #[derive(Diagnostic)] #[diag(codegen_ssa_cgu_not_recorded)] pub struct CguNotRecorded<'a> { pub cgu_user_name: &'a str, pub cgu_name: &'a str, } #[derive(Diagnostic)] #[diag(codegen_ssa_unknown_reuse_kind)] pub struct UnknownReuseKind { #[primary_span] pub span: Span, pub kind: Symbol, } #[derive(Diagnostic)] #[diag(codegen_ssa_missing_query_depgraph)] pub struct MissingQueryDepGraph { #[primary_span] pub span: Span, } #[derive(Diagnostic)] #[diag(codegen_ssa_malformed_cgu_name)] pub struct MalformedCguName { #[primary_span] pub span: Span, pub user_path: String, pub crate_name: String, } #[derive(Diagnostic)] #[diag(codegen_ssa_no_module_named)] pub struct NoModuleNamed<'a> { #[primary_span] pub span: Span, pub user_path: &'a str, pub cgu_name: Symbol, pub cgu_names: String, } #[derive(Diagnostic)] #[diag(codegen_ssa_field_associated_value_expected)] pub struct FieldAssociatedValueExpected { #[primary_span] pub span: Span, pub name: Symbol, } #[derive(Diagnostic)] #[diag(codegen_ssa_no_field)] pub struct NoField { #[primary_span] pub span: Span, pub name: Symbol, } #[derive(Diagnostic)] #[diag(codegen_ssa_lib_def_write_failure)] pub struct LibDefWriteFailure { pub error: Error, } #[derive(Diagnostic)] #[diag(codegen_ssa_version_script_write_failure)] pub struct VersionScriptWriteFailure { pub error: Error, } #[derive(Diagnostic)] #[diag(codegen_ssa_symbol_file_write_failure)] pub struct SymbolFileWriteFailure { pub error: Error, } #[derive(Diagnostic)] #[diag(codegen_ssa_ld64_unimplemented_modifier)] pub struct Ld64UnimplementedModifier; #[derive(Diagnostic)] #[diag(codegen_ssa_linker_unsupported_modifier)] pub struct LinkerUnsupportedModifier; #[derive(Diagnostic)] #[diag(codegen_ssa_L4Bender_exporting_symbols_unimplemented)] pub struct L4BenderExportingSymbolsUnimplemented; #[derive(Diagnostic)] #[diag(codegen_ssa_no_natvis_directory)] pub struct NoNatvisDirectory { pub error: Error, } #[derive(Diagnostic)] #[diag(codegen_ssa_copy_path_buf)] pub struct CopyPathBuf { pub source_file: PathBuf, pub output_path: PathBuf, pub error: Error, } // Reports Paths using `Debug` implementation rather than Path's `Display` implementation. #[derive(Diagnostic)] #[diag(codegen_ssa_copy_path)] pub struct CopyPath<'a> { from: DebugArgPath<'a>, to: DebugArgPath<'a>, error: Error, } impl<'a> CopyPath<'a> { pub fn new(from: &'a Path, to: &'a Path, error: Error) -> CopyPath<'a> { CopyPath { from: DebugArgPath(from), to: DebugArgPath(to), error } } } struct DebugArgPath<'a>(pub &'a Path); impl IntoDiagnosticArg for DebugArgPath<'_> { fn into_diagnostic_arg(self) -> rustc_errors::DiagnosticArgValue<'static> { DiagnosticArgValue::Str(Cow::Owned(format!("{:?}", self.0))) } } #[derive(Diagnostic)] #[diag(codegen_ssa_binary_output_to_tty)] pub struct BinaryOutputToTty { pub shorthand: &'static str, } #[derive(Diagnostic)] #[diag(codegen_ssa_ignoring_emit_path)] pub struct IgnoringEmitPath { pub extension: String, } #[derive(Diagnostic)] #[diag(codegen_ssa_ignoring_output)] pub struct IgnoringOutput { pub extension: String, } #[derive(Diagnostic)] #[diag(codegen_ssa_create_temp_dir)] pub struct CreateTempDir { pub error: Error, } #[derive(Diagnostic)] #[diag(codegen_ssa_add_native_library)] pub struct AddNativeLibrary { pub library_path: PathBuf, pub error: Error, } #[derive(Diagnostic)] #[diag(codegen_ssa_multiple_external_func_decl)] pub struct MultipleExternalFuncDecl<'a> { #[primary_span] pub span: Span, pub function: Symbol, pub library_name: &'a str, } #[derive(Diagnostic)] pub enum LinkRlibError { #[diag(codegen_ssa_rlib_missing_format)] MissingFormat, #[diag(codegen_ssa_rlib_only_rmeta_found)] OnlyRmetaFound { crate_name: Symbol }, #[diag(codegen_ssa_rlib_not_found)] NotFound { crate_name: Symbol }, #[diag(codegen_ssa_rlib_incompatible_dependency_formats)] IncompatibleDependencyFormats { ty1: String, ty2: String, list1: String, list2: String }, } pub struct ThorinErrorWrapper(pub thorin::Error); impl IntoDiagnostic<'_> for ThorinErrorWrapper { fn into_diagnostic(self, handler: &Handler) -> DiagnosticBuilder<'_, ErrorGuaranteed> { let mut diag; match self.0 { thorin::Error::ReadInput(_) => { diag = handler.struct_err(fluent::codegen_ssa_thorin_read_input_failure); diag } thorin::Error::ParseFileKind(_) => { diag = handler.struct_err(fluent::codegen_ssa_thorin_parse_input_file_kind); diag } thorin::Error::ParseObjectFile(_) => { diag = handler.struct_err(fluent::codegen_ssa_thorin_parse_input_object_file); diag } thorin::Error::ParseArchiveFile(_) => { diag = handler.struct_err(fluent::codegen_ssa_thorin_parse_input_archive_file); diag } thorin::Error::ParseArchiveMember(_) => { diag = handler.struct_err(fluent::codegen_ssa_thorin_parse_archive_member); diag } thorin::Error::InvalidInputKind => { diag = handler.struct_err(fluent::codegen_ssa_thorin_invalid_input_kind); diag } thorin::Error::DecompressData(_) => { diag = handler.struct_err(fluent::codegen_ssa_thorin_decompress_data); diag } thorin::Error::NamelessSection(_, offset) => { diag = handler.struct_err(fluent::codegen_ssa_thorin_section_without_name); diag.set_arg("offset", format!("0x{offset:08x}")); diag } thorin::Error::RelocationWithInvalidSymbol(section, offset) => { diag = handler.struct_err(fluent::codegen_ssa_thorin_relocation_with_invalid_symbol); diag.set_arg("section", section); diag.set_arg("offset", format!("0x{offset:08x}")); diag } thorin::Error::MultipleRelocations(section, offset) => { diag = handler.struct_err(fluent::codegen_ssa_thorin_multiple_relocations); diag.set_arg("section", section); diag.set_arg("offset", format!("0x{offset:08x}")); diag } thorin::Error::UnsupportedRelocation(section, offset) => { diag = handler.struct_err(fluent::codegen_ssa_thorin_unsupported_relocation); diag.set_arg("section", section); diag.set_arg("offset", format!("0x{offset:08x}")); diag } thorin::Error::MissingDwoName(id) => { diag = handler.struct_err(fluent::codegen_ssa_thorin_missing_dwo_name); diag.set_arg("id", format!("0x{id:08x}")); diag } thorin::Error::NoCompilationUnits => { diag = handler.struct_err(fluent::codegen_ssa_thorin_no_compilation_units); diag } thorin::Error::NoDie => { diag = handler.struct_err(fluent::codegen_ssa_thorin_no_die); diag } thorin::Error::TopLevelDieNotUnit => { diag = handler.struct_err(fluent::codegen_ssa_thorin_top_level_die_not_unit); diag } thorin::Error::MissingRequiredSection(section) => { diag = handler.struct_err(fluent::codegen_ssa_thorin_missing_required_section); diag.set_arg("section", section); diag } thorin::Error::ParseUnitAbbreviations(_) => { diag = handler.struct_err(fluent::codegen_ssa_thorin_parse_unit_abbreviations); diag } thorin::Error::ParseUnitAttribute(_) => { diag = handler.struct_err(fluent::codegen_ssa_thorin_parse_unit_attribute); diag } thorin::Error::ParseUnitHeader(_) => { diag = handler.struct_err(fluent::codegen_ssa_thorin_parse_unit_header); diag } thorin::Error::ParseUnit(_) => { diag = handler.struct_err(fluent::codegen_ssa_thorin_parse_unit); diag } thorin::Error::IncompatibleIndexVersion(section, format, actual) => { diag = handler.struct_err(fluent::codegen_ssa_thorin_incompatible_index_version); diag.set_arg("section", section); diag.set_arg("actual", actual); diag.set_arg("format", format); diag } thorin::Error::OffsetAtIndex(_, index) => { diag = handler.struct_err(fluent::codegen_ssa_thorin_offset_at_index); diag.set_arg("index", index); diag } thorin::Error::StrAtOffset(_, offset) => { diag = handler.struct_err(fluent::codegen_ssa_thorin_str_at_offset); diag.set_arg("offset", format!("0x{offset:08x}")); diag } thorin::Error::ParseIndex(_, section) => { diag = handler.struct_err(fluent::codegen_ssa_thorin_parse_index); diag.set_arg("section", section); diag } thorin::Error::UnitNotInIndex(unit) => { diag = handler.struct_err(fluent::codegen_ssa_thorin_unit_not_in_index); diag.set_arg("unit", format!("0x{unit:08x}")); diag } thorin::Error::RowNotInIndex(_, row) => { diag = handler.struct_err(fluent::codegen_ssa_thorin_row_not_in_index); diag.set_arg("row", row); diag } thorin::Error::SectionNotInRow => { diag = handler.struct_err(fluent::codegen_ssa_thorin_section_not_in_row); diag } thorin::Error::EmptyUnit(unit) => { diag = handler.struct_err(fluent::codegen_ssa_thorin_empty_unit); diag.set_arg("unit", format!("0x{unit:08x}")); diag } thorin::Error::MultipleDebugInfoSection => { diag = handler.struct_err(fluent::codegen_ssa_thorin_multiple_debug_info_section); diag } thorin::Error::MultipleDebugTypesSection => { diag = handler.struct_err(fluent::codegen_ssa_thorin_multiple_debug_types_section); diag } thorin::Error::NotSplitUnit => { diag = handler.struct_err(fluent::codegen_ssa_thorin_not_split_unit); diag } thorin::Error::DuplicateUnit(unit) => { diag = handler.struct_err(fluent::codegen_ssa_thorin_duplicate_unit); diag.set_arg("unit", format!("0x{unit:08x}")); diag } thorin::Error::MissingReferencedUnit(unit) => { diag = handler.struct_err(fluent::codegen_ssa_thorin_missing_referenced_unit); diag.set_arg("unit", format!("0x{unit:08x}")); diag } thorin::Error::NoOutputObjectCreated => { diag = handler.struct_err(fluent::codegen_ssa_thorin_not_output_object_created); diag } thorin::Error::MixedInputEncodings => { diag = handler.struct_err(fluent::codegen_ssa_thorin_mixed_input_encodings); diag } thorin::Error::Io(e) => { diag = handler.struct_err(fluent::codegen_ssa_thorin_io); diag.set_arg("error", format!("{e}")); diag } thorin::Error::ObjectRead(e) => { diag = handler.struct_err(fluent::codegen_ssa_thorin_object_read); diag.set_arg("error", format!("{e}")); diag } thorin::Error::ObjectWrite(e) => { diag = handler.struct_err(fluent::codegen_ssa_thorin_object_write); diag.set_arg("error", format!("{e}")); diag } thorin::Error::GimliRead(e) => { diag = handler.struct_err(fluent::codegen_ssa_thorin_gimli_read); diag.set_arg("error", format!("{e}")); diag } thorin::Error::GimliWrite(e) => { diag = handler.struct_err(fluent::codegen_ssa_thorin_gimli_write); diag.set_arg("error", format!("{e}")); diag } _ => unimplemented!("Untranslated thorin error"), } } } pub struct LinkingFailed<'a> { pub linker_path: &'a PathBuf, pub exit_status: ExitStatus, pub command: &'a Command, pub escaped_output: String, } impl IntoDiagnostic<'_> for LinkingFailed<'_> { fn into_diagnostic(self, handler: &Handler) -> DiagnosticBuilder<'_, ErrorGuaranteed> { let mut diag = handler.struct_err(fluent::codegen_ssa_linking_failed); diag.set_arg("linker_path", format!("{}", self.linker_path.display())); diag.set_arg("exit_status", format!("{}", self.exit_status)); let contains_undefined_ref = self.escaped_output.contains("undefined reference to"); diag.note(format!("{:?}", self.command)).note(self.escaped_output); // Trying to match an error from OS linkers // which by now we have no way to translate. if contains_undefined_ref { diag.note(fluent::codegen_ssa_extern_funcs_not_found) .note(fluent::codegen_ssa_specify_libraries_to_link) .note(fluent::codegen_ssa_use_cargo_directive); } diag } } #[derive(Diagnostic)] #[diag(codegen_ssa_link_exe_unexpected_error)] pub struct LinkExeUnexpectedError; #[derive(Diagnostic)] #[diag(codegen_ssa_repair_vs_build_tools)] pub struct RepairVSBuildTools; #[derive(Diagnostic)] #[diag(codegen_ssa_missing_cpp_build_tool_component)] pub struct MissingCppBuildToolComponent; #[derive(Diagnostic)] #[diag(codegen_ssa_select_cpp_build_tool_workload)] pub struct SelectCppBuildToolWorkload; #[derive(Diagnostic)] #[diag(codegen_ssa_visual_studio_not_installed)] pub struct VisualStudioNotInstalled; #[derive(Diagnostic)] #[diag(codegen_ssa_linker_not_found)] #[note] pub struct LinkerNotFound { pub linker_path: PathBuf, pub error: Error, } #[derive(Diagnostic)] #[diag(codegen_ssa_unable_to_exe_linker)] #[note] #[note(codegen_ssa_command_note)] pub struct UnableToExeLinker { pub linker_path: PathBuf, pub error: Error, pub command_formatted: String, } #[derive(Diagnostic)] #[diag(codegen_ssa_msvc_missing_linker)] pub struct MsvcMissingLinker; #[derive(Diagnostic)] #[diag(codegen_ssa_check_installed_visual_studio)] pub struct CheckInstalledVisualStudio; #[derive(Diagnostic)] #[diag(codegen_ssa_insufficient_vs_code_product)] pub struct InsufficientVSCodeProduct; #[derive(Diagnostic)] #[diag(codegen_ssa_processing_dymutil_failed)] #[note] pub struct ProcessingDymutilFailed { pub status: ExitStatus, pub output: String, } #[derive(Diagnostic)] #[diag(codegen_ssa_unable_to_run_dsymutil)] #[note] pub struct UnableToRunDsymutil { pub error: Error, } #[derive(Diagnostic)] #[diag(codegen_ssa_stripping_debug_info_failed)] #[note] pub struct StrippingDebugInfoFailed<'a> { pub util: &'a str, pub status: ExitStatus, pub output: String, } #[derive(Diagnostic)] #[diag(codegen_ssa_unable_to_run)] pub struct UnableToRun<'a> { pub util: &'a str, pub error: Error, } #[derive(Diagnostic)] #[diag(codegen_ssa_linker_file_stem)] pub struct LinkerFileStem; #[derive(Diagnostic)] #[diag(codegen_ssa_static_library_native_artifacts)] pub struct StaticLibraryNativeArtifacts; #[derive(Diagnostic)] #[diag(codegen_ssa_static_library_native_artifacts_to_file)] pub struct StaticLibraryNativeArtifactsToFile<'a> { pub path: &'a Path, } #[derive(Diagnostic)] #[diag(codegen_ssa_link_script_unavailable)] pub struct LinkScriptUnavailable; #[derive(Diagnostic)] #[diag(codegen_ssa_link_script_write_failure)] pub struct LinkScriptWriteFailure { pub path: PathBuf, pub error: Error, } #[derive(Diagnostic)] #[diag(codegen_ssa_failed_to_write)] pub struct FailedToWrite { pub path: PathBuf, pub error: Error, } #[derive(Diagnostic)] #[diag(codegen_ssa_unable_to_write_debugger_visualizer)] pub struct UnableToWriteDebuggerVisualizer { pub path: PathBuf, pub error: Error, } #[derive(Diagnostic)] #[diag(codegen_ssa_rlib_archive_build_failure)] pub struct RlibArchiveBuildFailure { pub error: Error, } #[derive(Diagnostic)] pub enum ExtractBundledLibsError<'a> { #[diag(codegen_ssa_extract_bundled_libs_open_file)] OpenFile { rlib: &'a Path, error: Box }, #[diag(codegen_ssa_extract_bundled_libs_mmap_file)] MmapFile { rlib: &'a Path, error: Box }, #[diag(codegen_ssa_extract_bundled_libs_parse_archive)] ParseArchive { rlib: &'a Path, error: Box }, #[diag(codegen_ssa_extract_bundled_libs_read_entry)] ReadEntry { rlib: &'a Path, error: Box }, #[diag(codegen_ssa_extract_bundled_libs_archive_member)] ArchiveMember { rlib: &'a Path, error: Box }, #[diag(codegen_ssa_extract_bundled_libs_convert_name)] ConvertName { rlib: &'a Path, error: Box }, #[diag(codegen_ssa_extract_bundled_libs_write_file)] WriteFile { rlib: &'a Path, error: Box }, #[diag(codegen_ssa_extract_bundled_libs_write_file)] ExtractSection { rlib: &'a Path, error: Box }, } #[derive(Diagnostic)] #[diag(codegen_ssa_unsupported_arch)] pub struct UnsupportedArch<'a> { pub arch: &'a str, pub os: &'a str, } #[derive(Diagnostic)] pub enum AppleSdkRootError<'a> { #[diag(codegen_ssa_apple_sdk_error_sdk_path)] SdkPath { sdk_name: &'a str, error: Error }, } #[derive(Diagnostic)] #[diag(codegen_ssa_read_file)] pub struct ReadFileError { pub message: std::io::Error, } #[derive(Diagnostic)] #[diag(codegen_ssa_unsupported_link_self_contained)] pub struct UnsupportedLinkSelfContained; #[derive(Diagnostic)] #[diag(codegen_ssa_archive_build_failure)] // Public for rustc_codegen_llvm::back::archive pub struct ArchiveBuildFailure { pub error: std::io::Error, } #[derive(Diagnostic)] #[diag(codegen_ssa_unknown_archive_kind)] // Public for rustc_codegen_llvm::back::archive pub struct UnknownArchiveKind<'a> { pub kind: &'a str, } #[derive(Diagnostic)] #[diag(codegen_ssa_expected_coverage_symbol)] pub struct ExpectedCoverageSymbol { #[primary_span] pub span: Span, } #[derive(Diagnostic)] #[diag(codegen_ssa_expected_used_symbol)] pub struct ExpectedUsedSymbol { #[primary_span] pub span: Span, } #[derive(Diagnostic)] #[diag(codegen_ssa_multiple_main_functions)] #[help] pub struct MultipleMainFunctions { #[primary_span] pub span: Span, } #[derive(Diagnostic)] #[diag(codegen_ssa_metadata_object_file_write)] pub struct MetadataObjectFileWrite { pub error: Error, } #[derive(Diagnostic)] #[diag(codegen_ssa_invalid_windows_subsystem)] pub struct InvalidWindowsSubsystem { pub subsystem: Symbol, } #[derive(Diagnostic)] #[diag(codegen_ssa_shuffle_indices_evaluation)] pub struct ShuffleIndicesEvaluation { #[primary_span] pub span: Span, } #[derive(Diagnostic)] #[diag(codegen_ssa_missing_memory_ordering)] pub struct MissingMemoryOrdering; #[derive(Diagnostic)] #[diag(codegen_ssa_unknown_atomic_ordering)] pub struct UnknownAtomicOrdering; #[derive(Diagnostic)] #[diag(codegen_ssa_atomic_compare_exchange)] pub struct AtomicCompareExchange; #[derive(Diagnostic)] #[diag(codegen_ssa_unknown_atomic_operation)] pub struct UnknownAtomicOperation; #[derive(Diagnostic)] pub enum InvalidMonomorphization<'tcx> { #[diag(codegen_ssa_invalid_monomorphization_basic_integer_type, code = "E0511")] BasicIntegerType { #[primary_span] span: Span, name: Symbol, ty: Ty<'tcx>, }, #[diag(codegen_ssa_invalid_monomorphization_basic_float_type, code = "E0511")] BasicFloatType { #[primary_span] span: Span, name: Symbol, ty: Ty<'tcx>, }, #[diag(codegen_ssa_invalid_monomorphization_float_to_int_unchecked, code = "E0511")] FloatToIntUnchecked { #[primary_span] span: Span, ty: Ty<'tcx>, }, #[diag(codegen_ssa_invalid_monomorphization_floating_point_vector, code = "E0511")] FloatingPointVector { #[primary_span] span: Span, name: Symbol, f_ty: FloatTy, in_ty: Ty<'tcx>, }, #[diag(codegen_ssa_invalid_monomorphization_floating_point_type, code = "E0511")] FloatingPointType { #[primary_span] span: Span, name: Symbol, in_ty: Ty<'tcx>, }, #[diag(codegen_ssa_invalid_monomorphization_unrecognized_intrinsic, code = "E0511")] UnrecognizedIntrinsic { #[primary_span] span: Span, name: Symbol, }, #[diag(codegen_ssa_invalid_monomorphization_simd_argument, code = "E0511")] SimdArgument { #[primary_span] span: Span, name: Symbol, ty: Ty<'tcx>, }, #[diag(codegen_ssa_invalid_monomorphization_simd_input, code = "E0511")] SimdInput { #[primary_span] span: Span, name: Symbol, ty: Ty<'tcx>, }, #[diag(codegen_ssa_invalid_monomorphization_simd_first, code = "E0511")] SimdFirst { #[primary_span] span: Span, name: Symbol, ty: Ty<'tcx>, }, #[diag(codegen_ssa_invalid_monomorphization_simd_second, code = "E0511")] SimdSecond { #[primary_span] span: Span, name: Symbol, ty: Ty<'tcx>, }, #[diag(codegen_ssa_invalid_monomorphization_simd_third, code = "E0511")] SimdThird { #[primary_span] span: Span, name: Symbol, ty: Ty<'tcx>, }, #[diag(codegen_ssa_invalid_monomorphization_simd_return, code = "E0511")] SimdReturn { #[primary_span] span: Span, name: Symbol, ty: Ty<'tcx>, }, #[diag(codegen_ssa_invalid_monomorphization_invalid_bitmask, code = "E0511")] InvalidBitmask { #[primary_span] span: Span, name: Symbol, mask_ty: Ty<'tcx>, expected_int_bits: u64, expected_bytes: u64, }, #[diag(codegen_ssa_invalid_monomorphization_return_length_input_type, code = "E0511")] ReturnLengthInputType { #[primary_span] span: Span, name: Symbol, in_len: u64, in_ty: Ty<'tcx>, ret_ty: Ty<'tcx>, out_len: u64, }, #[diag(codegen_ssa_invalid_monomorphization_second_argument_length, code = "E0511")] SecondArgumentLength { #[primary_span] span: Span, name: Symbol, in_len: u64, in_ty: Ty<'tcx>, arg_ty: Ty<'tcx>, out_len: u64, }, #[diag(codegen_ssa_invalid_monomorphization_third_argument_length, code = "E0511")] ThirdArgumentLength { #[primary_span] span: Span, name: Symbol, in_len: u64, in_ty: Ty<'tcx>, arg_ty: Ty<'tcx>, out_len: u64, }, #[diag(codegen_ssa_invalid_monomorphization_return_integer_type, code = "E0511")] ReturnIntegerType { #[primary_span] span: Span, name: Symbol, ret_ty: Ty<'tcx>, out_ty: Ty<'tcx>, }, #[diag(codegen_ssa_invalid_monomorphization_simd_shuffle, code = "E0511")] SimdShuffle { #[primary_span] span: Span, name: Symbol, ty: Ty<'tcx>, }, #[diag(codegen_ssa_invalid_monomorphization_return_length, code = "E0511")] ReturnLength { #[primary_span] span: Span, name: Symbol, in_len: u64, ret_ty: Ty<'tcx>, out_len: u64, }, #[diag(codegen_ssa_invalid_monomorphization_return_element, code = "E0511")] ReturnElement { #[primary_span] span: Span, name: Symbol, in_elem: Ty<'tcx>, in_ty: Ty<'tcx>, ret_ty: Ty<'tcx>, out_ty: Ty<'tcx>, }, #[diag(codegen_ssa_invalid_monomorphization_shuffle_index_not_constant, code = "E0511")] ShuffleIndexNotConstant { #[primary_span] span: Span, name: Symbol, arg_idx: u64, }, #[diag(codegen_ssa_invalid_monomorphization_shuffle_index_out_of_bounds, code = "E0511")] ShuffleIndexOutOfBounds { #[primary_span] span: Span, name: Symbol, arg_idx: u64, total_len: u128, }, #[diag(codegen_ssa_invalid_monomorphization_inserted_type, code = "E0511")] InsertedType { #[primary_span] span: Span, name: Symbol, in_elem: Ty<'tcx>, in_ty: Ty<'tcx>, out_ty: Ty<'tcx>, }, #[diag(codegen_ssa_invalid_monomorphization_return_type, code = "E0511")] ReturnType { #[primary_span] span: Span, name: Symbol, in_elem: Ty<'tcx>, in_ty: Ty<'tcx>, ret_ty: Ty<'tcx>, }, #[diag(codegen_ssa_invalid_monomorphization_expected_return_type, code = "E0511")] ExpectedReturnType { #[primary_span] span: Span, name: Symbol, in_ty: Ty<'tcx>, ret_ty: Ty<'tcx>, }, #[diag(codegen_ssa_invalid_monomorphization_mismatched_lengths, code = "E0511")] MismatchedLengths { #[primary_span] span: Span, name: Symbol, m_len: u64, v_len: u64, }, #[diag(codegen_ssa_invalid_monomorphization_mask_type, code = "E0511")] MaskType { #[primary_span] span: Span, name: Symbol, ty: Ty<'tcx>, }, #[diag(codegen_ssa_invalid_monomorphization_vector_argument, code = "E0511")] VectorArgument { #[primary_span] span: Span, name: Symbol, in_ty: Ty<'tcx>, in_elem: Ty<'tcx>, }, #[diag(codegen_ssa_invalid_monomorphization_cannot_return, code = "E0511")] CannotReturn { #[primary_span] span: Span, name: Symbol, ret_ty: Ty<'tcx>, expected_int_bits: u64, expected_bytes: u64, }, #[diag(codegen_ssa_invalid_monomorphization_expected_element_type, code = "E0511")] ExpectedElementType { #[primary_span] span: Span, name: Symbol, expected_element: Ty<'tcx>, second_arg: Ty<'tcx>, in_elem: Ty<'tcx>, in_ty: Ty<'tcx>, mutability: ExpectedPointerMutability, }, #[diag(codegen_ssa_invalid_monomorphization_third_arg_element_type, code = "E0511")] ThirdArgElementType { #[primary_span] span: Span, name: Symbol, expected_element: Ty<'tcx>, third_arg: Ty<'tcx>, }, #[diag(codegen_ssa_invalid_monomorphization_unsupported_symbol_of_size, code = "E0511")] UnsupportedSymbolOfSize { #[primary_span] span: Span, name: Symbol, symbol: Symbol, in_ty: Ty<'tcx>, in_elem: Ty<'tcx>, size: u64, ret_ty: Ty<'tcx>, }, #[diag(codegen_ssa_invalid_monomorphization_unsupported_symbol, code = "E0511")] UnsupportedSymbol { #[primary_span] span: Span, name: Symbol, symbol: Symbol, in_ty: Ty<'tcx>, in_elem: Ty<'tcx>, ret_ty: Ty<'tcx>, }, #[diag(codegen_ssa_invalid_monomorphization_cast_fat_pointer, code = "E0511")] CastFatPointer { #[primary_span] span: Span, name: Symbol, ty: Ty<'tcx>, }, #[diag(codegen_ssa_invalid_monomorphization_expected_pointer, code = "E0511")] ExpectedPointer { #[primary_span] span: Span, name: Symbol, ty: Ty<'tcx>, }, #[diag(codegen_ssa_invalid_monomorphization_expected_usize, code = "E0511")] ExpectedUsize { #[primary_span] span: Span, name: Symbol, ty: Ty<'tcx>, }, #[diag(codegen_ssa_invalid_monomorphization_unsupported_cast, code = "E0511")] UnsupportedCast { #[primary_span] span: Span, name: Symbol, in_ty: Ty<'tcx>, in_elem: Ty<'tcx>, ret_ty: Ty<'tcx>, out_elem: Ty<'tcx>, }, #[diag(codegen_ssa_invalid_monomorphization_unsupported_operation, code = "E0511")] UnsupportedOperation { #[primary_span] span: Span, name: Symbol, in_ty: Ty<'tcx>, in_elem: Ty<'tcx>, }, #[diag(codegen_ssa_invalid_monomorphization_expected_vector_element_type, code = "E0511")] ExpectedVectorElementType { #[primary_span] span: Span, name: Symbol, expected_element: Ty<'tcx>, vector_type: Ty<'tcx>, }, } pub enum ExpectedPointerMutability { Mut, Not, } impl IntoDiagnosticArg for ExpectedPointerMutability { fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> { match self { ExpectedPointerMutability::Mut => DiagnosticArgValue::Str(Cow::Borrowed("*mut")), ExpectedPointerMutability::Not => DiagnosticArgValue::Str(Cow::Borrowed("*_")), } } } #[derive(Diagnostic)] #[diag(codegen_ssa_invalid_no_sanitize)] #[note] pub struct InvalidNoSanitize { #[primary_span] pub span: Span, } #[derive(Diagnostic)] #[diag(codegen_ssa_invalid_link_ordinal_nargs)] #[note] pub struct InvalidLinkOrdinalNargs { #[primary_span] pub span: Span, } #[derive(Diagnostic)] #[diag(codegen_ssa_illegal_link_ordinal_format)] #[note] pub struct InvalidLinkOrdinalFormat { #[primary_span] pub span: Span, } #[derive(Diagnostic)] #[diag(codegen_ssa_target_feature_safe_trait)] pub struct TargetFeatureSafeTrait { #[primary_span] #[label] pub span: Span, #[label(codegen_ssa_label_def)] pub def: Span, } #[derive(Diagnostic)] #[diag(codegen_ssa_failed_to_get_layout)] pub struct FailedToGetLayout<'tcx> { #[primary_span] pub span: Span, pub ty: Ty<'tcx>, pub err: LayoutError<'tcx>, } #[derive(Diagnostic)] #[diag(codegen_ssa_error_creating_remark_dir)] pub struct ErrorCreatingRemarkDir { pub error: std::io::Error, }