Use <[T]>::array_windows for exact size windows (#24146)

# Objective

- Reduce panicking code and bounds checks.

## Solution

- Replace `<[T]>::windows` with `<[T]>::array_windows` when the window
size is constant.
- Update MSRV in affected crates (and fix the new warnings).

## Testing

- Ran `cargo test -p bevy_mesh -p bevy_gizmos -p bevy_math -p
bevy_input_focus`

## MSRV

The main `bevy` crate has a MSRV of 1.95; I've increased the MSRV to
1.94 (when `array_windows` was stabilised) for `bevy_math` and
`bevy_input_focus` in this PR. If it's too early to increase the MSRV, I
can drop the changes to these crates in this PR or convert this PR to
draft.

Author: DavidCrossman

crates/bevy_gizmos/src/primitives/dim3.rs

@@ -670,12 +670,9 @@ where
             });
 
         // base circle
-        circle_coords
-            .windows(2)
-            .map(|win| (win[0], win[1]))
-            .for_each(|(start, end)| {
-                self.gizmos.line(start, end, self.color);
-            });
+        circle_coords.array_windows().for_each(|&[start, end]| {
+            self.gizmos.line(start, end, self.color);
+        });
     }
 }
 
@@ -764,9 +761,9 @@ where
                     .collect::<Vec<_>>()
             });
 
-        let upper_lines = upper_points.windows(2).map(|win| (win[0], win[1]));
-        let lower_lines = lower_points.windows(2).map(|win| (win[0], win[1]));
-        upper_lines.chain(lower_lines).for_each(|(start, end)| {
+        let upper_lines = upper_points.array_windows();
+        let lower_lines = lower_points.array_windows();
+        upper_lines.chain(lower_lines).for_each(|&[start, end]| {
             self.gizmos.line(start, end, self.color);
         });
 
@@ -875,8 +872,8 @@ where
 
         [&inner, &outer, &top, &bottom]
             .iter()
-            .flat_map(|points| points.windows(2).map(|win| (win[0], win[1])))
-            .for_each(|(start, end)| {
+            .flat_map(|points| points.array_windows())
+            .for_each(|&[start, end]| {
                 self.gizmos.line(start, end, self.color);
             });
 

crates/bevy_input_focus/Cargo.toml

@@ -7,7 +7,7 @@ homepage = "https://bevy.org"
 repository = "https://github.com/bevyengine/bevy"
 license = "MIT OR Apache-2.0"
 keywords = ["bevy"]
-rust-version = "1.85.0"
+rust-version = "1.94.0"
 
 [features]
 default = [

crates/bevy_input_focus/src/directional_navigation.rs

@@ -357,8 +357,8 @@ impl DirectionalNavigationMap {
     ///
     /// Unlike [`add_looping_edges`](Self::add_looping_edges), this method does not loop back to the first entity.
     pub fn add_edges(&mut self, entities: &[Entity], direction: CompassOctant) {
-        for pair in entities.windows(2) {
-            self.add_symmetrical_edge(pair[0], pair[1], direction);
+        for &[a, b] in entities.array_windows() {
+            self.add_symmetrical_edge(a, b, direction);
         }
     }
 
@@ -367,10 +367,10 @@ impl DirectionalNavigationMap {
     /// This is useful for creating a circular navigation path between a set of entities, such as a menu.
     pub fn add_looping_edges(&mut self, entities: &[Entity], direction: CompassOctant) {
         self.add_edges(entities, direction);
-        if let Some((first_entity, rest)) = entities.split_first() {
-            if let Some(last_entity) = rest.last() {
-                self.add_symmetrical_edge(*last_entity, *first_entity, direction);
-            }
+        if let Some((first_entity, rest)) = entities.split_first()
+            && let Some(last_entity) = rest.last()
+        {
+            self.add_symmetrical_edge(*last_entity, *first_entity, direction);
         }
     }
 

crates/bevy_input_focus/src/lib.rs

@@ -492,10 +492,10 @@ mod tests {
         event: On<FocusedInput<KeyboardInput>>,
         mut query: Query<&mut GatherKeyboardEvents>,
     ) {
-        if let Ok(mut gather) = query.get_mut(event.focused_entity) {
-            if let Key::Character(c) = &event.input.logical_key {
-                gather.0.push_str(c.as_str());
-            }
+        if let Ok(mut gather) = query.get_mut(event.focused_entity)
+            && let Key::Character(c) = &event.input.logical_key
+        {
+            gather.0.push_str(c.as_str());
         }
     }
 

crates/bevy_input_focus/src/navigator.rs

@@ -112,10 +112,10 @@ fn score_candidate(
     let distance = bevy_math::ops::sqrt(dx * dx + dy * dy);
 
     // Check max distance
-    if let Some(max_dist) = config.max_search_distance {
-        if distance > max_dist {
-            return f32::INFINITY;
-        }
+    if let Some(max_dist) = config.max_search_distance
+        && distance > max_dist
+    {
+        return f32::INFINITY;
     }
 
     // Calculate alignment score using center-to-center direction

crates/bevy_input_focus/src/tab_navigation.rs

@@ -323,10 +323,10 @@ impl TabNavigation<'_, '_> {
         tab_group_idx: usize,
     ) {
         if let Ok((entity, tabindex, children)) = self.tabindex_query.get(parent) {
-            if let Some(tabindex) = tabindex {
-                if tabindex.0 >= 0 {
-                    out.push((entity, *tabindex, tab_group_idx));
-                }
+            if let Some(tabindex) = tabindex
+                && tabindex.0 >= 0
+            {
+                out.push((entity, *tabindex, tab_group_idx));
             }
             if let Some(children) = children {
                 for child in children.iter() {
@@ -336,11 +336,11 @@ impl TabNavigation<'_, '_> {
                     }
                 }
             }
-        } else if let Ok((_, tabgroup, children)) = self.tabgroup_query.get(parent) {
-            if !tabgroup.modal {
-                for child in children.iter() {
-                    self.gather_focusable(out, *child, tab_group_idx);
-                }
+        } else if let Ok((_, tabgroup, children)) = self.tabgroup_query.get(parent)
+            && !tabgroup.modal
+        {
+            for child in children.iter() {
+                self.gather_focusable(out, *child, tab_group_idx);
             }
         }
     }

crates/bevy_math/Cargo.toml

@@ -7,7 +7,7 @@ homepage = "https://bevy.org"
 repository = "https://github.com/bevyengine/bevy"
 license = "MIT OR Apache-2.0"
 keywords = ["bevy"]
-rust-version = "1.85.0"
+rust-version = "1.94.0"
 
 [dependencies]
 glam = { version = "0.32.0", default-features = false, features = ["bytemuck"] }

crates/bevy_math/src/cubic_splines/mod.rs

@@ -183,9 +183,8 @@ impl<P: VectorSpace<Scalar = f32>> CubicGenerator<P> for CubicHermite<P> {
     fn to_curve(&self) -> Result<CubicCurve<P>, Self::Error> {
         let segments = self
             .control_points
-            .windows(2)
-            .map(|p| {
-                let (p0, v0, p1, v1) = (p[0].0, p[0].1, p[1].0, p[1].1);
+            .array_windows()
+            .map(|&[(p0, v0), (p1, v1)]| {
                 CubicSegment::coefficients([p0, v0, p1, v1], self.char_matrix())
             })
             .collect_vec();
@@ -478,8 +477,8 @@ impl<P: VectorSpace<Scalar = f32>> CubicGenerator<P> for CubicBSpline<P> {
     fn to_curve(&self) -> Result<CubicCurve<P>, Self::Error> {
         let segments = self
             .control_points
-            .windows(4)
-            .map(|p| CubicSegment::coefficients([p[0], p[1], p[2], p[3]], self.char_matrix()))
+            .array_windows()
+            .map(|&p| CubicSegment::coefficients(p, self.char_matrix()))
             .collect_vec();
 
         if segments.is_empty() {
@@ -665,12 +664,12 @@ impl<P: VectorSpace<Scalar = f32>> CubicNurbs<P> {
 
         // Ensure the knots are non-descending (previous element is less than or equal
         // to the next)
-        if knots.windows(2).any(|win| win[0] > win[1]) {
+        if knots.array_windows().any(|[a, b]| a > b) {
             return Err(CubicNurbsError::DescendingKnots);
         }
 
         // Ensure the knots are non-constant
-        if knots.windows(2).all(|win| win[0] == win[1]) {
+        if knots.array_windows().all(|[a, b]| a == b) {
             return Err(CubicNurbsError::ConstantKnots);
         }
 
@@ -788,24 +787,18 @@ impl<P: VectorSpace<Scalar = f32>> RationalGenerator<P> for CubicNurbs<P> {
     fn to_curve(&self) -> Result<RationalCurve<P>, Self::Error> {
         let segments = self
             .control_points
-            .windows(4)
-            .zip(self.weights.windows(4))
-            .zip(self.knots.windows(8))
+            .array_windows()
+            .zip(self.weights.array_windows())
+            .zip(self.knots.array_windows())
             .filter(|(_, knots)| knots[4] - knots[3] > 0.0)
-            .map(|((points, weights), knots)| {
+            .map(|((&points, &weights), knots)| {
                 // This is curve segment i. It uses control points P_i, P_i+2, P_i+2 and P_i+3,
                 // It is associated with knot span i+3 (which is the interval between knots i+3
                 // and i+4) and its characteristic matrix uses knots i+1 through i+6 (because
                 // those define the two knot spans on either side).
                 let span = knots[4] - knots[3];
-                let coefficient_knots = knots.try_into().expect("Knot windows are of length 6");
-                let matrix = Self::generate_matrix(coefficient_knots);
-                RationalSegment::coefficients(
-                    points.try_into().expect("Point windows are of length 4"),
-                    weights.try_into().expect("Weight windows are of length 4"),
-                    span,
-                    matrix,
-                )
+                let matrix = Self::generate_matrix(knots);
+                RationalSegment::coefficients(points, weights, span, matrix)
             })
             .collect_vec();
         if segments.is_empty() {
@@ -865,13 +858,9 @@ impl<P: VectorSpace> CubicGenerator<P> for LinearSpline<P> {
     fn to_curve(&self) -> Result<CubicCurve<P>, Self::Error> {
         let segments = self
             .points
-            .windows(2)
-            .map(|points| {
-                let a = points[0];
-                let b = points[1];
-                CubicSegment {
-                    coeff: [a, b - a, P::default(), P::default()],
-                }
+            .array_windows()
+            .map(|&[a, b]| CubicSegment {
+                coeff: [a, b - a, P::default(), P::default()],
             })
             .collect_vec();
 

crates/bevy_math/src/curve/cores.rs

@@ -589,7 +589,7 @@ impl<T> ChunkedUnevenCore<T> {
             });
         }
 
-        if values.len() % times.len() != 0 {
+        if !values.len().is_multiple_of(times.len()) {
             return Err(ChunkedUnevenCoreError::NonDivisibleLengths {
                 values_len: values.len(),
                 times_len: times.len(),

crates/bevy_mesh/src/mesh.rs

@@ -2205,6 +2205,18 @@ impl Mesh {
     /// [primitive topology]: PrimitiveTopology
     /// [triangles]: Triangle3d
     pub fn triangles(&self) -> Result<impl Iterator<Item = Triangle3d> + '_, MeshTrianglesError> {
+        fn indices_to_triangle<T: TryInto<usize> + Copy>(
+            vertices: &[[f32; 3]],
+            indices: &[T; 3],
+        ) -> Option<Triangle3d> {
+            let vert0 = Vec3::from(*vertices.get(indices[0].try_into().ok()?)?);
+            let vert1 = Vec3::from(*vertices.get(indices[1].try_into().ok()?)?);
+            let vert2 = Vec3::from(*vertices.get(indices[2].try_into().ok()?)?);
+            Some(Triangle3d {
+                vertices: [vert0, vert1, vert2],
+            })
+        }
+
         let position_data = self.try_attribute(Mesh::ATTRIBUTE_POSITION)?;
 
         let Some(vertices) = position_data.as_float3() else {
@@ -2219,75 +2231,53 @@ impl Mesh {
                 // This implicitly truncates the indices to a multiple of 3.
                 let iterator = match indices {
                     Indices::U16(vec) => FourIterators::First(
-                        vec.as_chunks::<3>()
+                        vec.as_chunks()
                             .0
                             .iter()
                             .flat_map(|indices| indices_to_triangle(vertices, indices)),
                     ),
                     Indices::U32(vec) => FourIterators::Second(
-                        vec.as_chunks::<3>()
+                        vec.as_chunks()
                             .0
                             .iter()
                             .flat_map(|indices| indices_to_triangle(vertices, indices)),
                     ),
                 };
 
-                return Ok(iterator);
+                Ok(iterator)
             }
-
             PrimitiveTopology::TriangleStrip => {
                 // When indices reference out-of-bounds vertex data, the triangle is omitted.
                 // If there aren't enough indices to make a triangle, then an empty vector will be
                 // returned.
                 let iterator = match indices {
                     Indices::U16(vec) => {
-                        FourIterators::Third(vec.as_slice().windows(3).enumerate().flat_map(
-                            move |(i, indices)| {
+                        FourIterators::Third(vec.array_windows().enumerate().flat_map(
+                            |(i, indices @ &[idx0, idx1, idx2])| {
                                 if i % 2 == 0 {
                                     indices_to_triangle(vertices, indices)
                                 } else {
-                                    indices_to_triangle(
-                                        vertices,
-                                        &[indices[1], indices[0], indices[2]],
-                                    )
+                                    indices_to_triangle(vertices, &[idx1, idx0, idx2])
                                 }
                             },
                         ))
                     }
                     Indices::U32(vec) => {
-                        FourIterators::Fourth(vec.as_slice().windows(3).enumerate().flat_map(
-                            move |(i, indices)| {
+                        FourIterators::Fourth(vec.array_windows().enumerate().flat_map(
+                            |(i, indices @ &[idx0, idx1, idx2])| {
                                 if i % 2 == 0 {
                                     indices_to_triangle(vertices, indices)
                                 } else {
-                                    indices_to_triangle(
-                                        vertices,
-                                        &[indices[1], indices[0], indices[2]],
-                                    )
+                                    indices_to_triangle(vertices, &[idx1, idx0, idx2])
                                 }
                             },
                         ))
                     }
                 };
 
-                return Ok(iterator);
+                Ok(iterator)
             }
-
-            _ => {
-                return Err(MeshTrianglesError::WrongTopology);
-            }
-        };
-
-        fn indices_to_triangle<T: TryInto<usize> + Copy>(
-            vertices: &[[f32; 3]],
-            indices: &[T],
-        ) -> Option<Triangle3d> {
-            let vert0: Vec3 = Vec3::from(*vertices.get(indices[0].try_into().ok()?)?);
-            let vert1: Vec3 = Vec3::from(*vertices.get(indices[1].try_into().ok()?)?);
-            let vert2: Vec3 = Vec3::from(*vertices.get(indices[2].try_into().ok()?)?);
-            Some(Triangle3d {
-                vertices: [vert0, vert1, vert2],
-            })
+            _ => Err(MeshTrianglesError::WrongTopology),
         }
     }