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

Update w/ comments

Browse Source 
Removes uses of ty() where a method is implemented on TypeFoldable, and also directly formats
a Term.
This commit is contained in:
kadmin 2022-01-11 19:18:18 +00:00
parent e7529d6a38
commit f396888c4d
10 changed files with 21 additions and 32 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
compiler/rustc_middle/src/ty/print/pretty.rs
View File

@ -905,7 +905,13 @@ pub trait PrettyPrinter<'tcx>:
}
for (assoc_item_def_id, term) in assoc_items {
let ty = if let Term::Ty(ty) = term.skip_binder() { ty } else { continue };
let ty = match term.skip_binder() {
Term::Ty(ty) => ty,
Term::Const(c) => {
p!(print(c));
continue;
}
};
if !first {
p!(", ");
}

7
compiler/rustc_middle/src/ty/sty.rs
View File

@ -1580,10 +1580,9 @@ impl<'tcx> ExistentialProjection<'tcx> {
) -> Self {
// Assert there is a Self.
projection_predicate.projection_ty.substs.type_at(0);
let ty = if let Term::Ty(ty) = projection_predicate.term {
ty
} else {
panic!("Only types are permitted here");
let ty = match projection_predicate.term {
Term::Ty(ty) => ty,
Term::Const(_c) => unimplemented!(),
};
Self {

10
compiler/rustc_privacy/src/lib.rs
View File

@ -128,10 +128,7 @@ where
polarity: _,
}) => self.visit_trait(trait_ref),
ty::PredicateKind::Projection(ty::ProjectionPredicate { projection_ty, term }) => {
match term {
ty::Term::Ty(ty) => ty.visit_with(self)?,
ty::Term::Const(ct) => ct.visit_with(self)?,
}
term.visit_with(self)?;
self.visit_projection_ty(projection_ty)
}
ty::PredicateKind::TypeOutlives(ty::OutlivesPredicate(ty, _region)) => {
@ -1189,10 +1186,7 @@ impl<'tcx> Visitor<'tcx> for TypePrivacyVisitor<'tcx> {
for (poly_predicate, _) in bounds.projection_bounds {
let pred = poly_predicate.skip_binder();
let poly_pred_term = match pred.term {
ty::Term::Ty(ty) => self.visit(ty),
ty::Term::Const(ct) => self.visit(ct),
};
let poly_pred_term = self.visit(pred.term);
if poly_pred_term.is_break()
|| self.visit_projection_ty(pred.projection_ty).is_break()
{

3
compiler/rustc_trait_selection/src/traits/auto_trait.rs
View File

@ -779,8 +779,7 @@ impl<'tcx> AutoTraitFinder<'tcx> {
// However, we should always make progress (either by generating
// subobligations or getting an error) when we started off with
// inference variables
if p.term().skip_binder().ty().map_or(false, |ty| ty.has_infer_types())
{
if p.term().skip_binder().ty().has_infer_types() {
panic!("Unexpected result when selecting {:?} {:?}", ty, obligation)
}
}

2
compiler/rustc_typeck/src/check/closure.rs
View File

@ -709,7 +709,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// does not have any regions in it.
let output_ty = self.resolve_vars_if_possible(predicate.term);
debug!("deduce_future_output_from_projection: output_ty={:?}", output_ty);
// FIXME(...): How to handle consts here? Will this always be a const?
// This is a projection on a Fn trait so will always be a type.
Some(output_ty.ty().unwrap())
}

9
compiler/rustc_typeck/src/check/method/suggest.rs
View File

@ -789,13 +789,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
item_def_id: projection_ty.item_def_id,
};
let fmt = match pred.skip_binder().term {
ty::Term::Ty(ty) => format!("{}", ty),
ty::Term::Const(c) => format!("{}", c),
};
let term = pred.skip_binder().term;
let obligation = format!("{} = {}", projection_ty, fmt);
let quiet = format!("{} = {}", quiet_projection_ty, fmt);
let obligation = format!("{} = {}", projection_ty, term);
let quiet = format!("{} = {}", quiet_projection_ty, term);
bound_span_label(projection_ty.self_ty(), &obligation, &quiet);
Some((obligation, projection_ty.self_ty()))

5
compiler/rustc_typeck/src/check/mod.rs
View File

@ -694,10 +694,7 @@ fn bounds_from_generic_predicates<'tcx>(
where_clauses.push(format!(
"{} = {}",
tcx.def_path_str(p.projection_ty.item_def_id),
match p.term {
ty::Term::Ty(ty) => format!("{}", ty),
ty::Term::Const(c) => format!("{}", c),
}
p.term,
));
}
let where_clauses = if where_clauses.is_empty() {

2
compiler/rustc_typeck/src/impl_wf_check/min_specialization.rs
View File

@ -199,7 +199,7 @@ fn unconstrained_parent_impl_substs<'tcx>(
for (predicate, _) in impl_generic_predicates.predicates.iter() {
if let ty::PredicateKind::Projection(proj) = predicate.kind().skip_binder() {
let projection_ty = proj.projection_ty;
let projected_ty = proj.term.ty();
let projected_ty = proj.term;
let unbound_trait_ref = projection_ty.trait_ref(tcx);
if Some(unbound_trait_ref) == impl_trait_ref {

5
src/librustdoc/clean/types.rs
View File

@ -1309,10 +1309,7 @@ impl FnDecl {
GenericBound::TraitBound(PolyTrait { trait_, .. }, ..) => {
let bindings = trait_.bindings().unwrap();
let ret_ty = bindings[0].term();
let ty = match ret_ty {
Term::Type(ty) => ty,
Term::Constant(_c) => unreachable!(),
};
let ty = ret_ty.ty().expect("Unexpected constant return term");
FnRetTy::Return(ty.clone())
}
_ => panic!("unexpected desugaring of async function"),

2
src/tools/clippy/clippy_lints/src/methods/mod.rs
View File

@ -2143,7 +2143,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
if let ty::PredicateKind::Projection(projection_predicate) = predicate.kind().skip_binder() {
let assoc_ty = match projection_predicate.term {
ty::Term::Ty(ty) => ty,
ty::Term::Const(c) => c.ty,
ty::Term::Const(_c) => continue,
};
// walk the associated type and check for Self
if let Some(self_adt) = self_ty.ty_adt_def() {