---

yaml
---
r: 11863
b: refs/heads/master
c: 83c9f58
h: refs/heads/master
i:
  11861: bd85f79
  11859: 5dc24dd
  11855: a450f60
v: v3

Author: marijnh

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 4511f936b1b4766962d01a80f6887eecb30e89f9
+refs/heads/master: 83c9f585342d6974c5f1847f18ab2b6322b1ea42
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
 refs/heads/try: 2898dcc5d97da9427ac367542382b6239d9c0bbf

trunk/src/rustc/back/upcall.rs

@@ -2,7 +2,7 @@
 import driver::session;
 import middle::trans::base;
 import middle::trans::common::{T_fn, T_i1, T_i8, T_i32,
-                               T_int, T_nil, T_dict,
+                               T_int, T_nil,
                                T_opaque_vec, T_ptr,
                                T_size_t, T_void};
 import lib::llvm::{type_names, ModuleRef, ValueRef, TypeRef};
@@ -19,7 +19,6 @@ type upcalls =
      create_shared_type_desc: ValueRef,
      free_shared_type_desc: ValueRef,
      get_type_desc: ValueRef,
-     intern_dict: ValueRef,
      vec_grow: ValueRef,
      vec_push: ValueRef,
      cmp_type: ValueRef,
@@ -81,8 +80,6 @@ fn declare_upcalls(targ_cfg: @session::config,
                  size_t, size_t,
                  T_ptr(T_ptr(tydesc_type)), int_t],
                 T_ptr(tydesc_type)),
-          intern_dict:
-              d("intern_dict", [size_t, T_ptr(T_dict())], T_ptr(T_dict())),
           vec_grow:
               dv("vec_grow", [T_ptr(T_ptr(opaque_vec_t)), int_t]),
           vec_push:

trunk/src/rustc/driver/driver.rs

@@ -144,7 +144,7 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg,
         time(time_passes, "region resolution",
              bind middle::region::resolve_crate(sess, def_map, crate));
     let ty_cx = ty::mk_ctxt(sess, def_map, ast_map, freevars, region_map);
-    let (method_map, dict_map) =
+    let (method_map, vtable_map) =
         time(time_passes, "typechecking",
              bind typeck::check_crate(ty_cx, impl_map, crate));
     time(time_passes, "const checking",
@@ -181,7 +181,7 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg,
 
     let maps = {mutbl_map: mutbl_map, copy_map: copy_map,
                 last_uses: last_uses, impl_map: impl_map,
-                method_map: method_map, dict_map: dict_map};
+                method_map: method_map, vtable_map: vtable_map};
 
     let (llmod, link_meta) =
         time(time_passes, "translation",

trunk/src/rustc/metadata/astencode.rs

@@ -17,8 +17,8 @@ import std::smallintmap::map;
 import middle::trans::common::maps;
 import middle::{ty, typeck, last_use, ast_map};
 import middle::typeck::method_origin;
-import middle::typeck::dict_res;
-import middle::typeck::dict_origin;
+import middle::typeck::vtable_res;
+import middle::typeck::vtable_origin;
 import driver::session::session;
 import middle::freevars::freevar_entry;
 import c = common;
@@ -506,40 +506,40 @@ impl of tr for last_use::is_last_use {
 }
 
 // ______________________________________________________________________
-// Encoding and decoding dict_res
+// Encoding and decoding vtable_res
 
-fn encode_dict_res(ecx: @e::encode_ctxt,
+fn encode_vtable_res(ecx: @e::encode_ctxt,
                    ebml_w: ebml::writer,
-                   dr: typeck::dict_res) {
+                   dr: typeck::vtable_res) {
     // can't autogenerate this code because automatic serialization of
     // ty::t doesn't work, and there is no way (atm) to have
     // hand-written serialization routines combine with auto-generated
     // ones.  perhaps we should fix this.
-    ebml_w.emit_from_vec(*dr) {|dict_origin|
-        encode_dict_origin(ecx, ebml_w, dict_origin)
+    ebml_w.emit_from_vec(*dr) {|vtable_origin|
+        encode_vtable_origin(ecx, ebml_w, vtable_origin)
     }
 }
 
-fn encode_dict_origin(ecx: @e::encode_ctxt,
+fn encode_vtable_origin(ecx: @e::encode_ctxt,
                       ebml_w: ebml::writer,
-                      dict_origin: typeck::dict_origin) {
-    ebml_w.emit_enum("dict_origin") {||
-        alt dict_origin {
-          typeck::dict_static(def_id, tys, dict_res) {
-            ebml_w.emit_enum_variant("dict_static", 0u, 3u) {||
+                      vtable_origin: typeck::vtable_origin) {
+    ebml_w.emit_enum("vtable_origin") {||
+        alt vtable_origin {
+          typeck::vtable_static(def_id, tys, vtable_res) {
+            ebml_w.emit_enum_variant("vtable_static", 0u, 3u) {||
                 ebml_w.emit_enum_variant_arg(0u) {||
                     ebml_w.emit_def_id(def_id)
                 }
                 ebml_w.emit_enum_variant_arg(1u) {||
                     ebml_w.emit_tys(ecx, tys);
                 }
                 ebml_w.emit_enum_variant_arg(2u) {||
-                    encode_dict_res(ecx, ebml_w, dict_res);
+                    encode_vtable_res(ecx, ebml_w, vtable_res);
                 }
             }
           }
-          typeck::dict_param(pn, bn) {
-            ebml_w.emit_enum_variant("dict_param", 1u, 2u) {||
+          typeck::vtable_param(pn, bn) {
+            ebml_w.emit_enum_variant("vtable_param", 1u, 2u) {||
                 ebml_w.emit_enum_variant_arg(0u) {||
                     ebml_w.emit_uint(pn);
                 }
@@ -548,8 +548,8 @@ fn encode_dict_origin(ecx: @e::encode_ctxt,
                 }
             }
           }
-          typeck::dict_iface(def_id, tys) {
-            ebml_w.emit_enum_variant("dict_iface", 1u, 3u) {||
+          typeck::vtable_iface(def_id, tys) {
+            ebml_w.emit_enum_variant("vtable_iface", 1u, 3u) {||
                 ebml_w.emit_enum_variant_arg(0u) {||
                     ebml_w.emit_def_id(def_id)
                 }
@@ -564,29 +564,30 @@ fn encode_dict_origin(ecx: @e::encode_ctxt,
 }
 
 impl helpers for ebml::ebml_deserializer {
-    fn read_dict_res(xcx: extended_decode_ctxt) -> typeck::dict_res {
-        @self.read_to_vec {|| self.read_dict_origin(xcx) }
+    fn read_vtable_res(xcx: extended_decode_ctxt) -> typeck::vtable_res {
+        @self.read_to_vec {|| self.read_vtable_origin(xcx) }
     }
 
-    fn read_dict_origin(xcx: extended_decode_ctxt) -> typeck::dict_origin {
-        self.read_enum("dict_origin") {||
+    fn read_vtable_origin(xcx: extended_decode_ctxt)
+        -> typeck::vtable_origin {
+        self.read_enum("vtable_origin") {||
             self.read_enum_variant {|i|
                 alt check i {
                   0u {
-                    typeck::dict_static(
+                    typeck::vtable_static(
                         self.read_enum_variant_arg(0u) {||
                             self.read_def_id(xcx)
                         },
                         self.read_enum_variant_arg(1u) {||
                             self.read_tys(xcx)
                         },
                         self.read_enum_variant_arg(2u) {||
-                            self.read_dict_res(xcx)
+                            self.read_vtable_res(xcx)
                         }
                     )
                   }
                   1u {
-                    typeck::dict_param(
+                    typeck::vtable_param(
                         self.read_enum_variant_arg(0u) {||
                             self.read_uint()
                         },
@@ -596,7 +597,7 @@ impl helpers for ebml::ebml_deserializer {
                     )
                   }
                   2u {
-                    typeck::dict_iface(
+                    typeck::vtable_iface(
                         self.read_enum_variant_arg(0u) {||
                             self.read_def_id(xcx)
                         },
@@ -786,11 +787,11 @@ fn encode_side_tables_for_id(ecx: @e::encode_ctxt,
         }
     }
 
-    option::may(ccx.maps.dict_map.find(id)) {|dr|
-        ebml_w.tag(c::tag_table_dict_map) {||
+    option::may(ccx.maps.vtable_map.find(id)) {|dr|
+        ebml_w.tag(c::tag_table_vtable_map) {||
             ebml_w.id(id);
             ebml_w.tag(c::tag_table_val) {||
-                encode_dict_res(ecx, ebml_w, dr);
+                encode_vtable_res(ecx, ebml_w, dr);
             }
         }
     }
@@ -883,9 +884,9 @@ fn decode_side_tables(xcx: extended_decode_ctxt,
             } else if tag == (c::tag_table_method_map as uint) {
                 dcx.maps.method_map.insert(id,
                                            val_dsr.read_method_origin(xcx));
-            } else if tag == (c::tag_table_dict_map as uint) {
-                dcx.maps.dict_map.insert(id,
-                                         val_dsr.read_dict_res(xcx));
+            } else if tag == (c::tag_table_vtable_map as uint) {
+                dcx.maps.vtable_map.insert(id,
+                                         val_dsr.read_vtable_res(xcx));
             } else {
                 xcx.dcx.tcx.sess.bug(
                     #fmt["unknown tag found in side tables: %x", tag]);

trunk/src/rustc/metadata/common.rs

@@ -98,7 +98,7 @@ enum astencode_tag { // Reserves 0x50 -- 0x6f
     tag_table_copy,
     tag_table_last_use,
     tag_table_method_map,
-    tag_table_dict_map
+    tag_table_vtable_map
 }
 
 // djb's cdb hashes.

trunk/src/rustc/middle/trans/base.rs

@@ -757,7 +757,7 @@ fn make_generic_glue_inner(ccx: @crate_ctxt, t: ty::t,
     }
 
     fcx.lltyparams = vec::map(vec::from_mut(lltydescs), {|d|
-        {desc: d, dicts: none}
+        {desc: d, vtables: none}
     });
 
     let bcx = top_scope_block(fcx, none);
@@ -2051,7 +2051,7 @@ type generic_info = {item_type: ty::t,
                      static_tis: [option<@tydesc_info>],
                      tydescs: [ValueRef],
                      param_bounds: @[ty::param_bounds],
-                     origins: option<typeck::dict_res>};
+                     origins: option<typeck::vtable_res>};
 
 enum generic_callee {
     generic_full(generic_info),
@@ -2107,17 +2107,17 @@ fn trans_external_path(cx: block, did: ast::def_id,
 }
 
 fn monomorphic_fn(ccx: @crate_ctxt, fn_id: ast::def_id, substs: [ty::t],
-                  dicts: option<typeck::dict_res>)
+                  vtables: option<typeck::vtable_res>)
     -> option<{llfn: ValueRef, fty: ty::t}> {
     let substs = vec::map(substs, {|t|
         alt ty::get(t).struct {
           ty::ty_box(mt) { ty::mk_opaque_box(ccx.tcx) }
           _ { t }
         }
     });
-    let hash_id = @{def: fn_id, substs: substs, dicts: alt dicts {
-      some(os) { some_dicts(vec::map(*os, impl::vtable_id)) }
-      none { no_dicts }
+    let hash_id = @{def: fn_id, substs: substs, vtables: alt vtables {
+      some(os) { some_vts(vec::map(*os, impl::vtable_id)) }
+      none { no_vts }
     }};
     alt ccx.monomorphized.find(hash_id) {
       some(val) { ret some(val); }
@@ -2148,7 +2148,7 @@ fn monomorphic_fn(ccx: @crate_ctxt, fn_id: ast::def_id, substs: [ty::t],
     let lldecl = decl_cdecl_fn(ccx.llmod, s, llfty);
     ccx.monomorphized.insert(hash_id, {llfn: lldecl, fty: mono_ty});
 
-    let psubsts = some({tys: substs, dicts: dicts, bounds: tpt.bounds});
+    let psubsts = some({tys: substs, vtables: vtables, bounds: tpt.bounds});
     alt check map_node {
       ast_map::node_item(i@@{node: ast::item_fn(decl, _, body), _}, _) {
         set_inline_hint_if_appr(i.attrs, lldecl);
@@ -2229,7 +2229,7 @@ fn maybe_instantiate_inline(ccx: @crate_ctxt, fn_id: ast::def_id)
 }
 
 fn lval_static_fn(bcx: block, fn_id: ast::def_id, id: ast::node_id,
-                  substs: option<([ty::t], typeck::dict_res)>)
+                  substs: option<([ty::t], typeck::vtable_res)>)
     -> lval_maybe_callee {
     let ccx = bcx.ccx();
     let tcx = ccx.tcx;
@@ -2249,16 +2249,17 @@ fn lval_static_fn(bcx: block, fn_id: ast::def_id, id: ast::node_id,
        fn_id.crate == ast::local_crate &&
        !vec::any(tys, {|t| ty::type_has_params(t)}) {
         let mono = alt substs {
-          some((stys, dicts)) {
+          some((stys, vtables)) {
             if (stys.len() + tys.len()) > 0u {
-                monomorphic_fn(ccx, fn_id, stys + tys, some(dicts))
+                monomorphic_fn(ccx, fn_id, stys + tys, some(vtables))
             } else { none }
           }
           none {
-            alt ccx.maps.dict_map.find(id) {
-              some(dicts) {
-                let rdicts = impl::resolve_vtables_in_fn_ctxt(bcx.fcx, dicts);
-                monomorphic_fn(ccx, fn_id, tys, some(rdicts))
+            alt ccx.maps.vtable_map.find(id) {
+              some(vtables) {
+                let rvtables = impl::resolve_vtables_in_fn_ctxt(
+                    bcx.fcx, vtables);
+                monomorphic_fn(ccx, fn_id, tys, some(rvtables))
               }
               none { monomorphic_fn(ccx, fn_id, tys, none) }
             }
@@ -2308,7 +2309,7 @@ fn lval_static_fn(bcx: block, fn_id: ast::def_id, id: ast::node_id,
                             static_tis: tis,
                             tydescs: tydescs,
                             param_bounds: tpt.bounds,
-                            origins: ccx.maps.dict_map.find(id)});
+                            origins: ccx.maps.vtable_map.find(id)});
     }
     ret {bcx: bcx, val: val, kind: owned, env: null_env, generic: gen};
 }
@@ -2925,9 +2926,11 @@ fn invoke_(bcx: block, llfn: ValueRef, llargs: [ValueRef],
     // cleanups to run
     if bcx.unreachable { ret bcx; }
     let normal_bcx = sub_block(bcx, "normal return");
-    /*std::io::println("fn: " + lib::llvm::type_to_str(bcx.ccx().tn, val_ty(llfn)));
+    /*std::io::println("fn: " + lib::llvm::type_to_str(bcx.ccx().tn,
+                     val_ty(llfn)));
     for a in llargs {
-        std::io::println(" a: " + lib::llvm::type_to_str(bcx.ccx().tn, val_ty(a)));
+        std::io::println(" a: " + lib::llvm::type_to_str(bcx.ccx().tn,
+                         val_ty(a)));
     }*/
     invoker(bcx, llfn, llargs, normal_bcx.llbb, get_landing_pad(bcx));
     ret normal_bcx;
@@ -4001,22 +4004,22 @@ fn create_llargs_for_fn_args(cx: fn_ctxt,
     }
     for bounds in tps_bounds {
         let lltydesc = llvm::LLVMGetParam(cx.llfn, arg_n as c_uint);
-        let dicts = none;
+        let vtables = none;
         arg_n += 1u;
         for bound in *bounds {
             alt bound {
               ty::bound_iface(_) {
-                let dict = llvm::LLVMGetParam(cx.llfn, arg_n as c_uint);
+                let vtable = llvm::LLVMGetParam(cx.llfn, arg_n as c_uint);
                 arg_n += 1u;
-                dicts = some(alt dicts {
-                    none { [dict] }
-                    some(ds) { ds + [dict] }
+                vtables = some(alt vtables {
+                    none { [vtable] }
+                    some(ds) { ds + [vtable] }
                 });
               }
               _ {}
             }
         }
-        cx.lltyparams += [{desc: lltydesc, dicts: dicts}];
+        cx.lltyparams += [{desc: lltydesc, vtables: vtables}];
     }
 
     // Populate the llargs field of the function context with the ValueRefs