Adjusting test comments

Author: rkreutz

SwiftRustIntegrationTestRunner/SwiftRustIntegrationTestRunnerTests/VecTests.swift

@@ -93,23 +93,8 @@ class VecTests: XCTestCase {
         XCTAssertEqual(reflected.pop()!, TransparentEnumInsideVecT.VariantB)
     }
 
-    /// Verify that a Vec<T> of transparent struct can be used as an argument and return
-    /// type for extern "Rust" functions.
-    func testReflectVecOfTransparentStruct() throws {
-        let vec: RustVec<TransparentStructInsideVecT> = RustVec()
-        vec.push(value: TransparentStructInsideVecT(string: "string".intoRustString(), integer: 10))
-        
-        let reflected = rust_reflect_vec_transparent_struct(vec)
-        XCTAssertEqual(reflected.len(), 1)
-        XCTAssertEqual(reflected.get(index: 0)!.string.toString(), "string")
-        XCTAssertEqual(reflected.get(index: 0)!.integer, 10)
-        let popped = try XCTUnwrap(reflected.pop())
-        XCTAssertEqual(popped.string.toString(), "string")
-        XCTAssertEqual(popped.integer, 10)
-    }
-
-    /// Verify that a Vec<T> of transparent struct can be used as an argument and return
-    /// type for extern "Rust" functions.
+    /// Verify that a Vec<T> of transparent struct with derive(Copy, Clone) can be used
+    /// as an argument and return type for extern "Rust" functions.
     func testReflectVecOfTransparentStructFromCopy() throws {
         let vec: RustVec<TransparentStructInsideVecTWithCopy> = RustVec()
         vec.push(value: TransparentStructInsideVecTWithCopy(integer: 10))
@@ -121,8 +106,8 @@ class VecTests: XCTestCase {
         XCTAssertEqual(popped.integer, 10)
     }
 
-    /// Verify that a Vec<T> of transparent struct can be used as an argument and return
-    /// type for extern "Rust" functions.
+    /// Verify that a Vec<T> of transparent struct with derive(Clone) can be used as an
+    /// argument and return type for extern "Rust" functions.
     func testReflectVecOfTransparentStructFromClone() throws {
         let vec: RustVec<TransparentStructInsideVecT> = RustVec()
         vec.push(value: TransparentStructInsideVecT(string: "string".intoRustString(), integer: 10))

crates/swift-bridge-ir/src/codegen/codegen_tests/vec_codegen_tests.rs

@@ -537,8 +537,8 @@ void __swift_bridge__$some_function(void* arg);
     }
 }
 
-/// Verify that we emit Rust, Swift and C header code that allows a transparent struct be used
-/// within a Vec<T>.
+/// Verify that we emit Rust, Swift and C header code that allows
+/// a transparent struct with derive(Clone) to be used within a Vec<T>.
 mod transparent_struct_vec_support {
     use super::*;
 
@@ -682,6 +682,8 @@ void* __swift_bridge__$Vec_SomeStruct$as_ptr(void* vec_ptr);
     }
 }
 
+/// Verify that we emit Rust, Swift and C header code that allows
+/// a transparent struct with derive(Copy, Clone) to be used within a Vec<T>.
 mod transparent_struct_vec_support_with_copy {
     use super::*;
 
@@ -824,6 +826,8 @@ void* __swift_bridge__$Vec_SomeStruct$as_ptr(void* vec_ptr);
     }
 }
 
+/// Verify that we DON'T emit Rust, Swift and C header code for a transparent
+/// struct with no derived traits.
 mod transparent_struct_vec_support_without_derives {
     use super::*;
 

crates/swift-bridge-ir/src/codegen/generate_rust_tokens/vec/vec_of_transparent_struct.rs

@@ -120,9 +120,9 @@ mod tests {
     use crate::test_utils::assert_tokens_eq;
     use proc_macro2::{Ident, Span};
 
-    /// Verify that we can generate the functions for an opaque Rust type that get exposed to Swift
-    /// in order to power the `extension MyRustType: Vectorizable { }` implementation on the Swift
-    /// side.
+    /// Verify that we can generate the functions for shared struct with derive(Copy, Clone) that
+    /// gets exposed to Swift in order to power the `extension MyRustType: Vectorizable { }`
+    /// implementation on the Swift side.
     #[test]
     fn generates_vectorizable_impl_for_shared_struct_with_copy() {
         let expected = quote! {
@@ -201,9 +201,9 @@ mod tests {
         );
     }
 
-    /// Verify that we can generate the functions for an opaque Rust type that get exposed to Swift
-    /// in order to power the `extension MyRustType: Vectorizable { }` implementation on the Swift
-    /// side.
+    /// Verify that we can generate the functions for shared struct with derive(Clone) that
+    /// gets exposed to Swift in order to power the `extension MyRustType: Vectorizable { }`
+    /// implementation on the Swift side.
     #[test]
     fn generates_vectorizable_impl_for_shared_struct_with_clone() {
         let expected = quote! {