Handle module selectors in syntactic_sugar

CHANGELOG.md

@@ -34,6 +34,12 @@
   [Hokila](https://github.com/Hokila)
   [#6897](https://github.com/realm/SwiftLint/issues/6897)
 
+* Stop `syntactic_sugar` from reporting and correcting types referenced with a
+  module selector other than `Swift::`, such as `Foo::Array<Int>`, and report
+  `Swift::Array<Int>()` in expressions.  
+  [gxlactuss](https://github.com/gxlactuss)
+  [#6924](https://github.com/realm/SwiftLint/issues/6924)
+
 ## 0.65.1: Fresh Folded Fixtures
 
 ### Breaking

Source/SwiftLintBuiltInRules/Rules/Idiomatic/SyntacticSugarRule.swift

@@ -53,6 +53,8 @@ private enum SugaredType: String {
         var typeName = typeName
         if typeName.hasPrefix("Swift.") {
             typeName.removeFirst("Swift.".count)
+        } else if typeName.hasPrefix("Swift::") {
+            typeName.removeFirst("Swift::".count)
         }
 
         self.init(rawValue: typeName)
@@ -195,7 +197,9 @@ private final class SyntacticSugarRuleVisitor: SyntaxVisitor {
         }
 
         if let simpleType = typeSyntax?.as(IdentifierTypeSyntax.self) {
-            if SugaredType(typeName: simpleType.name.text) != nil {
+            // A module selector other than `Swift::` refers to a type from that module, e.g. `Foo::Array<Int>`
+            let isSwiftType = simpleType.moduleSelector.map { $0.moduleName.text == "Swift" } ?? true
+            if isSwiftType, SugaredType(typeName: simpleType.name.text) != nil {
                 return violation(from: simpleType)
             }
 
@@ -342,7 +346,7 @@ extension IdentifierTypeSyntax: SyntaxWithGenericClause {
 
 extension GenericSpecializationExprSyntax: SyntaxWithGenericClause {
     var typeName: String? {
-        expression.as(DeclReferenceExprSyntax.self)?.firstToken(viewMode: .sourceAccurate)?.text ??
+        expression.as(DeclReferenceExprSyntax.self)?.baseName.text ??
         expression.as(MemberAccessExprSyntax.self)?.declName.baseName.text
     }
     var genericArguments: GenericArgumentClauseSyntax? { genericArgumentClause }

Source/SwiftLintBuiltInRules/Rules/Idiomatic/SyntacticSugarRuleExamples.swift

@@ -31,6 +31,9 @@ internal enum SyntacticSugarRuleExamples {
         "let x = case Optional<Any>.none = obj",
         "let a = Swift.Optional<String?>.none",
         "func f() -> [Array<Int>.Index] { [Array<Int>.Index]() }".asExample(excludeFromDocumentation: true),
+        "let x: Foo::Array<Int>".asExample(excludeFromDocumentation: true),
+        "func x(a: Foo::Optional<Int>) -> Foo::Dictionary<String, Int>".asExample(excludeFromDocumentation: true),
+        "let x = Foo::Array<Int>()".asExample(excludeFromDocumentation: true),
     ])
 
     static let triggering = #examples([
@@ -65,6 +68,9 @@ internal enum SyntacticSugarRuleExamples {
         let dict: [String: Any] = [:]
         _ = dict["key"] as? ↓Optional<String?> ?? Optional<String?>.none
         """,
+        "let x: ↓Swift::Array<String>".asExample(excludeFromDocumentation: true),
+        "let x: Foo::Array<↓Array<Int>>".asExample(excludeFromDocumentation: true),
+        "let x = ↓Swift::Dictionary<Int, String>()".asExample(excludeFromDocumentation: true),
     ])
 
     static let corrections = #corrections([
@@ -84,5 +90,7 @@ internal enum SyntacticSugarRuleExamples {
             "let x:[[[Int: Int]: Int]: String]",
         "let x:↓Array<↓Dictionary<Int, Int>>": "let x:[[Int: Int]]",
         "let x:↓Optional<↓Dictionary<Int, Int>>": "let x:[Int: Int]?",
+        "let x: Swift::Optional<String>": "let x: String?",
+        "let x = Swift::Array<Int>()": "let x = [Int]()",
     ])
 }