librustc: De-implicit-self the visitor. r=graydon

diff --git a/src/libcargo/cargo.rc b/src/libcargo/cargo.rc
index da90a129e9a6351e9f31cce196100cf12c6c6637..64bf8ef05ba2459e1a21fe39a695bf8767421ccb 100644 (file)
--- a/src/libcargo/cargo.rc
+++ b/src/libcargo/cargo.rc
@@ -35,6 +35,7 @@
 #[allow(non_camel_case_types)];
 #[allow(deprecated_mode)];
 #[allow(deprecated_pattern)];
+#[allow(deprecated_self)];
 
 extern mod core(vers = "0.6");
 extern mod std(vers = "0.6");

diff --git a/src/libcore/core.rc b/src/libcore/core.rc
index f7a65ed1fe442ae7e7537df9db0af0d0c49c02fa..1ac0bf4c0c5c053d36a83953cf53e5a31065cd70 100644 (file)
--- a/src/libcore/core.rc
+++ b/src/libcore/core.rc
@@ -52,6 +52,7 @@ Implicitly, all crates behave as if they included the following prologue:
 #[warn(deprecated_pattern)];
 #[warn(vecs_implicitly_copyable)];
 #[deny(non_camel_case_types)];
+#[allow(deprecated_self)];
 
 /* The Prelude. */
 

diff --git a/src/libcore/reflect.rs b/src/libcore/reflect.rs
index 81a36e1ae13eeae027a4f2ef0eb924dd0a1d1974..94fc9e37a751904d06b899d44e8f43ae3c4339fc 100644 (file)
--- a/src/libcore/reflect.rs
+++ b/src/libcore/reflect.rs
@@ -75,6 +75,7 @@ fn bump_past<T>() {
 }
 
 /// Abstract type-directed pointer-movement using the MovePtr trait
+#[cfg(stage0)]
 impl<V: TyVisitor MovePtr> MovePtrAdaptor<V>: TyVisitor {
     fn visit_bot() -> bool {
         self.align_to::<()>();
@@ -325,7 +326,8 @@ fn visit_leave_rec(n_fields: uint, sz: uint, align: uint) -> bool {
         true
     }
 
-    fn visit_enter_class(n_fields: uint, sz: uint, align: uint) -> bool {
+    fn visit_enter_class(n_fields: uint, sz: uint, align: uint)
+                      -> bool {
         self.align(align);
         if ! self.inner.visit_enter_class(n_fields, sz, align) {
             return false;
@@ -343,7 +345,8 @@ fn visit_class_field(i: uint, name: &str,
         true
     }
 
-    fn visit_leave_class(n_fields: uint, sz: uint, align: uint) -> bool {
+    fn visit_leave_class(n_fields: uint, sz: uint, align: uint)
+                      -> bool {
         if ! self.inner.visit_leave_class(n_fields, sz, align) {
             return false;
         }
@@ -394,7 +397,8 @@ fn visit_leave_fn(purity: uint, proto: uint,
         true
     }
 
-    fn visit_enter_enum(n_variants: uint, sz: uint, align: uint) -> bool {
+    fn visit_enter_enum(n_variants: uint, sz: uint, align: uint)
+                     -> bool {
         self.align(align);
         if ! self.inner.visit_enter_enum(n_variants, sz, align) {
             return false;
@@ -433,7 +437,8 @@ fn visit_leave_enum_variant(variant: uint,
         true
     }
 
-    fn visit_leave_enum(n_variants: uint, sz: uint, align: uint) -> bool {
+    fn visit_leave_enum(n_variants: uint, sz: uint, align: uint)
+                     -> bool {
         if ! self.inner.visit_leave_enum(n_variants, sz, align) {
             return false;
         }
@@ -494,3 +499,430 @@ fn visit_closure_ptr(ck: uint) -> bool {
         true
     }
 }
+
+/// Abstract type-directed pointer-movement using the MovePtr trait
+#[cfg(stage1)]
+#[cfg(stage2)]
+impl<V: TyVisitor MovePtr> MovePtrAdaptor<V>: TyVisitor {
+    fn visit_bot(&self) -> bool {
+        self.align_to::<()>();
+        if ! self.inner.visit_bot() { return false; }
+        self.bump_past::<()>();
+        true
+    }
+
+    fn visit_nil(&self) -> bool {
+        self.align_to::<()>();
+        if ! self.inner.visit_nil() { return false; }
+        self.bump_past::<()>();
+        true
+    }
+
+    fn visit_bool(&self) -> bool {
+        self.align_to::<bool>();
+        if ! self.inner.visit_bool() { return false; }
+        self.bump_past::<bool>();
+        true
+    }
+
+    fn visit_int(&self) -> bool {
+        self.align_to::<int>();
+        if ! self.inner.visit_int() { return false; }
+        self.bump_past::<int>();
+        true
+    }
+
+    fn visit_i8(&self) -> bool {
+        self.align_to::<i8>();
+        if ! self.inner.visit_i8() { return false; }
+        self.bump_past::<i8>();
+        true
+    }
+
+    fn visit_i16(&self) -> bool {
+        self.align_to::<i16>();
+        if ! self.inner.visit_i16() { return false; }
+        self.bump_past::<i16>();
+        true
+    }
+
+    fn visit_i32(&self) -> bool {
+        self.align_to::<i32>();
+        if ! self.inner.visit_i32() { return false; }
+        self.bump_past::<i32>();
+        true
+    }
+
+    fn visit_i64(&self) -> bool {
+        self.align_to::<i64>();
+        if ! self.inner.visit_i64() { return false; }
+        self.bump_past::<i64>();
+        true
+    }
+
+    fn visit_uint(&self) -> bool {
+        self.align_to::<uint>();
+        if ! self.inner.visit_uint() { return false; }
+        self.bump_past::<uint>();
+        true
+    }
+
+    fn visit_u8(&self) -> bool {
+        self.align_to::<u8>();
+        if ! self.inner.visit_u8() { return false; }
+        self.bump_past::<u8>();
+        true
+    }
+
+    fn visit_u16(&self) -> bool {
+        self.align_to::<u16>();
+        if ! self.inner.visit_u16() { return false; }
+        self.bump_past::<u16>();
+        true
+    }
+
+    fn visit_u32(&self) -> bool {
+        self.align_to::<u32>();
+        if ! self.inner.visit_u32() { return false; }
+        self.bump_past::<u32>();
+        true
+    }
+
+    fn visit_u64(&self) -> bool {
+        self.align_to::<u64>();
+        if ! self.inner.visit_u64() { return false; }
+        self.bump_past::<u64>();
+        true
+    }
+
+    fn visit_float(&self) -> bool {
+        self.align_to::<float>();
+        if ! self.inner.visit_float() { return false; }
+        self.bump_past::<float>();
+        true
+    }
+
+    fn visit_f32(&self) -> bool {
+        self.align_to::<f32>();
+        if ! self.inner.visit_f32() { return false; }
+        self.bump_past::<f32>();
+        true
+    }
+
+    fn visit_f64(&self) -> bool {
+        self.align_to::<f64>();
+        if ! self.inner.visit_f64() { return false; }
+        self.bump_past::<f64>();
+        true
+    }
+
+    fn visit_char(&self) -> bool {
+        self.align_to::<char>();
+        if ! self.inner.visit_char() { return false; }
+        self.bump_past::<char>();
+        true
+    }
+
+    fn visit_str(&self) -> bool {
+        self.align_to::<~str>();
+        if ! self.inner.visit_str() { return false; }
+        self.bump_past::<~str>();
+        true
+    }
+
+    fn visit_estr_box(&self) -> bool {
+        self.align_to::<@str>();
+        if ! self.inner.visit_estr_box() { return false; }
+        self.bump_past::<@str>();
+        true
+    }
+
+    fn visit_estr_uniq(&self) -> bool {
+        self.align_to::<~str>();
+        if ! self.inner.visit_estr_uniq() { return false; }
+        self.bump_past::<~str>();
+        true
+    }
+
+    fn visit_estr_slice(&self) -> bool {
+        self.align_to::<&static/str>();
+        if ! self.inner.visit_estr_slice() { return false; }
+        self.bump_past::<&static/str>();
+        true
+    }
+
+    fn visit_estr_fixed(&self, n: uint,
+                        sz: uint,
+                        align: uint) -> bool {
+        self.align(align);
+        if ! self.inner.visit_estr_fixed(n, sz, align) { return false; }
+        self.bump(sz);
+        true
+    }
+
+    fn visit_box(&self, mtbl: uint, inner: *TyDesc) -> bool {
+        self.align_to::<@u8>();
+        if ! self.inner.visit_box(mtbl, inner) { return false; }
+        self.bump_past::<@u8>();
+        true
+    }
+
+    fn visit_uniq(&self, mtbl: uint, inner: *TyDesc) -> bool {
+        self.align_to::<~u8>();
+        if ! self.inner.visit_uniq(mtbl, inner) { return false; }
+        self.bump_past::<~u8>();
+        true
+    }
+
+    fn visit_ptr(&self, mtbl: uint, inner: *TyDesc) -> bool {
+        self.align_to::<*u8>();
+        if ! self.inner.visit_ptr(mtbl, inner) { return false; }
+        self.bump_past::<*u8>();
+        true
+    }
+
+    fn visit_rptr(&self, mtbl: uint, inner: *TyDesc) -> bool {
+        self.align_to::<&static/u8>();
+        if ! self.inner.visit_rptr(mtbl, inner) { return false; }
+        self.bump_past::<&static/u8>();
+        true
+    }
+
+    fn visit_unboxed_vec(&self, mtbl: uint, inner: *TyDesc) -> bool {
+        self.align_to::<vec::UnboxedVecRepr>();
+        if ! self.inner.visit_vec(mtbl, inner) { return false; }
+        true
+    }
+
+    fn visit_vec(&self, mtbl: uint, inner: *TyDesc) -> bool {
+        self.align_to::<~[u8]>();
+        if ! self.inner.visit_vec(mtbl, inner) { return false; }
+        self.bump_past::<~[u8]>();
+        true
+    }
+
+    fn visit_evec_box(&self, mtbl: uint, inner: *TyDesc) -> bool {
+        self.align_to::<@[u8]>();
+        if ! self.inner.visit_evec_box(mtbl, inner) { return false; }
+        self.bump_past::<@[u8]>();
+        true
+    }
+
+    fn visit_evec_uniq(&self, mtbl: uint, inner: *TyDesc) -> bool {
+        self.align_to::<~[u8]>();
+        if ! self.inner.visit_evec_uniq(mtbl, inner) { return false; }
+        self.bump_past::<~[u8]>();
+        true
+    }
+
+    fn visit_evec_slice(&self, mtbl: uint, inner: *TyDesc) -> bool {
+        self.align_to::<&static/[u8]>();
+        if ! self.inner.visit_evec_slice(mtbl, inner) { return false; }
+        self.bump_past::<&static/[u8]>();
+        true
+    }
+
+    fn visit_evec_fixed(&self, n: uint, sz: uint, align: uint,
+                        mtbl: uint, inner: *TyDesc) -> bool {
+        self.align(align);
+        if ! self.inner.visit_evec_fixed(n, sz, align, mtbl, inner) {
+            return false;
+        }
+        self.bump(sz);
+        true
+    }
+
+    fn visit_enter_rec(&self, n_fields: uint, sz: uint, align: uint) -> bool {
+        self.align(align);
+        if ! self.inner.visit_enter_rec(n_fields, sz, align) { return false; }
+        true
+    }
+
+    fn visit_rec_field(&self, i: uint, name: &str,
+                       mtbl: uint, inner: *TyDesc) -> bool {
+        unsafe { self.align((*inner).align); }
+        if ! self.inner.visit_rec_field(i, name, mtbl, inner) {
+            return false;
+        }
+        unsafe { self.bump((*inner).size); }
+        true
+    }
+
+    fn visit_leave_rec(&self, n_fields: uint, sz: uint, align: uint) -> bool {
+        if ! self.inner.visit_leave_rec(n_fields, sz, align) { return false; }
+        true
+    }
+
+    fn visit_enter_class(&self, n_fields: uint, sz: uint, align: uint)
+                      -> bool {
+        self.align(align);
+        if ! self.inner.visit_enter_class(n_fields, sz, align) {
+            return false;
+        }
+        true
+    }
+
+    fn visit_class_field(&self, i: uint, name: &str,
+                         mtbl: uint, inner: *TyDesc) -> bool {
+        unsafe { self.align((*inner).align); }
+        if ! self.inner.visit_class_field(i, name, mtbl, inner) {
+            return false;
+        }
+        unsafe { self.bump((*inner).size); }
+        true
+    }
+
+    fn visit_leave_class(&self, n_fields: uint, sz: uint, align: uint)
+                      -> bool {
+        if ! self.inner.visit_leave_class(n_fields, sz, align) {
+            return false;
+        }
+        true
+    }
+
+    fn visit_enter_tup(&self, n_fields: uint, sz: uint, align: uint) -> bool {
+        self.align(align);
+        if ! self.inner.visit_enter_tup(n_fields, sz, align) { return false; }
+        true
+    }
+
+    fn visit_tup_field(&self, i: uint, inner: *TyDesc) -> bool {
+        unsafe { self.align((*inner).align); }
+        if ! self.inner.visit_tup_field(i, inner) { return false; }
+        unsafe { self.bump((*inner).size); }
+        true
+    }
+
+    fn visit_leave_tup(&self, n_fields: uint, sz: uint, align: uint) -> bool {
+        if ! self.inner.visit_leave_tup(n_fields, sz, align) { return false; }
+        true
+    }
+
+    fn visit_enter_fn(&self, purity: uint, proto: uint,
+                      n_inputs: uint, retstyle: uint) -> bool {
+        if ! self.inner.visit_enter_fn(purity, proto, n_inputs, retstyle) {
+            return false
+        }
+        true
+    }
+
+    fn visit_fn_input(&self, i: uint, mode: uint, inner: *TyDesc) -> bool {
+        if ! self.inner.visit_fn_input(i, mode, inner) { return false; }
+        true
+    }
+
+    fn visit_fn_output(&self, retstyle: uint, inner: *TyDesc) -> bool {
+        if ! self.inner.visit_fn_output(retstyle, inner) { return false; }
+        true
+    }
+
+    fn visit_leave_fn(&self, purity: uint, proto: uint,
+                      n_inputs: uint, retstyle: uint) -> bool {
+        if ! self.inner.visit_leave_fn(purity, proto, n_inputs, retstyle) {
+            return false;
+        }
+        true
+    }
+
+    fn visit_enter_enum(&self, n_variants: uint, sz: uint, align: uint)
+                     -> bool {
+        self.align(align);
+        if ! self.inner.visit_enter_enum(n_variants, sz, align) {
+            return false;
+        }
+        true
+    }
+
+    fn visit_enter_enum_variant(&self, variant: uint,
+                                disr_val: int,
+                                n_fields: uint,
+                                name: &str) -> bool {
+        self.inner.push_ptr();
+        if ! self.inner.visit_enter_enum_variant(variant, disr_val,
+                                                 n_fields, name) {
+            return false;
+        }
+        true
+    }
+
+    fn visit_enum_variant_field(&self, i: uint, inner: *TyDesc) -> bool {
+        unsafe { self.align((*inner).align); }
+        if ! self.inner.visit_enum_variant_field(i, inner) { return false; }
+        unsafe { self.bump((*inner).size); }
+        true
+    }
+
+    fn visit_leave_enum_variant(&self, variant: uint,
+                                disr_val: int,
+                                n_fields: uint,
+                                name: &str) -> bool {
+        if ! self.inner.visit_leave_enum_variant(variant, disr_val,
+                                                 n_fields, name) {
+            return false;
+        }
+        self.inner.pop_ptr();
+        true
+    }
+
+    fn visit_leave_enum(&self, n_variants: uint, sz: uint, align: uint)
+                     -> bool {
+        if ! self.inner.visit_leave_enum(n_variants, sz, align) {
+            return false;
+        }
+        self.bump(sz);
+        true
+    }
+
+    fn visit_trait(&self) -> bool {
+        self.align_to::<TyVisitor>();
+        if ! self.inner.visit_trait() { return false; }
+        self.bump_past::<TyVisitor>();
+        true
+    }
+
+    fn visit_var(&self) -> bool {
+        if ! self.inner.visit_var() { return false; }
+        true
+    }
+
+    fn visit_var_integral(&self) -> bool {
+        if ! self.inner.visit_var_integral() { return false; }
+        true
+    }
+
+    fn visit_param(&self, i: uint) -> bool {
+        if ! self.inner.visit_param(i) { return false; }
+        true
+    }
+
+    fn visit_self(&self) -> bool {
+        self.align_to::<&static/u8>();
+        if ! self.inner.visit_self() { return false; }
+        self.align_to::<&static/u8>();
+        true
+    }
+
+    fn visit_type(&self) -> bool {
+        if ! self.inner.visit_type() { return false; }
+        true
+    }
+
+    fn visit_opaque_box(&self) -> bool {
+        self.align_to::<@u8>();
+        if ! self.inner.visit_opaque_box() { return false; }
+        self.bump_past::<@u8>();
+        true
+    }
+
+    fn visit_constr(&self, inner: *TyDesc) -> bool {
+        if ! self.inner.visit_constr(inner) { return false; }
+        true
+    }
+
+    fn visit_closure_ptr(&self, ck: uint) -> bool {
+        self.align_to::<fn@()>();
+        if ! self.inner.visit_closure_ptr(ck) { return false; }
+        self.bump_past::<fn@()>();
+        true
+    }
+}

diff --git a/src/libcore/repr.rs b/src/libcore/repr.rs
index 4d4970eada8055551eccc56e6dec019d6170ec3a..75a572fa46444e07a7dac967580c4173db297e3e 100644 (file)
--- a/src/libcore/repr.rs
+++ b/src/libcore/repr.rs
@@ -265,6 +265,7 @@ fn write_unboxed_vec_repr(mtbl: uint, v: &UnboxedVecRepr,
 
 }
 
+#[cfg(stage0)]
 impl ReprVisitor : TyVisitor {
     fn visit_bot() -> bool {
         self.writer.write_str("!");
@@ -559,6 +560,310 @@ fn visit_opaque_box() -> bool {
     fn visit_closure_ptr(_ck: uint) -> bool { true }
 }
 
+#[cfg(stage1)]
+#[cfg(stage2)]
+impl ReprVisitor : TyVisitor {
+    fn visit_bot(&self) -> bool {
+        self.writer.write_str("!");
+        true
+    }
+    fn visit_nil(&self) -> bool { self.write::<()>() }
+    fn visit_bool(&self) -> bool { self.write::<bool>() }
+    fn visit_int(&self) -> bool { self.write::<int>() }
+    fn visit_i8(&self) -> bool { self.write::<i8>() }
+    fn visit_i16(&self) -> bool { self.write::<i16>() }
+    fn visit_i32(&self) -> bool { self.write::<i32>()  }
+    fn visit_i64(&self) -> bool { self.write::<i64>() }
+
+    fn visit_uint(&self) -> bool { self.write::<uint>() }
+    fn visit_u8(&self) -> bool { self.write::<u8>() }
+    fn visit_u16(&self) -> bool { self.write::<u16>() }
+    fn visit_u32(&self) -> bool { self.write::<u32>() }
+    fn visit_u64(&self) -> bool { self.write::<u64>() }
+
+    fn visit_float(&self) -> bool { self.write::<float>() }
+    fn visit_f32(&self) -> bool { self.write::<f32>() }
+    fn visit_f64(&self) -> bool { self.write::<f64>() }
+
+    fn visit_char(&self) -> bool {
+        do self.get::<char> |&ch| {
+            self.writer.write_char('\'');
+            self.writer.write_escaped_char(ch);
+            self.writer.write_char('\'');
+        }
+    }
+
+    // Type no longer exists, vestigial function.
+    fn visit_str(&self) -> bool { fail; }
+
+    fn visit_estr_box(&self) -> bool {
+        do self.get::<@str> |s| {
+            self.writer.write_char('@');
+            self.write_escaped_slice(*s);
+        }
+    }
+    fn visit_estr_uniq(&self) -> bool {
+        do self.get::<~str> |s| {
+            self.writer.write_char('~');
+            self.write_escaped_slice(*s);
+        }
+    }
+    fn visit_estr_slice(&self) -> bool {
+        do self.get::<&str> |s| {
+            self.write_escaped_slice(*s);
+        }
+    }
+
+    // Type no longer exists, vestigial function.
+    fn visit_estr_fixed(&self, _n: uint, _sz: uint,
+                        _align: uint) -> bool { fail; }
+
+    fn visit_box(&self, mtbl: uint, inner: *TyDesc) -> bool {
+        self.writer.write_char('@');
+        self.write_mut_qualifier(mtbl);
+        do self.get::<&managed::raw::BoxRepr> |b| {
+            let p = ptr::to_unsafe_ptr(&b.data) as *c_void;
+            self.visit_ptr_inner(p, inner);
+        }
+    }
+
+    fn visit_uniq(&self, mtbl: uint, inner: *TyDesc) -> bool {
+        self.writer.write_char('~');
+        self.write_mut_qualifier(mtbl);
+        do self.get::<&managed::raw::BoxRepr> |b| {
+            let p = ptr::to_unsafe_ptr(&b.data) as *c_void;
+            self.visit_ptr_inner(p, inner);
+        }
+    }
+
+    fn visit_ptr(&self, _mtbl: uint, _inner: *TyDesc) -> bool {
+        do self.get::<*c_void> |p| {
+            self.writer.write_str(fmt!("(0x%x as *())",
+                                       *p as uint));
+        }
+    }
+
+    fn visit_rptr(&self, mtbl: uint, inner: *TyDesc) -> bool {
+        self.writer.write_char('&');
+        self.write_mut_qualifier(mtbl);
+        do self.get::<*c_void> |p| {
+            self.visit_ptr_inner(*p, inner);
+        }
+    }
+
+    // Type no longer exists, vestigial function.
+    fn visit_vec(&self, _mtbl: uint, _inner: *TyDesc) -> bool { fail; }
+
+
+    fn visit_unboxed_vec(&self, mtbl: uint, inner: *TyDesc) -> bool {
+        do self.get::<vec::UnboxedVecRepr> |b| {
+            self.write_unboxed_vec_repr(mtbl, b, inner);
+        }
+    }
+
+    fn visit_evec_box(&self, mtbl: uint, inner: *TyDesc) -> bool {
+        do self.get::<&VecRepr> |b| {
+            self.writer.write_char('@');
+            self.write_unboxed_vec_repr(mtbl, &b.unboxed, inner);
+        }
+    }
+
+    fn visit_evec_uniq(&self, mtbl: uint, inner: *TyDesc) -> bool {
+        do self.get::<&VecRepr> |b| {
+            self.writer.write_char('~');
+            self.write_unboxed_vec_repr(mtbl, &b.unboxed, inner);
+        }
+    }
+
+    fn visit_evec_slice(&self, mtbl: uint, inner: *TyDesc) -> bool {
+        do self.get::<SliceRepr> |s| {
+            self.writer.write_char('&');
+            self.write_vec_range(mtbl, s.data, s.len, inner);
+        }
+    }
+
+    fn visit_evec_fixed(&self, _n: uint, sz: uint, _align: uint,
+                        mtbl: uint, inner: *TyDesc) -> bool {
+        do self.get::<u8> |b| {
+            self.write_vec_range(mtbl, ptr::to_unsafe_ptr(b), sz, inner);
+        }
+    }
+
+    fn visit_enter_rec(&self, _n_fields: uint,
+                       _sz: uint, _align: uint) -> bool {
+        self.writer.write_char('{');
+        true
+    }
+
+    fn visit_rec_field(&self, i: uint, name: &str,
+                       mtbl: uint, inner: *TyDesc) -> bool {
+        if i != 0 {
+            self.writer.write_str(", ");
+        }
+        self.write_mut_qualifier(mtbl);
+        self.writer.write_str(name);
+        self.writer.write_str(": ");
+        self.visit_inner(inner);
+        true
+    }
+
+    fn visit_leave_rec(&self, _n_fields: uint,
+                       _sz: uint, _align: uint) -> bool {
+        self.writer.write_char('}');
+        true
+    }
+
+    fn visit_enter_class(&self, _n_fields: uint,
+                         _sz: uint, _align: uint) -> bool {
+        self.writer.write_char('{');
+        true
+    }
+    fn visit_class_field(&self, i: uint, name: &str,
+                         mtbl: uint, inner: *TyDesc) -> bool {
+        if i != 0 {
+            self.writer.write_str(", ");
+        }
+        self.write_mut_qualifier(mtbl);
+        self.writer.write_str(name);
+        self.writer.write_str(": ");
+        self.visit_inner(inner);
+        true
+    }
+    fn visit_leave_class(&self, _n_fields: uint,
+                         _sz: uint, _align: uint) -> bool {
+        self.writer.write_char('}');
+        true
+    }
+
+    fn visit_enter_tup(&self, _n_fields: uint,
+                       _sz: uint, _align: uint) -> bool {
+        self.writer.write_char('(');
+        true
+    }
+    fn visit_tup_field(&self, i: uint, inner: *TyDesc) -> bool {
+        if i != 0 {
+            self.writer.write_str(", ");
+        }
+        self.visit_inner(inner);
+        true
+    }
+    fn visit_leave_tup(&self, _n_fields: uint,
+                       _sz: uint, _align: uint) -> bool {
+        self.writer.write_char(')');
+        true
+    }
+
+    fn visit_enter_enum(&self, n_variants: uint,
+                        _sz: uint, _align: uint) -> bool {
+        if n_variants == 1 {
+            self.var_stk.push(Degenerate)
+        } else {
+            self.var_stk.push(TagMatch)
+        }
+        true
+    }
+
+    fn visit_enter_enum_variant(&self, _variant: uint,
+                                disr_val: int,
+                                n_fields: uint,
+                                name: &str) -> bool {
+        let mut write = false;
+        match self.var_stk.pop() {
+            Degenerate => {
+                write = true;
+                self.var_stk.push(Degenerate);
+            }
+            TagMatch | TagMismatch => {
+                do self.get::<int>() |t| {
+                    if disr_val == *t {
+                        write = true;
+                        self.var_stk.push(TagMatch);
+                    } else {
+                        self.var_stk.push(TagMismatch);
+                    }
+                };
+                self.bump_past::<int>();
+            }
+        }
+
+        if write {
+            self.writer.write_str(name);
+            if n_fields > 0 {
+                self.writer.write_char('(');
+            }
+        }
+        true
+    }
+
+    fn visit_enum_variant_field(&self, i: uint, inner: *TyDesc) -> bool {
+        match self.var_stk.last() {
+            Degenerate | TagMatch => {
+                if i != 0 {
+                    self.writer.write_str(", ");
+                }
+                if ! self.visit_inner(inner) {
+                    return false;
+                }
+            }
+            TagMismatch => ()
+        }
+        true
+    }
+
+    fn visit_leave_enum_variant(&self, _variant: uint,
+                                _disr_val: int,
+                                n_fields: uint,
+                                _name: &str) -> bool {
+        match self.var_stk.last() {
+            Degenerate | TagMatch => {
+                if n_fields > 0 {
+                    self.writer.write_char(')');
+                }
+            }
+            TagMismatch => ()
+        }
+        true
+    }
+
+    fn visit_leave_enum(&self, _n_variants: uint,
+                        _sz: uint, _align: uint) -> bool {
+        self.var_stk.pop();
+        true
+    }
+
+    fn visit_enter_fn(&self, _purity: uint, _proto: uint,
+                      _n_inputs: uint, _retstyle: uint) -> bool { true }
+    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(&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 {
+        self.writer.write_char('@');
+        do self.get::<&managed::raw::BoxRepr> |b| {
+            let p = ptr::to_unsafe_ptr(&b.data) as *c_void;
+            self.visit_ptr_inner(p, b.header.type_desc);
+        }
+    }
+
+    // Type no longer exists, vestigial function.
+    fn visit_constr(&self, _inner: *TyDesc) -> bool { fail; }
+
+    fn visit_closure_ptr(&self, _ck: uint) -> bool { true }
+}
+
 pub fn write_repr<T>(writer: @Writer, object: &T) {
     unsafe {
         let ptr = ptr::to_unsafe_ptr(object) as *c_void;

diff --git a/src/librustc/front/intrinsic.rs b/src/librustc/front/intrinsic.rs
index 6657e6fcf0fee4fb6682a0ff2bf1f8d9c3b567c9..5ccac6f091accc7b99b6e2336eac6288b25aba4f 100644 (file)
--- a/src/librustc/front/intrinsic.rs
+++ b/src/librustc/front/intrinsic.rs
@@ -31,97 +31,97 @@ pub enum TyDesc = {
     };
 
     trait TyVisitor {
-        fn visit_bot() -> bool;
-        fn visit_nil() -> bool;
-        fn visit_bool() -> bool;
-
-        fn visit_int() -> bool;
-        fn visit_i8() -> bool;
-        fn visit_i16() -> bool;
-        fn visit_i32() -> bool;
-        fn visit_i64() -> bool;
-
-        fn visit_uint() -> bool;
-        fn visit_u8() -> bool;
-        fn visit_u16() -> bool;
-        fn visit_u32() -> bool;
-        fn visit_u64() -> bool;
-
-        fn visit_float() -> bool;
-        fn visit_f32() -> bool;
-        fn visit_f64() -> bool;
-
-        fn visit_char() -> bool;
-        fn visit_str() -> bool;
-
-        fn visit_estr_box() -> bool;
-        fn visit_estr_uniq() -> bool;
-        fn visit_estr_slice() -> bool;
-        fn visit_estr_fixed(n: uint, sz: uint, align: uint) -> bool;
-
-        fn visit_box(mtbl: uint, inner: *TyDesc) -> bool;
-        fn visit_uniq(mtbl: uint, inner: *TyDesc) -> bool;
-        fn visit_ptr(mtbl: uint, inner: *TyDesc) -> bool;
-        fn visit_rptr(mtbl: uint, inner: *TyDesc) -> bool;
-
-        fn visit_vec(mtbl: uint, inner: *TyDesc) -> bool;
-        fn visit_unboxed_vec(mtbl: uint, inner: *TyDesc) -> bool;
-        fn visit_evec_box(mtbl: uint, inner: *TyDesc) -> bool;
-        fn visit_evec_uniq(mtbl: uint, inner: *TyDesc) -> bool;
-        fn visit_evec_slice(mtbl: uint, inner: *TyDesc) -> bool;
-        fn visit_evec_fixed(n: uint, sz: uint, align: uint,
+        fn visit_bot(&self) -> bool;
+        fn visit_nil(&self) -> bool;
+        fn visit_bool(&self) -> bool;
+
+        fn visit_int(&self) -> bool;
+        fn visit_i8(&self) -> bool;
+        fn visit_i16(&self) -> bool;
+        fn visit_i32(&self) -> bool;
+        fn visit_i64(&self) -> bool;
+
+        fn visit_uint(&self) -> bool;
+        fn visit_u8(&self) -> bool;
+        fn visit_u16(&self) -> bool;
+        fn visit_u32(&self) -> bool;
+        fn visit_u64(&self) -> bool;
+
+        fn visit_float(&self) -> bool;
+        fn visit_f32(&self) -> bool;
+        fn visit_f64(&self) -> bool;
+
+        fn visit_char(&self) -> bool;
+        fn visit_str(&self) -> bool;
+
+        fn visit_estr_box(&self) -> bool;
+        fn visit_estr_uniq(&self) -> bool;
+        fn visit_estr_slice(&self) -> bool;
+        fn visit_estr_fixed(&self, n: uint, sz: uint, align: uint) -> bool;
+
+        fn visit_box(&self, mtbl: uint, inner: *TyDesc) -> bool;
+        fn visit_uniq(&self, mtbl: uint, inner: *TyDesc) -> bool;
+        fn visit_ptr(&self, mtbl: uint, inner: *TyDesc) -> bool;
+        fn visit_rptr(&self, mtbl: uint, inner: *TyDesc) -> bool;
+
+        fn visit_vec(&self, mtbl: uint, inner: *TyDesc) -> bool;
+        fn visit_unboxed_vec(&self, mtbl: uint, inner: *TyDesc) -> bool;
+        fn visit_evec_box(&self, mtbl: uint, inner: *TyDesc) -> bool;
+        fn visit_evec_uniq(&self, mtbl: uint, inner: *TyDesc) -> bool;
+        fn visit_evec_slice(&self, mtbl: uint, inner: *TyDesc) -> bool;
+        fn visit_evec_fixed(&self, n: uint, sz: uint, align: uint,
                             mtbl: uint, inner: *TyDesc) -> bool;
 
-        fn visit_enter_rec(n_fields: uint,
+        fn visit_enter_rec(&self, n_fields: uint,
                            sz: uint, align: uint) -> bool;
-        fn visit_rec_field(i: uint, name: &str,
+        fn visit_rec_field(&self, i: uint, name: &str,
                            mtbl: uint, inner: *TyDesc) -> bool;
-        fn visit_leave_rec(n_fields: uint,
+        fn visit_leave_rec(&self, n_fields: uint,
                            sz: uint, align: uint) -> bool;
 
-        fn visit_enter_class(n_fields: uint,
+        fn visit_enter_class(&self, n_fields: uint,
                              sz: uint, align: uint) -> bool;
-        fn visit_class_field(i: uint, name: &str,
+        fn visit_class_field(&self, i: uint, name: &str,
                              mtbl: uint, inner: *TyDesc) -> bool;
-        fn visit_leave_class(n_fields: uint,
+        fn visit_leave_class(&self, n_fields: uint,
                              sz: uint, align: uint) -> bool;
 
-        fn visit_enter_tup(n_fields: uint,
+        fn visit_enter_tup(&self, n_fields: uint,
                            sz: uint, align: uint) -> bool;
-        fn visit_tup_field(i: uint, inner: *TyDesc) -> bool;
-        fn visit_leave_tup(n_fields: uint,
+        fn visit_tup_field(&self, i: uint, inner: *TyDesc) -> bool;
+        fn visit_leave_tup(&self, n_fields: uint,
                            sz: uint, align: uint) -> bool;
 
-        fn visit_enter_enum(n_variants: uint,
+        fn visit_enter_enum(&self, n_variants: uint,
                             sz: uint, align: uint) -> bool;
-        fn visit_enter_enum_variant(variant: uint,
+        fn visit_enter_enum_variant(&self, variant: uint,
                                     disr_val: int,
                                     n_fields: uint,
                                     name: &str) -> bool;
-        fn visit_enum_variant_field(i: uint, inner: *TyDesc) -> bool;
-        fn visit_leave_enum_variant(variant: uint,
+        fn visit_enum_variant_field(&self, i: uint, inner: *TyDesc) -> bool;
+        fn visit_leave_enum_variant(&self, variant: uint,
                                     disr_val: int,
                                     n_fields: uint,
                                     name: &str) -> bool;
-        fn visit_leave_enum(n_variants: uint,
+        fn visit_leave_enum(&self, n_variants: uint,
                             sz: uint, align: uint) -> bool;
 
-        fn visit_enter_fn(purity: uint, proto: uint,
+        fn visit_enter_fn(&self, purity: uint, proto: uint,
                           n_inputs: uint, retstyle: uint) -> bool;
-        fn visit_fn_input(i: uint, mode: uint, inner: *TyDesc) -> bool;
-        fn visit_fn_output(retstyle: uint, inner: *TyDesc) -> bool;
-        fn visit_leave_fn(purity: uint, proto: uint,
+        fn visit_fn_input(&self, i: uint, mode: uint, inner: *TyDesc) -> bool;
+        fn visit_fn_output(&self, retstyle: uint, inner: *TyDesc) -> bool;
+        fn visit_leave_fn(&self, purity: uint, proto: uint,
                           n_inputs: uint, retstyle: uint) -> bool;
 
-        fn visit_trait() -> bool;
-        fn visit_var() -> bool;
-        fn visit_var_integral() -> bool;
-        fn visit_param(i: uint) -> bool;
-        fn visit_self() -> bool;
-        fn visit_type() -> bool;
-        fn visit_opaque_box() -> bool;
-        fn visit_constr(inner: *TyDesc) -> bool;
-        fn visit_closure_ptr(ck: uint) -> bool;
+        fn visit_trait(&self) -> bool;
+        fn visit_var(&self) -> bool;
+        fn visit_var_integral(&self) -> bool;
+        fn visit_param(&self, i: uint) -> bool;
+        fn visit_self(&self) -> bool;
+        fn visit_type(&self) -> bool;
+        fn visit_opaque_box(&self) -> bool;
+        fn visit_constr(&self, inner: *TyDesc) -> bool;
+        fn visit_closure_ptr(&self, ck: uint) -> bool;
     }
 
     #[abi = "rust-intrinsic"]

diff --git a/src/librustc/middle/lint.rs b/src/librustc/middle/lint.rs
index 0ee7e7ef370028376051c1efb0fd4aa77aeb19a0..af490aef3f470f2ca7209eeab8eaeef00185e577 100644 (file)
--- a/src/librustc/middle/lint.rs
+++ b/src/librustc/middle/lint.rs
@@ -233,7 +233,7 @@ fn get_lint_dict() -> lint_dict {
         (~"deprecated_self",
          @{lint: deprecated_self,
            desc: "warn about deprecated uses of `self`",
-           default: allow}),
+           default: warn}),
 
         /* FIXME(#3266)--make liveness warnings lintable
         (~"unused_variable",
@@ -631,13 +631,18 @@ fn check_item_deprecated_self(cx: ty::ctxt, item: @ast::item) {
     fn maybe_warn(cx: ty::ctxt,
                   item: @ast::item,
                   self_ty: ast::self_ty) {
-        cx.sess.span_lint(
-            deprecated_self,
-            item.id,
-            item.id,
-            self_ty.span,
-            ~"this method form is deprecated; use an explicit `self` \
-              parameter or mark the method as static");
+        match self_ty.node {
+            ast::sty_by_ref => {
+                cx.sess.span_lint(
+                    deprecated_self,
+                    item.id,
+                    item.id,
+                    self_ty.span,
+                    ~"this method form is deprecated; use an explicit `self` \
+                      parameter or mark the method as static");
+            }
+            _ => {}
+        }
     }
 
     match /*bad*/copy item.node {

diff --git a/src/librustc/middle/trans/reflect.rs b/src/librustc/middle/trans/reflect.rs
index 39ab5735dee3f023b997519081475d8cdf455250..ba9ff3a4f98bb043511100abb5398f67952de595 100644 (file)
--- a/src/librustc/middle/trans/reflect.rs
+++ b/src/librustc/middle/trans/reflect.rs
@@ -105,7 +105,8 @@ fn visit(ty_name: ~str, args: ~[ValueRef]) {
                                                       mth_idx,
                                                       v,
                                                       ty::vstore_box,
-                                                      ast::sty_by_ref),
+                                                      ast::sty_region(
+                                                        ast::m_imm)),
             ArgVals(args), SaveIn(scratch.val), DontAutorefArg);
         let result = scratch.to_value_llval(bcx);
         let next_bcx = sub_block(bcx, ~"next");

diff --git a/src/librustc/rustc.rc b/src/librustc/rustc.rc
index 1542e9f237bb2dd75d16e30323011194b8fc9817..059ada8b46efcee3de76ba7b54a7fafb58759e95 100644 (file)
--- a/src/librustc/rustc.rc
+++ b/src/librustc/rustc.rc
@@ -26,6 +26,7 @@
 #[allow(non_camel_case_types)];
 #[allow(deprecated_mode)];
 #[warn(deprecated_pattern)];
+#[allow(deprecated_self)];
 
 #[no_core];
 

diff --git a/src/librustdoc/rustdoc.rc b/src/librustdoc/rustdoc.rc
index ce0524f451d88f775d9854585ecf2d966c9f7209..ce42910f7019174c0378826c130b40b370d92577 100644 (file)
--- a/src/librustdoc/rustdoc.rc
+++ b/src/librustdoc/rustdoc.rc
@@ -27,6 +27,7 @@
 #[allow(non_implicitly_copyable_typarams)];
 #[allow(deprecated_mode)];
 #[allow(deprecated_pattern)];
+#[allow(deprecated_self)];
 
 extern mod core(vers = "0.6");
 extern mod std(vers = "0.6");

diff --git a/src/libstd/std.rc b/src/libstd/std.rc
index cac57f2ac448298be25c6cbf2c1298640e4e6678..51b55b1c46fd2f10ae8a0dbdc171517515d9053d 100644 (file)
--- a/src/libstd/std.rc
+++ b/src/libstd/std.rc
@@ -32,6 +32,7 @@ not required in or otherwise suitable for the core library.
 // that can't be silenced otherwise. Most every module is set to forbid
 #[allow(deprecated_mode)];
 #[forbid(deprecated_pattern)];
+#[allow(deprecated_self)];
 
 
 // Transitional

diff --git a/src/libsyntax/syntax.rc b/src/libsyntax/syntax.rc
index c167efad18f1e94c54d4d8be0e4292894049a564..13b32d52f119342a7b9cff0ff24c9fb84a062a89 100644 (file)
--- a/src/libsyntax/syntax.rc
+++ b/src/libsyntax/syntax.rc
@@ -24,6 +24,7 @@
 #[allow(non_camel_case_types)];
 #[allow(deprecated_mode)];
 #[warn(deprecated_pattern)];
+#[allow(deprecated_self)];
 
 #[no_core];
 

diff --git a/src/test/compile-fail/lint-default-methods.rs b/src/test/compile-fail/lint-default-methods.rs
index 6b71f9e972fb22e3c333c3da5d469b65f1646c7b..1350c3e3ad1cd5459245b819f8f89b02487a4b7b 100644 (file)
--- a/src/test/compile-fail/lint-default-methods.rs
+++ b/src/test/compile-fail/lint-default-methods.rs
@@ -1,7 +1,7 @@
 #[forbid(default_methods)];
 
 trait Foo { //~ ERROR default methods are experimental
-    fn bar() { io::println("hi"); }
+    fn bar(&self) { io::println("hi"); }
 }
 
 fn main() {}

diff --git a/src/test/run-pass/reflect-visit-data.rs b/src/test/run-pass/reflect-visit-data.rs
index cf0a0a07397c0d8c706de254c7cc7f84077f6ef6..c7c1a6bb331957ea4f554530ef32c9814e0d9687 100644 (file)
--- a/src/test/run-pass/reflect-visit-data.rs
+++ b/src/test/run-pass/reflect-visit-data.rs
@@ -61,154 +61,154 @@ fn bump_past<T>() {
 
 impl<V: TyVisitor movable_ptr> ptr_visit_adaptor<V>: TyVisitor {
 
-    fn visit_bot() -> bool {
+    fn visit_bot(&self) -> bool {
         self.align_to::<()>();
         if ! self.inner.visit_bot() { return false; }
         self.bump_past::<()>();
         true
     }
 
-    fn visit_nil() -> bool {
+    fn visit_nil(&self) -> bool {
         self.align_to::<()>();
         if ! self.inner.visit_nil() { return false; }
         self.bump_past::<()>();
         true
     }
 
-    fn visit_bool() -> bool {
+    fn visit_bool(&self) -> bool {
         self.align_to::<bool>();
         if ! self.inner.visit_bool() { return false; }
         self.bump_past::<bool>();
         true
     }
 
-    fn visit_int() -> bool {
+    fn visit_int(&self) -> bool {
         self.align_to::<int>();
         if ! self.inner.visit_int() { return false; }
         self.bump_past::<int>();
         true
     }
 
-    fn visit_i8() -> bool {
+    fn visit_i8(&self) -> bool {
         self.align_to::<i8>();
         if ! self.inner.visit_i8() { return false; }
         self.bump_past::<i8>();
         true
     }
 
-    fn visit_i16() -> bool {
+    fn visit_i16(&self) -> bool {
         self.align_to::<i16>();
         if ! self.inner.visit_i16() { return false; }
         self.bump_past::<i16>();
         true
     }
 
-    fn visit_i32() -> bool {
+    fn visit_i32(&self) -> bool {
         self.align_to::<i32>();
         if ! self.inner.visit_i32() { return false; }
         self.bump_past::<i32>();
         true
     }
 
-    fn visit_i64() -> bool {
+    fn visit_i64(&self) -> bool {
         self.align_to::<i64>();
         if ! self.inner.visit_i64() { return false; }
         self.bump_past::<i64>();
         true
     }
 
-    fn visit_uint() -> bool {
+    fn visit_uint(&self) -> bool {
         self.align_to::<uint>();
         if ! self.inner.visit_uint() { return false; }
         self.bump_past::<uint>();
         true
     }
 
-    fn visit_u8() -> bool {
+    fn visit_u8(&self) -> bool {
         self.align_to::<u8>();
         if ! self.inner.visit_u8() { return false; }
         self.bump_past::<u8>();
         true
     }
 
-    fn visit_u16() -> bool {
+    fn visit_u16(&self) -> bool {
         self.align_to::<u16>();
         if ! self.inner.visit_u16() { return false; }
         self.bump_past::<u16>();
         true
     }
 
-    fn visit_u32() -> bool {
+    fn visit_u32(&self) -> bool {
         self.align_to::<u32>();
         if ! self.inner.visit_u32() { return false; }
         self.bump_past::<u32>();
         true
     }
 
-    fn visit_u64() -> bool {
+    fn visit_u64(&self) -> bool {
         self.align_to::<u64>();
         if ! self.inner.visit_u64() { return false; }
         self.bump_past::<u64>();
         true
     }
 
-    fn visit_float() -> bool {
+    fn visit_float(&self) -> bool {
         self.align_to::<float>();
         if ! self.inner.visit_float() { return false; }
         self.bump_past::<float>();
         true
     }
 
-    fn visit_f32() -> bool {
+    fn visit_f32(&self) -> bool {
         self.align_to::<f32>();
         if ! self.inner.visit_f32() { return false; }
         self.bump_past::<f32>();
         true
     }
 
-    fn visit_f64() -> bool {
+    fn visit_f64(&self) -> bool {
         self.align_to::<f64>();
         if ! self.inner.visit_f64() { return false; }
         self.bump_past::<f64>();
         true
     }
 
-    fn visit_char() -> bool {
+    fn visit_char(&self) -> bool {
         self.align_to::<char>();
         if ! self.inner.visit_char() { return false; }
         self.bump_past::<char>();
         true
     }
 
-    fn visit_str() -> bool {
+    fn visit_str(&self) -> bool {
         self.align_to::<~str>();
         if ! self.inner.visit_str() { return false; }
         self.bump_past::<~str>();
         true
     }
 
-    fn visit_estr_box() -> bool {
+    fn visit_estr_box(&self) -> bool {
         self.align_to::<@str>();
         if ! self.inner.visit_estr_box() { return false; }
         self.bump_past::<@str>();
         true
     }
 
-    fn visit_estr_uniq() -> bool {
+    fn visit_estr_uniq(&self) -> bool {
         self.align_to::<~str>();
         if ! self.inner.visit_estr_uniq() { return false; }
         self.bump_past::<~str>();
         true
     }
 
-    fn visit_estr_slice() -> bool {
+    fn visit_estr_slice(&self) -> bool {
         self.align_to::<&static/str>();
         if ! self.inner.visit_estr_slice() { return false; }
         self.bump_past::<&static/str>();
         true
     }
 
-    fn visit_estr_fixed(n: uint,
+    fn visit_estr_fixed(&self, n: uint,
                         sz: uint,
                         align: uint) -> bool {
         self.align(align);
@@ -217,35 +217,35 @@ fn visit_estr_fixed(n: uint,
         true
     }
 
-    fn visit_box(mtbl: uint, inner: *TyDesc) -> bool {
+    fn visit_box(&self, mtbl: uint, inner: *TyDesc) -> bool {
         self.align_to::<@u8>();
         if ! self.inner.visit_box(mtbl, inner) { return false; }
         self.bump_past::<@u8>();
         true
     }
 
-    fn visit_uniq(mtbl: uint, inner: *TyDesc) -> bool {
+    fn visit_uniq(&self, mtbl: uint, inner: *TyDesc) -> bool {
         self.align_to::<~u8>();
         if ! self.inner.visit_uniq(mtbl, inner) { return false; }
         self.bump_past::<~u8>();
         true
     }
 
-    fn visit_ptr(mtbl: uint, inner: *TyDesc) -> bool {
+    fn visit_ptr(&self, mtbl: uint, inner: *TyDesc) -> bool {
         self.align_to::<*u8>();
         if ! self.inner.visit_ptr(mtbl, inner) { return false; }
         self.bump_past::<*u8>();
         true
     }
 
-    fn visit_rptr(mtbl: uint, inner: *TyDesc) -> bool {
+    fn visit_rptr(&self, mtbl: uint, inner: *TyDesc) -> bool {
         self.align_to::<&static/u8>();
         if ! self.inner.visit_rptr(mtbl, inner) { return false; }
         self.bump_past::<&static/u8>();
         true
     }
 
-    fn visit_unboxed_vec(mtbl: uint, inner: *TyDesc) -> bool {
+    fn visit_unboxed_vec(&self, mtbl: uint, inner: *TyDesc) -> bool {
         self.align_to::<UnboxedVecRepr>();
         // FIXME (#3732): Inner really has to move its own pointers on this one.
         // or else possibly we could have some weird interface wherein we
@@ -255,35 +255,35 @@ fn visit_unboxed_vec(mtbl: uint, inner: *TyDesc) -> bool {
         true
     }
 
-    fn visit_vec(mtbl: uint, inner: *TyDesc) -> bool {
+    fn visit_vec(&self, mtbl: uint, inner: *TyDesc) -> bool {
         self.align_to::<~[u8]>();
         if ! self.inner.visit_vec(mtbl, inner) { return false; }
         self.bump_past::<~[u8]>();
         true
     }
 
-    fn visit_evec_box(mtbl: uint, inner: *TyDesc) -> bool {
+    fn visit_evec_box(&self, mtbl: uint, inner: *TyDesc) -> bool {
         self.align_to::<@[u8]>();
         if ! self.inner.visit_evec_box(mtbl, inner) { return false; }
         self.bump_past::<@[u8]>();
         true
     }
 
-    fn visit_evec_uniq(mtbl: uint, inner: *TyDesc) -> bool {
+    fn visit_evec_uniq(&self, mtbl: uint, inner: *TyDesc) -> bool {
         self.align_to::<~[u8]>();
         if ! self.inner.visit_evec_uniq(mtbl, inner) { return false; }
         self.bump_past::<~[u8]>();
         true
     }
 
-    fn visit_evec_slice(mtbl: uint, inner: *TyDesc) -> bool {
+    fn visit_evec_slice(&self, mtbl: uint, inner: *TyDesc) -> bool {
         self.align_to::<&static/[u8]>();
         if ! self.inner.visit_evec_slice(mtbl, inner) { return false; }
         self.bump_past::<&static/[u8]>();
         true
     }
 
-    fn visit_evec_fixed(n: uint, sz: uint, align: uint,
+    fn visit_evec_fixed(&self, n: uint, sz: uint, align: uint,
                         mtbl: uint, inner: *TyDesc) -> bool {
         self.align(align);
         if ! self.inner.visit_evec_fixed(n, sz, align, mtbl, inner) {
@@ -293,24 +293,25 @@ fn visit_evec_fixed(n: uint, sz: uint, align: uint,
         true
     }
 
-    fn visit_enter_rec(n_fields: uint, sz: uint, align: uint) -> bool {
+    fn visit_enter_rec(&self, n_fields: uint, sz: uint, align: uint) -> bool {
         self.align(align);
         if ! self.inner.visit_enter_rec(n_fields, sz, align) { return false; }
         true
     }
 
-    fn visit_rec_field(i: uint, name: &str,
+    fn visit_rec_field(&self, i: uint, name: &str,
                        mtbl: uint, inner: *TyDesc) -> bool {
         if ! self.inner.visit_rec_field(i, name, mtbl, inner) { return false; }
         true
     }
 
-    fn visit_leave_rec(n_fields: uint, sz: uint, align: uint) -> bool {
+    fn visit_leave_rec(&self, n_fields: uint, sz: uint, align: uint) -> bool {
         if ! self.inner.visit_leave_rec(n_fields, sz, align) { return false; }
         true
     }
 
-    fn visit_enter_class(n_fields: uint, sz: uint, align: uint) -> bool {
+    fn visit_enter_class(&self, n_fields: uint, sz: uint, align: uint)
+                      -> bool {
         self.align(align);
         if ! self.inner.visit_enter_class(n_fields, sz, align) {
             return false;
@@ -318,7 +319,7 @@ fn visit_enter_class(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 {
         if ! self.inner.visit_class_field(i, name, mtbl, inner) {
             return false;
@@ -326,30 +327,31 @@ fn visit_class_field(i: uint, name: &str,
         true
     }
 
-    fn visit_leave_class(n_fields: uint, sz: uint, align: uint) -> bool {
+    fn visit_leave_class(&self, n_fields: uint, sz: uint, align: uint)
+                      -> bool {
         if ! self.inner.visit_leave_class(n_fields, sz, align) {
             return false;
         }
         true
     }
 
-    fn visit_enter_tup(n_fields: uint, sz: uint, align: uint) -> bool {
+    fn visit_enter_tup(&self, n_fields: uint, sz: uint, align: uint) -> bool {
         self.align(align);
         if ! self.inner.visit_enter_tup(n_fields, sz, align) { return false; }
         true
     }
 
-    fn visit_tup_field(i: uint, inner: *TyDesc) -> bool {
+    fn visit_tup_field(&self, i: uint, inner: *TyDesc) -> bool {
         if ! self.inner.visit_tup_field(i, inner) { return false; }
         true
     }
 
-    fn visit_leave_tup(n_fields: uint, sz: uint, align: uint) -> bool {
+    fn visit_leave_tup(&self, n_fields: uint, sz: uint, align: uint) -> bool {
         if ! self.inner.visit_leave_tup(n_fields, sz, align) { return false; }
         true
     }
 
-    fn visit_enter_fn(purity: uint, proto: uint,
+    fn visit_enter_fn(&self, purity: uint, proto: uint,
                       n_inputs: uint, retstyle: uint) -> bool {
         if ! self.inner.visit_enter_fn(purity, proto, n_inputs, retstyle) {
             return false
@@ -357,17 +359,17 @@ fn visit_enter_fn(purity: uint, proto: uint,
         true
     }
 
-    fn visit_fn_input(i: uint, mode: uint, inner: *TyDesc) -> bool {
+    fn visit_fn_input(&self, i: uint, mode: uint, inner: *TyDesc) -> bool {
         if ! self.inner.visit_fn_input(i, mode, inner) { return false; }
         true
     }
 
-    fn visit_fn_output(retstyle: uint, inner: *TyDesc) -> bool {
+    fn visit_fn_output(&self, retstyle: uint, inner: *TyDesc) -> bool {
         if ! self.inner.visit_fn_output(retstyle, inner) { return false; }
         true
     }
 
-    fn visit_leave_fn(purity: uint, proto: uint,
+    fn visit_leave_fn(&self, purity: uint, proto: uint,
                       n_inputs: uint, retstyle: uint) -> bool {
         if ! self.inner.visit_leave_fn(purity, proto, n_inputs, retstyle) {
             return false;
@@ -375,13 +377,14 @@ fn visit_leave_fn(purity: uint, proto: uint,
         true
     }
 
-    fn visit_enter_enum(n_variants: uint, sz: uint, align: uint) -> bool {
+    fn visit_enter_enum(&self, n_variants: uint, sz: uint, align: uint)
+                     -> bool {
         self.align(align);
         if ! self.inner.visit_enter_enum(n_variants, sz, align) { return false; }
         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 {
@@ -392,12 +395,12 @@ fn visit_enter_enum_variant(variant: uint,
         true
     }
 
-    fn visit_enum_variant_field(i: uint, inner: *TyDesc) -> bool {
+    fn visit_enum_variant_field(&self, i: uint, inner: *TyDesc) -> bool {
         if ! self.inner.visit_enum_variant_field(i, inner) { return false; }
         true
     }
 
-    fn visit_leave_enum_variant(variant: uint,
+    fn visit_leave_enum_variant(&self, variant: uint,
                                 disr_val: int,
                                 n_fields: uint,
                                 name: &str) -> bool {
@@ -408,58 +411,59 @@ fn visit_leave_enum_variant(variant: uint,
         true
     }
 
-    fn visit_leave_enum(n_variants: uint, sz: uint, align: uint) -> bool {
+    fn visit_leave_enum(&self, n_variants: uint, sz: uint, align: uint)
+                     -> bool {
         if ! self.inner.visit_leave_enum(n_variants, sz, align) { return false; }
         true
     }
 
-    fn visit_trait() -> bool {
+    fn visit_trait(&self) -> bool {
         self.align_to::<TyVisitor>();
         if ! self.inner.visit_trait() { return false; }
         self.bump_past::<TyVisitor>();
         true
     }
 
-    fn visit_var() -> bool {
+    fn visit_var(&self) -> bool {
         if ! self.inner.visit_var() { return false; }
         true
     }
 
-    fn visit_var_integral() -> bool {
+    fn visit_var_integral(&self) -> bool {
         if ! self.inner.visit_var_integral() { return false; }
         true
     }
 
-    fn visit_param(i: uint) -> bool {
+    fn visit_param(&self, i: uint) -> bool {
         if ! self.inner.visit_param(i) { return false; }
         true
     }
 
-    fn visit_self() -> bool {
+    fn visit_self(&self) -> bool {
         self.align_to::<&static/u8>();
         if ! self.inner.visit_self() { return false; }
         self.align_to::<&static/u8>();
         true
     }
 
-    fn visit_type() -> bool {
+    fn visit_type(&self) -> bool {
         if ! self.inner.visit_type() { return false; }
         true
     }
 
-    fn visit_opaque_box() -> bool {
+    fn visit_opaque_box(&self) -> bool {
         self.align_to::<@u8>();
         if ! self.inner.visit_opaque_box() { return false; }
         self.bump_past::<@u8>();
         true
     }
 
-    fn visit_constr(inner: *TyDesc) -> bool {
+    fn visit_constr(&self, inner: *TyDesc) -> bool {
         if ! self.inner.visit_constr(inner) { return false; }
         true
     }
 
-    fn visit_closure_ptr(ck: uint) -> bool {
+    fn visit_closure_ptr(&self, ck: uint) -> bool {
         self.align_to::<fn@()>();
         if ! self.inner.visit_closure_ptr(ck) { return false; }
         self.bump_past::<fn@()>();
@@ -503,121 +507,125 @@ fn move_ptr(adjustment: fn(*c_void) -> *c_void) {
 
 impl my_visitor: TyVisitor {
 
-    fn visit_bot() -> bool { true }
-    fn visit_nil() -> bool { true }
-    fn visit_bool() -> bool {
+    fn visit_bot(&self) -> bool { true }
+    fn visit_nil(&self) -> bool { true }
+    fn visit_bool(&self) -> bool {
       do self.get::<bool>() |b| {
             self.vals += ~[bool::to_str(b)];
       };
       true
     }
-    fn visit_int() -> bool {
+    fn visit_int(&self) -> bool {
       do self.get::<int>() |i| {
             self.vals += ~[int::to_str(i, 10u)];
       };
       true
     }
-    fn visit_i8() -> bool { true }
-    fn visit_i16() -> bool { true }
-    fn visit_i32() -> bool { true }
-    fn visit_i64() -> bool { true }
+    fn visit_i8(&self) -> bool { true }
+    fn visit_i16(&self) -> 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(_n: 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, _n: 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_vec(_mtbl: uint, _inner: *TyDesc) -> bool { 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_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(&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 { true }
+    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 {
         error!("rec field!");
         self.visit_inner(inner)
     }
-    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 {
         self.visit_inner(inner)
     }
-    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 {
+    fn visit_tup_field(&self, _i: uint, inner: *TyDesc) -> bool {
         error!("tup field!");
         self.visit_inner(inner)
     }
-    fn visit_leave_tup(_n_fields: uint,
+    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,
                         _sz: uint, _align: uint) -> bool {
         // FIXME (#3732): this needs to rewind between enum variants, or something.
         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 {
+    fn visit_enum_variant_field(&self, _i: uint, inner: *TyDesc) -> bool {
         self.visit_inner(inner)
     }
-    fn visit_leave_enum_variant(_variant: uint,
+    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,
                         _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 get_tydesc_for<T>(&&_t: T) -> *TyDesc {