From ad833a27d13bfd54c1173896a39fa7ce4a50a2f9 Mon Sep 17 00:00:00 2001 From: Andrew Stakhov Date: Thu, 20 Mar 2025 11:45:29 -0400 Subject: [PATCH 01/11] Code Formatter --- Rewrite/Directory.Build.props | 1 + Rewrite/Rewrite.Sources.sln | 52 +- .../CovariantReturnGenerator.cs | 302 ++++++++ .../Properties/launchSettings.json | 6 +- .../SymbolEqualityComparer.cs | 12 + .../src/Rewrite.CSharp/CSharpIsoVisitor.cs | 724 +++++++++--------- Rewrite/src/Rewrite.CSharp/CSharpParser.cs | 1 + Rewrite/src/Rewrite.CSharp/CSharpPrinter.cs | 168 ++-- Rewrite/src/Rewrite.CSharp/Extensions.cs | 35 +- .../src/Rewrite.CSharp/Format/AutoFormat.cs | 10 + .../Format/AutoFormatVisitor.cs | 286 +++++++ .../Format/DictionaryExtensions.cs | 27 + .../src/Rewrite.CSharp/Format/FormatStyle.cs | 60 ++ .../Format/NormalizeFormatVisitor.cs | 217 ------ .../src/Rewrite.CSharp/Format/TextChange.cs | 105 +++ .../Rewrite.CSharp/Format/TriviaChunker.cs | 49 ++ .../Format/UniqueSpaceVisitor.cs | 57 ++ Rewrite/src/Rewrite.CSharp/Global.cs | 3 + .../src/Rewrite.CSharp/Rewrite.CSharp.csproj | 3 +- Rewrite/src/Rewrite.CSharp/Roslyn/Parser.cs | 21 + .../Tree/AccessorDeclaration.g.cs | 34 +- .../Tree/AliasQualifiedName.g.cs | 22 +- .../Tree/AllowsConstraintClause.g.cs | 18 +- .../Tree/AnnotatedStatement.g.cs | 20 +- Rewrite/src/Rewrite.CSharp/Tree/Argument.g.cs | 26 +- .../Tree/ArrayRankSpecifier.g.cs | 18 +- .../src/Rewrite.CSharp/Tree/ArrayType.g.cs | 24 +- .../Tree/ArrowExpressionClause.g.cs | 18 +- .../Tree/AssignmentOperation.g.cs | 30 +- .../Rewrite.CSharp/Tree/AttributeList.g.cs | 24 +- .../Rewrite.CSharp/Tree/AwaitExpression.g.cs | 20 +- Rewrite/src/Rewrite.CSharp/Tree/Binary.g.cs | 30 +- .../Rewrite.CSharp/Tree/BinaryPattern.g.cs | 26 +- .../Tree/BlockScopeNamespaceDeclaration.g.cs | 40 +- .../Rewrite.CSharp/Tree/CSharpSourceFile.cs | 7 + .../Tree/CasePatternSwitchLabel.g.cs | 26 +- .../Tree/CheckedExpression.g.cs | 20 +- .../Rewrite.CSharp/Tree/CheckedStatement.g.cs | 20 +- .../Rewrite.CSharp/Tree/ClassDeclaration.g.cs | 70 +- .../Tree/ClassOrStructConstraint.g.cs | 16 +- .../Tree/CollectionExpression.g.cs | 22 +- .../Rewrite.CSharp/Tree/CompilationUnit.cs | 9 + .../Rewrite.CSharp/Tree/CompilationUnit.g.cs | 58 +- .../Rewrite.CSharp/Tree/ConstantPattern.g.cs | 16 +- .../src/Rewrite.CSharp/Tree/Constructor.g.cs | 20 +- .../Tree/ConstructorConstraint.g.cs | 12 +- .../Tree/ConstructorInitializer.g.cs | 22 +- .../Tree/ConversionOperatorDeclaration.g.cs | 44 +- Rewrite/src/Rewrite.CSharp/Tree/Cs.cs | 7 + .../Tree/DeclarationExpression.g.cs | 20 +- .../Tree/DefaultConstraint.g.cs | 12 +- .../Tree/DefaultExpression.g.cs | 18 +- .../Tree/DefaultSwitchLabel.g.cs | 16 +- .../Tree/DelegateDeclaration.g.cs | 48 +- .../Tree/DestructorDeclaration.g.cs | 16 +- .../Rewrite.CSharp/Tree/DiscardPattern.g.cs | 16 +- .../Tree/DiscardVariableDesignation.g.cs | 16 +- .../Rewrite.CSharp/Tree/EnumDeclaration.g.cs | 38 +- .../Tree/EnumMemberDeclaration.g.cs | 26 +- .../Rewrite.CSharp/Tree/EventDeclaration.g.cs | 42 +- .../Tree/ExpressionStatement.g.cs | 18 +- .../src/Rewrite.CSharp/Tree/ExternAlias.g.cs | 18 +- .../Tree/FileScopeNamespaceDeclaration.g.cs | 36 +- .../Rewrite.CSharp/Tree/FixedStatement.g.cs | 20 +- .../Tree/ForEachVariableLoop.g.cs | 46 +- .../src/Rewrite.CSharp/Tree/FromClause.g.cs | 26 +- .../Rewrite.CSharp/Tree/GotoStatement.g.cs | 20 +- .../src/Rewrite.CSharp/Tree/GroupClause.g.cs | 22 +- .../Tree/ImplicitElementAccess.g.cs | 18 +- .../Tree/IndexerDeclaration.g.cs | 46 +- .../Tree/InitializerExpression.g.cs | 18 +- .../Tree/InterpolatedString.g.cs | 26 +- .../Rewrite.CSharp/Tree/Interpolation.g.cs | 30 +- .../src/Rewrite.CSharp/Tree/IsPattern.g.cs | 22 +- .../src/Rewrite.CSharp/Tree/JoinClause.g.cs | 40 +- .../Rewrite.CSharp/Tree/JoinIntoClause.g.cs | 16 +- Rewrite/src/Rewrite.CSharp/Tree/Keyword.g.cs | 16 +- Rewrite/src/Rewrite.CSharp/Tree/Lambda.g.cs | 24 +- .../src/Rewrite.CSharp/Tree/LetClause.g.cs | 22 +- .../src/Rewrite.CSharp/Tree/ListPattern.g.cs | 22 +- .../Rewrite.CSharp/Tree/LockStatement.g.cs | 22 +- .../Tree/MethodDeclaration.g.cs | 60 +- .../src/Rewrite.CSharp/Tree/NameColon.g.cs | 18 +- Rewrite/src/Rewrite.CSharp/Tree/NewClass.g.cs | 20 +- .../Tree/NullSafeExpression.g.cs | 18 +- .../Tree/OperatorDeclaration.g.cs | 58 +- .../Rewrite.CSharp/Tree/OrderByClause.g.cs | 18 +- Rewrite/src/Rewrite.CSharp/Tree/Ordering.g.cs | 22 +- .../Tree/ParenthesizedPattern.g.cs | 18 +- .../ParenthesizedVariableDesignation.g.cs | 22 +- .../Tree/PointerFieldAccess.g.cs | 26 +- .../src/Rewrite.CSharp/Tree/PointerType.g.cs | 18 +- .../Tree/PositionalPatternClause.g.cs | 18 +- .../Tree/PropertyDeclaration.g.cs | 48 +- .../Tree/PropertyPatternClause.g.cs | 18 +- .../src/Rewrite.CSharp/Tree/QueryBody.g.cs | 24 +- .../Tree/QueryContinuation.g.cs | 20 +- .../Rewrite.CSharp/Tree/QueryExpression.g.cs | 20 +- .../Rewrite.CSharp/Tree/RangeExpression.g.cs | 22 +- .../Rewrite.CSharp/Tree/RecursivePattern.g.cs | 28 +- .../Rewrite.CSharp/Tree/RefExpression.g.cs | 16 +- .../Tree/RefStructConstraint.g.cs | 12 +- Rewrite/src/Rewrite.CSharp/Tree/RefType.g.cs | 24 +- .../Tree/RelationalPattern.g.cs | 22 +- .../src/Rewrite.CSharp/Tree/SelectClause.g.cs | 16 +- .../Tree/SingleVariableDesignation.g.cs | 16 +- .../src/Rewrite.CSharp/Tree/SlicePattern.g.cs | 12 +- .../Tree/StackAllocExpression.g.cs | 16 +- .../Tree/StatementExpression.g.cs | 16 +- .../src/Rewrite.CSharp/Tree/Subpattern.g.cs | 22 +- .../Rewrite.CSharp/Tree/SwitchExpression.g.cs | 24 +- .../Tree/SwitchExpressionArm.g.cs | 28 +- .../Rewrite.CSharp/Tree/SwitchSection.g.cs | 22 +- .../Rewrite.CSharp/Tree/SwitchStatement.g.cs | 24 +- Rewrite/src/Rewrite.CSharp/Tree/Try.g.cs | 52 +- .../src/Rewrite.CSharp/Tree/TupleElement.g.cs | 20 +- .../Rewrite.CSharp/Tree/TupleExpression.g.cs | 18 +- .../src/Rewrite.CSharp/Tree/TupleType.g.cs | 22 +- .../Rewrite.CSharp/Tree/TypeConstraint.g.cs | 16 +- .../Rewrite.CSharp/Tree/TypeParameter.g.cs | 26 +- .../Tree/TypeParameterConstraintClause.g.cs | 24 +- .../src/Rewrite.CSharp/Tree/TypePattern.g.cs | 20 +- Rewrite/src/Rewrite.CSharp/Tree/Unary.g.cs | 26 +- .../src/Rewrite.CSharp/Tree/UnaryPattern.g.cs | 20 +- .../Rewrite.CSharp/Tree/UnsafeStatement.g.cs | 16 +- .../Rewrite.CSharp/Tree/UsingDirective.g.cs | 40 +- .../Rewrite.CSharp/Tree/UsingStatement.g.cs | 26 +- .../src/Rewrite.CSharp/Tree/VarPattern.g.cs | 16 +- .../src/Rewrite.CSharp/Tree/WhereClause.g.cs | 16 +- Rewrite/src/Rewrite.CSharp/Tree/Yield.g.cs | 20 +- .../src/Rewrite.CSharp/Tree/_Extensions.cs | 89 ++- Rewrite/src/Rewrite.Core/Cursor.cs | 6 +- Rewrite/src/Rewrite.Core/ListUtils.cs | 131 ++++ Rewrite/src/Rewrite.Core/MutableSourceFile.cs | 16 +- Rewrite/src/Rewrite.Core/Rewrite.Core.csproj | 4 + Rewrite/src/Rewrite.Java/Globals.cs | 2 + Rewrite/src/Rewrite.Java/JavaPrinter.cs | 9 +- .../src/Rewrite.Java/Marker/ImplicitReturn.cs | 9 + Rewrite/src/Rewrite.Java/Rewrite.Java.csproj | 4 +- .../src/Rewrite.Java/Tree/AnnotatedType.cs | 2 +- .../src/Rewrite.Java/Tree/AnnotatedType.g.cs | 20 +- Rewrite/src/Rewrite.Java/Tree/Annotation.g.cs | 22 +- .../src/Rewrite.Java/Tree/ArrayAccess.g.cs | 24 +- .../src/Rewrite.Java/Tree/ArrayDimension.g.cs | 18 +- Rewrite/src/Rewrite.Java/Tree/ArrayType.g.cs | 28 +- Rewrite/src/Rewrite.Java/Tree/Assert.g.cs | 20 +- Rewrite/src/Rewrite.Java/Tree/Assignment.g.cs | 26 +- .../Tree/AssignmentOperation.g.cs | 30 +- Rewrite/src/Rewrite.Java/Tree/Binary.g.cs | 30 +- Rewrite/src/Rewrite.Java/Tree/Block.g.cs | 28 +- Rewrite/src/Rewrite.Java/Tree/Break.g.cs | 16 +- Rewrite/src/Rewrite.Java/Tree/Case.g.cs | 38 +- .../Rewrite.Java/Tree/ClassDeclaration.g.cs | 90 +-- Rewrite/src/Rewrite.Java/Tree/Comment.cs | 4 +- .../Rewrite.Java/Tree/CompilationUnit.g.cs | 52 +- Rewrite/src/Rewrite.Java/Tree/Continue.g.cs | 16 +- .../Rewrite.Java/Tree/ControlParentheses.g.cs | 18 +- .../Tree/DeconstructionPattern.g.cs | 26 +- .../src/Rewrite.Java/Tree/DoWhileLoop.g.cs | 24 +- Rewrite/src/Rewrite.Java/Tree/Empty.g.cs | 12 +- Rewrite/src/Rewrite.Java/Tree/EnumValue.g.cs | 24 +- .../src/Rewrite.Java/Tree/EnumValueSet.g.cs | 22 +- Rewrite/src/Rewrite.Java/Tree/Erroneous.g.cs | 16 +- Rewrite/src/Rewrite.Java/Tree/Expression.cs | 24 +- .../src/Rewrite.Java/Tree/FieldAccess.g.cs | 26 +- .../src/Rewrite.Java/Tree/ForEachLoop.g.cs | 46 +- Rewrite/src/Rewrite.Java/Tree/ForLoop.g.cs | 52 +- Rewrite/src/Rewrite.Java/Tree/Identifier.g.cs | 28 +- Rewrite/src/Rewrite.Java/Tree/If.g.cs | 44 +- Rewrite/src/Rewrite.Java/Tree/Import.g.cs | 28 +- Rewrite/src/Rewrite.Java/Tree/InstanceOf.g.cs | 30 +- .../Rewrite.Java/Tree/IntersectionType.g.cs | 18 +- Rewrite/src/Rewrite.Java/Tree/J.cs | 21 +- .../src/Rewrite.Java/Tree/JavaSourceFile.cs | 10 +- Rewrite/src/Rewrite.Java/Tree/Label.g.cs | 22 +- Rewrite/src/Rewrite.Java/Tree/Lambda.g.cs | 50 +- Rewrite/src/Rewrite.Java/Tree/Literal.g.cs | 36 +- .../src/Rewrite.Java/Tree/MemberReference.cs | 2 +- .../Rewrite.Java/Tree/MemberReference.g.cs | 42 +- .../Rewrite.Java/Tree/MethodDeclaration.cs | 14 +- .../Rewrite.Java/Tree/MethodDeclaration.g.cs | 90 +-- .../Rewrite.Java/Tree/MethodInvocation.g.cs | 38 +- Rewrite/src/Rewrite.Java/Tree/Modifier.g.cs | 24 +- Rewrite/src/Rewrite.Java/Tree/MultiCatch.g.cs | 18 +- Rewrite/src/Rewrite.Java/Tree/NameTree.cs | 4 +- Rewrite/src/Rewrite.Java/Tree/NewArray.g.cs | 30 +- Rewrite/src/Rewrite.Java/Tree/NewClass.cs | 2 +- Rewrite/src/Rewrite.Java/Tree/NewClass.g.cs | 40 +- .../src/Rewrite.Java/Tree/NullableType.g.cs | 22 +- Rewrite/src/Rewrite.Java/Tree/Package.g.cs | 20 +- .../Rewrite.Java/Tree/ParameterizedType.g.cs | 26 +- .../src/Rewrite.Java/Tree/Parentheses.g.cs | 18 +- .../Tree/ParenthesizedTypeTree.g.cs | 20 +- Rewrite/src/Rewrite.Java/Tree/Primitive.g.cs | 16 +- Rewrite/src/Rewrite.Java/Tree/Return.g.cs | 16 +- Rewrite/src/Rewrite.Java/Tree/Space.cs | 73 +- Rewrite/src/Rewrite.Java/Tree/Statement.cs | 2 +- Rewrite/src/Rewrite.Java/Tree/Switch.g.cs | 20 +- .../Rewrite.Java/Tree/SwitchExpression.g.cs | 24 +- .../src/Rewrite.Java/Tree/Synchronized.g.cs | 20 +- Rewrite/src/Rewrite.Java/Tree/Ternary.g.cs | 32 +- Rewrite/src/Rewrite.Java/Tree/TextComment.cs | 58 +- Rewrite/src/Rewrite.Java/Tree/Throw.g.cs | 16 +- Rewrite/src/Rewrite.Java/Tree/Try.g.cs | 72 +- Rewrite/src/Rewrite.Java/Tree/TypeCast.g.cs | 20 +- .../src/Rewrite.Java/Tree/TypeParameter.g.cs | 30 +- .../src/Rewrite.Java/Tree/TypeParameters.g.cs | 22 +- Rewrite/src/Rewrite.Java/Tree/TypeTree.cs | 14 +- Rewrite/src/Rewrite.Java/Tree/TypedTree.cs | 12 +- Rewrite/src/Rewrite.Java/Tree/Unary.g.cs | 26 +- Rewrite/src/Rewrite.Java/Tree/Unknown.g.cs | 32 +- .../Tree/VariableDeclarations.g.cs | 68 +- Rewrite/src/Rewrite.Java/Tree/WhileLoop.g.cs | 22 +- Rewrite/src/Rewrite.Java/Tree/Wildcard.g.cs | 22 +- Rewrite/src/Rewrite.Java/Tree/Yield.g.cs | 20 +- .../Rewrite.Remote.Codec.csproj | 2 +- .../src/Rewrite.Server/Rewrite.Server.csproj | 4 +- .../CSharpTypeAttributionTests.cs | 21 +- .../Formatter/AutoFormatterTests.cs | 51 ++ .../tests/Rewrite.CSharp.Tests/PlayTests.cs | 52 +- .../Rewrite.CSharp.Tests.csproj | 4 +- .../Tree/ClassDeclarationTests.cs | 18 + 222 files changed, 4249 insertions(+), 3059 deletions(-) create mode 100644 Rewrite/src/Rewrite.Analyzers/CovariantReturnGenerator.cs create mode 100644 Rewrite/src/Rewrite.Analyzers/SymbolEqualityComparer.cs create mode 100644 Rewrite/src/Rewrite.CSharp/Format/AutoFormat.cs create mode 100644 Rewrite/src/Rewrite.CSharp/Format/AutoFormatVisitor.cs create mode 100644 Rewrite/src/Rewrite.CSharp/Format/DictionaryExtensions.cs create mode 100644 Rewrite/src/Rewrite.CSharp/Format/FormatStyle.cs delete mode 100644 Rewrite/src/Rewrite.CSharp/Format/NormalizeFormatVisitor.cs create mode 100644 Rewrite/src/Rewrite.CSharp/Format/TextChange.cs create mode 100644 Rewrite/src/Rewrite.CSharp/Format/TriviaChunker.cs create mode 100644 Rewrite/src/Rewrite.CSharp/Format/UniqueSpaceVisitor.cs create mode 100644 Rewrite/src/Rewrite.CSharp/Global.cs create mode 100644 Rewrite/src/Rewrite.CSharp/Roslyn/Parser.cs create mode 100644 Rewrite/src/Rewrite.CSharp/Tree/CSharpSourceFile.cs create mode 100644 Rewrite/src/Rewrite.CSharp/Tree/CompilationUnit.cs create mode 100644 Rewrite/src/Rewrite.CSharp/Tree/Cs.cs create mode 100644 Rewrite/src/Rewrite.Java/Globals.cs create mode 100644 Rewrite/src/Rewrite.Java/Marker/ImplicitReturn.cs create mode 100644 Rewrite/tests/Rewrite.CSharp.Tests/Formatter/AutoFormatterTests.cs diff --git a/Rewrite/Directory.Build.props b/Rewrite/Directory.Build.props index 03aa0eda..52ac96a1 100644 --- a/Rewrite/Directory.Build.props +++ b/Rewrite/Directory.Build.props @@ -20,6 +20,7 @@ 0.18.1 + 4.12.0 diff --git a/Rewrite/Rewrite.Sources.sln b/Rewrite/Rewrite.Sources.sln index 8d3dc918..4a0682fa 100644 --- a/Rewrite/Rewrite.Sources.sln +++ b/Rewrite/Rewrite.Sources.sln @@ -55,78 +55,98 @@ Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU Release|Any CPU = Release|Any CPU + Analyzers|Any CPU = Analyzers|Any CPU EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution {C714F4F1-E2DF-4B29-A277-9B40BD7DE406}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {C714F4F1-E2DF-4B29-A277-9B40BD7DE406}.Release|Any CPU.ActiveCfg = Release|Any CPU + {C714F4F1-E2DF-4B29-A277-9B40BD7DE406}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU {FB30394C-7930-4BFF-97E2-400CFADE92C2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {FB30394C-7930-4BFF-97E2-400CFADE92C2}.Debug|Any CPU.Build.0 = Debug|Any CPU {FB30394C-7930-4BFF-97E2-400CFADE92C2}.Release|Any CPU.ActiveCfg = Release|Any CPU {FB30394C-7930-4BFF-97E2-400CFADE92C2}.Release|Any CPU.Build.0 = Release|Any CPU + {FB30394C-7930-4BFF-97E2-400CFADE92C2}.Debug|Any CPU.Build.0 = Debug|Any CPU + {FB30394C-7930-4BFF-97E2-400CFADE92C2}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU {C7E280C5-E841-4690-8AA3-653ECBC7C78B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {C7E280C5-E841-4690-8AA3-653ECBC7C78B}.Debug|Any CPU.Build.0 = Debug|Any CPU {C7E280C5-E841-4690-8AA3-653ECBC7C78B}.Release|Any CPU.ActiveCfg = Release|Any CPU {C7E280C5-E841-4690-8AA3-653ECBC7C78B}.Release|Any CPU.Build.0 = Release|Any CPU + {C7E280C5-E841-4690-8AA3-653ECBC7C78B}.Debug|Any CPU.Build.0 = Debug|Any CPU + {C7E280C5-E841-4690-8AA3-653ECBC7C78B}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU {F7F4F27F-2CAE-422B-B6CE-25A88C3603A1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {F7F4F27F-2CAE-422B-B6CE-25A88C3603A1}.Debug|Any CPU.Build.0 = Debug|Any CPU {F7F4F27F-2CAE-422B-B6CE-25A88C3603A1}.Release|Any CPU.ActiveCfg = Release|Any CPU {F7F4F27F-2CAE-422B-B6CE-25A88C3603A1}.Release|Any CPU.Build.0 = Release|Any CPU + {F7F4F27F-2CAE-422B-B6CE-25A88C3603A1}.Debug|Any CPU.Build.0 = Debug|Any CPU + {F7F4F27F-2CAE-422B-B6CE-25A88C3603A1}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU {D38BB305-3276-4AE1-87B1-C19C7A9F3840}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {D38BB305-3276-4AE1-87B1-C19C7A9F3840}.Debug|Any CPU.Build.0 = Debug|Any CPU {D38BB305-3276-4AE1-87B1-C19C7A9F3840}.Release|Any CPU.ActiveCfg = Release|Any CPU {D38BB305-3276-4AE1-87B1-C19C7A9F3840}.Release|Any CPU.Build.0 = Release|Any CPU + {D38BB305-3276-4AE1-87B1-C19C7A9F3840}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D38BB305-3276-4AE1-87B1-C19C7A9F3840}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU {5DD7D88A-5A10-457D-B1A2-30F7CF67AD9F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {5DD7D88A-5A10-457D-B1A2-30F7CF67AD9F}.Debug|Any CPU.Build.0 = Debug|Any CPU {5DD7D88A-5A10-457D-B1A2-30F7CF67AD9F}.Release|Any CPU.ActiveCfg = Release|Any CPU {5DD7D88A-5A10-457D-B1A2-30F7CF67AD9F}.Release|Any CPU.Build.0 = Release|Any CPU + {5DD7D88A-5A10-457D-B1A2-30F7CF67AD9F}.Debug|Any CPU.Build.0 = Debug|Any CPU + {5DD7D88A-5A10-457D-B1A2-30F7CF67AD9F}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU {06BCC1C7-9D8C-4D3B-934D-072C35A5C984}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {06BCC1C7-9D8C-4D3B-934D-072C35A5C984}.Debug|Any CPU.Build.0 = Debug|Any CPU {06BCC1C7-9D8C-4D3B-934D-072C35A5C984}.Release|Any CPU.ActiveCfg = Release|Any CPU {06BCC1C7-9D8C-4D3B-934D-072C35A5C984}.Release|Any CPU.Build.0 = Release|Any CPU + {06BCC1C7-9D8C-4D3B-934D-072C35A5C984}.Debug|Any CPU.Build.0 = Debug|Any CPU + {06BCC1C7-9D8C-4D3B-934D-072C35A5C984}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU {25208A27-E598-4BE3-9CD9-0618A6B9598F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {25208A27-E598-4BE3-9CD9-0618A6B9598F}.Debug|Any CPU.Build.0 = Debug|Any CPU {25208A27-E598-4BE3-9CD9-0618A6B9598F}.Release|Any CPU.ActiveCfg = Release|Any CPU {25208A27-E598-4BE3-9CD9-0618A6B9598F}.Release|Any CPU.Build.0 = Release|Any CPU + {25208A27-E598-4BE3-9CD9-0618A6B9598F}.Debug|Any CPU.Build.0 = Debug|Any CPU + {25208A27-E598-4BE3-9CD9-0618A6B9598F}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU {25EEACCB-9BAE-4361-A980-9E9CDA37602E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {25EEACCB-9BAE-4361-A980-9E9CDA37602E}.Debug|Any CPU.Build.0 = Debug|Any CPU {25EEACCB-9BAE-4361-A980-9E9CDA37602E}.Release|Any CPU.ActiveCfg = Release|Any CPU {25EEACCB-9BAE-4361-A980-9E9CDA37602E}.Release|Any CPU.Build.0 = Release|Any CPU + {25EEACCB-9BAE-4361-A980-9E9CDA37602E}.Debug|Any CPU.Build.0 = Debug|Any CPU + {25EEACCB-9BAE-4361-A980-9E9CDA37602E}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU {D3F48947-C702-4D1A-B6EE-96B89D13953D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {D3F48947-C702-4D1A-B6EE-96B89D13953D}.Debug|Any CPU.Build.0 = Debug|Any CPU {D3F48947-C702-4D1A-B6EE-96B89D13953D}.Release|Any CPU.ActiveCfg = Release|Any CPU {D3F48947-C702-4D1A-B6EE-96B89D13953D}.Release|Any CPU.Build.0 = Release|Any CPU + {D3F48947-C702-4D1A-B6EE-96B89D13953D}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D3F48947-C702-4D1A-B6EE-96B89D13953D}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU {D3F48947-C702-4D1A-B6EE-96B89D13953E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {D3F48947-C702-4D1A-B6EE-96B89D13953E}.Debug|Any CPU.Build.0 = Debug|Any CPU {D3F48947-C702-4D1A-B6EE-96B89D13953E}.Release|Any CPU.ActiveCfg = Release|Any CPU {D3F48947-C702-4D1A-B6EE-96B89D13953E}.Release|Any CPU.Build.0 = Release|Any CPU + {D3F48947-C702-4D1A-B6EE-96B89D13953E}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D3F48947-C702-4D1A-B6EE-96B89D13953E}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU {0E364862-1ACA-4C94-8EA0-23724FF67AA2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {0E364862-1ACA-4C94-8EA0-23724FF67AA2}.Debug|Any CPU.Build.0 = Debug|Any CPU {0E364862-1ACA-4C94-8EA0-23724FF67AA2}.Release|Any CPU.ActiveCfg = Release|Any CPU {0E364862-1ACA-4C94-8EA0-23724FF67AA2}.Release|Any CPU.Build.0 = Release|Any CPU + {0E364862-1ACA-4C94-8EA0-23724FF67AA2}.Debug|Any CPU.Build.0 = Debug|Any CPU + {0E364862-1ACA-4C94-8EA0-23724FF67AA2}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU {DE03049F-95A3-483F-939C-C2325548D590}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {DE03049F-95A3-483F-939C-C2325548D590}.Debug|Any CPU.Build.0 = Debug|Any CPU {DE03049F-95A3-483F-939C-C2325548D590}.Release|Any CPU.ActiveCfg = Release|Any CPU {DE03049F-95A3-483F-939C-C2325548D590}.Release|Any CPU.Build.0 = Release|Any CPU + {DE03049F-95A3-483F-939C-C2325548D590}.Debug|Any CPU.Build.0 = Debug|Any CPU + {DE03049F-95A3-483F-939C-C2325548D590}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU {40C71491-3CCC-40A0-8F01-3EC7204CF85F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {40C71491-3CCC-40A0-8F01-3EC7204CF85F}.Debug|Any CPU.Build.0 = Debug|Any CPU {40C71491-3CCC-40A0-8F01-3EC7204CF85F}.Release|Any CPU.ActiveCfg = Release|Any CPU {40C71491-3CCC-40A0-8F01-3EC7204CF85F}.Release|Any CPU.Build.0 = Release|Any CPU + {40C71491-3CCC-40A0-8F01-3EC7204CF85F}.Debug|Any CPU.Build.0 = Debug|Any CPU + {40C71491-3CCC-40A0-8F01-3EC7204CF85F}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU {5C70ACE0-BE37-4D67-A67F-EE69767994D2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {5C70ACE0-BE37-4D67-A67F-EE69767994D2}.Debug|Any CPU.Build.0 = Debug|Any CPU {5C70ACE0-BE37-4D67-A67F-EE69767994D2}.Release|Any CPU.ActiveCfg = Release|Any CPU {5C70ACE0-BE37-4D67-A67F-EE69767994D2}.Release|Any CPU.Build.0 = Release|Any CPU + {5C70ACE0-BE37-4D67-A67F-EE69767994D2}.Debug|Any CPU.Build.0 = Debug|Any CPU + {5C70ACE0-BE37-4D67-A67F-EE69767994D2}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU {C04C7CA4-69C3-444F-A654-6C722A0FC3BE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {C04C7CA4-69C3-444F-A654-6C722A0FC3BE}.Debug|Any CPU.Build.0 = Debug|Any CPU {C04C7CA4-69C3-444F-A654-6C722A0FC3BE}.Release|Any CPU.ActiveCfg = Release|Any CPU {C04C7CA4-69C3-444F-A654-6C722A0FC3BE}.Release|Any CPU.Build.0 = Release|Any CPU + {C04C7CA4-69C3-444F-A654-6C722A0FC3BE}.Debug|Any CPU.Build.0 = Debug|Any CPU + {C04C7CA4-69C3-444F-A654-6C722A0FC3BE}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU {E0721BA1-2772-4486-BDF3-FC9301723BB9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {E0721BA1-2772-4486-BDF3-FC9301723BB9}.Debug|Any CPU.Build.0 = Debug|Any CPU {E0721BA1-2772-4486-BDF3-FC9301723BB9}.Release|Any CPU.ActiveCfg = Release|Any CPU {E0721BA1-2772-4486-BDF3-FC9301723BB9}.Release|Any CPU.Build.0 = Release|Any CPU + {E0721BA1-2772-4486-BDF3-FC9301723BB9}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E0721BA1-2772-4486-BDF3-FC9301723BB9}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU {9818146E-C516-4D3C-80CE-A84741E7772B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {9818146E-C516-4D3C-80CE-A84741E7772B}.Debug|Any CPU.Build.0 = Debug|Any CPU {9818146E-C516-4D3C-80CE-A84741E7772B}.Release|Any CPU.ActiveCfg = Release|Any CPU {9818146E-C516-4D3C-80CE-A84741E7772B}.Release|Any CPU.Build.0 = Release|Any CPU + {9818146E-C516-4D3C-80CE-A84741E7772B}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU + {9818146E-C516-4D3C-80CE-A84741E7772B}.Analyzers|Any CPU.Build.0 = Debug|Any CPU EndGlobalSection GlobalSection(NestedProjects) = preSolution {25EEACCB-9BAE-4361-A980-9E9CDA37602E} = {7B268266-B9CD-4D85-ABC5-3B2C4611FD74} diff --git a/Rewrite/src/Rewrite.Analyzers/CovariantReturnGenerator.cs b/Rewrite/src/Rewrite.Analyzers/CovariantReturnGenerator.cs new file mode 100644 index 00000000..25b20950 --- /dev/null +++ b/Rewrite/src/Rewrite.Analyzers/CovariantReturnGenerator.cs @@ -0,0 +1,302 @@ +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.CSharp; +using Microsoft.CodeAnalysis.CSharp.Syntax; +using Microsoft.CodeAnalysis.Text; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Linq; +using System.Text; +using System.Text.RegularExpressions; +#pragma warning disable CS0162 // Unreachable code detected + +namespace Rewrite.Analyzers +{ + [Generator] + public class CovariantReturnGenerator : ISourceGenerator + { + private ImmutableHashSet _interfacesRequiringGenericVersion = null!; + + public void Initialize(GeneratorInitializationContext context) + { + context.RegisterForSyntaxNotifications(() => new SyntaxReceiver()); + } + + public void Execute(GeneratorExecutionContext context) + { + + if (context.SyntaxReceiver is not SyntaxReceiver receiver) + return; + + var compilation = context.Compilation; + var model = compilation.GetSemanticModel(receiver.Classes.FirstOrDefault()?.SyntaxTree ?? receiver.Interfaces.FirstOrDefault()?.SyntaxTree!); + var allInterfaces1 = model.LookupNamespacesAndTypes(0) + .OfType() + .Where(x => x.TypeKind == TypeKind.Interface) + .Where(x => x.ContainingNamespace.ToDisplayString().StartsWith("Rewrite")) + .ToList(); + // compilation.GetSemanticModel(x.SyntaxTree). + + var currentAssemblyInterface = receiver.Interfaces + .Select(x => compilation.GetSemanticModel(x.SyntaxTree).GetDeclaredSymbol(x)!) + .Distinct(SymbolEqualityComparer.Default) + .ToList(); + + var allInterfaces = allInterfaces1.Union(currentAssemblyInterface, SymbolEqualityComparer.Default).ToList(); + + // var allInterfaces = receiver.Interfaces + // .Select(x => GetFullyQualifiedName(x, compilation)) + // .Distinct() + // .Select(x => compilation.GetTypeByMetadataName(x)) + // .ToList(); + + var interfacesWithCovariantReturns = allInterfaces + .Where(interfaceSymbol => interfaceSymbol + .GetMembers() + .OfType() + .Any(methodSymbol => SymbolEqualityComparer.Default.Equals(methodSymbol.ReturnType, interfaceSymbol))) + .ToImmutableHashSet(SymbolEqualityComparer.Default); + + var interfacesWithCovariantReturnsInCurrentAssembly = interfacesWithCovariantReturns + .Cast() + .Where(x => currentAssemblyInterface.Contains(x, SymbolEqualityComparer.Default)) + .ToList(); + + _interfacesRequiringGenericVersion = currentAssemblyInterface + .Where(iface => iface + .AllInterfaces + .Any(baseInterface => interfacesWithCovariantReturns.Contains(baseInterface))) + .Union(interfacesWithCovariantReturnsInCurrentAssembly, SymbolEqualityComparer.Default) + .Cast() + .ToImmutableHashSet(SymbolEqualityComparer.Default); + + var allInterfacesWithGenericVersion = allInterfaces + .Where(iface => iface + .AllInterfaces + .Any(baseInterface => interfacesWithCovariantReturns.Contains(baseInterface))) + .Union(interfacesWithCovariantReturnsInCurrentAssembly, SymbolEqualityComparer.Default) + .Cast() + .ToImmutableHashSet(SymbolEqualityComparer.Default); + + + foreach (var interfaceSymbol in _interfacesRequiringGenericVersion.Cast()) + { + + var source = GenerateCovariantInterface(interfaceSymbol); + source = CSharpSyntaxTree.ParseText(source).GetRoot().NormalizeWhitespace().ToFullString(); + context.AddSource($"{ConvertToMetadataName(interfaceSymbol.ToString())}.covariant.g.cs", SourceText.From(source, Encoding.UTF8)); + } + context.AddSource($"_test.cs", $"//{allInterfacesWithGenericVersion.Count}"); + + var classesImplementingCovariantTypes = receiver.Classes + .Select(syntax => (Syntax: syntax, Model: compilation.GetSemanticModel(syntax.SyntaxTree).GetDeclaredSymbol(syntax)!)) + .Where(x => x.Model.AllInterfaces.Any(@interface => _interfacesRequiringGenericVersion.Contains(@interface))) + .Select(x => x.Model) + .Distinct(SymbolEqualityComparer.Default) + .ToList(); + + foreach (var classSymbol in classesImplementingCovariantTypes) + { + var source = GenerateClassGenericInterfaceImplementation(classSymbol); + source = CSharpSyntaxTree.ParseText(source).GetRoot().NormalizeWhitespace().ToFullString(); + context.AddSource($"{ConvertToMetadataName(classSymbol.ToString())}.covariant.g.cs", SourceText.From(source, Encoding.UTF8)); + } + } + + static string ConvertToMetadataName(string typeName) + { + // Regex to find generic type parameters + var match = Regex.Match(typeName, @"^(.+?)<([^>]+)>$"); + if (!match.Success) return typeName; // Not a generic type + + string baseName = match.Groups[1].Value; + string typeParams = match.Groups[2].Value; + + // Count number of generic parameters + int genericArgCount = typeParams.Split(',').Length; + return $"{baseName}`{genericArgCount}"; + } + + private (string, string) GeneratePartialDeclarationScope(INamedTypeSymbol symbol) + { + + var parentTypes = new Stack(); + var parent = (INamespaceOrTypeSymbol)symbol.ContainingSymbol; + while (parent.IsType) + { + parentTypes.Push((INamedTypeSymbol)parent); + if (((INamespaceOrTypeSymbol)parent.ContainingSymbol).IsNamespace) + break; + parent = (INamedTypeSymbol)parent.ContainingSymbol; + } + + var builder = new StringBuilder(); + var namespaceName = symbol.ContainingNamespace.ToDisplayString(); + builder.AppendLine($"namespace {namespaceName};"); + builder.AppendLine(); + + var sublevel = 0; + while (parentTypes.Count > 0) + { + var parentType = parentTypes.Pop(); + builder.AppendLine($"public partial {parentType.TypeKind.ToString().ToLower()} {parentType.Name}"); + builder.AppendLine("{"); + sublevel++; + } + + var end = new string('}', sublevel); + + return (builder.ToString(), end); + } + + private string GenerateClassGenericInterfaceImplementation(INamedTypeSymbol classSymbol) + { + var builder = new StringBuilder(); + var (start, end) = GeneratePartialDeclarationScope(classSymbol); + builder.AppendLine(start); + + var interfaces = classSymbol + .Interfaces + .Where(@interface => _interfacesRequiringGenericVersion.Contains(@interface)) + .ToList(); + + + // Generate the generic version of the interface + builder.AppendLine($"public partial class {classSymbol.Name}{GetTypeParameters(classSymbol)} : {string.Join(", ", interfaces.Select(x => $"{x}<{classSymbol.Name}{GetTypeParameters(classSymbol)}>"))}"); + builder.AppendLine("{}"); + builder.AppendLine(end); + return builder.ToString(); + } + + private IEnumerable GetMethodsWithReturnTypeAsType(InterfaceDeclarationSyntax declaration) + { + return declaration.Members.OfType().Where(x => x.ReturnType.ToString() == declaration.Identifier.ValueText); + } + + + private string GenerateCovariantInterface(INamedTypeSymbol typeSymbol) + { + var builder = new StringBuilder(); + var (start, end) = GeneratePartialDeclarationScope(typeSymbol); + builder.AppendLine(start); + + // Generate the generic version of the interface + builder.Append($"public partial interface {typeSymbol.Name} : {typeSymbol.Name}"); + + // Add the generic version of the parent interfaces + foreach (var parentInterface in typeSymbol.Interfaces.Where(x => _interfacesRequiringGenericVersion.Contains(x))) + { + builder.Append($", {parentInterface.Name}"); + } + + builder.AppendLine($" where T : {typeSymbol.Name}"); + // builder.AppendLine($" where T : J"); + builder.AppendLine(); + builder.AppendLine("{"); + + bool IsImplemented(IMethodSymbol methodSymbol) + { + if(methodSymbol.MethodKind != MethodKind.ExplicitInterfaceImplementation) + return false; + + return methodSymbol + .DeclaringSyntaxReferences + .Select(r => (MethodDeclarationSyntax)r.GetSyntax()) + .Any(methodSyntax => methodSyntax.Body is not null || methodSyntax.ExpressionBody is not null); + + } + + var methodsRequiringCovariantDefinitions = typeSymbol + .GetMembers() + .OfType() + .Where(x => x.MethodKind == MethodKind.Ordinary) + .Where(method => method.ReturnType.Equals(typeSymbol, SymbolEqualityComparer.Default) && method.IsAbstract) + .GroupBy(x => (x.Name, x.ReturnType.ToDisplayString(), GetParameterList(x))) + .Select(x => x.First()) + .ToList(); + + + // Generate new methods with covariant return types + foreach (var method in methodsRequiringCovariantDefinitions) + { + builder.AppendLine($" public new T {method.Name}({GetParameterList(method)});"); + builder.AppendLine($" {typeSymbol.Name} {typeSymbol.Name}.{method.Name}{GetTypeParameters(method)}({GetParameterList(method)}) => {method.Name}({GetArgumentList(method)});"); + } + + builder.AppendLine("}"); + builder.AppendLine(); + + // Generate the non-generic version of the interface + builder.AppendLine($"public partial interface {typeSymbol.Name}"); + builder.AppendLine("{"); + + if (typeSymbol.Name == "Pattern") + { + Debugger.Break(); + } + // Add default implementations for methods inherited from parent interfaces + var distinctMethods = new HashSet(); + foreach (var baseInterface in typeSymbol.AllInterfaces) + { + + foreach (var method in baseInterface.GetMembers().OfType().Where(x => !IsImplemented(x))) + { + var methodSignature = $"{typeSymbol.Name} {method.Name}{GetTypeParameters(method)}({GetParameterList(method)})"; + if (method.ReturnType.Equals(baseInterface, SymbolEqualityComparer.Default) && !distinctMethods.Contains(methodSignature)) + { + builder.AppendLine($" public new {methodSignature} => ({typeSymbol.Name})(({baseInterface.Name})this).{method.Name}({GetArgumentList(method)});"); + distinctMethods.Add(methodSignature); + } + } + } + + builder.AppendLine("}"); + builder.AppendLine(end); + + return builder.ToString(); + } + private string GetTypeParameters(INamedTypeSymbol method) + { + if (method.TypeParameters.IsEmpty) + return ""; + return $"<{string.Join(", ", method.TypeParameters.Select(p => p.Name))}>"; + } + private string GetTypeParameters(IMethodSymbol method) + { + if (method.TypeParameters.IsEmpty) + return ""; + return $"<{string.Join(", ", method.TypeParameters.Select(p => p.Name))}>"; + } + private string GetParameterList(IMethodSymbol method) + { + return string.Join(", ", method.Parameters.Select(p => $"{p.Type.ToString().Replace("?","")} {p.Name}")); + } + + private string GetArgumentList(IMethodSymbol method) + { + return string.Join(", ", method.Parameters.Select(p => p.Name)); + } + } + + public class SyntaxReceiver : ISyntaxReceiver + { + public List Interfaces { get; } = new(); + + public List Classes { get; set; } = new(); + + public void OnVisitSyntaxNode(SyntaxNode syntaxNode) + { + if (syntaxNode is not TypeDeclarationSyntax typeDeclaration || !typeDeclaration.Modifiers.Any(SyntaxKind.PartialKeyword)) + return; + switch (syntaxNode) + { + case InterfaceDeclarationSyntax interfaceDeclaration: + Interfaces.Add(interfaceDeclaration); + break; + case ClassDeclarationSyntax classDeclaration when classDeclaration.BaseList?.Types.Any() == true: + Classes.Add(classDeclaration); + break; + } + } + } +} diff --git a/Rewrite/src/Rewrite.Analyzers/Properties/launchSettings.json b/Rewrite/src/Rewrite.Analyzers/Properties/launchSettings.json index fcd2f883..de83f954 100644 --- a/Rewrite/src/Rewrite.Analyzers/Properties/launchSettings.json +++ b/Rewrite/src/Rewrite.Analyzers/Properties/launchSettings.json @@ -1,7 +1,11 @@ { "$schema": "http://json.schemastore.org/launchsettings.json", "profiles": { - "Generators": { + "Generators - CSharp": { + "commandName": "DebugRoslynComponent", + "targetProject": "../Rewrite.CSharp/Rewrite.CSharp.csproj" + }, + "Generators - Java": { "commandName": "DebugRoslynComponent", "targetProject": "../Rewrite.Java/Rewrite.Java.csproj" } diff --git a/Rewrite/src/Rewrite.Analyzers/SymbolEqualityComparer.cs b/Rewrite/src/Rewrite.Analyzers/SymbolEqualityComparer.cs new file mode 100644 index 00000000..2bf9b3b1 --- /dev/null +++ b/Rewrite/src/Rewrite.Analyzers/SymbolEqualityComparer.cs @@ -0,0 +1,12 @@ +using System.Collections.Generic; +using Microsoft.CodeAnalysis; + +namespace Rewrite.Analyzers; + +public class SymbolEqualityComparer : IEqualityComparer where T : ISymbol +{ + public static readonly SymbolEqualityComparer 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.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..e5381fe7 --- /dev/null +++ b/Rewrite/src/Rewrite.CSharp/Format/FormatStyle.cs @@ -0,0 +1,60 @@ +namespace Rewrite.RewriteCSharp.Format; + +internal record FormatStyle(string Indentation, string NewLine) + { + const string DefaultNewLine = "\r\n"; + 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 Usings => _usings.Elements(); public BlockScopeNamespaceDeclaration WithUsings(IList newUsings) { return Padding.WithUsings(_usings.WithElements(newUsings)); } - private readonly IList> _members = members; + private IList> _members = members; public IList Members => _members.Elements(); public BlockScopeNamespaceDeclaration WithMembers(IList newMembers) { return Padding.WithMembers(_members.WithElements(newMembers)); } - public Space End => end; + public Space End { get; set; } = end; public BlockScopeNamespaceDeclaration WithEnd(Space newEnd) { - return newEnd == end ? this : new BlockScopeNamespaceDeclaration(id, prefix, markers, _name, _externs, _usings, _members, newEnd); + return newEnd == End ? this : new BlockScopeNamespaceDeclaration(Id, Prefix, Markers, _name, _externs, _usings, _members, newEnd); } public sealed record PaddingHelper(Cs.BlockScopeNamespaceDeclaration T) { - public JRightPadded Name => T._name; + public JRightPadded Name { get => T._name; set => T._name = value; } public Cs.BlockScopeNamespaceDeclaration WithName(JRightPadded newName) { - return T._name == newName ? T : new Cs.BlockScopeNamespaceDeclaration(T.Id, T.Prefix, T.Markers, newName, T._externs, T._usings, T._members, T.End); + return Name == newName ? T : new Cs.BlockScopeNamespaceDeclaration(T.Id, T.Prefix, T.Markers, newName, T._externs, T._usings, T._members, T.End); } - public IList> Externs => T._externs; + public IList> Externs { get => T._externs; set => T._externs = value; } public Cs.BlockScopeNamespaceDeclaration WithExterns(IList> newExterns) { - return T._externs == newExterns ? T : new Cs.BlockScopeNamespaceDeclaration(T.Id, T.Prefix, T.Markers, T._name, newExterns, T._usings, T._members, T.End); + return Externs == newExterns ? T : new Cs.BlockScopeNamespaceDeclaration(T.Id, T.Prefix, T.Markers, T._name, newExterns, T._usings, T._members, T.End); } - public IList> Usings => T._usings; + public IList> Usings { get => T._usings; set => T._usings = value; } public Cs.BlockScopeNamespaceDeclaration WithUsings(IList> newUsings) { - return T._usings == newUsings ? T : new Cs.BlockScopeNamespaceDeclaration(T.Id, T.Prefix, T.Markers, T._name, T._externs, newUsings, T._members, T.End); + return Usings == newUsings ? T : new Cs.BlockScopeNamespaceDeclaration(T.Id, T.Prefix, T.Markers, T._name, T._externs, newUsings, T._members, T.End); } - public IList> Members => T._members; + public IList> Members { get => T._members; set => T._members = value; } public Cs.BlockScopeNamespaceDeclaration WithMembers(IList> newMembers) { - return T._members == newMembers ? T : new Cs.BlockScopeNamespaceDeclaration(T.Id, T.Prefix, T.Markers, T._name, T._externs, T._usings, newMembers, T.End); + return Members == newMembers ? T : new Cs.BlockScopeNamespaceDeclaration(T.Id, T.Prefix, T.Markers, T._name, T._externs, T._usings, newMembers, T.End); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/CSharpSourceFile.cs b/Rewrite/src/Rewrite.CSharp/Tree/CSharpSourceFile.cs new file mode 100644 index 00000000..9079d507 --- /dev/null +++ b/Rewrite/src/Rewrite.CSharp/Tree/CSharpSourceFile.cs @@ -0,0 +1,7 @@ +namespace Rewrite.RewriteCSharp.Tree; + +public partial interface CSharpSourceFile : Cs, MutableSourceFile +{ + public IList Members { get; } + public IList Usings => Members.OfType().ToList(); +} diff --git a/Rewrite/src/Rewrite.CSharp/Tree/CasePatternSwitchLabel.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/CasePatternSwitchLabel.g.cs index 85bfd38f..3866620b 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/CasePatternSwitchLabel.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/CasePatternSwitchLabel.g.cs @@ -81,50 +81,50 @@ public PaddingHelper Padding return v.VisitCasePatternSwitchLabel(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public CasePatternSwitchLabel WithId(Guid newId) { - return newId == id ? this : new CasePatternSwitchLabel(newId, prefix, markers, pattern, _whenClause, colonToken); + return newId == Id ? this : new CasePatternSwitchLabel(newId, Prefix, Markers, Pattern, _whenClause, ColonToken); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public CasePatternSwitchLabel WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new CasePatternSwitchLabel(id, newPrefix, markers, pattern, _whenClause, colonToken); + return newPrefix == Prefix ? this : new CasePatternSwitchLabel(Id, newPrefix, Markers, Pattern, _whenClause, ColonToken); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public CasePatternSwitchLabel WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new CasePatternSwitchLabel(id, prefix, newMarkers, pattern, _whenClause, colonToken); + return ReferenceEquals(newMarkers, Markers) ? this : new CasePatternSwitchLabel(Id, Prefix, newMarkers, Pattern, _whenClause, ColonToken); } - public Cs.Pattern Pattern => pattern; + public Cs.Pattern Pattern { get; set; } = pattern; public CasePatternSwitchLabel WithPattern(Cs.Pattern newPattern) { - return ReferenceEquals(newPattern, pattern) ? this : new CasePatternSwitchLabel(id, prefix, markers, newPattern, _whenClause, colonToken); + return ReferenceEquals(newPattern, Pattern) ? this : new CasePatternSwitchLabel(Id, Prefix, Markers, newPattern, _whenClause, ColonToken); } - private readonly JLeftPadded? _whenClause = whenClause; + private JLeftPadded? _whenClause = whenClause; public Expression? WhenClause => _whenClause?.Element; public CasePatternSwitchLabel WithWhenClause(Expression? newWhenClause) { return Padding.WithWhenClause(JLeftPadded.WithElement(_whenClause, newWhenClause)); } - public Space ColonToken => colonToken; + public Space ColonToken { get; set; } = colonToken; public CasePatternSwitchLabel WithColonToken(Space newColonToken) { - return newColonToken == colonToken ? this : new CasePatternSwitchLabel(id, prefix, markers, pattern, _whenClause, newColonToken); + return newColonToken == ColonToken ? this : new CasePatternSwitchLabel(Id, Prefix, Markers, Pattern, _whenClause, newColonToken); } public sealed record PaddingHelper(Cs.CasePatternSwitchLabel T) { - public JLeftPadded? WhenClause => T._whenClause; + public JLeftPadded? WhenClause { get => T._whenClause; set => T._whenClause = value; } public Cs.CasePatternSwitchLabel WithWhenClause(JLeftPadded? newWhenClause) { - return T._whenClause == newWhenClause ? T : new Cs.CasePatternSwitchLabel(T.Id, T.Prefix, T.Markers, T.Pattern, newWhenClause, T.ColonToken); + return WhenClause == newWhenClause ? T : new Cs.CasePatternSwitchLabel(T.Id, T.Prefix, T.Markers, T.Pattern, newWhenClause, T.ColonToken); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/CheckedExpression.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/CheckedExpression.g.cs index 03e0adef..cbd45b85 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/CheckedExpression.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/CheckedExpression.g.cs @@ -51,35 +51,35 @@ J.ControlParentheses expression return v.VisitCheckedExpression(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public CheckedExpression WithId(Guid newId) { - return newId == id ? this : new CheckedExpression(newId, prefix, markers, checkedOrUncheckedKeyword, expression); + return newId == Id ? this : new CheckedExpression(newId, Prefix, Markers, CheckedOrUncheckedKeyword, Expression); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public CheckedExpression WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new CheckedExpression(id, newPrefix, markers, checkedOrUncheckedKeyword, expression); + return newPrefix == Prefix ? this : new CheckedExpression(Id, newPrefix, Markers, CheckedOrUncheckedKeyword, Expression); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public CheckedExpression WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new CheckedExpression(id, prefix, newMarkers, checkedOrUncheckedKeyword, expression); + return ReferenceEquals(newMarkers, Markers) ? this : new CheckedExpression(Id, Prefix, newMarkers, CheckedOrUncheckedKeyword, Expression); } - public Cs.Keyword CheckedOrUncheckedKeyword => checkedOrUncheckedKeyword; + public Cs.Keyword CheckedOrUncheckedKeyword { get; set; } = checkedOrUncheckedKeyword; public CheckedExpression WithCheckedOrUncheckedKeyword(Cs.Keyword newCheckedOrUncheckedKeyword) { - return ReferenceEquals(newCheckedOrUncheckedKeyword, checkedOrUncheckedKeyword) ? this : new CheckedExpression(id, prefix, markers, newCheckedOrUncheckedKeyword, expression); + return ReferenceEquals(newCheckedOrUncheckedKeyword, CheckedOrUncheckedKeyword) ? this : new CheckedExpression(Id, Prefix, Markers, newCheckedOrUncheckedKeyword, Expression); } - public J.ControlParentheses Expression => expression; + public J.ControlParentheses Expression { get; set; } = expression; public CheckedExpression WithExpression(J.ControlParentheses newExpression) { - return ReferenceEquals(newExpression, expression) ? this : new CheckedExpression(id, prefix, markers, checkedOrUncheckedKeyword, newExpression); + return ReferenceEquals(newExpression, Expression) ? this : new CheckedExpression(Id, Prefix, Markers, CheckedOrUncheckedKeyword, newExpression); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.CSharp/Tree/CheckedStatement.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/CheckedStatement.g.cs index 805f0583..7640f652 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/CheckedStatement.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/CheckedStatement.g.cs @@ -63,35 +63,35 @@ J.Block block return v.VisitCheckedStatement(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public CheckedStatement WithId(Guid newId) { - return newId == id ? this : new CheckedStatement(newId, prefix, markers, keyword, block); + return newId == Id ? this : new CheckedStatement(newId, Prefix, Markers, Keyword, Block); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public CheckedStatement WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new CheckedStatement(id, newPrefix, markers, keyword, block); + return newPrefix == Prefix ? this : new CheckedStatement(Id, newPrefix, Markers, Keyword, Block); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public CheckedStatement WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new CheckedStatement(id, prefix, newMarkers, keyword, block); + return ReferenceEquals(newMarkers, Markers) ? this : new CheckedStatement(Id, Prefix, newMarkers, Keyword, Block); } - public Cs.Keyword Keyword => keyword; + public Cs.Keyword Keyword { get; set; } = keyword; public CheckedStatement WithKeyword(Cs.Keyword newKeyword) { - return ReferenceEquals(newKeyword, keyword) ? this : new CheckedStatement(id, prefix, markers, newKeyword, block); + return ReferenceEquals(newKeyword, Keyword) ? this : new CheckedStatement(Id, Prefix, Markers, newKeyword, Block); } - public J.Block Block => block; + public J.Block Block { get; set; } = block; public CheckedStatement WithBlock(J.Block newBlock) { - return ReferenceEquals(newBlock, block) ? this : new CheckedStatement(id, prefix, markers, keyword, newBlock); + return ReferenceEquals(newBlock, Block) ? this : new CheckedStatement(Id, Prefix, Markers, Keyword, newBlock); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.CSharp/Tree/ClassDeclaration.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/ClassDeclaration.g.cs index 1820244a..4ad9ead0 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/ClassDeclaration.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/ClassDeclaration.g.cs @@ -74,137 +74,137 @@ public PaddingHelper Padding return v.VisitClassDeclaration(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public ClassDeclaration WithId(Guid newId) { - return newId == id ? this : new ClassDeclaration(newId, prefix, markers, attributeList, modifiers, _kind, name, _typeParameters, _primaryConstructor, _extendings, _implementings, body, _typeParameterConstraintClauses, type); + return newId == Id ? this : new ClassDeclaration(newId, Prefix, Markers, AttributeList, Modifiers, _kind, Name, _typeParameters, _primaryConstructor, _extendings, _implementings, Body, _typeParameterConstraintClauses, Type); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public ClassDeclaration WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new ClassDeclaration(id, newPrefix, markers, attributeList, modifiers, _kind, name, _typeParameters, _primaryConstructor, _extendings, _implementings, body, _typeParameterConstraintClauses, type); + return newPrefix == Prefix ? this : new ClassDeclaration(Id, newPrefix, Markers, AttributeList, Modifiers, _kind, Name, _typeParameters, _primaryConstructor, _extendings, _implementings, Body, _typeParameterConstraintClauses, Type); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public ClassDeclaration WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new ClassDeclaration(id, prefix, newMarkers, attributeList, modifiers, _kind, name, _typeParameters, _primaryConstructor, _extendings, _implementings, body, _typeParameterConstraintClauses, type); + return ReferenceEquals(newMarkers, Markers) ? this : new ClassDeclaration(Id, Prefix, newMarkers, AttributeList, Modifiers, _kind, Name, _typeParameters, _primaryConstructor, _extendings, _implementings, Body, _typeParameterConstraintClauses, Type); } - public IList AttributeList => attributeList; + public IList AttributeList { get; set; } = attributeList; public ClassDeclaration WithAttributeList(IList newAttributeList) { - return newAttributeList == attributeList ? this : new ClassDeclaration(id, prefix, markers, newAttributeList, modifiers, _kind, name, _typeParameters, _primaryConstructor, _extendings, _implementings, body, _typeParameterConstraintClauses, type); + return newAttributeList == AttributeList ? this : new ClassDeclaration(Id, Prefix, Markers, newAttributeList, Modifiers, _kind, Name, _typeParameters, _primaryConstructor, _extendings, _implementings, Body, _typeParameterConstraintClauses, Type); } - public IList Modifiers => modifiers; + public IList Modifiers { get; set; } = modifiers; public ClassDeclaration WithModifiers(IList newModifiers) { - return newModifiers == modifiers ? this : new ClassDeclaration(id, prefix, markers, attributeList, newModifiers, _kind, name, _typeParameters, _primaryConstructor, _extendings, _implementings, body, _typeParameterConstraintClauses, type); + return newModifiers == Modifiers ? this : new ClassDeclaration(Id, Prefix, Markers, AttributeList, newModifiers, _kind, Name, _typeParameters, _primaryConstructor, _extendings, _implementings, Body, _typeParameterConstraintClauses, Type); } - private readonly J.ClassDeclaration.Kind _kind = kind; + private J.ClassDeclaration.Kind _kind = kind; public ClassDeclaration WithKind(J.ClassDeclaration.Kind newKind) { - return ReferenceEquals(newKind, _kind) ? this : new ClassDeclaration(id, prefix, markers, attributeList, modifiers, _kind, name, _typeParameters, _primaryConstructor, _extendings, _implementings, body, _typeParameterConstraintClauses, type); + return ReferenceEquals(newKind, Kind) ? this : new ClassDeclaration(Id, Prefix, Markers, AttributeList, Modifiers, _kind, Name, _typeParameters, _primaryConstructor, _extendings, _implementings, Body, _typeParameterConstraintClauses, Type); } - public J.Identifier Name => name; + public J.Identifier Name { get; set; } = name; public ClassDeclaration WithName(J.Identifier newName) { - return ReferenceEquals(newName, name) ? this : new ClassDeclaration(id, prefix, markers, attributeList, modifiers, _kind, newName, _typeParameters, _primaryConstructor, _extendings, _implementings, body, _typeParameterConstraintClauses, type); + return ReferenceEquals(newName, Name) ? this : new ClassDeclaration(Id, Prefix, Markers, AttributeList, Modifiers, _kind, newName, _typeParameters, _primaryConstructor, _extendings, _implementings, Body, _typeParameterConstraintClauses, Type); } - private readonly JContainer? _typeParameters = typeParameters; + private JContainer? _typeParameters = typeParameters; public IList? TypeParameters => _typeParameters?.GetElements(); public ClassDeclaration WithTypeParameters(IList? newTypeParameters) { return Padding.WithTypeParameters(JContainer.WithElementsNullable(_typeParameters, newTypeParameters)); } - private readonly JContainer? _primaryConstructor = primaryConstructor; + private JContainer? _primaryConstructor = primaryConstructor; public IList? PrimaryConstructor => _primaryConstructor?.GetElements(); public ClassDeclaration WithPrimaryConstructor(IList? newPrimaryConstructor) { return Padding.WithPrimaryConstructor(JContainer.WithElementsNullable(_primaryConstructor, newPrimaryConstructor)); } - private readonly JLeftPadded? _extendings = extendings; + private JLeftPadded? _extendings = extendings; public TypeTree? Extendings => _extendings?.Element; public ClassDeclaration WithExtendings(TypeTree? newExtendings) { return Padding.WithExtendings(JLeftPadded.WithElement(_extendings, newExtendings)); } - private readonly JContainer? _implementings = implementings; + private JContainer? _implementings = implementings; public IList? Implementings => _implementings?.GetElements(); public ClassDeclaration WithImplementings(IList? newImplementings) { return Padding.WithImplementings(JContainer.WithElementsNullable(_implementings, newImplementings)); } - public J.Block? Body => body; + public J.Block? Body { get; set; } = body; public ClassDeclaration WithBody(J.Block? newBody) { - return ReferenceEquals(newBody, body) ? this : new ClassDeclaration(id, prefix, markers, attributeList, modifiers, _kind, name, _typeParameters, _primaryConstructor, _extendings, _implementings, newBody, _typeParameterConstraintClauses, type); + return ReferenceEquals(newBody, Body) ? this : new ClassDeclaration(Id, Prefix, Markers, AttributeList, Modifiers, _kind, Name, _typeParameters, _primaryConstructor, _extendings, _implementings, newBody, _typeParameterConstraintClauses, Type); } - private readonly JContainer? _typeParameterConstraintClauses = typeParameterConstraintClauses; + private JContainer? _typeParameterConstraintClauses = typeParameterConstraintClauses; public IList? TypeParameterConstraintClauses => _typeParameterConstraintClauses?.GetElements(); public ClassDeclaration WithTypeParameterConstraintClauses(IList? newTypeParameterConstraintClauses) { return Padding.WithTypeParameterConstraintClauses(JContainer.WithElementsNullable(_typeParameterConstraintClauses, newTypeParameterConstraintClauses)); } - public JavaType.FullyQualified? Type => type; + public JavaType.FullyQualified? Type { get; set; } = type; public ClassDeclaration WithType(JavaType.FullyQualified? newType) { - return newType == type ? this : new ClassDeclaration(id, prefix, markers, attributeList, modifiers, _kind, name, _typeParameters, _primaryConstructor, _extendings, _implementings, body, _typeParameterConstraintClauses, newType); + return newType == Type ? this : new ClassDeclaration(Id, Prefix, Markers, AttributeList, Modifiers, _kind, Name, _typeParameters, _primaryConstructor, _extendings, _implementings, Body, _typeParameterConstraintClauses, newType); } public sealed record PaddingHelper(Cs.ClassDeclaration T) { - public J.ClassDeclaration.Kind Kind => T._kind; + public J.ClassDeclaration.Kind Kind { get => T._kind; set => T._kind = value; } public Cs.ClassDeclaration WithKind(J.ClassDeclaration.Kind newKind) { - return T._kind == newKind ? T : new Cs.ClassDeclaration(T.Id, T.Prefix, T.Markers, T.AttributeList, T.Modifiers, newKind, T.Name, T._typeParameters, T._primaryConstructor, T._extendings, T._implementings, T.Body, T._typeParameterConstraintClauses, T.Type); + return Kind == newKind ? T : new Cs.ClassDeclaration(T.Id, T.Prefix, T.Markers, T.AttributeList, T.Modifiers, newKind, T.Name, T._typeParameters, T._primaryConstructor, T._extendings, T._implementings, T.Body, T._typeParameterConstraintClauses, T.Type); } - public JContainer? TypeParameters => T._typeParameters; + public JContainer? TypeParameters { get => T._typeParameters; set => T._typeParameters = value; } public Cs.ClassDeclaration WithTypeParameters(JContainer? newTypeParameters) { - return T._typeParameters == newTypeParameters ? T : new Cs.ClassDeclaration(T.Id, T.Prefix, T.Markers, T.AttributeList, T.Modifiers, T._kind, T.Name, newTypeParameters, T._primaryConstructor, T._extendings, T._implementings, T.Body, T._typeParameterConstraintClauses, T.Type); + return TypeParameters == newTypeParameters ? T : new Cs.ClassDeclaration(T.Id, T.Prefix, T.Markers, T.AttributeList, T.Modifiers, T._kind, T.Name, newTypeParameters, T._primaryConstructor, T._extendings, T._implementings, T.Body, T._typeParameterConstraintClauses, T.Type); } - public JContainer? PrimaryConstructor => T._primaryConstructor; + public JContainer? PrimaryConstructor { get => T._primaryConstructor; set => T._primaryConstructor = value; } public Cs.ClassDeclaration WithPrimaryConstructor(JContainer? newPrimaryConstructor) { - return T._primaryConstructor == newPrimaryConstructor ? T : new Cs.ClassDeclaration(T.Id, T.Prefix, T.Markers, T.AttributeList, T.Modifiers, T._kind, T.Name, T._typeParameters, newPrimaryConstructor, T._extendings, T._implementings, T.Body, T._typeParameterConstraintClauses, T.Type); + return PrimaryConstructor == newPrimaryConstructor ? T : new Cs.ClassDeclaration(T.Id, T.Prefix, T.Markers, T.AttributeList, T.Modifiers, T._kind, T.Name, T._typeParameters, newPrimaryConstructor, T._extendings, T._implementings, T.Body, T._typeParameterConstraintClauses, T.Type); } - public JLeftPadded? Extendings => T._extendings; + public JLeftPadded? Extendings { get => T._extendings; set => T._extendings = value; } public Cs.ClassDeclaration WithExtendings(JLeftPadded? newExtendings) { - return T._extendings == newExtendings ? T : new Cs.ClassDeclaration(T.Id, T.Prefix, T.Markers, T.AttributeList, T.Modifiers, T._kind, T.Name, T._typeParameters, T._primaryConstructor, newExtendings, T._implementings, T.Body, T._typeParameterConstraintClauses, T.Type); + return Extendings == newExtendings ? T : new Cs.ClassDeclaration(T.Id, T.Prefix, T.Markers, T.AttributeList, T.Modifiers, T._kind, T.Name, T._typeParameters, T._primaryConstructor, newExtendings, T._implementings, T.Body, T._typeParameterConstraintClauses, T.Type); } - public JContainer? Implementings => T._implementings; + public JContainer? Implementings { get => T._implementings; set => T._implementings = value; } public Cs.ClassDeclaration WithImplementings(JContainer? newImplementings) { - return T._implementings == newImplementings ? T : new Cs.ClassDeclaration(T.Id, T.Prefix, T.Markers, T.AttributeList, T.Modifiers, T._kind, T.Name, T._typeParameters, T._primaryConstructor, T._extendings, newImplementings, T.Body, T._typeParameterConstraintClauses, T.Type); + return Implementings == newImplementings ? T : new Cs.ClassDeclaration(T.Id, T.Prefix, T.Markers, T.AttributeList, T.Modifiers, T._kind, T.Name, T._typeParameters, T._primaryConstructor, T._extendings, newImplementings, T.Body, T._typeParameterConstraintClauses, T.Type); } - public JContainer? TypeParameterConstraintClauses => T._typeParameterConstraintClauses; + public JContainer? TypeParameterConstraintClauses { get => T._typeParameterConstraintClauses; set => T._typeParameterConstraintClauses = value; } public Cs.ClassDeclaration WithTypeParameterConstraintClauses(JContainer? newTypeParameterConstraintClauses) { - return T._typeParameterConstraintClauses == newTypeParameterConstraintClauses ? T : new Cs.ClassDeclaration(T.Id, T.Prefix, T.Markers, T.AttributeList, T.Modifiers, T._kind, T.Name, T._typeParameters, T._primaryConstructor, T._extendings, T._implementings, T.Body, newTypeParameterConstraintClauses, T.Type); + return TypeParameterConstraintClauses == newTypeParameterConstraintClauses ? T : new Cs.ClassDeclaration(T.Id, T.Prefix, T.Markers, T.AttributeList, T.Modifiers, T._kind, T.Name, T._typeParameters, T._primaryConstructor, T._extendings, T._implementings, T.Body, newTypeParameterConstraintClauses, T.Type); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/ClassOrStructConstraint.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/ClassOrStructConstraint.g.cs index a2ede7ed..347164ac 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/ClassOrStructConstraint.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/ClassOrStructConstraint.g.cs @@ -43,29 +43,29 @@ ClassOrStructConstraint.TypeKind kind return v.VisitClassOrStructConstraint(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public ClassOrStructConstraint WithId(Guid newId) { - return newId == id ? this : new ClassOrStructConstraint(newId, prefix, markers, kind); + return newId == Id ? this : new ClassOrStructConstraint(newId, Prefix, Markers, Kind); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public ClassOrStructConstraint WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new ClassOrStructConstraint(id, newPrefix, markers, kind); + return newPrefix == Prefix ? this : new ClassOrStructConstraint(Id, newPrefix, Markers, Kind); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public ClassOrStructConstraint WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new ClassOrStructConstraint(id, prefix, newMarkers, kind); + return ReferenceEquals(newMarkers, Markers) ? this : new ClassOrStructConstraint(Id, Prefix, newMarkers, Kind); } - public TypeKind Kind => kind; + public TypeKind Kind { get; set; } = kind; public ClassOrStructConstraint WithKind(TypeKind newKind) { - return newKind == kind ? this : new ClassOrStructConstraint(id, prefix, markers, newKind); + return newKind == Kind ? this : new ClassOrStructConstraint(Id, Prefix, Markers, newKind); } public enum TypeKind { diff --git a/Rewrite/src/Rewrite.CSharp/Tree/CollectionExpression.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/CollectionExpression.g.cs index b5000c73..16cd8b9a 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/CollectionExpression.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/CollectionExpression.g.cs @@ -65,44 +65,44 @@ public PaddingHelper Padding return v.VisitCollectionExpression(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public CollectionExpression WithId(Guid newId) { - return newId == id ? this : new CollectionExpression(newId, prefix, markers, _elements, type); + return newId == Id ? this : new CollectionExpression(newId, Prefix, Markers, _elements, Type); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public CollectionExpression WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new CollectionExpression(id, newPrefix, markers, _elements, type); + return newPrefix == Prefix ? this : new CollectionExpression(Id, newPrefix, Markers, _elements, Type); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public CollectionExpression WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new CollectionExpression(id, prefix, newMarkers, _elements, type); + return ReferenceEquals(newMarkers, Markers) ? this : new CollectionExpression(Id, Prefix, newMarkers, _elements, Type); } - private readonly IList> _elements = elements; + private IList> _elements = elements; public IList Elements => _elements.Elements(); public CollectionExpression WithElements(IList newElements) { return Padding.WithElements(_elements.WithElements(newElements)); } - public JavaType Type => type; + public JavaType Type { get; set; } = type; public CollectionExpression WithType(JavaType newType) { - return newType == type ? this : new CollectionExpression(id, prefix, markers, _elements, newType); + return newType == Type ? this : new CollectionExpression(Id, Prefix, Markers, _elements, newType); } public sealed record PaddingHelper(Cs.CollectionExpression T) { - public IList> Elements => T._elements; + public IList> Elements { get => T._elements; set => T._elements = value; } public Cs.CollectionExpression WithElements(IList> newElements) { - return T._elements == newElements ? T : new Cs.CollectionExpression(T.Id, T.Prefix, T.Markers, newElements, T.Type); + return Elements == newElements ? T : new Cs.CollectionExpression(T.Id, T.Prefix, T.Markers, newElements, T.Type); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/CompilationUnit.cs b/Rewrite/src/Rewrite.CSharp/Tree/CompilationUnit.cs new file mode 100644 index 00000000..1f195aaa --- /dev/null +++ b/Rewrite/src/Rewrite.CSharp/Tree/CompilationUnit.cs @@ -0,0 +1,9 @@ +namespace Rewrite.RewriteCSharp.Tree; + +public partial interface Cs +{ + public new partial class CompilationUnit : MutableSourceFile + { + + } +} diff --git a/Rewrite/src/Rewrite.CSharp/Tree/CompilationUnit.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/CompilationUnit.g.cs index 51bce844..fc16dacb 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/CompilationUnit.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/CompilationUnit.g.cs @@ -73,108 +73,108 @@ public PaddingHelper Padding return v.VisitCompilationUnit(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public CompilationUnit WithId(Guid newId) { - return newId == id ? this : new CompilationUnit(newId, prefix, markers, sourcePath, fileAttributes, charsetName, charsetBomMarked, checksum, _externs, _usings, attributeLists, _members, eof); + return newId == Id ? this : new CompilationUnit(newId, Prefix, Markers, SourcePath, FileAttributes, CharsetName, CharsetBomMarked, Checksum, _externs, _usings, AttributeLists, _members, Eof); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public CompilationUnit WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new CompilationUnit(id, newPrefix, markers, sourcePath, fileAttributes, charsetName, charsetBomMarked, checksum, _externs, _usings, attributeLists, _members, eof); + return newPrefix == Prefix ? this : new CompilationUnit(Id, newPrefix, Markers, SourcePath, FileAttributes, CharsetName, CharsetBomMarked, Checksum, _externs, _usings, AttributeLists, _members, Eof); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public CompilationUnit WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new CompilationUnit(id, prefix, newMarkers, sourcePath, fileAttributes, charsetName, charsetBomMarked, checksum, _externs, _usings, attributeLists, _members, eof); + return ReferenceEquals(newMarkers, Markers) ? this : new CompilationUnit(Id, Prefix, newMarkers, SourcePath, FileAttributes, CharsetName, CharsetBomMarked, Checksum, _externs, _usings, AttributeLists, _members, Eof); } - public string SourcePath => sourcePath; + public string SourcePath { get; set; } = sourcePath; public CompilationUnit WithSourcePath(string newSourcePath) { - return newSourcePath == sourcePath ? this : new CompilationUnit(id, prefix, markers, newSourcePath, fileAttributes, charsetName, charsetBomMarked, checksum, _externs, _usings, attributeLists, _members, eof); + return newSourcePath == SourcePath ? this : new CompilationUnit(Id, Prefix, Markers, newSourcePath, FileAttributes, CharsetName, CharsetBomMarked, Checksum, _externs, _usings, AttributeLists, _members, Eof); } - public FileAttributes? FileAttributes => fileAttributes; + public FileAttributes? FileAttributes { get; set; } = fileAttributes; public CompilationUnit WithFileAttributes(FileAttributes? newFileAttributes) { - return newFileAttributes == fileAttributes ? this : new CompilationUnit(id, prefix, markers, sourcePath, newFileAttributes, charsetName, charsetBomMarked, checksum, _externs, _usings, attributeLists, _members, eof); + return newFileAttributes == FileAttributes ? this : new CompilationUnit(Id, Prefix, Markers, SourcePath, newFileAttributes, CharsetName, CharsetBomMarked, Checksum, _externs, _usings, AttributeLists, _members, Eof); } - public string? CharsetName => charsetName; + public string? CharsetName { get; set; } = charsetName; public CompilationUnit WithCharsetName(string? newCharsetName) { - return newCharsetName == charsetName ? this : new CompilationUnit(id, prefix, markers, sourcePath, fileAttributes, newCharsetName, charsetBomMarked, checksum, _externs, _usings, attributeLists, _members, eof); + return newCharsetName == CharsetName ? this : new CompilationUnit(Id, Prefix, Markers, SourcePath, FileAttributes, newCharsetName, CharsetBomMarked, Checksum, _externs, _usings, AttributeLists, _members, Eof); } - public bool CharsetBomMarked => charsetBomMarked; + public bool CharsetBomMarked { get; set; } = charsetBomMarked; public CompilationUnit WithCharsetBomMarked(bool newCharsetBomMarked) { - return newCharsetBomMarked == charsetBomMarked ? this : new CompilationUnit(id, prefix, markers, sourcePath, fileAttributes, charsetName, newCharsetBomMarked, checksum, _externs, _usings, attributeLists, _members, eof); + return newCharsetBomMarked == CharsetBomMarked ? this : new CompilationUnit(Id, Prefix, Markers, SourcePath, FileAttributes, CharsetName, newCharsetBomMarked, Checksum, _externs, _usings, AttributeLists, _members, Eof); } - public Checksum? Checksum => checksum; + public Checksum? Checksum { get; set; } = checksum; public CompilationUnit WithChecksum(Checksum? newChecksum) { - return newChecksum == checksum ? this : new CompilationUnit(id, prefix, markers, sourcePath, fileAttributes, charsetName, charsetBomMarked, newChecksum, _externs, _usings, attributeLists, _members, eof); + return newChecksum == Checksum ? this : new CompilationUnit(Id, Prefix, Markers, SourcePath, FileAttributes, CharsetName, CharsetBomMarked, newChecksum, _externs, _usings, AttributeLists, _members, Eof); } - private readonly IList> _externs = externs; + private IList> _externs = externs; public IList Externs => _externs.Elements(); public CompilationUnit WithExterns(IList newExterns) { return Padding.WithExterns(_externs.WithElements(newExterns)); } - private readonly IList> _usings = usings; + private IList> _usings = usings; public IList Usings => _usings.Elements(); public CompilationUnit WithUsings(IList newUsings) { return Padding.WithUsings(_usings.WithElements(newUsings)); } - public IList AttributeLists => attributeLists; + public IList AttributeLists { get; set; } = attributeLists; public CompilationUnit WithAttributeLists(IList newAttributeLists) { - return newAttributeLists == attributeLists ? this : new CompilationUnit(id, prefix, markers, sourcePath, fileAttributes, charsetName, charsetBomMarked, checksum, _externs, _usings, newAttributeLists, _members, eof); + return newAttributeLists == AttributeLists ? this : new CompilationUnit(Id, Prefix, Markers, SourcePath, FileAttributes, CharsetName, CharsetBomMarked, Checksum, _externs, _usings, newAttributeLists, _members, Eof); } - private readonly IList> _members = members; + private IList> _members = members; public IList Members => _members.Elements(); public CompilationUnit WithMembers(IList newMembers) { return Padding.WithMembers(_members.WithElements(newMembers)); } - public Space Eof => eof; + public Space Eof { get; set; } = eof; public CompilationUnit WithEof(Space newEof) { - return newEof == eof ? this : new CompilationUnit(id, prefix, markers, sourcePath, fileAttributes, charsetName, charsetBomMarked, checksum, _externs, _usings, attributeLists, _members, newEof); + return newEof == Eof ? this : new CompilationUnit(Id, Prefix, Markers, SourcePath, FileAttributes, CharsetName, CharsetBomMarked, Checksum, _externs, _usings, AttributeLists, _members, newEof); } public sealed record PaddingHelper(Cs.CompilationUnit T) { - public IList> Externs => T._externs; + public IList> Externs { get => T._externs; set => T._externs = value; } public Cs.CompilationUnit WithExterns(IList> newExterns) { - return T._externs == newExterns ? T : new Cs.CompilationUnit(T.Id, T.Prefix, T.Markers, T.SourcePath, T.FileAttributes, T.CharsetName, T.CharsetBomMarked, T.Checksum, newExterns, T._usings, T.AttributeLists, T._members, T.Eof); + return Externs == newExterns ? T : new Cs.CompilationUnit(T.Id, T.Prefix, T.Markers, T.SourcePath, T.FileAttributes, T.CharsetName, T.CharsetBomMarked, T.Checksum, newExterns, T._usings, T.AttributeLists, T._members, T.Eof); } - public IList> Usings => T._usings; + public IList> Usings { get => T._usings; set => T._usings = value; } public Cs.CompilationUnit WithUsings(IList> newUsings) { - return T._usings == newUsings ? T : new Cs.CompilationUnit(T.Id, T.Prefix, T.Markers, T.SourcePath, T.FileAttributes, T.CharsetName, T.CharsetBomMarked, T.Checksum, T._externs, newUsings, T.AttributeLists, T._members, T.Eof); + return Usings == newUsings ? T : new Cs.CompilationUnit(T.Id, T.Prefix, T.Markers, T.SourcePath, T.FileAttributes, T.CharsetName, T.CharsetBomMarked, T.Checksum, T._externs, newUsings, T.AttributeLists, T._members, T.Eof); } - public IList> Members => T._members; + public IList> Members { get => T._members; set => T._members = value; } public Cs.CompilationUnit WithMembers(IList> newMembers) { - return T._members == newMembers ? T : new Cs.CompilationUnit(T.Id, T.Prefix, T.Markers, T.SourcePath, T.FileAttributes, T.CharsetName, T.CharsetBomMarked, T.Checksum, T._externs, T._usings, T.AttributeLists, newMembers, T.Eof); + return Members == newMembers ? T : new Cs.CompilationUnit(T.Id, T.Prefix, T.Markers, T.SourcePath, T.FileAttributes, T.CharsetName, T.CharsetBomMarked, T.Checksum, T._externs, T._usings, T.AttributeLists, newMembers, T.Eof); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/ConstantPattern.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/ConstantPattern.g.cs index 9c56e115..6df82d14 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/ConstantPattern.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/ConstantPattern.g.cs @@ -66,29 +66,29 @@ Expression value return v.VisitConstantPattern(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public ConstantPattern WithId(Guid newId) { - return newId == id ? this : new ConstantPattern(newId, prefix, markers, value); + return newId == Id ? this : new ConstantPattern(newId, Prefix, Markers, Value); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public ConstantPattern WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new ConstantPattern(id, newPrefix, markers, value); + return newPrefix == Prefix ? this : new ConstantPattern(Id, newPrefix, Markers, Value); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public ConstantPattern WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new ConstantPattern(id, prefix, newMarkers, value); + return ReferenceEquals(newMarkers, Markers) ? this : new ConstantPattern(Id, Prefix, newMarkers, Value); } - public Expression Value => value; + public Expression Value { get; set; } = value; public ConstantPattern WithValue(Expression newValue) { - return ReferenceEquals(newValue, value) ? this : new ConstantPattern(id, prefix, markers, newValue); + return ReferenceEquals(newValue, Value) ? this : new ConstantPattern(Id, Prefix, Markers, newValue); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.CSharp/Tree/Constructor.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/Constructor.g.cs index 1236b878..4543af4d 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/Constructor.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/Constructor.g.cs @@ -56,35 +56,35 @@ J.MethodDeclaration constructorCore return v.VisitConstructor(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Constructor WithId(Guid newId) { - return newId == id ? this : new Constructor(newId, prefix, markers, initializer, constructorCore); + return newId == Id ? this : new Constructor(newId, Prefix, Markers, Initializer, ConstructorCore); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Constructor WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Constructor(id, newPrefix, markers, initializer, constructorCore); + return newPrefix == Prefix ? this : new Constructor(Id, newPrefix, Markers, Initializer, ConstructorCore); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Constructor WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Constructor(id, prefix, newMarkers, initializer, constructorCore); + return ReferenceEquals(newMarkers, Markers) ? this : new Constructor(Id, Prefix, newMarkers, Initializer, ConstructorCore); } - public Cs.ConstructorInitializer? Initializer => initializer; + public Cs.ConstructorInitializer? Initializer { get; set; } = initializer; public Constructor WithInitializer(Cs.ConstructorInitializer? newInitializer) { - return ReferenceEquals(newInitializer, initializer) ? this : new Constructor(id, prefix, markers, newInitializer, constructorCore); + return ReferenceEquals(newInitializer, Initializer) ? this : new Constructor(Id, Prefix, Markers, newInitializer, ConstructorCore); } - public J.MethodDeclaration ConstructorCore => constructorCore; + public J.MethodDeclaration ConstructorCore { get; set; } = constructorCore; public Constructor WithConstructorCore(J.MethodDeclaration newConstructorCore) { - return ReferenceEquals(newConstructorCore, constructorCore) ? this : new Constructor(id, prefix, markers, initializer, newConstructorCore); + return ReferenceEquals(newConstructorCore, ConstructorCore) ? this : new Constructor(Id, Prefix, Markers, Initializer, newConstructorCore); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.CSharp/Tree/ConstructorConstraint.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/ConstructorConstraint.g.cs index 2700b0e8..dc42533f 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/ConstructorConstraint.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/ConstructorConstraint.g.cs @@ -46,23 +46,23 @@ Markers markers return v.VisitConstructorConstraint(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public ConstructorConstraint WithId(Guid newId) { - return newId == id ? this : new ConstructorConstraint(newId, prefix, markers); + return newId == Id ? this : new ConstructorConstraint(newId, Prefix, Markers); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public ConstructorConstraint WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new ConstructorConstraint(id, newPrefix, markers); + return newPrefix == Prefix ? this : new ConstructorConstraint(Id, newPrefix, Markers); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public ConstructorConstraint WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new ConstructorConstraint(id, prefix, newMarkers); + return ReferenceEquals(newMarkers, Markers) ? this : new ConstructorConstraint(Id, Prefix, newMarkers); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.CSharp/Tree/ConstructorInitializer.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/ConstructorInitializer.g.cs index 90c7bb62..fc66cfba 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/ConstructorInitializer.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/ConstructorInitializer.g.cs @@ -78,31 +78,31 @@ public PaddingHelper Padding return v.VisitConstructorInitializer(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public ConstructorInitializer WithId(Guid newId) { - return newId == id ? this : new ConstructorInitializer(newId, prefix, markers, keyword, _arguments); + return newId == Id ? this : new ConstructorInitializer(newId, Prefix, Markers, Keyword, _arguments); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public ConstructorInitializer WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new ConstructorInitializer(id, newPrefix, markers, keyword, _arguments); + return newPrefix == Prefix ? this : new ConstructorInitializer(Id, newPrefix, Markers, Keyword, _arguments); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public ConstructorInitializer WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new ConstructorInitializer(id, prefix, newMarkers, keyword, _arguments); + return ReferenceEquals(newMarkers, Markers) ? this : new ConstructorInitializer(Id, Prefix, newMarkers, Keyword, _arguments); } - public Cs.Keyword Keyword => keyword; + public Cs.Keyword Keyword { get; set; } = keyword; public ConstructorInitializer WithKeyword(Cs.Keyword newKeyword) { - return ReferenceEquals(newKeyword, keyword) ? this : new ConstructorInitializer(id, prefix, markers, newKeyword, _arguments); + return ReferenceEquals(newKeyword, Keyword) ? this : new ConstructorInitializer(Id, Prefix, Markers, newKeyword, _arguments); } - private readonly JContainer _arguments = arguments; + private JContainer _arguments = arguments; public IList Arguments => _arguments.GetElements(); public ConstructorInitializer WithArguments(IList newArguments) @@ -111,11 +111,11 @@ public ConstructorInitializer WithArguments(IList newArguments) } public sealed record PaddingHelper(Cs.ConstructorInitializer T) { - public JContainer Arguments => T._arguments; + public JContainer Arguments { get => T._arguments; set => T._arguments = value; } public Cs.ConstructorInitializer WithArguments(JContainer newArguments) { - return T._arguments == newArguments ? T : new Cs.ConstructorInitializer(T.Id, T.Prefix, T.Markers, T.Keyword, newArguments); + return Arguments == newArguments ? T : new Cs.ConstructorInitializer(T.Id, T.Prefix, T.Markers, T.Keyword, newArguments); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/ConversionOperatorDeclaration.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/ConversionOperatorDeclaration.g.cs index aad50699..a749479f 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/ConversionOperatorDeclaration.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/ConversionOperatorDeclaration.g.cs @@ -83,63 +83,63 @@ public PaddingHelper Padding return v.VisitConversionOperatorDeclaration(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public ConversionOperatorDeclaration WithId(Guid newId) { - return newId == id ? this : new ConversionOperatorDeclaration(newId, prefix, markers, modifiers, _kind, _returnType, _parameters, _expressionBody, body); + return newId == Id ? this : new ConversionOperatorDeclaration(newId, Prefix, Markers, Modifiers, _kind, _returnType, _parameters, _expressionBody, Body); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public ConversionOperatorDeclaration WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new ConversionOperatorDeclaration(id, newPrefix, markers, modifiers, _kind, _returnType, _parameters, _expressionBody, body); + return newPrefix == Prefix ? this : new ConversionOperatorDeclaration(Id, newPrefix, Markers, Modifiers, _kind, _returnType, _parameters, _expressionBody, Body); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public ConversionOperatorDeclaration WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new ConversionOperatorDeclaration(id, prefix, newMarkers, modifiers, _kind, _returnType, _parameters, _expressionBody, body); + return ReferenceEquals(newMarkers, Markers) ? this : new ConversionOperatorDeclaration(Id, Prefix, newMarkers, Modifiers, _kind, _returnType, _parameters, _expressionBody, Body); } - public IList Modifiers => modifiers; + public IList Modifiers { get; set; } = modifiers; public ConversionOperatorDeclaration WithModifiers(IList newModifiers) { - return newModifiers == modifiers ? this : new ConversionOperatorDeclaration(id, prefix, markers, newModifiers, _kind, _returnType, _parameters, _expressionBody, body); + return newModifiers == Modifiers ? this : new ConversionOperatorDeclaration(Id, Prefix, Markers, newModifiers, _kind, _returnType, _parameters, _expressionBody, Body); } - private readonly JLeftPadded _kind = kind; + private JLeftPadded _kind = kind; public ExplicitImplicit Kind => _kind.Element; public ConversionOperatorDeclaration WithKind(ExplicitImplicit newKind) { return Padding.WithKind(_kind.WithElement(newKind)); } - private readonly JLeftPadded _returnType = returnType; + private JLeftPadded _returnType = returnType; public TypeTree ReturnType => _returnType.Element; public ConversionOperatorDeclaration WithReturnType(TypeTree newReturnType) { return Padding.WithReturnType(_returnType.WithElement(newReturnType)); } - private readonly JContainer _parameters = parameters; + private JContainer _parameters = parameters; public IList Parameters => _parameters.GetElements(); public ConversionOperatorDeclaration WithParameters(IList newParameters) { return Padding.WithParameters(JContainer.WithElements(_parameters, newParameters)); } - private readonly JLeftPadded? _expressionBody = expressionBody; + private JLeftPadded? _expressionBody = expressionBody; public Expression? ExpressionBody => _expressionBody?.Element; public ConversionOperatorDeclaration WithExpressionBody(Expression? newExpressionBody) { return Padding.WithExpressionBody(JLeftPadded.WithElement(_expressionBody, newExpressionBody)); } - public J.Block? Body => body; + public J.Block? Body { get; set; } = body; public ConversionOperatorDeclaration WithBody(J.Block? newBody) { - return ReferenceEquals(newBody, body) ? this : new ConversionOperatorDeclaration(id, prefix, markers, modifiers, _kind, _returnType, _parameters, _expressionBody, newBody); + return ReferenceEquals(newBody, Body) ? this : new ConversionOperatorDeclaration(Id, Prefix, Markers, Modifiers, _kind, _returnType, _parameters, _expressionBody, newBody); } public enum ExplicitImplicit { @@ -148,32 +148,32 @@ public enum ExplicitImplicit } public sealed record PaddingHelper(Cs.ConversionOperatorDeclaration T) { - public JLeftPadded Kind => T._kind; + public JLeftPadded Kind { get => T._kind; set => T._kind = value; } public Cs.ConversionOperatorDeclaration WithKind(JLeftPadded newKind) { - return T._kind == newKind ? T : new Cs.ConversionOperatorDeclaration(T.Id, T.Prefix, T.Markers, T.Modifiers, newKind, T._returnType, T._parameters, T._expressionBody, T.Body); + return Kind == newKind ? T : new Cs.ConversionOperatorDeclaration(T.Id, T.Prefix, T.Markers, T.Modifiers, newKind, T._returnType, T._parameters, T._expressionBody, T.Body); } - public JLeftPadded ReturnType => T._returnType; + public JLeftPadded ReturnType { get => T._returnType; set => T._returnType = value; } public Cs.ConversionOperatorDeclaration WithReturnType(JLeftPadded newReturnType) { - return T._returnType == newReturnType ? T : new Cs.ConversionOperatorDeclaration(T.Id, T.Prefix, T.Markers, T.Modifiers, T._kind, newReturnType, T._parameters, T._expressionBody, T.Body); + return ReturnType == newReturnType ? T : new Cs.ConversionOperatorDeclaration(T.Id, T.Prefix, T.Markers, T.Modifiers, T._kind, newReturnType, T._parameters, T._expressionBody, T.Body); } - public JContainer Parameters => T._parameters; + public JContainer Parameters { get => T._parameters; set => T._parameters = value; } public Cs.ConversionOperatorDeclaration WithParameters(JContainer newParameters) { - return T._parameters == newParameters ? T : new Cs.ConversionOperatorDeclaration(T.Id, T.Prefix, T.Markers, T.Modifiers, T._kind, T._returnType, newParameters, T._expressionBody, T.Body); + return Parameters == newParameters ? T : new Cs.ConversionOperatorDeclaration(T.Id, T.Prefix, T.Markers, T.Modifiers, T._kind, T._returnType, newParameters, T._expressionBody, T.Body); } - public JLeftPadded? ExpressionBody => T._expressionBody; + public JLeftPadded? ExpressionBody { get => T._expressionBody; set => T._expressionBody = value; } public Cs.ConversionOperatorDeclaration WithExpressionBody(JLeftPadded? newExpressionBody) { - return T._expressionBody == newExpressionBody ? T : new Cs.ConversionOperatorDeclaration(T.Id, T.Prefix, T.Markers, T.Modifiers, T._kind, T._returnType, T._parameters, newExpressionBody, T.Body); + return ExpressionBody == newExpressionBody ? T : new Cs.ConversionOperatorDeclaration(T.Id, T.Prefix, T.Markers, T.Modifiers, T._kind, T._returnType, T._parameters, newExpressionBody, T.Body); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/Cs.cs b/Rewrite/src/Rewrite.CSharp/Tree/Cs.cs new file mode 100644 index 00000000..f51024e6 --- /dev/null +++ b/Rewrite/src/Rewrite.CSharp/Tree/Cs.cs @@ -0,0 +1,7 @@ +namespace Rewrite.RewriteCSharp.Tree; + +public partial interface Cs +{ + public new partial class CompilationUnit : CSharpSourceFile + {} +} diff --git a/Rewrite/src/Rewrite.CSharp/Tree/DeclarationExpression.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/DeclarationExpression.g.cs index 3480a812..3e48a9a1 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/DeclarationExpression.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/DeclarationExpression.g.cs @@ -64,35 +64,35 @@ VariableDesignation variables return v.VisitDeclarationExpression(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public DeclarationExpression WithId(Guid newId) { - return newId == id ? this : new DeclarationExpression(newId, prefix, markers, typeExpression, variables); + return newId == Id ? this : new DeclarationExpression(newId, Prefix, Markers, TypeExpression, Variables); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public DeclarationExpression WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new DeclarationExpression(id, newPrefix, markers, typeExpression, variables); + return newPrefix == Prefix ? this : new DeclarationExpression(Id, newPrefix, Markers, TypeExpression, Variables); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public DeclarationExpression WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new DeclarationExpression(id, prefix, newMarkers, typeExpression, variables); + return ReferenceEquals(newMarkers, Markers) ? this : new DeclarationExpression(Id, Prefix, newMarkers, TypeExpression, Variables); } - public TypeTree? TypeExpression => typeExpression; + public TypeTree? TypeExpression { get; set; } = typeExpression; public DeclarationExpression WithTypeExpression(TypeTree? newTypeExpression) { - return ReferenceEquals(newTypeExpression, typeExpression) ? this : new DeclarationExpression(id, prefix, markers, newTypeExpression, variables); + return ReferenceEquals(newTypeExpression, TypeExpression) ? this : new DeclarationExpression(Id, Prefix, Markers, newTypeExpression, Variables); } - public Cs.VariableDesignation Variables => variables; + public Cs.VariableDesignation Variables { get; set; } = variables; public DeclarationExpression WithVariables(Cs.VariableDesignation newVariables) { - return ReferenceEquals(newVariables, variables) ? this : new DeclarationExpression(id, prefix, markers, typeExpression, newVariables); + return ReferenceEquals(newVariables, Variables) ? this : new DeclarationExpression(Id, Prefix, Markers, TypeExpression, newVariables); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.CSharp/Tree/DefaultConstraint.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/DefaultConstraint.g.cs index d045a633..c2a4fdd2 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/DefaultConstraint.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/DefaultConstraint.g.cs @@ -46,23 +46,23 @@ Markers markers return v.VisitDefaultConstraint(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public DefaultConstraint WithId(Guid newId) { - return newId == id ? this : new DefaultConstraint(newId, prefix, markers); + return newId == Id ? this : new DefaultConstraint(newId, Prefix, Markers); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public DefaultConstraint WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new DefaultConstraint(id, newPrefix, markers); + return newPrefix == Prefix ? this : new DefaultConstraint(Id, newPrefix, Markers); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public DefaultConstraint WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new DefaultConstraint(id, prefix, newMarkers); + return ReferenceEquals(newMarkers, Markers) ? this : new DefaultConstraint(Id, Prefix, newMarkers); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.CSharp/Tree/DefaultExpression.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/DefaultExpression.g.cs index fb8f39fe..5cfc3da1 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/DefaultExpression.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/DefaultExpression.g.cs @@ -76,25 +76,25 @@ public PaddingHelper Padding return v.VisitDefaultExpression(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public DefaultExpression WithId(Guid newId) { - return newId == id ? this : new DefaultExpression(newId, prefix, markers, _typeOperator); + return newId == Id ? this : new DefaultExpression(newId, Prefix, Markers, _typeOperator); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public DefaultExpression WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new DefaultExpression(id, newPrefix, markers, _typeOperator); + return newPrefix == Prefix ? this : new DefaultExpression(Id, newPrefix, Markers, _typeOperator); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public DefaultExpression WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new DefaultExpression(id, prefix, newMarkers, _typeOperator); + return ReferenceEquals(newMarkers, Markers) ? this : new DefaultExpression(Id, Prefix, newMarkers, _typeOperator); } - private readonly JContainer? _typeOperator = typeOperator; + private JContainer? _typeOperator = typeOperator; public IList? TypeOperator => _typeOperator?.GetElements(); public DefaultExpression WithTypeOperator(IList? newTypeOperator) @@ -103,11 +103,11 @@ public DefaultExpression WithTypeOperator(IList? newTypeOperator) } public sealed record PaddingHelper(Cs.DefaultExpression T) { - public JContainer? TypeOperator => T._typeOperator; + public JContainer? TypeOperator { get => T._typeOperator; set => T._typeOperator = value; } public Cs.DefaultExpression WithTypeOperator(JContainer? newTypeOperator) { - return T._typeOperator == newTypeOperator ? T : new Cs.DefaultExpression(T.Id, T.Prefix, T.Markers, newTypeOperator); + return TypeOperator == newTypeOperator ? T : new Cs.DefaultExpression(T.Id, T.Prefix, T.Markers, newTypeOperator); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/DefaultSwitchLabel.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/DefaultSwitchLabel.g.cs index a40cbfc5..0daee792 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/DefaultSwitchLabel.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/DefaultSwitchLabel.g.cs @@ -58,29 +58,29 @@ Space colonToken return v.VisitDefaultSwitchLabel(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public DefaultSwitchLabel WithId(Guid newId) { - return newId == id ? this : new DefaultSwitchLabel(newId, prefix, markers, colonToken); + return newId == Id ? this : new DefaultSwitchLabel(newId, Prefix, Markers, ColonToken); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public DefaultSwitchLabel WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new DefaultSwitchLabel(id, newPrefix, markers, colonToken); + return newPrefix == Prefix ? this : new DefaultSwitchLabel(Id, newPrefix, Markers, ColonToken); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public DefaultSwitchLabel WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new DefaultSwitchLabel(id, prefix, newMarkers, colonToken); + return ReferenceEquals(newMarkers, Markers) ? this : new DefaultSwitchLabel(Id, Prefix, newMarkers, ColonToken); } - public Space ColonToken => colonToken; + public Space ColonToken { get; set; } = colonToken; public DefaultSwitchLabel WithColonToken(Space newColonToken) { - return newColonToken == colonToken ? this : new DefaultSwitchLabel(id, prefix, markers, newColonToken); + return newColonToken == ColonToken ? this : new DefaultSwitchLabel(Id, Prefix, Markers, newColonToken); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.CSharp/Tree/DelegateDeclaration.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/DelegateDeclaration.g.cs index c3453779..5e103eeb 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/DelegateDeclaration.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/DelegateDeclaration.g.cs @@ -90,64 +90,64 @@ public PaddingHelper Padding return v.VisitDelegateDeclaration(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public DelegateDeclaration WithId(Guid newId) { - return newId == id ? this : new DelegateDeclaration(newId, prefix, markers, attributes, modifiers, _returnType, identifier, _typeParameters, _parameters, _typeParameterConstraintClauses); + return newId == Id ? this : new DelegateDeclaration(newId, Prefix, Markers, Attributes, Modifiers, _returnType, Identifier, _typeParameters, _parameters, _typeParameterConstraintClauses); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public DelegateDeclaration WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new DelegateDeclaration(id, newPrefix, markers, attributes, modifiers, _returnType, identifier, _typeParameters, _parameters, _typeParameterConstraintClauses); + return newPrefix == Prefix ? this : new DelegateDeclaration(Id, newPrefix, Markers, Attributes, Modifiers, _returnType, Identifier, _typeParameters, _parameters, _typeParameterConstraintClauses); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public DelegateDeclaration WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new DelegateDeclaration(id, prefix, newMarkers, attributes, modifiers, _returnType, identifier, _typeParameters, _parameters, _typeParameterConstraintClauses); + return ReferenceEquals(newMarkers, Markers) ? this : new DelegateDeclaration(Id, Prefix, newMarkers, Attributes, Modifiers, _returnType, Identifier, _typeParameters, _parameters, _typeParameterConstraintClauses); } - public IList Attributes => attributes; + public IList Attributes { get; set; } = attributes; public DelegateDeclaration WithAttributes(IList newAttributes) { - return newAttributes == attributes ? this : new DelegateDeclaration(id, prefix, markers, newAttributes, modifiers, _returnType, identifier, _typeParameters, _parameters, _typeParameterConstraintClauses); + return newAttributes == Attributes ? this : new DelegateDeclaration(Id, Prefix, Markers, newAttributes, Modifiers, _returnType, Identifier, _typeParameters, _parameters, _typeParameterConstraintClauses); } - public IList Modifiers => modifiers; + public IList Modifiers { get; set; } = modifiers; public DelegateDeclaration WithModifiers(IList newModifiers) { - return newModifiers == modifiers ? this : new DelegateDeclaration(id, prefix, markers, attributes, newModifiers, _returnType, identifier, _typeParameters, _parameters, _typeParameterConstraintClauses); + return newModifiers == Modifiers ? this : new DelegateDeclaration(Id, Prefix, Markers, Attributes, newModifiers, _returnType, Identifier, _typeParameters, _parameters, _typeParameterConstraintClauses); } - private readonly JLeftPadded _returnType = returnType; + private JLeftPadded _returnType = returnType; public TypeTree ReturnType => _returnType.Element; public DelegateDeclaration WithReturnType(TypeTree newReturnType) { return Padding.WithReturnType(_returnType.WithElement(newReturnType)); } - public J.Identifier Identifier => identifier; + public J.Identifier Identifier { get; set; } = identifier; public DelegateDeclaration WithIdentifier(J.Identifier newIdentifier) { - return ReferenceEquals(newIdentifier, identifier) ? this : new DelegateDeclaration(id, prefix, markers, attributes, modifiers, _returnType, newIdentifier, _typeParameters, _parameters, _typeParameterConstraintClauses); + return ReferenceEquals(newIdentifier, Identifier) ? this : new DelegateDeclaration(Id, Prefix, Markers, Attributes, Modifiers, _returnType, newIdentifier, _typeParameters, _parameters, _typeParameterConstraintClauses); } - private readonly JContainer? _typeParameters = typeParameters; + private JContainer? _typeParameters = typeParameters; public IList? TypeParameters => _typeParameters?.GetElements(); public DelegateDeclaration WithTypeParameters(IList? newTypeParameters) { return Padding.WithTypeParameters(JContainer.WithElementsNullable(_typeParameters, newTypeParameters)); } - private readonly JContainer _parameters = parameters; + private JContainer _parameters = parameters; public IList Parameters => _parameters.GetElements(); public DelegateDeclaration WithParameters(IList newParameters) { return Padding.WithParameters(JContainer.WithElements(_parameters, newParameters)); } - private readonly JContainer? _typeParameterConstraintClauses = typeParameterConstraintClauses; + private JContainer? _typeParameterConstraintClauses = typeParameterConstraintClauses; public IList? TypeParameterConstraintClauses => _typeParameterConstraintClauses?.GetElements(); public DelegateDeclaration WithTypeParameterConstraintClauses(IList? newTypeParameterConstraintClauses) @@ -156,32 +156,32 @@ public DelegateDeclaration WithTypeParameterConstraintClauses(IList ReturnType => T._returnType; + public JLeftPadded ReturnType { get => T._returnType; set => T._returnType = value; } public Cs.DelegateDeclaration WithReturnType(JLeftPadded newReturnType) { - return T._returnType == newReturnType ? T : new Cs.DelegateDeclaration(T.Id, T.Prefix, T.Markers, T.Attributes, T.Modifiers, newReturnType, T.Identifier, T._typeParameters, T._parameters, T._typeParameterConstraintClauses); + return ReturnType == newReturnType ? T : new Cs.DelegateDeclaration(T.Id, T.Prefix, T.Markers, T.Attributes, T.Modifiers, newReturnType, T.Identifier, T._typeParameters, T._parameters, T._typeParameterConstraintClauses); } - public JContainer? TypeParameters => T._typeParameters; + public JContainer? TypeParameters { get => T._typeParameters; set => T._typeParameters = value; } public Cs.DelegateDeclaration WithTypeParameters(JContainer? newTypeParameters) { - return T._typeParameters == newTypeParameters ? T : new Cs.DelegateDeclaration(T.Id, T.Prefix, T.Markers, T.Attributes, T.Modifiers, T._returnType, T.Identifier, newTypeParameters, T._parameters, T._typeParameterConstraintClauses); + return TypeParameters == newTypeParameters ? T : new Cs.DelegateDeclaration(T.Id, T.Prefix, T.Markers, T.Attributes, T.Modifiers, T._returnType, T.Identifier, newTypeParameters, T._parameters, T._typeParameterConstraintClauses); } - public JContainer Parameters => T._parameters; + public JContainer Parameters { get => T._parameters; set => T._parameters = value; } public Cs.DelegateDeclaration WithParameters(JContainer newParameters) { - return T._parameters == newParameters ? T : new Cs.DelegateDeclaration(T.Id, T.Prefix, T.Markers, T.Attributes, T.Modifiers, T._returnType, T.Identifier, T._typeParameters, newParameters, T._typeParameterConstraintClauses); + return Parameters == newParameters ? T : new Cs.DelegateDeclaration(T.Id, T.Prefix, T.Markers, T.Attributes, T.Modifiers, T._returnType, T.Identifier, T._typeParameters, newParameters, T._typeParameterConstraintClauses); } - public JContainer? TypeParameterConstraintClauses => T._typeParameterConstraintClauses; + public JContainer? TypeParameterConstraintClauses { get => T._typeParameterConstraintClauses; set => T._typeParameterConstraintClauses = value; } public Cs.DelegateDeclaration WithTypeParameterConstraintClauses(JContainer? newTypeParameterConstraintClauses) { - return T._typeParameterConstraintClauses == newTypeParameterConstraintClauses ? T : new Cs.DelegateDeclaration(T.Id, T.Prefix, T.Markers, T.Attributes, T.Modifiers, T._returnType, T.Identifier, T._typeParameters, T._parameters, newTypeParameterConstraintClauses); + return TypeParameterConstraintClauses == newTypeParameterConstraintClauses ? T : new Cs.DelegateDeclaration(T.Id, T.Prefix, T.Markers, T.Attributes, T.Modifiers, T._returnType, T.Identifier, T._typeParameters, T._parameters, newTypeParameterConstraintClauses); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/DestructorDeclaration.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/DestructorDeclaration.g.cs index 4338172e..fe3cc66d 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/DestructorDeclaration.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/DestructorDeclaration.g.cs @@ -76,29 +76,29 @@ J.MethodDeclaration methodCore return v.VisitDestructorDeclaration(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public DestructorDeclaration WithId(Guid newId) { - return newId == id ? this : new DestructorDeclaration(newId, prefix, markers, methodCore); + return newId == Id ? this : new DestructorDeclaration(newId, Prefix, Markers, MethodCore); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public DestructorDeclaration WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new DestructorDeclaration(id, newPrefix, markers, methodCore); + return newPrefix == Prefix ? this : new DestructorDeclaration(Id, newPrefix, Markers, MethodCore); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public DestructorDeclaration WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new DestructorDeclaration(id, prefix, newMarkers, methodCore); + return ReferenceEquals(newMarkers, Markers) ? this : new DestructorDeclaration(Id, Prefix, newMarkers, MethodCore); } - public J.MethodDeclaration MethodCore => methodCore; + public J.MethodDeclaration MethodCore { get; set; } = methodCore; public DestructorDeclaration WithMethodCore(J.MethodDeclaration newMethodCore) { - return ReferenceEquals(newMethodCore, methodCore) ? this : new DestructorDeclaration(id, prefix, markers, newMethodCore); + return ReferenceEquals(newMethodCore, MethodCore) ? this : new DestructorDeclaration(Id, Prefix, Markers, newMethodCore); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.CSharp/Tree/DiscardPattern.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/DiscardPattern.g.cs index 7328df10..812c027b 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/DiscardPattern.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/DiscardPattern.g.cs @@ -58,29 +58,29 @@ JavaType type return v.VisitDiscardPattern(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public DiscardPattern WithId(Guid newId) { - return newId == id ? this : new DiscardPattern(newId, prefix, markers, type); + return newId == Id ? this : new DiscardPattern(newId, Prefix, Markers, Type); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public DiscardPattern WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new DiscardPattern(id, newPrefix, markers, type); + return newPrefix == Prefix ? this : new DiscardPattern(Id, newPrefix, Markers, Type); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public DiscardPattern WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new DiscardPattern(id, prefix, newMarkers, type); + return ReferenceEquals(newMarkers, Markers) ? this : new DiscardPattern(Id, Prefix, newMarkers, Type); } - public JavaType Type => type; + public JavaType Type { get; set; } = type; public DiscardPattern WithType(JavaType newType) { - return newType == type ? this : new DiscardPattern(id, prefix, markers, newType); + return newType == Type ? this : new DiscardPattern(Id, Prefix, Markers, newType); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.CSharp/Tree/DiscardVariableDesignation.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/DiscardVariableDesignation.g.cs index 1aa4f56d..7a6225af 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/DiscardVariableDesignation.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/DiscardVariableDesignation.g.cs @@ -48,29 +48,29 @@ J.Identifier discard return v.VisitDiscardVariableDesignation(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public DiscardVariableDesignation WithId(Guid newId) { - return newId == id ? this : new DiscardVariableDesignation(newId, prefix, markers, discard); + return newId == Id ? this : new DiscardVariableDesignation(newId, Prefix, Markers, Discard); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public DiscardVariableDesignation WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new DiscardVariableDesignation(id, newPrefix, markers, discard); + return newPrefix == Prefix ? this : new DiscardVariableDesignation(Id, newPrefix, Markers, Discard); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public DiscardVariableDesignation WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new DiscardVariableDesignation(id, prefix, newMarkers, discard); + return ReferenceEquals(newMarkers, Markers) ? this : new DiscardVariableDesignation(Id, Prefix, newMarkers, Discard); } - public J.Identifier Discard => discard; + public J.Identifier Discard { get; set; } = discard; public DiscardVariableDesignation WithDiscard(J.Identifier newDiscard) { - return ReferenceEquals(newDiscard, discard) ? this : new DiscardVariableDesignation(id, prefix, markers, newDiscard); + return ReferenceEquals(newDiscard, Discard) ? this : new DiscardVariableDesignation(Id, Prefix, Markers, newDiscard); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.CSharp/Tree/EnumDeclaration.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/EnumDeclaration.g.cs index 1fcea2f4..cec03d23 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/EnumDeclaration.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/EnumDeclaration.g.cs @@ -87,51 +87,51 @@ public PaddingHelper Padding return v.VisitEnumDeclaration(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public EnumDeclaration WithId(Guid newId) { - return newId == id ? this : new EnumDeclaration(newId, prefix, markers, attributeLists, modifiers, _name, _baseType, _members); + return newId == Id ? this : new EnumDeclaration(newId, Prefix, Markers, AttributeLists, Modifiers, _name, _baseType, _members); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public EnumDeclaration WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new EnumDeclaration(id, newPrefix, markers, attributeLists, modifiers, _name, _baseType, _members); + return newPrefix == Prefix ? this : new EnumDeclaration(Id, newPrefix, Markers, AttributeLists, Modifiers, _name, _baseType, _members); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public EnumDeclaration WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new EnumDeclaration(id, prefix, newMarkers, attributeLists, modifiers, _name, _baseType, _members); + return ReferenceEquals(newMarkers, Markers) ? this : new EnumDeclaration(Id, Prefix, newMarkers, AttributeLists, Modifiers, _name, _baseType, _members); } - public IList? AttributeLists => attributeLists; + public IList? AttributeLists { get; set; } = attributeLists; public EnumDeclaration WithAttributeLists(IList? newAttributeLists) { - return newAttributeLists == attributeLists ? this : new EnumDeclaration(id, prefix, markers, newAttributeLists, modifiers, _name, _baseType, _members); + return newAttributeLists == AttributeLists ? this : new EnumDeclaration(Id, Prefix, Markers, newAttributeLists, Modifiers, _name, _baseType, _members); } - public IList Modifiers => modifiers; + public IList Modifiers { get; set; } = modifiers; public EnumDeclaration WithModifiers(IList newModifiers) { - return newModifiers == modifiers ? this : new EnumDeclaration(id, prefix, markers, attributeLists, newModifiers, _name, _baseType, _members); + return newModifiers == Modifiers ? this : new EnumDeclaration(Id, Prefix, Markers, AttributeLists, newModifiers, _name, _baseType, _members); } - private readonly JLeftPadded _name = name; + private JLeftPadded _name = name; public J.Identifier Name => _name.Element; public EnumDeclaration WithName(J.Identifier newName) { return Padding.WithName(_name.WithElement(newName)); } - private readonly JLeftPadded? _baseType = baseType; + private JLeftPadded? _baseType = baseType; public TypeTree? BaseType => _baseType?.Element; public EnumDeclaration WithBaseType(TypeTree? newBaseType) { return Padding.WithBaseType(JLeftPadded.WithElement(_baseType, newBaseType)); } - private readonly JContainer? _members = members; + private JContainer? _members = members; public IList? Members => _members?.GetElements(); public EnumDeclaration WithMembers(IList? newMembers) @@ -140,25 +140,25 @@ public EnumDeclaration WithMembers(IList? newMembers) } public sealed record PaddingHelper(Cs.EnumDeclaration T) { - public JLeftPadded Name => T._name; + public JLeftPadded Name { get => T._name; set => T._name = value; } public Cs.EnumDeclaration WithName(JLeftPadded newName) { - return T._name == newName ? T : new Cs.EnumDeclaration(T.Id, T.Prefix, T.Markers, T.AttributeLists, T.Modifiers, newName, T._baseType, T._members); + return Name == newName ? T : new Cs.EnumDeclaration(T.Id, T.Prefix, T.Markers, T.AttributeLists, T.Modifiers, newName, T._baseType, T._members); } - public JLeftPadded? BaseType => T._baseType; + public JLeftPadded? BaseType { get => T._baseType; set => T._baseType = value; } public Cs.EnumDeclaration WithBaseType(JLeftPadded? newBaseType) { - return T._baseType == newBaseType ? T : new Cs.EnumDeclaration(T.Id, T.Prefix, T.Markers, T.AttributeLists, T.Modifiers, T._name, newBaseType, T._members); + return BaseType == newBaseType ? T : new Cs.EnumDeclaration(T.Id, T.Prefix, T.Markers, T.AttributeLists, T.Modifiers, T._name, newBaseType, T._members); } - public JContainer? Members => T._members; + public JContainer? Members { get => T._members; set => T._members = value; } public Cs.EnumDeclaration WithMembers(JContainer? newMembers) { - return T._members == newMembers ? T : new Cs.EnumDeclaration(T.Id, T.Prefix, T.Markers, T.AttributeLists, T.Modifiers, T._name, T._baseType, newMembers); + return Members == newMembers ? T : new Cs.EnumDeclaration(T.Id, T.Prefix, T.Markers, T.AttributeLists, T.Modifiers, T._name, T._baseType, newMembers); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/EnumMemberDeclaration.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/EnumMemberDeclaration.g.cs index 4d6ea5e1..07f89a38 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/EnumMemberDeclaration.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/EnumMemberDeclaration.g.cs @@ -80,37 +80,37 @@ public PaddingHelper Padding return v.VisitEnumMemberDeclaration(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public EnumMemberDeclaration WithId(Guid newId) { - return newId == id ? this : new EnumMemberDeclaration(newId, prefix, markers, attributeLists, name, _initializer); + return newId == Id ? this : new EnumMemberDeclaration(newId, Prefix, Markers, AttributeLists, Name, _initializer); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public EnumMemberDeclaration WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new EnumMemberDeclaration(id, newPrefix, markers, attributeLists, name, _initializer); + return newPrefix == Prefix ? this : new EnumMemberDeclaration(Id, newPrefix, Markers, AttributeLists, Name, _initializer); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public EnumMemberDeclaration WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new EnumMemberDeclaration(id, prefix, newMarkers, attributeLists, name, _initializer); + return ReferenceEquals(newMarkers, Markers) ? this : new EnumMemberDeclaration(Id, Prefix, newMarkers, AttributeLists, Name, _initializer); } - public IList AttributeLists => attributeLists; + public IList AttributeLists { get; set; } = attributeLists; public EnumMemberDeclaration WithAttributeLists(IList newAttributeLists) { - return newAttributeLists == attributeLists ? this : new EnumMemberDeclaration(id, prefix, markers, newAttributeLists, name, _initializer); + return newAttributeLists == AttributeLists ? this : new EnumMemberDeclaration(Id, Prefix, Markers, newAttributeLists, Name, _initializer); } - public J.Identifier Name => name; + public J.Identifier Name { get; set; } = name; public EnumMemberDeclaration WithName(J.Identifier newName) { - return ReferenceEquals(newName, name) ? this : new EnumMemberDeclaration(id, prefix, markers, attributeLists, newName, _initializer); + return ReferenceEquals(newName, Name) ? this : new EnumMemberDeclaration(Id, Prefix, Markers, AttributeLists, newName, _initializer); } - private readonly JLeftPadded? _initializer = initializer; + private JLeftPadded? _initializer = initializer; public Expression? Initializer => _initializer?.Element; public EnumMemberDeclaration WithInitializer(Expression? newInitializer) @@ -119,11 +119,11 @@ public EnumMemberDeclaration WithInitializer(Expression? newInitializer) } public sealed record PaddingHelper(Cs.EnumMemberDeclaration T) { - public JLeftPadded? Initializer => T._initializer; + public JLeftPadded? Initializer { get => T._initializer; set => T._initializer = value; } public Cs.EnumMemberDeclaration WithInitializer(JLeftPadded? newInitializer) { - return T._initializer == newInitializer ? T : new Cs.EnumMemberDeclaration(T.Id, T.Prefix, T.Markers, T.AttributeLists, T.Name, newInitializer); + return Initializer == newInitializer ? T : new Cs.EnumMemberDeclaration(T.Id, T.Prefix, T.Markers, T.AttributeLists, T.Name, newInitializer); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/EventDeclaration.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/EventDeclaration.g.cs index 44c1bd60..b23e050b 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/EventDeclaration.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/EventDeclaration.g.cs @@ -89,57 +89,57 @@ public PaddingHelper Padding return v.VisitEventDeclaration(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public EventDeclaration WithId(Guid newId) { - return newId == id ? this : new EventDeclaration(newId, prefix, markers, attributeLists, modifiers, _typeExpression, _interfaceSpecifier, name, _accessors); + return newId == Id ? this : new EventDeclaration(newId, Prefix, Markers, AttributeLists, Modifiers, _typeExpression, _interfaceSpecifier, Name, _accessors); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public EventDeclaration WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new EventDeclaration(id, newPrefix, markers, attributeLists, modifiers, _typeExpression, _interfaceSpecifier, name, _accessors); + return newPrefix == Prefix ? this : new EventDeclaration(Id, newPrefix, Markers, AttributeLists, Modifiers, _typeExpression, _interfaceSpecifier, Name, _accessors); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public EventDeclaration WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new EventDeclaration(id, prefix, newMarkers, attributeLists, modifiers, _typeExpression, _interfaceSpecifier, name, _accessors); + return ReferenceEquals(newMarkers, Markers) ? this : new EventDeclaration(Id, Prefix, newMarkers, AttributeLists, Modifiers, _typeExpression, _interfaceSpecifier, Name, _accessors); } - public IList AttributeLists => attributeLists; + public IList AttributeLists { get; set; } = attributeLists; public EventDeclaration WithAttributeLists(IList newAttributeLists) { - return newAttributeLists == attributeLists ? this : new EventDeclaration(id, prefix, markers, newAttributeLists, modifiers, _typeExpression, _interfaceSpecifier, name, _accessors); + return newAttributeLists == AttributeLists ? this : new EventDeclaration(Id, Prefix, Markers, newAttributeLists, Modifiers, _typeExpression, _interfaceSpecifier, Name, _accessors); } - public IList Modifiers => modifiers; + public IList Modifiers { get; set; } = modifiers; public EventDeclaration WithModifiers(IList newModifiers) { - return newModifiers == modifiers ? this : new EventDeclaration(id, prefix, markers, attributeLists, newModifiers, _typeExpression, _interfaceSpecifier, name, _accessors); + return newModifiers == Modifiers ? this : new EventDeclaration(Id, Prefix, Markers, AttributeLists, newModifiers, _typeExpression, _interfaceSpecifier, Name, _accessors); } - private readonly JLeftPadded _typeExpression = typeExpression; + private JLeftPadded _typeExpression = typeExpression; public TypeTree TypeExpression => _typeExpression.Element; public EventDeclaration WithTypeExpression(TypeTree newTypeExpression) { return Padding.WithTypeExpression(_typeExpression.WithElement(newTypeExpression)); } - private readonly JRightPadded? _interfaceSpecifier = interfaceSpecifier; + private JRightPadded? _interfaceSpecifier = interfaceSpecifier; public TypeTree? InterfaceSpecifier => _interfaceSpecifier?.Element; public EventDeclaration WithInterfaceSpecifier(TypeTree? newInterfaceSpecifier) { return Padding.WithInterfaceSpecifier(JRightPadded.WithElement(_interfaceSpecifier, newInterfaceSpecifier)); } - public J.Identifier Name => name; + public J.Identifier Name { get; set; } = name; public EventDeclaration WithName(J.Identifier newName) { - return ReferenceEquals(newName, name) ? this : new EventDeclaration(id, prefix, markers, attributeLists, modifiers, _typeExpression, _interfaceSpecifier, newName, _accessors); + return ReferenceEquals(newName, Name) ? this : new EventDeclaration(Id, Prefix, Markers, AttributeLists, Modifiers, _typeExpression, _interfaceSpecifier, newName, _accessors); } - private readonly JContainer? _accessors = accessors; + private JContainer? _accessors = accessors; public IList? Accessors => _accessors?.GetElements(); public EventDeclaration WithAccessors(IList? newAccessors) @@ -148,25 +148,25 @@ public EventDeclaration WithAccessors(IList? newAccessors) } public sealed record PaddingHelper(Cs.EventDeclaration T) { - public JLeftPadded TypeExpression => T._typeExpression; + public JLeftPadded TypeExpression { get => T._typeExpression; set => T._typeExpression = value; } public Cs.EventDeclaration WithTypeExpression(JLeftPadded newTypeExpression) { - return T._typeExpression == newTypeExpression ? T : new Cs.EventDeclaration(T.Id, T.Prefix, T.Markers, T.AttributeLists, T.Modifiers, newTypeExpression, T._interfaceSpecifier, T.Name, T._accessors); + return TypeExpression == newTypeExpression ? T : new Cs.EventDeclaration(T.Id, T.Prefix, T.Markers, T.AttributeLists, T.Modifiers, newTypeExpression, T._interfaceSpecifier, T.Name, T._accessors); } - public JRightPadded? InterfaceSpecifier => T._interfaceSpecifier; + public JRightPadded? InterfaceSpecifier { get => T._interfaceSpecifier; set => T._interfaceSpecifier = value; } public Cs.EventDeclaration WithInterfaceSpecifier(JRightPadded? newInterfaceSpecifier) { - return T._interfaceSpecifier == newInterfaceSpecifier ? T : new Cs.EventDeclaration(T.Id, T.Prefix, T.Markers, T.AttributeLists, T.Modifiers, T._typeExpression, newInterfaceSpecifier, T.Name, T._accessors); + return InterfaceSpecifier == newInterfaceSpecifier ? T : new Cs.EventDeclaration(T.Id, T.Prefix, T.Markers, T.AttributeLists, T.Modifiers, T._typeExpression, newInterfaceSpecifier, T.Name, T._accessors); } - public JContainer? Accessors => T._accessors; + public JContainer? Accessors { get => T._accessors; set => T._accessors = value; } public Cs.EventDeclaration WithAccessors(JContainer? newAccessors) { - return T._accessors == newAccessors ? T : new Cs.EventDeclaration(T.Id, T.Prefix, T.Markers, T.AttributeLists, T.Modifiers, T._typeExpression, T._interfaceSpecifier, T.Name, newAccessors); + return Accessors == newAccessors ? T : new Cs.EventDeclaration(T.Id, T.Prefix, T.Markers, T.AttributeLists, T.Modifiers, T._typeExpression, T._interfaceSpecifier, T.Name, newAccessors); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/ExpressionStatement.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/ExpressionStatement.g.cs index e79c5516..1fee9665 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/ExpressionStatement.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/ExpressionStatement.g.cs @@ -64,25 +64,25 @@ public PaddingHelper Padding return v.VisitExpressionStatement(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public ExpressionStatement WithId(Guid newId) { - return newId == id ? this : new ExpressionStatement(newId, prefix, markers, _expression); + return newId == Id ? this : new ExpressionStatement(newId, Prefix, Markers, _expression); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public ExpressionStatement WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new ExpressionStatement(id, newPrefix, markers, _expression); + return newPrefix == Prefix ? this : new ExpressionStatement(Id, newPrefix, Markers, _expression); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public ExpressionStatement WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new ExpressionStatement(id, prefix, newMarkers, _expression); + return ReferenceEquals(newMarkers, Markers) ? this : new ExpressionStatement(Id, Prefix, newMarkers, _expression); } - private readonly JRightPadded _expression = expression; + private JRightPadded _expression = expression; public Expression Expression => _expression.Element; public ExpressionStatement WithExpression(Expression newExpression) @@ -91,11 +91,11 @@ public ExpressionStatement WithExpression(Expression newExpression) } public sealed record PaddingHelper(Cs.ExpressionStatement T) { - public JRightPadded Expression => T._expression; + public JRightPadded Expression { get => T._expression; set => T._expression = value; } public Cs.ExpressionStatement WithExpression(JRightPadded newExpression) { - return T._expression == newExpression ? T : new Cs.ExpressionStatement(T.Id, T.Prefix, T.Markers, newExpression); + return Expression == newExpression ? T : new Cs.ExpressionStatement(T.Id, T.Prefix, T.Markers, newExpression); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/ExternAlias.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/ExternAlias.g.cs index 20915357..0741f481 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/ExternAlias.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/ExternAlias.g.cs @@ -64,25 +64,25 @@ public PaddingHelper Padding return v.VisitExternAlias(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public ExternAlias WithId(Guid newId) { - return newId == id ? this : new ExternAlias(newId, prefix, markers, _identifier); + return newId == Id ? this : new ExternAlias(newId, Prefix, Markers, _identifier); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public ExternAlias WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new ExternAlias(id, newPrefix, markers, _identifier); + return newPrefix == Prefix ? this : new ExternAlias(Id, newPrefix, Markers, _identifier); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public ExternAlias WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new ExternAlias(id, prefix, newMarkers, _identifier); + return ReferenceEquals(newMarkers, Markers) ? this : new ExternAlias(Id, Prefix, newMarkers, _identifier); } - private readonly JLeftPadded _identifier = identifier; + private JLeftPadded _identifier = identifier; public J.Identifier Identifier => _identifier.Element; public ExternAlias WithIdentifier(J.Identifier newIdentifier) @@ -91,11 +91,11 @@ public ExternAlias WithIdentifier(J.Identifier newIdentifier) } public sealed record PaddingHelper(Cs.ExternAlias T) { - public JLeftPadded Identifier => T._identifier; + public JLeftPadded Identifier { get => T._identifier; set => T._identifier = value; } public Cs.ExternAlias WithIdentifier(JLeftPadded newIdentifier) { - return T._identifier == newIdentifier ? T : new Cs.ExternAlias(T.Id, T.Prefix, T.Markers, newIdentifier); + return Identifier == newIdentifier ? T : new Cs.ExternAlias(T.Id, T.Prefix, T.Markers, newIdentifier); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/FileScopeNamespaceDeclaration.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/FileScopeNamespaceDeclaration.g.cs index 91c86db4..4df8d92f 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/FileScopeNamespaceDeclaration.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/FileScopeNamespaceDeclaration.g.cs @@ -67,46 +67,46 @@ public PaddingHelper Padding return v.VisitFileScopeNamespaceDeclaration(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public FileScopeNamespaceDeclaration WithId(Guid newId) { - return newId == id ? this : new FileScopeNamespaceDeclaration(newId, prefix, markers, _name, _externs, _usings, _members); + return newId == Id ? this : new FileScopeNamespaceDeclaration(newId, Prefix, Markers, _name, _externs, _usings, _members); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public FileScopeNamespaceDeclaration WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new FileScopeNamespaceDeclaration(id, newPrefix, markers, _name, _externs, _usings, _members); + return newPrefix == Prefix ? this : new FileScopeNamespaceDeclaration(Id, newPrefix, Markers, _name, _externs, _usings, _members); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public FileScopeNamespaceDeclaration WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new FileScopeNamespaceDeclaration(id, prefix, newMarkers, _name, _externs, _usings, _members); + return ReferenceEquals(newMarkers, Markers) ? this : new FileScopeNamespaceDeclaration(Id, Prefix, newMarkers, _name, _externs, _usings, _members); } - private readonly JRightPadded _name = name; + private JRightPadded _name = name; public Expression Name => _name.Element; public FileScopeNamespaceDeclaration WithName(Expression newName) { return Padding.WithName(_name.WithElement(newName)); } - private readonly IList> _externs = externs; + private IList> _externs = externs; public IList Externs => _externs.Elements(); public FileScopeNamespaceDeclaration WithExterns(IList newExterns) { return Padding.WithExterns(_externs.WithElements(newExterns)); } - private readonly IList> _usings = usings; + private IList> _usings = usings; public IList Usings => _usings.Elements(); public FileScopeNamespaceDeclaration WithUsings(IList newUsings) { return Padding.WithUsings(_usings.WithElements(newUsings)); } - private readonly IList> _members = members; + private IList> _members = members; public IList Members => _members.Elements(); public FileScopeNamespaceDeclaration WithMembers(IList newMembers) @@ -115,32 +115,32 @@ public FileScopeNamespaceDeclaration WithMembers(IList newMembers) } public sealed record PaddingHelper(Cs.FileScopeNamespaceDeclaration T) { - public JRightPadded Name => T._name; + public JRightPadded Name { get => T._name; set => T._name = value; } public Cs.FileScopeNamespaceDeclaration WithName(JRightPadded newName) { - return T._name == newName ? T : new Cs.FileScopeNamespaceDeclaration(T.Id, T.Prefix, T.Markers, newName, T._externs, T._usings, T._members); + return Name == newName ? T : new Cs.FileScopeNamespaceDeclaration(T.Id, T.Prefix, T.Markers, newName, T._externs, T._usings, T._members); } - public IList> Externs => T._externs; + public IList> Externs { get => T._externs; set => T._externs = value; } public Cs.FileScopeNamespaceDeclaration WithExterns(IList> newExterns) { - return T._externs == newExterns ? T : new Cs.FileScopeNamespaceDeclaration(T.Id, T.Prefix, T.Markers, T._name, newExterns, T._usings, T._members); + return Externs == newExterns ? T : new Cs.FileScopeNamespaceDeclaration(T.Id, T.Prefix, T.Markers, T._name, newExterns, T._usings, T._members); } - public IList> Usings => T._usings; + public IList> Usings { get => T._usings; set => T._usings = value; } public Cs.FileScopeNamespaceDeclaration WithUsings(IList> newUsings) { - return T._usings == newUsings ? T : new Cs.FileScopeNamespaceDeclaration(T.Id, T.Prefix, T.Markers, T._name, T._externs, newUsings, T._members); + return Usings == newUsings ? T : new Cs.FileScopeNamespaceDeclaration(T.Id, T.Prefix, T.Markers, T._name, T._externs, newUsings, T._members); } - public IList> Members => T._members; + public IList> Members { get => T._members; set => T._members = value; } public Cs.FileScopeNamespaceDeclaration WithMembers(IList> newMembers) { - return T._members == newMembers ? T : new Cs.FileScopeNamespaceDeclaration(T.Id, T.Prefix, T.Markers, T._name, T._externs, T._usings, newMembers); + return Members == newMembers ? T : new Cs.FileScopeNamespaceDeclaration(T.Id, T.Prefix, T.Markers, T._name, T._externs, T._usings, newMembers); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/FixedStatement.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/FixedStatement.g.cs index 7ec396c7..bd06c6a1 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/FixedStatement.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/FixedStatement.g.cs @@ -65,35 +65,35 @@ J.Block block return v.VisitFixedStatement(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public FixedStatement WithId(Guid newId) { - return newId == id ? this : new FixedStatement(newId, prefix, markers, declarations, block); + return newId == Id ? this : new FixedStatement(newId, Prefix, Markers, Declarations, Block); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public FixedStatement WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new FixedStatement(id, newPrefix, markers, declarations, block); + return newPrefix == Prefix ? this : new FixedStatement(Id, newPrefix, Markers, Declarations, Block); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public FixedStatement WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new FixedStatement(id, prefix, newMarkers, declarations, block); + return ReferenceEquals(newMarkers, Markers) ? this : new FixedStatement(Id, Prefix, newMarkers, Declarations, Block); } - public J.ControlParentheses Declarations => declarations; + public J.ControlParentheses Declarations { get; set; } = declarations; public FixedStatement WithDeclarations(J.ControlParentheses newDeclarations) { - return ReferenceEquals(newDeclarations, declarations) ? this : new FixedStatement(id, prefix, markers, newDeclarations, block); + return ReferenceEquals(newDeclarations, Declarations) ? this : new FixedStatement(Id, Prefix, Markers, newDeclarations, Block); } - public J.Block Block => block; + public J.Block Block { get; set; } = block; public FixedStatement WithBlock(J.Block newBlock) { - return ReferenceEquals(newBlock, block) ? this : new FixedStatement(id, prefix, markers, declarations, newBlock); + return ReferenceEquals(newBlock, Block) ? this : new FixedStatement(Id, Prefix, Markers, Declarations, newBlock); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.CSharp/Tree/ForEachVariableLoop.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/ForEachVariableLoop.g.cs index 0e5e65fa..6aaa1482 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/ForEachVariableLoop.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/ForEachVariableLoop.g.cs @@ -65,31 +65,31 @@ public PaddingHelper Padding return v.VisitForEachVariableLoop(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public ForEachVariableLoop WithId(Guid newId) { - return newId == id ? this : new ForEachVariableLoop(newId, prefix, markers, controlElement, _body); + return newId == Id ? this : new ForEachVariableLoop(newId, Prefix, Markers, ControlElement, _body); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public ForEachVariableLoop WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new ForEachVariableLoop(id, newPrefix, markers, controlElement, _body); + return newPrefix == Prefix ? this : new ForEachVariableLoop(Id, newPrefix, Markers, ControlElement, _body); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public ForEachVariableLoop WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new ForEachVariableLoop(id, prefix, newMarkers, controlElement, _body); + return ReferenceEquals(newMarkers, Markers) ? this : new ForEachVariableLoop(Id, Prefix, newMarkers, ControlElement, _body); } - public Control ControlElement => controlElement; + public Control ControlElement { get; set; } = controlElement; public ForEachVariableLoop WithControlElement(Control newControlElement) { - return ReferenceEquals(newControlElement, controlElement) ? this : new ForEachVariableLoop(id, prefix, markers, newControlElement, _body); + return ReferenceEquals(newControlElement, ControlElement) ? this : new ForEachVariableLoop(Id, Prefix, Markers, newControlElement, _body); } - private readonly JRightPadded _body = body; + private JRightPadded _body = body; public Statement Body => _body.Element; public ForEachVariableLoop WithBody(Statement newBody) @@ -137,32 +137,32 @@ public PaddingHelper Padding return v.VisitForEachVariableLoopControl(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Control WithId(Guid newId) { - return newId == id ? this : new Control(newId, prefix, markers, _variable, _iterable); + return newId == Id ? this : new Control(newId, Prefix, Markers, _variable, _iterable); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Control WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Control(id, newPrefix, markers, _variable, _iterable); + return newPrefix == Prefix ? this : new Control(Id, newPrefix, Markers, _variable, _iterable); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Control WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Control(id, prefix, newMarkers, _variable, _iterable); + return ReferenceEquals(newMarkers, Markers) ? this : new Control(Id, Prefix, newMarkers, _variable, _iterable); } - private readonly JRightPadded _variable = variable; + private JRightPadded _variable = variable; public Expression Variable => _variable.Element; public Control WithVariable(Expression newVariable) { return Padding.WithVariable(_variable.WithElement(newVariable)); } - private readonly JRightPadded _iterable = iterable; + private JRightPadded _iterable = iterable; public Expression Iterable => _iterable.Element; public Control WithIterable(Expression newIterable) @@ -171,18 +171,18 @@ public Control WithIterable(Expression newIterable) } public sealed record PaddingHelper(Cs.ForEachVariableLoop.Control T) { - public JRightPadded Variable => T._variable; + public JRightPadded Variable { get => T._variable; set => T._variable = value; } public Cs.ForEachVariableLoop.Control WithVariable(JRightPadded newVariable) { - return T._variable == newVariable ? T : new Cs.ForEachVariableLoop.Control(T.Id, T.Prefix, T.Markers, newVariable, T._iterable); + return Variable == newVariable ? T : new Cs.ForEachVariableLoop.Control(T.Id, T.Prefix, T.Markers, newVariable, T._iterable); } - public JRightPadded Iterable => T._iterable; + public JRightPadded Iterable { get => T._iterable; set => T._iterable = value; } public Cs.ForEachVariableLoop.Control WithIterable(JRightPadded newIterable) { - return T._iterable == newIterable ? T : new Cs.ForEachVariableLoop.Control(T.Id, T.Prefix, T.Markers, T._variable, newIterable); + return Iterable == newIterable ? T : new Cs.ForEachVariableLoop.Control(T.Id, T.Prefix, T.Markers, T._variable, newIterable); } } @@ -204,11 +204,11 @@ public override int GetHashCode() } public sealed record PaddingHelper(Cs.ForEachVariableLoop T) { - public JRightPadded Body => T._body; + public JRightPadded Body { get => T._body; set => T._body = value; } public Cs.ForEachVariableLoop WithBody(JRightPadded newBody) { - return T._body == newBody ? T : new Cs.ForEachVariableLoop(T.Id, T.Prefix, T.Markers, T.ControlElement, newBody); + return Body == newBody ? T : new Cs.ForEachVariableLoop(T.Id, T.Prefix, T.Markers, T.ControlElement, newBody); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/FromClause.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/FromClause.g.cs index 22d0fa26..3c2accf8 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/FromClause.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/FromClause.g.cs @@ -82,50 +82,50 @@ public PaddingHelper Padding return v.VisitFromClause(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public FromClause WithId(Guid newId) { - return newId == id ? this : new FromClause(newId, prefix, markers, typeIdentifier, _identifier, expression); + return newId == Id ? this : new FromClause(newId, Prefix, Markers, TypeIdentifier, _identifier, Expression); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public FromClause WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new FromClause(id, newPrefix, markers, typeIdentifier, _identifier, expression); + return newPrefix == Prefix ? this : new FromClause(Id, newPrefix, Markers, TypeIdentifier, _identifier, Expression); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public FromClause WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new FromClause(id, prefix, newMarkers, typeIdentifier, _identifier, expression); + return ReferenceEquals(newMarkers, Markers) ? this : new FromClause(Id, Prefix, newMarkers, TypeIdentifier, _identifier, Expression); } - public TypeTree? TypeIdentifier => typeIdentifier; + public TypeTree? TypeIdentifier { get; set; } = typeIdentifier; public FromClause WithTypeIdentifier(TypeTree? newTypeIdentifier) { - return ReferenceEquals(newTypeIdentifier, typeIdentifier) ? this : new FromClause(id, prefix, markers, newTypeIdentifier, _identifier, expression); + return ReferenceEquals(newTypeIdentifier, TypeIdentifier) ? this : new FromClause(Id, Prefix, Markers, newTypeIdentifier, _identifier, Expression); } - private readonly JRightPadded _identifier = identifier; + private JRightPadded _identifier = identifier; public J.Identifier Identifier => _identifier.Element; public FromClause WithIdentifier(J.Identifier newIdentifier) { return Padding.WithIdentifier(_identifier.WithElement(newIdentifier)); } - public Expression Expression => expression; + public Expression Expression { get; set; } = expression; public FromClause WithExpression(Expression newExpression) { - return ReferenceEquals(newExpression, expression) ? this : new FromClause(id, prefix, markers, typeIdentifier, _identifier, newExpression); + return ReferenceEquals(newExpression, Expression) ? this : new FromClause(Id, Prefix, Markers, TypeIdentifier, _identifier, newExpression); } public sealed record PaddingHelper(Cs.FromClause T) { - public JRightPadded Identifier => T._identifier; + public JRightPadded Identifier { get => T._identifier; set => T._identifier = value; } public Cs.FromClause WithIdentifier(JRightPadded newIdentifier) { - return T._identifier == newIdentifier ? T : new Cs.FromClause(T.Id, T.Prefix, T.Markers, T.TypeIdentifier, newIdentifier, T.Expression); + return Identifier == newIdentifier ? T : new Cs.FromClause(T.Id, T.Prefix, T.Markers, T.TypeIdentifier, newIdentifier, T.Expression); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/GotoStatement.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/GotoStatement.g.cs index 62774393..7228dd1c 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/GotoStatement.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/GotoStatement.g.cs @@ -57,35 +57,35 @@ public partial class GotoStatement( return v.VisitGotoStatement(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public GotoStatement WithId(Guid newId) { - return newId == id ? this : new GotoStatement(newId, prefix, markers, caseOrDefaultKeyword, target); + return newId == Id ? this : new GotoStatement(newId, Prefix, Markers, CaseOrDefaultKeyword, Target); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public GotoStatement WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new GotoStatement(id, newPrefix, markers, caseOrDefaultKeyword, target); + return newPrefix == Prefix ? this : new GotoStatement(Id, newPrefix, Markers, CaseOrDefaultKeyword, Target); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public GotoStatement WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new GotoStatement(id, prefix, newMarkers, caseOrDefaultKeyword, target); + return ReferenceEquals(newMarkers, Markers) ? this : new GotoStatement(Id, Prefix, newMarkers, CaseOrDefaultKeyword, Target); } - public Cs.Keyword? CaseOrDefaultKeyword => caseOrDefaultKeyword; + public Cs.Keyword? CaseOrDefaultKeyword { get; set; } = caseOrDefaultKeyword; public GotoStatement WithCaseOrDefaultKeyword(Cs.Keyword? newCaseOrDefaultKeyword) { - return ReferenceEquals(newCaseOrDefaultKeyword, caseOrDefaultKeyword) ? this : new GotoStatement(id, prefix, markers, newCaseOrDefaultKeyword, target); + return ReferenceEquals(newCaseOrDefaultKeyword, CaseOrDefaultKeyword) ? this : new GotoStatement(Id, Prefix, Markers, newCaseOrDefaultKeyword, Target); } - public Expression? Target => target; + public Expression? Target { get; set; } = target; public GotoStatement WithTarget(Expression? newTarget) { - return ReferenceEquals(newTarget, target) ? this : new GotoStatement(id, prefix, markers, caseOrDefaultKeyword, newTarget); + return ReferenceEquals(newTarget, Target) ? this : new GotoStatement(Id, Prefix, Markers, CaseOrDefaultKeyword, newTarget); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.CSharp/Tree/GroupClause.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/GroupClause.g.cs index 158ba21c..048be6a7 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/GroupClause.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/GroupClause.g.cs @@ -74,44 +74,44 @@ public PaddingHelper Padding return v.VisitGroupClause(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public GroupClause WithId(Guid newId) { - return newId == id ? this : new GroupClause(newId, prefix, markers, _groupExpression, key); + return newId == Id ? this : new GroupClause(newId, Prefix, Markers, _groupExpression, Key); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public GroupClause WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new GroupClause(id, newPrefix, markers, _groupExpression, key); + return newPrefix == Prefix ? this : new GroupClause(Id, newPrefix, Markers, _groupExpression, Key); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public GroupClause WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new GroupClause(id, prefix, newMarkers, _groupExpression, key); + return ReferenceEquals(newMarkers, Markers) ? this : new GroupClause(Id, Prefix, newMarkers, _groupExpression, Key); } - private readonly JRightPadded _groupExpression = groupExpression; + private JRightPadded _groupExpression = groupExpression; public Expression GroupExpression => _groupExpression.Element; public GroupClause WithGroupExpression(Expression newGroupExpression) { return Padding.WithGroupExpression(_groupExpression.WithElement(newGroupExpression)); } - public Expression Key => key; + public Expression Key { get; set; } = key; public GroupClause WithKey(Expression newKey) { - return ReferenceEquals(newKey, key) ? this : new GroupClause(id, prefix, markers, _groupExpression, newKey); + return ReferenceEquals(newKey, Key) ? this : new GroupClause(Id, Prefix, Markers, _groupExpression, newKey); } public sealed record PaddingHelper(Cs.GroupClause T) { - public JRightPadded GroupExpression => T._groupExpression; + public JRightPadded GroupExpression { get => T._groupExpression; set => T._groupExpression = value; } public Cs.GroupClause WithGroupExpression(JRightPadded newGroupExpression) { - return T._groupExpression == newGroupExpression ? T : new Cs.GroupClause(T.Id, T.Prefix, T.Markers, newGroupExpression, T.Key); + return GroupExpression == newGroupExpression ? T : new Cs.GroupClause(T.Id, T.Prefix, T.Markers, newGroupExpression, T.Key); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/ImplicitElementAccess.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/ImplicitElementAccess.g.cs index 47c1607c..a6a40773 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/ImplicitElementAccess.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/ImplicitElementAccess.g.cs @@ -84,25 +84,25 @@ public PaddingHelper Padding return v.VisitImplicitElementAccess(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public ImplicitElementAccess WithId(Guid newId) { - return newId == id ? this : new ImplicitElementAccess(newId, prefix, markers, _argumentList); + return newId == Id ? this : new ImplicitElementAccess(newId, Prefix, Markers, _argumentList); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public ImplicitElementAccess WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new ImplicitElementAccess(id, newPrefix, markers, _argumentList); + return newPrefix == Prefix ? this : new ImplicitElementAccess(Id, newPrefix, Markers, _argumentList); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public ImplicitElementAccess WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new ImplicitElementAccess(id, prefix, newMarkers, _argumentList); + return ReferenceEquals(newMarkers, Markers) ? this : new ImplicitElementAccess(Id, Prefix, newMarkers, _argumentList); } - private readonly JContainer _argumentList = argumentList; + private JContainer _argumentList = argumentList; public IList ArgumentList => _argumentList.GetElements(); public ImplicitElementAccess WithArgumentList(IList newArgumentList) @@ -111,11 +111,11 @@ public ImplicitElementAccess WithArgumentList(IList newArgumentList } public sealed record PaddingHelper(Cs.ImplicitElementAccess T) { - public JContainer ArgumentList => T._argumentList; + public JContainer ArgumentList { get => T._argumentList; set => T._argumentList = value; } public Cs.ImplicitElementAccess WithArgumentList(JContainer newArgumentList) { - return T._argumentList == newArgumentList ? T : new Cs.ImplicitElementAccess(T.Id, T.Prefix, T.Markers, newArgumentList); + return ArgumentList == newArgumentList ? T : new Cs.ImplicitElementAccess(T.Id, T.Prefix, T.Markers, newArgumentList); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/IndexerDeclaration.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/IndexerDeclaration.g.cs index 54b9f9c6..465693aa 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/IndexerDeclaration.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/IndexerDeclaration.g.cs @@ -85,90 +85,90 @@ public PaddingHelper Padding return v.VisitIndexerDeclaration(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public IndexerDeclaration WithId(Guid newId) { - return newId == id ? this : new IndexerDeclaration(newId, prefix, markers, modifiers, typeExpression, _explicitInterfaceSpecifier, indexer, _parameters, _expressionBody, accessors); + return newId == Id ? this : new IndexerDeclaration(newId, Prefix, Markers, Modifiers, TypeExpression, _explicitInterfaceSpecifier, Indexer, _parameters, _expressionBody, Accessors); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public IndexerDeclaration WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new IndexerDeclaration(id, newPrefix, markers, modifiers, typeExpression, _explicitInterfaceSpecifier, indexer, _parameters, _expressionBody, accessors); + return newPrefix == Prefix ? this : new IndexerDeclaration(Id, newPrefix, Markers, Modifiers, TypeExpression, _explicitInterfaceSpecifier, Indexer, _parameters, _expressionBody, Accessors); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public IndexerDeclaration WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new IndexerDeclaration(id, prefix, newMarkers, modifiers, typeExpression, _explicitInterfaceSpecifier, indexer, _parameters, _expressionBody, accessors); + return ReferenceEquals(newMarkers, Markers) ? this : new IndexerDeclaration(Id, Prefix, newMarkers, Modifiers, TypeExpression, _explicitInterfaceSpecifier, Indexer, _parameters, _expressionBody, Accessors); } - public IList Modifiers => modifiers; + public IList Modifiers { get; set; } = modifiers; public IndexerDeclaration WithModifiers(IList newModifiers) { - return newModifiers == modifiers ? this : new IndexerDeclaration(id, prefix, markers, newModifiers, typeExpression, _explicitInterfaceSpecifier, indexer, _parameters, _expressionBody, accessors); + return newModifiers == Modifiers ? this : new IndexerDeclaration(Id, Prefix, Markers, newModifiers, TypeExpression, _explicitInterfaceSpecifier, Indexer, _parameters, _expressionBody, Accessors); } - public TypeTree TypeExpression => typeExpression; + public TypeTree TypeExpression { get; set; } = typeExpression; public IndexerDeclaration WithTypeExpression(TypeTree newTypeExpression) { - return ReferenceEquals(newTypeExpression, typeExpression) ? this : new IndexerDeclaration(id, prefix, markers, modifiers, newTypeExpression, _explicitInterfaceSpecifier, indexer, _parameters, _expressionBody, accessors); + return ReferenceEquals(newTypeExpression, TypeExpression) ? this : new IndexerDeclaration(Id, Prefix, Markers, Modifiers, newTypeExpression, _explicitInterfaceSpecifier, Indexer, _parameters, _expressionBody, Accessors); } - private readonly JRightPadded? _explicitInterfaceSpecifier = explicitInterfaceSpecifier; + private JRightPadded? _explicitInterfaceSpecifier = explicitInterfaceSpecifier; public TypeTree? ExplicitInterfaceSpecifier => _explicitInterfaceSpecifier?.Element; public IndexerDeclaration WithExplicitInterfaceSpecifier(TypeTree? newExplicitInterfaceSpecifier) { return Padding.WithExplicitInterfaceSpecifier(JRightPadded.WithElement(_explicitInterfaceSpecifier, newExplicitInterfaceSpecifier)); } - public Expression Indexer => indexer; + public Expression Indexer { get; set; } = indexer; public IndexerDeclaration WithIndexer(Expression newIndexer) { - return ReferenceEquals(newIndexer, indexer) ? this : new IndexerDeclaration(id, prefix, markers, modifiers, typeExpression, _explicitInterfaceSpecifier, newIndexer, _parameters, _expressionBody, accessors); + return ReferenceEquals(newIndexer, Indexer) ? this : new IndexerDeclaration(Id, Prefix, Markers, Modifiers, TypeExpression, _explicitInterfaceSpecifier, newIndexer, _parameters, _expressionBody, Accessors); } - private readonly JContainer _parameters = parameters; + private JContainer _parameters = parameters; public IList Parameters => _parameters.GetElements(); public IndexerDeclaration WithParameters(IList newParameters) { return Padding.WithParameters(JContainer.WithElements(_parameters, newParameters)); } - private readonly JLeftPadded? _expressionBody = expressionBody; + private JLeftPadded? _expressionBody = expressionBody; public Expression? ExpressionBody => _expressionBody?.Element; public IndexerDeclaration WithExpressionBody(Expression? newExpressionBody) { return Padding.WithExpressionBody(JLeftPadded.WithElement(_expressionBody, newExpressionBody)); } - public J.Block? Accessors => accessors; + public J.Block? Accessors { get; set; } = accessors; public IndexerDeclaration WithAccessors(J.Block? newAccessors) { - return ReferenceEquals(newAccessors, accessors) ? this : new IndexerDeclaration(id, prefix, markers, modifiers, typeExpression, _explicitInterfaceSpecifier, indexer, _parameters, _expressionBody, newAccessors); + return ReferenceEquals(newAccessors, Accessors) ? this : new IndexerDeclaration(Id, Prefix, Markers, Modifiers, TypeExpression, _explicitInterfaceSpecifier, Indexer, _parameters, _expressionBody, newAccessors); } public sealed record PaddingHelper(Cs.IndexerDeclaration T) { - public JRightPadded? ExplicitInterfaceSpecifier => T._explicitInterfaceSpecifier; + public JRightPadded? ExplicitInterfaceSpecifier { get => T._explicitInterfaceSpecifier; set => T._explicitInterfaceSpecifier = value; } public Cs.IndexerDeclaration WithExplicitInterfaceSpecifier(JRightPadded? newExplicitInterfaceSpecifier) { - return T._explicitInterfaceSpecifier == newExplicitInterfaceSpecifier ? T : new Cs.IndexerDeclaration(T.Id, T.Prefix, T.Markers, T.Modifiers, T.TypeExpression, newExplicitInterfaceSpecifier, T.Indexer, T._parameters, T._expressionBody, T.Accessors); + return ExplicitInterfaceSpecifier == newExplicitInterfaceSpecifier ? T : new Cs.IndexerDeclaration(T.Id, T.Prefix, T.Markers, T.Modifiers, T.TypeExpression, newExplicitInterfaceSpecifier, T.Indexer, T._parameters, T._expressionBody, T.Accessors); } - public JContainer Parameters => T._parameters; + public JContainer Parameters { get => T._parameters; set => T._parameters = value; } public Cs.IndexerDeclaration WithParameters(JContainer newParameters) { - return T._parameters == newParameters ? T : new Cs.IndexerDeclaration(T.Id, T.Prefix, T.Markers, T.Modifiers, T.TypeExpression, T._explicitInterfaceSpecifier, T.Indexer, newParameters, T._expressionBody, T.Accessors); + return Parameters == newParameters ? T : new Cs.IndexerDeclaration(T.Id, T.Prefix, T.Markers, T.Modifiers, T.TypeExpression, T._explicitInterfaceSpecifier, T.Indexer, newParameters, T._expressionBody, T.Accessors); } - public JLeftPadded? ExpressionBody => T._expressionBody; + public JLeftPadded? ExpressionBody { get => T._expressionBody; set => T._expressionBody = value; } public Cs.IndexerDeclaration WithExpressionBody(JLeftPadded? newExpressionBody) { - return T._expressionBody == newExpressionBody ? T : new Cs.IndexerDeclaration(T.Id, T.Prefix, T.Markers, T.Modifiers, T.TypeExpression, T._explicitInterfaceSpecifier, T.Indexer, T._parameters, newExpressionBody, T.Accessors); + return ExpressionBody == newExpressionBody ? T : new Cs.IndexerDeclaration(T.Id, T.Prefix, T.Markers, T.Modifiers, T.TypeExpression, T._explicitInterfaceSpecifier, T.Indexer, T._parameters, newExpressionBody, T.Accessors); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/InitializerExpression.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/InitializerExpression.g.cs index 72f230cc..2e94e932 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/InitializerExpression.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/InitializerExpression.g.cs @@ -78,25 +78,25 @@ public PaddingHelper Padding return v.VisitInitializerExpression(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public InitializerExpression WithId(Guid newId) { - return newId == id ? this : new InitializerExpression(newId, prefix, markers, _expressions); + return newId == Id ? this : new InitializerExpression(newId, Prefix, Markers, _expressions); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public InitializerExpression WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new InitializerExpression(id, newPrefix, markers, _expressions); + return newPrefix == Prefix ? this : new InitializerExpression(Id, newPrefix, Markers, _expressions); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public InitializerExpression WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new InitializerExpression(id, prefix, newMarkers, _expressions); + return ReferenceEquals(newMarkers, Markers) ? this : new InitializerExpression(Id, Prefix, newMarkers, _expressions); } - private readonly JContainer _expressions = expressions; + private JContainer _expressions = expressions; public IList Expressions => _expressions.GetElements(); public InitializerExpression WithExpressions(IList newExpressions) @@ -105,11 +105,11 @@ public InitializerExpression WithExpressions(IList newExpressions) } public sealed record PaddingHelper(Cs.InitializerExpression T) { - public JContainer Expressions => T._expressions; + public JContainer Expressions { get => T._expressions; set => T._expressions = value; } public Cs.InitializerExpression WithExpressions(JContainer newExpressions) { - return T._expressions == newExpressions ? T : new Cs.InitializerExpression(T.Id, T.Prefix, T.Markers, newExpressions); + return Expressions == newExpressions ? T : new Cs.InitializerExpression(T.Id, T.Prefix, T.Markers, newExpressions); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/InterpolatedString.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/InterpolatedString.g.cs index 93251a7e..09ed1ba4 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/InterpolatedString.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/InterpolatedString.g.cs @@ -66,50 +66,50 @@ public PaddingHelper Padding return v.VisitInterpolatedString(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public InterpolatedString WithId(Guid newId) { - return newId == id ? this : new InterpolatedString(newId, prefix, markers, start, _parts, end); + return newId == Id ? this : new InterpolatedString(newId, Prefix, Markers, Start, _parts, End); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public InterpolatedString WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new InterpolatedString(id, newPrefix, markers, start, _parts, end); + return newPrefix == Prefix ? this : new InterpolatedString(Id, newPrefix, Markers, Start, _parts, End); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public InterpolatedString WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new InterpolatedString(id, prefix, newMarkers, start, _parts, end); + return ReferenceEquals(newMarkers, Markers) ? this : new InterpolatedString(Id, Prefix, newMarkers, Start, _parts, End); } - public string Start => start; + public string Start { get; set; } = start; public InterpolatedString WithStart(string newStart) { - return newStart == start ? this : new InterpolatedString(id, prefix, markers, newStart, _parts, end); + return newStart == Start ? this : new InterpolatedString(Id, Prefix, Markers, newStart, _parts, End); } - private readonly IList> _parts = parts; + private IList> _parts = parts; public IList Parts => _parts.Elements(); public InterpolatedString WithParts(IList newParts) { return Padding.WithParts(_parts.WithElements(newParts)); } - public string End => end; + public string End { get; set; } = end; public InterpolatedString WithEnd(string newEnd) { - return newEnd == end ? this : new InterpolatedString(id, prefix, markers, start, _parts, newEnd); + return newEnd == End ? this : new InterpolatedString(Id, Prefix, Markers, Start, _parts, newEnd); } public sealed record PaddingHelper(Cs.InterpolatedString T) { - public IList> Parts => T._parts; + public IList> Parts { get => T._parts; set => T._parts = value; } public Cs.InterpolatedString WithParts(IList> newParts) { - return T._parts == newParts ? T : new Cs.InterpolatedString(T.Id, T.Prefix, T.Markers, T.Start, newParts, T.End); + return Parts == newParts ? T : new Cs.InterpolatedString(T.Id, T.Prefix, T.Markers, T.Start, newParts, T.End); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/Interpolation.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/Interpolation.g.cs index 73c91c05..9caa83f1 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/Interpolation.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/Interpolation.g.cs @@ -66,39 +66,39 @@ public PaddingHelper Padding return v.VisitInterpolation(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Interpolation WithId(Guid newId) { - return newId == id ? this : new Interpolation(newId, prefix, markers, _expression, _alignment, _format); + return newId == Id ? this : new Interpolation(newId, Prefix, Markers, _expression, _alignment, _format); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Interpolation WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Interpolation(id, newPrefix, markers, _expression, _alignment, _format); + return newPrefix == Prefix ? this : new Interpolation(Id, newPrefix, Markers, _expression, _alignment, _format); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Interpolation WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Interpolation(id, prefix, newMarkers, _expression, _alignment, _format); + return ReferenceEquals(newMarkers, Markers) ? this : new Interpolation(Id, Prefix, newMarkers, _expression, _alignment, _format); } - private readonly JRightPadded _expression = expression; + private JRightPadded _expression = expression; public Expression Expression => _expression.Element; public Interpolation WithExpression(Expression newExpression) { return Padding.WithExpression(_expression.WithElement(newExpression)); } - private readonly JRightPadded? _alignment = alignment; + private JRightPadded? _alignment = alignment; public Expression? Alignment => _alignment?.Element; public Interpolation WithAlignment(Expression? newAlignment) { return Padding.WithAlignment(JRightPadded.WithElement(_alignment, newAlignment)); } - private readonly JRightPadded? _format = format; + private JRightPadded? _format = format; public Expression? Format => _format?.Element; public Interpolation WithFormat(Expression? newFormat) @@ -107,25 +107,25 @@ public Interpolation WithFormat(Expression? newFormat) } public sealed record PaddingHelper(Cs.Interpolation T) { - public JRightPadded Expression => T._expression; + public JRightPadded Expression { get => T._expression; set => T._expression = value; } public Cs.Interpolation WithExpression(JRightPadded newExpression) { - return T._expression == newExpression ? T : new Cs.Interpolation(T.Id, T.Prefix, T.Markers, newExpression, T._alignment, T._format); + return Expression == newExpression ? T : new Cs.Interpolation(T.Id, T.Prefix, T.Markers, newExpression, T._alignment, T._format); } - public JRightPadded? Alignment => T._alignment; + public JRightPadded? Alignment { get => T._alignment; set => T._alignment = value; } public Cs.Interpolation WithAlignment(JRightPadded? newAlignment) { - return T._alignment == newAlignment ? T : new Cs.Interpolation(T.Id, T.Prefix, T.Markers, T._expression, newAlignment, T._format); + return Alignment == newAlignment ? T : new Cs.Interpolation(T.Id, T.Prefix, T.Markers, T._expression, newAlignment, T._format); } - public JRightPadded? Format => T._format; + public JRightPadded? Format { get => T._format; set => T._format = value; } public Cs.Interpolation WithFormat(JRightPadded? newFormat) { - return T._format == newFormat ? T : new Cs.Interpolation(T.Id, T.Prefix, T.Markers, T._expression, T._alignment, newFormat); + return Format == newFormat ? T : new Cs.Interpolation(T.Id, T.Prefix, T.Markers, T._expression, T._alignment, newFormat); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/IsPattern.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/IsPattern.g.cs index 75002e75..253df208 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/IsPattern.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/IsPattern.g.cs @@ -87,31 +87,31 @@ public PaddingHelper Padding return v.VisitIsPattern(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public IsPattern WithId(Guid newId) { - return newId == id ? this : new IsPattern(newId, prefix, markers, expression, _pattern); + return newId == Id ? this : new IsPattern(newId, Prefix, Markers, Expression, _pattern); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public IsPattern WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new IsPattern(id, newPrefix, markers, expression, _pattern); + return newPrefix == Prefix ? this : new IsPattern(Id, newPrefix, Markers, Expression, _pattern); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public IsPattern WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new IsPattern(id, prefix, newMarkers, expression, _pattern); + return ReferenceEquals(newMarkers, Markers) ? this : new IsPattern(Id, Prefix, newMarkers, Expression, _pattern); } - public Expression Expression => expression; + public Expression Expression { get; set; } = expression; public IsPattern WithExpression(Expression newExpression) { - return ReferenceEquals(newExpression, expression) ? this : new IsPattern(id, prefix, markers, newExpression, _pattern); + return ReferenceEquals(newExpression, Expression) ? this : new IsPattern(Id, Prefix, Markers, newExpression, _pattern); } - private readonly JLeftPadded _pattern = pattern; + private JLeftPadded _pattern = pattern; public Cs.Pattern Pattern => _pattern.Element; public IsPattern WithPattern(Cs.Pattern newPattern) @@ -120,11 +120,11 @@ public IsPattern WithPattern(Cs.Pattern newPattern) } public sealed record PaddingHelper(Cs.IsPattern T) { - public JLeftPadded Pattern => T._pattern; + public JLeftPadded Pattern { get => T._pattern; set => T._pattern = value; } public Cs.IsPattern WithPattern(JLeftPadded newPattern) { - return T._pattern == newPattern ? T : new Cs.IsPattern(T.Id, T.Prefix, T.Markers, T.Expression, newPattern); + return Pattern == newPattern ? T : new Cs.IsPattern(T.Id, T.Prefix, T.Markers, T.Expression, newPattern); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/JoinClause.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/JoinClause.g.cs index 9ea5e2d3..1c4040c9 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/JoinClause.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/JoinClause.g.cs @@ -87,52 +87,52 @@ public PaddingHelper Padding return v.VisitJoinClause(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public JoinClause WithId(Guid newId) { - return newId == id ? this : new JoinClause(newId, prefix, markers, _identifier, _inExpression, _leftExpression, rightExpression, _into); + return newId == Id ? this : new JoinClause(newId, Prefix, Markers, _identifier, _inExpression, _leftExpression, RightExpression, _into); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public JoinClause WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new JoinClause(id, newPrefix, markers, _identifier, _inExpression, _leftExpression, rightExpression, _into); + return newPrefix == Prefix ? this : new JoinClause(Id, newPrefix, Markers, _identifier, _inExpression, _leftExpression, RightExpression, _into); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public JoinClause WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new JoinClause(id, prefix, newMarkers, _identifier, _inExpression, _leftExpression, rightExpression, _into); + return ReferenceEquals(newMarkers, Markers) ? this : new JoinClause(Id, Prefix, newMarkers, _identifier, _inExpression, _leftExpression, RightExpression, _into); } - private readonly JRightPadded _identifier = identifier; + private JRightPadded _identifier = identifier; public J.Identifier Identifier => _identifier.Element; public JoinClause WithIdentifier(J.Identifier newIdentifier) { return Padding.WithIdentifier(_identifier.WithElement(newIdentifier)); } - private readonly JRightPadded _inExpression = inExpression; + private JRightPadded _inExpression = inExpression; public Expression InExpression => _inExpression.Element; public JoinClause WithInExpression(Expression newInExpression) { return Padding.WithInExpression(_inExpression.WithElement(newInExpression)); } - private readonly JRightPadded _leftExpression = leftExpression; + private JRightPadded _leftExpression = leftExpression; public Expression LeftExpression => _leftExpression.Element; public JoinClause WithLeftExpression(Expression newLeftExpression) { return Padding.WithLeftExpression(_leftExpression.WithElement(newLeftExpression)); } - public Expression RightExpression => rightExpression; + public Expression RightExpression { get; set; } = rightExpression; public JoinClause WithRightExpression(Expression newRightExpression) { - return ReferenceEquals(newRightExpression, rightExpression) ? this : new JoinClause(id, prefix, markers, _identifier, _inExpression, _leftExpression, newRightExpression, _into); + return ReferenceEquals(newRightExpression, RightExpression) ? this : new JoinClause(Id, Prefix, Markers, _identifier, _inExpression, _leftExpression, newRightExpression, _into); } - private readonly JLeftPadded? _into = into; + private JLeftPadded? _into = into; public Cs.JoinIntoClause? Into => _into?.Element; public JoinClause WithInto(Cs.JoinIntoClause? newInto) @@ -141,32 +141,32 @@ public JoinClause WithInto(Cs.JoinIntoClause? newInto) } public sealed record PaddingHelper(Cs.JoinClause T) { - public JRightPadded Identifier => T._identifier; + public JRightPadded Identifier { get => T._identifier; set => T._identifier = value; } public Cs.JoinClause WithIdentifier(JRightPadded newIdentifier) { - return T._identifier == newIdentifier ? T : new Cs.JoinClause(T.Id, T.Prefix, T.Markers, newIdentifier, T._inExpression, T._leftExpression, T.RightExpression, T._into); + return Identifier == newIdentifier ? T : new Cs.JoinClause(T.Id, T.Prefix, T.Markers, newIdentifier, T._inExpression, T._leftExpression, T.RightExpression, T._into); } - public JRightPadded InExpression => T._inExpression; + public JRightPadded InExpression { get => T._inExpression; set => T._inExpression = value; } public Cs.JoinClause WithInExpression(JRightPadded newInExpression) { - return T._inExpression == newInExpression ? T : new Cs.JoinClause(T.Id, T.Prefix, T.Markers, T._identifier, newInExpression, T._leftExpression, T.RightExpression, T._into); + return InExpression == newInExpression ? T : new Cs.JoinClause(T.Id, T.Prefix, T.Markers, T._identifier, newInExpression, T._leftExpression, T.RightExpression, T._into); } - public JRightPadded LeftExpression => T._leftExpression; + public JRightPadded LeftExpression { get => T._leftExpression; set => T._leftExpression = value; } public Cs.JoinClause WithLeftExpression(JRightPadded newLeftExpression) { - return T._leftExpression == newLeftExpression ? T : new Cs.JoinClause(T.Id, T.Prefix, T.Markers, T._identifier, T._inExpression, newLeftExpression, T.RightExpression, T._into); + return LeftExpression == newLeftExpression ? T : new Cs.JoinClause(T.Id, T.Prefix, T.Markers, T._identifier, T._inExpression, newLeftExpression, T.RightExpression, T._into); } - public JLeftPadded? Into => T._into; + public JLeftPadded? Into { get => T._into; set => T._into = value; } public Cs.JoinClause WithInto(JLeftPadded? newInto) { - return T._into == newInto ? T : new Cs.JoinClause(T.Id, T.Prefix, T.Markers, T._identifier, T._inExpression, T._leftExpression, T.RightExpression, newInto); + return Into == newInto ? T : new Cs.JoinClause(T.Id, T.Prefix, T.Markers, T._identifier, T._inExpression, T._leftExpression, T.RightExpression, newInto); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/JoinIntoClause.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/JoinIntoClause.g.cs index 92b5194d..964a6fb1 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/JoinIntoClause.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/JoinIntoClause.g.cs @@ -58,29 +58,29 @@ J.Identifier identifier return v.VisitJoinIntoClause(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public JoinIntoClause WithId(Guid newId) { - return newId == id ? this : new JoinIntoClause(newId, prefix, markers, identifier); + return newId == Id ? this : new JoinIntoClause(newId, Prefix, Markers, Identifier); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public JoinIntoClause WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new JoinIntoClause(id, newPrefix, markers, identifier); + return newPrefix == Prefix ? this : new JoinIntoClause(Id, newPrefix, Markers, Identifier); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public JoinIntoClause WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new JoinIntoClause(id, prefix, newMarkers, identifier); + return ReferenceEquals(newMarkers, Markers) ? this : new JoinIntoClause(Id, Prefix, newMarkers, Identifier); } - public J.Identifier Identifier => identifier; + public J.Identifier Identifier { get; set; } = identifier; public JoinIntoClause WithIdentifier(J.Identifier newIdentifier) { - return ReferenceEquals(newIdentifier, identifier) ? this : new JoinIntoClause(id, prefix, markers, newIdentifier); + return ReferenceEquals(newIdentifier, Identifier) ? this : new JoinIntoClause(Id, Prefix, Markers, newIdentifier); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.CSharp/Tree/Keyword.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/Keyword.g.cs index ed3a7461..4b796589 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/Keyword.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/Keyword.g.cs @@ -39,29 +39,29 @@ Keyword.KeywordKind kind return v.VisitKeyword(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Keyword WithId(Guid newId) { - return newId == id ? this : new Keyword(newId, prefix, markers, kind); + return newId == Id ? this : new Keyword(newId, Prefix, Markers, Kind); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Keyword WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Keyword(id, newPrefix, markers, kind); + return newPrefix == Prefix ? this : new Keyword(Id, newPrefix, Markers, Kind); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Keyword WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Keyword(id, prefix, newMarkers, kind); + return ReferenceEquals(newMarkers, Markers) ? this : new Keyword(Id, Prefix, newMarkers, Kind); } - public KeywordKind Kind => kind; + public KeywordKind Kind { get; set; } = kind; public Keyword WithKind(KeywordKind newKind) { - return newKind == kind ? this : new Keyword(id, prefix, markers, newKind); + return newKind == Kind ? this : new Keyword(Id, Prefix, Markers, newKind); } public enum KeywordKind { diff --git a/Rewrite/src/Rewrite.CSharp/Tree/Lambda.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/Lambda.g.cs index e4aff11b..695fb911 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/Lambda.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/Lambda.g.cs @@ -41,41 +41,41 @@ public partial class Lambda( return v.VisitLambda(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Lambda WithId(Guid newId) { - return newId == id ? this : new Lambda(newId, prefix, markers, lambdaExpression, returnType, modifiers); + return newId == Id ? this : new Lambda(newId, Prefix, Markers, LambdaExpression, ReturnType, Modifiers); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Lambda WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Lambda(id, newPrefix, markers, lambdaExpression, returnType, modifiers); + return newPrefix == Prefix ? this : new Lambda(Id, newPrefix, Markers, LambdaExpression, ReturnType, Modifiers); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Lambda WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Lambda(id, prefix, newMarkers, lambdaExpression, returnType, modifiers); + return ReferenceEquals(newMarkers, Markers) ? this : new Lambda(Id, Prefix, newMarkers, LambdaExpression, ReturnType, Modifiers); } - public J.Lambda LambdaExpression => lambdaExpression; + public J.Lambda LambdaExpression { get; set; } = lambdaExpression; public Lambda WithLambdaExpression(J.Lambda newLambdaExpression) { - return ReferenceEquals(newLambdaExpression, lambdaExpression) ? this : new Lambda(id, prefix, markers, newLambdaExpression, returnType, modifiers); + return ReferenceEquals(newLambdaExpression, LambdaExpression) ? this : new Lambda(Id, Prefix, Markers, newLambdaExpression, ReturnType, Modifiers); } - public TypeTree? ReturnType => returnType; + public TypeTree? ReturnType { get; set; } = returnType; public Lambda WithReturnType(TypeTree? newReturnType) { - return ReferenceEquals(newReturnType, returnType) ? this : new Lambda(id, prefix, markers, lambdaExpression, newReturnType, modifiers); + return ReferenceEquals(newReturnType, ReturnType) ? this : new Lambda(Id, Prefix, Markers, LambdaExpression, newReturnType, Modifiers); } - public IList Modifiers => modifiers; + public IList Modifiers { get; set; } = modifiers; public Lambda WithModifiers(IList newModifiers) { - return newModifiers == modifiers ? this : new Lambda(id, prefix, markers, lambdaExpression, returnType, newModifiers); + return newModifiers == Modifiers ? this : new Lambda(Id, Prefix, Markers, LambdaExpression, ReturnType, newModifiers); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.CSharp/Tree/LetClause.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/LetClause.g.cs index 20aa5a55..ca6c4a7f 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/LetClause.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/LetClause.g.cs @@ -87,44 +87,44 @@ public PaddingHelper Padding return v.VisitLetClause(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public LetClause WithId(Guid newId) { - return newId == id ? this : new LetClause(newId, prefix, markers, _identifier, expression); + return newId == Id ? this : new LetClause(newId, Prefix, Markers, _identifier, Expression); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public LetClause WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new LetClause(id, newPrefix, markers, _identifier, expression); + return newPrefix == Prefix ? this : new LetClause(Id, newPrefix, Markers, _identifier, Expression); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public LetClause WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new LetClause(id, prefix, newMarkers, _identifier, expression); + return ReferenceEquals(newMarkers, Markers) ? this : new LetClause(Id, Prefix, newMarkers, _identifier, Expression); } - private readonly JRightPadded _identifier = identifier; + private JRightPadded _identifier = identifier; public J.Identifier Identifier => _identifier.Element; public LetClause WithIdentifier(J.Identifier newIdentifier) { return Padding.WithIdentifier(_identifier.WithElement(newIdentifier)); } - public Expression Expression => expression; + public Expression Expression { get; set; } = expression; public LetClause WithExpression(Expression newExpression) { - return ReferenceEquals(newExpression, expression) ? this : new LetClause(id, prefix, markers, _identifier, newExpression); + return ReferenceEquals(newExpression, Expression) ? this : new LetClause(Id, Prefix, Markers, _identifier, newExpression); } public sealed record PaddingHelper(Cs.LetClause T) { - public JRightPadded Identifier => T._identifier; + public JRightPadded Identifier { get => T._identifier; set => T._identifier = value; } public Cs.LetClause WithIdentifier(JRightPadded newIdentifier) { - return T._identifier == newIdentifier ? T : new Cs.LetClause(T.Id, T.Prefix, T.Markers, newIdentifier, T.Expression); + return Identifier == newIdentifier ? T : new Cs.LetClause(T.Id, T.Prefix, T.Markers, newIdentifier, T.Expression); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/ListPattern.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/ListPattern.g.cs index a468f18b..919e4793 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/ListPattern.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/ListPattern.g.cs @@ -93,44 +93,44 @@ public PaddingHelper Padding return v.VisitListPattern(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public ListPattern WithId(Guid newId) { - return newId == id ? this : new ListPattern(newId, prefix, markers, _patterns, designation); + return newId == Id ? this : new ListPattern(newId, Prefix, Markers, _patterns, Designation); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public ListPattern WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new ListPattern(id, newPrefix, markers, _patterns, designation); + return newPrefix == Prefix ? this : new ListPattern(Id, newPrefix, Markers, _patterns, Designation); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public ListPattern WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new ListPattern(id, prefix, newMarkers, _patterns, designation); + return ReferenceEquals(newMarkers, Markers) ? this : new ListPattern(Id, Prefix, newMarkers, _patterns, Designation); } - private readonly JContainer _patterns = patterns; + private JContainer _patterns = patterns; public IList Patterns => _patterns.GetElements(); public ListPattern WithPatterns(IList newPatterns) { return Padding.WithPatterns(JContainer.WithElements(_patterns, newPatterns)); } - public Cs.VariableDesignation? Designation => designation; + public Cs.VariableDesignation? Designation { get; set; } = designation; public ListPattern WithDesignation(Cs.VariableDesignation? newDesignation) { - return ReferenceEquals(newDesignation, designation) ? this : new ListPattern(id, prefix, markers, _patterns, newDesignation); + return ReferenceEquals(newDesignation, Designation) ? this : new ListPattern(Id, Prefix, Markers, _patterns, newDesignation); } public sealed record PaddingHelper(Cs.ListPattern T) { - public JContainer Patterns => T._patterns; + public JContainer Patterns { get => T._patterns; set => T._patterns = value; } public Cs.ListPattern WithPatterns(JContainer newPatterns) { - return T._patterns == newPatterns ? T : new Cs.ListPattern(T.Id, T.Prefix, T.Markers, newPatterns, T.Designation); + return Patterns == newPatterns ? T : new Cs.ListPattern(T.Id, T.Prefix, T.Markers, newPatterns, T.Designation); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/LockStatement.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/LockStatement.g.cs index 420f8035..b022a962 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/LockStatement.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/LockStatement.g.cs @@ -84,31 +84,31 @@ public PaddingHelper Padding return v.VisitLockStatement(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public LockStatement WithId(Guid newId) { - return newId == id ? this : new LockStatement(newId, prefix, markers, expression, _statement); + return newId == Id ? this : new LockStatement(newId, Prefix, Markers, Expression, _statement); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public LockStatement WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new LockStatement(id, newPrefix, markers, expression, _statement); + return newPrefix == Prefix ? this : new LockStatement(Id, newPrefix, Markers, Expression, _statement); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public LockStatement WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new LockStatement(id, prefix, newMarkers, expression, _statement); + return ReferenceEquals(newMarkers, Markers) ? this : new LockStatement(Id, Prefix, newMarkers, Expression, _statement); } - public J.ControlParentheses Expression => expression; + public J.ControlParentheses Expression { get; set; } = expression; public LockStatement WithExpression(J.ControlParentheses newExpression) { - return ReferenceEquals(newExpression, expression) ? this : new LockStatement(id, prefix, markers, newExpression, _statement); + return ReferenceEquals(newExpression, Expression) ? this : new LockStatement(Id, Prefix, Markers, newExpression, _statement); } - private readonly JRightPadded _statement = statement; + private JRightPadded _statement = statement; public Statement Statement => _statement.Element; public LockStatement WithStatement(Statement newStatement) @@ -117,11 +117,11 @@ public LockStatement WithStatement(Statement newStatement) } public sealed record PaddingHelper(Cs.LockStatement T) { - public JRightPadded Statement => T._statement; + public JRightPadded Statement { get => T._statement; set => T._statement = value; } public Cs.LockStatement WithStatement(JRightPadded newStatement) { - return T._statement == newStatement ? T : new Cs.LockStatement(T.Id, T.Prefix, T.Markers, T.Expression, newStatement); + return Statement == newStatement ? T : new Cs.LockStatement(T.Id, T.Prefix, T.Markers, T.Expression, newStatement); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/MethodDeclaration.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/MethodDeclaration.g.cs index 10722118..1475a24b 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/MethodDeclaration.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/MethodDeclaration.g.cs @@ -73,82 +73,82 @@ public PaddingHelper Padding return v.VisitMethodDeclaration(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public MethodDeclaration WithId(Guid newId) { - return newId == id ? this : new MethodDeclaration(newId, prefix, markers, attributes, modifiers, _typeParameters, returnTypeExpression, _explicitInterfaceSpecifier, name, _parameters, body, methodType, _typeParameterConstraintClauses); + return newId == Id ? this : new MethodDeclaration(newId, Prefix, Markers, Attributes, Modifiers, _typeParameters, ReturnTypeExpression, _explicitInterfaceSpecifier, Name, _parameters, Body, MethodType, _typeParameterConstraintClauses); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public MethodDeclaration WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new MethodDeclaration(id, newPrefix, markers, attributes, modifiers, _typeParameters, returnTypeExpression, _explicitInterfaceSpecifier, name, _parameters, body, methodType, _typeParameterConstraintClauses); + return newPrefix == Prefix ? this : new MethodDeclaration(Id, newPrefix, Markers, Attributes, Modifiers, _typeParameters, ReturnTypeExpression, _explicitInterfaceSpecifier, Name, _parameters, Body, MethodType, _typeParameterConstraintClauses); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public MethodDeclaration WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new MethodDeclaration(id, prefix, newMarkers, attributes, modifiers, _typeParameters, returnTypeExpression, _explicitInterfaceSpecifier, name, _parameters, body, methodType, _typeParameterConstraintClauses); + return ReferenceEquals(newMarkers, Markers) ? this : new MethodDeclaration(Id, Prefix, newMarkers, Attributes, Modifiers, _typeParameters, ReturnTypeExpression, _explicitInterfaceSpecifier, Name, _parameters, Body, MethodType, _typeParameterConstraintClauses); } - public IList Attributes => attributes; + public IList Attributes { get; set; } = attributes; public MethodDeclaration WithAttributes(IList newAttributes) { - return newAttributes == attributes ? this : new MethodDeclaration(id, prefix, markers, newAttributes, modifiers, _typeParameters, returnTypeExpression, _explicitInterfaceSpecifier, name, _parameters, body, methodType, _typeParameterConstraintClauses); + return newAttributes == Attributes ? this : new MethodDeclaration(Id, Prefix, Markers, newAttributes, Modifiers, _typeParameters, ReturnTypeExpression, _explicitInterfaceSpecifier, Name, _parameters, Body, MethodType, _typeParameterConstraintClauses); } - public IList Modifiers => modifiers; + public IList Modifiers { get; set; } = modifiers; public MethodDeclaration WithModifiers(IList newModifiers) { - return newModifiers == modifiers ? this : new MethodDeclaration(id, prefix, markers, attributes, newModifiers, _typeParameters, returnTypeExpression, _explicitInterfaceSpecifier, name, _parameters, body, methodType, _typeParameterConstraintClauses); + return newModifiers == Modifiers ? this : new MethodDeclaration(Id, Prefix, Markers, Attributes, newModifiers, _typeParameters, ReturnTypeExpression, _explicitInterfaceSpecifier, Name, _parameters, Body, MethodType, _typeParameterConstraintClauses); } - private readonly JContainer? _typeParameters = typeParameters; + private JContainer? _typeParameters = typeParameters; public IList? TypeParameters => _typeParameters?.GetElements(); public MethodDeclaration WithTypeParameters(IList? newTypeParameters) { return Padding.WithTypeParameters(JContainer.WithElementsNullable(_typeParameters, newTypeParameters)); } - public TypeTree ReturnTypeExpression => returnTypeExpression; + public TypeTree ReturnTypeExpression { get; set; } = returnTypeExpression; public MethodDeclaration WithReturnTypeExpression(TypeTree newReturnTypeExpression) { - return ReferenceEquals(newReturnTypeExpression, returnTypeExpression) ? this : new MethodDeclaration(id, prefix, markers, attributes, modifiers, _typeParameters, newReturnTypeExpression, _explicitInterfaceSpecifier, name, _parameters, body, methodType, _typeParameterConstraintClauses); + return ReferenceEquals(newReturnTypeExpression, ReturnTypeExpression) ? this : new MethodDeclaration(Id, Prefix, Markers, Attributes, Modifiers, _typeParameters, newReturnTypeExpression, _explicitInterfaceSpecifier, Name, _parameters, Body, MethodType, _typeParameterConstraintClauses); } - private readonly JRightPadded? _explicitInterfaceSpecifier = explicitInterfaceSpecifier; + private JRightPadded? _explicitInterfaceSpecifier = explicitInterfaceSpecifier; public TypeTree? ExplicitInterfaceSpecifier => _explicitInterfaceSpecifier?.Element; public MethodDeclaration WithExplicitInterfaceSpecifier(TypeTree? newExplicitInterfaceSpecifier) { return Padding.WithExplicitInterfaceSpecifier(JRightPadded.WithElement(_explicitInterfaceSpecifier, newExplicitInterfaceSpecifier)); } - public J.Identifier Name => name; + public J.Identifier Name { get; set; } = name; public MethodDeclaration WithName(J.Identifier newName) { - return ReferenceEquals(newName, name) ? this : new MethodDeclaration(id, prefix, markers, attributes, modifiers, _typeParameters, returnTypeExpression, _explicitInterfaceSpecifier, newName, _parameters, body, methodType, _typeParameterConstraintClauses); + return ReferenceEquals(newName, Name) ? this : new MethodDeclaration(Id, Prefix, Markers, Attributes, Modifiers, _typeParameters, ReturnTypeExpression, _explicitInterfaceSpecifier, newName, _parameters, Body, MethodType, _typeParameterConstraintClauses); } - private readonly JContainer _parameters = parameters; + private JContainer _parameters = parameters; public IList Parameters => _parameters.GetElements(); public MethodDeclaration WithParameters(IList newParameters) { return Padding.WithParameters(JContainer.WithElements(_parameters, newParameters)); } - public Statement? Body => body; + public Statement? Body { get; set; } = body; public MethodDeclaration WithBody(Statement? newBody) { - return ReferenceEquals(newBody, body) ? this : new MethodDeclaration(id, prefix, markers, attributes, modifiers, _typeParameters, returnTypeExpression, _explicitInterfaceSpecifier, name, _parameters, newBody, methodType, _typeParameterConstraintClauses); + return ReferenceEquals(newBody, Body) ? this : new MethodDeclaration(Id, Prefix, Markers, Attributes, Modifiers, _typeParameters, ReturnTypeExpression, _explicitInterfaceSpecifier, Name, _parameters, newBody, MethodType, _typeParameterConstraintClauses); } - public JavaType.Method? MethodType => methodType; + public JavaType.Method? MethodType { get; set; } = methodType; public MethodDeclaration WithMethodType(JavaType.Method? newMethodType) { - return newMethodType == methodType ? this : new MethodDeclaration(id, prefix, markers, attributes, modifiers, _typeParameters, returnTypeExpression, _explicitInterfaceSpecifier, name, _parameters, body, newMethodType, _typeParameterConstraintClauses); + return newMethodType == MethodType ? this : new MethodDeclaration(Id, Prefix, Markers, Attributes, Modifiers, _typeParameters, ReturnTypeExpression, _explicitInterfaceSpecifier, Name, _parameters, Body, newMethodType, _typeParameterConstraintClauses); } - private readonly JContainer _typeParameterConstraintClauses = typeParameterConstraintClauses; + private JContainer _typeParameterConstraintClauses = typeParameterConstraintClauses; public IList TypeParameterConstraintClauses => _typeParameterConstraintClauses.GetElements(); public MethodDeclaration WithTypeParameterConstraintClauses(IList newTypeParameterConstraintClauses) @@ -157,32 +157,32 @@ public MethodDeclaration WithTypeParameterConstraintClauses(IList? TypeParameters => T._typeParameters; + public JContainer? TypeParameters { get => T._typeParameters; set => T._typeParameters = value; } public Cs.MethodDeclaration WithTypeParameters(JContainer? newTypeParameters) { - return T._typeParameters == newTypeParameters ? T : new Cs.MethodDeclaration(T.Id, T.Prefix, T.Markers, T.Attributes, T.Modifiers, newTypeParameters, T.ReturnTypeExpression, T._explicitInterfaceSpecifier, T.Name, T._parameters, T.Body, T.MethodType, T._typeParameterConstraintClauses); + return TypeParameters == newTypeParameters ? T : new Cs.MethodDeclaration(T.Id, T.Prefix, T.Markers, T.Attributes, T.Modifiers, newTypeParameters, T.ReturnTypeExpression, T._explicitInterfaceSpecifier, T.Name, T._parameters, T.Body, T.MethodType, T._typeParameterConstraintClauses); } - public JRightPadded? ExplicitInterfaceSpecifier => T._explicitInterfaceSpecifier; + public JRightPadded? ExplicitInterfaceSpecifier { get => T._explicitInterfaceSpecifier; set => T._explicitInterfaceSpecifier = value; } public Cs.MethodDeclaration WithExplicitInterfaceSpecifier(JRightPadded? newExplicitInterfaceSpecifier) { - return T._explicitInterfaceSpecifier == newExplicitInterfaceSpecifier ? T : new Cs.MethodDeclaration(T.Id, T.Prefix, T.Markers, T.Attributes, T.Modifiers, T._typeParameters, T.ReturnTypeExpression, newExplicitInterfaceSpecifier, T.Name, T._parameters, T.Body, T.MethodType, T._typeParameterConstraintClauses); + return ExplicitInterfaceSpecifier == newExplicitInterfaceSpecifier ? T : new Cs.MethodDeclaration(T.Id, T.Prefix, T.Markers, T.Attributes, T.Modifiers, T._typeParameters, T.ReturnTypeExpression, newExplicitInterfaceSpecifier, T.Name, T._parameters, T.Body, T.MethodType, T._typeParameterConstraintClauses); } - public JContainer Parameters => T._parameters; + public JContainer Parameters { get => T._parameters; set => T._parameters = value; } public Cs.MethodDeclaration WithParameters(JContainer newParameters) { - return T._parameters == newParameters ? T : new Cs.MethodDeclaration(T.Id, T.Prefix, T.Markers, T.Attributes, T.Modifiers, T._typeParameters, T.ReturnTypeExpression, T._explicitInterfaceSpecifier, T.Name, newParameters, T.Body, T.MethodType, T._typeParameterConstraintClauses); + return Parameters == newParameters ? T : new Cs.MethodDeclaration(T.Id, T.Prefix, T.Markers, T.Attributes, T.Modifiers, T._typeParameters, T.ReturnTypeExpression, T._explicitInterfaceSpecifier, T.Name, newParameters, T.Body, T.MethodType, T._typeParameterConstraintClauses); } - public JContainer TypeParameterConstraintClauses => T._typeParameterConstraintClauses; + public JContainer TypeParameterConstraintClauses { get => T._typeParameterConstraintClauses; set => T._typeParameterConstraintClauses = value; } public Cs.MethodDeclaration WithTypeParameterConstraintClauses(JContainer newTypeParameterConstraintClauses) { - return T._typeParameterConstraintClauses == newTypeParameterConstraintClauses ? T : new Cs.MethodDeclaration(T.Id, T.Prefix, T.Markers, T.Attributes, T.Modifiers, T._typeParameters, T.ReturnTypeExpression, T._explicitInterfaceSpecifier, T.Name, T._parameters, T.Body, T.MethodType, newTypeParameterConstraintClauses); + return TypeParameterConstraintClauses == newTypeParameterConstraintClauses ? T : new Cs.MethodDeclaration(T.Id, T.Prefix, T.Markers, T.Attributes, T.Modifiers, T._typeParameters, T.ReturnTypeExpression, T._explicitInterfaceSpecifier, T.Name, T._parameters, T.Body, T.MethodType, newTypeParameterConstraintClauses); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/NameColon.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/NameColon.g.cs index 929d032a..3a4ebf44 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/NameColon.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/NameColon.g.cs @@ -81,25 +81,25 @@ public PaddingHelper Padding return v.VisitNameColon(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public NameColon WithId(Guid newId) { - return newId == id ? this : new NameColon(newId, prefix, markers, _name); + return newId == Id ? this : new NameColon(newId, Prefix, Markers, _name); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public NameColon WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new NameColon(id, newPrefix, markers, _name); + return newPrefix == Prefix ? this : new NameColon(Id, newPrefix, Markers, _name); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public NameColon WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new NameColon(id, prefix, newMarkers, _name); + return ReferenceEquals(newMarkers, Markers) ? this : new NameColon(Id, Prefix, newMarkers, _name); } - private readonly JRightPadded _name = name; + private JRightPadded _name = name; public J.Identifier Name => _name.Element; public NameColon WithName(J.Identifier newName) @@ -108,11 +108,11 @@ public NameColon WithName(J.Identifier newName) } public sealed record PaddingHelper(Cs.NameColon T) { - public JRightPadded Name => T._name; + public JRightPadded Name { get => T._name; set => T._name = value; } public Cs.NameColon WithName(JRightPadded newName) { - return T._name == newName ? T : new Cs.NameColon(T.Id, T.Prefix, T.Markers, newName); + return Name == newName ? T : new Cs.NameColon(T.Id, T.Prefix, T.Markers, newName); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/NewClass.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/NewClass.g.cs index 697c608a..6679e3ef 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/NewClass.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/NewClass.g.cs @@ -58,35 +58,35 @@ public partial class NewClass( return v.VisitNewClass(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public NewClass WithId(Guid newId) { - return newId == id ? this : new NewClass(newId, prefix, markers, newClassCore, initializer); + return newId == Id ? this : new NewClass(newId, Prefix, Markers, NewClassCore, Initializer); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public NewClass WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new NewClass(id, newPrefix, markers, newClassCore, initializer); + return newPrefix == Prefix ? this : new NewClass(Id, newPrefix, Markers, NewClassCore, Initializer); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public NewClass WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new NewClass(id, prefix, newMarkers, newClassCore, initializer); + return ReferenceEquals(newMarkers, Markers) ? this : new NewClass(Id, Prefix, newMarkers, NewClassCore, Initializer); } - public J.NewClass NewClassCore => newClassCore; + public J.NewClass NewClassCore { get; set; } = newClassCore; public NewClass WithNewClassCore(J.NewClass newNewClassCore) { - return ReferenceEquals(newNewClassCore, newClassCore) ? this : new NewClass(id, prefix, markers, newNewClassCore, initializer); + return ReferenceEquals(newNewClassCore, NewClassCore) ? this : new NewClass(Id, Prefix, Markers, newNewClassCore, Initializer); } - public Cs.InitializerExpression? Initializer => initializer; + public Cs.InitializerExpression? Initializer { get; set; } = initializer; public NewClass WithInitializer(Cs.InitializerExpression? newInitializer) { - return ReferenceEquals(newInitializer, initializer) ? this : new NewClass(id, prefix, markers, newClassCore, newInitializer); + return ReferenceEquals(newInitializer, Initializer) ? this : new NewClass(Id, Prefix, Markers, NewClassCore, newInitializer); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.CSharp/Tree/NullSafeExpression.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/NullSafeExpression.g.cs index dbed12f2..6d9d5a07 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/NullSafeExpression.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/NullSafeExpression.g.cs @@ -64,25 +64,25 @@ public PaddingHelper Padding return v.VisitNullSafeExpression(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public NullSafeExpression WithId(Guid newId) { - return newId == id ? this : new NullSafeExpression(newId, prefix, markers, _expression); + return newId == Id ? this : new NullSafeExpression(newId, Prefix, Markers, _expression); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public NullSafeExpression WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new NullSafeExpression(id, newPrefix, markers, _expression); + return newPrefix == Prefix ? this : new NullSafeExpression(Id, newPrefix, Markers, _expression); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public NullSafeExpression WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new NullSafeExpression(id, prefix, newMarkers, _expression); + return ReferenceEquals(newMarkers, Markers) ? this : new NullSafeExpression(Id, Prefix, newMarkers, _expression); } - private readonly JRightPadded _expression = expression; + private JRightPadded _expression = expression; public Expression Expression => _expression.Element; public NullSafeExpression WithExpression(Expression newExpression) @@ -91,11 +91,11 @@ public NullSafeExpression WithExpression(Expression newExpression) } public sealed record PaddingHelper(Cs.NullSafeExpression T) { - public JRightPadded Expression => T._expression; + public JRightPadded Expression { get => T._expression; set => T._expression = value; } public Cs.NullSafeExpression WithExpression(JRightPadded newExpression) { - return T._expression == newExpression ? T : new Cs.NullSafeExpression(T.Id, T.Prefix, T.Markers, newExpression); + return Expression == newExpression ? T : new Cs.NullSafeExpression(T.Id, T.Prefix, T.Markers, newExpression); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/OperatorDeclaration.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/OperatorDeclaration.g.cs index e62086ed..1bcbdb9c 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/OperatorDeclaration.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/OperatorDeclaration.g.cs @@ -91,86 +91,86 @@ public PaddingHelper Padding return v.VisitOperatorDeclaration(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public OperatorDeclaration WithId(Guid newId) { - return newId == id ? this : new OperatorDeclaration(newId, prefix, markers, attributeLists, modifiers, _explicitInterfaceSpecifier, operatorKeyword, checkedKeyword, _operatorToken, returnType, _parameters, body, methodType); + return newId == Id ? this : new OperatorDeclaration(newId, Prefix, Markers, AttributeLists, Modifiers, _explicitInterfaceSpecifier, OperatorKeyword, CheckedKeyword, _operatorToken, ReturnType, _parameters, Body, MethodType); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public OperatorDeclaration WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new OperatorDeclaration(id, newPrefix, markers, attributeLists, modifiers, _explicitInterfaceSpecifier, operatorKeyword, checkedKeyword, _operatorToken, returnType, _parameters, body, methodType); + return newPrefix == Prefix ? this : new OperatorDeclaration(Id, newPrefix, Markers, AttributeLists, Modifiers, _explicitInterfaceSpecifier, OperatorKeyword, CheckedKeyword, _operatorToken, ReturnType, _parameters, Body, MethodType); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public OperatorDeclaration WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new OperatorDeclaration(id, prefix, newMarkers, attributeLists, modifiers, _explicitInterfaceSpecifier, operatorKeyword, checkedKeyword, _operatorToken, returnType, _parameters, body, methodType); + return ReferenceEquals(newMarkers, Markers) ? this : new OperatorDeclaration(Id, Prefix, newMarkers, AttributeLists, Modifiers, _explicitInterfaceSpecifier, OperatorKeyword, CheckedKeyword, _operatorToken, ReturnType, _parameters, Body, MethodType); } - public IList AttributeLists => attributeLists; + public IList AttributeLists { get; set; } = attributeLists; public OperatorDeclaration WithAttributeLists(IList newAttributeLists) { - return newAttributeLists == attributeLists ? this : new OperatorDeclaration(id, prefix, markers, newAttributeLists, modifiers, _explicitInterfaceSpecifier, operatorKeyword, checkedKeyword, _operatorToken, returnType, _parameters, body, methodType); + return newAttributeLists == AttributeLists ? this : new OperatorDeclaration(Id, Prefix, Markers, newAttributeLists, Modifiers, _explicitInterfaceSpecifier, OperatorKeyword, CheckedKeyword, _operatorToken, ReturnType, _parameters, Body, MethodType); } - public IList Modifiers => modifiers; + public IList Modifiers { get; set; } = modifiers; public OperatorDeclaration WithModifiers(IList newModifiers) { - return newModifiers == modifiers ? this : new OperatorDeclaration(id, prefix, markers, attributeLists, newModifiers, _explicitInterfaceSpecifier, operatorKeyword, checkedKeyword, _operatorToken, returnType, _parameters, body, methodType); + return newModifiers == Modifiers ? this : new OperatorDeclaration(Id, Prefix, Markers, AttributeLists, newModifiers, _explicitInterfaceSpecifier, OperatorKeyword, CheckedKeyword, _operatorToken, ReturnType, _parameters, Body, MethodType); } - private readonly JRightPadded? _explicitInterfaceSpecifier = explicitInterfaceSpecifier; + private JRightPadded? _explicitInterfaceSpecifier = explicitInterfaceSpecifier; public TypeTree? ExplicitInterfaceSpecifier => _explicitInterfaceSpecifier?.Element; public OperatorDeclaration WithExplicitInterfaceSpecifier(TypeTree? newExplicitInterfaceSpecifier) { return Padding.WithExplicitInterfaceSpecifier(JRightPadded.WithElement(_explicitInterfaceSpecifier, newExplicitInterfaceSpecifier)); } - public Cs.Keyword OperatorKeyword => operatorKeyword; + public Cs.Keyword OperatorKeyword { get; set; } = operatorKeyword; public OperatorDeclaration WithOperatorKeyword(Cs.Keyword newOperatorKeyword) { - return ReferenceEquals(newOperatorKeyword, operatorKeyword) ? this : new OperatorDeclaration(id, prefix, markers, attributeLists, modifiers, _explicitInterfaceSpecifier, newOperatorKeyword, checkedKeyword, _operatorToken, returnType, _parameters, body, methodType); + return ReferenceEquals(newOperatorKeyword, OperatorKeyword) ? this : new OperatorDeclaration(Id, Prefix, Markers, AttributeLists, Modifiers, _explicitInterfaceSpecifier, newOperatorKeyword, CheckedKeyword, _operatorToken, ReturnType, _parameters, Body, MethodType); } - public Cs.Keyword? CheckedKeyword => checkedKeyword; + public Cs.Keyword? CheckedKeyword { get; set; } = checkedKeyword; public OperatorDeclaration WithCheckedKeyword(Cs.Keyword? newCheckedKeyword) { - return ReferenceEquals(newCheckedKeyword, checkedKeyword) ? this : new OperatorDeclaration(id, prefix, markers, attributeLists, modifiers, _explicitInterfaceSpecifier, operatorKeyword, newCheckedKeyword, _operatorToken, returnType, _parameters, body, methodType); + return ReferenceEquals(newCheckedKeyword, CheckedKeyword) ? this : new OperatorDeclaration(Id, Prefix, Markers, AttributeLists, Modifiers, _explicitInterfaceSpecifier, OperatorKeyword, newCheckedKeyword, _operatorToken, ReturnType, _parameters, Body, MethodType); } - private readonly JLeftPadded _operatorToken = operatorToken; + private JLeftPadded _operatorToken = operatorToken; public Operator OperatorToken => _operatorToken.Element; public OperatorDeclaration WithOperatorToken(Operator newOperatorToken) { return Padding.WithOperatorToken(_operatorToken.WithElement(newOperatorToken)); } - public TypeTree ReturnType => returnType; + public TypeTree ReturnType { get; set; } = returnType; public OperatorDeclaration WithReturnType(TypeTree newReturnType) { - return ReferenceEquals(newReturnType, returnType) ? this : new OperatorDeclaration(id, prefix, markers, attributeLists, modifiers, _explicitInterfaceSpecifier, operatorKeyword, checkedKeyword, _operatorToken, newReturnType, _parameters, body, methodType); + return ReferenceEquals(newReturnType, ReturnType) ? this : new OperatorDeclaration(Id, Prefix, Markers, AttributeLists, Modifiers, _explicitInterfaceSpecifier, OperatorKeyword, CheckedKeyword, _operatorToken, newReturnType, _parameters, Body, MethodType); } - private readonly JContainer _parameters = parameters; + private JContainer _parameters = parameters; public IList Parameters => _parameters.GetElements(); public OperatorDeclaration WithParameters(IList newParameters) { return Padding.WithParameters(JContainer.WithElements(_parameters, newParameters)); } - public J.Block Body => body; + public J.Block Body { get; set; } = body; public OperatorDeclaration WithBody(J.Block newBody) { - return ReferenceEquals(newBody, body) ? this : new OperatorDeclaration(id, prefix, markers, attributeLists, modifiers, _explicitInterfaceSpecifier, operatorKeyword, checkedKeyword, _operatorToken, returnType, _parameters, newBody, methodType); + return ReferenceEquals(newBody, Body) ? this : new OperatorDeclaration(Id, Prefix, Markers, AttributeLists, Modifiers, _explicitInterfaceSpecifier, OperatorKeyword, CheckedKeyword, _operatorToken, ReturnType, _parameters, newBody, MethodType); } - public JavaType.Method? MethodType => methodType; + public JavaType.Method? MethodType { get; set; } = methodType; public OperatorDeclaration WithMethodType(JavaType.Method? newMethodType) { - return newMethodType == methodType ? this : new OperatorDeclaration(id, prefix, markers, attributeLists, modifiers, _explicitInterfaceSpecifier, operatorKeyword, checkedKeyword, _operatorToken, returnType, _parameters, body, newMethodType); + return newMethodType == MethodType ? this : new OperatorDeclaration(Id, Prefix, Markers, AttributeLists, Modifiers, _explicitInterfaceSpecifier, OperatorKeyword, CheckedKeyword, _operatorToken, ReturnType, _parameters, Body, newMethodType); } public enum Operator { @@ -199,25 +199,25 @@ public enum Operator } public sealed record PaddingHelper(Cs.OperatorDeclaration T) { - public JRightPadded? ExplicitInterfaceSpecifier => T._explicitInterfaceSpecifier; + public JRightPadded? ExplicitInterfaceSpecifier { get => T._explicitInterfaceSpecifier; set => T._explicitInterfaceSpecifier = value; } public Cs.OperatorDeclaration WithExplicitInterfaceSpecifier(JRightPadded? newExplicitInterfaceSpecifier) { - return T._explicitInterfaceSpecifier == newExplicitInterfaceSpecifier ? T : new Cs.OperatorDeclaration(T.Id, T.Prefix, T.Markers, T.AttributeLists, T.Modifiers, newExplicitInterfaceSpecifier, T.OperatorKeyword, T.CheckedKeyword, T._operatorToken, T.ReturnType, T._parameters, T.Body, T.MethodType); + return ExplicitInterfaceSpecifier == newExplicitInterfaceSpecifier ? T : new Cs.OperatorDeclaration(T.Id, T.Prefix, T.Markers, T.AttributeLists, T.Modifiers, newExplicitInterfaceSpecifier, T.OperatorKeyword, T.CheckedKeyword, T._operatorToken, T.ReturnType, T._parameters, T.Body, T.MethodType); } - public JLeftPadded OperatorToken => T._operatorToken; + public JLeftPadded OperatorToken { get => T._operatorToken; set => T._operatorToken = value; } public Cs.OperatorDeclaration WithOperatorToken(JLeftPadded newOperatorToken) { - return T._operatorToken == newOperatorToken ? T : new Cs.OperatorDeclaration(T.Id, T.Prefix, T.Markers, T.AttributeLists, T.Modifiers, T._explicitInterfaceSpecifier, T.OperatorKeyword, T.CheckedKeyword, newOperatorToken, T.ReturnType, T._parameters, T.Body, T.MethodType); + return OperatorToken == newOperatorToken ? T : new Cs.OperatorDeclaration(T.Id, T.Prefix, T.Markers, T.AttributeLists, T.Modifiers, T._explicitInterfaceSpecifier, T.OperatorKeyword, T.CheckedKeyword, newOperatorToken, T.ReturnType, T._parameters, T.Body, T.MethodType); } - public JContainer Parameters => T._parameters; + public JContainer Parameters { get => T._parameters; set => T._parameters = value; } public Cs.OperatorDeclaration WithParameters(JContainer newParameters) { - return T._parameters == newParameters ? T : new Cs.OperatorDeclaration(T.Id, T.Prefix, T.Markers, T.AttributeLists, T.Modifiers, T._explicitInterfaceSpecifier, T.OperatorKeyword, T.CheckedKeyword, T._operatorToken, T.ReturnType, newParameters, T.Body, T.MethodType); + return Parameters == newParameters ? T : new Cs.OperatorDeclaration(T.Id, T.Prefix, T.Markers, T.AttributeLists, T.Modifiers, T._explicitInterfaceSpecifier, T.OperatorKeyword, T.CheckedKeyword, T._operatorToken, T.ReturnType, newParameters, T.Body, T.MethodType); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/OrderByClause.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/OrderByClause.g.cs index 24061240..854cef68 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/OrderByClause.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/OrderByClause.g.cs @@ -83,25 +83,25 @@ public PaddingHelper Padding return v.VisitOrderByClause(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public OrderByClause WithId(Guid newId) { - return newId == id ? this : new OrderByClause(newId, prefix, markers, _orderings); + return newId == Id ? this : new OrderByClause(newId, Prefix, Markers, _orderings); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public OrderByClause WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new OrderByClause(id, newPrefix, markers, _orderings); + return newPrefix == Prefix ? this : new OrderByClause(Id, newPrefix, Markers, _orderings); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public OrderByClause WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new OrderByClause(id, prefix, newMarkers, _orderings); + return ReferenceEquals(newMarkers, Markers) ? this : new OrderByClause(Id, Prefix, newMarkers, _orderings); } - private readonly IList> _orderings = orderings; + private IList> _orderings = orderings; public IList Orderings => _orderings.Elements(); public OrderByClause WithOrderings(IList newOrderings) @@ -110,11 +110,11 @@ public OrderByClause WithOrderings(IList newOrderings) } public sealed record PaddingHelper(Cs.OrderByClause T) { - public IList> Orderings => T._orderings; + public IList> Orderings { get => T._orderings; set => T._orderings = value; } public Cs.OrderByClause WithOrderings(IList> newOrderings) { - return T._orderings == newOrderings ? T : new Cs.OrderByClause(T.Id, T.Prefix, T.Markers, newOrderings); + return Orderings == newOrderings ? T : new Cs.OrderByClause(T.Id, T.Prefix, T.Markers, newOrderings); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/Ordering.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/Ordering.g.cs index 63b542f2..d82d2089 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/Ordering.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/Ordering.g.cs @@ -72,36 +72,36 @@ public PaddingHelper Padding return v.VisitOrdering(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Ordering WithId(Guid newId) { - return newId == id ? this : new Ordering(newId, prefix, markers, _expression, direction); + return newId == Id ? this : new Ordering(newId, Prefix, Markers, _expression, Direction); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Ordering WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Ordering(id, newPrefix, markers, _expression, direction); + return newPrefix == Prefix ? this : new Ordering(Id, newPrefix, Markers, _expression, Direction); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Ordering WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Ordering(id, prefix, newMarkers, _expression, direction); + return ReferenceEquals(newMarkers, Markers) ? this : new Ordering(Id, Prefix, newMarkers, _expression, Direction); } - private readonly JRightPadded _expression = expression; + private JRightPadded _expression = expression; public Expression Expression => _expression.Element; public Ordering WithExpression(Expression newExpression) { return Padding.WithExpression(_expression.WithElement(newExpression)); } - public DirectionKind? Direction => direction; + public DirectionKind? Direction { get; set; } = direction; public Ordering WithDirection(DirectionKind? newDirection) { - return newDirection == direction ? this : new Ordering(id, prefix, markers, _expression, newDirection); + return newDirection == Direction ? this : new Ordering(Id, Prefix, Markers, _expression, newDirection); } public enum DirectionKind { @@ -110,11 +110,11 @@ public enum DirectionKind } public sealed record PaddingHelper(Cs.Ordering T) { - public JRightPadded Expression => T._expression; + public JRightPadded Expression { get => T._expression; set => T._expression = value; } public Cs.Ordering WithExpression(JRightPadded newExpression) { - return T._expression == newExpression ? T : new Cs.Ordering(T.Id, T.Prefix, T.Markers, newExpression, T.Direction); + return Expression == newExpression ? T : new Cs.Ordering(T.Id, T.Prefix, T.Markers, newExpression, T.Direction); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/ParenthesizedPattern.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/ParenthesizedPattern.g.cs index bc7ab83c..ff480bbc 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/ParenthesizedPattern.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/ParenthesizedPattern.g.cs @@ -83,25 +83,25 @@ public PaddingHelper Padding return v.VisitParenthesizedPattern(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public ParenthesizedPattern WithId(Guid newId) { - return newId == id ? this : new ParenthesizedPattern(newId, prefix, markers, _pattern); + return newId == Id ? this : new ParenthesizedPattern(newId, Prefix, Markers, _pattern); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public ParenthesizedPattern WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new ParenthesizedPattern(id, newPrefix, markers, _pattern); + return newPrefix == Prefix ? this : new ParenthesizedPattern(Id, newPrefix, Markers, _pattern); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public ParenthesizedPattern WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new ParenthesizedPattern(id, prefix, newMarkers, _pattern); + return ReferenceEquals(newMarkers, Markers) ? this : new ParenthesizedPattern(Id, Prefix, newMarkers, _pattern); } - private readonly JContainer _pattern = pattern; + private JContainer _pattern = pattern; public IList Pattern => _pattern.GetElements(); public ParenthesizedPattern WithPattern(IList newPattern) @@ -110,11 +110,11 @@ public ParenthesizedPattern WithPattern(IList newPattern) } public sealed record PaddingHelper(Cs.ParenthesizedPattern T) { - public JContainer Pattern => T._pattern; + public JContainer Pattern { get => T._pattern; set => T._pattern = value; } public Cs.ParenthesizedPattern WithPattern(JContainer newPattern) { - return T._pattern == newPattern ? T : new Cs.ParenthesizedPattern(T.Id, T.Prefix, T.Markers, newPattern); + return Pattern == newPattern ? T : new Cs.ParenthesizedPattern(T.Id, T.Prefix, T.Markers, newPattern); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/ParenthesizedVariableDesignation.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/ParenthesizedVariableDesignation.g.cs index bf98bf5f..b59cd2b8 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/ParenthesizedVariableDesignation.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/ParenthesizedVariableDesignation.g.cs @@ -78,44 +78,44 @@ public PaddingHelper Padding return v.VisitParenthesizedVariableDesignation(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public ParenthesizedVariableDesignation WithId(Guid newId) { - return newId == id ? this : new ParenthesizedVariableDesignation(newId, prefix, markers, _variables, type); + return newId == Id ? this : new ParenthesizedVariableDesignation(newId, Prefix, Markers, _variables, Type); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public ParenthesizedVariableDesignation WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new ParenthesizedVariableDesignation(id, newPrefix, markers, _variables, type); + return newPrefix == Prefix ? this : new ParenthesizedVariableDesignation(Id, newPrefix, Markers, _variables, Type); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public ParenthesizedVariableDesignation WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new ParenthesizedVariableDesignation(id, prefix, newMarkers, _variables, type); + return ReferenceEquals(newMarkers, Markers) ? this : new ParenthesizedVariableDesignation(Id, Prefix, newMarkers, _variables, Type); } - private readonly JContainer _variables = variables; + private JContainer _variables = variables; public IList Variables => _variables.GetElements(); public ParenthesizedVariableDesignation WithVariables(IList newVariables) { return Padding.WithVariables(JContainer.WithElements(_variables, newVariables)); } - public JavaType? Type => type; + public JavaType? Type { get; set; } = type; public ParenthesizedVariableDesignation WithType(JavaType? newType) { - return newType == type ? this : new ParenthesizedVariableDesignation(id, prefix, markers, _variables, newType); + return newType == Type ? this : new ParenthesizedVariableDesignation(Id, Prefix, Markers, _variables, newType); } public sealed record PaddingHelper(Cs.ParenthesizedVariableDesignation T) { - public JContainer Variables => T._variables; + public JContainer Variables { get => T._variables; set => T._variables = value; } public Cs.ParenthesizedVariableDesignation WithVariables(JContainer newVariables) { - return T._variables == newVariables ? T : new Cs.ParenthesizedVariableDesignation(T.Id, T.Prefix, T.Markers, newVariables, T.Type); + return Variables == newVariables ? T : new Cs.ParenthesizedVariableDesignation(T.Id, T.Prefix, T.Markers, newVariables, T.Type); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/PointerFieldAccess.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/PointerFieldAccess.g.cs index 89c6b1bd..ca85850d 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/PointerFieldAccess.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/PointerFieldAccess.g.cs @@ -66,50 +66,50 @@ public PaddingHelper Padding return v.VisitPointerFieldAccess(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public PointerFieldAccess WithId(Guid newId) { - return newId == id ? this : new PointerFieldAccess(newId, prefix, markers, target, _name, type); + return newId == Id ? this : new PointerFieldAccess(newId, Prefix, Markers, Target, _name, Type); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public PointerFieldAccess WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new PointerFieldAccess(id, newPrefix, markers, target, _name, type); + return newPrefix == Prefix ? this : new PointerFieldAccess(Id, newPrefix, Markers, Target, _name, Type); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public PointerFieldAccess WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new PointerFieldAccess(id, prefix, newMarkers, target, _name, type); + return ReferenceEquals(newMarkers, Markers) ? this : new PointerFieldAccess(Id, Prefix, newMarkers, Target, _name, Type); } - public Expression Target => target; + public Expression Target { get; set; } = target; public PointerFieldAccess WithTarget(Expression newTarget) { - return ReferenceEquals(newTarget, target) ? this : new PointerFieldAccess(id, prefix, markers, newTarget, _name, type); + return ReferenceEquals(newTarget, Target) ? this : new PointerFieldAccess(Id, Prefix, Markers, newTarget, _name, Type); } - private readonly JLeftPadded _name = name; + private JLeftPadded _name = name; public J.Identifier Name => _name.Element; public PointerFieldAccess WithName(J.Identifier newName) { return Padding.WithName(_name.WithElement(newName)); } - public JavaType? Type => type; + public JavaType? Type { get; set; } = type; public PointerFieldAccess WithType(JavaType? newType) { - return newType == type ? this : new PointerFieldAccess(id, prefix, markers, target, _name, newType); + return newType == Type ? this : new PointerFieldAccess(Id, Prefix, Markers, Target, _name, newType); } public sealed record PaddingHelper(Cs.PointerFieldAccess T) { - public JLeftPadded Name => T._name; + public JLeftPadded Name { get => T._name; set => T._name = value; } public Cs.PointerFieldAccess WithName(JLeftPadded newName) { - return T._name == newName ? T : new Cs.PointerFieldAccess(T.Id, T.Prefix, T.Markers, T.Target, newName, T.Type); + return Name == newName ? T : new Cs.PointerFieldAccess(T.Id, T.Prefix, T.Markers, T.Target, newName, T.Type); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/PointerType.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/PointerType.g.cs index f1f83e89..e62648bf 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/PointerType.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/PointerType.g.cs @@ -77,25 +77,25 @@ public PaddingHelper Padding return v.VisitPointerType(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public PointerType WithId(Guid newId) { - return newId == id ? this : new PointerType(newId, prefix, markers, _elementType); + return newId == Id ? this : new PointerType(newId, Prefix, Markers, _elementType); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public PointerType WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new PointerType(id, newPrefix, markers, _elementType); + return newPrefix == Prefix ? this : new PointerType(Id, newPrefix, Markers, _elementType); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public PointerType WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new PointerType(id, prefix, newMarkers, _elementType); + return ReferenceEquals(newMarkers, Markers) ? this : new PointerType(Id, Prefix, newMarkers, _elementType); } - private readonly JRightPadded _elementType = elementType; + private JRightPadded _elementType = elementType; public TypeTree ElementType => _elementType.Element; public PointerType WithElementType(TypeTree newElementType) @@ -104,11 +104,11 @@ public PointerType WithElementType(TypeTree newElementType) } public sealed record PaddingHelper(Cs.PointerType T) { - public JRightPadded ElementType => T._elementType; + public JRightPadded ElementType { get => T._elementType; set => T._elementType = value; } public Cs.PointerType WithElementType(JRightPadded newElementType) { - return T._elementType == newElementType ? T : new Cs.PointerType(T.Id, T.Prefix, T.Markers, newElementType); + return ElementType == newElementType ? T : new Cs.PointerType(T.Id, T.Prefix, T.Markers, newElementType); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/PositionalPatternClause.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/PositionalPatternClause.g.cs index 3d244982..c59802b3 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/PositionalPatternClause.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/PositionalPatternClause.g.cs @@ -83,25 +83,25 @@ public PaddingHelper Padding return v.VisitPositionalPatternClause(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public PositionalPatternClause WithId(Guid newId) { - return newId == id ? this : new PositionalPatternClause(newId, prefix, markers, _subpatterns); + return newId == Id ? this : new PositionalPatternClause(newId, Prefix, Markers, _subpatterns); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public PositionalPatternClause WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new PositionalPatternClause(id, newPrefix, markers, _subpatterns); + return newPrefix == Prefix ? this : new PositionalPatternClause(Id, newPrefix, Markers, _subpatterns); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public PositionalPatternClause WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new PositionalPatternClause(id, prefix, newMarkers, _subpatterns); + return ReferenceEquals(newMarkers, Markers) ? this : new PositionalPatternClause(Id, Prefix, newMarkers, _subpatterns); } - private readonly JContainer _subpatterns = subpatterns; + private JContainer _subpatterns = subpatterns; public IList Subpatterns => _subpatterns.GetElements(); public PositionalPatternClause WithSubpatterns(IList newSubpatterns) @@ -110,11 +110,11 @@ public PositionalPatternClause WithSubpatterns(IList newSubpatter } public sealed record PaddingHelper(Cs.PositionalPatternClause T) { - public JContainer Subpatterns => T._subpatterns; + public JContainer Subpatterns { get => T._subpatterns; set => T._subpatterns = value; } public Cs.PositionalPatternClause WithSubpatterns(JContainer newSubpatterns) { - return T._subpatterns == newSubpatterns ? T : new Cs.PositionalPatternClause(T.Id, T.Prefix, T.Markers, newSubpatterns); + return Subpatterns == newSubpatterns ? T : new Cs.PositionalPatternClause(T.Id, T.Prefix, T.Markers, newSubpatterns); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/PropertyDeclaration.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/PropertyDeclaration.g.cs index fd6f2567..2ca24de3 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/PropertyDeclaration.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/PropertyDeclaration.g.cs @@ -71,68 +71,68 @@ public PaddingHelper Padding return v.VisitPropertyDeclaration(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public PropertyDeclaration WithId(Guid newId) { - return newId == id ? this : new PropertyDeclaration(newId, prefix, markers, attributeLists, modifiers, typeExpression, _interfaceSpecifier, name, accessors, expressionBody, _initializer); + return newId == Id ? this : new PropertyDeclaration(newId, Prefix, Markers, AttributeLists, Modifiers, TypeExpression, _interfaceSpecifier, Name, Accessors, ExpressionBody, _initializer); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public PropertyDeclaration WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new PropertyDeclaration(id, newPrefix, markers, attributeLists, modifiers, typeExpression, _interfaceSpecifier, name, accessors, expressionBody, _initializer); + return newPrefix == Prefix ? this : new PropertyDeclaration(Id, newPrefix, Markers, AttributeLists, Modifiers, TypeExpression, _interfaceSpecifier, Name, Accessors, ExpressionBody, _initializer); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public PropertyDeclaration WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new PropertyDeclaration(id, prefix, newMarkers, attributeLists, modifiers, typeExpression, _interfaceSpecifier, name, accessors, expressionBody, _initializer); + return ReferenceEquals(newMarkers, Markers) ? this : new PropertyDeclaration(Id, Prefix, newMarkers, AttributeLists, Modifiers, TypeExpression, _interfaceSpecifier, Name, Accessors, ExpressionBody, _initializer); } - public IList AttributeLists => attributeLists; + public IList AttributeLists { get; set; } = attributeLists; public PropertyDeclaration WithAttributeLists(IList newAttributeLists) { - return newAttributeLists == attributeLists ? this : new PropertyDeclaration(id, prefix, markers, newAttributeLists, modifiers, typeExpression, _interfaceSpecifier, name, accessors, expressionBody, _initializer); + return newAttributeLists == AttributeLists ? this : new PropertyDeclaration(Id, Prefix, Markers, newAttributeLists, Modifiers, TypeExpression, _interfaceSpecifier, Name, Accessors, ExpressionBody, _initializer); } - public IList Modifiers => modifiers; + public IList Modifiers { get; set; } = modifiers; public PropertyDeclaration WithModifiers(IList newModifiers) { - return newModifiers == modifiers ? this : new PropertyDeclaration(id, prefix, markers, attributeLists, newModifiers, typeExpression, _interfaceSpecifier, name, accessors, expressionBody, _initializer); + return newModifiers == Modifiers ? this : new PropertyDeclaration(Id, Prefix, Markers, AttributeLists, newModifiers, TypeExpression, _interfaceSpecifier, Name, Accessors, ExpressionBody, _initializer); } - public TypeTree TypeExpression => typeExpression; + public TypeTree TypeExpression { get; set; } = typeExpression; public PropertyDeclaration WithTypeExpression(TypeTree newTypeExpression) { - return ReferenceEquals(newTypeExpression, typeExpression) ? this : new PropertyDeclaration(id, prefix, markers, attributeLists, modifiers, newTypeExpression, _interfaceSpecifier, name, accessors, expressionBody, _initializer); + return ReferenceEquals(newTypeExpression, TypeExpression) ? this : new PropertyDeclaration(Id, Prefix, Markers, AttributeLists, Modifiers, newTypeExpression, _interfaceSpecifier, Name, Accessors, ExpressionBody, _initializer); } - private readonly JRightPadded? _interfaceSpecifier = interfaceSpecifier; + private JRightPadded? _interfaceSpecifier = interfaceSpecifier; public TypeTree? InterfaceSpecifier => _interfaceSpecifier?.Element; public PropertyDeclaration WithInterfaceSpecifier(TypeTree? newInterfaceSpecifier) { return Padding.WithInterfaceSpecifier(JRightPadded.WithElement(_interfaceSpecifier, newInterfaceSpecifier)); } - public J.Identifier Name => name; + public J.Identifier Name { get; set; } = name; public PropertyDeclaration WithName(J.Identifier newName) { - return ReferenceEquals(newName, name) ? this : new PropertyDeclaration(id, prefix, markers, attributeLists, modifiers, typeExpression, _interfaceSpecifier, newName, accessors, expressionBody, _initializer); + return ReferenceEquals(newName, Name) ? this : new PropertyDeclaration(Id, Prefix, Markers, AttributeLists, Modifiers, TypeExpression, _interfaceSpecifier, newName, Accessors, ExpressionBody, _initializer); } - public J.Block? Accessors => accessors; + public J.Block? Accessors { get; set; } = accessors; public PropertyDeclaration WithAccessors(J.Block? newAccessors) { - return ReferenceEquals(newAccessors, accessors) ? this : new PropertyDeclaration(id, prefix, markers, attributeLists, modifiers, typeExpression, _interfaceSpecifier, name, newAccessors, expressionBody, _initializer); + return ReferenceEquals(newAccessors, Accessors) ? this : new PropertyDeclaration(Id, Prefix, Markers, AttributeLists, Modifiers, TypeExpression, _interfaceSpecifier, Name, newAccessors, ExpressionBody, _initializer); } - public Cs.ArrowExpressionClause? ExpressionBody => expressionBody; + public Cs.ArrowExpressionClause? ExpressionBody { get; set; } = expressionBody; public PropertyDeclaration WithExpressionBody(Cs.ArrowExpressionClause? newExpressionBody) { - return ReferenceEquals(newExpressionBody, expressionBody) ? this : new PropertyDeclaration(id, prefix, markers, attributeLists, modifiers, typeExpression, _interfaceSpecifier, name, accessors, newExpressionBody, _initializer); + return ReferenceEquals(newExpressionBody, ExpressionBody) ? this : new PropertyDeclaration(Id, Prefix, Markers, AttributeLists, Modifiers, TypeExpression, _interfaceSpecifier, Name, Accessors, newExpressionBody, _initializer); } - private readonly JLeftPadded? _initializer = initializer; + private JLeftPadded? _initializer = initializer; public Expression? Initializer => _initializer?.Element; public PropertyDeclaration WithInitializer(Expression? newInitializer) @@ -141,18 +141,18 @@ public PropertyDeclaration WithInitializer(Expression? newInitializer) } public sealed record PaddingHelper(Cs.PropertyDeclaration T) { - public JRightPadded? InterfaceSpecifier => T._interfaceSpecifier; + public JRightPadded? InterfaceSpecifier { get => T._interfaceSpecifier; set => T._interfaceSpecifier = value; } public Cs.PropertyDeclaration WithInterfaceSpecifier(JRightPadded? newInterfaceSpecifier) { - return T._interfaceSpecifier == newInterfaceSpecifier ? T : new Cs.PropertyDeclaration(T.Id, T.Prefix, T.Markers, T.AttributeLists, T.Modifiers, T.TypeExpression, newInterfaceSpecifier, T.Name, T.Accessors, T.ExpressionBody, T._initializer); + return InterfaceSpecifier == newInterfaceSpecifier ? T : new Cs.PropertyDeclaration(T.Id, T.Prefix, T.Markers, T.AttributeLists, T.Modifiers, T.TypeExpression, newInterfaceSpecifier, T.Name, T.Accessors, T.ExpressionBody, T._initializer); } - public JLeftPadded? Initializer => T._initializer; + public JLeftPadded? Initializer { get => T._initializer; set => T._initializer = value; } public Cs.PropertyDeclaration WithInitializer(JLeftPadded? newInitializer) { - return T._initializer == newInitializer ? T : new Cs.PropertyDeclaration(T.Id, T.Prefix, T.Markers, T.AttributeLists, T.Modifiers, T.TypeExpression, T._interfaceSpecifier, T.Name, T.Accessors, T.ExpressionBody, newInitializer); + return Initializer == newInitializer ? T : new Cs.PropertyDeclaration(T.Id, T.Prefix, T.Markers, T.AttributeLists, T.Modifiers, T.TypeExpression, T._interfaceSpecifier, T.Name, T.Accessors, T.ExpressionBody, newInitializer); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/PropertyPatternClause.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/PropertyPatternClause.g.cs index e5f5ddb7..d1904ab5 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/PropertyPatternClause.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/PropertyPatternClause.g.cs @@ -85,25 +85,25 @@ public PaddingHelper Padding return v.VisitPropertyPatternClause(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public PropertyPatternClause WithId(Guid newId) { - return newId == id ? this : new PropertyPatternClause(newId, prefix, markers, _subpatterns); + return newId == Id ? this : new PropertyPatternClause(newId, Prefix, Markers, _subpatterns); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public PropertyPatternClause WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new PropertyPatternClause(id, newPrefix, markers, _subpatterns); + return newPrefix == Prefix ? this : new PropertyPatternClause(Id, newPrefix, Markers, _subpatterns); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public PropertyPatternClause WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new PropertyPatternClause(id, prefix, newMarkers, _subpatterns); + return ReferenceEquals(newMarkers, Markers) ? this : new PropertyPatternClause(Id, Prefix, newMarkers, _subpatterns); } - private readonly JContainer _subpatterns = subpatterns; + private JContainer _subpatterns = subpatterns; public IList Subpatterns => _subpatterns.GetElements(); public PropertyPatternClause WithSubpatterns(IList newSubpatterns) @@ -112,11 +112,11 @@ public PropertyPatternClause WithSubpatterns(IList newSubpatterns) } public sealed record PaddingHelper(Cs.PropertyPatternClause T) { - public JContainer Subpatterns => T._subpatterns; + public JContainer Subpatterns { get => T._subpatterns; set => T._subpatterns = value; } public Cs.PropertyPatternClause WithSubpatterns(JContainer newSubpatterns) { - return T._subpatterns == newSubpatterns ? T : new Cs.PropertyPatternClause(T.Id, T.Prefix, T.Markers, newSubpatterns); + return Subpatterns == newSubpatterns ? T : new Cs.PropertyPatternClause(T.Id, T.Prefix, T.Markers, newSubpatterns); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/QueryBody.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/QueryBody.g.cs index 77c2662f..406afa40 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/QueryBody.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/QueryBody.g.cs @@ -61,41 +61,41 @@ public partial class QueryBody( return v.VisitQueryBody(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public QueryBody WithId(Guid newId) { - return newId == id ? this : new QueryBody(newId, prefix, markers, clauses, selectOrGroup, continuation); + return newId == Id ? this : new QueryBody(newId, Prefix, Markers, Clauses, SelectOrGroup, Continuation); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public QueryBody WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new QueryBody(id, newPrefix, markers, clauses, selectOrGroup, continuation); + return newPrefix == Prefix ? this : new QueryBody(Id, newPrefix, Markers, Clauses, SelectOrGroup, Continuation); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public QueryBody WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new QueryBody(id, prefix, newMarkers, clauses, selectOrGroup, continuation); + return ReferenceEquals(newMarkers, Markers) ? this : new QueryBody(Id, Prefix, newMarkers, Clauses, SelectOrGroup, Continuation); } - public IList Clauses => clauses; + public IList Clauses { get; set; } = clauses; public QueryBody WithClauses(IList newClauses) { - return newClauses == clauses ? this : new QueryBody(id, prefix, markers, newClauses, selectOrGroup, continuation); + return newClauses == Clauses ? this : new QueryBody(Id, Prefix, Markers, newClauses, SelectOrGroup, Continuation); } - public Cs.SelectOrGroupClause? SelectOrGroup => selectOrGroup; + public Cs.SelectOrGroupClause? SelectOrGroup { get; set; } = selectOrGroup; public QueryBody WithSelectOrGroup(Cs.SelectOrGroupClause? newSelectOrGroup) { - return ReferenceEquals(newSelectOrGroup, selectOrGroup) ? this : new QueryBody(id, prefix, markers, clauses, newSelectOrGroup, continuation); + return ReferenceEquals(newSelectOrGroup, SelectOrGroup) ? this : new QueryBody(Id, Prefix, Markers, Clauses, newSelectOrGroup, Continuation); } - public Cs.QueryContinuation? Continuation => continuation; + public Cs.QueryContinuation? Continuation { get; set; } = continuation; public QueryBody WithContinuation(Cs.QueryContinuation? newContinuation) { - return ReferenceEquals(newContinuation, continuation) ? this : new QueryBody(id, prefix, markers, clauses, selectOrGroup, newContinuation); + return ReferenceEquals(newContinuation, Continuation) ? this : new QueryBody(Id, Prefix, Markers, Clauses, SelectOrGroup, newContinuation); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.CSharp/Tree/QueryContinuation.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/QueryContinuation.g.cs index 58bbb80e..02547acf 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/QueryContinuation.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/QueryContinuation.g.cs @@ -58,35 +58,35 @@ QueryBody body return v.VisitQueryContinuation(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public QueryContinuation WithId(Guid newId) { - return newId == id ? this : new QueryContinuation(newId, prefix, markers, identifier, body); + return newId == Id ? this : new QueryContinuation(newId, Prefix, Markers, Identifier, Body); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public QueryContinuation WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new QueryContinuation(id, newPrefix, markers, identifier, body); + return newPrefix == Prefix ? this : new QueryContinuation(Id, newPrefix, Markers, Identifier, Body); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public QueryContinuation WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new QueryContinuation(id, prefix, newMarkers, identifier, body); + return ReferenceEquals(newMarkers, Markers) ? this : new QueryContinuation(Id, Prefix, newMarkers, Identifier, Body); } - public J.Identifier Identifier => identifier; + public J.Identifier Identifier { get; set; } = identifier; public QueryContinuation WithIdentifier(J.Identifier newIdentifier) { - return ReferenceEquals(newIdentifier, identifier) ? this : new QueryContinuation(id, prefix, markers, newIdentifier, body); + return ReferenceEquals(newIdentifier, Identifier) ? this : new QueryContinuation(Id, Prefix, Markers, newIdentifier, Body); } - public Cs.QueryBody Body => body; + public Cs.QueryBody Body { get; set; } = body; public QueryContinuation WithBody(Cs.QueryBody newBody) { - return ReferenceEquals(newBody, body) ? this : new QueryContinuation(id, prefix, markers, identifier, newBody); + return ReferenceEquals(newBody, Body) ? this : new QueryContinuation(Id, Prefix, Markers, Identifier, newBody); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.CSharp/Tree/QueryExpression.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/QueryExpression.g.cs index 4760517c..102014bb 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/QueryExpression.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/QueryExpression.g.cs @@ -62,35 +62,35 @@ QueryBody body return v.VisitQueryExpression(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public QueryExpression WithId(Guid newId) { - return newId == id ? this : new QueryExpression(newId, prefix, markers, fromClause, body); + return newId == Id ? this : new QueryExpression(newId, Prefix, Markers, FromClause, Body); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public QueryExpression WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new QueryExpression(id, newPrefix, markers, fromClause, body); + return newPrefix == Prefix ? this : new QueryExpression(Id, newPrefix, Markers, FromClause, Body); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public QueryExpression WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new QueryExpression(id, prefix, newMarkers, fromClause, body); + return ReferenceEquals(newMarkers, Markers) ? this : new QueryExpression(Id, Prefix, newMarkers, FromClause, Body); } - public Cs.FromClause FromClause => fromClause; + public Cs.FromClause FromClause { get; set; } = fromClause; public QueryExpression WithFromClause(Cs.FromClause newFromClause) { - return ReferenceEquals(newFromClause, fromClause) ? this : new QueryExpression(id, prefix, markers, newFromClause, body); + return ReferenceEquals(newFromClause, FromClause) ? this : new QueryExpression(Id, Prefix, Markers, newFromClause, Body); } - public Cs.QueryBody Body => body; + public Cs.QueryBody Body { get; set; } = body; public QueryExpression WithBody(Cs.QueryBody newBody) { - return ReferenceEquals(newBody, body) ? this : new QueryExpression(id, prefix, markers, fromClause, newBody); + return ReferenceEquals(newBody, Body) ? this : new QueryExpression(Id, Prefix, Markers, FromClause, newBody); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.CSharp/Tree/RangeExpression.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/RangeExpression.g.cs index b5cb8ddd..5761e8c6 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/RangeExpression.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/RangeExpression.g.cs @@ -89,44 +89,44 @@ public PaddingHelper Padding return v.VisitRangeExpression(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public RangeExpression WithId(Guid newId) { - return newId == id ? this : new RangeExpression(newId, prefix, markers, _start, end); + return newId == Id ? this : new RangeExpression(newId, Prefix, Markers, _start, End); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public RangeExpression WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new RangeExpression(id, newPrefix, markers, _start, end); + return newPrefix == Prefix ? this : new RangeExpression(Id, newPrefix, Markers, _start, End); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public RangeExpression WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new RangeExpression(id, prefix, newMarkers, _start, end); + return ReferenceEquals(newMarkers, Markers) ? this : new RangeExpression(Id, Prefix, newMarkers, _start, End); } - private readonly JRightPadded? _start = start; + private JRightPadded? _start = start; public Expression? Start => _start?.Element; public RangeExpression WithStart(Expression? newStart) { return Padding.WithStart(JRightPadded.WithElement(_start, newStart)); } - public Expression? End => end; + public Expression? End { get; set; } = end; public RangeExpression WithEnd(Expression? newEnd) { - return ReferenceEquals(newEnd, end) ? this : new RangeExpression(id, prefix, markers, _start, newEnd); + return ReferenceEquals(newEnd, End) ? this : new RangeExpression(Id, Prefix, Markers, _start, newEnd); } public sealed record PaddingHelper(Cs.RangeExpression T) { - public JRightPadded? Start => T._start; + public JRightPadded? Start { get => T._start; set => T._start = value; } public Cs.RangeExpression WithStart(JRightPadded? newStart) { - return T._start == newStart ? T : new Cs.RangeExpression(T.Id, T.Prefix, T.Markers, newStart, T.End); + return Start == newStart ? T : new Cs.RangeExpression(T.Id, T.Prefix, T.Markers, newStart, T.End); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/RecursivePattern.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/RecursivePattern.g.cs index a9b7802b..c35f4c90 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/RecursivePattern.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/RecursivePattern.g.cs @@ -65,47 +65,47 @@ public partial class RecursivePattern( return v.VisitRecursivePattern(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public RecursivePattern WithId(Guid newId) { - return newId == id ? this : new RecursivePattern(newId, prefix, markers, typeQualifier, positionalPattern, propertyPattern, designation); + return newId == Id ? this : new RecursivePattern(newId, Prefix, Markers, TypeQualifier, PositionalPattern, PropertyPattern, Designation); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public RecursivePattern WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new RecursivePattern(id, newPrefix, markers, typeQualifier, positionalPattern, propertyPattern, designation); + return newPrefix == Prefix ? this : new RecursivePattern(Id, newPrefix, Markers, TypeQualifier, PositionalPattern, PropertyPattern, Designation); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public RecursivePattern WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new RecursivePattern(id, prefix, newMarkers, typeQualifier, positionalPattern, propertyPattern, designation); + return ReferenceEquals(newMarkers, Markers) ? this : new RecursivePattern(Id, Prefix, newMarkers, TypeQualifier, PositionalPattern, PropertyPattern, Designation); } - public TypeTree? TypeQualifier => typeQualifier; + public TypeTree? TypeQualifier { get; set; } = typeQualifier; public RecursivePattern WithTypeQualifier(TypeTree? newTypeQualifier) { - return ReferenceEquals(newTypeQualifier, typeQualifier) ? this : new RecursivePattern(id, prefix, markers, newTypeQualifier, positionalPattern, propertyPattern, designation); + return ReferenceEquals(newTypeQualifier, TypeQualifier) ? this : new RecursivePattern(Id, Prefix, Markers, newTypeQualifier, PositionalPattern, PropertyPattern, Designation); } - public Cs.PositionalPatternClause? PositionalPattern => positionalPattern; + public Cs.PositionalPatternClause? PositionalPattern { get; set; } = positionalPattern; public RecursivePattern WithPositionalPattern(Cs.PositionalPatternClause? newPositionalPattern) { - return ReferenceEquals(newPositionalPattern, positionalPattern) ? this : new RecursivePattern(id, prefix, markers, typeQualifier, newPositionalPattern, propertyPattern, designation); + return ReferenceEquals(newPositionalPattern, PositionalPattern) ? this : new RecursivePattern(Id, Prefix, Markers, TypeQualifier, newPositionalPattern, PropertyPattern, Designation); } - public Cs.PropertyPatternClause? PropertyPattern => propertyPattern; + public Cs.PropertyPatternClause? PropertyPattern { get; set; } = propertyPattern; public RecursivePattern WithPropertyPattern(Cs.PropertyPatternClause? newPropertyPattern) { - return ReferenceEquals(newPropertyPattern, propertyPattern) ? this : new RecursivePattern(id, prefix, markers, typeQualifier, positionalPattern, newPropertyPattern, designation); + return ReferenceEquals(newPropertyPattern, PropertyPattern) ? this : new RecursivePattern(Id, Prefix, Markers, TypeQualifier, PositionalPattern, newPropertyPattern, Designation); } - public Cs.VariableDesignation? Designation => designation; + public Cs.VariableDesignation? Designation { get; set; } = designation; public RecursivePattern WithDesignation(Cs.VariableDesignation? newDesignation) { - return ReferenceEquals(newDesignation, designation) ? this : new RecursivePattern(id, prefix, markers, typeQualifier, positionalPattern, propertyPattern, newDesignation); + return ReferenceEquals(newDesignation, Designation) ? this : new RecursivePattern(Id, Prefix, Markers, TypeQualifier, PositionalPattern, PropertyPattern, newDesignation); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.CSharp/Tree/RefExpression.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/RefExpression.g.cs index 6c561131..8703a149 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/RefExpression.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/RefExpression.g.cs @@ -54,29 +54,29 @@ Expression expression return v.VisitRefExpression(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public RefExpression WithId(Guid newId) { - return newId == id ? this : new RefExpression(newId, prefix, markers, expression); + return newId == Id ? this : new RefExpression(newId, Prefix, Markers, Expression); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public RefExpression WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new RefExpression(id, newPrefix, markers, expression); + return newPrefix == Prefix ? this : new RefExpression(Id, newPrefix, Markers, Expression); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public RefExpression WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new RefExpression(id, prefix, newMarkers, expression); + return ReferenceEquals(newMarkers, Markers) ? this : new RefExpression(Id, Prefix, newMarkers, Expression); } - public Expression Expression => expression; + public Expression Expression { get; set; } = expression; public RefExpression WithExpression(Expression newExpression) { - return ReferenceEquals(newExpression, expression) ? this : new RefExpression(id, prefix, markers, newExpression); + return ReferenceEquals(newExpression, Expression) ? this : new RefExpression(Id, Prefix, Markers, newExpression); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.CSharp/Tree/RefStructConstraint.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/RefStructConstraint.g.cs index 4729bec8..53267895 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/RefStructConstraint.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/RefStructConstraint.g.cs @@ -42,23 +42,23 @@ Markers markers return v.VisitRefStructConstraint(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public RefStructConstraint WithId(Guid newId) { - return newId == id ? this : new RefStructConstraint(newId, prefix, markers); + return newId == Id ? this : new RefStructConstraint(newId, Prefix, Markers); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public RefStructConstraint WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new RefStructConstraint(id, newPrefix, markers); + return newPrefix == Prefix ? this : new RefStructConstraint(Id, newPrefix, Markers); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public RefStructConstraint WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new RefStructConstraint(id, prefix, newMarkers); + return ReferenceEquals(newMarkers, Markers) ? this : new RefStructConstraint(Id, Prefix, newMarkers); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.CSharp/Tree/RefType.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/RefType.g.cs index d6bbe71a..7692b688 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/RefType.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/RefType.g.cs @@ -57,41 +57,41 @@ public partial class RefType( return v.VisitRefType(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public RefType WithId(Guid newId) { - return newId == id ? this : new RefType(newId, prefix, markers, readonlyKeyword, typeIdentifier, type); + return newId == Id ? this : new RefType(newId, Prefix, Markers, ReadonlyKeyword, TypeIdentifier, Type); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public RefType WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new RefType(id, newPrefix, markers, readonlyKeyword, typeIdentifier, type); + return newPrefix == Prefix ? this : new RefType(Id, newPrefix, Markers, ReadonlyKeyword, TypeIdentifier, Type); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public RefType WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new RefType(id, prefix, newMarkers, readonlyKeyword, typeIdentifier, type); + return ReferenceEquals(newMarkers, Markers) ? this : new RefType(Id, Prefix, newMarkers, ReadonlyKeyword, TypeIdentifier, Type); } - public J.Modifier? ReadonlyKeyword => readonlyKeyword; + public J.Modifier? ReadonlyKeyword { get; set; } = readonlyKeyword; public RefType WithReadonlyKeyword(J.Modifier? newReadonlyKeyword) { - return ReferenceEquals(newReadonlyKeyword, readonlyKeyword) ? this : new RefType(id, prefix, markers, newReadonlyKeyword, typeIdentifier, type); + return ReferenceEquals(newReadonlyKeyword, ReadonlyKeyword) ? this : new RefType(Id, Prefix, Markers, newReadonlyKeyword, TypeIdentifier, Type); } - public TypeTree TypeIdentifier => typeIdentifier; + public TypeTree TypeIdentifier { get; set; } = typeIdentifier; public RefType WithTypeIdentifier(TypeTree newTypeIdentifier) { - return ReferenceEquals(newTypeIdentifier, typeIdentifier) ? this : new RefType(id, prefix, markers, readonlyKeyword, newTypeIdentifier, type); + return ReferenceEquals(newTypeIdentifier, TypeIdentifier) ? this : new RefType(Id, Prefix, Markers, ReadonlyKeyword, newTypeIdentifier, Type); } - public JavaType? Type => type; + public JavaType? Type { get; set; } = type; public RefType WithType(JavaType? newType) { - return newType == type ? this : new RefType(id, prefix, markers, readonlyKeyword, typeIdentifier, newType); + return newType == Type ? this : new RefType(Id, Prefix, Markers, ReadonlyKeyword, TypeIdentifier, newType); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.CSharp/Tree/RelationalPattern.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/RelationalPattern.g.cs index 1660514e..480d0b76 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/RelationalPattern.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/RelationalPattern.g.cs @@ -85,36 +85,36 @@ public PaddingHelper Padding return v.VisitRelationalPattern(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public RelationalPattern WithId(Guid newId) { - return newId == id ? this : new RelationalPattern(newId, prefix, markers, _operator, value); + return newId == Id ? this : new RelationalPattern(newId, Prefix, Markers, _operator, Value); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public RelationalPattern WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new RelationalPattern(id, newPrefix, markers, _operator, value); + return newPrefix == Prefix ? this : new RelationalPattern(Id, newPrefix, Markers, _operator, Value); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public RelationalPattern WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new RelationalPattern(id, prefix, newMarkers, _operator, value); + return ReferenceEquals(newMarkers, Markers) ? this : new RelationalPattern(Id, Prefix, newMarkers, _operator, Value); } - private readonly JLeftPadded _operator = @operator; + private JLeftPadded _operator = @operator; public OperatorType Operator => _operator.Element; public RelationalPattern WithOperator(OperatorType newOperator) { return Padding.WithOperator(_operator.WithElement(newOperator)); } - public Expression Value => value; + public Expression Value { get; set; } = value; public RelationalPattern WithValue(Expression newValue) { - return ReferenceEquals(newValue, value) ? this : new RelationalPattern(id, prefix, markers, _operator, newValue); + return ReferenceEquals(newValue, Value) ? this : new RelationalPattern(Id, Prefix, Markers, _operator, newValue); } public enum OperatorType { @@ -125,11 +125,11 @@ public enum OperatorType } public sealed record PaddingHelper(Cs.RelationalPattern T) { - public JLeftPadded Operator => T._operator; + public JLeftPadded Operator { get => T._operator; set => T._operator = value; } public Cs.RelationalPattern WithOperator(JLeftPadded newOperator) { - return T._operator == newOperator ? T : new Cs.RelationalPattern(T.Id, T.Prefix, T.Markers, newOperator, T.Value); + return Operator == newOperator ? T : new Cs.RelationalPattern(T.Id, T.Prefix, T.Markers, newOperator, T.Value); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/SelectClause.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/SelectClause.g.cs index adc67663..e42cdbbd 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/SelectClause.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/SelectClause.g.cs @@ -48,29 +48,29 @@ Expression expression return v.VisitSelectClause(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public SelectClause WithId(Guid newId) { - return newId == id ? this : new SelectClause(newId, prefix, markers, expression); + return newId == Id ? this : new SelectClause(newId, Prefix, Markers, Expression); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public SelectClause WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new SelectClause(id, newPrefix, markers, expression); + return newPrefix == Prefix ? this : new SelectClause(Id, newPrefix, Markers, Expression); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public SelectClause WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new SelectClause(id, prefix, newMarkers, expression); + return ReferenceEquals(newMarkers, Markers) ? this : new SelectClause(Id, Prefix, newMarkers, Expression); } - public Expression Expression => expression; + public Expression Expression { get; set; } = expression; public SelectClause WithExpression(Expression newExpression) { - return ReferenceEquals(newExpression, expression) ? this : new SelectClause(id, prefix, markers, newExpression); + return ReferenceEquals(newExpression, Expression) ? this : new SelectClause(Id, Prefix, Markers, newExpression); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.CSharp/Tree/SingleVariableDesignation.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/SingleVariableDesignation.g.cs index 9804a3b6..8bf9d894 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/SingleVariableDesignation.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/SingleVariableDesignation.g.cs @@ -51,29 +51,29 @@ J.Identifier name return v.VisitSingleVariableDesignation(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public SingleVariableDesignation WithId(Guid newId) { - return newId == id ? this : new SingleVariableDesignation(newId, prefix, markers, name); + return newId == Id ? this : new SingleVariableDesignation(newId, Prefix, Markers, Name); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public SingleVariableDesignation WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new SingleVariableDesignation(id, newPrefix, markers, name); + return newPrefix == Prefix ? this : new SingleVariableDesignation(Id, newPrefix, Markers, Name); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public SingleVariableDesignation WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new SingleVariableDesignation(id, prefix, newMarkers, name); + return ReferenceEquals(newMarkers, Markers) ? this : new SingleVariableDesignation(Id, Prefix, newMarkers, Name); } - public J.Identifier Name => name; + public J.Identifier Name { get; set; } = name; public SingleVariableDesignation WithName(J.Identifier newName) { - return ReferenceEquals(newName, name) ? this : new SingleVariableDesignation(id, prefix, markers, newName); + return ReferenceEquals(newName, Name) ? this : new SingleVariableDesignation(Id, Prefix, Markers, newName); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.CSharp/Tree/SlicePattern.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/SlicePattern.g.cs index b5674b08..4c9d8788 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/SlicePattern.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/SlicePattern.g.cs @@ -59,23 +59,23 @@ Markers markers return v.VisitSlicePattern(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public SlicePattern WithId(Guid newId) { - return newId == id ? this : new SlicePattern(newId, prefix, markers); + return newId == Id ? this : new SlicePattern(newId, Prefix, Markers); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public SlicePattern WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new SlicePattern(id, newPrefix, markers); + return newPrefix == Prefix ? this : new SlicePattern(Id, newPrefix, Markers); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public SlicePattern WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new SlicePattern(id, prefix, newMarkers); + return ReferenceEquals(newMarkers, Markers) ? this : new SlicePattern(Id, Prefix, newMarkers); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.CSharp/Tree/StackAllocExpression.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/StackAllocExpression.g.cs index a3b30267..32c3e700 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/StackAllocExpression.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/StackAllocExpression.g.cs @@ -39,29 +39,29 @@ J.NewArray expression return v.VisitStackAllocExpression(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public StackAllocExpression WithId(Guid newId) { - return newId == id ? this : new StackAllocExpression(newId, prefix, markers, expression); + return newId == Id ? this : new StackAllocExpression(newId, Prefix, Markers, Expression); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public StackAllocExpression WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new StackAllocExpression(id, newPrefix, markers, expression); + return newPrefix == Prefix ? this : new StackAllocExpression(Id, newPrefix, Markers, Expression); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public StackAllocExpression WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new StackAllocExpression(id, prefix, newMarkers, expression); + return ReferenceEquals(newMarkers, Markers) ? this : new StackAllocExpression(Id, Prefix, newMarkers, Expression); } - public J.NewArray Expression => expression; + public J.NewArray Expression { get; set; } = expression; public StackAllocExpression WithExpression(J.NewArray newExpression) { - return ReferenceEquals(newExpression, expression) ? this : new StackAllocExpression(id, prefix, markers, newExpression); + return ReferenceEquals(newExpression, Expression) ? this : new StackAllocExpression(Id, Prefix, Markers, newExpression); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.CSharp/Tree/StatementExpression.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/StatementExpression.g.cs index 9a29b1f2..b7b95618 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/StatementExpression.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/StatementExpression.g.cs @@ -39,29 +39,29 @@ Statement statement return v.VisitStatementExpression(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public StatementExpression WithId(Guid newId) { - return newId == id ? this : new StatementExpression(newId, prefix, markers, statement); + return newId == Id ? this : new StatementExpression(newId, Prefix, Markers, Statement); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public StatementExpression WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new StatementExpression(id, newPrefix, markers, statement); + return newPrefix == Prefix ? this : new StatementExpression(Id, newPrefix, Markers, Statement); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public StatementExpression WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new StatementExpression(id, prefix, newMarkers, statement); + return ReferenceEquals(newMarkers, Markers) ? this : new StatementExpression(Id, Prefix, newMarkers, Statement); } - public Statement Statement => statement; + public Statement Statement { get; set; } = statement; public StatementExpression WithStatement(Statement newStatement) { - return ReferenceEquals(newStatement, statement) ? this : new StatementExpression(id, prefix, markers, newStatement); + return ReferenceEquals(newStatement, Statement) ? this : new StatementExpression(Id, Prefix, Markers, newStatement); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.CSharp/Tree/Subpattern.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/Subpattern.g.cs index 0ee504b2..e46eadc9 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/Subpattern.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/Subpattern.g.cs @@ -93,31 +93,31 @@ public PaddingHelper Padding return v.VisitSubpattern(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Subpattern WithId(Guid newId) { - return newId == id ? this : new Subpattern(newId, prefix, markers, name, _pattern); + return newId == Id ? this : new Subpattern(newId, Prefix, Markers, Name, _pattern); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Subpattern WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Subpattern(id, newPrefix, markers, name, _pattern); + return newPrefix == Prefix ? this : new Subpattern(Id, newPrefix, Markers, Name, _pattern); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Subpattern WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Subpattern(id, prefix, newMarkers, name, _pattern); + return ReferenceEquals(newMarkers, Markers) ? this : new Subpattern(Id, Prefix, newMarkers, Name, _pattern); } - public Expression? Name => name; + public Expression? Name { get; set; } = name; public Subpattern WithName(Expression? newName) { - return ReferenceEquals(newName, name) ? this : new Subpattern(id, prefix, markers, newName, _pattern); + return ReferenceEquals(newName, Name) ? this : new Subpattern(Id, Prefix, Markers, newName, _pattern); } - private readonly JLeftPadded _pattern = pattern; + private JLeftPadded _pattern = pattern; public Cs.Pattern Pattern => _pattern.Element; public Subpattern WithPattern(Cs.Pattern newPattern) @@ -126,11 +126,11 @@ public Subpattern WithPattern(Cs.Pattern newPattern) } public sealed record PaddingHelper(Cs.Subpattern T) { - public JLeftPadded Pattern => T._pattern; + public JLeftPadded Pattern { get => T._pattern; set => T._pattern = value; } public Cs.Subpattern WithPattern(JLeftPadded newPattern) { - return T._pattern == newPattern ? T : new Cs.Subpattern(T.Id, T.Prefix, T.Markers, T.Name, newPattern); + return Pattern == newPattern ? T : new Cs.Subpattern(T.Id, T.Prefix, T.Markers, T.Name, newPattern); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/SwitchExpression.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/SwitchExpression.g.cs index ac8f665b..76a0c9c4 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/SwitchExpression.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/SwitchExpression.g.cs @@ -82,32 +82,32 @@ public PaddingHelper Padding return v.VisitSwitchExpression(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public SwitchExpression WithId(Guid newId) { - return newId == id ? this : new SwitchExpression(newId, prefix, markers, _expression, _arms); + return newId == Id ? this : new SwitchExpression(newId, Prefix, Markers, _expression, _arms); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public SwitchExpression WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new SwitchExpression(id, newPrefix, markers, _expression, _arms); + return newPrefix == Prefix ? this : new SwitchExpression(Id, newPrefix, Markers, _expression, _arms); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public SwitchExpression WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new SwitchExpression(id, prefix, newMarkers, _expression, _arms); + return ReferenceEquals(newMarkers, Markers) ? this : new SwitchExpression(Id, Prefix, newMarkers, _expression, _arms); } - private readonly JRightPadded _expression = expression; + private JRightPadded _expression = expression; public Expression Expression => _expression.Element; public SwitchExpression WithExpression(Expression newExpression) { return Padding.WithExpression(_expression.WithElement(newExpression)); } - private readonly JContainer _arms = arms; + private JContainer _arms = arms; public IList Arms => _arms.GetElements(); public SwitchExpression WithArms(IList newArms) @@ -116,18 +116,18 @@ public SwitchExpression WithArms(IList newArms) } public sealed record PaddingHelper(Cs.SwitchExpression T) { - public JRightPadded Expression => T._expression; + public JRightPadded Expression { get => T._expression; set => T._expression = value; } public Cs.SwitchExpression WithExpression(JRightPadded newExpression) { - return T._expression == newExpression ? T : new Cs.SwitchExpression(T.Id, T.Prefix, T.Markers, newExpression, T._arms); + return Expression == newExpression ? T : new Cs.SwitchExpression(T.Id, T.Prefix, T.Markers, newExpression, T._arms); } - public JContainer Arms => T._arms; + public JContainer Arms { get => T._arms; set => T._arms = value; } public Cs.SwitchExpression WithArms(JContainer newArms) { - return T._arms == newArms ? T : new Cs.SwitchExpression(T.Id, T.Prefix, T.Markers, T._expression, newArms); + return Arms == newArms ? T : new Cs.SwitchExpression(T.Id, T.Prefix, T.Markers, T._expression, newArms); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/SwitchExpressionArm.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/SwitchExpressionArm.g.cs index 343afb79..f89fc42e 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/SwitchExpressionArm.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/SwitchExpressionArm.g.cs @@ -82,38 +82,38 @@ public PaddingHelper Padding return v.VisitSwitchExpressionArm(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public SwitchExpressionArm WithId(Guid newId) { - return newId == id ? this : new SwitchExpressionArm(newId, prefix, markers, pattern, _whenExpression, _expression); + return newId == Id ? this : new SwitchExpressionArm(newId, Prefix, Markers, Pattern, _whenExpression, _expression); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public SwitchExpressionArm WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new SwitchExpressionArm(id, newPrefix, markers, pattern, _whenExpression, _expression); + return newPrefix == Prefix ? this : new SwitchExpressionArm(Id, newPrefix, Markers, Pattern, _whenExpression, _expression); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public SwitchExpressionArm WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new SwitchExpressionArm(id, prefix, newMarkers, pattern, _whenExpression, _expression); + return ReferenceEquals(newMarkers, Markers) ? this : new SwitchExpressionArm(Id, Prefix, newMarkers, Pattern, _whenExpression, _expression); } - public Cs.Pattern Pattern => pattern; + public Cs.Pattern Pattern { get; set; } = pattern; public SwitchExpressionArm WithPattern(Cs.Pattern newPattern) { - return ReferenceEquals(newPattern, pattern) ? this : new SwitchExpressionArm(id, prefix, markers, newPattern, _whenExpression, _expression); + return ReferenceEquals(newPattern, Pattern) ? this : new SwitchExpressionArm(Id, Prefix, Markers, newPattern, _whenExpression, _expression); } - private readonly JLeftPadded? _whenExpression = whenExpression; + private JLeftPadded? _whenExpression = whenExpression; public Expression? WhenExpression => _whenExpression?.Element; public SwitchExpressionArm WithWhenExpression(Expression? newWhenExpression) { return Padding.WithWhenExpression(JLeftPadded.WithElement(_whenExpression, newWhenExpression)); } - private readonly JLeftPadded _expression = expression; + private JLeftPadded _expression = expression; public Expression Expression => _expression.Element; public SwitchExpressionArm WithExpression(Expression newExpression) @@ -122,18 +122,18 @@ public SwitchExpressionArm WithExpression(Expression newExpression) } public sealed record PaddingHelper(Cs.SwitchExpressionArm T) { - public JLeftPadded? WhenExpression => T._whenExpression; + public JLeftPadded? WhenExpression { get => T._whenExpression; set => T._whenExpression = value; } public Cs.SwitchExpressionArm WithWhenExpression(JLeftPadded? newWhenExpression) { - return T._whenExpression == newWhenExpression ? T : new Cs.SwitchExpressionArm(T.Id, T.Prefix, T.Markers, T.Pattern, newWhenExpression, T._expression); + return WhenExpression == newWhenExpression ? T : new Cs.SwitchExpressionArm(T.Id, T.Prefix, T.Markers, T.Pattern, newWhenExpression, T._expression); } - public JLeftPadded Expression => T._expression; + public JLeftPadded Expression { get => T._expression; set => T._expression = value; } public Cs.SwitchExpressionArm WithExpression(JLeftPadded newExpression) { - return T._expression == newExpression ? T : new Cs.SwitchExpressionArm(T.Id, T.Prefix, T.Markers, T.Pattern, T._whenExpression, newExpression); + return Expression == newExpression ? T : new Cs.SwitchExpressionArm(T.Id, T.Prefix, T.Markers, T.Pattern, T._whenExpression, newExpression); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/SwitchSection.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/SwitchSection.g.cs index 4c40637f..1f4d440d 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/SwitchSection.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/SwitchSection.g.cs @@ -87,31 +87,31 @@ public PaddingHelper Padding return v.VisitSwitchSection(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public SwitchSection WithId(Guid newId) { - return newId == id ? this : new SwitchSection(newId, prefix, markers, labels, _statements); + return newId == Id ? this : new SwitchSection(newId, Prefix, Markers, Labels, _statements); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public SwitchSection WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new SwitchSection(id, newPrefix, markers, labels, _statements); + return newPrefix == Prefix ? this : new SwitchSection(Id, newPrefix, Markers, Labels, _statements); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public SwitchSection WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new SwitchSection(id, prefix, newMarkers, labels, _statements); + return ReferenceEquals(newMarkers, Markers) ? this : new SwitchSection(Id, Prefix, newMarkers, Labels, _statements); } - public IList Labels => labels; + public IList Labels { get; set; } = labels; public SwitchSection WithLabels(IList newLabels) { - return newLabels == labels ? this : new SwitchSection(id, prefix, markers, newLabels, _statements); + return newLabels == Labels ? this : new SwitchSection(Id, Prefix, Markers, newLabels, _statements); } - private readonly IList> _statements = statements; + private IList> _statements = statements; public IList Statements => _statements.Elements(); public SwitchSection WithStatements(IList newStatements) @@ -120,11 +120,11 @@ public SwitchSection WithStatements(IList newStatements) } public sealed record PaddingHelper(Cs.SwitchSection T) { - public IList> Statements => T._statements; + public IList> Statements { get => T._statements; set => T._statements = value; } public Cs.SwitchSection WithStatements(IList> newStatements) { - return T._statements == newStatements ? T : new Cs.SwitchSection(T.Id, T.Prefix, T.Markers, T.Labels, newStatements); + return Statements == newStatements ? T : new Cs.SwitchSection(T.Id, T.Prefix, T.Markers, T.Labels, newStatements); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/SwitchStatement.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/SwitchStatement.g.cs index a5a438de..9baf1ed6 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/SwitchStatement.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/SwitchStatement.g.cs @@ -89,32 +89,32 @@ public PaddingHelper Padding return v.VisitSwitchStatement(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public SwitchStatement WithId(Guid newId) { - return newId == id ? this : new SwitchStatement(newId, prefix, markers, _expression, _sections); + return newId == Id ? this : new SwitchStatement(newId, Prefix, Markers, _expression, _sections); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public SwitchStatement WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new SwitchStatement(id, newPrefix, markers, _expression, _sections); + return newPrefix == Prefix ? this : new SwitchStatement(Id, newPrefix, Markers, _expression, _sections); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public SwitchStatement WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new SwitchStatement(id, prefix, newMarkers, _expression, _sections); + return ReferenceEquals(newMarkers, Markers) ? this : new SwitchStatement(Id, Prefix, newMarkers, _expression, _sections); } - private readonly JContainer _expression = expression; + private JContainer _expression = expression; public IList Expression => _expression.GetElements(); public SwitchStatement WithExpression(IList newExpression) { return Padding.WithExpression(JContainer.WithElements(_expression, newExpression)); } - private readonly JContainer _sections = sections; + private JContainer _sections = sections; public IList Sections => _sections.GetElements(); public SwitchStatement WithSections(IList newSections) @@ -123,18 +123,18 @@ public SwitchStatement WithSections(IList newSections) } public sealed record PaddingHelper(Cs.SwitchStatement T) { - public JContainer Expression => T._expression; + public JContainer Expression { get => T._expression; set => T._expression = value; } public Cs.SwitchStatement WithExpression(JContainer newExpression) { - return T._expression == newExpression ? T : new Cs.SwitchStatement(T.Id, T.Prefix, T.Markers, newExpression, T._sections); + return Expression == newExpression ? T : new Cs.SwitchStatement(T.Id, T.Prefix, T.Markers, newExpression, T._sections); } - public JContainer Sections => T._sections; + public JContainer Sections { get => T._sections; set => T._sections = value; } public Cs.SwitchStatement WithSections(JContainer newSections) { - return T._sections == newSections ? T : new Cs.SwitchStatement(T.Id, T.Prefix, T.Markers, T._expression, newSections); + return Sections == newSections ? T : new Cs.SwitchStatement(T.Id, T.Prefix, T.Markers, T._expression, newSections); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/Try.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/Try.g.cs index 7b6bcd31..12fccbf1 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/Try.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/Try.g.cs @@ -66,37 +66,37 @@ public PaddingHelper Padding return v.VisitTry(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Try WithId(Guid newId) { - return newId == id ? this : new Try(newId, prefix, markers, body, catches, _finally); + return newId == Id ? this : new Try(newId, Prefix, Markers, Body, Catches, _finally); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Try WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Try(id, newPrefix, markers, body, catches, _finally); + return newPrefix == Prefix ? this : new Try(Id, newPrefix, Markers, Body, Catches, _finally); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Try WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Try(id, prefix, newMarkers, body, catches, _finally); + return ReferenceEquals(newMarkers, Markers) ? this : new Try(Id, Prefix, newMarkers, Body, Catches, _finally); } - public J.Block Body => body; + public J.Block Body { get; set; } = body; public Try WithBody(J.Block newBody) { - return ReferenceEquals(newBody, body) ? this : new Try(id, prefix, markers, newBody, catches, _finally); + return ReferenceEquals(newBody, Body) ? this : new Try(Id, Prefix, Markers, newBody, Catches, _finally); } - public IList Catches => catches; + public IList Catches { get; set; } = catches; public Try WithCatches(IList newCatches) { - return newCatches == catches ? this : new Try(id, prefix, markers, body, newCatches, _finally); + return newCatches == Catches ? this : new Try(Id, Prefix, Markers, Body, newCatches, _finally); } - private readonly JLeftPadded? _finally = @finally; + private JLeftPadded? _finally = @finally; public J.Block? Finally => _finally?.Element; public Try WithFinally(J.Block? newFinally) @@ -162,50 +162,50 @@ public PaddingHelper Padding return v.VisitTryCatch(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Catch WithId(Guid newId) { - return newId == id ? this : new Catch(newId, prefix, markers, parameter, _filterExpression, body); + return newId == Id ? this : new Catch(newId, Prefix, Markers, Parameter, _filterExpression, Body); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Catch WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Catch(id, newPrefix, markers, parameter, _filterExpression, body); + return newPrefix == Prefix ? this : new Catch(Id, newPrefix, Markers, Parameter, _filterExpression, Body); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Catch WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Catch(id, prefix, newMarkers, parameter, _filterExpression, body); + return ReferenceEquals(newMarkers, Markers) ? this : new Catch(Id, Prefix, newMarkers, Parameter, _filterExpression, Body); } - public J.ControlParentheses Parameter => parameter; + public J.ControlParentheses Parameter { get; set; } = parameter; public Catch WithParameter(J.ControlParentheses newParameter) { - return ReferenceEquals(newParameter, parameter) ? this : new Catch(id, prefix, markers, newParameter, _filterExpression, body); + return ReferenceEquals(newParameter, Parameter) ? this : new Catch(Id, Prefix, Markers, newParameter, _filterExpression, Body); } - private readonly JLeftPadded>? _filterExpression = filterExpression; + private JLeftPadded>? _filterExpression = filterExpression; public J.ControlParentheses? FilterExpression => _filterExpression?.Element; public Catch WithFilterExpression(J.ControlParentheses? newFilterExpression) { return Padding.WithFilterExpression(JLeftPadded>.WithElement(_filterExpression, newFilterExpression)); } - public J.Block Body => body; + public J.Block Body { get; set; } = body; public Catch WithBody(J.Block newBody) { - return ReferenceEquals(newBody, body) ? this : new Catch(id, prefix, markers, parameter, _filterExpression, newBody); + return ReferenceEquals(newBody, Body) ? this : new Catch(Id, Prefix, Markers, Parameter, _filterExpression, newBody); } public sealed record PaddingHelper(Cs.Try.Catch T) { - public JLeftPadded>? FilterExpression => T._filterExpression; + public JLeftPadded>? FilterExpression { get => T._filterExpression; set => T._filterExpression = value; } public Cs.Try.Catch WithFilterExpression(JLeftPadded>? newFilterExpression) { - return T._filterExpression == newFilterExpression ? T : new Cs.Try.Catch(T.Id, T.Prefix, T.Markers, T.Parameter, newFilterExpression, T.Body); + return FilterExpression == newFilterExpression ? T : new Cs.Try.Catch(T.Id, T.Prefix, T.Markers, T.Parameter, newFilterExpression, T.Body); } } @@ -227,11 +227,11 @@ public override int GetHashCode() } public sealed record PaddingHelper(Cs.Try T) { - public JLeftPadded? Finally => T._finally; + public JLeftPadded? Finally { get => T._finally; set => T._finally = value; } public Cs.Try WithFinally(JLeftPadded? newFinally) { - return T._finally == newFinally ? T : new Cs.Try(T.Id, T.Prefix, T.Markers, T.Body, T.Catches, newFinally); + return Finally == newFinally ? T : new Cs.Try(T.Id, T.Prefix, T.Markers, T.Body, T.Catches, newFinally); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/TupleElement.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/TupleElement.g.cs index a9bfb276..bb159748 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/TupleElement.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/TupleElement.g.cs @@ -44,35 +44,35 @@ public partial class TupleElement( return v.VisitTupleElement(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public TupleElement WithId(Guid newId) { - return newId == id ? this : new TupleElement(newId, prefix, markers, type, name); + return newId == Id ? this : new TupleElement(newId, Prefix, Markers, Type, Name); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public TupleElement WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new TupleElement(id, newPrefix, markers, type, name); + return newPrefix == Prefix ? this : new TupleElement(Id, newPrefix, Markers, Type, Name); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public TupleElement WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new TupleElement(id, prefix, newMarkers, type, name); + return ReferenceEquals(newMarkers, Markers) ? this : new TupleElement(Id, Prefix, newMarkers, Type, Name); } - public TypeTree Type => type; + public TypeTree Type { get; set; } = type; public TupleElement WithType(TypeTree newType) { - return ReferenceEquals(newType, type) ? this : new TupleElement(id, prefix, markers, newType, name); + return ReferenceEquals(newType, Type) ? this : new TupleElement(Id, Prefix, Markers, newType, Name); } - public J.Identifier? Name => name; + public J.Identifier? Name { get; set; } = name; public TupleElement WithName(J.Identifier? newName) { - return ReferenceEquals(newName, name) ? this : new TupleElement(id, prefix, markers, type, newName); + return ReferenceEquals(newName, Name) ? this : new TupleElement(Id, Prefix, Markers, Type, newName); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.CSharp/Tree/TupleExpression.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/TupleExpression.g.cs index 0c1da740..c4dc502d 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/TupleExpression.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/TupleExpression.g.cs @@ -79,25 +79,25 @@ public PaddingHelper Padding return v.VisitTupleExpression(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public TupleExpression WithId(Guid newId) { - return newId == id ? this : new TupleExpression(newId, prefix, markers, _arguments); + return newId == Id ? this : new TupleExpression(newId, Prefix, Markers, _arguments); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public TupleExpression WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new TupleExpression(id, newPrefix, markers, _arguments); + return newPrefix == Prefix ? this : new TupleExpression(Id, newPrefix, Markers, _arguments); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public TupleExpression WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new TupleExpression(id, prefix, newMarkers, _arguments); + return ReferenceEquals(newMarkers, Markers) ? this : new TupleExpression(Id, Prefix, newMarkers, _arguments); } - private readonly JContainer _arguments = arguments; + private JContainer _arguments = arguments; public IList Arguments => _arguments.GetElements(); public TupleExpression WithArguments(IList newArguments) @@ -106,11 +106,11 @@ public TupleExpression WithArguments(IList newArguments) } public sealed record PaddingHelper(Cs.TupleExpression T) { - public JContainer Arguments => T._arguments; + public JContainer Arguments { get => T._arguments; set => T._arguments = value; } public Cs.TupleExpression WithArguments(JContainer newArguments) { - return T._arguments == newArguments ? T : new Cs.TupleExpression(T.Id, T.Prefix, T.Markers, newArguments); + return Arguments == newArguments ? T : new Cs.TupleExpression(T.Id, T.Prefix, T.Markers, newArguments); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/TupleType.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/TupleType.g.cs index 84623dcd..bcb6ca0e 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/TupleType.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/TupleType.g.cs @@ -83,44 +83,44 @@ public PaddingHelper Padding return v.VisitTupleType(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public TupleType WithId(Guid newId) { - return newId == id ? this : new TupleType(newId, prefix, markers, _elements, type); + return newId == Id ? this : new TupleType(newId, Prefix, Markers, _elements, Type); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public TupleType WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new TupleType(id, newPrefix, markers, _elements, type); + return newPrefix == Prefix ? this : new TupleType(Id, newPrefix, Markers, _elements, Type); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public TupleType WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new TupleType(id, prefix, newMarkers, _elements, type); + return ReferenceEquals(newMarkers, Markers) ? this : new TupleType(Id, Prefix, newMarkers, _elements, Type); } - private readonly JContainer _elements = elements; + private JContainer _elements = elements; public IList Elements => _elements.GetElements(); public TupleType WithElements(IList newElements) { return Padding.WithElements(JContainer.WithElements(_elements, newElements)); } - public JavaType? Type => type; + public JavaType? Type { get; set; } = type; public TupleType WithType(JavaType? newType) { - return newType == type ? this : new TupleType(id, prefix, markers, _elements, newType); + return newType == Type ? this : new TupleType(Id, Prefix, Markers, _elements, newType); } public sealed record PaddingHelper(Cs.TupleType T) { - public JContainer Elements => T._elements; + public JContainer Elements { get => T._elements; set => T._elements = value; } public Cs.TupleType WithElements(JContainer newElements) { - return T._elements == newElements ? T : new Cs.TupleType(T.Id, T.Prefix, T.Markers, newElements, T.Type); + return Elements == newElements ? T : new Cs.TupleType(T.Id, T.Prefix, T.Markers, newElements, T.Type); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/TypeConstraint.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/TypeConstraint.g.cs index 6955ff64..d98053e3 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/TypeConstraint.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/TypeConstraint.g.cs @@ -69,29 +69,29 @@ public PaddingHelper Padding return v.VisitTypeConstraint(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public TypeConstraint WithId(Guid newId) { - return newId == id ? this : new TypeConstraint(newId, prefix, markers, typeExpression); + return newId == Id ? this : new TypeConstraint(newId, Prefix, Markers, TypeExpression); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public TypeConstraint WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new TypeConstraint(id, newPrefix, markers, typeExpression); + return newPrefix == Prefix ? this : new TypeConstraint(Id, newPrefix, Markers, TypeExpression); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public TypeConstraint WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new TypeConstraint(id, prefix, newMarkers, typeExpression); + return ReferenceEquals(newMarkers, Markers) ? this : new TypeConstraint(Id, Prefix, newMarkers, TypeExpression); } - public TypeTree TypeExpression => typeExpression; + public TypeTree TypeExpression { get; set; } = typeExpression; public TypeConstraint WithTypeExpression(TypeTree newTypeExpression) { - return ReferenceEquals(newTypeExpression, typeExpression) ? this : new TypeConstraint(id, prefix, markers, newTypeExpression); + return ReferenceEquals(newTypeExpression, TypeExpression) ? this : new TypeConstraint(Id, Prefix, Markers, newTypeExpression); } public sealed record PaddingHelper(Cs.TypeConstraint T) { diff --git a/Rewrite/src/Rewrite.CSharp/Tree/TypeParameter.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/TypeParameter.g.cs index aa0e3629..b70b46ca 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/TypeParameter.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/TypeParameter.g.cs @@ -81,42 +81,42 @@ public PaddingHelper Padding return v.VisitTypeParameter(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public TypeParameter WithId(Guid newId) { - return newId == id ? this : new TypeParameter(newId, prefix, markers, attributeLists, _variance, name); + return newId == Id ? this : new TypeParameter(newId, Prefix, Markers, AttributeLists, _variance, Name); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public TypeParameter WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new TypeParameter(id, newPrefix, markers, attributeLists, _variance, name); + return newPrefix == Prefix ? this : new TypeParameter(Id, newPrefix, Markers, AttributeLists, _variance, Name); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public TypeParameter WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new TypeParameter(id, prefix, newMarkers, attributeLists, _variance, name); + return ReferenceEquals(newMarkers, Markers) ? this : new TypeParameter(Id, Prefix, newMarkers, AttributeLists, _variance, Name); } - public IList AttributeLists => attributeLists; + public IList AttributeLists { get; set; } = attributeLists; public TypeParameter WithAttributeLists(IList newAttributeLists) { - return newAttributeLists == attributeLists ? this : new TypeParameter(id, prefix, markers, newAttributeLists, _variance, name); + return newAttributeLists == AttributeLists ? this : new TypeParameter(Id, Prefix, Markers, newAttributeLists, _variance, Name); } - private readonly JLeftPadded? _variance = variance; + private JLeftPadded? _variance = variance; public VarianceKind? Variance => _variance?.Element; public TypeParameter WithVariance(VarianceKind? newVariance) { return Padding.WithVariance(newVariance == null ? null : JLeftPadded.WithElement(_variance, newVariance.Value)); } - public J.Identifier Name => name; + public J.Identifier Name { get; set; } = name; public TypeParameter WithName(J.Identifier newName) { - return ReferenceEquals(newName, name) ? this : new TypeParameter(id, prefix, markers, attributeLists, _variance, newName); + return ReferenceEquals(newName, Name) ? this : new TypeParameter(Id, Prefix, Markers, AttributeLists, _variance, newName); } public enum VarianceKind { @@ -125,11 +125,11 @@ public enum VarianceKind } public sealed record PaddingHelper(Cs.TypeParameter T) { - public JLeftPadded? Variance => T._variance; + public JLeftPadded? Variance { get => T._variance; set => T._variance = value; } public Cs.TypeParameter WithVariance(JLeftPadded? newVariance) { - return T._variance == newVariance ? T : new Cs.TypeParameter(T.Id, T.Prefix, T.Markers, T.AttributeLists, newVariance, T.Name); + return Variance == newVariance ? T : new Cs.TypeParameter(T.Id, T.Prefix, T.Markers, T.AttributeLists, newVariance, T.Name); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/TypeParameterConstraintClause.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/TypeParameterConstraintClause.g.cs index 3fca48c4..bab686bb 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/TypeParameterConstraintClause.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/TypeParameterConstraintClause.g.cs @@ -65,32 +65,32 @@ public PaddingHelper Padding return v.VisitTypeParameterConstraintClause(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public TypeParameterConstraintClause WithId(Guid newId) { - return newId == id ? this : new TypeParameterConstraintClause(newId, prefix, markers, _typeParameter, _typeParameterConstraints); + return newId == Id ? this : new TypeParameterConstraintClause(newId, Prefix, Markers, _typeParameter, _typeParameterConstraints); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public TypeParameterConstraintClause WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new TypeParameterConstraintClause(id, newPrefix, markers, _typeParameter, _typeParameterConstraints); + return newPrefix == Prefix ? this : new TypeParameterConstraintClause(Id, newPrefix, Markers, _typeParameter, _typeParameterConstraints); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public TypeParameterConstraintClause WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new TypeParameterConstraintClause(id, prefix, newMarkers, _typeParameter, _typeParameterConstraints); + return ReferenceEquals(newMarkers, Markers) ? this : new TypeParameterConstraintClause(Id, Prefix, newMarkers, _typeParameter, _typeParameterConstraints); } - private readonly JRightPadded _typeParameter = typeParameter; + private JRightPadded _typeParameter = typeParameter; public J.Identifier TypeParameter => _typeParameter.Element; public TypeParameterConstraintClause WithTypeParameter(J.Identifier newTypeParameter) { return Padding.WithTypeParameter(_typeParameter.WithElement(newTypeParameter)); } - private readonly JContainer _typeParameterConstraints = typeParameterConstraints; + private JContainer _typeParameterConstraints = typeParameterConstraints; public IList TypeParameterConstraints => _typeParameterConstraints.GetElements(); public TypeParameterConstraintClause WithTypeParameterConstraints(IList newTypeParameterConstraints) @@ -99,18 +99,18 @@ public TypeParameterConstraintClause WithTypeParameterConstraints(IList TypeParameter => T._typeParameter; + public JRightPadded TypeParameter { get => T._typeParameter; set => T._typeParameter = value; } public Cs.TypeParameterConstraintClause WithTypeParameter(JRightPadded newTypeParameter) { - return T._typeParameter == newTypeParameter ? T : new Cs.TypeParameterConstraintClause(T.Id, T.Prefix, T.Markers, newTypeParameter, T._typeParameterConstraints); + return TypeParameter == newTypeParameter ? T : new Cs.TypeParameterConstraintClause(T.Id, T.Prefix, T.Markers, newTypeParameter, T._typeParameterConstraints); } - public JContainer TypeParameterConstraints => T._typeParameterConstraints; + public JContainer TypeParameterConstraints { get => T._typeParameterConstraints; set => T._typeParameterConstraints = value; } public Cs.TypeParameterConstraintClause WithTypeParameterConstraints(JContainer newTypeParameterConstraints) { - return T._typeParameterConstraints == newTypeParameterConstraints ? T : new Cs.TypeParameterConstraintClause(T.Id, T.Prefix, T.Markers, T._typeParameter, newTypeParameterConstraints); + return TypeParameterConstraints == newTypeParameterConstraints ? T : new Cs.TypeParameterConstraintClause(T.Id, T.Prefix, T.Markers, T._typeParameter, newTypeParameterConstraints); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/TypePattern.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/TypePattern.g.cs index 422aba3e..e80e9a48 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/TypePattern.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/TypePattern.g.cs @@ -63,35 +63,35 @@ public partial class TypePattern( return v.VisitTypePattern(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public TypePattern WithId(Guid newId) { - return newId == id ? this : new TypePattern(newId, prefix, markers, typeIdentifier, designation); + return newId == Id ? this : new TypePattern(newId, Prefix, Markers, TypeIdentifier, Designation); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public TypePattern WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new TypePattern(id, newPrefix, markers, typeIdentifier, designation); + return newPrefix == Prefix ? this : new TypePattern(Id, newPrefix, Markers, TypeIdentifier, Designation); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public TypePattern WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new TypePattern(id, prefix, newMarkers, typeIdentifier, designation); + return ReferenceEquals(newMarkers, Markers) ? this : new TypePattern(Id, Prefix, newMarkers, TypeIdentifier, Designation); } - public TypeTree TypeIdentifier => typeIdentifier; + public TypeTree TypeIdentifier { get; set; } = typeIdentifier; public TypePattern WithTypeIdentifier(TypeTree newTypeIdentifier) { - return ReferenceEquals(newTypeIdentifier, typeIdentifier) ? this : new TypePattern(id, prefix, markers, newTypeIdentifier, designation); + return ReferenceEquals(newTypeIdentifier, TypeIdentifier) ? this : new TypePattern(Id, Prefix, Markers, newTypeIdentifier, Designation); } - public Cs.VariableDesignation? Designation => designation; + public Cs.VariableDesignation? Designation { get; set; } = designation; public TypePattern WithDesignation(Cs.VariableDesignation? newDesignation) { - return ReferenceEquals(newDesignation, designation) ? this : new TypePattern(id, prefix, markers, typeIdentifier, newDesignation); + return ReferenceEquals(newDesignation, Designation) ? this : new TypePattern(Id, Prefix, Markers, TypeIdentifier, newDesignation); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.CSharp/Tree/Unary.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/Unary.g.cs index 248026cf..e818c423 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/Unary.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/Unary.g.cs @@ -66,42 +66,42 @@ public PaddingHelper Padding return v.VisitUnary(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Unary WithId(Guid newId) { - return newId == id ? this : new Unary(newId, prefix, markers, _operator, expression, type); + return newId == Id ? this : new Unary(newId, Prefix, Markers, _operator, Expression, Type); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Unary WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Unary(id, newPrefix, markers, _operator, expression, type); + return newPrefix == Prefix ? this : new Unary(Id, newPrefix, Markers, _operator, Expression, Type); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Unary WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Unary(id, prefix, newMarkers, _operator, expression, type); + return ReferenceEquals(newMarkers, Markers) ? this : new Unary(Id, Prefix, newMarkers, _operator, Expression, Type); } - private readonly JLeftPadded _operator = @operator; + private JLeftPadded _operator = @operator; public Types Operator => _operator.Element; public Unary WithOperator(Types newOperator) { return Padding.WithOperator(_operator.WithElement(newOperator)); } - public Expression Expression => expression; + public Expression Expression { get; set; } = expression; public Unary WithExpression(Expression newExpression) { - return ReferenceEquals(newExpression, expression) ? this : new Unary(id, prefix, markers, _operator, newExpression, type); + return ReferenceEquals(newExpression, Expression) ? this : new Unary(Id, Prefix, Markers, _operator, newExpression, Type); } - public JavaType? Type => type; + public JavaType? Type { get; set; } = type; public Unary WithType(JavaType? newType) { - return newType == type ? this : new Unary(id, prefix, markers, _operator, expression, newType); + return newType == Type ? this : new Unary(Id, Prefix, Markers, _operator, Expression, newType); } public enum Types { @@ -114,11 +114,11 @@ public enum Types } public sealed record PaddingHelper(Cs.Unary T) { - public JLeftPadded Operator => T._operator; + public JLeftPadded Operator { get => T._operator; set => T._operator = value; } public Cs.Unary WithOperator(JLeftPadded newOperator) { - return T._operator == newOperator ? T : new Cs.Unary(T.Id, T.Prefix, T.Markers, newOperator, T.Expression, T.Type); + return Operator == newOperator ? T : new Cs.Unary(T.Id, T.Prefix, T.Markers, newOperator, T.Expression, T.Type); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/UnaryPattern.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/UnaryPattern.g.cs index cd754a2f..076bf85a 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/UnaryPattern.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/UnaryPattern.g.cs @@ -58,35 +58,35 @@ Pattern pattern return v.VisitUnaryPattern(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public UnaryPattern WithId(Guid newId) { - return newId == id ? this : new UnaryPattern(newId, prefix, markers, @operator, pattern); + return newId == Id ? this : new UnaryPattern(newId, Prefix, Markers, Operator, Pattern); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public UnaryPattern WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new UnaryPattern(id, newPrefix, markers, @operator, pattern); + return newPrefix == Prefix ? this : new UnaryPattern(Id, newPrefix, Markers, Operator, Pattern); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public UnaryPattern WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new UnaryPattern(id, prefix, newMarkers, @operator, pattern); + return ReferenceEquals(newMarkers, Markers) ? this : new UnaryPattern(Id, Prefix, newMarkers, Operator, Pattern); } - public Cs.Keyword Operator => @operator; + public Cs.Keyword Operator { get; set; } = @operator; public UnaryPattern WithOperator(Cs.Keyword newOperator) { - return ReferenceEquals(newOperator, @operator) ? this : new UnaryPattern(id, prefix, markers, newOperator, pattern); + return ReferenceEquals(newOperator, Operator) ? this : new UnaryPattern(Id, Prefix, Markers, newOperator, Pattern); } - public Cs.Pattern Pattern => pattern; + public Cs.Pattern Pattern { get; set; } = pattern; public UnaryPattern WithPattern(Cs.Pattern newPattern) { - return ReferenceEquals(newPattern, pattern) ? this : new UnaryPattern(id, prefix, markers, @operator, newPattern); + return ReferenceEquals(newPattern, Pattern) ? this : new UnaryPattern(Id, Prefix, Markers, Operator, newPattern); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.CSharp/Tree/UnsafeStatement.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/UnsafeStatement.g.cs index bf1d2b5b..7a9741d3 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/UnsafeStatement.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/UnsafeStatement.g.cs @@ -69,29 +69,29 @@ J.Block block return v.VisitUnsafeStatement(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public UnsafeStatement WithId(Guid newId) { - return newId == id ? this : new UnsafeStatement(newId, prefix, markers, block); + return newId == Id ? this : new UnsafeStatement(newId, Prefix, Markers, Block); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public UnsafeStatement WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new UnsafeStatement(id, newPrefix, markers, block); + return newPrefix == Prefix ? this : new UnsafeStatement(Id, newPrefix, Markers, Block); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public UnsafeStatement WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new UnsafeStatement(id, prefix, newMarkers, block); + return ReferenceEquals(newMarkers, Markers) ? this : new UnsafeStatement(Id, Prefix, newMarkers, Block); } - public J.Block Block => block; + public J.Block Block { get; set; } = block; public UnsafeStatement WithBlock(J.Block newBlock) { - return ReferenceEquals(newBlock, block) ? this : new UnsafeStatement(id, prefix, markers, newBlock); + return ReferenceEquals(newBlock, Block) ? this : new UnsafeStatement(Id, Prefix, Markers, newBlock); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.CSharp/Tree/UsingDirective.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/UsingDirective.g.cs index 03b48bfe..186b1214 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/UsingDirective.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/UsingDirective.g.cs @@ -68,86 +68,86 @@ public PaddingHelper Padding return v.VisitUsingDirective(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public UsingDirective WithId(Guid newId) { - return newId == id ? this : new UsingDirective(newId, prefix, markers, _global, _static, _unsafe, _alias, namespaceOrType); + return newId == Id ? this : new UsingDirective(newId, Prefix, Markers, _global, _static, _unsafe, _alias, NamespaceOrType); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public UsingDirective WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new UsingDirective(id, newPrefix, markers, _global, _static, _unsafe, _alias, namespaceOrType); + return newPrefix == Prefix ? this : new UsingDirective(Id, newPrefix, Markers, _global, _static, _unsafe, _alias, NamespaceOrType); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public UsingDirective WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new UsingDirective(id, prefix, newMarkers, _global, _static, _unsafe, _alias, namespaceOrType); + return ReferenceEquals(newMarkers, Markers) ? this : new UsingDirective(Id, Prefix, newMarkers, _global, _static, _unsafe, _alias, NamespaceOrType); } - private readonly JRightPadded _global = global; + private JRightPadded _global = global; public bool Global => _global.Element; public UsingDirective WithGlobal(bool newGlobal) { return Padding.WithGlobal(_global.WithElement(newGlobal)); } - private readonly JLeftPadded _static = @static; + private JLeftPadded _static = @static; public bool Static => _static.Element; public UsingDirective WithStatic(bool newStatic) { return Padding.WithStatic(_static.WithElement(newStatic)); } - private readonly JLeftPadded _unsafe = @unsafe; + private JLeftPadded _unsafe = @unsafe; public bool Unsafe => _unsafe.Element; public UsingDirective WithUnsafe(bool newUnsafe) { return Padding.WithUnsafe(_unsafe.WithElement(newUnsafe)); } - private readonly JRightPadded? _alias = alias; + private JRightPadded? _alias = alias; public J.Identifier? Alias => _alias?.Element; public UsingDirective WithAlias(J.Identifier? newAlias) { return Padding.WithAlias(JRightPadded.WithElement(_alias, newAlias)); } - public TypeTree NamespaceOrType => namespaceOrType; + public TypeTree NamespaceOrType { get; set; } = namespaceOrType; public UsingDirective WithNamespaceOrType(TypeTree newNamespaceOrType) { - return ReferenceEquals(newNamespaceOrType, namespaceOrType) ? this : new UsingDirective(id, prefix, markers, _global, _static, _unsafe, _alias, newNamespaceOrType); + return ReferenceEquals(newNamespaceOrType, NamespaceOrType) ? this : new UsingDirective(Id, Prefix, Markers, _global, _static, _unsafe, _alias, newNamespaceOrType); } public sealed record PaddingHelper(Cs.UsingDirective T) { - public JRightPadded Global => T._global; + public JRightPadded Global { get => T._global; set => T._global = value; } public Cs.UsingDirective WithGlobal(JRightPadded newGlobal) { - return T._global == newGlobal ? T : new Cs.UsingDirective(T.Id, T.Prefix, T.Markers, newGlobal, T._static, T._unsafe, T._alias, T.NamespaceOrType); + return Global == newGlobal ? T : new Cs.UsingDirective(T.Id, T.Prefix, T.Markers, newGlobal, T._static, T._unsafe, T._alias, T.NamespaceOrType); } - public JLeftPadded Static => T._static; + public JLeftPadded Static { get => T._static; set => T._static = value; } public Cs.UsingDirective WithStatic(JLeftPadded newStatic) { - return T._static == newStatic ? T : new Cs.UsingDirective(T.Id, T.Prefix, T.Markers, T._global, newStatic, T._unsafe, T._alias, T.NamespaceOrType); + return Static == newStatic ? T : new Cs.UsingDirective(T.Id, T.Prefix, T.Markers, T._global, newStatic, T._unsafe, T._alias, T.NamespaceOrType); } - public JLeftPadded Unsafe => T._unsafe; + public JLeftPadded Unsafe { get => T._unsafe; set => T._unsafe = value; } public Cs.UsingDirective WithUnsafe(JLeftPadded newUnsafe) { - return T._unsafe == newUnsafe ? T : new Cs.UsingDirective(T.Id, T.Prefix, T.Markers, T._global, T._static, newUnsafe, T._alias, T.NamespaceOrType); + return Unsafe == newUnsafe ? T : new Cs.UsingDirective(T.Id, T.Prefix, T.Markers, T._global, T._static, newUnsafe, T._alias, T.NamespaceOrType); } - public JRightPadded? Alias => T._alias; + public JRightPadded? Alias { get => T._alias; set => T._alias = value; } public Cs.UsingDirective WithAlias(JRightPadded? newAlias) { - return T._alias == newAlias ? T : new Cs.UsingDirective(T.Id, T.Prefix, T.Markers, T._global, T._static, T._unsafe, newAlias, T.NamespaceOrType); + return Alias == newAlias ? T : new Cs.UsingDirective(T.Id, T.Prefix, T.Markers, T._global, T._static, T._unsafe, newAlias, T.NamespaceOrType); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/UsingStatement.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/UsingStatement.g.cs index 8ee4b5e0..947295b6 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/UsingStatement.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/UsingStatement.g.cs @@ -66,50 +66,50 @@ public PaddingHelper Padding return v.VisitUsingStatement(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public UsingStatement WithId(Guid newId) { - return newId == id ? this : new UsingStatement(newId, prefix, markers, awaitKeyword, _expression, statement); + return newId == Id ? this : new UsingStatement(newId, Prefix, Markers, AwaitKeyword, _expression, Statement); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public UsingStatement WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new UsingStatement(id, newPrefix, markers, awaitKeyword, _expression, statement); + return newPrefix == Prefix ? this : new UsingStatement(Id, newPrefix, Markers, AwaitKeyword, _expression, Statement); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public UsingStatement WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new UsingStatement(id, prefix, newMarkers, awaitKeyword, _expression, statement); + return ReferenceEquals(newMarkers, Markers) ? this : new UsingStatement(Id, Prefix, newMarkers, AwaitKeyword, _expression, Statement); } - public Cs.Keyword? AwaitKeyword => awaitKeyword; + public Cs.Keyword? AwaitKeyword { get; set; } = awaitKeyword; public UsingStatement WithAwaitKeyword(Cs.Keyword? newAwaitKeyword) { - return ReferenceEquals(newAwaitKeyword, awaitKeyword) ? this : new UsingStatement(id, prefix, markers, newAwaitKeyword, _expression, statement); + return ReferenceEquals(newAwaitKeyword, AwaitKeyword) ? this : new UsingStatement(Id, Prefix, Markers, newAwaitKeyword, _expression, Statement); } - private readonly JLeftPadded _expression = expression; + private JLeftPadded _expression = expression; public Expression Expression => _expression.Element; public UsingStatement WithExpression(Expression newExpression) { return Padding.WithExpression(_expression.WithElement(newExpression)); } - public Statement Statement => statement; + public Statement Statement { get; set; } = statement; public UsingStatement WithStatement(Statement newStatement) { - return ReferenceEquals(newStatement, statement) ? this : new UsingStatement(id, prefix, markers, awaitKeyword, _expression, newStatement); + return ReferenceEquals(newStatement, Statement) ? this : new UsingStatement(Id, Prefix, Markers, AwaitKeyword, _expression, newStatement); } public sealed record PaddingHelper(Cs.UsingStatement T) { - public JLeftPadded Expression => T._expression; + public JLeftPadded Expression { get => T._expression; set => T._expression = value; } public Cs.UsingStatement WithExpression(JLeftPadded newExpression) { - return T._expression == newExpression ? T : new Cs.UsingStatement(T.Id, T.Prefix, T.Markers, T.AwaitKeyword, newExpression, T.Statement); + return Expression == newExpression ? T : new Cs.UsingStatement(T.Id, T.Prefix, T.Markers, T.AwaitKeyword, newExpression, T.Statement); } } diff --git a/Rewrite/src/Rewrite.CSharp/Tree/VarPattern.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/VarPattern.g.cs index 273861d8..b931559c 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/VarPattern.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/VarPattern.g.cs @@ -46,29 +46,29 @@ VariableDesignation designation return v.VisitVarPattern(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public VarPattern WithId(Guid newId) { - return newId == id ? this : new VarPattern(newId, prefix, markers, designation); + return newId == Id ? this : new VarPattern(newId, Prefix, Markers, Designation); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public VarPattern WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new VarPattern(id, newPrefix, markers, designation); + return newPrefix == Prefix ? this : new VarPattern(Id, newPrefix, Markers, Designation); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public VarPattern WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new VarPattern(id, prefix, newMarkers, designation); + return ReferenceEquals(newMarkers, Markers) ? this : new VarPattern(Id, Prefix, newMarkers, Designation); } - public Cs.VariableDesignation Designation => designation; + public Cs.VariableDesignation Designation { get; set; } = designation; public VarPattern WithDesignation(Cs.VariableDesignation newDesignation) { - return ReferenceEquals(newDesignation, designation) ? this : new VarPattern(id, prefix, markers, newDesignation); + return ReferenceEquals(newDesignation, Designation) ? this : new VarPattern(Id, Prefix, Markers, newDesignation); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.CSharp/Tree/WhereClause.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/WhereClause.g.cs index f1132ab9..5b32a0ee 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/WhereClause.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/WhereClause.g.cs @@ -59,29 +59,29 @@ Expression condition return v.VisitWhereClause(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public WhereClause WithId(Guid newId) { - return newId == id ? this : new WhereClause(newId, prefix, markers, condition); + return newId == Id ? this : new WhereClause(newId, Prefix, Markers, Condition); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public WhereClause WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new WhereClause(id, newPrefix, markers, condition); + return newPrefix == Prefix ? this : new WhereClause(Id, newPrefix, Markers, Condition); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public WhereClause WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new WhereClause(id, prefix, newMarkers, condition); + return ReferenceEquals(newMarkers, Markers) ? this : new WhereClause(Id, Prefix, newMarkers, Condition); } - public Expression Condition => condition; + public Expression Condition { get; set; } = condition; public WhereClause WithCondition(Expression newCondition) { - return ReferenceEquals(newCondition, condition) ? this : new WhereClause(id, prefix, markers, newCondition); + return ReferenceEquals(newCondition, Condition) ? this : new WhereClause(Id, Prefix, Markers, newCondition); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.CSharp/Tree/Yield.g.cs b/Rewrite/src/Rewrite.CSharp/Tree/Yield.g.cs index 589fd8b3..41a016e8 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/Yield.g.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/Yield.g.cs @@ -49,35 +49,35 @@ public partial class Yield( return v.VisitYield(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Yield WithId(Guid newId) { - return newId == id ? this : new Yield(newId, prefix, markers, returnOrBreakKeyword, expression); + return newId == Id ? this : new Yield(newId, Prefix, Markers, ReturnOrBreakKeyword, Expression); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Yield WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Yield(id, newPrefix, markers, returnOrBreakKeyword, expression); + return newPrefix == Prefix ? this : new Yield(Id, newPrefix, Markers, ReturnOrBreakKeyword, Expression); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Yield WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Yield(id, prefix, newMarkers, returnOrBreakKeyword, expression); + return ReferenceEquals(newMarkers, Markers) ? this : new Yield(Id, Prefix, newMarkers, ReturnOrBreakKeyword, Expression); } - public Cs.Keyword ReturnOrBreakKeyword => returnOrBreakKeyword; + public Cs.Keyword ReturnOrBreakKeyword { get; set; } = returnOrBreakKeyword; public Yield WithReturnOrBreakKeyword(Cs.Keyword newReturnOrBreakKeyword) { - return ReferenceEquals(newReturnOrBreakKeyword, returnOrBreakKeyword) ? this : new Yield(id, prefix, markers, newReturnOrBreakKeyword, expression); + return ReferenceEquals(newReturnOrBreakKeyword, ReturnOrBreakKeyword) ? this : new Yield(Id, Prefix, Markers, newReturnOrBreakKeyword, Expression); } - public Expression? Expression => expression; + public Expression? Expression { get; set; } = expression; public Yield WithExpression(Expression? newExpression) { - return ReferenceEquals(newExpression, expression) ? this : new Yield(id, prefix, markers, returnOrBreakKeyword, newExpression); + return ReferenceEquals(newExpression, Expression) ? this : new Yield(Id, Prefix, Markers, ReturnOrBreakKeyword, newExpression); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.CSharp/Tree/_Extensions.cs b/Rewrite/src/Rewrite.CSharp/Tree/_Extensions.cs index d72be238..5ed907bd 100644 --- a/Rewrite/src/Rewrite.CSharp/Tree/_Extensions.cs +++ b/Rewrite/src/Rewrite.CSharp/Tree/_Extensions.cs @@ -9,6 +9,8 @@ partial record Location { } } + + public partial interface Cs { @@ -40,7 +42,7 @@ public partial class StackAllocExpression public partial class Subpattern : Expression { JavaType? TypedTree.Type => this.Pattern.Type; - public Subpattern WithType(JavaType? type) => WithPattern(Pattern.WithType(type)); + public Subpattern WithType(JavaType? type) => WithPattern((Pattern)Pattern.WithType(type)); } public partial class AliasQualifiedName : Expression { @@ -50,7 +52,7 @@ public partial class AliasQualifiedName : Expression public new partial class ClassDeclaration : Expression { public J.ClassDeclaration.Kind Kind => _kind; - JavaType? TypedTree.Type => type; + JavaType? TypedTree.Type => Type; public ClassDeclaration WithType(JavaType? type) => WithType((JavaType.FullyQualified?)type); } public new partial class MethodDeclaration : Expression @@ -87,7 +89,7 @@ public partial class DefaultSwitchLabel : Expression public partial class CasePatternSwitchLabel : Expression { public JavaType? Type => Pattern.Type; - public CasePatternSwitchLabel WithType(JavaType? type) => WithPattern(Pattern.WithType(type)); + public CasePatternSwitchLabel WithType(JavaType? type) => WithPattern((Pattern)Pattern.WithType(type)); } public new partial class SwitchExpression : Expression { @@ -95,96 +97,99 @@ public partial class CasePatternSwitchLabel : Expression public SwitchExpression WithType(JavaType? type) => WithExpression(Expression.WithType(type)); } - public partial interface VariableDesignation : VariableDesignation, Expression where T : VariableDesignation - { - VariableDesignation VariableDesignation.WithType(JavaType? type) => ((TypedTree)this).WithType(type); - Expression Expression.WithType(JavaType? type) => ((TypedTree)this).WithType(type); - } - - public partial interface VariableDesignation : Expression - { - public new VariableDesignation WithType(JavaType? type); - Expression Expression.WithType(JavaType? type) => WithType(type); - } - public partial interface Pattern : Pattern, Expression where T : Pattern - { - Expression Expression.WithType(JavaType? type) => ((TypedTree)this).WithType(type); - Pattern Pattern.WithType(JavaType? type) => ((TypedTree)this).WithType(type); - } - public partial interface Pattern : Expression - { - public new Pattern WithType(JavaType? type); - Expression Expression.WithType(JavaType? type) => WithType(type); - } - - public partial class ConstantPattern : Pattern + // public partial interface VariableDesignation : VariableDesignation, Expression where T : VariableDesignation + // { + // VariableDesignation VariableDesignation.WithType(JavaType? type) => ((TypedTree)this).WithType(type); + // Expression Expression.WithType(JavaType? type) => ((TypedTree)this).WithType(type); + // } + + // public partial interface VariableDesignation : Expression + // { + // public new VariableDesignation WithType(JavaType? type); + // Expression Expression.WithType(JavaType? type) => WithType(type); + // } + // public partial interface Pattern : Pattern, Expression where T : Pattern + // { + // // Expression Expression.WithType(JavaType? type) => ((TypedTree)this).WithType(type); + // // Pattern Pattern.WithType(JavaType? type) => ((TypedTree)this).WithType(type); + // } + // public partial interface Pattern : Expression + // { + // // public new Pattern WithType(JavaType? type); + // // Expression Expression.WithType(JavaType? type) => WithType(type); + // } + + public partial class ConstantPattern { public JavaType? Type => Value.Type; public ConstantPattern WithType(JavaType? type) => WithValue(Value.WithType(type)); } - public partial class BinaryPattern : Pattern + public partial class BinaryPattern { public JavaType? Type => null; public BinaryPattern WithType(JavaType? type) => this; } - public partial class RelationalPattern : Pattern + public partial class RelationalPattern { public JavaType? Type => this.Value.Type; public RelationalPattern WithType(JavaType? type) => WithValue(Value.WithType(type)); } - public partial class TypePattern : Pattern + public partial class TypePattern { public JavaType? Type => this.TypeIdentifier.Type; public TypePattern WithType(JavaType? type) => WithTypeIdentifier(TypeIdentifier.WithType(type)); } - public partial class VarPattern : Pattern + public partial class VarPattern { public JavaType? Type => this.Designation.Type; - public VarPattern WithType(JavaType? type) => this.WithDesignation(Designation.WithType(type)); + public VarPattern WithType(JavaType? type) => this.WithDesignation((VariableDesignation)Designation.WithType(type)); } - public partial class SlicePattern : Pattern + public partial class SlicePattern { public JavaType? Type => null; public SlicePattern WithType(JavaType? type) => this; } - public partial class RecursivePattern : Pattern + public partial class RecursivePattern { public JavaType? Type => TypeQualifier?.Type; public RecursivePattern WithType(JavaType? type) => TypeQualifier != null ? WithTypeQualifier(TypeQualifier.WithType(type)) : this; } - public partial class ListPattern : Pattern + public partial class ListPattern { public JavaType? Type => Patterns is [{ } singleValue] ? singleValue.Type : null; public ListPattern WithType(JavaType? type) => Patterns is [{ } singleValue] ? Padding.WithPatterns(Padding.Patterns.WithElements([singleValue])) : this; } - public partial class ParenthesizedPattern : Pattern + public partial class ParenthesizedPattern { public JavaType? Type => Pattern is [{ } singleValue] ? singleValue.Type : null; public ParenthesizedPattern WithType(JavaType? type) => Pattern is [{ } singleValue] ? Padding.WithPattern(Padding.Pattern.WithElements([singleValue])) : this; } - public partial class DiscardPattern : Pattern + public partial class DiscardPattern { } - public partial class UnaryPattern : Pattern + public partial class UnaryPattern { public JavaType? Type => Pattern.Type; - public UnaryPattern WithType(JavaType? type) => WithPattern(Pattern.WithType(type)); + public UnaryPattern WithType(JavaType? type) => WithPattern((Pattern)Pattern.WithType(type)); } public partial class IsPattern { public JavaType? Type => Pattern.Type; - public IsPattern WithType(JavaType? type) => WithPattern(Pattern.WithType(type)); + public IsPattern WithType(JavaType? type) + { + return WithPattern((Pattern)Pattern.WithType(type)); + } } public new partial class NewClass { @@ -234,17 +239,17 @@ public partial class Interpolation public Interpolation WithType(JavaType? type) => WithExpression(Expression.WithType(type)); } - public partial class ParenthesizedVariableDesignation : VariableDesignation + public partial class ParenthesizedVariableDesignation : VariableDesignation { } - public partial class SingleVariableDesignation : VariableDesignation + public partial class SingleVariableDesignation : VariableDesignation { public JavaType? Type => Name.Type; public SingleVariableDesignation WithType(JavaType? type) => WithName(Name.WithType(type)); } - public partial class DiscardVariableDesignation : VariableDesignation + public partial class DiscardVariableDesignation : VariableDesignation { public JavaType? Type => Discard.Type; public DiscardVariableDesignation WithType(JavaType? type) => WithDiscard(Discard.WithType(type)); diff --git a/Rewrite/src/Rewrite.Core/Cursor.cs b/Rewrite/src/Rewrite.Core/Cursor.cs index d6070da1..b9c6f156 100644 --- a/Rewrite/src/Rewrite.Core/Cursor.cs +++ b/Rewrite/src/Rewrite.Core/Cursor.cs @@ -12,6 +12,10 @@ public class Cursor private Dictionary? _messages; + public Cursor() : this(null, ROOT_VALUE) + { + + } public Cursor(Cursor? parent, object? value) { _parent = parent; @@ -66,7 +70,7 @@ public T FirstEnclosingOrThrow() throw new InvalidOperationException("Expected to find enclosing " + typeof(T).Name); } - private T? FirstEnclosing() + public T? FirstEnclosing() { var c = this; while (c != null) diff --git a/Rewrite/src/Rewrite.Core/ListUtils.cs b/Rewrite/src/Rewrite.Core/ListUtils.cs index 59e019ff..e0bd4c28 100644 --- a/Rewrite/src/Rewrite.Core/ListUtils.cs +++ b/Rewrite/src/Rewrite.Core/ListUtils.cs @@ -4,6 +4,137 @@ namespace Rewrite.Core; public static class ListUtils { + /// + /// Maps elements in a list using the provided mapping function while preserving list structure. + /// + /// The type of elements in the list + /// Input list to map + /// Mapping function that takes index and element + /// New mapped list or original if unchanged + public static IList Map(IList? list, Func map) + { + if (list == null || !list.Any()) + { + return list!; + } + + IList newList = list; + bool nullEncountered = false; + + for (int i = 0; i < list.Count; i++) + { + T tree = list[i]; + T? newTree = map(i, tree); + + if (!EqualityComparer.Default.Equals(newTree, tree)) + { + if (!ReferenceEquals(newList, list)) + { + newList = new List(list); + } + newList[i] = newTree!; + } + nullEncountered |= newTree == null; + } + + if (!ReferenceEquals(newList, list) && nullEncountered) + { + newList.RemoveAll(x => x == null); + } + + return newList!; + } + + /// + /// Maps the last element of a list using the provided mapping function. + /// + /// The type of elements in the list + /// The input list + /// The mapping function to apply to the last element + /// A new list with the last element mapped, or the original list if unchanged + public static IList? MapLast(IList? ls, Func mapLast) + { + if (ls == null || ls.Count == 0) + { + return ls; + } + + T last = ls[ls.Count - 1]; + T newLast = mapLast(last); + + if (!EqualityComparer.Default.Equals(last, newLast)) + { + var newLs = new List(ls); + if (newLast == null) + { + newLs.RemoveAt(ls.Count - 1); + } + else + { + newLs[ls.Count - 1] = newLast; + } + return newLs; + } + return ls; + } + + /// + /// Maps the first element of a list using the provided mapping function. + /// + /// The type of elements in the list + /// The input list + /// The mapping function to apply to the first element + /// A new list with the first element mapped, or the original list if unchanged + public static IList MapFirst(IList? ls, Func mapFirst) + { + if (ls == null || !ls.Any()) + { + return ls!; + } + + T first = ls.First(); + T? newFirst = mapFirst(first); + + if (!ReferenceEquals(first, newFirst)) + { + var newLs = new List(ls); + if (newFirst == null) + { + newLs.RemoveAt(0); + } + else + { + newLs[0] = newFirst; + } + return newLs; + } + + return ls; + } + + /// + /// Removes all elements from the list that match the given predicate. + /// + /// The type of elements in the list. + /// The list from which to remove elements. + /// A delegate that defines the conditions of the elements to remove. + public static void RemoveAll(this IList list, Func predicate) + { + if (list == null) + throw new ArgumentNullException(nameof(list), "The list cannot be null."); + + if (predicate == null) + throw new ArgumentNullException(nameof(predicate), "The predicate cannot be null."); + + for (int i = list.Count - 1; i >= 0; i--) + { + if (predicate(list[i])) + { + list.RemoveAt(i); + } + } + } + // todo: AS: this method is used in contexts where tree is changed in immutable way. // this immutability is broken by how this method tries to optimize as it sometimes reuses same list when a copy should have been made. since this collection is writable, // it's possible that changes mutation in one set affects it in other place, which is not the intent of immutable copy diff --git a/Rewrite/src/Rewrite.Core/MutableSourceFile.cs b/Rewrite/src/Rewrite.Core/MutableSourceFile.cs index 04eca522..f5abc2a0 100644 --- a/Rewrite/src/Rewrite.Core/MutableSourceFile.cs +++ b/Rewrite/src/Rewrite.Core/MutableSourceFile.cs @@ -1,20 +1,6 @@ namespace Rewrite.Core; -public interface MutableSourceFile : MutableSourceFile where T : MutableSourceFile -{ - new T WithSourcePath(string sourcePath); - MutableSourceFile MutableSourceFile.WithSourcePath(string sourcePath) => WithSourcePath(sourcePath); - new T WithCharsetName(string? charsetName); - MutableSourceFile MutableSourceFile.WithCharsetName(string? charsetName) => WithCharsetName(charsetName); - new T WithCharsetBomMarked(bool charsetBomMarked); - MutableSourceFile MutableSourceFile.WithCharsetBomMarked(bool charsetBomMarked) => WithCharsetBomMarked(charsetBomMarked); - new T WithChecksum(Checksum? checksum); - MutableSourceFile MutableSourceFile.WithChecksum(Checksum? checksum) => WithChecksum(checksum); - new T WithFileAttributes(FileAttributes? fileAttributes); - MutableSourceFile MutableSourceFile.WithFileAttributes(FileAttributes? fileAttributes) => WithFileAttributes(fileAttributes); -} - -public interface MutableSourceFile : SourceFile +public partial interface MutableSourceFile : SourceFile { MutableSourceFile WithSourcePath(string sourcePath); MutableSourceFile WithCharsetName(string? charsetName); diff --git a/Rewrite/src/Rewrite.Core/Rewrite.Core.csproj b/Rewrite/src/Rewrite.Core/Rewrite.Core.csproj index 21e22784..1938b5f8 100644 --- a/Rewrite/src/Rewrite.Core/Rewrite.Core.csproj +++ b/Rewrite/src/Rewrite.Core/Rewrite.Core.csproj @@ -7,6 +7,10 @@ Core library for the automated code refactoring framework OpenRewrite. + + + diff --git a/Rewrite/src/Rewrite.Java/Globals.cs b/Rewrite/src/Rewrite.Java/Globals.cs new file mode 100644 index 00000000..55ada366 --- /dev/null +++ b/Rewrite/src/Rewrite.Java/Globals.cs @@ -0,0 +1,2 @@ +global using Rewrite.Core; +global using Rewrite.Core.Marker; diff --git a/Rewrite/src/Rewrite.Java/JavaPrinter.cs b/Rewrite/src/Rewrite.Java/JavaPrinter.cs index 48d224a5..a37e0abf 100644 --- a/Rewrite/src/Rewrite.Java/JavaPrinter.cs +++ b/Rewrite/src/Rewrite.Java/JavaPrinter.cs @@ -14,8 +14,7 @@ public JavaPrinter() { } - protected void VisitRightPadded(IList> nodes, JRightPadded.Location location, - string suffixBetween, PrintOutputCapture

p) where T : J + protected virtual void VisitRightPadded(IList> nodes, JRightPadded.Location location, string suffixBetween, PrintOutputCapture

p) where T : J { for (int i = 0; i < nodes.Count; ++i) { @@ -30,7 +29,7 @@ protected void VisitRightPadded(IList> nodes, JRightPadded.Lo } } - public void VisitContainer(string before, JContainer? container, JContainer.Location location, + protected virtual void VisitContainer(string before, JContainer? container, JContainer.Location location, string suffixBetween, string? after, PrintOutputCapture

p) where T : J { if (container != null) @@ -60,7 +59,7 @@ public override Space VisitSpace(Space space, Space.Location? loc, PrintOutputCa return space; } - protected void VisitLeftPadded(string? prefix, JLeftPadded? leftPadded, JLeftPadded.Location location, + protected virtual void VisitLeftPadded(string? prefix, JLeftPadded? leftPadded, JLeftPadded.Location location, PrintOutputCapture

p) where T : J { if (leftPadded != null) @@ -76,7 +75,7 @@ protected void VisitLeftPadded(string? prefix, JLeftPadded? leftPadded, JL } } - protected void VisitRightPadded(JRightPadded? rightPadded, JRightPadded.Location location, string? suffix, + protected virtual void VisitRightPadded(JRightPadded? rightPadded, JRightPadded.Location location, string? suffix, PrintOutputCapture

p) where T : J { if (rightPadded != null) diff --git a/Rewrite/src/Rewrite.Java/Marker/ImplicitReturn.cs b/Rewrite/src/Rewrite.Java/Marker/ImplicitReturn.cs new file mode 100644 index 00000000..528743ea --- /dev/null +++ b/Rewrite/src/Rewrite.Java/Marker/ImplicitReturn.cs @@ -0,0 +1,9 @@ +namespace Rewrite.RewriteJava.Marker; + +public record ImplicitReturn(Guid Id) : Rewrite.Core.Marker.Marker +{ + public bool Equals(Core.Marker.Marker? other) + { + throw new NotImplementedException(); + } +} diff --git a/Rewrite/src/Rewrite.Java/Rewrite.Java.csproj b/Rewrite/src/Rewrite.Java/Rewrite.Java.csproj index 0e29f135..82c1fd90 100644 --- a/Rewrite/src/Rewrite.Java/Rewrite.Java.csproj +++ b/Rewrite/src/Rewrite.Java/Rewrite.Java.csproj @@ -7,7 +7,9 @@ Rewrite.RewriteJava Java language support for the automated code refactoring framework OpenRewrite. - + + + <_Parameter1>Rewrite.CSharp diff --git a/Rewrite/src/Rewrite.Java/Tree/AnnotatedType.cs b/Rewrite/src/Rewrite.Java/Tree/AnnotatedType.cs index 0a57e6ab..e2af37e6 100644 --- a/Rewrite/src/Rewrite.Java/Tree/AnnotatedType.cs +++ b/Rewrite/src/Rewrite.Java/Tree/AnnotatedType.cs @@ -6,7 +6,7 @@ partial class AnnotatedType { public JavaType? Type => TypeExpression.Type; - public AnnotatedType WithType(JavaType? type) => WithTypeExpression(TypeExpression.WithType(type)); + public AnnotatedType WithType(JavaType? type) => WithTypeExpression((TypeTree)TypeExpression.WithType(type)); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/AnnotatedType.g.cs b/Rewrite/src/Rewrite.Java/Tree/AnnotatedType.g.cs index 81143b9b..25932980 100644 --- a/Rewrite/src/Rewrite.Java/Tree/AnnotatedType.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/AnnotatedType.g.cs @@ -39,35 +39,35 @@ TypeTree typeExpression return v.VisitAnnotatedType(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public AnnotatedType WithId(Guid newId) { - return newId == id ? this : new AnnotatedType(newId, prefix, markers, annotations, typeExpression); + return newId == Id ? this : new AnnotatedType(newId, Prefix, Markers, Annotations, TypeExpression); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public AnnotatedType WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new AnnotatedType(id, newPrefix, markers, annotations, typeExpression); + return newPrefix == Prefix ? this : new AnnotatedType(Id, newPrefix, Markers, Annotations, TypeExpression); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public AnnotatedType WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new AnnotatedType(id, prefix, newMarkers, annotations, typeExpression); + return ReferenceEquals(newMarkers, Markers) ? this : new AnnotatedType(Id, Prefix, newMarkers, Annotations, TypeExpression); } - public IList Annotations => annotations; + public IList Annotations { get; set; } = annotations; public AnnotatedType WithAnnotations(IList newAnnotations) { - return newAnnotations == annotations ? this : new AnnotatedType(id, prefix, markers, newAnnotations, typeExpression); + return newAnnotations == Annotations ? this : new AnnotatedType(Id, Prefix, Markers, newAnnotations, TypeExpression); } - public TypeTree TypeExpression => typeExpression; + public TypeTree TypeExpression { get; set; } = typeExpression; public AnnotatedType WithTypeExpression(TypeTree newTypeExpression) { - return ReferenceEquals(newTypeExpression, typeExpression) ? this : new AnnotatedType(id, prefix, markers, annotations, newTypeExpression); + return ReferenceEquals(newTypeExpression, TypeExpression) ? this : new AnnotatedType(Id, Prefix, Markers, Annotations, newTypeExpression); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.Java/Tree/Annotation.g.cs b/Rewrite/src/Rewrite.Java/Tree/Annotation.g.cs index 272207ab..94d834f5 100644 --- a/Rewrite/src/Rewrite.Java/Tree/Annotation.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/Annotation.g.cs @@ -64,31 +64,31 @@ public PaddingHelper Padding return v.VisitAnnotation(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Annotation WithId(Guid newId) { - return newId == id ? this : new Annotation(newId, prefix, markers, annotationType, _arguments); + return newId == Id ? this : new Annotation(newId, Prefix, Markers, AnnotationType, _arguments); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Annotation WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Annotation(id, newPrefix, markers, annotationType, _arguments); + return newPrefix == Prefix ? this : new Annotation(Id, newPrefix, Markers, AnnotationType, _arguments); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Annotation WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Annotation(id, prefix, newMarkers, annotationType, _arguments); + return ReferenceEquals(newMarkers, Markers) ? this : new Annotation(Id, Prefix, newMarkers, AnnotationType, _arguments); } - public NameTree AnnotationType => annotationType; + public NameTree AnnotationType { get; set; } = annotationType; public Annotation WithAnnotationType(NameTree newAnnotationType) { - return ReferenceEquals(newAnnotationType, annotationType) ? this : new Annotation(id, prefix, markers, newAnnotationType, _arguments); + return ReferenceEquals(newAnnotationType, AnnotationType) ? this : new Annotation(Id, Prefix, Markers, newAnnotationType, _arguments); } - private readonly JContainer? _arguments = arguments; + private JContainer? _arguments = arguments; public IList? Arguments => _arguments?.GetElements(); public Annotation WithArguments(IList? newArguments) @@ -97,11 +97,11 @@ public Annotation WithArguments(IList? newArguments) } public sealed record PaddingHelper(J.Annotation T) { - public JContainer? Arguments => T._arguments; + public JContainer? Arguments { get => T._arguments; set => T._arguments = value; } public J.Annotation WithArguments(JContainer? newArguments) { - return T._arguments == newArguments ? T : new J.Annotation(T.Id, T.Prefix, T.Markers, T.AnnotationType, newArguments); + return Arguments == newArguments ? T : new J.Annotation(T.Id, T.Prefix, T.Markers, T.AnnotationType, newArguments); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/ArrayAccess.g.cs b/Rewrite/src/Rewrite.Java/Tree/ArrayAccess.g.cs index 4eaeb720..a5421736 100644 --- a/Rewrite/src/Rewrite.Java/Tree/ArrayAccess.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/ArrayAccess.g.cs @@ -40,41 +40,41 @@ public partial class ArrayAccess( return v.VisitArrayAccess(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public ArrayAccess WithId(Guid newId) { - return newId == id ? this : new ArrayAccess(newId, prefix, markers, indexed, dimension, type); + return newId == Id ? this : new ArrayAccess(newId, Prefix, Markers, Indexed, Dimension, Type); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public ArrayAccess WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new ArrayAccess(id, newPrefix, markers, indexed, dimension, type); + return newPrefix == Prefix ? this : new ArrayAccess(Id, newPrefix, Markers, Indexed, Dimension, Type); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public ArrayAccess WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new ArrayAccess(id, prefix, newMarkers, indexed, dimension, type); + return ReferenceEquals(newMarkers, Markers) ? this : new ArrayAccess(Id, Prefix, newMarkers, Indexed, Dimension, Type); } - public Expression Indexed => indexed; + public Expression Indexed { get; set; } = indexed; public ArrayAccess WithIndexed(Expression newIndexed) { - return ReferenceEquals(newIndexed, indexed) ? this : new ArrayAccess(id, prefix, markers, newIndexed, dimension, type); + return ReferenceEquals(newIndexed, Indexed) ? this : new ArrayAccess(Id, Prefix, Markers, newIndexed, Dimension, Type); } - public J.ArrayDimension Dimension => dimension; + public J.ArrayDimension Dimension { get; set; } = dimension; public ArrayAccess WithDimension(J.ArrayDimension newDimension) { - return ReferenceEquals(newDimension, dimension) ? this : new ArrayAccess(id, prefix, markers, indexed, newDimension, type); + return ReferenceEquals(newDimension, Dimension) ? this : new ArrayAccess(Id, Prefix, Markers, Indexed, newDimension, Type); } - public JavaType? Type => type; + public JavaType? Type { get; set; } = type; public ArrayAccess WithType(JavaType? newType) { - return newType == type ? this : new ArrayAccess(id, prefix, markers, indexed, dimension, newType); + return newType == Type ? this : new ArrayAccess(Id, Prefix, Markers, Indexed, Dimension, newType); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.Java/Tree/ArrayDimension.g.cs b/Rewrite/src/Rewrite.Java/Tree/ArrayDimension.g.cs index 5f851cdf..cfcae6a4 100644 --- a/Rewrite/src/Rewrite.Java/Tree/ArrayDimension.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/ArrayDimension.g.cs @@ -63,25 +63,25 @@ public PaddingHelper Padding return v.VisitArrayDimension(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public ArrayDimension WithId(Guid newId) { - return newId == id ? this : new ArrayDimension(newId, prefix, markers, _index); + return newId == Id ? this : new ArrayDimension(newId, Prefix, Markers, _index); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public ArrayDimension WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new ArrayDimension(id, newPrefix, markers, _index); + return newPrefix == Prefix ? this : new ArrayDimension(Id, newPrefix, Markers, _index); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public ArrayDimension WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new ArrayDimension(id, prefix, newMarkers, _index); + return ReferenceEquals(newMarkers, Markers) ? this : new ArrayDimension(Id, Prefix, newMarkers, _index); } - private readonly JRightPadded _index = index; + private JRightPadded _index = index; public Expression Index => _index.Element; public ArrayDimension WithIndex(Expression newIndex) @@ -90,11 +90,11 @@ public ArrayDimension WithIndex(Expression newIndex) } public sealed record PaddingHelper(J.ArrayDimension T) { - public JRightPadded Index => T._index; + public JRightPadded Index { get => T._index; set => T._index = value; } public J.ArrayDimension WithIndex(JRightPadded newIndex) { - return T._index == newIndex ? T : new J.ArrayDimension(T.Id, T.Prefix, T.Markers, newIndex); + return Index == newIndex ? T : new J.ArrayDimension(T.Id, T.Prefix, T.Markers, newIndex); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/ArrayType.g.cs b/Rewrite/src/Rewrite.Java/Tree/ArrayType.g.cs index 2c9c71c6..6a2c20d4 100644 --- a/Rewrite/src/Rewrite.Java/Tree/ArrayType.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/ArrayType.g.cs @@ -41,47 +41,47 @@ JavaType type 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, elementType, annotations, dimension, type); + return newId == Id ? this : new ArrayType(newId, Prefix, Markers, ElementType, Annotations, Dimension, 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, elementType, annotations, dimension, type); + return newPrefix == Prefix ? this : new ArrayType(Id, newPrefix, Markers, ElementType, Annotations, Dimension, 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, elementType, annotations, dimension, type); + return ReferenceEquals(newMarkers, Markers) ? this : new ArrayType(Id, Prefix, newMarkers, ElementType, Annotations, Dimension, Type); } - public TypeTree ElementType => elementType; + public TypeTree ElementType { get; set; } = elementType; public ArrayType WithElementType(TypeTree newElementType) { - return ReferenceEquals(newElementType, elementType) ? this : new ArrayType(id, prefix, markers, newElementType, annotations, dimension, type); + return ReferenceEquals(newElementType, ElementType) ? this : new ArrayType(Id, Prefix, Markers, newElementType, Annotations, Dimension, Type); } - public IList? Annotations => annotations; + public IList? Annotations { get; set; } = annotations; public ArrayType WithAnnotations(IList? newAnnotations) { - return newAnnotations == annotations ? this : new ArrayType(id, prefix, markers, elementType, newAnnotations, dimension, type); + return newAnnotations == Annotations ? this : new ArrayType(Id, Prefix, Markers, ElementType, newAnnotations, Dimension, Type); } - public JLeftPadded? Dimension => dimension; + public JLeftPadded? Dimension { get; set; } = dimension; public ArrayType WithDimension(JLeftPadded? newDimension) { - return newDimension == dimension ? this : new ArrayType(id, prefix, markers, elementType, annotations, newDimension, type); + return newDimension == Dimension ? this : new ArrayType(Id, Prefix, Markers, ElementType, Annotations, newDimension, 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, elementType, annotations, dimension, newType); + return newType == Type ? this : new ArrayType(Id, Prefix, Markers, ElementType, Annotations, Dimension, newType); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.Java/Tree/Assert.g.cs b/Rewrite/src/Rewrite.Java/Tree/Assert.g.cs index 2b0efa8d..253a25d6 100644 --- a/Rewrite/src/Rewrite.Java/Tree/Assert.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/Assert.g.cs @@ -39,35 +39,35 @@ public partial class Assert( return v.VisitAssert(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Assert WithId(Guid newId) { - return newId == id ? this : new Assert(newId, prefix, markers, condition, detail); + return newId == Id ? this : new Assert(newId, Prefix, Markers, Condition, Detail); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Assert WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Assert(id, newPrefix, markers, condition, detail); + return newPrefix == Prefix ? this : new Assert(Id, newPrefix, Markers, Condition, Detail); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Assert WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Assert(id, prefix, newMarkers, condition, detail); + return ReferenceEquals(newMarkers, Markers) ? this : new Assert(Id, Prefix, newMarkers, Condition, Detail); } - public Expression Condition => condition; + public Expression Condition { get; set; } = condition; public Assert WithCondition(Expression newCondition) { - return ReferenceEquals(newCondition, condition) ? this : new Assert(id, prefix, markers, newCondition, detail); + return ReferenceEquals(newCondition, Condition) ? this : new Assert(Id, Prefix, Markers, newCondition, Detail); } - public JLeftPadded? Detail => detail; + public JLeftPadded? Detail { get; set; } = detail; public Assert WithDetail(JLeftPadded? newDetail) { - return newDetail == detail ? this : new Assert(id, prefix, markers, condition, newDetail); + return newDetail == Detail ? this : new Assert(Id, Prefix, Markers, Condition, newDetail); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.Java/Tree/Assignment.g.cs b/Rewrite/src/Rewrite.Java/Tree/Assignment.g.cs index 80d15854..b7589599 100644 --- a/Rewrite/src/Rewrite.Java/Tree/Assignment.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/Assignment.g.cs @@ -65,50 +65,50 @@ public PaddingHelper Padding return v.VisitAssignment(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Assignment WithId(Guid newId) { - return newId == id ? this : new Assignment(newId, prefix, markers, variable, _expression, type); + return newId == Id ? this : new Assignment(newId, Prefix, Markers, Variable, _expression, Type); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Assignment WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Assignment(id, newPrefix, markers, variable, _expression, type); + return newPrefix == Prefix ? this : new Assignment(Id, newPrefix, Markers, Variable, _expression, Type); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Assignment WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Assignment(id, prefix, newMarkers, variable, _expression, type); + return ReferenceEquals(newMarkers, Markers) ? this : new Assignment(Id, Prefix, newMarkers, Variable, _expression, Type); } - public Expression Variable => variable; + public Expression Variable { get; set; } = variable; public Assignment WithVariable(Expression newVariable) { - return ReferenceEquals(newVariable, variable) ? this : new Assignment(id, prefix, markers, newVariable, _expression, type); + return ReferenceEquals(newVariable, Variable) ? this : new Assignment(Id, Prefix, Markers, newVariable, _expression, Type); } - private readonly JLeftPadded _expression = expression; + private JLeftPadded _expression = expression; public Expression Expression => _expression.Element; public Assignment WithExpression(Expression newExpression) { return Padding.WithExpression(_expression.WithElement(newExpression)); } - public JavaType? Type => type; + public JavaType? Type { get; set; } = type; public Assignment WithType(JavaType? newType) { - return newType == type ? this : new Assignment(id, prefix, markers, variable, _expression, newType); + return newType == Type ? this : new Assignment(Id, Prefix, Markers, Variable, _expression, newType); } public sealed record PaddingHelper(J.Assignment T) { - public JLeftPadded Expression => T._expression; + public JLeftPadded Expression { get => T._expression; set => T._expression = value; } public J.Assignment WithExpression(JLeftPadded newExpression) { - return T._expression == newExpression ? T : new J.Assignment(T.Id, T.Prefix, T.Markers, T.Variable, newExpression, T.Type); + return Expression == newExpression ? T : new J.Assignment(T.Id, T.Prefix, T.Markers, T.Variable, newExpression, T.Type); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/AssignmentOperation.g.cs b/Rewrite/src/Rewrite.Java/Tree/AssignmentOperation.g.cs index e5e39d7f..681c02bb 100644 --- a/Rewrite/src/Rewrite.Java/Tree/AssignmentOperation.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/AssignmentOperation.g.cs @@ -66,48 +66,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 Types Operator => _operator.Element; public AssignmentOperation WithOperator(Types 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 Types { @@ -128,11 +128,11 @@ public enum Types } public sealed record PaddingHelper(J.AssignmentOperation T) { - public JLeftPadded Operator => T._operator; + public JLeftPadded Operator { get => T._operator; set => T._operator = value; } public J.AssignmentOperation WithOperator(JLeftPadded newOperator) { - return T._operator == newOperator ? T : new J.AssignmentOperation(T.Id, T.Prefix, T.Markers, T.Variable, newOperator, T.Assignment, T.Type); + return Operator == newOperator ? T : new J.AssignmentOperation(T.Id, T.Prefix, T.Markers, T.Variable, newOperator, T.Assignment, T.Type); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/Binary.g.cs b/Rewrite/src/Rewrite.Java/Tree/Binary.g.cs index 6ec43515..c12ca3fa 100644 --- a/Rewrite/src/Rewrite.Java/Tree/Binary.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/Binary.g.cs @@ -66,48 +66,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 Types Operator => _operator.Element; public Binary WithOperator(Types 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 Types { @@ -133,11 +133,11 @@ public enum Types } public sealed record PaddingHelper(J.Binary T) { - public JLeftPadded Operator => T._operator; + public JLeftPadded Operator { get => T._operator; set => T._operator = value; } public J.Binary WithOperator(JLeftPadded newOperator) { - return T._operator == newOperator ? T : new J.Binary(T.Id, T.Prefix, T.Markers, T.Left, newOperator, T.Right, T.Type); + return Operator == newOperator ? T : new J.Binary(T.Id, T.Prefix, T.Markers, T.Left, newOperator, T.Right, T.Type); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/Block.g.cs b/Rewrite/src/Rewrite.Java/Tree/Block.g.cs index db570b89..07ebb89d 100644 --- a/Rewrite/src/Rewrite.Java/Tree/Block.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/Block.g.cs @@ -70,58 +70,58 @@ public PaddingHelper Padding return v.VisitBlock(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Block WithId(Guid newId) { - return newId == id ? this : new Block(newId, prefix, markers, _static, _statements, end); + return newId == Id ? this : new Block(newId, Prefix, Markers, _static, _statements, End); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Block WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Block(id, newPrefix, markers, _static, _statements, end); + return newPrefix == Prefix ? this : new Block(Id, newPrefix, Markers, _static, _statements, End); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Block WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Block(id, prefix, newMarkers, _static, _statements, end); + return ReferenceEquals(newMarkers, Markers) ? this : new Block(Id, Prefix, newMarkers, _static, _statements, End); } - private readonly JRightPadded _static = @static; + private JRightPadded _static = @static; public bool Static => _static.Element; public Block WithStatic(bool newStatic) { return Padding.WithStatic(_static.WithElement(newStatic)); } - private readonly IList> _statements = statements; + private IList> _statements = statements; public IList Statements => _statements.Elements(); public Block WithStatements(IList newStatements) { return Padding.WithStatements(_statements.WithElements(newStatements)); } - public Space End => end; + public Space End { get; set; } = end; public Block WithEnd(Space newEnd) { - return newEnd == end ? this : new Block(id, prefix, markers, _static, _statements, newEnd); + return newEnd == End ? this : new Block(Id, Prefix, Markers, _static, _statements, newEnd); } public sealed record PaddingHelper(J.Block T) { - public JRightPadded Static => T._static; + public JRightPadded Static { get => T._static; set => T._static = value; } public J.Block WithStatic(JRightPadded newStatic) { - return T._static == newStatic ? T : new J.Block(T.Id, T.Prefix, T.Markers, newStatic, T._statements, T.End); + return Static == newStatic ? T : new J.Block(T.Id, T.Prefix, T.Markers, newStatic, T._statements, T.End); } - public IList> Statements => T._statements; + public IList> Statements { get => T._statements; set => T._statements = value; } public J.Block WithStatements(IList> newStatements) { - return T._statements == newStatements ? T : new J.Block(T.Id, T.Prefix, T.Markers, T._static, newStatements, T.End); + return Statements == newStatements ? T : new J.Block(T.Id, T.Prefix, T.Markers, T._static, newStatements, T.End); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/Break.g.cs b/Rewrite/src/Rewrite.Java/Tree/Break.g.cs index 94c3ff36..cf61cc14 100644 --- a/Rewrite/src/Rewrite.Java/Tree/Break.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/Break.g.cs @@ -38,29 +38,29 @@ public partial class Break( return v.VisitBreak(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Break WithId(Guid newId) { - return newId == id ? this : new Break(newId, prefix, markers, label); + return newId == Id ? this : new Break(newId, Prefix, Markers, Label); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Break WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Break(id, newPrefix, markers, label); + return newPrefix == Prefix ? this : new Break(Id, newPrefix, Markers, Label); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Break WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Break(id, prefix, newMarkers, label); + return ReferenceEquals(newMarkers, Markers) ? this : new Break(Id, Prefix, newMarkers, Label); } - public J.Identifier? Label => label; + public J.Identifier? Label { get; set; } = label; public Break WithLabel(J.Identifier? newLabel) { - return ReferenceEquals(newLabel, label) ? this : new Break(id, prefix, markers, newLabel); + return ReferenceEquals(newLabel, Label) ? this : new Break(Id, Prefix, Markers, newLabel); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.Java/Tree/Case.g.cs b/Rewrite/src/Rewrite.Java/Tree/Case.g.cs index a8c1f3af..6b42c8d3 100644 --- a/Rewrite/src/Rewrite.Java/Tree/Case.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/Case.g.cs @@ -67,56 +67,56 @@ public PaddingHelper Padding return v.VisitCase(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Case WithId(Guid newId) { - return newId == id ? this : new Case(newId, prefix, markers, caseType, _caseLabels, _statements, _body, guard); + return newId == Id ? this : new Case(newId, Prefix, Markers, CaseType, _caseLabels, _statements, _body, Guard); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Case WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Case(id, newPrefix, markers, caseType, _caseLabels, _statements, _body, guard); + return newPrefix == Prefix ? this : new Case(Id, newPrefix, Markers, CaseType, _caseLabels, _statements, _body, Guard); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Case WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Case(id, prefix, newMarkers, caseType, _caseLabels, _statements, _body, guard); + return ReferenceEquals(newMarkers, Markers) ? this : new Case(Id, Prefix, newMarkers, CaseType, _caseLabels, _statements, _body, Guard); } - public Types CaseType => caseType; + public Types CaseType { get; set; } = caseType; public Case WithCaseType(Types newCaseType) { - return newCaseType == caseType ? this : new Case(id, prefix, markers, newCaseType, _caseLabels, _statements, _body, guard); + return newCaseType == CaseType ? this : new Case(Id, Prefix, Markers, newCaseType, _caseLabels, _statements, _body, Guard); } - private readonly JContainer _caseLabels = caseLabels; + private JContainer _caseLabels = caseLabels; public IList CaseLabels => _caseLabels.GetElements(); public Case WithCaseLabels(IList newCaseLabels) { return Padding.WithCaseLabels(JContainer.WithElements(_caseLabels, newCaseLabels)); } - private readonly JContainer _statements = statements; + private JContainer _statements = statements; public IList Statements => _statements.GetElements(); public Case WithStatements(IList newStatements) { return Padding.WithStatements(JContainer.WithElements(_statements, newStatements)); } - private readonly JRightPadded? _body = body; + private JRightPadded? _body = body; public J? Body => _body?.Element; public Case WithBody(J? newBody) { return Padding.WithBody(JRightPadded.WithElement(_body, newBody)); } - public Expression? Guard => guard; + public Expression? Guard { get; set; } = guard; public Case WithGuard(Expression? newGuard) { - return ReferenceEquals(newGuard, guard) ? this : new Case(id, prefix, markers, caseType, _caseLabels, _statements, _body, newGuard); + return ReferenceEquals(newGuard, Guard) ? this : new Case(Id, Prefix, Markers, CaseType, _caseLabels, _statements, _body, newGuard); } public enum Types { @@ -125,25 +125,25 @@ public enum Types } public sealed record PaddingHelper(J.Case T) { - public JContainer CaseLabels => T._caseLabels; + public JContainer CaseLabels { get => T._caseLabels; set => T._caseLabels = value; } public J.Case WithCaseLabels(JContainer newCaseLabels) { - return T._caseLabels == newCaseLabels ? T : new J.Case(T.Id, T.Prefix, T.Markers, T.CaseType, newCaseLabels, T._statements, T._body, T.Guard); + return CaseLabels == newCaseLabels ? T : new J.Case(T.Id, T.Prefix, T.Markers, T.CaseType, newCaseLabels, T._statements, T._body, T.Guard); } - public JContainer Statements => T._statements; + public JContainer Statements { get => T._statements; set => T._statements = value; } public J.Case WithStatements(JContainer newStatements) { - return T._statements == newStatements ? T : new J.Case(T.Id, T.Prefix, T.Markers, T.CaseType, T._caseLabels, newStatements, T._body, T.Guard); + return Statements == newStatements ? T : new J.Case(T.Id, T.Prefix, T.Markers, T.CaseType, T._caseLabels, newStatements, T._body, T.Guard); } - public JRightPadded? Body => T._body; + public JRightPadded? Body { get => T._body; set => T._body = value; } public J.Case WithBody(JRightPadded? newBody) { - return T._body == newBody ? T : new J.Case(T.Id, T.Prefix, T.Markers, T.CaseType, T._caseLabels, T._statements, newBody, T.Guard); + return Body == newBody ? T : new J.Case(T.Id, T.Prefix, T.Markers, T.CaseType, T._caseLabels, T._statements, newBody, T.Guard); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/ClassDeclaration.g.cs b/Rewrite/src/Rewrite.Java/Tree/ClassDeclaration.g.cs index 8ce11331..96e07a7b 100644 --- a/Rewrite/src/Rewrite.Java/Tree/ClassDeclaration.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/ClassDeclaration.g.cs @@ -73,94 +73,94 @@ public PaddingHelper Padding return v.VisitClassDeclaration(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public ClassDeclaration WithId(Guid newId) { - return newId == id ? this : new ClassDeclaration(newId, prefix, markers, leadingAnnotations, modifiers, _declarationKind, name, _typeParameters, _primaryConstructor, _extends, _implements, _permits, body, type); + return newId == Id ? this : new ClassDeclaration(newId, Prefix, Markers, LeadingAnnotations, Modifiers, _declarationKind, Name, _typeParameters, _primaryConstructor, _extends, _implements, _permits, Body, Type); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public ClassDeclaration WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new ClassDeclaration(id, newPrefix, markers, leadingAnnotations, modifiers, _declarationKind, name, _typeParameters, _primaryConstructor, _extends, _implements, _permits, body, type); + return newPrefix == Prefix ? this : new ClassDeclaration(Id, newPrefix, Markers, LeadingAnnotations, Modifiers, _declarationKind, Name, _typeParameters, _primaryConstructor, _extends, _implements, _permits, Body, Type); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public ClassDeclaration WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new ClassDeclaration(id, prefix, newMarkers, leadingAnnotations, modifiers, _declarationKind, name, _typeParameters, _primaryConstructor, _extends, _implements, _permits, body, type); + return ReferenceEquals(newMarkers, Markers) ? this : new ClassDeclaration(Id, Prefix, newMarkers, LeadingAnnotations, Modifiers, _declarationKind, Name, _typeParameters, _primaryConstructor, _extends, _implements, _permits, Body, Type); } - public IList LeadingAnnotations => leadingAnnotations; + public IList LeadingAnnotations { get; set; } = leadingAnnotations; public ClassDeclaration WithLeadingAnnotations(IList newLeadingAnnotations) { - return newLeadingAnnotations == leadingAnnotations ? this : new ClassDeclaration(id, prefix, markers, newLeadingAnnotations, modifiers, _declarationKind, name, _typeParameters, _primaryConstructor, _extends, _implements, _permits, body, type); + return newLeadingAnnotations == LeadingAnnotations ? this : new ClassDeclaration(Id, Prefix, Markers, newLeadingAnnotations, Modifiers, _declarationKind, Name, _typeParameters, _primaryConstructor, _extends, _implements, _permits, Body, Type); } - public IList Modifiers => modifiers; + public IList Modifiers { get; set; } = modifiers; public ClassDeclaration WithModifiers(IList newModifiers) { - return newModifiers == modifiers ? this : new ClassDeclaration(id, prefix, markers, leadingAnnotations, newModifiers, _declarationKind, name, _typeParameters, _primaryConstructor, _extends, _implements, _permits, body, type); + return newModifiers == Modifiers ? this : new ClassDeclaration(Id, Prefix, Markers, LeadingAnnotations, newModifiers, _declarationKind, Name, _typeParameters, _primaryConstructor, _extends, _implements, _permits, Body, Type); } - private readonly Kind _declarationKind = declarationKind; + private Kind _declarationKind = declarationKind; public ClassDeclaration WithDeclarationKind(Kind newDeclarationKind) { - return ReferenceEquals(newDeclarationKind, _declarationKind) ? this : new ClassDeclaration(id, prefix, markers, leadingAnnotations, modifiers, _declarationKind, name, _typeParameters, _primaryConstructor, _extends, _implements, _permits, body, type); + return ReferenceEquals(newDeclarationKind, DeclarationKind) ? this : new ClassDeclaration(Id, Prefix, Markers, LeadingAnnotations, Modifiers, _declarationKind, Name, _typeParameters, _primaryConstructor, _extends, _implements, _permits, Body, Type); } - public J.Identifier Name => name; + public J.Identifier Name { get; set; } = name; public ClassDeclaration WithName(J.Identifier newName) { - return ReferenceEquals(newName, name) ? this : new ClassDeclaration(id, prefix, markers, leadingAnnotations, modifiers, _declarationKind, newName, _typeParameters, _primaryConstructor, _extends, _implements, _permits, body, type); + return ReferenceEquals(newName, Name) ? this : new ClassDeclaration(Id, Prefix, Markers, LeadingAnnotations, Modifiers, _declarationKind, newName, _typeParameters, _primaryConstructor, _extends, _implements, _permits, Body, Type); } - private readonly JContainer? _typeParameters = typeParameters; + private JContainer? _typeParameters = typeParameters; public IList? TypeParameters => _typeParameters?.GetElements(); public ClassDeclaration WithTypeParameters(IList? newTypeParameters) { return Padding.WithTypeParameters(JContainer.WithElementsNullable(_typeParameters, newTypeParameters)); } - private readonly JContainer? _primaryConstructor = primaryConstructor; + private JContainer? _primaryConstructor = primaryConstructor; public IList? PrimaryConstructor => _primaryConstructor?.GetElements(); public ClassDeclaration WithPrimaryConstructor(IList? newPrimaryConstructor) { return Padding.WithPrimaryConstructor(JContainer.WithElementsNullable(_primaryConstructor, newPrimaryConstructor)); } - private readonly JLeftPadded? _extends = extends; + private JLeftPadded? _extends = extends; public TypeTree? Extends => _extends?.Element; public ClassDeclaration WithExtends(TypeTree? newExtends) { return Padding.WithExtends(JLeftPadded.WithElement(_extends, newExtends)); } - private readonly JContainer? _implements = implements; + private JContainer? _implements = implements; public IList? Implements => _implements?.GetElements(); public ClassDeclaration WithImplements(IList? newImplements) { return Padding.WithImplements(JContainer.WithElementsNullable(_implements, newImplements)); } - private readonly JContainer? _permits = permits; + private JContainer? _permits = permits; public IList? Permits => _permits?.GetElements(); public ClassDeclaration WithPermits(IList? newPermits) { return Padding.WithPermits(JContainer.WithElementsNullable(_permits, newPermits)); } - public J.Block Body => body; + public J.Block Body { get; set; } = body; public ClassDeclaration WithBody(J.Block newBody) { - return ReferenceEquals(newBody, body) ? this : new ClassDeclaration(id, prefix, markers, leadingAnnotations, modifiers, _declarationKind, name, _typeParameters, _primaryConstructor, _extends, _implements, _permits, newBody, type); + return ReferenceEquals(newBody, Body) ? this : new ClassDeclaration(Id, Prefix, Markers, LeadingAnnotations, Modifiers, _declarationKind, Name, _typeParameters, _primaryConstructor, _extends, _implements, _permits, newBody, Type); } - public JavaType.FullyQualified? Type => type; + public JavaType.FullyQualified? Type { get; set; } = type; public ClassDeclaration WithType(JavaType.FullyQualified? newType) { - return newType == type ? this : new ClassDeclaration(id, prefix, markers, leadingAnnotations, modifiers, _declarationKind, name, _typeParameters, _primaryConstructor, _extends, _implements, _permits, body, newType); + return newType == Type ? this : new ClassDeclaration(Id, Prefix, Markers, LeadingAnnotations, Modifiers, _declarationKind, Name, _typeParameters, _primaryConstructor, _extends, _implements, _permits, Body, newType); } #if DEBUG_VISITOR [DebuggerStepThrough] @@ -178,35 +178,35 @@ Kind.Types kindType return v.VisitClassDeclarationKind(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Kind WithId(Guid newId) { - return newId == id ? this : new Kind(newId, prefix, markers, annotations, kindType); + return newId == Id ? this : new Kind(newId, Prefix, Markers, Annotations, KindType); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Kind WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Kind(id, newPrefix, markers, annotations, kindType); + return newPrefix == Prefix ? this : new Kind(Id, newPrefix, Markers, Annotations, KindType); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Kind WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Kind(id, prefix, newMarkers, annotations, kindType); + return ReferenceEquals(newMarkers, Markers) ? this : new Kind(Id, Prefix, newMarkers, Annotations, KindType); } - public IList Annotations => annotations; + public IList Annotations { get; set; } = annotations; public Kind WithAnnotations(IList newAnnotations) { - return newAnnotations == annotations ? this : new Kind(id, prefix, markers, newAnnotations, kindType); + return newAnnotations == Annotations ? this : new Kind(Id, Prefix, Markers, newAnnotations, KindType); } - public Types KindType => kindType; + public Types KindType { get; set; } = kindType; public Kind WithKindType(Types newKindType) { - return newKindType == kindType ? this : new Kind(id, prefix, markers, annotations, newKindType); + return newKindType == KindType ? this : new Kind(Id, Prefix, Markers, Annotations, newKindType); } public enum Types { @@ -234,46 +234,46 @@ public override int GetHashCode() } public sealed record PaddingHelper(J.ClassDeclaration T) { - public J.ClassDeclaration.Kind DeclarationKind => T._declarationKind; + public J.ClassDeclaration.Kind DeclarationKind { get => T._declarationKind; set => T._declarationKind = value; } public J.ClassDeclaration WithDeclarationKind(J.ClassDeclaration.Kind newDeclarationKind) { - return T._declarationKind == newDeclarationKind ? T : new J.ClassDeclaration(T.Id, T.Prefix, T.Markers, T.LeadingAnnotations, T.Modifiers, newDeclarationKind, T.Name, T._typeParameters, T._primaryConstructor, T._extends, T._implements, T._permits, T.Body, T.Type); + return DeclarationKind == newDeclarationKind ? T : new J.ClassDeclaration(T.Id, T.Prefix, T.Markers, T.LeadingAnnotations, T.Modifiers, newDeclarationKind, T.Name, T._typeParameters, T._primaryConstructor, T._extends, T._implements, T._permits, T.Body, T.Type); } - public JContainer? TypeParameters => T._typeParameters; + public JContainer? TypeParameters { get => T._typeParameters; set => T._typeParameters = value; } public J.ClassDeclaration WithTypeParameters(JContainer? newTypeParameters) { - return T._typeParameters == newTypeParameters ? T : new J.ClassDeclaration(T.Id, T.Prefix, T.Markers, T.LeadingAnnotations, T.Modifiers, T._declarationKind, T.Name, newTypeParameters, T._primaryConstructor, T._extends, T._implements, T._permits, T.Body, T.Type); + return TypeParameters == newTypeParameters ? T : new J.ClassDeclaration(T.Id, T.Prefix, T.Markers, T.LeadingAnnotations, T.Modifiers, T._declarationKind, T.Name, newTypeParameters, T._primaryConstructor, T._extends, T._implements, T._permits, T.Body, T.Type); } - public JContainer? PrimaryConstructor => T._primaryConstructor; + public JContainer? PrimaryConstructor { get => T._primaryConstructor; set => T._primaryConstructor = value; } public J.ClassDeclaration WithPrimaryConstructor(JContainer? newPrimaryConstructor) { - return T._primaryConstructor == newPrimaryConstructor ? T : new J.ClassDeclaration(T.Id, T.Prefix, T.Markers, T.LeadingAnnotations, T.Modifiers, T._declarationKind, T.Name, T._typeParameters, newPrimaryConstructor, T._extends, T._implements, T._permits, T.Body, T.Type); + return PrimaryConstructor == newPrimaryConstructor ? T : new J.ClassDeclaration(T.Id, T.Prefix, T.Markers, T.LeadingAnnotations, T.Modifiers, T._declarationKind, T.Name, T._typeParameters, newPrimaryConstructor, T._extends, T._implements, T._permits, T.Body, T.Type); } - public JLeftPadded? Extends => T._extends; + public JLeftPadded? Extends { get => T._extends; set => T._extends = value; } public J.ClassDeclaration WithExtends(JLeftPadded? newExtends) { - return T._extends == newExtends ? T : new J.ClassDeclaration(T.Id, T.Prefix, T.Markers, T.LeadingAnnotations, T.Modifiers, T._declarationKind, T.Name, T._typeParameters, T._primaryConstructor, newExtends, T._implements, T._permits, T.Body, T.Type); + return Extends == newExtends ? T : new J.ClassDeclaration(T.Id, T.Prefix, T.Markers, T.LeadingAnnotations, T.Modifiers, T._declarationKind, T.Name, T._typeParameters, T._primaryConstructor, newExtends, T._implements, T._permits, T.Body, T.Type); } - public JContainer? Implements => T._implements; + public JContainer? Implements { get => T._implements; set => T._implements = value; } public J.ClassDeclaration WithImplements(JContainer? newImplements) { - return T._implements == newImplements ? T : new J.ClassDeclaration(T.Id, T.Prefix, T.Markers, T.LeadingAnnotations, T.Modifiers, T._declarationKind, T.Name, T._typeParameters, T._primaryConstructor, T._extends, newImplements, T._permits, T.Body, T.Type); + return Implements == newImplements ? T : new J.ClassDeclaration(T.Id, T.Prefix, T.Markers, T.LeadingAnnotations, T.Modifiers, T._declarationKind, T.Name, T._typeParameters, T._primaryConstructor, T._extends, newImplements, T._permits, T.Body, T.Type); } - public JContainer? Permits => T._permits; + public JContainer? Permits { get => T._permits; set => T._permits = value; } public J.ClassDeclaration WithPermits(JContainer? newPermits) { - return T._permits == newPermits ? T : new J.ClassDeclaration(T.Id, T.Prefix, T.Markers, T.LeadingAnnotations, T.Modifiers, T._declarationKind, T.Name, T._typeParameters, T._primaryConstructor, T._extends, T._implements, newPermits, T.Body, T.Type); + return Permits == newPermits ? T : new J.ClassDeclaration(T.Id, T.Prefix, T.Markers, T.LeadingAnnotations, T.Modifiers, T._declarationKind, T.Name, T._typeParameters, T._primaryConstructor, T._extends, T._implements, newPermits, T.Body, T.Type); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/Comment.cs b/Rewrite/src/Rewrite.Java/Tree/Comment.cs index ee7769f7..46812cbd 100644 --- a/Rewrite/src/Rewrite.Java/Tree/Comment.cs +++ b/Rewrite/src/Rewrite.Java/Tree/Comment.cs @@ -7,14 +7,14 @@ namespace Rewrite.RewriteJava.Tree; [SuppressMessage("ReSharper", "InconsistentNaming")] [SuppressMessage("ReSharper", "PossibleUnintendedReferenceComparison")] -public interface Comment +public interface Comment : IEquatable { public bool Multiline { get; } public string Suffix { get; } public Markers Markers { get; } - + void PrintComment

(Cursor cursor, PrintOutputCapture

p); Comment WithSuffix(string replace); diff --git a/Rewrite/src/Rewrite.Java/Tree/CompilationUnit.g.cs b/Rewrite/src/Rewrite.Java/Tree/CompilationUnit.g.cs index 2412ffec..96cd4a79 100644 --- a/Rewrite/src/Rewrite.Java/Tree/CompilationUnit.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/CompilationUnit.g.cs @@ -71,94 +71,94 @@ public PaddingHelper Padding return v.VisitCompilationUnit(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public CompilationUnit WithId(Guid newId) { - return newId == id ? this : new CompilationUnit(newId, prefix, markers, sourcePath, fileAttributes, charsetName, charsetBomMarked, checksum, _packageDeclaration, _imports, classes, eof); + return newId == Id ? this : new CompilationUnit(newId, Prefix, Markers, SourcePath, FileAttributes, CharsetName, CharsetBomMarked, Checksum, _packageDeclaration, _imports, Classes, Eof); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public CompilationUnit WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new CompilationUnit(id, newPrefix, markers, sourcePath, fileAttributes, charsetName, charsetBomMarked, checksum, _packageDeclaration, _imports, classes, eof); + return newPrefix == Prefix ? this : new CompilationUnit(Id, newPrefix, Markers, SourcePath, FileAttributes, CharsetName, CharsetBomMarked, Checksum, _packageDeclaration, _imports, Classes, Eof); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public CompilationUnit WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new CompilationUnit(id, prefix, newMarkers, sourcePath, fileAttributes, charsetName, charsetBomMarked, checksum, _packageDeclaration, _imports, classes, eof); + return ReferenceEquals(newMarkers, Markers) ? this : new CompilationUnit(Id, Prefix, newMarkers, SourcePath, FileAttributes, CharsetName, CharsetBomMarked, Checksum, _packageDeclaration, _imports, Classes, Eof); } - public string SourcePath => sourcePath; + public string SourcePath { get; set; } = sourcePath; public CompilationUnit WithSourcePath(string newSourcePath) { - return newSourcePath == sourcePath ? this : new CompilationUnit(id, prefix, markers, newSourcePath, fileAttributes, charsetName, charsetBomMarked, checksum, _packageDeclaration, _imports, classes, eof); + return newSourcePath == SourcePath ? this : new CompilationUnit(Id, Prefix, Markers, newSourcePath, FileAttributes, CharsetName, CharsetBomMarked, Checksum, _packageDeclaration, _imports, Classes, Eof); } - public FileAttributes? FileAttributes => fileAttributes; + public FileAttributes? FileAttributes { get; set; } = fileAttributes; public CompilationUnit WithFileAttributes(FileAttributes? newFileAttributes) { - return newFileAttributes == fileAttributes ? this : new CompilationUnit(id, prefix, markers, sourcePath, newFileAttributes, charsetName, charsetBomMarked, checksum, _packageDeclaration, _imports, classes, eof); + return newFileAttributes == FileAttributes ? this : new CompilationUnit(Id, Prefix, Markers, SourcePath, newFileAttributes, CharsetName, CharsetBomMarked, Checksum, _packageDeclaration, _imports, Classes, Eof); } - public string? CharsetName => charsetName; + public string? CharsetName { get; set; } = charsetName; public CompilationUnit WithCharsetName(string? newCharsetName) { - return newCharsetName == charsetName ? this : new CompilationUnit(id, prefix, markers, sourcePath, fileAttributes, newCharsetName, charsetBomMarked, checksum, _packageDeclaration, _imports, classes, eof); + return newCharsetName == CharsetName ? this : new CompilationUnit(Id, Prefix, Markers, SourcePath, FileAttributes, newCharsetName, CharsetBomMarked, Checksum, _packageDeclaration, _imports, Classes, Eof); } - public bool CharsetBomMarked => charsetBomMarked; + public bool CharsetBomMarked { get; set; } = charsetBomMarked; public CompilationUnit WithCharsetBomMarked(bool newCharsetBomMarked) { - return newCharsetBomMarked == charsetBomMarked ? this : new CompilationUnit(id, prefix, markers, sourcePath, fileAttributes, charsetName, newCharsetBomMarked, checksum, _packageDeclaration, _imports, classes, eof); + return newCharsetBomMarked == CharsetBomMarked ? this : new CompilationUnit(Id, Prefix, Markers, SourcePath, FileAttributes, CharsetName, newCharsetBomMarked, Checksum, _packageDeclaration, _imports, Classes, Eof); } - public Checksum? Checksum => checksum; + public Checksum? Checksum { get; set; } = checksum; public CompilationUnit WithChecksum(Checksum? newChecksum) { - return newChecksum == checksum ? this : new CompilationUnit(id, prefix, markers, sourcePath, fileAttributes, charsetName, charsetBomMarked, newChecksum, _packageDeclaration, _imports, classes, eof); + return newChecksum == Checksum ? this : new CompilationUnit(Id, Prefix, Markers, SourcePath, FileAttributes, CharsetName, CharsetBomMarked, newChecksum, _packageDeclaration, _imports, Classes, Eof); } - private readonly JRightPadded? _packageDeclaration = packageDeclaration; + private JRightPadded? _packageDeclaration = packageDeclaration; public J.Package? PackageDeclaration => _packageDeclaration?.Element; public CompilationUnit WithPackageDeclaration(J.Package? newPackageDeclaration) { return Padding.WithPackageDeclaration(JRightPadded.WithElement(_packageDeclaration, newPackageDeclaration)); } - private readonly IList> _imports = imports; + private IList> _imports = imports; public IList Imports => _imports.Elements(); public CompilationUnit WithImports(IList newImports) { return Padding.WithImports(_imports.WithElements(newImports)); } - public IList Classes => classes; + public IList Classes { get; set; } = classes; public CompilationUnit WithClasses(IList newClasses) { - return newClasses == classes ? this : new CompilationUnit(id, prefix, markers, sourcePath, fileAttributes, charsetName, charsetBomMarked, checksum, _packageDeclaration, _imports, newClasses, eof); + return newClasses == Classes ? this : new CompilationUnit(Id, Prefix, Markers, SourcePath, FileAttributes, CharsetName, CharsetBomMarked, Checksum, _packageDeclaration, _imports, newClasses, Eof); } - public Space Eof => eof; + public Space Eof { get; set; } = eof; public CompilationUnit WithEof(Space newEof) { - return newEof == eof ? this : new CompilationUnit(id, prefix, markers, sourcePath, fileAttributes, charsetName, charsetBomMarked, checksum, _packageDeclaration, _imports, classes, newEof); + return newEof == Eof ? this : new CompilationUnit(Id, Prefix, Markers, SourcePath, FileAttributes, CharsetName, CharsetBomMarked, Checksum, _packageDeclaration, _imports, Classes, newEof); } public sealed record PaddingHelper(J.CompilationUnit T) { - public JRightPadded? PackageDeclaration => T._packageDeclaration; + public JRightPadded? PackageDeclaration { get => T._packageDeclaration; set => T._packageDeclaration = value; } public J.CompilationUnit WithPackageDeclaration(JRightPadded? newPackageDeclaration) { - return T._packageDeclaration == newPackageDeclaration ? T : new J.CompilationUnit(T.Id, T.Prefix, T.Markers, T.SourcePath, T.FileAttributes, T.CharsetName, T.CharsetBomMarked, T.Checksum, newPackageDeclaration, T._imports, T.Classes, T.Eof); + return PackageDeclaration == newPackageDeclaration ? T : new J.CompilationUnit(T.Id, T.Prefix, T.Markers, T.SourcePath, T.FileAttributes, T.CharsetName, T.CharsetBomMarked, T.Checksum, newPackageDeclaration, T._imports, T.Classes, T.Eof); } - public IList> Imports => T._imports; + public IList> Imports { get => T._imports; set => T._imports = value; } public J.CompilationUnit WithImports(IList> newImports) { - return T._imports == newImports ? T : new J.CompilationUnit(T.Id, T.Prefix, T.Markers, T.SourcePath, T.FileAttributes, T.CharsetName, T.CharsetBomMarked, T.Checksum, T._packageDeclaration, newImports, T.Classes, T.Eof); + return Imports == newImports ? T : new J.CompilationUnit(T.Id, T.Prefix, T.Markers, T.SourcePath, T.FileAttributes, T.CharsetName, T.CharsetBomMarked, T.Checksum, T._packageDeclaration, newImports, T.Classes, T.Eof); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/Continue.g.cs b/Rewrite/src/Rewrite.Java/Tree/Continue.g.cs index 24426c3b..8ac61f7d 100644 --- a/Rewrite/src/Rewrite.Java/Tree/Continue.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/Continue.g.cs @@ -38,29 +38,29 @@ public partial class Continue( return v.VisitContinue(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Continue WithId(Guid newId) { - return newId == id ? this : new Continue(newId, prefix, markers, label); + return newId == Id ? this : new Continue(newId, Prefix, Markers, Label); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Continue WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Continue(id, newPrefix, markers, label); + return newPrefix == Prefix ? this : new Continue(Id, newPrefix, Markers, Label); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Continue WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Continue(id, prefix, newMarkers, label); + return ReferenceEquals(newMarkers, Markers) ? this : new Continue(Id, Prefix, newMarkers, Label); } - public J.Identifier? Label => label; + public J.Identifier? Label { get; set; } = label; public Continue WithLabel(J.Identifier? newLabel) { - return ReferenceEquals(newLabel, label) ? this : new Continue(id, prefix, markers, newLabel); + return ReferenceEquals(newLabel, Label) ? this : new Continue(Id, Prefix, Markers, newLabel); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.Java/Tree/ControlParentheses.g.cs b/Rewrite/src/Rewrite.Java/Tree/ControlParentheses.g.cs index 716b193f..7d433088 100644 --- a/Rewrite/src/Rewrite.Java/Tree/ControlParentheses.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/ControlParentheses.g.cs @@ -63,25 +63,25 @@ public PaddingHelper Padding return v.VisitControlParentheses(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public J.ControlParentheses WithId(Guid newId) { - return newId == id ? this : new J.ControlParentheses(newId, prefix, markers, _tree); + return newId == Id ? this : new J.ControlParentheses(newId, Prefix, Markers, _tree); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public J.ControlParentheses WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new J.ControlParentheses(id, newPrefix, markers, _tree); + return newPrefix == Prefix ? this : new J.ControlParentheses(Id, newPrefix, Markers, _tree); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public J.ControlParentheses WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new J.ControlParentheses(id, prefix, newMarkers, _tree); + return ReferenceEquals(newMarkers, Markers) ? this : new J.ControlParentheses(Id, Prefix, newMarkers, _tree); } - private readonly JRightPadded _tree = tree; + private JRightPadded _tree = tree; public J2 Tree => _tree.Element; public J.ControlParentheses WithTree(J2 newTree) @@ -90,11 +90,11 @@ public J.ControlParentheses WithTree(J2 newTree) } public sealed record PaddingHelper(J.ControlParentheses T) { - public JRightPadded Tree => T._tree; + public JRightPadded Tree { get => T._tree; set => T._tree = value; } public J.ControlParentheses WithTree(JRightPadded newTree) { - return T._tree == newTree ? T : new J.ControlParentheses(T.Id, T.Prefix, T.Markers, newTree); + return Tree == newTree ? T : new J.ControlParentheses(T.Id, T.Prefix, T.Markers, newTree); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/DeconstructionPattern.g.cs b/Rewrite/src/Rewrite.Java/Tree/DeconstructionPattern.g.cs index fd8ec3e0..0bd9049c 100644 --- a/Rewrite/src/Rewrite.Java/Tree/DeconstructionPattern.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/DeconstructionPattern.g.cs @@ -65,50 +65,50 @@ public PaddingHelper Padding return v.VisitDeconstructionPattern(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public DeconstructionPattern WithId(Guid newId) { - return newId == id ? this : new DeconstructionPattern(newId, prefix, markers, deconstructor, _nested, type); + return newId == Id ? this : new DeconstructionPattern(newId, Prefix, Markers, Deconstructor, _nested, Type); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public DeconstructionPattern WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new DeconstructionPattern(id, newPrefix, markers, deconstructor, _nested, type); + return newPrefix == Prefix ? this : new DeconstructionPattern(Id, newPrefix, Markers, Deconstructor, _nested, Type); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public DeconstructionPattern WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new DeconstructionPattern(id, prefix, newMarkers, deconstructor, _nested, type); + return ReferenceEquals(newMarkers, Markers) ? this : new DeconstructionPattern(Id, Prefix, newMarkers, Deconstructor, _nested, Type); } - public Expression Deconstructor => deconstructor; + public Expression Deconstructor { get; set; } = deconstructor; public DeconstructionPattern WithDeconstructor(Expression newDeconstructor) { - return ReferenceEquals(newDeconstructor, deconstructor) ? this : new DeconstructionPattern(id, prefix, markers, newDeconstructor, _nested, type); + return ReferenceEquals(newDeconstructor, Deconstructor) ? this : new DeconstructionPattern(Id, Prefix, Markers, newDeconstructor, _nested, Type); } - private readonly JContainer _nested = nested; + private JContainer _nested = nested; public IList Nested => _nested.GetElements(); public DeconstructionPattern WithNested(IList newNested) { return Padding.WithNested(JContainer.WithElements(_nested, newNested)); } - public JavaType Type => type; + public JavaType Type { get; set; } = type; public DeconstructionPattern WithType(JavaType newType) { - return newType == type ? this : new DeconstructionPattern(id, prefix, markers, deconstructor, _nested, newType); + return newType == Type ? this : new DeconstructionPattern(Id, Prefix, Markers, Deconstructor, _nested, newType); } public sealed record PaddingHelper(J.DeconstructionPattern T) { - public JContainer Nested => T._nested; + public JContainer Nested { get => T._nested; set => T._nested = value; } public J.DeconstructionPattern WithNested(JContainer newNested) { - return T._nested == newNested ? T : new J.DeconstructionPattern(T.Id, T.Prefix, T.Markers, T.Deconstructor, newNested, T.Type); + return Nested == newNested ? T : new J.DeconstructionPattern(T.Id, T.Prefix, T.Markers, T.Deconstructor, newNested, T.Type); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/DoWhileLoop.g.cs b/Rewrite/src/Rewrite.Java/Tree/DoWhileLoop.g.cs index 09d20be0..3117f8c2 100644 --- a/Rewrite/src/Rewrite.Java/Tree/DoWhileLoop.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/DoWhileLoop.g.cs @@ -64,32 +64,32 @@ public PaddingHelper Padding return v.VisitDoWhileLoop(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public DoWhileLoop WithId(Guid newId) { - return newId == id ? this : new DoWhileLoop(newId, prefix, markers, _body, _whileCondition); + return newId == Id ? this : new DoWhileLoop(newId, Prefix, Markers, _body, _whileCondition); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public DoWhileLoop WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new DoWhileLoop(id, newPrefix, markers, _body, _whileCondition); + return newPrefix == Prefix ? this : new DoWhileLoop(Id, newPrefix, Markers, _body, _whileCondition); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public DoWhileLoop WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new DoWhileLoop(id, prefix, newMarkers, _body, _whileCondition); + return ReferenceEquals(newMarkers, Markers) ? this : new DoWhileLoop(Id, Prefix, newMarkers, _body, _whileCondition); } - private readonly JRightPadded _body = body; + private JRightPadded _body = body; public Statement Body => _body.Element; public DoWhileLoop WithBody(Statement newBody) { return Padding.WithBody(_body.WithElement(newBody)); } - private readonly JLeftPadded> _whileCondition = whileCondition; + private JLeftPadded> _whileCondition = whileCondition; public J.ControlParentheses WhileCondition => _whileCondition.Element; public DoWhileLoop WithWhileCondition(J.ControlParentheses newWhileCondition) @@ -98,18 +98,18 @@ public DoWhileLoop WithWhileCondition(J.ControlParentheses newWhileC } public sealed record PaddingHelper(J.DoWhileLoop T) { - public JRightPadded Body => T._body; + public JRightPadded Body { get => T._body; set => T._body = value; } public J.DoWhileLoop WithBody(JRightPadded newBody) { - return T._body == newBody ? T : new J.DoWhileLoop(T.Id, T.Prefix, T.Markers, newBody, T._whileCondition); + return Body == newBody ? T : new J.DoWhileLoop(T.Id, T.Prefix, T.Markers, newBody, T._whileCondition); } - public JLeftPadded> WhileCondition => T._whileCondition; + public JLeftPadded> WhileCondition { get => T._whileCondition; set => T._whileCondition = value; } public J.DoWhileLoop WithWhileCondition(JLeftPadded> newWhileCondition) { - return T._whileCondition == newWhileCondition ? T : new J.DoWhileLoop(T.Id, T.Prefix, T.Markers, T._body, newWhileCondition); + return WhileCondition == newWhileCondition ? T : new J.DoWhileLoop(T.Id, T.Prefix, T.Markers, T._body, newWhileCondition); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/Empty.g.cs b/Rewrite/src/Rewrite.Java/Tree/Empty.g.cs index 72f168ee..0d02f6a2 100644 --- a/Rewrite/src/Rewrite.Java/Tree/Empty.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/Empty.g.cs @@ -37,23 +37,23 @@ Markers markers return v.VisitEmpty(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Empty WithId(Guid newId) { - return newId == id ? this : new Empty(newId, prefix, markers); + return newId == Id ? this : new Empty(newId, Prefix, Markers); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Empty WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Empty(id, newPrefix, markers); + return newPrefix == Prefix ? this : new Empty(Id, newPrefix, Markers); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Empty WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Empty(id, prefix, newMarkers); + return ReferenceEquals(newMarkers, Markers) ? this : new Empty(Id, Prefix, newMarkers); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.Java/Tree/EnumValue.g.cs b/Rewrite/src/Rewrite.Java/Tree/EnumValue.g.cs index 4941eac6..f9825bbc 100644 --- a/Rewrite/src/Rewrite.Java/Tree/EnumValue.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/EnumValue.g.cs @@ -40,41 +40,41 @@ public partial class EnumValue( return v.VisitEnumValue(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public EnumValue WithId(Guid newId) { - return newId == id ? this : new EnumValue(newId, prefix, markers, annotations, name, initializer); + return newId == Id ? this : new EnumValue(newId, Prefix, Markers, Annotations, Name, Initializer); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public EnumValue WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new EnumValue(id, newPrefix, markers, annotations, name, initializer); + return newPrefix == Prefix ? this : new EnumValue(Id, newPrefix, Markers, Annotations, Name, Initializer); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public EnumValue WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new EnumValue(id, prefix, newMarkers, annotations, name, initializer); + return ReferenceEquals(newMarkers, Markers) ? this : new EnumValue(Id, Prefix, newMarkers, Annotations, Name, Initializer); } - public IList Annotations => annotations; + public IList Annotations { get; set; } = annotations; public EnumValue WithAnnotations(IList newAnnotations) { - return newAnnotations == annotations ? this : new EnumValue(id, prefix, markers, newAnnotations, name, initializer); + return newAnnotations == Annotations ? this : new EnumValue(Id, Prefix, Markers, newAnnotations, Name, Initializer); } - public J.Identifier Name => name; + public J.Identifier Name { get; set; } = name; public EnumValue WithName(J.Identifier newName) { - return ReferenceEquals(newName, name) ? this : new EnumValue(id, prefix, markers, annotations, newName, initializer); + return ReferenceEquals(newName, Name) ? this : new EnumValue(Id, Prefix, Markers, Annotations, newName, Initializer); } - public J.NewClass? Initializer => initializer; + public J.NewClass? Initializer { get; set; } = initializer; public EnumValue WithInitializer(J.NewClass? newInitializer) { - return ReferenceEquals(newInitializer, initializer) ? this : new EnumValue(id, prefix, markers, annotations, name, newInitializer); + return ReferenceEquals(newInitializer, Initializer) ? this : new EnumValue(Id, Prefix, Markers, Annotations, Name, newInitializer); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.Java/Tree/EnumValueSet.g.cs b/Rewrite/src/Rewrite.Java/Tree/EnumValueSet.g.cs index c47ac76d..29dc571f 100644 --- a/Rewrite/src/Rewrite.Java/Tree/EnumValueSet.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/EnumValueSet.g.cs @@ -64,44 +64,44 @@ public PaddingHelper Padding return v.VisitEnumValueSet(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public EnumValueSet WithId(Guid newId) { - return newId == id ? this : new EnumValueSet(newId, prefix, markers, _enums, terminatedWithSemicolon); + return newId == Id ? this : new EnumValueSet(newId, Prefix, Markers, _enums, TerminatedWithSemicolon); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public EnumValueSet WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new EnumValueSet(id, newPrefix, markers, _enums, terminatedWithSemicolon); + return newPrefix == Prefix ? this : new EnumValueSet(Id, newPrefix, Markers, _enums, TerminatedWithSemicolon); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public EnumValueSet WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new EnumValueSet(id, prefix, newMarkers, _enums, terminatedWithSemicolon); + return ReferenceEquals(newMarkers, Markers) ? this : new EnumValueSet(Id, Prefix, newMarkers, _enums, TerminatedWithSemicolon); } - private readonly IList> _enums = enums; + private IList> _enums = enums; public IList Enums => _enums.Elements(); public EnumValueSet WithEnums(IList newEnums) { return Padding.WithEnums(_enums.WithElements(newEnums)); } - public bool TerminatedWithSemicolon => terminatedWithSemicolon; + public bool TerminatedWithSemicolon { get; set; } = terminatedWithSemicolon; public EnumValueSet WithTerminatedWithSemicolon(bool newTerminatedWithSemicolon) { - return newTerminatedWithSemicolon == terminatedWithSemicolon ? this : new EnumValueSet(id, prefix, markers, _enums, newTerminatedWithSemicolon); + return newTerminatedWithSemicolon == TerminatedWithSemicolon ? this : new EnumValueSet(Id, Prefix, Markers, _enums, newTerminatedWithSemicolon); } public sealed record PaddingHelper(J.EnumValueSet T) { - public IList> Enums => T._enums; + public IList> Enums { get => T._enums; set => T._enums = value; } public J.EnumValueSet WithEnums(IList> newEnums) { - return T._enums == newEnums ? T : new J.EnumValueSet(T.Id, T.Prefix, T.Markers, newEnums, T.TerminatedWithSemicolon); + return Enums == newEnums ? T : new J.EnumValueSet(T.Id, T.Prefix, T.Markers, newEnums, T.TerminatedWithSemicolon); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/Erroneous.g.cs b/Rewrite/src/Rewrite.Java/Tree/Erroneous.g.cs index 6cc67476..6b700a50 100644 --- a/Rewrite/src/Rewrite.Java/Tree/Erroneous.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/Erroneous.g.cs @@ -41,29 +41,29 @@ string text return v.VisitErroneous(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Erroneous WithId(Guid newId) { - return newId == id ? this : new Erroneous(newId, prefix, markers, text); + return newId == Id ? this : new Erroneous(newId, Prefix, Markers, Text); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Erroneous WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Erroneous(id, newPrefix, markers, text); + return newPrefix == Prefix ? this : new Erroneous(Id, newPrefix, Markers, Text); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Erroneous WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Erroneous(id, prefix, newMarkers, text); + return ReferenceEquals(newMarkers, Markers) ? this : new Erroneous(Id, Prefix, newMarkers, Text); } - public string Text => text; + public string Text { get; set; } = text; public Erroneous WithText(string newText) { - return newText == text ? this : new Erroneous(id, prefix, markers, newText); + return newText == Text ? this : new Erroneous(Id, Prefix, Markers, newText); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.Java/Tree/Expression.cs b/Rewrite/src/Rewrite.Java/Tree/Expression.cs index 2699e1ab..96777a2b 100644 --- a/Rewrite/src/Rewrite.Java/Tree/Expression.cs +++ b/Rewrite/src/Rewrite.Java/Tree/Expression.cs @@ -5,22 +5,22 @@ namespace Rewrite.RewriteJava.Tree; -public interface Expression : Expression, TypedTree where T : Expression -{ - J J.WithPrefix(Space space) => ((J)this).WithPrefix(space); - Expression Expression.WithPrefix(Space space) => ((J)this).WithPrefix(space); - TypedTree TypedTree.WithType(JavaType? type) => ((TypedTree)this).WithType(type); - Expression Expression.WithType(JavaType? type) => ((TypedTree)this).WithType(type); -} +// public interface Expression : Expression, TypedTree where T : Expression +// { +// J J.WithPrefix(Space space) => ((J)this).WithPrefix(space); +// Expression Expression.WithPrefix(Space space) => ((J)this).WithPrefix(space); +// TypedTree TypedTree.WithType(JavaType? type) => ((TypedTree)this).WithType(type); +// Expression Expression.WithType(JavaType? type) => ((TypedTree)this).WithType(type); +// } [SuppressMessage("ReSharper", "InconsistentNaming")] [SuppressMessage("ReSharper", "PossibleUnintendedReferenceComparison")] -public interface Expression : TypedTree +public partial interface Expression : TypedTree { - public new Expression WithType(JavaType? type); - TypedTree TypedTree.WithType(JavaType? type) => WithType(type); + // public new Expression WithType(JavaType? type); + // TypedTree TypedTree.WithType(JavaType? type) => WithType(type); - public new Expression WithPrefix(Space padding); - J J.WithPrefix(Space padding) => WithPrefix(padding); + // public new Expression WithPrefix(Space padding) => (Expression)((J)this).WithPrefix(padding); + // J J.WithPrefix(Space padding) => WithPrefix(padding); IList SideEffects => (Enumerable.Empty() as IList)!; diff --git a/Rewrite/src/Rewrite.Java/Tree/FieldAccess.g.cs b/Rewrite/src/Rewrite.Java/Tree/FieldAccess.g.cs index 0d7f8e3f..318b3a22 100644 --- a/Rewrite/src/Rewrite.Java/Tree/FieldAccess.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/FieldAccess.g.cs @@ -65,50 +65,50 @@ public PaddingHelper Padding return v.VisitFieldAccess(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public FieldAccess WithId(Guid newId) { - return newId == id ? this : new FieldAccess(newId, prefix, markers, target, _name, type); + return newId == Id ? this : new FieldAccess(newId, Prefix, Markers, Target, _name, Type); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public FieldAccess WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new FieldAccess(id, newPrefix, markers, target, _name, type); + return newPrefix == Prefix ? this : new FieldAccess(Id, newPrefix, Markers, Target, _name, Type); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public FieldAccess WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new FieldAccess(id, prefix, newMarkers, target, _name, type); + return ReferenceEquals(newMarkers, Markers) ? this : new FieldAccess(Id, Prefix, newMarkers, Target, _name, Type); } - public Expression Target => target; + public Expression Target { get; set; } = target; public FieldAccess WithTarget(Expression newTarget) { - return ReferenceEquals(newTarget, target) ? this : new FieldAccess(id, prefix, markers, newTarget, _name, type); + return ReferenceEquals(newTarget, Target) ? this : new FieldAccess(Id, Prefix, Markers, newTarget, _name, Type); } - private readonly JLeftPadded _name = name; + private JLeftPadded _name = name; public J.Identifier Name => _name.Element; public FieldAccess WithName(J.Identifier newName) { return Padding.WithName(_name.WithElement(newName)); } - public JavaType? Type => type; + public JavaType? Type { get; set; } = type; public FieldAccess WithType(JavaType? newType) { - return newType == type ? this : new FieldAccess(id, prefix, markers, target, _name, newType); + return newType == Type ? this : new FieldAccess(Id, Prefix, Markers, Target, _name, newType); } public sealed record PaddingHelper(J.FieldAccess T) { - public JLeftPadded Name => T._name; + public JLeftPadded Name { get => T._name; set => T._name = value; } public J.FieldAccess WithName(JLeftPadded newName) { - return T._name == newName ? T : new J.FieldAccess(T.Id, T.Prefix, T.Markers, T.Target, newName, T.Type); + return Name == newName ? T : new J.FieldAccess(T.Id, T.Prefix, T.Markers, T.Target, newName, T.Type); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/ForEachLoop.g.cs b/Rewrite/src/Rewrite.Java/Tree/ForEachLoop.g.cs index 8cf0105a..f1d7605f 100644 --- a/Rewrite/src/Rewrite.Java/Tree/ForEachLoop.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/ForEachLoop.g.cs @@ -64,31 +64,31 @@ public PaddingHelper Padding return v.VisitForEachLoop(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public ForEachLoop WithId(Guid newId) { - return newId == id ? this : new ForEachLoop(newId, prefix, markers, loopControl, _body); + return newId == Id ? this : new ForEachLoop(newId, Prefix, Markers, LoopControl, _body); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public ForEachLoop WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new ForEachLoop(id, newPrefix, markers, loopControl, _body); + return newPrefix == Prefix ? this : new ForEachLoop(Id, newPrefix, Markers, LoopControl, _body); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public ForEachLoop WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new ForEachLoop(id, prefix, newMarkers, loopControl, _body); + return ReferenceEquals(newMarkers, Markers) ? this : new ForEachLoop(Id, Prefix, newMarkers, LoopControl, _body); } - public Control LoopControl => loopControl; + public Control LoopControl { get; set; } = loopControl; public ForEachLoop WithLoopControl(Control newLoopControl) { - return ReferenceEquals(newLoopControl, loopControl) ? this : new ForEachLoop(id, prefix, markers, newLoopControl, _body); + return ReferenceEquals(newLoopControl, LoopControl) ? this : new ForEachLoop(Id, Prefix, Markers, newLoopControl, _body); } - private readonly JRightPadded _body = body; + private JRightPadded _body = body; public Statement Body => _body.Element; public ForEachLoop WithBody(Statement newBody) @@ -136,32 +136,32 @@ public PaddingHelper Padding return v.VisitForEachControl(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Control WithId(Guid newId) { - return newId == id ? this : new Control(newId, prefix, markers, _variable, _iterable); + return newId == Id ? this : new Control(newId, Prefix, Markers, _variable, _iterable); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Control WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Control(id, newPrefix, markers, _variable, _iterable); + return newPrefix == Prefix ? this : new Control(Id, newPrefix, Markers, _variable, _iterable); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Control WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Control(id, prefix, newMarkers, _variable, _iterable); + return ReferenceEquals(newMarkers, Markers) ? this : new Control(Id, Prefix, newMarkers, _variable, _iterable); } - private readonly JRightPadded _variable = variable; + private JRightPadded _variable = variable; public J.VariableDeclarations Variable => _variable.Element; public Control WithVariable(J.VariableDeclarations newVariable) { return Padding.WithVariable(_variable.WithElement(newVariable)); } - private readonly JRightPadded _iterable = iterable; + private JRightPadded _iterable = iterable; public Expression Iterable => _iterable.Element; public Control WithIterable(Expression newIterable) @@ -170,18 +170,18 @@ public Control WithIterable(Expression newIterable) } public sealed record PaddingHelper(J.ForEachLoop.Control T) { - public JRightPadded Variable => T._variable; + public JRightPadded Variable { get => T._variable; set => T._variable = value; } public J.ForEachLoop.Control WithVariable(JRightPadded newVariable) { - return T._variable == newVariable ? T : new J.ForEachLoop.Control(T.Id, T.Prefix, T.Markers, newVariable, T._iterable); + return Variable == newVariable ? T : new J.ForEachLoop.Control(T.Id, T.Prefix, T.Markers, newVariable, T._iterable); } - public JRightPadded Iterable => T._iterable; + public JRightPadded Iterable { get => T._iterable; set => T._iterable = value; } public J.ForEachLoop.Control WithIterable(JRightPadded newIterable) { - return T._iterable == newIterable ? T : new J.ForEachLoop.Control(T.Id, T.Prefix, T.Markers, T._variable, newIterable); + return Iterable == newIterable ? T : new J.ForEachLoop.Control(T.Id, T.Prefix, T.Markers, T._variable, newIterable); } } @@ -203,11 +203,11 @@ public override int GetHashCode() } public sealed record PaddingHelper(J.ForEachLoop T) { - public JRightPadded Body => T._body; + public JRightPadded Body { get => T._body; set => T._body = value; } public J.ForEachLoop WithBody(JRightPadded newBody) { - return T._body == newBody ? T : new J.ForEachLoop(T.Id, T.Prefix, T.Markers, T.LoopControl, newBody); + return Body == newBody ? T : new J.ForEachLoop(T.Id, T.Prefix, T.Markers, T.LoopControl, newBody); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/ForLoop.g.cs b/Rewrite/src/Rewrite.Java/Tree/ForLoop.g.cs index 417ce61d..52d9ea97 100644 --- a/Rewrite/src/Rewrite.Java/Tree/ForLoop.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/ForLoop.g.cs @@ -64,31 +64,31 @@ public PaddingHelper Padding return v.VisitForLoop(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public ForLoop WithId(Guid newId) { - return newId == id ? this : new ForLoop(newId, prefix, markers, loopControl, _body); + return newId == Id ? this : new ForLoop(newId, Prefix, Markers, LoopControl, _body); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public ForLoop WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new ForLoop(id, newPrefix, markers, loopControl, _body); + return newPrefix == Prefix ? this : new ForLoop(Id, newPrefix, Markers, LoopControl, _body); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public ForLoop WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new ForLoop(id, prefix, newMarkers, loopControl, _body); + return ReferenceEquals(newMarkers, Markers) ? this : new ForLoop(Id, Prefix, newMarkers, LoopControl, _body); } - public Control LoopControl => loopControl; + public Control LoopControl { get; set; } = loopControl; public ForLoop WithLoopControl(Control newLoopControl) { - return ReferenceEquals(newLoopControl, loopControl) ? this : new ForLoop(id, prefix, markers, newLoopControl, _body); + return ReferenceEquals(newLoopControl, LoopControl) ? this : new ForLoop(Id, Prefix, Markers, newLoopControl, _body); } - private readonly JRightPadded _body = body; + private JRightPadded _body = body; public Statement Body => _body.Element; public ForLoop WithBody(Statement newBody) @@ -137,39 +137,39 @@ public PaddingHelper Padding return v.VisitForControl(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Control WithId(Guid newId) { - return newId == id ? this : new Control(newId, prefix, markers, _init, _condition, _update); + return newId == Id ? this : new Control(newId, Prefix, Markers, _init, _condition, _update); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Control WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Control(id, newPrefix, markers, _init, _condition, _update); + return newPrefix == Prefix ? this : new Control(Id, newPrefix, Markers, _init, _condition, _update); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Control WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Control(id, prefix, newMarkers, _init, _condition, _update); + return ReferenceEquals(newMarkers, Markers) ? this : new Control(Id, Prefix, newMarkers, _init, _condition, _update); } - private readonly IList> _init = init; + private IList> _init = init; public IList Init => _init.Elements(); public Control WithInit(IList newInit) { return Padding.WithInit(_init.WithElements(newInit)); } - private readonly JRightPadded _condition = condition; + private JRightPadded _condition = condition; public Expression Condition => _condition.Element; public Control WithCondition(Expression newCondition) { return Padding.WithCondition(_condition.WithElement(newCondition)); } - private readonly IList> _update = update; + private IList> _update = update; public IList Update => _update.Elements(); public Control WithUpdate(IList newUpdate) @@ -178,25 +178,25 @@ public Control WithUpdate(IList newUpdate) } public sealed record PaddingHelper(J.ForLoop.Control T) { - public IList> Init => T._init; + public IList> Init { get => T._init; set => T._init = value; } public J.ForLoop.Control WithInit(IList> newInit) { - return T._init == newInit ? T : new J.ForLoop.Control(T.Id, T.Prefix, T.Markers, newInit, T._condition, T._update); + return Init == newInit ? T : new J.ForLoop.Control(T.Id, T.Prefix, T.Markers, newInit, T._condition, T._update); } - public JRightPadded Condition => T._condition; + public JRightPadded Condition { get => T._condition; set => T._condition = value; } public J.ForLoop.Control WithCondition(JRightPadded newCondition) { - return T._condition == newCondition ? T : new J.ForLoop.Control(T.Id, T.Prefix, T.Markers, T._init, newCondition, T._update); + return Condition == newCondition ? T : new J.ForLoop.Control(T.Id, T.Prefix, T.Markers, T._init, newCondition, T._update); } - public IList> Update => T._update; + public IList> Update { get => T._update; set => T._update = value; } public J.ForLoop.Control WithUpdate(IList> newUpdate) { - return T._update == newUpdate ? T : new J.ForLoop.Control(T.Id, T.Prefix, T.Markers, T._init, T._condition, newUpdate); + return Update == newUpdate ? T : new J.ForLoop.Control(T.Id, T.Prefix, T.Markers, T._init, T._condition, newUpdate); } } @@ -218,11 +218,11 @@ public override int GetHashCode() } public sealed record PaddingHelper(J.ForLoop T) { - public JRightPadded Body => T._body; + public JRightPadded Body { get => T._body; set => T._body = value; } public J.ForLoop WithBody(JRightPadded newBody) { - return T._body == newBody ? T : new J.ForLoop(T.Id, T.Prefix, T.Markers, T.LoopControl, newBody); + return Body == newBody ? T : new J.ForLoop(T.Id, T.Prefix, T.Markers, T.LoopControl, newBody); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/Identifier.g.cs b/Rewrite/src/Rewrite.Java/Tree/Identifier.g.cs index 4bfa9514..27e2843f 100644 --- a/Rewrite/src/Rewrite.Java/Tree/Identifier.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/Identifier.g.cs @@ -41,47 +41,47 @@ public sealed partial class Identifier( return v.VisitIdentifier(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Identifier WithId(Guid newId) { - return newId == id ? this : new Identifier(newId, prefix, markers, annotations, simpleName, type, fieldType); + return newId == Id ? this : new Identifier(newId, Prefix, Markers, Annotations, SimpleName, Type, FieldType); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Identifier WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Identifier(id, newPrefix, markers, annotations, simpleName, type, fieldType); + return newPrefix == Prefix ? this : new Identifier(Id, newPrefix, Markers, Annotations, SimpleName, Type, FieldType); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Identifier WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Identifier(id, prefix, newMarkers, annotations, simpleName, type, fieldType); + return ReferenceEquals(newMarkers, Markers) ? this : new Identifier(Id, Prefix, newMarkers, Annotations, SimpleName, Type, FieldType); } - public IList Annotations => annotations; + public IList Annotations { get; set; } = annotations; public Identifier WithAnnotations(IList newAnnotations) { - return newAnnotations == annotations ? this : new Identifier(id, prefix, markers, newAnnotations, simpleName, type, fieldType); + return newAnnotations == Annotations ? this : new Identifier(Id, Prefix, Markers, newAnnotations, SimpleName, Type, FieldType); } - public string SimpleName => simpleName; + public string SimpleName { get; set; } = simpleName; public Identifier WithSimpleName(string newSimpleName) { - return newSimpleName == simpleName ? this : new Identifier(id, prefix, markers, annotations, newSimpleName, type, fieldType); + return newSimpleName == SimpleName ? this : new Identifier(Id, Prefix, Markers, Annotations, newSimpleName, Type, FieldType); } - public JavaType? Type => type; + public JavaType? Type { get; set; } = type; public Identifier WithType(JavaType? newType) { - return newType == type ? this : new Identifier(id, prefix, markers, annotations, simpleName, newType, fieldType); + return newType == Type ? this : new Identifier(Id, Prefix, Markers, Annotations, SimpleName, newType, FieldType); } - public JavaType.Variable? FieldType => fieldType; + public JavaType.Variable? FieldType { get; set; } = fieldType; public Identifier WithFieldType(JavaType.Variable? newFieldType) { - return newFieldType == fieldType ? this : new Identifier(id, prefix, markers, annotations, simpleName, type, newFieldType); + return newFieldType == FieldType ? this : new Identifier(Id, Prefix, Markers, Annotations, SimpleName, Type, newFieldType); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.Java/Tree/If.g.cs b/Rewrite/src/Rewrite.Java/Tree/If.g.cs index 007fe48c..f130f893 100644 --- a/Rewrite/src/Rewrite.Java/Tree/If.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/If.g.cs @@ -65,42 +65,42 @@ public PaddingHelper Padding return v.VisitIf(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public If WithId(Guid newId) { - return newId == id ? this : new If(newId, prefix, markers, ifCondition, _thenPart, elsePart); + return newId == Id ? this : new If(newId, Prefix, Markers, IfCondition, _thenPart, ElsePart); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public If WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new If(id, newPrefix, markers, ifCondition, _thenPart, elsePart); + return newPrefix == Prefix ? this : new If(Id, newPrefix, Markers, IfCondition, _thenPart, ElsePart); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public If WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new If(id, prefix, newMarkers, ifCondition, _thenPart, elsePart); + return ReferenceEquals(newMarkers, Markers) ? this : new If(Id, Prefix, newMarkers, IfCondition, _thenPart, ElsePart); } - public J.ControlParentheses IfCondition => ifCondition; + public J.ControlParentheses IfCondition { get; set; } = ifCondition; public If WithIfCondition(J.ControlParentheses newIfCondition) { - return ReferenceEquals(newIfCondition, ifCondition) ? this : new If(id, prefix, markers, newIfCondition, _thenPart, elsePart); + return ReferenceEquals(newIfCondition, IfCondition) ? this : new If(Id, Prefix, Markers, newIfCondition, _thenPart, ElsePart); } - private readonly JRightPadded _thenPart = thenPart; + private JRightPadded _thenPart = thenPart; public Statement ThenPart => _thenPart.Element; public If WithThenPart(Statement newThenPart) { return Padding.WithThenPart(_thenPart.WithElement(newThenPart)); } - public Else? ElsePart => elsePart; + public Else? ElsePart { get; set; } = elsePart; public If WithElsePart(Else? newElsePart) { - return ReferenceEquals(newElsePart, elsePart) ? this : new If(id, prefix, markers, ifCondition, _thenPart, newElsePart); + return ReferenceEquals(newElsePart, ElsePart) ? this : new If(Id, Prefix, Markers, IfCondition, _thenPart, newElsePart); } #if DEBUG_VISITOR [DebuggerStepThrough] @@ -142,25 +142,25 @@ public PaddingHelper Padding return v.VisitElse(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Else WithId(Guid newId) { - return newId == id ? this : new Else(newId, prefix, markers, _body); + return newId == Id ? this : new Else(newId, Prefix, Markers, _body); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Else WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Else(id, newPrefix, markers, _body); + return newPrefix == Prefix ? this : new Else(Id, newPrefix, Markers, _body); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Else WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Else(id, prefix, newMarkers, _body); + return ReferenceEquals(newMarkers, Markers) ? this : new Else(Id, Prefix, newMarkers, _body); } - private readonly JRightPadded _body = body; + private JRightPadded _body = body; public Statement Body => _body.Element; public Else WithBody(Statement newBody) @@ -169,11 +169,11 @@ public Else WithBody(Statement newBody) } public sealed record PaddingHelper(J.If.Else T) { - public JRightPadded Body => T._body; + public JRightPadded Body { get => T._body; set => T._body = value; } public J.If.Else WithBody(JRightPadded newBody) { - return T._body == newBody ? T : new J.If.Else(T.Id, T.Prefix, T.Markers, newBody); + return Body == newBody ? T : new J.If.Else(T.Id, T.Prefix, T.Markers, newBody); } } @@ -195,11 +195,11 @@ public override int GetHashCode() } public sealed record PaddingHelper(J.If T) { - public JRightPadded ThenPart => T._thenPart; + public JRightPadded ThenPart { get => T._thenPart; set => T._thenPart = value; } public J.If WithThenPart(JRightPadded newThenPart) { - return T._thenPart == newThenPart ? T : new J.If(T.Id, T.Prefix, T.Markers, T.IfCondition, newThenPart, T.ElsePart); + return ThenPart == newThenPart ? T : new J.If(T.Id, T.Prefix, T.Markers, T.IfCondition, newThenPart, T.ElsePart); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/Import.g.cs b/Rewrite/src/Rewrite.Java/Tree/Import.g.cs index c92bb447..fe272112 100644 --- a/Rewrite/src/Rewrite.Java/Tree/Import.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/Import.g.cs @@ -65,38 +65,38 @@ public PaddingHelper Padding return v.VisitImport(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Import WithId(Guid newId) { - return newId == id ? this : new Import(newId, prefix, markers, _static, qualid, _alias); + return newId == Id ? this : new Import(newId, Prefix, Markers, _static, Qualid, _alias); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Import WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Import(id, newPrefix, markers, _static, qualid, _alias); + return newPrefix == Prefix ? this : new Import(Id, newPrefix, Markers, _static, Qualid, _alias); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Import WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Import(id, prefix, newMarkers, _static, qualid, _alias); + return ReferenceEquals(newMarkers, Markers) ? this : new Import(Id, Prefix, newMarkers, _static, Qualid, _alias); } - private readonly JLeftPadded _static = @static; + private JLeftPadded _static = @static; public bool Static => _static.Element; public Import WithStatic(bool newStatic) { return Padding.WithStatic(_static.WithElement(newStatic)); } - public J.FieldAccess Qualid => qualid; + public J.FieldAccess Qualid { get; set; } = qualid; public Import WithQualid(J.FieldAccess newQualid) { - return ReferenceEquals(newQualid, qualid) ? this : new Import(id, prefix, markers, _static, newQualid, _alias); + return ReferenceEquals(newQualid, Qualid) ? this : new Import(Id, Prefix, Markers, _static, newQualid, _alias); } - private readonly JLeftPadded? _alias = alias; + private JLeftPadded? _alias = alias; public J.Identifier? Alias => _alias?.Element; public Import WithAlias(J.Identifier? newAlias) @@ -105,18 +105,18 @@ public Import WithAlias(J.Identifier? newAlias) } public sealed record PaddingHelper(J.Import T) { - public JLeftPadded Static => T._static; + public JLeftPadded Static { get => T._static; set => T._static = value; } public J.Import WithStatic(JLeftPadded newStatic) { - return T._static == newStatic ? T : new J.Import(T.Id, T.Prefix, T.Markers, newStatic, T.Qualid, T._alias); + return Static == newStatic ? T : new J.Import(T.Id, T.Prefix, T.Markers, newStatic, T.Qualid, T._alias); } - public JLeftPadded? Alias => T._alias; + public JLeftPadded? Alias { get => T._alias; set => T._alias = value; } public J.Import WithAlias(JLeftPadded? newAlias) { - return T._alias == newAlias ? T : new J.Import(T.Id, T.Prefix, T.Markers, T._static, T.Qualid, newAlias); + return Alias == newAlias ? T : new J.Import(T.Id, T.Prefix, T.Markers, T._static, T.Qualid, newAlias); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/InstanceOf.g.cs b/Rewrite/src/Rewrite.Java/Tree/InstanceOf.g.cs index 92d8ce49..a4db63e2 100644 --- a/Rewrite/src/Rewrite.Java/Tree/InstanceOf.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/InstanceOf.g.cs @@ -66,56 +66,56 @@ public PaddingHelper Padding return v.VisitInstanceOf(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public InstanceOf WithId(Guid newId) { - return newId == id ? this : new InstanceOf(newId, prefix, markers, _expression, clazz, pattern, type); + return newId == Id ? this : new InstanceOf(newId, Prefix, Markers, _expression, Clazz, Pattern, Type); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public InstanceOf WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new InstanceOf(id, newPrefix, markers, _expression, clazz, pattern, type); + return newPrefix == Prefix ? this : new InstanceOf(Id, newPrefix, Markers, _expression, Clazz, Pattern, Type); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public InstanceOf WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new InstanceOf(id, prefix, newMarkers, _expression, clazz, pattern, type); + return ReferenceEquals(newMarkers, Markers) ? this : new InstanceOf(Id, Prefix, newMarkers, _expression, Clazz, Pattern, Type); } - private readonly JRightPadded _expression = expression; + private JRightPadded _expression = expression; public Expression Expression => _expression.Element; public InstanceOf WithExpression(Expression newExpression) { return Padding.WithExpression(_expression.WithElement(newExpression)); } - public J Clazz => clazz; + public J Clazz { get; set; } = clazz; public InstanceOf WithClazz(J newClazz) { - return ReferenceEquals(newClazz, clazz) ? this : new InstanceOf(id, prefix, markers, _expression, newClazz, pattern, type); + return ReferenceEquals(newClazz, Clazz) ? this : new InstanceOf(Id, Prefix, Markers, _expression, newClazz, Pattern, Type); } - public J? Pattern => pattern; + public J? Pattern { get; set; } = pattern; public InstanceOf WithPattern(J? newPattern) { - return ReferenceEquals(newPattern, pattern) ? this : new InstanceOf(id, prefix, markers, _expression, clazz, newPattern, type); + return ReferenceEquals(newPattern, Pattern) ? this : new InstanceOf(Id, Prefix, Markers, _expression, Clazz, newPattern, Type); } - public JavaType? Type => type; + public JavaType? Type { get; set; } = type; public InstanceOf WithType(JavaType? newType) { - return newType == type ? this : new InstanceOf(id, prefix, markers, _expression, clazz, pattern, newType); + return newType == Type ? this : new InstanceOf(Id, Prefix, Markers, _expression, Clazz, Pattern, newType); } public sealed record PaddingHelper(J.InstanceOf T) { - public JRightPadded Expression => T._expression; + public JRightPadded Expression { get => T._expression; set => T._expression = value; } public J.InstanceOf WithExpression(JRightPadded newExpression) { - return T._expression == newExpression ? T : new J.InstanceOf(T.Id, T.Prefix, T.Markers, newExpression, T.Clazz, T.Pattern, T.Type); + return Expression == newExpression ? T : new J.InstanceOf(T.Id, T.Prefix, T.Markers, newExpression, T.Clazz, T.Pattern, T.Type); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/IntersectionType.g.cs b/Rewrite/src/Rewrite.Java/Tree/IntersectionType.g.cs index f3fb91db..d8905727 100644 --- a/Rewrite/src/Rewrite.Java/Tree/IntersectionType.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/IntersectionType.g.cs @@ -63,25 +63,25 @@ public PaddingHelper Padding return v.VisitIntersectionType(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public IntersectionType WithId(Guid newId) { - return newId == id ? this : new IntersectionType(newId, prefix, markers, _bounds); + return newId == Id ? this : new IntersectionType(newId, Prefix, Markers, _bounds); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public IntersectionType WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new IntersectionType(id, newPrefix, markers, _bounds); + return newPrefix == Prefix ? this : new IntersectionType(Id, newPrefix, Markers, _bounds); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public IntersectionType WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new IntersectionType(id, prefix, newMarkers, _bounds); + return ReferenceEquals(newMarkers, Markers) ? this : new IntersectionType(Id, Prefix, newMarkers, _bounds); } - private readonly JContainer _bounds = bounds; + private JContainer _bounds = bounds; public IList Bounds => _bounds.GetElements(); public IntersectionType WithBounds(IList newBounds) @@ -90,11 +90,11 @@ public IntersectionType WithBounds(IList newBounds) } public sealed record PaddingHelper(J.IntersectionType T) { - public JContainer Bounds => T._bounds; + public JContainer Bounds { get => T._bounds; set => T._bounds = value; } public J.IntersectionType WithBounds(JContainer newBounds) { - return T._bounds == newBounds ? T : new J.IntersectionType(T.Id, T.Prefix, T.Markers, newBounds); + return Bounds == newBounds ? T : new J.IntersectionType(T.Id, T.Prefix, T.Markers, newBounds); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/J.cs b/Rewrite/src/Rewrite.Java/Tree/J.cs index 32734722..8affca9a 100644 --- a/Rewrite/src/Rewrite.Java/Tree/J.cs +++ b/Rewrite/src/Rewrite.Java/Tree/J.cs @@ -1,16 +1,21 @@ using Rewrite.Core.Marker; namespace Rewrite.RewriteJava.Tree; - -public partial interface J : J where T : J -{ - public new T WithPrefix(Space prefix); - J J.WithPrefix(Space prefix) => WithPrefix(prefix); - public new T WithMarkers(Markers markers); - J J.WithMarkers(Markers markers) => WithMarkers(markers); -} +// +// public partial interface J : J where T : J +// { +// public new T WithPrefix(Space prefix); +// J J.WithPrefix(Space prefix) => WithPrefix(prefix); +// public new T WithMarkers(Markers markers); +// J J.WithMarkers(Markers markers) => WithMarkers(markers); +// } public partial interface J { public J WithPrefix(Space prefix); public J WithMarkers(Markers markers); + + public IList Comments => Prefix.Comments; + public J WithComments(IList comments) => WithPrefix(Prefix.WithComments(comments)); } + + diff --git a/Rewrite/src/Rewrite.Java/Tree/JavaSourceFile.cs b/Rewrite/src/Rewrite.Java/Tree/JavaSourceFile.cs index df79475f..57d024b9 100644 --- a/Rewrite/src/Rewrite.Java/Tree/JavaSourceFile.cs +++ b/Rewrite/src/Rewrite.Java/Tree/JavaSourceFile.cs @@ -2,12 +2,12 @@ namespace Rewrite.RewriteJava.Tree; -public interface JavaSourceFile : JavaSourceFile, MutableSourceFile where T : MutableSourceFile -{ - -} +// public interface JavaSourceFile : JavaSourceFile, MutableSourceFile where T : MutableSourceFile +// { +// +// } -public interface JavaSourceFile : J, MutableSourceFile +public partial interface JavaSourceFile : J, MutableSourceFile { // TODO do we even need this in C#? // J.Package? PackageDeclaration { get; } diff --git a/Rewrite/src/Rewrite.Java/Tree/Label.g.cs b/Rewrite/src/Rewrite.Java/Tree/Label.g.cs index 2b0d5d20..9d21c18a 100644 --- a/Rewrite/src/Rewrite.Java/Tree/Label.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/Label.g.cs @@ -64,44 +64,44 @@ public PaddingHelper Padding return v.VisitLabel(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Label WithId(Guid newId) { - return newId == id ? this : new Label(newId, prefix, markers, _name, statement); + return newId == Id ? this : new Label(newId, Prefix, Markers, _name, Statement); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Label WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Label(id, newPrefix, markers, _name, statement); + return newPrefix == Prefix ? this : new Label(Id, newPrefix, Markers, _name, Statement); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Label WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Label(id, prefix, newMarkers, _name, statement); + return ReferenceEquals(newMarkers, Markers) ? this : new Label(Id, Prefix, newMarkers, _name, Statement); } - private readonly JRightPadded _name = name; + private JRightPadded _name = name; public J.Identifier Name => _name.Element; public Label WithName(J.Identifier newName) { return Padding.WithName(_name.WithElement(newName)); } - public Statement Statement => statement; + public Statement Statement { get; set; } = statement; public Label WithStatement(Statement newStatement) { - return ReferenceEquals(newStatement, statement) ? this : new Label(id, prefix, markers, _name, newStatement); + return ReferenceEquals(newStatement, Statement) ? this : new Label(Id, Prefix, Markers, _name, newStatement); } public sealed record PaddingHelper(J.Label T) { - public JRightPadded Name => T._name; + public JRightPadded Name { get => T._name; set => T._name = value; } public J.Label WithName(JRightPadded newName) { - return T._name == newName ? T : new J.Label(T.Id, T.Prefix, T.Markers, newName, T.Statement); + return Name == newName ? T : new J.Label(T.Id, T.Prefix, T.Markers, newName, T.Statement); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/Lambda.g.cs b/Rewrite/src/Rewrite.Java/Tree/Lambda.g.cs index 7ba250c0..2864f9b0 100644 --- a/Rewrite/src/Rewrite.Java/Tree/Lambda.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/Lambda.g.cs @@ -41,47 +41,47 @@ public partial class Lambda( return v.VisitLambda(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Lambda WithId(Guid newId) { - return newId == id ? this : new Lambda(newId, prefix, markers, @params, arrow, body, type); + return newId == Id ? this : new Lambda(newId, Prefix, Markers, Params, Arrow, Body, Type); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Lambda WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Lambda(id, newPrefix, markers, @params, arrow, body, type); + return newPrefix == Prefix ? this : new Lambda(Id, newPrefix, Markers, Params, Arrow, Body, Type); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Lambda WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Lambda(id, prefix, newMarkers, @params, arrow, body, type); + return ReferenceEquals(newMarkers, Markers) ? this : new Lambda(Id, Prefix, newMarkers, Params, Arrow, Body, Type); } - public Parameters Params => @params; + public Parameters Params { get; set; } = @params; public Lambda WithParams(Parameters newParams) { - return ReferenceEquals(newParams, @params) ? this : new Lambda(id, prefix, markers, newParams, arrow, body, type); + return ReferenceEquals(newParams, Params) ? this : new Lambda(Id, Prefix, Markers, newParams, Arrow, Body, Type); } - public Space Arrow => arrow; + public Space Arrow { get; set; } = arrow; public Lambda WithArrow(Space newArrow) { - return newArrow == arrow ? this : new Lambda(id, prefix, markers, @params, newArrow, body, type); + return newArrow == Arrow ? this : new Lambda(Id, Prefix, Markers, Params, newArrow, Body, Type); } - public J Body => body; + public J Body { get; set; } = body; public Lambda WithBody(J newBody) { - return ReferenceEquals(newBody, body) ? this : new Lambda(id, prefix, markers, @params, arrow, newBody, type); + return ReferenceEquals(newBody, Body) ? this : new Lambda(Id, Prefix, Markers, Params, Arrow, newBody, Type); } - public JavaType? Type => type; + public JavaType? Type { get; set; } = type; public Lambda WithType(JavaType? newType) { - return newType == type ? this : new Lambda(id, prefix, markers, @params, arrow, body, newType); + return newType == Type ? this : new Lambda(Id, Prefix, Markers, Params, Arrow, Body, newType); } #if DEBUG_VISITOR [DebuggerStepThrough] @@ -124,31 +124,31 @@ public PaddingHelper Padding return v.VisitLambdaParameters(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Parameters WithId(Guid newId) { - return newId == id ? this : new Parameters(newId, prefix, markers, parenthesized, _elements); + return newId == Id ? this : new Parameters(newId, Prefix, Markers, Parenthesized, _elements); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Parameters WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Parameters(id, newPrefix, markers, parenthesized, _elements); + return newPrefix == Prefix ? this : new Parameters(Id, newPrefix, Markers, Parenthesized, _elements); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Parameters WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Parameters(id, prefix, newMarkers, parenthesized, _elements); + return ReferenceEquals(newMarkers, Markers) ? this : new Parameters(Id, Prefix, newMarkers, Parenthesized, _elements); } - public bool Parenthesized => parenthesized; + public bool Parenthesized { get; set; } = parenthesized; public Parameters WithParenthesized(bool newParenthesized) { - return newParenthesized == parenthesized ? this : new Parameters(id, prefix, markers, newParenthesized, _elements); + return newParenthesized == Parenthesized ? this : new Parameters(Id, Prefix, Markers, newParenthesized, _elements); } - private readonly IList> _elements = elements; + private IList> _elements = elements; public IList Elements => _elements.Elements(); public Parameters WithElements(IList newElements) @@ -157,11 +157,11 @@ public Parameters WithElements(IList newElements) } public sealed record PaddingHelper(J.Lambda.Parameters T) { - public IList> Elements => T._elements; + public IList> Elements { get => T._elements; set => T._elements = value; } public J.Lambda.Parameters WithElements(IList> newElements) { - return T._elements == newElements ? T : new J.Lambda.Parameters(T.Id, T.Prefix, T.Markers, T.Parenthesized, newElements); + return Elements == newElements ? T : new J.Lambda.Parameters(T.Id, T.Prefix, T.Markers, T.Parenthesized, newElements); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/Literal.g.cs b/Rewrite/src/Rewrite.Java/Tree/Literal.g.cs index e620063c..c302878b 100644 --- a/Rewrite/src/Rewrite.Java/Tree/Literal.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/Literal.g.cs @@ -41,64 +41,64 @@ JavaType.Primitive type return v.VisitLiteral(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Literal WithId(Guid newId) { - return newId == id ? this : new Literal(newId, prefix, markers, value, valueSource, unicodeEscapes, type); + return newId == Id ? this : new Literal(newId, Prefix, Markers, Value, ValueSource, UnicodeEscapes, Type); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Literal WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Literal(id, newPrefix, markers, value, valueSource, unicodeEscapes, type); + return newPrefix == Prefix ? this : new Literal(Id, newPrefix, Markers, Value, ValueSource, UnicodeEscapes, Type); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Literal WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Literal(id, prefix, newMarkers, value, valueSource, unicodeEscapes, type); + return ReferenceEquals(newMarkers, Markers) ? this : new Literal(Id, Prefix, newMarkers, Value, ValueSource, UnicodeEscapes, Type); } - public object? Value => value; + public object? Value { get; set; } = value; public Literal WithValue(object? newValue) { - return newValue == value ? this : new Literal(id, prefix, markers, newValue, valueSource, unicodeEscapes, type); + return newValue == Value ? this : new Literal(Id, Prefix, Markers, newValue, ValueSource, UnicodeEscapes, Type); } - public string? ValueSource => valueSource; + public string? ValueSource { get; set; } = valueSource; public Literal WithValueSource(string? newValueSource) { - return newValueSource == valueSource ? this : new Literal(id, prefix, markers, value, newValueSource, unicodeEscapes, type); + return newValueSource == ValueSource ? this : new Literal(Id, Prefix, Markers, Value, newValueSource, UnicodeEscapes, Type); } - public IList? UnicodeEscapes => unicodeEscapes; + public IList? UnicodeEscapes { get; set; } = unicodeEscapes; public Literal WithUnicodeEscapes(IList? newUnicodeEscapes) { - return newUnicodeEscapes == unicodeEscapes ? this : new Literal(id, prefix, markers, value, valueSource, newUnicodeEscapes, type); + return newUnicodeEscapes == UnicodeEscapes ? this : new Literal(Id, Prefix, Markers, Value, ValueSource, newUnicodeEscapes, Type); } - public JavaType.Primitive Type => type; + public JavaType.Primitive Type { get; set; } = type; public Literal WithType(JavaType.Primitive newType) { - return newType == type ? this : new Literal(id, prefix, markers, value, valueSource, unicodeEscapes, newType); + return newType == Type ? this : new Literal(Id, Prefix, Markers, Value, ValueSource, UnicodeEscapes, newType); } public sealed record UnicodeEscape( int valueSourceIndex, string codePoint ) { - public int ValueSourceIndex => valueSourceIndex; + public int ValueSourceIndex { get; set; } = valueSourceIndex; public UnicodeEscape WithValueSourceIndex(int newValueSourceIndex) { - return newValueSourceIndex == valueSourceIndex ? this : new UnicodeEscape(newValueSourceIndex, codePoint); + return newValueSourceIndex == ValueSourceIndex ? this : new UnicodeEscape(newValueSourceIndex, CodePoint); } - public string CodePoint => codePoint; + public string CodePoint { get; set; } = codePoint; public UnicodeEscape WithCodePoint(string newCodePoint) { - return newCodePoint == codePoint ? this : new UnicodeEscape(valueSourceIndex, newCodePoint); + return newCodePoint == CodePoint ? this : new UnicodeEscape(ValueSourceIndex, newCodePoint); } } #if DEBUG_VISITOR diff --git a/Rewrite/src/Rewrite.Java/Tree/MemberReference.cs b/Rewrite/src/Rewrite.Java/Tree/MemberReference.cs index 7145f9e8..7f495595 100644 --- a/Rewrite/src/Rewrite.Java/Tree/MemberReference.cs +++ b/Rewrite/src/Rewrite.Java/Tree/MemberReference.cs @@ -4,6 +4,6 @@ partial interface J { partial class MemberReference { - Expression Expression.WithType(JavaType? newType) => WithType(type); + Expression Expression.WithType(JavaType? newType) => WithType(Type); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/MemberReference.g.cs b/Rewrite/src/Rewrite.Java/Tree/MemberReference.g.cs index 69f13b18..71b40d99 100644 --- a/Rewrite/src/Rewrite.Java/Tree/MemberReference.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/MemberReference.g.cs @@ -68,84 +68,84 @@ public PaddingHelper Padding return v.VisitMemberReference(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public MemberReference WithId(Guid newId) { - return newId == id ? this : new MemberReference(newId, prefix, markers, _containing, _typeParameters, _reference, type, methodType, variableType); + return newId == Id ? this : new MemberReference(newId, Prefix, Markers, _containing, _typeParameters, _reference, Type, MethodType, VariableType); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public MemberReference WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new MemberReference(id, newPrefix, markers, _containing, _typeParameters, _reference, type, methodType, variableType); + return newPrefix == Prefix ? this : new MemberReference(Id, newPrefix, Markers, _containing, _typeParameters, _reference, Type, MethodType, VariableType); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public MemberReference WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new MemberReference(id, prefix, newMarkers, _containing, _typeParameters, _reference, type, methodType, variableType); + return ReferenceEquals(newMarkers, Markers) ? this : new MemberReference(Id, Prefix, newMarkers, _containing, _typeParameters, _reference, Type, MethodType, VariableType); } - private readonly JRightPadded _containing = containing; + private JRightPadded _containing = containing; public Expression Containing => _containing.Element; public MemberReference WithContaining(Expression newContaining) { return Padding.WithContaining(_containing.WithElement(newContaining)); } - private readonly JContainer? _typeParameters = typeParameters; + private JContainer? _typeParameters = typeParameters; public IList? TypeParameters => _typeParameters?.GetElements(); public MemberReference WithTypeParameters(IList? newTypeParameters) { return Padding.WithTypeParameters(JContainer.WithElementsNullable(_typeParameters, newTypeParameters)); } - private readonly JLeftPadded _reference = reference; + private JLeftPadded _reference = reference; public J.Identifier Reference => _reference.Element; public MemberReference WithReference(J.Identifier newReference) { return Padding.WithReference(_reference.WithElement(newReference)); } - public JavaType? Type => type; + public JavaType? Type { get; set; } = type; public MemberReference WithType(JavaType? newType) { - return newType == type ? this : new MemberReference(id, prefix, markers, _containing, _typeParameters, _reference, newType, methodType, variableType); + return newType == Type ? this : new MemberReference(Id, Prefix, Markers, _containing, _typeParameters, _reference, newType, MethodType, VariableType); } - public JavaType.Method? MethodType => methodType; + public JavaType.Method? MethodType { get; set; } = methodType; public MemberReference WithMethodType(JavaType.Method? newMethodType) { - return newMethodType == methodType ? this : new MemberReference(id, prefix, markers, _containing, _typeParameters, _reference, type, newMethodType, variableType); + return newMethodType == MethodType ? this : new MemberReference(Id, Prefix, Markers, _containing, _typeParameters, _reference, Type, newMethodType, VariableType); } - public JavaType.Variable? VariableType => variableType; + public JavaType.Variable? VariableType { get; set; } = variableType; public MemberReference WithVariableType(JavaType.Variable? newVariableType) { - return newVariableType == variableType ? this : new MemberReference(id, prefix, markers, _containing, _typeParameters, _reference, type, methodType, newVariableType); + return newVariableType == VariableType ? this : new MemberReference(Id, Prefix, Markers, _containing, _typeParameters, _reference, Type, MethodType, newVariableType); } public sealed record PaddingHelper(J.MemberReference T) { - public JRightPadded Containing => T._containing; + public JRightPadded Containing { get => T._containing; set => T._containing = value; } public J.MemberReference WithContaining(JRightPadded newContaining) { - return T._containing == newContaining ? T : new J.MemberReference(T.Id, T.Prefix, T.Markers, newContaining, T._typeParameters, T._reference, T.Type, T.MethodType, T.VariableType); + return Containing == newContaining ? T : new J.MemberReference(T.Id, T.Prefix, T.Markers, newContaining, T._typeParameters, T._reference, T.Type, T.MethodType, T.VariableType); } - public JContainer? TypeParameters => T._typeParameters; + public JContainer? TypeParameters { get => T._typeParameters; set => T._typeParameters = value; } public J.MemberReference WithTypeParameters(JContainer? newTypeParameters) { - return T._typeParameters == newTypeParameters ? T : new J.MemberReference(T.Id, T.Prefix, T.Markers, T._containing, newTypeParameters, T._reference, T.Type, T.MethodType, T.VariableType); + return TypeParameters == newTypeParameters ? T : new J.MemberReference(T.Id, T.Prefix, T.Markers, T._containing, newTypeParameters, T._reference, T.Type, T.MethodType, T.VariableType); } - public JLeftPadded Reference => T._reference; + public JLeftPadded Reference { get => T._reference; set => T._reference = value; } public J.MemberReference WithReference(JLeftPadded newReference) { - return T._reference == newReference ? T : new J.MemberReference(T.Id, T.Prefix, T.Markers, T._containing, T._typeParameters, newReference, T.Type, T.MethodType, T.VariableType); + return Reference == newReference ? T : new J.MemberReference(T.Id, T.Prefix, T.Markers, T._containing, T._typeParameters, newReference, T.Type, T.MethodType, T.VariableType); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/MethodDeclaration.cs b/Rewrite/src/Rewrite.Java/Tree/MethodDeclaration.cs index 3d8989a8..ea128b78 100644 --- a/Rewrite/src/Rewrite.Java/Tree/MethodDeclaration.cs +++ b/Rewrite/src/Rewrite.Java/Tree/MethodDeclaration.cs @@ -10,18 +10,18 @@ public MethodDeclaration WithName(Identifier identifier) { return new MethodDeclaration( Id, - prefix, - markers, - leadingAnnotations, - modifiers, + Prefix, + Markers, + LeadingAnnotations, + Modifiers, _typeParameters, - returnTypeExpression, + ReturnTypeExpression, _name.WithIdentifier(identifier), _parameters, _throws, - body, + Body, _defaultValue, - methodType); + MethodType); } public JavaType? Type => null; diff --git a/Rewrite/src/Rewrite.Java/Tree/MethodDeclaration.g.cs b/Rewrite/src/Rewrite.Java/Tree/MethodDeclaration.g.cs index 7f717dfc..c3fcd603 100644 --- a/Rewrite/src/Rewrite.Java/Tree/MethodDeclaration.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/MethodDeclaration.g.cs @@ -97,169 +97,169 @@ public AnnotationsHelper Annotations return v.VisitMethodDeclaration(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public MethodDeclaration WithId(Guid newId) { - return newId == id ? this : new MethodDeclaration(newId, prefix, markers, leadingAnnotations, modifiers, _typeParameters, returnTypeExpression, _name, _parameters, _throws, body, _defaultValue, methodType); + return newId == Id ? this : new MethodDeclaration(newId, Prefix, Markers, LeadingAnnotations, Modifiers, _typeParameters, ReturnTypeExpression, _name, _parameters, _throws, Body, _defaultValue, MethodType); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public MethodDeclaration WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new MethodDeclaration(id, newPrefix, markers, leadingAnnotations, modifiers, _typeParameters, returnTypeExpression, _name, _parameters, _throws, body, _defaultValue, methodType); + return newPrefix == Prefix ? this : new MethodDeclaration(Id, newPrefix, Markers, LeadingAnnotations, Modifiers, _typeParameters, ReturnTypeExpression, _name, _parameters, _throws, Body, _defaultValue, MethodType); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public MethodDeclaration WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new MethodDeclaration(id, prefix, newMarkers, leadingAnnotations, modifiers, _typeParameters, returnTypeExpression, _name, _parameters, _throws, body, _defaultValue, methodType); + return ReferenceEquals(newMarkers, Markers) ? this : new MethodDeclaration(Id, Prefix, newMarkers, LeadingAnnotations, Modifiers, _typeParameters, ReturnTypeExpression, _name, _parameters, _throws, Body, _defaultValue, MethodType); } - public IList LeadingAnnotations => leadingAnnotations; + public IList LeadingAnnotations { get; set; } = leadingAnnotations; public MethodDeclaration WithLeadingAnnotations(IList newLeadingAnnotations) { - return newLeadingAnnotations == leadingAnnotations ? this : new MethodDeclaration(id, prefix, markers, newLeadingAnnotations, modifiers, _typeParameters, returnTypeExpression, _name, _parameters, _throws, body, _defaultValue, methodType); + return newLeadingAnnotations == LeadingAnnotations ? this : new MethodDeclaration(Id, Prefix, Markers, newLeadingAnnotations, Modifiers, _typeParameters, ReturnTypeExpression, _name, _parameters, _throws, Body, _defaultValue, MethodType); } - public IList Modifiers => modifiers; + public IList Modifiers { get; set; } = modifiers; public MethodDeclaration WithModifiers(IList newModifiers) { - return newModifiers == modifiers ? this : new MethodDeclaration(id, prefix, markers, leadingAnnotations, newModifiers, _typeParameters, returnTypeExpression, _name, _parameters, _throws, body, _defaultValue, methodType); + return newModifiers == Modifiers ? this : new MethodDeclaration(Id, Prefix, Markers, LeadingAnnotations, newModifiers, _typeParameters, ReturnTypeExpression, _name, _parameters, _throws, Body, _defaultValue, MethodType); } - private readonly J.TypeParameters? _typeParameters = typeParameters; - public TypeTree? ReturnTypeExpression => returnTypeExpression; + private J.TypeParameters? _typeParameters = typeParameters; + public TypeTree? ReturnTypeExpression { get; set; } = returnTypeExpression; public MethodDeclaration WithReturnTypeExpression(TypeTree? newReturnTypeExpression) { - return ReferenceEquals(newReturnTypeExpression, returnTypeExpression) ? this : new MethodDeclaration(id, prefix, markers, leadingAnnotations, modifiers, _typeParameters, newReturnTypeExpression, _name, _parameters, _throws, body, _defaultValue, methodType); + return ReferenceEquals(newReturnTypeExpression, ReturnTypeExpression) ? this : new MethodDeclaration(Id, Prefix, Markers, LeadingAnnotations, Modifiers, _typeParameters, newReturnTypeExpression, _name, _parameters, _throws, Body, _defaultValue, MethodType); } - private readonly IdentifierWithAnnotations _name = name; - private readonly JContainer _parameters = parameters; + private IdentifierWithAnnotations _name = name; + private JContainer _parameters = parameters; public IList Parameters => _parameters.GetElements(); public MethodDeclaration WithParameters(IList newParameters) { return Padding.WithParameters(JContainer.WithElements(_parameters, newParameters)); } - private readonly JContainer? _throws = throws; + private JContainer? _throws = throws; public IList? Throws => _throws?.GetElements(); public MethodDeclaration WithThrows(IList? newThrows) { return Padding.WithThrows(JContainer.WithElementsNullable(_throws, newThrows)); } - public J.Block? Body => body; + public J.Block? Body { get; set; } = body; public MethodDeclaration WithBody(J.Block? newBody) { - return ReferenceEquals(newBody, body) ? this : new MethodDeclaration(id, prefix, markers, leadingAnnotations, modifiers, _typeParameters, returnTypeExpression, _name, _parameters, _throws, newBody, _defaultValue, methodType); + return ReferenceEquals(newBody, Body) ? this : new MethodDeclaration(Id, Prefix, Markers, LeadingAnnotations, Modifiers, _typeParameters, ReturnTypeExpression, _name, _parameters, _throws, newBody, _defaultValue, MethodType); } - private readonly JLeftPadded? _defaultValue = defaultValue; + private JLeftPadded? _defaultValue = defaultValue; public Expression? DefaultValue => _defaultValue?.Element; public MethodDeclaration WithDefaultValue(Expression? newDefaultValue) { return Padding.WithDefaultValue(JLeftPadded.WithElement(_defaultValue, newDefaultValue)); } - public JavaType.Method? MethodType => methodType; + public JavaType.Method? MethodType { get; set; } = methodType; public MethodDeclaration WithMethodType(JavaType.Method? newMethodType) { - return newMethodType == methodType ? this : new MethodDeclaration(id, prefix, markers, leadingAnnotations, modifiers, _typeParameters, returnTypeExpression, _name, _parameters, _throws, body, _defaultValue, newMethodType); + return newMethodType == MethodType ? this : new MethodDeclaration(Id, Prefix, Markers, LeadingAnnotations, Modifiers, _typeParameters, ReturnTypeExpression, _name, _parameters, _throws, Body, _defaultValue, newMethodType); } public sealed record IdentifierWithAnnotations( J.Identifier identifier, IList annotations ) { - public J.Identifier Identifier => identifier; + public J.Identifier Identifier { get; set; } = identifier; public IdentifierWithAnnotations WithIdentifier(J.Identifier newIdentifier) { - return ReferenceEquals(newIdentifier, identifier) ? this : new IdentifierWithAnnotations(newIdentifier, annotations); + return ReferenceEquals(newIdentifier, Identifier) ? this : new IdentifierWithAnnotations(newIdentifier, Annotations); } - public IList Annotations => annotations; + public IList Annotations { get; set; } = annotations; public IdentifierWithAnnotations WithAnnotations(IList newAnnotations) { - return newAnnotations == annotations ? this : new IdentifierWithAnnotations(identifier, newAnnotations); + return newAnnotations == Annotations ? this : new IdentifierWithAnnotations(Identifier, newAnnotations); } } public sealed record PaddingHelper(J.MethodDeclaration T) { - public J.TypeParameters? TypeParameters => T._typeParameters; + public J.TypeParameters? TypeParameters { get => T._typeParameters; set => T._typeParameters = value; } public J.MethodDeclaration WithTypeParameters(J.TypeParameters? newTypeParameters) { - return T._typeParameters == newTypeParameters ? T : new J.MethodDeclaration(T.Id, T.Prefix, T.Markers, T.LeadingAnnotations, T.Modifiers, newTypeParameters, T.ReturnTypeExpression, T._name, T._parameters, T._throws, T.Body, T._defaultValue, T.MethodType); + return TypeParameters == newTypeParameters ? T : new J.MethodDeclaration(T.Id, T.Prefix, T.Markers, T.LeadingAnnotations, T.Modifiers, newTypeParameters, T.ReturnTypeExpression, T._name, T._parameters, T._throws, T.Body, T._defaultValue, T.MethodType); } - public J.MethodDeclaration.IdentifierWithAnnotations Name => T._name; + public J.MethodDeclaration.IdentifierWithAnnotations Name { get => T._name; set => T._name = value; } public J.MethodDeclaration WithName(J.MethodDeclaration.IdentifierWithAnnotations newName) { - return T._name == newName ? T : new J.MethodDeclaration(T.Id, T.Prefix, T.Markers, T.LeadingAnnotations, T.Modifiers, T._typeParameters, T.ReturnTypeExpression, newName, T._parameters, T._throws, T.Body, T._defaultValue, T.MethodType); + return Name == newName ? T : new J.MethodDeclaration(T.Id, T.Prefix, T.Markers, T.LeadingAnnotations, T.Modifiers, T._typeParameters, T.ReturnTypeExpression, newName, T._parameters, T._throws, T.Body, T._defaultValue, T.MethodType); } - public JContainer Parameters => T._parameters; + public JContainer Parameters { get => T._parameters; set => T._parameters = value; } public J.MethodDeclaration WithParameters(JContainer newParameters) { - return T._parameters == newParameters ? T : new J.MethodDeclaration(T.Id, T.Prefix, T.Markers, T.LeadingAnnotations, T.Modifiers, T._typeParameters, T.ReturnTypeExpression, T._name, newParameters, T._throws, T.Body, T._defaultValue, T.MethodType); + return Parameters == newParameters ? T : new J.MethodDeclaration(T.Id, T.Prefix, T.Markers, T.LeadingAnnotations, T.Modifiers, T._typeParameters, T.ReturnTypeExpression, T._name, newParameters, T._throws, T.Body, T._defaultValue, T.MethodType); } - public JContainer? Throws => T._throws; + public JContainer? Throws { get => T._throws; set => T._throws = value; } public J.MethodDeclaration WithThrows(JContainer? newThrows) { - return T._throws == newThrows ? T : new J.MethodDeclaration(T.Id, T.Prefix, T.Markers, T.LeadingAnnotations, T.Modifiers, T._typeParameters, T.ReturnTypeExpression, T._name, T._parameters, newThrows, T.Body, T._defaultValue, T.MethodType); + return Throws == newThrows ? T : new J.MethodDeclaration(T.Id, T.Prefix, T.Markers, T.LeadingAnnotations, T.Modifiers, T._typeParameters, T.ReturnTypeExpression, T._name, T._parameters, newThrows, T.Body, T._defaultValue, T.MethodType); } - public JLeftPadded? DefaultValue => T._defaultValue; + public JLeftPadded? DefaultValue { get => T._defaultValue; set => T._defaultValue = value; } public J.MethodDeclaration WithDefaultValue(JLeftPadded? newDefaultValue) { - return T._defaultValue == newDefaultValue ? T : new J.MethodDeclaration(T.Id, T.Prefix, T.Markers, T.LeadingAnnotations, T.Modifiers, T._typeParameters, T.ReturnTypeExpression, T._name, T._parameters, T._throws, T.Body, newDefaultValue, T.MethodType); + return DefaultValue == newDefaultValue ? T : new J.MethodDeclaration(T.Id, T.Prefix, T.Markers, T.LeadingAnnotations, T.Modifiers, T._typeParameters, T.ReturnTypeExpression, T._name, T._parameters, T._throws, T.Body, newDefaultValue, T.MethodType); } } public sealed record AnnotationsHelper(J.MethodDeclaration T) { - public J.TypeParameters? TypeParameters => T._typeParameters; + public J.TypeParameters? TypeParameters { get => T._typeParameters; set => T._typeParameters = value; } public J.MethodDeclaration WithTypeParameters(J.TypeParameters? newTypeParameters) { - return T._typeParameters == newTypeParameters ? T : new J.MethodDeclaration(T.Id, T.Prefix, T.Markers, T.LeadingAnnotations, T.Modifiers, newTypeParameters, T.ReturnTypeExpression, T._name, T._parameters, T._throws, T.Body, T._defaultValue, T.MethodType); + return TypeParameters == newTypeParameters ? T : new J.MethodDeclaration(T.Id, T.Prefix, T.Markers, T.LeadingAnnotations, T.Modifiers, newTypeParameters, T.ReturnTypeExpression, T._name, T._parameters, T._throws, T.Body, T._defaultValue, T.MethodType); } - public J.MethodDeclaration.IdentifierWithAnnotations Name => T._name; + public J.MethodDeclaration.IdentifierWithAnnotations Name { get => T._name; set => T._name = value; } public J.MethodDeclaration WithName(J.MethodDeclaration.IdentifierWithAnnotations newName) { - return T._name == newName ? T : new J.MethodDeclaration(T.Id, T.Prefix, T.Markers, T.LeadingAnnotations, T.Modifiers, T._typeParameters, T.ReturnTypeExpression, newName, T._parameters, T._throws, T.Body, T._defaultValue, T.MethodType); + return Name == newName ? T : new J.MethodDeclaration(T.Id, T.Prefix, T.Markers, T.LeadingAnnotations, T.Modifiers, T._typeParameters, T.ReturnTypeExpression, newName, T._parameters, T._throws, T.Body, T._defaultValue, T.MethodType); } - public JContainer Parameters => T._parameters; + public JContainer Parameters { get => T._parameters; set => T._parameters = value; } public J.MethodDeclaration WithParameters(JContainer newParameters) { - return T._parameters == newParameters ? T : new J.MethodDeclaration(T.Id, T.Prefix, T.Markers, T.LeadingAnnotations, T.Modifiers, T._typeParameters, T.ReturnTypeExpression, T._name, newParameters, T._throws, T.Body, T._defaultValue, T.MethodType); + return Parameters == newParameters ? T : new J.MethodDeclaration(T.Id, T.Prefix, T.Markers, T.LeadingAnnotations, T.Modifiers, T._typeParameters, T.ReturnTypeExpression, T._name, newParameters, T._throws, T.Body, T._defaultValue, T.MethodType); } - public JContainer? Throws => T._throws; + public JContainer? Throws { get => T._throws; set => T._throws = value; } public J.MethodDeclaration WithThrows(JContainer? newThrows) { - return T._throws == newThrows ? T : new J.MethodDeclaration(T.Id, T.Prefix, T.Markers, T.LeadingAnnotations, T.Modifiers, T._typeParameters, T.ReturnTypeExpression, T._name, T._parameters, newThrows, T.Body, T._defaultValue, T.MethodType); + return Throws == newThrows ? T : new J.MethodDeclaration(T.Id, T.Prefix, T.Markers, T.LeadingAnnotations, T.Modifiers, T._typeParameters, T.ReturnTypeExpression, T._name, T._parameters, newThrows, T.Body, T._defaultValue, T.MethodType); } - public JLeftPadded? DefaultValue => T._defaultValue; + public JLeftPadded? DefaultValue { get => T._defaultValue; set => T._defaultValue = value; } public J.MethodDeclaration WithDefaultValue(JLeftPadded? newDefaultValue) { - return T._defaultValue == newDefaultValue ? T : new J.MethodDeclaration(T.Id, T.Prefix, T.Markers, T.LeadingAnnotations, T.Modifiers, T._typeParameters, T.ReturnTypeExpression, T._name, T._parameters, T._throws, T.Body, newDefaultValue, T.MethodType); + return DefaultValue == newDefaultValue ? T : new J.MethodDeclaration(T.Id, T.Prefix, T.Markers, T.LeadingAnnotations, T.Modifiers, T._typeParameters, T.ReturnTypeExpression, T._name, T._parameters, T._throws, T.Body, newDefaultValue, T.MethodType); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/MethodInvocation.g.cs b/Rewrite/src/Rewrite.Java/Tree/MethodInvocation.g.cs index 1caf6bdb..8671c917 100644 --- a/Rewrite/src/Rewrite.Java/Tree/MethodInvocation.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/MethodInvocation.g.cs @@ -67,78 +67,78 @@ public PaddingHelper Padding return v.VisitMethodInvocation(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public MethodInvocation WithId(Guid newId) { - return newId == id ? this : new MethodInvocation(newId, prefix, markers, _select, _typeParameters, name, _arguments, methodType); + return newId == Id ? this : new MethodInvocation(newId, Prefix, Markers, _select, _typeParameters, Name, _arguments, MethodType); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public MethodInvocation WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new MethodInvocation(id, newPrefix, markers, _select, _typeParameters, name, _arguments, methodType); + return newPrefix == Prefix ? this : new MethodInvocation(Id, newPrefix, Markers, _select, _typeParameters, Name, _arguments, MethodType); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public MethodInvocation WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new MethodInvocation(id, prefix, newMarkers, _select, _typeParameters, name, _arguments, methodType); + return ReferenceEquals(newMarkers, Markers) ? this : new MethodInvocation(Id, Prefix, newMarkers, _select, _typeParameters, Name, _arguments, MethodType); } - private readonly JRightPadded? _select = select; + private JRightPadded? _select = select; public Expression? Select => _select?.Element; public MethodInvocation WithSelect(Expression? newSelect) { return Padding.WithSelect(JRightPadded.WithElement(_select, newSelect)); } - private readonly JContainer? _typeParameters = typeParameters; + private JContainer? _typeParameters = typeParameters; public IList? TypeParameters => _typeParameters?.GetElements(); public MethodInvocation WithTypeParameters(IList? newTypeParameters) { return Padding.WithTypeParameters(JContainer.WithElementsNullable(_typeParameters, newTypeParameters)); } - public J.Identifier Name => name; + public J.Identifier Name { get; set; } = name; public MethodInvocation WithName(J.Identifier newName) { - return ReferenceEquals(newName, name) ? this : new MethodInvocation(id, prefix, markers, _select, _typeParameters, newName, _arguments, methodType); + return ReferenceEquals(newName, Name) ? this : new MethodInvocation(Id, Prefix, Markers, _select, _typeParameters, newName, _arguments, MethodType); } - private readonly JContainer _arguments = arguments; + private JContainer _arguments = arguments; public IList Arguments => _arguments.GetElements(); public MethodInvocation WithArguments(IList newArguments) { return Padding.WithArguments(JContainer.WithElements(_arguments, newArguments)); } - public JavaType.Method? MethodType => methodType; + public JavaType.Method? MethodType { get; set; } = methodType; public MethodInvocation WithMethodType(JavaType.Method? newMethodType) { - return newMethodType == methodType ? this : new MethodInvocation(id, prefix, markers, _select, _typeParameters, name, _arguments, newMethodType); + return newMethodType == MethodType ? this : new MethodInvocation(Id, Prefix, Markers, _select, _typeParameters, Name, _arguments, newMethodType); } public sealed record PaddingHelper(J.MethodInvocation T) { - public JRightPadded? Select => T._select; + public JRightPadded? Select { get => T._select; set => T._select = value; } public J.MethodInvocation WithSelect(JRightPadded? newSelect) { - return T._select == newSelect ? T : new J.MethodInvocation(T.Id, T.Prefix, T.Markers, newSelect, T._typeParameters, T.Name, T._arguments, T.MethodType); + return Select == newSelect ? T : new J.MethodInvocation(T.Id, T.Prefix, T.Markers, newSelect, T._typeParameters, T.Name, T._arguments, T.MethodType); } - public JContainer? TypeParameters => T._typeParameters; + public JContainer? TypeParameters { get => T._typeParameters; set => T._typeParameters = value; } public J.MethodInvocation WithTypeParameters(JContainer? newTypeParameters) { - return T._typeParameters == newTypeParameters ? T : new J.MethodInvocation(T.Id, T.Prefix, T.Markers, T._select, newTypeParameters, T.Name, T._arguments, T.MethodType); + return TypeParameters == newTypeParameters ? T : new J.MethodInvocation(T.Id, T.Prefix, T.Markers, T._select, newTypeParameters, T.Name, T._arguments, T.MethodType); } - public JContainer Arguments => T._arguments; + public JContainer Arguments { get => T._arguments; set => T._arguments = value; } public J.MethodInvocation WithArguments(JContainer newArguments) { - return T._arguments == newArguments ? T : new J.MethodInvocation(T.Id, T.Prefix, T.Markers, T._select, T._typeParameters, T.Name, newArguments, T.MethodType); + return Arguments == newArguments ? T : new J.MethodInvocation(T.Id, T.Prefix, T.Markers, T._select, T._typeParameters, T.Name, newArguments, T.MethodType); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/Modifier.g.cs b/Rewrite/src/Rewrite.Java/Tree/Modifier.g.cs index 590848c3..f53fe855 100644 --- a/Rewrite/src/Rewrite.Java/Tree/Modifier.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/Modifier.g.cs @@ -40,41 +40,41 @@ IList annotations return v.VisitModifier(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Modifier WithId(Guid newId) { - return newId == id ? this : new Modifier(newId, prefix, markers, keyword, modifierType, annotations); + return newId == Id ? this : new Modifier(newId, Prefix, Markers, Keyword, ModifierType, Annotations); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Modifier WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Modifier(id, newPrefix, markers, keyword, modifierType, annotations); + return newPrefix == Prefix ? this : new Modifier(Id, newPrefix, Markers, Keyword, ModifierType, Annotations); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Modifier WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Modifier(id, prefix, newMarkers, keyword, modifierType, annotations); + return ReferenceEquals(newMarkers, Markers) ? this : new Modifier(Id, Prefix, newMarkers, Keyword, ModifierType, Annotations); } - public string? Keyword => keyword; + public string? Keyword { get; set; } = keyword; public Modifier WithKeyword(string? newKeyword) { - return newKeyword == keyword ? this : new Modifier(id, prefix, markers, newKeyword, modifierType, annotations); + return newKeyword == Keyword ? this : new Modifier(Id, Prefix, Markers, newKeyword, ModifierType, Annotations); } - public Types ModifierType => modifierType; + public Types ModifierType { get; set; } = modifierType; public Modifier WithModifierType(Types newModifierType) { - return newModifierType == modifierType ? this : new Modifier(id, prefix, markers, keyword, newModifierType, annotations); + return newModifierType == ModifierType ? this : new Modifier(Id, Prefix, Markers, Keyword, newModifierType, Annotations); } - public IList Annotations => annotations; + public IList Annotations { get; set; } = annotations; public Modifier WithAnnotations(IList newAnnotations) { - return newAnnotations == annotations ? this : new Modifier(id, prefix, markers, keyword, modifierType, newAnnotations); + return newAnnotations == Annotations ? this : new Modifier(Id, Prefix, Markers, Keyword, ModifierType, newAnnotations); } public enum Types { diff --git a/Rewrite/src/Rewrite.Java/Tree/MultiCatch.g.cs b/Rewrite/src/Rewrite.Java/Tree/MultiCatch.g.cs index 626c4abd..622cbae3 100644 --- a/Rewrite/src/Rewrite.Java/Tree/MultiCatch.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/MultiCatch.g.cs @@ -63,25 +63,25 @@ public PaddingHelper Padding return v.VisitMultiCatch(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public MultiCatch WithId(Guid newId) { - return newId == id ? this : new MultiCatch(newId, prefix, markers, _alternatives); + return newId == Id ? this : new MultiCatch(newId, Prefix, Markers, _alternatives); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public MultiCatch WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new MultiCatch(id, newPrefix, markers, _alternatives); + return newPrefix == Prefix ? this : new MultiCatch(Id, newPrefix, Markers, _alternatives); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public MultiCatch WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new MultiCatch(id, prefix, newMarkers, _alternatives); + return ReferenceEquals(newMarkers, Markers) ? this : new MultiCatch(Id, Prefix, newMarkers, _alternatives); } - private readonly IList> _alternatives = alternatives; + private IList> _alternatives = alternatives; public IList Alternatives => _alternatives.Elements(); public MultiCatch WithAlternatives(IList newAlternatives) @@ -90,11 +90,11 @@ public MultiCatch WithAlternatives(IList newAlternatives) } public sealed record PaddingHelper(J.MultiCatch T) { - public IList> Alternatives => T._alternatives; + public IList> Alternatives { get => T._alternatives; set => T._alternatives = value; } public J.MultiCatch WithAlternatives(IList> newAlternatives) { - return T._alternatives == newAlternatives ? T : new J.MultiCatch(T.Id, T.Prefix, T.Markers, newAlternatives); + return Alternatives == newAlternatives ? T : new J.MultiCatch(T.Id, T.Prefix, T.Markers, newAlternatives); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/NameTree.cs b/Rewrite/src/Rewrite.Java/Tree/NameTree.cs index 1caefef3..28e1d9ad 100644 --- a/Rewrite/src/Rewrite.Java/Tree/NameTree.cs +++ b/Rewrite/src/Rewrite.Java/Tree/NameTree.cs @@ -7,7 +7,7 @@ namespace Rewrite.RewriteJava.Tree; [SuppressMessage("ReSharper", "InconsistentNaming")] [SuppressMessage("ReSharper", "PossibleUnintendedReferenceComparison")] -public interface NameTree : TypedTree +public partial interface NameTree : TypedTree { - public new NameTree WithType(JavaType? type) => (NameTree)((TypedTree)this).WithType(type); + // public new NameTree WithType(JavaType? type) => (NameTree)((TypedTree)this).WithType(type); } diff --git a/Rewrite/src/Rewrite.Java/Tree/NewArray.g.cs b/Rewrite/src/Rewrite.Java/Tree/NewArray.g.cs index c21e4b33..44c69f6c 100644 --- a/Rewrite/src/Rewrite.Java/Tree/NewArray.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/NewArray.g.cs @@ -66,56 +66,56 @@ public PaddingHelper Padding return v.VisitNewArray(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public NewArray WithId(Guid newId) { - return newId == id ? this : new NewArray(newId, prefix, markers, typeExpression, dimensions, _initializer, type); + return newId == Id ? this : new NewArray(newId, Prefix, Markers, TypeExpression, Dimensions, _initializer, Type); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public NewArray WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new NewArray(id, newPrefix, markers, typeExpression, dimensions, _initializer, type); + return newPrefix == Prefix ? this : new NewArray(Id, newPrefix, Markers, TypeExpression, Dimensions, _initializer, Type); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public NewArray WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new NewArray(id, prefix, newMarkers, typeExpression, dimensions, _initializer, type); + return ReferenceEquals(newMarkers, Markers) ? this : new NewArray(Id, Prefix, newMarkers, TypeExpression, Dimensions, _initializer, Type); } - public TypeTree? TypeExpression => typeExpression; + public TypeTree? TypeExpression { get; set; } = typeExpression; public NewArray WithTypeExpression(TypeTree? newTypeExpression) { - return ReferenceEquals(newTypeExpression, typeExpression) ? this : new NewArray(id, prefix, markers, newTypeExpression, dimensions, _initializer, type); + return ReferenceEquals(newTypeExpression, TypeExpression) ? this : new NewArray(Id, Prefix, Markers, newTypeExpression, Dimensions, _initializer, Type); } - public IList Dimensions => dimensions; + public IList Dimensions { get; set; } = dimensions; public NewArray WithDimensions(IList newDimensions) { - return newDimensions == dimensions ? this : new NewArray(id, prefix, markers, typeExpression, newDimensions, _initializer, type); + return newDimensions == Dimensions ? this : new NewArray(Id, Prefix, Markers, TypeExpression, newDimensions, _initializer, Type); } - private readonly JContainer? _initializer = initializer; + private JContainer? _initializer = initializer; public IList? Initializer => _initializer?.GetElements(); public NewArray WithInitializer(IList? newInitializer) { return Padding.WithInitializer(JContainer.WithElementsNullable(_initializer, newInitializer)); } - public JavaType? Type => type; + public JavaType? Type { get; set; } = type; public NewArray WithType(JavaType? newType) { - return newType == type ? this : new NewArray(id, prefix, markers, typeExpression, dimensions, _initializer, newType); + return newType == Type ? this : new NewArray(Id, Prefix, Markers, TypeExpression, Dimensions, _initializer, newType); } public sealed record PaddingHelper(J.NewArray T) { - public JContainer? Initializer => T._initializer; + public JContainer? Initializer { get => T._initializer; set => T._initializer = value; } public J.NewArray WithInitializer(JContainer? newInitializer) { - return T._initializer == newInitializer ? T : new J.NewArray(T.Id, T.Prefix, T.Markers, T.TypeExpression, T.Dimensions, newInitializer, T.Type); + return Initializer == newInitializer ? T : new J.NewArray(T.Id, T.Prefix, T.Markers, T.TypeExpression, T.Dimensions, newInitializer, T.Type); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/NewClass.cs b/Rewrite/src/Rewrite.Java/Tree/NewClass.cs index 0193f6e4..5733f701 100644 --- a/Rewrite/src/Rewrite.Java/Tree/NewClass.cs +++ b/Rewrite/src/Rewrite.Java/Tree/NewClass.cs @@ -10,7 +10,7 @@ partial class NewClass public NewClass WithType(JavaType? type) { if (type == Clazz?.Type) return this; - return new NewClass(Id, prefix, markers, _enclosing, @new, clazz?.WithType(type), _arguments, body, constructorType); + return new NewClass(Id, Prefix, Markers, _enclosing, New, Clazz?.WithType(type), _arguments, Body, ConstructorType); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/NewClass.g.cs b/Rewrite/src/Rewrite.Java/Tree/NewClass.g.cs index 18f4416e..23a71eda 100644 --- a/Rewrite/src/Rewrite.Java/Tree/NewClass.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/NewClass.g.cs @@ -68,76 +68,76 @@ public PaddingHelper Padding return v.VisitNewClass(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public NewClass WithId(Guid newId) { - return newId == id ? this : new NewClass(newId, prefix, markers, _enclosing, @new, clazz, _arguments, body, constructorType); + return newId == Id ? this : new NewClass(newId, Prefix, Markers, _enclosing, New, Clazz, _arguments, Body, ConstructorType); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public NewClass WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new NewClass(id, newPrefix, markers, _enclosing, @new, clazz, _arguments, body, constructorType); + return newPrefix == Prefix ? this : new NewClass(Id, newPrefix, Markers, _enclosing, New, Clazz, _arguments, Body, ConstructorType); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public NewClass WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new NewClass(id, prefix, newMarkers, _enclosing, @new, clazz, _arguments, body, constructorType); + return ReferenceEquals(newMarkers, Markers) ? this : new NewClass(Id, Prefix, newMarkers, _enclosing, New, Clazz, _arguments, Body, ConstructorType); } - private readonly JRightPadded? _enclosing = enclosing; + private JRightPadded? _enclosing = enclosing; public Expression? Enclosing => _enclosing?.Element; public NewClass WithEnclosing(Expression? newEnclosing) { return Padding.WithEnclosing(JRightPadded.WithElement(_enclosing, newEnclosing)); } - public Space New => @new; + public Space New { get; set; } = @new; public NewClass WithNew(Space newNew) { - return newNew == @new ? this : new NewClass(id, prefix, markers, _enclosing, newNew, clazz, _arguments, body, constructorType); + return newNew == New ? this : new NewClass(Id, Prefix, Markers, _enclosing, newNew, Clazz, _arguments, Body, ConstructorType); } - public TypeTree? Clazz => clazz; + public TypeTree? Clazz { get; set; } = clazz; public NewClass WithClazz(TypeTree? newClazz) { - return ReferenceEquals(newClazz, clazz) ? this : new NewClass(id, prefix, markers, _enclosing, @new, newClazz, _arguments, body, constructorType); + return ReferenceEquals(newClazz, Clazz) ? this : new NewClass(Id, Prefix, Markers, _enclosing, New, newClazz, _arguments, Body, ConstructorType); } - private readonly JContainer _arguments = arguments; + private JContainer _arguments = arguments; public IList Arguments => _arguments.GetElements(); public NewClass WithArguments(IList newArguments) { return Padding.WithArguments(JContainer.WithElements(_arguments, newArguments)); } - public J.Block? Body => body; + public J.Block? Body { get; set; } = body; public NewClass WithBody(J.Block? newBody) { - return ReferenceEquals(newBody, body) ? this : new NewClass(id, prefix, markers, _enclosing, @new, clazz, _arguments, newBody, constructorType); + return ReferenceEquals(newBody, Body) ? this : new NewClass(Id, Prefix, Markers, _enclosing, New, Clazz, _arguments, newBody, ConstructorType); } - public JavaType.Method? ConstructorType => constructorType; + public JavaType.Method? ConstructorType { get; set; } = constructorType; public NewClass WithConstructorType(JavaType.Method? newConstructorType) { - return newConstructorType == constructorType ? this : new NewClass(id, prefix, markers, _enclosing, @new, clazz, _arguments, body, newConstructorType); + return newConstructorType == ConstructorType ? this : new NewClass(Id, Prefix, Markers, _enclosing, New, Clazz, _arguments, Body, newConstructorType); } public sealed record PaddingHelper(J.NewClass T) { - public JRightPadded? Enclosing => T._enclosing; + public JRightPadded? Enclosing { get => T._enclosing; set => T._enclosing = value; } public J.NewClass WithEnclosing(JRightPadded? newEnclosing) { - return T._enclosing == newEnclosing ? T : new J.NewClass(T.Id, T.Prefix, T.Markers, newEnclosing, T.New, T.Clazz, T._arguments, T.Body, T.ConstructorType); + return Enclosing == newEnclosing ? T : new J.NewClass(T.Id, T.Prefix, T.Markers, newEnclosing, T.New, T.Clazz, T._arguments, T.Body, T.ConstructorType); } - public JContainer Arguments => T._arguments; + public JContainer Arguments { get => T._arguments; set => T._arguments = value; } public J.NewClass WithArguments(JContainer newArguments) { - return T._arguments == newArguments ? T : new J.NewClass(T.Id, T.Prefix, T.Markers, T._enclosing, T.New, T.Clazz, newArguments, T.Body, T.ConstructorType); + return Arguments == newArguments ? T : new J.NewClass(T.Id, T.Prefix, T.Markers, T._enclosing, T.New, T.Clazz, newArguments, T.Body, T.ConstructorType); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/NullableType.g.cs b/Rewrite/src/Rewrite.Java/Tree/NullableType.g.cs index 3983ec92..6d2f97d3 100644 --- a/Rewrite/src/Rewrite.Java/Tree/NullableType.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/NullableType.g.cs @@ -64,31 +64,31 @@ public PaddingHelper Padding return v.VisitNullableType(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public NullableType WithId(Guid newId) { - return newId == id ? this : new NullableType(newId, prefix, markers, annotations, _typeTree); + return newId == Id ? this : new NullableType(newId, Prefix, Markers, Annotations, _typeTree); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public NullableType WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new NullableType(id, newPrefix, markers, annotations, _typeTree); + return newPrefix == Prefix ? this : new NullableType(Id, newPrefix, Markers, Annotations, _typeTree); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public NullableType WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new NullableType(id, prefix, newMarkers, annotations, _typeTree); + return ReferenceEquals(newMarkers, Markers) ? this : new NullableType(Id, Prefix, newMarkers, Annotations, _typeTree); } - public IList Annotations => annotations; + public IList Annotations { get; set; } = annotations; public NullableType WithAnnotations(IList newAnnotations) { - return newAnnotations == annotations ? this : new NullableType(id, prefix, markers, newAnnotations, _typeTree); + return newAnnotations == Annotations ? this : new NullableType(Id, Prefix, Markers, newAnnotations, _typeTree); } - private readonly JRightPadded _typeTree = typeTree; + private JRightPadded _typeTree = typeTree; public TypeTree TypeTree => _typeTree.Element; public NullableType WithTypeTree(TypeTree newTypeTree) @@ -97,11 +97,11 @@ public NullableType WithTypeTree(TypeTree newTypeTree) } public sealed record PaddingHelper(J.NullableType T) { - public JRightPadded TypeTree => T._typeTree; + public JRightPadded TypeTree { get => T._typeTree; set => T._typeTree = value; } public J.NullableType WithTypeTree(JRightPadded newTypeTree) { - return T._typeTree == newTypeTree ? T : new J.NullableType(T.Id, T.Prefix, T.Markers, T.Annotations, newTypeTree); + return TypeTree == newTypeTree ? T : new J.NullableType(T.Id, T.Prefix, T.Markers, T.Annotations, newTypeTree); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/Package.g.cs b/Rewrite/src/Rewrite.Java/Tree/Package.g.cs index 559592cc..91886a10 100644 --- a/Rewrite/src/Rewrite.Java/Tree/Package.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/Package.g.cs @@ -39,35 +39,35 @@ IList annotations return v.VisitPackage(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Package WithId(Guid newId) { - return newId == id ? this : new Package(newId, prefix, markers, expression, annotations); + return newId == Id ? this : new Package(newId, Prefix, Markers, Expression, Annotations); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Package WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Package(id, newPrefix, markers, expression, annotations); + return newPrefix == Prefix ? this : new Package(Id, newPrefix, Markers, Expression, Annotations); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Package WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Package(id, prefix, newMarkers, expression, annotations); + return ReferenceEquals(newMarkers, Markers) ? this : new Package(Id, Prefix, newMarkers, Expression, Annotations); } - public Expression Expression => expression; + public Expression Expression { get; set; } = expression; public Package WithExpression(Expression newExpression) { - return ReferenceEquals(newExpression, expression) ? this : new Package(id, prefix, markers, newExpression, annotations); + return ReferenceEquals(newExpression, Expression) ? this : new Package(Id, Prefix, Markers, newExpression, Annotations); } - public IList Annotations => annotations; + public IList Annotations { get; set; } = annotations; public Package WithAnnotations(IList newAnnotations) { - return newAnnotations == annotations ? this : new Package(id, prefix, markers, expression, newAnnotations); + return newAnnotations == Annotations ? this : new Package(Id, Prefix, Markers, Expression, newAnnotations); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.Java/Tree/ParameterizedType.g.cs b/Rewrite/src/Rewrite.Java/Tree/ParameterizedType.g.cs index ad101519..73502d52 100644 --- a/Rewrite/src/Rewrite.Java/Tree/ParameterizedType.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/ParameterizedType.g.cs @@ -65,50 +65,50 @@ public PaddingHelper Padding return v.VisitParameterizedType(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public ParameterizedType WithId(Guid newId) { - return newId == id ? this : new ParameterizedType(newId, prefix, markers, clazz, _typeParameters, type); + return newId == Id ? this : new ParameterizedType(newId, Prefix, Markers, Clazz, _typeParameters, Type); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public ParameterizedType WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new ParameterizedType(id, newPrefix, markers, clazz, _typeParameters, type); + return newPrefix == Prefix ? this : new ParameterizedType(Id, newPrefix, Markers, Clazz, _typeParameters, Type); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public ParameterizedType WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new ParameterizedType(id, prefix, newMarkers, clazz, _typeParameters, type); + return ReferenceEquals(newMarkers, Markers) ? this : new ParameterizedType(Id, Prefix, newMarkers, Clazz, _typeParameters, Type); } - public NameTree Clazz => clazz; + public NameTree Clazz { get; set; } = clazz; public ParameterizedType WithClazz(NameTree newClazz) { - return ReferenceEquals(newClazz, clazz) ? this : new ParameterizedType(id, prefix, markers, newClazz, _typeParameters, type); + return ReferenceEquals(newClazz, Clazz) ? this : new ParameterizedType(Id, Prefix, Markers, newClazz, _typeParameters, Type); } - private readonly JContainer? _typeParameters = typeParameters; + private JContainer? _typeParameters = typeParameters; public IList? TypeParameters => _typeParameters?.GetElements(); public ParameterizedType WithTypeParameters(IList? newTypeParameters) { return Padding.WithTypeParameters(JContainer.WithElementsNullable(_typeParameters, newTypeParameters)); } - public JavaType? Type => type; + public JavaType? Type { get; set; } = type; public ParameterizedType WithType(JavaType? newType) { - return newType == type ? this : new ParameterizedType(id, prefix, markers, clazz, _typeParameters, newType); + return newType == Type ? this : new ParameterizedType(Id, Prefix, Markers, Clazz, _typeParameters, newType); } public sealed record PaddingHelper(J.ParameterizedType T) { - public JContainer? TypeParameters => T._typeParameters; + public JContainer? TypeParameters { get => T._typeParameters; set => T._typeParameters = value; } public J.ParameterizedType WithTypeParameters(JContainer? newTypeParameters) { - return T._typeParameters == newTypeParameters ? T : new J.ParameterizedType(T.Id, T.Prefix, T.Markers, T.Clazz, newTypeParameters, T.Type); + return TypeParameters == newTypeParameters ? T : new J.ParameterizedType(T.Id, T.Prefix, T.Markers, T.Clazz, newTypeParameters, T.Type); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/Parentheses.g.cs b/Rewrite/src/Rewrite.Java/Tree/Parentheses.g.cs index 46092333..ae88c8ec 100644 --- a/Rewrite/src/Rewrite.Java/Tree/Parentheses.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/Parentheses.g.cs @@ -63,25 +63,25 @@ public PaddingHelper Padding return v.VisitParentheses(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public J.Parentheses WithId(Guid newId) { - return newId == id ? this : new J.Parentheses(newId, prefix, markers, _tree); + return newId == Id ? this : new J.Parentheses(newId, Prefix, Markers, _tree); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public J.Parentheses WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new J.Parentheses(id, newPrefix, markers, _tree); + return newPrefix == Prefix ? this : new J.Parentheses(Id, newPrefix, Markers, _tree); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public J.Parentheses WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new J.Parentheses(id, prefix, newMarkers, _tree); + return ReferenceEquals(newMarkers, Markers) ? this : new J.Parentheses(Id, Prefix, newMarkers, _tree); } - private readonly JRightPadded _tree = tree; + private JRightPadded _tree = tree; public J2 Tree => _tree.Element; public J.Parentheses WithTree(J2 newTree) @@ -90,11 +90,11 @@ public J.Parentheses WithTree(J2 newTree) } public sealed record PaddingHelper(J.Parentheses T) { - public JRightPadded Tree => T._tree; + public JRightPadded Tree { get => T._tree; set => T._tree = value; } public J.Parentheses WithTree(JRightPadded newTree) { - return T._tree == newTree ? T : new J.Parentheses(T.Id, T.Prefix, T.Markers, newTree); + return Tree == newTree ? T : new J.Parentheses(T.Id, T.Prefix, T.Markers, newTree); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/ParenthesizedTypeTree.g.cs b/Rewrite/src/Rewrite.Java/Tree/ParenthesizedTypeTree.g.cs index abd2d8c3..d53e683b 100644 --- a/Rewrite/src/Rewrite.Java/Tree/ParenthesizedTypeTree.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/ParenthesizedTypeTree.g.cs @@ -43,35 +43,35 @@ J.Parentheses parenthesizedType return v.VisitParenthesizedTypeTree(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public ParenthesizedTypeTree WithId(Guid newId) { - return newId == id ? this : new ParenthesizedTypeTree(newId, prefix, markers, annotations, parenthesizedType); + return newId == Id ? this : new ParenthesizedTypeTree(newId, Prefix, Markers, Annotations, ParenthesizedType); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public ParenthesizedTypeTree WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new ParenthesizedTypeTree(id, newPrefix, markers, annotations, parenthesizedType); + return newPrefix == Prefix ? this : new ParenthesizedTypeTree(Id, newPrefix, Markers, Annotations, ParenthesizedType); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public ParenthesizedTypeTree WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new ParenthesizedTypeTree(id, prefix, newMarkers, annotations, parenthesizedType); + return ReferenceEquals(newMarkers, Markers) ? this : new ParenthesizedTypeTree(Id, Prefix, newMarkers, Annotations, ParenthesizedType); } - public IList Annotations => annotations; + public IList Annotations { get; set; } = annotations; public ParenthesizedTypeTree WithAnnotations(IList newAnnotations) { - return newAnnotations == annotations ? this : new ParenthesizedTypeTree(id, prefix, markers, newAnnotations, parenthesizedType); + return newAnnotations == Annotations ? this : new ParenthesizedTypeTree(Id, Prefix, Markers, newAnnotations, ParenthesizedType); } - public J.Parentheses ParenthesizedType => parenthesizedType; + public J.Parentheses ParenthesizedType { get; set; } = parenthesizedType; public ParenthesizedTypeTree WithParenthesizedType(J.Parentheses newParenthesizedType) { - return ReferenceEquals(newParenthesizedType, parenthesizedType) ? this : new ParenthesizedTypeTree(id, prefix, markers, annotations, newParenthesizedType); + return ReferenceEquals(newParenthesizedType, ParenthesizedType) ? this : new ParenthesizedTypeTree(Id, Prefix, Markers, Annotations, newParenthesizedType); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.Java/Tree/Primitive.g.cs b/Rewrite/src/Rewrite.Java/Tree/Primitive.g.cs index 98462965..2918c596 100644 --- a/Rewrite/src/Rewrite.Java/Tree/Primitive.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/Primitive.g.cs @@ -38,29 +38,29 @@ JavaType.Primitive type return v.VisitPrimitive(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Primitive WithId(Guid newId) { - return newId == id ? this : new Primitive(newId, prefix, markers, type); + return newId == Id ? this : new Primitive(newId, Prefix, Markers, Type); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Primitive WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Primitive(id, newPrefix, markers, type); + return newPrefix == Prefix ? this : new Primitive(Id, newPrefix, Markers, Type); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Primitive WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Primitive(id, prefix, newMarkers, type); + return ReferenceEquals(newMarkers, Markers) ? this : new Primitive(Id, Prefix, newMarkers, Type); } - public JavaType.Primitive Type => type; + public JavaType.Primitive Type { get; set; } = type; public Primitive WithType(JavaType.Primitive newType) { - return newType == type ? this : new Primitive(id, prefix, markers, newType); + return newType == Type ? this : new Primitive(Id, Prefix, Markers, newType); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.Java/Tree/Return.g.cs b/Rewrite/src/Rewrite.Java/Tree/Return.g.cs index ddf7c5d7..aa5ce188 100644 --- a/Rewrite/src/Rewrite.Java/Tree/Return.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/Return.g.cs @@ -38,29 +38,29 @@ public partial class Return( return v.VisitReturn(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Return WithId(Guid newId) { - return newId == id ? this : new Return(newId, prefix, markers, expression); + return newId == Id ? this : new Return(newId, Prefix, Markers, Expression); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Return WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Return(id, newPrefix, markers, expression); + return newPrefix == Prefix ? this : new Return(Id, newPrefix, Markers, Expression); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Return WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Return(id, prefix, newMarkers, expression); + return ReferenceEquals(newMarkers, Markers) ? this : new Return(Id, Prefix, newMarkers, Expression); } - public Expression? Expression => expression; + public Expression? Expression { get; set; } = expression; public Return WithExpression(Expression? newExpression) { - return ReferenceEquals(newExpression, expression) ? this : new Return(id, prefix, markers, newExpression); + return ReferenceEquals(newExpression, Expression) ? this : new Return(Id, Prefix, Markers, newExpression); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.Java/Tree/Space.cs b/Rewrite/src/Rewrite.Java/Tree/Space.cs index 908cabf3..042b272b 100644 --- a/Rewrite/src/Rewrite.Java/Tree/Space.cs +++ b/Rewrite/src/Rewrite.Java/Tree/Space.cs @@ -1,6 +1,7 @@ using System.Diagnostics; using System.Diagnostics.CodeAnalysis; using System.Text; +using Microsoft.CodeAnalysis.Text; using Rewrite.Core; using Rewrite.Core.Marker; @@ -15,17 +16,58 @@ namespace Rewrite.RewriteJava.Tree; #if DEBUG_VISITOR [DebuggerStepThrough] #endif -public class Space( - IList comments, - string? whitespace -) +public class Space : IEquatable { + private readonly Lazy _hashCode; + private readonly IList _comments; + + private readonly string _whitespace; + + public bool Equals(Space? other) + { + return Equals(this, other); + } + + public static bool Equals(Space? v1, Space? v2) + { + if (ReferenceEquals(v1, v2)) return true; + if (v1 is null && v2 is null) return false; + if(v1 is null || v2 is not null) return false; + if(v1 is not null || v2 is null) return false; + + return v1!.Comments.SequenceEqual(v2.Comments) && v1.Whitespace == v2.Whitespace; + } + + public static bool operator ==(Space? v1, Space? v2) => Equals(v1, v2); + + public static bool operator !=(Space? v1, Space? v2) => !(v1 == v2); + + + public Space(IList comments, string? whitespace) + { + _comments = comments; + _whitespace = whitespace ?? ""; + _hashCode = new(() => + { + var hashCode = _whitespace.GetHashCode(); + foreach (var comment in _comments) + { + HashCode.Combine(hashCode, comment.GetHashCode()); + } + + return hashCode; + }); + } + + public static readonly Space EMPTY = new([], ""); + public static readonly Space SINGLE_SPACE = new([], " "); - public IList Comments => comments; + public IList Comments => _comments; + + public string Whitespace => _whitespace; - public string? Whitespace => whitespace; public bool IsEmpty => this == EMPTY; public Space WithComments(IList? newComments) @@ -119,8 +161,7 @@ public static Space Format(string formatting, int beginIndex, int toIndex) { inMultiLineComment = false; comment.Length -= 1; - comments.Add(new TextComment(true, comment.ToString(), prefix.ToString(0, prefix.Length - 1), - Markers.EMPTY)); + comments.Add(new TextComment(true, comment.ToString(), prefix.ToString(0, prefix.Length - 1), Markers.EMPTY)); prefix.Length = 0; comment.Length = 0; continue; @@ -208,14 +249,14 @@ public static Space Format(string formatting, int beginIndex, int toIndex) return Build(whitespace, comments); } - public override string? ToString() + public override string ToString() { StringBuilder p = new(); p.Append(Whitespace); - for (int i = 0; i < comments.Count; ++i) + for (int i = 0; i < _comments.Count; ++i) { - var comment = comments[i]; + var comment = _comments[i]; var text = ((TextComment)comment).Text; p.Append(comment.Multiline ? $"/*{text}*/" : $"//{text}"); p.Append(comment.Suffix); @@ -393,4 +434,14 @@ private static void RangeCheck(int arrayLength, int fromIndex, int toIndex) ArgumentOutOfRangeException.ThrowIfNegative(fromIndex); ArgumentOutOfRangeException.ThrowIfGreaterThan(toIndex, arrayLength); } + + public override bool Equals(object? obj) + { + if (obj is null) return false; + if (ReferenceEquals(this, obj)) return true; + if (obj.GetType() != GetType()) return false; + return Equals((Space)obj); + } + + public override int GetHashCode() => _hashCode.Value; } diff --git a/Rewrite/src/Rewrite.Java/Tree/Statement.cs b/Rewrite/src/Rewrite.Java/Tree/Statement.cs index b0715be3..12191ebe 100644 --- a/Rewrite/src/Rewrite.Java/Tree/Statement.cs +++ b/Rewrite/src/Rewrite.Java/Tree/Statement.cs @@ -7,6 +7,6 @@ namespace Rewrite.RewriteJava.Tree; [SuppressMessage("ReSharper", "InconsistentNaming")] [SuppressMessage("ReSharper", "PossibleUnintendedReferenceComparison")] -public interface Statement : J +public partial interface Statement : J { } diff --git a/Rewrite/src/Rewrite.Java/Tree/Switch.g.cs b/Rewrite/src/Rewrite.Java/Tree/Switch.g.cs index 7b964e4d..1477c63c 100644 --- a/Rewrite/src/Rewrite.Java/Tree/Switch.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/Switch.g.cs @@ -39,35 +39,35 @@ Block cases return v.VisitSwitch(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Switch WithId(Guid newId) { - return newId == id ? this : new Switch(newId, prefix, markers, selector, cases); + return newId == Id ? this : new Switch(newId, Prefix, Markers, Selector, Cases); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Switch WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Switch(id, newPrefix, markers, selector, cases); + return newPrefix == Prefix ? this : new Switch(Id, newPrefix, Markers, Selector, Cases); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Switch WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Switch(id, prefix, newMarkers, selector, cases); + return ReferenceEquals(newMarkers, Markers) ? this : new Switch(Id, Prefix, newMarkers, Selector, Cases); } - public J.ControlParentheses Selector => selector; + public J.ControlParentheses Selector { get; set; } = selector; public Switch WithSelector(J.ControlParentheses newSelector) { - return ReferenceEquals(newSelector, selector) ? this : new Switch(id, prefix, markers, newSelector, cases); + return ReferenceEquals(newSelector, Selector) ? this : new Switch(Id, Prefix, Markers, newSelector, Cases); } - public J.Block Cases => cases; + public J.Block Cases { get; set; } = cases; public Switch WithCases(J.Block newCases) { - return ReferenceEquals(newCases, cases) ? this : new Switch(id, prefix, markers, selector, newCases); + return ReferenceEquals(newCases, Cases) ? this : new Switch(Id, Prefix, Markers, Selector, newCases); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.Java/Tree/SwitchExpression.g.cs b/Rewrite/src/Rewrite.Java/Tree/SwitchExpression.g.cs index 752f228b..f2536c90 100644 --- a/Rewrite/src/Rewrite.Java/Tree/SwitchExpression.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/SwitchExpression.g.cs @@ -40,41 +40,41 @@ public partial class SwitchExpression( return v.VisitSwitchExpression(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public SwitchExpression WithId(Guid newId) { - return newId == id ? this : new SwitchExpression(newId, prefix, markers, selector, cases, type); + return newId == Id ? this : new SwitchExpression(newId, Prefix, Markers, Selector, Cases, Type); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public SwitchExpression WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new SwitchExpression(id, newPrefix, markers, selector, cases, type); + return newPrefix == Prefix ? this : new SwitchExpression(Id, newPrefix, Markers, Selector, Cases, Type); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public SwitchExpression WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new SwitchExpression(id, prefix, newMarkers, selector, cases, type); + return ReferenceEquals(newMarkers, Markers) ? this : new SwitchExpression(Id, Prefix, newMarkers, Selector, Cases, Type); } - public J.ControlParentheses Selector => selector; + public J.ControlParentheses Selector { get; set; } = selector; public SwitchExpression WithSelector(J.ControlParentheses newSelector) { - return ReferenceEquals(newSelector, selector) ? this : new SwitchExpression(id, prefix, markers, newSelector, cases, type); + return ReferenceEquals(newSelector, Selector) ? this : new SwitchExpression(Id, Prefix, Markers, newSelector, Cases, Type); } - public J.Block Cases => cases; + public J.Block Cases { get; set; } = cases; public SwitchExpression WithCases(J.Block newCases) { - return ReferenceEquals(newCases, cases) ? this : new SwitchExpression(id, prefix, markers, selector, newCases, type); + return ReferenceEquals(newCases, Cases) ? this : new SwitchExpression(Id, Prefix, Markers, Selector, newCases, Type); } - public JavaType? Type => type; + public JavaType? Type { get; set; } = type; public SwitchExpression WithType(JavaType? newType) { - return newType == type ? this : new SwitchExpression(id, prefix, markers, selector, cases, newType); + return newType == Type ? this : new SwitchExpression(Id, Prefix, Markers, Selector, Cases, newType); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.Java/Tree/Synchronized.g.cs b/Rewrite/src/Rewrite.Java/Tree/Synchronized.g.cs index c9958ed8..ee13ec1d 100644 --- a/Rewrite/src/Rewrite.Java/Tree/Synchronized.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/Synchronized.g.cs @@ -39,35 +39,35 @@ Block body return v.VisitSynchronized(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Synchronized WithId(Guid newId) { - return newId == id ? this : new Synchronized(newId, prefix, markers, @lock, body); + return newId == Id ? this : new Synchronized(newId, Prefix, Markers, Lock, Body); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Synchronized WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Synchronized(id, newPrefix, markers, @lock, body); + return newPrefix == Prefix ? this : new Synchronized(Id, newPrefix, Markers, Lock, Body); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Synchronized WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Synchronized(id, prefix, newMarkers, @lock, body); + return ReferenceEquals(newMarkers, Markers) ? this : new Synchronized(Id, Prefix, newMarkers, Lock, Body); } - public J.ControlParentheses Lock => @lock; + public J.ControlParentheses Lock { get; set; } = @lock; public Synchronized WithLock(J.ControlParentheses newLock) { - return ReferenceEquals(newLock, @lock) ? this : new Synchronized(id, prefix, markers, newLock, body); + return ReferenceEquals(newLock, Lock) ? this : new Synchronized(Id, Prefix, Markers, newLock, Body); } - public J.Block Body => body; + public J.Block Body { get; set; } = body; public Synchronized WithBody(J.Block newBody) { - return ReferenceEquals(newBody, body) ? this : new Synchronized(id, prefix, markers, @lock, newBody); + return ReferenceEquals(newBody, Body) ? this : new Synchronized(Id, Prefix, Markers, Lock, newBody); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.Java/Tree/Ternary.g.cs b/Rewrite/src/Rewrite.Java/Tree/Ternary.g.cs index 361c6170..39ccaf95 100644 --- a/Rewrite/src/Rewrite.Java/Tree/Ternary.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/Ternary.g.cs @@ -66,64 +66,64 @@ public PaddingHelper Padding return v.VisitTernary(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Ternary WithId(Guid newId) { - return newId == id ? this : new Ternary(newId, prefix, markers, condition, _truePart, _falsePart, type); + return newId == Id ? this : new Ternary(newId, Prefix, Markers, Condition, _truePart, _falsePart, Type); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Ternary WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Ternary(id, newPrefix, markers, condition, _truePart, _falsePart, type); + return newPrefix == Prefix ? this : new Ternary(Id, newPrefix, Markers, Condition, _truePart, _falsePart, Type); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Ternary WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Ternary(id, prefix, newMarkers, condition, _truePart, _falsePart, type); + return ReferenceEquals(newMarkers, Markers) ? this : new Ternary(Id, Prefix, newMarkers, Condition, _truePart, _falsePart, Type); } - public Expression Condition => condition; + public Expression Condition { get; set; } = condition; public Ternary WithCondition(Expression newCondition) { - return ReferenceEquals(newCondition, condition) ? this : new Ternary(id, prefix, markers, newCondition, _truePart, _falsePart, type); + return ReferenceEquals(newCondition, Condition) ? this : new Ternary(Id, Prefix, Markers, newCondition, _truePart, _falsePart, Type); } - private readonly JLeftPadded _truePart = truePart; + private JLeftPadded _truePart = truePart; public Expression TruePart => _truePart.Element; public Ternary WithTruePart(Expression newTruePart) { return Padding.WithTruePart(_truePart.WithElement(newTruePart)); } - private readonly JLeftPadded _falsePart = falsePart; + private JLeftPadded _falsePart = falsePart; public Expression FalsePart => _falsePart.Element; public Ternary WithFalsePart(Expression newFalsePart) { return Padding.WithFalsePart(_falsePart.WithElement(newFalsePart)); } - public JavaType? Type => type; + public JavaType? Type { get; set; } = type; public Ternary WithType(JavaType? newType) { - return newType == type ? this : new Ternary(id, prefix, markers, condition, _truePart, _falsePart, newType); + return newType == Type ? this : new Ternary(Id, Prefix, Markers, Condition, _truePart, _falsePart, newType); } public sealed record PaddingHelper(J.Ternary T) { - public JLeftPadded TruePart => T._truePart; + public JLeftPadded TruePart { get => T._truePart; set => T._truePart = value; } public J.Ternary WithTruePart(JLeftPadded newTruePart) { - return T._truePart == newTruePart ? T : new J.Ternary(T.Id, T.Prefix, T.Markers, T.Condition, newTruePart, T._falsePart, T.Type); + return TruePart == newTruePart ? T : new J.Ternary(T.Id, T.Prefix, T.Markers, T.Condition, newTruePart, T._falsePart, T.Type); } - public JLeftPadded FalsePart => T._falsePart; + public JLeftPadded FalsePart { get => T._falsePart; set => T._falsePart = value; } public J.Ternary WithFalsePart(JLeftPadded newFalsePart) { - return T._falsePart == newFalsePart ? T : new J.Ternary(T.Id, T.Prefix, T.Markers, T.Condition, T._truePart, newFalsePart, T.Type); + return FalsePart == newFalsePart ? T : new J.Ternary(T.Id, T.Prefix, T.Markers, T.Condition, T._truePart, newFalsePart, T.Type); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/TextComment.cs b/Rewrite/src/Rewrite.Java/Tree/TextComment.cs index f9059f5e..f803195e 100644 --- a/Rewrite/src/Rewrite.Java/Tree/TextComment.cs +++ b/Rewrite/src/Rewrite.Java/Tree/TextComment.cs @@ -12,38 +12,51 @@ namespace Rewrite.RewriteJava.Tree; [SuppressMessage("ReSharper", "UnusedMember.Global")] [SuppressMessage("ReSharper", "RedundantNameQualifier")] [DebuggerStepThrough] -public sealed class TextComment( - bool multiline, - string text, - string suffix, - Markers markers -) : Comment +public sealed class TextComment : Comment { - public bool Multiline => multiline; + private readonly Lazy _hashCode; + private readonly bool _multiline; + private readonly string _text; + private readonly string _suffix; + private readonly Markers _markers; + + public TextComment(bool multiline, + string text, + string suffix, + Markers markers) + { + _multiline = multiline; + _text = text; + _suffix = suffix; + _markers = markers; + _hashCode = new(() => HashCode.Combine(_multiline, _text, _suffix, _markers)); + } + + public bool Multiline => _multiline; public TextComment WithMultiline(bool newMultiline) { - return newMultiline == multiline ? this : new TextComment(newMultiline, text, suffix, markers); + return newMultiline == _multiline ? this : new TextComment(newMultiline, _text, _suffix, _markers); } - public string Text => text; + public string Text => _text; - public string Suffix => suffix; + public string Suffix => _suffix; - public Markers Markers => markers; + public Markers Markers => _markers; private static readonly Func MARKER_WRAPPER = o => "/*~~" + o + (o.Length == 0 ? "" : "~~") + ">*/"; public void PrintComment

(Cursor cursor, PrintOutputCapture

p) { - foreach (var marker in markers.MarkerList) + foreach (var marker in _markers.MarkerList) { p.Append(p.MarkerPrinter.BeforeSyntax(marker, new Cursor(cursor, this), MARKER_WRAPPER)); } - p.Append(multiline ? $"/*{text}*/" : $"//{text}"); - foreach (var marker in markers.MarkerList) + p.Append(_multiline ? $"/*{_text}*/" : $"//{_text}"); + foreach (var marker in _markers.MarkerList) { p.Append(p.MarkerPrinter.AfterSyntax(marker, new Cursor(cursor, this), MARKER_WRAPPER)); } @@ -51,18 +64,29 @@ public void PrintComment

(Cursor cursor, PrintOutputCapture

p) public TextComment WithSuffix(string newSuffix) { - return newSuffix == Suffix ? this : new TextComment(multiline, text, newSuffix, Markers); + return newSuffix == Suffix ? this : new TextComment(_multiline, _text, newSuffix, Markers); } Comment Comment.WithSuffix(string newSuffix) => WithSuffix(newSuffix); public TextComment WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new TextComment(multiline, text, suffix, newMarkers); + return ReferenceEquals(newMarkers, _markers) ? this : new TextComment(_multiline, _text, _suffix, newMarkers); } public TextComment WithText(string newText) { - return newText == Text ? this : new TextComment(Multiline, newText, suffix, markers); + return newText == Text ? this : new TextComment(Multiline, newText, _suffix, _markers); + } + + public bool Equals(TextComment? other) + { + if (ReferenceEquals(null, other)) return false; + return Markers.Id == other.Markers.Id && this.Multiline == other.Multiline && this.Suffix == other.Suffix && this.Text == other.Text; + } + + bool IEquatable.Equals(Comment? other) + { + return other is TextComment textComment && Equals(textComment); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/Throw.g.cs b/Rewrite/src/Rewrite.Java/Tree/Throw.g.cs index 4ef2098c..c56cb8a1 100644 --- a/Rewrite/src/Rewrite.Java/Tree/Throw.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/Throw.g.cs @@ -38,29 +38,29 @@ Expression exception return v.VisitThrow(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Throw WithId(Guid newId) { - return newId == id ? this : new Throw(newId, prefix, markers, exception); + return newId == Id ? this : new Throw(newId, Prefix, Markers, Exception); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Throw WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Throw(id, newPrefix, markers, exception); + return newPrefix == Prefix ? this : new Throw(Id, newPrefix, Markers, Exception); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Throw WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Throw(id, prefix, newMarkers, exception); + return ReferenceEquals(newMarkers, Markers) ? this : new Throw(Id, Prefix, newMarkers, Exception); } - public Expression Exception => exception; + public Expression Exception { get; set; } = exception; public Throw WithException(Expression newException) { - return ReferenceEquals(newException, exception) ? this : new Throw(id, prefix, markers, newException); + return ReferenceEquals(newException, Exception) ? this : new Throw(Id, Prefix, Markers, newException); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.Java/Tree/Try.g.cs b/Rewrite/src/Rewrite.Java/Tree/Try.g.cs index 1c3c1351..e4570d4c 100644 --- a/Rewrite/src/Rewrite.Java/Tree/Try.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/Try.g.cs @@ -66,44 +66,44 @@ public PaddingHelper Padding return v.VisitTry(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Try WithId(Guid newId) { - return newId == id ? this : new Try(newId, prefix, markers, _resources, body, catches, _finally); + return newId == Id ? this : new Try(newId, Prefix, Markers, _resources, Body, Catches, _finally); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Try WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Try(id, newPrefix, markers, _resources, body, catches, _finally); + return newPrefix == Prefix ? this : new Try(Id, newPrefix, Markers, _resources, Body, Catches, _finally); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Try WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Try(id, prefix, newMarkers, _resources, body, catches, _finally); + return ReferenceEquals(newMarkers, Markers) ? this : new Try(Id, Prefix, newMarkers, _resources, Body, Catches, _finally); } - private readonly JContainer? _resources = resources; + private JContainer? _resources = resources; public IList? Resources => _resources?.GetElements(); public Try WithResources(IList? newResources) { return Padding.WithResources(JContainer.WithElementsNullable(_resources, newResources)); } - public J.Block Body => body; + public J.Block Body { get; set; } = body; public Try WithBody(J.Block newBody) { - return ReferenceEquals(newBody, body) ? this : new Try(id, prefix, markers, _resources, newBody, catches, _finally); + return ReferenceEquals(newBody, Body) ? this : new Try(Id, Prefix, Markers, _resources, newBody, Catches, _finally); } - public IList Catches => catches; + public IList Catches { get; set; } = catches; public Try WithCatches(IList newCatches) { - return newCatches == catches ? this : new Try(id, prefix, markers, _resources, body, newCatches, _finally); + return newCatches == Catches ? this : new Try(Id, Prefix, Markers, _resources, Body, newCatches, _finally); } - private readonly JLeftPadded? _finally = @finally; + private JLeftPadded? _finally = @finally; public J.Block? Finally => _finally?.Element; public Try WithFinally(J.Block? newFinally) @@ -126,35 +126,35 @@ bool terminatedWithSemicolon return v.VisitTryResource(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Resource WithId(Guid newId) { - return newId == id ? this : new Resource(newId, prefix, markers, variableDeclarations, terminatedWithSemicolon); + return newId == Id ? this : new Resource(newId, Prefix, Markers, VariableDeclarations, TerminatedWithSemicolon); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Resource WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Resource(id, newPrefix, markers, variableDeclarations, terminatedWithSemicolon); + return newPrefix == Prefix ? this : new Resource(Id, newPrefix, Markers, VariableDeclarations, TerminatedWithSemicolon); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Resource WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Resource(id, prefix, newMarkers, variableDeclarations, terminatedWithSemicolon); + return ReferenceEquals(newMarkers, Markers) ? this : new Resource(Id, Prefix, newMarkers, VariableDeclarations, TerminatedWithSemicolon); } - public TypedTree VariableDeclarations => variableDeclarations; + public TypedTree VariableDeclarations { get; set; } = variableDeclarations; public Resource WithVariableDeclarations(TypedTree newVariableDeclarations) { - return ReferenceEquals(newVariableDeclarations, variableDeclarations) ? this : new Resource(id, prefix, markers, newVariableDeclarations, terminatedWithSemicolon); + return ReferenceEquals(newVariableDeclarations, VariableDeclarations) ? this : new Resource(Id, Prefix, Markers, newVariableDeclarations, TerminatedWithSemicolon); } - public bool TerminatedWithSemicolon => terminatedWithSemicolon; + public bool TerminatedWithSemicolon { get; set; } = terminatedWithSemicolon; public Resource WithTerminatedWithSemicolon(bool newTerminatedWithSemicolon) { - return newTerminatedWithSemicolon == terminatedWithSemicolon ? this : new Resource(id, prefix, markers, variableDeclarations, newTerminatedWithSemicolon); + return newTerminatedWithSemicolon == TerminatedWithSemicolon ? this : new Resource(Id, Prefix, Markers, VariableDeclarations, newTerminatedWithSemicolon); } #if DEBUG_VISITOR [DebuggerStepThrough] @@ -187,35 +187,35 @@ J.Block body return v.VisitCatch(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Catch WithId(Guid newId) { - return newId == id ? this : new Catch(newId, prefix, markers, parameter, body); + return newId == Id ? this : new Catch(newId, Prefix, Markers, Parameter, Body); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Catch WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Catch(id, newPrefix, markers, parameter, body); + return newPrefix == Prefix ? this : new Catch(Id, newPrefix, Markers, Parameter, Body); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Catch WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Catch(id, prefix, newMarkers, parameter, body); + return ReferenceEquals(newMarkers, Markers) ? this : new Catch(Id, Prefix, newMarkers, Parameter, Body); } - public J.ControlParentheses Parameter => parameter; + public J.ControlParentheses Parameter { get; set; } = parameter; public Catch WithParameter(J.ControlParentheses newParameter) { - return ReferenceEquals(newParameter, parameter) ? this : new Catch(id, prefix, markers, newParameter, body); + return ReferenceEquals(newParameter, Parameter) ? this : new Catch(Id, Prefix, Markers, newParameter, Body); } - public J.Block Body => body; + public J.Block Body { get; set; } = body; public Catch WithBody(J.Block newBody) { - return ReferenceEquals(newBody, body) ? this : new Catch(id, prefix, markers, parameter, newBody); + return ReferenceEquals(newBody, Body) ? this : new Catch(Id, Prefix, Markers, Parameter, newBody); } #if DEBUG_VISITOR [DebuggerStepThrough] @@ -234,18 +234,18 @@ public override int GetHashCode() } public sealed record PaddingHelper(J.Try T) { - public JContainer? Resources => T._resources; + public JContainer? Resources { get => T._resources; set => T._resources = value; } public J.Try WithResources(JContainer? newResources) { - return T._resources == newResources ? T : new J.Try(T.Id, T.Prefix, T.Markers, newResources, T.Body, T.Catches, T._finally); + return Resources == newResources ? T : new J.Try(T.Id, T.Prefix, T.Markers, newResources, T.Body, T.Catches, T._finally); } - public JLeftPadded? Finally => T._finally; + public JLeftPadded? Finally { get => T._finally; set => T._finally = value; } public J.Try WithFinally(JLeftPadded? newFinally) { - return T._finally == newFinally ? T : new J.Try(T.Id, T.Prefix, T.Markers, T._resources, T.Body, T.Catches, newFinally); + return Finally == newFinally ? T : new J.Try(T.Id, T.Prefix, T.Markers, T._resources, T.Body, T.Catches, newFinally); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/TypeCast.g.cs b/Rewrite/src/Rewrite.Java/Tree/TypeCast.g.cs index e4a1cccc..e329ac23 100644 --- a/Rewrite/src/Rewrite.Java/Tree/TypeCast.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/TypeCast.g.cs @@ -39,35 +39,35 @@ Expression expression return v.VisitTypeCast(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public TypeCast WithId(Guid newId) { - return newId == id ? this : new TypeCast(newId, prefix, markers, clazz, expression); + return newId == Id ? this : new TypeCast(newId, Prefix, Markers, Clazz, Expression); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public TypeCast WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new TypeCast(id, newPrefix, markers, clazz, expression); + return newPrefix == Prefix ? this : new TypeCast(Id, newPrefix, Markers, Clazz, Expression); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public TypeCast WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new TypeCast(id, prefix, newMarkers, clazz, expression); + return ReferenceEquals(newMarkers, Markers) ? this : new TypeCast(Id, Prefix, newMarkers, Clazz, Expression); } - public J.ControlParentheses Clazz => clazz; + public J.ControlParentheses Clazz { get; set; } = clazz; public TypeCast WithClazz(J.ControlParentheses newClazz) { - return ReferenceEquals(newClazz, clazz) ? this : new TypeCast(id, prefix, markers, newClazz, expression); + return ReferenceEquals(newClazz, Clazz) ? this : new TypeCast(Id, Prefix, Markers, newClazz, Expression); } - public Expression Expression => expression; + public Expression Expression { get; set; } = expression; public TypeCast WithExpression(Expression newExpression) { - return ReferenceEquals(newExpression, expression) ? this : new TypeCast(id, prefix, markers, clazz, newExpression); + return ReferenceEquals(newExpression, Expression) ? this : new TypeCast(Id, Prefix, Markers, Clazz, newExpression); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.Java/Tree/TypeParameter.g.cs b/Rewrite/src/Rewrite.Java/Tree/TypeParameter.g.cs index ece8f802..9d44d307 100644 --- a/Rewrite/src/Rewrite.Java/Tree/TypeParameter.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/TypeParameter.g.cs @@ -66,43 +66,43 @@ public PaddingHelper Padding return v.VisitTypeParameter(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public TypeParameter WithId(Guid newId) { - return newId == id ? this : new TypeParameter(newId, prefix, markers, annotations, modifiers, name, _bounds); + return newId == Id ? this : new TypeParameter(newId, Prefix, Markers, Annotations, Modifiers, Name, _bounds); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public TypeParameter WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new TypeParameter(id, newPrefix, markers, annotations, modifiers, name, _bounds); + return newPrefix == Prefix ? this : new TypeParameter(Id, newPrefix, Markers, Annotations, Modifiers, Name, _bounds); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public TypeParameter WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new TypeParameter(id, prefix, newMarkers, annotations, modifiers, name, _bounds); + return ReferenceEquals(newMarkers, Markers) ? this : new TypeParameter(Id, Prefix, newMarkers, Annotations, Modifiers, Name, _bounds); } - public IList Annotations => annotations; + public IList Annotations { get; set; } = annotations; public TypeParameter WithAnnotations(IList newAnnotations) { - return newAnnotations == annotations ? this : new TypeParameter(id, prefix, markers, newAnnotations, modifiers, name, _bounds); + return newAnnotations == Annotations ? this : new TypeParameter(Id, Prefix, Markers, newAnnotations, Modifiers, Name, _bounds); } - public IList Modifiers => modifiers; + public IList Modifiers { get; set; } = modifiers; public TypeParameter WithModifiers(IList newModifiers) { - return newModifiers == modifiers ? this : new TypeParameter(id, prefix, markers, annotations, newModifiers, name, _bounds); + return newModifiers == Modifiers ? this : new TypeParameter(Id, Prefix, Markers, Annotations, newModifiers, Name, _bounds); } - public Expression Name => name; + public Expression Name { get; set; } = name; public TypeParameter WithName(Expression newName) { - return ReferenceEquals(newName, name) ? this : new TypeParameter(id, prefix, markers, annotations, modifiers, newName, _bounds); + return ReferenceEquals(newName, Name) ? this : new TypeParameter(Id, Prefix, Markers, Annotations, Modifiers, newName, _bounds); } - private readonly JContainer? _bounds = bounds; + private JContainer? _bounds = bounds; public IList? Bounds => _bounds?.GetElements(); public TypeParameter WithBounds(IList? newBounds) @@ -111,11 +111,11 @@ public TypeParameter WithBounds(IList? newBounds) } public sealed record PaddingHelper(J.TypeParameter T) { - public JContainer? Bounds => T._bounds; + public JContainer? Bounds { get => T._bounds; set => T._bounds = value; } public J.TypeParameter WithBounds(JContainer? newBounds) { - return T._bounds == newBounds ? T : new J.TypeParameter(T.Id, T.Prefix, T.Markers, T.Annotations, T.Modifiers, T.Name, newBounds); + return Bounds == newBounds ? T : new J.TypeParameter(T.Id, T.Prefix, T.Markers, T.Annotations, T.Modifiers, T.Name, newBounds); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/TypeParameters.g.cs b/Rewrite/src/Rewrite.Java/Tree/TypeParameters.g.cs index d739be7d..34dad518 100644 --- a/Rewrite/src/Rewrite.Java/Tree/TypeParameters.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/TypeParameters.g.cs @@ -64,31 +64,31 @@ public PaddingHelper Padding return v.VisitTypeParameters(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public TypeParameters WithId(Guid newId) { - return newId == id ? this : new TypeParameters(newId, prefix, markers, annotations, _parameters); + return newId == Id ? this : new TypeParameters(newId, Prefix, Markers, Annotations, _parameters); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public TypeParameters WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new TypeParameters(id, newPrefix, markers, annotations, _parameters); + return newPrefix == Prefix ? this : new TypeParameters(Id, newPrefix, Markers, Annotations, _parameters); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public TypeParameters WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new TypeParameters(id, prefix, newMarkers, annotations, _parameters); + return ReferenceEquals(newMarkers, Markers) ? this : new TypeParameters(Id, Prefix, newMarkers, Annotations, _parameters); } - public IList Annotations => annotations; + public IList Annotations { get; set; } = annotations; public TypeParameters WithAnnotations(IList newAnnotations) { - return newAnnotations == annotations ? this : new TypeParameters(id, prefix, markers, newAnnotations, _parameters); + return newAnnotations == Annotations ? this : new TypeParameters(Id, Prefix, Markers, newAnnotations, _parameters); } - private readonly IList> _parameters = parameters; + private IList> _parameters = parameters; public IList Parameters => _parameters.Elements(); public TypeParameters WithParameters(IList newParameters) @@ -97,11 +97,11 @@ public TypeParameters WithParameters(IList newParameters) } public sealed record PaddingHelper(J.TypeParameters T) { - public IList> Parameters => T._parameters; + public IList> Parameters { get => T._parameters; set => T._parameters = value; } public J.TypeParameters WithParameters(IList> newParameters) { - return T._parameters == newParameters ? T : new J.TypeParameters(T.Id, T.Prefix, T.Markers, T.Annotations, newParameters); + return Parameters == newParameters ? T : new J.TypeParameters(T.Id, T.Prefix, T.Markers, T.Annotations, newParameters); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/TypeTree.cs b/Rewrite/src/Rewrite.Java/Tree/TypeTree.cs index 34fee457..c417b425 100644 --- a/Rewrite/src/Rewrite.Java/Tree/TypeTree.cs +++ b/Rewrite/src/Rewrite.Java/Tree/TypeTree.cs @@ -5,14 +5,14 @@ namespace Rewrite.RewriteJava.Tree; -public interface TypeTree : TypeTree, TypedTree where T : TypeTree -{ - public new T WithType(JavaType? type); - TypeTree TypeTree.WithType(JavaType? type) => WithType(type); -} +// public interface TypeTree : TypeTree, TypedTree where T : TypeTree +// { +// public new T WithType(JavaType? type); +// TypeTree TypeTree.WithType(JavaType? type) => WithType(type); +// } [SuppressMessage("ReSharper", "InconsistentNaming")] [SuppressMessage("ReSharper", "PossibleUnintendedReferenceComparison")] -public interface TypeTree : NameTree +public partial interface TypeTree : NameTree { - public new TypeTree WithType(JavaType? type) => (TypeTree)((TypedTree)this).WithType(type); + // public new TypeTree WithType(JavaType? type) => (TypeTree)((TypedTree)this).WithType(type); } diff --git a/Rewrite/src/Rewrite.Java/Tree/TypedTree.cs b/Rewrite/src/Rewrite.Java/Tree/TypedTree.cs index 299c5dd5..ed090121 100644 --- a/Rewrite/src/Rewrite.Java/Tree/TypedTree.cs +++ b/Rewrite/src/Rewrite.Java/Tree/TypedTree.cs @@ -6,11 +6,11 @@ namespace Rewrite.RewriteJava.Tree; -public interface TypedTree : J, TypedTree where T : TypedTree -{ - public new T WithType(JavaType? type); - TypedTree TypedTree.WithType(JavaType? type) => WithType(type); -} +// public interface TypedTree : J, TypedTree where T : TypedTree +// { +// public new T WithType(JavaType? type); +// TypedTree TypedTree.WithType(JavaType? type) => WithType(type); +// } ///

/// A tree with type attribution information. Unlike , /// this does not necessarily mean the tree is the name of a type. So for @@ -19,7 +19,7 @@ public interface TypedTree : J, TypedTree where T : TypedTree /// [SuppressMessage("ReSharper", "InconsistentNaming")] [SuppressMessage("ReSharper", "PossibleUnintendedReferenceComparison")] -public interface TypedTree : J +public partial interface TypedTree : J { public JavaType? Type { get; } diff --git a/Rewrite/src/Rewrite.Java/Tree/Unary.g.cs b/Rewrite/src/Rewrite.Java/Tree/Unary.g.cs index 91019e60..d691fc1a 100644 --- a/Rewrite/src/Rewrite.Java/Tree/Unary.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/Unary.g.cs @@ -65,42 +65,42 @@ public PaddingHelper Padding return v.VisitUnary(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Unary WithId(Guid newId) { - return newId == id ? this : new Unary(newId, prefix, markers, _operator, expression, type); + return newId == Id ? this : new Unary(newId, Prefix, Markers, _operator, Expression, Type); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Unary WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Unary(id, newPrefix, markers, _operator, expression, type); + return newPrefix == Prefix ? this : new Unary(Id, newPrefix, Markers, _operator, Expression, Type); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Unary WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Unary(id, prefix, newMarkers, _operator, expression, type); + return ReferenceEquals(newMarkers, Markers) ? this : new Unary(Id, Prefix, newMarkers, _operator, Expression, Type); } - private readonly JLeftPadded _operator = @operator; + private JLeftPadded _operator = @operator; public Types Operator => _operator.Element; public Unary WithOperator(Types newOperator) { return Padding.WithOperator(_operator.WithElement(newOperator)); } - public Expression Expression => expression; + public Expression Expression { get; set; } = expression; public Unary WithExpression(Expression newExpression) { - return ReferenceEquals(newExpression, expression) ? this : new Unary(id, prefix, markers, _operator, newExpression, type); + return ReferenceEquals(newExpression, Expression) ? this : new Unary(Id, Prefix, Markers, _operator, newExpression, Type); } - public JavaType? Type => type; + public JavaType? Type { get; set; } = type; public Unary WithType(JavaType? newType) { - return newType == type ? this : new Unary(id, prefix, markers, _operator, expression, newType); + return newType == Type ? this : new Unary(Id, Prefix, Markers, _operator, Expression, newType); } public enum Types { @@ -115,11 +115,11 @@ public enum Types } public sealed record PaddingHelper(J.Unary T) { - public JLeftPadded Operator => T._operator; + public JLeftPadded Operator { get => T._operator; set => T._operator = value; } public J.Unary WithOperator(JLeftPadded newOperator) { - return T._operator == newOperator ? T : new J.Unary(T.Id, T.Prefix, T.Markers, newOperator, T.Expression, T.Type); + return Operator == newOperator ? T : new J.Unary(T.Id, T.Prefix, T.Markers, newOperator, T.Expression, T.Type); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/Unknown.g.cs b/Rewrite/src/Rewrite.Java/Tree/Unknown.g.cs index 31f51dcd..991f9b89 100644 --- a/Rewrite/src/Rewrite.Java/Tree/Unknown.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/Unknown.g.cs @@ -41,29 +41,29 @@ Unknown.Source unknownSource return v.VisitUnknown(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Unknown WithId(Guid newId) { - return newId == id ? this : new Unknown(newId, prefix, markers, unknownSource); + return newId == Id ? this : new Unknown(newId, Prefix, Markers, UnknownSource); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Unknown WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Unknown(id, newPrefix, markers, unknownSource); + return newPrefix == Prefix ? this : new Unknown(Id, newPrefix, Markers, UnknownSource); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Unknown WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Unknown(id, prefix, newMarkers, unknownSource); + return ReferenceEquals(newMarkers, Markers) ? this : new Unknown(Id, Prefix, newMarkers, UnknownSource); } - public Source UnknownSource => unknownSource; + public Source UnknownSource { get; set; } = unknownSource; public Unknown WithUnknownSource(Source newUnknownSource) { - return ReferenceEquals(newUnknownSource, unknownSource) ? this : new Unknown(id, prefix, markers, newUnknownSource); + return ReferenceEquals(newUnknownSource, UnknownSource) ? this : new Unknown(Id, Prefix, Markers, newUnknownSource); } /// /// This class only exists to clean up the printed results from `SearchResult` markers. @@ -84,29 +84,29 @@ string text return v.VisitUnknownSource(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Source WithId(Guid newId) { - return newId == id ? this : new Source(newId, prefix, markers, text); + return newId == Id ? this : new Source(newId, Prefix, Markers, Text); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Source WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Source(id, newPrefix, markers, text); + return newPrefix == Prefix ? this : new Source(Id, newPrefix, Markers, Text); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Source WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Source(id, prefix, newMarkers, text); + return ReferenceEquals(newMarkers, Markers) ? this : new Source(Id, Prefix, newMarkers, Text); } - public string Text => text; + public string Text { get; set; } = text; public Source WithText(string newText) { - return newText == text ? this : new Source(id, prefix, markers, newText); + return newText == Text ? this : new Source(Id, Prefix, Markers, newText); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.Java/Tree/VariableDeclarations.g.cs b/Rewrite/src/Rewrite.Java/Tree/VariableDeclarations.g.cs index 6c0c2941..19400719 100644 --- a/Rewrite/src/Rewrite.Java/Tree/VariableDeclarations.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/VariableDeclarations.g.cs @@ -68,55 +68,55 @@ public PaddingHelper Padding return v.VisitVariableDeclarations(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public VariableDeclarations WithId(Guid newId) { - return newId == id ? this : new VariableDeclarations(newId, prefix, markers, leadingAnnotations, modifiers, typeExpression, varargs, dimensionsBeforeName, _variables); + return newId == Id ? this : new VariableDeclarations(newId, Prefix, Markers, LeadingAnnotations, Modifiers, TypeExpression, Varargs, DimensionsBeforeName, _variables); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public VariableDeclarations WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new VariableDeclarations(id, newPrefix, markers, leadingAnnotations, modifiers, typeExpression, varargs, dimensionsBeforeName, _variables); + return newPrefix == Prefix ? this : new VariableDeclarations(Id, newPrefix, Markers, LeadingAnnotations, Modifiers, TypeExpression, Varargs, DimensionsBeforeName, _variables); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public VariableDeclarations WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new VariableDeclarations(id, prefix, newMarkers, leadingAnnotations, modifiers, typeExpression, varargs, dimensionsBeforeName, _variables); + return ReferenceEquals(newMarkers, Markers) ? this : new VariableDeclarations(Id, Prefix, newMarkers, LeadingAnnotations, Modifiers, TypeExpression, Varargs, DimensionsBeforeName, _variables); } - public IList LeadingAnnotations => leadingAnnotations; + public IList LeadingAnnotations { get; set; } = leadingAnnotations; public VariableDeclarations WithLeadingAnnotations(IList newLeadingAnnotations) { - return newLeadingAnnotations == leadingAnnotations ? this : new VariableDeclarations(id, prefix, markers, newLeadingAnnotations, modifiers, typeExpression, varargs, dimensionsBeforeName, _variables); + return newLeadingAnnotations == LeadingAnnotations ? this : new VariableDeclarations(Id, Prefix, Markers, newLeadingAnnotations, Modifiers, TypeExpression, Varargs, DimensionsBeforeName, _variables); } - public IList Modifiers => modifiers; + public IList Modifiers { get; set; } = modifiers; public VariableDeclarations WithModifiers(IList newModifiers) { - return newModifiers == modifiers ? this : new VariableDeclarations(id, prefix, markers, leadingAnnotations, newModifiers, typeExpression, varargs, dimensionsBeforeName, _variables); + return newModifiers == Modifiers ? this : new VariableDeclarations(Id, Prefix, Markers, LeadingAnnotations, newModifiers, TypeExpression, Varargs, DimensionsBeforeName, _variables); } - public TypeTree? TypeExpression => typeExpression; + public TypeTree? TypeExpression { get; set; } = typeExpression; public VariableDeclarations WithTypeExpression(TypeTree? newTypeExpression) { - return ReferenceEquals(newTypeExpression, typeExpression) ? this : new VariableDeclarations(id, prefix, markers, leadingAnnotations, modifiers, newTypeExpression, varargs, dimensionsBeforeName, _variables); + return ReferenceEquals(newTypeExpression, TypeExpression) ? this : new VariableDeclarations(Id, Prefix, Markers, LeadingAnnotations, Modifiers, newTypeExpression, Varargs, DimensionsBeforeName, _variables); } - public Space? Varargs => varargs; + public Space? Varargs { get; set; } = varargs; public VariableDeclarations WithVarargs(Space? newVarargs) { - return newVarargs == varargs ? this : new VariableDeclarations(id, prefix, markers, leadingAnnotations, modifiers, typeExpression, newVarargs, dimensionsBeforeName, _variables); + return newVarargs == Varargs ? this : new VariableDeclarations(Id, Prefix, Markers, LeadingAnnotations, Modifiers, TypeExpression, newVarargs, DimensionsBeforeName, _variables); } - public IList> DimensionsBeforeName => dimensionsBeforeName; + public IList> DimensionsBeforeName { get; set; } = dimensionsBeforeName; public VariableDeclarations WithDimensionsBeforeName(IList> newDimensionsBeforeName) { - return newDimensionsBeforeName == dimensionsBeforeName ? this : new VariableDeclarations(id, prefix, markers, leadingAnnotations, modifiers, typeExpression, varargs, newDimensionsBeforeName, _variables); + return newDimensionsBeforeName == DimensionsBeforeName ? this : new VariableDeclarations(Id, Prefix, Markers, LeadingAnnotations, Modifiers, TypeExpression, Varargs, newDimensionsBeforeName, _variables); } - private readonly IList> _variables = variables; + private IList> _variables = variables; public IList Variables => _variables.Elements(); public VariableDeclarations WithVariables(IList newVariables) @@ -166,56 +166,56 @@ public PaddingHelper Padding return v.VisitVariable(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public NamedVariable WithId(Guid newId) { - return newId == id ? this : new NamedVariable(newId, prefix, markers, name, dimensionsAfterName, _initializer, variableType); + return newId == Id ? this : new NamedVariable(newId, Prefix, Markers, Name, DimensionsAfterName, _initializer, VariableType); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public NamedVariable WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new NamedVariable(id, newPrefix, markers, name, dimensionsAfterName, _initializer, variableType); + return newPrefix == Prefix ? this : new NamedVariable(Id, newPrefix, Markers, Name, DimensionsAfterName, _initializer, VariableType); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public NamedVariable WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new NamedVariable(id, prefix, newMarkers, name, dimensionsAfterName, _initializer, variableType); + return ReferenceEquals(newMarkers, Markers) ? this : new NamedVariable(Id, Prefix, newMarkers, Name, DimensionsAfterName, _initializer, VariableType); } - public J.Identifier Name => name; + public J.Identifier Name { get; set; } = name; public NamedVariable WithName(J.Identifier newName) { - return ReferenceEquals(newName, name) ? this : new NamedVariable(id, prefix, markers, newName, dimensionsAfterName, _initializer, variableType); + return ReferenceEquals(newName, Name) ? this : new NamedVariable(Id, Prefix, Markers, newName, DimensionsAfterName, _initializer, VariableType); } - public IList> DimensionsAfterName => dimensionsAfterName; + public IList> DimensionsAfterName { get; set; } = dimensionsAfterName; public NamedVariable WithDimensionsAfterName(IList> newDimensionsAfterName) { - return newDimensionsAfterName == dimensionsAfterName ? this : new NamedVariable(id, prefix, markers, name, newDimensionsAfterName, _initializer, variableType); + return newDimensionsAfterName == DimensionsAfterName ? this : new NamedVariable(Id, Prefix, Markers, Name, newDimensionsAfterName, _initializer, VariableType); } - private readonly JLeftPadded? _initializer = initializer; + private JLeftPadded? _initializer = initializer; public Expression? Initializer => _initializer?.Element; public NamedVariable WithInitializer(Expression? newInitializer) { return Padding.WithInitializer(JLeftPadded.WithElement(_initializer, newInitializer)); } - public JavaType.Variable? VariableType => variableType; + public JavaType.Variable? VariableType { get; set; } = variableType; public NamedVariable WithVariableType(JavaType.Variable? newVariableType) { - return newVariableType == variableType ? this : new NamedVariable(id, prefix, markers, name, dimensionsAfterName, _initializer, newVariableType); + return newVariableType == VariableType ? this : new NamedVariable(Id, Prefix, Markers, Name, DimensionsAfterName, _initializer, newVariableType); } public sealed record PaddingHelper(J.VariableDeclarations.NamedVariable T) { - public JLeftPadded? Initializer => T._initializer; + public JLeftPadded? Initializer { get => T._initializer; set => T._initializer = value; } public J.VariableDeclarations.NamedVariable WithInitializer(JLeftPadded? newInitializer) { - return T._initializer == newInitializer ? T : new J.VariableDeclarations.NamedVariable(T.Id, T.Prefix, T.Markers, T.Name, T.DimensionsAfterName, newInitializer, T.VariableType); + return Initializer == newInitializer ? T : new J.VariableDeclarations.NamedVariable(T.Id, T.Prefix, T.Markers, T.Name, T.DimensionsAfterName, newInitializer, T.VariableType); } } @@ -237,11 +237,11 @@ public override int GetHashCode() } public sealed record PaddingHelper(J.VariableDeclarations T) { - public IList> Variables => T._variables; + public IList> Variables { get => T._variables; set => T._variables = value; } public J.VariableDeclarations WithVariables(IList> newVariables) { - return T._variables == newVariables ? T : new J.VariableDeclarations(T.Id, T.Prefix, T.Markers, T.LeadingAnnotations, T.Modifiers, T.TypeExpression, T.Varargs, T.DimensionsBeforeName, newVariables); + return Variables == newVariables ? T : new J.VariableDeclarations(T.Id, T.Prefix, T.Markers, T.LeadingAnnotations, T.Modifiers, T.TypeExpression, T.Varargs, T.DimensionsBeforeName, newVariables); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/WhileLoop.g.cs b/Rewrite/src/Rewrite.Java/Tree/WhileLoop.g.cs index 2d7360ec..bb1a2d62 100644 --- a/Rewrite/src/Rewrite.Java/Tree/WhileLoop.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/WhileLoop.g.cs @@ -64,31 +64,31 @@ public PaddingHelper Padding return v.VisitWhileLoop(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public WhileLoop WithId(Guid newId) { - return newId == id ? this : new WhileLoop(newId, prefix, markers, condition, _body); + return newId == Id ? this : new WhileLoop(newId, Prefix, Markers, Condition, _body); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public WhileLoop WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new WhileLoop(id, newPrefix, markers, condition, _body); + return newPrefix == Prefix ? this : new WhileLoop(Id, newPrefix, Markers, Condition, _body); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public WhileLoop WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new WhileLoop(id, prefix, newMarkers, condition, _body); + return ReferenceEquals(newMarkers, Markers) ? this : new WhileLoop(Id, Prefix, newMarkers, Condition, _body); } - public J.ControlParentheses Condition => condition; + public J.ControlParentheses Condition { get; set; } = condition; public WhileLoop WithCondition(J.ControlParentheses newCondition) { - return ReferenceEquals(newCondition, condition) ? this : new WhileLoop(id, prefix, markers, newCondition, _body); + return ReferenceEquals(newCondition, Condition) ? this : new WhileLoop(Id, Prefix, Markers, newCondition, _body); } - private readonly JRightPadded _body = body; + private JRightPadded _body = body; public Statement Body => _body.Element; public WhileLoop WithBody(Statement newBody) @@ -97,11 +97,11 @@ public WhileLoop WithBody(Statement newBody) } public sealed record PaddingHelper(J.WhileLoop T) { - public JRightPadded Body => T._body; + public JRightPadded Body { get => T._body; set => T._body = value; } public J.WhileLoop WithBody(JRightPadded newBody) { - return T._body == newBody ? T : new J.WhileLoop(T.Id, T.Prefix, T.Markers, T.Condition, newBody); + return Body == newBody ? T : new J.WhileLoop(T.Id, T.Prefix, T.Markers, T.Condition, newBody); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/Wildcard.g.cs b/Rewrite/src/Rewrite.Java/Tree/Wildcard.g.cs index 82c184ab..c0bc8a68 100644 --- a/Rewrite/src/Rewrite.Java/Tree/Wildcard.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/Wildcard.g.cs @@ -64,36 +64,36 @@ public PaddingHelper Padding return v.VisitWildcard(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Wildcard WithId(Guid newId) { - return newId == id ? this : new Wildcard(newId, prefix, markers, _wildcardBound, boundedType); + return newId == Id ? this : new Wildcard(newId, Prefix, Markers, _wildcardBound, BoundedType); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Wildcard WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Wildcard(id, newPrefix, markers, _wildcardBound, boundedType); + return newPrefix == Prefix ? this : new Wildcard(Id, newPrefix, Markers, _wildcardBound, BoundedType); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Wildcard WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Wildcard(id, prefix, newMarkers, _wildcardBound, boundedType); + return ReferenceEquals(newMarkers, Markers) ? this : new Wildcard(Id, Prefix, newMarkers, _wildcardBound, BoundedType); } - private readonly JLeftPadded? _wildcardBound = wildcardBound; + private JLeftPadded? _wildcardBound = wildcardBound; public Bound? WildcardBound => _wildcardBound?.Element; public Wildcard WithWildcardBound(Bound? newWildcardBound) { return Padding.WithWildcardBound(newWildcardBound == null ? null : JLeftPadded.WithElement(_wildcardBound, newWildcardBound.Value)); } - public NameTree? BoundedType => boundedType; + public NameTree? BoundedType { get; set; } = boundedType; public Wildcard WithBoundedType(NameTree? newBoundedType) { - return ReferenceEquals(newBoundedType, boundedType) ? this : new Wildcard(id, prefix, markers, _wildcardBound, newBoundedType); + return ReferenceEquals(newBoundedType, BoundedType) ? this : new Wildcard(Id, Prefix, Markers, _wildcardBound, newBoundedType); } public enum Bound { @@ -102,11 +102,11 @@ public enum Bound } public sealed record PaddingHelper(J.Wildcard T) { - public JLeftPadded? WildcardBound => T._wildcardBound; + public JLeftPadded? WildcardBound { get => T._wildcardBound; set => T._wildcardBound = value; } public J.Wildcard WithWildcardBound(JLeftPadded? newWildcardBound) { - return T._wildcardBound == newWildcardBound ? T : new J.Wildcard(T.Id, T.Prefix, T.Markers, newWildcardBound, T.BoundedType); + return WildcardBound == newWildcardBound ? T : new J.Wildcard(T.Id, T.Prefix, T.Markers, newWildcardBound, T.BoundedType); } } diff --git a/Rewrite/src/Rewrite.Java/Tree/Yield.g.cs b/Rewrite/src/Rewrite.Java/Tree/Yield.g.cs index 42f741ef..be5654e5 100644 --- a/Rewrite/src/Rewrite.Java/Tree/Yield.g.cs +++ b/Rewrite/src/Rewrite.Java/Tree/Yield.g.cs @@ -39,35 +39,35 @@ Expression value return v.VisitYield(this, p); } - public Guid Id => id; + public Guid Id { get; set; } = id; public Yield WithId(Guid newId) { - return newId == id ? this : new Yield(newId, prefix, markers, @implicit, value); + return newId == Id ? this : new Yield(newId, Prefix, Markers, Implicit, Value); } - public Space Prefix => prefix; + public Space Prefix { get; set; } = prefix; public Yield WithPrefix(Space newPrefix) { - return newPrefix == prefix ? this : new Yield(id, newPrefix, markers, @implicit, value); + return newPrefix == Prefix ? this : new Yield(Id, newPrefix, Markers, Implicit, Value); } - public Markers Markers => markers; + public Markers Markers { get; set; } = markers; public Yield WithMarkers(Markers newMarkers) { - return ReferenceEquals(newMarkers, markers) ? this : new Yield(id, prefix, newMarkers, @implicit, value); + return ReferenceEquals(newMarkers, Markers) ? this : new Yield(Id, Prefix, newMarkers, Implicit, Value); } - public bool Implicit => @implicit; + public bool Implicit { get; set; } = @implicit; public Yield WithImplicit(bool newImplicit) { - return newImplicit == @implicit ? this : new Yield(id, prefix, markers, newImplicit, value); + return newImplicit == Implicit ? this : new Yield(Id, Prefix, Markers, newImplicit, Value); } - public Expression Value => value; + public Expression Value { get; set; } = value; public Yield WithValue(Expression newValue) { - return ReferenceEquals(newValue, value) ? this : new Yield(id, prefix, markers, @implicit, newValue); + return ReferenceEquals(newValue, Value) ? this : new Yield(Id, Prefix, Markers, Implicit, newValue); } #if DEBUG_VISITOR [DebuggerStepThrough] diff --git a/Rewrite/src/Rewrite.Remote.Codec/Rewrite.Remote.Codec.csproj b/Rewrite/src/Rewrite.Remote.Codec/Rewrite.Remote.Codec.csproj index e6c428fa..946b81b1 100644 --- a/Rewrite/src/Rewrite.Remote.Codec/Rewrite.Remote.Codec.csproj +++ b/Rewrite/src/Rewrite.Remote.Codec/Rewrite.Remote.Codec.csproj @@ -9,7 +9,7 @@ - + diff --git a/Rewrite/src/Rewrite.Server/Rewrite.Server.csproj b/Rewrite/src/Rewrite.Server/Rewrite.Server.csproj index 7eca9198..aac984d3 100644 --- a/Rewrite/src/Rewrite.Server/Rewrite.Server.csproj +++ b/Rewrite/src/Rewrite.Server/Rewrite.Server.csproj @@ -32,7 +32,9 @@ - + + + diff --git a/Rewrite/tests/Rewrite.CSharp.Tests/CSharpTypeAttributionTests.cs b/Rewrite/tests/Rewrite.CSharp.Tests/CSharpTypeAttributionTests.cs index 07d8d2c6..3f0f9f3b 100644 --- a/Rewrite/tests/Rewrite.CSharp.Tests/CSharpTypeAttributionTests.cs +++ b/Rewrite/tests/Rewrite.CSharp.Tests/CSharpTypeAttributionTests.cs @@ -35,18 +35,19 @@ public void Main() """, spec => spec.AfterRecipe = cu => { - var c = (J.ClassDeclaration)cu.Members[0]; - var md = (J.MethodDeclaration)c.Body.Statements[1]; - var m = (J.MethodInvocation)md.Body!.Statements[0]; + var c = (Cs.ClassDeclaration)cu.Members[0]; + var md = (Cs.MethodDeclaration)c.Body!.Statements[1]; + var m = md.Descendents().OfType().First(); // m.Arguments.Should(). Assert.Equal((decimal)3, m.Arguments.Count, 1); - m.Arguments[2].Should().BeOfType(); - var it = - (J.MethodInvocation)((J.Return)((J.Block)((J.Lambda)m.Arguments[2]).Body).Statements[0]) - .Expression!; - AsFullyQualified(it.Select?.Type)?.FullyQualifiedName.Should().BeEquivalentTo("java.lang.String"); - it.MethodType?.Name.Should().BeEquivalentTo("substring"); - it.MethodType?.DeclaringType.FullyQualifiedName.Should().BeEquivalentTo("java.lang.String"); + var thirdArgument = m.Arguments[2] as Cs.Argument; + thirdArgument.Should().BeOfType(); + + var it = thirdArgument.Expression!; + //todo: fix this to be properly type attested with c# + // AsFullyQualified(it.Select?.Type)?.FullyQualifiedName.Should().BeEquivalentTo("java.lang.String"); + // it.MethodType?.Name.Should().BeEquivalentTo("substring"); + // it.MethodType?.DeclaringType.FullyQualifiedName.Should().BeEquivalentTo("java.lang.String"); }) ); } diff --git a/Rewrite/tests/Rewrite.CSharp.Tests/Formatter/AutoFormatterTests.cs b/Rewrite/tests/Rewrite.CSharp.Tests/Formatter/AutoFormatterTests.cs new file mode 100644 index 00000000..4e6a73a3 --- /dev/null +++ b/Rewrite/tests/Rewrite.CSharp.Tests/Formatter/AutoFormatterTests.cs @@ -0,0 +1,51 @@ +using Rewrite.RewriteCSharp.Format; + +namespace Rewrite.CSharp.Tests.Formatter; +using static Assertions; + +public class AutoFormatterTests(ITestOutputHelper output) : RewriteTest(output) +{ + protected override void Defaults(RecipeSpec spec) + { + spec.Recipe = new AutoFormatRecipe(); + } + + [Fact] + public void FormatBasic() + { + RewriteRun(CSharp( + before: """ + public class Foo { public int A { get; set; } } + """, + after: """ + public class Foo + { + public int A { get; set; } + } + """)); + } + + [Fact] + public void PartialFormat() + { + var spec = CSharp( + before: """ + public class Foo{ + public int A { get; set; } + } + """, + after: """ + public class Foo{ + public int A { get; set; } + } + """); + var beforeLst = CSharpParser.Instance.Parse(spec.Before!); + var formatTarget = beforeLst.Descendents().OfType().First()!; + var visitor = new AutoFormatVisitor(formatTarget); + var afterLst = visitor.Visit(beforeLst, 0)!; + var actual = afterLst.ToString(); + var expected = spec.After; + actual.ShouldBeSameAs(expected); + + } +} diff --git a/Rewrite/tests/Rewrite.CSharp.Tests/PlayTests.cs b/Rewrite/tests/Rewrite.CSharp.Tests/PlayTests.cs index 18bbc8c3..6ea96dc8 100644 --- a/Rewrite/tests/Rewrite.CSharp.Tests/PlayTests.cs +++ b/Rewrite/tests/Rewrite.CSharp.Tests/PlayTests.cs @@ -1,15 +1,22 @@ -namespace Rewrite.CSharp.Tests; +using System.Text.RegularExpressions; +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.CSharp; +using Microsoft.CodeAnalysis.Formatting; +using Microsoft.CodeAnalysis.Text; +using Rewrite.Core.Marker; + +namespace Rewrite.CSharp.Tests; [Exploratory] -public class PlayTests(ITestOutputHelper output) : RewriteTest(output) +public class PlayTests(ITestOutputHelper output) : RewriteTest(output) { /// /// Some pretty print tests for string delta report /// [Theory] [Exploratory] - [InlineData("abc\n123","abc123")] - [InlineData("abc123","abc134")] + [InlineData("abc\n123", "abc123")] + [InlineData("abc123", "abc134")] [InlineData(""" one two @@ -34,17 +41,18 @@ public void Delta(string before, string after) public void MyTest() { var root = new CSharpParser.Builder().Build().Parse( - """ - /*1*/ - a/*2*/ - .FirstOrDefault()/*3*/?/*4*/ - ./*5*/GetCustomAttribute(1)/*6*/?/*7*/./*8*/Name; - """ + """ + /*1*/ + a/*2*/ + .FirstOrDefault()/*3*/?/*4*/ + ./*5*/GetCustomAttribute(1)/*6*/?/*7*/./*8*/Name; + """ ); if (root is ParseError) { } + _output.WriteLine(root.ToString()); } @@ -65,4 +73,28 @@ void Main() var node = root.Descendents().OfType().First().Body!.Statements[0]; _output.WriteLine(node.ToString()); } + + [Fact] + [Exploratory] + public void TestCursor() + { + var node = CSharpParser.Instance.Parse( + """ + public class Foo + { + int _field = 1; + } + """ + ); + var visitor = new TestVisitor(); + visitor.Visit(node, 0); + } + class TestVisitor : CSharpIsoVisitor + { + protected override JRightPadded? VisitRightPadded(JRightPadded? right, CsRightPadded.Location loc, int p) + { + return base.VisitRightPadded(right, loc, p); + } + } + } diff --git a/Rewrite/tests/Rewrite.CSharp.Tests/Rewrite.CSharp.Tests.csproj b/Rewrite/tests/Rewrite.CSharp.Tests/Rewrite.CSharp.Tests.csproj index 189c7507..492d6b74 100644 --- a/Rewrite/tests/Rewrite.CSharp.Tests/Rewrite.CSharp.Tests.csproj +++ b/Rewrite/tests/Rewrite.CSharp.Tests/Rewrite.CSharp.Tests.csproj @@ -16,8 +16,8 @@ - - + + diff --git a/Rewrite/tests/Rewrite.CSharp.Tests/Tree/ClassDeclarationTests.cs b/Rewrite/tests/Rewrite.CSharp.Tests/Tree/ClassDeclarationTests.cs index 85274079..92d8f676 100644 --- a/Rewrite/tests/Rewrite.CSharp.Tests/Tree/ClassDeclarationTests.cs +++ b/Rewrite/tests/Rewrite.CSharp.Tests/Tree/ClassDeclarationTests.cs @@ -7,6 +7,24 @@ namespace Rewrite.CSharp.Tests.Tree; public class ClassDeclarationTests(ITestOutputHelper output) : RewriteTest(output) { + [Fact] + public void BaseParameters() + { + RewriteRun( + CSharp( + """ + class PlayTests(ITestOutputHelper output) : RewriteTest( output ) { + + } + """, c => + { + c.AfterRecipe = comp => { _output.WriteLine(comp.ToString()); }; + } + ) + ); + } + + [Fact] public void ModifierAndClassWithoutBody() { From 5c0a26e57a069498cc1598a86395ea2a768f96fe Mon Sep 17 00:00:00 2001 From: Andrew Stakhov Date: Mon, 24 Mar 2025 13:03:19 -0400 Subject: [PATCH 02/11] Bump version --- version.json | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/version.json b/version.json index 54f38b41..d4ff1774 100644 --- a/version.json +++ b/version.json @@ -1,6 +1,6 @@ { "$schema": "https://raw.githubusercontent.com/AArnott/Nerdbank.GitVersioning/master/src/NerdBank.GitVersioning/version.schema.json", - "version": "0.9", + "version": "0.24", "publicReleaseRefSpec": [ "^refs/heads/main$" ], @@ -10,4 +10,4 @@ } }, "buildNumberOffset": -1 -} \ No newline at end of file +} From 3d70908f725dbe4342e423113c3a3dfaf16cc3ac Mon Sep 17 00:00:00 2001 From: Andrew Stakhov Date: Mon, 24 Mar 2025 18:07:15 -0400 Subject: [PATCH 03/11] Collapse remoting into this repo. Add nuke build automation --- .github/workflows/ci.yml | 27 +- .nuke/build.schema.json | 51 +- .nuke/parameters.json | 2 +- Rewrite/Directory.Build.props | 7 +- Rewrite/Directory.Build.targets | 7 +- Rewrite/Rewrite.Sources.sln | 171 ---- Rewrite/Rewrite.Sources.v3.ncrunchsolution | 8 - Rewrite/Rewrite.sln | 124 ++- Rewrite/Rewrite.v3.ncrunchsolution | 8 - Rewrite/openrewrite-icon.png | Bin 0 -> 512 bytes Rewrite/openrewrite-icon.svg | 4 + Rewrite/src/ClearBinObjFolders.bat | 4 + .../Rewrite.Analyzers.csproj | 2 + .../Rewrite.Analyzers/openrewrite-icon.png | Bin 0 -> 512 bytes Rewrite/src/Rewrite.MSBuild/Dependency.cs | 7 + .../src/Rewrite.MSBuild/DependencyInsight.cs | 66 ++ .../InstallableRemotingRecipe.cs | 10 + .../Marker/ProjectDependencies.cs | 9 + Rewrite/src/Rewrite.MSBuild/NugetManager.cs | 536 ++++++++++ Rewrite/src/Rewrite.MSBuild/ProjectContext.cs | 42 + .../ProjectDependencyResolver.cs | 158 +++ Rewrite/src/Rewrite.MSBuild/ProjectParser.cs | 112 +++ .../Rewrite.MSBuild/Rewrite.MSBuild.csproj | 28 + Rewrite/src/Rewrite.MSBuild/SolutionParser.cs | 69 ++ .../Rewrite.Remote.Codec.csproj | 27 +- Rewrite/src/Rewrite.Remote.Server/Options.cs | 23 + .../Rewrite.Remote.Server.csproj | 29 + Rewrite/src/Rewrite.Remote.Server/Server.cs | 534 ++++++++++ Rewrite/src/Rewrite.Remote/DiffEvent.cs | 14 + Rewrite/src/Rewrite.Remote/IRemotingClient.cs | 11 + .../src/Rewrite.Remote/IRemotingContext.cs | 30 + Rewrite/src/Rewrite.Remote/JsonReceiver.cs | 91 ++ Rewrite/src/Rewrite.Remote/JsonSender.cs | 95 ++ Rewrite/src/Rewrite.Remote/OmniReceiver.cs | 30 + Rewrite/src/Rewrite.Remote/OmniSender.cs | 12 + .../src/Rewrite.Remote/ParseErrorReceiver.cs | 70 ++ .../src/Rewrite.Remote/ParseErrorSender.cs | 38 + Rewrite/src/Rewrite.Remote/Receiver.cs | 9 + Rewrite/src/Rewrite.Remote/ReceiverContext.cs | 145 +++ Rewrite/src/Rewrite.Remote/ReceiverFactory.cs | 8 + Rewrite/src/Rewrite.Remote/RemotePrinter.cs | 14 + .../Rewrite.Remote/RemotePrinterFactory.cs | 11 + Rewrite/src/Rewrite.Remote/RemoteUtils.cs | 334 ++++++ Rewrite/src/Rewrite.Remote/RemotingClient.cs | 52 + Rewrite/src/Rewrite.Remote/RemotingContext.cs | 79 ++ .../RemotingExecutionContextView.cs | 29 + .../src/Rewrite.Remote/RemotingMessageType.cs | 6 + .../src/Rewrite.Remote/RemotingMessenger.cs | 299 ++++++ .../src/Rewrite.Remote/Rewrite.Remote.csproj | 28 + Rewrite/src/Rewrite.Remote/Sender.cs | 8 + Rewrite/src/Rewrite.Remote/SenderContext.cs | 313 ++++++ Rewrite/src/Rewrite.Remote/TreeReceiver.cs | 7 + Rewrite/src/Rewrite.Remote/TreeSender.cs | 8 + Rewrite/src/Rewrite.Remote/TypeComparer.cs | 9 + Rewrite/src/Rewrite.Remote/TypeUtils.cs | 132 +++ .../src/Rewrite.Remote/ValueDeserializer.cs | 257 +++++ Rewrite/src/Rewrite.Remote/ValueSerializer.cs | 218 ++++ .../src/Rewrite.Server/Rewrite.Server.csproj | 11 +- .../Rewrite.Test.Engine.Remote.csproj | 8 +- Rewrite/src/Rewrite.Test/EnvironmentInfo.cs | 6 + Rewrite/src/Rewrite.Test/RewriteTest.cs | 6 +- _build/Build.cs | 102 +- _build/GitRepositoryAttribute.cs | 33 + _build/_build.csproj | 4 +- build.ps1 | 2 +- build.sh | 2 +- .../java/org/openrewrite/csharp/tree/Cs.java | 950 +++++++++--------- 67 files changed, 4775 insertions(+), 771 deletions(-) delete mode 100644 Rewrite/Rewrite.Sources.sln delete mode 100644 Rewrite/Rewrite.Sources.v3.ncrunchsolution delete mode 100644 Rewrite/Rewrite.v3.ncrunchsolution create mode 100644 Rewrite/openrewrite-icon.png create mode 100644 Rewrite/openrewrite-icon.svg create mode 100644 Rewrite/src/ClearBinObjFolders.bat create mode 100644 Rewrite/src/Rewrite.Analyzers/openrewrite-icon.png create mode 100644 Rewrite/src/Rewrite.MSBuild/Dependency.cs create mode 100644 Rewrite/src/Rewrite.MSBuild/DependencyInsight.cs create mode 100644 Rewrite/src/Rewrite.MSBuild/InstallableRemotingRecipe.cs create mode 100644 Rewrite/src/Rewrite.MSBuild/Marker/ProjectDependencies.cs create mode 100644 Rewrite/src/Rewrite.MSBuild/NugetManager.cs create mode 100644 Rewrite/src/Rewrite.MSBuild/ProjectContext.cs create mode 100644 Rewrite/src/Rewrite.MSBuild/ProjectDependencyResolver.cs create mode 100644 Rewrite/src/Rewrite.MSBuild/ProjectParser.cs create mode 100644 Rewrite/src/Rewrite.MSBuild/Rewrite.MSBuild.csproj create mode 100644 Rewrite/src/Rewrite.MSBuild/SolutionParser.cs create mode 100644 Rewrite/src/Rewrite.Remote.Server/Options.cs create mode 100644 Rewrite/src/Rewrite.Remote.Server/Rewrite.Remote.Server.csproj create mode 100644 Rewrite/src/Rewrite.Remote.Server/Server.cs create mode 100644 Rewrite/src/Rewrite.Remote/DiffEvent.cs create mode 100644 Rewrite/src/Rewrite.Remote/IRemotingClient.cs create mode 100644 Rewrite/src/Rewrite.Remote/IRemotingContext.cs create mode 100644 Rewrite/src/Rewrite.Remote/JsonReceiver.cs create mode 100644 Rewrite/src/Rewrite.Remote/JsonSender.cs create mode 100644 Rewrite/src/Rewrite.Remote/OmniReceiver.cs create mode 100644 Rewrite/src/Rewrite.Remote/OmniSender.cs create mode 100644 Rewrite/src/Rewrite.Remote/ParseErrorReceiver.cs create mode 100644 Rewrite/src/Rewrite.Remote/ParseErrorSender.cs create mode 100644 Rewrite/src/Rewrite.Remote/Receiver.cs create mode 100644 Rewrite/src/Rewrite.Remote/ReceiverContext.cs create mode 100644 Rewrite/src/Rewrite.Remote/ReceiverFactory.cs create mode 100644 Rewrite/src/Rewrite.Remote/RemotePrinter.cs create mode 100644 Rewrite/src/Rewrite.Remote/RemotePrinterFactory.cs create mode 100644 Rewrite/src/Rewrite.Remote/RemoteUtils.cs create mode 100644 Rewrite/src/Rewrite.Remote/RemotingClient.cs create mode 100644 Rewrite/src/Rewrite.Remote/RemotingContext.cs create mode 100644 Rewrite/src/Rewrite.Remote/RemotingExecutionContextView.cs create mode 100644 Rewrite/src/Rewrite.Remote/RemotingMessageType.cs create mode 100644 Rewrite/src/Rewrite.Remote/RemotingMessenger.cs create mode 100644 Rewrite/src/Rewrite.Remote/Rewrite.Remote.csproj create mode 100644 Rewrite/src/Rewrite.Remote/Sender.cs create mode 100644 Rewrite/src/Rewrite.Remote/SenderContext.cs create mode 100644 Rewrite/src/Rewrite.Remote/TreeReceiver.cs create mode 100644 Rewrite/src/Rewrite.Remote/TreeSender.cs create mode 100644 Rewrite/src/Rewrite.Remote/TypeComparer.cs create mode 100644 Rewrite/src/Rewrite.Remote/TypeUtils.cs create mode 100644 Rewrite/src/Rewrite.Remote/ValueDeserializer.cs create mode 100644 Rewrite/src/Rewrite.Remote/ValueSerializer.cs create mode 100644 Rewrite/src/Rewrite.Test/EnvironmentInfo.cs create mode 100644 _build/GitRepositoryAttribute.cs diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index cefc8c8b..5f4bac96 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -24,6 +24,7 @@ env: GRADLE_ENTERPRISE_CACHE_USERNAME: ${{ secrets.gradle_enterprise_cache_username }} GRADLE_ENTERPRISE_CACHE_PASSWORD: ${{ secrets.gradle_enterprise_cache_password }} RELEASE_BUILD: "true" + CI: true jobs: build: @@ -52,9 +53,21 @@ jobs: ./gradlew ${{ env.GRADLE_SWITCHES }} assemble (cd Rewrite && dotnet restore Rewrite.sln --no-cache --force --force-evaluate) (cd Rewrite && dotnet publish Rewrite.sln --no-restore) - - name: test + + - name: DotNet Tests + run: | + ./build.sh Test + + - name: Report .NET Test Results + if: always() + uses: dorny/test-reporter@v1 + with: + name: Unit Tests + path: artifacts/test-results/*.trx + reporter: dotnet-trx + + - name: Java Tests run: | - (cd Rewrite && dotnet test Rewrite.sln --filter "Category!=KnownBug & Category!=Exploratory & Category!=Roslyn") ./gradlew ${{ env.GRADLE_SWITCHES }} test - name: publish-java-snapshots @@ -66,12 +79,10 @@ jobs: ORG_GRADLE_PROJECT_signingKey: ${{ secrets.OSSRH_SIGNING_KEY }} ORG_GRADLE_PROJECT_signingPassword: ${{ secrets.OSSRH_SIGNING_PASSWORD }} - - name: publish-dotnet-snapshots + - name: dotnet-ci-build if: github.event_name != 'pull_request' - run: | - cd Rewrite - mkdir ~/localNugetFeed - dotnet pack --version-suffix rc.${{ github.run_number }} --output ~/localNuGetFeed Rewrite.sln - dotnet nuget push ~/localNuGetFeed/*.nupkg --source https://api.nuget.org/v3/index.json --api-key ${{env.NUGET_API_KEY}} + run: ./build.sh CIBuild env: NUGET_API_KEY: ${{ secrets.NUGET_API_KEY }} + + diff --git a/.nuke/build.schema.json b/.nuke/build.schema.json index d14111c6..d338ce23 100644 --- a/.nuke/build.schema.json +++ b/.nuke/build.schema.json @@ -1,19 +1,5 @@ { "$schema": "http://json-schema.org/draft-04/schema#", - "properties": { - "Configuration": { - "type": "string", - "description": "Configuration to build - Default is 'Debug' (local) or 'Release' (server)", - "enum": [ - "Debug", - "Release" - ] - }, - "Solution": { - "type": "string", - "description": "Path to a solution file that is automatically loaded" - } - }, "definitions": { "Host": { "type": "string", @@ -38,11 +24,16 @@ "ExecutableTarget": { "type": "string", "enum": [ + "CIBuild", + "CIRelease", "Clean", "Compile", "DownloadTestFixtures", + "GradleAssemble", + "NugetPush", "Pack", - "Restore" + "Restore", + "Test" ] }, "Verbosity": { @@ -113,5 +104,33 @@ } } }, - "$ref": "#/definitions/NukeBuild" + "allOf": [ + { + "properties": { + "Configuration": { + "type": "string", + "description": "Configuration to build - Default is 'Debug' (local) or 'Release' (server)", + "enum": [ + "Debug", + "Release" + ] + }, + "NugetApiKey": { + "type": "string", + "description": "ApiKey for the specified source", + "default": "Secrets must be entered via 'nuke :secrets [profile]'" + }, + "NugetFeed": { + "type": "string" + }, + "Solution": { + "type": "string", + "description": "Path to a solution file that is automatically loaded" + } + } + }, + { + "$ref": "#/definitions/NukeBuild" + } + ] } diff --git a/.nuke/parameters.json b/.nuke/parameters.json index 9371a4a8..c63d65aa 100644 --- a/.nuke/parameters.json +++ b/.nuke/parameters.json @@ -1,4 +1,4 @@ { "$schema": "build.schema.json", - "Solution": "Rewrite/Rewrite.Sources.sln" + "Solution": "Rewrite/Rewrite.sln" } diff --git a/Rewrite/Directory.Build.props b/Rewrite/Directory.Build.props index 52ac96a1..a6f1d5c8 100644 --- a/Rewrite/Directory.Build.props +++ b/Rewrite/Directory.Build.props @@ -11,18 +11,19 @@ openrewrite.png Apache-2.0 0.23.0 - ..\..\..\..\..\moderneinc\rewrite-remote\Rewrite.Remote - True + False False True true + true + snupkg - 0.18.1 4.12.0 + diff --git a/Rewrite/Directory.Build.targets b/Rewrite/Directory.Build.targets index fad66aef..b843cab1 100644 --- a/Rewrite/Directory.Build.targets +++ b/Rewrite/Directory.Build.targets @@ -1,6 +1,6 @@ - + @@ -9,9 +9,10 @@ + diff --git a/Rewrite/Rewrite.Sources.sln b/Rewrite/Rewrite.Sources.sln deleted file mode 100644 index 4a0682fa..00000000 --- a/Rewrite/Rewrite.Sources.sln +++ /dev/null @@ -1,171 +0,0 @@ - -Microsoft Visual Studio Solution File, Format Version 12.00 -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rewrite.Core", "src\Rewrite.Core\Rewrite.Core.csproj", "{FB30394C-7930-4BFF-97E2-400CFADE92C2}" -EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rewrite.Properties", "src\Rewrite.Properties\Rewrite.Properties.csproj", "{C7E280C5-E841-4690-8AA3-653ECBC7C78B}" -EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rewrite.Yaml", "src\Rewrite.Yaml\Rewrite.Yaml.csproj", "{F7F4F27F-2CAE-422B-B6CE-25A88C3603A1}" -EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rewrite.Xml", "src\Rewrite.Xml\Rewrite.Xml.csproj", "{D38BB305-3276-4AE1-87B1-C19C7A9F3840}" -EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rewrite.Json", "src\Rewrite.Json\Rewrite.Json.csproj", "{5DD7D88A-5A10-457D-B1A2-30F7CF67AD9F}" -EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rewrite.Java", "src\Rewrite.Java\Rewrite.Java.csproj", "{06BCC1C7-9D8C-4D3B-934D-072C35A5C984}" -EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rewrite.CSharp", "src\Rewrite.CSharp\Rewrite.CSharp.csproj", "{25208A27-E598-4BE3-9CD9-0618A6B9598F}" -EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rewrite.CSharp.Tests", "tests\Rewrite.CSharp.Tests\Rewrite.CSharp.Tests.csproj", "{25EEACCB-9BAE-4361-A980-9E9CDA37602E}" -EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rewrite.Test", "src\Rewrite.Test\Rewrite.Test.csproj", "{D3F48947-C702-4D1A-B6EE-96B89D13953D}" -EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rewrite.Server", "src\Rewrite.Server\Rewrite.Server.csproj", "{D3F48947-C702-4D1A-B6EE-96B89D13953E}" -EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{C7A4A8F9-0343-4A3E-AB77-101C458C23B5}" -EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{7B268266-B9CD-4D85-ABC5-3B2C4611FD74}" -EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "_solution", "_solution", "{B5C675AF-506B-47E6-AB10-4E7BC36531D2}" - ProjectSection(SolutionItems) = preProject - .gitignore = .gitignore - Directory.Build.props = Directory.Build.props - Directory.Build.targets = Directory.Build.targets - README.md = README.md - Directory.Build.props.user = Directory.Build.props.user - EndProjectSection -EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "commercial", "commercial", "{45B6292D-DC7E-46A7-A86E-7455BBEAED70}" -EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rewrite.Remote", "..\..\..\moderneinc\rewrite-remote\Rewrite.Remote\src\Rewrite.Remote\Rewrite.Remote.csproj", "{0E364862-1ACA-4C94-8EA0-23724FF67AA2}" -EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rewrite.MSBuild", "..\..\..\moderneinc\rewrite-remote\Rewrite.Remote\src\Rewrite.MSBuild\Rewrite.MSBuild.csproj", "{DE03049F-95A3-483F-939C-C2325548D590}" -EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "_build", "..\_build\_build.csproj", "{C714F4F1-E2DF-4B29-A277-9B40BD7DE406}" -EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rewrite.Remote.Codec", "src\Rewrite.Remote.Codec\Rewrite.Remote.Codec.csproj", "{40C71491-3CCC-40A0-8F01-3EC7204CF85F}" -EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rewrite.Test.CSharp", "src\Rewrite.Test.CSharp\Rewrite.Test.CSharp.csproj", "{5C70ACE0-BE37-4D67-A67F-EE69767994D2}" -EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rewrite.Test.Engine.Remote", "src\Rewrite.Test.Engine.Remote\Rewrite.Test.Engine.Remote.csproj", "{C04C7CA4-69C3-444F-A654-6C722A0FC3BE}" -EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rewrite.Remote.Server", "..\..\..\moderneinc\rewrite-remote\Rewrite.Remote\src\Rewrite.Remote.Server\Rewrite.Remote.Server.csproj", "{E0721BA1-2772-4486-BDF3-FC9301723BB9}" -EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rewrite.Analyzers", "src\Rewrite.Analyzers\Rewrite.Analyzers.csproj", "{9818146E-C516-4D3C-80CE-A84741E7772B}" -EndProject -Global - GlobalSection(SolutionConfigurationPlatforms) = preSolution - Debug|Any CPU = Debug|Any CPU - Release|Any CPU = Release|Any CPU - Analyzers|Any CPU = Analyzers|Any CPU - EndGlobalSection - GlobalSection(ProjectConfigurationPlatforms) = postSolution - {C714F4F1-E2DF-4B29-A277-9B40BD7DE406}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {C714F4F1-E2DF-4B29-A277-9B40BD7DE406}.Release|Any CPU.ActiveCfg = Release|Any CPU - {C714F4F1-E2DF-4B29-A277-9B40BD7DE406}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU - {FB30394C-7930-4BFF-97E2-400CFADE92C2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {FB30394C-7930-4BFF-97E2-400CFADE92C2}.Release|Any CPU.ActiveCfg = Release|Any CPU - {FB30394C-7930-4BFF-97E2-400CFADE92C2}.Release|Any CPU.Build.0 = Release|Any CPU - {FB30394C-7930-4BFF-97E2-400CFADE92C2}.Debug|Any CPU.Build.0 = Debug|Any CPU - {FB30394C-7930-4BFF-97E2-400CFADE92C2}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU - {C7E280C5-E841-4690-8AA3-653ECBC7C78B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {C7E280C5-E841-4690-8AA3-653ECBC7C78B}.Release|Any CPU.ActiveCfg = Release|Any CPU - {C7E280C5-E841-4690-8AA3-653ECBC7C78B}.Release|Any CPU.Build.0 = Release|Any CPU - {C7E280C5-E841-4690-8AA3-653ECBC7C78B}.Debug|Any CPU.Build.0 = Debug|Any CPU - {C7E280C5-E841-4690-8AA3-653ECBC7C78B}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU - {F7F4F27F-2CAE-422B-B6CE-25A88C3603A1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {F7F4F27F-2CAE-422B-B6CE-25A88C3603A1}.Release|Any CPU.ActiveCfg = Release|Any CPU - {F7F4F27F-2CAE-422B-B6CE-25A88C3603A1}.Release|Any CPU.Build.0 = Release|Any CPU - {F7F4F27F-2CAE-422B-B6CE-25A88C3603A1}.Debug|Any CPU.Build.0 = Debug|Any CPU - {F7F4F27F-2CAE-422B-B6CE-25A88C3603A1}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU - {D38BB305-3276-4AE1-87B1-C19C7A9F3840}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {D38BB305-3276-4AE1-87B1-C19C7A9F3840}.Release|Any CPU.ActiveCfg = Release|Any CPU - {D38BB305-3276-4AE1-87B1-C19C7A9F3840}.Release|Any CPU.Build.0 = Release|Any CPU - {D38BB305-3276-4AE1-87B1-C19C7A9F3840}.Debug|Any CPU.Build.0 = Debug|Any CPU - {D38BB305-3276-4AE1-87B1-C19C7A9F3840}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU - {5DD7D88A-5A10-457D-B1A2-30F7CF67AD9F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {5DD7D88A-5A10-457D-B1A2-30F7CF67AD9F}.Release|Any CPU.ActiveCfg = Release|Any CPU - {5DD7D88A-5A10-457D-B1A2-30F7CF67AD9F}.Release|Any CPU.Build.0 = Release|Any CPU - {5DD7D88A-5A10-457D-B1A2-30F7CF67AD9F}.Debug|Any CPU.Build.0 = Debug|Any CPU - {5DD7D88A-5A10-457D-B1A2-30F7CF67AD9F}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU - {06BCC1C7-9D8C-4D3B-934D-072C35A5C984}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {06BCC1C7-9D8C-4D3B-934D-072C35A5C984}.Release|Any CPU.ActiveCfg = Release|Any CPU - {06BCC1C7-9D8C-4D3B-934D-072C35A5C984}.Release|Any CPU.Build.0 = Release|Any CPU - {06BCC1C7-9D8C-4D3B-934D-072C35A5C984}.Debug|Any CPU.Build.0 = Debug|Any CPU - {06BCC1C7-9D8C-4D3B-934D-072C35A5C984}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU - {25208A27-E598-4BE3-9CD9-0618A6B9598F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {25208A27-E598-4BE3-9CD9-0618A6B9598F}.Release|Any CPU.ActiveCfg = Release|Any CPU - {25208A27-E598-4BE3-9CD9-0618A6B9598F}.Release|Any CPU.Build.0 = Release|Any CPU - {25208A27-E598-4BE3-9CD9-0618A6B9598F}.Debug|Any CPU.Build.0 = Debug|Any CPU - {25208A27-E598-4BE3-9CD9-0618A6B9598F}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU - {25EEACCB-9BAE-4361-A980-9E9CDA37602E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {25EEACCB-9BAE-4361-A980-9E9CDA37602E}.Release|Any CPU.ActiveCfg = Release|Any CPU - {25EEACCB-9BAE-4361-A980-9E9CDA37602E}.Release|Any CPU.Build.0 = Release|Any CPU - {25EEACCB-9BAE-4361-A980-9E9CDA37602E}.Debug|Any CPU.Build.0 = Debug|Any CPU - {25EEACCB-9BAE-4361-A980-9E9CDA37602E}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU - {D3F48947-C702-4D1A-B6EE-96B89D13953D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {D3F48947-C702-4D1A-B6EE-96B89D13953D}.Release|Any CPU.ActiveCfg = Release|Any CPU - {D3F48947-C702-4D1A-B6EE-96B89D13953D}.Release|Any CPU.Build.0 = Release|Any CPU - {D3F48947-C702-4D1A-B6EE-96B89D13953D}.Debug|Any CPU.Build.0 = Debug|Any CPU - {D3F48947-C702-4D1A-B6EE-96B89D13953D}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU - {D3F48947-C702-4D1A-B6EE-96B89D13953E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {D3F48947-C702-4D1A-B6EE-96B89D13953E}.Release|Any CPU.ActiveCfg = Release|Any CPU - {D3F48947-C702-4D1A-B6EE-96B89D13953E}.Release|Any CPU.Build.0 = Release|Any CPU - {D3F48947-C702-4D1A-B6EE-96B89D13953E}.Debug|Any CPU.Build.0 = Debug|Any CPU - {D3F48947-C702-4D1A-B6EE-96B89D13953E}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU - {0E364862-1ACA-4C94-8EA0-23724FF67AA2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {0E364862-1ACA-4C94-8EA0-23724FF67AA2}.Release|Any CPU.ActiveCfg = Release|Any CPU - {0E364862-1ACA-4C94-8EA0-23724FF67AA2}.Release|Any CPU.Build.0 = Release|Any CPU - {0E364862-1ACA-4C94-8EA0-23724FF67AA2}.Debug|Any CPU.Build.0 = Debug|Any CPU - {0E364862-1ACA-4C94-8EA0-23724FF67AA2}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU - {DE03049F-95A3-483F-939C-C2325548D590}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {DE03049F-95A3-483F-939C-C2325548D590}.Release|Any CPU.ActiveCfg = Release|Any CPU - {DE03049F-95A3-483F-939C-C2325548D590}.Release|Any CPU.Build.0 = Release|Any CPU - {DE03049F-95A3-483F-939C-C2325548D590}.Debug|Any CPU.Build.0 = Debug|Any CPU - {DE03049F-95A3-483F-939C-C2325548D590}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU - {40C71491-3CCC-40A0-8F01-3EC7204CF85F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {40C71491-3CCC-40A0-8F01-3EC7204CF85F}.Release|Any CPU.ActiveCfg = Release|Any CPU - {40C71491-3CCC-40A0-8F01-3EC7204CF85F}.Release|Any CPU.Build.0 = Release|Any CPU - {40C71491-3CCC-40A0-8F01-3EC7204CF85F}.Debug|Any CPU.Build.0 = Debug|Any CPU - {40C71491-3CCC-40A0-8F01-3EC7204CF85F}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU - {5C70ACE0-BE37-4D67-A67F-EE69767994D2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {5C70ACE0-BE37-4D67-A67F-EE69767994D2}.Release|Any CPU.ActiveCfg = Release|Any CPU - {5C70ACE0-BE37-4D67-A67F-EE69767994D2}.Release|Any CPU.Build.0 = Release|Any CPU - {5C70ACE0-BE37-4D67-A67F-EE69767994D2}.Debug|Any CPU.Build.0 = Debug|Any CPU - {5C70ACE0-BE37-4D67-A67F-EE69767994D2}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU - {C04C7CA4-69C3-444F-A654-6C722A0FC3BE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {C04C7CA4-69C3-444F-A654-6C722A0FC3BE}.Release|Any CPU.ActiveCfg = Release|Any CPU - {C04C7CA4-69C3-444F-A654-6C722A0FC3BE}.Release|Any CPU.Build.0 = Release|Any CPU - {C04C7CA4-69C3-444F-A654-6C722A0FC3BE}.Debug|Any CPU.Build.0 = Debug|Any CPU - {C04C7CA4-69C3-444F-A654-6C722A0FC3BE}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU - {E0721BA1-2772-4486-BDF3-FC9301723BB9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {E0721BA1-2772-4486-BDF3-FC9301723BB9}.Release|Any CPU.ActiveCfg = Release|Any CPU - {E0721BA1-2772-4486-BDF3-FC9301723BB9}.Release|Any CPU.Build.0 = Release|Any CPU - {E0721BA1-2772-4486-BDF3-FC9301723BB9}.Debug|Any CPU.Build.0 = Debug|Any CPU - {E0721BA1-2772-4486-BDF3-FC9301723BB9}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU - {9818146E-C516-4D3C-80CE-A84741E7772B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {9818146E-C516-4D3C-80CE-A84741E7772B}.Debug|Any CPU.Build.0 = Debug|Any CPU - {9818146E-C516-4D3C-80CE-A84741E7772B}.Release|Any CPU.ActiveCfg = Release|Any CPU - {9818146E-C516-4D3C-80CE-A84741E7772B}.Release|Any CPU.Build.0 = Release|Any CPU - {9818146E-C516-4D3C-80CE-A84741E7772B}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU - {9818146E-C516-4D3C-80CE-A84741E7772B}.Analyzers|Any CPU.Build.0 = Debug|Any CPU - EndGlobalSection - GlobalSection(NestedProjects) = preSolution - {25EEACCB-9BAE-4361-A980-9E9CDA37602E} = {7B268266-B9CD-4D85-ABC5-3B2C4611FD74} - {FB30394C-7930-4BFF-97E2-400CFADE92C2} = {C7A4A8F9-0343-4A3E-AB77-101C458C23B5} - {25208A27-E598-4BE3-9CD9-0618A6B9598F} = {C7A4A8F9-0343-4A3E-AB77-101C458C23B5} - {06BCC1C7-9D8C-4D3B-934D-072C35A5C984} = {C7A4A8F9-0343-4A3E-AB77-101C458C23B5} - {5DD7D88A-5A10-457D-B1A2-30F7CF67AD9F} = {C7A4A8F9-0343-4A3E-AB77-101C458C23B5} - {C7E280C5-E841-4690-8AA3-653ECBC7C78B} = {C7A4A8F9-0343-4A3E-AB77-101C458C23B5} - {D3F48947-C702-4D1A-B6EE-96B89D13953D} = {C7A4A8F9-0343-4A3E-AB77-101C458C23B5} - {D3F48947-C702-4D1A-B6EE-96B89D13953E} = {C7A4A8F9-0343-4A3E-AB77-101C458C23B5} - {D38BB305-3276-4AE1-87B1-C19C7A9F3840} = {C7A4A8F9-0343-4A3E-AB77-101C458C23B5} - {F7F4F27F-2CAE-422B-B6CE-25A88C3603A1} = {C7A4A8F9-0343-4A3E-AB77-101C458C23B5} - {0E364862-1ACA-4C94-8EA0-23724FF67AA2} = {45B6292D-DC7E-46A7-A86E-7455BBEAED70} - {DE03049F-95A3-483F-939C-C2325548D590} = {45B6292D-DC7E-46A7-A86E-7455BBEAED70} - {C714F4F1-E2DF-4B29-A277-9B40BD7DE406} = {B5C675AF-506B-47E6-AB10-4E7BC36531D2} - {40C71491-3CCC-40A0-8F01-3EC7204CF85F} = {C7A4A8F9-0343-4A3E-AB77-101C458C23B5} - {5C70ACE0-BE37-4D67-A67F-EE69767994D2} = {C7A4A8F9-0343-4A3E-AB77-101C458C23B5} - {C04C7CA4-69C3-444F-A654-6C722A0FC3BE} = {C7A4A8F9-0343-4A3E-AB77-101C458C23B5} - {E0721BA1-2772-4486-BDF3-FC9301723BB9} = {45B6292D-DC7E-46A7-A86E-7455BBEAED70} - {9818146E-C516-4D3C-80CE-A84741E7772B} = {C7A4A8F9-0343-4A3E-AB77-101C458C23B5} - EndGlobalSection -EndGlobal diff --git a/Rewrite/Rewrite.Sources.v3.ncrunchsolution b/Rewrite/Rewrite.Sources.v3.ncrunchsolution deleted file mode 100644 index 1ef1d71c..00000000 --- a/Rewrite/Rewrite.Sources.v3.ncrunchsolution +++ /dev/null @@ -1,8 +0,0 @@ - - - False - True - True - True - - \ No newline at end of file diff --git a/Rewrite/Rewrite.sln b/Rewrite/Rewrite.sln index 0e394a97..282be8cc 100644 --- a/Rewrite/Rewrite.sln +++ b/Rewrite/Rewrite.sln @@ -14,18 +14,12 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rewrite.Java", "src\Rewrite EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rewrite.CSharp", "src\Rewrite.CSharp\Rewrite.CSharp.csproj", "{25208A27-E598-4BE3-9CD9-0618A6B9598F}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rewrite.Remote.Codec", "src\Rewrite.Remote.Codec\Rewrite.Remote.Codec.csproj", "{25208A27-E598-4BE3-9CD9-0618A6B9598E}" -EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rewrite.CSharp.Tests", "tests\Rewrite.CSharp.Tests\Rewrite.CSharp.Tests.csproj", "{25EEACCB-9BAE-4361-A980-9E9CDA37602E}" EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rewrite.Test", "src\Rewrite.Test\Rewrite.Test.csproj", "{D3F48947-C702-4D1A-B6EE-96B89D13953D}" EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rewrite.Server", "src\Rewrite.Server\Rewrite.Server.csproj", "{D3F48947-C702-4D1A-B6EE-96B89D13953E}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rewrite.Test.CSharp", "src\Rewrite.Test.CSharp\Rewrite.Test.CSharp.csproj", "{3D70D4FA-3BA2-4230-B474-5A70DB23B8CE}" -EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rewrite.Test.Engine.Remote", "src\Rewrite.Test.Engine.Remote\Rewrite.Test.Engine.Remote.csproj", "{6EC419CB-E60B-4F06-A710-B02EA6B9AAAC}" -EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{C7A4A8F9-0343-4A3E-AB77-101C458C23B5}" EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{7B268266-B9CD-4D85-ABC5-3B2C4611FD74}" @@ -37,80 +31,129 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "_solution", "_solution", "{ Directory.Build.targets = Directory.Build.targets README.md = README.md Directory.Build.props.user = Directory.Build.props.user + ..\version.json = ..\version.json EndProjectSection EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rewrite.Analyzers", "src\Rewrite.Analyzers\Rewrite.Analyzers.csproj", "{8623AABC-D198-4D56-B26B-14A503B226E1}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "_build", "..\_build\_build.csproj", "{C714F4F1-E2DF-4B29-A277-9B40BD7DE406}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rewrite.Remote.Codec", "src\Rewrite.Remote.Codec\Rewrite.Remote.Codec.csproj", "{40C71491-3CCC-40A0-8F01-3EC7204CF85F}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rewrite.Test.CSharp", "src\Rewrite.Test.CSharp\Rewrite.Test.CSharp.csproj", "{5C70ACE0-BE37-4D67-A67F-EE69767994D2}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rewrite.Test.Engine.Remote", "src\Rewrite.Test.Engine.Remote\Rewrite.Test.Engine.Remote.csproj", "{C04C7CA4-69C3-444F-A654-6C722A0FC3BE}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rewrite.Analyzers", "src\Rewrite.Analyzers\Rewrite.Analyzers.csproj", "{9818146E-C516-4D3C-80CE-A84741E7772B}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rewrite.Remote", "src\Rewrite.Remote\Rewrite.Remote.csproj", "{EEF136BD-B789-4C0E-BFC7-4D5FD66C5B12}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rewrite.Remote.Server", "src\Rewrite.Remote.Server\Rewrite.Remote.Server.csproj", "{E611118C-2205-4771-A902-0852E2B7301A}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rewrite.MSBuild", "src\Rewrite.MSBuild\Rewrite.MSBuild.csproj", "{E799F5AF-1143-4E84-8787-09A2B0702385}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU Release|Any CPU = Release|Any CPU + Analyzers|Any CPU = Analyzers|Any CPU EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution + {C714F4F1-E2DF-4B29-A277-9B40BD7DE406}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {C714F4F1-E2DF-4B29-A277-9B40BD7DE406}.Release|Any CPU.ActiveCfg = Release|Any CPU + {C714F4F1-E2DF-4B29-A277-9B40BD7DE406}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU {FB30394C-7930-4BFF-97E2-400CFADE92C2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {FB30394C-7930-4BFF-97E2-400CFADE92C2}.Debug|Any CPU.Build.0 = Debug|Any CPU {FB30394C-7930-4BFF-97E2-400CFADE92C2}.Release|Any CPU.ActiveCfg = Release|Any CPU {FB30394C-7930-4BFF-97E2-400CFADE92C2}.Release|Any CPU.Build.0 = Release|Any CPU + {FB30394C-7930-4BFF-97E2-400CFADE92C2}.Debug|Any CPU.Build.0 = Debug|Any CPU + {FB30394C-7930-4BFF-97E2-400CFADE92C2}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU {C7E280C5-E841-4690-8AA3-653ECBC7C78B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {C7E280C5-E841-4690-8AA3-653ECBC7C78B}.Debug|Any CPU.Build.0 = Debug|Any CPU {C7E280C5-E841-4690-8AA3-653ECBC7C78B}.Release|Any CPU.ActiveCfg = Release|Any CPU {C7E280C5-E841-4690-8AA3-653ECBC7C78B}.Release|Any CPU.Build.0 = Release|Any CPU + {C7E280C5-E841-4690-8AA3-653ECBC7C78B}.Debug|Any CPU.Build.0 = Debug|Any CPU + {C7E280C5-E841-4690-8AA3-653ECBC7C78B}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU {F7F4F27F-2CAE-422B-B6CE-25A88C3603A1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {F7F4F27F-2CAE-422B-B6CE-25A88C3603A1}.Debug|Any CPU.Build.0 = Debug|Any CPU {F7F4F27F-2CAE-422B-B6CE-25A88C3603A1}.Release|Any CPU.ActiveCfg = Release|Any CPU {F7F4F27F-2CAE-422B-B6CE-25A88C3603A1}.Release|Any CPU.Build.0 = Release|Any CPU + {F7F4F27F-2CAE-422B-B6CE-25A88C3603A1}.Debug|Any CPU.Build.0 = Debug|Any CPU + {F7F4F27F-2CAE-422B-B6CE-25A88C3603A1}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU {D38BB305-3276-4AE1-87B1-C19C7A9F3840}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {D38BB305-3276-4AE1-87B1-C19C7A9F3840}.Debug|Any CPU.Build.0 = Debug|Any CPU {D38BB305-3276-4AE1-87B1-C19C7A9F3840}.Release|Any CPU.ActiveCfg = Release|Any CPU {D38BB305-3276-4AE1-87B1-C19C7A9F3840}.Release|Any CPU.Build.0 = Release|Any CPU + {D38BB305-3276-4AE1-87B1-C19C7A9F3840}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D38BB305-3276-4AE1-87B1-C19C7A9F3840}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU {5DD7D88A-5A10-457D-B1A2-30F7CF67AD9F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {5DD7D88A-5A10-457D-B1A2-30F7CF67AD9F}.Debug|Any CPU.Build.0 = Debug|Any CPU {5DD7D88A-5A10-457D-B1A2-30F7CF67AD9F}.Release|Any CPU.ActiveCfg = Release|Any CPU {5DD7D88A-5A10-457D-B1A2-30F7CF67AD9F}.Release|Any CPU.Build.0 = Release|Any CPU + {5DD7D88A-5A10-457D-B1A2-30F7CF67AD9F}.Debug|Any CPU.Build.0 = Debug|Any CPU + {5DD7D88A-5A10-457D-B1A2-30F7CF67AD9F}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU {06BCC1C7-9D8C-4D3B-934D-072C35A5C984}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {06BCC1C7-9D8C-4D3B-934D-072C35A5C984}.Debug|Any CPU.Build.0 = Debug|Any CPU {06BCC1C7-9D8C-4D3B-934D-072C35A5C984}.Release|Any CPU.ActiveCfg = Release|Any CPU {06BCC1C7-9D8C-4D3B-934D-072C35A5C984}.Release|Any CPU.Build.0 = Release|Any CPU + {06BCC1C7-9D8C-4D3B-934D-072C35A5C984}.Debug|Any CPU.Build.0 = Debug|Any CPU + {06BCC1C7-9D8C-4D3B-934D-072C35A5C984}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU {25208A27-E598-4BE3-9CD9-0618A6B9598F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {25208A27-E598-4BE3-9CD9-0618A6B9598F}.Debug|Any CPU.Build.0 = Debug|Any CPU {25208A27-E598-4BE3-9CD9-0618A6B9598F}.Release|Any CPU.ActiveCfg = Release|Any CPU {25208A27-E598-4BE3-9CD9-0618A6B9598F}.Release|Any CPU.Build.0 = Release|Any CPU - {25208A27-E598-4BE3-9CD9-0618A6B9598E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {25208A27-E598-4BE3-9CD9-0618A6B9598E}.Debug|Any CPU.Build.0 = Debug|Any CPU - {25208A27-E598-4BE3-9CD9-0618A6B9598E}.Release|Any CPU.ActiveCfg = Release|Any CPU - {25208A27-E598-4BE3-9CD9-0618A6B9598E}.Release|Any CPU.Build.0 = Release|Any CPU + {25208A27-E598-4BE3-9CD9-0618A6B9598F}.Debug|Any CPU.Build.0 = Debug|Any CPU + {25208A27-E598-4BE3-9CD9-0618A6B9598F}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU {25EEACCB-9BAE-4361-A980-9E9CDA37602E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {25EEACCB-9BAE-4361-A980-9E9CDA37602E}.Debug|Any CPU.Build.0 = Debug|Any CPU {25EEACCB-9BAE-4361-A980-9E9CDA37602E}.Release|Any CPU.ActiveCfg = Release|Any CPU {25EEACCB-9BAE-4361-A980-9E9CDA37602E}.Release|Any CPU.Build.0 = Release|Any CPU + {25EEACCB-9BAE-4361-A980-9E9CDA37602E}.Debug|Any CPU.Build.0 = Debug|Any CPU + {25EEACCB-9BAE-4361-A980-9E9CDA37602E}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU {D3F48947-C702-4D1A-B6EE-96B89D13953D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {D3F48947-C702-4D1A-B6EE-96B89D13953D}.Debug|Any CPU.Build.0 = Debug|Any CPU {D3F48947-C702-4D1A-B6EE-96B89D13953D}.Release|Any CPU.ActiveCfg = Release|Any CPU {D3F48947-C702-4D1A-B6EE-96B89D13953D}.Release|Any CPU.Build.0 = Release|Any CPU + {D3F48947-C702-4D1A-B6EE-96B89D13953D}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D3F48947-C702-4D1A-B6EE-96B89D13953D}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU {D3F48947-C702-4D1A-B6EE-96B89D13953E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {D3F48947-C702-4D1A-B6EE-96B89D13953E}.Debug|Any CPU.Build.0 = Debug|Any CPU {D3F48947-C702-4D1A-B6EE-96B89D13953E}.Release|Any CPU.ActiveCfg = Release|Any CPU {D3F48947-C702-4D1A-B6EE-96B89D13953E}.Release|Any CPU.Build.0 = Release|Any CPU - {3D70D4FA-3BA2-4230-B474-5A70DB23B8CE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {3D70D4FA-3BA2-4230-B474-5A70DB23B8CE}.Debug|Any CPU.Build.0 = Debug|Any CPU - {3D70D4FA-3BA2-4230-B474-5A70DB23B8CE}.Release|Any CPU.ActiveCfg = Release|Any CPU - {3D70D4FA-3BA2-4230-B474-5A70DB23B8CE}.Release|Any CPU.Build.0 = Release|Any CPU - {6EC419CB-E60B-4F06-A710-B02EA6B9AAAC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {6EC419CB-E60B-4F06-A710-B02EA6B9AAAC}.Debug|Any CPU.Build.0 = Debug|Any CPU - {6EC419CB-E60B-4F06-A710-B02EA6B9AAAC}.Release|Any CPU.ActiveCfg = Release|Any CPU - {6EC419CB-E60B-4F06-A710-B02EA6B9AAAC}.Release|Any CPU.Build.0 = Release|Any CPU - {8623AABC-D198-4D56-B26B-14A503B226E1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {8623AABC-D198-4D56-B26B-14A503B226E1}.Debug|Any CPU.Build.0 = Debug|Any CPU - {8623AABC-D198-4D56-B26B-14A503B226E1}.Release|Any CPU.ActiveCfg = Release|Any CPU - {8623AABC-D198-4D56-B26B-14A503B226E1}.Release|Any CPU.Build.0 = Release|Any CPU + {D3F48947-C702-4D1A-B6EE-96B89D13953E}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D3F48947-C702-4D1A-B6EE-96B89D13953E}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU + {40C71491-3CCC-40A0-8F01-3EC7204CF85F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {40C71491-3CCC-40A0-8F01-3EC7204CF85F}.Release|Any CPU.ActiveCfg = Release|Any CPU + {40C71491-3CCC-40A0-8F01-3EC7204CF85F}.Release|Any CPU.Build.0 = Release|Any CPU + {40C71491-3CCC-40A0-8F01-3EC7204CF85F}.Debug|Any CPU.Build.0 = Debug|Any CPU + {40C71491-3CCC-40A0-8F01-3EC7204CF85F}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU + {5C70ACE0-BE37-4D67-A67F-EE69767994D2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {5C70ACE0-BE37-4D67-A67F-EE69767994D2}.Release|Any CPU.ActiveCfg = Release|Any CPU + {5C70ACE0-BE37-4D67-A67F-EE69767994D2}.Release|Any CPU.Build.0 = Release|Any CPU + {5C70ACE0-BE37-4D67-A67F-EE69767994D2}.Debug|Any CPU.Build.0 = Debug|Any CPU + {5C70ACE0-BE37-4D67-A67F-EE69767994D2}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU + {C04C7CA4-69C3-444F-A654-6C722A0FC3BE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {C04C7CA4-69C3-444F-A654-6C722A0FC3BE}.Release|Any CPU.ActiveCfg = Release|Any CPU + {C04C7CA4-69C3-444F-A654-6C722A0FC3BE}.Release|Any CPU.Build.0 = Release|Any CPU + {C04C7CA4-69C3-444F-A654-6C722A0FC3BE}.Debug|Any CPU.Build.0 = Debug|Any CPU + {C04C7CA4-69C3-444F-A654-6C722A0FC3BE}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU + {9818146E-C516-4D3C-80CE-A84741E7772B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {9818146E-C516-4D3C-80CE-A84741E7772B}.Debug|Any CPU.Build.0 = Debug|Any CPU + {9818146E-C516-4D3C-80CE-A84741E7772B}.Release|Any CPU.ActiveCfg = Release|Any CPU + {9818146E-C516-4D3C-80CE-A84741E7772B}.Release|Any CPU.Build.0 = Release|Any CPU + {9818146E-C516-4D3C-80CE-A84741E7772B}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU + {9818146E-C516-4D3C-80CE-A84741E7772B}.Analyzers|Any CPU.Build.0 = Debug|Any CPU + {EEF136BD-B789-4C0E-BFC7-4D5FD66C5B12}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {EEF136BD-B789-4C0E-BFC7-4D5FD66C5B12}.Debug|Any CPU.Build.0 = Debug|Any CPU + {EEF136BD-B789-4C0E-BFC7-4D5FD66C5B12}.Release|Any CPU.ActiveCfg = Release|Any CPU + {EEF136BD-B789-4C0E-BFC7-4D5FD66C5B12}.Release|Any CPU.Build.0 = Release|Any CPU + {EEF136BD-B789-4C0E-BFC7-4D5FD66C5B12}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU + {EEF136BD-B789-4C0E-BFC7-4D5FD66C5B12}.Analyzers|Any CPU.Build.0 = Debug|Any CPU + {E611118C-2205-4771-A902-0852E2B7301A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {E611118C-2205-4771-A902-0852E2B7301A}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E611118C-2205-4771-A902-0852E2B7301A}.Release|Any CPU.ActiveCfg = Release|Any CPU + {E611118C-2205-4771-A902-0852E2B7301A}.Release|Any CPU.Build.0 = Release|Any CPU + {E611118C-2205-4771-A902-0852E2B7301A}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU + {E611118C-2205-4771-A902-0852E2B7301A}.Analyzers|Any CPU.Build.0 = Debug|Any CPU + {E799F5AF-1143-4E84-8787-09A2B0702385}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {E799F5AF-1143-4E84-8787-09A2B0702385}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E799F5AF-1143-4E84-8787-09A2B0702385}.Release|Any CPU.ActiveCfg = Release|Any CPU + {E799F5AF-1143-4E84-8787-09A2B0702385}.Release|Any CPU.Build.0 = Release|Any CPU + {E799F5AF-1143-4E84-8787-09A2B0702385}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU + {E799F5AF-1143-4E84-8787-09A2B0702385}.Analyzers|Any CPU.Build.0 = Debug|Any CPU EndGlobalSection GlobalSection(NestedProjects) = preSolution {25EEACCB-9BAE-4361-A980-9E9CDA37602E} = {7B268266-B9CD-4D85-ABC5-3B2C4611FD74} {FB30394C-7930-4BFF-97E2-400CFADE92C2} = {C7A4A8F9-0343-4A3E-AB77-101C458C23B5} {25208A27-E598-4BE3-9CD9-0618A6B9598F} = {C7A4A8F9-0343-4A3E-AB77-101C458C23B5} - {25208A27-E598-4BE3-9CD9-0618A6B9598E} = {C7A4A8F9-0343-4A3E-AB77-101C458C23B5} - {3D70D4FA-3BA2-4230-B474-5A70DB23B8CE} = {C7A4A8F9-0343-4A3E-AB77-101C458C23B5} - {6EC419CB-E60B-4F06-A710-B02EA6B9AAAC} = {C7A4A8F9-0343-4A3E-AB77-101C458C23B5} {06BCC1C7-9D8C-4D3B-934D-072C35A5C984} = {C7A4A8F9-0343-4A3E-AB77-101C458C23B5} {5DD7D88A-5A10-457D-B1A2-30F7CF67AD9F} = {C7A4A8F9-0343-4A3E-AB77-101C458C23B5} {C7E280C5-E841-4690-8AA3-653ECBC7C78B} = {C7A4A8F9-0343-4A3E-AB77-101C458C23B5} @@ -118,6 +161,13 @@ Global {D3F48947-C702-4D1A-B6EE-96B89D13953E} = {C7A4A8F9-0343-4A3E-AB77-101C458C23B5} {D38BB305-3276-4AE1-87B1-C19C7A9F3840} = {C7A4A8F9-0343-4A3E-AB77-101C458C23B5} {F7F4F27F-2CAE-422B-B6CE-25A88C3603A1} = {C7A4A8F9-0343-4A3E-AB77-101C458C23B5} - {8623AABC-D198-4D56-B26B-14A503B226E1} = {C7A4A8F9-0343-4A3E-AB77-101C458C23B5} + {C714F4F1-E2DF-4B29-A277-9B40BD7DE406} = {B5C675AF-506B-47E6-AB10-4E7BC36531D2} + {40C71491-3CCC-40A0-8F01-3EC7204CF85F} = {C7A4A8F9-0343-4A3E-AB77-101C458C23B5} + {5C70ACE0-BE37-4D67-A67F-EE69767994D2} = {C7A4A8F9-0343-4A3E-AB77-101C458C23B5} + {C04C7CA4-69C3-444F-A654-6C722A0FC3BE} = {C7A4A8F9-0343-4A3E-AB77-101C458C23B5} + {9818146E-C516-4D3C-80CE-A84741E7772B} = {C7A4A8F9-0343-4A3E-AB77-101C458C23B5} + {EEF136BD-B789-4C0E-BFC7-4D5FD66C5B12} = {C7A4A8F9-0343-4A3E-AB77-101C458C23B5} + {E611118C-2205-4771-A902-0852E2B7301A} = {C7A4A8F9-0343-4A3E-AB77-101C458C23B5} + {E799F5AF-1143-4E84-8787-09A2B0702385} = {C7A4A8F9-0343-4A3E-AB77-101C458C23B5} EndGlobalSection EndGlobal diff --git a/Rewrite/Rewrite.v3.ncrunchsolution b/Rewrite/Rewrite.v3.ncrunchsolution deleted file mode 100644 index 13107d39..00000000 --- a/Rewrite/Rewrite.v3.ncrunchsolution +++ /dev/null @@ -1,8 +0,0 @@ - - - True - True - True - True - - \ No newline at end of file diff --git a/Rewrite/openrewrite-icon.png b/Rewrite/openrewrite-icon.png new file mode 100644 index 0000000000000000000000000000000000000000..b7e3046de04b554a753c9411f4e18ad7792f48b0 GIT binary patch literal 512 zcmV+b0{{JqP)Wouu&;0IxKOi1z2u1Nns28II`G!A}HWKr#)S{JvsWF>;5lsdIWF7y!`0 zkCas$y#~2Q|ia$!h=A?idmtbKqpQpXEVW&nrKR$~RV_YvOgH8~srptD&AeTXws zC73)R_~AF;^R9gi^f*ZS->5}Iwo!iNK*D(}ul@oEXO?!5%JlaD0000 + + + diff --git a/Rewrite/src/ClearBinObjFolders.bat b/Rewrite/src/ClearBinObjFolders.bat new file mode 100644 index 00000000..5535358b --- /dev/null +++ b/Rewrite/src/ClearBinObjFolders.bat @@ -0,0 +1,4 @@ +FOR /F "tokens=*" %%G IN ('DIR /B /AD /S bin') DO RMDIR /S /Q "%%G" +FOR /F "tokens=*" %%G IN ('DIR /B /AD /S obj') DO RMDIR /S /Q "%%G" +FOR /F "tokens=*" %%G IN ('DIR /B /AD /S tmp') DO RMDIR /S /Q "%%G" +FOR /F "tokens=*" %%G IN ('DIR /B /AD /S target') DO RMDIR /S /Q "%%G" \ No newline at end of file diff --git a/Rewrite/src/Rewrite.Analyzers/Rewrite.Analyzers.csproj b/Rewrite/src/Rewrite.Analyzers/Rewrite.Analyzers.csproj index 87b92165..e7125bed 100644 --- a/Rewrite/src/Rewrite.Analyzers/Rewrite.Analyzers.csproj +++ b/Rewrite/src/Rewrite.Analyzers/Rewrite.Analyzers.csproj @@ -5,6 +5,8 @@ false NU5128 $(GetTargetPathDependsOn);GetDependencyTargetPaths + analyzers + false diff --git a/Rewrite/src/Rewrite.Analyzers/openrewrite-icon.png b/Rewrite/src/Rewrite.Analyzers/openrewrite-icon.png new file mode 100644 index 0000000000000000000000000000000000000000..b7e3046de04b554a753c9411f4e18ad7792f48b0 GIT binary patch literal 512 zcmV+b0{{JqP)Wouu&;0IxKOi1z2u1Nns28II`G!A}HWKr#)S{JvsWF>;5lsdIWF7y!`0 zkCas$y#~2Q|ia$!h=A?idmtbKqpQpXEVW&nrKR$~RV_YvOgH8~srptD&AeTXws zC73)R_~AF;^R9gi^f*ZS->5}Iwo!iNK*D(}ul@oEXO?!5%JlaD0000 "Dependency Insight"; +// +// public override string Description => "Search for dependency of specific package"; +// +// public override ITreeVisitor GetVisitor() +// { +// return new ProjectDependenciesVisitor(packagePattern); +// } +// +// private class ProjectDependenciesVisitor(string? packagePattern) : XmlVisitor +// { +// private const int Utf8Bom = '\uFEFF'; +// +// public override Xml VisitDocument(Xml.Document document, ExecutionContext ctx) +// { +// if (document.Markers.FindFirst() != null) +// { +// return document; +// } +// +// var outputCapture = new PrintOutputCapture(0); +// new XmlPrinter().Visit(document, outputCapture); +// var printed = outputCapture.GetOut(); +// // strip UTF-8 BOM if present +// printed = printed.Length > 0 && printed[0] == Utf8Bom ? printed[1..] : printed; +// try +// { +// var dependencies = ProjectDependencyResolver.TransitiveProjectDependencies(printed, packagePattern); +// var dependenciesArray = dependencies as Dependency[] ?? dependencies.ToArray(); +// if (dependenciesArray.Length != 0) +// { +// var marker = new ProjectDependencies(Tree.RandomId(), document.SourcePath, +// new List(dependenciesArray)); +// return document.WithMarkers(document.Markers.AddIfAbsent(marker)); +// } +// +// return document; +// } +// catch (Exception e) +// { +// // avoid compile-time dependency on `Microsoft.Build` +// if (e.GetType().FullName == "Microsoft.Build.Exceptions.InvalidProjectFileException" || +// e is ArgumentException && +// e.Message == "Value cannot be null or an empty string. (Parameter 'value')" || +// e.Message.EndsWith(" unexpectedly not a rooted path")) +// { +// return Markup.WarnMarkup(document, e); +// } +// +// return Markup.ErrorMarkup(document, e); +// } +// } +// } +//} diff --git a/Rewrite/src/Rewrite.MSBuild/InstallableRemotingRecipe.cs b/Rewrite/src/Rewrite.MSBuild/InstallableRemotingRecipe.cs new file mode 100644 index 00000000..48ef6bfa --- /dev/null +++ b/Rewrite/src/Rewrite.MSBuild/InstallableRemotingRecipe.cs @@ -0,0 +1,10 @@ +using Rewrite.Core.Config; + +namespace Rewrite.MSBuild; + +public class InstallableRemotingRecipe(string repository, string version, List recipes) +{ + public string Repository => repository; + public string Version => version; + public List Recipes => recipes; +} diff --git a/Rewrite/src/Rewrite.MSBuild/Marker/ProjectDependencies.cs b/Rewrite/src/Rewrite.MSBuild/Marker/ProjectDependencies.cs new file mode 100644 index 00000000..6bdc1613 --- /dev/null +++ b/Rewrite/src/Rewrite.MSBuild/Marker/ProjectDependencies.cs @@ -0,0 +1,9 @@ +namespace Rewrite.MSBuild.Marker; + +public record ProjectDependencies(Guid Id, string ProjectFile, IList Dependencies) : Core.Marker.Marker +{ + public bool Equals(Core.Marker.Marker? other) + { + return other is ProjectDependencies && other.Id.Equals(Id); + } +} diff --git a/Rewrite/src/Rewrite.MSBuild/NugetManager.cs b/Rewrite/src/Rewrite.MSBuild/NugetManager.cs new file mode 100644 index 00000000..e1604c16 --- /dev/null +++ b/Rewrite/src/Rewrite.MSBuild/NugetManager.cs @@ -0,0 +1,536 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.Versioning; +using log4net; +using NuGet.Common; +using NuGet.Configuration; +using NuGet.Frameworks; +using NuGet.PackageManagement; +using NuGet.Packaging; +using NuGet.Packaging.Core; +using NuGet.Packaging.Signing; +using NuGet.ProjectManagement; +using NuGet.Protocol; +using NuGet.Protocol.Core.Types; +using NuGet.Resolver; +using NuGet.Versioning; +using Rewrite.Core; + +namespace Rewrite.MSBuild; + +public class NugetManager +{ + private static readonly ILog log = LogManager.GetLogger(typeof(NugetManager)); + + public static async Task InstallRecipeAsync(string packageId, string packageVersion, + List packageSources, + string packagesPath, + CancellationToken cancellationToken) + { + var logger = NugetManagerLogger.Instance; + + + var frameworkName = Assembly.GetExecutingAssembly().GetCustomAttributes(true) + .OfType() + .Select(x => x.FrameworkName) + .FirstOrDefault(); + var currentFramework = frameworkName == null + ? NuGetFramework.AnyFramework + : NuGetFramework.ParseFrameworkName(frameworkName, new DefaultFrameworkNameProvider()); + + var nuGetVersion = packageVersion.ToUpper() is "LATEST" or "RELEASE" + ? await FindLatestVersionAsync(packageId, packageVersion.Equals("LATEST", StringComparison.CurrentCultureIgnoreCase), packageSources, logger, + cancellationToken) + : new NuGetVersion(packageVersion); + + var packageIdentityToResolve = new PackageIdentity(packageId, nuGetVersion); + + var settings = Settings.LoadDefaultSettings(packagesPath, null, null); + var sourceRepositoryProvider = + new SourceRepositoryProvider(new PackageSourceProvider(settings), Repository.Provider.GetCoreV3()); + var packageManager = new NuGetPackageManager(sourceRepositoryProvider, settings, packagesPath); + var packageExists = packageManager.PackageExistsInPackagesFolder(packageIdentityToResolve); + + if (log.IsDebugEnabled) + { + log.Debug(packageExists + ? $"Skip package {packageId}:{packageVersion} downloading since it already exists in the package store" + : $"Downloading package {packageId}:{packageVersion}"); + } + + var (packageReader, source) = + packageExists + ? (new PackageArchiveReader( + packageManager.PackagesFolderNuGetProject.GetInstalledPackageFilePath(packageIdentityToResolve)), $"{Uri.UriSchemeFile}://{packagesPath}") + : await DownloadNupkgAsync(packageId, packageVersion, packageSources, + settings, + logger, packageManager, + packageIdentityToResolve, cancellationToken); + + using (packageReader) + { + + var nuspecReader = await packageReader.GetNuspecReaderAsync(cancellationToken); + + if (log.IsDebugEnabled) + { + log.Debug($"Resolved nuspec {nuspecReader}"); + } + + var identity = nuspecReader.GetIdentity(); + + if (log.IsDebugEnabled) + { + log.Debug($"Resolved package identity {identity}"); + } + + var dependency = FindDependencyGroup(currentFramework, nuspecReader) ?? + throw new InvalidOperationException("Dependency group not found"); + await LoadRecipePackagesAsync(dependency, currentFramework, + packageManager.PackagesFolderNuGetProject, cancellationToken); + + var installedPath = packageManager.PackagesFolderNuGetProject.GetInstalledPath(identity); + var assemblies = + LoadFrameworkSpecificGroupItemsToAssembly(currentFramework, packageReader, identity, installedPath); + var recipes = assemblies.SelectMany(FindAllRecipes).ToList(); + + if (log.IsDebugEnabled) + { + log.Debug($"Found {recipes.Count}"); + + if (recipes.Count > 0) + { + log.Debug($"Found the following recipes [{recipes}]"); + } + } + + var mappedRecipes = recipes.Select(r => + r.Descriptor.With( + source: new Uri( + $"recipe://{nuspecReader.GetIdentity().Id}/{nuspecReader.GetIdentity().Version}"))) + .ToList(); + + return new InstallableRemotingRecipe(source, nuspecReader.GetIdentity().Version.ToString(), mappedRecipes); + } + } + + private static async Task FindLatestVersionAsync(string packageId, bool includePrerelease, List packageSources, ILogger logger, CancellationToken cancellationToken) + { + return (await Task.WhenAll(packageSources.Select(s => Repository.Factory.GetCoreV3(s)) + .Select(async repository => + { + var resource = await repository.GetResourceAsync(cancellationToken); + var packages = await resource.SearchAsync(packageId, new SearchFilter(includePrerelease), 0, 100, logger, + cancellationToken); + var iPackageSearchMetadata = packages.FirstOrDefault(psm => psm.Identity.Id == packageId); + if (iPackageSearchMetadata == null) + { + return []; + } + return await iPackageSearchMetadata.GetVersionsAsync(); + }))) + .SelectMany(psm => psm.Select(m => m.Version)) + .Distinct() + .OrderDescending() + .First(); + } + + private static async Task<(PackageArchiveReader, string)> DownloadNupkgAsync(string packageId, string packageVersion, + List packageSources, + ISettings settings, ILogger logger, NuGetPackageManager packageManager, + PackageIdentity packageIdentityToResolve, + CancellationToken cancellationToken) + { + + if (log.IsDebugEnabled) + { + log.Debug($"Downloading package {packageId}:{packageVersion}"); + } + + + var allowPrereleaseVersions = true; + var allowUnlisted = false; + var resolutionContext = new ResolutionContext( + DependencyBehavior.Lowest, allowPrereleaseVersions, allowUnlisted, VersionConstraints.None); + var projectContext = new ProjectContext + { + PackageExtractionContext = new PackageExtractionContext(PackageSaveMode.Defaultv3, + XmlDocFileSaveMode.Compress, ClientPolicyContext.GetClientPolicy(settings, logger), logger) + }; + + + var sourceRepositories = packageSources.Select(s => Repository.Factory.GetCoreV3(s)).ToList(); + SourceRepository? packageSourceRepository = null; + foreach (var sourceRepository in sourceRepositories) + { + if (await sourceRepository.GetResource().DoesPackageExistAsync( + packageIdentityToResolve.Id, + packageIdentityToResolve.Version, resolutionContext.SourceCacheContext, logger, cancellationToken)) + { + packageSourceRepository = sourceRepository; + break; + } + } + + if (packageSourceRepository == null) + { + throw new Exception($"Could not find package source repository for {packageId} {packageVersion}"); + } + + await packageManager.InstallPackageAsync(packageManager.PackagesFolderNuGetProject, + packageIdentityToResolve, + resolutionContext, + projectContext, + sourceRepositories, + [], + cancellationToken); + + if (log.IsDebugEnabled) + { + log.Debug( + $"Package {packageId}:{packageVersion} has been successfully downloaded and stored at {packageManager.PackagesFolderNuGetProject}"); + } + + return (new PackageArchiveReader( + packageManager.PackagesFolderNuGetProject.GetInstalledPackageFilePath(packageIdentityToResolve)), packageSourceRepository.PackageSource.Source); + } + + public static async Task LoadRecipeAssemblyAsync(string recipeClassName, string packageId, + string packageVersion, + string nuGetProjectFolderPath, Dictionary> options, + CancellationToken cancellationToken) + { + var folderNuGetProject = new FolderNuGetProject(nuGetProjectFolderPath); + var frameworkName = Assembly.GetExecutingAssembly().GetCustomAttributes(true) + .OfType() + .Select(x => x.FrameworkName) + .FirstOrDefault(); + var currentFramework = frameworkName == null + ? NuGetFramework.AnyFramework + : NuGetFramework.ParseFrameworkName(frameworkName, new DefaultFrameworkNameProvider()); + + + var packageIdentity = new PackageIdentity(packageId, new NuGetVersion(packageVersion)); + var installedPath = folderNuGetProject.GetInstalledPath(packageIdentity); + var nugetPackagePath = folderNuGetProject.GetInstalledPackageFilePath(packageIdentity); + using var packageReader = new PackageArchiveReader(nugetPackagePath); + var nuspecReader = await packageReader.GetNuspecReaderAsync(cancellationToken); + + var dependencyGroup = FindDependencyGroup(currentFramework, nuspecReader) ?? + throw new InvalidOperationException("Dependency group not found"); + + await LoadRecipePackagesAsync(dependencyGroup, currentFramework, folderNuGetProject, cancellationToken); + + var assemblies = + LoadFrameworkSpecificGroupItemsToAssembly(currentFramework, packageReader, packageIdentity, installedPath); + + + var recipe = LoadRecipe(assemblies[0], recipeClassName, options); + + if (recipe == null) + { + throw new ArgumentException($"Recipe type {recipeClassName} not found"); + } + + return recipe; + } + + static List FindAllRecipes(Assembly assembly) + { + var recipes = new List(); + foreach (var type in assembly.GetExportedTypes()) + { + if (!typeof(Recipe).IsAssignableFrom(type)) continue; + + var constructorInfo = type.GetConstructors()[0]; + var parameters = new object?[constructorInfo.GetParameters().Length]; + for (var index = 0; index < constructorInfo.GetParameters().Length; index++) + { + var parameterInfo = constructorInfo.GetParameters()[index]; + var parameterInfoParameterType = parameterInfo.ParameterType; + + parameters[index] = parameterInfoParameterType.IsValueType + ? Activator.CreateInstance(parameterInfoParameterType) + : null; + } + + recipes.Add((Recipe)constructorInfo.Invoke(parameters)); + } + + return recipes; + } + + static Recipe LoadRecipe(Assembly assembly, string recipeClassName, Dictionary> args) + { + var type = assembly.GetType(recipeClassName); + if (!typeof(Recipe).IsAssignableFrom(type)) + throw new ArgumentException($"Given Recipe class name {recipeClassName} is not a Recipe type but {type}"); + + var constructorInfo = type.GetConstructors()[0]; + var parameters = new object?[constructorInfo.GetParameters().Length]; + for (var index = 0; index < constructorInfo.GetParameters().Length; index++) + { + var parameterInfo = constructorInfo.GetParameters()[index]; + var parameterInfoParameterType = parameterInfo.ParameterType; + if (!args.TryGetValue(parameterInfo.Name!, out var value)) + { + if (!(parameterInfo.IsOptional || parameterInfo.HasDefaultValue || + parameterInfoParameterType.CustomAttributes.FirstOrDefault(data => + data.AttributeType == typeof(NullableAttribute)) != null)) + { + throw new ArgumentNullException( + $"Recipe requires {parameterInfo.Name} to be passed but given null"); + } + + parameters[index] = null; + } + else + { + parameters[index] = value.Invoke(parameterInfoParameterType); + } + } + + return (Recipe)constructorInfo.Invoke(parameters); + } + + private static async Task LoadRecipePackagesAsync(PackageDependencyGroup dependencyGroup, + NuGetFramework currentFramework, + FolderNuGetProject folderNuGetProject, CancellationToken cancellationToken) + { + if (log.IsDebugEnabled) + { + log.Debug($"Loading assemblies for {dependencyGroup}"); + } + + foreach (var dependencyGroupPackage in dependencyGroup.Packages) + { + var packageIdentity = + new PackageIdentity(dependencyGroupPackage.Id, dependencyGroupPackage.VersionRange.MinVersion); + + if (AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(a => a.GetName().Name == packageIdentity.Id) != + null) + { + if (log.IsDebugEnabled) + { + log.Debug($"Skipping already loaded {packageIdentity.Id} assembly."); + } + + continue; + } + + var packageInstalledPath = folderNuGetProject.GetInstalledPath(packageIdentity); + var nugetArchiveFilePath = folderNuGetProject.GetInstalledPackageFilePath(packageIdentity); + + using var packageReader = new PackageArchiveReader(nugetArchiveFilePath); + var nuspecReader = await packageReader.GetNuspecReaderAsync(cancellationToken); + + var packageDependencyGroup = FindDependencyGroup(currentFramework, nuspecReader); + + if (packageDependencyGroup == null && nuspecReader.GetDevelopmentDependency()) + { + // some packages are dev packages and has nothing to load + continue; + } + + if (packageDependencyGroup == null) + { + throw new InvalidOperationException("PackageDependencyGroup snot found"); + } + + await LoadRecipePackagesAsync(packageDependencyGroup, currentFramework, folderNuGetProject, + cancellationToken); + LoadFrameworkSpecificGroupItemsToAssembly(currentFramework, packageReader, packageIdentity, + packageInstalledPath); + } + } + + private static List LoadFrameworkSpecificGroupItemsToAssembly(NuGetFramework currentFramework, + PackageArchiveReader packageReader, PackageIdentity packageIdentity, string packageInstalledPath) + { + var loadedAssemblies = new List(); + var findFrameworkSpecificGroup = FindFrameworkSpecificGroup(packageReader, currentFramework); + foreach (var item in findFrameworkSpecificGroup.Items.Where(it => it.EndsWith(".dll"))) + { + if (log.IsDebugEnabled) + { + log.Debug($"Loading assembly {item}"); + } + + // if (AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(a => a.GetName().Name == packageIdentity.Id) != + // null) + // { + // continue; + // } + // else + // { + try + { + loadedAssemblies.Add(Assembly.LoadFrom(Path.Combine(packageInstalledPath, item))); + } + catch (FileLoadException e) + { + if (log.IsDebugEnabled) + { + log.Debug($"Failed to load assembly {item}\n{e}"); + } + } + // } + } + + return loadedAssemblies; + } + + private static PackageDependencyGroup? FindDependencyGroup(NuGetFramework currentFramework, + NuspecReader nuspecReader) + { + // PackageDependencyGroup dependencyGroup; + // dependencyGroup + // = nuspecReader.GetDependencyGroups() + // .Where(d => d.TargetFramework.Framework == currentFramework.Framework && + // d.TargetFramework.Version.CompareTo(currentFramework.Version) <= 0) + // .OrderBy(g => g.TargetFramework.Version).LastOrDefault(); + // + // if (dependencyGroup == null) + // { + // dependencyGroup = nuspecReader.GetDependencyGroups() + // .Where(d => d.TargetFramework.Framework == ".NETStandard").OrderBy(g => g.TargetFramework.Version) + // .Last(); + // } + // + // if (dependencyGroup == null) + // { + // dependencyGroup = nuspecReader.GetDependencyGroups().Last(); + // } + // + // return dependencyGroup; + + return nuspecReader.GetDependencyGroups() + .Where(pdg => DefaultCompatibilityProvider.Instance.IsCompatible(currentFramework, pdg.TargetFramework)) + .MinBy(pdg => pdg.Packages.Count()); + } + + private static FrameworkSpecificGroup FindFrameworkSpecificGroup(PackageArchiveReader packageArchiveReader, + NuGetFramework currentFramework) + { + // FrameworkSpecificGroup dependencyGroup; + // dependencyGroup + // = packageArchiveReader.GetFrameworkItems() + // .Where(d => d.TargetFramework.Framework == currentFramework.Framework && + // d.TargetFramework.Version.CompareTo(currentFramework.Version) <= 0) + // .OrderBy(g => g.TargetFramework.Version).LastOrDefault(); + // + // if (dependencyGroup == null) + // { + // dependencyGroup = packageArchiveReader.GetFrameworkItems() + // .Where(d => d.TargetFramework.Framework == ".NETStandard").OrderBy(g => g.TargetFramework.Version) + // .Last(); + // + // } + // + // if (dependencyGroup == null) + // { + // dependencyGroup = nuspecReader.GetDependencyGroups().Last(); + // } + // + // return dependencyGroup; + // var entry = packageArchiveReader.GetEntry(packageArchiveReader.GetFiles() + // .First(f => f.EndsWith(packageIdentity.Id + ".dll"))); + + return packageArchiveReader.GetLibItems() + .Where(pdg => DefaultCompatibilityProvider.Instance.IsCompatible(currentFramework, pdg.TargetFramework)) + .OrderBy(pdg => pdg.Items.Count()) + .First(); + } + + class NugetManagerLogger : ILogger + { + private static ILogger? _instance; + + public static ILogger Instance + { + get + { + if (_instance == null) + { + _instance = new NugetManagerLogger(); + } + + return _instance; + } + } + + public void LogDebug(string data) + { + log.Debug(data); + } + + public void LogVerbose(string data) + { + log.Debug(data); + } + + public void LogInformation(string data) + { + log.Info(data); + } + + public void LogMinimal(string data) + { + log.Info(data); + } + + public void LogWarning(string data) + { + log.Warn(data); + } + + public void LogError(string data) + { + log.Error(data); + } + + public void LogInformationSummary(string data) + { + log.Info(data); + } + + public void Log(LogLevel level, string data) + { + switch (level) + { + case LogLevel.Debug: + case LogLevel.Verbose: + log.Debug(data); + break; + case LogLevel.Information: + case LogLevel.Minimal: + log.Info(data); + break; + case LogLevel.Warning: + log.Warn(data); + break; + case LogLevel.Error: + log.Error(data); + break; + default: + throw new ArgumentOutOfRangeException(nameof(level), level, null); + } + } + + public Task LogAsync(LogLevel level, string data) + { + Log(level, data); + return Task.CompletedTask; + } + + public void Log(ILogMessage message) + { + Log(message.Level, message.Message); + } + + public Task LogAsync(ILogMessage message) + { + return LogAsync(message.Level, message.Message); + } + } +} diff --git a/Rewrite/src/Rewrite.MSBuild/ProjectContext.cs b/Rewrite/src/Rewrite.MSBuild/ProjectContext.cs new file mode 100644 index 00000000..00abad9b --- /dev/null +++ b/Rewrite/src/Rewrite.MSBuild/ProjectContext.cs @@ -0,0 +1,42 @@ +using System.Xml.Linq; +using NuGet.Common; +using NuGet.Packaging; +using NuGet.ProjectManagement; +using ExecutionContext = System.Threading.ExecutionContext; + +namespace Rewrite.MSBuild; + +public class ProjectContext : INuGetProjectContext +{ + public void Log(MessageLevel level, string message, params object[] args) + { + // Do your logging here... + } + + public void Log(ILogMessage message) + { + } + + public void ReportError(ILogMessage message) + { + } + + public FileConflictAction ResolveFileConflict(string message) => FileConflictAction.Ignore; + + public PackageExtractionContext PackageExtractionContext { get; set; } = null!; + + NuGet.ProjectManagement.ExecutionContext INuGetProjectContext.ExecutionContext { get; } = null!; + + public XDocument OriginalPackagesConfig { get; set; } = null!; + + public ISourceControlManagerProvider SourceControlManagerProvider => null!; + + public ExecutionContext ExecutionContext => null!; + + public void ReportError(string message) + { + } + + public NuGetActionType ActionType { get; set; } + public Guid OperationId { get; set; } +} \ No newline at end of file diff --git a/Rewrite/src/Rewrite.MSBuild/ProjectDependencyResolver.cs b/Rewrite/src/Rewrite.MSBuild/ProjectDependencyResolver.cs new file mode 100644 index 00000000..c8e8503e --- /dev/null +++ b/Rewrite/src/Rewrite.MSBuild/ProjectDependencyResolver.cs @@ -0,0 +1,158 @@ +using System.Text.RegularExpressions; +using System.Xml; +using Microsoft.Build.Construction; +using Microsoft.Build.Definition; +using Microsoft.Build.Evaluation; +using Microsoft.Build.Locator; +using NuGet.Common; +using NuGet.Configuration; +using NuGet.Frameworks; +using NuGet.Packaging; +using NuGet.Packaging.Core; +using NuGet.Protocol; +using NuGet.Protocol.Core.Types; +using NuGet.Versioning; + +namespace Rewrite.MSBuild; + +public class ProjectDependencyResolver +{ + static ProjectDependencyResolver() + { + var instance = MSBuildLocator.QueryVisualStudioInstances().OrderByDescending(instance => instance.Version) + .First(); + MSBuildLocator.RegisterInstance(instance); + } + + private readonly Regex? _packagePattern; + private readonly Project _project; + private readonly string _globalPackagesFolder; + private readonly NuGetFramework _projectFramework; + private readonly ILogger _logger; + private readonly CancellationToken _cancellationToken; + private readonly SourceCacheContext _cache; + private readonly SourceRepository _repository; + private readonly HashSet _result = []; + + + private ProjectDependencyResolver(string projectFileContent, string? packagePattern) + { + _packagePattern = packagePattern != null + ? new Regex("^" + packagePattern.Replace(".", "\\.").Replace("*", ".*").Replace("?", ".") + "$") + : null; + + using var stringReader = new StringReader(projectFileContent); + using var xmlReader = XmlReader.Create(stringReader); + + var projectRootElement = ProjectRootElement.Create(xmlReader); + var projectOptions = new ProjectOptions(); + // projectOptions.GlobalProperties = new Dictionary + // { + // { "Configuration", "Debug" } + // }; + _project = Project.FromProjectRootElement( + projectRootElement, projectOptions); + var settings = Settings.LoadDefaultSettings(root: null); + _globalPackagesFolder = SettingsUtility.GetGlobalPackagesFolder(settings) ?? + Path.Combine(Path.GetTempPath(), "/nuget"); + var targetFramework = _project.GetPropertyValue("TargetFramework")!; + _projectFramework = NuGetFramework.ParseFolder(targetFramework); + + var projectItems = _project.GetItems("Compile").ToList(); + foreach (var projectItem in projectItems) + { + Console.WriteLine(projectItem.EvaluatedInclude); + } + + + _logger = NullLogger.Instance; + _cancellationToken = CancellationToken.None; + + _cache = new SourceCacheContext(); + _repository = Repository.Factory.GetCoreV3("https://api.nuget.org/v3/index.json"); + } + + public static IEnumerable TransitiveProjectDependencies(string projectFileContents, string? package) + { + var dependencyResolver = new ProjectDependencyResolver(projectFileContents, package); + return dependencyResolver.ResolveProject().GetAwaiter().GetResult(); + } + + private async Task> ResolveProject() + { + foreach (var packageReference in _project.GetItems("PackageReference")) + { + var packageName = packageReference.EvaluatedInclude; + if (!packageReference.HasMetadata("Version") || + packageReference.GetMetadataValue("Version").Length == 0) continue; + + var packageVersion = packageReference.GetMetadataValue("Version"); + try + { + var versionRange = VersionRange.Parse(packageVersion); + NuGetVersion? nuGetVersion; + if (versionRange.IsFloating || !versionRange.IsMinInclusive || !versionRange.IsMaxInclusive || + versionRange.MinVersion != versionRange.MaxVersion || packageVersion.Contains('[')) + { + nuGetVersion = await GetLatestVersionInRange(packageName, versionRange); + } + else + { + nuGetVersion = NuGetVersion.Parse(packageVersion); + } + + if (nuGetVersion != null) + { + var identity = new PackageIdentity(packageName, nuGetVersion); + await ResolveDependency(identity); + } + } + catch (ArgumentException) + { + // ignore + } + } + + return _packagePattern != null ? _result.Where(d => _packagePattern.IsMatch(d.Package)) : _result; + } + + async Task GetLatestVersionInRange(string packageId, VersionRange versionRange) + { + var resource = await _repository.GetResourceAsync(_cancellationToken); + IEnumerable versions = + await resource.GetAllVersionsAsync(packageId, _cache, NullLogger.Instance, CancellationToken.None); + return versions.Where(versionRange.Satisfies).MaxBy(v => v); + } + + private async Task ResolveDependency(PackageIdentity identity) + { + if (!_result.Add(new Dependency(identity.Id, identity.Version.ToString()))) + { + return; + } + + var downloadResource = await _repository.GetResourceAsync(_cancellationToken); + var result = await downloadResource.GetDownloadResourceResultAsync(identity, + new PackageDownloadContext(_cache), _globalPackagesFolder, _logger, _cancellationToken); + if (result.Status == DownloadResourceResultStatus.NotFound) + { + return; + } + + var nuspecReader = new NuspecReader(await result.PackageReader.GetNuspecAsync(_cancellationToken)); + IEnumerable groups = nuspecReader.GetDependencyGroups(); + var suitableGroup = groups.FirstOrDefault(g => _projectFramework.Equals(g?.TargetFramework) || (g?.TargetFramework?.IsAny ?? false)); + if (suitableGroup != null) + { + foreach (var dependency in suitableGroup.Packages) + { + if (dependency.VersionRange.MinVersion != null) + { + var transitiveIdentity = new PackageIdentity(dependency.Id, + NuGetVersion.Parse(dependency.VersionRange.MinVersion!.ToString())); + await ResolveDependency(transitiveIdentity); + } + } + } + } +} diff --git a/Rewrite/src/Rewrite.MSBuild/ProjectParser.cs b/Rewrite/src/Rewrite.MSBuild/ProjectParser.cs new file mode 100644 index 00000000..07062868 --- /dev/null +++ b/Rewrite/src/Rewrite.MSBuild/ProjectParser.cs @@ -0,0 +1,112 @@ +using System.Reflection; +using log4net; +using Microsoft.Build.Definition; +using Microsoft.Build.Evaluation; +using Microsoft.Build.Locator; +using Microsoft.CodeAnalysis; +using NuGet.Configuration; +using NuGet.Frameworks; +using Rewrite.Core; +using Rewrite.Core.Marker; +using Rewrite.RewriteCSharp; +using Rewrite.RewriteJava.Tree; +using static Rewrite.RewriteJava.Tree.Space; +using FileAttributes = Rewrite.Core.FileAttributes; +using Project = Microsoft.Build.Evaluation.Project; + +namespace Rewrite.MSBuild; + +public class ProjectParser +{ + + private static readonly ILog log = LogManager.GetLogger(typeof(ProjectParser)); + + static ProjectParser() + { + if (!MSBuildLocator.CanRegister) return; + + var instance = MSBuildLocator.QueryVisualStudioInstances().OrderByDescending(instance => instance.Version) + .First(); + MSBuildLocator.RegisterInstance(instance); + } + + public static bool Init() + { + if (!MSBuildLocator.CanRegister) return false; + + var instance = MSBuildLocator.QueryVisualStudioInstances().OrderByDescending(instance => instance.Version) + .First(); + MSBuildLocator.RegisterInstance(instance); + return true; + } + + private readonly Project _project; + private readonly IList _inputs = []; + private readonly Parser _parser; + private readonly string solutionDir; + + + public ProjectParser(string projectFilePath, string solutionDir) + { + var projectOptions = new ProjectOptions(); + // projectOptions.GlobalProperties = new Dictionary + // { + // { "Configuration", "Debug" } + // }; + // _project = Project.FromFile(projectFilePath, projectOptions); + + // FIXME: do we need to unload project then? + _project = + ProjectCollection.GlobalProjectCollection.LoadedProjects.FirstOrDefault(d => + d.FullPath == projectFilePath) ?? + Project.FromFile(projectFilePath, projectOptions); + this.solutionDir = solutionDir; + var settings = Settings.LoadDefaultSettings(root: null); + var targetFramework = _project.GetPropertyValue("TargetFramework")!; + NuGetFramework.ParseFolder(targetFramework); + + var projectItems = _project.GetItems("Compile").ToList(); + foreach (var projectItem in projectItems) + { + _inputs.Add(new Parser.Input(Path.Combine(projectItem.Project.DirectoryPath, projectItem.EvaluatedInclude), + () => new FileStream(Path.Combine(projectItem.Project.DirectoryPath, projectItem.EvaluatedInclude), + FileMode.Open))); + } + + projectItems = _project.GetItems("ProjectReference").ToList(); + IList references = []; + foreach (var item in projectItems) + { + var include = item.EvaluatedInclude; + // var reference = MetadataReference.CreateFromFile(Path.Combine(Path.GetDirectoryName(item.Project.FullPath)!, + // _project.GetPropertyValue("OutputPath").Replace('\\', Path.DirectorySeparatorChar), Path.GetFileName(include))); + var reference = + MetadataReference.CreateFromFile(Path.Combine(Path.GetDirectoryName(item.Project.FullPath)!, include)); + references.Add(reference); + } + + projectItems = _project.GetItems("PackageReference").ToList(); + foreach (var item in projectItems) + { + var include = item.EvaluatedInclude; + var assemblyName = new AssemblyName(include); + var assembly = Assembly.Load(assemblyName); + var reference = MetadataReference.CreateFromFile(assembly.Location); + references.Add(reference); + } + + var builder = new CSharpParser.Builder(); + builder = builder.References(references); + foreach (var reference in references) + { + Console.WriteLine(reference.Display); + } + + _parser = builder.Build(); + } + + public IEnumerable ParseSourceFiles() + { + return _parser.ParseInputs(_inputs, solutionDir, new InMemoryExecutionContext()); + } +} diff --git a/Rewrite/src/Rewrite.MSBuild/Rewrite.MSBuild.csproj b/Rewrite/src/Rewrite.MSBuild/Rewrite.MSBuild.csproj new file mode 100644 index 00000000..8474bef3 --- /dev/null +++ b/Rewrite/src/Rewrite.MSBuild/Rewrite.MSBuild.csproj @@ -0,0 +1,28 @@ + + + + net8.0 + moderne.png + enable + enable + + + + + + + + + + + + + + + + + + + + + diff --git a/Rewrite/src/Rewrite.MSBuild/SolutionParser.cs b/Rewrite/src/Rewrite.MSBuild/SolutionParser.cs new file mode 100644 index 00000000..74875750 --- /dev/null +++ b/Rewrite/src/Rewrite.MSBuild/SolutionParser.cs @@ -0,0 +1,69 @@ +using System.Reflection; +using log4net; +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.MSBuild; +using Rewrite.Core; +using Rewrite.RewriteCSharp; + +namespace Rewrite.MSBuild; + +public class SolutionParser +{ + private static readonly ILog log = LogManager.GetLogger(typeof(SolutionParser)); + + public async Task LoadSolutionAsync(string solutionFilePath, CancellationToken cancellationToken) + { + var workspace = MSBuildWorkspace.Create(); + return await workspace.OpenSolutionAsync(solutionFilePath, cancellationToken: cancellationToken); + } + + public IEnumerable ParseProjectSources(Solution solution, string projectName, string rootDir, + InMemoryExecutionContext ctx) + { + var project = solution.Projects.First(it => it.FilePath!.Equals(projectName)); + var fullProjectPath = Path.GetFullPath(Path.GetDirectoryName(project.FilePath!)!); + var objPath = Path.Combine(Path.GetDirectoryName(project.FilePath!)!, "obj"); + var builder = new CSharpParser.Builder(); + var allMetadataReferences = GetAllMetadataReferences(project); + var parser = builder.References(allMetadataReferences).Build(); + + IList inputs = []; + foreach (var doc in project.Documents + .Where(d => d.SourceCodeKind == SourceCodeKind.Regular) + .Where(d => Path.GetFullPath(d.FilePath!).StartsWith(fullProjectPath)) + .Where(d => !d.FilePath!.StartsWith(objPath))) + { + inputs.Add(new Parser.Input(Path.GetFullPath(doc.FilePath!), + () => new FileStream(doc.FilePath!, FileMode.Open))); + } + + var sourceFiles = parser.ParseInputs(inputs, rootDir, ctx); + return sourceFiles; + } + + private static IEnumerable GetAllMetadataReferences(Project project) + { + var allReferences = new HashSet(); + var projectsToProcess = new Queue(); + projectsToProcess.Enqueue(project); + + while (projectsToProcess.Count > 0) + { + var currentProject = projectsToProcess.Dequeue(); + + // Add metadata references of the current project + foreach (var reference in currentProject.MetadataReferences) + allReferences.Add(reference); + + // Queue up the referenced projects for processing + foreach (var projectReference in currentProject.ProjectReferences) + { + var referencedProject = project.Solution.GetProject(projectReference.ProjectId); + if (referencedProject != null && !projectsToProcess.Contains(referencedProject)) + projectsToProcess.Enqueue(referencedProject); + } + } + + return allReferences; + } +} \ No newline at end of file diff --git a/Rewrite/src/Rewrite.Remote.Codec/Rewrite.Remote.Codec.csproj b/Rewrite/src/Rewrite.Remote.Codec/Rewrite.Remote.Codec.csproj index 946b81b1..145f1d9f 100644 --- a/Rewrite/src/Rewrite.Remote.Codec/Rewrite.Remote.Codec.csproj +++ b/Rewrite/src/Rewrite.Remote.Codec/Rewrite.Remote.Codec.csproj @@ -10,29 +10,22 @@ - - - - - - + + + + + + + + + + <_Parameter1>$(MSBuildProjectName).Tests - - - - - - - - - - - diff --git a/Rewrite/src/Rewrite.Remote.Server/Options.cs b/Rewrite/src/Rewrite.Remote.Server/Options.cs new file mode 100644 index 00000000..e6dfaf92 --- /dev/null +++ b/Rewrite/src/Rewrite.Remote.Server/Options.cs @@ -0,0 +1,23 @@ +using CommandLine; +using NuGet.Configuration; + +namespace Rewrite.Remote.Server; + +public class Options +{ + [Option('p', "port", Required = false, HelpText = "Set port on which server is running.")] + public int Port { get; set; } = 54321; + + [Option('t', "timeout", Required = false, + HelpText = "Set timeout for each request in milliseconds.")] + public int TimeoutInMilliseconds { get; set; } = int.MaxValue / 1000; + + public TimeSpan Timeout => TimeSpan.FromMilliseconds(TimeoutInMilliseconds); + + [Option('l', "logfile", Required = false, HelpText = "Set log file path.")] + public string? LogFilePath { get; set; } + + [Option('f', "nupkgfolder", Required = false, HelpText = "Set nuget packages folder path.")] + public string NugetPackagesFolder { get; set; } = SettingsUtility.GetGlobalPackagesFolder(Settings.LoadDefaultSettings(null)); + +} diff --git a/Rewrite/src/Rewrite.Remote.Server/Rewrite.Remote.Server.csproj b/Rewrite/src/Rewrite.Remote.Server/Rewrite.Remote.Server.csproj new file mode 100644 index 00000000..8286cccc --- /dev/null +++ b/Rewrite/src/Rewrite.Remote.Server/Rewrite.Remote.Server.csproj @@ -0,0 +1,29 @@ + + + + net8.0 + enable + moderne.png + enable + false + + + + + + + + + + + + + + + + + + + + + diff --git a/Rewrite/src/Rewrite.Remote.Server/Server.cs b/Rewrite/src/Rewrite.Remote.Server/Server.cs new file mode 100644 index 00000000..d33fdb4d --- /dev/null +++ b/Rewrite/src/Rewrite.Remote.Server/Server.cs @@ -0,0 +1,534 @@ +using System.Formats.Cbor; +using System.Net; +using System.Net.Sockets; +using log4net; +using log4net.Appender; +using log4net.Core; +using log4net.Layout; +using log4net.Repository.Hierarchy; +using Microsoft.CodeAnalysis; +using NuGet.Configuration; +using PeterO.Cbor; +using Rewrite.Core; +using Rewrite.Core.Marker; +using Rewrite.MSBuild; +using Rewrite.Remote.Codec.CSharp; +using Rewrite.Remote.Codec.Java; +using Rewrite.Remote.Codec.Properties; +using Rewrite.Remote.Codec.Xml; +using Rewrite.Remote.Codec.Yaml; +using Rewrite.RewriteCSharp.Tree; +using Rewrite.RewriteJson.Tree; +using Rewrite.RewriteProperties.Tree; +using Rewrite.RewriteXml.Tree; +using Rewrite.RewriteYaml.Tree; + +namespace Rewrite.Remote.Server; + +public class Server +{ + private static readonly ILog log = LogManager.GetLogger(typeof(Server)); + + static Server() + { + Initialization.Initialize(); + + SenderContext.Register(typeof(Cs), () => new CSharpSender()); + SenderContext.Register(typeof(Json), () => new Codec.Json.JsonSender()); + SenderContext.Register(typeof(Yaml), () => new YamlSender()); + SenderContext.Register(typeof(Xml), () => new XmlSender()); + SenderContext.Register(typeof(Properties), () => new PropertiesSender()); + SenderContext.Register(typeof(ParseError), () => new ParseErrorSender()); + + ReceiverContext.Register(typeof(Cs), () => new CSharpReceiver()); + ReceiverContext.Register(typeof(Json), () => new Codec.Json.JsonReceiver()); + ReceiverContext.Register(typeof(Yaml), () => new YamlReceiver()); + ReceiverContext.Register(typeof(Xml), () => new XmlReceiver()); + ReceiverContext.Register(typeof(Properties), () => new PropertiesReceiver()); + ReceiverContext.Register(typeof(ParseError), () => new ParseErrorReceiver()); + + IRemotingContext.RegisterRecipeFactory(Recipe.Noop().GetType().FullName!, _ => Recipe.Noop()); + + RemotingContext.RegisterValueDeserializer((type, reader, context) => + { + Guid id = default; + string? prefix = null; + Markers? markers = null; + string? text = null; + while (reader.PeekState() != CborReaderState.EndMap) + { + switch (reader.ReadTextString()) + { + case "id": + id = (Guid)context.Deserialize(typeof(Guid), reader)!; + break; + case "prefix": + prefix = (string?)context.Deserialize(typeof(string), reader); + break; + case "markers": + markers = (Markers?)context.Deserialize(typeof(Markers), reader); + break; + case "text": + text = (string?)context.Deserialize(typeof(string), reader); + break; + } + } + + reader.ReadEndMap(); + return new Properties.Value(id, prefix!, markers!, text!); + }); + } + + private const int Ok = 0; + private const int Error = 1; + + private RemotingContext? _remotingContext; + private RemotingMessenger? _messenger; + private Solution? _solution; + private Options _options; + + public Server(Options options) + { + this._options = options; + + var hierarchy = (Hierarchy)LogManager.GetRepository(); + + var patternLayout = new PatternLayout + { + ConversionPattern = "%date [%thread] %-5level %logger - %message%newline" + }; + patternLayout.ActivateOptions(); + + ProjectParser.Init(); + IAppender appender; + if (options.LogFilePath != null) + { + var fileAppender = new FileAppender + { + AppendToFile = false, + File = options.LogFilePath, + Layout = patternLayout, + }; + fileAppender.ActivateOptions(); + appender = fileAppender; + } + else + { + var fileAppender = new ConsoleAppender + { + Layout = patternLayout, + }; + fileAppender.ActivateOptions(); + appender = fileAppender; + } + + hierarchy.Root.AddAppender(appender); + + var memory = new MemoryAppender(); + memory.ActivateOptions(); + hierarchy.Root.AddAppender(memory); + + hierarchy.Root.Level = Level.Debug; + hierarchy.Configured = true; + } + + public async Task Listen() + { + var port = _options.Port; + var timeout = _options.Timeout; + _remotingContext = new RemotingContext(); + + _messenger = new RemotingMessenger(_remotingContext, + additionalHandlers: new Dictionary> + { + { "parse-project-sources", ParseProjectSources }, + { "list-projects", ListProjects }, + { "recipe-install", InstallRecipe }, + { "run-recipe-load-and-visitor", LoadRecipeAssemblyAndRunVisitor } + }); + + var server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); + try + { + var ipAddress = IPAddress.Loopback; + var endPoint = new IPEndPoint(ipAddress, port); + + Console.WriteLine($"starting server on port ({port}) ..."); + if (log.IsDebugEnabled) + { + log.Debug($"starting server on port ({port}) ..."); + } + + server.Bind(endPoint); + server.Listen(5); + Console.WriteLine($"Server started ({port}) ..."); + if (log.IsDebugEnabled) + { + log.Debug($"Server started ({port}) ..."); + } + + while (server.Poll((int)double.Min(timeout.TotalMicroseconds, int.MaxValue), SelectMode.SelectRead)) + { + try + { + using var client = await server.AcceptAsync(); + await HandleClient(client); + } + catch (Exception e) + { + log.Error($"Failure while serving client: {e}"); + } + } + } + catch (SocketException e) + { + log.Error($"Failed to start on port {port}\n{e}"); + throw; + } + catch (Exception e) + { + Console.WriteLine(e); + log.Error(e); + throw; + } + finally + { + if (log.IsDebugEnabled) + { + log.Error("Closing server"); + } + + server.Close(); + } + } + + private async Task InstallRecipe(NetworkStream stream, RemotingContext context, + CancellationToken cancellationToken) + { + var packageId = CBORObject.Read(stream).AsString(); + var packageVersion = CBORObject.Read(stream).AsString(); + var includeDefaultSource = CBORObject.Read(stream).AsBoolean(); + var sources = CBORObject.Read(stream).Values.Select(rawSource => + { + var source = rawSource["source"].AsString(); + var packageSource = new PackageSource(source); + + var rawCredential = rawSource["credential"]; + if (rawCredential is { IsNull: false }) + { + packageSource.Credentials = + new PackageSourceCredential(source, + rawCredential["username"].AsString(), + rawCredential["password"].AsString(), + true, + null); + } + + return packageSource; + }).ToList(); + + var commandEnd = CBORObject.Read(stream); + + log.Info($$""" + Handling InstallRecipe Request: { + packageId: {{packageId}}, + packageVersion: {{packageVersion}}, + packageSources: [{{sources}}], + includeDefaultSource: [{{includeDefaultSource}}], + } + """); + + if (sources.Count == 0 && !includeDefaultSource) + { + throw new ArgumentException("No sources provided"); + } + + var installableRecipes = await + NugetManager.InstallRecipeAsync(packageId, packageVersion, includeDefaultSource ? sources.Concat([new PackageSource("https://api.nuget.org/v3/index.json")]).ToList() : sources, _options.NugetPackagesFolder, cancellationToken); + + if (log.IsDebugEnabled) + { + log.Debug($"Found {installableRecipes.Recipes.Count} recipes for package {packageId}"); + } + + + CBORObject.Write((int)RemotingMessageType.Response, stream); + CBORObject.Write(Ok, stream); + + CBORObject.Write(new Dictionary + { + { + "recipes", + installableRecipes.Recipes.Select(d => new Dictionary + { + { "name", d.Name }, + { "source", d.Source.ToString() }, + { + "options", d.Options.Select(od => new Dictionary + { + { "name", od.Name }, + { "type", od.Type }, + { "required", od.Required }, + }) + } + }).ToList() + }, + { "repository", installableRecipes.Repository }, + { "version", installableRecipes.Version }, + }, + stream + ); + } + + private async Task LoadRecipeAssemblyAndRunVisitor(NetworkStream stream, RemotingContext context, + CancellationToken cancellationToken) + { + var recipeName = CBORObject.Read(stream).AsString(); + var packageSource = new Uri(CBORObject.Read(stream).AsString()); + var packageId = packageSource.Host; + var packageVersion = packageSource.AbsolutePath.Replace("/", ""); + + var options = new Dictionary>(); + + var optionsObj = CBORObject.Read(stream); + + foreach (var optionsObjEntry in optionsObj.Entries) + { + options.Add(optionsObjEntry.Key.AsString(), optionsObjEntry.Value.ToObject); + } + + var inputStream = RemoteUtils.ReadToCommandEnd(stream); + + var received = RemotingMessenger.ReceiveTree(context, inputStream, RemotingMessenger._state); + var ctx = new InMemoryExecutionContext(); + RemotingExecutionContextView.View(ctx).RemotingContext = context; + + log.Info($$""" + Handling LoadRecipeAssemblyAndRunVisitor Request: { + recipeName: {{recipeName}}, + packageId: {{packageId}}, + packageVersion: {{packageVersion}}, + options: {{options}}, + sourceFilePath: {{((SourceFile)received).SourcePath}} + } + """); + + if (log.IsDebugEnabled) + { + log.Debug("Trying to load recipe assembly"); + } + + var loadedRecipe = await + NugetManager.LoadRecipeAssemblyAsync(recipeName, packageId, packageVersion, _options.NugetPackagesFolder, + options, + cancellationToken); + + if (log.IsDebugEnabled) + { + log.Debug($"Recipe {loadedRecipe.Descriptor.Name} was successfully loaded into the assembly. \nTrying to run it on the SourceFile"); + } + + var treeVisitor = loadedRecipe.GetVisitor(); + + if (received is SourceFile sf && treeVisitor.IsAcceptable(sf, ctx)) + { + RemotingMessenger._state = treeVisitor.Visit(sf, ctx); + } + else + { + log.Warn($"SourceFile of type [{received.GetType()}] is not acceptable"); + RemotingMessenger._state = received; + } + + if (RemotingMessenger._state == null) + { + throw new InvalidOperationException("_state cannot be null"); + } + + CBORObject.Write((int)RemotingMessageType.Response, stream); + CBORObject.Write(Ok, stream); + RemotingMessenger.SendTree(context, stream, RemotingMessenger._state, received); + } + + private Task ParseProjectSources(NetworkStream stream, RemotingContext context, + CancellationToken cancellationToken) + { + var projectFile = CBORObject.Read(stream).AsString(); + var solutionFile = CBORObject.Read(stream).AsString(); + var rootDir = CBORObject.Read(stream).AsString(); + var commandEnd = CBORObject.Read(stream); + + log.Info($$""" + Handling ParseProjectSources Request: { + projectFile: {{projectFile}}, + solutionFile: {{solutionFile}}, + rootDir: {{rootDir}}, + } + """); + + if (_solution is null || _solution.FilePath != solutionFile) + { + CBORObject.Write((int)RemotingMessageType.Response, stream); + CBORObject.Write(Error, stream); + if (_solution is null) + { + log.Error($"Failed to handle request. Solution {solutionFile} was not loaded using `list-projects`"); + CBORObject.Write($"Solution {solutionFile} was not loaded using `list-projects`", stream); + } + else + { + log.Error( + $"Failed to handle request. Solution {solutionFile} does not match loaded solution {_solution.FilePath}"); + CBORObject.Write($"Solution {solutionFile} does not match loaded solution {_solution.FilePath}", + stream); + } + + return Task.CompletedTask; + } + + if (log.IsDebugEnabled) + { + log.Debug($"Requesting all sources for project {projectFile}"); + } + + var sourceFiles = + new SolutionParser().ParseProjectSources(_solution, projectFile, rootDir, new InMemoryExecutionContext()) + .ToList(); + + if (log.IsDebugEnabled) + { + log.Debug($"Sending back the following sources: [{sourceFiles}]"); + } + + CBORObject.Write((int)RemotingMessageType.Response, stream); + CBORObject.Write(Ok, stream); + CBORObject.Write(sourceFiles.Count, stream); + foreach (var sourceFile in sourceFiles) + { + RemotingMessenger.SendTree(context, stream, sourceFile, default); + } + + return Task.CompletedTask; + } + + private async Task ListProjects(NetworkStream stream, RemotingContext context, + CancellationToken cancellationToken) + { + var solutionFile = CBORObject.Read(stream).AsString(); + var commandEnd = CBORObject.Read(stream); + + + log.Info($$""" + Handling ListProjects Request: { + solutionFile: {{solutionFile}}, + } + """); + _solution = await new SolutionParser().LoadSolutionAsync(solutionFile, cancellationToken); + + CBORObject.Write((int)RemotingMessageType.Response, stream); + CBORObject.Write(Ok, stream); + + var projects = _solution.Projects + .Where(project => project.FilePath is not null) + .Select(project => project.FilePath!) + // apply `Distinct()` as there may be multiple target frameworks + .Distinct().ToList(); + + if (log.IsDebugEnabled) + { + log.Debug($"Found the following projects [{projects}]"); + } + + CBORObject.Write(projects, stream); + } + + + private async Task HandleClient(Socket socket) + { + log.Info($"Received a new client connection {socket.RemoteEndPoint}"); + _remotingContext?.Connect(socket); + await using var stream = new NetworkStream(socket); + do + { + var dataWritten = false; + try + { + var messageType = (RemotingMessageType)CBORObject.Read(stream).AsInt32(); + if (messageType != RemotingMessageType.Request) + { + throw new ArgumentException($"Unexpected message type {messageType}"); + } + + + var cancellationTokenSource = new CancellationTokenSource(_options.Timeout); + var requestHandlingTask = _messenger!.ProcessRequest(stream, cancellationTokenSource.Token); + if (await Task.WhenAny(requestHandlingTask, Task.Delay(_options.Timeout, CancellationToken.None)) == + requestHandlingTask) + { + dataWritten = await requestHandlingTask; + } + else + { + throw new TimeoutException($"Request was not fulfilled withing given {_options.Timeout} timeout"); + } + + if (!dataWritten && stream.CanWrite) + { + try + { + log.Error("Response was not completed after processing"); + CBORObject.Write((int)RemotingMessageType.Response, stream); + CBORObject.Write(Error, stream); + CBORObject.Write("Response was not completed", stream); + } + catch (IOException exception) + { + log.Error("Failed to write response", exception); + // the socket was closed + // Console.Error.WriteLine(ignore); + break; + } + catch (Exception exception) + { + log.Error("Unexpected response sending exception", exception); + } + } + } + catch (Exception e) + { + log.Error("Response handling exception", e); + if (!dataWritten && stream.CanWrite) + { + try + { + CBORObject.Write((int)RemotingMessageType.Response, stream); + CBORObject.Write(Error, stream); + CBORObject.Write(e.ToString(), stream); + } + catch (IOException exception) + { + log.Error("Failed to write response", exception); + break; + } + catch (Exception exception) + { + log.Error("Unexpected response sending exception", exception); + } + } + } + finally + { + RemotingMessenger.SendEndMessage(stream); + stream.Flush(); + } + } while (socket.Connected && socket.Poll(TimeSpan.FromSeconds(5), SelectMode.SelectRead) && + socket.Available > 0); + + + log.Info($"Client socket disconnected {socket.RemoteEndPoint}"); + } + + + + +} diff --git a/Rewrite/src/Rewrite.Remote/DiffEvent.cs b/Rewrite/src/Rewrite.Remote/DiffEvent.cs new file mode 100644 index 00000000..1069f364 --- /dev/null +++ b/Rewrite/src/Rewrite.Remote/DiffEvent.cs @@ -0,0 +1,14 @@ +namespace Rewrite.Remote; + +public record DiffEvent(EventType EventType, string? ConcreteType, object? Msg); + +public enum EventType +{ + NoChange, + Update, + Add, + Delete, + Move, + StartList, + EndList, +} \ No newline at end of file diff --git a/Rewrite/src/Rewrite.Remote/IRemotingClient.cs b/Rewrite/src/Rewrite.Remote/IRemotingClient.cs new file mode 100644 index 00000000..36b4a1a9 --- /dev/null +++ b/Rewrite/src/Rewrite.Remote/IRemotingClient.cs @@ -0,0 +1,11 @@ +using Rewrite.Core; + +namespace Rewrite.Remote; + +public interface IRemotingClient +{ + void Hello(); + string Print(Cursor cursor); + void Reset(); + IList RunRecipe(string recipe, IDictionary options, IList sourceFiles); +} \ No newline at end of file diff --git a/Rewrite/src/Rewrite.Remote/IRemotingContext.cs b/Rewrite/src/Rewrite.Remote/IRemotingContext.cs new file mode 100644 index 00000000..61d1a982 --- /dev/null +++ b/Rewrite/src/Rewrite.Remote/IRemotingContext.cs @@ -0,0 +1,30 @@ +using System.Net.NetworkInformation; +using System.Net.Sockets; +using System.Reflection; +using PeterO.Cbor; +using Rewrite.Core; + +namespace Rewrite.Remote; + +public interface IRemotingContext +{ + internal static readonly Dictionary> RecipeFactories = new(); + internal static readonly ThreadLocal RemotingThreadLocal = new(); + IRemotingClient? Client { get; } + public static IRemotingContext? Current() => RemotingThreadLocal.Value; + + public void SetCurrent() => RemotingThreadLocal.Value = this; + void Reset(); + + public static void RegisterRecipeFactory(string recipeId, Func factory) => + RecipeFactories[recipeId] = factory; + + static IRemotingContext Create() + { + // TODO use `AssemblyDependencyResolver` to load assembly? + var type = Assembly.Load("Rewrite.Remote").GetType("Rewrite.Remote.RemotingContext"); + return (IRemotingContext)Activator.CreateInstance(type!)!; + } + + void Connect(Socket socket); +} \ No newline at end of file diff --git a/Rewrite/src/Rewrite.Remote/JsonReceiver.cs b/Rewrite/src/Rewrite.Remote/JsonReceiver.cs new file mode 100644 index 00000000..023d1054 --- /dev/null +++ b/Rewrite/src/Rewrite.Remote/JsonReceiver.cs @@ -0,0 +1,91 @@ +using System.Formats.Cbor; + +namespace Rewrite.Remote; + +public class JsonReceiver(MemoryStream stream, DeserializationContext context) + : TreeReceiver +{ + private const bool Debug = false; + + private readonly CborReader _reader = new(stream.ToArray(), CborConformanceMode.Lax, true); +#if(DEBUG) + private int _count; +#endif + + public DiffEvent ReceiveNode() + { + switch (_reader.PeekState()) + { + case CborReaderState.StartArray: + _reader.ReadStartArray(); + var eventType = (EventType)_reader.ReadInt32(); + object? msg = null; + string? concreteType = null; + switch (eventType) + { + case EventType.Add: + case EventType.Update: + concreteType = eventType == EventType.Add && _reader.PeekState() == CborReaderState.TextString + ? _reader.ReadTextString() + : null; + break; + case EventType.Delete: + case EventType.NoChange: + case EventType.StartList: + case EventType.EndList: + break; + default: + throw new NotImplementedException(eventType.ToString()); + } + + _reader.ReadEndArray(); +#if(DEBUG) + //todo: switch to proper logging infrastructure + Console.WriteLine("[" + _count++ + "] " + new DiffEvent(eventType, concreteType, msg)); +#endif + return new DiffEvent(eventType, concreteType, msg); + default: + throw new NotImplementedException(); + } + } + + public DiffEvent ReceiveValue(Type expectedType) + { + switch (_reader.PeekState()) + { + case CborReaderState.StartArray: + _reader.ReadStartArray(); + var eventType = (EventType)_reader.ReadInt32(); + object? msg = null; + string? concreteType = null; + switch (eventType) + { + case EventType.Add: + case EventType.Update: + if (expectedType.Name != "Nullable`1" && expectedType.IsGenericType && + (expectedType.GetGenericTypeDefinition().IsAssignableTo(typeof(IList<>)) || + expectedType.GetGenericTypeDefinition().IsAssignableTo(typeof(List<>)))) + // this is a special case for list events + msg = _reader.ReadInt32(); + else + msg = context.Deserialize(expectedType, _reader); + break; + case EventType.Delete: + case EventType.NoChange: + case EventType.StartList: + case EventType.EndList: + break; + default: + throw new NotImplementedException(eventType.ToString()); + } +#if(DEBUG) + //todo: switch to proper logging infrastructure + Console.WriteLine("[" + _count++ + "] " + new DiffEvent(eventType, concreteType, msg)); +#endif + _reader.ReadEndArray(); + return new DiffEvent(eventType, concreteType, msg); + default: + throw new NotImplementedException("Unexpected state: " + _reader.PeekState()); + } + } +} diff --git a/Rewrite/src/Rewrite.Remote/JsonSender.cs b/Rewrite/src/Rewrite.Remote/JsonSender.cs new file mode 100644 index 00000000..82185a31 --- /dev/null +++ b/Rewrite/src/Rewrite.Remote/JsonSender.cs @@ -0,0 +1,95 @@ +using System.Formats.Cbor; +using System.Numerics; +using Rewrite.Core.Marker; + +namespace Rewrite.Remote; + +public class JsonSender(Stream stream, SerializationContext context) : TreeSender +{ + private const bool Debug = false; + private readonly CborWriter _writer = new(CborConformanceMode.Lax, allowMultipleRootLevelValues: true); + + public void SendNode(DiffEvent diffEvent, Action visitor) + { + switch (diffEvent.EventType) + { + case EventType.Add: + case EventType.Update: + _writer.WriteStartArray(diffEvent.ConcreteType != null ? 2 : 1); + + _writer.WriteInt32((int)diffEvent.EventType); + + if (diffEvent.ConcreteType != null) + { + _writer.WriteTextString(diffEvent.ConcreteType); + } +#if(DEBUG) + //todo: switch to proper logging infrastructure + Console.WriteLine("SEND: " + diffEvent); +#endif + _writer.WriteEndArray(); + + stream.Write(_writer.Encode()); + _writer.Reset(); // reset the writer for the next frames + + visitor(this); + break; + case EventType.Delete: + case EventType.NoChange: + _writer.WriteStartArray(1); + _writer.WriteInt32((int)diffEvent.EventType); + +#if(DEBUG) + //todo: switch to proper logging infrastructure + Console.WriteLine("SEND: " + diffEvent); +#endif + _writer.WriteEndArray(); + + stream.Write(_writer.Encode()); + _writer.Reset(); // reset the writer for the next frames + break; + default: + throw new NotImplementedException(); + } + } + + public void SendValue(DiffEvent diffEvent) + { + switch (diffEvent.EventType) + { + case EventType.Add: + case EventType.Update: + _writer.WriteStartArray(diffEvent.ConcreteType != null ? 3 : 2); + _writer.WriteInt32((int)diffEvent.EventType); + if (diffEvent.ConcreteType != null) + { + _writer.WriteTextString(diffEvent.ConcreteType); + } + + context.Serialize(diffEvent.Msg, diffEvent.ConcreteType, _writer); + _writer.WriteEndArray(); + break; + case EventType.Delete: + case EventType.NoChange: + case EventType.StartList: + case EventType.EndList: + _writer.WriteStartArray(1); + _writer.WriteInt32((int)diffEvent.EventType); + _writer.WriteEndArray(); + break; + default: + throw new NotImplementedException(); + } +#if(DEBUG) + //todo: switch to proper logging infrastructure + Console.WriteLine("SEND: " + diffEvent); +#endif + stream.Write(_writer.Encode(), 0, _writer.Encode().Length); + _writer.Reset(); + } + + public void Flush() + { + stream.Flush(); + } +} diff --git a/Rewrite/src/Rewrite.Remote/OmniReceiver.cs b/Rewrite/src/Rewrite.Remote/OmniReceiver.cs new file mode 100644 index 00000000..86ce223f --- /dev/null +++ b/Rewrite/src/Rewrite.Remote/OmniReceiver.cs @@ -0,0 +1,30 @@ +using Rewrite.Core; + +namespace Rewrite.Remote; + +internal class OmniReceiver : Receiver +{ + public ReceiverContext Fork(ReceiverContext ctx) + { + throw new NotImplementedException("Cannot fork OmniReceiver"); + } + + public object Receive(T? before, ReceiverContext ctx) where T : Tree + { + var visitor = new Visitor(); + return visitor.Visit(before, ctx); + } + + private class Visitor : TreeVisitor + { + public override Tree Visit(Tree? tree, ReceiverContext ctx) + { + Cursor = new Cursor(Cursor, tree!); + + tree = ctx.PolymorphicReceiveTree(tree); + + Cursor = Cursor.Parent!; + return tree!; + } + } +} diff --git a/Rewrite/src/Rewrite.Remote/OmniSender.cs b/Rewrite/src/Rewrite.Remote/OmniSender.cs new file mode 100644 index 00000000..737c260a --- /dev/null +++ b/Rewrite/src/Rewrite.Remote/OmniSender.cs @@ -0,0 +1,12 @@ +using Rewrite.Core; + +namespace Rewrite.Remote; + +internal class OmniSender : Sender +{ + public void Send(T after, T? before, SenderContext ctx) where T : Tree + { + var sender = ctx.NewSender(after.GetType()); + sender.Send(after, before, ctx); + } +} \ No newline at end of file diff --git a/Rewrite/src/Rewrite.Remote/ParseErrorReceiver.cs b/Rewrite/src/Rewrite.Remote/ParseErrorReceiver.cs new file mode 100644 index 00000000..65238c26 --- /dev/null +++ b/Rewrite/src/Rewrite.Remote/ParseErrorReceiver.cs @@ -0,0 +1,70 @@ +using Rewrite.Core; +using Rewrite.Core.Marker; +using FileAttributes = Rewrite.Core.FileAttributes; + +namespace Rewrite.Remote; + +public class ParseErrorReceiver : Receiver +{ + public ReceiverContext Fork(ReceiverContext ctx) + { + return ctx.Fork(new Visitor(), new Factory()); + } + + public object Receive(T? before, ReceiverContext ctx) where T : Tree + { + var forked = Fork(ctx); + return forked.Visitor!.Visit(before, forked)!; + } + + private class Visitor : ParseErrorVisitor + { + + public override ParseError? Visit(Tree? tree, ReceiverContext ctx) + { + Cursor = new Cursor(Cursor, tree!); + + tree = ctx.ReceiveNode((ParseError?)tree, ctx.ReceiveTree); + + Cursor = Cursor.Parent!; + return (ParseError?)tree; + } + + public override ParseError VisitParseError(ParseError parseError, ReceiverContext ctx) + { + parseError = parseError.WithId(ctx.ReceiveValue(parseError.Id)!); + parseError = parseError.WithMarkers(ctx.ReceiveNode(parseError.Markers, ctx.ReceiveMarkers)!); + parseError = parseError.WithSourcePath(ctx.ReceiveValue(parseError.SourcePath)!); + parseError = parseError.WithFileAttributes(ctx.ReceiveValue(parseError.FileAttributes)); + parseError = parseError.WithCharsetName(ctx.ReceiveValue(parseError.CharsetName)); + parseError = parseError.WithCharsetBomMarked(ctx.ReceiveValue(parseError.CharsetBomMarked)); + parseError = parseError.WithChecksum(ctx.ReceiveValue(parseError.Checksum)); + parseError = parseError.WithText(ctx.ReceiveValue(parseError.Text)!); + // parseError = parseError.WithErroneous(ctx.ReceiveTree(parseError.Erroneous)); + return parseError; + } + } + + private class Factory : ReceiverFactory + { + public Tree Create(string type, ReceiverContext ctx) where T : Tree + { + if (type is "Rewrite.Core.ParseError" or "org.openrewrite.tree.ParseError") + { + return new ParseError( + ctx.ReceiveValue(default(Guid))!, + ctx.ReceiveNode(default(Markers), ctx.ReceiveMarkers)!, + ctx.ReceiveValue(default(string))!, + ctx.ReceiveValue(default(FileAttributes)), + ctx.ReceiveValue(default(string)), + ctx.ReceiveValue(default(bool)), + ctx.ReceiveValue(default(Checksum)), + ctx.ReceiveValue(default(string)) ?? "", + null // ctx.ReceiveTree(default(SourceFile)) + ); + } + + throw new NotImplementedException("No factory method for type: " + type); + } + } +} diff --git a/Rewrite/src/Rewrite.Remote/ParseErrorSender.cs b/Rewrite/src/Rewrite.Remote/ParseErrorSender.cs new file mode 100644 index 00000000..58a71c4f --- /dev/null +++ b/Rewrite/src/Rewrite.Remote/ParseErrorSender.cs @@ -0,0 +1,38 @@ +using Rewrite.Core; + +namespace Rewrite.Remote; + +public class ParseErrorSender : Sender +{ + public void Send(T after, T? before, SenderContext ctx) where T : Core.Tree { + var visitor = new Visitor(); + visitor.Visit(after, ctx.Fork(visitor, before)); + } + + private class Visitor : ParseErrorVisitor + { + + public override ParseError Visit(Tree? tree, SenderContext ctx) + { + Cursor = new Cursor(Cursor, tree ?? throw new InvalidOperationException($"Parameter {nameof(tree)} should not be null")); + ctx.SendNode(tree, x => x, ctx.SendTree); + Cursor = Cursor.Parent!; + + return (ParseError) tree; + } + + public override ParseError VisitParseError(ParseError parseError, SenderContext ctx) + { + ctx.SendValue(parseError, v => v.Id); + ctx.SendNode(parseError, v => v.Markers, ctx.SendMarkers); + ctx.SendValue(parseError, v => v.SourcePath); + ctx.SendTypedValue(parseError, v => v.FileAttributes); + ctx.SendValue(parseError, v => v.CharsetName); + ctx.SendValue(parseError, v => v.CharsetBomMarked); + ctx.SendTypedValue(parseError, v => v.Checksum); + ctx.SendValue(parseError, v => v.Text); + // ctx.SendNode(parseError, v => v.Erroneous, ctx.SendTree); + return parseError; + } + } +} diff --git a/Rewrite/src/Rewrite.Remote/Receiver.cs b/Rewrite/src/Rewrite.Remote/Receiver.cs new file mode 100644 index 00000000..d6c489bd --- /dev/null +++ b/Rewrite/src/Rewrite.Remote/Receiver.cs @@ -0,0 +1,9 @@ +using Rewrite.Core; + +namespace Rewrite.Remote; + +public interface Receiver +{ + ReceiverContext Fork(ReceiverContext ctx); + public object Receive(T? before, ReceiverContext ctx) where T : Tree; +} \ No newline at end of file diff --git a/Rewrite/src/Rewrite.Remote/ReceiverContext.cs b/Rewrite/src/Rewrite.Remote/ReceiverContext.cs new file mode 100644 index 00000000..b55ae860 --- /dev/null +++ b/Rewrite/src/Rewrite.Remote/ReceiverContext.cs @@ -0,0 +1,145 @@ +using System.Collections; +using System.Collections.Specialized; +using Rewrite.Core; +using Rewrite.Core.Marker; + +namespace Rewrite.Remote; + +public class ReceiverContext +{ + private static readonly SortedDictionary> Registry = new(new TypeComparer()); + + public TreeReceiver Receiver { get; } + public ITreeVisitor? Visitor { get; } + private ReceiverFactory? Factory { get; } + + public ReceiverContext(TreeReceiver receiver) + { + Receiver = receiver; + } + + private ReceiverContext(TreeReceiver receiver, ITreeVisitor visitor, + ReceiverFactory factory) + { + Receiver = receiver; + Visitor = visitor; + Factory = factory; + } + + public ReceiverContext Fork(ITreeVisitor visitor, ReceiverFactory factory) + where T : class, Tree + { + return new ReceiverContext(Receiver, visitor, factory); + } + + public static T ReceiveTree(T? before, JsonReceiver jsonReceiver) where T : Tree + { + var ctx = new ReceiverContext(jsonReceiver); + return ctx.ReceiveTree(before); + } + + public T ReceiveTree(T? before) where T : Tree + { + return (T)new OmniReceiver().Receive(before, this); + } + + public T ReceiveTree(T? before, string? type, ReceiverContext ctx) where T : Tree + { + return before != null ? (T?)before.Accept(Visitor!, ctx)! : (T)Factory!.Create(type!, ctx); + } + + public Tree? PolymorphicReceiveTree(Tree? before) + { + var diffEvent = Receiver.ReceiveNode(); + switch (diffEvent.EventType) + { + case EventType.Add: + case EventType.Update: + var treeReceiver = NewReceiver(diffEvent.ConcreteType ?? before!.GetType().FullName!); + var forked = treeReceiver.Fork(this); + return forked.ReceiveTree(diffEvent.EventType == EventType.Add ? null : before, diffEvent.ConcreteType, forked); + + case EventType.Delete: + return null; + + default: + return before; + } + } + + private Receiver NewReceiver(string typeName) + { + var type = TypeUtils.GetType(typeName); + try + { + return Registry.First(entry => entry.Key.IsAssignableFrom(type)).Value.Invoke(); + } + catch (Exception e) + { + throw new ArgumentException("Unsupported receiver type: " + typeName, e); + } + } + + public T? ReceiveNode(T? before, DetailsReceiver details) + { + var evt = Receiver.ReceiveNode(); + switch (evt.EventType) + { + case EventType.Delete: + return default; + case EventType.Add: + return details(default, evt.ConcreteType, this); + case EventType.Update: + return details(before, evt.ConcreteType, this); + } + + return before; + } + + public Markers ReceiveMarkers(Markers? before, string? type, ReceiverContext ctx) + { + var id = ReceiveValue(before?.Id ?? default); + + var afterMarkers = RemoteUtils.ReceiveValues(before?.MarkerList, ctx); + return before != null ? before.WithId(id).WithMarkers(afterMarkers!) : new Markers(id, afterMarkers!); + } + + public IList? ReceiveNodes(IList? before, DetailsReceiver details) + { + return RemoteUtils.ReceiveNodes(before, details, this); + } + + public IList ReceiveValues(IList? before) + { + return RemoteUtils.ReceiveValues(before, this)!; + } + + public T? ReceiveValue(T? before) + { + return ReceiveValue0(before); + } + + private T? ReceiveValue0(T? before) + { + var evt = Receiver.ReceiveValue(typeof(T)); + + switch (evt.EventType) + { + case EventType.Update: + case EventType.Add: + return (T?)evt.Msg; + case EventType.Delete: + return default; + case EventType.NoChange: + default: + return before; + } + } + + public static void Register(Type type, Func receiverFactory) + { + Registry.TryAdd(type, receiverFactory); + } + + public delegate T DetailsReceiver(T? before, string? type, ReceiverContext ctx); +} diff --git a/Rewrite/src/Rewrite.Remote/ReceiverFactory.cs b/Rewrite/src/Rewrite.Remote/ReceiverFactory.cs new file mode 100644 index 00000000..d321e7a0 --- /dev/null +++ b/Rewrite/src/Rewrite.Remote/ReceiverFactory.cs @@ -0,0 +1,8 @@ +using Rewrite.Core; + +namespace Rewrite.Remote; + +public interface ReceiverFactory +{ + Tree Create(string type, ReceiverContext ctx) where T : Tree; +} \ No newline at end of file diff --git a/Rewrite/src/Rewrite.Remote/RemotePrinter.cs b/Rewrite/src/Rewrite.Remote/RemotePrinter.cs new file mode 100644 index 00000000..e560b324 --- /dev/null +++ b/Rewrite/src/Rewrite.Remote/RemotePrinter.cs @@ -0,0 +1,14 @@ +using Rewrite.Core; + +namespace Rewrite.Remote; + +public class RemotePrinter

(IRemotingClient client) : TreeVisitor> +{ + public override Tree? Visit(Tree? tree, PrintOutputCapture

p) + { + Cursor = new Cursor(Cursor, tree ?? throw new InvalidOperationException($"Parameter {nameof(tree)} should not be null")); + p.Append(client.Print(Cursor)); + Cursor = Cursor.Parent!; + return tree; + } +} diff --git a/Rewrite/src/Rewrite.Remote/RemotePrinterFactory.cs b/Rewrite/src/Rewrite.Remote/RemotePrinterFactory.cs new file mode 100644 index 00000000..acab09ce --- /dev/null +++ b/Rewrite/src/Rewrite.Remote/RemotePrinterFactory.cs @@ -0,0 +1,11 @@ +using Rewrite.Core; + +namespace Rewrite.Remote; + +public class RemotePrinterFactory(IRemotingClient client) : IPrinterFactory +{ + public TreeVisitor> CreatePrinter() + { + return new RemotePrinter(client); + } +} \ No newline at end of file diff --git a/Rewrite/src/Rewrite.Remote/RemoteUtils.cs b/Rewrite/src/Rewrite.Remote/RemoteUtils.cs new file mode 100644 index 00000000..7e8520f7 --- /dev/null +++ b/Rewrite/src/Rewrite.Remote/RemoteUtils.cs @@ -0,0 +1,334 @@ +using System.Collections.Immutable; +using Rewrite.Core; +using Rewrite.Core.Marker; + +namespace Rewrite.Remote; + +internal static class RemoteUtils +{ + private static readonly byte[] CopyBuffer = new byte[16 * 1024]; + private static readonly byte[] CommandEnd = [0x81, 0x17]; + + internal static MemoryStream ReadToCommandEnd(Stream stream) + { + var memoryStream = new MemoryStream(); + + int bytesRead; + while ((bytesRead = stream.Read(CopyBuffer, 0, CopyBuffer.Length)) > 0) + { + memoryStream.Write(CopyBuffer, 0, bytesRead); + if (bytesRead > 1 && CopyBuffer[bytesRead - 2] == CommandEnd[0] && + CopyBuffer[bytesRead - 1] == CommandEnd[1]) + { + break; + } + else if (bytesRead == 1) + { + var originalPosition = memoryStream.Position; + memoryStream.Position = memoryStream.Length - 2; + if (memoryStream.ReadByte() == CommandEnd[0] && memoryStream.ReadByte() == CommandEnd[1]) + { + memoryStream.Position = originalPosition; + break; + } + } + } + + memoryStream.Position = 0; + return memoryStream; + } + + internal static IList? ReceiveNodes(IList? before, ReceiverContext.DetailsReceiver details, + ReceiverContext ctx) + { + var listEvent = ctx.Receiver.ReceiveValue(typeof(IList<>)); + switch (listEvent.EventType) + { + case EventType.NoChange: + return before; + case EventType.Delete: + return null; + case EventType.Add: + var afterSize = (int)listEvent.Msg!; + var after = new List(afterSize); + for (var i = 0; i < afterSize; i++) + { + var diffEvent = ctx.Receiver.ReceiveNode(); + if (diffEvent.EventType == EventType.Add) + { + after.Add(details(default, diffEvent.ConcreteType, ctx)); + } + else if (diffEvent.EventType == EventType.NoChange) + { + after.Add(default!); + } + else + { + throw new NotImplementedException("Unexpected operation: " + diffEvent.EventType); + } + } + + return after; + case EventType.Update: + return ReceiveUpdatedNodes(before!, (int)listEvent.Msg!, details, ctx); + default: + throw new NotImplementedException("Unexpected operation: " + listEvent.EventType); + } + } + + private static IList ReceiveUpdatedNodes(IList before, int afterSize, + ReceiverContext.DetailsReceiver details, ReceiverContext ctx) + { + var modified = false; + var afterList = before; + var evt = ctx.Receiver.ReceiveNode(); + if (evt.EventType != EventType.StartList) + { + throw new InvalidOperationException("Expected start list event: " + evt.EventType); + } + + var beforeIdx = 0; + do + { + evt = ctx.Receiver.ReceiveNode(); + switch (evt.EventType) + { + case EventType.NoChange: + case EventType.EndList: + break; + case EventType.Delete: + case EventType.Update: + case EventType.Add: + if (!modified) + { + afterList = CopyRange(before, beforeIdx); + modified = true; + } + + break; + default: + throw new NotSupportedException("Unexpected operation: " + evt.EventType); + } + + switch (evt.EventType) + { + case EventType.NoChange: + if (modified) + { + afterList.Add(before[beforeIdx]); + } + + beforeIdx++; + break; + case EventType.Delete: + beforeIdx++; + break; + case EventType.Update: + afterList.Add(details(before[beforeIdx], evt.ConcreteType, ctx)!); + beforeIdx++; + break; + case EventType.Add: + afterList.Add(details(default, evt.ConcreteType, ctx)); + break; + } + } while (evt.EventType != EventType.EndList); + + return afterList.Count > afterSize ? ((List)afterList).GetRange(0, afterSize) : afterList; + } + + internal static IList? ReceiveValues(IList? before, ReceiverContext ctx) + { + var listEvent = ctx.Receiver.ReceiveValue(typeof(IList<>)); + switch (listEvent.EventType) + { + case EventType.NoChange: + return before; + case EventType.Delete: + return null; + case EventType.Add: + var afterSize = (int)listEvent.Msg!; + var after = new List(afterSize); + for (var i = 0; i < afterSize; i++) + { + var diffEvent = ctx.Receiver.ReceiveValue(typeof(T)); + if (diffEvent.EventType == EventType.Add) + { + after.Add((T)diffEvent.Msg!); + } + else if (diffEvent.EventType == EventType.NoChange) + { + after.Add(default!); + } + else + { + throw new NotImplementedException("Unexpected operation: " + diffEvent.EventType); + } + } + + return after; + case EventType.Update: + return ReceiveUpdatedValues(before!, (int)listEvent.Msg!, ctx); + default: + throw new NotImplementedException("Unexpected operation: " + listEvent.EventType); + } + } + + private static IList ReceiveUpdatedValues(IList before, int afterSize, ReceiverContext ctx) + { + var modified = false; + var afterList = before; + var evt = ctx.Receiver.ReceiveNode(); + if (evt.EventType != EventType.StartList) + { + throw new InvalidOperationException("Expected start list event: " + evt.EventType); + } + + var beforeIdx = 0; + do + { + evt = ctx.Receiver.ReceiveValue(typeof(T)); + switch (evt.EventType) + { + case EventType.NoChange: + case EventType.EndList: + break; + case EventType.Delete: + case EventType.Update: + case EventType.Add: + if (!modified) + { + afterList = CopyRange(before, beforeIdx); + modified = true; + } + + break; + default: + throw new NotSupportedException("Unexpected operation: " + evt.EventType); + } + + switch (evt.EventType) + { + case EventType.NoChange: + if (modified) + { + afterList.Add(before[beforeIdx]); + } + + beforeIdx++; + break; + case EventType.Delete: + beforeIdx++; + break; + case EventType.Update: + afterList.Add((T)evt.Msg!); + beforeIdx++; + break; + case EventType.Add: + afterList.Add((T)evt.Msg!); + break; + } + } while (evt.EventType != EventType.EndList); + + return afterList.Count > afterSize ? ((List)afterList).GetRange(0, afterSize) : afterList; + } + + internal static void CalculateListDiff(IList before, IList after, Func idFunction, + ListDiffConsumer consumer) where T : class where I : notnull + { + int beforeIdx = 0, afterIdx = 0; + int beforeSize = before.Count, afterSize = after.Count; + Dictionary? afterMap = null; + + while (beforeIdx < beforeSize || afterIdx < afterSize) + { + // Check if we've reached the end of either of the lists + if (beforeIdx >= beforeSize) + { + consumer(Operation.Add, -1, afterIdx, default, after[afterIdx++]); + continue; + } + else if (afterIdx >= afterSize) + { + consumer(Operation.Delete, beforeIdx, -1, before[beforeIdx++], default); + continue; + } + + if (before[beforeIdx] == after[afterIdx]) + { + consumer( + Operation.NoChange, + beforeIdx, + afterIdx, + before[beforeIdx++], + after[afterIdx++] + ); + } + else + { + I beforeId = idFunction(before[beforeIdx]); + I afterId = idFunction(after[afterIdx]); + if (beforeId!.Equals(afterId)) + { + consumer( + Operation.Update, + beforeIdx, + afterIdx, + before[beforeIdx++], + after[afterIdx++] + ); + } + else + { + if (afterMap == null) + { + afterMap = CreateIndexMap(after, afterIdx, idFunction); + } + + // If elements at current indices are not equal, figure out the operation + if (!afterMap.ContainsKey(beforeId)) + { + consumer(Operation.Delete, beforeIdx, -1, before[beforeIdx++], null); + } + else + { + consumer(Operation.Add, -1, afterIdx, null, after[afterIdx++]); + } + } + } + } + } + + private static Dictionary CreateIndexMap(IList list, int fromIndex, Func idFunction) where I : notnull + { + var result = new Dictionary(list.Count - fromIndex); + for (var i = fromIndex; i < list.Count; i++) + { + result.Add(idFunction(list[i]), i); + } + + return result; + } + + + private static List CopyRange(IEnumerable before, int j) + { + return before switch + { + List list => [..list.GetRange(0, j)], + ImmutableList immutableList => [..immutableList.GetRange(0, j)], + _ => [..before.Take(j)] + }; + } + + internal delegate void ListDiffConsumer(Operation op, int beforeIndex, int afterIndex, T? beforeValue, + T? afterValue); + + internal enum Operation + { + NoChange, + Update, + Add, + Delete, + Move + } +} diff --git a/Rewrite/src/Rewrite.Remote/RemotingClient.cs b/Rewrite/src/Rewrite.Remote/RemotingClient.cs new file mode 100644 index 00000000..b1ff14d5 --- /dev/null +++ b/Rewrite/src/Rewrite.Remote/RemotingClient.cs @@ -0,0 +1,52 @@ +using System.Net.Sockets; +using Rewrite.Core; + +namespace Rewrite.Remote; + +public class RemotingClient : IRemotingClient +{ + private readonly RemotingMessenger _messenger; + private readonly Func _streamSupplier; + + internal RemotingClient(RemotingContext context, Socket socket) + { + _messenger = new RemotingMessenger(context); + _streamSupplier = () => new NetworkStream(socket); + } + + public void Hello() + { + var stream = _streamSupplier(); + lock (stream) + { + _messenger.SendRequest(stream, "hello"); + } + } + + public string Print(Cursor cursor) + { + var stream = _streamSupplier(); + lock (stream) + { + return _messenger.SendPrintRequest(stream, cursor); + } + } + + public void Reset() + { + var stream = _streamSupplier(); + lock (stream) + { + _messenger.SendResetRequest(stream); + } + } + + public IList RunRecipe(string recipe, IDictionary options, IList sourceFiles) + { + var stream = _streamSupplier(); + lock (stream) + { + return _messenger.SendRunRecipeRequest(stream, recipe, options, sourceFiles); + } + } +} \ No newline at end of file diff --git a/Rewrite/src/Rewrite.Remote/RemotingContext.cs b/Rewrite/src/Rewrite.Remote/RemotingContext.cs new file mode 100644 index 00000000..efd71389 --- /dev/null +++ b/Rewrite/src/Rewrite.Remote/RemotingContext.cs @@ -0,0 +1,79 @@ +using System.Net.Sockets; +using System.Runtime.CompilerServices; +using PeterO.Cbor; +using Rewrite.Core; + +namespace Rewrite.Remote; + +public record RemotingContext : IRemotingContext +{ + private static readonly Dictionary ValueSerializers = new(); + private static readonly List<(Type, ValueDeserializer)> ValueDeserializers = []; + + private readonly Dictionary _objectToIdMap = new(new ReferenceEqualityComparer()); + private readonly Dictionary _idToObjectMap = new(); + + + public IRemotingClient? Client { get; private set; } + + public void Connect(Socket socket) => Client = new RemotingClient(this, socket); + + public bool TryGetId(object key, out long value) => _objectToIdMap.TryGetValue(key, out value); + + public long Add(object value) + { + // FIXME make sure the ID is not already used + var id = _objectToIdMap.Count; + _objectToIdMap[value] = id; + _idToObjectMap[id] = value; + return id; + } + + public void Add(long key, object value) + { + _idToObjectMap[key] = value; + _objectToIdMap[value] = key; + } + + public object? GetObject(long key) => _idToObjectMap.GetValueOrDefault(key); + + public void Reset() + { + _idToObjectMap.Clear(); + _objectToIdMap.Clear(); + } + + public SenderContext NewSenderContext(Stream outputStream) => + new(new JsonSender(outputStream, new SerializationContext(this, ValueSerializers))); + + public ReceiverContext NewReceiverContext(MemoryStream inputStream) => + new(new JsonReceiver(inputStream, new DeserializationContext(this, ValueDeserializers))); + + public RemotingContext Copy() => new(); + + public Recipe NewRecipe(string recipeId, CBORObject recipeOptions) => + IRemotingContext.RecipeFactories[recipeId](recipeOptions); + + public static void RegisterValueSerializer(ValueSerializer serializer) => + ValueSerializers[typeof(T)] = new DelegateBasedSerializer(serializer); + + public static void RegisterValueDeserializer(ValueDeserializer deserializer) + { + for (var i = 0; i < ValueDeserializers.Count; i++) + { + var type = ValueDeserializers[i].Item1; + if (type != typeof(T)) continue; + ValueDeserializers[i] = (type, new DelegateBasedDeserializer(deserializer)); + return; + } + + ValueDeserializers.Add((typeof(T), new DelegateBasedDeserializer(deserializer))); + } +} + +internal class ReferenceEqualityComparer : IEqualityComparer +{ + public new bool Equals(object? x, object? y) => ReferenceEquals(x, y); + + public int GetHashCode(object obj) => RuntimeHelpers.GetHashCode(obj); +} diff --git a/Rewrite/src/Rewrite.Remote/RemotingExecutionContextView.cs b/Rewrite/src/Rewrite.Remote/RemotingExecutionContextView.cs new file mode 100644 index 00000000..3eafea13 --- /dev/null +++ b/Rewrite/src/Rewrite.Remote/RemotingExecutionContextView.cs @@ -0,0 +1,29 @@ +using Rewrite.Core; +using ExecutionContext = Rewrite.Core.ExecutionContext; + +namespace Rewrite.Remote; + +public class RemotingExecutionContextView(ExecutionContext @delegate) : DelegatingExecutionContext(@delegate) +{ + private readonly ExecutionContext _delegate = @delegate; + + public static RemotingExecutionContextView View(ExecutionContext ctx) + { + if (ctx is RemotingExecutionContextView) + { + return (RemotingExecutionContextView)ctx; + } + + return new RemotingExecutionContextView(ctx); + } + + public IRemotingContext? RemotingContext + { + get => _delegate.GetMessage("remoting") ?? IRemotingContext.Current(); + set + { + value?.SetCurrent(); + _delegate.PutMessage("remoting", value); + } + } +} diff --git a/Rewrite/src/Rewrite.Remote/RemotingMessageType.cs b/Rewrite/src/Rewrite.Remote/RemotingMessageType.cs new file mode 100644 index 00000000..13a9605a --- /dev/null +++ b/Rewrite/src/Rewrite.Remote/RemotingMessageType.cs @@ -0,0 +1,6 @@ +namespace Rewrite.Remote; + +public enum RemotingMessageType +{ + Request = 0, Response = 1 +} \ No newline at end of file diff --git a/Rewrite/src/Rewrite.Remote/RemotingMessenger.cs b/Rewrite/src/Rewrite.Remote/RemotingMessenger.cs new file mode 100644 index 00000000..e3c48dae --- /dev/null +++ b/Rewrite/src/Rewrite.Remote/RemotingMessenger.cs @@ -0,0 +1,299 @@ +using System.Formats.Cbor; +using System.Net.Sockets; +using log4net; +using PeterO.Cbor; +using Rewrite.Core; + +namespace Rewrite.Remote; + +public class RemotingMessenger +{ + private static readonly ILog log = LogManager.GetLogger(typeof(RemotingMessenger)); + + private const int Ok = 0; + private const int Error = 1; + + private RemotingContext _context; + + private readonly IDictionary>? + _additionalHandlers; + + public static Tree? _state; + public readonly List _recipes = []; + + public RemotingMessenger(RemotingContext context, + IDictionary>? additionalHandlers = null) + { + _context = context; + _additionalHandlers = additionalHandlers; + } + + public async Task ProcessRequest(NetworkStream stream, CancellationToken cancellationToken) + { + var command = CBORObject.Read(stream).AsString(); + if (log.IsDebugEnabled) + { + log.Debug($"Received a new client[{stream.Socket.RemoteEndPoint}]'s request command[{command}]"); + } + + switch (command) + { + case "hello": + log.Info("Handling \"hello\" Request"); + CBORObject.Read(stream); + CBORObject.Write((int)RemotingMessageType.Response, stream); + CBORObject.Write(Ok, stream); + break; + case "reset": + log.Info("Handling \"reset\" Request"); + _state = null; + _context = _context.Copy(); + _context.Connect(stream.Socket); + ReadCommandEnd(stream); + _recipes.Clear(); + CBORObject.Write((int)RemotingMessageType.Response, stream); + CBORObject.Write(Ok, stream); + break; + case "load-recipe": + LoadRecipe(stream); + ReadCommandEnd(stream); + break; + case "run-recipe-visitor": + // this already reads command end + RunRecipe(stream); + break; + case "print": + Print(stream); + ReadCommandEnd(stream); + break; + default: + if (_additionalHandlers != null && _additionalHandlers.TryGetValue(command, out var handler)) + await handler(stream, _context, cancellationToken); + else + throw new NotImplementedException("Unsupported command: " + command); + + break; + } + + return true; + } + + private void ProcessNestedRequest(NetworkStream stream) + { + AsyncHelper.RunSync(async () => + { + await ProcessRequest(stream, CancellationToken.None); + SendEndMessage(stream); + await stream.FlushAsync(); + }); + } + + private static void ReadCommandEnd(NetworkStream stream) + { + CBORObject.Read(stream); + } + + private void LoadRecipe(NetworkStream stream) + { + var recipeId = CBORObject.Read(stream).AsString(); + var recipeOptions = CBORObject.Read(stream); + + log.Info($"Handling \"LoadRecipe\" Request for Id[{recipeId}] with options {recipeOptions}"); + + var recipe = _context.NewRecipe(recipeId, recipeOptions); + _recipes.Add(recipe); + + CBORObject.Write((int)RemotingMessageType.Response, stream); + CBORObject.Write(Ok, stream); + CBORObject.Write(_recipes.Count - 1, stream); + } + + + private void RunRecipe(NetworkStream stream) + { + var recipeIndex = CBORObject.Read(stream).AsInt32(); + var recipe = _recipes[recipeIndex]; + + log.Info($"Handling \"RunRecipe\" Request for index {recipe}"); + + var inputStream = RemoteUtils.ReadToCommandEnd(stream); + + var received = ReceiveTree(_context, inputStream, _state); + var ctx = new InMemoryExecutionContext(); + RemotingExecutionContextView.View(ctx).RemotingContext = _context; + var treeVisitor = recipe.GetVisitor(); + + if (received is SourceFile sf && treeVisitor.IsAcceptable(sf, ctx)) + { + _state = treeVisitor.Visit(sf, ctx); + } + else + { + _state = received; + } + + if (_state == null) + { + throw new InvalidOperationException("State is null"); + } + + CBORObject.Write((int)RemotingMessageType.Response, stream); + CBORObject.Write(Ok, stream); + SendTree(_context, stream, _state, received); + } + + public static void SendTree(RemotingContext context, Stream stream, T after, T? before) where T : Tree + { + var outputStream = new MemoryStream(); + var senderContext = context.NewSenderContext(outputStream); + senderContext.SendTree(after, before); + outputStream.Position = 0; + + var cborWriter = new CborWriter(); + cborWriter.WriteByteString(outputStream.ToArray()); + var cborData = cborWriter.Encode(); + stream.Write(cborData, 0, cborData.Length); + } + + public static T ReceiveTree(RemotingContext context, Stream stream, T? before) where T : Tree + { + var bytes = CBORObject.Read(stream).GetByteString()!; + var receiverContext = context.NewReceiverContext(new MemoryStream(bytes)); + return receiverContext.ReceiveTree(before); + } + + private void Print(NetworkStream stream) + { + var inputStream = RemoteUtils.ReadToCommandEnd(stream); + + var received = ReceiveTree(_context, inputStream, default(Tree)); + var rootCursor = new Cursor(null, Cursor.ROOT_VALUE); + var ctx = new InMemoryExecutionContext(); + RemotingExecutionContextView.View(ctx).RemotingContext = _context; + var print = received.Print(new Cursor(rootCursor, received), new PrintOutputCapture(0)); + + CBORObject.Write((int)RemotingMessageType.Response, stream); + CBORObject.Write(Ok, stream); + CBORObject.Write(print, stream); + } + + public void SendRequest(NetworkStream stream, string command) + { + stream.WriteByte((byte)RemotingMessageType.Request); + CBORObject.Write(command, stream); + SendEndMessage(stream); + stream.Flush(); + } + + public void SendRequest(NetworkStream stream, string command, params object[] args) + { + stream.WriteByte((byte)RemotingMessageType.Request); + CBORObject.Write(command, stream); + foreach (var arg in args) + { + // FIXME serialize properly + CBORObject.Write(arg, stream); + } + + SendEndMessage(stream); + stream.Flush(); + } + + public void SendRequest(NetworkStream stream, string command, params Action[] args) + { + stream.WriteByte((byte)RemotingMessageType.Request); + CBORObject.Write(command, stream); + foreach (var arg in args) + { + arg(stream); + } + + SendEndMessage(stream); + stream.Flush(); + } + + public static void SendEndMessage(NetworkStream stream) + { + stream.WriteByte(0x81); + stream.WriteByte(0x17); + } + + public string SendPrintRequest(NetworkStream stream, Cursor cursor) + { + SendRequest(stream, "print", s => { SendTree(_context, s, cursor.GetValue()!, default); }); + + int b; + if ((b = stream.ReadByte()) != (int)RemotingMessageType.Response) + { + throw new ArgumentException("Unexpected message type: " + b); + } + + if (stream.ReadByte() != 0) + { + throw new ArgumentException("Remote print failed: " + CBORObject.Read(stream)); + } + + var print = CBORObject.Read(stream).AsString(); + var end = CBORObject.Read(stream); + return print; + } + + public IList SendRunRecipeRequest(NetworkStream stream, string recipe, + IDictionary options, IList sourceFiles) + { + SendRequest(stream, "run-recipe", s => + { + CBORObject.Write(recipe, s); + CBORObject.Write(options, s); + CBORObject.Write(sourceFiles.Count, s); + foreach (var sourceFile in sourceFiles) + { + SendTree(_context, s, sourceFile, default); + } + }); + + int b; + while ((b = stream.ReadByte()) == (int)RemotingMessageType.Request) + { + ProcessNestedRequest(stream); + } + + if (b != (int)RemotingMessageType.Response) + { + throw new ArgumentException("Unexpected message type: " + b); + } + + if (stream.ReadByte() != 0) + { + throw new ArgumentException("Remote recipe run failed: " + CBORObject.Read(stream)); + } + + var inputStream = RemoteUtils.ReadToCommandEnd(stream); + IList updated = new List(); + foreach (var sourceFile in sourceFiles) + { + updated.Add(ReceiveTree(_context, inputStream, sourceFile)); + } + + var end = CBORObject.Read(inputStream); + return updated; + } + + public void SendResetRequest(NetworkStream stream) + { + SendRequest(stream, "reset"); + + var b = stream.ReadByte(); + if (b != (int)RemotingMessageType.Response) + { + throw new ArgumentException("Unexpected message type: " + b); + } + + if (stream.ReadByte() != 0) + { + throw new ArgumentException("Remote recipe run failed: " + CBORObject.Read(stream)); + } + + var commandEnd = CBORObject.Read(stream); + } +} diff --git a/Rewrite/src/Rewrite.Remote/Rewrite.Remote.csproj b/Rewrite/src/Rewrite.Remote/Rewrite.Remote.csproj new file mode 100644 index 00000000..eda12c65 --- /dev/null +++ b/Rewrite/src/Rewrite.Remote/Rewrite.Remote.csproj @@ -0,0 +1,28 @@ + + + + net8.0 + enable + enable + CS8669 + + + + + + + + + <_Parameter1>Rewrite.Remote.Tests + + + <_Parameter1>Rewrite.Remote.Server + + + + + + + + + diff --git a/Rewrite/src/Rewrite.Remote/Sender.cs b/Rewrite/src/Rewrite.Remote/Sender.cs new file mode 100644 index 00000000..c8bafa44 --- /dev/null +++ b/Rewrite/src/Rewrite.Remote/Sender.cs @@ -0,0 +1,8 @@ +using Rewrite.Core; + +namespace Rewrite.Remote; + +public interface Sender +{ + public void Send(T after, T? before, SenderContext ctx) where T : Tree; +} \ No newline at end of file diff --git a/Rewrite/src/Rewrite.Remote/SenderContext.cs b/Rewrite/src/Rewrite.Remote/SenderContext.cs new file mode 100644 index 00000000..1dd1e2e2 --- /dev/null +++ b/Rewrite/src/Rewrite.Remote/SenderContext.cs @@ -0,0 +1,313 @@ +using Rewrite.Core; +using Rewrite.Core.Marker; + +namespace Rewrite.Remote; + +public class SenderContext +{ + private static readonly SortedDictionary> Registry = new(new TypeComparer()); + public TreeSender Sender { get; } + private ITreeVisitor? Visitor { get; } + private object? Before { get; set; } + + public SenderContext(TreeSender sender) + { + Sender = sender; + Visitor = null; + Before = null; + } + + private SenderContext(TreeSender sender, ITreeVisitor visitor, object? before) + { + Sender = sender; + Visitor = visitor; + Before = before; + } + + public Sender NewSender(Type type) + { + try + { + return Registry.First(entry => entry.Key.IsAssignableFrom(type)).Value.Invoke(); + } + catch (Exception e) + { + throw new ArgumentException("Unsupported sender type: " + type, e); + } + } + + public SenderContext Fork(ITreeVisitor visitor, object? before) where T : class, Tree + { + return new SenderContext(Sender, visitor, before); + } + + private void Visit(Action consumer, V after, object? before) + { + var saveBefore = Before; + Before = before; + consumer(after, this); + Before = saveBefore; + } + + public static void SendTree(T after, T? before, JsonSender jsonSender) where T : Tree + { + new SenderContext(jsonSender).SendTree(after, before); + } + + public void SendTree(T after, T? before) where T : Tree + { + new OmniSender().Send(after, before, this); + } + + public void SendNode(T owner, Func extractor, Action details) + { + SendNode(extractor(owner), Before != null ? extractor((T)Before) : default, details); + } + + public void SendValue(T owner, Func valueExtractor) + { + var afterValue = valueExtractor(owner); + var beforeValue = Before != null ? valueExtractor((T)Before) : default; + SendValue(afterValue, beforeValue); + } + + public void SendTypedValue(T owner, Func valueExtractor) + { + var afterValue = valueExtractor(owner); + var beforeValue = Before != null ? valueExtractor((T)Before) : default; + SendTypedValue(afterValue, beforeValue); + } + + private void SendNode(V? after, V? before, Action details) + { + DiffEvent evt; + if (AreEqual(after, before)) + { + evt = new DiffEvent(EventType.NoChange, null, null); + } + else if (before == null) + { + // FIXME this should not be `Markers` specific; should the type be passed in as a parameter? + var concreteType = typeof(V) != typeof(Markers) ? TypeUtils.ToJavaTypeName(after!.GetType()) : null; + evt = new DiffEvent(EventType.Add, concreteType, null); + } + else if (after == null) + { + evt = new DiffEvent(EventType.Delete, null, null); + } + else + { + evt = new DiffEvent(EventType.Update, null, null); + } + + Sender.SendNode(evt, _ => Visit(details!, after, before)); + } + + private void SendValue(V after, V? before) + { + DiffEvent evt; + if (Before != null && AreEqual(after, before)) + { + evt = new DiffEvent(EventType.NoChange, null, null); + } + else if (Before == null || before == null) + { + // FIXME we need a better mechanism to map types + var concreteType = after is Marker ? TypeUtils.ToJavaTypeName(after) : null; + evt = new DiffEvent(EventType.Add, concreteType, after); + } + else if (after == null) + { + evt = new DiffEvent(EventType.Delete, null, null); + } + else + { + evt = new DiffEvent(EventType.Update, null, after); + } + + Sender.SendValue(evt); + } + + private void SendTypedValue(V? after, V? before) + { + DiffEvent evt; + if (Before != null && AreEqual(after, before)) + { + evt = new DiffEvent(EventType.NoChange, null, null); + } + else if (Before == null || before == null) + { + var concreteType = after != null ? TypeUtils.ToJavaTypeName(after.GetType()) : null; + evt = new DiffEvent(EventType.Add, concreteType, after); + } + else if (after == null) + { + evt = new DiffEvent(EventType.Delete, null, null); + } + else + { + evt = new DiffEvent(EventType.Update, null, after); + } + + Sender.SendValue(evt); + } + + public void SendNodes(T owner, Func?> elementExtractor, Action details, + Func idFunction) where V : class where I : notnull + { + var afterList = elementExtractor(owner) ?? []; + var beforeList = Before == null ? null : elementExtractor((T)Before); + + if (SendListEvent(afterList, beforeList)) + { + if (beforeList != null) + { + Sender.SendValue>(new DiffEvent(EventType.StartList, null, null)); + } + + RemoteUtils.CalculateListDiff(beforeList ?? [], afterList, idFunction, + (op, _, _, beforeValue, afterValue) => + { + switch (op) + { + case RemoteUtils.Operation.Delete: + case RemoteUtils.Operation.NoChange: + case RemoteUtils.Operation.Add: + case RemoteUtils.Operation.Update: + SendNode(afterValue, beforeValue, details); + break; + case RemoteUtils.Operation.Move: + // FIXME + throw new NotImplementedException("Unexpected operation: " + op); + } + }); + if (beforeList != null) + { + Sender.SendValue>(new DiffEvent(EventType.EndList, null, null)); + } + } + } + + public void SendValues(T owner, Func?> valueExtractor, Func idFunction) where V : class where I : notnull + { + var afterList = valueExtractor(owner); + var beforeList = Before == null ? null : valueExtractor((T)Before); + + if (SendListEvent(afterList, beforeList)) + { + if (beforeList != null) + { + Sender.SendValue>(new DiffEvent(EventType.StartList, null, null)); + } + + RemoteUtils.CalculateListDiff(beforeList ?? [], afterList ?? [], idFunction, + (op, _, _, beforeValue, afterValue) => + { + switch (op) + { + case RemoteUtils.Operation.Delete: + case RemoteUtils.Operation.NoChange: + case RemoteUtils.Operation.Add: + case RemoteUtils.Operation.Update: + SendValue(afterValue, beforeValue); + break; + case RemoteUtils.Operation.Move: + // FIXME + throw new NotImplementedException("Unexpected operation: " + op); + } + }); + if (beforeList != null) + { + Sender.SendValue>(new DiffEvent(EventType.EndList, null, null)); + } + } + } + + public void SendTypedValues(T owner, Func> valueExtractor, Func idFunction) + where V : class where I : notnull + { + var afterList = valueExtractor(owner); + var beforeList = Before == null ? null : valueExtractor((T)Before); + + if (SendListEvent(afterList, beforeList)) + { + if (beforeList != null) + { + Sender.SendValue>(new DiffEvent(EventType.StartList, null, null)); + } + + RemoteUtils.CalculateListDiff(beforeList ?? [], afterList, idFunction, + (op, _, _, beforeValue, afterValue) => + { + switch (op) + { + case RemoteUtils.Operation.Delete: + case RemoteUtils.Operation.NoChange: + case RemoteUtils.Operation.Add: + case RemoteUtils.Operation.Update: + SendTypedValue(afterValue, beforeValue); + break; + case RemoteUtils.Operation.Move: + // FIXME + throw new NotImplementedException("Unexpected operation: " + op); + } + }); + if (beforeList != null) + { + Sender.SendValue>(new DiffEvent(EventType.EndList, null, null)); + } + } + } + + private bool SendListEvent(IList? after, IList? before) + { + DiffEvent evt; + if (after == before) + { + evt = new DiffEvent(EventType.NoChange, null, null); + } + else if (before == null) + { + evt = new DiffEvent(EventType.Add, null, after!.Count); + } + else if (after == null) + { + evt = new DiffEvent(EventType.Delete, null, null); + } + else + { + evt = new DiffEvent(EventType.Update, null, after.Count); + } + + Sender.SendValue(evt); + return evt.EventType != EventType.NoChange && evt.EventType != EventType.Delete; + } + + public void SendMarkers(Markers markers, SenderContext ignore) + { + SendValue(markers, ms => ms.Id); + SendValues(markers, ms => ms.MarkerList, ms => ms.Id); + } + + public void SendTree(T after, SenderContext ctx) where T : Tree + { + after.Accept(Visitor!, ctx); + } + + private static bool AreEqual(V? after, V? before) + { + if (after == null || before == null) + { + return after is null && before is null; + } + + return typeof(V).IsClass || typeof(V).IsAssignableTo(typeof(Tree)) || typeof(V).IsAssignableTo(typeof(Marker)) + ? ReferenceEquals(after, before) + : EqualityComparer.Default.Equals(after, before); + } + + public static void Register(Type type, Func senderFactory) + { + Registry.TryAdd(type, senderFactory); + } +} diff --git a/Rewrite/src/Rewrite.Remote/TreeReceiver.cs b/Rewrite/src/Rewrite.Remote/TreeReceiver.cs new file mode 100644 index 00000000..08a36bd0 --- /dev/null +++ b/Rewrite/src/Rewrite.Remote/TreeReceiver.cs @@ -0,0 +1,7 @@ +namespace Rewrite.Remote; + +public interface TreeReceiver +{ + DiffEvent ReceiveNode(); + DiffEvent ReceiveValue(Type expectedType); +} \ No newline at end of file diff --git a/Rewrite/src/Rewrite.Remote/TreeSender.cs b/Rewrite/src/Rewrite.Remote/TreeSender.cs new file mode 100644 index 00000000..dc249c4f --- /dev/null +++ b/Rewrite/src/Rewrite.Remote/TreeSender.cs @@ -0,0 +1,8 @@ +namespace Rewrite.Remote; + +public interface TreeSender +{ + void SendNode(DiffEvent diffEvent, Action visitor); + void SendValue(DiffEvent diffEvent); + void Flush(); +} \ No newline at end of file diff --git a/Rewrite/src/Rewrite.Remote/TypeComparer.cs b/Rewrite/src/Rewrite.Remote/TypeComparer.cs new file mode 100644 index 00000000..4b256081 --- /dev/null +++ b/Rewrite/src/Rewrite.Remote/TypeComparer.cs @@ -0,0 +1,9 @@ +namespace Rewrite.Remote; + +internal record TypeComparer : IComparer +{ + public int Compare(Type? x, Type? y) + { + return x == y ? 0 : x!.IsAssignableFrom(y) ? 1 : -1; + } +} diff --git a/Rewrite/src/Rewrite.Remote/TypeUtils.cs b/Rewrite/src/Rewrite.Remote/TypeUtils.cs new file mode 100644 index 00000000..8237f0b8 --- /dev/null +++ b/Rewrite/src/Rewrite.Remote/TypeUtils.cs @@ -0,0 +1,132 @@ +using System.Globalization; +using System.Reflection; +using System.Text.RegularExpressions; +using Rewrite.Core.Marker; + +namespace Rewrite.Remote; + +internal static class TypeUtils +{ + private static readonly Dictionary TypeCache = new(); + private static readonly Dictionary JavaTypeNameCache = new(); + + private static readonly Regex DotNetTypeNameRegex = + new Regex(@"Rewrite\.Rewrite(?[^.]+?)\.Tree\.(?[^+]+)(?:\+(?.+))?"); + + private static readonly Regex JavaTypeNameRegex = + new Regex(@"org\.openrewrite\.(?[^.]+?)\.tree\.(?[^$]+)(?:\$(?.+))*"); + + internal static Type GetType(string typeName) + { + if (TypeCache.TryGetValue(typeName, out var type)) return type; + + Match match; + if ((match = JavaTypeNameRegex.Match(typeName)).Success) + { + var module = ModuleFromJavaPackage(match.Groups["module"].Value); + var result = "Rewrite.Rewrite" + module + ".Tree." + match.Groups["interface"].Value + + (match.Groups["class"].Success ? "+" + match.Groups["class"].Value.Replace('$', '+') : ""); + type = Assembly.Load("Rewrite." + module).GetType(result); + } + else if ((match = DotNetTypeNameRegex.Match(typeName)).Success) + { + var module = match.Groups["module"].Value; + type = Assembly.Load("Rewrite." + module).GetType(typeName); + } + else if (typeName == "org.openrewrite.tree.ParseError") + { + type = Assembly.Load("Rewrite.Core").GetType("Rewrite.Core.ParseError"); + } + + if (type == null) + { + throw new TypeLoadException($"Unable to find type {typeName}"); + } + TypeCache.Add(typeName, type); + return type; + } + + private static string ModuleFromJavaPackage(string javaModule) + { + return javaModule == "csharp" ? "CSharp" : CultureInfo.CurrentCulture.TextInfo.ToTitleCase(javaModule); + } + + private static readonly Func PackageMap = before => + { + if (before.StartsWith("Rewrite")) + return before.Substring(7).ToLower(); + else if (before.Equals("MSBuild")) + return "csharp"; + else return before.ToLower(); + }; + + public static string ToJavaTypeName(object o) + { + if (o is UnknownJavaMarker unknown) + return unknown.Data["@c"] as string ?? throw new InvalidOperationException("Key not found"); + return ToJavaTypeName(o.GetType()); + } + + public static string ToJavaTypeName(Type type) + { + if (JavaTypeNameCache.TryGetValue(type, out var javaTypeName)) return javaTypeName; + + var typeName = type.FullName!; + if (typeName.StartsWith("Rewrite.Core.Marker.")) + { + javaTypeName = "org.openrewrite.marker." + typeName[20..].Replace('+', '$'); + } + else if (typeName.StartsWith("Rewrite.Core.")) + { + if (typeName == "Rewrite.Core.ParseError") + return "org.openrewrite.tree.ParseError"; + + javaTypeName = "org.openrewrite." + typeName[13..].Replace('+', '$'); + } + else if (type.IsPrimitive) + { + if (type == typeof(bool)) + { + javaTypeName = "java.lang.Boolean"; + } + else if (type == typeof(int)) + { + javaTypeName = "java.lang.Integer"; + } + else if (type == typeof(long)) + { + javaTypeName = "java.lang.Long"; + } + else if (type == typeof(char)) + { + javaTypeName = "java.lang.Character"; + } + else if (type == typeof(void)) + { + javaTypeName = "java.lang.Void"; + } + } + else if (type == typeof(string)) + { + javaTypeName = "java.lang.String"; + } + else + { + var match = Regex.Match(typeName, @"Rewrite.(\w+)\.(\w+\.)*([A-Za-z+0-9]+)"); + if (match.Success) + { + var package = PackageMap.Invoke(match.Groups[1].Value); + var subpackage = match.Groups[2].Success ? match.Groups[2].Value.ToLower() : ""; + javaTypeName = $"org.openrewrite.{package}.{subpackage}{match.Groups[3].Value.Replace('+', '$')}"; + } + else + { + // FIXME: IDK if that is right + javaTypeName = "java.lang.Object"; + } + } + + JavaTypeNameCache.Add(type, javaTypeName!); + return javaTypeName!; + } +} diff --git a/Rewrite/src/Rewrite.Remote/ValueDeserializer.cs b/Rewrite/src/Rewrite.Remote/ValueDeserializer.cs new file mode 100644 index 00000000..3067ef44 --- /dev/null +++ b/Rewrite/src/Rewrite.Remote/ValueDeserializer.cs @@ -0,0 +1,257 @@ +using System.Formats.Cbor; +using System.Text; +using Rewrite.Core.Marker; + +namespace Rewrite.Remote; + +public interface ValueDeserializer +{ + // TODO expectedType vs. actualType + object? Deserialize(Type type, CborReader reader, DeserializationContext context); + + public static Dictionary ReadCborMap(CborReader reader) + { + reader.ReadStartMap(); + var dict = new Dictionary(); + + while (reader.PeekState() != CborReaderState.EndMap) + { + var key = reader.ReadTextString(); + var value = ReadCborValue(reader); + + dict.TryAdd(key, value); + } + + reader.ReadEndMap(); + + return dict; + } + + public static object? ReadCborValue(CborReader reader) + { + // Check the major type of the next CBOR data item + switch (reader.PeekState()) + { + case CborReaderState.Null: + reader.ReadNull(); + return null; + case CborReaderState.TextString: + return reader.ReadTextString(); + case CborReaderState.UnsignedInteger: + case CborReaderState.NegativeInteger: + return reader.ReadInt64(); + case CborReaderState.Boolean: + return reader.ReadBoolean(); + case CborReaderState.SimpleValue: + return reader.ReadSimpleValue(); + case CborReaderState.ByteString: + return reader.ReadByteString(); + case CborReaderState.Tag: + return reader.ReadDecimal(); + case CborReaderState.StartArray: + return ReadCborArray(reader); + case CborReaderState.StartMap: + return ReadCborMap(reader); + // TODO: handle other types as necessary + default: + throw new NotSupportedException("Unsupported CBOR data type: " + reader.PeekState()); + } + } + + public static List ReadCborArray(CborReader reader) + { + var count = reader.ReadStartArray(); + var list = new List(count ?? 4); + while (reader.PeekState() != CborReaderState.EndArray) + { + var value = ReadCborValue(reader); + list.Add(value); + } + + reader.ReadEndArray(); + return list; + } +} + +public delegate T ValueDeserializer(Type type, CborReader reader, DeserializationContext context); + +internal class DelegateBasedDeserializer(ValueDeserializer @delegate) : ValueDeserializer +{ + public object? Deserialize(Type type, CborReader reader, DeserializationContext context) => + @delegate(type, reader, context); +} + +public class DeserializationContext( + RemotingContext remotingContext, + List<(Type, ValueDeserializer)> valueDeserializers) +{ + private static readonly DefaultValueDeserializer DefaultDeserializer = new(); + public RemotingContext RemotingContext => remotingContext; + + public T? Deserialize(CborReader reader) + { + return (T?)Deserialize(typeof(T), reader); + } + public object? Deserialize(Type expectedType, CborReader reader) + { + if (reader.PeekState() == CborReaderState.Null) + { + reader.ReadNull(); + return null; + } + + if (expectedType == typeof(int)) + return reader.ReadInt32(); + + if (expectedType == typeof(Guid)) + return new Guid(reader.ReadByteString()); + + if (expectedType == typeof(string)) + return reader.ReadTextString(); + + if (expectedType == typeof(bool)) + return reader.ReadBoolean(); + + if (expectedType == typeof(long)) + return reader.ReadInt64(); + + if (expectedType == typeof(double) || expectedType == typeof(float)) + return reader.ReadDouble(); + + + var isNullable = expectedType.IsGenericType && expectedType.GetGenericTypeDefinition() == typeof(Nullable<>); + var underlyingType = isNullable ? Nullable.GetUnderlyingType(expectedType)! : expectedType; + if (underlyingType.IsEnum && reader.PeekState() == CborReaderState.UnsignedInteger) + return Enum.GetValues(underlyingType).GetValue(reader.ReadInt32()); + + switch (reader.PeekState()) + { + case CborReaderState.Boolean: + return reader.ReadBoolean(); + case CborReaderState.UnsignedInteger: + case CborReaderState.NegativeInteger: + var i = reader.ReadInt32(); + var objectById = RemotingContext.GetObject(i); + return objectById ?? i; + + case CborReaderState.HalfPrecisionFloat: + case CborReaderState.SinglePrecisionFloat: + case CborReaderState.DoublePrecisionFloat: + return reader.ReadDouble(); + case CborReaderState.TextString: + var str = reader.ReadTextString(); + if (reader.PeekState() == CborReaderState.EndArray || reader.PeekState() == CborReaderState.EndMap) + return str; + + var concreteType = reader.PeekState() != CborReaderState.EndArray && reader.PeekState() != CborReaderState.EndMap + ? str + : expectedType?.FullName; + + if (concreteType == "org.openrewrite.FileAttributes") + { + ValueDeserializer.ReadCborMap(reader); + return new Rewrite.Core.FileAttributes(); + } + + if (concreteType == "java.lang.String") + return reader.ReadTextString(); + + if (concreteType == "java.lang.Boolean") + return reader.ReadBoolean(); + + if (concreteType == "java.lang.Integer") + return reader.ReadInt32(); + + if (concreteType == "java.lang.Character") + return reader.ReadTextString()[0]; + + if (concreteType == "java.lang.Long") + return reader.ReadInt64(); + + if (concreteType == "java.lang.Double") + return reader.ReadDouble(); + + if (concreteType == "java.lang.Float") + return reader.ReadSingle(); + + if (concreteType == "java.math.BigInteger") + return reader.ReadBigInteger(); + + if (concreteType == "java.math.BigDecimal") + return reader.ReadDecimal(); + + throw new NotImplementedException("No deserialization implemented for: " + concreteType); + + case CborReaderState.StartArray: + reader.ReadStartArray(); + concreteType = reader.ReadTextString(); + var actualType = TypeUtils.GetType(concreteType); + foreach (var (type, deserializer) in valueDeserializers) + { + if (!type.IsAssignableFrom(actualType)) continue; + return deserializer.Deserialize(actualType, reader, this); + } + + break; + + case CborReaderState.StartMap: + if (typeof(Marker).IsAssignableFrom(expectedType)) + { + if (reader.PeekState() == CborReaderState.UnsignedInteger) + return RemotingContext.GetObject(reader.ReadInt64()); + + var markerMap = ValueDeserializer.ReadCborMap(reader); + Marker marker; + switch (markerMap["@c"]) + { + case "org.openrewrite.marker.SearchResult": + case "Rewrite.Core.Marker.SearchResult": + var desc = markerMap.TryGetValue("description", out var value) + ? value as string + : null; + marker = new SearchResult(new Guid((markerMap["id"] as byte[])!), desc); + break; + default: + marker = new UnknownJavaMarker(new Guid((markerMap["id"] as byte[])!), markerMap!); + break; + } + + if (markerMap.TryGetValue("@ref", out var id)) + RemotingContext.Add((long)id!, marker); + + return marker; + // concreteType = msg?.GetType().FullName; + } + reader.ReadStartMap(); + if (reader.ReadTextString() != "@c") + throw new NotImplementedException("Expected @c key"); + concreteType = reader.ReadTextString(); + actualType = TypeUtils.GetType(concreteType); + foreach (var (type, deserializer) in valueDeserializers) + { + if (!type.IsAssignableFrom(actualType)) continue; + return deserializer.Deserialize(actualType, reader, this); + } + + break; + default: + throw new NotImplementedException("No deserialization implemented for: " + + expectedType); + } + + // DefaultDeserializer.Deserialize(expectedType, reader, this); + + throw new NotImplementedException("No deserializer found for: " + ValueDeserializer.ReadCborMap(reader) + .Aggregate(new StringBuilder(), (sb, kv) => sb.Append($"{kv.Key}: {kv.Value}, "), sb => sb.ToString())); + } +} + +internal class DefaultValueDeserializer : ValueDeserializer +{ + public object? Deserialize(Type? expectedType, CborReader reader, DeserializationContext context) + { + + throw new NotImplementedException("No deserializer found for: " + ValueDeserializer.ReadCborMap(reader) + .Aggregate(new StringBuilder(), (sb, kv) => sb.Append($"{kv.Key}: {kv.Value}, "), sb => sb.ToString())); + } +} diff --git a/Rewrite/src/Rewrite.Remote/ValueSerializer.cs b/Rewrite/src/Rewrite.Remote/ValueSerializer.cs new file mode 100644 index 00000000..ca2a390b --- /dev/null +++ b/Rewrite/src/Rewrite.Remote/ValueSerializer.cs @@ -0,0 +1,218 @@ +using System.Formats.Cbor; +using System.Numerics; +using Rewrite.Core.Marker; + +namespace Rewrite.Remote; + +public interface ValueSerializer +{ + void Serialize(object value, string? typeName, CborWriter writer, SerializationContext context); + + public static void WriteObjectUsingReflection(object value, string? typeName, bool withId, CborWriter writer, + SerializationContext context) + { + if (withId && context.RemotingContext.TryGetId(value, out var id)) + { + writer.WriteInt64(id); + return; + } + + writer.WriteStartMap(null); + writer.WriteTextString("@c"); + var type = Nullable.GetUnderlyingType(value.GetType()) ?? value.GetType(); + writer.WriteTextString(typeName ?? TypeUtils.ToJavaTypeName(type)); + if (withId) + { + writer.WriteTextString("@ref"); + id = context.RemotingContext.Add(value); + writer.WriteInt64(id); + } + + var properties = type.GetProperties(); + foreach (var property in properties) + { + if (property.GetMethod == null || property.GetMethod.IsStatic) + continue; + var name = property.Name; + writer.WriteTextString(char.ToLower(name[0]) + name[1..]); + context.Serialize(property.GetValue(value), null, writer); + } + + writer.WriteEndMap(); + } +} + +public delegate void ValueSerializer(T value, string? typeName, CborWriter writer, + SerializationContext context); + +internal class DelegateBasedSerializer(ValueSerializer @delegate) : ValueSerializer +{ + public void Serialize(object value, string? typeName, CborWriter writer, SerializationContext context) + { + @delegate((T)value, typeName, writer, context); + } +} + +public class SerializationContext( + RemotingContext remotingContext, + Dictionary? valueSerializers = default) +{ + private static readonly DefaultValueSerializer DefaultSerializer = new(); + public RemotingContext RemotingContext => remotingContext; + + public void Serialize(object? value, string? typeName, CborWriter writer) + { + if (value == null) + { + writer.WriteNull(); + return; + } + + if (valueSerializers != null) + { + foreach (var (type, serializer) in valueSerializers) + { + if (!type.IsInstanceOfType(value)) continue; + serializer.Serialize(value, typeName, writer, this); + return; + } + } + + DefaultSerializer.Serialize(value, typeName, writer, this); + } +} + +internal class DefaultValueSerializer : ValueSerializer +{ + public void Serialize(object value, string? typeName, CborWriter writer, SerializationContext context) + { + switch (value) + { + case Guid guid: + writer.WriteByteString(guid.ToByteArray()); + break; + case string s: + writer.WriteTextString(s); + break; + case Markers m: + { + if (context.RemotingContext.TryGetId(m, out var id)) + { + writer.WriteInt64(id); + } + else + { + id = context.RemotingContext.Add(m); + + writer.WriteStartMap(3); + writer.WriteTextString("id"); + context.Serialize(m.Id, null, writer); + writer.WriteTextString("@ref"); + writer.WriteInt64(id); + writer.WriteTextString("markers"); + writer.WriteStartArray(m.MarkerList.Count); + foreach (var marker in m.MarkerList) + { + context.Serialize(marker, null, writer); + } + + writer.WriteEndArray(); + writer.WriteEndMap(); + } + + break; + } + case int i: + writer.WriteInt32(i); + break; + case uint ui: + writer.WriteUInt32(ui); + break; + case long l: + writer.WriteInt64(l); + break; + case ulong ul: + writer.WriteUInt64(ul); + break; + case bool b: + writer.WriteBoolean(b); + break; + case Enum: + writer.WriteInt32((int)value); + break; + case double d: + writer.WriteDouble(d); + break; + case char c: + writer.WriteTextString(c.ToString()); + break; + case decimal de: + writer.WriteDecimal(de); + break; + case float f: + writer.WriteSingle(f); + break; + case BigInteger bi: + writer.WriteBigInteger(bi); + break; + case System.Collections.IList list: + { + writer.WriteStartArray(list.Count); + foreach (var o in list) + { + context.Serialize(o, null, writer); + } + + writer.WriteEndArray(); + break; + } + case System.Collections.IDictionary dictionary: + { + writer.WriteStartMap(dictionary.Count); + foreach (var key in dictionary.Keys) + { + context.Serialize(key, null, writer); + context.Serialize(dictionary[key], null, writer); + } + + writer.WriteEndMap(); + break; + } + case Marker: + { + if (context.RemotingContext.TryGetId(value, out var id)) + { + writer.WriteInt64(id); + } + else + { + id = context.RemotingContext.Add(value); + + writer.WriteStartMap(null); + writer.WriteTextString("@c"); + var type = Nullable.GetUnderlyingType(value.GetType()) ?? value.GetType(); + writer.WriteTextString(typeName ?? TypeUtils.ToJavaTypeName(type)); + writer.WriteTextString("@ref"); + writer.WriteInt64(id); + + var properties = type.GetProperties(); + foreach (var property in properties) + { + var name = property.Name; + writer.WriteTextString(char.ToLower(name[0]) + name[1..]); + context.Serialize(property.GetValue(value), null, writer); + } + + writer.WriteEndMap(); + } + + break; + } + default: + { + ValueSerializer.WriteObjectUsingReflection(value, typeName, false, writer, context); + break; + } + } + } +} \ No newline at end of file diff --git a/Rewrite/src/Rewrite.Server/Rewrite.Server.csproj b/Rewrite/src/Rewrite.Server/Rewrite.Server.csproj index aac984d3..180fc627 100644 --- a/Rewrite/src/Rewrite.Server/Rewrite.Server.csproj +++ b/Rewrite/src/Rewrite.Server/Rewrite.Server.csproj @@ -19,15 +19,8 @@ - - - - - - - - - + + diff --git a/Rewrite/src/Rewrite.Test.Engine.Remote/Rewrite.Test.Engine.Remote.csproj b/Rewrite/src/Rewrite.Test.Engine.Remote/Rewrite.Test.Engine.Remote.csproj index 370fa90a..f3a4695d 100644 --- a/Rewrite/src/Rewrite.Test.Engine.Remote/Rewrite.Test.Engine.Remote.csproj +++ b/Rewrite/src/Rewrite.Test.Engine.Remote/Rewrite.Test.Engine.Remote.csproj @@ -14,6 +14,8 @@ + + @@ -21,10 +23,4 @@ - - - - - - diff --git a/Rewrite/src/Rewrite.Test/EnvironmentInfo.cs b/Rewrite/src/Rewrite.Test/EnvironmentInfo.cs new file mode 100644 index 00000000..f1047f7e --- /dev/null +++ b/Rewrite/src/Rewrite.Test/EnvironmentInfo.cs @@ -0,0 +1,6 @@ +namespace Rewrite.Test; + +public static class EnvironmentInfo +{ + public static bool IsCI => Environment.GetEnvironmentVariable("CI")?.ToLowerInvariant() == "true"; +} diff --git a/Rewrite/src/Rewrite.Test/RewriteTest.cs b/Rewrite/src/Rewrite.Test/RewriteTest.cs index 249d8ab0..aa551434 100644 --- a/Rewrite/src/Rewrite.Test/RewriteTest.cs +++ b/Rewrite/src/Rewrite.Test/RewriteTest.cs @@ -4,6 +4,7 @@ using Microsoft.CodeAnalysis.CSharp; using Rewrite.Core; using Rewrite.Core.Quark; +using Rewrite.CSharp.Tests; using Rewrite.RewriteCSharp; using Rewrite.RewriteJava.Tree; using Xunit.Abstractions; @@ -178,7 +179,10 @@ public void RewriteRun(Action spec, params SourceSpec[] sourceSpecs) throw new Exception($"LST should not contain unknown nodes: {unknown.First()}"); } - _output.WriteLine(sourceFile.RenderLstTree()); + if(!EnvironmentInfo.IsCI) + { + _output.WriteLine(sourceFile.RenderLstTree()); + } var markers = sourceFile.Markers; sourceSpecIter.MoveNext().Should().BeTrue(); diff --git a/_build/Build.cs b/_build/Build.cs index d8e1d466..813efd35 100644 --- a/_build/Build.cs +++ b/_build/Build.cs @@ -10,12 +10,15 @@ using Nuke.Common.Tools.DotNet; using Nuke.Common.Tools.Git; using Nuke.Common.Tools.NerdbankGitVersioning; +using Nuke.Common.Tools.NuGet; using Nuke.Common.Utilities.Collections; using static Nuke.Common.EnvironmentInfo; -using static Nuke.Common.IO.FileSystemTasks; using static Nuke.Common.IO.PathConstruction; using static Nuke.Common.Tools.DotNet.DotNetTasks; +using LibGit2Sharp; +using Nuke.Common.CI.GitHubActions; +// ReSharper disable UnusedMember.Local class Build : NukeBuild { /// Support plugins are available for: @@ -26,11 +29,22 @@ class Build : NukeBuild public static int Main () => Execute(x => x.Compile); + + GitHubActions GitHubActions => GitHubActions.Instance; + + [Parameter("ApiKey for the specified source")][Secret] readonly string NugetApiKey; + [Parameter] readonly string NugetFeed = "https://api.nuget.org/v3/index.json"; + [Parameter("Configuration to build - Default is 'Debug' (local) or 'Release' (server)")] readonly Configuration Configuration = IsLocalBuild ? Configuration.Debug : Configuration.Release; AbsolutePath ArtifactsDirectory => RootDirectory / "artifacts"; [Solution(GenerateProjects = true)] Solution Solution; [NerdbankGitVersioning] NerdbankGitVersioning Version; + [GitRepositoryExt] LibGit2Sharp.Repository GitRepository; + + + + bool IsCurrentBranchCommitted() => !GitRepository.RetrieveStatus().IsDirty; Target Clean => _ => _ .Before(Restore) @@ -41,36 +55,92 @@ class Build : NukeBuild Target Restore => _ => _ .Executes(() => { + DotNetRestore(c => c + .SetProjectFile(Solution.Path) + .SetVersion(Version.NuGetPackageVersion)); }); Target Compile => _ => _ + .Description("Compiles .net projects") .DependsOn(Restore) .Executes(() => { + DotNetBuild(c => c + .SetProjectFile(Solution.Path) + .SetVersion(Version.NuGetPackageVersion)); }); Target Pack => _ => _ + .Description("Creates nuget packages inside artifacts directory") .DependsOn(Restore) .Executes(() => { DotNetPack(x => x .SetProject(Solution.Path) - .EnableIncludeSymbols() - .SetSymbolPackageFormat(DotNetSymbolPackageFormat.snupkg) .SetVersion(Version.NuGetPackageVersion) .SetOutputDirectory(ArtifactsDirectory)); }); + Target Test => _ => _ + .Description("Runs .NET tests") + .DependsOn(Restore) + .Executes(() => + { + var categoriesToExclude = new [] + { + "KnownBug", + "Exploratory", + "Roslyn" + }; + var filter = string.Join('&', categoriesToExclude.Select(x => $"Category!={x}")); + DotNetTest(x => x + .SetProjectFile(Solution.tests.Rewrite_CSharp_Tests) + .SetFilter(filter) + .SetResultsDirectory(ArtifactsDirectory / "test-results") + .SetLoggers("trx") + ); + }); + + + Target NugetPush => _ => _ + .Description("Publishes NuGet packages to Nuget.org") + .Requires(() => NugetApiKey, () => NugetFeed) + .OnlyWhenStatic(IsCurrentBranchCommitted) + .DependsOn(Pack) + .Executes(() => + { + // this.GitRepository.Head.Tip. + var artifacts = ArtifactsDirectory.GlobFiles("*.nupkg"); + if (artifacts.IsEmpty()) + { + Assert.Fail("No packages were found in artifacts directory."); + } + NuGetTasks.NuGetPush(s => s + .SetSource(NugetFeed) + .SetApiKey(NugetApiKey) + .CombineWith( + artifacts, (cs, v) => cs + .SetTargetPath(v)), + degreeOfParallelism: 3, + completeOnFailure: true); + }); + + Target CIBuild => _ => _ + .DependsOn(Compile); + + Target CIRelease => _ => _ + .DependsOn(Pack, NugetPush); + Target DownloadTestFixtures => _ => _ .Executes(() => { var fixturesDirectory = Solution.Directory / "tests" / "fixtures"; var fixturesFile = fixturesDirectory / "fixtures.txt"; var fixtures = fixturesFile.ReadAllLines() - .Select(url => new + .Select(url => new { Name = url.Split('/').Last(x => !string.IsNullOrEmpty(x)).Replace(".git",""), - Url = url + Url = url }) .ToList(); foreach (var fixture in fixtures) @@ -86,4 +156,26 @@ class Build : NukeBuild } } }); + + Target GradleAssemble => _ => _ + .Executes(() => + { + ProcessTasks.StartProcess(RootDirectory / "gradlew.bat", "assemble", RootDirectory).AssertWaitForExit(); + }); + + + string[] GetTagsForCurrentCheckout() + { + var headCommit = GitRepository.Head.Tip; + var tagsPointingAtHead = GitRepository.Tags + .Where(tag => + { + var targetCommit = (tag.Target as Commit) ?? (tag.Target as TagAnnotation)?.Target as Commit; + return targetCommit != null && targetCommit.Sha == headCommit.Sha; + }) + .Select(x => x.FriendlyName) + .ToArray(); + return tagsPointingAtHead; + } + } diff --git a/_build/GitRepositoryAttribute.cs b/_build/GitRepositoryAttribute.cs new file mode 100644 index 00000000..24a12cc9 --- /dev/null +++ b/_build/GitRepositoryAttribute.cs @@ -0,0 +1,33 @@ +// Copyright 2019 Maintainers of NUKE. +// Distributed under the MIT License. +// https://github.com/nuke-build/nuke/blob/master/LICENSE + +using System; +using System.Reflection; +using JetBrains.Annotations; +using Nuke.Common; +using Nuke.Common.Git; +using Nuke.Common.ValueInjection; + +/// +/// Injects an instance of based on the local repository. +/// +[PublicAPI] +[UsedImplicitly(ImplicitUseKindFlags.Default)] +public class GitRepositoryExtAttribute : ValueInjectionAttributeBase +{ + public override object GetValue(MemberInfo member, object instance) + { + try + { + var build = (INukeBuild) instance; + if (LibGit2Sharp.Repository.IsValid(build.RootDirectory)) + return new LibGit2Sharp.Repository(build.RootDirectory); + return null; + } + catch (Exception) + { + return null; + } + } +} diff --git a/_build/_build.csproj b/_build/_build.csproj index b9726cb4..3bd2c579 100644 --- a/_build/_build.csproj +++ b/_build/_build.csproj @@ -12,7 +12,9 @@ - + + + diff --git a/build.ps1 b/build.ps1 index 9a48eafd..4989e058 100644 --- a/build.ps1 +++ b/build.ps1 @@ -18,7 +18,7 @@ $TempDirectory = "$PSScriptRoot\\.nuke\temp" $DotNetGlobalFile = "$PSScriptRoot\\global.json" $DotNetInstallUrl = "https://dot.net/v1/dotnet-install.ps1" -$DotNetChannel = "STS" +$DotNetChannel = "LTS" $env:DOTNET_CLI_TELEMETRY_OPTOUT = 1 $env:DOTNET_NOLOGO = 1 diff --git a/build.sh b/build.sh index e58b138f..0f45fabf 100755 --- a/build.sh +++ b/build.sh @@ -14,7 +14,7 @@ TEMP_DIRECTORY="$SCRIPT_DIR//.nuke/temp" DOTNET_GLOBAL_FILE="$SCRIPT_DIR//global.json" DOTNET_INSTALL_URL="https://dot.net/v1/dotnet-install.sh" -DOTNET_CHANNEL="STS" +DOTNET_CHANNEL="LTS" export DOTNET_CLI_TELEMETRY_OPTOUT=1 export DOTNET_NOLOGO=1 diff --git a/rewrite-csharp/src/main/java/org/openrewrite/csharp/tree/Cs.java b/rewrite-csharp/src/main/java/org/openrewrite/csharp/tree/Cs.java index fbe42d60..2681f009 100644 --- a/rewrite-csharp/src/main/java/org/openrewrite/csharp/tree/Cs.java +++ b/rewrite-csharp/src/main/java/org/openrewrite/csharp/tree/Cs.java @@ -1,12 +1,12 @@ /* * Copyright 2024 the original author or authors. - *

+ * <p> * Licensed under the Moderne Source Available License (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at - *

+ * <p> * https://docs.moderne.io/licensing/moderne-source-available-license - *

+ * <p> * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. @@ -322,9 +322,9 @@ public Cs.CompilationUnit withUsings(List> usings) /** * Represents an operator declaration in C# classes, which allows overloading of operators * for custom types. - *

+ * <p> * For example: - * 

+     * <pre>
      *     // Unary operator overload
      *     public static Vector operator +(Vector a)
      *
@@ -339,7 +339,7 @@ public Cs.CompilationUnit withUsings(List> usings)
      *
      *     // Custom operator
      *     public static Point operator ++(Point p)
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -372,58 +372,58 @@ final class OperatorDeclaration implements Cs, Statement { List modifiers; /** - * 
+         * <pre>
          * IEnumerable.Vector operator +(Vector a)
          * ^^^^^^^^^^^^^^^^^^
-         *
+ * </pre> */ @Nullable JRightPadded explicitInterfaceSpecifier; /** - * 
+         * <pre>
          * public static Vector operator +(Vector a)
          *                    ^^^^^^^^
-         *
+ * </pre> */ @With @Getter Cs.Keyword operatorKeyword; /** - * 
+         * <pre>
          * public static Integer operator checked +(Integer a, Integer b)
          *                               ^^^^^^^^
-         *
+ * </pre> */ @With @Getter Cs.@Nullable Keyword checkedKeyword; /** - * 
+         * <pre>
          * public static Vector operator +(Vector a)
          *                            ^
-         *
+ * </pre> */ JLeftPadded operatorToken; /** - * 
+         * <pre>
          * public static explicit operator int(Complex c)
          *                                ^^^^
-         *
+ * </pre> */ @With @Getter TypeTree returnType; /** - * 
+         * <pre>
          * public static Vector operator + (Vector a)
          *                                ^^^^^^^^^
-         *
+ * </pre> */ JContainer parameters; @@ -436,10 +436,10 @@ public OperatorDeclaration withParameters(List parameters) { } /** - * 
+         * <pre>
          * public static Vector operator +(...) { ... }
          *                                      ^^^^^^^
-         *
+ * </pre> */ @With @Getter @@ -537,32 +537,32 @@ public enum Operator { Percent, /** - * << token + * << token */ LeftShift, /** - * >> token + * >> token */ RightShift, /** - * < token + * < token */ LessThan, /** - * > token + * > token */ GreaterThan, /** - * <= token + * <= token */ LessThanEquals, /** - * >= token + * >= token */ GreaterThanEquals, @@ -577,7 +577,7 @@ public enum Operator { NotEquals, /** - * & token + * & token */ Ampersand, @@ -641,9 +641,9 @@ public OperatorDeclaration withParameters(JContainer parameters) { /** * Represents a C# ref expression used to pass variables by reference. - *

+ * <p> * For example: - * 

+     * <pre>
      *     // Method call with ref argument
      *     Process(ref value);
      *
@@ -655,7 +655,7 @@ public OperatorDeclaration withParameters(JContainer parameters) {
      *
      *     // Ref property return
      *     public ref int Property => ref field;
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -676,10 +676,10 @@ final class RefExpression implements Cs, Expression { Markers markers; /** - * 
+         * <pre>
          * Process(ref value)
          *            ^^^^^
-         *
+ * </pre> */ @With @Getter @@ -708,9 +708,9 @@ public CoordinateBuilder.Expression getCoordinates() { /** * Represents a C# pointer type declaration. - *

+ * <p> * For example: - * 

+     * <pre>
      *     // Basic pointer declaration
      *     int* ptr;
      *        ^
@@ -718,7 +718,7 @@ public CoordinateBuilder.Expression getCoordinates() {
      *     // Pointer to pointer
      *     int** ptr;
      *         ^
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -744,10 +744,10 @@ final class PointerType implements Cs, TypeTree, Expression { Markers markers; /** - * 
+         * <pre>
          * int* ptr;
          * ^^^
-         *
+ * </pre> */ JRightPadded elementType; @@ -811,9 +811,9 @@ public PointerType withElementType(JRightPadded elementType) { /** * Represents a C# ref type, which indicates that a type is passed or returned by reference. * Used in method parameters, return types, and local variable declarations. - *

+ * <p> * For example: - * 

+     * <pre>
      *     // Method parameter
      *     void Process(ref int value)
      *
@@ -825,7 +825,7 @@ public PointerType withElementType(JRightPadded elementType) {
      *
      *     // Property
      *     ref readonly int Property => ref field;
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -846,10 +846,10 @@ final class RefType implements Cs, TypeTree, Expression { Markers markers; /** - * 
+         * <pre>
          * ref readonly int number
          *     ^^^^^^^^
-         *
+ * </pre> */ @With @Getter @@ -857,10 +857,10 @@ final class RefType implements Cs, TypeTree, Expression { Modifier readonlyKeyword; /** - * 
+         * <pre>
          * ref readonly int number
          *              ^^^
-         *
+ * </pre> */ @With @Getter @@ -1055,9 +1055,9 @@ public ForEachVariableLoop withBody(JRightPadded body) { /** * Represents a name and colon syntax in C#, which is used in various contexts such as named arguments, * tuple elements, and property patterns. - *

+ * <p> * For example: - * 

+     * <pre>
      *     // In named arguments
      *     Method(name: "John", age: 25)
      *            ^^^^          ^^^^
@@ -1069,7 +1069,7 @@ public ForEachVariableLoop withBody(JRightPadded body) {
      *     // In property patterns
      *     { Name: "John", Age: 25 }
      *      ^^^^          ^^^^
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -1094,10 +1094,10 @@ final class NameColon implements Cs { Markers markers; /** - * 
+         * <pre>
          * Method(name: "John")
          *        ^^^^
-         *
+ * </pre> */ JRightPadded name; @@ -1626,9 +1626,9 @@ public CoordinateBuilder.Expression getCoordinates() { /** * Represents a C# goto statement, which performs an unconditional jump to a labeled statement, * case label, or default label within a switch statement. - *

+ * <p> * For example: - * 

+     * <pre>
      *     // Simple goto statement
      *     goto Label;
      *
@@ -1641,7 +1641,7 @@ public CoordinateBuilder.Expression getCoordinates() {
      *     // With label declaration
      *     Label:
      *     Console.WriteLine("At label");
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -1662,12 +1662,12 @@ final class GotoStatement implements Cs, Statement { Markers markers; /** - * 
+         * <pre>
          * goto case 1;
          *      ^^^^
          * goto default;
          *      ^^^^^^^
-         *
+ * </pre> */ @With @Getter @@ -1675,12 +1675,12 @@ final class GotoStatement implements Cs, Statement { Keyword caseOrDefaultKeyword; /** - * 
+         * <pre>
          * goto case 1;
          *           ^
          * goto Label;
          *      ^^^^^
-         *
+ * </pre> */ @With @Getter @@ -1700,9 +1700,9 @@ public CoordinateBuilder.Statement getCoordinates() { /** * Represents a C# event declaration. - *

+ * <p> * For example: - * 

+     * <pre>
      * // Simple event declaration
      * public event EventHandler OnClick;
      *
@@ -1720,7 +1720,7 @@ public CoordinateBuilder.Statement getCoordinates() {
      *
      * // Static event
      * public static event Action StaticEvent;
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -1745,20 +1745,20 @@ final class EventDeclaration implements Cs, Statement { Markers markers; /** - * 
+         * <pre>
          * [Obsolete] public event EventHandler OnClick;
          * ^^^^^^^^^
-         *
+ * </pre> */ @With @Getter List attributeLists; /** - * 
+         * <pre>
          * public event EventHandler OnClick;
          * ^^^^^^
-         *
+ * </pre> */ @With @Getter @@ -1767,10 +1767,10 @@ final class EventDeclaration implements Cs, Statement { JLeftPadded typeExpression; /** - * 
+         * <pre>
          * public event EventHandler OnClick;
          *             ^^^^^^^^^^^
-         *
+ * </pre> */ public TypeTree getTypeExpression() { return typeExpression.getElement(); @@ -1784,10 +1784,10 @@ public EventDeclaration withTypeExpression(TypeTree typeExpression) { JRightPadded interfaceSpecifier; /** - * 
+         * <pre>
          * public event EventHandler INotifyPropertyChanged.OnPropertyChanged;
          *                          ^^^^^^^^^^^^^^^^^^^^
-         *
+ * </pre> */ public @Nullable NameTree getInterfaceSpecifier() { return interfaceSpecifier == null ? null : interfaceSpecifier.getElement(); @@ -1798,20 +1798,20 @@ public EventDeclaration withInterfaceSpecifier(@Nullable TypeTree interfaceSpeci } /** - * 
+         * <pre>
          * public event EventHandler OnClick;
          *                          ^^^^^^^
-         *
+ * </pre> */ @With @Getter Identifier name; /** - * 
+         * <pre>
          * public event EventHandler OnChange {
          *                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-         *
+ * </pre> */ @Nullable JContainer accessors; @@ -3977,10 +3977,10 @@ public

J acceptCSharp(CSharpVisitor

v, P p) { /** * Represents a constructor constraint in a where clause. * Example: - * 

+     * <pre>
      * where T : new()
      *           ^^^^^
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -4008,10 +4008,10 @@ public

J acceptCSharp(CSharpVisitor

v, P p) { /** * Represents a default constraint in a where clause. * Example: - * 

+     * <pre>
      * where T : default
      *           ^^^^^^^
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -4039,18 +4039,18 @@ public

J acceptCSharp(CSharpVisitor

v, P p) { /** * A declaration expression node represents a local variable declaration in an expression context. * This is used in two primary scenarios in C#: - *

    + * <ul> *
  • Out variable declarations: {@code Method(out int x)}
    • *
  • Deconstruction declarations: {@code int (x, y) = GetPoint()}
    • - *
+ * </ul> * Example 1: Out variable declaration: - * 
+     * <pre>
      * if(int.TryParse(s, out int result)) {
      *     // use result
      * }
-     *
+ * </pre> * Example 2: Deconstruction declaration: - * 
+     * <pre>
      * int (x, y) = point;
      * ^^^^^^^^^^
      * (int count, var (name, age)) = GetPersonDetails();
@@ -4058,7 +4058,7 @@ public 
 J acceptCSharp(CSharpVisitor
 v, P p) {
      *                 ^^^^^^^^^^^ ParenthesizedVariableDesignation
      *  ^^^^^^^^^ DeclarationExpression
      *      ^^^^^ SingleVariableDesignation
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -4127,13 +4127,13 @@ interface VariableDesignation extends Expression, Cs { * Represents a single variable declaration within a declaration expression. * Used both for simple out variable declarations and as elements within deconstruction declarations. * Example in out variable: - * 
+     * <pre>
      * int.TryParse(s, out int x)  // 'int x' is the SingleVariable
-     *
+ * </pre> * Example in deconstruction: - * 
+     * <pre>
      * (int x, string y) = point;  // both 'int x' and 'string y' are SingleVariables
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -4185,15 +4185,15 @@ public CoordinateBuilder.Expression getCoordinates() { /** * Represents a parenthesized list of variable declarations used in deconstruction patterns. * Example of simple deconstruction: - * 
+     * <pre>
      * int (x, y) = point;
-     *
+ * </pre> * Example of nested deconstruction: - * 
+     * <pre>
      * (int count, var (string name, int age)) = GetPersonDetails();
      *             ^^^^^^^^^^^^^^^^^^^^^^^^^^ nested ParenthesizedVariable
      *  ^^^^^^^^^ SingleVariableDesignation
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -4275,7 +4275,7 @@ public ParenthesizedVariableDesignation withVariables(JContainer + * <pre> * * if (obj is _) // discard pattern * @@ -4283,7 +4283,7 @@ public ParenthesizedVariableDesignation withVariables(JContainer + * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -4333,7 +4333,7 @@ public CoordinateBuilder.Expression getCoordinates() { * Represents a tuple expression in C#. * Can be used in tuple construction, deconstruction and tuple literals. * Examples: - * 
+     * <pre>
      * // Tuple construction
      * var point = (1, 2);
      * // Named tuple elements
@@ -4342,7 +4342,7 @@ public CoordinateBuilder.Expression getCoordinates() {
      * var nested = (1, (2, 3));
      * // Tuple type with multiple elements
      * (string name, int age) person = ("John", 25);
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -4428,9 +4428,9 @@ public TupleExpression withArguments(JContainer arguments) { /** * Represents a C# constructor declaration which may include an optional constructor initializer. - *

+ * <p> * For example: - * 

+     * <pre>
      *   // Constructor with no initializer
      *   public MyClass() {
      *   }
@@ -4442,7 +4442,7 @@ public TupleExpression withArguments(JContainer arguments) {
      *   // Constructor with this initializer
      *   public MyClass(string s) : this(int.Parse(s)) {
      *   }
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -4486,9 +4486,9 @@ public CoordinateBuilder.Statement getCoordinates() { * Represents a C# destructor which is a method called before an object is destroyed by the garbage collector. * A destructor must be named the same as the class prefixed with a tilde (~), cannot be explicitly called, * cannot have parameters or access modifiers, and cannot be overloaded or inherited. - *

+ * <p> * For example: - * 

+     * <pre>
      *     // Basic destructor
      *     ~MyClass()
      *     {
@@ -4517,8 +4517,8 @@ public CoordinateBuilder.Statement getCoordinates() {
      *             // Cleanup
      *         }
      *     }
-     *
- *

+ * </pre> + * <p> * Note: In modern C#, it's recommended to implement IDisposable pattern instead of relying on destructors * for deterministic cleanup of resources, as destructors are non-deterministic and can impact performance. */ @@ -4628,7 +4628,7 @@ public enum Type { */ PointerType, /** - * Represent &a to get pointer access for a variable + * Represent &a to get pointer access for a variable */ AddressOf, @@ -4688,14 +4688,14 @@ public Cs.Unary withOperator(JLeftPadded operator) { * Represents a constructor initializer which is a call to another constructor, either in the same class (this) * or in the base class (base). * Examples: - * 

+     * <pre>
      * class Person {
      * // Constructor with 'this' initializer
      * public Person(string name) : this(name, 0) { }
      * // Constructor with 'base' initializer
      * public Person(string name, int age) : base(name) { }
      * }
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -4770,9 +4770,9 @@ public ConstructorInitializer withArguments(JContainer arguments) { /** * Represents a C# tuple type specification, which allows grouping multiple types into a single type. * Can be used in method returns, variable declarations, etc. - *

+ * <p> * For example: - * 

+     * <pre>
      *   // Simple tuple type
      *   (int, string) coordinates;
      *
@@ -4787,7 +4787,7 @@ public ConstructorInitializer withArguments(JContainer arguments) {
      *
      *   // As parameter type
      *   public void ProcessData((int id, string value) data) { }
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -4907,9 +4907,9 @@ public

J acceptCSharp(CSharpVisitor

v, P p) { /** * Represents a C# new class instantiation expression, which can optionally include an object/collection initializer. - *

+ * <p> * For example: - * 

+     * <pre>
      * // Simple new class without initializer
      * new Person("John", 25)
      *
@@ -4921,7 +4921,7 @@ public 
 J acceptCSharp(CSharpVisitor
 v, P p) {
      *
      * // New class with constructor and initializer
      * new Person("John") { Age = 25 }
-     *
+ * </pre> * The newClassCore field contains the basic class instantiation including constructor call, * while the initializer field contains the optional object/collection initializer expressions * wrapped in a JContainer to preserve whitespace around curly braces and between initializer expressions. @@ -4977,14 +4977,14 @@ public CoordinateBuilder.Statement getCoordinates() { /** * Represents an initializer expression that consists of a list of expressions, typically used in array * or collection initialization contexts. The expressions are contained within delimiters like curly braces. - *

+ * <p> * For example: - * 

+     * <pre>
      * new int[] { 1, 2, 3 }
      *            ^^^^^^^^^
      * new List { "a", "b", "c" }
      *                   ^^^^^^^^^^^^^^^
-     *
+ * </pre> * The JContainer wrapper captures whitespace before the opening brace, while also preserving whitespace * after each expression (before commas) through its internal JRightPadded elements. */ @@ -5072,9 +5072,9 @@ public InitializerExpression withExpressions(JContainer expressions) /** * Represents implicit element access in C# which allows accessing elements without specifying the element accessor target. * This is commonly used in object initializers, collection initializers and anonymous object initializers. - *

+ * <p> * For example: - * 

+     * <pre>
      * // Collection initializer
      * new List {
      *     { 10, 20 }, // ImplicitElementAccess with two arguments
@@ -5082,11 +5082,11 @@ public InitializerExpression withExpressions(JContainer expressions)
      * }
      *
      * // Object initializer
-     * new Dictionary {
+     * new Dictionary<string, string> {
      *     { "key1", "value1" }, // ImplicitElementAccess wrapping key-value pair arguments
      *     { "key2", "value2" }
      * }
-     *
+ * </pre> * The argumentList field contains the list of arguments wrapped in braces, with whitespace preserved * before the opening brace and between arguments. */ @@ -5173,12 +5173,12 @@ public ImplicitElementAccess withArgumentList(JContainer argumentList) /** * Represents a C# yield statement which can either return a value or break from an iterator. - *

+ * <p> * For example: - * 

+     * <pre>
      *   yield return value;   // Returns next value in iterator
      *   yield break;          // Signals end of iteration
-     *
+ * </pre> */ @Getter @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @@ -5216,15 +5216,15 @@ public CoordinateBuilder.Statement getCoordinates() { /** * An expression that yields the default value of a type. - *

+ * <p> * For example: - * 

+     * <pre>
      *   default(int)         // Returns 0
      *   default(string)      // Returns null
      *   default(bool)        // Returns false
      *   default(MyClass)     // Returns null
      *   var x = default;     // Type inferred from context (C# 7.1+)
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -5318,9 +5318,9 @@ public DefaultExpression withTypeOperator(@Nullable JContainer typeOpe /** * Represents a C# is pattern expression that performs pattern matching. * The expression consists of a value to test, followed by the 'is' keyword and a pattern. - *

+ * <p> * For example: - * 

+     * <pre>
      *     // Type pattern
      *     if (obj is string)
      *
@@ -5341,7 +5341,7 @@ public DefaultExpression withTypeOperator(@Nullable JContainer typeOpe
      *
      *     // List pattern
      *     if (list is [1, 2, 3])
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -5441,9 +5441,9 @@ interface Pattern extends Expression, Cs { /** * Represents a unary pattern in C#, which negates another pattern using the "not" keyword. - *

+ * <p> * For example: - * 

+     * <pre>
      *     // Using "not" pattern to negate a type pattern
      *     if (obj is not string) { }
      *
@@ -5457,7 +5457,7 @@ interface Pattern extends Expression, Cs {
      *         case not int: // Negates type pattern
      *             break;
      *     }
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -5477,10 +5477,10 @@ final class UnaryPattern implements Cs, Pattern, Expression { Markers markers; /** - * 
+         * <pre>
          * a is not b
          *      ^^^
-         *
+ * </pre> */ @With @Getter @@ -5514,9 +5514,9 @@ public CoordinateBuilder.Expression getCoordinates() { /** * Represents a C# type pattern, which matches a value against a type and optionally assigns it to a new variable. - *

+ * <p> * For example: - * 

+     * <pre>
      *     // Simple type pattern
      *     if (obj is string)
      *
@@ -5538,7 +5538,7 @@ public CoordinateBuilder.Expression getCoordinates() {
      *         int n => n * 2,
      *         _ => 0
      *     };
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -5593,9 +5593,9 @@ public CoordinateBuilder.Expression getCoordinates() { /** * Represents a C# binary pattern that combines two patterns with a logical operator. * The binary pattern is used in pattern matching to create compound pattern tests. - *

+ * <p> * For example: - * 

+     * <pre>
      *     // Using 'and' to combine patterns
      *     if (obj is string { Length: > 0 } and not null)
      *
@@ -5617,7 +5617,7 @@ public CoordinateBuilder.Expression getCoordinates() {
      *         >= 0 and <= 50 => "Small",
      *         _ => "Large"
      *     };
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -5716,9 +5716,9 @@ public BinaryPattern withOperator(JLeftPadded operator) { /** * Represents a C# constant pattern that matches against literal values or constant expressions. - *

+ * <p> * For example: - * 

+     * <pre>
      *     // Literal constant patterns
      *     if (obj is null)
      *     if (number is 42)
@@ -5743,7 +5743,7 @@ public BinaryPattern withOperator(JLeftPadded operator) {
      *
      *     // Enum constant patterns
      *     if (day is DayOfWeek.Sunday)
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -5763,10 +5763,10 @@ final class ConstantPattern implements Pattern { Markers markers; /** - * 
+         * <pre>
          * if (obj is 42)
          *            ^^
-         *
+ * </pre> */ @With @Getter @@ -5796,9 +5796,9 @@ public CoordinateBuilder.Expression getCoordinates() { /** * Represents a C# discard pattern (_), which matches any value and discards it. - *

+ * <p> * For example: - * 

+     * <pre>
      *     // Simple discard pattern in is expression
      *     if (obj is _)
      *
@@ -5814,7 +5814,7 @@ public CoordinateBuilder.Expression getCoordinates() {
      *
      *     // In property patterns
      *     if (obj is { Id: _, Name: "test" })
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -5852,9 +5852,9 @@ public CoordinateBuilder.Expression getCoordinates() { /** * Represents a C# list pattern that matches elements in a list or array against a sequence of patterns. - *

+ * <p> * For example: - * 

+     * <pre>
      *     // Simple list patterns
      *     if (array is [1, 2, 3] lst)
      *     if (list is [1, _, 3])
@@ -5881,8 +5881,8 @@ public CoordinateBuilder.Expression getCoordinates() {
      *     };
      *
      *     // With length patterns
-     *     if (array is [> 0, <= 10] valid)
-     *
+ * if (array is [> 0, <= 10] valid) + * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -5907,18 +5907,18 @@ final class ListPattern implements Pattern { Markers markers; /** - * 
+         * <pre>
          * if (array is [1, 2, 3] lst)
          *              ^^^^^^^^^
-         *
+ * </pre> */ JContainer patterns; /** - * 
+         * <pre>
          * if (array is [1, 2, 3] lst)
          *                        ^^^
-         *
+ * </pre> */ @With @Getter @@ -5987,9 +5987,9 @@ public ListPattern withPatterns(JContainer patterns) { /** * Represents a C# parenthesized pattern expression that groups a nested pattern. - *

+ * <p> * For example: - * 

+     * <pre>
      *     // Simple parenthesized pattern
      *     if (obj is (string or int))
      *
@@ -6001,11 +6001,11 @@ public ListPattern withPatterns(JContainer patterns) {
      *
      *     // In switch expressions
      *     return value switch {
-     *         (> 0 and < 10) => "single digit",
+     *         (> 0 and < 10) => "single digit",
      *         (string or int) => "basic type",
      *         _ => "other"
      *     };
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -6030,10 +6030,10 @@ final class ParenthesizedPattern implements Pattern { Markers markers; /** - * 
+         * <pre>
          * if (obj is (string or int))
          *            ^^^^^^^^^^^^^^^
-         *
+ * </pre> */ JContainer pattern; @@ -6097,9 +6097,9 @@ public ParenthesizedPattern withPattern(JContainer pattern) { /** * Represents a C# recursive pattern that can match nested object structures, including property patterns and positional patterns. - *

+ * <p> * For example: - * 

+     * <pre>
      *     // Simple property pattern
      *     if (obj is { Name: "test", Age: > 18 })
      *
@@ -6121,7 +6121,7 @@ public ParenthesizedPattern withPattern(JContainer pattern) {
      *         Rectangle { Width: var w, Height: var h } => w * h,
      *         _ => 0
      *     };
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -6141,10 +6141,10 @@ final class RecursivePattern implements Pattern { Markers markers; /** - * 
+         * <pre>
          * if (obj is Person { Name: "test" })
          *            ^^^^^^
-         *
+ * </pre> */ @With @Getter @@ -6152,10 +6152,10 @@ final class RecursivePattern implements Pattern { TypeTree typeQualifier; /** - * 
+         * <pre>
          * if (point is (int x, int y))
          *              ^^^^^^^^^^^^^^
-         *
+ * </pre> */ @With @Getter @@ -6163,10 +6163,10 @@ final class RecursivePattern implements Pattern { PositionalPatternClause positionalPattern; /** - * 
+         * <pre>
          * if (obj is { Name: "test", Age: 18 })
          *            ^^^^^^^^^^^^^^^^^^^^^^^^^
-         *
+ * </pre> */ @With @Getter @@ -6174,10 +6174,10 @@ final class RecursivePattern implements Pattern { PropertyPatternClause propertyPattern; /** - * 
+         * <pre>
          * if (obj is Person { Name: "test" } p)
          *                                    ^
-         *
+ * </pre> */ @With @Getter @@ -6208,10 +6208,10 @@ public CoordinateBuilder.Expression getCoordinates() { /** * Represents a var pattern that is used in switch statement pattern matching. - * 
+     * <pre>
      * case var (x, y):
      *      ^^^
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -6232,10 +6232,10 @@ final class VarPattern implements Cs, Pattern { Markers markers; /** - * 
+         * <pre>
          * case var (x, y):
          *          ^^^^^^
-         *
+ * </pre> */ @With @Getter @@ -6264,9 +6264,9 @@ public CoordinateBuilder.Expression getCoordinates() { /** * Represents a positional pattern clause in C# pattern matching, which matches the deconstructed parts of an object. - *

+ * <p> * For example: - * 

+     * <pre>
      *     // Simple positional pattern
      *     if (point is (0, 0))
      *
@@ -6274,7 +6274,7 @@ public CoordinateBuilder.Expression getCoordinates() {
      *     if (point is (int x, int y))
      *
      *     // With nested patterns
-     *     if (point is (> 0, < 100))
+     *     if (point is (> 0, < 100))
      *
      *     // In switch expressions
      *     return point switch {
@@ -6282,7 +6282,7 @@ public CoordinateBuilder.Expression getCoordinates() {
      *         (var x, var y) when x == y => "on diagonal",
      *         _ => "other"
      *     };
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -6307,10 +6307,10 @@ final class PositionalPatternClause implements Cs { Markers markers; /** - * 
+         * <pre>
          * if (point is (0, 0))
          *              ^^^^^^
-         *
+ * </pre> */ JContainer subpatterns; @@ -6358,26 +6358,26 @@ public PositionalPatternClause withSubpatterns(JContainer subpattern /** * Represents a C# relational pattern that matches values using comparison operators. - *

+ * <p> * For example: - * 

+     * <pre>
      *     // Simple relational patterns
      *     if (number is > 0)
-     *     if (value is <= 100)
+     *     if (value is <= 100)
      *
      *     // In switch expressions
      *     return size switch {
      *         > 100 => "Large",
-     *         < 0 => "Invalid",
+     *         < 0 => "Invalid",
      *         _ => "Normal"
      *     };
      *
      *     // Combined with other patterns
-     *     if (x is > 0 and < 100)
+     *     if (x is > 0 and < 100)
      *
      *     // With properties
      *     if (person is { Age: >= 18 })
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -6402,18 +6402,18 @@ final class RelationalPattern implements Pattern { Markers markers; /** - * 
+         * <pre>
          * if (number is > 100)
          *               ^
-         *
+ * </pre> */ JLeftPadded operator; /** - * 
+         * <pre>
          * if (number is > 100)
          *                 ^^^
-         *
+ * </pre> */ @With @Getter @@ -6486,9 +6486,9 @@ public RelationalPattern withOperator(JLeftPadded operator) { /** * Represents a C# slice pattern that matches sequences with arbitrary elements between fixed elements. - *

+ * <p> * For example: - * 

+     * <pre>
      *     // Simple slice pattern
      *     if (array is [1, .., 5])
      *
@@ -6507,7 +6507,7 @@ public RelationalPattern withOperator(JLeftPadded operator) {
      *         [var single] => single.ToString(),
      *         [] => "empty"
      *     };
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -6552,9 +6552,9 @@ public CoordinateBuilder.Expression getCoordinates() { /** * Represents a property pattern clause in C# pattern matching, which matches against object properties. - *

+ * <p> * For example: - * 

+     * <pre>
      *     // Simple property pattern
      *     if (obj is { Name: "test" })
      *
@@ -6573,7 +6573,7 @@ public CoordinateBuilder.Expression getCoordinates() {
      *         { Type: "square", Side: var s } => s * s,
      *         _ => 0
      *     };
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -6598,10 +6598,10 @@ final class PropertyPatternClause implements Cs { Markers markers; /** - * 
+         * <pre>
          * if (obj is { Name: "test", Age: 18 })
          *            ^^^^^^^^^^^^^^^^^^^^^^^^^
-         *
+ * </pre> */ JContainer subpatterns; @@ -6651,9 +6651,9 @@ public PropertyPatternClause withSubpatterns(JContainer subpatterns) /** * Represents a subpattern in C# pattern matching, which can appear in property patterns or positional patterns. * Each subpattern consists of an optional name with a corresponding pattern. - *

+ * <p> * For example: - * 

+     * <pre>
      *     // In property patterns
      *     if (obj is { Name: "test", Age: > 18 })
      *                  ^^^^^^^^^^^^  ^^^^^^^^^
@@ -6678,7 +6678,7 @@ public PropertyPatternClause withSubpatterns(JContainer subpatterns)
      *           ^^^^^^^^^^^^  ^^^^^^^^^^^^^
      *         _ => 0
      *     };
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -6703,12 +6703,12 @@ final class Subpattern implements Cs, Expression { Markers markers; /** - * 
+         * <pre>
          * if (obj is { Name: "test" })
          *               ^^^^
          * if (point is (x: > 0))
          *               ^
-         *
+ * </pre> */ @With @Getter @@ -6716,12 +6716,12 @@ final class Subpattern implements Cs, Expression { Expression name; /** - * 
+         * <pre>
          * if (obj is { Name: "test" })
          *                    ^^^^^
          * if (point is (x: > 0))
          *                  ^^
-         *
+ * </pre> */ JLeftPadded pattern; @@ -6786,21 +6786,21 @@ public Subpattern withPattern(JLeftPadded pattern) { /** * Represents a C# switch expression which provides a concise way to handle multiple patterns with corresponding expressions. - *

+ * <p> * For example: - * 

+     * <pre>
      * var description = size switch {
-     *     < 0 => "negative",
+     *     < 0 => "negative",
      *     0 => "zero",
      *     > 0 => "positive"
      * };
      *
      * var color = (r, g, b) switch {
-     *     var (r, g, b) when r == g && g == b => "grayscale",
+     *     var (r, g, b) when r == g && g == b => "grayscale",
      *     ( > 128, _, _) => "bright red",
      *     _ => "other"
      * };
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -6825,10 +6825,10 @@ final class SwitchExpression implements Cs, Expression { Markers markers; /** - * 
+         * <pre>
          * size switch { ... }
          * ^^^^
-         *
+ * </pre> */ JRightPadded expression; @@ -6841,10 +6841,10 @@ public Cs.SwitchExpression withExpression(Expression expression) { } /** - * 
+         * <pre>
          * size switch { ... }
          *             ^^^^^
-         *
+ * </pre> */ JContainer arms; @@ -6915,11 +6915,11 @@ public Cs.SwitchExpression withArms(JContainer arms) { /** * Represents a single case arm in a switch expression, consisting of a pattern, optional when clause, and result expression. - *

+ * <p> * For example: - * 

-     * case < 0 when IsValid() => "negative",
-     * > 0 => "positive",
+     * <pre>
+     * case < 0 when IsValid() => "negative",
+     * > 0 => "positive",
      * _ => "zero"
      *
      * // With complex patterns and conditions
@@ -6928,7 +6928,7 @@ public Cs.SwitchExpression withArms(JContainer arms) {
      *     ( > 18, _) => "basic access",
      *     _ => "no access"
      * }
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -6954,20 +6954,20 @@ final class SwitchExpressionArm implements Cs { Markers markers; /** - * 
-         * < 0 when IsValid() => "negative"
+         * <pre>
+         * < 0 when IsValid() => "negative"
          * ^^^
-         *
+ * </pre> */ @With @Getter Pattern pattern; /** - * 
-         * < 0 when IsValid() => "negative"
+         * <pre>
+         * < 0 when IsValid() => "negative"
          *     ^^^^^^^^^^^^^^
-         *
+ * </pre> */ @Nullable JLeftPadded whenExpression; @@ -6981,10 +6981,10 @@ public SwitchExpressionArm withWhenExpression(@Nullable Expression whenExpressio } /** - * 
-         * < 0 when IsValid() => "negative"
+         * <pre>
+         * < 0 when IsValid() => "negative"
          *                       ^^^^^^^^^^
-         *
+ * </pre> */ JLeftPadded expression; @@ -7040,9 +7040,9 @@ public SwitchExpressionArm withExpression(JLeftPadded expression) { /** * Represents a switch statement section containing one or more case labels followed by a list of statements. - *

+ * <p> * For example: - * 

+     * <pre>
      * switch(value) {
      *     case 1:                    // single case label
      *     case 2:                    // multiple case labels
@@ -7061,7 +7061,7 @@ public SwitchExpressionArm withExpression(JLeftPadded expression) {
      *         Console.WriteLine("default");
      *         break;
      * }
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -7086,23 +7086,23 @@ final class SwitchSection implements Cs, Statement { Markers markers; /** - * 
+         * <pre>
          * case 1:
          * case 2:
          * ^^^^^^^
-         *
+ * </pre> */ @Getter @With List labels; /** - * 
+         * <pre>
          * case 1:
          *     Console.WriteLine("1");
          *     break;
          *     ^^^^^^^^^^^^^^^^^^^^
-         *
+ * </pre> */ List> statements; @@ -7159,9 +7159,9 @@ public interface SwitchLabel extends Expression { /** * Represents a default case label in a switch statement. - *

+ * <p> * For example: - * 

+     * <pre>
      * switch(value) {
      *     case 1:
      *         break;
@@ -7175,7 +7175,7 @@ public interface SwitchLabel extends Expression {
      *     1 => "one",
      *     default => "other"
      * };
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -7195,10 +7195,10 @@ final class DefaultSwitchLabel implements Cs, SwitchLabel, Expression { Markers markers; /** - * 
+         * <pre>
          * default:
          *        ^
-         *
+ * </pre> */ @With @Getter @@ -7227,9 +7227,9 @@ public CoordinateBuilder.Expression getCoordinates() { /** * Represents a pattern-based case label in a switch statement, optionally including a when clause. - *

+ * <p> * For example: - * 

+     * <pre>
      * switch(obj) {
      *     case int n when n > 0:
      *     case string s when s.Length > 0:
@@ -7238,7 +7238,7 @@ public CoordinateBuilder.Expression getCoordinates() {
      *     case not null:
      *     case > 100:
      * }
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -7263,10 +7263,10 @@ final class CasePatternSwitchLabel implements Cs, SwitchLabel { Markers markers; /** - * 
+         * <pre>
          * case int n when n > 0:
          *      ^^^^^
-         *
+ * </pre> */ @With @Getter @@ -7274,10 +7274,10 @@ final class CasePatternSwitchLabel implements Cs, SwitchLabel { /** - * 
+         * <pre>
          * case int n when n > 0:
          *            ^^^^^^^^^^
-         *
+ * </pre> */ @Nullable JLeftPadded whenClause; @@ -7291,10 +7291,10 @@ public CasePatternSwitchLabel withWhenClause(@Nullable Expression whenClause) { } /** - * 
+         * <pre>
          * case int n when n > 0 :
          *                      ^
-         *
+ * </pre> */ @With @Getter @@ -7351,9 +7351,9 @@ public CasePatternSwitchLabel withWhenClause(@Nullable JLeftPadded w /** * Represents a C# switch statement for control flow based on pattern matching and case labels. - *

+ * <p> * For example: - * 

+     * <pre>
      * switch(value) {
      *     case 1:
      *         Console.WriteLine("one");
@@ -7375,7 +7375,7 @@ public CasePatternSwitchLabel withWhenClause(@Nullable JLeftPadded w
      *         Console.WriteLine("default");
      *         break;
      * }
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -7400,10 +7400,10 @@ final class SwitchStatement implements Cs, Statement { Markers markers; /** - * 
+         * <pre>
          * switch(value) {
          *       ^^^^^^
-         *
+ * </pre> */ JContainer expression; @@ -7416,7 +7416,7 @@ public SwitchStatement withExpression(List expression) { } /** - * 
+         * <pre>
          * switch(value) {
          *     case 1:
          *         Console.WriteLine("one");
@@ -7426,7 +7426,7 @@ public SwitchStatement withExpression(List expression) {
          *         break;
          * }
          * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-         *
+ * </pre> */ JContainer sections; @@ -7487,9 +7487,9 @@ public SwitchStatement withSections(JContainer sections) { /** * Represents a C# lock statement which provides thread synchronization. - *

+ * <p> * For example: - * 

+     * <pre>
      *     // Simple lock statement
      *     lock (syncObject) {
      *         // protected code
@@ -7504,7 +7504,7 @@ public SwitchStatement withSections(JContainer sections) {
      *     lock (SyncRoot) {
      *         // thread-safe operations
      *     }
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -7530,20 +7530,20 @@ final class LockStatement implements Cs, Statement { Markers markers; /** - * 
+         * <pre>
          * lock (syncObject) { }
          *      ^^^^^^^^^^
-         *
+ * </pre> */ @With @Getter J.ControlParentheses expression; /** - * 
+         * <pre>
          * lock (syncObject) { }
          *                  ^^^^^
-         *
+ * </pre> */ JRightPadded statement; @@ -7599,9 +7599,9 @@ public LockStatement withStatement(JRightPadded statement) { * Represents a C# fixed statement which pins a moveable variable at a memory location. * The fixed statement prevents the garbage collector from relocating a movable variable * and declares a pointer to that variable. - *

+ * <p> * For example: - * 

+     * <pre>
      *     // Fixed statement with array
      *     fixed (int* p = array) {
      *         // use p
@@ -7613,15 +7613,15 @@ public LockStatement withStatement(JRightPadded statement) {
      *     }
      *
      *     // Multiple pointers in one fixed statement
-     *     fixed (byte* p1 = &b1, p2 = &b2) {
+     *     fixed (byte* p1 = &b1, p2 = &b2) {
      *         // use p1 and p2
      *     }
      *
      *     // Fixed statement with custom type
-     *     fixed (CustomStruct* ptr = &struct) {
+     *     fixed (CustomStruct* ptr = &struct) {
      *         // use ptr
      *     }
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -7641,17 +7641,17 @@ final class FixedStatement implements Cs, Statement { Markers markers; /** - * 
+         * <pre>
          * fixed (int* p = array) { }
          *       ^^^^^^^^^^^^^^
-         *
+ * </pre> */ @Getter @With ControlParentheses declarations; /** - * 
+         * <pre>
          * fixed (int* p = array) { }
          *                       ^^^^^
          *
@@ -7660,7 +7660,7 @@ final class FixedStatement implements Cs, Statement {
          * fixed (int* p = array)
          *  return p;
          *  ^^^^^^^^^
-         *
+ * </pre> */ @With @Getter @@ -7679,16 +7679,16 @@ public CoordinateBuilder.Statement getCoordinates() { } /** * Represents a C# checked or unchecked expression which controls overflow checking behavior. - *

+ * <p> * For example: - * 

+     * <pre>
      *     // Checked expression
      *     int result = checked(x + y);
      *
      *     // Unchecked expression
      *     int value = unchecked(a * b);
      *
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -7709,20 +7709,20 @@ final class CheckedExpression implements Cs, Expression { Markers markers; /** - * 
+         * <pre>
          * checked(x + y)
          * ^^^^^^^
-         *
+ * </pre> */ @With @Getter Keyword checkedOrUncheckedKeyword; /** - * 
+         * <pre>
          * checked(x + y)
          *       ^^^^^^^
-         *
+ * </pre> */ @With @Getter @@ -7752,9 +7752,9 @@ public CoordinateBuilder.Expression getCoordinates() { * Represents a C# checked statement which enforces overflow checking for arithmetic operations * and conversions. Operations within a checked block will throw OverflowException if arithmetic * overflow occurs. - *

+ * <p> * For example: - * 

+     * <pre>
      *     // Basic checked block
      *     checked {
      *         int result = int.MaxValue + 1; // throws OverflowException
@@ -7771,7 +7771,7 @@ public CoordinateBuilder.Expression getCoordinates() {
      *     checked {
      *         int result = Math.Abs(int.MinValue); // throws OverflowException
      *     }
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -7795,12 +7795,12 @@ final class CheckedStatement implements Cs, Statement { Keyword keyword; /** - * 
+         * <pre>
          * checked {
          *         ^^^^^^^^^
          * }
          * ^
-         *
+ * </pre> */ @With @Getter @@ -7822,9 +7822,9 @@ public CoordinateBuilder.Statement getCoordinates() { * Represents a C# unsafe statement block which allows direct memory manipulation and pointer operations. * Code within an unsafe block can perform operations like pointer arithmetic, fixed-size buffers, * and direct memory access. - *

+ * <p> * For example: - * 

+     * <pre>
      *     // Basic unsafe block
      *     unsafe {
      *         int* ptr = &value;
@@ -7849,7 +7849,7 @@ public CoordinateBuilder.Statement getCoordinates() {
      *         int size = sizeof(CustomStruct);
      *         byte* buffer = stackalloc byte[size];
      *     }
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -7870,12 +7870,12 @@ final class UnsafeStatement implements Cs, Statement { Markers markers; /** - * 
+         * <pre>
          * unsafe {
          *        ^^^^^^^^^
          * }
          * ^
-         *
+ * </pre> */ @With @Getter @@ -7897,9 +7897,9 @@ public CoordinateBuilder.Statement getCoordinates() { * Represents a C# range expression which creates a Range value representing a sequence of indices. * Range expressions use the '..' operator to specify start and end bounds, and can use '^' to specify * indices from the end. - *

+ * <p> * For example: - * 

+     * <pre>
      *     // Full range
      *     arr[..]
      *
@@ -7920,7 +7920,7 @@ public CoordinateBuilder.Statement getCoordinates() {
      *     // Standalone range expressions
      *     Range r1 = 1..4;
      *     Range r2 = ..^1;
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -7946,19 +7946,19 @@ final class RangeExpression implements Cs, Expression { Markers markers; /** - * 
+         * <pre>
          * 2  ..5
          * ^^^
-         *
+ * </pre> */ @Nullable JRightPadded start; /** - * 
+         * <pre>
          * 2..5
          *   ^
-         *
+ * </pre> */ @With @Getter @@ -8026,9 +8026,9 @@ public RangeExpression withStart(@Nullable JRightPadded start) { /** * Represents a C# LINQ query expression that provides SQL-like syntax for working with collections. - *

+ * <p> * For example: - * 

+     * <pre>
      *     // Simple query
      *     from user in users
      *     where user.Age > 18
@@ -8046,7 +8046,7 @@ public RangeExpression withStart(@Nullable JRightPadded start) {
      *     from o in c.Orders
      *     where o.Total > 1000
      *     select new { c.Name, o.Total }
-     *
+ * </pre> */ @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @AllArgsConstructor(access = AccessLevel.PUBLIC) @@ -8065,22 +8065,22 @@ final class QueryExpression implements Cs, Expression { Markers markers; /** - * 
+         * <pre>
          * from user in users
          * ^^^^^^^^^^^^^^^^^^
-         *
+ * </pre> */ @With @Getter FromClause fromClause; /** - * 
+         * <pre>
          * from user in users
          * where user.Age > 18
          * select user.Name
          * ^^^^^^^^^^^^^^^^^ excluding the from clause
-         *
+ * </pre> */ @With @Getter @@ -8116,9 +8116,9 @@ public interface SelectOrGroupClause extends Cs /** * Represents the body of a LINQ query expression, consisting of the query clauses and a final select or group clause. - *

+ * <p> * For example: - * 

+     * <pre>
      *     // Body of query includes everything after initial 'from':
      *     from c in customers
      *     where c.Age > 18       // Clauses part
@@ -8133,7 +8133,7 @@ public interface SelectOrGroupClause extends Cs
      *         on o.CustomerId equals c.Id
      *     where o.Total > 1000   // Clauses part
      *     select new { o, c }    // SelectOrGroup part
-     *
+ * </pre> */ @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @AllArgsConstructor(access = AccessLevel.PUBLIC) @@ -8152,26 +8152,26 @@ final class QueryBody implements Cs { Markers markers; /** - * 
+         * <pre>
          * from c in customers
          * where c.Age > 18
          * ^^^^^^^^^^^^^^^^
          * orderby c.LastName
          * ^^^^^^^^^^^^^^^^^^
          * select c.Name
-         *
+ * </pre> */ @With @Getter List clauses; /** - * 
+         * <pre>
          * from c in customers
          * where c.Age > 18
          * select c.Name
          * ^^^^^^^^^^^^^ the final select or group clause
-         *
+ * </pre> */ @With @Getter @@ -8179,13 +8179,13 @@ final class QueryBody implements Cs { SelectOrGroupClause selectOrGroup; /** - * 
+         * <pre>
          * from c in customers
          * select c
          * into temp            // Continuation starts here
          * where temp.Age > 18
          * select temp.Name
-         *
+ * </pre> */ @With @Getter @@ -8205,9 +8205,9 @@ interface QueryClause extends Cs /** * Represents a LINQ from clause that introduces a range variable and its source collection. * This is typically the initial clause of a LINQ query. - *

+ * <p> * For example: - * 

+     * <pre>
      *     // Simple from clause
      *     from user in users
      *
@@ -8219,7 +8219,7 @@ interface QueryClause extends Cs
      *
      *     // With type and pattern
      *     from (int x, int y) in coordinates
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -8244,10 +8244,10 @@ final class FromClause implements Cs, QueryClause, Expression { Markers markers; /** - * 
+         * <pre>
          * from Customer c in customers
          *     ^^^^^^^^^
-         *
+ * </pre> */ @With @Getter @@ -8255,18 +8255,18 @@ final class FromClause implements Cs, QueryClause, Expression { TypeTree typeIdentifier; /** - * 
+         * <pre>
          * from Customer c in customers
          *              ^^
-         *
+ * </pre> */ JRightPadded identifier; /** - * 
+         * <pre>
          * from user in users
          *             ^^^^^^
-         *
+ * </pre> */ @With @Getter @@ -8331,9 +8331,9 @@ public FromClause withIdentifier(JRightPadded identifier) { /** * Represents a let clause in a C# LINQ query expression that introduces * a new range variable based on a computation. - *

+ * <p> * For example: - * 

+     * <pre>
      *     // Simple let clause
      *     from n in numbers
      *     let square = n * n
@@ -8350,7 +8350,7 @@ public FromClause withIdentifier(JRightPadded identifier) {
      *     let fullName = p.FirstName + " " + p.LastName
      *     let age = DateTime.Now.Year - p.BirthYear
      *     select new { fullName, age }
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -8375,18 +8375,18 @@ final class LetClause implements Cs, QueryClause { Markers markers; /** - * 
+         * <pre>
          * let square = n * n
          *    ^^^^^^^^^
-         *
+ * </pre> */ JRightPadded identifier; /** - * 
+         * <pre>
          * let square = n * n
          *             ^^^^^^
-         *
+ * </pre> */ @With @Getter @@ -8438,9 +8438,9 @@ public LetClause withIdentifier(JRightPadded identifier) { /** * Represents a C# join clause in a LINQ query expression. - *

+ * <p> * For example: - * 

+     * <pre>
      * // Simple join
      * join customer in customers on order.CustomerId equals customer.Id
      *
@@ -8455,7 +8455,7 @@ public LetClause withIdentifier(JRightPadded identifier) {
      *   on order.CustomerId equals customer.Id
      * join employee in employees
      *   on order.EmployeeId equals employee.Id
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -8480,44 +8480,44 @@ final class JoinClause implements Cs, QueryClause { Markers markers; /** - * 
+         * <pre>
          * join customer in customers
          *     ^^^^^^^^^^^^
-         *
+ * </pre> */ JRightPadded identifier; /** - * 
+         * <pre>
          * join customer in customers on order.CustomerId equals customer.Id
          *                 ^^^^^^^^^^^^^
-         *
+ * </pre> */ JRightPadded inExpression; /** - * 
+         * <pre>
          * join customer in customers on order.CustomerId equals customer.Id
          *                              ^^^^^^^^^^^^^^^^^^^^^^^^
-         *
+ * </pre> */ JRightPadded leftExpression; /** - * 
+         * <pre>
          * join customer in customers on order.CustomerId equals customer.Id
          *                                                      ^^^^^^^^^^^^
-         *
+ * </pre> */ @With @Getter Expression rightExpression; /** - * 
+         * <pre>
          * join category in categories on product.CategoryId equals category.Id into productCategories
          *                                                                     ^^^^^^^^^^^^^^^^^^^^^^^
-         *
+ * </pre> */ @Nullable JLeftPadded into; @@ -8624,9 +8624,9 @@ public JoinClause withInto(@Nullable JLeftPadded into) { /** * Represents the 'into' portion of a group join clause in C# LINQ syntax. * Used to specify the identifier that will hold the grouped results. - *

+ * <p> * For example: - * 

+     * <pre>
      * // Group join using into clause
      * join category in categories
      *    on product.CategoryId equals category.Id
@@ -8639,7 +8639,7 @@ public JoinClause withInto(@Nullable JLeftPadded into) {
      * join returns in db.Returns
      *    on customer.Id equals returns.CustomerId
      *    into customerReturns
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -8659,10 +8659,10 @@ final class JoinIntoClause implements Cs, QueryClause { Markers markers; /** - * 
+         * <pre>
          * into productCategories
          *     ^^^^^^^^^^^^^^^^^^
-         *
+ * </pre> */ @With @Getter @@ -8676,9 +8676,9 @@ public

J acceptCSharp(CSharpVisitor

v, P p) { /** * Represents a C# LINQ where clause that filters elements in a query based on a condition. - *

+ * <p> * For example: - * 

+     * <pre>
      *     // Simple where clause
      *     from p in people
      *     where p.Age >= 18
@@ -8692,9 +8692,9 @@ public 
 J acceptCSharp(CSharpVisitor
 v, P p) {
      *
      *     // Where with complex condition
      *     from o in orders
-     *     where o.Total > 1000 && o.Status == "Pending"
+     *     where o.Total > 1000 && o.Status == "Pending"
      *     select o
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -8715,10 +8715,10 @@ final class WhereClause implements Cs, QueryClause { Markers markers; /** - * 
+         * <pre>
          * where p.Age >= 18
          *      ^^^^^^^^^^^^
-         *
+ * </pre> */ @With @Getter @@ -8732,9 +8732,9 @@ public

J acceptCSharp(CSharpVisitor

v, P p) { /** * Represents a C# LINQ orderby clause that specifies the ordering of results in a query. - *

+ * <p> * For example: - * 

+     * <pre>
      *     // Simple orderby with single key
      *     from p in people
      *     orderby p.LastName
@@ -8749,7 +8749,7 @@ public 
 J acceptCSharp(CSharpVisitor
 v, P p) {
      *     from o in orders
      *     orderby o.Customer.Name, o.Total * 1.08
      *     select o
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -8774,10 +8774,10 @@ final class OrderByClause implements Cs, QueryClause { Markers markers; /** - * 
+         * <pre>
          * orderby p.LastName ascending, p.FirstName descending
          *         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-         *
+ * </pre> */ List> orderings; @@ -8826,9 +8826,9 @@ public OrderByClause withOrderings(List> orderings) { /** * Represents a LINQ query continuation using the 'into' keyword, which allows query results to be * further processed in subsequent query clauses. - *

+ * <p> * For example: - * 

+     * <pre>
      *     // Query continuation with grouping
      *     from c in customers
      *     group c by c.Country into g
@@ -8840,7 +8840,7 @@ public OrderByClause withOrderings(List> orderings) {
      *     select new { Modulo = g.Key, Items = g } into r
      *     where r.Items.Count() > 2
      *     select r
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -8860,21 +8860,21 @@ final class QueryContinuation implements Cs { Markers markers; /** - * 
+         * <pre>
          * group c by c.Country into g
          *                         ^^^
-         *
+ * </pre> */ @With @Getter J.Identifier identifier; /** - * 
+         * <pre>
          * group c by c.Country into g
          * select new { Country = g.Key }
          * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-         *
+ * </pre> */ @With @Getter @@ -8889,10 +8889,10 @@ public

J acceptCSharp(CSharpVisitor

v, P p) { /** * Represents a single ordering clause within C# orderby expression. - * 

+     * <pre>
      * orderby name ascending
      * orderby age descending, name ascending
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -8917,10 +8917,10 @@ final class Ordering implements Cs { Markers markers; /** - * 
+         * <pre>
          * orderby name ascending
          *        ^^^^
-         *
+ * </pre> */ JRightPadded expression; @@ -8933,10 +8933,10 @@ public Ordering withExpression(Expression expression) { } /** - * 
+         * <pre>
          * orderby name ascending
          *             ^^^^^^^^^
-         *
+ * </pre> */ @With @Getter @@ -8984,13 +8984,13 @@ public Ordering withExpression(JRightPadded expression) { /** * Represents a select clause in a LINQ expression in C#. - * 
+     * <pre>
      * // Simple select
      * select item
      *
      * // Select with projection
      * select new { Name = p.Name, Age = p.Age }
-     *
+ * </pre> */ @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @AllArgsConstructor(access = AccessLevel.PUBLIC) @@ -9010,10 +9010,10 @@ final class SelectClause implements Cs, SelectOrGroupClause { Markers markers; /** - * 
+         * <pre>
          * select item
          *        ^^^^
-         *
+ * </pre> */ @With @Getter @@ -9027,13 +9027,13 @@ public

J acceptCSharp(CSharpVisitor

v, P p) { /** * Represents a group clause in a LINQ query. - * 

+     * <pre>
      * // Simple group by
      * group item by key
      *
      * // Group by with complex key
      * group customer by new { customer.State, customer.City }
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -9058,10 +9058,10 @@ final class GroupClause implements Cs, SelectOrGroupClause { Markers markers; /** - * 
+         * <pre>
          * group item by key
          *       ^^^^
-         *
+ * </pre> */ JRightPadded groupExpression; @@ -9074,10 +9074,10 @@ public GroupClause withGroupExpression(Expression groupExpression) { } /** - * 
+         * <pre>
          * group item by key
          *              ^^^
-         *
+ * </pre> */ @With @Getter @@ -9118,7 +9118,7 @@ public GroupClause withGroupExpression(JRightPadded groupExpression) } /** * Represents a C# indexer declaration which allows objects to be indexed like arrays. - * 
+     * <pre>
      * // Simple indexer
      * public int this[int index] { get { } set { } }
      *
@@ -9133,7 +9133,7 @@ public GroupClause withGroupExpression(JRightPadded groupExpression)
      *
      * // Protected indexer with expression body
      * protected internal int this[int i] => array[i];
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -9163,29 +9163,29 @@ final class IndexerDeclaration implements Cs, Statement, TypedTree { List modifiers; /** - * 
+         * <pre>
          * public int this[int index]
          *        ^^^
-         *
+ * </pre> */ @With @Getter TypeTree typeExpression; /** - * 
+         * <pre>
          * public int IFoo.this[int index]
          *          ^^^^^
-         *
+ * </pre> */ @Nullable JRightPadded explicitInterfaceSpecifier; /** - * 
+         * <pre>
          * public TypeName ISomeType.this[int index]
          *                          ^^^^
-         *
+ * </pre> * Either FieldAccess (when interface qualified) or Identifier ("this") */ @Getter @@ -9193,27 +9193,27 @@ final class IndexerDeclaration implements Cs, Statement, TypedTree { Expression indexer; /** - * 
+         * <pre>
          * public int this[int index] { get; set; }
          *               ^^^^^^^^^^
-         *
+ * </pre> */ JContainer parameters; /** - * 
+         * <pre>
          * public int this[int index] => array[index];
          *                            ^^^^^^^^^^^^^^^^
-         *
+ * </pre> */ @Nullable JLeftPadded expressionBody; /** - * 
+         * <pre>
          * public int this[int index] { get; set; }
          *                           ^^^^^^^^^^^^
-         *
+ * </pre> */ @Nullable @With @@ -9319,9 +9319,9 @@ public IndexerDeclaration withExpressionBody(@Nullable JLeftPadded e /** * Represents a C# delegate declaration which defines a type that can reference methods. * Delegates act as type-safe function pointers and provide the foundation for events in C#. - *

+ * <p> * For example: - * 

+     * <pre>
      * // Simple non-generic delegate with single parameter
      * public delegate void Logger(string message);
      *
@@ -9329,7 +9329,7 @@ public IndexerDeclaration withExpressionBody(@Nullable JLeftPadded e
      * public delegate T Factory() where T : class, new();
      *
      * // Delegate with multiple parameters and constraint
-     * public delegate TResult Convert(T input)
+     * public delegate TResult Convert<T, TResult>(T input)
      *     where T : struct
      *     where TResult : class;
      *
@@ -9338,7 +9338,7 @@ public IndexerDeclaration withExpressionBody(@Nullable JLeftPadded e
      *
      * // Protected access
      * protected delegate bool Validator(T item);
-     *
+ * </pre> */ @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true) @@ -9368,20 +9368,20 @@ final class DelegateDeclaration implements Cs, Statement { List attributes; /** - * 
+         * <pre>
          * public delegate void MyDelegate(string message);
          * ^^^^^^
-         *
+ * </pre> */ @With @Getter List modifiers; /** - * 
+         * <pre>
          * public delegate void MyDelegate(string message);
          *               ^^^^
-         *
+ * </pre> */ JLeftPadded returnType; @@ -9394,37 +9394,37 @@ public DelegateDeclaration withReturnType(TypeTree returnType) { } /** - * 
+         * <pre>
          * public delegate void MyDelegate(string message);
          *                     ^^^^^^^^^^^
-         *
+ * </pre> */ @With @Getter Identifier identifier; /** - * 
+         * <pre>
          * public delegate T GenericDelegate(T item);
          *                                  ^^^
-         *
+ * </pre> */ @Nullable JContainer typeParameters; /** - * 
+         * <pre>
          * public delegate void MyDelegate(string message);
          *                                ^^^^^^^^^^^^^^^^
-         *
+ * </pre> */ JContainer parameters; /** - * 
+         * <pre>
          * public delegate T Factory() where T : class;
          *                               ^^^^^^^^^^^^^^^^
-         *
+ * </pre> */ @Nullable JContainer typeParameterConstraintClauses; @@ -9526,7 +9526,7 @@ public DelegateDeclaration withTypeParameterConstraintClauses(@Nullable JContain /** * Represents a C# operator conversion declaration that defines custom type conversion behavior. - * 
+     * <pre>
      * // Implicit conversion
      * public static implicit operator string(MyType t) => t.ToString();
      *
@@ -9565,20 +9565,20 @@ final class ConversionOperatorDeclaration implements Cs, Statement {
         Markers markers;
 
         /**
-         * 
+         * <pre>
          * public static implicit operator string(MyType t)
          * ^^^^^^^^^^^^^
-         * 

+         * </pre>
          */
         @With
         @Getter
         List modifiers;
 
         /**
-         * 
+         * <pre>
          * public static implicit operator string(MyType t)
          *               ^^^^^^^^
-         * 

+         * </pre>
          */
         JLeftPadded kind;
 
@@ -9591,10 +9591,10 @@ public ConversionOperatorDeclaration withKind(ExplicitImplicit kind) {
         }
 
         /**
-         * 
+         * <pre>
          * public static implicit operator string(MyType t)
          *                                ^^^^^^^
-         * 

+         * </pre>
          */
         JLeftPadded returnType;
 
@@ -9607,27 +9607,27 @@ public ConversionOperatorDeclaration withReturnType(TypeTree returnType) {
         }
 
         /**
-         * 
+         * <pre>
          * public static implicit operator string(MyType t)
          *                                      ^^^^^^^^^
-         * 

+         * </pre>
          */
         JContainer parameters;
 
         /**
-         * 
+         * <pre>
          * public static implicit operator string(MyType t) => t.ToString();
          *                                                 ^^^^^^^^^^^^^^^
-         * 

+         * </pre>
          */
         @Nullable
         JLeftPadded expressionBody;
 
         /**
-         * 
+         * <pre>
          * public static implicit operator string(MyType t) { return t.ToString(); }
          *                                                 ^^^^^^^^^^^^^^^^^^^^^^^
-         * 

+         * </pre>
          */
         @With
         @Getter
@@ -9728,9 +9728,9 @@ public ConversionOperatorDeclaration withExpressionBody(@Nullable JLeftPadded
+     * <p>
      * For example:
-     * 
+     * <pre>
      *     // Simple type parameter
      *     class Container<T>
      *
@@ -9742,7 +9742,7 @@ public ConversionOperatorDeclaration withExpressionBody(@Nullable JLeftPadded
+     * </pre>
      */
     @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
     @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true)
@@ -9771,19 +9771,19 @@ final class TypeParameter implements Cs {
         List attributeLists;
 
         /**
-         * 
+         * <pre>
          * interface IEnumerable
          *                      ^^^
-         * 

+         * </pre>
          */
         @Nullable
         JLeftPadded variance;
 
         /**
-         * 
+         * <pre>
          * class Container
          *                 ^
-         * 

+         * </pre>
          */
         @With
         @Getter
@@ -9838,9 +9838,9 @@ public Cs.TypeParameter withVariance(@Nullable JLeftPadded varianc
 
     /**
      * Represents a C# enum declaration, including optional modifiers, attributes, and enum members.
-     * 

+     * <p>
      * For example:
-     * 
+     * <pre>
      *     // Simple enum
      *     public enum Colors { Red, Green, Blue }
      *
@@ -9855,7 +9855,7 @@ public Cs.TypeParameter withVariance(@Nullable JLeftPadded varianc
      *         Write = 2,
      *         ReadWrite = Read | Write
      *     }
-     * 

+     * </pre>
      */
     @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
     @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true)
@@ -9889,10 +9889,10 @@ final class EnumDeclaration implements Cs, Statement {
         List modifiers;
 
         /**
-         * 
+         * <pre>
          * public enum Colors { Red, Green }
          *            ^^^^^^
-         * 

+         * </pre>
          */
         JLeftPadded name;
 
@@ -9905,19 +9905,19 @@ public EnumDeclaration withName(Identifier name) {
         }
 
         /**
-         * 
+         * <pre>
          * enum Flags : byte { None }
          *           ^^^^^^^
-         * 

+         * </pre>
          */
         @Nullable
         JLeftPadded baseType;
 
         /**
-         * 
+         * <pre>
          * enum Colors { Red, Green, Blue }
          *             ^^^^^^^^^^^^^^^^^^
-         * 

+         * </pre>
          */
         @Nullable
         JContainer members;
@@ -9987,9 +9987,9 @@ public EnumDeclaration withMembers(JContainer members) {
 
     /**
      * Represents a C# enum member declaration, including optional attributes and initializer.
-     * 

+     * <p>
      * For example:
-     * 
+     * <pre>
      *     // Simple enum member
      *     Red,
      *
@@ -9999,7 +9999,7 @@ public EnumDeclaration withMembers(JContainer members) {
      *     // Member with attributes and expression initializer
      *     [Obsolete]
      *     Blue = Red | Green,
-     * 

+     * </pre>
      */
     @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
     @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true)
@@ -10028,20 +10028,20 @@ final class EnumMemberDeclaration implements Cs, Expression {
         List attributeLists;
 
         /**
-         * 
+         * <pre>
          * Red = 1
          * ^^^
-         * 

+         * </pre>
          */
         @With
         @Getter
         Identifier name;
 
         /**
-         * 
+         * <pre>
          * Red = 1
          *     ^^^
-         * 

+         * </pre>
          */
         @Nullable
         JLeftPadded initializer;
@@ -10105,15 +10105,15 @@ public EnumMemberDeclaration withInitializer(@Nullable JLeftPadded i
 
     /**
      * Represents a C# alias qualified name, which uses an extern alias to qualify a name.
-     * 

+     * <p>
      * For example:
-     * 
+     * <pre>
      *     // Using LibA to qualify TypeName
      *     LibA::TypeName
      *
      *     // Using LibB to qualify namespace
      *     LibB::System.Collections
-     * 

+     * </pre>
      */
     @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
     @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true)
@@ -10138,18 +10138,18 @@ final class AliasQualifiedName implements Cs, TypeTree, Expression, Marker {
         Markers markers;
 
         /**
-         * 
+         * <pre>
          * LibA::TypeName
          * ^^^^
-         * 

+         * </pre>
          */
         JRightPadded alias;
 
         /**
-         * 
+         * <pre>
          * LibA::TypeName
          *      ^^^^^^^^
-         * 

+         * </pre>
          * In case of method invocation, whole expression gets placed here
          */
         @With
@@ -10317,9 +10317,9 @@ public CoordinateBuilder.Statement getCoordinates() {
 
         /**
          * Represents a C# catch clause in a try/catch statement, which optionally includes a filter expression.
-         * 

+         * <p>
          * For example:
-         * 
+         * <pre>
          *     // Simple catch clause
          *     catch (Exception e) { }
          *
@@ -10332,7 +10332,7 @@ public CoordinateBuilder.Statement getCoordinates() {
          *     }
          *     catch (ArgumentException e) when (e.ParamName == "id") { }
          *     catch (Exception e) when (e.InnerException != null) { }
-         * 

+         * </pre>
          */
         @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
         @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true)
@@ -10357,29 +10357,29 @@ public static final class Catch implements Cs {
             Markers markers;
 
             /**
-             * 
+             * <pre>
              * catch (Exception e) when (e.Code == 404) { }
              *      ^^^^^^^^^^^^^^
-             * 

+             * </pre>
              */
             @With
             @Getter
             ControlParentheses parameter;
 
             /**
-             * 
+             * <pre>
              * catch (Exception e) when (e.Code == 404) { }
              *                    ^^^^^^^^^^^^^^^^^^^^^
-             * 

+             * </pre>
              */
             @Nullable
             JLeftPadded> filterExpression;
 
             /**
-             * 
+             * <pre>
              * catch (Exception e) when (e.Code == 404) { }
              *                                         ^^^^
-             * 

+             * </pre>
              */
             @With
             @Getter
@@ -10458,9 +10458,9 @@ public Cs.Try withFinally(@Nullable JLeftPadded finallie) {
 
     /**
      * Represents a C# arrow expression clause (=>).
-     * 

+     * <p>
      * For example:
-     * 
+     * <pre>
      *     // In property accessors
      *     public string Name {
      *         get => _name;
@@ -10474,7 +10474,7 @@ public Cs.Try withFinally(@Nullable JLeftPadded finallie) {
      *
      *     // In operators
      *     public static implicit operator string(Person p) => p.Name;
-     * 

+     * </pre>
      */
     @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
     @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true)
@@ -10499,10 +10499,10 @@ final class ArrowExpressionClause implements Cs, Statement {
         Markers markers;
 
         /**
-         * 
+         * <pre>
          * get => value;
          *     ^^^^^^^^
-         * 

+         * </pre>
          */
         JRightPadded expression;
 
@@ -10556,9 +10556,9 @@ public ArrowExpressionClause withExpression(JRightPadded expression)
 
     /**
      * Represents a C# accessor declaration (get/set/init) within a property or indexer.
-     * 

+     * <p>
      * For example:
-     * 
+     * <pre>
      *     // Simple get/set accessors
      *     public int Value {
      *         get { return _value; }
@@ -10581,7 +10581,7 @@ public ArrowExpressionClause withExpression(JRightPadded expression)
      *         get { return _age; }
      *         private set { _age = value; }
      *     }
-     * 

+     * </pre>
      */
     @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
     @EqualsAndHashCode(callSuper = false, onlyExplicitlyIncluded = true)
@@ -10614,18 +10614,18 @@ final class AccessorDeclaration implements Cs, Statement {
         List modifiers;
 
         /**
-         * 
+         * <pre>
          * get { return value; }
          * ^^^
-         * 

+         * </pre>
          */
         JLeftPadded kind;
 
         /**
-         * 
+         * <pre>
          * get => value;
          *     ^^^^^^^^^
-         * 

+         * </pre>
          */
         @With
         @Getter
@@ -10633,10 +10633,10 @@ final class AccessorDeclaration implements Cs, Statement {
         ArrowExpressionClause expressionBody;
 
         /**
-         * 
+         * <pre>
          * get { return value; }
          *     ^^^^^^^^^^^^^^^
-         * 

+         * </pre>
          */
         @With
         @Getter

From 34e9e57facbcb9c22f0cda20c277635918741da0 Mon Sep 17 00:00:00 2001
From: Andrew Stakhov 
Date: Mon, 24 Mar 2025 20:01:04 -0400
Subject: [PATCH 04/11] Fix missed dependency

---
 .github/workflows/ci.yml                                   | 5 +++++
 .../tests/Rewrite.CSharp.Tests/Rewrite.CSharp.Tests.csproj | 7 ++-----
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 5f4bac96..8e72cb33 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -38,6 +38,11 @@ jobs:
       - uses: actions/setup-dotnet@v4
         with:
           dotnet-version: '8.0.x'
+
+      - uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: '9.0.x'
+
       - uses: gradle/actions/setup-gradle@v4
       - name: set-up-jdk
         uses: actions/setup-java@v4
diff --git a/Rewrite/tests/Rewrite.CSharp.Tests/Rewrite.CSharp.Tests.csproj b/Rewrite/tests/Rewrite.CSharp.Tests/Rewrite.CSharp.Tests.csproj
index 492d6b74..d98c151b 100644
--- a/Rewrite/tests/Rewrite.CSharp.Tests/Rewrite.CSharp.Tests.csproj
+++ b/Rewrite/tests/Rewrite.CSharp.Tests/Rewrite.CSharp.Tests.csproj
@@ -32,11 +32,8 @@
         
     
 
-    
-      
-    
-    
-      
+    
+      
     
 
     

From 0ac1d5b52ef547b3bf98021f7cb9c2a5ba213331 Mon Sep 17 00:00:00 2001
From: Andrew Stakhov 
Date: Mon, 24 Mar 2025 20:24:18 -0400
Subject: [PATCH 05/11] Another attempt

---
 .github/workflows/ci.yml                            | 13 ++++++++-----
 .../Rewrite.CSharp.Tests.csproj                     |  9 +++------
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 8e72cb33..64b52f09 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -53,11 +53,10 @@ jobs:
       - name: check-java
         run: java --version
 
-      - name: build
-        run: |
-          ./gradlew ${{ env.GRADLE_SWITCHES }} assemble
-          (cd Rewrite && dotnet restore Rewrite.sln --no-cache --force --force-evaluate)
-          (cd Rewrite && dotnet publish Rewrite.sln --no-restore)
+#      - name: dotnet-build
+#        run: |
+#          (cd Rewrite && dotnet restore Rewrite.sln --no-cache --force --force-evaluate)
+#          (cd Rewrite && dotnet publish Rewrite.sln --no-restore)
 
       - name: DotNet Tests
         run: |
@@ -71,6 +70,10 @@ jobs:
           path: artifacts/test-results/*.trx
           reporter: dotnet-trx
 
+      - name: java-build
+        run: |
+          ./gradlew ${{ env.GRADLE_SWITCHES }} assemble
+
       - name: Java Tests
         run: |
           ./gradlew ${{ env.GRADLE_SWITCHES }} test
diff --git a/Rewrite/tests/Rewrite.CSharp.Tests/Rewrite.CSharp.Tests.csproj b/Rewrite/tests/Rewrite.CSharp.Tests/Rewrite.CSharp.Tests.csproj
index d98c151b..89ce475b 100644
--- a/Rewrite/tests/Rewrite.CSharp.Tests/Rewrite.CSharp.Tests.csproj
+++ b/Rewrite/tests/Rewrite.CSharp.Tests/Rewrite.CSharp.Tests.csproj
@@ -32,10 +32,6 @@
         
     
 
-    
-      
-    
-
     
         
         
@@ -54,8 +50,9 @@
     
 
     
-      
-      
+        
+        
+        
     
 
 

From 0529b1a8d5fe52ab8bf956fda02e67c3d78780d2 Mon Sep 17 00:00:00 2001
From: Andrew Stakhov 
Date: Mon, 24 Mar 2025 20:34:55 -0400
Subject: [PATCH 06/11] Fix crlf test

---
 Rewrite/src/Rewrite.CSharp/Format/FormatStyle.cs       | 10 ++++++++--
 .../Formatter/AutoFormatterTests.cs                    |  1 +
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/Rewrite/src/Rewrite.CSharp/Format/FormatStyle.cs b/Rewrite/src/Rewrite.CSharp/Format/FormatStyle.cs
index e5381fe7..e46ba6ff 100644
--- a/Rewrite/src/Rewrite.CSharp/Format/FormatStyle.cs
+++ b/Rewrite/src/Rewrite.CSharp/Format/FormatStyle.cs
@@ -1,8 +1,14 @@
-namespace Rewrite.RewriteCSharp.Format;
+using System.Runtime.InteropServices;
+
+namespace Rewrite.RewriteCSharp.Format;
 
 internal record FormatStyle(string Indentation, string NewLine)
     {
-        const string DefaultNewLine = "\r\n";
+        static FormatStyle()
+        {
+            DefaultNewLine = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "\r\n" : "\n";
+        }
+        static string DefaultNewLine;
         public bool UseTabs => Indentation == "\t";
         public int IdentationSize => Indentation.Length;
 
diff --git a/Rewrite/tests/Rewrite.CSharp.Tests/Formatter/AutoFormatterTests.cs b/Rewrite/tests/Rewrite.CSharp.Tests/Formatter/AutoFormatterTests.cs
index 4e6a73a3..4390a9d9 100644
--- a/Rewrite/tests/Rewrite.CSharp.Tests/Formatter/AutoFormatterTests.cs
+++ b/Rewrite/tests/Rewrite.CSharp.Tests/Formatter/AutoFormatterTests.cs
@@ -16,6 +16,7 @@ public void FormatBasic()
         RewriteRun(CSharp(
             before: """
                 public class Foo { public int   A {    get;  set;   } }
+                
                 """,
             after: """
                    public class Foo

From e158a2e98a00946712b1379c11fa5062f58f26ed Mon Sep 17 00:00:00 2001
From: Andrew Stakhov 
Date: Mon, 24 Mar 2025 20:55:05 -0400
Subject: [PATCH 07/11] Try to fix build

---
 .../Rewrite.CSharp.Tests/Formatter/AutoFormatterTests.cs      | 2 +-
 rewrite-csharp-remote-server/build.gradle.kts                 | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Rewrite/tests/Rewrite.CSharp.Tests/Formatter/AutoFormatterTests.cs b/Rewrite/tests/Rewrite.CSharp.Tests/Formatter/AutoFormatterTests.cs
index 4390a9d9..9cfd1df7 100644
--- a/Rewrite/tests/Rewrite.CSharp.Tests/Formatter/AutoFormatterTests.cs
+++ b/Rewrite/tests/Rewrite.CSharp.Tests/Formatter/AutoFormatterTests.cs
@@ -16,7 +16,7 @@ public void FormatBasic()
         RewriteRun(CSharp(
             before: """
                 public class Foo { public int   A {    get;  set;   } }
-                
+
                 """,
             after: """
                    public class Foo
diff --git a/rewrite-csharp-remote-server/build.gradle.kts b/rewrite-csharp-remote-server/build.gradle.kts
index 8cc39a1e..8016bd39 100644
--- a/rewrite-csharp-remote-server/build.gradle.kts
+++ b/rewrite-csharp-remote-server/build.gradle.kts
@@ -3,8 +3,8 @@ plugins {
 }
 
 
-val latest = if (System.getenv("RELEASE_PUBLICATION") != null) "latest.release" else "latest.integration"
-
+var latest = if (System.getenv("RELEASE_PUBLICATION") != null) "latest.release" else "latest.integration"
+latest = "latest.release"
 dependencies {
 
     compileOnly("com.google.auto.service:auto-service-annotations:1.1.1")

From 7b57d934c6ff85f29468c359ba2c94c2114bb548 Mon Sep 17 00:00:00 2001
From: Andrew Stakhov 
Date: Mon, 24 Mar 2025 21:15:58 -0400
Subject: [PATCH 08/11] Add missing rewrite server

---
 .github/workflows/ci.yml              |  4 +--
 .nuke/build.schema.json               |  1 +
 Rewrite/src/Rewrite.Server/Program.cs | 36 +++++++++++----------------
 _build/Build.cs                       | 13 +++++++++-
 4 files changed, 29 insertions(+), 25 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 64b52f09..e02d43d6 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -58,9 +58,9 @@ jobs:
 #          (cd Rewrite && dotnet restore Rewrite.sln --no-cache --force --force-evaluate)
 #          (cd Rewrite && dotnet publish Rewrite.sln --no-restore)
 
-      - name: DotNet Tests
+      - name: DotNet Build & Test
         run: |
-          ./build.sh Test
+          ./build.sh CIBuild
 
       - name: Report .NET Test Results
         if: always()
diff --git a/.nuke/build.schema.json b/.nuke/build.schema.json
index d338ce23..03f7d954 100644
--- a/.nuke/build.schema.json
+++ b/.nuke/build.schema.json
@@ -32,6 +32,7 @@
         "GradleAssemble",
         "NugetPush",
         "Pack",
+        "PublishServer",
         "Restore",
         "Test"
       ]
diff --git a/Rewrite/src/Rewrite.Server/Program.cs b/Rewrite/src/Rewrite.Server/Program.cs
index 44c97397..2d1103f5 100644
--- a/Rewrite/src/Rewrite.Server/Program.cs
+++ b/Rewrite/src/Rewrite.Server/Program.cs
@@ -2,31 +2,23 @@
 using Rewrite.Remote.Server;
 using Parser = CommandLine.Parser;
 
-namespace Rewrite.Server;
+var result = new Parser(ps =>
+    {
+        ps.AllowMultiInstance = true;
+    })
+    .ParseArguments(args);
 
-public class Program
+if (result.Errors.Any())
 {
-    public static void Main(string[] args)
+    foreach (var resultError in result.Errors)
     {
-        var result = new Parser(ps =>
-            {
-                ps.AllowMultiInstance = true;
-            })
-            .ParseArguments(args);
-
-        if (result.Errors.Any())
-        {
-            foreach (var resultError in result.Errors)
-            {
-                Console.WriteLine(resultError);
-            }
-            throw new AggregateException(result.Errors.Select(e => new ArgumentException(e.ToString())));
-        }
+        Console.WriteLine(resultError);
+    }
+    throw new AggregateException(result.Errors.Select(e => new ArgumentException(e.ToString())));
+}
 
-        var options = result.Value;
+var options = result.Value;
 
-        var server = new Remote.Server.Server(options);
+var server = new Rewrite.Remote.Server.Server(options);
 
-        server.Listen().Wait();
-    }
-}
+server.Listen().Wait();
diff --git a/_build/Build.cs b/_build/Build.cs
index 813efd35..8521cc4b 100644
--- a/_build/Build.cs
+++ b/_build/Build.cs
@@ -79,6 +79,17 @@ class Build : NukeBuild
                 .SetProject(Solution.Path)
                 .SetVersion(Version.NuGetPackageVersion)
                 .SetOutputDirectory(ArtifactsDirectory));
+
+        });
+
+    Target PublishServer => _ => _
+        .Description("Publishes server")
+        .DependsOn(Restore)
+        .Executes(() =>
+        {
+            DotNetPublish(c => c
+                .SetProject(Solution.src.Rewrite_Server)
+                .SetVersion(Version.NuGetPackageVersion));
         });
 
     Target Test => _ => _
@@ -126,7 +137,7 @@ class Build : NukeBuild
         });
 
     Target CIBuild => _ => _
-        .DependsOn(Compile);
+        .DependsOn(PublishServer, Test);
 
     Target CIRelease => _ => _
         .DependsOn(Pack, NugetPush);

From d32e5d81c848aedaeaf63123c5f61aaa31e4c427 Mon Sep 17 00:00:00 2001
From: Andrew Stakhov 
Date: Mon, 24 Mar 2025 21:29:50 -0400
Subject: [PATCH 09/11] Add reporting for java tests

---
 .github/workflows/ci.yml | 18 +++++++++++++-----
 _build/_build.csproj     |  2 +-
 2 files changed, 14 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index e02d43d6..1c321230 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -70,6 +70,9 @@ jobs:
           path: artifacts/test-results/*.trx
           reporter: dotnet-trx
 
+
+
+
       - name: java-build
         run: |
           ./gradlew ${{ env.GRADLE_SWITCHES }} assemble
@@ -78,6 +81,15 @@ jobs:
         run: |
           ./gradlew ${{ env.GRADLE_SWITCHES }} test
 
+      - name: Report Java Test Results
+        if: always()
+        uses: dorny/test-reporter@v1
+        with:
+          name: Unit Tests
+          path: rewrite-csharp-remote-server/build/test-results/test/*.xml
+          reporter: java-junit
+
+
       - name: publish-java-snapshots
         if: github.event_name != 'pull_request'
         run: ./gradlew ${{ env.GRADLE_SWITCHES }} snapshot publish -PforceSigning -x test
@@ -87,10 +99,6 @@ jobs:
           ORG_GRADLE_PROJECT_signingKey: ${{ secrets.OSSRH_SIGNING_KEY }}
           ORG_GRADLE_PROJECT_signingPassword: ${{ secrets.OSSRH_SIGNING_PASSWORD }}
 
-      - name: dotnet-ci-build
-        if: github.event_name != 'pull_request'
-        run: ./build.sh CIBuild
-        env:
-          NUGET_API_KEY: ${{ secrets.NUGET_API_KEY }}
+
 
 
diff --git a/_build/_build.csproj b/_build/_build.csproj
index 3bd2c579..338c46ac 100644
--- a/_build/_build.csproj
+++ b/_build/_build.csproj
@@ -13,7 +13,7 @@
 
   
     
-    
+    
 
   
 

From dd7265dce357fa0b2805c322ac803a263092d872 Mon Sep 17 00:00:00 2001
From: Andrew Stakhov 
Date: Mon, 24 Mar 2025 23:59:09 -0400
Subject: [PATCH 10/11] Merge recipe project into this repo

---
 Rewrite/Rewrite.sln                           | 18 +++++++
 .../Rewrite.Core/Config/RecipeDescriptor.cs   | 15 +++++-
 Rewrite/src/Rewrite.Core/Recipe.cs            |  1 +
 Rewrite/src/Rewrite.Recipes/FindClass.cs      | 28 ++++++++++
 .../src/Rewrite.Recipes/InvertAssertion.cs    | 45 ++++++++++++++++
 Rewrite/src/Rewrite.Recipes/Json/Indent.cs    | 53 +++++++++++++++++++
 .../Rewrite.Recipes/Properties/AddProperty.cs | 49 +++++++++++++++++
 .../Rewrite.Recipes/Rewrite.Recipes.csproj    | 18 +++++++
 .../Rewrite.CSharp.Tests/RecipeOptionsTest.cs |  1 +
 .../CollectionDefinitions.cs                  |  7 +++
 .../Rewrite.Recipes.Tests/FindClassTests.cs   | 49 +++++++++++++++++
 .../InvertAssertionTest.cs                    | 46 ++++++++++++++++
 .../Rewrite.Recipes.Tests.csproj              | 27 ++++++++++
 13 files changed, 355 insertions(+), 2 deletions(-)
 create mode 100644 Rewrite/src/Rewrite.Recipes/FindClass.cs
 create mode 100644 Rewrite/src/Rewrite.Recipes/InvertAssertion.cs
 create mode 100644 Rewrite/src/Rewrite.Recipes/Json/Indent.cs
 create mode 100644 Rewrite/src/Rewrite.Recipes/Properties/AddProperty.cs
 create mode 100644 Rewrite/src/Rewrite.Recipes/Rewrite.Recipes.csproj
 create mode 100644 Rewrite/tests/Rewrite.Recipes.Tests/CollectionDefinitions.cs
 create mode 100644 Rewrite/tests/Rewrite.Recipes.Tests/FindClassTests.cs
 create mode 100644 Rewrite/tests/Rewrite.Recipes.Tests/InvertAssertionTest.cs
 create mode 100644 Rewrite/tests/Rewrite.Recipes.Tests/Rewrite.Recipes.Tests.csproj

diff --git a/Rewrite/Rewrite.sln b/Rewrite/Rewrite.sln
index 282be8cc..09f947f7 100644
--- a/Rewrite/Rewrite.sln
+++ b/Rewrite/Rewrite.sln
@@ -50,6 +50,10 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rewrite.Remote.Server", "sr
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rewrite.MSBuild", "src\Rewrite.MSBuild\Rewrite.MSBuild.csproj", "{E799F5AF-1143-4E84-8787-09A2B0702385}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rewrite.Recipes", "src\Rewrite.Recipes\Rewrite.Recipes.csproj", "{1D67FB54-B4A2-4D55-8B63-F93303F3D138}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rewrite.Recipes.Tests", "tests\Rewrite.Recipes.Tests\Rewrite.Recipes.Tests.csproj", "{C5D5CBE2-F9E4-4AF2-A247-B30E83F7EC47}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -149,6 +153,18 @@ Global
 		{E799F5AF-1143-4E84-8787-09A2B0702385}.Release|Any CPU.Build.0 = Release|Any CPU
 		{E799F5AF-1143-4E84-8787-09A2B0702385}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU
 		{E799F5AF-1143-4E84-8787-09A2B0702385}.Analyzers|Any CPU.Build.0 = Debug|Any CPU
+		{1D67FB54-B4A2-4D55-8B63-F93303F3D138}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{1D67FB54-B4A2-4D55-8B63-F93303F3D138}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{1D67FB54-B4A2-4D55-8B63-F93303F3D138}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{1D67FB54-B4A2-4D55-8B63-F93303F3D138}.Release|Any CPU.Build.0 = Release|Any CPU
+		{1D67FB54-B4A2-4D55-8B63-F93303F3D138}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU
+		{1D67FB54-B4A2-4D55-8B63-F93303F3D138}.Analyzers|Any CPU.Build.0 = Debug|Any CPU
+		{C5D5CBE2-F9E4-4AF2-A247-B30E83F7EC47}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{C5D5CBE2-F9E4-4AF2-A247-B30E83F7EC47}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{C5D5CBE2-F9E4-4AF2-A247-B30E83F7EC47}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{C5D5CBE2-F9E4-4AF2-A247-B30E83F7EC47}.Release|Any CPU.Build.0 = Release|Any CPU
+		{C5D5CBE2-F9E4-4AF2-A247-B30E83F7EC47}.Analyzers|Any CPU.ActiveCfg = Debug|Any CPU
+		{C5D5CBE2-F9E4-4AF2-A247-B30E83F7EC47}.Analyzers|Any CPU.Build.0 = Debug|Any CPU
 	EndGlobalSection
 	GlobalSection(NestedProjects) = preSolution
 		{25EEACCB-9BAE-4361-A980-9E9CDA37602E} = {7B268266-B9CD-4D85-ABC5-3B2C4611FD74}
@@ -169,5 +185,7 @@ Global
 		{EEF136BD-B789-4C0E-BFC7-4D5FD66C5B12} = {C7A4A8F9-0343-4A3E-AB77-101C458C23B5}
 		{E611118C-2205-4771-A902-0852E2B7301A} = {C7A4A8F9-0343-4A3E-AB77-101C458C23B5}
 		{E799F5AF-1143-4E84-8787-09A2B0702385} = {C7A4A8F9-0343-4A3E-AB77-101C458C23B5}
+		{1D67FB54-B4A2-4D55-8B63-F93303F3D138} = {C7A4A8F9-0343-4A3E-AB77-101C458C23B5}
+		{C5D5CBE2-F9E4-4AF2-A247-B30E83F7EC47} = {7B268266-B9CD-4D85-ABC5-3B2C4611FD74}
 	EndGlobalSection
 EndGlobal
diff --git a/Rewrite/src/Rewrite.Core/Config/RecipeDescriptor.cs b/Rewrite/src/Rewrite.Core/Config/RecipeDescriptor.cs
index 6fc54119..e051a260 100644
--- a/Rewrite/src/Rewrite.Core/Config/RecipeDescriptor.cs
+++ b/Rewrite/src/Rewrite.Core/Config/RecipeDescriptor.cs
@@ -9,6 +9,7 @@ public class RecipeDescriptor
     // Properties with public getters and private setters to maintain immutability
     public string Name { get; }
     public string DisplayName { get; }
+    public string InstanceName { get; }
     public string Description { get; }
     public ISet Tags { get; }
     public TimeSpan? EstimatedEffortPerOccurrence { get; }
@@ -21,13 +22,21 @@ public class RecipeDescriptor
     public Uri Source { get; }
 
     // Constructor to initialize the properties
-    public RecipeDescriptor(string name, string displayName, string description, ISet tags,
-        TimeSpan? estimatedEffortPerOccurrence, List options, List recipeList,
+    public RecipeDescriptor(
+        string name,
+        string displayName,
+        string instanceName,
+        string description,
+        ISet tags,
+        TimeSpan? estimatedEffortPerOccurrence,
+        List options,
+        List recipeList,
         /*List dataTables, List maintainers, List contributors,
         List examples,*/ Uri source)
     {
         Name = name;
         DisplayName = displayName;
+        InstanceName = instanceName;
         Description = description;
         Tags = tags;
         EstimatedEffortPerOccurrence = estimatedEffortPerOccurrence;
@@ -60,6 +69,7 @@ public override int GetHashCode()
     public RecipeDescriptor With(
         string? name = null,
         string? displayName = null,
+        string? instanceName = null,
         string? description = null,
         HashSet? tags = null,
         TimeSpan? estimatedEffortPerOccurrence = null,
@@ -74,6 +84,7 @@ public RecipeDescriptor With(
         return new RecipeDescriptor(
             name ?? this.Name,
             displayName ?? this.DisplayName,
+            instanceName ?? this.InstanceName,
             description ?? this.Description,
             tags ?? this.Tags,
             estimatedEffortPerOccurrence ?? this.EstimatedEffortPerOccurrence,
diff --git a/Rewrite/src/Rewrite.Core/Recipe.cs b/Rewrite/src/Rewrite.Core/Recipe.cs
index e1360649..8b22319c 100644
--- a/Rewrite/src/Rewrite.Core/Recipe.cs
+++ b/Rewrite/src/Rewrite.Core/Recipe.cs
@@ -14,6 +14,7 @@ public RecipeDescriptor Descriptor
             return _descriptor ??= new RecipeDescriptor(
                 Name,
                 DisplayName,
+                InstanceName,
                 Description,
                 Tags,
                 EstimatedEffortPerOccurrence,
diff --git a/Rewrite/src/Rewrite.Recipes/FindClass.cs b/Rewrite/src/Rewrite.Recipes/FindClass.cs
new file mode 100644
index 00000000..2494caa4
--- /dev/null
+++ b/Rewrite/src/Rewrite.Recipes/FindClass.cs
@@ -0,0 +1,28 @@
+using Rewrite.Core;
+using Rewrite.Core.Marker;
+using Rewrite.RewriteJava;
+using Rewrite.RewriteJava.Tree;
+using ExecutionContext = Rewrite.Core.ExecutionContext;
+
+namespace Rewrite.Recipes;
+
+public class FindClass([Option(displayName: "Description", description: "A special sign to specifically highlight the class found by the recipe", example: "~~>")] string? description = null): Recipe
+{
+    public override string DisplayName => "Find Class";
+
+    public override string Description => "Search for all the classes in the given source";
+
+    public override ITreeVisitor GetVisitor()
+    {
+        return new FindClassVisitor(description);
+    }
+
+    private class FindClassVisitor(string? description = null) : JavaVisitor
+    {
+        public override J VisitClassDeclaration(J.ClassDeclaration classDeclaration, ExecutionContext ctx)
+        {
+            var tree = (MutableTree)base.VisitClassDeclaration(classDeclaration, ctx)!;
+            return tree.WithMarkers(tree.Markers.AddIfAbsent(new SearchResult(Tree.RandomId(), description)));
+        }
+    }
+}
diff --git a/Rewrite/src/Rewrite.Recipes/InvertAssertion.cs b/Rewrite/src/Rewrite.Recipes/InvertAssertion.cs
new file mode 100644
index 00000000..2230cb94
--- /dev/null
+++ b/Rewrite/src/Rewrite.Recipes/InvertAssertion.cs
@@ -0,0 +1,45 @@
+using System.Text;
+using Rewrite.Core;
+using Rewrite.RewriteJava;
+using Rewrite.RewriteJava.Tree;
+using ExecutionContext = Rewrite.Core.ExecutionContext;
+
+namespace Rewrite.Recipes;
+
+public class InvertAssertion : Recipe
+{
+    private const string ASSERT_TRUE = "Xunit.Assert.True";
+    
+    public override string DisplayName => "Invert Assertion";
+    public override string Description => "Find for all the `Assert.True(!someBool)` and transform it into `Assert.False(someBool)`.";
+
+    public override ITreeVisitor GetVisitor()
+    {
+        return new InvertAssertionVisitor();
+    }
+
+    private class InvertAssertionVisitor : JavaVisitor
+    {
+        public override J.MethodInvocation VisitMethodInvocation(J.MethodInvocation method, ExecutionContext ctx)
+        {
+            // Assert.True(!a);
+            var mi = (base.VisitMethodInvocation(method, ctx) as J.MethodInvocation)!;
+
+            if (!ASSERT_TRUE.EndsWith(ExtractName(mi)) || !IsUnaryOperatorNot(mi)) return mi;
+
+            var unary = (J.Unary)mi.Arguments[0];
+
+            return mi.WithArguments([unary.Expression]).WithName(mi.Name.WithSimpleName("False"));
+        }
+
+        private static string ExtractName(J.MethodInvocation mi)
+        {
+            return (mi.Select is J.Identifier i ? (i.SimpleName + ".") : "") + mi.Name.SimpleName;
+        }
+
+        private static bool IsUnaryOperatorNot(J.MethodInvocation method)
+        {
+            return method.Arguments is [J.Unary { Operator: J.Unary.Types.Not }];
+        }
+    };
+}
diff --git a/Rewrite/src/Rewrite.Recipes/Json/Indent.cs b/Rewrite/src/Rewrite.Recipes/Json/Indent.cs
new file mode 100644
index 00000000..877970da
--- /dev/null
+++ b/Rewrite/src/Rewrite.Recipes/Json/Indent.cs
@@ -0,0 +1,53 @@
+using System.Text.RegularExpressions;
+using Rewrite.Core;
+using Rewrite.RewriteJson;
+using Rewrite.RewriteJson.Tree;
+using ExecutionContext = Rewrite.Core.ExecutionContext;
+
+namespace Rewrite.Recipes.Json;
+
+using ExecutionContext = ExecutionContext;
+
+public class Indent : Recipe
+{
+    public override string DisplayName => "Indent";
+    
+    public override string Description => "Fix JSON indentation"; 
+    
+    public override ITreeVisitor GetVisitor()
+    {
+        return new IndentVisitor();
+    }
+
+    private class IndentVisitor : JsonVisitor
+    {
+        public override Space VisitSpace(Space space, ExecutionContext ctx)
+        {
+            if (Cursor.Value is RewriteJson.Tree.Json.Document doc)
+            {
+                if (doc.Prefix == space)
+                {
+                    space = space.WithWhitespace("  " + space.Whitespace);
+                }
+
+                if (doc.Eof == space && space.Whitespace != null)
+                {
+                    space = space.WithWhitespace(Regex.Replace(space.Whitespace, @"\n(?!$)", "\n  "));
+                }
+            }
+            else if (space.Whitespace != null)
+            {
+                space = space.WithWhitespace(space.Whitespace.Replace("\n", "\n  "));
+            }
+
+            space = space.WithComments(ListUtils.Map(space.Comments, comment =>
+            {
+                comment = comment.WithText(comment.Text.Replace("\n", "\n  "));
+                comment = comment.WithSuffix(comment.Suffix.Replace("\n", "\n  "));
+                return comment;
+            }));
+
+            return space;
+        }
+    }
+}
diff --git a/Rewrite/src/Rewrite.Recipes/Properties/AddProperty.cs b/Rewrite/src/Rewrite.Recipes/Properties/AddProperty.cs
new file mode 100644
index 00000000..c0eb86a3
--- /dev/null
+++ b/Rewrite/src/Rewrite.Recipes/Properties/AddProperty.cs
@@ -0,0 +1,49 @@
+using System.Linq;
+using Rewrite.Core;
+using Rewrite.Core.Marker;
+using Rewrite.RewriteProperties;
+using ExecutionContext = Rewrite.Core.ExecutionContext;
+
+namespace Rewrite.Recipes.Properties;
+
+using ExecutionContext = ExecutionContext;
+
+public class AddProperty(
+    [Option("Property Name", "A name of the property to add", "test")] string property,
+    [Option("Value", "Value to specify for the given property name", "some-value")] string value) : Recipe
+{
+    public override string DisplayName => "Add Property";
+    public override string Description => "Add specified property to a property file";
+
+    public override ITreeVisitor GetVisitor()
+    {
+        return new AddPropertyVisitor(property, value);
+    }
+
+    private class AddPropertyVisitor(string property, string value) : PropertiesVisitor
+    {
+        public override RewriteProperties.Tree.Properties VisitFile(RewriteProperties.Tree.Properties.File file, ExecutionContext p)
+        {
+            var first = file.Content.FirstOrDefault(e => e is RewriteProperties.Tree.Properties.Entry entry && entry.Key == property);
+            if (first == null)
+            {
+                var entry = new RewriteProperties.Tree.Properties.Entry(Tree.RandomId(), "\n", Markers.EMPTY, property,
+                    " ", RewriteProperties.Tree.Properties.Entry.Delimiter.EQUALS,
+                    new RewriteProperties.Tree.Properties.Value(Tree.RandomId(), " ", Markers.EMPTY, value));
+                return file.WithContent(ListUtils.Concat(file.Content, entry).ToList());
+            }
+            else
+            {
+                return file.WithContent(ListUtils.Map(file.Content, e =>
+                {
+                    if (e is RewriteProperties.Tree.Properties.Entry entry && entry.Key == property)
+                    {
+                        return entry.Value.Text.Equals(value) ? entry : entry.WithValue(entry.Value.WithText(value));
+                    }
+
+                    return e;
+                }));
+            }
+        }
+    }
+}
diff --git a/Rewrite/src/Rewrite.Recipes/Rewrite.Recipes.csproj b/Rewrite/src/Rewrite.Recipes/Rewrite.Recipes.csproj
new file mode 100644
index 00000000..5be84c44
--- /dev/null
+++ b/Rewrite/src/Rewrite.Recipes/Rewrite.Recipes.csproj
@@ -0,0 +1,18 @@
+
+
+    
+        net8.0
+        enable
+        enable
+        Rewrite.Recipes
+    
+
+    
+      
+      
+      
+      
+      
+    
+
+
diff --git a/Rewrite/tests/Rewrite.CSharp.Tests/RecipeOptionsTest.cs b/Rewrite/tests/Rewrite.CSharp.Tests/RecipeOptionsTest.cs
index e4505809..106981e3 100644
--- a/Rewrite/tests/Rewrite.CSharp.Tests/RecipeOptionsTest.cs
+++ b/Rewrite/tests/Rewrite.CSharp.Tests/RecipeOptionsTest.cs
@@ -16,6 +16,7 @@ public void testDescriptorResolution()
         findClassDescriptor.Should().BeEquivalentTo(new RecipeDescriptor(
             "Rewrite.CSharp.Tests.RecipeOptionsTest+TestRecipe",
             "Test Recipe",
+            "Test Recipe Instance",
             "Test Recipe Description",
             new HashSet(),
             TimeSpan.FromMinutes(5),
diff --git a/Rewrite/tests/Rewrite.Recipes.Tests/CollectionDefinitions.cs b/Rewrite/tests/Rewrite.Recipes.Tests/CollectionDefinitions.cs
new file mode 100644
index 00000000..75308ab3
--- /dev/null
+++ b/Rewrite/tests/Rewrite.Recipes.Tests/CollectionDefinitions.cs
@@ -0,0 +1,7 @@
+using Rewrite.Test.Engine.Remote;
+using Xunit;
+
+namespace Rewrite.CSharp.Tests;
+
+[CollectionDefinition("C# remoting")]
+public class RemotingCollection : ICollectionFixture;
diff --git a/Rewrite/tests/Rewrite.Recipes.Tests/FindClassTests.cs b/Rewrite/tests/Rewrite.Recipes.Tests/FindClassTests.cs
new file mode 100644
index 00000000..2946f289
--- /dev/null
+++ b/Rewrite/tests/Rewrite.Recipes.Tests/FindClassTests.cs
@@ -0,0 +1,49 @@
+using FluentAssertions;
+using Rewrite.Core;
+using Rewrite.Core.Marker;
+using Rewrite.Recipes;
+using Rewrite.RewriteJava.Tree;
+using Rewrite.Test;
+using Xunit;
+using Xunit.Abstractions;
+using FileAttributes = Rewrite.Core.FileAttributes;
+
+namespace Rewrite.Java.Tests;
+
+public class FindClassTests(ITestOutputHelper output) : RewriteTest(output)
+{
+
+    [Fact]
+    public void Test1()
+    {
+        var source = new J.CompilationUnit(
+            Tree.RandomId(),
+            Space.EMPTY,
+            Markers.EMPTY, "Foo.java", new FileAttributes(), null, false, null, null, [],
+            [
+                new J.ClassDeclaration(
+                    Tree.RandomId(),
+                    Space.EMPTY,
+                    Markers.EMPTY,
+                    [],
+                    [],
+                    new J.ClassDeclaration.Kind(Tree.RandomId(), Space.EMPTY, Markers.EMPTY, [],
+                        J.ClassDeclaration.Kind.Types.Class),
+                    new J.Identifier(Tree.RandomId(), Space.EMPTY, Markers.EMPTY, [], "Foo", null, null),
+                    null,
+                    null,
+                    null,
+                    null,
+                    null,
+                    new J.Block(Tree.RandomId(), Space.EMPTY, Markers.EMPTY,
+                        new JRightPadded(false, Space.EMPTY, Markers.EMPTY), [], Space.EMPTY),
+                    null
+                )
+            ],
+            Space.EMPTY
+        );
+        var after = new FindClass().GetVisitor().Visit(source, new InMemoryExecutionContext()) as J.CompilationUnit;
+        after.Should().NotBeSameAs(source);
+        after.Classes[0].Markers.MarkerList.Should().Contain(e => e is SearchResult);
+    }
+}
diff --git a/Rewrite/tests/Rewrite.Recipes.Tests/InvertAssertionTest.cs b/Rewrite/tests/Rewrite.Recipes.Tests/InvertAssertionTest.cs
new file mode 100644
index 00000000..36804eda
--- /dev/null
+++ b/Rewrite/tests/Rewrite.Recipes.Tests/InvertAssertionTest.cs
@@ -0,0 +1,46 @@
+using Rewrite.Test;
+using Rewrite.Test.CSharp;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace Rewrite.Recipes;
+
+using static Assertions;
+
+[Collection("C# remoting")]
+public class Tests(ITestOutputHelper output) : RewriteTest(output)
+{
+    protected override void Defaults(RecipeSpec spec)
+    {
+        spec.Recipe = new InvertAssertion();
+    }
+
+    [Fact]
+    public void VerifyItWorksTest()
+    {
+        RewriteRun(
+            CSharp(
+                """
+                    class MyClass
+                    {
+                        void test()
+                        {
+                            bool a = false;
+                            Assert.True(!a);
+                        }
+                    }             
+                """,
+                """
+                    class MyClass
+                    {
+                        void test()
+                        {
+                            bool a = false;
+                            Assert.False(a);
+                        }
+                    }             
+                """
+            )
+        );
+    }
+}
diff --git a/Rewrite/tests/Rewrite.Recipes.Tests/Rewrite.Recipes.Tests.csproj b/Rewrite/tests/Rewrite.Recipes.Tests/Rewrite.Recipes.Tests.csproj
new file mode 100644
index 00000000..d1b964ab
--- /dev/null
+++ b/Rewrite/tests/Rewrite.Recipes.Tests/Rewrite.Recipes.Tests.csproj
@@ -0,0 +1,27 @@
+
+
+    
+        net8.0
+        enable
+        enable
+
+        false
+        true
+        Rewrite.Recipes
+    
+
+    
+        
+        
+        
+        
+    
+
+    
+      
+      
+      
+      
+    
+
+

From 2490102c29f86191483f208f9d406019ae6a1a89 Mon Sep 17 00:00:00 2001
From: Andrew Stakhov 
Date: Tue, 25 Mar 2025 11:11:16 -0400
Subject: [PATCH 11/11] Fix failing test

---
 .../org/openrewrite/csharp/remote/ProjectParsingTest.java     | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/rewrite-csharp-remote-server/src/test/java/org/openrewrite/csharp/remote/ProjectParsingTest.java b/rewrite-csharp-remote-server/src/test/java/org/openrewrite/csharp/remote/ProjectParsingTest.java
index f6ece957..ba2c76b2 100644
--- a/rewrite-csharp-remote-server/src/test/java/org/openrewrite/csharp/remote/ProjectParsingTest.java
+++ b/rewrite-csharp-remote-server/src/test/java/org/openrewrite/csharp/remote/ProjectParsingTest.java
@@ -16,6 +16,7 @@
 
 package org.openrewrite.csharp.remote;
 
+import lombok.SneakyThrows;
 import org.junit.jupiter.api.Test;
 import org.openrewrite.Cursor;
 import org.openrewrite.InMemoryExecutionContext;
@@ -31,6 +32,7 @@
 
 public class ProjectParsingTest {
 
+    @SneakyThrows
     @Test
     public void testParse() {
         WatchableExecutionContext ctx =
@@ -50,7 +52,7 @@ public void testParse() {
               .getContextClassLoader()
               .getResource(
                 "ModerneHelloWorld/ModerneHelloWorld.sln")
-              .getPath());
+                    .toURI());
             client.findAllProjects(pathToSolution, ctx)
               .forEach(proj -> client.parseProjectSources(proj,
                   pathToSolution,