---

yaml
---
r: 93946
b: refs/heads/try
c: a9bd049
h: refs/heads/master
v: v3

Author: alexcrichton

[refs]

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

branches/try/doc/rust.md

@@ -1754,8 +1754,6 @@ 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,6 +37,7 @@
  */
 
 use std::ptr;
+use std::routine::Runnable;
 use std::util;
 
 /**
@@ -49,7 +50,7 @@ pub struct CVec<T> {
 }
 
 struct DtorRes {
-    dtor: Option<proc()>,
+    dtor: Option<~Runnable>,
 }
 
 #[unsafe_destructor]
@@ -58,13 +59,13 @@ impl Drop for DtorRes {
         let dtor = util::replace(&mut self.dtor, None);
         match dtor {
             None => (),
-            Some(f) => f()
+            Some(f) => f.run()
         }
     }
 }
 
 impl DtorRes {
-    fn new(dtor: Option<proc()>) -> DtorRes {
+    fn new(dtor: Option<~Runnable>) -> DtorRes {
         DtorRes {
             dtor: dtor,
         }
@@ -102,7 +103,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: proc())
+pub unsafe fn c_vec_with_dtor<T>(base: *mut T, len: uint, dtor: ~Runnable)
                                  -> CVec<T> {
     return CVec{
         base: base,
@@ -154,6 +155,19 @@ 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 {
@@ -163,7 +177,9 @@ mod tests {
 
             return c_vec_with_dtor(mem as *mut u8,
                                    n as uint,
-                                   proc() unsafe { libc::free(mem); });
+                                   ~LibcFree {
+                                    mem: mem,
+                                   } as ~Runnable);
         }
     }
 

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

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

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

@@ -48,6 +48,14 @@ 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) {
@@ -58,10 +66,9 @@ 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(|&a| item_in_cfg(cx, *a))
-            .flat_map(|&x| cx.fold_item(x).move_iter())
-            .collect();
+    let filtered_items = m.items.iter().filter_map(|a| {
+        filter_item(cx, *a).and_then(|x| cx.fold_item(x))
+    }).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();
@@ -115,25 +122,28 @@ fn fold_item_underscore(cx: &Context, item: &ast::item_) -> ast::item_ {
     fold::noop_fold_item_underscore(&item, cx)
 }
 
-fn retain_stmt(cx: &Context, stmt: @ast::Stmt) -> bool {
+fn filter_stmt(cx: &Context, stmt: @ast::Stmt) -> Option<@ast::Stmt> {
     match stmt.node {
       ast::StmtDecl(decl, _) => {
         match decl.node {
           ast::DeclItem(item) => {
-            item_in_cfg(cx, item)
+            if item_in_cfg(cx, item) {
+                Some(stmt)
+            } else {
+                None
+            }
           }
-          _ => true
+          _ => Some(stmt)
         }
       }
-      _ => true
+      _ => Some(stmt),
     }
 }
 
 fn fold_block(cx: &Context, b: &ast::Block) -> ast::Block {
-    let resulting_stmts = b.stmts.iter()
-            .filter(|&a| retain_stmt(cx, *a))
-            .flat_map(|&stmt| cx.fold_stmt(stmt).move_iter())
-            .collect();
+    let resulting_stmts = b.stmts.iter().filter_map(|a| {
+        filter_stmt(cx, *a).and_then(|stmt| cx.fold_stmt(stmt))
+    }).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

@@ -18,6 +18,8 @@
 //! Features are enabled in programs via the crate-level attributes of
 //! #[feature(...)] with a comma-separated list of features.
 
+use middle::lint;
+
 use syntax::ast;
 use syntax::attr::AttrMetaMethods;
 use syntax::codemap::Span;
@@ -38,7 +40,6 @@ 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
@@ -108,17 +109,6 @@ 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() {
@@ -164,8 +154,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.");
             }
             _ => {}
@@ -209,7 +199,10 @@ pub fn check_crate(sess: Session, crate: &ast::Crate) {
                                                      directive not necessary");
                         }
                         None => {
-                            sess.span_err(mi.span, "unknown feature");
+                            sess.add_lint(lint::unknown_features,
+                                          ast::CRATE_NODE_ID,
+                                          mi.span,
+                                          ~"unknown feature");
                         }
                     }
                 }

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

@@ -19,7 +19,6 @@ 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";
 
@@ -99,14 +98,14 @@ impl fold::ast_fold for StandardLibraryInjector {
         }
     }
 
-    fn fold_item(&self, item: @ast::item) -> SmallVector<@ast::item> {
+    fn fold_item(&self, item: @ast::item) -> Option<@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 {
-            SmallVector::one(item)
+            Some(item)
         }
     }
 

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

@@ -26,7 +26,6 @@ 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,
@@ -77,7 +76,7 @@ impl fold::ast_fold for TestHarnessGenerator {
         }
     }
 
-    fn fold_item(&self, i: @ast::item) -> SmallVector<@ast::item> {
+    fn fold_item(&self, i: @ast::item) -> Option<@ast::item> {
         self.cx.path.push(i.ident);
         debug!("current path: {}",
                ast_util::path_name_i(self.cx.path.clone()));
@@ -109,7 +108,7 @@ impl fold::ast_fold for TestHarnessGenerator {
 
         let res = fold::noop_fold_item(i, self);
         self.cx.path.pop();
-        res
+        return res;
     }
 
     fn fold_mod(&self, m: &ast::_mod) -> ast::_mod {

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

@@ -128,62 +128,22 @@ 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)]
@@ -1789,12 +1749,6 @@ 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: ast::CrateNum,
+    cnum: int,
     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<ast::CrateNum> {
+               -> Option<int> {
     for c in e.crate_cache.iter() {
         if loader::metadata_matches(*c.metas, metas)
             && (hash.is_empty() || c.hash.as_slice() == hash) {