Rename AstConv to HIR ty lowering

This includes updating astconv-related items and a few local variables.

Author: fmease

compiler/rustc_hir_analysis/src/astconv/bounds.rs

@@ -9,13 +9,13 @@ use rustc_span::{ErrorGuaranteed, Span};
 use rustc_trait_selection::traits;
 use smallvec::SmallVec;
 
-use crate::astconv::{AstConv, OnlySelfBounds, PredicateFilter};
+use crate::astconv::{HirTyLowerer, OnlySelfBounds, PredicateFilter};
 use crate::bounds::Bounds;
 use crate::errors;
 
-impl<'tcx> dyn AstConv<'tcx> + '_ {
+impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
     /// Sets `implicitly_sized` to true on `Bounds` if necessary
-    pub(crate) fn add_implicitly_sized(
+    pub(crate) fn add_sized_bound(
         &self,
         bounds: &mut Bounds<'tcx>,
         self_ty: Ty<'tcx>,
@@ -114,7 +114,7 @@ impl<'tcx> dyn AstConv<'tcx> + '_ {
     /// `param_ty` and `ast_bounds`. See `instantiate_poly_trait_ref`
     /// for more details.
     #[instrument(level = "debug", skip(self, ast_bounds, bounds))]
-    pub(crate) fn add_bounds<'hir, I: Iterator<Item = &'hir hir::GenericBound<'tcx>>>(
+    pub(crate) fn lower_poly_bounds<'hir, I: Iterator<Item = &'hir hir::GenericBound<'tcx>>>(
         &self,
         param_ty: Ty<'tcx>,
         ast_bounds: I,
@@ -142,7 +142,7 @@ impl<'tcx> dyn AstConv<'tcx> + '_ {
                         }
                         hir::TraitBoundModifier::Maybe => continue,
                     };
-                    let _ = self.instantiate_poly_trait_ref(
+                    let _ = self.lower_poly_trait_ref(
                         &poly_trait_ref.trait_ref,
                         poly_trait_ref.span,
                         constness,
@@ -154,7 +154,7 @@ impl<'tcx> dyn AstConv<'tcx> + '_ {
                     );
                 }
                 hir::GenericBound::Outlives(lifetime) => {
-                    let region = self.ast_region_to_region(lifetime, None);
+                    let region = self.lower_lifetime(lifetime, None);
                     bounds.push_region_bound(
                         self.tcx(),
                         ty::Binder::bind_with_vars(
@@ -184,7 +184,7 @@ impl<'tcx> dyn AstConv<'tcx> + '_ {
     /// example above, but is not true in supertrait listings like `trait Foo: Bar + Baz`.
     ///
     /// `span` should be the declaration size of the parameter.
-    pub(crate) fn compute_bounds(
+    pub(crate) fn lower_mono_bounds(
         &self,
         param_ty: Ty<'tcx>,
         ast_bounds: &[hir::GenericBound<'tcx>],
@@ -199,7 +199,7 @@ impl<'tcx> dyn AstConv<'tcx> + '_ {
             PredicateFilter::SelfOnly | PredicateFilter::SelfThatDefines(_) => OnlySelfBounds(true),
         };
 
-        self.add_bounds(
+        self.lower_poly_bounds(
             param_ty,
             ast_bounds.iter().filter(|bound| match filter {
                 PredicateFilter::All
@@ -232,7 +232,7 @@ impl<'tcx> dyn AstConv<'tcx> + '_ {
     /// `trait_ref` here will be `for<'a> T: Iterator`. The `binding` data however is from *inside*
     /// the binder (e.g., `&'a u32`) and hence may reference bound regions.
     #[instrument(level = "debug", skip(self, bounds, speculative, dup_bindings, path_span))]
-    pub(super) fn add_predicates_for_ast_type_binding(
+    pub(super) fn lower_assoc_item_binding(
         &self,
         hir_ref_id: hir::HirId,
         trait_ref: ty::PolyTraitRef<'tcx>,
@@ -271,7 +271,7 @@ impl<'tcx> dyn AstConv<'tcx> + '_ {
             ty::AssocKind::Type
         };
 
-        let candidate = if self.trait_defines_associated_item_named(
+        let candidate = if self.probe_trait_that_defines_assoc_item(
             trait_ref.def_id(),
             assoc_kind,
             binding.ident,
@@ -281,7 +281,7 @@ impl<'tcx> dyn AstConv<'tcx> + '_ {
         } else {
             // Otherwise, we have to walk through the supertraits to find
             // one that does define it.
-            self.one_bound_for_assoc_item(
+            self.probe_single_bound_for_assoc_item(
                 || traits::supertraits(tcx, trait_ref),
                 trait_ref.skip_binder().print_only_trait_name(),
                 None,
@@ -418,7 +418,7 @@ impl<'tcx> dyn AstConv<'tcx> + '_ {
                     infer_args: false,
                 };
 
-                let alias_args = self.create_args_for_associated_item(
+                let alias_args = self.lower_generic_args_of_assoc_item(
                     path_span,
                     assoc_item.def_id,
                     &item_segment,
@@ -459,7 +459,7 @@ impl<'tcx> dyn AstConv<'tcx> + '_ {
             }
             hir::TypeBindingKind::Equality { term } => {
                 let term = match term {
-                    hir::Term::Ty(ty) => self.ast_ty_to_ty(ty).into(),
+                    hir::Term::Ty(ty) => self.lower_ty(ty).into(),
                     hir::Term::Const(ct) => ty::Const::from_anon_const(tcx, ct.def_id).into(),
                 };
 
@@ -524,7 +524,7 @@ impl<'tcx> dyn AstConv<'tcx> + '_ {
                 // for the `Self` type.
                 if !only_self_bounds.0 {
                     let param_ty = Ty::new_alias(tcx, ty::Projection, projection_ty.skip_binder());
-                    self.add_bounds(
+                    self.lower_poly_bounds(
                         param_ty,
                         ast_bounds.iter(),
                         bounds,

compiler/rustc_hir_analysis/src/astconv/errors.rs

@@ -1,4 +1,4 @@
-use crate::astconv::AstConv;
+use crate::astconv::HirTyLowerer;
 use crate::errors::{
     self, AssocTypeBindingNotAllowed, ManualImplementation, MissingTypeParams,
     ParenthesizedFnTraitExpansion,
@@ -22,7 +22,7 @@ use rustc_span::symbol::{sym, Ident};
 use rustc_span::{Span, Symbol, DUMMY_SP};
 use rustc_trait_selection::traits::object_safety_violations_for_assoc_item;
 
-impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
+impl<'o, 'tcx> dyn HirTyLowerer<'tcx> + 'o {
     /// On missing type parameters, emit an E0393 error and provide a structured suggestion using
     /// the type parameter's name as a placeholder.
     pub(crate) fn complain_about_missing_type_params(
@@ -311,7 +311,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
         // FIXME(associated_const_equality): This has quite a few false positives and negatives.
         let wrap_in_braces_sugg = if let Some(binding) = binding
             && let hir::TypeBindingKind::Equality { term: hir::Term::Ty(hir_ty) } = binding.kind
-            && let ty = self.ast_ty_to_ty(hir_ty)
+            && let ty = self.lower_ty(hir_ty)
             && (ty.is_enum() || ty.references_error())
             && tcx.features().associated_const_equality
         {
@@ -918,7 +918,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
 }
 
 /// Emits an error regarding forbidden type binding associations
-pub fn prohibit_assoc_ty_binding(
+pub fn prohibit_assoc_item_binding(
     tcx: TyCtxt<'_>,
     span: Span,
     segment: Option<(&hir::PathSegment<'_>, Span)>,

compiler/rustc_hir_analysis/src/astconv/generics.rs

@@ -1,7 +1,7 @@
 use super::IsMethodCall;
 use crate::astconv::{
-    errors::prohibit_assoc_ty_binding, CreateInstantiationsForGenericArgsCtxt, ExplicitLateBound,
-    GenericArgCountMismatch, GenericArgCountResult, GenericArgPosition,
+    errors::prohibit_assoc_item_binding, ExplicitLateBound, GenericArgCountMismatch,
+    GenericArgCountResult, GenericArgPosition, GenericArgsLowerer,
 };
 use crate::structured_errors::{GenericArgsInfo, StructuredDiag, WrongNumberOfGenericArgs};
 use rustc_ast::ast::ParamKindOrd;
@@ -170,14 +170,14 @@ fn generic_arg_mismatch_err(
 ///   instantiate a `GenericArg`.
 /// - `inferred_kind`: if no parameter was provided, and inference is enabled, then
 ///   creates a suitable inference variable.
-pub fn create_args_for_parent_generic_args<'tcx: 'a, 'a>(
+pub fn lower_generic_args<'tcx: 'a, 'a>(
     tcx: TyCtxt<'tcx>,
     def_id: DefId,
     parent_args: &[ty::GenericArg<'tcx>],
     has_self: bool,
     self_ty: Option<Ty<'tcx>>,
     arg_count: &GenericArgCountResult,
-    ctx: &mut impl CreateInstantiationsForGenericArgsCtxt<'a, 'tcx>,
+    ctx: &mut impl GenericArgsLowerer<'a, 'tcx>,
 ) -> GenericArgsRef<'tcx> {
     // Collect the segments of the path; we need to instantiate arguments
     // for parameters throughout the entire path (wherever there are
@@ -458,7 +458,7 @@ pub(crate) fn check_generic_arg_count(
     if gen_pos != GenericArgPosition::Type
         && let Some(b) = gen_args.bindings.first()
     {
-        prohibit_assoc_ty_binding(tcx, b.span, None);
+        prohibit_assoc_item_binding(tcx, b.span, None);
     }
 
     let explicit_late_bound =

compiler/rustc_hir_analysis/src/astconv/lint.rs

@@ -6,9 +6,9 @@ use rustc_lint_defs::{builtin::BARE_TRAIT_OBJECTS, Applicability};
 use rustc_span::Span;
 use rustc_trait_selection::traits::error_reporting::suggestions::NextTypeParamName;
 
-use super::AstConv;
+use super::HirTyLowerer;
 
-impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
+impl<'o, 'tcx> dyn HirTyLowerer<'tcx> + 'o {
     /// Make sure that we are in the condition to suggest the blanket implementation.
     pub(super) fn maybe_lint_blanket_trait_impl<G: EmissionGuarantee>(
         &self,