about summary refs log tree commit diff
path: root/compiler/rustc_builtin_macros/src/deriving
AgeCommit message (Collapse)AuthorLines
2023-12-24Remove `ExtCtxt` methods that duplicate `DiagCtxt` methods.Nicholas Nethercote-35/+38
2023-12-20Give `VariantData::Struct` named fields, to clairfy `recovered`.Alona Enraght-Moony-4/+4
2023-12-03Parse a pattern with no armNadrieril-1/+1
2023-11-23Rollup merge of #118131 - lukas-code:multi-default, r=wesleywiserMatthias Krüger-9/+8
improve tool-only help for multiple `#[default]` variants When defining an enum with multiple `#[default]` variants, we emit a tool-only suggestion for every `#[default]`ed variant to remove all other `#[default]`s. This PR improves the suggestion to correctly handle the cases where one variant has multiple `#[default]`s and where different `#[default]`s have the same span due to macro expansions. fixes https://github.com/rust-lang/rust/issues/118119
2023-11-21Fix `clippy::needless_borrow` in the compilerNilstrieb-4/+4
`x clippy compiler -Aclippy::all -Wclippy::needless_borrow --fix`. Then I had to remove a few unnecessary parens and muts that were exposed now.
2023-11-21improve help for multiple `#[default]` variantsLukas Markeffsky-9/+8
2023-11-09Emit #[inline] on derive(Debug)Ben Kimock-1/+1
2023-11-02Minimize `pub` usage in `source_map.rs`.Nicholas Nethercote-1/+2
Most notably, this commit changes the `pub use crate::*;` in that file to `use crate::*;`. This requires a lot of `use` items in other crates to be adjusted, because everything defined within `rustc_span::*` was also available via `rustc_span::source_map::*`, which is bizarre. The commit also removes `SourceMap::span_to_relative_line_string`, which is unused.
2023-10-25Auto merge of #116236 - dtolnay:builtinmacrocomment, r=cjgillotbors-94/+112
Modernize rustc_builtin_macros generics helpers - Rustfmt-compatible formatting for the code snippets in comments - Eliminate an _"Extra scope required"_ obsoleted by NLL
2023-10-22Directly collect into ty_param_names instead of peeking to see if emptyDavid Tolnay-6/+4
2023-10-22Eliminate an "Extra scope required" obsoleted by NLLDavid Tolnay-55/+51
2023-10-22Rustfmt-compatible formatting for code snippets in rustc_builtin_macrosDavid Tolnay-40/+64
2023-10-13Format all the let chains in compilerMichael Goulet-25/+34
2023-09-24ConstParamTy: require EqRalf Jung-1/+1
2023-09-18Rollup merge of #115891 - RalfJung:structural-trait-derive, r=nnethercoteMatthias Krüger-114/+42
simplify inject_impl_of_structural_trait There's a comment at `inject_impl_of_structural_trait` saying we cannot use `TraitDef`, but that comment is outdated -- we *can* use `TraitDef` nowadays since it has the `skip_path_as_bound` flag. (The flag needed some fixing, though.)
2023-09-18simplify inject_impl_of_structural_traitRalf Jung-114/+42
2023-09-16Fix invalid markdown codeblock labelGuillaume Gomez-6/+6
2023-09-08Rework no_coverage to coverage(off)Andy Caldwell-1/+1
2023-07-30inline format!() args up to and including rustc_middleMatthias Krüger-11/+10
2023-07-16Add a comparison between match *self and intrinsics::unreachable()David Tolnay-2/+3
2023-07-16Generate safe stable code for derives on empty enumsDavid Tolnay-4/+13
Generate `match *self {}` instead of `unsafe { core::intrinsics::unreachable() }`. This is: 1. safe 2. stable for the benefit of everyone looking at these derived impls through `cargo expand`. Both expansions compile to the same code at all optimization levels (including `0`).
2023-07-12Re-format let-else per rustfmt updateMark Rousskov-4/+4
2023-05-26Avoid some unnecessary local `attr` variables.Nicholas Nethercote-19/+11
2023-05-26Inline derived `hash` function.Nicholas Nethercote-2/+3
Because most of the other derived functions are inlined: `clone`, `default`, `eq`, `partial_cmp`, `cmp`. The exception is `fmt`, but it tends to not be on hot paths as much.
2023-05-18Rollup merge of #111633 - nnethercote:avoid-ref-format, r=WaffleLapkinDylan DPC-5/+5
Avoid `&format("...")` calls in error message code. Some error message cleanups. Best reviewed one commit at a time. r? `@davidtwco`
2023-05-16Add derive for `core::marker::ConstParamTy`Nilstrieb-0/+23
This makes it easier to implement it for a type, just like `Copy`.
2023-05-16Avoid `&format("...")` calls in error message code.Nicholas Nethercote-5/+5
Error message all end up passing into a function as an `impl Into<{D,Subd}iagnosticMessage>`. If an error message is creatd as `&format("...")` that means we allocate a string (in the `format!` call), then take a reference, and then clone (allocating again) the reference to produce the `{D,Subd}iagnosticMessage`, which is silly. This commit removes the leading `&` from a lot of these cases. This means the original `String` is moved into the `{D,Subd}iagnosticMessage`, avoiding the double allocations. This requires changing some function argument types from `&str` to `String` (when all arguments are `String`) or `impl Into<{D,Subd}iagnosticMessage>` (when some arguments are `String` and some are `&str`).
2023-05-07enable `rust_2018_idioms` for doctestsozkanonur-1/+1
Signed-off-by: ozkanonur <work@onurozkan.dev>
2023-04-10Migrate most of `rustc_builtin_macros` to diagnostic implsclubby789-82/+48
Co-authored-by: Joe ST <joe@fbstj.net> Co-authored-by: Michael Goulet <michael@errs.io>
2023-03-22rustc: Remove unused `Session` argument from some attribute functionsVadim Petrochenkov-6/+6
2023-03-11Address the new odd backticks tidy lint in compiler/est31-0/+1
2023-02-21Use `ThinVec` in a few more AST types.Nicholas Nethercote-1/+1
2023-02-21Use `ThinVec` in `ast::ExprKind::Match`.Nicholas Nethercote-5/+5
2023-02-21Use `ThinVec` in `ast::PatKind::Struct`.Nicholas Nethercote-2/+2
2023-02-21Use `ThinVec` in `ast::Block`.Nicholas Nethercote-21/+21
2023-02-21Use `ThinVec` in various AST types.Nicholas Nethercote-42/+47
This commit changes the sequence parsers to produce `ThinVec`, which triggers numerous conversions.
2023-02-21Use `ThinVec` in `ast::Impl` and related types.Nicholas Nethercote-1/+2
2023-02-21Use `ThinVec` in `ast::WhereClause`.Nicholas Nethercote-1/+6
2023-02-21Use `ThinVec` in `ast::Generics` and related types.Nicholas Nethercote-5/+5
2023-02-19Auto merge of #108128 - clubby789:builtin-derived-attr, r=jackh726bors-2/+1
Properly check for builtin derived code Fixes #108122
2023-02-16Properly check for builtin derivesclubby789-2/+1
2023-02-16`if $c:expr { Some($r:expr) } else { None }` =>> `$c.then(|| $r)`Maybe Waffle-11/+7
2023-02-09Extend `BYTE_SLICE_IN_PACKED_STRUCT_WITH_DERIVE`.Nicholas Nethercote-20/+35
To temporarily allow a `str` field in a packed struct using `derive`, along with `[u8]`.
2023-02-07Add ~const bounds trait bounds when using derive_constMichael Goulet-10/+27
2023-02-02Don't generate unecessary `&&self.field` in deriving Debugclubby789-5/+20
2023-02-01Fix syntax in `-Zunpretty-expanded` output for derived `PartialEq`.Nicholas Nethercote-5/+19
If you do `derive(PartialEq)` on a packed struct, the output shown by `-Zunpretty=expanded` includes expressions like this: ``` { self.x } == { other.x } ``` This is invalid syntax. This doesn't break compilation, because the AST nodes are constructed within the compiler. But it does mean anyone using `-Zunpretty=expanded` output as a guide for hand-written impls could get a nasty surprise. This commit fixes things by instead using this form: ``` ({ self.x }) == ({ other.x }) ```
2023-01-30Allow more deriving on packed structs.Nicholas Nethercote-48/+98
Currently, deriving on packed structs has some non-trivial limitations, related to the fact that taking references on unaligned fields is UB. The current approach to field accesses in derived code: - Normal case: `&self.0` - In a packed struct that derives `Copy`: `&{self.0}` - In a packed struct that doesn't derive `Copy`: `&self.0` Plus, we disallow deriving any builtin traits other than `Default` for any packed generic type, because it's possible that there might be misaligned fields. This is a fairly broad restriction. Plus, we disallow deriving any builtin traits other than `Default` for most packed types that don't derive `Copy`. (The exceptions are those where the alignments inherently satisfy the packing, e.g. in a type with `repr(packed(N))` where all the fields have alignments of `N` or less anyway. Such types are pretty strange, because the `packed` attribute is not having any effect.) This commit introduces a new, simpler approach to field accesses: - Normal case: `&self.0` - In a packed struct: `&{self.0}` In the latter case, this requires that all fields impl `Copy`, which is a new restriction. This means that the following example compiles under the old approach and doesn't compile under the new approach. ``` #[derive(Debug)] struct NonCopy(u8); #[derive(Debug) #[repr(packed)] struct MyType(NonCopy); ``` (Note that the old approach's support for cases like this was brittle. Changing the `u8` to a `u16` would be enough to stop it working. So not much capability is lost here.) However, the other constraints from the old rules are removed. We can now derive builtin traits for packed generic structs like this: ``` trait Trait { type A; } #[derive(Hash)] #[repr(packed)] pub struct Foo<T: Trait>(T, T::A); ``` To allow this, we add a `T: Copy` bound in the derived impl and a `T::A: Copy` bound in where clauses. So `T` and `T::A` must impl `Copy`. We can now also derive builtin traits for packed structs that don't derive `Copy`, so long as the fields impl `Copy`: ``` #[derive(Hash)] #[repr(packed)] pub struct Foo(u32); ``` This includes types that hand-impl `Copy` rather than deriving it, such as the following, that show up in winapi-0.2: ``` #[derive(Clone)] #[repr(packed)] struct MyType(i32); impl Copy for MyType {} ``` The new approach is simpler to understand and implement, and it avoids the need for the `unsafe_derive_on_repr_packed` check. One exception is required for backwards-compatibility: we allow `[u8]` fields for now. There is a new lint for this, `byte_slice_in_packed_struct_with_derive`.
2023-01-28Auto merge of #103659 - clubby789:improve-partialord-derive, r=nagisabors-9/+73
Special-case deriving `PartialOrd` for enums with dataless variants I was able to get slightly better codegen by flipping the derived `PartialOrd` logic for two-variant enums. I also tried to document the implementation of the derive macro to make the special-case logic a little clearer. ```rs #[derive(PartialEq, PartialOrd)] pub enum A<T> { A, B(T) } ``` ```diff impl<T: ::core::cmp::PartialOrd> ::core::cmp::PartialOrd for A<T> { #[inline] fn partial_cmp( &self, other: &A<T>, ) -> ::core::option::Option<::core::cmp::Ordering> { let __self_tag = ::core::intrinsics::discriminant_value(self); let __arg1_tag = ::core::intrinsics::discriminant_value(other); - match ::core::cmp::PartialOrd::partial_cmp(&__self_tag, &__arg1_tag) { - ::core::option::Option::Some(::core::cmp::Ordering::Equal) => { - match (self, other) { - (A::B(__self_0), A::B(__arg1_0)) => { - ::core::cmp::PartialOrd::partial_cmp(__self_0, __arg1_0) - } - _ => ::core::option::Option::Some(::core::cmp::Ordering::Equal), - } + match (self, other) { + (A::B(__self_0), A::B(__arg1_0)) => { + ::core::cmp::PartialOrd::partial_cmp(__self_0, __arg1_0) } - cmp => cmp, + _ => ::core::cmp::PartialOrd::partial_cmp(&__self_tag, &__arg1_tag), } } } ``` Godbolt: [Current](https://godbolt.org/z/GYjEzG1T8), [New](https://godbolt.org/z/GoK78qx15) I'm not sure how common a case comparing two enums like this (such as `Option`) is, and if it's worth the slowdown of adding a special case to the derive. If it causes overall regressions it might be worth just manually implementing this for `Option`.
2023-01-21Auto merge of #106884 - clubby789:fieldless-enum-debug, r=michaelwoeristerbors-42/+124
Simplify `derive(Debug)` output for fieldless enums Fixes #106875
2023-01-19Special case `derive(Debug)` for fieldless enumsclubby789-2/+49
generated by cgit-pink 1.4.1-3-g733a5 (git 2.37.1) at 2026-07-14 06:09:42 +0000