From 754aaea88c5f2899e628a54fed4643384219da29 Mon Sep 17 00:00:00 2001 From: Jared Roesch Date: Wed, 8 Jul 2015 12:27:32 -0700 Subject: [PATCH] Remove snake_case names from ty.rs --- src/librustc/metadata/csearch.rs | 2 +- src/librustc/metadata/decoder.rs | 6 +- src/librustc/metadata/encoder.rs | 4 +- src/librustc/metadata/tydecode.rs | 6 +- src/librustc/metadata/tyencode.rs | 2 +- src/librustc/middle/cast.rs | 4 +- src/librustc/middle/check_match.rs | 6 +- src/librustc/middle/expr_use_visitor.rs | 2 +- src/librustc/middle/implicator.rs | 2 +- src/librustc/middle/infer/combine.rs | 16 +- src/librustc/middle/infer/error_reporting.rs | 20 +- .../middle/infer/higher_ranked/mod.rs | 4 +- src/librustc/middle/infer/mod.rs | 26 +-- .../middle/infer/region_inference/mod.rs | 8 +- src/librustc/middle/mem_categorization.rs | 2 +- src/librustc/middle/traits/mod.rs | 2 +- src/librustc/middle/traits/project.rs | 2 +- src/librustc/middle/traits/select.rs | 6 +- src/librustc/middle/ty.rs | 208 +++++++++--------- src/librustc/middle/ty_fold.rs | 18 +- src/librustc/middle/ty_match.rs | 2 +- src/librustc/middle/ty_relate/mod.rs | 50 ++--- src/librustc/util/ppaux.rs | 4 +- src/librustc_trans/trans/adt.rs | 4 +- src/librustc_trans/trans/attributes.rs | 2 +- src/librustc_trans/trans/common.rs | 4 +- src/librustc_trans/trans/consts.rs | 2 +- .../trans/debuginfo/metadata.rs | 10 +- .../trans/debuginfo/type_names.rs | 4 +- src/librustc_trans/trans/expr.rs | 20 +- src/librustc_trans/trans/tvec.rs | 2 +- src/librustc_trans/trans/type_of.rs | 4 +- src/librustc_typeck/astconv.rs | 6 +- src/librustc_typeck/check/_match.rs | 10 +- src/librustc_typeck/check/cast.rs | 14 +- src/librustc_typeck/check/coercion.rs | 12 +- src/librustc_typeck/check/demand.rs | 2 +- src/librustc_typeck/check/method/confirm.rs | 2 +- src/librustc_typeck/check/method/mod.rs | 2 +- src/librustc_typeck/check/method/probe.rs | 6 +- src/librustc_typeck/check/mod.rs | 36 +-- src/librustc_typeck/coherence/mod.rs | 4 +- src/librustc_typeck/coherence/orphan.rs | 4 +- src/librustc_typeck/collect.rs | 6 +- src/librustc_typeck/variance.rs | 2 +- src/librustdoc/clean/mod.rs | 2 +- 46 files changed, 277 insertions(+), 285 deletions(-) diff --git a/src/librustc/metadata/csearch.rs b/src/librustc/metadata/csearch.rs index 4e0cf7b0e4c..2a469ed69ef 100644 --- a/src/librustc/metadata/csearch.rs +++ b/src/librustc/metadata/csearch.rs @@ -197,7 +197,7 @@ pub fn get_item_attrs(cstore: &cstore::CStore, pub fn get_struct_fields(cstore: &cstore::CStore, def: ast::DefId) - -> Vec { + -> Vec { let cdata = cstore.get_crate_data(def.krate); decoder::get_struct_fields(cstore.intr.clone(), &*cdata, def.node) } diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs index 5a79ef203b4..5ab22676ce0 100644 --- a/src/librustc/metadata/decoder.rs +++ b/src/librustc/metadata/decoder.rs @@ -1049,7 +1049,7 @@ fn struct_field_family_to_visibility(family: Family) -> ast::Visibility { } pub fn get_struct_fields(intr: Rc, cdata: Cmd, id: ast::NodeId) - -> Vec { + -> Vec { let data = cdata.data(); let item = lookup_item(id, data); reader::tagged_docs(item, tag_item_field).filter_map(|an_item| { @@ -1059,7 +1059,7 @@ pub fn get_struct_fields(intr: Rc, cdata: Cmd, id: ast::NodeId) let did = item_def_id(an_item, cdata); let tagdoc = reader::get_doc(an_item, tag_item_field_origin); let origin_id = translated_def_id(cdata, tagdoc); - Some(ty::field_ty { + Some(ty::FieldTy { name: name, id: did, vis: struct_field_family_to_visibility(f), @@ -1073,7 +1073,7 @@ pub fn get_struct_fields(intr: Rc, cdata: Cmd, id: ast::NodeId) let tagdoc = reader::get_doc(an_item, tag_item_field_origin); let f = item_family(an_item); let origin_id = translated_def_id(cdata, tagdoc); - ty::field_ty { + ty::FieldTy { name: special_idents::unnamed_field.name, id: did, vis: struct_field_family_to_visibility(f), diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index b677e7b8570..67ea3b2efb1 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -267,7 +267,7 @@ fn encode_parent_item(rbml_w: &mut Encoder, id: DefId) { } fn encode_struct_fields(rbml_w: &mut Encoder, - fields: &[ty::field_ty], + fields: &[ty::FieldTy], origin: DefId) { for f in fields { if f.name == special_idents::unnamed_field.name { @@ -636,7 +636,7 @@ fn encode_provided_source(rbml_w: &mut Encoder, /* Returns an index of items in this class */ fn encode_info_for_struct(ecx: &EncodeContext, rbml_w: &mut Encoder, - fields: &[ty::field_ty], + fields: &[ty::FieldTy], global_index: &mut Vec>) -> Vec> { /* Each class has its own index, since different classes diff --git a/src/librustc/metadata/tydecode.rs b/src/librustc/metadata/tydecode.rs index 61fce699dd5..930f86a93cb 100644 --- a/src/librustc/metadata/tydecode.rs +++ b/src/librustc/metadata/tydecode.rs @@ -525,7 +525,7 @@ fn parse_ty_<'a, 'tcx, F>(st: &mut PState<'a, 'tcx>, conv: &mut F) -> Ty<'tcx> w assert_eq!(next(st), ':'); let len = parse_hex(st); assert_eq!(next(st), '#'); - let key = ty::creader_cache_key {cnum: st.krate, + let key = ty::CReaderCacheKey {cnum: st.krate, pos: pos, len: len }; @@ -587,11 +587,11 @@ fn parse_mutability(st: &mut PState) -> ast::Mutability { } } -fn parse_mt_<'a, 'tcx, F>(st: &mut PState<'a, 'tcx>, conv: &mut F) -> ty::mt<'tcx> where +fn parse_mt_<'a, 'tcx, F>(st: &mut PState<'a, 'tcx>, conv: &mut F) -> ty::TypeWithMutability<'tcx> where F: FnMut(DefIdSource, ast::DefId) -> ast::DefId, { let m = parse_mutability(st); - ty::mt { ty: parse_ty_(st, conv), mutbl: m } + ty::TypeWithMutability { ty: parse_ty_(st, conv), mutbl: m } } fn parse_def_(st: &mut PState, source: DefIdSource, conv: &mut F) -> ast::DefId where diff --git a/src/librustc/metadata/tyencode.rs b/src/librustc/metadata/tyencode.rs index 441f9f102ae..865af4239b6 100644 --- a/src/librustc/metadata/tyencode.rs +++ b/src/librustc/metadata/tyencode.rs @@ -183,7 +183,7 @@ fn enc_mutability(w: &mut Encoder, mt: ast::Mutability) { } fn enc_mt<'a, 'tcx>(w: &mut Encoder, cx: &ctxt<'a, 'tcx>, - mt: ty::mt<'tcx>) { + mt: ty::TypeWithMutability<'tcx>) { enc_mutability(w, mt.mutbl); enc_ty(w, cx, mt.ty); } diff --git a/src/librustc/middle/cast.rs b/src/librustc/middle/cast.rs index ec1fd67616b..ad2ec37c212 100644 --- a/src/librustc/middle/cast.rs +++ b/src/librustc/middle/cast.rs @@ -36,9 +36,9 @@ pub enum CastTy<'tcx> { /// Function Pointers FnPtr, /// Raw pointers - Ptr(&'tcx ty::mt<'tcx>), + Ptr(&'tcx ty::TypeWithMutability<'tcx>), /// References - RPtr(&'tcx ty::mt<'tcx>), + RPtr(&'tcx ty::TypeWithMutability<'tcx>), } /// Cast Kind. See RFC 401 (or librustc_typeck/check/cast.rs) diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index a303c49bf8d..339fecf8f8b 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -535,7 +535,7 @@ fn construct_witness(cx: &MatchCheckCtxt, ctor: &Constructor, } } - ty::TyRef(_, ty::mt { ty, mutbl }) => { + ty::TyRef(_, ty::TypeWithMutability { ty, mutbl }) => { match ty.sty { ty::TyArray(_, n) => match ctor { &Single => { @@ -600,7 +600,7 @@ fn all_constructors(cx: &MatchCheckCtxt, left_ty: Ty, ty::TyBool => [true, false].iter().map(|b| ConstantValue(ConstVal::Bool(*b))).collect(), - ty::TyRef(_, ty::mt { ty, .. }) => match ty.sty { + ty::TyRef(_, ty::TypeWithMutability { ty, .. }) => match ty.sty { ty::TySlice(_) => range_inclusive(0, max_slice_length).map(|length| Slice(length)).collect(), _ => vec!(Single) @@ -808,7 +808,7 @@ pub fn constructor_arity(cx: &MatchCheckCtxt, ctor: &Constructor, ty: Ty) -> usi match ty.sty { ty::TyTuple(ref fs) => fs.len(), ty::TyBox(_) => 1, - ty::TyRef(_, ty::mt { ty, .. }) => match ty.sty { + ty::TyRef(_, ty::TypeWithMutability { ty, .. }) => match ty.sty { ty::TySlice(_) => match *ctor { Slice(length) => length, ConstantValue(_) => 0, diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs index 0d204a823af..54fc2daff2b 100644 --- a/src/librustc/middle/expr_use_visitor.rs +++ b/src/librustc/middle/expr_use_visitor.rs @@ -720,7 +720,7 @@ impl<'d,'t,'a,'tcx> ExprUseVisitor<'d,'t,'a,'tcx> { // are properly handled. self.walk_expr(with_expr); - fn contains_field_named(field: &ty::field, + fn contains_field_named(field: &ty::Field, fields: &Vec) -> bool { diff --git a/src/librustc/middle/implicator.rs b/src/librustc/middle/implicator.rs index 3e097578857..197e90c20a0 100644 --- a/src/librustc/middle/implicator.rs +++ b/src/librustc/middle/implicator.rs @@ -115,7 +115,7 @@ impl<'a, 'tcx> Implicator<'a, 'tcx> { ty::TyArray(t, _) | ty::TySlice(t) | - ty::TyRawPtr(ty::mt { ty: t, .. }) | + ty::TyRawPtr(ty::TypeWithMutability { ty: t, .. }) | ty::TyBox(t) => { self.accumulate_from_ty(t) } diff --git a/src/librustc/middle/infer/combine.rs b/src/librustc/middle/infer/combine.rs index 0d081cfeee0..abc75720ee9 100644 --- a/src/librustc/middle/infer/combine.rs +++ b/src/librustc/middle/infer/combine.rs @@ -108,7 +108,7 @@ pub fn super_combine_tys<'a,'tcx:'a,R>(infcx: &InferCtxt<'a, 'tcx>, // All other cases of inference are errors (&ty::TyInfer(_), _) | (_, &ty::TyInfer(_)) => { - Err(ty::terr_sorts(ty_relate::expected_found(relation, &a, &b))) + Err(ty::Sorts(ty_relate::expected_found(relation, &a, &b))) } @@ -278,7 +278,7 @@ impl<'a, 'tcx> CombineFields<'a, 'tcx> { }; let u = ty.fold_with(&mut generalize); if generalize.cycle_detected { - Err(ty::terr_cyclic_ty) + Err(ty::CyclicTy) } else { Ok(u) } @@ -363,12 +363,12 @@ impl<'cx, 'tcx> ty_fold::TypeFolder<'tcx> for Generalizer<'cx, 'tcx> { pub trait RelateResultCompare<'tcx, T> { fn compare(&self, t: T, f: F) -> RelateResult<'tcx, T> where - F: FnOnce() -> ty::type_err<'tcx>; + F: FnOnce() -> ty::TypeError<'tcx>; } impl<'tcx, T:Clone + PartialEq> RelateResultCompare<'tcx, T> for RelateResult<'tcx, T> { fn compare(&self, t: T, f: F) -> RelateResult<'tcx, T> where - F: FnOnce() -> ty::type_err<'tcx>, + F: FnOnce() -> ty::TypeError<'tcx>, { self.clone().and_then(|s| { if s == t { @@ -381,16 +381,16 @@ impl<'tcx, T:Clone + PartialEq> RelateResultCompare<'tcx, T> for RelateResult<'t } fn int_unification_error<'tcx>(a_is_expected: bool, v: (ty::IntVarValue, ty::IntVarValue)) - -> ty::type_err<'tcx> + -> ty::TypeError<'tcx> { let (a, b) = v; - ty::terr_int_mismatch(ty_relate::expected_found_bool(a_is_expected, &a, &b)) + ty::IntMismatch(ty_relate::expected_found_bool(a_is_expected, &a, &b)) } fn float_unification_error<'tcx>(a_is_expected: bool, v: (ast::FloatTy, ast::FloatTy)) - -> ty::type_err<'tcx> + -> ty::TypeError<'tcx> { let (a, b) = v; - ty::terr_float_mismatch(ty_relate::expected_found_bool(a_is_expected, &a, &b)) + ty::FloatMismatch(ty_relate::expected_found_bool(a_is_expected, &a, &b)) } diff --git a/src/librustc/middle/infer/error_reporting.rs b/src/librustc/middle/infer/error_reporting.rs index 8d226739e16..432c5bc1404 100644 --- a/src/librustc/middle/infer/error_reporting.rs +++ b/src/librustc/middle/infer/error_reporting.rs @@ -220,17 +220,17 @@ pub trait ErrorReporting<'tcx> { fn process_errors(&self, errors: &Vec>) -> Vec>; - fn report_type_error(&self, trace: TypeTrace<'tcx>, terr: &ty::type_err<'tcx>); + fn report_type_error(&self, trace: TypeTrace<'tcx>, terr: &ty::TypeError<'tcx>); fn report_and_explain_type_error(&self, trace: TypeTrace<'tcx>, - terr: &ty::type_err<'tcx>); + terr: &ty::TypeError<'tcx>); fn values_str(&self, values: &ValuePairs<'tcx>) -> Option; fn expected_found_str + HasTypeFlags>( &self, - exp_found: &ty::expected_found) + exp_found: &ty::ExpectedFound) -> Option; fn report_concrete_failure(&self, @@ -260,7 +260,7 @@ pub trait ErrorReporting<'tcx> { fn report_processed_errors(&self, var_origin: &[RegionVariableOrigin], - trace_origin: &[(TypeTrace<'tcx>, ty::type_err<'tcx>)], + trace_origin: &[(TypeTrace<'tcx>, ty::TypeError<'tcx>)], same_regions: &[SameRegions]); fn give_suggestion(&self, same_regions: &[SameRegions]); @@ -351,7 +351,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { match free_regions_from_same_fn(self.tcx, sub, sup) { Some(ref same_frs) if trace.is_some() => { let trace = trace.unwrap(); - let terr = ty::terr_regions_does_not_outlive(sup, + let terr = ty::RegionsDoesNotOutlive(sup, sub); trace_origins.push((trace, terr)); append_to_same_regions(&mut same_regions, same_frs); @@ -467,7 +467,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { } } - fn report_type_error(&self, trace: TypeTrace<'tcx>, terr: &ty::type_err<'tcx>) { + fn report_type_error(&self, trace: TypeTrace<'tcx>, terr: &ty::TypeError<'tcx>) { let expected_found_str = match self.values_str(&trace.values) { Some(v) => v, None => { @@ -490,7 +490,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { fn report_and_explain_type_error(&self, trace: TypeTrace<'tcx>, - terr: &ty::type_err<'tcx>) { + terr: &ty::TypeError<'tcx>) { let span = trace.origin.span(); self.report_type_error(trace, terr); self.tcx.note_and_explain_type_err(terr, span); @@ -508,7 +508,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { fn expected_found_str + HasTypeFlags>( &self, - exp_found: &ty::expected_found) + exp_found: &ty::ExpectedFound) -> Option { let expected = exp_found.expected.resolve(self); @@ -595,7 +595,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { match origin { infer::Subtype(trace) | infer::DefaultExistentialBound(trace) => { - let terr = ty::terr_regions_does_not_outlive(sup, sub); + let terr = ty::RegionsDoesNotOutlive(sup, sub); self.report_and_explain_type_error(trace, &terr); } infer::Reborrow(span) => { @@ -888,7 +888,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { fn report_processed_errors(&self, var_origins: &[RegionVariableOrigin], - trace_origins: &[(TypeTrace<'tcx>, ty::type_err<'tcx>)], + trace_origins: &[(TypeTrace<'tcx>, ty::TypeError<'tcx>)], same_regions: &[SameRegions]) { for vo in var_origins { self.report_inference_failure(vo.clone()); diff --git a/src/librustc/middle/infer/higher_ranked/mod.rs b/src/librustc/middle/infer/higher_ranked/mod.rs index 64063623f67..ec3d4012c0c 100644 --- a/src/librustc/middle/infer/higher_ranked/mod.rs +++ b/src/librustc/middle/infer/higher_ranked/mod.rs @@ -85,11 +85,11 @@ impl<'a,'tcx> HigherRankedRelations<'a,'tcx> for CombineFields<'a,'tcx> { Err((skol_br, tainted_region)) => { if self.a_is_expected { debug!("Not as polymorphic!"); - return Err(ty::terr_regions_insufficiently_polymorphic(skol_br, + return Err(ty::RegionsInsufficientlyPolymorphic(skol_br, tainted_region)); } else { debug!("Overly polymorphic!"); - return Err(ty::terr_regions_overly_polymorphic(skol_br, + return Err(ty::RegionsOverlyPolymorphic(skol_br, tainted_region)); } } diff --git a/src/librustc/middle/infer/mod.rs b/src/librustc/middle/infer/mod.rs index 63f31921ec2..3175146ea7f 100644 --- a/src/librustc/middle/infer/mod.rs +++ b/src/librustc/middle/infer/mod.rs @@ -171,9 +171,9 @@ impl fmt::Display for TypeOrigin { /// See `error_reporting.rs` for more details #[derive(Clone, Debug)] pub enum ValuePairs<'tcx> { - Types(ty::expected_found>), - TraitRefs(ty::expected_found>), - PolyTraitRefs(ty::expected_found>), + Types(ty::ExpectedFound>), + TraitRefs(ty::ExpectedFound>), + PolyTraitRefs(ty::ExpectedFound>), } /// The trace designates the path through inference that we took to @@ -460,12 +460,12 @@ pub fn mk_sub_poly_trait_refs<'a, 'tcx>(cx: &InferCtxt<'a, 'tcx>, fn expected_found(a_is_expected: bool, a: T, b: T) - -> ty::expected_found + -> ty::ExpectedFound { if a_is_expected { - ty::expected_found {expected: a, found: b} + ty::ExpectedFound {expected: a, found: b} } else { - ty::expected_found {expected: b, found: a} + ty::ExpectedFound {expected: b, found: a} } } @@ -913,7 +913,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { match higher_ranked::leak_check(self, skol_map, snapshot) { Ok(()) => Ok(()), - Err((br, r)) => Err(ty::terr_regions_insufficiently_polymorphic(br, r)) + Err((br, r)) => Err(ty::RegionsInsufficientlyPolymorphic(br, r)) } } @@ -1198,7 +1198,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { sp: Span, mk_msg: M, actual_ty: String, - err: Option<&ty::type_err<'tcx>>) where + err: Option<&ty::TypeError<'tcx>>) where M: FnOnce(Option, String) -> String, { self.type_error_message_str_with_expected(sp, mk_msg, None, actual_ty, err) @@ -1209,7 +1209,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { mk_msg: M, expected_ty: Option>, actual_ty: String, - err: Option<&ty::type_err<'tcx>>) where + err: Option<&ty::TypeError<'tcx>>) where M: FnOnce(Option, String) -> String, { debug!("hi! expected_ty = {:?}, actual_ty = {}", expected_ty, actual_ty); @@ -1235,7 +1235,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { sp: Span, mk_msg: M, actual_ty: Ty<'tcx>, - err: Option<&ty::type_err<'tcx>>) where + err: Option<&ty::TypeError<'tcx>>) where M: FnOnce(String) -> String, { let actual_ty = self.resolve_type_vars_if_possible(&actual_ty); @@ -1254,10 +1254,10 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { span: Span, expected: Ty<'tcx>, actual: Ty<'tcx>, - err: &ty::type_err<'tcx>) { + err: &ty::TypeError<'tcx>) { let trace = TypeTrace { origin: Misc(span), - values: Types(ty::expected_found { + values: Types(ty::ExpectedFound { expected: expected, found: actual }) @@ -1431,7 +1431,7 @@ impl<'tcx> TypeTrace<'tcx> { pub fn dummy(tcx: &ty::ctxt<'tcx>) -> TypeTrace<'tcx> { TypeTrace { origin: Misc(codemap::DUMMY_SP), - values: Types(ty::expected_found { + values: Types(ty::ExpectedFound { expected: tcx.types.err, found: tcx.types.err, }) diff --git a/src/librustc/middle/infer/region_inference/mod.rs b/src/librustc/middle/infer/region_inference/mod.rs index 891a39e723a..17168bb7fa6 100644 --- a/src/librustc/middle/infer/region_inference/mod.rs +++ b/src/librustc/middle/infer/region_inference/mod.rs @@ -133,7 +133,7 @@ pub enum RegionResolutionError<'tcx> { /// should put a lifetime. In those cases we process and put those errors /// into `ProcessedErrors` before we do any reporting. ProcessedErrors(Vec, - Vec<(TypeTrace<'tcx>, ty::type_err<'tcx>)>, + Vec<(TypeTrace<'tcx>, ty::TypeError<'tcx>)>, Vec), } @@ -873,7 +873,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { if self.tcx.region_maps.nearest_common_ancestor(fr_scope, s_id) == fr_scope { Ok(s) } else { - Err(ty::terr_regions_no_overlap(b, a)) + Err(ty::RegionsNoOverlap(b, a)) } } @@ -892,7 +892,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { if a == b { Ok(a) } else { - Err(ty::terr_regions_no_overlap(b, a)) + Err(ty::RegionsNoOverlap(b, a)) } } } @@ -949,7 +949,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { } else if r_id == scope_b { Ok(ReScope(scope_a)) } else { - Err(ty::terr_regions_no_overlap(region_a, region_b)) + Err(ty::RegionsNoOverlap(region_a, region_b)) } } } diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index f506de525ff..a25c45283f2 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -1614,7 +1614,7 @@ impl fmt::Debug for InteriorKind { fn element_kind(t: Ty) -> ElementKind { match t.sty { - ty::TyRef(_, ty::mt{ty, ..}) | + ty::TyRef(_, ty::TypeWithMutability{ty, ..}) | ty::TyBox(ty) => match ty.sty { ty::TySlice(_) => VecElement, _ => OtherElement diff --git a/src/librustc/middle/traits/mod.rs b/src/librustc/middle/traits/mod.rs index b5f01ada7e1..148b27adf64 100644 --- a/src/librustc/middle/traits/mod.rs +++ b/src/librustc/middle/traits/mod.rs @@ -155,7 +155,7 @@ pub enum SelectionError<'tcx> { Unimplemented, OutputTypeParameterMismatch(ty::PolyTraitRef<'tcx>, ty::PolyTraitRef<'tcx>, - ty::type_err<'tcx>), + ty::TypeError<'tcx>), TraitNotObjectSafe(ast::DefId), } diff --git a/src/librustc/middle/traits/project.rs b/src/librustc/middle/traits/project.rs index e29d9646509..cd38e9d0d31 100644 --- a/src/librustc/middle/traits/project.rs +++ b/src/librustc/middle/traits/project.rs @@ -51,7 +51,7 @@ pub enum ProjectionTyError<'tcx> { #[derive(Clone)] pub struct MismatchedProjectionTypes<'tcx> { - pub err: ty::type_err<'tcx> + pub err: ty::TypeError<'tcx> } #[derive(PartialEq, Eq, Debug)] diff --git a/src/librustc/middle/traits/select.rs b/src/librustc/middle/traits/select.rs index ad91f664af2..9926165d7e1 100644 --- a/src/librustc/middle/traits/select.rs +++ b/src/librustc/middle/traits/select.rs @@ -1659,7 +1659,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { } } - ty::TyRef(_, ty::mt { ty: _, mutbl }) => { + ty::TyRef(_, ty::TypeWithMutability { ty: _, mutbl }) => { // &mut T or &T match bound { ty::BoundCopy => { @@ -1851,8 +1851,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { Some(vec![referent_ty]) } - ty::TyRawPtr(ty::mt { ty: element_ty, ..}) | - ty::TyRef(_, ty::mt { ty: element_ty, ..}) => { + ty::TyRawPtr(ty::TypeWithMutability { ty: element_ty, ..}) | + ty::TyRef(_, ty::TypeWithMutability { ty: element_ty, ..}) => { Some(vec![element_ty]) }, diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index 715072a12eb..889615917cf 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -8,10 +8,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +// FIXME: (@jroesch) @eddyb should remove this when he renames ctxt #![allow(non_camel_case_types)] -pub use self::terr_vstore_kind::*; -pub use self::type_err::*; +pub use self::TypeError::*; pub use self::InferTy::*; pub use self::InferRegion::*; pub use self::ImplOrTraitItemId::*; @@ -109,9 +109,9 @@ pub struct CrateAnalysis { } #[derive(Copy, Clone, PartialEq, Eq, Hash)] -pub struct field<'tcx> { +pub struct Field<'tcx> { pub name: ast::Name, - pub mt: mt<'tcx> + pub mt: TypeWithMutability<'tcx> } @@ -488,13 +488,13 @@ pub struct AssociatedType<'tcx> { } #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)] -pub struct mt<'tcx> { +pub struct TypeWithMutability<'tcx> { pub ty: Ty<'tcx>, pub mutbl: ast::Mutability, } #[derive(Clone, Copy, Debug)] -pub struct field_ty { +pub struct FieldTy { pub name: Name, pub id: DefId, pub vis: ast::Visibility, @@ -674,7 +674,7 @@ pub type MethodMap<'tcx> = FnvHashMap>; // Contains information needed to resolve types and (in the future) look up // the types of AST nodes. #[derive(Copy, Clone, PartialEq, Eq, Hash)] -pub struct creader_cache_key { +pub struct CReaderCacheKey { pub cnum: CrateNum, pub pos: usize, pub len: usize @@ -864,7 +864,7 @@ pub struct ctxt<'tcx> { pub map: ast_map::Map<'tcx>, pub freevars: RefCell, pub tcache: RefCell>>, - pub rcache: RefCell>>, + pub rcache: RefCell>>, pub tc_cache: RefCell, TypeContents>>, pub ast_ty_to_ty_cache: RefCell>>, pub enum_var_cache: RefCell>>>>>, @@ -873,7 +873,7 @@ pub struct ctxt<'tcx> { pub lang_items: middle::lang_items::LanguageItems, /// A mapping of fake provided method def_ids to the default implementation pub provided_method_sources: RefCell>, - pub struct_fields: RefCell>>>, + pub struct_fields: RefCell>>>, /// Maps from def-id of a type or region parameter to its /// (inferred) variance. @@ -1747,11 +1747,11 @@ pub enum TypeVariants<'tcx> { TySlice(Ty<'tcx>), /// A raw pointer. Written as `*mut T` or `*const T` - TyRawPtr(mt<'tcx>), + TyRawPtr(TypeWithMutability<'tcx>), /// A reference; a pointer with an associated lifetime. Written as /// `&a mut T` or `&'a T`. - TyRef(&'tcx Region, mt<'tcx>), + TyRef(&'tcx Region, TypeWithMutability<'tcx>), /// If the def-id is Some(_), then this is the type of a specific /// fn item. Otherwise, if None(_), it a fn pointer type. @@ -1945,50 +1945,42 @@ pub enum IntVarValue { } #[derive(Clone, Copy, Debug)] -pub enum terr_vstore_kind { - terr_vec, - terr_str, - terr_fn, - terr_trait -} - -#[derive(Clone, Copy, Debug)] -pub struct expected_found { +pub struct ExpectedFound { pub expected: T, pub found: T } // Data structures used in type unification #[derive(Clone, Copy, Debug)] -pub enum type_err<'tcx> { - terr_mismatch, - terr_unsafety_mismatch(expected_found), - terr_abi_mismatch(expected_found), - terr_mutability, - terr_box_mutability, - terr_ptr_mutability, - terr_ref_mutability, - terr_vec_mutability, - terr_tuple_size(expected_found), - terr_fixed_array_size(expected_found), - terr_ty_param_size(expected_found), - terr_arg_count, - terr_regions_does_not_outlive(Region, Region), - terr_regions_not_same(Region, Region), - terr_regions_no_overlap(Region, Region), - terr_regions_insufficiently_polymorphic(BoundRegion, Region), - terr_regions_overly_polymorphic(BoundRegion, Region), - terr_sorts(expected_found>), - terr_integer_as_char, - terr_int_mismatch(expected_found), - terr_float_mismatch(expected_found), - terr_traits(expected_found), - terr_builtin_bounds(expected_found), - terr_variadic_mismatch(expected_found), - terr_cyclic_ty, - terr_convergence_mismatch(expected_found), - terr_projection_name_mismatched(expected_found), - terr_projection_bounds_length(expected_found), +pub enum TypeError<'tcx> { + Mismatch, + UnsafetyMismatch(ExpectedFound), + AbiMismatch(ExpectedFound), + Mutability, + BoxMutability, + PtrMutability, + RefMutability, + VecMutability, + TupleSize(ExpectedFound), + FixedArraySize(ExpectedFound), + TyParamSize(ExpectedFound), + ArgCount, + RegionsDoesNotOutlive(Region, Region), + RegionsNotSame(Region, Region), + RegionsNoOverlap(Region, Region), + RegionsInsufficientlyPolymorphic(BoundRegion, Region), + RegionsOverlyPolymorphic(BoundRegion, Region), + Sorts(ExpectedFound>), + IntegerAsChar, + IntMismatch(ExpectedFound), + FloatMismatch(ExpectedFound), + Traits(ExpectedFound), + BuiltinBoundsMismatch(ExpectedFound), + VariadicMismatch(ExpectedFound), + CyclicTy, + ConvergenceMismatch(ExpectedFound), + ProjectionNameMismatched(ExpectedFound), + ProjectionBoundsLength(ExpectedFound), } /// Bounds suitable for an existentially quantified type parameter @@ -3573,28 +3565,28 @@ impl<'tcx> ctxt<'tcx> { self.mk_ty(TyBox(ty)) } - pub fn mk_ptr(&self, tm: mt<'tcx>) -> Ty<'tcx> { + pub fn mk_ptr(&self, tm: TypeWithMutability<'tcx>) -> Ty<'tcx> { self.mk_ty(TyRawPtr(tm)) } - pub fn mk_ref(&self, r: &'tcx Region, tm: mt<'tcx>) -> Ty<'tcx> { + pub fn mk_ref(&self, r: &'tcx Region, tm: TypeWithMutability<'tcx>) -> Ty<'tcx> { self.mk_ty(TyRef(r, tm)) } pub fn mk_mut_ref(&self, r: &'tcx Region, ty: Ty<'tcx>) -> Ty<'tcx> { - self.mk_ref(r, mt {ty: ty, mutbl: ast::MutMutable}) + self.mk_ref(r, TypeWithMutability {ty: ty, mutbl: ast::MutMutable}) } pub fn mk_imm_ref(&self, r: &'tcx Region, ty: Ty<'tcx>) -> Ty<'tcx> { - self.mk_ref(r, mt {ty: ty, mutbl: ast::MutImmutable}) + self.mk_ref(r, TypeWithMutability {ty: ty, mutbl: ast::MutImmutable}) } pub fn mk_mut_ptr(&self, ty: Ty<'tcx>) -> Ty<'tcx> { - self.mk_ptr(mt {ty: ty, mutbl: ast::MutMutable}) + self.mk_ptr(TypeWithMutability {ty: ty, mutbl: ast::MutMutable}) } pub fn mk_imm_ptr(&self, ty: Ty<'tcx>) -> Ty<'tcx> { - self.mk_ptr(mt {ty: ty, mutbl: ast::MutImmutable}) + self.mk_ptr(TypeWithMutability {ty: ty, mutbl: ast::MutImmutable}) } pub fn mk_nil_ptr(&self) -> Ty<'tcx> { @@ -4278,7 +4270,7 @@ impl<'tcx> TyS<'tcx> { } fn tc_mt<'tcx>(cx: &ctxt<'tcx>, - mt: mt<'tcx>, + mt: TypeWithMutability<'tcx>, cache: &mut FnvHashMap, TypeContents>) -> TypeContents { let mc = TC::ReachesMutable.when(mt.mutbl == MutMutable); @@ -4350,11 +4342,11 @@ impl<'tcx> TyS<'tcx> { // Fast-path for primitive types let result = match self.sty { TyBool | TyChar | TyInt(..) | TyUint(..) | TyFloat(..) | - TyRawPtr(..) | TyBareFn(..) | TyRef(_, mt { + TyRawPtr(..) | TyBareFn(..) | TyRef(_, TypeWithMutability { mutbl: ast::MutImmutable, .. }) => Some(false), - TyStr | TyBox(..) | TyRef(_, mt { + TyStr | TyBox(..) | TyRef(_, TypeWithMutability { mutbl: ast::MutMutable, .. }) => Some(true), @@ -4789,10 +4781,10 @@ impl<'tcx> TyS<'tcx> { // // The parameter `explicit` indicates if this is an *explicit* dereference. // Some types---notably unsafe ptrs---can only be dereferenced explicitly. - pub fn builtin_deref(&self, explicit: bool) -> Option> { + pub fn builtin_deref(&self, explicit: bool) -> Option> { match self.sty { TyBox(ty) => { - Some(mt { + Some(TypeWithMutability { ty: ty, mutbl: ast::MutImmutable, }) @@ -4931,10 +4923,10 @@ impl<'tcx> TyS<'tcx> { match autoref { None => self, Some(AutoPtr(r, m)) => { - cx.mk_ref(r, mt { ty: self, mutbl: m }) + cx.mk_ref(r, TypeWithMutability { ty: self, mutbl: m }) } Some(AutoUnsafe(m)) => { - cx.mk_ptr(mt { ty: self, mutbl: m }) + cx.mk_ptr(TypeWithMutability { ty: self, mutbl: m }) } } } @@ -4983,67 +4975,67 @@ impl<'tcx> TyS<'tcx> { /// in parentheses after some larger message. You should also invoke `note_and_explain_type_err()` /// afterwards to present additional details, particularly when it comes to lifetime-related /// errors. -impl<'tcx> fmt::Display for type_err<'tcx> { +impl<'tcx> fmt::Display for TypeError<'tcx> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { - terr_cyclic_ty => write!(f, "cyclic type of infinite size"), - terr_mismatch => write!(f, "types differ"), - terr_unsafety_mismatch(values) => { + CyclicTy => write!(f, "cyclic type of infinite size"), + Mismatch => write!(f, "types differ"), + UnsafetyMismatch(values) => { write!(f, "expected {} fn, found {} fn", values.expected, values.found) } - terr_abi_mismatch(values) => { + AbiMismatch(values) => { write!(f, "expected {} fn, found {} fn", values.expected, values.found) } - terr_mutability => write!(f, "values differ in mutability"), - terr_box_mutability => { + Mutability => write!(f, "values differ in mutability"), + BoxMutability => { write!(f, "boxed values differ in mutability") } - terr_vec_mutability => write!(f, "vectors differ in mutability"), - terr_ptr_mutability => write!(f, "pointers differ in mutability"), - terr_ref_mutability => write!(f, "references differ in mutability"), - terr_ty_param_size(values) => { + VecMutability => write!(f, "vectors differ in mutability"), + PtrMutability => write!(f, "pointers differ in mutability"), + RefMutability => write!(f, "references differ in mutability"), + TyParamSize(values) => { write!(f, "expected a type with {} type params, \ found one with {} type params", values.expected, values.found) } - terr_fixed_array_size(values) => { + FixedArraySize(values) => { write!(f, "expected an array with a fixed size of {} elements, \ found one with {} elements", values.expected, values.found) } - terr_tuple_size(values) => { + TupleSize(values) => { write!(f, "expected a tuple with {} elements, \ found one with {} elements", values.expected, values.found) } - terr_arg_count => { + ArgCount => { write!(f, "incorrect number of function parameters") } - terr_regions_does_not_outlive(..) => { + RegionsDoesNotOutlive(..) => { write!(f, "lifetime mismatch") } - terr_regions_not_same(..) => { + RegionsNotSame(..) => { write!(f, "lifetimes are not the same") } - terr_regions_no_overlap(..) => { + RegionsNoOverlap(..) => { write!(f, "lifetimes do not intersect") } - terr_regions_insufficiently_polymorphic(br, _) => { + RegionsInsufficientlyPolymorphic(br, _) => { write!(f, "expected bound lifetime parameter {}, \ found concrete lifetime", br) } - terr_regions_overly_polymorphic(br, _) => { + RegionsOverlyPolymorphic(br, _) => { write!(f, "expected concrete lifetime, \ found bound lifetime parameter {}", br) } - terr_sorts(values) => tls::with(|tcx| { + Sorts(values) => tls::with(|tcx| { // A naive approach to making sure that we're not reporting silly errors such as: // (expected closure, found closure). let expected_str = values.expected.sort_string(tcx); @@ -5054,12 +5046,12 @@ impl<'tcx> fmt::Display for type_err<'tcx> { write!(f, "expected {}, found {}", expected_str, found_str) } }), - terr_traits(values) => tls::with(|tcx| { + Traits(values) => tls::with(|tcx| { write!(f, "expected trait `{}`, found trait `{}`", tcx.item_path_str(values.expected), tcx.item_path_str(values.found)) }), - terr_builtin_bounds(values) => { + BuiltinBoundsMismatch(values) => { if values.expected.is_empty() { write!(f, "expected no bounds, found `{}`", values.found) @@ -5072,35 +5064,35 @@ impl<'tcx> fmt::Display for type_err<'tcx> { values.found) } } - terr_integer_as_char => { + IntegerAsChar => { write!(f, "expected an integral type, found `char`") } - terr_int_mismatch(ref values) => { + IntMismatch(ref values) => { write!(f, "expected `{:?}`, found `{:?}`", values.expected, values.found) } - terr_float_mismatch(ref values) => { + FloatMismatch(ref values) => { write!(f, "expected `{:?}`, found `{:?}`", values.expected, values.found) } - terr_variadic_mismatch(ref values) => { + VariadicMismatch(ref values) => { write!(f, "expected {} fn, found {} function", if values.expected { "variadic" } else { "non-variadic" }, if values.found { "variadic" } else { "non-variadic" }) } - terr_convergence_mismatch(ref values) => { + ConvergenceMismatch(ref values) => { write!(f, "expected {} fn, found {} function", if values.expected { "converging" } else { "diverging" }, if values.found { "converging" } else { "diverging" }) } - terr_projection_name_mismatched(ref values) => { + ProjectionNameMismatched(ref values) => { write!(f, "expected {}, found {}", values.expected, values.found) } - terr_projection_bounds_length(ref values) => { + ProjectionBoundsLength(ref values) => { write!(f, "expected {} associated type bindings, found {}", values.expected, values.found) @@ -5408,7 +5400,7 @@ impl<'tcx> ctxt<'tcx> { } } - pub fn field_idx_strict(&self, name: ast::Name, fields: &[field]) + pub fn field_idx_strict(&self, name: ast::Name, fields: &[Field<'tcx>]) -> usize { let mut i = 0; for f in fields { if f.name == name { return i; } i += 1; } @@ -5420,36 +5412,36 @@ impl<'tcx> ctxt<'tcx> { .collect::>())); } - pub fn note_and_explain_type_err(&self, err: &type_err<'tcx>, sp: Span) { + pub fn note_and_explain_type_err(&self, err: &TypeError<'tcx>, sp: Span) { match *err { - terr_regions_does_not_outlive(subregion, superregion) => { + RegionsDoesNotOutlive(subregion, superregion) => { self.note_and_explain_region("", subregion, "..."); self.note_and_explain_region("...does not necessarily outlive ", superregion, ""); } - terr_regions_not_same(region1, region2) => { + RegionsNotSame(region1, region2) => { self.note_and_explain_region("", region1, "..."); self.note_and_explain_region("...is not the same lifetime as ", region2, ""); } - terr_regions_no_overlap(region1, region2) => { + RegionsNoOverlap(region1, region2) => { self.note_and_explain_region("", region1, "..."); self.note_and_explain_region("...does not overlap ", region2, ""); } - terr_regions_insufficiently_polymorphic(_, conc_region) => { + RegionsInsufficientlyPolymorphic(_, conc_region) => { self.note_and_explain_region("concrete lifetime that was found is ", conc_region, ""); } - terr_regions_overly_polymorphic(_, ty::ReInfer(ty::ReVar(_))) => { + RegionsOverlyPolymorphic(_, ty::ReInfer(ty::ReVar(_))) => { // don't bother to print out the message below for // inference variables, it's not very illuminating. } - terr_regions_overly_polymorphic(_, conc_region) => { + RegionsOverlyPolymorphic(_, conc_region) => { self.note_and_explain_region("expected concrete lifetime is ", conc_region, ""); } - terr_sorts(values) => { + Sorts(values) => { let expected_str = values.expected.sort_string(self); let found_str = values.found.sort_string(self); if expected_str == found_str && expected_str == "closure" { @@ -5960,7 +5952,7 @@ impl<'tcx> ctxt<'tcx> { // Look up the list of field names and IDs for a given struct. // Panics if the id is not bound to a struct. - pub fn lookup_struct_fields(&self, did: ast::DefId) -> Vec { + pub fn lookup_struct_fields(&self, did: ast::DefId) -> Vec { if did.krate == ast::LOCAL_CRATE { let struct_fields = self.struct_fields.borrow(); match struct_fields.get(&did) { @@ -5984,11 +5976,11 @@ impl<'tcx> ctxt<'tcx> { // Returns a list of fields corresponding to the struct's items. trans uses // this. Takes a list of substs with which to instantiate field types. pub fn struct_fields(&self, did: ast::DefId, substs: &Substs<'tcx>) - -> Vec> { + -> Vec> { self.lookup_struct_fields(did).iter().map(|f| { - field { + Field { name: f.name, - mt: mt { + mt: TypeWithMutability { ty: self.lookup_field_type(did, f.id, substs), mutbl: MutImmutable } @@ -6074,7 +6066,7 @@ impl<'tcx> ctxt<'tcx> { } UpvarCapture::ByRef(borrow) => { tcx.mk_ref(tcx.mk_region(borrow.region), - ty::mt { + ty::TypeWithMutability { ty: freevar_ty, mutbl: borrow.kind.to_mutbl_lossy(), }) @@ -6427,7 +6419,7 @@ impl<'tcx> ctxt<'tcx> { h.as_str().hash(state); did.node.hash(state); }; - let mt = |state: &mut SipHasher, mt: mt| { + let mt = |state: &mut SipHasher, mt: TypeWithMutability| { mt.mutbl.hash(state); }; let fn_sig = |state: &mut SipHasher, sig: &Binder>| { @@ -7222,7 +7214,7 @@ impl<'tcx> HasTypeFlags for FnSig<'tcx> { } } -impl<'tcx> HasTypeFlags for field<'tcx> { +impl<'tcx> HasTypeFlags for Field<'tcx> { fn has_type_flags(&self, flags: TypeFlags) -> bool { self.mt.ty.has_type_flags(flags) } @@ -7251,7 +7243,7 @@ impl<'tcx> fmt::Debug for ClosureUpvar<'tcx> { } } -impl<'tcx> fmt::Debug for field<'tcx> { +impl<'tcx> fmt::Debug for Field<'tcx> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "field({},{})", self.name, self.mt) } diff --git a/src/librustc/middle/ty_fold.rs b/src/librustc/middle/ty_fold.rs index 7016c148465..7f2897fb9f5 100644 --- a/src/librustc/middle/ty_fold.rs +++ b/src/librustc/middle/ty_fold.rs @@ -85,7 +85,7 @@ pub trait TypeFolder<'tcx> : Sized { super_fold_ty(self, t) } - fn fold_mt(&mut self, t: &ty::mt<'tcx>) -> ty::mt<'tcx> { + fn fold_mt(&mut self, t: &ty::TypeWithMutability<'tcx>) -> ty::TypeWithMutability<'tcx> { super_fold_mt(self, t) } @@ -251,8 +251,8 @@ impl<'tcx> TypeFoldable<'tcx> for ty::ClosureTy<'tcx> { } } -impl<'tcx> TypeFoldable<'tcx> for ty::mt<'tcx> { - fn fold_with>(&self, folder: &mut F) -> ty::mt<'tcx> { +impl<'tcx> TypeFoldable<'tcx> for ty::TypeWithMutability<'tcx> { + fn fold_with>(&self, folder: &mut F) -> ty::TypeWithMutability<'tcx> { folder.fold_mt(self) } } @@ -275,9 +275,9 @@ impl<'tcx> TypeFoldable<'tcx> for ty::TraitRef<'tcx> { } } -impl<'tcx> TypeFoldable<'tcx> for ty::field<'tcx> { - fn fold_with>(&self, folder: &mut F) -> ty::field<'tcx> { - ty::field { +impl<'tcx> TypeFoldable<'tcx> for ty::Field<'tcx> { + fn fold_with>(&self, folder: &mut F) -> ty::Field<'tcx> { + ty::Field { name: self.name, mt: self.mt.fold_with(folder), } @@ -685,9 +685,9 @@ pub fn super_fold_trait_ref<'tcx, T: TypeFolder<'tcx>>(this: &mut T, } pub fn super_fold_mt<'tcx, T: TypeFolder<'tcx>>(this: &mut T, - mt: &ty::mt<'tcx>) - -> ty::mt<'tcx> { - ty::mt {ty: mt.ty.fold_with(this), + mt: &ty::TypeWithMutability<'tcx>) + -> ty::TypeWithMutability<'tcx> { + ty::TypeWithMutability {ty: mt.ty.fold_with(this), mutbl: mt.mutbl} } diff --git a/src/librustc/middle/ty_match.rs b/src/librustc/middle/ty_match.rs index 5776235780a..d2d9a0f6cbe 100644 --- a/src/librustc/middle/ty_match.rs +++ b/src/librustc/middle/ty_match.rs @@ -78,7 +78,7 @@ impl<'a, 'tcx> TypeRelation<'a, 'tcx> for Match<'a, 'tcx> { (&ty::TyInfer(_), _) | (_, &ty::TyInfer(_)) => { - Err(ty::terr_sorts(ty_relate::expected_found(self, &a, &b))) + Err(ty::Sorts(ty_relate::expected_found(self, &a, &b))) } (&ty::TyError, _) | (_, &ty::TyError) => { diff --git a/src/librustc/middle/ty_relate/mod.rs b/src/librustc/middle/ty_relate/mod.rs index b8b2469b206..2a66a41f372 100644 --- a/src/librustc/middle/ty_relate/mod.rs +++ b/src/librustc/middle/ty_relate/mod.rs @@ -20,7 +20,7 @@ use std::rc::Rc; use syntax::abi; use syntax::ast; -pub type RelateResult<'tcx, T> = Result>; +pub type RelateResult<'tcx, T> = Result>; #[derive(Clone, Debug)] pub enum Cause { @@ -89,11 +89,11 @@ pub trait Relate<'a,'tcx>: TypeFoldable<'tcx> { /////////////////////////////////////////////////////////////////////////// // Relate impls -impl<'a,'tcx:'a> Relate<'a,'tcx> for ty::mt<'tcx> { +impl<'a,'tcx:'a> Relate<'a,'tcx> for ty::TypeWithMutability<'tcx> { fn relate(relation: &mut R, - a: &ty::mt<'tcx>, - b: &ty::mt<'tcx>) - -> RelateResult<'tcx, ty::mt<'tcx>> + a: &ty::TypeWithMutability<'tcx>, + b: &ty::TypeWithMutability<'tcx>) + -> RelateResult<'tcx, ty::TypeWithMutability<'tcx>> where R: TypeRelation<'a,'tcx> { debug!("{}.mts({:?}, {:?})", @@ -101,7 +101,7 @@ impl<'a,'tcx:'a> Relate<'a,'tcx> for ty::mt<'tcx> { a, b); if a.mutbl != b.mutbl { - Err(ty::terr_mutability) + Err(ty::Mutability) } else { let mutbl = a.mutbl; let variance = match mutbl { @@ -109,7 +109,7 @@ impl<'a,'tcx:'a> Relate<'a,'tcx> for ty::mt<'tcx> { ast::MutMutable => ty::Invariant, }; let ty = try!(relation.relate_with_variance(variance, &a.ty, &b.ty)); - Ok(ty::mt {ty: ty, mutbl: mutbl}) + Ok(ty::TypeWithMutability {ty: ty, mutbl: mutbl}) } } } @@ -186,7 +186,7 @@ fn relate_type_params<'a,'tcx:'a,R>(relation: &mut R, where R: TypeRelation<'a,'tcx> { if a_tys.len() != b_tys.len() { - return Err(ty::terr_ty_param_size(expected_found(relation, + return Err(ty::TyParamSize(expected_found(relation, &a_tys.len(), &b_tys.len()))); } @@ -256,7 +256,7 @@ impl<'a,'tcx:'a> Relate<'a,'tcx> for ty::FnSig<'tcx> { where R: TypeRelation<'a,'tcx> { if a.variadic != b.variadic { - return Err(ty::terr_variadic_mismatch( + return Err(ty::VariadicMismatch( expected_found(relation, &a.variadic, &b.variadic))); } @@ -270,7 +270,7 @@ impl<'a,'tcx:'a> Relate<'a,'tcx> for ty::FnSig<'tcx> { (ty::FnDiverging, ty::FnDiverging) => Ok(ty::FnDiverging), (a, b) => - Err(ty::terr_convergence_mismatch( + Err(ty::ConvergenceMismatch( expected_found(relation, &(a != ty::FnDiverging), &(b != ty::FnDiverging)))), }); @@ -287,7 +287,7 @@ fn relate_arg_vecs<'a,'tcx:'a,R>(relation: &mut R, where R: TypeRelation<'a,'tcx> { if a_args.len() != b_args.len() { - return Err(ty::terr_arg_count); + return Err(ty::ArgCount); } a_args.iter().zip(b_args) @@ -303,7 +303,7 @@ impl<'a,'tcx:'a> Relate<'a,'tcx> for ast::Unsafety { where R: TypeRelation<'a,'tcx> { if a != b { - Err(ty::terr_unsafety_mismatch(expected_found(relation, a, b))) + Err(ty::UnsafetyMismatch(expected_found(relation, a, b))) } else { Ok(*a) } @@ -320,7 +320,7 @@ impl<'a,'tcx:'a> Relate<'a,'tcx> for abi::Abi { if a == b { Ok(*a) } else { - Err(ty::terr_abi_mismatch(expected_found(relation, a, b))) + Err(ty::AbiMismatch(expected_found(relation, a, b))) } } } @@ -333,7 +333,7 @@ impl<'a,'tcx:'a> Relate<'a,'tcx> for ty::ProjectionTy<'tcx> { where R: TypeRelation<'a,'tcx> { if a.item_name != b.item_name { - Err(ty::terr_projection_name_mismatched( + Err(ty::ProjectionNameMismatched( expected_found(relation, &a.item_name, &b.item_name))) } else { let trait_ref = try!(relation.relate(&a.trait_ref, &b.trait_ref)); @@ -368,7 +368,7 @@ impl<'a,'tcx:'a> Relate<'a,'tcx> for Vec> { // so we can just iterate through the lists pairwise, so long as they are the // same length. if a.len() != b.len() { - Err(ty::terr_projection_bounds_length(expected_found(relation, &a.len(), &b.len()))) + Err(ty::ProjectionBoundsLength(expected_found(relation, &a.len(), &b.len()))) } else { a.iter().zip(b) .map(|(a, b)| relation.relate(a, b)) @@ -412,7 +412,7 @@ impl<'a,'tcx:'a> Relate<'a,'tcx> for ty::BuiltinBounds { // Two sets of builtin bounds are only relatable if they are // precisely the same (but see the coercion code). if a != b { - Err(ty::terr_builtin_bounds(expected_found(relation, a, b))) + Err(ty::BuiltinBoundsMismatch(expected_found(relation, a, b))) } else { Ok(*a) } @@ -428,7 +428,7 @@ impl<'a,'tcx:'a> Relate<'a,'tcx> for ty::TraitRef<'tcx> { { // Different traits cannot be related if a.def_id != b.def_id { - Err(ty::terr_traits(expected_found(relation, &a.def_id, &b.def_id))) + Err(ty::Traits(expected_found(relation, &a.def_id, &b.def_id))) } else { let substs = try!(relate_item_substs(relation, a.def_id, a.substs, b.substs)); Ok(ty::TraitRef { def_id: a.def_id, substs: relation.tcx().mk_substs(substs) }) @@ -547,7 +547,7 @@ pub fn super_relate_tys<'a,'tcx:'a,R>(relation: &mut R, if sz_a == sz_b { Ok(tcx.mk_array(t, sz_a)) } else { - Err(ty::terr_fixed_array_size(expected_found(relation, &sz_a, &sz_b))) + Err(ty::FixedArraySize(expected_found(relation, &sz_a, &sz_b))) } } @@ -565,10 +565,10 @@ pub fn super_relate_tys<'a,'tcx:'a,R>(relation: &mut R, .collect::>()); Ok(tcx.mk_tup(ts)) } else if !(as_.is_empty() || bs.is_empty()) { - Err(ty::terr_tuple_size( + Err(ty::TupleSize( expected_found(relation, &as_.len(), &bs.len()))) } else { - Err(ty::terr_sorts(expected_found(relation, &a, &b))) + Err(ty::Sorts(expected_found(relation, &a, &b))) } } @@ -587,7 +587,7 @@ pub fn super_relate_tys<'a,'tcx:'a,R>(relation: &mut R, _ => { - Err(ty::terr_sorts(expected_found(relation, &a, &b))) + Err(ty::Sorts(expected_found(relation, &a, &b))) } } } @@ -652,7 +652,7 @@ impl<'a,'tcx:'a,T> Relate<'a,'tcx> for Box pub fn expected_found<'a,'tcx:'a,R,T>(relation: &mut R, a: &T, b: &T) - -> ty::expected_found + -> ty::ExpectedFound where R: TypeRelation<'a,'tcx>, T: Clone { expected_found_bool(relation.a_is_expected(), a, b) @@ -661,14 +661,14 @@ pub fn expected_found<'a,'tcx:'a,R,T>(relation: &mut R, pub fn expected_found_bool(a_is_expected: bool, a: &T, b: &T) - -> ty::expected_found + -> ty::ExpectedFound where T: Clone { let a = a.clone(); let b = b.clone(); if a_is_expected { - ty::expected_found {expected: a, found: b} + ty::ExpectedFound {expected: a, found: b} } else { - ty::expected_found {expected: b, found: a} + ty::ExpectedFound {expected: b, found: a} } } diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs index 9d82b0c2aa8..bf7681743f6 100644 --- a/src/librustc/util/ppaux.rs +++ b/src/librustc/util/ppaux.rs @@ -19,7 +19,7 @@ use middle::ty::{TyError, TyStr, TyArray, TySlice, TyFloat, TyBareFn}; use middle::ty::{TyParam, TyRawPtr, TyRef, TyTuple}; use middle::ty::TyClosure; use middle::ty::{TyBox, TyTrait, TyInt, TyUint, TyInfer}; -use middle::ty::{self, mt, Ty, HasTypeFlags}; +use middle::ty::{self, TypeWithMutability, Ty, HasTypeFlags}; use middle::ty_fold::{self, TypeFoldable}; use std::fmt; @@ -321,7 +321,7 @@ impl<'tcx> fmt::Debug for ty::TyS<'tcx> { } } -impl<'tcx> fmt::Display for ty::mt<'tcx> { +impl<'tcx> fmt::Display for ty::TypeWithMutability<'tcx> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{}{}", if self.mutbl == ast::MutMutable { "mut " } else { "" }, diff --git a/src/librustc_trans/trans/adt.rs b/src/librustc_trans/trans/adt.rs index eca9891c57c..83cfcb0b623 100644 --- a/src/librustc_trans/trans/adt.rs +++ b/src/librustc_trans/trans/adt.rs @@ -398,7 +398,7 @@ fn find_discr_field_candidate<'tcx>(tcx: &ty::ctxt<'tcx>, mut path: DiscrField) -> Option { match ty.sty { // Fat &T/&mut T/Box i.e. T is [T], str, or Trait - ty::TyRef(_, ty::mt { ty, .. }) | ty::TyBox(ty) if !type_is_sized(tcx, ty) => { + ty::TyRef(_, ty::TypeWithMutability { ty, .. }) | ty::TyBox(ty) if !type_is_sized(tcx, ty) => { path.push(FAT_PTR_ADDR); Some(path) }, @@ -415,7 +415,7 @@ fn find_discr_field_candidate<'tcx>(tcx: &ty::ctxt<'tcx>, assert_eq!(nonzero_fields.len(), 1); let nonzero_field = tcx.lookup_field_type(did, nonzero_fields[0].id, substs); match nonzero_field.sty { - ty::TyRawPtr(ty::mt { ty, .. }) if !type_is_sized(tcx, ty) => { + ty::TyRawPtr(ty::TypeWithMutability { ty, .. }) if !type_is_sized(tcx, ty) => { path.push_all(&[0, FAT_PTR_ADDR]); Some(path) }, diff --git a/src/librustc_trans/trans/attributes.rs b/src/librustc_trans/trans/attributes.rs index 25cde149df1..3f0dd83975c 100644 --- a/src/librustc_trans/trans/attributes.rs +++ b/src/librustc_trans/trans/attributes.rs @@ -223,7 +223,7 @@ pub fn from_fn_type<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, fn_type: ty::Ty<'tcx // We can also mark the return value as `dereferenceable` in certain cases match ret_ty.sty { // These are not really pointers but pairs, (pointer, len) - ty::TyRef(_, ty::mt { ty: inner, .. }) + ty::TyRef(_, ty::TypeWithMutability { ty: inner, .. }) | ty::TyBox(inner) if common::type_is_sized(ccx.tcx(), inner) => { let llret_sz = machine::llsize_of_real(ccx, type_of::type_of(ccx, inner)); attrs.ret(llvm::DereferenceableAttribute(llret_sz)); diff --git a/src/librustc_trans/trans/common.rs b/src/librustc_trans/trans/common.rs index a4559708bf4..ba48a9f92a4 100644 --- a/src/librustc_trans/trans/common.rs +++ b/src/librustc_trans/trans/common.rs @@ -130,8 +130,8 @@ pub fn type_is_sized<'tcx>(tcx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> bool { pub fn type_is_fat_ptr<'tcx>(cx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> bool { match ty.sty { - ty::TyRawPtr(ty::mt{ty, ..}) | - ty::TyRef(_, ty::mt{ty, ..}) | + ty::TyRawPtr(ty::TypeWithMutability{ty, ..}) | + ty::TyRef(_, ty::TypeWithMutability{ty, ..}) | ty::TyBox(ty) => { !type_is_sized(cx, ty) } diff --git a/src/librustc_trans/trans/consts.rs b/src/librustc_trans/trans/consts.rs index ece52b3ad4d..785efd75ce3 100644 --- a/src/librustc_trans/trans/consts.rs +++ b/src/librustc_trans/trans/consts.rs @@ -621,7 +621,7 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, let len = unsafe { llvm::LLVMConstIntGetZExtValue(len) as u64 }; let len = match bt.sty { - ty::TyBox(ty) | ty::TyRef(_, ty::mt{ty, ..}) => match ty.sty { + ty::TyBox(ty) | ty::TyRef(_, ty::TypeWithMutability{ty, ..}) => match ty.sty { ty::TyStr => { assert!(len > 0); len - 1 diff --git a/src/librustc_trans/trans/debuginfo/metadata.rs b/src/librustc_trans/trans/debuginfo/metadata.rs index 45349969a0b..ce9192d6ada 100644 --- a/src/librustc_trans/trans/debuginfo/metadata.rs +++ b/src/librustc_trans/trans/debuginfo/metadata.rs @@ -206,7 +206,7 @@ impl<'tcx> TypeMap<'tcx> { let inner_type_id = self.get_unique_type_id_as_string(inner_type_id); unique_type_id.push_str(&inner_type_id[..]); }, - ty::TyRawPtr(ty::mt { ty: inner_type, mutbl } ) => { + ty::TyRawPtr(ty::TypeWithMutability { ty: inner_type, mutbl } ) => { unique_type_id.push('*'); if mutbl == ast::MutMutable { unique_type_id.push_str("mut"); @@ -216,7 +216,7 @@ impl<'tcx> TypeMap<'tcx> { let inner_type_id = self.get_unique_type_id_as_string(inner_type_id); unique_type_id.push_str(&inner_type_id[..]); }, - ty::TyRef(_, ty::mt { ty: inner_type, mutbl }) => { + ty::TyRef(_, ty::TypeWithMutability { ty: inner_type, mutbl }) => { unique_type_id.push('&'); if mutbl == ast::MutMutable { unique_type_id.push_str("mut"); @@ -561,7 +561,7 @@ fn vec_slice_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, unique_type_id: UniqueTypeId, span: Span) -> MetadataCreationResult { - let data_ptr_type = cx.tcx().mk_ptr(ty::mt { + let data_ptr_type = cx.tcx().mk_ptr(ty::TypeWithMutability { ty: element_type, mutbl: ast::MutImmutable }); @@ -765,7 +765,7 @@ pub fn type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, trait_pointer_metadata(cx, t, None, unique_type_id), false) } - ty::TyBox(ty) | ty::TyRawPtr(ty::mt{ty, ..}) | ty::TyRef(_, ty::mt{ty, ..}) => { + ty::TyBox(ty) | ty::TyRawPtr(ty::TypeWithMutability{ty, ..}) | ty::TyRef(_, ty::TypeWithMutability{ty, ..}) => { match ty.sty { ty::TySlice(typ) => { vec_slice_metadata(cx, t, typ, unique_type_id, usage_site_span) @@ -1113,7 +1113,7 @@ impl<'tcx> MemberDescriptionFactory<'tcx> { // Creates MemberDescriptions for the fields of a struct struct StructMemberDescriptionFactory<'tcx> { - fields: Vec>, + fields: Vec>, is_simd: bool, span: Span, } diff --git a/src/librustc_trans/trans/debuginfo/type_names.rs b/src/librustc_trans/trans/debuginfo/type_names.rs index f4116883199..4b9b9cd6646 100644 --- a/src/librustc_trans/trans/debuginfo/type_names.rs +++ b/src/librustc_trans/trans/debuginfo/type_names.rs @@ -77,7 +77,7 @@ pub fn push_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, push_debuginfo_type_name(cx, inner_type, true, output); output.push('>'); }, - ty::TyRawPtr(ty::mt { ty: inner_type, mutbl } ) => { + ty::TyRawPtr(ty::TypeWithMutability { ty: inner_type, mutbl } ) => { output.push('*'); match mutbl { ast::MutImmutable => output.push_str("const "), @@ -86,7 +86,7 @@ pub fn push_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, push_debuginfo_type_name(cx, inner_type, true, output); }, - ty::TyRef(_, ty::mt { ty: inner_type, mutbl }) => { + ty::TyRef(_, ty::TypeWithMutability { ty: inner_type, mutbl }) => { output.push('&'); if mutbl == ast::MutMutable { output.push_str("mut "); diff --git a/src/librustc_trans/trans/expr.rs b/src/librustc_trans/trans/expr.rs index 7722cb322c9..b40984444cf 100644 --- a/src/librustc_trans/trans/expr.rs +++ b/src/librustc_trans/trans/expr.rs @@ -440,9 +440,9 @@ fn coerce_unsized<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, match (&source.ty.sty, &target.ty.sty) { (&ty::TyBox(a), &ty::TyBox(b)) | - (&ty::TyRef(_, ty::mt { ty: a, .. }), &ty::TyRef(_, ty::mt { ty: b, .. })) | - (&ty::TyRef(_, ty::mt { ty: a, .. }), &ty::TyRawPtr(ty::mt { ty: b, .. })) | - (&ty::TyRawPtr(ty::mt { ty: a, .. }), &ty::TyRawPtr(ty::mt { ty: b, .. })) => { + (&ty::TyRef(_, ty::TypeWithMutability { ty: a, .. }), &ty::TyRef(_, ty::TypeWithMutability { ty: b, .. })) | + (&ty::TyRef(_, ty::TypeWithMutability { ty: a, .. }), &ty::TyRawPtr(ty::TypeWithMutability { ty: b, .. })) | + (&ty::TyRawPtr(ty::TypeWithMutability { ty: a, .. }), &ty::TyRawPtr(ty::TypeWithMutability { ty: b, .. })) => { let (inner_source, inner_target) = (a, b); let (base, old_info) = if !type_is_sized(bcx.tcx(), inner_source) { @@ -707,7 +707,7 @@ fn trans_field<'blk, 'tcx, F>(bcx: Block<'blk, 'tcx>, base: &ast::Expr, get_idx: F) -> DatumBlock<'blk, 'tcx, Expr> where - F: FnOnce(&'blk ty::ctxt<'tcx>, &[ty::field<'tcx>]) -> usize, + F: FnOnce(&'blk ty::ctxt<'tcx>, &[ty::Field<'tcx>]) -> usize, { let mut bcx = bcx; let _icx = push_ctxt("trans_rec_field"); @@ -1333,7 +1333,7 @@ pub fn with_field_tys<'tcx, R, F>(tcx: &ty::ctxt<'tcx>, node_id_opt: Option, op: F) -> R where - F: FnOnce(ty::Disr, &[ty::field<'tcx>]) -> R, + F: FnOnce(ty::Disr, &[ty::Field<'tcx>]) -> R, { match ty.sty { ty::TyStruct(did, substs) => { @@ -1344,9 +1344,9 @@ pub fn with_field_tys<'tcx, R, F>(tcx: &ty::ctxt<'tcx>, ty::TyTuple(ref v) => { let fields: Vec<_> = v.iter().enumerate().map(|(i, &f)| { - ty::field { + ty::Field { name: token::intern(&i.to_string()), - mt: ty::mt { + mt: ty::TypeWithMutability { ty: f, mutbl: ast::MutImmutable } @@ -1994,7 +1994,7 @@ pub fn cast_is_noop<'tcx>(tcx: &ty::ctxt<'tcx>, } match (t_in.builtin_deref(true), t_out.builtin_deref(true)) { - (Some(ty::mt{ ty: t_in, .. }), Some(ty::mt{ ty: t_out, .. })) => { + (Some(ty::TypeWithMutability{ ty: t_in, .. }), Some(ty::TypeWithMutability{ ty: t_out, .. })) => { t_in == t_out } _ => { @@ -2275,8 +2275,8 @@ fn deref_once<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, } } - ty::TyRawPtr(ty::mt { ty: content_ty, .. }) | - ty::TyRef(_, ty::mt { ty: content_ty, .. }) => { + ty::TyRawPtr(ty::TypeWithMutability { ty: content_ty, .. }) | + ty::TyRef(_, ty::TypeWithMutability { ty: content_ty, .. }) => { if type_is_sized(bcx.tcx(), content_ty) { let ptr = datum.to_llscalarish(bcx); diff --git a/src/librustc_trans/trans/tvec.rs b/src/librustc_trans/trans/tvec.rs index d94a0e235ee..2db86459de4 100644 --- a/src/librustc_trans/trans/tvec.rs +++ b/src/librustc_trans/trans/tvec.rs @@ -315,7 +315,7 @@ pub fn get_base_and_len<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, } // Only used for pattern matching. - ty::TyBox(ty) | ty::TyRef(_, ty::mt{ty, ..}) => { + ty::TyBox(ty) | ty::TyRef(_, ty::TypeWithMutability{ty, ..}) => { let inner = if type_is_sized(bcx.tcx(), ty) { Load(bcx, llval) } else { diff --git a/src/librustc_trans/trans/type_of.rs b/src/librustc_trans/trans/type_of.rs index 4359a8d270d..63774a983ab 100644 --- a/src/librustc_trans/trans/type_of.rs +++ b/src/librustc_trans/trans/type_of.rs @@ -193,7 +193,7 @@ pub fn sizing_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Typ ty::TyUint(t) => Type::uint_from_ty(cx, t), ty::TyFloat(t) => Type::float_from_ty(cx, t), - ty::TyBox(ty) | ty::TyRef(_, ty::mt{ty, ..}) | ty::TyRawPtr(ty::mt{ty, ..}) => { + ty::TyBox(ty) | ty::TyRef(_, ty::TypeWithMutability{ty, ..}) | ty::TyRawPtr(ty::TypeWithMutability{ty, ..}) => { if type_is_sized(cx.tcx(), ty) { Type::i8p(cx) } else { @@ -352,7 +352,7 @@ pub fn in_memory_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> adt::incomplete_type_of(cx, &*repr, "closure") } - ty::TyBox(ty) | ty::TyRef(_, ty::mt{ty, ..}) | ty::TyRawPtr(ty::mt{ty, ..}) => { + ty::TyBox(ty) | ty::TyRef(_, ty::TypeWithMutability{ty, ..}) | ty::TyRawPtr(ty::TypeWithMutability{ty, ..}) => { if !type_is_sized(cx.tcx(), ty) { if let ty::TyStr = ty.sty { // This means we get a nicer name in the output (str is always diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs index 046e83bf3fc..c8f0a632fa5 100644 --- a/src/librustc_typeck/astconv.rs +++ b/src/librustc_typeck/astconv.rs @@ -1556,7 +1556,7 @@ pub fn ast_ty_to_ty<'tcx>(this: &AstConv<'tcx>, } } ast::TyPtr(ref mt) => { - tcx.mk_ptr(ty::mt { + tcx.mk_ptr(ty::TypeWithMutability { ty: ast_ty_to_ty(this, rscope, &*mt.ty), mutbl: mt.mutbl }) @@ -1569,7 +1569,7 @@ pub fn ast_ty_to_ty<'tcx>(this: &AstConv<'tcx>, rscope, ty::ObjectLifetimeDefault::Specific(r)); let t = ast_ty_to_ty(this, rscope1, &*mt.ty); - tcx.mk_ref(tcx.mk_region(r), ty::mt {ty: t, mutbl: mt.mutbl}) + tcx.mk_ref(tcx.mk_region(r), ty::TypeWithMutability {ty: t, mutbl: mt.mutbl}) } ast::TyTup(ref fields) => { let flds = fields.iter() @@ -1755,7 +1755,7 @@ fn ty_of_method_or_bare_fn<'a, 'tcx>(this: &AstConv<'tcx>, ty::ByReferenceExplicitSelfCategory(region, mutability) => { (Some(this.tcx().mk_ref( this.tcx().mk_region(region), - ty::mt { + ty::TypeWithMutability { ty: self_info.untransformed_self_ty, mutbl: mutability })), diff --git a/src/librustc_typeck/check/_match.rs b/src/librustc_typeck/check/_match.rs index 87f867d7f90..4b0f0f6e174 100644 --- a/src/librustc_typeck/check/_match.rs +++ b/src/librustc_typeck/check/_match.rs @@ -170,7 +170,7 @@ pub fn check_pat<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, // then `x` is assigned a value of type `&M T` where M is the mutability // and T is the expected type. let region_var = fcx.infcx().next_region_var(infer::PatternRegion(pat.span)); - let mt = ty::mt { ty: expected, mutbl: mutbl }; + let mt = ty::TypeWithMutability { ty: expected, mutbl: mutbl }; let region_ty = tcx.mk_ref(tcx.mk_region(region_var), mt); // `x` is assigned a value of type `&M T`, hence `&M T <: typeof(x)` is @@ -272,7 +272,7 @@ pub fn check_pat<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, ast::PatRegion(ref inner, mutbl) => { let inner_ty = fcx.infcx().next_ty_var(); - let mt = ty::mt { ty: inner_ty, mutbl: mutbl }; + let mt = ty::TypeWithMutability { ty: inner_ty, mutbl: mutbl }; let region = fcx.infcx().next_region_var(infer::PatternRegion(pat.span)); let rptr_ty = tcx.mk_ref(tcx.mk_region(region), mt); @@ -301,7 +301,7 @@ pub fn check_pat<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, }), _ => { let region = fcx.infcx().next_region_var(infer::PatternRegion(pat.span)); - tcx.mk_ref(tcx.mk_region(region), ty::mt { + tcx.mk_ref(tcx.mk_region(region), ty::TypeWithMutability { ty: tcx.mk_slice(inner_ty), mutbl: expected_ty.builtin_deref(true).map(|mt| mt.mutbl) .unwrap_or(ast::MutImmutable) @@ -324,7 +324,7 @@ pub fn check_pat<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, let mutbl = expected_ty.builtin_deref(true) .map_or(ast::MutImmutable, |mt| mt.mutbl); - let slice_ty = tcx.mk_ref(tcx.mk_region(region), ty::mt { + let slice_ty = tcx.mk_ref(tcx.mk_region(region), ty::TypeWithMutability { ty: tcx.mk_slice(inner_ty), mutbl: mutbl }); @@ -729,7 +729,7 @@ pub fn check_pat_enum<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, pub fn check_struct_pat_fields<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>, span: Span, fields: &'tcx [Spanned], - struct_fields: &[ty::field<'tcx>], + struct_fields: &[ty::Field<'tcx>], struct_id: ast::DefId, etc: bool) { let tcx = pcx.fcx.ccx.tcx; diff --git a/src/librustc_typeck/check/cast.rs b/src/librustc_typeck/check/cast.rs index 49b47da5177..3a65b3fc082 100644 --- a/src/librustc_typeck/check/cast.rs +++ b/src/librustc_typeck/check/cast.rs @@ -272,8 +272,8 @@ impl<'tcx> CastCheck<'tcx> { fn check_ptr_ptr_cast<'a>(&self, fcx: &FnCtxt<'a, 'tcx>, - m_expr: &'tcx ty::mt<'tcx>, - m_cast: &'tcx ty::mt<'tcx>) + m_expr: &'tcx ty::TypeWithMutability<'tcx>, + m_cast: &'tcx ty::TypeWithMutability<'tcx>) -> Result { debug!("check_ptr_ptr_cast m_expr={:?} m_cast={:?}", @@ -299,7 +299,7 @@ impl<'tcx> CastCheck<'tcx> { fn check_fptr_ptr_cast<'a>(&self, fcx: &FnCtxt<'a, 'tcx>, - m_cast: &'tcx ty::mt<'tcx>) + m_cast: &'tcx ty::TypeWithMutability<'tcx>) -> Result { // fptr-ptr cast. must be to sized ptr @@ -313,7 +313,7 @@ impl<'tcx> CastCheck<'tcx> { fn check_ptr_addr_cast<'a>(&self, fcx: &FnCtxt<'a, 'tcx>, - m_expr: &'tcx ty::mt<'tcx>) + m_expr: &'tcx ty::TypeWithMutability<'tcx>) -> Result { // ptr-addr cast. must be from sized ptr @@ -327,8 +327,8 @@ impl<'tcx> CastCheck<'tcx> { fn check_ref_cast<'a>(&self, fcx: &FnCtxt<'a, 'tcx>, - m_expr: &'tcx ty::mt<'tcx>, - m_cast: &'tcx ty::mt<'tcx>) + m_expr: &'tcx ty::TypeWithMutability<'tcx>, + m_cast: &'tcx ty::TypeWithMutability<'tcx>) -> Result { // array-ptr-cast. @@ -353,7 +353,7 @@ impl<'tcx> CastCheck<'tcx> { fn check_addr_ptr_cast<'a>(&self, fcx: &FnCtxt<'a, 'tcx>, - m_cast: &'tcx ty::mt<'tcx>) + m_cast: &'tcx ty::TypeWithMutability<'tcx>) -> Result { // ptr-addr cast. pointer must be thin. diff --git a/src/librustc_typeck/check/coercion.rs b/src/librustc_typeck/check/coercion.rs index a0abef74907..51e05f52f77 100644 --- a/src/librustc_typeck/check/coercion.rs +++ b/src/librustc_typeck/check/coercion.rs @@ -66,7 +66,7 @@ use middle::infer::{self, Coercion}; use middle::traits::{self, ObligationCause}; use middle::traits::{predicate_for_trait_def, report_selection_error}; use middle::ty::{AutoDerefRef, AdjustDerefRef}; -use middle::ty::{self, mt, Ty}; +use middle::ty::{self, TypeWithMutability, Ty}; use middle::ty_relate::RelateResult; use util::common::indent; @@ -202,7 +202,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> { return None; } let ty = self.tcx().mk_ref(r_borrow, - mt {ty: inner_ty, mutbl: mutbl_b}); + TypeWithMutability {ty: inner_ty, mutbl: mutbl_b}); if let Err(err) = self.subtype(ty, b) { if first_error.is_none() { first_error = Some(err); @@ -247,7 +247,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> { (u, cu) } else { debug!("Missing Unsize or CoerceUnsized traits"); - return Err(ty::terr_mismatch); + return Err(ty::Mismatch); }; // Note, we want to avoid unnecessary unsizing. We don't want to coerce to @@ -307,7 +307,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> { // Uncertain or unimplemented. Ok(None) | Err(traits::Unimplemented) => { debug!("coerce_unsized: early return - can't prove obligation"); - return Err(ty::terr_mismatch); + return Err(ty::Mismatch); } // Object safety violations or miscellaneous. @@ -411,7 +411,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> { }; // Check that the types which they point at are compatible. - let a_unsafe = self.tcx().mk_ptr(ty::mt{ mutbl: mutbl_b, ty: mt_a.ty }); + let a_unsafe = self.tcx().mk_ptr(ty::TypeWithMutability{ mutbl: mutbl_b, ty: mt_a.ty }); try!(self.subtype(a_unsafe, b)); try!(coerce_mutbls(mt_a.mutbl, mutbl_b)); @@ -472,6 +472,6 @@ fn coerce_mutbls<'tcx>(from_mutbl: ast::Mutability, (ast::MutMutable, ast::MutMutable) | (ast::MutImmutable, ast::MutImmutable) | (ast::MutMutable, ast::MutImmutable) => Ok(None), - (ast::MutImmutable, ast::MutMutable) => Err(ty::terr_mutability) + (ast::MutImmutable, ast::MutMutable) => Err(ty::Mutability) } } diff --git a/src/librustc_typeck/check/demand.rs b/src/librustc_typeck/check/demand.rs index 392515926da..e175fd9bcfd 100644 --- a/src/librustc_typeck/check/demand.rs +++ b/src/librustc_typeck/check/demand.rs @@ -32,7 +32,7 @@ pub fn suptype_with_fn<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, ty_a: Ty<'tcx>, ty_b: Ty<'tcx>, handle_err: F) where - F: FnOnce(Span, Ty<'tcx>, Ty<'tcx>, &ty::type_err<'tcx>), + F: FnOnce(Span, Ty<'tcx>, Ty<'tcx>, &ty::TypeError<'tcx>), { // n.b.: order of actual, expected is reversed match infer::mk_subty(fcx.infcx(), b_is_expected, infer::Misc(sp), diff --git a/src/librustc_typeck/check/method/confirm.rs b/src/librustc_typeck/check/method/confirm.rs index 8db5b5e7c50..2b6705419d4 100644 --- a/src/librustc_typeck/check/method/confirm.rs +++ b/src/librustc_typeck/check/method/confirm.rs @@ -433,7 +433,7 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> { }; match sig.0.inputs[0].sty { - ty::TyRef(_, ty::mt { + ty::TyRef(_, ty::TypeWithMutability { ty: _, mutbl: ast::MutMutable, }) => {} diff --git a/src/librustc_typeck/check/method/mod.rs b/src/librustc_typeck/check/method/mod.rs index 2117cba1087..48bb02bd8a7 100644 --- a/src/librustc_typeck/check/method/mod.rs +++ b/src/librustc_typeck/check/method/mod.rs @@ -271,7 +271,7 @@ pub fn lookup_in_trait_adjusted<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, // Trait method is fn(&self) or fn(&mut self), need an // autoref. Pull the region etc out of the type of first argument. match transformed_self_ty.sty { - ty::TyRef(region, ty::mt { mutbl, ty: _ }) => { + ty::TyRef(region, ty::TypeWithMutability { mutbl, ty: _ }) => { fcx.write_adjustment(self_expr.id, ty::AdjustDerefRef(ty::AutoDerefRef { autoderefs: autoderefs, diff --git a/src/librustc_typeck/check/method/probe.rs b/src/librustc_typeck/check/method/probe.rs index c43046ba0e7..2b9dcf843cd 100644 --- a/src/librustc_typeck/check/method/probe.rs +++ b/src/librustc_typeck/check/method/probe.rs @@ -311,11 +311,11 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { let lang_def_id = self.tcx().lang_items.slice_impl(); self.assemble_inherent_impl_for_primitive(lang_def_id); } - ty::TyRawPtr(ty::mt { ty: _, mutbl: ast::MutImmutable }) => { + ty::TyRawPtr(ty::TypeWithMutability { ty: _, mutbl: ast::MutImmutable }) => { let lang_def_id = self.tcx().lang_items.const_ptr_impl(); self.assemble_inherent_impl_for_primitive(lang_def_id); } - ty::TyRawPtr(ty::mt { ty: _, mutbl: ast::MutMutable }) => { + ty::TyRawPtr(ty::TypeWithMutability { ty: _, mutbl: ast::MutMutable }) => { let lang_def_id = self.tcx().lang_items.mut_ptr_impl(); self.assemble_inherent_impl_for_primitive(lang_def_id); } @@ -951,7 +951,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { // Search through mutabilities in order to find one where pick works: [ast::MutImmutable, ast::MutMutable].iter().filter_map(|&m| { - let autoref_ty = tcx.mk_ref(region, ty::mt { + let autoref_ty = tcx.mk_ref(region, ty::TypeWithMutability { ty: step.self_ty, mutbl: m }); diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 9704bef6487..3a3a7bc76b5 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -1030,7 +1030,7 @@ fn report_cast_to_unsized_type<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, format!("cast to unsized type: `{}` as `{}`", actual, tstr) }, t_expr, None); match t_expr.sty { - ty::TyRef(_, ty::mt { mutbl: mt, .. }) => { + ty::TyRef(_, ty::TypeWithMutability { mutbl: mt, .. }) => { let mtstr = match mt { ast::MutMutable => "mut ", ast::MutImmutable => "" @@ -1577,7 +1577,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { origin: infer::TypeOrigin, sub: Ty<'tcx>, sup: Ty<'tcx>) - -> Result<(), ty::type_err<'tcx>> { + -> Result<(), ty::TypeError<'tcx>> { infer::mk_subty(self.infcx(), a_is_expected, origin, sub, sup) } @@ -1586,7 +1586,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { origin: infer::TypeOrigin, sub: Ty<'tcx>, sup: Ty<'tcx>) - -> Result<(), ty::type_err<'tcx>> { + -> Result<(), ty::TypeError<'tcx>> { infer::mk_eqty(self.infcx(), a_is_expected, origin, sub, sup) } @@ -1601,7 +1601,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { sp: Span, mk_msg: M, actual_ty: Ty<'tcx>, - err: Option<&ty::type_err<'tcx>>) where + err: Option<&ty::TypeError<'tcx>>) where M: FnOnce(String) -> String, { self.infcx().type_error_message(sp, mk_msg, actual_ty, err); @@ -1611,7 +1611,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { sp: Span, e: Ty<'tcx>, a: Ty<'tcx>, - err: &ty::type_err<'tcx>) { + err: &ty::TypeError<'tcx>) { self.infcx().report_mismatched_types(sp, e, a, err) } @@ -1675,7 +1675,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { pub fn lookup_field_ty(&self, span: Span, class_id: ast::DefId, - items: &[ty::field_ty], + items: &[ty::FieldTy], fieldname: ast::Name, substs: &subst::Substs<'tcx>) -> Option> @@ -1688,7 +1688,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { pub fn lookup_tup_field_ty(&self, span: Span, class_id: ast::DefId, - items: &[ty::field_ty], + items: &[ty::FieldTy], idx: usize, substs: &subst::Substs<'tcx>) -> Option> @@ -1895,7 +1895,7 @@ fn try_overloaded_deref<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, base_expr: Option<&ast::Expr>, base_ty: Ty<'tcx>, lvalue_pref: LvaluePreference) - -> Option> + -> Option> { // Try DerefMut first, if preferred. let method = match (lvalue_pref, fcx.tcx().lang_items.deref_mut_trait()) { @@ -1926,7 +1926,7 @@ fn try_overloaded_deref<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, fn make_overloaded_lvalue_return_type<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, method_call: Option, method: Option>) - -> Option> + -> Option> { match method { Some(method) => { @@ -2777,7 +2777,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, class_id: ast::DefId, node_id: ast::NodeId, substitutions: &'tcx subst::Substs<'tcx>, - field_types: &[ty::field_ty], + field_types: &[ty::FieldTy], ast_fields: &'tcx [ast::Field], check_completeness: bool, enum_id_opt: Option) { @@ -3111,7 +3111,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, hint, lvalue_pref); - let tm = ty::mt { ty: fcx.expr_ty(&**oprnd), mutbl: mutbl }; + let tm = ty::TypeWithMutability { ty: fcx.expr_ty(&**oprnd), mutbl: mutbl }; let oprnd_t = if tm.ty.references_error() { tcx.types.err } else { @@ -4909,13 +4909,13 @@ pub fn check_intrinsic_type(ccx: &CrateCtxt, it: &ast::ForeignItem) { "offset" | "arith_offset" => { (1, vec!( - tcx.mk_ptr(ty::mt { + tcx.mk_ptr(ty::TypeWithMutability { ty: param(ccx, 0), mutbl: ast::MutImmutable }), ccx.tcx.types.isize ), - tcx.mk_ptr(ty::mt { + tcx.mk_ptr(ty::TypeWithMutability { ty: param(ccx, 0), mutbl: ast::MutImmutable })) @@ -4923,11 +4923,11 @@ pub fn check_intrinsic_type(ccx: &CrateCtxt, it: &ast::ForeignItem) { "copy" | "copy_nonoverlapping" => { (1, vec!( - tcx.mk_ptr(ty::mt { + tcx.mk_ptr(ty::TypeWithMutability { ty: param(ccx, 0), mutbl: ast::MutImmutable }), - tcx.mk_ptr(ty::mt { + tcx.mk_ptr(ty::TypeWithMutability { ty: param(ccx, 0), mutbl: ast::MutMutable }), @@ -4938,11 +4938,11 @@ pub fn check_intrinsic_type(ccx: &CrateCtxt, it: &ast::ForeignItem) { "volatile_copy_memory" | "volatile_copy_nonoverlapping_memory" => { (1, vec!( - tcx.mk_ptr(ty::mt { + tcx.mk_ptr(ty::TypeWithMutability { ty: param(ccx, 0), mutbl: ast::MutMutable }), - tcx.mk_ptr(ty::mt { + tcx.mk_ptr(ty::TypeWithMutability { ty: param(ccx, 0), mutbl: ast::MutImmutable }), @@ -4953,7 +4953,7 @@ pub fn check_intrinsic_type(ccx: &CrateCtxt, it: &ast::ForeignItem) { "write_bytes" | "volatile_set_memory" => { (1, vec!( - tcx.mk_ptr(ty::mt { + tcx.mk_ptr(ty::TypeWithMutability { ty: param(ccx, 0), mutbl: ast::MutMutable }), diff --git a/src/librustc_typeck/coherence/mod.rs b/src/librustc_typeck/coherence/mod.rs index 20407e927f7..078c66fc262 100644 --- a/src/librustc_typeck/coherence/mod.rs +++ b/src/librustc_typeck/coherence/mod.rs @@ -450,11 +450,11 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { let infcx = new_infer_ctxt(tcx, &tcx.tables, Some(param_env), true); - let check_mutbl = |mt_a: ty::mt<'tcx>, mt_b: ty::mt<'tcx>, + let check_mutbl = |mt_a: ty::TypeWithMutability<'tcx>, mt_b: ty::TypeWithMutability<'tcx>, mk_ptr: &Fn(Ty<'tcx>) -> Ty<'tcx>| { if (mt_a.mutbl, mt_b.mutbl) == (ast::MutImmutable, ast::MutMutable) { infcx.report_mismatched_types(span, mk_ptr(mt_b.ty), - target, &ty::terr_mutability); + target, &ty::Mutability); } (mt_a.ty, mt_b.ty, unsize_trait, None) }; diff --git a/src/librustc_typeck/coherence/orphan.rs b/src/librustc_typeck/coherence/orphan.rs index e585b8cd2bd..0190e5274c4 100644 --- a/src/librustc_typeck/coherence/orphan.rs +++ b/src/librustc_typeck/coherence/orphan.rs @@ -100,14 +100,14 @@ impl<'cx, 'tcx> OrphanChecker<'cx, 'tcx> { "[T]", item.span); } - ty::TyRawPtr(ty::mt { ty: _, mutbl: ast::MutImmutable }) => { + ty::TyRawPtr(ty::TypeWithMutability { ty: _, mutbl: ast::MutImmutable }) => { self.check_primitive_impl(def_id, self.tcx.lang_items.const_ptr_impl(), "const_ptr", "*const T", item.span); } - ty::TyRawPtr(ty::mt { ty: _, mutbl: ast::MutMutable }) => { + ty::TyRawPtr(ty::TypeWithMutability { ty: _, mutbl: ast::MutMutable }) => { self.check_primitive_impl(def_id, self.tcx.lang_items.mut_ptr_impl(), "mut_ptr", diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index e170808ad07..efbbae34e28 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -655,7 +655,7 @@ fn convert_field<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, struct_predicates: &ty::GenericPredicates<'tcx>, v: &ast::StructField, origin: ast::DefId) - -> ty::field_ty + -> ty::FieldTy { let tt = ccx.icx(struct_predicates).to_ty(&ExplicitRscope, &*v.node.ty); write_ty_to_tcx(ccx.tcx, v.node.id, tt); @@ -671,7 +671,7 @@ fn convert_field<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, match v.node.kind { ast::NamedField(ident, visibility) => { - ty::field_ty { + ty::FieldTy { name: ident.name, id: local_def(v.node.id), vis: visibility, @@ -679,7 +679,7 @@ fn convert_field<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, } } ast::UnnamedField(visibility) => { - ty::field_ty { + ty::FieldTy { name: special_idents::unnamed_field.name, id: local_def(v.node.id), vis: visibility, diff --git a/src/librustc_typeck/variance.rs b/src/librustc_typeck/variance.rs index c1f9725fc81..346ecf58276 100644 --- a/src/librustc_typeck/variance.rs +++ b/src/librustc_typeck/variance.rs @@ -1074,7 +1074,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { /// appearing in a context with ambient variance `variance` fn add_constraints_from_mt(&mut self, generics: &ty::Generics<'tcx>, - mt: &ty::mt<'tcx>, + mt: &ty::TypeWithMutability<'tcx>, variance: VarianceTermPtr<'a>) { match mt.mutbl { ast::MutMutable => { diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index c25267520cc..710aa72099c 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1729,7 +1729,7 @@ impl Clean for ast::StructField { } } -impl Clean for ty::field_ty { +impl Clean for ty::FieldTy { fn clean(&self, cx: &DocContext) -> Item { use syntax::parse::token::special_idents::unnamed_field; use rustc::metadata::csearch;