diff options
| author | bors <bors@rust-lang.org> | 2015-07-12 19:22:11 +0000 |
|---|---|---|
| committer | bors <bors@rust-lang.org> | 2015-07-12 19:22:11 +0000 |
| commit | adcae006d250e40d7369d9bee3ecd05915acb22d (patch) | |
| tree | a8fb2092c3dc11a434b0f46cc077e57fffe3a9a2 /src | |
| parent | 50d305e498c29c022c5bca2726d22e9f09b0a437 (diff) | |
| parent | 19218ee2a34a8c92bbbfc4a8e24e99ed04198979 (diff) | |
| download | rust-adcae006d250e40d7369d9bee3ecd05915acb22d.tar.gz rust-adcae006d250e40d7369d9bee3ecd05915acb22d.zip | |
Auto merge of #26895 - jroesch:modernize-typeck-names, r=nikomatsakis
This PR modernizes some names in the type checker. The only remaining snake_case name in ty.rs is `ctxt` which should be resolved by @eddyb's pending refactor. We can bike shed over the names, it would just be nice to bring the type checker inline with modern Rust. r? @eddyb cc @nikomatsakis
Diffstat (limited to 'src')
48 files changed, 316 insertions, 312 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<ty::field_ty> { + -> Vec<ty::FieldTy> { 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 95fe2d87c94..7415b576f76 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<IdentInterner>, cdata: Cmd, id: ast::NodeId) - -> Vec<ty::field_ty> { + -> Vec<ty::FieldTy> { 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<IdentInterner>, 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<IdentInterner>, 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 a9e9f17bdce..5c23621a05a 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<entry<i64>>) -> Vec<entry<i64>> { /* 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..57157560f1f 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::TypeAndMut<'tcx> where F: FnMut(DefIdSource, ast::DefId) -> ast::DefId, { let m = parse_mutability(st); - ty::mt { ty: parse_ty_(st, conv), mutbl: m } + ty::TypeAndMut { ty: parse_ty_(st, conv), mutbl: m } } fn parse_def_<F>(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..a932ada61f1 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::TypeAndMut<'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..bbd452b35ac 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::TypeAndMut<'tcx>), /// References - RPtr(&'tcx ty::mt<'tcx>), + RPtr(&'tcx ty::TypeAndMut<'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 b7955290f91..fc2444ed5b4 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::TypeAndMut { 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::TypeAndMut { 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::TypeAndMut { 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<ast::Field>) -> bool { diff --git a/src/librustc/middle/implicator.rs b/src/librustc/middle/implicator.rs index 3e097578857..18059848481 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::TypeAndMut { 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..94c76e23999 100644 --- a/src/librustc/middle/infer/combine.rs +++ b/src/librustc/middle/infer/combine.rs @@ -43,7 +43,7 @@ use super::type_variable::{RelationDir, BiTo, EqTo, SubtypeOf, SupertypeOf}; use middle::ty::{TyVar}; use middle::ty::{IntType, UintType}; -use middle::ty::{self, Ty}; +use middle::ty::{self, Ty, TypeError}; use middle::ty_fold; use middle::ty_fold::{TypeFolder, TypeFoldable}; use middle::ty_relate::{self, Relate, RelateResult, TypeRelation}; @@ -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(TypeError::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(TypeError::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<F>(&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<F>(&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)) + TypeError::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)) + TypeError::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 4a6cc019eb2..1ad7df9cd3a 100644 --- a/src/librustc/middle/infer/error_reporting.rs +++ b/src/librustc/middle/infer/error_reporting.rs @@ -77,7 +77,7 @@ use middle::def; use middle::infer; use middle::region; use middle::subst; -use middle::ty::{self, Ty, HasTypeFlags}; +use middle::ty::{self, Ty, TypeError, HasTypeFlags}; use middle::ty::{Region, ReFree}; use std::cell::{Cell, RefCell}; @@ -220,17 +220,17 @@ pub trait ErrorReporting<'tcx> { fn process_errors(&self, errors: &Vec<RegionResolutionError<'tcx>>) -> Vec<RegionResolutionError<'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>); 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<String>; fn expected_found_str<T: fmt::Display + Resolvable<'tcx> + HasTypeFlags>( &self, - exp_found: &ty::expected_found<T>) + exp_found: &ty::ExpectedFound<T>) -> Option<String>; 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,8 +351,8 @@ 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, - sub); + let terr = TypeError::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<T: fmt::Display + Resolvable<'tcx> + HasTypeFlags>( &self, - exp_found: &ty::expected_found<T>) + exp_found: &ty::ExpectedFound<T>) -> Option<String> { 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 = TypeError::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..1919d8ffd29 100644 --- a/src/librustc/middle/infer/higher_ranked/mod.rs +++ b/src/librustc/middle/infer/higher_ranked/mod.rs @@ -15,7 +15,7 @@ use super::{CombinedSnapshot, InferCtxt, HigherRankedType, SkolemizationMap}; use super::combine::CombineFields; use middle::subst; -use middle::ty::{self, Binder}; +use middle::ty::{self, TypeError, Binder}; use middle::ty_fold::{self, TypeFoldable}; use middle::ty_relate::{Relate, RelateResult, TypeRelation}; use syntax::codemap::Span; @@ -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(TypeError::RegionsInsufficientlyPolymorphic(skol_br, tainted_region)); } else { debug!("Overly polymorphic!"); - return Err(ty::terr_regions_overly_polymorphic(skol_br, + return Err(TypeError::RegionsOverlyPolymorphic(skol_br, tainted_region)); } } diff --git a/src/librustc/middle/infer/mod.rs b/src/librustc/middle/infer/mod.rs index 63f31921ec2..6017c88bf87 100644 --- a/src/librustc/middle/infer/mod.rs +++ b/src/librustc/middle/infer/mod.rs @@ -10,14 +10,11 @@ //! See the Book for more information. -#![allow(non_camel_case_types)] - pub use self::LateBoundRegionConversionTime::*; pub use self::RegionVariableOrigin::*; pub use self::SubregionOrigin::*; pub use self::TypeOrigin::*; pub use self::ValuePairs::*; -pub use self::fixup_err::*; pub use middle::ty::IntVarValue; pub use self::freshen::TypeFreshener; pub use self::region_inference::GenericKind; @@ -32,7 +29,7 @@ use middle::subst::Subst; use middle::traits::{self, FulfillmentContext, Normalized, SelectionContext, ObligationCause}; use middle::ty::{TyVid, IntVid, FloatVid, RegionVid, UnconstrainedNumeric}; -use middle::ty::{self, Ty, HasTypeFlags}; +use middle::ty::{self, Ty, TypeError, HasTypeFlags}; use middle::ty_fold::{self, TypeFolder, TypeFoldable}; use middle::ty_relate::{Relate, RelateResult, TypeRelation}; use rustc_data_structures::unify::{self, UnificationTable}; @@ -65,7 +62,7 @@ pub mod unify_key; pub type Bound<T> = Option<T>; pub type UnitResult<'tcx> = RelateResult<'tcx, ()>; // "unify result" -pub type fres<T> = Result<T, fixup_err>; // "fixup result" +pub type FixupResult<T> = Result<T, FixupError>; // "fixup result" pub struct InferCtxt<'a, 'tcx: 'a> { pub tcx: &'a ty::ctxt<'tcx>, @@ -171,9 +168,9 @@ impl fmt::Display for TypeOrigin { /// See `error_reporting.rs` for more details #[derive(Clone, Debug)] pub enum ValuePairs<'tcx> { - Types(ty::expected_found<Ty<'tcx>>), - TraitRefs(ty::expected_found<ty::TraitRef<'tcx>>), - PolyTraitRefs(ty::expected_found<ty::PolyTraitRef<'tcx>>), + Types(ty::ExpectedFound<Ty<'tcx>>), + TraitRefs(ty::ExpectedFound<ty::TraitRef<'tcx>>), + PolyTraitRefs(ty::ExpectedFound<ty::PolyTraitRef<'tcx>>), } /// The trace designates the path through inference that we took to @@ -313,23 +310,25 @@ pub enum RegionVariableOrigin { } #[derive(Copy, Clone, Debug)] -pub enum fixup_err { - unresolved_int_ty(IntVid), - unresolved_float_ty(FloatVid), - unresolved_ty(TyVid) +pub enum FixupError { + UnresolvedIntTy(IntVid), + UnresolvedFloatTy(FloatVid), + UnresolvedTy(TyVid) } -pub fn fixup_err_to_string(f: fixup_err) -> String { +pub fn fixup_err_to_string(f: FixupError) -> String { + use self::FixupError::*; + match f { - unresolved_int_ty(_) => { + UnresolvedIntTy(_) => { "cannot determine the type of this integer; add a suffix to \ specify the type explicitly".to_string() } - unresolved_float_ty(_) => { + UnresolvedFloatTy(_) => { "cannot determine the type of this number; add a suffix to specify \ the type explicitly".to_string() } - unresolved_ty(_) => "unconstrained type".to_string(), + UnresolvedTy(_) => "unconstrained type".to_string(), } } @@ -460,12 +459,12 @@ pub fn mk_sub_poly_trait_refs<'a, 'tcx>(cx: &InferCtxt<'a, 'tcx>, fn expected_found<T>(a_is_expected: bool, a: T, b: T) - -> ty::expected_found<T> + -> ty::ExpectedFound<T> { 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 +912,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(TypeError::RegionsInsufficientlyPolymorphic(br, r)) } } @@ -1169,7 +1168,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { if ty.has_infer_types() || ty.references_error() { Err(()) } else { Ok(ty) } } - pub fn fully_resolve<T:TypeFoldable<'tcx>>(&self, value: &T) -> fres<T> { + pub fn fully_resolve<T:TypeFoldable<'tcx>>(&self, value: &T) -> FixupResult<T> { /*! * Attempts to resolve all type/region variables in * `value`. Region inference must have been run already (e.g., @@ -1198,7 +1197,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) -> String, { self.type_error_message_str_with_expected(sp, mk_msg, None, actual_ty, err) @@ -1209,7 +1208,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { mk_msg: M, expected_ty: Option<Ty<'tcx>>, actual_ty: String, - err: Option<&ty::type_err<'tcx>>) where + err: Option<&ty::TypeError<'tcx>>) where M: FnOnce(Option<String>, String) -> String, { debug!("hi! expected_ty = {:?}, actual_ty = {}", expected_ty, actual_ty); @@ -1235,7 +1234,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 +1253,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 +1430,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 ba5814167a6..cbd195eee4a 100644 --- a/src/librustc/middle/infer/region_inference/mod.rs +++ b/src/librustc/middle/infer/region_inference/mod.rs @@ -23,7 +23,7 @@ use super::{RegionVariableOrigin, SubregionOrigin, TypeTrace, MiscVariable}; use rustc_data_structures::graph::{self, Direction, NodeIndex}; use middle::free_region::FreeRegionMap; use middle::region; -use middle::ty::{self, Ty}; +use middle::ty::{self, Ty, TypeError}; use middle::ty::{BoundRegion, FreeRegion, Region, RegionVid}; use middle::ty::{ReEmpty, ReStatic, ReInfer, ReFree, ReEarlyBound}; use middle::ty::{ReLateBound, ReScope, ReVar, ReSkolemized, BrFresh}; @@ -132,7 +132,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<RegionVariableOrigin>, - Vec<(TypeTrace<'tcx>, ty::type_err<'tcx>)>, + Vec<(TypeTrace<'tcx>, ty::TypeError<'tcx>)>, Vec<SameRegions>), } @@ -872,7 +872,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(TypeError::RegionsNoOverlap(b, a)) } } @@ -891,7 +891,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { if a == b { Ok(a) } else { - Err(ty::terr_regions_no_overlap(b, a)) + Err(TypeError::RegionsNoOverlap(b, a)) } } } @@ -948,7 +948,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(TypeError::RegionsNoOverlap(region_a, region_b)) } } } diff --git a/src/librustc/middle/infer/resolve.rs b/src/librustc/middle/infer/resolve.rs index 41a0d373fba..39807002b58 100644 --- a/src/librustc/middle/infer/resolve.rs +++ b/src/librustc/middle/infer/resolve.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use super::{InferCtxt, fixup_err, fres, unresolved_ty, unresolved_int_ty, unresolved_float_ty}; +use super::{InferCtxt, FixupError, FixupResult}; use middle::ty::{self, Ty, HasTypeFlags}; use middle::ty_fold::{self, TypeFoldable}; @@ -51,7 +51,7 @@ impl<'a, 'tcx> ty_fold::TypeFolder<'tcx> for OpportunisticTypeResolver<'a, 'tcx> /// Full type resolution replaces all type and region variables with /// their concrete results. If any variable cannot be replaced (never unified, etc) /// then an `Err` result is returned. -pub fn fully_resolve<'a, 'tcx, T>(infcx: &InferCtxt<'a,'tcx>, value: &T) -> fres<T> +pub fn fully_resolve<'a, 'tcx, T>(infcx: &InferCtxt<'a,'tcx>, value: &T) -> FixupResult<T> where T : TypeFoldable<'tcx> { let mut full_resolver = FullTypeResolver { infcx: infcx, err: None }; @@ -66,7 +66,7 @@ pub fn fully_resolve<'a, 'tcx, T>(infcx: &InferCtxt<'a,'tcx>, value: &T) -> fres // `err` field is not enforcable otherwise. struct FullTypeResolver<'a, 'tcx:'a> { infcx: &'a InferCtxt<'a, 'tcx>, - err: Option<fixup_err>, + err: Option<FixupError>, } impl<'a, 'tcx> ty_fold::TypeFolder<'tcx> for FullTypeResolver<'a, 'tcx> { @@ -81,15 +81,15 @@ impl<'a, 'tcx> ty_fold::TypeFolder<'tcx> for FullTypeResolver<'a, 'tcx> { let t = self.infcx.shallow_resolve(t); match t.sty { ty::TyInfer(ty::TyVar(vid)) => { - self.err = Some(unresolved_ty(vid)); + self.err = Some(FixupError::UnresolvedTy(vid)); self.tcx().types.err } ty::TyInfer(ty::IntVar(vid)) => { - self.err = Some(unresolved_int_ty(vid)); + self.err = Some(FixupError::UnresolvedIntTy(vid)); self.tcx().types.err } ty::TyInfer(ty::FloatVar(vid)) => { - self.err = Some(unresolved_float_ty(vid)); + self.err = Some(FixupError::UnresolvedFloatTy(vid)); self.tcx().types.err } ty::TyInfer(_) => { diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index f506de525ff..bf47396bb9f 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::TypeAndMut{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 21f9e417acb..e8a2e29b590 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::TypeAndMut { 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::TypeAndMut { ty: element_ty, ..}) | + ty::TyRef(_, ty::TypeAndMut { ty: element_ty, ..}) => { Some(vec![element_ty]) }, diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index b4b8fbf2064..5200ed1eb5b 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -8,10 +8,9 @@ // 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::InferTy::*; pub use self::InferRegion::*; pub use self::ImplOrTraitItemId::*; @@ -109,9 +108,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: TypeAndMut<'tcx> } @@ -488,13 +487,13 @@ pub struct AssociatedType<'tcx> { } #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)] -pub struct mt<'tcx> { +pub struct TypeAndMut<'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 +673,7 @@ pub type MethodMap<'tcx> = FnvHashMap<MethodCall, MethodCallee<'tcx>>; // 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 +863,7 @@ pub struct ctxt<'tcx> { pub map: ast_map::Map<'tcx>, pub freevars: RefCell<FreevarMap>, pub tcache: RefCell<DefIdMap<TypeScheme<'tcx>>>, - pub rcache: RefCell<FnvHashMap<creader_cache_key, Ty<'tcx>>>, + pub rcache: RefCell<FnvHashMap<CReaderCacheKey, Ty<'tcx>>>, pub tc_cache: RefCell<FnvHashMap<Ty<'tcx>, TypeContents>>, pub ast_ty_to_ty_cache: RefCell<NodeMap<Ty<'tcx>>>, pub enum_var_cache: RefCell<DefIdMap<Rc<Vec<Rc<VariantInfo<'tcx>>>>>>, @@ -873,7 +872,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<DefIdMap<ast::DefId>>, - pub struct_fields: RefCell<DefIdMap<Rc<Vec<field_ty>>>>, + pub struct_fields: RefCell<DefIdMap<Rc<Vec<FieldTy>>>>, /// Maps from def-id of a type or region parameter to its /// (inferred) variance. @@ -1747,11 +1746,11 @@ pub enum TypeVariants<'tcx> { TySlice(Ty<'tcx>), /// A raw pointer. Written as `*mut T` or `*const T` - TyRawPtr(mt<'tcx>), + TyRawPtr(TypeAndMut<'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, TypeAndMut<'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 +1944,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<T> { +pub struct ExpectedFound<T> { 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<ast::Unsafety>), - terr_abi_mismatch(expected_found<abi::Abi>), - terr_mutability, - terr_box_mutability, - terr_ptr_mutability, - terr_ref_mutability, - terr_vec_mutability, - terr_tuple_size(expected_found<usize>), - terr_fixed_array_size(expected_found<usize>), - terr_ty_param_size(expected_found<usize>), - 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<Ty<'tcx>>), - terr_integer_as_char, - terr_int_mismatch(expected_found<IntVarValue>), - terr_float_mismatch(expected_found<ast::FloatTy>), - terr_traits(expected_found<ast::DefId>), - terr_builtin_bounds(expected_found<BuiltinBounds>), - terr_variadic_mismatch(expected_found<bool>), - terr_cyclic_ty, - terr_convergence_mismatch(expected_found<bool>), - terr_projection_name_mismatched(expected_found<ast::Name>), - terr_projection_bounds_length(expected_found<usize>), +pub enum TypeError<'tcx> { + Mismatch, + UnsafetyMismatch(ExpectedFound<ast::Unsafety>), + AbiMismatch(ExpectedFound<abi::Abi>), + Mutability, + BoxMutability, + PtrMutability, + RefMutability, + VecMutability, + TupleSize(ExpectedFound<usize>), + FixedArraySize(ExpectedFound<usize>), + TyParamSize(ExpectedFound<usize>), + ArgCount, + RegionsDoesNotOutlive(Region, Region), + RegionsNotSame(Region, Region), + RegionsNoOverlap(Region, Region), + RegionsInsufficientlyPolymorphic(BoundRegion, Region), + RegionsOverlyPolymorphic(BoundRegion, Region), + Sorts(ExpectedFound<Ty<'tcx>>), + IntegerAsChar, + IntMismatch(ExpectedFound<IntVarValue>), + FloatMismatch(ExpectedFound<ast::FloatTy>), + Traits(ExpectedFound<ast::DefId>), + BuiltinBoundsMismatch(ExpectedFound<BuiltinBounds>), + VariadicMismatch(ExpectedFound<bool>), + CyclicTy, + ConvergenceMismatch(ExpectedFound<bool>), + ProjectionNameMismatched(ExpectedFound<ast::Name>), + ProjectionBoundsLength(ExpectedFound<usize>), } /// Bounds suitable for an existentially quantified type parameter @@ -3573,28 +3564,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: TypeAndMut<'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: TypeAndMut<'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, TypeAndMut {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, TypeAndMut {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(TypeAndMut {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(TypeAndMut {ty: ty, mutbl: ast::MutImmutable}) } pub fn mk_nil_ptr(&self) -> Ty<'tcx> { @@ -4278,7 +4269,7 @@ impl<'tcx> TyS<'tcx> { } fn tc_mt<'tcx>(cx: &ctxt<'tcx>, - mt: mt<'tcx>, + mt: TypeAndMut<'tcx>, cache: &mut FnvHashMap<Ty<'tcx>, TypeContents>) -> TypeContents { let mc = TC::ReachesMutable.when(mt.mutbl == MutMutable); @@ -4350,11 +4341,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(_, TypeAndMut { mutbl: ast::MutImmutable, .. }) => Some(false), - TyStr | TyBox(..) | TyRef(_, mt { + TyStr | TyBox(..) | TyRef(_, TypeAndMut { mutbl: ast::MutMutable, .. }) => Some(true), @@ -4789,10 +4780,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<mt<'tcx>> { + pub fn builtin_deref(&self, explicit: bool) -> Option<TypeAndMut<'tcx>> { match self.sty { TyBox(ty) => { - Some(mt { + Some(TypeAndMut { ty: ty, mutbl: ast::MutImmutable, }) @@ -4931,15 +4922,16 @@ 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, TypeAndMut { ty: self, mutbl: m }) } Some(AutoUnsafe(m)) => { - cx.mk_ptr(mt { ty: self, mutbl: m }) + cx.mk_ptr(TypeAndMut { ty: self, mutbl: m }) } } } fn sort_string(&self, cx: &ctxt) -> String { + match self.sty { TyBool | TyChar | TyInt(_) | TyUint(_) | TyFloat(_) | TyStr => self.to_string(), @@ -4983,67 +4975,69 @@ 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 { + use self::TypeError::*; + 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 +5048,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 +5066,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 +5402,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 +5414,38 @@ impl<'tcx> ctxt<'tcx> { .collect::<Vec<String>>())); } - 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) { + use self::TypeError::*; + 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 +5956,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<field_ty> { + pub fn lookup_struct_fields(&self, did: ast::DefId) -> Vec<FieldTy> { if did.krate == ast::LOCAL_CRATE { let struct_fields = self.struct_fields.borrow(); match struct_fields.get(&did) { @@ -5984,11 +5980,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<field<'tcx>> { + -> Vec<Field<'tcx>> { self.lookup_struct_fields(did).iter().map(|f| { - field { + Field { name: f.name, - mt: mt { + mt: TypeAndMut { ty: self.lookup_field_type(did, f.id, substs), mutbl: MutImmutable } @@ -6074,7 +6070,7 @@ impl<'tcx> ctxt<'tcx> { } UpvarCapture::ByRef(borrow) => { tcx.mk_ref(tcx.mk_region(borrow.region), - ty::mt { + ty::TypeAndMut { ty: freevar_ty, mutbl: borrow.kind.to_mutbl_lossy(), }) @@ -6427,7 +6423,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: TypeAndMut| { mt.mutbl.hash(state); }; let fn_sig = |state: &mut SipHasher, sig: &Binder<FnSig<'tcx>>| { @@ -7227,7 +7223,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) } @@ -7256,7 +7252,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..3cf5e6ffa03 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::TypeAndMut<'tcx>) -> ty::TypeAndMut<'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<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> ty::mt<'tcx> { +impl<'tcx> TypeFoldable<'tcx> for ty::TypeAndMut<'tcx> { + fn fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> ty::TypeAndMut<'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<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> ty::field<'tcx> { - ty::field { +impl<'tcx> TypeFoldable<'tcx> for ty::Field<'tcx> { + fn fold_with<F: TypeFolder<'tcx>>(&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::TypeAndMut<'tcx>) + -> ty::TypeAndMut<'tcx> { + ty::TypeAndMut {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..56b90e198a5 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::TypeError::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..3a4bb102146 100644 --- a/src/librustc/middle/ty_relate/mod.rs +++ b/src/librustc/middle/ty_relate/mod.rs @@ -14,13 +14,13 @@ //! type equality, etc. use middle::subst::{ErasedRegions, NonerasedRegions, ParamSpace, Substs}; -use middle::ty::{self, Ty}; +use middle::ty::{self, Ty, TypeError}; use middle::ty_fold::TypeFoldable; use std::rc::Rc; use syntax::abi; use syntax::ast; -pub type RelateResult<'tcx, T> = Result<T, ty::type_err<'tcx>>; +pub type RelateResult<'tcx, T> = Result<T, ty::TypeError<'tcx>>; #[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::TypeAndMut<'tcx> { fn relate<R>(relation: &mut R, - a: &ty::mt<'tcx>, - b: &ty::mt<'tcx>) - -> RelateResult<'tcx, ty::mt<'tcx>> + a: &ty::TypeAndMut<'tcx>, + b: &ty::TypeAndMut<'tcx>) + -> RelateResult<'tcx, ty::TypeAndMut<'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(TypeError::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::TypeAndMut {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(TypeError::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(TypeError::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(TypeError::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(TypeError::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(TypeError::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(TypeError::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(TypeError::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<ty::PolyProjectionPredicate<'tcx>> { // 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(TypeError::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(TypeError::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(TypeError::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(TypeError::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::<Result<_, _>>()); Ok(tcx.mk_tup(ts)) } else if !(as_.is_empty() || bs.is_empty()) { - Err(ty::terr_tuple_size( + Err(TypeError::TupleSize( expected_found(relation, &as_.len(), &bs.len()))) } else { - Err(ty::terr_sorts(expected_found(relation, &a, &b))) + Err(TypeError::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(TypeError::Sorts(expected_found(relation, &a, &b))) } } } @@ -652,7 +652,7 @@ impl<'a,'tcx:'a,T> Relate<'a,'tcx> for Box<T> pub fn expected_found<'a,'tcx:'a,R,T>(relation: &mut R, a: &T, b: &T) - -> ty::expected_found<T> + -> ty::ExpectedFound<T> 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<T>(a_is_expected: bool, a: &T, b: &T) - -> ty::expected_found<T> + -> ty::ExpectedFound<T> 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..4d60500ecf6 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, TypeAndMut, 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::TypeAndMut<'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..2b480abe3f1 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<DiscrField> { match ty.sty { // Fat &T/&mut T/Box<T> 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::TypeAndMut { 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::TypeAndMut { 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..f8daefa87a5 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::TypeAndMut { 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..2f5f5345e64 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::TypeAndMut{ty, ..}) | + ty::TyRef(_, ty::TypeAndMut{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 5b6d939d9e6..242eceb8335 100644 --- a/src/librustc_trans/trans/consts.rs +++ b/src/librustc_trans/trans/consts.rs @@ -620,7 +620,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::TypeAndMut{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..8f44bb67050 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::TypeAndMut { 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::TypeAndMut { 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::TypeAndMut { ty: element_type, mutbl: ast::MutImmutable }); @@ -765,7 +765,9 @@ 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::TypeAndMut{ty, ..}) | + ty::TyRef(_, ty::TypeAndMut{ty, ..}) => { match ty.sty { ty::TySlice(typ) => { vec_slice_metadata(cx, t, typ, unique_type_id, usage_site_span) @@ -1113,7 +1115,7 @@ impl<'tcx> MemberDescriptionFactory<'tcx> { // Creates MemberDescriptions for the fields of a struct struct StructMemberDescriptionFactory<'tcx> { - fields: Vec<ty::field<'tcx>>, + fields: Vec<ty::Field<'tcx>>, 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..b912acb90a2 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::TypeAndMut { 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::TypeAndMut { 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 f62e4d43cc6..f7ace785120 100644 --- a/src/librustc_trans/trans/expr.rs +++ b/src/librustc_trans/trans/expr.rs @@ -438,9 +438,12 @@ 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::TypeAndMut { ty: a, .. }), + &ty::TyRef(_, ty::TypeAndMut { ty: b, .. })) | + (&ty::TyRef(_, ty::TypeAndMut { ty: a, .. }), + &ty::TyRawPtr(ty::TypeAndMut { ty: b, .. })) | + (&ty::TyRawPtr(ty::TypeAndMut { ty: a, .. }), + &ty::TyRawPtr(ty::TypeAndMut { ty: b, .. })) => { let (inner_source, inner_target) = (a, b); let (base, old_info) = if !type_is_sized(bcx.tcx(), inner_source) { @@ -705,7 +708,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"); @@ -1331,7 +1334,7 @@ pub fn with_field_tys<'tcx, R, F>(tcx: &ty::ctxt<'tcx>, node_id_opt: Option<ast::NodeId>, 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) => { @@ -1342,9 +1345,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::TypeAndMut { ty: f, mutbl: ast::MutImmutable } @@ -1990,7 +1993,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::TypeAndMut{ ty: t_in, .. }), Some(ty::TypeAndMut{ ty: t_out, .. })) => { t_in == t_out } _ => { @@ -2271,8 +2274,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::TypeAndMut { ty: content_ty, .. }) | + ty::TyRef(_, ty::TypeAndMut { 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..0e05ca52959 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::TypeAndMut{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..5be513d8ba4 100644 --- a/src/librustc_trans/trans/type_of.rs +++ b/src/librustc_trans/trans/type_of.rs @@ -193,7 +193,9 @@ 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::TypeAndMut{ty, ..}) | + ty::TyRawPtr(ty::TypeAndMut{ty, ..}) => { if type_is_sized(cx.tcx(), ty) { Type::i8p(cx) } else { @@ -352,7 +354,9 @@ 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::TypeAndMut{ty, ..}) | + ty::TyRawPtr(ty::TypeAndMut{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 0f2506dc301..a57fc60e923 100644 --- a/src/librustc_typeck/astconv.rs +++ b/src/librustc_typeck/astconv.rs @@ -1555,7 +1555,7 @@ pub fn ast_ty_to_ty<'tcx>(this: &AstConv<'tcx>, } } ast::TyPtr(ref mt) => { - tcx.mk_ptr(ty::mt { + tcx.mk_ptr(ty::TypeAndMut { ty: ast_ty_to_ty(this, rscope, &*mt.ty), mutbl: mt.mutbl }) @@ -1568,7 +1568,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::TypeAndMut {ty: t, mutbl: mt.mutbl}) } ast::TyTup(ref fields) => { let flds = fields.iter() @@ -1754,7 +1754,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::TypeAndMut { 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..a995401cf5c 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::TypeAndMut { 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::TypeAndMut { 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::TypeAndMut { 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::TypeAndMut { 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<ast::FieldPat>], - 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..37541dee7d9 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::TypeAndMut<'tcx>, + m_cast: &'tcx ty::TypeAndMut<'tcx>) -> Result<CastKind, CastError> { 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::TypeAndMut<'tcx>) -> Result<CastKind, CastError> { // 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::TypeAndMut<'tcx>) -> Result<CastKind, CastError> { // 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::TypeAndMut<'tcx>, + m_cast: &'tcx ty::TypeAndMut<'tcx>) -> Result<CastKind, CastError> { // 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::TypeAndMut<'tcx>) -> Result<CastKind, CastError> { // 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..6963e25cd5b 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, TypeAndMut, Ty, TypeError}; 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}); + TypeAndMut {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(TypeError::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(TypeError::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::TypeAndMut{ 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(TypeError::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 b9c986a512e..a8c56b2660c 100644 --- a/src/librustc_typeck/check/method/confirm.rs +++ b/src/librustc_typeck/check/method/confirm.rs @@ -432,7 +432,7 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> { }; match sig.0.inputs[0].sty { - ty::TyRef(_, ty::mt { + ty::TyRef(_, ty::TypeAndMut { ty: _, mutbl: ast::MutMutable, }) => {} diff --git a/src/librustc_typeck/check/method/mod.rs b/src/librustc_typeck/check/method/mod.rs index 2117cba1087..a74c004389b 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::TypeAndMut { 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..a960123efc6 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::TypeAndMut { 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::TypeAndMut { 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::TypeAndMut { ty: step.self_ty, mutbl: m }); diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index e6c79cfd30e..0f2bb95558e 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -1029,7 +1029,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::TypeAndMut { mutbl: mt, .. }) => { let mtstr = match mt { ast::MutMutable => "mut ", ast::MutImmutable => "" @@ -1576,7 +1576,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) } @@ -1585,7 +1585,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) } @@ -1600,7 +1600,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); @@ -1610,7 +1610,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) } @@ -1674,7 +1674,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<Ty<'tcx>> @@ -1687,7 +1687,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<Ty<'tcx>> @@ -1894,7 +1894,7 @@ fn try_overloaded_deref<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, base_expr: Option<&ast::Expr>, base_ty: Ty<'tcx>, lvalue_pref: LvaluePreference) - -> Option<ty::mt<'tcx>> + -> Option<ty::TypeAndMut<'tcx>> { // Try DerefMut first, if preferred. let method = match (lvalue_pref, fcx.tcx().lang_items.deref_mut_trait()) { @@ -1925,7 +1925,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<MethodCall>, method: Option<MethodCallee<'tcx>>) - -> Option<ty::mt<'tcx>> + -> Option<ty::TypeAndMut<'tcx>> { match method { Some(method) => { @@ -2776,7 +2776,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<ast::DefId>) { @@ -3110,7 +3110,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::TypeAndMut { ty: fcx.expr_ty(&**oprnd), mutbl: mutbl }; let oprnd_t = if tm.ty.references_error() { tcx.types.err } else { @@ -4908,13 +4908,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::TypeAndMut { ty: param(ccx, 0), mutbl: ast::MutImmutable }), ccx.tcx.types.isize ), - tcx.mk_ptr(ty::mt { + tcx.mk_ptr(ty::TypeAndMut { ty: param(ccx, 0), mutbl: ast::MutImmutable })) @@ -4922,11 +4922,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::TypeAndMut { ty: param(ccx, 0), mutbl: ast::MutImmutable }), - tcx.mk_ptr(ty::mt { + tcx.mk_ptr(ty::TypeAndMut { ty: param(ccx, 0), mutbl: ast::MutMutable }), @@ -4937,11 +4937,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::TypeAndMut { ty: param(ccx, 0), mutbl: ast::MutMutable }), - tcx.mk_ptr(ty::mt { + tcx.mk_ptr(ty::TypeAndMut { ty: param(ccx, 0), mutbl: ast::MutImmutable }), @@ -4952,7 +4952,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::TypeAndMut { ty: param(ccx, 0), mutbl: ast::MutMutable }), diff --git a/src/librustc_typeck/check/writeback.rs b/src/librustc_typeck/check/writeback.rs index 419fa9e160a..9d7ff3b9613 100644 --- a/src/librustc_typeck/check/writeback.rs +++ b/src/librustc_typeck/check/writeback.rs @@ -390,7 +390,7 @@ impl<'cx, 'tcx> Resolver<'cx, 'tcx> { reason: reason } } - fn report_error(&self, e: infer::fixup_err) { + fn report_error(&self, e: infer::FixupError) { self.writeback_errors.set(true); if !self.tcx.sess.has_errors() { match self.reason { diff --git a/src/librustc_typeck/coherence/mod.rs b/src/librustc_typeck/coherence/mod.rs index 20407e927f7..0416f66b2c7 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::TypeAndMut<'tcx>, mt_b: ty::TypeAndMut<'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::TypeError::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..be8fce28b6f 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::TypeAndMut { 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::TypeAndMut { 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..4af23a27c94 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::TypeAndMut<'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<Item> for ast::StructField { } } -impl Clean<Item> for ty::field_ty { +impl Clean<Item> for ty::FieldTy { fn clean(&self, cx: &DocContext) -> Item { use syntax::parse::token::special_idents::unnamed_field; use rustc::metadata::csearch; |