---

yaml
---
r: 89961
b: refs/heads/master
c: 6143400
h: refs/heads/master
i:
  89959: 345c788
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: c06ce4c9bf2ce649dafaa695b2d0078d75676c71
+refs/heads/master: 6143400aaac2239feb979deebe9777f6edccce1a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d3e57dca68fde4effdda3e4ae2887aa535fcd6
 refs/heads/try: b160761e35efcd1207112b3b782c06633cf441a8

trunk/configure

@@ -520,14 +520,20 @@ then
     fi
 fi
 
+BIN_SUF=
+if [ $CFG_OSTYPE = "pc-mingw32" ]
+then
+    BIN_SUF=.exe
+fi
+
 if [ ! -z "$CFG_ENABLE_LOCAL_RUST" ]
 then
-    if [ ! -f ${CFG_LOCAL_RUST_ROOT}/bin/rustc ]
+    if [ ! -f ${CFG_LOCAL_RUST_ROOT}/bin/rustc${BIN_SUF} ]
     then
         err "no local rust to use"
     else
-        LRV=`${CFG_LOCAL_RUST_ROOT}/bin/rustc --version`
-        step_msg "using rustc at: ${CFG_LOCAL_RUST_ROOT} with version: " $LRV
+        LRV=`${CFG_LOCAL_RUST_ROOT}/bin/rustc${BIN_SUF} --version`
+        step_msg "using rustc at: ${CFG_LOCAL_RUST_ROOT} with version: $LRV"
     fi
 fi
 

trunk/doc/rust.md

@@ -1131,9 +1131,8 @@ block.
 let fptr: extern "C" fn() -> ~[int] = new_vec;
 ~~~~
 
-Extern functions may be called from Rust code, but
-caution must be taken with respect to the size of the stack
-segment, just as when calling an extern function normally.
+Extern functions may be called directly from Rust code as Rust uses large,
+contiguous stack segments like C.
 
 ### Type definitions
 
@@ -3162,7 +3161,7 @@ Borrowed pointers (`&`)
     Borrowed pointers arise by (automatic) conversion from owning pointers, managed pointers,
     or by applying the borrowing operator `&` to some other value,
     including [lvalues, rvalues or temporaries](#lvalues-rvalues-and-temporaries).
-    Borrowed pointers are written `&content`, or in some cases `&f/content` for some lifetime-variable `f`,
+    Borrowed pointers are written `&content`, or in some cases `&'f content` for some lifetime-variable `f`,
     for example `&int` means a borrowed pointer to an integer.
     Copying a borrowed pointer is a "shallow" operation:
     it involves only copying the pointer itself.
@@ -3597,9 +3596,9 @@ and releases them back to its environment when they are no longer needed.
 The default implementation of the service-provider interface
 consists of the C runtime functions `malloc` and `free`.
 
-The runtime memory-management system, in turn, supplies Rust tasks
-with facilities for allocating, extending and releasing stacks,
-as well as allocating and freeing heap data.
+The runtime memory-management system, in turn, supplies Rust tasks with
+facilities for allocating releasing stacks, as well as allocating and freeing
+heap data.
 
 ### Built in types
 
@@ -3762,7 +3761,6 @@ have come and gone during the course of Rust's development:
 
 Additional specific influences can be seen from the following languages:
 
-* The stack-growth implementation of Go.
 * The structural algebraic types and compilation manager of SML.
 * The attribute and assembly systems of C#.
 * The references and deterministic destructor system of C++.

trunk/src/etc/local_stage0.sh

@@ -3,8 +3,8 @@
 TARG_DIR=$1
 PREFIX=$2
 
-BINDIR=bin
-LIBDIR=lib
+LIB_DIR=lib
+LIB_PREFIX=lib
 
 OS=`uname -s`
 case $OS in
@@ -21,7 +21,8 @@ case $OS in
     (*)
 	BIN_SUF=.exe
 	LIB_SUF=.dll
-	LIBDIR=bin
+	LIB_DIR=bin
+	LIB_PREFIX=
 	break
 	;;
 esac
@@ -31,7 +32,7 @@ if [ -z $PREFIX ]; then
     exit 1
 fi
 
-if [ ! -e ${PREFIX}/bin/rustc ]; then
+if [ ! -e ${PREFIX}/bin/rustc${BIN_SUF} ]; then
     echo "No local rust installed at ${PREFIX}"
     exit 1
 fi
@@ -41,9 +42,9 @@ if [ -z $TARG_DIR ]; then
     exit 1
 fi
 
-cp ${PREFIX}/bin/rustc ${TARG_DIR}/stage0/bin/
-cp ${PREFIX}/lib/rustc/${TARG_DIR}/${LIBDIR}/* ${TARG_DIR}/stage0/${LIBDIR}/
-cp ${PREFIX}/lib/libextra*${LIB_SUF} ${TARG_DIR}/stage0/${LIBDIR}/
-cp ${PREFIX}/lib/librust*${LIB_SUF} ${TARG_DIR}/stage0/${LIBDIR}/
-cp ${PREFIX}/lib/libstd*${LIB_SUF} ${TARG_DIR}/stage0/${LIBDIR}/
-cp ${PREFIX}/lib/libsyntax*${LIB_SUF} ${TARG_DIR}/stage0/${LIBDIR}/
+cp ${PREFIX}/bin/rustc${BIN_SUF} ${TARG_DIR}/stage0/bin/
+cp ${PREFIX}/${LIB_DIR}/rustc/${TARG_DIR}/${LIB_DIR}/* ${TARG_DIR}/stage0/${LIB_DIR}/
+cp ${PREFIX}/${LIB_DIR}/${LIB_PREFIX}extra*${LIB_SUF} ${TARG_DIR}/stage0/${LIB_DIR}/
+cp ${PREFIX}/${LIB_DIR}/${LIB_PREFIX}rust*${LIB_SUF} ${TARG_DIR}/stage0/${LIB_DIR}/
+cp ${PREFIX}/${LIB_DIR}/${LIB_PREFIX}std*${LIB_SUF} ${TARG_DIR}/stage0/${LIB_DIR}/
+cp ${PREFIX}/${LIB_DIR}/${LIB_PREFIX}syntax*${LIB_SUF} ${TARG_DIR}/stage0/${LIB_DIR}/

trunk/src/libextra/sync.rs

@@ -326,7 +326,7 @@ impl Sem<~[WaitQueue]> {
     // and rwlock_write_mode.
     pub fn access_cond<U>(&self, blk: |c: &Condvar| -> U) -> U {
         do self.access {
-            blk(&Condvar { sem: self, order: Nothing, token: NonCopyable::new() })
+            blk(&Condvar { sem: self, order: Nothing, token: NonCopyable })
         }
     }
 }
@@ -569,7 +569,7 @@ impl RWLock {
                 do task::rekillable {
                     let opt_lock = Just(&self.order_lock);
                     blk(&Condvar { sem: cond.sem, order: opt_lock,
-                                   token: NonCopyable::new() })
+                                   token: NonCopyable })
                 }
             }
         }
@@ -605,7 +605,7 @@ impl RWLock {
             (&self.order_lock).release();
             do (|| {
                 do task::rekillable {
-                    blk(RWLockWriteMode { lock: self, token: NonCopyable::new() })
+                    blk(RWLockWriteMode { lock: self, token: NonCopyable })
                 }
             }).finally {
                 let writer_or_last_reader;
@@ -662,7 +662,7 @@ impl RWLock {
                 }
             }
         }
-        RWLockReadMode { lock: token.lock, token: NonCopyable::new() }
+        RWLockReadMode { lock: token.lock, token: NonCopyable }
     }
 }
 
@@ -682,7 +682,7 @@ impl<'self> RWLockWriteMode<'self> {
         // access lock. See comment in RWLock::write_cond for why.
         blk(&Condvar { sem:        &self.lock.access_lock,
                        order: Just(&self.lock.order_lock),
-                       token: NonCopyable::new() })
+                       token: NonCopyable })
     }
 }
 

trunk/src/librustc/lib/llvm.rs

@@ -33,6 +33,7 @@ pub enum CallConv {
     ColdCallConv = 9,
     X86StdcallCallConv = 64,
     X86FastcallCallConv = 65,
+    X86_64_Win64 = 79,
 }
 
 pub enum Visibility {

trunk/src/librustc/middle/resolve.rs

@@ -29,7 +29,7 @@ use syntax::parse::token;
 use syntax::parse::token::{ident_interner, interner_get};
 use syntax::parse::token::special_idents;
 use syntax::print::pprust::path_to_str;
-use syntax::codemap::{Span, dummy_sp, BytePos};
+use syntax::codemap::{Span, dummy_sp, Pos};
 use syntax::opt_vec::OptVec;
 use syntax::visit;
 use syntax::visit::Visitor;
@@ -2624,7 +2624,7 @@ impl Resolver {
                     if "???" == module_name {
                         let span = Span {
                             lo: span.lo,
-                            hi: span.lo + BytePos(segment_name.len()),
+                            hi: span.lo + Pos::from_uint(segment_name.len()),
                             expn_info: span.expn_info,
                         };
                         self.resolve_error(span,

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

@@ -33,7 +33,7 @@ use syntax::{ast};
 use syntax::{attr, ast_map};
 use syntax::parse::token::special_idents;
 use syntax::abi::{RustIntrinsic, Rust, Stdcall, Fastcall, System,
-                  Cdecl, Aapcs, C, AbiSet};
+                  Cdecl, Aapcs, C, AbiSet, Win64};
 use util::ppaux::{Repr, UserString};
 use middle::trans::type_::Type;
 
@@ -96,6 +96,7 @@ pub fn llvm_calling_convention(ccx: &mut CrateContext,
             Stdcall => lib::llvm::X86StdcallCallConv,
             Fastcall => lib::llvm::X86FastcallCallConv,
             C => lib::llvm::CCallConv,
+            Win64 => lib::llvm::X86_64_Win64,
 
             // NOTE These API constants ought to be more specific
             Cdecl => lib::llvm::CCallConv,
@@ -398,11 +399,19 @@ pub fn register_rust_fn_with_foreign_abi(ccx: @mut CrateContext,
 
     let tys = foreign_types_for_id(ccx, node_id);
     let llfn_ty = lltype_for_fn_from_foreign_types(&tys);
+    let t = ty::node_id_to_type(ccx.tcx, node_id);
+    let cconv = match ty::get(t).sty {
+        ty::ty_bare_fn(ref fn_ty) => {
+            let c = llvm_calling_convention(ccx, fn_ty.abis);
+            c.unwrap_or(lib::llvm::CCallConv)
+        }
+        _ => lib::llvm::CCallConv
+    };
     let llfn = base::register_fn_llvmty(ccx,
                                         sp,
                                         sym,
                                         node_id,
-                                        lib::llvm::CCallConv,
+                                        cconv,
                                         llfn_ty);
     add_argument_attributes(&tys, llfn);
     debug!("register_rust_fn_with_foreign_abi(node_id={:?}, llfn_ty={}, llfn={})",

trunk/src/librustc/middle/typeck/astconv.rs

@@ -560,10 +560,6 @@ pub fn ast_ty_to_ty<AC:AstConv, RS:RegionScope>(
             ast_ty.span,
             "found `ty_infer` in unexpected place");
       }
-      ast::ty_mac(_) => {
-        tcx.sess.span_bug(ast_ty.span,
-                          "found `ty_mac` in unexpected place");
-      }
     };
 
     tcx.ast_ty_to_ty_cache.insert(ast_ty.id, ty::atttce_resolved(typ));

trunk/src/librustdoc/html/render.rs

@@ -466,14 +466,15 @@ impl DocFolder for Cache {
         // Register any generics to their corresponding string. This is used
         // when pretty-printing types
         match item.inner {
-            clean::StructItem(ref s)   => self.generics(&s.generics),
-            clean::EnumItem(ref e)     => self.generics(&e.generics),
-            clean::FunctionItem(ref f) => self.generics(&f.generics),
-            clean::TypedefItem(ref t)  => self.generics(&t.generics),
-            clean::TraitItem(ref t)    => self.generics(&t.generics),
-            clean::ImplItem(ref i)     => self.generics(&i.generics),
-            clean::TyMethodItem(ref i) => self.generics(&i.generics),
-            clean::MethodItem(ref i)   => self.generics(&i.generics),
+            clean::StructItem(ref s)          => self.generics(&s.generics),
+            clean::EnumItem(ref e)            => self.generics(&e.generics),
+            clean::FunctionItem(ref f)        => self.generics(&f.generics),
+            clean::TypedefItem(ref t)         => self.generics(&t.generics),
+            clean::TraitItem(ref t)           => self.generics(&t.generics),
+            clean::ImplItem(ref i)            => self.generics(&i.generics),
+            clean::TyMethodItem(ref i)        => self.generics(&i.generics),
+            clean::MethodItem(ref i)          => self.generics(&i.generics),
+            clean::ForeignFunctionItem(ref f) => self.generics(&f.generics),
             _ => {}
         }
 

trunk/src/libstd/gc.rs

@@ -0,0 +1,99 @@
+// 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.
+//
+// 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.
+
+/*! Task-local garbage-collected boxes
+
+The `Gc` type provides shared ownership of an immutable value. Destruction is not deterministic, and
+will occur some time between every `Gc` handle being gone and the end of the task. The garbage
+collector is task-local so `Gc<T>` is not sendable.
+
+*/
+
+use kinds::Send;
+use clone::{Clone, DeepClone};
+
+/// Immutable garbage-collected pointer type
+#[no_send]
+#[deriving(Clone)]
+pub struct Gc<T> {
+    priv ptr: @T
+}
+
+impl<T: 'static> Gc<T> {
+    /// Construct a new garbage-collected box
+    #[inline]
+    pub fn new(value: T) -> Gc<T> {
+        Gc { ptr: @value }
+    }
+}
+
+impl<T: 'static> Gc<T> {
+    /// Borrow the value contained in the garbage-collected box
+    #[inline]
+    pub fn borrow<'r>(&'r self) -> &'r T {
+        &*self.ptr
+    }
+}
+
+/// The `Send` bound restricts this to acyclic graphs where it is well-defined.
+///
+/// A `Freeze` bound would also work, but `Send` *or* `Freeze` cannot be expressed.
+impl<T: DeepClone + Send + 'static> DeepClone for Gc<T> {
+    #[inline]
+    fn deep_clone(&self) -> Gc<T> {
+        Gc::new(self.borrow().deep_clone())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use cell::Cell;
+
+    #[test]
+    fn test_clone() {
+        let x = Gc::new(Cell::new(5));
+        let y = x.clone();
+        do x.borrow().with_mut_ref |inner| {
+            *inner = 20;
+        }
+        assert_eq!(y.borrow().take(), 20);
+    }
+
+    #[test]
+    fn test_deep_clone() {
+        let x = Gc::new(Cell::new(5));
+        let y = x.deep_clone();
+        do x.borrow().with_mut_ref |inner| {
+            *inner = 20;
+        }
+        assert_eq!(y.borrow().take(), 5);
+    }
+
+    #[test]
+    fn test_simple() {
+        let x = Gc::new(5);
+        assert_eq!(*x.borrow(), 5);
+    }
+
+    #[test]
+    fn test_simple_clone() {
+        let x = Gc::new(5);
+        let y = x.clone();
+        assert_eq!(*x.borrow(), 5);
+        assert_eq!(*y.borrow(), 5);
+    }
+
+    #[test]
+    fn test_destructor() {
+        let x = Gc::new(~5);
+        assert_eq!(**x.borrow(), 5);
+    }
+}

trunk/src/libstd/lib.rs

@@ -133,6 +133,7 @@ pub mod owned;
 pub mod managed;
 pub mod borrow;
 pub mod rc;
+pub mod gc;
 
 
 /* Core language traits */

trunk/src/libstd/ptr.rs

@@ -155,7 +155,7 @@ pub unsafe fn replace_ptr<T>(dest: *mut T, mut src: T) -> T {
  * Reads the value from `*src` and returns it. Does not copy `*src`.
  */
 #[inline(always)]
-pub unsafe fn read_ptr<T>(src: *mut T) -> T {
+pub unsafe fn read_ptr<T>(src: *T) -> T {
     let mut tmp: T = intrinsics::uninit();
     copy_nonoverlapping_memory(&mut tmp, src, 1);
     tmp
@@ -168,7 +168,7 @@ pub unsafe fn read_ptr<T>(src: *mut T) -> T {
 #[inline(always)]
 pub unsafe fn read_and_zero_ptr<T>(dest: *mut T) -> T {
     // Copy the data out from `dest`:
-    let tmp = read_ptr(dest);
+    let tmp = read_ptr(&*dest);
 
     // Now zero out `dest`:
     zero_memory(dest, 1);