---

yaml
---
r: 193754
b: refs/heads/beta
c: d54bd9f
h: refs/heads/master
v: v3

Author: alexcrichton

[refs]

@@ -31,7 +31,7 @@ refs/heads/automation-fail: 1bf06495443584539b958873e04cc2f864ab10e4
 refs/heads/issue-18208-method-dispatch-3-quick-reject: 2009f85b9f99dedcec4404418eda9ddba90258a2
 refs/heads/batch: b7fd822592a4fb577552d93010c4a4e14f314346
 refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
-refs/heads/beta: 9eb69abad8ffbce840e7dc7038ddea434dc987f1
+refs/heads/beta: d54bd9f29af67748b7ddf80a5cf285145949ddc2
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: de8a23bbc3a7b9cbd7574b5b91a34af59bf030e6

branches/beta/mk/llvm.mk

@@ -44,10 +44,10 @@ $$(LLVM_STAMP_$(1)): $(S)src/rustllvm/llvm-auto-clean-trigger
 	touch -r $$@.start_time $$@ && rm $$@.start_time
 
 ifeq ($$(CFG_ENABLE_LLVM_STATIC_STDCPP),1)
-LLVM_STDCPP_RUSTFLAGS_$(1) = -L "$$(dir $$(shell $$(CC_$(1)) $$(CFG_GCCISH_CFLAGS_$(1)) \
-					-print-file-name=libstdc++.a))"
+LLVM_STDCPP_LOCATION_$(1) = $$(shell $$(CC_$(1)) $$(CFG_GCCISH_CFLAGS_$(1)) \
+					-print-file-name=libstdc++.a)
 else
-LLVM_STDCPP_RUSTFLAGS_$(1) =
+LLVM_STDCPP_LOCATION_$(1) =
 endif
 
 

branches/beta/mk/main.mk

@@ -30,8 +30,8 @@ CFG_PACKAGE_VERS=$(CFG_RELEASE_NUM)
 CFG_DISABLE_UNSTABLE_FEATURES=1
 endif
 ifeq ($(CFG_RELEASE_CHANNEL),beta)
-CFG_RELEASE=$(CFG_RELEASE_NUM)-beta$(CFG_PRERELEASE_VERSION)
-CFG_PACKAGE_VERS=$(CFG_RELEASE_NUM)-beta$(CFG_PRERELEASE_VERSION)
+CFG_RELEASE=$(CFG_RELEASE_NUM)-beta(CFG_PRERELEASE_VERSION)
+CFG_PACKAGE_VERS=$(CFG_RELEASE_NUM)-beta(CFG_PRERELEASE_VERSION)
 CFG_DISABLE_UNSTABLE_FEATURES=1
 endif
 ifeq ($(CFG_RELEASE_CHANNEL),nightly)

branches/beta/mk/target.mk

@@ -85,7 +85,7 @@ $$(TLIB$(1)_T_$(2)_H_$(3))/stamp.$(4): \
 		$$(RUST_LIB_FLAGS_ST$(1)) \
 		-L "$$(RT_OUTPUT_DIR_$(2))" \
 		-L "$$(LLVM_LIBDIR_$(2))" \
-		$$(LLVM_STDCPP_RUSTFLAGS_$(2)) \
+		-L "$$(dir $$(LLVM_STDCPP_LOCATION_$(2)))" \
 		$$(RUSTFLAGS_$(4)) \
 		--out-dir $$(@D) \
 		-C extra-filename=-$$(CFG_FILENAME_EXTRA) \

branches/beta/src/doc/trpl/hello-cargo.md

@@ -85,11 +85,9 @@ Hello, world!
 Bam! We build our project with `cargo build`, and run it with
 `./target/debug/hello_world`. This hasn't bought us a whole lot over our simple use
 of `rustc`, but think about the future: when our project has more than one
-file, we would need to call `rustc` more than once and pass it a bunch of options to
+file, we would need to call `rustc` more than once, and pass it a bunch of options to
 tell it to build everything together. With Cargo, as our project grows, we can
-just `cargo build`, and it'll work the right way. When your project is finally
-ready for release, you can use `cargo build --release` to compile your crates with
-optimizations.
+just `cargo build` and it'll work the right way. When you're project is finally ready for release, you can use `cargo build --release` to compile your crates with optimizations.
 
 You'll also notice that Cargo has created a new file: `Cargo.lock`.
 

branches/beta/src/etc/gdb_rust_pretty_printing.py

@@ -27,18 +27,9 @@ def rust_pretty_printer_lookup_function(val):
     if type_code == gdb.TYPE_CODE_STRUCT:
         struct_kind = classify_struct(val.type)
 
-        if struct_kind == STRUCT_KIND_SLICE:
-            return RustSlicePrinter(val)
-
         if struct_kind == STRUCT_KIND_STR_SLICE:
             return RustStringSlicePrinter(val)
 
-        if struct_kind == STRUCT_KIND_STD_VEC:
-            return RustStdVecPrinter(val)
-
-        if struct_kind == STRUCT_KIND_STD_STRING:
-            return RustStdStringPrinter(val)
-
         if struct_kind == STRUCT_KIND_TUPLE:
             return RustTuplePrinter(val)
 
@@ -181,28 +172,6 @@ def children(self):
     def display_hint(self):
         return "array"
 
-class RustSlicePrinter:
-    def __init__(self, val):
-        self.val = val
-
-    def display_hint(self):
-        return "array"
-
-    def to_string(self):
-        length = int(self.val["length"])
-        return self.val.type.tag + ("(len: %i)" % length)
-
-    def children(self):
-        cs = []
-        length = int(self.val["length"])
-        data_ptr = self.val["data_ptr"]
-        assert data_ptr.type.code == gdb.TYPE_CODE_PTR
-        pointee_type = data_ptr.type.target()
-
-        for index in range(0, length):
-            cs.append((str(index), (data_ptr + index).dereference()))
-
-        return cs
 
 class RustStringSlicePrinter:
     def __init__(self, val):
@@ -212,35 +181,6 @@ def to_string(self):
         slice_byte_len = self.val["length"]
         return '"%s"' % self.val["data_ptr"].string(encoding="utf-8", length=slice_byte_len)
 
-class RustStdVecPrinter:
-    def __init__(self, val):
-        self.val = val
-
-    def display_hint(self):
-        return "array"
-
-    def to_string(self):
-        length = int(self.val["len"])
-        cap = int(self.val["cap"])
-        return self.val.type.tag + ("(len: %i, cap: %i)" % (length, cap))
-
-    def children(self):
-        cs = []
-        (length, data_ptr) = extract_length_and_data_ptr_from_std_vec(self.val)
-        pointee_type = data_ptr.type.target()
-
-        for index in range(0, length):
-            cs.append((str(index), (data_ptr + index).dereference()))
-        return cs
-
-class RustStdStringPrinter:
-    def __init__(self, val):
-        self.val = val
-
-    def to_string(self):
-        (length, data_ptr) = extract_length_and_data_ptr_from_std_vec(self.val["vec"])
-        return '"%s"' % data_ptr.string(encoding="utf-8", length=length)
-
 
 class RustCStyleEnumPrinter:
     def __init__(self, val):
@@ -264,38 +204,19 @@ def to_string(self):
 STRUCT_KIND_TUPLE_VARIANT   = 3
 STRUCT_KIND_STRUCT_VARIANT  = 4
 STRUCT_KIND_CSTYLE_VARIANT  = 5
-STRUCT_KIND_SLICE           = 6
-STRUCT_KIND_STR_SLICE       = 7
-STRUCT_KIND_STD_VEC         = 8
-STRUCT_KIND_STD_STRING      = 9
+STRUCT_KIND_STR_SLICE       = 6
 
 
 def classify_struct(type):
-    # print("\nclassify_struct: tag=%s\n" % type.tag)
     if type.tag == "&str":
         return STRUCT_KIND_STR_SLICE
 
-    if type.tag.startswith("&[") and type.tag.endswith("]"):
-        return STRUCT_KIND_SLICE
-
     fields = list(type.fields())
     field_count = len(fields)
 
     if field_count == 0:
         return STRUCT_KIND_REGULAR_STRUCT
 
-    if (field_count == 3 and
-        fields[0].name == "ptr" and
-        fields[1].name == "len" and
-        fields[2].name == "cap" and
-        type.tag.startswith("Vec<")):
-        return STRUCT_KIND_STD_VEC
-
-    if (field_count == 1 and
-        fields[0].name == "vec" and
-        type.tag == "String"):
-        return STRUCT_KIND_STD_STRING
-
     if fields[0].name == "RUST$ENUM$DISR":
         if field_count == 1:
             return STRUCT_KIND_CSTYLE_VARIANT
@@ -333,11 +254,3 @@ def get_field_at_index(val, index):
             return field
         i += 1
     return None
-
-def extract_length_and_data_ptr_from_std_vec(vec_val):
-    length = int(vec_val["len"])
-    vec_ptr_val = vec_val["ptr"]
-    unique_ptr_val = vec_ptr_val[first_field(vec_ptr_val)]
-    data_ptr = unique_ptr_val[first_field(unique_ptr_val)]
-    assert data_ptr.type.code == gdb.TYPE_CODE_PTR
-    return (length, data_ptr)

branches/beta/src/etc/lldb_rust_formatters.py

@@ -40,12 +40,31 @@ def print_struct_val(val, internal_dict):
 
     if is_vec_slice(val):
         return print_vec_slice_val(val, internal_dict)
-    elif is_std_vec(val):
-        return print_std_vec_val(val, internal_dict)
     else:
         return print_struct_val_starting_from(0, val, internal_dict)
 
 
+def print_vec_slice_val(val, internal_dict):
+    length = val.GetChildAtIndex(1).GetValueAsUnsigned()
+
+    data_ptr_val = val.GetChildAtIndex(0)
+    data_ptr_type = data_ptr_val.GetType()
+    assert data_ptr_type.IsPointerType()
+
+    element_type = data_ptr_type.GetPointeeType()
+    element_type_size = element_type.GetByteSize()
+
+    start_address = data_ptr_val.GetValueAsUnsigned()
+
+    def render_element(i):
+        address = start_address + i * element_type_size
+        element_val = val.CreateValueFromAddress(val.GetName() +
+                                                 ("[%s]" % i), address, element_type)
+        return print_val(element_val, internal_dict)
+
+    return "&[%s]" % (', '.join([render_element(i) for i in range(length)]))
+
+
 def print_struct_val_starting_from(field_start_index, val, internal_dict):
     '''
     Prints a struct, tuple, or tuple struct value with Rust syntax.
@@ -81,16 +100,6 @@ def render_child(child_index):
             this += field_name + ": "
 
         field_val = val.GetChildAtIndex(child_index)
-
-        if not field_val.IsValid():
-            field = t.GetFieldAtIndex(child_index)
-            # LLDB is not good at handling zero-sized values, so we have to help
-            # it a little
-            if field.GetType().GetByteSize() == 0:
-                return this + extract_type_name(field.GetType().GetName())
-            else:
-                return this + "<invalid value>"
-
         return this + print_val(field_val, internal_dict)
 
     body = separator.join([render_child(idx) for idx in range(field_start_index, num_children)])
@@ -186,30 +195,6 @@ def print_fixed_size_vec_val(val, internal_dict):
     return output
 
 
-def print_vec_slice_val(val, internal_dict):
-    length = val.GetChildAtIndex(1).GetValueAsUnsigned()
-
-    data_ptr_val = val.GetChildAtIndex(0)
-    data_ptr_type = data_ptr_val.GetType()
-
-    return "&[%s]" % print_array_of_values(val.GetName(),
-                                           data_ptr_val,
-                                           length,
-                                           internal_dict)
-
-
-def print_std_vec_val(val, internal_dict):
-    length = val.GetChildAtIndex(1).GetValueAsUnsigned()
-
-    # Vec<> -> Unique<> -> NonZero<> -> *T
-    data_ptr_val = val.GetChildAtIndex(0).GetChildAtIndex(0).GetChildAtIndex(0)
-    data_ptr_type = data_ptr_val.GetType()
-
-    return "vec![%s]" % print_array_of_values(val.GetName(),
-                                              data_ptr_val,
-                                              length,
-                                              internal_dict)
-
 #=--------------------------------------------------------------------------------------------------
 # Helper Functions
 #=--------------------------------------------------------------------------------------------------
@@ -258,44 +243,3 @@ def is_vec_slice(val):
 
     type_name = extract_type_name(ty.GetName()).replace("&'static", "&").replace(" ", "")
     return type_name.startswith("&[") and type_name.endswith("]")
-
-def is_std_vec(val):
-    ty = val.GetType()
-    if ty.GetTypeClass() != lldb.eTypeClassStruct:
-        return False
-
-    if ty.GetNumberOfFields() != 3:
-        return False
-
-    if ty.GetFieldAtIndex(0).GetName() != "ptr":
-        return False
-
-    if ty.GetFieldAtIndex(1).GetName() != "len":
-        return False
-
-    if ty.GetFieldAtIndex(2).GetName() != "cap":
-        return False
-
-    return ty.GetName().startswith("collections::vec::Vec<")
-
-
-def print_array_of_values(array_name, data_ptr_val, length, internal_dict):
-    '''Prints a contigous memory range, interpreting it as values of the
-       pointee-type of data_ptr_val.'''
-
-    data_ptr_type = data_ptr_val.GetType()
-    assert data_ptr_type.IsPointerType()
-
-    element_type = data_ptr_type.GetPointeeType()
-    element_type_size = element_type.GetByteSize()
-
-    start_address = data_ptr_val.GetValueAsUnsigned()
-
-    def render_element(i):
-        address = start_address + i * element_type_size
-        element_val = data_ptr_val.CreateValueFromAddress(array_name + ("[%s]" % i),
-                                                          address,
-                                                          element_type)
-        return print_val(element_val, internal_dict)
-
-    return ', '.join([render_element(i) for i in range(length)])

branches/beta/src/liballoc/heap.rs

@@ -198,7 +198,6 @@ mod imp {
     extern {}
 
     extern {
-        #[allocator]
         fn je_mallocx(size: size_t, flags: c_int) -> *mut c_void;
         fn je_rallocx(ptr: *mut c_void, size: size_t, flags: c_int) -> *mut c_void;
         fn je_xallocx(ptr: *mut c_void, size: size_t, extra: size_t, flags: c_int) -> size_t;

branches/beta/src/liballoc/lib.rs

@@ -69,7 +69,6 @@
 
 #![feature(no_std)]
 #![no_std]
-#![feature(allocator)]
 #![feature(lang_items, unsafe_destructor)]
 #![feature(box_syntax)]
 #![feature(optin_builtin_traits)]

branches/beta/src/libcore/hash/mod.rs

@@ -70,7 +70,9 @@ mod sip;
 /// A hashable type.
 ///
 /// The `H` type parameter is an abstract hash state that is used by the `Hash`
-/// to compute the hash.
+/// to compute the hash. Specific implementations of this trait may specialize
+/// for particular instances of `H` in order to be able to optimize the hashing
+/// behavior.
 #[stable(feature = "rust1", since = "1.0.0")]
 pub trait Hash {
     /// Feeds this value into the state given, updating the hasher as necessary.

branches/beta/src/libcore/ptr.rs

@@ -33,34 +33,31 @@
 //! let my_speed_ptr: *mut i32 = &mut my_speed;
 //! ```
 //!
-//! To get a pointer to a boxed value, dereference the box:
-//!
-//! ```
-//! let my_num: Box<i32> = Box::new(10);
-//! let my_num_ptr: *const i32 = &*my_num;
-//! let mut my_speed: Box<i32> = Box::new(88);
-//! let my_speed_ptr: *mut i32 = &mut *my_speed;
-//! ```
-//!
 //! This does not take ownership of the original allocation
 //! and requires no resource management later,
 //! but you must not use the pointer after its lifetime.
 //!
-//! ## 2. Consume a box (`Box<T>`).
+//! ## 2. Transmute an owned box (`Box<T>`).
 //!
-//! The `into_raw` function consumes a box and returns
-//! the raw pointer. It doesn't destroy `T` or deallocate any memory.
+//! The `transmute` function takes, by value, whatever it's given
+//! and returns it as whatever type is requested, as long as the
+//! types are the same size. Because `Box<T>` and `*mut T` have the same
+//! representation they can be trivially,
+//! though unsafely, transformed from one type to the other.
 //!
 //! ```
-//! use std::boxed;
+//! use std::mem;
 //!
 //! unsafe {
+//!     let my_num: Box<i32> = Box::new(10);
+//!     let my_num: *const i32 = mem::transmute(my_num);
 //!     let my_speed: Box<i32> = Box::new(88);
-//!     let my_speed: *mut i32 = boxed::into_raw(my_speed);
+//!     let my_speed: *mut i32 = mem::transmute(my_speed);
 //!
 //!     // By taking ownership of the original `Box<T>` though
-//!     // we are obligated to put it together later to be destroyed.
-//!     drop(Box::from_raw(my_speed));
+//!     // we are obligated to transmute it back later to be destroyed.
+//!     drop(mem::transmute::<_, Box<i32>>(my_speed));
+//!     drop(mem::transmute::<_, Box<i32>>(my_num));
 //! }
 //! ```
 //!