Jakub/pac ty disc by jchlanda · Pull Request #2 · jchlanda/rust

jchlanda · 2026-07-06T10:38:55Z

No description provided.

Signed-off-by: Amirhossein Akhlaghpour <m9.akhlaghpoor@gmail.com>

The macro is used in expressions, but the arm for eliminating a trailing comma introduces a semicolon.

``` error: lifetime may not live long enough --> $DIR/higher-ranked-return.rs:11:46 | LL | let x = async move |x: &str| -> &str { | ________________________________-________-____^ | | | | | | | let's call the lifetime of this reference `'2` | | let's call the lifetime of this reference `'1` LL | | x LL | | }; | |_________^ returning this value requires that `'1` must outlive `'2` ``` instead of ``` error: lifetime may not live long enough --> $DIR/higher-ranked-return.rs:11:46 | LL | let x = async move |x: &str| -> &str { | ________________________________-________----_^ | | | | | | | return type of async closure `{async closure body@$DIR/higher-ranked-return.rs:11:46: 13:10}` contains a lifetime `'2` | | let's call the lifetime of this reference `'1` LL | | x LL | | }; | |_________^ returning this value requires that `'1` must outlive `'2` ```

This optimisation is currently broken on s390x[^1]. It looks like a big-endian issue in general. but as we only know about the test fails on s390x we only disable it there. Should be reenabled when the problem is fixed and llvm backend is updated. [^1]: llvm/llvm-project#208712

@Kobzol

emit `(lldb)` prefix to make commands more distinct As discussed in rust-lang#158298 r? @Kobzol, @jieyouxu

…nathanBrouwer Rollup of 18 pull requests Successful merges: - rust-lang#150679 (dirfd file operations (2/4)) - rust-lang#158758 (Rename `lazy_type_alias` feature gate to `checked_type_aliases` ) - rust-lang#159177 (Explicitly materialize debuginfo tests for all debuggers) - rust-lang#159392 (Update Rust crate rand to v0.9.3 [SECURITY]) - rust-lang#159393 (Update Rust crate rkyv to v0.8.16 [SECURITY]) - rust-lang#159394 (Update Rust crate tar to v0.4.46 [SECURITY]) - rust-lang#159395 (Update Rust crate tracing-subscriber [SECURITY]) - rust-lang#159193 (Port compiletest's CLI to clap) - rust-lang#158992 (Shorten types more when only interesting part is lifetimes) - rust-lang#159226 (Track extra_lifetime_params_map per-owner) - rust-lang#159273 (tidy: document u64 limit for numeric sort keys) - rust-lang#159322 (Fix safety doc in intrinsics::simd) - rust-lang#159329 (Fix the stale metrics directory warning) - rust-lang#159357 (Add regression tests for two fixed issues) - rust-lang#159360 (Remove FIXMEs referencing rust-lang#44232) - rust-lang#159375 (make a couple codegen-llvm tests compatible with 2021 edition) - rust-lang#159381 (emit `(lldb)` prefix to make commands more distinct) - rust-lang#159396 (Update actions/checkout action to v7)

@oli-obk

…r=WaffleLapkin interpret: properly check for inhabitedness of nested references This implements the opsem from the ongoing FCP in rust-lang/unsafe-code-guidelines#413. The bit we were previously missing is that transmuting a `&&!` into existence was not caught as being immediate UB -- only the `&!` case behaved as expected. I did not adjust the layout computation because when we compute the layout of `&T`, we cannot know the layout of `T` (as that might be recursive). r? @oli-obk

Alongside Rust implementation of LLVM's SipHash-2-4.

This is only to be used when emitting an operand bundle, which might not have access to an Instance of the function, but for which FnAbi is guaranteed to be correct.

Start moving away from global schema, by cloning it into users. Helpers for fn ptr type discrimination status and value of the key.

This is a move away from a blind bitcast between the types. Now, when dealing with function pointers, transmute will detect a domain change (change of fn ptr type) and issue resigning.

…r` call sites

As the libc changes was merged in to the main we do not need to patch it. cc-rs still needs to be patched as compiler/rustc_llvm/Cargo.toml still pins to an old version: cc = "=1.2.16"

…tors

…g get_fn_addr call sites

… handling

@oli-obk

codegen: skip stores for entirely-uninit constant aggregate fields, attempt #2 This reverts both rust-lang#159825 and rust-lang#157797, and goes back to the original fix from rust-lang#157797, albeit with a small refactor to share code between the now three branches that do the same check. This preserves the original issue (rust-lang#157743) in a fixed state, but avoids the whack-a-mole the initially landed attempt created. Fixes: rust-lang#159867 r? @oli-obk

@lapla-cogito

…er_types, r=BoxyUwU fix ICE in generic_const_parameter_types with inherents tracking issue: rust-lang#137626 relevant PR where the code was added: rust-lang#154853 (fyi ping @lapla-cogito - nws that this was buggy, it's extreeeemely subtle and easy to miss! ❤️ I mean, I also reviewed that PR and missed it too :3 ) discovered when implementing a change that explicitly tracks whether the args for inherent associated consts are in "self form" or "impl form" Following along the test case: - `normalize_canonicalized_inherent_projection` is called with `AliasTermKind::InherentConst` with the generic args being in "self form", i.e. `[ThreeTypes<u8, u16, u32>]` - `traits::normalize_inherent_projection` is called with said alias - it calls `compute_inherent_assoc_term_args`, which does the dance of generating fresh vars for each param in the impl block, equating with the self type, and returning what the fresh vars solved to. This converts from "self args" to "impl args", i.e. `[u8, u16, u32]` - it then calls `const_of_item` and instantiates with `[u8, u16, u32]`. this is correct and good, `const_of_item` expects "impl form" args. - it then calls `push_const_arg_has_type_obligation` - which calls `type_of` and instantiates with `[u8, u16, u32]` to fetch the type of the const, to be able to register a `ConstArgHasType`. this is correct and good, `type_of` expects "impl form" args. - `traits::normalize_inherent_projection` returns, dropping the impl form args it computed - `normalize_canonicalized_inherent_projection` calls `ocx.register_obligations(const_arg_has_type_obligation(...))`, passing `goal`. Remember that `goal` has the original "self args" generic arg format. - `const_arg_has_type_obligation` calls `type_of` and instantiates with `[ThreeTypes<u8, u16, u32>]`. This is no good very bad!! `type_of` expects "impl form" args, not "self form"!! - ICE!! `type parameter T3/#2 (T3/#2/2) out of range when instantiating, args=[ThreeTypes<u8, u16, u32>]` The reason I filed this under `feature(generic_const_parameter_types)` is because for this bug to manifest, `type_of` must return a type that actually references a generic param to be able to trigger an ICE. Otherwise, the buggy incorrect args are silently ignored and compilation continues "fine". The fix: `normalize_inherent_projection` already registers a `ConstArgHasType`. why are we doing it a second time. just delete it. 💀 r? @BoxyUwU

@petrochenkov

…ods, r=petrochenkov delegation: supporting inherent impls This PR adds support for delegation to inherent impl functions on the delegation side. Support for inherent impls in delegation consists of two problems: we need to resolve inherent function through `ProbeContext` routine and then we need to generate delegation function knowing the `DefId` of the signature function. The first problem is a fundamental problem given current compiler architecture, and it is not solved in this PR. To imitate working resolution for tests we adopt simple resolution by name only in inherent impls (not trait impls, which would work if we implement fair resolution through `ProbeContext`). A `resolve_type_relative_delegations` query was created which tries to resolve unresolved delegations after resolve stage. In future, when we will be able to fairly resolve delegations through `ProbeContext` contents of this query can be changed and all other logic implemented in this pull request will work. ## Free to inherent impl Unlike free to trait delegation where we generated explicit `Self` param, here we just use default parameter. ```rust struct X<'a, T, const B: bool>(...); impl<'a, T, const B: bool> X<'a, T, B> { fn foo<'b, U, const X: usize>(&self) { ... } } reuse X::<'static, (), false>::foo as foo1; reuse X::<'static, (), false,>::foo::<'static, (), 123> as foo3; //Desugaring: #[attr = Inline(Hint)] fn foo1<'b, U, const X: _>(self: _) -> _ where 'b:'b { X<'static, (), false>::foo::<'b, U, X>(self) } #[attr = Inline(Hint)] fn foo3(self: _) -> _ { X<'static, (), false>::foo::<'static, (), 123>(self) } ``` ## Trait to inherent impl In trait to inherent impl delegation we replace the type of self parameter from impl's type to `Self` generic param (if the signature function is a method). ```rust trait Trait { reuse X::<'static, (), false>::foo as foo1; reuse X::<'static, (), false,>::foo::<'static, (), true> as foo3; } // Desugaring: trait Trait { #[attr = Inline(Hint)] fn foo1<'b, U, const X: _>(self: _) -> _ where 'b:'b { X<'static, (), false>::foo::<'b, U, X>(self) } #[attr = Inline(Hint)] fn foo3(self: _) -> _ { X<'static, (), false>::foo::<'static, (), 123>(self) } } ``` Note that we didn't specified target expression, so we would get errors like: ```rust error[E0308]: mismatched types --> $DIR/xd.rs:10:14 | LL | trait Trait { | ----------- found this type parameter LL | reuse X::foo; | ^^^ | | | expected `&X<'_, T, B>`, found `&Self` | arguments to this function are incorrect | = note: expected reference `&X<'_, T, B>` found reference `&Self` ``` ## Trait impl to inherent impl Here the resolution should look signature in trait as in other cases where we delegate from trait impl. We generate function whose signature matches the resolved function in trait. We propagate only child generics if they are not specified. ```rust trait Trait { fn foo<A, B, C>(&self) { } fn foo1<T, U, V>(&self) { } fn foo2<'a, T, U, V>(&self) where 'a:'a { } fn foo3(&self) { } } impl Trait for X { reuse X::<'static, (), false>::foo as foo1; reuse X::<'static, (), false,>::foo::<'static, (), 123> as foo3; } // Desugaring: impl Trait for X<'_> { #[attr = Inline(Hint)] fn foo1<T, U, V>(self: _) -> _ { X<'static, (), false>::foo::<T, U, V>(self) } #[attr = Inline(Hint)] fn foo3(self: _) -> _ { X<'static, (), false>::foo::<'static, (), 123>(self) } } ``` ## Inherent impl to inherent impl In inherent impl to inherent impl delegation we replace signature self type with delegation parent self type in case of methods. ```rust trait Trait { fn foo<A, B, C>(&self) { } fn foo1<T, U, V>(&self) { } fn foo2<'a, T, U, V>(&self) where 'a:'a { } fn foo3(&self) { } } struct Y; impl Trait for Y { reuse X::<'static, (), false>::foo as foo1; reuse X::<'static, (), false,>::foo::<'static, (), 123> as foo3; } impl Trait for Y { #[attr = Inline(Hint)] fn foo1<T, U, V>(self: _) -> _ { X<'static, (), false>::foo::<T, U, V>(self) } #[attr = Inline(Hint)] fn foo3(self: _) -> _ { X<'static, (), false>::foo::<'static, (), 123>(self) } } ``` We did not specify target expression so we would get errors like: ```rust error[E0308]: mismatched types --> $DIR/xd.rs:12:14 | LL | reuse X::foo; | ^^^ | | | expected `&X<'_, T, B>`, found `Y` | arguments to this function are incorrect | = note: expected reference `&X<'_, T, B>` found struct `Y` ``` ## Generics After some experiments I think that we should force user to always specify generics for parent segment of delegation to inherent impls. Consider the following example and imagine that we can use fair resolution through `ProbeContext`: ```rust trait M1 {} trait M2 {} struct S1; struct S2; impl M1 for S1 {} impl M2 for S2 {} struct X<T, U>(T, U); impl<T: M1> X<T, ()> { fn foo() {} } impl<T: M2> X<T, usize> { fn foo() {} } reuse X::foo; ``` How to resolve `X::foo`? If we generate parent generics (`fn foo<T, U>() { X::<T, U>::foo() }`) which clauses should we inherit? It is impossible to determine which function to reuse, and despite the fact that there may be some cases where it is possible, I don't think that we should write heuristics for that. So always specifying parent generics seems to be a good option. Also I think we should ban infers in parent segment too. One implementation aspect of how we map generic args for signature and predicates inheritance, as we inherit predicates not from the ADT declaration but from the impl block we need to take generic args from this impl, not from the declaration. So indices of generic args are taken from the impl block and then they are used in mapping and future instantiation: ```rust struct S<'a, A, const C: usize> { xd: &'a [A; C], } // index of A = 3 // index of C = 4 impl<'a, 'b, 'c, A, const C: usize> S<A, C> { fn foo_self<'d: 'd, 'e, T, const B: bool>(self) {} } trait Trait<'a, AA, BB> where Self: Sized { reuse S::<(), ()>::foo_self; // Args: [Self/#0, 'a/#1, AA/#2, BB/#3, '{region error}, 'd/rust-lang#4, (), {const error}, T/rust-lang#5, B/rust-lang#6] // Mapping: {0: 0, 7: 9, 5: 5, 3: 6, 6: 8, 4: 7}, A (index 3) is mapped into index 6 (`()`), C (index 4) mapped into index 7 (const error) } ``` ## Other concerns ### Glob and list delegations List delegations are supported, glob delegations are not supported: ```rust struct X; impl X { fn foo(&self) {} fn foo2(&self) {} } struct Y; impl Y { reuse X::{foo, foo2} { X } } impl Y { reuse X::*; //~^ ERROR: expected trait, found struct `X` } ``` ### Self type adjustments and target expression deletion Adjustments for receiver are applied, adjustments for other parameters whose types contain `Self` are not applied as `Self` acts as a type alias to the struct, not a generic param which will can get replaced. The deletion of target expression should work as before. ```rust enum X { ... } impl X { fn static_f() {} fn by_value(self) {} fn by_ref(&self) {} fn by_mut_ref(&mut self) {} } struct Y; impl Y { fn get_x(&self) -> X { X } reuse X::{static_f, by_value, by_ref, by_mut_ref} { self.get_x() } } impl Y { fn get_x(&self) -> X { X } #[attr = Inline(Hint)] fn static_f() -> _ { X::static_f() } #[attr = Inline(Hint)] fn by_value(self: _) -> _ { X::by_value(self.get_x()) } #[attr = Inline(Hint)] fn by_ref(self: _) -> _ { X::by_ref(self.get_x()) } #[attr = Inline(Hint)] fn by_mut_ref(self: _) -> _ { X::by_mut_ref(self.get_x()) } } fn main() { let y = Y; y.by_ref(); y.by_mut_ref(); //~^ ERROR: cannot borrow `y` as mutable, as it is not declared as mutable y.by_value(); let y = &Y; y.by_value(); //~^ ERROR: cannot move out of `*y` which is behind a shared reference y.by_ref(); y.by_mut_ref(); //~^ ERROR: cannot borrow `*y` as mutable, as it is behind a `&` reference let y = &mut Y; y.by_value(); //~^ ERROR: cannot move out of `*y` which is behind a mutable reference y.by_ref(); y.by_mut_ref(); } ``` ### Recursive delegations Works as before, we just check the resolution chain and we do not care whether it came from resolution at resolve stage or from resolution of type relative delegations. r? @petrochenkov

jchlanda marked this pull request as draft July 6, 2026 10:39

jchlanda force-pushed the jakub/pac_config branch from 1c82b8f to cf64be8 Compare July 7, 2026 08:05

jchlanda force-pushed the jakub/pac_ty_disc branch from f8b5f7b to 79d7f97 Compare July 8, 2026 12:12

jchlanda force-pushed the jakub/pac_config branch 3 times, most recently from 24bde9f to 809c245 Compare July 9, 2026 11:37

jchlanda force-pushed the jakub/pac_ty_disc branch 6 times, most recently from 5b7b3bd to f3316ab Compare July 9, 2026 14:59

jchlanda force-pushed the jakub/pac_config branch from 809c245 to 7e15238 Compare July 13, 2026 08:18

jchlanda force-pushed the jakub/pac_ty_disc branch from f3316ab to 927c43e Compare July 13, 2026 09:28

Dnreikronos and others added 16 commits July 13, 2026 11:46

Reject invalid direct_const_arg nested owners

e94c0e6

Add regression test for issue 95719

8583c9a

chore: add codegen test for remainder match

d376c08

Signed-off-by: Amirhossein Akhlaghpour <m9.akhlaghpoor@gmail.com>

inline Once wait and wait_force

09882ef

Bump rustc-perf submodule

9561a52

std_detect: Eliminate incorrect symlink in macro arm

aa53fee

The macro is used in expressions, but the arm for eliminating a trailing comma introduces a semicolon.

Replace shortened type with _ instead of ... as placeholder

5f35fc8

Add regression test for issue 144033

8e12609

Skip intrinsic-test when rustfmt is unavailable

bf52201

Simplify regression test for issue 144033

f3f4235

Add regression test

ca15064

Add regression test

5b3e95d

Update tidy licenses

edbbeae

Only force backtraces when a panic occurs in bootstrap

9aa459e

JonathanBrouwer and others added 26 commits July 16, 2026 21:01

Rollup merge of rust-lang#159381 - Walnut356:cmd_prefix, r=Kobzol

72062cf

emit `(lldb)` prefix to make commands more distinct As discussed in rust-lang#158298 r? @Kobzol, @jieyouxu

Teach builder how to issue llvm.ptrauth.resign

933b982

Introduce function pointer type encoder

981d41b

Alongside Rust implementation of LLVM's SipHash-2-4.

Extend FnAbi to hold type_discriminator

4a7c9dd

This is only to be used when emitting an operand bundle, which might not have access to an Instance of the function, but for which FnAbi is guaranteed to be correct.

Add FPTR_TYPE_DISCR to the supported set of features

976ef7e

Start moving away from global schema, by cloning it into users. Helpers for fn ptr type discrimination status and value of the key.

Teach static initializer how to handle fn ptr discriminators

dca628f

Extend transmute to handle fn ptr discriminators

18fcf86

This is a move away from a blind bitcast between the types. Now, when dealing with function pointers, transmute will detect a domain change (change of fn ptr type) and issue resigning.

Extend minicore with items required by fn ptr ty discriminator tests

1bf9879

Add fn ptr type discrimination tests

4daa841

Update SIMD vector encoding and extend the testing for it

779ed32

Init/fini entries don't participate in fn ty discrimination

dacec7c

Unify creation of discrimination data and fill in missing `get_fn_add…

024f26a

…r` call sites

Update the main document with changes to [patch] section

67b93c1

As the libc changes was merged in to the main we do not need to patch it. cc-rs still needs to be patched as compiler/rustc_llvm/Cargo.toml still pins to an old version: cc = "=1.2.16"

Adapt tests to // ignore-tidy-file-linelength directive

7aeb893

PR feedback: Introduce function pointer type encoder

d571964

PR feedback: Extend FnAbi to hold type_discriminator

7134f59

PR feedback: Teach static initializer how to handle fn ptr discrimina…

911b2b4

…tors

PR feedback: Unify creation of discrimination data and fill in missin…

eb16c2d

…g get_fn_addr call sites

PR feedback: Extend transmute to handle fn ptr discriminators

7bd76dd

PR feedback: Unify creation of discrimination data and fill in missing

cfe92fc

PR feedback: Encoder

f9b08db

PR Feedback: To Encoder - Retire Complex

54893fd

PR Feedback: To Encoder - Treat data pointer the same as fn in Option…

cff5996

… handling

jchlanda force-pushed the jakub/pac_ty_disc branch from c224581 to cff5996 Compare July 17, 2026 06:56

Navigation Menu

Jakub/pac ty disc - #2

Jakub/pac ty disc#2
jchlanda wants to merge 308 commits into
jakub/pac_configfrom
jakub/pac_ty_disc

jchlanda commented Jul 6, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

20 participants

Conversation

jchlanda commented Jul 6, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

20 participants