diff --git a/source-gen/source_gen/ceylon/ast/ConcreteClassGenerator.ceylon b/source-gen/source_gen/ceylon/ast/ConcreteClassGenerator.ceylon index 8d5ce281..61bbbc13 100644 --- a/source-gen/source_gen/ceylon/ast/ConcreteClassGenerator.ceylon +++ b/source-gen/source_gen/ceylon/ast/ConcreteClassGenerator.ceylon @@ -71,6 +71,9 @@ class ConcreteClassGenerator( shared actual Result transform(Transformer transformer) => transformer.transform``type``(this); + shared actual void visit(Visitor visitor) + => visitor.visit``type``(this); + shared actual Boolean equals(Object that) {"); if (nonempty params) { value optionalParams = params.select((String->String elem) => elem.key.endsWith("?")); diff --git a/source/ceylon/ast/core/AddAssignmentOperation.ceylon b/source/ceylon/ast/core/AddAssignmentOperation.ceylon index fe23ff17..861ed64e 100644 --- a/source/ceylon/ast/core/AddAssignmentOperation.ceylon +++ b/source/ceylon/ast/core/AddAssignmentOperation.ceylon @@ -29,6 +29,9 @@ shared class AddAssignmentOperation(target, summand) shared actual Result transform(Transformer transformer) => transformer.transformAddAssignmentOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitAddAssignmentOperation(this); + shared actual Boolean equals(Object that) { if (is AddAssignmentOperation that) { return leftOperand == that.leftOperand && rightOperand == that.rightOperand; diff --git a/source/ceylon/ast/core/AliasDec.ceylon b/source/ceylon/ast/core/AliasDec.ceylon index cb70f620..13dab726 100644 --- a/source/ceylon/ast/core/AliasDec.ceylon +++ b/source/ceylon/ast/core/AliasDec.ceylon @@ -19,6 +19,9 @@ shared class AliasDec(name, qualifier = DecQualifier()) shared actual Result transform(Transformer transformer) => transformer.transformAliasDec(this); + shared actual void visit(Visitor visitor) + => visitor.visitAliasDec(this); + shared actual Boolean equals(Object that) { if (is AliasDec that) { return name == that.name && qualifier == that.qualifier; diff --git a/source/ceylon/ast/core/AndAssignmentOperation.ceylon b/source/ceylon/ast/core/AndAssignmentOperation.ceylon index c4702668..6d873dcc 100644 --- a/source/ceylon/ast/core/AndAssignmentOperation.ceylon +++ b/source/ceylon/ast/core/AndAssignmentOperation.ceylon @@ -29,6 +29,9 @@ shared class AndAssignmentOperation(target, other) shared actual Result transform(Transformer transformer) => transformer.transformAndAssignmentOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitAndAssignmentOperation(this); + shared actual Boolean equals(Object that) { if (is AndAssignmentOperation that) { return leftOperand == that.leftOperand && rightOperand == that.rightOperand; diff --git a/source/ceylon/ast/core/AndOperation.ceylon b/source/ceylon/ast/core/AndOperation.ceylon index bce6e5fd..172f8c83 100644 --- a/source/ceylon/ast/core/AndOperation.ceylon +++ b/source/ceylon/ast/core/AndOperation.ceylon @@ -20,6 +20,9 @@ shared class AndOperation(leftOperand, rightOperand) shared actual Result transform(Transformer transformer) => transformer.transformAndOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitAndOperation(this); + shared actual Boolean equals(Object that) { if (is AndOperation that) { return leftOperand == that.leftOperand && rightOperand == that.rightOperand; diff --git a/source/ceylon/ast/core/Annotation.ceylon b/source/ceylon/ast/core/Annotation.ceylon index 34ff4c25..be6fe395 100644 --- a/source/ceylon/ast/core/Annotation.ceylon +++ b/source/ceylon/ast/core/Annotation.ceylon @@ -22,6 +22,9 @@ shared class Annotation(name, arguments = null) shared actual Result transform(Transformer transformer) => transformer.transformAnnotation(this); + shared actual void visit(Visitor visitor) + => visitor.visitAnnotation(this); + shared actual Boolean equals(Object that) { if (is Annotation that) { if (exists arguments) { diff --git a/source/ceylon/ast/core/Annotations.ceylon b/source/ceylon/ast/core/Annotations.ceylon index 59a6c8b9..77032e00 100644 --- a/source/ceylon/ast/core/Annotations.ceylon +++ b/source/ceylon/ast/core/Annotations.ceylon @@ -27,6 +27,9 @@ shared class Annotations(anonymousAnnotation = null, annotations = []) shared actual Result transform(Transformer transformer) => transformer.transformAnnotations(this); + shared actual void visit(Visitor visitor) + => visitor.visitAnnotations(this); + shared actual Boolean equals(Object that) { if (is Annotations that) { if (exists anonymousAnnotation) { diff --git a/source/ceylon/ast/core/AnonymousArgument.ceylon b/source/ceylon/ast/core/AnonymousArgument.ceylon index 144b5029..7db66a47 100644 --- a/source/ceylon/ast/core/AnonymousArgument.ceylon +++ b/source/ceylon/ast/core/AnonymousArgument.ceylon @@ -23,6 +23,9 @@ shared class AnonymousArgument(expression) shared actual Result transform(Transformer transformer) => transformer.transformAnonymousArgument(this); + shared actual void visit(Visitor visitor) + => visitor.visitAnonymousArgument(this); + shared actual Boolean equals(Object that) { if (is AnonymousArgument that) { return expression == that.expression; diff --git a/source/ceylon/ast/core/ArgumentList.ceylon b/source/ceylon/ast/core/ArgumentList.ceylon index 96884428..6825cced 100644 --- a/source/ceylon/ast/core/ArgumentList.ceylon +++ b/source/ceylon/ast/core/ArgumentList.ceylon @@ -22,6 +22,9 @@ shared class ArgumentList(listedArguments = [], sequenceArgument = null) shared actual Result transform(Transformer transformer) => transformer.transformArgumentList(this); + shared actual void visit(Visitor visitor) + => visitor.visitArgumentList(this); + shared actual Boolean equals(Object that) { if (is ArgumentList that) { if (exists sequenceArgument) { diff --git a/source/ceylon/ast/core/Assertion.ceylon b/source/ceylon/ast/core/Assertion.ceylon index c5757e81..fc1e3db9 100644 --- a/source/ceylon/ast/core/Assertion.ceylon +++ b/source/ceylon/ast/core/Assertion.ceylon @@ -21,6 +21,9 @@ shared class Assertion(conditions, annotations = Annotations()) shared actual Result transform(Transformer transformer) => transformer.transformAssertion(this); + shared actual void visit(Visitor visitor) + => visitor.visitAssertion(this); + shared actual Boolean equals(Object that) { if (is Assertion that) { return conditions == that.conditions && annotations == that.annotations; diff --git a/source/ceylon/ast/core/AssignOperation.ceylon b/source/ceylon/ast/core/AssignOperation.ceylon index 88be7788..4daede4f 100644 --- a/source/ceylon/ast/core/AssignOperation.ceylon +++ b/source/ceylon/ast/core/AssignOperation.ceylon @@ -28,6 +28,9 @@ shared class AssignOperation(target, expression) shared actual Result transform(Transformer transformer) => transformer.transformAssignOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitAssignOperation(this); + shared actual Boolean equals(Object that) { if (is AssignOperation that) { return leftOperand == that.leftOperand && rightOperand == that.rightOperand; diff --git a/source/ceylon/ast/core/AssignmentStatement.ceylon b/source/ceylon/ast/core/AssignmentStatement.ceylon index 0bb53a3e..a0796731 100644 --- a/source/ceylon/ast/core/AssignmentStatement.ceylon +++ b/source/ceylon/ast/core/AssignmentStatement.ceylon @@ -27,6 +27,9 @@ shared class AssignmentStatement(expression) shared actual Result transform(Transformer transformer) => transformer.transformAssignmentStatement(this); + shared actual void visit(Visitor visitor) + => visitor.visitAssignmentStatement(this); + shared actual Boolean equals(Object that) { if (is AssignmentStatement that) { return expression == that.expression; diff --git a/source/ceylon/ast/core/BaseExpression.ceylon b/source/ceylon/ast/core/BaseExpression.ceylon index 458a8451..ff8a18fe 100644 --- a/source/ceylon/ast/core/BaseExpression.ceylon +++ b/source/ceylon/ast/core/BaseExpression.ceylon @@ -20,6 +20,9 @@ shared class BaseExpression(nameAndArgs) shared actual Result transform(Transformer transformer) => transformer.transformBaseExpression(this); + shared actual void visit(Visitor visitor) + => visitor.visitBaseExpression(this); + shared actual Boolean equals(Object that) { if (is BaseExpression that) { return nameAndArgs == that.nameAndArgs; diff --git a/source/ceylon/ast/core/BaseMeta.ceylon b/source/ceylon/ast/core/BaseMeta.ceylon index d14e4264..732b2e98 100644 --- a/source/ceylon/ast/core/BaseMeta.ceylon +++ b/source/ceylon/ast/core/BaseMeta.ceylon @@ -24,6 +24,9 @@ shared class BaseMeta(nameAndArgs, packageQualifier = null) shared actual Result transform(Transformer transformer) => transformer.transformBaseMeta(this); + shared actual void visit(Visitor visitor) + => visitor.visitBaseMeta(this); + shared actual Boolean equals(Object that) { if (is BaseMeta that) { if (exists packageQualifier) { diff --git a/source/ceylon/ast/core/BaseType.ceylon b/source/ceylon/ast/core/BaseType.ceylon index dc9e86dc..be771a39 100644 --- a/source/ceylon/ast/core/BaseType.ceylon +++ b/source/ceylon/ast/core/BaseType.ceylon @@ -21,6 +21,9 @@ shared class BaseType(nameAndArgs, qualifier = null) shared actual Result transform(Transformer transformer) => transformer.transformBaseType(this); + shared actual void visit(Visitor visitor) + => visitor.visitBaseType(this); + shared actual Boolean equals(Object that) { if (is BaseType that) { if (exists qualifier) { diff --git a/source/ceylon/ast/core/Block.ceylon b/source/ceylon/ast/core/Block.ceylon index 15fe31d4..9f710d17 100644 --- a/source/ceylon/ast/core/Block.ceylon +++ b/source/ceylon/ast/core/Block.ceylon @@ -34,6 +34,9 @@ shared class Block(content) shared actual Result transform(Transformer transformer) => transformer.transformBlock(this); + shared actual void visit(Visitor visitor) + => visitor.visitBlock(this); + shared actual Boolean equals(Object that) { if (is Block that) { return content == that.content; diff --git a/source/ceylon/ast/core/BooleanCondition.ceylon b/source/ceylon/ast/core/BooleanCondition.ceylon index ad6335c7..d111385a 100644 --- a/source/ceylon/ast/core/BooleanCondition.ceylon +++ b/source/ceylon/ast/core/BooleanCondition.ceylon @@ -17,6 +17,9 @@ shared class BooleanCondition(condition) shared actual Result transform(Transformer transformer) => transformer.transformBooleanCondition(this); + shared actual void visit(Visitor visitor) + => visitor.visitBooleanCondition(this); + shared actual Boolean equals(Object that) { if (is BooleanCondition that) { return condition == that.condition; diff --git a/source/ceylon/ast/core/Break.ceylon b/source/ceylon/ast/core/Break.ceylon index f137f7f6..555c76cc 100644 --- a/source/ceylon/ast/core/Break.ceylon +++ b/source/ceylon/ast/core/Break.ceylon @@ -12,6 +12,9 @@ shared class Break() shared actual Result transform(Transformer transformer) => transformer.transformBreak(this); + shared actual void visit(Visitor visitor) + => visitor.visitBreak(this); + shared actual Boolean equals(Object that) { return that is Break; } diff --git a/source/ceylon/ast/core/CallableConstructorDefinition.ceylon b/source/ceylon/ast/core/CallableConstructorDefinition.ceylon index ebf4062c..57b4db48 100644 --- a/source/ceylon/ast/core/CallableConstructorDefinition.ceylon +++ b/source/ceylon/ast/core/CallableConstructorDefinition.ceylon @@ -60,6 +60,9 @@ shared class CallableConstructorDefinition(name, parameters, block, extendedType shared actual Result transform(Transformer transformer) => transformer.transformCallableConstructorDefinition(this); + shared actual void visit(Visitor visitor) + => visitor.visitCallableConstructorDefinition(this); + shared actual Boolean equals(Object that) { if (is CallableConstructorDefinition that) { if (exists extendedType) { diff --git a/source/ceylon/ast/core/CallableParameter.ceylon b/source/ceylon/ast/core/CallableParameter.ceylon index b2851914..f721daad 100644 --- a/source/ceylon/ast/core/CallableParameter.ceylon +++ b/source/ceylon/ast/core/CallableParameter.ceylon @@ -29,6 +29,9 @@ shared class CallableParameter(type, name, parameterLists, annotations = Annotat shared actual Result transform(Transformer transformer) => transformer.transformCallableParameter(this); + shared actual void visit(Visitor visitor) + => visitor.visitCallableParameter(this); + shared actual Boolean equals(Object that) { if (is CallableParameter that) { return annotations == that.annotations && type == that.type && name == that.name && parameterLists == that.parameterLists; diff --git a/source/ceylon/ast/core/CallableType.ceylon b/source/ceylon/ast/core/CallableType.ceylon index 435ee202..70658a22 100644 --- a/source/ceylon/ast/core/CallableType.ceylon +++ b/source/ceylon/ast/core/CallableType.ceylon @@ -24,6 +24,9 @@ shared class CallableType(returnType, argumentTypes) shared actual Result transform(Transformer transformer) => transformer.transformCallableType(this); + shared actual void visit(Visitor visitor) + => visitor.visitCallableType(this); + shared actual Boolean equals(Object that) { if (is CallableType that) { return returnType == that.returnType && argumentTypes == that.argumentTypes; diff --git a/source/ceylon/ast/core/CaseClause.ceylon b/source/ceylon/ast/core/CaseClause.ceylon index e4015849..14047070 100644 --- a/source/ceylon/ast/core/CaseClause.ceylon +++ b/source/ceylon/ast/core/CaseClause.ceylon @@ -24,6 +24,9 @@ shared class CaseClause(caseItem, block) shared actual Result transform(Transformer transformer) => transformer.transformCaseClause(this); + shared actual void visit(Visitor visitor) + => visitor.visitCaseClause(this); + shared actual Boolean equals(Object that) { if (is CaseClause that) { return caseItem == that.caseItem && block == that.block; diff --git a/source/ceylon/ast/core/CaseExpression.ceylon b/source/ceylon/ast/core/CaseExpression.ceylon index 058e3d6c..9bf975c3 100644 --- a/source/ceylon/ast/core/CaseExpression.ceylon +++ b/source/ceylon/ast/core/CaseExpression.ceylon @@ -24,6 +24,9 @@ shared class CaseExpression(caseItem, expression) shared actual Result transform(Transformer transformer) => transformer.transformCaseExpression(this); + shared actual void visit(Visitor visitor) + => visitor.visitCaseExpression(this); + shared actual Boolean equals(Object that) { if (is CaseExpression that) { return caseItem == that.caseItem && expression == that.expression; diff --git a/source/ceylon/ast/core/CaseTypes.ceylon b/source/ceylon/ast/core/CaseTypes.ceylon index 128c6c58..401014b0 100644 --- a/source/ceylon/ast/core/CaseTypes.ceylon +++ b/source/ceylon/ast/core/CaseTypes.ceylon @@ -20,6 +20,9 @@ shared class CaseTypes(caseTypes) shared actual Result transform(Transformer transformer) => transformer.transformCaseTypes(this); + shared actual void visit(Visitor visitor) + => visitor.visitCaseTypes(this); + shared actual Boolean equals(Object that) { if (is CaseTypes that) { return caseTypes == that.caseTypes; diff --git a/source/ceylon/ast/core/CatchClause.ceylon b/source/ceylon/ast/core/CatchClause.ceylon index a6dfe281..461cd943 100644 --- a/source/ceylon/ast/core/CatchClause.ceylon +++ b/source/ceylon/ast/core/CatchClause.ceylon @@ -26,6 +26,9 @@ shared class CatchClause(variable, block) shared actual Result transform(Transformer transformer) => transformer.transformCatchClause(this); + shared actual void visit(Visitor visitor) + => visitor.visitCatchClause(this); + shared actual Boolean equals(Object that) { if (is CatchClause that) { return variable == that.variable && block == that.block; diff --git a/source/ceylon/ast/core/CharacterLiteral.ceylon b/source/ceylon/ast/core/CharacterLiteral.ceylon index 9fb9d596..e25614a5 100644 --- a/source/ceylon/ast/core/CharacterLiteral.ceylon +++ b/source/ceylon/ast/core/CharacterLiteral.ceylon @@ -8,6 +8,9 @@ shared class CharacterLiteral(text) extends Literal(text) { shared actual Result transform(Transformer transformer) => transformer.transformCharacterLiteral(this); + shared actual void visit(Visitor visitor) + => visitor.visitCharacterLiteral(this); + shared actual Boolean equals(Object that) { if (is CharacterLiteral that) { return text == that.text; diff --git a/source/ceylon/ast/core/ClassAliasDefinition.ceylon b/source/ceylon/ast/core/ClassAliasDefinition.ceylon index fd4b7c22..0eb30663 100644 --- a/source/ceylon/ast/core/ClassAliasDefinition.ceylon +++ b/source/ceylon/ast/core/ClassAliasDefinition.ceylon @@ -68,6 +68,9 @@ shared class ClassAliasDefinition(name, parameters, specifier, caseTypes = null, shared actual Result transform(Transformer transformer) => transformer.transformClassAliasDefinition(this); + shared actual void visit(Visitor visitor) + => visitor.visitClassAliasDefinition(this); + shared actual Boolean equals(Object that) { if (is ClassAliasDefinition that) { if (exists caseTypes) { diff --git a/source/ceylon/ast/core/ClassBody.ceylon b/source/ceylon/ast/core/ClassBody.ceylon index 31772cbc..b93dc8b2 100644 --- a/source/ceylon/ast/core/ClassBody.ceylon +++ b/source/ceylon/ast/core/ClassBody.ceylon @@ -33,6 +33,9 @@ shared class ClassBody(content) shared actual Result transform(Transformer transformer) => transformer.transformClassBody(this); + shared actual void visit(Visitor visitor) + => visitor.visitClassBody(this); + shared actual Boolean equals(Object that) { if (is ClassBody that) { return content == that.content; diff --git a/source/ceylon/ast/core/ClassDec.ceylon b/source/ceylon/ast/core/ClassDec.ceylon index 768d499d..eb94eecf 100644 --- a/source/ceylon/ast/core/ClassDec.ceylon +++ b/source/ceylon/ast/core/ClassDec.ceylon @@ -37,6 +37,9 @@ shared class ClassDec(name, qualifier = DecQualifier()) shared actual Result transform(Transformer transformer) => transformer.transformClassDec(this); + shared actual void visit(Visitor visitor) + => visitor.visitClassDec(this); + shared actual Boolean equals(Object that) { if (is ClassDec that) { if (exists qualifier) { diff --git a/source/ceylon/ast/core/ClassDefinition.ceylon b/source/ceylon/ast/core/ClassDefinition.ceylon index e12b2dc7..ec725971 100644 --- a/source/ceylon/ast/core/ClassDefinition.ceylon +++ b/source/ceylon/ast/core/ClassDefinition.ceylon @@ -67,6 +67,9 @@ shared class ClassDefinition(name, parameters, body, caseTypes = null, extendedT shared actual Result transform(Transformer transformer) => transformer.transformClassDefinition(this); + shared actual void visit(Visitor visitor) + => visitor.visitClassDefinition(this); + shared actual Boolean equals(Object that) { if (is ClassDefinition that) { if (exists caseTypes) { diff --git a/source/ceylon/ast/core/ClassSpecifier.ceylon b/source/ceylon/ast/core/ClassSpecifier.ceylon index 0c859119..b360a0c3 100644 --- a/source/ceylon/ast/core/ClassSpecifier.ceylon +++ b/source/ceylon/ast/core/ClassSpecifier.ceylon @@ -17,6 +17,9 @@ shared class ClassSpecifier(target) shared actual Result transform(Transformer transformer) => transformer.transformClassSpecifier(this); + shared actual void visit(Visitor visitor) + => visitor.visitClassSpecifier(this); + shared actual Boolean equals(Object that) { if (is ClassSpecifier that) { return target == that.target; diff --git a/source/ceylon/ast/core/ClosedBound.ceylon b/source/ceylon/ast/core/ClosedBound.ceylon index 2c92c463..cca7d6ca 100644 --- a/source/ceylon/ast/core/ClosedBound.ceylon +++ b/source/ceylon/ast/core/ClosedBound.ceylon @@ -12,6 +12,9 @@ shared class ClosedBound(endpoint) shared actual Result transform(Transformer transformer) => transformer.transformClosedBound(this); + shared actual void visit(Visitor visitor) + => visitor.visitClosedBound(this); + shared actual Boolean equals(Object that) { if (is ClosedBound that) { return endpoint == that.endpoint; diff --git a/source/ceylon/ast/core/CompareOperation.ceylon b/source/ceylon/ast/core/CompareOperation.ceylon index f196aa79..ba46f0e7 100644 --- a/source/ceylon/ast/core/CompareOperation.ceylon +++ b/source/ceylon/ast/core/CompareOperation.ceylon @@ -24,6 +24,9 @@ shared class CompareOperation(leftOperand, rightOperand) shared actual Result transform(Transformer transformer) => transformer.transformCompareOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitCompareOperation(this); + shared actual Boolean equals(Object that) { if (is CompareOperation that) { return leftOperand == that.leftOperand && rightOperand == that.rightOperand; diff --git a/source/ceylon/ast/core/CompilationUnit.ceylon b/source/ceylon/ast/core/CompilationUnit.ceylon index cc48be39..07dc2033 100644 --- a/source/ceylon/ast/core/CompilationUnit.ceylon +++ b/source/ceylon/ast/core/CompilationUnit.ceylon @@ -35,6 +35,9 @@ shared class CompilationUnit(declarations, imports = []) // we *could* provide a shared actual Result transform(Transformer transformer) => transformer.transformCompilationUnit(this); + shared actual void visit(Visitor visitor) + => visitor.visitCompilationUnit(this); + shared actual Boolean equals(Object that) { if (is CompilationUnit that) { return imports == that.imports && declarations == that.declarations; diff --git a/source/ceylon/ast/core/ComplementAssignmentOperation.ceylon b/source/ceylon/ast/core/ComplementAssignmentOperation.ceylon index 3fa303e0..d7785231 100644 --- a/source/ceylon/ast/core/ComplementAssignmentOperation.ceylon +++ b/source/ceylon/ast/core/ComplementAssignmentOperation.ceylon @@ -29,6 +29,9 @@ shared class ComplementAssignmentOperation(target, other) shared actual Result transform(Transformer transformer) => transformer.transformComplementAssignmentOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitComplementAssignmentOperation(this); + shared actual Boolean equals(Object that) { if (is ComplementAssignmentOperation that) { return leftOperand == that.leftOperand && rightOperand == that.rightOperand; diff --git a/source/ceylon/ast/core/ComplementOperation.ceylon b/source/ceylon/ast/core/ComplementOperation.ceylon index 6a985613..2431f92a 100644 --- a/source/ceylon/ast/core/ComplementOperation.ceylon +++ b/source/ceylon/ast/core/ComplementOperation.ceylon @@ -22,6 +22,9 @@ shared class ComplementOperation(leftOperand, rightOperand) shared actual Result transform(Transformer transformer) => transformer.transformComplementOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitComplementOperation(this); + shared actual Boolean equals(Object that) { if (is ComplementOperation that) { return leftOperand == that.leftOperand && rightOperand == that.rightOperand; diff --git a/source/ceylon/ast/core/Comprehension.ceylon b/source/ceylon/ast/core/Comprehension.ceylon index da4ab526..3668bd34 100644 --- a/source/ceylon/ast/core/Comprehension.ceylon +++ b/source/ceylon/ast/core/Comprehension.ceylon @@ -20,6 +20,9 @@ shared class Comprehension(clause) shared actual Result transform(Transformer transformer) => transformer.transformComprehension(this); + shared actual void visit(Visitor visitor) + => visitor.visitComprehension(this); + shared actual Boolean equals(Object that) { if (is Comprehension that) { return clause == that.clause; diff --git a/source/ceylon/ast/core/Conditions.ceylon b/source/ceylon/ast/core/Conditions.ceylon index 966603ee..b44e2e83 100644 --- a/source/ceylon/ast/core/Conditions.ceylon +++ b/source/ceylon/ast/core/Conditions.ceylon @@ -15,6 +15,9 @@ shared class Conditions(conditions) shared actual Result transform(Transformer transformer) => transformer.transformConditions(this); + shared actual void visit(Visitor visitor) + => visitor.visitConditions(this); + shared actual Boolean equals(Object that) { if (is Conditions that) { return conditions == that.conditions; diff --git a/source/ceylon/ast/core/Construction.ceylon b/source/ceylon/ast/core/Construction.ceylon index a7d61292..3cc58a13 100644 --- a/source/ceylon/ast/core/Construction.ceylon +++ b/source/ceylon/ast/core/Construction.ceylon @@ -30,6 +30,9 @@ shared class Construction(nameAndArgs, arguments, qualifier = null) shared actual Result transform(Transformer transformer) => transformer.transformConstruction(this); + shared actual void visit(Visitor visitor) + => visitor.visitConstruction(this); + shared actual Boolean equals(Object that) { if (is Construction that) { if (exists qualifier) { diff --git a/source/ceylon/ast/core/ConstructorDec.ceylon b/source/ceylon/ast/core/ConstructorDec.ceylon index 463f5af7..849c9e0b 100644 --- a/source/ceylon/ast/core/ConstructorDec.ceylon +++ b/source/ceylon/ast/core/ConstructorDec.ceylon @@ -21,6 +21,9 @@ shared class ConstructorDec(name, qualifier) shared actual Result transform(Transformer transformer) => transformer.transformConstructorDec(this); + shared actual void visit(Visitor visitor) + => visitor.visitConstructorDec(this); + shared actual Boolean equals(Object that) { if (is ConstructorDec that) { return name == that.name && qualifier == that.qualifier; diff --git a/source/ceylon/ast/core/Continue.ceylon b/source/ceylon/ast/core/Continue.ceylon index d2d8e708..388578c3 100644 --- a/source/ceylon/ast/core/Continue.ceylon +++ b/source/ceylon/ast/core/Continue.ceylon @@ -12,6 +12,9 @@ shared class Continue() shared actual Result transform(Transformer transformer) => transformer.transformContinue(this); + shared actual void visit(Visitor visitor) + => visitor.visitContinue(this); + shared actual Boolean equals(Object that) { return that is Continue; } diff --git a/source/ceylon/ast/core/DecQualifier.ceylon b/source/ceylon/ast/core/DecQualifier.ceylon index c261c0fb..5d718bbb 100644 --- a/source/ceylon/ast/core/DecQualifier.ceylon +++ b/source/ceylon/ast/core/DecQualifier.ceylon @@ -24,6 +24,9 @@ shared class DecQualifier(components = [], packageQualifier = null) shared actual Result transform(Transformer transformer) => transformer.transformDecQualifier(this); + shared actual void visit(Visitor visitor) + => visitor.visitDecQualifier(this); + shared actual Boolean equals(Object that) { if (is DecQualifier that) { if (exists packageQualifier) { diff --git a/source/ceylon/ast/core/DefaultedCallableParameter.ceylon b/source/ceylon/ast/core/DefaultedCallableParameter.ceylon index 31cd8156..31102a2a 100644 --- a/source/ceylon/ast/core/DefaultedCallableParameter.ceylon +++ b/source/ceylon/ast/core/DefaultedCallableParameter.ceylon @@ -18,6 +18,9 @@ shared class DefaultedCallableParameter(parameter, specifier) shared actual Result transform(Transformer transformer) => transformer.transformDefaultedCallableParameter(this); + shared actual void visit(Visitor visitor) + => visitor.visitDefaultedCallableParameter(this); + shared actual Boolean equals(Object that) { if (is DefaultedCallableParameter that) { return parameter == that.parameter && specifier == that.specifier; diff --git a/source/ceylon/ast/core/DefaultedParameterReference.ceylon b/source/ceylon/ast/core/DefaultedParameterReference.ceylon index d056756e..c80c0922 100644 --- a/source/ceylon/ast/core/DefaultedParameterReference.ceylon +++ b/source/ceylon/ast/core/DefaultedParameterReference.ceylon @@ -19,6 +19,9 @@ shared class DefaultedParameterReference(parameter, specifier) shared actual Result transform(Transformer transformer) => transformer.transformDefaultedParameterReference(this); + shared actual void visit(Visitor visitor) + => visitor.visitDefaultedParameterReference(this); + shared actual Boolean equals(Object that) { if (is DefaultedParameterReference that) { return parameter == that.parameter && specifier == that.specifier; diff --git a/source/ceylon/ast/core/DefaultedType.ceylon b/source/ceylon/ast/core/DefaultedType.ceylon index dad2ce91..6963805d 100644 --- a/source/ceylon/ast/core/DefaultedType.ceylon +++ b/source/ceylon/ast/core/DefaultedType.ceylon @@ -16,6 +16,9 @@ shared class DefaultedType(type) shared actual Result transform(Transformer transformer) => transformer.transformDefaultedType(this); + shared actual void visit(Visitor visitor) + => visitor.visitDefaultedType(this); + shared actual Boolean equals(Object that) { if (is DefaultedType that) { return type == that.type; diff --git a/source/ceylon/ast/core/DefaultedValueParameter.ceylon b/source/ceylon/ast/core/DefaultedValueParameter.ceylon index 444ed823..8d6d456c 100644 --- a/source/ceylon/ast/core/DefaultedValueParameter.ceylon +++ b/source/ceylon/ast/core/DefaultedValueParameter.ceylon @@ -18,6 +18,9 @@ shared class DefaultedValueParameter(parameter, specifier) shared actual Result transform(Transformer transformer) => transformer.transformDefaultedValueParameter(this); + shared actual void visit(Visitor visitor) + => visitor.visitDefaultedValueParameter(this); + shared actual Boolean equals(Object that) { if (is DefaultedValueParameter that) { return parameter == that.parameter && specifier == that.specifier; diff --git a/source/ceylon/ast/core/Destructure.ceylon b/source/ceylon/ast/core/Destructure.ceylon index 1e893ec2..e4c78f31 100644 --- a/source/ceylon/ast/core/Destructure.ceylon +++ b/source/ceylon/ast/core/Destructure.ceylon @@ -25,6 +25,9 @@ shared class Destructure(pattern, specifier, valueModifier = ValueModifier()) shared actual Result transform(Transformer transformer) => transformer.transformDestructure(this); + shared actual void visit(Visitor visitor) + => visitor.visitDestructure(this); + shared actual Boolean equals(Object that) { if (is Destructure that) { return pattern == that.pattern && specifier == that.specifier && valueModifier == that.valueModifier; diff --git a/source/ceylon/ast/core/DifferenceOperation.ceylon b/source/ceylon/ast/core/DifferenceOperation.ceylon index aa9c5512..a5823145 100644 --- a/source/ceylon/ast/core/DifferenceOperation.ceylon +++ b/source/ceylon/ast/core/DifferenceOperation.ceylon @@ -29,6 +29,9 @@ shared class DifferenceOperation(minuend, subtrahend) shared actual Result transform(Transformer transformer) => transformer.transformDifferenceOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitDifferenceOperation(this); + shared actual Boolean equals(Object that) { if (is DifferenceOperation that) { return leftOperand == that.leftOperand && rightOperand == that.rightOperand; diff --git a/source/ceylon/ast/core/DivideAssignmentOperation.ceylon b/source/ceylon/ast/core/DivideAssignmentOperation.ceylon index ba215ffd..b3bca8c1 100644 --- a/source/ceylon/ast/core/DivideAssignmentOperation.ceylon +++ b/source/ceylon/ast/core/DivideAssignmentOperation.ceylon @@ -29,6 +29,9 @@ shared class DivideAssignmentOperation(target, divisor) shared actual Result transform(Transformer transformer) => transformer.transformDivideAssignmentOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitDivideAssignmentOperation(this); + shared actual Boolean equals(Object that) { if (is DivideAssignmentOperation that) { return leftOperand == that.leftOperand && rightOperand == that.rightOperand; diff --git a/source/ceylon/ast/core/DynamicBlock.ceylon b/source/ceylon/ast/core/DynamicBlock.ceylon index 5400347f..8701fc0e 100644 --- a/source/ceylon/ast/core/DynamicBlock.ceylon +++ b/source/ceylon/ast/core/DynamicBlock.ceylon @@ -23,6 +23,9 @@ shared class DynamicBlock(block) shared actual Result transform(Transformer transformer) => transformer.transformDynamicBlock(this); + shared actual void visit(Visitor visitor) + => visitor.visitDynamicBlock(this); + shared actual Boolean equals(Object that) { if (is DynamicBlock that) { return block == that.block; diff --git a/source/ceylon/ast/core/DynamicInterfaceDefinition.ceylon b/source/ceylon/ast/core/DynamicInterfaceDefinition.ceylon index fd2d4208..50c3e320 100644 --- a/source/ceylon/ast/core/DynamicInterfaceDefinition.ceylon +++ b/source/ceylon/ast/core/DynamicInterfaceDefinition.ceylon @@ -55,6 +55,9 @@ shared class DynamicInterfaceDefinition(name, body, caseTypes = null, satisfiedT shared actual Result transform(Transformer transformer) => transformer.transformDynamicInterfaceDefinition(this); + shared actual void visit(Visitor visitor) + => visitor.visitDynamicInterfaceDefinition(this); + shared actual Boolean equals(Object that) { if (is DynamicInterfaceDefinition that) { if (exists caseTypes) { diff --git a/source/ceylon/ast/core/DynamicModifier.ceylon b/source/ceylon/ast/core/DynamicModifier.ceylon index f60e3092..08c97faa 100644 --- a/source/ceylon/ast/core/DynamicModifier.ceylon +++ b/source/ceylon/ast/core/DynamicModifier.ceylon @@ -7,6 +7,9 @@ shared class DynamicModifier() shared actual Result transform(Transformer transformer) => transformer.transformDynamicModifier(this); + shared actual void visit(Visitor visitor) + => visitor.visitDynamicModifier(this); + shared actual Boolean equals(Object that) { if (is DynamicModifier that) { return text == that.text; diff --git a/source/ceylon/ast/core/DynamicValue.ceylon b/source/ceylon/ast/core/DynamicValue.ceylon index 541a4611..2ec25a4e 100644 --- a/source/ceylon/ast/core/DynamicValue.ceylon +++ b/source/ceylon/ast/core/DynamicValue.ceylon @@ -23,6 +23,9 @@ shared class DynamicValue(namedArguments = [], iterableArgument = ArgumentList() shared actual Result transform(Transformer transformer) => transformer.transformDynamicValue(this); + shared actual void visit(Visitor visitor) + => visitor.visitDynamicValue(this); + shared actual Boolean equals(Object that) { if (is DynamicValue that) { return namedArguments == that.namedArguments && iterableArgument == that.iterableArgument && modifier == that.modifier; diff --git a/source/ceylon/ast/core/ElementOrSubrangeExpression.ceylon b/source/ceylon/ast/core/ElementOrSubrangeExpression.ceylon index 5f63699f..d3cb2634 100644 --- a/source/ceylon/ast/core/ElementOrSubrangeExpression.ceylon +++ b/source/ceylon/ast/core/ElementOrSubrangeExpression.ceylon @@ -24,6 +24,9 @@ shared class ElementOrSubrangeExpression(primary, subscript) shared actual Result transform(Transformer transformer) => transformer.transformElementOrSubrangeExpression(this); + shared actual void visit(Visitor visitor) + => visitor.visitElementOrSubrangeExpression(this); + shared actual Boolean equals(Object that) { if (is ElementOrSubrangeExpression that) { return primary == that.primary && subscript == that.subscript; diff --git a/source/ceylon/ast/core/ElseClause.ceylon b/source/ceylon/ast/core/ElseClause.ceylon index 881c1216..600f3dac 100644 --- a/source/ceylon/ast/core/ElseClause.ceylon +++ b/source/ceylon/ast/core/ElseClause.ceylon @@ -22,6 +22,9 @@ shared class ElseClause(child) shared actual Result transform(Transformer transformer) => transformer.transformElseClause(this); + shared actual void visit(Visitor visitor) + => visitor.visitElseClause(this); + shared actual Boolean equals(Object that) { if (is ElseClause that) { return child == that.child; diff --git a/source/ceylon/ast/core/ElseOperation.ceylon b/source/ceylon/ast/core/ElseOperation.ceylon index fdd6e5e4..fd887a95 100644 --- a/source/ceylon/ast/core/ElseOperation.ceylon +++ b/source/ceylon/ast/core/ElseOperation.ceylon @@ -28,6 +28,9 @@ shared class ElseOperation(optionalValue, defaultValue) shared actual Result transform(Transformer transformer) => transformer.transformElseOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitElseOperation(this); + shared actual Boolean equals(Object that) { if (is ElseOperation that) { return leftOperand == that.leftOperand && rightOperand == that.rightOperand; diff --git a/source/ceylon/ast/core/EntryOperation.ceylon b/source/ceylon/ast/core/EntryOperation.ceylon index 765388e4..65b81f1d 100644 --- a/source/ceylon/ast/core/EntryOperation.ceylon +++ b/source/ceylon/ast/core/EntryOperation.ceylon @@ -28,6 +28,9 @@ shared class EntryOperation(key, item) shared actual Result transform(Transformer transformer) => transformer.transformEntryOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitEntryOperation(this); + shared actual Boolean equals(Object that) { if (is EntryOperation that) { return leftOperand == that.leftOperand && rightOperand == that.rightOperand; diff --git a/source/ceylon/ast/core/EntryPattern.ceylon b/source/ceylon/ast/core/EntryPattern.ceylon index aa14510f..f68303b7 100644 --- a/source/ceylon/ast/core/EntryPattern.ceylon +++ b/source/ceylon/ast/core/EntryPattern.ceylon @@ -21,6 +21,9 @@ shared class EntryPattern(key, item) shared actual Result transform(Transformer transformer) => transformer.transformEntryPattern(this); + shared actual void visit(Visitor visitor) + => visitor.visitEntryPattern(this); + shared actual Boolean equals(Object that) { if (is EntryPattern that) { return key == that.key && item == that.item; diff --git a/source/ceylon/ast/core/EntryType.ceylon b/source/ceylon/ast/core/EntryType.ceylon index 8ba1468c..77d2bd68 100644 --- a/source/ceylon/ast/core/EntryType.ceylon +++ b/source/ceylon/ast/core/EntryType.ceylon @@ -20,6 +20,9 @@ shared class EntryType(key, item) shared actual Result transform(Transformer transformer) => transformer.transformEntryType(this); + shared actual void visit(Visitor visitor) + => visitor.visitEntryType(this); + shared actual Boolean equals(Object that) { if (is EntryType that) { return key == that.key && item == that.item; diff --git a/source/ceylon/ast/core/EqualOperation.ceylon b/source/ceylon/ast/core/EqualOperation.ceylon index 20a0b4e3..d52ddd95 100644 --- a/source/ceylon/ast/core/EqualOperation.ceylon +++ b/source/ceylon/ast/core/EqualOperation.ceylon @@ -20,6 +20,9 @@ shared class EqualOperation(leftOperand, rightOperand) shared actual Result transform(Transformer transformer) => transformer.transformEqualOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitEqualOperation(this); + shared actual Boolean equals(Object that) { if (is EqualOperation that) { return leftOperand == that.leftOperand && rightOperand == that.rightOperand; diff --git a/source/ceylon/ast/core/ExistsCondition.ceylon b/source/ceylon/ast/core/ExistsCondition.ceylon index c3e16966..64ffd410 100644 --- a/source/ceylon/ast/core/ExistsCondition.ceylon +++ b/source/ceylon/ast/core/ExistsCondition.ceylon @@ -21,6 +21,9 @@ shared class ExistsCondition(tested, negated = false) shared actual Result transform(Transformer transformer) => transformer.transformExistsCondition(this); + shared actual void visit(Visitor visitor) + => visitor.visitExistsCondition(this); + shared actual Boolean equals(Object that) { if (is ExistsCondition that) { return tested == that.tested && negated == that.negated; diff --git a/source/ceylon/ast/core/ExistsOperation.ceylon b/source/ceylon/ast/core/ExistsOperation.ceylon index d0f46cd5..f41dde07 100644 --- a/source/ceylon/ast/core/ExistsOperation.ceylon +++ b/source/ceylon/ast/core/ExistsOperation.ceylon @@ -21,6 +21,9 @@ shared class ExistsOperation(operand) shared actual Result transform(Transformer transformer) => transformer.transformExistsOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitExistsOperation(this); + shared actual Boolean equals(Object that) { if (is ExistsOperation that) { return operand == that.operand; diff --git a/source/ceylon/ast/core/ExponentiationOperation.ceylon b/source/ceylon/ast/core/ExponentiationOperation.ceylon index e4ed4b38..9e9a6400 100644 --- a/source/ceylon/ast/core/ExponentiationOperation.ceylon +++ b/source/ceylon/ast/core/ExponentiationOperation.ceylon @@ -28,6 +28,9 @@ shared class ExponentiationOperation(base, exponent) shared actual Result transform(Transformer transformer) => transformer.transformExponentiationOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitExponentiationOperation(this); + shared actual Boolean equals(Object that) { if (is ExponentiationOperation that) { return leftOperand == that.leftOperand && rightOperand == that.rightOperand; diff --git a/source/ceylon/ast/core/ExpressionComprehensionClause.ceylon b/source/ceylon/ast/core/ExpressionComprehensionClause.ceylon index 10c5cc83..ff40abb8 100644 --- a/source/ceylon/ast/core/ExpressionComprehensionClause.ceylon +++ b/source/ceylon/ast/core/ExpressionComprehensionClause.ceylon @@ -15,6 +15,9 @@ shared class ExpressionComprehensionClause(expression) shared actual Result transform(Transformer transformer) => transformer.transformExpressionComprehensionClause(this); + shared actual void visit(Visitor visitor) + => visitor.visitExpressionComprehensionClause(this); + shared actual Boolean equals(Object that) { if (is ExpressionComprehensionClause that) { return expression == that.expression; diff --git a/source/ceylon/ast/core/ExtendedType.ceylon b/source/ceylon/ast/core/ExtendedType.ceylon index ab89cd6a..e239f113 100644 --- a/source/ceylon/ast/core/ExtendedType.ceylon +++ b/source/ceylon/ast/core/ExtendedType.ceylon @@ -17,6 +17,9 @@ shared class ExtendedType(target) shared actual Result transform(Transformer transformer) => transformer.transformExtendedType(this); + shared actual void visit(Visitor visitor) + => visitor.visitExtendedType(this); + shared actual Boolean equals(Object that) { if (is ExtendedType that) { return target == that.target; diff --git a/source/ceylon/ast/core/Extension.ceylon b/source/ceylon/ast/core/Extension.ceylon index b18339cd..92ba8a36 100644 --- a/source/ceylon/ast/core/Extension.ceylon +++ b/source/ceylon/ast/core/Extension.ceylon @@ -30,6 +30,9 @@ shared class Extension(nameAndArgs, arguments, qualifier = null) shared actual Result transform(Transformer transformer) => transformer.transformExtension(this); + shared actual void visit(Visitor visitor) + => visitor.visitExtension(this); + shared actual Boolean equals(Object that) { if (is Extension that) { if (exists arguments) { diff --git a/source/ceylon/ast/core/FailClause.ceylon b/source/ceylon/ast/core/FailClause.ceylon index 3368f49d..546189b0 100644 --- a/source/ceylon/ast/core/FailClause.ceylon +++ b/source/ceylon/ast/core/FailClause.ceylon @@ -15,6 +15,9 @@ shared class FailClause(block) shared actual Result transform(Transformer transformer) => transformer.transformFailClause(this); + shared actual void visit(Visitor visitor) + => visitor.visitFailClause(this); + shared actual Boolean equals(Object that) { if (is FailClause that) { return block == that.block; diff --git a/source/ceylon/ast/core/FinallyClause.ceylon b/source/ceylon/ast/core/FinallyClause.ceylon index f88c84b6..b3fcc061 100644 --- a/source/ceylon/ast/core/FinallyClause.ceylon +++ b/source/ceylon/ast/core/FinallyClause.ceylon @@ -15,6 +15,9 @@ shared class FinallyClause(block) shared actual Result transform(Transformer transformer) => transformer.transformFinallyClause(this); + shared actual void visit(Visitor visitor) + => visitor.visitFinallyClause(this); + shared actual Boolean equals(Object that) { if (is FinallyClause that) { return block == that.block; diff --git a/source/ceylon/ast/core/FloatLiteral.ceylon b/source/ceylon/ast/core/FloatLiteral.ceylon index a63e9eba..2d9191a1 100644 --- a/source/ceylon/ast/core/FloatLiteral.ceylon +++ b/source/ceylon/ast/core/FloatLiteral.ceylon @@ -14,6 +14,9 @@ shared class FloatLiteral(text) extends Literal(text) { shared actual Result transform(Transformer transformer) => transformer.transformFloatLiteral(this); + shared actual void visit(Visitor visitor) + => visitor.visitFloatLiteral(this); + "Float literals are considered equal iff their [[texts|text]] are equal. Two literals with the same float values but different representations (grouping, magnitude, leading and/or trailing zeroes, and/or radix differ) are considered different." diff --git a/source/ceylon/ast/core/ForClause.ceylon b/source/ceylon/ast/core/ForClause.ceylon index 94fe23c2..0f01d8c0 100644 --- a/source/ceylon/ast/core/ForClause.ceylon +++ b/source/ceylon/ast/core/ForClause.ceylon @@ -22,6 +22,9 @@ shared class ForClause(iterator, block) shared actual Result transform(Transformer transformer) => transformer.transformForClause(this); + shared actual void visit(Visitor visitor) + => visitor.visitForClause(this); + shared actual Boolean equals(Object that) { if (is ForClause that) { return iterator == that.iterator && block == that.block; diff --git a/source/ceylon/ast/core/ForComprehensionClause.ceylon b/source/ceylon/ast/core/ForComprehensionClause.ceylon index 6c45adb8..22f44771 100644 --- a/source/ceylon/ast/core/ForComprehensionClause.ceylon +++ b/source/ceylon/ast/core/ForComprehensionClause.ceylon @@ -20,6 +20,9 @@ shared class ForComprehensionClause(iterator, clause) shared actual Result transform(Transformer transformer) => transformer.transformForComprehensionClause(this); + shared actual void visit(Visitor visitor) + => visitor.visitForComprehensionClause(this); + shared actual Boolean equals(Object that) { if (is ForComprehensionClause that) { return iterator == that.iterator && clause == that.clause; diff --git a/source/ceylon/ast/core/ForFail.ceylon b/source/ceylon/ast/core/ForFail.ceylon index 4425db6e..eee57076 100644 --- a/source/ceylon/ast/core/ForFail.ceylon +++ b/source/ceylon/ast/core/ForFail.ceylon @@ -28,6 +28,9 @@ shared class ForFail(forClause, failClause = null) shared actual Result transform(Transformer transformer) => transformer.transformForFail(this); + shared actual void visit(Visitor visitor) + => visitor.visitForFail(this); + shared actual Boolean equals(Object that) { if (is ForFail that) { if (exists failClause) { diff --git a/source/ceylon/ast/core/ForIterator.ceylon b/source/ceylon/ast/core/ForIterator.ceylon index 9c88a899..1d885286 100644 --- a/source/ceylon/ast/core/ForIterator.ceylon +++ b/source/ceylon/ast/core/ForIterator.ceylon @@ -18,6 +18,9 @@ shared class ForIterator(pattern, iterated) shared actual Result transform(Transformer transformer) => transformer.transformForIterator(this); + shared actual void visit(Visitor visitor) + => visitor.visitForIterator(this); + shared actual Boolean equals(Object that) { if (is ForIterator that) { return pattern == that.pattern && iterated == that.iterated; diff --git a/source/ceylon/ast/core/FullPackageName.ceylon b/source/ceylon/ast/core/FullPackageName.ceylon index 1a6ea28e..fb6c56e8 100644 --- a/source/ceylon/ast/core/FullPackageName.ceylon +++ b/source/ceylon/ast/core/FullPackageName.ceylon @@ -17,6 +17,9 @@ shared class FullPackageName(components) shared actual Result transform(Transformer transformer) => transformer.transformFullPackageName(this); + shared actual void visit(Visitor visitor) + => visitor.visitFullPackageName(this); + shared actual Boolean equals(Object that) { if (is FullPackageName that) { return components == that.components; diff --git a/source/ceylon/ast/core/FunctionArgument.ceylon b/source/ceylon/ast/core/FunctionArgument.ceylon index 2844d2ec..16bc4317 100644 --- a/source/ceylon/ast/core/FunctionArgument.ceylon +++ b/source/ceylon/ast/core/FunctionArgument.ceylon @@ -35,6 +35,9 @@ shared class FunctionArgument(name, type, parameterLists, definition) shared actual Result transform(Transformer transformer) => transformer.transformFunctionArgument(this); + shared actual void visit(Visitor visitor) + => visitor.visitFunctionArgument(this); + shared actual Boolean equals(Object that) { if (is FunctionArgument that) { return name == that.name && type == that.type && parameterLists == that.parameterLists && definition == that.definition; diff --git a/source/ceylon/ast/core/FunctionDec.ceylon b/source/ceylon/ast/core/FunctionDec.ceylon index 1b3edf22..fd2960cf 100644 --- a/source/ceylon/ast/core/FunctionDec.ceylon +++ b/source/ceylon/ast/core/FunctionDec.ceylon @@ -19,6 +19,9 @@ shared class FunctionDec(name, qualifier = DecQualifier()) shared actual Result transform(Transformer transformer) => transformer.transformFunctionDec(this); + shared actual void visit(Visitor visitor) + => visitor.visitFunctionDec(this); + shared actual Boolean equals(Object that) { if (is FunctionDec that) { return name == that.name && qualifier == that.qualifier; diff --git a/source/ceylon/ast/core/FunctionDeclaration.ceylon b/source/ceylon/ast/core/FunctionDeclaration.ceylon index 578d2136..c98307d6 100644 --- a/source/ceylon/ast/core/FunctionDeclaration.ceylon +++ b/source/ceylon/ast/core/FunctionDeclaration.ceylon @@ -40,6 +40,9 @@ shared class FunctionDeclaration(name, type, parameterLists, typeParameters = nu shared actual Result transform(Transformer transformer) => transformer.transformFunctionDeclaration(this); + shared actual void visit(Visitor visitor) + => visitor.visitFunctionDeclaration(this); + shared actual Boolean equals(Object that) { if (is FunctionDeclaration that) { if (exists typeParameters) { diff --git a/source/ceylon/ast/core/FunctionDefinition.ceylon b/source/ceylon/ast/core/FunctionDefinition.ceylon index 49a812b1..3ce1721e 100644 --- a/source/ceylon/ast/core/FunctionDefinition.ceylon +++ b/source/ceylon/ast/core/FunctionDefinition.ceylon @@ -36,6 +36,9 @@ shared class FunctionDefinition(name, type, parameterLists, definition, typePara shared actual Result transform(Transformer transformer) => transformer.transformFunctionDefinition(this); + shared actual void visit(Visitor visitor) + => visitor.visitFunctionDefinition(this); + shared actual Boolean equals(Object that) { if (is FunctionDefinition that) { if (exists typeParameters) { diff --git a/source/ceylon/ast/core/FunctionExpression.ceylon b/source/ceylon/ast/core/FunctionExpression.ceylon index 42250c44..ee9a695a 100644 --- a/source/ceylon/ast/core/FunctionExpression.ceylon +++ b/source/ceylon/ast/core/FunctionExpression.ceylon @@ -28,6 +28,9 @@ shared class FunctionExpression(parameterLists, definition, type = null) shared actual Result transform(Transformer transformer) => transformer.transformFunctionExpression(this); + shared actual void visit(Visitor visitor) + => visitor.visitFunctionExpression(this); + shared actual Boolean equals(Object that) { if (is FunctionExpression that) { if (exists type) { diff --git a/source/ceylon/ast/core/FunctionModifier.ceylon b/source/ceylon/ast/core/FunctionModifier.ceylon index 87d50810..bf5f32d0 100644 --- a/source/ceylon/ast/core/FunctionModifier.ceylon +++ b/source/ceylon/ast/core/FunctionModifier.ceylon @@ -10,6 +10,9 @@ shared class FunctionModifier() shared actual Result transform(Transformer transformer) => transformer.transformFunctionModifier(this); + shared actual void visit(Visitor visitor) + => visitor.visitFunctionModifier(this); + shared actual Boolean equals(Object that) { return that is FunctionModifier; } diff --git a/source/ceylon/ast/core/FunctionShortcutDefinition.ceylon b/source/ceylon/ast/core/FunctionShortcutDefinition.ceylon index 8a5ce91f..6703e47d 100644 --- a/source/ceylon/ast/core/FunctionShortcutDefinition.ceylon +++ b/source/ceylon/ast/core/FunctionShortcutDefinition.ceylon @@ -29,6 +29,9 @@ shared class FunctionShortcutDefinition(name, type, parameterLists, definition, shared actual Result transform(Transformer transformer) => transformer.transformFunctionShortcutDefinition(this); + shared actual void visit(Visitor visitor) + => visitor.visitFunctionShortcutDefinition(this); + shared actual Boolean equals(Object that) { if (is FunctionShortcutDefinition that) { if (exists typeParameters) { diff --git a/source/ceylon/ast/core/GivenDec.ceylon b/source/ceylon/ast/core/GivenDec.ceylon index fba9dcaf..f4100fa2 100644 --- a/source/ceylon/ast/core/GivenDec.ceylon +++ b/source/ceylon/ast/core/GivenDec.ceylon @@ -18,6 +18,9 @@ shared class GivenDec(name, qualifier = DecQualifier()) shared actual Result transform(Transformer transformer) => transformer.transformGivenDec(this); + shared actual void visit(Visitor visitor) + => visitor.visitGivenDec(this); + shared actual Boolean equals(Object that) { if (is GivenDec that) { return name == that.name && qualifier == that.qualifier; diff --git a/source/ceylon/ast/core/GroupedExpression.ceylon b/source/ceylon/ast/core/GroupedExpression.ceylon index 67a8c7b8..fe52ca13 100644 --- a/source/ceylon/ast/core/GroupedExpression.ceylon +++ b/source/ceylon/ast/core/GroupedExpression.ceylon @@ -15,6 +15,9 @@ shared class GroupedExpression(innerExpression) shared actual Result transform(Transformer transformer) => transformer.transformGroupedExpression(this); + shared actual void visit(Visitor visitor) + => visitor.visitGroupedExpression(this); + shared actual Boolean equals(Object that) { if (is GroupedExpression that) { return innerExpression == that.innerExpression; diff --git a/source/ceylon/ast/core/GroupedType.ceylon b/source/ceylon/ast/core/GroupedType.ceylon index 296e27f7..5fa08536 100644 --- a/source/ceylon/ast/core/GroupedType.ceylon +++ b/source/ceylon/ast/core/GroupedType.ceylon @@ -24,6 +24,9 @@ shared class GroupedType(type) shared actual Result transform(Transformer transformer) => transformer.transformGroupedType(this); + shared actual void visit(Visitor visitor) + => visitor.visitGroupedType(this); + shared actual Boolean equals(Object that) { if (is GroupedType that) { return type == that.type; diff --git a/source/ceylon/ast/core/IdenticalOperation.ceylon b/source/ceylon/ast/core/IdenticalOperation.ceylon index eef9a5ab..33a89f1d 100644 --- a/source/ceylon/ast/core/IdenticalOperation.ceylon +++ b/source/ceylon/ast/core/IdenticalOperation.ceylon @@ -19,6 +19,9 @@ shared class IdenticalOperation(leftOperand, rightOperand) shared actual Result transform(Transformer transformer) => transformer.transformIdenticalOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitIdenticalOperation(this); + shared actual Boolean equals(Object that) { if (is IdenticalOperation that) { return leftOperand == that.leftOperand && rightOperand == that.rightOperand; diff --git a/source/ceylon/ast/core/Identifier.ceylon b/source/ceylon/ast/core/Identifier.ceylon index c9ce76a6..8cda5a4c 100644 --- a/source/ceylon/ast/core/Identifier.ceylon +++ b/source/ceylon/ast/core/Identifier.ceylon @@ -72,6 +72,9 @@ shared class LIdentifier(String name, Boolean usePrefix = false) extends Identif shared actual Result transform(Transformer transformer) => transformer.transformLIdentifier(this); + shared actual void visit(Visitor visitor) + => visitor.visitLIdentifier(this); + shared actual Boolean equals(Object that) { if (is LIdentifier that) { return name == that.name; @@ -104,6 +107,9 @@ shared class UIdentifier(String name, Boolean usePrefix = false) extends Identif shared actual Result transform(Transformer transformer) => transformer.transformUIdentifier(this); + shared actual void visit(Visitor visitor) + => visitor.visitUIdentifier(this); + shared actual Boolean equals(Object that) { if (is UIdentifier that) { return name == that.name; diff --git a/source/ceylon/ast/core/IdentityOperation.ceylon b/source/ceylon/ast/core/IdentityOperation.ceylon index 02df456f..ec8ccb18 100644 --- a/source/ceylon/ast/core/IdentityOperation.ceylon +++ b/source/ceylon/ast/core/IdentityOperation.ceylon @@ -16,6 +16,9 @@ shared class IdentityOperation(operand) shared actual Result transform(Transformer transformer) => transformer.transformIdentityOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitIdentityOperation(this); + shared actual Boolean equals(Object that) { if (is IdentityOperation that) { return operand == that.operand; diff --git a/source/ceylon/ast/core/IfClause.ceylon b/source/ceylon/ast/core/IfClause.ceylon index 5290fefd..886df979 100644 --- a/source/ceylon/ast/core/IfClause.ceylon +++ b/source/ceylon/ast/core/IfClause.ceylon @@ -17,6 +17,9 @@ shared class IfClause(conditions, block) shared actual Result transform(Transformer transformer) => transformer.transformIfClause(this); + shared actual void visit(Visitor visitor) + => visitor.visitIfClause(this); + shared actual Boolean equals(Object that) { if (is IfClause that) { return conditions == that.conditions && block == that.block; diff --git a/source/ceylon/ast/core/IfComprehensionClause.ceylon b/source/ceylon/ast/core/IfComprehensionClause.ceylon index 520acece..1f7a00e2 100644 --- a/source/ceylon/ast/core/IfComprehensionClause.ceylon +++ b/source/ceylon/ast/core/IfComprehensionClause.ceylon @@ -20,6 +20,9 @@ shared class IfComprehensionClause(conditions, clause) shared actual Result transform(Transformer transformer) => transformer.transformIfComprehensionClause(this); + shared actual void visit(Visitor visitor) + => visitor.visitIfComprehensionClause(this); + shared actual Boolean equals(Object that) { if (is IfComprehensionClause that) { return conditions == that.conditions && clause == that.clause; diff --git a/source/ceylon/ast/core/IfElse.ceylon b/source/ceylon/ast/core/IfElse.ceylon index bf0114e9..2d2f503d 100644 --- a/source/ceylon/ast/core/IfElse.ceylon +++ b/source/ceylon/ast/core/IfElse.ceylon @@ -37,6 +37,9 @@ shared class IfElse(ifClause, elseClause) shared actual Result transform(Transformer transformer) => transformer.transformIfElse(this); + shared actual void visit(Visitor visitor) + => visitor.visitIfElse(this); + shared actual Boolean equals(Object that) { if (is IfElse that) { if (exists elseClause) { diff --git a/source/ceylon/ast/core/IfElseExpression.ceylon b/source/ceylon/ast/core/IfElseExpression.ceylon index 51fa2c1a..3156150e 100644 --- a/source/ceylon/ast/core/IfElseExpression.ceylon +++ b/source/ceylon/ast/core/IfElseExpression.ceylon @@ -34,6 +34,9 @@ shared class IfElseExpression(conditions, thenExpression, elseExpression) shared actual Result transform(Transformer transformer) => transformer.transformIfElseExpression(this); + shared actual void visit(Visitor visitor) + => visitor.visitIfElseExpression(this); + shared actual Boolean equals(Object that) { if (is IfElseExpression that) { return conditions == that.conditions && thenExpression == that.thenExpression && elseExpression == that.elseExpression; diff --git a/source/ceylon/ast/core/Import.ceylon b/source/ceylon/ast/core/Import.ceylon index b318c4d1..e38eafa0 100644 --- a/source/ceylon/ast/core/Import.ceylon +++ b/source/ceylon/ast/core/Import.ceylon @@ -19,6 +19,9 @@ shared class Import(packageName, elements) shared actual Result transform(Transformer transformer) => transformer.transformImport(this); + shared actual void visit(Visitor visitor) + => visitor.visitImport(this); + shared actual Boolean equals(Object that) { if (is Import that) { return packageName == that.packageName && elements == that.elements; diff --git a/source/ceylon/ast/core/ImportElements.ceylon b/source/ceylon/ast/core/ImportElements.ceylon index e146bb62..f0620d7e 100644 --- a/source/ceylon/ast/core/ImportElements.ceylon +++ b/source/ceylon/ast/core/ImportElements.ceylon @@ -29,6 +29,9 @@ shared class ImportElements(elements = [], wildcard = null) shared actual Result transform(Transformer transformer) => transformer.transformImportElements(this); + shared actual void visit(Visitor visitor) + => visitor.visitImportElements(this); + shared actual Boolean equals(Object that) { if (is ImportElements that) { if (exists wildcard) { diff --git a/source/ceylon/ast/core/ImportFunctionValueAlias.ceylon b/source/ceylon/ast/core/ImportFunctionValueAlias.ceylon index 4a040be5..f6038631 100644 --- a/source/ceylon/ast/core/ImportFunctionValueAlias.ceylon +++ b/source/ceylon/ast/core/ImportFunctionValueAlias.ceylon @@ -15,6 +15,9 @@ shared class ImportFunctionValueAlias(name) shared actual Result transform(Transformer transformer) => transformer.transformImportFunctionValueAlias(this); + shared actual void visit(Visitor visitor) + => visitor.visitImportFunctionValueAlias(this); + shared actual Boolean equals(Object that) { if (is ImportFunctionValueAlias that) { return name == that.name; diff --git a/source/ceylon/ast/core/ImportFunctionValueElement.ceylon b/source/ceylon/ast/core/ImportFunctionValueElement.ceylon index 3f7a807d..d9f3148e 100644 --- a/source/ceylon/ast/core/ImportFunctionValueElement.ceylon +++ b/source/ceylon/ast/core/ImportFunctionValueElement.ceylon @@ -41,6 +41,9 @@ shared class ImportFunctionValueElement(name, importAlias = null, nestedImports shared actual Result transform(Transformer transformer) => transformer.transformImportFunctionValueElement(this); + shared actual void visit(Visitor visitor) + => visitor.visitImportFunctionValueElement(this); + shared actual Boolean equals(Object that) { if (is ImportFunctionValueElement that) { if (exists importAlias) { diff --git a/source/ceylon/ast/core/ImportTypeAlias.ceylon b/source/ceylon/ast/core/ImportTypeAlias.ceylon index 1f5f6294..e8ad17f4 100644 --- a/source/ceylon/ast/core/ImportTypeAlias.ceylon +++ b/source/ceylon/ast/core/ImportTypeAlias.ceylon @@ -15,6 +15,9 @@ shared class ImportTypeAlias(name) shared actual Result transform(Transformer transformer) => transformer.transformImportTypeAlias(this); + shared actual void visit(Visitor visitor) + => visitor.visitImportTypeAlias(this); + shared actual Boolean equals(Object that) { if (is ImportTypeAlias that) { return name == that.name; diff --git a/source/ceylon/ast/core/ImportTypeElement.ceylon b/source/ceylon/ast/core/ImportTypeElement.ceylon index 6f73a7fd..af2500fc 100644 --- a/source/ceylon/ast/core/ImportTypeElement.ceylon +++ b/source/ceylon/ast/core/ImportTypeElement.ceylon @@ -36,6 +36,9 @@ shared class ImportTypeElement(name, importAlias = null, nestedImports = null) shared actual Result transform(Transformer transformer) => transformer.transformImportTypeElement(this); + shared actual void visit(Visitor visitor) + => visitor.visitImportTypeElement(this); + shared actual Boolean equals(Object that) { if (is ImportTypeElement that) { if (exists importAlias) { diff --git a/source/ceylon/ast/core/ImportWildcard.ceylon b/source/ceylon/ast/core/ImportWildcard.ceylon index ad00de6b..d6555be1 100644 --- a/source/ceylon/ast/core/ImportWildcard.ceylon +++ b/source/ceylon/ast/core/ImportWildcard.ceylon @@ -9,6 +9,9 @@ shared class ImportWildcard() shared actual Result transform(Transformer transformer) => transformer.transformImportWildcard(this); + shared actual void visit(Visitor visitor) + => visitor.visitImportWildcard(this); + shared actual Boolean equals(Object that) { return that is ImportWildcard; } diff --git a/source/ceylon/ast/core/InModifier.ceylon b/source/ceylon/ast/core/InModifier.ceylon index f6ead560..c4536831 100644 --- a/source/ceylon/ast/core/InModifier.ceylon +++ b/source/ceylon/ast/core/InModifier.ceylon @@ -7,6 +7,9 @@ shared class InModifier() shared actual Result transform(Transformer transformer) => transformer.transformInModifier(this); + shared actual void visit(Visitor visitor) + => visitor.visitInModifier(this); + shared actual Boolean equals(Object that) { return that is InModifier; } diff --git a/source/ceylon/ast/core/InOperation.ceylon b/source/ceylon/ast/core/InOperation.ceylon index 0a9948d8..caeb7cce 100644 --- a/source/ceylon/ast/core/InOperation.ceylon +++ b/source/ceylon/ast/core/InOperation.ceylon @@ -41,6 +41,9 @@ shared class InOperation(element, category) shared actual Result transform(Transformer transformer) => transformer.transformInOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitInOperation(this); + shared actual Boolean equals(Object that) { if (is InOperation that) { return leftOperand == that.leftOperand && rightOperand == that.rightOperand; diff --git a/source/ceylon/ast/core/IntegerLiteral.ceylon b/source/ceylon/ast/core/IntegerLiteral.ceylon index d64ba74b..5af6f4be 100644 --- a/source/ceylon/ast/core/IntegerLiteral.ceylon +++ b/source/ceylon/ast/core/IntegerLiteral.ceylon @@ -15,6 +15,9 @@ shared class IntegerLiteral(text) extends Literal(text) { shared actual Result transform(Transformer transformer) => transformer.transformIntegerLiteral(this); + shared actual void visit(Visitor visitor) + => visitor.visitIntegerLiteral(this); + "Integer literals are considered equal iff their [[texts|text]] are equal. Two literals with the same integer values but different representations (grouping, magnitude, leading zeroes, and/or radix differ) are considered different." diff --git a/source/ceylon/ast/core/InterfaceAliasDefinition.ceylon b/source/ceylon/ast/core/InterfaceAliasDefinition.ceylon index fdb76104..7003b56a 100644 --- a/source/ceylon/ast/core/InterfaceAliasDefinition.ceylon +++ b/source/ceylon/ast/core/InterfaceAliasDefinition.ceylon @@ -53,6 +53,9 @@ shared class InterfaceAliasDefinition(name, specifier, caseTypes = null, satisfi shared actual Result transform(Transformer transformer) => transformer.transformInterfaceAliasDefinition(this); + shared actual void visit(Visitor visitor) + => visitor.visitInterfaceAliasDefinition(this); + shared actual Boolean equals(Object that) { if (is InterfaceAliasDefinition that) { if (exists caseTypes) { diff --git a/source/ceylon/ast/core/InterfaceBody.ceylon b/source/ceylon/ast/core/InterfaceBody.ceylon index 3957672e..9c71d3c5 100644 --- a/source/ceylon/ast/core/InterfaceBody.ceylon +++ b/source/ceylon/ast/core/InterfaceBody.ceylon @@ -28,6 +28,9 @@ shared class InterfaceBody(content) shared actual Result transform(Transformer transformer) => transformer.transformInterfaceBody(this); + shared actual void visit(Visitor visitor) + => visitor.visitInterfaceBody(this); + shared actual Boolean equals(Object that) { if (is InterfaceBody that) { return content == that.content; diff --git a/source/ceylon/ast/core/InterfaceDec.ceylon b/source/ceylon/ast/core/InterfaceDec.ceylon index dacb43d7..06e6943e 100644 --- a/source/ceylon/ast/core/InterfaceDec.ceylon +++ b/source/ceylon/ast/core/InterfaceDec.ceylon @@ -28,6 +28,9 @@ shared class InterfaceDec(name, qualifier = DecQualifier()) shared actual Result transform(Transformer transformer) => transformer.transformInterfaceDec(this); + shared actual void visit(Visitor visitor) + => visitor.visitInterfaceDec(this); + shared actual Boolean equals(Object that) { if (is InterfaceDec that) { if (exists qualifier) { diff --git a/source/ceylon/ast/core/InterfaceDefinition.ceylon b/source/ceylon/ast/core/InterfaceDefinition.ceylon index ad745626..3a5dbccf 100644 --- a/source/ceylon/ast/core/InterfaceDefinition.ceylon +++ b/source/ceylon/ast/core/InterfaceDefinition.ceylon @@ -54,6 +54,9 @@ shared class InterfaceDefinition(name, body, caseTypes = null, satisfiedTypes = shared actual Result transform(Transformer transformer) => transformer.transformInterfaceDefinition(this); + shared actual void visit(Visitor visitor) + => visitor.visitInterfaceDefinition(this); + shared actual Boolean equals(Object that) { if (is InterfaceDefinition that) { if (exists caseTypes) { diff --git a/source/ceylon/ast/core/IntersectAssignmentOperation.ceylon b/source/ceylon/ast/core/IntersectAssignmentOperation.ceylon index ef81c4ff..3aee2dc7 100644 --- a/source/ceylon/ast/core/IntersectAssignmentOperation.ceylon +++ b/source/ceylon/ast/core/IntersectAssignmentOperation.ceylon @@ -29,6 +29,9 @@ shared class IntersectAssignmentOperation(target, other) shared actual Result transform(Transformer transformer) => transformer.transformIntersectAssignmentOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitIntersectAssignmentOperation(this); + shared actual Boolean equals(Object that) { if (is IntersectAssignmentOperation that) { return leftOperand == that.leftOperand && rightOperand == that.rightOperand; diff --git a/source/ceylon/ast/core/IntersectionOperation.ceylon b/source/ceylon/ast/core/IntersectionOperation.ceylon index ebcc6fa3..adecced1 100644 --- a/source/ceylon/ast/core/IntersectionOperation.ceylon +++ b/source/ceylon/ast/core/IntersectionOperation.ceylon @@ -22,6 +22,9 @@ shared class IntersectionOperation(leftOperand, rightOperand) shared actual Result transform(Transformer transformer) => transformer.transformIntersectionOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitIntersectionOperation(this); + shared actual Boolean equals(Object that) { if (is IntersectionOperation that) { return leftOperand == that.leftOperand && rightOperand == that.rightOperand; diff --git a/source/ceylon/ast/core/IntersectionType.ceylon b/source/ceylon/ast/core/IntersectionType.ceylon index cdee3ee8..a5a5aba2 100644 --- a/source/ceylon/ast/core/IntersectionType.ceylon +++ b/source/ceylon/ast/core/IntersectionType.ceylon @@ -18,6 +18,9 @@ shared class IntersectionType(children) shared actual Result transform(Transformer transformer) => transformer.transformIntersectionType(this); + shared actual void visit(Visitor visitor) + => visitor.visitIntersectionType(this); + shared actual Boolean equals(Object that) { if (is IntersectionType that) { return children == that.children; diff --git a/source/ceylon/ast/core/Invocation.ceylon b/source/ceylon/ast/core/Invocation.ceylon index 61acb432..8c09f3d4 100644 --- a/source/ceylon/ast/core/Invocation.ceylon +++ b/source/ceylon/ast/core/Invocation.ceylon @@ -18,6 +18,9 @@ shared class Invocation(invoked, arguments = PositionalArguments()) shared actual Result transform(Transformer transformer) => transformer.transformInvocation(this); + shared actual void visit(Visitor visitor) + => visitor.visitInvocation(this); + shared actual Boolean equals(Object that) { if (is Invocation that) { return invoked == that.invoked && arguments == that.arguments; diff --git a/source/ceylon/ast/core/InvocationStatement.ceylon b/source/ceylon/ast/core/InvocationStatement.ceylon index 5e888384..cc9094d4 100644 --- a/source/ceylon/ast/core/InvocationStatement.ceylon +++ b/source/ceylon/ast/core/InvocationStatement.ceylon @@ -16,6 +16,9 @@ shared class InvocationStatement(expression) shared actual Result transform(Transformer transformer) => transformer.transformInvocationStatement(this); + shared actual void visit(Visitor visitor) + => visitor.visitInvocationStatement(this); + shared actual Boolean equals(Object that) { if (is InvocationStatement that) { return expression == that.expression; diff --git a/source/ceylon/ast/core/IsCase.ceylon b/source/ceylon/ast/core/IsCase.ceylon index aead87ab..bd7116db 100644 --- a/source/ceylon/ast/core/IsCase.ceylon +++ b/source/ceylon/ast/core/IsCase.ceylon @@ -16,6 +16,9 @@ shared class IsCase(type) shared actual Result transform(Transformer transformer) => transformer.transformIsCase(this); + shared actual void visit(Visitor visitor) + => visitor.visitIsCase(this); + shared actual Boolean equals(Object that) { if (is IsCase that) { return type == that.type; diff --git a/source/ceylon/ast/core/IsCondition.ceylon b/source/ceylon/ast/core/IsCondition.ceylon index 6666cd3a..f1e5673b 100644 --- a/source/ceylon/ast/core/IsCondition.ceylon +++ b/source/ceylon/ast/core/IsCondition.ceylon @@ -22,6 +22,9 @@ shared class IsCondition(variable, negated = false) shared actual Result transform(Transformer transformer) => transformer.transformIsCondition(this); + shared actual void visit(Visitor visitor) + => visitor.visitIsCondition(this); + shared actual Boolean equals(Object that) { if (is IsCondition that) { return variable == that.variable && negated == that.negated; diff --git a/source/ceylon/ast/core/IsOperation.ceylon b/source/ceylon/ast/core/IsOperation.ceylon index 646b83db..2ea41418 100644 --- a/source/ceylon/ast/core/IsOperation.ceylon +++ b/source/ceylon/ast/core/IsOperation.ceylon @@ -21,6 +21,9 @@ shared class IsOperation(operand, type) shared actual Result transform(Transformer transformer) => transformer.transformIsOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitIsOperation(this); + shared actual Boolean equals(Object that) { if (is IsOperation that) { return operand == that.operand && type == that.type; diff --git a/source/ceylon/ast/core/Iterable.ceylon b/source/ceylon/ast/core/Iterable.ceylon index 8b640bb2..fd3b095c 100644 --- a/source/ceylon/ast/core/Iterable.ceylon +++ b/source/ceylon/ast/core/Iterable.ceylon @@ -15,6 +15,9 @@ shared class Iterable(argumentList) shared actual Result transform(Transformer transformer) => transformer.transformIterable(this); + shared actual void visit(Visitor visitor) + => visitor.visitIterable(this); + shared actual Boolean equals(Object that) { if (is Iterable that) { return argumentList == that.argumentList; diff --git a/source/ceylon/ast/core/IterableType.ceylon b/source/ceylon/ast/core/IterableType.ceylon index 397ec975..d792c9e2 100644 --- a/source/ceylon/ast/core/IterableType.ceylon +++ b/source/ceylon/ast/core/IterableType.ceylon @@ -10,6 +10,9 @@ shared class IterableType(variadicType) shared actual Result transform(Transformer transformer) => transformer.transformIterableType(this); + shared actual void visit(Visitor visitor) + => visitor.visitIterableType(this); + shared actual Boolean equals(Object that) { if (is IterableType that) { return variadicType == that.variadicType; diff --git a/source/ceylon/ast/core/KeySubscript.ceylon b/source/ceylon/ast/core/KeySubscript.ceylon index eeb8716d..8cce2047 100644 --- a/source/ceylon/ast/core/KeySubscript.ceylon +++ b/source/ceylon/ast/core/KeySubscript.ceylon @@ -19,6 +19,9 @@ shared class KeySubscript(key) shared actual Result transform(Transformer transformer) => transformer.transformKeySubscript(this); + shared actual void visit(Visitor visitor) + => visitor.visitKeySubscript(this); + shared actual Boolean equals(Object that) { if (is KeySubscript that) { return key == that.key; diff --git a/source/ceylon/ast/core/LargeAsOperation.ceylon b/source/ceylon/ast/core/LargeAsOperation.ceylon index caa30865..88e62f76 100644 --- a/source/ceylon/ast/core/LargeAsOperation.ceylon +++ b/source/ceylon/ast/core/LargeAsOperation.ceylon @@ -16,6 +16,9 @@ shared class LargeAsOperation(leftOperand, rightOperand) shared actual Result transform(Transformer transformer) => transformer.transformLargeAsOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitLargeAsOperation(this); + shared actual Boolean equals(Object that) { if (is LargeAsOperation that) { return leftOperand == that.leftOperand && rightOperand == that.rightOperand; diff --git a/source/ceylon/ast/core/LargerOperation.ceylon b/source/ceylon/ast/core/LargerOperation.ceylon index ad6a1b2b..3b479424 100644 --- a/source/ceylon/ast/core/LargerOperation.ceylon +++ b/source/ceylon/ast/core/LargerOperation.ceylon @@ -16,6 +16,9 @@ shared class LargerOperation(leftOperand, rightOperand) shared actual Result transform(Transformer transformer) => transformer.transformLargerOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitLargerOperation(this); + shared actual Boolean equals(Object that) { if (is LargerOperation that) { return leftOperand == that.leftOperand && rightOperand == that.rightOperand; diff --git a/source/ceylon/ast/core/LazySpecification.ceylon b/source/ceylon/ast/core/LazySpecification.ceylon index 158196bf..374143a8 100644 --- a/source/ceylon/ast/core/LazySpecification.ceylon +++ b/source/ceylon/ast/core/LazySpecification.ceylon @@ -20,6 +20,9 @@ shared class LazySpecification(name, specifier, parameterLists = [], qualifier = shared actual Result transform(Transformer transformer) => transformer.transformLazySpecification(this); + shared actual void visit(Visitor visitor) + => visitor.visitLazySpecification(this); + shared actual Boolean equals(Object that) { if (is LazySpecification that) { if (exists qualifier) { diff --git a/source/ceylon/ast/core/LazySpecifier.ceylon b/source/ceylon/ast/core/LazySpecifier.ceylon index 598d3c35..0dab72f3 100644 --- a/source/ceylon/ast/core/LazySpecifier.ceylon +++ b/source/ceylon/ast/core/LazySpecifier.ceylon @@ -12,6 +12,9 @@ shared class LazySpecifier(expression) shared actual Result transform(Transformer transformer) => transformer.transformLazySpecifier(this); + shared actual void visit(Visitor visitor) + => visitor.visitLazySpecifier(this); + shared actual Boolean equals(Object that) { if (is LazySpecifier that) { return expression == that.expression; diff --git a/source/ceylon/ast/core/LetExpression.ceylon b/source/ceylon/ast/core/LetExpression.ceylon index 6d4918d3..46698fee 100644 --- a/source/ceylon/ast/core/LetExpression.ceylon +++ b/source/ceylon/ast/core/LetExpression.ceylon @@ -25,6 +25,9 @@ shared class LetExpression(patterns, expression) shared actual Result transform(Transformer transformer) => transformer.transformLetExpression(this); + shared actual void visit(Visitor visitor) + => visitor.visitLetExpression(this); + shared actual Boolean equals(Object that) { if (is LetExpression that) { return patterns == that.patterns && expression == that.expression; diff --git a/source/ceylon/ast/core/MatchCase.ceylon b/source/ceylon/ast/core/MatchCase.ceylon index 21026b4d..95be2653 100644 --- a/source/ceylon/ast/core/MatchCase.ceylon +++ b/source/ceylon/ast/core/MatchCase.ceylon @@ -38,6 +38,9 @@ shared class MatchCase(expressions) shared actual Result transform(Transformer transformer) => transformer.transformMatchCase(this); + shared actual void visit(Visitor visitor) + => visitor.visitMatchCase(this); + shared actual Boolean equals(Object that) { if (is MatchCase that) { return expressions == that.expressions; diff --git a/source/ceylon/ast/core/MeasureOperation.ceylon b/source/ceylon/ast/core/MeasureOperation.ceylon index 9dcf98f6..3dfa1286 100644 --- a/source/ceylon/ast/core/MeasureOperation.ceylon +++ b/source/ceylon/ast/core/MeasureOperation.ceylon @@ -28,6 +28,9 @@ shared class MeasureOperation(first, size) shared actual Result transform(Transformer transformer) => transformer.transformMeasureOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitMeasureOperation(this); + shared actual Boolean equals(Object that) { if (is MeasureOperation that) { return leftOperand == that.leftOperand && rightOperand == that.rightOperand; diff --git a/source/ceylon/ast/core/MeasureSubscript.ceylon b/source/ceylon/ast/core/MeasureSubscript.ceylon index a20a5740..ec84832e 100644 --- a/source/ceylon/ast/core/MeasureSubscript.ceylon +++ b/source/ceylon/ast/core/MeasureSubscript.ceylon @@ -24,6 +24,9 @@ shared class MeasureSubscript(from, length) shared actual Result transform(Transformer transformer) => transformer.transformMeasureSubscript(this); + shared actual void visit(Visitor visitor) + => visitor.visitMeasureSubscript(this); + shared actual Boolean equals(Object that) { if (is MeasureSubscript that) { return from == that.from && length == that.length; diff --git a/source/ceylon/ast/core/MemberMeta.ceylon b/source/ceylon/ast/core/MemberMeta.ceylon index 4c694914..056e749a 100644 --- a/source/ceylon/ast/core/MemberMeta.ceylon +++ b/source/ceylon/ast/core/MemberMeta.ceylon @@ -22,6 +22,9 @@ shared class MemberMeta(qualifier, nameAndArgs) shared actual Result transform(Transformer transformer) => transformer.transformMemberMeta(this); + shared actual void visit(Visitor visitor) + => visitor.visitMemberMeta(this); + shared actual Boolean equals(Object that) { if (is MemberMeta that) { return qualifier == that.qualifier && nameAndArgs == that.nameAndArgs; diff --git a/source/ceylon/ast/core/MemberNameWithTypeArguments.ceylon b/source/ceylon/ast/core/MemberNameWithTypeArguments.ceylon index f2c1fca8..c0cce7a4 100644 --- a/source/ceylon/ast/core/MemberNameWithTypeArguments.ceylon +++ b/source/ceylon/ast/core/MemberNameWithTypeArguments.ceylon @@ -11,6 +11,9 @@ shared class MemberNameWithTypeArguments(name, typeArguments = null) shared actual Result transform(Transformer transformer) => transformer.transformMemberNameWithTypeArguments(this); + shared actual void visit(Visitor visitor) + => visitor.visitMemberNameWithTypeArguments(this); + shared actual Boolean equals(Object that) { if (is MemberNameWithTypeArguments that) { if (exists typeArguments) { diff --git a/source/ceylon/ast/core/MemberOperator.ceylon b/source/ceylon/ast/core/MemberOperator.ceylon index 55efbc47..5035c3f0 100644 --- a/source/ceylon/ast/core/MemberOperator.ceylon +++ b/source/ceylon/ast/core/MemberOperator.ceylon @@ -9,6 +9,9 @@ shared class MemberOperator() shared actual Result transform(Transformer transformer) => transformer.transformMemberOperator(this); + shared actual void visit(Visitor visitor) + => visitor.visitMemberOperator(this); + shared actual Boolean equals(Object that) { return that is MemberOperator; } diff --git a/source/ceylon/ast/core/ModuleBody.ceylon b/source/ceylon/ast/core/ModuleBody.ceylon index 25c85e16..72759108 100644 --- a/source/ceylon/ast/core/ModuleBody.ceylon +++ b/source/ceylon/ast/core/ModuleBody.ceylon @@ -20,6 +20,9 @@ shared class ModuleBody(moduleImports = []) shared actual Result transform(Transformer transformer) => transformer.transformModuleBody(this); + shared actual void visit(Visitor visitor) + => visitor.visitModuleBody(this); + shared actual Boolean equals(Object that) { if (is ModuleBody that) { return moduleImports == that.moduleImports; diff --git a/source/ceylon/ast/core/ModuleCompilationUnit.ceylon b/source/ceylon/ast/core/ModuleCompilationUnit.ceylon index e3b2913c..d7d2c244 100644 --- a/source/ceylon/ast/core/ModuleCompilationUnit.ceylon +++ b/source/ceylon/ast/core/ModuleCompilationUnit.ceylon @@ -25,6 +25,9 @@ shared class ModuleCompilationUnit(moduleDescriptor, imports = []) shared actual Result transform(Transformer transformer) => transformer.transformModuleCompilationUnit(this); + shared actual void visit(Visitor visitor) + => visitor.visitModuleCompilationUnit(this); + shared actual Boolean equals(Object that) { if (is ModuleCompilationUnit that) { return moduleDescriptor == that.moduleDescriptor && imports == that.imports; diff --git a/source/ceylon/ast/core/ModuleDec.ceylon b/source/ceylon/ast/core/ModuleDec.ceylon index f4a80f2a..33100a5a 100644 --- a/source/ceylon/ast/core/ModuleDec.ceylon +++ b/source/ceylon/ast/core/ModuleDec.ceylon @@ -21,6 +21,9 @@ shared class ModuleDec(moduleName) shared actual Result transform(Transformer transformer) => transformer.transformModuleDec(this); + shared actual void visit(Visitor visitor) + => visitor.visitModuleDec(this); + shared actual Boolean equals(Object that) { if (is ModuleDec that) { if (exists moduleName) { diff --git a/source/ceylon/ast/core/ModuleDescriptor.ceylon b/source/ceylon/ast/core/ModuleDescriptor.ceylon index dbeb4bbf..01a56999 100644 --- a/source/ceylon/ast/core/ModuleDescriptor.ceylon +++ b/source/ceylon/ast/core/ModuleDescriptor.ceylon @@ -38,6 +38,9 @@ shared class ModuleDescriptor(name, version, body = ModuleBody(), annotations = shared actual Result transform(Transformer transformer) => transformer.transformModuleDescriptor(this); + shared actual void visit(Visitor visitor) + => visitor.visitModuleDescriptor(this); + shared actual Boolean equals(Object that) { if (is ModuleDescriptor that) { return name == that.name && version == that.version && body == that.body && annotations == that.annotations; diff --git a/source/ceylon/ast/core/ModuleImport.ceylon b/source/ceylon/ast/core/ModuleImport.ceylon index efd00f08..b5f4145f 100644 --- a/source/ceylon/ast/core/ModuleImport.ceylon +++ b/source/ceylon/ast/core/ModuleImport.ceylon @@ -26,6 +26,9 @@ shared class ModuleImport(name, version, annotations = Annotations()) shared actual Result transform(Transformer transformer) => transformer.transformModuleImport(this); + shared actual void visit(Visitor visitor) + => visitor.visitModuleImport(this); + shared actual Boolean equals(Object that) { if (is ModuleImport that) { return name == that.name && version == that.version && annotations == that.annotations; diff --git a/source/ceylon/ast/core/MultiplyAssignmentOperation.ceylon b/source/ceylon/ast/core/MultiplyAssignmentOperation.ceylon index e5cec662..16d9df28 100644 --- a/source/ceylon/ast/core/MultiplyAssignmentOperation.ceylon +++ b/source/ceylon/ast/core/MultiplyAssignmentOperation.ceylon @@ -27,6 +27,9 @@ shared class MultiplyAssignmentOperation(target, factor) shared actual Result transform(Transformer transformer) => transformer.transformMultiplyAssignmentOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitMultiplyAssignmentOperation(this); + shared actual Boolean equals(Object that) { if (is MultiplyAssignmentOperation that) { return leftOperand == that.leftOperand && rightOperand == that.rightOperand; diff --git a/source/ceylon/ast/core/NamedArguments.ceylon b/source/ceylon/ast/core/NamedArguments.ceylon index f42d8e75..0d53f56f 100644 --- a/source/ceylon/ast/core/NamedArguments.ceylon +++ b/source/ceylon/ast/core/NamedArguments.ceylon @@ -29,6 +29,9 @@ shared class NamedArguments(namedArguments = [], iterableArgument = ArgumentList shared actual Result transform(Transformer transformer) => transformer.transformNamedArguments(this); + shared actual void visit(Visitor visitor) + => visitor.visitNamedArguments(this); + shared actual Boolean equals(Object that) { if (is NamedArguments that) { return namedArguments == that.namedArguments && iterableArgument == that.iterableArgument; diff --git a/source/ceylon/ast/core/NegationOperation.ceylon b/source/ceylon/ast/core/NegationOperation.ceylon index 607c6b05..d9038059 100644 --- a/source/ceylon/ast/core/NegationOperation.ceylon +++ b/source/ceylon/ast/core/NegationOperation.ceylon @@ -14,6 +14,9 @@ shared class NegationOperation(operand) shared actual Result transform(Transformer transformer) => transformer.transformNegationOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitNegationOperation(this); + shared actual Boolean equals(Object that) { if (is NegationOperation that) { return operand == that.operand; diff --git a/source/ceylon/ast/core/Node.ceylon b/source/ceylon/ast/core/Node.ceylon index 73817313..a3af667a 100644 --- a/source/ceylon/ast/core/Node.ceylon +++ b/source/ceylon/ast/core/Node.ceylon @@ -200,7 +200,7 @@ shared abstract class Node() "Visit this node with the given [[visitor]]. Calls the appropriate `visitX` method on the visitor." - shared void visit(Visitor visitor) => transform(visitor); + shared formal void visit(Visitor visitor); "Visit the children of this node with the given [[visitor]]. Calls [[visit]] on each [[child node|children]]." shared void visitChildren(Visitor visitor) { diff --git a/source/ceylon/ast/core/NonemptyCondition.ceylon b/source/ceylon/ast/core/NonemptyCondition.ceylon index 013106f9..8ff20f48 100644 --- a/source/ceylon/ast/core/NonemptyCondition.ceylon +++ b/source/ceylon/ast/core/NonemptyCondition.ceylon @@ -21,6 +21,9 @@ shared class NonemptyCondition(tested, negated = false) shared actual Result transform(Transformer transformer) => transformer.transformNonemptyCondition(this); + shared actual void visit(Visitor visitor) + => visitor.visitNonemptyCondition(this); + shared actual Boolean equals(Object that) { if (is NonemptyCondition that) { return tested == that.tested && negated == that.negated; diff --git a/source/ceylon/ast/core/NonemptyOperation.ceylon b/source/ceylon/ast/core/NonemptyOperation.ceylon index e8dbf6fe..8da9a7f8 100644 --- a/source/ceylon/ast/core/NonemptyOperation.ceylon +++ b/source/ceylon/ast/core/NonemptyOperation.ceylon @@ -16,6 +16,9 @@ shared class NonemptyOperation(operand) shared actual Result transform(Transformer transformer) => transformer.transformNonemptyOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitNonemptyOperation(this); + shared actual Boolean equals(Object that) { if (is NonemptyOperation that) { return operand == that.operand; diff --git a/source/ceylon/ast/core/NotEqualOperation.ceylon b/source/ceylon/ast/core/NotEqualOperation.ceylon index 0b709e45..a71220fa 100644 --- a/source/ceylon/ast/core/NotEqualOperation.ceylon +++ b/source/ceylon/ast/core/NotEqualOperation.ceylon @@ -19,6 +19,9 @@ shared class NotEqualOperation(leftOperand, rightOperand) shared actual Result transform(Transformer transformer) => transformer.transformNotEqualOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitNotEqualOperation(this); + shared actual Boolean equals(Object that) { if (is NotEqualOperation that) { return leftOperand == that.leftOperand && rightOperand == that.rightOperand; diff --git a/source/ceylon/ast/core/NotOperation.ceylon b/source/ceylon/ast/core/NotOperation.ceylon index d6ec477d..94d63eca 100644 --- a/source/ceylon/ast/core/NotOperation.ceylon +++ b/source/ceylon/ast/core/NotOperation.ceylon @@ -21,6 +21,9 @@ shared class NotOperation(operand) shared actual Result transform(Transformer transformer) => transformer.transformNotOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitNotOperation(this); + shared actual Boolean equals(Object that) { if (is NotOperation that) { return operand == that.operand; diff --git a/source/ceylon/ast/core/ObjectArgument.ceylon b/source/ceylon/ast/core/ObjectArgument.ceylon index a2e8b672..45cd67f6 100644 --- a/source/ceylon/ast/core/ObjectArgument.ceylon +++ b/source/ceylon/ast/core/ObjectArgument.ceylon @@ -34,6 +34,9 @@ shared class ObjectArgument(name, body, extendedType = null, satisfiedTypes = nu shared actual Result transform(Transformer transformer) => transformer.transformObjectArgument(this); + shared actual void visit(Visitor visitor) + => visitor.visitObjectArgument(this); + shared actual Boolean equals(Object that) { if (is ObjectArgument that) { if (exists extendedType) { diff --git a/source/ceylon/ast/core/ObjectDefinition.ceylon b/source/ceylon/ast/core/ObjectDefinition.ceylon index 44be46d6..27388b0d 100644 --- a/source/ceylon/ast/core/ObjectDefinition.ceylon +++ b/source/ceylon/ast/core/ObjectDefinition.ceylon @@ -48,6 +48,9 @@ shared class ObjectDefinition(name, body, extendedType = null, satisfiedTypes = shared actual Result transform(Transformer transformer) => transformer.transformObjectDefinition(this); + shared actual void visit(Visitor visitor) + => visitor.visitObjectDefinition(this); + shared actual Boolean equals(Object that) { if (is ObjectDefinition that) { if (exists extendedType) { diff --git a/source/ceylon/ast/core/ObjectExpression.ceylon b/source/ceylon/ast/core/ObjectExpression.ceylon index ef6d11af..1cadbfda 100644 --- a/source/ceylon/ast/core/ObjectExpression.ceylon +++ b/source/ceylon/ast/core/ObjectExpression.ceylon @@ -21,6 +21,9 @@ shared class ObjectExpression(body, extendedType = null, satisfiedTypes = null) shared actual Result transform(Transformer transformer) => transformer.transformObjectExpression(this); + shared actual void visit(Visitor visitor) + => visitor.visitObjectExpression(this); + shared actual Boolean equals(Object that) { if (is ObjectExpression that) { if (exists extendedType) { diff --git a/source/ceylon/ast/core/OfOperation.ceylon b/source/ceylon/ast/core/OfOperation.ceylon index bfedb56b..b29a5cb4 100644 --- a/source/ceylon/ast/core/OfOperation.ceylon +++ b/source/ceylon/ast/core/OfOperation.ceylon @@ -23,6 +23,9 @@ shared class OfOperation(operand, type) shared actual Result transform(Transformer transformer) => transformer.transformOfOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitOfOperation(this); + shared actual Boolean equals(Object that) { if (is OfOperation that) { return operand == that.operand && type == that.type; diff --git a/source/ceylon/ast/core/OpenBound.ceylon b/source/ceylon/ast/core/OpenBound.ceylon index 17fc2fd5..87a17a2a 100644 --- a/source/ceylon/ast/core/OpenBound.ceylon +++ b/source/ceylon/ast/core/OpenBound.ceylon @@ -16,6 +16,9 @@ shared class OpenBound(endpoint) shared actual Result transform(Transformer transformer) => transformer.transformOpenBound(this); + shared actual void visit(Visitor visitor) + => visitor.visitOpenBound(this); + shared actual Boolean equals(Object that) { if (is OpenBound that) { return endpoint == that.endpoint; diff --git a/source/ceylon/ast/core/OptionalType.ceylon b/source/ceylon/ast/core/OptionalType.ceylon index 983a7fde..fd745c4a 100644 --- a/source/ceylon/ast/core/OptionalType.ceylon +++ b/source/ceylon/ast/core/OptionalType.ceylon @@ -18,6 +18,9 @@ shared class OptionalType(definiteType) shared actual Result transform(Transformer transformer) => transformer.transformOptionalType(this); + shared actual void visit(Visitor visitor) + => visitor.visitOptionalType(this); + shared actual Boolean equals(Object that) { if (is OptionalType that) { return definiteType == that.definiteType; diff --git a/source/ceylon/ast/core/OrAssignmentOperation.ceylon b/source/ceylon/ast/core/OrAssignmentOperation.ceylon index 71ac0234..495d21c5 100644 --- a/source/ceylon/ast/core/OrAssignmentOperation.ceylon +++ b/source/ceylon/ast/core/OrAssignmentOperation.ceylon @@ -29,6 +29,9 @@ shared class OrAssignmentOperation(target, other) shared actual Result transform(Transformer transformer) => transformer.transformOrAssignmentOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitOrAssignmentOperation(this); + shared actual Boolean equals(Object that) { if (is OrAssignmentOperation that) { return leftOperand == that.leftOperand && rightOperand == that.rightOperand; diff --git a/source/ceylon/ast/core/OrOperation.ceylon b/source/ceylon/ast/core/OrOperation.ceylon index d4f8a28e..1bee1f70 100644 --- a/source/ceylon/ast/core/OrOperation.ceylon +++ b/source/ceylon/ast/core/OrOperation.ceylon @@ -20,6 +20,9 @@ shared class OrOperation(leftOperand, rightOperand) shared actual Result transform(Transformer transformer) => transformer.transformOrOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitOrOperation(this); + shared actual Boolean equals(Object that) { if (is OrOperation that) { return leftOperand == that.leftOperand && rightOperand == that.rightOperand; diff --git a/source/ceylon/ast/core/OutModifier.ceylon b/source/ceylon/ast/core/OutModifier.ceylon index d6b5e5c2..f8101897 100644 --- a/source/ceylon/ast/core/OutModifier.ceylon +++ b/source/ceylon/ast/core/OutModifier.ceylon @@ -7,6 +7,9 @@ shared class OutModifier() shared actual Result transform(Transformer transformer) => transformer.transformOutModifier(this); + shared actual void visit(Visitor visitor) + => visitor.visitOutModifier(this); + shared actual Boolean equals(Object that) { return that is OutModifier; } diff --git a/source/ceylon/ast/core/PackageCompilationUnit.ceylon b/source/ceylon/ast/core/PackageCompilationUnit.ceylon index 7b2cee6e..81b898d6 100644 --- a/source/ceylon/ast/core/PackageCompilationUnit.ceylon +++ b/source/ceylon/ast/core/PackageCompilationUnit.ceylon @@ -19,6 +19,9 @@ shared class PackageCompilationUnit(packageDescriptor, imports = []) shared actual Result transform(Transformer transformer) => transformer.transformPackageCompilationUnit(this); + shared actual void visit(Visitor visitor) + => visitor.visitPackageCompilationUnit(this); + shared actual Boolean equals(Object that) { if (is PackageCompilationUnit that) { return packageDescriptor == that.packageDescriptor && imports == that.imports; diff --git a/source/ceylon/ast/core/PackageDec.ceylon b/source/ceylon/ast/core/PackageDec.ceylon index 1bd46217..aa1563fa 100644 --- a/source/ceylon/ast/core/PackageDec.ceylon +++ b/source/ceylon/ast/core/PackageDec.ceylon @@ -21,6 +21,9 @@ shared class PackageDec(packageName) shared actual Result transform(Transformer transformer) => transformer.transformPackageDec(this); + shared actual void visit(Visitor visitor) + => visitor.visitPackageDec(this); + shared actual Boolean equals(Object that) { if (is PackageDec that) { if (exists packageName) { diff --git a/source/ceylon/ast/core/PackageDescriptor.ceylon b/source/ceylon/ast/core/PackageDescriptor.ceylon index 8dcc2b0f..4566357c 100644 --- a/source/ceylon/ast/core/PackageDescriptor.ceylon +++ b/source/ceylon/ast/core/PackageDescriptor.ceylon @@ -20,6 +20,9 @@ shared class PackageDescriptor(name, annotations = Annotations()) shared actual Result transform(Transformer transformer) => transformer.transformPackageDescriptor(this); + shared actual void visit(Visitor visitor) + => visitor.visitPackageDescriptor(this); + shared actual Boolean equals(Object that) { if (is PackageDescriptor that) { return name == that.name && annotations == that.annotations; diff --git a/source/ceylon/ast/core/PackageQualifier.ceylon b/source/ceylon/ast/core/PackageQualifier.ceylon index d5148305..3dfa70c2 100644 --- a/source/ceylon/ast/core/PackageQualifier.ceylon +++ b/source/ceylon/ast/core/PackageQualifier.ceylon @@ -15,6 +15,9 @@ shared class PackageQualifier() shared actual Result transform(Transformer transformer) => transformer.transformPackageQualifier(this); + shared actual void visit(Visitor visitor) + => visitor.visitPackageQualifier(this); + shared actual Boolean equals(Object that) { return that is PackageQualifier; } diff --git a/source/ceylon/ast/core/ParameterReference.ceylon b/source/ceylon/ast/core/ParameterReference.ceylon index 7df807bc..2a95afca 100644 --- a/source/ceylon/ast/core/ParameterReference.ceylon +++ b/source/ceylon/ast/core/ParameterReference.ceylon @@ -28,6 +28,9 @@ shared class ParameterReference(name) shared actual Result transform(Transformer transformer) => transformer.transformParameterReference(this); + shared actual void visit(Visitor visitor) + => visitor.visitParameterReference(this); + shared actual Boolean equals(Object that) { if (is ParameterReference that) { return name == that.name; diff --git a/source/ceylon/ast/core/Parameters.ceylon b/source/ceylon/ast/core/Parameters.ceylon index b8e7d4ca..5ee12f14 100644 --- a/source/ceylon/ast/core/Parameters.ceylon +++ b/source/ceylon/ast/core/Parameters.ceylon @@ -45,6 +45,9 @@ shared class Parameters(parameters = []) shared actual Result transform(Transformer transformer) => transformer.transformParameters(this); + shared actual void visit(Visitor visitor) + => visitor.visitParameters(this); + shared actual Boolean equals(Object that) { if (is Parameters that) { return parameters == that.parameters; diff --git a/source/ceylon/ast/core/PatternList.ceylon b/source/ceylon/ast/core/PatternList.ceylon index ca73acf1..5cbb07e2 100644 --- a/source/ceylon/ast/core/PatternList.ceylon +++ b/source/ceylon/ast/core/PatternList.ceylon @@ -17,6 +17,9 @@ shared class PatternList(patterns) shared actual Result transform(Transformer transformer) => transformer.transformPatternList(this); + shared actual void visit(Visitor visitor) + => visitor.visitPatternList(this); + shared actual Boolean equals(Object that) { if (is PatternList that) { return patterns == that.patterns; diff --git a/source/ceylon/ast/core/PositionalArguments.ceylon b/source/ceylon/ast/core/PositionalArguments.ceylon index ba1d2baf..27ecc0d0 100644 --- a/source/ceylon/ast/core/PositionalArguments.ceylon +++ b/source/ceylon/ast/core/PositionalArguments.ceylon @@ -20,6 +20,9 @@ shared class PositionalArguments(argumentList = ArgumentList()) shared actual Result transform(Transformer transformer) => transformer.transformPositionalArguments(this); + shared actual void visit(Visitor visitor) + => visitor.visitPositionalArguments(this); + shared actual Boolean equals(Object that) { if (is PositionalArguments that) { return argumentList == that.argumentList; diff --git a/source/ceylon/ast/core/PostfixDecrementOperation.ceylon b/source/ceylon/ast/core/PostfixDecrementOperation.ceylon index 6362787f..4706c101 100644 --- a/source/ceylon/ast/core/PostfixDecrementOperation.ceylon +++ b/source/ceylon/ast/core/PostfixDecrementOperation.ceylon @@ -10,6 +10,9 @@ shared class PostfixDecrementOperation(operand) shared actual Result transform(Transformer transformer) => transformer.transformPostfixDecrementOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitPostfixDecrementOperation(this); + shared actual Boolean equals(Object that) { if (is PostfixDecrementOperation that) { return operand == that.operand; diff --git a/source/ceylon/ast/core/PostfixIncrementOperation.ceylon b/source/ceylon/ast/core/PostfixIncrementOperation.ceylon index c6579924..93cc37cf 100644 --- a/source/ceylon/ast/core/PostfixIncrementOperation.ceylon +++ b/source/ceylon/ast/core/PostfixIncrementOperation.ceylon @@ -10,6 +10,9 @@ shared class PostfixIncrementOperation(operand) shared actual Result transform(Transformer transformer) => transformer.transformPostfixIncrementOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitPostfixIncrementOperation(this); + shared actual Boolean equals(Object that) { if (is PostfixIncrementOperation that) { return operand == that.operand; diff --git a/source/ceylon/ast/core/PrefixDecrementOperation.ceylon b/source/ceylon/ast/core/PrefixDecrementOperation.ceylon index 5ea5e2d3..85fdbaf7 100644 --- a/source/ceylon/ast/core/PrefixDecrementOperation.ceylon +++ b/source/ceylon/ast/core/PrefixDecrementOperation.ceylon @@ -10,6 +10,9 @@ shared class PrefixDecrementOperation(operand) shared actual Result transform(Transformer transformer) => transformer.transformPrefixDecrementOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitPrefixDecrementOperation(this); + shared actual Boolean equals(Object that) { if (is PrefixDecrementOperation that) { return operand == that.operand; diff --git a/source/ceylon/ast/core/PrefixIncrementOperation.ceylon b/source/ceylon/ast/core/PrefixIncrementOperation.ceylon index d15988a6..f199e883 100644 --- a/source/ceylon/ast/core/PrefixIncrementOperation.ceylon +++ b/source/ceylon/ast/core/PrefixIncrementOperation.ceylon @@ -10,6 +10,9 @@ shared class PrefixIncrementOperation(operand) shared actual Result transform(Transformer transformer) => transformer.transformPrefixIncrementOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitPrefixIncrementOperation(this); + shared actual Boolean equals(Object that) { if (is PrefixIncrementOperation that) { return operand == that.operand; diff --git a/source/ceylon/ast/core/PrefixPostfixStatement.ceylon b/source/ceylon/ast/core/PrefixPostfixStatement.ceylon index a40fae6e..6b6e9777 100644 --- a/source/ceylon/ast/core/PrefixPostfixStatement.ceylon +++ b/source/ceylon/ast/core/PrefixPostfixStatement.ceylon @@ -14,6 +14,9 @@ shared class PrefixPostfixStatement(expression) shared actual Result transform(Transformer transformer) => transformer.transformPrefixPostfixStatement(this); + shared actual void visit(Visitor visitor) + => visitor.visitPrefixPostfixStatement(this); + shared actual Boolean equals(Object that) { if (is PrefixPostfixStatement that) { return expression == that.expression; diff --git a/source/ceylon/ast/core/ProductOperation.ceylon b/source/ceylon/ast/core/ProductOperation.ceylon index 59746a90..758a0b69 100644 --- a/source/ceylon/ast/core/ProductOperation.ceylon +++ b/source/ceylon/ast/core/ProductOperation.ceylon @@ -23,6 +23,9 @@ shared class ProductOperation(leftFactor, rightFactor) shared actual Result transform(Transformer transformer) => transformer.transformProductOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitProductOperation(this); + shared actual Boolean equals(Object that) { if (is ProductOperation that) { return leftOperand == that.leftOperand && rightOperand == that.rightOperand; diff --git a/source/ceylon/ast/core/QualifiedExpression.ceylon b/source/ceylon/ast/core/QualifiedExpression.ceylon index 7409a382..ea5efec6 100644 --- a/source/ceylon/ast/core/QualifiedExpression.ceylon +++ b/source/ceylon/ast/core/QualifiedExpression.ceylon @@ -25,6 +25,9 @@ shared class QualifiedExpression(receiverExpression, nameAndArgs, memberOperator shared actual Result transform(Transformer transformer) => transformer.transformQualifiedExpression(this); + shared actual void visit(Visitor visitor) + => visitor.visitQualifiedExpression(this); + shared actual Boolean equals(Object that) { if (is QualifiedExpression that) { return receiverExpression == that.receiverExpression && nameAndArgs == that.nameAndArgs; diff --git a/source/ceylon/ast/core/QualifiedType.ceylon b/source/ceylon/ast/core/QualifiedType.ceylon index b59849b4..95f50115 100644 --- a/source/ceylon/ast/core/QualifiedType.ceylon +++ b/source/ceylon/ast/core/QualifiedType.ceylon @@ -17,6 +17,9 @@ shared class QualifiedType(qualifyingType, nameAndArgs) shared actual Result transform(Transformer transformer) => transformer.transformQualifiedType(this); + shared actual void visit(Visitor visitor) + => visitor.visitQualifiedType(this); + shared actual Boolean equals(Object that) { if (is QualifiedType that) { return nameAndArgs == that.nameAndArgs && qualifyingType == that.qualifyingType; diff --git a/source/ceylon/ast/core/QuotientOperation.ceylon b/source/ceylon/ast/core/QuotientOperation.ceylon index 4c797799..c80ef027 100644 --- a/source/ceylon/ast/core/QuotientOperation.ceylon +++ b/source/ceylon/ast/core/QuotientOperation.ceylon @@ -24,6 +24,9 @@ shared class QuotientOperation(dividend, divisor) shared actual Result transform(Transformer transformer) => transformer.transformQuotientOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitQuotientOperation(this); + shared actual Boolean equals(Object that) { if (is QuotientOperation that) { return leftOperand == that.leftOperand && rightOperand == that.rightOperand; diff --git a/source/ceylon/ast/core/RemainderAssignmentOperation.ceylon b/source/ceylon/ast/core/RemainderAssignmentOperation.ceylon index 0c4ae1f8..2fca2699 100644 --- a/source/ceylon/ast/core/RemainderAssignmentOperation.ceylon +++ b/source/ceylon/ast/core/RemainderAssignmentOperation.ceylon @@ -28,6 +28,9 @@ shared class RemainderAssignmentOperation(target, divisor) shared actual Result transform(Transformer transformer) => transformer.transformRemainderAssignmentOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitRemainderAssignmentOperation(this); + shared actual Boolean equals(Object that) { if (is RemainderAssignmentOperation that) { return leftOperand == that.leftOperand && rightOperand == that.rightOperand; diff --git a/source/ceylon/ast/core/RemainderOperation.ceylon b/source/ceylon/ast/core/RemainderOperation.ceylon index 8cf19e53..a6c6a672 100644 --- a/source/ceylon/ast/core/RemainderOperation.ceylon +++ b/source/ceylon/ast/core/RemainderOperation.ceylon @@ -24,6 +24,9 @@ shared class RemainderOperation(dividend, divisor) shared actual Result transform(Transformer transformer) => transformer.transformRemainderOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitRemainderOperation(this); + shared actual Boolean equals(Object that) { if (is RemainderOperation that) { return leftOperand == that.leftOperand && rightOperand == that.rightOperand; diff --git a/source/ceylon/ast/core/Resource.ceylon b/source/ceylon/ast/core/Resource.ceylon index 15ddf865..c6cd9876 100644 --- a/source/ceylon/ast/core/Resource.ceylon +++ b/source/ceylon/ast/core/Resource.ceylon @@ -22,6 +22,9 @@ shared class Resource(resource) shared actual Result transform(Transformer transformer) => transformer.transformResource(this); + shared actual void visit(Visitor visitor) + => visitor.visitResource(this); + shared actual Boolean equals(Object that) { if (is Resource that) { return resource == that.resource; diff --git a/source/ceylon/ast/core/Resources.ceylon b/source/ceylon/ast/core/Resources.ceylon index 0c032f6a..4539d568 100644 --- a/source/ceylon/ast/core/Resources.ceylon +++ b/source/ceylon/ast/core/Resources.ceylon @@ -15,6 +15,9 @@ shared class Resources(resources) shared actual Result transform(Transformer transformer) => transformer.transformResources(this); + shared actual void visit(Visitor visitor) + => visitor.visitResources(this); + shared actual Boolean equals(Object that) { if (is Resources that) { return resources == that.resources; diff --git a/source/ceylon/ast/core/Return.ceylon b/source/ceylon/ast/core/Return.ceylon index 41c55959..6a1b4cda 100644 --- a/source/ceylon/ast/core/Return.ceylon +++ b/source/ceylon/ast/core/Return.ceylon @@ -12,6 +12,9 @@ shared class Return(result = null) shared actual Result transform(Transformer transformer) => transformer.transformReturn(this); + shared actual void visit(Visitor visitor) + => visitor.visitReturn(this); + shared actual Boolean equals(Object that) { if (is Return that) { if (exists result) { diff --git a/source/ceylon/ast/core/SafeMemberOperator.ceylon b/source/ceylon/ast/core/SafeMemberOperator.ceylon index 4a602495..61f4aafa 100644 --- a/source/ceylon/ast/core/SafeMemberOperator.ceylon +++ b/source/ceylon/ast/core/SafeMemberOperator.ceylon @@ -16,6 +16,9 @@ shared class SafeMemberOperator() shared actual Result transform(Transformer transformer) => transformer.transformSafeMemberOperator(this); + shared actual void visit(Visitor visitor) + => visitor.visitSafeMemberOperator(this); + shared actual Boolean equals(Object that) { return that is SafeMemberOperator; } diff --git a/source/ceylon/ast/core/SatisfiedTypes.ceylon b/source/ceylon/ast/core/SatisfiedTypes.ceylon index 9186887c..b0a16772 100644 --- a/source/ceylon/ast/core/SatisfiedTypes.ceylon +++ b/source/ceylon/ast/core/SatisfiedTypes.ceylon @@ -15,6 +15,9 @@ shared class SatisfiedTypes(satisfiedTypes) shared actual Result transform(Transformer transformer) => transformer.transformSatisfiedTypes(this); + shared actual void visit(Visitor visitor) + => visitor.visitSatisfiedTypes(this); + shared actual Boolean equals(Object that) { if (is SatisfiedTypes that) { return satisfiedTypes == that.satisfiedTypes; diff --git a/source/ceylon/ast/core/ScaleOperation.ceylon b/source/ceylon/ast/core/ScaleOperation.ceylon index 3728b97c..19df4325 100644 --- a/source/ceylon/ast/core/ScaleOperation.ceylon +++ b/source/ceylon/ast/core/ScaleOperation.ceylon @@ -40,6 +40,9 @@ shared class ScaleOperation(factor, scalable) shared actual Result transform(Transformer transformer) => transformer.transformScaleOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitScaleOperation(this); + shared actual Boolean equals(Object that) { if (is ScaleOperation that) { return leftOperand == that.leftOperand && rightOperand == that.rightOperand; diff --git a/source/ceylon/ast/core/SelfReference.ceylon b/source/ceylon/ast/core/SelfReference.ceylon index b7bbefa4..39baa747 100644 --- a/source/ceylon/ast/core/SelfReference.ceylon +++ b/source/ceylon/ast/core/SelfReference.ceylon @@ -19,6 +19,8 @@ shared class This() extends SelfReference() { } shared actual Result transform(Transformer transformer) => transformer.transformThis(this); + shared actual void visit(Visitor visitor) + => visitor.visitThis(this); equals(Object that) => that is This; } @@ -34,6 +36,8 @@ shared class Super() extends SelfReference() { } shared actual Result transform(Transformer transformer) => transformer.transformSuper(this); + shared actual void visit(Visitor visitor) + => visitor.visitSuper(this); equals(Object that) => that is Super; } @@ -49,6 +53,8 @@ shared class Outer() extends SelfReference() { } shared actual Result transform(Transformer transformer) => transformer.transformOuter(this); + shared actual void visit(Visitor visitor) + => visitor.visitOuter(this); equals(Object that) => that is Outer; } @@ -63,5 +69,7 @@ shared class Package() extends SelfReference() { } shared actual Result transform(Transformer transformer) => transformer.transformPackage(this); + shared actual void visit(Visitor visitor) + => visitor.visitPackage(this); equals(Object that) => that is Package; } diff --git a/source/ceylon/ast/core/SequentialType.ceylon b/source/ceylon/ast/core/SequentialType.ceylon index 5b8fe3ce..1ff32af4 100644 --- a/source/ceylon/ast/core/SequentialType.ceylon +++ b/source/ceylon/ast/core/SequentialType.ceylon @@ -31,6 +31,9 @@ shared class SequentialType(elementType, length = null) shared actual Result transform(Transformer transformer) => transformer.transformSequentialType(this); + shared actual void visit(Visitor visitor) + => visitor.visitSequentialType(this); + shared actual Boolean equals(Object that) { if (is SequentialType that) { if (exists length) { diff --git a/source/ceylon/ast/core/SmallAsOperation.ceylon b/source/ceylon/ast/core/SmallAsOperation.ceylon index 1bb5c20d..5e61a41b 100644 --- a/source/ceylon/ast/core/SmallAsOperation.ceylon +++ b/source/ceylon/ast/core/SmallAsOperation.ceylon @@ -16,6 +16,9 @@ shared class SmallAsOperation(leftOperand, rightOperand) shared actual Result transform(Transformer transformer) => transformer.transformSmallAsOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitSmallAsOperation(this); + shared actual Boolean equals(Object that) { if (is SmallAsOperation that) { return leftOperand == that.leftOperand && rightOperand == that.rightOperand; diff --git a/source/ceylon/ast/core/SmallerOperation.ceylon b/source/ceylon/ast/core/SmallerOperation.ceylon index 2349c4fc..8a7d26a2 100644 --- a/source/ceylon/ast/core/SmallerOperation.ceylon +++ b/source/ceylon/ast/core/SmallerOperation.ceylon @@ -16,6 +16,9 @@ shared class SmallerOperation(leftOperand, rightOperand) shared actual Result transform(Transformer transformer) => transformer.transformSmallerOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitSmallerOperation(this); + shared actual Boolean equals(Object that) { if (is SmallerOperation that) { return leftOperand == that.leftOperand && rightOperand == that.rightOperand; diff --git a/source/ceylon/ast/core/SpanFromSubscript.ceylon b/source/ceylon/ast/core/SpanFromSubscript.ceylon index 38582643..6a3b45c3 100644 --- a/source/ceylon/ast/core/SpanFromSubscript.ceylon +++ b/source/ceylon/ast/core/SpanFromSubscript.ceylon @@ -20,6 +20,9 @@ shared class SpanFromSubscript(from) shared actual Result transform(Transformer transformer) => transformer.transformSpanFromSubscript(this); + shared actual void visit(Visitor visitor) + => visitor.visitSpanFromSubscript(this); + shared actual Boolean equals(Object that) { if (is SpanFromSubscript that) { return from == that.from; diff --git a/source/ceylon/ast/core/SpanOperation.ceylon b/source/ceylon/ast/core/SpanOperation.ceylon index 2f9cbd18..cb3ab6e9 100644 --- a/source/ceylon/ast/core/SpanOperation.ceylon +++ b/source/ceylon/ast/core/SpanOperation.ceylon @@ -29,6 +29,9 @@ shared class SpanOperation(first, last) shared actual Result transform(Transformer transformer) => transformer.transformSpanOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitSpanOperation(this); + shared actual Boolean equals(Object that) { if (is SpanOperation that) { return leftOperand == that.leftOperand && rightOperand == that.rightOperand; diff --git a/source/ceylon/ast/core/SpanSubscript.ceylon b/source/ceylon/ast/core/SpanSubscript.ceylon index 639d7e74..6f9d0580 100644 --- a/source/ceylon/ast/core/SpanSubscript.ceylon +++ b/source/ceylon/ast/core/SpanSubscript.ceylon @@ -24,6 +24,9 @@ shared class SpanSubscript(from, to) shared actual Result transform(Transformer transformer) => transformer.transformSpanSubscript(this); + shared actual void visit(Visitor visitor) + => visitor.visitSpanSubscript(this); + shared actual Boolean equals(Object that) { if (is SpanSubscript that) { return from == that.from && to == that.to; diff --git a/source/ceylon/ast/core/SpanToSubscript.ceylon b/source/ceylon/ast/core/SpanToSubscript.ceylon index 45116438..e93c63b2 100644 --- a/source/ceylon/ast/core/SpanToSubscript.ceylon +++ b/source/ceylon/ast/core/SpanToSubscript.ceylon @@ -19,6 +19,9 @@ shared class SpanToSubscript(to) shared actual Result transform(Transformer transformer) => transformer.transformSpanToSubscript(this); + shared actual void visit(Visitor visitor) + => visitor.visitSpanToSubscript(this); + shared actual Boolean equals(Object that) { if (is SpanToSubscript that) { return to == that.to; diff --git a/source/ceylon/ast/core/SpecifiedArgument.ceylon b/source/ceylon/ast/core/SpecifiedArgument.ceylon index c0b830c3..6bfa6ea3 100644 --- a/source/ceylon/ast/core/SpecifiedArgument.ceylon +++ b/source/ceylon/ast/core/SpecifiedArgument.ceylon @@ -20,6 +20,9 @@ shared class SpecifiedArgument(specification) shared actual Result transform(Transformer transformer) => transformer.transformSpecifiedArgument(this); + shared actual void visit(Visitor visitor) + => visitor.visitSpecifiedArgument(this); + shared actual Boolean equals(Object that) { if (is SpecifiedArgument that) { return specification == that.specification; diff --git a/source/ceylon/ast/core/SpecifiedPattern.ceylon b/source/ceylon/ast/core/SpecifiedPattern.ceylon index 2f6f999f..66e2d0d5 100644 --- a/source/ceylon/ast/core/SpecifiedPattern.ceylon +++ b/source/ceylon/ast/core/SpecifiedPattern.ceylon @@ -17,6 +17,9 @@ shared class SpecifiedPattern(pattern, specifier) shared actual Result transform(Transformer transformer) => transformer.transformSpecifiedPattern(this); + shared actual void visit(Visitor visitor) + => visitor.visitSpecifiedPattern(this); + shared actual Boolean equals(Object that) { if (is SpecifiedPattern that) { return pattern == that.pattern && specifier == that.specifier; diff --git a/source/ceylon/ast/core/SpecifiedVariable.ceylon b/source/ceylon/ast/core/SpecifiedVariable.ceylon index 5b3b933f..3407a07f 100644 --- a/source/ceylon/ast/core/SpecifiedVariable.ceylon +++ b/source/ceylon/ast/core/SpecifiedVariable.ceylon @@ -22,6 +22,9 @@ shared class SpecifiedVariable(name, specifier, type = null) shared actual Result transform(Transformer transformer) => transformer.transformSpecifiedVariable(this); + shared actual void visit(Visitor visitor) + => visitor.visitSpecifiedVariable(this); + shared actual Boolean equals(Object that) { if (is SpecifiedVariable that) { if (exists type) { diff --git a/source/ceylon/ast/core/Specifier.ceylon b/source/ceylon/ast/core/Specifier.ceylon index 39fc2b3b..6250a9d5 100644 --- a/source/ceylon/ast/core/Specifier.ceylon +++ b/source/ceylon/ast/core/Specifier.ceylon @@ -12,6 +12,9 @@ shared class Specifier(expression) shared actual Result transform(Transformer transformer) => transformer.transformSpecifier(this); + shared actual void visit(Visitor visitor) + => visitor.visitSpecifier(this); + shared actual Boolean equals(Object that) { if (is Specifier that) { return expression == that.expression; diff --git a/source/ceylon/ast/core/SpreadArgument.ceylon b/source/ceylon/ast/core/SpreadArgument.ceylon index 9b7bf328..c551436b 100644 --- a/source/ceylon/ast/core/SpreadArgument.ceylon +++ b/source/ceylon/ast/core/SpreadArgument.ceylon @@ -26,6 +26,9 @@ shared class SpreadArgument(argument) shared actual Result transform(Transformer transformer) => transformer.transformSpreadArgument(this); + shared actual void visit(Visitor visitor) + => visitor.visitSpreadArgument(this); + shared actual Boolean equals(Object that) { if (is SpreadArgument that) { return argument == that.argument; diff --git a/source/ceylon/ast/core/SpreadMemberOperator.ceylon b/source/ceylon/ast/core/SpreadMemberOperator.ceylon index 21b8e472..9db38b0e 100644 --- a/source/ceylon/ast/core/SpreadMemberOperator.ceylon +++ b/source/ceylon/ast/core/SpreadMemberOperator.ceylon @@ -16,6 +16,9 @@ shared class SpreadMemberOperator() shared actual Result transform(Transformer transformer) => transformer.transformSpreadMemberOperator(this); + shared actual void visit(Visitor visitor) + => visitor.visitSpreadMemberOperator(this); + shared actual Boolean equals(Object that) { return that is SpreadMemberOperator; } diff --git a/source/ceylon/ast/core/SpreadType.ceylon b/source/ceylon/ast/core/SpreadType.ceylon index a0f64dfc..1ece3ae6 100644 --- a/source/ceylon/ast/core/SpreadType.ceylon +++ b/source/ceylon/ast/core/SpreadType.ceylon @@ -17,6 +17,9 @@ shared class SpreadType(type) shared actual Result transform(Transformer transformer) => transformer.transformSpreadType(this); + shared actual void visit(Visitor visitor) + => visitor.visitSpreadType(this); + shared actual Boolean equals(Object that) { if (is SpreadType that) { return type == that.type; diff --git a/source/ceylon/ast/core/StringLiteral.ceylon b/source/ceylon/ast/core/StringLiteral.ceylon index 31465f4b..becf998d 100644 --- a/source/ceylon/ast/core/StringLiteral.ceylon +++ b/source/ceylon/ast/core/StringLiteral.ceylon @@ -15,6 +15,9 @@ shared class StringLiteral(text, isVerbatim = false) extends Literal(text) { shared actual Result transform(Transformer transformer) => transformer.transformStringLiteral(this); + shared actual void visit(Visitor visitor) + => visitor.visitStringLiteral(this); + shared actual Boolean equals(Object that) { if (is StringLiteral that) { return isVerbatim == that.isVerbatim && text == that.text; diff --git a/source/ceylon/ast/core/StringTemplate.ceylon b/source/ceylon/ast/core/StringTemplate.ceylon index ddadc89c..d7245335 100644 --- a/source/ceylon/ast/core/StringTemplate.ceylon +++ b/source/ceylon/ast/core/StringTemplate.ceylon @@ -30,6 +30,9 @@ shared class StringTemplate(literals, expressions) shared actual Result transform(Transformer transformer) => transformer.transformStringTemplate(this); + shared actual void visit(Visitor visitor) + => visitor.visitStringTemplate(this); + shared actual Boolean equals(Object that) { if (is StringTemplate that) { return literals == that.literals && expressions == that.expressions; diff --git a/source/ceylon/ast/core/SubtractAssignmentOperation.ceylon b/source/ceylon/ast/core/SubtractAssignmentOperation.ceylon index fdfd6de6..19b73128 100644 --- a/source/ceylon/ast/core/SubtractAssignmentOperation.ceylon +++ b/source/ceylon/ast/core/SubtractAssignmentOperation.ceylon @@ -28,6 +28,9 @@ shared class SubtractAssignmentOperation(target, subtrahend) shared actual Result transform(Transformer transformer) => transformer.transformSubtractAssignmentOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitSubtractAssignmentOperation(this); + shared actual Boolean equals(Object that) { if (is SubtractAssignmentOperation that) { return leftOperand == that.leftOperand && rightOperand == that.rightOperand; diff --git a/source/ceylon/ast/core/SumOperation.ceylon b/source/ceylon/ast/core/SumOperation.ceylon index cdcc6caa..8a2b923f 100644 --- a/source/ceylon/ast/core/SumOperation.ceylon +++ b/source/ceylon/ast/core/SumOperation.ceylon @@ -29,6 +29,9 @@ shared class SumOperation(leftSummand, rightSummand) shared actual Result transform(Transformer transformer) => transformer.transformSumOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitSumOperation(this); + shared actual Boolean equals(Object that) { if (is SumOperation that) { return leftOperand == that.leftOperand && rightOperand == that.rightOperand; diff --git a/source/ceylon/ast/core/SwitchCaseElse.ceylon b/source/ceylon/ast/core/SwitchCaseElse.ceylon index afbc3be6..dcd42a69 100644 --- a/source/ceylon/ast/core/SwitchCaseElse.ceylon +++ b/source/ceylon/ast/core/SwitchCaseElse.ceylon @@ -26,6 +26,9 @@ shared class SwitchCaseElse(clause, cases) shared actual Result transform(Transformer transformer) => transformer.transformSwitchCaseElse(this); + shared actual void visit(Visitor visitor) + => visitor.visitSwitchCaseElse(this); + shared actual Boolean equals(Object that) { if (is SwitchCaseElse that) { return clause == that.clause && cases == that.cases; diff --git a/source/ceylon/ast/core/SwitchCaseElseExpression.ceylon b/source/ceylon/ast/core/SwitchCaseElseExpression.ceylon index 0b14f898..f411eb8c 100644 --- a/source/ceylon/ast/core/SwitchCaseElseExpression.ceylon +++ b/source/ceylon/ast/core/SwitchCaseElseExpression.ceylon @@ -26,6 +26,9 @@ shared class SwitchCaseElseExpression(clause, caseExpressions, elseExpression) shared actual Result transform(Transformer transformer) => transformer.transformSwitchCaseElseExpression(this); + shared actual void visit(Visitor visitor) + => visitor.visitSwitchCaseElseExpression(this); + shared actual Boolean equals(Object that) { if (is SwitchCaseElseExpression that) { if (exists elseExpression) { diff --git a/source/ceylon/ast/core/SwitchCases.ceylon b/source/ceylon/ast/core/SwitchCases.ceylon index 8a76bd5e..571ba1bf 100644 --- a/source/ceylon/ast/core/SwitchCases.ceylon +++ b/source/ceylon/ast/core/SwitchCases.ceylon @@ -25,6 +25,9 @@ shared class SwitchCases(caseClauses, elseClause = null) shared actual Result transform(Transformer transformer) => transformer.transformSwitchCases(this); + shared actual void visit(Visitor visitor) + => visitor.visitSwitchCases(this); + shared actual Boolean equals(Object that) { if (is SwitchCases that) { if (exists elseClause) { diff --git a/source/ceylon/ast/core/SwitchClause.ceylon b/source/ceylon/ast/core/SwitchClause.ceylon index c31b96b9..63ffad22 100644 --- a/source/ceylon/ast/core/SwitchClause.ceylon +++ b/source/ceylon/ast/core/SwitchClause.ceylon @@ -26,6 +26,9 @@ shared class SwitchClause(switched) shared actual Result transform(Transformer transformer) => transformer.transformSwitchClause(this); + shared actual void visit(Visitor visitor) + => visitor.visitSwitchClause(this); + shared actual Boolean equals(Object that) { if (is SwitchClause that) { return switched == that.switched; diff --git a/source/ceylon/ast/core/ThenOperation.ceylon b/source/ceylon/ast/core/ThenOperation.ceylon index 0d102fc9..8ab4901e 100644 --- a/source/ceylon/ast/core/ThenOperation.ceylon +++ b/source/ceylon/ast/core/ThenOperation.ceylon @@ -28,6 +28,9 @@ shared class ThenOperation(condition, result) shared actual Result transform(Transformer transformer) => transformer.transformThenOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitThenOperation(this); + shared actual Boolean equals(Object that) { if (is ThenOperation that) { return leftOperand == that.leftOperand && rightOperand == that.rightOperand; diff --git a/source/ceylon/ast/core/Throw.ceylon b/source/ceylon/ast/core/Throw.ceylon index c0c06065..cdc7005e 100644 --- a/source/ceylon/ast/core/Throw.ceylon +++ b/source/ceylon/ast/core/Throw.ceylon @@ -12,6 +12,9 @@ shared class Throw(result = null) shared actual Result transform(Transformer transformer) => transformer.transformThrow(this); + shared actual void visit(Visitor visitor) + => visitor.visitThrow(this); + shared actual Boolean equals(Object that) { if (is Throw that) { if (exists result) { diff --git a/source/ceylon/ast/core/TryCatchFinally.ceylon b/source/ceylon/ast/core/TryCatchFinally.ceylon index 87688eed..689a925d 100644 --- a/source/ceylon/ast/core/TryCatchFinally.ceylon +++ b/source/ceylon/ast/core/TryCatchFinally.ceylon @@ -41,6 +41,9 @@ shared class TryCatchFinally(tryClause, catchClauses = [], finallyClause = null) shared actual Result transform(Transformer transformer) => transformer.transformTryCatchFinally(this); + shared actual void visit(Visitor visitor) + => visitor.visitTryCatchFinally(this); + shared actual Boolean equals(Object that) { if (is TryCatchFinally that) { if (exists finallyClause) { diff --git a/source/ceylon/ast/core/TryClause.ceylon b/source/ceylon/ast/core/TryClause.ceylon index 49ce9d5f..b23e524c 100644 --- a/source/ceylon/ast/core/TryClause.ceylon +++ b/source/ceylon/ast/core/TryClause.ceylon @@ -29,6 +29,9 @@ shared class TryClause(block, resources = null) shared actual Result transform(Transformer transformer) => transformer.transformTryClause(this); + shared actual void visit(Visitor visitor) + => visitor.visitTryClause(this); + shared actual Boolean equals(Object that) { if (is TryClause that) { if (exists resources) { diff --git a/source/ceylon/ast/core/Tuple.ceylon b/source/ceylon/ast/core/Tuple.ceylon index 7e5438ab..bc1cc017 100644 --- a/source/ceylon/ast/core/Tuple.ceylon +++ b/source/ceylon/ast/core/Tuple.ceylon @@ -16,6 +16,9 @@ shared class Tuple(argumentList) shared actual Result transform(Transformer transformer) => transformer.transformTuple(this); + shared actual void visit(Visitor visitor) + => visitor.visitTuple(this); + shared actual Boolean equals(Object that) { if (is Tuple that) { return argumentList == that.argumentList; diff --git a/source/ceylon/ast/core/TuplePattern.ceylon b/source/ceylon/ast/core/TuplePattern.ceylon index d8d2ddcd..8e71fe72 100644 --- a/source/ceylon/ast/core/TuplePattern.ceylon +++ b/source/ceylon/ast/core/TuplePattern.ceylon @@ -32,6 +32,9 @@ shared class TuplePattern(elementPatterns, variadicElementPattern = null) shared actual Result transform(Transformer transformer) => transformer.transformTuplePattern(this); + shared actual void visit(Visitor visitor) + => visitor.visitTuplePattern(this); + shared actual Boolean equals(Object that) { if (is TuplePattern that) { if (exists variadicElementPattern) { diff --git a/source/ceylon/ast/core/TupleType.ceylon b/source/ceylon/ast/core/TupleType.ceylon index 1454a9a8..5ec5b989 100644 --- a/source/ceylon/ast/core/TupleType.ceylon +++ b/source/ceylon/ast/core/TupleType.ceylon @@ -16,6 +16,9 @@ shared class TupleType(typeList) shared actual Result transform(Transformer transformer) => transformer.transformTupleType(this); + shared actual void visit(Visitor visitor) + => visitor.visitTupleType(this); + shared actual Boolean equals(Object that) { if (is TupleType that) { return typeList == that.typeList; diff --git a/source/ceylon/ast/core/TypeAliasDefinition.ceylon b/source/ceylon/ast/core/TypeAliasDefinition.ceylon index cd7f435f..092d6453 100644 --- a/source/ceylon/ast/core/TypeAliasDefinition.ceylon +++ b/source/ceylon/ast/core/TypeAliasDefinition.ceylon @@ -39,6 +39,9 @@ shared class TypeAliasDefinition(name, specifier, typeParameters = null, typeCon shared actual Result transform(Transformer transformer) => transformer.transformTypeAliasDefinition(this); + shared actual void visit(Visitor visitor) + => visitor.visitTypeAliasDefinition(this); + shared actual Boolean equals(Object that) { if (is TypeAliasDefinition that) { if (exists typeParameters) { diff --git a/source/ceylon/ast/core/TypeArgument.ceylon b/source/ceylon/ast/core/TypeArgument.ceylon index 5091fb3d..b75b8020 100644 --- a/source/ceylon/ast/core/TypeArgument.ceylon +++ b/source/ceylon/ast/core/TypeArgument.ceylon @@ -24,6 +24,9 @@ shared class TypeArgument(type, variance = null) shared actual Result transform(Transformer transformer) => transformer.transformTypeArgument(this); + shared actual void visit(Visitor visitor) + => visitor.visitTypeArgument(this); + shared actual Boolean equals(Object that) { if (is TypeArgument that) { if (exists variance) { diff --git a/source/ceylon/ast/core/TypeArguments.ceylon b/source/ceylon/ast/core/TypeArguments.ceylon index ee038307..0769b981 100644 --- a/source/ceylon/ast/core/TypeArguments.ceylon +++ b/source/ceylon/ast/core/TypeArguments.ceylon @@ -16,6 +16,9 @@ shared class TypeArguments(typeArguments) shared actual Result transform(Transformer transformer) => transformer.transformTypeArguments(this); + shared actual void visit(Visitor visitor) + => visitor.visitTypeArguments(this); + shared actual Boolean equals(Object that) { if (is TypeArguments that) { return typeArguments == that.typeArguments; diff --git a/source/ceylon/ast/core/TypeConstraint.ceylon b/source/ceylon/ast/core/TypeConstraint.ceylon index 1375d30a..18c74251 100644 --- a/source/ceylon/ast/core/TypeConstraint.ceylon +++ b/source/ceylon/ast/core/TypeConstraint.ceylon @@ -33,6 +33,9 @@ shared class TypeConstraint(parameterName, caseTypes = null, satisfiedTypes = nu shared actual Result transform(Transformer transformer) => transformer.transformTypeConstraint(this); + shared actual void visit(Visitor visitor) + => visitor.visitTypeConstraint(this); + shared actual Boolean equals(Object that) { if (is TypeConstraint that) { if (exists caseTypes) { diff --git a/source/ceylon/ast/core/TypeList.ceylon b/source/ceylon/ast/core/TypeList.ceylon index de2cfafb..0261851c 100644 --- a/source/ceylon/ast/core/TypeList.ceylon +++ b/source/ceylon/ast/core/TypeList.ceylon @@ -16,6 +16,9 @@ shared class TypeList(elements, variadic = null) shared actual Result transform(Transformer transformer) => transformer.transformTypeList(this); + shared actual void visit(Visitor visitor) + => visitor.visitTypeList(this); + shared actual Boolean equals(Object that) { if (is TypeList that) { if (exists variadic) { diff --git a/source/ceylon/ast/core/TypeMeta.ceylon b/source/ceylon/ast/core/TypeMeta.ceylon index 4112b19b..a09c159a 100644 --- a/source/ceylon/ast/core/TypeMeta.ceylon +++ b/source/ceylon/ast/core/TypeMeta.ceylon @@ -15,6 +15,9 @@ shared class TypeMeta(type) shared actual Result transform(Transformer transformer) => transformer.transformTypeMeta(this); + shared actual void visit(Visitor visitor) + => visitor.visitTypeMeta(this); + shared actual Boolean equals(Object that) { if (is TypeMeta that) { return type == that.type; diff --git a/source/ceylon/ast/core/TypeNameWithTypeArguments.ceylon b/source/ceylon/ast/core/TypeNameWithTypeArguments.ceylon index 3475adba..55cfe9d1 100644 --- a/source/ceylon/ast/core/TypeNameWithTypeArguments.ceylon +++ b/source/ceylon/ast/core/TypeNameWithTypeArguments.ceylon @@ -11,6 +11,9 @@ shared class TypeNameWithTypeArguments(name, typeArguments = null) shared actual Result transform(Transformer transformer) => transformer.transformTypeNameWithTypeArguments(this); + shared actual void visit(Visitor visitor) + => visitor.visitTypeNameWithTypeArguments(this); + shared actual Boolean equals(Object that) { if (is TypeNameWithTypeArguments that) { if (exists typeArguments) { diff --git a/source/ceylon/ast/core/TypeParameter.ceylon b/source/ceylon/ast/core/TypeParameter.ceylon index 003f216d..baf03e00 100644 --- a/source/ceylon/ast/core/TypeParameter.ceylon +++ b/source/ceylon/ast/core/TypeParameter.ceylon @@ -30,6 +30,9 @@ shared class TypeParameter(parameterName, variance = null, defaultArgument = nul shared actual Result transform(Transformer transformer) => transformer.transformTypeParameter(this); + shared actual void visit(Visitor visitor) + => visitor.visitTypeParameter(this); + shared actual Boolean equals(Object that) { if (is TypeParameter that) { if (exists variance) { diff --git a/source/ceylon/ast/core/TypeParameters.ceylon b/source/ceylon/ast/core/TypeParameters.ceylon index 79c3fced..fcb9e2aa 100644 --- a/source/ceylon/ast/core/TypeParameters.ceylon +++ b/source/ceylon/ast/core/TypeParameters.ceylon @@ -15,6 +15,9 @@ shared class TypeParameters(typeParameters) shared actual Result transform(Transformer transformer) => transformer.transformTypeParameters(this); + shared actual void visit(Visitor visitor) + => visitor.visitTypeParameters(this); + shared actual Boolean equals(Object that) { if (is TypeParameters that) { return typeParameters == that.typeParameters; diff --git a/source/ceylon/ast/core/TypeSpecifier.ceylon b/source/ceylon/ast/core/TypeSpecifier.ceylon index 50827945..7c647b7a 100644 --- a/source/ceylon/ast/core/TypeSpecifier.ceylon +++ b/source/ceylon/ast/core/TypeSpecifier.ceylon @@ -15,6 +15,9 @@ shared class TypeSpecifier(type) shared actual Result transform(Transformer transformer) => transformer.transformTypeSpecifier(this); + shared actual void visit(Visitor visitor) + => visitor.visitTypeSpecifier(this); + shared actual Boolean equals(Object that) { if (is TypeSpecifier that) { return type == that.type; diff --git a/source/ceylon/ast/core/TypedVariable.ceylon b/source/ceylon/ast/core/TypedVariable.ceylon index 94e697b0..55c81e0e 100644 --- a/source/ceylon/ast/core/TypedVariable.ceylon +++ b/source/ceylon/ast/core/TypedVariable.ceylon @@ -16,6 +16,9 @@ shared class TypedVariable(name, type, specifier = null) shared actual Result transform(Transformer transformer) => transformer.transformTypedVariable(this); + shared actual void visit(Visitor visitor) + => visitor.visitTypedVariable(this); + shared actual Boolean equals(Object that) { if (is TypedVariable that) { if (exists specifier) { diff --git a/source/ceylon/ast/core/UnionAssignmentOperation.ceylon b/source/ceylon/ast/core/UnionAssignmentOperation.ceylon index 57e9afc9..a3fa3a81 100644 --- a/source/ceylon/ast/core/UnionAssignmentOperation.ceylon +++ b/source/ceylon/ast/core/UnionAssignmentOperation.ceylon @@ -29,6 +29,9 @@ shared class UnionAssignmentOperation(target, other) shared actual Result transform(Transformer transformer) => transformer.transformUnionAssignmentOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitUnionAssignmentOperation(this); + shared actual Boolean equals(Object that) { if (is UnionAssignmentOperation that) { return leftOperand == that.leftOperand && rightOperand == that.rightOperand; diff --git a/source/ceylon/ast/core/UnionOperation.ceylon b/source/ceylon/ast/core/UnionOperation.ceylon index 1b390913..c99c1ceb 100644 --- a/source/ceylon/ast/core/UnionOperation.ceylon +++ b/source/ceylon/ast/core/UnionOperation.ceylon @@ -22,6 +22,9 @@ shared class UnionOperation(leftOperand, rightOperand) shared actual Result transform(Transformer transformer) => transformer.transformUnionOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitUnionOperation(this); + shared actual Boolean equals(Object that) { if (is UnionOperation that) { return leftOperand == that.leftOperand && rightOperand == that.rightOperand; diff --git a/source/ceylon/ast/core/UnionType.ceylon b/source/ceylon/ast/core/UnionType.ceylon index 0576a9f3..fdc90e26 100644 --- a/source/ceylon/ast/core/UnionType.ceylon +++ b/source/ceylon/ast/core/UnionType.ceylon @@ -17,6 +17,9 @@ shared class UnionType(children) shared actual Result transform(Transformer transformer) => transformer.transformUnionType(this); + shared actual void visit(Visitor visitor) + => visitor.visitUnionType(this); + shared actual Boolean equals(Object that) { if (is UnionType that) { return children == that.children; diff --git a/source/ceylon/ast/core/UnspecifiedVariable.ceylon b/source/ceylon/ast/core/UnspecifiedVariable.ceylon index 47a6b4b5..97ee7734 100644 --- a/source/ceylon/ast/core/UnspecifiedVariable.ceylon +++ b/source/ceylon/ast/core/UnspecifiedVariable.ceylon @@ -24,6 +24,9 @@ shared class UnspecifiedVariable(name, type = null) shared actual Result transform(Transformer transformer) => transformer.transformUnspecifiedVariable(this); + shared actual void visit(Visitor visitor) + => visitor.visitUnspecifiedVariable(this); + shared actual Boolean equals(Object that) { if (is UnspecifiedVariable that) { if (exists type) { diff --git a/source/ceylon/ast/core/ValueArgument.ceylon b/source/ceylon/ast/core/ValueArgument.ceylon index 57dcdb62..2d78b15e 100644 --- a/source/ceylon/ast/core/ValueArgument.ceylon +++ b/source/ceylon/ast/core/ValueArgument.ceylon @@ -39,6 +39,9 @@ shared class ValueArgument(name, type, definition) shared actual Result transform(Transformer transformer) => transformer.transformValueArgument(this); + shared actual void visit(Visitor visitor) + => visitor.visitValueArgument(this); + shared actual Boolean equals(Object that) { if (is ValueArgument that) { return name == that.name && type == that.type && definition == that.definition; diff --git a/source/ceylon/ast/core/ValueConstructorDefinition.ceylon b/source/ceylon/ast/core/ValueConstructorDefinition.ceylon index feb20cea..de2688b9 100644 --- a/source/ceylon/ast/core/ValueConstructorDefinition.ceylon +++ b/source/ceylon/ast/core/ValueConstructorDefinition.ceylon @@ -42,6 +42,9 @@ shared class ValueConstructorDefinition(name, block, extendedType, annotations) shared actual Result transform(Transformer transformer) => transformer.transformValueConstructorDefinition(this); + shared actual void visit(Visitor visitor) + => visitor.visitValueConstructorDefinition(this); + shared actual Boolean equals(Object that) { if (is ValueConstructorDefinition that) { if (exists extendedType) { diff --git a/source/ceylon/ast/core/ValueDec.ceylon b/source/ceylon/ast/core/ValueDec.ceylon index 5b4e2eef..fbaa7eef 100644 --- a/source/ceylon/ast/core/ValueDec.ceylon +++ b/source/ceylon/ast/core/ValueDec.ceylon @@ -19,6 +19,9 @@ shared class ValueDec(name, qualifier = DecQualifier()) shared actual Result transform(Transformer transformer) => transformer.transformValueDec(this); + shared actual void visit(Visitor visitor) + => visitor.visitValueDec(this); + shared actual Boolean equals(Object that) { if (is ValueDec that) { return name == that.name && that.qualifier == qualifier; diff --git a/source/ceylon/ast/core/ValueDeclaration.ceylon b/source/ceylon/ast/core/ValueDeclaration.ceylon index 5d0df8ac..175138e1 100644 --- a/source/ceylon/ast/core/ValueDeclaration.ceylon +++ b/source/ceylon/ast/core/ValueDeclaration.ceylon @@ -35,6 +35,9 @@ shared class ValueDeclaration(name, type, annotations = Annotations()) shared actual Result transform(Transformer transformer) => transformer.transformValueDeclaration(this); + shared actual void visit(Visitor visitor) + => visitor.visitValueDeclaration(this); + shared actual Boolean equals(Object that) { if (is ValueDeclaration that) { return name == that.name && type == that.type && annotations == that.annotations; diff --git a/source/ceylon/ast/core/ValueDefinition.ceylon b/source/ceylon/ast/core/ValueDefinition.ceylon index accb6e31..6768b876 100644 --- a/source/ceylon/ast/core/ValueDefinition.ceylon +++ b/source/ceylon/ast/core/ValueDefinition.ceylon @@ -24,6 +24,9 @@ shared class ValueDefinition(name, type, definition, annotations = Annotations() shared actual Result transform(Transformer transformer) => transformer.transformValueDefinition(this); + shared actual void visit(Visitor visitor) + => visitor.visitValueDefinition(this); + shared actual Boolean equals(Object that) { if (is ValueDefinition that) { return name == that.name && type == that.type && definition == that.definition && annotations == that.annotations; diff --git a/source/ceylon/ast/core/ValueGetterDefinition.ceylon b/source/ceylon/ast/core/ValueGetterDefinition.ceylon index 78b6708f..925ce949 100644 --- a/source/ceylon/ast/core/ValueGetterDefinition.ceylon +++ b/source/ceylon/ast/core/ValueGetterDefinition.ceylon @@ -23,6 +23,9 @@ shared class ValueGetterDefinition(name, type, definition, annotations) shared actual Result transform(Transformer transformer) => transformer.transformValueGetterDefinition(this); + shared actual void visit(Visitor visitor) + => visitor.visitValueGetterDefinition(this); + shared actual Boolean equals(Object that) { if (is ValueGetterDefinition that) { return name == that.name && type == that.type && definition == that.definition && annotations == that.annotations; diff --git a/source/ceylon/ast/core/ValueModifier.ceylon b/source/ceylon/ast/core/ValueModifier.ceylon index 0c9daf32..b17d6305 100644 --- a/source/ceylon/ast/core/ValueModifier.ceylon +++ b/source/ceylon/ast/core/ValueModifier.ceylon @@ -10,6 +10,9 @@ shared class ValueModifier() shared actual Result transform(Transformer transformer) => transformer.transformValueModifier(this); + shared actual void visit(Visitor visitor) + => visitor.visitValueModifier(this); + shared actual Boolean equals(Object that) { return that is ValueModifier; } diff --git a/source/ceylon/ast/core/ValueParameter.ceylon b/source/ceylon/ast/core/ValueParameter.ceylon index 8c0adda6..2894684e 100644 --- a/source/ceylon/ast/core/ValueParameter.ceylon +++ b/source/ceylon/ast/core/ValueParameter.ceylon @@ -22,6 +22,9 @@ shared class ValueParameter(type, name, annotations = Annotations()) shared actual Result transform(Transformer transformer) => transformer.transformValueParameter(this); + shared actual void visit(Visitor visitor) + => visitor.visitValueParameter(this); + shared actual Boolean equals(Object that) { if (is ValueParameter that) { return annotations == that.annotations && type == that.type && name == that.name; diff --git a/source/ceylon/ast/core/ValueSetterDefinition.ceylon b/source/ceylon/ast/core/ValueSetterDefinition.ceylon index 156b2d48..5a4e3799 100644 --- a/source/ceylon/ast/core/ValueSetterDefinition.ceylon +++ b/source/ceylon/ast/core/ValueSetterDefinition.ceylon @@ -23,6 +23,9 @@ shared class ValueSetterDefinition(name, definition, annotations = Annotations() shared actual Result transform(Transformer transformer) => transformer.transformValueSetterDefinition(this); + shared actual void visit(Visitor visitor) + => visitor.visitValueSetterDefinition(this); + shared actual Boolean equals(Object that) { if (is ValueSetterDefinition that) { return name == that.name && definition == that.definition && annotations == that.annotations; diff --git a/source/ceylon/ast/core/ValueSpecification.ceylon b/source/ceylon/ast/core/ValueSpecification.ceylon index 3e86239e..45d1bfd7 100644 --- a/source/ceylon/ast/core/ValueSpecification.ceylon +++ b/source/ceylon/ast/core/ValueSpecification.ceylon @@ -16,6 +16,9 @@ shared class ValueSpecification(name, specifier, qualifier = null) shared actual Result transform(Transformer transformer) => transformer.transformValueSpecification(this); + shared actual void visit(Visitor visitor) + => visitor.visitValueSpecification(this); + shared actual Boolean equals(Object that) { if (is ValueSpecification that) { if (exists qualifier) { diff --git a/source/ceylon/ast/core/VariablePattern.ceylon b/source/ceylon/ast/core/VariablePattern.ceylon index def0c125..b0bed986 100644 --- a/source/ceylon/ast/core/VariablePattern.ceylon +++ b/source/ceylon/ast/core/VariablePattern.ceylon @@ -15,6 +15,9 @@ shared class VariablePattern(variable) shared actual Result transform(Transformer transformer) => transformer.transformVariablePattern(this); + shared actual void visit(Visitor visitor) + => visitor.visitVariablePattern(this); + shared actual Boolean equals(Object that) { if (is VariablePattern that) { return variable == that.variable; diff --git a/source/ceylon/ast/core/VariadicParameter.ceylon b/source/ceylon/ast/core/VariadicParameter.ceylon index 95864c46..02197076 100644 --- a/source/ceylon/ast/core/VariadicParameter.ceylon +++ b/source/ceylon/ast/core/VariadicParameter.ceylon @@ -20,6 +20,9 @@ shared class VariadicParameter(type, name, annotations = Annotations()) shared actual Result transform(Transformer transformer) => transformer.transformVariadicParameter(this); + shared actual void visit(Visitor visitor) + => visitor.visitVariadicParameter(this); + shared actual Boolean equals(Object that) { if (is VariadicParameter that) { return annotations == that.annotations && type == that.type && name == that.name; diff --git a/source/ceylon/ast/core/VariadicType.ceylon b/source/ceylon/ast/core/VariadicType.ceylon index 70ffc8ce..7598d7de 100644 --- a/source/ceylon/ast/core/VariadicType.ceylon +++ b/source/ceylon/ast/core/VariadicType.ceylon @@ -15,6 +15,9 @@ shared class VariadicType(elementType, isNonempty = false) shared actual Result transform(Transformer transformer) => transformer.transformVariadicType(this); + shared actual void visit(Visitor visitor) + => visitor.visitVariadicType(this); + shared actual Boolean equals(Object that) { if (is VariadicType that) { return isNonempty == that.isNonempty && elementType == that.elementType; diff --git a/source/ceylon/ast/core/VariadicVariable.ceylon b/source/ceylon/ast/core/VariadicVariable.ceylon index 1a378db0..7cc537d4 100644 --- a/source/ceylon/ast/core/VariadicVariable.ceylon +++ b/source/ceylon/ast/core/VariadicVariable.ceylon @@ -24,6 +24,9 @@ shared class VariadicVariable(name, type = null) shared actual Result transform(Transformer transformer) => transformer.transformVariadicVariable(this); + shared actual void visit(Visitor visitor) + => visitor.visitVariadicVariable(this); + shared actual Boolean equals(Object that) { if (is VariadicVariable that) { if (exists type) { diff --git a/source/ceylon/ast/core/Visitor.ceylon b/source/ceylon/ast/core/Visitor.ceylon index 9d1de6ba..3a29eac6 100644 --- a/source/ceylon/ast/core/Visitor.ceylon +++ b/source/ceylon/ast/core/Visitor.ceylon @@ -11,634 +11,322 @@ Thus, the default visitor will already traverse the AST fully, and if you need to perform some operation only for some node type that might appear anywhere in the AST, you can simply override that particular method and leave the rest as it is." -shared interface Visitor satisfies WideningTransformer { - transformAddAssignmentOperation(AddAssignmentOperation that) => visitAddAssignmentOperation(that); - transformAliasDec(AliasDec that) => visitAliasDec(that); - transformAndAssignmentOperation(AndAssignmentOperation that) => visitAndAssignmentOperation(that); - transformAndOperation(AndOperation that) => visitAndOperation(that); - transformAnnotation(Annotation that) => visitAnnotation(that); - transformAnnotations(Annotations that) => visitAnnotations(that); - transformAnonymousArgument(AnonymousArgument that) => visitAnonymousArgument(that); - transformAnyClass(AnyClass that) => visitAnyClass(that); - transformAnyCompilationUnit(AnyCompilationUnit that) => visitAnyCompilationUnit(that); - transformAnyFunction(AnyFunction that) => visitAnyFunction(that); - transformAnyInterface(AnyInterface that) => visitAnyInterface(that); - transformAnyInterfaceDefinition(AnyInterfaceDefinition that) => visitAnyInterfaceDefinition(that); - transformAnyMemberOperator(AnyMemberOperator that) => visitAnyMemberOperator(that); - transformAnySpecifier(AnySpecifier that) => visitAnySpecifier(that); - transformAnyValue(AnyValue that) => visitAnyValue(that); - transformArgumentList(ArgumentList that) => visitArgumentList(that); - transformArguments(Arguments that) => visitArguments(that); - transformArithmeticAssignmentOperation(ArithmeticAssignmentOperation that) => visitArithmeticAssignmentOperation(that); - transformArithmeticOperation(ArithmeticOperation that) => visitArithmeticOperation(that); - transformAssertion(Assertion that) => visitAssertion(that); - transformAssignOperation(AssignOperation that) => visitAssignOperation(that); - transformAssignmentOperation(AssignmentOperation that) => visitAssignmentOperation(that); - transformAssignmentStatement(AssignmentStatement that) => visitAssignmentStatement(that); - transformAtom(Atom that) => visitAtom(that); - transformBaseExpression(BaseExpression that) => visitBaseExpression(that); - transformBaseMeta(BaseMeta that) => visitBaseMeta(that); - transformBaseType(BaseType that) => visitBaseType(that); - transformBinaryOperation(BinaryOperation that) => visitBinaryOperation(that); - transformBlock(Block that) => visitBlock(that); - transformBody(Body that) => visitBody(that); - transformBooleanCondition(BooleanCondition that) => visitBooleanCondition(that); - transformBound(Bound that) => visitBound(that); - transformBreak(Break that) => visitBreak(that); - transformCallableParameter(CallableParameter that) => visitCallableParameter(that); - transformCallableType(CallableType that) => visitCallableType(that); - transformCaseClause(CaseClause that) => visitCaseClause(that); - transformCaseExpression(CaseExpression that) => visitCaseExpression(that); - transformCaseItem(CaseItem that) => visitCaseItem(that); - transformCaseTypes(CaseTypes that) => visitCaseTypes(that); - transformCatchClause(CatchClause that) => visitCatchClause(that); - transformCharacterLiteral(CharacterLiteral that) => visitCharacterLiteral(that); - transformClassAliasDefinition(ClassAliasDefinition that) => visitClassAliasDefinition(that); - transformClassBody(ClassBody that) => visitClassBody(that); - transformClassDec(ClassDec that) => visitClassDec(that); - transformClassDefinition(ClassDefinition that) => visitClassDefinition(that); - transformClassOrInterface(ClassOrInterface that) => visitClassOrInterface(that); - transformClassSpecifier(ClassSpecifier that) => visitClassSpecifier(that); - transformClosedBound(ClosedBound that) => visitClosedBound(that); - transformCompareOperation(CompareOperation that) => visitCompareOperation(that); - transformComparisonOperation(ComparisonOperation that) => visitComparisonOperation(that); - transformCompilationUnit(CompilationUnit that) => visitCompilationUnit(that); - transformComplementAssignmentOperation(ComplementAssignmentOperation that) => visitComplementAssignmentOperation(that); - transformComplementOperation(ComplementOperation that) => visitComplementOperation(that); - transformComprehension(Comprehension that) => visitComprehension(that); - transformComprehensionClause(ComprehensionClause that) => visitComprehensionClause(that); - transformCondition(Condition that) => visitCondition(that); - transformConditionalExpression(ConditionalExpression that) => visitConditionalExpression(that); - transformConditions(Conditions that) => visitConditions(that); - transformConstruction(Construction that) => visitConstruction(that); - transformConstructorDec(ConstructorDec that) => visitConstructorDec(that); - transformCallableConstructorDefinition(CallableConstructorDefinition that) => visitCallableConstructorDefinition(that); - transformConstructorDefinition(ConstructorDefinition that) => visitConstructorDefinition(that); - transformContinue(Continue that) => visitContinue(that); - transformControlStructure(ControlStructure that) => visitControlStructure(that); - transformDec(Dec that) => visitDec(that); - transformDecQualifier(DecQualifier that) => visitDecQualifier(that); - transformDeclaration(Declaration that) => visitDeclaration(that); - transformDefaultedCallableParameter(DefaultedCallableParameter that) => visitDefaultedCallableParameter(that); - transformDefaultedParameter(DefaultedParameter that) => visitDefaultedParameter(that); - transformDefaultedParameterReference(DefaultedParameterReference that) => visitDefaultedParameterReference(that); - transformDefaultedType(DefaultedType that) => visitDefaultedType(that); - transformDefaultedValueParameter(DefaultedValueParameter that) => visitDefaultedValueParameter(that); - transformDestructure(Destructure that) => visitDestructure(that); - transformDifferenceOperation(DifferenceOperation that) => visitDifferenceOperation(that); - transformDirective(Directive that) => visitDirective(that); - transformDivideAssignmentOperation(DivideAssignmentOperation that) => visitDivideAssignmentOperation(that); - transformDynamicBlock(DynamicBlock that) => visitDynamicBlock(that); - transformDynamicInterfaceDefinition(DynamicInterfaceDefinition that) => visitDynamicInterfaceDefinition(that); - transformDynamicModifier(DynamicModifier that) => visitDynamicModifier(that); - transformDynamicValue(DynamicValue that) => visitDynamicValue(that); - transformElementOrSubrangeExpression(ElementOrSubrangeExpression that) => visitElementOrSubrangeExpression(that); - transformElseClause(ElseClause that) => visitElseClause(that); - transformElseOperation(ElseOperation that) => visitElseOperation(that); - transformEntryOperation(EntryOperation that) => visitEntryOperation(that); - transformEntryPattern(EntryPattern that) => visitEntryPattern(that); - transformEntryType(EntryType that) => visitEntryType(that); - transformEqualOperation(EqualOperation that) => visitEqualOperation(that); - transformEqualityOperation(EqualityOperation that) => visitEqualityOperation(that); - transformExistsCondition(ExistsCondition that) => visitExistsCondition(that); - transformExistsOperation(ExistsOperation that) => visitExistsOperation(that); - transformExistsOrNonemptyCondition(ExistsOrNonemptyCondition that) => visitExistsOrNonemptyCondition(that); - transformExponentiationOperation(ExponentiationOperation that) => visitExponentiationOperation(that); - transformExpression(Expression that) => visitExpression(that); - transformExpressionComprehensionClause(ExpressionComprehensionClause that) => visitExpressionComprehensionClause(that); - transformExpressionStatement(ExpressionStatement that) => visitExpressionStatement(that); - transformExtendedType(ExtendedType that) => visitExtendedType(that); - transformExtension(Extension that) => visitExtension(that); - transformExtensionOrConstruction(ExtensionOrConstruction that) => visitExtensionOrConstruction(that); - transformFailClause(FailClause that) => visitFailClause(that); - transformFinallyClause(FinallyClause that) => visitFinallyClause(that); - transformFloatLiteral(FloatLiteral that) => visitFloatLiteral(that); - transformForClause(ForClause that) => visitForClause(that); - transformForComprehensionClause(ForComprehensionClause that) => visitForComprehensionClause(that); - transformForFail(ForFail that) => visitForFail(that); - transformForIterator(ForIterator that) => visitForIterator(that); - transformFullPackageName(FullPackageName that) => visitFullPackageName(that); - transformFunctionArgument(FunctionArgument that) => visitFunctionArgument(that); - transformFunctionDec(FunctionDec that) => visitFunctionDec(that); - transformFunctionDeclaration(FunctionDeclaration that) => visitFunctionDeclaration(that); - transformFunctionDefinition(FunctionDefinition that) => visitFunctionDefinition(that); - transformFunctionExpression(FunctionExpression that) => visitFunctionExpression(that); - transformFunctionModifier(FunctionModifier that) => visitFunctionModifier(that); - transformFunctionShortcutDefinition(FunctionShortcutDefinition that) => visitFunctionShortcutDefinition(that); - transformGivenDec(GivenDec that) => visitGivenDec(that); - transformGroupedExpression(GroupedExpression that) => visitGroupedExpression(that); - transformGroupedType(GroupedType that) => visitGroupedType(that); - transformIdenticalOperation(IdenticalOperation that) => visitIdenticalOperation(that); - transformIdentifier(Identifier that) => visitIdentifier(that); - transformIdentityOperation(IdentityOperation that) => visitIdentityOperation(that); - transformIfClause(IfClause that) => visitIfClause(that); - transformIfComprehensionClause(IfComprehensionClause that) => visitIfComprehensionClause(that); - transformIfElse(IfElse that) => visitIfElse(that); - transformIfElseExpression(IfElseExpression that) => visitIfElseExpression(that); - transformImport(Import that) => visitImport(that); - transformImportAlias(ImportAlias that) => visitImportAlias(that); - transformImportElement(ImportElement that) => visitImportElement(that); - transformImportElements(ImportElements that) => visitImportElements(that); - transformImportFunctionValueAlias(ImportFunctionValueAlias that) => visitImportFunctionValueAlias(that); - transformImportFunctionValueElement(ImportFunctionValueElement that) => visitImportFunctionValueElement(that); - transformImportTypeAlias(ImportTypeAlias that) => visitImportTypeAlias(that); - transformImportTypeElement(ImportTypeElement that) => visitImportTypeElement(that); - transformImportWildcard(ImportWildcard that) => visitImportWildcard(that); - transformInModifier(InModifier that) => visitInModifier(that); - transformInOperation(InOperation that) => visitInOperation(that); - transformInitialComprehensionClause(InitialComprehensionClause that) => visitInitialComprehensionClause(that); - transformInlineDefinitionArgument(InlineDefinitionArgument that) => visitInlineDefinitionArgument(that); - transformIntegerLiteral(IntegerLiteral that) => visitIntegerLiteral(that); - transformInterfaceAliasDefinition(InterfaceAliasDefinition that) => visitInterfaceAliasDefinition(that); - transformInterfaceBody(InterfaceBody that) => visitInterfaceBody(that); - transformInterfaceDec(InterfaceDec that) => visitInterfaceDec(that); - transformInterfaceDefinition(InterfaceDefinition that) => visitInterfaceDefinition(that); - transformIntersectAssignmentOperation(IntersectAssignmentOperation that) => visitIntersectAssignmentOperation(that); - transformIntersectionOperation(IntersectionOperation that) => visitIntersectionOperation(that); - transformIntersectionType(IntersectionType that) => visitIntersectionType(that); - transformInvocation(Invocation that) => visitInvocation(that); - transformInvocationStatement(InvocationStatement that) => visitInvocationStatement(that); - transformIsCase(IsCase that) => visitIsCase(that); - transformIsCondition(IsCondition that) => visitIsCondition(that); - transformIsOperation(IsOperation that) => visitIsOperation(that); - transformIterable(Iterable that) => visitIterable(that); - transformIterableType(IterableType that) => visitIterableType(that); - transformKeySubscript(KeySubscript that) => visitKeySubscript(that); - transformLIdentifier(LIdentifier that) => visitLIdentifier(that); - transformLargeAsOperation(LargeAsOperation that) => visitLargeAsOperation(that); - transformLargerOperation(LargerOperation that) => visitLargerOperation(that); - transformLazySpecification(LazySpecification that) => visitLazySpecification(that); - transformLazySpecifier(LazySpecifier that) => visitLazySpecifier(that); - transformLetExpression(LetExpression that) => visitLetExpression(that); - transformLiteral(Literal that) => visitLiteral(that); - transformLocalModifier(LocalModifier that) => visitLocalModifier(that); - transformLogicalAssignmentOperation(LogicalAssignmentOperation that) => visitLogicalAssignmentOperation(that); - transformLogicalOperation(LogicalOperation that) => visitLogicalOperation(that); - transformMainType(MainType that) => visitMainType(that); - transformMatchCase(MatchCase that) => visitMatchCase(that); - transformMeasureOperation(MeasureOperation that) => visitMeasureOperation(that); - transformMeasureSubscript(MeasureSubscript that) => visitMeasureSubscript(that); - transformMemberDec(MemberDec that) => visitMemberDec(that); - transformMemberMeta(MemberMeta that) => visitMemberMeta(that); - transformMemberNameWithTypeArguments(MemberNameWithTypeArguments that) => visitMemberNameWithTypeArguments(that); - transformMemberOperator(MemberOperator that) => visitMemberOperator(that); - transformMeta(Meta that) => visitMeta(that); - transformModifier(Modifier that) => visitModifier(that); - transformModuleBody(ModuleBody that) => visitModuleBody(that); - transformModuleCompilationUnit(ModuleCompilationUnit that) => visitModuleCompilationUnit(that); - transformModuleDec(ModuleDec that) => visitModuleDec(that); - transformModuleDescriptor(ModuleDescriptor that) => visitModuleDescriptor(that); - transformModuleImport(ModuleImport that) => visitModuleImport(that); - transformMultiplyAssignmentOperation(MultiplyAssignmentOperation that) => visitMultiplyAssignmentOperation(that); - transformNameWithTypeArguments(NameWithTypeArguments that) => visitNameWithTypeArguments(that); - transformNamedArgument(NamedArgument that) => visitNamedArgument(that); - transformNamedArguments(NamedArguments that) => visitNamedArguments(that); - transformNegationOperation(NegationOperation that) => visitNegationOperation(that); - transformNode(Node that) => visitNode(that); - transformNonemptyCondition(NonemptyCondition that) => visitNonemptyCondition(that); - transformNonemptyOperation(NonemptyOperation that) => visitNonemptyOperation(that); - transformNotEqualOperation(NotEqualOperation that) => visitNotEqualOperation(that); - transformNotOperation(NotOperation that) => visitNotOperation(that); - transformObjectArgument(ObjectArgument that) => visitObjectArgument(that); - transformObjectDefinition(ObjectDefinition that) => visitObjectDefinition(that); - transformObjectExpression(ObjectExpression that) => visitObjectExpression(that); - transformOfOperation(OfOperation that) => visitOfOperation(that); - transformOpenBound(OpenBound that) => visitOpenBound(that); - transformOperation(Operation that) => visitOperation(that); - transformOptionalType(OptionalType that) => visitOptionalType(that); - transformOrAssignmentOperation(OrAssignmentOperation that) => visitOrAssignmentOperation(that); - transformOrOperation(OrOperation that) => visitOrOperation(that); - transformOutModifier(OutModifier that) => visitOutModifier(that); - transformOuter(Outer that) => visitOuter(that); - transformPackage(Package that) => visitPackage(that); - transformPackageCompilationUnit(PackageCompilationUnit that) => visitPackageCompilationUnit(that); - transformPackageDec(PackageDec that) => visitPackageDec(that); - transformPackageDescriptor(PackageDescriptor that) => visitPackageDescriptor(that); - transformPackageQualifier(PackageQualifier that) => visitPackageQualifier(that); - transformParameter(Parameter that) => visitParameter(that); - transformParameterReference(ParameterReference that) => visitParameterReference(that); - transformParameters(Parameters that) => visitParameters(that); - transformPattern(Pattern that) => visitPattern(that); - transformPatternList(PatternList that) => visitPatternList(that); - transformPositionalArguments(PositionalArguments that) => visitPositionalArguments(that); - transformPostfixDecrementOperation(PostfixDecrementOperation that) => visitPostfixDecrementOperation(that); - transformPostfixIncrementOperation(PostfixIncrementOperation that) => visitPostfixIncrementOperation(that); - transformPostfixOperation(PostfixOperation that) => visitPostfixOperation(that); - transformPrefixDecrementOperation(PrefixDecrementOperation that) => visitPrefixDecrementOperation(that); - transformPrefixIncrementOperation(PrefixIncrementOperation that) => visitPrefixIncrementOperation(that); - transformPrefixOperation(PrefixOperation that) => visitPrefixOperation(that); - transformPrefixPostfixStatement(PrefixPostfixStatement that) => visitPrefixPostfixStatement(that); - transformPrimary(Primary that) => visitPrimary(that); - transformProductOperation(ProductOperation that) => visitProductOperation(that); - transformQualifiedExpression(QualifiedExpression that) => visitQualifiedExpression(that); - transformQualifiedType(QualifiedType that) => visitQualifiedType(that); - transformQuotientOperation(QuotientOperation that) => visitQuotientOperation(that); - transformRangeSubscript(RangeSubscript that) => visitRangeSubscript(that); - transformRemainderAssignmentOperation(RemainderAssignmentOperation that) => visitRemainderAssignmentOperation(that); - transformRemainderOperation(RemainderOperation that) => visitRemainderOperation(that); - transformRequiredParameter(RequiredParameter that) => visitRequiredParameter(that); - transformResource(Resource that) => visitResource(that); - transformResources(Resources that) => visitResources(that); - transformReturn(Return that) => visitReturn(that); - transformSafeMemberOperator(SafeMemberOperator that) => visitSafeMemberOperator(that); - transformSatisfiedTypes(SatisfiedTypes that) => visitSatisfiedTypes(that); - transformScaleOperation(ScaleOperation that) => visitScaleOperation(that); - transformSelfReference(SelfReference that) => visitSelfReference(that); - transformSequentialType(SequentialType that) => visitSequentialType(that); - transformSetAssignmentOperation(SetAssignmentOperation that) => visitSetAssignmentOperation(that); - transformSetOperation(SetOperation that) => visitSetOperation(that); - transformSimpleType(SimpleType that) => visitSimpleType(that); - transformSmallAsOperation(SmallAsOperation that) => visitSmallAsOperation(that); - transformSmallerOperation(SmallerOperation that) => visitSmallerOperation(that); - transformSpanFromSubscript(SpanFromSubscript that) => visitSpanFromSubscript(that); - transformSpanOperation(SpanOperation that) => visitSpanOperation(that); - transformSpanSubscript(SpanSubscript that) => visitSpanSubscript(that); - transformSpanToSubscript(SpanToSubscript that) => visitSpanToSubscript(that); - transformSpecification(Specification that) => visitSpecification(that); - transformSpecifiedArgument(SpecifiedArgument that) => visitSpecifiedArgument(that); - transformSpecifiedPattern(SpecifiedPattern that) => visitSpecifiedPattern(that); - transformSpecifiedVariable(SpecifiedVariable that) => visitSpecifiedVariable(that); - transformSpecifier(Specifier that) => visitSpecifier(that); - transformSpreadArgument(SpreadArgument that) => visitSpreadArgument(that); - transformSpreadMemberOperator(SpreadMemberOperator that) => visitSpreadMemberOperator(that); - transformSpreadType(SpreadType that) => visitSpreadType(that); - transformStatement(Statement that) => visitStatement(that); - transformStringLiteral(StringLiteral that) => visitStringLiteral(that); - transformStringTemplate(StringTemplate that) => visitStringTemplate(that); - transformSubscript(Subscript that) => visitSubscript(that); - transformSubtractAssignmentOperation(SubtractAssignmentOperation that) => visitSubtractAssignmentOperation(that); - transformSumOperation(SumOperation that) => visitSumOperation(that); - transformSuper(Super that) => visitSuper(that); - transformSwitchCaseElse(SwitchCaseElse that) => visitSwitchCaseElse(that); - transformSwitchCaseElseExpression(SwitchCaseElseExpression that) => visitSwitchCaseElseExpression(that); - transformSwitchCases(SwitchCases that) => visitSwitchCases(that); - transformSwitchClause(SwitchClause that) => visitSwitchClause(that); - transformThenOperation(ThenOperation that) => visitThenOperation(that); - transformThis(This that) => visitThis(that); - transformThrow(Throw that) => visitThrow(that); - transformTryCatchFinally(TryCatchFinally that) => visitTryCatchFinally(that); - transformTryClause(TryClause that) => visitTryClause(that); - transformTuple(Tuple that) => visitTuple(that); - transformTuplePattern(TuplePattern that) => visitTuplePattern(that); - transformTupleType(TupleType that) => visitTupleType(that); - transformType(Type that) => visitType(that); - transformTypeAliasDefinition(TypeAliasDefinition that) => visitTypeAliasDefinition(that); - transformTypeArgument(TypeArgument that) => visitTypeArgument(that); - transformTypeArguments(TypeArguments that) => visitTypeArguments(that); - transformTypeConstraint(TypeConstraint that) => visitTypeConstraint(that); - transformTypeDec(TypeDec that) => visitTypeDec(that); - transformTypeDeclaration(TypeDeclaration that) => visitTypeDeclaration(that); - transformTypeList(TypeList that) => visitTypeList(that); - transformTypeMeta(TypeMeta that) => visitTypeMeta(that); - transformTypeModifier(TypeModifier that) => visitTypeModifier(that); - transformTypeNameWithTypeArguments(TypeNameWithTypeArguments that) => visitTypeNameWithTypeArguments(that); - transformTypeParameter(TypeParameter that) => visitTypeParameter(that); - transformTypeParameters(TypeParameters that) => visitTypeParameters(that); - transformTypeSpecifier(TypeSpecifier that) => visitTypeSpecifier(that); - transformTypedDeclaration(TypedDeclaration that) => visitTypedDeclaration(that); - transformTypedVariable(TypedVariable that) => visitTypedVariable(that); - transformUIdentifier(UIdentifier that) => visitUIdentifier(that); - transformUnaryArithmeticOperation(UnaryArithmeticOperation that) => visitUnaryArithmeticOperation(that); - transformUnaryIshOperation(UnaryIshOperation that) => visitUnaryIshOperation(that); - transformUnaryOperation(UnaryOperation that) => visitUnaryOperation(that); - transformUnaryTypeOperation(UnaryTypeOperation that) => visitUnaryTypeOperation(that); - transformUnionAssignmentOperation(UnionAssignmentOperation that) => visitUnionAssignmentOperation(that); - transformUnionOperation(UnionOperation that) => visitUnionOperation(that); - transformUnionType(UnionType that) => visitUnionType(that); - transformUnionableType(UnionableType that) => visitUnionableType(that); - transformUnspecifiedVariable(UnspecifiedVariable that) => visitUnspecifiedVariable(that); - transformValueArgument(ValueArgument that) => visitValueArgument(that); - transformValueConstructorDefinition(ValueConstructorDefinition that) => visitValueConstructorDefinition(that); - transformValueDec(ValueDec that) => visitValueDec(that); - transformValueDeclaration(ValueDeclaration that) => visitValueDeclaration(that); - transformValueDefinition(ValueDefinition that) => visitValueDefinition(that); - transformValueExpression(ValueExpression that) => visitValueExpression(that); - transformValueGetterDefinition(ValueGetterDefinition that) => visitValueGetterDefinition(that); - transformValueModifier(ValueModifier that) => visitValueModifier(that); - transformValueParameter(ValueParameter that) => visitValueParameter(that); - transformValueSetterDefinition(ValueSetterDefinition that) => visitValueSetterDefinition(that); - transformValueSpecification(ValueSpecification that) => visitValueSpecification(that); - transformVariable(Variable that) => visitVariable(that); - transformVariablePattern(VariablePattern that) => visitVariablePattern(that); - transformVariadicParameter(VariadicParameter that) => visitVariadicParameter(that); - transformVariadicVariable(VariadicVariable that) => visitVariadicVariable(that); - transformVariance(Variance that) => visitVariance(that); - transformVoidModifier(VoidModifier that) => visitVoidModifier(that); - transformWhile(While that) => visitWhile(that); - transformWithinOperation(WithinOperation that) => visitWithinOperation(that); - - shared default void visitAddAssignmentOperation(AddAssignmentOperation that) => super.transformAddAssignmentOperation(that); - shared default void visitAliasDec(AliasDec that) => super.transformAliasDec(that); - shared default void visitAndAssignmentOperation(AndAssignmentOperation that) => super.transformAndAssignmentOperation(that); - shared default void visitAndOperation(AndOperation that) => super.transformAndOperation(that); - shared default void visitAnnotation(Annotation that) => super.transformAnnotation(that); - shared default void visitAnnotations(Annotations that) => super.transformAnnotations(that); - shared default void visitAnonymousArgument(AnonymousArgument that) => super.transformAnonymousArgument(that); - shared default void visitAnyClass(AnyClass that) => super.transformAnyClass(that); - shared default void visitAnyCompilationUnit(AnyCompilationUnit that) => super.transformAnyCompilationUnit(that); - shared default void visitAnyFunction(AnyFunction that) => super.transformAnyFunction(that); - shared default void visitAnyInterface(AnyInterface that) => super.transformAnyInterface(that); - shared default void visitAnyInterfaceDefinition(AnyInterfaceDefinition that) => super.transformAnyInterfaceDefinition(that); - shared default void visitAnyMemberOperator(AnyMemberOperator that) => super.transformAnyMemberOperator(that); - shared default void visitAnySpecifier(AnySpecifier that) => super.transformAnySpecifier(that); - shared default void visitAnyValue(AnyValue that) => super.transformAnyValue(that); - shared default void visitArgumentList(ArgumentList that) => super.transformArgumentList(that); - shared default void visitArguments(Arguments that) => super.transformArguments(that); - shared default void visitArithmeticAssignmentOperation(ArithmeticAssignmentOperation that) => super.transformArithmeticAssignmentOperation(that); - shared default void visitArithmeticOperation(ArithmeticOperation that) => super.transformArithmeticOperation(that); - shared default void visitAssertion(Assertion that) => super.transformAssertion(that); - shared default void visitAssignmentOperation(AssignmentOperation that) => super.transformAssignmentOperation(that); - shared default void visitAssignmentStatement(AssignmentStatement that) => super.transformAssignmentStatement(that); - shared default void visitAssignOperation(AssignOperation that) => super.transformAssignOperation(that); - shared default void visitAtom(Atom that) => super.transformAtom(that); - shared default void visitBaseExpression(BaseExpression that) => super.transformBaseExpression(that); - shared default void visitBaseMeta(BaseMeta that) => super.transformBaseMeta(that); - shared default void visitBaseType(BaseType that) => super.transformBaseType(that); - shared default void visitBinaryOperation(BinaryOperation that) => super.transformBinaryOperation(that); - shared default void visitBlock(Block that) => super.transformBlock(that); - shared default void visitBody(Body that) => super.transformBody(that); - shared default void visitBooleanCondition(BooleanCondition that) => super.transformBooleanCondition(that); - shared default void visitBound(Bound that) => super.transformBound(that); - shared default void visitBreak(Break that) => super.transformBreak(that); - shared default void visitCallableParameter(CallableParameter that) => super.transformCallableParameter(that); - shared default void visitCallableType(CallableType that) => super.transformCallableType(that); - shared default void visitCaseClause(CaseClause that) => super.transformCaseClause(that); - shared default void visitCaseExpression(CaseExpression that) => super.transformCaseExpression(that); - shared default void visitCaseItem(CaseItem that) => super.transformCaseItem(that); - shared default void visitCaseTypes(CaseTypes that) => super.transformCaseTypes(that); - shared default void visitCatchClause(CatchClause that) => super.transformCatchClause(that); - shared default void visitCharacterLiteral(CharacterLiteral that) => super.transformCharacterLiteral(that); - shared default void visitClassAliasDefinition(ClassAliasDefinition that) => super.transformClassAliasDefinition(that); - shared default void visitClassBody(ClassBody that) => super.transformClassBody(that); - shared default void visitClassDec(ClassDec that) => super.transformClassDec(that); - shared default void visitClassDefinition(ClassDefinition that) => super.transformClassDefinition(that); - shared default void visitClassOrInterface(ClassOrInterface that) => super.transformClassOrInterface(that); - shared default void visitClassSpecifier(ClassSpecifier that) => super.transformClassSpecifier(that); - shared default void visitClosedBound(ClosedBound that) => super.transformClosedBound(that); - shared default void visitCompareOperation(CompareOperation that) => super.transformCompareOperation(that); - shared default void visitComparisonOperation(ComparisonOperation that) => super.transformComparisonOperation(that); - shared default void visitCompilationUnit(CompilationUnit that) => super.transformCompilationUnit(that); - shared default void visitComplementAssignmentOperation(ComplementAssignmentOperation that) => super.transformComplementAssignmentOperation(that); - shared default void visitComplementOperation(ComplementOperation that) => super.transformComplementOperation(that); - shared default void visitComprehensionClause(ComprehensionClause that) => super.transformComprehensionClause(that); - shared default void visitComprehension(Comprehension that) => super.transformComprehension(that); - shared default void visitCondition(Condition that) => super.transformCondition(that); - shared default void visitConditionalExpression(ConditionalExpression that) => super.transformConditionalExpression(that); - shared default void visitConditions(Conditions that) => super.transformConditions(that); - shared default void visitConstruction(Construction that) => super.transformConstruction(that); - shared default void visitConstructorDec(ConstructorDec that) => super.transformConstructorDec(that); - shared default void visitCallableConstructorDefinition(CallableConstructorDefinition that) => super.transformCallableConstructorDefinition(that); - shared default void visitConstructorDefinition(ConstructorDefinition that) => super.transformConstructorDefinition(that); - shared default void visitContinue(Continue that) => super.transformContinue(that); - shared default void visitControlStructure(ControlStructure that) => super.transformControlStructure(that); - shared default void visitDec(Dec that) => super.transformDec(that); - shared default void visitDeclaration(Declaration that) => super.transformDeclaration(that); - shared default void visitDecQualifier(DecQualifier that) => super.transformDecQualifier(that); - shared default void visitDefaultedCallableParameter(DefaultedCallableParameter that) => super.transformDefaultedCallableParameter(that); - shared default void visitDefaultedParameter(DefaultedParameter that) => super.transformDefaultedParameter(that); - shared default void visitDefaultedParameterReference(DefaultedParameterReference that) => super.transformDefaultedParameterReference(that); - shared default void visitDefaultedType(DefaultedType that) => super.transformDefaultedType(that); - shared default void visitDefaultedValueParameter(DefaultedValueParameter that) => super.transformDefaultedValueParameter(that); - shared default void visitDestructure(Destructure that) => super.transformDestructure(that); - shared default void visitDifferenceOperation(DifferenceOperation that) => super.transformDifferenceOperation(that); - shared default void visitDirective(Directive that) => super.transformDirective(that); - shared default void visitDivideAssignmentOperation(DivideAssignmentOperation that) => super.transformDivideAssignmentOperation(that); - shared default void visitDynamicBlock(DynamicBlock that) => super.transformDynamicBlock(that); - shared default void visitDynamicInterfaceDefinition(DynamicInterfaceDefinition that) => super.transformDynamicInterfaceDefinition(that); - shared default void visitDynamicModifier(DynamicModifier that) => super.transformDynamicModifier(that); - shared default void visitDynamicValue(DynamicValue that) => super.transformDynamicValue(that); - shared default void visitElementOrSubrangeExpression(ElementOrSubrangeExpression that) => super.transformElementOrSubrangeExpression(that); - shared default void visitElseClause(ElseClause that) => super.transformElseClause(that); - shared default void visitElseOperation(ElseOperation that) => super.transformElseOperation(that); - shared default void visitEntryOperation(EntryOperation that) => super.transformEntryOperation(that); - shared default void visitEntryPattern(EntryPattern that) => super.transformEntryPattern(that); - shared default void visitEntryType(EntryType that) => super.transformEntryType(that); - shared default void visitEqualityOperation(EqualityOperation that) => super.transformEqualityOperation(that); - shared default void visitEqualOperation(EqualOperation that) => super.transformEqualOperation(that); - shared default void visitExistsCondition(ExistsCondition that) => super.transformExistsCondition(that); - shared default void visitExistsOperation(ExistsOperation that) => super.transformExistsOperation(that); - shared default void visitExistsOrNonemptyCondition(ExistsOrNonemptyCondition that) => super.transformExistsOrNonemptyCondition(that); - shared default void visitExponentiationOperation(ExponentiationOperation that) => super.transformExponentiationOperation(that); - shared default void visitExpressionComprehensionClause(ExpressionComprehensionClause that) => super.transformExpressionComprehensionClause(that); - shared default void visitExpression(Expression that) => super.transformExpression(that); - shared default void visitExpressionStatement(ExpressionStatement that) => super.transformExpressionStatement(that); - shared default void visitExtendedType(ExtendedType that) => super.transformExtendedType(that); - shared default void visitExtension(Extension that) => super.transformExtension(that); - shared default void visitExtensionOrConstruction(ExtensionOrConstruction that) => super.transformExtensionOrConstruction(that); - shared default void visitFailClause(FailClause that) => super.transformFailClause(that); - shared default void visitFinallyClause(FinallyClause that) => super.transformFinallyClause(that); - shared default void visitFloatLiteral(FloatLiteral that) => super.transformFloatLiteral(that); - shared default void visitForClause(ForClause that) => super.transformForClause(that); - shared default void visitForComprehensionClause(ForComprehensionClause that) => super.transformForComprehensionClause(that); - shared default void visitForFail(ForFail that) => super.transformForFail(that); - shared default void visitForIterator(ForIterator that) => super.transformForIterator(that); - shared default void visitFullPackageName(FullPackageName that) => super.transformFullPackageName(that); - shared default void visitFunctionArgument(FunctionArgument that) => super.transformFunctionArgument(that); - shared default void visitFunctionDec(FunctionDec that) => super.transformFunctionDec(that); - shared default void visitFunctionDeclaration(FunctionDeclaration that) => super.transformFunctionDeclaration(that); - shared default void visitFunctionDefinition(FunctionDefinition that) => super.transformFunctionDefinition(that); - shared default void visitFunctionExpression(FunctionExpression that) => super.transformFunctionExpression(that); - shared default void visitFunctionModifier(FunctionModifier that) => super.transformFunctionModifier(that); - shared default void visitFunctionShortcutDefinition(FunctionShortcutDefinition that) => super.transformFunctionShortcutDefinition(that); - shared default void visitGivenDec(GivenDec that) => super.transformGivenDec(that); - shared default void visitGroupedExpression(GroupedExpression that) => super.transformGroupedExpression(that); - shared default void visitGroupedType(GroupedType that) => super.transformGroupedType(that); - shared default void visitIdenticalOperation(IdenticalOperation that) => super.transformIdenticalOperation(that); - shared default void visitIdentifier(Identifier that) => super.transformIdentifier(that); - shared default void visitIdentityOperation(IdentityOperation that) => super.transformIdentityOperation(that); - shared default void visitIfClause(IfClause that) => super.transformIfClause(that); - shared default void visitIfComprehensionClause(IfComprehensionClause that) => super.transformIfComprehensionClause(that); - shared default void visitIfElse(IfElse that) => super.transformIfElse(that); - shared default void visitIfElseExpression(IfElseExpression that) => super.transformIfElseExpression(that); - shared default void visitImportAlias(ImportAlias that) => super.transformImportAlias(that); - shared default void visitImportElement(ImportElement that) => super.transformImportElement(that); - shared default void visitImportElements(ImportElements that) => super.transformImportElements(that); - shared default void visitImportFunctionValueAlias(ImportFunctionValueAlias that) => super.transformImportFunctionValueAlias(that); - shared default void visitImportFunctionValueElement(ImportFunctionValueElement that) => super.transformImportFunctionValueElement(that); - shared default void visitImport(Import that) => super.transformImport(that); - shared default void visitImportTypeAlias(ImportTypeAlias that) => super.transformImportTypeAlias(that); - shared default void visitImportTypeElement(ImportTypeElement that) => super.transformImportTypeElement(that); - shared default void visitImportWildcard(ImportWildcard that) => super.transformImportWildcard(that); - shared default void visitInitialComprehensionClause(InitialComprehensionClause that) => super.transformInitialComprehensionClause(that); - shared default void visitInlineDefinitionArgument(InlineDefinitionArgument that) => super.transformInlineDefinitionArgument(that); - shared default void visitInModifier(InModifier that) => super.transformInModifier(that); - shared default void visitInOperation(InOperation that) => super.transformInOperation(that); - shared default void visitIntegerLiteral(IntegerLiteral that) => super.transformIntegerLiteral(that); - shared default void visitInterfaceAliasDefinition(InterfaceAliasDefinition that) => super.transformInterfaceAliasDefinition(that); - shared default void visitInterfaceBody(InterfaceBody that) => super.transformInterfaceBody(that); - shared default void visitInterfaceDec(InterfaceDec that) => super.transformInterfaceDec(that); - shared default void visitInterfaceDefinition(InterfaceDefinition that) => super.transformInterfaceDefinition(that); - shared default void visitIntersectAssignmentOperation(IntersectAssignmentOperation that) => super.transformIntersectAssignmentOperation(that); - shared default void visitIntersectionOperation(IntersectionOperation that) => super.transformIntersectionOperation(that); - shared default void visitIntersectionType(IntersectionType that) => super.transformIntersectionType(that); - shared default void visitInvocation(Invocation that) => super.transformInvocation(that); - shared default void visitInvocationStatement(InvocationStatement that) => super.transformInvocationStatement(that); - shared default void visitIsCase(IsCase that) => super.transformIsCase(that); - shared default void visitIsCondition(IsCondition that) => super.transformIsCondition(that); - shared default void visitIsOperation(IsOperation that) => super.transformIsOperation(that); - shared default void visitIterable(Iterable that) => super.transformIterable(that); - shared default void visitIterableType(IterableType that) => super.transformIterableType(that); - shared default void visitKeySubscript(KeySubscript that) => super.transformKeySubscript(that); - shared default void visitLargeAsOperation(LargeAsOperation that) => super.transformLargeAsOperation(that); - shared default void visitLargerOperation(LargerOperation that) => super.transformLargerOperation(that); - shared default void visitLazySpecification(LazySpecification that) => super.transformLazySpecification(that); - shared default void visitLazySpecifier(LazySpecifier that) => super.transformLazySpecifier(that); - shared default void visitLIdentifier(LIdentifier that) => super.transformLIdentifier(that); - shared default void visitLetExpression(LetExpression that) => super.transformLetExpression(that); - shared default void visitLiteral(Literal that) => super.transformLiteral(that); - shared default void visitLocalModifier(LocalModifier that) => super.transformLocalModifier(that); - shared default void visitLogicalAssignmentOperation(LogicalAssignmentOperation that) => super.transformLogicalAssignmentOperation(that); - shared default void visitLogicalOperation(LogicalOperation that) => super.transformLogicalOperation(that); - shared default void visitMainType(MainType that) => super.transformMainType(that); - shared default void visitMatchCase(MatchCase that) => super.transformMatchCase(that); - shared default void visitMeasureOperation(MeasureOperation that) => super.transformMeasureOperation(that); - shared default void visitMeasureSubscript(MeasureSubscript that) => super.transformMeasureSubscript(that); - shared default void visitMemberDec(MemberDec that) => super.transformMemberDec(that); - shared default void visitMemberMeta(MemberMeta that) => super.transformMemberMeta(that); - shared default void visitMemberNameWithTypeArguments(MemberNameWithTypeArguments that) => super.transformMemberNameWithTypeArguments(that); - shared default void visitMemberOperator(MemberOperator that) => super.transformMemberOperator(that); - shared default void visitMeta(Meta that) => super.transformMeta(that); - shared default void visitModifier(Modifier that) => super.transformModifier(that); - shared default void visitModuleBody(ModuleBody that) => super.transformModuleBody(that); - shared default void visitModuleCompilationUnit(ModuleCompilationUnit that) => super.transformModuleCompilationUnit(that); - shared default void visitModuleDec(ModuleDec that) => super.transformModuleDec(that); - shared default void visitModuleDescriptor(ModuleDescriptor that) => super.transformModuleDescriptor(that); - shared default void visitModuleImport(ModuleImport that) => super.transformModuleImport(that); - shared default void visitMultiplyAssignmentOperation(MultiplyAssignmentOperation that) => super.transformMultiplyAssignmentOperation(that); - shared default void visitNamedArgument(NamedArgument that) => super.transformNamedArgument(that); - shared default void visitNamedArguments(NamedArguments that) => super.transformNamedArguments(that); - shared default void visitNameWithTypeArguments(NameWithTypeArguments that) => super.transformNameWithTypeArguments(that); - shared default void visitNegationOperation(NegationOperation that) => super.transformNegationOperation(that); +shared interface Visitor { + shared default void visitAddAssignmentOperation(AddAssignmentOperation that) => visitArithmeticAssignmentOperation(that); + shared default void visitAliasDec(AliasDec that) => visitTypeDec(that); + shared default void visitAndAssignmentOperation(AndAssignmentOperation that) => visitLogicalAssignmentOperation(that); + shared default void visitAndOperation(AndOperation that) => visitLogicalOperation(that); + shared default void visitAnnotation(Annotation that) => visitNode(that); + shared default void visitAnnotations(Annotations that) => visitNode(that); + shared default void visitAnonymousArgument(AnonymousArgument that) => visitNamedArgument(that); + shared default void visitAnyClass(AnyClass that) => visitClassOrInterface(that); + shared default void visitAnyCompilationUnit(AnyCompilationUnit that) => visitNode(that); + shared default void visitAnyFunction(AnyFunction that) => visitTypedDeclaration(that); + shared default void visitAnyInterface(AnyInterface that) => visitClassOrInterface(that); + shared default void visitAnyInterfaceDefinition(AnyInterfaceDefinition that) => visitAnyInterface(that); + shared default void visitAnyMemberOperator(AnyMemberOperator that) => visitNode(that); + shared default void visitAnyValue(AnyValue that) => visitTypedDeclaration(that); + shared default void visitAnySpecifier(AnySpecifier that) => visitNode(that); + shared default void visitArgumentList(ArgumentList that) => visitNode(that); + shared default void visitArguments(Arguments that) => visitNode(that); + shared default void visitArithmeticAssignmentOperation(ArithmeticAssignmentOperation that) => visitAssignmentOperation(that); + shared default void visitArithmeticOperation(ArithmeticOperation that) => visitBinaryOperation(that); + shared default void visitAssertion(Assertion that) => visitStatement(that); + shared default void visitAssignOperation(AssignOperation that) => visitAssignmentOperation(that); + shared default void visitAssignmentOperation(AssignmentOperation that) => visitBinaryOperation(that); + shared default void visitAssignmentStatement(AssignmentStatement that) => visitExpressionStatement(that); + shared default void visitAtom(Atom that) => visitPrimary(that); + shared default void visitBaseExpression(BaseExpression that) => visitPrimary(that); + shared default void visitBaseMeta(BaseMeta that) => visitMeta(that); + shared default void visitBaseType(BaseType that) => visitSimpleType(that); + shared default void visitBinaryOperation(BinaryOperation that) => visitOperation(that); + shared default void visitBlock(Block that) => visitBody(that); + shared default void visitBody(Body that) => visitNode(that); + shared default void visitBooleanCondition(BooleanCondition that) => visitCondition(that); + shared default void visitBound(Bound that) => visitNode(that); + shared default void visitBreak(Break that) => visitDirective(that); + shared default void visitCallableConstructorDefinition(CallableConstructorDefinition that) => visitConstructorDefinition(that); + shared default void visitCallableParameter(CallableParameter that) => visitRequiredParameter(that); + shared default void visitCallableType(CallableType that) => visitPrimaryType(that); + shared default void visitCaseClause(CaseClause that) => visitNode(that); + shared default void visitCaseExpression(CaseExpression that) => visitNode(that); + shared default void visitCaseItem(CaseItem that) => visitNode(that); + shared default void visitCaseTypes(CaseTypes that) => visitNode(that); + shared default void visitCatchClause(CatchClause that) => visitNode(that); + shared default void visitCharacterLiteral(CharacterLiteral that) => visitLiteral(that); + shared default void visitClassAliasDefinition(ClassAliasDefinition that) => visitAnyClass(that); + shared default void visitClassBody(ClassBody that) => visitBody(that); + shared default void visitClassDec(ClassDec that) => visitTypeDec(that); + shared default void visitClassDefinition(ClassDefinition that) => visitAnyClass(that); + shared default void visitClassOrInterface(ClassOrInterface that) => visitTypeDeclaration(that); + shared default void visitClassSpecifier(ClassSpecifier that) => visitNode(that); + shared default void visitClosedBound(ClosedBound that) => visitBound(that); + shared default void visitCompareOperation(CompareOperation that) => visitBinaryOperation(that); + shared default void visitComparisonOperation(ComparisonOperation that) => visitBinaryOperation(that); + shared default void visitCompilationUnit(CompilationUnit that) => visitAnyCompilationUnit(that); + shared default void visitComplementAssignmentOperation(ComplementAssignmentOperation that) => visitSetAssignmentOperation(that); + shared default void visitComplementOperation(ComplementOperation that) => visitSetOperation(that); + shared default void visitComprehension(Comprehension that) => visitNode(that); + shared default void visitComprehensionClause(ComprehensionClause that) => visitNode(that); + shared default void visitCondition(Condition that) => visitNode(that); + shared default void visitConditionalExpression(ConditionalExpression that) => visitExpression(that); + shared default void visitConditions(Conditions that) => visitNode(that); + shared default void visitConstruction(Construction that) => visitExtensionOrConstruction(that); + shared default void visitConstructorDec(ConstructorDec that) => visitDec(that); + shared default void visitConstructorDefinition(ConstructorDefinition that) => visitDeclaration(that); + shared default void visitContinue(Continue that) => visitDirective(that); + shared default void visitControlStructure(ControlStructure that) => visitStatement(that); + shared default void visitDec(Dec that) => visitPrimary(that); + shared default void visitDecQualifier(DecQualifier that) => visitNode(that); + shared default void visitDeclaration(Declaration that) => visitNode(that); + shared default void visitDefaultedCallableParameter(DefaultedCallableParameter that) => visitDefaultedParameter(that); + shared default void visitDefaultedParameter(DefaultedParameter that) => visitParameter(that); + shared default void visitDefaultedParameterReference(DefaultedParameterReference that) => visitDefaultedParameter(that); + shared default void visitDefaultedType(DefaultedType that) => visitTypeIsh(that); + shared default void visitDefaultedValueParameter(DefaultedValueParameter that) => visitDefaultedParameter(that); + shared default void visitDestructure(Destructure that) => visitStatement(that); + shared default void visitDifferenceOperation(DifferenceOperation that) => visitArithmeticOperation(that); + shared default void visitDirective(Directive that) => visitStatement(that); + shared default void visitDivideAssignmentOperation(DivideAssignmentOperation that) => visitArithmeticAssignmentOperation(that); + shared default void visitDynamicBlock(DynamicBlock that) => visitControlStructure(that); + shared default void visitDynamicInterfaceDefinition(DynamicInterfaceDefinition that) => visitAnyInterfaceDefinition(that); + shared default void visitDynamicModifier(DynamicModifier that) => visitTypeModifier(that); + shared default void visitDynamicValue(DynamicValue that) => visitAtom(that); + shared default void visitElementOrSubrangeExpression(ElementOrSubrangeExpression that) => visitPrimary(that); + shared default void visitElseClause(ElseClause that) => visitNode(that); + shared default void visitElseOperation(ElseOperation that) => visitBinaryOperation(that); + shared default void visitEntryOperation(EntryOperation that) => visitBinaryOperation(that); + shared default void visitEntryPattern(EntryPattern that) => visitPattern(that); + shared default void visitEntryType(EntryType that) => visitType(that); + shared default void visitEqualOperation(EqualOperation that) => visitEqualityOperation(that); + shared default void visitEqualityOperation(EqualityOperation that) => visitBinaryOperation(that); + shared default void visitExistsCondition(ExistsCondition that) => visitExistsOrNonemptyCondition(that); + shared default void visitExistsOperation(ExistsOperation that) => visitUnaryOperation(that); + shared default void visitExistsOrNonemptyCondition(ExistsOrNonemptyCondition that) => visitCondition(that); + shared default void visitExponentiationOperation(ExponentiationOperation that) => visitArithmeticOperation(that); + shared default void visitExpression(Expression that) => visitNode(that); + shared default void visitExpressionComprehensionClause(ExpressionComprehensionClause that) => visitComprehensionClause(that); + shared default void visitExpressionStatement(ExpressionStatement that) => visitStatement(that); + shared default void visitExtendedType(ExtendedType that) => visitNode(that); + shared default void visitExtension(Extension that) => visitExtensionOrConstruction(that); + shared default void visitExtensionOrConstruction(ExtensionOrConstruction that) => visitNode(that); + shared default void visitFailClause(FailClause that) => visitNode(that); + shared default void visitFinallyClause(FinallyClause that) => visitNode(that); + shared default void visitFloatLiteral(FloatLiteral that) => visitLiteral(that); + shared default void visitForClause(ForClause that) => visitNode(that); + shared default void visitForComprehensionClause(ForComprehensionClause that) => visitInitialComprehensionClause(that); + shared default void visitForFail(ForFail that) => visitControlStructure(that); + shared default void visitForIterator(ForIterator that) => visitNode(that); + shared default void visitFullPackageName(FullPackageName that) => visitNode(that); + shared default void visitFunctionArgument(FunctionArgument that) => visitInlineDefinitionArgument(that); + shared default void visitFunctionDec(FunctionDec that) => visitMemberDec(that); + shared default void visitFunctionDeclaration(FunctionDeclaration that) => visitAnyFunction(that); + shared default void visitFunctionDefinition(FunctionDefinition that) => visitAnyFunction(that); + shared default void visitFunctionExpression(FunctionExpression that) => visitExpression(that); + shared default void visitFunctionModifier(FunctionModifier that) => visitLocalModifier(that); + shared default void visitFunctionShortcutDefinition(FunctionShortcutDefinition that) => visitAnyFunction(that); + shared default void visitGivenDec(GivenDec that) => visitTypeDec(that); + shared default void visitGroupedExpression(GroupedExpression that) => visitAtom(that); + shared default void visitGroupedType(GroupedType that) => visitPrimaryType(that); + shared default void visitIdenticalOperation(IdenticalOperation that) => visitEqualityOperation(that); + shared default void visitIdentifier(Identifier that) => visitNode(that); + shared default void visitIdentityOperation(IdentityOperation that) => visitUnaryArithmeticOperation(that); + shared default void visitIfClause(IfClause that) => visitNode(that); + shared default void visitIfComprehensionClause(IfComprehensionClause that) => visitInitialComprehensionClause(that); + shared default void visitIfElse(IfElse that) => visitControlStructure(that); + shared default void visitIfElseExpression(IfElseExpression that) => visitConditionalExpression(that); + shared default void visitImport(Import that) => visitNode(that); + shared default void visitImportAlias(ImportAlias that) => visitNode(that); + shared default void visitImportElement(ImportElement that) => visitNode(that); + shared default void visitImportElements(ImportElements that) => visitNode(that); + shared default void visitImportFunctionValueAlias(ImportFunctionValueAlias that) => visitImportAlias(that); + shared default void visitImportFunctionValueElement(ImportFunctionValueElement that) => visitImportElement(that); + shared default void visitImportTypeAlias(ImportTypeAlias that) => visitImportAlias(that); + shared default void visitImportTypeElement(ImportTypeElement that) => visitImportElement(that); + shared default void visitImportWildcard(ImportWildcard that) => visitNode(that); + shared default void visitInModifier(InModifier that) => visitVariance(that); + shared default void visitInOperation(InOperation that) => visitBinaryOperation(that); + shared default void visitInitialComprehensionClause(InitialComprehensionClause that) => visitComprehensionClause(that); + shared default void visitInlineDefinitionArgument(InlineDefinitionArgument that) => visitNamedArgument(that); + shared default void visitIntegerLiteral(IntegerLiteral that) => visitLiteral(that); + shared default void visitInterfaceAliasDefinition(InterfaceAliasDefinition that) => visitAnyInterface(that); + shared default void visitInterfaceBody(InterfaceBody that) => visitBody(that); + shared default void visitInterfaceDec(InterfaceDec that) => visitTypeDec(that); + shared default void visitInterfaceDefinition(InterfaceDefinition that) => visitAnyInterfaceDefinition(that); + shared default void visitIntersectAssignmentOperation(IntersectAssignmentOperation that) => visitSetAssignmentOperation(that); + shared default void visitIntersectionOperation(IntersectionOperation that) => visitSetOperation(that); + shared default void visitIntersectionType(IntersectionType that) => visitUnionableType(that); + shared default void visitInvocation(Invocation that) => visitPrimary(that); + shared default void visitInvocationStatement(InvocationStatement that) => visitExpressionStatement(that); + shared default void visitIsCase(IsCase that) => visitCaseItem(that); + shared default void visitIsCondition(IsCondition that) => visitCondition(that); + shared default void visitIsOperation(IsOperation that) => visitUnaryTypeOperation(that); + shared default void visitIterable(Iterable that) => visitAtom(that); + shared default void visitIterableType(IterableType that) => visitPrimaryType(that); + shared default void visitKeySubscript(KeySubscript that) => visitSubscript(that); + shared default void visitLIdentifier(LIdentifier that) => visitIdentifier(that); + shared default void visitLargeAsOperation(LargeAsOperation that) => visitComparisonOperation(that); + shared default void visitLargerOperation(LargerOperation that) => visitComparisonOperation(that); + shared default void visitLazySpecification(LazySpecification that) => visitSpecification(that); + shared default void visitLazySpecifier(LazySpecifier that) => visitAnySpecifier(that); + shared default void visitLetExpression(LetExpression that) => visitExpression(that); + shared default void visitLiteral(Literal that) => visitAtom(that); + shared default void visitLocalModifier(LocalModifier that) => visitTypeModifier(that); + shared default void visitLogicalAssignmentOperation(LogicalAssignmentOperation that) => visitAssignmentOperation(that); + shared default void visitLogicalOperation(LogicalOperation that) => visitBinaryOperation(that); + shared default void visitMainType(MainType that) => visitType(that); + shared default void visitMatchCase(MatchCase that) => visitCaseItem(that); + shared default void visitMeasureOperation(MeasureOperation that) => visitBinaryOperation(that); + shared default void visitMeasureSubscript(MeasureSubscript that) => visitRangeSubscript(that); + shared default void visitMemberDec(MemberDec that) => visitDec(that); + shared default void visitMemberMeta(MemberMeta that) => visitMeta(that); + shared default void visitMemberNameWithTypeArguments(MemberNameWithTypeArguments that) => visitNameWithTypeArguments(that); + shared default void visitMemberOperator(MemberOperator that) => visitAnyMemberOperator(that); + shared default void visitMeta(Meta that) => visitPrimary(that); + shared default void visitModifier(Modifier that) => visitNode(that); + shared default void visitModuleBody(ModuleBody that) => visitNode(that); + shared default void visitModuleCompilationUnit(ModuleCompilationUnit that) => visitAnyCompilationUnit(that); + shared default void visitModuleDec(ModuleDec that) => visitDec(that); + shared default void visitModuleDescriptor(ModuleDescriptor that) => visitNode(that); + shared default void visitModuleImport(ModuleImport that) => visitNode(that); + shared default void visitMultiplyAssignmentOperation(MultiplyAssignmentOperation that) => visitArithmeticAssignmentOperation(that); + shared default void visitNameWithTypeArguments(NameWithTypeArguments that) => visitTypeIsh(that); + shared default void visitNamedArgument(NamedArgument that) => visitNode(that); + shared default void visitNamedArguments(NamedArguments that) => visitArguments(that); + shared default void visitNegationOperation(NegationOperation that) => visitUnaryArithmeticOperation(that); shared default void visitNode(Node that) => that.visitChildren(this); - shared default void visitNonemptyCondition(NonemptyCondition that) => super.transformNonemptyCondition(that); - shared default void visitNonemptyOperation(NonemptyOperation that) => super.transformNonemptyOperation(that); - shared default void visitNotEqualOperation(NotEqualOperation that) => super.transformNotEqualOperation(that); - shared default void visitNotOperation(NotOperation that) => super.transformNotOperation(that); - shared default void visitObjectArgument(ObjectArgument that) => super.transformObjectArgument(that); - shared default void visitObjectDefinition(ObjectDefinition that) => super.transformObjectDefinition(that); - shared default void visitObjectExpression(ObjectExpression that) => super.transformObjectExpression(that); - shared default void visitOfOperation(OfOperation that) => super.transformOfOperation(that); - shared default void visitOpenBound(OpenBound that) => super.transformOpenBound(that); - shared default void visitOperation(Operation that) => super.transformOperation(that); - shared default void visitOptionalType(OptionalType that) => super.transformOptionalType(that); - shared default void visitOrAssignmentOperation(OrAssignmentOperation that) => super.transformOrAssignmentOperation(that); - shared default void visitOrOperation(OrOperation that) => super.transformOrOperation(that); - shared default void visitOuter(Outer that) => super.transformOuter(that); - shared default void visitOutModifier(OutModifier that) => super.transformOutModifier(that); - shared default void visitPackageCompilationUnit(PackageCompilationUnit that) => super.transformPackageCompilationUnit(that); - shared default void visitPackageDec(PackageDec that) => super.transformPackageDec(that); - shared default void visitPackageDescriptor(PackageDescriptor that) => super.transformPackageDescriptor(that); - shared default void visitPackage(Package that) => super.transformPackage(that); - shared default void visitPackageQualifier(PackageQualifier that) => super.transformPackageQualifier(that); - shared default void visitParameter(Parameter that) => super.transformParameter(that); - shared default void visitParameterReference(ParameterReference that) => super.transformParameterReference(that); - shared default void visitParameters(Parameters that) => super.transformParameters(that); - shared default void visitPattern(Pattern that) => super.transformPattern(that); - shared default void visitPatternList(PatternList that) => super.transformPatternList(that); - shared default void visitPositionalArguments(PositionalArguments that) => super.transformPositionalArguments(that); - shared default void visitPostfixDecrementOperation(PostfixDecrementOperation that) => super.transformPostfixDecrementOperation(that); - shared default void visitPostfixIncrementOperation(PostfixIncrementOperation that) => super.transformPostfixIncrementOperation(that); - shared default void visitPostfixOperation(PostfixOperation that) => super.transformPostfixOperation(that); - shared default void visitPrefixDecrementOperation(PrefixDecrementOperation that) => super.transformPrefixDecrementOperation(that); - shared default void visitPrefixIncrementOperation(PrefixIncrementOperation that) => super.transformPrefixIncrementOperation(that); - shared default void visitPrefixOperation(PrefixOperation that) => super.transformPrefixOperation(that); - shared default void visitPrefixPostfixStatement(PrefixPostfixStatement that) => super.transformPrefixPostfixStatement(that); - shared default void visitPrimary(Primary that) => super.transformPrimary(that); - shared default void visitProductOperation(ProductOperation that) => super.transformProductOperation(that); - shared default void visitQualifiedExpression(QualifiedExpression that) => super.transformQualifiedExpression(that); - shared default void visitQualifiedType(QualifiedType that) => super.transformQualifiedType(that); - shared default void visitQuotientOperation(QuotientOperation that) => super.transformQuotientOperation(that); - shared default void visitRangeSubscript(RangeSubscript that) => super.transformRangeSubscript(that); - shared default void visitRemainderAssignmentOperation(RemainderAssignmentOperation that) => super.transformRemainderAssignmentOperation(that); - shared default void visitRemainderOperation(RemainderOperation that) => super.transformRemainderOperation(that); - shared default void visitRequiredParameter(RequiredParameter that) => super.transformRequiredParameter(that); - shared default void visitResource(Resource that) => super.transformResource(that); - shared default void visitResources(Resources that) => super.transformResources(that); - shared default void visitReturn(Return that) => super.transformReturn(that); - shared default void visitSafeMemberOperator(SafeMemberOperator that) => super.transformSafeMemberOperator(that); - shared default void visitSatisfiedTypes(SatisfiedTypes that) => super.transformSatisfiedTypes(that); - shared default void visitScaleOperation(ScaleOperation that) => super.transformScaleOperation(that); - shared default void visitSelfReference(SelfReference that) => super.transformSelfReference(that); - shared default void visitSequentialType(SequentialType that) => super.transformSequentialType(that); - shared default void visitSetAssignmentOperation(SetAssignmentOperation that) => super.transformSetAssignmentOperation(that); - shared default void visitSetOperation(SetOperation that) => super.transformSetOperation(that); - shared default void visitSimpleType(SimpleType that) => super.transformSimpleType(that); - shared default void visitSmallAsOperation(SmallAsOperation that) => super.transformSmallAsOperation(that); - shared default void visitSmallerOperation(SmallerOperation that) => super.transformSmallerOperation(that); - shared default void visitSpanFromSubscript(SpanFromSubscript that) => super.transformSpanFromSubscript(that); - shared default void visitSpanOperation(SpanOperation that) => super.transformSpanOperation(that); - shared default void visitSpanSubscript(SpanSubscript that) => super.transformSpanSubscript(that); - shared default void visitSpanToSubscript(SpanToSubscript that) => super.transformSpanToSubscript(that); - shared default void visitSpecification(Specification that) => super.transformSpecification(that); - shared default void visitSpecifiedArgument(SpecifiedArgument that) => super.transformSpecifiedArgument(that); - shared default void visitSpecifiedPattern(SpecifiedPattern that) => super.transformSpecifiedPattern(that); - shared default void visitSpecifiedVariable(SpecifiedVariable that) => super.transformSpecifiedVariable(that); - shared default void visitSpecifier(Specifier that) => super.transformSpecifier(that); - shared default void visitSpreadArgument(SpreadArgument that) => super.transformSpreadArgument(that); - shared default void visitSpreadMemberOperator(SpreadMemberOperator that) => super.transformSpreadMemberOperator(that); - shared default void visitSpreadType(SpreadType that) => super.transformSpreadType(that); - shared default void visitStatement(Statement that) => super.transformStatement(that); - shared default void visitStringLiteral(StringLiteral that) => super.transformStringLiteral(that); - shared default void visitStringTemplate(StringTemplate that) => super.transformStringTemplate(that); - shared default void visitSubscript(Subscript that) => super.transformSubscript(that); - shared default void visitSubtractAssignmentOperation(SubtractAssignmentOperation that) => super.transformSubtractAssignmentOperation(that); - shared default void visitSumOperation(SumOperation that) => super.transformSumOperation(that); - shared default void visitSuper(Super that) => super.transformSuper(that); - shared default void visitSwitchCaseElse(SwitchCaseElse that) => super.transformSwitchCaseElse(that); - shared default void visitSwitchCaseElseExpression(SwitchCaseElseExpression that) => super.transformSwitchCaseElseExpression(that); - shared default void visitSwitchCases(SwitchCases that) => super.transformSwitchCases(that); - shared default void visitSwitchClause(SwitchClause that) => super.transformSwitchClause(that); - shared default void visitThenOperation(ThenOperation that) => super.transformThenOperation(that); - shared default void visitThis(This that) => super.transformThis(that); - shared default void visitThrow(Throw that) => super.transformThrow(that); - shared default void visitTryCatchFinally(TryCatchFinally that) => super.transformTryCatchFinally(that); - shared default void visitTryClause(TryClause that) => super.transformTryClause(that); - shared default void visitTuple(Tuple that) => super.transformTuple(that); - shared default void visitTuplePattern(TuplePattern that) => super.transformTuplePattern(that); - shared default void visitTupleType(TupleType that) => super.transformTupleType(that); - shared default void visitTypeAliasDefinition(TypeAliasDefinition that) => super.transformTypeAliasDefinition(that); - shared default void visitTypeArguments(TypeArguments that) => super.transformTypeArguments(that); - shared default void visitTypeArgument(TypeArgument that) => super.transformTypeArgument(that); - shared default void visitTypeConstraint(TypeConstraint that) => super.transformTypeConstraint(that); - shared default void visitTypeModifier(TypeModifier that) => super.transformTypeModifier(that); - shared default void visitTypedDeclaration(TypedDeclaration that) => super.transformTypedDeclaration(that); - shared default void visitTypeDeclaration(TypeDeclaration that) => super.transformTypeDeclaration(that); - shared default void visitTypeDec(TypeDec that) => super.transformTypeDec(that); - shared default void visitTypedVariable(TypedVariable that) => super.transformTypedVariable(that); - shared default void visitTypeList(TypeList that) => super.transformTypeList(that); - shared default void visitTypeMeta(TypeMeta that) => super.transformTypeMeta(that); - shared default void visitTypeNameWithTypeArguments(TypeNameWithTypeArguments that) => super.transformTypeNameWithTypeArguments(that); - shared default void visitTypeParameters(TypeParameters that) => super.transformTypeParameters(that); - shared default void visitTypeParameter(TypeParameter that) => super.transformTypeParameter(that); - shared default void visitTypeSpecifier(TypeSpecifier that) => super.transformTypeSpecifier(that); - shared default void visitType(Type that) => super.transformType(that); - shared default void visitUIdentifier(UIdentifier that) => super.transformUIdentifier(that); - shared default void visitUnaryArithmeticOperation(UnaryArithmeticOperation that) => super.transformUnaryArithmeticOperation(that); - shared default void visitUnaryIshOperation(UnaryIshOperation that) => super.transformUnaryIshOperation(that); - shared default void visitUnaryOperation(UnaryOperation that) => super.transformUnaryOperation(that); - shared default void visitUnaryTypeOperation(UnaryTypeOperation that) => super.transformUnaryTypeOperation(that); - shared default void visitUnionableType(UnionableType that) => super.transformUnionableType(that); - shared default void visitUnionAssignmentOperation(UnionAssignmentOperation that) => super.transformUnionAssignmentOperation(that); - shared default void visitUnionOperation(UnionOperation that) => super.transformUnionOperation(that); - shared default void visitUnionType(UnionType that) => super.transformUnionType(that); - shared default void visitUnspecifiedVariable(UnspecifiedVariable that) => super.transformUnspecifiedVariable(that); - shared default void visitValueArgument(ValueArgument that) => super.transformValueArgument(that); - shared default void visitValueConstructorDefinition(ValueConstructorDefinition that) => super.transformValueConstructorDefinition(that); - shared default void visitValueDeclaration(ValueDeclaration that) => super.transformValueDeclaration(that); - shared default void visitValueDec(ValueDec that) => super.transformValueDec(that); - shared default void visitValueDefinition(ValueDefinition that) => super.transformValueDefinition(that); - shared default void visitValueExpression(ValueExpression that) => super.transformValueExpression(that); - shared default void visitValueGetterDefinition(ValueGetterDefinition that) => super.transformValueGetterDefinition(that); - shared default void visitValueModifier(ValueModifier that) => super.transformValueModifier(that); - shared default void visitValueParameter(ValueParameter that) => super.transformValueParameter(that); - shared default void visitValueSetterDefinition(ValueSetterDefinition that) => super.transformValueSetterDefinition(that); - shared default void visitValueSpecification(ValueSpecification that) => super.transformValueSpecification(that); - shared default void visitVariable(Variable that) => super.transformVariable(that); - shared default void visitVariablePattern(VariablePattern that) => super.transformVariablePattern(that); - shared default void visitVariadicParameter(VariadicParameter that) => super.transformVariadicParameter(that); - shared default void visitVariadicVariable(VariadicVariable that) => super.transformVariadicVariable(that); - shared default void visitVariance(Variance that) => super.transformVariance(that); - shared default void visitVoidModifier(VoidModifier that) => super.transformVoidModifier(that); - shared default void visitWhile(While that) => super.transformWhile(that); - shared default void visitWithinOperation(WithinOperation that) => super.transformWithinOperation(that); + shared default void visitNonemptyCondition(NonemptyCondition that) => visitExistsOrNonemptyCondition(that); + shared default void visitNonemptyOperation(NonemptyOperation that) => visitUnaryOperation(that); + shared default void visitNotEqualOperation(NotEqualOperation that) => visitEqualityOperation(that); + shared default void visitNotOperation(NotOperation that) => visitUnaryOperation(that); + shared default void visitObjectArgument(ObjectArgument that) => visitInlineDefinitionArgument(that); + shared default void visitObjectDefinition(ObjectDefinition that) => visitDeclaration(that); + shared default void visitObjectExpression(ObjectExpression that) => visitAtom(that); + shared default void visitOfOperation(OfOperation that) => visitUnaryTypeOperation(that); + shared default void visitOpenBound(OpenBound that) => visitBound(that); + shared default void visitOperation(Operation that) => visitValueExpression(that); + shared default void visitOptionalType(OptionalType that) => visitPrimaryType(that); + shared default void visitOrAssignmentOperation(OrAssignmentOperation that) => visitLogicalAssignmentOperation(that); + shared default void visitOrOperation(OrOperation that) => visitLogicalOperation(that); + shared default void visitOutModifier(OutModifier that) => visitVariance(that); + shared default void visitOuter(Outer that) => visitSelfReference(that); + shared default void visitPackage(Package that) => visitSelfReference(that); + shared default void visitPackageCompilationUnit(PackageCompilationUnit that) => visitAnyCompilationUnit(that); + shared default void visitPackageDec(PackageDec that) => visitDec(that); + shared default void visitPackageDescriptor(PackageDescriptor that) => visitNode(that); + shared default void visitPackageQualifier(PackageQualifier that) => visitTypeIsh(that); + shared default void visitParameter(Parameter that) => visitNode(that); + shared default void visitParameterReference(ParameterReference that) => visitRequiredParameter(that); + shared default void visitParameters(Parameters that) => visitNode(that); + shared default void visitPattern(Pattern that) => visitNode(that); + shared default void visitPatternList(PatternList that) => visitNode(that); + shared default void visitPositionalArguments(PositionalArguments that) => visitArguments(that); + shared default void visitPostfixDecrementOperation(PostfixDecrementOperation that) => visitPostfixOperation(that); + shared default void visitPostfixIncrementOperation(PostfixIncrementOperation that) => visitPostfixOperation(that); + shared default void visitPostfixOperation(PostfixOperation that) => visitUnaryOperation(that); + shared default void visitPrefixDecrementOperation(PrefixDecrementOperation that) => visitPrefixOperation(that); + shared default void visitPrefixIncrementOperation(PrefixIncrementOperation that) => visitPrefixOperation(that); + shared default void visitPrefixOperation(PrefixOperation that) => visitUnaryOperation(that); + shared default void visitPrefixPostfixStatement(PrefixPostfixStatement that) => visitExpressionStatement(that); + shared default void visitPrimary(Primary that) => visitValueExpression(that); + shared default void visitPrimaryType(PrimaryType that) => visitUnionableType(that); + shared default void visitProductOperation(ProductOperation that) => visitArithmeticOperation(that); + shared default void visitQualifiedExpression(QualifiedExpression that) => visitPrimary(that); + shared default void visitQualifiedType(QualifiedType that) => visitSimpleType(that); + shared default void visitQuotientOperation(QuotientOperation that) => visitArithmeticOperation(that); + shared default void visitRangeSubscript(RangeSubscript that) => visitSubscript(that); + shared default void visitRemainderAssignmentOperation(RemainderAssignmentOperation that) => visitArithmeticAssignmentOperation(that); + shared default void visitRemainderOperation(RemainderOperation that) => visitArithmeticOperation(that); + shared default void visitRequiredParameter(RequiredParameter that) => visitParameter(that); + shared default void visitResource(Resource that) => visitNode(that); + shared default void visitResources(Resources that) => visitNode(that); + shared default void visitReturn(Return that) => visitDirective(that); + shared default void visitSafeMemberOperator(SafeMemberOperator that) => visitAnyMemberOperator(that); + shared default void visitSatisfiedTypes(SatisfiedTypes that) => visitNode(that); + shared default void visitScaleOperation(ScaleOperation that) => visitBinaryOperation(that); + shared default void visitSelfReference(SelfReference that) => visitExpression(that); + shared default void visitSequentialType(SequentialType that) => visitPrimaryType(that); + shared default void visitSetAssignmentOperation(SetAssignmentOperation that) => visitAssignmentOperation(that); + shared default void visitSetOperation(SetOperation that) => visitBinaryOperation(that); + shared default void visitSimpleType(SimpleType that) => visitPrimaryType(that); + shared default void visitSmallAsOperation(SmallAsOperation that) => visitComparisonOperation(that); + shared default void visitSmallerOperation(SmallerOperation that) => visitComparisonOperation(that); + shared default void visitSpanFromSubscript(SpanFromSubscript that) => visitRangeSubscript(that); + shared default void visitSpanOperation(SpanOperation that) => visitBinaryOperation(that); + shared default void visitSpanSubscript(SpanSubscript that) => visitRangeSubscript(that); + shared default void visitSpanToSubscript(SpanToSubscript that) => visitRangeSubscript(that); + shared default void visitSpecification(Specification that) => visitStatement(that); + shared default void visitSpecifiedArgument(SpecifiedArgument that) => visitNamedArgument(that); + shared default void visitSpecifiedPattern(SpecifiedPattern that) => visitNode(that); + shared default void visitSpecifiedVariable(SpecifiedVariable that) => visitVariable(that); + shared default void visitSpecifier(Specifier that) => visitNode(that); + shared default void visitSpreadArgument(SpreadArgument that) => visitNode(that); + shared default void visitSpreadMemberOperator(SpreadMemberOperator that) => visitAnyMemberOperator(that); + shared default void visitSpreadType(SpreadType that) => visitTypeIsh(that); + shared default void visitStatement(Statement that) => visitNode(that); + shared default void visitStringLiteral(StringLiteral that) => visitLiteral(that); + shared default void visitStringTemplate(StringTemplate that) => visitAtom(that); + shared default void visitSubscript(Subscript that) => visitNode(that); + shared default void visitSubtractAssignmentOperation(SubtractAssignmentOperation that) => visitArithmeticAssignmentOperation(that); + shared default void visitSumOperation(SumOperation that) => visitArithmeticOperation(that); + shared default void visitSuper(Super that) => visitSelfReference(that); + shared default void visitSwitchCaseElse(SwitchCaseElse that) => visitControlStructure(that); + shared default void visitSwitchCaseElseExpression(SwitchCaseElseExpression that) => visitConditionalExpression(that); + shared default void visitSwitchCases(SwitchCases that) => visitNode(that); + shared default void visitSwitchClause(SwitchClause that) => visitNode(that); + shared default void visitThenOperation(ThenOperation that) => visitBinaryOperation(that); + shared default void visitThis(This that) => visitSelfReference(that); + shared default void visitThrow(Throw that) => visitDirective(that); + shared default void visitTryCatchFinally(TryCatchFinally that) => visitControlStructure(that); + shared default void visitTryClause(TryClause that) => visitNode(that); + shared default void visitTuple(Tuple that) => visitAtom(that); + shared default void visitTuplePattern(TuplePattern that) => visitPattern(that); + shared default void visitTupleType(TupleType that) => visitPrimaryType(that); + shared default void visitType(Type that) => visitTypeIsh(that); + shared default void visitTypeAliasDefinition(TypeAliasDefinition that) => visitTypeDeclaration(that); + shared default void visitTypeArgument(TypeArgument that) => visitTypeIsh(that); + shared default void visitTypeArguments(TypeArguments that) => visitTypeIsh(that); + shared default void visitTypeConstraint(TypeConstraint that) => visitNode(that); + shared default void visitTypeDec(TypeDec that) => visitDec(that); + shared default void visitTypeDeclaration(TypeDeclaration that) => visitDeclaration(that); + shared default void visitTypeIsh(TypeIsh that) => visitNode(that); + shared default void visitTypeList(TypeList that) => visitTypeIsh(that); + shared default void visitTypeMeta(TypeMeta that) => visitMeta(that); + shared default void visitTypeModifier(TypeModifier that) => visitModifier(that); + shared default void visitTypeNameWithTypeArguments(TypeNameWithTypeArguments that) => visitNameWithTypeArguments(that); + shared default void visitTypeParameter(TypeParameter that) => visitNode(that); + shared default void visitTypeParameters(TypeParameters that) => visitNode(that); + shared default void visitTypeSpecifier(TypeSpecifier that) => visitNode(that); + shared default void visitTypedDeclaration(TypedDeclaration that) => visitDeclaration(that); + shared default void visitTypedVariable(TypedVariable that) => visitVariable(that); + shared default void visitUIdentifier(UIdentifier that) => visitIdentifier(that); + shared default void visitUnaryArithmeticOperation(UnaryArithmeticOperation that) => visitUnaryOperation(that); + shared default void visitUnaryIshOperation(UnaryIshOperation that) => visitOperation(that); + shared default void visitUnaryOperation(UnaryOperation that) => visitUnaryIshOperation(that); + shared default void visitUnaryTypeOperation(UnaryTypeOperation that) => visitUnaryIshOperation(that); + shared default void visitUnionAssignmentOperation(UnionAssignmentOperation that) => visitSetAssignmentOperation(that); + shared default void visitUnionOperation(UnionOperation that) => visitSetOperation(that); + shared default void visitUnionType(UnionType that) => visitMainType(that); + shared default void visitUnionableType(UnionableType that) => visitMainType(that); + shared default void visitUnspecifiedVariable(UnspecifiedVariable that) => visitVariable(that); + shared default void visitValueArgument(ValueArgument that) => visitInlineDefinitionArgument(that); + shared default void visitValueConstructorDefinition(ValueConstructorDefinition that) => visitConstructorDefinition(that); + shared default void visitValueDec(ValueDec that) => visitMemberDec(that); + shared default void visitValueDeclaration(ValueDeclaration that) => visitAnyValue(that); + shared default void visitValueDefinition(ValueDefinition that) => visitAnyValue(that); + shared default void visitValueExpression(ValueExpression that) => visitExpression(that); + shared default void visitValueGetterDefinition(ValueGetterDefinition that) => visitAnyValue(that); + shared default void visitValueModifier(ValueModifier that) => visitLocalModifier(that); + shared default void visitValueParameter(ValueParameter that) => visitRequiredParameter(that); + shared default void visitValueSetterDefinition(ValueSetterDefinition that) => visitDeclaration(that); + shared default void visitValueSpecification(ValueSpecification that) => visitSpecification(that); + shared default void visitVariable(Variable that) => visitNode(that); + shared default void visitVariablePattern(VariablePattern that) => visitPattern(that); + shared default void visitVariadicParameter(VariadicParameter that) => visitParameter(that); + shared default void visitVariadicType(VariadicType that) => visitTypeIsh(that); + shared default void visitVariadicVariable(VariadicVariable that) => visitVariable(that); + shared default void visitVariance(Variance that) => visitModifier(that); + shared default void visitVoidModifier(VoidModifier that) => visitTypeModifier(that); + shared default void visitWhile(While that) => visitControlStructure(that); + shared default void visitWithinOperation(WithinOperation that) => visitOperation(that); } diff --git a/source/ceylon/ast/core/VoidModifier.ceylon b/source/ceylon/ast/core/VoidModifier.ceylon index 54e81712..30b4658a 100644 --- a/source/ceylon/ast/core/VoidModifier.ceylon +++ b/source/ceylon/ast/core/VoidModifier.ceylon @@ -7,6 +7,9 @@ shared class VoidModifier() shared actual Result transform(Transformer transformer) => transformer.transformVoidModifier(this); + shared actual void visit(Visitor visitor) + => visitor.visitVoidModifier(this); + shared actual Boolean equals(Object that) { return that is VoidModifier; } diff --git a/source/ceylon/ast/core/While.ceylon b/source/ceylon/ast/core/While.ceylon index 3f5d303e..be163c89 100644 --- a/source/ceylon/ast/core/While.ceylon +++ b/source/ceylon/ast/core/While.ceylon @@ -18,6 +18,9 @@ shared class While(conditions, block) shared actual Result transform(Transformer transformer) => transformer.transformWhile(this); + shared actual void visit(Visitor visitor) + => visitor.visitWhile(this); + shared actual Boolean equals(Object that) { if (is While that) { return conditions == that.conditions && block == that.block; diff --git a/source/ceylon/ast/core/WithinOperation.ceylon b/source/ceylon/ast/core/WithinOperation.ceylon index acdbac94..c67b1119 100644 --- a/source/ceylon/ast/core/WithinOperation.ceylon +++ b/source/ceylon/ast/core/WithinOperation.ceylon @@ -25,6 +25,9 @@ shared class WithinOperation(operand, lowerBound, upperBound) shared actual Result transform(Transformer transformer) => transformer.transformWithinOperation(this); + shared actual void visit(Visitor visitor) + => visitor.visitWithinOperation(this); + shared actual Boolean equals(Object that) { if (is WithinOperation that) { return lowerBound == that.lowerBound && upperBound == that.upperBound;