auto merge of #7254 : Blei/rust/intrinsic-overhaul, r=cmr

This sets the `get_tydesc()` return type correctly and removes the intrinsic module. See #3730, #3475.

Update: this now also removes the unused shape fields in tydescs.

src/test/run-pass/extern-pub.rs

@@ -1,11 +1,5 @@
-use std::libc;
-use std::sys;
-use std::vec;
-
 extern {
-    pub unsafe fn vec_reserve_shared_actual(t: *sys::TypeDesc,
-                                            v: **vec::raw::VecRepr,
-                                            n: libc::size_t);
+    pub unsafe fn free(p: *u8);
 }
 
 pub fn main() {

src/test/run-pass/reflect-visit-data.rs

@@ -10,15 +10,14 @@
 
 // xfail-fast
 
-use std::bool;
 use std::int;
 use std::libc::c_void;
 use std::ptr;
 use std::sys;
 use std::vec::UnboxedVecRepr;
-use intrinsic::{TyDesc, get_tydesc, visit_tydesc, TyVisitor, Opaque};
+use std::unstable::intrinsics::{TyDesc, get_tydesc, visit_tydesc, TyVisitor, Opaque};
 
-#[doc = "High-level interfaces to `intrinsic::visit_ty` reflection system."]
+#[doc = "High-level interfaces to `std::unstable::intrinsics::visit_ty` reflection system."]
 
 /// Trait for visitor that wishes to reflect on data.
 trait movable_ptr {
@@ -637,7 +636,9 @@ impl TyVisitor for my_visitor {
 }
 
 fn get_tydesc_for<T>(_t: T) -> *TyDesc {
-    get_tydesc::<T>()
+    unsafe {
+        get_tydesc::<T>()
+    }
 }
 
 struct Triple { x: int, y: int, z: int }
@@ -651,8 +652,8 @@ pub fn main() {
                                        vals: ~[]});
         let v = ptr_visit_adaptor(Inner {inner: u});
         let td = get_tydesc_for(r);
-        unsafe { error!("tydesc sz: %u, align: %u",
-                        (*td).size, (*td).align); }
+        error!("tydesc sz: %u, align: %u",
+               (*td).size, (*td).align);
         let v = @v as @TyVisitor;
         visit_tydesc(td, v);
 
@@ -661,8 +662,7 @@ pub fn main() {
             println(fmt!("val: %s", *s));
         }
         error!("%?", u.vals.clone());
-        assert!(u.vals == ~[
-            ~"1", ~"2", ~"3", ~"true", ~"false", ~"5", ~"4", ~"3", ~"12"
-        ]);
+        assert_eq!(u.vals.clone(),
+                   ~[ ~"1", ~"2", ~"3", ~"true", ~"false", ~"5", ~"4", ~"3", ~"12"]);
     }
- }
+}

src/test/run-pass/reflect-visit-type.rs

@@ -8,141 +8,153 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// xfail-test
-use intrinsic::{TyDesc, get_tydesc, visit_tydesc, TyVisitor};
-struct my_visitor(@mut { types: ~[str] });
+use std::unstable::intrinsics::{TyDesc, get_tydesc, visit_tydesc, TyVisitor, Opaque};
 
-impl TyVisitor for my_visitor {
-    fn visit_bot() -> bool {
-        self.types += ~["bot"];
+struct MyVisitor {
+    types: @mut ~[~str],
+}
+
+impl TyVisitor for MyVisitor {
+    fn visit_bot(&self) -> bool {
+        self.types.push(~"bot");
         error!("visited bot type");
         true
     }
-    fn visit_nil() -> bool {
-        self.types += ~["nil"];
+    fn visit_nil(&self) -> bool {
+        self.types.push(~"nil");
         error!("visited nil type");
         true
     }
-    fn visit_bool() -> bool {
-        self.types += ~["bool"];
+    fn visit_bool(&self) -> bool {
+        self.types.push(~"bool");
         error!("visited bool type");
         true
     }
-    fn visit_int() -> bool {
-        self.types += ~["int"];
+    fn visit_int(&self) -> bool {
+        self.types.push(~"int");
         error!("visited int type");
         true
     }
-    fn visit_i8() -> bool {
-        self.types += ~["i8"];
+    fn visit_i8(&self) -> bool {
+        self.types.push(~"i8");
         error!("visited i8 type");
         true
     }
-    fn visit_i16() -> bool {
-        self.types += ~["i16"];
+    fn visit_i16(&self) -> bool {
+        self.types.push(~"i16");
         error!("visited i16 type");
         true
     }
-    fn visit_i32() -> bool { true }
-    fn visit_i64() -> bool { true }
+    fn visit_i32(&self) -> bool { true }
+    fn visit_i64(&self) -> bool { true }
 
-    fn visit_uint() -> bool { true }
-    fn visit_u8() -> bool { true }
-    fn visit_u16() -> bool { true }
-    fn visit_u32() -> bool { true }
-    fn visit_u64() -> bool { true }
+    fn visit_uint(&self) -> bool { true }
+    fn visit_u8(&self) -> bool { true }
+    fn visit_u16(&self) -> bool { true }
+    fn visit_u32(&self) -> bool { true }
+    fn visit_u64(&self) -> bool { true }
 
-    fn visit_float() -> bool { true }
-    fn visit_f32() -> bool { true }
-    fn visit_f64() -> bool { true }
+    fn visit_float(&self) -> bool { true }
+    fn visit_f32(&self) -> bool { true }
+    fn visit_f64(&self) -> bool { true }
 
-    fn visit_char() -> bool { true }
-    fn visit_str() -> bool { true }
+    fn visit_char(&self) -> bool { true }
+    fn visit_str(&self) -> bool { true }
 
-    fn visit_estr_box() -> bool { true }
-    fn visit_estr_uniq() -> bool { true }
-    fn visit_estr_slice() -> bool { true }
-    fn visit_estr_fixed(_sz: uint, _sz: uint,
+    fn visit_estr_box(&self) -> bool { true }
+    fn visit_estr_uniq(&self) -> bool { true }
+    fn visit_estr_slice(&self) -> bool { true }
+    fn visit_estr_fixed(&self,
+                        _sz: uint, _sz: uint,
                         _align: uint) -> bool { true }
 
-    fn visit_box(_mtbl: uint, _inner: *TyDesc) -> bool { true }
-    fn visit_uniq(_mtbl: uint, _inner: *TyDesc) -> bool { true }
-    fn visit_ptr(_mtbl: uint, _inner: *TyDesc) -> bool { true }
-    fn visit_rptr(_mtbl: uint, _inner: *TyDesc) -> bool { true }
+    fn visit_box(&self, _mtbl: uint, _inner: *TyDesc) -> bool { true }
+    fn visit_uniq(&self, _mtbl: uint, _inner: *TyDesc) -> bool { true }
+    fn visit_ptr(&self, _mtbl: uint, _inner: *TyDesc) -> bool { true }
+    fn visit_rptr(&self, _mtbl: uint, _inner: *TyDesc) -> bool { true }
 
-    fn visit_vec(_mtbl: uint, inner: *TyDesc) -> bool {
-        self.types += ~["["];
-        visit_tydesc(inner, my_visitor(*self) as TyVisitor);
-        self.types += ~["]"];
+    fn visit_vec(&self, _mtbl: uint, _inner: *TyDesc) -> bool { true }
+    fn visit_unboxed_vec(&self, _mtbl: uint, _inner: *TyDesc) -> bool { true }
+    fn visit_evec_box(&self, _mtbl: uint, _inner: *TyDesc) -> bool { true }
+    fn visit_evec_uniq(&self, _mtbl: uint, inner: *TyDesc) -> bool {
+        self.types.push(~"[");
+        unsafe {
+            visit_tydesc(inner, (@*self) as @TyVisitor);
+        }
+        self.types.push(~"]");
         true
     }
-    fn visit_unboxed_vec(_mtbl: uint, _inner: *TyDesc) -> bool { true }
-    fn visit_evec_box(_mtbl: uint, _inner: *TyDesc) -> bool { true }
-    fn visit_evec_uniq(_mtbl: uint, _inner: *TyDesc) -> bool { true }
-    fn visit_evec_slice(_mtbl: uint, _inner: *TyDesc) -> bool { true }
-    fn visit_evec_fixed(_n: uint, _sz: uint, _align: uint,
+    fn visit_evec_slice(&self, _mtbl: uint, _inner: *TyDesc) -> bool { true }
+    fn visit_evec_fixed(&self, _n: uint, _sz: uint, _align: uint,
                         _mtbl: uint, _inner: *TyDesc) -> bool { true }
 
-    fn visit_enter_rec(_n_fields: uint,
+    fn visit_enter_rec(&self, _n_fields: uint,
                        _sz: uint, _align: uint) -> bool { true }
-    fn visit_rec_field(_i: uint, _name: &str,
+    fn visit_rec_field(&self, _i: uint, _name: &str,
                        _mtbl: uint, _inner: *TyDesc) -> bool { true }
-    fn visit_leave_rec(_n_fields: uint,
+    fn visit_leave_rec(&self, _n_fields: uint,
                        _sz: uint, _align: uint) -> bool { true }
 
-    fn visit_enter_class(_n_fields: uint,
+    fn visit_enter_class(&self, _n_fields: uint,
                          _sz: uint, _align: uint) -> bool { true }
-    fn visit_class_field(_i: uint, _name: &str,
+    fn visit_class_field(&self, _i: uint, _name: &str,
                          _mtbl: uint, _inner: *TyDesc) -> bool { true }
-    fn visit_leave_class(_n_fields: uint,
+    fn visit_leave_class(&self, _n_fields: uint,
                          _sz: uint, _align: uint) -> bool { true }
 
-    fn visit_enter_tup(_n_fields: uint,
+    fn visit_enter_tup(&self, _n_fields: uint,
                        _sz: uint, _align: uint) -> bool { true }
-    fn visit_tup_field(_i: uint, _inner: *TyDesc) -> bool { true }
-    fn visit_leave_tup(_n_fields: uint,
+    fn visit_tup_field(&self, _i: uint, _inner: *TyDesc) -> bool { true }
+    fn visit_leave_tup(&self, _n_fields: uint,
                        _sz: uint, _align: uint) -> bool { true }
 
-    fn visit_enter_enum(_n_variants: uint,
+    fn visit_enter_enum(&self, _n_variants: uint,
+                        _get_disr: extern unsafe fn(ptr: *Opaque) -> int,
                         _sz: uint, _align: uint) -> bool { true }
-    fn visit_enter_enum_variant(_variant: uint,
+    fn visit_enter_enum_variant(&self,
+                                _variant: uint,
                                 _disr_val: int,
                                 _n_fields: uint,
                                 _name: &str) -> bool { true }
-    fn visit_enum_variant_field(_i: uint, _inner: *TyDesc) -> bool { true }
-    fn visit_leave_enum_variant(_variant: uint,
+    fn visit_enum_variant_field(&self, _i: uint, _offset: uint, _inner: *TyDesc) -> bool { true }
+    fn visit_leave_enum_variant(&self,
+                                _variant: uint,
                                 _disr_val: int,
                                 _n_fields: uint,
                                 _name: &str) -> bool { true }
-    fn visit_leave_enum(_n_variants: uint,
+    fn visit_leave_enum(&self,
+                        _n_variants: uint,
+                        _get_disr: extern unsafe fn(ptr: *Opaque) -> int,
                         _sz: uint, _align: uint) -> bool { true }
 
-    fn visit_enter_fn(_purity: uint, _proto: uint,
+    fn visit_enter_fn(&self, _purity: uint, _proto: uint,
                       _n_inputs: uint, _retstyle: uint) -> bool { true }
-    fn visit_fn_input(_i: uint, _mode: uint, _inner: *TyDesc) -> bool { true }
-    fn visit_fn_output(_retstyle: uint, _inner: *TyDesc) -> bool { true }
-    fn visit_leave_fn(_purity: uint, _proto: uint,
+    fn visit_fn_input(&self, _i: uint, _mode: uint, _inner: *TyDesc) -> bool { true }
+    fn visit_fn_output(&self, _retstyle: uint, _inner: *TyDesc) -> bool { true }
+    fn visit_leave_fn(&self, _purity: uint, _proto: uint,
                       _n_inputs: uint, _retstyle: uint) -> bool { true }
 
 
-    fn visit_trait() -> bool { true }
-    fn visit_var() -> bool { true }
-    fn visit_var_integral() -> bool { true }
-    fn visit_param(_i: uint) -> bool { true }
-    fn visit_self() -> bool { true }
-    fn visit_type() -> bool { true }
-    fn visit_opaque_box() -> bool { true }
-    fn visit_constr(_inner: *TyDesc) -> bool { true }
-    fn visit_closure_ptr(_ck: uint) -> bool { true }
+    fn visit_trait(&self) -> bool { true }
+    fn visit_var(&self) -> bool { true }
+    fn visit_var_integral(&self) -> bool { true }
+    fn visit_param(&self, _i: uint) -> bool { true }
+    fn visit_self(&self) -> bool { true }
+    fn visit_type(&self) -> bool { true }
+    fn visit_opaque_box(&self) -> bool { true }
+    fn visit_constr(&self, _inner: *TyDesc) -> bool { true }
+    fn visit_closure_ptr(&self, _ck: uint) -> bool { true }
 }
 
-fn visit_ty<T>(v: TyVisitor) {
-    visit_tydesc(get_tydesc::<T>(), v);
+fn visit_ty<T>(v: @TyVisitor) {
+    unsafe {
+        visit_tydesc(get_tydesc::<T>(), v);
+    }
 }
 
 pub fn main() {
-    let v = my_visitor(@mut {types: ~[]});
-    let vv = v as TyVisitor;
+    let v = @MyVisitor {types: @mut ~[]};
+    let vv = v as @TyVisitor;
 
     visit_ty::<bool>(vv);
     visit_ty::<int>(vv);
@@ -150,9 +162,8 @@ pub fn main() {
     visit_ty::<i16>(vv);
     visit_ty::<~[int]>(vv);
 
-    for (v.types.clone()).each {|s|
-        io::println(fmt!("type: %s", s));
+    for v.types.iter().advance |&s| {
+        println(fmt!("type: %s", s));
     }
-    assert!(v.types == ["bool", "int", "i8", "i16",
-                       "[", "int", "]"]);
+    assert_eq!((*v.types).clone(), ~[~"bool", ~"int", ~"i8", ~"i16", ~"[", ~"int", ~"]"]);
 }