Modify reflect interface to pass tydescs back to client, stop on false return.

These changes are required to prune type-recursion and admit early
returns in the visitor code. Changes to visitors in subsequent csets.

Author: graydon

src/rustc/front/intrinsic.rs

@@ -3,8 +3,21 @@
 
 mod intrinsic {
 
-    import rusti::visit_ty;
-    export ty_visitor, visit_ty;
+    import rusti::visit_tydesc;
+    export ty_visitor, get_tydesc, visit_tydesc, tydesc;
+
+    // FIXME (#2712): remove this when the interface has settled and the
+    // version in sys is no longer present.
+    fn get_tydesc<T>() -> *tydesc {
+        rusti::get_tydesc::<T>() as *tydesc
+    }
+
+    enum tydesc = {
+        first_param: **u8,
+        size: uint,
+        align: uint
+        // Remaining fields not listed
+    };
 
     iface ty_visitor {
         fn visit_bot() -> bool;
@@ -35,50 +48,37 @@ mod intrinsic {
         fn visit_estr_slice() -> bool;
         fn visit_estr_fixed(sz: uint) -> bool;
 
-        fn visit_enter_box(mtbl: uint) -> bool;
-        fn visit_leave_box(mtbl: uint) -> bool;
-        fn visit_enter_uniq(mtbl: uint) -> bool;
-        fn visit_leave_uniq(mtbl: uint) -> bool;
-        fn visit_enter_ptr(mtbl: uint) -> bool;
-        fn visit_leave_ptr(mtbl: uint) -> bool;
-        fn visit_enter_rptr(mtbl: uint) -> bool;
-        fn visit_leave_rptr(mtbl: uint) -> bool;
-
-        fn visit_enter_vec(mtbl: uint) -> bool;
-        fn visit_leave_vec(mtbl: uint) -> bool;
-        fn visit_enter_evec_box(mtbl: uint) -> bool;
-        fn visit_leave_evec_box(mtbl: uint) -> bool;
-        fn visit_enter_evec_uniq(mtbl: uint) -> bool;
-        fn visit_leave_evec_uniq(mtbl: uint) -> bool;
-        fn visit_enter_evec_slice(mtbl: uint) -> bool;
-        fn visit_leave_evec_slice(mtbl: uint) -> bool;
-        fn visit_enter_evec_fixed(mtbl: uint, n: uint,
-                                  sz: uint, align: uint) -> bool;
-        fn visit_leave_evec_fixed(mtbl: uint, 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, mtbl: uint,
+                            sz: uint, align: uint,
+                            inner: *tydesc) -> bool;
 
         fn visit_enter_rec(n_fields: uint,
                            sz: uint, align: uint) -> bool;
-        fn visit_enter_rec_field(mtbl: uint, i: uint,
-                                 name: str/&) -> bool;
-        fn visit_leave_rec_field(mtbl: uint, i: uint,
-                                 name: str/&) -> bool;
+        fn visit_rec_field(i: uint, name: str/&,
+                           mtbl: uint, inner: *tydesc) -> bool;
         fn visit_leave_rec(n_fields: uint,
                            sz: uint, align: uint) -> bool;
 
         fn visit_enter_class(n_fields: uint,
                              sz: uint, align: uint) -> bool;
-        fn visit_enter_class_field(mtbl: uint, i: uint,
-                                   name: str/&) -> bool;
-        fn visit_leave_class_field(mtbl: uint, i: uint,
-                                   name: str/&) -> bool;
+        fn visit_class_field(i: uint, name: str/&,
+                             mtbl: uint, inner: *tydesc) -> bool;
         fn visit_leave_class(n_fields: uint,
                              sz: uint, align: uint) -> bool;
 
         fn visit_enter_tup(n_fields: uint,
                            sz: uint, align: uint) -> bool;
-        fn visit_enter_tup_field(i: uint) -> bool;
-        fn visit_leave_tup_field(i: uint) -> bool;
+        fn visit_tup_field(i: uint, inner: *tydesc) -> bool;
         fn visit_leave_tup(n_fields: uint,
                            sz: uint, align: uint) -> bool;
 
@@ -88,8 +88,7 @@ mod intrinsic {
                                     disr_val: int,
                                     n_fields: uint,
                                     name: str/&) -> bool;
-        fn visit_enter_enum_variant_field(i: uint) -> bool;
-        fn visit_leave_enum_variant_field(i: uint) -> bool;
+        fn visit_enum_variant_field(i: uint, inner: *tydesc) -> bool;
         fn visit_leave_enum_variant(variant: uint,
                                     disr_val: int,
                                     n_fields: uint,
@@ -99,29 +98,25 @@ mod intrinsic {
 
         fn visit_enter_fn(purity: uint, proto: uint,
                           n_inputs: uint, retstyle: uint) -> bool;
-        fn visit_enter_fn_input(i: uint, mode: uint) -> bool;
-        fn visit_leave_fn_input(i: uint, mode: uint) -> bool;
-        fn visit_enter_fn_output(retstyle: uint) -> bool;
-        fn visit_leave_fn_output(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,
                           n_inputs: uint, retstyle: uint) -> bool;
 
         fn visit_trait() -> bool;
-        fn visit_enter_res() -> bool;
-        fn visit_leave_res() -> 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_enter_constr() -> bool;
-        fn visit_leave_constr() -> bool;
+        fn visit_constr(inner: *tydesc) -> bool;
         fn visit_closure_ptr(ck: uint) -> bool;
     }
 
     #[abi = "rust-intrinsic"]
     extern mod rusti {
-        fn visit_ty<T>(&&tv: ty_visitor);
+        fn get_tydesc<T>() -> *();
+        fn visit_tydesc(td: *tydesc, &&tv: ty_visitor);
     }
 }

src/rustc/middle/trans/base.rs

@@ -671,8 +671,8 @@ fn incr_refcnt_of_boxed(cx: block, box_ptr: ValueRef) {
 fn make_visit_glue(bcx: block, v: ValueRef, t: ty::t) {
     let _icx = bcx.insn_ctxt("make_visit_glue");
     let mut bcx = bcx;
-    assert bcx.ccx().tcx.intrinsic_traits.contains_key(@"ty_visitor");
-    let (iid, ty) = bcx.ccx().tcx.intrinsic_traits.get(@"ty_visitor");
+    assert bcx.ccx().tcx.intrinsic_defs.contains_key(@"ty_visitor");
+    let (iid, ty) = bcx.ccx().tcx.intrinsic_defs.get(@"ty_visitor");
     let v = PointerCast(bcx, v, T_ptr(type_of::type_of(bcx.ccx(), ty)));
     bcx = reflect::emit_calls_to_trait_visit_ty(bcx, t, v, iid);
     build_return(bcx);

src/rustc/middle/trans/foreign.rs

@@ -910,8 +910,13 @@ fn trans_intrinsic(ccx: @crate_ctxt, decl: ValueRef, item: @ast::foreign_item,
       }
       "get_tydesc" {
         let tp_ty = substs.tys[0];
-        let td = get_tydesc_simple(ccx, tp_ty);
-        Store(bcx, PointerCast(bcx, td, T_ptr(T_nil())), fcx.llretptr);
+        let mut static_ti = none;
+        let lltydesc = get_tydesc(ccx, tp_ty, static_ti);
+        lazily_emit_all_tydesc_glue(ccx, copy static_ti);
+        // FIXME (#2712): change this to T_ptr(ccx.tydesc_ty) when the
+        // core::sys copy of the get_tydesc interface dies off.
+        let td = PointerCast(bcx, lltydesc, T_ptr(T_nil()));
+        Store(bcx, td, fcx.llretptr);
       }
       "init" {
         let tp_ty = substs.tys[0];
@@ -951,10 +956,12 @@ fn trans_intrinsic(ccx: @crate_ctxt, decl: ValueRef, item: @ast::foreign_item,
         Store(bcx, C_bool(ty::type_needs_drop(ccx.tcx, tp_ty)),
               fcx.llretptr);
       }
-      "visit_ty" {
-        let tp_ty = substs.tys[0];
-        let visitor = get_param(decl, first_real_arg);
-        call_tydesc_glue(bcx, visitor, tp_ty, abi::tydesc_field_visit_glue);
+      "visit_tydesc" {
+        let td = get_param(decl, first_real_arg);
+        let visitor = get_param(decl, first_real_arg + 1u);
+        let td = PointerCast(bcx, td, T_ptr(ccx.tydesc_type));
+        call_tydesc_glue_full(bcx, visitor, td,
+                              abi::tydesc_field_visit_glue, none);
       }
       "frame_address" {
         let frameaddress = ccx.intrinsics.get("llvm.frameaddress");