From 3f515eeb836558f645bd7453328d86d155d9eba8 Mon Sep 17 00:00:00 2001 From: Andrew Roan Date: Sun, 24 May 2026 22:47:45 -0500 Subject: [PATCH 1/4] Add tests for label_for_symbol function --- src/language_server.rs | 173 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 173 insertions(+) diff --git a/src/language_server.rs b/src/language_server.rs index 398d825..5d384e5 100644 --- a/src/language_server.rs +++ b/src/language_server.rs @@ -209,3 +209,176 @@ impl SourceKitLsp { } } } + +#[cfg(test)] +mod tests { + use super::*; + use zed_extension_api::lsp::{Symbol, SymbolKind}; + + fn make_symbol(kind: SymbolKind, name: &str) -> Symbol { + Symbol { + kind, + name: name.to_string(), + } + } + + // Asserts the three fields of a CodeLabel match the Rust built-in adapter pattern: + // - `code` is the full valid Swift snippet (prefix + name + suffix) for tree-sitter + // - `spans` selects prefix + name from `code` (suffix excluded from display) + // - `filter_range` indexes into the displayed text and selects just the name, + // skipping the keyword prefix, so fuzzy matching works on the name alone + fn assert_code_label( + label: &CodeLabel, + expected_code: &str, + expected_display: &str, + expected_name: &str, + ) { + assert_eq!(label.code, expected_code, "code field"); + + assert_eq!(label.spans.len(), 1, "expected exactly one span"); + let CodeLabelSpan::CodeRange(span) = &label.spans[0] else { + panic!("expected CodeRange span, got Literal"); + }; + + let displayed = &expected_code[span.start as usize..span.end as usize]; + assert_eq!( + displayed, expected_display, + "span selects wrong text from code" + ); + + let filter_text = + &displayed[label.filter_range.start as usize..label.filter_range.end as usize]; + assert_eq!( + filter_text, expected_name, + "filter_range should select just the symbol name" + ); + } + + #[test] + fn label_for_function() { + let label = SourceKitLsp::new() + .label_for_symbol(make_symbol(SymbolKind::Function, "myFunc")) + .expect("expected a label for Function"); + assert_code_label(&label, "func myFunc() {}", "func myFunc", "myFunc"); + } + + #[test] + fn label_for_method() { + let label = SourceKitLsp::new() + .label_for_symbol(make_symbol(SymbolKind::Method, "myMethod")) + .expect("expected a label for Method"); + assert_code_label(&label, "func myMethod() {}", "func myMethod", "myMethod"); + } + + #[test] + fn label_for_variable() { + let label = SourceKitLsp::new() + .label_for_symbol(make_symbol(SymbolKind::Variable, "myVar")) + .expect("expected a label for Variable"); + assert_code_label(&label, "var myVar: Int", "var myVar", "myVar"); + } + + #[test] + fn label_for_constant() { + let label = SourceKitLsp::new() + .label_for_symbol(make_symbol(SymbolKind::Constant, "myConst")) + .expect("expected a label for Constant"); + assert_code_label(&label, "let myConst: Int", "let myConst", "myConst"); + } + + #[test] + fn label_for_class() { + let label = SourceKitLsp::new() + .label_for_symbol(make_symbol(SymbolKind::Class, "MyClass")) + .expect("expected a label for Class"); + assert_code_label(&label, "class MyClass {}", "class MyClass", "MyClass"); + } + + #[test] + fn label_for_struct() { + let label = SourceKitLsp::new() + .label_for_symbol(make_symbol(SymbolKind::Struct, "MyStruct")) + .expect("expected a label for Struct"); + assert_code_label(&label, "struct MyStruct {}", "struct MyStruct", "MyStruct"); + } + + #[test] + fn label_for_enum() { + let label = SourceKitLsp::new() + .label_for_symbol(make_symbol(SymbolKind::Enum, "MyEnum")) + .expect("expected a label for Enum"); + assert_code_label(&label, "enum MyEnum {}", "enum MyEnum", "MyEnum"); + } + + #[test] + fn label_for_protocol() { + let label = SourceKitLsp::new() + .label_for_symbol(make_symbol(SymbolKind::Interface, "MyProtocol")) + .expect("expected a label for Interface"); + assert_code_label( + &label, + "protocol MyProtocol {}", + "protocol MyProtocol", + "MyProtocol", + ); + } + + #[test] + fn label_for_property() { + let label = SourceKitLsp::new() + .label_for_symbol(make_symbol(SymbolKind::Property, "myProp")) + .expect("expected a label for Property"); + assert_code_label(&label, "var myProp: Int", "var myProp", "myProp"); + } + + #[test] + fn label_for_extension() { + let label = SourceKitLsp::new() + .label_for_symbol(make_symbol(SymbolKind::Namespace, "MyType")) + .expect("expected a label for Namespace"); + assert_code_label(&label, "extension MyType {}", "extension MyType", "MyType"); + } + + #[test] + fn label_for_enum_case() { + let label = SourceKitLsp::new() + .label_for_symbol(make_symbol(SymbolKind::EnumMember, "myCase")) + .expect("expected a label for EnumMember"); + assert_code_label(&label, "enum E { case myCase }", "case myCase", "myCase"); + } + + #[test] + fn label_for_initializer() { + let label = SourceKitLsp::new() + .label_for_symbol(make_symbol(SymbolKind::Constructor, "init(x:y:)")) + .expect("expected a label for Constructor (init)"); + assert_code_label(&label, "class C { init(x:y:) }", "init(x:y:)", "init"); + } + + #[test] + fn label_for_deinitializer() { + let label = SourceKitLsp::new() + .label_for_symbol(make_symbol(SymbolKind::Constructor, "deinit")) + .expect("expected a label for Constructor (deinit)"); + assert_code_label(&label, "class C { deinit }", "deinit", "deinit"); + } + + #[test] + fn label_for_type_parameter() { + let label = SourceKitLsp::new() + .label_for_symbol(make_symbol(SymbolKind::TypeParameter, "MyAlias")) + .expect("expected a label for TypeParameter"); + assert_code_label( + &label, + "typealias MyAlias = Any", + "typealias MyAlias", + "MyAlias", + ); + } + + #[test] + fn label_for_unhandled_kind_returns_none() { + let label = SourceKitLsp::new().label_for_symbol(make_symbol(SymbolKind::File, "anything")); + assert!(label.is_none(), "expected None for unhandled SymbolKind"); + } +} From e2a5b6f824bb549ce415ebe1a1802b12e2b30225 Mon Sep 17 00:00:00 2001 From: Andrew Roan Date: Sun, 24 May 2026 23:04:01 -0500 Subject: [PATCH 2/4] Add swift package fixture fix-label_for_symbol --- .gitignore | 1 + fixtures/my-package/Package.swift | 14 ++++ .../my-package/Sources/MyTarget/MyActor.swift | 18 +++++ .../my-package/Sources/MyTarget/MyClass.swift | 18 +++++ .../my-package/Sources/MyTarget/MyEnum.swift | 13 ++++ .../Sources/MyTarget/MyProtocol.swift | 8 +++ .../Sources/MyTarget/MyStruct.swift | 14 ++++ .../Sources/MyTarget/TopLevel.swift | 6 ++ .../Tests/MyTarget-SwiftTestingTests.swift | 68 +++++++++++++++++++ .../Tests/MyTarget-XCTestTests.swift | 61 +++++++++++++++++ 10 files changed, 221 insertions(+) create mode 100644 fixtures/my-package/Package.swift create mode 100644 fixtures/my-package/Sources/MyTarget/MyActor.swift create mode 100644 fixtures/my-package/Sources/MyTarget/MyClass.swift create mode 100644 fixtures/my-package/Sources/MyTarget/MyEnum.swift create mode 100644 fixtures/my-package/Sources/MyTarget/MyProtocol.swift create mode 100644 fixtures/my-package/Sources/MyTarget/MyStruct.swift create mode 100644 fixtures/my-package/Sources/MyTarget/TopLevel.swift create mode 100644 fixtures/my-package/Tests/MyTarget-SwiftTestingTests.swift create mode 100644 fixtures/my-package/Tests/MyTarget-XCTestTests.swift diff --git a/.gitignore b/.gitignore index 198839d..da05c88 100644 --- a/.gitignore +++ b/.gitignore @@ -3,3 +3,4 @@ .idea grammars target +.build diff --git a/fixtures/my-package/Package.swift b/fixtures/my-package/Package.swift new file mode 100644 index 0000000..51b8c07 --- /dev/null +++ b/fixtures/my-package/Package.swift @@ -0,0 +1,14 @@ +// swift-tools-version:5.9 + +import PackageDescription + +let package = Package( + name: "my-package", + products: [ + .library(name: "MyTarget", targets: ["MyTarget"]), + ], + targets: [ + .target(name: "MyTarget"), + .testTarget(name: "MyTargetTests", dependencies: ["MyTarget"]) + ] +) diff --git a/fixtures/my-package/Sources/MyTarget/MyActor.swift b/fixtures/my-package/Sources/MyTarget/MyActor.swift new file mode 100644 index 0000000..5408527 --- /dev/null +++ b/fixtures/my-package/Sources/MyTarget/MyActor.swift @@ -0,0 +1,18 @@ +public actor MyActor { + public var aFoo: Int + public let aBar: String + + public func aMemberFunction(aNewFoo: Int) -> Int { + self.aFoo = aNewFoo + return aNewFoo + } + + public init(foo: Int, bar: String) { + self.aFoo = foo + self.aBar = bar + } + + deinit { + self.aFoo = 0 + } +} diff --git a/fixtures/my-package/Sources/MyTarget/MyClass.swift b/fixtures/my-package/Sources/MyTarget/MyClass.swift new file mode 100644 index 0000000..2fffb87 --- /dev/null +++ b/fixtures/my-package/Sources/MyTarget/MyClass.swift @@ -0,0 +1,18 @@ +public class MyClass { + public var cFoo: Int + public let cBar: String + + public func cMemberFunction(cNewFoo: Int) -> Int { + self.cFoo = cNewFoo + return cNewFoo + } + + public init(foo: Int, bar: String) { + self.cFoo = foo + self.cBar = bar + } + + deinit { + self.cFoo = 0 + } +} diff --git a/fixtures/my-package/Sources/MyTarget/MyEnum.swift b/fixtures/my-package/Sources/MyTarget/MyEnum.swift new file mode 100644 index 0000000..1abb654 --- /dev/null +++ b/fixtures/my-package/Sources/MyTarget/MyEnum.swift @@ -0,0 +1,13 @@ +public enum MyEnum: Equatable { + case foo(Int) + case bar(String) + + public func eMemberFunction(newFoo: Int) -> Self? { + switch self { + case .foo: + return .foo(newFoo) + case .bar: + return nil + } + } +} diff --git a/fixtures/my-package/Sources/MyTarget/MyProtocol.swift b/fixtures/my-package/Sources/MyTarget/MyProtocol.swift new file mode 100644 index 0000000..5d5923f --- /dev/null +++ b/fixtures/my-package/Sources/MyTarget/MyProtocol.swift @@ -0,0 +1,8 @@ +public protocol MyProtocol { + var pFoo: Int { get set } + var pBar: String { get } + + mutating func pMemberFunction(pNewFoo: Int) -> Int + + init(foo: Int, bar: String) +} diff --git a/fixtures/my-package/Sources/MyTarget/MyStruct.swift b/fixtures/my-package/Sources/MyTarget/MyStruct.swift new file mode 100644 index 0000000..cf3373f --- /dev/null +++ b/fixtures/my-package/Sources/MyTarget/MyStruct.swift @@ -0,0 +1,14 @@ +public struct MyStruct { + public var sFoo: Int + public let sBar: String + + public mutating func sMemberFunction(sNewFoo: Int) -> Int { + self.sFoo = sNewFoo + return sNewFoo + } + + public init(foo: Int, bar: String) { + self.sFoo = foo + self.sBar = bar + } +} diff --git a/fixtures/my-package/Sources/MyTarget/TopLevel.swift b/fixtures/my-package/Sources/MyTarget/TopLevel.swift new file mode 100644 index 0000000..06709bf --- /dev/null +++ b/fixtures/my-package/Sources/MyTarget/TopLevel.swift @@ -0,0 +1,6 @@ +public var topLevelFoo: Int = 0 + +public func topLevelFunction(tNewFoo: Int) -> Int { + topLevelFoo = tNewFoo + return tNewFoo +} diff --git a/fixtures/my-package/Tests/MyTarget-SwiftTestingTests.swift b/fixtures/my-package/Tests/MyTarget-SwiftTestingTests.swift new file mode 100644 index 0000000..7db948c --- /dev/null +++ b/fixtures/my-package/Tests/MyTarget-SwiftTestingTests.swift @@ -0,0 +1,68 @@ +import MyTarget +import Testing + +@Suite +struct MyTarget_SwiftTestingTests { + @Test + func myActor() async { + let myActor = MyActor(foo: 1, bar: "initial") + + let newFoo = await myActor.aMemberFunction(aNewFoo: 2) + let currentAFoo = await myActor.aFoo + #expect(newFoo == currentAFoo) + } + + @Test + func myClass() { + let myClass = MyClass(foo: 1, bar: "initial") + + let newFoo = myClass.cMemberFunction(cNewFoo: 2) + #expect(newFoo == myClass.cFoo) + } + + @Test + func myStruct() { + var myStruct = MyStruct(foo: 1, bar: "initial") + + let newFoo = myStruct.sMemberFunction(sNewFoo: 2) + #expect(newFoo == myStruct.sFoo) + } + + @Test + func myProtocol() { + let myProtocolWitness = MyProtocolWitness(foo: 1, bar: "initial") + + let newFoo = myProtocolWitness.pMemberFunction(pNewFoo: 2) + #expect(newFoo == myProtocolWitness.pFoo) + } + + @Test + func topLevel() { + let newFoo = topLevelFunction(tNewFoo: topLevelFoo + 1) + + #expect(newFoo == topLevelFoo) + } + + @Test + func myEnum() { + let myEnum = MyEnum.foo(1) + + let newFoo = myEnum.eMemberFunction(newFoo: 2) + #expect(newFoo == MyEnum.foo(2)) + } +} + +private class MyProtocolWitness: MyProtocol { + var pFoo: Int + let pBar: String + + func pMemberFunction(pNewFoo: Int) -> Int { + self.pFoo = pNewFoo + return pNewFoo + } + + required init(foo: Int, bar: String) { + self.pFoo = foo + self.pBar = bar + } +} diff --git a/fixtures/my-package/Tests/MyTarget-XCTestTests.swift b/fixtures/my-package/Tests/MyTarget-XCTestTests.swift new file mode 100644 index 0000000..0d5a0ee --- /dev/null +++ b/fixtures/my-package/Tests/MyTarget-XCTestTests.swift @@ -0,0 +1,61 @@ +import MyTarget +import XCTest + +class MyTarget_XCTestTests: XCTestCase { + func testMyActor() async { + let myActor = MyActor(foo: 1, bar: "initial") + + let newFoo = await myActor.aMemberFunction(aNewFoo: 2) + let currentAFoo = await myActor.aFoo + XCTAssertTrue(newFoo == currentAFoo) + } + + func testMyClass() { + let myClass = MyClass(foo: 1, bar: "initial") + + let newFoo = myClass.cMemberFunction(cNewFoo: 2) + XCTAssertTrue(newFoo == myClass.cFoo) + } + + func testMyStruct() { + var myStruct = MyStruct(foo: 1, bar: "initial") + + let newFoo = myStruct.sMemberFunction(sNewFoo: 2) + XCTAssertTrue(newFoo == myStruct.sFoo) + } + + func testMyProtocol() { + let myProtocolWitness = MyProtocolWitness(foo: 1, bar: "initial") + + let newFoo = myProtocolWitness.pMemberFunction(pNewFoo: 2) + XCTAssertTrue(newFoo == myProtocolWitness.pFoo) + } + + func testTopLevel() { + let newFoo = topLevelFunction(tNewFoo: topLevelFoo + 1) + + XCTAssertTrue(newFoo == topLevelFoo) + } + + func testMyEnum() { + let myEnum = MyEnum.foo(1) + + let newFoo = myEnum.eMemberFunction(newFoo: 2) + XCTAssertTrue(newFoo == MyEnum.foo(2)) + } +} + +private class MyProtocolWitness: MyProtocol { + var pFoo: Int + let pBar: String + + func pMemberFunction(pNewFoo: Int) -> Int { + self.pFoo = pNewFoo + return pNewFoo + } + + required init(foo: Int, bar: String) { + self.pFoo = foo + self.pBar = bar + } +} From c991ad3959ffbb13b36e057f8872c75b1e640c21 Mon Sep 17 00:00:00 2001 From: Andrew Roan Date: Sun, 24 May 2026 23:11:06 -0500 Subject: [PATCH 3/4] Add missing symbol kinds and fix behavior to match rust extension in label_for_symbol fix-label_for_symbol --- src/language_server.rs | 79 ++++++++++++++++++++++-------------------- 1 file changed, 42 insertions(+), 37 deletions(-) diff --git a/src/language_server.rs b/src/language_server.rs index 5d384e5..6d2421d 100644 --- a/src/language_server.rs +++ b/src/language_server.rs @@ -160,52 +160,57 @@ impl SourceKitLsp { pub fn label_for_symbol(&self, symbol: Symbol) -> Option { match symbol.kind { - SymbolKind::Method | SymbolKind::Function => { - // Simple label: "func " - let code = format!("func {}", symbol.name); + // Enum cases need the surrounding enum body as tree-sitter context so that + // `case` tokenizes correctly. The `case` keyword is shown in the label but + // excluded from the filter so fuzzy matching works on the case name alone. + SymbolKind::EnumMember => { + let context = "enum E { "; + let case_kw = "case "; + let code = format!("{context}{case_kw}{} }}", symbol.name); + let display_start = context.len(); + let display_end = display_start + case_kw.len() + symbol.name.len(); Some(CodeLabel { - code: code.clone(), - spans: vec![CodeLabelSpan::code_range(0..code.len())], - filter_range: (0..symbol.name.len()).into(), - }) - } - SymbolKind::Variable | SymbolKind::Constant => { - // Simple label: "var/let " - let code = format!("var/let {}", symbol.name); - Some(CodeLabel { - code: code.clone(), - spans: vec![CodeLabelSpan::code_range(0..code.len())], - filter_range: (0..symbol.name.len()).into(), - }) - } - SymbolKind::Class => { - // Simple label: "class " - let code = format!("class {}", symbol.name); - Some(CodeLabel { - code: code.clone(), - spans: vec![CodeLabelSpan::code_range(0..code.len())], - filter_range: (0..symbol.name.len()).into(), + spans: vec![CodeLabelSpan::code_range(display_start..display_end)], + filter_range: (case_kw.len()..case_kw.len() + symbol.name.len()).into(), + code, }) } - SymbolKind::Struct => { - // Simple label: "struct " - let code = format!("struct {}", symbol.name); + // SourceKit-LSP sends the full signature as the name ("init(x:y:)", "deinit"), + // so no keyword prefix is needed. A class body provides tree-sitter context. + // Filter stops at `(` so typing "init" matches all initializers. + SymbolKind::Constructor => { + let context = "class C { "; + let code = format!("{context}{} }}", symbol.name); + let display_start = context.len(); + let display_end = display_start + symbol.name.len(); + let filter_end = symbol.name.find('(').unwrap_or(symbol.name.len()); Some(CodeLabel { - code: code.clone(), - spans: vec![CodeLabelSpan::code_range(0..code.len())], - filter_range: (0..symbol.name.len()).into(), + spans: vec![CodeLabelSpan::code_range(display_start..display_end)], + filter_range: (0..filter_end).into(), + code, }) } - SymbolKind::Enum => { - // Simple label: "enum " - let code = format!("enum {}", symbol.name); + kind => { + let (prefix, suffix) = match kind { + SymbolKind::Method | SymbolKind::Function => ("func ", "() {}"), + SymbolKind::Variable | SymbolKind::Property => ("var ", ": Int"), + SymbolKind::Constant => ("let ", ": Int"), + SymbolKind::Class => ("class ", " {}"), + SymbolKind::Interface => ("protocol ", " {}"), + SymbolKind::Struct => ("struct ", " {}"), + SymbolKind::Enum => ("enum ", " {}"), + SymbolKind::Namespace => ("extension ", " {}"), + SymbolKind::TypeParameter => ("typealias ", " = Any"), + _ => return None, + }; + let code = format!("{prefix}{}{suffix}", symbol.name); + let display_len = prefix.len() + symbol.name.len(); Some(CodeLabel { - code: code.clone(), - spans: vec![CodeLabelSpan::code_range(0..code.len())], - filter_range: (0..symbol.name.len()).into(), + spans: vec![CodeLabelSpan::code_range(0..display_len)], + filter_range: (prefix.len()..display_len).into(), + code, }) } - _ => None, } } } From 6eef952a5880d595e1ea8b2f81ce451ffed792a4 Mon Sep 17 00:00:00 2001 From: Andrew Roan Date: Mon, 20 Jul 2026 12:52:43 -0500 Subject: [PATCH 4/4] Remove fixture swift package fix-label_for_symbol --- fixtures/my-package/Package.swift | 14 ---- .../my-package/Sources/MyTarget/MyActor.swift | 18 ----- .../my-package/Sources/MyTarget/MyClass.swift | 18 ----- .../my-package/Sources/MyTarget/MyEnum.swift | 13 ---- .../Sources/MyTarget/MyProtocol.swift | 8 --- .../Sources/MyTarget/MyStruct.swift | 14 ---- .../Sources/MyTarget/TopLevel.swift | 6 -- .../Tests/MyTarget-SwiftTestingTests.swift | 68 ------------------- .../Tests/MyTarget-XCTestTests.swift | 61 ----------------- 9 files changed, 220 deletions(-) delete mode 100644 fixtures/my-package/Package.swift delete mode 100644 fixtures/my-package/Sources/MyTarget/MyActor.swift delete mode 100644 fixtures/my-package/Sources/MyTarget/MyClass.swift delete mode 100644 fixtures/my-package/Sources/MyTarget/MyEnum.swift delete mode 100644 fixtures/my-package/Sources/MyTarget/MyProtocol.swift delete mode 100644 fixtures/my-package/Sources/MyTarget/MyStruct.swift delete mode 100644 fixtures/my-package/Sources/MyTarget/TopLevel.swift delete mode 100644 fixtures/my-package/Tests/MyTarget-SwiftTestingTests.swift delete mode 100644 fixtures/my-package/Tests/MyTarget-XCTestTests.swift diff --git a/fixtures/my-package/Package.swift b/fixtures/my-package/Package.swift deleted file mode 100644 index 51b8c07..0000000 --- a/fixtures/my-package/Package.swift +++ /dev/null @@ -1,14 +0,0 @@ -// swift-tools-version:5.9 - -import PackageDescription - -let package = Package( - name: "my-package", - products: [ - .library(name: "MyTarget", targets: ["MyTarget"]), - ], - targets: [ - .target(name: "MyTarget"), - .testTarget(name: "MyTargetTests", dependencies: ["MyTarget"]) - ] -) diff --git a/fixtures/my-package/Sources/MyTarget/MyActor.swift b/fixtures/my-package/Sources/MyTarget/MyActor.swift deleted file mode 100644 index 5408527..0000000 --- a/fixtures/my-package/Sources/MyTarget/MyActor.swift +++ /dev/null @@ -1,18 +0,0 @@ -public actor MyActor { - public var aFoo: Int - public let aBar: String - - public func aMemberFunction(aNewFoo: Int) -> Int { - self.aFoo = aNewFoo - return aNewFoo - } - - public init(foo: Int, bar: String) { - self.aFoo = foo - self.aBar = bar - } - - deinit { - self.aFoo = 0 - } -} diff --git a/fixtures/my-package/Sources/MyTarget/MyClass.swift b/fixtures/my-package/Sources/MyTarget/MyClass.swift deleted file mode 100644 index 2fffb87..0000000 --- a/fixtures/my-package/Sources/MyTarget/MyClass.swift +++ /dev/null @@ -1,18 +0,0 @@ -public class MyClass { - public var cFoo: Int - public let cBar: String - - public func cMemberFunction(cNewFoo: Int) -> Int { - self.cFoo = cNewFoo - return cNewFoo - } - - public init(foo: Int, bar: String) { - self.cFoo = foo - self.cBar = bar - } - - deinit { - self.cFoo = 0 - } -} diff --git a/fixtures/my-package/Sources/MyTarget/MyEnum.swift b/fixtures/my-package/Sources/MyTarget/MyEnum.swift deleted file mode 100644 index 1abb654..0000000 --- a/fixtures/my-package/Sources/MyTarget/MyEnum.swift +++ /dev/null @@ -1,13 +0,0 @@ -public enum MyEnum: Equatable { - case foo(Int) - case bar(String) - - public func eMemberFunction(newFoo: Int) -> Self? { - switch self { - case .foo: - return .foo(newFoo) - case .bar: - return nil - } - } -} diff --git a/fixtures/my-package/Sources/MyTarget/MyProtocol.swift b/fixtures/my-package/Sources/MyTarget/MyProtocol.swift deleted file mode 100644 index 5d5923f..0000000 --- a/fixtures/my-package/Sources/MyTarget/MyProtocol.swift +++ /dev/null @@ -1,8 +0,0 @@ -public protocol MyProtocol { - var pFoo: Int { get set } - var pBar: String { get } - - mutating func pMemberFunction(pNewFoo: Int) -> Int - - init(foo: Int, bar: String) -} diff --git a/fixtures/my-package/Sources/MyTarget/MyStruct.swift b/fixtures/my-package/Sources/MyTarget/MyStruct.swift deleted file mode 100644 index cf3373f..0000000 --- a/fixtures/my-package/Sources/MyTarget/MyStruct.swift +++ /dev/null @@ -1,14 +0,0 @@ -public struct MyStruct { - public var sFoo: Int - public let sBar: String - - public mutating func sMemberFunction(sNewFoo: Int) -> Int { - self.sFoo = sNewFoo - return sNewFoo - } - - public init(foo: Int, bar: String) { - self.sFoo = foo - self.sBar = bar - } -} diff --git a/fixtures/my-package/Sources/MyTarget/TopLevel.swift b/fixtures/my-package/Sources/MyTarget/TopLevel.swift deleted file mode 100644 index 06709bf..0000000 --- a/fixtures/my-package/Sources/MyTarget/TopLevel.swift +++ /dev/null @@ -1,6 +0,0 @@ -public var topLevelFoo: Int = 0 - -public func topLevelFunction(tNewFoo: Int) -> Int { - topLevelFoo = tNewFoo - return tNewFoo -} diff --git a/fixtures/my-package/Tests/MyTarget-SwiftTestingTests.swift b/fixtures/my-package/Tests/MyTarget-SwiftTestingTests.swift deleted file mode 100644 index 7db948c..0000000 --- a/fixtures/my-package/Tests/MyTarget-SwiftTestingTests.swift +++ /dev/null @@ -1,68 +0,0 @@ -import MyTarget -import Testing - -@Suite -struct MyTarget_SwiftTestingTests { - @Test - func myActor() async { - let myActor = MyActor(foo: 1, bar: "initial") - - let newFoo = await myActor.aMemberFunction(aNewFoo: 2) - let currentAFoo = await myActor.aFoo - #expect(newFoo == currentAFoo) - } - - @Test - func myClass() { - let myClass = MyClass(foo: 1, bar: "initial") - - let newFoo = myClass.cMemberFunction(cNewFoo: 2) - #expect(newFoo == myClass.cFoo) - } - - @Test - func myStruct() { - var myStruct = MyStruct(foo: 1, bar: "initial") - - let newFoo = myStruct.sMemberFunction(sNewFoo: 2) - #expect(newFoo == myStruct.sFoo) - } - - @Test - func myProtocol() { - let myProtocolWitness = MyProtocolWitness(foo: 1, bar: "initial") - - let newFoo = myProtocolWitness.pMemberFunction(pNewFoo: 2) - #expect(newFoo == myProtocolWitness.pFoo) - } - - @Test - func topLevel() { - let newFoo = topLevelFunction(tNewFoo: topLevelFoo + 1) - - #expect(newFoo == topLevelFoo) - } - - @Test - func myEnum() { - let myEnum = MyEnum.foo(1) - - let newFoo = myEnum.eMemberFunction(newFoo: 2) - #expect(newFoo == MyEnum.foo(2)) - } -} - -private class MyProtocolWitness: MyProtocol { - var pFoo: Int - let pBar: String - - func pMemberFunction(pNewFoo: Int) -> Int { - self.pFoo = pNewFoo - return pNewFoo - } - - required init(foo: Int, bar: String) { - self.pFoo = foo - self.pBar = bar - } -} diff --git a/fixtures/my-package/Tests/MyTarget-XCTestTests.swift b/fixtures/my-package/Tests/MyTarget-XCTestTests.swift deleted file mode 100644 index 0d5a0ee..0000000 --- a/fixtures/my-package/Tests/MyTarget-XCTestTests.swift +++ /dev/null @@ -1,61 +0,0 @@ -import MyTarget -import XCTest - -class MyTarget_XCTestTests: XCTestCase { - func testMyActor() async { - let myActor = MyActor(foo: 1, bar: "initial") - - let newFoo = await myActor.aMemberFunction(aNewFoo: 2) - let currentAFoo = await myActor.aFoo - XCTAssertTrue(newFoo == currentAFoo) - } - - func testMyClass() { - let myClass = MyClass(foo: 1, bar: "initial") - - let newFoo = myClass.cMemberFunction(cNewFoo: 2) - XCTAssertTrue(newFoo == myClass.cFoo) - } - - func testMyStruct() { - var myStruct = MyStruct(foo: 1, bar: "initial") - - let newFoo = myStruct.sMemberFunction(sNewFoo: 2) - XCTAssertTrue(newFoo == myStruct.sFoo) - } - - func testMyProtocol() { - let myProtocolWitness = MyProtocolWitness(foo: 1, bar: "initial") - - let newFoo = myProtocolWitness.pMemberFunction(pNewFoo: 2) - XCTAssertTrue(newFoo == myProtocolWitness.pFoo) - } - - func testTopLevel() { - let newFoo = topLevelFunction(tNewFoo: topLevelFoo + 1) - - XCTAssertTrue(newFoo == topLevelFoo) - } - - func testMyEnum() { - let myEnum = MyEnum.foo(1) - - let newFoo = myEnum.eMemberFunction(newFoo: 2) - XCTAssertTrue(newFoo == MyEnum.foo(2)) - } -} - -private class MyProtocolWitness: MyProtocol { - var pFoo: Int - let pBar: String - - func pMemberFunction(pNewFoo: Int) -> Int { - self.pFoo = pNewFoo - return pNewFoo - } - - required init(foo: Int, bar: String) { - self.pFoo = foo - self.pBar = bar - } -}