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.2
ceylon.interop.java1.2.2
com.redhat.ceylon.typechecker1.2.2
Values
originalNodeKeyshared Key<JNode> originalNodeKey

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

Functions
aIdentifierToCeylonshared 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
  • AssertionError

    If the token type is not AIDENTIFIER.

aStringLiteralToCeylonshared 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.

addAssignmentOperationToCeylonshared 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

aliasDecToCeylonshared 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
andAssignmentOperationToCeylonshared 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

andOperationToCeylonshared 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

annotationToCeylonshared 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
annotationsToCeylonshared Annotations annotationsToCeylon(Tree.JAnnotationList annotations, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
anonymousArgumentToCeylonshared 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
anyClassToCeylonshared 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
anyCompilationUnitToCeylonshared AnyCompilationUnit anyCompilationUnitToCeylon(Tree.JCompilationUnit anyCompilationUnit, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
anyFunctionToCeylonshared 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
anyInterfaceDefinitionToCeylonshared AnyInterfaceDefinition anyInterfaceDefinitionToCeylon(Tree.JInterfaceDefinition anyInterfaceDefinition, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
anyInterfaceToCeylonshared 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
anyMemberOperatorToCeylonshared 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
anySpecifierToCeylonshared AnySpecifier anySpecifierToCeylon(Tree.JSpecifierExpression anySpecifier, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
anyTypeArgumentsToCeylonshared 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
anyValueToCeylonshared 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
argumentListToCeylonshared 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
argumentsToCeylonshared 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
arithmeticAssignmentOperationToCeylonshared 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
arithmeticOperationToCeylonshared 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
assertionToCeylonshared Assertion assertionToCeylon(Tree.JAssertion assertion, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
assignOperationToCeylonshared 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

assignmentOperationToCeylonshared 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
assignmentStatementToCeylonshared 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
atomToCeylonshared Atom atomToCeylon(Tree.JAtom atom, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
attachOriginalNodeshared 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.

baseExpressionToCeylonshared 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
baseMetaToCeylonshared 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)
baseTypeToCeylonshared BaseType baseTypeToCeylon(Tree.JBaseType baseType, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
binaryOperationToCeylonshared 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
blockToCeylonshared Block blockToCeylon(Tree.JBlock block, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
bodyToCeylonshared 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
booleanConditionToCeylonshared BooleanCondition booleanConditionToCeylon(Tree.JBooleanCondition booleanCondition, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
boundToCeylonshared 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
breakToCeylonshared Break breakToCeylon(Tree.JBreak break, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
callableConstructorDefinitionToCeylonshared CallableConstructorDefinition callableConstructorDefinitionToCeylon(Tree.JConstructor callableConstructorDefinition, Anything(JNode, Node) update = ...)

Converts a RedHat AST Constructor to a ceylon.ast CallableConstructorDefinition.

Parameters:
  • update = noop
callableParameterToCeylonshared 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
callableTypeToCeylonshared CallableType callableTypeToCeylon(Tree.JFunctionType callableType, Anything(JNode, Node) update = ...)

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

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

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

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

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

Parameters:
  • update = noop
caseItemToCeylonshared 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
caseTypesToCeylonshared 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
catchClauseToCeylonshared CatchClause catchClauseToCeylon(Tree.JCatchClause catchClause, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
characterLiteralToCeylonshared 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
  • AssertionError

    If the token type is not CHAR_LITERAL.

classAliasDefinitionToCeylonshared ClassAliasDefinition classAliasDefinitionToCeylon(Tree.JClassDeclaration classAliasDefinition, Anything(JNode, Node) update = ...)

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

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

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

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

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

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

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

Parameters:
  • update = noop
classOrInterfaceToCeylonshared 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
classSpecifierToCeylonshared ClassSpecifier classSpecifierToCeylon(Tree.JClassSpecifier classSpecifier, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
closedBoundToCeylonshared 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

compareOperationToCeylonshared 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

comparisonOperationToCeylonshared 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
compilationUnitToCeylonshared 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

compileAddAssignmentOperationshared 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
compileAliasDecshared 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
compileAndAssignmentOperationshared 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
compileAndOperationshared 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
compileAnnotationshared 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
compileAnnotationsshared 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
compileAnonymousArgumentshared 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
compileAnyClassshared 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
compileAnyCompilationUnitshared 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
compileAnyFunctionshared 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
compileAnyInterfaceshared 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
compileAnyInterfaceDefinitionshared 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
compileAnyMemberOperatorshared 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
compileAnySpecifiershared 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
compileAnyValueshared 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
compileArgumentListshared 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
compileArgumentsshared 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
compileArithmeticAssignmentOperationshared 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
compileArithmeticOperationshared 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
compileAssertionshared 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
compileAssignOperationshared 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
compileAssignmentOperationshared 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
compileAssignmentStatementshared 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
compileAtomshared 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
compileBaseExpressionshared 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
compileBaseMetashared 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
compileBaseTypeshared 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
compileBinaryOperationshared 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
compileBlockshared 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
compileBooleanConditionshared 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
compileBreakshared 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
compileCallableConstructorDefinitionshared CallableConstructorDefinition? compileCallableConstructorDefinition(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileCallableParametershared 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
compileCallableTypeshared 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
compileCaseClauseshared 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
compileCaseItemshared 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
compileCaseTypesshared 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
compileCatchClauseshared 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
compileCharacterLiteralshared 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
compileClassAliasDefinitionshared 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
compileClassBodyshared 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
compileClassDecshared 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
compileClassDefinitionshared 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
compileClassOrInterfaceshared 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
compileClassSpecifiershared 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
compileCompareOperationshared 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
compileComparisonOperationshared 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
compileCompilationUnitshared 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
compileComplementAssignmentOperationshared 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
compileComplementOperationshared 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
compileComprehensionshared 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
compileComprehensionClauseshared 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
compileConditionshared 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
compileConditionalExpressionshared 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
compileConditionsshared 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
compileConstructionshared 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
compileConstructorDecshared 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
compileConstructorDefinitionshared 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
compileContinueshared 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
compileControlStructureshared 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
compileDecshared 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
compileDeclarationshared 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
compileDefaultedCallableParametershared 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
compileDefaultedParametershared 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
compileDefaultedParameterReferenceshared 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
compileDefaultedTypeshared 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
compileDefaultedValueParametershared 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
compileDestructureshared 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
compileDifferenceOperationshared 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
compileDirectiveshared 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
compileDivideAssignmentOperationshared 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
compileDynamicBlockshared 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
compileDynamicInterfaceDefinitionshared 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
compileDynamicModifiershared 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
compileDynamicValueshared 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
compileElementOrSubrangeExpressionshared 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
compileElseClauseshared 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
compileElseOperationshared 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
compileEntryOperationshared 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
compileEntryPatternshared 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
compileEntryTypeshared 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
compileEqualOperationshared 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
compileEqualityOperationshared 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
compileExistsConditionshared 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
compileExistsOperationshared 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
compileExistsOrNonemptyConditionshared 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
compileExponentiationOperationshared 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
compileExpressionshared 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
compileExpressionComprehensionClauseshared 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
compileExpressionStatementshared 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
compileExtendedTypeshared 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
compileExtensionshared 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
compileExtensionOrConstructionshared 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
compileFailClauseshared 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
compileFinallyClauseshared 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
compileFloatLiteralshared 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
compileForClauseshared 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
compileForComprehensionClauseshared 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
compileForFailshared 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
compileForIteratorshared 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
compileFullPackageNameshared 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
compileFunctionArgumentshared 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
compileFunctionDecshared 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
compileFunctionDeclarationshared 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
compileFunctionDefinitionshared 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
compileFunctionExpressionshared 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
compileFunctionModifiershared 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
compileFunctionShortcutDefinitionshared 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
compileGivenDecshared 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
compileGroupedExpressionshared 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
compileGroupedTypeshared 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
compileIdenticalOperationshared 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
compileIdentifiershared 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
compileIdentityOperationshared 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
compileIfClauseshared 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
compileIfComprehensionClauseshared 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
compileIfElseshared 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
compileIfElseExpressionshared 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
compileImportshared 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
compileImportAliasshared 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
compileImportElementshared 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
compileImportElementsshared 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
compileImportFunctionValueAliasshared 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
compileImportFunctionValueElementshared 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
compileImportTypeAliasshared 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
compileImportTypeElementshared 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
compileImportWildcardshared 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
compileInModifiershared 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
compileInOperationshared 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
compileInitialComprehensionClauseshared 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
compileInlineDefinitionArgumentshared 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
compileIntegerLiteralshared 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
compileInterfaceAliasDefinitionshared 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
compileInterfaceBodyshared 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
compileInterfaceDecshared 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
compileInterfaceDefinitionshared 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
compileIntersectAssignmentOperationshared 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
compileIntersectionOperationshared 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
compileIntersectionTypeshared 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
compileInvocationshared 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
compileInvocationStatementshared 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
compileIsCaseshared 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
compileIsConditionshared 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
compileIsOperationshared 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
compileIterableshared 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
compileIterableTypeshared 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
compileKeySubscriptshared 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
compileLIdentifiershared 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
compileLargeAsOperationshared 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
compileLargerOperationshared 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
compileLazySpecificationshared 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
compileLazySpecifiershared 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
compileLetExpressionshared 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
compileLiteralshared 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
compileLocalModifiershared 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
compileLogicalAssignmentOperationshared 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
compileLogicalOperationshared 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
compileMainTypeshared 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
compileMatchCaseshared 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
compileMeasureOperationshared 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
compileMeasureSubscriptshared 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
compileMemberDecshared 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
compileMemberMetashared 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
compileMemberOperatorshared 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
compileMetashared 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
compileModifiershared 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
compileModuleBodyshared 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
compileModuleCompilationUnitshared 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
compileModuleDecshared 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
compileModuleDescriptorshared 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
compileModuleImportshared 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
compileMultiplyAssignmentOperationshared 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
compileNamedArgumentshared 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
compileNamedArgumentsshared 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
compileNegationOperationshared 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
compileNonemptyConditionshared 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
compileNonemptyOperationshared 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
compileNotEqualOperationshared 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
compileNotOperationshared 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
compileObjectArgumentshared 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
compileObjectDefinitionshared 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
compileObjectExpressionshared 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
compileOfOperationshared 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
compileOperationshared 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
compileOptionalTypeshared 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
compileOrAssignmentOperationshared 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
compileOrOperationshared 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
compileOutModifiershared 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
compileOutershared 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
compilePIdentifiershared 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
compilePackageshared 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
compilePackageCompilationUnitshared 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
compilePackageDecshared 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
compilePackageDescriptorshared 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
compileParametershared 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
compileParameterReferenceshared 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
compileParametersshared 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
compilePatternshared 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
compilePositionalArgumentsshared 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
compilePostfixDecrementOperationshared 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
compilePostfixIncrementOperationshared 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
compilePostfixOperationshared 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
compilePrefixDecrementOperationshared 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
compilePrefixIncrementOperationshared 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
compilePrefixOperationshared 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
compilePrefixPostfixStatementshared 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
compilePrimaryshared 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
compilePrimaryTypeshared 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
compileProductOperationshared 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
compileQualifiedExpressionshared 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
compileQualifiedTypeshared 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
compileQuotientOperationshared 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
compileRangeSubscriptshared 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
compileRemainderAssignmentOperationshared 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
compileRemainderOperationshared 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
compileRequiredParametershared 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
compileResourceshared 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
compileResourcesshared 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
compileReturnshared 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
compileSafeMemberOperatorshared 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
compileSatisfiedTypesshared 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
compileScaleOperationshared 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
compileSelfReferenceshared 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
compileSequentialTypeshared 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
compileSetAssignmentOperationshared 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
compileSetOperationshared 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
compileSimpleTypeshared 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
compileSmallAsOperationshared 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
compileSmallerOperationshared 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
compileSpanFromSubscriptshared SpanFromSubscript? compileSpanFromSubscript(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileSpanOperationshared SpanOperation? compileSpanOperation(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileSpanSubscriptshared SpanSubscript? compileSpanSubscript(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileSpanToSubscriptshared SpanToSubscript? compileSpanToSubscript(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileSpecificationshared Specification? compileSpecification(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileSpecifiedArgumentshared SpecifiedArgument? compileSpecifiedArgument(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Specified Argument into a SpecifiedArgument using the Ceylon compiler (more specifically, the rule for a namedArgument).

Parameters:
  • update = noop
compileSpecifiershared Specifier? compileSpecifier(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileSpreadArgumentshared SpreadArgument? compileSpreadArgument(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Spread Argument into a SpreadArgument using the Ceylon compiler (more specifically, the rule for a spreadArgument).

Parameters:
  • update = noop
compileSpreadMemberOperatorshared SpreadMemberOperator? compileSpreadMemberOperator(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileSpreadTypeshared SpreadType? compileSpreadType(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Spread Type into a SpreadType using the Ceylon compiler (more specifically, the rule for a spreadType).

Parameters:
  • update = noop
compileStatementshared Statement? compileStatement(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileStringLiteralshared StringLiteral? compileStringLiteral(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a String Literal into a StringLiteral using the Ceylon compiler (more specifically, the rule for a stringLiteral).

Parameters:
  • update = noop
compileStringTemplateshared StringTemplate? compileStringTemplate(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a String Template into a StringTemplate using the Ceylon compiler (more specifically, the rule for a stringExpression).

Parameters:
  • update = noop
compileSubscriptshared Subscript? compileSubscript(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileSubtractAssignmentOperationshared SubtractAssignmentOperation? compileSubtractAssignmentOperation(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileSumOperationshared SumOperation? compileSumOperation(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileSupershared Super? compileSuper(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileSwitchCaseElseshared SwitchCaseElse? compileSwitchCaseElse(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Switch Case Else into a SwitchCaseElse using the Ceylon compiler (more specifically, the rule for a switchCaseElse).

Parameters:
  • update = noop
compileSwitchCaseElseExpressionshared SwitchCaseElseExpression? compileSwitchCaseElseExpression(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Switch Case Else Expression into a SwitchCaseElseExpression using the Ceylon compiler (more specifically, the rule for a switchExpression).

Parameters:
  • update = noop
compileSwitchCasesshared SwitchCases? compileSwitchCases(String code, Anything(JNode, Node) update = ...)

Compiles the given code for Switch Cases into SwitchCases using the Ceylon compiler (more specifically, the rule for cases).

Parameters:
  • update = noop
compileSwitchClauseshared SwitchClause? compileSwitchClause(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Switch Clause into a SwitchClause using the Ceylon compiler (more specifically, the rule for a switchHeader).

Parameters:
  • update = noop
compileThenOperationshared ThenOperation? compileThenOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Then Operation into a ThenOperation using the Ceylon compiler (more specifically, the rule for a thenElseExpression).

Parameters:
  • update = noop
compileThisshared This? compileThis(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileThrowshared Throw? compileThrow(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileTryCatchFinallyshared TryCatchFinally? compileTryCatchFinally(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Try Catch Finally into a TryCatchFinally using the Ceylon compiler (more specifically, the rule for a tryCatchFinally).

Parameters:
  • update = noop
compileTryClauseshared TryClause? compileTryClause(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Try Clause into a TryClause using the Ceylon compiler (more specifically, the rule for a tryBlock).

Parameters:
  • update = noop
compileTupleshared Tuple? compileTuple(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileTuplePatternshared TuplePattern? compileTuplePattern(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileTupleTypeshared TupleType? compileTupleType(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Tuple Type into a TupleType using the Ceylon compiler (more specifically, the rule for a tupleType).

Parameters:
  • update = noop
compileTypeshared Type? compileType(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileTypeAliasDefinitionshared TypeAliasDefinition? compileTypeAliasDefinition(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileTypeArgumentsshared TypeArguments? compileTypeArguments(String code, Anything(JNode, Node) update = ...)

Compiles the given code for Type Arguments into a TypeArguments using the Ceylon compiler (more specifically, the rule for typeArguments).

Parameters:
  • update = noop
compileTypeConstraintshared TypeConstraint? compileTypeConstraint(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Type Constraint into a TypeConstraint using the Ceylon compiler (more specifically, the rule for a typeConstraint).

Parameters:
  • update = noop
compileTypeDecshared TypeDec? compileTypeDec(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileTypeDeclarationshared TypeDeclaration? compileTypeDeclaration(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileTypeIshshared TypeIsh? compileTypeIsh(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Type-ish into a TypeIsh using the Ceylon compiler (more specifically, the rule for a type, variadicType or defaultedType).

Parameters:
  • update = noop
compileTypeMetashared TypeMeta? compileTypeMeta(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileTypeModifiershared TypeModifier? compileTypeModifier(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileTypeParametershared TypeParameter? compileTypeParameter(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileTypeParametersshared TypeParameters? compileTypeParameters(String code, Anything(JNode, Node) update = ...)

Compiles the given code for Type Parameters into TypeParameters using the Ceylon compiler (more specifically, the rule for typeParameters).

Parameters:
  • update = noop
compileTypeSpecifiershared TypeSpecifier? compileTypeSpecifier(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Type Specifier into a TypeSpecifier using the Ceylon compiler (more specifically, the rule for a typeSpecifier).

Parameters:
  • update = noop
compileTypedDeclarationshared TypedDeclaration? compileTypedDeclaration(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileUIdentifiershared UIdentifier? compileUIdentifier(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Uppercase Identifier into a UIdentifier using the Ceylon compiler (more specifically, the rule for a Type Name).

Parameters:
  • update = noop
compileUnaryArithmeticOperationshared UnaryArithmeticOperation? compileUnaryArithmeticOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Unary Arithmetic Operation into an UnaryArithmeticOperation using the Ceylon compiler (more specifically, the rule for an negationComplementExpression).

Parameters:
  • update = noop
compileUnaryIshOperationshared UnaryIshOperation? compileUnaryIshOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for an Unary Ish Operation into an UnaryIshOperation using the Ceylon compiler (more specifically, the rule for an unaryIshOperation).

Parameters:
  • update = noop
compileUnaryOperationshared UnaryOperation? compileUnaryOperation(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileUnaryTypeOperationshared UnaryTypeOperation? compileUnaryTypeOperation(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileUnionAssignmentOperationshared UnionAssignmentOperation? compileUnionAssignmentOperation(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileUnionOperationshared UnionOperation? compileUnionOperation(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Union Operation into an UnionOperation using the Ceylon compiler (more specifically, the rule for a unionExpression).

Parameters:
  • update = noop
compileUnionTypeshared UnionType? compileUnionType(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Union Type into an UnionType using the Ceylon compiler (more specifically, the rule for a unionType).

Parameters:
  • update = noop
compileUnionableTypeshared UnionableType? compileUnionableType(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Unionable Type into a UnionableType using the Ceylon compiler (more specifically, the rule for an intersectionType).

Parameters:
  • update = noop
compileValueArgumentshared ValueArgument? compileValueArgument(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileValueConstructorDefinitionshared ValueConstructorDefinition? compileValueConstructorDefinition(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileValueDecshared ValueDec? compileValueDec(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileValueDeclarationshared ValueDeclaration? compileValueDeclaration(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileValueDefinitionshared ValueDefinition? compileValueDefinition(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileValueExpressionshared ValueExpression? compileValueExpression(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileValueGetterDefinitionshared ValueGetterDefinition? compileValueGetterDefinition(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Value Getter Definition into a ValueGetterDefinition using the Ceylon compiler (more specifically, the rule for a declaration).

Parameters:
  • update = noop
compileValueModifiershared ValueModifier? compileValueModifier(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileValueParametershared ValueParameter? compileValueParameter(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileValueSetterDefinitionshared ValueSetterDefinition? compileValueSetterDefinition(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Value Setter Definition into a ValueSetterDefinition using the Ceylon compiler (more specifically, the rule for a declaration).

Parameters:
  • update = noop
compileValueSpecificationshared ValueSpecification? compileValueSpecification(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileVariablePatternshared VariablePattern? compileVariablePattern(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileVariadicParametershared VariadicParameter? compileVariadicParameter(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileVariadicTypeshared VariadicType? compileVariadicType(String code, Anything(JNode, Node) update = ...)

Compiles the given code for a Variadic Type into a VariadicType using the Ceylon compiler (more specifically, the rule for a variadicType).

Parameters:
  • update = noop
compileVarianceshared Variance? compileVariance(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileVoidModifiershared VoidModifier? compileVoidModifier(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileWhileshared While? compileWhile(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
compileWithinOperationshared WithinOperation? compileWithinOperation(String code, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
complementAssignmentOperationToCeylonshared ComplementAssignmentOperation complementAssignmentOperationToCeylon(Tree.JComplementAssignOp complementAssignmentOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST ComplementAssignOp to a ceylon.ast ComplementAssignmentOperation.

Parameters:
  • complementAssignmentOperation
    • Check precedence

  • update = noop
    • Check precedence

complementOperationToCeylonshared ComplementOperation complementOperationToCeylon(Tree.JComplementOp complementOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST ComplementOp to a ceylon.ast ComplementOperation.

Parameters:
  • complementOperation
    • Check precedence

  • update = noop
    • Check precedence

comprehensionClauseToCeylonshared ComprehensionClause comprehensionClauseToCeylon(Tree.JComprehensionClause comprehensionClause, Anything(JNode, Node) update = ...)

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

Parameters:
  • comprehensionClause
    • is JInitialComprehensionClause|JExpressionComprehensionClause comprehensionClause
  • update = noop
comprehensionToCeylonshared Comprehension comprehensionToCeylon(Tree.JComprehension comprehension, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
conditionToCeylonshared Condition conditionToCeylon(Tree.JCondition condition, Anything(JNode, Node) update = ...)

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

Parameters:
  • condition
    • is JBooleanCondition|JIsCondition|JExistsOrNonemptyCondition condition
  • update = noop
conditionalExpressionToCeylonshared ConditionalExpression conditionalExpressionToCeylon(Tree.JIfExpression|Tree.JSwitchExpression conditionalExpression, Anything(JNode, Node) update = ...)

Converts a RedHat AST IfExpression or SwitchExpression to a ceylon.ast ConditionalExpression.

Parameters:
  • update = noop
conditionsToCeylonshared Conditions conditionsToCeylon(Tree.JConditionList conditions, Anything(JNode, Node) update = ...)

Converts a RedHat AST ConditionList to ceylon.ast Conditions.

Parameters:
  • conditions
    • nonempty conds = CeylonIterable(conditions.conditions).collect(propagateUpdate(conditionToCeylon, update))
  • update = noop
    • nonempty conds = CeylonIterable(conditions.conditions).collect(propagateUpdate(conditionToCeylon, update))
constructionToCeylonshared Construction constructionToCeylon(Tree.JInvocationExpression construction, Anything(JNode, Node) update = ...)

Converts a RedHat AST InvocationExpression to a ceylon.ast Construction.

Parameters:
  • construction
    • is JExtendedTypeExpression ete = construction.primary
  • update = noop
constructorDecToCeylonshared ConstructorDec constructorDecToCeylon(Tree.JNewLiteral constructorDec, Anything(JNode, Node) update = ...)

Converts a RedHat AST NewLiteral to a ceylon.ast ConstructorDec.

Parameters:
  • constructorDec
    • is JQualifiedType jType = constructorDec.type
  • update = noop
constructorDefinitionToCeylonshared ConstructorDefinition constructorDefinitionToCeylon(Tree.JConstructor|Tree.JEnumerated constructorDefinition, Anything(JNode, Node) update = ...)

Converts a RedHat AST Constructor or Enumerated to a ceylon.ast ConstructorDefinition.

Parameters:
  • update = noop
continueToCeylonshared Continue continueToCeylon(Tree.JContinue continue, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
controlStructureToCeylonshared ControlStructure controlStructureToCeylon(Tree.JControlStatement controlStructure, Anything(JNode, Node) update = ...)

Converts a RedHat AST ControlStatement to a ceylon.ast ControlStructure.

Parameters:
  • controlStructure
    • is JIfStatement|JForStatement|JWhileStatement|JSwitchStatement|JTryCatchStatement|JDynamicStatement controlStructure
  • update = noop
createParsershared CeylonParser createParser(String code)

Creates a Ceylon parser that operates on the given code.

decToCeylonshared Dec decToCeylon(Tree.JMetaLiteral dec, Anything(JNode, Node) update = ...)

Converts a RedHat AST MetaLiteral to a ceylon.ast Dec.

Parameters:
  • dec
    • is JClassLiteral|JInterfaceLiteral|JAliasLiteral|JTypeParameterLiteral|JValueLiteral|JFunctionLiteral|JNewLiteral|JModuleLiteral|JPackageLiteral dec
  • update = noop
declarationOrStatementToCeylonshared Declaration|Statement declarationOrStatementToCeylon(Tree.JStatement declarationOrStatement, Anything(JNode, Node) update = ...)

Converts a RedHat AST JStatement to a ceylon.ast Declaration or Statement.

Parameters:
  • declarationOrStatement
    • is JDeclaration|JExecutableStatement declarationOrStatement
  • update = noop
declarationToCeylonshared Declaration declarationToCeylon(Tree.JDeclaration declaration, Anything(JNode, Node) update = ...)

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

Parameters:
  • declaration
    • is JMissingDeclaration|JTypeDeclaration|JTypedDeclaration|JConstructor|JEnumerated|JTypeParameterDeclaration declaration
  • update = noop
defaultedCallableParameterToCeylonshared DefaultedCallableParameter defaultedCallableParameterToCeylon(Tree.JFunctionalParameterDeclaration defaultedCallableParameter, Anything(JNode, Node) update = ...)

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

Parameters:
  • defaultedCallableParameter
    • is JMethodDeclaration dec = defaultedCallableParameter.typedDeclaration
  • update = noop
defaultedParameterReferenceToCeylonshared DefaultedParameterReference defaultedParameterReferenceToCeylon(Tree.JInitializerParameter defaultedParameterReference, Anything(JNode, Node) update = ...)

Converts a RedHat AST InitializerParameter to a ceylon.ast DefaultedParameterReference.

Parameters:
  • defaultedParameterReference
    • Must be defaulted

  • update = noop
defaultedParameterToCeylonshared DefaultedParameter defaultedParameterToCeylon(Tree.JParameter defaultedParameter, Anything(JNode, Node) update = ...)

Converts a RedHat AST Parameter to a ceylon.ast DefaultedParameter.

Parameters:
  • defaultedParameter
    • is JParameterDeclaration|JInitializerParameter defaultedParameter
  • update = noop
defaultedTypeToCeylonshared DefaultedType defaultedTypeToCeylon(Tree.JDefaultedType defaultedType, Anything(JNode, Node) update = ...)

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

Parameters:
  • defaultedType
    • is JStaticType jType = defaultedType.type
  • update = noop
defaultedValueParameterToCeylonshared DefaultedValueParameter defaultedValueParameterToCeylon(Tree.JValueParameterDeclaration defaultedValueParameter, Anything(JNode, Node) update = ...)

Converts a RedHat AST ValueParameterDeclaration to a ceylon.ast DefaultedValueParameter.

Parameters:
  • defaultedValueParameter
    • Must be defaulted

  • update = noop
destructureToCeylonshared Destructure destructureToCeylon(Tree.JDestructure destructure, Anything(JNode, Node) update = ...)

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

Parameters:
  • destructure
    • is TuplePattern|EntryPattern pattern = patternToCeylon(destructure.pattern, update)
  • update = noop
    • is TuplePattern|EntryPattern pattern = patternToCeylon(destructure.pattern, update)
differenceOperationToCeylonshared DifferenceOperation differenceOperationToCeylon(Tree.JDifferenceOp differenceOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST DifferenceOp to a ceylon.ast DifferenceOperation.

Parameters:
  • differenceOperation
    • Check precedence

  • update = noop
    • Check precedence

directiveToCeylonshared Directive directiveToCeylon(Tree.JDirective directive, Anything(JNode, Node) update = ...)

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

Parameters:
  • directive
    • is JReturn|JThrow|JBreak|JContinue directive
  • update = noop
divideAssignmentOperationToCeylonshared DivideAssignmentOperation divideAssignmentOperationToCeylon(Tree.JDivideAssignOp divideAssignmentOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST DivideAssignOp to a ceylon.ast DivideAssignmentOperation.

Parameters:
  • divideAssignmentOperation
    • Check precedence

  • update = noop
    • Check precedence

dynamicBlockToCeylonshared DynamicBlock dynamicBlockToCeylon(Tree.JDynamicStatement dynamicBlock, Anything(JNode, Node) update = ...)

Converts a RedHat AST DynamicStatement to a ceylon.ast DynamicBlock.

Parameters:
  • update = noop
dynamicClauseToCeylonshared DynamicBlock dynamicClauseToCeylon(Tree.JDynamicClause dynamicClause, Anything(JNode, Node) update = ...)

Converts a RedHat AST DynamicClause to a ceylon.ast DynamicBlock.

This function is only offered for convenience, if you happen to have an unwrapped DynamicClause; the real RedHat AST node corresponding to ceylon.ast’s DynamicBlock is DynamicStatement.

Parameters:
  • update = noop
dynamicInterfaceDefinitionToCeylonshared DynamicInterfaceDefinition dynamicInterfaceDefinitionToCeylon(Tree.JInterfaceDefinition dynamicInterfaceDefinition, Anything(JNode, Node) update = ...)

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

Parameters:
  • dynamicInterfaceDefinition
    • Must be dynamic

    • is DynamicInterfaceDefinition ret = anyInterfaceDefinitionToCeylon(dynamicInterfaceDefinition, update)
  • update = noop
    • is DynamicInterfaceDefinition ret = anyInterfaceDefinitionToCeylon(dynamicInterfaceDefinition, update)
Throws
  • AssertionError

    If the interface is not dynamic

dynamicModifierToCeylonshared DynamicModifier dynamicModifierToCeylon(Tree.JDynamicModifier dynamicModifier, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
dynamicValueToCeylonshared DynamicValue dynamicValueToCeylon(Tree.JDynamic dynamicValue, Anything(JNode, Node) update = ...)

Converts a RedHat AST Dynamic to a ceylon.ast DynamicValue.

Parameters:
  • update = noop
elementOrSubrangeExpressionToCeylonshared ElementOrSubrangeExpression elementOrSubrangeExpressionToCeylon(Tree.JIndexExpression elementOrSubrangeExpression, Anything(JNode, Node) update = ...)

Converts a RedHat AST IndexExpression to a ceylon.ast ElementOrSubrangeExpression.

Parameters:
  • update = noop
elseClauseToCeylonshared ElseClause elseClauseToCeylon(Tree.JElseClause elseClause, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
elseOperationToCeylonshared ElseOperation elseOperationToCeylon(Tree.JDefaultOp elseOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST DefaultOp to a ceylon.ast ElseOperation.

Parameters:
  • elseOperation
    • Check precedence

  • update = noop
    • Check precedence

entryOperationToCeylonshared EntryOperation entryOperationToCeylon(Tree.JEntryOp entryOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST EntryOp to a ceylon.ast EntryOperation.

Parameters:
  • entryOperation
    • Check precedence

  • update = noop
    • Check precedence

entryPatternToCeylonshared EntryPattern entryPatternToCeylon(Tree.JKeyValuePattern entryPattern, Anything(JNode, Node) update = ...)

Converts a RedHat AST KeyValuePattern to a ceylon.ast EntryPattern.

Parameters:
  • entryPattern
    • is VariablePattern|TuplePattern key = patternToCeylon(entryPattern.key, update)
    • is VariablePattern|TuplePattern item = patternToCeylon(entryPattern.\ivalue, update)
  • update = noop
    • is VariablePattern|TuplePattern key = patternToCeylon(entryPattern.key, update)
    • is VariablePattern|TuplePattern item = patternToCeylon(entryPattern.\ivalue, update)
entryTypeToCeylonshared EntryType entryTypeToCeylon(Tree.JEntryType entryType, Anything(JNode, Node) update = ...)

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

Parameters:
  • entryType
    • is MainType key = typeToCeylon(entryType.keyType, update)
    • is MainType item = typeToCeylon(entryType.valueType, update)
  • update = noop
    • is MainType key = typeToCeylon(entryType.keyType, update)
    • is MainType item = typeToCeylon(entryType.valueType, update)
equalOperationToCeylonshared EqualOperation equalOperationToCeylon(Tree.JEqualOp equalOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST EqualOp to a ceylon.ast EqualOperation.

Parameters:
  • equalOperation
    • Check precedence

  • update = noop
    • Check precedence

equalityOperationToCeylonshared EqualityOperation equalityOperationToCeylon(Tree.JEqualityOp|Tree.JIdenticalOp equalityOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST EqualityOp or IdenticalOp to a ceylon.ast EqualityOperation.

Parameters:
  • equalityOperation
    • is JEqualOp|JNotEqualOp|JIdenticalOp equalityOperation
  • update = noop
existsConditionToCeylonshared ExistsCondition existsConditionToCeylon(Tree.JExistsCondition existsCondition, Anything(JNode, Node) update = ...)

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

Parameters:
  • existsCondition
    • is ExistsCondition ret = existsOrNonemptyConditionToCeylon(existsCondition, update)
  • update = noop
    • is ExistsCondition ret = existsOrNonemptyConditionToCeylon(existsCondition, update)
existsOperationToCeylonshared ExistsOperation existsOperationToCeylon(Tree.JExists existsOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST Exists to a ceylon.ast ExistsOperation.

Parameters:
  • existsOperation
    • Check precedence

  • update = noop
    • Check precedence

existsOrNonemptyConditionToCeylonshared ExistsOrNonemptyCondition existsOrNonemptyConditionToCeylon(Tree.JExistsOrNonemptyCondition existsOrNonemptyCondition, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
exponentiationOperationToCeylonshared ExponentiationOperation exponentiationOperationToCeylon(Tree.JPowerOp exponentiationExpression, Anything(JNode, Node) update = ...)

Converts a RedHat AST PowerOp to a ceylon.ast ExponentiationOperation.

Parameters:
  • exponentiationExpression
    • is PrePostfixingExpression left = expressionToCeylon(exponentiationExpression.leftTerm, update)
    • is ExponentiatingExpression right = expressionToCeylon(exponentiationExpression.rightTerm, update)
  • update = noop
    • is PrePostfixingExpression left = expressionToCeylon(exponentiationExpression.leftTerm, update)
    • is ExponentiatingExpression right = expressionToCeylon(exponentiationExpression.rightTerm, update)
expressionComprehensionClauseToCeylonshared ExpressionComprehensionClause expressionComprehensionClauseToCeylon(Tree.JExpressionComprehensionClause expressionComprehensionClause, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
expressionStatementToCeylonshared ExpressionStatement expressionStatementToCeylon(Tree.JExpressionStatement expressionStatement, Anything(JNode, Node) update = ...)

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

Parameters:
  • expressionStatement
    • is JAssignmentOp|JPrefixOperatorExpression|JPostfixOperatorExpression|JInvocationExpression expression = expressionStatement.expression.term
  • update = noop
expressionToCeylonshared Expression expressionToCeylon(Tree.JTerm term, Anything(JNode, Node) update = ...)

Converts a RedHat AST Term to a ceylon.ast Expression.

Parameters:
  • update = noop
extendedTypeToCeylonshared ExtendedType extendedTypeToCeylon(Tree.JExtendedType extendedType, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
extensionOrConstructionToCeylonshared ExtensionOrConstruction extensionOrConstructionToCeylon(Tree.JInvocationExpression|Tree.JSimpleType extensionOrConstruction, Anything(JNode, Node) update = ...)

Converts a RedHat AST InvocationExpression or SimpleType to a ceylon.ast ExtensionOrConstruction.

Parameters:
  • update = noop
extensionToCeylonshared Extension extensionToCeylon(Tree.JInvocationExpression|Tree.JSimpleType extension, Anything(JNode, Node) update = ...)

Converts a RedHat AST InvocationExpression or SimpleType to a ceylon.ast Extension.

Parameters:
  • update = noop
failClauseToCeylonshared FailClause failClauseToCeylon(Tree.JElseClause failClause, Anything(JNode, Node) update = ...)

Converts a RedHat AST ElseClause to a ceylon.ast FailClause.

Parameters:
  • failClause
    • exists jBlock = failClause.block
  • update = noop
finallyClauseToCeylonshared FinallyClause finallyClauseToCeylon(Tree.JFinallyClause finallyClause, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
floatLiteralToCeylonshared FloatLiteral floatLiteralToCeylon(Tree.JFloatLiteral floatLiteral, Anything(JNode, Node) update = ...)

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

Parameters:
  • floatLiteral
    • floatLiteral.mainToken.type == float_literal
  • update = noop
Throws
  • AssertionError

    If the token type is not FLOAT_LITERAL.

forClauseToCeylonshared ForClause forClauseToCeylon(Tree.JForClause forClause, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
forComprehensionClauseToCeylonshared ForComprehensionClause forComprehensionClauseToCeylon(Tree.JForComprehensionClause forComprehensionClause, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
forFailToCeylonshared ForFail forFailToCeylon(Tree.JForStatement forFail, Anything(JNode, Node) update = ...)

Converts a RedHat AST ForStatement to a ceylon.ast ForFail.

Parameters:
  • update = noop
forIteratorToCeylonshared ForIterator forIteratorToCeylon(Tree.JForIterator forIterator, Anything(JNode, Node) update = ...)

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

Parameters:
  • forIterator
    • is JValueIterator|JPatternIterator forIterator
  • update = noop
fullPackageNameToCeylonshared FullPackageName fullPackageNameToCeylon(Tree.JImportPath fullPackageName, Anything(JNode, Node) update = ...)

Converts a RedHat AST ImportPath to a ceylon.ast FullPackageName.

Parameters:
  • fullPackageName
    • nonempty components = CeylonIterable(fullPackageName.identifiers).collect(propagateUpdate(pIdentifierToCeylon, update))
  • update = noop
    • nonempty components = CeylonIterable(fullPackageName.identifiers).collect(propagateUpdate(pIdentifierToCeylon, update))
functionArgumentToCeylonshared FunctionArgument functionArgumentToCeylon(Tree.JMethodArgument functionArgument, Anything(JNode, Node) update = ...)

Converts a RedHat AST MethodArgument to a ceylon.ast FunctionArgument.

(Warning: The RedHat MethodArgument should not be confused with FunctionArgument, which corresponds to ceylon.ast’s FunctionExpression.)

Parameters:
  • functionArgument
    • is JStaticType|JFunctionModifier|JVoidModifier|JDynamicModifier jType = functionArgument.type
  • update = noop
functionDecToCeylonshared FunctionDec functionDecToCeylon(Tree.JFunctionLiteral functionDec, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
functionDeclarationToCeylonshared FunctionDeclaration functionDeclarationToCeylon(Tree.JMethodDeclaration functionDeclaration, Anything(JNode, Node) update = ...)

Converts a RedHat AST MethodDeclaration to a ceylon.ast FunctionDeclaration.

Parameters:
  • functionDeclaration
    • Must not have a specification

  • update = noop
functionDefinitionToCeylonshared FunctionDefinition functionDefinitionToCeylon(Tree.JMethodDefinition functionDefinition, Anything(JNode, Node) update = ...)

Converts a RedHat AST MethodDefinition to a ceylon.ast FunctionDefinition.

Parameters:
  • update = noop
functionExpressionToCeylonshared FunctionExpression functionExpressionToCeylon(Tree.JFunctionArgument functionExpression, Anything(JNode, Node) update = ...)

Converts a RedHat AST FunctionArgument to a ceylon.ast FunctionExpression.

Parameters:
  • functionExpression
    • nonempty parameterLists = CeylonIterable(functionExpression.parameterLists).collect(propagateUpdate(parametersToCeylon, update))
  • update = noop
    • nonempty parameterLists = CeylonIterable(functionExpression.parameterLists).collect(propagateUpdate(parametersToCeylon, update))
functionModifierToCeylonshared FunctionModifier functionModifierToCeylon(Tree.JFunctionModifier functionModifier, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
functionShortcutDefinitionToCeylonshared FunctionShortcutDefinition functionShortcutDefinitionToCeylon(Tree.JMethodDeclaration functionShortcutDefinition, Anything(JNode, Node) update = ...)

Converts a RedHat AST MethodDeclaration to a ceylon.ast FunctionShortcutDefinition.

Parameters:
  • update = noop
givenDecToCeylonshared GivenDec givenDecToCeylon(Tree.JTypeParameterLiteral givenDec, Anything(JNode, Node) update = ...)

Converts a RedHat AST TypeParameterLiteral to a ceylon.ast GivenDec.

Parameters:
  • givenDec
    • is JBaseType|JQualifiedType jType = givenDec.type
  • update = noop
groupedExpressionToCeylonshared GroupedExpression groupedExpressionToCeylon(Tree.JExpression groupedExpression, Anything(JNode, Node) update = ...)

Converts a RedHat AST Expression to a ceylon.ast GroupedExpression.

Warning: Expression is used somewhat ambiguously in the RedHat AST. It can be used to wrap any expression in parentheses (and is used thus in the rule parExpression), and despite its name, it’s not the root of the expression type hierarchy (which is Term); however, many other node types declare an Expression child instead of a Term child, and the Expression used is then often a simple wrapper around a Term without parenthesis tokens.

This function only converts true grouped expressions (i. e., it asserts the existence of tokens); if you’re not sure if your Expression is grouped or not, use expressionToCeylon() instead.

Parameters:
  • groupedExpression
    • Must be a grouped expression

  • update = noop
Throws
  • AssertionError

    If the expression is not a true grouped expression

groupedTypeToCeylonshared GroupedType groupedTypeToCeylon(Tree.JGroupedType groupedType, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
identicalOperationToCeylonshared IdenticalOperation identicalOperationToCeylon(Tree.JIdenticalOp identicalOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST IdenticalOp to a ceylon.ast IdenticalOperation.

Parameters:
  • identicalOperation
    • Check precedence

  • update = noop
    • Check precedence

identifierToCeylonshared Identifier identifierToCeylon(Tree.JIdentifier identifier, Anything(JNode, Node) update = ...)

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

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

  • update = noop
Throws
  • AssertionError

    If the token type is neither LIDENTIFIER nor UIDENTIFIER.

identityOperationToCeylonshared IdentityOperation identityOperationToCeylon(Tree.JPositiveOp identityOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST PositiveOp to a ceylon.ast IdentityOperation.

Parameters:
  • identityOperation
    • is ExponentiatingExpression operand = expressionToCeylon(identityOperation.term, update)
  • update = noop
    • is ExponentiatingExpression operand = expressionToCeylon(identityOperation.term, update)
ifClauseToCeylonshared IfClause ifClauseToCeylon(Tree.JIfClause ifClause, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
ifComprehensionClauseToCeylonshared IfComprehensionClause ifComprehensionClauseToCeylon(Tree.JIfComprehensionClause ifComprehensionClause, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
ifElseExpressionToCeylonshared IfElseExpression ifElseExpressionToCeylon(Tree.JIfExpression ifElseExpression, Anything(JNode, Node) update = ...)

Converts a RedHat AST IfExpression to a ceylon.ast IfElseExpression.

Parameters:
  • ifElseExpression
    • exists jThenExpression = ifElseExpression.ifClause.expression
    • exists jElseExpression = ifElseExpression.elseClause.expression
  • update = noop
    • Check precedence

ifElseToCeylonshared IfElse ifElseToCeylon(Tree.JIfStatement ifElse, Anything(JNode, Node) update = ...)

Converts a RedHat AST IfStatement to a ceylon.ast IfElse.

Parameters:
  • update = noop
importAliasToCeylonshared ImportAlias importAliasToCeylon(Tree.JAlias importAlias, Anything(JNode, Node) update = ...)

Converts a RedHat AST Alias to a ceylon.ast ImportAlias.

Parameters:
  • update = noop
importElementToCeylonshared ImportElement importElementToCeylon(Tree.JImportMemberOrType importElement, Anything(JNode, Node) update = ...)

Converts a RedHat AST ImportMemberOrType to a ceylon.ast ImportElement.

Parameters:
  • update = noop
importElementsToCeylonshared ImportElements importElementsToCeylon(Tree.JImportMemberOrTypeList importElements, Anything(JNode, Node) update = ...)

Converts a RedHat AST ImportMemberOrTypeList to a ceylon.ast ImportElements.

Parameters:
  • update = noop
importFunctionValueAliasToCeylonshared ImportFunctionValueAlias importFunctionValueAliasToCeylon(Tree.JAlias importFunctionValueAlias, Anything(JNode, Node) update = ...)

Converts a RedHat AST Alias to a ceylon.ast ImportFunctionValueAlias.

Parameters:
  • update = noop
importFunctionValueElementToCeylonshared ImportFunctionValueElement importFunctionValueElementToCeylon(Tree.JImportMemberOrType importFunctionValueElement, Anything(JNode, Node) update = ...)

Converts a RedHat AST ImportMemberOrType to a ceylon.ast ImportFunctionValueElement.

Parameters:
  • update = noop
importToCeylonshared Import importToCeylon(Tree.JImport import, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
importTypeAliasToCeylonshared ImportTypeAlias importTypeAliasToCeylon(Tree.JAlias importTypeAlias, Anything(JNode, Node) update = ...)

Converts a RedHat AST Alias to a ceylon.ast ImportTypeAlias.

Parameters:
  • update = noop
importTypeElementToCeylonshared ImportTypeElement importTypeElementToCeylon(Tree.JImportMemberOrType importTypeElement, Anything(JNode, Node) update = ...)

Converts a RedHat AST ImportMemberOrType to a ceylon.ast ImportTypeElement.

(It might seem more appropriate if this method only accepted ImportTypes, but the RedHat parser never actually produces these. See ceylon/ceylon-spec#323.)

Parameters:
  • update = noop
importWildcardToCeylonshared ImportWildcard importWildcardToCeylon(Tree.JImportWildcard importWildcard, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
inModifierToCeylonshared InModifier inModifierToCeylon(Tree.JTypeVariance inModifier, Anything(JNode, Node) update = ...)

Converts a RedHat AST TypeVariance with token type IN_OP (in_op) to a ceylon.ast InModifier.

Parameters:
  • inModifier
    • Must be an ‘in’ modifier

  • update = noop
inOperationToCeylonshared InOperation inOperationToCeylon(Tree.JInOp inOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST InOp to a ceylon.ast InOperation.

Parameters:
  • inOperation
    • Check precedence

  • update = noop
    • Check precedence

initialComprehensionClauseToCeylonshared InitialComprehensionClause initialComprehensionClauseToCeylon(Tree.JInitialComprehensionClause initialComprehensionClause, Anything(JNode, Node) update = ...)

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

Parameters:
  • initialComprehensionClause
    • is JForComprehensionClause|JIfComprehensionClause initialComprehensionClause
  • update = noop
inlineDefinitionArgumentToCeylonshared InlineDefinitionArgument inlineDefinitionArgumentToCeylon(Tree.JTypedArgument inlineDefinitionArgument, Anything(JNode, Node) update = ...)

Converts a RedHat AST TypedArgument to a ceylon.ast InlineDefinitionArgument.

Parameters:
  • inlineDefinitionArgument
    • is JAttributeArgument|JMethodArgument|JObjectArgument inlineDefinitionArgument
  • update = noop
integerLiteralToCeylonshared IntegerLiteral integerLiteralToCeylon(Tree.JIntegerLiteral integerLiteral, Anything(JNode, Node) update = ...)

Converts a RedHat AST NaturalLiteral to a ceylon.ast IntegerLiteral.

Parameters:
  • integerLiteral
    • integerLiteral.mainToken.type == naturalLiteral
  • update = noop
Throws
  • AssertionError

    If the token type is not NATURAL_LITERAL.

interfaceAliasDefinitionToCeylonshared InterfaceAliasDefinition interfaceAliasDefinitionToCeylon(Tree.JInterfaceDeclaration interfaceAliasDefinition, Anything(JNode, Node) update = ...)

Converts a RedHat AST InterfaceDeclaration to a ceylon.ast InterfaceAliasDefinition.

Parameters:
  • update = noop
interfaceBodyToCeylonshared InterfaceBody interfaceBodyToCeylon(Tree.JInterfaceBody interfaceBody, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
interfaceDecToCeylonshared InterfaceDec interfaceDecToCeylon(Tree.JInterfaceLiteral interfaceDec, Anything(JNode, Node) update = ...)

Converts a RedHat AST InterfaceLiteral to a ceylon.ast InterfaceDec.

Parameters:
  • interfaceDec
    • is JBaseType|JQualifiedType? jType = interfaceDec.type
  • update = noop
interfaceDefinitionToCeylonshared InterfaceDefinition interfaceDefinitionToCeylon(Tree.JInterfaceDefinition interfaceDefinition, Anything(JNode, Node) update = ...)

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

Parameters:
  • interfaceDefinition
    • Must not be dynamic

    • is InterfaceDefinition ret = anyInterfaceDefinitionToCeylon(interfaceDefinition, update)
  • update = noop
    • is InterfaceDefinition ret = anyInterfaceDefinitionToCeylon(interfaceDefinition, update)
Throws
  • AssertionError

    If the interface is dynamic

intersectAssignmentOperationToCeylonshared IntersectAssignmentOperation intersectAssignmentOperationToCeylon(Tree.JIntersectAssignOp intersectAssignmentOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST IntersectAssignOp to a ceylon.ast IntersectAssignmentOperation.

Parameters:
  • intersectAssignmentOperation
    • Check precedence

  • update = noop
    • Check precedence

intersectionOperationToCeylonshared IntersectionOperation intersectionOperationToCeylon(Tree.JIntersectionOp intersectionOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST IntersectionOp to a ceylon.ast IntersectionOperation.

Parameters:
  • intersectionOperation
    • Check precedence

  • update = noop
    • Check precedence

intersectionTypeToCeylonshared IntersectionType intersectionTypeToCeylon(Tree.JIntersectionType intersectionType, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
    • is PrimaryType type = typeToCeylon(jType, update)
invocationStatementToCeylonshared InvocationStatement invocationStatementToCeylon(Tree.JExpressionStatement invocationStatement, Anything(JNode, Node) update = ...)

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

Parameters:
  • invocationStatement
    • is JInvocationExpression expression = invocationStatement.expression.term
  • update = noop
invocationToCeylonshared Invocation invocationToCeylon(Tree.JInvocationExpression invocation, Anything(JNode, Node) update = ...)

Converts a RedHat AST InvocationExpression to a ceylon.ast Invocation.

Parameters:
  • update = noop
isCaseToCeylonshared IsCase isCaseToCeylon(Tree.JIsCase isCase, Anything(JNode, Node) update = ...)

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

Parameters:
  • isCase
    • is JStaticType jType = isCase.type
  • update = noop
isConditionToCeylonshared IsCondition isConditionToCeylon(Tree.JIsCondition isCondition, Anything(JNode, Node) update = ...)

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

Parameters:
  • isCondition
    • is JStaticType jType = isCondition.type
  • update = noop
isOperationToCeylonshared IsOperation isOperationToCeylon(Tree.JIsOp isOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST IsOp to a ceylon.ast IsOperation.

Parameters:
  • isOperation
    • Check precedence

    • Must be a real type

  • update = noop
    • Check precedence

iterableToCeylonshared Iterable iterableToCeylon(Tree.JSequenceEnumeration iterable, Anything(JNode, Node) update = ...)

Converts a RedHat AST SequenceEnumeration to a ceylon.ast Iterable.

Parameters:
  • update = noop
iterableTypeToCeylonshared IterableType iterableTypeToCeylon(Tree.JIterableType iterableType, Anything(JNode, Node) update = ...)

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

Parameters:
  • iterableType
    • exists elemType = iterableType.elementType
  • update = noop
    • is VariadicType varType = typeIshToCeylon(elemType, update)
keySubscriptToCeylonshared KeySubscript keySubscriptToCeylon(Tree.JElement keySubscript, Anything(JNode, Node) update = ...)

Converts a RedHat AST Element to a ceylon.ast KeySubscript.

Parameters:
  • keySubscript
    • Check precedence

  • update = noop
    • Check precedence

lIdentifierToCeylonshared LIdentifier lIdentifierToCeylon(Tree.JIdentifier identifier, Anything(JNode, Node) update = ...)

Converts a RedHat AST Identifier to a ceylon.ast LIdentifier.

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

  • update = noop
Throws
  • AssertionError

    If the token type is not LIDENTIFIER.

largeAsOperationToCeylonshared LargeAsOperation largeAsOperationToCeylon(Tree.JLargeAsOp largeAsOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST LargeAsOp to a ceylon.ast LargeAsOperation.

Parameters:
  • largeAsOperation
    • Check precedence

  • update = noop
    • Check precedence

largerOperationToCeylonshared LargerOperation largerOperationToCeylon(Tree.JLargerOp largerOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST LargerOp to a ceylon.ast LargerOperation.

Parameters:
  • largerOperation
    • Check precedence

  • update = noop
    • Check precedence

lazySpecificationToCeylonshared LazySpecification lazySpecificationToCeylon(Tree.JSpecifierStatement lazySpecification, Anything(JNode, Node) update = ...)

Converts a RedHat AST SpecifierStatement to a ceylon.ast LazySpecification.

Only lazy specification statements are converted by this function; for non-lazy specification statements, use valueSpecificationToCeylon().

Parameters:
  • lazySpecification
    • Only function or value may be specified

  • update = noop
lazySpecifierToCeylonshared LazySpecifier lazySpecifierToCeylon(Tree.JLazySpecifierExpression lazySpecifier, Anything(JNode, Node) update = ...)

Converts a RedHat AST LazySpecifierExpression to a ceylon.ast LazySpecifier.

Parameters:
  • lazySpecifier
    • Must be a “wrapper” Expression, not a grouping Expression

    • Must be a true lazy specifier

  • update = noop
letExpressionToCeylonshared LetExpression letExpressionToCeylon(Tree.JLetExpression letExpression, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
literalToCeylonshared Literal literalToCeylon(Tree.JLiteral literal, Anything(JNode, Node) update = ...)

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

(A QuotedLiteral – a string surrounded by single or double quotes – is always converted to a StringLiteral.)

Parameters:
  • literal
    • is JStringLiteral|JCharacterLiteral|JIntegerLiteral|JFloatLiteral|JQuotedLiteral literal
  • update = noop
Throws
  • AssertionError

    If the token type is wrong.

localModifierToCeylonshared LocalModifier localModifierToCeylon(Tree.JLocalModifier localModifier, Anything(JNode, Node) update = ...)

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

Parameters:
  • localModifier
    • is JValueModifier|JFunctionModifier localModifier
  • update = noop
logicalAssignmentOperationToCeylonshared LogicalAssignmentOperation logicalAssignmentOperationToCeylon(Tree.JLogicalAssignmentOp logicalAssignmentOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST LogicalAssignmentOp to a ceylon.ast LogicalAssignmentOperation.

Parameters:
  • logicalAssignmentOperation
    • is JAndAssignOp|JOrAssignOp logicalAssignmentOperation
  • update = noop
logicalOperationToCeylonshared LogicalOperation logicalOperationToCeylon(Tree.JLogicalOp logicalOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST LogicalOp to a ceylon.ast LogicalOperation.

Parameters:
  • logicalOperation
    • is JAndOp|JOrOp logicalOperation
  • update = noop
mainTypeToCeylonshared MainType mainTypeToCeylon(Tree.JStaticType mainType, Anything(JNode, Node) update = ...)

Converts a RedHat AST StaticType to a ceylon.ast MainType.

Parameters:
  • update = noop
matchCaseToCeylonshared MatchCase matchCaseToCeylon(Tree.JMatchCase matchCase, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
    • is IntegerLiteral|CharacterLiteral|StringLiteral|NegationOperation|BaseExpression|QualifiedExpression expression = expressionToCeylon(element, update)
measureOperationToCeylonshared MeasureOperation measureOperationToCeylon(Tree.JSegmentOp measureOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST SegmentOp to a ceylon.ast MeasureOperation.

Parameters:
  • measureOperation
    • Check precedence

  • update = noop
    • Check precedence

measureSubscriptToCeylonshared MeasureSubscript measureSubscriptToCeylon(Tree.JElementRange measureSubscript, Anything(JNode, Node) update = ...)

Converts a RedHat AST ElementRange to a ceylon.ast MeasureSubscript.

Parameters:
  • measureSubscript
    • exists jFrom = measureSubscript.lowerBound
    • exists jLength = measureSubscript.length
    • !measureSubscript.upperBound exists
  • update = noop
    • Check precedence

memberDecToCeylonshared MemberDec memberDecToCeylon(Tree.JMemberLiteral memberDec, Anything(JNode, Node) update = ...)

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

Parameters:
  • memberDec
    • Must be a Dec, not a Meta

  • update = noop
memberMetaToCeylonshared MemberMeta memberMetaToCeylon(Tree.JMemberLiteral memberMeta, Anything(JNode, Node) update = ...)

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

Parameters:
  • memberMeta
    • exists jQualifier = memberMeta.type
    • Must not be a reference expression

  • update = noop
memberOperatorToCeylonshared MemberOperator memberOperatorToCeylon(Tree.JMemberOp memberOperator, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
metaToCeylonshared Meta metaToCeylon(Tree.JMetaLiteral metaLiteral, Anything(JNode, Node) update = ...)

Converts a RedHat AST MetaLiteral to a ceylon.ast Meta.

Parameters:
  • metaLiteral
    • is JTypeLiteral|JMemberLiteral metaLiteral
  • update = noop
modifierToCeylonshared Modifier modifierToCeylon(Tree.JVoidModifier|Tree.JLocalModifier|Tree.JDynamicModifier|Tree.JTypeVariance modifier, Anything(JNode, Node) update = ...)

Converts a RedHat AST VoidModifier or DynamicModifier to a ceylon.ast Modifier.

Parameters:
  • update = noop
moduleBodyToCeylonshared ModuleBody moduleBodyToCeylon(Tree.JImportModuleList moduleBody, Anything(JNode, Node) update = ...)

Converts a RedHat AST ImportModuleList to a ceylon.ast ModuleBody.

Parameters:
  • update = noop
moduleCompilationUnitToCeylonshared ModuleCompilationUnit moduleCompilationUnitToCeylon(Tree.JCompilationUnit moduleCompilationUnit, Anything(JNode, Node) update = ...)

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

Parameters:
  • moduleCompilationUnit
    • Must not have declarations or package descriptors

    • Must have exactly one module descriptor

  • update = noop
Throws
  • AssertionError

    If the compilation unit contains package descriptors, declarations, or not exactly one module descriptor

moduleDecToCeylonshared ModuleDec moduleDecToCeylon(Tree.JModuleLiteral moduleDec, Anything(JNode, Node) update = ...)

Converts a RedHat AST ModuleLiteral to a ceylon.ast ModuleDec.

Parameters:
  • update = noop
moduleDescriptorToCeylonshared ModuleDescriptor moduleDescriptorToCeylon(Tree.JModuleDescriptor moduleDescriptor, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
moduleImportToCeylonshared ModuleImport moduleImportToCeylon(Tree.JImportModule moduleImport, Anything(JNode, Node) update = ...)

Converts a RedHat AST ImportModule to a ceylon.ast ModuleImport.

Parameters:
  • update = noop
multiplyAssignmentOperationToCeylonshared MultiplyAssignmentOperation multiplyAssignmentOperationToCeylon(Tree.JMultiplyAssignOp multiplyAssignmentOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST MultiplyAssignOp to a ceylon.ast MultiplyAssignmentOperation.

Parameters:
  • multiplyAssignmentOperation
    • Check precedence

  • update = noop
    • Check precedence

namedArgumentToCeylonshared NamedArgument namedArgumentToCeylon(Tree.JNamedArgument namedArgument, Anything(JNode, Node) update = ...)

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

Parameters:
  • namedArgument
    • is JSpecifiedArgument|JTypedArgument namedArgument
  • update = noop
namedArgumentsToCeylonshared NamedArguments namedArgumentsToCeylon(Tree.JNamedArgumentList namedArguments, Anything(JNode, Node) update = ...)

Converts a RedHat AST NamedArgumentList to a ceylon.ast NamedArguments.

Parameters:
  • update = noop
negationOperationToCeylonshared NegationOperation negationOperationToCeylon(Tree.JNegativeOp negationOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST NegativeOp to a ceylon.ast NegationOperation.

Parameters:
  • negationOperation
    • is ExponentiatingExpression operand = expressionToCeylon(negationOperation.term, update)
  • update = noop
    • is ExponentiatingExpression operand = expressionToCeylon(negationOperation.term, update)
nonemptyConditionToCeylonshared NonemptyCondition nonemptyConditionToCeylon(Tree.JNonemptyCondition nonemptyCondition, Anything(JNode, Node) update = ...)

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

Parameters:
  • nonemptyCondition
    • is NonemptyCondition ret = existsOrNonemptyConditionToCeylon(nonemptyCondition, update)
  • update = noop
    • is NonemptyCondition ret = existsOrNonemptyConditionToCeylon(nonemptyCondition, update)
nonemptyOperationToCeylonshared NonemptyOperation nonemptyOperationToCeylon(Tree.JNonempty nonemptyOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST Nonempty to a ceylon.ast NonemptyOperation.

Parameters:
  • nonemptyOperation
    • Check precedence

  • update = noop
    • Check precedence

notEqualOperationToCeylonshared NotEqualOperation notEqualOperationToCeylon(Tree.JNotEqualOp notEqualOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST NotEqualOp to a ceylon.ast NotEqualOperation.

Parameters:
  • notEqualOperation
    • Check precedence

  • update = noop
    • Check precedence

notOperationToCeylonshared NotOperation notOperationToCeylon(Tree.JNotOp notOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST NotOp to a ceylon.ast NotOperation.

Parameters:
  • notOperation
    • Check precedence

  • update = noop
    • Check precedence

objectArgumentToCeylonshared ObjectArgument objectArgumentToCeylon(Tree.JObjectArgument objectArgument, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
objectDefinitionToCeylonshared ObjectDefinition objectDefinitionToCeylon(Tree.JObjectDefinition objectDefinition, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
objectExpressionToCeylonshared ObjectExpression objectExpressionToCeylon(Tree.JObjectExpression objectExpression, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
ofOperationToCeylonshared OfOperation ofOperationToCeylon(Tree.JOfOp ofOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST OfOp to a ceylon.ast OfOperation.

Parameters:
  • ofOperation
    • Check precedence

    • Must be a real type

  • update = noop
    • Check precedence

openBoundToCeylonshared OpenBound openBoundToCeylon(Tree.JOpenBound openBound, Anything(JNode, Node) update = ...)

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

Parameters:
  • openBound
    • Check precedence

  • update = noop
    • Check precedence

operationToCeylonshared Operation operationToCeylon(Tree.JOperatorExpression operatorExpression, Anything(JNode, Node) update = ...)

Converts a RedHat AST OperatorExpression to a ceylon.ast Operation.

Parameters:
  • operatorExpression
    • is JUnaryOperatorExpression|JBinaryOperatorExpression|JWithinOp operatorExpression
  • update = noop
optionalTypeToCeylonshared OptionalType optionalTypeToCeylon(Tree.JOptionalType optionalType, Anything(JNode, Node) update = ...)

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

Parameters:
  • optionalType
    • is PrimaryType definite = typeToCeylon(optionalType.definiteType, update)
  • update = noop
    • is PrimaryType definite = typeToCeylon(optionalType.definiteType, update)
orAssignmentOperationToCeylonshared OrAssignmentOperation orAssignmentOperationToCeylon(Tree.JOrAssignOp orAssignmentOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST OrAssignOp to a ceylon.ast OrAssignmentOperation.

Parameters:
  • orAssignmentOperation
    • Check precedence

  • update = noop
    • Check precedence

orOperationToCeylonshared OrOperation orOperationToCeylon(Tree.JOrOp orOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST OrOp to a ceylon.ast OrOperation.

Parameters:
  • orOperation
    • Check precedence

  • update = noop
    • Check precedence

outModifierToCeylonshared OutModifier outModifierToCeylon(Tree.JTypeVariance outModifier, Anything(JNode, Node) update = ...)

Converts a RedHat AST TypeVariance with token type OUT (outType) to a ceylon.ast OutModifier.

Parameters:
  • outModifier
    • Must be an ‘in’ modifier

  • update = noop
outerToCeylonshared Outer outerToCeylon(Tree.JOuter outer, Anything(JNode, Node) update = ...)

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

Parameters:
  • outer
    • \iouter.mainToken.type == outerType
    • \iouter.mainToken.text == "outer"
  • update = noop
Throws
  • AssertionError

    If the token type is not OUTER or the token text is not outer.

pIdentifierToCeylonshared LIdentifier pIdentifierToCeylon(Tree.JIdentifier identifier, Anything(JNode, Node) update = ...)

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

There’s no syntactical difference between package 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
  • AssertionError

    If the token type is not PIDENTIFIER.

packageCompilationUnitToCeylonshared PackageCompilationUnit packageCompilationUnitToCeylon(Tree.JCompilationUnit packageCompilationUnit, Anything(JNode, Node) update = ...)

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

Parameters:
  • packageCompilationUnit
    • Must not have declarations or module descriptors

    • Must have exactly one package descriptor

  • update = noop
Throws
  • AssertionError

    If the compilation unit contains module descriptors, declarations, or not exactly one package descriptor

packageDecToCeylonshared PackageDec packageDecToCeylon(Tree.JPackageLiteral packageDec, Anything(JNode, Node) update = ...)

Converts a RedHat AST PackageLiteral to a ceylon.ast PackageDec.

Parameters:
  • update = noop
packageDescriptorToCeylonshared PackageDescriptor packageDescriptorToCeylon(Tree.JPackageDescriptor packageDescriptor, Anything(JNode, Node) update = ...)

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

Parameters:
  • update = noop
packageToCeylonshared Package packageToCeylon(Tree.JPackage package, Anything(JNode, Node) update = ...)

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

Parameters:
  • package
    • \ipackage.mainToken.type == packageType
    • \ipackage.mainToken.text == "package"
  • update = noop
Throws
  • AssertionError

    If the token type is not PACKAGE or the token text is not package.

parameterReferenceToCeylonshared ParameterReference parameterReferenceToCeylon(Tree.JInitializerParameter parameterReference, Anything(JNode, Node) update = ...)

Converts a RedHat AST InitializerParameter to a ceylon.ast ParameterReference.

Parameters:
  • parameterReference
    • Must not be defaulted

  • update = noop
parameterToCeylonshared Parameter parameterToCeylon(Tree.JParameter parameter, Anything(JNode, Node) update = ...)

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

Parameters:
  • parameter
    • is JParameterDeclaration|JInitializerParameter parameter
  • update = noop
parametersToCeylonshared Parameters parametersToCeylon(Tree.JParameterList parameters, Anything(JNode, Node) update = ...)

Converts a RedHat AST ParameterList to a ceylon.ast Parameters.

Parameters:
  • update = noop
patternToCeylonshared Pattern patternToCeylon(Tree.JPattern pattern, Anything(JNode, Node) update = ...)

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

Parameters:
  • pattern
    • is JVariablePattern|JTuplePattern|JKeyValuePattern pattern
  • update = noop
positionalArgumentsToCeylonshared PositionalArguments positionalArgumentsToCeylon(Tree.JPositionalArgumentList positionalArguments, Anything(JNode, Node) update = ...)

Converts a RedHat AST PositionalArgumentList to a ceylon.ast PositionalArguments.

Parameters:
  • update = noop
postfixDecrementOperationToCeylonshared PostfixDecrementOperation postfixDecrementOperationToCeylon(Tree.JPostfixDecrementOp postfixDecrementOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST PostfixDecrementOp to a ceylon.ast PostfixDecrementOperation.

Parameters:
  • postfixDecrementOperation
    • is JPrimary jPrimary = postfixDecrementOperation.term
  • update = noop
postfixIncrementOperationToCeylonshared PostfixIncrementOperation postfixIncrementOperationToCeylon(Tree.JPostfixIncrementOp postfixIncrementOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST PostfixIncrementOp to a ceylon.ast PostfixIncrementOperation.

Parameters:
  • postfixIncrementOperation
    • is JPrimary jPrimary = postfixIncrementOperation.term
  • update = noop
postfixOperationToCeylonshared PostfixOperation postfixOperationToCeylon(Tree.JPostfixOperatorExpression postfixOperatorExpression, Anything(JNode, Node) update = ...)

Converts a RedHat AST PostfixOperatorExpression to a ceylon.ast PostfixOperation.

Parameters:
  • postfixOperatorExpression
    • is JPostfixDecrementOp|JPostfixIncrementOp postfixOperatorExpression
  • update = noop
prefixDecrementOperationToCeylonshared PrefixDecrementOperation prefixDecrementOperationToCeylon(Tree.JDecrementOp prefixDecrementOperation, Anything(JNode, Node) update = ...)

Converts a RedHat AST DecrementOp to a ceylon.ast PrefixDecrementOperation.

Parameters:
  • prefixDecrementOperation
    • is JPrimary jPrimary = prefixDecrementOperation.term
  • update = noop
prefixIncrementOperationToCeylonshared PrefixIncrementOperation prefixIncrementOperationToCeylon(Tree.JIncrement