---

yaml
---
r: 72055
b: refs/heads/dist-snap
c: c98f0cb
h: refs/heads/master
i:
  72053: 6a1d5a2
  72051: dd56f64
  72047: 6a05e00
v: v3

Author: thestinger

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
 refs/heads/incoming: b50030718cf28f2a5a81857a26b57442734fe854
-refs/heads/dist-snap: fdb4ef321ed5eee681c2b723dcb157c280aa72f2
+refs/heads/dist-snap: c98f0cb3627fbdc2f1e56cfe1aad20a96730d208
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/mk/rt.mk

@@ -76,8 +76,7 @@ RUNTIME_CXXS_$(1) := \
               rt/boxed_region.cpp \
               rt/arch/$$(HOST_$(1))/context.cpp \
               rt/arch/$$(HOST_$(1))/gpr.cpp \
-              rt/rust_android_dummy.cpp \
-              rt/rust_test_helpers.cpp
+              rt/rust_android_dummy.cpp
 
 RUNTIME_CS_$(1) := rt/linenoise/linenoise.c rt/linenoise/utf8.c
 

branches/dist-snap/src/libcore/rt/uv/net.rs

@@ -356,6 +356,7 @@ impl NativeHandle<*uvll::uv_write_t> for WriteRequest {
 
 
 #[test]
+#[ignore(reason = "ffi struct issues")]
 fn connect_close() {
     do run_in_bare_thread() {
         let mut loop_ = Loop::new();
@@ -408,6 +409,7 @@ fn connect_read() {
 }
 
 #[test]
+#[ignore(reason = "ffi struct issues")]
 fn listen() {
     do run_in_bare_thread() {
         static MAX: int = 10;

branches/dist-snap/src/libcore/vec.rs

@@ -18,6 +18,10 @@ use cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering, Less, Equal, Greater};
 use clone::Clone;
 use iter::BaseIter;
 use iter;
+#[cfg(stage1)]
+#[cfg(stage2)]
+#[cfg(stage3)]
+use iterator::Iterator;
 use kinds::Copy;
 use libc;
 use option::{None, Option, Some};
@@ -1919,6 +1923,7 @@ impl<'self,T> ImmutableVector<T> for &'self [T] {
 #[cfg(stage3)]
 pub trait ImmutableVector<'self, T> {
     fn slice(&self, start: uint, end: uint) -> &'self [T];
+    fn iter(self) -> VecIterator<'self, T>;
     fn head(&self) -> &'self T;
     fn head_opt(&self) -> Option<&'self T>;
     fn tail(&self) -> &'self [T];
@@ -1949,6 +1954,15 @@ impl<'self,T> ImmutableVector<'self, T> for &'self [T] {
         slice(*self, start, end)
     }
 
+    #[inline]
+    fn iter(self) -> VecIterator<'self, T> {
+        unsafe {
+            let p = vec::raw::to_ptr(self);
+            VecIterator{ptr: p, end: p.offset(self.len()),
+                        lifetime: cast::transmute(p)}
+        }
+    }
+
     /// Returns the first element of a vector, failing if the vector is empty.
     #[inline]
     fn head(&self) -> &'self T { head(*self) }
@@ -2795,7 +2809,33 @@ impl<A:Clone> Clone for ~[A] {
     }
 }
 
-// ___________________________________________________________________________
+// could be implemented with &[T] with .slice(), but this avoids bounds checks
+#[cfg(stage1)]
+#[cfg(stage2)]
+#[cfg(stage3)]
+pub struct VecIterator<'self, T> {
+    priv ptr: *T,
+    priv end: *T,
+    priv lifetime: &'self T // FIXME: #5922
+}
+
+#[cfg(stage1)]
+#[cfg(stage2)]
+#[cfg(stage3)]
+impl<'self, T> Iterator<&'self T> for VecIterator<'self, T> {
+    #[inline]
+    fn next(&mut self) -> Option<&'self T> {
+        unsafe {
+            if self.ptr == self.end {
+                None
+            } else {
+                let old = self.ptr;
+                self.ptr = self.ptr.offset(1);
+                Some(cast::transmute(old))
+            }
+        }
+    }
+}
 
 #[cfg(test)]
 mod tests {
@@ -4421,6 +4461,19 @@ mod tests {
         [1, 2, 3, 4, 5, 5, 5, 5].cmp(& &[1, 2, 3, 4, 5, 6]) == Less;
         [2, 2].cmp(& &[1, 2, 3, 4]) == Greater;
     }
+
+    #[test]
+    fn test_iterator() {
+        use iterator::*;
+        let xs = [1, 2, 5, 10, 11];
+        let ys = [1, 2, 5, 10, 11, 19];
+        let mut it = xs.iter();
+        let mut i = 0;
+        for it.advance |&x| {
+            assert_eq!(x, ys[i]);
+            i += 1;
+        }
+    }
 }
 
 // Local Variables:

branches/dist-snap/src/librustc/lib/llvm.rs

@@ -125,25 +125,27 @@ pub enum RealPredicate {
     RealPredicateTrue = 15,
 }
 
-// The LLVM TypeKind type - must stay in sync with the def of
+// enum for the LLVM TypeKind type - must stay in sync with the def of
 // LLVMTypeKind in llvm/include/llvm-c/Core.h
-pub type TypeKind = u32;
-pub static Void: TypeKind      = 0;
-pub static Half: TypeKind      = 1;
-pub static Float: TypeKind     = 2;
-pub static Double: TypeKind    = 3;
-pub static X86_FP80: TypeKind  = 4;
-pub static FP128: TypeKind     = 5;
-pub static PPC_FP128: TypeKind = 6;
-pub static Label: TypeKind     = 7;
-pub static Integer: TypeKind   = 8;
-pub static Function: TypeKind  = 9;
-pub static Struct: TypeKind    = 10;
-pub static Array: TypeKind     = 11;
-pub static Pointer: TypeKind   = 12;
-pub static Vector: TypeKind    = 13;
-pub static Metadata: TypeKind  = 14;
-pub static X86_MMX: TypeKind   = 15;
+#[deriving(Eq)]
+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
+}
 
 pub enum AtomicBinOp {
     Xchg = 0,
@@ -1580,8 +1582,7 @@ pub fn type_to_str_inner(names: @TypeNames, +outer0: &[TypeRef], ty: TypeRef)
           }
           Vector => return @"Vector",
           Metadata => return @"Metadata",
-          X86_MMX => return @"X86_MMAX",
-          _ => fail!()
+          X86_MMX => return @"X86_MMAX"
         }
     }
 }

branches/dist-snap/src/librustc/metadata/tydecode.rs

@@ -313,9 +313,8 @@ fn parse_ty(st: @mut PState, conv: conv_did) -> ty::t {
         let def = parse_def(st, NominalType, conv);
         let substs = parse_substs(st, conv);
         let store = parse_trait_store(st);
-        let mt = parse_mutability(st);
         assert!(next(st) == ']');
-        return ty::mk_trait(st.tcx, def, substs, store, mt);
+        return ty::mk_trait(st.tcx, def, substs, store);
       }
       'p' => {
         let did = parse_def(st, TypeParameter, conv);
@@ -397,16 +396,13 @@ fn parse_ty(st: @mut PState, conv: conv_did) -> ty::t {
     }
 }
 
-fn parse_mutability(st: @mut PState) -> ast::mutability {
+fn parse_mt(st: @mut PState, conv: conv_did) -> ty::mt {
+    let mut m;
     match peek(st) {
-      'm' => { next(st); ast::m_mutbl }
-      '?' => { next(st); ast::m_const }
-      _ => { ast::m_imm }
+      'm' => { next(st); m = ast::m_mutbl; }
+      '?' => { next(st); m = ast::m_const; }
+      _ => { m = ast::m_imm; }
     }
-}
-
-fn parse_mt(st: @mut PState, conv: conv_did) -> ty::mt {
-    let m = parse_mutability(st);
     ty::mt { ty: parse_ty(st, conv), mutbl: m }
 }
 

branches/dist-snap/src/librustc/metadata/tyencode.rs

@@ -22,7 +22,6 @@ use core::io;
 use core::uint;
 use core::vec;
 use syntax::abi::AbiSet;
-use syntax::ast;
 use syntax::ast::*;
 use syntax::diagnostic::span_handler;
 use syntax::print::pprust::*;
@@ -114,17 +113,12 @@ pub fn enc_ty(w: @io::Writer, cx: @ctxt, t: ty::t) {
       }
     }
 }
-
-fn enc_mutability(w: @io::Writer, mt: ast::mutability) {
-    match mt {
+fn enc_mt(w: @io::Writer, cx: @ctxt, mt: ty::mt) {
+    match mt.mutbl {
       m_imm => (),
       m_mutbl => w.write_char('m'),
       m_const => w.write_char('?')
     }
-}
-
-fn enc_mt(w: @io::Writer, cx: @ctxt, mt: ty::mt) {
-    enc_mutability(w, mt.mutbl);
     enc_ty(w, cx, mt.ty);
 }
 
@@ -275,13 +269,12 @@ fn enc_sty(w: @io::Writer, cx: @ctxt, +st: ty::sty) {
         enc_substs(w, cx, (*substs));
         w.write_char(']');
       }
-      ty::ty_trait(def, ref substs, store, mt) => {
+      ty::ty_trait(def, ref substs, store) => {
         w.write_str(&"x[");
         w.write_str((cx.ds)(def));
         w.write_char('|');
         enc_substs(w, cx, (*substs));
         enc_trait_store(w, cx, store);
-        enc_mutability(w, mt);
         w.write_char(']');
       }
       ty::ty_tup(ts) => {

branches/dist-snap/src/librustc/middle/kind.rs

@@ -589,7 +589,7 @@ pub fn check_cast_for_escaping_regions(
 pub fn check_kind_bounds_of_cast(cx: Context, source: @expr, target: @expr) {
     let target_ty = ty::expr_ty(cx.tcx, target);
     match ty::get(target_ty).sty {
-        ty::ty_trait(_, _, ty::UniqTraitStore, _) => {
+        ty::ty_trait(_, _, ty::UniqTraitStore) => {
             let source_ty = ty::expr_ty(cx.tcx, source);
             if !ty::type_is_owned(cx.tcx, source_ty) {
                 cx.tcx.sess.span_err(

branches/dist-snap/src/librustc/middle/trans/cabi.rs

@@ -180,3 +180,37 @@ pub impl FnType {
         Ret(bcx, llretval);
     }
 }
+
+enum LLVM_ABIInfo { LLVM_ABIInfo }
+
+impl ABIInfo for LLVM_ABIInfo {
+    fn compute_info(&self,
+                    atys: &[TypeRef],
+                    rty: TypeRef,
+                    _ret_def: bool) -> FnType {
+        let arg_tys = do atys.map |a| {
+            LLVMType { cast: false, ty: *a }
+        };
+        let ret_ty = LLVMType {
+            cast: false,
+            ty: rty
+        };
+        let attrs = do atys.map |_| {
+            option::None
+        };
+        let sret = false;
+
+        return FnType {
+            arg_tys: arg_tys,
+            ret_ty: ret_ty,
+            attrs: attrs,
+            sret: sret
+        };
+    }
+}
+
+pub fn llvm_abi_info() -> @ABIInfo {
+    return @LLVM_ABIInfo as @ABIInfo;
+}
+
+

branches/dist-snap/src/librustc/middle/trans/cabi_mips.rs

@@ -227,6 +227,6 @@ impl ABIInfo for MIPS_ABIInfo {
     }
 }
 
-pub fn abi_info() -> @ABIInfo {
+pub fn mips_abi_info() -> @ABIInfo {
     return @MIPS_ABIInfo as @ABIInfo;
 }

branches/dist-snap/src/librustc/middle/trans/cabi_x86.rs

@@ -410,6 +410,6 @@ impl ABIInfo for X86_64_ABIInfo {
     }
 }
 
-pub fn abi_info() -> @ABIInfo {
+pub fn x86_64_abi_info() -> @ABIInfo {
     return @X86_64_ABIInfo as @ABIInfo;
 }