Merge pull request swiftlang#82 from dylansturg/optional_function_types

Wrap function types in tuples when converting to optional shorthand s…

Author: allevato

Sources/SwiftFormatRules/UseShorthandTypeNames.swift

@@ -120,10 +120,25 @@ public final class UseShorthandTypeNames: SyntaxFormatRule {
   func shortenOptionalType(argument: GenericArgumentSyntax, trivia: (Trivia, Trivia))
     -> TypeSyntax
   {
+    let argumentType: TypeSyntax
+    if let functionType = argument.argumentType as? FunctionTypeSyntax {
+      // Function types must be wrapped as a tuple before using shorthand optional syntax,
+      // otherwise the "?" applies to the return type instead of the function type.
+      let tupleTypeElement =
+        SyntaxFactory.makeTupleTypeElement(type: functionType, trailingComma: nil)
+      let tupleElementList = SyntaxFactory.makeTupleTypeElementList([tupleTypeElement])
+      argumentType = SyntaxFactory.makeTupleType(
+        leftParen: SyntaxFactory.makeLeftParenToken(),
+        elements: tupleElementList,
+        rightParen: SyntaxFactory.makeRightParenToken())
+    } else {
+      // Otherwise, the argument type can safely become an optional by simply appending a "?".
+      argumentType = argument.argumentType
+    }
     let (_, trailing) = trivia
     let questionMark = SyntaxFactory.makePostfixQuestionMarkToken(trailingTrivia: trailing)
-    let newOptional = SyntaxFactory.makeOptionalType(
-      wrappedType: argument.argumentType, questionMark: questionMark)
+    let newOptional =
+      SyntaxFactory.makeOptionalType(wrappedType: argumentType, questionMark: questionMark)
     return newOptional
   }
 

Tests/SwiftFormatRulesTests/UseShorthandTypeNamesTests.swift

@@ -11,12 +11,16 @@ public class UseShorthandTypeNamesTests: DiagnosingTestCase {
       input: """
              func enumeratedDictionary<Element>(
                from values: Array<Element>,
-               start: Optional<Array<Element>.Index> = nil
+               start: Optional<Array<Element>.Index> = nil,
+               callback: Optional<(_ someArg: Optional<Bool>) -> Void> = nil
              ) -> Dictionary<Int, Array<Element>> {
                // Specializer syntax
                Array<Array<Optional<Int>>.Index>.init()
                // More specializer syntax
                Array<[Int]>.init()
+               let foo: Optional<() -> Void>? = nil
+               let bar: Array<() -> Void> = []
+               let baz: Dictionary<Int, Optional<(Any) -> Void>>? = nil
              }
              func nestedLongForms(
                x: Array<Dictionary<String, Int>>,
@@ -30,12 +34,16 @@ public class UseShorthandTypeNamesTests: DiagnosingTestCase {
       expected: """
                 func enumeratedDictionary<Element>(
                   from values: [Element],
-                  start: Array<Element>.Index? = nil
+                  start: Array<Element>.Index? = nil,
+                  callback: ((_ someArg: Bool?) -> Void)? = nil
                 ) -> [Int: [Element]] {
                   // Specializer syntax
                   [Array<Int?>.Index].init()
                   // More specializer syntax
                   [[Int]].init()
+                  let foo: (() -> Void)?? = nil
+                  let bar: [() -> Void] = []
+                  let baz: [Int: ((Any) -> Void)?]? = nil
                 }
                 func nestedLongForms(
                   x: [[String: Int]],