---

yaml
---
r: 93947
b: refs/heads/try
c: d662820
h: refs/heads/master
i:
  93945: c2b4da6
  93943: ff608ab
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: a9bd049fc09445a20ab8a9283a24f1074403d061
+refs/heads/try: d662820b297f0ecda17126577571fcf886bdac81
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/doc/rust.md

@@ -1754,6 +1754,8 @@ names are effectively reserved. Some significant attributes include:
 * The `deriving` attribute, for automatically generating
   implementations of certain traits.
 * The `static_assert` attribute, for asserting that a static bool is true at compiletime
+* The `thread_local` attribute, for defining a `static mut` as a thread-local. Note that this is
+  only a low-level building block, and is not local to a *task*, nor does it provide safety.
 
 Other attributes may be added or removed during development of the language.
 

branches/try/src/libextra/c_vec.rs

@@ -37,7 +37,6 @@
  */
 
 use std::ptr;
-use std::routine::Runnable;
 use std::util;
 
 /**
@@ -50,7 +49,7 @@ pub struct CVec<T> {
 }
 
 struct DtorRes {
-    dtor: Option<~Runnable>,
+    dtor: Option<proc()>,
 }
 
 #[unsafe_destructor]
@@ -59,13 +58,13 @@ impl Drop for DtorRes {
         let dtor = util::replace(&mut self.dtor, None);
         match dtor {
             None => (),
-            Some(f) => f.run()
+            Some(f) => f()
         }
     }
 }
 
 impl DtorRes {
-    fn new(dtor: Option<~Runnable>) -> DtorRes {
+    fn new(dtor: Option<proc()>) -> DtorRes {
         DtorRes {
             dtor: dtor,
         }
@@ -103,7 +102,7 @@ pub unsafe fn CVec<T>(base: *mut T, len: uint) -> CVec<T> {
  * * dtor - A function to run when the value is destructed, useful
  *          for freeing the buffer, etc.
  */
-pub unsafe fn c_vec_with_dtor<T>(base: *mut T, len: uint, dtor: ~Runnable)
+pub unsafe fn c_vec_with_dtor<T>(base: *mut T, len: uint, dtor: proc())
                                  -> CVec<T> {
     return CVec{
         base: base,
@@ -155,19 +154,6 @@ mod tests {
 
     use std::libc::*;
     use std::libc;
-    use std::routine::Runnable;
-
-    struct LibcFree {
-        mem: *c_void,
-    }
-
-    impl Runnable for LibcFree {
-        fn run(~self) {
-            unsafe {
-                libc::free(self.mem)
-            }
-        }
-    }
 
     fn malloc(n: size_t) -> CVec<u8> {
         unsafe {
@@ -177,9 +163,7 @@ mod tests {
 
             return c_vec_with_dtor(mem as *mut u8,
                                    n as uint,
-                                   ~LibcFree {
-                                    mem: mem,
-                                   } as ~Runnable);
+                                   proc() unsafe { libc::free(mem); });
         }
     }
 

branches/try/src/librustc/driver/session.rs

@@ -28,7 +28,6 @@ use syntax::abi;
 use syntax::parse::token;
 use syntax;
 
-use std::int;
 use std::hashmap::{HashMap,HashSet};
 
 #[deriving(Clone)]
@@ -209,7 +208,7 @@ pub struct Session_ {
     building_library: @mut bool,
     working_dir: Path,
     lints: @mut HashMap<ast::NodeId, ~[(lint::lint, codemap::Span, ~str)]>,
-    node_id: @mut uint,
+    node_id: @mut ast::NodeId,
 }
 
 pub type Session = @Session_;
@@ -274,13 +273,15 @@ impl Session_ {
     pub fn next_node_id(&self) -> ast::NodeId {
         self.reserve_node_ids(1)
     }
-    pub fn reserve_node_ids(&self, count: uint) -> ast::NodeId {
+    pub fn reserve_node_ids(&self, count: ast::NodeId) -> ast::NodeId {
         let v = *self.node_id;
-        *self.node_id += count;
-        if v > (int::max_value as uint) {
-            self.bug("Input too large, ran out of node ids!");
+
+        match v.checked_add(&count) {
+            Some(next) => { *self.node_id = next; }
+            None => self.bug("Input too large, ran out of node ids!")
         }
-        v as int
+
+        v
     }
     pub fn diagnostic(&self) -> @mut diagnostic::span_handler {
         self.span_diagnostic

branches/try/src/librustc/front/config.rs

@@ -48,14 +48,6 @@ pub fn strip_items(crate: ast::Crate,
     ctxt.fold_crate(crate)
 }
 
-fn filter_item(cx: &Context, item: @ast::item) -> Option<@ast::item> {
-    if item_in_cfg(cx, item) {
-        Some(item)
-    } else {
-        None
-    }
-}
-
 fn filter_view_item<'r>(cx: &Context, view_item: &'r ast::view_item)
                         -> Option<&'r ast::view_item> {
     if view_item_in_cfg(cx, view_item) {
@@ -66,9 +58,10 @@ fn filter_view_item<'r>(cx: &Context, view_item: &'r ast::view_item)
 }
 
 fn fold_mod(cx: &Context, m: &ast::_mod) -> ast::_mod {
-    let filtered_items = m.items.iter().filter_map(|a| {
-        filter_item(cx, *a).and_then(|x| cx.fold_item(x))
-    }).collect();
+    let filtered_items = m.items.iter()
+            .filter(|&a| item_in_cfg(cx, *a))
+            .flat_map(|&x| cx.fold_item(x).move_iter())
+            .collect();
     let filtered_view_items = m.view_items.iter().filter_map(|a| {
         filter_view_item(cx, a).map(|x| cx.fold_view_item(x))
     }).collect();
@@ -122,28 +115,25 @@ fn fold_item_underscore(cx: &Context, item: &ast::item_) -> ast::item_ {
     fold::noop_fold_item_underscore(&item, cx)
 }
 
-fn filter_stmt(cx: &Context, stmt: @ast::Stmt) -> Option<@ast::Stmt> {
+fn retain_stmt(cx: &Context, stmt: @ast::Stmt) -> bool {
     match stmt.node {
       ast::StmtDecl(decl, _) => {
         match decl.node {
           ast::DeclItem(item) => {
-            if item_in_cfg(cx, item) {
-                Some(stmt)
-            } else {
-                None
-            }
+            item_in_cfg(cx, item)
           }
-          _ => Some(stmt)
+          _ => true
         }
       }
-      _ => Some(stmt),
+      _ => true
     }
 }
 
 fn fold_block(cx: &Context, b: &ast::Block) -> ast::Block {
-    let resulting_stmts = b.stmts.iter().filter_map(|a| {
-        filter_stmt(cx, *a).and_then(|stmt| cx.fold_stmt(stmt))
-    }).collect();
+    let resulting_stmts = b.stmts.iter()
+            .filter(|&a| retain_stmt(cx, *a))
+            .flat_map(|&stmt| cx.fold_stmt(stmt).move_iter())
+            .collect();
     let filtered_view_items = b.view_items.iter().filter_map(|a| {
         filter_view_item(cx, a).map(|x| cx.fold_view_item(x))
     }).collect();

branches/try/src/librustc/front/feature_gate.rs

@@ -40,6 +40,7 @@ static KNOWN_FEATURES: &'static [(&'static str, Status)] = &[
     ("asm", Active),
     ("managed_boxes", Active),
     ("non_ascii_idents", Active),
+    ("thread_local", Active),
 
     // These are used to test this portion of the compiler, they don't actually
     // mean anything
@@ -109,6 +110,17 @@ impl Visitor<()> for Context {
     }
 
     fn visit_item(&mut self, i: @ast::item, _:()) {
+        // NOTE: uncomment after snapshot
+        /*
+        for attr in i.attrs.iter() {
+            if "thread_local" == attr.name() {
+                self.gate_feature("thread_local", i.span,
+                                  "`#[thread_local]` is an experimental feature, and does not \
+                                  currently handle destructors. There is no corresponding \
+                                  `#[task_local]` mapping to the task model");
+            }
+        }
+        */
         match i.node {
             ast::item_enum(ref def, _) => {
                 for variant in def.variants.iter() {
@@ -154,8 +166,8 @@ impl Visitor<()> for Context {
             },
             ast::ty_box(_) => {
                 self.gate_feature("managed_boxes", t.span,
-                                  "The managed box syntax is being replaced by the `std::gc::Gc`
-                                  and `std::rc::Rc` types. Equivalent functionality to managed
+                                  "The managed box syntax is being replaced by the `std::gc::Gc` \
+                                  and `std::rc::Rc` types. Equivalent functionality to managed \
                                   trait objects will be implemented but is currently missing.");
             }
             _ => {}

branches/try/src/librustc/front/std_inject.rs

@@ -19,6 +19,7 @@ use syntax::codemap;
 use syntax::fold::ast_fold;
 use syntax::fold;
 use syntax::opt_vec;
+use syntax::util::small_vector::SmallVector;
 
 static STD_VERSION: &'static str = "0.9-pre";
 
@@ -98,14 +99,14 @@ impl fold::ast_fold for StandardLibraryInjector {
         }
     }
 
-    fn fold_item(&self, item: @ast::item) -> Option<@ast::item> {
+    fn fold_item(&self, item: @ast::item) -> SmallVector<@ast::item> {
         if !no_prelude(item.attrs) {
             // only recur if there wasn't `#[no_implicit_prelude];`
             // on this item, i.e. this means that the prelude is not
             // implicitly imported though the whole subtree
             fold::noop_fold_item(item, self)
         } else {
-            Some(item)
+            SmallVector::one(item)
         }
     }
 

branches/try/src/librustc/front/test.rs

@@ -26,6 +26,7 @@ use syntax::fold;
 use syntax::opt_vec;
 use syntax::print::pprust;
 use syntax::{ast, ast_util};
+use syntax::util::small_vector::SmallVector;
 
 struct Test {
     span: Span,
@@ -76,7 +77,7 @@ impl fold::ast_fold for TestHarnessGenerator {
         }
     }
 
-    fn fold_item(&self, i: @ast::item) -> Option<@ast::item> {
+    fn fold_item(&self, i: @ast::item) -> SmallVector<@ast::item> {
         self.cx.path.push(i.ident);
         debug!("current path: {}",
                ast_util::path_name_i(self.cx.path.clone()));
@@ -108,7 +109,7 @@ impl fold::ast_fold for TestHarnessGenerator {
 
         let res = fold::noop_fold_item(i, self);
         self.cx.path.pop();
-        return res;
+        res
     }
 
     fn fold_mod(&self, m: &ast::_mod) -> ast::_mod {

branches/try/src/librustc/lib/llvm.rs

@@ -128,22 +128,62 @@ pub enum RealPredicate {
 
 // The LLVM TypeKind type - must stay in sync with the def of
 // LLVMTypeKind in llvm/include/llvm-c/Core.h
+#[cfg(not(stage0))]
+#[deriving(Eq)]
+#[repr(C)]
+pub enum TypeKind {
+    Void      = 0,
+    Half      = 1,
+    Float     = 2,
+    Double    = 3,
+    X86_FP80  = 4,
+    FP128     = 5,
+    PPC_FP128 = 6,
+    Label     = 7,
+    Integer   = 8,
+    Function  = 9,
+    Struct    = 10,
+    Array     = 11,
+    Pointer   = 12,
+    Vector    = 13,
+    Metadata  = 14,
+    X86_MMX   = 15,
+}
+
+// NOTE remove these after snapshot.  (See also #10308.)
+#[cfg(stage0)]
 pub type TypeKind = u32;
+#[cfg(stage0)]
 pub static Void: TypeKind      = 0;
+#[cfg(stage0)]
 pub static Half: TypeKind      = 1;
+#[cfg(stage0)]
 pub static Float: TypeKind     = 2;
+#[cfg(stage0)]
 pub static Double: TypeKind    = 3;
+#[cfg(stage0)]
 pub static X86_FP80: TypeKind  = 4;
+#[cfg(stage0)]
 pub static FP128: TypeKind     = 5;
+#[cfg(stage0)]
 pub static PPC_FP128: TypeKind = 6;
+#[cfg(stage0)]
 pub static Label: TypeKind     = 7;
+#[cfg(stage0)]
 pub static Integer: TypeKind   = 8;
+#[cfg(stage0)]
 pub static Function: TypeKind  = 9;
+#[cfg(stage0)]
 pub static Struct: TypeKind    = 10;
+#[cfg(stage0)]
 pub static Array: TypeKind     = 11;
+#[cfg(stage0)]
 pub static Pointer: TypeKind   = 12;
+#[cfg(stage0)]
 pub static Vector: TypeKind    = 13;
+#[cfg(stage0)]
 pub static Metadata: TypeKind  = 14;
+#[cfg(stage0)]
 pub static X86_MMX: TypeKind   = 15;
 
 #[repr(C)]
@@ -1749,6 +1789,12 @@ pub fn SetUnnamedAddr(Global: ValueRef, Unnamed: bool) {
     }
 }
 
+pub fn set_thread_local(global: ValueRef, is_thread_local: bool) {
+    unsafe {
+        llvm::LLVMSetThreadLocal(global, is_thread_local as Bool);
+    }
+}
+
 pub fn ConstICmp(Pred: IntPredicate, V1: ValueRef, V2: ValueRef) -> ValueRef {
     unsafe {
         llvm::LLVMConstICmp(Pred as c_ushort, V1, V2)

branches/try/src/librustc/metadata/creader.rs

@@ -67,7 +67,7 @@ impl visit::Visitor<()> for ReadCrateVisitor {
 
 #[deriving(Clone)]
 struct cache_entry {
-    cnum: int,
+    cnum: ast::CrateNum,
     span: Span,
     hash: @str,
     metas: @~[@ast::MetaItem]
@@ -242,7 +242,7 @@ fn metas_with_ident(ident: @str, metas: ~[@ast::MetaItem])
 }
 
 fn existing_match(e: &Env, metas: &[@ast::MetaItem], hash: &str)
-               -> Option<int> {
+               -> Option<ast::CrateNum> {
     for c in e.crate_cache.iter() {
         if loader::metadata_matches(*c.metas, metas)
             && (hash.is_empty() || c.hash.as_slice() == hash) {