Move generic DivRem <T,U> to num/traits/ops and expose legacy bridge

* New file `corelib/src/num/traits/ops/divrem.cairo`
  – defines the generic `DivRem<T,U>` trait (was in core traits.cairo).
  – adds the `by_divrem_legacy::Bridge` adapter that maps every existing
    symmetric `crate::traits::DivRem<T>` implementation to
    `DivRem<T,T>` so old code keeps compiling.
  – publishes concrete aliases (`DivRemU8 … DivRemU256`) outside the
    module, per review guidelines.

* `corelib/src/num/traits/ops.cairo`
  – re-exports `DivRem`, making it part of the public numeric-ops API.

* `corelib/src/num/traits.cairo`
  – bubbles the new trait up alongside the other `num::traits` re-exports.

* `corelib/src/traits.cairo`
  – removes the now-redundant generic-DivRem definition and restores the
    legacy `DivRem<T>` docs (no longer marked deprecated).

These edits address reviewer feedback on PR starkware-libs#7722:
  • trait must live under `num/traits/ops`
  • drop the “Generic” suffix
  • inner adapter module should stay private; concrete `pub impl`s live
    at top level.

All existing tests pass, and the new `divrem` tests in `num_test.cairo`
verify both generic and legacy paths.

Author: 0xpantera

corelib/src/fixed_size_array.cairo

@@ -1,5 +1,5 @@
 use crate::metaprogramming::{SnapRemove, TupleExtendFront, TupleSnapForward, TupleSplit};
-use crate::tuple::{SerdeTuple, TuplePartialEq, TuplePartialEqHelper};
+use crate::tuple::{DefaultNext, SerdeTuple, TuplePartialEq, TuplePartialEqHelper};
 
 impl TupleSplitFixedSizedArraySized1<T> of TupleSplit<[T; 1]> {
     type Head = T;

corelib/src/lib.cairo

@@ -4,7 +4,6 @@ pub mod traits;
 use serde::Serde;
 #[feature("deprecated-index-traits")]
 #[feature("deprecated-op-assign-traits")]
-#[feature("generic-divrem")]
 #[allow(unused_imports)]
 use traits::{
     Add, AddEq, BitAnd, BitNot, BitOr, BitXor, Copy, Default, Destruct, Div, DivEq, DivRem, Drop,

corelib/src/num/traits/ops/divrem.cairo

@@ -46,29 +46,24 @@ pub trait DivRem<T, U> {
 }
 
 //  Compatibility bridge:  DivRem<T>  →  DivRemGeneric<T,T>
-mod _divrem_bridge {
-    #[feature("generic-divrem")]
-    use crate::traits::DivRem;
-    use super::DivRem as DivRemGeneric;
-
+mod by_divrem_legacy {
     /// Generic adapter: if the old symmetric `DivRem<T>` exists,
     /// provide the corresponding `DivRemGeneric<T,T>` implementation.
-    impl Bridge<T, +DivRem<T>> of DivRemGeneric<T, T> {
+    pub impl Bridge<T, +crate::traits::DivRem<T>> of super::DivRem<T, T> {
         type Quotient = T;
         type Remainder = T;
 
         fn div_rem(lhs: T, rhs: NonZero<T>) -> (T, T) {
-            DivRem::<T>::div_rem(lhs, rhs)
+            core::traits::DivRem::<T>::div_rem(lhs, rhs)
         }
     }
-
-    // Instantiate the generic adapter for every concrete integer type
-    // that already has a symmetric `DivRem` implementation.
-    pub impl BridgeU8 = Bridge<u8>;
-    pub impl BridgeU16 = Bridge<u16>;
-    pub impl BridgeU32 = Bridge<u32>;
-    pub impl BridgeU64 = Bridge<u64>;
-    pub impl BridgeU128 = Bridge<u128>;
-    pub impl BridgeU256 = Bridge<u256>;
 }
-use _divrem_bridge::*;
+
+// Instantiate the generic adapter for every concrete integer type
+// that already has a symmetric `DivRem` implementation.
+pub impl BridgeU8 = by_divrem_legacy::Bridge<u8>;
+pub impl BridgeU16 = by_divrem_legacy::Bridge<u16>;
+pub impl BridgeU32 = by_divrem_legacy::Bridge<u32>;
+pub impl BridgeU64 = by_divrem_legacy::Bridge<u64>;
+pub impl BridgeU128 = by_divrem_legacy::Bridge<u128>;
+pub impl BridgeU256 = by_divrem_legacy::Bridge<u256>;

corelib/src/prelude/v2023_01.cairo

@@ -2,45 +2,45 @@ pub use starknet::storage::{
     StorageMapReadAccess, StorageMapWriteAccess, StoragePointerReadAccess,
     StoragePointerWriteAccess,
 };
-use crate::array::{self, Array, ArrayTrait, Span, SpanTrait, ToSpanTrait};
-use crate::box::{self, Box, BoxTrait};
+use crate::array::{Array, ArrayTrait, Span, SpanTrait, ToSpanTrait, self};
+use crate::box::{Box, BoxTrait, self};
 use crate::byte_array::{
-    self, ByteArray, ByteArrayIndexView, ByteArrayStringLiteral, ByteArrayTrait,
+    ByteArray, ByteArrayIndexView, ByteArrayStringLiteral, ByteArrayTrait, self,
 };
 use crate::bytes_31::{
-    self, Bytes31IndexView, Bytes31IntoFelt252, Bytes31Trait, Felt252TryIntoBytes31, bytes31,
-    bytes31_const,
+    Bytes31IndexView, Bytes31IntoFelt252, Bytes31Trait, Felt252TryIntoBytes31, bytes31,
+    bytes31_const, self,
 };
-use crate::clone::{self, Clone};
+use crate::clone::{Clone, self};
 use crate::dict::{
-    self, Felt252Dict, Felt252DictTrait, SquashedFelt252Dict, felt252_dict_new, felt252_dict_squash,
+    Felt252Dict, Felt252DictTrait, SquashedFelt252Dict, felt252_dict_new, felt252_dict_squash, self,
 };
-use crate::ec::{self, EcOp, EcPoint, EcState};
-use crate::gas::{self, BuiltinCosts, GasBuiltin, get_builtin_costs};
+use crate::ec::{EcOp, EcPoint, EcState, self};
+use crate::gas::{BuiltinCosts, GasBuiltin, get_builtin_costs, self};
 use crate::integer::{
-    self, Bitwise, Felt252IntoU256, Felt252TryIntoU128, Felt252TryIntoU16, Felt252TryIntoU32,
+    Bitwise, Felt252IntoU256, Felt252TryIntoU128, Felt252TryIntoU16, Felt252TryIntoU32,
     Felt252TryIntoU64, Felt252TryIntoU8, I128IntoFelt252, I16IntoFelt252, I32IntoFelt252,
     I64IntoFelt252, I8IntoFelt252, NumericLiteral, U128IntoFelt252, U16IntoFelt252, U32IntoFelt252,
-    U64IntoFelt252, U8IntoFelt252, i128, i16, i32, i64, i8, u128, u128_is_zero, u16, u256, u32, u64,
-    u8,
+    U64IntoFelt252, U8IntoFelt252, i128, i16, i32, i64, i8, self, u128, u128_is_zero, u16, u256,
+    u32, u64, u8,
 };
 #[feature("corelib-internal-use")]
 #[deprecated(feature: "corelib-internal-use", note: "Use `core::num::traits::Sqrt` instead")]
 use crate::integer::{u128_sqrt, u256_sqrt};
 use crate::iter::{FromIterator, IntoIterator, Iterator};
-use crate::nullable::{self, Nullable, NullableTrait, match_nullable, null, nullable_from_box};
+use crate::nullable::{Nullable, NullableTrait, match_nullable, null, nullable_from_box, self};
 pub use crate::ops::Deref;
-use crate::option::Option::{self, None, Some};
-use crate::option::{self, OptionTrait};
-use crate::panics::{self, Panic, PanicResult, panic};
-use crate::pedersen::{self, Pedersen};
-use crate::poseidon::{self, Poseidon};
-use crate::result::Result::{self, Err, Ok};
-use crate::result::{self, ResultTrait};
-use crate::serde::{self, Serde};
+use crate::option::Option::{None, Some, self};
+use crate::option::{OptionTrait, self};
+use crate::panics::{Panic, PanicResult, panic, self};
+use crate::pedersen::{Pedersen, self};
+use crate::poseidon::{Poseidon, self};
+use crate::result::Result::{Err, Ok, self};
+use crate::result::{ResultTrait, self};
+use crate::serde::{Serde, self};
 #[feature("corelib-internal-use")]
-use crate::starknet::{self, System};
-use crate::string::{self, StringLiteral};
+use crate::starknet::{System, self};
+use crate::string::{StringLiteral, self};
 #[cfg(test)]
 use crate::test;
 #[deprecated(
@@ -68,14 +68,14 @@ pub use crate::traits::RemEq;
 )]
 #[feature("deprecated-op-assign-traits")]
 pub use crate::traits::SubEq;
-#[feature("generic-divrem")]
 use crate::traits::{
-    self, Add, BitAnd, BitNot, BitOr, BitXor, Copy, Default, Destruct, Div, DivRem, Drop,
+    Add, BitAnd, BitNot, BitOr, BitXor, Copy, Default, Destruct, Div, DivRem, Drop,
     Felt252DictValue, Into, Mul, Neg, Not, PanicDestruct, PartialEq, PartialOrd, Rem, Sub, TryInto,
+    self,
 };
 #[feature("deprecated-index-traits")]
 use crate::traits::{Index, IndexView};
-use crate::zeroable::{self, NonZero, Zeroable};
+use crate::zeroable::{NonZero, Zeroable, self};
 use crate::{
     BoolBitAnd, BoolBitOr, BoolBitXor, BoolFelt252DictValue, BoolIntoFelt252, BoolNot,
     BoolPartialEq, BoolSerde, Felt252Add, Felt252AddEq, Felt252Default, Felt252Felt252DictValue,

corelib/src/prelude/v2023_10.cairo

@@ -13,16 +13,16 @@ pub use crate::integer::{Bitwise, i128, i16, i32, i64, i8, u128, u16, u256, u32,
 pub use crate::iter::{FromIterator, IntoIterator, Iterator};
 pub use crate::nullable::{Nullable, NullableTrait};
 pub use crate::ops::Deref;
-pub use crate::option::Option::{self, None, Some};
+pub use crate::option::Option::{None, Some, self};
 pub use crate::option::OptionTrait;
 pub use crate::panics::{Panic, PanicResult, panic};
 pub use crate::pedersen::Pedersen;
 pub use crate::poseidon::Poseidon;
-pub use crate::result::Result::{self, Err, Ok};
+pub use crate::result::Result::{Err, Ok, self};
 pub use crate::result::ResultTrait;
 pub use crate::serde::Serde;
 #[feature("corelib-internal-use")]
-pub use crate::starknet::{self, System};
+pub use crate::starknet::{System, self};
 #[deprecated(
     feature: "deprecated-op-assign-traits", note: "Use `core::ops::AddAssign`.", since: "2.7.0",
 )]
@@ -58,7 +58,6 @@ pub use crate::traits::RemEq;
 )]
 #[feature("deprecated-op-assign-traits")]
 pub use crate::traits::SubEq;
-#[feature("generic-divrem")]
 pub use crate::traits::{
     Add, BitAnd, BitNot, BitOr, BitXor, Copy, Default, Destruct, Div, DivRem, Drop,
     Felt252DictValue, Into, Mul, Neg, Not, PanicDestruct, PartialEq, PartialOrd, Rem, Sub, TryInto,

corelib/src/prelude/v2024_07.cairo

@@ -8,15 +8,14 @@ pub use crate::integer::{i128, i16, i32, i64, i8, u128, u16, u256, u32, u64, u8}
 pub use crate::iter::{FromIterator, IntoIterator, Iterator};
 pub use crate::nullable::{Nullable, NullableTrait};
 pub use crate::ops::Deref;
-pub use crate::option::Option::{self, None, Some};
+pub use crate::option::Option::{None, Some, self};
 pub use crate::option::OptionTrait;
 pub use crate::panics::{Panic, PanicResult, panic};
-pub use crate::result::Result::{self, Err, Ok};
+pub use crate::result::Result::{Err, Ok, self};
 pub use crate::result::ResultTrait;
 pub use crate::serde::Serde;
 #[feature("corelib-internal-use")]
-pub use crate::starknet::{self, System};
-#[feature("generic-divrem")]
+pub use crate::starknet::{System, self};
 pub use crate::traits::{
     Add, Copy, Default, Destruct, Div, DivRem, Drop, Felt252DictValue, Into, Mul, Neg, Not,
     PanicDestruct, PartialEq, PartialOrd, Rem, Sub, TryInto,

corelib/src/test/num_test.cairo

@@ -3,7 +3,6 @@ use crate::num::traits::{
     OverflowingSub, Pow, SaturatingAdd, SaturatingMul, SaturatingSub, WrappingAdd, WrappingMul,
     WrappingSub,
 };
-#[feature("generic-divrem")]
 use crate::traits::DivRem as DivRemLegacy;
 use crate::zeroable::NonZero;
 

corelib/src/traits.cairo

@@ -364,11 +364,17 @@ pub trait RemEq<T> {
     fn rem_eq(ref self: T, other: T);
 }
 
-/// Legacy trait for division with remainder.
+/// Performs truncated division and remainder.
 ///
-/// This is kept for backward compatibility.
-/// New code should use `crate::num::traits::ops::divrem::DivRem<T, U>` instead.
-#[deprecated(feature: "generic-divrem", note: "Use `num::traits::ops::divrem::DivRem`.")]
+/// This trait provides a way to efficiently compute both the quotient and remainder in a single
+/// operation. The division truncates towards zero, matching the behavior of the `/` and `%`
+/// operators.
+///
+/// # Examples
+///
+/// ```
+/// assert!(DivRem::div_rem(7_u32, 3) == (2, 1));
+/// ```
 pub trait DivRem<T> {
     fn div_rem(lhs: T, rhs: NonZero<T>) -> (T, T);
 }

corelib/src/tuple.cairo

@@ -747,7 +747,7 @@ impl DefaultTupleBase of Default<()> {
 }
 
 
-impl DefaultNext<
+pub(crate) impl DefaultNext<
     T,
     impl TS: crate::metaprogramming::TupleSplit<T>,
     +Default<TS::Head>,