Module swift

An add expression. a + b a &+ b

A bitwise AND expression. a & b

An arithmetic operation, such as: a + b

A binary arithmetic operation, such as: a + b

A binary bitwise operation, such as: a & b a << b a .^ b

A bitwise operation, such as: a & b a << b ~a

The Bool type.

The Character type.

A class or struct declaration. For example MyStruct or MyClass in the following example:

A compiler error message.

A compiler-generated note (typically attached to an error or warning).

A compiler-generated remark (milder than a warning, this does not indicate an issue).

A compiler-generated warning.

A divide expression. a / b

An expression that references a case of an enum. For example both enumElement in: let value = MyEnum.enumElement ... switch (anotherValue) { case .enumElement: ...

A field declaration. That is, a variable declaration that is a member of a class, struct, enum or protocol.

A floating-point type. This includes the Float type, the Double, and builtin floating-point types.

A free (non-member) function.

An integer-like type. For example, Int, Int16, Uint16, etc.

A multiply expression. a * b a &* b

A Swift nil-coalesing expr (??).

A bitwise NOT expression. ~a

A numeric type. This includes the integer and floating point types.

A bitwise OR expression. a | b

A pointwise bitwise-and expression: a .& b

A pointwise bitwise-or expression: a .| b

A pointwise bitwise exclusive-or expression: a .^ b

A remainder expression. a % b

A reference to self.

A bitwise shift left expression. a << b a &<<

A bitwise shift right expression. a >> b a &>>

A subtract expression. a - b a &- b

A unary arithmetic operation, such as: -a

A unary bitwise operation, such as: ~a

A unary minus expression. -a

A unary plus expression. +a

The trivial type with a single element.

A bitwise XOR expression. a ^ b

INTERNAL: Do not use.

A conversion that erases the actor isolation of an expression with @isolated(any) function type.

An implicit application of a property wrapper on the argument of a call.

An addition assignment expression: a += b a &+= b

A bitwise-and assignment expression: a &= b

An arithmetic assignment expression. For example: x += 1 y *= z

A bitwise assignment expression. For example: x &= y z <<= 1

A division assignment expression: a /= b

A simple assignment expression using the = operator: x = 0

A left-shift assignment expression: a <<= b a &<<= b

A multiplication assignment expression: a *= b a &*= b

An assignment expression apart from =. For example: x += 1 y &= z

A bitwise-or assignment expression: a |= b

A pointwise bitwise-and assignment expression: a .&= b

A pointwise assignment expression. For example: x .&= y

A pointwise bitwise-or assignment expression: a .|= b

A pointwise bitwise exclusive-or assignment expression: a .^= b

A right-shift assignment expression: a >>= b a &>>= b

A remainder assignment expression: a %= b

A subtraction assignment expression: a -= b a &-= b

A bitwise exclusive-or assignment expression: a ^= b

An assignment expression. For example: x = 0 y += 1 z <<= 1

A node in the abstract syntax tree.

A Swift autoclosure expression, that is, a closure automatically generated around an argument when the parameter has the @autoclosure attribute or for the right-hand operand of short-circuiting logical operations. For example, there is an AutoClosureExpr around the value 0 in:

An availability condition of an if, while, or guard statements.

An availability spec, that is, part of an AvailabilityInfo condition. For example iOS 12 and * in: if #available(iOS 12, *)

A Swift binary expression, that is, an expression that appears between its two operands. For example: x + y

A boolean literal. For example true in: let x = true

An expression that marks value as borrowed. In the example below, _borrow marks the borrow expression:

A builtin type representing N values stored contiguously.

A Swift literal of a kind that is built in to the Swift language.

A captured variable or function parameter in the scope of a closure.

An expression that forces value to be moved. In the example below, consume marks the move expression:

An expression that forces value to be copied. In the example below, copy marks the copy expression:

An expression that extracts the actor isolation of the current context, of type (any Actor)?. This is synthesized by the type checker and does not have any way to be expressed explicitly in the source.

An expression that references or accesses a declaration.

A deinitializer of a class.

A compiler-generated error, warning, note or remark.

A statement that takes a non-copyable value and destructs its members/fields.

An expression representing a partially applied lookup of an instance property via the receiver’s type object.

An archetype type of PackElementType.

An enumeration declaration, for example: enum MyColors { case red case green case blue }

An enum element declaration, for example enumElement and anotherEnumElement in: enum MyEnum { case enumElement case anotherEnumElement(Int) }

The superclass of all elements indicating some kind of error.

A Swift explicit closure expr, that is, a closure written using { ... -> ... in ... } syntax rather than automatically generated by the compiler.

The base class for all expressions in Swift.

An expression that extracts the function isolation of an expression with @isolated(any) function type.

A function.

The type of a generic function with type parameters

An initializer of a class, struct, enum or protocol.

An integer literal. For example 1 in: let x = 1

A component of a KeyPathExpr.

A key-path expression.

A Swift literal.

A location of a program element.

A declaration of a macro. Some examples:

The role of a macro, for example #freestanding(declaration) or @attached(member).

An identifier literal that is expanded at compile time. For example #file in: let x = #file

An expression that materializes a pack during expansion. Appears around PackExpansionExpr.

A function that is a member of a class, struct, enum or protocol.

A placeholder for missing declarations that can arise on object deserialization.

A pattern that corresponds to a fresh variable binding.

A class, struct, enum or protocol.

A class, struct, enum or protocol.

An instance of #fileLiteral, #imageLiteral or #colorLiteral expressions, which are used in playgrounds.

An opaque type, that is a type formally equivalent to an underlying type but abstracting it away.

A declaration of an opaque type, that is formally equivalent to a given type but abstracts it away.

An implicit expression created by the compiler when a method is called on a protocol. For example in protocol P { func foo() -> Int } func bar(x: P) -> Int { return x.foo() } `x.foo()` is actually wrapped in an `OpenExistentialExpr` that "opens" `x` replacing it in its subexpression with an `OpaqueValueExpr`.

A wildcard availability spec *

An ambiguous expression that might refer to multiple declarations. This will be present only for failing compilations.

An archetype type of PackType.

A pack element expression is a child of PackExpansionExpr.

A type of PackElementExpr, see PackElementExpr for more information.

A pack expansion expression.

A type of PackExpansionExpr, see PackExpansionExpr for more information.

An actual type of a pack expression at the instatiation point.

A sugar type of the form P<X> with P a protocol.

A syntactic construct that can be matched against an expression, occurring in switch cases, conditions, and variable bindings.

An availability spec based on platform and version, for example macOS 12 or watchOS 14

A Swift postfix unary expression, that is, a unary expression that appears after its operand. For example: x!

A diagnostic directive, which is either #error or #warning.

A Swift prefix unary expression, that is, a unary expression that appears before its operand. For example: -x

A placeholder substituting property initializations with = when the property has a property wrapper with an initializer.

A regular expression literal which is checked at compile time, for example /a(a|b)*b/.

A self parameter.

An expression that wraps a statement which produces a single value.

A string literal. For example "abc" in: let x = "abc"

A reference to super.

A TapExpr is an internal expression generated by the Swift compiler.

A statement implicitly wrapping values to be used in branches of if/switch expressions. For example in: let rank = switch value { case 0..<0x80: 1 case 0x80..<0x0800: 2 default: 3 } the literal expressions 1, 2 and 3 are wrapped in ThenStmt.

A tuple type, for example: (Int, String)

A Swift type.

A declaration of a type alias to another type. For example: typealias MyInt = Int

A type alias to another type. For example: typealias MyInt = Int

A Swift type declaration, for example a class, struct, enum or protocol declaration.

A Location that is given to something that is not associated with any position in the source code.

A conversion from the uninhabited type to any other type. It’s never evaluated.

A conversion that performs an unsafe bitcast.

A declaration that introduces a value with a type.

A declaration of a variable such as * a local variable in a function: func foo() { var x = 42 // <- let y = "hello" // <- ... } * a member of a struct or class: struct S { var size : Int // <- } * …

A variadic sequence type, that is, an array-like type that holds variadic arguments. For example the type Int... of args in: func myVarargsFunction(args: Int...) { ... }