ast->hir and astconv for array lengths

BoxyUwU · BoxyUwU · commit d79ca2d5b5ef · 2023-05-11T17:59:22.000+01:00
diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
@@ -77,7 +77,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 }
                 ExprKind::Repeat(expr, count) => {
                     let expr = self.lower_expr(expr);
-                    let count = self.lower_array_length(count);
+                    let count = self.lower_array_length(
+                        count,
+                        &ImplTraitContext::Disallowed(ImplTraitPosition::RepeatExprs),
+                    );
                     hir::ExprKind::Repeat(expr, count)
                 }
                 ExprKind::Tup(elts) => hir::ExprKind::Tup(self.lower_exprs(elts)),
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
@@ -257,6 +257,7 @@ enum ImplTraitContext {
 /// Position in which `impl Trait` is disallowed.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 enum ImplTraitPosition {
+    RepeatExprs,
     Path,
     Variable,
     Trait,
@@ -288,6 +289,7 @@ enum ImplTraitPosition {
 impl std::fmt::Display for ImplTraitPosition {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let name = match self {
+            ImplTraitPosition::RepeatExprs => "repeat expr lengths",
             ImplTraitPosition::Path => "paths",
             ImplTraitPosition::Variable => "variable bindings",
             ImplTraitPosition::Trait => "traits",
@@ -1363,7 +1365,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 ))
             }
             TyKind::Array(ty, length) => {
-                hir::TyKind::Array(self.lower_ty(ty, itctx), self.lower_array_length(length))
+                hir::TyKind::Array(self.lower_ty(ty, itctx), self.lower_array_length(length, itctx))
             }
             TyKind::Typeof(expr) => hir::TyKind::Typeof(self.lower_anon_const(expr)),
             TyKind::TraitObject(bounds, kind) => {
@@ -2392,12 +2394,17 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         self.expr_block(block)
     }
 
-    fn lower_array_length(&mut self, c: &AnonConst) -> hir::ArrayLen {
-        // FIXME(const_arg_kind)
-        match c.value.kind {
+    fn lower_array_length(
+        &mut self,
+        c: &AnonConst,
+        itctx: &ImplTraitContext,
+    ) -> &'hir hir::ConstArg<'hir> {
+        let const_arg = match c.value.kind {
             ExprKind::Underscore => {
                 if self.tcx.features().generic_arg_infer {
-                    hir::ArrayLen::Infer(self.lower_node_id(c.id), c.value.span)
+                    hir::ConstArg {
+                        kind: hir::ConstArgKind::Infer(self.lower_node_id(c.id), c.value.span),
+                    }
                 } else {
                     feature_err(
                         &self.tcx.sess.parse_sess,
@@ -2406,11 +2413,14 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         "using `_` for array lengths is unstable",
                     )
                     .stash(c.value.span, StashKey::UnderscoreForArrayLengths);
-                    hir::ArrayLen::Body(self.lower_anon_const(c))
+                    hir::ConstArg {
+                        kind: hir::ConstArgKind::AnonConst(c.value.span, self.lower_anon_const(c)),
+                    }
                 }
             }
-            _ => hir::ArrayLen::Body(self.lower_anon_const(c)),
-        }
+            _ => return self.lower_const_arg(c, itctx),
+        };
+        self.arena.alloc(const_arg)
     }
 
     fn lower_anon_const(&mut self, c: &AnonConst) -> hir::AnonConst {
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
@@ -250,20 +250,23 @@ pub struct ConstArg<'hir> {
 pub enum ConstArgKind<'hir> {
     AnonConst(Span, AnonConst),
     Param(HirId, QPath<'hir>),
+    Infer(HirId, Span),
 }
 
 impl<'hir> ConstArg<'hir> {
     pub fn span(&self) -> Span {
         match self.kind {
             ConstArgKind::AnonConst(span, _) => span,
             ConstArgKind::Param(_, qpath) => qpath.span(),
+            ConstArgKind::Infer(_, span) => span,
         }
     }
 
     pub fn hir_id(&self) -> HirId {
         match self.kind {
             ConstArgKind::AnonConst(_, ct) => ct.hir_id,
             ConstArgKind::Param(id, _) => id,
+            ConstArgKind::Infer(id, _) => id,
         }
     }
 }
@@ -1667,20 +1670,6 @@ impl fmt::Display for ConstContext {
 /// A literal.
 pub type Lit = Spanned<LitKind>;
 
-#[derive(Copy, Clone, Debug, HashStable_Generic)]
-pub enum ArrayLen {
-    Infer(HirId, Span),
-    Body(AnonConst),
-}
-
-impl ArrayLen {
-    pub fn hir_id(&self) -> HirId {
-        match self {
-            &ArrayLen::Infer(hir_id, _) | &ArrayLen::Body(AnonConst { hir_id, .. }) => hir_id,
-        }
-    }
-}
-
 /// A constant (expression) that's not an item or associated item,
 /// but needs its own `DefId` for type-checking, const-eval, etc.
 /// These are usually found nested inside types (e.g., array lengths)
@@ -2055,7 +2044,7 @@ pub enum ExprKind<'hir> {
     ///
     /// E.g., `[1; 5]`. The first expression is the element
     /// to be repeated; the second is the number of times to repeat it.
-    Repeat(&'hir Expr<'hir>, ArrayLen),
+    Repeat(&'hir Expr<'hir>, &'hir ConstArg<'hir>),
 
     /// A suspension point for generators (i.e., `yield <expr>`).
     Yield(&'hir Expr<'hir>, YieldSource),
@@ -2692,7 +2681,7 @@ pub enum TyKind<'hir> {
     /// A variable length slice (i.e., `[T]`).
     Slice(&'hir Ty<'hir>),
     /// A fixed length array (i.e., `[T; n]`).
-    Array(&'hir Ty<'hir>, ArrayLen),
+    Array(&'hir Ty<'hir>, &'hir ConstArg<'hir>),
     /// A raw pointer (i.e., `*const T` or `*mut T`).
     Ptr(MutTy<'hir>),
     /// A reference (i.e., `&'a T` or `&'a mut T`).
@@ -3778,7 +3767,10 @@ impl<'hir> Node<'hir> {
                 kind:
                     ExprKind::ConstBlock(AnonConst { body, .. })
                     | ExprKind::Closure(Closure { body, .. })
-                    | ExprKind::Repeat(_, ArrayLen::Body(AnonConst { body, .. })),
+                    | ExprKind::Repeat(
+                        _,
+                        ConstArg { kind: ConstArgKind::AnonConst(_, AnonConst { body, .. }) },
+                    ),
                 ..
             }) => Some(*body),
             _ => None,
diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs
@@ -329,9 +329,6 @@ pub trait Visitor<'v>: Sized {
     fn visit_pat_field(&mut self, f: &'v PatField<'v>) {
         walk_pat_field(self, f)
     }
-    fn visit_array_length(&mut self, len: &'v ArrayLen) {
-        walk_array_len(self, len)
-    }
     fn visit_anon_const(&mut self, c: &'v AnonConst) {
         walk_anon_const(self, c)
     }
@@ -670,13 +667,6 @@ pub fn walk_pat_field<'v, V: Visitor<'v>>(visitor: &mut V, field: &'v PatField<'
     visitor.visit_pat(field.pat)
 }
 
-pub fn walk_array_len<'v, V: Visitor<'v>>(visitor: &mut V, len: &'v ArrayLen) {
-    match len {
-        &ArrayLen::Infer(hir_id, _span) => visitor.visit_id(hir_id),
-        ArrayLen::Body(c) => visitor.visit_anon_const(c),
-    }
-}
-
 pub fn walk_anon_const<'v, V: Visitor<'v>>(visitor: &mut V, constant: &'v AnonConst) {
     visitor.visit_id(constant.hir_id);
     visitor.visit_nested_body(constant.body);
@@ -691,7 +681,7 @@ pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr<'v>)
         ExprKind::ConstBlock(ref anon_const) => visitor.visit_anon_const(anon_const),
         ExprKind::Repeat(ref element, ref count) => {
             visitor.visit_expr(element);
-            visitor.visit_array_length(count)
+            visitor.visit_const_arg(count);
         }
         ExprKind::Struct(ref qpath, fields, ref optional_base) => {
             visitor.visit_qpath(qpath, expression.hir_id, expression.span);
@@ -841,7 +831,7 @@ pub fn walk_ty<'v, V: Visitor<'v>>(visitor: &mut V, typ: &'v Ty<'v>) {
         }
         TyKind::Array(ref ty, ref length) => {
             visitor.visit_ty(ty);
-            visitor.visit_array_length(length)
+            visitor.visit_const_arg(length);
         }
         TyKind::TraitObject(bounds, ref lifetime, _syntax) => {
             for bound in bounds {
@@ -863,6 +853,9 @@ pub fn walk_const_arg<'v, V: Visitor<'v>>(visitor: &mut V, ct: &'v ConstArg<'v>)
             visitor.visit_id(*hir_id);
             visitor.visit_qpath(qpath, *hir_id, qpath.span())
         }
+        ConstArgKind::Infer(hir_id, _) => {
+            visitor.visit_id(*hir_id);
+        }
     }
 }
 
diff --git a/compiler/rustc_hir_analysis/src/astconv/mod.rs b/compiler/rustc_hir_analysis/src/astconv/mod.rs
@@ -62,6 +62,27 @@ pub struct PathSeg(pub DefId, pub usize);
 #[derive(Copy, Clone, Debug)]
 pub struct OnlySelfBounds(pub bool);
 
+#[derive(Debug, Copy, Clone)]
+pub enum ConstArgsParam {
+    Param(DefId),
+    ArrayLen,
+}
+
+impl From<DefId> for ConstArgsParam {
+    fn from(value: DefId) -> Self {
+        Self::Param(value)
+    }
+}
+
+impl ConstArgsParam {
+    pub fn to_ty<'tcx>(self, tcx: TyCtxt<'tcx>) -> ty::EarlyBinder<Ty<'tcx>> {
+        match self {
+            ConstArgsParam::Param(param_def_id) => tcx.type_of(param_def_id),
+            ConstArgsParam::ArrayLen => ty::EarlyBinder(tcx.types.usize),
+        }
+    }
+}
+
 pub trait AstConv<'tcx> {
     fn tcx(&self) -> TyCtxt<'tcx>;
 
@@ -3327,12 +3348,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                 tcx.at(span).type_of(def_id).subst(tcx, substs)
             }
             hir::TyKind::Array(ty, length) => {
-                let length = match length {
-                    &hir::ArrayLen::Infer(_, span) => self.ct_infer(tcx.types.usize, None, span),
-                    hir::ArrayLen::Body(constant) => {
-                        ty::Const::from_anon_const(tcx, constant.def_id)
-                    }
-                };
+                let length = self.ast_const_to_const(length, ConstArgsParam::ArrayLen);
 
                 tcx.mk_array_with_const_len(self.ast_ty_to_ty(ty), length)
             }
@@ -3755,17 +3771,28 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
         }
     }
 
-    #[instrument(level = "debug", skip(self), ret)]
     pub fn ast_const_to_const(
         &self,
         ast_ct: &hir::ConstArg<'_>,
-        param_def_id: DefId,
+        arg_param: impl Into<ConstArgsParam>,
+    ) -> Const<'tcx> {
+        self.ast_const_to_const_inner(ast_ct, arg_param.into())
+    }
+
+    #[instrument(level = "debug", skip(self), ret)]
+    fn ast_const_to_const_inner(
+        &self,
+        ast_ct: &hir::ConstArg<'_>,
+        arg_param: ConstArgsParam,
     ) -> Const<'tcx> {
         let tcx = self.tcx();
 
         match ast_ct.kind {
+            hir::ConstArgKind::Infer(_, _) => {
+                self.ct_infer(arg_param.to_ty(tcx).subst_identity(), None, ast_ct.span())
+            }
             hir::ConstArgKind::AnonConst(_, ct) => {
-                tcx.feed_anon_const_type(ct.def_id, tcx.type_of(param_def_id));
+                tcx.feed_anon_const_type(ct.def_id, arg_param.to_ty(tcx));
                 Const::from_anon_const(tcx, ct.def_id)
             }
             hir::ConstArgKind::Param(_, path) => match path {
diff --git a/compiler/rustc_hir_analysis/src/collect.rs b/compiler/rustc_hir_analysis/src/collect.rs
@@ -128,6 +128,12 @@ impl<'v> Visitor<'v> for HirPlaceholderCollector {
         }
         intravisit::walk_ty(self, t)
     }
+    fn visit_const_arg(&mut self, c: &'v hir::ConstArg<'v>) {
+        if let hir::ConstArgKind::Infer(_, span) = c.kind {
+            self.0.push(span)
+        }
+        intravisit::walk_const_arg(self, c)
+    }
     fn visit_generic_arg(&mut self, generic_arg: &'v hir::GenericArg<'v>) {
         match generic_arg {
             hir::GenericArg::Infer(inf) => {
@@ -138,12 +144,6 @@ impl<'v> Visitor<'v> for HirPlaceholderCollector {
             _ => {}
         }
     }
-    fn visit_array_length(&mut self, length: &'v hir::ArrayLen) {
-        if let &hir::ArrayLen::Infer(_, span) = length {
-            self.0.push(span);
-        }
-        intravisit::walk_array_len(self, length)
-    }
 }
 
 struct CollectItemTypesVisitor<'tcx> {
@@ -1017,7 +1017,7 @@ fn is_suggestable_infer_ty(ty: &hir::Ty<'_>) -> bool {
         Infer => true,
         Slice(ty) => is_suggestable_infer_ty(ty),
         Array(ty, length) => {
-            is_suggestable_infer_ty(ty) || matches!(length, hir::ArrayLen::Infer(_, _))
+            is_suggestable_infer_ty(ty) || matches!(length.kind, hir::ConstArgKind::Infer(_, _))
         }
         Tup(tys) => tys.iter().any(is_suggestable_infer_ty),
         Ptr(mut_ty) | Ref(_, mut_ty) => is_suggestable_infer_ty(mut_ty.ty),
diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs
@@ -350,7 +350,7 @@ impl<'a> State<'a> {
                 self.word("[");
                 self.print_type(ty);
                 self.word("; ");
-                self.print_array_length(length);
+                self.print_const_arg(length);
                 self.word("]");
             }
             hir::TyKind::Typeof(ref e) => {
@@ -376,6 +376,7 @@ impl<'a> State<'a> {
         match &const_arg.kind {
             hir::ConstArgKind::AnonConst(_, ct) => self.print_anon_const(ct),
             hir::ConstArgKind::Param(_, path) => self.print_qpath(path, false),
+            hir::ConstArgKind::Infer(_, _) => self.word("_"),
         }
         self.end();
     }
@@ -1028,13 +1029,6 @@ impl<'a> State<'a> {
         self.print_else(elseopt)
     }
 
-    pub fn print_array_length(&mut self, len: &hir::ArrayLen) {
-        match len {
-            hir::ArrayLen::Infer(_, _) => self.word("_"),
-            hir::ArrayLen::Body(ct) => self.print_anon_const(ct),
-        }
-    }
-
     pub fn print_anon_const(&mut self, constant: &hir::AnonConst) {
         self.ann.nested(self, Nested::Body(constant.body))
     }
@@ -1112,12 +1106,12 @@ impl<'a> State<'a> {
         self.end()
     }
 
-    fn print_expr_repeat(&mut self, element: &hir::Expr<'_>, count: &hir::ArrayLen) {
+    fn print_expr_repeat(&mut self, element: &hir::Expr<'_>, count: &hir::ConstArg<'_>) {
         self.ibox(INDENT_UNIT);
         self.word("[");
         self.print_expr(element);
         self.word_space(";");
-        self.print_array_length(count);
+        self.print_const_arg(count);
         self.word("]");
         self.end()
     }
diff --git a/compiler/rustc_hir_typeck/src/expr.rs b/compiler/rustc_hir_typeck/src/expr.rs
@@ -33,6 +33,7 @@ use rustc_hir::intravisit::Visitor;
 use rustc_hir::lang_items::LangItem;
 use rustc_hir::{ExprKind, HirId, QPath};
 use rustc_hir_analysis::astconv::AstConv as _;
+use rustc_hir_analysis::astconv::ConstArgsParam;
 use rustc_hir_analysis::check::ty_kind_suggestion;
 use rustc_infer::infer;
 use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
@@ -1347,7 +1348,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             return
         };
         if let hir::TyKind::Array(_, length) = ty.peel_refs().kind
-            && let hir::ArrayLen::Body(hir::AnonConst { hir_id, .. }) = length
+            && let hir::ConstArgKind::AnonConst(_, hir::AnonConst { hir_id, .. }) = length.kind
             && let Some(span) = self.tcx.hir().opt_span(hir_id)
         {
             match self.tcx.sess.diagnostic().steal_diagnostic(span, StashKey::UnderscoreForArrayLengths) {
@@ -1387,12 +1388,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     fn check_expr_repeat(
         &self,
         element: &'tcx hir::Expr<'tcx>,
-        count: &'tcx hir::ArrayLen,
+        count: &'tcx hir::ConstArg<'_>,
         expected: Expectation<'tcx>,
         expr: &'tcx hir::Expr<'tcx>,
     ) -> Ty<'tcx> {
         let tcx = self.tcx;
-        let count = self.array_length_to_const(count);
+        let count = self.const_arg_to_const(count, ConstArgsParam::ArrayLen);
         if let Some(count) = count.try_eval_target_usize(tcx, self.param_env) {
             self.suggest_array_len(expr, count);
         }
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
diff --git a/compiler/rustc_infer/src/infer/error_reporting/mod.rs b/compiler/rustc_infer/src/infer/error_reporting/mod.rs
diff --git a/compiler/rustc_trait_selection/src/traits/wf.rs b/compiler/rustc_trait_selection/src/traits/wf.rs

Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,10 @@ impl<'hir> LoweringContext<'_, 'hir> {`
`77`	`77`	`}`
`78`	`78`	`ExprKind::Repeat(expr, count) => {`
`79`	`79`	`let expr = self.lower_expr(expr);`
`80`		`- let count = self.lower_array_length(count);`
	`80`	`+ let count = self.lower_array_length(`
	`81`	`+ count,`
	`82`	`+ &ImplTraitContext::Disallowed(ImplTraitPosition::RepeatExprs),`
	`83`	`+ );`
`81`	`84`	`hir::ExprKind::Repeat(expr, count)`
`82`	`85`	`}`
`83`	`86`	`ExprKind::Tup(elts) => hir::ExprKind::Tup(self.lower_exprs(elts)),`
Original file line number	Diff line number	Diff line change
`@@ -329,9 +329,6 @@ pub trait Visitor<'v>: Sized {`
`329`	`329`	`fn visit_pat_field(&mut self, f: &'v PatField<'v>) {`
`330`	`330`	`walk_pat_field(self, f)`
`331`	`331`	`}`
`332`		`- fn visit_array_length(&mut self, len: &'v ArrayLen) {`
`333`		`- walk_array_len(self, len)`
`334`		`- }`
`335`	`332`	`fn visit_anon_const(&mut self, c: &'v AnonConst) {`
`336`	`333`	`walk_anon_const(self, c)`
`337`	`334`	`}`
`@@ -670,13 +667,6 @@ pub fn walk_pat_field<'v, V: Visitor<'v>>(visitor: &mut V, field: &'v PatField<'`
`670`	`667`	`visitor.visit_pat(field.pat)`
`671`	`668`	`}`
`672`	`669`
`673`		`-pub fn walk_array_len<'v, V: Visitor<'v>>(visitor: &mut V, len: &'v ArrayLen) {`
`674`		`- match len {`
`675`		`- &ArrayLen::Infer(hir_id, _span) => visitor.visit_id(hir_id),`
`676`		`- ArrayLen::Body(c) => visitor.visit_anon_const(c),`
`677`		`- }`
`678`		`-}`
`679`		`-`
`680`	`670`	`pub fn walk_anon_const<'v, V: Visitor<'v>>(visitor: &mut V, constant: &'v AnonConst) {`
`681`	`671`	`visitor.visit_id(constant.hir_id);`
`682`	`672`	`visitor.visit_nested_body(constant.body);`
`@@ -691,7 +681,7 @@ pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr<'v>)`
`691`	`681`	`ExprKind::ConstBlock(ref anon_const) => visitor.visit_anon_const(anon_const),`
`692`	`682`	`ExprKind::Repeat(ref element, ref count) => {`
`693`	`683`	`visitor.visit_expr(element);`
`694`		`- visitor.visit_array_length(count)`
	`684`	`+ visitor.visit_const_arg(count);`
`695`	`685`	`}`
`696`	`686`	`ExprKind::Struct(ref qpath, fields, ref optional_base) => {`
`697`	`687`	`visitor.visit_qpath(qpath, expression.hir_id, expression.span);`
`@@ -841,7 +831,7 @@ pub fn walk_ty<'v, V: Visitor<'v>>(visitor: &mut V, typ: &'v Ty<'v>) {`
`841`	`831`	`}`
`842`	`832`	`TyKind::Array(ref ty, ref length) => {`
`843`	`833`	`visitor.visit_ty(ty);`
`844`		`- visitor.visit_array_length(length)`
	`834`	`+ visitor.visit_const_arg(length);`
`845`	`835`	`}`
`846`	`836`	`TyKind::TraitObject(bounds, ref lifetime, _syntax) => {`
`847`	`837`	`for bound in bounds {`
`@@ -863,6 +853,9 @@ pub fn walk_const_arg<'v, V: Visitor<'v>>(visitor: &mut V, ct: &'v ConstArg<'v>)`
`863`	`853`	`visitor.visit_id(*hir_id);`
`864`	`854`	`visitor.visit_qpath(qpath, *hir_id, qpath.span())`
`865`	`855`	`}`
	`856`	`+ ConstArgKind::Infer(hir_id, _) => {`
	`857`	`+ visitor.visit_id(*hir_id);`
	`858`	`+ }`
`866`	`859`	`}`
`867`	`860`	`}`
`868`	`861`
Original file line number	Diff line number	Diff line change
`@@ -128,6 +128,12 @@ impl<'v> Visitor<'v> for HirPlaceholderCollector {`
`128`	`128`	`}`
`129`	`129`	`intravisit::walk_ty(self, t)`
`130`	`130`	`}`
	`131`	`+ fn visit_const_arg(&mut self, c: &'v hir::ConstArg<'v>) {`
	`132`	`+ if let hir::ConstArgKind::Infer(_, span) = c.kind {`
	`133`	`+ self.0.push(span)`
	`134`	`+ }`
	`135`	`+ intravisit::walk_const_arg(self, c)`
	`136`	`+ }`
`131`	`137`	`fn visit_generic_arg(&mut self, generic_arg: &'v hir::GenericArg<'v>) {`
`132`	`138`	`match generic_arg {`
`133`	`139`	`hir::GenericArg::Infer(inf) => {`
`@@ -138,12 +144,6 @@ impl<'v> Visitor<'v> for HirPlaceholderCollector {`
`138`	`144`	`_ => {}`
`139`	`145`	`}`
`140`	`146`	`}`
`141`		`- fn visit_array_length(&mut self, length: &'v hir::ArrayLen) {`
`142`		`- if let &hir::ArrayLen::Infer(_, span) = length {`
`143`		`- self.0.push(span);`
`144`		`- }`
`145`		`- intravisit::walk_array_len(self, length)`
`146`		`- }`
`147`	`147`	`}`
`148`	`148`
`149`	`149`	`struct CollectItemTypesVisitor<'tcx> {`
`@@ -1017,7 +1017,7 @@ fn is_suggestable_infer_ty(ty: &hir::Ty<'_>) -> bool {`
`1017`	`1017`	`Infer => true,`
`1018`	`1018`	`Slice(ty) => is_suggestable_infer_ty(ty),`
`1019`	`1019`	`Array(ty, length) => {`
`1020`		`- is_suggestable_infer_ty(ty) \|\| matches!(length, hir::ArrayLen::Infer(_, _))`
	`1020`	`+ is_suggestable_infer_ty(ty) \|\| matches!(length.kind, hir::ConstArgKind::Infer(_, _))`
`1021`	`1021`	`}`
`1022`	`1022`	`Tup(tys) => tys.iter().any(is_suggestable_infer_ty),`
`1023`	`1023`	`Ptr(mut_ty) \| Ref(_, mut_ty) => is_suggestable_infer_ty(mut_ty.ty),`