---

yaml
---
r: 93790
b: refs/heads/try
c: 97aaf42
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 0da105a8b7b6b1e0568e8ff20f6ff4b13cc7ecc2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d3e57dca68fde4effdda3e4ae2887aa535fcd6
-refs/heads/try: 1de47cb84286dd769b398da5d7dd1df2fd6f3406
+refs/heads/try: 97aaf42462ff35ad2bf097c8c1351e876d8d72b8
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/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
 

branches/try/doc/rust.md

@@ -3161,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.

branches/try/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}/

branches/try/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 })
     }
 }
 

branches/try/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 {

branches/try/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,

branches/try/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={})",

branches/try/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));

branches/try/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);
+    }
+}

branches/try/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 */

branches/try/src/libstd/util.rs

@@ -62,12 +62,6 @@ pub fn replace<T>(dest: &mut T, mut src: T) -> T {
 #[unsafe_no_drop_flag]
 pub struct NonCopyable;
 
-impl NonCopyable {
-    // FIXME(#8233) should not be necessary
-    /// Create a new noncopyable token.
-    pub fn new() -> NonCopyable { NonCopyable }
-}
-
 impl Drop for NonCopyable {
     fn drop(&mut self) { }
 }

branches/try/src/libsyntax/abi.rs

@@ -23,6 +23,7 @@ pub enum Abi {
     Stdcall,
     Fastcall,
     Aapcs,
+    Win64,
 
     // Multiplatform ABIs second
     Rust,
@@ -73,6 +74,8 @@ static AbiDatas: &'static [AbiData] = &[
     AbiData {abi: Stdcall, name: "stdcall", abi_arch: Archs(IntelBits)},
     AbiData {abi: Fastcall, name:"fastcall", abi_arch: Archs(IntelBits)},
     AbiData {abi: Aapcs, name: "aapcs", abi_arch: Archs(ArmBits)},
+    AbiData {abi: Win64, name: "win64",
+             abi_arch: Archs(1 << (X86_64 as uint))},
 
     // Cross-platform ABIs
     //

branches/try/src/libsyntax/ast.rs

@@ -861,7 +861,6 @@ pub enum ty_ {
     ty_bare_fn(@TyBareFn),
     ty_tup(~[Ty]),
     ty_path(Path, Option<OptVec<TyParamBound>>, NodeId), // for #7264; see above
-    ty_mac(mac),
     ty_typeof(@Expr),
     // ty_infer means the type should be inferred instead of it having been
     // specified. This should only appear at the "top level" of a type and not

branches/try/src/libsyntax/codemap.rs

@@ -29,9 +29,11 @@ pub trait Pos {
     fn to_uint(&self) -> uint;
 }
 
-/// A byte offset
+/// A byte offset. Keep this small (currently 32-bits), as AST contains
+/// a lot of them.
 #[deriving(Clone, Eq, IterBytes, Ord)]
-pub struct BytePos(uint);
+pub struct BytePos(u32);
+
 /// A character offset. Because of multibyte utf8 characters, a byte offset
 /// is not equivalent to a character offset. The CodeMap will convert BytePos
 /// values to CharPos values as necessary.
@@ -42,8 +44,8 @@ pub struct CharPos(uint);
 // have been unsuccessful
 
 impl Pos for BytePos {
-    fn from_uint(n: uint) -> BytePos { BytePos(n) }
-    fn to_uint(&self) -> uint { **self }
+    fn from_uint(n: uint) -> BytePos { BytePos(n as u32) }
+    fn to_uint(&self) -> uint { **self as uint }
 }
 
 impl Add<BytePos, BytePos> for BytePos {
@@ -278,7 +280,7 @@ impl CodeMap {
 
         let filemap = @FileMap {
             name: filename, substr: substr, src: src,
-            start_pos: BytePos(start_pos),
+            start_pos: Pos::from_uint(start_pos),
             lines: @mut ~[],
             multibyte_chars: @mut ~[],
         };

branches/try/src/libsyntax/fold.rs

@@ -277,7 +277,6 @@ pub trait ast_fold {
             ty_fixed_length_vec(ref mt, e) => {
                 ty_fixed_length_vec(fold_mt(mt, self), self.fold_expr(e))
             }
-            ty_mac(ref mac) => ty_mac(self.fold_mac(mac)),
             ty_typeof(expr) => ty_typeof(self.fold_expr(expr)),
         };
         Ty {