CeylonExpressionTransformer.ceylon

"Builds a Ceylon expression string for an AST node;
 compiling and evaluating the resulting string will yield
 a copy of the transformed node.
 
 Usage:
 ~~~
 myNode.transform(CeylonExpressionTransformer());
 ~~~"
shared class CeylonExpressionTransformer(String indentLevel = "    ") satisfies ImmediateNarrowingTransformer<String> {
    
    variable String indent = "";
    
    String transformWithIndent(Node|Node[]|Null that) {
        switch (that)
        case (is Node) {
            value origIndent = indent;
            indent += indentLevel;
            value ret = that.transform(this);
            indent = origIndent;
            return ret;
        }
        case (is []) {
            return "[]";
        }
        case (null) {
            return "null";
        }
        else { // case (is [Node+]) { – but Node and [Node+] are not disjoint, because Sequence is a sealed interface, not a class
            value origIndent = indent;
            indent += indentLevel+indentLevel;
            value firstString = that.first.transform(this);
            value multiLine = that.size>1 || firstString.lines.longerThan(1);
            StringBuilder code = StringBuilder();
            code.append("[");
            if (multiLine) {
                code.appendNewline();
                code.append(indent);
            }
            code.append(firstString);
            for (node in that.rest) {
                code.append(",");
                code.appendNewline();
                code.append(indent);
                code.append(node.transform(this));
            }
            if (multiLine) {
                code.appendNewline();
                code.append(origIndent + indentLevel);
            }
            code.append("]");
            indent = origIndent;
            return code.string;
        }
    }
    
    transformAddAssignmentOperation(AddAssignmentOperation that)
            => "AddAssignmentOperation {
                `` indent + indentLevel ``target = ``transformWithIndent(that.target)``;
                `` indent + indentLevel ``summand = ``transformWithIndent(that.summand)``;
                ``indent``}";
    transformAliasDec(AliasDec that)
            => that.qualifier.children nonempty
            then "AliasDec {
                  `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                  `` indent + indentLevel ``qualifier = ``transformWithIndent(that.qualifier)``;
                  ``indent``}"
            else "AliasDec(``transformWithIndent(that.name)``)";
    transformAndAssignmentOperation(AndAssignmentOperation that)
            => "AndAssignmentOperation {
                `` indent + indentLevel ``target = ``transformWithIndent(that.target)``;
                `` indent + indentLevel ``other = ``transformWithIndent(that.other)``;
                ``indent``}";
    transformAndOperation(AndOperation that)
            => "AndOperation {
                `` indent + indentLevel ``leftOperand = ``transformWithIndent(that.leftOperand)``;
                `` indent + indentLevel ``rightOperand = ``transformWithIndent(that.rightOperand)``;
                ``indent``}";
    transformArgumentList(ArgumentList that)
            => that.sequenceArgument exists
            then "ArgumentList {
                  `` indent + indentLevel ``listedArguments = ``transformWithIndent(that.listedArguments)``;
                  `` indent + indentLevel ``sequenceArgument = ``transformWithIndent(that.sequenceArgument)``;
                  ``indent``}"
            else "ArgumentList(``transformWithIndent(that.listedArguments)``)";
    transformAnnotation(Annotation that)
            => that.arguments exists
            then "Annotation {
                  `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                  `` indent + indentLevel ``arguments = ``transformWithIndent(that.arguments)``;
                  ``indent``}"
            else "Annotation(``transformWithIndent(that.name)``)";
    transformAnnotations(Annotations that)
            => that.anonymousAnnotation exists
            then (that.annotations nonempty
                then "Annotations {
                      `` indent + indentLevel ``anonymousAnnotation = ``transformWithIndent(that.anonymousAnnotation)``;
                      `` indent + indentLevel ``annotations = ``transformWithIndent(that.annotations)``;
                      ``indent``}"
                else "Annotations(``transformWithIndent(that.anonymousAnnotation)``)")
            else (that.annotations nonempty
                then "Annotations {
                      `` indent + indentLevel ``annotations = ``transformWithIndent(that.annotations)``;
                      ``indent``}"
                else "Annotations()");
    transformAnonymousArgument(AnonymousArgument that) => "AnonymousArgument(``transformWithIndent(that.expression)``)";
    transformAssertion(Assertion that)
            => "Assertion {
                `` indent + indentLevel ``conditions = ``transformWithIndent(that.conditions)``;
                `` indent + indentLevel ``annotations = ``transformWithIndent(that.annotations)``;
                ``indent``}";
    transformAssignOperation(AssignOperation that)
            => "AssignOperation {
                `` indent + indentLevel ``target = ``transformWithIndent(that.target)``;
                `` indent + indentLevel ``expression = ``transformWithIndent(that.expression)``;
                ``indent``}";
    transformAssignmentStatement(AssignmentStatement that) => "AssignmentStatement(``transformWithIndent(that.expression)``)";
    transformBaseExpression(BaseExpression that) => "BaseExpression(``transformWithIndent(that.nameAndArgs)``)";
    transformBaseMeta(BaseMeta that)
            => that.packageQualifier exists
            then "BaseMeta(``transformWithIndent(that.nameAndArgs)``, ``transformWithIndent(that.packageQualifier)``)"
            else "BaseMeta(``transformWithIndent(that.nameAndArgs)``)";
    transformBaseType(BaseType that)
            => that.qualifier exists
            then "BaseType(``transformWithIndent(that.nameAndArgs)``, ``transformWithIndent(that.qualifier)``)"
            else "BaseType(``transformWithIndent(that.nameAndArgs)``)";
    transformBlock(Block that) => "Block(``transformWithIndent(that.content)``)";
    transformBooleanCondition(BooleanCondition that) => "BooleanCondition(``transformWithIndent(that.condition)``)";
    transformBreak(Break that) => "Break()";
    transformCallableConstructorDefinition(CallableConstructorDefinition that)
            => "CallableConstructorDefinition {
                `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                `` indent + indentLevel ``parameters = ``transformWithIndent(that.parameters)``;
                `` indent + indentLevel ``block = ``transformWithIndent(that.block)``;
                `` indent + indentLevel ``extendedType = ``transformWithIndent(that.extendedType)``;
                `` indent + indentLevel ``annotations = ``transformWithIndent(that.annotations)``;
                ``indent``}";
    transformCallableParameter(CallableParameter that)
            => "CallableParameter {
                `` indent + indentLevel ``annotations = ``transformWithIndent(that.annotations)``;
                `` indent + indentLevel ``type = ``transformWithIndent(that.type)``;
                `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                `` indent + indentLevel ``parameterLists = ``transformWithIndent(that.parameterLists)``;
                ``indent``}";
    transformCallableType(CallableType that)
            => "CallableType {
                `` indent + indentLevel ``returnType = ``transformWithIndent(that.returnType)``;
                `` indent + indentLevel ``argumentTypes = ``transformWithIndent(that.argumentTypes)``;
                ``indent``}";
    transformCaseClause(CaseClause that)
            => "CaseClause {
                `` indent + indentLevel ``caseItem = ``transformWithIndent(that.caseItem)``;
                `` indent + indentLevel ``block = ``transformWithIndent(that.block)``;
                ``indent``}";
    transformCaseExpression(CaseExpression that)
            => "CaseExpression {
                `` indent + indentLevel ``caseItem = ``transformWithIndent(that.caseItem)``;
                `` indent + indentLevel ``expression = ``transformWithIndent(that.expression)``;
                ``indent``}";
    transformCaseTypes(CaseTypes that) => "CaseTypes(``transformWithIndent(that.caseTypes)``)";
    transformCatchClause(CatchClause that)
            => "CatchClause {
                `` indent + indentLevel ``variable = ``transformWithIndent(that.variable)``;
                `` indent + indentLevel ``block = ``transformWithIndent(that.block)``;
                ``indent``}";
    transformCharacterLiteral(CharacterLiteral that) => "CharacterLiteral(\"\"\"``that.text``\"\"\")";
    transformClassAliasDefinition(ClassAliasDefinition that)
            => "ClassAliasDefinition {
                `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                `` indent + indentLevel ``parameters = ``transformWithIndent(that.parameters)``;
                `` indent + indentLevel ``specifier = ``transformWithIndent(that.specifier)``;
                `` indent + indentLevel ``caseTypes = ``transformWithIndent(that.caseTypes)``;
                `` indent + indentLevel ``extendedType = ``transformWithIndent(that.extendedType)``;
                `` indent + indentLevel ``satisfiedTypes = ``transformWithIndent(that.satisfiedTypes)``;
                `` indent + indentLevel ``typeParameters = ``transformWithIndent(that.typeParameters)``;
                `` indent + indentLevel ``typeConstraints = ``transformWithIndent(that.typeConstraints)``;
                `` indent + indentLevel ``annotations = ``transformWithIndent(that.annotations)``;
                ``indent``}";
    transformClassBody(ClassBody that) => "ClassBody(``transformWithIndent(that.content)``)";
    transformClassDec(ClassDec that)
            => that.qualifier?.children nonempty
            then "ClassDec {
                  `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                  `` indent + indentLevel ``qualifier = ``transformWithIndent(that.qualifier)``;
                  ``indent``}"
            else "ClassDec(``transformWithIndent(that.name)``)";
    transformClassDefinition(ClassDefinition that)
            => "ClassDefinition {
                `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                `` indent + indentLevel ``parameters = ``transformWithIndent(that.parameters)``;
                `` indent + indentLevel ``body = ``transformWithIndent(that.body)``;
                `` indent + indentLevel ``caseTypes = ``transformWithIndent(that.caseTypes)``;
                `` indent + indentLevel ``extendedType = ``transformWithIndent(that.extendedType)``;
                `` indent + indentLevel ``satisfiedTypes = ``transformWithIndent(that.satisfiedTypes)``;
                `` indent + indentLevel ``typeParameters = ``transformWithIndent(that.typeParameters)``;
                `` indent + indentLevel ``typeConstraints = ``transformWithIndent(that.typeConstraints)``;
                `` indent + indentLevel ``annotations = ``transformWithIndent(that.annotations)``;
                ``indent``}";
    transformClassSpecifier(ClassSpecifier that) => "ClassSpecifier(``transformWithIndent(that.target)``)";
    transformClosedBound(ClosedBound that) => "ClosedBound(``transformWithIndent(that.endpoint)``)";
    transformCompareOperation(CompareOperation that)
            => "CompareOperation {
                `` indent + indentLevel ``leftOperand = ``transformWithIndent(that.leftOperand)``;
                `` indent + indentLevel ``rightOperand = ``transformWithIndent(that.rightOperand)``;
                ``indent``}";
    transformCompilationUnit(CompilationUnit that)
            => "CompilationUnit {
                `` indent + indentLevel ``imports = ``transformWithIndent(that.imports)``;
                `` indent + indentLevel ``declarations = ``transformWithIndent(that.declarations)``;
                ``indent``}";
    transformComplementAssignmentOperation(ComplementAssignmentOperation that)
            => "ComplementAssignmentOperation {
                `` indent + indentLevel ``target = ``transformWithIndent(that.target)``;
                `` indent + indentLevel ``other = ``transformWithIndent(that.other)``;
                ``indent``}";
    transformComplementOperation(ComplementOperation that)
            => "ComplementOperation {
                `` indent + indentLevel ``leftOperand = ``transformWithIndent(that.leftOperand)``;
                `` indent + indentLevel ``rightOperand = ``transformWithIndent(that.rightOperand)``;
                ``indent``}";
    transformComprehension(Comprehension that) => "Comprehension(``transformWithIndent(that.clause)``)";
    transformConditions(Conditions that) => "Conditions(``transformWithIndent(that.conditions)``)";
    transformConstruction(Construction that)
            => that.qualifier exists
            then "Construction {
                  `` indent + indentLevel ``nameAndArgs = ``transformWithIndent(that.nameAndArgs)``;
                  `` indent + indentLevel ``arguments = ``transformWithIndent(that.arguments)``;
                  `` indent + indentLevel ``qualifier = ``transformWithIndent(that.qualifier)``;
                  ``indent``}"
            else "Construction {
                  `` indent + indentLevel ``nameAndArgs = ``transformWithIndent(that.nameAndArgs)``;
                  `` indent + indentLevel ``arguments = ``transformWithIndent(that.arguments)``;
                  ``indent``}";
    transformConstructorDec(ConstructorDec that)
            => "ConstructorDec {
                `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                `` indent + indentLevel ``qualifier = ``transformWithIndent(that.qualifier)``;
                ``indent``}";
    transformContinue(Continue that) => "Continue()";
    transformDecQualifier(DecQualifier that)
            => that.packageQualifier exists
            then "DecQualifier(``transformWithIndent(that.components)``, ``transformWithIndent(that.packageQualifier)``)"
            else "DecQualifier(``transformWithIndent(that.components)``)";
    transformDefaultedCallableParameter(DefaultedCallableParameter that)
            => "DefaultedCallableParameter {
                `` indent + indentLevel ``parameter = ``transformWithIndent(that.parameter)``;
                `` indent + indentLevel ``specifier = ``transformWithIndent(that.specifier)``;
                ``indent``}";
    transformDefaultedParameterReference(DefaultedParameterReference that)
            => "DefaultedParameterReference {
                `` indent + indentLevel ``parameter = ``transformWithIndent(that.parameter)``;
                `` indent + indentLevel ``specifier = ``transformWithIndent(that.specifier)``;
                ``indent``}";
    transformDefaultedType(DefaultedType that) => "DefaultedType(``transformWithIndent(that.type)``)";
    transformDefaultedValueParameter(DefaultedValueParameter that)
            => "DefaultedValueParameter {
                `` indent + indentLevel ``parameter = ``transformWithIndent(that.parameter)``;
                `` indent + indentLevel ``specifier = ``transformWithIndent(that.specifier)``;
                ``indent``}";
    transformDestructure(Destructure that)
            => "Destructure {
                `` indent + indentLevel ``pattern = ``transformWithIndent(that.pattern)``;
                `` indent + indentLevel ``specifier = ``transformWithIndent(that.specifier)``;
                ``indent``}";
    transformDifferenceOperation(DifferenceOperation that)
            => "DifferenceOperation {
                `` indent + indentLevel ``minuend = ``transformWithIndent(that.minuend)``;
                `` indent + indentLevel ``subtrahend = ``transformWithIndent(that.subtrahend)``;
                ``indent``}";
    transformDivideAssignmentOperation(DivideAssignmentOperation that)
            => "DivideAssignmentOperation {
                `` indent + indentLevel ``target = ``transformWithIndent(that.target)``;
                `` indent + indentLevel ``divisor = ``transformWithIndent(that.divisor)``;
                ``indent``}";
    transformDynamicBlock(DynamicBlock that) => "DynamicBlock(``transformWithIndent(that.block)``)";
    transformDynamicInterfaceDefinition(DynamicInterfaceDefinition that)
            => "DynamicInterfaceDefinition {
                `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                `` indent + indentLevel ``body = ``transformWithIndent(that.body)``;
                `` indent + indentLevel ``caseTypes = ``transformWithIndent(that.caseTypes)``;
                `` indent + indentLevel ``satisfiedTypes = ``transformWithIndent(that.satisfiedTypes)``;
                `` indent + indentLevel ``typeParameters = ``transformWithIndent(that.typeParameters)``;
                `` indent + indentLevel ``typeConstraints = ``transformWithIndent(that.typeConstraints)``;
                `` indent + indentLevel ``annotations = ``transformWithIndent(that.annotations)``;
                ``indent``}";
    transformDynamicModifier(DynamicModifier that) => "DynamicModifier()";
    transformDynamicValue(DynamicValue that)
            => "DynamicValue {
                `` indent + indentLevel ``namedArguments = ``transformWithIndent(that.namedArguments)``;
                `` indent + indentLevel ``iterableArgument = ``transformWithIndent(that.iterableArgument)``;
                `` indent + indentLevel ``modifier = ``transformWithIndent(that.modifier)``;
                ``indent``}";
    transformElementOrSubrangeExpression(ElementOrSubrangeExpression that)
            => "ElementOrSubrangeExpression {
                `` indent + indentLevel ``primary = ``transformWithIndent(that.primary)``;
                `` indent + indentLevel ``subscript = ``transformWithIndent(that.subscript)``;
                ``indent``}";
    transformElseClause(ElseClause that) => "ElseClause(``transformWithIndent(that.child)``)";
    transformElseOperation(ElseOperation that)
            => "ElseOperation {
                `` indent + indentLevel ``optionalValue = ``transformWithIndent(that.leftOperand)``;
                `` indent + indentLevel ``defaultValue = ``transformWithIndent(that.rightOperand)``;
                ``indent``}";
    transformEntryOperation(EntryOperation that)
            => "EntryOperation {
                `` indent + indentLevel ``key = ``transformWithIndent(that.key)``;
                `` indent + indentLevel ``item = ``transformWithIndent(that.item)``;
                ``indent``}";
    transformEntryPattern(EntryPattern that)
            => "EntryPattern {
                `` indent + indentLevel ``key = ``transformWithIndent(that.key)``;
                `` indent + indentLevel ``item = ``transformWithIndent(that.item)``;
                ``indent``}";
    transformEntryType(EntryType that)
            => "EntryType {
                `` indent + indentLevel ``key = ``transformWithIndent(that.key)``;
                `` indent + indentLevel ``item = ``transformWithIndent(that.item)``;
                ``indent``}";
    transformEqualOperation(EqualOperation that)
            => "EqualOperation {
                `` indent + indentLevel ``leftOperand = ``transformWithIndent(that.leftOperand)``;
                `` indent + indentLevel ``rightOperand = ``transformWithIndent(that.rightOperand)``;
                ``indent``}";
    transformExistsCondition(ExistsCondition that)
            => that.negated
            then "ExistsCondition {
                  `` indent + indentLevel ``tested = ``transformWithIndent(that.tested)``;
                  `` indent + indentLevel ``negated = ``that.negated``;
                  ``indent``}"
            else "ExistsCondition(``transformWithIndent(that.tested)``)";
    transformExistsOperation(ExistsOperation that) => "ExistsOperation(``transformWithIndent(that.operand)``)";
    transformExponentiationOperation(ExponentiationOperation that)
            => "ExponentiationOperation {
                `` indent + indentLevel ``base = ``transformWithIndent(that.base)``;
                `` indent + indentLevel ``exponent = ``transformWithIndent(that.exponent)``;
                ``indent``}";
    transformExpressionComprehensionClause(ExpressionComprehensionClause that) => "ExpressionComprehensionClause(``transformWithIndent(that.expression)``)";
    transformExtendedType(ExtendedType that) => "ExtendedType(``transformWithIndent(that.target)``)";
    transformExtension(Extension that)
            => that.qualifier exists
            then "Extension {
                  `` indent + indentLevel ``nameAndArgs = ``transformWithIndent(that.nameAndArgs)``;
                  `` indent + indentLevel ``arguments = ``transformWithIndent(that.arguments)``;
                  `` indent + indentLevel ``qualifier = ``transformWithIndent(that.qualifier)``;
                  ``indent``}"
            else "Extension {
                  `` indent + indentLevel ``nameAndArgs = ``transformWithIndent(that.nameAndArgs)``;
                  `` indent + indentLevel ``arguments = ``transformWithIndent(that.arguments)``;
                  ``indent``}";
    transformFailClause(FailClause that) => "FailClause(``transformWithIndent(that.block)``)";
    transformFinallyClause(FinallyClause that) => "FinallyClause(``transformWithIndent(that.block)``)";
    transformFloatLiteral(FloatLiteral that) => "FloatLiteral(\"``that.text``\")";
    transformForClause(ForClause that)
            => "ForClause {
                `` indent + indentLevel ``iterator = ``transformWithIndent(that.iterator)``;
                `` indent + indentLevel ``block = ``transformWithIndent(that.block)``;
                ``indent``}";
    transformForComprehensionClause(ForComprehensionClause that)
            => "ForComprehensionClause {
                `` indent + indentLevel ``iterator = ``transformWithIndent(that.iterator)``;
                `` indent + indentLevel ``clause = ``transformWithIndent(that.clause)``;
                ``indent``}";
    transformForFail(ForFail that)
            => "ForFail {
                `` indent + indentLevel ``forClause = ``transformWithIndent(that.forClause)``;
                `` indent + indentLevel ``failClause = ``transformWithIndent(that.failClause)``;
                ``indent``}";
    transformForIterator(ForIterator that)
            => "ForIterator {
                `` indent + indentLevel ``pattern = ``transformWithIndent(that.pattern)``;
                `` indent + indentLevel ``iterated = ``transformWithIndent(that.iterated)``;
                ``indent``}";
    transformFullPackageName(FullPackageName that) => "FullPackageName(``transformWithIndent(that.components)``)";
    transformFunctionArgument(FunctionArgument that)
            => "FunctionArgument {
                `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                `` indent + indentLevel ``type = ``transformWithIndent(that.type)``;
                `` indent + indentLevel ``parameterLists = ``transformWithIndent(that.parameterLists)``;
                `` indent + indentLevel ``definition = ``transformWithIndent(that.definition)``;
                ``indent``}";
    transformFunctionDec(FunctionDec that)
            => that.qualifier.children nonempty
            then "FunctionDec {
                  `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                  `` indent + indentLevel ``qualifier = ``transformWithIndent(that.qualifier)``;
                  ``indent``}"
            else "FunctionDec(``transformWithIndent(that.name)``)";
    transformFunctionDeclaration(FunctionDeclaration that)
            => "FunctionDeclaration {
                `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                `` indent + indentLevel ``type = ``transformWithIndent(that.type)``;
                `` indent + indentLevel ``parameterLists = ``transformWithIndent(that.parameterLists)``;
                `` indent + indentLevel ``typeParameters = ``transformWithIndent(that.typeParameters)``;
                `` indent + indentLevel ``typeConstraints = ``transformWithIndent(that.typeConstraints)``;
                `` indent + indentLevel ``annotations = ``transformWithIndent(that.annotations)``;
                ``indent``}";
    transformFunctionDefinition(FunctionDefinition that)
            => "FunctionDefinition {
                `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                `` indent + indentLevel ``type = ``transformWithIndent(that.type)``;
                `` indent + indentLevel ``parameterLists = ``transformWithIndent(that.parameterLists)``;
                `` indent + indentLevel ``definition = ``transformWithIndent(that.definition)``;
                `` indent + indentLevel ``typeParameters = ``transformWithIndent(that.typeParameters)``;
                `` indent + indentLevel ``typeConstraints = ``transformWithIndent(that.typeConstraints)``;
                `` indent + indentLevel ``annotations = ``transformWithIndent(that.annotations)``;
                ``indent``}";
    transformFunctionExpression(FunctionExpression that)
            => "FunctionExpression {
                `` indent + indentLevel ``parameterLists = ``transformWithIndent(that.parameterLists)``;
                `` indent + indentLevel ``definition = ``transformWithIndent(that.definition)``;
                `` indent + indentLevel ``type = ``transformWithIndent(that.type)``;
                ``indent``}";
    transformFunctionModifier(FunctionModifier that) => "FunctionModifier()";
    transformFunctionShortcutDefinition(FunctionShortcutDefinition that)
            => "FunctionShortcutDefinition {
                `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                `` indent + indentLevel ``type = ``transformWithIndent(that.type)``;
                `` indent + indentLevel ``parameterLists = ``transformWithIndent(that.parameterLists)``;
                `` indent + indentLevel ``definition = ``transformWithIndent(that.definition)``;
                `` indent + indentLevel ``typeParameters = ``transformWithIndent(that.typeParameters)``;
                `` indent + indentLevel ``typeConstraints = ``transformWithIndent(that.typeConstraints)``;
                `` indent + indentLevel ``annotations = ``transformWithIndent(that.annotations)``;
                ``indent``}";
    transformGivenDec(GivenDec that)
            => that.qualifier.children nonempty
            then "GivenDec {
                  `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                  `` indent + indentLevel ``qualifier = ``transformWithIndent(that.qualifier)``;
                  ``indent``}"
            else "GivenDec(``transformWithIndent(that.name)``)";
    transformGroupedExpression(GroupedExpression that) => "GroupedExpression(``transformWithIndent(that.innerExpression)``)";
    transformGroupedType(GroupedType that) => "GroupedType(``transformWithIndent(that.type)``)";
    transformIdenticalOperation(IdenticalOperation that)
            => "IdenticalOperation {
                `` indent + indentLevel ``leftOperand = ``transformWithIndent(that.leftOperand)``;
                `` indent + indentLevel ``rightOperand = ``transformWithIndent(that.rightOperand)``;
                ``indent``}";
    transformIdentityOperation(IdentityOperation that) => "IdentityOperation(``transformWithIndent(that.operand)``)";
    transformIfClause(IfClause that)
            => "IfClause {
                `` indent + indentLevel ``conditions = ``transformWithIndent(that.conditions)``;
                `` indent + indentLevel ``block = ``transformWithIndent(that.block)``;
                ``indent``}";
    transformIfComprehensionClause(IfComprehensionClause that)
            => "IfComprehensionClause {
                `` indent + indentLevel ``conditions = ``transformWithIndent(that.conditions)``;
                `` indent + indentLevel ``clause = ``transformWithIndent(that.clause)``;
                ``indent``}";
    transformIfElse(IfElse that)
            => "IfElse {
                `` indent + indentLevel ``ifClause = ``transformWithIndent(that.ifClause)``;
                `` indent + indentLevel ``elseClause = ``transformWithIndent(that.elseClause)``;
                ``indent``}";
    transformIfElseExpression(IfElseExpression that)
            => "IfElseExpression {
                `` indent + indentLevel ``conditions = ``transformWithIndent(that.conditions)``;
                `` indent + indentLevel ``thenExpression = ``transformWithIndent(that.thenExpression)``;
                `` indent + indentLevel ``elseExpression = ``transformWithIndent(that.elseExpression)``;
                ``indent``}";
    transformImport(Import that)
            => "Import {
                `` indent + indentLevel ``packageName = ``transformWithIndent(that.packageName)``;
                `` indent + indentLevel ``elements = ``transformWithIndent(that.elements)``;
                ``indent``}";
    transformImportElements(ImportElements that)
            => "ImportElements {
                `` indent + indentLevel ``elements = ``transformWithIndent(that.elements)``;
                `` indent + indentLevel ``wildcard = ``transformWithIndent(that.wildcard)``;
                ``indent``}";
    transformImportFunctionValueAlias(ImportFunctionValueAlias that) => "ImportFunctionValueAlias(``transformWithIndent(that.name)``)";
    transformImportFunctionValueElement(ImportFunctionValueElement that)
            => "ImportFunctionValueElement {
                `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                `` indent + indentLevel ``importAlias = ``transformWithIndent(that.importAlias)``;
                `` indent + indentLevel ``nestedImports = ``transformWithIndent(that.nestedImports)``;
                ``indent``}";
    transformImportTypeAlias(ImportTypeAlias that) => "ImportTypeAlias(``transformWithIndent(that.name)``)";
    transformImportTypeElement(ImportTypeElement that)
            => "ImportTypeElement {
                `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                `` indent + indentLevel ``importAlias = ``transformWithIndent(that.importAlias)``;
                `` indent + indentLevel ``nestedImports = ``transformWithIndent(that.nestedImports)``;
                ``indent``}";
    transformImportWildcard(ImportWildcard that) => "ImportWildcard()";
    transformInModifier(InModifier that) => "InModifier()";
    transformInOperation(InOperation that)
            => "InOperation {
                `` indent + indentLevel ``element = ``transformWithIndent(that.element)``;
                `` indent + indentLevel ``category = ``transformWithIndent(that.category)``;
                ``indent``}";
    transformIntegerLiteral(IntegerLiteral that) => "IntegerLiteral(\"``that.text``\")";
    transformInterfaceAliasDefinition(InterfaceAliasDefinition that)
            => "InterfaceAliasDefinition {
                `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                `` indent + indentLevel ``specifier = ``transformWithIndent(that.specifier)``;
                `` indent + indentLevel ``caseTypes = ``transformWithIndent(that.caseTypes)``;
                `` indent + indentLevel ``satisfiedTypes = ``transformWithIndent(that.satisfiedTypes)``;
                `` indent + indentLevel ``typeParameters = ``transformWithIndent(that.typeParameters)``;
                `` indent + indentLevel ``typeConstraints = ``transformWithIndent(that.typeConstraints)``;
                `` indent + indentLevel ``annotations = ``transformWithIndent(that.annotations)``;
                ``indent``}";
    transformInterfaceBody(InterfaceBody that) => "InterfaceBody(``transformWithIndent(that.content)``)";
    transformInterfaceDec(InterfaceDec that)
            => that.qualifier?.children nonempty
            then "InterfaceDec {
                  `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                  `` indent + indentLevel ``qualifier = ``transformWithIndent(that.qualifier)``;
                  ``indent``}"
            else "InterfaceDec(``transformWithIndent(that.name)``)";
    transformInterfaceDefinition(InterfaceDefinition that)
            => "InterfaceDefinition {
                `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                `` indent + indentLevel ``body = ``transformWithIndent(that.body)``;
                `` indent + indentLevel ``caseTypes = ``transformWithIndent(that.caseTypes)``;
                `` indent + indentLevel ``satisfiedTypes = ``transformWithIndent(that.satisfiedTypes)``;
                `` indent + indentLevel ``typeParameters = ``transformWithIndent(that.typeParameters)``;
                `` indent + indentLevel ``typeConstraints = ``transformWithIndent(that.typeConstraints)``;
                `` indent + indentLevel ``annotations = ``transformWithIndent(that.annotations)``;
                ``indent``}";
    transformIntersectionType(IntersectionType that) => "IntersectionType(``transformWithIndent(that.children)``)";
    transformIntersectAssignmentOperation(IntersectAssignmentOperation that)
            => "IntersectAssignmentOperation {
                `` indent + indentLevel ``target = ``transformWithIndent(that.target)``;
                `` indent + indentLevel ``other = ``transformWithIndent(that.other)``;
                ``indent``}";
    transformIntersectionOperation(IntersectionOperation that)
            => "IntersectionOperation {
                `` indent + indentLevel ``leftOperand = ``transformWithIndent(that.leftOperand)``;
                `` indent + indentLevel ``rightOperand = ``transformWithIndent(that.rightOperand)``;
                ``indent``}";
    transformInvocation(Invocation that)
            => "Invocation {
                `` indent + indentLevel ``invoked = ``transformWithIndent(that.invoked)``;
                `` indent + indentLevel ``arguments = ``transformWithIndent(that.arguments)``;
                ``indent``}";
    transformInvocationStatement(InvocationStatement that) => "InvocationStatement(``transformWithIndent(that.expression)``)";
    transformIsCase(IsCase that) => "IsCase(``transformWithIndent(that.type)``)";
    transformIsCondition(IsCondition that)
            => that.negated
            then "IsCondition {
                  `` indent + indentLevel ``variable = ``transformWithIndent(that.variable)``;
                  `` indent + indentLevel ``negated = ``that.negated``;
                  ``indent``}"
            else "IsCondition(``transformWithIndent(that.variable)``)";
    transformIsOperation(IsOperation that)
            => "IsOperation {
                `` indent + indentLevel ``operand = ``transformWithIndent(that.operand)``;
                `` indent + indentLevel ``type = ``transformWithIndent(that.type)``;
                ``indent``}";
    transformIterable(Iterable that) => "Iterable(``transformWithIndent(that.argumentList)``)";
    transformIterableType(IterableType that) => "IterableType(``transformWithIndent(that.variadicType)``)";
    transformKeySubscript(KeySubscript that) => "KeySubscript(``transformWithIndent(that.key)``)";
    transformLIdentifier(LIdentifier that)
            => that.usePrefix
            then "LIdentifier(\"``that.name``\", true)"
            else "LIdentifier(\"``that.name``\")";
    transformLazySpecification(LazySpecification that)
            =>
            !that.parameterLists nonempty && !that.qualifier exists
            then "LazySpecification {
                  `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                  `` indent + indentLevel ``specifier = ``transformWithIndent(that.specifier)``;
                  ``indent``}"
            else "LazySpecification {
                  `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                  `` indent + indentLevel ``specifier = ``transformWithIndent(that.specifier)``;
                  `` indent + indentLevel ``parameterLists = ``transformWithIndent(that.parameterLists)``;
                  `` indent + indentLevel ``qualifier = ``transformWithIndent(that.qualifier)``;
                  ``indent``}";
    transformLetExpression(LetExpression that)
            => "LetExpression {
                `` indent + indentLevel ``patterns = ``transformWithIndent(that.patterns)``;
                `` indent + indentLevel ``expression = ``transformWithIndent(that.expression)``;
                ``indent``}";
    transformMatchCase(MatchCase that) => "MatchCase(``transformWithIndent(that.expressions)``)";
    transformMeasureSubscript(MeasureSubscript that)
            => "MeasureSubscript {
                `` indent + indentLevel ``from = ``transformWithIndent(that.from)``;
                `` indent + indentLevel ``length = ``transformWithIndent(that.length)``;
                ``indent``}";
    transformMemberNameWithTypeArguments(MemberNameWithTypeArguments that)
            => that.typeArguments exists
            then "MemberNameWithTypeArguments {
                  `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                  `` indent + indentLevel ``typeArguments = ``transformWithIndent(that.typeArguments)``;
                  ``indent``}"
            else "MemberNameWithTypeArguments(``transformWithIndent(that.name)``)";
    transformLargeAsOperation(LargeAsOperation that)
            => "LargeAsOperation {
                `` indent + indentLevel ``leftOperand = ``transformWithIndent(that.leftOperand)``;
                `` indent + indentLevel ``rightOperand = ``transformWithIndent(that.rightOperand)``;
                ``indent``}";
    transformLargerOperation(LargerOperation that)
            => "LargerOperation {
                `` indent + indentLevel ``leftOperand = ``transformWithIndent(that.leftOperand)``;
                `` indent + indentLevel ``rightOperand = ``transformWithIndent(that.rightOperand)``;
                ``indent``}";
    transformLazySpecifier(LazySpecifier that) => "LazySpecifier(``transformWithIndent(that.expression)``)";
    transformMeasureOperation(MeasureOperation that)
            => "MeasureOperation {
                `` indent + indentLevel ``first = ``transformWithIndent(that.first)``;
                `` indent + indentLevel ``size = ``transformWithIndent(that.size)``;
                ``indent``}";
    transformMemberMeta(MemberMeta that)
            => "MemberMeta {
                `` indent + indentLevel ``qualifier = ``transformWithIndent(that.qualifier)``;
                `` indent + indentLevel ``nameAndArgs = ``transformWithIndent(that.nameAndArgs)``;
                ``indent``}";
    transformMemberOperator(MemberOperator that) => "MemberOperator()";
    transformModuleBody(ModuleBody that) => "ModuleBody(``transformWithIndent(that.moduleImports)``)";
    transformModuleCompilationUnit(ModuleCompilationUnit that)
            => "ModuleCompilationUnit {
                `` indent + indentLevel ``moduleDescriptor = ``transformWithIndent(that.moduleDescriptor)``;
                `` indent + indentLevel ``imports = ``transformWithIndent(that.imports)``;
                ``indent``}";
    transformModuleDec(ModuleDec that) => "ModuleDec(``transformWithIndent(that.moduleName)``)";
    transformModuleDescriptor(ModuleDescriptor that)
            => "ModuleDescriptor {
                `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                `` indent + indentLevel ``version = ``transformWithIndent(that.version)``;
                `` indent + indentLevel ``body = ``transformWithIndent(that.body)``;
                `` indent + indentLevel ``annotations = ``transformWithIndent(that.annotations)``;
                ``indent``}";
    transformModuleImport(ModuleImport that)
            => "ModuleImport {
                `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                `` indent + indentLevel ``version = ``transformWithIndent(that.version)``;
                `` indent + indentLevel ``annotations = ``transformWithIndent(that.annotations)``;
                ``indent``}";
    transformMultiplyAssignmentOperation(MultiplyAssignmentOperation that)
            => "MultiplyAssignmentOperation {
                `` indent + indentLevel ``target = ``transformWithIndent(that.target)``;
                `` indent + indentLevel ``factor = ``transformWithIndent(that.factor)``;
                ``indent``}";
    transformNamedArguments(NamedArguments that)
            => that.iterableArgument.children nonempty
            then "NamedArguments {
                  `` indent + indentLevel ``namedArguments = ``transformWithIndent(that.namedArguments)``;
                  `` indent + indentLevel ``iterableArgument = ``transformWithIndent(that.iterableArgument)``;
                  ``indent``}"
            else (that.namedArguments nonempty
                then "NamedArguments(``transformWithIndent(that.namedArguments)``)"
                else "NamedArguments()");
    transformNegationOperation(NegationOperation that) => "NegationOperation(``transformWithIndent(that.operand)``)";
    transformNonemptyCondition(NonemptyCondition that)
            => that.negated
            then "NonemptyCondition {
                  `` indent + indentLevel ``tested = ``transformWithIndent(that.tested)``;
                  `` indent + indentLevel ``negated = ``that.negated``;
                  ``indent``}"
            else "NonemptyCondition(``transformWithIndent(that.tested)``)";
    transformNonemptyOperation(NonemptyOperation that) => "NonemptyOperation(``transformWithIndent(that.operand)``)";
    transformNotEqualOperation(NotEqualOperation that)
            => "NotEqualOperation {
                `` indent + indentLevel ``leftOperand = ``transformWithIndent(that.leftOperand)``;
                `` indent + indentLevel ``rightOperand = ``transformWithIndent(that.rightOperand)``;
                ``indent``}";
    transformNotOperation(NotOperation that) => "NotOperation(``transformWithIndent(that.operand)``)";
    transformObjectArgument(ObjectArgument that)
            => "ObjectArgument {
                `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                `` indent + indentLevel ``body = ``transformWithIndent(that.body)``;
                `` indent + indentLevel ``extendedType = ``transformWithIndent(that.extendedType)``;
                `` indent + indentLevel ``satisfiedTypes = ``transformWithIndent(that.satisfiedTypes)``;
                ``indent``}";
    transformObjectDefinition(ObjectDefinition that)
            => "ObjectDefinition {
                `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                `` indent + indentLevel ``body = ``transformWithIndent(that.body)``;
                `` indent + indentLevel ``extendedType = ``transformWithIndent(that.extendedType)``;
                `` indent + indentLevel ``satisfiedTypes = ``transformWithIndent(that.satisfiedTypes)``;
                `` indent + indentLevel ``annotations = ``transformWithIndent(that.annotations)``;
                ``indent``}";
    transformObjectExpression(ObjectExpression that)
            => "ObjectExpression {
                `` indent + indentLevel ``body = ``transformWithIndent(that.body)``;
                `` indent + indentLevel ``extendedType = ``transformWithIndent(that.extendedType)``;
                `` indent + indentLevel ``satisfiedTypes = ``transformWithIndent(that.satisfiedTypes)``;
                ``indent``}";
    transformOfOperation(OfOperation that)
            => "OfOperation {
                `` indent + indentLevel ``operand = ``transformWithIndent(that.operand)``;
                `` indent + indentLevel ``type = ``transformWithIndent(that.type)``;
                ``indent``}";
    transformOpenBound(OpenBound that) => "OpenBound(``transformWithIndent(that.endpoint)``)";
    transformOptionalType(OptionalType that) => "OptionalType(``transformWithIndent(that.definiteType)``)";
    transformOrAssignmentOperation(OrAssignmentOperation that)
            => "OrAssignmentOperation {
                `` indent + indentLevel ``target = ``transformWithIndent(that.target)``;
                `` indent + indentLevel ``other = ``transformWithIndent(that.other)``;
                ``indent``}";
    transformOrOperation(OrOperation that)
            => "OrOperation {
                `` indent + indentLevel ``leftOperand = ``transformWithIndent(that.leftOperand)``;
                `` indent + indentLevel ``rightOperand = ``transformWithIndent(that.rightOperand)``;
                ``indent``}";
    transformOutModifier(OutModifier that) => "OutModifier()";
    transformOuter(Outer that) => "Outer()";
    transformPackage(Package that) => "Package()";
    transformPackageCompilationUnit(PackageCompilationUnit that)
            => "PackageCompilationUnit {
                `` indent + indentLevel ``packageDescriptor = ``transformWithIndent(that.packageDescriptor)``;
                `` indent + indentLevel ``imports = ``transformWithIndent(that.imports)``;
                ``indent``}";
    transformPackageDec(PackageDec that) => "PackageDec(``transformWithIndent(that.packageName)``)";
    transformPackageDescriptor(PackageDescriptor that)
            => "PackageDescriptor {
                `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                `` indent + indentLevel ``annotations = ``transformWithIndent(that.annotations)``;
                ``indent``}";
    transformPackageQualifier(PackageQualifier that) => "PackageQualifier()";
    transformParameterReference(ParameterReference that) => "ParameterReference(``transformWithIndent(that.name)``)";
    transformParameters(Parameters that)
            => that.parameters nonempty
            then "Parameters(``transformWithIndent(that.parameters)``)"
            else "Parameters()";
    transformPatternList(PatternList that) => "PatternList(``transformWithIndent(that.patterns)``)";
    transformPositionalArguments(PositionalArguments that) => "PositionalArguments(``transformWithIndent(that.argumentList)``)";
    transformPostfixDecrementOperation(PostfixDecrementOperation that) => "PostfixDecrementOperation(``transformWithIndent(that.operand)``)";
    transformPostfixIncrementOperation(PostfixIncrementOperation that) => "PostfixIncrementOperation(``transformWithIndent(that.operand)``)";
    transformPrefixDecrementOperation(PrefixDecrementOperation that) => "PrefixDecrementOperation(``transformWithIndent(that.operand)``)";
    transformPrefixIncrementOperation(PrefixIncrementOperation that) => "PrefixIncrementOperation(``transformWithIndent(that.operand)``)";
    transformPrefixPostfixStatement(PrefixPostfixStatement that) => "PrefixPostfixStatement(``transformWithIndent(that.expression)``)";
    transformProductOperation(ProductOperation that)
            => "ProductOperation {
                `` indent + indentLevel ``leftFactor = ``transformWithIndent(that.leftFactor)``;
                `` indent + indentLevel ``rightFactor = ``transformWithIndent(that.rightFactor)``;
                ``indent``}";
    transformQualifiedExpression(QualifiedExpression that)
            => that.memberOperator is MemberOperator
            then "QualifiedExpression {
                  `` indent + indentLevel ``receiverExpression = ``transformWithIndent(that.receiverExpression)``;
                  `` indent + indentLevel ``nameAndArgs = ``transformWithIndent(that.nameAndArgs)``;
                  ``indent``}"
            else "QualifiedExpression {
                  `` indent + indentLevel ``receiverExpression = ``transformWithIndent(that.receiverExpression)``;
                  `` indent + indentLevel ``nameAndArgs = ``transformWithIndent(that.nameAndArgs)``;
                  `` indent + indentLevel ``memberOperator = ``transformWithIndent(that.memberOperator)``;
                  ``indent``}";
    transformQualifiedType(QualifiedType that)
            => "QualifiedType {
                `` indent + indentLevel ``qualifyingType = ``transformWithIndent(that.qualifyingType)``;
                `` indent + indentLevel ``nameAndArgs = ``transformWithIndent(that.nameAndArgs)``;
                ``indent``}";
    transformQuotientOperation(QuotientOperation that)
            => "QuotientOperation {
                `` indent + indentLevel ``dividend = ``transformWithIndent(that.dividend)``;
                `` indent + indentLevel ``divisor = ``transformWithIndent(that.divisor)``;
                ``indent``}";
    transformRemainderAssignmentOperation(RemainderAssignmentOperation that)
            => "RemainderAssignmentOperation {
                `` indent + indentLevel ``target = ``transformWithIndent(that.target)``;
                `` indent + indentLevel ``divisor = ``transformWithIndent(that.divisor)``;
                ``indent``}";
    transformRemainderOperation(RemainderOperation that)
            => "RemainderOperation {
                `` indent + indentLevel ``dividend = ``transformWithIndent(that.dividend)``;
                `` indent + indentLevel ``divisor = ``transformWithIndent(that.divisor)``;
                ``indent``}";
    transformResource(Resource that) => "Resource(``transformWithIndent(that.resource)``)";
    transformResources(Resources that) => "Resources(``transformWithIndent(that.resources)``)";
    transformReturn(Return that)
            => that.result exists
            then "Return(``transformWithIndent(that.result)``)"
            else "Return()";
    transformSafeMemberOperator(SafeMemberOperator that) => "SafeMemberOperator()";
    transformSatisfiedTypes(SatisfiedTypes that) => "SatisfiedTypes(``transformWithIndent(that.satisfiedTypes)``)";
    transformScaleOperation(ScaleOperation that)
            => "ScaleOperation {
                `` indent + indentLevel ``factor = ``transformWithIndent(that.factor)``;
                `` indent + indentLevel ``scalable = ``transformWithIndent(that.scalable)``;
                ``indent``}";
    transformSequentialType(SequentialType that)
            => that.length exists
            then "SequentialType(``transformWithIndent(that.elementType)``, ``transformWithIndent(that.length)``)"
            else "SequentialType(``transformWithIndent(that.elementType)``)";
    transformSmallAsOperation(SmallAsOperation that)
            => "SmallAsOperation {
                `` indent + indentLevel ``leftOperand = ``transformWithIndent(that.leftOperand)``;
                `` indent + indentLevel ``rightOperand = ``transformWithIndent(that.rightOperand)``;
                ``indent``}";
    transformSmallerOperation(SmallerOperation that)
            => "SmallerOperation {
                `` indent + indentLevel ``leftOperand = ``transformWithIndent(that.leftOperand)``;
                `` indent + indentLevel ``rightOperand = ``transformWithIndent(that.rightOperand)``;
                ``indent``}";
    transformSpanFromSubscript(SpanFromSubscript that) => "SpanFromSubscript(``transformWithIndent(that.from)``)";
    transformSpanOperation(SpanOperation that)
            => "SpanOperation {
                `` indent + indentLevel ``first = ``transformWithIndent(that.first)``;
                `` indent + indentLevel ``last = ``transformWithIndent(that.last)``;
                ``indent``}";
    transformSpanSubscript(SpanSubscript that)
            => "SpanSubscript {
                `` indent + indentLevel ``from = ``transformWithIndent(that.from)``;
                `` indent + indentLevel ``to = ``transformWithIndent(that.to)``;
                ``indent``}";
    transformSpanToSubscript(SpanToSubscript that) => "SpanToSubscript(``transformWithIndent(that.to)``)";
    transformSpecifiedArgument(SpecifiedArgument that) => "SpecifiedArgument(``transformWithIndent(that.specification)``)";
    transformSpecifiedPattern(SpecifiedPattern that)
            => "SpecifiedPattern {
                `` indent + indentLevel ``pattern = ``transformWithIndent(that.pattern)``;
                `` indent + indentLevel ``specifier = ``transformWithIndent(that.specifier)``;
                ``indent``}";
    transformSpecifiedVariable(SpecifiedVariable that)
            => "SpecifiedVariable {
                `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                `` indent + indentLevel ``specifier = ``transformWithIndent(that.specifier)``;
                `` indent + indentLevel ``type = ``transformWithIndent(that.type)``;
                ``indent``}";
    transformSpecifier(Specifier that) => "Specifier(``transformWithIndent(that.expression)``)";
    transformSpreadArgument(SpreadArgument that) => "SpreadArgument(``transformWithIndent(that.argument)``)";
    transformSpreadMemberOperator(SpreadMemberOperator that) => "SpreadMemberOperator()";
    transformSpreadType(SpreadType that) => "SpreadType(``transformWithIndent(that.type)``)";
    transformStringLiteral(StringLiteral that)
            => that.text.split { '\n'.equals; groupSeparators = false; discardSeparators = true; }.longerThan(1)
            then "StringLiteral(
                  `` indent + indentLevel ``\"\"\"`` that.text.split { '\n'.equals; groupSeparators = false; discardSeparators = true; }.first ````"".join(that.text.split { '\n'.equals; groupSeparators = false; discardSeparators = true; }.rest.collect(("\n" + " ".repeat(indent.size + indentLevel.size + "\"\"\"".size)).plus))``\"\"\"`` that.isVerbatim then ", true" else "" ``)"
            else "StringLiteral(\"\"\"``that.text``\"\"\"`` that.isVerbatim then ", true" else "" ``)";
    transformStringTemplate(StringTemplate that)
            => "StringTemplate {
                `` indent + indentLevel ``literals = ``transformWithIndent(that.literals)``;
                `` indent + indentLevel ``expressions = ``transformWithIndent(that.expressions)``;
                ``indent``}";
    transformSubtractAssignmentOperation(SubtractAssignmentOperation that)
            => "SubtractAssignmentOperation {
                `` indent + indentLevel ``target = ``transformWithIndent(that.target)``;
                `` indent + indentLevel ``subtrahend = ``transformWithIndent(that.subtrahend)``;
                ``indent``}";
    transformSumOperation(SumOperation that)
            => "SumOperation {
                `` indent + indentLevel ``leftSummand = ``transformWithIndent(that.leftSummand)``;
                `` indent + indentLevel ``rightSummand = ``transformWithIndent(that.rightSummand)``;
                ``indent``}";
    transformSuper(Super that) => "Super()";
    transformSwitchCaseElse(SwitchCaseElse that)
            => "SwitchCaseElse {
                `` indent + indentLevel ``clause = ``transformWithIndent(that.clause)``;
                `` indent + indentLevel ``cases = ``transformWithIndent(that.cases)``;
                ``indent``}";
    transformSwitchCaseElseExpression(SwitchCaseElseExpression that)
            => "SwitchCaseElseExpression {
                `` indent + indentLevel ``clause = ``transformWithIndent(that.clause)``;
                `` indent + indentLevel ``caseExpressions = ``transformWithIndent(that.caseExpressions)``;
                `` indent + indentLevel ``elseExpression = ``transformWithIndent(that.elseExpression)``;
                ``indent``}";
    transformSwitchCases(SwitchCases that)
            => "SwitchCases {
                `` indent + indentLevel ``caseClauses = ``transformWithIndent(that.caseClauses)``;
                `` indent + indentLevel ``elseClause = ``transformWithIndent(that.elseClause)``;
                ``indent``}";
    transformSwitchClause(SwitchClause that) => "SwitchClause(``transformWithIndent(that.switched)``)";
    transformThenOperation(ThenOperation that)
            => "ThenOperation {
                `` indent + indentLevel ``condition = ``transformWithIndent(that.leftOperand)``;
                `` indent + indentLevel ``result = ``transformWithIndent(that.rightOperand)``;
                ``indent``}";
    transformThis(This that) => "This()";
    transformThrow(Throw that)
            => that.result exists
            then "Throw(``transformWithIndent(that.result)``)"
            else "Throw()";
    transformTryCatchFinally(TryCatchFinally that)
            => "TryCatchFinally {
                `` indent + indentLevel ``tryClause = ``transformWithIndent(that.tryClause)``;
                `` indent + indentLevel ``catchClauses = ``transformWithIndent(that.catchClauses)``;
                `` indent + indentLevel ``finallyClause = ``transformWithIndent(that.finallyClause)``;
                ``indent``}";
    transformTryClause(TryClause that)
            => "TryClause {
                `` indent + indentLevel ``block = ``transformWithIndent(that.block)``;
                `` indent + indentLevel ``resources = ``transformWithIndent(that.resources)``;
                ``indent``}";
    transformTuple(Tuple that) => "Tuple(``transformWithIndent(that.argumentList)``)";
    transformTuplePattern(TuplePattern that)
            => that.variadicElementPattern exists
            then "TuplePattern {
                  `` indent + indentLevel ``elementPatterns = ``transformWithIndent(that.elementPatterns)``;
                  `` indent + indentLevel ``variadicElementPattern = ``transformWithIndent(that.variadicElementPattern)``;
                  ``indent``}"
            else "TuplePattern(``transformWithIndent(that.elementPatterns)``)";
    transformTupleType(TupleType that) => "TupleType(``transformWithIndent(that.typeList)``)";
    transformTypeAliasDefinition(TypeAliasDefinition that)
            => "TypeAliasDefinition {
                `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                `` indent + indentLevel ``specifier = ``transformWithIndent(that.specifier)``;
                `` indent + indentLevel ``typeParameters = ``transformWithIndent(that.typeParameters)``;
                `` indent + indentLevel ``typeConstraints = ``transformWithIndent(that.typeConstraints)``;
                `` indent + indentLevel ``annotations = ``transformWithIndent(that.annotations)``;
                ``indent``}";
    transformTypeArgument(TypeArgument that)
            => that.variance exists
            then "TypeArgument {
                  `` indent + indentLevel ``type = ``transformWithIndent(that.type)``;
                  `` indent + indentLevel ``variance = ``transformWithIndent(that.variance)``;
                  ``indent``}"
            else "TypeArgument(``transformWithIndent(that.type)``)";
    transformTypeArguments(TypeArguments that) => "TypeArguments(``transformWithIndent(that.typeArguments)``)";
    transformTypeConstraint(TypeConstraint that)
            => "TypeConstraint {
                `` indent + indentLevel ``parameterName = ``transformWithIndent(that.parameterName)``;
                `` indent + indentLevel ``caseTypes = ``transformWithIndent(that.caseTypes)``;
                `` indent + indentLevel ``satisfiedTypes = ``transformWithIndent(that.satisfiedTypes)``;
                ``indent``}";
    transformTypeList(TypeList that)
            => that.variadic exists
            then "TypeList {
                  `` indent + indentLevel ``elements = ``transformWithIndent(that.elements)``;
                  `` indent + indentLevel ``variadic = ``transformWithIndent(that.variadic)``;
                  ``indent``}"
            else "TypeList(``transformWithIndent(that.elements)``)";
    transformTypeNameWithTypeArguments(TypeNameWithTypeArguments that)
            => that.typeArguments exists
            then "TypeNameWithTypeArguments {
                  `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                  `` indent + indentLevel ``typeArguments = ``transformWithIndent(that.typeArguments)``;
                  }"
            else "TypeNameWithTypeArguments(``transformWithIndent(that.name)``)";
    transformTypeMeta(TypeMeta that) => "TypeMeta(``transformWithIndent(that.type)``)";
    transformTypeParameter(TypeParameter that)
            => "TypeParameter {
                `` indent + indentLevel ``parameterName = ``transformWithIndent(that.parameterName)``;
                `` indent + indentLevel ``variance = ``transformWithIndent(that.variance)``;
                `` indent + indentLevel ``defaultArgument = ``transformWithIndent(that.defaultArgument)``;
                ``indent``}";
    transformTypeParameters(TypeParameters that) => "TypeParameters(``transformWithIndent(that.typeParameters)``)";
    transformTypeSpecifier(TypeSpecifier that) => "TypeSpecifier(``transformWithIndent(that.type)``)";
    transformTypedVariable(TypedVariable that)
            => "TypedVariable {
                `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                `` indent + indentLevel ``type = ``transformWithIndent(that.type)``;
                `` indent + indentLevel ``specifier = ``transformWithIndent(that.specifier)``;
                ``indent``}";
    transformUIdentifier(UIdentifier that)
            => that.usePrefix
            then "UIdentifier(\"``that.name``\", true)"
            else "UIdentifier(\"``that.name``\")";
    transformUnionType(UnionType that)
            => "UnionType(``transformWithIndent(that.children)``)";
    transformUnionAssignmentOperation(UnionAssignmentOperation that)
            => "UnionAssignmentOperation {
                `` indent + indentLevel ``target = ``transformWithIndent(that.target)``;
                `` indent + indentLevel ``other = ``transformWithIndent(that.other)``;
                ``indent``}";
    transformUnionOperation(UnionOperation that)
            => "UnionOperation {
                `` indent + indentLevel ``leftOperand = ``transformWithIndent(that.leftOperand)``;
                `` indent + indentLevel ``rightOperand = ``transformWithIndent(that.rightOperand)``;
                ``indent``}";
    transformUnspecifiedVariable(UnspecifiedVariable that)
            => that.type exists
            then "UnspecifiedVariable {
                  `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                  `` indent + indentLevel ``type = ``transformWithIndent(that.type)``;
                  ``indent``}"
            else "UnspecifiedVariable(``transformWithIndent(that.name)``)";
    transformValueArgument(ValueArgument that)
            => "ValueArgument {
                `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                `` indent + indentLevel ``type = ``transformWithIndent(that.type)``;
                `` indent + indentLevel ``definition = ``transformWithIndent(that.definition)``;
                ``indent``}";
    transformValueConstructorDefinition(ValueConstructorDefinition that)
            => "ValueConstructorDefinition {
                `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                `` indent + indentLevel ``block = ``transformWithIndent(that.block)``;
                `` indent + indentLevel ``extendedType = ``transformWithIndent(that.extendedType)``;
                `` indent + indentLevel ``annotations = ``transformWithIndent(that.annotations)``;
                ``indent``}";
    transformValueDec(ValueDec that)
            => that.qualifier.children nonempty
            then "ValueDec {
                  `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                  `` indent + indentLevel ``qualifier = ``transformWithIndent(that.qualifier)``;
                  ``indent``}"
            else "ValueDec(``transformWithIndent(that.name)``)";
    transformValueDeclaration(ValueDeclaration that)
            => "ValueDeclaration {
                `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                `` indent + indentLevel ``type = ``transformWithIndent(that.type)``;
                `` indent + indentLevel ``annotations = ``transformWithIndent(that.annotations)``;
                ``indent``}";
    transformValueDefinition(ValueDefinition that)
            => "ValueDefinition {
                `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                `` indent + indentLevel ``type = ``transformWithIndent(that.type)``;
                `` indent + indentLevel ``definition = ``transformWithIndent(that.definition)``;
                `` indent + indentLevel ``annotations = ``transformWithIndent(that.annotations)``;
                ``indent``}";
    transformValueGetterDefinition(ValueGetterDefinition that)
            => "ValueGetterDefinition {
                `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                `` indent + indentLevel ``type = ``transformWithIndent(that.type)``;
                `` indent + indentLevel ``definition = ``transformWithIndent(that.definition)``;
                `` indent + indentLevel ``annotations = ``transformWithIndent(that.annotations)``;
                ``indent``}";
    transformValueModifier(ValueModifier that) => "ValueModifier()";
    transformValueParameter(ValueParameter that)
            => "ValueParameter {
                `` indent + indentLevel ``annotations = ``transformWithIndent(that.annotations)``;
                `` indent + indentLevel ``type = ``transformWithIndent(that.type)``;
                `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                ``indent``}";
    transformValueSetterDefinition(ValueSetterDefinition that)
            => "ValueSetterDefinition {
                `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                `` indent + indentLevel ``definition = ``transformWithIndent(that.definition)``;
                `` indent + indentLevel ``annotations = ``transformWithIndent(that.annotations)``;
                ``indent``}";
    transformValueSpecification(ValueSpecification that)
            => "ValueSpecification {
                `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                `` indent + indentLevel ``specifier = ``transformWithIndent(that.specifier)``;
                ``indent``}";
    transformVariablePattern(VariablePattern that) => "VariablePattern(``transformWithIndent(that.variable)``)";
    transformVariadicParameter(VariadicParameter that)
            => "VariadicParameter {
                `` indent + indentLevel ``annotations = ``transformWithIndent(that.annotations)``;
                `` indent + indentLevel ``type = ``transformWithIndent(that.type)``;
                `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                ``indent``}";
    transformVariadicType(VariadicType that)
            => that.isNonempty
            then "VariadicType {
                  `` indent + indentLevel ``elementType = ``transformWithIndent(that.elementType)``;
                  `` indent + indentLevel ``isNonempty = true;
                  ``indent``}"
            else "VariadicType(``transformWithIndent(that.elementType)``)";
    transformVariadicVariable(VariadicVariable that)
            => that.type exists
            then "VariadicVariable {
                  `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
                  `` indent + indentLevel ``type = ``transformWithIndent(that.type)``;
                  ``indent``}"
            else "VariadicVariable(``transformWithIndent(that.name)``)";
    transformVoidModifier(VoidModifier that) => "VoidModifier()";
    transformWhile(While that)
            => "While {
                `` indent + indentLevel ``conditions = ``transformWithIndent(that.conditions)``;
                `` indent + indentLevel ``block = ``transformWithIndent(that.block)``;
                ``indent``}";
    transformWithinOperation(WithinOperation that)
            => "WithinOperation {
                `` indent + indentLevel ``operand = ``transformWithIndent(that.operand)``;
                `` indent + indentLevel ``lowerBound = ``transformWithIndent(that.lowerBound)``;
                `` indent + indentLevel ``upperBound = ``transformWithIndent(that.upperBound)``;
                ``indent``}";
}