Index

`AddAssignmentOperation`	An add assignment operation (`+=`).
`AddingExpression`	An expression on or above the precedence level of addition and subtraction.
`AliasDec`	An alias reference expression, that is, the `AliasDec.name` of an alias, optionally qualified by a `AliasDec.qualifier` (s…
`AndAssignmentOperation`	A logical conjunction assignment expression.
`AndOperation`	A logical conjunction expression.
`Annotation`	An annotation.
`Annotations`	A list of annotations.
`AnonymousArgument`	An anonymous named argument, that is, an expression followed by a semicolon.
`AnyClass`	A class definition or alias.
`AnyCompilationUnit`	A compilation unit.
`AnyFunction`	A function declaration or definition.
`AnyInterface`	An interface definition or alias.
`AnyInterfaceDefinition`	A regular or dynamic interface definition.
`AnyMemberOperator`	A member operator, used in a `QualifiedExpression`.
`AnySpecifier`	An eager or lazy expression specifier.
`AnyValue`	A value declaration or definition.
`ArgumentList`	An argument list.
`Arguments`	An argument list that can be used in an `Invocation`.
`ArithmeticAssignmentOperation`	An arithmetic assignment operation, a shortcut for an `ArithmeticOperation` combined with an `AssignmentOperation`.
`ArithmeticOperation`	An arithmetic operation expression.
`Assertion`	An assertion statement, that is, an annotation list, followed by the keyword ‘`assert`’, a condition list, and terminated…
`AssignOperation`	An assignment expression.
`AssigningExpression`	An expression on or above the precedence level of assignment.
`AssignmentOperation`	An assignment expression.
`AssignmentStatement`	An assignment expression statement, that is, an assignment terminated by a semicolon.
`Atom`	An “atomic” expression.
`BaseExpression`	An unqualified identifier with an optional list of type arguments.
`BaseMeta`	A base metamodel expression, that is, a member name with optional type arguments, optionally qualified with a ‘`package`’…
`BaseType`	A type name with optional type arguments.
`BinaryOperation`	A binary operator expression.
`Block`	A list of statements and declarations, surrounded by braces.
`Body`	A list of statements and declarations, surrounded by braces.
`BooleanCondition`	A boolean condition, that is, an expression.
`Bound`	A lower or upper bound of a bounded comparison operation.
`Break`	A `break` directive.
`CallableConstructorDefinition`	A callable constructor definition.
`CallableParameter`	A callable parameter.
`CallableType`	A callable type.
`CascadingNarrowingTransformer`	A `NarrowingTransformer` that narrows cascadingly to the “less abstract” type of the visited subject by switching on the c…
`CaseClause`	A ‘`case`’ clause of a ‘`switch`’ statement (`SwitchCaseElse`), that is, the keyword ‘`case`’, followed by a case item enclosed i…
`CaseExpression`	A ‘`case`’ expression clause of a ‘`switch`’ expression (`SwitchCaseElseExpression`), that is, the keyword ‘`case`’, followed b…
`CaseItem`	A ‘`case`’ item from a ‘`case`’ clause (`CaseClause`).
`CaseTypes`	A nonempty list of case types, separated by the union operator (‘`\|`’).
`CatchClause`	A ‘`catch`’ clause, that is, the keyword ‘`catch`’, followed by a `CatchClause.variable` (enclosed in parentheses) and a `…`
`CeylonExpressionTransformer`	Builds a Ceylon expression string for an AST node; compiling and evaluating the resulting string will yield a copy of…
`CharacterLiteral`	A character literal consists of a single character or an escape sequence.
`ClassAliasDefinition`	A class alias definition.
`ClassBody`	A list of statements and declarations, surrounded by braces.
`ClassDec`	A class reference expression, that is, the `ClassDec.name` of a class or anonymous class, qualified by a (possibly empty) `…`
`ClassDefinition`	A class definition.
`ClassOrInterface`	A class or interface declaration.
`ClassSpecifier`	A class specifier for a class alias, that is, a lazy specification operator ‘`=>`’ followed by an extension or…
`ClosedBound`	A closed lower or upper bound of a bounded comparison operation.
`CompareOperation`	A compare expression.
`ComparingExpression`	An expression on or above the precedence level of comparison, containment, assignability and inheritance tests.
`ComparisonOperation`	A comparison expression.
`CompilationUnit`	A regular compilation unit, containing toplevel type, value, or function definitions.
`ComplementAssignmentOperation`	A complement assignment operation.
`ComplementOperation`	A set complement expression.
`Comprehension`	A comprehension, that is, a chain of comprehension clauses, beginning with an `InitialComprehensionClause` and terminated b…
`ComprehensionClause`	A comprehension clause, one component of a `Comprehension`.
`Condition`	A condition.
`ConditionalExpression`	A conditional expression.
`Conditions`	A comma-separated list of one or more `Conditions.conditions`, enclosed in parentheses.
`ConjoiningExpression`	An expression on or above the precedence level of logical conjunction.
`Construction`	A construction, that is, a member name with optional type arguments and `Construction.arguments`, optionally qualified w…
`ConstructorDec`	A constructor reference expression, that is, the `ConstructorDec.name` of a constructor, qualified by a `ConstructorDec.`
`ConstructorDefinition`	A constructor definition.
`Continue`	A `continue` directive.
`ControlStructure`	A control structure statement, used to control normal execution flow.
`Dec`	A reference expression, that is, a detyped reference to a program element.
`DecQualifier`	A qualifier for a `Dec`, that is, a period-separated sequence of identifiers, possibly itself qualified by a ‘`package`’…
`Declaration`	A declaration.
`DefaultedCallableParameter`	A callable parameter, along with a default implementation for the parameter.
`DefaultedParameter`	A defaulted parameter.
`DefaultedParameterReference`	The name of a parameter declared in the body of the function or class, along with a default value for the parameter.
`DefaultedType`	A defaulted type.
`DefaultedValueParameter`	A value parameter, along with a default value for the parameter.
`Destructure`	A destructuring statement, that is, a ‘`value`’ modifier (`valueModifier`), followed by a `Destructure.pattern` and a `…`
`DifferenceOperation`	A difference expression.
`Directive`	A control directive, terminated by a semicolon.
`DisjoiningExpression`	An expression on or above the precedence level of logical disjunction.
`DivideAssignmentOperation`	A divide assignment operation (`/=`).
`DynamicBlock`	A `dynamic` block, that is, a `DynamicBlock.block` prefixed by the keyword ‘`dynamic`’.
`DynamicInterfaceDefinition`	A dynamic interface definition.
`DynamicModifier`	A ‘`dynamic`’ modifier keyword.
`DynamicValue`	A dynamic value expression, that is, the keyword ‘`dynamic`’ followed by any number of named arguments and a (possibly e…
`Editor`	An AST editor.
`ElementOrSubrangeExpression`	An element or subrange access expression, that is, a target `ElementOrSubrangeExpression.primary` followed by a `…`
`ElseClause`	An `else` clause, that is, the keyword ‘`else`’, followed by a block or another if/else conditional.
`ElseOperation`	An “else” operation.
`EntryOperation`	An entry expression.
`EntryPattern`	An entry pattern, that is, a `EntryPattern.key` pattern and an `EntryPattern.item` pattern, separated by an entry operator.
`EntryType`	An entry type, that is, a shortcut for `TypeNameWithTypeArguments(TypeName(UIdentifier("Entry")), [left, right])`.
`EqualOperation`	An equals expression.
`EqualityOperation`	An expression to test for identity or (in)equality of two objects.
`EquatingExpression`	An expression on or above the precedence level of equality tests.
`ExistsCondition`	An existence condition, that is, the keyword ‘`exists`’, followed by either a specified pattern or a member name…
`ExistsNonemptyExpression`	An expression on or above the precedence level of existence and nonemptiness tests.
`ExistsOperation`	A postfix existence test expression.
`ExistsOrNonemptyCondition`	An existence or nonemptiness condition, that is, the keyword ‘`exists`’ or ‘`nonempty`’, followed by either a specified…
`ExponentiatingExpression`	An expression on or above the precedence level of exponentiation.
`ExponentiationOperation`	An exponentiation expression.
`Expression`	Abstract superclass of all expression nodes.
`ExpressionComprehensionClause`	An expression that terminates a comprehension.
`ExpressionStatement`	An expression statement, that is, an expression terminated by a semicolon.
`ExtendedType`	An ‘`extends`’ clause for a class definition, that is, the keyword ‘`extends`’, followed by an extension or construction.
`Extension`	An extension, that is, a type name with optional type arguments and optional `Extension.arguments`, optionally qualified w…
`ExtensionOrConstruction`	An extension or construction, that is, anything that can go in an extended type or class specifier.
`FailClause`	An ‘`else`’ failure clause for a ‘`for`’ loop (`ForFail`), that is, the keyword ‘`else`’ followed by a `FailClause.block`.
`FinallyClause`	A ‘`finally`’ clause, that is, the keyword ‘`finally`’ followed by a `FinallyClause.block`.
`FloatLiteral`	A floating point literal is distinguished from an integer literal (`IntegerLiteral`) by the presence of fractional digits…
`ForClause`	A ‘`for`’ clause, that is, the keyword ‘`for`’ followed by an `ForClause.iterator` and a `ForClause.block`.
`ForComprehensionClause`	A ‘`for`’ comprehension clause, also known as a quantifier clause.
`ForFail`	A ‘`for`’ loop with an optional failure clause, that is, a ‘`for`’ clause (`forClause`), optionally followed by an ‘`else`’…
`ForIterator`	An iterator for a ‘`for`’ loop, enclosed in parentheses.
`FullPackageName`	A full package name, that is, a period-separated list of lowercase identifiers.
`FunctionArgument`	An inline function argument definition.
`FunctionDec`	A function reference expression, that is, the `FunctionDec.name` of a function or method, qualified by a (possibly empty) `…`
`FunctionDeclaration`	A function declaration.
`FunctionDefinition`	A function definition, using a block.
`FunctionExpression`	An expression that returns a callable function.
`FunctionModifier`	A ‘`function`’ modifier keyword.
`FunctionShortcutDefinition`	A function shortcut definition, using a lazy specifier and terminated by a semicolon.
`GivenDec`	A type parameter reference expression, that is, the name of a type parameter, prefixed by the type keyword `given` and…
`GroupedExpression`	A grouped, or parenthesized expression.
`GroupedType`	A type, grouped in angle brackets to resolve lexical ambiguity:
`IdenticalOperation`	An identity test operation.
`Identifier`
`IdentityOperation`	The expression `+i`.
`IfClause`	An `if` clause, that is, the keyword ‘`if`’, followed by a condition list and a `IfClause.block`.
`IfComprehensionClause`	An ‘`if`’ comprehension clause, also knows as a filter clause.
`IfElse`	An if/else conditional.
`IfElseExpression`	An if/then/else conditional expression, that is, the keyword ‘`if`’, followed by a condition list, the keyword ‘`then`’, f…
`ImmediateNarrowingTransformer`	A `NarrowingTransformer` that narrows immediately to the type of the visited subject by invoking its `transform` (`N…`
`Import`	An import statement, that is, the keyword ‘`import`’ followed by the package name and the imported `Import.elements` from…
`ImportAlias`	An import alias, that is, an identifier followed by an “equals” character.
`ImportElement`	A single import element, that is, the name of an imported program element, optionally preceded by an alias and/or f…
`ImportElements`	A comma-separated list of import elements, where the last element may optionally be a wildcard instead, surrounded by…
`ImportFunctionValueAlias`	A function or value import alias, that is, a lowercase identifier followed by an “equals” character.
`ImportFunctionValueElement`	A single function or value import element, that is, the name of an imported function or value, optionally preceded by a …
`ImportTypeAlias`	A type import alias, that is, an uppercase identifier followed by an “equals” character.
`ImportTypeElement`	A single type import element, that is, the name of an imported type, optionally preceded by a type alias and/or f…
`ImportWildcard`	An import wildcard, that is, three colons (‘`...`’).
`InModifier`	An ‘`in`’ modifier, indicating a contravariant type parameter or argument.
`InOperation`	A containment test expression.
`InitialComprehensionClause`	A comprehension clause that can start a comprehension.
`InlineDefinitionArgument`	A named argument that defines a getter, function, or anonymous class, and assigns it to a parameter.
`IntegerLiteral`	An integer literal may be expressed in decimal (no prefix), hexadecimal (prefix ‘#’) or binary (prefix ‘$’) notation.
`InterfaceAliasDefinition`	An interface alias definition.
`InterfaceBody`	A list of declarations, surrounded by braces.
`InterfaceDec`	An interface reference expression, that is, the `InterfaceDec.name` of an interface, optionally qualified by a `…`
`InterfaceDefinition`	A regular interface definition.
`IntersectAssignmentOperation`	An intersect assignment operation.
`IntersectingExpression`	An expression on or above the precedence level of intersection.
`IntersectionOperation`	A set intersection expression.
`IntersectionType`	An intersection type.
`InvertingExpression`	An expression on or above the precedence level of arithmetic inversion or identity.
`Invocation`	An invocation, that is, an invoked expression with an argument list.
`InvocationStatement`	An invocation statement, that is, an invocation terminated by a semicolon.
`IsCase`	A ‘`case`’ item to test the type of the `switch` expression.
`IsCondition`	An assignability condition, that is, the keyword ‘`is`’, followed by an (optionally specified) typed variable and…
`IsOperation`	A postfix assignability test expression.
`Iterable`	An iterable object instantiation expression.
`IterableType`	An iterable type, like `{String*}` or `{Integer+}`.
`Key`	A key by which a `Node`’s additional information can be accessed.
`KeySubscript`	A key / index subscript expression, to select an element from a `Correspondence` expression.
`LIdentifier`	An initial lowercase identifier.
`LargeAsOperation`	A “large as” expression.
`LargerOperation`	A “larger than” expression.
`LazySpecification`	A lazy specification statement, that is, a member name, optionally followed by one or more parameter lists, and s…
`LazySpecifier`	A lazy expression specifier, that is, an expression prefixed by a computation operator ‘`=>`’.
`LetExpression`	A `let` expression, that is, the keyword ‘`let`’, followed by a list of patterns and an `LetExpression.expression` that can…
`Literal`	A literal is a single token that represents a Unicode character, a character string, or a numeric value.
`LocalModifier`	A modifier that indicates type inference.
`LogicalAssignmentOperation`	A logical assignment expression.
`LogicalOperation`	A logical binary operation expression.
`MainType`	“Main” types: the types that you normally use.
`MatchCase`	A ‘`case`’ item to test if the `switch` expression matches one or more expressions.
`MeasureOperation`	A measured range expression.
`MeasureSubscript`	A measure subscript, to select a (sub)range from a `Ranged` expression using the first index and `MeasureSubscript.length`.
`MemberDec`	A member reference expression.
`MemberMeta`	A member metamodel expression, that is, a qualifying type, followed by a member name with optional type arguments,…
`MemberName`
`MemberNameWithTypeArguments`	A member name and, optionally, type arguments.
`MemberOperator`	A regular member operator, ‘`.`’.
`Meta`	A metamodel expression, that is, a typed reference to a type, class, function or value.
`Modifier`	A modifier keyword.
`ModuleBody`	A module descriptor body, that is, any number of module imports surrounded by braces.
`ModuleCompilationUnit`	A module descriptor compilation unit, containing a module descriptor.
`ModuleDec`	A module reference expression, that is, the name of a module (or empty for the current module), prefixed by the keyword…
`ModuleDescriptor`	A module descriptor: a list of annotations, followed by the keyword ‘`module’`, and then the module `ModuleDescriptor.name`,
`ModuleImport`	An import of another module within a module descriptor.
`MultiplyAssignmentOperation`	A multiply assignment operation (`*=`).
`MultiplyingExpression`	An expression on or above the precedence level of multiplication or division.
`NameWithTypeArguments`	A name and, optionally, type arguments.
`NamedArgument`	A named argument.
`NamedArguments`	A named argument list.
`NarrowingTransformer`	A `Transformer` with the default operation to narrow the type of the visited subject; all methods for abstract node types…
`NegatingExpression`	An expression on or above the precedence level of logical negation.
`NegationOperation`	An arithmetic unary negation operation, that is, `-i`.
`Node`	Abstract superclass of all AST nodes.
`NonemptyCondition`	A nonemptiness condition, that is, the keyword ‘`nonempty`’, followed by either a specified pattern or a member name…
`NonemptyOperation`	A nonempty postfix expression.
`NotEqualOperation`	A not equals expression.
`NotOperation`	A logical not expression.
`ObjectArgument`	An object argument definition.
`ObjectDefinition`	An object definition.
`ObjectExpression`	An object expression, that is, the keyword ‘`object`’, followed by an optional extended type and optional satisfied types,…
`OfOperation`	A coverage expression.
`OpenBound`	An open lower or upper bound of a bounded comparison operation.
`Operation`	An operator expression.
`OptionalType`	An optional type, that is, a shortcut for `UnionType(definiteType, nullType)`.
`OrAssignmentOperation`	A logical disjunction assignment expression.
`OrOperation`	A logical disjunction expression.
`OutModifier`	An ’`out`’ modifier, indicating a covariant type parameter or argument.
`Outer`	The value of this expression is the current instance of the type which immediately contains the immediately containing…
`Package`	`package` isn’t actually an expression; it can be used to qualify and disambiguate a value or callable reference.
`PackageCompilationUnit`	A package descriptor compilation unit, containing a package descriptor.
`PackageDec`	A package reference expression, that is, the name of a package (or empty for the current package), prefixed by the…
`PackageDescriptor`	A package descriptor: a list of annotations, followed by the keyword ‘`package`’, the package name, and terminated by a…
`PackageName`
`PackageQualifier`	A package qualifier, that is, the keyword ‘`package`’ followed by a member operator.
`Parameter`	A class, method, or function parameter.
`ParameterReference`	The name of a parameter, without type information.
`Parameters`	A parameter list.
`Pattern`	A pattern declares one or multiple variables. Destructuring statements, assertions, and some control structures can…
`PatternList`	A comma-separated list of specified patterns, enclosed in parentheses.
`PositionalArguments`	A positional argument list.
`PostfixDecrementOperation`	A postfix decrement expression (`i--`).
`PostfixIncrementOperation`	A postfix increment expression (`i++`).
`PostfixOperation`	A postfix arithmetic expression, that is, `i++` or `i--` for any `Primary` `i`.
`PrePostfixingExpression`	An expression on or above the precedence level of arithmetic pre- or postfix expressions.
`PrefixDecrementOperation`	A prefix decrement expression (`--i`).
`PrefixIncrementOperation`	A prefix increment expression (`++i`).
`PrefixOperation`	A prefix arithmetic expression, that is, `++i` or `--i` for any `Primary` `i`.
`PrefixPostfixStatement`	A prefix or postfix increment or decrement expression statement.
`Primary`	A primary expression.
`PrimaryType`	A primary type; only intersection, union and entry types come before these.
`ProductOperation`	A product expression.
`QualifiedExpression`	A receiver expression, followed by a member operator (usually ‘`.`’) and an (unqualified) identifier with optional type…
`QualifiedType`	A qualified type, consisting of a qualifying type and a type name with arguments, separated by a member operator.
`QuotientOperation`	A quotient or division expression.
`RangeSubscript`	A range subscript, to select a (sub)range from a `Ranged` expression.
`RemainderAssignmentOperation`	A remainder assignment operation (`%=`).
`RemainderOperation`	A remainder expression.
`RequiredParameter`	A required parameter (neither defaulted nor variadic).
`Resource`	A resource in a try-with-resources statement.
`Resources`	A comma-separated list of `Resources.resources`, surrounded by parentheses.
`Return`	A `return` directive, with an optional returned expression.
`SafeMemberOperator`	A nullsafe member operator, ‘`?.`’.
`SatisfiedTypes`	A nonempty list of satisfied types, separated by the intersection operator (‘`&`’).
`ScaleOperation`	A scale expression.
`ScalingExpression`	An expression on or above the precedence level of scaling.
`ScopedKey`	A `Key` with an explicitly provided scope, to avoid name collisions.
`SelfReference`	`this`, `super`, `outer` and `package` are self reference expressions.
`SequentialType`	A sequential type, that is, a primary type, followed by an opening bracket, optionally an integer `SequentialType.length`,…
`SetAssignmentOperation`	A set assignment operation.
`SetOperation`	A set operation: intersection, union or complement.
`SimpleType`	A simple type: One or more TypeNamesWithArguments, separated by member operators.
`SmallAsOperation`	A “small as” expression.
`SmallerOperation`	A “smaller than” expression.
`SpanFromSubscript`	A span-from subscript, to select a (sub)range from a `Ranged` expression using the first index.
`SpanOperation`	A spanned range expression.
`SpanSubscript`	A span subscript, to select a (sub)range from a `Ranged` expression using the first and last index.
`SpanToSubscript`	A span-to subscript, to select a (sub)range from a `Ranged` expression using the last index.
`SpanningExpression`	An expression on or above the precedence level of range and entry construction.
`Specification`	A specification statement.
`SpecifiedArgument`	A specified named argument, that is, a `Specification`.
`SpecifiedPattern`	A `SpecifiedPattern.pattern` followed by a `SpecifiedPattern.specifier` that is assigned to the pattern.
`SpecifiedVariable`	A specified inline variable declaration.
`Specifier`	An expression specifier, that is, an expression prefixed by a specification operator ‘`=`’.
`SpreadArgument`	A spread argument.
`SpreadMemberOperator`	A spread member operator, ‘`*.`’.
`SpreadType`	A spread type.
`Statement`	A statement.
`StringLiteral`	A string literal consists of a series of characters and/or, if it’s not verbatim, escape sequences.
`StringTemplate`	A string template, that is, a string start, followed by any number of value expression and string mid pairs, followed b…
`StructureExpression`	An expression on or above the precedence level of “structural” expressions.
`Subscript`	A subscript used to access an element or subrange in a `ElementOrSubrangeExpression` (where it is surrounded by brackets).
`SubtractAssignmentOperation`	A subtract assignment operation (`-=`).
`SumOperation`	A sum expression.
`Super`	The value of this expression is the current instance, and its type is the intersection of the immediate superclass and…
`SwitchCaseElse`	A `switch`/`case`/`else` statement, that is, a `switch` clause (`clause`), followed by `SwitchCaseElse.cases`.
`SwitchCaseElseExpression`	A `switch`/`case`/`else` expression, that is, a `switch` clause (`switchClause`), followed by one or more `case` expressions (`c…`
`SwitchCases`	A list of ‘`case`’ clauses (with an optional trailing ‘`else`’ clause) for a `switch` statement (`SwitchCaseElse`).
`SwitchClause`	A ‘`switch`’ clause of a `switch` statement (`SwitchCaseElse`), that is, the keyword ‘`switch`’, followed by an expression or…
`ThenElseExpression`	An expression on or above the precedence level of “`then`” and “`else`” expressions.
`ThenOperation`	A “then” operation.
`This`	The value of this expression is the current instance, and its type is the immediately containing type.
`Throw`	A `throw` directive, with an optional thrown exception.
`Transformer`	Abstract interface to perform some operations on AST nodes and possibly get some result.
`TryCatchFinally`	A try-cA try/catch/finally statement, that is, a ‘`try`’ clause (`tryClause`), followed by any amount of ‘`catch`’ clauses (`c…`
`TryClause`	A ‘`try`’ clause, that is, the keyword ‘`try`’, followed optionally by `TryClause.resources` and then by a `TryClause.block` (r…
`Tuple`	A tuple instantiation expression.
`TuplePattern`	A tuple pattern, that is, several patterns, including optionally a trailing variadic one, separated by commas and…
`TupleType`	A tuple type.
`Type`	Representation of a type.
`TypeAliasDefinition`	A type alias definition.
`TypeArgument`	A type argument, that is, a `TypeArgument.type` with optional `TypeArgument.variance` (use-site variance).
`TypeArguments`	A comma-separated list of type arguments, enclosed in angle brackets.
`TypeConstraint`	A constraint upon a type parameter.
`TypeDec`	A type reference expression.
`TypeDeclaration`	A type declaration.
`TypeIsh`	All node types in the type sub-hierarchy: `Type` and some auxiliary node types that aren’t proper Types.
`TypeList`	A list of types, with an optional trailing variadic type.
`TypeMeta`	A type metamodel expression, that is, a `Type` surrounded by backticks.
`TypeModifier`	A modifier that can be used instead of a type in some places.
`TypeName`
`TypeNameWithTypeArguments`	A type name and, optionally, type arguments.
`TypeParameter`	A type parameter of a class, method or function.
`TypeParameters`	A nonempty comma-separated list of type parameters, surrounded by angle brackets.
`TypeSpecifier`	A type specifier, that is, a type prefixed by a computation operator ‘`=>`’.
`TypedDeclaration`	A declaration with a type.
`TypedVariable`	A typed inline variable declaration.
`UIdentifier`	An initial uppercase identifier.
`UnaryArithmeticOperation`	A unary arithmetic expression, that is, `+i` or `-i`.
`UnaryIshOperation`	An expression consisting of a `ValueExpression`, an operator, and possibly a `Type`.
`UnaryOperation`	A unary operator expression.
`UnaryTypeOperation`	A unary type operation.
`UnionAssignmentOperation`	A union assignment operation.
`UnionOperation`	A set union expression.
`UnionType`	A union type.
`UnionableType`	Types that can be children of a `UnionType`.
`UnioningExpression`	An expression on or above the precedence level of union or complementation.
`UnspecifiedVariable`	An unspecified inline variable declaration.
`ValueArgument`	An inline getter argument definition.
`ValueConstructorDefinition`	A value constructor definition.
`ValueDec`	A value reference expression, that is, the `ValueDec.name` of a value, qualified by a (possibly empty) `ValueDec.qualifier`…
`ValueDeclaration`	A value declaration.
`ValueDefinition`	A value definition, using a specifier.
`ValueExpression`	An expression that returns an ordinary value.
`ValueGetterDefinition`	A value definition, using a getter block.
`ValueModifier`	A ‘`value`’ modifier keyword.
`ValueParameter`	A value parameter.
`ValueSetterDefinition`	A setter definition, that is, the keyword ‘`assign`’, followed by the `ValueSetterDefinition.name` of the value and the `…`
`ValueSpecification`	A value specification statement, that is, a member name followed by a `Specifier`.
`Variable`	An inline variable declaration.
`VariablePattern`	A simple variable pattern.
`VariadicParameter`	A variadic parameter.
`VariadicType`	A variadic type is a `MainType` followed by a “*” (possibly-empty) or a “+” (nonempty).
`VariadicVariable`	A variadic pattern variable.
`Variance`	A modifier that indicates type parameter / argument variance.
`Visitor`	An AST visitor.
`VoidModifier`	A ‘`void`’ modifier keyword.
`While`	A `while` loop, that is, the keyword ‘`while`’, followed by `While.conditions` and a `While.block`.
`WideningTransformer`	A `Transformer` with the default operation to widen the type of the visited subject: `WideningTransformer.`
`WithinOperation`	A bounded comparison operation, also known as “within” operation.
`annotation()`	Shortcut helper function for an `Annotation` with the specified name and no arguments.
`lidentifierNeedsPrefix()`
`uidentifierNeedsPrefix()`

Keyboard Shortcuts

Documentation:

Search page:

Filter declarations by tags

Index