Overview

Packages
ceylon.ast.redhat

Dependencies
`ceylon.ast.core`	`1.3.2`
`ceylon.interop.java`	`1.3.2`
`com.redhat.ceylon.typechecker`	`1.3.2`

Values
`originalNodeKey`	Source Code`shared Key<JNode> originalNodeKey` A key for attaching the RedHat AST Node from which a `ceylon.ast` `Node` was converted. See also `attachOriginalNode()`, `ceylon.ast.redhat`

Functions
`aIdentifierToCeylon`	Source Code`shared 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 = e) u` Throws `AssertionError` If the token type is not `AIDENTIFIER`.
`aStringLiteralToCeylon`	Source Code`shared 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` `sert (is CommonToken token = stringLiteral.mai` `update = ate` Throws `AssertionError` If the token type is neither `ASTRING_LITERAL` nor `AVERBATIM_STRING`.
`addAssignmentOperationToCeylon`	Source Code`shared 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
`aliasDecToCeylon`	Source Code`shared 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`
`andAssignmentOperationToCeylon`	Source Code`shared 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
`andOperationToCeylon`	Source Code`shared 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
`annotationToCeylon`	Source Code`shared 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`
`annotationsToCeylon`	Source Code `shared Annotations annotationsToCeylon(Tree.JAnnotationList annotations, Anything(JNode, Node) update = ...)` Converts a RedHat AST AnnotationList to a `ceylon.ast` `Annotations`. Parameters: `update = noop`
`anonymousArgumentToCeylon`	Source Code`shared 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 = = no`
`anyClassToCeylon`	Source Code`shared 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`
`anyCompilationUnitToCeylon`	Source Code `shared AnyCompilationUnit anyCompilationUnitToCeylon(Tree.JCompilationUnit anyCompilationUnit, Anything(JNode, Node) update = ...)` Converts a RedHat AST CompilationUnit to a `ceylon.ast` `AnyCompilationUnit`. Parameters: `update = noop`
`anyFunctionToCeylon`	Source Code`shared 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`
`anyInterfaceDefinitionToCeylon`	Source Code `shared AnyInterfaceDefinition anyInterfaceDefinitionToCeylon(Tree.JInterfaceDefinition anyInterfaceDefinition, Anything(JNode, Node) update = ...)` Converts a RedHat AST InterfaceDefinition to a `ceylon.ast` `AnyInterfaceDefinition`. Parameters: `update = noop`
`anyInterfaceToCeylon`	Source Code`shared 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`
`anyMemberOperatorToCeylon`	Source Code`shared 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`
`anySpecifierToCeylon`	Source Code `shared AnySpecifier anySpecifierToCeylon(Tree.JSpecifierExpression anySpecifier, Anything(JNode, Node) update = ...)` Converts a RedHat AST SpecifierExpression to a `ceylon.ast` `AnySpecifier`. Parameters: `update = noop`
`anyTypeArgumentsToCeylon`	Source Code`shared 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`
`anyValueToCeylon`	Source Code`shared 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`
`argumentListToCeylon`	Source Code `shared 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`
`argumentsToCeylon`	Source Code`shared 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`
`arithmeticAssignmentOperationToCeylon`	Source Code`shared 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`
`arithmeticOperationToCeylon`	Source Code`shared 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`
`assertionToCeylon`	Source Code `shared Assertion assertionToCeylon(Tree.JAssertion assertion, Anything(JNode, Node) update = ...)` Converts a RedHat AST Assertion to a `ceylon.ast` `Assertion`. Parameters: `update = noop`
`assignOperationToCeylon`	Source Code`shared 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
`assignmentOperationToCeylon`	Source Code`shared 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`
`assignmentStatementToCeylon`	Source Code`shared 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`
`atomToCeylon`	Source Code `shared Atom atomToCeylon(Tree.JAtom atom, Anything(JNode, Node) update = ...)` Converts a RedHat AST Atom to a `ceylon.ast` `Atom`. Parameters: `update = noop`
`attachOriginalNode`	Source Code `shared 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 `parseX` functions. See also `originalNodeKey`, `ceylon.ast.redhat`
`baseExpressionToCeylon`	Source Code`shared 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`
`baseMetaToCeylon`	Source Code`shared 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)`
`baseTypeToCeylon`	Source Code `shared BaseType baseTypeToCeylon(Tree.JBaseType baseType, Anything(JNode, Node) update = ...)` Converts a RedHat AST BaseType to a `ceylon.ast` `BaseType`. Parameters: `update = noop`
`binaryOperationToCeylon`	Source Code`shared 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`
`blockToCeylon`	Source Code `shared Block blockToCeylon(Tree.JBlock block, Anything(JNode, Node) update = ...)` Converts a RedHat AST Block to a `ceylon.ast` `Block`. Parameters: `update = noop`
`bodyToCeylon`	Source Code`shared 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`
`booleanConditionToCeylon`	Source Code `shared BooleanCondition booleanConditionToCeylon(Tree.JBooleanCondition booleanCondition, Anything(JNode, Node) update = ...)` Converts a RedHat AST BooleanCondition to a `ceylon.ast` `BooleanCondition`. Parameters: `update = noop`
`boundToCeylon`	Source Code`shared 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`
`breakToCeylon`	Source Code `shared Break breakToCeylon(Tree.JBreak break, Anything(JNode, Node) update = ...)` Converts a RedHat AST Break to a `ceylon.ast` `Break`. Parameters: `update = noop`
`callableConstructorDefinitionToCeylon`	Source Code `shared CallableConstructorDefinition callableConstructorDefinitionToCeylon(Tree.JConstructor callableConstructorDefinition, Anything(JNode, Node) update = ...)` Converts a RedHat AST Constructor to a `ceylon.ast` `CallableConstructorDefinition`. Parameters: `update = noop`
`callableParameterToCeylon`	Source Code`shared 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`
`callableTypeToCeylon`	Source Code `shared CallableType callableTypeToCeylon(Tree.JFunctionType callableType, Anything(JNode, Node) update = ...)` Converts a RedHat AST FunctionType to a `ceylon.ast` `CallableType`. Parameters: `update = noop`
`caseClauseToCeylon`	Source Code `shared CaseClause caseClauseToCeylon(Tree.JCaseClause caseClause, Anything(JNode, Node) update = ...)` Converts a RedHat AST CaseClause to a `ceylon.ast` `CaseClause`. Parameters: `update = noop`
`caseExpressionToCeylon`	Source Code `shared CaseExpression caseExpressionToCeylon(Tree.JCaseClause caseExpression, Anything(JNode, Node) update = ...)` Converts a RedHat AST CaseClause to a `ceylon.ast` `CaseExpression`. Parameters: `update = noop`
`caseItemToCeylon`	Source Code`shared 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`
`caseTypesToCeylon`	Source Code`shared CaseTypes caseTypesToCeylon(Tree.JCaseTypes caseTypes, Anything(JNode, Node) update = ...)` Converts RedHat AST CaseTypes to `ceylon.ast` `CaseTypes`. Parameters: `caseTypes` `rt (nonempty cases = concatenate(CeylonIterable(caseTypes.types), CeylonIterable(caseTypes.baseMemberExpressions)) .sort(byIncreasing(compose(Token.tokenIndex, JNode.toke` `update = noop`
`catchClauseToCeylon`	Source Code `shared CatchClause catchClauseToCeylon(Tree.JCatchClause catchClause, Anything(JNode, Node) update = ...)` Converts a RedHat AST CatchClause to a `ceylon.ast` `CatchClause`. Parameters: `update = noop`
`characterLiteralToCeylon`	Source Code`shared 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`.
`classAliasDefinitionToCeylon`	Source Code `shared ClassAliasDefinition classAliasDefinitionToCeylon(Tree.JClassDeclaration classAliasDefinition, Anything(JNode, Node) update = ...)` Converts a RedHat AST ClassDeclaration to a `ceylon.ast` `ClassAliasDefinition`. Parameters: `update = noop`
`classBodyToCeylon`	Source Code `shared ClassBody classBodyToCeylon(Tree.JClassBody classBody, Anything(JNode, Node) update = ...)` Converts a RedHat AST ClassBody to a `ceylon.ast` `ClassBody`. Parameters: `update = noop`
`classDecToCeylon`	Source Code `shared ClassDec classDecToCeylon(Tree.JClassLiteral classDec, Anything(JNode, Node) update = ...)` Converts a RedHat AST ClassLiteral to a `ceylon.ast` `ClassDec`. Parameters: `update = noop`
`classDefinitionToCeylon`	Source Code `shared ClassDefinition classDefinitionToCeylon(Tree.JClassDefinition classDefinition, Anything(JNode, Node) update = ...)` Converts a RedHat AST ClassDefinition to a `ceylon.ast` `ClassDefinition`. Parameters: `update = noop`
`classOrInterfaceToCeylon`	Source Code`shared 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`
`classSpecifierToCeylon`	Source Code `shared ClassSpecifier classSpecifierToCeylon(Tree.JClassSpecifier classSpecifier, Anything(JNode, Node) update = ...)` Converts a RedHat AST ClassSpecifier to a `ceylon.ast` `ClassSpecifier`. Parameters: `update = noop`
`closedBoundToCeylon`	Source Code`shared 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
`compareOperationToCeylon`	Source Code`shared 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
`comparisonOperationToCeylon`	Source Code`shared 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`
`compilationUnitToCeylon`	Source Code`shared 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
`complementAssignmentOperationToCeylon`	Source Code`shared 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
`complementOperationToCeylon`	Source Code`shared 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
`comprehensionClauseToCeylon`	Source Code`shared 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`
`comprehensionToCeylon`	Source Code `shared Comprehension comprehensionToCeylon(Tree.JComprehension comprehension, Anything(JNode, Node) update = ...)` Converts a RedHat AST Comprehension to a `ceylon.ast` `Comprehension`. Parameters: `update = noop`
`conditionToCeylon`	Source Code`shared 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`
`conditionalExpressionToCeylon`	Source Code `shared 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`
`conditionsToCeylon`	Source Code`shared 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))`
`constructionToCeylon`	Source Code`shared 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`
`constructorDecToCeylon`	Source Code`shared 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`
`constructorDefinitionToCeylon`	Source Code `shared 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`
`continueToCeylon`	Source Code `shared Continue continueToCeylon(Tree.JContinue continue, Anything(JNode, Node) update = ...)` Converts a RedHat AST Continue to a `ceylon.ast` `Continue`. Parameters: `update = noop`
`controlStructureToCeylon`	Source Code`shared 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`
`createParser`	Source Code `shared CeylonParser createParser(String code)` Creates a Ceylon parser that operates on the given `code`.
`decToCeylon`	Source Code`shared 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`
`declarationOrStatementToCeylon`	Source Code`shared 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`
`declarationToCeylon`	Source Code`shared 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`
`defaultedCallableParameterToCeylon`	Source Code`shared 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`
`defaultedParameterReferenceToCeylon`	Source Code`shared 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`
`defaultedParameterToCeylon`	Source Code`shared 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`
`defaultedTypeToCeylon`	Source Code`shared 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`
`defaultedValueParameterToCeylon`	Source Code`shared 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`
`destructureToCeylon`	Source Code`shared 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)`
`differenceOperationToCeylon`	Source Code`shared 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
`directiveToCeylon`	Source Code`shared 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`
`divideAssignmentOperationToCeylon`	Source Code`shared 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
`dynamicBlockToCeylon`	Source Code `shared DynamicBlock dynamicBlockToCeylon(Tree.JDynamicStatement dynamicBlock, Anything(JNode, Node) update = ...)` Converts a RedHat AST DynamicStatement to a `ceylon.ast` `DynamicBlock`. Parameters: `update = noop`
`dynamicClauseToCeylon`	Source Code `shared 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 = = no` See also `dynamicBlockToCeylon()`
`dynamicInterfaceDefinitionToCeylon`	Source Code`shared 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
`dynamicModifierToCeylon`	Source Code `shared DynamicModifier dynamicModifierToCeylon(Tree.JDynamicModifier dynamicModifier, Anything(JNode, Node) update = ...)` Converts a RedHat AST DynamicModifier to a `ceylon.ast` `DynamicModifier`. Parameters: `update = noop`
`dynamicValueToCeylon`	Source Code `shared DynamicValue dynamicValueToCeylon(Tree.JDynamic dynamicValue, Anything(JNode, Node) update = ...)` Converts a RedHat AST Dynamic to a `ceylon.ast` `DynamicValue`. Parameters: `update = noop`
`elementOrSubrangeExpressionToCeylon`	Source Code `shared ElementOrSubrangeExpression elementOrSubrangeExpressionToCeylon(Tree.JIndexExpression elementOrSubrangeExpression, Anything(JNode, Node) update = ...)` Converts a RedHat AST IndexExpression to a `ceylon.ast` `ElementOrSubrangeExpression`. Parameters: `update = noop`
`elseClauseToCeylon`	Source Code `shared ElseClause elseClauseToCeylon(Tree.JElseClause elseClause, Anything(JNode, Node) update = ...)` Converts a RedHat AST ElseClause to a `ceylon.ast` `ElseClause`. Parameters: `update = noop`
`elseOperationToCeylon`	Source Code`shared 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
`entryOperationToCeylon`	Source Code`shared 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
`entryPatternToCeylon`	Source Code`shared 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)`
`entryTypeToCeylon`	Source Code`shared 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)`
`equalOperationToCeylon`	Source Code`shared 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
`equalityOperationToCeylon`	Source Code`shared 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`
`existsConditionToCeylon`	Source Code`shared 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)`
`existsOperationToCeylon`	Source Code`shared 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
`existsOrNonemptyConditionToCeylon`	Source Code `shared ExistsOrNonemptyCondition existsOrNonemptyConditionToCeylon(Tree.JExistsOrNonemptyCondition existsOrNonemptyCondition, Anything(JNode, Node) update = ...)` Converts a RedHat AST ExistsOrNonemptyCondition to a `ceylon.ast` `ExistsOrNonemptyCondition`. Parameters: `update = noop`
`exponentiationOperationToCeylon`	Source Code`shared 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)`
`expressionComprehensionClauseToCeylon`	Source Code `shared ExpressionComprehensionClause expressionComprehensionClauseToCeylon(Tree.JExpressionComprehensionClause expressionComprehensionClause, Anything(JNode, Node) update = ...)` Converts a RedHat AST ExpressionComprehensionClause to a `ceylon.ast` `ExpressionComprehensionClause`. Parameters: `update = noop`
`expressionStatementToCeylon`	Source Code`shared 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`
`expressionToCeylon`	Source Code `shared Expression expressionToCeylon(Tree.JTerm term, Anything(JNode, Node) update = ...)` Converts a RedHat AST Term to a `ceylon.ast` `Expression`. Parameters: `update = noop`
`extendedTypeToCeylon`	Source Code `shared ExtendedType extendedTypeToCeylon(Tree.JExtendedType extendedType, Anything(JNode, Node) update = ...)` Converts a RedHat AST ExtendedType to a `ceylon.ast` `ExtendedType`. Parameters: `update = noop`
`extensionOrConstructionToCeylon`	Source Code `shared 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`
`extensionToCeylon`	Source Code `shared 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`
`failClauseToCeylon`	Source Code`shared 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`
`finallyClauseToCeylon`	Source Code `shared FinallyClause finallyClauseToCeylon(Tree.JFinallyClause finallyClause, Anything(JNode, Node) update = ...)` Converts a RedHat AST FinallyClause to a `ceylon.ast` `FinallyClause`. Parameters: `update = noop`
`floatLiteralToCeylon`	Source Code`shared 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`.
`forClauseToCeylon`	Source Code `shared ForClause forClauseToCeylon(Tree.JForClause forClause, Anything(JNode, Node) update = ...)` Converts a RedHat AST ForClause to a `ceylon.ast` `ForClause`. Parameters: `update = noop`
`forComprehensionClauseToCeylon`	Source Code `shared ForComprehensionClause forComprehensionClauseToCeylon(Tree.JForComprehensionClause forComprehensionClause, Anything(JNode, Node) update = ...)` Converts a RedHat AST ForComprehensionClause to a `ceylon.ast` `ForComprehensionClause`. Parameters: `update = noop`
`forFailToCeylon`	Source Code `shared ForFail forFailToCeylon(Tree.JForStatement forFail, Anything(JNode, Node) update = ...)` Converts a RedHat AST ForStatement to a `ceylon.ast` `ForFail`. Parameters: `update = noop`
`forIteratorToCeylon`	Source Code`shared 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`
`fullPackageNameToCeylon`	Source Code`shared 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))`
`functionArgumentToCeylon`	Source Code`shared 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.ty` `update = = no`
`functionDecToCeylon`	Source Code `shared FunctionDec functionDecToCeylon(Tree.JFunctionLiteral functionDec, Anything(JNode, Node) update = ...)` Converts a RedHat AST FunctionDec to a `ceylon.ast` `FunctionDec`. Parameters: `update = noop`
`functionDeclarationToCeylon`	Source Code`shared 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`
`functionDefinitionToCeylon`	Source Code `shared FunctionDefinition functionDefinitionToCeylon(Tree.JMethodDefinition functionDefinition, Anything(JNode, Node) update = ...)` Converts a RedHat AST MethodDefinition to a `ceylon.ast` `FunctionDefinition`. Parameters: `update = noop`
`functionExpressionToCeylon`	Source Code`shared 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))`
`functionModifierToCeylon`	Source Code `shared FunctionModifier functionModifierToCeylon(Tree.JFunctionModifier functionModifier, Anything(JNode, Node) update = ...)` Converts a RedHat AST FunctionModifier to a `ceylon.ast` `FunctionModifier`. Parameters: `update = noop`
`functionShortcutDefinitionToCeylon`	Source Code `shared FunctionShortcutDefinition functionShortcutDefinitionToCeylon(Tree.JMethodDeclaration functionShortcutDefinition, Anything(JNode, Node) update = ...)` Converts a RedHat AST MethodDeclaration to a `ceylon.ast` `FunctionShortcutDefinition`. Parameters: `update = noop`
`givenDecToCeylon`	Source Code`shared 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`
`groupedExpressionToCeylon`	Source Code `shared GroupedExpression groupedExpressionToCeylon(Tree.JParExpression groupedExpression, Anything(JNode, Node) update = ...)` Converts a RedHat AST ParExpression to a `ceylon.ast` `GroupedExpression`. Parameters: `update = noop` Throws `AssertionError` If the expression is not a true grouped expression
`groupedTypeToCeylon`	Source Code `shared GroupedType groupedTypeToCeylon(Tree.JGroupedType groupedType, Anything(JNode, Node) update = ...)` Converts a RedHat AST GroupedType to a `ceylon.ast` `GroupedType`. Parameters: `update = noop`
`identicalOperationToCeylon`	Source Code`shared 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
`identifierToCeylon`	Source Code`shared 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). For synthetic nodes produced by the typechecker during desugaring, a token may not exist. `update = noop` Throws `AssertionError` If the token type is neither `LIDENTIFIER` nor `UIDENTIFIER`.
`identityOperationToCeylon`	Source Code`shared 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)`
`ifClauseToCeylon`	Source Code `shared IfClause ifClauseToCeylon(Tree.JIfClause ifClause, Anything(JNode, Node) update = ...)` Converts a RedHat AST IfClause to a `ceylon.ast` `IfClause`. Parameters: `update = noop`
`ifComprehensionClauseToCeylon`	Source Code `shared IfComprehensionClause ifComprehensionClauseToCeylon(Tree.JIfComprehensionClause ifComprehensionClause, Anything(JNode, Node) update = ...)` Converts a RedHat AST IfComprehensionClause to a `ceylon.ast` `IfComprehensionClause`. Parameters: `update = noop`
`ifElseExpressionToCeylon`	Source Code`shared 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
`ifElseToCeylon`	Source Code `shared IfElse ifElseToCeylon(Tree.JIfStatement ifElse, Anything(JNode, Node) update = ...)` Converts a RedHat AST IfStatement to a `ceylon.ast` `IfElse`. Parameters: `update = noop`
`importAliasToCeylon`	Source Code `shared ImportAlias importAliasToCeylon(Tree.JAlias importAlias, Anything(JNode, Node) update = ...)` Converts a RedHat AST Alias to a `ceylon.ast` `ImportAlias`. Parameters: `update = noop`
`importElementToCeylon`	Source Code `shared ImportElement importElementToCeylon(Tree.JImportMemberOrType importElement, Anything(JNode, Node) update = ...)` Converts a RedHat AST ImportMemberOrType to a `ceylon.ast` `ImportElement`. Parameters: `update = noop`
`importElementsToCeylon`	Source Code `shared ImportElements importElementsToCeylon(Tree.JImportMemberOrTypeList importElements, Anything(JNode, Node) update = ...)` Converts a RedHat AST ImportMemberOrTypeList to a `ceylon.ast` `ImportElements`. Parameters: `update = noop`
`importToCeylon`	Source Code `shared Import importToCeylon(Tree.JImport import, Anything(JNode, Node) update = ...)` Converts a RedHat AST Import to a `ceylon.ast` `Import`. Parameters: `update = noop`
`importWildcardToCeylon`	Source Code `shared ImportWildcard importWildcardToCeylon(Tree.JImportWildcard importWildcard, Anything(JNode, Node) update = ...)` Converts a RedHat AST ImportWildcard to a `ceylon.ast` `ImportWildcard`. Parameters: `update = noop`
`inModifierToCeylon`	Source Code`shared 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`
`inOperationToCeylon`	Source Code`shared 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
`initialComprehensionClauseToCeylon`	Source Code`shared 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`
`inlineDefinitionArgumentToCeylon`	Source Code`shared 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`
`integerLiteralToCeylon`	Source Code`shared 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`.
`interfaceAliasDefinitionToCeylon`	Source Code `shared InterfaceAliasDefinition interfaceAliasDefinitionToCeylon(Tree.JInterfaceDeclaration interfaceAliasDefinition, Anything(JNode, Node) update = ...)` Converts a RedHat AST InterfaceDeclaration to a `ceylon.ast` `InterfaceAliasDefinition`. Parameters: `update = noop`
`interfaceBodyToCeylon`	Source Code `shared InterfaceBody interfaceBodyToCeylon(Tree.JInterfaceBody interfaceBody, Anything(JNode, Node) update = ...)` Converts a RedHat AST InterfaceBody to a `ceylon.ast` `InterfaceBody`. Parameters: `update = noop`
`interfaceDecToCeylon`	Source Code`shared 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`
`interfaceDefinitionToCeylon`	Source Code`shared 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
`intersectAssignmentOperationToCeylon`	Source Code`shared 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
`intersectionOperationToCeylon`	Source Code`shared 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
`intersectionTypeToCeylon`	Source Code `shared 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)`
`invocationStatementToCeylon`	Source Code`shared 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`
`invocationToCeylon`	Source Code `shared Invocation invocationToCeylon(Tree.JInvocationExpression invocation, Anything(JNode, Node) update = ...)` Converts a RedHat AST InvocationExpression to a `ceylon.ast` `Invocation`. Parameters: `update = noop`
`isCaseToCeylon`	Source Code`shared 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`
`isConditionToCeylon`	Source Code`shared 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`
`isOperationToCeylon`	Source Code`shared 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
`iterableToCeylon`	Source Code `shared Iterable iterableToCeylon(Tree.JSequenceEnumeration iterable, Anything(JNode, Node) update = ...)` Converts a RedHat AST SequenceEnumeration to a `ceylon.ast` `Iterable`. Parameters: `update = noop`
`iterableTypeToCeylon`	Source Code`shared 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)`
`keySubscriptToCeylon`	Source Code `shared KeySubscript keySubscriptToCeylon(Tree.JElement keySubscript, Anything(JNode, Node) update = ...)` Converts a RedHat AST Element to a `ceylon.ast` `KeySubscript`. Parameters: `update = noop`
`lIdentifierToCeylon`	Source Code`shared 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). For synthetic nodes produced by the typechecker during desugaring, a token may not exist. `update = = no` Throws `AssertionError` If the token type is not `LIDENTIFIER`.
`largeAsOperationToCeylon`	Source Code`shared 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
`largerOperationToCeylon`	Source Code`shared 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
`lazySpecificationToCeylon`	Source Code`shared 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`
`lazySpecifierToCeylon`	Source Code`shared 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`
`letExpressionToCeylon`	Source Code `shared LetExpression letExpressionToCeylon(Tree.JLetExpression letExpression, Anything(JNode, Node) update = ...)` Converts a RedHat AST LetExpression to a `ceylon.ast` `LetExpression`. Parameters: `update = noop`
`literalToCeylon`	Source Code`shared 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` `rt (is JStringLiteral\|JCharacterLiteral\|JIntegerLiteral\|JFloatLiteral\|JQuotedLiteral lit` `update = e =` Throws `AssertionError` If the token type is wrong.
`localModifierToCeylon`	Source Code`shared 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`
`logicalAssignmentOperationToCeylon`	Source Code`shared 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`
`logicalOperationToCeylon`	Source Code`shared 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`
`mainTypeToCeylon`	Source Code `shared MainType mainTypeToCeylon(Tree.JStaticType mainType, Anything(JNode, Node) update = ...)` Converts a RedHat AST StaticType to a `ceylon.ast` `MainType`. Parameters: `update = noop`
`matchCaseToCeylon`	Source Code `shared 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\|Tuple expression = expressionToCeylon(element, update)`
`measureOperationToCeylon`	Source Code`shared 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
`measureSubscriptToCeylon`	Source Code`shared 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
`memberDecToCeylon`	Source Code`shared 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`
`memberMetaToCeylon`	Source Code`shared 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`
`memberOperatorToCeylon`	Source Code `shared MemberOperator memberOperatorToCeylon(Tree.JMemberOp memberOperator, Anything(JNode, Node) update = ...)` Converts a RedHat AST MemberOp to a `ceylon.ast` `MemberOperator`. Parameters: `update = noop`
`metaToCeylon`	Source Code`shared 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`
`modifierToCeylon`	Source Code `shared 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`
`moduleBodyToCeylon`	Source Code `shared ModuleBody moduleBodyToCeylon(Tree.JImportModuleList moduleBody, Anything(JNode, Node) update = ...)` Converts a RedHat AST ImportModuleList to a `ceylon.ast` `ModuleBody`. Parameters: `update = noop`
`moduleCompilationUnitToCeylon`	Source Code`shared 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
`moduleDecToCeylon`	Source Code `shared ModuleDec moduleDecToCeylon(Tree.JModuleLiteral moduleDec, Anything(JNode, Node) update = ...)` Converts a RedHat AST ModuleLiteral to a `ceylon.ast` `ModuleDec`. Parameters: `update = noop`
`moduleDescriptorToCeylon`	Source Code `shared ModuleDescriptor moduleDescriptorToCeylon(Tree.JModuleDescriptor moduleDescriptor, Anything(JNode, Node) update = ...)` Converts a RedHat AST ModuleDescriptor to a `ceylon.ast` `ModuleDescriptor`. Parameters: `update = noop`
`moduleImportToCeylon`	Source Code `shared ModuleImport moduleImportToCeylon(Tree.JImportModule moduleImport, Anything(JNode, Node) update = ...)` Converts a RedHat AST ImportModule to a `ceylon.ast` `ModuleImport`. Parameters: `update = noop`
`multiplyAssignmentOperationToCeylon`	Source Code`shared 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
`namedArgumentToCeylon`	Source Code`shared 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`
`namedArgumentsToCeylon`	Source Code `shared NamedArguments namedArgumentsToCeylon(Tree.JNamedArgumentList namedArguments, Anything(JNode, Node) update = ...)` Converts a RedHat AST NamedArgumentList to a `ceylon.ast` `NamedArguments`. Parameters: `update = noop`
`negationOperationToCeylon`	Source Code`shared 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)`
`nonemptyConditionToCeylon`	Source Code`shared 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)`
`nonemptyOperationToCeylon`	Source Code`shared 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
`notEqualOperationToCeylon`	Source Code`shared 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
`notOperationToCeylon`	Source Code`shared 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
`objectArgumentToCeylon`	Source Code `shared ObjectArgument objectArgumentToCeylon(Tree.JObjectArgument objectArgument, Anything(JNode, Node) update = ...)` Converts a RedHat AST ObjectArgument to a `ceylon.ast` `ObjectArgument`. Parameters: `update = noop`
`objectDefinitionToCeylon`	Source Code `shared ObjectDefinition objectDefinitionToCeylon(Tree.JObjectDefinition objectDefinition, Anything(JNode, Node) update = ...)` Converts a RedHat AST ObjectDefinition to a `ceylon.ast` `ObjectDefinition`. Parameters: `update = noop`
`objectExpressionToCeylon`	Source Code `shared ObjectExpression objectExpressionToCeylon(Tree.JObjectExpression objectExpression, Anything(JNode, Node) update = ...)` Converts a RedHat AST ObjectExpression to a `ceylon.ast` `ObjectExpression`. Parameters: `update = noop`
`ofOperationToCeylon`	Source Code`shared 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
`openBoundToCeylon`	Source Code`shared 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
`operationToCeylon`	Source Code`shared 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`
`optionalTypeToCeylon`	Source Code`shared 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)`
`orAssignmentOperationToCeylon`	Source Code`shared 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
`orOperationToCeylon`	Source Code`shared 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
`outModifierToCeylon`	Source Code`shared 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`
`outerToCeylon`	Source Code`shared 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`.
`pIdentifierToCeylon`	Source Code`shared 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 = pdat` Throws `AssertionError` If the token type is not `PIDENTIFIER`.
`packageCompilationUnitToCeylon`	Source Code`shared 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
`packageDecToCeylon`	Source Code `shared PackageDec packageDecToCeylon(Tree.JPackageLiteral packageDec, Anything(JNode, Node) update = ...)` Converts a RedHat AST PackageLiteral to a `ceylon.ast` `PackageDec`. Parameters: `update = noop`
`packageDescriptorToCeylon`	Source Code `shared PackageDescriptor packageDescriptorToCeylon(Tree.JPackageDescriptor packageDescriptor, Anything(JNode, Node) update = ...)` Converts a RedHat AST PackageDescriptor to a `ceylon.ast` `PackageDescriptor`. Parameters: `update = noop`
`packageToCeylon`	Source Code`shared 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`.
`parameterReferenceToCeylon`	Source Code`shared 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`
`parameterToCeylon`	Source Code`shared 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`
`parametersToCeylon`	Source Code `shared Parameters parametersToCeylon(Tree.JParameterList parameters, Anything(JNode, Node) update = ...)` Converts a RedHat AST ParameterList to a `ceylon.ast` `Parameters`. Parameters: `update = noop`
`parseAddAssignmentOperation`	Source Code `shared AddAssignmentOperation? parseAddAssignmentOperation(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseAliasDec`	Source Code `shared AliasDec? parseAliasDec(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Alias Dec into an `AliasDec` using the Ceylon compiler (more specifically, the rule for a `metaLiteral`). Parameters: `update = noop`
`parseAndAssignmentOperation`	Source Code `shared AndAssignmentOperation? parseAndAssignmentOperation(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseAndOperation`	Source Code `shared AndOperation? parseAndOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an And Operation into an `AndOperation` using the Ceylon compiler (more specifically, the rule for an `conjunctionExpression`). Parameters: `update = noop`
`parseAnnotation`	Source Code `shared Annotation? parseAnnotation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Annotation into an `Annotation` using the Ceylon compiler (more specifically, the rule for an `annotation`). Parameters: `update = e =`
`parseAnnotations`	Source Code `shared Annotations? parseAnnotations(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for Annotations into an `Annotations` using the Ceylon compiler (more specifically, the rule for `annotations`). Parameters: `update = noop`
`parseAnonymousArgument`	Source Code `shared AnonymousArgument? parseAnonymousArgument(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Anonymous Argument into an `AnonymousArgument` using the Ceylon compiler (more specifically, the rule for an `anonymousArgument`). Parameters: `update = = no`
`parseAnyClass`	Source Code `shared AnyClass? parseAnyClass(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for Any Class into an `AnyClass` using the Ceylon compiler (more specifically, the rule for a `declaration`). Parameters: `update = noop`
`parseAnyCompilationUnit`	Source Code `shared AnyCompilationUnit? parseAnyCompilationUnit(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for Any Compilation Unit into an `AnyCompilationUnit` using the Ceylon compiler (more specifically, the rule for a `compilationUnit`). Parameters: `update = noop`
`parseAnyFunction`	Source Code `shared AnyFunction? parseAnyFunction(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for Any Function into an `AnyFunction` using the Ceylon compiler (more specifically, the rule for a `declaration`). Parameters: `update = noop`
`parseAnyInterface`	Source Code `shared AnyInterface? parseAnyInterface(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for Any Interface into an `AnyInterface` using the Ceylon compiler (more specifically, the rule for a `declaration`). Parameters: `update = noop`
`parseAnyInterfaceDefinition`	Source Code `shared AnyInterfaceDefinition? parseAnyInterfaceDefinition(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Any Interface Definition into an `AnyInterfaceDefinition` using the Ceylon compiler (more specifically, the rule for a `declaration`). Parameters: `update = = no`
`parseAnyMemberOperator`	Source Code `shared AnyMemberOperator? parseAnyMemberOperator(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for Any Member Operator into an `AnyMemberOperator` using the Ceylon compiler (more specifically, the rule for a `memberSelectionOperator`). Parameters: `update = noop`
`parseAnySpecifier`	Source Code `shared AnySpecifier? parseAnySpecifier(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseAnyValue`	Source Code `shared AnyValue? parseAnyValue(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for Any Value into an `AnyValue` using the Ceylon compiler (more specifically, the rule for a `declaration`). Parameters: `update = noop`
`parseArgumentList`	Source Code `shared ArgumentList? parseArgumentList(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Argument List into an `ArgumentList` using the Ceylon compiler (more specifically, the rule for a `sequencedArgument`). Parameters: `update = ate`
`parseArguments`	Source Code `shared Arguments? parseArguments(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for Arguments into `Arguments` using the Ceylon compiler (more specifically, the rule for `namedArguments` and `positionalArguments`). Parameters: `update = noop`
`parseArithmeticAssignmentOperation`	Source Code `shared ArithmeticAssignmentOperation? parseArithmeticAssignmentOperation(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseArithmeticOperation`	Source Code `shared ArithmeticOperation? parseArithmeticOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Arithmetic Operation into an `ArithmeticOperation` using the Ceylon compiler (more specifically, the rule for an `additiveExpression`). Parameters: `update = noop`
`parseAssertion`	Source Code `shared Assertion? parseAssertion(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Assertion into an `Assertion` using the Ceylon compiler (more specifically, the rule for an `assertion`). Parameters: `update = noop`
`parseAssignOperation`	Source Code `shared AssignOperation? parseAssignOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Assign Operation into an `AssignOperation` using the Ceylon compiler (more specifically, the rule for an `assignmentExpression`). Parameters: `update = noop`
`parseAssignmentOperation`	Source Code `shared AssignmentOperation? parseAssignmentOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Assignment Operation into an `AssignmentOperation` using the Ceylon compiler (more specifically, the rule for an `assignmentExpression`). Parameters: `update = noop`
`parseAssignmentStatement`	Source Code `shared AssignmentStatement? parseAssignmentStatement(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Assignment Statement into an `AssignmentStatement` using the Ceylon compiler (more specifically, the rule for an `expressionOrSpecificationStatement`). Parameters: `update = noop`
`parseAtom`	Source Code `shared Atom? parseAtom(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Atom into an `Atom` using the Ceylon compiler (more specifically, the rule for a `base`). Parameters: `update = noop`
`parseBaseExpression`	Source Code `shared BaseExpression? parseBaseExpression(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Base Expression into a `BaseExpression` using the Ceylon compiler (more specifically, the rule for a `baseReference`). Parameters: `update = noop`
`parseBaseMeta`	Source Code `shared BaseMeta? parseBaseMeta(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Base Meta into a `BaseMeta` using the Ceylon compiler (more specifically, the rule for a `metaLiteral`). Parameters: `update = noop`
`parseBaseType`	Source Code `shared BaseType? parseBaseType(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Base Type into a `BaseType` using the Ceylon compiler (more specifically, the rule for a `baseType`). Parameters: `update = noop`
`parseBinaryOperation`	Source Code `shared BinaryOperation? parseBinaryOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Binary Operation into a `BinaryOperation` using the Ceylon compiler (more specifically, the rule for an `assignmentExpression`). Parameters: `update = noop`
`parseBlock`	Source Code `shared Block? parseBlock(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Block into a `Block` using the Ceylon compiler (more specifically, the rule for a `block`). Parameters: `update = noop`
`parseBooleanCondition`	Source Code `shared BooleanCondition? parseBooleanCondition(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Boolean Condition into a `BooleanCondition` using the Ceylon compiler (more specifically, the rule for a `booleanCondition`). Parameters: `update = noop`
`parseBreak`	Source Code `shared Break? parseBreak(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Break into a `Break` using the Ceylon compiler (more specifically, the rule for a `directiveStatement`). Parameters: `update = noop`
`parseCallableConstructorDefinition`	Source Code `shared CallableConstructorDefinition? parseCallableConstructorDefinition(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseCallableParameter`	Source Code `shared CallableParameter? parseCallableParameter(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Callable Parameter into a `CallableParameter` using the Ceylon compiler (more specifically, the rule for a `parameter`). Parameters: `update = noop`
`parseCallableType`	Source Code `shared CallableType? parseCallableType(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Callable Type into a `CallableType` using the Ceylon compiler (more specifically, the rule for an `primaryType`). Parameters: `update = e =`
`parseCaseClause`	Source Code `shared CaseClause? parseCaseClause(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Case Clause into a `CaseClause` using the Ceylon compiler (more specifically, the rule for a `caseBlock`). Parameters: `update = noop`
`parseCaseItem`	Source Code `shared CaseItem? parseCaseItem(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Case Item into a `CaseItem` using the Ceylon compiler (more specifically, the rule for a `caseItem`). Parameters: `update = noop`
`parseCaseTypes`	Source Code `shared CaseTypes? parseCaseTypes(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for Case Types into `CaseTypes` using the Ceylon compiler (more specifically, the rule for `caseTypes`). Parameters: `update = e =`
`parseCatchClause`	Source Code `shared CatchClause? parseCatchClause(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Catch Clause into a `CatchClause` using the Ceylon compiler (more specifically, the rule for a `catchBlock`). Parameters: `update = noop`
`parseCharacterLiteral`	Source Code `shared CharacterLiteral? parseCharacterLiteral(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Character Literal into a `CharacterLiteral` using the Ceylon compiler (more specifically, the rule for a `nonStringLiteral`). Parameters: `update = noop`
`parseClassAliasDefinition`	Source Code `shared ClassAliasDefinition? parseClassAliasDefinition(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Class Alias into a `ClassAliasDefinition` using the Ceylon compiler (more specifically, the rule for a `declaration`). Parameters: `update = noop`
`parseClassBody`	Source Code `shared ClassBody? parseClassBody(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Class Body into a `ClassBody` using the Ceylon compiler (more specifically, the rule for a `classBody`). Parameters: `update = noop`
`parseClassDec`	Source Code `shared ClassDec? parseClassDec(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Class Dec into a `ClassDec` using the Ceylon compiler (more specifically, the rule for a `metaLiteral`). Parameters: `update = noop`
`parseClassDefinition`	Source Code `shared ClassDefinition? parseClassDefinition(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Class Definition into a `ClassDefinition` using the Ceylon compiler (more specifically, the rule for a `declaration`). Parameters: `update = noop`
`parseClassOrInterface`	Source Code `shared ClassOrInterface? parseClassOrInterface(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseClassSpecifier`	Source Code `shared ClassSpecifier? parseClassSpecifier(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Class Specifier into a `ClassSpecifier` using the Ceylon compiler (more specifically, the rule for a `classSpecifier`). Parameters: `update = noop`
`parseCompareOperation`	Source Code `shared CompareOperation? parseCompareOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Compare Operation into a `CompareOperation` using the Ceylon compiler (more specifically, the rule for a `comparisonExpression`). Parameters: `update = noop`
`parseComparisonOperation`	Source Code `shared ComparisonOperation? parseComparisonOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Comparison Operation into a `ComparisonOperation` using the Ceylon compiler (more specifically, the rule for a `comparisonExpression`). Parameters: `update = noop`
`parseCompilationUnit`	Source Code `shared CompilationUnit? parseCompilationUnit(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Compilation Unit into a `CompilationUnit` using the Ceylon compiler (more specifically, the rule for a `compilationUnit`). Parameters: `update = noop`
`parseComplementAssignmentOperation`	Source Code `shared ComplementAssignmentOperation? parseComplementAssignmentOperation(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseComplementOperation`	Source Code `shared ComplementOperation? parseComplementOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Complement Operation into a `ComplementOperation` using the Ceylon compiler (more specifically, the rule for a `unionExpression`). Parameters: `update = noop`
`parseComprehension`	Source Code `shared Comprehension? parseComprehension(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Comprehension into a `Comprehension` using the Ceylon compiler (more specifically, the rule for a `comprehension`). Parameters: `update = noop`
`parseComprehensionClause`	Source Code `shared ComprehensionClause? parseComprehensionClause(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Comprehension Clause into a `ComprehensionClause` using the Ceylon compiler (more specifically, the rule for a `comprehensionClause`). Parameters: `update = noop`
`parseCondition`	Source Code `shared Condition? parseCondition(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Condition into a `Condition` using the Ceylon compiler (more specifically, the rule for a `condition`). Parameters: `update = noop`
`parseConditionalExpression`	Source Code `shared ConditionalExpression? parseConditionalExpression(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseConditions`	Source Code `shared Conditions? parseConditions(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for Conditions into `Conditions` using the Ceylon compiler (more specifically, the rule for `conditions`). Parameters: `update = noop`
`parseConstruction`	Source Code `shared Construction? parseConstruction(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Construction into a `Construction` using the Ceylon compiler (more specifically, the rule for a `classInstantiation`). Parameters: `update = noop`
`parseConstructorDec`	Source Code `shared ConstructorDec? parseConstructorDec(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Constructor Dec into a `ConstructorDec` using the Ceylon compiler (more specifically, the rule for a `metaLiteral`). Parameters: `update = noop`
`parseConstructorDefinition`	Source Code `shared ConstructorDefinition? parseConstructorDefinition(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Constructor Definition into a `ConstructorDefinition` using the Ceylon compiler (more specifically, the rule for a `declaration`). Parameters: `update = noop`
`parseContinue`	Source Code `shared Continue? parseContinue(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Continue into a `Continue` using the Ceylon compiler (more specifically, the rule for a `continue`). Parameters: `update = noop`
`parseControlStructure`	Source Code `shared ControlStructure? parseControlStructure(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Control Structure into a `ControlStructure` using the Ceylon compiler (more specifically, the rule for a `controlStatement`). Parameters: `update = noop`
`parseDec`	Source Code `shared Dec? parseDec(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Dec into a `Dec` using the Ceylon compiler (more specifically, the rule for a `metaLiteral`). Parameters: `update = noop`
`parseDeclaration`	Source Code `shared Declaration? parseDeclaration(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Declaration into a `Declaration` using the Ceylon compiler (more specifically, the rule for a `declaration`). Parameters: `update = pdat`
`parseDefaultedCallableParameter`	Source Code `shared DefaultedCallableParameter? parseDefaultedCallableParameter(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseDefaultedParameter`	Source Code `shared DefaultedParameter? parseDefaultedParameter(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Defaulted Parameter into a `DefaultedParameter` using the Ceylon compiler (more specifically, the rule for a `parameterDeclarationOrRef`). Parameters: `update = noop`
`parseDefaultedParameterReference`	Source Code `shared DefaultedParameterReference? parseDefaultedParameterReference(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseDefaultedType`	Source Code `shared DefaultedType? parseDefaultedType(String code, Anything(JNode, Node) update = ...)` Parses 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 = = no`
`parseDefaultedValueParameter`	Source Code `shared DefaultedValueParameter? parseDefaultedValueParameter(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseDestructure`	Source Code `shared Destructure? parseDestructure(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Destructure into a `Destructure` using the Ceylon compiler (more specifically, the rule for a `destructure`). Parameters: `update = noop`
`parseDifferenceOperation`	Source Code `shared DifferenceOperation? parseDifferenceOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Difference Operation into a `DifferenceOperation` using the Ceylon compiler (more specifically, the rule for an `additiveExpression`). Parameters: `update = noop`
`parseDirective`	Source Code `shared Directive? parseDirective(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Directive into a `Directive` using the Ceylon compiler (more specifically, the rule for a `directive`). Parameters: `update = noop`
`parseDivideAssignmentOperation`	Source Code `shared DivideAssignmentOperation? parseDivideAssignmentOperation(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseDynamicBlock`	Source Code `shared DynamicBlock? parseDynamicBlock(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Dynamic Block into a `DynamicBlock` using the Ceylon compiler (more specifically, the rule for a `dynamicBlock`). Parameters: `update = = no`
`parseDynamicInterfaceDefinition`	Source Code `shared DynamicInterfaceDefinition? parseDynamicInterfaceDefinition(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseDynamicModifier`	Source Code `shared DynamicModifier? parseDynamicModifier(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Dynamic Modifier into a `DynamicModifier` using the Ceylon compiler (more specifically, the lexer). Parameters: `update = noop`
`parseDynamicValue`	Source Code `shared DynamicValue? parseDynamicValue(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Dynamic Value into a `DynamicValue` using the Ceylon compiler (more specifically, the rule for a `dynamicObject`). Parameters: `update = noop`
`parseElementOrSubrangeExpression`	Source Code `shared ElementOrSubrangeExpression? parseElementOrSubrangeExpression(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseElseClause`	Source Code `shared ElseClause? parseElseClause(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Else Clause into an `ElseClause` using the Ceylon compiler (more specifically, the rule for an `elseBlock`). Parameters: `update = upd`
`parseElseOperation`	Source Code `shared ElseOperation? parseElseOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Else Operation into an `ElseOperation` using the Ceylon compiler (more specifically, the rule for a `thenElseExpression`). Parameters: `update = noop`
`parseEntryOperation`	Source Code `shared EntryOperation? parseEntryOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Entry Operation into an `EntryOperation` using the Ceylon compiler (more specifically, the rule for an `entryRangeExpression`). Parameters: `update = noop`
`parseEntryPattern`	Source Code `shared EntryPattern? parseEntryPattern(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Entry Pattern into an `EntryPattern` using the Ceylon compiler (more specifically, the rule for an `keyItemPattern`). Parameters: `update = noop`
`parseEntryType`	Source Code `shared EntryType? parseEntryType(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Entry Type into an `EntryType` using the Ceylon compiler (more specifically, the rule for a `type`). Parameters: `update = noop`
`parseEqualOperation`	Source Code `shared EqualOperation? parseEqualOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Equal Operation into an `EqualOperation` using the Ceylon compiler (more specifically, the rule for an `equalityExpression`). Parameters: `update = noop`
`parseEqualityOperation`	Source Code `shared EqualityOperation? parseEqualityOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Equality Operation into an `EqualityOperation` using the Ceylon compiler (more specifically, the rule for an `equalityExpression`). Parameters: `update = noop`
`parseExistsCondition`	Source Code `shared ExistsCondition? parseExistsCondition(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Exists Condition into an `ExistsCondition` using the Ceylon compiler (more specifically, the rule for an `existsCondition`). Parameters: `update = noop`
`parseExistsOperation`	Source Code `shared ExistsOperation? parseExistsOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Exists Operation into an `ExistsOperation` using the Ceylon compiler (more specifically, the rule for an `existenceEmptinessExpression`). Parameters: `update = noop`
`parseExistsOrNonemptyCondition`	Source Code `shared ExistsOrNonemptyCondition? parseExistsOrNonemptyCondition(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseExponentiationOperation`	Source Code `shared ExponentiationOperation? parseExponentiationOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Exponentiation Operation into an `ExponentiationOperation` using the Ceylon compiler (more specifically, the rule for an `exponentiationExpression`). Parameters: `update = noop`
`parseExpression`	Source Code `shared Expression? parseExpression(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Expression into an `Expression` using the Ceylon compiler (more specifically, the rule for a `functionOrExpression`). Parameters: `update = noop`
`parseExpressionComprehensionClause`	Source Code `shared ExpressionComprehensionClause? parseExpressionComprehensionClause(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseExpressionStatement`	Source Code `shared ExpressionStatement? parseExpressionStatement(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Expression Statement into an `ExpressionStatement` using the Ceylon compiler (more specifically, the rule for an `expressionOrSpecificationStatement`). Parameters: `update = noop`
`parseExtendedType`	Source Code `shared ExtendedType? parseExtendedType(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Extended Type into an `ExtendedType` using the Ceylon compiler (more specifically, the rule for an `extendedType`). Parameters: `update = noop`
`parseExtension`	Source Code `shared Extension? parseExtension(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Extension into an `Extension` using the Ceylon compiler (more specifically, the rule for an `classInstantiation`). Parameters: `update = noop`
`parseExtensionOrConstruction`	Source Code `shared ExtensionOrConstruction? parseExtensionOrConstruction(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseFailClause`	Source Code `shared FailClause? parseFailClause(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Fail Clause into a `FailClause` using the Ceylon compiler (more specifically, the rule for a `failBlock`). Parameters: `update = e =`
`parseFinallyClause`	Source Code `shared FinallyClause? parseFinallyClause(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Finally Clause into a `FinallyClause` using the Ceylon compiler (more specifically, the rule for a `finallyBlock`). Parameters: `update = noop`
`parseFloatLiteral`	Source Code `shared FloatLiteral? parseFloatLiteral(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Float Literal into a `FloatLiteral` using the Ceylon compiler (more specifically, the rule for a `nonStringLiteral`). Parameters: `update = noop`
`parseForClause`	Source Code `shared ForClause? parseForClause(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a ‘`for`’ Clause into a `ForClause` using the Ceylon compiler (more specifically, the rule for a `forBlock`). Parameters: `update = e =`
`parseForComprehensionClause`	Source Code `shared ForComprehensionClause? parseForComprehensionClause(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseForFail`	Source Code `shared ForFail? parseForFail(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a ‘`for`’ loop into a `ForFail` using the Ceylon compiler (more specifically, the rule for a `forElse`). Parameters: `update = e =`
`parseForIterator`	Source Code `shared ForIterator? parseForIterator(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a For Iterator into a `ForIterator` using the Ceylon compiler (more specifically, the rule for a `forIterator`). Parameters: `update = noop`
`parseFullPackageName`	Source Code `shared FullPackageName? parseFullPackageName(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseFunctionArgument`	Source Code `shared FunctionArgument? parseFunctionArgument(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Function Argument into a `FunctionArgument` using the Ceylon compiler (more specifically, the rule for a `namedArgumentDeclaration`). Parameters: `update = e =`
`parseFunctionDec`	Source Code `shared FunctionDec? parseFunctionDec(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Function Dec into a `FunctionDec` using the Ceylon compiler (more specifically, the rule for a `metaLiteral`). Parameters: `update = noop`
`parseFunctionDeclaration`	Source Code `shared FunctionDeclaration? parseFunctionDeclaration(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Function Declaration into a `FunctionDeclaration` using the Ceylon compiler (more specifically, the rule for a `declaration`). Parameters: `update = noop`
`parseFunctionDefinition`	Source Code `shared FunctionDefinition? parseFunctionDefinition(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Function Definition into a `FunctionDefinition` using the Ceylon compiler (more specifically, the rule for a `declaration`). Parameters: `update = noop`
`parseFunctionExpression`	Source Code `shared FunctionExpression? parseFunctionExpression(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Function Expression into a `FunctionExpression` using the Ceylon compiler (more specifically, the rule for an `anonymousFunction`). Parameters: `update = = no`
`parseFunctionModifier`	Source Code `shared FunctionModifier? parseFunctionModifier(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Function Modifier into a `FunctionModifier` using the Ceylon compiler (more specifically, the lexer). Parameters: `update = noop`
`parseFunctionShortcutDefinition`	Source Code `shared FunctionShortcutDefinition? parseFunctionShortcutDefinition(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseGivenDec`	Source Code `shared GivenDec? parseGivenDec(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Given Dec into a `GivenDec` using the Ceylon compiler (more specifically, the rule for a `metaLiteral`). Parameters: `update = noop`
`parseGroupedExpression`	Source Code `shared GroupedExpression? parseGroupedExpression(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Grouped Expression into a `GroupedExpression` using the Ceylon compiler (more specifically, the rule for a `parExpression`). Parameters: `update = noop`
`parseGroupedType`	Source Code `shared GroupedType? parseGroupedType(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Grouped Type into a `GroupedType` using the Ceylon compiler (more specifically, the rule for a `groupedType`). Parameters: `update = noop`
`parseIdenticalOperation`	Source Code `shared IdenticalOperation? parseIdenticalOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Identical Operation into an `IdenticalOperation` using the Ceylon compiler (more specifically, the rule for an `equalityExpression`). Parameters: `update = noop`
`parseIdentifier`	Source Code `shared Identifier? parseIdentifier(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Identifier into an `Identifier` using the Ceylon compiler (more specifically, the rule for an Import Name). Parameters: `update = ode)`
`parseIdentityOperation`	Source Code `shared IdentityOperation? parseIdentityOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Identity Operation into an `IdentityOperation` using the Ceylon compiler (more specifically, the rule for an `negationComplementExpression`). Parameters: `update = noop`
`parseIfClause`	Source Code `shared IfClause? parseIfClause(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an If Clause into an `IfClause` using the Ceylon compiler (more specifically, the rule for an `ifBlock`). Parameters: `update = noop`
`parseIfComprehensionClause`	Source Code `shared IfComprehensionClause? parseIfComprehensionClause(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseIfElse`	Source Code `shared IfElse? parseIfElse(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an If Else into an `IfElse` using the Ceylon compiler (more specifically, the rule for an `ifElse`). Parameters: `update = noop`
`parseIfElseExpression`	Source Code `shared IfElseExpression? parseIfElseExpression(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseImport`	Source Code `shared Import? parseImport(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Import into an `Import` using the Ceylon compiler (more specifically, the rule for an `import`). Parameters: `update = noop`
`parseImportAlias`	Source Code `shared ImportAlias? parseImportAlias(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Import Alias into an `ImportAlias` using the Ceylon compiler (more specifically, the rule for an `importElement`). Parameters: `update = noop`
`parseImportElement`	Source Code `shared ImportElement? parseImportElement(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Import Element into an `ImportElement` using the Ceylon compiler (more specifically, the rule for an `importElement`). Parameters: `update = noop`
`parseImportElements`	Source Code `shared ImportElements? parseImportElements(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Import Elements into an `ImportElements` using the Ceylon compiler (more specifically, the rule for an `importElementList`). Parameters: `update = noop`
`parseImportWildcard`	Source Code `shared ImportWildcard? parseImportWildcard(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Import Wildcard into an `ImportWildcard` using the Ceylon compiler (more specifically, the rule for an `importWildcard`). Parameters: `update = noop`
`parseInModifier`	Source Code `shared InModifier? parseInModifier(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an In Modifier into an `InModifier` using the Ceylon compiler (more specifically, the rule for a `variance`). Parameters: `update = e =`
`parseInOperation`	Source Code `shared InOperation? parseInOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an In Operation into an `InOperation` using the Ceylon compiler (more specifically, the rule for a `comparisonExpression`). Parameters: `update = noop`
`parseInitialComprehensionClause`	Source Code `shared InitialComprehensionClause? parseInitialComprehensionClause(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseInlineDefinitionArgument`	Source Code `shared InlineDefinitionArgument? parseInlineDefinitionArgument(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseIntegerLiteral`	Source Code `shared IntegerLiteral? parseIntegerLiteral(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Integer Literal into an `IntegerLiteral` using the Ceylon compiler (more specifically, the rule for a `nonstringLiteral`). Parameters: `update = noop`
`parseInterfaceAliasDefinition`	Source Code `shared InterfaceAliasDefinition? parseInterfaceAliasDefinition(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseInterfaceBody`	Source Code `shared InterfaceBody? parseInterfaceBody(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Interface Body into an `InterfaceBody` using the Ceylon compiler (more specifically, the rule for an `interfaceBody`). Parameters: `update = noop`
`parseInterfaceDec`	Source Code `shared InterfaceDec? parseInterfaceDec(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Interface Dec into an `InterfaceDec` using the Ceylon compiler (more specifically, the rule for an `metaLiteral`). Parameters: `update = noop`
`parseInterfaceDefinition`	Source Code `shared InterfaceDefinition? parseInterfaceDefinition(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Interface Definition into an `InterfaceDefinition` using the Ceylon compiler (more specifically, the rule for a `declaration`). Parameters: `update = noop`
`parseIntersectAssignmentOperation`	Source Code `shared IntersectAssignmentOperation? parseIntersectAssignmentOperation(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseIntersectionOperation`	Source Code `shared IntersectionOperation? parseIntersectionOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Intersection Operation into an `IntersectionOperation` using the Ceylon compiler (more specifically, the rule for an `intersectionExpression`). Parameters: `update = noop`
`parseIntersectionType`	Source Code `shared IntersectionType? parseIntersectionType(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Intersection Type into an `IntersectionType` using the Ceylon compiler (more specifically, the rule for an `intersectionType`). Parameters: `update = noop`
`parseInvocation`	Source Code `shared Invocation? parseInvocation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Invocation into an `Invocation` using the Ceylon compiler (more specifically, the rule for a `primary`). Parameters: `update = noop`
`parseInvocationStatement`	Source Code `shared InvocationStatement? parseInvocationStatement(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Invocation Statement into an `InvocationStatement` using the Ceylon compiler (more specifically, the rule for an `expressionOrSpecificationStatement`). Parameters: `update = noop`
`parseIsCase`	Source Code `shared IsCase? parseIsCase(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Is Case into an `IsCase` using the Ceylon compiler (more specifically, the rule for an `isCaseCondition`). Parameters: `update = noop`
`parseIsCondition`	Source Code `shared IsCondition? parseIsCondition(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Is Condition into an `IsCondition` using the Ceylon compiler (more specifically, the rule for an `isCondition`). Parameters: `update = noop`
`parseIsOperation`	Source Code `shared IsOperation? parseIsOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Is Operation into an `IsOperation` using the Ceylon compiler (more specifically, the rule for a `comparisonExpression`). Parameters: `update = noop`
`parseIterable`	Source Code `shared Iterable? parseIterable(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Iterable into an `Iterable` using the Ceylon compiler (more specifically, the rule for an `enumeration`). Parameters: `update = noop`
`parseIterableType`	Source Code `shared IterableType? parseIterableType(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Iterable Type into an `IterableType` using the Ceylon compiler (more specifically, the rule for an `iterableType`). Parameters: `update = noop`
`parseKeySubscript`	Source Code `shared KeySubscript? parseKeySubscript(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Key Subscript into a `KeySubscript` using the Ceylon compiler (more specifically, the rule for a `indexOrIndexRange`). Parameters: `update = noop`
`parseLIdentifier`	Source Code `shared LIdentifier? parseLIdentifier(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Lowercase Identifier into an `LIdentifier` using the Ceylon compiler (more specifically, the rule for a Member Name). Parameters: `update = ode)`
`parseLargeAsOperation`	Source Code `shared LargeAsOperation? parseLargeAsOperation(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseLargerOperation`	Source Code `shared LargerOperation? parseLargerOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Larger Operation into a `LargerOperation` using the Ceylon compiler (more specifically, the rule for a `comparisonExpression`). Parameters: `update = noop`
`parseLazySpecification`	Source Code `shared LazySpecification? parseLazySpecification(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Lazy Specification into a `LazySpecification` using the Ceylon compiler (more specifically, the rule for an `expressionOrSpecificationStatement`). Parameters: `update = noop`
`parseLazySpecifier`	Source Code `shared LazySpecifier? parseLazySpecifier(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Lazy Specifier into a `LazySpecifier` using the Ceylon compiler (more specifically, the rule for a `lazySpecifier`). Parameters: `update = e =`
`parseLetExpression`	Source Code `shared LetExpression? parseLetExpression(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Let Expression into a `LetExpression` using the Ceylon compiler (more specifically, the rule for a `let`). Parameters: `update = noop`
`parseLiteral`	Source Code `shared Literal? parseLiteral(String code, Anything(JNode, Node) update = ...)` Parses 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 = e =`
`parseLocalModifier`	Source Code `shared LocalModifier? parseLocalModifier(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Local Modifier into a `LocalModifier` using the Ceylon compiler (more specifically, the lexer). Parameters: `update = noop`
`parseLogicalAssignmentOperation`	Source Code `shared LogicalAssignmentOperation? parseLogicalAssignmentOperation(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseLogicalOperation`	Source Code `shared LogicalOperation? parseLogicalOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Logical Operation into a `LogicalOperation` using the Ceylon compiler (more specifically, the rule for a `disjunctionExpression`). Parameters: `update = noop`
`parseMainType`	Source Code `shared MainType? parseMainType(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Main Type into a `MainType` using the Ceylon compiler (more specifically, the rule for a `unionType`). Parameters: `update = noop`
`parseMatchCase`	Source Code `shared MatchCase? parseMatchCase(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Match Case into a `MatchCase` using the Ceylon compiler (more specifically, the rule for a `matchCaseCondition`). Parameters: `update = noop`
`parseMeasureOperation`	Source Code `shared MeasureOperation? parseMeasureOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Measure Operation into a `MeasureOperation` using the Ceylon compiler (more specifically, the rule for an `entryRangeExpression`). Parameters: `update = noop`
`parseMeasureSubscript`	Source Code `shared MeasureSubscript? parseMeasureSubscript(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Measure Subscript into a `MeasureSubscript` using the Ceylon compiler (more specifically, the rule for an `indexOrIndexRange`). Parameters: `update = noop`
`parseMemberDec`	Source Code `shared MemberDec? parseMemberDec(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Member Dec into a `MemberDec` using the Ceylon compiler (more specifically, the rule for a `metaLiteral`). Parameters: `update = noop`
`parseMemberMeta`	Source Code `shared MemberMeta? parseMemberMeta(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Member Meta into a `MemberMeta` using the Ceylon compiler (more specifically, the rule for a `metaLiteral`). Parameters: `update = noop`
`parseMemberOperator`	Source Code `shared MemberOperator? parseMemberOperator(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Member Operator into a `MemberOperator` using the Ceylon compiler (more specifically, the rule for a `memberSelectionOperator`). Parameters: `update = noop`
`parseMeta`	Source Code `shared Meta? parseMeta(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Meta into a `Meta` using the Ceylon compiler (more specifically, the rule for a `metaLiteral`). Parameters: `update = noop`
`parseModifier`	Source Code `shared Modifier? parseModifier(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Modifier into a `Modifier` using the Ceylon compiler (more specifically, the lexer). Parameters: `update = noop`
`parseModuleBody`	Source Code `shared ModuleBody? parseModuleBody(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Module Body into a `ModuleBody` using the Ceylon compiler (more specifically, the rule for a `moduleBody`). Parameters: `update = noop`
`parseModuleCompilationUnit`	Source Code `shared ModuleCompilationUnit? parseModuleCompilationUnit(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseModuleDec`	Source Code `shared ModuleDec? parseModuleDec(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Module Dec into a `ModuleDec` using the Ceylon compiler (more specifically, the rule for a `metaLiteral`). Parameters: `update = noop`
`parseModuleDescriptor`	Source Code `shared ModuleDescriptor? parseModuleDescriptor(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Module Descriptor into a `ModuleDescriptor` using the Ceylon compiler (more specifically, the rule for a `moduleDescriptor`). Parameters: `update = noop`
`parseModuleImport`	Source Code `shared ModuleImport? parseModuleImport(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Module Import into a `ModuleImport` using the Ceylon compiler (more specifically, the rule for an `importModuleList`). Parameters: `update = = no`
`parseMultiplyAssignmentOperation`	Source Code `shared MultiplyAssignmentOperation? parseMultiplyAssignmentOperation(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseNamedArgument`	Source Code `shared NamedArgument? parseNamedArgument(String code, Anything(JNode, Node) update = ...)` Parses 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 = pdat`
`parseNamedArguments`	Source Code `shared NamedArguments? parseNamedArguments(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for Named Arguments into `NamedArguments` using the Ceylon compiler (more specifically, the rule for `namedArguments`). Parameters: `update = noop`
`parseNegationOperation`	Source Code `shared NegationOperation? parseNegationOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Negation Operation into a `NegationOperation` using the Ceylon compiler (more specifically, the rule for a `negationComplementExpression`). Parameters: `update = noop`
`parseNonemptyCondition`	Source Code `shared NonemptyCondition? parseNonemptyCondition(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Nonempty Condition into a `NonemptyCondition` using the Ceylon compiler (more specifically, the rule for a `nonemptyCondition`). Parameters: `update = noop`
`parseNonemptyOperation`	Source Code `shared NonemptyOperation? parseNonemptyOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Nonempty Operation into a `NonemptyOperation` using the Ceylon compiler (more specifically, the rule for a `existenceEmptinessExpression`). Parameters: `update = noop`
`parseNotEqualOperation`	Source Code `shared NotEqualOperation? parseNotEqualOperation(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseNotOperation`	Source Code `shared NotOperation? parseNotOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Not Operation into a `NotOperation` using the Ceylon compiler (more specifically, the rule for a `logicalNegationExpression`). Parameters: `update = noop`
`parseObjectArgument`	Source Code `shared ObjectArgument? parseObjectArgument(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Object Argument into an `ObjectArgument` using the Ceylon compiler (more specifically, the rule for an `objectArgument`). Parameters: `update = noop`
`parseObjectDefinition`	Source Code `shared ObjectDefinition? parseObjectDefinition(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Object Definition into an `ObjectDefinition` using the Ceylon compiler (more specifically, the rule for an `declaration`). Parameters: `update = noop`
`parseObjectExpression`	Source Code `shared ObjectExpression? parseObjectExpression(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Object Expression into an `ObjectExpression` using the Ceylon compiler (more specifically, the rule for an `objectExpression`). Parameters: `update = noop`
`parseOfOperation`	Source Code `shared OfOperation? parseOfOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Of Operation into an `OfOperation` using the Ceylon compiler (more specifically, the rule for a `comparisonExpression`). Parameters: `update = noop`
`parseOperation`	Source Code `shared Operation? parseOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Operation into an `Operation` using the Ceylon compiler (more specifically, the rule for an `assignmentExpression`). Parameters: `update = noop`
`parseOptionalType`	Source Code `shared OptionalType? parseOptionalType(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Optional Type into an `OptionalType` using the Ceylon compiler (more specifically, the rule for an `primaryType`). Parameters: `update = noop`
`parseOrAssignmentOperation`	Source Code `shared OrAssignmentOperation? parseOrAssignmentOperation(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseOrOperation`	Source Code `shared OrOperation? parseOrOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Or Operation into an `OrOperation` using the Ceylon compiler (more specifically, the rule for an `disjunctionExpression`). Parameters: `update = noop`
`parseOutModifier`	Source Code `shared OutModifier? parseOutModifier(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Out Modifier into an `OutModifier` using the Ceylon compiler (more specifically, the rule for a `variance`). Parameters: `update = e =`
`parseOuter`	Source Code `shared Outer? parseOuter(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Outer into an `Outer` using the Ceylon compiler (more specifically, the rule for a `selfReference`). Parameters: `update = noop`
`parsePIdentifier`	Source Code `shared LIdentifier? parsePIdentifier(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Package Identifier into an `LIdentifier` using the Ceylon compiler (more specifically, the rule for a `packageName`). Parameters: `update = ode)`
`parsePackage`	Source Code `shared Package? parsePackage(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Package into a `Package` using the Ceylon compiler (more specifically, the rule for a `selfReference`). Parameters: `update = noop`
`parsePackageCompilationUnit`	Source Code `shared PackageCompilationUnit? parsePackageCompilationUnit(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parsePackageDec`	Source Code `shared PackageDec? parsePackageDec(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Package Dec into a `PackageDec` using the Ceylon compiler (more specifically, the rule for a `metaLiteral`). Parameters: `update = noop`
`parsePackageDescriptor`	Source Code `shared PackageDescriptor? parsePackageDescriptor(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Package Descriptor into a `PackageDescriptor` using the Ceylon compiler (more specifically, the rule for a `packageDescriptor`). Parameters: `update = noop`
`parseParameter`	Source Code `shared Parameter? parseParameter(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Parameter into a `Parameter` using the Ceylon compiler (more specifically, the rule for a `parameterDeclarationOrRef`). Parameters: `update = noop`
`parseParameterReference`	Source Code `shared ParameterReference? parseParameterReference(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Parameter Reference into a `ParameterReference` using the Ceylon compiler (more specifically, the rule for a `parameterRef`). Parameters: `update = noop`
`parseParameters`	Source Code `shared Parameters? parseParameters(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Parameters into a `Parameters` using the Ceylon compiler (more specifically, the rule for a `parameters`). Parameters: `update = noop`
`parsePattern`	Source Code `shared Pattern? parsePattern(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Pattern into a `Pattern` using the Ceylon compiler (more specifically, the rule for a `pattern`). Parameters: `update = noop`
`parsePositionalArguments`	Source Code `shared PositionalArguments? parsePositionalArguments(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for Positional Arguments into `PositionalArguments` using the Ceylon compiler (more specifically, the rule for `positionalArguments`). Parameters: `update = pdat`
`parsePostfixDecrementOperation`	Source Code `shared PostfixDecrementOperation? parsePostfixDecrementOperation(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parsePostfixIncrementOperation`	Source Code `shared PostfixIncrementOperation? parsePostfixIncrementOperation(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parsePostfixOperation`	Source Code `shared PostfixOperation? parsePostfixOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Postfix Operation into a `PostfixOperation` using the Ceylon compiler (more specifically, the rule for a `postfixIncrementDecrementExpression`). Parameters: `update = noop`
`parsePrefixDecrementOperation`	Source Code `shared PrefixDecrementOperation? parsePrefixDecrementOperation(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parsePrefixIncrementOperation`	Source Code `shared PrefixIncrementOperation? parsePrefixIncrementOperation(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parsePrefixOperation`	Source Code `shared PrefixOperation? parsePrefixOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Prefix Operation into a `PrefixOperation` using the Ceylon compiler (more specifically, the rule for an `incrementDecrementExpression`). Parameters: `update = noop`
`parsePrefixPostfixStatement`	Source Code `shared PrefixPostfixStatement? parsePrefixPostfixStatement(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parsePrimary`	Source Code `shared Primary? parsePrimary(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Primary into a `Primary` using the Ceylon compiler (more specifically, the rule for a `primary`). Parameters: `update = noop`
`parsePrimaryType`	Source Code `shared PrimaryType? parsePrimaryType(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Primary Type into a `PrimaryType` using the Ceylon compiler (more specifically, the rule for a `primaryType`). Parameters: `update = noop`
`parseProductOperation`	Source Code `shared ProductOperation? parseProductOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Product Operation into a `ProductOperation` using the Ceylon compiler (more specifically, the rule for a `multiplicativeExpression`). Parameters: `update = noop`
`parseQualifiedExpression`	Source Code `shared QualifiedExpression? parseQualifiedExpression(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Qualified Expression into a `QualifiedExpression` using the Ceylon compiler (more specifically, the rule for a `primary`). Parameters: `update = noop`
`parseQualifiedType`	Source Code `shared QualifiedType? parseQualifiedType(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Qualified Type into a `QualifiedType` using the Ceylon compiler (more specifically, the rule for a `qualifiedType`). Parameters: `update = noop`
`parseQuotientOperation`	Source Code `shared QuotientOperation? parseQuotientOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Quotient Operation into a `QuotientOperation` using the Ceylon compiler (more specifically, the rule for a `multiplicativeExpression`). Parameters: `update = noop`
`parseRangeSubscript`	Source Code `shared RangeSubscript? parseRangeSubscript(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Range Subscript into a `RangeSubscript` using the Ceylon compiler (more specifically, the rule for an `indexOrIndexRange`). Parameters: `update = noop`
`parseRemainderAssignmentOperation`	Source Code `shared RemainderAssignmentOperation? parseRemainderAssignmentOperation(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseRemainderOperation`	Source Code `shared RemainderOperation? parseRemainderOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Remainder Operation into a `RemainderOperation` using the Ceylon compiler (more specifically, the rule for a `multiplicativeExpression`). Parameters: `update = noop`
`parseRequiredParameter`	Source Code `shared RequiredParameter? parseRequiredParameter(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Required Parameter into a `RequiredParameter` using the Ceylon compiler (more specifically, the rule for a `parameterDeclarationOrRef`). Parameters: `update = noop`
`parseResource`	Source Code `shared Resource? parseResource(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Resource into a `Resource` using the Ceylon compiler (more specifically, the rule for a `resource`). Parameters: `update = = no`
`parseResources`	Source Code `shared Resources? parseResources(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for Resources into `Resources` using the Ceylon compiler (more specifically, the rule for `resources`). Parameters: `update = noop`
`parseReturn`	Source Code `shared Return? parseReturn(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Return into a `Return` using the Ceylon compiler (more specifically, the rule for a `return`). Parameters: `update = noop`
`parseSafeMemberOperator`	Source Code `shared SafeMemberOperator? parseSafeMemberOperator(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseSatisfiedTypes`	Source Code `shared SatisfiedTypes? parseSatisfiedTypes(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for Satisfied Types into `SatisfiedTypes` using the Ceylon compiler (more specifically, the rule for `satisfiedTypes`). Parameters: `update = noop`
`parseScaleOperation`	Source Code `shared ScaleOperation? parseScaleOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Scale Operation into a `ScaleOperation` using the Ceylon compiler (more specifically, the rule for a `scaleExpression`). Parameters: `update = noop`
`parseSelfReference`	Source Code `shared SelfReference? parseSelfReference(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Self Reference into a `SelfReference` using the Ceylon compiler (more specifically, the rule for a `selfReference`). Parameters: `update = noop`
`parseSequentialType`	Source Code `shared SequentialType? parseSequentialType(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Sequential Type into a `SequentialType` using the Ceylon compiler (more specifically, the rule for an `primaryType`). Parameters: `update = noop`
`parseSetAssignmentOperation`	Source Code `shared SetAssignmentOperation? parseSetAssignmentOperation(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseSetOperation`	Source Code `shared SetOperation? parseSetOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Set Operation into a `SetOperation` using the Ceylon compiler (more specifically, the rule for a `unionExpression`). Parameters: `update = noop`
`parseSimpleType`	Source Code `shared SimpleType? parseSimpleType(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Simple Type into a `SimpleType` using the Ceylon compiler (more specifically, the rule for a `qualifiedType`). Parameters: `update = noop`
`parseSmallAsOperation`	Source Code `shared SmallAsOperation? parseSmallAsOperation(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseSmallerOperation`	Source Code `shared SmallerOperation? parseSmallerOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Smaller Operation into a `SmallerOperation` using the Ceylon compiler (more specifically, the rule for a `comparisonExpression`). Parameters: `update = noop`
`parseSpanFromSubscript`	Source Code `shared SpanFromSubscript? parseSpanFromSubscript(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseSpanOperation`	Source Code `shared SpanOperation? parseSpanOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Span Operation into a `SpanOperation` using the Ceylon compiler (more specifically, the rule for an `entryRangeExpression`). Parameters: `update = noop`
`parseSpanSubscript`	Source Code `shared SpanSubscript? parseSpanSubscript(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Span Subscript into a `SpanSubscript` using the Ceylon compiler (more specifically, the rule for an `indexOrIndexRange`). Parameters: `update = noop`
`parseSpanToSubscript`	Source Code `shared SpanToSubscript? parseSpanToSubscript(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseSpecification`	Source Code `shared Specification? parseSpecification(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Specification into a `Specification` using the Ceylon compiler (more specifically, the rule for an `expressionOrSpecificationStatement`). Parameters: `update = noop`
`parseSpecifiedArgument`	Source Code `shared SpecifiedArgument? parseSpecifiedArgument(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Specified Argument into a `SpecifiedArgument` using the Ceylon compiler (more specifically, the rule for a `namedArgument`). Parameters: `update = pdat`
`parseSpecifier`	Source Code `shared Specifier? parseSpecifier(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Specifier into a `Specifier` using the Ceylon compiler (more specifically, the rule for a `specifier`). Parameters: `update = e =`
`parseSpreadArgument`	Source Code `shared SpreadArgument? parseSpreadArgument(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Spread Argument into a `SpreadArgument` using the Ceylon compiler (more specifically, the rule for a `spreadArgument`). Parameters: `update = noop`
`parseSpreadMemberOperator`	Source Code `shared SpreadMemberOperator? parseSpreadMemberOperator(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseSpreadType`	Source Code `shared SpreadType? parseSpreadType(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Spread Type into a `SpreadType` using the Ceylon compiler (more specifically, the rule for a `spreadType`). Parameters: `update = noop`
`parseStatement`	Source Code `shared Statement? parseStatement(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Statement into a `Statement` using the Ceylon compiler (more specifically, the rule for a `declarationOrStatement`). Parameters: `update = = no`
`parseStringLiteral`	Source Code `shared StringLiteral? parseStringLiteral(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a String Literal into a `StringLiteral` using the Ceylon compiler (more specifically, the rule for a `stringLiteral`). Parameters: `update = ate`
`parseStringTemplate`	Source Code `shared StringTemplate? parseStringTemplate(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a String Template into a `StringTemplate` using the Ceylon compiler (more specifically, the rule for a `stringExpression`). Parameters: `update = = no`
`parseSubscript`	Source Code `shared Subscript? parseSubscript(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Subscript into a `Subscript` using the Ceylon compiler (more specifically, the rule for an `indexOrIndexRange`). Parameters: `update = noop`
`parseSubtractAssignmentOperation`	Source Code `shared SubtractAssignmentOperation? parseSubtractAssignmentOperation(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseSumOperation`	Source Code `shared SumOperation? parseSumOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Sum Operation into a `SumOperation` using the Ceylon compiler (more specifically, the rule for an `additiveExpression`). Parameters: `update = noop`
`parseSuper`	Source Code `shared Super? parseSuper(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Super into a `Super` using the Ceylon compiler (more specifically, the rule for a `selfReference`). Parameters: `update = noop`
`parseSwitchCaseElse`	Source Code `shared SwitchCaseElse? parseSwitchCaseElse(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseSwitchCaseElseExpression`	Source Code `shared SwitchCaseElseExpression? parseSwitchCaseElseExpression(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseSwitchCases`	Source Code `shared SwitchCases? parseSwitchCases(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for Switch Cases into `SwitchCases` using the Ceylon compiler (more specifically, the rule for `cases`). Parameters: `update = noop`
`parseSwitchClause`	Source Code `shared SwitchClause? parseSwitchClause(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Switch Clause into a `SwitchClause` using the Ceylon compiler (more specifically, the rule for a `switchHeader`). Parameters: `update = noop`
`parseThenOperation`	Source Code `shared ThenOperation? parseThenOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Then Operation into a `ThenOperation` using the Ceylon compiler (more specifically, the rule for a `thenElseExpression`). Parameters: `update = noop`
`parseThis`	Source Code `shared This? parseThis(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a This into a `This` using the Ceylon compiler (more specifically, the rule for a `selfReference`). Parameters: `update = noop`
`parseThrow`	Source Code `shared Throw? parseThrow(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Throw into a `Throw` using the Ceylon compiler (more specifically, the rule for a `throw`). Parameters: `update = noop`
`parseTryCatchFinally`	Source Code `shared TryCatchFinally? parseTryCatchFinally(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseTryClause`	Source Code `shared TryClause? parseTryClause(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Try Clause into a `TryClause` using the Ceylon compiler (more specifically, the rule for a `tryBlock`). Parameters: `update = noop`
`parseTuple`	Source Code `shared Tuple? parseTuple(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Tuple into a `Tuple` using the Ceylon compiler (more specifically, the rule for a `tuple`). Parameters: `update = noop`
`parseTuplePattern`	Source Code `shared TuplePattern? parseTuplePattern(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Tuple Pattern into a `TuplePattern` using the Ceylon compiler (more specifically, the rule for a `tuplePattern`). Parameters: `update = noop`
`parseTupleType`	Source Code `shared TupleType? parseTupleType(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Tuple Type into a `TupleType` using the Ceylon compiler (more specifically, the rule for a `tupleType`). Parameters: `update = e =`
`parseType`	Source Code `shared Type? parseType(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Type into a `Type` using the Ceylon compiler (more specifically, the rule for a `type`). Parameters: `update = noop`
`parseTypeAliasDefinition`	Source Code `shared TypeAliasDefinition? parseTypeAliasDefinition(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseTypeArguments`	Source Code `shared TypeArguments? parseTypeArguments(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for Type Arguments into a `TypeArguments` using the Ceylon compiler (more specifically, the rule for `typeArguments`). Parameters: `update = noop`
`parseTypeConstraint`	Source Code `shared TypeConstraint? parseTypeConstraint(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Type Constraint into a `TypeConstraint` using the Ceylon compiler (more specifically, the rule for a `typeConstraint`). Parameters: `update = noop`
`parseTypeDec`	Source Code `shared TypeDec? parseTypeDec(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Type Dec into a `TypeDec` using the Ceylon compiler (more specifically, the rule for a `metaLiteral`). Parameters: `update = noop`
`parseTypeDeclaration`	Source Code `shared TypeDeclaration? parseTypeDeclaration(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Type Declaration into a `TypeDeclaration` using the Ceylon compiler (more specifically, the rule for a `declaration`). Parameters: `update = noop`
`parseTypeIsh`	Source Code `shared TypeIsh? parseTypeIsh(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseTypeMeta`	Source Code `shared TypeMeta? parseTypeMeta(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Type Meta into a `TypeMeta` using the Ceylon compiler (more specifically, the rule for a `metaLiteral`). Parameters: `update = noop`
`parseTypeModifier`	Source Code `shared TypeModifier? parseTypeModifier(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Type Modifier into a `TypeModifier` using the Ceylon compiler (more specifically, the lexer). Parameters: `update = noop`
`parseTypeParameter`	Source Code `shared TypeParameter? parseTypeParameter(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Type Parameter into a `TypeParameter` using the Ceylon compiler (more specifically, the rule for a `typeParameter`). Parameters: `update = noop`
`parseTypeParameters`	Source Code `shared TypeParameters? parseTypeParameters(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for Type Parameters into `TypeParameters` using the Ceylon compiler (more specifically, the rule for `typeParameters`). Parameters: `update = noop`
`parseTypeSpecifier`	Source Code `shared TypeSpecifier? parseTypeSpecifier(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Type Specifier into a `TypeSpecifier` using the Ceylon compiler (more specifically, the rule for a `typeSpecifier`). Parameters: `update = noop`
`parseTypedDeclaration`	Source Code `shared TypedDeclaration? parseTypedDeclaration(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Typed Declaration into a `TypedDeclaration` using the Ceylon compiler (more specifically, the rule for a `declaration`). Parameters: `update = noop`
`parseUIdentifier`	Source Code `shared UIdentifier? parseUIdentifier(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for an Uppercase Identifier into a `UIdentifier` using the Ceylon compiler (more specifically, the rule for a Type Name). Parameters: `update = ode)`
`parseUnaryArithmeticOperation`	Source Code `shared UnaryArithmeticOperation? parseUnaryArithmeticOperation(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseUnaryIshOperation`	Source Code `shared UnaryIshOperation? parseUnaryIshOperation(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseUnaryOperation`	Source Code `shared UnaryOperation? parseUnaryOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Unary Operation into a `UnaryOperation` using the Ceylon compiler (more specifically, the rule for an `assignmentExpression`). Parameters: `update = noop`
`parseUnaryTypeOperation`	Source Code `shared UnaryTypeOperation? parseUnaryTypeOperation(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseUnionAssignmentOperation`	Source Code `shared UnionAssignmentOperation? parseUnionAssignmentOperation(String code, Anything(JNode, Node) update = ...)` Parses 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`
`parseUnionOperation`	Source Code `shared UnionOperation? parseUnionOperation(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Union Operation into an `UnionOperation` using the Ceylon compiler (more specifically, the rule for a `unionExpression`). Parameters: `update = noop`
`parseUnionType`	Source Code `shared UnionType? parseUnionType(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Union Type into an `UnionType` using the Ceylon compiler (more specifically, the rule for a `unionType`). Parameters: `update = noop`
`parseUnionableType`	Source Code `shared UnionableType? parseUnionableType(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Unionable Type into a `UnionableType` using the Ceylon compiler (more specifically, the rule for an `intersectionType`). Parameters: `update = noop`
`parseValueArgument`	Source Code `shared ValueArgument? parseValueArgument(String code, Anything(JNode, Node) update = ...)` Parses the given `code` for a Value Argument into a `ValueArgument` using the Ceylon compiler (more specifically, the rule for a `namedArgumentDeclaration`). Parameters: `update = = no`
`parseValueConstructorDefinition`

Keyboard Shortcuts

Documentation:

Search page:

Filter declarations by tags