Use impl IntoIterator consistently

.github/workflows/pullrequest.yml

@@ -18,6 +18,9 @@ jobs:
 
     steps:
       - uses: dtolnay/rust-toolchain@1.87.0
+      - name: Enable symlinks on Windows
+        if: runner.os == 'Windows'
+        run: git config --global core.symlinks true
       - uses: actions/checkout@v4
         with:
           submodules: true
@@ -165,6 +168,9 @@ jobs:
 
     steps:
       - uses: dtolnay/rust-toolchain@1.87.0
+      - name: Enable symlinks on Windows
+        if: runner.os == 'Windows'
+        run: git config --global core.symlinks true
       - uses: actions/checkout@v4
         with:
           submodules: true

test/src/sql_counter.rs

@@ -15,7 +15,7 @@ impl DurableObject for SqlCounter {
     fn new(state: State, _env: Env) -> Self {
         let sql = state.storage().sql();
         // Create table if it does not exist.  Note: `exec` is synchronous.
-        sql.exec("CREATE TABLE IF NOT EXISTS counter(value INTEGER);", None)
+        sql.exec("CREATE TABLE IF NOT EXISTS counter(value INTEGER);", [])
             .expect("create table");
         Self { sql }
     }
@@ -43,15 +43,15 @@ impl SqlCounter {
 
         let rows: Vec<Row> = self
             .sql
-            .exec("SELECT value FROM counter LIMIT 1;", None)?
+            .exec("SELECT value FROM counter LIMIT 1;", [])?
             .to_array()?;
         let current = rows.first().map_or(0, |r| r.value);
         let next = current + 1;
 
         // Upsert new value – simplest way: delete and insert again.
-        self.sql.exec("DELETE FROM counter;", None)?;
+        self.sql.exec("DELETE FROM counter;", [])?;
         self.sql
-            .exec("INSERT INTO counter(value) VALUES (?);", vec![next.into()])?;
+            .exec("INSERT INTO counter(value) VALUES (?);", [next.into()])?;
 
         Response::ok(format!("SQL counter is now {next}"))
     }
@@ -77,9 +77,9 @@ impl SqlCounter {
         };
 
         // Store the safe value
-        self.sql.exec("DELETE FROM counter;", None)?;
+        self.sql.exec("DELETE FROM counter;", [])?;
         self.sql
-            .exec("INSERT INTO counter(value) VALUES (?);", vec![safe_value])?;
+            .exec("INSERT INTO counter(value) VALUES (?);", [safe_value])?;
 
         Response::ok(format!("Successfully stored large value: {large_value}"))
     }

test/src/sql_iterator.rs

@@ -68,18 +68,18 @@ impl DurableObject for SqlIterator {
         // Create table and seed with test data
         sql.exec(
             "CREATE TABLE IF NOT EXISTS products(id INTEGER PRIMARY KEY, name TEXT, price REAL, in_stock INTEGER);",
-            None,
+            [],
         ).expect("create table");
 
         sql.exec(
             "CREATE TABLE IF NOT EXISTS blob_data(id INTEGER PRIMARY KEY, name TEXT, data BLOB);",
-            None,
+            [],
         )
         .expect("create blob table");
 
         // Check if we need to seed data
         let count: Vec<serde_json::Value> = sql
-            .exec("SELECT COUNT(*) as count FROM products;", None)
+            .exec("SELECT COUNT(*) as count FROM products;", [])
             .expect("count query")
             .to_array()
             .expect("count result");
@@ -103,14 +103,14 @@ impl DurableObject for SqlIterator {
             for (name, price, in_stock) in products {
                 sql.exec(
                     "INSERT INTO products(name, price, in_stock) VALUES (?, ?, ?);",
-                    vec![name.into(), price.into(), i32::from(in_stock).into()],
+                    [name.into(), price.into(), i32::from(in_stock).into()],
                 )
                 .expect("insert product");
             }
         }
 
         let blob_count: Vec<serde_json::Value> = sql
-            .exec("SELECT COUNT(*) as count FROM blob_data;", None)
+            .exec("SELECT COUNT(*) as count FROM blob_data;", [])
             .expect("blob count query")
             .to_array()
             .expect("blob count result");
@@ -135,7 +135,7 @@ impl DurableObject for SqlIterator {
             for (name, data) in blob_test_data {
                 sql.exec(
                     "INSERT INTO blob_data(name, data) VALUES (?, ?);",
-                    vec![name.into(), SqlStorageValue::Blob(data)],
+                    [name.into(), SqlStorageValue::Blob(data)],
                 )
                 .expect("insert blob data");
             }
@@ -162,7 +162,7 @@ impl DurableObject for SqlIterator {
 
 impl SqlIterator {
     fn handle_next(&self) -> Result<Response> {
-        let cursor = self.sql.exec("SELECT * FROM products ORDER BY id;", None)?;
+        let cursor = self.sql.exec("SELECT * FROM products ORDER BY id;", [])?;
 
         let mut results = Vec::new();
         let iterator = cursor.next::<Product>();
@@ -190,7 +190,7 @@ impl SqlIterator {
     }
 
     fn handle_raw(&self) -> Result<Response> {
-        let cursor = self.sql.exec("SELECT * FROM products ORDER BY id;", None)?;
+        let cursor = self.sql.exec("SELECT * FROM products ORDER BY id;", [])?;
 
         let mut results = Vec::new();
         let column_names = cursor.column_names();
@@ -216,7 +216,7 @@ impl SqlIterator {
     }
 
     fn handle_next_invalid(&self) -> Result<Response> {
-        let cursor = self.sql.exec("SELECT * FROM products ORDER BY id;", None)?;
+        let cursor = self.sql.exec("SELECT * FROM products ORDER BY id;", [])?;
 
         let mut results = Vec::new();
         let iterator = cursor.next::<BadProduct>();
@@ -244,9 +244,7 @@ impl SqlIterator {
     }
 
     fn handle_blob_next(&self) -> Result<Response> {
-        let cursor = self
-            .sql
-            .exec("SELECT * FROM blob_data ORDER BY id;", None)?;
+        let cursor = self.sql.exec("SELECT * FROM blob_data ORDER BY id;", [])?;
 
         let mut results = Vec::new();
         let iterator = cursor.raw();
@@ -285,9 +283,7 @@ impl SqlIterator {
     }
 
     fn handle_blob_raw(&self) -> Result<Response> {
-        let cursor = self
-            .sql
-            .exec("SELECT * FROM blob_data ORDER BY id;", None)?;
+        let cursor = self.sql.exec("SELECT * FROM blob_data ORDER BY id;", [])?;
 
         let mut results = Vec::new();
         let column_names = cursor.column_names();
@@ -341,18 +337,18 @@ impl SqlIterator {
         // Insert test data
         self.sql.exec(
             "INSERT INTO blob_data(name, data) VALUES (?, ?);",
-            vec![test_name.into(), SqlStorageValue::Blob(test_data.clone())],
+            [test_name.into(), SqlStorageValue::Blob(test_data.clone())],
         )?;
 
         // Read it back using both methods (raw iterator approach for both)
         let cursor_next = self.sql.exec(
             "SELECT * FROM blob_data WHERE name = ? ORDER BY id DESC LIMIT 1;",
-            vec![test_name.into()],
+            [test_name.into()],
         )?;
 
         let cursor_raw = self.sql.exec(
             "SELECT * FROM blob_data WHERE name = ? ORDER BY id DESC LIMIT 1;",
-            vec![test_name.into()],
+            [test_name.into()],
         )?;
 
         let mut results = Vec::new();
@@ -400,10 +396,8 @@ impl SqlIterator {
         }
 
         // Clean up test data
-        self.sql.exec(
-            "DELETE FROM blob_data WHERE name = ?;",
-            vec![test_name.into()],
-        )?;
+        self.sql
+            .exec("DELETE FROM blob_data WHERE name = ?;", [test_name.into()])?;
 
         let response_body = format!("blob-roundtrip test results:\n{}", results.join("\n"));
 

worker/src/d1/mod.rs

@@ -49,7 +49,10 @@ impl D1Database {
     /// Batch execute one or more statements against the database.
     ///
     /// Returns the results in the same order as the provided statements.
-    pub async fn batch(&self, statements: Vec<D1PreparedStatement>) -> Result<Vec<D1Result>> {
+    pub async fn batch(
+        &self,
+        statements: impl IntoIterator<Item = D1PreparedStatement>,
+    ) -> Result<Vec<D1Result>> {
         let statements = statements.into_iter().map(|s| s.0).collect::<Array>();
         let results = JsFuture::from(self.0.batch(statements)?).await;
         let results = cast_to_d1_error(results)?;

worker/src/durable.rs

@@ -361,7 +361,10 @@ impl Storage {
     }
 
     /// Retrieves the values associated with each of the provided keys.
-    pub async fn get_multiple(&self, keys: Vec<impl Deref<Target = str>>) -> Result<Map> {
+    pub async fn get_multiple<S: Deref<Target = str>, I: IntoIterator<Item = S>>(
+        &self,
+        keys: I,
+    ) -> Result<Map> {
         let keys = self.inner.get_multiple(
             keys.into_iter()
                 .map(|key| JsValue::from(key.deref()))
@@ -426,7 +429,10 @@ impl Storage {
 
     /// Deletes the provided keys and their associated values. Returns a count of the number of
     /// key-value pairs deleted.
-    pub async fn delete_multiple(&self, keys: Vec<impl Deref<Target = str>>) -> Result<usize> {
+    pub async fn delete_multiple(
+        &self,
+        keys: impl IntoIterator<Item = impl Deref<Target = str>>,
+    ) -> Result<usize> {
         let fut: JsFuture = self
             .inner
             .delete_multiple(
@@ -590,7 +596,10 @@ impl Transaction {
             .map_err(Error::from)
     }
 
-    pub async fn get_multiple(&self, keys: Vec<impl Deref<Target = str>>) -> Result<Map> {
+    pub async fn get_multiple<I: IntoIterator<Item = D>, D: Deref<Target = str>>(
+        &self,
+        keys: I,
+    ) -> Result<Map> {
         let keys = self.inner.get_multiple(
             keys.into_iter()
                 .map(|key| JsValue::from(key.deref()))
@@ -629,7 +638,10 @@ impl Transaction {
             .map_err(Error::from)
     }
 
-    pub async fn delete_multiple(&self, keys: Vec<impl Deref<Target = str>>) -> Result<usize> {
+    pub async fn delete_multiple<I: IntoIterator<Item = D>, D: Deref<Target = str>>(
+        &self,
+        keys: I,
+    ) -> Result<usize> {
         let fut: JsFuture = self
             .inner
             .delete_multiple(

worker/src/r2/builder.rs

@@ -408,8 +408,8 @@ impl ListOptionsBuilder<'_> {
     ///         .await?;
     /// }
     /// ```
-    pub fn include(mut self, include: Vec<Include>) -> Self {
-        self.include = Some(include);
+    pub fn include(mut self, include: impl IntoIterator<Item = Include>) -> Self {
+        self.include = Some(include.into_iter().collect());
         self
     }
 

worker/src/r2/mod.rs

@@ -87,7 +87,10 @@ impl Bucket {
     /// pairs globally.
     ///
     /// Up to 1000 keys may be deleted per call.
-    pub async fn delete_multiple(&self, keys: Vec<impl Deref<Target = str>>) -> Result<()> {
+    pub async fn delete_multiple(
+        &self,
+        keys: impl IntoIterator<Item = impl Deref<Target = str>>,
+    ) -> Result<()> {
         let fut: JsFuture = self
             .inner
             .delete_multiple(keys.into_iter().map(|key| JsValue::from(&*key)).collect())?

worker/src/router.rs

@@ -357,7 +357,12 @@ impl<'a, D: 'a> Router<'a, D> {
         self
     }
 
-    fn add_handler(&mut self, pattern: &str, func: Handler<'a, D>, methods: Vec<Method>) {
+    fn add_handler(
+        &mut self,
+        pattern: &str,
+        func: Handler<'a, D>,
+        methods: impl IntoIterator<Item = Method>,
+    ) {
         for method in methods {
             self.handlers
                 .entry(method.clone())