k256+primeorder: organize group trait impls (#1401)

- Creates a logical comment-delimited section of the source for `group`
  trait impls
- Alphabetizes trait impls by name
- Adds some explanatory comments

Author: tarcieri

k256/src/arithmetic/projective.rs

@@ -15,12 +15,13 @@ use elliptic_curve::{
         cofactor::CofactorGroup,
         prime::{PrimeCurve, PrimeCurveAffine, PrimeGroup},
     },
+    ops::BatchInvert,
+    point::NonIdentity,
     rand_core::TryRngCore,
     sec1::{FromEncodedPoint, ToEncodedPoint},
     subtle::{Choice, ConditionallySelectable, ConstantTimeEq, CtOption},
     zeroize::DefaultIsZeroes,
 };
-use elliptic_curve::{ops::BatchInvert, point::NonIdentity};
 
 #[cfg(feature = "alloc")]
 use alloc::vec::Vec;
@@ -387,6 +388,16 @@ impl ConstantTimeEq for ProjectivePoint {
     }
 }
 
+impl Default for ProjectivePoint {
+    fn default() -> Self {
+        Self::IDENTITY
+    }
+}
+
+impl DefaultIsZeroes for ProjectivePoint {}
+
+impl Eq for ProjectivePoint {}
+
 impl PartialEq for ProjectivePoint {
     fn eq(&self, other: &Self) -> bool {
         self.ct_eq(other).into()
@@ -405,7 +416,42 @@ impl PartialEq<ProjectivePoint> for AffinePoint {
     }
 }
 
-impl Eq for ProjectivePoint {}
+//
+// `group` trait impls
+//
+
+/// secp256k1 has a cofactor of 1.
+impl CofactorGroup for ProjectivePoint {
+    type Subgroup = Self;
+
+    fn clear_cofactor(&self) -> Self::Subgroup {
+        *self
+    }
+
+    fn into_subgroup(self) -> CtOption<Self::Subgroup> {
+        CtOption::new(self, Choice::from(1))
+    }
+
+    fn is_torsion_free(&self) -> Choice {
+        Choice::from(1)
+    }
+}
+
+impl CurveGroup for ProjectivePoint {
+    type AffineRepr = AffinePoint;
+
+    fn to_affine(&self) -> AffinePoint {
+        ProjectivePoint::to_affine(self)
+    }
+
+    #[cfg(feature = "alloc")]
+    #[inline]
+    fn batch_normalize(projective: &[Self], affine: &mut [Self::AffineRepr]) {
+        assert_eq!(projective.len(), affine.len());
+        let mut zs = vec![FieldElement::ONE; projective.len()];
+        batch_normalize_generic(projective, zs.as_mut_slice(), affine);
+    }
+}
 
 impl Group for ProjectivePoint {
     type Scalar = Scalar;
@@ -452,51 +498,15 @@ impl GroupEncoding for ProjectivePoint {
     }
 }
 
-impl CofactorGroup for ProjectivePoint {
-    type Subgroup = ProjectivePoint;
-
-    fn clear_cofactor(&self) -> Self::Subgroup {
-        *self
-    }
-
-    fn into_subgroup(self) -> CtOption<Self::Subgroup> {
-        CtOption::new(self, Choice::from(1))
-    }
-
-    fn is_torsion_free(&self) -> Choice {
-        Choice::from(1)
-    }
-}
-
-impl PrimeGroup for ProjectivePoint {}
-
-impl CurveGroup for ProjectivePoint {
-    type AffineRepr = AffinePoint;
-
-    fn to_affine(&self) -> AffinePoint {
-        ProjectivePoint::to_affine(self)
-    }
-
-    #[cfg(feature = "alloc")]
-    #[inline]
-    fn batch_normalize(projective: &[Self], affine: &mut [Self::AffineRepr]) {
-        assert_eq!(projective.len(), affine.len());
-        let mut zs = vec![FieldElement::ONE; projective.len()];
-        batch_normalize_generic(projective, zs.as_mut_slice(), affine);
-    }
-}
-
 impl PrimeCurve for ProjectivePoint {
     type Affine = AffinePoint;
 }
 
-impl Default for ProjectivePoint {
-    fn default() -> Self {
-        Self::IDENTITY
-    }
-}
+impl PrimeGroup for ProjectivePoint {}
 
-impl DefaultIsZeroes for ProjectivePoint {}
+//
+// `core::ops` trait impls
+//
 
 impl Add<&ProjectivePoint> for &ProjectivePoint {
     type Output = ProjectivePoint;

primeorder/src/projective.rs

@@ -222,6 +222,55 @@ where
     }
 }
 
+//
+// `group` trait impls
+//
+
+/// Prime order elliptic curves have a cofactor of 1.
+impl<C> CofactorGroup for ProjectivePoint<C>
+where
+    C: PrimeCurveParams,
+    CompressedPoint<C>: Send + Sync,
+    FieldBytes<C>: Copy,
+    FieldBytesSize<C>: ModulusSize,
+    CompressedPoint<C>: Copy,
+    <UncompressedPointSize<C> as ArraySize>::ArrayType<u8>: Copy,
+{
+    type Subgroup = ProjectivePoint<C>;
+
+    fn clear_cofactor(&self) -> Self::Subgroup {
+        *self
+    }
+
+    fn into_subgroup(self) -> CtOption<Self::Subgroup> {
+        CtOption::new(self, Choice::from(1))
+    }
+
+    fn is_torsion_free(&self) -> Choice {
+        Choice::from(1)
+    }
+}
+
+impl<C> CurveGroup for ProjectivePoint<C>
+where
+    C: PrimeCurveParams,
+    FieldBytes<C>: Copy,
+{
+    type AffineRepr = AffinePoint<C>;
+
+    fn to_affine(&self) -> AffinePoint<C> {
+        ProjectivePoint::to_affine(self)
+    }
+
+    #[cfg(feature = "alloc")]
+    #[inline]
+    fn batch_normalize(projective: &[Self], affine: &mut [Self::AffineRepr]) {
+        assert_eq!(projective.len(), affine.len());
+        let mut zs = vec![C::FieldElement::ONE; projective.len()];
+        batch_normalize_generic(projective, zs.as_mut_slice(), affine);
+    }
+}
+
 impl<C> Group for ProjectivePoint<C>
 where
     C: PrimeCurveParams,
@@ -275,50 +324,33 @@ where
     }
 }
 
-impl<C> CofactorGroup for ProjectivePoint<C>
+impl<C> PrimeCurve for ProjectivePoint<C>
 where
+    Self: Double,
     C: PrimeCurveParams,
-    CompressedPoint<C>: Send + Sync,
+    CompressedPoint<C>: Copy + Send + Sync,
     FieldBytes<C>: Copy,
     FieldBytesSize<C>: ModulusSize,
-    CompressedPoint<C>: Copy,
     <UncompressedPointSize<C> as ArraySize>::ArrayType<u8>: Copy,
 {
-    type Subgroup = ProjectivePoint<C>;
-
-    fn clear_cofactor(&self) -> Self::Subgroup {
-        *self
-    }
-
-    fn into_subgroup(self) -> CtOption<Self::Subgroup> {
-        CtOption::new(self, Choice::from(1))
-    }
-
-    fn is_torsion_free(&self) -> Choice {
-        Choice::from(1)
-    }
+    type Affine = AffinePoint<C>;
 }
 
-impl<C> CurveGroup for ProjectivePoint<C>
+impl<C> PrimeGroup for ProjectivePoint<C>
 where
+    Self: Double,
     C: PrimeCurveParams,
+    CompressedPoint<C>: Copy + Send + Sync,
     FieldBytes<C>: Copy,
+    FieldBytesSize<C>: ModulusSize,
+    <UncompressedPointSize<C> as ArraySize>::ArrayType<u8>: Copy,
 {
-    type AffineRepr = AffinePoint<C>;
-
-    fn to_affine(&self) -> AffinePoint<C> {
-        ProjectivePoint::to_affine(self)
-    }
-
-    #[cfg(feature = "alloc")]
-    #[inline]
-    fn batch_normalize(projective: &[Self], affine: &mut [Self::AffineRepr]) {
-        assert_eq!(projective.len(), affine.len());
-        let mut zs = vec![C::FieldElement::ONE; projective.len()];
-        batch_normalize_generic(projective, zs.as_mut_slice(), affine);
-    }
 }
 
+//
+// Batch trait impls
+//
+
 impl<const N: usize, C> BatchNormalize<[ProjectivePoint<C>; N]> for ProjectivePoint<C>
 where
     C: PrimeCurveParams,
@@ -481,29 +513,6 @@ impl<C: PrimeCurveParams> LookupTable<C> {
     }
 }
 
-impl<C> PrimeGroup for ProjectivePoint<C>
-where
-    Self: Double,
-    C: PrimeCurveParams,
-    CompressedPoint<C>: Copy + Send + Sync,
-    FieldBytes<C>: Copy,
-    FieldBytesSize<C>: ModulusSize,
-    <UncompressedPointSize<C> as ArraySize>::ArrayType<u8>: Copy,
-{
-}
-
-impl<C> PrimeCurve for ProjectivePoint<C>
-where
-    Self: Double,
-    C: PrimeCurveParams,
-    CompressedPoint<C>: Copy + Send + Sync,
-    FieldBytes<C>: Copy,
-    FieldBytesSize<C>: ModulusSize,
-    <UncompressedPointSize<C> as ArraySize>::ArrayType<u8>: Copy,
-{
-    type Affine = AffinePoint<C>;
-}
-
 impl<C> PartialEq for ProjectivePoint<C>
 where
     C: PrimeCurveParams,
@@ -560,7 +569,7 @@ where
 }
 
 //
-// Arithmetic trait impls
+// `core::ops` trait impls
 //
 
 impl<C> Add<ProjectivePoint<C>> for ProjectivePoint<C>