Always pass a &PathSegment in astconv.

Author: cjgillot

compiler/rustc_hir_analysis/src/astconv/generics.rs

@@ -382,25 +382,13 @@ pub fn check_generic_arg_count_for_call(
     seg: &hir::PathSegment<'_>,
     is_method_call: IsMethodCall,
 ) -> GenericArgCountResult {
-    let empty_args = hir::GenericArgs::none();
-    let gen_args = seg.args.unwrap_or(&empty_args);
     let gen_pos = match is_method_call {
         IsMethodCall::Yes => GenericArgPosition::MethodCall,
         IsMethodCall::No => GenericArgPosition::Value,
     };
     let has_self = generics.parent.is_none() && generics.has_self;
 
-    check_generic_arg_count(
-        tcx,
-        span,
-        def_id,
-        seg,
-        generics,
-        gen_args,
-        gen_pos,
-        has_self,
-        seg.infer_args,
-    )
+    check_generic_arg_count(tcx, span, def_id, seg, generics, gen_pos, has_self)
 }
 
 /// Checks that the correct number of generic arguments have been provided.
@@ -412,13 +400,12 @@ pub(crate) fn check_generic_arg_count(
     def_id: DefId,
     seg: &hir::PathSegment<'_>,
     gen_params: &ty::Generics,
-    gen_args: &hir::GenericArgs<'_>,
     gen_pos: GenericArgPosition,
     has_self: bool,
-    infer_args: bool,
 ) -> GenericArgCountResult {
     let default_counts = gen_params.own_defaults();
     let param_counts = gen_params.own_counts();
+    let gen_args = seg.args();
 
     // Subtracting from param count to ensure type params synthesized from `impl Trait`
     // cannot be explicitly specified.
@@ -429,14 +416,13 @@ pub(crate) fn check_generic_arg_count(
         .count();
     let named_type_param_count = param_counts.types - has_self as usize - synth_type_param_count;
     let infer_lifetimes =
-        (gen_pos != GenericArgPosition::Type || infer_args) && !gen_args.has_lifetime_params();
+        (gen_pos != GenericArgPosition::Type || seg.infer_args) && !gen_args.has_lifetime_params();
 
     if gen_pos != GenericArgPosition::Type && let Some(b) = gen_args.bindings.first() {
             prohibit_assoc_ty_binding(tcx, b.span);
         }
 
-    let explicit_late_bound =
-        prohibit_explicit_late_bound_lifetimes(tcx, gen_params, gen_args, gen_pos);
+    let explicit_late_bound = prohibit_explicit_late_bound_lifetimes(tcx, gen_params, seg, gen_pos);
 
     let mut invalid_args = vec![];
 
@@ -560,7 +546,7 @@ pub(crate) fn check_generic_arg_count(
     };
 
     let args_correct = {
-        let expected_min = if infer_args {
+        let expected_min = if seg.infer_args {
             0
         } else {
             param_counts.consts + named_type_param_count
@@ -598,9 +584,10 @@ pub fn prohibit_assoc_ty_binding(tcx: TyCtxt<'_>, span: Span) {
 pub(crate) fn prohibit_explicit_late_bound_lifetimes(
     tcx: TyCtxt<'_>,
     def: &ty::Generics,
-    args: &hir::GenericArgs<'_>,
+    seg: &hir::PathSegment<'_>,
     position: GenericArgPosition,
 ) -> ExplicitLateBound {
+    let args = seg.args();
     let infer_lifetimes = position != GenericArgPosition::Type && !args.has_lifetime_params();
 
     if infer_lifetimes {

compiler/rustc_hir_analysis/src/astconv/mod.rs

@@ -288,8 +288,6 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
             def_id,
             &[],
             item_segment,
-            item_segment.args(),
-            item_segment.infer_args,
             None,
             ty::BoundConstness::NotConst,
         );
@@ -332,14 +330,12 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
     /// type itself: `['a]`. The returned `SubstsRef` concatenates these two
     /// lists: `[Vec<u8>, u8, 'a]`.
     #[instrument(level = "debug", skip(self, span), ret)]
-    fn create_substs_for_ast_path<'a>(
+    fn create_substs_for_ast_path(
         &self,
         span: Span,
         def_id: DefId,
         parent_substs: &[subst::GenericArg<'tcx>],
         seg: &hir::PathSegment<'_>,
-        generic_args: &'a hir::GenericArgs<'_>,
-        infer_args: bool,
         self_ty: Option<Ty<'tcx>>,
         constness: ty::BoundConstness,
     ) -> (SubstsRef<'tcx>, GenericArgCountResult) {
@@ -370,10 +366,8 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
             def_id,
             seg,
             generics,
-            generic_args,
             GenericArgPosition::Type,
             self_ty.is_some(),
-            infer_args,
         );
 
         // Skip processing if type has no generic parameters.
@@ -540,9 +534,9 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
             astconv: self,
             def_id,
             span,
-            generic_args,
+            generic_args: seg.args(),
             inferred_params: vec![],
-            infer_args,
+            infer_args: seg.infer_args,
         };
         let substs = create_substs_for_generic_args(
             tcx,
@@ -623,8 +617,6 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
             item_def_id,
             parent_substs,
             item_segment,
-            item_segment.args(),
-            item_segment.infer_args,
             None,
             ty::BoundConstness::NotConst,
         );
@@ -671,17 +663,13 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
         trait_ref_span: Span,
         trait_def_id: DefId,
         trait_segment: &hir::PathSegment<'_>,
-        args: &GenericArgs<'_>,
-        infer_args: bool,
         self_ty: Ty<'tcx>,
     ) -> GenericArgCountResult {
         let (substs, arg_count) = self.create_substs_for_ast_path(
             trait_ref_span,
             trait_def_id,
             &[],
             trait_segment,
-            args,
-            infer_args,
             Some(self_ty),
             constness,
         );
@@ -690,7 +678,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
         let bound_vars = tcx.late_bound_vars(hir_id);
         debug!(?bound_vars);
 
-        let assoc_bindings = self.create_assoc_bindings_for_generic_args(args);
+        let assoc_bindings = self.create_assoc_bindings_for_generic_args(trait_segment.args());
 
         let poly_trait_ref =
             ty::Binder::bind_with_vars(tcx.mk_trait_ref(trait_def_id, substs), bound_vars);
@@ -751,8 +739,6 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
         let trait_ref_span = trait_ref.path.span;
         let trait_def_id = trait_ref.trait_def_id().unwrap_or_else(|| FatalError.raise());
         let trait_segment = trait_ref.path.segments.last().unwrap();
-        let args = trait_segment.args();
-        let infer_args = trait_segment.infer_args;
 
         self.prohibit_generics(trait_ref.path.segments.split_last().unwrap().1.iter(), |_| {});
         self.complain_about_internal_fn_trait(span, trait_def_id, trait_segment, false);
@@ -767,8 +753,6 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
             trait_ref_span,
             trait_def_id,
             trait_segment,
-            args,
-            infer_args,
             self_ty,
         )
     }
@@ -787,8 +771,13 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
         let speculative = false;
         let trait_ref_span = span;
         let trait_def_id = self.tcx().require_lang_item(lang_item, Some(span));
-        let trait_segment = &hir::PathSegment::invalid();
-        let infer_args = false;
+        let trait_segment = &hir::PathSegment {
+            ident: Ident::empty(),
+            hir_id: hir::HirId::INVALID,
+            res: Res::Err,
+            args: Some(args),
+            infer_args: false,
+        };
 
         self.instantiate_poly_trait_ref_inner(
             hir_id,
@@ -800,8 +789,6 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
             trait_ref_span,
             trait_def_id,
             trait_segment,
-            args,
-            infer_args,
             self_ty,
         );
     }
@@ -846,8 +833,6 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
             trait_def_id,
             &[],
             trait_segment,
-            trait_segment.args(),
-            trait_segment.infer_args,
             Some(self_ty),
             constness,
         )
@@ -3074,8 +3059,6 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                     def_id,
                     &[],
                     &hir::PathSegment::invalid(),
-                    &GenericArgs::none(),
-                    true,
                     None,
                     ty::BoundConstness::NotConst,
                 );