---

yaml
---
r: 90099
b: refs/heads/master
c: 31da6b7
h: refs/heads/master
i:
  90097: 4e5223b
  90095: 54e9e3f
v: v3

Author: brendanzab

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: faf4c939fb6c55f0b9d19b1292fa4601169b3c17
+refs/heads/master: 31da6b76986f337483a971884113a043c835102b
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d3e57dca68fde4effdda3e4ae2887aa535fcd6
 refs/heads/try: b160761e35efcd1207112b3b782c06633cf441a8

trunk/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);
         }
     }
 

trunk/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

trunk/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) {

trunk/src/librustc/metadata/decoder.rs

@@ -76,18 +76,18 @@ fn lookup_hash(d: ebml::Doc, eq_fn: |&[u8]| -> bool, hash: u64) ->
 
 pub type GetCrateDataCb<'self> = 'self |ast::CrateNum| -> Cmd;
 
-pub fn maybe_find_item(item_id: ast::NodeId, items: ebml::Doc) -> Option<ebml::Doc> {
-    fn eq_item(bytes: &[u8], item_id: ast::NodeId) -> bool {
+pub fn maybe_find_item(item_id: int, items: ebml::Doc) -> Option<ebml::Doc> {
+    fn eq_item(bytes: &[u8], item_id: int) -> bool {
         return u64_from_be_bytes(
-            bytes.slice(0u, 4u), 0u, 4u) as ast::NodeId
+            bytes.slice(0u, 4u), 0u, 4u) as int
             == item_id;
     }
     lookup_hash(items,
                 |a| eq_item(a, item_id),
                 (item_id as i64).hash())
 }
 
-fn find_item(item_id: ast::NodeId, items: ebml::Doc) -> ebml::Doc {
+fn find_item(item_id: int, items: ebml::Doc) -> ebml::Doc {
     match maybe_find_item(item_id, items) {
        None => fail!("lookup_item: id not found: {}", item_id),
        Some(d) => d
@@ -96,7 +96,7 @@ fn find_item(item_id: ast::NodeId, items: ebml::Doc) -> ebml::Doc {
 
 // Looks up an item in the given metadata and returns an ebml doc pointing
 // to the item data.
-pub fn lookup_item(item_id: ast::NodeId, data: @~[u8]) -> ebml::Doc {
+pub fn lookup_item(item_id: int, data: @~[u8]) -> ebml::Doc {
     let items = reader::get_doc(reader::Doc(data), tag_items);
     find_item(item_id, items)
 }
@@ -343,7 +343,7 @@ fn item_name(intr: @ident_interner, item: ebml::Doc) -> ast::Ident {
     let string = name.as_str_slice();
     match intr.find_equiv(&string) {
         None => token::str_to_ident(string),
-        Some(val) => ast::Ident::new(val as ast::Name),
+        Some(val) => ast::Ident::new(val),
     }
 }
 

trunk/src/librustc/metadata/tydecode.rs

@@ -58,7 +58,7 @@ type conv_did<'self> =
 
 pub struct PState<'self> {
     data: &'self [u8],
-    crate: ast::CrateNum,
+    crate: int,
     pos: uint,
     tcx: ty::ctxt
 }
@@ -101,7 +101,7 @@ fn parse_ident_(st: &mut PState, is_last: |char| -> bool) -> ast::Ident {
     return st.tcx.sess.ident_of(rslt);
 }
 
-pub fn parse_state_from_data<'a>(data: &'a [u8], crate_num: ast::CrateNum,
+pub fn parse_state_from_data<'a>(data: &'a [u8], crate_num: int,
                              pos: uint, tcx: ty::ctxt) -> PState<'a> {
     PState {
         data: data,
@@ -111,19 +111,19 @@ pub fn parse_state_from_data<'a>(data: &'a [u8], crate_num: ast::CrateNum,
     }
 }
 
-pub fn parse_ty_data(data: &[u8], crate_num: ast::CrateNum, pos: uint, tcx: ty::ctxt,
+pub fn parse_ty_data(data: &[u8], crate_num: int, pos: uint, tcx: ty::ctxt,
                      conv: conv_did) -> ty::t {
     let mut st = parse_state_from_data(data, crate_num, pos, tcx);
     parse_ty(&mut st, conv)
 }
 
-pub fn parse_bare_fn_ty_data(data: &[u8], crate_num: ast::CrateNum, pos: uint, tcx: ty::ctxt,
+pub fn parse_bare_fn_ty_data(data: &[u8], crate_num: int, pos: uint, tcx: ty::ctxt,
                              conv: conv_did) -> ty::BareFnTy {
     let mut st = parse_state_from_data(data, crate_num, pos, tcx);
     parse_bare_fn_ty(&mut st, conv)
 }
 
-pub fn parse_trait_ref_data(data: &[u8], crate_num: ast::CrateNum, pos: uint, tcx: ty::ctxt,
+pub fn parse_trait_ref_data(data: &[u8], crate_num: int, pos: uint, tcx: ty::ctxt,
                             conv: conv_did) -> ty::TraitRef {
     let mut st = parse_state_from_data(data, crate_num, pos, tcx);
     parse_trait_ref(&mut st, conv)
@@ -251,15 +251,15 @@ fn parse_region(st: &mut PState, conv: conv_did) -> ty::Region {
     match next(st) {
       'b' => {
         assert_eq!(next(st), '[');
-        let id = parse_uint(st) as ast::NodeId;
+        let id = parse_uint(st) as int;
         assert_eq!(next(st), '|');
         let br = parse_bound_region(st, |x,y| conv(x,y));
         assert_eq!(next(st), ']');
         ty::ReLateBound(id, br)
       }
       'B' => {
         assert_eq!(next(st), '[');
-        let node_id = parse_uint(st) as ast::NodeId;
+        let node_id = parse_uint(st) as int;
         assert_eq!(next(st), '|');
         let index = parse_uint(st);
         assert_eq!(next(st), '|');
@@ -268,15 +268,15 @@ fn parse_region(st: &mut PState, conv: conv_did) -> ty::Region {
       }
       'f' => {
         assert_eq!(next(st), '[');
-        let id = parse_uint(st) as ast::NodeId;
+        let id = parse_uint(st) as int;
         assert_eq!(next(st), '|');
         let br = parse_bound_region(st, |x,y| conv(x,y));
         assert_eq!(next(st), ']');
         ty::ReFree(ty::FreeRegion {scope_id: id,
                                     bound_region: br})
       }
       's' => {
-        let id = parse_uint(st) as ast::NodeId;
+        let id = parse_uint(st) as int;
         assert_eq!(next(st), '|');
         ty::ReScope(id)
       }
@@ -539,7 +539,7 @@ fn parse_bare_fn_ty(st: &mut PState, conv: conv_did) -> ty::BareFnTy {
 
 fn parse_sig(st: &mut PState, conv: conv_did) -> ty::FnSig {
     assert_eq!(next(st), '[');
-    let id = parse_uint(st) as ast::NodeId;
+    let id = parse_uint(st) as int;
     assert_eq!(next(st), '|');
     let mut inputs = ~[];
     while peek(st) != ']' {
@@ -572,20 +572,20 @@ pub fn parse_def_id(buf: &[u8]) -> ast::DefId {
     let def_part = buf.slice(colon_idx + 1u, len);
 
     let crate_num = match uint::parse_bytes(crate_part, 10u) {
-       Some(cn) => cn as ast::CrateNum,
+       Some(cn) => cn as int,
        None => fail!("internal error: parse_def_id: crate number expected, but found {:?}",
                      crate_part)
     };
     let def_num = match uint::parse_bytes(def_part, 10u) {
-       Some(dn) => dn as ast::NodeId,
+       Some(dn) => dn as int,
        None => fail!("internal error: parse_def_id: id expected, but found {:?}",
                      def_part)
     };
     ast::DefId { crate: crate_num, node: def_num }
 }
 
 pub fn parse_type_param_def_data(data: &[u8], start: uint,
-                                 crate_num: ast::CrateNum, tcx: ty::ctxt,
+                                 crate_num: int, tcx: ty::ctxt,
                                  conv: conv_did) -> ty::TypeParameterDef
 {
     let mut st = parse_state_from_data(data, crate_num, start, tcx);

trunk/src/librustc/middle/astencode.rs

@@ -161,7 +161,8 @@ fn reserve_id_range(sess: Session,
     // Handle the case of an empty range:
     if from_id_range.empty() { return from_id_range; }
     let cnt = from_id_range.max - from_id_range.min;
-    let to_id_min = sess.reserve_node_ids(cnt);
+    assert!(cnt >= 0);
+    let to_id_min = sess.reserve_node_ids(cnt as uint);
     let to_id_max = to_id_min + cnt;
     ast_util::id_range { min: to_id_min, max: to_id_max }
 }
@@ -1203,7 +1204,7 @@ fn decode_side_tables(xcx: @ExtendedDecodeContext,
     let tbl_doc = ast_doc.get(c::tag_table as uint);
     reader::docs(tbl_doc, |tag, entry_doc| {
         let id0 = entry_doc.get(c::tag_table_id as uint).as_int();
-        let id = xcx.tr_id(id0 as ast::NodeId);
+        let id = xcx.tr_id(id0);
 
         debug!(">> Side table document with tag 0x{:x} \
                 found for id {} (orig {})",

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

@@ -278,6 +278,10 @@ impl Type {
         Type::opaque_box(cx).ptr_to()
     }
 
+    pub fn enum_discrim(cx: &CrateContext) -> Type {
+        cx.int_type
+    }
+
     pub fn opaque_trait(ctx: &CrateContext, store: ty::TraitStore) -> Type {
         let tydesc_ptr = ctx.tydesc_type.ptr_to();
         let box_ty = match store {

trunk/src/librustc/middle/ty.rs

@@ -169,7 +169,7 @@ pub struct field_ty {
 // the types of AST nodes.
 #[deriving(Eq,IterBytes)]
 pub struct creader_cache_key {
-    cnum: CrateNum,
+    cnum: int,
     pos: uint,
     len: uint
 }