jiebi/CodeConvo huggingface dataset:
Change:
According to the manual, multiple comma-separated attributes may be specified within a single pair of square brackets. The parser does not do this at present (). Which one is correct? Use case:
I believe the manual is correct in this case, that looks like it should be a valid attribute.
But, which is the behaviour we want?
Yes, I could imagine either scheme becoming blessed as the preferred style, so I feel this needs more discussion if it hasn't already been decided. Either way, there will need to be a test to preserve the preferred style in the future.
Nominating.
Not a 1.0 milestone issue, Asssigning P-low.
IMO, we should not accept a comma in attributes. We never used that feature, I've long wanted to remove it, and didn't realize that it was broken.

Discussion:
## Attributes ~~~~ {.notrust .ebnf .gram} <del> attribute : '#' '!' ? '[' attr_list ']' ; attr_list : attr [ ',' attr_list ]* ; attr : ident [ '=' literal | '(' attr_list ')' ] ? ; </del> <ins> attribute : '#' '!' ? '[' meta_item ']' ; meta_item : ident [ '=' literal | '(' meta_seq ')' ] ? ; meta_seq : meta_item [ ',' meta_seq ]* ; </ins> ~~~~ Static entities in Rust &mdash; crates, modules and items &mdash; may have _attributes_
Change:
Currently we can write but not nor It would be nice to have these irrefutable patterns work in parameter specifications, if not in all functions then at least in Ruby-like blocks.
I think this is a good idea. It was agreed on to support this during the Toronto meeting, but when I was implementing destructuring bindings I somehow forgot about it. There are some awkward corners to be decided on (we allow param names in fn types -- will we also allow pointless patterns there?), but on the whole this should be straightforward to implement. (Though a lot of code will have to be touched.)
Ack! I think I closed this by mistake. However, I think this is a dup of , so I'm going to leave it closed.

Discussion:
} /// A convenience macro for logging at the debug log level. This macro can also <del> /// be omitted at compile time by passing `--cfg ndebug` to the compiler. If </del> <ins> /// be omitted at compile time by passing `-C debug-assertions` to the compiler. If </ins> /// this option is not passed, then debug statements will be compiled. /// /// # Examples
Change:
Example: The last statement is mutably borrowing x but x is already borrowed (or rather should be) by the proc. The result is a program that compiles fine but segfaults when run.
cc Nominating, closure shouldn't be able to capture borrowed variables.
I'm pretty sure the proc "code" needs a thorough review, giving this issue along with all the other similar proc bugs.
cc
P-backcompat-lang, 1.0.

Discussion:
let dirp = cfg.cwd.map(|c| c.with_ref(|p| p)).unwrap_or(ptr::null()); <ins> let cfg = unsafe { mem::transmute::<ProcessConfig,ProcessConfig<'static>>(cfg) }; </ins> with_envp(cfg.env, proc(envp) { with_argv(cfg.program, cfg.args, proc(argv) unsafe { let (mut input, mut output) = try!(pipe());

let fty = ty::node_id_to_type(cx.tcx, id); match ty::get(fty).sty { ty::ty_closure(box ty::ClosureTy { <del> store: ty::UniqTraitStore, bounds, .. }) => b(|cx, fv| check_for_uniq(cx, fv, bounds)), </del> <ins> store: ty::UniqTraitStore, bounds: mut bounds, .. }) => { // Procs can't close over non-static references! bounds.add(ty::BoundStatic); b(|cx, fv| check_for_uniq(cx, fv, bounds)) } </ins> ty::ty_closure(box ty::ClosureTy { store: ty::RegionTraitStore(region, _), bounds, ..

<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 = Some(1); let mut p: proc(&mut Option<int>) = proc(_) {}; match x { Some(ref y) => { p = proc(z: &mut Option<int>) { *z = None; let _ = y; //~^ ERROR cannot capture variable of type `&int`, which does not fulfill `'static` }; } None => {} } p(&mut x); } </ins>
Change:
We're not comparing stage2 and stage3 at the moment, and the amount of bugs caught by that extra stage that wouldn't be caught in stage2 is probably very small. We could shave off some cycle time by only going to stage2, and doing a stage3 check only on checkpoints.
Fixed in .

Discussion:
define DEF_RUSTC_TARGET # $(1) == architecture <del> rustc-H-$(1): rustc-stage3-H-$(1) </del> <ins> rustc-H-$(1): rustc-stage2-H-$(1) </ins> endef $(foreach host,$(CFG_TARGET_TRIPLES),			

endif # The stage we install from <del> ISTAGE = 3 </del> <ins> ISTAGE = 2 </ins> PREFIX_ROOT = $(CFG_PREFIX) PREFIX_BIN = $(PREFIX_ROOT)/bin

# Shorthand for build/stageN/bin HB = $(HBIN$(ISTAGE)_H_$(CFG_HOST_TRIPLE)) <ins> HB3 = $(HBIN3_H_$(CFG_HOST_TRIPLE)) </ins> # Shorthand for build/stageN/lib HL = $(HLIB$(ISTAGE)_H_$(CFG_HOST_TRIPLE)) # Shorthand for the prefix bin directory

$(Q)mkdir -p $(PREFIX_BIN) $(Q)mkdir -p $(PREFIX_LIB) $(Q)mkdir -p $(PREFIX_ROOT)/share/man/man1 <del> $(Q)$(call INSTALL,$(HB),$(PHB),rustc$(X)) $(Q)$(call INSTALL,$(HB),$(PHB),cargo$(X)) $(Q)$(call INSTALL,$(HB),$(PHB),rustdoc$(X)) </del> <ins> $(Q)$(call INSTALL,$(HB3),$(PHB),rustc$(X)) $(Q)$(call INSTALL,$(HB3),$(PHB),cargo$(X)) $(Q)$(call INSTALL,$(HB3),$(PHB),rustdoc$(X)) </ins> $(Q)$(call INSTALL,$(HL),$(PHL),$(CFG_RUNTIME)) $(Q)$(call INSTALL_LIB,$(HL),$(PHL),$(CORELIB_GLOB)) $(Q)$(call INSTALL_LIB,$(HL),$(PHL),$(STDLIB_GLOB))

# Main test targets ###################################################################### <del> check: all tidy check-stage3  </del> <ins> check: all tidy check-stage2  </ins> check-full: all tidy check-stage1 check-stage2 check-stage3
Change:
Consider this code: The error is: It'd be nice if the explicit ref wasn't required in this case.
cc
This has now been fixed.
I believe this is covered by

Discussion:
<ins> // Copyright 2015 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: Sized { fn foo(self) {} } trait Bar: Sized { fn bar(self) {} } struct S; impl<'l> Foo for &'l S {} impl<T: Foo> Bar for T {} fn main() { let s = S; s.foo(); (&s).bar(); s.bar(); } </ins>
Change:
They're currently very restricted as they only work with a single iterator type for both arguments, so, e.g. doesn't work. It should be easy to just add another parameter for the second argument.

Discussion:
use super::Iterator; /// Compare `a` and `b` for equality using `TotalEq` <del> pub fn equals<A: TotalEq, T: Iterator<A>>(mut a: T, mut b: T) -> bool { </del> <ins> pub fn equals<A: TotalEq, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool { </ins> loop { match (a.next(), b.next()) { (None, None) => return true,

} /// Order `a` and `b` lexicographically using `TotalOrd` <del> pub fn cmp<A: TotalOrd, T: Iterator<A>>(mut a: T, mut b: T) -> cmp::Ordering { </del> <ins> pub fn cmp<A: TotalOrd, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> cmp::Ordering { </ins> loop { match (a.next(), b.next()) { (None, None) => return cmp::Equal,

} /// Compare `a` and `b` for equality (Using partial equality, `Eq`) <del> pub fn eq<A: Eq, T: Iterator<A>>(mut a: T, mut b: T) -> bool { </del> <ins> pub fn eq<A: Eq, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool { </ins> loop { match (a.next(), b.next()) { (None, None) => return true,

} /// Compare `a` and `b` for nonequality (Using partial equality, `Eq`) <del> pub fn ne<A: Eq, T: Iterator<A>>(mut a: T, mut b: T) -> bool { </del> <ins> pub fn ne<A: Eq, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool { </ins> loop { match (a.next(), b.next()) { (None, None) => return false,

} /// Return `a` < `b` lexicographically (Using partial order, `Ord`) <del> pub fn lt<A: Ord, T: Iterator<A>>(mut a: T, mut b: T) -> bool { </del> <ins> pub fn lt<A: Ord, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool { </ins> loop { match (a.next(), b.next()) { (None, None) => return false,

} /// Return `a` <= `b` lexicographically (Using partial order, `Ord`) <del> pub fn le<A: Ord, T: Iterator<A>>(mut a: T, mut b: T) -> bool { </del> <ins> pub fn le<A: Ord, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool { </ins> loop { match (a.next(), b.next()) { (None, None) => return true,

} /// Return `a` > `b` lexicographically (Using partial order, `Ord`) <del> pub fn gt<A: Ord, T: Iterator<A>>(mut a: T, mut b: T) -> bool { </del> <ins> pub fn gt<A: Ord, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool { </ins> loop { match (a.next(), b.next()) { (None, None) => return false,

} /// Return `a` >= `b` lexicographically (Using partial order, `Ord`) <del> pub fn ge<A: Ord, T: Iterator<A>>(mut a: T, mut b: T) -> bool { </del> <ins> pub fn ge<A: Ord, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool { </ins> loop { match (a.next(), b.next()) { (None, None) => return true,

assert!(gt(c.iter(), b.iter()) == (c[0] >  b[0])); assert!(ge(c.iter(), b.iter()) == (c[0] >= b[0])); } <ins> #[test] fn test_multi_iter() { use slice::ImmutableVector; use iter::DoubleEndedIterator; let xs = [1i,2,3,4]; let ys = [4i,3,2,1]; assert!(eq(xs.iter(), ys.iter().rev())); assert!(lt(xs.iter(), xs.iter().skip(2))); } </ins> } #[cfg(test)]
Change:
I don't exactly know what terminology to use to describe this bug; feel free to update the title to reflect reality... This was something I encountered while using bjz's ; this test is derived from that library (but independent of it). Transcript of compilation attempt: we would actually manage to properly assign to the type of , since I do not see any reason for the generic float type to be constrained to . (Note that if you add a type annotation to the then compilation terminates successfully.) even if we cannot accomplish that goal for some hypothetical reason, we still need to a better job with the error message here. Note also that the is necessary to reproduce the poor-quality error message given here. If you remove it, you get this instead: (which also is not great, but at least then I have a hint that my problem originates with some use of a generic float literal somewhere in my code.
Inference is totally different now, does this issue still persist, ?
The following compiles successfully now:

Discussion:
<ins> // Copyright 2015 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. #[derive(Debug)] struct Matrix4<S>(S); trait POrd<S> {} fn translate<S: POrd<S>>(s: S) -> Matrix4<S> { Matrix4(s) } impl POrd<f32> for f32 {} impl POrd<f64> for f64 {} fn main() { let x = 1.0; let m : Matrix4<f32> = translate(x); println!("m: {:?}", m); } </ins>
Change:
Nominating for P-backcompat-lang as a borrow check bug
cc
cc me
0 P-backcompat-lang.
Also, it doesn't fail when using instead of :
I think is actually irrelevant to the real bug here. The assignment shouldn't be allowed while exists since the immutable borrow freezes everything. It seems to still work with , so maybe the owned pointer version just got lost in the to transition.
Side note: the current Redex model correctly rejects this code (yay!).
I have a simple fix for this: I'm testing on top of a lot of other borrowck changes, but this code in particular wasn't modified. I'll add a test, try again on master, and submit a PR.
theoretically the to transition was just renaming the syntax, I believe is still represented in the compiler in exactly the same way that was. (Maybe could try this code on the last pre--removal compiler (or anything before that) to see if it was rejected then.)
I just figured we would have run into not actually freezing pointers a long time ago, but it's possible I suppose.

Discussion:
// with inherited mutability and with `&mut` // pointers. LpExtend(ref lp_base, mc::McInherited, _) | <ins> LpExtend(ref lp_base, _, LpDeref(mc::OwnedPtr)) | LpExtend(ref lp_base, _, LpDeref(mc::GcPtr)) | </ins> LpExtend(ref lp_base, _, LpDeref(mc::BorrowedPtr(ty::MutBorrow, _))) => { lp_base.clone() }

<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. // This tests that we can't modify Box<&mut T> contents while they // are borrowed. struct A { a: int } struct B<'a> { a: Box<&'a mut int> } fn borrow_in_var_from_var() { let mut x: int = 1; let y = box &mut x; let p = &y; let q = &***p; **y = 2; //~ ERROR cannot assign to `**y` because it is borrowed drop(p); drop(q); } fn borrow_in_var_from_field() { let mut x = A { a: 1 }; let y = box &mut x.a; let p = &y; let q = &***p; **y = 2; //~ ERROR cannot assign to `**y` because it is borrowed drop(p); drop(q); } fn borrow_in_field_from_var() { let mut x: int = 1; let y = B { a: box &mut x }; let p = &y.a; let q = &***p; **y.a = 2; //~ ERROR cannot assign to `**y.a` because it is borrowed drop(p); drop(q); } fn borrow_in_field_from_field() { let mut x = A { a: 1 }; let y = B { a: box &mut x.a }; let p = &y.a; let q = &***p; **y.a = 2; //~ ERROR cannot assign to `**y.a` because it is borrowed drop(p); drop(q); } fn main() { borrow_in_var_from_var(); borrow_in_var_from_field(); borrow_in_field_from_var(); borrow_in_field_from_field(); } </ins>
Change:
This is one of those bugs where an earlier error is leading to poor error reporting later on in the output. So it should not be considered high priority. Nonetheless, it would be nice if we could strive for error messages to be sane when considered in isolation, which this example violates: Transcript: The issue is that the second message claims that does not have a field named , but it clearly does. I could understand this message if it said vec2 does not have a field named .

Discussion:
/// `etc` is true if the pattern said '...' and false otherwise. pub fn check_struct_pat_fields(pcx: &pat_ctxt, span: Span, <del> path: &ast::Path, </del> fields: &[ast::FieldPat], <del> class_fields: Vec<ty::field_ty> , </del> <ins> class_fields: Vec<ty::field_ty>, </ins> class_id: ast::DefId, substitutions: &ty::substs, etc: bool) {

found_fields.insert(index); } None => { <del> let name = pprust::path_to_str(path); </del> // Check the pattern anyway, so that attempts to look // up its type won't fail check_pat(pcx, field.pat, ty::mk_err()); tcx.sess.span_err(span, format!("struct `{}` does not have a field named `{}`", <del> name, </del> <ins> ty::item_path_str(tcx, class_id), </ins> token::get_ident(field.ident)).as_slice()); } }

} } <del> check_struct_pat_fields(pcx, span, path, fields, class_fields, struct_id, </del> <ins> check_struct_pat_fields(pcx, span, fields, class_fields, struct_id, </ins> substitutions, etc); }

// Get the struct fields from this struct-like enum variant. let class_fields = ty::lookup_struct_fields(tcx, variant_id); <del> check_struct_pat_fields(pcx, span, path, fields, class_fields, </del> <ins> check_struct_pat_fields(pcx, span, fields, class_fields, </ins> variant_id, substitutions, etc); } Some(&ast::DefStruct(..)) | Some(&ast::DefVariant(..)) => {

<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. struct vec2 { y: f32 } struct vec3 { y: f32, z: f32 } fn make(v: vec2) { let vec3 { y: _, z: _ } = v; //~^ ERROR mismatched types: expected `vec2` but found `vec3` //~^^ ERROR struct `vec2` does not have a field named `z` } fn main() { } </ins>  No newline at end of file
Change:
The source file CUs should not be nested in the crate CU. They should be separate: first the crate-file CU, then the source-file CUs, in sequence. This will probably not break much, possibly the crate reader will need to change a bit in the runtime. Apparently the nesting is not something other dwarf-speakers expect.
(a) fixed ages ago, (b) obsolete since we're dropping DWARF of this sort

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:
See I propose to change the license of Non trivial contributors: OK OK Contributors appearing in git blame that are trivial (trivial update due to language changes): OK OK (sent agreement to by email) OK OK Contributors with removed and trivial contributions are not considered. For the persons that are not in "OK" state, please respond to this issue saying: Then, I'll propose the corresponding PR. Thanks.
Yes I am a MoCo employee, you don't have to worry about me for this or future benchmark relicensing issues.
Thanks On Jun 7, 2014 5:06 AM, "TeXitoi" wrote:

Discussion:
"libsync/mpsc_intrusive.rs", # BSD "test/bench/shootout-fannkuch-redux.rs", # BSD "test/bench/shootout-meteor.rs", # BSD <ins> "test/bench/shootout-pidigits.rs", # BSD </ins> "test/bench/shootout-regex-dna.rs", # BSD ]

<del> // Copyright 2013 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. </del> <ins> // The Computer Language Benchmarks Game // http://benchmarksgame.alioth.debian.org/ </ins> // <del> // 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. </del> <ins> // contributed by the Rust Project Developers // Copyright (c) 2013-2014 The Rust Project Developers // // All rights reserved. // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions // are met: // // - Redistributions of source code must retain the above copyright //   notice, this list of conditions and the following disclaimer. // // - Redistributions in binary form must reproduce the above copyright //   notice, this list of conditions and the following disclaimer in //   the documentation and/or other materials provided with the //   distribution. // // - Neither the name of "The Computer Language Benchmarks Game" nor //   the name of "The Computer Language Shootout Benchmarks" nor the //   names of its contributors may be used to endorse or promote //   products derived from this software without specific prior //   written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS // FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE // COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) // HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, // STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED // OF THE POSSIBILITY OF SUCH DAMAGE. </ins> extern crate num;
Change:
Apparently the GNU tools expect VMA and LMA of .debuginfo / .debugabbrev to be zero. I'm not sure why we haven't seen this yet, but tromey reports this is crashing his copies of readelf and gdb. Odd!
Zero LMA/VMA of debug sections in elf. Closed 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:
For some reason, trying to place two trait objects with the same templated lifetime into a struct confuses borrowck: This does NOT occur with references to primitive types (tested w/ int). It also does NOT occur if there is only one trait object reference. This is currently holding up progress on red (my text editor in Rust), so a rapid fix would be very helpful. Thanks in advance.
In an absolutely baffling turn of events, using tuple-like structs works fine. The below compiles happily... This is a usable workaround for the time being, but really only raises more questions as to what exactly is going on in the borrow checker.
cc me
This compiles as of .

Discussion:
<ins> // Copyright 2015 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 SomeTrait {} struct Meow; impl SomeTrait for Meow {} struct Foo<'a> { x: &'a SomeTrait, y: &'a SomeTrait, } impl<'a> Foo<'a> { pub fn new<'b>(x: &'b SomeTrait, y: &'b SomeTrait) -> Foo<'b> { Foo { x: x, y: y } } } fn main() { let r = Meow; let s = Meow; let q = Foo::new(&r as &SomeTrait, &s as &SomeTrait); } </ins>
Change:
Native type identifiers are global, not crate-relative. This doesn't seem easy to typecheck because of the diamond import problem: Suppose: Crate A defines a native type foo; Crate B imports A and exports A.foo; Crate C imports A and exports A.foo; Crate D imports B and C and unifies B.foo and C.foo. B.foo and C.foo won't be considered compatible. Instead of having one global value set, we could subject them to crate-relative name resolution, just like any other type. In other words, we would have e.g. "TYnative of crateid * native_id".
WONTFIX (not required for bootstrapping; code in rustc is all different. defs are all crate-relative there).

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