---

yaml
---
r: 81694
b: refs/heads/master
c: 85c0fb7
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: fadc6cc4b006d0eb6250afb899f10f8b67ad546d
+refs/heads/master: 85c0fb7b8a81fc48a2155decd20abf16b1c5eeb6
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6c08cc2db4f98e9f07ae7d50338396c4123c2f0a
 refs/heads/try: 70152ff55722878cde684ee6462c14c65f2c4729

trunk/RELEASES.txt

@@ -1,3 +1,148 @@
+Version 0.8 (October 2013)
+--------------------------
+
+   * ~2100 changes, numerous bugfixes
+
+   * Language
+      * The `for` loop syntax has changed to work with the `Iterator` trait.
+      * At long last, unwinding works on Windows.
+      * Default methods definitely mostly work.
+      * Many trait inheritance bugs fixed.
+      * Owned and borrowed trait objects work more reliably.
+      * `copy` is no longer a keyword. It has been replaced by the `Clone` trait.
+      * rustc no longer emits code for the `debug!` macro unless it is passed
+        `--cfg debug`
+      * mod.rs is now "blessed". When loading `mod foo;`, rustc will now look
+        for foo.rs, then foo/mod.rs, and will generate an error when both are
+        present.
+      * Strings no longer contain trailing nulls. The new `std::c_str` module
+        provides new mechanisms for converting to C strings.
+      * The type of foreign functions is now `extern "C" fn` instead of `*u8'.
+      * The FFI has been overhauled such that foreign functions are called directly,
+        instead of through a stack-switching wrapper.
+      * Calling a foreign function must be done through a Rust function with the
+        `#[fixed_stack_segment]` attribute.
+      * The `externfn!` macro can be used to declare both a foreign function and
+        a `#[fixed_stack_segment]` wrapper at once.
+      * `pub` and `priv` modifiers on `extern` blocks are no longer parsed.
+      * `unsafe` is no longer allowed on extern fns - they are all unsafe.
+      * `priv` is disallowed everywhere except for struct fields and enum variants.
+      * `&T` (besides `&'static T`) is no longer allowed in `@T`.
+      * `ref` bindings in irrefutable patterns work correctly now.
+      * `char` is now prevented from containing invalid code points.
+      * Casting to `bool` is no longer allowed.
+      * `yield` is a reserved keyword.
+      * `typeof` is a reserved keyword.
+      * Crates may be imported by URL with `extern mod foo = "url";`.
+      * Explicit enum discriminants may be given as uints as in `enum E { V = 0u }`
+      * Static vectors can be initialized with repeating elements,
+        e.g. `static foo: [u8, .. 100]: [0, .. 100];`.
+      * Static structs can be initialized with functional record update,
+        e.g. `static foo: Foo = Foo { a: 5, .. bar };`.
+      * `cfg!` can be used to conditionally execute code based on the crate
+        configuration, similarly to `#[cfg(...)]`.
+      * The `unnecessary_qualification` lint detects unneeded module
+        prefixes (default: allow).
+      * Arithmetic operations have been implemented on the SIMD types in
+        `std::unstable::simd`.
+      * Exchange allocation headers were removed, reducing memory usage.
+      * `format!` implements a completely new, extensible, and higher-performance
+        string formatting system. It will replace `fmt!`.
+      * `print!` and `println!` write formatted strings (using the `format!`
+        extension) to stdout.
+      * `write!` and `writeln!` write formatted strings (using the `format!`
+        extension) to the new Writers in `std::rt::io`.
+      * The library section in which a function or static is placed may
+        be specified with `#[link_section = "..."]`.
+      * The `proto!` syntax extension for defining bounded message protocols
+        was removed.
+      * `macro_rules!` is hygenic for `let` declarations.
+      * The `#[export_name]` attribute specifies the name of a symbol.
+      * `unreachable!` can be used to indicate unreachable code, and fails
+        if executed.
+
+   * Libraries
+      * std: Transitioned to the new runtime, written in Rust.
+      * std: Added an experimental I/O library, `rt::io`, based on the new
+        runtime.
+      * std: A new generic `range` function was added to the prelude, replacing
+        `uint::range` and friends.
+      * std: `range_rev` no longer exists. Since range is an iterator it can be
+        reversed with `range(lo, hi).invert()`.
+      * std: The `chain` method on option renamed to `and_then`; `unwrap_or_default`
+        renamed to `unwrap_or`.
+      * std: The `iterator` module was renamed to `iter`.
+      * std: Integral types now support the `checked_add`, `checked_sub`, and
+        `checked_mul` operations for detecting overflow.
+      * std: Many methods in `str`, `vec`, `option, `result` were renamed for
+        consistency.
+      * std: Methods are standardizing on conventions for casting methods:
+        `to_foo` for copying, `into_foo` for moving, `as_foo` for temporary
+        and cheap casts.
+      * std: The `CString` type in `c_str` provides new ways to convert to and
+        from C strings.
+      * std: `DoubleEndedIterator` can yield elements in two directions.
+      * std: The `mut_split` method on vectors partitions an `&mut [T]` into
+        two splices.
+      * std: `str::from_bytes` renamed to `str::from_utf8`.
+      * std: `pop_opt` and `shift_opt` methods added to vectors.
+      * std: The task-local data interface no longer uses @, and keys are
+        no longer function pointers.
+      * std: The `swap_unwrap` method of `Option` renamed to `take_unwrap`.
+      * std: Added `SharedPort` to `comm`.
+      * std: `Eq` has a default method for `ne`; only `eq` is required
+        in implementations.
+      * std: `Ord` has default methods for `le`, `gt` and `le`; only `lt`
+        is required in implementations.
+      * std: `is_utf8` performance is improved, impacting many string functions.
+      * std: `os::MemoryMap` provides cross-platform mmap.
+      * std: `ptr::offset` is now unsafe, but also more optimized. Offsets that
+        are not 'in-bounds' are considered undefined.
+      * std: Many freestanding functions in `vec` removed in favor of methods.
+      * std: Many freestanding functions on scalar types removed in favor of
+        methods.
+      * std: Many options to task builders were removed since they don't make
+        sense in the new scheduler design.
+      * std: More containers implement `FromIterator` so can be created by the
+        `collect` method.
+      * std: More complete atomic types in `unstable::atomics`.
+      * std: `comm::PortSet` removed.
+      * std: Mutating methods in the `Set` and `Map` traits have been moved into
+        the `MutableSet` and `MutableMap` traits. `Container::is_empty`,
+        `Map::contains_key`, `MutableMap::insert`, and `MutableMap::remove` have
+        default implementations.
+      * extra: `dlist`, the doubly-linked list was modernized.
+      * extra: Added a `hex` module with `ToHex` and `FromHex` traits.
+      * extra: Added `glob` module, replacing `std::os::glob`.
+      * extra: `rope` was removed.
+      * extra: `deque` was renamed to `ringbuf`. `RingBuf` implements `Deque`.
+      * extra: `net`, and `timer` were removed. The experimental replacements
+        are `std::rt::io::net` and `std::rt::io::timer`.
+      * extra: Iterators implemented for `SmallIntMap`.
+      * extra: Iterators implemented for `Bitv` and `BitvSet`.
+      * extra: `SmallIntSet` removed. Use `BitvSet`.
+      * extra: Performance of JSON parsing greatly improved.
+      * extra: `semver` updated to SemVer 2.0.0.
+      * extra: `term` handles more terminals correctly.
+      * extra: `dbg` module removed.
+
+   * Other
+      * rustc's debug info generation (`-Z debug-info`) is greatly improved.
+      * rustc accepts `--target-cpu` to compile to a specific CPU architecture,
+        similarly to gcc's `--march` flag.
+      * rustpkg has received many improvements.
+      * rustpkg supports git tags as package IDs.
+      * rustpkg builds into target-specific directories so it can be used for
+        cross-compiling.
+      * The number of concurrent test tasks is controlled by the environment
+        variable RUST_TEST_TASKS.
+      * The test harness can now report metrics for benchmarks.
+      * All tools have man pages.
+      * Programs compiled with `--test` now support the `-h` and `--help` flags.
+      * The runtime uses jemalloc for allocations.
+      * Segmented stacks are temporarily disabled as part of the transition to
+        the new runtime. Stack overflows are possible!
+
 Version 0.7 (July 2013)
 -----------------------
 

trunk/src/librustc/middle/lang_items.rs

@@ -59,36 +59,36 @@ pub enum LangItem {
 
     StrEqFnLangItem,                   // 19
     UniqStrEqFnLangItem,               // 20
-    FailFnLangItem,                    // 22
-    FailBoundsCheckFnLangItem,         // 23
-    ExchangeMallocFnLangItem,          // 24
-    ClosureExchangeMallocFnLangItem,   // 25
-    ExchangeFreeFnLangItem,            // 26
-    MallocFnLangItem,                  // 27
-    FreeFnLangItem,                    // 28
-    BorrowAsImmFnLangItem,             // 29
-    BorrowAsMutFnLangItem,             // 30
-    ReturnToMutFnLangItem,             // 31
-    CheckNotBorrowedFnLangItem,        // 32
-    StrDupUniqFnLangItem,              // 33
-    RecordBorrowFnLangItem,            // 34
-    UnrecordBorrowFnLangItem,          // 35
-
-    StartFnLangItem,                   // 36
-
-    TyDescStructLangItem,              // 37
-    TyVisitorTraitLangItem,            // 38
-    OpaqueStructLangItem,              // 39
+    FailFnLangItem,                    // 21
+    FailBoundsCheckFnLangItem,         // 22
+    ExchangeMallocFnLangItem,          // 23
+    ClosureExchangeMallocFnLangItem,   // 24
+    ExchangeFreeFnLangItem,            // 25
+    MallocFnLangItem,                  // 26
+    FreeFnLangItem,                    // 27
+    BorrowAsImmFnLangItem,             // 28
+    BorrowAsMutFnLangItem,             // 29
+    ReturnToMutFnLangItem,             // 30
+    CheckNotBorrowedFnLangItem,        // 31
+    StrDupUniqFnLangItem,              // 32
+    RecordBorrowFnLangItem,            // 33
+    UnrecordBorrowFnLangItem,          // 34
+
+    StartFnLangItem,                   // 35
+
+    TyDescStructLangItem,              // 36
+    TyVisitorTraitLangItem,            // 37
+    OpaqueStructLangItem,              // 38
 }
 
 pub struct LanguageItems {
-    items: [Option<DefId>, ..41]
+    items: [Option<DefId>, ..39]
 }
 
 impl LanguageItems {
     pub fn new() -> LanguageItems {
         LanguageItems {
-            items: [ None, ..41 ]
+            items: [ None, ..39 ]
         }
     }
 
@@ -122,27 +122,26 @@ impl LanguageItems {
 
             19 => "str_eq",
             20 => "uniq_str_eq",
-            21 => "log_type",
-            22 => "fail_",
-            23 => "fail_bounds_check",
-            24 => "exchange_malloc",
-            25 => "closure_exchange_malloc",
-            26 => "exchange_free",
-            27 => "malloc",
-            28 => "free",
-            29 => "borrow_as_imm",
-            30 => "borrow_as_mut",
-            31 => "return_to_mut",
-            32 => "check_not_borrowed",
-            33 => "strdup_uniq",
-            34 => "record_borrow",
-            35 => "unrecord_borrow",
-
-            36 => "start",
-
-            37 => "ty_desc",
-            38 => "ty_visitor",
-            39 => "opaque",
+            21 => "fail_",
+            22 => "fail_bounds_check",
+            23 => "exchange_malloc",
+            24 => "closure_exchange_malloc",
+            25 => "exchange_free",
+            26 => "malloc",
+            27 => "free",
+            28 => "borrow_as_imm",
+            29 => "borrow_as_mut",
+            30 => "return_to_mut",
+            31 => "check_not_borrowed",
+            32 => "strdup_uniq",
+            33 => "record_borrow",
+            34 => "unrecord_borrow",
+
+            35 => "start",
+
+            36 => "ty_desc",
+            37 => "ty_visitor",
+            38 => "opaque",
 
             _ => "???"
         }

trunk/src/librustc/middle/trans/expr.rs

@@ -313,36 +313,6 @@ pub fn trans_to_datum(bcx: @mut Block, expr: @ast::Expr) -> DatumBlock {
         let target_obj_ty = expr_ty_adjusted(bcx, expr);
         debug!("auto_borrow_obj(target=%s)",
                target_obj_ty.repr(tcx));
-
-        // Extract source store information
-        let (source_store, source_mutbl) = match ty::get(source_datum.ty).sty {
-            ty::ty_trait(_, _, s, m, _) => (s, m),
-            _ => {
-                bcx.sess().span_bug(
-                    expr.span,
-                    fmt!("auto_borrow_trait_obj expected a trait, found %s",
-                         source_datum.ty.repr(bcx.tcx())));
-            }
-        };
-
-        // check if any borrowing is really needed or we could reuse the source_datum instead
-        match ty::get(target_obj_ty).sty {
-            ty::ty_trait(_, _, ty::RegionTraitStore(target_scope), target_mutbl, _) => {
-                if target_mutbl == ast::MutImmutable && target_mutbl == source_mutbl {
-                    match source_store {
-                        ty::RegionTraitStore(source_scope) => {
-                            if tcx.region_maps.is_subregion_of(target_scope, source_scope) {
-                                return DatumBlock { bcx: bcx, datum: source_datum };
-                            }
-                        },
-                        _ => {}
-
-                    };
-                }
-            },
-            _ => {}
-        }
-
         let scratch = scratch_datum(bcx, target_obj_ty,
                                     "__auto_borrow_obj", false);
 
@@ -361,6 +331,15 @@ pub fn trans_to_datum(bcx: @mut Block, expr: @ast::Expr) -> DatumBlock {
         // ~T, or &T, depending on source_obj_ty.
         let source_data_ptr = GEPi(bcx, source_llval, [0u, abi::trt_field_box]);
         let source_data = Load(bcx, source_data_ptr); // always a ptr
+        let (source_store, source_mutbl) = match ty::get(source_datum.ty).sty {
+            ty::ty_trait(_, _, s, m, _) => (s, m),
+            _ => {
+                bcx.sess().span_bug(
+                    expr.span,
+                    fmt!("auto_borrow_trait_obj expected a trait, found %s",
+                         source_datum.ty.repr(bcx.tcx())));
+            }
+        };
         let target_data = match source_store {
             ty::BoxTraitStore(*) => {
                 // For deref of @T or @mut T, create a dummy datum and

trunk/src/librustc/middle/trans/meth.rs

@@ -434,22 +434,13 @@ pub fn trans_trait_callee(bcx: @mut Block,
     let _icx = push_ctxt("impl::trans_trait_callee");
     let mut bcx = bcx;
 
-    // make a local copy for trait if needed
     let self_ty = expr_ty_adjusted(bcx, self_expr);
-    let self_scratch = match ty::get(self_ty).sty {
-        ty::ty_trait(_, _, ty::RegionTraitStore(*), _, _) => {
-            unpack_datum!(bcx, expr::trans_to_datum(bcx, self_expr))
-        }
-        _ => {
-            let d = scratch_datum(bcx, self_ty, "__trait_callee", false);
-            bcx = expr::trans_into(bcx, self_expr, expr::SaveIn(d.val));
-            // Arrange a temporary cleanup for the object in case something
-            // should go wrong before the method is actually *invoked*.
-            d.add_clean(bcx);
-            d
-        }
-    };
+    let self_scratch = scratch_datum(bcx, self_ty, "__trait_callee", false);
+    bcx = expr::trans_into(bcx, self_expr, expr::SaveIn(self_scratch.val));
 
+    // Arrange a temporary cleanup for the object in case something
+    // should go wrong before the method is actually *invoked*.
+    self_scratch.add_clean(bcx);
 
     let callee_ty = node_id_type(bcx, callee_id);
     trans_trait_callee_from_llval(bcx,

trunk/src/librustc/middle/trans/type_.rs

@@ -278,12 +278,23 @@ impl Type {
 
     pub fn opaque_trait(ctx: &CrateContext, store: ty::TraitStore) -> Type {
         let tydesc_ptr = ctx.tydesc_type.ptr_to();
-        let box_ty = match store {
-            ty::BoxTraitStore => Type::opaque_box(ctx),
-            ty::UniqTraitStore => Type::unique(ctx, &Type::i8()),
-            ty::RegionTraitStore(*) => Type::i8()
-        };
-        Type::struct_([tydesc_ptr, box_ty.ptr_to()], false)
+        match store {
+            ty::BoxTraitStore => {
+                Type::struct_(
+                    [ tydesc_ptr, Type::opaque_box(ctx).ptr_to() ],
+                false)
+            }
+            ty::UniqTraitStore => {
+                Type::struct_(
+                    [ tydesc_ptr, Type::unique(ctx, &Type::i8()).ptr_to()],
+                false)
+            }
+            ty::RegionTraitStore(*) => {
+                Type::struct_(
+                    [ tydesc_ptr, Type::i8().ptr_to() ],
+                false)
+            }
+        }
     }
 
     pub fn kind(&self) -> TypeKind {