public static string ConvertMethodDeclaration(string java)
{
var javaClassDeclaration = @"
class A
{
" + java + @"
}";
var declaration = JavaParser.parseBodyDeclaration(javaClassDeclaration);
var options = new JavaConversionOptions();
var context = new ConversionContext(options);
var classDeclaration = SyntaxFactory.ClassDeclaration("A");
var statementSyntax = BodyDeclarationVisitor.VisitBodyDeclarationForClass(context,
classDeclaration, (BodyDeclaration)declaration.getChildrenNodes().get(0))
.NormalizeWhitespace();
var tree = CSharpSyntaxTree.Create(statementSyntax);
return(tree.GetText().ToString());
}
private static ClassDeclarationSyntax VisitClassDeclaration(ConversionContext context, ClassOrInterfaceDeclaration javac, bool isNested = false)
{
string name = javac.getName();
if (!isNested)
{
context.RootTypeName = name;
}
context.LastTypeName = name;
var classSyntax = SyntaxFactory.ClassDeclaration(name);
var typeParams = javac.getTypeParameters().ToList <TypeParameter>();
if (typeParams != null && typeParams.Count > 0)
{
classSyntax = classSyntax.AddTypeParameterListParameters(typeParams.Select(i => SyntaxFactory.TypeParameter(i.getName())).ToArray());
}
var mods = javac.getModifiers();
if (mods.HasFlag(Modifier.PRIVATE))
{
classSyntax = classSyntax.AddModifiers(SyntaxFactory.Token(SyntaxKind.PrivateKeyword));
}
if (mods.HasFlag(Modifier.PROTECTED))
{
classSyntax = classSyntax.AddModifiers(SyntaxFactory.Token(SyntaxKind.ProtectedKeyword));
}
if (mods.HasFlag(Modifier.PUBLIC))
{
classSyntax = classSyntax.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword));
}
if (mods.HasFlag(Modifier.ABSTRACT))
{
classSyntax = classSyntax.AddModifiers(SyntaxFactory.Token(SyntaxKind.AbstractKeyword));
}
if (mods.HasFlag(Modifier.FINAL))
{
classSyntax = classSyntax.AddModifiers(SyntaxFactory.Token(SyntaxKind.SealedKeyword));
}
var extends = javac.getExtends().ToList <ClassOrInterfaceType>();
if (extends != null)
{
foreach (var extend in extends)
{
classSyntax = classSyntax.AddBaseListTypes(SyntaxFactory.SimpleBaseType(TypeHelper.GetSyntaxFromType(extend)));
}
}
var implements = javac.getImplements().ToList <ClassOrInterfaceType>();
if (implements != null)
{
foreach (var implement in implements)
{
classSyntax = classSyntax.AddBaseListTypes(SyntaxFactory.SimpleBaseType(TypeHelper.GetSyntaxFromType(implement, true)));
}
}
var members = javac.getMembers().ToList <BodyDeclaration>();
foreach (var member in members)
{
if (member is ClassOrInterfaceDeclaration)
{
var childc = (ClassOrInterfaceDeclaration)member;
if (childc.isInterface())
{
var childInt = VisitInterfaceDeclaration(context, childc, true);
classSyntax = classSyntax.AddMembers(childInt);
}
else
{
var childClass = VisitClassDeclaration(context, childc, true);
classSyntax = classSyntax.AddMembers(childClass);
}
}
else
{
var syntax = BodyDeclarationVisitor.VisitBodyDeclarationForClass(context, classSyntax, member);
classSyntax = classSyntax.AddMembers(syntax);
}
while (context.PendingAnonymousTypes.Count > 0)
{
var anon = context.PendingAnonymousTypes.Dequeue();
classSyntax = classSyntax.AddMembers(anon);
}
}
return(classSyntax);
}
private static ExpressionSyntax VisitAnonymousClassCreationExpression(ConversionContext context, ObjectCreationExpr newExpr, List <BodyDeclaration> anonBody)
{
string baseTypeName = TypeHelper.ConvertType(newExpr.getType().getName());
string anonTypeName = string.Empty;
for (int i = 0; i <= 100; i++)
{
if (i == 100)
{
throw new InvalidOperationException("Too many anonymous types");
}
anonTypeName = string.Format("Anonymous{0}{1}", baseTypeName, i == 0 ? string.Empty : i.ToString());
if (!context.UsedAnonymousTypeNames.Contains(anonTypeName))
{
context.UsedAnonymousTypeNames.Add(anonTypeName);
break; // go with this one
}
}
var classSyntax = SyntaxFactory.ClassDeclaration(anonTypeName)
.AddModifiers(
SyntaxFactory.Token(SyntaxKind.PrivateKeyword),
SyntaxFactory.Token(SyntaxKind.SealedKeyword))
.WithBaseList(SyntaxFactory.BaseList(SyntaxFactory.SeparatedList(new List <BaseTypeSyntax>
{
SyntaxFactory.SimpleBaseType(SyntaxFactory.ParseTypeName(baseTypeName))
})));
var parentField = SyntaxFactory.FieldDeclaration(
SyntaxFactory.VariableDeclaration(SyntaxFactory.ParseTypeName(context.LastTypeName)).AddVariables(SyntaxFactory.VariableDeclarator("parent")))
.AddModifiers(SyntaxFactory.Token(SyntaxKind.PrivateKeyword), SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword));
var ctorSyntax = SyntaxFactory.ConstructorDeclaration(anonTypeName)
.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword))
.AddParameterListParameters(SyntaxFactory.Parameter(SyntaxFactory.ParseToken("parent")).WithType(SyntaxFactory.ParseTypeName(context.LastTypeName)))
.AddBodyStatements(SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ThisExpression(), SyntaxFactory.IdentifierName("parent")), SyntaxFactory.IdentifierName("parent"))));
classSyntax = classSyntax.AddMembers(ctorSyntax, parentField);
foreach (var member in anonBody)
{
var memberSyntax = BodyDeclarationVisitor.VisitBodyDeclarationForClass(context, classSyntax, member);
classSyntax = classSyntax.AddMembers(memberSyntax);
}
context.PendingAnonymousTypes.Enqueue(classSyntax);
var args = newExpr.getArgs().ToList <Expression>();
if (args == null || args.Count == 0)
{
return(SyntaxFactory.ObjectCreationExpression(SyntaxFactory.ParseTypeName(anonTypeName))
.AddArgumentListArguments(SyntaxFactory.Argument(SyntaxFactory.ThisExpression())));
}
var argSyntaxes = new List <ArgumentSyntax>();
argSyntaxes.Add(SyntaxFactory.Argument(SyntaxFactory.ThisExpression()));
foreach (var arg in args)
{
var argSyntax = ExpressionVisitor.VisitExpression(context, arg);
argSyntaxes.Add(SyntaxFactory.Argument(argSyntax));
}
return(SyntaxFactory.ObjectCreationExpression(SyntaxFactory.ParseTypeName(anonTypeName), SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(argSyntaxes, Enumerable.Repeat(SyntaxFactory.Token(SyntaxKind.CommaToken), argSyntaxes.Count - 1))), null));
}