FilesExpand file tree

 master

/

ForStatementVisitor.cs

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

71 lines (59 loc) · 2.71 KB

 master

/

ForStatementVisitor.cs

Copy path

Top

File metadata and controls

• Code
• Blame

71 lines (59 loc) · 2.71 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

using System.Collections.Generic;

using System.Linq;

using com.github.javaparser.ast.body;

using com.github.javaparser.ast.expr;

using com.github.javaparser.ast.stmt;

using JavaToCSharp.Expressions;

using Microsoft.CodeAnalysis.CSharp;

using Microsoft.CodeAnalysis.CSharp.Syntax;

namespace JavaToCSharp.Statements;

public class ForStatementVisitor : StatementVisitor<ForStmt>

{

public override StatementSyntax? Visit(ConversionContext context, ForStmt forStmt)

{

var inits = forStmt.getInitialization().ToList<Expression>();

var initSyntaxes = new List<ExpressionSyntax>();

VariableDeclarationSyntax? varSyntax = null;

if (inits != null)

{

foreach (var init in inits)

{

if (init is VariableDeclarationExpr varExpr)

{

var type = TypeHelper.ConvertType(varExpr.getCommonType());

var variableDeclarators = varExpr.getVariables()?.ToList<VariableDeclarator>() ?? new List<VariableDeclarator>();

var vars = variableDeclarators

.Select(i => SyntaxFactory.VariableDeclarator(i.toString()))

.ToArray();

varSyntax = SyntaxFactory.VariableDeclaration(SyntaxFactory.ParseTypeName(type), SyntaxFactory.SeparatedList(vars, Enumerable.Repeat(SyntaxFactory.Token(SyntaxKind.CommaToken), vars.Length - 1)));

}

else

{

var initSyntax = ExpressionVisitor.VisitExpression(context, init);

if (initSyntax is not null)

{

initSyntaxes.Add(initSyntax);

}

}

}

}

var condition = forStmt.getCompare().FromOptional<Expression>();

var conditionSyntax = ExpressionVisitor.VisitExpression(context, condition);

var increments = forStmt.getUpdate().ToList<Expression>();

var incrementSyntaxes = new List<ExpressionSyntax>();

if (increments != null)

{

var expressionSyntaxes = increments.Select(increment => ExpressionVisitor.VisitExpression(context, increment));

incrementSyntaxes.AddRange(expressionSyntaxes.Where(expressionSyntax => expressionSyntax != null)!);

}

var body = forStmt.getBody();

var bodySyntax = VisitStatement(context, body);

if (bodySyntax == null)

return null;

return SyntaxFactory.ForStatement(bodySyntax)

.WithDeclaration(varSyntax)

.AddInitializers(initSyntaxes.ToArray())

.WithCondition(conditionSyntax)

.AddIncrementors(incrementSyntaxes.ToArray());

}

}