Fix issue parseType helper didn't handle qualified types like Foo.Bar

Author: calda

Sources/ParsingHelpers.swift

@@ -1291,6 +1291,7 @@ extension Formatter {
     ///  - `some ...`
     ///  - `borrowing ...`
     ///  - `consuming ...`
+    ///  - `(type).(type)`
     func parseType(at startOfTypeIndex: Int) -> (name: String, range: ClosedRange<Int>)? {
         guard let baseType = parseNonOptionalType(at: startOfTypeIndex) else { return nil }
 
@@ -1302,6 +1303,16 @@ extension Formatter {
             return (name: tokens[typeRange].string, range: typeRange)
         }
 
+        // Any type can be followed by a `.` which can then continue the type
+        if let nextTokenIndex = index(of: .nonSpaceOrCommentOrLinebreak, after: baseType.range.upperBound),
+           tokens[nextTokenIndex] == .operator(".", .infix),
+           let followingToken = index(of: .nonSpaceOrCommentOrLinebreak, after: nextTokenIndex),
+           let followingType = parseType(at: followingToken)
+        {
+            let typeRange = startOfTypeIndex ... followingType.range.upperBound
+            return (name: tokens[typeRange].string, range: typeRange)
+        }
+
         return baseType
     }
 

Tests/ParsingHelpersTests.swift

@@ -1746,6 +1746,27 @@ class ParsingHelpersTests: XCTestCase {
         XCTAssertEqual(formatter.parseType(at: 5)?.name, "any Foo")
     }
 
+    func testParseCompoundType() {
+        let formatter = Formatter(tokenize("""
+        let foo: Foo.Bar.Baaz
+        """))
+        XCTAssertEqual(formatter.parseType(at: 5)?.name, "Foo.Bar.Baaz")
+    }
+
+    func testParseCompoundGenericType() {
+        let formatter = Formatter(tokenize("""
+        let foo: Foo<Bar>.Bar.Baaz<Quux.V2>
+        """))
+        XCTAssertEqual(formatter.parseType(at: 5)?.name, "Foo<Bar>.Bar.Baaz<Quux.V2>")
+    }
+
+    func testParseExistentialTypeWithSubtype() {
+        let formatter = Formatter(tokenize("""
+        let foo: (any Foo).Bar.Baaz
+        """))
+        XCTAssertEqual(formatter.parseType(at: 5)?.name, "(any Foo).Bar.Baaz")
+    }
+
     func testParseOpaqueReturnType() {
         let formatter = Formatter(tokenize("""
         var body: some View { EmptyView() }

Tests/RulesTests+Wrapping.swift

@@ -4843,6 +4843,20 @@ class WrappingTests: RulesTests {
         testFormatting(for: input, rule: FormatRules.wrapAttributes, options: options)
     }
 
+    func testAttributeOnComputedProperty() {
+        let input = """
+        extension SectionContainer: ContentProviding where Section: ContentProviding {
+            @_disfavoredOverload
+            public var content: Section.Content {
+                section.content
+            }
+        }
+        """
+
+        let options = FormatOptions(storedVarAttributes: .sameLine, computedVarAttributes: .prevLine)
+        testFormatting(for: input, rule: FormatRules.wrapAttributes, options: options)
+    }
+
     // MARK: wrapEnumCases
 
     func testMultilineEnumCases() {