"""

Schema description

This file should be kept simple:

* no flow control

* no aliases

* only class definitions with annotations and `include` calls

For how documentation of generated QL code works, please read schema_documentation.md.

"""

from misc.codegen.lib.schemadefs import *

include("prefix.dbscheme")

@qltest.skip

class Element:

is_unknown: predicate | cpp.skip

@qltest.collapse_hierarchy

class File(Element):

name: string

is_successfully_extracted: predicate | cpp.skip

@qltest.skip

@qltest.collapse_hierarchy

class Location(Element):

file: File

start_line: int

start_column: int

end_line: int

end_column: int

@qltest.skip

class Locatable(Element):

location: optional[Location] | cpp.skip | doc("location associated with this element in the code")

@qltest.collapse_hierarchy

@qltest.skip

class ErrorElement(Locatable):

"""The superclass of all elements indicating some kind of error."""

pass

@use_for_null

class UnspecifiedElement(ErrorElement):

parent: optional[Element]

property: string

index: optional[int]

error: string

children: list["AstNode"] | child | desc("These will be present only in certain downgraded databases.")

class Comment(Locatable):

text: string

class Diagnostics(Locatable):

text: string

kind: int

class DbFile(File):

pass

class DbLocation(Location):

pass

@synth.on_arguments()

class UnknownFile(File):

pass

@synth.on_arguments()

class UnknownLocation(Location):

pass

class AstNode(Locatable):

pass

@group("type")

@ql.hideable

class Type(Element):

name: string

canonical_type: "Type" | desc("""

This is the unique type we get after resolving aliases and desugaring. For example, given

```

typealias MyInt = Int

```

then `[MyInt?]` has the canonical type `Array<Optional<Int>>`.

""")

@group("decl")

class Decl(AstNode):

module: "ModuleDecl"

members: list["Decl"] | child | desc("""

Prefer to use more specific methods (such as `EnumDecl.getEnumElement`) rather than relying

on the order of members given by `getMember`. In some cases the order of members may not

align with expectations, and could change in future releases.

""")

@group("expr")

@ql.hideable

class Expr(AstNode):

"""The base class for all expressions in Swift."""

type: optional[Type]

@group("pattern")

@ql.hideable

class Pattern(AstNode):

type: optional[Type]

@group("stmt")

class Stmt(AstNode):

pass

@group("decl")

class GenericContext(Element):

generic_type_params: list["GenericTypeParamDecl"] | child

@qltest.test_with("EnumDecl")

class EnumCaseDecl(Decl):

elements: list["EnumElementDecl"]

class ExtensionDecl(GenericContext, Decl):

extended_type_decl: "NominalTypeDecl"

protocols: list["ProtocolDecl"]

class IfConfigDecl(Decl):

active_elements: list[AstNode]

class ImportDecl(Decl):

is_exported: predicate

imported_module: optional["ModuleDecl"]

declarations: list["ValueDecl"]

@qltest.skip

class MissingMemberDecl(Decl):

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

name: string

class OperatorDecl(Decl):

name: string

class PatternBindingDecl(Decl):

inits: list[optional[Expr]] | child

patterns: list[Pattern] | child

class PoundDiagnosticDecl(Decl):

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

kind: int | desc("""This is 1 for `#error` and 2 for `#warning`.""") | ql.internal

message: "StringLiteralExpr" | child

class PrecedenceGroupDecl(Decl):

pass

class TopLevelCodeDecl(Decl):

body: "BraceStmt" | child

class ValueDecl(Decl):

interface_type: Type

class AbstractStorageDecl(ValueDecl):

accessors: list["Accessor"] | child

class VarDecl(AbstractStorageDecl):

"""

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 // <-

}

```

* ...

"""

name: string

type: Type

attached_property_wrapper_type: optional[Type]

parent_pattern: optional[Pattern]

parent_initializer: optional[Expr]

property_wrapper_backing_var_binding: optional[PatternBindingDecl] | child | desc("""

This is the synthesized binding introducing the property wrapper backing variable for this

variable, if any. See `getPropertyWrapperBackingVar`.

""")

property_wrapper_backing_var: optional["VarDecl"] | child | desc("""

This is the compiler synthesized variable holding the property wrapper for this variable, if any.

For a property wrapper like

```

@propertyWrapper struct MyWrapper { ... }

struct S {

@MyWrapper var x : Int = 42

}

```

the compiler synthesizes a variable in `S` along the lines of

```

var _x = MyWrapper(wrappedValue: 42)

```

This predicate returns such variable declaration.

""")

property_wrapper_projection_var_binding: optional[PatternBindingDecl] | child | desc("""

This is the synthesized binding introducing the property wrapper projection variable for this

variable, if any. See `getPropertyWrapperProjectionVar`.

""")

property_wrapper_projection_var: optional["VarDecl"] | child | desc("""

If this variable has a property wrapper with a projected value, this is the corresponding

synthesized variable holding that projected value, accessible with this variable's name

prefixed with `$`.

For a property wrapper like

```

@propertyWrapper struct MyWrapper {

var projectedValue : Bool

...

}

struct S {

@MyWrapper var x : Int = 42

}

```

```

the compiler synthesizes a variable in `S` along the lines of

```

var $x : Bool { ... }

```

This predicate returns such variable declaration.

""")

class ParamDecl(VarDecl):

is_inout: predicate | doc("this is an `inout` parameter")

property_wrapper_local_wrapped_var_binding: optional[PatternBindingDecl] | child | desc("""

This is the synthesized binding introducing the property wrapper local wrapped projection

variable for this variable, if any.

""")

property_wrapper_local_wrapped_var: optional["VarDecl"] | child | desc("""

This is the synthesized local wrapped value, shadowing this parameter declaration in case it

has a property wrapper.

""")

class Callable(AstNode):

name: optional[string] | doc("name of this callable") | desc("The name includes argument "

"labels of the callable, for example `myFunction(arg:)`.")

self_param: optional[ParamDecl] | child

params: list[ParamDecl] | child

body: optional["BraceStmt"] | child | desc("The body is absent within protocol declarations.")

captures: list["CapturedDecl"] | child

@group("decl")

class Function(GenericContext, ValueDecl, Callable):

pass

@qltest.test_with("EnumDecl")

class EnumElementDecl(ValueDecl):

name: string

params: list[ParamDecl] | child

class InfixOperatorDecl(OperatorDecl):

precedence_group: optional[PrecedenceGroupDecl]

class PostfixOperatorDecl(OperatorDecl):

pass

class PrefixOperatorDecl(OperatorDecl):

pass

class TypeDecl(ValueDecl):

name: string

inherited_types: list[Type] | desc("""

This only returns the types effectively appearing in the declaration. In particular it

will not resolve `TypeAliasDecl`s or consider base types added by extensions.

""")

class AbstractTypeParamDecl(TypeDecl):

pass

@group("decl")

class Initializer(Function):

pass

@group("decl")

class Deinitializer(Function):

pass

@ql.internal

@group("decl")

class AccessorOrNamedFunction(Function):

pass

class GenericTypeDecl(GenericContext, TypeDecl):

pass

class ModuleDecl(TypeDecl):

is_builtin_module: predicate | doc("this module is the built-in one")

is_system_module: predicate | doc("this module is a system one")

imported_modules: set["ModuleDecl"]

exported_modules: set["ModuleDecl"]

class SubscriptDecl(AbstractStorageDecl, GenericContext):

params: list[ParamDecl] | child

element_type: Type

element_type: Type

@group("decl")

class Accessor(AccessorOrNamedFunction):

is_getter: predicate | doc('this accessor is a getter')

is_setter: predicate | doc('this accessor is a setter')

is_will_set: predicate | doc('this accessor is a `willSet`, called before the property is set')

is_did_set: predicate | doc('this accessor is a `didSet`, called after the property is set')

is_read: predicate | doc('this accessor is a `_read` coroutine, yielding a borrowed value of the property')

is_modify: predicate | doc('this accessor is a `_modify` coroutine, yielding an inout value of the property')

is_unsafe_address: predicate | doc('this accessor is an `unsafeAddress` immutable addressor')

is_unsafe_mutable_address: predicate | doc('this accessor is an `unsafeMutableAddress` mutable addressor')

class AssociatedTypeDecl(AbstractTypeParamDecl):

pass

@group("decl")

class NamedFunction(AccessorOrNamedFunction):

pass

class ConcreteVarDecl(VarDecl):

introducer_int: int | doc("introducer enumeration value") | desc("""

This is 0 if the variable was introduced with `let` and 1 if it was introduced with `var`.

""")

class GenericTypeParamDecl(AbstractTypeParamDecl):

pass

class NominalTypeDecl(GenericTypeDecl):

type: Type

class OpaqueTypeDecl(GenericTypeDecl):

"""

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

away.

Such a declaration is implicitly given when a declaration is written with an opaque result type,

for example

```

func opaque() -> some SignedInteger { return 1 }

```

See https://docs.swift.org/swift-book/LanguageGuide/OpaqueTypes.html.

"""

naming_declaration: ValueDecl

opaque_generic_params: list["GenericTypeParamType"]

opaque_generic_params: list["GenericTypeParamType"]

class TypeAliasDecl(GenericTypeDecl):

"""

A declaration of a type alias to another type. For example:

```

typealias MyInt = Int

```

"""

aliased_type: Type | doc("aliased type on the right-hand side of this type alias declaration") | desc("""

For example the aliased type of `MyInt` in the following code is `Int`:

```

typealias MyInt = Int

```

""")

class ClassDecl(NominalTypeDecl):

pass

class EnumDecl(NominalTypeDecl):

pass

class ProtocolDecl(NominalTypeDecl):

pass

class StructDecl(NominalTypeDecl):

pass

@group("expr")

class Argument(Locatable):

label: string

expr: Expr | child

class ClosureExpr(Expr, Callable):

pass

class AnyTryExpr(Expr):

sub_expr: Expr | child

class AppliedPropertyWrapperExpr(Expr):

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

kind: int | desc("This is 1 for a wrapped value and 2 for a projected one.")

value: Expr | child | desc("The value on which the wrapper is applied.")

param: ParamDecl | doc("parameter declaration owning this wrapper application")

class ApplyExpr(Expr):

function: Expr | child | doc("function being applied")

arguments: list[Argument] | child | doc("arguments passed to the applied function")

class AssignExpr(Expr):

dest: Expr | child

source: Expr | child

class BindOptionalExpr(Expr):

sub_expr: Expr | child

class CapturedDecl(Decl):

decl: ValueDecl | doc("the declaration captured by the parent closure")

is_direct: predicate

is_escaping: predicate

class CaptureListExpr(Expr):

binding_decls: list[PatternBindingDecl] | child

variables: list[VarDecl] | child | synth | desc("""

These are the variables introduced by this capture in the closure's scope, not the captured ones.

""")

closure_body: "ClosureExpr" | child

class CollectionExpr(Expr):

pass

class DeclRefExpr(Expr):

decl: Decl

replacement_types: list[Type]

has_direct_to_storage_semantics: predicate

has_direct_to_implementation_semantics: predicate

has_ordinary_semantics: predicate

has_distributed_thunk_semantics: predicate

class DefaultArgumentExpr(Expr):

param_decl: ParamDecl

param_index: int

caller_side_default: optional[Expr]

class DiscardAssignmentExpr(Expr):

pass

class DotSyntaxBaseIgnoredExpr(Expr):

qualifier: Expr | child

sub_expr: Expr | child

class DynamicTypeExpr(Expr):

base: Expr | child

class EnumIsCaseExpr(Expr):

sub_expr: Expr | child

element: EnumElementDecl

@qltest.skip

class ErrorExpr(Expr, ErrorElement):

pass

class ExplicitCastExpr(Expr):

sub_expr: Expr | child

class ForceValueExpr(Expr):

sub_expr: Expr | child

@qltest.collapse_hierarchy

class IdentityExpr(Expr):

sub_expr: Expr | child

class IfExpr(Expr):

condition: Expr | child

then_expr: Expr | child

else_expr: Expr | child

@qltest.collapse_hierarchy

class ImplicitConversionExpr(Expr):

sub_expr: Expr | child

class InOutExpr(Expr):

sub_expr: Expr | child

class KeyPathApplicationExpr(Expr):

base: Expr | child

key_path: Expr | child

class KeyPathDotExpr(Expr):

pass

class KeyPathComponent(AstNode):

"""

A component of a `KeyPathExpr`.

"""

kind: int | doc("kind of key path component") | desc("""

INTERNAL: Do not use.

This is 3 for properties, 4 for array and dictionary subscripts, 5 for optional forcing

(`!`), 6 for optional chaining (`?`), 7 for implicit optional wrapping, 8 for `self`,

and 9 for tuple element indexing.

The following values should not appear: 0 for invalid components, 1 for unresolved

properties, 2 for unresolved subscripts, 10 for #keyPath dictionary keys, and 11 for

implicit IDE code completion data.

""")

subscript_arguments : list[Argument] | child | doc(

"arguments to an array or dictionary subscript expression")

tuple_index : optional[int]

decl_ref : optional[ValueDecl] | doc("property or subscript operator")

component_type : Type | doc("return type of this component application") | desc("""

An optional-chaining component has a non-optional type to feed into the rest of the key

path; an optional-wrapping component is inserted if required to produce an optional type

as the final output.

""")

class KeyPathExpr(Expr):

"""

A key-path expression.

"""

root: optional["TypeRepr"] | child

components: list[KeyPathComponent] | child

class LazyInitializationExpr(Expr):

sub_expr: Expr | child

class LiteralExpr(Expr):

pass

class LookupExpr(Expr):

base: Expr | child

member: optional[Decl]

class MakeTemporarilyEscapableExpr(Expr):

escaping_closure: "OpaqueValueExpr" | child

nonescaping_closure: Expr | child

sub_expr: Expr | child

@qltest.skip

class ObjCSelectorExpr(Expr):

sub_expr: Expr | child

method: Function

class OneWayExpr(Expr):

sub_expr: Expr | child

class OpaqueValueExpr(Expr):

pass

class OpenExistentialExpr(Expr):

""" 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`.

```

"""

sub_expr: Expr | child | desc("""

This wrapped subexpression is where the opaque value and the dynamic type under the protocol type may be used.""")

existential: Expr | child | doc("protocol-typed expression opened by this expression")

opaque_expr: OpaqueValueExpr | doc("opaque value expression embedded within `getSubExpr()`")

class OptionalEvaluationExpr(Expr):

sub_expr: Expr | child

class OtherInitializerRefExpr(Expr):

initializer: Initializer

class PropertyWrapperValuePlaceholderExpr(Expr):

"""

A placeholder substituting property initializations with `=` when the property has a property

wrapper with an initializer.

"""

wrapped_value: optional[Expr]

placeholder: OpaqueValueExpr

class RebindSelfInInitializerExpr(Expr):

sub_expr: Expr | child

self: VarDecl

@qltest.skip

class SequenceExpr(Expr):

elements: list[Expr] | child

class SuperRefExpr(Expr):

self: VarDecl

class TapExpr(Expr):

sub_expr: optional[Expr] | child

body: "BraceStmt" | child

var: VarDecl

class TupleElementExpr(Expr):

sub_expr: Expr | child

index: int

class TupleExpr(Expr):

elements: list[Expr] | child

class TypeExpr(Expr):

type_repr: optional["TypeRepr"] | child

class UnresolvedDeclRefExpr(Expr, ErrorElement):

name: optional[string]

class UnresolvedDotExpr(Expr, ErrorElement):

base: Expr | child

name: string

class UnresolvedMemberExpr(Expr, ErrorElement):

name: string

class UnresolvedPatternExpr(Expr, ErrorElement):

sub_pattern: Pattern | child

class UnresolvedSpecializeExpr(Expr, ErrorElement):

sub_expr: Expr | child

class VarargExpansionExpr(Expr):

sub_expr: Expr | child

class AnyHashableErasureExpr(ImplicitConversionExpr):

pass

class ArchetypeToSuperExpr(ImplicitConversionExpr):

pass

class ArrayExpr(CollectionExpr):

elements: list[Expr] | child

class ArrayToPointerExpr(ImplicitConversionExpr):

pass

class AutoClosureExpr(ClosureExpr):

pass

class AwaitExpr(IdentityExpr):

pass

class BinaryExpr(ApplyExpr):

pass

@qltest.skip

class BridgeFromObjCExpr(ImplicitConversionExpr):

pass

@qltest.skip

class BridgeToObjCExpr(ImplicitConversionExpr):

pass

class BuiltinLiteralExpr(LiteralExpr):

pass

class CallExpr(ApplyExpr):

pass

class CheckedCastExpr(ExplicitCastExpr):

pass

class ClassMetatypeToObjectExpr(ImplicitConversionExpr):

pass

class ExplicitClosureExpr(ClosureExpr):

pass

class CoerceExpr(ExplicitCastExpr):

pass

class CollectionUpcastConversionExpr(ImplicitConversionExpr):

pass

@qltest.skip

class ConditionalBridgeFromObjCExpr(ImplicitConversionExpr):

pass

class CovariantFunctionConversionExpr(ImplicitConversionExpr):

pass

class CovariantReturnConversionExpr(ImplicitConversionExpr):

pass

class DerivedToBaseExpr(ImplicitConversionExpr):

pass

class DestructureTupleExpr(ImplicitConversionExpr):

pass

class DictionaryExpr(CollectionExpr):

elements: list[Expr] | child

class DifferentiableFunctionExpr(ImplicitConversionExpr):

pass

class DifferentiableFunctionExtractOriginalExpr(ImplicitConversionExpr):

pass

class DotSelfExpr(IdentityExpr):

pass

@qltest.collapse_hierarchy

class DynamicLookupExpr(LookupExpr):

pass

class ErasureExpr(ImplicitConversionExpr):

pass

class ExistentialMetatypeToObjectExpr(ImplicitConversionExpr):

pass

class ForceTryExpr(AnyTryExpr):

pass

class ForeignObjectConversionExpr(ImplicitConversionExpr):

pass

class FunctionConversionExpr(ImplicitConversionExpr):

pass

class InOutToPointerExpr(ImplicitConversionExpr):

pass

class InjectIntoOptionalExpr(ImplicitConversionExpr):

pass

class InterpolatedStringLiteralExpr(LiteralExpr):

interpolation_expr: optional[OpaqueValueExpr]

appending_expr: optional[TapExpr] | child

class LinearFunctionExpr(ImplicitConversionExpr):

pass

class LinearFunctionExtractOriginalExpr(ImplicitConversionExpr):

pass

class LinearToDifferentiableFunctionExpr(ImplicitConversionExpr):

pass

class LoadExpr(ImplicitConversionExpr):

pass

class MemberRefExpr(LookupExpr):

has_direct_to_storage_semantics: predicate

has_direct_to_implementation_semantics: predicate

has_ordinary_semantics: predicate

has_distributed_thunk_semantics: predicate

class MetatypeConversionExpr(ImplicitConversionExpr):

pass

class NilLiteralExpr(LiteralExpr):

pass

class ObjectLiteralExpr(LiteralExpr):

"""

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

"""

kind: int | desc("""This is 0 for `#fileLiteral`, 1 for `#imageLiteral` and 2 for `#colorLiteral`.""")

arguments: list[Argument] | child

class OptionalTryExpr(AnyTryExpr):

pass

class OverloadedDeclRefExpr(Expr, ErrorElement):

"""

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

for failing compilations.

"""

possible_declarations: list[ValueDecl]

class ParenExpr(IdentityExpr):

pass

class PointerToPointerExpr(ImplicitConversionExpr):

pass

class PostfixUnaryExpr(ApplyExpr):

pass

class PrefixUnaryExpr(ApplyExpr):

pass

class ProtocolMetatypeToObjectExpr(ImplicitConversionExpr):

pass

@ql.default_doc_name("regular expression")

class RegexLiteralExpr(LiteralExpr):

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

pattern: string

version: int | doc(

"version of the internal regular expression language being used by Swift")

@ql.internal

class SelfApplyExpr(ApplyExpr):

"""

An internal raw instance of method lookups like `x.foo` in `x.foo()`.

This is completely replaced by the synthesized type `MethodLookupExpr`.

"""

base: Expr

class StringToPointerExpr(ImplicitConversionExpr):

pass

class SubscriptExpr(LookupExpr):

arguments: list[Argument] | child

has_direct_to_storage_semantics: predicate

has_direct_to_implementation_semantics: predicate

has_ordinary_semantics: predicate

has_distributed_thunk_semantics: predicate

class TryExpr(AnyTryExpr):

pass

class UnderlyingToOpaqueExpr(ImplicitConversionExpr):

pass

class UnevaluatedInstanceExpr(ImplicitConversionExpr):

pass

class UnresolvedMemberChainResultExpr(IdentityExpr, ErrorElement):

pass

class UnresolvedTypeConversionExpr(ImplicitConversionExpr, ErrorElement):

pass

class BooleanLiteralExpr(BuiltinLiteralExpr):

value: boolean

class ConditionalCheckedCastExpr(CheckedCastExpr):

pass

@ql.internal

class InitializerRefCallExpr(SelfApplyExpr):

pass

@ql.internal

class DotSyntaxCallExpr(SelfApplyExpr):

pass

@synth.from_class(SelfApplyExpr)

class MethodLookupExpr(LookupExpr):

method_ref: Expr | child | doc("the underlying method declaration reference expression")

class DynamicMemberRefExpr(DynamicLookupExpr):

pass

class DynamicSubscriptExpr(DynamicLookupExpr):

pass

class ForcedCheckedCastExpr(CheckedCastExpr):

pass

class IsExpr(CheckedCastExpr):

pass

class MagicIdentifierLiteralExpr(BuiltinLiteralExpr):

kind: string

class NumberLiteralExpr(BuiltinLiteralExpr):

pass

class StringLiteralExpr(BuiltinLiteralExpr):

value: string

class FloatLiteralExpr(NumberLiteralExpr):

string_value: string

class IntegerLiteralExpr(NumberLiteralExpr):

string_value: string

class AnyPattern(Pattern):

pass

class BindingPattern(Pattern):

sub_pattern: Pattern | child

class BoolPattern(Pattern):

value: boolean

class EnumElementPattern(Pattern):

element: EnumElementDecl

sub_pattern: optional[Pattern] | child

class ExprPattern(Pattern):

sub_expr: Expr | child

class IsPattern(Pattern):

cast_type_repr: optional["TypeRepr"] | child

sub_pattern: optional[Pattern] | child

class NamedPattern(Pattern):

var_decl: VarDecl

class OptionalSomePattern(Pattern):

sub_pattern: Pattern | child

class ParenPattern(Pattern):

sub_pattern: Pattern | child

class TuplePattern(Pattern):

elements: list[Pattern] | child

class TypedPattern(Pattern):

sub_pattern: Pattern | child

type_repr: optional["TypeRepr"] | child

@group("stmt")

@qltest.test_with("SwitchStmt")

class CaseLabelItem(AstNode):

pattern: Pattern | child

guard: optional[Expr] | child

class AvailabilitySpec(AstNode):

"""

An availability spec, that is, part of an `AvailabilityInfo` condition. For example `iOS 12` and `*` in:

```

if #available(iOS 12, *)

```

"""

pass

class PlatformVersionAvailabilitySpec(AvailabilitySpec):

"""

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

"""

platform: string

version: string

class OtherAvailabilitySpec(AvailabilitySpec):

"""

A wildcard availability spec `*`

"""

pass

class AvailabilityInfo(AstNode):

"""

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

Examples:

```

if #available(iOS 12, *) {

// Runs on iOS 12 and above

} else {

// Runs only anything below iOS 12

}

if #unavailable(macOS 10.14, *) {

// Runs only on macOS 10 and below

}

```

"""

is_unavailable: predicate | doc("it is #unavailable as opposed to #available")

specs: list[AvailabilitySpec] | child

@group("stmt")

class ConditionElement(AstNode):

boolean: optional[Expr] | child

pattern: optional[Pattern] | child

initializer: optional[Expr] | child

availability: optional[AvailabilityInfo] | child

@group("stmt")

class StmtCondition(AstNode):

elements: list[ConditionElement] | child

class BraceStmt(Stmt):

variables: list[VarDecl] | synth | child | doc("variable declared in the scope of this brace statement")

elements: list[AstNode] | child

class BreakStmt(Stmt):

target_name: optional[string]

target: optional[Stmt]

@qltest.test_with("SwitchStmt")

class CaseStmt(Stmt):

labels: list[CaseLabelItem] | child

variables: list[VarDecl] | child

body: Stmt | child

class ContinueStmt(Stmt):

target_name: optional[string]

target: optional[Stmt]

class DeferStmt(Stmt):

body: BraceStmt | child

class FailStmt(Stmt):

pass

class FallthroughStmt(Stmt):

fallthrough_source: CaseStmt

fallthrough_dest: CaseStmt

class LabeledStmt(Stmt):

label: optional[string]

class PoundAssertStmt(Stmt):

condition: Expr

message: string

class ReturnStmt(Stmt):

result: optional[Expr] | child

class ThrowStmt(Stmt):

sub_expr: Expr | child

class YieldStmt(Stmt):

results: list[Expr] | child

@qltest.test_with('SingleValueStmtExpr')

class ThenStmt(Stmt):

""" A statement implicitly wrapping values to be used in branches of if/switch expressions. For example in:

```