Something that can readily be converted to a Body using the block(), classBody() or interfaceBody() utility functions.

Something that can readily be converted to an Identifier using the identifier() utility function.

Converts a string (or literal) and a stream of annotation names (or annotations) to Annotations.

Usage examples:

annotations { "shared", "actual" }
annotations {
    doc = "Determines if the stream is empty, that is to say, if 
           the iterator returns no elements.";
    "shared", "default"
}

A utility function to create a BaseExpression directly from a string, without having to use NameWithTypeArguments (a rather verbose name).

(The type arguments will all be invariant; if you want to use use-site variance, you have to construct the TypeArgument objects yourself.)

Usage examples:

baseExpression("null") // null
baseExpression("String") // String; not to be confused with baseType("String")!
baseExpression("emptyOrSingleton", "Integer") // emptyOrSingleton<Integer>

A utility function to create a BaseType directly from a string, without having to use TypeNameWithTypeArguments (a rather verbose name).

(The type arguments will all be invariant; if you want to use use-site variance, you have to construct the TypeArgument objects yourself.)

Usage examples:

baseType("String") // String
baseType("Sequence", "Integer") // Sequence<Integer>

Converts a stream of declarations and statements to a Block.

Converts a stream of primary types and anonymous class names to CaseTypes.

Usage examples:

caseTypes("Other") // self type constraint
caseTypes("true", "false")

Converts a stream of declarations and statements to a ClassBody.

Creates a class definition.

Usage example:

classDefinition {
    name = "MyClass";
    parameters = {
        ValueParameter {
            annotations = annotations { "shared", "actual" };
            type = baseType("String");
            name = lidentifier("string");
        }
    };
    caseTypes = { "CT1", "CT2" };
    extendedType = extendedType {
        "Super";
        IntegerLiteral("1"), baseExpression("string")
    };
    satisfiedTypes = { "Identifiable" };
    typeParameters = { "Element", "Absent" };
    annotations = annotations {
        "My class does something.

         It’s the most amazing class ever.";
        "shared"
    };

    functionDefinition {
        // ...
    },
    functionDefinition {
        // ...
    }
}

Creates a ClassInstantiation from its name, arguments, and optionally qualifier.

Keep in mind that ClassInstantiation appears only as child node of ExtendedType and ClassSpecifier, for which you should just use extendedType() / classSpecifier() instead. A normal class instantiation is just a regular Invocation.

Usage examples:

classInstantiation("Sup")
classInstantiation {
    name = "Point";
    baseExpression("x"),
    baseExpression("y")
}

Creates a ClassSpecifier from its name, arguments, and optionally qualifier.

Usage examples:

classSpecifier("Object")
classSpecifier {
    name = "Point";
    baseExpression("y"),
    baseExpression("x")
}

Creates an ExtendedType from its name, arguments, and optionally qualifier.

Usage examples:

extendedType("Sup")
extendedType {
    name = "Point";
    baseExpression("x"),
    baseExpression("y")
}

Creates a function definition.

Usage example:

functionDefinition {
    name = "myFunction";
    type = VoidModifier();
    parameters = {
        ValueParameter {
            type = baseType("String");
            name = lidentifier("name");
        }
    };
    typeParameters = { "Element" };
    annotations = annotations {
        "My function does something.

         It’s the most amazing function ever.";
        "shared", "actual", "default"
    };

    invocationStatement { invoked = "print"; StringLiteral("Hello, World!") }
}

Parses an identifier from its text. The text may contain the prefix, but no escape sequences.

Examples:

identifier("name")
identifier("S_``state``")

Converts a stream of declarations to an InterfaceBody.

Creates an interface definition.

Usage example:

interfaceDefinition {
    name = "MyInterface";
    caseTypes = { "CT1", "CT2" };
    satisfiedTypes = { "Identifiable" };
    typeParameters = { "Element", "Absent" };
    annotations = annotations {
        "My interface does something.

         It’s the most amazing interface ever.";
        "shared", "sealed"
    };

    functionDefinition {
        // ...
    },
    functionDefinition {
        // ...
    }
}

Creates an Invocation using positional arguments.

Usage example:

invocation {
    "printAll";
    StringLiteral("Hello, World!"), StringLiteral("Goodbye, World!")
}

Creates an InvocationStatement using positional arguments.

Usage example:

invocationStatement {
    "printAll";
    StringLiteral("Hello, World!"), StringLiteral("Goodbye, World!")
}

Utility function to create an LIdentifier, with prefix if and only if necessary.

Examples:

lidentifier("null")
lidentifier(attributeName)

Convenience function to create either a MemberNameWithTypeArguments or a TypeNameWithTypeArguments, depending on the kind of name.

A utility function to create PositionalArguments directly from a list of expressions, spread arguments and comprehensions, without having to use ArgumentList and having to wrap the listed arguments in a sequence.

Usage examples:

positionalArguments()
positionalArguments(thisInstance, SpreadArgument(baseExpression("others")))

Converts a type name to a PrimaryType.

This function is not intended for external use. Use baseType() or qualifiedType() instead. It exists only for use in other functions like caseTypes() and satisfiedTypes().

A utility function to create a QualifiedExpression directly from some strings, without having to use TypeNameWithTypeArguments (a rather verbose name).

(The type arguments will all be invariant; if you want to use use-site variance, you have to construct the TypeArgument objects yourself.)

Usage examples:

qualifiedExpression("x", "Y") // x.Y
qualifiedExpression(qualifiedExpression(baseExpression("process"), "arguments"), "first") // process.arguments.first

A utility function to create a QualifiedType directly from a string, without having to use TypeNameWithTypeArguments (a rather verbose name).

(The type arguments will all be invariant; if you want to use use-site variance, you have to construct the TypeArgument objects yourself.)

Usage examples:

qualifiedType("X", "Y") // X.Y
qualifiedType(qualifiedType(baseType("X", "A"), "Y", "B"), "Z", "C") //X<A>.Y<B>.Z<C>

Converts a stream of primary types to SatisfiedTypes.

Usage examples:

satisfiedTypes("Identifiable")
satisfiedTypes(baseType("MutableList", "Element"))

Utility function to construct a StringTemplate from an alternating list of string literals and expressions.

Using this function, you can list the string literals and expressions in exactly the order in which they appear in the string template (rather than separated into two sequences, as in StringLiteral), at the cost of some type safety.

A utility function to create TypeParameters from a stream of objects that can readily be converted to a TypeParameter.

Usage examples:

typeParameters("Other") // self type
typeParameters("Element") // invariant, e. g. MutableList
typeParameters(
    TypeParameter(UIdentifier("Element"), OutModifier()),
    TypeParameter(UIdentifier("Absent"), OutModifier(), baseType("Null"))
) // covariant, e. g. Iterable

Utility function to create an UIdentifier, with prefix if and only if necessary.

Examples:

uidentifier("Anything")
uidentifier(className)