# Summary of the Grammar

## Lexical Structure

Grammar of whitespace

whitespace → whitespace-item whitespace opt

whitespace-item → line-break

whitespace-item → inline-space

whitespace-item → comment

whitespace-item → multiline-comment

whitespace-item → U+0000, U+000B, or U+000C

line-break → U+000A

line-break → U+000D

line-break → U+000D followed by U+000A

inline-spaces → inline-space inline-spaces opt

inline-space → U+0009 or U+0020

comment → `//` comment-text line-break

multiline-comment → `/*` multiline-comment-text `*/`

comment-text → comment-text-item comment-text opt

comment-text-item → Any Unicode scalar value except U+000A or U+000D

multiline-comment-text → multiline-comment-text-item multiline-comment-text opt

multiline-comment-text-item → multiline-comment

multiline-comment-text-item → comment-text-item

multiline-comment-text-item → Any Unicode scalar value except `/*` or `*/`

Grammar of an identifier

identifier → identifier-head identifier-characters opt

identifier → ``` identifier-head identifier-characters opt ```

identifier → implicit-parameter-name

identifier → property-wrapper-projection

identifier-list → identifier | identifier `,` identifier-list

identifier-head → Upper- or lowercase letter A through Z

identifier-head → `_`

identifier-head → U+00A8, U+00AA, U+00AD, U+00AF, U+00B2–U+00B5, or U+00B7–U+00BA

identifier-head → U+00BC–U+00BE, U+00C0–U+00D6, U+00D8–U+00F6, or U+00F8–U+00FF

identifier-head → U+0100–U+02FF, U+0370–U+167F, U+1681–U+180D, or U+180F–U+1DBF

identifier-head → U+1E00–U+1FFF

identifier-head → U+200B–U+200D, U+202A–U+202E, U+203F–U+2040, U+2054, or U+2060–U+206F

identifier-head → U+2070–U+20CF, U+2100–U+218F, U+2460–U+24FF, or U+2776–U+2793

identifier-head → U+2C00–U+2DFF or U+2E80–U+2FFF

identifier-head → U+3004–U+3007, U+3021–U+302F, U+3031–U+303F, or U+3040–U+D7FF

identifier-head → U+F900–U+FD3D, U+FD40–U+FDCF, U+FDF0–U+FE1F, or U+FE30–U+FE44

identifier-head → U+FE47–U+FFFD

identifier-head → U+10000–U+1FFFD, U+20000–U+2FFFD, U+30000–U+3FFFD, or U+40000–U+4FFFD

identifier-head → U+50000–U+5FFFD, U+60000–U+6FFFD, U+70000–U+7FFFD, or U+80000–U+8FFFD

identifier-head → U+90000–U+9FFFD, U+A0000–U+AFFFD, U+B0000–U+BFFFD, or U+C0000–U+CFFFD

identifier-head → U+D0000–U+DFFFD or U+E0000–U+EFFFD

identifier-character → Digit 0 through 9

identifier-character → U+0300–U+036F, U+1DC0–U+1DFF, U+20D0–U+20FF, or U+FE20–U+FE2F

identifier-character → identifier-head

identifier-characters → identifier-character identifier-characters opt

implicit-parameter-name → `$` decimal-digits

property-wrapper-projection → `$` identifier-characters

Grammar of a literal

literal → numeric-literal | string-literal | regular-expression-literal | boolean-literal | nil-literal

numeric-literal → `-`opt integer-literal | `-`opt floating-point-literal

boolean-literal → `true` | `false`

nil-literal → `nil`

Grammar of an integer literal

integer-literal → binary-literal

integer-literal → octal-literal

integer-literal → decimal-literal

integer-literal → hexadecimal-literal

binary-literal → `0b` binary-digit binary-literal-characters opt

binary-digit → Digit 0 or 1

binary-literal-character → binary-digit | `_`

binary-literal-characters → binary-literal-character binary-literal-characters opt

octal-literal → `0o` octal-digit octal-literal-characters opt

octal-digit → Digit 0 through 7

octal-literal-character → octal-digit | `_`

octal-literal-characters → octal-literal-character octal-literal-characters opt

decimal-literal → decimal-digit decimal-literal-characters opt

decimal-digit → Digit 0 through 9

decimal-digits → decimal-digit decimal-digits opt

decimal-literal-character → decimal-digit | `_`

decimal-literal-characters → decimal-literal-character decimal-literal-characters opt

hexadecimal-literal → `0x` hexadecimal-digit hexadecimal-literal-characters opt

hexadecimal-digit → Digit 0 through 9, a through f, or A through F

hexadecimal-literal-character → hexadecimal-digit | `_`

hexadecimal-literal-characters → hexadecimal-literal-character hexadecimal-literal-characters opt

Grammar of a floating-point literal

floating-point-literal → decimal-literal decimal-fraction opt decimal-exponent opt

floating-point-literal → hexadecimal-literal hexadecimal-fraction opt hexadecimal-exponent

decimal-fraction → `.` decimal-literal

decimal-exponent → floating-point-e sign opt decimal-literal

hexadecimal-fraction → `.` hexadecimal-digit hexadecimal-literal-characters opt

hexadecimal-exponent → floating-point-p sign opt decimal-literal

floating-point-e → `e` | `E`

floating-point-p → `p` | `P`

sign → `+` | `-`

Grammar of a string literal

string-literal → static-string-literal | interpolated-string-literal

string-literal-opening-delimiter → extended-string-literal-delimiter opt `"`

string-literal-closing-delimiter → `"` extended-string-literal-delimiter opt

static-string-literal → string-literal-opening-delimiter quoted-text opt string-literal-closing-delimiter

static-string-literal → multiline-string-literal-opening-delimiter multiline-quoted-text opt multiline-string-literal-closing-delimiter

multiline-string-literal-opening-delimiter → extended-string-literal-delimiter opt `"""`

multiline-string-literal-closing-delimiter → `"""` extended-string-literal-delimiter opt

extended-string-literal-delimiter → `#` extended-string-literal-delimiter opt

quoted-text → quoted-text-item quoted-text opt

quoted-text-item → escaped-character

quoted-text-item → Any Unicode scalar value except `"`, `\`, U+000A, or U+000D

multiline-quoted-text → multiline-quoted-text-item multiline-quoted-text opt

multiline-quoted-text-item → escaped-character

multiline-quoted-text-item → Any Unicode scalar value except `\`

multiline-quoted-text-item → escaped-newline

interpolated-string-literal → string-literal-opening-delimiter interpolated-text opt string-literal-closing-delimiter

interpolated-string-literal → multiline-string-literal-opening-delimiter multiline-interpolated-text opt multiline-string-literal-closing-delimiter

interpolated-text → interpolated-text-item interpolated-text opt

interpolated-text-item → `\(` expression `)` | quoted-text-item

multiline-interpolated-text → multiline-interpolated-text-item multiline-interpolated-text opt

multiline-interpolated-text-item → `\(` expression `)` | multiline-quoted-text-item

escape-sequence → `\` extended-string-literal-delimiter

escaped-character → escape-sequence `0` | escape-sequence `\` | escape-sequence `t` | escape-sequence `n` | escape-sequence `r` | escape-sequence `"` | escape-sequence `'`

escaped-character → escape-sequence `u` `{` unicode-scalar-digits `}`

unicode-scalar-digits → Between one and eight hexadecimal digits

escaped-newline → escape-sequence inline-spaces opt line-break

Grammar of a regular expression literal

regular-expression-literal → regular-expression-literal-opening-delimiter regular-expression regular-expression-literal-closing-delimiter

regular-expression → Any regular expression

regular-expression-literal-opening-delimiter → extended-regular-expression-literal-delimiter opt `/`

regular-expression-literal-closing-delimiter → `/` extended-regular-expression-literal-delimiter opt

extended-regular-expression-literal-delimiter → `#` extended-regular-expression-literal-delimiter opt

Grammar of operators

operator → operator-head operator-characters opt

operator → dot-operator-head dot-operator-characters

operator-head → `/` | `=` | `-` | `+` | `!` | `*` | `%` | `<` | `>` | `&` | `|` | `^` | `~` | `?`

operator-head → U+00A1–U+00A7

operator-head → U+00A9 or U+00AB

operator-head → U+00AC or U+00AE

operator-head → U+00B0–U+00B1

operator-head → U+00B6, U+00BB, U+00BF, U+00D7, or U+00F7

operator-head → U+2016–U+2017

operator-head → U+2020–U+2027

operator-head → U+2030–U+203E

operator-head → U+2041–U+2053

operator-head → U+2055–U+205E

operator-head → U+2190–U+23FF

operator-head → U+2500–U+2775

operator-head → U+2794–U+2BFF

operator-head → U+2E00–U+2E7F

operator-head → U+3001–U+3003

operator-head → U+3008–U+3020

operator-head → U+3030

operator-character → operator-head

operator-character → U+0300–U+036F

operator-character → U+1DC0–U+1DFF

operator-character → U+20D0–U+20FF

operator-character → U+FE00–U+FE0F

operator-character → U+FE20–U+FE2F

operator-character → U+E0100–U+E01EF

operator-characters → operator-character operator-characters opt

dot-operator-head → `.`

dot-operator-character → `.` | operator-character

dot-operator-characters → dot-operator-character dot-operator-characters opt

infix-operator → operator

prefix-operator → operator

postfix-operator → operator

## Types

Grammar of a type

type → function-type

type → array-type

type → dictionary-type

type → type-identifier

type → tuple-type

type → optional-type

type → implicitly-unwrapped-optional-type

type → protocol-composition-type

type → opaque-type

type → metatype-type

type → any-type

type → self-type

type → `(` type `)`

Grammar of a type annotation

type-annotation → `:` attributes opt `inout`opt type

Grammar of a type identifier

type-identifier → type-name generic-argument-clause opt | type-name generic-argument-clause opt `.` type-identifier

type-name → identifier

Grammar of a tuple type

tuple-type → `(` `)` | `(` tuple-type-element `,` tuple-type-element-list `)`

tuple-type-element-list → tuple-type-element | tuple-type-element `,` tuple-type-element-list

tuple-type-element → element-name type-annotation | type

element-name → identifier

Grammar of a function type

function-type → attributes opt function-type-argument-clause `async`opt `throws`opt `->` type

function-type-argument-clause → `(` `)`

function-type-argument-clause → `(` function-type-argument-list `...`opt `)`

function-type-argument-list → function-type-argument | function-type-argument `,` function-type-argument-list

function-type-argument → attributes opt `inout`opt type | argument-label type-annotation

argument-label → identifier

Grammar of an array type

array-type → `[` type `]`

Grammar of a dictionary type

dictionary-type → `[` type `:` type `]`

Grammar of an optional type

optional-type → type `?`

Grammar of an implicitly unwrapped optional type

implicitly-unwrapped-optional-type → type `!`

Grammar of a protocol composition type

protocol-composition-type → type-identifier `&` protocol-composition-continuation

protocol-composition-continuation → type-identifier | protocol-composition-type

Grammar of an opaque type

opaque-type → `some` type

Grammar of a metatype type

metatype-type → type `.` `Type` | type `.` `Protocol`

Grammar of an Any type

any-type → `Any`

Grammar of a Self type

self-type → `Self`

Grammar of a type inheritance clause

type-inheritance-clause → `:` type-inheritance-list

type-inheritance-list → attributes opt type-identifier | attributes opt type-identifier `,` type-inheritance-list

## Expressions

Grammar of an expression

expression → try-operator opt await-operator opt prefix-expression infix-expressions opt

expression-list → expression | expression `,` expression-list

Grammar of a prefix expression

prefix-expression → prefix-operator opt postfix-expression

prefix-expression → in-out-expression

Grammar of an in-out expression

in-out-expression → `&` identifier

Grammar of a try expression

try-operator → `try` | `try` `?` | `try` `!`

Grammar of an await expression

await-operator → `await`

Grammar of an infix expression

infix-expression → infix-operator prefix-expression

infix-expression → assignment-operator try-operator opt prefix-expression

infix-expression → conditional-operator try-operator opt prefix-expression

infix-expression → type-casting-operator

infix-expressions → infix-expression infix-expressions opt

Grammar of an assignment operator

assignment-operator → `=`

Grammar of a conditional operator

conditional-operator → `?` expression `:`

Grammar of a type-casting operator

type-casting-operator → `is` type

type-casting-operator → `as` type

type-casting-operator → `as` `?` type

type-casting-operator → `as` `!` type

Grammar of a primary expression

primary-expression → identifier generic-argument-clause opt

primary-expression → literal-expression

primary-expression → self-expression

primary-expression → superclass-expression

primary-expression → closure-expression

primary-expression → parenthesized-expression

primary-expression → tuple-expression

primary-expression → implicit-member-expression

primary-expression → wildcard-expression

primary-expression → key-path-expression

primary-expression → selector-expression

primary-expression → key-path-string-expression

Grammar of a literal expression

literal-expression → literal

literal-expression → array-literal | dictionary-literal | playground-literal

literal-expression → `#file` | `#fileID` | `#filePath`

literal-expression → `#line` | `#column` | `#function` | `#dsohandle`

array-literal → `[` array-literal-items opt `]`

array-literal-items → array-literal-item `,`opt | array-literal-item `,` array-literal-items

array-literal-item → expression

dictionary-literal → `[` dictionary-literal-items `]` | `[` `:` `]`

dictionary-literal-items → dictionary-literal-item `,`opt | dictionary-literal-item `,` dictionary-literal-items

dictionary-literal-item → expression `:` expression

playground-literal → `#colorLiteral` `(` `red` `:` expression `,` `green` `:` expression `,` `blue` `:` expression `,` `alpha` `:` expression `)`

playground-literal → `#fileLiteral` `(` `resourceName` `:` expression `)`

playground-literal → `#imageLiteral` `(` `resourceName` `:` expression `)`

Grammar of a self expression

self-expression → `self` | self-method-expression | self-subscript-expression | self-initializer-expression

self-method-expression → `self` `.` identifier

self-subscript-expression → `self` `[` function-call-argument-list `]`

self-initializer-expression → `self` `.` `init`

Grammar of a superclass expression

superclass-expression → superclass-method-expression | superclass-subscript-expression | superclass-initializer-expression

superclass-method-expression → `super` `.` identifier

superclass-subscript-expression → `super` `[` function-call-argument-list `]`

superclass-initializer-expression → `super` `.` `init`

Grammar of a closure expression

closure-expression → `{` attributes opt closure-signature opt statements opt `}`

closure-signature → capture-list opt closure-parameter-clause `async`opt `throws`opt function-result opt `in`

closure-signature → capture-list `in`

closure-parameter-clause → `(` `)` | `(` closure-parameter-list `)` | identifier-list

closure-parameter-list → closure-parameter | closure-parameter `,` closure-parameter-list

closure-parameter → closure-parameter-name type-annotation opt

closure-parameter → closure-parameter-name type-annotation `...`

closure-parameter-name → identifier

capture-list → `[` capture-list-items `]`

capture-list-items → capture-list-item | capture-list-item `,` capture-list-items

capture-list-item → capture-specifier opt identifier

capture-list-item → capture-specifier opt identifier `=` expression

capture-list-item → capture-specifier opt self-expression

capture-specifier → `weak` | `unowned` | `unowned(safe)` | `unowned(unsafe)`

Grammar of a implicit member expression

implicit-member-expression → `.` identifier

implicit-member-expression → `.` identifier `.` postfix-expression

Grammar of a parenthesized expression

parenthesized-expression → `(` expression `)`

Grammar of a tuple expression

tuple-expression → `(` `)` | `(` tuple-element `,` tuple-element-list `)`

tuple-element-list → tuple-element | tuple-element `,` tuple-element-list

tuple-element → expression | identifier `:` expression

Grammar of a wildcard expression

wildcard-expression → `_`

Grammar of a key-path expression

key-path-expression → `\` type opt `.` key-path-components

key-path-components → key-path-component | key-path-component `.` key-path-components

key-path-component → identifier key-path-postfixes opt | key-path-postfixes

key-path-postfixes → key-path-postfix key-path-postfixes opt

key-path-postfix → `?` | `!` | `self` | `[` function-call-argument-list `]`

Grammar of a selector expression

selector-expression → `#selector` `(` expression `)`

selector-expression → `#selector` `(` `getter:` expression `)`

selector-expression → `#selector` `(` `setter:` expression `)`

Grammar of a key-path string expression

key-path-string-expression → `#keyPath` `(` expression `)`

Grammar of a postfix expression

postfix-expression → primary-expression

postfix-expression → postfix-expression postfix-operator

postfix-expression → function-call-expression

postfix-expression → initializer-expression

postfix-expression → explicit-member-expression

postfix-expression → postfix-self-expression

postfix-expression → subscript-expression

postfix-expression → forced-value-expression

postfix-expression → optional-chaining-expression

Grammar of a function call expression

function-call-expression → postfix-expression function-call-argument-clause

function-call-expression → postfix-expression function-call-argument-clause opt trailing-closures

function-call-argument-clause → `(` `)` | `(` function-call-argument-list `)`

function-call-argument-list → function-call-argument | function-call-argument `,` function-call-argument-list

function-call-argument → expression | identifier `:` expression

function-call-argument → operator | identifier `:` operator

trailing-closures → closure-expression labeled-trailing-closures opt

labeled-trailing-closures → labeled-trailing-closure labeled-trailing-closures opt

labeled-trailing-closure → identifier `:` closure-expression

Grammar of an initializer expression

initializer-expression → postfix-expression `.` `init`

initializer-expression → postfix-expression `.` `init` `(` argument-names `)`

Grammar of an explicit member expression

explicit-member-expression → postfix-expression `.` decimal-digits

explicit-member-expression → postfix-expression `.` identifier generic-argument-clause opt

explicit-member-expression → postfix-expression `.` identifier `(` argument-names `)`

explicit-member-expression → postfix-expression conditional-compilation-block

argument-names → argument-name argument-names opt

argument-name → identifier `:`

Grammar of a postfix self expression

postfix-self-expression → postfix-expression `.` `self`

Grammar of a subscript expression

subscript-expression → postfix-expression `[` function-call-argument-list `]`

Grammar of a forced-value expression

forced-value-expression → postfix-expression `!`

Grammar of an optional-chaining expression

optional-chaining-expression → postfix-expression `?`

## Statements

Grammar of a statement

statement → expression `;`opt

statement → declaration `;`opt

statement → loop-statement `;`opt

statement → branch-statement `;`opt

statement → labeled-statement `;`opt

statement → control-transfer-statement `;`opt

statement → defer-statement `;`opt

statement → do-statement `;`opt

statement → compiler-control-statement

statements → statement statements opt

Grammar of a loop statement

loop-statement → for-in-statement

loop-statement → while-statement

loop-statement → repeat-while-statement

Grammar of a for-in statement

for-in-statement → `for` `case`opt pattern `in` expression where-clause opt code-block

Grammar of a while statement

while-statement → `while` condition-list code-block

condition-list → condition | condition `,` condition-list

condition → expression | availability-condition | case-condition | optional-binding-condition

case-condition → `case` pattern initializer

optional-binding-condition → `let` pattern initializer opt | `var` pattern initializer opt

Grammar of a repeat-while statement

repeat-while-statement → `repeat` code-block `while` expression

Grammar of a branch statement

branch-statement → if-statement

branch-statement → guard-statement

branch-statement → switch-statement

Grammar of an if statement

if-statement → `if` condition-list code-block else-clause opt

else-clause → `else` code-block | `else` if-statement

Grammar of a guard statement

guard-statement → `guard` condition-list `else` code-block

Grammar of a switch statement

switch-statement → `switch` expression `{` switch-cases opt `}`

switch-cases → switch-case switch-cases opt

switch-case → case-label statements

switch-case → default-label statements

switch-case → conditional-switch-case

case-label → attributes opt `case` case-item-list `:`

case-item-list → pattern where-clause opt | pattern where-clause opt `,` case-item-list

default-label → attributes opt `default` `:`

where-clause → `where` where-expression

where-expression → expression

conditional-switch-case → switch-if-directive-clause switch-elseif-directive-clauses opt switch-else-directive-clause opt endif-directive

switch-if-directive-clause → if-directive compilation-condition switch-cases opt

switch-elseif-directive-clauses → elseif-directive-clause switch-elseif-directive-clauses opt

switch-elseif-directive-clause → elseif-directive compilation-condition switch-cases opt

switch-else-directive-clause → else-directive switch-cases opt

Grammar of a labeled statement

labeled-statement → statement-label loop-statement

labeled-statement → statement-label if-statement

labeled-statement → statement-label switch-statement

labeled-statement → statement-label do-statement

statement-label → label-name `:`

label-name → identifier

Grammar of a control transfer statement

control-transfer-statement → break-statement

control-transfer-statement → continue-statement

control-transfer-statement → fallthrough-statement

control-transfer-statement → return-statement

control-transfer-statement → throw-statement

Grammar of a break statement

break-statement → `break` label-name opt

Grammar of a continue statement

continue-statement → `continue` label-name opt

Grammar of a fallthrough statement

fallthrough-statement → `fallthrough`

Grammar of a return statement

return-statement → `return` expression opt

Grammar of a throw statement

throw-statement → `throw` expression

Grammar of a defer statement

defer-statement → `defer` code-block

Grammar of a do statement

do-statement → `do` code-block catch-clauses opt

catch-clauses → catch-clause catch-clauses opt

catch-clause → `catch` catch-pattern-list opt code-block

catch-pattern-list → catch-pattern | catch-pattern `,` catch-pattern-list

catch-pattern → pattern where-clause opt

Grammar of a compiler control statement

compiler-control-statement → conditional-compilation-block

compiler-control-statement → line-control-statement

compiler-control-statement → diagnostic-statement

Grammar of a conditional compilation block

conditional-compilation-block → if-directive-clause elseif-directive-clauses opt else-directive-clause opt endif-directive

if-directive-clause → if-directive compilation-condition statements opt

elseif-directive-clauses → elseif-directive-clause elseif-directive-clauses opt

elseif-directive-clause → elseif-directive compilation-condition statements opt

else-directive-clause → else-directive statements opt

if-directive → `#if`

elseif-directive → `#elseif`

else-directive → `#else`

endif-directive → `#endif`

compilation-condition → platform-condition

compilation-condition → identifier

compilation-condition → boolean-literal

compilation-condition → `(` compilation-condition `)`

compilation-condition → `!` compilation-condition

compilation-condition → compilation-condition `&&` compilation-condition

compilation-condition → compilation-condition `||` compilation-condition

platform-condition → `os` `(` operating-system `)`

platform-condition → `arch` `(` architecture `)`

platform-condition → `swift` `(` `>=` swift-version `)` | `swift` `(` `<` swift-version `)`

platform-condition → `compiler` `(` `>=` swift-version `)` | `compiler` `(` `<` swift-version `)`

platform-condition → `canImport` `(` import-path `)`

platform-condition → `targetEnvironment` `(` environment `)`

operating-system → `macOS` | `iOS` | `watchOS` | `tvOS` | `Linux` | `Windows`

architecture → `i386` | `x86_64` | `arm` | `arm64`

swift-version → decimal-digits swift-version-continuation opt

swift-version-continuation → `.` decimal-digits swift-version-continuation opt

environment → `simulator` | `macCatalyst`

Grammar of a line control statement

line-control-statement → `#sourceLocation` `(` `file:` file-path `,` `line:` line-number `)`

line-control-statement → `#sourceLocation` `(` `)`

line-number → A decimal integer greater than zero

file-path → static-string-literal

Grammar of a compile-time diagnostic statement

diagnostic-statement → `#error` `(` diagnostic-message `)`

diagnostic-statement → `#warning` `(` diagnostic-message `)`

diagnostic-message → static-string-literal

Grammar of an availability condition

availability-condition → `#available` `(` availability-arguments `)`

availability-condition → `#unavailable` `(` availability-arguments `)`

availability-arguments → availability-argument | availability-argument `,` availability-arguments

availability-argument → platform-name platform-version

availability-argument → `*`

platform-name → `iOS` | `iOSApplicationExtension`

platform-name → `macOS` | `macOSApplicationExtension`

platform-name → `macCatalyst` | `macCatalystApplicationExtension`

platform-name → `watchOS` | `watchOSApplicationExtension`

platform-name → `tvOS` | `tvOSApplicationExtension`

platform-version → decimal-digits

platform-version → decimal-digits `.` decimal-digits

platform-version → decimal-digits `.` decimal-digits `.` decimal-digits

## Declarations

Grammar of a declaration

declaration → import-declaration

declaration → constant-declaration

declaration → variable-declaration

declaration → typealias-declaration

declaration → function-declaration

declaration → enum-declaration

declaration → struct-declaration

declaration → class-declaration

declaration → actor-declaration

declaration → protocol-declaration

declaration → initializer-declaration

declaration → deinitializer-declaration

declaration → extension-declaration

declaration → subscript-declaration

declaration → operator-declaration

declaration → precedence-group-declaration

declarations → declaration declarations opt

Grammar of a top-level declaration

top-level-declaration → statements opt

Grammar of a code block

code-block → `{` statements opt `}`

Grammar of an import declaration

import-declaration → attributes opt `import` import-kind opt import-path

import-kind → `typealias` | `struct` | `class` | `enum` | `protocol` | `let` | `var` | `func`

import-path → identifier | identifier `.` import-path

Grammar of a constant declaration

constant-declaration → attributes opt declaration-modifiers opt `let` pattern-initializer-list

pattern-initializer-list → pattern-initializer | pattern-initializer `,` pattern-initializer-list

pattern-initializer → pattern initializer opt

initializer → `=` expression

Grammar of a variable declaration

variable-declaration → variable-declaration-head pattern-initializer-list

variable-declaration → variable-declaration-head variable-name type-annotation code-block

variable-declaration → variable-declaration-head variable-name type-annotation getter-setter-block

variable-declaration → variable-declaration-head variable-name type-annotation getter-setter-keyword-block

variable-declaration → variable-declaration-head variable-name initializer willSet-didSet-block

variable-declaration → variable-declaration-head variable-name type-annotation initializer opt willSet-didSet-block

variable-declaration-head → attributes opt declaration-modifiers opt `var`

variable-name → identifier

getter-setter-block → code-block

getter-setter-block → `{` getter-clause setter-clause opt `}`

getter-setter-block → `{` setter-clause getter-clause `}`

getter-clause → attributes opt mutation-modifier opt `get` code-block

setter-clause → attributes opt mutation-modifier opt `set` setter-name opt code-block

setter-name → `(` identifier `)`

getter-setter-keyword-block → `{` getter-keyword-clause setter-keyword-clause opt `}`

getter-setter-keyword-block → `{` setter-keyword-clause getter-keyword-clause `}`

getter-keyword-clause → attributes opt mutation-modifier opt `get`

setter-keyword-clause → attributes opt mutation-modifier opt `set`

willSet-didSet-block → `{` willSet-clause didSet-clause opt `}`

willSet-didSet-block → `{` didSet-clause willSet-clause opt `}`

willSet-clause → attributes opt `willSet` setter-name opt code-block

didSet-clause → attributes opt `didSet` setter-name opt code-block

Grammar of a type alias declaration

typealias-declaration → attributes opt access-level-modifier opt `typealias` typealias-name generic-parameter-clause opt typealias-assignment

typealias-name → identifier

typealias-assignment → `=` type

Grammar of a function declaration

function-declaration → function-head function-name generic-parameter-clause opt function-signature generic-where-clause opt function-body opt

function-head → attributes opt declaration-modifiers opt `func`

function-name → identifier | operator

function-signature → parameter-clause `async`opt `throws`opt function-result opt

function-signature → parameter-clause `async`opt `rethrows` function-result opt

function-result → `->` attributes opt type

function-body → code-block

parameter-clause → `(` `)` | `(` parameter-list `)`

parameter-list → parameter | parameter `,` parameter-list

parameter → external-parameter-name opt local-parameter-name type-annotation default-argument-clause opt

parameter → external-parameter-name opt local-parameter-name type-annotation

parameter → external-parameter-name opt local-parameter-name type-annotation `...`

external-parameter-name → identifier

local-parameter-name → identifier

default-argument-clause → `=` expression

Grammar of an enumeration declaration

enum-declaration → attributes opt access-level-modifier opt union-style-enum

enum-declaration → attributes opt access-level-modifier opt raw-value-style-enum

union-style-enum → `indirect`opt `enum` enum-name generic-parameter-clause opt type-inheritance-clause opt generic-where-clause opt `{` union-style-enum-members opt `}`

union-style-enum-members → union-style-enum-member union-style-enum-members opt

union-style-enum-member → declaration | union-style-enum-case-clause | compiler-control-statement

union-style-enum-case-clause → attributes opt `indirect`opt `case` union-style-enum-case-list

union-style-enum-case-list → union-style-enum-case | union-style-enum-case `,` union-style-enum-case-list

union-style-enum-case → enum-case-name tuple-type opt

enum-name → identifier

enum-case-name → identifier

raw-value-style-enum → `enum` enum-name generic-parameter-clause opt type-inheritance-clause generic-where-clause opt `{` raw-value-style-enum-members `}`

raw-value-style-enum-members → raw-value-style-enum-member raw-value-style-enum-members opt

raw-value-style-enum-member → declaration | raw-value-style-enum-case-clause | compiler-control-statement

raw-value-style-enum-case-clause → attributes opt `case` raw-value-style-enum-case-list

raw-value-style-enum-case-list → raw-value-style-enum-case | raw-value-style-enum-case `,` raw-value-style-enum-case-list

raw-value-style-enum-case → enum-case-name raw-value-assignment opt

raw-value-assignment → `=` raw-value-literal

raw-value-literal → numeric-literal | static-string-literal | boolean-literal

Grammar of a structure declaration

struct-declaration → attributes opt access-level-modifier opt `struct` struct-name generic-parameter-clause opt type-inheritance-clause opt generic-where-clause opt struct-body

struct-name → identifier

struct-body → `{` struct-members opt `}`

struct-members → struct-member struct-members opt

struct-member → declaration | compiler-control-statement

Grammar of a class declaration

class-declaration → attributes opt access-level-modifier opt `final`opt `class` class-name generic-parameter-clause opt type-inheritance-clause opt generic-where-clause opt class-body

class-declaration → attributes opt `final` access-level-modifier opt `class` class-name generic-parameter-clause opt type-inheritance-clause opt generic-where-clause opt class-body

class-name → identifier

class-body → `{` class-members opt `}`

class-members → class-member class-members opt

class-member → declaration | compiler-control-statement

Grammar of an actor declaration

actor-declaration → attributes opt access-level-modifier opt `actor` actor-name generic-parameter-clause opt type-inheritance-clause opt generic-where-clause opt actor-body

actor-name → identifier

actor-body → `{` actor-members opt `}`

actor-members → actor-member actor-members opt

actor-member → declaration | compiler-control-statement

Grammar of a protocol declaration

protocol-declaration → attributes opt access-level-modifier opt `protocol` protocol-name type-inheritance-clause opt generic-where-clause opt protocol-body

protocol-name → identifier

protocol-body → `{` protocol-members opt `}`

protocol-members → protocol-member protocol-members opt

protocol-member → protocol-member-declaration | compiler-control-statement

protocol-member-declaration → protocol-property-declaration

protocol-member-declaration → protocol-method-declaration

protocol-member-declaration → protocol-initializer-declaration

protocol-member-declaration → protocol-subscript-declaration

protocol-member-declaration → protocol-associated-type-declaration

protocol-member-declaration → typealias-declaration

Grammar of a protocol property declaration

protocol-property-declaration → variable-declaration-head variable-name type-annotation getter-setter-keyword-block

Grammar of a protocol method declaration

protocol-method-declaration → function-head function-name generic-parameter-clause opt function-signature generic-where-clause opt

Grammar of a protocol initializer declaration

protocol-initializer-declaration → initializer-head generic-parameter-clause opt parameter-clause `throws`opt generic-where-clause opt

protocol-initializer-declaration → initializer-head generic-parameter-clause opt parameter-clause `rethrows` generic-where-clause opt

Grammar of a protocol subscript declaration

protocol-subscript-declaration → subscript-head subscript-result generic-where-clause opt getter-setter-keyword-block

Grammar of a protocol associated type declaration

protocol-associated-type-declaration → attributes opt access-level-modifier opt `associatedtype` typealias-name type-inheritance-clause opt typealias-assignment opt generic-where-clause opt

Grammar of an initializer declaration

initializer-declaration → initializer-head generic-parameter-clause opt parameter-clause `async`opt `throws`opt generic-where-clause opt initializer-body

initializer-declaration → initializer-head generic-parameter-clause opt parameter-clause `async`opt `rethrows` generic-where-clause opt initializer-body

initializer-head → attributes opt declaration-modifiers opt `init`

initializer-head → attributes opt declaration-modifiers opt `init` `?`

initializer-head → attributes opt declaration-modifiers opt `init` `!`

initializer-body → code-block

Grammar of a deinitializer declaration

deinitializer-declaration → attributes opt `deinit` code-block

Grammar of an extension declaration

extension-declaration → attributes opt access-level-modifier opt `extension` type-identifier type-inheritance-clause opt generic-where-clause opt extension-body

extension-body → `{` extension-members opt `}`

extension-members → extension-member extension-members opt

extension-member → declaration | compiler-control-statement

Grammar of a subscript declaration

subscript-declaration → subscript-head subscript-result generic-where-clause opt code-block

subscript-declaration → subscript-head subscript-result generic-where-clause opt getter-setter-block

subscript-declaration → subscript-head subscript-result generic-where-clause opt getter-setter-keyword-block

subscript-head → attributes opt declaration-modifiers opt `subscript` generic-parameter-clause opt parameter-clause

subscript-result → `->` attributes opt type

Grammar of an operator declaration

operator-declaration → prefix-operator-declaration | postfix-operator-declaration | infix-operator-declaration

prefix-operator-declaration → `prefix` `operator` operator

postfix-operator-declaration → `postfix` `operator` operator

infix-operator-declaration → `infix` `operator` operator infix-operator-group opt

infix-operator-group → `:` precedence-group-name

Grammar of a precedence group declaration

precedence-group-declaration → `precedencegroup` precedence-group-name `{` precedence-group-attributes opt `}`

precedence-group-attributes → precedence-group-attribute precedence-group-attributes opt

precedence-group-attribute → precedence-group-relation

precedence-group-attribute → precedence-group-assignment

precedence-group-attribute → precedence-group-associativity

precedence-group-relation → `higherThan` `:` precedence-group-names

precedence-group-relation → `lowerThan` `:` precedence-group-names

precedence-group-assignment → `assignment` `:` boolean-literal

precedence-group-associativity → `associativity` `:` `left`

precedence-group-associativity → `associativity` `:` `right`

precedence-group-associativity → `associativity` `:` `none`

precedence-group-names → precedence-group-name | precedence-group-name `,` precedence-group-names

precedence-group-name → identifier

Grammar of a declaration modifier

declaration-modifier → `class` | `convenience` | `dynamic` | `final` | `infix` | `lazy` | `optional` | `override` | `postfix` | `prefix` | `required` | `static` | `unowned` | `unowned` `(` `safe` `)` | `unowned` `(` `unsafe` `)` | `weak`

declaration-modifier → access-level-modifier

declaration-modifier → mutation-modifier

declaration-modifier → actor-isolation-modifier

declaration-modifiers → declaration-modifier declaration-modifiers opt

access-level-modifier → `private` | `private` `(` `set` `)`

access-level-modifier → `fileprivate` | `fileprivate` `(` `set` `)`

access-level-modifier → `internal` | `internal` `(` `set` `)`

access-level-modifier → `public` | `public` `(` `set` `)`

access-level-modifier → `open` | `open` `(` `set` `)`

mutation-modifier → `mutating` | `nonmutating`

actor-isolation-modifier → `nonisolated`

## Attributes

Grammar of an attribute

attribute → `@` attribute-name attribute-argument-clause opt

attribute-name → identifier

attribute-argument-clause → `(` balanced-tokens opt `)`

attributes → attribute attributes opt

balanced-tokens → balanced-token balanced-tokens opt

balanced-token → `(` balanced-tokens opt `)`

balanced-token → `[` balanced-tokens opt `]`

balanced-token → `{` balanced-tokens opt `}`

balanced-token → Any identifier, keyword, literal, or operator

balanced-token → Any punctuation except `(`, `)`, `[`, `]`, `{`, or `}`

## Patterns

Grammar of a pattern

pattern → wildcard-pattern type-annotation opt

pattern → identifier-pattern type-annotation opt

pattern → value-binding-pattern

pattern → tuple-pattern type-annotation opt

pattern → enum-case-pattern

pattern → optional-pattern

pattern → type-casting-pattern

pattern → expression-pattern

Grammar of a wildcard pattern

wildcard-pattern → `_`

Grammar of an identifier pattern

identifier-pattern → identifier

Grammar of a value-binding pattern

value-binding-pattern → `var` pattern | `let` pattern

Grammar of a tuple pattern

tuple-pattern → `(` tuple-pattern-element-list opt `)`

tuple-pattern-element-list → tuple-pattern-element | tuple-pattern-element `,` tuple-pattern-element-list

tuple-pattern-element → pattern | identifier `:` pattern

Grammar of an enumeration case pattern

enum-case-pattern → type-identifier opt `.` enum-case-name tuple-pattern opt

Grammar of an optional pattern

optional-pattern → identifier-pattern `?`

Grammar of a type casting pattern

type-casting-pattern → is-pattern | as-pattern

is-pattern → `is` type

as-pattern → pattern `as` type

Grammar of an expression pattern

expression-pattern → expression

## Generic Parameters and Arguments

Grammar of a generic parameter clause

generic-parameter-clause → `<` generic-parameter-list `>`

generic-parameter-list → generic-parameter | generic-parameter `,` generic-parameter-list

generic-parameter → type-name

generic-parameter → type-name `:` type-identifier

generic-parameter → type-name `:` protocol-composition-type

generic-where-clause → `where` requirement-list

requirement-list → requirement | requirement `,` requirement-list

requirement → conformance-requirement | same-type-requirement

conformance-requirement → type-identifier `:` type-identifier

conformance-requirement → type-identifier `:` protocol-composition-type

same-type-requirement → type-identifier `==` type

Grammar of a generic argument clause

generic-argument-clause → `<` generic-argument-list `>`

generic-argument-list → generic-argument | generic-argument `,` generic-argument-list

generic-argument → type