[rustc.git] / compiler / rustc_ast_lowering / src / errors.rs

use rustc_errors::DiagnosticArgFromDisplay;
use rustc_macros::{Diagnostic, Subdiagnostic};
use rustc_span::{symbol::Ident, Span, Symbol};

#[derive(Diagnostic, Clone, Copy)]
#[diag(ast_lowering_generic_type_with_parentheses, code = "E0214")]
pub struct GenericTypeWithParentheses {
    #[primary_span]
    #[label]
    pub span: Span,
    #[subdiagnostic]
    pub sub: Option<UseAngleBrackets>,
}

#[derive(Clone, Copy, Subdiagnostic)]
#[multipart_suggestion(ast_lowering_use_angle_brackets, applicability = "maybe-incorrect")]
pub struct UseAngleBrackets {
    #[suggestion_part(code = "<")]
    pub open_param: Span,
    #[suggestion_part(code = ">")]
    pub close_param: Span,
}

#[derive(Diagnostic)]
#[diag(ast_lowering_invalid_abi, code = "E0703")]
#[note]
pub struct InvalidAbi {
    #[primary_span]
    #[label]
    pub span: Span,
    pub abi: Symbol,
    pub command: String,
    #[subdiagnostic]
    pub suggestion: Option<InvalidAbiSuggestion>,
}

#[derive(Subdiagnostic)]
#[suggestion(
    ast_lowering_invalid_abi_suggestion,
    code = "{suggestion}",
    applicability = "maybe-incorrect"
)]
pub struct InvalidAbiSuggestion {
    #[primary_span]
    pub span: Span,
    pub suggestion: String,
}

#[derive(Diagnostic, Clone, Copy)]
#[diag(ast_lowering_assoc_ty_parentheses)]
pub struct AssocTyParentheses {
    #[primary_span]
    pub span: Span,
    #[subdiagnostic]
    pub sub: AssocTyParenthesesSub,
}

#[derive(Clone, Copy, Subdiagnostic)]
pub enum AssocTyParenthesesSub {
    #[multipart_suggestion(ast_lowering_remove_parentheses)]
    Empty {
        #[suggestion_part(code = "")]
        parentheses_span: Span,
    },
    #[multipart_suggestion(ast_lowering_use_angle_brackets)]
    NotEmpty {
        #[suggestion_part(code = "<")]
        open_param: Span,
        #[suggestion_part(code = ">")]
        close_param: Span,
    },
}

#[derive(Diagnostic)]
#[diag(ast_lowering_misplaced_impl_trait, code = "E0562")]
pub struct MisplacedImplTrait<'a> {
    #[primary_span]
    pub span: Span,
    pub position: DiagnosticArgFromDisplay<'a>,
}

#[derive(Diagnostic)]
#[diag(ast_lowering_misplaced_assoc_ty_binding)]
pub struct MisplacedAssocTyBinding<'a> {
    #[primary_span]
    pub span: Span,
    pub position: DiagnosticArgFromDisplay<'a>,
}

#[derive(Diagnostic, Clone, Copy)]
#[diag(ast_lowering_underscore_expr_lhs_assign)]
pub struct UnderscoreExprLhsAssign {
    #[primary_span]
    #[label]
    pub span: Span,
}

#[derive(Diagnostic, Clone, Copy)]
#[diag(ast_lowering_base_expression_double_dot)]
pub struct BaseExpressionDoubleDot {
    #[primary_span]
    #[label]
    pub span: Span,
}

#[derive(Diagnostic, Clone, Copy)]
#[diag(ast_lowering_await_only_in_async_fn_and_blocks, code = "E0728")]
pub struct AwaitOnlyInAsyncFnAndBlocks {
    #[primary_span]
    #[label]
    pub await_kw_span: Span,
    #[label(ast_lowering_this_not_async)]
    pub item_span: Option<Span>,
}

#[derive(Diagnostic, Clone, Copy)]
#[diag(ast_lowering_generator_too_many_parameters, code = "E0628")]
pub struct GeneratorTooManyParameters {
    #[primary_span]
    pub fn_decl_span: Span,
}

#[derive(Diagnostic, Clone, Copy)]
#[diag(ast_lowering_closure_cannot_be_static, code = "E0697")]
pub struct ClosureCannotBeStatic {
    #[primary_span]
    pub fn_decl_span: Span,
}

#[derive(Diagnostic, Clone, Copy)]
#[help]
#[diag(ast_lowering_async_non_move_closure_not_supported, code = "E0708")]
pub struct AsyncNonMoveClosureNotSupported {
    #[primary_span]
    pub fn_decl_span: Span,
}

#[derive(Diagnostic, Clone, Copy)]
#[diag(ast_lowering_functional_record_update_destructuring_assignment)]
pub struct FunctionalRecordUpdateDestructuringAssignment {
    #[primary_span]
    #[suggestion(code = "", applicability = "machine-applicable")]
    pub span: Span,
}

#[derive(Diagnostic, Clone, Copy)]
#[diag(ast_lowering_async_generators_not_supported, code = "E0727")]
pub struct AsyncGeneratorsNotSupported {
    #[primary_span]
    pub span: Span,
}

#[derive(Diagnostic, Clone, Copy)]
#[diag(ast_lowering_inline_asm_unsupported_target, code = "E0472")]
pub struct InlineAsmUnsupportedTarget {
    #[primary_span]
    pub span: Span,
}

#[derive(Diagnostic, Clone, Copy)]
#[diag(ast_lowering_att_syntax_only_x86)]
pub struct AttSyntaxOnlyX86 {
    #[primary_span]
    pub span: Span,
}

#[derive(Diagnostic, Clone, Copy)]
#[diag(ast_lowering_abi_specified_multiple_times)]
pub struct AbiSpecifiedMultipleTimes {
    #[primary_span]
    pub abi_span: Span,
    pub prev_name: Symbol,
    #[label]
    pub prev_span: Span,
    #[note]
    pub equivalent: Option<()>,
}

#[derive(Diagnostic, Clone, Copy)]
#[diag(ast_lowering_clobber_abi_not_supported)]
pub struct ClobberAbiNotSupported {
    #[primary_span]
    pub abi_span: Span,
}

#[derive(Diagnostic)]
#[note]
#[diag(ast_lowering_invalid_abi_clobber_abi)]
pub struct InvalidAbiClobberAbi {
    #[primary_span]
    pub abi_span: Span,
    pub supported_abis: String,
}

#[derive(Diagnostic, Clone, Copy)]
#[diag(ast_lowering_invalid_register)]
pub struct InvalidRegister<'a> {
    #[primary_span]
    pub op_span: Span,
    pub reg: Symbol,
    pub error: &'a str,
}

#[derive(Diagnostic, Clone, Copy)]
#[diag(ast_lowering_invalid_register_class)]
pub struct InvalidRegisterClass<'a> {
    #[primary_span]
    pub op_span: Span,
    pub reg_class: Symbol,
    pub error: &'a str,
}

#[derive(Diagnostic)]
#[diag(ast_lowering_invalid_asm_template_modifier_reg_class)]
pub struct InvalidAsmTemplateModifierRegClass {
    #[primary_span]
    #[label(ast_lowering_template_modifier)]
    pub placeholder_span: Span,
    #[label(ast_lowering_argument)]
    pub op_span: Span,
    #[subdiagnostic]
    pub sub: InvalidAsmTemplateModifierRegClassSub,
}

#[derive(Subdiagnostic)]
pub enum InvalidAsmTemplateModifierRegClassSub {
    #[note(ast_lowering_support_modifiers)]
    SupportModifier { class_name: Symbol, modifiers: String },
    #[note(ast_lowering_does_not_support_modifiers)]
    DoesNotSupportModifier { class_name: Symbol },
}

#[derive(Diagnostic, Clone, Copy)]
#[diag(ast_lowering_invalid_asm_template_modifier_const)]
pub struct InvalidAsmTemplateModifierConst {
    #[primary_span]
    #[label(ast_lowering_template_modifier)]
    pub placeholder_span: Span,
    #[label(ast_lowering_argument)]
    pub op_span: Span,
}

#[derive(Diagnostic, Clone, Copy)]
#[diag(ast_lowering_invalid_asm_template_modifier_sym)]
pub struct InvalidAsmTemplateModifierSym {
    #[primary_span]
    #[label(ast_lowering_template_modifier)]
    pub placeholder_span: Span,
    #[label(ast_lowering_argument)]
    pub op_span: Span,
}

#[derive(Diagnostic, Clone, Copy)]
#[diag(ast_lowering_register_class_only_clobber)]
pub struct RegisterClassOnlyClobber {
    #[primary_span]
    pub op_span: Span,
    pub reg_class_name: Symbol,
}

#[derive(Diagnostic, Clone, Copy)]
#[diag(ast_lowering_register_conflict)]
pub struct RegisterConflict<'a> {
    #[primary_span]
    #[label(ast_lowering_register1)]
    pub op_span1: Span,
    #[label(ast_lowering_register2)]
    pub op_span2: Span,
    pub reg1_name: &'a str,
    pub reg2_name: &'a str,
    #[help]
    pub in_out: Option<Span>,
}

#[derive(Diagnostic, Clone, Copy)]
#[help]
#[diag(ast_lowering_sub_tuple_binding)]
pub struct SubTupleBinding<'a> {
    #[primary_span]
    #[label]
    #[suggestion(
        ast_lowering_sub_tuple_binding_suggestion,
        style = "verbose",
        code = "..",
        applicability = "maybe-incorrect"
    )]
    pub span: Span,
    pub ident: Ident,
    pub ident_name: Symbol,
    pub ctx: &'a str,
}

#[derive(Diagnostic, Clone, Copy)]
#[diag(ast_lowering_extra_double_dot)]
pub struct ExtraDoubleDot<'a> {
    #[primary_span]
    #[label]
    pub span: Span,
    #[label(ast_lowering_previously_used_here)]
    pub prev_span: Span,
    pub ctx: &'a str,
}

#[derive(Diagnostic, Clone, Copy)]
#[note]
#[diag(ast_lowering_misplaced_double_dot)]
pub struct MisplacedDoubleDot {
    #[primary_span]
    pub span: Span,
}

#[derive(Diagnostic, Clone, Copy)]
#[diag(ast_lowering_misplaced_relax_trait_bound)]
pub struct MisplacedRelaxTraitBound {
    #[primary_span]
    pub span: Span,
}

#[derive(Diagnostic, Clone, Copy)]
#[diag(ast_lowering_not_supported_for_lifetime_binder_async_closure)]
pub struct NotSupportedForLifetimeBinderAsyncClosure {
    #[primary_span]
    pub span: Span,
}

#[derive(Diagnostic, Clone, Copy)]
#[diag(ast_lowering_arbitrary_expression_in_pattern)]
pub struct ArbitraryExpressionInPattern {
    #[primary_span]
    pub span: Span,
}

#[derive(Diagnostic, Clone, Copy)]
#[diag(ast_lowering_inclusive_range_with_no_end)]
pub struct InclusiveRangeWithNoEnd {
    #[primary_span]
    pub span: Span,
}

#[derive(Diagnostic, Clone, Copy)]
#[diag(ast_lowering_trait_fn_async, code = "E0706")]
#[note]
#[note(ast_lowering_note2)]
pub struct TraitFnAsync {
    #[primary_span]
    pub fn_span: Span,
    #[label]
    pub span: Span,
}

#[derive(Diagnostic)]
pub enum BadReturnTypeNotation {
    #[diag(ast_lowering_bad_return_type_notation_inputs)]
    Inputs {
        #[primary_span]
        #[suggestion(code = "()", applicability = "maybe-incorrect")]
        span: Span,
    },
    #[diag(ast_lowering_bad_return_type_notation_output)]
    Output {
        #[primary_span]
        #[suggestion(code = "", applicability = "maybe-incorrect")]
        span: Span,
    },
}
Commit	Line	Data
2b03887a FG	1	use rustc_errors::DiagnosticArgFromDisplay;
2b03887a FG	2	use rustc_macros::{Diagnostic, Subdiagnostic};
f2b60f7d FG	3	use rustc_span::{symbol::Ident, Span, Symbol};
f2b60f7d FG	4
2b03887a FG	5	#[derive(Diagnostic, Clone, Copy)]
2b03887a FG	6	#[diag(ast_lowering_generic_type_with_parentheses, code = "E0214")]
f2b60f7d FG	7	pub struct GenericTypeWithParentheses {
	8	#[primary_span]
	9	#[label]
	10	pub span: Span,
	11	#[subdiagnostic]
	12	pub sub: Option<UseAngleBrackets>,
	13	}
	14
2b03887a FG	15	#[derive(Clone, Copy, Subdiagnostic)]
2b03887a FG	16	#[multipart_suggestion(ast_lowering_use_angle_brackets, applicability = "maybe-incorrect")]
f2b60f7d	17	pub struct UseAngleBrackets {
2b03887a	18	#[suggestion_part(code = "<")]
f2b60f7d	19	pub open_param: Span,
2b03887a	20	#[suggestion_part(code = ">")]
f2b60f7d FG	21	pub close_param: Span,
	22	}
	23
2b03887a FG	24	#[derive(Diagnostic)]
	25	#[diag(ast_lowering_invalid_abi, code = "E0703")]
	26	#[note]
f2b60f7d FG	27	pub struct InvalidAbi {
	28	#[primary_span]
	29	#[label]
	30	pub span: Span,
	31	pub abi: Symbol,
2b03887a FG	32	pub command: String,
	33	#[subdiagnostic]
	34	pub suggestion: Option<InvalidAbiSuggestion>,
	35	}
	36
	37	#[derive(Subdiagnostic)]
	38	#[suggestion(
	39	ast_lowering_invalid_abi_suggestion,
	40	code = "{suggestion}",
	41	applicability = "maybe-incorrect"
	42	)]
	43	pub struct InvalidAbiSuggestion {
	44	#[primary_span]
	45	pub span: Span,
	46	pub suggestion: String,
f2b60f7d FG	47	}
f2b60f7d FG	48
2b03887a FG	49	#[derive(Diagnostic, Clone, Copy)]
2b03887a FG	50	#[diag(ast_lowering_assoc_ty_parentheses)]
f2b60f7d FG	51	pub struct AssocTyParentheses {
	52	#[primary_span]
	53	pub span: Span,
	54	#[subdiagnostic]
	55	pub sub: AssocTyParenthesesSub,
	56	}
	57
2b03887a	58	#[derive(Clone, Copy, Subdiagnostic)]
f2b60f7d	59	pub enum AssocTyParenthesesSub {
2b03887a FG	60	#[multipart_suggestion(ast_lowering_remove_parentheses)]
	61	Empty {
	62	#[suggestion_part(code = "")]
	63	parentheses_span: Span,
	64	},
	65	#[multipart_suggestion(ast_lowering_use_angle_brackets)]
	66	NotEmpty {
	67	#[suggestion_part(code = "<")]
	68	open_param: Span,
	69	#[suggestion_part(code = ">")]
	70	close_param: Span,
	71	},
	72	}
	73
	74	#[derive(Diagnostic)]
	75	#[diag(ast_lowering_misplaced_impl_trait, code = "E0562")]
f2b60f7d FG	76	pub struct MisplacedImplTrait<'a> {
	77	#[primary_span]
	78	pub span: Span,
	79	pub position: DiagnosticArgFromDisplay<'a>,
	80	}
	81
9ffffee4 FG	82	#[derive(Diagnostic)]
	83	#[diag(ast_lowering_misplaced_assoc_ty_binding)]
	84	pub struct MisplacedAssocTyBinding<'a> {
f2b60f7d FG	85	#[primary_span]
f2b60f7d FG	86	pub span: Span,
9ffffee4	87	pub position: DiagnosticArgFromDisplay<'a>,
f2b60f7d FG	88	}
f2b60f7d FG	89
2b03887a FG	90	#[derive(Diagnostic, Clone, Copy)]
2b03887a FG	91	#[diag(ast_lowering_underscore_expr_lhs_assign)]
f2b60f7d FG	92	pub struct UnderscoreExprLhsAssign {
	93	#[primary_span]
	94	#[label]
	95	pub span: Span,
	96	}
	97
2b03887a FG	98	#[derive(Diagnostic, Clone, Copy)]
2b03887a FG	99	#[diag(ast_lowering_base_expression_double_dot)]
f2b60f7d FG	100	pub struct BaseExpressionDoubleDot {
	101	#[primary_span]
	102	#[label]
	103	pub span: Span,
	104	}
	105
2b03887a FG	106	#[derive(Diagnostic, Clone, Copy)]
2b03887a FG	107	#[diag(ast_lowering_await_only_in_async_fn_and_blocks, code = "E0728")]
f2b60f7d FG	108	pub struct AwaitOnlyInAsyncFnAndBlocks {
	109	#[primary_span]
	110	#[label]
49aad941	111	pub await_kw_span: Span,
2b03887a	112	#[label(ast_lowering_this_not_async)]
f2b60f7d FG	113	pub item_span: Option<Span>,
	114	}
	115
2b03887a FG	116	#[derive(Diagnostic, Clone, Copy)]
2b03887a FG	117	#[diag(ast_lowering_generator_too_many_parameters, code = "E0628")]
f2b60f7d FG	118	pub struct GeneratorTooManyParameters {
	119	#[primary_span]
	120	pub fn_decl_span: Span,
	121	}
	122
2b03887a FG	123	#[derive(Diagnostic, Clone, Copy)]
2b03887a FG	124	#[diag(ast_lowering_closure_cannot_be_static, code = "E0697")]
f2b60f7d FG	125	pub struct ClosureCannotBeStatic {
	126	#[primary_span]
	127	pub fn_decl_span: Span,
	128	}
	129
2b03887a	130	#[derive(Diagnostic, Clone, Copy)]
f2b60f7d	131	#[help]
2b03887a	132	#[diag(ast_lowering_async_non_move_closure_not_supported, code = "E0708")]
f2b60f7d FG	133	pub struct AsyncNonMoveClosureNotSupported {
	134	#[primary_span]
	135	pub fn_decl_span: Span,
	136	}
	137
2b03887a FG	138	#[derive(Diagnostic, Clone, Copy)]
2b03887a FG	139	#[diag(ast_lowering_functional_record_update_destructuring_assignment)]
353b0b11	140	pub struct FunctionalRecordUpdateDestructuringAssignment {
f2b60f7d FG	141	#[primary_span]
	142	#[suggestion(code = "", applicability = "machine-applicable")]
	143	pub span: Span,
	144	}
	145
2b03887a FG	146	#[derive(Diagnostic, Clone, Copy)]
2b03887a FG	147	#[diag(ast_lowering_async_generators_not_supported, code = "E0727")]
f2b60f7d FG	148	pub struct AsyncGeneratorsNotSupported {
	149	#[primary_span]
	150	pub span: Span,
	151	}
	152
2b03887a FG	153	#[derive(Diagnostic, Clone, Copy)]
2b03887a FG	154	#[diag(ast_lowering_inline_asm_unsupported_target, code = "E0472")]
f2b60f7d FG	155	pub struct InlineAsmUnsupportedTarget {
	156	#[primary_span]
	157	pub span: Span,
	158	}
	159
2b03887a FG	160	#[derive(Diagnostic, Clone, Copy)]
2b03887a FG	161	#[diag(ast_lowering_att_syntax_only_x86)]
f2b60f7d FG	162	pub struct AttSyntaxOnlyX86 {
	163	#[primary_span]
	164	pub span: Span,
	165	}
	166
2b03887a FG	167	#[derive(Diagnostic, Clone, Copy)]
2b03887a FG	168	#[diag(ast_lowering_abi_specified_multiple_times)]
f2b60f7d FG	169	pub struct AbiSpecifiedMultipleTimes {
	170	#[primary_span]
	171	pub abi_span: Span,
	172	pub prev_name: Symbol,
	173	#[label]
	174	pub prev_span: Span,
	175	#[note]
	176	pub equivalent: Option<()>,
	177	}
	178
2b03887a FG	179	#[derive(Diagnostic, Clone, Copy)]
2b03887a FG	180	#[diag(ast_lowering_clobber_abi_not_supported)]
f2b60f7d FG	181	pub struct ClobberAbiNotSupported {
	182	#[primary_span]
	183	pub abi_span: Span,
	184	}
	185
2b03887a	186	#[derive(Diagnostic)]
f2b60f7d	187	#[note]
2b03887a	188	#[diag(ast_lowering_invalid_abi_clobber_abi)]
f2b60f7d FG	189	pub struct InvalidAbiClobberAbi {
	190	#[primary_span]
	191	pub abi_span: Span,
	192	pub supported_abis: String,
	193	}
	194
2b03887a FG	195	#[derive(Diagnostic, Clone, Copy)]
2b03887a FG	196	#[diag(ast_lowering_invalid_register)]
f2b60f7d FG	197	pub struct InvalidRegister<'a> {
	198	#[primary_span]
	199	pub op_span: Span,
	200	pub reg: Symbol,
	201	pub error: &'a str,
	202	}
	203
2b03887a FG	204	#[derive(Diagnostic, Clone, Copy)]
2b03887a FG	205	#[diag(ast_lowering_invalid_register_class)]
f2b60f7d FG	206	pub struct InvalidRegisterClass<'a> {
	207	#[primary_span]
	208	pub op_span: Span,
	209	pub reg_class: Symbol,
	210	pub error: &'a str,
	211	}
	212
2b03887a FG	213	#[derive(Diagnostic)]
2b03887a FG	214	#[diag(ast_lowering_invalid_asm_template_modifier_reg_class)]
f2b60f7d FG	215	pub struct InvalidAsmTemplateModifierRegClass {
f2b60f7d FG	216	#[primary_span]
2b03887a	217	#[label(ast_lowering_template_modifier)]
f2b60f7d	218	pub placeholder_span: Span,
2b03887a	219	#[label(ast_lowering_argument)]
f2b60f7d FG	220	pub op_span: Span,
	221	#[subdiagnostic]
	222	pub sub: InvalidAsmTemplateModifierRegClassSub,
	223	}
	224
2b03887a	225	#[derive(Subdiagnostic)]
f2b60f7d	226	pub enum InvalidAsmTemplateModifierRegClassSub {
2b03887a	227	#[note(ast_lowering_support_modifiers)]
f2b60f7d	228	SupportModifier { class_name: Symbol, modifiers: String },
2b03887a	229	#[note(ast_lowering_does_not_support_modifiers)]
f2b60f7d FG	230	DoesNotSupportModifier { class_name: Symbol },
	231	}
	232
2b03887a FG	233	#[derive(Diagnostic, Clone, Copy)]
2b03887a FG	234	#[diag(ast_lowering_invalid_asm_template_modifier_const)]
f2b60f7d FG	235	pub struct InvalidAsmTemplateModifierConst {
f2b60f7d FG	236	#[primary_span]
2b03887a	237	#[label(ast_lowering_template_modifier)]
f2b60f7d	238	pub placeholder_span: Span,
2b03887a	239	#[label(ast_lowering_argument)]
f2b60f7d FG	240	pub op_span: Span,
	241	}
	242
2b03887a FG	243	#[derive(Diagnostic, Clone, Copy)]
2b03887a FG	244	#[diag(ast_lowering_invalid_asm_template_modifier_sym)]
f2b60f7d FG	245	pub struct InvalidAsmTemplateModifierSym {
f2b60f7d FG	246	#[primary_span]
2b03887a	247	#[label(ast_lowering_template_modifier)]
f2b60f7d	248	pub placeholder_span: Span,
2b03887a	249	#[label(ast_lowering_argument)]
f2b60f7d FG	250	pub op_span: Span,
	251	}
	252
2b03887a FG	253	#[derive(Diagnostic, Clone, Copy)]
2b03887a FG	254	#[diag(ast_lowering_register_class_only_clobber)]
f2b60f7d FG	255	pub struct RegisterClassOnlyClobber {
	256	#[primary_span]
	257	pub op_span: Span,
	258	pub reg_class_name: Symbol,
	259	}
	260
2b03887a FG	261	#[derive(Diagnostic, Clone, Copy)]
2b03887a FG	262	#[diag(ast_lowering_register_conflict)]
f2b60f7d FG	263	pub struct RegisterConflict<'a> {
f2b60f7d FG	264	#[primary_span]
2b03887a	265	#[label(ast_lowering_register1)]
f2b60f7d	266	pub op_span1: Span,
2b03887a	267	#[label(ast_lowering_register2)]
f2b60f7d FG	268	pub op_span2: Span,
	269	pub reg1_name: &'a str,
	270	pub reg2_name: &'a str,
	271	#[help]
	272	pub in_out: Option<Span>,
	273	}
	274
2b03887a	275	#[derive(Diagnostic, Clone, Copy)]
f2b60f7d	276	#[help]
2b03887a	277	#[diag(ast_lowering_sub_tuple_binding)]
f2b60f7d FG	278	pub struct SubTupleBinding<'a> {
	279	#[primary_span]
	280	#[label]
487cf647	281	#[suggestion(
2b03887a	282	ast_lowering_sub_tuple_binding_suggestion,
487cf647	283	style = "verbose",
f2b60f7d FG	284	code = "..",
	285	applicability = "maybe-incorrect"
	286	)]
	287	pub span: Span,
	288	pub ident: Ident,
	289	pub ident_name: Symbol,
	290	pub ctx: &'a str,
	291	}
	292
2b03887a FG	293	#[derive(Diagnostic, Clone, Copy)]
2b03887a FG	294	#[diag(ast_lowering_extra_double_dot)]
f2b60f7d FG	295	pub struct ExtraDoubleDot<'a> {
	296	#[primary_span]
	297	#[label]
	298	pub span: Span,
2b03887a	299	#[label(ast_lowering_previously_used_here)]
f2b60f7d FG	300	pub prev_span: Span,
	301	pub ctx: &'a str,
	302	}
	303
2b03887a	304	#[derive(Diagnostic, Clone, Copy)]
f2b60f7d	305	#[note]
2b03887a	306	#[diag(ast_lowering_misplaced_double_dot)]
f2b60f7d FG	307	pub struct MisplacedDoubleDot {
	308	#[primary_span]
	309	pub span: Span,
	310	}
	311
2b03887a FG	312	#[derive(Diagnostic, Clone, Copy)]
2b03887a FG	313	#[diag(ast_lowering_misplaced_relax_trait_bound)]
f2b60f7d FG	314	pub struct MisplacedRelaxTraitBound {
	315	#[primary_span]
	316	pub span: Span,
	317	}
	318
2b03887a FG	319	#[derive(Diagnostic, Clone, Copy)]
2b03887a FG	320	#[diag(ast_lowering_not_supported_for_lifetime_binder_async_closure)]
f2b60f7d FG	321	pub struct NotSupportedForLifetimeBinderAsyncClosure {
	322	#[primary_span]
	323	pub span: Span,
	324	}
	325
2b03887a FG	326	#[derive(Diagnostic, Clone, Copy)]
2b03887a FG	327	#[diag(ast_lowering_arbitrary_expression_in_pattern)]
f2b60f7d FG	328	pub struct ArbitraryExpressionInPattern {
	329	#[primary_span]
	330	pub span: Span,
	331	}
	332
2b03887a FG	333	#[derive(Diagnostic, Clone, Copy)]
2b03887a FG	334	#[diag(ast_lowering_inclusive_range_with_no_end)]
f2b60f7d FG	335	pub struct InclusiveRangeWithNoEnd {
	336	#[primary_span]
	337	pub span: Span,
	338	}
	339
2b03887a FG	340	#[derive(Diagnostic, Clone, Copy)]
2b03887a FG	341	#[diag(ast_lowering_trait_fn_async, code = "E0706")]
f2b60f7d	342	#[note]
9ffffee4	343	#[note(ast_lowering_note2)]
f2b60f7d FG	344	pub struct TraitFnAsync {
	345	#[primary_span]
	346	pub fn_span: Span,
	347	#[label]
	348	pub span: Span,
	349	}
353b0b11 FG	350
	351	#[derive(Diagnostic)]
	352	pub enum BadReturnTypeNotation {
	353	#[diag(ast_lowering_bad_return_type_notation_inputs)]
	354	Inputs {
	355	#[primary_span]
	356	#[suggestion(code = "()", applicability = "maybe-incorrect")]
	357	span: Span,
	358	},
	359	#[diag(ast_lowering_bad_return_type_notation_output)]
	360	Output {
	361	#[primary_span]
	362	#[suggestion(code = "", applicability = "maybe-incorrect")]
	363	span: Span,
	364	},
	365	}