---

yaml
---
r: 4055
b: refs/heads/master
c: c62a9fe
h: refs/heads/master
i:
  4053: cae2524
  4051: d981446
  4047: 659cfab
v: v3

Author: msullivan

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 3b2d23b2cdc270715f559d7fc0cfe4019011a7de
+refs/heads/master: c62a9fec775a2f0fba5980fb13329bed57a1b118

trunk/src/comp/back/link.rs

@@ -2,9 +2,9 @@
 import driver::session;
 import lib::llvm::llvm;
 import front::attr;
+import middle::trans;
 import middle::ty;
 import metadata::encoder;
-import middle::trans_common::crate_ctxt;
 import std::str;
 import std::fs;
 import std::ivec;
@@ -13,6 +13,7 @@ import option::some;
 import option::none;
 import std::sha1::sha1;
 import std::sort;
+import trans::crate_ctxt;
 import syntax::ast;
 import syntax::print::pprust;
 import lib::llvm::llvm::ModuleRef;

trunk/src/comp/driver/rustc.rs

@@ -143,7 +143,7 @@ fn compile_input(session::session sess, ast::crate_cfg cfg, str input,
              bind middle::tstate::ck::check_crate(ty_cx, crate));
     }
     time(time_passes, "alias checking",
-         bind middle::alias::check_crate(ty_cx, crate));
+         bind middle::alias::check_crate(@ty_cx, crate));
     auto llmod =
         time[llvm::llvm::ModuleRef](time_passes, "translation",
                                     bind trans::trans_crate

trunk/src/comp/metadata/encoder.rs

@@ -11,7 +11,7 @@ import std::ebmlivec;
 import std::map;
 import syntax::ast::*;
 import common::*;
-import middle::trans_common::crate_ctxt;
+import middle::trans::crate_ctxt;
 import middle::ty;
 import middle::ty::node_id_to_monotype;
 import front::attr;

trunk/src/comp/middle/alias.rs

@@ -36,10 +36,10 @@ type scope = @restrict[];
 
 tag local_info { arg(ast::mode); objfield(ast::mutability); }
 
-type ctx = rec(ty::ctxt tcx,
+type ctx = rec(@ty::ctxt tcx,
                std::map::hashmap[node_id, local_info] local_map);
 
-fn check_crate(ty::ctxt tcx, &@ast::crate crate) {
+fn check_crate(@ty::ctxt tcx, &@ast::crate crate) {
     auto cx = @rec(tcx=tcx,
                    // Stores information about object fields and function
                    // arguments that's otherwise not easily available.
@@ -149,7 +149,7 @@ fn visit_decl(&@ctx cx, &@ast::decl d, &scope sc, &vt[scope] v) {
 
 fn check_call(&ctx cx, &@ast::expr f, &(@ast::expr)[] args, &scope sc) ->
    rec(node_id[] root_vars, ty::t[] unsafe_ts) {
-    auto fty = ty::expr_ty(cx.tcx, f);
+    auto fty = ty::expr_ty(*cx.tcx, f);
     auto arg_ts = fty_args(cx, fty);
     let node_id[] roots = ~[];
     let tup(uint, node_id)[] mut_roots = ~[];
@@ -248,7 +248,7 @@ fn check_tail_call(&ctx cx, &@ast::expr call) {
             case (ast::expr_call(?f, ?args_)) { args = args_; f }
         };
     auto i = 0u;
-    for (ty::arg arg_t in fty_args(cx, ty::expr_ty(cx.tcx, f))) {
+    for (ty::arg arg_t in fty_args(cx, ty::expr_ty(*cx.tcx, f))) {
         if (arg_t.mode != ty::mo_val) {
             auto mut_a = arg_t.mode == ty::mo_alias(true);
             auto ok = true;
@@ -354,15 +354,15 @@ fn check_for(&ctx cx, &@ast::local local, &@ast::expr seq, &ast::block block,
     auto unsafe = alt (inner_mut(root.ds)) { some(?t) { ~[t] } _ { ~[] } };
 
     // If this is a mutable vector, don't allow it to be touched.
-    auto seq_t = ty::expr_ty(cx.tcx, seq);
-    alt (ty::struct(cx.tcx, seq_t)) {
+    auto seq_t = ty::expr_ty(*cx.tcx, seq);
+    alt (ty::struct(*cx.tcx, seq_t)) {
         ty::ty_vec(?mt) | ty::ty_ivec(?mt) {
             if (mt.mut != ast::imm) { unsafe = ~[seq_t]; }
         }
         ty::ty_str | ty::ty_istr { /* no-op */ }
         _ {
             cx.tcx.sess.span_unimpl(seq.span, "unknown seq type " +
-                                    util::ppaux::ty_to_str(cx.tcx, seq_t));
+                                    util::ppaux::ty_to_str(*cx.tcx, seq_t));
         }
     }
     auto new_sc =
@@ -380,7 +380,7 @@ fn check_var(&ctx cx, &@ast::expr ex, &ast::path p, ast::node_id id,
     auto def = cx.tcx.def_map.get(id);
     if (!def_is_local(def, true)) { ret; }
     auto my_defnum = ast::def_id_of_def(def)._1;
-    auto var_t = ty::expr_ty(cx.tcx, ex);
+    auto var_t = ty::expr_ty(*cx.tcx, ex);
     for (restrict r in *sc) {
         // excludes variables introduced since the alias was made
         if (my_defnum < r.block_defnum) {
@@ -523,7 +523,7 @@ fn expr_root(&ctx cx, @ast::expr ex, bool autoderef) ->
    rec(@ast::expr ex, @deref[] ds) {
     fn maybe_auto_unbox(&ctx cx, &ty::t t) ->
        rec(ty::t t, option::t[deref] d) {
-        alt (ty::struct(cx.tcx, t)) {
+        alt (ty::struct(*cx.tcx, t)) {
             case (ty::ty_box(?mt)) {
                 ret rec(t=mt.ty,
                         d=some(@rec(mut=mt.mut != ast::imm,
@@ -541,9 +541,9 @@ fn expr_root(&ctx cx, @ast::expr ex, bool autoderef) ->
         alt ({ ex.node }) {
             case (ast::expr_field(?base, ?ident)) {
                 auto auto_unbox =
-                    maybe_auto_unbox(cx, ty::expr_ty(cx.tcx, base));
+                    maybe_auto_unbox(cx, ty::expr_ty(*cx.tcx, base));
                 auto mut = false;
-                alt (ty::struct(cx.tcx, auto_unbox.t)) {
+                alt (ty::struct(*cx.tcx, auto_unbox.t)) {
                     case (ty::ty_tup(?fields)) {
                         auto fnm = ty::field_num(cx.tcx.sess, ex.span, ident);
                         mut = fields.(fnm).mut != ast::imm;
@@ -564,8 +564,8 @@ fn expr_root(&ctx cx, @ast::expr ex, bool autoderef) ->
             }
             case (ast::expr_index(?base, _)) {
                 auto auto_unbox =
-                    maybe_auto_unbox(cx, ty::expr_ty(cx.tcx, base));
-                alt (ty::struct(cx.tcx, auto_unbox.t)) {
+                    maybe_auto_unbox(cx, ty::expr_ty(*cx.tcx, base));
+                alt (ty::struct(*cx.tcx, auto_unbox.t)) {
                     case (ty::ty_vec(?mt)) {
                         ds += ~[@rec(mut=mt.mut != ast::imm,
                                     kind=index,
@@ -582,9 +582,9 @@ fn expr_root(&ctx cx, @ast::expr ex, bool autoderef) ->
             }
             case (ast::expr_unary(?op, ?base)) {
                 if (op == ast::deref) {
-                    auto base_t = ty::expr_ty(cx.tcx, base);
+                    auto base_t = ty::expr_ty(*cx.tcx, base);
                     auto mut = false;
-                    alt (ty::struct(cx.tcx, base_t)) {
+                    alt (ty::struct(*cx.tcx, base_t)) {
                         case (ty::ty_box(?mt)) { mut = mt.mut != ast::imm; }
                         case (ty::ty_res(_, _, _)) {}
                         case (ty::ty_tag(_, _)) {}
@@ -598,7 +598,7 @@ fn expr_root(&ctx cx, @ast::expr ex, bool autoderef) ->
         }
     }
     if (autoderef) {
-        auto auto_unbox = maybe_auto_unbox(cx, ty::expr_ty(cx.tcx, ex));
+        auto auto_unbox = maybe_auto_unbox(cx, ty::expr_ty(*cx.tcx, ex));
         maybe_push_auto_unbox(auto_unbox.d, ds);
     }
     ret rec(ex=ex, ds=@ds);
@@ -669,7 +669,7 @@ fn ty_can_unsafely_include(&ctx cx, ty::t needle, ty::t haystack, bool mut) ->
             _ { ret false; }
         }
     }
-    ret helper(cx.tcx, needle, haystack, mut);
+    ret helper(*cx.tcx, needle, haystack, mut);
 }
 
 fn def_is_local(&ast::def d, bool objfields_count) -> bool {
@@ -681,7 +681,7 @@ fn def_is_local(&ast::def d, bool objfields_count) -> bool {
 }
 
 fn fty_args(&ctx cx, ty::t fty) -> ty::arg[] {
-    ret alt (ty::struct(cx.tcx, ty::type_autoderef(cx.tcx, fty))) {
+    ret alt (ty::struct(*cx.tcx, ty::type_autoderef(*cx.tcx, fty))) {
         ty::ty_fn(_, ?args, _, _, _) | ty::ty_native_fn(_, ?args, _) { args }
     };
 }