Source Code

This module defines a bidirectional conversion between ceylon.ast and the RedHat compiler AST, as well as functions that directly compile code to ceylon.ast nodes using the RedHat compiler.

ceylon.ast → RedHat AST:

that.transform(RedHatTransformer(SimpleTokenFactory()))

RedHat AST → ceylon.ast:

compilationUnitToCeylon(that)

Code → ceylon.ast:

compileCompilationUnit(code)

For the latter two, there are also functions for (almost) every other node type, e. g. expressionToCeylon(), compileType(), etc.

All XToCeylon and compileX functions also take a second parameter:

Anything(JNode,Node) update = noop

This function is invoked once for every Node created with the original RedHat AST node (above aliased to JNode) and the new ceylon.ast Node as arguments. It can be used to copy information from the old AST to the new one, for example:

Key<Token[]> tokensKey = ScopedKey<Token[]>(`module`, "tokens");
value cu = compileCompilationUnit {
    code;
    void update(JNode orig, Node res) {
        res.set(tokensKey, [orig.mainToken, orig.mainEndToken].coalesced);
    }
};
// later
assert (exists tokens = cu.get(tokensKey));

The default is noop(), i. e., to do nothing. Another useful argument provided by this module is attachOriginalNode(), which allows you to later retrieve the original node from originalNodeKey:

value cu = compileCompilationUnit {
    code;
    update = attachOriginalNode;
};
// later
assert (exists orig = cu.get(originalNodeKey));
value tokens = [orig.mainToken, orig.mainEndToken].coalesced;
Platform: Java
By: Lucas Werkmeister
License: http://www.apache.org/licenses/LICENSE-2.0.html
Packages
ceylon.ast.redhat
Dependencies
ceylon.ast.core1.2.0
ceylon.interop.java1.2.0
com.redhat.ceylon.typechecker1.2.0
Values
originalNodeKeySource Codeshared Key<JNode> originalNodeKey

A key for attaching the RedHat AST Node from which a ceylon.ast Node was converted.

Functions
aIdentifierToCeylonSource Codeshared LIdentifier aIdentifierToCeylon(Tree.JIdentifier identifier, Anything(JNode, Node) update = ...)

Converts a RedHat AST Identifier with token type AIDENTIFIER to a ceylon.ast LIdentifier.

There’s no syntactical difference between annotation and lowercase identifiers, but they have different token types.

Parameters:
  • identifier
    • Need CommonToken to get length of token (!= text’s length for \iCONSTANT)

  • update = noop
Throws
aStringLiteralToCeylonSource Codeshared StringLiteral aStringLiteralToCeylon(Tree.JStringLiteral stringLiteral, Anything(JNode, Node) update = ...)

Converts a RedHat AST StringLiteral with annotation token type (ASTRING_LITERAL or AVERBATIM_STRING) to a ceylon.ast StringLiteral.

Parameters:
  • stringLiteral
    • is CommonToken token = stringLiteral.mainToken
  • update = noop
Throws
  • AssertionError

    If the token type is neither ASTRING_LITERAL nor AVERBATIM_STRING.

addAssignmentOperationToCeylonSource Codeshared AddAssignmentOperation addAssignmentOperationToCeylon(Tree.JAddAssignOp addAssignmentOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST AddAssignOp to a ceylon.ast AddAssignmentOperation.

Parameters:
  • addAssignmentOperation
    • Check precedence

  • update = noop
    • Check precedence

aliasDecToCeylonSource Codeshared AliasDec aliasDecToCeylon(Tree.JAliasLiteral aliasDec, Anything(JNode, Node) update = ...)

Converts a RedHat AST AliasLiteral to a ceylon.ast AliasDec.

Parameters:
  • aliasDec
    • is JBaseType|JQualifiedType jType = aliasDec.type
  • update = noop
andAssignmentOperationToCeylonSource Codeshared AndAssignmentOperation andAssignmentOperationToCeylon(Tree.JAndAssignOp andAssignmentOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST AndAssignOp to a ceylon.ast AndAssignmentOperation.

Parameters:
  • andAssignmentOperation
    • Check precedence

  • update = noop
    • Check precedence

andOperationToCeylonSource Codeshared AndOperation andOperationToCeylon(Tree.JAndOp andOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST AndOp to a ceylon.ast AndOperation.

Parameters:
  • andOperation
    • Check precedence

  • update = noop
    • Check precedence

annotationToCeylonSource Codeshared Annotation annotationToCeylon(Tree.JAnnotation annotation, Anything(JNode, Node) update = ...)

Converts a RedHat AST Annotation to a ceylon.ast Annotation.

Parameters:
  • annotation
    • is JBaseMemberExpression bme = annotation.primary
  • update = noop
annotationsToCeylonSource Codeshared Annotations annotationsToCeylon(Tree.JAnnotationList annotations, Anything(JNode, Node) update = ...)

Converts a RedHat AST AnnotationList to a ceylon.ast Annotations.

Parameters:
  • update = noop
anonymousArgumentToCeylonSource Codeshared AnonymousArgument anonymousArgumentToCeylon(Tree.JSpecifiedArgument anonymousArgument, Anything(JNode, Node) update = ...)

Converts a RedHat AST SpecifiedArgument to a ceylon.ast AnonymousArgument.

Warning: RedHat AST’s SpecifiedArgument is also used for true specified arguments; this function does not convert those and will throw an exception instead!

Parameters:
  • anonymousArgument
    • Must be anonymous

  • update = noop
anyClassToCeylonSource Codeshared AnyClass anyClassToCeylon(Tree.JAnyClass anyClass, Anything(JNode, Node) update = ...)

Converts a RedHat AST AnyClass to a ceylon.ast AnyClass.

Parameters:
  • anyClass
    • is JClassDefinition|JClassDeclaration anyClass
  • update = noop
anyCompilationUnitToCeylonSource Codeshared AnyCompilationUnit anyCompilationUnitToCeylon(Tree.JCompilationUnit anyCompilationUnit, Anything(JNode, Node) update = ...)

Converts a RedHat AST CompilationUnit to a ceylon.ast AnyCompilationUnit.

Parameters:
  • update = noop
anyFunctionToCeylonSource Codeshared AnyFunction anyFunctionToCeylon(Tree.JAnyMethod anyFunction, Anything(JNode, Node) update = ...)

Converts a RedHat AST AnyMethod to a ceylon.ast AnyFunction.

Parameters:
  • anyFunction
    • is JMethodDefinition|JMethodDeclaration anyFunction
  • update = noop
anyInterfaceDefinitionToCeylonSource Codeshared AnyInterfaceDefinition anyInterfaceDefinitionToCeylon(Tree.JInterfaceDefinition anyInterfaceDefinition, Anything(JNode, Node) update = ...)

Converts a RedHat AST InterfaceDefinition to a ceylon.ast AnyInterfaceDefinition.

Parameters:
  • update = noop
anyInterfaceToCeylonSource Codeshared AnyInterface anyInterfaceToCeylon(Tree.JAnyInterface anyInterface, Anything(JNode, Node) update = ...)

Converts a RedHat AST AnyInterface to a ceylon.ast AnyInterface.

Parameters:
  • anyInterface
    • is JInterfaceDefinition|JInterfaceDeclaration anyInterface
  • update = noop
anyMemberOperatorToCeylonSource Codeshared AnyMemberOperator anyMemberOperatorToCeylon(Tree.JMemberOperator anyMemberOperator, Anything(JNode, Node) update = ...)

Converts a RedHat AST MemberOperator to a ceylon.ast AnyMemberOperator.

Parameters:
  • anyMemberOperator
    • is JMemberOp|JSafeMemberOp|JSpreadOp anyMemberOperator
  • update = noop
anySpecifierToCeylonSource Codeshared AnySpecifier anySpecifierToCeylon(Tree.JSpecifierExpression anySpecifier, Anything(JNode, Node) update = ...)

Converts a RedHat AST SpecifierExpression to a ceylon.ast AnySpecifier.

Parameters:
  • update = noop
anyTypeArgumentsToCeylonSource Codeshared TypeArguments? anyTypeArgumentsToCeylon(Tree.JTypeArguments? typeArguments, Anything(JNode, Node) update = ...)

Converts RedHat AST TypeArguments to ceylon.ast TypeArguments or null.

Returns

  • typeArgumentsToCeylon(typeArguments, update) for a proper TypeArgumentList,
  • null for InferredTypeArguments or null.
Parameters:
  • typeArguments
    • is JTypeArgumentList|JInferredTypeArguments? typeArguments
  • update = noop
anyValueToCeylonSource Codeshared AnyValue anyValueToCeylon(Tree.JAnyAttribute anyValue, Anything(JNode, Node) update = ...)

Converts a RedHat AST AnyAttribute to a ceylon.ast AnyValue.

Parameters:
  • anyValue
    • is JAttributeDeclaration|JAttributeGetterDefinition anyValue
  • update = noop
argumentListToCeylonSource Codeshared ArgumentList argumentListToCeylon(Tree.JSequencedArgument argumentList, Anything(JNode, Node) update = ...)

Converts a RedHat AST SequencedArgument to a ceylon.ast ArgumentList.

(The RedHat AST ArgumentList does not correspond to the ceylon.ast ArgumentList!)

Parameters:
  • update = noop
argumentsToCeylonSource Codeshared Arguments argumentsToCeylon(Tree.JArgumentList arguments, Anything(JNode, Node) update = ...)

Converts a RedHat AST ArgumentList to a ceylon.ast Arguments.

Parameters:
  • arguments
    • is JPositionalArgumentList|JNamedArgumentList arguments
  • update = noop
arithmeticAssignmentOperationToCeylonSource Codeshared ArithmeticAssignmentOperation arithmeticAssignmentOperationToCeylon(Tree.JArithmeticAssignmentOp arithmeticAssignmentOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST ArithmeticAssignmentOp to a ceylon.ast ArithmeticAssignmentOperation.

Parameters:
  • arithmeticAssignmentOperation
    • is JAddAssignOp|JSubtractAssignOp|JMultiplyAssignOp|JDivideAssignOp|JRemainderAssignOp arithmeticAssignmentOperation
  • update = noop
arithmeticOperationToCeylonSource Codeshared ArithmeticOperation arithmeticOperationToCeylon(Tree.JArithmeticOp arithmeticOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST ArithmeticOp to a ceylon.ast ArithmeticOperation.

Parameters:
  • arithmeticOperation
    • is JPowerOp|JProductOp|JQuotientOp|JRemainderOp|JSumOp|JDifferenceOp arithmeticOperation
  • update = noop
assertionToCeylonSource Codeshared Assertion assertionToCeylon(Tree.JAssertion assertion, Anything(JNode, Node) update = ...)

Converts a RedHat AST Assertion to a ceylon.ast Assertion.

Parameters:
  • update = noop
assignOperationToCeylonSource Codeshared AssignOperation assignOperationToCeylon(Tree.JAssignOp assignOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST AssignOp to a ceylon.ast AssignOperation.

Parameters:
  • assignOperation
    • Check precedence

  • update = noop
    • Check precedence

assignmentOperationToCeylonSource Codeshared AssignmentOperation assignmentOperationToCeylon(Tree.JAssignmentOp assignmentOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST AssignmentOp to a ceylon.ast AssignmentOperation.

Parameters:
  • assignmentOperation
    • is JAssignOp|JArithmeticAssignmentOp|JBitwiseAssignmentOp|JLogicalAssignmentOp assignmentOperation
  • update = noop
assignmentStatementToCeylonSource Codeshared AssignmentStatement assignmentStatementToCeylon(Tree.JExpressionStatement assignmentStatement, Anything(JNode, Node) update = ...)

Converts a RedHat AST ExpressionStatement to a ceylon.ast AssignmentStatement.

Parameters:
  • assignmentStatement
    • is JAssignmentOp expression = assignmentStatement.expression.term
  • update = noop
atomToCeylonSource Codeshared Atom atomToCeylon(Tree.JAtom atom, Anything(JNode, Node) update = ...)

Converts a RedHat AST Atom to a ceylon.ast Atom.

Parameters:
  • update = noop
attachOriginalNodeSource Codeshared void attachOriginalNode(JNode original, Node result)

A function for attaching the RedHat AST Node from which a ceylon.ast Node was converted. To be used as a second parameter to any of the XToCeylon or compileX functions.

baseExpressionToCeylonSource Codeshared BaseExpression baseExpressionToCeylon(Tree.JBaseMemberOrTypeExpression baseMemberOrTypeExpression, Anything(JNode, Node) update = ...)

Converts a RedHat AST BaseMemberOrTypeExpression to a ceylon.ast BaseExpression.

Parameters:
  • baseMemberOrTypeExpression
    • is JTypeArgumentList|JInferredTypeArguments jTypeArguments = baseMemberOrTypeExpression.typeArguments
  • update = noop
baseMetaToCeylonSource Codeshared BaseMeta baseMetaToCeylon(Tree.JMemberLiteral baseMeta, Anything(JNode, Node) update = ...)

Converts a RedHat AST MemberLiteral to a ceylon.ast BaseMeta.

Parameters:
  • baseMeta
    • Must be unqualified

    • Must not be a reference expression

    • is MemberName name = identifierToCeylon(baseMeta.identifier, update)
  • update = noop
    • is MemberName name = identifierToCeylon(baseMeta.identifier, update)
baseTypeToCeylonSource Codeshared BaseType baseTypeToCeylon(Tree.JBaseType baseType, Anything(JNode, Node) update = ...)

Converts a RedHat AST BaseType to a ceylon.ast BaseType.

Parameters:
  • update = noop
binaryOperationToCeylonSource Codeshared BinaryOperation binaryOperationToCeylon(Tree.JBinaryOperatorExpression binaryOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST BinaryOperatorExpression to a ceylon.ast BinaryOperation.

Parameters:
  • binaryOperation
    • is JArithmeticOp|JBitwiseOp|JScaleOp|JRangeOp|JSegmentOp|JEntryOp|JInOp|JComparisonOp|JCompareOp|JEqualityOp|JIdenticalOp|JLogicalOp|JThenOp|JDefaultOp|JAssignmentOp binaryOperation
  • update = noop
blockToCeylonSource Codeshared Block blockToCeylon(Tree.JBlock block, Anything(JNode, Node) update = ...)

Converts a RedHat AST Block to a ceylon.ast Block.

Parameters:
  • update = noop
bodyToCeylonSource Codeshared Body bodyToCeylon(Tree.JBody body, Anything(JNode, Node) update = ...)

Converts a RedHat AST Body to a ceylon.ast Body.

Parameters:
  • body
    • is JBlock|JClassBody|JInterfaceBody body
  • update = noop
booleanConditionToCeylonSource Codeshared BooleanCondition booleanConditionToCeylon(Tree.JBooleanCondition booleanCondition, Anything(JNode, Node) update = ...)

Converts a RedHat AST BooleanCondition to a ceylon.ast BooleanCondition.

Parameters:
  • update = noop
boundToCeylonSource Codeshared Bound boundToCeylon(Tree.JBound bound, Anything(JNode, Node) update = ...)

Converts a RedHat AST Bound to a ceylon.ast Bound.

Parameters:
  • bound
    • is JOpenBound|JClosedBound bound
  • update = noop
breakToCeylonSource Codeshared Break breakToCeylon(Tree.JBreak break, Anything(JNode, Node) update = ...)

Converts a RedHat AST Break to a ceylon.ast Break.

Parameters:
  • update = noop
callableParameterToCeylonSource Codeshared CallableParameter callableParameterToCeylon(Tree.JFunctionalParameterDeclaration callableParameter, Anything(JNode, Node) update = ...)

Converts a RedHat AST FunctionalParameterDeclaration to a ceylon.ast CallableParameter.

Parameters:
  • callableParameter
    • is JMethodDeclaration dec = callableParameter.typedDeclaration
  • update = noop
callableTypeToCeylonSource Codeshared CallableType callableTypeToCeylon(Tree.JFunctionType callableType, Anything(JNode, Node) update = ...)

Converts a RedHat AST FunctionType to a ceylon.ast CallableType.

Parameters:
  • update = noop
caseClauseToCeylonSource Codeshared CaseClause caseClauseToCeylon(Tree.JCaseClause caseClause, Anything(JNode, Node) update = ...)

Converts a RedHat AST CaseClause to a ceylon.ast CaseClause.

Parameters:
  • update = noop
caseExpressionToCeylonSource Codeshared CaseExpression caseExpressionToCeylon(Tree.JCaseClause caseExpression, Anything(JNode, Node) update = ...)

Converts a RedHat AST CaseClause to a ceylon.ast CaseExpression.

Parameters:
  • update = noop
caseItemToCeylonSource Codeshared CaseItem caseItemToCeylon(Tree.JCaseItem caseItem, Anything(JNode, Node) update = ...)

Converts a RedHat AST CaseItem to a ceylon.ast CaseItem.

Parameters:
  • caseItem
    • is JMatchCase|JIsCase|JSatisfiesCase caseItem
  • update = noop
caseTypesToCeylonSource Codeshared CaseTypes caseTypesToCeylon(Tree.JCaseTypes caseTypes, Anything(JNode, Node) update = ...)

Converts RedHat AST CaseTypes to ceylon.ast CaseTypes.

Parameters:
  • caseTypes
    • nonempty cases = concatenate(CeylonIterable(caseTypes.types), CeylonIterable(caseTypes.baseMemberExpressions)) .sort(byIncreasing(compose(Token.tokenIndex, JNode.token)))
  • update = noop
catchClauseToCeylonSource Codeshared CatchClause catchClauseToCeylon(Tree.JCatchClause catchClause, Anything(JNode, Node) update = ...)

Converts a RedHat AST CatchClause to a ceylon.ast CatchClause.

Parameters:
  • update = noop
characterLiteralToCeylonSource Codeshared CharacterLiteral characterLiteralToCeylon(Tree.JCharacterLiteral characterLiteral, Anything(JNode, Node) update = ...)

Converts a RedHat AST CharLiteral to a ceylon.ast CharacterLiteral.

Parameters:
  • characterLiteral
    • characterLiteral.mainToken.type == character_literal
  • update = noop
Throws
classAliasDefinitionToCeylonSource Codeshared ClassAliasDefinition classAliasDefinitionToCeylon(Tree.JClassDeclaration classAliasDefinition, Anything(JNode, Node) update = ...)

Converts a RedHat AST ClassDeclaration to a ceylon.ast ClassAliasDefinition.

Parameters:
  • update = noop
classBodyToCeylonSource Codeshared ClassBody classBodyToCeylon(Tree.JClassBody classBody, Anything(JNode, Node) update = ...)

Converts a RedHat AST ClassBody to a ceylon.ast ClassBody.

Parameters:
  • update = noop
classDecToCeylonSource Codeshared ClassDec classDecToCeylon(Tree.JClassLiteral classDec, Anything(JNode, Node) update = ...)

Converts a RedHat AST ClassLiteral to a ceylon.ast ClassDec.

Parameters:
  • update = noop
classDefinitionToCeylonSource Codeshared ClassDefinition classDefinitionToCeylon(Tree.JClassDefinition classDefinition, Anything(JNode, Node) update = ...)

Converts a RedHat AST ClassDefinition to a ceylon.ast ClassDefinition.

Parameters:
  • update = noop
classOrInterfaceToCeylonSource Codeshared ClassOrInterface classOrInterfaceToCeylon(Tree.JClassOrInterface classOrInterface, Anything(JNode, Node) update = ...)

Converts a RedHat AST ClassOrInterface to a ceylon.ast ClassOrInterface.

Parameters:
  • classOrInterface
    • is JAnyClass|JAnyInterface classOrInterface
  • update = noop
classSpecifierToCeylonSource Codeshared ClassSpecifier classSpecifierToCeylon(Tree.JClassSpecifier classSpecifier, Anything(JNode, Node) update = ...)

Converts a RedHat AST ClassSpecifier to a ceylon.ast ClassSpecifier.

Parameters:
  • update = noop
closedBoundToCeylonSource Codeshared ClosedBound closedBoundToCeylon(Tree.JClosedBound closedBound, Anything(JNode, Node) update = ...)

Converts a RedHat AST ClosedBound to a ceylon.ast ClosedBound.

Parameters:
  • closedBound
    • Check precedence

  • update = noop
    • Check precedence

compareOperationToCeylonSource Codeshared CompareOperation compareOperationToCeylon(Tree.JCompareOp compareOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST CompareOp to a ceylon.ast CompareOperation.

Parameters:
  • compareOperation
    • Check precedence

  • update = noop
    • Check precedence

comparisonOperationToCeylonSource Codeshared ComparisonOperation comparisonOperationToCeylon(Tree.JComparisonOp comparisonOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST ComparisonOp to a ceylon.ast ComparisonOperation.

Parameters:
  • comparisonOperation
    • is JLargerOp|JSmallerOp|JLargeAsOp|JSmallAsOp comparisonOperation
  • update = noop
compilationUnitToCeylonSource Codeshared CompilationUnit compilationUnitToCeylon(Tree.JCompilationUnit compilationUnit, Anything(JNode, Node) update = ...)

Converts a RedHat AST CompilationUnit to a ceylon.ast CompilationUnit.

Note: This only converts regular compilation units. For arbitrary compilation units, see anyCompilationUnitToCeylon().

Parameters:
  • compilationUnit
    • Must not have package or module descriptors

  • update = noop
Throws
  • AssertionError

    If the compilation unit contains package or module descriptors

compileAddAssignmentOperationSource Codeshared AddAssignmentOperation? compileAddAssignmentOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Add Assignment Operation into an AddAssignmentOperation using the Ceylon compiler (more specifically, the rule for an assignmentExpression).

Parameters:
  • update = noop
compileAliasDecSource Codeshared AliasDec? compileAliasDec(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Alias Dec into an AliasDec using the Ceylon compiler (more specifically, the rule for a metaLiteral).

Parameters:
  • update = noop
compileAndAssignmentOperationSource Codeshared AndAssignmentOperation? compileAndAssignmentOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an And Assignment Operation into an AndAssignmentOperation using the Ceylon compiler (more specifically, the rule for an assignmentExpression).

Parameters:
  • update = noop
compileAndOperationSource Codeshared AndOperation? compileAndOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an And Operation into an AndOperation using the Ceylon compiler (more specifically, the rule for an conjunctionExpression).

Parameters:
  • update = noop
compileAnnotationSource Codeshared Annotation? compileAnnotation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Annotation into an Annotation using the Ceylon compiler (more specifically, the rule for an annotation).

Parameters:
  • update = noop
compileAnnotationsSource Codeshared Annotations? compileAnnotations(String code, Anything(JNode, Node) update = ...)

Compiles the given code for Annotations into an Annotations using the Ceylon compiler (more specifically, the rule for annotations).

Parameters:
  • update = noop
compileAnonymousArgumentSource Codeshared AnonymousArgument? compileAnonymousArgument(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Anonymous Argument into an AnonymousArgument using the Ceylon compiler (more specifically, the rule for an anonymousArgument).

Parameters:
  • update = noop
compileAnyClassSource Codeshared AnyClass? compileAnyClass(String code, Anything(JNode, Node) update = ...)

Compiles the given code for Any Class into an AnyClass using the Ceylon compiler (more specifically, the rule for a declaration).

Parameters:
  • update = noop
compileAnyCompilationUnitSource Codeshared AnyCompilationUnit? compileAnyCompilationUnit(String code, Anything(JNode, Node) update = ...)

Compiles the given code for Any Compilation Unit into an AnyCompilationUnit using the Ceylon compiler (more specifically, the rule for a compilationUnit).

Parameters:
  • update = noop
compileAnyFunctionSource Codeshared AnyFunction? compileAnyFunction(String code, Anything(JNode, Node) update = ...)

Compiles the given code for Any Function into an AnyFunction using the Ceylon compiler (more specifically, the rule for a declaration).

Parameters:
  • update = noop
compileAnyInterfaceSource Codeshared AnyInterface? compileAnyInterface(String code, Anything(JNode, Node) update = ...)

Compiles the given code for Any Interface into an AnyInterface using the Ceylon compiler (more specifically, the rule for a declaration).

Parameters:
  • update = noop
compileAnyInterfaceDefinitionSource Codeshared AnyInterfaceDefinition? compileAnyInterfaceDefinition(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Any Interface Definition into an AnyInterfaceDefinition using the Ceylon compiler (more specifically, the rule for a declaration).

Parameters:
  • update = noop
compileAnyMemberOperatorSource Codeshared AnyMemberOperator? compileAnyMemberOperator(String code, Anything(JNode, Node) update = ...)

Compiles the given code for Any Member Operator into an AnyMemberOperator using the Ceylon compiler (more specifically, the rule for a memberSelectionOperator).

Parameters:
  • update = noop
compileAnySpecifierSource Codeshared AnySpecifier? compileAnySpecifier(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Any Specifier into an AnySpecifier using the Ceylon compiler (more specifically, the rule for a specifier or lazySpecifier).

Parameters:
  • update = noop
compileAnyValueSource Codeshared AnyValue? compileAnyValue(String code, Anything(JNode, Node) update = ...)

Compiles the given code for Any Value into an AnyValue using the Ceylon compiler (more specifically, the rule for a declaration).

Parameters:
  • update = noop
compileArgumentListSource Codeshared ArgumentList? compileArgumentList(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Argument List into an ArgumentList using the Ceylon compiler (more specifically, the rule for a sequencedArgument).

Parameters:
  • update = noop
compileArgumentsSource Codeshared Arguments? compileArguments(String code, Anything(JNode, Node) update = ...)

Compiles the given code for Arguments into Arguments using the Ceylon compiler (more specifically, the rule for namedArguments and positionalArguments).

Parameters:
  • update = noop
compileArithmeticAssignmentOperationSource Codeshared ArithmeticAssignmentOperation? compileArithmeticAssignmentOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Arithmetic Assignment Operation into an ArithmeticAssignmentOperation using the Ceylon compiler (more specifically, the rule for an assignmentExpression).

Parameters:
  • update = noop
compileArithmeticOperationSource Codeshared ArithmeticOperation? compileArithmeticOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Arithmetic Operation into an ArithmeticOperation using the Ceylon compiler (more specifically, the rule for an additiveExpression).

Parameters:
  • update = noop
compileAssertionSource Codeshared Assertion? compileAssertion(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Assertion into an Assertion using the Ceylon compiler (more specifically, the rule for an assertion).

Parameters:
  • update = noop
compileAssignOperationSource Codeshared AssignOperation? compileAssignOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Assign Operation into an AssignOperation using the Ceylon compiler (more specifically, the rule for an assignmentExpression).

Parameters:
  • update = noop
compileAssignmentOperationSource Codeshared AssignmentOperation? compileAssignmentOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Assignment Operation into an AssignmentOperation using the Ceylon compiler (more specifically, the rule for an assignmentExpression).

Parameters:
  • update = noop
compileAssignmentStatementSource Codeshared AssignmentStatement? compileAssignmentStatement(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Assignment Statement into an AssignmentStatement using the Ceylon compiler (more specifically, the rule for an expressionOrSpecificationStatement).

Parameters:
  • update = noop
compileAtomSource Codeshared Atom? compileAtom(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Atom into an Atom using the Ceylon compiler (more specifically, the rule for a base).

Parameters:
  • update = noop
compileBaseExpressionSource Codeshared BaseExpression? compileBaseExpression(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Base Expression into a BaseExpression using the Ceylon compiler (more specifically, the rule for a baseReference).

Parameters:
  • update = noop
compileBaseMetaSource Codeshared BaseMeta? compileBaseMeta(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Base Meta into a BaseMeta using the Ceylon compiler (more specifically, the rule for a metaLiteral).

Parameters:
  • update = noop
compileBaseTypeSource Codeshared BaseType? compileBaseType(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Base Type into a BaseType using the Ceylon compiler (more specifically, the rule for a baseType).

Parameters:
  • update = noop
compileBinaryOperationSource Codeshared BinaryOperation? compileBinaryOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Binary Operation into a BinaryOperation using the Ceylon compiler (more specifically, the rule for an assignmentExpression).

Parameters:
  • update = noop
compileBlockSource Codeshared Block? compileBlock(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Block into a Block using the Ceylon compiler (more specifically, the rule for a block).

Parameters:
  • update = noop
compileBooleanConditionSource Codeshared BooleanCondition? compileBooleanCondition(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Boolean Condition into a BooleanCondition using the Ceylon compiler (more specifically, the rule for a booleanCondition).

Parameters:
  • update = noop
compileBreakSource Codeshared Break? compileBreak(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Break into a Break using the Ceylon compiler (more specifically, the rule for a directiveStatement).

Parameters:
  • update = noop
compileCallableParameterSource Codeshared CallableParameter? compileCallableParameter(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Callable Parameter into a CallableParameter using the Ceylon compiler (more specifically, the rule for a parameter).

Parameters:
  • update = noop
compileCallableTypeSource Codeshared CallableType? compileCallableType(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Callable Type into a CallableType using the Ceylon compiler (more specifically, the rule for an primaryType).

Parameters:
  • update = noop
compileCaseClauseSource Codeshared CaseClause? compileCaseClause(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Case Clause into a CaseClause using the Ceylon compiler (more specifically, the rule for a caseBlock).

Parameters:
  • update = noop
compileCaseItemSource Codeshared CaseItem? compileCaseItem(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Case Item into a CaseItem using the Ceylon compiler (more specifically, the rule for a caseItem).

Parameters:
  • update = noop
compileCaseTypesSource Codeshared CaseTypes? compileCaseTypes(String code, Anything(JNode, Node) update = ...)

Compiles the given code for Case Types into CaseTypes using the Ceylon compiler (more specifically, the rule for caseTypes).

Parameters:
  • update = noop
compileCatchClauseSource Codeshared CatchClause? compileCatchClause(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Catch Clause into a CatchClause using the Ceylon compiler (more specifically, the rule for a catchBlock).

Parameters:
  • update = noop
compileCharacterLiteralSource Codeshared CharacterLiteral? compileCharacterLiteral(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Character Literal into a CharacterLiteral using the Ceylon compiler (more specifically, the rule for a nonStringLiteral).

Parameters:
  • update = noop
compileClassAliasDefinitionSource Codeshared ClassAliasDefinition? compileClassAliasDefinition(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Class Alias into a ClassAliasDefinition using the Ceylon compiler (more specifically, the rule for a declaration).

Parameters:
  • update = noop
compileClassBodySource Codeshared ClassBody? compileClassBody(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Class Body into a ClassBody using the Ceylon compiler (more specifically, the rule for a classBody).

Parameters:
  • update = noop
compileClassDecSource Codeshared ClassDec? compileClassDec(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Class Dec into a ClassDec using the Ceylon compiler (more specifically, the rule for a metaLiteral).

Parameters:
  • update = noop
compileClassDefinitionSource Codeshared ClassDefinition? compileClassDefinition(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Class Definition into a ClassDefinition using the Ceylon compiler (more specifically, the rule for a declaration).

Parameters:
  • update = noop
compileClassOrInterfaceSource Codeshared ClassOrInterface? compileClassOrInterface(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Class Or Interface into a ClassOrInterface using the Ceylon compiler (more specifically, the rule for a declaration).

Parameters:
  • update = noop
compileClassSpecifierSource Codeshared ClassSpecifier? compileClassSpecifier(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Class Specifier into a ClassSpecifier using the Ceylon compiler (more specifically, the rule for a classSpecifier).

Parameters:
  • update = noop
compileCompareOperationSource Codeshared CompareOperation? compileCompareOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Compare Operation into a CompareOperation using the Ceylon compiler (more specifically, the rule for a comparisonExpression).

Parameters:
  • update = noop
compileComparisonOperationSource Codeshared ComparisonOperation? compileComparisonOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Comparison Operation into a ComparisonOperation using the Ceylon compiler (more specifically, the rule for a comparisonExpression).

Parameters:
  • update = noop
compileCompilationUnitSource Codeshared CompilationUnit? compileCompilationUnit(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Compilation Unit into a CompilationUnit using the Ceylon compiler (more specifically, the rule for a compilationUnit).

Parameters:
  • update = noop
compileComplementAssignmentOperationSource Codeshared ComplementAssignmentOperation? compileComplementAssignmentOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Complement Assignment Operation into a ComplementAssignmentOperation using the Ceylon compiler (more specifically, the rule for an assignmentExpression).

Parameters:
  • update = noop
compileComplementOperationSource Codeshared ComplementOperation? compileComplementOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Complement Operation into a ComplementOperation using the Ceylon compiler (more specifically, the rule for a unionExpression).

Parameters:
  • update = noop
compileComprehensionSource Codeshared Comprehension? compileComprehension(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Comprehension into a Comprehension using the Ceylon compiler (more specifically, the rule for a comprehension).

Parameters:
  • update = noop
compileComprehensionClauseSource Codeshared ComprehensionClause? compileComprehensionClause(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Comprehension Clause into a ComprehensionClause using the Ceylon compiler (more specifically, the rule for a comprehensionClause).

Parameters:
  • update = noop
compileConditionSource Codeshared Condition? compileCondition(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Condition into a Condition using the Ceylon compiler (more specifically, the rule for a condition).

Parameters:
  • update = noop
compileConditionalExpressionSource Codeshared ConditionalExpression? compileConditionalExpression(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Any Specifier into a ConditionalExpression using the Ceylon compiler (more specifically, the rule for an ifExpression or a switchExpression).

Parameters:
  • update = noop
compileConditionsSource Codeshared Conditions? compileConditions(String code, Anything(JNode, Node) update = ...)

Compiles the given code for Conditions into Conditions using the Ceylon compiler (more specifically, the rule for conditions).

Parameters:
  • update = noop
compileConstructionSource Codeshared Construction? compileConstruction(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Construction into a Construction using the Ceylon compiler (more specifically, the rule for a classInstantiation).

Parameters:
  • update = noop
compileConstructorDecSource Codeshared ConstructorDec? compileConstructorDec(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Constructor Dec into a ConstructorDec using the Ceylon compiler (more specifically, the rule for a metaLiteral).

Parameters:
  • update = noop
compileConstructorDefinitionSource Codeshared ConstructorDefinition? compileConstructorDefinition(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Constructor Definition into a ConstructorDefinition using the Ceylon compiler (more specifically, the rule for a declaration).

Parameters:
  • update = noop
compileContinueSource Codeshared Continue? compileContinue(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Continue into a Continue using the Ceylon compiler (more specifically, the rule for a continue).

Parameters:
  • update = noop
compileControlStructureSource Codeshared ControlStructure? compileControlStructure(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Control Structure into a ControlStructure using the Ceylon compiler (more specifically, the rule for a controlStatement).

Parameters:
  • update = noop
compileDecSource Codeshared Dec? compileDec(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Dec into a Dec using the Ceylon compiler (more specifically, the rule for a metaLiteral).

Parameters:
  • update = noop
compileDeclarationSource Codeshared Declaration? compileDeclaration(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Declaration into a Declaration using the Ceylon compiler (more specifically, the rule for a declaration).

Parameters:
  • update = noop
compileDefaultedCallableParameterSource Codeshared DefaultedCallableParameter? compileDefaultedCallableParameter(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Defaulted Callable Parameter into a DefaultedCallableParameter using the Ceylon compiler (more specifically, the rule for a parameterDeclarationOrRef).

Parameters:
  • update = noop
compileDefaultedParameterSource Codeshared DefaultedParameter? compileDefaultedParameter(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Defaulted Parameter into a DefaultedParameter using the Ceylon compiler (more specifically, the rule for a parameterDeclarationOrRef).

Parameters:
  • update = noop
compileDefaultedParameterReferenceSource Codeshared DefaultedParameterReference? compileDefaultedParameterReference(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Defaulted Parameter Reference into a DefaultedParameterReference using the Ceylon compiler (more specifically, the rule for a parameterRef).

Parameters:
  • update = noop
compileDefaultedTypeSource Codeshared DefaultedType? compileDefaultedType(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Defaulted Type into a DefaultedType using the Ceylon compiler (more specifically, the rule for a defaultedType).

Take care:

Iterable<String>=

is lexed as

Iterable, <, String, >=

which can’t be parsed. Use

Iterable<String> =

instead, if necessary.

Parameters:
  • update = noop
compileDefaultedValueParameterSource Codeshared DefaultedValueParameter? compileDefaultedValueParameter(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Defaulted Value Parameter into a DefaultedValueParameter using the Ceylon compiler (more specifically, the rule for a parameterDeclarationOrRef).

Parameters:
  • update = noop
compileDestructureSource Codeshared Destructure? compileDestructure(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Destructure into a Destructure using the Ceylon compiler (more specifically, the rule for a destructure).

Parameters:
  • update = noop
compileDifferenceOperationSource Codeshared DifferenceOperation? compileDifferenceOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Difference Operation into a DifferenceOperation using the Ceylon compiler (more specifically, the rule for an additiveExpression).

Parameters:
  • update = noop
compileDirectiveSource Codeshared Directive? compileDirective(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Directive into a Directive using the Ceylon compiler (more specifically, the rule for a directive).

Parameters:
  • update = noop
compileDivideAssignmentOperationSource Codeshared DivideAssignmentOperation? compileDivideAssignmentOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Divide Assignment Operation into a DivideAssignmentOperation using the Ceylon compiler (more specifically, the rule for a assignmentExpression).

Parameters:
  • update = noop
compileDynamicBlockSource Codeshared DynamicBlock? compileDynamicBlock(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Dynamic Block into a DynamicBlock using the Ceylon compiler (more specifically, the rule for a dynamicBlock).

Parameters:
  • update = noop
compileDynamicInterfaceDefinitionSource Codeshared DynamicInterfaceDefinition? compileDynamicInterfaceDefinition(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Dynamic Interface Definition into a DynamicInterfaceDefinition using the Ceylon compiler (more specifically, the rule for a declaration).

Parameters:
  • update = noop
compileDynamicModifierSource Codeshared DynamicModifier? compileDynamicModifier(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Dynamic Modifier into a DynamicModifier using the Ceylon compiler (more specifically, the lexer).

Parameters:
  • update = noop
compileDynamicValueSource Codeshared DynamicValue? compileDynamicValue(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Dynamic Value into a DynamicValue using the Ceylon compiler (more specifically, the rule for a dynamicObject).

Parameters:
  • update = noop
compileElementOrSubrangeExpressionSource Codeshared ElementOrSubrangeExpression? compileElementOrSubrangeExpression(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Element Or Subrange Expression into an ElementOrSubrangeExpression using the Ceylon compiler (more specifically, the rule for a primary).

Parameters:
  • update = noop
compileElseClauseSource Codeshared ElseClause? compileElseClause(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Else Clause into an ElseClause using the Ceylon compiler (more specifically, the rule for an elseBlock).

Parameters:
  • update = noop
compileElseOperationSource Codeshared ElseOperation? compileElseOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Else Operation into an ElseOperation using the Ceylon compiler (more specifically, the rule for a thenElseExpression).

Parameters:
  • update = noop
compileEntryOperationSource Codeshared EntryOperation? compileEntryOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Entry Operation into an EntryOperation using the Ceylon compiler (more specifically, the rule for an entryRangeExpression).

Parameters:
  • update = noop
compileEntryPatternSource Codeshared EntryPattern? compileEntryPattern(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Entry Pattern into an EntryPattern using the Ceylon compiler (more specifically, the rule for an keyItemPattern).

Parameters:
  • update = noop
compileEntryTypeSource Codeshared EntryType? compileEntryType(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Entry Type into an EntryType using the Ceylon compiler (more specifically, the rule for a type).

Parameters:
  • update = noop
compileEqualOperationSource Codeshared EqualOperation? compileEqualOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Equal Operation into an EqualOperation using the Ceylon compiler (more specifically, the rule for an equalityExpression).

Parameters:
  • update = noop
compileEqualityOperationSource Codeshared EqualityOperation? compileEqualityOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Equality Operation into an EqualityOperation using the Ceylon compiler (more specifically, the rule for an equalityExpression).

Parameters:
  • update = noop
compileExistsConditionSource Codeshared ExistsCondition? compileExistsCondition(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Exists Condition into an ExistsCondition using the Ceylon compiler (more specifically, the rule for an existsCondition).

Parameters:
  • update = noop
compileExistsOperationSource Codeshared ExistsOperation? compileExistsOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Exists Operation into an ExistsOperation using the Ceylon compiler (more specifically, the rule for an existenceEmptinessExpression).

Parameters:
  • update = noop
compileExistsOrNonemptyConditionSource Codeshared ExistsOrNonemptyCondition? compileExistsOrNonemptyCondition(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Exists Or Nonempty Condition into an ExistsOrNonemptyCondition using the Ceylon compiler (more specifically, the rule for an condition).

Parameters:
  • update = noop
compileExponentiationOperationSource Codeshared ExponentiationOperation? compileExponentiationOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Exponentiation Operation into an ExponentiationOperation using the Ceylon compiler (more specifically, the rule for an exponentiationExpression).

Parameters:
  • update = noop
compileExpressionSource Codeshared Expression? compileExpression(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Expression into an Expression using the Ceylon compiler (more specifically, the rule for a functionOrExpression).

Parameters:
  • update = noop
compileExpressionComprehensionClauseSource Codeshared ExpressionComprehensionClause? compileExpressionComprehensionClause(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Expression Comprehension Clause into an ExpressionComprehensionClause using the Ceylon compiler (more specifically, the rule for an expressionComprehensionClause).

Parameters:
  • update = noop
compileExpressionStatementSource Codeshared ExpressionStatement? compileExpressionStatement(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Expression Statement into an ExpressionStatement using the Ceylon compiler (more specifically, the rule for an expressionOrSpecificationStatement).

Parameters:
  • update = noop
compileExtendedTypeSource Codeshared ExtendedType? compileExtendedType(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Extended Type into an ExtendedType using the Ceylon compiler (more specifically, the rule for an extendedType).

Parameters:
  • update = noop
compileExtensionSource Codeshared Extension? compileExtension(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Extension into an Extension using the Ceylon compiler (more specifically, the rule for an classInstantiation).

Parameters:
  • update = noop
compileExtensionOrConstructionSource Codeshared ExtensionOrConstruction? compileExtensionOrConstruction(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Extension Or Construction into an ExtensionOrConstruction using the Ceylon compiler (more specifically, the rule for an classInstantiation).

Parameters:
  • update = noop
compileFailClauseSource Codeshared FailClause? compileFailClause(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Fail Clause into a FailClause using the Ceylon compiler (more specifically, the rule for a failBlock).

Parameters:
  • update = noop
compileFinallyClauseSource Codeshared FinallyClause? compileFinallyClause(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Finally Clause into a FinallyClause using the Ceylon compiler (more specifically, the rule for a finallyBlock).

Parameters:
  • update = noop
compileFloatLiteralSource Codeshared FloatLiteral? compileFloatLiteral(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Float Literal into a FloatLiteral using the Ceylon compiler (more specifically, the rule for a nonStringLiteral).

Parameters:
  • update = noop
compileForClauseSource Codeshared ForClause? compileForClause(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a ‘for’ Clause into a ForClause using the Ceylon compiler (more specifically, the rule for a forBlock).

Parameters:
  • update = noop
compileForComprehensionClauseSource Codeshared ForComprehensionClause? compileForComprehensionClause(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a For Comprehension Clause into a ForComprehensionClause using the Ceylon compiler (more specifically, the rule for a forComprehensionClause).

Parameters:
  • update = noop
compileForFailSource Codeshared ForFail? compileForFail(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a ‘for’ loop into a ForFail using the Ceylon compiler (more specifically, the rule for a forElse).

Parameters:
  • update = noop
compileForIteratorSource Codeshared ForIterator? compileForIterator(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a For Iterator into a ForIterator using the Ceylon compiler (more specifically, the rule for a forIterator).

Parameters:
  • update = noop
compileFullPackageNameSource Codeshared FullPackageName? compileFullPackageName(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Full Package Name into a FullPackageName using the Ceylon compiler (more specifically, the rule for a fullPackageName).

Parameters:
  • update = noop
compileFunctionArgumentSource Codeshared FunctionArgument? compileFunctionArgument(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Function Argument into a FunctionArgument using the Ceylon compiler (more specifically, the rule for a namedArgumentDeclaration).

Parameters:
  • update = noop
compileFunctionDecSource Codeshared FunctionDec? compileFunctionDec(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Function Dec into a FunctionDec using the Ceylon compiler (more specifically, the rule for a metaLiteral).

Parameters:
  • update = noop
compileFunctionDeclarationSource Codeshared FunctionDeclaration? compileFunctionDeclaration(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Function Declaration into a FunctionDeclaration using the Ceylon compiler (more specifically, the rule for a declaration).

Parameters:
  • update = noop
compileFunctionDefinitionSource Codeshared FunctionDefinition? compileFunctionDefinition(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Function Definition into a FunctionDefinition using the Ceylon compiler (more specifically, the rule for a declaration).

Parameters:
  • update = noop
compileFunctionExpressionSource Codeshared FunctionExpression? compileFunctionExpression(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Function Expression into a FunctionExpression using the Ceylon compiler (more specifically, the rule for an anonymousFunction).

Parameters:
  • update = noop
compileFunctionModifierSource Codeshared FunctionModifier? compileFunctionModifier(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Function Modifier into a FunctionModifier using the Ceylon compiler (more specifically, the lexer).

Parameters:
  • update = noop
compileFunctionShortcutDefinitionSource Codeshared FunctionShortcutDefinition? compileFunctionShortcutDefinition(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Function Shortcut Definition into a FunctionShortcutDefinition using the Ceylon compiler (more specifically, the rule for a declaration).

Parameters:
  • update = noop
compileGivenDecSource Codeshared GivenDec? compileGivenDec(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Given Dec into a GivenDec using the Ceylon compiler (more specifically, the rule for a metaLiteral).

Parameters:
  • update = noop
compileGroupedExpressionSource Codeshared GroupedExpression? compileGroupedExpression(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Grouped Expression into a GroupedExpression using the Ceylon compiler (more specifically, the rule for a parExpression).

Parameters:
  • update = noop
compileGroupedTypeSource Codeshared GroupedType? compileGroupedType(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Grouped Type into a GroupedType using the Ceylon compiler (more specifically, the rule for a groupedType).

Parameters:
  • update = noop
compileIdenticalOperationSource Codeshared IdenticalOperation? compileIdenticalOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Identical Operation into an IdenticalOperation using the Ceylon compiler (more specifically, the rule for an equalityExpression).

Parameters:
  • update = noop
compileIdentifierSource Codeshared Identifier? compileIdentifier(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Identifier into an Identifier using the Ceylon compiler (more specifically, the rule for an Import Name).

Parameters:
  • update = noop
compileIdentityOperationSource Codeshared IdentityOperation? compileIdentityOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Identity Operation into an IdentityOperation using the Ceylon compiler (more specifically, the rule for an negationComplementExpression).

Parameters:
  • update = noop
compileIfClauseSource Codeshared IfClause? compileIfClause(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an If Clause into an IfClause using the Ceylon compiler (more specifically, the rule for an ifBlock).

Parameters:
  • update = noop
compileIfComprehensionClauseSource Codeshared IfComprehensionClause? compileIfComprehensionClause(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an If Comprehension Clause into an IfComprehensionClause using the Ceylon compiler (more specifically, the rule for an ifComprehensionClause).

Parameters:
  • update = noop
compileIfElseSource Codeshared IfElse? compileIfElse(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an If Else into an IfElse using the Ceylon compiler (more specifically, the rule for an ifElse).

Parameters:
  • update = noop
compileIfElseExpressionSource Codeshared IfElseExpression? compileIfElseExpression(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an If Else Expression into an IfElseExpression using the Ceylon compiler (more specifically, the rule for an ifExpression).

Parameters:
  • update = noop
compileImportSource Codeshared Import? compileImport(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Import into an Import using the Ceylon compiler (more specifically, the rule for an import).

Parameters:
  • update = noop
compileImportAliasSource Codeshared ImportAlias? compileImportAlias(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Import Alias into an ImportAlias using the Ceylon compiler (more specifically, the rule for an importElement).

Parameters:
  • update = noop
compileImportElementSource Codeshared ImportElement? compileImportElement(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Import Element into an ImportElement using the Ceylon compiler (more specifically, the rule for an importElement).

Parameters:
  • update = noop
compileImportElementsSource Codeshared ImportElements? compileImportElements(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Import Elements into an ImportElements using the Ceylon compiler (more specifically, the rule for an importElementList).

Parameters:
  • update = noop
compileImportFunctionValueAliasSource Codeshared ImportFunctionValueAlias? compileImportFunctionValueAlias(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Import Function Value Alias into an ImportFunctionValueAlias using the Ceylon compiler (more specifically, the rule for an importElement).

Parameters:
  • update = noop
compileImportFunctionValueElementSource Codeshared ImportFunctionValueElement? compileImportFunctionValueElement(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Import Function Value Element into an ImportFunctionValueElement using the Ceylon compiler (more specifically, the rule for an importElement).

Parameters:
  • update = noop
compileImportTypeAliasSource Codeshared ImportTypeAlias? compileImportTypeAlias(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Import Type Alias into an ImportTypeAlias using the Ceylon compiler (more specifically, the rule for an importElement).

Parameters:
  • update = noop
compileImportTypeElementSource Codeshared ImportTypeElement? compileImportTypeElement(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Import Type Element into an ImportTypeElement using the Ceylon compiler (more specifically, the rule for an importElement).

Parameters:
  • update = noop
compileImportWildcardSource Codeshared ImportWildcard? compileImportWildcard(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Import Wildcard into an ImportWildcard using the Ceylon compiler (more specifically, the rule for an importWildcard).

Parameters:
  • update = noop
compileInModifierSource Codeshared InModifier? compileInModifier(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an In Modifier into an InModifier using the Ceylon compiler (more specifically, the rule for a variance).

Parameters:
  • update = noop
compileInOperationSource Codeshared InOperation? compileInOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an In Operation into an InOperation using the Ceylon compiler (more specifically, the rule for a comparisonExpression).

Parameters:
  • update = noop
compileInitialComprehensionClauseSource Codeshared InitialComprehensionClause? compileInitialComprehensionClause(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Initial Comprehension Clause into an InitialComprehensionClause using the Ceylon compiler (more specifically, the rule for an initialComprehensionClause).

Parameters:
  • update = noop
compileInlineDefinitionArgumentSource Codeshared InlineDefinitionArgument? compileInlineDefinitionArgument(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Inline Definition Argument into an InlineDefinitionArgument using the Ceylon compiler (more specifically, the rule for a namedArgumentDeclaration).

Parameters:
  • update = noop
compileIntegerLiteralSource Codeshared IntegerLiteral? compileIntegerLiteral(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Integer Literal into an IntegerLiteral using the Ceylon compiler (more specifically, the rule for a nonstringLiteral).

Parameters:
  • update = noop
compileInterfaceAliasDefinitionSource Codeshared InterfaceAliasDefinition? compileInterfaceAliasDefinition(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Interface Alias Definition into an InterfaceAliasDefinition using the Ceylon compiler (more specifically, the rule for a declaration).

Parameters:
  • update = noop
compileInterfaceBodySource Codeshared InterfaceBody? compileInterfaceBody(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Interface Body into an InterfaceBody using the Ceylon compiler (more specifically, the rule for an interfaceBody).

Parameters:
  • update = noop
compileInterfaceDecSource Codeshared InterfaceDec? compileInterfaceDec(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Interface Dec into an InterfaceDec using the Ceylon compiler (more specifically, the rule for an metaLiteral).

Parameters:
  • update = noop
compileInterfaceDefinitionSource Codeshared InterfaceDefinition? compileInterfaceDefinition(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Interface Definition into an InterfaceDefinition using the Ceylon compiler (more specifically, the rule for a declaration).

Parameters:
  • update = noop
compileIntersectAssignmentOperationSource Codeshared IntersectAssignmentOperation? compileIntersectAssignmentOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Intersect Assignment Operation into an IntersectAssignmentOperation using the Ceylon compiler (more specifically, the rule for an assignmentExpression).

Parameters:
  • update = noop
compileIntersectionOperationSource Codeshared IntersectionOperation? compileIntersectionOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Intersection Operation into an IntersectionOperation using the Ceylon compiler (more specifically, the rule for an intersectionExpression).

Parameters:
  • update = noop
compileIntersectionTypeSource Codeshared IntersectionType? compileIntersectionType(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Intersection Type into an IntersectionType using the Ceylon compiler (more specifically, the rule for an intersectionType).

Parameters:
  • update = noop
compileInvocationSource Codeshared Invocation? compileInvocation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Invocation into an Invocation using the Ceylon compiler (more specifically, the rule for a primary).

Parameters:
  • update = noop
compileInvocationStatementSource Codeshared InvocationStatement? compileInvocationStatement(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Invocation Statement into an InvocationStatement using the Ceylon compiler (more specifically, the rule for an expressionOrSpecificationStatement).

Parameters:
  • update = noop
compileIsCaseSource Codeshared IsCase? compileIsCase(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Is Case into an IsCase using the Ceylon compiler (more specifically, the rule for an isCaseCondition).

Parameters:
  • update = noop
compileIsConditionSource Codeshared IsCondition? compileIsCondition(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Is Condition into an IsCondition using the Ceylon compiler (more specifically, the rule for an isCondition).

Parameters:
  • update = noop
compileIsOperationSource Codeshared IsOperation? compileIsOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Is Operation into an IsOperation using the Ceylon compiler (more specifically, the rule for a comparisonExpression).

Parameters:
  • update = noop
compileIterableSource Codeshared Iterable? compileIterable(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Iterable into an Iterable using the Ceylon compiler (more specifically, the rule for an enumeration).

Parameters:
  • update = noop
compileIterableTypeSource Codeshared IterableType? compileIterableType(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Iterable Type into an IterableType using the Ceylon compiler (more specifically, the rule for an iterableType).

Parameters:
  • update = noop
compileKeySubscriptSource Codeshared KeySubscript? compileKeySubscript(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Key Subscript into a KeySubscript using the Ceylon compiler (more specifically, the rule for a indexOrIndexRange).

Parameters:
  • update = noop
compileLIdentifierSource Codeshared LIdentifier? compileLIdentifier(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Lowercase Identifier into an LIdentifier using the Ceylon compiler (more specifically, the rule for a Member Name).

Parameters:
  • update = noop
compileLargeAsOperationSource Codeshared LargeAsOperation? compileLargeAsOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Large As Operation into a LargeAsOperation using the Ceylon compiler (more specifically, the rule for a comparisonExpression).

Parameters:
  • update = noop
compileLargerOperationSource Codeshared LargerOperation? compileLargerOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Larger Operation into a LargerOperation using the Ceylon compiler (more specifically, the rule for a comparisonExpression).

Parameters:
  • update = noop
compileLazySpecificationSource Codeshared LazySpecification? compileLazySpecification(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Lazy Specification into a LazySpecification using the Ceylon compiler (more specifically, the rule for an expressionOrSpecificationStatement).

Parameters:
  • update = noop
compileLazySpecifierSource Codeshared LazySpecifier? compileLazySpecifier(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Lazy Specifier into a LazySpecifier using the Ceylon compiler (more specifically, the rule for a lazySpecifier).

Parameters:
  • update = noop
compileLetExpressionSource Codeshared LetExpression? compileLetExpression(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Let Expression into a LetExpression using the Ceylon compiler (more specifically, the rule for a let).

Parameters:
  • update = noop
compileLiteralSource Codeshared Literal? compileLiteral(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Literal into a Literal using the Ceylon compiler (more specifically, the rules for a stringLiteral and a nonstringLiteral).

Parameters:
  • update = noop
compileLocalModifierSource Codeshared LocalModifier? compileLocalModifier(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Local Modifier into a LocalModifier using the Ceylon compiler (more specifically, the lexer).

Parameters:
  • update = noop
compileLogicalAssignmentOperationSource Codeshared LogicalAssignmentOperation? compileLogicalAssignmentOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Logical Assignment Operation into a LogicalAssignmentOperation using the Ceylon compiler (more specifically, the rule for an assignmentExpression).

Parameters:
  • update = noop
compileLogicalOperationSource Codeshared LogicalOperation? compileLogicalOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Logical Operation into a LogicalOperation using the Ceylon compiler (more specifically, the rule for a disjunctionExpression).

Parameters:
  • update = noop
compileMainTypeSource Codeshared MainType? compileMainType(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Main Type into a MainType using the Ceylon compiler (more specifically, the rule for a unionType).

Parameters:
  • update = noop
compileMatchCaseSource Codeshared MatchCase? compileMatchCase(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Match Case into a MatchCase using the Ceylon compiler (more specifically, the rule for a matchCaseCondition).

Parameters:
  • update = noop
compileMeasureOperationSource Codeshared MeasureOperation? compileMeasureOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Measure Operation into a MeasureOperation using the Ceylon compiler (more specifically, the rule for an entryRangeExpression).

Parameters:
  • update = noop
compileMeasureSubscriptSource Codeshared MeasureSubscript? compileMeasureSubscript(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Measure Subscript into a MeasureSubscript using the Ceylon compiler (more specifically, the rule for an indexOrIndexRange).

Parameters:
  • update = noop
compileMemberDecSource Codeshared MemberDec? compileMemberDec(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Member Dec into a MemberDec using the Ceylon compiler (more specifically, the rule for a metaLiteral).

Parameters:
  • update = noop
compileMemberMetaSource Codeshared MemberMeta? compileMemberMeta(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Member Meta into a MemberMeta using the Ceylon compiler (more specifically, the rule for a metaLiteral).

Parameters:
  • update = noop
compileMemberOperatorSource Codeshared MemberOperator? compileMemberOperator(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Member Operator into a MemberOperator using the Ceylon compiler (more specifically, the rule for a memberSelectionOperator).

Parameters:
  • update = noop
compileMetaSource Codeshared Meta? compileMeta(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Meta into a Meta using the Ceylon compiler (more specifically, the rule for a metaLiteral).

Parameters:
  • update = noop
compileModifierSource Codeshared Modifier? compileModifier(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Modifier into a Modifier using the Ceylon compiler (more specifically, the lexer).

Parameters:
  • update = noop
compileModuleBodySource Codeshared ModuleBody? compileModuleBody(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Module Body into a ModuleBody using the Ceylon compiler (more specifically, the rule for a moduleBody).

Parameters:
  • update = noop
compileModuleCompilationUnitSource Codeshared ModuleCompilationUnit? compileModuleCompilationUnit(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Module Compilation Unit into a ModuleCompilationUnit using the Ceylon compiler (more specifically, the rule for a compilationUnit).

Parameters:
  • update = noop
compileModuleDecSource Codeshared ModuleDec? compileModuleDec(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Module Dec into a ModuleDec using the Ceylon compiler (more specifically, the rule for a metaLiteral).

Parameters:
  • update = noop
compileModuleDescriptorSource Codeshared ModuleDescriptor? compileModuleDescriptor(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Module Descriptor into a ModuleDescriptor using the Ceylon compiler (more specifically, the rule for a moduleDescriptor).

Parameters:
  • update = noop
compileModuleImportSource Codeshared ModuleImport? compileModuleImport(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Module Import into a ModuleImport using the Ceylon compiler (more specifically, the rule for an importModuleList).

Parameters:
  • update = noop
compileMultiplyAssignmentOperationSource Codeshared MultiplyAssignmentOperation? compileMultiplyAssignmentOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Multiply Assignment Operation into a MultiplyAssignmentOperation using the Ceylon compiler (more specifically, the rule for an assignmentExpression).

Parameters:
  • update = noop
compileNamedArgumentSource Codeshared NamedArgument? compileNamedArgument(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Named Argument into a NamedArgument using the Ceylon compiler (more specifically, the rules for a namedArgument and for an anonymousArgument).

Parameters:
  • update = noop
compileNamedArgumentsSource Codeshared NamedArguments? compileNamedArguments(String code, Anything(JNode, Node) update = ...)

Compiles the given code for Named Arguments into NamedArguments using the Ceylon compiler (more specifically, the rule for namedArguments).

Parameters:
  • update = noop
compileNegationOperationSource Codeshared NegationOperation? compileNegationOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Negation Operation into a NegationOperation using the Ceylon compiler (more specifically, the rule for a negationComplementExpression).

Parameters:
  • update = noop
compileNonemptyConditionSource Codeshared NonemptyCondition? compileNonemptyCondition(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Nonempty Condition into a NonemptyCondition using the Ceylon compiler (more specifically, the rule for a nonemptyCondition).

Parameters:
  • update = noop
compileNonemptyOperationSource Codeshared NonemptyOperation? compileNonemptyOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Nonempty Operation into a NonemptyOperation using the Ceylon compiler (more specifically, the rule for a existenceEmptinessExpression).

Parameters:
  • update = noop
compileNotEqualOperationSource Codeshared NotEqualOperation? compileNotEqualOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Not Equal Operation into a NotEqualOperation using the Ceylon compiler (more specifically, the rule for a equalityExpression).

Parameters:
  • update = noop
compileNotOperationSource Codeshared NotOperation? compileNotOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Not Operation into a NotOperation using the Ceylon compiler (more specifically, the rule for a logicalNegationExpression).

Parameters:
  • update = noop
compileObjectArgumentSource Codeshared ObjectArgument? compileObjectArgument(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Object Argument into an ObjectArgument using the Ceylon compiler (more specifically, the rule for an objectArgument).

Parameters:
  • update = noop
compileObjectDefinitionSource Codeshared ObjectDefinition? compileObjectDefinition(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Object Definition into an ObjectDefinition using the Ceylon compiler (more specifically, the rule for an declaration).

Parameters:
  • update = noop
compileObjectExpressionSource Codeshared ObjectExpression? compileObjectExpression(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Object Expression into an ObjectExpression using the Ceylon compiler (more specifically, the rule for an objectExpression).

Parameters:
  • update = noop
compileOfOperationSource Codeshared OfOperation? compileOfOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Of Operation into an OfOperation using the Ceylon compiler (more specifically, the rule for a comparisonExpression).

Parameters:
  • update = noop
compileOperationSource Codeshared Operation? compileOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Operation into an Operation using the Ceylon compiler (more specifically, the rule for an assignmentExpression).

Parameters:
  • update = noop
compileOptionalTypeSource Codeshared OptionalType? compileOptionalType(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Optional Type into an OptionalType using the Ceylon compiler (more specifically, the rule for an primaryType).

Parameters:
  • update = noop
compileOrAssignmentOperationSource Codeshared OrAssignmentOperation? compileOrAssignmentOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Or Assignment Operation into an OrAssignmentOperation using the Ceylon compiler (more specifically, the rule for an assignmentExpression).

Parameters:
  • update = noop
compileOrOperationSource Codeshared OrOperation? compileOrOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Or Operation into an OrOperation using the Ceylon compiler (more specifically, the rule for an disjunctionExpression).

Parameters:
  • update = noop
compileOutModifierSource Codeshared OutModifier? compileOutModifier(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Out Modifier into an OutModifier using the Ceylon compiler (more specifically, the rule for a variance).

Parameters:
  • update = noop
compileOuterSource Codeshared Outer? compileOuter(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Outer into an Outer using the Ceylon compiler (more specifically, the rule for a selfReference).

Parameters:
  • update = noop
compilePIdentifierSource Codeshared LIdentifier? compilePIdentifier(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Package Identifier into an LIdentifier using the Ceylon compiler (more specifically, the rule for a packageName).

Parameters:
  • update = noop
compilePackageSource Codeshared Package? compilePackage(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Package into a Package using the Ceylon compiler (more specifically, the rule for a selfReference).

Parameters:
  • update = noop
compilePackageCompilationUnitSource Codeshared PackageCompilationUnit? compilePackageCompilationUnit(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Package Compilation Unit into a PackageCompilationUnit using the Ceylon compiler (more specifically, the rule for a compilationUnit).

Parameters:
  • update = noop
compilePackageDecSource Codeshared PackageDec? compilePackageDec(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Package Dec into a PackageDec using the Ceylon compiler (more specifically, the rule for a metaLiteral).

Parameters:
  • update = noop
compilePackageDescriptorSource Codeshared PackageDescriptor? compilePackageDescriptor(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Package Descriptor into a PackageDescriptor using the Ceylon compiler (more specifically, the rule for a packageDescriptor).

Parameters:
  • update = noop
compileParameterSource Codeshared Parameter? compileParameter(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Parameter into a Parameter using the Ceylon compiler (more specifically, the rule for a parameterDeclarationOrRef).

Parameters:
  • update = noop
compileParameterReferenceSource Codeshared ParameterReference? compileParameterReference(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Parameter Reference into a ParameterReference using the Ceylon compiler (more specifically, the rule for a parameterRef).

Parameters:
  • update = noop
compileParametersSource Codeshared Parameters? compileParameters(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Parameters into a Parameters using the Ceylon compiler (more specifically, the rule for a parameters).

Parameters:
  • update = noop
compilePatternSource Codeshared Pattern? compilePattern(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Pattern into a Pattern using the Ceylon compiler (more specifically, the rule for a pattern).

Parameters:
  • update = noop
compilePositionalArgumentsSource Codeshared PositionalArguments? compilePositionalArguments(String code, Anything(JNode, Node) update = ...)

Compiles the given code for Positional Arguments into PositionalArguments using the Ceylon compiler (more specifically, the rule for positionalArguments).

Parameters:
  • update = noop
compilePostfixDecrementOperationSource Codeshared PostfixDecrementOperation? compilePostfixDecrementOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Postfix Decrement Operation into a PostfixDecrementOperation using the Ceylon compiler (more specifically, the rule for a postfixIncrementDecrementExpression).

Parameters:
  • update = noop
compilePostfixIncrementOperationSource Codeshared PostfixIncrementOperation? compilePostfixIncrementOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Postfix Increment Operation into a PostfixIncrementOperation using the Ceylon compiler (more specifically, the rule for a postfixIncrementDecrementExpression).

Parameters:
  • update = noop
compilePostfixOperationSource Codeshared PostfixOperation? compilePostfixOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Postfix Operation into a PostfixOperation using the Ceylon compiler (more specifically, the rule for a postfixIncrementDecrementExpression).

Parameters:
  • update = noop
compilePrefixDecrementOperationSource Codeshared PrefixDecrementOperation? compilePrefixDecrementOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Prefix Decrement Operation into a PrefixDecrementOperation using the Ceylon compiler (more specifically, the rule for n incrementDecrementExpression).

Parameters:
  • update = noop
compilePrefixIncrementOperationSource Codeshared PrefixIncrementOperation? compilePrefixIncrementOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Prefix Increment Operation into a PrefixIncrementOperation using the Ceylon compiler (more specifically, the rule for an incrementDecrementExpression).

Parameters:
  • update = noop
compilePrefixOperationSource Codeshared PrefixOperation? compilePrefixOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Prefix Operation into a PrefixOperation using the Ceylon compiler (more specifically, the rule for an incrementDecrementExpression).

Parameters:
  • update = noop
compilePrefixPostfixStatementSource Codeshared PrefixPostfixStatement? compilePrefixPostfixStatement(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Prefix Postfix Statement into a PrefixPostfixStatement using the Ceylon compiler (more specifically, the rule for an expressionOrSpecificationStatement).

Parameters:
  • update = noop
compilePrimarySource Codeshared Primary? compilePrimary(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Primary into a Primary using the Ceylon compiler (more specifically, the rule for a primary).

Parameters:
  • update = noop
compilePrimaryTypeSource Codeshared PrimaryType? compilePrimaryType(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Primary Type into a PrimaryType using the Ceylon compiler (more specifically, the rule for a primaryType).

Parameters:
  • update = noop
compileProductOperationSource Codeshared ProductOperation? compileProductOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Product Operation into a ProductOperation using the Ceylon compiler (more specifically, the rule for a multiplicativeExpression).

Parameters:
  • update = noop
compileQualifiedExpressionSource Codeshared QualifiedExpression? compileQualifiedExpression(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Qualified Expression into a QualifiedExpression using the Ceylon compiler (more specifically, the rule for a primary).

Parameters:
  • update = noop
compileQualifiedTypeSource Codeshared QualifiedType? compileQualifiedType(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Qualified Type into a QualifiedType using the Ceylon compiler (more specifically, the rule for a qualifiedType).

Parameters:
  • update = noop
compileQuotientOperationSource Codeshared QuotientOperation? compileQuotientOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Quotient Operation into a QuotientOperation using the Ceylon compiler (more specifically, the rule for a multiplicativeExpression).

Parameters:
  • update = noop
compileRangeSubscriptSource Codeshared RangeSubscript? compileRangeSubscript(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Range Subscript into a RangeSubscript using the Ceylon compiler (more specifically, the rule for an indexOrIndexRange).

Parameters:
  • update = noop
compileRemainderAssignmentOperationSource Codeshared RemainderAssignmentOperation? compileRemainderAssignmentOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Remainder Assignment Operation into a RemainderAssignmentOperation using the Ceylon compiler (more specifically, the rule for a assignmentExpression).

Parameters:
  • update = noop
compileRemainderOperationSource Codeshared RemainderOperation? compileRemainderOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Remainder Operation into a RemainderOperation using the Ceylon compiler (more specifically, the rule for a multiplicativeExpression).

Parameters:
  • update = noop
compileRequiredParameterSource Codeshared RequiredParameter? compileRequiredParameter(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Required Parameter into a RequiredParameter using the Ceylon compiler (more specifically, the rule for a parameterDeclarationOrRef).

Parameters:
  • update = noop
compileResourceSource Codeshared Resource? compileResource(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Resource into a Resource using the Ceylon compiler (more specifically, the rule for a resource).

Parameters:
  • update = noop
compileResourcesSource Codeshared Resources? compileResources(String code, Anything(JNode, Node) update = ...)

Compiles the given code for Resources into Resources using the Ceylon compiler (more specifically, the rule for resources).

Parameters:
  • update = noop
compileReturnSource Codeshared Return? compileReturn(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Return into a Return using the Ceylon compiler (more specifically, the rule for a return).

Parameters:
  • update = noop
compileSafeMemberOperatorSource Codeshared SafeMemberOperator? compileSafeMemberOperator(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Safe Member Operator into a SafeMemberOperator using the Ceylon compiler (more specifically, the rule for a memberSelectionOperator).

Parameters:
  • update = noop
compileSatisfiedTypesSource Codeshared SatisfiedTypes? compileSatisfiedTypes(String code, Anything(JNode, Node) update = ...)

Compiles the given code for Satisfied Types into SatisfiedTypes using the Ceylon compiler (more specifically, the rule for satisfiedTypes).

Parameters:
  • update = noop
compileScaleOperationSource Codeshared ScaleOperation? compileScaleOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Scale Operation into a ScaleOperation using the Ceylon compiler (more specifically, the rule for a scaleExpression).

Parameters:
  • update = noop
compileSelfReferenceSource Codeshared SelfReference? compileSelfReference(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Self Reference into a SelfReference using the Ceylon compiler (more specifically, the rule for a selfReference).

Parameters:
  • update = noop
compileSequentialTypeSource Codeshared SequentialType? compileSequentialType(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Sequential Type into a SequentialType using the Ceylon compiler (more specifically, the rule for an primaryType).

Parameters:
  • update = noop
compileSetAssignmentOperationSource Codeshared SetAssignmentOperation? compileSetAssignmentOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Set Assignment Operation into a SetAssignmentOperation using the Ceylon compiler (more specifically, the rule for an assignmentExpression).

Parameters:
  • update = noop
compileSetOperationSource Codeshared SetOperation? compileSetOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Set Operation into a SetOperation using the Ceylon compiler (more specifically, the rule for a unionExpression).

Parameters:
  • update = noop
compileSimpleTypeSource Codeshared SimpleType? compileSimpleType(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Simple Type into a SimpleType using the Ceylon compiler (more specifically, the rule for a qualifiedType).

Parameters:
  • update = noop
compileSmallAsOperationSource Codeshared SmallAsOperation? compileSmallAsOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Small As Operation into a SmallAsOperation using the Ceylon compiler (more specifically, the rule for a comparisonExpression).

Parameters:
  • update = noop
compileSmallerOperationSource Codeshared SmallerOperation? compileSmallerOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Smaller Operation into a SmallerOperation using the Ceylon compiler (more specifically, the rule for a comparisonExpression).

Parameters:
  • update = noop
compileSpanFromSubscriptSource Codeshared