rust/src/librustc/middle/trans/datum.rs, branch beta

Move trans, back, driver, and back into a new crate, rustc_trans. Reduces memory usage significantly and opens opportunities for more parallel compilation.

2014-11-18T12:32:43+00:00

Switch to purely namespaced enums

2014-11-17T15:35:51+00:00

This breaks code that referred to variant names in the same namespace as their enum. Reexport the variants in the old location or alter code to refer to the new locations: ``` pub enum Foo { A, B } fn main() { let a = A; } ``` => ``` pub use self::Foo::{A, B}; pub enum Foo { A, B } fn main() { let a = A; } ``` or ``` pub enum Foo { A, B } fn main() { let a = Foo::A; } ``` [breaking-change]

Remove ty_bot from the type system

2014-10-28T16:54:16+00:00

We now instead use a fresh variable for expressions that diverge.

librustc: Remove all uses of {:?}.

2014-10-16T15:15:34+00:00

rustc: remove support for Gc.

2014-10-02T13:59:31+00:00

rustc: fix fallout from the addition of a 'tcx lifetime on trans::Block.

2014-09-08T12:28:24+00:00

make CrateContext fields private

2014-09-05T16:18:53+00:00

Schedule cleanup for &* on fat owned pointers

2014-09-02T20:29:33+00:00

For example `let _x: &Trait = &*(box Foo as Box);`. There was a bug where no cleanup would be scheduled by the deref. No test because cleanup-auto-borrow-obj.rs is a test for this once we remove trait cross-borrowing (done on another branch).

Rebasing changes

2014-08-26T04:07:32+00:00

DST coercions and DST structs

2014-08-26T00:38:51+00:00

[breaking-change] 1. The internal layout for traits has changed from (vtable, data) to (data, vtable). If you were relying on this in unsafe transmutes, you might get some very weird and apparently unrelated errors. You should not be doing this! Prefer not to do this at all, but if you must, you should use raw::TraitObject rather than hardcoding rustc's internal representation into your code. 2. The minimal type of reference-to-vec-literals (e.g., `&[1, 2, 3]`) is now a fixed size vec (e.g., `&[int, ..3]`) where it used to be an unsized vec (e.g., `&[int]`). If you want the unszied type, you must explicitly give the type (e.g., `let x: &[_] = &[1, 2, 3]`). Note in particular where multiple blocks must have the same type (e.g., if and else clauses, vec elements), the compiler will not coerce to the unsized type without a hint. E.g., `[&[1], &[1, 2]]` used to be a valid expression of type '[&[int]]'. It no longer type checks since the first element now has type `&[int, ..1]` and the second has type &[int, ..2]` which are incompatible. 3. The type of blocks (including functions) must be coercible to the expected type (used to be a subtype). Mostly this makes things more flexible and not less (in particular, in the case of coercing function bodies to the return type). However, in some rare cases, this is less flexible. TBH, I'm not exactly sure of the exact effects. I think the change causes us to resolve inferred type variables slightly earlier which might make us slightly more restrictive. Possibly it only affects blocks with unreachable code. E.g., `if ... { fail!(); "Hello" }` used to type check, it no longer does. The fix is to add a semicolon after the string.