Default = new();
+ public bool Equals(T x, T y) => SymbolEqualityComparer.Default.Equals(x, y);
+
+ public int GetHashCode(T obj) => SymbolEqualityComparer.Default.GetHashCode(obj);
+}
\ No newline at end of file
diff --git a/Rewrite/src/Rewrite.Analyzers/openrewrite-icon.png b/Rewrite/src/Rewrite.Analyzers/openrewrite-icon.png
new file mode 100644
index 00000000..b7e3046d
Binary files /dev/null and b/Rewrite/src/Rewrite.Analyzers/openrewrite-icon.png differ
diff --git a/Rewrite/src/Rewrite.CSharp/CSharpIsoVisitor.cs b/Rewrite/src/Rewrite.CSharp/CSharpIsoVisitor.cs
index dd9b989e..9a9484d6 100644
--- a/Rewrite/src/Rewrite.CSharp/CSharpIsoVisitor.cs
+++ b/Rewrite/src/Rewrite.CSharp/CSharpIsoVisitor.cs
@@ -1,913 +1,907 @@
-#nullable disable
-using Rewrite.RewriteCSharp.Tree;
+using Rewrite.RewriteCSharp.Tree;
using Rewrite.RewriteJava.Tree;
namespace Rewrite.RewriteCSharp;
public class CSharpIsoVisitor : CSharpVisitor
{
- public override Cs.CompilationUnit VisitCompilationUnit(Cs.CompilationUnit compilationUnit, P p)
+public override Cs.CompilationUnit? VisitCompilationUnit(Cs.CompilationUnit compilationUnit, P p)
{
- return (Cs.CompilationUnit )(base.VisitCompilationUnit(compilationUnit, p));
+ return base.VisitCompilationUnit(compilationUnit, p) as Cs.CompilationUnit;
}
- public override Cs.OperatorDeclaration VisitOperatorDeclaration(Cs.OperatorDeclaration operatorDeclaration, P p)
+public override Cs.OperatorDeclaration? VisitOperatorDeclaration(Cs.OperatorDeclaration operatorDeclaration, P p)
{
- return (Cs.OperatorDeclaration )(base.VisitOperatorDeclaration(operatorDeclaration, p));
+ return base.VisitOperatorDeclaration(operatorDeclaration, p) as Cs.OperatorDeclaration;
}
- public override Cs.RefExpression VisitRefExpression(Cs.RefExpression refExpression, P p)
+public override Cs.RefExpression? VisitRefExpression(Cs.RefExpression refExpression, P p)
{
- return (Cs.RefExpression )(base.VisitRefExpression(refExpression, p));
+ return base.VisitRefExpression(refExpression, p) as Cs.RefExpression;
}
- public override Cs.PointerType VisitPointerType(Cs.PointerType pointerType, P p)
+public override Cs.PointerType? VisitPointerType(Cs.PointerType pointerType, P p)
{
- return (Cs.PointerType )(base.VisitPointerType(pointerType, p));
+ return base.VisitPointerType(pointerType, p) as Cs.PointerType;
}
- public override Cs.RefType VisitRefType(Cs.RefType refType, P p)
+public override Cs.RefType? VisitRefType(Cs.RefType refType, P p)
{
- return (Cs.RefType )(base.VisitRefType(refType, p));
+ return base.VisitRefType(refType, p) as Cs.RefType;
}
- public override Cs.ForEachVariableLoop VisitForEachVariableLoop(Cs.ForEachVariableLoop forEachVariableLoop, P p)
+public override Cs.ForEachVariableLoop? VisitForEachVariableLoop(Cs.ForEachVariableLoop forEachVariableLoop, P p)
{
- return (Cs.ForEachVariableLoop )(base.VisitForEachVariableLoop(forEachVariableLoop, p));
+ return base.VisitForEachVariableLoop(forEachVariableLoop, p) as Cs.ForEachVariableLoop;
}
- public override Cs.ForEachVariableLoop.Control VisitForEachVariableLoopControl(Cs.ForEachVariableLoop.Control control, P p)
+public override Cs.ForEachVariableLoop.Control? VisitForEachVariableLoopControl(Cs.ForEachVariableLoop.Control control, P p)
{
- return (Cs.ForEachVariableLoop.Control )(base.VisitForEachVariableLoopControl(control, p));
+ return (base.VisitForEachVariableLoopControl(control, p)) as Cs.ForEachVariableLoop.Control;
}
- public override Cs.NameColon VisitNameColon(Cs.NameColon nameColon, P p)
+public override Cs.NameColon? VisitNameColon(Cs.NameColon nameColon, P p)
{
- return (Cs.NameColon )(base.VisitNameColon(nameColon, p));
+ return base.VisitNameColon(nameColon, p) as Cs.NameColon;
}
- public override Cs.Argument VisitArgument(Cs.Argument argument, P p)
+public override Cs.Argument? VisitArgument(Cs.Argument argument, P p)
{
- return (Cs.Argument )(base.VisitArgument(argument, p));
+ return base.VisitArgument(argument, p) as Cs.Argument;
}
- public override Cs.AnnotatedStatement VisitAnnotatedStatement(Cs.AnnotatedStatement annotatedStatement, P p)
+public override Cs.AnnotatedStatement? VisitAnnotatedStatement(Cs.AnnotatedStatement annotatedStatement, P p)
{
- return (Cs.AnnotatedStatement )(base.VisitAnnotatedStatement(annotatedStatement, p));
+ return base.VisitAnnotatedStatement(annotatedStatement, p) as Cs.AnnotatedStatement;
}
- public override Cs.ArrayRankSpecifier VisitArrayRankSpecifier(Cs.ArrayRankSpecifier arrayRankSpecifier, P p)
+public override Cs.ArrayRankSpecifier? VisitArrayRankSpecifier(Cs.ArrayRankSpecifier arrayRankSpecifier, P p)
{
- return (Cs.ArrayRankSpecifier )(base.VisitArrayRankSpecifier(arrayRankSpecifier, p));
+ return base.VisitArrayRankSpecifier(arrayRankSpecifier, p) as Cs.ArrayRankSpecifier;
}
- public override Cs.AssignmentOperation VisitAssignmentOperation(Cs.AssignmentOperation assignmentOperation, P p)
+public override Cs.AssignmentOperation? VisitAssignmentOperation(Cs.AssignmentOperation assignmentOperation, P p)
{
- return (Cs.AssignmentOperation )(base.VisitAssignmentOperation(assignmentOperation, p));
+ return base.VisitAssignmentOperation(assignmentOperation, p) as Cs.AssignmentOperation;
}
- public override Cs.AttributeList VisitAttributeList(Cs.AttributeList attributeList, P p)
+public override Cs.AttributeList? VisitAttributeList(Cs.AttributeList attributeList, P p)
{
- return (Cs.AttributeList )(base.VisitAttributeList(attributeList, p));
+ return base.VisitAttributeList(attributeList, p) as Cs.AttributeList;
}
- public override Cs.AwaitExpression VisitAwaitExpression(Cs.AwaitExpression awaitExpression, P p)
+public override Cs.AwaitExpression? VisitAwaitExpression(Cs.AwaitExpression awaitExpression, P p)
{
- return (Cs.AwaitExpression )(base.VisitAwaitExpression(awaitExpression, p));
+ return base.VisitAwaitExpression(awaitExpression, p) as Cs.AwaitExpression;
}
- public override Cs.StackAllocExpression VisitStackAllocExpression(Cs.StackAllocExpression stackAllocExpression, P p)
+public override Cs.StackAllocExpression? VisitStackAllocExpression(Cs.StackAllocExpression stackAllocExpression, P p)
{
- return (Cs.StackAllocExpression )(base.VisitStackAllocExpression(stackAllocExpression, p));
+ return base.VisitStackAllocExpression(stackAllocExpression, p) as Cs.StackAllocExpression;
}
- public override Cs.GotoStatement VisitGotoStatement(Cs.GotoStatement gotoStatement, P p)
+public override Cs.GotoStatement? VisitGotoStatement(Cs.GotoStatement gotoStatement, P p)
{
- return (Cs.GotoStatement )(base.VisitGotoStatement(gotoStatement, p));
+ return base.VisitGotoStatement(gotoStatement, p) as Cs.GotoStatement;
}
- public override Cs.EventDeclaration VisitEventDeclaration(Cs.EventDeclaration eventDeclaration, P p)
+public override Cs.EventDeclaration? VisitEventDeclaration(Cs.EventDeclaration eventDeclaration, P p)
{
- return (Cs.EventDeclaration )(base.VisitEventDeclaration(eventDeclaration, p));
+ return base.VisitEventDeclaration(eventDeclaration, p) as Cs.EventDeclaration;
}
- public override Cs.Binary VisitBinary(Cs.Binary binary, P p)
+public override Cs.Binary? VisitBinary(Cs.Binary binary, P p)
{
- return (Cs.Binary )(base.VisitBinary(binary, p));
+ return base.VisitBinary(binary, p) as Cs.Binary;
}
- public override Cs.BlockScopeNamespaceDeclaration VisitBlockScopeNamespaceDeclaration(Cs.BlockScopeNamespaceDeclaration blockScopeNamespaceDeclaration, P p)
+public override Cs.BlockScopeNamespaceDeclaration? VisitBlockScopeNamespaceDeclaration(Cs.BlockScopeNamespaceDeclaration blockScopeNamespaceDeclaration, P p)
{
- return (Cs.BlockScopeNamespaceDeclaration )(base.VisitBlockScopeNamespaceDeclaration(blockScopeNamespaceDeclaration, p));
+ return base.VisitBlockScopeNamespaceDeclaration(blockScopeNamespaceDeclaration, p) as Cs.BlockScopeNamespaceDeclaration;
}
- public override Cs.CollectionExpression VisitCollectionExpression(Cs.CollectionExpression collectionExpression, P p)
+public override Cs.CollectionExpression? VisitCollectionExpression(Cs.CollectionExpression collectionExpression, P p)
{
- return (Cs.CollectionExpression )(base.VisitCollectionExpression(collectionExpression, p));
+ return base.VisitCollectionExpression(collectionExpression, p) as Cs.CollectionExpression;
}
- public override Cs.ExpressionStatement VisitExpressionStatement(Cs.ExpressionStatement expressionStatement, P p)
+public override Cs.ExpressionStatement? VisitExpressionStatement(Cs.ExpressionStatement expressionStatement, P p)
{
- return (Cs.ExpressionStatement )(base.VisitExpressionStatement(expressionStatement, p));
+ return base.VisitExpressionStatement(expressionStatement, p) as Cs.ExpressionStatement;
}
- public override Cs.ExternAlias VisitExternAlias(Cs.ExternAlias externAlias, P p)
+public override Cs.ExternAlias? VisitExternAlias(Cs.ExternAlias externAlias, P p)
{
- return (Cs.ExternAlias )(base.VisitExternAlias(externAlias, p));
+ return base.VisitExternAlias(externAlias, p) as Cs.ExternAlias;
}
- public override Cs.FileScopeNamespaceDeclaration VisitFileScopeNamespaceDeclaration(Cs.FileScopeNamespaceDeclaration fileScopeNamespaceDeclaration, P p)
+public override Cs.FileScopeNamespaceDeclaration? VisitFileScopeNamespaceDeclaration(Cs.FileScopeNamespaceDeclaration fileScopeNamespaceDeclaration, P p)
{
- return (Cs.FileScopeNamespaceDeclaration )(base.VisitFileScopeNamespaceDeclaration(fileScopeNamespaceDeclaration, p));
+ return base.VisitFileScopeNamespaceDeclaration(fileScopeNamespaceDeclaration, p) as Cs.FileScopeNamespaceDeclaration;
}
- public override Cs.InterpolatedString VisitInterpolatedString(Cs.InterpolatedString interpolatedString, P p)
+public override Cs.InterpolatedString? VisitInterpolatedString(Cs.InterpolatedString interpolatedString, P p)
{
- return (Cs.InterpolatedString )(base.VisitInterpolatedString(interpolatedString, p));
+ return base.VisitInterpolatedString(interpolatedString, p) as Cs.InterpolatedString;
}
- public override Cs.Interpolation VisitInterpolation(Cs.Interpolation interpolation, P p)
+public override Cs.Interpolation? VisitInterpolation(Cs.Interpolation interpolation, P p)
{
- return (Cs.Interpolation )(base.VisitInterpolation(interpolation, p));
+ return base.VisitInterpolation(interpolation, p) as Cs.Interpolation;
}
- public override Cs.NullSafeExpression VisitNullSafeExpression(Cs.NullSafeExpression nullSafeExpression, P p)
+public override Cs.NullSafeExpression? VisitNullSafeExpression(Cs.NullSafeExpression nullSafeExpression, P p)
{
- return (Cs.NullSafeExpression )(base.VisitNullSafeExpression(nullSafeExpression, p));
+ return base.VisitNullSafeExpression(nullSafeExpression, p) as Cs.NullSafeExpression;
}
- public override Cs.StatementExpression VisitStatementExpression(Cs.StatementExpression statementExpression, P p)
+public override Cs.StatementExpression? VisitStatementExpression(Cs.StatementExpression statementExpression, P p)
{
- return (Cs.StatementExpression )(base.VisitStatementExpression(statementExpression, p));
+ return base.VisitStatementExpression(statementExpression, p) as Cs.StatementExpression;
}
- public override Cs.UsingDirective VisitUsingDirective(Cs.UsingDirective usingDirective, P p)
+public override Cs.UsingDirective? VisitUsingDirective(Cs.UsingDirective usingDirective, P p)
{
- return (Cs.UsingDirective )(base.VisitUsingDirective(usingDirective, p));
+ return base.VisitUsingDirective(usingDirective, p) as Cs.UsingDirective;
}
- public override Cs.PropertyDeclaration VisitPropertyDeclaration(Cs.PropertyDeclaration propertyDeclaration, P p)
+public override Cs.PropertyDeclaration? VisitPropertyDeclaration(Cs.PropertyDeclaration propertyDeclaration, P p)
{
- return (Cs.PropertyDeclaration )(base.VisitPropertyDeclaration(propertyDeclaration, p));
+ return base.VisitPropertyDeclaration(propertyDeclaration, p) as Cs.PropertyDeclaration;
}
- public override Cs.Keyword VisitKeyword(Cs.Keyword keyword, P p)
+public override Cs.Keyword? VisitKeyword(Cs.Keyword keyword, P p)
{
- return (Cs.Keyword )(base.VisitKeyword(keyword, p));
+ return base.VisitKeyword(keyword, p) as Cs.Keyword;
}
- public override Cs.Lambda VisitLambda(Cs.Lambda lambda, P p)
+public override Cs.Lambda? VisitLambda(Cs.Lambda lambda, P p)
{
- return (Cs.Lambda )(base.VisitLambda(lambda, p));
+ return base.VisitLambda(lambda, p) as Cs.Lambda;
}
- public override Cs.ClassDeclaration VisitClassDeclaration(Cs.ClassDeclaration classDeclaration, P p)
+public override Cs.ClassDeclaration? VisitClassDeclaration(Cs.ClassDeclaration classDeclaration, P p)
{
- return (Cs.ClassDeclaration )(base.VisitClassDeclaration(classDeclaration, p));
+ return base.VisitClassDeclaration(classDeclaration, p) as Cs.ClassDeclaration;
}
- public override Cs.MethodDeclaration VisitMethodDeclaration(Cs.MethodDeclaration methodDeclaration, P p)
+public override Cs.MethodDeclaration? VisitMethodDeclaration(Cs.MethodDeclaration methodDeclaration, P p)
{
- return (Cs.MethodDeclaration )(base.VisitMethodDeclaration(methodDeclaration, p));
+ return base.VisitMethodDeclaration(methodDeclaration, p) as Cs.MethodDeclaration;
}
- public override Cs.UsingStatement VisitUsingStatement(Cs.UsingStatement usingStatement, P p)
+public override Cs.UsingStatement? VisitUsingStatement(Cs.UsingStatement usingStatement, P p)
{
- return (Cs.UsingStatement )(base.VisitUsingStatement(usingStatement, p));
+ return base.VisitUsingStatement(usingStatement, p) as Cs.UsingStatement;
}
- public override Cs.TypeParameterConstraintClause VisitTypeParameterConstraintClause(Cs.TypeParameterConstraintClause typeParameterConstraintClause, P p)
+public override Cs.TypeParameterConstraintClause? VisitTypeParameterConstraintClause(Cs.TypeParameterConstraintClause typeParameterConstraintClause, P p)
{
- return (Cs.TypeParameterConstraintClause )(base.VisitTypeParameterConstraintClause(typeParameterConstraintClause, p));
+ return base.VisitTypeParameterConstraintClause(typeParameterConstraintClause, p) as Cs.TypeParameterConstraintClause;
}
- public override Cs.TypeConstraint VisitTypeConstraint(Cs.TypeConstraint typeConstraint, P p)
+public override Cs.TypeConstraint? VisitTypeConstraint(Cs.TypeConstraint typeConstraint, P p)
{
- return (Cs.TypeConstraint )(base.VisitTypeConstraint(typeConstraint, p));
+ return base.VisitTypeConstraint(typeConstraint, p) as Cs.TypeConstraint;
}
- public override Cs.AllowsConstraintClause VisitAllowsConstraintClause(Cs.AllowsConstraintClause allowsConstraintClause, P p)
+public override Cs.AllowsConstraintClause? VisitAllowsConstraintClause(Cs.AllowsConstraintClause allowsConstraintClause, P p)
{
- return (Cs.AllowsConstraintClause )(base.VisitAllowsConstraintClause(allowsConstraintClause, p));
+ return base.VisitAllowsConstraintClause(allowsConstraintClause, p) as Cs.AllowsConstraintClause;
}
- public override Cs.RefStructConstraint VisitRefStructConstraint(Cs.RefStructConstraint refStructConstraint, P p)
+public override Cs.RefStructConstraint? VisitRefStructConstraint(Cs.RefStructConstraint refStructConstraint, P p)
{
- return (Cs.RefStructConstraint )(base.VisitRefStructConstraint(refStructConstraint, p));
+ return base.VisitRefStructConstraint(refStructConstraint, p) as Cs.RefStructConstraint;
}
- public override Cs.ClassOrStructConstraint VisitClassOrStructConstraint(Cs.ClassOrStructConstraint classOrStructConstraint, P p)
+public override Cs.ClassOrStructConstraint? VisitClassOrStructConstraint(Cs.ClassOrStructConstraint classOrStructConstraint, P p)
{
- return (Cs.ClassOrStructConstraint )(base.VisitClassOrStructConstraint(classOrStructConstraint, p));
+ return base.VisitClassOrStructConstraint(classOrStructConstraint, p) as Cs.ClassOrStructConstraint;
}
- public override Cs.ConstructorConstraint VisitConstructorConstraint(Cs.ConstructorConstraint constructorConstraint, P p)
+public override Cs.ConstructorConstraint? VisitConstructorConstraint(Cs.ConstructorConstraint constructorConstraint, P p)
{
- return (Cs.ConstructorConstraint )(base.VisitConstructorConstraint(constructorConstraint, p));
+ return base.VisitConstructorConstraint(constructorConstraint, p) as Cs.ConstructorConstraint;
}
- public override Cs.DefaultConstraint VisitDefaultConstraint(Cs.DefaultConstraint defaultConstraint, P p)
+public override Cs.DefaultConstraint? VisitDefaultConstraint(Cs.DefaultConstraint defaultConstraint, P p)
{
- return (Cs.DefaultConstraint )(base.VisitDefaultConstraint(defaultConstraint, p));
+ return base.VisitDefaultConstraint(defaultConstraint, p) as Cs.DefaultConstraint;
}
- public override Cs.DeclarationExpression VisitDeclarationExpression(Cs.DeclarationExpression declarationExpression, P p)
+public override Cs.DeclarationExpression? VisitDeclarationExpression(Cs.DeclarationExpression declarationExpression, P p)
{
- return (Cs.DeclarationExpression )(base.VisitDeclarationExpression(declarationExpression, p));
+ return base.VisitDeclarationExpression(declarationExpression, p) as Cs.DeclarationExpression;
}
- public override Cs.SingleVariableDesignation VisitSingleVariableDesignation(Cs.SingleVariableDesignation singleVariableDesignation, P p)
+public override Cs.SingleVariableDesignation? VisitSingleVariableDesignation(Cs.SingleVariableDesignation singleVariableDesignation, P p)
{
- return (Cs.SingleVariableDesignation )(base.VisitSingleVariableDesignation(singleVariableDesignation, p));
+ return base.VisitSingleVariableDesignation(singleVariableDesignation, p) as Cs.SingleVariableDesignation;
}
- public override Cs.ParenthesizedVariableDesignation VisitParenthesizedVariableDesignation(Cs.ParenthesizedVariableDesignation parenthesizedVariableDesignation, P p)
+public override Cs.ParenthesizedVariableDesignation? VisitParenthesizedVariableDesignation(Cs.ParenthesizedVariableDesignation parenthesizedVariableDesignation, P p)
{
- return (Cs.ParenthesizedVariableDesignation )(base.VisitParenthesizedVariableDesignation(parenthesizedVariableDesignation, p));
+ return base.VisitParenthesizedVariableDesignation(parenthesizedVariableDesignation, p) as Cs.ParenthesizedVariableDesignation;
}
- public override Cs.DiscardVariableDesignation VisitDiscardVariableDesignation(Cs.DiscardVariableDesignation discardVariableDesignation, P p)
+public override Cs.DiscardVariableDesignation? VisitDiscardVariableDesignation(Cs.DiscardVariableDesignation discardVariableDesignation, P p)
{
- return (Cs.DiscardVariableDesignation )(base.VisitDiscardVariableDesignation(discardVariableDesignation, p));
+ return base.VisitDiscardVariableDesignation(discardVariableDesignation, p) as Cs.DiscardVariableDesignation;
}
- public override Cs.TupleExpression VisitTupleExpression(Cs.TupleExpression tupleExpression, P p)
+public override Cs.TupleExpression? VisitTupleExpression(Cs.TupleExpression tupleExpression, P p)
{
- return (Cs.TupleExpression )(base.VisitTupleExpression(tupleExpression, p));
+ return base.VisitTupleExpression(tupleExpression, p) as Cs.TupleExpression;
}
- public override Cs.Constructor VisitConstructor(Cs.Constructor constructor, P p)
+public override Cs.Constructor? VisitConstructor(Cs.Constructor constructor, P p)
{
- return (Cs.Constructor )(base.VisitConstructor(constructor, p));
+ return base.VisitConstructor(constructor, p) as Cs.Constructor;
}
- public override Cs.DestructorDeclaration VisitDestructorDeclaration(Cs.DestructorDeclaration destructorDeclaration, P p)
+public override Cs.DestructorDeclaration? VisitDestructorDeclaration(Cs.DestructorDeclaration destructorDeclaration, P p)
{
- return (Cs.DestructorDeclaration )(base.VisitDestructorDeclaration(destructorDeclaration, p));
+ return base.VisitDestructorDeclaration(destructorDeclaration, p) as Cs.DestructorDeclaration;
}
- public override Cs.Unary VisitUnary(Cs.Unary unary, P p)
+public override Cs.Unary? VisitUnary(Cs.Unary unary, P p)
{
- return (Cs.Unary )(base.VisitUnary(unary, p));
+ return base.VisitUnary(unary, p) as Cs.Unary;
}
- public override Cs.ConstructorInitializer VisitConstructorInitializer(Cs.ConstructorInitializer constructorInitializer, P p)
+public override Cs.ConstructorInitializer? VisitConstructorInitializer(Cs.ConstructorInitializer constructorInitializer, P p)
{
- return (Cs.ConstructorInitializer )(base.VisitConstructorInitializer(constructorInitializer, p));
+ return base.VisitConstructorInitializer(constructorInitializer, p) as Cs.ConstructorInitializer;
}
- public override Cs.TupleType VisitTupleType(Cs.TupleType tupleType, P p)
+public override Cs.TupleType? VisitTupleType(Cs.TupleType tupleType, P p)
{
- return (Cs.TupleType )(base.VisitTupleType(tupleType, p));
+ return base.VisitTupleType(tupleType, p) as Cs.TupleType;
}
- public override Cs.TupleElement VisitTupleElement(Cs.TupleElement tupleElement, P p)
+public override Cs.TupleElement? VisitTupleElement(Cs.TupleElement tupleElement, P p)
{
- return (Cs.TupleElement )(base.VisitTupleElement(tupleElement, p));
+ return base.VisitTupleElement(tupleElement, p) as Cs.TupleElement;
}
- public override Cs.NewClass VisitNewClass(Cs.NewClass newClass, P p)
+public override Cs.NewClass? VisitNewClass(Cs.NewClass newClass, P p)
{
- return (Cs.NewClass )(base.VisitNewClass(newClass, p));
+ return base.VisitNewClass(newClass, p) as Cs.NewClass;
}
- public override Cs.InitializerExpression VisitInitializerExpression(Cs.InitializerExpression initializerExpression, P p)
+public override Cs.InitializerExpression? VisitInitializerExpression(Cs.InitializerExpression initializerExpression, P p)
{
- return (Cs.InitializerExpression )(base.VisitInitializerExpression(initializerExpression, p));
+ return base.VisitInitializerExpression(initializerExpression, p) as Cs.InitializerExpression;
}
- public override Cs.ImplicitElementAccess VisitImplicitElementAccess(Cs.ImplicitElementAccess implicitElementAccess, P p)
+public override Cs.ImplicitElementAccess? VisitImplicitElementAccess(Cs.ImplicitElementAccess implicitElementAccess, P p)
{
- return (Cs.ImplicitElementAccess )(base.VisitImplicitElementAccess(implicitElementAccess, p));
+ return base.VisitImplicitElementAccess(implicitElementAccess, p) as Cs.ImplicitElementAccess;
}
- public override Cs.Yield VisitYield(Cs.Yield yield, P p)
+public override Cs.Yield? VisitYield(Cs.Yield yield, P p)
{
- return (Cs.Yield )(base.VisitYield(yield, p));
+ return base.VisitYield(yield, p) as Cs.Yield;
}
- public override Cs.DefaultExpression VisitDefaultExpression(Cs.DefaultExpression defaultExpression, P p)
+public override Cs.DefaultExpression? VisitDefaultExpression(Cs.DefaultExpression defaultExpression, P p)
{
- return (Cs.DefaultExpression )(base.VisitDefaultExpression(defaultExpression, p));
+ return base.VisitDefaultExpression(defaultExpression, p) as Cs.DefaultExpression;
}
- public override Cs.IsPattern VisitIsPattern(Cs.IsPattern isPattern, P p)
+public override Cs.IsPattern? VisitIsPattern(Cs.IsPattern isPattern, P p)
{
- return (Cs.IsPattern )(base.VisitIsPattern(isPattern, p));
+ return base.VisitIsPattern(isPattern, p) as Cs.IsPattern;
}
- public override Cs.UnaryPattern VisitUnaryPattern(Cs.UnaryPattern unaryPattern, P p)
+public override Cs.UnaryPattern? VisitUnaryPattern(Cs.UnaryPattern unaryPattern, P p)
{
- return (Cs.UnaryPattern )(base.VisitUnaryPattern(unaryPattern, p));
+ return base.VisitUnaryPattern(unaryPattern, p) as Cs.UnaryPattern;
}
- public override Cs.TypePattern VisitTypePattern(Cs.TypePattern typePattern, P p)
+public override Cs.TypePattern? VisitTypePattern(Cs.TypePattern typePattern, P p)
{
- return (Cs.TypePattern )(base.VisitTypePattern(typePattern, p));
+ return base.VisitTypePattern(typePattern, p) as Cs.TypePattern;
}
- public override Cs.BinaryPattern VisitBinaryPattern(Cs.BinaryPattern binaryPattern, P p)
+public override Cs.BinaryPattern? VisitBinaryPattern(Cs.BinaryPattern binaryPattern, P p)
{
- return (Cs.BinaryPattern )(base.VisitBinaryPattern(binaryPattern, p));
+ return base.VisitBinaryPattern(binaryPattern, p) as Cs.BinaryPattern;
}
- public override Cs.ConstantPattern VisitConstantPattern(Cs.ConstantPattern constantPattern, P p)
+public override Cs.ConstantPattern? VisitConstantPattern(Cs.ConstantPattern constantPattern, P p)
{
- return (Cs.ConstantPattern )(base.VisitConstantPattern(constantPattern, p));
+ return base.VisitConstantPattern(constantPattern, p) as Cs.ConstantPattern;
}
- public override Cs.DiscardPattern VisitDiscardPattern(Cs.DiscardPattern discardPattern, P p)
+public override Cs.DiscardPattern? VisitDiscardPattern(Cs.DiscardPattern discardPattern, P p)
{
- return (Cs.DiscardPattern )(base.VisitDiscardPattern(discardPattern, p));
+ return base.VisitDiscardPattern(discardPattern, p) as Cs.DiscardPattern;
}
- public override Cs.ListPattern VisitListPattern(Cs.ListPattern listPattern, P p)
+public override Cs.ListPattern? VisitListPattern(Cs.ListPattern listPattern, P p)
{
- return (Cs.ListPattern )(base.VisitListPattern(listPattern, p));
+ return base.VisitListPattern(listPattern, p) as Cs.ListPattern;
}
- public override Cs.ParenthesizedPattern VisitParenthesizedPattern(Cs.ParenthesizedPattern parenthesizedPattern, P p)
+public override Cs.ParenthesizedPattern? VisitParenthesizedPattern(Cs.ParenthesizedPattern parenthesizedPattern, P p)
{
- return (Cs.ParenthesizedPattern )(base.VisitParenthesizedPattern(parenthesizedPattern, p));
+ return base.VisitParenthesizedPattern(parenthesizedPattern, p) as Cs.ParenthesizedPattern;
}
- public override Cs.RecursivePattern VisitRecursivePattern(Cs.RecursivePattern recursivePattern, P p)
+public override Cs.RecursivePattern? VisitRecursivePattern(Cs.RecursivePattern recursivePattern, P p)
{
- return (Cs.RecursivePattern )(base.VisitRecursivePattern(recursivePattern, p));
+ return base.VisitRecursivePattern(recursivePattern, p) as Cs.RecursivePattern;
}
- public override Cs.VarPattern VisitVarPattern(Cs.VarPattern varPattern, P p)
+public override Cs.VarPattern? VisitVarPattern(Cs.VarPattern varPattern, P p)
{
- return (Cs.VarPattern )(base.VisitVarPattern(varPattern, p));
+ return base.VisitVarPattern(varPattern, p) as Cs.VarPattern;
}
- public override Cs.PositionalPatternClause VisitPositionalPatternClause(Cs.PositionalPatternClause positionalPatternClause, P p)
+public override Cs.PositionalPatternClause? VisitPositionalPatternClause(Cs.PositionalPatternClause positionalPatternClause, P p)
{
- return (Cs.PositionalPatternClause )(base.VisitPositionalPatternClause(positionalPatternClause, p));
+ return base.VisitPositionalPatternClause(positionalPatternClause, p) as Cs.PositionalPatternClause;
}
- public override Cs.RelationalPattern VisitRelationalPattern(Cs.RelationalPattern relationalPattern, P p)
+public override Cs.RelationalPattern? VisitRelationalPattern(Cs.RelationalPattern relationalPattern, P p)
{
- return (Cs.RelationalPattern )(base.VisitRelationalPattern(relationalPattern, p));
+ return base.VisitRelationalPattern(relationalPattern, p) as Cs.RelationalPattern;
}
- public override Cs.SlicePattern VisitSlicePattern(Cs.SlicePattern slicePattern, P p)
+public override Cs.SlicePattern? VisitSlicePattern(Cs.SlicePattern slicePattern, P p)
{
- return (Cs.SlicePattern )(base.VisitSlicePattern(slicePattern, p));
+ return base.VisitSlicePattern(slicePattern, p) as Cs.SlicePattern;
}
- public override Cs.PropertyPatternClause VisitPropertyPatternClause(Cs.PropertyPatternClause propertyPatternClause, P p)
+public override Cs.PropertyPatternClause? VisitPropertyPatternClause(Cs.PropertyPatternClause propertyPatternClause, P p)
{
- return (Cs.PropertyPatternClause )(base.VisitPropertyPatternClause(propertyPatternClause, p));
+ return base.VisitPropertyPatternClause(propertyPatternClause, p) as Cs.PropertyPatternClause;
}
- public override Cs.Subpattern VisitSubpattern(Cs.Subpattern subpattern, P p)
+public override Cs.Subpattern? VisitSubpattern(Cs.Subpattern subpattern, P p)
{
- return (Cs.Subpattern )(base.VisitSubpattern(subpattern, p));
+ return base.VisitSubpattern(subpattern, p) as Cs.Subpattern;
}
- public override Cs.SwitchExpression VisitSwitchExpression(Cs.SwitchExpression switchExpression, P p)
+public override Cs.SwitchExpression? VisitSwitchExpression(Cs.SwitchExpression switchExpression, P p)
{
- return (Cs.SwitchExpression )(base.VisitSwitchExpression(switchExpression, p));
+ return base.VisitSwitchExpression(switchExpression, p) as Cs.SwitchExpression;
}
- public override Cs.SwitchExpressionArm VisitSwitchExpressionArm(Cs.SwitchExpressionArm switchExpressionArm, P p)
+public override Cs.SwitchExpressionArm? VisitSwitchExpressionArm(Cs.SwitchExpressionArm switchExpressionArm, P p)
{
- return (Cs.SwitchExpressionArm )(base.VisitSwitchExpressionArm(switchExpressionArm, p));
+ return base.VisitSwitchExpressionArm(switchExpressionArm, p) as Cs.SwitchExpressionArm;
}
- public override Cs.SwitchSection VisitSwitchSection(Cs.SwitchSection switchSection, P p)
+public override Cs.SwitchSection? VisitSwitchSection(Cs.SwitchSection switchSection, P p)
{
- return (Cs.SwitchSection )(base.VisitSwitchSection(switchSection, p));
+ return base.VisitSwitchSection(switchSection, p) as Cs.SwitchSection;
}
- public override Cs.DefaultSwitchLabel VisitDefaultSwitchLabel(Cs.DefaultSwitchLabel defaultSwitchLabel, P p)
+public override Cs.DefaultSwitchLabel? VisitDefaultSwitchLabel(Cs.DefaultSwitchLabel defaultSwitchLabel, P p)
{
- return (Cs.DefaultSwitchLabel )(base.VisitDefaultSwitchLabel(defaultSwitchLabel, p));
+ return base.VisitDefaultSwitchLabel(defaultSwitchLabel, p) as Cs.DefaultSwitchLabel;
}
- public override Cs.CasePatternSwitchLabel VisitCasePatternSwitchLabel(Cs.CasePatternSwitchLabel casePatternSwitchLabel, P p)
+public override Cs.CasePatternSwitchLabel? VisitCasePatternSwitchLabel(Cs.CasePatternSwitchLabel casePatternSwitchLabel, P p)
{
- return (Cs.CasePatternSwitchLabel )(base.VisitCasePatternSwitchLabel(casePatternSwitchLabel, p));
+ return base.VisitCasePatternSwitchLabel(casePatternSwitchLabel, p) as Cs.CasePatternSwitchLabel;
}
- public override Cs.SwitchStatement VisitSwitchStatement(Cs.SwitchStatement switchStatement, P p)
+public override Cs.SwitchStatement? VisitSwitchStatement(Cs.SwitchStatement switchStatement, P p)
{
- return (Cs.SwitchStatement )(base.VisitSwitchStatement(switchStatement, p));
+ return base.VisitSwitchStatement(switchStatement, p) as Cs.SwitchStatement;
}
- public override Cs.LockStatement VisitLockStatement(Cs.LockStatement lockStatement, P p)
+public override Cs.LockStatement? VisitLockStatement(Cs.LockStatement lockStatement, P p)
{
- return (Cs.LockStatement )(base.VisitLockStatement(lockStatement, p));
+ return base.VisitLockStatement(lockStatement, p) as Cs.LockStatement;
}
- public override Cs.FixedStatement VisitFixedStatement(Cs.FixedStatement fixedStatement, P p)
+public override Cs.FixedStatement? VisitFixedStatement(Cs.FixedStatement fixedStatement, P p)
{
- return (Cs.FixedStatement )(base.VisitFixedStatement(fixedStatement, p));
+ return base.VisitFixedStatement(fixedStatement, p) as Cs.FixedStatement;
}
- public override Cs.CheckedExpression VisitCheckedExpression(Cs.CheckedExpression checkedExpression, P p)
+public override Cs.CheckedExpression? VisitCheckedExpression(Cs.CheckedExpression checkedExpression, P p)
{
- return (Cs.CheckedExpression )(base.VisitCheckedExpression(checkedExpression, p));
+ return base.VisitCheckedExpression(checkedExpression, p) as Cs.CheckedExpression;
}
- public override Cs.CheckedStatement VisitCheckedStatement(Cs.CheckedStatement checkedStatement, P p)
+public override Cs.CheckedStatement? VisitCheckedStatement(Cs.CheckedStatement checkedStatement, P p)
{
- return (Cs.CheckedStatement )(base.VisitCheckedStatement(checkedStatement, p));
+ return base.VisitCheckedStatement(checkedStatement, p) as Cs.CheckedStatement;
}
- public override Cs.UnsafeStatement VisitUnsafeStatement(Cs.UnsafeStatement unsafeStatement, P p)
+public override Cs.UnsafeStatement? VisitUnsafeStatement(Cs.UnsafeStatement unsafeStatement, P p)
{
- return (Cs.UnsafeStatement )(base.VisitUnsafeStatement(unsafeStatement, p));
+ return base.VisitUnsafeStatement(unsafeStatement, p) as Cs.UnsafeStatement;
}
- public override Cs.RangeExpression VisitRangeExpression(Cs.RangeExpression rangeExpression, P p)
+public override Cs.RangeExpression? VisitRangeExpression(Cs.RangeExpression rangeExpression, P p)
{
- return (Cs.RangeExpression )(base.VisitRangeExpression(rangeExpression, p));
+ return base.VisitRangeExpression(rangeExpression, p) as Cs.RangeExpression;
}
- public override Cs.QueryExpression VisitQueryExpression(Cs.QueryExpression queryExpression, P p)
+public override Cs.QueryExpression? VisitQueryExpression(Cs.QueryExpression queryExpression, P p)
{
- return (Cs.QueryExpression )(base.VisitQueryExpression(queryExpression, p));
+ return base.VisitQueryExpression(queryExpression, p) as Cs.QueryExpression;
}
- public override Cs.QueryBody VisitQueryBody(Cs.QueryBody queryBody, P p)
+public override Cs.QueryBody? VisitQueryBody(Cs.QueryBody queryBody, P p)
{
- return (Cs.QueryBody )(base.VisitQueryBody(queryBody, p));
+ return base.VisitQueryBody(queryBody, p) as Cs.QueryBody;
}
- public override Cs.FromClause VisitFromClause(Cs.FromClause fromClause, P p)
+public override Cs.FromClause? VisitFromClause(Cs.FromClause fromClause, P p)
{
- return (Cs.FromClause )(base.VisitFromClause(fromClause, p));
+ return base.VisitFromClause(fromClause, p) as Cs.FromClause;
}
- public override Cs.LetClause VisitLetClause(Cs.LetClause letClause, P p)
+public override Cs.LetClause? VisitLetClause(Cs.LetClause letClause, P p)
{
- return (Cs.LetClause )(base.VisitLetClause(letClause, p));
+ return base.VisitLetClause(letClause, p) as Cs.LetClause;
}
- public override Cs.JoinClause VisitJoinClause(Cs.JoinClause joinClause, P p)
+public override Cs.JoinClause? VisitJoinClause(Cs.JoinClause joinClause, P p)
{
- return (Cs.JoinClause )(base.VisitJoinClause(joinClause, p));
+ return base.VisitJoinClause(joinClause, p) as Cs.JoinClause;
}
- public override Cs.JoinIntoClause VisitJoinIntoClause(Cs.JoinIntoClause joinIntoClause, P p)
+public override Cs.JoinIntoClause? VisitJoinIntoClause(Cs.JoinIntoClause joinIntoClause, P p)
{
- return (Cs.JoinIntoClause )(base.VisitJoinIntoClause(joinIntoClause, p));
+ return base.VisitJoinIntoClause(joinIntoClause, p) as Cs.JoinIntoClause;
}
- public override Cs.WhereClause VisitWhereClause(Cs.WhereClause whereClause, P p)
+public override Cs.WhereClause? VisitWhereClause(Cs.WhereClause whereClause, P p)
{
- return (Cs.WhereClause )(base.VisitWhereClause(whereClause, p));
+ return base.VisitWhereClause(whereClause, p) as Cs.WhereClause;
}
- public override Cs.OrderByClause VisitOrderByClause(Cs.OrderByClause orderByClause, P p)
+public override Cs.OrderByClause? VisitOrderByClause(Cs.OrderByClause orderByClause, P p)
{
- return (Cs.OrderByClause )(base.VisitOrderByClause(orderByClause, p));
+ return base.VisitOrderByClause(orderByClause, p) as Cs.OrderByClause;
}
- public override Cs.QueryContinuation VisitQueryContinuation(Cs.QueryContinuation queryContinuation, P p)
+public override Cs.QueryContinuation? VisitQueryContinuation(Cs.QueryContinuation queryContinuation, P p)
{
- return (Cs.QueryContinuation )(base.VisitQueryContinuation(queryContinuation, p));
+ return base.VisitQueryContinuation(queryContinuation, p) as Cs.QueryContinuation;
}
- public override Cs.Ordering VisitOrdering(Cs.Ordering ordering, P p)
+public override Cs.Ordering? VisitOrdering(Cs.Ordering ordering, P p)
{
- return (Cs.Ordering )(base.VisitOrdering(ordering, p));
+ return base.VisitOrdering(ordering, p) as Cs.Ordering;
}
- public override Cs.SelectClause VisitSelectClause(Cs.SelectClause selectClause, P p)
+public override Cs.SelectClause? VisitSelectClause(Cs.SelectClause selectClause, P p)
{
- return (Cs.SelectClause )(base.VisitSelectClause(selectClause, p));
+ return base.VisitSelectClause(selectClause, p) as Cs.SelectClause;
}
- public override Cs.GroupClause VisitGroupClause(Cs.GroupClause groupClause, P p)
+public override Cs.GroupClause? VisitGroupClause(Cs.GroupClause groupClause, P p)
{
- return (Cs.GroupClause )(base.VisitGroupClause(groupClause, p));
+ return base.VisitGroupClause(groupClause, p) as Cs.GroupClause;
}
- public override Cs.IndexerDeclaration VisitIndexerDeclaration(Cs.IndexerDeclaration indexerDeclaration, P p)
+public override Cs.IndexerDeclaration? VisitIndexerDeclaration(Cs.IndexerDeclaration indexerDeclaration, P p)
{
- return (Cs.IndexerDeclaration )(base.VisitIndexerDeclaration(indexerDeclaration, p));
+ return base.VisitIndexerDeclaration(indexerDeclaration, p) as Cs.IndexerDeclaration;
}
- public override Cs.DelegateDeclaration VisitDelegateDeclaration(Cs.DelegateDeclaration delegateDeclaration, P p)
+public override Cs.DelegateDeclaration? VisitDelegateDeclaration(Cs.DelegateDeclaration delegateDeclaration, P p)
{
- return (Cs.DelegateDeclaration )(base.VisitDelegateDeclaration(delegateDeclaration, p));
+ return base.VisitDelegateDeclaration(delegateDeclaration, p) as Cs.DelegateDeclaration;
}
- public override Cs.ConversionOperatorDeclaration VisitConversionOperatorDeclaration(Cs.ConversionOperatorDeclaration conversionOperatorDeclaration, P p)
+public override Cs.ConversionOperatorDeclaration? VisitConversionOperatorDeclaration(Cs.ConversionOperatorDeclaration conversionOperatorDeclaration, P p)
{
- return (Cs.ConversionOperatorDeclaration )(base.VisitConversionOperatorDeclaration(conversionOperatorDeclaration, p));
+ return base.VisitConversionOperatorDeclaration(conversionOperatorDeclaration, p) as Cs.ConversionOperatorDeclaration;
}
- public override Cs.TypeParameter VisitTypeParameter(Cs.TypeParameter typeParameter, P p)
+public override Cs.TypeParameter? VisitTypeParameter(Cs.TypeParameter typeParameter, P p)
{
- return (Cs.TypeParameter )(base.VisitTypeParameter(typeParameter, p));
+ return base.VisitTypeParameter(typeParameter, p) as Cs.TypeParameter;
}
- public override Cs.EnumDeclaration VisitEnumDeclaration(Cs.EnumDeclaration enumDeclaration, P p)
+public override Cs.EnumDeclaration? VisitEnumDeclaration(Cs.EnumDeclaration enumDeclaration, P p)
{
- return (Cs.EnumDeclaration )(base.VisitEnumDeclaration(enumDeclaration, p));
+ return base.VisitEnumDeclaration(enumDeclaration, p) as Cs.EnumDeclaration;
}
- public override Cs.EnumMemberDeclaration VisitEnumMemberDeclaration(Cs.EnumMemberDeclaration enumMemberDeclaration, P p)
+public override Cs.EnumMemberDeclaration? VisitEnumMemberDeclaration(Cs.EnumMemberDeclaration enumMemberDeclaration, P p)
{
- return (Cs.EnumMemberDeclaration )(base.VisitEnumMemberDeclaration(enumMemberDeclaration, p));
+ return base.VisitEnumMemberDeclaration(enumMemberDeclaration, p) as Cs.EnumMemberDeclaration;
}
- public override Cs.AliasQualifiedName VisitAliasQualifiedName(Cs.AliasQualifiedName aliasQualifiedName, P p)
+public override Cs.AliasQualifiedName? VisitAliasQualifiedName(Cs.AliasQualifiedName aliasQualifiedName, P p)
{
- return (Cs.AliasQualifiedName )(base.VisitAliasQualifiedName(aliasQualifiedName, p));
+ return base.VisitAliasQualifiedName(aliasQualifiedName, p) as Cs.AliasQualifiedName;
}
- public override Cs.ArrayType VisitArrayType(Cs.ArrayType arrayType, P p)
+public override Cs.ArrayType? VisitArrayType(Cs.ArrayType arrayType, P p)
{
- return (Cs.ArrayType )(base.VisitArrayType(arrayType, p));
+ return base.VisitArrayType(arrayType, p) as Cs.ArrayType;
}
- public override Cs.Try VisitTry(Cs.Try @try, P p)
+public override Cs.Try? VisitTry(Cs.Try @try, P p)
{
- return (Cs.Try )(base.VisitTry(@try, p));
+ return base.VisitTry(@try, p) as Cs.Try;
}
- public override Cs.Try.Catch VisitTryCatch(Cs.Try.Catch @catch, P p)
+public override Cs.Try.Catch? VisitTryCatch(Cs.Try.Catch @catch, P p)
{
- return (Cs.Try.Catch )(base.VisitTryCatch(@catch, p));
+ return (base.VisitTryCatch(@catch, p)) as Cs.Try.Catch;
}
- public override Cs.ArrowExpressionClause VisitArrowExpressionClause(Cs.ArrowExpressionClause arrowExpressionClause, P p)
+public override Cs.ArrowExpressionClause? VisitArrowExpressionClause(Cs.ArrowExpressionClause arrowExpressionClause, P p)
{
- return (Cs.ArrowExpressionClause )(base.VisitArrowExpressionClause(arrowExpressionClause, p));
+ return base.VisitArrowExpressionClause(arrowExpressionClause, p) as Cs.ArrowExpressionClause;
}
- public override Cs.AccessorDeclaration VisitAccessorDeclaration(Cs.AccessorDeclaration accessorDeclaration, P p)
+public override Cs.AccessorDeclaration? VisitAccessorDeclaration(Cs.AccessorDeclaration accessorDeclaration, P p)
{
- return (Cs.AccessorDeclaration )(base.VisitAccessorDeclaration(accessorDeclaration, p));
+ return base.VisitAccessorDeclaration(accessorDeclaration, p) as Cs.AccessorDeclaration;
}
- public override Cs.PointerFieldAccess VisitPointerFieldAccess(Cs.PointerFieldAccess pointerFieldAccess, P p)
+public override Cs.PointerFieldAccess? VisitPointerFieldAccess(Cs.PointerFieldAccess pointerFieldAccess, P p)
{
- return (Cs.PointerFieldAccess )(base.VisitPointerFieldAccess(pointerFieldAccess, p));
+ return base.VisitPointerFieldAccess(pointerFieldAccess, p) as Cs.PointerFieldAccess;
}
- protected override Space VisitSpace(Space space, CsSpace.Location loc, P p)
- {
- return (Space )(base.VisitSpace(space, loc, p));
- }
-
- public override Expression VisitExpression(Expression expression, P p)
+public override Expression VisitExpression(Expression expression, P p)
{
return (Expression )(base.VisitExpression(expression, p));
}
- public override Statement VisitStatement(Statement statement, P p)
+public override Statement VisitStatement(Statement statement, P p)
{
return (Statement )(base.VisitStatement(statement, p));
}
- public override J.AnnotatedType VisitAnnotatedType(J.AnnotatedType annotatedType, P p)
+public override J.AnnotatedType? VisitAnnotatedType(J.AnnotatedType annotatedType, P p)
{
- return (J.AnnotatedType )(base.VisitAnnotatedType(annotatedType, p));
+ return base.VisitAnnotatedType(annotatedType, p) as J.AnnotatedType;
}
- public override J.Annotation VisitAnnotation(J.Annotation annotation, P p)
+public override J.Annotation? VisitAnnotation(J.Annotation annotation, P p)
{
- return (J.Annotation )(base.VisitAnnotation(annotation, p));
+ return base.VisitAnnotation(annotation, p) as J.Annotation;
}
- public override J.ArrayAccess VisitArrayAccess(J.ArrayAccess arrayAccess, P p)
+public override J.ArrayAccess? VisitArrayAccess(J.ArrayAccess arrayAccess, P p)
{
- return (J.ArrayAccess )(base.VisitArrayAccess(arrayAccess, p));
+ return base.VisitArrayAccess(arrayAccess, p) as J.ArrayAccess;
}
- public override J.ArrayType VisitArrayType(J.ArrayType arrayType, P p)
+public override J.ArrayType? VisitArrayType(J.ArrayType arrayType, P p)
{
- return (J.ArrayType )(base.VisitArrayType(arrayType, p));
+ return base.VisitArrayType(arrayType, p) as J.ArrayType;
}
- public override J.Assert VisitAssert(J.Assert assert, P p)
+public override J.Assert? VisitAssert(J.Assert assert, P p)
{
- return (J.Assert )(base.VisitAssert(assert, p));
+ return base.VisitAssert(assert, p) as J.Assert;
}
- public override J.Assignment VisitAssignment(J.Assignment assignment, P p)
+public override J.Assignment? VisitAssignment(J.Assignment assignment, P p)
{
- return (J.Assignment )(base.VisitAssignment(assignment, p));
+ return base.VisitAssignment(assignment, p) as J.Assignment;
}
- public override J.AssignmentOperation VisitAssignmentOperation(J.AssignmentOperation assignmentOperation, P p)
+public override J.AssignmentOperation? VisitAssignmentOperation(J.AssignmentOperation assignmentOperation, P p)
{
- return (J.AssignmentOperation )(base.VisitAssignmentOperation(assignmentOperation, p));
+ return base.VisitAssignmentOperation(assignmentOperation, p) as J.AssignmentOperation;
}
- public override J.Binary VisitBinary(J.Binary binary, P p)
+public override J.Binary? VisitBinary(J.Binary binary, P p)
{
- return (J.Binary )(base.VisitBinary(binary, p));
+ return base.VisitBinary(binary, p) as J.Binary;
}
- public override J.Block VisitBlock(J.Block block, P p)
+public override J.Block? VisitBlock(J.Block block, P p)
{
- return (J.Block )(base.VisitBlock(block, p));
+ return base.VisitBlock(block, p) as J.Block;
}
- public override J.Break VisitBreak(J.Break @break, P p)
+public override J.Break? VisitBreak(J.Break @break, P p)
{
- return (J.Break )(base.VisitBreak(@break, p));
+ return base.VisitBreak(@break, p) as J.Break;
}
- public override J.Case VisitCase(J.Case @case, P p)
+public override J.Case? VisitCase(J.Case @case, P p)
{
- return (J.Case )(base.VisitCase(@case, p));
+ return base.VisitCase(@case, p) as J.Case;
}
- public override J.ClassDeclaration VisitClassDeclaration(J.ClassDeclaration classDeclaration, P p)
+public override J.ClassDeclaration? VisitClassDeclaration(J.ClassDeclaration classDeclaration, P p)
{
- return (J.ClassDeclaration )(base.VisitClassDeclaration(classDeclaration, p));
+ return base.VisitClassDeclaration(classDeclaration, p) as J.ClassDeclaration;
}
- public override J.ClassDeclaration.Kind VisitClassDeclarationKind(J.ClassDeclaration.Kind kind, P p)
+public override J.ClassDeclaration.Kind? VisitClassDeclarationKind(J.ClassDeclaration.Kind kind, P p)
{
- return (J.ClassDeclaration.Kind )(base.VisitClassDeclarationKind(kind, p));
+ return (base.VisitClassDeclarationKind(kind, p)) as J.ClassDeclaration.Kind;
}
- public override J.CompilationUnit VisitCompilationUnit(J.CompilationUnit compilationUnit, P p)
+public override J.CompilationUnit? VisitCompilationUnit(J.CompilationUnit compilationUnit, P p)
{
- return (J.CompilationUnit )(base.VisitCompilationUnit(compilationUnit, p));
+ return base.VisitCompilationUnit(compilationUnit, p) as J.CompilationUnit;
}
- public override J.Continue VisitContinue(J.Continue @continue, P p)
+public override J.Continue? VisitContinue(J.Continue @continue, P p)
{
- return (J.Continue )(base.VisitContinue(@continue, p));
+ return base.VisitContinue(@continue, p) as J.Continue;
}
- public override J.DoWhileLoop VisitDoWhileLoop(J.DoWhileLoop doWhileLoop, P p)
+public override J.DoWhileLoop? VisitDoWhileLoop(J.DoWhileLoop doWhileLoop, P p)
{
- return (J.DoWhileLoop )(base.VisitDoWhileLoop(doWhileLoop, p));
+ return base.VisitDoWhileLoop(doWhileLoop, p) as J.DoWhileLoop;
}
- public override J.Empty VisitEmpty(J.Empty empty, P p)
+public override J.Empty? VisitEmpty(J.Empty empty, P p)
{
- return (J.Empty )(base.VisitEmpty(empty, p));
+ return base.VisitEmpty(empty, p) as J.Empty;
}
- public override J.EnumValue VisitEnumValue(J.EnumValue enumValue, P p)
+public override J.EnumValue? VisitEnumValue(J.EnumValue enumValue, P p)
{
- return (J.EnumValue )(base.VisitEnumValue(enumValue, p));
+ return base.VisitEnumValue(enumValue, p) as J.EnumValue;
}
- public override J.EnumValueSet VisitEnumValueSet(J.EnumValueSet enumValueSet, P p)
+public override J.EnumValueSet? VisitEnumValueSet(J.EnumValueSet enumValueSet, P p)
{
- return (J.EnumValueSet )(base.VisitEnumValueSet(enumValueSet, p));
+ return base.VisitEnumValueSet(enumValueSet, p) as J.EnumValueSet;
}
- public override J.FieldAccess VisitFieldAccess(J.FieldAccess fieldAccess, P p)
+public override J.FieldAccess? VisitFieldAccess(J.FieldAccess fieldAccess, P p)
{
- return (J.FieldAccess )(base.VisitFieldAccess(fieldAccess, p));
+ return base.VisitFieldAccess(fieldAccess, p) as J.FieldAccess;
}
- public override J.ForEachLoop VisitForEachLoop(J.ForEachLoop forEachLoop, P p)
+public override J.ForEachLoop? VisitForEachLoop(J.ForEachLoop forEachLoop, P p)
{
- return (J.ForEachLoop )(base.VisitForEachLoop(forEachLoop, p));
+ return base.VisitForEachLoop(forEachLoop, p) as J.ForEachLoop;
}
- public override J.ForEachLoop.Control VisitForEachControl(J.ForEachLoop.Control control, P p)
+public override J.ForEachLoop.Control? VisitForEachControl(J.ForEachLoop.Control control, P p)
{
- return (J.ForEachLoop.Control )(base.VisitForEachControl(control, p));
+ return (base.VisitForEachControl(control, p)) as J.ForEachLoop.Control;
}
- public override J.ForLoop VisitForLoop(J.ForLoop forLoop, P p)
+public override J.ForLoop? VisitForLoop(J.ForLoop forLoop, P p)
{
- return (J.ForLoop )(base.VisitForLoop(forLoop, p));
+ return base.VisitForLoop(forLoop, p) as J.ForLoop;
}
- public override J.ForLoop.Control VisitForControl(J.ForLoop.Control control, P p)
+public override J.ForLoop.Control? VisitForControl(J.ForLoop.Control control, P p)
{
- return (J.ForLoop.Control )(base.VisitForControl(control, p));
+ return (base.VisitForControl(control, p)) as J.ForLoop.Control;
}
- public override J.ParenthesizedTypeTree VisitParenthesizedTypeTree(J.ParenthesizedTypeTree parenthesizedTypeTree, P p)
+public override J.ParenthesizedTypeTree? VisitParenthesizedTypeTree(J.ParenthesizedTypeTree parenthesizedTypeTree, P p)
{
- return (J.ParenthesizedTypeTree )(base.VisitParenthesizedTypeTree(parenthesizedTypeTree, p));
+ return base.VisitParenthesizedTypeTree(parenthesizedTypeTree, p) as J.ParenthesizedTypeTree;
}
- public override J.Identifier VisitIdentifier(J.Identifier identifier, P p)
+public override J.Identifier? VisitIdentifier(J.Identifier identifier, P p)
{
- return (J.Identifier )(base.VisitIdentifier(identifier, p));
+ return base.VisitIdentifier(identifier, p) as J.Identifier;
}
- public override J.If VisitIf(J.If @if, P p)
+public override J.If? VisitIf(J.If @if, P p)
{
- return (J.If )(base.VisitIf(@if, p));
+ return base.VisitIf(@if, p) as J.If;
}
- public override J.If.Else VisitElse(J.If.Else @else, P p)
+public override J.If.Else? VisitElse(J.If.Else @else, P p)
{
- return (J.If.Else )(base.VisitElse(@else, p));
+ return (base.VisitElse(@else, p)) as J.If.Else;
}
- public override J.Import VisitImport(J.Import import, P p)
+public override J.Import? VisitImport(J.Import import, P p)
{
- return (J.Import )(base.VisitImport(import, p));
+ return base.VisitImport(import, p) as J.Import;
}
- public override J.InstanceOf VisitInstanceOf(J.InstanceOf instanceOf, P p)
+public override J.InstanceOf? VisitInstanceOf(J.InstanceOf instanceOf, P p)
{
- return (J.InstanceOf )(base.VisitInstanceOf(instanceOf, p));
+ return base.VisitInstanceOf(instanceOf, p) as J.InstanceOf;
}
- public override J.IntersectionType VisitIntersectionType(J.IntersectionType intersectionType, P p)
+public override J.IntersectionType? VisitIntersectionType(J.IntersectionType intersectionType, P p)
{
- return (J.IntersectionType )(base.VisitIntersectionType(intersectionType, p));
+ return base.VisitIntersectionType(intersectionType, p) as J.IntersectionType;
}
- public override J.Label VisitLabel(J.Label label, P p)
+public override J.Label? VisitLabel(J.Label label, P p)
{
- return (J.Label )(base.VisitLabel(label, p));
+ return base.VisitLabel(label, p) as J.Label;
}
- public override J.Lambda VisitLambda(J.Lambda lambda, P p)
+public override J.Lambda? VisitLambda(J.Lambda lambda, P p)
{
- return (J.Lambda )(base.VisitLambda(lambda, p));
+ return base.VisitLambda(lambda, p) as J.Lambda;
}
- public override J.Lambda.Parameters VisitLambdaParameters(J.Lambda.Parameters parameters, P p)
+public override J.Lambda.Parameters? VisitLambdaParameters(J.Lambda.Parameters parameters, P p)
{
- return (J.Lambda.Parameters )(base.VisitLambdaParameters(parameters, p));
+ return (base.VisitLambdaParameters(parameters, p)) as J.Lambda.Parameters;
}
- public override J.Literal VisitLiteral(J.Literal literal, P p)
+public override J.Literal? VisitLiteral(J.Literal literal, P p)
{
- return (J.Literal )(base.VisitLiteral(literal, p));
+ return base.VisitLiteral(literal, p) as J.Literal;
}
- public override J.MemberReference VisitMemberReference(J.MemberReference memberReference, P p)
+public override J.MemberReference? VisitMemberReference(J.MemberReference memberReference, P p)
{
- return (J.MemberReference )(base.VisitMemberReference(memberReference, p));
+ return base.VisitMemberReference(memberReference, p) as J.MemberReference;
}
- public override J.MethodDeclaration VisitMethodDeclaration(J.MethodDeclaration methodDeclaration, P p)
+public override J.MethodDeclaration? VisitMethodDeclaration(J.MethodDeclaration methodDeclaration, P p)
{
- return (J.MethodDeclaration )(base.VisitMethodDeclaration(methodDeclaration, p));
+ return base.VisitMethodDeclaration(methodDeclaration, p) as J.MethodDeclaration;
}
- public override J.MethodInvocation VisitMethodInvocation(J.MethodInvocation methodInvocation, P p)
+public override J.MethodInvocation? VisitMethodInvocation(J.MethodInvocation methodInvocation, P p)
{
- return (J.MethodInvocation )(base.VisitMethodInvocation(methodInvocation, p));
+ return base.VisitMethodInvocation(methodInvocation, p) as J.MethodInvocation;
}
- public override J.Modifier VisitModifier(J.Modifier modifier, P p)
+public override J.Modifier? VisitModifier(J.Modifier modifier, P p)
{
- return (J.Modifier )(base.VisitModifier(modifier, p));
+ return base.VisitModifier(modifier, p) as J.Modifier;
}
- public override J.MultiCatch VisitMultiCatch(J.MultiCatch multiCatch, P p)
+public override J.MultiCatch? VisitMultiCatch(J.MultiCatch multiCatch, P p)
{
- return (J.MultiCatch )(base.VisitMultiCatch(multiCatch, p));
+ return base.VisitMultiCatch(multiCatch, p) as J.MultiCatch;
}
- public override J.NewArray VisitNewArray(J.NewArray newArray, P p)
+public override J.NewArray? VisitNewArray(J.NewArray newArray, P p)
{
- return (J.NewArray )(base.VisitNewArray(newArray, p));
+ return base.VisitNewArray(newArray, p) as J.NewArray;
}
- public override J.ArrayDimension VisitArrayDimension(J.ArrayDimension arrayDimension, P p)
+public override J.ArrayDimension? VisitArrayDimension(J.ArrayDimension arrayDimension, P p)
{
- return (J.ArrayDimension )(base.VisitArrayDimension(arrayDimension, p));
+ return base.VisitArrayDimension(arrayDimension, p) as J.ArrayDimension;
}
- public override J.NewClass VisitNewClass(J.NewClass newClass, P p)
+public override J.NewClass? VisitNewClass(J.NewClass newClass, P p)
{
- return (J.NewClass )(base.VisitNewClass(newClass, p));
+ return base.VisitNewClass(newClass, p) as J.NewClass;
}
- public override J.NullableType VisitNullableType(J.NullableType nullableType, P p)
+public override J.NullableType? VisitNullableType(J.NullableType nullableType, P p)
{
- return (J.NullableType )(base.VisitNullableType(nullableType, p));
+ return base.VisitNullableType(nullableType, p) as J.NullableType;
}
- public override J.Package VisitPackage(J.Package package, P p)
+public override J.Package? VisitPackage(J.Package package, P p)
{
- return (J.Package )(base.VisitPackage(package, p));
+ return base.VisitPackage(package, p) as J.Package;
}
- public override J.ParameterizedType VisitParameterizedType(J.ParameterizedType parameterizedType, P p)
+public override J.ParameterizedType? VisitParameterizedType(J.ParameterizedType parameterizedType, P p)
{
- return (J.ParameterizedType )(base.VisitParameterizedType(parameterizedType, p));
+ return base.VisitParameterizedType(parameterizedType, p) as J.ParameterizedType;
}
- public override J.Parentheses VisitParentheses(J.Parentheses parentheses, P p)
+public override J.Parentheses? VisitParentheses(J.Parentheses parentheses, P p)
{
- return (J.Parentheses )(base.VisitParentheses(parentheses, p));
+ return (base.VisitParentheses(parentheses, p)) as J.Parentheses;
}
- public override J.ControlParentheses VisitControlParentheses(J.ControlParentheses controlParentheses, P p)
+public override J.ControlParentheses? VisitControlParentheses(J.ControlParentheses controlParentheses, P p)
{
- return (J.ControlParentheses )(base.VisitControlParentheses(controlParentheses, p));
+ return (base.VisitControlParentheses(controlParentheses, p)) as J.ControlParentheses;
}
- public override J.Primitive VisitPrimitive(J.Primitive primitive, P p)
+public override J.Primitive? VisitPrimitive(J.Primitive primitive, P p)
{
- return (J.Primitive )(base.VisitPrimitive(primitive, p));
+ return base.VisitPrimitive(primitive, p) as J.Primitive;
}
- public override J.Return VisitReturn(J.Return @return, P p)
+public override J.Return? VisitReturn(J.Return @return, P p)
{
- return (J.Return )(base.VisitReturn(@return, p));
+ return base.VisitReturn(@return, p) as J.Return;
}
- public override J.Switch VisitSwitch(J.Switch @switch, P p)
+public override J.Switch? VisitSwitch(J.Switch @switch, P p)
{
- return (J.Switch )(base.VisitSwitch(@switch, p));
+ return base.VisitSwitch(@switch, p) as J.Switch;
}
- public override J.SwitchExpression VisitSwitchExpression(J.SwitchExpression switchExpression, P p)
+public override J.SwitchExpression? VisitSwitchExpression(J.SwitchExpression switchExpression, P p)
{
- return (J.SwitchExpression )(base.VisitSwitchExpression(switchExpression, p));
+ return base.VisitSwitchExpression(switchExpression, p) as J.SwitchExpression;
}
- public override J.Synchronized VisitSynchronized(J.Synchronized synchronized, P p)
+public override J.Synchronized? VisitSynchronized(J.Synchronized synchronized, P p)
{
- return (J.Synchronized )(base.VisitSynchronized(synchronized, p));
+ return base.VisitSynchronized(synchronized, p) as J.Synchronized;
}
- public override J.Ternary VisitTernary(J.Ternary ternary, P p)
+public override J.Ternary? VisitTernary(J.Ternary ternary, P p)
{
- return (J.Ternary )(base.VisitTernary(ternary, p));
+ return base.VisitTernary(ternary, p) as J.Ternary;
}
- public override J.Throw VisitThrow(J.Throw @throw, P p)
+public override J.Throw? VisitThrow(J.Throw @throw, P p)
{
- return (J.Throw )(base.VisitThrow(@throw, p));
+ return base.VisitThrow(@throw, p) as J.Throw;
}
- public override J.Try VisitTry(J.Try @try, P p)
+public override J.Try? VisitTry(J.Try @try, P p)
{
- return (J.Try )(base.VisitTry(@try, p));
+ return base.VisitTry(@try, p) as J.Try;
}
- public override J.Try.Resource VisitTryResource(J.Try.Resource resource, P p)
+public override J.Try.Resource? VisitTryResource(J.Try.Resource resource, P p)
{
- return (J.Try.Resource )(base.VisitTryResource(resource, p));
+ return (base.VisitTryResource(resource, p)) as J.Try.Resource;
}
- public override J.Try.Catch VisitCatch(J.Try.Catch @catch, P p)
+public override J.Try.Catch? VisitCatch(J.Try.Catch @catch, P p)
{
- return (J.Try.Catch )(base.VisitCatch(@catch, p));
+ return (base.VisitCatch(@catch, p)) as J.Try.Catch;
}
- public override J.TypeCast VisitTypeCast(J.TypeCast typeCast, P p)
+public override J.TypeCast? VisitTypeCast(J.TypeCast typeCast, P p)
{
- return (J.TypeCast )(base.VisitTypeCast(typeCast, p));
+ return base.VisitTypeCast(typeCast, p) as J.TypeCast;
}
- public override J.TypeParameter VisitTypeParameter(J.TypeParameter typeParameter, P p)
+public override J.TypeParameter? VisitTypeParameter(J.TypeParameter typeParameter, P p)
{
- return (J.TypeParameter )(base.VisitTypeParameter(typeParameter, p));
+ return base.VisitTypeParameter(typeParameter, p) as J.TypeParameter;
}
- public override J.TypeParameters VisitTypeParameters(J.TypeParameters typeParameters, P p)
+public override J.TypeParameters? VisitTypeParameters(J.TypeParameters typeParameters, P p)
{
- return (J.TypeParameters )(base.VisitTypeParameters(typeParameters, p));
+ return base.VisitTypeParameters(typeParameters, p) as J.TypeParameters;
}
- public override J.Unary VisitUnary(J.Unary unary, P p)
+public override J.Unary? VisitUnary(J.Unary unary, P p)
{
- return (J.Unary )(base.VisitUnary(unary, p));
+ return base.VisitUnary(unary, p) as J.Unary;
}
- public override J.VariableDeclarations VisitVariableDeclarations(J.VariableDeclarations variableDeclarations, P p)
+public override J.VariableDeclarations? VisitVariableDeclarations(J.VariableDeclarations variableDeclarations, P p)
{
- return (J.VariableDeclarations )(base.VisitVariableDeclarations(variableDeclarations, p));
+ return base.VisitVariableDeclarations(variableDeclarations, p) as J.VariableDeclarations;
}
- public override J.VariableDeclarations.NamedVariable VisitVariable(J.VariableDeclarations.NamedVariable namedVariable, P p)
+public override J.VariableDeclarations.NamedVariable? VisitVariable(J.VariableDeclarations.NamedVariable namedVariable, P p)
{
- return (J.VariableDeclarations.NamedVariable )(base.VisitVariable(namedVariable, p));
+ return base.VisitVariable(namedVariable, p) as J.VariableDeclarations.NamedVariable;
}
- public override J.WhileLoop VisitWhileLoop(J.WhileLoop whileLoop, P p)
+public override J.WhileLoop? VisitWhileLoop(J.WhileLoop whileLoop, P p)
{
- return (J.WhileLoop )(base.VisitWhileLoop(whileLoop, p));
+ return base.VisitWhileLoop(whileLoop, p) as J.WhileLoop;
}
- public override J.Wildcard VisitWildcard(J.Wildcard wildcard, P p)
+public override J.Wildcard? VisitWildcard(J.Wildcard wildcard, P p)
{
- return (J.Wildcard )(base.VisitWildcard(wildcard, p));
+ return base.VisitWildcard(wildcard, p) as J.Wildcard;
}
- public override J.Yield VisitYield(J.Yield yield, P p)
+public override J.Yield? VisitYield(J.Yield yield, P p)
{
- return (J.Yield )(base.VisitYield(yield, p));
+ return base.VisitYield(yield, p) as J.Yield;
}
- public override J.Unknown VisitUnknown(J.Unknown unknown, P p)
+public override J.Unknown? VisitUnknown(J.Unknown unknown, P p)
{
- return (J.Unknown )(base.VisitUnknown(unknown, p));
+ return base.VisitUnknown(unknown, p) as J.Unknown;
}
- public override J.Unknown.Source VisitUnknownSource(J.Unknown.Source source, P p)
+public override J.Unknown.Source? VisitUnknownSource(J.Unknown.Source source, P p)
{
- return (J.Unknown.Source )(base.VisitUnknownSource(source, p));
+ return (base.VisitUnknownSource(source, p)) as J.Unknown.Source;
}
}
diff --git a/Rewrite/src/Rewrite.CSharp/CSharpParser.cs b/Rewrite/src/Rewrite.CSharp/CSharpParser.cs
index ab91a525..1f754d5c 100644
--- a/Rewrite/src/Rewrite.CSharp/CSharpParser.cs
+++ b/Rewrite/src/Rewrite.CSharp/CSharpParser.cs
@@ -11,6 +11,7 @@ namespace Rewrite.RewriteCSharp;
public class CSharpParser : Core.Parser
{
+ public static CSharpParser Instance { get; } = new Builder().Build();
private readonly IEnumerable _references;
private CSharpParser(IEnumerable references)
diff --git a/Rewrite/src/Rewrite.CSharp/CSharpPrinter.cs b/Rewrite/src/Rewrite.CSharp/CSharpPrinter.cs
index 49ac4686..6fd60fa3 100644
--- a/Rewrite/src/Rewrite.CSharp/CSharpPrinter.cs
+++ b/Rewrite/src/Rewrite.CSharp/CSharpPrinter.cs
@@ -15,6 +15,7 @@
*/
using System.Diagnostics;
+using System.Runtime.CompilerServices;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Rewrite.Core;
using Rewrite.Core.Marker;
@@ -33,6 +34,7 @@ namespace Rewrite.RewriteCSharp;
public class CSharpPrinter : CSharpVisitor>
{
private readonly CSharpJavaPrinter _delegate;
+ private readonly JavaPrinter _javaPrinter = new();
public CSharpPrinter()
{
@@ -310,6 +312,7 @@ protected void VisitRightPadded(JRightPadded? rightPadded, CsRightPadded.L
{
if (rightPadded != null)
{
+ PreVisitRightPadded(rightPadded, p);
BeforeSyntax(Space.EMPTY, rightPadded.Markers, (CsSpace.Location?)null, p);
Visit(rightPadded.Element, p);
AfterSyntax(rightPadded.Markers, p);
@@ -318,6 +321,28 @@ protected void VisitRightPadded(JRightPadded? rightPadded, CsRightPadded.L
{
p.Append(suffix);
}
+ PostVisitRightPadded(rightPadded, p);
+ }
+ }
+
+ protected void VisitRightPadded(IList> nodes, CsRightPadded.Location location, string suffixBetween, PrintOutputCapture p,
+ [CallerArgumentExpression("nodes")] string? valueArgumentExpression = null) where T : J
+ {
+ for (int i = 0; i < nodes.Count; i++)
+ {
+
+ var node = nodes[i];
+ PreVisitRightPadded(node, p);
+ Visit(node.Element, p);
+ VisitSpace(node.After, location.AfterLocation, p);
+ VisitMarkers(node.Markers, p);
+ var isLastElement = i < nodes.Count - 1;
+ if (isLastElement)
+ {
+ p.Append(suffixBetween);
+ }
+ PostVisitRightPadded(node, p);
+
}
}
@@ -841,6 +866,22 @@ public override Cs VisitPointerFieldAccess(Cs.PointerFieldAccess node, PrintOutp
return node;
}
+ protected override JRightPadded? VisitRightPadded(JRightPadded? right, CsRightPadded.Location loc, PrintOutputCapture p)
+ {
+ PreVisitRightPadded(right, p);
+ var result = base.VisitRightPadded(right, loc, p);
+ PostVisitRightPadded(result, p);
+ return result;
+ }
+
+ public override JRightPadded? VisitRightPadded(JRightPadded? right, JRightPadded.Location loc, PrintOutputCapture p)
+ {
+ PreVisitRightPadded(right, p);
+ var result = base.VisitRightPadded(right, loc, p);
+ PostVisitRightPadded(result, p);
+ return result;
+ }
+
public override Cs VisitCompilationUnit(Cs.CompilationUnit compilationUnit, PrintOutputCapture p)
{
BeforeSyntax(compilationUnit, Space.Location.COMPILATION_UNIT_PREFIX, p);
@@ -1052,8 +1093,7 @@ public override Cs VisitBlockScopeNamespaceDeclaration(Cs.BlockScopeNamespaceDec
public override J? VisitExpressionStatement(Cs.ExpressionStatement expressionStatement, PrintOutputCapture p)
{
BeforeSyntax(expressionStatement, CsSpace.Location.AWAIT_EXPRESSION_PREFIX, p);
- VisitRightPadded(expressionStatement.Padding.Expression, CsRightPadded.Location.EXPRESSION_STATEMENT_EXPRESSION, p);
- p.Append(";");
+ VisitRightPadded(expressionStatement.Padding.Expression, CsRightPadded.Location.EXPRESSION_STATEMENT_EXPRESSION, ";", p);
AfterSyntax(expressionStatement, p);
return expressionStatement;
}
@@ -1067,26 +1107,25 @@ public override Cs VisitBlockScopeNamespaceDeclaration(Cs.BlockScopeNamespaceDec
return externAlias;
}
- public override Cs VisitFileScopeNamespaceDeclaration(Cs.FileScopeNamespaceDeclaration namespaceDeclaration,
- PrintOutputCapture p)
+ public override Cs VisitFileScopeNamespaceDeclaration(Cs.FileScopeNamespaceDeclaration namespaceDeclaration, PrintOutputCapture p)
{
BeforeSyntax(namespaceDeclaration, CsSpace.Location.FILE_SCOPE_NAMESPACE_DECLARATION_PREFIX, p);
p.Append("namespace");
- VisitRightPadded(namespaceDeclaration.Padding.Name,
- CsRightPadded.Location.FILE_SCOPE_NAMESPACE_DECLARATION_NAME, p);
- p.Append(";");
- foreach (var externAlias in namespaceDeclaration.Padding.Externs)
- {
- VisitRightPadded(externAlias, CsRightPadded.Location.COMPILATION_UNIT_EXTERNS, p);
- p.Append(';');
- }
+ VisitRightPadded(namespaceDeclaration.Padding.Name, CsRightPadded.Location.FILE_SCOPE_NAMESPACE_DECLARATION_NAME, ";", p);
- foreach (var usingDirective in namespaceDeclaration.Padding.Usings)
- {
- VisitRightPadded(usingDirective, CsRightPadded.Location.FILE_SCOPE_NAMESPACE_DECLARATION_USINGS, p);
- p.Append(';');
- }
+ VisitStatements(namespaceDeclaration.Padding.Externs, CsRightPadded.Location.FILE_SCOPE_NAMESPACE_DECLARATION_EXTERNS,p);
+ // foreach (var externAlias in namespaceDeclaration.Padding.Externs)
+ // {
+ // VisitRightPadded(externAlias, CsRightPadded.Location.COMPILATION_UNIT_EXTERNS, p);
+ // }
+ VisitStatements(namespaceDeclaration.Padding.Usings, CsRightPadded.Location.FILE_SCOPE_NAMESPACE_DECLARATION_USINGS,p);
+
+ // foreach (var usingDirective in namespaceDeclaration.Padding.Usings)
+ // {
+ // VisitRightPadded(usingDirective, CsRightPadded.Location.FILE_SCOPE_NAMESPACE_DECLARATION_USINGS, p);
+ // p.Append(';');
+ // }
VisitStatements(namespaceDeclaration.Padding.Members, CsRightPadded.Location.FILE_SCOPE_NAMESPACE_DECLARATION_MEMBERS, p);
return namespaceDeclaration;
@@ -1325,14 +1364,19 @@ public override Cs VisitLambda(Cs.Lambda lambda, PrintOutputCapture p)
protected override Space VisitSpace(Space space, CsSpace.Location loc, PrintOutputCapture p)
{
- return _delegate.VisitSpace(space, Space.Location.LANGUAGE_EXTENSION, p);
+ return _javaPrinter.VisitSpace(space, Space.Location.LANGUAGE_EXTENSION, p);
+ // return _delegate.VisitSpace(space, Space.Location.LANGUAGE_EXTENSION, p);
}
+
public override Space VisitSpace(Space space, Space.Location? loc, PrintOutputCapture p)
{
- return _delegate.VisitSpace(space, loc, p);
+ return _javaPrinter.VisitSpace(space, loc, p);
+ // return _delegate.VisitSpace(space, loc, p);
}
+
+
protected void VisitLeftPaddedEnum(JLeftPadded? leftPadded, CsLeftPadded.Location location, PrintOutputCapture p) where T : Enum
{
if (leftPadded == null)
@@ -1340,24 +1384,27 @@ protected void VisitLeftPaddedEnum(JLeftPadded? leftPadded, CsLeftPadded.L
VisitLeftPadded(leftPadded, location, p);
p.Append(leftPadded.Element.ToString().ToLower());
}
- protected void VisitLeftPadded(string prefix, JLeftPadded? leftPadded, CsLeftPadded.Location location, PrintOutputCapture p) where T : J
+ protected void VisitLeftPadded(string prefix, JLeftPadded? leftPadded, CsLeftPadded.Location location, PrintOutputCapture p,
+ [CallerArgumentExpression("leftPadded")] string? valueArgumentExpression = null) where T : J
{
if (leftPadded != null)
{
+ PreVisitLeftPadded(leftPadded, p);
BeforeSyntax(leftPadded.Before, leftPadded.Markers, location.BeforeLocation, p);
- if (prefix != null)
- {
- p.Append(prefix);
- }
+ p.Append(prefix);
Visit(leftPadded.Element, p);
AfterSyntax(leftPadded.Markers, p);
+ PostVisitLeftPadded(leftPadded,p);
}
}
- protected void VisitContainer(string before, JContainer? container, CsContainer.Location location, string suffixBetween, string after, PrintOutputCapture p) where T : J
+
+ protected virtual void VisitContainer(string before, JContainer? container, CsContainer.Location location, string suffixBetween, string after, PrintOutputCapture p,
+ [CallerArgumentExpression("container")] string? valueArgumentExpression = null) where T : J
{
+ PreVisitContainer(container, p);
if (container == null)
{
return;
@@ -1367,23 +1414,10 @@ protected void VisitContainer(string before, JContainer? container, CsCont
p.Append(before);
VisitRightPadded(container.Padding.Elements, location.ElementLocation, suffixBetween, p);
p.Append(after);
+ PostVisitContainer(container, p);
}
- protected void VisitRightPadded(IList> nodes, CsRightPadded.Location location, string suffixBetween, PrintOutputCapture p) where T : J
- {
- for (int i = 0; i < nodes.Count; i++)
- {
- var node = nodes[i];
- Visit(node.Element, p);
- VisitSpace(node.After, location.AfterLocation, p);
- VisitMarkers(node.Markers, p);
- if (i < nodes.Count - 1)
- {
- p.Append(suffixBetween);
- }
- }
- }
protected void VisitStatements(string before, JContainer? container, CsContainer.Location location, string after, PrintOutputCapture p)
{
@@ -1398,6 +1432,14 @@ protected void VisitStatements(string before, JContainer? container,
p.Append(after);
}
+ protected void VisitStatements(IList> statements, CsRightPadded.Location location, PrintOutputCapture p) where T : Statement
+ {
+ foreach (var paddedStat in statements)
+ {
+ VisitStatement(paddedStat, location, p);
+ }
+ }
+
protected void VisitStatements(IList> statements, CsRightPadded.Location location, PrintOutputCapture p)
{
foreach (var paddedStat in statements)
@@ -1406,13 +1448,14 @@ protected void VisitStatements(IList> statements, CsRigh
}
}
- protected void VisitStatement(JRightPadded? paddedStat, CsRightPadded.Location location, PrintOutputCapture p)
+ protected void VisitStatement(JRightPadded? paddedStat, CsRightPadded.Location location, PrintOutputCapture p) where T : Statement
{
+
if (paddedStat == null)
{
return;
}
-
+ PreVisitRightPadded(paddedStat, p);
Visit(paddedStat.Element, p);
VisitSpace(paddedStat.After, location.AfterLocation, p);
VisitMarkers(paddedStat.Markers, p);
@@ -1423,7 +1466,10 @@ protected void VisitStatement(JRightPadded? paddedStat, CsRightPadded
return;
}
+ PostVisitRightPadded(paddedStat, p);
+
_delegate.PrintStatementTerminator(paddedStat.Element, p);
+
}
public override J? VisitTypeParameterConstraintClause(Cs.TypeParameterConstraintClause typeParameterConstraintClause, PrintOutputCapture p)
@@ -1467,6 +1513,33 @@ protected void VisitStatement(JRightPadded? paddedStat, CsRightPadded
}
+ protected virtual void PreVisitContainer(JContainer? node, PrintOutputCapture state)
+ {
+
+ }
+
+ protected virtual void PreVisitRightPadded(JRightPadded? node, PrintOutputCapture state)
+ {
+ }
+
+ protected virtual void PreVisitLeftPadded(JLeftPadded? node, PrintOutputCapture state)
+ {
+ }
+
+ protected virtual void PostVisitContainer(JContainer? node, PrintOutputCapture state)
+ {
+
+ }
+
+ protected virtual void PostVisitRightPadded(JRightPadded? node, PrintOutputCapture state)
+ {
+ }
+
+ protected virtual void PostVisitLeftPadded(JLeftPadded? node, PrintOutputCapture state)
+ {
+ }
+
+
private class CSharpJavaPrinter(CSharpPrinter _parent) : JavaPrinter
{
public override J? PreVisit(Core.Tree? tree, PrintOutputCapture p)
@@ -1505,6 +1578,12 @@ private class CSharpJavaPrinter(CSharpPrinter _parent) : JavaPrinter p)
+ {
+ // this workaround ensures that parent receives VisitSpace callback on EVERY call, not just ones initiated by parent
+ return _parent.VisitSpace(space, loc, p);
+ }
+
public override J VisitNewArray(J.NewArray newArray, PrintOutputCapture p)
{
BeforeSyntax(newArray, Space.Location.NEW_ARRAY_PREFIX, p);
@@ -1672,8 +1751,7 @@ public override J VisitMethodDeclaration(J.MethodDeclaration method, PrintOutput
if (method.Markers.FirstOrDefault(m => m is CompactConstructor) == null)
{
- VisitContainer("(", method.Padding.Parameters, JContainer.Location.METHOD_DECLARATION_PARAMETERS, ",",
- ")", p);
+ VisitContainer("(", method.Padding.Parameters, JContainer.Location.METHOD_DECLARATION_PARAMETERS, ",", ")", p);
}
@@ -1825,7 +1903,9 @@ Cs.DelegateDeclaration or
Cs.PropertyDeclaration { Initializer: not null } or
Cs.EventDeclaration { Accessors: null } or
Cs.GotoStatement or
- Cs.AccessorDeclaration { Body: null, ExpressionBody: null }
+ Cs.AccessorDeclaration { Body: null, ExpressionBody: null } or
+ Cs.UsingDirective or
+ Cs.ExternAlias
)
{
p.Append(';');
diff --git a/Rewrite/src/Rewrite.CSharp/Extensions.cs b/Rewrite/src/Rewrite.CSharp/Extensions.cs
index 321af2b7..262b5bc1 100644
--- a/Rewrite/src/Rewrite.CSharp/Extensions.cs
+++ b/Rewrite/src/Rewrite.CSharp/Extensions.cs
@@ -2,6 +2,7 @@
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Rewrite.Core;
+using Rewrite.RewriteCSharp.Tree;
using Rewrite.RewriteJava.Tree;
namespace Rewrite.RewriteCSharp;
@@ -22,11 +23,35 @@ public static class Extensions
public static TRoot ReplaceNode(this TRoot root, J oldNode, J newNode)
where TRoot : Core.Tree
{
- var newRoot = new ReplaceVisitor(oldNode, newNode).Visit(root, null);
+ var newRoot = new ReplaceNodeVisitor(oldNode, newNode).Visit(root, null);
return (TRoot)newRoot!;
}
- private class ReplaceVisitor(J oldNode, J newNode) : CSharpVisitor
+
+ private class ReplaceContainerVisitor(J oldNode, J newNode) : CSharpVisitor
+ {
+ public override JContainer? VisitContainer(JContainer? container, JContainer.Location loc, object? p)
+ {
+ return base.VisitContainer(container, loc, p);
+ }
+
+ protected override JContainer? VisitContainer(JContainer? container, CsContainer.Location loc, object? p)
+ {
+ return base.VisitContainer(container, loc, p);
+ }
+
+ public override J? PreVisit(Core.Tree? tree, object? p)
+ {
+ if (oldNode.Equals(tree))
+ {
+ return newNode;
+ }
+ return base.PreVisit(tree, p);
+ }
+ }
+
+
+ private class ReplaceNodeVisitor(J oldNode, J newNode) : CSharpVisitor
{
public override J? PreVisit(Core.Tree? tree, object? p)
{
@@ -40,11 +65,11 @@ private class ReplaceVisitor(J oldNode, J newNode) : CSharpVisitor
private class SearchVisitor : CSharpVisitor>
{
- public override J? PostVisit(Core.Tree tree, List p)
+ public override J? PreVisit(Core.Tree? tree, List p)
{
- p.Add(tree);
- return base.PostVisit(tree, p);
+ p.Add(tree!);
+ return base.PreVisit(tree!, p);
}
}
}
diff --git a/Rewrite/src/Rewrite.CSharp/Format/AutoFormat.cs b/Rewrite/src/Rewrite.CSharp/Format/AutoFormat.cs
new file mode 100644
index 00000000..c11f94eb
--- /dev/null
+++ b/Rewrite/src/Rewrite.CSharp/Format/AutoFormat.cs
@@ -0,0 +1,10 @@
+using ExecutionContext = Rewrite.Core.ExecutionContext;
+
+namespace Rewrite.RewriteCSharp.Format;
+
+public class AutoFormatRecipe : Recipe
+{
+ public override string DisplayName => "C# Auto Format";
+ public override string Description => "Formats the code for standard whitespace and indentation";
+ public override ITreeVisitor GetVisitor() => new AutoFormatVisitor();
+}
diff --git a/Rewrite/src/Rewrite.CSharp/Format/AutoFormatVisitor.cs b/Rewrite/src/Rewrite.CSharp/Format/AutoFormatVisitor.cs
new file mode 100644
index 00000000..c618c25b
--- /dev/null
+++ b/Rewrite/src/Rewrite.CSharp/Format/AutoFormatVisitor.cs
@@ -0,0 +1,286 @@
+using System.Diagnostics;
+using System.Text;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Formatting;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Formatting;
+using Microsoft.CodeAnalysis.Text;
+using Rewrite.RewriteCSharp.Tree;
+
+namespace Rewrite.RewriteCSharp.Format;
+
+
+public class AutoFormatVisitor : CSharpIsoVisitor
+{
+ private readonly Core.Tree? _stopAfter;
+
+ public AutoFormatVisitor() : this(null)
+ {
+ }
+
+ public AutoFormatVisitor(Core.Tree? stopAfter)
+ {
+ _stopAfter = stopAfter;
+ }
+
+ public override J? Visit(Core.Tree? tree, TState p)
+ {
+ return Visit(tree, p, new Cursor());
+ }
+
+ public override J? Visit(Core.Tree? tree, TState p, Cursor cursor)
+ {
+ // we only wanna act on the root
+ var cu = tree as Cs.CompilationUnit ?? cursor.FirstEnclosingOrThrow();
+ var originalCode = cu.ToString()!;
+
+ var roslynCu = SyntaxFactory.ParseCompilationUnit(originalCode);
+
+ SyntaxNode roslynNodeToFormat = roslynCu;
+ var style = FormatStyle.DetectStyle(originalCode);
+ var workspace = new AdhocWorkspace();
+ var options = workspace.Options
+ .WithChangedOption(FormattingOptions.UseTabs, LanguageNames.CSharp, style.UseTabs)
+ .WithChangedOption(FormattingOptions.IndentationSize, LanguageNames.CSharp, style.IdentationSize)
+ .WithChangedOption(FormattingOptions.NewLine, LanguageNames.CSharp, style.NewLine)
+ ;
+ roslynCu = AnnotateAllTriviasWithElastic(roslynCu, roslynNodeToFormat);
+ if (_stopAfter != null)
+ {
+ var nodeSpanMapper = new TreeMapVisitor();
+ nodeSpanMapper.Visit(cu, new PrintOutputCapture(0));
+ var lstSpanForTargetNode = nodeSpanMapper.SpanMap[_stopAfter];
+ roslynNodeToFormat = roslynCu.FindNode(lstSpanForTargetNode);
+
+ options = options.WithChangedOption(CSharpFormattingOptions.WrappingPreserveSingleLine, true);
+ }
+
+
+
+ // apply formatting to roslyn node and merge it back into compilation unit
+ var spanToFormat = GetOuterTokensSpan(roslynNodeToFormat);
+ var formattedRoslynCu = Formatter.Format(roslynCu, spanToFormat, workspace, options);
+
+
+ // ensure all whitespace is unique reference objects as that's how we're going to be targeting them since they don't have ID
+ var uniqueSpaceVisitor = new UniqueSpaceVisitor();
+ tree = uniqueSpaceVisitor.Visit(tree, 0);
+
+ var changes = GetWhitespaceChanges(roslynCu.ToFullString(), formattedRoslynCu.ToFullString());
+ // compose list of whitespace changes that need to be made
+ var spaceChangeScanner = new SpaceChangeScannerVisitor(changes);
+ spaceChangeScanner.Visit(tree, new PrintOutputCapture(0));
+ // apply whitespace changes and generate new tree
+ var applier = new SpaceChangeApplierVisitor();
+ tree = applier.Visit(tree, spaceChangeScanner.PendingSpaceChanges);
+
+ return (J?)tree;
+ }
+
+ /// Gets span between node's previous token and node's next token
+ private TextSpan GetOuterTokensSpan(SyntaxNode node)
+ {
+ var start = node.GetFirstToken().GetPreviousToken().Span.Start;
+ var nextToken = node.GetLastToken().GetNextToken();
+ var end = nextToken.IsPresent() ? nextToken.SpanStart : node.Span.End;
+ var span = new TextSpan(start, end-start);
+ return span;
+ }
+
+ ///
+ /// Within a given compilation unit, marks all trivia belonging to subnode as Elastic. This ensures that formatter will not try to preserve
+ /// any formatting for it as it's considered "autogenerated".
+ ///
+ /// containing
+ /// Node to mark as elastic
+ ///
+ private CompilationUnitSyntax AnnotateAllTriviasWithElastic(CompilationUnitSyntax compilationUnit, SyntaxNode node)
+ {
+ var allTrivias = node.DescendantTrivia();
+ var modifiedNode = node.ReplaceTrivia(allTrivias, (original, _) => original.WithAdditionalAnnotations(SyntaxAnnotation.ElasticAnnotation));
+
+ return compilationUnit.ReplaceNode(node, modifiedNode);
+ }
+
+ ///
+ /// Compares two C# code strings and returns a list of text changes representing the whitespace differences between them.
+ /// Will only work correctly with valid C# syntax.
+ ///
+ /// The original C# code string.
+ /// The modified C# code string.
+ /// A list of TextChange objects representing whitespace differences.
+ /// Thrown when the chunker produces different number of elements for before and after strings.
+ public static List GetWhitespaceChanges(string before, string after)
+ {
+ var chunker = new TriviaChunker();
+ var beforeChunks = chunker.Chunk(before);
+ var afterChunks = chunker.Chunk(after);
+
+ if (beforeChunks.Length != afterChunks.Length)
+ {
+ throw new InvalidOperationException("Chunker should produce the same number of elements for before and after.");
+ }
+
+ var changes = new List();
+ int position = 0;
+
+ // Compare chunks and track position to create TextChange objects for differences
+ for (int i = 0; i < beforeChunks.Length; i++)
+ {
+ var beforeChunk = beforeChunks[i];
+ var afterChunk = afterChunks[i];
+
+ if (beforeChunk != afterChunk)
+ {
+ changes.Add(new TextChange(new TextSpan(position, beforeChunk.Length), beforeChunk, afterChunk));
+ }
+
+ position += beforeChunk.Length;
+ }
+
+ return changes;
+ }
+
+ ///
+ /// Maps all LST nodes to they occupy when printed out
+ ///
+ private class TreeMapVisitor : CSharpPrinter
+ {
+ public Dictionary SpanMap { get; } = new();
+
+ public override J? PreVisit(Rewrite.Core.Tree? tree, PrintOutputCapture p)
+ {
+ if (tree != null)
+ {
+ var j = (J)tree;
+ SpanMap.Add(tree, new TextSpan(p.Out.Length + j.Prefix.ToString().Length, 0));
+ }
+ return tree as J;
+ }
+
+ public override J? PostVisit(Rewrite.Core.Tree tree, PrintOutputCapture p)
+ {
+ if (SpanMap.TryGetValue(tree, out TextSpan span))
+ {
+ SpanMap[tree] = new TextSpan(span.Start, p.Out.Length - span.Start);
+ }
+ return tree as J;
+ }
+ }
+
+ ///
+ /// Converts list of whitespace changes to list of transform targeting specific space elements (PendingSpaceChanges)
+ /// This is a two stage process as we we're relying to Printer to map which Space objects in LST correspond to textspans from
+ /// and schedule modification operation.
+ ///
+ ///
+ private class SpaceChangeScannerVisitor(IList changes) : CSharpPrinter
+ {
+ private readonly HashSet _changes = new(changes);
+ public Dictionary>> PendingSpaceChanges { get; } = new();
+
+ protected override Space VisitSpace(Space space, CsSpace.Location loc, PrintOutputCapture p)
+ {
+ return VisitSpace(space, () => base.VisitSpace(space, loc, p), p);
+ }
+
+ public override Space VisitSpace(Space space, Space.Location? loc, PrintOutputCapture p)
+ {
+ return VisitSpace(space, () => base.VisitSpace(space, loc, p), p);
+ }
+
+ public Space VisitSpace(Space space, Action visitBase, PrintOutputCapture p)
+ {
+ if (space == Space.EMPTY)
+ return space; // special case cuz markers are hardcoded with Space.Empty
+ var start = p.Out.Length;
+ visitBase();
+ var end = p.Out.Length;
+ var span = new TextSpan(start, end - start);
+
+ var overlappingChanges = _changes.Where(change => span.IntersectsWith(change.Span)).ToList();
+
+ if (overlappingChanges.Count > 1)
+ {
+ throw new Exception("Found multiple changes affecting same textspan area");
+ }
+
+ if (overlappingChanges.Count > 0)
+ {
+ var change = overlappingChanges.FirstOrDefault();
+ var changeTargetString = change.OldText;
+ var currentSpaceString = space.ToString();
+ // make sure the change is actually being applied to correct space it was originally computed from,
+ // since it's possible we had an empty Space occupying same region in original (overlap conflict)
+ if (currentSpaceString != changeTargetString)
+ {
+ return space;
+ }
+
+ var newWhitespace = ApplyChanges(span, space.Whitespace, overlappingChanges);
+ var newSpace = Space.Format(newWhitespace);
+ PendingSpaceChanges.Upsert(space, x => x.WithWhitespace(newSpace.Whitespace));
+ }
+
+ return space;
+ }
+
+ string ApplyChanges(TextSpan beforeSpan, string beforeWhitespace, List changes)
+ {
+ var sb = new StringBuilder();
+ using var currentChangeEnumerator = changes.GetEnumerator();
+ var hasChange = currentChangeEnumerator.MoveNext();
+ for (int i = beforeSpan.Start; i <= beforeSpan.End; i++)
+ {
+ var currentPositionInBefore = i - beforeSpan.Start;
+ if (hasChange && i >= currentChangeEnumerator.Current.Span.Start)
+ {
+ sb.Append(currentChangeEnumerator.Current.NewText);
+ i = currentChangeEnumerator.Current.Span.End - 1;
+ // remove it so we don't apply it twice in case multiple Space objects overlaps same region
+ _changes.Remove(currentChangeEnumerator.Current);
+ hasChange = currentChangeEnumerator.MoveNext();
+ }
+ else if (currentPositionInBefore < beforeWhitespace.Length)
+ {
+ sb.Append(beforeWhitespace[currentPositionInBefore]);
+ }
+ }
+
+ return sb.ToString();
+ }
+ }
+
+ ///
+ /// Walks the tree and for each Space object performs scheduled transformations produced by
+ ///
+ private class SpaceChangeApplierVisitor : CSharpIsoVisitor>>>
+ {
+ protected override Space VisitSpace(Space space, CsSpace.Location loc, Dictionary>> p)
+ {
+ var newSpace = ApplyChange(space, p);
+ return newSpace;
+ //return base.VisitSpace(space, loc, p);
+ }
+
+ public override Space VisitSpace(Space space, Space.Location? loc, Dictionary>> p)
+ {
+ var newSpace = ApplyChange(space, p);
+ return newSpace;
+ }
+
+ private Space ApplyChange(Space space, Dictionary>> p)
+ {
+ if (p.TryGetValue(space, out var spaceApplier))
+ {
+ foreach (var applySpace in spaceApplier)
+ {
+ space = applySpace(space);
+ }
+ }
+
+ return space;
+ }
+ }
+}
diff --git a/Rewrite/src/Rewrite.CSharp/Format/DictionaryExtensions.cs b/Rewrite/src/Rewrite.CSharp/Format/DictionaryExtensions.cs
new file mode 100644
index 00000000..9c620566
--- /dev/null
+++ b/Rewrite/src/Rewrite.CSharp/Format/DictionaryExtensions.cs
@@ -0,0 +1,27 @@
+namespace Rewrite.RewriteCSharp.Format;
+
+public static class DictionaryExtensions
+{
+ ///
+ /// Adds a value to a list associated with the specified key in a dictionary. If the key doesn't exist,
+ /// creates a new list and adds the value.
+ ///
+ /// The type of the dictionary key.
+ /// The type of values in the lists.
+ /// The dictionary to modify.
+ /// The key to find or create.
+ /// The value to add to the list.
+ /// True if a new list was created for the key; false if the value was added to an existing list.
+ public static bool Upsert(this IDictionary> dict, TKey key, TValue value)
+ {
+ var isNew = false;
+ if (!dict.TryGetValue(key, out var list))
+ {
+ list = new List();
+ dict[key] = list;
+ isNew = true;
+ }
+ list.Add(value);
+ return isNew;
+ }
+}
diff --git a/Rewrite/src/Rewrite.CSharp/Format/FormatStyle.cs b/Rewrite/src/Rewrite.CSharp/Format/FormatStyle.cs
new file mode 100644
index 00000000..e46ba6ff
--- /dev/null
+++ b/Rewrite/src/Rewrite.CSharp/Format/FormatStyle.cs
@@ -0,0 +1,66 @@
+using System.Runtime.InteropServices;
+
+namespace Rewrite.RewriteCSharp.Format;
+
+internal record FormatStyle(string Indentation, string NewLine)
+ {
+ static FormatStyle()
+ {
+ DefaultNewLine = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "\r\n" : "\n";
+ }
+ static string DefaultNewLine;
+ public bool UseTabs => Indentation == "\t";
+ public int IdentationSize => Indentation.Length;
+
+ public static FormatStyle DetectStyle(string code)
+ {
+
+ if (string.IsNullOrWhiteSpace(code))
+ return new FormatStyle(" ", DefaultNewLine); // Default to space and LF
+
+ // Detect line ending type
+ string endOfLine = code.Contains("\n") ? (code.Contains("\r\n") ? "\r\n" : "\n") : DefaultNewLine ;
+
+ // Split lines
+ var lines = code.Split(new[] { "\r\n", "\n" }, StringSplitOptions.None);
+ var spaceIndentLevels = new List();
+ bool usesTabs = false;
+
+ foreach (var line in lines)
+ {
+ if (string.IsNullOrWhiteSpace(line)) continue;
+
+ int leadingSpaces = line.TakeWhile(c => c == ' ').Count();
+ int leadingTabs = line.TakeWhile(c => c == '\t').Count();
+
+ if (leadingTabs > 0)
+ {
+ usesTabs = true;
+ break; // Found a tab, so the file likely uses tabs
+ }
+
+ if (leadingSpaces > 0)
+ spaceIndentLevels.Add(leadingSpaces);
+ }
+
+ if (usesTabs)
+ return new FormatStyle("\t", endOfLine);
+
+ if (spaceIndentLevels.Count < 2)
+ return new FormatStyle(" ", endOfLine); // Default to 4 spaces if not enough data
+
+ // Find the most common spacing step
+ var distinctSteps = spaceIndentLevels.Distinct().OrderBy(x => x).ToList();
+ var spacingDifferences = new List();
+
+ for (int i = 1; i < distinctSteps.Count; i++)
+ spacingDifferences.Add(distinctSteps[i] - distinctSteps[i - 1]);
+
+ int detectedTabSize = spacingDifferences.GroupBy(x => x)
+ .OrderByDescending(g => g.Count())
+ .Select(g => g.Key)
+ .FirstOrDefault(4); // Default to 4 spaces if unclear
+
+ return new FormatStyle(new string(' ', detectedTabSize), endOfLine);
+ }
+ }
diff --git a/Rewrite/src/Rewrite.CSharp/Format/NormalizeFormatVisitor.cs b/Rewrite/src/Rewrite.CSharp/Format/NormalizeFormatVisitor.cs
deleted file mode 100644
index 1032f5cc..00000000
--- a/Rewrite/src/Rewrite.CSharp/Format/NormalizeFormatVisitor.cs
+++ /dev/null
@@ -1,217 +0,0 @@
-using System.Diagnostics.CodeAnalysis;
-using System.Text.Json.Serialization;
-using Rewrite.Core;
-using Rewrite.RewriteCSharp.Internal;
-using Rewrite.RewriteCSharp.Tree;
-using Rewrite.RewriteJava;
-using Rewrite.RewriteJava.Tree;
-
-namespace Rewrite.RewriteCSharp.Format;
-
-///
-/// Ensures that whitespace is on the outermost AST element possible.
-///
-public class NormalizeFormatVisitor : CSharpIsoVisitor
-{
- private readonly Core.Tree? stopAfter;
-
- [JsonConstructor]
- public NormalizeFormatVisitor(Core.Tree? stopAfter)
- {
- this.stopAfter = stopAfter;
- }
-
- public NormalizeFormatVisitor() : this(null) { }
-
- public override J.ClassDeclaration VisitClassDeclaration(J.ClassDeclaration classDecl, P p)
- {
- var c = base.VisitClassDeclaration(classDecl, p);
-
- if (c.LeadingAnnotations.Any())
- {
- c = ConcatenatePrefix(c, Space.FirstPrefix(c.LeadingAnnotations));
- c = c.WithLeadingAnnotations(Space.FormatFirstPrefix(c.LeadingAnnotations, Space.EMPTY));
- return c;
- }
-
- if (c.Modifiers.Any())
- {
- c = ConcatenatePrefix(c, Space.FirstPrefix(c.Modifiers));
- c = c.WithModifiers(Space.FormatFirstPrefix(c.Modifiers, Space.EMPTY));
- return c;
- }
-
- if (!c.Padding.DeclarationKind.Prefix.IsEmpty)
- {
- c = ConcatenatePrefix(c, c.Padding.DeclarationKind.Prefix);
- c = c.Padding.WithDeclarationKind(c.Padding.DeclarationKind.WithPrefix(Space.EMPTY));
- return c;
- }
-
- var typeParameters = c.Padding.TypeParameters;
- if (typeParameters != null && typeParameters.Elements.Any())
- {
- c = ConcatenatePrefix(c, typeParameters.Before);
- c = c.Padding.WithTypeParameters(typeParameters.WithBefore(Space.EMPTY));
- return c;
- }
-
- return c.WithName(c.Name.WithPrefix(c.Name.Prefix.WithWhitespace(" ")));
- }
-
-
- [SuppressMessage("ReSharper", "ConstantConditionWarning")]
- public override J.MethodDeclaration VisitMethodDeclaration(J.MethodDeclaration method, P p)
- {
- var m = base.VisitMethodDeclaration(method, p);
-
- if (m.LeadingAnnotations.Any())
- {
- m = ConcatenatePrefix(m, Space.FirstPrefix(m.LeadingAnnotations));
- m = m.WithLeadingAnnotations(Space.FormatFirstPrefix(m.LeadingAnnotations, Space.EMPTY));
- return m;
- }
-
- if (m.Modifiers.Any())
- {
- m = ConcatenatePrefix(m, Space.FirstPrefix(m.Modifiers));
- m = m.WithModifiers(Space.FormatFirstPrefix(m.Modifiers, Space.EMPTY));
- return m;
- }
-
- if (m.Annotations.TypeParameters != null)
- {
- if (m.Annotations.TypeParameters.Parameters.Any())
- {
- m = ConcatenatePrefix(m, m.Annotations.TypeParameters.Prefix);
- m = m.Annotations.WithTypeParameters(m.Annotations.TypeParameters!.WithPrefix(Space.EMPTY));
- }
- return m;
- }
-
- if (m.ReturnTypeExpression != null)
- {
- if (!string.IsNullOrEmpty(m.ReturnTypeExpression.Prefix.Whitespace))
- {
- m = ConcatenatePrefix(m, m.ReturnTypeExpression.Prefix);
- m = m.WithReturnTypeExpression(m.ReturnTypeExpression!.WithPrefix(Space.EMPTY) as TypeTree);
- }
- return m;
- }
-
- m = ConcatenatePrefix(m, m.Name.Prefix);
- m = m.WithName(m.Name.WithPrefix(Space.EMPTY));
- return m;
- }
-
- [SuppressMessage("ReSharper", "ConstantConditionWarning")]
- public override Cs.MethodDeclaration VisitMethodDeclaration(Cs.MethodDeclaration method, P p)
- {
- var m = base.VisitMethodDeclaration(method, p);
-
- if (m.Attributes.Any())
- {
- m = ConcatenatePrefix(m, Space.FirstPrefix(m.Attributes));
- m = m.WithAttributes(Space.FormatFirstPrefix(m.Attributes, Space.EMPTY));
- return m;
- }
-
- if (m.Modifiers.Any())
- {
- m = ConcatenatePrefix(m, Space.FirstPrefix(m.Modifiers));
- m = m.WithModifiers(Space.FormatFirstPrefix(m.Modifiers, Space.EMPTY));
- return m;
- }
-
-
- if (!string.IsNullOrEmpty(m.ReturnTypeExpression.Prefix.Whitespace))
- {
- m = ConcatenatePrefix(m, m.ReturnTypeExpression.Prefix);
- m = m.WithReturnTypeExpression((TypeTree)m.ReturnTypeExpression!.WithPrefix(Space.EMPTY));
- }
- return m;
-
- }
-
- [SuppressMessage("ReSharper", "ConstantConditionWarning")]
- public override J.VariableDeclarations VisitVariableDeclarations(J.VariableDeclarations multiVariable, P p)
- {
- var v = base.VisitVariableDeclarations(multiVariable, p);
-
- if (v.LeadingAnnotations.Any())
- {
- v = ConcatenatePrefix(v, Space.FirstPrefix(v.LeadingAnnotations));
- v = v.WithLeadingAnnotations(Space.FormatFirstPrefix(v.LeadingAnnotations, Space.EMPTY));
- return v;
- }
-
- if (v.Modifiers.Any())
- {
- v = ConcatenatePrefix(v, Space.FirstPrefix(v.Modifiers));
- v = v.WithModifiers(Space.FormatFirstPrefix(v.Modifiers, Space.EMPTY));
- return v;
- }
-
- if (v.TypeExpression != null)
- {
- v = ConcatenatePrefix(v, v.TypeExpression.Prefix);
- v = v.WithTypeExpression(v.TypeExpression!.WithPrefix(Space.EMPTY) as TypeTree);
- return v;
- }
-
- return v;
- }
-
- private J2 ConcatenatePrefix(J2 j, Space prefix) where J2 : J
- {
- string? shift = StringUtils.CommonMargin(null, j.Prefix.Whitespace);
-
- var comments = ListUtils.ConcatAll(
- j.Prefix.Comments,
- prefix.Comments.Map(comment =>
- {
- Comment c = comment;
- if (string.IsNullOrEmpty(shift))
- {
- return c;
- }
-
- if (comment is TextComment textComment)
- {
- c = textComment.WithText(textComment.Text.Replace("\n", "\n" + shift));
- }
-
-
- if (c.Suffix.Contains("\n"))
- {
- c = c.WithSuffix(c.Suffix.Replace("\n", "\n" + shift));
- }
-
- return c;
- })
- );
-
- return j.WithPrefix(j.Prefix
- .WithWhitespace(j.Prefix.Whitespace + prefix.Whitespace)
- .WithComments(comments));
- }
-
- public override J? PostVisit(Core.Tree tree, P p)
- {
- if (stopAfter != null && stopAfter.IsScope(tree))
- {
- Cursor.PutMessageOnFirstEnclosing("stop", true);
- }
- return base.PostVisit(tree, p);
- }
-
-
- public override J? Visit(Core.Tree? tree, P p)
- {
- if (Cursor.GetNearestMessage("stop") != null)
- {
- return (J)tree!;
- }
- return base.Visit(tree, p);
- }
-}
diff --git a/Rewrite/src/Rewrite.CSharp/Format/TextChange.cs b/Rewrite/src/Rewrite.CSharp/Format/TextChange.cs
new file mode 100644
index 00000000..84a3b9e1
--- /dev/null
+++ b/Rewrite/src/Rewrite.CSharp/Format/TextChange.cs
@@ -0,0 +1,105 @@
+using System.Diagnostics;
+using Microsoft.CodeAnalysis.Text;
+
+namespace Rewrite.RewriteCSharp.Format;
+
+
+///
+/// Describes a single change when a particular span is replaced with a new text.
+///
+public readonly struct TextChange : IEquatable
+{
+ ///
+ /// The original span of the changed text.
+ ///
+
+ public TextSpan Span { get; }
+
+ ///
+ /// The old text.
+ ///
+
+ public string? OldText { get; }
+
+ ///
+ /// The new text.
+ ///
+
+ public string? NewText { get; }
+ ///
+ /// Initializes a new instance of
+ ///
+ /// The original span of the changed text.
+ /// The new text.
+ public TextChange(TextSpan span, string oldText, string newText)
+ : this()
+ {
+ if (newText == null)
+ {
+ throw new ArgumentNullException(nameof(newText));
+ }
+
+ this.Span = span;
+ this.NewText = newText;
+ this.OldText = oldText;
+ }
+
+ ///
+ /// Provides a string representation for .
+ ///
+ public override string ToString()
+ {
+ return $"{nameof(TextChange)}: {{ {Span}, Before: \"{OldText}\", NewText: \"{NewText}\" }}";
+ }
+
+ public override bool Equals(object? obj)
+ {
+ return obj is TextChange && this.Equals((TextChange)obj);
+ }
+
+ public bool Equals(TextChange other)
+ {
+ return
+ EqualityComparer.Default.Equals(this.Span, other.Span) &&
+ EqualityComparer.Default.Equals(this.OldText, other.OldText) &&
+ EqualityComparer.Default.Equals(this.NewText, other.NewText);
+ }
+
+ public override int GetHashCode()
+ {
+ return HashCode.Combine(this.Span.GetHashCode(), this.NewText?.GetHashCode() ?? 0);
+ }
+
+ public static bool operator ==(TextChange left, TextChange right)
+ {
+ return left.Equals(right);
+ }
+
+ public static bool operator !=(TextChange left, TextChange right)
+ {
+ return !(left == right);
+ }
+
+ ///
+ /// Converts a to a .
+ ///
+ ///
+ public static implicit operator TextChangeRange(TextChange change)
+ {
+ Debug.Assert(change.NewText != null);
+ return new TextChangeRange(change.Span, change.NewText.Length);
+ }
+
+
+ internal string GetDebuggerDisplay()
+ {
+ var newTextDisplay = NewText switch
+ {
+ null => "null",
+ { Length: < 10 } => $"\"{NewText}\"",
+ { Length: var length } => $"(NewLength = {length})"
+ };
+ return $"new TextChange(new TextSpan({Span.Start}, {Span.Length}), {newTextDisplay})";
+ }
+}
+
diff --git a/Rewrite/src/Rewrite.CSharp/Format/TriviaChunker.cs b/Rewrite/src/Rewrite.CSharp/Format/TriviaChunker.cs
new file mode 100644
index 00000000..e574aab9
--- /dev/null
+++ b/Rewrite/src/Rewrite.CSharp/Format/TriviaChunker.cs
@@ -0,0 +1,49 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Text;
+
+namespace Rewrite.RewriteCSharp.Format;
+
+///
+/// Computes changes to Whitespace c# code using c# token based chunking
+///
+internal class TriviaChunker
+{
+
+
+ ///
+ /// Splits a C# code string into chunks based on syntax tokens and their trivia.
+ ///
+ /// The C# code to chunk.
+ ///
+ /// An array of string chunks representing tokens and their surrounding trivia.
+ /// The elements will be in alternating order ( trivia / token / trivia ... / token / trivia )
+ ///
+ public string[] Chunk(string csharpCode)
+ {
+ var result = new List();
+
+ // Parse text into syntax tree and get first token
+ var root = CSharpSyntaxTree.ParseText(csharpCode).GetCompilationUnitRoot();
+ var token = root.GetFirstToken();
+ SyntaxToken prevToken = SyntaxFactory.Token(SyntaxKind.None);
+
+ // Process each token and collect trivia
+ do
+ {
+ // Combine trailing trivia from previous token with leading trivia of current token
+ var trivia = $"{prevToken.TrailingTrivia.ToFullString()}{token.LeadingTrivia.ToFullString()}";
+ result.Add(trivia);
+
+ // Add token text and prepare for next iteration
+ result.Add(token.ToString());
+ prevToken = token;
+ token = token.GetNextToken();
+ } while (!token.IsKind(SyntaxKind.None));
+
+ // Add final trailing trivia
+ result.Add(prevToken.TrailingTrivia.ToFullString());
+
+ return result.ToArray();
+ }
+}
diff --git a/Rewrite/src/Rewrite.CSharp/Format/UniqueSpaceVisitor.cs b/Rewrite/src/Rewrite.CSharp/Format/UniqueSpaceVisitor.cs
new file mode 100644
index 00000000..ec42150d
--- /dev/null
+++ b/Rewrite/src/Rewrite.CSharp/Format/UniqueSpaceVisitor.cs
@@ -0,0 +1,57 @@
+using Rewrite.RewriteCSharp.Tree;
+
+namespace Rewrite.RewriteCSharp.Format;
+
+///
+/// Visitor that ensures space objects are unique by reference equality
+///
+internal class UniqueSpaceVisitor : CSharpIsoVisitor
+{
+ /// Space objects seen so far, compared by reference equality
+ private readonly HashSet _spaces = new(ReferenceEqualityComparer.Instance);
+
+ /// Visit space with location
+ /// Space to visit
+ /// Location in source
+ /// Parameter passed through visitor
+ /// Unique space instance
+ protected override Space VisitSpace(Space space, CsSpace.Location loc, int p)
+ {
+ return VisitSpace(space, p);
+ }
+
+ /// Visit space with optional location
+ /// Space to visit
+ /// Optional location in source
+ /// Parameter passed through visitor
+ /// Unique space instance
+ public override Space VisitSpace(Space space, Space.Location? loc, int p)
+ {
+ return VisitSpace(space, p);
+ }
+
+ ///
+ /// Visit space and ensure it is unique. If an empty space is encountered, creates new space instance.
+ /// If space was seen before, creates new instance with same content.
+ ///
+ /// Space to visit
+ /// Parameter passed through visitor
+ /// Unique space instance
+ public Space VisitSpace(Space space, int p)
+ {
+ // Create new instance for empty space
+ if (ReferenceEquals(space, Space.EMPTY))
+ {
+ space = new Space([], "");
+ }
+
+ // Create new instance if space was seen before
+ if (_spaces.Contains(space))
+ {
+ space = new Space(space.Comments, space.Whitespace);
+ }
+
+ _spaces.Add(space);
+ return space;
+ }
+}
diff --git a/Rewrite/src/Rewrite.CSharp/Global.cs b/Rewrite/src/Rewrite.CSharp/Global.cs
new file mode 100644
index 00000000..3d1ed872
--- /dev/null
+++ b/Rewrite/src/Rewrite.CSharp/Global.cs
@@ -0,0 +1,3 @@
+global using Rewrite.RewriteJava.Tree;
+global using Rewrite.Core;
+global using Rewrite.Core.Marker;
diff --git a/Rewrite/src/Rewrite.CSharp/Rewrite.CSharp.csproj b/Rewrite/src/Rewrite.CSharp/Rewrite.CSharp.csproj
index 5c9a3279..fa07a306 100644
--- a/Rewrite/src/Rewrite.CSharp/Rewrite.CSharp.csproj
+++ b/Rewrite/src/Rewrite.CSharp/Rewrite.CSharp.csproj
@@ -9,7 +9,8 @@
-
+
+
diff --git a/Rewrite/src/Rewrite.CSharp/Roslyn/Parser.cs b/Rewrite/src/Rewrite.CSharp/Roslyn/Parser.cs
new file mode 100644
index 00000000..42dc9d9e
--- /dev/null
+++ b/Rewrite/src/Rewrite.CSharp/Roslyn/Parser.cs
@@ -0,0 +1,21 @@
+// using Microsoft.CodeAnalysis;
+// using Microsoft.CodeAnalysis.CSharp;
+// using Microsoft.CodeAnalysis.CSharp.Syntax;
+// using Rewrite.RewriteCSharp.Tree;
+//
+// namespace Rewrite.RewriteCSharp.Roslyn;
+//
+// public class Parser
+// {
+// public SyntaxNode Parse(Core.Tree tree)
+// {
+// Core.Tree.ToString(tree)
+// var code = tree.ToString() ?? throw new InvalidOperationException("Tree ToString() returned null. Is the local printer configured?");
+//
+// var syntaxNode = tree switch
+// {
+// Cs.CompilationUnit => SyntaxFactory.ParseCompilationUnit(code),
+// Cs.ClassDeclaration => SyntaxFactory.ParseMemberDeclaration(code),
+// }
+// }
+// }
diff --git a/Rewrite/src/Rewrite.CSharp/Tree/AccessorDeclaration.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/AccessorDeclaration.g.cs
index 9db11234..0a3cff23 100644
--- a/Rewrite/src/Rewrite.CSharp/Tree/AccessorDeclaration.g.cs
+++ b/Rewrite/src/Rewrite.CSharp/Tree/AccessorDeclaration.g.cs
@@ -93,54 +93,54 @@ public PaddingHelper Padding
return v.VisitAccessorDeclaration(this, p);
}
- public Guid Id => id;
+ public Guid Id { get; set; } = id;
public AccessorDeclaration WithId(Guid newId)
{
- return newId == id ? this : new AccessorDeclaration(newId, prefix, markers, attributes, modifiers, _kind, expressionBody, body);
+ return newId == Id ? this : new AccessorDeclaration(newId, Prefix, Markers, Attributes, Modifiers, _kind, ExpressionBody, Body);
}
- public Space Prefix => prefix;
+ public Space Prefix { get; set; } = prefix;
public AccessorDeclaration WithPrefix(Space newPrefix)
{
- return newPrefix == prefix ? this : new AccessorDeclaration(id, newPrefix, markers, attributes, modifiers, _kind, expressionBody, body);
+ return newPrefix == Prefix ? this : new AccessorDeclaration(Id, newPrefix, Markers, Attributes, Modifiers, _kind, ExpressionBody, Body);
}
- public Markers Markers => markers;
+ public Markers Markers { get; set; } = markers;
public AccessorDeclaration WithMarkers(Markers newMarkers)
{
- return ReferenceEquals(newMarkers, markers) ? this : new AccessorDeclaration(id, prefix, newMarkers, attributes, modifiers, _kind, expressionBody, body);
+ return ReferenceEquals(newMarkers, Markers) ? this : new AccessorDeclaration(Id, Prefix, newMarkers, Attributes, Modifiers, _kind, ExpressionBody, Body);
}
- public IList Attributes => attributes;
+ public IList Attributes { get; set; } = attributes;
public AccessorDeclaration WithAttributes(IList newAttributes)
{
- return newAttributes == attributes ? this : new AccessorDeclaration(id, prefix, markers, newAttributes, modifiers, _kind, expressionBody, body);
+ return newAttributes == Attributes ? this : new AccessorDeclaration(Id, Prefix, Markers, newAttributes, Modifiers, _kind, ExpressionBody, Body);
}
- public IList Modifiers => modifiers;
+ public IList Modifiers { get; set; } = modifiers;
public AccessorDeclaration WithModifiers(IList newModifiers)
{
- return newModifiers == modifiers ? this : new AccessorDeclaration(id, prefix, markers, attributes, newModifiers, _kind, expressionBody, body);
+ return newModifiers == Modifiers ? this : new AccessorDeclaration(Id, Prefix, Markers, Attributes, newModifiers, _kind, ExpressionBody, Body);
}
- private readonly JLeftPadded _kind = kind;
+ private JLeftPadded _kind = kind;
public AccessorKinds Kind => _kind.Element;
public AccessorDeclaration WithKind(AccessorKinds newKind)
{
return Padding.WithKind(_kind.WithElement(newKind));
}
- public Cs.ArrowExpressionClause? ExpressionBody => expressionBody;
+ public Cs.ArrowExpressionClause? ExpressionBody { get; set; } = expressionBody;
public AccessorDeclaration WithExpressionBody(Cs.ArrowExpressionClause? newExpressionBody)
{
- return ReferenceEquals(newExpressionBody, expressionBody) ? this : new AccessorDeclaration(id, prefix, markers, attributes, modifiers, _kind, newExpressionBody, body);
+ return ReferenceEquals(newExpressionBody, ExpressionBody) ? this : new AccessorDeclaration(Id, Prefix, Markers, Attributes, Modifiers, _kind, newExpressionBody, Body);
}
- public J.Block? Body => body;
+ public J.Block? Body { get; set; } = body;
public AccessorDeclaration WithBody(J.Block? newBody)
{
- return ReferenceEquals(newBody, body) ? this : new AccessorDeclaration(id, prefix, markers, attributes, modifiers, _kind, expressionBody, newBody);
+ return ReferenceEquals(newBody, Body) ? this : new AccessorDeclaration(Id, Prefix, Markers, Attributes, Modifiers, _kind, ExpressionBody, newBody);
}
public enum AccessorKinds
{
@@ -152,11 +152,11 @@ public enum AccessorKinds
}
public sealed record PaddingHelper(Cs.AccessorDeclaration T)
{
- public JLeftPadded Kind => T._kind;
+ public JLeftPadded Kind { get => T._kind; set => T._kind = value; }
public Cs.AccessorDeclaration WithKind(JLeftPadded newKind)
{
- return T._kind == newKind ? T : new Cs.AccessorDeclaration(T.Id, T.Prefix, T.Markers, T.Attributes, T.Modifiers, newKind, T.ExpressionBody, T.Body);
+ return Kind == newKind ? T : new Cs.AccessorDeclaration(T.Id, T.Prefix, T.Markers, T.Attributes, T.Modifiers, newKind, T.ExpressionBody, T.Body);
}
}
diff --git a/Rewrite/src/Rewrite.CSharp/Tree/AliasQualifiedName.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/AliasQualifiedName.g.cs
index 342ce574..d8eab0ee 100644
--- a/Rewrite/src/Rewrite.CSharp/Tree/AliasQualifiedName.g.cs
+++ b/Rewrite/src/Rewrite.CSharp/Tree/AliasQualifiedName.g.cs
@@ -76,44 +76,44 @@ public PaddingHelper Padding
return v.VisitAliasQualifiedName(this, p);
}
- public Guid Id => id;
+ public Guid Id { get; set; } = id;
public AliasQualifiedName WithId(Guid newId)
{
- return newId == id ? this : new AliasQualifiedName(newId, prefix, markers, _alias, name);
+ return newId == Id ? this : new AliasQualifiedName(newId, Prefix, Markers, _alias, Name);
}
- public Space Prefix => prefix;
+ public Space Prefix { get; set; } = prefix;
public AliasQualifiedName WithPrefix(Space newPrefix)
{
- return newPrefix == prefix ? this : new AliasQualifiedName(id, newPrefix, markers, _alias, name);
+ return newPrefix == Prefix ? this : new AliasQualifiedName(Id, newPrefix, Markers, _alias, Name);
}
- public Markers Markers => markers;
+ public Markers Markers { get; set; } = markers;
public AliasQualifiedName WithMarkers(Markers newMarkers)
{
- return ReferenceEquals(newMarkers, markers) ? this : new AliasQualifiedName(id, prefix, newMarkers, _alias, name);
+ return ReferenceEquals(newMarkers, Markers) ? this : new AliasQualifiedName(Id, Prefix, newMarkers, _alias, Name);
}
- private readonly JRightPadded _alias = alias;
+ private JRightPadded _alias = alias;
public J.Identifier Alias => _alias.Element;
public AliasQualifiedName WithAlias(J.Identifier newAlias)
{
return Padding.WithAlias(_alias.WithElement(newAlias));
}
- public Expression Name => name;
+ public Expression Name { get; set; } = name;
public AliasQualifiedName WithName(Expression newName)
{
- return ReferenceEquals(newName, name) ? this : new AliasQualifiedName(id, prefix, markers, _alias, newName);
+ return ReferenceEquals(newName, Name) ? this : new AliasQualifiedName(Id, Prefix, Markers, _alias, newName);
}
public sealed record PaddingHelper(Cs.AliasQualifiedName T)
{
- public JRightPadded Alias => T._alias;
+ public JRightPadded Alias { get => T._alias; set => T._alias = value; }
public Cs.AliasQualifiedName WithAlias(JRightPadded newAlias)
{
- return T._alias == newAlias ? T : new Cs.AliasQualifiedName(T.Id, T.Prefix, T.Markers, newAlias, T.Name);
+ return Alias == newAlias ? T : new Cs.AliasQualifiedName(T.Id, T.Prefix, T.Markers, newAlias, T.Name);
}
}
diff --git a/Rewrite/src/Rewrite.CSharp/Tree/AllowsConstraintClause.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/AllowsConstraintClause.g.cs
index 1e9f6ed1..cc5a6696 100644
--- a/Rewrite/src/Rewrite.CSharp/Tree/AllowsConstraintClause.g.cs
+++ b/Rewrite/src/Rewrite.CSharp/Tree/AllowsConstraintClause.g.cs
@@ -68,25 +68,25 @@ public PaddingHelper Padding
return v.VisitAllowsConstraintClause(this, p);
}
- public Guid Id => id;
+ public Guid Id { get; set; } = id;
public AllowsConstraintClause WithId(Guid newId)
{
- return newId == id ? this : new AllowsConstraintClause(newId, prefix, markers, _expressions);
+ return newId == Id ? this : new AllowsConstraintClause(newId, Prefix, Markers, _expressions);
}
- public Space Prefix => prefix;
+ public Space Prefix { get; set; } = prefix;
public AllowsConstraintClause WithPrefix(Space newPrefix)
{
- return newPrefix == prefix ? this : new AllowsConstraintClause(id, newPrefix, markers, _expressions);
+ return newPrefix == Prefix ? this : new AllowsConstraintClause(Id, newPrefix, Markers, _expressions);
}
- public Markers Markers => markers;
+ public Markers Markers { get; set; } = markers;
public AllowsConstraintClause WithMarkers(Markers newMarkers)
{
- return ReferenceEquals(newMarkers, markers) ? this : new AllowsConstraintClause(id, prefix, newMarkers, _expressions);
+ return ReferenceEquals(newMarkers, Markers) ? this : new AllowsConstraintClause(Id, Prefix, newMarkers, _expressions);
}
- private readonly JContainer _expressions = expressions;
+ private JContainer _expressions = expressions;
public IList Expressions => _expressions.GetElements();
public AllowsConstraintClause WithExpressions(IList newExpressions)
@@ -95,11 +95,11 @@ public AllowsConstraintClause WithExpressions(IList newExpr
}
public sealed record PaddingHelper(Cs.AllowsConstraintClause T)
{
- public JContainer Expressions => T._expressions;
+ public JContainer Expressions { get => T._expressions; set => T._expressions = value; }
public Cs.AllowsConstraintClause WithExpressions(JContainer newExpressions)
{
- return T._expressions == newExpressions ? T : new Cs.AllowsConstraintClause(T.Id, T.Prefix, T.Markers, newExpressions);
+ return Expressions == newExpressions ? T : new Cs.AllowsConstraintClause(T.Id, T.Prefix, T.Markers, newExpressions);
}
}
diff --git a/Rewrite/src/Rewrite.CSharp/Tree/AnnotatedStatement.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/AnnotatedStatement.g.cs
index 8ee3f0ce..4831ae15 100644
--- a/Rewrite/src/Rewrite.CSharp/Tree/AnnotatedStatement.g.cs
+++ b/Rewrite/src/Rewrite.CSharp/Tree/AnnotatedStatement.g.cs
@@ -40,35 +40,35 @@ Statement statement
return v.VisitAnnotatedStatement(this, p);
}
- public Guid Id => id;
+ public Guid Id { get; set; } = id;
public AnnotatedStatement WithId(Guid newId)
{
- return newId == id ? this : new AnnotatedStatement(newId, prefix, markers, attributeLists, statement);
+ return newId == Id ? this : new AnnotatedStatement(newId, Prefix, Markers, AttributeLists, Statement);
}
- public Space Prefix => prefix;
+ public Space Prefix { get; set; } = prefix;
public AnnotatedStatement WithPrefix(Space newPrefix)
{
- return newPrefix == prefix ? this : new AnnotatedStatement(id, newPrefix, markers, attributeLists, statement);
+ return newPrefix == Prefix ? this : new AnnotatedStatement(Id, newPrefix, Markers, AttributeLists, Statement);
}
- public Markers Markers => markers;
+ public Markers Markers { get; set; } = markers;
public AnnotatedStatement WithMarkers(Markers newMarkers)
{
- return ReferenceEquals(newMarkers, markers) ? this : new AnnotatedStatement(id, prefix, newMarkers, attributeLists, statement);
+ return ReferenceEquals(newMarkers, Markers) ? this : new AnnotatedStatement(Id, Prefix, newMarkers, AttributeLists, Statement);
}
- public IList AttributeLists => attributeLists;
+ public IList AttributeLists { get; set; } = attributeLists;
public AnnotatedStatement WithAttributeLists(IList newAttributeLists)
{
- return newAttributeLists == attributeLists ? this : new AnnotatedStatement(id, prefix, markers, newAttributeLists, statement);
+ return newAttributeLists == AttributeLists ? this : new AnnotatedStatement(Id, Prefix, Markers, newAttributeLists, Statement);
}
- public Statement Statement => statement;
+ public Statement Statement { get; set; } = statement;
public AnnotatedStatement WithStatement(Statement newStatement)
{
- return ReferenceEquals(newStatement, statement) ? this : new AnnotatedStatement(id, prefix, markers, attributeLists, newStatement);
+ return ReferenceEquals(newStatement, Statement) ? this : new AnnotatedStatement(Id, Prefix, Markers, AttributeLists, newStatement);
}
#if DEBUG_VISITOR
[DebuggerStepThrough]
diff --git a/Rewrite/src/Rewrite.CSharp/Tree/Argument.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/Argument.g.cs
index 3388794d..bd04ee68 100644
--- a/Rewrite/src/Rewrite.CSharp/Tree/Argument.g.cs
+++ b/Rewrite/src/Rewrite.CSharp/Tree/Argument.g.cs
@@ -66,50 +66,50 @@ public PaddingHelper Padding
return v.VisitArgument(this, p);
}
- public Guid Id => id;
+ public Guid Id { get; set; } = id;
public Argument WithId(Guid newId)
{
- return newId == id ? this : new Argument(newId, prefix, markers, _nameColumn, refKindKeyword, expression);
+ return newId == Id ? this : new Argument(newId, Prefix, Markers, _nameColumn, RefKindKeyword, Expression);
}
- public Space Prefix => prefix;
+ public Space Prefix { get; set; } = prefix;
public Argument WithPrefix(Space newPrefix)
{
- return newPrefix == prefix ? this : new Argument(id, newPrefix, markers, _nameColumn, refKindKeyword, expression);
+ return newPrefix == Prefix ? this : new Argument(Id, newPrefix, Markers, _nameColumn, RefKindKeyword, Expression);
}
- public Markers Markers => markers;
+ public Markers Markers { get; set; } = markers;
public Argument WithMarkers(Markers newMarkers)
{
- return ReferenceEquals(newMarkers, markers) ? this : new Argument(id, prefix, newMarkers, _nameColumn, refKindKeyword, expression);
+ return ReferenceEquals(newMarkers, Markers) ? this : new Argument(Id, Prefix, newMarkers, _nameColumn, RefKindKeyword, Expression);
}
- private readonly JRightPadded? _nameColumn = nameColumn;
+ private JRightPadded? _nameColumn = nameColumn;
public J.Identifier? NameColumn => _nameColumn?.Element;
public Argument WithNameColumn(J.Identifier? newNameColumn)
{
return Padding.WithNameColumn(JRightPadded.WithElement(_nameColumn, newNameColumn));
}
- public Cs.Keyword? RefKindKeyword => refKindKeyword;
+ public Cs.Keyword? RefKindKeyword { get; set; } = refKindKeyword;
public Argument WithRefKindKeyword(Cs.Keyword? newRefKindKeyword)
{
- return ReferenceEquals(newRefKindKeyword, refKindKeyword) ? this : new Argument(id, prefix, markers, _nameColumn, newRefKindKeyword, expression);
+ return ReferenceEquals(newRefKindKeyword, RefKindKeyword) ? this : new Argument(Id, Prefix, Markers, _nameColumn, newRefKindKeyword, Expression);
}
- public Expression Expression => expression;
+ public Expression Expression { get; set; } = expression;
public Argument WithExpression(Expression newExpression)
{
- return ReferenceEquals(newExpression, expression) ? this : new Argument(id, prefix, markers, _nameColumn, refKindKeyword, newExpression);
+ return ReferenceEquals(newExpression, Expression) ? this : new Argument(Id, Prefix, Markers, _nameColumn, RefKindKeyword, newExpression);
}
public sealed record PaddingHelper(Cs.Argument T)
{
- public JRightPadded? NameColumn => T._nameColumn;
+ public JRightPadded? NameColumn { get => T._nameColumn; set => T._nameColumn = value; }
public Cs.Argument WithNameColumn(JRightPadded? newNameColumn)
{
- return T._nameColumn == newNameColumn ? T : new Cs.Argument(T.Id, T.Prefix, T.Markers, newNameColumn, T.RefKindKeyword, T.Expression);
+ return NameColumn == newNameColumn ? T : new Cs.Argument(T.Id, T.Prefix, T.Markers, newNameColumn, T.RefKindKeyword, T.Expression);
}
}
diff --git a/Rewrite/src/Rewrite.CSharp/Tree/ArrayRankSpecifier.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/ArrayRankSpecifier.g.cs
index 32ff93a0..2fe1108a 100644
--- a/Rewrite/src/Rewrite.CSharp/Tree/ArrayRankSpecifier.g.cs
+++ b/Rewrite/src/Rewrite.CSharp/Tree/ArrayRankSpecifier.g.cs
@@ -64,25 +64,25 @@ public PaddingHelper Padding
return v.VisitArrayRankSpecifier(this, p);
}
- public Guid Id => id;
+ public Guid Id { get; set; } = id;
public ArrayRankSpecifier WithId(Guid newId)
{
- return newId == id ? this : new ArrayRankSpecifier(newId, prefix, markers, _sizes);
+ return newId == Id ? this : new ArrayRankSpecifier(newId, Prefix, Markers, _sizes);
}
- public Space Prefix => prefix;
+ public Space Prefix { get; set; } = prefix;
public ArrayRankSpecifier WithPrefix(Space newPrefix)
{
- return newPrefix == prefix ? this : new ArrayRankSpecifier(id, newPrefix, markers, _sizes);
+ return newPrefix == Prefix ? this : new ArrayRankSpecifier(Id, newPrefix, Markers, _sizes);
}
- public Markers Markers => markers;
+ public Markers Markers { get; set; } = markers;
public ArrayRankSpecifier WithMarkers(Markers newMarkers)
{
- return ReferenceEquals(newMarkers, markers) ? this : new ArrayRankSpecifier(id, prefix, newMarkers, _sizes);
+ return ReferenceEquals(newMarkers, Markers) ? this : new ArrayRankSpecifier(Id, Prefix, newMarkers, _sizes);
}
- private readonly JContainer _sizes = sizes;
+ private JContainer _sizes = sizes;
public IList Sizes => _sizes.GetElements();
public ArrayRankSpecifier WithSizes(IList newSizes)
@@ -91,11 +91,11 @@ public ArrayRankSpecifier WithSizes(IList newSizes)
}
public sealed record PaddingHelper(Cs.ArrayRankSpecifier T)
{
- public JContainer Sizes => T._sizes;
+ public JContainer Sizes { get => T._sizes; set => T._sizes = value; }
public Cs.ArrayRankSpecifier WithSizes(JContainer newSizes)
{
- return T._sizes == newSizes ? T : new Cs.ArrayRankSpecifier(T.Id, T.Prefix, T.Markers, newSizes);
+ return Sizes == newSizes ? T : new Cs.ArrayRankSpecifier(T.Id, T.Prefix, T.Markers, newSizes);
}
}
diff --git a/Rewrite/src/Rewrite.CSharp/Tree/ArrayType.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/ArrayType.g.cs
index d519a26d..30487328 100644
--- a/Rewrite/src/Rewrite.CSharp/Tree/ArrayType.g.cs
+++ b/Rewrite/src/Rewrite.CSharp/Tree/ArrayType.g.cs
@@ -41,41 +41,41 @@ public partial class ArrayType(
return v.VisitArrayType(this, p);
}
- public Guid Id => id;
+ public Guid Id { get; set; } = id;
public ArrayType WithId(Guid newId)
{
- return newId == id ? this : new ArrayType(newId, prefix, markers, typeExpression, dimensions, type);
+ return newId == Id ? this : new ArrayType(newId, Prefix, Markers, TypeExpression, Dimensions, Type);
}
- public Space Prefix => prefix;
+ public Space Prefix { get; set; } = prefix;
public ArrayType WithPrefix(Space newPrefix)
{
- return newPrefix == prefix ? this : new ArrayType(id, newPrefix, markers, typeExpression, dimensions, type);
+ return newPrefix == Prefix ? this : new ArrayType(Id, newPrefix, Markers, TypeExpression, Dimensions, Type);
}
- public Markers Markers => markers;
+ public Markers Markers { get; set; } = markers;
public ArrayType WithMarkers(Markers newMarkers)
{
- return ReferenceEquals(newMarkers, markers) ? this : new ArrayType(id, prefix, newMarkers, typeExpression, dimensions, type);
+ return ReferenceEquals(newMarkers, Markers) ? this : new ArrayType(Id, Prefix, newMarkers, TypeExpression, Dimensions, Type);
}
- public TypeTree? TypeExpression => typeExpression;
+ public TypeTree? TypeExpression { get; set; } = typeExpression;
public ArrayType WithTypeExpression(TypeTree? newTypeExpression)
{
- return ReferenceEquals(newTypeExpression, typeExpression) ? this : new ArrayType(id, prefix, markers, newTypeExpression, dimensions, type);
+ return ReferenceEquals(newTypeExpression, TypeExpression) ? this : new ArrayType(Id, Prefix, Markers, newTypeExpression, Dimensions, Type);
}
- public IList Dimensions => dimensions;
+ public IList Dimensions { get; set; } = dimensions;
public ArrayType WithDimensions(IList newDimensions)
{
- return newDimensions == dimensions ? this : new ArrayType(id, prefix, markers, typeExpression, newDimensions, type);
+ return newDimensions == Dimensions ? this : new ArrayType(Id, Prefix, Markers, TypeExpression, newDimensions, Type);
}
- public JavaType? Type => type;
+ public JavaType? Type { get; set; } = type;
public ArrayType WithType(JavaType? newType)
{
- return newType == type ? this : new ArrayType(id, prefix, markers, typeExpression, dimensions, newType);
+ return newType == Type ? this : new ArrayType(Id, Prefix, Markers, TypeExpression, Dimensions, newType);
}
#if DEBUG_VISITOR
[DebuggerStepThrough]
diff --git a/Rewrite/src/Rewrite.CSharp/Tree/ArrowExpressionClause.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/ArrowExpressionClause.g.cs
index 02f2218b..60cba954 100644
--- a/Rewrite/src/Rewrite.CSharp/Tree/ArrowExpressionClause.g.cs
+++ b/Rewrite/src/Rewrite.CSharp/Tree/ArrowExpressionClause.g.cs
@@ -81,25 +81,25 @@ public PaddingHelper Padding
return v.VisitArrowExpressionClause(this, p);
}
- public Guid Id => id;
+ public Guid Id { get; set; } = id;
public ArrowExpressionClause WithId(Guid newId)
{
- return newId == id ? this : new ArrowExpressionClause(newId, prefix, markers, _expression);
+ return newId == Id ? this : new ArrowExpressionClause(newId, Prefix, Markers, _expression);
}
- public Space Prefix => prefix;
+ public Space Prefix { get; set; } = prefix;
public ArrowExpressionClause WithPrefix(Space newPrefix)
{
- return newPrefix == prefix ? this : new ArrowExpressionClause(id, newPrefix, markers, _expression);
+ return newPrefix == Prefix ? this : new ArrowExpressionClause(Id, newPrefix, Markers, _expression);
}
- public Markers Markers => markers;
+ public Markers Markers { get; set; } = markers;
public ArrowExpressionClause WithMarkers(Markers newMarkers)
{
- return ReferenceEquals(newMarkers, markers) ? this : new ArrowExpressionClause(id, prefix, newMarkers, _expression);
+ return ReferenceEquals(newMarkers, Markers) ? this : new ArrowExpressionClause(Id, Prefix, newMarkers, _expression);
}
- private readonly JRightPadded _expression = expression;
+ private JRightPadded _expression = expression;
public Expression Expression => _expression.Element;
public ArrowExpressionClause WithExpression(Expression newExpression)
@@ -108,11 +108,11 @@ public ArrowExpressionClause WithExpression(Expression newExpression)
}
public sealed record PaddingHelper(Cs.ArrowExpressionClause T)
{
- public JRightPadded Expression => T._expression;
+ public JRightPadded Expression { get => T._expression; set => T._expression = value; }
public Cs.ArrowExpressionClause WithExpression(JRightPadded newExpression)
{
- return T._expression == newExpression ? T : new Cs.ArrowExpressionClause(T.Id, T.Prefix, T.Markers, newExpression);
+ return Expression == newExpression ? T : new Cs.ArrowExpressionClause(T.Id, T.Prefix, T.Markers, newExpression);
}
}
diff --git a/Rewrite/src/Rewrite.CSharp/Tree/AssignmentOperation.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/AssignmentOperation.g.cs
index 9797bfa7..8b98904b 100644
--- a/Rewrite/src/Rewrite.CSharp/Tree/AssignmentOperation.g.cs
+++ b/Rewrite/src/Rewrite.CSharp/Tree/AssignmentOperation.g.cs
@@ -67,48 +67,48 @@ public PaddingHelper Padding
return v.VisitAssignmentOperation(this, p);
}
- public Guid Id => id;
+ public Guid Id { get; set; } = id;
public AssignmentOperation WithId(Guid newId)
{
- return newId == id ? this : new AssignmentOperation(newId, prefix, markers, variable, _operator, assignment, type);
+ return newId == Id ? this : new AssignmentOperation(newId, Prefix, Markers, Variable, _operator, Assignment, Type);
}
- public Space Prefix => prefix;
+ public Space Prefix { get; set; } = prefix;
public AssignmentOperation WithPrefix(Space newPrefix)
{
- return newPrefix == prefix ? this : new AssignmentOperation(id, newPrefix, markers, variable, _operator, assignment, type);
+ return newPrefix == Prefix ? this : new AssignmentOperation(Id, newPrefix, Markers, Variable, _operator, Assignment, Type);
}
- public Markers Markers => markers;
+ public Markers Markers { get; set; } = markers;
public AssignmentOperation WithMarkers(Markers newMarkers)
{
- return ReferenceEquals(newMarkers, markers) ? this : new AssignmentOperation(id, prefix, newMarkers, variable, _operator, assignment, type);
+ return ReferenceEquals(newMarkers, Markers) ? this : new AssignmentOperation(Id, Prefix, newMarkers, Variable, _operator, Assignment, Type);
}
- public Expression Variable => variable;
+ public Expression Variable { get; set; } = variable;
public AssignmentOperation WithVariable(Expression newVariable)
{
- return ReferenceEquals(newVariable, variable) ? this : new AssignmentOperation(id, prefix, markers, newVariable, _operator, assignment, type);
+ return ReferenceEquals(newVariable, Variable) ? this : new AssignmentOperation(Id, Prefix, Markers, newVariable, _operator, Assignment, Type);
}
- private readonly JLeftPadded _operator = @operator;
+ private JLeftPadded _operator = @operator;
public OperatorType Operator => _operator.Element;
public AssignmentOperation WithOperator(OperatorType newOperator)
{
return Padding.WithOperator(_operator.WithElement(newOperator));
}
- public Expression Assignment => assignment;
+ public Expression Assignment { get; set; } = assignment;
public AssignmentOperation WithAssignment(Expression newAssignment)
{
- return ReferenceEquals(newAssignment, assignment) ? this : new AssignmentOperation(id, prefix, markers, variable, _operator, newAssignment, type);
+ return ReferenceEquals(newAssignment, Assignment) ? this : new AssignmentOperation(Id, Prefix, Markers, Variable, _operator, newAssignment, Type);
}
- public JavaType? Type => type;
+ public JavaType? Type { get; set; } = type;
public AssignmentOperation WithType(JavaType? newType)
{
- return newType == type ? this : new AssignmentOperation(id, prefix, markers, variable, _operator, assignment, newType);
+ return newType == Type ? this : new AssignmentOperation(Id, Prefix, Markers, Variable, _operator, Assignment, newType);
}
public enum OperatorType
{
@@ -116,11 +116,11 @@ public enum OperatorType
}
public sealed record PaddingHelper(Cs.AssignmentOperation T)
{
- public JLeftPadded Operator => T._operator;
+ public JLeftPadded Operator { get => T._operator; set => T._operator = value; }
public Cs.AssignmentOperation WithOperator(JLeftPadded newOperator)
{
- return T._operator == newOperator ? T : new Cs.AssignmentOperation(T.Id, T.Prefix, T.Markers, T.Variable, newOperator, T.Assignment, T.Type);
+ return Operator == newOperator ? T : new Cs.AssignmentOperation(T.Id, T.Prefix, T.Markers, T.Variable, newOperator, T.Assignment, T.Type);
}
}
diff --git a/Rewrite/src/Rewrite.CSharp/Tree/AttributeList.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/AttributeList.g.cs
index 2d6bfedb..9216fc2e 100644
--- a/Rewrite/src/Rewrite.CSharp/Tree/AttributeList.g.cs
+++ b/Rewrite/src/Rewrite.CSharp/Tree/AttributeList.g.cs
@@ -65,32 +65,32 @@ public PaddingHelper Padding
return v.VisitAttributeList(this, p);
}
- public Guid Id => id;
+ public Guid Id { get; set; } = id;
public AttributeList WithId(Guid newId)
{
- return newId == id ? this : new AttributeList(newId, prefix, markers, _target, _attributes);
+ return newId == Id ? this : new AttributeList(newId, Prefix, Markers, _target, _attributes);
}
- public Space Prefix => prefix;
+ public Space Prefix { get; set; } = prefix;
public AttributeList WithPrefix(Space newPrefix)
{
- return newPrefix == prefix ? this : new AttributeList(id, newPrefix, markers, _target, _attributes);
+ return newPrefix == Prefix ? this : new AttributeList(Id, newPrefix, Markers, _target, _attributes);
}
- public Markers Markers => markers;
+ public Markers Markers { get; set; } = markers;
public AttributeList WithMarkers(Markers newMarkers)
{
- return ReferenceEquals(newMarkers, markers) ? this : new AttributeList(id, prefix, newMarkers, _target, _attributes);
+ return ReferenceEquals(newMarkers, Markers) ? this : new AttributeList(Id, Prefix, newMarkers, _target, _attributes);
}
- private readonly JRightPadded? _target = target;
+ private JRightPadded? _target = target;
public J.Identifier? Target => _target?.Element;
public AttributeList WithTarget(J.Identifier? newTarget)
{
return Padding.WithTarget(JRightPadded.WithElement(_target, newTarget));
}
- private readonly IList> _attributes = attributes;
+ private IList> _attributes = attributes;
public IList Attributes => _attributes.Elements();
public AttributeList WithAttributes(IList newAttributes)
@@ -99,18 +99,18 @@ public AttributeList WithAttributes(IList newAttributes)
}
public sealed record PaddingHelper(Cs.AttributeList T)
{
- public JRightPadded? Target => T._target;
+ public JRightPadded? Target { get => T._target; set => T._target = value; }
public Cs.AttributeList WithTarget(JRightPadded? newTarget)
{
- return T._target == newTarget ? T : new Cs.AttributeList(T.Id, T.Prefix, T.Markers, newTarget, T._attributes);
+ return Target == newTarget ? T : new Cs.AttributeList(T.Id, T.Prefix, T.Markers, newTarget, T._attributes);
}
- public IList> Attributes => T._attributes;
+ public IList> Attributes { get => T._attributes; set => T._attributes = value; }
public Cs.AttributeList WithAttributes(IList> newAttributes)
{
- return T._attributes == newAttributes ? T : new Cs.AttributeList(T.Id, T.Prefix, T.Markers, T._target, newAttributes);
+ return Attributes == newAttributes ? T : new Cs.AttributeList(T.Id, T.Prefix, T.Markers, T._target, newAttributes);
}
}
diff --git a/Rewrite/src/Rewrite.CSharp/Tree/AwaitExpression.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/AwaitExpression.g.cs
index b806dbcf..2f49ff4a 100644
--- a/Rewrite/src/Rewrite.CSharp/Tree/AwaitExpression.g.cs
+++ b/Rewrite/src/Rewrite.CSharp/Tree/AwaitExpression.g.cs
@@ -40,35 +40,35 @@ public partial class AwaitExpression(
return v.VisitAwaitExpression(this, p);
}
- public Guid Id => id;
+ public Guid Id { get; set; } = id;
public AwaitExpression WithId(Guid newId)
{
- return newId == id ? this : new AwaitExpression(newId, prefix, markers, expression, type);
+ return newId == Id ? this : new AwaitExpression(newId, Prefix, Markers, Expression, Type);
}
- public Space Prefix => prefix;
+ public Space Prefix { get; set; } = prefix;
public AwaitExpression WithPrefix(Space newPrefix)
{
- return newPrefix == prefix ? this : new AwaitExpression(id, newPrefix, markers, expression, type);
+ return newPrefix == Prefix ? this : new AwaitExpression(Id, newPrefix, Markers, Expression, Type);
}
- public Markers Markers => markers;
+ public Markers Markers { get; set; } = markers;
public AwaitExpression WithMarkers(Markers newMarkers)
{
- return ReferenceEquals(newMarkers, markers) ? this : new AwaitExpression(id, prefix, newMarkers, expression, type);
+ return ReferenceEquals(newMarkers, Markers) ? this : new AwaitExpression(Id, Prefix, newMarkers, Expression, Type);
}
- public J Expression => expression;
+ public J Expression { get; set; } = expression;
public AwaitExpression WithExpression(J newExpression)
{
- return ReferenceEquals(newExpression, expression) ? this : new AwaitExpression(id, prefix, markers, newExpression, type);
+ return ReferenceEquals(newExpression, Expression) ? this : new AwaitExpression(Id, Prefix, Markers, newExpression, Type);
}
- public JavaType? Type => type;
+ public JavaType? Type { get; set; } = type;
public AwaitExpression WithType(JavaType? newType)
{
- return newType == type ? this : new AwaitExpression(id, prefix, markers, expression, newType);
+ return newType == Type ? this : new AwaitExpression(Id, Prefix, Markers, Expression, newType);
}
#if DEBUG_VISITOR
[DebuggerStepThrough]
diff --git a/Rewrite/src/Rewrite.CSharp/Tree/Binary.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/Binary.g.cs
index b10f3465..84e60ca1 100644
--- a/Rewrite/src/Rewrite.CSharp/Tree/Binary.g.cs
+++ b/Rewrite/src/Rewrite.CSharp/Tree/Binary.g.cs
@@ -67,48 +67,48 @@ public PaddingHelper Padding
return v.VisitBinary(this, p);
}
- public Guid Id => id;
+ public Guid Id { get; set; } = id;
public Binary WithId(Guid newId)
{
- return newId == id ? this : new Binary(newId, prefix, markers, left, _operator, right, type);
+ return newId == Id ? this : new Binary(newId, Prefix, Markers, Left, _operator, Right, Type);
}
- public Space Prefix => prefix;
+ public Space Prefix { get; set; } = prefix;
public Binary WithPrefix(Space newPrefix)
{
- return newPrefix == prefix ? this : new Binary(id, newPrefix, markers, left, _operator, right, type);
+ return newPrefix == Prefix ? this : new Binary(Id, newPrefix, Markers, Left, _operator, Right, Type);
}
- public Markers Markers => markers;
+ public Markers Markers { get; set; } = markers;
public Binary WithMarkers(Markers newMarkers)
{
- return ReferenceEquals(newMarkers, markers) ? this : new Binary(id, prefix, newMarkers, left, _operator, right, type);
+ return ReferenceEquals(newMarkers, Markers) ? this : new Binary(Id, Prefix, newMarkers, Left, _operator, Right, Type);
}
- public Expression Left => left;
+ public Expression Left { get; set; } = left;
public Binary WithLeft(Expression newLeft)
{
- return ReferenceEquals(newLeft, left) ? this : new Binary(id, prefix, markers, newLeft, _operator, right, type);
+ return ReferenceEquals(newLeft, Left) ? this : new Binary(Id, Prefix, Markers, newLeft, _operator, Right, Type);
}
- private readonly JLeftPadded _operator = @operator;
+ private JLeftPadded _operator = @operator;
public OperatorType Operator => _operator.Element;
public Binary WithOperator(OperatorType newOperator)
{
return Padding.WithOperator(_operator.WithElement(newOperator));
}
- public Expression Right => right;
+ public Expression Right { get; set; } = right;
public Binary WithRight(Expression newRight)
{
- return ReferenceEquals(newRight, right) ? this : new Binary(id, prefix, markers, left, _operator, newRight, type);
+ return ReferenceEquals(newRight, Right) ? this : new Binary(Id, Prefix, Markers, Left, _operator, newRight, Type);
}
- public JavaType? Type => type;
+ public JavaType? Type { get; set; } = type;
public Binary WithType(JavaType? newType)
{
- return newType == type ? this : new Binary(id, prefix, markers, left, _operator, right, newType);
+ return newType == Type ? this : new Binary(Id, Prefix, Markers, Left, _operator, Right, newType);
}
public enum OperatorType
{
@@ -117,11 +117,11 @@ public enum OperatorType
}
public sealed record PaddingHelper(Cs.Binary T)
{
- public JLeftPadded Operator => T._operator;
+ public JLeftPadded Operator { get => T._operator; set => T._operator = value; }
public Cs.Binary WithOperator(JLeftPadded newOperator)
{
- return T._operator == newOperator ? T : new Cs.Binary(T.Id, T.Prefix, T.Markers, T.Left, newOperator, T.Right, T.Type);
+ return Operator == newOperator ? T : new Cs.Binary(T.Id, T.Prefix, T.Markers, T.Left, newOperator, T.Right, T.Type);
}
}
diff --git a/Rewrite/src/Rewrite.CSharp/Tree/BinaryPattern.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/BinaryPattern.g.cs
index 2e81faa7..b7103a13 100644
--- a/Rewrite/src/Rewrite.CSharp/Tree/BinaryPattern.g.cs
+++ b/Rewrite/src/Rewrite.CSharp/Tree/BinaryPattern.g.cs
@@ -90,42 +90,42 @@ public PaddingHelper Padding
return v.VisitBinaryPattern(this, p);
}
- public Guid Id => id;
+ public Guid Id { get; set; } = id;
public BinaryPattern WithId(Guid newId)
{
- return newId == id ? this : new BinaryPattern(newId, prefix, markers, left, _operator, right);
+ return newId == Id ? this : new BinaryPattern(newId, Prefix, Markers, Left, _operator, Right);
}
- public Space Prefix => prefix;
+ public Space Prefix { get; set; } = prefix;
public BinaryPattern WithPrefix(Space newPrefix)
{
- return newPrefix == prefix ? this : new BinaryPattern(id, newPrefix, markers, left, _operator, right);
+ return newPrefix == Prefix ? this : new BinaryPattern(Id, newPrefix, Markers, Left, _operator, Right);
}
- public Markers Markers => markers;
+ public Markers Markers { get; set; } = markers;
public BinaryPattern WithMarkers(Markers newMarkers)
{
- return ReferenceEquals(newMarkers, markers) ? this : new BinaryPattern(id, prefix, newMarkers, left, _operator, right);
+ return ReferenceEquals(newMarkers, Markers) ? this : new BinaryPattern(Id, Prefix, newMarkers, Left, _operator, Right);
}
- public Cs.Pattern Left => left;
+ public Cs.Pattern Left { get; set; } = left;
public BinaryPattern WithLeft(Cs.Pattern newLeft)
{
- return ReferenceEquals(newLeft, left) ? this : new BinaryPattern(id, prefix, markers, newLeft, _operator, right);
+ return ReferenceEquals(newLeft, Left) ? this : new BinaryPattern(Id, Prefix, Markers, newLeft, _operator, Right);
}
- private readonly JLeftPadded _operator = @operator;
+ private JLeftPadded _operator = @operator;
public OperatorType Operator => _operator.Element;
public BinaryPattern WithOperator(OperatorType newOperator)
{
return Padding.WithOperator(_operator.WithElement(newOperator));
}
- public Cs.Pattern Right => right;
+ public Cs.Pattern Right { get; set; } = right;
public BinaryPattern WithRight(Cs.Pattern newRight)
{
- return ReferenceEquals(newRight, right) ? this : new BinaryPattern(id, prefix, markers, left, _operator, newRight);
+ return ReferenceEquals(newRight, Right) ? this : new BinaryPattern(Id, Prefix, Markers, Left, _operator, newRight);
}
public enum OperatorType
{
@@ -134,11 +134,11 @@ public enum OperatorType
}
public sealed record PaddingHelper(Cs.BinaryPattern T)
{
- public JLeftPadded Operator => T._operator;
+ public JLeftPadded Operator { get => T._operator; set => T._operator = value; }
public Cs.BinaryPattern WithOperator(JLeftPadded newOperator)
{
- return T._operator == newOperator ? T : new Cs.BinaryPattern(T.Id, T.Prefix, T.Markers, T.Left, newOperator, T.Right);
+ return Operator == newOperator ? T : new Cs.BinaryPattern(T.Id, T.Prefix, T.Markers, T.Left, newOperator, T.Right);
}
}
diff --git a/Rewrite/src/Rewrite.CSharp/Tree/BlockScopeNamespaceDeclaration.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/BlockScopeNamespaceDeclaration.g.cs
index d9d7204f..631a9288 100644
--- a/Rewrite/src/Rewrite.CSharp/Tree/BlockScopeNamespaceDeclaration.g.cs
+++ b/Rewrite/src/Rewrite.CSharp/Tree/BlockScopeNamespaceDeclaration.g.cs
@@ -68,86 +68,86 @@ public PaddingHelper Padding
return v.VisitBlockScopeNamespaceDeclaration(this, p);
}
- public Guid Id => id;
+ public Guid Id { get; set; } = id;
public BlockScopeNamespaceDeclaration WithId(Guid newId)
{
- return newId == id ? this : new BlockScopeNamespaceDeclaration(newId, prefix, markers, _name, _externs, _usings, _members, end);
+ return newId == Id ? this : new BlockScopeNamespaceDeclaration(newId, Prefix, Markers, _name, _externs, _usings, _members, End);
}
- public Space Prefix => prefix;
+ public Space Prefix { get; set; } = prefix;
public BlockScopeNamespaceDeclaration WithPrefix(Space newPrefix)
{
- return newPrefix == prefix ? this : new BlockScopeNamespaceDeclaration(id, newPrefix, markers, _name, _externs, _usings, _members, end);
+ return newPrefix == Prefix ? this : new BlockScopeNamespaceDeclaration(Id, newPrefix, Markers, _name, _externs, _usings, _members, End);
}
- public Markers Markers => markers;
+ public Markers Markers { get; set; } = markers;
public BlockScopeNamespaceDeclaration WithMarkers(Markers newMarkers)
{
- return ReferenceEquals(newMarkers, markers) ? this : new BlockScopeNamespaceDeclaration(id, prefix, newMarkers, _name, _externs, _usings, _members, end);
+ return ReferenceEquals(newMarkers, Markers) ? this : new BlockScopeNamespaceDeclaration(Id, Prefix, newMarkers, _name, _externs, _usings, _members, End);
}
- private readonly JRightPadded _name = name;
+ private JRightPadded _name = name;
public Expression Name => _name.Element;
public BlockScopeNamespaceDeclaration WithName(Expression newName)
{
return Padding.WithName(_name.WithElement(newName));
}
- private readonly IList> _externs = externs;
+ private IList> _externs = externs;
public IList Externs => _externs.Elements();
public BlockScopeNamespaceDeclaration WithExterns(IList newExterns)
{
return Padding.WithExterns(_externs.WithElements(newExterns));
}
- private readonly IList> _usings = usings;
+ private IList> _usings = usings;
public IList