profile
viewpoint
lcnr lcnr Germany NaCl (they/them)

lcnr/crow 94

A simple pixel perfect 2D rendering engine

lcnr/akari 35

A showcase game for the crow rendering engine

distransient/gmtk2019 5

"Only One"

lcnr/computer 3

A simple computer made from scratch

lcnr/binary 1

Efficient type based integers

lcnr/amethyst 0

Data-oriented and data-driven game engine written in Rust

lcnr/arewegameyet 0

The repository for arewegameyet.rs

lcnr/awesome-rust-mentors 0

A list of rust lang mentors tagged by topics of interest

pull request commentrust-lang/rust

Fixed build failure of `rustfmt`

@bors r+ rollup

bishtpawan

comment created time in 2 hours

pull request commentrust-lang/rust

Use `DroplessArena` where we know the type doesn't need drop

might influence perf

@bors try @rust-timer queue

bugadani

comment created time in 2 hours

pull request commentrust-lang/rust

Fixed build failure of `rustfmt`

While it would be nice to get an MVCE here, I think it's fine to merge this as is. @bishtpawan did you test if this is the only ICE when compiling rustfmt? If so, r=me

bishtpawan

comment created time in 2 hours

pull request commentrust-lang/rust

Eliminate some temporary vectors

@bors try @rust-timer queue

bugadani

comment created time in 12 hours

Pull request review commentrust-lang/rust

Eliminate some temporary vectors

 struct FulfillProcessor<'a, 'b, 'tcx> {     register_region_obligations: bool, } -fn mk_pending(os: Vec<PredicateObligation<'tcx>>) -> Vec<PendingPredicateObligation<'tcx>> {+fn mk_pending(os: &[PredicateObligation<'tcx>]) -> Vec<PendingPredicateObligation<'tcx>> {

hmm, I personally think that this is fine, we can always change it to be generic once we need to :thinking: But I also don't think using impl IntoIterator is a big problem here so :shrug:

bugadani

comment created time in 12 hours

PullRequestReviewEvent

issue commentrust-lang/rust

Increasingly slow compilation as more levels of `async` are added in Rust 1.46

To revert this we would have to revert #75443 as that PR caused the perf regression. That PR however is the right thing to do so I don't want to revert that, especially because there is a fairly clean way to fix this.

IMO the way forward here is to do something like #76928 for other affected code paths. I don't have a lot of time at the moment so I don't feel like I have the capacity to look into this without having a self-contained MCVE for the remaining problem.

nicholasbishop

comment created time in 14 hours

delete branch lcnr/rust

delete branch : span-overwrite

delete time in 14 hours

pull request commentrust-lang/rust

Eliminate some temporary vectors

I guess it depends (it always does), but heap allocations are insanely fast nowadays, so unless it happens very frequently it shouldn't matter.

An interesting example here might be #72776 where using a SmallVec quite noticeably worsened perf because SmallVecs indexing is slightly slower than indexing a Vec.

bugadani

comment created time in 14 hours

PullRequestReviewEvent

pull request commentrust-lang/rust

Fixed build failure of `rustfmt`

requires ./x.py fmt.

r? @lcnr

bishtpawan

comment created time in 15 hours

Pull request review commentrust-lang/rust

Eliminate some temporary vectors

 impl<K: DepKind> DepGraph<K> {     pub fn query(&self) -> DepGraphQuery<K> {         let data = self.data.as_ref().unwrap().current.data.lock();         let nodes: Vec<_> = data.iter().map(|n| n.node).collect();-        let mut edges = Vec::new();+        let n_edges = data.iter().map(|d| d.edges.len()).sum::<usize>();+        let mut edges = Vec::with_capacity(n_edges);

I personally think that changes like this make the code less readable and therefore should only be applied if they result in a - hopefully noticable - perf benefit.

bugadani

comment created time in 16 hours

Pull request review commentrust-lang/rust

Eliminate some temporary vectors

 impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {             all_bounds.filter(|p| p.def_id() == stack.obligation.predicate.def_id());          // Keep only those bounds which may apply, and propagate overflow if it occurs.-        let mut param_candidates = vec![];+        let mut param_candidates: SmallVec<[_; 2]> = SmallVec::new();

existing issue, but why are we even using a separate vec here instead of using

        for bound in matching_bounds {
            let wc = self.evaluate_where_clause(stack, bound)?;
            if wc.may_apply() {
                candidates.vec.push(ParamCandidate(bound));
            }
        }
bugadani

comment created time in 15 hours

Pull request review commentrust-lang/rust

Eliminate some temporary vectors

 impl<'a, 'b, 'tcx> FulfillProcessor<'a, 'b, 'tcx> {                 | ty::PredicateAtom::ConstEvaluatable(..)                 | ty::PredicateAtom::ConstEquate(..) => {                     let pred = infcx.replace_bound_vars_with_placeholders(binder);-                    ProcessResult::Changed(mk_pending(vec![-                        obligation.with(pred.to_predicate(self.selcx.tcx())),-                    ]))+                    let v: SmallVec<[_; 1]> =+                        smallvec![obligation.with(pred.to_predicate(self.selcx.tcx()))];+                    ProcessResult::Changed(mk_pending(v))
                    ProcessResult::Changed(mk_pending(
                      [obligation.with(pred.to_predicate(self.selcx.tcx()))].iter().copied()
                    ))

I also think that using a vec here is fine, I don't think that this code is hot enough for this to matter and adding a generic parameter to mk_pending probably increases the emitted llvmir which does not seem like a positive trade to me.

bugadani

comment created time in 15 hours

PullRequestReviewEvent

Pull request review commentrust-lang/rust

Eliminate some temporary vectors

 tracing = "0.1" rustc_span = { path = "../rustc_span" } rustc_ast = { path = "../rustc_ast" } rustc_target = { path = "../rustc_target" }+smallvec = { version = "1.0" }
smallvec = { version = "1" }

The newest version is 1.4.2 and we should try to use the same version for the whole compiler

bugadani

comment created time in 16 hours

Pull request review commentrust-lang/rust

Eliminate some temporary vectors

 impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {             all_bounds.filter(|p| p.def_id() == stack.obligation.predicate.def_id());          // Keep only those bounds which may apply, and propagate overflow if it occurs.-        let mut param_candidates = vec![];+        let mut param_candidates: SmallVec<[_; 2]> = SmallVec::new();

why are we even using a separate vec here instead of using

        for bound in matching_bounds {
            let wc = self.evaluate_where_clause(stack, bound)?;
            if wc.may_apply() {
                candidates.vec.push(ParamCandidate(bound));
            }
        }
bugadani

comment created time in 15 hours

PullRequestReviewEvent

pull request commentrust-lang/rust

always try inlining functions which do not call other functions

@bors try @rust-timer queue exclude=deeply-nested

updated metadata encoding to only use 1 byte

lcnr

comment created time in 18 hours

pull request commentrust-lang/rust

Assert that locals have storage when used

LGTM

r? @jonas-schievink for a final review, am not too familiar with this

tmiasko

comment created time in 18 hours

push eventlcnr/rust

Mark Rousskov

commit sha 05c9c0ee5dcd935f518db151bee2dc88380fb92f

Modify executable checking to be more universal This uses a dummy file to check if the filesystem being used supports the executable bit in general.

view details

dylni

commit sha 1ff7da6551a7cdf6ace2a9d00e92bbab550334ee

Move `slice::check_range` to `RangeBounds`

view details

dylni

commit sha 1095dcab96d524e700b11edf366d45a0fd173fa0

Fix links

view details

dylni

commit sha eb63168e007058dad4af758faf1dca449c049777

Fix doctests

view details

dylni

commit sha f055b0bb0847ecf08fe452a270faae8324b55b05

Rename method to `assert_len`

view details

Camelid

commit sha 549f861f7d53811521cf929cf58fb6828a2a88d9

Use correct article in help message for conversion or cast Before it always used `an`; now it uses the correct article for the type.

view details

Camelid

commit sha 094f14c554c3a1f103a5d6778d4b4e131c297f11

Add article after "to" Also added missing backtick in "you can cast" message.

view details

Camelid

commit sha 8a6831a7fd3fc624643b50f494212e0ceaad3c28

Say "doesn't" instead of "wouldn't" in convert message

view details

Alexander Mols

commit sha 8fe61546696b626ecf68ef838d5d82e393719e80

Use posix_spawn() on unix if program is a path Previously `Command::spawn` would fall back to the non-posix_spawn based implementation if the `PATH` environment variable was possibly changed. On systems with a modern (g)libc `posix_spawn()` can be significantly faster. If program is a path itself the `PATH` environment variable is not used for the lookup and it should be safe to use the `posix_spawnp()` method. [1] We found this, because we have a cli application that effectively runs a lot of subprocesses. It would sometimes noticeably hang while printing output. Profiling showed that the process was spending the majority of time in the kernel's `copy_page_range` function while spawning subprocesses. During this time the process is completely blocked from running, explaining why users were reporting the cli app hanging. Through this we discovered that `std::process::Command` has a fast and slow path for process execution. The fast path is backed by `posix_spawnp()` and the slow path by fork/exec syscalls being called explicitly. Using fork for process creation is supposed to be fast, but it slows down as your process uses more memory. It's not because the kernel copies the actual memory from the parent, but it does need to copy the references to it (see `copy_page_range` above!). We ended up using the slow path, because the command spawn implementation in falls back to the slow path if it suspects the PATH environment variable was changed. Here is a smallish program demonstrating the slowdown before this code change: ``` use std::process::Command; use std::time::Instant; fn main() { let mut args = std::env::args().skip(1); if let Some(size) = args.next() { // Allocate some memory let _xs: Vec<_> = std::iter::repeat(0) .take(size.parse().expect("valid number")) .collect(); let mut command = Command::new("/bin/sh"); command .arg("-c") .arg("echo hello"); if args.next().is_some() { println!("Overriding PATH"); command.env("PATH", std::env::var("PATH").expect("PATH env var")); } let now = Instant::now(); let child = command .spawn() .expect("failed to execute process"); println!("Spawn took: {:?}", now.elapsed()); let output = child.wait_with_output().expect("failed to wait on process"); println!("Output: {:?}", output); } else { eprintln!("Usage: prog [size]"); std::process::exit(1); } () } ``` Running it and passing different amounts of elements to use to allocate memory shows that the time taken for `spawn()` can differ quite significantly. In latter case the `posix_spawnp()` implementation is 30x faster: ``` $ cargo run --release 10000000 ... Spawn took: 324.275µs hello $ cargo run --release 10000000 changepath ... Overriding PATH Spawn took: 2.346809ms hello $ cargo run --release 100000000 ... Spawn took: 387.842µs hello $ cargo run --release 100000000 changepath ... Overriding PATH Spawn took: 13.434677ms hello ``` [1]: https://github.com/bminor/glibc/blob/5f72f9800b250410cad3abfeeb09469ef12b2438/posix/execvpe.c#L81

view details

Bastian Kauschke

commit sha 9c302f55bd07a04305dfa2bd815d2559deb8468f

normalize in codegen_fulfill_obligations

view details

Bastian Kauschke

commit sha f0487cee7439f3a4b4c7daec0e7f2a0ccc21053c

normalize substs during inlining

view details

Bastian Kauschke

commit sha 32739a2ff1b7b6e5c1b475341b01f4a499830a84

add regression test

view details

Bastian Kauschke

commit sha ac893b8a02788eec6f6fad0cc89de0177b0c0a50

add test for should_inline incorrect param_env

view details

Jacob Hughes

commit sha 4b96049da2329ba6e9a7fd4cd8224417fb4baede

BTreeMap: refactor Entry out of map.rs into its own file btree/map.rs is approaching the 3000 line mark, splitting out the entry code buys about 500 lines of headroom

view details

Ivan Tham

commit sha 2ce11afbec1dc1279360063fee0135a09b7fc11b

Use double quote for rustdoc html

view details

Jack Huey

commit sha dd5c9bf1392bdc697740e62a1924b7942cdfd86a

Use map_bound(_ref) instead of Binder::bind when possible

view details

Jack Huey

commit sha 11d62aa2849b48b850c412cc7ce20d8a60a74ab8

Review comments

view details

Santiago Pastorino

commit sha 3c4ad5508242bd560d095f1380bb8d739a0cbba2

Add inline_const feature flag

view details

Santiago Pastorino

commit sha c3e8d7965ccef7fe47db591ae0064af0034e3f25

Parse inline const expressions

view details

Santiago Pastorino

commit sha 59d07c3ae5a1f53924c7580fa302c397c362f1a2

Parse inline const patterns

view details

push time in 18 hours

issue commentrust-lang/rust

`rustfmt` no longer builds after rust-lang/rust#77306

So I think that the easiest fix is to add tcx.normalize_erasing_regions(param_env, substs) before this call. https://github.com/rust-lang/rust/blob/9832374f6e378971e1a933362cf9781b121bb845/compiler/rustc_mir_build/src/lints.rs#L74-L80

I am however surprised that func.ty(body, tcx) isn't actually normalized here. cc @eddyb @nikomatsakis do we want to instead normalize this in mir building?

rust-highfive

comment created time in 18 hours

issue commentrust-lang/rust

`rustfmt` no longer builds after rust-lang/rust#77306

Can you post the resulting backtrace using RUST_BACKTRACE=1?

rust-highfive

comment created time in 19 hours

issue openedrust-lang/compiler-team

TypeVisitor: use ops::ControlFlow instead of bool

Proposal

change the visit methods of TypeFoldable and TypeVisitor to use std::ops::ControlFlow<(), ()> instead of bool. In the future we may change the used type to std::ops::ControlFlow<(), Self::BreakTy> but this is not part of this MCP for now.

This makes it more intuitive and means that we can stop adding comments like false // keep visiting, for example in https://github.com/rust-lang/rust/blob/9832374f6e378971e1a933362cf9781b121bb845/compiler/rustc_trait_selection/src/opaque_types.rs#L696.

Mentors or Reviewers

If you have a reviewer or mentor in mind for this work, mention then here. You can put your own name here if you are planning to mentor the work.

Process

The main points of the Major Change Process is as follows:

  • [x] File an issue describing the proposal.
  • [ ] A compiler team member or contributor who is knowledgeable in the area can second by writing @rustbot second.
    • Finding a "second" suffices for internal changes. If however you are proposing a new public-facing feature, such as a -C flag, then full team check-off is required.
    • Compiler team members can initiate a check-off via @rfcbot fcp merge on either the MCP or the PR.
  • [ ] Once an MCP is seconded, the Final Comment Period begins. If no objections are raised after 10 days, the MCP is considered approved.

You can read more about Major Change Proposals on forge.

Comments

This issue is not meant to be used for technical discussion. There is a Zulip stream for that. Use this issue to leave procedural comments, such as volunteering to review, indicating that you second the proposal (or third, etc), or raising a concern that you would like to be addressed.

created time in 20 hours

delete branch lcnr/rust

delete branch : existential-proj

delete time in 21 hours

pull request commentrust-lang/rust

Add some MIR-related regression tests

thanks

@bors r+ rollup

JohnTitor

comment created time in a day

issue closedrust-lang/rust

Odd inference error reporting around generics

I made a MRE of a bug I encountered (in someone else's code actually):

struct S<T> {
    _t: std::marker::PhantomData<T>
}

impl<T> S<T> {
    fn f<U: ?Sized>(k: &U) where
    T: std::borrow::Borrow<U> {}
}

fn main() {
    let _ = |_: String| {};
    S::<String>::f("".as_ref());
}

I expected to see this happen: A compile error mentioning something about not being able to infer the type that as_ref should return, I suppose. Instead, this happened:

error[E0283]: type annotations needed
  --> src/main.rs:12:5
   |
6  | /     fn f<U: ?Sized>(k: &U) where
7  | |     T: std::borrow::Borrow<U> {}
   | |________________________________- required by `S::<T>::f`
...
12 |       S::<String>::f("".as_ref());
   |       ^^^^^^^^^^^^^^ cannot infer type for struct `std::string::String`
   |
   = note: cannot satisfy `std::string::String: std::borrow::Borrow<_>`

error: aborting due to previous error

Meta

Tested on playground, using stable, beta, and nightly (same error for all):

1.45.2
1.46.0-beta.4
1.47.0-nightly (2020-08-10 770bd3d1d03f0de2e27b)

Interesting variation:

struct S<T> {
    _t: std::marker::PhantomData<T>
}

impl<T> S<T> {
    fn f<U: ?Sized>(k: &U) where
    T: std::borrow::Borrow<U> {}
}

fn main() {
    S::<String>::f("".as_ref());
}

Which instead yields:

error[E0283]: type annotations needed
  --> src/main.rs:11:5
   |
6  | /     fn f<U: ?Sized>(k: &U) where
7  | |     T: std::borrow::Borrow<U> {}
   | |________________________________- required by `S::<T>::f`
...
11 |       S::<String>::f("".as_ref());
   |       ^^^^^^^^^^^^^^ cannot infer type for struct `std::string::String`
   |
   = note: cannot satisfy `std::string::String: std::borrow::Borrow<_>`

error: aborting due to previous error

(which is just a poor error, I think)

closed time in a day

izik1

issue commentrust-lang/rust

Odd inference error reporting around generics

The error message has been fixed by #78111 and now is

error[E0283]: type annotations needed
  --> src/main.rs:12:5
   |
6  | /     fn f<U: ?Sized>(k: &U) where
7  | |     T: std::borrow::Borrow<U> {}
   | |_____________________________- required by `S::<T>::f`
...
12 |       S::<String>::f("".as_ref());
   |       ^^^^^^^^^^^^^^ ----------- this method call resolves to `&T`
   |       |
   |       cannot infer type for type parameter `U` declared on the associated function `f`
   |
   = note: cannot satisfy `String: Borrow<_>`

As we already added a very similar test in that PR I am closing this as is without adding an additional test for it.

Thanks for opening this issue.

izik1

comment created time in a day

issue commentrust-lang/rust

type annotation warning involving completely unrelated scopes

This should have been fixed by #78111, marking as E-needs-test.

matthiaskrgr

comment created time in a day

issue commentrust-lang/rust

Bad error message when closure parameter type can't be inferred

The error message should have been fixed by #78111, marking as E-needs-test.

rbtcollins

comment created time in a day

pull request commentrust-lang/rust

Trait predicate ambiguities are not always in `Self`

will mark these issues as E-needs-test and close #75398

SNCPlay42

comment created time in a day

delete branch lcnr/rust

delete branch : namesNstuff

delete time in a day

pull request commentrust-lang/rust

Trait predicate ambiguities are not always in `Self`

Hmm, also not sure about that. I think #72616, #71732 are useful as additional tests but we probably can just close #75398 as is

SNCPlay42

comment created time in a day

pull request commentrust-lang/rust

Don't run `resolve_vars_if_possible` in `normalize_erasing_regions`

I don't expect the result to be free to inference variables, I expect the result to be free of Known inference variables.

My personal expectation is that this should be an invariant and believe that this is already the case, even if not documented rn.

I have only recently familiarized myself with this code so I might be incorrect here though

jyn514

comment created time in a day

pull request commentrust-lang/rust

Trait predicate ambiguities are not always in `Self`

@bors r+ rollup

SNCPlay42

comment created time in 2 days

Pull request review commentrust-lang/rust

Trait predicate ambiguities are not always in `Self`

 impl<'a, 'tcx> InferCtxtPrivExt<'tcx> for InferCtxt<'a, 'tcx> {                 // known, since we don't dispatch based on region                 // relationships. +                // Pick the first substitution that still contains inference variables as the one+                // we're going to emit an error for. If there are none (see above), fall back to+                // the substitution for `Self`.+                let subst = {+                    let substs = data.trait_ref.substs;+                    substs.iter().find(|s| s.needs_infer()).unwrap_or_else(|| substs[0])

yeah, that looks like the best solution to me :+1:

SNCPlay42

comment created time in 2 days

PullRequestReviewEvent

Pull request review commentrust-lang/rust

Trait predicate ambiguities are not always in `Self`

 impl<'a, 'tcx> InferCtxtPrivExt<'tcx> for InferCtxt<'a, 'tcx> {                 // known, since we don't dispatch based on region                 // relationships. +                // Pick the first substitution that still contains inference variables as the one+                // we're going to emit an error for. If there are none (see above), fall back to+                // the substitution for `Self`.+                let subst = {+                    let substs = data.trait_ref.substs;+                    substs.iter().find(|s| s.needs_infer()).unwrap_or_else(|| substs[0])

We probably want to use something like find(|s| s.needs_infer() && !matches!(s.unpack(), ty::GenericArgKind::Lifetime(_))) as emit_inference_failure_err can't deal with lifetimes rn.

I expect this to ICE for a trait like trait Foo<'a, T> if both 'a and T is unknown.What I am thinking of is something close to https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=66c6ee4894a18b7386ac056405b7cd02

trait Foo<'a, T> {
    fn test(&self) -> T {
        todo!()
    }
}

impl<'a> Foo<'static, u32> for &'a () {}

impl<'a> Foo<'a, i16> for &'a () {}

fn main() {
    let x = &();
    assert_eq!(x.test(), 7);
}
SNCPlay42

comment created time in 2 days

pull request commentrust-lang/rust

Trait predicate ambiguities are not always in `Self`

@bors r- missed something in my review

SNCPlay42

comment created time in 2 days

pull request commentrust-lang/rust

Trait predicate ambiguities are not always in `Self`

damn, that's beautiful :heart: Previously while looking into this with @doctorn I never even thought about this, at least partially because emit_inference_failure_err still took a Ty<'tcx> back then which would have made implementing this PR harder.

Thank you

@bors r+ rollup

SNCPlay42

comment created time in 2 days

delete branch lcnr/awesome-rust-mentors

delete branch : patch-1

delete time in 2 days

push eventlcnr/awesome-rust-mentors

lcnr

commit sha d3082dc9e9aac4b5a41a310abe05a3a42ccd64b4

update mentors

view details

push time in 2 days

PR opened rust-lang/rust

change name in .mailmap
+1 -1

0 comment

1 changed file

pr created time in 2 days

pull request commentrust-lang/rust

feat: Update hashbrown to instantiate less llvm IR

@bors try @rust-timer queue

Marwes

comment created time in 2 days

create barnchlcnr/rust

branch : namesNstuff

created branch time in 2 days

issue commentrust-lang/rust

`rustfmt` no longer builds after rust-lang/rust#77306

yes, so we do not want to use tcx.normalize_erasing_regions in codegen_fulfill_obligations as that can be a bit costly but instead normalize eagerly before then.

To detect cases where we are still using unnormalized values #77306 added a debug assert there. If we look at the backtrace we can find out where the trait_ref is coming from and normalize it there

rust-highfive

comment created time in 2 days

issue commentrust-lang/rust

`rustfmt` no longer builds after rust-lang/rust#77306

won't be able to get to this myself in the next few days. To fix this we probably have to compile it with RUST_BACKTRACE=1, find the place where we call Instance::resolve and put a tcx.normalize_erasing_regions before that

rust-highfive

comment created time in 2 days

Pull request review commentrust-lang/rust

[WIP] Refactor `Binder` to track bound vars

 impl<'tcx> PredicateVisitor<'tcx> for HasEscapingVarsVisitor {     } } +crate struct CountBoundVars<'tcx> {+    crate outer_index: ty::DebruijnIndex,+    crate bound_tys: SsoHashSet<ty::BoundTy>,+    crate bound_regions: SsoHashSet<ty::BoundRegion>,+    crate bound_consts: SsoHashSet<ty::BoundVar>,+    crate visited: SsoHashSet<Ty<'tcx>>,+}++impl<'tcx> CountBoundVars<'tcx> {+    crate fn new() -> Self {+        CountBoundVars {+            outer_index: ty::INNERMOST,+            bound_tys: SsoHashSet::default(),+            bound_regions: SsoHashSet::default(),+            bound_consts: SsoHashSet::default(),+            visited: SsoHashSet::default(),+        }+    }+}++impl<'tcx> TypeVisitor<'tcx> for CountBoundVars<'tcx> {+    fn visit_binder<T: TypeFoldable<'tcx>>(&mut self, t: &Binder<T>) -> bool {+        self.outer_index.shift_in(1);+        let result = t.super_visit_with(self);+        self.outer_index.shift_out(1);+        result+    }++    fn visit_ty(&mut self, t: Ty<'tcx>) -> bool {+        if t.outer_exclusive_binder >= self.outer_index || !self.visited.insert(t) {

isn't this incorrect?

Don't you instead want to exit early if t.outer_exclusive_binder <= self.outer_index?

jackh726

comment created time in 2 days

PullRequestReviewEvent

pull request commentrust-lang/rust

Fix issue with specifying generic arguments for primitive types

:+1:

@bors r+ rollup

varkor

comment created time in 2 days

pull request commentrust-lang/rust

Calculate visibilities once in resolve

https://github.com/rust-lang/compiler-team/blob/master/content/experts/map.toml mentions @davidtwco but feel free to reassign

r? @davidtwco for now

petrochenkov

comment created time in 3 days

Pull request review commentrust-lang/rust

Calculate visibilities once in resolve

 impl<'a, 'tcx> Visitor<'tcx> for PrivateItemsInPublicInterfacesVisitor<'a, 'tcx>  pub fn provide(providers: &mut Providers) {     *providers = Providers {+        visibility,         privacy_access_levels,         check_private_in_public,         check_mod_privacy,         ..*providers     }; } +fn visibility(tcx: TyCtxt<'_>, def_id: DefId) -> ty::Visibility {+    let def_id = def_id.expect_local();+    match tcx.visibilities.get(&def_id) {+        Some(vis) => *vis,+        None => {+            let hir_id = tcx.hir().local_def_id_to_hir_id(def_id);+            match tcx.hir().get(hir_id) {+                // Unique types created for closures participate in type privacy checking.+                // They have visibilities inherited from the module they are defined in.+                Node::Expr(hir::Expr { kind: hir::ExprKind::Closure(..), .. }) => {+                    ty::Visibility::Restricted(tcx.parent_module(hir_id).to_def_id())+                }+                // - AST lowering may clone `use` items and the clones don't+                //   get their entries in the resolver's visibility table.+                // - AST lowering also creates opaque type items with inherited visibilies.+                //   Visibility on them should have no effect, but to avoid the visibility+                //   query failing on some items, we provide it for opaque types as well.+                Node::Item(hir::Item {+                    vis,+                    kind: hir::ItemKind::Use(..) | hir::ItemKind::OpaqueTy(..),+                    ..+                }) => ty::Visibility::from_hir(vis, hir_id, tcx),+                // Visibilities of trait impl items are inherited from their traits+                // and are not filled in resolve.+                Node::ImplItem(impl_item) => {+                    match tcx.hir().get(tcx.hir().get_parent_item(hir_id)) {+                        Node::Item(hir::Item {+                            kind: hir::ItemKind::Impl { of_trait: Some(trait_ref), .. },+                            ..+                        }) => trait_ref+                            .path+                            .res+                            .opt_def_id()+                            .map_or(ty::Visibility::Public, |def_id| tcx.visibility(def_id)),

is opt_def_id only None here if we already emitted an error?

Can we use a delay_span_bug here?

petrochenkov

comment created time in 3 days

PullRequestReviewEvent
PullRequestReviewEvent

Pull request review commentrust-lang/rust

Lift: take self by value

 impl<'cx, 'tcx> dataflow::ResultsVisitor<'cx, 'tcx> for MirBorrowckCtxt<'cx, 'tc                 // "Lift" into the tcx -- once regions are erased, this type should be in the                 // global arenas; this "lift" operation basically just asserts that is true, but                 // that is useful later.-                tcx.lift(&drop_place_ty).unwrap();+                tcx.lift(drop_place_ty).unwrap();

Isn't this function call fairly useless now that we only have one global context?

lcnr

comment created time in 3 days

PullRequestReviewEvent

Pull request review commentrust-lang/rust

[WIP] Refactor `Binder` to track bound vars

 impl<'tcx> PredicateVisitor<'tcx> for HasEscapingVarsVisitor {     } } +crate struct CountBoundVars {+    crate outer_index: ty::DebruijnIndex,+    crate bound_tys: FxHashSet<ty::BoundTy>,+    crate bound_regions: FxHashSet<ty::BoundRegion>,+    crate bound_consts: FxHashSet<ty::BoundVar>,+}

it probably makes sense to use MiniSet instead of FxHashSet here as these sets should mostly be nearly empty

jackh726

comment created time in 3 days

PullRequestReviewEvent

Pull request review commentrust-lang/rust

[WIP] Refactor `Binder` to track bound vars

 impl<'tcx> PredicateVisitor<'tcx> for HasEscapingVarsVisitor {     } } +crate struct CountBoundVars {+    crate outer_index: ty::DebruijnIndex,+    crate bound_tys: FxHashSet<ty::BoundTy>,+    crate bound_regions: FxHashSet<ty::BoundRegion>,+    crate bound_consts: FxHashSet<ty::BoundVar>,+}++impl<'tcx> TypeVisitor<'tcx> for CountBoundVars {+    fn visit_binder<T: TypeFoldable<'tcx>>(&mut self, t: &Binder<T>) -> bool {+        self.outer_index.shift_in(1);+        let result = t.super_visit_with(self);+        self.outer_index.shift_out(1);+        result+    }++    fn visit_ty(&mut self, t: Ty<'tcx>) -> bool {+        match t.kind {

you can also implement PredicateVisitor here to do the same for ty::Predicate

jackh726

comment created time in 3 days

PullRequestReviewEvent

Pull request review commentrust-lang/rust

[WIP] Refactor `Binder` to track bound vars

 impl<'tcx> PredicateVisitor<'tcx> for HasEscapingVarsVisitor {     } } +crate struct CountBoundVars {+    crate outer_index: ty::DebruijnIndex,+    crate bound_tys: FxHashSet<ty::BoundTy>,+    crate bound_regions: FxHashSet<ty::BoundRegion>,+    crate bound_consts: FxHashSet<ty::BoundVar>,+}++impl<'tcx> TypeVisitor<'tcx> for CountBoundVars {+    fn visit_binder<T: TypeFoldable<'tcx>>(&mut self, t: &Binder<T>) -> bool {+        self.outer_index.shift_in(1);+        let result = t.super_visit_with(self);+        self.outer_index.shift_out(1);+        result+    }++    fn visit_ty(&mut self, t: Ty<'tcx>) -> bool {+        match t.kind {

can you exit early with ty.has_vars_bound_at_or_above(self.outer_index) here? Should greatly reduce the perf impact I think

jackh726

comment created time in 3 days

PullRequestReviewEvent

Pull request review commentrust-lang/rust

[WIP] Refactor `Binder` to track bound vars

 impl<'tcx> PredicateVisitor<'tcx> for HasEscapingVarsVisitor {     } } +crate struct CountBoundVars {+    crate outer_index: ty::DebruijnIndex,+    crate bound_tys: FxHashSet<ty::BoundTy>,+    crate bound_regions: FxHashSet<ty::BoundRegion>,+    crate bound_consts: FxHashSet<ty::BoundVar>,+}++impl<'tcx> TypeVisitor<'tcx> for CountBoundVars {+    fn visit_binder<T: TypeFoldable<'tcx>>(&mut self, t: &Binder<T>) -> bool {+        self.outer_index.shift_in(1);+        let result = t.super_visit_with(self);+        self.outer_index.shift_out(1);+        result+    }++    fn visit_ty(&mut self, t: Ty<'tcx>) -> bool {+        match t.kind {+            ty::Bound(debruijn, ty) if debruijn >= self.outer_index => {

Why do we consider for for<T> for<U> Struct<T, U> that the inner binder (for<U>) binds T and U while for for<'a> for<'b> Struct<'a, 'b> the inner binder only binds b afaict?

In case I am misunderstanding something here: why do we use debruijn >= self.outer_index for types and debruijn == self.outer_index for regions?

jackh726

comment created time in 3 days

PullRequestReviewEvent

pull request commentrust-lang/rust

Make sure arenas don't allocate bigger than HUGE_PAGE

well, then

@bors r+ rollup

bugadani

comment created time in 3 days

pull request commentrust-lang/rust

Make sure arenas don't allocate bigger than HUGE_PAGE

this code is really hot, so it's better to be safe here

@bors try @rust-timer queue

bugadani

comment created time in 3 days

Pull request review commentrust-lang/rust

Make sure arenas don't allocate bigger than HUGE_PAGE

 impl<T> TypedArena<T> {                 // If the previous chunk's len is less than HUGE_PAGE                 // bytes, then this chunk will be least double the previous                 // chunk's size.-                new_cap = last_chunk.storage.len();-                if new_cap < HUGE_PAGE / elem_size {-                    new_cap = new_cap.checked_mul(2).unwrap();-                }+                new_cap = last_chunk.storage.len().min(HUGE_PAGE / 2);

you now use HUGE_PAGE instead of HUGE_PAGE / elem_size here, is that intentional?

bugadani

comment created time in 4 days

PullRequestReviewEvent
PullRequestReviewEvent

pull request commentrust-lang/rust

always try inlining functions which do not call other functions

what the heck happened to deeply-nested here? :scream:

Ignoring that one, it does look like both incremental and full builds profit from this change :thinking: I personally would love to land this, potentially after disabling it for check builds. iirc there are still some blocking issues though regarding the source info of the inlined function. cc @oli-obk

lcnr

comment created time in 4 days

pull request commentrust-lang/rust

Suggest correct place to add `self` parameter when inside closure

cc @estebank

@bors r+ rollup

blyxxyz

comment created time in 4 days

PullRequestReviewEvent

pull request commentrust-lang/rust

Fix grammar in note for orphan-rule error [E0210]

thanks!

@bors r+ rollup

willcrozi

comment created time in 4 days

pull request commentrust-lang/rust

Lift: take self by value

yeah, I guess that's about as expected. Mostly think that taking self by value here is cleaner

lcnr

comment created time in 4 days

issue openedrust-lang/compiler-team

Change type folding to take self by value

Proposal

Try changing both fold_with and super_fold_with to take self by value instead of by reference. This removes a lot of unnecessary borrows and clones. It will have an influence on perf, which if negative will result in this MCP being discarded.

https://github.com/rust-lang/rust/pull/78027 implements the same change for Lift.

Mentors or Reviewers

:shrug:

Process

The main points of the Major Change Process is as follows:

  • [x] File an issue describing the proposal.
  • [ ] A compiler team member or contributor who is knowledgeable in the area can second by writing @rustbot second.
    • Finding a "second" suffices for internal changes. If however you are proposing a new public-facing feature, such as a -C flag, then full team check-off is required.
    • Compiler team members can initiate a check-off via @rfcbot fcp merge on either the MCP or the PR.
  • [ ] Once an MCP is seconded, the Final Comment Period begins. If no objections are raised after 10 days, the MCP is considered approved.

You can read more about Major Change Proposals on forge.

Comments

This issue is not meant to be used for technical discussion. There is a Zulip stream for that. Use this issue to leave procedural comments, such as volunteering to review, indicating that you second the proposal (or third, etc), or raising a concern that you would like to be addressed.

created time in 4 days

pull request commentrust-lang/rust

always try inlining functions which do not call other functions

Let's try another perf run, caching is_trivial_mir on disk should hopefully fix most of the incremental cost.

@bors try @rust-timer queue

lcnr

comment created time in 4 days

Pull request review commentrust-lang/rust

always try inlining functions which do not call other functions

 define_tables! {     super_predicates: Table<DefIndex, Lazy!(ty::GenericPredicates<'tcx>)>,     // As an optimization, a missing entry indicates an empty `&[]`.     explicit_item_bounds: Table<DefIndex, Lazy!([(ty::Predicate<'tcx>, Span)])>,+    is_trivial_mir: Table<DefIndex, Lazy<bool>>,

I am using Lazy<bool> here because I don't know how any of this works :sweat_smile: using Table<DefIndex, ()> seems interesting. Will look into this

lcnr

comment created time in 4 days

PullRequestReviewEvent

push eventlcnr/rust

Dylan DPC

commit sha f23559451b0dc5181d73ddd89657266d4e150b6a

Rollup merge of #77303 - lcnr:const-evaluatable-TooGeneric, r=oli-obk,varkor const evaluatable: improve `TooGeneric` handling Instead of emitting an error in `fulfill`, we now correctly stall on inference variables. As `const_eval_resolve` returns `ErrorHandled::TooGeneric` when encountering generic parameters on which we actually do want to error, we check for inference variables and eagerly emit an error if they don't exist, returning `ErrorHandled::Reported` instead. Also contains a small bugfix for `ConstEquate` where we previously only stalled on type variables. This is probably a leftover from when we did not yet support stalling on const inference variables. r? @oli-obk cc @varkor @eddyb

view details

Dylan DPC

commit sha 6d3cfd9d51e9c25452a28d18af130ad7e1fc2c90

Rollup merge of #77305 - lcnr:candidate_from_obligation, r=davidtwco move candidate_from_obligation_no_cache It's only called from `candidate_from_obligation` which is already in this file.

view details

Dylan DPC

commit sha 70740b1b82be274c63a4f7c3795db8a5d2b15d3b

Rollup merge of #77315 - exrook:rename-allocerror, r=joshtriplett Rename AllocErr to AllocError Implements rust-lang/wg-allocators#57

view details

Dylan DPC

commit sha 0044a9c08478d54047abc812a86220cd33f5f120

Rollup merge of #77319 - tgnottingham:siphasher_endianness, r=nnethercote Stable hashing: add comments and tests concerning platform-independence SipHasher128 implements short_write in an endian-independent way, yet its write_xxx Hasher trait methods undo this endian-independence by byte swapping the integer inputs on big-endian hardware. StableHasher then adds endian-independence back by also byte-swapping on big-endian hardware prior to invoking SipHasher128. This double swap may have the appearance of being a no-op, but is in fact by design. In particular, we really do want SipHasher128 to be platform-dependent, in order to be consistent with the libstd SipHasher. Try to clarify this intent. Also, add and update a couple of unit tests. --- Previous commit text: ~SipHasher128: fix platform-independence confusion~ ~StableHasher is supposed to ensure platform independence by converting integers to little-endian and extending isize and usize to 64 bits as necessary, but in fact, much of that work is already handled by SipHasher128.~ ~In particular, SipHasher128 implements short_write in an endian-independent way, yet both StableHasher and SipHasher128 additionally attempt to achieve endian-independence by byte swapping on BE hardware before invoking short writes. This double swap has no effect, so let's remove it.~ ~Because short_write is endian-independent, SipHasher128 is already handling part of the platform-independence, and it would be somewhat difficult to make it *not* handle that part with the current implementation. As splitting platform-independence responsibilities between StableHasher and SipHasher128 would be confusing, let's make SipHasher128 handle all of it.~ ~Finally, update some incorrect comments and increase test coverage. Unit tests pass on both LE and BE systems.~

view details

Dylan DPC

commit sha 73258f87eaacd0b0b9dfbda5603119d425866801

Rollup merge of #77324 - Aaron1011:fix/const-item-mutation-ptr, r=petrochenkov Don't fire `const_item_mutation` lint on writes through a pointer Fixes #77321

view details

Dylan DPC

commit sha 849e5636ea91a09a7e7a34a0cb3183978bed9887

Rollup merge of #77343 - varkor:rustc_args_required_const-validation, r=lcnr Validate `rustc_args_required_const` Fixes https://github.com/rust-lang/rust/issues/74608.

view details

Dylan DPC

commit sha ffb771bc7988ffb5ba862d2d794246ab0ede747d

Rollup merge of #77349 - ehuss:update-cargo, r=ehuss Update cargo 8 commits in 05c611ae3c4255b7a2bcf4fcfa65b20286a07839..75615f8e69f748d7ef0df7bc0b064a9b1f5c78b2 2020-09-23 23:10:38 +0000 to 2020-09-29 18:42:19 +0000 - Correct mistake about supporting sub-makes and document CARGO_MAKEFLAGS (rust-lang/cargo#8741) - Properly set for_host for proc-macro tests. (rust-lang/cargo#8742) - Add Zsh completion for target triples (rust-lang/cargo#8740) - Reinitialize index on "Object not found" error. (rust-lang/cargo#8735) - Normalize raw string indentation. (rust-lang/cargo#8739) - Update links to rustup docs. (rust-lang/cargo#8738) - Add contributor guide. (rust-lang/cargo#8715) - Fix minor error in `cargo update` docs. (rust-lang/cargo#8737)

view details

Dylan DPC

commit sha cc1513b860900f87a1077193f0a1dd4e1beeb577

Rollup merge of #77360 - oli-obk:zst_const_pat_regression, r=RalfJung References to ZSTs may be at arbitrary aligned addresses fixes #77320 r? @RalfJung

view details

Dylan DPC

commit sha 85e77edc82f8052b865cf35f9aaade2d668ea4f1

Rollup merge of #77371 - camelid:remove-extra-space-in-diagnostic, r=varkor Remove trailing space in error message - Add test for error message - Remove trailing space in error message

view details

bors

commit sha b218b952f800c1160b8b5e764ca651b02d678565

Auto merge of #77381 - Dylan-DPC:rollup-0sr6p5p, r=Dylan-DPC Rollup of 12 pull requests Successful merges: - #76909 (Add Iterator::advance_by and DoubleEndedIterator::advance_back_by) - #77153 (Fix recursive nonterminal expansion during pretty-print/reparse check) - #77202 (Defer Apple SDKROOT detection to link time.) - #77303 (const evaluatable: improve `TooGeneric` handling) - #77305 (move candidate_from_obligation_no_cache) - #77315 (Rename AllocErr to AllocError) - #77319 (Stable hashing: add comments and tests concerning platform-independence) - #77324 (Don't fire `const_item_mutation` lint on writes through a pointer) - #77343 (Validate `rustc_args_required_const`) - #77349 (Update cargo) - #77360 (References to ZSTs may be at arbitrary aligned addresses) - #77371 (Remove trailing space in error message) Failed merges: r? `@ghost`

view details

Carol (Nichols || Goulding)

commit sha 2033eb1495b4a0386a0ab08815769477baf20c89

Write manifest for MAJOR.MINOR channel to enable rustup convenience This connects to https://github.com/rust-lang/rustup/issues/794. It's hard to remember if there have been patch releases for old versions when you'd like to install the latest in a MAJOR.MINOR series. When we're doing a stable release, we write duplicate manifests to `stable`. With this change, only when we're doing a stable release, also write duplicate manifests to `MAJOR.MINOR` to eventually enable rustup (and any other tooling that builds Rust release URLs) to request, say, `1.45` and get `1.45.2` (assuming `1.45.2` is the latest available `1.45` and assuming that we never publish patch releases out of order).

view details

Ivan Tham

commit sha 86e30b605c585f2841dfd4bddb5afb696ab03cb5

Fix typo in vec doc "tries to reserves"

view details

Scott McMurray

commit sha 20202da09e86bd15ffcd0ce22b5ebe8a27ef17a0

Improve the example for ptr::copy Fixes #77220

view details

bors

commit sha 3bbc443cc6657b5df623101f74688ec92e35f35d

Auto merge of #77379 - camelid:improve-wording-crate-resolution-error, r=davidtwco Improve wording for external crate resolution error I think it reads better this way.

view details

David Tolnay

commit sha 17db1cb5d5a864d611e17d6e2466731c3b50a794

Bypass const_item_mutation if const's type has Drop impl

view details

David Tolnay

commit sha 0dfe7b6434f6aabbe9673a891ba74c7c7922661d

Add justification of the destructor filter

view details

David Tolnay

commit sha bb760b53bf7f9593c09a03e5dea28ef5f31065d7

Simplify defid destructor check

view details

David Tolnay

commit sha 0f6284c88d521904bb0ada34325a0372a1ea26f1

Add test of const item mutation with Drop impl

view details

David Tolnay

commit sha 352ce8b29990d62465675b46b42a695a4206d5be

Test a type with drop glue but no Drop impl

view details

David Tolnay

commit sha 41baa090ad1c40a7fc96f96664543ce4c26746c2

Skip dropck::check_drop_impl in is_const_item_without_destructor adt_destructor by default also validates the Drop impl using dropck::check_drop_impl, which contains an expect_local(). This leads to ICE in check_const_item_mutation if the const's type is not a local type. thread 'rustc' panicked at 'DefId::expect_local: `DefId(5:4805 ~ alloc[d7e9]::vec::{impl#50})` isn't local', compiler/rustc_span/src/def_id.rs:174:43 stack backtrace: 0: rust_begin_unwind 1: rustc_span::def_id::DefId::expect_local::{{closure}} 2: rustc_typeck::check::dropck::check_drop_impl 3: rustc_middle::ty::util::<impl rustc_middle::ty::context::TyCtxt>::calculate_dtor::{{closure}} 4: rustc_middle::ty::trait_def::<impl rustc_middle::ty::context::TyCtxt>::for_each_relevant_impl 5: rustc_middle::ty::util::<impl rustc_middle::ty::context::TyCtxt>::calculate_dtor 6: rustc_typeck::check::adt_destructor 7: rustc_middle::ty::query::<impl rustc_query_system::query::config::QueryAccessors<rustc_middle::ty::context::TyCtxt> for rustc_middle::ty::query::queries::adt_destructor>::compute 8: rustc_query_system::dep_graph::graph::DepGraph<K>::with_task_impl 9: rustc_query_system::query::plumbing::get_query_impl 10: rustc_mir::transform::check_const_item_mutation::ConstMutationChecker::is_const_item_without_destructor

view details

push time in 4 days

push eventlcnr/rust

Bastian Kauschke

commit sha 18080f9b434339fe6f4f1454b8ebad98fd2c311c

cache me on disk

view details

Bastian Kauschke

commit sha 54fcb47ce840b88f5acb398f3878cd0241d37734

allow intrinsics

view details

push time in 4 days

pull request commentrust-lang/rust

Don't run `resolve_vars_if_possible` in `normalize_erasing_regions`

I believe that resolve_vars_if_possible should always be a noop after normalize in a fresh InferCtxt as I expect all infer variables created during normalization to be still unknown after it.

So I do think it is valuable to remove that afaict unnecessary step here.

jyn514

comment created time in 4 days

pull request commentrust-lang/rust

Use rebind instead of Binder::bind when possible

looking fairly neutral to me

@bors r+

jackh726

comment created time in 4 days

pull request commentrust-lang/rust

Lift: take self by value

@bors try @rust-timer queue

lcnr

comment created time in 5 days

PR opened rust-lang/rust

Lift: take self by value

seems small enough to not warrant an MCP :shrug:

+138 -151

0 comment

15 changed files

pr created time in 5 days

create barnchlcnr/rust

branch : lift-by-value

created branch time in 5 days

pull request commentrust-lang/rust

Use map_bound(_ref) instead of Binder::bind when possible

we have been bitten by perf in the past here, so better safe than sorry

@bors try @rust-timer queue

if perf is clean r=me

jackh726

comment created time in 5 days

PullRequestReviewEvent

Pull request review commentrust-lang/rust

Eliminate some temporary vectors

 dependencies = [  "rustc_ast",  "rustc_span",  "rustc_target",+ "smallvec 1.4.2",

specifying a version number here works :O

bugadani

comment created time in 5 days

PullRequestReviewEvent

Pull request review commentrust-lang/rust

Use map_bound(_ref) instead of Binder::bind when possible

 impl<'tcx> Predicate<'tcx> {         }     } +    /// Converts this to a `Binder<PredicateAtom<'tcx>>`. If the value was an+    /// `Atom`, then it is not allowed to contain escaping bound vars.+    pub fn bound_atom(self, _tcx: TyCtxt<'tcx>) -> Binder<PredicateAtom<'tcx>> {+        match self.kind() {+            &PredicateKind::ForAll(binder) => binder,+            &PredicateKind::Atom(atom) => {+                assert!(!atom.has_escaping_bound_vars());

also, is there a reason you did not remove the _tcx argument here? Do you expect us to need it in the future?

jackh726

comment created time in 5 days

Pull request review commentrust-lang/rust

Use map_bound(_ref) instead of Binder::bind when possible

 impl<'a, 'tcx> ProbeContext<'a, 'tcx> {         // FIXME: do we want to commit to this behavior for param bounds?         debug!("assemble_inherent_candidates_from_param(param_ty={:?})", param_ty); -        let bounds =-            self.param_env.caller_bounds().iter().map(ty::Predicate::skip_binders).filter_map(-                |predicate| match predicate {-                    ty::PredicateAtom::Trait(trait_predicate, _) => {-                        match trait_predicate.trait_ref.self_ty().kind() {-                            ty::Param(ref p) if *p == param_ty => {-                                Some(ty::Binder::bind(trait_predicate.trait_ref))-                            }-                            _ => None,+        let tcx = self.tcx;+        let bounds = self.param_env.caller_bounds().iter().filter_map(|predicate| {+            let bound_predicate = predicate.bound_atom(tcx);+            match bound_predicate.skip_binder() {+                ty::PredicateAtom::Trait(trait_predicate, _) => {+                    match trait_predicate.trait_ref.self_ty().kind() {+                        ty::Param(ref p) if *p == param_ty => {
                    match *trait_predicate.trait_ref.self_ty().kind() {
                        ty::Param(p) if p == param_ty => {
jackh726

comment created time in 5 days

Pull request review commentrust-lang/rust

Use map_bound(_ref) instead of Binder::bind when possible

 fn ensure_drop_predicates_are_implied_by_item_defn<'tcx>(         // could be extended easily also to the other `Predicate`.         let predicate_matches_closure = |p: Predicate<'tcx>| {             let mut relator: SimpleEqRelation<'tcx> = SimpleEqRelation::new(tcx, self_param_env);+            let bound_predicate = predicate.bound_atom(tcx);+            let bound_p = p.bound_atom(tcx);             match (predicate.skip_binders(), p.skip_binders()) {

nit: style

maybe instead shadow p and predicate here and match on (predicate.skip_binder(), p.skip_binder())

jackh726

comment created time in 5 days

Pull request review commentrust-lang/rust

Use map_bound(_ref) instead of Binder::bind when possible

 impl<'tcx> Predicate<'tcx> {         }     } +    /// Converts this to a `Binder<PredicateAtom<'tcx>>`. If the value was an+    /// `Atom`, then it is not allowed to contain escaping bound vars.+    pub fn bound_atom(self, _tcx: TyCtxt<'tcx>) -> Binder<PredicateAtom<'tcx>> {+        match self.kind() {+            &PredicateKind::ForAll(binder) => binder,+            &PredicateKind::Atom(atom) => {+                assert!(!atom.has_escaping_bound_vars());
                debug_assert!(!atom.has_escaping_bound_vars());

i expect this method to be faily hot, so it might also make sense to mark this #[inline]

jackh726

comment created time in 5 days

Pull request review commentrust-lang/rust

Use map_bound(_ref) instead of Binder::bind when possible

 impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {         }          let result = ensure_sufficient_stack(|| {-            match obligation.predicate.skip_binders() {+            let bound_predicate =+                obligation.predicate.bound_atom_with_opt_escaping(self.infcx().tcx);

why do you use ...with_opt_escaping here? We previously used skip_binders which failed on unbound vars

jackh726

comment created time in 5 days

Pull request review commentrust-lang/rust

Use map_bound(_ref) instead of Binder::bind when possible

 impl<T> Binder<T> {         Binder(f(self.0))     } +    /// Wraps a `value` in a binder, using the same bound variables as the+    /// current `Binder`. This should not be used if the new value *changes*+    /// the bound variables. Note: the (old or new) value itself does not+    /// necessarily need to *name* all the bound variables.+    pub fn rebind<U>(&self, value: U) -> Binder<U> {

It might make sense to add a comment here which says that we do not yet track bound variables.

I am also kind of suprised that none of the methods on ty::Binder are marked as inline even though they are very frequently used and really simple. Might be interesting to check if that has a perf impact.

jackh726

comment created time in 5 days

Pull request review commentrust-lang/rust

Use map_bound(_ref) instead of Binder::bind when possible

 impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {              ty::Array(element_ty, _) => {                 // (*) binder moved here-                Where(ty::Binder::bind(vec![element_ty]))+                Where(obligation.predicate.rebind(vec![*element_ty]))

can you instead of using *element_ty here change the match statement to

match *self_ty.kind() {
jackh726

comment created time in 5 days

PullRequestReviewEvent
PullRequestReviewEvent

pull request commentrust-lang/rust

Check for frequent types in type folding

@bors try @rust-timer queue

JulianKnodt

comment created time in 5 days

more