Skip to content

Commit 2c854d7

Browse files
OlegDokukaOlegDokuka
committed
migrate to updated J.Case API
1 parent 9315dfc commit 2c854d7

File tree

10 files changed

+235
-27
lines changed

10 files changed

+235
-27
lines changed

‎Rewrite/src/Rewrite.Java/JavaVisitor.g.cs‎

Lines changed: 21 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -206,9 +206,10 @@ public virtual J VisitStatement(Statement statement, P p) {
206206
}
207207
@case = (J.Case) tempStatement;
208208
@case = @case.WithMarkers(VisitMarkers(@case.Markers, p));
209-
@case = @case.Padding.WithExpressions(VisitContainer(@case.Padding.Expressions, JContainer.Location.CASE_EXPRESSION, p)!);
209+
@case = @case.Padding.WithCaseLabels(VisitContainer(@case.Padding.CaseLabels, JContainer.Location.CASE_CASE_LABELS, p)!);
210210
@case = @case.Padding.WithStatements(VisitContainer(@case.Padding.Statements, JContainer.Location.CASE, p)!);
211211
@case = @case.Padding.WithBody(@case.Padding.Body == null ? null : VisitRightPadded(@case.Padding.Body, JRightPadded.Location.CASE_BODY, p));
212+
@case = @case.WithGuard(VisitAndCast<Expression>(@case.Guard, p));
212213
return @case;
213214
}
214215

@@ -1049,6 +1050,25 @@ public virtual J VisitStatement(Statement statement, P p) {
10491050
return source;
10501051
}
10511052

1053+
public virtual J? VisitErroneous(J.Erroneous erroneous, P p)
1054+
{
1055+
erroneous = erroneous.WithPrefix(VisitSpace(erroneous.Prefix, Space.Location.ERRONEOUS_PREFIX, p)!);
1056+
var tempStatement = (Statement) VisitStatement(erroneous, p);
1057+
if (tempStatement is not J.Erroneous)
1058+
{
1059+
return tempStatement;
1060+
}
1061+
erroneous = (J.Erroneous) tempStatement;
1062+
var tempExpression = (Expression) VisitExpression(erroneous, p);
1063+
if (tempExpression is not J.Erroneous)
1064+
{
1065+
return tempExpression;
1066+
}
1067+
erroneous = (J.Erroneous) tempExpression;
1068+
erroneous = erroneous.WithMarkers(VisitMarkers(erroneous.Markers, p));
1069+
return erroneous;
1070+
}
1071+
10521072
public virtual JContainer<T>? VisitContainer<T>(JContainer<T>? container, JContainer.Location loc, P p)
10531073
{
10541074
if (container == null) {

‎Rewrite/src/Rewrite.Java/Tree/Case.g.cs‎

Lines changed: 22 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -31,9 +31,10 @@ public partial class Case(
3131
Space prefix,
3232
Markers markers,
3333
Case.Types caseType,
34-
JContainer<Expression> expressions,
34+
JContainer<J> caseLabels,
3535
JContainer<Statement> statements,
36-
JRightPadded<J>? body
36+
JRightPadded<J>? body,
37+
Expression? guard
3738
) : J, Statement, J<Case>, MutableTree<Case>
3839
{
3940
[NonSerialized] private WeakReference<PaddingHelper>? _padding;
@@ -70,32 +71,32 @@ public PaddingHelper Padding
7071

7172
public Case WithId(Guid newId)
7273
{
73-
return newId == id ? this : new Case(newId, prefix, markers, caseType, _expressions, _statements, _body);
74+
return newId == id ? this : new Case(newId, prefix, markers, caseType, _caseLabels, _statements, _body, guard);
7475
}
7576
public Space Prefix => prefix;
7677

7778
public Case WithPrefix(Space newPrefix)
7879
{
79-
return newPrefix == prefix ? this : new Case(id, newPrefix, markers, caseType, _expressions, _statements, _body);
80+
return newPrefix == prefix ? this : new Case(id, newPrefix, markers, caseType, _caseLabels, _statements, _body, guard);
8081
}
8182
public Markers Markers => markers;
8283

8384
public Case WithMarkers(Markers newMarkers)
8485
{
85-
return ReferenceEquals(newMarkers, markers) ? this : new Case(id, prefix, newMarkers, caseType, _expressions, _statements, _body);
86+
return ReferenceEquals(newMarkers, markers) ? this : new Case(id, prefix, newMarkers, caseType, _caseLabels, _statements, _body, guard);
8687
}
8788
public Types CaseType => caseType;
8889

8990
public Case WithCaseType(Types newCaseType)
9091
{
91-
return newCaseType == caseType ? this : new Case(id, prefix, markers, newCaseType, _expressions, _statements, _body);
92+
return newCaseType == caseType ? this : new Case(id, prefix, markers, newCaseType, _caseLabels, _statements, _body, guard);
9293
}
93-
private readonly JContainer<Expression> _expressions = expressions;
94-
public IList<Expression> Expressions => _expressions.GetElements();
94+
private readonly JContainer<J> _caseLabels = caseLabels;
95+
public IList<J> CaseLabels => _caseLabels.GetElements();
9596

96-
public Case WithExpressions(IList<Expression> newExpressions)
97+
public Case WithCaseLabels(IList<J> newCaseLabels)
9798
{
98-
return Padding.WithExpressions(JContainer<Expression>.WithElements(_expressions, newExpressions));
99+
return Padding.WithCaseLabels(JContainer<J>.WithElements(_caseLabels, newCaseLabels));
99100
}
100101
private readonly JContainer<Statement> _statements = statements;
101102
public IList<Statement> Statements => _statements.GetElements();
@@ -111,32 +112,38 @@ public Case WithBody(J? newBody)
111112
{
112113
return Padding.WithBody(JRightPadded<J>.WithElement(_body, newBody));
113114
}
115+
public Expression? Guard => guard;
116+
117+
public Case WithGuard(Expression? newGuard)
118+
{
119+
return ReferenceEquals(newGuard, guard) ? this : new Case(id, prefix, markers, caseType, _caseLabels, _statements, _body, newGuard);
120+
}
114121
public enum Types
115122
{
116123
Statement,
117124
Rule,
118125
}
119126
public sealed record PaddingHelper(J.Case T)
120127
{
121-
public JContainer<Expression> Expressions => T._expressions;
128+
public JContainer<J> CaseLabels => T._caseLabels;
122129

123-
public J.Case WithExpressions(JContainer<Expression> newExpressions)
130+
public J.Case WithCaseLabels(JContainer<J> newCaseLabels)
124131
{
125-
return T._expressions == newExpressions ? T : new J.Case(T.Id, T.Prefix, T.Markers, T.CaseType, newExpressions, T._statements, T._body);
132+
return T._caseLabels == newCaseLabels ? T : new J.Case(T.Id, T.Prefix, T.Markers, T.CaseType, newCaseLabels, T._statements, T._body, T.Guard);
126133
}
127134

128135
public JContainer<Statement> Statements => T._statements;
129136

130137
public J.Case WithStatements(JContainer<Statement> newStatements)
131138
{
132-
return T._statements == newStatements ? T : new J.Case(T.Id, T.Prefix, T.Markers, T.CaseType, T._expressions, newStatements, T._body);
139+
return T._statements == newStatements ? T : new J.Case(T.Id, T.Prefix, T.Markers, T.CaseType, T._caseLabels, newStatements, T._body, T.Guard);
133140
}
134141

135142
public JRightPadded<J>? Body => T._body;
136143

137144
public J.Case WithBody(JRightPadded<J>? newBody)
138145
{
139-
return T._body == newBody ? T : new J.Case(T.Id, T.Prefix, T.Markers, T.CaseType, T._expressions, T._statements, newBody);
146+
return T._body == newBody ? T : new J.Case(T.Id, T.Prefix, T.Markers, T.CaseType, T._caseLabels, T._statements, newBody, T.Guard);
140147
}
141148

142149
}

‎Rewrite/src/Rewrite.Java/Tree/Erroneous.g.cs‎

Lines changed: 83 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,83 @@
1+
//------------------------------------------------------------------------------
2+
// <auto-generated>
3+
// Changes to this file may cause incorrect behavior and will be lost if
4+
// the code is regenerated.
5+
// </auto-generated>
6+
//------------------------------------------------------------------------------
7+
#nullable enable
8+
#pragma warning disable CS0108 // 'member1' hides inherited member 'member2'. Use the new keyword if hiding was intended.
9+
#pragma warning disable CS8767 // Nullability of reference types in type of parameter doesn't match implicitly implemented member (possibly because of nullability attributes).
10+
using System.Diagnostics;
11+
using System.Diagnostics.CodeAnalysis;
12+
using Rewrite.Core;
13+
using Rewrite.Core.Marker;
14+
using FileAttributes = Rewrite.Core.FileAttributes;
15+
16+
namespace Rewrite.RewriteJava.Tree;
17+
18+
[SuppressMessage("ReSharper", "InconsistentNaming")]
19+
[SuppressMessage("ReSharper", "PossibleUnintendedReferenceComparison")]
20+
[SuppressMessage("ReSharper", "InvertIf")]
21+
[SuppressMessage("ReSharper", "RedundantExtendsListEntry")]
22+
[SuppressMessage("ReSharper", "UnusedMember.Global")]
23+
[SuppressMessage("ReSharper", "RedundantNameQualifier")]
24+
public partial interface J : Rewrite.Core.Tree
25+
{
26+
/// <summary>
27+
/// A node that represents an erroneous element.
28+
/// </summary>
29+
#if DEBUG_VISITOR
30+
[DebuggerStepThrough]
31+
#endif
32+
public partial class Erroneous(
33+
Guid id,
34+
Space prefix,
35+
Markers markers,
36+
string text
37+
) : Statement, Expression, Expression<Erroneous>, J<Erroneous>, MutableTree<Erroneous>
38+
{
39+
public J? AcceptJava<P>(JavaVisitor<P> v, P p)
40+
{
41+
return v.VisitErroneous(this, p);
42+
}
43+
44+
public Guid Id => id;
45+
46+
public Erroneous WithId(Guid newId)
47+
{
48+
return newId == id ? this : new Erroneous(newId, prefix, markers, text);
49+
}
50+
public Space Prefix => prefix;
51+
52+
public Erroneous WithPrefix(Space newPrefix)
53+
{
54+
return newPrefix == prefix ? this : new Erroneous(id, newPrefix, markers, text);
55+
}
56+
public Markers Markers => markers;
57+
58+
public Erroneous WithMarkers(Markers newMarkers)
59+
{
60+
return ReferenceEquals(newMarkers, markers) ? this : new Erroneous(id, prefix, newMarkers, text);
61+
}
62+
public string Text => text;
63+
64+
public Erroneous WithText(string newText)
65+
{
66+
return newText == text ? this : new Erroneous(id, prefix, markers, newText);
67+
}
68+
#if DEBUG_VISITOR
69+
[DebuggerStepThrough]
70+
#endif
71+
public bool Equals(Rewrite.Core.Tree? other)
72+
{
73+
return other is Erroneous && other.Id == Id;
74+
}
75+
#if DEBUG_VISITOR
76+
[DebuggerStepThrough]
77+
#endif
78+
public override int GetHashCode()
79+
{
80+
return Id.GetHashCode();
81+
}
82+
}
83+
}

‎Rewrite/src/Rewrite.Remote.Codec/CSharp/CSharpReceiver.g.cs‎

Lines changed: 24 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1279,9 +1279,10 @@ public override J VisitCase(J.Case @case, ReceiverContext ctx)
12791279
@case = @case.WithPrefix(ctx.ReceiveNode(@case.Prefix, ReceiveSpace)!);
12801280
@case = @case.WithMarkers(ctx.ReceiveNode(@case.Markers, ctx.ReceiveMarkers)!);
12811281
@case = @case.WithCaseType(ctx.ReceiveValue(@case.CaseType)!);
1282-
@case = @case.Padding.WithExpressions(ctx.ReceiveNode(@case.Padding.Expressions, ReceiveContainer)!);
1282+
@case = @case.Padding.WithCaseLabels(ctx.ReceiveNode(@case.Padding.CaseLabels, ReceiveContainer)!);
12831283
@case = @case.Padding.WithStatements(ctx.ReceiveNode(@case.Padding.Statements, ReceiveContainer)!);
12841284
@case = @case.Padding.WithBody(ctx.ReceiveNode(@case.Padding.Body, ReceiveRightPadded));
1285+
@case = @case.WithGuard(ctx.ReceiveNode(@case.Guard, ctx.ReceiveTree));
12851286
return @case;
12861287
}
12871288

@@ -1890,6 +1891,15 @@ public override J VisitUnknownSource(J.Unknown.Source source, ReceiverContext ct
18901891
return source;
18911892
}
18921893

1894+
public override J VisitErroneous(J.Erroneous erroneous, ReceiverContext ctx)
1895+
{
1896+
erroneous = erroneous.WithId(ctx.ReceiveValue(erroneous.Id)!);
1897+
erroneous = erroneous.WithPrefix(ctx.ReceiveNode(erroneous.Prefix, ReceiveSpace)!);
1898+
erroneous = erroneous.WithMarkers(ctx.ReceiveNode(erroneous.Markers, ctx.ReceiveMarkers)!);
1899+
erroneous = erroneous.WithText(ctx.ReceiveValue(erroneous.Text)!);
1900+
return erroneous;
1901+
}
1902+
18931903
}
18941904

18951905
private class Factory : ReceiverFactory
@@ -3246,9 +3256,10 @@ public Rewrite.Core.Tree Create<T>(string type, ReceiverContext ctx) where T : R
32463256
ctx.ReceiveNode(default(Space), ReceiveSpace)!,
32473257
ctx.ReceiveNode(default(Markers), ctx.ReceiveMarkers)!,
32483258
ctx.ReceiveValue(default(J.Case.Types))!,
3249-
ctx.ReceiveNode(default(JContainer<Expression>), ReceiveContainer)!,
3259+
ctx.ReceiveNode(default(JContainer<J>), ReceiveContainer)!,
32503260
ctx.ReceiveNode(default(JContainer<Statement>), ReceiveContainer)!,
3251-
ctx.ReceiveNode(default(JRightPadded<J>?), ReceiveRightPadded)!
3261+
ctx.ReceiveNode(default(JRightPadded<J>?), ReceiveRightPadded)!,
3262+
ctx.ReceiveNode(default(Expression?), ctx.ReceiveTree)!
32523263
);
32533264
}
32543265

@@ -3923,6 +3934,16 @@ public Rewrite.Core.Tree Create<T>(string type, ReceiverContext ctx) where T : R
39233934
);
39243935
}
39253936

3937+
if (type is "Rewrite.RewriteCSharp.Tree.J.Erroneous" or "org.openrewrite.java.tree.J$Erroneous")
3938+
{
3939+
return new J.Erroneous(
3940+
ctx.ReceiveValue(default(Guid))!,
3941+
ctx.ReceiveNode(default(Space), ReceiveSpace)!,
3942+
ctx.ReceiveNode(default(Markers), ctx.ReceiveMarkers)!,
3943+
ctx.ReceiveValue(default(string))!
3944+
);
3945+
}
3946+
39263947
throw new NotImplementedException("No factory method for type: " + type);
39273948
}
39283949
}

‎Rewrite/src/Rewrite.Remote.Codec/CSharp/CSharpSender.g.cs‎

Lines changed: 11 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1270,9 +1270,10 @@ public override J VisitCase(J.Case @case, SenderContext ctx)
12701270
ctx.SendNode(@case, v => v.Prefix, SendSpace);
12711271
ctx.SendNode(@case, v => v.Markers, ctx.SendMarkers);
12721272
ctx.SendValue(@case, v => v.CaseType);
1273-
ctx.SendNode(@case, v => v.Padding.Expressions, SendContainer);
1273+
ctx.SendNode(@case, v => v.Padding.CaseLabels, SendContainer);
12741274
ctx.SendNode(@case, v => v.Padding.Statements, SendContainer);
12751275
ctx.SendNode(@case, v => v.Padding.Body, SendRightPadded);
1276+
ctx.SendNode(@case, v => v.Guard, ctx.SendTree);
12761277
return @case;
12771278
}
12781279

@@ -1895,6 +1896,15 @@ public override J VisitUnknownSource(J.Unknown.Source source, SenderContext ctx)
18951896
return source;
18961897
}
18971898

1899+
public override J VisitErroneous(J.Erroneous erroneous, SenderContext ctx)
1900+
{
1901+
ctx.SendValue(erroneous, v => v.Id);
1902+
ctx.SendNode(erroneous, v => v.Prefix, SendSpace);
1903+
ctx.SendNode(erroneous, v => v.Markers, ctx.SendMarkers);
1904+
ctx.SendValue(erroneous, v => v.Text);
1905+
return erroneous;
1906+
}
1907+
18981908
private static void SendContainer<T>(JContainer<T> container, SenderContext ctx)
18991909
where T : J
19001910
{

‎Rewrite/src/Rewrite.Remote.Codec/Java/JavaReceiver.g.cs‎

Lines changed: 24 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -159,9 +159,10 @@ public override J VisitCase(J.Case @case, ReceiverContext ctx)
159159
@case = @case.WithPrefix(ctx.ReceiveNode(@case.Prefix, ReceiveSpace)!);
160160
@case = @case.WithMarkers(ctx.ReceiveNode(@case.Markers, ctx.ReceiveMarkers)!);
161161
@case = @case.WithCaseType(ctx.ReceiveValue(@case.CaseType)!);
162-
@case = @case.Padding.WithExpressions(ctx.ReceiveNode(@case.Padding.Expressions, ReceiveContainer)!);
162+
@case = @case.Padding.WithCaseLabels(ctx.ReceiveNode(@case.Padding.CaseLabels, ReceiveContainer)!);
163163
@case = @case.Padding.WithStatements(ctx.ReceiveNode(@case.Padding.Statements, ReceiveContainer)!);
164164
@case = @case.Padding.WithBody(ctx.ReceiveNode(@case.Padding.Body, ReceiveRightPadded));
165+
@case = @case.WithGuard(ctx.ReceiveNode(@case.Guard, ctx.ReceiveTree));
165166
return @case;
166167
}
167168

@@ -787,6 +788,15 @@ public override J VisitUnknownSource(J.Unknown.Source source, ReceiverContext ct
787788
return source;
788789
}
789790

791+
public override J VisitErroneous(J.Erroneous erroneous, ReceiverContext ctx)
792+
{
793+
erroneous = erroneous.WithId(ctx.ReceiveValue(erroneous.Id)!);
794+
erroneous = erroneous.WithPrefix(ctx.ReceiveNode(erroneous.Prefix, ReceiveSpace)!);
795+
erroneous = erroneous.WithMarkers(ctx.ReceiveNode(erroneous.Markers, ctx.ReceiveMarkers)!);
796+
erroneous = erroneous.WithText(ctx.ReceiveValue(erroneous.Text)!);
797+
return erroneous;
798+
}
799+
790800
}
791801

792802
private class Factory : ReceiverFactory
@@ -918,9 +928,10 @@ public Rewrite.Core.Tree Create<T>(string type, ReceiverContext ctx) where T : R
918928
ctx.ReceiveNode(default(Space), ReceiveSpace)!,
919929
ctx.ReceiveNode(default(Markers), ctx.ReceiveMarkers)!,
920930
ctx.ReceiveValue(default(J.Case.Types))!,
921-
ctx.ReceiveNode(default(JContainer<Expression>), ReceiveContainer)!,
931+
ctx.ReceiveNode(default(JContainer<J>), ReceiveContainer)!,
922932
ctx.ReceiveNode(default(JContainer<Statement>), ReceiveContainer)!,
923-
ctx.ReceiveNode(default(JRightPadded<J>?), ReceiveRightPadded)!
933+
ctx.ReceiveNode(default(JRightPadded<J>?), ReceiveRightPadded)!,
934+
ctx.ReceiveNode(default(Expression?), ctx.ReceiveTree)!
924935
);
925936
}
926937

@@ -1613,6 +1624,16 @@ public Rewrite.Core.Tree Create<T>(string type, ReceiverContext ctx) where T : R
16131624
);
16141625
}
16151626

1627+
if (type is "Rewrite.RewriteJava.Tree.J.Erroneous" or "org.openrewrite.java.tree.J$Erroneous")
1628+
{
1629+
return new J.Erroneous(
1630+
ctx.ReceiveValue(default(Guid))!,
1631+
ctx.ReceiveNode(default(Space), ReceiveSpace)!,
1632+
ctx.ReceiveNode(default(Markers), ctx.ReceiveMarkers)!,
1633+
ctx.ReceiveValue(default(string))!
1634+
);
1635+
}
1636+
16161637
throw new NotImplementedException("No factory method for type: " + type);
16171638
}
16181639
}

‎Rewrite/src/Rewrite.Remote.Codec/Java/JavaSender.g.cs‎

Lines changed: 11 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -150,9 +150,10 @@ public override J VisitCase(J.Case @case, SenderContext ctx)
150150
ctx.SendNode(@case, v => v.Prefix, SendSpace);
151151
ctx.SendNode(@case, v => v.Markers, ctx.SendMarkers);
152152
ctx.SendValue(@case, v => v.CaseType);
153-
ctx.SendNode(@case, v => v.Padding.Expressions, SendContainer);
153+
ctx.SendNode(@case, v => v.Padding.CaseLabels, SendContainer);
154154
ctx.SendNode(@case, v => v.Padding.Statements, SendContainer);
155155
ctx.SendNode(@case, v => v.Padding.Body, SendRightPadded);
156+
ctx.SendNode(@case, v => v.Guard, ctx.SendTree);
156157
return @case;
157158
}
158159

@@ -792,6 +793,15 @@ public override J VisitUnknownSource(J.Unknown.Source source, SenderContext ctx)
792793
return source;
793794
}
794795

796+
public override J VisitErroneous(J.Erroneous erroneous, SenderContext ctx)
797+
{
798+
ctx.SendValue(erroneous, v => v.Id);
799+
ctx.SendNode(erroneous, v => v.Prefix, SendSpace);
800+
ctx.SendNode(erroneous, v => v.Markers, ctx.SendMarkers);
801+
ctx.SendValue(erroneous, v => v.Text);
802+
return erroneous;
803+
}
804+
795805
private static void SendContainer<T>(JContainer<T> container, SenderContext ctx)
796806
where T : J
797807
{

0 commit comments

Comments
 (0)