An expression on or above the precedence level of addition and subtraction.

An expression on or above the precedence level of assignment.

This contains all “Layer 4” operators, that is, all operators total.

An expression on or above the precedence level of comparison, containment, assignability and inheritance tests.

An expression on or above the precedence level of logical conjunction.

An expression on or above the precedence level of logical disjunction.

This contains all “Layer 3” operators.

An expression on or above the precedence level of equality tests.

This contains all “Layer 2” operators.

An expression on or above the precedence level of existence and nonemptiness tests.

An expression on or above the precedence level of exponentiation.

An expression on or above the precedence level of intersection.

An expression on or above the precedence level of arithmetic inversion or identity.

Not to be confused with the precedence level of logical negation (NegatingExpression).

A node that can appear as the qualifier of a MemberMeta.

An expression on or above the precedence level of multiplication or division.

An expression on or above the precedence level of logical negation.

Not to be confused with the precedence level of arithmetic inversion (InvertingExpression).

An expression on or above the precedence level of arithmetic pre- or postfix expressions.

(This is the highest precedence level for operators; only primary expressions rank higher.)

An expression on or above the precedence level of scaling.

An expression on or above the precedence level of range and entry construction.

This contains all “Layer 1” operators.

An expression on or above the precedence level of “then” and “else” expressions.

An expression on or above the precedence level of union or complementation.

Shortcut helper function for an Annotation with the specified name and no arguments.

A NarrowingTransformer that narrows cascadingly to the “less abstract” type of the visited subject by switching on the case types and invoking the proper transformX method.

For example:

// ValueExample has the case types Primary | Operation
shared actual default Result transformValueExpression(ValueExpression that) {
    switch (that)
    case (is Primary) { return transformPrimary(that); }
    case (is Operation) { return transformOperation(that); }
}

I honestly don’t know when you’d want to use this instead of ImmediateNarrowingTransformer; perhaps the strongest argument for its existence is that it was trivial to generate along with other generated code while ceylon.ast was originally written, but would be significantly more painful to create (by hand or automatically) afterwards.

An AST editor. There is one method per AST node; override the methods for which you need to change the AST, and leave the others untouched.

The default operation for “bottom“ node types’ methods is to copy the node, editing the children. (The default operation for non-“bottom” node types’ methods is inherited from NarrowingTransformer, see there.) By itself, an Editor will not actually edit the AST – it’s only scaffolding that allows you to easily edit parts of the AST without having to bother with the deep nesting of the nodes.

For example:

class PrefixEditor(String prefix) extends Editor() {
    shared actual Identifier editIdentifier(Identifier that)
            => that.copy { name = prefix + that.name; };
}

will prepend prefix to every Identifier in the AST.

Note that this deep copy of the AST can be expensive; if you know that you will not touch certain parts of the AST – for example, you only edit method names, and never instructions – you might want to override some methods to return this instead of a deep copy (in this example, override Editor.transformBody()).

A NarrowingTransformer that narrows immediately to the type of the visited subject by invoking its transform (Node.transform) method.

For example:

shared actual default Result transformValueExpression(ValueExpression that)
        => that.transform(this);

This interface should be functionally equivalent to CascadingNarrowingTransformer, but is likely a lot faster because it uses only a single virtual method lookup instead of a series of type checks and calls.

A Transformer with the default operation to narrow the type of the visited subject; all methods for abstract node types have a default implementation while those for concrete node types remain formal.

There are two ways to perform this narrowing:

• immediately, by invoking the transform (Node.transform) method on the subject, or
• cascadingly, where each method switches on the enumerated subtypes of the node type and narrows only by one layer by invoking the corresponding transformX method on the transformer.

It should be possible to use them interchangeably (swap out the satisfying type of your implementing class without any effect), and since the immediate version is faster (it’s only a virtual method lookup instead of a series of calls and type checks), you should probably use that.

Abstract interface to perform some operations on AST nodes and possibly get some result.

For every subtype of Node, there is one transform method, each returning Result. These are all formal, as there are two sensible default behaviors:

• widening, as done in WideningTransformer: every transform eventually ends up in Transformer.transformNode().
  • for example: Transformer.transformTypeAliasDefinition() → Transformer.transformTypeDeclaration() → Transformer.transformDeclaration() → Transformer.transformNode()
• narrowing, as done in NarrowingTransformer: every transform eventually ends up in the transform method for the concrete class.
  • for example: Transformer.transformIdentifier() switches on Identifier’s case types and delegates to the transform methods for the subclasses.

Be careful when mixing the two behaviors, lest you end up in an infinite recursion!

An AST visitor. There is one method per AST node; override the methods for which you need to do something, and leave the others untouched.

The default operation for most node types is to pass the visit up to the node’s supertype; for example, if you override only Visitor.visitIdentifier(), you will receive calls to both Node.visit() and Node.visit(), as the default operation for Visitor.visitLIdentifier() and Visitor.visitUIdentifier() is to delegate to Visitor.visitIdentifier(). Visitor.visitNode() is different: As the root of the AST class hierarchy, it has no superclass; instead, it visits all the children of the node. Thus, the default visitor will already traverse the AST fully, and if you need to perform some operation only for some node type that might appear anywhere in the AST, you can simply override that particular method and leave the rest as it is.

A Transformer with the default operation to widen the type of the visited subject: WideningTransformer.transformLIdentifier() delegates to WideningTransformer.transformIdentifier(), which in turn delegates to Transformer.transformNode(), which (Node being without a superclass) is the only formal method left.

An add assignment operation (+=).

Right-associative.

Examples:

index += step
document.cursor.position += insertion.size

An alias reference expression, that is, the AliasDec.name of an alias, optionally qualified by a AliasDec.qualifier (separated from it by a member operator ‘.’), prefixed by the type keyword alias and surrounded by backticks.

Examples:

`alias TypeName`
`alias A.B.C

A logical conjunction assignment expression.

Right-associative.

Examples:

valid &&= parsed exists
legal &&= !globalLock

A logical conjunction expression.

Left-associative.

Examples:

i%2 == 0 && j%2 == 1
attr1 == that.attr1 && attr2 == that.attr2 && attr3 == that.attr3

An annotation.

For the common case “no arguments”, the toplevel helper function annotation() may be used.

Examples:

shared
formal
by ("John Doe <john.doe@company.com>")
see (`function print`)
action { description = "Log in"; url = "/login"; }

A list of annotations.

The first annotation may optionally be an anonymous annotation, that is, a string literal interpreted as the argument of a doc() annotation.

Annotations are not separated by any punctuation.

Examples:

shared formal
"The number of elements in this list" see (`value List.lastIndex`) shared actual

An anonymous named argument, that is, an expression followed by a semicolon.

Examples:

name;
width * height;

A class definition or alias.

Examples (multi-line):

shared class PrintableWrapper<T>(shared T wrapped)
        satisfies Printable {
    shared actual void print() {
        package.print(wrapped else "<null>");
    }
}

shared class VariadicString(Character* characters) => String(characters);

A compilation unit.

There are three kinds of compilation unit:

• Regular compilation units contain toplevel type, value, or function definitions.
• Module descriptor compilation units contain a module descriptor.
• Package descriptor compilation units contain a package descriptor.

(Because it is the most commonly used, and also what most people associate with a “compilation unit”, the first kind is simply called CompilationUnit and this abstract class is called AnyCompilationUnit, rather than calling this CompilationUnit and using RegularCompilationUnit or CodeCompilationUnit for regular compilation units.)

Every compilation unit starts with a (possibly empty) list of AnyCompilationUnit.imports.

Examples (separated by blank lines):

module tmp "1.0.0" {}

package tmp;

void run() {
    print("Hello, World!");
}

A function declaration or definition.

If the AnyFunction.definition is missing or a specifier, then the statement must be terminated by a semicolon; if it’s a Block, the semicolon is not necessary.

Examples:

shared formal Boolean equals(Object that);
function compareByLength({Anything*} first, {Anything*} second) => first.length.compare(second.length);
shared void run() {
    print("Hello, `` process.arguments.first else "World" ``!");

An interface definition or alias.

Examples (multi-line):

shared interface Printable {
    shared default void print() => package.print(this);
}

shared interface People => {Person*};

A regular or dynamic interface definition.

Examples (multi-line):

shared interface Printable {
    shared default void print() => package.print(this);
}

shared dynamic Document {
    shared formal String xmlVersion;
    shared formal StyleSheetList styleSheets;
    shared formal String documentURI;
    // ...
}

A member operator, used in a QualifiedExpression.

An eager or lazy expression specifier.

Examples:

= 1
=> text.uppercased

A value declaration or definition.

If the TypedDeclaration.definition is missing or a specifier, then the statement must be terminated by a semicolon; if it’s a Block, the semicolon is not necesary.

Examples:

shared String name;
shared formal Comparison compare(Other that);
shared default Boolean empty => iterator().next() is Finished;

An argument list.

A list of expressions, here called listed arguments, optionally followed by a spread argument or a comprehension.

Examples:

width, height
*args
/* empty parameter list is also allowed */
this, *others

An argument list that can be used in an Invocation.

Not to be confused with ArgumentList. An ArgumentList is just a comma-separated list of arguments with an optional trailing sequential argument. Arguments either simply wrap an ArgumentList in parentheses (PositionalArguments), or can also add named arguments (NamedArguments).

Examples:

(x, y, *messages)
()
(for (i in 1..10) i^2)
{ factor = 2.1; *actors }

An arithmetic assignment operation, a shortcut for an ArithmeticOperation combined with an AssignmentOperation.

Right-associative.

An arithmetic operation expression.

An assertion statement, that is, an annotation list, followed by the keyword ‘assert’, a condition list, and terminated by a semicolon.

Examples:

assert (exists num = parseFloat(numText));
"Weight cannot be negative" assert (weight >= 0);

An assignment expression.

Right-associative.

Examples:

i = 1
text = "Hello, ``name else "World"``!"

An assignment expression.

Right-associative.

This is the abstract superclass of all assignment operations, with operators like =, +=, &=, etc. Not to be confused with AssignOperation, the concrete class for = expressions!

An assignment expression statement, that is, an assignment terminated by a semicolon.

In principle, a statement like i = 0; could be parsed ambigously, either as an assignment statement or as a specification. When possible, the Ceylon language favors the latter interpretation, which means that an assignment statement where the target is a BaseExpression is invalid. (This is only true for simple AssignOperations; other assignment operations, e. g. i += size;, are still valid assignment expression statements.)

Examples:

text.length += added.length;
ret.endToken = tokens.token(";", semicolon);

An “atomic” expression.

While atoms can wrap and contain other expressions, they never consist of several expressions chained together without any wrapping. For example, in [1, 2, 3], the child expressions are wrapped in the surrounding brackets; in 1.add, however, the child expressions are not wrapped. Therefore, a Tuple is an atom, while a QualifiedExpression isn’t.

An unqualified identifier with an optional list of type arguments.

A base expression can refer to either:

• a toplevel function, value, or class,
• a function, value, or class in the current scope, or
• a function, value, or class in the current block.

Examples:

null
max<Integer,Nothing>

A base metamodel expression, that is, a member name with optional type arguments, surrounded by backticks.

(A type name with optional type arguments surrounded by backticks is a TypeMeta.)

Examples:

`sum<Float>`
`system`

A type name with optional type arguments.

A binary operator expression.

Binary operations can be left-associative (a X b X c means (a X b) X c) or right-associative (a X b X c means a X (b X c)). To represent this in the type system, the left and right children of concrete classes usually have different types: One has the type of the current precedence level (see the PrecedenceXOperation aliases), one has the type of the precedence level below.

(Some binary operations have no precedence because they can’t be nested (for example, a == b == c is never allowed); in this case, both children have the type of the precedence level below.)

A list of statements and declarations, surrounded by braces.

A block contains imperative code, a series of statements that is executed sequentially each time the block is entered (declarations can’t be executed). It may also return a value.

Examples (multi-line):

{
    print("``indent``BEGIN ``that``");
    value origIndent = indent;
    indent += indentLevel;
    that.visit(this);
    indent = origIndent;
    print("``indent``END ``that``");
}
{
    throw AssertionError("Not yet implemented!");
}
{
    if (exists first = s.first) {
        return String { first.lowercased, *s.rest };
    } else {
        return "";
    }
}

A list of statements and declarations, surrounded by braces.

Examples:

{}
{ shared String name; string => name; }

A boolean condition, that is, an expression.

The condition is satisfied when the expression evaluates to true.

Examples:

type in { type_ws, type_comment }
literals.size == expressions.size + 1

A lower or upper bound of a bounded comparison operation.

A break directive.

A callable parameter.

Examples:

Comparison comparing(Element left, Element right)
void onSuccess()

A callable type, that is, a shortcut for SimpleType(TypeNameWithTypeArguments(UIdentifier("Callable"), [returnType, TupleType(argumentTypes)])).

Examples:

Integer(Integer,Integer)
String(Character*)

A ‘case’ clause of a ‘switch’ statement (SwitchCaseElse), that is, the keyword ‘case’, followed by a case item enclosed in parentheses and a CaseClause.block.

Examples (multi-line):

case (is String) {
    int = parseInteger(val);
}

case (null) { return; }

A ‘case’ item from a ‘case’ clause (CaseClause).

Examples:

is String
0, 1

A nonempty list of case types, separated by the union operator (‘|’).

Examples:

of String | Float | Integer
of Other
of empty | [Element+]

A ‘catch’ clause, that is, the keyword ‘catch’, followed by a CatchClause.variable (enclosed in parentheses) and a CatchClause.block.

Examples (multi-line):

catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
}

catch (e) {
    console.error(e);
}

Builds a Ceylon expression string for an AST node; compiling and evaluating the resulting string will yield a copy of the transformed node.

Usage:

myNode.transform(CeylonExpressionTransformer());

A character literal consists of a single character or an escape sequence.

Note: in contrast to IntegerLiteral and FloatLiteral, the value of CharacterLiteral.text isn’t verified, and there is no attribute to get the Character value of the literal; getting that value requires unicode support (to parse \{CHARACTER NAME}) that isn’t available on all platforms.

A class alias definition.

A class alias definition has the following components:

• ClassAliasDefinition.annotations,
• the ‘class’ keyword,
• the ClassAliasDefinition.name,
• the type parameters, if present,
• the ClassAliasDefinition.parameters,
• the case types, if present,
• the extended type, if present,
• the satisfied types, if present,
• the type constraints, if present,
• the ClassAliasDefinition.specifier, and
• a terminating semicolon.

(While semantically, a class alias may never have case types or extend or satisfy other types, these nodes may syntactically still be present.)

Examples:

shared class VariadicString(Character* characters) => String(characters);
shared class MemberName(String name) => LIdentifier(name);

A list of statements and declarations, surrounded by braces.

Logically, a class body is divided into two sections:

• An initializer section, mixing statements and declarations, and
• a declaration section, containing only statements.

There is, however, no syntactical separation between these, so syntactically a class body looks exactly like a Block.

Examples (multi-line):

{
    shared formal Float x;
    shared formal Float y;
    shared actual default Float distance(Point other) => ((x-other.x)^2 + (y-other.y)^2)^0.5;
}
{
    if (token != secret) {
        throw AssertionError("You may not instantiate this class!");
    }
    shared void hack(Anything victim) {
        ████ ███████ ██ █;
    }
}

A class reference expression, that is, the ClassDec.name of a class or anonymous class, optionally qualified by a ClassDec.qualifier (separated from it by a member operator ‘.’), prefixed by the type keyword class and surrounded by backticks.

The ClassDec.name may be an LIdentifier to refer to the class declaration of an anonymous class. For example, in

value dec1 = `class null`;
value dec2 = `value null`;

dec1 refers to the anonymous class of the null object, while dec2 refers to the only instance of that class, the null object itself.

Examples:

`class String`
`class A.B.C`

A class definition.

A class definition has the following components:

• ClassDefinition.annotations,
• the ‘class’ keyword,
• the ClassDefinition.name,
• the type parameters, if present,
• the ClassDefinition.parameters,
• the case types, if present,
• the extended type, if present,
• the satisfied types, if present,
• the type constraints, if present, and
• the ClassDefinition.body.

Examples (multi-line):

shared class PrintableWrapper<T>(shared T wrapped)
        satisfies Printable {
    shared actual void print() {
        package.print(wrapped else "<null>");
    }
}

shared class Counter(Integer initialCount=0) {

    variable Integer n = initialCount;

    shared Integer count => n;

    shared void increment() => n++;
}

A class instantiation, used in an extends clause and in a class alias.

(This node is only used as child of ExtendedType and ClassSpecifier; for normal instantiations of a class, use a regular Invocation with a BaseExpression for the class name.)

The class name may optionally be qualified with super..

Examples:

Node()
super.Entry<Key, Item>(key, item)

A class or interface declaration.

Examples (multi-line):

shared class PrintableWrapper<T>(shared T wrapped)
        satisfies Printable {
    shared actual void print() {
        package.print(wrapped else "<null>");
    }
}

shared interface 3DSized<Unit>
        given Unit satisfies Numeric<Unit> {
    shared formal Unit width;
    shared formal Unit length;
    shared formal Unit height;
}

A class specifier for a class alias, that is, a lazy specification operator ‘=>’ followed by a class instantiation.

Examples:

=> String(characters)
=> Entry<String,Item>(name, item)

A closed lower or upper bound of a bounded comparison operation.

In a closed bound, the ClosedBound.endpoint is a part of the designated interval; therefore, the minimum / maximum value of the interval is the endpoint.

A compare expression.

No associativity.

Examples:

first <=> last
n <=> 0

This is the concrete class for expressions like first <=> last; not to be confused with ComparisonOperation, the abstract superclass of expressions like a <= b and x > 3!

A comparison expression.

No associativity.

This is the abstract superclass of expressions like a <= b and x > 3; not to be confused with CompareOperation, the concrete class representing expressions like first <=> second!

A regular compilation unit, containing toplevel type, value, or function definitions.

This is the most commonly used type of compilation unit, and the basic “container” for your declarations.

Examples:

void run() {
    print("Hello, World!");
}

// end of example, start of next example

import ceylon.collection {
    SetMutator
}

MyPlugin myPlugin = MyPlugin(); // only instance

register
shared void registerMyPlugin(SetMutator<Plugin> registry)
    => registry.put(myPlugin);

A complement assignment operation.

Right-associative.

Examples:

people ~= kids
elements ~= otherElements

A set complement expression.

Defined via Set.complement(). Left-associative.

Examples:

receivers~blocked
primes ~ HashSet { 2 }

A comprehension, that is, a chain of comprehension clauses, beginning with an InitialComprehensionClause and terminated by an ExpressionComprehensionClause.

Examples:

for (people in peoples) for (person in people) if (person.age >= age) person
if (exists typeArguments = that.typeArguments) for (typeArgument in typeArguments) typeArgument.type

A comprehension clause, one component of a Comprehension.

Examples:

for (person in people) if (person.age > 18) person.age
if (isPrime(i)) i

A condition.

There are four kinds of conditions:

• a boolean condition is satisfied when a boolean expression evaluates to true,
• an assignability condition is satisfied when a value satisfies a specified type,
• an existence condition is satisfied when a value is not null, and
• a nonemptiness condition is satisfied when a sequential value is not null and not empty.

Examples:

exists first = string.first
type in { type_ws, type_comment }
is Float number
nonempty members

A comma-separated list of one or more Conditions.conditions, enclosed in parentheses.

Examples:

(nonempty elems = that.elements, elems.first == expected)
(is Integer num = obj.num, is Integer num2 = obj2.num, num == num2)

A continue directive.

A control structure statement, used to control normal execution flow.

(An assertion failure is not considered as “normal” control flow; therefore, an Assertion is not a control structure.)

Examples:

if (exists elem = queue.take) { process(elem); }
for (i in 1:12) { print(month(i)); }

A reference expression, that is, a detyped reference to a program element.

Reference expressions may refer to:

• a class, interface, alias, or type parameter (TypeDec)
• a function or value (MemberDec)
• a package or module (PackageDec, ModuleDec).

Not to be confused with Meta, which represents a typed reference. Simply speaking, if there’s a keyword (`class String`, `value system`), then it’s a Dec, otherwise it’s a Meta.

Reference expressions are often used in annotations, e. g. see().

A qualifier for a Dec, that is, either a period-separated sequence of one or more type names, or exactly one member name.

Examples:

process
Entry

A declaration.

Most declarations either define or have a type.

The general order of the children of a declaration is as follows:

Annotations
(Modifier | Type) Identifier TypeParameters? Parameters*
CaseTypes? ExtendedType? SatisfiedTypes?
TypeConstraints?
(Body | AnySpecifier? ";")

However, the only children common to all declarations are the Declaration.name of the declared program element and its Declaration.annotations.

Examples:

shared actual String string => "``outer.string`` by ``step``";
shared class Person(shared String name) { string => name; }

A callable parameter, along with a default implementation for the parameter.

Examples:

Float weight(Item item) => item.cost
void log(String message) => process.writeErrorLine(message);

A defaulted parameter.

Examples:

length = text.size
Comparison comparing(Element x, Element y) => x.hash <=> y.hash

The name of a parameter declared in the body of the function or class, along with a default value for the parameter.

Examples:

length = text.size
status = ok

A defaulted type.

Examples:

String=
Integer->String=

A value parameter, along with a default value for the parameter.

Examples:

Integer length = text.size
Boolean discounted = false

A difference expression.

Defined via Invertible.minus(). Left-associative.

Examples:

size - 1
lastIndex - firstIndex

A control directive, terminated by a semicolon.

There are four kinds of control directives:

• the return (Return) directive, to return a value or terminate execution,
• the throw (Throw) directive, to raise an exception,
• the break (Break) directive, to terminate a loop, and
• the continue (Continue) directive, to jump to the next iteration of a loop.

Examples:

return ret;
throw AssertionError("Not implemented yet!"); // TODO implement
break;
continue;

A divide assignment operation (/=).

Right-associative.

Examples:

width /= 2
amount /= exchangeRate

A dynamic block, that is, a DynamicBlock.block prefixed by the keyword ‘dynamic’.

Examples (multi-line):

dynamic {
    setTimeout(\iMath.random() * 1000, () => print("A message from the past"));
}

dynamic {
    console.log("Direct console access");
    console.dir(this); // I wonder what this looks like
}

A dynamic interface definition.

A dynamic interface definition has the following components:

• DynamicInterfaceDefinition.annotations,
• the dynamic keyword,,
• the DynamicInterfaceDefinition.name,
• the type parameters, if present,
• the case types, if present,
• the satisfied types, if present,
• the type constraints, if present, and
• the DynamicInterfaceDefinition.body.

Examples (multi-line):

shared dynamic Document {
    shared formal String xmlVersion;
    shared formal StyleSheetList styleSheets;
    shared formal String documentURI;
    // ...
}

shared dynamic Promise {
    shared formal Promise \ithen(void onFulfilled(dynamic result) => noop(), void onRejected(dynamic error) => noop());
    shared formal Promise catch(void onRejected(dynamic error) => noop());
}

A ‘dynamic’ modifier keyword.

A dynamic value expression, that is, the keyword ‘dynamic’ followed by any number of named arguments and a (possibly empty) argument list, enclosed in brackets.

Examples:

dynamic [ error = 404; message = "not found"; ]
dynamic [ ]

An element or subrange access expression, that is, a target ElementOrSubrangeExpression.primary followed by a ElementOrSubrangeExpression.subscript surrounded with brackets.

Examples:

text[start...]
map[key]

An ‘else’ clause of a ‘switch’ statement (SwitchCaseElse).

(This is not quite the same thing as an ElseClause, since in an ElseCaseClause ‘else if’ is not allowed.)

Examples (multi-line):

else {
    throw AssertionError("Unknown type!");
}

else {
    items.add(null);
}

An else clause, that is, the keyword ‘else’, followed by a block or another if/else conditional.

Examples (multi-line):

else {
    return "<null>";
}

else if (exists div) {
    visit(div.paragraphs);
}

An “else” operation.

Left-associative.

Examples:

0 <= val <= 10 then priority(val) else invalid
parseInteger(input) else 0

An entry expression.

Defined via Entry. No associativity.

Examples:

"1"->1
name->Person(name)

An entry type, that is, a shortcut for TypeNameWithTypeArguments(TypeName(UIdentifier("Entry")), [left, right]).

Examples:

String->Integer
Printable&Persistent&Identifiable->Handle

An equals expression.

Defined via Object.equals(). No associativity.

Examples:

length == 1
first == last
parseInteger(input) == 0

An expression to test for identity or (in)equality of two objects.

This is the abstract superclass of the nodes for ==, !=, ===; not to be confused with EqualOperation, the concrete class for ==!

An existence condition, that is, the keyword ‘exists’, followed by either an (optionally typed) specified variable or an (untyped) member name.

Examples:

exists name
exists firstItem = first?.item

A postfix existence test expression.

No associativity.

Examples:

element exists
parseInteger(text) exists

An existence or nonemptiness condition, that is, the keyword ‘exists’ or ‘nonempty’, followed by either an (optionally typed) specified variable or an (untyped) member name.

Examples:

nonempty employees
exists String name = person.name

An exponentiation expression.

Defined via Exponentiable.power(). Right-associative.

Examples:

sideLength^dimension
e^x

Abstract superclass of all expression nodes.

Correct operator precedence and associativity is enforced by the parameter types of the various child classes. For example, consider the following simple expression:

1 + 2 * 3

Because multiplication has higher precedence than addition, the correct syntax tree for this expression is:

SumOperation {
    leftOperand = IntegerLiteral("1");
    rightOperand = ProductOperation {
        leftOperand = IntegerLiteral("2");
        rightOperand = IntegerLiteral("3");
    };
}

A very simple, strictly left-associative parser that doesn’t respect operator precedence might instead try to produce:

ProductOperation {
    leftFactor = SumOperation {
        leftSummand = IntegerLiteral("1");
        rightSummand = IntegerLiteral("2");
    };
    rightFactor = IntegerLiteral("3");
}

However, this is not well-typed (the parser would likely have an assertion failure at runtime), because the types of ProductOperation’s child nodes are crafted such that only nodes with correct precedence and associativity can be created.

To ensure this, there is one type alias for each precedence level, specified as the union type of

• the next higher level’s alias, and
• all operator types on this level.

For example, there is MultiplyingExpression for multiplicative expressions and AddingExpression for summative expressions. ProductOperation.leftFactor then has type MultiplyingExpression, which does not include SumOperation. ProductOperation.rightFactor has the next higher level’s type UnioningExpression, reflecting the left-associativity of product operations: Instead of

ProductOperation {
    leftFactor = IntegerLiteral("1");
    rightFactor = ProductOperation {
        leftFactor = IntegerLiteral("2");
        rightFactor = IntegerLiteral("3");
    };
}

you should have

ProductOperation {
    leftFactor = ProductOperation {
        leftFactor = IntegerLiteral("1");
        rightFactor = IntegerLiteral("2");
    };
    rightFactor = IntegerLiteral("3");
}

These aliases are, from highest to lowest precedence:

• PrePostfixingExpression
• ExponentiatingExpression
• InvertingExpression
• IntersectingExpression
• UnioningExpression
• MultiplyingExpression
• ScalingExpression
• AddingExpression
• SpanningExpression
• ExistsNonemptyExpression
• ComparingExpression
• EquatingExpression
• NegatingExpression
• ConjoiningExpression
• DisjoiningExpression
• ThenElseExpression
• AssigningExpression

An expression that terminates a comprehension.

Examples:

person.age
i

All node types in the expression sub-hierarchy: Expression and some auxiliary node types that aren’t proper Expressions.

An expression statement, that is, an expression terminated by a semicolon.

Only certain expressions are valid statements:

• assignment (but see below),
• prefix or postfix increment or decrement, and
• invocation (or instantiation).

Be aware that very simple assignments are specifications; an AssignmentStatement where the target of the AssignOperation is a BaseExpression is invalid.

Examples:

text.length += added.length;
i++;
print("Hello, World!");

An ‘extends’ clause for a class definition.

Examples:

extends Node()
extends super.Entry<Key, Item>(key, item)

An ‘else’ failure clause for a ‘for’ loop (ForFail), that is, the keyword ‘else’ followed by a FailClause.block.

Examples:

else { print("Hello, World!"); }

A ‘finally’ clause, that is, the keyword ‘finally’ followed by a FinallyClause.block.

Examples:

finally { print("END"); }
finally { workers.collect(Worker.kill); }

A floating point literal is distinguished from an integer literal (IntegerLiteral) by the presence of fractional digits or a fractional magnitude.

A ‘for’ clause, that is, the keyword ‘for’ followed by an ForClause.iterator and a ForClause.block.

(Not to be confused with a complete ‘for’ loop (ForFail), which also includes an optional failure clause.)

Examples:

for (person in people) { print(person.name); }
for (name->person in peopleByName) { print("``name``: ``person.age``"); }

A ‘for’ comprehension clause, also known as a quantifier clause.

A ‘for’ comprehension clause consists of the keyword ‘for’, an ForComprehensionClause.iterator and a following ForComprehensionClause.clause.

Examples:

for (person in people) "``person.firstName`` ``person.lastName``"
for (people in peoples) for (person in people) if (person.age >= 18) person

A ‘for’ loop with an optional failure clause, that is, a ‘for’ clause (forClause), optionally followed by an ‘else’ failure clause (failClause).

Examples (multi-line):

for (i in 1:12) {
    print(month(i));
}

for (person in people) {                                  
    if (!person.greeted) {
        print("Hello, ``person.name``!");
        break;
    }
} else {
    print("Hello, World!");
}

An iterator for a ‘for’ loop, enclosed in parentheses.

Examples:

(person in people)
(name->person in peopleByName)

A full package name, that is, a period-separated list of lowercase identifiers.

Examples:

ceylon.language
ceylon.ast.core

An inline function argument definition.

Examples (multi-line):

void onClick() {
    DialogBox { message = "Hello!"; parent = this; }.show();
}

void onError(dynamic err)
        => console.error(err);

A function reference expression, that is, the FunctionDec.name of a function or method, optionally qualified by a FunctionDec.qualifier (separated from it by a member operator ‘.’), prefixed by the member keyword function and surrounded by backticks.

Examples:

`function concatenate`
`function Iterable.chain`

A function declaration.

A function declaration declares the FunctionDeclaration.name, FunctionDeclaration.type, parameters,
type parameters and type constraints of the value, but doesn’t provide a FunctionDeclaration.definition for it. There are several possible reasons for this:

• The function can be a formal() method of an abstract() class or an interface, and subtypes have to provide the definition.
• The function can be the declaration of a class or function parameter that only listed the name.
• The function can be forward-declared, and the definition will be provided later.

In any case, the declaration must explicitly specify a type; a ‘function’ modifier (FunctionModifier) indicating type inference cannot be used. (The ’dynamic’ modifier counts as a “type” here, indicating not the inference, but rather the absense of typing information.)

A function definition, using a block.

Exampes (multi-line):

shared void run() {
    print("Hello, `` process.arguments.first else "World" ``!");
}
shared actual Boolean equals(Object that) {
    if (is Color that) {
        return red == that.red && green == that.green && blue == that.blue;
    } else {
        return false;
    }
}

An expression that returns a callable function.

Unlike value expressions, function expressions don’t return instances of classes.

Examples (multi-line):

(String? name) => name else "John Doe"

(String string) {
    value mid = string.size / 2;
    return [string[...mid], [string[mid+1...]];
}

A ‘function’ modifier keyword.

The ‘function’ modifier keyword indicates that the type of a function is inferred.

A function shortcut definition, using a lazy specifier and terminated by a semicolon.

Examples:

shared void run() => print("Hello, `` process.arguments.first else "World" ``!");
shared actual Boolean equals(Object that) => that is This;

A type parameter reference expression, that is, the name of a type parameter, prefixed by the type keyword given and surrounded by backticks.

Note that the type parameter may not be qualified (i. e., `given Entry.Key` is not allowed), because a type parameter is not considered visible outside the declaration with the type parameter. For more information, see ceylon/ceylon-spec#1002.

A grouped, or parenthesized expression.

Examples:

(1 + 2) * 3
"Hello, " + (process.arguments.first else "World")

A type, grouped in angle brackets to resolve lexical ambiguity:

String->String[]

is parsed as

Entry<String,String[]>

To get

Entry<String,String>[]

you need to write

<String->String>[]

An identity test operation.

Defined natively, on objects that satisfy Identifiable. No associativity.

Examples:

node === rootNode
this === zero

The expression +i.

This expression is defined to return i for any i of Invertible type.

(Not to be confused with IdenticalOperation, i === i.)

An if clause, that is, the keyword ‘if’, followed by a condition list and a IfClause.block.

Examples:

if (15 <= estimatedAge <= 25) { askForID(); }
if (exists elseClause = that.elseClause) { elseClause.visit(this); }

An ‘if’ comprehension clause, also knows as a filter clause.

An ‘if’ comprehension clause consists of the keyword ‘if’, a condition list and a following IfComprehensionClause.clause.

Examples:

if (person.age >= 18) person
if (exists typeArguments = that.typeArguments) for (typeArgument in typeArguments) typeArgument.type

An if/else conditional.

The conditional begins with an if clause (ifClause) and may then optionally be followed by a chain of if/else clauses, optionally terminated by an else clause.

Examples (multi-line):

if (exists p = paragraphs.first) {
    setupAnchor(p);
    paragraphs.collect(output);
} else if (exists div) {
    visit(div.paragraphs);
} else {
    outputEmpty();
}

if (text.size >= terminalWidth) {
    print(text);
} else if (text.size >= remainingWidth) {
    wrap();
    print(text);
    remainingWidth = terminalWidth - text.size;
} else {
    print(text);
    remainingWidth -= text.size;
}

An import statement, that is, the keyword ‘import’ followed by the package name and the imported Import.elements from the package.

Examples:

import ceylon.ast.core { ... }
import java.lang { JString=String, System { sysout=\iout } }
import ceylon.collection { ArrayList, MutableList }

An import alias, that is, an identifier followed by an “equals” character.

(Not to be confused with an alias declaration like alias TypeName => UIdentifier;.)

Examples:

JString=
sysout=

A single import element, that is, the name of an imported program element,
optionally preceded by an alias and/or followed by nested import elements.

Examples:

HashMap
ln=log
System { sysout=out }

A comma-separated list of import elements, where the last element may optionally be a wildcard instead, surrounded by braces.

Import elements may not be empty.

(ceylon.ast ImportElements are slightly different from the specification’s ImportElements; in the specification, the surrounding braces are always part of the “parent” node (Import, ImportTypeElement), while in ceylon.ast, they are part of the ImportElements.)

Examples:

MutableList, ArrayList
JString=String, System { sysout=out }

A function or value import alias, that is, a lowercase identifier followed by an “equals” character.

Examples:

sysout=
ln=

A single function or value import element, that is, the name of an imported function or value, optionally preceded by a type alias.

Examples:

ln=log
sysout=out

A type import alias, that is, an uppercase identifier followed by an “equals” character.

Examples:

JString=
Char=

A single type import element, that is, the name of an imported type, optionally preceded by a type alias and/or followed by nested import elements to import and rename members.

Examples:

HashMap
System { sysout=out }

An import wildcard, that is, three colons (‘...’).

Used to indicate that all elements from a package should be imported.

An ‘in’ modifier, indicating a contravariant type parameter or argument.

A containment test expression.

Defined via Category.contains().

Examples:

digit in (0..9 by 2)
user in authorizedUsers
input in { "yes", "no" }

The containment operation is special because the receiver of the method invocation by which it is defined is the right-hand side, not the left-hand side. In other words, lhs in rhs corresponds to

rhs.contains(lhs)

while e. g. lhs * rhs corresponds to

lhs.times(rhs)

(the qualifier and argument swapped places).

A comprehension clause that can start a comprehension. Examples: for (person in people) “person.firstName person.lastName”

if (exists typeArguments = that.typeArguments) for (typeArgument in typeArguments) typeArgument.type

A named argument that defines a getter, function, or anonymous class, and assigns it to a parameter.

Examples (multi-line):

void onSuccess(Result result) {
    print(result);
    logger.end(currentTask, result);
}

object destroyable satisfies Destroyable {
    shared actual void destroy(Anything error) => process.exit(1);
}

An integer literal may be expressed in decimal (no prefix), hexadecimal (prefix ‘#’) or binary (prefix ‘$’) notation. Integer literals may be grouped with underscores, and may contain a magnitude.

An interface alias definition.

An interface alias definition has the following components:

• InterfaceAliasDefinition.annotations,
• the ‘interface’ keyword,
• the InterfaceAliasDefinition.name,
• the type parameters, if present,
• the case types, if present,
• the satisfied types, if present,
• the type constraints, if present,
• the InterfaceAliasDefinition.specifier, and
• a terminating semicolon.

(While semantically, an interface alias may never have case types or satisfy other types, these nodes may syntactically still be present.)

Examples:

shared interface People => {Person*};
shared interface Compare<Value> => Comparison(Value,Value);

A list of declarations, surrounded by braces.

Unlike class bodies, interface bodies can’t immediately contain runnable code, so the InterfaceBody.content is just declarations, no statements.

Examples (multi-line):

{
    shared formal Other plus(Other other);
}
{
    shared default void writeString(String string) => print(string);
    shared default void write(Anything that) => writeString(that?.string else "<null>");
}

An interface reference expression, that is, the InterfaceDec.name of an interface, optionally qualified by a InterfaceDec.qualifier (separated from it by a member operator ‘.’), prefixed by the type keyword interface and surrounded by backticks.

Examples:

`interface Iterable`
`interface A.B.C`

A regular interface definition.

An interface definition has the following components:

• InterfaceDefinition.annotations,
• the interface keyword,
• the InterfaceDefinition.name,
• the type parameters, if present,
• the case types, if present,
• the satisfied types, if present,
• the type constraints, if present, and
• the InterfaceDefinition.body.

Examples (multi-line):

shared interface Printable {
    shared default void print() => package.print(this);
}

shared interface Numeric<Other> of Other
        satisfies Invertible<Other>
        given Other satisfies Numeric<Other> {
    shared formal Other times(other);
    shared formal Other divided(other);
}

An intersect assignment operation.

Right-associative.

Examples:

people &= authorizedUsers
commonElements &= elements

A set intersection expression.

Defined via Set.intersection(). Left-associative.

Examples:

persistents&printables&identifiables
x1&y1

An intersection type.

Examples:

Element&Identifiable
Persistent&Printable&Identifiable

An invocation, that is, an invoked expression with an argument list.

Examples:

print("Hello, World!")
process.kill()
ArrayList { initialCapacity = 100; 1, 1 }

An invocation statement, that is, an invocation terminated by a semicolon.

(The invocation can also be an instantiation invocation.)

Examples:

print("Hello, World!");
that.visitChildren(this);

A ‘case’ item to test the type of the switch expression.

Examples:

is String
is Persistent&Serializable
is Integer|Float

An assignability condition, that is, the keyword ‘is’, followed by an (optionally specified) typed variable and optionally prefixed by a negation operator ‘!’.

Examples:

is Integer|Float num
is Administrator user

A postfix assignability test expression.

No associativity.

Examples:

element is String|Integer
user is ExecutiveUser

An iterable object instantiation expression.

Examples:

{}
{ second, first, *rest.rest }

An iterable type, like {String*} or {}.

A key by which a Node’s additional information can be accessed.

A key / index subscript expression, to select an element from a Correspondence expression.

Examples:

key
offset + i

A key→value iterator for a ‘for’ loop, enclosed in parentheses.

Examples:

(name->person in peopleByName)
(index->char in text.indexed)

An initial lowercase identifier.

A “large as” expression.

No associativity.

A “larger than” expression.

No associativity.

A lazy specification statement, that is, a member name, optionally followed by one or more parameter lists, and specified by a lazy specifier.

Examples:

string => counter.string;
visitIdentifier(Identifier that) => names.put((names[that.name] else 0) + 1);

A lazy expression specifier, that is, an expression prefixed by a computation operator ‘=>’.

Examples:

=> text.uppercased
=> nothing

A literal is a single token that represents a Unicode character, a character string, or a numeric value.

A modifier that indicates type inference.

It can only be used on local definitions (not toplevel, not shared), hence the name.

A logical assignment expression.

Right-associative.

A logical binary operation expression.

“Main” types: the types that you normally use.

This class is used as “Type, except EntryType” in EntryType and VariadicType, since both of these can’t have entry types as children. In other words, this class is only there to represent how types are parsed, not their semantics.

A ‘case’ item to test if the switch expression matches one or more expressions.

Examples:

null
0 | 1
null | smaller | larger

A measured range expression.

Defined via measure(). No associativity.

Examples:

0:size
today:14

A measure subscript, to select a (sub)range from a Ranged expression using the first index and MeasureSubscript.length.

Examples:

0:30
match.start:match.size

A member reference expression.

Examples:

`value null`
`function Iterable.map`

A member metamodel expression, that is, a MemberMeta.qualifier, followed by a member name with optional type arguments, surrounded by backticks.

(A qualifier followed by a type name with optional type arguments surrounded by backticks is a TypeMeta.)

Examples:

`Person.say`
`system.milliseconds`
`Iterable<String>.collect<Integer?>`

A member name and, optionally, type arguments.

A regular member operator, ‘.’.

A metamodel expression, that is, a typed reference to a type, class, function or value.

Examples:

`List<String>`
`sum<Float>`
`system.milliseconds`

Not to be confused with Dec, which represents a detyped reference. Simply speaking, if there’s a keyword (`class String`, `value system`), then it’s a Dec, otherwise it’s a Meta.

A modifier keyword.

Note: The Ceylon Language Specification also refers to certain annotations, e. g. shared(), abstract(), variable(), etc., as “modifiers” – see §7.4.1, Declaration Modifiers. In ceylon.ast, however, Modifier refers only to the reserved keywords that can be used on a function or value:

• void – VoidModifier
• dynamic – DynamicModifier
• function – FunctionModifier
• value – ValueModifier

A module descriptor body, that is, any number of module imports surrounded by braces.

(Because a module body can’t contain procedural code, this is not a subclass of Body. If a future version of Ceylon allows procedural code in a module body, then this may change.)

Examples:

{}
{ shared import ceylon.test "1.1.0"; }
{ import ceylon.collection "1.1.0"; }

A module descriptor compilation unit, containing a module descriptor.

Examples (separated by blank lines):

module tmp "1.0.0" {}

"Representation of a Ceylon AST in Ceylon."
by ("Lucas Werkmeister <mail@lucaswerkmeister.de>")
license ("http://www.apache.org/licenses/LICENSE-2.0.html")
module ceylon.ast.core "1.1.0" {
    import ceylon.collection "1.1.0";
}

A module reference expression, that is, the name of a module, prefixed by the keyword “module” and surrounded by backticks.

Examples:

`module ceylon.language`
`module ceylon.ast.core`

A module descriptor: a list of annotations, followed by the keyword ‘module’, and then the module ModuleDescriptor.name, ModuleDescriptor.version and ModuleDescriptor.body.

Examples (multi-line):

module tmp "1.0.0" {}

"Tests for the [[ceylon.ast.core module|module ceylon.ast.core]]"
by ("Lucas Werkmeister <mail@lucaswerkmeister.de>")
license ("http://www.apache.org/licenses/LICENSE-2.0.html")
module test.ceylon.ast.core "1.1.0" {
    shared import ceylon.test "1.1.0";
    import ceylon.ast.core "1.1.0";
}

An import of another module within a module descriptor.

Each module import consists of a list of ModuleImport.annotations, followed by the keyword ‘package’, the ModuleImport.name of the imported module, and the ModuleImport.version of the imported module, terminated by a semicolon.

Examples:

shared import ceylon.test "1.1.0";
import ceylon.collection "1.1.0";

A multiply assignment operation (*=).

Right-associative.

Examples:

balance *= 1 + interestRate

A name and, optionally, type arguments.

A named argument.

Examples:

name;
size = width * height;
Color color(Integer x, Integer y) => red;

A named argument list.

Any number of named arguments, followed by a (possibly empty) ordinary list of arguments.

Examples:

{}
{ name; size = width * height; }
{
    Head { title = pageTitle; }
    Body {
        for (paragraph in paragraphs)
            P(paragraph)
    }
}

An arithmetic unary negation operation, that is, -i.

This operator is defined in terms of Invertible.negated.

Abstract superclass of all AST nodes.

Note that nodes are not Identifiable: as they are immutable, the identity of a particular instance is meaningless.

Additional information

You can attach additional information to individual AST nodes using the Node.put() and Node.get() methods. Usage example:

// toplevel
shared Key<Token[]> tokensKey
    = ScopedKey<Token[]>(`module my.parser`, "tokens");

// in the parser
node.put(tokensKey, tokens);

// somewhere else
assert (exists tokens = node.get(tokensKey));

A nonemptiness condition, that is, the keyword ‘nonempty’, followed by either an (optionally typed) specified variable or an (untyped) member name.

Examples:

nonempty employees
nonempty persons = people.sequence()

A nonempty postfix expression.

No associativity.

A not equals expression.

Defined via Object.equals(). No associativity.

Examples:

uid != 0
process.arguments.length != 7

A logical not expression.

Right-associative.

Examples:

!n in primes
!predicate(element)

An object argument definition.

Examples (multi-line):

object destroyable satisfies Destroyable {
    shared actual void destroy(Anything error) => process.exit(1);
}

object items satisfies Iterable<Integer> {
    variable Integer accesses = 0;
    shared actual Iterator<Integer> iterator() => (0..(++accesses)).iterator();
}

An object definition.

Examples (multi-line):

shared object red extends Color(255, 0, 0) {
    string => "Red";
}

object stdoutWriter satisfies Writer {
    shared actual void close() => flush();
    shared actual void flush() {}
    shared actual void write(String string) {
        process.write(string);
    }
    shared actual void writeLine(String line) {
        process.writeLine(line);
    }
    shared actual void writeBytes({Byte*} bytes) {
        throw AssertionError("Can’t write bytes");
    }
}

A coverage expression.

Narrows or widens the type of an expression to another type that covers the expression type.

Defined natively. No associativity.

Examples:

thing of Object?
component.parent of Container?

An open lower or upper bound of a bounded comparison operation.

In an open bound, the OpenBound.endpoint is not a part of the designated interval; therefore, when dealing with real numbers, the interval has no minimum / maximum value, as you can get infinitely close to the endpoint without reaching it.

For example, in the interval 0 < x < 1, the values 0.9, 0.99, 0.999, etc. for x are all within the interval.

An operator expression.

Operations combine Primaries, as well as other operations, depending on precedence. Operator precedence and associativity is represented in the AST through the child types of the nodes; an AST that would violate associativity (for example, using a sum expression as the direct child of a product expression – without wrapping it in a GroupedExpression) isn’t well-typed.

(This class is called Operation rather than OperatorExpression to avoid overly long names of the subtypes; for the same reason, subtypes are only suffixed -Operation rather than -BinaryOperation or -UnaryOperation.)

An optional type, that is, a shortcut for UnionType(definiteType, nullType).

Examples:

String?
<String->Integer>?

A logical disjunction assignment expression.

Right-associative.

Examples:

permitted ||= backdoorTriggered
canPrint ||= networkPrinterPresent

A logical disjunction expression.

Left-associative.

Examples:

digit == 0 || digit == 1
element in errors || !element exists

An ’out’ modifier, indicating a covariant type parameter or argument.

The value of this expression is the current instance of the type which immediately contains the immediately containing type, and its type is assignable to that type.

As this class is completely stateless, you can reuse outerInstance instead of creating new instances of this class in order to save memory.

package isn’t actually an expression; it can be used to qualify and disambiguate a value or callable reference.

As this class is completely stateless, you can reuse packageInstance instead of creating new instances of this class in order to save memory.

A package descriptor compilation unit, containing a package descriptor.

Examples:

package tmp;
shared package ceylon.ast.core;

A package reference expression, that is, the name of a package, prefixed by the keyword “package” and surrounded by backticks.

Examples:

`package ceylon.language`
`package ceylon.ast.core`

A package descriptor: a list of annotations, followed by the keyword ‘package’, the package name, and terminated by a semicolon.

Examples:

package tmp;
"Test package" see (`package my.application`) package test.my.application;

A class, method, or function parameter.

Examples:

String name
comparing
Integer length = text.size
Element+ elements

The name of a parameter declared in the body of the function or class.

This is frequently used for class parameters, where having the documentation in the parameter list would clutter the parameter list.

Examples:

comparing
name

A parameter list.

Examples:

()
(String text, Integer length = text.size)
(Element+ elements)

A note about this class’ parameters

It would seem reasonable to instead declare the parameters of this class like this:

class Parameters(RequiredParameter[] required,
    DefaultedParameter[] defaulted,
    VariadicParameter|ParameterReference variadic)

Note that variadic must have the type VariadicParameter|ParameterReference, not just VariadicParameter, because a variadic parameter can also be just a reference, and declared in the body of the function or class. And this is where the problem comes in:

(param)

In this parameter list, is param a required or a defaulted parameter? In other words, is this

• a Parameters { required = [param]; }, or
• a Parameters { variadic = param; }?

To decide this, you need to look into the body of the function, and check if the declaration of param has a regular or a variadic type. This is a semantical distinction, not a syntactical one, and in general we can’t expect tools that operate on an AST to be able to make this distinction.

Instead, we have just one list of parameters; the separation into required, defaulted, and variadic ones may then be done in later stages of AST processing.

A positional argument list.

A list of arguments where the mapping from an argument to its parameter is based only on the position of the argument. Syntactically, this is just a wrapper for an ArgumentList, enclosed in parentheses.

Examples:

(x, y, *messages)
()
(for (i in 1..10) i^2)

A postfix decrement expression (i--).

A postfix increment expression (i++).

A postfix arithmetic expression, that is, i++ or i-- for any Primary i.

A prefix decrement expression (--i).

A prefix increment expression (++i).

A prefix arithmetic expression, that is, ++i or --i for any Primary i.

A prefix or postfix increment or decrement expression statement.

Examples:

i++;
--size;

A primary expression.

Primaries can be combined using operations.

A primary type; only intersection and union types come before these.

A product expression.

Defined via Numeric.times(). Left-associative.

A receiver expression, followed by a member operator (usually ‘.’) and an (unqualified) identifier with optional type arguments.

Examples:

", ".join
process.arguments.first
people*.name
sort(people, byAscending(Person.salary)).first?.salary

A qualified type, consisting of a qualifying type and a type name with arguments, separated by a member operator.

Foo.Bar // Foo is the qualifying type, Bar the type name
X<A>.Y<B>.Z<C> // X<A>.Y<B> is the qualifying type – another qualified type –, Z the type name and C the type arguments

A quotient or division expression.

Defined via Numeric.divided(). Left-associative.

A range subscript, to select a (sub)range from a Ranged expression.

Examples:

1 .. text.size - 2
1...

A remainder assignment operation (%=).

Right-associative.

Examples:

increment %= step

A remainder expression.

Defined via Integral.remainder(). Left-associative.

A required parameter (neither defaulted nor variadic).

Examples:

String name
comparing

A resource in a try-with-resources statement.

Examples:

lock
writer = file.Writer()

A comma-separated list of Resources.resources, surrounded by parentheses.

Examples:

(lock)
(reader = inFile.Reader(), writer = outFile.Writer())

A return directive, with an optional returned expression.

A nullsafe member operator, ‘?.’.

Technically, the nullsafe attribute operator and the nullsafe method operator are two different operators, since a nullsafe invocation is not the same as an invocation of a nullsafely accessed method attribute; however, that distinction is only semantical, not syntactical, and therefore does not belong in the AST.

A nonempty list of satisfied types, separated by the intersection operator (‘&’).

Examples:

satisfies {Element+}
satisfies Printable & Persistent

A scale expression.

Defined via Scalable.scale(). Right-associative.

Examples:

2 ** vector
brakeFactor ** velocity

The scale operation is special because the receiver of the method invocation by which it is defined is the right-hand side, not the left-hand side. In other words, lhs ** rhs corresponds to

rhs.scale(lhs)

while e. g. lhs * rhs corresponds to

lhs.times(rhs)

(the qualifier and argument swapped places).

A Key with an explicitly provided scope, to avoid name collisions.

this, super, outer and package are self reference expressions. The type of these expressions depends on the context in which they appear.

While these expressions are interesting from a typing perspective, their AST nodes are actually really boring and completely stateless. In order to save some memory, you can reuse thisInstance, superInstance, outerInstance and packageInstance instead of creating new instances every time.

A sequential type, that is, a shortcut for TypeNameWithTypeArguments(UIdentifier("Sequential"), [elementType]).

Examples:

String[]
<String->Integer>[]

A set assignment operation.

Right-associative.

A set operation: intersection, union or complement.

A simple type: One or more TypeNamesWithArguments, separated by member operators.

String
Iterable<String,Nothing>
Outer.Inner

The type of every instance can be written as a SimpleType.

A “small as” expression.

No associativity.

A “smaller than” expression.

No associativity.

A span-from subscript, to select a (sub)range from a Ranged expression using the first index.

Examples:

1...
match.start ...

A spanned range expression.

Defined via span(). No associativity.

Examples:

0..9 monday..friday first.successor..last.predecessor

A span subscript, to select a (sub)range from a Ranged expression using the first and last index.

Examples:

1 .. text.size - 2
text.size - 1 .. 0

A span-to subscript, to select a (sub)range from a Ranged expression using the last index.

Examples:

... text.size - 1
...count

A specification statement.

Examples:

offset = preamble.size + title.size;
debug(Anything a) => process.writeErrorLine(a);

A specified named argument, that is, a Specification.

Examples:

groupSeparators = false;
initialCapacity = 256;

A specified inline variable declaration.

Examples:

num = parseFloat(numString)
String name = person.name

An expression specifier, that is, an expression prefixed by a specification operator ‘=’.

Examples:

= 1
= nothing

A spread argument.

Used in argument lists to “spread” a sequential value over multiple arguments.

(The spread “operator” * looks like a prefix unary operator, but because it produces multiple values, not just one, a spread argument is not an expression.)

Examples:

*args
*values.collect(Object.string)
*[]

A spread member operator, ‘*.’.

Technically, the spread attribute operator and the spread method operator are two different operators, since a spread invocation is not the same as an invocation of a spread accessed method attribute; however, that distinction is only semantical, not syntactical, and therefore does not belong in the AST.

A statement.

Examples:

value name = person.name else "<unnamed>";
print("Hello, World!");

A string literal consists of a series of characters and/or, if it’s not verbatim, escape sequences.

Note: in contrast to IntegerLiteral and FloatLiteral, the value of StringLiteral.text isn’t verified, and there is no attribute to get the String value of the literal; getting that value requires unicode support (to parse '{CHARACTER NAME}') that isn’t available on all platforms.

A string template, that is, a string start, followed by any number of value expression and string mid pairs, followed by a value expression and a string end.

(The distinction between string starts, mids, and ends is a purely lexical one, and not covered in ceylon.ast.)

There must be at least one expression in a string template, and the number of string literals must be exactly the number of expressions plus one.

Examples:

"Elapsed: `` tEnd - tStart ``ms"
"Hello, ``person.firstName`` ``person.lastName``. How nice to see you back in ``person.homeTown``."

A subscript used to access an element or subrange in a ElementOrSubrangeExpression (where it is surrounded by brackets).

In mathematical notations, these accessors are usually written as subscript, e. g. x_i for the i^th x element.

Examples:

index
... text.size - 2

A subtract assignment operation (-=).

Right-associative.

Examples:

countdown -= \iΔt

A sum expression.

Defined via Summable.plus(). Left-associative.

Examples:

i + 1
firstIndex + size

The value of this expression is the current instance, and its type is the intersection of the immediate superclass and all immediate superinterfaces of the current class.

As this class is completely stateless, you can reuse superInstance instead of creating new instances of this class in order to save memory.

A switch/case/else statement, that is, a switch clause (clause), followed by SwitchCaseElse.cases.

Examples (multi-line):

switch (i.magnitude)
case (0, 1) { return false; }
case (2) { return true; }
else {
    return i % 2 == 1 && expensivePrimeTest(i);
}

switch (that)
case (is Block) { return transformBlock(that); }
case (is IfElse) { return transformIfElse(that); }

A list of ‘case’ clauses (with an optional trailing ‘else’ clause) for a switch statement (SwitchCaseElse).

Examples (multi-line):

case (is Block) { return transformBlock(that); }
case (is IfElse) { return transformIfElse(that); }

case (0, 1) { return false; }
case (2) { return true; }
else {
    return i % 2 == 1 && expensivePrimeTest(i);
}

A ‘switch’ clause of a switch statement (SwitchCaseElse), that is, the keyword ‘switch’, followed by an SwitchClause.expression enclosed in parentheses.

Examples:

switch (i.magnitude)
switch (child)

A “then” operation.

Left-associative.

Examples:

!name.empty then name
age != -1 then age

The value of this expression is the current instance, and its type is the immediately containing type.

As this class is completely stateless, you can reuse thisInstance instead of creating new instances of this class in order to save memory.

A throw directive, with an optional thrown exception.

A try-cA try/catch/finally statement, that is, a ‘try’ clause (tryClause), followed by any amount of ‘catch’ clauses (catchClauses), and optionally terminated by a ‘finally’ clause (finallyClause).

Examples (multi-line):

// removing a non-critical entity, e. g. when running low on resources
try (writer = file.Writer()) {
    that.serialize(writer);
} finally {
    despawn(that);
}

// a compilation controller
try (lock) {
    compilationUnit.compile(this);
} catch (CancellationException e) {
    // ignore
} catch (otherException) {
    log(otherException);
    compilationUnit.compiled = false;
}

A ‘try’ clause, that is, the keyword ‘try’, followed optionally by TryClause.resources and then by a TryClause.block (required).

Examples (multi-line):

try {
    value zombie = spawn { Zombie; center = player.location; spread = 50; };
    zombie.aggro = player;
}

try (writer = file.Writer()) {
    that.serialize(writer);
}

A tuple instantiation expression.

Examples:

[]     
[x, y]
[father, mother, *children]

A tuple type.

Examples:

[String,Integer,Integer]
[Float,Integer*]
[]

Representation of a type.

A type alias definition.

A type alias definition has the following components:

• TypeAliasDefinition.annotations,
• the ‘alias’ keyword,
• the TypeAliasDefinition.name,
• the type parameters, if present,
• the type constraints, if any,
• the TypeAliasDefinition.specifier, and
• a terminating semicolon.

Examples:

alias Primitive => Boolean|Integer|Float|Character|String|Null;
alias AnyMutableSet<Element> given Element satisfies Object => Set<Element>&SetMutator<Element>;

A type argument, that is, a TypeArgument.type with optional TypeArgument.variance (use-site variance).

(Use-site variance is only rarely used; most of the time, TypeArgument.variance should be null.)

Examples:

String
out T

A nonempty comma-separated list of type arguments, enclosed in angle brackets.

Examples:

<String,Nothing>
<out Element>

A constraint upon a type parameter.

Examples:

given Key satisfies Object
given Printable of String | Integer | Float
given T of T1|T2|T3 satisfies U

A type reference expression.

A type declaration.

Examples (multi-line):

shared interface Printable {
    shared default void print() {
        package.print(this);
    }
}

shared alias TypeName => UIdentifier;

All node types in the type sub-hierarchy: Type and some auxiliary node types that aren’t proper Types.

(For example, while String* is part of the valid type {String*}, it’s not a valid type by itself.)

A list of types, with an optional trailing variadic type.

Examples:

String, String, String+

A type metamodel expression, that is, a Type surrounded by backticks.

Examples:

`List<String>`
`Integer|Float`

A modifier that can be used instead of a type in some places.

This includes:

• the local modifiers ‘value’ and ‘function’, indicating type inference;
• the ‘void’ modifier, indicating that a function doesn’t return a value; and
• the ‘dynamic’ modifier, indicating absense of any typing information.

A type name and, optionally, type arguments.

A type parameter of a class, method or function.

The type parameter may optionally declare a type TypeParameter.variance (without one, it is invariant) and/or a default type argument (used when the use-site declares some but not all type arguments).

Examples:

out Element
out Absent=Null

A nonempty comma-separated list of type parameters, surrounded by angle brackets.

Examples:

<in Key, out Item>
<out Element>

A type specifier, that is, a type prefixed by a computation operator ‘=>’.

Examples:

=> Map<String,Person>
=> Comparison(Value,Value)

A declaration with a type.

The type can either be explicitly specified (TypedDeclaration.type is a Type) or inferred (TypedDeclaration.type is a Modifier that indicates type inference).

Examples:

shared String name;
shared actual void visit(Node that) { print(that); that.visitChildren(this); }

A typed inline variable declaration.

Examples:

Integer|Float num
String name

An initial uppercase identifier.

A unary arithmetic expression, that is, +i or -i.

An expression consisting of a ValueExpression, an operator, and possibly a Type.

These can be regular unary operations – either prefix or postfix – or unary type operations, which are always postfix, and include a type.

A unary operator expression.