Skip to content

Commit aa03871

Browse files
eddybeddyb
committed
rustc: combine type-flag-checking traits and fns and into one trait.
1 parent 378a370 commit aa03871

33 files changed

+306
-431
lines changed

‎src/librustc/metadata/tydecode.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -21,7 +21,7 @@ pub use self::DefIdSource::*;
2121
use middle::region;
2222
use middle::subst;
2323
use middle::subst::VecPerParamSpace;
24-
use middle::ty::{self, ToPredicate, Ty};
24+
use middle::ty::{self, ToPredicate, Ty, HasTypeFlags};
2525

2626
use std::str;
2727
use syntax::abi;
@@ -534,7 +534,7 @@ fn parse_ty_<'a, 'tcx, F>(st: &mut PState<'a, 'tcx>, conv: &mut F) -> Ty<'tcx> w
534534
// If there is a closure buried in the type some where, then we
535535
// need to re-convert any def ids (see case 'k', below). That means
536536
// we can't reuse the cached version.
537-
if !ty::type_has_ty_closure(tt) {
537+
if !tt.has_closure_types() {
538538
return tt;
539539
}
540540
}

‎src/librustc/middle/implicator.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -400,7 +400,7 @@ impl<'a, 'tcx> Implicator<'a, 'tcx> {
400400
}
401401

402402
fn fully_normalize<T>(&self, value: &T) -> Result<T,ErrorReported>
403-
where T : TypeFoldable<'tcx> + ty::HasProjectionTypes
403+
where T : TypeFoldable<'tcx> + ty::HasTypeFlags
404404
{
405405
let value =
406406
traits::fully_normalize(self.infcx,

‎src/librustc/middle/infer/error_reporting.rs

+5-16
Original file line numberDiff line numberDiff line change
@@ -77,7 +77,7 @@ use middle::def;
7777
use middle::infer;
7878
use middle::region;
7979
use middle::subst;
80-
use middle::ty::{self, Ty};
80+
use middle::ty::{self, Ty, HasTypeFlags};
8181
use middle::ty::{Region, ReFree};
8282

8383
use std::cell::{Cell, RefCell};
@@ -226,7 +226,7 @@ pub trait ErrorReporting<'tcx> {
226226

227227
fn values_str(&self, values: &ValuePairs<'tcx>) -> Option<String>;
228228

229-
fn expected_found_str<T: fmt::Display + Resolvable<'tcx>>(
229+
fn expected_found_str<T: fmt::Display + Resolvable<'tcx> + HasTypeFlags>(
230230
&self,
231231
exp_found: &ty::expected_found<T>)
232232
-> Option<String>;
@@ -504,18 +504,18 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
504504
}
505505
}
506506

507-
fn expected_found_str<T: fmt::Display + Resolvable<'tcx>>(
507+
fn expected_found_str<T: fmt::Display + Resolvable<'tcx> + HasTypeFlags>(
508508
&self,
509509
exp_found: &ty::expected_found<T>)
510510
-> Option<String>
511511
{
512512
let expected = exp_found.expected.resolve(self);
513-
if expected.contains_error() {
513+
if expected.references_error() {
514514
return None;
515515
}
516516

517517
let found = exp_found.found.resolve(self);
518-
if found.contains_error() {
518+
if found.references_error() {
519519
return None;
520520
}
521521

@@ -1793,26 +1793,19 @@ impl<'a, 'tcx> ErrorReportingHelpers<'tcx> for InferCtxt<'a, 'tcx> {
17931793

17941794
pub trait Resolvable<'tcx> {
17951795
fn resolve<'a>(&self, infcx: &InferCtxt<'a, 'tcx>) -> Self;
1796-
fn contains_error(&self) -> bool;
17971796
}
17981797

17991798
impl<'tcx> Resolvable<'tcx> for Ty<'tcx> {
18001799
fn resolve<'a>(&self, infcx: &InferCtxt<'a, 'tcx>) -> Ty<'tcx> {
18011800
infcx.resolve_type_vars_if_possible(self)
18021801
}
1803-
fn contains_error(&self) -> bool {
1804-
ty::type_is_error(*self)
1805-
}
18061802
}
18071803

18081804
impl<'tcx> Resolvable<'tcx> for ty::TraitRef<'tcx> {
18091805
fn resolve<'a>(&self, infcx: &InferCtxt<'a, 'tcx>)
18101806
-> ty::TraitRef<'tcx> {
18111807
infcx.resolve_type_vars_if_possible(self)
18121808
}
1813-
fn contains_error(&self) -> bool {
1814-
ty::trait_ref_contains_error(self)
1815-
}
18161809
}
18171810

18181811
impl<'tcx> Resolvable<'tcx> for ty::PolyTraitRef<'tcx> {
@@ -1822,10 +1815,6 @@ impl<'tcx> Resolvable<'tcx> for ty::PolyTraitRef<'tcx> {
18221815
{
18231816
infcx.resolve_type_vars_if_possible(self)
18241817
}
1825-
1826-
fn contains_error(&self) -> bool {
1827-
ty::trait_ref_contains_error(&self.0)
1828-
}
18291818
}
18301819

18311820
fn lifetimes_in_scope(tcx: &ty::ctxt,

‎src/librustc/middle/infer/freshen.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -30,7 +30,7 @@
3030
//! variable only once, and it does so as soon as it can, so it is reasonable to ask what the type
3131
//! inferencer knows "so far".
3232
33-
use middle::ty::{self, Ty};
33+
use middle::ty::{self, Ty, HasTypeFlags};
3434
use middle::ty_fold;
3535
use middle::ty_fold::TypeFoldable;
3636
use middle::ty_fold::TypeFolder;
@@ -104,7 +104,7 @@ impl<'a, 'tcx> TypeFolder<'tcx> for TypeFreshener<'a, 'tcx> {
104104
}
105105

106106
fn fold_ty(&mut self, t: Ty<'tcx>) -> Ty<'tcx> {
107-
if !ty::type_needs_infer(t) && !ty::type_has_erasable_regions(t) {
107+
if !t.needs_infer() && !t.has_erasable_regions() {
108108
return t;
109109
}
110110

‎src/librustc/middle/infer/mod.rs

+11-14
Original file line numberDiff line numberDiff line change
@@ -26,7 +26,7 @@ use middle::free_region::FreeRegionMap;
2626
use middle::subst;
2727
use middle::subst::Substs;
2828
use middle::ty::{TyVid, IntVid, FloatVid, RegionVid, UnconstrainedNumeric};
29-
use middle::ty::{self, Ty};
29+
use middle::ty::{self, Ty, HasTypeFlags};
3030
use middle::ty_fold::{self, TypeFolder, TypeFoldable};
3131
use middle::ty_relate::{Relate, RelateResult, TypeRelation};
3232
use rustc_data_structures::unify::{self, UnificationTable};
@@ -973,20 +973,17 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
973973

974974
let resolved_expected = expected_ty.map(|e_ty| self.resolve_type_vars_if_possible(&e_ty));
975975

976-
match resolved_expected {
977-
Some(t) if ty::type_is_error(t) => (),
978-
_ => {
979-
let error_str = err.map_or("".to_string(), |t_err| {
980-
format!(" ({})", t_err)
981-
});
976+
if !resolved_expected.references_error() {
977+
let error_str = err.map_or("".to_string(), |t_err| {
978+
format!(" ({})", t_err)
979+
});
982980

983-
self.tcx.sess.span_err(sp, &format!("{}{}",
984-
mk_msg(resolved_expected.map(|t| self.ty_to_string(t)), actual_ty),
985-
error_str));
981+
self.tcx.sess.span_err(sp, &format!("{}{}",
982+
mk_msg(resolved_expected.map(|t| self.ty_to_string(t)), actual_ty),
983+
error_str));
986984

987-
if let Some(err) = err {
988-
ty::note_and_explain_type_err(self.tcx, err, sp)
989-
}
985+
if let Some(err) = err {
986+
ty::note_and_explain_type_err(self.tcx, err, sp)
990987
}
991988
}
992989
}
@@ -1001,7 +998,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
1001998
let actual_ty = self.resolve_type_vars_if_possible(&actual_ty);
1002999

10031000
// Don't report an error if actual type is TyError.
1004-
if ty::type_is_error(actual_ty) {
1001+
if actual_ty.references_error() {
10051002
return;
10061003
}
10071004

‎src/librustc/middle/infer/resolve.rs

+3-3
Original file line numberDiff line numberDiff line change
@@ -9,7 +9,7 @@
99
// except according to those terms.
1010

1111
use super::{InferCtxt, fixup_err, fres, unresolved_ty, unresolved_int_ty, unresolved_float_ty};
12-
use middle::ty::{self, Ty};
12+
use middle::ty::{self, Ty, HasTypeFlags};
1313
use middle::ty_fold::{self, TypeFoldable};
1414

1515
///////////////////////////////////////////////////////////////////////////
@@ -36,7 +36,7 @@ impl<'a, 'tcx> ty_fold::TypeFolder<'tcx> for OpportunisticTypeResolver<'a, 'tcx>
3636
}
3737

3838
fn fold_ty(&mut self, t: Ty<'tcx>) -> Ty<'tcx> {
39-
if !ty::type_has_ty_infer(t) {
39+
if !t.has_infer_types() {
4040
t // micro-optimize -- if there is nothing in this type that this fold affects...
4141
} else {
4242
let t0 = self.infcx.shallow_resolve(t);
@@ -75,7 +75,7 @@ impl<'a, 'tcx> ty_fold::TypeFolder<'tcx> for FullTypeResolver<'a, 'tcx> {
7575
}
7676

7777
fn fold_ty(&mut self, t: Ty<'tcx>) -> Ty<'tcx> {
78-
if !ty::type_needs_infer(t) {
78+
if !t.needs_infer() {
7979
t // micro-optimize -- if there is nothing in this type that this fold affects...
8080
} else {
8181
let t = self.infcx.shallow_resolve(t);

‎src/librustc/middle/intrinsicck.rs

+3-3
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,7 @@ use metadata::csearch;
1313
use middle::def::DefFn;
1414
use middle::subst::{Subst, Substs, EnumeratedItems};
1515
use middle::ty::{TransmuteRestriction, ctxt, TyBareFn};
16-
use middle::ty::{self, Ty};
16+
use middle::ty::{self, Ty, HasTypeFlags};
1717

1818
use std::fmt;
1919

@@ -92,8 +92,8 @@ impl<'a, 'tcx> IntrinsicCheckingVisitor<'a, 'tcx> {
9292

9393
// Simple case: no type parameters involved.
9494
if
95-
!ty::type_has_params(from) && !ty::type_has_self(from) &&
96-
!ty::type_has_params(to) && !ty::type_has_self(to)
95+
!from.has_param_types() && !from.has_self_ty() &&
96+
!to.has_param_types() && !to.has_self_ty()
9797
{
9898
let restriction = TransmuteRestriction {
9999
span: span,

‎src/librustc/middle/subst.rs

+5-16
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,7 @@
1313
pub use self::ParamSpace::*;
1414
pub use self::RegionSubsts::*;
1515

16-
use middle::ty::{self, Ty};
16+
use middle::ty::{self, Ty, HasTypeFlags, RegionEscape};
1717
use middle::ty_fold::{self, TypeFoldable, TypeFolder};
1818

1919
use std::fmt;
@@ -100,17 +100,6 @@ impl<'tcx> Substs<'tcx> {
100100
*self.types.get(ty_param_def.space, ty_param_def.index as usize)
101101
}
102102

103-
pub fn has_regions_escaping_depth(&self, depth: u32) -> bool {
104-
self.types.iter().any(|&t| ty::type_escapes_depth(t, depth)) || {
105-
match self.regions {
106-
ErasedRegions =>
107-
false,
108-
NonerasedRegions(ref regions) =>
109-
regions.iter().any(|r| r.escapes_depth(depth)),
110-
}
111-
}
112-
}
113-
114103
pub fn self_ty(&self) -> Option<Ty<'tcx>> {
115104
self.types.get_self().cloned()
116105
}
@@ -632,7 +621,7 @@ impl<'a, 'tcx> TypeFolder<'tcx> for SubstFolder<'a, 'tcx> {
632621
}
633622

634623
fn fold_ty(&mut self, t: Ty<'tcx>) -> Ty<'tcx> {
635-
if !ty::type_needs_subst(t) {
624+
if !t.needs_subst() {
636625
return t;
637626
}
638627

@@ -729,10 +718,10 @@ impl<'a,'tcx> SubstFolder<'a,'tcx> {
729718
/// first case we do not increase the Debruijn index and in the second case we do. The reason
730719
/// is that only in the second case have we passed through a fn binder.
731720
fn shift_regions_through_binders(&self, ty: Ty<'tcx>) -> Ty<'tcx> {
732-
debug!("shift_regions(ty={:?}, region_binders_passed={:?}, type_has_escaping_regions={:?})",
733-
ty, self.region_binders_passed, ty::type_has_escaping_regions(ty));
721+
debug!("shift_regions(ty={:?}, region_binders_passed={:?}, has_escaping_regions={:?})",
722+
ty, self.region_binders_passed, ty.has_escaping_regions());
734723

735-
if self.region_binders_passed == 0 || !ty::type_has_escaping_regions(ty) {
724+
if self.region_binders_passed == 0 || !ty.has_escaping_regions() {
736725
return ty;
737726
}
738727

‎src/librustc/middle/traits/error_reporting.rs

+4-4
Original file line numberDiff line numberDiff line change
@@ -25,7 +25,7 @@ use super::{
2525

2626
use fmt_macros::{Parser, Piece, Position};
2727
use middle::infer::InferCtxt;
28-
use middle::ty::{self, ToPredicate, ReferencesError, ToPolyTraitRef, TraitRef};
28+
use middle::ty::{self, ToPredicate, HasTypeFlags, ToPolyTraitRef, TraitRef};
2929
use middle::ty_fold::TypeFoldable;
3030
use std::collections::HashMap;
3131
use std::fmt;
@@ -245,7 +245,7 @@ pub fn report_selection_error<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
245245
OutputTypeParameterMismatch(ref expected_trait_ref, ref actual_trait_ref, ref e) => {
246246
let expected_trait_ref = infcx.resolve_type_vars_if_possible(&*expected_trait_ref);
247247
let actual_trait_ref = infcx.resolve_type_vars_if_possible(&*actual_trait_ref);
248-
if !ty::type_is_error(actual_trait_ref.self_ty()) {
248+
if !actual_trait_ref.self_ty().references_error() {
249249
span_err!(infcx.tcx.sess, obligation.cause.span, E0281,
250250
"type mismatch: the type `{}` implements the trait `{}`, \
251251
but the trait `{}` is required ({})",
@@ -325,8 +325,8 @@ pub fn maybe_report_ambiguity<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
325325
let trait_ref = data.to_poly_trait_ref();
326326
let self_ty = trait_ref.self_ty();
327327
let all_types = &trait_ref.substs().types;
328-
if all_types.iter().any(|&t| ty::type_is_error(t)) {
329-
} else if all_types.iter().any(|&t| ty::type_needs_infer(t)) {
328+
if all_types.references_error() {
329+
} else if all_types.needs_infer() {
330330
// This is kind of a hack: it frequently happens that some earlier
331331
// error prevents types from being fully inferred, and then we get
332332
// a bunch of uninteresting errors saying something like "<generic

‎src/librustc/middle/traits/fulfill.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -9,7 +9,7 @@
99
// except according to those terms.
1010

1111
use middle::infer::InferCtxt;
12-
use middle::ty::{self, RegionEscape, Ty};
12+
use middle::ty::{self, RegionEscape, Ty, HasTypeFlags};
1313

1414
use std::collections::HashSet;
1515
use std::fmt;

‎src/librustc/middle/traits/mod.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -17,7 +17,7 @@ pub use self::ObligationCauseCode::*;
1717

1818
use middle::free_region::FreeRegionMap;
1919
use middle::subst;
20-
use middle::ty::{self, HasProjectionTypes, Ty};
20+
use middle::ty::{self, HasTypeFlags, Ty};
2121
use middle::ty_fold::TypeFoldable;
2222
use middle::infer::{self, fixup_err_to_string, InferCtxt};
2323
use std::rc::Rc;
@@ -432,7 +432,7 @@ pub fn fully_normalize<'a,'tcx,T>(infcx: &InferCtxt<'a,'tcx>,
432432
cause: ObligationCause<'tcx>,
433433
value: &T)
434434
-> Result<T, Vec<FulfillmentError<'tcx>>>
435-
where T : TypeFoldable<'tcx> + HasProjectionTypes
435+
where T : TypeFoldable<'tcx> + HasTypeFlags
436436
{
437437
debug!("normalize_param_env(value={:?})", value);
438438

‎src/librustc/middle/traits/project.rs

+5-6
Original file line numberDiff line numberDiff line change
@@ -23,8 +23,7 @@ use super::util;
2323

2424
use middle::infer;
2525
use middle::subst::Subst;
26-
use middle::ty::{self, ToPredicate, ReferencesError, RegionEscape,
27-
HasProjectionTypes, ToPolyTraitRef, Ty};
26+
use middle::ty::{self, ToPredicate, RegionEscape, HasTypeFlags, ToPolyTraitRef, Ty};
2827
use middle::ty_fold::{self, TypeFoldable, TypeFolder};
2928
use syntax::parse::token;
3029
use util::common::FN_OUTPUT_NAME;
@@ -195,7 +194,7 @@ pub fn normalize<'a,'b,'tcx,T>(selcx: &'a mut SelectionContext<'b,'tcx>,
195194
cause: ObligationCause<'tcx>,
196195
value: &T)
197196
-> Normalized<'tcx, T>
198-
where T : TypeFoldable<'tcx> + HasProjectionTypes
197+
where T : TypeFoldable<'tcx> + HasTypeFlags
199198
{
200199
normalize_with_depth(selcx, cause, 0, value)
201200
}
@@ -206,7 +205,7 @@ pub fn normalize_with_depth<'a,'b,'tcx,T>(selcx: &'a mut SelectionContext<'b,'tc
206205
depth: usize,
207206
value: &T)
208207
-> Normalized<'tcx, T>
209-
where T : TypeFoldable<'tcx> + HasProjectionTypes
208+
where T : TypeFoldable<'tcx> + HasTypeFlags
210209
{
211210
let mut normalizer = AssociatedTypeNormalizer::new(selcx, cause, depth);
212211
let result = normalizer.fold(value);
@@ -238,7 +237,7 @@ impl<'a,'b,'tcx> AssociatedTypeNormalizer<'a,'b,'tcx> {
238237
}
239238
}
240239

241-
fn fold<T:TypeFoldable<'tcx> + HasProjectionTypes>(&mut self, value: &T) -> T {
240+
fn fold<T:TypeFoldable<'tcx> + HasTypeFlags>(&mut self, value: &T) -> T {
242241
let value = self.selcx.infcx().resolve_type_vars_if_possible(value);
243242

244243
if !value.has_projection_types() {
@@ -374,7 +373,7 @@ fn opt_normalize_projection_type<'a,'b,'tcx>(
374373
depth,
375374
obligations);
376375

377-
if ty::type_has_projection(projected_ty) {
376+
if projected_ty.has_projection_types() {
378377
let mut normalizer = AssociatedTypeNormalizer::new(selcx, cause, depth);
379378
let normalized_ty = normalizer.fold(&projected_ty);
380379

0 commit comments

Comments
 (0)