Remove setters macro (#2882)

Since we decided on plain old rust objects long ago, we shouldn't have
any setters. Any appropriate

Author: heaths

sdk/core/azure_core/CHANGELOG.md

@@ -7,6 +7,7 @@
 ### Breaking Changes
 
 - Removed the `fs` module including the `FileStream` and `FileStreamBuilder` types. Moved to `examples/` for `typespec_client_core` to copy if needed.
+- Removed the `setters` macro.
 
 ### Bugs Fixed
 

sdk/typespec/typespec_client_core/CHANGELOG.md

@@ -7,6 +7,7 @@
 ### Breaking Changes
 
 - Removed the `fs` module including the `FileStream` and `FileStreamBuilder` types. Moved to `examples/` to copy if needed.
+- Removed the `setters` macro.
 
 ### Bugs Fixed
 

sdk/typespec/typespec_client_core/examples/common/fs.rs

@@ -1,6 +1,8 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
+#![allow(dead_code)]
+
 use futures::{task::Poll, Future};
 use std::{cmp::min, io::SeekFrom, pin::Pin, sync::Arc, task::Context};
 use tokio::{
@@ -11,11 +13,10 @@ use tokio::{
 use tracing::debug;
 use typespec_client_core::{
     error::Result,
-    http::{Body, RequestContent},
-    setters,
     stream::{SeekableStream, DEFAULT_BUFFER_SIZE},
 };
 
+/// Builds a [`FileStream`].
 #[derive(Debug)]
 pub struct FileStreamBuilder {
     handle: File,
@@ -37,15 +38,31 @@ impl FileStreamBuilder {
         }
     }
 
-    setters! {
-        // #[doc = "Offset into the file to start reading from"]
-        offset: u64 => Some(offset),
-        // #[doc = "Amount of data to read from the file"]
-        block_size: u64 => Some(block_size),
-        // #[doc = "Amount of data to buffer in memory during streaming reads"]
-        buffer_size: usize => Some(buffer_size),
+    /// Offset into the file to start reading from
+    pub fn offset(self, offset: u64) -> Self {
+        Self {
+            offset: Some(offset),
+            ..self
+        }
+    }
+
+    /// Amount of data to read from the file
+    pub fn block_size(self, block_size: u64) -> Self {
+        Self {
+            block_size: Some(block_size),
+            ..self
+        }
+    }
+
+    /// Amount of data to buffer in memory during streaming reads
+    pub fn buffer_size(self, buffer_size: usize) -> Self {
+        Self {
+            buffer_size: Some(buffer_size),
+            ..self
+        }
     }
 
+    /// Build a [`FileStream`] from this `FileStreamBuilder`.
     pub async fn build(mut self) -> Result<FileStream> {
         let stream_size = self.handle.metadata().await?.len();
 
@@ -159,29 +176,31 @@ impl futures::io::AsyncRead for FileStream {
 }
 
 #[cfg(not(target_arch = "wasm32"))]
-impl From<&FileStream> for Body {
-    fn from(stream: &FileStream) -> Self {
-        Body::SeekableStream(Box::new(stream.clone()))
+mod convert {
+    use super::FileStream;
+    use typespec_client_core::http::{Body, RequestContent};
+
+    impl From<&FileStream> for Body {
+        fn from(stream: &FileStream) -> Self {
+            Body::SeekableStream(Box::new(stream.clone()))
+        }
     }
-}
 
-#[cfg(not(target_arch = "wasm32"))]
-impl From<FileStream> for Body {
-    fn from(stream: FileStream) -> Self {
-        Body::SeekableStream(Box::new(stream))
+    impl From<FileStream> for Body {
+        fn from(stream: FileStream) -> Self {
+            Body::SeekableStream(Box::new(stream))
+        }
     }
-}
 
-#[cfg(not(target_arch = "wasm32"))]
-impl<T, F> From<&FileStream> for RequestContent<T, F> {
-    fn from(stream: &FileStream) -> Self {
-        Body::from(stream).into()
+    impl<T, F> From<&FileStream> for RequestContent<T, F> {
+        fn from(stream: &FileStream) -> Self {
+            Body::from(stream).into()
+        }
     }
-}
 
-#[cfg(not(target_arch = "wasm32"))]
-impl<T, F> From<FileStream> for RequestContent<T, F> {
-    fn from(stream: FileStream) -> Self {
-        Body::from(stream).into()
+    impl<T, F> From<FileStream> for RequestContent<T, F> {
+        fn from(stream: FileStream) -> Self {
+            Body::from(stream).into()
+        }
     }
 }

sdk/typespec/typespec_client_core/src/http/options/retry.rs

@@ -115,9 +115,11 @@ impl RetryOptions {
 /// # use typespec_client_core::time::Duration;
 /// # use typespec_client_core::http::{ExponentialRetryOptions, RetryOptions};
 /// RetryOptions::exponential(
-///    ExponentialRetryOptions::default()
-///        .max_retries(10u32)
-///        .initial_delay(Duration::seconds(1)),
+///     ExponentialRetryOptions {
+///         max_retries: 10u32,
+///         initial_delay: Duration::seconds(1),
+///         ..Default::default()
+///     }
 /// );
 /// ```
 #[derive(Clone, Debug)]
@@ -143,15 +145,6 @@ pub struct ExponentialRetryOptions {
     pub max_delay: Duration,
 }
 
-impl ExponentialRetryOptions {
-    setters! {
-        initial_delay: Duration => initial_delay,
-        max_retries: u32 => max_retries,
-        max_total_elapsed: Duration => max_total_elapsed,
-        max_delay: Duration => max_delay,
-    }
-}
-
 impl Default for ExponentialRetryOptions {
     fn default() -> Self {
         Self {
@@ -171,8 +164,10 @@ impl Default for ExponentialRetryOptions {
 /// ```
 /// # use typespec_client_core::http::{FixedRetryOptions, RetryOptions};
 /// RetryOptions::fixed(
-///    FixedRetryOptions::default()
-///        .max_retries(10u32)
+///     FixedRetryOptions {
+///         max_retries: 10u32,
+///         ..Default::default()
+///     }
 /// );
 /// ```
 #[derive(Clone, Debug)]
@@ -193,17 +188,6 @@ pub struct FixedRetryOptions {
     pub max_total_elapsed: Duration,
 }
 
-impl FixedRetryOptions {
-    setters! {
-        #[doc = "Set the delay between retry attempts."]
-        delay: Duration => delay,
-        #[doc = "Set the maximum number of retry attempts before giving up."]
-        max_retries: u32 => max_retries,
-        #[doc = "Set the maximum permissible elapsed time since starting to retry."]
-        max_total_elapsed: Duration => max_total_elapsed,
-    }
-}
-
 impl Default for FixedRetryOptions {
     fn default() -> Self {
         Self {

sdk/typespec/typespec_client_core/src/http/policies/retry/mod.rs

@@ -306,11 +306,11 @@ mod test {
     #[tokio::test]
     async fn test_retry_statuses() {
         let retries = 2u32;
-        let retry_policy = RetryOptions::fixed(
-            FixedRetryOptions::default()
-                .delay(Duration::nanoseconds(1))
-                .max_retries(retries),
-        )
+        let retry_policy = RetryOptions::fixed(FixedRetryOptions {
+            delay: Duration::nanoseconds(1),
+            max_retries: retries,
+            ..Default::default()
+        })
         .to_policy();
         let ctx = Context::new();
         let url = Url::parse("http://localhost").unwrap();

sdk/typespec/typespec_client_core/src/macros.rs

@@ -190,63 +190,6 @@ macro_rules! create_extensible_enum {
     );
 }
 
-/// Creates setter methods
-///
-/// The methods created are of the form `$name` that takes an argument of type `$typ`
-/// and sets the field `$name` to result of calling `$transform` with the value of the argument.
-///
-/// In other words. The following macro call:
-/// ```
-/// # #[macro_use] extern crate typespec_client_core;
-/// struct MyStruct<'a> { foo: Option<&'a str> };
-/// impl <'a> MyStruct<'a> {
-///     setters! { foo: &'a str => Some(foo), }
-/// }
-/// ```
-/// Roughly expands to:
-/// ```
-/// struct MyStruct<'a> { foo: Option<&'a str> };
-/// impl <'a> MyStruct<'a> {
-///     fn foo(self, foo: &'a str) -> Self {
-///         Self {
-///             foo: Some(foo),
-///             ..self
-///         }
-///     }
-/// }
-/// ```
-#[macro_export]
-macro_rules! setters {
-    (@single $(#[$meta:meta])* $name:ident : $typ:ty => $transform:expr) => {
-        #[allow(clippy::redundant_field_names)]
-        #[allow(clippy::needless_update)]
-        #[allow(missing_docs)]
-        #[must_use]
-        $(#[$meta])*
-        pub fn $name<P: ::std::convert::Into<$typ>>(self, $name: P) -> Self {
-            let $name: $typ = $name.into();
-            Self  {
-                $name: $transform,
-                ..self
-            }
-        }
-    };
-    // Terminal condition
-    (@recurse) => {};
-    // Recurse without transform
-    (@recurse $(#[$meta:meta])* $name:ident : $typ:ty, $($tokens:tt)*) => {
-        $crate::setters! { @recurse $(#[$meta])* $name: $typ => $name, $($tokens)* }
-    };
-    // Recurse with transform
-    (@recurse $(#[$meta:meta])* $name:ident : $typ:ty => $transform:expr, $($tokens:tt)*) => {
-        $crate::setters! { @single $(#[$meta])* $name : $typ => $transform }
-        $crate::setters! { @recurse $($tokens)* }
-    };
-    ($($tokens:tt)*) => {
-        $crate::setters! { @recurse $($tokens)* }
-    }
-}
-
 #[cfg(test)]
 mod test {
     use serde::{Deserialize, Serialize};
@@ -277,14 +220,6 @@ mod test {
         b: u32,
     }
 
-    #[allow(dead_code)]
-    impl Options {
-        setters! {
-            a: String => Some(a),
-            b: u32 => b,
-        }
-    }
-
     impl Default for Options {
         fn default() -> Self {
             Options { a: None, b: 1 }
@@ -310,7 +245,10 @@ mod test {
 
     #[test]
     fn setters() {
-        let options = Options::default().a("test".to_owned());
+        let options = Options {
+            a: Some("test".to_string()),
+            ..Default::default()
+        };
 
         assert_eq!(Some("test".to_owned()), options.a);
         assert_eq!(1, options.b);