Merge pull request swiftlang#256 from google/format-shorthand

Fix false diagnostics in UseShorthandTypeNames.

Author: dabelknap

Sources/SwiftFormatRules/UseShorthandTypeNames.swift

@@ -32,31 +32,30 @@ public final class UseShorthandTypeNames: SyntaxFormatRule {
           !(parent is MemberTypeIdentifierSyntax) else { return node }
     // Type is in long form if it has a non-nil generic argument clause
     guard let genArg = node.genericArgumentClause else { return node }
-    diagnose(.useTypeShorthand(type: node.name.text.lowercased()), on: node)
 
     // Ensure that all arguments in the clause are shortened and in expected-format by visiting
     // the argument list, first
     let argList = visit(genArg.arguments) as! GenericArgumentListSyntax
     // Store trivia of the long form type to pass to the new shorthand type later
     let trivia = retrieveTrivia(from: node)
 
+    let newNode: TypeSyntax
     switch node.name.text {
     case "Array":
       guard let arg = argList.firstAndOnly else { return node }
-      let newArray = shortenArrayType(argument: arg, trivia: trivia)
-      return newArray
+      newNode = shortenArrayType(argument: arg, trivia: trivia)
     case "Dictionary":
       guard let args = exactlyTwoChildren(of: argList) else { return node }
-      let newDictionary = shortenDictionaryType(arguments: args, trivia: trivia)
-      return newDictionary
+      newNode = shortenDictionaryType(arguments: args, trivia: trivia)
     case "Optional":
       guard let arg = argList.firstAndOnly else { return node }
-      let newOptional = shortenOptionalType(argument: arg, trivia: trivia)
-      return newOptional
+      newNode = shortenOptionalType(argument: arg, trivia: trivia)
     default:
-      break
+      return node
     }
-    return node
+
+    diagnose(.useTypeShorthand(type: node.name.text), on: node)
+    return newNode
   }
 
   // Visits all potential long forms interpreted as expressions

Tests/SwiftFormatRulesTests/UseShorthandTypeNamesTests.swift

@@ -23,6 +23,8 @@ public class UseShorthandTypeNamesTests: DiagnosingTestCase {
                y: Dictionary<Array<Optional<String>>, Optional<Int>>) {
                Dictionary<Array<Int>.Index, String>.init()
                Dictionary<String, Optional<Float>>.init()
+               UnsafePointer<UInt8>.init()
+               UnsafeMutablePointer<UInt8>.init()
              }
              """,
       expected: """
@@ -40,7 +42,14 @@ public class UseShorthandTypeNamesTests: DiagnosingTestCase {
                   y: [[String?]: Int?]) {
                   [Array<Int>.Index: String].init()
                   [String: Float?].init()
+                  UnsafePointer<UInt8>.init()
+                  UnsafeMutablePointer<UInt8>.init()
                 }
                 """)
+    XCTAssertDiagnosed(.useTypeShorthand(type: "Array"))
+    XCTAssertDiagnosed(.useTypeShorthand(type: "Dictionary"))
+    XCTAssertDiagnosed(.useTypeShorthand(type: "Optional"))
+    XCTAssertNotDiagnosed(.useTypeShorthand(type: "UnsafePointer"))
+    XCTAssertNotDiagnosed(.useTypeShorthand(type: "UnsafeMutablePointer"))
   }
 }