mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

rustc: remove use of @[].

Browse Source
This commit is contained in:
Huon Wilson 2014-02-01 15:57:59 +11:00
parent 891ada9be1
commit f8734df515
27 changed files with 189 additions and 180 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/librustc/metadata/csearch.rs
View File

@ -18,6 +18,7 @@ use middle::ty;
use middle::typeck;
use std::vec;
use std::rc::Rc;
use reader = extra::ebml::reader;
use syntax::ast;
use syntax::ast_map;
@ -221,8 +222,8 @@ pub fn get_field_type(tcx: ty::ctxt, class_id: ast::DefId,
class_id, def) );
let ty = decoder::item_type(def, the_field, tcx, cdata);
ty::ty_param_bounds_and_ty {
generics: ty::Generics {type_param_defs: @~[],
region_param_defs: @[]},
generics: ty::Generics {type_param_defs: Rc::new(~[]),
region_param_defs: Rc::new(~[])},
ty: ty
}
}

18
src/librustc/metadata/decoder.rs
View File

@ -25,11 +25,11 @@ use middle::ty;
use middle::typeck;
use middle::astencode::vtable_decoder_helpers;
use std::at_vec;
use std::u64;
use std::io;
use std::io::extensions::u64_from_be_bytes;
use std::option;
use std::rc::Rc;
use std::vec;
use extra::ebml::reader;
use extra::ebml;
@ -246,7 +246,7 @@ fn item_ty_param_defs(item: ebml::Doc,
tcx: ty::ctxt,
cdata: Cmd,
tag: uint)
-> @~[ty::TypeParameterDef] {
-> Rc<~[ty::TypeParameterDef]> {
let mut bounds = ~[];
reader::tagged_docs(item, tag, |p| {
let bd = parse_type_param_def_data(
@ -255,15 +255,15 @@ fn item_ty_param_defs(item: ebml::Doc,
bounds.push(bd);
true
});
@bounds
Rc::new(bounds)
}
fn item_region_param_defs(item_doc: ebml::Doc,
tcx: ty::ctxt,
cdata: Cmd)
-> @[ty::RegionParameterDef] {
at_vec::build(None, |push| {
reader::tagged_docs(item_doc, tag_region_param_def, |rp_doc| {
-> Rc<~[ty::RegionParameterDef]> {
let mut v = ~[];
reader::tagged_docs(item_doc, tag_region_param_def, |rp_doc| {
let ident_str_doc = reader::get_doc(rp_doc,
tag_region_param_def_ident);
let ident = item_name(tcx.sess.intr(), ident_str_doc);
@ -271,11 +271,11 @@ fn item_region_param_defs(item_doc: ebml::Doc,
tag_region_param_def_def_id);
let def_id = reader::with_doc_data(def_id_doc, parse_def_id);
let def_id = translate_def_id(cdata, def_id);
push(ty::RegionParameterDef { ident: ident,
def_id: def_id });
v.push(ty::RegionParameterDef { ident: ident,
def_id: def_id });
true
});
})
Rc::new(v)
}
fn item_ty_param_count(item: ebml::Doc) -> uint {

16
src/librustc/metadata/encoder.rs
View File

@ -171,7 +171,7 @@ pub fn def_to_str(did: DefId) -> ~str {
fn encode_ty_type_param_defs(ebml_w: &mut writer::Encoder,
ecx: &EncodeContext,
params: @~[ty::TypeParameterDef],
params: &[ty::TypeParameterDef],
tag: uint) {
let ty_str_ctxt = @tyencode::ctxt {
diag: ecx.diag,
@ -188,7 +188,7 @@ fn encode_ty_type_param_defs(ebml_w: &mut writer::Encoder,
fn encode_region_param_defs(ebml_w: &mut writer::Encoder,
ecx: &EncodeContext,
params: @[ty::RegionParameterDef]) {
params: &[ty::RegionParameterDef]) {
for param in params.iter() {
ebml_w.start_tag(tag_region_param_def);
@ -215,9 +215,9 @@ fn encode_item_variances(ebml_w: &mut writer::Encoder,
fn encode_bounds_and_type(ebml_w: &mut writer::Encoder,
ecx: &EncodeContext,
tpt: &ty::ty_param_bounds_and_ty) {
encode_ty_type_param_defs(ebml_w, ecx, tpt.generics.type_param_defs,
encode_ty_type_param_defs(ebml_w, ecx, tpt.generics.type_param_defs(),
tag_items_data_item_ty_param_bounds);
encode_region_param_defs(ebml_w, ecx, tpt.generics.region_param_defs);
encode_region_param_defs(ebml_w, ecx, tpt.generics.region_param_defs());
encode_type(ecx, ebml_w, tpt.ty);
}
@ -786,7 +786,7 @@ fn encode_method_ty_fields(ecx: &EncodeContext,
encode_def_id(ebml_w, method_ty.def_id);
encode_name(ecx, ebml_w, method_ty.ident);
encode_ty_type_param_defs(ebml_w, ecx,
method_ty.generics.type_param_defs,
method_ty.generics.type_param_defs(),
tag_item_method_tps);
encode_method_fty(ecx, ebml_w, &method_ty.fty);
encode_visibility(ebml_w, method_ty.vis);
@ -827,7 +827,7 @@ fn encode_info_for_method(ecx: &EncodeContext,
}
for &ast_method in ast_method_opt.iter() {
let num_params = tpt.generics.type_param_defs.len();
let num_params = tpt.generics.type_param_defs().len();
if num_params > 0u || is_default_impl
|| should_inline(ast_method.attrs) {
(ecx.encode_inlined_item)(
@ -1171,10 +1171,10 @@ fn encode_info_for_item(ecx: &EncodeContext,
encode_item_variances(ebml_w, ecx, item.id);
let trait_def = ty::lookup_trait_def(tcx, def_id);
encode_ty_type_param_defs(ebml_w, ecx,
trait_def.generics.type_param_defs,
trait_def.generics.type_param_defs(),
tag_items_data_item_ty_param_bounds);
encode_region_param_defs(ebml_w, ecx,
trait_def.generics.region_param_defs);
trait_def.generics.region_param_defs());
encode_trait_ref(ebml_w, ecx, trait_def.trait_ref, tag_item_trait_ref);
encode_name(ecx, ebml_w, item.ident);
encode_attributes(ebml_w, item.attrs);

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

@ -32,10 +32,10 @@ use syntax::fold::Folder;
use syntax::parse::token;
use syntax;
use std::at_vec;
use std::libc;
use std::cast;
use std::io::Seek;
use std::rc::Rc;
use extra::ebml::reader;
use extra::ebml;
@ -812,13 +812,13 @@ impl<'a> ebml_writer_helpers for writer::Encoder<'a> {
this.emit_struct_field("generics", 0, |this| {
this.emit_struct("Generics", 2, |this| {
this.emit_struct_field("type_param_defs", 0, |this| {
this.emit_from_vec(*tpbt.generics.type_param_defs,
this.emit_from_vec(tpbt.generics.type_param_defs(),
|this, type_param_def| {
this.emit_type_param_def(ecx, type_param_def);
})
});
this.emit_struct_field("region_param_defs", 1, |this| {
tpbt.generics.region_param_defs.encode(this);
tpbt.generics.region_param_defs().encode(this);
})
})
});
@ -997,7 +997,7 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext,
ebml_w.tag(c::tag_table_tcache, |ebml_w| {
ebml_w.id(id);
ebml_w.tag(c::tag_table_val, |ebml_w| {
ebml_w.emit_tpbt(ecx, *tpbt);
ebml_w.emit_tpbt(ecx, tpbt.clone());
})
})
}
@ -1064,7 +1064,7 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext,
ebml_w.tag(c::tag_table_capture_map, |ebml_w| {
ebml_w.id(id);
ebml_w.tag(c::tag_table_val, |ebml_w| {
ebml_w.emit_from_vec(*cap_vars, |ebml_w, cap_var| {
ebml_w.emit_from_vec(*cap_vars.borrow(), |ebml_w, cap_var| {
cap_var.encode(ebml_w);
})
})
@ -1183,8 +1183,8 @@ impl<'a> ebml_decoder_decoder_helpers for reader::Decoder<'a> {
this.read_struct_field("type_param_defs",
0,
|this| {
@this.read_to_vec(|this|
this.read_type_param_def(xcx))
Rc::new(this.read_to_vec(|this|
this.read_type_param_def(xcx)))
}),
region_param_defs:
this.read_struct_field("region_param_defs",
@ -1382,13 +1382,11 @@ fn decode_side_tables(xcx: @ExtendedDecodeContext,
}
c::tag_table_capture_map => {
let cvars =
at_vec::to_managed_move(
val_dsr.read_to_vec(
|val_dsr| val_dsr.read_capture_var(xcx)));
val_dsr.read_to_vec(|val_dsr| val_dsr.read_capture_var(xcx));
let mut capture_map = dcx.maps
.capture_map
.borrow_mut();
capture_map.get().insert(id, cvars);
capture_map.get().insert(id, Rc::new(cvars));
}
_ => {
xcx.dcx.tcx.sess.bug(

3
src/librustc/middle/borrowck/check_loans.rs
View File

@ -733,7 +733,7 @@ fn check_loans_in_fn<'a>(this: &mut CheckLoanCtxt<'a>,
span: Span) {
let capture_map = this.bccx.capture_map.borrow();
let cap_vars = capture_map.get().get(&closure_id);
for cap_var in cap_vars.iter() {
for cap_var in cap_vars.borrow().iter() {
let var_id = ast_util::def_id_of_def(cap_var.def).node;
let var_path = @LpVar(var_id);
this.check_if_path_is_moved(closure_id, span,
@ -839,4 +839,3 @@ fn check_loans_in_block<'a>(this: &mut CheckLoanCtxt<'a>,
visit::walk_block(this, blk, ());
this.check_for_conflicting_loans(blk.id);
}

2
src/librustc/middle/borrowck/gather_loans/gather_moves.rs
View File

@ -69,7 +69,7 @@ pub fn gather_captures(bccx: &BorrowckCtxt,
closure_expr: &ast::Expr) {
let capture_map = bccx.capture_map.borrow();
let captured_vars = capture_map.get().get(&closure_expr.id);
for captured_var in captured_vars.iter() {
for captured_var in captured_vars.borrow().iter() {
match captured_var.mode {
moves::CapMove => {
let fvar_id = ast_util::def_id_of_def(captured_var.def).node;

5
src/librustc/middle/const_eval.rs
View File

@ -24,6 +24,7 @@ use syntax::{ast, ast_map, ast_util};
use std::cell::RefCell;
use std::hashmap::HashMap;
use std::rc::Rc;
//
// This pass classifies expressions by their constant-ness.
@ -321,7 +322,7 @@ pub enum const_val {
const_int(i64),
const_uint(u64),
const_str(InternedString),
const_binary(@[u8]),
const_binary(Rc<~[u8]>),
const_bool(bool)
}
@ -510,7 +511,7 @@ pub fn eval_const_expr_partial<T: ty::ExprTyProvider>(tcx: &T, e: &Expr)
pub fn lit_to_const(lit: &Lit) -> const_val {
match lit.node {
LitStr(ref s, _) => const_str((*s).clone()),
LitBinary(data) => const_binary(data),
LitBinary(ref data) => const_binary(data.clone()),
LitChar(n) => const_uint(n as u64),
LitInt(n, _) => const_int(n),
LitUint(n, _) => const_uint(n),

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

@ -277,7 +277,7 @@ pub fn check_expr(cx: &mut Context, e: &Expr) {
ExprPath(_) => {
let did = ast_util::def_id_of_def(def_map.get()
.get_copy(&e.id));
ty::lookup_item_type(cx.tcx, did).generics.type_param_defs
ty::lookup_item_type(cx.tcx, did).generics.type_param_defs.clone()
}
_ => {
// Type substitutions should only occur on paths and
@ -289,6 +289,7 @@ pub fn check_expr(cx: &mut Context, e: &Expr) {
"non path/method call expr has type substs??")
}
};
let type_param_defs = type_param_defs.borrow();
if ts.len() != type_param_defs.len() {
// Fail earlier to make debugging easier
fail!("internal error: in kind::check_expr, length \
@ -362,8 +363,8 @@ fn check_ty(cx: &mut Context, aty: &Ty) {
for ts in r.iter() {
let def_map = cx.tcx.def_map.borrow();
let did = ast_util::def_id_of_def(def_map.get().get_copy(&id));
let type_param_defs =
ty::lookup_item_type(cx.tcx, did).generics.type_param_defs;
let generics = ty::lookup_item_type(cx.tcx, did).generics;
let type_param_defs = generics.type_param_defs();
for (&ty, type_param_def) in ts.iter().zip(type_param_defs.iter()) {
check_typaram_bounds(cx, aty.id, aty.span, ty, type_param_def)
}

2
src/librustc/middle/liveness.rs
View File

@ -502,7 +502,7 @@ fn visit_expr(v: &mut LivenessVisitor, expr: &Expr, this: @IrMaps) {
let capture_map = this.capture_map.borrow();
let cvs = capture_map.get().get(&expr.id);
let mut call_caps = ~[];
for cv in cvs.iter() {
for cv in cvs.borrow().iter() {
match moves::moved_variable_node_id_from_def(cv.def) {
Some(rv) => {
let cv_ln = this.add_live_node(FreeVarNode(cv.span));

25
src/librustc/middle/moves.rs
View File

@ -136,9 +136,9 @@ use util::ppaux::Repr;
use util::common::indenter;
use util::ppaux::UserString;
use std::at_vec;
use std::cell::RefCell;
use std::hashmap::{HashSet, HashMap};
use std::rc::Rc;
use syntax::ast::*;
use syntax::ast_util;
use syntax::visit;
@ -159,7 +159,7 @@ pub struct CaptureVar {
mode: CaptureMode // How variable is being accessed
}
pub type CaptureMap = @RefCell<HashMap<NodeId, @[CaptureVar]>>;
pub type CaptureMap = @RefCell<HashMap<NodeId, Rc<~[CaptureVar]>>>;
pub type MovesMap = @RefCell<HashSet<NodeId>>;
@ -681,23 +681,22 @@ impl VisitContext {
self.consume_expr(arg_expr)
}
pub fn compute_captures(&mut self, fn_expr_id: NodeId) -> @[CaptureVar] {
pub fn compute_captures(&mut self, fn_expr_id: NodeId) -> Rc<~[CaptureVar]> {
debug!("compute_capture_vars(fn_expr_id={:?})", fn_expr_id);
let _indenter = indenter();
let fn_ty = ty::node_id_to_type(self.tcx, fn_expr_id);
let sigil = ty::ty_closure_sigil(fn_ty);
let freevars = freevars::get_freevars(self.tcx, fn_expr_id);
if sigil == BorrowedSigil {
let v = if sigil == BorrowedSigil {
// || captures everything by ref
at_vec::from_fn(freevars.len(), |i| {
let fvar = &freevars[i];
CaptureVar {def: fvar.def, span: fvar.span, mode: CapRef}
})
freevars.iter()
.map(|fvar| CaptureVar {def: fvar.def, span: fvar.span, mode: CapRef})
.collect()
} else {
// @fn() and ~fn() capture by copy or by move depending on type
at_vec::from_fn(freevars.len(), |i| {
let fvar = &freevars[i];
freevars.iter()
.map(|fvar| {
let fvar_def_id = ast_util::def_id_of_def(fvar.def).node;
let fvar_ty = ty::node_id_to_type(self.tcx, fvar_def_id);
debug!("fvar_def_id={:?} fvar_ty={}",
@ -708,7 +707,9 @@ impl VisitContext {
CapCopy
};
CaptureVar {def: fvar.def, span: fvar.span, mode:mode}
})
}
}).collect()
};
Rc::new(v)
}
}

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

@ -13,8 +13,9 @@
use middle::ty;
use middle::ty_fold;
use middle::ty_fold::TypeFolder;
use std::rc::Rc;
use syntax::opt_vec::OptVec;
use std::at_vec;
///////////////////////////////////////////////////////////////////////////
// Public trait `Subst`
@ -84,10 +85,9 @@ impl<T:Subst> Subst for ~[T] {
self.map(|t| t.subst(tcx, substs))
}
}
impl<T:Subst> Subst for @[T] {
fn subst(&self, tcx: ty::ctxt, substs: &ty::substs) -> @[T] {
at_vec::map(*self, |t| t.subst(tcx, substs))
impl<T:Subst> Subst for Rc<T> {
fn subst(&self, tcx: ty::ctxt, substs: &ty::substs) -> Rc<T> {
Rc::new(self.borrow().subst(tcx, substs))
}
}

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

@ -220,7 +220,7 @@ fn resolve_default_method_vtables(bcx: &Block,
bcx.tcx(), param_substs, impl_res.trait_vtables);
// Now we pull any vtables for parameters on the actual method.
let num_method_vtables = method.generics.type_param_defs.len();
let num_method_vtables = method.generics.type_param_defs().len();
let method_vtables = match impl_vtables {
Some(vtables) => {
let num_impl_type_parameters =

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

@ -403,11 +403,11 @@ pub fn trans_expr_fn<'a>(
let capture_map = ccx.maps.capture_map.borrow();
capture_map.get().get_copy(&user_id)
};
let ClosureResult {llbox, cdata_ty, bcx} = build_closure(bcx, cap_vars, sigil);
let ClosureResult {llbox, cdata_ty, bcx} = build_closure(bcx, *cap_vars.borrow(), sigil);
trans_closure(ccx, sub_path, decl, body, llfn,
bcx.fcx.param_substs, user_id,
[], ty::ty_fn_ret(fty),
|bcx| load_environment(bcx, cdata_ty, cap_vars, sigil));
|bcx| load_environment(bcx, cdata_ty, *cap_vars.borrow(), sigil));
fill_fn_pair(bcx, dest_addr, llfn, llbox);
bcx

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

@ -152,7 +152,7 @@ pub fn maybe_instantiate_inline(ccx: @CrateContext, fn_id: ast::DefId)
let impl_tpt = ty::lookup_item_type(ccx.tcx, impl_did);
let num_type_params =
impl_tpt.generics.type_param_defs.len() +
impl_tpt.generics.type_param_defs().len() +
mth.generics.ty_params.len();
if num_type_params == 0 {

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

@ -182,7 +182,7 @@ pub fn trans_static_method_callee(bcx: &Block,
// out which impl the `Trait<T1...Tn>` bound on the type `self` was
// bound to.
let bound_index = ty::lookup_trait_def(bcx.tcx(), trait_id).
generics.type_param_defs.len();
generics.type_param_defs().len();
let mname = if method_id.crate == ast::LOCAL_CRATE {
{
@ -318,7 +318,7 @@ pub fn combine_impl_and_methods_tps(bcx: &Block,
let ccx = bcx.ccx();
let method = ty::method(ccx.tcx, mth_did);
let n_m_tps = method.generics.type_param_defs.len();
let n_m_tps = method.generics.type_param_defs().len();
let node_substs = node_id_type_params(bcx, callee_id);
debug!("rcvr_substs={:?}", rcvr_substs.repr(ccx.tcx));
let ty_substs

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

@ -34,6 +34,7 @@ use std::cmp;
use std::hashmap::{HashMap, HashSet};
use std::ops;
use std::ptr::to_unsafe_ptr;
use std::rc::Rc;
use std::to_bytes;
use std::to_str::ToStr;
use std::vec;
@ -870,15 +871,21 @@ pub struct RegionParameterDef {
#[deriving(Clone)]
pub struct Generics {
/// List of type parameters declared on the item.
type_param_defs: @~[TypeParameterDef],
type_param_defs: Rc<~[TypeParameterDef]>,
/// List of region parameters declared on the item.
region_param_defs: @[RegionParameterDef],
region_param_defs: Rc<~[RegionParameterDef]>,
}
impl Generics {
pub fn has_type_params(&self) -> bool {
!self.type_param_defs.is_empty()
!self.type_param_defs.borrow().is_empty()
}
pub fn type_param_defs<'a>(&'a self) -> &'a [TypeParameterDef] {
self.type_param_defs.borrow().as_slice()
}
pub fn region_param_defs<'a>(&'a self) -> &'a [RegionParameterDef] {
self.region_param_defs.borrow().as_slice()
}
}
@ -3105,7 +3112,7 @@ pub fn expr_has_ty_params(cx: ctxt, expr: &ast::Expr) -> bool {
pub fn method_call_type_param_defs(tcx: ctxt,
method_map: typeck::method_map,
id: ast::NodeId)
-> Option<@~[TypeParameterDef]> {
-> Option<Rc<~[TypeParameterDef]>> {
let method_map = method_map.borrow();
method_map.get().find(&id).map(|method| {
match method.origin {
@ -3125,12 +3132,12 @@ pub fn method_call_type_param_defs(tcx: ctxt,
// method bounds, so we must preprend the tps from the
// trait itself. This ought to be harmonized.
let trait_type_param_defs =
lookup_trait_def(tcx, trt_id).generics.type_param_defs;
@vec::append(
(*trait_type_param_defs).clone(),
*ty::trait_method(tcx,
trt_id,
n_mth).generics.type_param_defs)
lookup_trait_def(tcx, trt_id).generics.type_param_defs();
Rc::new(vec::append(
trait_type_param_defs.to_owned(),
ty::trait_method(tcx,
trt_id,
n_mth).generics.type_param_defs()))
}
}
})
@ -4212,7 +4219,7 @@ pub fn lookup_field_type(tcx: ctxt,
Some(&ty_param_bounds_and_ty {ty, ..}) => ty,
None => {
let tpt = csearch::get_field_type(tcx, struct_id, id);
tcache.get().insert(id, tpt);
tcache.get().insert(id, tpt.clone());
tpt.ty
}
}

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

@ -170,7 +170,7 @@ fn ast_path_substs<AC:AstConv,RS:RegionScope>(
// If the type is parameterized by the this region, then replace this
// region with the current anon region binding (in other words,
// whatever & would get replaced with).
let expected_num_region_params = decl_generics.region_param_defs.len();
let expected_num_region_params = decl_generics.region_param_defs().len();
let supplied_num_region_params = path.segments.last().unwrap().lifetimes.len();
let regions = if expected_num_region_params == supplied_num_region_params {
path.segments.last().unwrap().lifetimes.map(
@ -197,8 +197,8 @@ fn ast_path_substs<AC:AstConv,RS:RegionScope>(
// Convert the type parameters supplied by the user.
let supplied_ty_param_count = path.segments.iter().flat_map(|s| s.types.iter()).len();
let formal_ty_param_count = decl_generics.type_param_defs.len();
let required_ty_param_count = decl_generics.type_param_defs.iter()
let formal_ty_param_count = decl_generics.type_param_defs().len();
let required_ty_param_count = decl_generics.type_param_defs().iter()
.take_while(|x| x.default.is_none())
.len();
if supplied_ty_param_count < required_ty_param_count {
@ -228,7 +228,7 @@ fn ast_path_substs<AC:AstConv,RS:RegionScope>(
~"provided type arguments with defaults");
}
let defaults = decl_generics.type_param_defs.slice_from(supplied_ty_param_count)
let defaults = decl_generics.type_param_defs().slice_from(supplied_ty_param_count)
.iter().map(|&x| x.default.unwrap());
let tps = path.segments.iter().flat_map(|s| s.types.iter())
.map(|&a_t| ast_ty_to_ty(this, rscope, a_t))

7
src/librustc/middle/typeck/check/_match.rs
View File

@ -147,7 +147,7 @@ pub fn check_pat_variant(pcx: &pat_ctxt, pat: &ast::Pat, path: &ast::Path,
ty::enum_variant_with_id(tcx, enm, var);
let var_tpt = ty::lookup_item_type(tcx, var);
vinfo.args.map(|t| {
if var_tpt.generics.type_param_defs.len() ==
if var_tpt.generics.type_param_defs().len() ==
expected_substs.tps.len()
{
ty::subst(tcx, expected_substs, *t)
@ -172,7 +172,7 @@ pub fn check_pat_variant(pcx: &pat_ctxt, pat: &ast::Pat, path: &ast::Path,
None);
fcx.write_error(pat.id);
kind_name = "[error]";
arg_types = (*subpats).clone()
arg_types = subpats.clone()
.unwrap_or_default()
.map(|_| ty::mk_err());
}
@ -221,7 +221,7 @@ pub fn check_pat_variant(pcx: &pat_ctxt, pat: &ast::Pat, path: &ast::Path,
None);
fcx.write_error(pat.id);
kind_name = "[error]";
arg_types = (*subpats).clone()
arg_types = subpats.clone()
.unwrap_or_default()
.map(|_| ty::mk_err());
}
@ -699,4 +699,3 @@ pub fn check_pointer_pat(pcx: &pat_ctxt,
#[deriving(Eq)]
enum PointerKind { Send, Borrowed }

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

@ -954,7 +954,7 @@ impl<'a> LookupContext<'a> {
// If they were not explicitly supplied, just construct fresh
// type variables.
let num_supplied_tps = self.supplied_tps.len();
let num_method_tps = candidate.method_ty.generics.type_param_defs.len();
let num_method_tps = candidate.method_ty.generics.type_param_defs().len();
let m_substs = {
if num_supplied_tps == 0u {
self.fcx.infcx().next_ty_vars(num_method_tps)

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

@ -564,7 +564,7 @@ pub fn check_item(ccx: @CrateCtxt, it: &ast::Item) {
let param_env = ty::construct_parameter_environment(
ccx.tcx,
None,
*fn_tpt.generics.type_param_defs,
fn_tpt.generics.type_param_defs(),
[],
[],
body.id);
@ -674,9 +674,9 @@ fn check_method_body(ccx: @CrateCtxt,
ty::construct_parameter_environment(
ccx.tcx,
self_bound,
*item_generics.type_param_defs,
*method_generics.type_param_defs,
item_generics.region_param_defs,
item_generics.type_param_defs(),
method_generics.type_param_defs(),
item_generics.region_param_defs(),
method.body.id);
// Compute the fty from point of view of inside fn
@ -776,7 +776,7 @@ fn compare_impl_method(tcx: ty::ctxt,
debug!("compare_impl_method()");
let infcx = infer::new_infer_ctxt(tcx);
let impl_tps = impl_generics.type_param_defs.len();
let impl_tps = impl_generics.type_param_defs().len();
// Try to give more informative error messages about self typing
// mismatches. Note that any mismatch will also be detected
@ -812,8 +812,8 @@ fn compare_impl_method(tcx: ty::ctxt,
}
}
let num_impl_m_type_params = impl_m.generics.type_param_defs.len();
let num_trait_m_type_params = trait_m.generics.type_param_defs.len();
let num_impl_m_type_params = impl_m.generics.type_param_defs().len();
let num_trait_m_type_params = trait_m.generics.type_param_defs().len();
if num_impl_m_type_params != num_trait_m_type_params {
tcx.sess.span_err(
impl_m_span,
@ -838,10 +838,10 @@ fn compare_impl_method(tcx: ty::ctxt,
return;
}
for (i, trait_param_def) in trait_m.generics.type_param_defs.iter().enumerate() {
// For each of the corresponding impl ty param's bounds...
let impl_param_def = &impl_m.generics.type_param_defs[i];
let it = trait_m.generics.type_param_defs().iter()
.zip(impl_m.generics.type_param_defs().iter());
for (i, (trait_param_def, impl_param_def)) in it.enumerate() {
// Check that the impl does not require any builtin-bounds
// that the trait does not guarantee:
let extra_bounds =
@ -886,15 +886,15 @@ fn compare_impl_method(tcx: ty::ctxt,
// impl type is "&'a str", then this would replace the self
// type with a free region `self`.
let dummy_impl_tps: ~[ty::t] =
impl_generics.type_param_defs.iter().enumerate().
impl_generics.type_param_defs().iter().enumerate().
map(|(i,t)| ty::mk_param(tcx, i, t.def_id)).
collect();
let dummy_method_tps: ~[ty::t] =
impl_m.generics.type_param_defs.iter().enumerate().
impl_m.generics.type_param_defs().iter().enumerate().
map(|(i,t)| ty::mk_param(tcx, i + impl_tps, t.def_id)).
collect();
let dummy_impl_regions: OptVec<ty::Region> =
impl_generics.region_param_defs.iter().
impl_generics.region_param_defs().iter().
map(|l| ty::ReFree(ty::FreeRegion {
scope_id: impl_m_body_id,
bound_region: ty::BrNamed(l.def_id, l.ident)})).
@ -1374,8 +1374,8 @@ pub fn impl_self_ty(vcx: &VtableContext,
let (n_tps, n_rps, raw_ty) = {
let ity = ty::lookup_item_type(tcx, did);
(ity.generics.type_param_defs.len(),
ity.generics.region_param_defs.len(),
(ity.generics.type_param_defs().len(),
ity.generics.region_param_defs().len(),
ity.ty)
};
@ -1419,10 +1419,10 @@ fn generics_of_static_method_container(type_context: ty::ctxt,
-> ty::Generics {
match provenance {
ast::FromTrait(trait_def_id) => {
ty::lookup_trait_def(type_context, trait_def_id).generics
ty::lookup_trait_def(type_context, trait_def_id).generics.clone()
}
ast::FromImpl(impl_def_id) => {
ty::lookup_item_type(type_context, impl_def_id).generics
ty::lookup_item_type(type_context, impl_def_id).generics.clone()
}
}
}
@ -1485,7 +1485,7 @@ fn check_type_parameter_positions_in_path(function_context: @FnCtxt,
// Make sure lifetime parameterization agrees with the trait or
// implementation type.
let trait_region_parameter_count = generics.region_param_defs.len();
let trait_region_parameter_count = generics.region_param_defs().len();
let supplied_region_parameter_count = trait_segment.lifetimes.len();
if trait_region_parameter_count != supplied_region_parameter_count
&& supplied_region_parameter_count != 0 {
@ -1501,8 +1501,8 @@ fn check_type_parameter_positions_in_path(function_context: @FnCtxt,
// Make sure the number of type parameters supplied on the trait
// or implementation segment equals the number of type parameters
// on the trait or implementation definition.
let formal_ty_param_count = generics.type_param_defs.len();
let required_ty_param_count = generics.type_param_defs.iter()
let formal_ty_param_count = generics.type_param_defs().len();
let required_ty_param_count = generics.type_param_defs().iter()
.take_while(|x| x.default.is_none())
.len();
let supplied_ty_param_count = trait_segment.types.len();
@ -1517,7 +1517,7 @@ fn check_type_parameter_positions_in_path(function_context: @FnCtxt,
} else {
"s"
};
let needs = if required_ty_param_count < generics.type_param_defs.len() {
let needs = if required_ty_param_count < generics.type_param_defs().len() {
"needs at least"
} else {
"needs"
@ -1539,7 +1539,7 @@ fn check_type_parameter_positions_in_path(function_context: @FnCtxt,
} else {
"s"
};
let needs = if required_ty_param_count < generics.type_param_defs.len() {
let needs = if required_ty_param_count < generics.type_param_defs().len() {
"needs at most"
} else {
"needs"
@ -2465,8 +2465,8 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
// Look up the number of type parameters and the raw type, and
// determine whether the class is region-parameterized.
let item_type = ty::lookup_item_type(tcx, class_id);
let type_parameter_count = item_type.generics.type_param_defs.len();
let region_parameter_count = item_type.generics.region_param_defs.len();
let type_parameter_count = item_type.generics.type_param_defs().len();
let region_parameter_count = item_type.generics.region_param_defs().len();
let raw_type = item_type.ty;
// Generate the struct type.
@ -2523,8 +2523,8 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
// Look up the number of type parameters and the raw type, and
// determine whether the enum is region-parameterized.
let item_type = ty::lookup_item_type(tcx, enum_id);
let type_parameter_count = item_type.generics.type_param_defs.len();
let region_parameter_count = item_type.generics.region_param_defs.len();
let type_parameter_count = item_type.generics.type_param_defs().len();
let region_parameter_count = item_type.generics.region_param_defs().len();
let raw_type = item_type.ty;
// Generate the enum type.
@ -3710,8 +3710,8 @@ pub fn instantiate_path(fcx: @FnCtxt,
node_id: ast::NodeId) {
debug!(">>> instantiate_path");
let ty_param_count = tpt.generics.type_param_defs.len();
let ty_param_req = tpt.generics.type_param_defs.iter()
let ty_param_count = tpt.generics.type_param_defs().len();
let ty_param_req = tpt.generics.type_param_defs().iter()
.take_while(|x| x.default.is_none())
.len();
let mut ty_substs_len = 0;
@ -3726,7 +3726,7 @@ pub fn instantiate_path(fcx: @FnCtxt,
// determine the region parameters, using the value given by the user
// (if any) and otherwise using a fresh region variable
let num_expected_regions = tpt.generics.region_param_defs.len();
let num_expected_regions = tpt.generics.region_param_defs().len();
let num_supplied_regions = pth.segments.last().unwrap().lifetimes.len();
let regions = if num_expected_regions == num_supplied_regions {
pth.segments.last().unwrap().lifetimes.map(
@ -3755,7 +3755,7 @@ pub fn instantiate_path(fcx: @FnCtxt,
ast::DefStaticMethod(_, provenance @ ast::FromTrait(_), _) => {
let generics = generics_of_static_method_container(fcx.ccx.tcx,
provenance);
(ty_param_count - 1, ty_param_req - 1, Some(generics.type_param_defs.len()))
(ty_param_count - 1, ty_param_req - 1, Some(generics.type_param_defs().len()))
}
_ => (ty_param_count, ty_param_req, None),
};
@ -3800,7 +3800,7 @@ pub fn instantiate_path(fcx: @FnCtxt,
// at the appropriate position.
let mut result = ~[];
let mut pushed = false;
let defaults = tpt.generics.type_param_defs.iter()
let defaults = tpt.generics.type_param_defs().iter()
.enumerate().filter_map(|(i, x)| {
match self_parameter_index {
Some(index) if index == i => None,
@ -4305,7 +4305,7 @@ pub fn check_intrinsic_type(ccx: @CrateCtxt, it: &ast::ForeignItem) {
variadic: false}
});
let i_ty = ty::lookup_item_type(ccx.tcx, local_def(it.id));
let i_n_tps = i_ty.generics.type_param_defs.len();
let i_n_tps = i_ty.generics.type_param_defs().len();
if i_n_tps != n_tps {
tcx.sess.span_err(it.span, format!("intrinsic has wrong number \
of type parameters: found {}, \

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

@ -423,7 +423,7 @@ fn search_for_vtable(vcx: &VtableContext,
let im_generics =
ty::lookup_item_type(tcx, im.did).generics;
let subres = lookup_vtables(vcx, location_info,
*im_generics.type_param_defs, &substs,
im_generics.type_param_defs(), &substs,
is_early);
@ -688,12 +688,12 @@ pub fn early_resolve_expr(ex: &ast::Expr, fcx: @FnCtxt, is_early: bool) {
let item_ty = ty::lookup_item_type(cx.tcx, did);
debug!("early resolve expr: def {:?} {:?}, {:?}, {}", ex.id, did, def,
fcx.infcx().ty_to_str(item_ty.ty));
if has_trait_bounds(*item_ty.generics.type_param_defs) {
if has_trait_bounds(item_ty.generics.type_param_defs()) {
debug!("early_resolve_expr: looking up vtables for type params {}",
item_ty.generics.type_param_defs.repr(fcx.tcx()));
item_ty.generics.type_param_defs().repr(fcx.tcx()));
let vcx = fcx.vtable_context();
let vtbls = lookup_vtables(&vcx, &location_info_for_expr(ex),
*item_ty.generics.type_param_defs,
item_ty.generics.type_param_defs(),
substs, is_early);
if !is_early {
insert_vtables(fcx, ex.id, vtbls);
@ -717,11 +717,11 @@ pub fn early_resolve_expr(ex: &ast::Expr, fcx: @FnCtxt, is_early: bool) {
Some(type_param_defs) => {
debug!("vtable resolution on parameter bounds for method call {}",
ex.repr(fcx.tcx()));
if has_trait_bounds(*type_param_defs) {
if has_trait_bounds(*type_param_defs.borrow()) {
let substs = fcx.node_ty_substs(callee_id);
let vcx = fcx.vtable_context();
let vtbls = lookup_vtables(&vcx, &location_info_for_expr(ex),
*type_param_defs, &substs, is_early);
*type_param_defs.borrow(), &substs, is_early);
if !is_early {
insert_vtables(fcx, callee_id, vtbls);
}
@ -784,9 +784,9 @@ pub fn resolve_impl(ccx: @CrateCtxt,
let param_env = ty::construct_parameter_environment(
ccx.tcx,
None,
*impl_generics.type_param_defs,
impl_generics.type_param_defs(),
[],
impl_generics.region_param_defs,
impl_generics.region_param_defs(),
impl_item.id);
let impl_trait_ref = @impl_trait_ref.subst(ccx.tcx, &param_env.free_substs);
@ -800,7 +800,7 @@ pub fn resolve_impl(ccx: @CrateCtxt,
let trait_def = ty::lookup_trait_def(ccx.tcx, impl_trait_ref.def_id);
let vtbls = lookup_vtables(&vcx,
&loc_info,
*trait_def.generics.type_param_defs,
trait_def.generics.type_param_defs(),
&impl_trait_ref.substs,
false);

26
src/librustc/middle/typeck/coherence.rs
View File

@ -47,13 +47,13 @@ use syntax::visit;
use std::cell::RefCell;
use std::hashmap::HashSet;
use std::result::Ok;
use std::rc::Rc;
use std::vec;
pub struct UniversalQuantificationResult {
monotype: t,
type_variables: ~[ty::t],
type_param_defs: @~[ty::TypeParameterDef]
type_param_defs: Rc<~[ty::TypeParameterDef]>
}
pub fn get_base_type(inference_context: @InferCtxt,
@ -356,11 +356,11 @@ impl CoherenceChecker {
// construct the polytype for the method based on the method_ty
let new_generics = ty::Generics {
type_param_defs:
@vec::append(
(*impl_poly_type.generics.type_param_defs).clone(),
*new_method_ty.generics.type_param_defs),
Rc::new(vec::append(
impl_poly_type.generics.type_param_defs().to_owned(),
new_method_ty.generics.type_param_defs())),
region_param_defs:
impl_poly_type.generics.region_param_defs
impl_poly_type.generics.region_param_defs.clone()
};
let new_polytype = ty::ty_param_bounds_and_ty {
generics: new_generics,
@ -449,7 +449,7 @@ impl CoherenceChecker {
let polytype_b = self.get_self_type_for_implementation(
implementation_b);
if self.polytypes_unify(polytype_a, polytype_b) {
if self.polytypes_unify(polytype_a.clone(), polytype_b) {
let session = self.crate_context.tcx.sess;
session.span_err(
self.span_of_impl(implementation_b),
@ -497,13 +497,13 @@ impl CoherenceChecker {
pub fn universally_quantify_polytype(&self,
polytype: ty_param_bounds_and_ty)
-> UniversalQuantificationResult {
let region_parameter_count = polytype.generics.region_param_defs.len();
let region_parameter_count = polytype.generics.region_param_defs().len();
let region_parameters =
self.inference_context.next_region_vars(
infer::BoundRegionInCoherence,
region_parameter_count);
let bounds_count = polytype.generics.type_param_defs.len();
let bounds_count = polytype.generics.type_param_defs().len();
let type_parameters = self.inference_context.next_ty_vars(bounds_count);
let substitutions = substs {
@ -518,7 +518,7 @@ impl CoherenceChecker {
UniversalQuantificationResult {
monotype: monotype,
type_variables: substitutions.tps,
type_param_defs: polytype.generics.type_param_defs
type_param_defs: polytype.generics.type_param_defs.clone()
}
}
@ -770,7 +770,7 @@ pub fn make_substs_for_receiver_types(tcx: ty::ctxt,
// determine how many type parameters were declared on the impl
let num_impl_type_parameters = {
let impl_polytype = ty::lookup_item_type(tcx, impl_id);
impl_polytype.generics.type_param_defs.len()
impl_polytype.generics.type_param_defs().len()
};
// determine how many type parameters appear on the trait
@ -778,7 +778,7 @@ pub fn make_substs_for_receiver_types(tcx: ty::ctxt,
// the current method type has the type parameters from the trait + method
let num_method_type_parameters =
num_trait_type_parameters + method.generics.type_param_defs.len();
num_trait_type_parameters + method.generics.type_param_defs().len();
// the new method type will have the type parameters from the impl + method
let combined_tps = vec::from_fn(num_method_type_parameters, |i| {
@ -789,7 +789,7 @@ pub fn make_substs_for_receiver_types(tcx: ty::ctxt,
// replace type parameters that belong to method with another
// type parameter, this time with the index adjusted
let method_index = i - num_trait_type_parameters;
let type_param_def = &method.generics.type_param_defs[method_index];
let type_param_def = &method.generics.type_param_defs()[method_index];
let new_index = num_impl_type_parameters + method_index;
ty::mk_param(tcx, new_index, type_param_def.def_id)
}

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

@ -44,6 +44,7 @@ use middle::typeck::{CrateCtxt, lookup_def_tcx, no_params, write_ty_to_tcx};
use util::ppaux;
use util::ppaux::Repr;
use std::rc::Rc;
use std::vec;
use syntax::abi::AbiSet;
use syntax::ast::{RegionTyParamBound, TraitTyParamBound};
@ -285,9 +286,9 @@ pub fn ensure_trait_methods(ccx: &CrateCtxt, trait_id: ast::NodeId) {
let dummy_defid = ast::DefId {crate: 0, node: 0};
// Represents [A',B',C']
let num_trait_bounds = trait_ty_generics.type_param_defs.len();
let num_trait_bounds = trait_ty_generics.type_param_defs().len();
let non_shifted_trait_tps = vec::from_fn(num_trait_bounds, |i| {
ty::mk_param(tcx, i, trait_ty_generics.type_param_defs[i].def_id)
ty::mk_param(tcx, i, trait_ty_generics.type_param_defs()[i].def_id)
});
// Represents [D']
@ -295,18 +296,18 @@ pub fn ensure_trait_methods(ccx: &CrateCtxt, trait_id: ast::NodeId) {
dummy_defid);
// Represents [E',F',G']
let num_method_bounds = m.generics.type_param_defs.len();
let num_method_bounds = m.generics.type_param_defs().len();
let shifted_method_tps = vec::from_fn(num_method_bounds, |i| {
ty::mk_param(tcx, i + num_trait_bounds + 1,
m.generics.type_param_defs[i].def_id)
m.generics.type_param_defs()[i].def_id)
});
// Convert the regions 'a, 'b, 'c defined on the trait into
// bound regions on the fn. Note that because these appear in the
// bound for `Self` they must be early bound.
let new_early_region_param_defs = trait_ty_generics.region_param_defs;
let new_early_region_param_defs = trait_ty_generics.region_param_defs.clone();
let rps_from_trait =
trait_ty_generics.region_param_defs.iter().
trait_ty_generics.region_param_defs().iter().
enumerate().
map(|(index,d)| ty::ReEarlyBound(d.def_id.node, index, d.ident)).
collect();
@ -334,7 +335,7 @@ pub fn ensure_trait_methods(ccx: &CrateCtxt, trait_id: ast::NodeId) {
let mut new_type_param_defs = ~[];
let substd_type_param_defs =
trait_ty_generics.type_param_defs.subst(tcx, &substs);
new_type_param_defs.push_all(*substd_type_param_defs);
new_type_param_defs.push_all(*substd_type_param_defs.borrow());
// add in the "self" type parameter
let self_trait_def = get_trait_def(ccx, local_def(trait_id));
@ -351,7 +352,7 @@ pub fn ensure_trait_methods(ccx: &CrateCtxt, trait_id: ast::NodeId) {
// add in the type parameters from the method
let substd_type_param_defs = m.generics.type_param_defs.subst(tcx, &substs);
new_type_param_defs.push_all(*substd_type_param_defs);
new_type_param_defs.push_all(*substd_type_param_defs.borrow());
debug!("static method {} type_param_defs={} ty={}, substs={}",
m.def_id.repr(tcx),
@ -363,7 +364,7 @@ pub fn ensure_trait_methods(ccx: &CrateCtxt, trait_id: ast::NodeId) {
tcache.get().insert(m.def_id,
ty_param_bounds_and_ty {
generics: ty::Generics {
type_param_defs: @new_type_param_defs,
type_param_defs: Rc::new(new_type_param_defs),
region_param_defs: new_early_region_param_defs
},
ty: ty
@ -383,7 +384,7 @@ pub fn ensure_trait_methods(ccx: &CrateCtxt, trait_id: ast::NodeId) {
let trait_self_ty = ty::mk_self(this.tcx, local_def(trait_id));
let fty = astconv::ty_of_method(this, *m_id, *m_purity, trait_self_ty,
*m_explicit_self, m_decl);
let num_trait_type_params = trait_generics.type_param_defs.len();
let num_trait_type_params = trait_generics.type_param_defs().len();
ty::Method::new(
*m_ident,
// FIXME(#5121) -- distinguish early vs late lifetime params
@ -466,7 +467,7 @@ fn convert_methods(ccx: &CrateCtxt,
{
let tcx = ccx.tcx;
for m in ms.iter() {
let num_rcvr_ty_params = rcvr_ty_generics.type_param_defs.len();
let num_rcvr_ty_params = rcvr_ty_generics.type_param_defs().len();
let m_ty_generics = ty_generics(ccx, &m.generics, num_rcvr_ty_params);
let mty = @ty_of_method(ccx,
container,
@ -489,10 +490,10 @@ fn convert_methods(ccx: &CrateCtxt,
// itself
ty_param_bounds_and_ty {
generics: ty::Generics {
type_param_defs: @vec::append(
(*rcvr_ty_generics.type_param_defs).clone(),
*m_ty_generics.type_param_defs),
region_param_defs: rcvr_ty_generics.region_param_defs,
type_param_defs: Rc::new(vec::append(
rcvr_ty_generics.type_param_defs().to_owned(),
m_ty_generics.type_param_defs())),
region_param_defs: rcvr_ty_generics.region_param_defs.clone(),
},
ty: fty
});
@ -574,7 +575,7 @@ pub fn convert(ccx: &CrateCtxt, it: &ast::Item) {
let mut tcache = tcx.tcache.borrow_mut();
tcache.get().insert(local_def(it.id),
ty_param_bounds_and_ty {
generics: i_ty_generics,
generics: i_ty_generics.clone(),
ty: selfty});
}
@ -637,7 +638,7 @@ pub fn convert(ccx: &CrateCtxt, it: &ast::Item) {
{
let mut tcache = tcx.tcache.borrow_mut();
tcache.get().insert(local_def(it.id), tpt);
tcache.get().insert(local_def(it.id), tpt.clone());
}
convert_struct(ccx, struct_def, tpt, it.id);
@ -816,7 +817,7 @@ pub fn ty_of_item(ccx: &CrateCtxt, it: &ast::Item)
{
let tcache = tcx.tcache.borrow();
match tcache.get().find(&def_id) {
Some(&tpt) => return tpt,
Some(tpt) => return tpt.clone(),
_ => {}
}
}
@ -826,7 +827,7 @@ pub fn ty_of_item(ccx: &CrateCtxt, it: &ast::Item)
let tpt = no_params(typ);
let mut tcache = tcx.tcache.borrow_mut();
tcache.get().insert(local_def(it.id), tpt);
tcache.get().insert(local_def(it.id), tpt.clone());
return tpt;
}
ast::ItemFn(decl, purity, abi, ref generics, _) => {
@ -838,8 +839,8 @@ pub fn ty_of_item(ccx: &CrateCtxt, it: &ast::Item)
decl);
let tpt = ty_param_bounds_and_ty {
generics: ty::Generics {
type_param_defs: ty_generics.type_param_defs,
region_param_defs: @[],
type_param_defs: ty_generics.type_param_defs.clone(),
region_param_defs: Rc::new(~[]),
},
ty: ty::mk_bare_fn(ccx.tcx, tofd)
};
@ -849,14 +850,14 @@ pub fn ty_of_item(ccx: &CrateCtxt, it: &ast::Item)
ppaux::ty_to_str(tcx, tpt.ty));
let mut tcache = ccx.tcx.tcache.borrow_mut();
tcache.get().insert(local_def(it.id), tpt);
tcache.get().insert(local_def(it.id), tpt.clone());
return tpt;
}
ast::ItemTy(t, ref generics) => {
{
let mut tcache = tcx.tcache.borrow_mut();
match tcache.get().find(&local_def(it.id)) {
Some(&tpt) => return tpt,
Some(tpt) => return tpt.clone(),
None => { }
}
}
@ -870,7 +871,7 @@ pub fn ty_of_item(ccx: &CrateCtxt, it: &ast::Item)
};
let mut tcache = tcx.tcache.borrow_mut();
tcache.get().insert(local_def(it.id), tpt);
tcache.get().insert(local_def(it.id), tpt.clone());
return tpt;
}
ast::ItemEnum(_, ref generics) => {
@ -884,7 +885,7 @@ pub fn ty_of_item(ccx: &CrateCtxt, it: &ast::Item)
};
let mut tcache = tcx.tcache.borrow_mut();
tcache.get().insert(local_def(it.id), tpt);
tcache.get().insert(local_def(it.id), tpt.clone());
return tpt;
}
ast::ItemTrait(..) => {
@ -902,7 +903,7 @@ pub fn ty_of_item(ccx: &CrateCtxt, it: &ast::Item)
};
let mut tcache = tcx.tcache.borrow_mut();
tcache.get().insert(local_def(it.id), tpt);
tcache.get().insert(local_def(it.id), tpt.clone());
return tpt;
}
ast::ItemImpl(..) | ast::ItemMod(_) |
@ -925,8 +926,8 @@ pub fn ty_of_foreign_item(ccx: &CrateCtxt,
ast::ForeignItemStatic(t, _) => {
ty::ty_param_bounds_and_ty {
generics: ty::Generics {
type_param_defs: @~[],
region_param_defs: @[],
type_param_defs: Rc::new(~[]),
region_param_defs: Rc::new(~[]),
},
ty: ast_ty_to_ty(ccx, &ExplicitRscope, t)
}
@ -938,11 +939,11 @@ pub fn ty_generics(ccx: &CrateCtxt,
generics: &ast::Generics,
base_index: uint) -> ty::Generics {
return ty::Generics {
region_param_defs: generics.lifetimes.iter().map(|l| {
region_param_defs: Rc::new(generics.lifetimes.iter().map(|l| {
ty::RegionParameterDef { ident: l.ident,
def_id: local_def(l.id) }
}).collect(),
type_param_defs: @generics.ty_params.mapi_to_vec(|offset, param| {
}).collect()),
type_param_defs: Rc::new(generics.ty_params.mapi_to_vec(|offset, param| {
let existing_def_opt = {
let ty_param_defs = ccx.tcx.ty_param_defs.borrow();
ty_param_defs.get().find(&param.id).map(|def| *def)
@ -969,7 +970,7 @@ pub fn ty_generics(ccx: &CrateCtxt,
def
}
}
})
}))
};
fn compute_bounds(
@ -1040,7 +1041,7 @@ pub fn ty_of_foreign_fn_decl(ccx: &CrateCtxt,
};
let mut tcache = ccx.tcx.tcache.borrow_mut();
tcache.get().insert(def_id, tpt);
tcache.get().insert(def_id, tpt.clone());
return tpt;
}
@ -1049,11 +1050,11 @@ pub fn mk_item_substs(ccx: &CrateCtxt,
self_ty: Option<ty::t>) -> ty::substs
{
let params: ~[ty::t] =
ty_generics.type_param_defs.iter().enumerate().map(
ty_generics.type_param_defs().iter().enumerate().map(
|(i, t)| ty::mk_param(ccx.tcx, i, t.def_id)).collect();
let regions: OptVec<ty::Region> =
ty_generics.region_param_defs.iter().enumerate().map(
ty_generics.region_param_defs().iter().enumerate().map(
|(i, l)| ty::ReEarlyBound(l.def_id.node, i, l.ident)).collect();
substs {regions: ty::NonerasedRegions(regions),

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

@ -70,6 +70,7 @@ use util::ppaux;
use std::cell::RefCell;
use std::hashmap::HashMap;
use std::rc::Rc;
use std::result;
use extra::list::List;
use extra::list;
@ -271,8 +272,8 @@ pub fn lookup_def_ccx(ccx: &CrateCtxt, sp: Span, id: ast::NodeId)
pub fn no_params(t: ty::t) -> ty::ty_param_bounds_and_ty {
ty::ty_param_bounds_and_ty {
generics: ty::Generics {type_param_defs: @~[],
region_param_defs: @[]},
generics: ty::Generics {type_param_defs: Rc::new(~[]),
region_param_defs: Rc::new(~[])},
ty: t
}
}

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

@ -750,7 +750,7 @@ impl<'a> ConstraintContext<'a> {
variance: VarianceTermPtr<'a>) {
debug!("add_constraints_from_substs(def_id={:?})", def_id);
for (i, p) in generics.type_param_defs.iter().enumerate() {
for (i, p) in generics.type_param_defs().iter().enumerate() {
let variance_decl =
self.declared_variance(p.def_id, def_id, TypeParam, i);
let variance_i = self.xform(variance, variance_decl);
@ -760,7 +760,7 @@ impl<'a> ConstraintContext<'a> {
match substs.regions {
ty::ErasedRegions => {}
ty::NonerasedRegions(ref rps) => {
for (i, p) in generics.region_param_defs.iter().enumerate() {
for (i, p) in generics.region_param_defs().iter().enumerate() {
let variance_decl =
self.declared_variance(p.def_id, def_id, RegionParam, i);
let variance_i = self.xform(variance, variance_decl);

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

@ -522,11 +522,11 @@ pub fn parameterized(cx: ctxt,
}
let generics = if is_trait {
ty::lookup_trait_def(cx, did).generics
ty::lookup_trait_def(cx, did).generics.clone()
} else {
ty::lookup_item_type(cx, did).generics
};
let ty_params = generics.type_param_defs.iter();
let ty_params = generics.type_param_defs().iter();
let num_defaults = ty_params.zip(tps.iter()).rev().take_while(|&(def, &actual)| {
match def.default {
Some(default) => default == actual,
@ -789,8 +789,8 @@ impl Repr for ty::ty_param_bounds_and_ty {
impl Repr for ty::Generics {
fn repr(&self, tcx: ctxt) -> ~str {
format!("Generics(type_param_defs: {}, region_param_defs: {})",
self.type_param_defs.repr(tcx),
self.region_param_defs.repr(tcx))
self.type_param_defs().repr(tcx),
self.region_param_defs().repr(tcx))
}
}

2
src/libstd/reflect.rs
View File

@ -250,7 +250,7 @@ impl<V:TyVisitor + MovePtr> TyVisitor for MovePtrAdaptor<V> {
true
}
fn visit_evec_box(&mut self, mtbl: uint, inner: *TyDesc) -> bool {
fn visit_evec_box(&mut self, _mtbl: uint, _inner: *TyDesc) -> bool {
true
}