rust - https://github.com/rust-lang/rust

Age	Commit message (Collapse)	Author	Lines
2019-07-27	tests: Move run-pass tests without naming conflicts to ui	Vadim Petrochenkov	-23/+0

2019-07-27	tests: Add missing run-pass annotations	Vadim Petrochenkov	-0/+2

2018-12-25	Remove licenses	Mark Rousskov	-11/+0

2015-04-08	Remove pretty-expanded from failing tests	Alex Crichton	-1/+0
	This commit removes pretty-expanded from all tests that wind up calling panic! one way or another now that its internals are unstable.
2015-04-01	Fallout in tests	Niko Matsakis	-1/+1

2015-03-26	Mass rename uint/int to usize/isize	Alex Crichton	-2/+2
	Now that support has been removed, all lingering use cases are renamed.
2015-03-23	rustdoc: Replace no-pretty-expanded with pretty-expanded	Brian Anderson	-0/+2
	Now that features must be declared expanded source often does not compile. This adds 'pretty-expanded' to a bunch of test cases that still work.
2015-01-25	cleanup: s/impl Copy/#[derive(Copy)]/g	Jorge Aparicio	-2/+1

2014-12-08	librustc: Make `Copy` opt-in.	Niko Matsakis	-0/+2
	This change makes the compiler no longer infer whether types (structures and enumerations) implement the `Copy` trait (and thus are implicitly copyable). Rather, you must implement `Copy` yourself via `impl Copy for MyType {}`. A new warning has been added, `missing_copy_implementations`, to warn you if a non-generic public type has been added that could have implemented `Copy` but didn't. For convenience, you may temporarily opt out of this behavior by using `#![feature(opt_out_copy)]`. Note though that this feature gate will never be accepted and will be removed by the time that 1.0 is released, so you should transition your code away from using it. This breaks code like: #[deriving(Show)] struct Point2D { x: int, y: int, } fn main() { let mypoint = Point2D { x: 1, y: 1, }; let otherpoint = mypoint; println!("{}{}", mypoint, otherpoint); } Change this code to: #[deriving(Show)] struct Point2D { x: int, y: int, } impl Copy for Point2D {} fn main() { let mypoint = Point2D { x: 1, y: 1, }; let otherpoint = mypoint; println!("{}{}", mypoint, otherpoint); } This is the backwards-incompatible part of #13231. Part of RFC #3. [breaking-change]
2014-10-23	Fix codegen breaking aliasing rules for functions with sret results	Björn Steinbrink	-0/+30
	This reverts commit a0ec902e239b2219edf1a18b036dd32c18d3be42 "Avoid unnecessary temporary on assignments". Leaving out the temporary for the functions return value can lead to a situation that conflicts with rust's aliasing rules. Given this: ````rust fn func(f: &mut Foo) -> Foo { /* ... / } fn bar() { let mut foo = Foo { / ... */ }; foo = func(&mut foo); } ```` We effectively get two mutable references to the same variable `foo` at the same time. One for the parameter `f`, and one for the hidden out-pointer. So we can't just `trans_into` the destination directly, but must use `trans` to get a new temporary slot from which the result can be copied.