Skip to content

Commit 5c192ae

Browse files
eddybeddyb
committed
rustc: move type definitions from middle::freevars to middle::ty.
1 parent 6536a0c commit 5c192ae

File tree

11 files changed

+86
-114
lines changed

11 files changed

+86
-114
lines changed

‎src/librustc/middle/astencode.rs

Lines changed: 14 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -18,13 +18,12 @@ use driver::session::Session;
1818
use metadata::decoder;
1919
use middle::def;
2020
use metadata::encoder as e;
21-
use middle::freevars::{CaptureMode, freevar_entry};
22-
use middle::freevars;
2321
use middle::region;
2422
use metadata::tydecode;
2523
use metadata::tydecode::{DefIdSource, NominalType, TypeWithId, TypeParameter};
2624
use metadata::tydecode::{RegionParameter};
2725
use metadata::tyencode;
26+
use middle::mem_categorization::Typer;
2827
use middle::subst;
2928
use middle::subst::VecPerParamSpace;
3029
use middle::typeck::{MethodCall, MethodCallee, MethodOrigin};
@@ -540,36 +539,36 @@ impl tr for ty::TraitStore {
540539
// ______________________________________________________________________
541540
// Encoding and decoding of freevar information
542541

543-
fn encode_freevar_entry(rbml_w: &mut Encoder, fv: &freevar_entry) {
542+
fn encode_freevar_entry(rbml_w: &mut Encoder, fv: &ty::Freevar) {
544543
(*fv).encode(rbml_w).unwrap();
545544
}
546545

547-
fn encode_capture_mode(rbml_w: &mut Encoder, cm: CaptureMode) {
546+
fn encode_capture_mode(rbml_w: &mut Encoder, cm: ast::CaptureClause) {
548547
cm.encode(rbml_w).unwrap();
549548
}
550549

551550
trait rbml_decoder_helper {
552551
fn read_freevar_entry(&mut self, dcx: &DecodeContext)
553-
-> freevar_entry;
554-
fn read_capture_mode(&mut self) -> CaptureMode;
552+
-> ty::Freevar;
553+
fn read_capture_mode(&mut self) -> ast::CaptureClause;
555554
}
556555

557556
impl<'a> rbml_decoder_helper for reader::Decoder<'a> {
558557
fn read_freevar_entry(&mut self, dcx: &DecodeContext)
559-
-> freevar_entry {
560-
let fv: freevar_entry = Decodable::decode(self).unwrap();
558+
-> ty::Freevar {
559+
let fv: ty::Freevar = Decodable::decode(self).unwrap();
561560
fv.tr(dcx)
562561
}
563562

564-
fn read_capture_mode(&mut self) -> CaptureMode {
565-
let cm: CaptureMode = Decodable::decode(self).unwrap();
563+
fn read_capture_mode(&mut self) -> ast::CaptureClause {
564+
let cm: ast::CaptureClause = Decodable::decode(self).unwrap();
566565
cm
567566
}
568567
}
569568

570-
impl tr for freevar_entry {
571-
fn tr(&self, dcx: &DecodeContext) -> freevar_entry {
572-
freevar_entry {
569+
impl tr for ty::Freevar {
570+
fn tr(&self, dcx: &DecodeContext) -> ty::Freevar {
571+
ty::Freevar {
573572
def: self.def.tr(dcx),
574573
span: self.span.tr(dcx),
575574
}
@@ -1291,8 +1290,8 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext,
12911290
});
12921291

12931292
for freevar in fv.iter() {
1294-
match freevars::get_capture_mode(tcx, id) {
1295-
freevars::CaptureByRef => {
1293+
match tcx.capture_mode(id) {
1294+
ast::CaptureByRef => {
12961295
rbml_w.tag(c::tag_table_upvar_borrow_map, |rbml_w| {
12971296
rbml_w.id(id);
12981297
rbml_w.tag(c::tag_table_val, |rbml_w| {

‎src/librustc/middle/expr_use_visitor.rs

Lines changed: 7 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -17,6 +17,7 @@
1717
use middle::mem_categorization as mc;
1818
use middle::def;
1919
use middle::freevars;
20+
use middle::mem_categorization::Typer;
2021
use middle::pat_util;
2122
use middle::ty;
2223
use middle::typeck::{MethodCall, MethodObject, MethodOrigin, MethodParam};
@@ -911,12 +912,12 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,TYPER> {
911912
debug!("walk_captures({})", closure_expr.repr(self.tcx()));
912913

913914
let tcx = self.typer.tcx();
914-
freevars::with_freevars(tcx, closure_expr.id, |freevars| {
915-
match freevars::get_capture_mode(self.tcx(), closure_expr.id) {
916-
freevars::CaptureByRef => {
915+
ty::with_freevars(tcx, closure_expr.id, |freevars| {
916+
match self.tcx().capture_mode(closure_expr.id) {
917+
ast::CaptureByRef => {
917918
self.walk_by_ref_captures(closure_expr, freevars);
918919
}
919-
freevars::CaptureByValue => {
920+
ast::CaptureByValue => {
920921
self.walk_by_value_captures(closure_expr, freevars);
921922
}
922923
}
@@ -925,7 +926,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,TYPER> {
925926

926927
fn walk_by_ref_captures(&mut self,
927928
closure_expr: &ast::Expr,
928-
freevars: &[freevars::freevar_entry]) {
929+
freevars: &[ty::Freevar]) {
929930
for freevar in freevars.iter() {
930931
let id_var = freevar.def.def_id().node;
931932
let cmt_var = return_if_err!(self.cat_captured_var(closure_expr.id,
@@ -950,7 +951,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,TYPER> {
950951

951952
fn walk_by_value_captures(&mut self,
952953
closure_expr: &ast::Expr,
953-
freevars: &[freevars::freevar_entry]) {
954+
freevars: &[ty::Freevar]) {
954955
for freevar in freevars.iter() {
955956
let cmt_var = return_if_err!(self.cat_captured_var(closure_expr.id,
956957
closure_expr.span,

‎src/librustc/middle/freevars.rs

Lines changed: 8 additions & 50 deletions
Original file line numberDiff line numberDiff line change
@@ -14,7 +14,6 @@
1414
#![allow(non_camel_case_types)]
1515

1616
use middle::def;
17-
use middle::mem_categorization::Typer;
1817
use middle::resolve;
1918
use middle::ty;
2019
use util::nodemap::{NodeMap, NodeSet};
@@ -24,27 +23,6 @@ use syntax::codemap::Span;
2423
use syntax::visit::Visitor;
2524
use syntax::visit;
2625

27-
#[deriving(Clone, Decodable, Encodable, Show)]
28-
pub enum CaptureMode {
29-
/// Copy/move the value into the environment.
30-
CaptureByValue,
31-
32-
/// Access by reference (used for stack closures).
33-
CaptureByRef
34-
}
35-
36-
// A vector of defs representing the free variables referred to in a function.
37-
// (The def_upvar will already have been stripped).
38-
#[deriving(Encodable, Decodable)]
39-
pub struct freevar_entry {
40-
pub def: def::Def, //< The variable being accessed free.
41-
pub span: Span //< First span where it is accessed (there can be multiple)
42-
}
43-
44-
pub type freevar_map = NodeMap<Vec<freevar_entry>>;
45-
46-
pub type CaptureModeMap = NodeMap<CaptureMode>;
47-
4826
struct CollectFreevarsVisitor<'a, 'b:'a> {
4927
node_id: ast::NodeId,
5028
seen: NodeSet,
@@ -60,30 +38,22 @@ impl<'a, 'b, 'v> Visitor<'v> for CollectFreevarsVisitor<'a, 'b> {
6038
fn visit_expr(&mut self, expr: &ast::Expr) {
6139
match expr.node {
6240
ast::ExprProc(..) => {
63-
self.cx.capture_mode_map.insert(expr.id, CaptureByValue);
41+
self.cx.capture_mode_map.insert(expr.id, ast::CaptureByValue);
6442
self.depth += 1;
6543
visit::walk_expr(self, expr);
6644
self.depth -= 1;
6745
}
6846
ast::ExprFnBlock(_, _, _) => {
6947
// NOTE(stage0): After snapshot, change to:
7048
//
71-
//let capture_mode = match capture_clause {
72-
// ast::CaptureByValue => CaptureByValue,
73-
// ast::CaptureByRef => CaptureByRef,
74-
//};
75-
let capture_mode = CaptureByRef;
76-
self.cx.capture_mode_map.insert(expr.id, capture_mode);
49+
//self.cx.capture_mode_map.insert(expr.id, capture_clause);
50+
self.cx.capture_mode_map.insert(expr.id, ast::CaptureByRef);
7751
self.depth += 1;
7852
visit::walk_expr(self, expr);
7953
self.depth -= 1;
8054
}
8155
ast::ExprUnboxedFn(capture_clause, _, _, _) => {
82-
let capture_mode = match capture_clause {
83-
ast::CaptureByValue => CaptureByValue,
84-
ast::CaptureByRef => CaptureByRef,
85-
};
86-
self.cx.capture_mode_map.insert(expr.id, capture_mode);
56+
self.cx.capture_mode_map.insert(expr.id, capture_clause);
8757
self.depth += 1;
8858
visit::walk_expr(self, expr);
8959
self.depth -= 1;
@@ -111,7 +81,7 @@ impl<'a, 'b, 'v> Visitor<'v> for CollectFreevarsVisitor<'a, 'b> {
11181
},
11282
_ => return
11383
};
114-
self.cx.freevars.find_or_insert(self.node_id, vec![]).push(freevar_entry {
84+
self.cx.freevars.find_or_insert(self.node_id, vec![]).push(ty::Freevar {
11585
def: def,
11686
span: expr.span,
11787
});
@@ -124,8 +94,8 @@ impl<'a, 'b, 'v> Visitor<'v> for CollectFreevarsVisitor<'a, 'b> {
12494

12595
struct AnnotateFreevarsVisitor<'a> {
12696
def_map: &'a resolve::DefMap,
127-
freevars: freevar_map,
128-
capture_mode_map: CaptureModeMap,
97+
freevars: ty::FreevarMap,
98+
capture_mode_map: ty::CaptureModeMap,
12999
}
130100

131101
impl<'a, 'v> Visitor<'v> for AnnotateFreevarsVisitor<'a> {
@@ -147,7 +117,7 @@ impl<'a, 'v> Visitor<'v> for AnnotateFreevarsVisitor<'a> {
147117
// node of interest rather than building up the free variables in
148118
// one pass. This could be improved upon if it turns out to matter.
149119
pub fn annotate_freevars(def_map: &resolve::DefMap, krate: &ast::Crate)
150-
-> (freevar_map, CaptureModeMap) {
120+
-> (ty::FreevarMap, ty::CaptureModeMap) {
151121
let mut visitor = AnnotateFreevarsVisitor {
152122
def_map: def_map,
153123
freevars: NodeMap::new(),
@@ -156,15 +126,3 @@ pub fn annotate_freevars(def_map: &resolve::DefMap, krate: &ast::Crate)
156126
visit::walk_crate(&mut visitor, krate);
157127
(visitor.freevars, visitor.capture_mode_map)
158128
}
159-
160-
pub fn with_freevars<T>(tcx: &ty::ctxt, fid: ast::NodeId, f: |&[freevar_entry]| -> T) -> T {
161-
match tcx.freevars.borrow().find(&fid) {
162-
None => fail!("with_freevars: {} has no freevars", fid),
163-
Some(d) => f(d.as_slice())
164-
}
165-
}
166-
167-
pub fn get_capture_mode<'tcx, T:Typer<'tcx>>(tcx: &T, closure_expr_id: ast::NodeId)
168-
-> CaptureMode {
169-
tcx.capture_mode(closure_expr_id)
170-
}

‎src/librustc/middle/kind.rs

Lines changed: 5 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -8,8 +8,6 @@
88
// option. This file may not be copied, modified, or distributed
99
// except according to those terms.
1010

11-
use middle::freevars::freevar_entry;
12-
use middle::freevars;
1311
use middle::mem_categorization::Typer;
1412
use middle::subst;
1513
use middle::ty;
@@ -146,10 +144,10 @@ fn check_item(cx: &mut Context, item: &Item) {
146144
fn with_appropriate_checker(cx: &Context,
147145
id: NodeId,
148146
fn_span: Span,
149-
b: |checker: |&Context, &freevar_entry||) {
147+
b: |checker: |&Context, &ty::Freevar||) {
150148
fn check_for_uniq(cx: &Context,
151149
fn_span: Span,
152-
fv: &freevar_entry,
150+
fv: &ty::Freevar,
153151
bounds: ty::BuiltinBounds) {
154152
// all captured data must be owned, regardless of whether it is
155153
// moved in or copied in.
@@ -162,7 +160,7 @@ fn with_appropriate_checker(cx: &Context,
162160
fn check_for_block(cx: &Context,
163161
fn_span: Span,
164162
fn_id: NodeId,
165-
fv: &freevar_entry,
163+
fv: &ty::Freevar,
166164
bounds: ty::BuiltinBounds) {
167165
let id = fv.def.def_id().node;
168166
let var_t = ty::node_id_to_type(cx.tcx, id);
@@ -177,7 +175,7 @@ fn with_appropriate_checker(cx: &Context,
177175
bounds, Some(var_t));
178176
}
179177

180-
fn check_for_bare(cx: &Context, fv: &freevar_entry) {
178+
fn check_for_bare(cx: &Context, fv: &ty::Freevar) {
181179
span_err!(cx.tcx.sess, fv.span, E0143,
182180
"can't capture dynamic environment in a fn item; \
183181
use the || {} closure form instead", "{ ... }");
@@ -227,7 +225,7 @@ fn check_fn(
227225

228226
// <Check kinds on free variables:
229227
with_appropriate_checker(cx, fn_id, sp, |chk| {
230-
freevars::with_freevars(cx.tcx, fn_id, |freevars| {
228+
ty::with_freevars(cx.tcx, fn_id, |freevars| {
231229
for fv in freevars.iter() {
232230
chk(cx, fv);
233231
}

‎src/librustc/middle/liveness.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -459,7 +459,7 @@ fn visit_expr(ir: &mut IrMaps, expr: &Expr) {
459459
// in better error messages than just pointing at the closure
460460
// construction site.
461461
let mut call_caps = Vec::new();
462-
freevars::with_freevars(ir.tcx, expr.id, |freevars| {
462+
ty::with_freevars(ir.tcx, expr.id, |freevars| {
463463
for fv in freevars.iter() {
464464
match fv.def {
465465
DefLocal(rv) => {

‎src/librustc/middle/mem_categorization.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -273,7 +273,7 @@ pub trait Typer<'tcx> {
273273
fn temporary_scope(&self, rvalue_id: ast::NodeId) -> Option<ast::NodeId>;
274274
fn upvar_borrow(&self, upvar_id: ty::UpvarId) -> ty::UpvarBorrow;
275275
fn capture_mode(&self, closure_expr_id: ast::NodeId)
276-
-> freevars::CaptureMode;
276+
-> ast::CaptureClause;
277277
fn unboxed_closures<'a>(&'a self)
278278
-> &'a RefCell<DefIdMap<ty::UnboxedClosure>>;
279279
}

‎src/librustc/middle/trans/closure.rs

Lines changed: 15 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -15,6 +15,7 @@ use driver::config::FullDebugInfo;
1515
use llvm::ValueRef;
1616
use middle::def;
1717
use middle::freevars;
18+
use middle::mem_categorization::Typer;
1819
use middle::trans::adt;
1920
use middle::trans::base::*;
2021
use middle::trans::build::*;
@@ -100,7 +101,7 @@ use syntax::ast_util;
100101
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
101102

102103
pub struct EnvValue {
103-
action: freevars::CaptureMode,
104+
action: ast::CaptureClause,
104105
datum: Datum<Lvalue>
105106
}
106107

@@ -120,8 +121,8 @@ pub fn mk_closure_tys(tcx: &ty::ctxt,
120121
// converted to ptrs.
121122
let bound_tys = bound_values.iter().map(|bv| {
122123
match bv.action {
123-
freevars::CaptureByValue => bv.datum.ty,
124-
freevars::CaptureByRef => ty::mk_mut_ptr(tcx, bv.datum.ty)
124+
ast::CaptureByValue => bv.datum.ty,
125+
ast::CaptureByRef => ty::mk_mut_ptr(tcx, bv.datum.ty)
125126
}
126127
}).collect();
127128
let cdata_ty = ty::mk_tup(tcx, bound_tys);
@@ -208,10 +209,10 @@ pub fn store_environment<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
208209
let bound_data = GEPi(bcx, llbox, [0u, abi::box_field_body, i]);
209210

210211
match bv.action {
211-
freevars::CaptureByValue => {
212+
ast::CaptureByValue => {
212213
bcx = bv.datum.store_to(bcx, bound_data);
213214
}
214-
freevars::CaptureByRef => {
215+
ast::CaptureByRef => {
215216
Store(bcx, bv.datum.to_llref(), bound_data);
216217
}
217218
}
@@ -223,8 +224,8 @@ pub fn store_environment<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
223224
// Given a context and a list of upvars, build a closure. This just
224225
// collects the upvars and packages them up for store_environment.
225226
fn build_closure<'blk, 'tcx>(bcx0: Block<'blk, 'tcx>,
226-
freevar_mode: freevars::CaptureMode,
227-
freevars: &Vec<freevars::freevar_entry>,
227+
freevar_mode: ast::CaptureClause,
228+
freevars: &Vec<ty::Freevar>,
228229
store: ty::TraitStore)
229230
-> ClosureResult<'blk, 'tcx> {
230231
let _icx = push_ctxt("closure::build_closure");
@@ -247,7 +248,7 @@ fn build_closure<'blk, 'tcx>(bcx0: Block<'blk, 'tcx>,
247248
// with the upvars and type descriptors.
248249
fn load_environment<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
249250
cdata_ty: ty::t,
250-
freevars: &Vec<freevars::freevar_entry>,
251+
freevars: &Vec<ty::Freevar>,
251252
store: ty::TraitStore)
252253
-> Block<'blk, 'tcx> {
253254
let _icx = push_ctxt("closure::load_environment");
@@ -301,7 +302,7 @@ fn load_environment<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
301302
fn load_unboxed_closure_environment<'blk, 'tcx>(
302303
bcx: Block<'blk, 'tcx>,
303304
arg_scope_id: ScopeId,
304-
freevars: &Vec<freevars::freevar_entry>,
305+
freevars: &Vec<ty::Freevar>,
305306
closure_id: ast::DefId)
306307
-> Block<'blk, 'tcx> {
307308
let _icx = push_ctxt("closure::load_environment");
@@ -386,11 +387,9 @@ pub fn trans_expr_fn<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
386387
// set an inline hint for all closures
387388
set_inline_hint(llfn);
388389

389-
let freevar_mode = freevars::get_capture_mode(tcx, id);
390-
let freevars: Vec<freevars::freevar_entry> =
391-
freevars::with_freevars(tcx,
392-
id,
393-
|fv| fv.iter().map(|&fv| fv).collect());
390+
let freevar_mode = tcx.capture_mode(id);
391+
let freevars: Vec<ty::Freevar> =
392+
ty::with_freevars(tcx, id, |fv| fv.iter().map(|&fv| fv).collect());
394393

395394
let ClosureResult {
396395
llbox,
@@ -476,10 +475,8 @@ pub fn trans_unboxed_closure<'blk, 'tcx>(
476475
.clone();
477476
let function_type = ty::mk_closure(bcx.tcx(), function_type);
478477

479-
let freevars: Vec<freevars::freevar_entry> =
480-
freevars::with_freevars(bcx.tcx(),
481-
id,
482-
|fv| fv.iter().map(|&fv| fv).collect());
478+
let freevars: Vec<ty::Freevar> =
479+
ty::with_freevars(bcx.tcx(), id, |fv| fv.iter().map(|&fv| fv).collect());
483480
let freevars_ptr = &freevars;
484481

485482
trans_closure(bcx.ccx(),

0 commit comments

Comments
 (0)