org.openrewrite.csharp.CSharpIsoVisitor Maven / Gradle / Ivy
Show all versions of rewrite-csharp Show documentation
/*
* Copyright 2024 the original author or authors.
*
* Licensed under the Moderne Source Available License (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://docs.moderne.io/licensing/moderne-source-available-license
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* -------------------THIS FILE IS AUTO GENERATED--------------------------
* Changes to this file may cause incorrect behavior and will be lost if
* the code is regenerated.
*/
package org.openrewrite.csharp;
import org.jspecify.annotations.Nullable;
import org.openrewrite.*;
import org.openrewrite.internal.ListUtils;
import org.openrewrite.marker.Markers;
import org.openrewrite.tree.*;
import org.openrewrite.java.JavaVisitor;
import org.openrewrite.java.tree.*;
import org.openrewrite.csharp.tree.*;
import java.util.List;
public class CSharpIsoVisitor
extends CSharpVisitor
{
@Override
public Cs.CompilationUnit visitCompilationUnit(Cs.CompilationUnit compilationUnit, P p) {
return (Cs.CompilationUnit) super.visitCompilationUnit(compilationUnit, p);
}
@Override
public Cs.ForEachVariableLoop visitForEachVariableLoop(Cs.ForEachVariableLoop forEachVariableLoop, P p) {
return (Cs.ForEachVariableLoop) super.visitForEachVariableLoop(forEachVariableLoop, p);
}
@Override
public Cs.Argument visitArgument(Cs.Argument argument, P p) {
return (Cs.Argument) super.visitArgument(argument, p);
}
@Override
public Cs.AnnotatedStatement visitAnnotatedStatement(Cs.AnnotatedStatement annotatedStatement, P p) {
return (Cs.AnnotatedStatement) super.visitAnnotatedStatement(annotatedStatement, p);
}
@Override
public Cs.ArrayRankSpecifier visitArrayRankSpecifier(Cs.ArrayRankSpecifier arrayRankSpecifier, P p) {
return (Cs.ArrayRankSpecifier) super.visitArrayRankSpecifier(arrayRankSpecifier, p);
}
@Override
public Cs.AssignmentOperation visitAssignmentOperation(Cs.AssignmentOperation assignmentOperation, P p) {
return (Cs.AssignmentOperation) super.visitAssignmentOperation(assignmentOperation, p);
}
@Override
public Cs.AttributeList visitAttributeList(Cs.AttributeList attributeList, P p) {
return (Cs.AttributeList) super.visitAttributeList(attributeList, p);
}
@Override
public Cs.AwaitExpression visitAwaitExpression(Cs.AwaitExpression awaitExpression, P p) {
return (Cs.AwaitExpression) super.visitAwaitExpression(awaitExpression, p);
}
@Override
public Cs.Binary visitBinary(Cs.Binary binary, P p) {
return (Cs.Binary) super.visitBinary(binary, p);
}
@Override
public Cs.BlockScopeNamespaceDeclaration visitBlockScopeNamespaceDeclaration(Cs.BlockScopeNamespaceDeclaration blockScopeNamespaceDeclaration, P p) {
return (Cs.BlockScopeNamespaceDeclaration) super.visitBlockScopeNamespaceDeclaration(blockScopeNamespaceDeclaration, p);
}
@Override
public Cs.CollectionExpression visitCollectionExpression(Cs.CollectionExpression collectionExpression, P p) {
return (Cs.CollectionExpression) super.visitCollectionExpression(collectionExpression, p);
}
@Override
public Cs.ExpressionStatement visitExpressionStatement(Cs.ExpressionStatement expressionStatement, P p) {
return (Cs.ExpressionStatement) super.visitExpressionStatement(expressionStatement, p);
}
@Override
public Cs.ExternAlias visitExternAlias(Cs.ExternAlias externAlias, P p) {
return (Cs.ExternAlias) super.visitExternAlias(externAlias, p);
}
@Override
public Cs.FileScopeNamespaceDeclaration visitFileScopeNamespaceDeclaration(Cs.FileScopeNamespaceDeclaration fileScopeNamespaceDeclaration, P p) {
return (Cs.FileScopeNamespaceDeclaration) super.visitFileScopeNamespaceDeclaration(fileScopeNamespaceDeclaration, p);
}
@Override
public Cs.InterpolatedString visitInterpolatedString(Cs.InterpolatedString interpolatedString, P p) {
return (Cs.InterpolatedString) super.visitInterpolatedString(interpolatedString, p);
}
@Override
public Cs.Interpolation visitInterpolation(Cs.Interpolation interpolation, P p) {
return (Cs.Interpolation) super.visitInterpolation(interpolation, p);
}
@Override
public Cs.NullSafeExpression visitNullSafeExpression(Cs.NullSafeExpression nullSafeExpression, P p) {
return (Cs.NullSafeExpression) super.visitNullSafeExpression(nullSafeExpression, p);
}
@Override
public Cs.StatementExpression visitStatementExpression(Cs.StatementExpression statementExpression, P p) {
return (Cs.StatementExpression) super.visitStatementExpression(statementExpression, p);
}
@Override
public Cs.UsingDirective visitUsingDirective(Cs.UsingDirective usingDirective, P p) {
return (Cs.UsingDirective) super.visitUsingDirective(usingDirective, p);
}
@Override
public Cs.PropertyDeclaration visitPropertyDeclaration(Cs.PropertyDeclaration propertyDeclaration, P p) {
return (Cs.PropertyDeclaration) super.visitPropertyDeclaration(propertyDeclaration, p);
}
@Override
public Cs.Keyword visitKeyword(Cs.Keyword keyword, P p) {
return (Cs.Keyword) super.visitKeyword(keyword, p);
}
@Override
public Cs.Lambda visitLambda(Cs.Lambda lambda, P p) {
return (Cs.Lambda) super.visitLambda(lambda, p);
}
@Override
public Cs.ClassDeclaration visitClassDeclaration(Cs.ClassDeclaration classDeclaration, P p) {
return (Cs.ClassDeclaration) super.visitClassDeclaration(classDeclaration, p);
}
@Override
public Cs.MethodDeclaration visitMethodDeclaration(Cs.MethodDeclaration methodDeclaration, P p) {
return (Cs.MethodDeclaration) super.visitMethodDeclaration(methodDeclaration, p);
}
@Override
public Cs.UsingStatement visitUsingStatement(Cs.UsingStatement usingStatement, P p) {
return (Cs.UsingStatement) super.visitUsingStatement(usingStatement, p);
}
@Override
public Cs.TypeParameterConstraintClause visitTypeParameterConstraintClause(Cs.TypeParameterConstraintClause typeParameterConstraintClause, P p) {
return (Cs.TypeParameterConstraintClause) super.visitTypeParameterConstraintClause(typeParameterConstraintClause, p);
}
@Override
public Cs.TypeConstraint visitTypeConstraint(Cs.TypeConstraint typeConstraint, P p) {
return (Cs.TypeConstraint) super.visitTypeConstraint(typeConstraint, p);
}
@Override
public Cs.AllowsConstraintClause visitAllowsConstraintClause(Cs.AllowsConstraintClause allowsConstraintClause, P p) {
return (Cs.AllowsConstraintClause) super.visitAllowsConstraintClause(allowsConstraintClause, p);
}
@Override
public Cs.RefStructConstraint visitRefStructConstraint(Cs.RefStructConstraint refStructConstraint, P p) {
return (Cs.RefStructConstraint) super.visitRefStructConstraint(refStructConstraint, p);
}
@Override
public Cs.ClassOrStructConstraint visitClassOrStructConstraint(Cs.ClassOrStructConstraint classOrStructConstraint, P p) {
return (Cs.ClassOrStructConstraint) super.visitClassOrStructConstraint(classOrStructConstraint, p);
}
@Override
public Cs.ConstructorConstraint visitConstructorConstraint(Cs.ConstructorConstraint constructorConstraint, P p) {
return (Cs.ConstructorConstraint) super.visitConstructorConstraint(constructorConstraint, p);
}
@Override
public Cs.DefaultConstraint visitDefaultConstraint(Cs.DefaultConstraint defaultConstraint, P p) {
return (Cs.DefaultConstraint) super.visitDefaultConstraint(defaultConstraint, p);
}
@Override
public Cs.DeclarationExpression visitDeclarationExpression(Cs.DeclarationExpression declarationExpression, P p) {
return (Cs.DeclarationExpression) super.visitDeclarationExpression(declarationExpression, p);
}
@Override
public Cs.SingleVariableDesignation visitSingleVariableDesignation(Cs.SingleVariableDesignation singleVariableDesignation, P p) {
return (Cs.SingleVariableDesignation) super.visitSingleVariableDesignation(singleVariableDesignation, p);
}
@Override
public Cs.ParenthesizedVariableDesignation visitParenthesizedVariableDesignation(Cs.ParenthesizedVariableDesignation parenthesizedVariableDesignation, P p) {
return (Cs.ParenthesizedVariableDesignation) super.visitParenthesizedVariableDesignation(parenthesizedVariableDesignation, p);
}
@Override
public Cs.DiscardVariableDesignation visitDiscardVariableDesignation(Cs.DiscardVariableDesignation discardVariableDesignation, P p) {
return (Cs.DiscardVariableDesignation) super.visitDiscardVariableDesignation(discardVariableDesignation, p);
}
@Override
public Cs.TupleExpression visitTupleExpression(Cs.TupleExpression tupleExpression, P p) {
return (Cs.TupleExpression) super.visitTupleExpression(tupleExpression, p);
}
@Override
public Cs.Constructor visitConstructor(Cs.Constructor constructor, P p) {
return (Cs.Constructor) super.visitConstructor(constructor, p);
}
@Override
public Cs.DestructorDeclaration visitDestructorDeclaration(Cs.DestructorDeclaration destructorDeclaration, P p) {
return (Cs.DestructorDeclaration) super.visitDestructorDeclaration(destructorDeclaration, p);
}
@Override
public Cs.Unary visitUnary(Cs.Unary unary, P p) {
return (Cs.Unary) super.visitUnary(unary, p);
}
@Override
public Cs.ConstructorInitializer visitConstructorInitializer(Cs.ConstructorInitializer constructorInitializer, P p) {
return (Cs.ConstructorInitializer) super.visitConstructorInitializer(constructorInitializer, p);
}
@Override
public Cs.TupleType visitTupleType(Cs.TupleType tupleType, P p) {
return (Cs.TupleType) super.visitTupleType(tupleType, p);
}
@Override
public Cs.TupleElement visitTupleElement(Cs.TupleElement tupleElement, P p) {
return (Cs.TupleElement) super.visitTupleElement(tupleElement, p);
}
@Override
public Cs.NewClass visitNewClass(Cs.NewClass newClass, P p) {
return (Cs.NewClass) super.visitNewClass(newClass, p);
}
@Override
public Cs.InitializerExpression visitInitializerExpression(Cs.InitializerExpression initializerExpression, P p) {
return (Cs.InitializerExpression) super.visitInitializerExpression(initializerExpression, p);
}
@Override
public Cs.ImplicitElementAccess visitImplicitElementAccess(Cs.ImplicitElementAccess implicitElementAccess, P p) {
return (Cs.ImplicitElementAccess) super.visitImplicitElementAccess(implicitElementAccess, p);
}
@Override
public Cs.Yield visitYield(Cs.Yield yield, P p) {
return (Cs.Yield) super.visitYield(yield, p);
}
@Override
public Cs.DefaultExpression visitDefaultExpression(Cs.DefaultExpression defaultExpression, P p) {
return (Cs.DefaultExpression) super.visitDefaultExpression(defaultExpression, p);
}
@Override
public Cs.IsPattern visitIsPattern(Cs.IsPattern isPattern, P p) {
return (Cs.IsPattern) super.visitIsPattern(isPattern, p);
}
@Override
public Cs.UnaryPattern visitUnaryPattern(Cs.UnaryPattern unaryPattern, P p) {
return (Cs.UnaryPattern) super.visitUnaryPattern(unaryPattern, p);
}
@Override
public Cs.TypePattern visitTypePattern(Cs.TypePattern typePattern, P p) {
return (Cs.TypePattern) super.visitTypePattern(typePattern, p);
}
@Override
public Cs.BinaryPattern visitBinaryPattern(Cs.BinaryPattern binaryPattern, P p) {
return (Cs.BinaryPattern) super.visitBinaryPattern(binaryPattern, p);
}
@Override
public Cs.ConstantPattern visitConstantPattern(Cs.ConstantPattern constantPattern, P p) {
return (Cs.ConstantPattern) super.visitConstantPattern(constantPattern, p);
}
@Override
public Cs.DiscardPattern visitDiscardPattern(Cs.DiscardPattern discardPattern, P p) {
return (Cs.DiscardPattern) super.visitDiscardPattern(discardPattern, p);
}
@Override
public Cs.ListPattern visitListPattern(Cs.ListPattern listPattern, P p) {
return (Cs.ListPattern) super.visitListPattern(listPattern, p);
}
@Override
public Cs.ParenthesizedPattern visitParenthesizedPattern(Cs.ParenthesizedPattern parenthesizedPattern, P p) {
return (Cs.ParenthesizedPattern) super.visitParenthesizedPattern(parenthesizedPattern, p);
}
@Override
public Cs.RecursivePattern visitRecursivePattern(Cs.RecursivePattern recursivePattern, P p) {
return (Cs.RecursivePattern) super.visitRecursivePattern(recursivePattern, p);
}
@Override
public Cs.VarPattern visitVarPattern(Cs.VarPattern varPattern, P p) {
return (Cs.VarPattern) super.visitVarPattern(varPattern, p);
}
@Override
public Cs.PositionalPatternClause visitPositionalPatternClause(Cs.PositionalPatternClause positionalPatternClause, P p) {
return (Cs.PositionalPatternClause) super.visitPositionalPatternClause(positionalPatternClause, p);
}
@Override
public Cs.RelationalPattern visitRelationalPattern(Cs.RelationalPattern relationalPattern, P p) {
return (Cs.RelationalPattern) super.visitRelationalPattern(relationalPattern, p);
}
@Override
public Cs.SlicePattern visitSlicePattern(Cs.SlicePattern slicePattern, P p) {
return (Cs.SlicePattern) super.visitSlicePattern(slicePattern, p);
}
@Override
public Cs.PropertyPatternClause visitPropertyPatternClause(Cs.PropertyPatternClause propertyPatternClause, P p) {
return (Cs.PropertyPatternClause) super.visitPropertyPatternClause(propertyPatternClause, p);
}
@Override
public Cs.Subpattern visitSubpattern(Cs.Subpattern subpattern, P p) {
return (Cs.Subpattern) super.visitSubpattern(subpattern, p);
}
@Override
public Cs.SwitchExpression visitSwitchExpression(Cs.SwitchExpression switchExpression, P p) {
return (Cs.SwitchExpression) super.visitSwitchExpression(switchExpression, p);
}
@Override
public Cs.SwitchExpressionArm visitSwitchExpressionArm(Cs.SwitchExpressionArm switchExpressionArm, P p) {
return (Cs.SwitchExpressionArm) super.visitSwitchExpressionArm(switchExpressionArm, p);
}
@Override
public Cs.SwitchSection visitSwitchSection(Cs.SwitchSection switchSection, P p) {
return (Cs.SwitchSection) super.visitSwitchSection(switchSection, p);
}
@Override
public Cs.DefaultSwitchLabel visitDefaultSwitchLabel(Cs.DefaultSwitchLabel defaultSwitchLabel, P p) {
return (Cs.DefaultSwitchLabel) super.visitDefaultSwitchLabel(defaultSwitchLabel, p);
}
@Override
public Cs.CasePatternSwitchLabel visitCasePatternSwitchLabel(Cs.CasePatternSwitchLabel casePatternSwitchLabel, P p) {
return (Cs.CasePatternSwitchLabel) super.visitCasePatternSwitchLabel(casePatternSwitchLabel, p);
}
@Override
public Cs.SwitchStatement visitSwitchStatement(Cs.SwitchStatement switchStatement, P p) {
return (Cs.SwitchStatement) super.visitSwitchStatement(switchStatement, p);
}
@Override
public Cs.LockStatement visitLockStatement(Cs.LockStatement lockStatement, P p) {
return (Cs.LockStatement) super.visitLockStatement(lockStatement, p);
}
@Override
public Cs.FixedStatement visitFixedStatement(Cs.FixedStatement fixedStatement, P p) {
return (Cs.FixedStatement) super.visitFixedStatement(fixedStatement, p);
}
@Override
public Cs.CheckedStatement visitCheckedStatement(Cs.CheckedStatement checkedStatement, P p) {
return (Cs.CheckedStatement) super.visitCheckedStatement(checkedStatement, p);
}
@Override
public Cs.UnsafeStatement visitUnsafeStatement(Cs.UnsafeStatement unsafeStatement, P p) {
return (Cs.UnsafeStatement) super.visitUnsafeStatement(unsafeStatement, p);
}
@Override
public Cs.RangeExpression visitRangeExpression(Cs.RangeExpression rangeExpression, P p) {
return (Cs.RangeExpression) super.visitRangeExpression(rangeExpression, p);
}
@Override
public Cs.QueryExpression visitQueryExpression(Cs.QueryExpression queryExpression, P p) {
return (Cs.QueryExpression) super.visitQueryExpression(queryExpression, p);
}
@Override
public Cs.QueryBody visitQueryBody(Cs.QueryBody queryBody, P p) {
return (Cs.QueryBody) super.visitQueryBody(queryBody, p);
}
@Override
public Cs.FromClause visitFromClause(Cs.FromClause fromClause, P p) {
return (Cs.FromClause) super.visitFromClause(fromClause, p);
}
@Override
public Cs.LetClause visitLetClause(Cs.LetClause letClause, P p) {
return (Cs.LetClause) super.visitLetClause(letClause, p);
}
@Override
public Cs.JoinClause visitJoinClause(Cs.JoinClause joinClause, P p) {
return (Cs.JoinClause) super.visitJoinClause(joinClause, p);
}
@Override
public Cs.JoinIntoClause visitJoinIntoClause(Cs.JoinIntoClause joinIntoClause, P p) {
return (Cs.JoinIntoClause) super.visitJoinIntoClause(joinIntoClause, p);
}
@Override
public Cs.WhereClause visitWhereClause(Cs.WhereClause whereClause, P p) {
return (Cs.WhereClause) super.visitWhereClause(whereClause, p);
}
@Override
public Cs.OrderByClause visitOrderByClause(Cs.OrderByClause orderByClause, P p) {
return (Cs.OrderByClause) super.visitOrderByClause(orderByClause, p);
}
@Override
public Cs.QueryContinuation visitQueryContinuation(Cs.QueryContinuation queryContinuation, P p) {
return (Cs.QueryContinuation) super.visitQueryContinuation(queryContinuation, p);
}
@Override
public Cs.Ordering visitOrdering(Cs.Ordering ordering, P p) {
return (Cs.Ordering) super.visitOrdering(ordering, p);
}
@Override
public Cs.SelectClause visitSelectClause(Cs.SelectClause selectClause, P p) {
return (Cs.SelectClause) super.visitSelectClause(selectClause, p);
}
@Override
public Cs.GroupClause visitGroupClause(Cs.GroupClause groupClause, P p) {
return (Cs.GroupClause) super.visitGroupClause(groupClause, p);
}
@Override
public Cs.IndexerDeclaration visitIndexerDeclaration(Cs.IndexerDeclaration indexerDeclaration, P p) {
return (Cs.IndexerDeclaration) super.visitIndexerDeclaration(indexerDeclaration, p);
}
@Override
public Cs.DelegateDeclaration visitDelegateDeclaration(Cs.DelegateDeclaration delegateDeclaration, P p) {
return (Cs.DelegateDeclaration) super.visitDelegateDeclaration(delegateDeclaration, p);
}
@Override
public Cs.ConversionOperatorDeclaration visitConversionOperatorDeclaration(Cs.ConversionOperatorDeclaration conversionOperatorDeclaration, P p) {
return (Cs.ConversionOperatorDeclaration) super.visitConversionOperatorDeclaration(conversionOperatorDeclaration, p);
}
@Override
public Cs.TypeParameter visitTypeParameter(Cs.TypeParameter typeParameter, P p) {
return (Cs.TypeParameter) super.visitTypeParameter(typeParameter, p);
}
@Override
public Cs.EnumDeclaration visitEnumDeclaration(Cs.EnumDeclaration enumDeclaration, P p) {
return (Cs.EnumDeclaration) super.visitEnumDeclaration(enumDeclaration, p);
}
@Override
public Cs.EnumMemberDeclaration visitEnumMemberDeclaration(Cs.EnumMemberDeclaration enumMemberDeclaration, P p) {
return (Cs.EnumMemberDeclaration) super.visitEnumMemberDeclaration(enumMemberDeclaration, p);
}
@Override
public Cs.AliasQualifiedName visitAliasQualifiedName(Cs.AliasQualifiedName aliasQualifiedName, P p) {
return (Cs.AliasQualifiedName) super.visitAliasQualifiedName(aliasQualifiedName, p);
}
@Override
public Cs.ArrayType visitArrayType(Cs.ArrayType arrayType, P p) {
return (Cs.ArrayType) super.visitArrayType(arrayType, p);
}
@Override
public J.AnnotatedType visitAnnotatedType(J.AnnotatedType annotatedType, P p) {
return (J.AnnotatedType) super.visitAnnotatedType(annotatedType, p);
}
@Override
public J.Annotation visitAnnotation(J.Annotation annotation, P p) {
return (J.Annotation) super.visitAnnotation(annotation, p);
}
@Override
public J.ArrayAccess visitArrayAccess(J.ArrayAccess arrayAccess, P p) {
return (J.ArrayAccess) super.visitArrayAccess(arrayAccess, p);
}
@Override
public J.ArrayType visitArrayType(J.ArrayType arrayType, P p) {
return (J.ArrayType) super.visitArrayType(arrayType, p);
}
@Override
public J.Assert visitAssert(J.Assert assert_, P p) {
return (J.Assert) super.visitAssert(assert_, p);
}
@Override
public J.Assignment visitAssignment(J.Assignment assignment, P p) {
return (J.Assignment) super.visitAssignment(assignment, p);
}
@Override
public J.AssignmentOperation visitAssignmentOperation(J.AssignmentOperation assignmentOperation, P p) {
return (J.AssignmentOperation) super.visitAssignmentOperation(assignmentOperation, p);
}
@Override
public J.Binary visitBinary(J.Binary binary, P p) {
return (J.Binary) super.visitBinary(binary, p);
}
@Override
public J.Block visitBlock(J.Block block, P p) {
return (J.Block) super.visitBlock(block, p);
}
@Override
public J.Break visitBreak(J.Break break_, P p) {
return (J.Break) super.visitBreak(break_, p);
}
@Override
public J.Case visitCase(J.Case case_, P p) {
return (J.Case) super.visitCase(case_, p);
}
@Override
public J.ClassDeclaration visitClassDeclaration(J.ClassDeclaration classDeclaration, P p) {
return (J.ClassDeclaration) super.visitClassDeclaration(classDeclaration, p);
}
@Override
public J.Continue visitContinue(J.Continue continue_, P p) {
return (J.Continue) super.visitContinue(continue_, p);
}
@Override
public J.DoWhileLoop visitDoWhileLoop(J.DoWhileLoop doWhileLoop, P p) {
return (J.DoWhileLoop) super.visitDoWhileLoop(doWhileLoop, p);
}
@Override
public J.Empty visitEmpty(J.Empty empty, P p) {
return (J.Empty) super.visitEmpty(empty, p);
}
@Override
public J.EnumValue visitEnumValue(J.EnumValue enumValue, P p) {
return (J.EnumValue) super.visitEnumValue(enumValue, p);
}
@Override
public J.EnumValueSet visitEnumValueSet(J.EnumValueSet enumValueSet, P p) {
return (J.EnumValueSet) super.visitEnumValueSet(enumValueSet, p);
}
@Override
public J.FieldAccess visitFieldAccess(J.FieldAccess fieldAccess, P p) {
return (J.FieldAccess) super.visitFieldAccess(fieldAccess, p);
}
@Override
public J.ForEachLoop visitForEachLoop(J.ForEachLoop forEachLoop, P p) {
return (J.ForEachLoop) super.visitForEachLoop(forEachLoop, p);
}
@Override
public J.ForLoop visitForLoop(J.ForLoop forLoop, P p) {
return (J.ForLoop) super.visitForLoop(forLoop, p);
}
@Override
public J.ParenthesizedTypeTree visitParenthesizedTypeTree(J.ParenthesizedTypeTree parenthesizedTypeTree, P p) {
return (J.ParenthesizedTypeTree) super.visitParenthesizedTypeTree(parenthesizedTypeTree, p);
}
@Override
public J.Identifier visitIdentifier(J.Identifier identifier, P p) {
return (J.Identifier) super.visitIdentifier(identifier, p);
}
@Override
public J.If visitIf(J.If if_, P p) {
return (J.If) super.visitIf(if_, p);
}
@Override
public J.Import visitImport(J.Import import_, P p) {
return (J.Import) super.visitImport(import_, p);
}
@Override
public J.InstanceOf visitInstanceOf(J.InstanceOf instanceOf, P p) {
return (J.InstanceOf) super.visitInstanceOf(instanceOf, p);
}
@Override
public J.IntersectionType visitIntersectionType(J.IntersectionType intersectionType, P p) {
return (J.IntersectionType) super.visitIntersectionType(intersectionType, p);
}
@Override
public J.Label visitLabel(J.Label label, P p) {
return (J.Label) super.visitLabel(label, p);
}
@Override
public J.Lambda visitLambda(J.Lambda lambda, P p) {
return (J.Lambda) super.visitLambda(lambda, p);
}
@Override
public J.Literal visitLiteral(J.Literal literal, P p) {
return (J.Literal) super.visitLiteral(literal, p);
}
@Override
public J.MemberReference visitMemberReference(J.MemberReference memberReference, P p) {
return (J.MemberReference) super.visitMemberReference(memberReference, p);
}
@Override
public J.MethodDeclaration visitMethodDeclaration(J.MethodDeclaration methodDeclaration, P p) {
return (J.MethodDeclaration) super.visitMethodDeclaration(methodDeclaration, p);
}
@Override
public J.MethodInvocation visitMethodInvocation(J.MethodInvocation methodInvocation, P p) {
return (J.MethodInvocation) super.visitMethodInvocation(methodInvocation, p);
}
@Override
public J.Modifier visitModifier(J.Modifier modifier, P p) {
return (J.Modifier) super.visitModifier(modifier, p);
}
@Override
public J.MultiCatch visitMultiCatch(J.MultiCatch multiCatch, P p) {
return (J.MultiCatch) super.visitMultiCatch(multiCatch, p);
}
@Override
public J.NewArray visitNewArray(J.NewArray newArray, P p) {
return (J.NewArray) super.visitNewArray(newArray, p);
}
@Override
public J.ArrayDimension visitArrayDimension(J.ArrayDimension arrayDimension, P p) {
return (J.ArrayDimension) super.visitArrayDimension(arrayDimension, p);
}
@Override
public J.NewClass visitNewClass(J.NewClass newClass, P p) {
return (J.NewClass) super.visitNewClass(newClass, p);
}
@Override
public J.NullableType visitNullableType(J.NullableType nullableType, P p) {
return (J.NullableType) super.visitNullableType(nullableType, p);
}
@Override
public J.Package visitPackage(J.Package package_, P p) {
return (J.Package) super.visitPackage(package_, p);
}
@Override
public J.ParameterizedType visitParameterizedType(J.ParameterizedType parameterizedType, P p) {
return (J.ParameterizedType) super.visitParameterizedType(parameterizedType, p);
}
@Override
public J.Parentheses visitParentheses(J.Parentheses parentheses, P p) {
return (J.Parentheses) super.visitParentheses(parentheses, p);
}
@Override
public J.ControlParentheses visitControlParentheses(J.ControlParentheses controlParentheses, P p) {
return (J.ControlParentheses) super.visitControlParentheses(controlParentheses, p);
}
@Override
public J.Primitive visitPrimitive(J.Primitive primitive, P p) {
return (J.Primitive) super.visitPrimitive(primitive, p);
}
@Override
public J.Return visitReturn(J.Return return_, P p) {
return (J.Return) super.visitReturn(return_, p);
}
@Override
public J.Switch visitSwitch(J.Switch switch_, P p) {
return (J.Switch) super.visitSwitch(switch_, p);
}
@Override
public J.SwitchExpression visitSwitchExpression(J.SwitchExpression switchExpression, P p) {
return (J.SwitchExpression) super.visitSwitchExpression(switchExpression, p);
}
@Override
public J.Synchronized visitSynchronized(J.Synchronized synchronized_, P p) {
return (J.Synchronized) super.visitSynchronized(synchronized_, p);
}
@Override
public J.Ternary visitTernary(J.Ternary ternary, P p) {
return (J.Ternary) super.visitTernary(ternary, p);
}
@Override
public J.Throw visitThrow(J.Throw throw_, P p) {
return (J.Throw) super.visitThrow(throw_, p);
}
@Override
public J.Try visitTry(J.Try try_, P p) {
return (J.Try) super.visitTry(try_, p);
}
@Override
public J.TypeCast visitTypeCast(J.TypeCast typeCast, P p) {
return (J.TypeCast) super.visitTypeCast(typeCast, p);
}
@Override
public J.TypeParameter visitTypeParameter(J.TypeParameter typeParameter, P p) {
return (J.TypeParameter) super.visitTypeParameter(typeParameter, p);
}
@Override
public J.Unary visitUnary(J.Unary unary, P p) {
return (J.Unary) super.visitUnary(unary, p);
}
@Override
public J.VariableDeclarations visitVariableDeclarations(J.VariableDeclarations variableDeclarations, P p) {
return (J.VariableDeclarations) super.visitVariableDeclarations(variableDeclarations, p);
}
@Override
public J.WhileLoop visitWhileLoop(J.WhileLoop whileLoop, P p) {
return (J.WhileLoop) super.visitWhileLoop(whileLoop, p);
}
@Override
public J.Wildcard visitWildcard(J.Wildcard wildcard, P p) {
return (J.Wildcard) super.visitWildcard(wildcard, p);
}
@Override
public J.Yield visitYield(J.Yield yield, P p) {
return (J.Yield) super.visitYield(yield, p);
}
@Override
public J.Unknown visitUnknown(J.Unknown unknown, P p) {
return (J.Unknown) super.visitUnknown(unknown, p);
}
}