public static MethodDeclarationSyntax CreateMethod(MethodGenerationData data)
{
Debug.Assert(!string.IsNullOrEmpty(data.m_MethodName), "Trying to generate a method with null or empty method name!");
Debug.Assert(!string.IsNullOrEmpty(data.m_MethodReturnType), "Trying to generate a method with null or empty return type!");
Debug.Assert(data.m_MethodBodyStatements != null && data.m_MethodBodyStatements.Count > 0, "Trying to generate a method with no body!");
MethodDeclarationSyntax syntax = SyntaxFactory
.MethodDeclaration(SyntaxFactory.ParseTypeName(data.m_MethodReturnType), data.m_MethodName)
.AddModifiers(CodeGenerationUtility.CreateProtectionLevelToken(data.m_ProtectionLevel));
switch (data.m_InheritanceKeyword)
{
case FunctionInheritanceKeyword.STATIC: syntax = syntax.AddModifiers(SyntaxFactory.Token(SyntaxKind.StaticKeyword)); break;
case FunctionInheritanceKeyword.OVERRIDE: syntax = syntax.AddModifiers(SyntaxFactory.Token(SyntaxKind.OverrideKeyword)); break;
case FunctionInheritanceKeyword.VIRTUAL: syntax = syntax.AddModifiers(SyntaxFactory.Token(SyntaxKind.VirtualKeyword)); break;
}
if (data.m_IsAsync)
{
bool canMakeAsync = false;
for (int i = 0; i < s_AcceptedAsyncReturnTypes.Length; i++)
{
if (!data.m_MethodReturnType.Contains(s_AcceptedAsyncReturnTypes[i]))
{
continue;
}
canMakeAsync = true;
break;
}
Debug.Assert(canMakeAsync, "Trying to generate async function but the return type is not supported! Please make the return type either void, Task or UniTask");
if (canMakeAsync)
{
syntax = syntax.AddModifiers(SyntaxFactory.Token(SyntaxKind.AsyncKeyword));
}
}
syntax = syntax.AddAttributeLists(AttributeGenerationService.CreateAttributeListSyntaxes(data.m_Attributes));
foreach (var param in data.m_MethodParams)
{
syntax = syntax.AddParameterListParameters(CodeGenerationUtility.CreateParameterSyntax(param.m_ParamName, param.m_ParamType));
}
foreach (var statement in data.m_MethodBodyStatements)
{
syntax = syntax.AddBodyStatements((SyntaxFactory.ParseStatement(statement)));
}
return(syntax);
}
/// <summary> Creates the fields in the generated class. Such as "private int testInt = 0" </summary>
public static FieldDeclarationSyntax[] CreateFieldDeclarationSyntaxes(List <FieldGenerationData> datas)
{
var syntaxes = new List <FieldDeclarationSyntax>();
for (int i = 0; i < datas.Count; i++)
{
// Variable Type: bool, Variable Name: Cancelled. Created variable => bool Cancelled
VariableDeclarationSyntax variableSyntax = SyntaxFactory
.VariableDeclaration(SyntaxFactory.ParseTypeName(datas[i].m_VariableType))
.AddVariables(CreateVariableDeclaratorSyntax(datas[i]));
// With Protection Level = bool Cancelled => private bool Cancelled
syntaxes.Add(SyntaxFactory.FieldDeclaration(variableSyntax)
.AddModifiers(CodeGenerationUtility.CreateProtectionLevelToken(datas[i].m_ProtectionLevel))
.AddModifiers(CreateStaticFieldModifierTokens(datas[i])));
}
return(syntaxes.ToArray());
}
/// <summary> Modify the method found in GetOriginalMethodDeclarationSyntax(). </summary>
private static MethodDeclarationSyntax GetModifiedMethodDeclarationSyntax(MethodDeclarationSyntax method, MethodModificationData modificationData)
{
var nodes = method.DescendantNodes().ToList();
ParameterListSyntax paramListSyntax = SyntaxFactory.ParameterList();
foreach (var param in modificationData.m_NewMethodParams)
{
paramListSyntax = paramListSyntax.AddParameters(CodeGenerationUtility.CreateParameterSyntax(param.m_ParamName, param.m_ParamType));
}
method = modificationData.m_ParamModificationType == MethodParameterModificationType.REPLACE_PARAMS
? method.WithParameterList(paramListSyntax)
: method.AddParameterListParameters(paramListSyntax.Parameters.ToArray());
BlockSyntax blockSyntax = SyntaxFactory.Block();
var oldStatements = method.Body.Statements.ToList();
foreach (var statement in modificationData.m_BodyStatements)
{
if (modificationData.m_BodyModificationType == MethodBodyModificationType.ADD_OR_REPLACE_BODY)
{
if (oldStatements.Find(x => x.ToFullString().Contains(statement)) != null)
{
continue;
}
}
blockSyntax = blockSyntax.AddStatements(SyntaxFactory.ParseStatement(statement));
}
// if replacing the body, the statement in the old function with be completely replaced with the new statement
method = modificationData.m_BodyModificationType == MethodBodyModificationType.REPLACE_BODY
? method.WithBody(blockSyntax)
: method.AddBodyStatements(blockSyntax.Statements.ToArray());
return(method.NormalizeWhitespace());
}
private static ClassDeclarationSyntax CreateClassDeclarationSyntax(string className, string[] baseClasses, ClassType classType, List <ConstraintData> constraints)
{
ClassDeclarationSyntax syntax = SyntaxFactory.ClassDeclaration(className);
List <SyntaxToken> tokens = new List <SyntaxToken>();
tokens.Add(SyntaxFactory.Token(SyntaxKind.PublicKeyword));
switch (classType)
{
case ClassType.Standard: break;
case ClassType.Partial: tokens.Add(SyntaxFactory.Token(SyntaxKind.PartialKeyword)); break;
case ClassType.Static: tokens.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword)); break;
case ClassType.StaticPartial:
tokens.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword));
tokens.Add(SyntaxFactory.Token(SyntaxKind.PartialKeyword));
break;
}
// Add the public modifier: (public class Order)
syntax = syntax.AddModifiers(tokens.ToArray());
// Inherit BaseEntity<T> and implement IHaveIdentity: (public class Order : BaseEntity<T>, IHaveIdentity)
for (int i = 0; i < baseClasses.Length; i++)
{
syntax = syntax.AddBaseListTypes(SyntaxFactory.SimpleBaseType(SyntaxFactory.ParseTypeName(baseClasses[i])));
}
for (int i = 0; i < constraints.Count; i++)
{
syntax = syntax.AddConstraintClauses(CodeGenerationUtility.CreateConstraintClause(constraints[i]));
}
return(syntax);
}
