/// <summary> Create a field initializer with new keyword. Example: IntReactiveProperty a = new IntReactiveProperty()</summary>
private static EqualsValueClauseSyntax CreateNewFieldInitializer(FieldGenerationData data)
{
var arguments = SyntaxFactory.ArgumentList();
if (!string.IsNullOrEmpty(data.m_InitializerValue) || VariableTypeCheckerUtility.IsVariableBoolean(data.m_VariableType))
{
arguments = arguments.AddArguments(SyntaxFactory.Argument(LiteralExpressionUtility.CreateLiteralExpression(data.m_VariableType, data.m_InitializerValue)));
}
return(SyntaxFactory.EqualsValueClause(SyntaxFactory.ObjectCreationExpression(
NameSyntaxUtility.GetNameSyntax(data.m_VariableType), arguments, null)));
}
private static SyntaxToken[] CreateStaticFieldModifierTokens(FieldGenerationData data)
{
var tokens = new List <SyntaxToken>();
switch (data.m_StaticModifier)
{
case StaticFieldType.Static: tokens.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword)); break;
case StaticFieldType.Const: tokens.Add(SyntaxFactory.Token(SyntaxKind.ConstKeyword)); break;
case StaticFieldType.StaticReadOnly:
tokens.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword));
tokens.Add(SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword));
break;
}
return(tokens.ToArray());
}
/// <summary>
/// Declares the variables in the field along with their initializers.
/// <para>In the example "private int testInt = 0", "testInt" would be the variable. </para>
/// </summary>
private static VariableDeclaratorSyntax CreateVariableDeclaratorSyntax(FieldGenerationData data)
{
VariableDeclaratorSyntax declaratorSyntax = SyntaxFactory.VariableDeclarator(data.m_VariableName);
if (!data.m_UseInitializer)
{
return(declaratorSyntax);
}
if (VariableTypeCheckerUtility.IsVariableInitializableWithoutNewKeyword(data.m_VariableType))
{
return(declaratorSyntax.WithInitializer(CreateFieldInitializer(data)));
}
else
{
return(declaratorSyntax.WithInitializer(CreateNewFieldInitializer(data)));
}
}
private static List <FieldGenerationData> ExtractFields(FieldDeclarationSyntax[] fields)
{
var dataList = new List <FieldGenerationData>();
for (int i = 0; i < fields.Length; i++)
{
var declaration = fields[i].Declaration;
var protectionLevel = ExtractProtectionLevel(fields[i].Modifiers.ToArray());
bool isConst = fields[i].Modifiers.Any(x => x.Kind() == SyntaxKind.ConstKeyword);
bool isStatic = fields[i].Modifiers.Any(x => x.Kind() == SyntaxKind.StaticKeyword);
bool isReadOnly = fields[i].Modifiers.Any(x => x.Kind() == SyntaxKind.ReadOnlyKeyword);
var staticModifier = isConst ? StaticFieldType.Const
: isStatic && isReadOnly ? StaticFieldType.StaticReadOnly
: isStatic ? StaticFieldType.Static
: StaticFieldType.None;
foreach (var variable in declaration.Variables)
{
var fieldGenerationData = new FieldGenerationData();
fieldGenerationData.m_VariableType = declaration.Type.ToString();
fieldGenerationData.m_VariableName = variable.Identifier.ToString();
fieldGenerationData.m_ProtectionLevel = protectionLevel;
fieldGenerationData.m_StaticModifier = staticModifier;
// maybe a bit off for string initializers
fieldGenerationData.m_InitializerValue = variable.Initializer?.Value.ToString();
fieldGenerationData.m_Attributes = ExtractAttributes(fields[i].AttributeLists.ToArray());
dataList.Add(fieldGenerationData);
}
}
return(dataList);
}
/// <summary> Create a field initializer without the new keyword. Example: int a = 0 </summary>
private static EqualsValueClauseSyntax CreateFieldInitializer(FieldGenerationData data)
{
return(SyntaxFactory.EqualsValueClause(LiteralExpressionUtility.CreateLiteralExpression(data.m_VariableType, data.m_InitializerValue)));
}
