Address nits

Co-authored-by: Oli Scherer <[email protected]>

Author: compiler-errors

compiler/rustc_hir_analysis/src/check/mod.rs

@@ -352,7 +352,7 @@ fn bounds_from_generic_predicates<'tcx>(
         // insert the associated types where they correspond, but for now let's be "lazy" and
         // propose this instead of the following valid resugaring:
         // `T: Trait, Trait::Assoc = K` → `T: Trait<Assoc = K>`
-        where_clauses.push(format!("{} = {}", tcx.def_path_str(p.projection_ty.def_id), p.term,));
+        where_clauses.push(format!("{} = {}", tcx.def_path_str(p.projection_ty.def_id), p.term));
     }
     let where_clauses = if where_clauses.is_empty() {
         String::new()

compiler/rustc_middle/src/ty/fast_reject.rs

@@ -126,7 +126,7 @@ pub fn simplify_type<'tcx>(
             TreatParams::AsPlaceholder => Some(PlaceholderSimplifiedType),
             TreatParams::AsInfer => None,
         },
-        ty::Alias(ty::Opaque, ..) | ty::Alias(ty::Projection, _) => match treat_params {
+        ty::Alias(..) => match treat_params {
             // When treating `ty::Param` as a placeholder, projections also
             // don't unify with anything else as long as they are fully normalized.
             //
@@ -225,10 +225,7 @@ impl DeepRejectCtxt {
         match impl_ty.kind() {
             // Start by checking whether the type in the impl may unify with
             // pretty much everything. Just return `true` in that case.
-            ty::Param(_)
-            | ty::Alias(ty::Projection, _)
-            | ty::Error(_)
-            | ty::Alias(ty::Opaque, ..) => return true,
+            ty::Param(_) | ty::Error(_) | ty::Alias(..) => return true,
             // These types only unify with inference variables or their own
             // variant.
             ty::Bool
@@ -326,8 +323,6 @@ impl DeepRejectCtxt {
                 _ => false,
             },
 
-            ty::Alias(ty::Opaque, ..) => true,
-
             // Impls cannot contain these types as these cannot be named directly.
             ty::FnDef(..) | ty::Closure(..) | ty::Generator(..) => false,
 
@@ -347,7 +342,7 @@ impl DeepRejectCtxt {
             // projections can unify with other stuff.
             //
             // Looking forward to lazy normalization this is the safer strategy anyways.
-            ty::Alias(ty::Projection, _) => true,
+            ty::Alias(..) => true,
 
             ty::Error(_) => true,
 

compiler/rustc_trait_selection/src/traits/project.rs

@@ -1377,12 +1377,7 @@ fn assemble_candidates_from_trait_def<'cx, 'tcx>(
     // Check whether the self-type is itself a projection.
     // If so, extract what we know from the trait and try to come up with a good answer.
     let bounds = match *obligation.predicate.self_ty().kind() {
-        ty::Alias(ty::Projection, ref data) => {
-            tcx.bound_item_bounds(data.def_id).subst(tcx, data.substs)
-        }
-        ty::Alias(ty::Opaque, ty::AliasTy { def_id, substs }) => {
-            tcx.bound_item_bounds(def_id).subst(tcx, substs)
-        }
+        ty::Alias(_, ref data) => tcx.bound_item_bounds(data.def_id).subst(tcx, data.substs),
         ty::Infer(ty::TyVar(_)) => {
             // If the self-type is an inference variable, then it MAY wind up
             // being a projected type, so induce an ambiguity.