Colon Spacing

Colons should be next to the identifier when specifying a type and next to the key in dictionary literals

  • Identifier: colon
  • Enabled by default: Yes
  • Supports autocorrection: Yes
  • Kind: style
  • Analyzer rule: No
  • Minimum Swift compiler version: 5.0.0
  • Default configuration:
    KeyValue
    severity warning
    flexible_right_spacing false
    apply_to_dictionaries true

Non Triggering Examples

let abc: Void
let abc: [Void: Void]
let abc: (Void, Void)
let abc: ([Void], String, Int)
let abc: [([Void], String, Int)]
let abc: String="def"
let abc: Int=0
let abc: Enum=Enum.Value
func abc(def: Void) {}
func abc(def: Void, ghi: Void) {}
let abc: String = "abc:"
let abc = [Void: Void]()
let abc = [1: [3: 2], 3: 4]
let abc = ["string": "string"]
let abc = ["string:string": "string"]
let abc: [String: Int]
func foo(bar: [String: Int]) {}
func foo() -> [String: Int] { return [:] }
let abc: Any
let abc: [Any: Int]
let abc: [String: Any]
class Foo: Bar {}
class Foo<T>: Bar {}
class Foo<T: Equatable>: Bar {}
class Foo<T, U>: Bar {}
class Foo<T: Equatable> {}
object.method(x: /* comment */ 5)
switch foo {
case .bar:
    _ = something()
}
object.method(x: 5, y: "string")
object.method(x: 5, y:
              "string")
object.method(5, y: "string")
func abc() { def(ghi: jkl) }
func abc(def: Void) { ghi(jkl: mno) }
class ABC { let def = ghi(jkl: mno) } }
func foo() { let dict = [1: 1] }
let aaa = Self.bbb ? Self.ccc : Self.ddd else {
return nil
Example("}
range.flatMap(file.syntaxMap.kinds(inByteRange:)) ?? []
@objc(receiveReply:)
public class func receiveReply(_ reply: bad_instruction_exception_reply_t) -> CInt { 0 }
switch str {
case "adlm", "adlam":             return .adlam
case "aghb", "caucasianalbanian": return .caucasianAlbanian
default:                          return nil
}
precedencegroup PipelinePrecedence {
  associativity: left
}
infix operator |> : PipelinePrecedence
switch scalar {
  case 0x000A...0x000D /* LF ... CR */: return true
  case 0x0085 /* NEXT LINE (NEL) */: return true
  case 0x2028 /* LINE SEPARATOR */: return true
  case 0x2029 /* PARAGRAPH SEPARATOR */: return true
  default: return false
}

Triggering Examples

let abc:Void
let abc:  Void
let abc :Void
let abc : Void
let abc : [Void: Void]
let abc : (Void, String, Int)
let abc : ([Void], String, Int)
let abc : [([Void], String, Int)]
let abc:  (Void, String, Int)
let abc:  ([Void], String, Int)
let abc:  [([Void], String, Int)]
let abc :String="def"
let abc :Int=0
let abc :Int = 0
let abc:Int=0
let abc:Int = 0
let abc:Enum=Enum.Value
func abc(def:Void) {}
func abc(def:  Void) {}
func abc(def :Void) {}
func abc(def : Void) {}
func abc(def: Void, ghi :Void) {}
let abc = [Void:Void]()
let abc = [Void : Void]()
let abc = [Void:  Void]()
let abc = [Void :  Void]()
let abc = [1: [3 : 2], 3: 4]
let abc = [1: [3 : 2], 3:  4]
let abc: [String : Int]
let abc: [String:Int]
func foo(bar: [String : Int]) {}
func foo(bar: [String:Int]) {}
func foo() -> [String : Int] { return [:] }
func foo() -> [String:Int] { return [:] }
let abc : Any
let abc: [Any : Int]
let abc: [String : Any]
class Foo : Bar {}
class Foo:Bar {}
class Foo<T> : Bar {}
class Foo<T>:Bar {}
class Foo<T, U>:Bar {}
class Foo<T: Equatable>:Bar {}
class Foo<T:Equatable> {}
class Foo<T : Equatable> {}
object.method(x: 5, y : "string")
object.method(x:5, y: "string")
object.method(x:  5, y: "string")
func abc() { def(ghi:jkl) }
func abc(def: Void) { ghi(jkl:mno) }
class ABC { let def = ghi(jkl:mno) } }
func foo() { let dict = [1 : 1] }
switch foo {
case .bar : return baz
}
private var action:(() -> Void)?