Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) client-ip=2620:137:e000::1:20;
Date:   Mon, 14 Nov 2022 14:35:01 +0000
From:   Gary Guo <gary@garyguo.net>
To:     Miguel Ojeda <ojeda@kernel.org>
Cc:     Wedson Almeida Filho <wedsonaf@gmail.com>,
        Alex Gaynor <alex.gaynor@gmail.com>,
        Boqun Feng <boqun.feng@gmail.com>,
        =?UTF-8?B?QmrDtnJu?= Roy Baron <bjorn3_gh@protonmail.com>,
        rust-for-linux@vger.kernel.org, linux-kernel@vger.kernel.org,
        patches@lists.linux.dev
Subject: Re: [PATCH v1 13/28] rust: alloc: add
 `Vec::try_with_capacity{,_in}()` constructors
Message-ID: <20221114143501.7c1a6d2a@GaryWorkstation>
In-Reply-To: <20221110164152.26136-14-ojeda@kernel.org>
References: <20221110164152.26136-1-ojeda@kernel.org>
        <20221110164152.26136-14-ojeda@kernel.org>
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: 7bit
MIME-Version: 1.0
X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1
X-MS-Exchange-AntiSpam-MessageData-0: =?us-ascii?Q?DN1fuhe7pVTpnNMCBWGYc25n5wu0ruY+f7ArLMq3uHvF0mfd5GwVhWsrpyOE?=
 =?us-ascii?Q?fWJs+bwq5Mvyxfo0p08e9LwYuSrwjbTM2p8F5hSwZFENPlDR04W0LbycpnrJ?=
 =?us-ascii?Q?U2m5uXYtu22s929JMkk588wiOjieW2Mp7+veyF7ZZ6ezl+PdhxVZC9v2NaoG?=
 =?us-ascii?Q?m5GzhCYkRqFBxjOdffIoU9d3VMjFfjyATPuryTt/M1pnBGaN1E2hqLtwC8lf?=
 =?us-ascii?Q?5ceaWf4bmPFkNUcFhrXPEjC/9my4LkAlxL3CqdxkLn8x1zocg0vyhbkGuL/n?=
 =?us-ascii?Q?AHeg0hXQnYtQkA4fYFMso3/fHZ/D65+mV04SM5M9bbok3vCcXWiBlt0Rq2Qz?=
 =?us-ascii?Q?P/HnrmiXAh1zFgm1aF8O49GHbY2SiS+PFGTglYUFUNz+kN424dsa1Ldj/8+d?=
 =?us-ascii?Q?oBuxvkJwgDM2SF/X9pLo3Y8g1Qab2SUVpxvFJLnHGMU4a9m0Zxm/fpMf8/V5?=
 =?us-ascii?Q?YlYHWnT3jijRpcdg4UcC8hFzuhmNRxGXQfn2EDREK/JXLD02aSC2AIjquHvI?=
 =?us-ascii?Q?ShrPlI+g3GsW3SJuxMk/t4T55d9m+5rojZGHCZ9erzh+J7Vw4ena+r6zqlN+?=
 =?us-ascii?Q?5U2B1+hOQ4W/axigG8wrgOfa60RuRUOjZ/Hs/73nYlH3dKZVFbKtvCqLiioX?=
 =?us-ascii?Q?KTqjy5N1SUgTmMdf+FcfzKEkIWplAiOVdeX0T2DE8L44BNbFXQMc0GD99Uey?=
 =?us-ascii?Q?XYQdCzV89kGGv1NmtIGfNisPgLvEUfFdMDthDy1yIVgjefwwPAoIV4HLnP4s?=
 =?us-ascii?Q?Lt6rRZh+YtkTHBUYV1lvIe/Z8IakG00URFeiFPX6iOdfVKzWUz+rQgzhkHXe?=
 =?us-ascii?Q?JPjAd92z/0pU0/YJUruy685TfgePqSqcH+Xt4NsbRBEgBXTD//6/kHTvHYOw?=
 =?us-ascii?Q?XIBZcQDHWtm1EZBY7B0C0plS+ddMbGDvzbsrU9Tc3iSle89p6FIjLDWmYXQP?=
 =?us-ascii?Q?LBrXY51XN71T+dm54A/8EJ3bl658UTObvFf3NyA4fY5MLqKLCNhPWAnFVfd3?=
 =?us-ascii?Q?izyF+QLpXDmCvZJubJ3jro6nByxtYzYG130fJ18pGkrZbBsu/sNuYdDhEC5g?=
 =?us-ascii?Q?gX9sjYUda2R/dDfKXqSWp+7mPrK1Zhd3NCg+f1tLMiVpaOl244w8e+zx3XTy?=
 =?us-ascii?Q?b5YoBsqi/MUmNjhyNjuxGeBQ59N+0go6XRhhAywWRdUcObASkbfNKwFQgHi8?=
 =?us-ascii?Q?jqySVBeU1BUPlh7Su4QYp9ZRJh2LB7Npmoozzi4+Mtltjpk9bnNq+0JHnGow?=
 =?us-ascii?Q?r0PLs0YywF2kRuQisAIm0Vf9LI84dHz7cN5u8dB3/yEgVfMFa/Z5lCau9wYQ?=
 =?us-ascii?Q?T/94A1e1HYvryFGTlj3cJU0MsApqcfZ3ZktYAdHztqXd6MJ2bPKLjaPvHAow?=
 =?us-ascii?Q?auwB0gPPySi/V5Mb+VVnOvOoPmyddHP4GK2V4fuyhFyYjnDgLmRfzHlM105Z?=
 =?us-ascii?Q?WV/acDn2IxpxZe1zeou1UH4xHYnIgeQAa4ZhM64Xs9TcEH0fj+oq+V1jne2Z?=
 =?us-ascii?Q?r6JYlJfx1vNMjvubNTq0FIpH/mVquV0RwprNO174LdKfZMENid/N+Hi8FLXi?=
 =?us-ascii?Q?XZJmQlzlXVb/IQxbPzKUbQqGaI70DfLcoOj4/FXdzJq9C4KQK29hBiLOnUPr?=
 =?us-ascii?Q?vlle9mebWQ1P7CpeyEdxjpt8CNuu7pZ9FGloUbyCVdF/?=
X-OriginatorOrg: garyguo.net
X-MS-Exchange-CrossTenant-Network-Message-Id: 58ab8abc-cc4f-4c8a-87dc-08dac64d6a61
X-MS-Exchange-CrossTenant-AuthSource: LO2P265MB5183.GBRP265.PROD.OUTLOOK.COM
X-MS-Exchange-CrossTenant-AuthAs: Internal
X-MS-Exchange-CrossTenant-OriginalArrivalTime: 14 Nov 2022 14:35:02.6841
 (UTC)
X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted
X-MS-Exchange-CrossTenant-Id: bbc898ad-b10f-4e10-8552-d9377b823d45
X-MS-Exchange-CrossTenant-MailboxType: HOSTED
X-MS-Exchange-CrossTenant-UserPrincipalName: G0p0xK2c5CDczMMTLw8ABdBJxHQOdUMzrBJu2T0vsbLT3IiVvka7pK5qFWEsWIhAC4C11JLY+RU5M4GEPVundg==
X-MS-Exchange-Transport-CrossTenantHeadersStamped: LO0P265MB5572
X-Spam-Status: No, score=-2.1 required=5.0 tests=BAYES_00,DKIM_SIGNED,
        DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RCVD_IN_DNSWL_NONE,
        RCVD_IN_MSPIKE_H2,SPF_HELO_PASS,SPF_PASS autolearn=ham
        autolearn_force=no version=3.4.6
X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on
        lindbergh.monkeyblade.net
Precedence: bulk
List-ID: <linux-kernel.vger.kernel.org>
X-Mailing-List: linux-kernel@vger.kernel.org

On Thu, 10 Nov 2022 17:41:25 +0100
Miguel Ojeda <ojeda@kernel.org> wrote:

> Add `Vec::try_with_capacity()` and `Vec::try_with_capacity_in()` as
> the fallible versions of `Vec::with_capacity()` and
> `Vec::with_capacity_in()`, respectively.
> 
> The implementations follow the originals and use the previously
> added `RawVec::try_with_capacity_in()`.
> 
> In turn, `Vec::try_with_capacity()` will be used to implement
> the `CString` type (which wraps a `Vec<u8>`) in a later patch.
> 
> Signed-off-by: Miguel Ojeda <ojeda@kernel.org>

Reviewed-by: Gary Guo <gary@garyguo.net>

> ---
>  rust/alloc/raw_vec.rs |  1 -
>  rust/alloc/vec/mod.rs | 89 +++++++++++++++++++++++++++++++++++++++++++
>  2 files changed, 89 insertions(+), 1 deletion(-)
> 
> diff --git a/rust/alloc/raw_vec.rs b/rust/alloc/raw_vec.rs
> index c342f3843972..eb77db5def55 100644
> --- a/rust/alloc/raw_vec.rs
> +++ b/rust/alloc/raw_vec.rs
> @@ -135,7 +135,6 @@ impl<T, A: Allocator> RawVec<T, A> {
>  
>      /// Like `try_with_capacity`, but parameterized over the choice of
>      /// allocator for the returned `RawVec`.
> -    #[allow(dead_code)]
>      #[inline]
>      pub fn try_with_capacity_in(capacity: usize, alloc: A) -> Result<Self, TryReserveError> {
>          Self::try_allocate_in(capacity, AllocInit::Uninitialized, alloc)
> diff --git a/rust/alloc/vec/mod.rs b/rust/alloc/vec/mod.rs
> index 540787804cc2..8ac6c1e3b2a8 100644
> --- a/rust/alloc/vec/mod.rs
> +++ b/rust/alloc/vec/mod.rs
> @@ -472,6 +472,48 @@ impl<T> Vec<T> {
>          Self::with_capacity_in(capacity, Global)
>      }
>  
> +    /// Tries to construct a new, empty `Vec<T>` with the specified capacity.
> +    ///
> +    /// The vector will be able to hold exactly `capacity` elements without
> +    /// reallocating. If `capacity` is 0, the vector will not allocate.
> +    ///
> +    /// It is important to note that although the returned vector has the
> +    /// *capacity* specified, the vector will have a zero *length*. For an
> +    /// explanation of the difference between length and capacity, see
> +    /// *[Capacity and reallocation]*.
> +    ///
> +    /// [Capacity and reallocation]: #capacity-and-reallocation
> +    ///
> +    /// # Examples
> +    ///
> +    /// ```
> +    /// let mut vec = Vec::try_with_capacity(10).unwrap();
> +    ///
> +    /// // The vector contains no items, even though it has capacity for more
> +    /// assert_eq!(vec.len(), 0);
> +    /// assert_eq!(vec.capacity(), 10);
> +    ///
> +    /// // These are all done without reallocating...
> +    /// for i in 0..10 {
> +    ///     vec.push(i);
> +    /// }
> +    /// assert_eq!(vec.len(), 10);
> +    /// assert_eq!(vec.capacity(), 10);
> +    ///
> +    /// // ...but this may make the vector reallocate
> +    /// vec.push(11);
> +    /// assert_eq!(vec.len(), 11);
> +    /// assert!(vec.capacity() >= 11);
> +    ///
> +    /// let mut result = Vec::try_with_capacity(usize::MAX);
> +    /// assert!(result.is_err());
> +    /// ```
> +    #[inline]
> +    #[stable(feature = "kernel", since = "1.0.0")]
> +    pub fn try_with_capacity(capacity: usize) -> Result<Self, TryReserveError> {
> +        Self::try_with_capacity_in(capacity, Global)
> +    }
> +
>      /// Creates a `Vec<T>` directly from the raw components of another vector.
>      ///
>      /// # Safety
> @@ -617,6 +659,53 @@ impl<T, A: Allocator> Vec<T, A> {
>          Vec { buf: RawVec::with_capacity_in(capacity, alloc), len: 0 }
>      }
>  
> +    /// Tries to construct a new, empty `Vec<T, A>` with the specified capacity
> +    /// with the provided allocator.
> +    ///
> +    /// The vector will be able to hold exactly `capacity` elements without
> +    /// reallocating. If `capacity` is 0, the vector will not allocate.
> +    ///
> +    /// It is important to note that although the returned vector has the
> +    /// *capacity* specified, the vector will have a zero *length*. For an
> +    /// explanation of the difference between length and capacity, see
> +    /// *[Capacity and reallocation]*.
> +    ///
> +    /// [Capacity and reallocation]: #capacity-and-reallocation
> +    ///
> +    /// # Examples
> +    ///
> +    /// ```
> +    /// #![feature(allocator_api)]
> +    ///
> +    /// use std::alloc::System;
> +    ///
> +    /// let mut vec = Vec::try_with_capacity_in(10, System).unwrap();
> +    ///
> +    /// // The vector contains no items, even though it has capacity for more
> +    /// assert_eq!(vec.len(), 0);
> +    /// assert_eq!(vec.capacity(), 10);
> +    ///
> +    /// // These are all done without reallocating...
> +    /// for i in 0..10 {
> +    ///     vec.push(i);
> +    /// }
> +    /// assert_eq!(vec.len(), 10);
> +    /// assert_eq!(vec.capacity(), 10);
> +    ///
> +    /// // ...but this may make the vector reallocate
> +    /// vec.push(11);
> +    /// assert_eq!(vec.len(), 11);
> +    /// assert!(vec.capacity() >= 11);
> +    ///
> +    /// let mut result = Vec::try_with_capacity_in(usize::MAX, System);
> +    /// assert!(result.is_err());
> +    /// ```
> +    #[inline]
> +    #[stable(feature = "kernel", since = "1.0.0")]
> +    pub fn try_with_capacity_in(capacity: usize, alloc: A) -> Result<Self, TryReserveError> {
> +        Ok(Vec { buf: RawVec::try_with_capacity_in(capacity, alloc)?, len: 0 })
> +    }
> +
>      /// Creates a `Vec<T, A>` directly from the raw components of another vector.
>      ///
>      /// # Safety