jiebi/CodeConvo huggingface dataset:
Change:
It looks like introduced a regression. The following used to work: but now generates the following error:
Yeah, sorry about that! There's already a fix for this in
I am also now seeing spurious 'non-exhaustive patterns' errors when attempting to match struct variants of an imported enum type. For example, here is a simplification of some code in : The error is:
Oh dear. Looks like it only fails when the enum is defined in a different crate as this works: I'll take a look!
Please add an appropriate test for this case... Niko
I a test for the cross-crate case in . There are already quite a few existing tests for local variants.
On Sun, Jun 22, 2014 at 07:43:54AM -0700, Jakub Wieczorek wrote: great

Discussion:
} fn all_constructors(cx: &MatchCheckCtxt, m: &Matrix, left_ty: ty::t) -> Vec<ctor> { <ins> // This produces a list of all vector constructors that we would expect to appear // in an exhaustive set of patterns. Because such a list would normally be infinite, // we narrow it down to only those constructors that actually appear in the inspected // column, plus, any that are missing and not covered by a pattern with a destructured slice. </ins> fn vec_constructors(m: &Matrix) -> Vec<ctor> { let max_vec_len = m.iter().map(|r| match r.get(0).node { PatVec(ref before, _, ref after) => before.len() + after.len(), _ => 0u }).max().unwrap_or(0u); <del> let contains_slice = m.iter().any(|r| match r.get(0).node { PatVec(_, ref slice, _) => slice.is_some(), _ => false }); let lengths = iter::range_inclusive(0u, if contains_slice { max_vec_len } else { max_vec_len + 1 }); lengths.map(|len| vec(len)).collect() </del> <ins> let min_vec_len_with_slice = m.iter().map(|r| match r.get(0).node { PatVec(ref before, Some(_), ref after) => before.len() + after.len(), _ => max_vec_len + 1 }).min().unwrap_or(max_vec_len + 1); let other_lengths = m.iter().map(|r| match r.get(0).node { PatVec(ref before, _, ref after) => before.len() + after.len(), _ => 0u }).filter(|&len| len > min_vec_len_with_slice); iter::range_inclusive(0u, min_vec_len_with_slice) .chain(other_lengths) .map(|len| vec(len)) .collect() </ins> } match ty::get(left_ty).sty {

<ins> // Copyright 2014 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. fn main() { let mut x = &[1, 2, 3, 4]; let mut result = vec!(); loop { x = match x { [1, n, 3, ..rest] => { result.push(n); rest } [n, ..rest] => { result.push(n); rest } [] => break } } assert!(result.as_slice() == [2, 4]); } </ins>

assert_eq!(branch, 1); } <ins> fn e() { match &[1, 2, 3] { [1, 2] => (), [..] => () } } </ins> pub fn main() { a(); b(); c(); d(); <ins> e(); </ins> }
Change:
Code sample: Backtrace and debug log:
Similar code without the feature does not cause a compiler error:
A smaller test case:
Neither of the test cases are ICEing for me today, I'm seeing the following:
Flagging as needstest

Discussion:
<ins> // Copyright 2014 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. trait Foo { fn bar(&mut self, other: &mut Foo); } struct Baz; impl Foo for Baz { fn bar(&mut self, other: &Foo) {} //~^ ERROR method `bar` has an incompatible type for trait: values differ in mutability [E0053] } fn main() {} </ins>

<ins> // Copyright 2014 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. #![feature(overloaded_calls)] use std::{fmt, ops}; struct Shower<T> { x: T } impl<T: fmt::Show> ops::Fn<(), ()> for Shower<T> { fn call(&self, _args: ()) { //~^ ERROR `call` has an incompatible type for trait: expected "rust-call" fn but found "Rust" fn println!("{}", self.x); } } fn make_shower<T>(x: T) -> Shower<T> { Shower { x: x } } pub fn main() { let show3 = make_shower(3i); show3(); } </ins>

<ins> // Copyright 2014 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. enum Foo { A = 1i64, //~^ ERROR mismatched types: expected `int` but found `i64` B = 2u8 //~^ ERROR mismatched types: expected `int` but found `u8` } fn main() {} </ins>

<ins> // Copyright 2014 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. fn main() { if true { return } match () { () => { static MAGIC: uint = 0; } } } </ins>
Change:
Test case: Result:
Fixed long ago (if you switch to passing the arg by &)

Discussion:
rustup toolchain install --profile minimal nightly-${TOOLCHAIN} # Sanity check to see if the nightly exists echo nightly-${TOOLCHAIN} > rust-toolchain <del> echo "=> Uninstalling all old nighlies" </del> <ins> echo "=> Uninstalling all old nightlies" </ins> for nightly in $(rustup toolchain list | grep nightly | grep -v $TOOLCHAIN | grep -v nightly-x86_64); do rustup toolchain uninstall $nightly done
Change:
links should have colors to highlight that they are links: ! Some find it difficult to know which items are links. [EDIT] Removed sidebar circles. Never thought they needed changing.
has the same issue: ! [EDIT] Removed sidebar circles. Never thought they needed changing.
Totally agree. Also, instead of colors, we could use dashed underlines to indicate links while still keeping the same feel. (I disagree about the sidebar as well, I think its normal to expect those to be links, because they're in a sidebar without any text)
Sidebar is fine, thats a pretty normal convention to have those as links. At first glance I didn't realize most of the text in the main doc area was clickable however, I really like the idea of having the dashed underlines. +1
Didn't think sidebar necessarily should change. Was just highlighting black links. Edited pictures to removed sidebar circles.
Really quick mockup:  It doesn't show in the screenshot, but the last bool has the mouse over it, so it's darker.
code is and maybe some sort of style so it doesn't show up on the [src] link
CC: Don't have a branch but this is probably a straightforward fix if you decide on a style. Or if you like nightpool's suggestion.
I like that style, I think. I am bad at looks, though.
If there are any other decent styles worth pursuing (different brown variant, solid underline, combo, red...I'm just guess here), a quick mockup of them would allow easy compare and contrast. It would allow an easier/faster decision.
+1 from me
I'm currently playing with rustdoc. I may try to implement this once the docs are built.

Discussion:
Some(&LOCAL_CRATE) => { let len = CURRENT_LOCATION_KEY.with(|s| s.borrow().len()); let len = if len == 0 {0} else {len - 1}; <del> try!(write!(f, "<a href='{}primitive.{}.html'>", </del> <ins> try!(write!(f, "<a class='primitive' href='{}primitive.{}.html'>", </ins> repeat("../").take(len).collect::<String>(), prim.to_url_str())); needs_termination = true;

}; match loc { Some(root) => { <del> try!(write!(f, "<a href='{}{}/primitive.{}.html'>", </del> <ins> try!(write!(f, "<a class='primitive' href='{}{}/primitive.{}.html'>", </ins> root, path.0.first().unwrap(), prim.to_url_str()));

.content span.mod, .content a.mod, block a.current.mod { color: #4d76ae; } .content span.enum, .content a.enum, .block a.current.enum { color: #5e9766; } .content span.struct, .content a.struct, .block a.current.struct { color: #e53700; } <del> .content span.fn, .content a.fn, .block a.current.fn { color: #8c6067; } .content span.method, .content a.method, .block a.current.method { color: #8c6067; } .content span.tymethod, .content a.tymethod, .block a.current.tymethod { color: #8c6067; } </del> <ins> .content a.primitive { color: #39a7bf; } .content a.type { color: #e57300; } .content a.macro { color: #068000; } .content span.fn, .content a.fn, .block a.current.fn, .content span.method, .content a.method, .block a.current.method, .content span.tymethod, .content a.tymethod, .block a.current.tymethod, </ins> .content .fnname { color: #8c6067; } .block a.current.crate { font-weight: 500; }
Change:
Right now debuginfo can only be turned on or off globally. Sometimes it would be good to be able to exclude only specific functions from debuginfo, especially when they trigger a bug in rustc's or LLVM's debuginfo handling (e.g. ). This way, one would be able to still mostly use debuginfo in the presence of (localized) debuginfo issues.

Discussion:
"packed", "static_assert", "thread_local", <ins> "no_debug", </ins> // not used anywhere (!?) but apparently we want to keep them around "comment",

let (ident, fn_decl, generics, top_level_block, span, has_path) = match fnitem { ast_map::NodeItem(ref item) => { <ins> if contains_nodebug_attribute(item.attrs.as_slice()) { return FunctionDebugContext { repr: FunctionWithoutDebugInfo }; } </ins> match item.node { ast::ItemFn(fn_decl, _, _, ref generics, top_level_block) => { (item.ident, fn_decl, generics, top_level_block, item.span, true)

ast_map::NodeImplItem(ref item) => { match **item { ast::MethodImplItem(ref method) => { <ins> if contains_nodebug_attribute(method.attrs.as_slice()) { return FunctionDebugContext { repr: FunctionWithoutDebugInfo }; } </ins> (method.pe_ident(), method.pe_fn_decl(), method.pe_generics(),

ast_map::NodeTraitItem(ref trait_method) => { match **trait_method { ast::ProvidedMethod(ref method) => { <ins> if contains_nodebug_attribute(method.attrs.as_slice()) { return FunctionDebugContext { repr: FunctionWithoutDebugInfo }; } </ins> (method.pe_ident(), method.pe_fn_decl(), method.pe_generics(),

//  Utility Functions //=----------------------------------------------------------------------------- <ins> fn contains_nodebug_attribute(attributes: &[ast::Attribute]) -> bool { attributes.iter().any(|attr| { let meta_item: &ast::MetaItem = &*attr.node.value; match meta_item.node { ast::MetaWord(ref value) => value.get() == "no_debug", _ => false } }) } </ins> /// Return codemap::Loc corresponding to the beginning of the span fn span_start(cx: &CrateContext, span: Span) -> codemap::Loc { cx.sess().codemap().lookup_char_pos(span.lo)

<ins> // Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. // ignore-android: FIXME(#10381) // ignore-lldb // compile-flags:-g // gdb-command:break 'no-debug-attribute.rs':32 // gdb-command:break 'no-debug-attribute.rs':38 // gdb-command:run // gdb-command:info locals // gdb-check:No locals. // gdb-command:continue // gdb-command:info locals // gdb-check:abc = 10 // gdb-command:continue #![allow(unused_variable)] fn function_with_debuginfo() { let abc = 10u; return (); // #break } #[no_debug] fn function_without_debuginfo() { let abc = -57i32; return (); // #break } fn main() { function_without_debuginfo(); function_with_debuginfo(); } </ins>
Change:
The following code compiles: Nominating for 1.0, P-backcompat-lang. I may well just fix this along with , since the solution is likely going to be similar to what pointed out, but I want to get it on the radar.
Hmm, OK. So the code does attempt to handle this, but I don't know if it is handled in the right way. Specifically, it creates fresh region variables for each region and checks to see whether they unify. The trouble is that does unify with —it unifies if and only if and are the same region. But this is precisely what claimed to be a problem in . So I'm not sure what the right thing is to do here.
I'm going to assign to because I'm blocked on his opinion on what to do here.
Assigning P-backcompat-lang, 1.0.
Right thing to do is to use .
Argh. The right fix is to substitute some skolemized lifetimes in for the early bound regions before doing the unification rather than fresh variables.
Actually I think the problem is that we're just not calling on the inference context

Discussion:
ty::note_and_explain_type_err(tcx, terr); } } <ins> // Finally, resolve all regions. This catches wily misuses of lifetime // parameters. infcx.resolve_regions_and_report_errors(); </ins> } fn check_cast(fcx: &FnCtxt,

<ins> // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. // Tests that the trait matching code takes lifetime parameters into account. // (Issue #15517.) struct Foo<'a,'b> { x: &'a int, y: &'b int, } trait Tr { fn foo(x: Self) {} } impl<'a,'b> Tr for Foo<'a,'b> { fn foo(x: Foo<'b,'a>) { //~^ ERROR method not compatible with trait //~^^ ERROR method not compatible with trait } } fn main(){} </ins>
Change:
Compile the above (faulty) code with gives me this:
Probably related to .
Thanks for the information! Close this one.

Discussion:
<del> Subproject commit 2bd5d42c9956369132228da6409f0e68da56c51a </del> <ins> Subproject commit 2cd1b5593d26dc6a03c20f8619187ad4b2485552 </ins>

<del> Subproject commit 8ca261268068d80c0969260fff15199bad87b587 </del> <ins> Subproject commit 960d610e7f33889a2577f5f17c26f0d5c82b30df </ins>

<del> Subproject commit 3ae62681ff236d5528ef7c8c28ba7c6b2ecc6731 </del> <ins> Subproject commit 2cb0ed9ba56360949f492f9866afe8c293f9f9da </ins>

<del> Subproject commit 8888f9428fe9a48f31de6bd2cef9b9bf80791edc </del> <ins> Subproject commit a9fb7d13eadfcc5f457962731f105b97f9a7474a </ins>

<del> Subproject commit b3e2a6e6c8a3aae5b5d950c63046f23bae07096d </del> <ins> Subproject commit 7352353ae91c48b136d2ca7d03822e1448165e1e </ins>
Change:
The transmute intrinsic has some special restrictions. The check that implements these does not actually check that the function is a lang item, just looking at the name 'transmute': For defs in the local crate it appears this only happens with foreign functions called 'transmute'. From looking at the code, it looks like the cross-crate case isn't so restricted and will try to check every function called 'transmute'.
(I guess this would be an easy fix after .)

Discussion:
<ins> // Copyright 2014 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. #![crate_type = "lib"] extern { pub fn transmute(); } </ins>

<ins> // Copyright 2014 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. // aux-build:issue-15562.rs extern crate i = "issue-15562"; pub fn main() { extern { fn transmute(); } unsafe { transmute(); i::transmute(); } } // We declare this so we don't run into unresolved symbol errors // The above extern is NOT `extern "rust-intrinsic"` and thus // means it'll try to find a corresponding symbol to link to. #[no_mangle] pub extern fn transmute() {} </ins>
Change:
Currently, Servo uses snapshots generated from . This works great for self-targeting builds, but there's no support today for generating cross-compilation snapshots. This feature is required to support Servo Android test machines on Travis CI. I see that handles cross-compilation: It would be great if there were a different (?), too, to support this scenario.
If I went ahead and created such a target, is that something you would be open to?
Sounds reasonable to me!
I've started the patch to do this. There is some existing cruft from somebody making a similar half-fix previously that needs to be deleted. Doing it right I will involve switching the default behavior to package all targets, leaving the current behavior as a special case for our bots, which means we need to update the bots. It looks pretty easy though and I hope to have it done tomorrow.
Thanks! That explains the confusion I had - I kept getting halfway through it and then getting very confused because it looked like it should be doing what I wanted already.

Discussion:
$$(eval $$(call DEF_PREPARE,osx-$(1))) dist-prepare-osx-$(1): PREPARE_HOST=$(1) <del> dist-prepare-osx-$(1): PREPARE_TARGETS=$(1) </del> <ins> dist-prepare-osx-$(1): PREPARE_TARGETS=$(2) </ins> dist-prepare-osx-$(1): PREPARE_DEST_DIR=tmp/dist/pkgroot-$(1) dist-prepare-osx-$(1): PREPARE_DIR_CMD=$(DEFAULT_PREPARE_DIR_CMD) dist-prepare-osx-$(1): PREPARE_BIN_CMD=$(DEFAULT_PREPARE_BIN_CMD)

endef <del> $(foreach host,$(CFG_HOST),$(eval $(call DEF_OSX_PKG,$(host)))) </del> <ins> ifneq ($(CFG_ENABLE_DIST_HOST_ONLY),) $(foreach host,$(CFG_HOST),$(eval $(call DEF_OSX_PKG,$(host),$(host)))) else $(foreach host,$(CFG_HOST),$(eval $(call DEF_OSX_PKG,$(host),$(TARGET)))) endif </ins> dist-osx: $(foreach host,$(CFG_HOST),dist/$(PKG_NAME)-$(host).pkg)

$$(eval $$(call DEF_PREPARE,dir-$(1))) dist-install-dir-$(1): PREPARE_HOST=$(1) <del> dist-install-dir-$(1): PREPARE_TARGETS=$(1) </del> <ins> dist-install-dir-$(1): PREPARE_TARGETS=$(2) </ins> dist-install-dir-$(1): PREPARE_DEST_DIR=tmp/dist/$$(PKG_NAME)-$(1) dist-install-dir-$(1): PREPARE_DIR_CMD=$(DEFAULT_PREPARE_DIR_CMD) dist-install-dir-$(1): PREPARE_BIN_CMD=$(DEFAULT_PREPARE_BIN_CMD)

endef <ins> ifneq ($(CFG_ENABLE_DIST_HOST_ONLY),) </ins> $(foreach host,$(CFG_HOST), <del> $(eval $(call DEF_INSTALLER,$(host)))) </del> <ins> $(eval $(call DEF_INSTALLER,$(host),$(host)))) else $(foreach host,$(CFG_HOST), $(eval $(call DEF_INSTALLER,$(host),$(CFG_TARGET)))) endif </ins> dist-install-dirs: $(foreach host,$(CFG_HOST),dist-install-dir-$(host))
Change:
That is, it's not obeying the global part of the path and instead just creating a variable with the name .
cc
Oh, and moving the out of to makes compile without warning, so I guess the global boolean is just being ignored somewhere.

Discussion:
} }, _ => { <del> if enum_path.segments.len() == 1 { </del> <ins> if !enum_path.global && enum_path.segments.len() == 1 { </ins> // it could still be either an enum // or an identifier pattern, resolve // will sort it out:

<ins> // Copyright 2014 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. #![deny(warnings)] #![allow(unused_imports)] enum Foo { A } mod bar { pub fn normal(x: ::Foo) { use A; match x { A => {} } } pub fn wrong(x: ::Foo) { match x { ::A => {} } } } pub fn main() { bar::normal(A); bar::wrong(A); } </ins>
Change:
These appear all the time and result in large code bloat. At least the file and line should be combined into a static.
Also, and result in inefficient codegen and code bloat because they call into the string formatter when they don't need to.
This seems to be done for . The macro in still uses the string formatter for all invocations, but I don't even know how to use those.

Discussion:
// NOTE: remove after next snapshot #[cfg(stage0)] <ins> pub use self::fail_ as fail; // NOTE: remove after next snapshot #[cfg(stage0)] </ins> #[cold] #[inline(never)] // this is the slow path, always #[lang="fail_"] fn fail_(expr_file_line: &(&'static str, &'static str, uint)) -> ! {

#[cfg(not(stage0))] #[cold] #[inline(never)] // this is the slow path, always #[lang="fail"] <del> fn fail(expr_file_line: &(&'static str, &'static str, uint)) -> ! { </del> <ins> pub fn fail(expr_file_line: &(&'static str, &'static str, uint)) -> ! { </ins> let (expr, file, line) = *expr_file_line; let ref file_line = (file, line); format_args!(|args| -> () {

} #[cold] #[inline(never)] <del> pub fn fail_str(msg: &str, file: &(&'static str, uint)) -> ! { format_args!(|fmt| fail_fmt(fmt, file), "{}", msg) } #[cold] #[inline(never)] </del> pub fn fail_fmt(fmt: &fmt::Arguments, file_line: &(&'static str, uint)) -> ! { #[allow(ctypes)] extern {

fail!("{}", "explicit failure") ); ($msg:expr) => ({ <del> static _FILE_LINE: (&'static str, uint) = (file!(), line!()); ::core::failure::fail_str($msg, &_FILE_LINE) </del> <ins> static _MSG_FILE_LINE: (&'static str, &'static str, uint) = ($msg, file!(), line!()); ::core::failure::fail(&_MSG_FILE_LINE) </ins> }); ($fmt:expr, $($arg:tt)*) => ({ // a closure can't have return type !, so we need a full

pub fn expect(self, msg: &str) -> T { match self { Some(val) => val, <del> None => fail!(msg), </del> <ins> None => fail!("{}", msg), </ins> } }
Change:
We currently emit vec growth glue, but it is called using the push/pop mechanism (e.g. of transcallglue). In reality, the only call site for this glue is generated when translating vec append statements, so it really is user-level glue and need not adhere to the "worst-case glue-call args" max argument count. The fact that we don't do this costs us one extra word of worst-case glue-call args at the moment (7 words instead of the 6 we'd need otherwise). This is a relatively minor issue, but now noted.
WONTFIX (not required for bootstrapping)

Discussion:
rustup toolchain install --profile minimal nightly-${TOOLCHAIN} # Sanity check to see if the nightly exists echo nightly-${TOOLCHAIN} > rust-toolchain <del> echo "=> Uninstalling all old nighlies" </del> <ins> echo "=> Uninstalling all old nightlies" </ins> for nightly in $(rustup toolchain list | grep nightly | grep -v $TOOLCHAIN | grep -v nightly-x86_64); do rustup toolchain uninstall $nightly done