---

yaml
---
r: 7075
b: refs/heads/master
c: ae225e2
h: refs/heads/master
i:
  7073: f4effaf
  7071: ad75807
v: v3

Author: erickt

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 7b00bac540ad4034906db329712d9b46e2d05719
+refs/heads/master: ae225e2b6c8dfe7a24444bd5b11b8b21df7d5f9d

trunk/mk/clean.mk

@@ -48,7 +48,8 @@ clean-misc:
                                    test/*/*.$(ext) \
                                    test/bench/*/*.$(ext)))
 	$(Q)rm -Rf $(foreach ext, \
-                 html aux cp fn ky log pdf pg toc tp vr cps, \
+                 css html js \
+                 aux cp fn ky log pdf pg toc tp vr cps, \
                  $(wildcard doc/*.$(ext) \
                             doc/*/*.$(ext) \
                             doc/*/*/*.$(ext)))

trunk/src/comp/back/upcall.rs

@@ -2,7 +2,7 @@
 import driver::session;
 import middle::trans;
 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;
@@ -20,7 +20,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,
@@ -77,8 +76,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/comp/middle/resolve.rs

@@ -1892,7 +1892,7 @@ fn visit_mod_with_impl_scope(e: @env, m: ast::_mod, s: span, sc: iscopes,
 
 fn resolve_impl_in_expr(e: @env, x: @ast::expr, sc: iscopes, v: vt<iscopes>) {
     alt x.node {
-      ast::expr_field(_, _, _) | ast::expr_path(_) | ast::expr_cast(_, _) {
+      ast::expr_field(_, _, _) | ast::expr_path(_) {
         e.impl_map.insert(x.id, sc);
       }
       _ {}

trunk/src/comp/middle/trans.rs

@@ -5689,7 +5689,6 @@ fn trans_crate(sess: session::session, crate: @ast::crate, tcx: ty::ctxt,
           discrim_symbols: new_int_hash::<str>(),
           consts: new_int_hash::<ValueRef>(),
           tydescs: ty::new_ty_hash(),
-          dicts: map::mk_hashmap(hash_dict_id, {|a, b| a == b}),
           module_data: new_str_hash::<ValueRef>(),
           lltypes: ty::new_ty_hash(),
           names: namegen(0),

trunk/src/comp/middle/trans_closure.rs

@@ -461,24 +461,18 @@ fn trans_bind_1(cx: @block_ctxt, outgoing_fty: ty::t,
     let (outgoing_fty_real, lltydescs, param_bounds) = alt f_res.generic {
       none. { (outgoing_fty, [], @[]) }
       some(ginfo) {
-        let tds = [], orig = 0u;
-        vec::iter2(ginfo.tydescs, *ginfo.param_bounds) {|td, bounds|
-            tds += [td];
+        for bounds in *ginfo.param_bounds {
             for bound in *bounds {
                 alt bound {
                   ty::bound_iface(_) {
-                    let dict = trans_impl::get_dict(
-                        bcx, option::get(ginfo.origins)[orig]);
-                    tds += [PointerCast(bcx, dict.val, val_ty(td))];
-                    orig += 1u;
-                    bcx = dict.bcx;
+                    fail "FIXME[impl] binding bounded types not implemented";
                   }
                   _ {}
                 }
             }
         }
         lazily_emit_all_generic_info_tydesc_glues(cx, ginfo);
-        (ginfo.item_type, tds, ginfo.param_bounds)
+        (ginfo.item_type, ginfo.tydescs, ginfo.param_bounds)
       }
     };
 

trunk/src/comp/middle/trans_common.rs

@@ -93,7 +93,6 @@ type crate_ctxt =
      discrim_symbols: hashmap<ast::node_id, str>,
      consts: hashmap<ast::node_id, ValueRef>,
      tydescs: hashmap<ty::t, @tydesc_info>,
-     dicts: hashmap<dict_id, ValueRef>,
      module_data: hashmap<str, ValueRef>,
      lltypes: hashmap<ty::t, TypeRef>,
      names: namegen,
@@ -926,24 +925,6 @@ pure fn type_is_tup_like(cx: @block_ctxt, t: ty::t) -> bool {
     ty::type_is_tup_like(tcx, t)
 }
 
-// Used to identify cached dictionaries
-tag dict_param {
-    dict_param_dict(dict_id);
-    dict_param_ty(ty::t);
-}
-type dict_id = @{impl_def: ast::def_id, params: [dict_param]};
-fn hash_dict_id(&&dp: dict_id) -> uint {
-    let h = syntax::ast_util::hash_def_id(dp.impl_def);
-    for param in dp.params {
-        h = h << 2u;
-        alt param {
-          dict_param_dict(d) { h += hash_dict_id(d); }
-          dict_param_ty(t) { h += t; }
-        }
-    }
-    h
-}
-
 //
 // Local Variables:
 // mode: rust

trunk/src/comp/middle/trans_impl.rs

@@ -5,38 +5,8 @@ import option::{some, none};
 import syntax::{ast, ast_util};
 import metadata::csearch;
 import back::link;
-import lib::llvm::llvm;
-import llvm::{ValueRef, TypeRef, LLVMGetParam};
-
-// Translation functionality related to impls and ifaces
-//
-// Terminology:
-//  vtable:  a table of function pointers pointing to method wrappers
-//           of an impl that implements an iface
-//  dict:    a record containing a vtable pointer along with pointers to
-//           all tydescs and other dicts needed to run methods in this vtable
-//           (i.e. corresponding to the type parameters of the impl)
-//  wrapper: a function that takes a dict as first argument, along
-//           with the method-specific tydescs for a method (and all
-//           other args the method expects), which fetches the extra
-//           tydescs and dicts from the dict, splices them into the
-//           arglist, and calls through to the actual method
-//
-// Generic functions take, along with their normal arguments, a number
-// of extra tydesc and dict arguments -- one tydesc for each type
-// parameter, one dict (following the tydesc in the arg order) for
-// each interface bound on a type parameter.
-//
-// Most dicts are completely static, and are allocated and filled at
-// compile time. Dicts that depend on run-time values (tydescs or
-// dicts for type parameter types) are built at run-time, and interned
-// through upcall_intern_dict in the runtime. This means that dict
-// pointers are self-contained things that do not need to be cleaned
-// up.
-//
-// The trans_constants pass in trans.rs outputs the vtables. Typeck
-// annotates notes with information about the methods and dicts that
-// are referenced (ccx.method_map and ccx.dict_map).
+import lib::llvm;
+import llvm::llvm::{ValueRef, TypeRef, LLVMGetParam};
 
 fn trans_impl(cx: @local_ctxt, name: ast::ident, methods: [@ast::method],
               id: ast::node_id, tps: [ast::ty_param]) {
@@ -85,8 +55,7 @@ fn trans_dict_callee(bcx: @block_ctxt, e: @ast::expr, base: @ast::expr,
     let generic = none;
     if vec::len(*method.tps) > 0u {
         let tydescs = [], tis = [];
-        let tptys = ty::node_id_to_type_params(tcx, e.id);
-        for t in vec::tail_n(tptys, vec::len(tptys) - vec::len(*method.tps)) {
+        for t in ty::node_id_to_type_params(tcx, e.id) {
             // TODO: Doesn't always escape.
             let ti = none;
             let td = get_tydesc(bcx, t, true, tps_normal, ti).result;
@@ -106,18 +75,18 @@ fn trans_dict_callee(bcx: @block_ctxt, e: @ast::expr, base: @ast::expr,
 }
 
 fn llfn_arg_tys(ft: TypeRef) -> {inputs: [TypeRef], output: TypeRef} {
-    let out_ty = llvm::LLVMGetReturnType(ft);
-    let n_args = llvm::LLVMCountParamTypes(ft);
+    let out_ty = llvm::llvm::LLVMGetReturnType(ft);
+    let n_args = llvm::llvm::LLVMCountParamTypes(ft);
     let args = vec::init_elt(0 as TypeRef, n_args);
-    unsafe { llvm::LLVMGetParamTypes(ft, vec::to_ptr(args)); }
+    unsafe { llvm::llvm::LLVMGetParamTypes(ft, vec::to_ptr(args)); }
     {inputs: args, output: out_ty}
 }
 
 fn trans_wrapper(ccx: @crate_ctxt, pt: [ast::ident],
                  extra_tps: [ty::param_bounds], m: @ast::method) -> ValueRef {
     let real_fn = ccx.item_ids.get(m.id);
     let {inputs: real_args, output: real_ret} =
-        llfn_arg_tys(llvm::LLVMGetElementType(val_ty(real_fn)));
+        llfn_arg_tys(llvm::llvm::LLVMGetElementType(val_ty(real_fn)));
     let extra_ptrs = [];
     for tp in extra_tps {
         extra_ptrs += [T_ptr(ccx.tydesc_type)];
@@ -151,7 +120,7 @@ fn trans_wrapper(ccx: @crate_ctxt, pt: [ast::ident],
         args += [load_inbounds(bcx, dict, [0, i as int])];
     }
     // the rest of the parameters
-    let i = 3u, params_total = llvm::LLVMCountParamTypes(llfn_ty);
+    let i = 3u, params_total = llvm::llvm::LLVMCountParamTypes(llfn_ty);
     while i < params_total {
         args += [LLVMGetParam(llfn, i)];
         i += 1u;
@@ -162,88 +131,9 @@ fn trans_wrapper(ccx: @crate_ctxt, pt: [ast::ident],
     ret llfn;
 }
 
-fn dict_is_static(tcx: ty::ctxt, origin: typeck::dict_origin) -> bool {
-    alt origin {
-      typeck::dict_static(_, ts, origs) {
-        vec::all(ts, {|t| !ty::type_contains_params(tcx, t)}) &&
-        vec::all(*origs, {|o| dict_is_static(tcx, o)})
-      }
-      typeck::dict_param(_, _) { false }
-    }
-}
-
+// FIXME[impl] cache these on the function level somehow
 fn get_dict(bcx: @block_ctxt, origin: typeck::dict_origin) -> result {
-    let ccx = bcx_ccx(bcx);
-    alt origin {
-      typeck::dict_static(impl_did, tys, sub_origins) {
-        if dict_is_static(ccx.tcx, origin) {
-            ret rslt(bcx, get_static_dict(bcx, origin));
-        }
-        let {bcx, ptrs} = get_dict_ptrs(bcx, origin);
-        let pty = T_ptr(T_i8()), dict_ty = T_array(pty, vec::len(ptrs));
-        let dict = alloca(bcx, dict_ty), i = 0;
-        for ptr in ptrs {
-            Store(bcx, PointerCast(bcx, ptr, pty), GEPi(bcx, dict, [0, i]));
-            i += 1;
-        }
-        dict = Call(bcx, ccx.upcalls.intern_dict,
-                    [C_uint(ccx, vec::len(ptrs)),
-                     PointerCast(bcx, dict, T_ptr(T_dict()))]);
-        rslt(bcx, dict)
-      }
-      typeck::dict_param(n_param, n_bound) {
-        rslt(bcx, option::get(bcx.fcx.lltyparams[n_param].dicts)[n_bound])
-      }
-    }
-}
-
-fn dict_id(tcx: ty::ctxt, origin: typeck::dict_origin) -> dict_id {
-    alt origin {
-      typeck::dict_static(did, ts, origs) {
-        let d_params = [], orig = 0u;
-        if vec::len(ts) == 0u { ret @{impl_def: did, params: d_params}; }
-        let impl_params = ty::lookup_item_type(tcx, did).bounds;
-        vec::iter2(ts, *impl_params) {|t, bounds|
-            d_params += [dict_param_ty(t)];
-            for bound in *bounds {
-                alt bound {
-                  ty::bound_iface(_) {
-                    d_params += [dict_param_dict(dict_id(tcx, origs[orig]))];
-                    orig += 1u;
-                  }
-                }
-            }
-        }
-        @{impl_def: did, params: d_params}
-      }
-    }
-}
-
-fn get_static_dict(bcx: @block_ctxt, origin: typeck::dict_origin)
-    -> ValueRef {
-    let ccx = bcx_ccx(bcx);
-    let id = dict_id(ccx.tcx, origin);
-    alt ccx.dicts.find(id) {
-      some(d) { ret d; }
-      none. {}
-    }
-    let ptrs = C_struct(get_dict_ptrs(bcx, origin).ptrs);
-    let name = ccx.names.next("dict");
-    let gvar = str::as_buf(name, {|buf|
-        llvm::LLVMAddGlobal(ccx.llmod, val_ty(ptrs), buf)
-    });
-    llvm::LLVMSetGlobalConstant(gvar, lib::llvm::True);
-    llvm::LLVMSetInitializer(gvar, ptrs);
-    llvm::LLVMSetLinkage(gvar,
-                         lib::llvm::LLVMInternalLinkage as llvm::Linkage);
-    let cast = llvm::LLVMConstPointerCast(gvar, T_ptr(T_dict()));
-    ccx.dicts.insert(id, cast);
-    cast
-}
-
-fn get_dict_ptrs(bcx: @block_ctxt, origin: typeck::dict_origin)
-    -> {bcx: @block_ctxt, ptrs: [ValueRef]} {
-    let ccx = bcx_ccx(bcx);
+    let bcx = bcx, ccx = bcx_ccx(bcx);
     alt origin {
       typeck::dict_static(impl_did, tys, sub_origins) {
         let vtable = if impl_did.crate == ast::local_crate {
@@ -253,9 +143,9 @@ fn get_dict_ptrs(bcx: @block_ctxt, origin: typeck::dict_origin)
             get_extern_const(ccx.externs, ccx.llmod, name, T_ptr(T_i8()))
         };
         let impl_params = ty::lookup_item_type(ccx.tcx, impl_did).bounds;
-        let ptrs = [vtable], origin = 0u, ti = none, bcx = bcx;
-        vec::iter2(*impl_params, tys) {|param, ty|
-            let rslt = get_tydesc(bcx, ty, true, tps_normal, ti).result;
+        let ptrs = [vtable], i = 0u, origin = 0u, ti = none;
+        for param in *impl_params {
+            let rslt = get_tydesc(bcx, tys[i], false, tps_normal, ti).result;
             ptrs += [rslt.val];
             bcx = rslt.bcx;
             for bound in *param {
@@ -269,8 +159,18 @@ fn get_dict_ptrs(bcx: @block_ctxt, origin: typeck::dict_origin)
                   _ {}
                 }
             }
+            i += 1u;
         }
-        {bcx: bcx, ptrs: ptrs}
+        let pty = T_ptr(T_i8()), dict_ty = T_array(pty, vec::len(ptrs));
+        let dict = alloca(bcx, dict_ty), i = 0;
+        for ptr in ptrs {
+            Store(bcx, PointerCast(bcx, ptr, pty), GEPi(bcx, dict, [0, i]));
+            i += 1;
+        }
+        rslt(bcx, PointerCast(bcx, dict, T_ptr(T_dict())))
+      }
+      typeck::dict_param(n_param, n_bound) {
+        rslt(bcx, option::get(bcx.fcx.lltyparams[n_param].dicts)[n_bound])
       }
     }
-}
+}