Include intrinsic module in all crates, emit visit glue, fn intrinsic::visit_ty. Not yet working.

Author: graydon

src/rustc/front/intrinsic.rs

@@ -3,144 +3,51 @@
 
 mod intrinsic {
 
-    // import rusti::visit_ty;
-    // import rusti::visit_val;
-    // import rusti::visit_val_pair;
-
-    export ty_visitor, val_visitor, val_pair_visitor;
-
-    fn macros() {
-        // Present for side-effect of defining intrinsic macros.
-        #macro([#error[f, ...], log(core::error, #fmt[f, ...])]);
-        #macro([#warn[f, ...], log(core::warn, #fmt[f, ...])]);
-        #macro([#info[f, ...], log(core::info, #fmt[f, ...])]);
-        #macro([#debug[f, ...], log(core::debug, #fmt[f, ...])]);
-    }
+    import rusti::visit_ty;
+    export ty_visitor, visit_ty;
 
     iface ty_visitor {
-        fn visit_bot();
-        fn visit_nil();
-        fn visit_bool();
-
-        fn visit_int();
-        fn visit_i8();
-        fn visit_i16();
-        fn visit_i32();
-        fn visit_i64();
-
-        fn visit_uint();
-        fn visit_u8();
-        fn visit_u16();
-        fn visit_u32();
-        fn visit_u64();
-
-        fn visit_float();
-        fn visit_f32();
-        fn visit_f64();
-
-        fn visit_char();
-        fn visit_str();
-
-        fn visit_vec(cells_mut: bool,
-                     visit_cell: fn(uint, self));
-
-        fn visit_box(inner_mut: bool,
-                     visit_inner: fn(self));
-
-        fn visit_uniq(inner_mut: bool,
-                      visit_inner: fn(self));
-
-        fn visit_ptr(inner_mut: bool,
-                     visit_inner: fn(self));
-
-        fn visit_rptr(inner_mut: bool,
-                      visit_inner: fn(self));
-
-        fn visit_rec(n_fields: uint,
-                     field_name: fn(uint) -> str/&,
-                     field_mut: fn(uint) -> bool,
-                     visit_field: fn(uint, self));
-        fn visit_tup(n_fields: uint,
-                     visit_field: fn(uint, self));
-        fn visit_enum(n_variants: uint,
-                      variant: uint,
-                      variant_name: fn(uint) -> str/&,
-                      visit_variant: fn(uint, self));
-    }
-
-    iface val_visitor {
-
-        // Basic types we can visit directly.
-        fn visit_bot();
-        fn visit_nil();
-        fn visit_bool(b: &bool);
-
-        fn visit_int(i: &int);
-        fn visit_i8(i: &i8);
-        fn visit_i16(i: &i16);
-        fn visit_i32(i: &i32);
-        fn visit_i64(i: &i64);
-
-        fn visit_uint(u: &uint);
-        fn visit_u8(i: &i8);
-        fn visit_u16(i: &i16);
-        fn visit_u32(i: &i32);
-        fn visit_u64(i: &i64);
-
-        fn visit_float(f: &float);
-        fn visit_f32(f: &f32);
-        fn visit_f64(f: &f64);
-
-        fn visit_char(c: &char);
-
-        // Vecs and strs we can provide a stub view of.
-        fn visit_str(repr: &vec::unsafe::vec_repr,
-                     visit_cell: fn(uint,self));
-
-        fn visit_vec(repr: &vec::unsafe::vec_repr,
-                     cells_mut: bool,
-                     visit_cell: fn(uint, self));
-
-        fn visit_box(mem: *u8,
-                     inner_mut: bool,
-                     visit_inner: fn(self));
-
-        fn visit_uniq(mem: *u8,
-                      inner_mut: bool,
-                      visit_inner: fn(self));
-
-        fn visit_ptr(mem: *u8,
-                     inner_mut: bool,
-                     visit_inner: fn(self));
-
-        fn visit_rptr(mem: *u8,
-                      inner_mut: bool,
-                      visit_inner: fn(self));
-
-        // Aggregates we can't really provide anything useful for
-        // beyond a *u8. You really have to know what you're doing.
-        fn visit_rec(mem: *u8,
-                     n_fields: uint,
-                     field_name: fn(uint) -> str/&,
-                     field_mut: fn(uint) -> bool,
-                     visit_field: fn(uint, self));
-        fn visit_tup(mem: *u8,
-                     n_fields: uint,
-                     visit_field: fn(uint, self));
-        fn visit_enum(mem: *u8,
-                      n_variants: uint,
-                      variant: uint,
-                      variant_name: fn(uint) -> str/&,
-                      visit_variant: fn(uint, self));
-    }
-
-    iface val_pair_visitor {
+        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;
+
+        // FIXME: possibly pair these as enter/leave calls
+        // not just enter with implicit number of subsequent
+        // calls.
+        fn visit_vec_of(mutbl: uint) -> bool;
+        fn visit_box_of(mutbl: uint) -> bool;
+        fn visit_uniq_of(mutbl: uint) -> bool;
+        fn visit_ptr_of(mutbl: uint) -> bool;
+        fn visit_rptr_of(mutbl: uint) -> bool;
+        fn visit_rec_of(n_fields: uint) -> bool;
+        fn visit_rec_field(name: str/&, mutbl: uint) -> bool;
+        fn visit_tup_of(n_fields: uint) -> bool;
+        fn visit_tup_field(mutbl: uint) -> bool;
+        fn visit_enum_of(n_variants: uint) -> bool;
+        fn visit_enum_variant(name: str/&) -> bool;
     }
 
     #[abi = "rust-intrinsic"]
     native mod rusti {
-        // fn visit_ty<T,V:ty_visitor>(tv: V);
-        // fn visit_val<T,V:val_visitor>(v: &T, vv: V);
-        // fn visit_val_pair<T,V:val_pair_visitor>(a: &T, b: &T, vpv: &V);
+        fn visit_ty<T>(&&tv: ty_visitor);
     }
 }

src/rustc/front/intrinsic_inject.rs

@@ -7,10 +7,9 @@ export inject_intrinsic;
 fn inject_intrinsic(sess: session,
                     crate: @ast::crate) -> @ast::crate {
 
-    // FIXME: upgrade this to #include_str("intrinsic.rs");
-    let intrinsic_module = @"mod intrinsic { }";
+    let intrinsic_module = @#include_str("intrinsic.rs");
 
-    let item = parse::parse_item_from_source_str("intrinsic",
+    let item = parse::parse_item_from_source_str("<intrinsic>",
                                                  intrinsic_module,
                                                  sess.opts.cfg,
                                                  [], ast::public,

src/rustc/middle/trans/base.rs

@@ -641,13 +641,10 @@ 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;
-    alt bcx.ccx().intrinsic_ifaces.find("visit_ty") {
-      some(iid) {
-        bcx = reflect::emit_calls_to_iface_visit_ty(bcx, t, v, iid);
-      }
-      none {
-      }
-    }
+    assert bcx.ccx().tcx.intrinsic_ifaces.contains_key("ty_visitor");
+    let (iid, ty) = bcx.ccx().tcx.intrinsic_ifaces.get("ty_visitor");
+    let v = PointerCast(bcx, v, T_ptr(type_of::type_of(bcx.ccx(), ty)));
+    bcx = reflect::emit_calls_to_iface_visit_ty(bcx, t, Load(bcx, v), iid);
     build_return(bcx);
 }
 
@@ -1073,6 +1070,7 @@ fn lazily_emit_all_tydesc_glue(ccx: @crate_ctxt,
     lazily_emit_tydesc_glue(ccx, abi::tydesc_field_take_glue, static_ti);
     lazily_emit_tydesc_glue(ccx, abi::tydesc_field_drop_glue, static_ti);
     lazily_emit_tydesc_glue(ccx, abi::tydesc_field_free_glue, static_ti);
+    lazily_emit_tydesc_glue(ccx, abi::tydesc_field_visit_glue, static_ti);
 }
 
 fn lazily_emit_tydesc_glue(ccx: @crate_ctxt, field: uint,
@@ -5302,7 +5300,6 @@ fn trans_crate(sess: session::session, crate: @ast::crate, tcx: ty::ctxt,
           tn: tn,
           externs: str_hash::<ValueRef>(),
           intrinsics: intrinsics,
-          intrinsic_ifaces: reflect::find_intrinsic_ifaces(crate),
           item_vals: int_hash::<ValueRef>(),
           exp_map: emap,
           reachable: reachable,

src/rustc/middle/trans/common.rs

@@ -72,7 +72,6 @@ type crate_ctxt = {
      tn: type_names,
      externs: hashmap<str, ValueRef>,
      intrinsics: hashmap<str, ValueRef>,
-     intrinsic_ifaces: hashmap<str, ast::def_id>,
      item_vals: hashmap<ast::node_id, ValueRef>,
      exp_map: resolve::exp_map,
      reachable: reachable::map,

src/rustc/middle/trans/native.rs

@@ -836,53 +836,8 @@ fn trans_intrinsic(ccx: @crate_ctxt, decl: ValueRef, item: @ast::native_item,
       }
       "visit_ty" {
         let tp_ty = substs.tys[0];
-        let vp_ty = substs.tys[1];
         let visitor = get_param(decl, first_real_arg);
-
-        alt impl::find_vtable_in_fn_ctxt(substs,
-                                         1u, /* n_param */
-                                         0u  /* n_bound */ ) {
-
-          typeck::vtable_iface(iid, _) {
-            bcx = reflect::emit_calls_to_iface_visit_ty(bcx, tp_ty,
-                                                        visitor, iid);
-          }
-
-          // This case is a slightly weird and possibly redundant path in
-          // which we monomorphize the reflection interface.  FIXME:
-          // possibly remove this, it might be overkill.
-          typeck::vtable_static(impl_did, impl_substs, sub_origins) {
-            reflect::visit_ty_steps(bcx, tp_ty) {|mth_name, args|
-                let mth_id = impl::method_with_name(ccx, impl_did, mth_name);
-                let mth_ty = ty::lookup_item_type(ccx.tcx, mth_id).ty;
-                // FIXME: is this safe? There is no callee AST node,
-                // we're synthesizing it.
-                let callee_id = (-1) as ast::node_id;
-                let get_lval = {|bcx|
-                    let lval = lval_static_fn_inner(bcx, mth_id, callee_id,
-                                                    impl_substs,
-                                                    some(sub_origins));
-                    {env: self_env(visitor, vp_ty, none) with lval}
-                };
-                bcx = trans_call_inner(
-                    bcx, none, mth_ty, ty::mk_bool(ccx.tcx),
-                    get_lval, arg_vals(args), ignore);
-            }
-          }
-
-          _ {
-            ccx.sess.span_bug(item.span,
-                              "non-static callee in 'visit_ty' intrinsinc");
-          }
-        }
-      }
-
-      "visit_val" {
-        bcx.sess().unimpl("trans::native::visit_val");
-      }
-
-      "visit_val_pair" {
-        bcx.sess().unimpl("trans::native::visit_val_pair");
+        call_tydesc_glue(bcx, visitor, tp_ty, abi::tydesc_field_visit_glue);
       }
     }
     build_return(bcx);