nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-04-28 02:57:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rename and modernize region enum names

Browse Source
This commit is contained in:
Niko Matsakis 2013-10-29 10:34:11 -04:00
parent 5e54a7323d
commit 195f1d77bd
35 changed files with 315 additions and 307 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
src/librustc/metadata/tydecode.rs
View File

@ -228,22 +228,22 @@ fn parse_region_substs(st: &mut PState, conv: conv_did) -> ty::RegionSubsts {
}
}
fn parse_bound_region(st: &mut PState, conv: conv_did) -> ty::bound_region {
fn parse_bound_region(st: &mut PState, conv: conv_did) -> ty::BoundRegion {
match next(st) {
'a' => {
let id = parse_uint(st);
assert_eq!(next(st), '|');
ty::br_anon(id)
ty::BrAnon(id)
}
'[' => {
let def = parse_def(st, RegionParameter, |x,y| conv(x,y));
let ident = st.tcx.sess.ident_of(parse_str(st, ']'));
ty::br_named(def, ident)
ty::BrNamed(def, ident)
}
'f' => {
let id = parse_uint(st);
assert_eq!(next(st), '|');
ty::br_fresh(id)
ty::BrFresh(id)
}
_ => fail!("parse_bound_region: bad input")
}
@ -257,7 +257,7 @@ fn parse_region(st: &mut PState, conv: conv_did) -> ty::Region {
assert_eq!(next(st), '|');
let br = parse_bound_region(st, |x,y| conv(x,y));
assert_eq!(next(st), ']');
ty::re_fn_bound(id, br)
ty::ReLateBound(id, br)
}
'B' => {
assert_eq!(next(st), '[');
@ -266,7 +266,7 @@ fn parse_region(st: &mut PState, conv: conv_did) -> ty::Region {
let index = parse_uint(st);
assert_eq!(next(st), '|');
let nm = st.tcx.sess.ident_of(parse_str(st, ']'));
ty::re_type_bound(node_id, index, nm)
ty::ReEarlyBound(node_id, index, nm)
}
'f' => {
assert_eq!(next(st), '[');
@ -274,19 +274,19 @@ fn parse_region(st: &mut PState, conv: conv_did) -> ty::Region {
assert_eq!(next(st), '|');
let br = parse_bound_region(st, |x,y| conv(x,y));
assert_eq!(next(st), ']');
ty::re_free(ty::FreeRegion {scope_id: id,
ty::ReFree(ty::FreeRegion {scope_id: id,
bound_region: br})
}
's' => {
let id = parse_uint(st) as int;
assert_eq!(next(st), '|');
ty::re_scope(id)
ty::ReScope(id)
}
't' => {
ty::re_static
ty::ReStatic
}
'e' => {
ty::re_static
ty::ReStatic
}
_ => fail!("parse_region: bad input")
}

22
src/librustc/metadata/tyencode.rs
View File

@ -155,49 +155,49 @@ fn enc_region_substs(w: @mut MemWriter, cx: @ctxt, substs: &ty::RegionSubsts) {
fn enc_region(w: @mut MemWriter, cx: @ctxt, r: ty::Region) {
match r {
ty::re_fn_bound(id, br) => {
ty::ReLateBound(id, br) => {
mywrite!(w, "b[{}|", id);
enc_bound_region(w, cx, br);
mywrite!(w, "]");
}
ty::re_type_bound(node_id, index, ident) => {
ty::ReEarlyBound(node_id, index, ident) => {
mywrite!(w, "B[{}|{}|{}]",
node_id,
index,
cx.tcx.sess.str_of(ident));
}
ty::re_free(ref fr) => {
ty::ReFree(ref fr) => {
mywrite!(w, "f[{}|", fr.scope_id);
enc_bound_region(w, cx, fr.bound_region);
mywrite!(w, "]");
}
ty::re_scope(nid) => {
ty::ReScope(nid) => {
mywrite!(w, "s{}|", nid);
}
ty::re_static => {
ty::ReStatic => {
mywrite!(w, "t");
}
ty::re_empty => {
ty::ReEmpty => {
mywrite!(w, "e");
}
ty::re_infer(_) => {
ty::ReInfer(_) => {
// these should not crop up after typeck
cx.diag.handler().bug("Cannot encode region variables");
}
}
}
fn enc_bound_region(w: @mut MemWriter, cx: @ctxt, br: ty::bound_region) {
fn enc_bound_region(w: @mut MemWriter, cx: @ctxt, br: ty::BoundRegion) {
match br {
ty::br_anon(idx) => {
ty::BrAnon(idx) => {
mywrite!(w, "a{}|", idx);
}
ty::br_named(d, s) => {
ty::BrNamed(d, s) => {
mywrite!(w, "[{}|{}]",
(cx.ds)(d),
cx.tcx.sess.str_of(s));
}
ty::br_fresh(id) => {
ty::BrFresh(id) => {
mywrite!(w, "f{}|", id);
}
}

22
src/librustc/middle/astencode.rs
View File

@ -476,27 +476,27 @@ impl tr for ty::AutoRef {
impl tr for ty::Region {
fn tr(&self, xcx: @ExtendedDecodeContext) -> ty::Region {
match *self {
ty::re_fn_bound(id, br) => ty::re_fn_bound(xcx.tr_id(id),
ty::ReLateBound(id, br) => ty::ReLateBound(xcx.tr_id(id),
br.tr(xcx)),
ty::re_type_bound(id, index, ident) => ty::re_type_bound(xcx.tr_id(id),
ty::ReEarlyBound(id, index, ident) => ty::ReEarlyBound(xcx.tr_id(id),
index,
ident),
ty::re_scope(id) => ty::re_scope(xcx.tr_id(id)),
ty::re_empty | ty::re_static | ty::re_infer(*) => *self,
ty::re_free(ref fr) => {
ty::re_free(ty::FreeRegion {scope_id: xcx.tr_id(fr.scope_id),
ty::ReScope(id) => ty::ReScope(xcx.tr_id(id)),
ty::ReEmpty | ty::ReStatic | ty::ReInfer(*) => *self,
ty::ReFree(ref fr) => {
ty::ReFree(ty::FreeRegion {scope_id: xcx.tr_id(fr.scope_id),
bound_region: fr.bound_region.tr(xcx)})
}
}
}
}
impl tr for ty::bound_region {
fn tr(&self, xcx: @ExtendedDecodeContext) -> ty::bound_region {
impl tr for ty::BoundRegion {
fn tr(&self, xcx: @ExtendedDecodeContext) -> ty::BoundRegion {
match *self {
ty::br_anon(_) |
ty::br_fresh(_) => *self,
ty::br_named(id, ident) => ty::br_named(xcx.tr_def_id(id),
ty::BrAnon(_) |
ty::BrFresh(_) => *self,
ty::BrNamed(id, ident) => ty::BrNamed(xcx.tr_def_id(id),
ident),
}
}

18
src/librustc/middle/borrowck/gather_loans/lifetime.rs
View File

@ -199,7 +199,7 @@ impl<'self> GuaranteeLifetimeContext<'self> {
// Make sure that the loan does not exceed the maximum time
// that we can root the value, dynamically.
let root_region = ty::re_scope(self.root_scope_id);
let root_region = ty::ReScope(self.root_scope_id);
if !self.bccx.is_subregion_of(self.loan_region, root_region) {
self.report_error(
err_out_of_root_scope(root_region, self.loan_region));
@ -208,9 +208,9 @@ impl<'self> GuaranteeLifetimeContext<'self> {
// Extract the scope id that indicates how long the rooting is required
let root_scope = match self.loan_region {
ty::re_scope(id) => id,
ty::ReScope(id) => id,
_ => {
// the check above should fail for anything is not re_scope
// the check above should fail for anything is not ReScope
self.bccx.tcx.sess.span_bug(
cmt_base.span,
format!("Cannot issue root for scope region: {:?}",
@ -260,12 +260,12 @@ impl<'self> GuaranteeLifetimeContext<'self> {
note_and_explain_region(
self.bccx.tcx,
"managed value only needs to be frozen for ",
ty::re_scope(root_scope),
ty::ReScope(root_scope),
"...");
note_and_explain_region(
self.bccx.tcx,
"...but due to Issue #6248, it will be frozen for ",
ty::re_scope(cleanup_scope),
ty::ReScope(cleanup_scope),
"");
}
@ -324,13 +324,13 @@ impl<'self> GuaranteeLifetimeContext<'self> {
match cmt.cat {
mc::cat_rvalue(cleanup_scope_id) => {
ty::re_scope(cleanup_scope_id)
ty::ReScope(cleanup_scope_id)
}
mc::cat_copied_upvar(_) => {
ty::re_scope(self.item_scope_id)
ty::ReScope(self.item_scope_id)
}
mc::cat_static_item => {
ty::re_static
ty::ReStatic
}
mc::cat_local(local_id) |
mc::cat_arg(local_id) |
@ -338,7 +338,7 @@ impl<'self> GuaranteeLifetimeContext<'self> {
self.bccx.tcx.region_maps.encl_region(local_id)
}
mc::cat_deref(_, _, mc::unsafe_ptr(*)) => {
ty::re_static
ty::ReStatic
}
mc::cat_deref(_, _, mc::region_ptr(_, r)) => {
r

20
src/librustc/middle/borrowck/gather_loans/mod.rs
View File

@ -277,7 +277,7 @@ fn gather_loans_in_expr(this: &mut GatherLoanCtxt,
// Currently these do not use adjustments, so we have to
// hardcode this check here (note that the receiver DOES use
// adjustments).
let scope_r = ty::re_scope(ex.id);
let scope_r = ty::ReScope(ex.id);
let arg_cmt = this.bccx.cat_expr(arg);
this.guarantee_valid(arg.id,
arg.span,
@ -441,7 +441,7 @@ impl<'self> GatherLoanCtxt<'self> {
// a loan for the empty region can never be dereferenced, so
// it is always safe
if loan_region == ty::re_empty {
if loan_region == ty::ReEmpty {
return;
}
@ -470,10 +470,10 @@ impl<'self> GatherLoanCtxt<'self> {
restrictions::SafeIf(loan_path, restrictions) => {
let loan_scope = match loan_region {
ty::re_scope(id) => id,
ty::re_free(ref fr) => fr.scope_id,
ty::ReScope(id) => id,
ty::ReFree(ref fr) => fr.scope_id,
ty::re_static => {
ty::ReStatic => {
// If we get here, an error must have been
// reported in
// `lifetime::guarantee_lifetime()`, because
@ -485,10 +485,10 @@ impl<'self> GatherLoanCtxt<'self> {
return;
}
ty::re_empty |
ty::re_fn_bound(*) |
ty::re_type_bound(*) |
ty::re_infer(*) => {
ty::ReEmpty |
ty::ReLateBound(*) |
ty::ReEarlyBound(*) |
ty::ReInfer(*) => {
self.tcx().sess.span_bug(
cmt.span,
format!("Invalid borrow lifetime: {:?}", loan_region));
@ -715,7 +715,7 @@ impl<'self> GatherLoanCtxt<'self> {
let cmt_discr = match arm_match_ids {
None => cmt,
Some((arm_id, match_id)) => {
let arm_scope = ty::re_scope(arm_id);
let arm_scope = ty::ReScope(arm_id);
if self.bccx.is_subregion_of(scope_r, arm_scope) {
self.bccx.cat_discr(cmt, match_id)
} else {

6
src/librustc/middle/kind.rs
View File

@ -545,7 +545,7 @@ pub fn check_cast_for_escaping_regions(
// Check, based on the region associated with the trait, whether it can
// possibly escape the enclosing fn item (note that all type parameters
// must have been declared on the enclosing fn item).
if target_regions.iter().any(|r| is_re_scope(*r)) {
if target_regions.iter().any(|r| is_ReScope(*r)) {
return; /* case (1) */
}
@ -584,9 +584,9 @@ pub fn check_cast_for_escaping_regions(
}
});
fn is_re_scope(r: ty::Region) -> bool {
fn is_ReScope(r: ty::Region) -> bool {
match r {
ty::re_scope(*) => true,
ty::ReScope(*) => true,
_ => false
}
}

10
src/librustc/middle/region.rs
View File

@ -137,7 +137,7 @@ impl RegionMaps {
pub fn encl_region(&self, id: ast::NodeId) -> ty::Region {
//! Returns the narrowest scope region that encloses `id`, if any.
ty::re_scope(self.encl_scope(id))
ty::ReScope(self.encl_scope(id))
}
pub fn scopes_intersect(&self, scope1: ast::NodeId, scope2: ast::NodeId)
@ -227,19 +227,19 @@ impl RegionMaps {
sub_region == super_region || {
match (sub_region, super_region) {
(_, ty::re_static) => {
(_, ty::ReStatic) => {
true
}
(ty::re_scope(sub_scope), ty::re_scope(super_scope)) => {
(ty::ReScope(sub_scope), ty::ReScope(super_scope)) => {
self.is_subscope_of(sub_scope, super_scope)
}
(ty::re_scope(sub_scope), ty::re_free(ref fr)) => {
(ty::ReScope(sub_scope), ty::ReFree(ref fr)) => {
self.is_subscope_of(sub_scope, fr.scope_id)
}
(ty::re_free(sub_fr), ty::re_free(super_fr)) => {
(ty::ReFree(sub_fr), ty::ReFree(super_fr)) => {
self.sub_free_region(sub_fr, super_fr)
}

4
src/librustc/middle/resolve_lifetime.rs
View File

@ -176,7 +176,7 @@ impl LifetimeContext {
ItemScope(lifetimes) => {
match search_lifetimes(lifetimes, lifetime_ref) {
Some((index, decl_id)) => {
let def = ast::DefTypeBoundRegion(index, decl_id);
let def = ast::DefEarlyBoundRegion(index, decl_id);
self.insert_lifetime(lifetime_ref, def);
return;
}
@ -189,7 +189,7 @@ impl LifetimeContext {
FnScope(id, lifetimes, s) => {
match search_lifetimes(lifetimes, lifetime_ref) {
Some((_index, decl_id)) => {
let def = ast::DefFnBoundRegion(id, depth, decl_id);
let def = ast::DefLateBoundRegion(id, depth, decl_id);
self.insert_lifetime(lifetime_ref, def);
return;
}

4
src/librustc/middle/subst.rs
View File

@ -193,9 +193,9 @@ impl Subst for ty::Region {
// the specialized routine
// `middle::typeck::check::regionmanip::replace_bound_regions_in_fn_sig()`.
match self {
&ty::re_type_bound(_, i, _) => {
&ty::ReEarlyBound(_, i, _) => {
match substs.regions {
ty::ErasedRegions => ty::re_static,
ty::ErasedRegions => ty::ReStatic,
ty::NonerasedRegions(ref regions) => *regions.get(i),
}
}

4
src/librustc/middle/trans/_match.rs
View File

@ -1048,7 +1048,7 @@ fn extract_vec_elems(bcx: @mut Block,
let slice_len = Sub(bcx, len, slice_len_offset);
let slice_ty = ty::mk_evec(bcx.tcx(),
ty::mt {ty: vt.unit_ty, mutbl: ast::MutImmutable},
ty::vstore_slice(ty::re_static)
ty::vstore_slice(ty::ReStatic)
);
let scratch = scratch_datum(bcx, slice_ty, "", false);
Store(bcx, slice_begin,
@ -1697,7 +1697,7 @@ fn compile_submatch_continue(mut bcx: @mut Block,
let t = node_id_type(bcx, pat_id);
let Result {bcx: after_cx, val: matches} = {
do with_scope_result(bcx, None,
"compare_scope") |bcx| {
"compaReScope") |bcx| {
match trans_opt(bcx, opt) {
single_result(
Result {bcx, val}) => {

6
src/librustc/middle/trans/consts.rs
View File

@ -181,7 +181,7 @@ pub fn const_expr(cx: @mut CrateContext, e: &ast::Expr) -> (ValueRef, bool) {
let adjustment = cx.tcx.adjustments.find_copy(&e.id);
match adjustment {
None => { }
Some(@ty::AutoAddEnv(ty::re_static, ast::BorrowedSigil)) => {
Some(@ty::AutoAddEnv(ty::ReStatic, ast::BorrowedSigil)) => {
llconst = C_struct([llconst, C_null(Type::opaque_box(cx).ptr_to())], false)
}
Some(@ty::AutoAddEnv(ref r, ref s)) => {
@ -211,11 +211,11 @@ pub fn const_expr(cx: @mut CrateContext, e: &ast::Expr) -> (ValueRef, bool) {
};
match *autoref {
ty::AutoUnsafe(m) |
ty::AutoPtr(ty::re_static, m) => {
ty::AutoPtr(ty::ReStatic, m) => {
assert!(m != ast::MutMutable);
llconst = llptr;
}
ty::AutoBorrowVec(ty::re_static, m) => {
ty::AutoBorrowVec(ty::ReStatic, m) => {
assert!(m != ast::MutMutable);
assert_eq!(abi::slice_elt_base, 0);
assert_eq!(abi::slice_elt_len, 1);

2
src/librustc/middle/trans/datum.rs
View File

@ -588,7 +588,7 @@ impl Datum {
// result (which will be by-value). Note that it is not
// significant *which* region we pick here.
let llval = self.to_ref_llval(bcx);
let rptr_ty = ty::mk_imm_rptr(bcx.tcx(), ty::re_static,
let rptr_ty = ty::mk_imm_rptr(bcx.tcx(), ty::ReStatic,
self.ty);
Datum {val: llval, ty: rptr_ty, mode: ByValue}
}

2
src/librustc/middle/trans/expr.rs
View File

@ -271,7 +271,7 @@ pub fn trans_to_datum(bcx: @mut Block, expr: &ast::Expr) -> DatumBlock {
// real one, but it will have the same runtime representation
let slice_ty = ty::mk_evec(tcx,
ty::mt { ty: unit_ty, mutbl: ast::MutImmutable },
ty::vstore_slice(ty::re_static));
ty::vstore_slice(ty::ReStatic));
let scratch = scratch_datum(bcx, slice_ty, "__adjust", false);

2
src/librustc/middle/trans/glue.rs
View File

@ -339,7 +339,7 @@ pub fn make_visit_glue(bcx: @mut Block, v: ValueRef, t: ty::t) -> @mut Block {
do with_scope(bcx, None, "visitor cleanup") |bcx| {
let mut bcx = bcx;
let (visitor_trait, object_ty) = match ty::visitor_object_ty(bcx.tcx(),
ty::re_static) {
ty::ReStatic) {
Ok(pair) => pair,
Err(s) => {
bcx.tcx().sess.fatal(s);

2
src/librustc/middle/trans/reflect.rs
View File

@ -59,7 +59,7 @@ impl Reflector {
// We're careful to not use first class aggregates here because that
// will kick us off fast isel. (Issue #4352.)
let bcx = self.bcx;
let str_vstore = ty::vstore_slice(ty::re_static);
let str_vstore = ty::vstore_slice(ty::ReStatic);
let str_ty = ty::mk_estr(bcx.tcx(), str_vstore);
let scratch = scratch_datum(bcx, str_ty, "", false);
let len = C_uint(bcx.ccx(), s.len());

72
src/librustc/middle/ty.rs
View File

@ -470,43 +470,45 @@ pub struct param_ty {
/// Representation of regions:
#[deriving(Clone, Eq, IterBytes, Encodable, Decodable, ToStr)]
pub enum Region {
// Region bound in a type declaration (type/enum/struct/trait),
// which will be substituted when an instance of the type is accessed
re_type_bound(/* param id */ ast::NodeId, /*index*/ uint, ast::Ident),
// Region bound in a type or fn declaration which will be
// substituted 'early' -- that is, at the same time when type
// parameters are substituted.
ReEarlyBound(/* param id */ ast::NodeId, /*index*/ uint, ast::Ident),
// Region bound in a fn scope, which will be substituted when the
// fn is called.
re_fn_bound(/* binder_id */ ast::NodeId, bound_region),
// Region bound in a function scope, which will be substituted when the
// function is called. The first argument must be the `binder_id` of
// some enclosing function signature.
ReLateBound(/* binder_id */ ast::NodeId, BoundRegion),
/// When checking a function body, the types of all arguments and so forth
/// that refer to bound region parameters are modified to refer to free
/// region parameters.
re_free(FreeRegion),
ReFree(FreeRegion),
/// A concrete region naming some expression within the current function.
re_scope(NodeId),
ReScope(NodeId),
/// Static data that has an "infinite" lifetime. Top in the region lattice.
re_static,
ReStatic,
/// A region variable. Should not exist after typeck.
re_infer(InferRegion),
ReInfer(InferRegion),
/// Empty lifetime is for data that is never accessed.
/// Bottom in the region lattice. We treat re_empty somewhat
/// Bottom in the region lattice. We treat ReEmpty somewhat
/// specially; at least right now, we do not generate instances of
/// it during the GLB computations, but rather
/// generate an error instead. This is to improve error messages.
/// The only way to get an instance of re_empty is to have a region
/// The only way to get an instance of ReEmpty is to have a region
/// variable with no constraints.
re_empty,
ReEmpty,
}
impl Region {
pub fn is_bound(&self) -> bool {
match self {
&ty::re_type_bound(*) => true,
&ty::re_fn_bound(*) => true,
&ty::ReEarlyBound(*) => true,
&ty::ReLateBound(*) => true,
_ => false
}
}
@ -515,28 +517,28 @@ impl Region {
#[deriving(Clone, Eq, TotalOrd, TotalEq, IterBytes, Encodable, Decodable, ToStr)]
pub struct FreeRegion {
scope_id: NodeId,
bound_region: bound_region
bound_region: BoundRegion
}
#[deriving(Clone, Eq, TotalEq, TotalOrd, IterBytes, Encodable, Decodable, ToStr)]
pub enum bound_region {
pub enum BoundRegion {
/// An anonymous region parameter for a given fn (&T)
br_anon(uint),
BrAnon(uint),
/// Named region parameters for functions (a in &'a T)
///
/// The def-id is needed to distinguish free regions in
/// the event of shadowing.
br_named(ast::DefId, ast::Ident),
BrNamed(ast::DefId, ast::Ident),
/// Fresh bound identifiers created during GLB computations.
br_fresh(uint),
BrFresh(uint),
}
/**
* Represents the values to use when substituting lifetime parameters.
* If the value is `ErasedRegions`, then this subst is occurring during
* trans, and all region parameters will be replaced with `ty::re_static`. */
* trans, and all region parameters will be replaced with `ty::ReStatic`. */
#[deriving(Clone, Eq, IterBytes)]
pub enum RegionSubsts {
ErasedRegions,
@ -701,8 +703,8 @@ pub enum type_err {
terr_regions_does_not_outlive(Region, Region),
terr_regions_not_same(Region, Region),
terr_regions_no_overlap(Region, Region),
terr_regions_insufficiently_polymorphic(bound_region, Region),
terr_regions_overly_polymorphic(bound_region, Region),
terr_regions_insufficiently_polymorphic(BoundRegion, Region),
terr_regions_overly_polymorphic(BoundRegion, Region),
terr_vstores_differ(terr_vstore_kind, expected_found<vstore>),
terr_trait_stores_differ(terr_vstore_kind, expected_found<TraitStore>),
terr_in_field(@type_err, ast::Ident),
@ -778,7 +780,7 @@ pub enum InferTy {
#[deriving(Clone, Encodable, Decodable, IterBytes, ToStr)]
pub enum InferRegion {
ReVar(RegionVid),
ReSkolemized(uint, bound_region)
ReSkolemized(uint, BoundRegion)
}
impl cmp::Eq for InferRegion {
@ -1043,7 +1045,7 @@ pub fn mk_t(cx: ctxt, st: sty) -> t {
fn rflags(r: Region) -> uint {
(has_regions as uint) | {
match r {
ty::re_infer(_) => needs_infer as uint,
ty::ReInfer(_) => needs_infer as uint,
_ => 0u
}
}
@ -2148,7 +2150,7 @@ pub fn type_contents(cx: ctxt, ty: t) -> TypeContents {
ast::MutMutable => TC::ReachesMutable | TC::OwnsAffine,
ast::MutImmutable => TC::None,
};
b | (TC::ReachesBorrowed).when(region != ty::re_static)
b | (TC::ReachesBorrowed).when(region != ty::ReStatic)
}
fn closure_contents(cx: ctxt, cty: &ClosureTy) -> TypeContents {
@ -4220,12 +4222,12 @@ pub fn normalize_ty(cx: ctxt, t: t) -> t {
fn fold_vstore(&mut self, vstore: vstore) -> vstore {
match vstore {
vstore_fixed(*) | vstore_uniq | vstore_box => vstore,
vstore_slice(_) => vstore_slice(re_static)
vstore_slice(_) => vstore_slice(ReStatic)
}
}
fn fold_region(&mut self, _: ty::Region) -> ty::Region {
ty::re_static
ty::ReStatic
}
fn fold_substs(&mut self,
@ -4564,10 +4566,16 @@ pub fn hash_crate_independent(tcx: ctxt, t: t, local_hash: @str) -> u64 {
let mut hash = SipState::new(0, 0);
let region = |_hash: &mut SipState, r: Region| {
match r {
re_static => {}
ReStatic => {}
re_empty | re_bound(*) | re_free(*) | re_scope(*) | re_infer(*) =>
ReEmpty |
ReEarlyBound(*) |
ReLateBound(*) |
ReFree(*) |
ReStatic(*) |
ReInfer(*) => {
tcx.sess.bug("non-static region found when hashing a type")
}
}
};
let vstore = |hash: &mut SipState, v: vstore| {
@ -4751,9 +4759,9 @@ pub fn construct_parameter_environment(
// map bound 'a => free 'a
let region_params = item_region_params.iter().
map(|r| ty::re_free(ty::FreeRegion {
map(|r| ty::ReFree(ty::FreeRegion {
scope_id: free_id,
bound_region: ty::br_named(r.def_id, r.ident)})).
bound_region: ty::BrNamed(r.def_id, r.ident)})).
collect();
let free_substs = substs {

28
src/librustc/middle/typeck/astconv.rs
View File

@ -87,23 +87,23 @@ pub fn ast_region_to_region(
}
Some(&ast::DefStaticRegion) => {
ty::re_static
ty::ReStatic
}
Some(&ast::DefFnBoundRegion(binder_id, _, id)) => {
ty::re_fn_bound(binder_id, ty::br_named(ast_util::local_def(id),
lifetime.ident))
Some(&ast::DefLateBoundRegion(binder_id, _, id)) => {
ty::ReLateBound(binder_id, ty::BrNamed(ast_util::local_def(id),
lifetime.ident))
}
Some(&ast::DefTypeBoundRegion(index, id)) => {
ty::re_type_bound(id, index, lifetime.ident)
Some(&ast::DefEarlyBoundRegion(index, id)) => {
ty::ReEarlyBound(id, index, lifetime.ident)
}
Some(&ast::DefFreeRegion(scope_id, id)) => {
ty::re_free(ty::FreeRegion {
ty::ReFree(ty::FreeRegion {
scope_id: scope_id,
bound_region: ty::br_named(ast_util::local_def(id),
lifetime.ident)
bound_region: ty::BrNamed(ast_util::local_def(id),
lifetime.ident)
})
}
};
@ -133,7 +133,7 @@ pub fn opt_ast_region_to_region<AC:AstConv,RS:RegionScope>(
debug!("optional region in illegal location");
this.tcx().sess.span_err(
default_span, "missing lifetime specifier");
ty::re_static
ty::ReStatic
}
Some(rs) => {
@ -190,7 +190,7 @@ fn ast_path_substs<AC:AstConv,RS:RegionScope>(
match anon_regions {
Some(v) => opt_vec::from(v),
None => opt_vec::from(vec::from_fn(expected_num_region_params,
|_| ty::re_static)) // hokey
|_| ty::ReStatic)) // hokey
}
};
@ -431,7 +431,7 @@ pub fn ast_ty_to_ty<AC:AstConv, RS:RegionScope>(
let bounds = conv_builtin_bounds(this.tcx(), &f.bounds, match f.sigil {
// Use corresponding trait store to figure out default bounds
// if none were specified.
ast::BorrowedSigil => ty::RegionTraitStore(ty::re_empty), // dummy region
ast::BorrowedSigil => ty::RegionTraitStore(ty::ReEmpty), // dummy region
ast::OwnedSigil => ty::UniqTraitStore,
ast::ManagedSigil => ty::BoxTraitStore,
});
@ -713,7 +713,7 @@ pub fn ty_of_closure<AC:AstConv,RS:RegionScope>(
ast::OwnedSigil | ast::ManagedSigil => {
// @fn(), ~fn() default to static as the bound
// on their upvars:
ty::re_static
ty::ReStatic
}
ast::BorrowedSigil => {
// &fn() defaults as normal for an omitted lifetime:
@ -803,7 +803,7 @@ fn conv_builtin_bounds(tcx: ty::ctxt, ast_bounds: &Option<OptVec<ast::TyParamBou
// @Trait is sugar for @Trait:'static.
// &'static Trait is sugar for &'static Trait:'static.
(&None, ty::BoxTraitStore) |
(&None, ty::RegionTraitStore(ty::re_static)) => {
(&None, ty::RegionTraitStore(ty::ReStatic)) => {
let mut set = ty::EmptyBuiltinBounds(); set.add(ty::BoundStatic); set
}
// &'r Trait is sugar for &'r Trait:<no-bounds>.

26
src/librustc/middle/typeck/check/mod.rs
View File

@ -438,7 +438,7 @@ pub fn check_fn(ccx: @mut CrateCtxt,
let (_, opt_self_ty, fn_sig) =
replace_bound_regions_in_fn_sig(
tcx, opt_self_ty, fn_sig,
|br| ty::re_free(ty::FreeRegion {scope_id: body.id,
|br| ty::ReFree(ty::FreeRegion {scope_id: body.id,
bound_region: br}));
let opt_self_info =
opt_self_info.map(
@ -931,9 +931,9 @@ pub fn compare_impl_method(tcx: ty::ctxt,
collect();
let dummy_impl_regions: OptVec<ty::Region> =
impl_generics.region_param_defs.iter().
map(|l| ty::re_free(ty::FreeRegion {
map(|l| ty::ReFree(ty::FreeRegion {
scope_id: impl_m_body_id,
bound_region: ty::br_named(l.def_id, l.ident)})).
bound_region: ty::BrNamed(l.def_id, l.ident)})).
collect();
let dummy_substs = ty::substs {
tps: vec::append(dummy_impl_tps, dummy_method_tps),
@ -1090,7 +1090,7 @@ impl FnCtxt {
}
pub fn block_region(&self) -> ty::Region {
ty::re_scope(self.region_lb)
ty::ReScope(self.region_lb)
}
#[inline]
@ -1357,10 +1357,10 @@ pub fn check_lit(fcx: @mut FnCtxt, lit: @ast::lit) -> ty::t {
let tcx = fcx.ccx.tcx;
match lit.node {
ast::lit_str(*) => ty::mk_estr(tcx, ty::vstore_slice(ty::re_static)),
ast::lit_str(*) => ty::mk_estr(tcx, ty::vstore_slice(ty::ReStatic)),
ast::lit_binary(*) => {
ty::mk_evec(tcx, ty::mt{ ty: ty::mk_u8(), mutbl: ast::MutImmutable },
ty::vstore_slice(ty::re_static))
ty::vstore_slice(ty::ReStatic))
}
ast::lit_char(_) => ty::mk_char(),
ast::lit_int(_, t) => ty::mk_mach_int(t),
@ -3925,19 +3925,19 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) {
//We only care about the operation here
match split[1] {
"cxchg" => (0, ~[ty::mk_mut_rptr(tcx,
ty::re_fn_bound(it.id, ty::br_anon(0)),
ty::ReLateBound(it.id, ty::BrAnon(0)),
ty::mk_int()),
ty::mk_int(),
ty::mk_int()
], ty::mk_int()),
"load" => (0,
~[
ty::mk_imm_rptr(tcx, ty::re_fn_bound(it.id, ty::br_anon(0)), ty::mk_int())
ty::mk_imm_rptr(tcx, ty::ReLateBound(it.id, ty::BrAnon(0)), ty::mk_int())
],
ty::mk_int()),
"store" => (0,
~[
ty::mk_mut_rptr(tcx, ty::re_fn_bound(it.id, ty::br_anon(0)), ty::mk_int()),
ty::mk_mut_rptr(tcx, ty::ReLateBound(it.id, ty::BrAnon(0)), ty::mk_int()),
ty::mk_int()
],
ty::mk_nil()),
@ -3945,7 +3945,7 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) {
"xchg" | "xadd" | "xsub" | "and" | "nand" | "or" | "xor" | "max" |
"min" | "umax" | "umin" => {
(0, ~[ty::mk_mut_rptr(tcx,
ty::re_fn_bound(it.id, ty::br_anon(0)),
ty::ReLateBound(it.id, ty::BrAnon(0)),
ty::mk_int()), ty::mk_int() ], ty::mk_int())
}
"fence" => {
@ -3971,7 +3971,7 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) {
"move_val" | "move_val_init" => {
(1u,
~[
ty::mk_mut_rptr(tcx, ty::re_fn_bound(it.id, ty::br_anon(0)), param(ccx, 0)),
ty::mk_mut_rptr(tcx, ty::ReLateBound(it.id, ty::BrAnon(0)), param(ccx, 0)),
param(ccx, 0u)
],
ty::mk_nil())
@ -3983,7 +3983,7 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) {
"atomic_xchg_rel" | "atomic_xadd_rel" | "atomic_xsub_rel" => {
(0,
~[
ty::mk_mut_rptr(tcx, ty::re_fn_bound(it.id, ty::br_anon(0)), ty::mk_int()),
ty::mk_mut_rptr(tcx, ty::ReLateBound(it.id, ty::BrAnon(0)), ty::mk_int()),
ty::mk_int()
],
ty::mk_int())
@ -4006,7 +4006,7 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) {
Ok(t) => t,
Err(s) => { tcx.sess.span_fatal(it.span, s); }
};
let region = ty::re_fn_bound(it.id, ty::br_anon(0));
let region = ty::ReLateBound(it.id, ty::BrAnon(0));
let visitor_object_ty = match ty::visitor_object_ty(tcx, region) {
Ok((_, vot)) => vot,
Err(s) => { tcx.sess.span_fatal(it.span, s); }

20
src/librustc/middle/typeck/check/regionck.rs
View File

@ -29,7 +29,7 @@ this point a bit better.
use middle::freevars::get_freevars;
use middle::ty::{re_scope};
use middle::ty::{ReScope};
use middle::ty;
use middle::typeck::check::FnCtxt;
use middle::typeck::check::regionmanip::relate_nested_regions;
@ -64,7 +64,7 @@ fn encl_region_of_def(fcx: @mut FnCtxt, def: ast::Def) -> ty::Region {
DefUpvar(_, subdef, closure_id, body_id) => {
match ty::ty_closure_sigil(fcx.node_ty(closure_id)) {
BorrowedSigil => encl_region_of_def(fcx, *subdef),
ManagedSigil | OwnedSigil => re_scope(body_id)
ManagedSigil | OwnedSigil => ReScope(body_id)
}
}
_ => {
@ -317,7 +317,7 @@ fn visit_expr(rcx: &mut Rcx, expr: @ast::Expr) {
//
// FIXME(#6268) remove to support nested method calls
constrain_regions_in_type_of_node(
rcx, expr.id, ty::re_scope(expr.id),
rcx, expr.id, ty::ReScope(expr.id),
infer::AutoBorrow(expr.span));
}
}
@ -416,7 +416,7 @@ fn visit_expr(rcx: &mut Rcx, expr: @ast::Expr) {
//
// FIXME(#6268) nested method calls requires that this rule change
let ty0 = rcx.resolve_node_type(expr.id);
constrain_regions_in_type(rcx, ty::re_scope(expr.id),
constrain_regions_in_type(rcx, ty::ReScope(expr.id),
infer::AddrOf(expr.span), ty0);
visit::walk_expr(rcx, expr, ());
}
@ -474,7 +474,7 @@ fn check_expr_fn_block(rcx: &mut Rcx,
// (since otherwise that would require
// infinite stack).
constrain_free_variables(rcx, region, expr);
let repeating_scope = ty::re_scope(rcx.repeating_scope);
let repeating_scope = ty::ReScope(rcx.repeating_scope);
rcx.fcx.mk_subr(true, infer::InfStackClosure(expr.span),
region, repeating_scope);
}
@ -500,7 +500,7 @@ fn constrain_callee(rcx: &mut Rcx,
call_expr: @ast::Expr,
callee_expr: @ast::Expr)
{
let call_region = ty::re_scope(call_expr.id);
let call_region = ty::ReScope(call_expr.id);
let callee_ty = rcx.resolve_node_type(callee_id);
match ty::get(callee_ty).sty {
@ -555,7 +555,7 @@ fn constrain_call(rcx: &mut Rcx,
//
// FIXME(#6268) to support nested method calls, should be callee_id
let callee_scope = call_expr.id;
let callee_region = ty::re_scope(callee_scope);
let callee_region = ty::ReScope(callee_scope);
for &arg_expr in arg_exprs.iter() {
debug!("Argument");
@ -604,7 +604,7 @@ fn constrain_derefs(rcx: &mut Rcx,
* the deref expr.
*/
let tcx = rcx.fcx.tcx();
let r_deref_expr = ty::re_scope(deref_expr.id);
let r_deref_expr = ty::ReScope(deref_expr.id);
for i in range(0u, derefs) {
debug!("constrain_derefs(deref_expr=?, derefd_ty={}, derefs={:?}/{:?}",
rcx.fcx.infcx().ty_to_str(derefd_ty),
@ -650,7 +650,7 @@ fn constrain_index(rcx: &mut Rcx,
debug!("constrain_index(index_expr=?, indexed_ty={}",
rcx.fcx.infcx().ty_to_str(indexed_ty));
let r_index_expr = ty::re_scope(index_expr.id);
let r_index_expr = ty::ReScope(index_expr.id);
match ty::get(indexed_ty).sty {
ty::ty_estr(ty::vstore_slice(r_ptr)) |
ty::ty_evec(_, ty::vstore_slice(r_ptr)) => {
@ -912,7 +912,7 @@ pub mod guarantor {
let expr_cat = categorize(rcx, expr);
debug!("guarantor::for_by_ref(expr={:?}, callee_scope={:?}) category={:?}",
expr.id, callee_scope, expr_cat);
let minimum_lifetime = ty::re_scope(callee_scope);
let minimum_lifetime = ty::ReScope(callee_scope);
for guarantor in expr_cat.guarantor.iter() {
mk_subregion_due_to_derefence(rcx, expr.span,
minimum_lifetime, *guarantor);

8
src/librustc/middle/typeck/check/regionmanip.rs
View File

@ -23,8 +23,8 @@ pub fn replace_bound_regions_in_fn_sig(
tcx: ty::ctxt,
opt_self_ty: Option<ty::t>,
fn_sig: &ty::FnSig,
mapf: &fn(ty::bound_region) -> ty::Region)
-> (HashMap<ty::bound_region,ty::Region>, Option<ty::t>, ty::FnSig)
mapf: &fn(ty::BoundRegion) -> ty::Region)
-> (HashMap<ty::BoundRegion,ty::Region>, Option<ty::t>, ty::FnSig)
{
debug!("replace_bound_regions_in_fn_sig(self_ty={}, fn_sig={})",
opt_self_ty.repr(tcx),
@ -35,7 +35,7 @@ pub fn replace_bound_regions_in_fn_sig(
let mut f = ty_fold::RegionFolder::regions(tcx, |r| {
debug!("region r={}", r.to_str());
match r {
ty::re_fn_bound(s, br) if s == fn_sig.binder_id => {
ty::ReLateBound(s, br) if s == fn_sig.binder_id => {
*map.find_or_insert_with(br, |_| mapf(br))
}
_ => r
@ -175,7 +175,7 @@ pub fn relate_free_regions(
debug!("relate_free_regions(t={})", ppaux::ty_to_str(tcx, t));
relate_nested_regions(tcx, None, t, |a, b| {
match (&a, &b) {
(&ty::re_free(free_a), &ty::re_free(free_b)) => {
(&ty::ReFree(free_a), &ty::ReFree(free_b)) => {
tcx.region_maps.relate_free_regions(free_a, free_b);
}
_ => {}

2
src/librustc/middle/typeck/check/vtable.rs
View File

@ -480,7 +480,7 @@ fn fixup_substs(vcx: &VtableContext,
// use a dummy type just to package up the substs that need fixing up
let t = ty::mk_trait(tcx,
id, substs,
ty::RegionTraitStore(ty::re_static),
ty::RegionTraitStore(ty::ReStatic),
ast::MutImmutable,
ty::EmptyBuiltinBounds());
do fixup_ty(vcx, location_info, t, is_early).map |t_f| {

6
src/librustc/middle/typeck/collect.rs
View File

@ -282,8 +282,8 @@ pub fn ensure_trait_methods(ccx: &CrateCtxt,
// Convert the regions 'a, 'b, 'c defined on the trait into
// bound regions on the fn.
let rps_from_trait = trait_ty_generics.region_param_defs.iter().map(|d| {
ty::re_fn_bound(m.fty.sig.binder_id,
ty::br_named(d.def_id, d.ident))
ty::ReLateBound(m.fty.sig.binder_id,
ty::BrNamed(d.def_id, d.ident))
}).collect();
// build up the substitution from
@ -964,7 +964,7 @@ pub fn mk_item_substs(ccx: &CrateCtxt,
let regions: OptVec<ty::Region> =
ty_generics.region_param_defs.iter().enumerate().map(
|(i, l)| ty::re_type_bound(l.def_id.node, i, l.ident)).collect();
|(i, l)| ty::ReEarlyBound(l.def_id.node, i, l.ident)).collect();
substs {regions: ty::NonerasedRegions(regions),
self_ty: self_ty,

6
src/librustc/middle/typeck/infer/glb.rs
View File

@ -161,7 +161,7 @@ impl Combine for Glb {
snapshot: uint,
new_vars: &[RegionVid],
new_binder_id: NodeId,
a_map: &HashMap<ty::bound_region, ty::Region>,
a_map: &HashMap<ty::BoundRegion, ty::Region>,
a_vars: &[RegionVid],
b_vars: &[RegionVid],
r0: ty::Region) -> ty::Region {
@ -228,13 +228,13 @@ impl Combine for Glb {
}
fn rev_lookup(this: &Glb,
a_map: &HashMap<ty::bound_region, ty::Region>,
a_map: &HashMap<ty::BoundRegion, ty::Region>,
new_binder_id: NodeId,
r: ty::Region) -> ty::Region
{
for (a_br, a_r) in a_map.iter() {
if *a_r == r {
return ty::re_fn_bound(new_binder_id, *a_br);
return ty::ReLateBound(new_binder_id, *a_br);
}
}
this.infcx.tcx.sess.span_bug(

6
src/librustc/middle/typeck/infer/lattice.rs
View File

@ -522,10 +522,10 @@ pub fn lattice_var_and_t<L:LatticeDir + Combine,
// fn types
pub fn var_ids<T:Combine>(this: &T,
map: &HashMap<ty::bound_region, ty::Region>)
map: &HashMap<ty::BoundRegion, ty::Region>)
-> ~[RegionVid] {
map.iter().map(|(_, r)| match *r {
ty::re_infer(ty::ReVar(r)) => { r }
ty::ReInfer(ty::ReVar(r)) => { r }
r => {
this.infcx().tcx.sess.span_bug(
this.trace().origin.span(),
@ -536,7 +536,7 @@ pub fn var_ids<T:Combine>(this: &T,
pub fn is_var_in_set(new_vars: &[RegionVid], r: ty::Region) -> bool {
match r {
ty::re_infer(ty::ReVar(ref v)) => new_vars.iter().any(|x| x == v),
ty::ReInfer(ty::ReVar(ref v)) => new_vars.iter().any(|x| x == v),
_ => false
}
}

4
src/librustc/middle/typeck/infer/lub.rs
View File

@ -149,7 +149,7 @@ impl Combine for Lub {
snapshot: uint,
new_vars: &[RegionVid],
new_scope: NodeId,
a_map: &HashMap<ty::bound_region, ty::Region>,
a_map: &HashMap<ty::BoundRegion, ty::Region>,
r0: ty::Region)
-> ty::Region {
// Regions that pre-dated the LUB computation stay as they are.
@ -182,7 +182,7 @@ impl Combine for Lub {
debug!("generalize_region(r0={:?}): \
replacing with {:?}, tainted={:?}",
r0, *a_br, tainted);
return ty::re_fn_bound(new_scope, *a_br);
return ty::ReLateBound(new_scope, *a_br);
}
}

16
src/librustc/middle/typeck/infer/mod.rs
View File

@ -216,11 +216,11 @@ pub enum RegionVariableOrigin {
// Region variables created for bound regions
// in a function or method that is called
BoundRegionInFnCall(Span, ty::bound_region),
BoundRegionInFnCall(Span, ty::BoundRegion),
// Region variables created for bound regions
// when doing subtyping/lub/glb computations
BoundRegionInFnType(Span, ty::bound_region),
BoundRegionInFnType(Span, ty::BoundRegion),
BoundRegionInTypeOrImpl(Span),
@ -638,7 +638,7 @@ impl InferCtxt {
}
pub fn next_region_var(&mut self, origin: RegionVariableOrigin) -> ty::Region {
ty::re_infer(ty::ReVar(self.region_vars.new_region_var(origin)))
ty::ReInfer(ty::ReVar(self.region_vars.new_region_var(origin)))
}
pub fn next_region_vars(&mut self,
@ -798,7 +798,7 @@ impl InferCtxt {
trace: TypeTrace,
fsig: &ty::FnSig)
-> (ty::FnSig,
HashMap<ty::bound_region,
HashMap<ty::BoundRegion,
ty::Region>) {
let (map, _, fn_sig) =
replace_bound_regions_in_fn_sig(self.tcx, None, fsig, |br| {
@ -933,13 +933,13 @@ impl Repr for RegionVariableOrigin {
AddrOfSlice(a) => format!("AddrOfSlice({})", a.repr(tcx)),
Autoref(a) => format!("Autoref({})", a.repr(tcx)),
Coercion(a) => format!("Coercion({})", a.repr(tcx)),
BoundRegionInFnCall(a, b) => format!("BoundRegionInFnCall({},{})",
BoundRegionInFnCall(a, b) => format!("bound_regionInFnCall({},{})",
a.repr(tcx), b.repr(tcx)),
BoundRegionInFnType(a, b) => format!("BoundRegionInFnType({},{})",
BoundRegionInFnType(a, b) => format!("bound_regionInFnType({},{})",
a.repr(tcx), b.repr(tcx)),
BoundRegionInTypeOrImpl(a) => format!("BoundRegionInTypeOrImpl({})",
BoundRegionInTypeOrImpl(a) => format!("bound_regionInTypeOrImpl({})",
a.repr(tcx)),
BoundRegionInCoherence => format!("BoundRegionInCoherence"),
BoundRegionInCoherence => format!("bound_regionInCoherence"),
}
}
}

140
src/librustc/middle/typeck/infer/region_inference/mod.rs
View File

@ -13,9 +13,9 @@
use middle::ty;
use middle::ty::{FreeRegion, Region, RegionVid};
use middle::ty::{re_empty, re_static, re_infer, re_free, re_type_bound,
re_fn_bound};
use middle::ty::{re_scope, ReVar, ReSkolemized, br_fresh};
use middle::ty::{ReEmpty, ReStatic, ReInfer, ReFree, ReEarlyBound,
ReLateBound};
use middle::ty::{ReScope, ReVar, ReSkolemized, BrFresh};
use middle::typeck::infer::cres;
use middle::typeck::infer::{RegionVariableOrigin, SubregionOrigin};
use middle::typeck::infer;
@ -187,10 +187,10 @@ impl RegionVarBindings {
return vid;
}
pub fn new_skolemized(&mut self, br: ty::bound_region) -> Region {
pub fn new_skolemized(&mut self, br: ty::BoundRegion) -> Region {
let sc = self.skolemization_count;
self.skolemization_count += 1;
re_infer(ReSkolemized(sc, br))
ReInfer(ReSkolemized(sc, br))
}
pub fn new_bound(&mut self, binder_id: ast::NodeId) -> Region {
@ -219,7 +219,7 @@ impl RegionVarBindings {
self.tcx.sess.bug("Rollover in RegionInference new_bound()");
}
re_fn_bound(binder_id, br_fresh(sc))
ReLateBound(binder_id, BrFresh(sc))
}
pub fn add_constraint(&mut self,
@ -246,23 +246,23 @@ impl RegionVarBindings {
debug!("RegionVarBindings: make_subregion({:?}, {:?})", sub, sup);
match (sub, sup) {
(re_type_bound(*), _) |
(re_fn_bound(*), _) |
(_, re_type_bound(*)) |
(_, re_fn_bound(*)) => {
(ReEarlyBound(*), _) |
(ReLateBound(*), _) |
(_, ReEarlyBound(*)) |
(_, ReLateBound(*)) => {
self.tcx.sess.span_bug(
origin.span(),
format!("Cannot relate bound region: {} <= {}",
sub.repr(self.tcx),
sup.repr(self.tcx)));
}
(re_infer(ReVar(sub_id)), re_infer(ReVar(sup_id))) => {
(ReInfer(ReVar(sub_id)), ReInfer(ReVar(sup_id))) => {
self.add_constraint(ConstrainVarSubVar(sub_id, sup_id), origin);
}
(r, re_infer(ReVar(sup_id))) => {
(r, ReInfer(ReVar(sup_id))) => {
self.add_constraint(ConstrainRegSubVar(r, sup_id), origin);
}
(re_infer(ReVar(sub_id)), r) => {
(ReInfer(ReVar(sub_id)), r) => {
self.add_constraint(ConstrainVarSubReg(sub_id, r), origin);
}
_ => {
@ -281,8 +281,8 @@ impl RegionVarBindings {
debug!("RegionVarBindings: lub_regions({:?}, {:?})", a, b);
match (a, b) {
(re_static, _) | (_, re_static) => {
re_static // nothing lives longer than static
(ReStatic, _) | (_, ReStatic) => {
ReStatic // nothing lives longer than static
}
_ => {
@ -304,7 +304,7 @@ impl RegionVarBindings {
debug!("RegionVarBindings: glb_regions({:?}, {:?})", a, b);
match (a, b) {
(re_static, r) | (r, re_static) => {
(ReStatic, r) | (r, ReStatic) => {
// static lives longer than everything else
r
}
@ -333,13 +333,13 @@ impl RegionVarBindings {
Value(r) => r,
NoValue => {
// No constraints, return ty::re_empty
re_empty
// No constraints, return ty::ReEmpty
ReEmpty
}
ErrorValue => {
// An error that has previously been reported.
re_static
ReStatic
}
}
}
@ -366,7 +366,7 @@ impl RegionVarBindings {
let vars = TwoRegions { a: a, b: b };
match self.combine_map(t).find(&vars) {
Some(&c) => {
return re_infer(ReVar(c));
return ReInfer(ReVar(c));
}
None => {}
}
@ -375,10 +375,10 @@ impl RegionVarBindings {
if self.in_snapshot() {
self.undo_log.push(AddCombination(t, vars));
}
relate(self, a, re_infer(ReVar(c)));
relate(self, b, re_infer(ReVar(c)));
relate(self, a, ReInfer(ReVar(c)));
relate(self, b, ReInfer(ReVar(c)));
debug!("combine_vars() c={:?}", c);
re_infer(ReVar(c))
ReInfer(ReVar(c))
}
pub fn vars_created_since_snapshot(&mut self, snapshot: uint)
@ -421,14 +421,14 @@ impl RegionVarBindings {
// nb: can't use uint::range() here as we move result_set
let regs = match self.undo_log[undo_index] {
AddConstraint(ConstrainVarSubVar(ref a, ref b)) => {
Some((re_infer(ReVar(*a)),
re_infer(ReVar(*b))))
Some((ReInfer(ReVar(*a)),
ReInfer(ReVar(*b))))
}
AddConstraint(ConstrainRegSubVar(ref a, ref b)) => {
Some((*a, re_infer(ReVar(*b))))
Some((*a, ReInfer(ReVar(*b))))
}
AddConstraint(ConstrainVarSubReg(ref a, ref b)) => {
Some((re_infer(ReVar(*a)), *b))
Some((ReInfer(ReVar(*a)), *b))
}
AddConstraint(ConstrainRegSubReg(a, b)) => {
Some((a, b))
@ -495,33 +495,33 @@ impl RegionVarBindings {
fn lub_concrete_regions(&self, a: Region, b: Region) -> Region {
match (a, b) {
(re_fn_bound(*), _) |
(_, re_fn_bound(*)) |
(re_type_bound(*), _) |
(_, re_type_bound(*)) => {
(ReLateBound(*), _) |
(_, ReLateBound(*)) |
(ReEarlyBound(*), _) |
(_, ReEarlyBound(*)) => {
self.tcx.sess.bug(
format!("Cannot relate bound region: LUB({}, {})",
a.repr(self.tcx),
b.repr(self.tcx)));
}
(re_static, _) | (_, re_static) => {
re_static // nothing lives longer than static
(ReStatic, _) | (_, ReStatic) => {
ReStatic // nothing lives longer than static
}
(re_empty, r) | (r, re_empty) => {
(ReEmpty, r) | (r, ReEmpty) => {
r // everything lives longer than empty
}
(re_infer(ReVar(v_id)), _) | (_, re_infer(ReVar(v_id))) => {
(ReInfer(ReVar(v_id)), _) | (_, ReInfer(ReVar(v_id))) => {
self.tcx.sess.span_bug(
self.var_origins[v_id.to_uint()].span(),
format!("lub_concrete_regions invoked with \
non-concrete regions: {:?}, {:?}", a, b));
}
(f @ re_free(ref fr), re_scope(s_id)) |
(re_scope(s_id), f @ re_free(ref fr)) => {
(f @ ReFree(ref fr), ReScope(s_id)) |
(ReScope(s_id), f @ ReFree(ref fr)) => {
// A "free" region can be interpreted as "some region
// at least as big as the block fr.scope_id". So, we can
// reasonably compare free regions and scopes:
@ -534,30 +534,30 @@ impl RegionVarBindings {
// otherwise, we don't know what the free region is,
// so we must conservatively say the LUB is static:
_ => re_static
_ => ReStatic
}
}
(re_scope(a_id), re_scope(b_id)) => {
(ReScope(a_id), ReScope(b_id)) => {
// The region corresponding to an outer block is a
// subtype of the region corresponding to an inner
// block.
let rm = self.tcx.region_maps;
match rm.nearest_common_ancestor(a_id, b_id) {
Some(r_id) => re_scope(r_id),
_ => re_static
Some(r_id) => ReScope(r_id),
_ => ReStatic
}
}
(re_free(ref a_fr), re_free(ref b_fr)) => {
(ReFree(ref a_fr), ReFree(ref b_fr)) => {
self.lub_free_regions(a_fr, b_fr)
}
// For these types, we cannot define any additional
// relationship:
(re_infer(ReSkolemized(*)), _) |
(_, re_infer(ReSkolemized(*))) => {
if a == b {a} else {re_static}
(ReInfer(ReSkolemized(*)), _) |
(_, ReInfer(ReSkolemized(*))) => {
if a == b {a} else {ReStatic}
}
}
}
@ -575,7 +575,7 @@ impl RegionVarBindings {
return match a.cmp(b) {
Less => helper(self, a, b),
Greater => helper(self, b, a),
Equal => ty::re_free(*a)
Equal => ty::ReFree(*a)
};
fn helper(this: &RegionVarBindings,
@ -584,11 +584,11 @@ impl RegionVarBindings {
{
let rm = this.tcx.region_maps;
if rm.sub_free_region(*a, *b) {
ty::re_free(*b)
ty::ReFree(*b)
} else if rm.sub_free_region(*b, *a) {
ty::re_free(*a)
ty::ReFree(*a)
} else {
ty::re_static
ty::ReStatic
}
}
}
@ -599,36 +599,36 @@ impl RegionVarBindings {
-> cres<Region> {
debug!("glb_concrete_regions({:?}, {:?})", a, b);
match (a, b) {
(re_fn_bound(*), _) |
(_, re_fn_bound(*)) |
(re_type_bound(*), _) |
(_, re_type_bound(*)) => {
(ReLateBound(*), _) |
(_, ReLateBound(*)) |
(ReEarlyBound(*), _) |
(_, ReEarlyBound(*)) => {
self.tcx.sess.bug(
format!("Cannot relate bound region: GLB({}, {})",
a.repr(self.tcx),
b.repr(self.tcx)));
}
(re_static, r) | (r, re_static) => {
(ReStatic, r) | (r, ReStatic) => {
// static lives longer than everything else
Ok(r)
}
(re_empty, _) | (_, re_empty) => {
(ReEmpty, _) | (_, ReEmpty) => {
// nothing lives shorter than everything else
Ok(re_empty)
Ok(ReEmpty)
}
(re_infer(ReVar(v_id)), _) |
(_, re_infer(ReVar(v_id))) => {
(ReInfer(ReVar(v_id)), _) |
(_, ReInfer(ReVar(v_id))) => {
self.tcx.sess.span_bug(
self.var_origins[v_id.to_uint()].span(),
format!("glb_concrete_regions invoked with \
non-concrete regions: {:?}, {:?}", a, b));
}
(re_free(ref fr), s @ re_scope(s_id)) |
(s @ re_scope(s_id), re_free(ref fr)) => {
(ReFree(ref fr), s @ ReScope(s_id)) |
(s @ ReScope(s_id), ReFree(ref fr)) => {
// Free region is something "at least as big as
// `fr.scope_id`." If we find that the scope `fr.scope_id` is bigger
// than the scope `s_id`, then we can say that the GLB
@ -641,18 +641,18 @@ impl RegionVarBindings {
}
}
(re_scope(a_id), re_scope(b_id)) => {
(ReScope(a_id), ReScope(b_id)) => {
self.intersect_scopes(a, b, a_id, b_id)
}
(re_free(ref a_fr), re_free(ref b_fr)) => {
(ReFree(ref a_fr), ReFree(ref b_fr)) => {
self.glb_free_regions(a_fr, b_fr)
}
// For these types, we cannot define any additional
// relationship:
(re_infer(ReSkolemized(*)), _) |
(_, re_infer(ReSkolemized(*))) => {
(ReInfer(ReSkolemized(*)), _) |
(_, ReInfer(ReSkolemized(*))) => {
if a == b {
Ok(a)
} else {
@ -675,7 +675,7 @@ impl RegionVarBindings {
return match a.cmp(b) {
Less => helper(self, a, b),
Greater => helper(self, b, a),
Equal => Ok(ty::re_free(*a))
Equal => Ok(ty::ReFree(*a))
};
fn helper(this: &RegionVarBindings,
@ -684,11 +684,11 @@ impl RegionVarBindings {
{
let rm = this.tcx.region_maps;
if rm.sub_free_region(*a, *b) {
Ok(ty::re_free(*a))
Ok(ty::ReFree(*a))
} else if rm.sub_free_region(*b, *a) {
Ok(ty::re_free(*b))
Ok(ty::ReFree(*b))
} else {
this.intersect_scopes(ty::re_free(*a), ty::re_free(*b),
this.intersect_scopes(ty::ReFree(*a), ty::ReFree(*b),
a.scope_id, b.scope_id)
}
}
@ -715,8 +715,8 @@ impl RegionVarBindings {
scope_a, scope_b, region_a, region_b);
let rm = self.tcx.region_maps;
match rm.nearest_common_ancestor(scope_a, scope_b) {
Some(r_id) if scope_a == r_id => Ok(re_scope(scope_b)),
Some(r_id) if scope_b == r_id => Ok(re_scope(scope_a)),
Some(r_id) if scope_a == r_id => Ok(ReScope(scope_b)),
Some(r_id) if scope_b == r_id => Ok(ReScope(scope_a)),
_ => Err(ty::terr_regions_no_overlap(region_a, region_b))
}
}

6
src/librustc/middle/typeck/infer/resolve.rs
View File

@ -192,21 +192,21 @@ impl ResolveState {
pub fn resolve_region(&mut self, orig: ty::Region) -> ty::Region {
debug!("Resolve_region({})", orig.inf_str(self.infcx));
match orig {
ty::re_infer(ty::ReVar(rid)) => self.resolve_region_var(rid),
ty::ReInfer(ty::ReVar(rid)) => self.resolve_region_var(rid),
_ => orig
}
}
pub fn resolve_region_var(&mut self, rid: RegionVid) -> ty::Region {
if !self.should(resolve_rvar) {
return ty::re_infer(ty::ReVar(rid));
return ty::ReInfer(ty::ReVar(rid));
}
self.infcx.region_vars.resolve_var(rid)
}
pub fn assert_not_rvar(&mut self, rid: RegionVid, r: ty::Region) {
match r {
ty::re_infer(ty::ReVar(rid2)) => {
ty::ReInfer(ty::ReVar(rid2)) => {
self.err = Some(region_var_bound_by_region_var(rid, rid2));
}
_ => { }

2
src/librustc/middle/typeck/infer/sub.rs
View File

@ -192,7 +192,7 @@ impl Combine for Sub {
// Each skolemized should only be relatable to itself
// or new variables:
match *tainted_region {
ty::re_infer(ty::ReVar(ref vid)) => {
ty::ReInfer(ty::ReVar(ref vid)) => {
if new_vars.iter().any(|x| x == vid) { continue; }
}
_ => {

12
src/librustc/middle/typeck/infer/test.rs
View File

@ -188,7 +188,7 @@ impl Env {
meta: FnMeta {purity: ast::impure_fn,
proto: ast::ProtoBare,
onceness: ast::Many,
region: ty::re_static,
region: ty::ReStatic,
bounds: @~[]},
sig: FnSig {
inputs: inputs,
@ -203,22 +203,22 @@ impl Env {
}
pub fn t_rptr_bound(&self, id: uint) -> ty::t {
ty::mk_imm_rptr(self.tcx, ty::re_bound(ty::br_anon(id)), self.t_int())
ty::mk_imm_rptr(self.tcx, ty::re_bound(ty::BrAnon(id)), self.t_int())
}
pub fn t_rptr_scope(&self, id: ast::node_id) -> ty::t {
ty::mk_imm_rptr(self.tcx, ty::re_scope(id), self.t_int())
ty::mk_imm_rptr(self.tcx, ty::ReScope(id), self.t_int())
}
pub fn t_rptr_free(&self, nid: ast::node_id, id: uint) -> ty::t {
ty::mk_imm_rptr(self.tcx,
ty::re_free(ty::FreeRegion {scope_id: nid,
bound_region: ty::br_anon(id)}),
ty::ReFree(ty::FreeRegion {scope_id: nid,
bound_region: ty::BrAnon(id)}),
self.t_int())
}
pub fn t_rptr_static(&self) -> ty::t {
ty::mk_imm_rptr(self.tcx, ty::re_static, self.t_int())
ty::mk_imm_rptr(self.tcx, ty::ReStatic, self.t_int())
}
pub fn lub() -> Lub { Lub(self.infcx.combine_fields(true, dummy_sp())) }

10
src/librustc/middle/typeck/mod.rs
View File

@ -317,19 +317,19 @@ pub fn require_same_types(
// a list of mapping from in-scope-region-names ("isr") to the
// corresponding ty::Region
pub type isr_alist = @List<(ty::bound_region, ty::Region)>;
pub type isr_alist = @List<(ty::BoundRegion, ty::Region)>;
trait get_and_find_region {
fn get(&self, br: ty::bound_region) -> ty::Region;
fn find(&self, br: ty::bound_region) -> Option<ty::Region>;
fn get(&self, br: ty::BoundRegion) -> ty::Region;
fn find(&self, br: ty::BoundRegion) -> Option<ty::Region>;
}
impl get_and_find_region for isr_alist {
fn get(&self, br: ty::bound_region) -> ty::Region {
fn get(&self, br: ty::BoundRegion) -> ty::Region {
self.find(br).unwrap()
}
fn find(&self, br: ty::bound_region) -> Option<ty::Region> {
fn find(&self, br: ty::BoundRegion) -> Option<ty::Region> {
let mut ret = None;
do list::each(*self) |isr| {
let (isr_br, isr_r) = *isr;

6
src/librustc/middle/typeck/rscope.rs
View File

@ -56,8 +56,8 @@ impl RegionScope for BindingRscope {
-> Option<~[ty::Region]> {
let idx = *self.anon_bindings;
*self.anon_bindings += count;
Some(vec::from_fn(count, |i| ty::re_fn_bound(self.binder_id,
ty::br_anon(idx + i))))
Some(vec::from_fn(count, |i| ty::ReLateBound(self.binder_id,
ty::BrAnon(idx + i))))
}
}
@ -65,5 +65,5 @@ pub fn bound_type_regions(defs: &[ty::RegionParameterDef])
-> OptVec<ty::Region> {
assert!(defs.iter().all(|def| def.def_id.crate == ast::LOCAL_CRATE));
defs.iter().enumerate().map(
|(i, def)| ty::re_type_bound(def.def_id.node, i, def.ident)).collect()
|(i, def)| ty::ReEarlyBound(def.def_id.node, i, def.ident)).collect()
}

10
src/librustc/middle/typeck/variance.rs
View File

@ -613,20 +613,20 @@ impl<'self> ConstraintContext<'self> {
region: ty::Region,
variance: VarianceTermPtr<'self>) {
match region {
ty::re_type_bound(param_id, _, _) => {
ty::ReEarlyBound(param_id, _, _) => {
let index = self.inferred_index(param_id);
self.add_constraint(index, variance);
}
ty::re_static => { }
ty::ReStatic => { }
ty::re_fn_bound(*) => {
ty::ReLateBound(*) => {
// We do not infer variance for region parameters on
// methods or in fn types.
}
ty::re_free(*) | ty::re_scope(*) | ty::re_infer(*) |
ty::re_empty => {
ty::ReFree(*) | ty::ReScope(*) | ty::ReInfer(*) |
ty::ReEmpty => {
// We don't expect to see anything but 'static or bound
// regions when visiting member types or method types.
self.tcx().sess.bug(format!("Unexpected region encountered in \

94
src/librustc/util/ppaux.rs
View File

@ -11,11 +11,11 @@
use metadata::encoder;
use middle::ty::{ReSkolemized, ReVar};
use middle::ty::{bound_region, br_anon, br_named};
use middle::ty::{br_fresh, ctxt, field};
use middle::ty::{BoundRegion, BrAnon, BrNamed};
use middle::ty::{BrFresh, ctxt, field};
use middle::ty::{mt, t, param_ty};
use middle::ty::{re_free, re_scope, re_infer, re_static, Region,
re_empty};
use middle::ty::{ReFree, ReScope, ReInfer, ReStatic, Region,
ReEmpty};
use middle::ty::{ty_bool, ty_char, ty_bot, ty_box, ty_struct, ty_enum};
use middle::ty::{ty_err, ty_estr, ty_evec, ty_float, ty_bare_fn, ty_closure};
use middle::ty::{ty_nil, ty_opaque_box, ty_opaque_closure_ptr, ty_param};
@ -71,7 +71,7 @@ pub fn explain_region(cx: ctxt, region: ty::Region) -> ~str {
pub fn explain_region_and_span(cx: ctxt, region: ty::Region)
-> (~str, Option<Span>) {
return match region {
re_scope(node_id) => {
ReScope(node_id) => {
match cx.items.find(&node_id) {
Some(&ast_map::node_block(ref blk)) => {
explain_span(cx, "block", blk.span)
@ -104,11 +104,11 @@ pub fn explain_region_and_span(cx: ctxt, region: ty::Region)
}
}
re_free(ref fr) => {
ReFree(ref fr) => {
let prefix = match fr.bound_region {
br_anon(idx) => format!("the anonymous lifetime \\#{} defined on",
BrAnon(idx) => format!("the anonymous lifetime \\#{} defined on",
idx + 1),
br_fresh(_) => format!("an anonymous lifetime defined on"),
BrFresh(_) => format!("an anonymous lifetime defined on"),
_ => format!("the lifetime {} as defined on",
bound_region_ptr_to_str(cx, fr.bound_region))
};
@ -130,13 +130,13 @@ pub fn explain_region_and_span(cx: ctxt, region: ty::Region)
}
}
re_static => { (~"the static lifetime", None) }
ReStatic => { (~"the static lifetime", None) }
re_empty => { (~"the empty lifetime", None) }
ReEmpty => { (~"the empty lifetime", None) }
// I believe these cases should not occur (except when debugging,
// perhaps)
ty::re_infer(_) | ty::re_type_bound(*) | ty::re_fn_bound(*) => {
ty::ReInfer(_) | ty::ReEarlyBound(*) | ty::ReLateBound(*) => {
(format!("lifetime {:?}", region), None)
}
};
@ -150,13 +150,13 @@ pub fn explain_region_and_span(cx: ctxt, region: ty::Region)
}
}
pub fn bound_region_ptr_to_str(cx: ctxt, br: bound_region) -> ~str {
pub fn bound_region_ptr_to_str(cx: ctxt, br: BoundRegion) -> ~str {
bound_region_to_str(cx, "&", true, br)
}
pub fn bound_region_to_str(cx: ctxt,
prefix: &str, space: bool,
br: bound_region) -> ~str {
br: BoundRegion) -> ~str {
let space_str = if space { " " } else { "" };
if cx.sess.verbose() {
@ -164,14 +164,14 @@ pub fn bound_region_to_str(cx: ctxt,
}
match br {
br_named(_, ident) => format!("{}'{}{}", prefix,
BrNamed(_, ident) => format!("{}'{}{}", prefix,
cx.sess.str_of(ident), space_str),
br_anon(_) => prefix.to_str(),
br_fresh(_) => prefix.to_str(),
BrAnon(_) => prefix.to_str(),
BrFresh(_) => prefix.to_str(),
}
}
pub fn re_scope_id_to_str(cx: ctxt, node_id: ast::NodeId) -> ~str {
pub fn ReScope_id_to_str(cx: ctxt, node_id: ast::NodeId) -> ~str {
match cx.items.find(&node_id) {
Some(&ast_map::node_block(ref blk)) => {
format!("<block at {}>",
@ -204,7 +204,7 @@ pub fn re_scope_id_to_str(cx: ctxt, node_id: ast::NodeId) -> ~str {
format!("<unknown-{}>", node_id)
}
_ => { cx.sess.bug(
format!("re_scope refers to {}",
format!("ReScope refers to {}",
ast_map::node_id_to_str(cx.items, node_id,
token::get_ident_interner()))) }
}
@ -229,16 +229,16 @@ pub fn region_to_str(cx: ctxt, prefix: &str, space: bool, region: Region) -> ~st
// to fit that into a short string. Hence the recommendation to use
// `explain_region()` or `note_and_explain_region()`.
match region {
ty::re_scope(_) => prefix.to_str(),
ty::re_type_bound(_, _, ident) => cx.sess.str_of(ident).to_owned(),
ty::re_fn_bound(_, br) => bound_region_to_str(cx, prefix, space, br),
ty::re_free(ref fr) => bound_region_to_str(cx, prefix, space, fr.bound_region),
ty::re_infer(ReSkolemized(_, br)) => {
ty::ReScope(_) => prefix.to_str(),
ty::ReEarlyBound(_, _, ident) => cx.sess.str_of(ident).to_owned(),
ty::ReLateBound(_, br) => bound_region_to_str(cx, prefix, space, br),
ty::ReFree(ref fr) => bound_region_to_str(cx, prefix, space, fr.bound_region),
ty::ReInfer(ReSkolemized(_, br)) => {
bound_region_to_str(cx, prefix, space, br)
}
ty::re_infer(ReVar(_)) => prefix.to_str(),
ty::re_static => format!("{}'static{}", prefix, space_str),
ty::re_empty => format!("{}'<empty>{}", prefix, space_str)
ty::ReInfer(ReVar(_)) => prefix.to_str(),
ty::ReStatic => format!("{}'static{}", prefix, space_str),
ty::ReEmpty => format!("{}'<empty>{}", prefix, space_str)
}
}
@ -356,8 +356,8 @@ pub fn ty_to_str(cx: ctxt, typ: t) -> ~str {
};
match (cty.sigil, cty.region) {
(ast::ManagedSigil, ty::re_static) |
(ast::OwnedSigil, ty::re_static) => {}
(ast::ManagedSigil, ty::ReStatic) |
(ast::OwnedSigil, ty::ReStatic) => {}
(_, region) => {
s.push_str(region_to_str(cx, "", true, region));
@ -689,14 +689,14 @@ impl Repr for ast::Pat {
}
}
impl Repr for ty::bound_region {
impl Repr for ty::BoundRegion {
fn repr(&self, tcx: ctxt) -> ~str {
match *self {
ty::br_anon(id) => format!("br_anon({})", id),
ty::br_named(id, ident) => format!("br_named({}, {})",
ty::BrAnon(id) => format!("BrAnon({})", id),
ty::BrNamed(id, ident) => format!("BrNamed({}, {})",
id.repr(tcx),
ident.repr(tcx)),
ty::br_fresh(id) => format!("br_fresh({})", id),
ty::BrFresh(id) => format!("BrFresh({})", id),
}
}
}
@ -704,41 +704,41 @@ impl Repr for ty::bound_region {
impl Repr for ty::Region {
fn repr(&self, tcx: ctxt) -> ~str {
match *self {
ty::re_type_bound(id, index, ident) => {
format!("re_type_bound({}, {}, {})",
ty::ReEarlyBound(id, index, ident) => {
format!("ReEarlyBound({}, {}, {})",
id, index, ident.repr(tcx))
}
ty::re_fn_bound(binder_id, ref bound_region) => {
format!("re_fn_bound({}, {})",
ty::ReLateBound(binder_id, ref bound_region) => {
format!("ReLateBound({}, {})",
binder_id, bound_region.repr(tcx))
}
ty::re_free(ref fr) => {
format!("re_free({}, {})",
ty::ReFree(ref fr) => {
format!("ReFree({}, {})",
fr.scope_id,
fr.bound_region.repr(tcx))
}
ty::re_scope(id) => {
format!("re_scope({})", id)
ty::ReScope(id) => {
format!("ReScope({})", id)
}
ty::re_static => {
format!("re_static")
ty::ReStatic => {
format!("ReStatic")
}
ty::re_infer(ReVar(ref vid)) => {
format!("re_infer({})", vid.id)
ty::ReInfer(ReVar(ref vid)) => {
format!("ReInfer({})", vid.id)
}
ty::re_infer(ReSkolemized(id, ref bound_region)) => {
ty::ReInfer(ReSkolemized(id, ref bound_region)) => {
format!("re_skolemized({}, {})",
id, bound_region.repr(tcx))
}
ty::re_empty => {
format!("re_empty")
ty::ReEmpty => {
format!("ReEmpty")
}
}
}

4
src/libsyntax/ast.rs
View File

@ -254,8 +254,8 @@ pub enum Def {
#[deriving(Clone, Eq, IterBytes, Encodable, Decodable, ToStr)]
pub enum DefRegion {
DefStaticRegion,
DefTypeBoundRegion(/* index */ uint, /* lifetime decl */ NodeId),
DefFnBoundRegion(/* binder_id */ NodeId, /* depth */ uint, /* lifetime decl */ NodeId),
DefEarlyBoundRegion(/* index */ uint, /* lifetime decl */ NodeId),
DefLateBoundRegion(/* binder_id */ NodeId, /* depth */ uint, /* lifetime decl */ NodeId),
DefFreeRegion(/* block scope */ NodeId, /* lifetime decl */ NodeId),
}