compiler/rustc_codegen_gcc/src/errors.rs

   1 use rustc_errors::{DiagnosticArgValue, IntoDiagnosticArg};
   2 use rustc_macros::Diagnostic;
   3 use rustc_middle::ty::Ty;
   4 use rustc_span::{Span, Symbol};
   5 use std::borrow::Cow;
   6
   7 struct ExitCode(Option<i32>);
   8
   9 impl IntoDiagnosticArg for ExitCode {
  10     fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
  11         let ExitCode(exit_code) = self;
  12         match exit_code {
  13             Some(t) => t.into_diagnostic_arg(),
  14             None => DiagnosticArgValue::Str(Cow::Borrowed("<signal>")),
  15         }
  16     }
  17 }
  18
  19 #[derive(Diagnostic)]
  20 #[diag(codegen_gcc_invalid_monomorphization_basic_integer, code = "E0511")]
  21 pub(crate) struct InvalidMonomorphizationBasicInteger<'a> {
  22     #[primary_span]
  23     pub span: Span,
  24     pub name: Symbol,
  25     pub ty: Ty<'a>,
  26 }
  27
  28 #[derive(Diagnostic)]
  29 #[diag(codegen_gcc_invalid_monomorphization_invalid_float_vector, code = "E0511")]
  30 pub(crate) struct InvalidMonomorphizationInvalidFloatVector<'a> {
  31     #[primary_span]
  32     pub span: Span,
  33     pub name: Symbol,
  34     pub elem_ty: &'a str,
  35     pub vec_ty: Ty<'a>,
  36 }
  37
  38 #[derive(Diagnostic)]
  39 #[diag(codegen_gcc_invalid_monomorphization_not_float, code = "E0511")]
  40 pub(crate) struct InvalidMonomorphizationNotFloat<'a> {
  41     #[primary_span]
  42     pub span: Span,
  43     pub name: Symbol,
  44     pub ty: Ty<'a>,
  45 }
  46
  47 #[derive(Diagnostic)]
  48 #[diag(codegen_gcc_invalid_monomorphization_unrecognized, code = "E0511")]
  49 pub(crate) struct InvalidMonomorphizationUnrecognized {
  50     #[primary_span]
  51     pub span: Span,
  52     pub name: Symbol,
  53 }
  54
  55 #[derive(Diagnostic)]
  56 #[diag(codegen_gcc_invalid_monomorphization_expected_signed_unsigned, code = "E0511")]
  57 pub(crate) struct InvalidMonomorphizationExpectedSignedUnsigned<'a> {
  58     #[primary_span]
  59     pub span: Span,
  60     pub name: Symbol,
  61     pub elem_ty: Ty<'a>,
  62     pub vec_ty: Ty<'a>,
  63 }
  64
  65 #[derive(Diagnostic)]
  66 #[diag(codegen_gcc_invalid_monomorphization_unsupported_element, code = "E0511")]
  67 pub(crate) struct InvalidMonomorphizationUnsupportedElement<'a> {
  68     #[primary_span]
  69     pub span: Span,
  70     pub name: Symbol,
  71     pub in_ty: Ty<'a>,
  72     pub elem_ty: Ty<'a>,
  73     pub ret_ty: Ty<'a>,
  74 }
  75
  76 #[derive(Diagnostic)]
  77 #[diag(codegen_gcc_invalid_monomorphization_invalid_bitmask, code = "E0511")]
  78 pub(crate) struct InvalidMonomorphizationInvalidBitmask<'a> {
  79     #[primary_span]
  80     pub span: Span,
  81     pub name: Symbol,
  82     pub ty: Ty<'a>,
  83     pub expected_int_bits: u64,
  84     pub expected_bytes: u64,
  85 }
  86
  87 #[derive(Diagnostic)]
  88 #[diag(codegen_gcc_invalid_monomorphization_simd_shuffle, code = "E0511")]
  89 pub(crate) struct InvalidMonomorphizationSimdShuffle<'a> {
  90     #[primary_span]
  91     pub span: Span,
  92     pub name: Symbol,
  93     pub ty: Ty<'a>,
  94 }
  95
  96 #[derive(Diagnostic)]
  97 #[diag(codegen_gcc_invalid_monomorphization_expected_simd, code = "E0511")]
  98 pub(crate) struct InvalidMonomorphizationExpectedSimd<'a> {
  99     #[primary_span]
 100     pub span: Span,
 101     pub name: Symbol,
 102     pub position: &'a str,
 103     pub found_ty: Ty<'a>,
 104 }
 105
 106 #[derive(Diagnostic)]
 107 #[diag(codegen_gcc_invalid_monomorphization_mask_type, code = "E0511")]
 108 pub(crate) struct InvalidMonomorphizationMaskType<'a> {
 109     #[primary_span]
 110     pub span: Span,
 111     pub name: Symbol,
 112     pub ty: Ty<'a>,
 113 }
 114
 115 #[derive(Diagnostic)]
 116 #[diag(codegen_gcc_invalid_monomorphization_return_length, code = "E0511")]
 117 pub(crate) struct InvalidMonomorphizationReturnLength<'a> {
 118     #[primary_span]
 119     pub span: Span,
 120     pub name: Symbol,
 121     pub in_len: u64,
 122     pub ret_ty: Ty<'a>,
 123     pub out_len: u64,
 124 }
 125
 126 #[derive(Diagnostic)]
 127 #[diag(codegen_gcc_invalid_monomorphization_return_length_input_type, code = "E0511")]
 128 pub(crate) struct InvalidMonomorphizationReturnLengthInputType<'a> {
 129     #[primary_span]
 130     pub span: Span,
 131     pub name: Symbol,
 132     pub in_len: u64,
 133     pub in_ty: Ty<'a>,
 134     pub ret_ty: Ty<'a>,
 135     pub out_len: u64,
 136 }
 137
 138 #[derive(Diagnostic)]
 139 #[diag(codegen_gcc_invalid_monomorphization_return_element, code = "E0511")]
 140 pub(crate) struct InvalidMonomorphizationReturnElement<'a> {
 141     #[primary_span]
 142     pub span: Span,
 143     pub name: Symbol,
 144     pub in_elem: Ty<'a>,
 145     pub in_ty: Ty<'a>,
 146     pub ret_ty: Ty<'a>,
 147     pub out_ty: Ty<'a>,
 148 }
 149
 150 #[derive(Diagnostic)]
 151 #[diag(codegen_gcc_invalid_monomorphization_return_type, code = "E0511")]
 152 pub(crate) struct InvalidMonomorphizationReturnType<'a> {
 153     #[primary_span]
 154     pub span: Span,
 155     pub name: Symbol,
 156     pub in_elem: Ty<'a>,
 157     pub in_ty: Ty<'a>,
 158     pub ret_ty: Ty<'a>,
 159 }
 160
 161 #[derive(Diagnostic)]
 162 #[diag(codegen_gcc_invalid_monomorphization_inserted_type, code = "E0511")]
 163 pub(crate) struct InvalidMonomorphizationInsertedType<'a> {
 164     #[primary_span]
 165     pub span: Span,
 166     pub name: Symbol,
 167     pub in_elem: Ty<'a>,
 168     pub in_ty: Ty<'a>,
 169     pub out_ty: Ty<'a>,
 170 }
 171
 172 #[derive(Diagnostic)]
 173 #[diag(codegen_gcc_invalid_monomorphization_return_integer_type, code = "E0511")]
 174 pub(crate) struct InvalidMonomorphizationReturnIntegerType<'a> {
 175     #[primary_span]
 176     pub span: Span,
 177     pub name: Symbol,
 178     pub ret_ty: Ty<'a>,
 179     pub out_ty: Ty<'a>,
 180 }
 181
 182 #[derive(Diagnostic)]
 183 #[diag(codegen_gcc_invalid_monomorphization_mismatched_lengths, code = "E0511")]
 184 pub(crate) struct InvalidMonomorphizationMismatchedLengths {
 185     #[primary_span]
 186     pub span: Span,
 187     pub name: Symbol,
 188     pub m_len: u64,
 189     pub v_len: u64,
 190 }
 191
 192 #[derive(Diagnostic)]
 193 #[diag(codegen_gcc_invalid_monomorphization_unsupported_cast, code = "E0511")]
 194 pub(crate) struct InvalidMonomorphizationUnsupportedCast<'a> {
 195     #[primary_span]
 196     pub span: Span,
 197     pub name: Symbol,
 198     pub in_ty: Ty<'a>,
 199     pub in_elem: Ty<'a>,
 200     pub ret_ty: Ty<'a>,
 201     pub out_elem: Ty<'a>,
 202 }
 203
 204 #[derive(Diagnostic)]
 205 #[diag(codegen_gcc_invalid_monomorphization_unsupported_operation, code = "E0511")]
 206 pub(crate) struct InvalidMonomorphizationUnsupportedOperation<'a> {
 207     #[primary_span]
 208     pub span: Span,
 209     pub name: Symbol,
 210     pub in_ty: Ty<'a>,
 211     pub in_elem: Ty<'a>,
 212 }
 213
 214 #[derive(Diagnostic)]
 215 #[diag(codegen_gcc_lto_not_supported)]
 216 pub(crate) struct LTONotSupported;
 217
 218 #[derive(Diagnostic)]
 219 #[diag(codegen_gcc_unwinding_inline_asm)]
 220 pub(crate) struct UnwindingInlineAsm {
 221     #[primary_span]
 222     pub span: Span,
 223 }
 224
 225 #[derive(Diagnostic)]
 226 #[diag(codegen_gcc_invalid_minimum_alignment)]
 227 pub(crate) struct InvalidMinimumAlignment {
 228     pub err: String,
 229 }
 230
 231 #[derive(Diagnostic)]
 232 #[diag(codegen_gcc_tied_target_features)]
 233 #[help]
 234 pub(crate) struct TiedTargetFeatures {
 235     #[primary_span]
 236     pub span: Span,
 237     pub features: String,
 238 }