/*
* public static T Or<T>(this Option<T> thisOption, T or)
* {
* T v;
*
* thisOption.
*
* return v;
* }
*/
public static FieldDeclarationSyntax Field(string fieldName, string type, Optional <ExpressionSyntax> assignment, params SyntaxKind[] modifiers)
{
//var st = SF.ParseStatement( $"static public readonly {m_class.Identifier} def = new {m_class.Identifier};" );
//var newClass = SF.ParseExpression( $"new {m_class.Identifier}()" );
var declarator = SF.VariableDeclarator(fieldName);
if (assignment.HasValue)
{
declarator = declarator.WithInitializer(SF.EqualsValueClause(assignment.Value));
}
var decl = SF.VariableDeclaration(SF.IdentifierName(type), SF.SingletonSeparatedList(declarator));
var field = SF.FieldDeclaration(decl);
if (modifiers.Length > 0)
{
var stl = new SyntaxTokenList(modifiers.Select(mod => SF.Token(mod)));
field = field.WithModifiers(stl);
}
return(field);
}
private ClassDeclarationSyntax GetClassForLocatorInInfo(WebLocatorInfo locatorInfo)
{
var infoMembers = new List <MemberDeclarationSyntax>();
var infoMembersList = new List <(string type, string fName, string value)>
{
(nameof(WebLocatorType), nameof(locatorInfo.LocatorType), $"{nameof(WebLocatorType)}.{locatorInfo.LocatorType}"),
("string", nameof(locatorInfo.LocatorValue), locatorInfo.LocatorValue),
("bool", nameof(locatorInfo.IsRelative), $"{locatorInfo.IsRelative}"),
};
foreach (var infoMemberItem in infoMembersList)
{
var docComment = GetDocCommentWithText(infoMemberItem.value);
var fd = SF.FieldDeclaration(
SF.VariableDeclaration(SF.ParseTypeName(infoMemberItem.type))
.AddVariables(SF.VariableDeclarator(SF.Identifier(infoMemberItem.fName))
)
)
.AddModifiers(
SF.Token(SF.TriviaList(), SyntaxKind.PublicKeyword, SF.TriviaList())
.WithLeadingTrivia(SF.Trivia(docComment))
);
infoMembers.Add(fd);
}
var infoCD = SF.ClassDeclaration(LocatorClassName)
.AddModifiers(SF.Token(SyntaxKind.PublicKeyword))
.AddMembers(infoMembers.ToArray());
return(infoCD);
}
private static FieldDeclarationSyntax CreateFileSystemPropertyDeclaration()
{
return(SF.FieldDeclaration(SF.VariableDeclaration(CreateFileSystemType())
.WithVariables(SF.SingletonSeparatedList(SF.VariableDeclarator(SF.Identifier("_fileSystem")))))
.WithModifiers(SF.TokenList(SF.Token(SyntaxKind.PrivateKeyword),
SF.Token(SyntaxKind.ReadOnlyKeyword))));
}
private ClassDeclarationSyntax GetClassForConstLocatorInInfo(WebLocatorInfo locatorInfo)
{
var infoMembers = new List <MemberDeclarationSyntax>();
var infoMembersList = new List <(string type, string fName, ExpressionSyntax expr)>
{
(nameof(WebLocatorType), nameof(locatorInfo.LocatorType), GetESForValue(locatorInfo.LocatorType)),
("string", nameof(locatorInfo.LocatorValue), GetESForValue(locatorInfo.LocatorValue)),
("bool", nameof(locatorInfo.IsRelative), GetESForValue(locatorInfo.IsRelative))
};
foreach (var infoMemberItem in infoMembersList)
{
var fd = SF.FieldDeclaration(
SF.VariableDeclaration(SF.ParseTypeName(infoMemberItem.type))
.AddVariables(SF.VariableDeclarator(SF.Identifier(infoMemberItem.fName))
.WithInitializer(SF.EqualsValueClause(infoMemberItem.expr))
)
)
.AddModifiers(SF.Token(SyntaxKind.PublicKeyword), SF.Token(SyntaxKind.ConstKeyword));
infoMembers.Add(fd);
}
var infoCD = SF.ClassDeclaration(LocatorStaticClassName)
.AddModifiers(SF.Token(SyntaxKind.PublicKeyword), SF.Token(SyntaxKind.StaticKeyword))
.AddMembers(infoMembers.ToArray());
return(infoCD);
}
public ClassDeclarationSyntax GenerateHelper()
{
if (!HasImports)
{
return(null);
}
var xAttributeList = SyntaxFactory.FieldDeclaration(
SyntaxFactory.List <AttributeListSyntax>(),
SyntaxFactory.TokenList(SyntaxFactory.Token(CSSyntaxKind.PrivateKeyword), SyntaxFactory.Token(CSSyntaxKind.StaticKeyword)),
CommonConversions.CreateVariableDeclarationAndAssignment(
"namespaceAttributes", SyntaxFactory.InitializerExpression(
CSSyntaxKind.ArrayInitializerExpression,
SyntaxFactory.SeparatedList <ExpressionSyntax>(
from x in _xNamespaceFields
let fieldIdentifierName = SyntaxFactory.IdentifierName(x.Declaration.Variables.Single().Identifier)
let namespaceNameExpression = SyntaxFactory.MemberAccessExpression(CSSyntaxKind.SimpleMemberAccessExpression, fieldIdentifierName, SyntaxFactory.IdentifierName("NamespaceName"))
let attributeNameExpression = fieldIdentifierName.IsEquivalentTo(DefaultIdentifierName) ? CommonConversions.Literal("xmlns") : BuildXmlnsAttributeName(fieldIdentifierName)
let arguments = SyntaxFactory.Argument(attributeNameExpression).Yield().Concat(SyntaxFactory.Argument(namespaceNameExpression))
select SyntaxFactory.ObjectCreationExpression(SyntaxFactory.IdentifierName("XAttribute")).WithArgumentList(SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(arguments))))),
SyntaxFactory.ArrayType(SyntaxFactory.IdentifierName("XAttribute"), SyntaxFactory.SingletonList(SyntaxFactory.ArrayRankSpecifier(SyntaxFactory.SingletonSeparatedList <ExpressionSyntax>(SyntaxFactory.OmittedArraySizeExpression()))))));
var boilerplate = SyntaxFactory.ParseStatement(@"
TContainer Apply<TContainer>(TContainer x) where TContainer : XContainer
{
foreach (var d in x.Descendants()) {
foreach (var n in namespaceAttributes) {
var a = d.Attribute(n.Name);
if (a != null && a.Value == n.Value) {
a.Remove();
}
}
}
x.Add(namespaceAttributes);
return x;
}") as LocalFunctionStatementSyntax;
var applyMethod = SyntaxFactory.MethodDeclaration(
SyntaxFactory.List <AttributeListSyntax>(),
SyntaxFactory.TokenList(SyntaxFactory.Token(CSSyntaxKind.InternalKeyword), SyntaxFactory.Token(CSSyntaxKind.StaticKeyword)),
boilerplate.ReturnType,
null,
boilerplate.Identifier,
boilerplate.TypeParameterList,
boilerplate.ParameterList,
boilerplate.ConstraintClauses,
boilerplate.Body,
boilerplate.ExpressionBody);
return(SyntaxFactory.ClassDeclaration(
SyntaxFactory.List <AttributeListSyntax>(),
SyntaxFactory.TokenList(SyntaxFactory.Token(CSSyntaxKind.InternalKeyword), SyntaxFactory.Token(CSSyntaxKind.StaticKeyword)),
HelperClassUniqueIdentifierName.Identifier,
null, null,
SyntaxFactory.List <TypeParameterConstraintClauseSyntax>(),
SyntaxFactory.List(_xNamespaceFields.Concat <MemberDeclarationSyntax>(xAttributeList).Concat(applyMethod))
));
}
private MemberDeclarationSyntax TypedMockProviderField()
{
return(F.FieldDeclaration(F.VariableDeclaration(TypesForSymbols.TypedMockProvider()).WithVariables(
F.SingletonSeparatedList(F.VariableDeclarator(F.Identifier(MockProviderName))
.WithInitializer(F.EqualsValueClause(F.ObjectCreationExpression(TypesForSymbols.TypedMockProvider())
.WithArgumentList(F.ArgumentList())))))
).WithModifiers(F.TokenList(F.Token(SyntaxKind.PrivateKeyword), F.Token(SyntaxKind.ReadOnlyKeyword))));
}
/// <summary>
/// Returns syntax for the static fields of the serializer class.
/// </summary>
/// <param name="fields">The fields.</param>
/// <returns>Syntax for the static fields of the serializer class.</returns>
private static MemberDeclarationSyntax[] GenerateFields(List <FieldInfoMember> fields)
{
var result = new List <MemberDeclarationSyntax>();
// Add each field and initialize it.
foreach (var field in fields)
{
// Declare the getter for this field.
if (!field.IsGettableProperty)
{
var getterType =
typeof(Func <,>).MakeGenericType(field.FieldInfo.DeclaringType, field.FieldInfo.FieldType)
.GetTypeSyntax();
var fieldGetterVariable = SF.VariableDeclarator(field.GetterFieldName);
result.Add(
SF.FieldDeclaration(SF.VariableDeclaration(getterType).AddVariables(fieldGetterVariable))
.AddModifiers(
SF.Token(SyntaxKind.PrivateKeyword),
SF.Token(SyntaxKind.ReadOnlyKeyword)));
}
if (!field.IsSettableProperty)
{
if (field.FieldInfo.DeclaringType != null && field.FieldInfo.DeclaringType.GetTypeInfo().IsValueType)
{
var setterType =
typeof(ValueTypeSetter <,>).MakeGenericType(
field.FieldInfo.DeclaringType,
field.FieldInfo.FieldType).GetTypeSyntax();
var fieldSetterVariable = SF.VariableDeclarator(field.SetterFieldName);
result.Add(
SF.FieldDeclaration(SF.VariableDeclaration(setterType).AddVariables(fieldSetterVariable))
.AddModifiers(
SF.Token(SyntaxKind.PrivateKeyword),
SF.Token(SyntaxKind.ReadOnlyKeyword)));
}
else
{
var setterType =
typeof(Action <,>).MakeGenericType(field.FieldInfo.DeclaringType, field.FieldInfo.FieldType)
.GetTypeSyntax();
var fieldSetterVariable = SF.VariableDeclarator(field.SetterFieldName);
result.Add(
SF.FieldDeclaration(SF.VariableDeclaration(setterType).AddVariables(fieldSetterVariable))
.AddModifiers(
SF.Token(SyntaxKind.PrivateKeyword),
SF.Token(SyntaxKind.ReadOnlyKeyword)));
}
}
}
return(result.ToArray());
}
public FieldDeclarationSyntax ToFieldDeclaration()
{
if (canonicalName.value != name.name.value)
{
Console.WriteLine($"Warning!!! '{canonicalName.value}' != '{name.name.value}';");
}
if (annotations.Count != 0)
{
Console.WriteLine($"Warning!!! Annotations!;");
}
var declaratorSyntax = SF.VariableDeclarator(SF.Identifier(name.name.value));
if (initializer.TryGetValue(out var initializerExpression))
{
declaratorSyntax = declaratorSyntax.WithInitializer(
// todo: I think this might not work ... a lot!
SF.EqualsValueClause(initializerExpression.ToLiteralExpressionSyntax()));
}
var fieldDeclaration = SF.FieldDeclaration(
SF.VariableDeclaration(type.ToTypeSyntax())
.WithVariables(SF.SingletonSeparatedList <VariableDeclaratorSyntax>(declaratorSyntax)));
if (flags.HasFlag(Flag.isConst))
{
fieldDeclaration = fieldDeclaration.WithModifiers(SF.TokenList(SF.Token(SyntaxKind.ConstKeyword)));
}
if (flags.HasFlag(Flag.isFinal))
{
fieldDeclaration = fieldDeclaration.WithModifiers(SF.TokenList(SF.Token(SyntaxKind.ReadOnlyKeyword)));
}
if (flags.HasFlag(Flag.isStatic))
{
fieldDeclaration = fieldDeclaration.WithModifiers(SF.TokenList(SF.Token(SyntaxKind.StaticKeyword)));
}
if (flags.HasFlag(Flag.isCovariant))
{
throw new NotImplementedException();
}
if (flags.HasFlag(Flag.isGenericCovariantImpl))
{
throw new NotImplementedException();
}
if (flags.HasFlag(Flag.hasImplicitSetter))
{
throw new NotImplementedException();
}
if (flags.HasFlag(Flag.hasImplicitGetter))
{
throw new NotImplementedException();
}
return(fieldDeclaration);
}
private SyntaxTree CreateSyntaxTree()
{
var compilationUnit = SF
.CompilationUnit()
.AddUsings
(
SF.UsingDirective
(SF.ParseName("System"))
);
var ns = SF
.NamespaceDeclaration(SF.IdentifierName("SynTreeFred"));
var cls = SF
.ClassDeclaration("Henry")
.AddModifiers(SF.Token(SyntaxKind.PublicKeyword));
// How to define base class and interfaces, with/without generics
//
//cls = cls.AddBaseListTypes(
// SF.SimpleBaseType(SF.ParseTypeName("Object")),
// SF.SimpleBaseType(SF.ParseTypeName("IEnumerable<string>")));
var inti = SF
.VariableDeclaration(SF.ParseTypeName("int"))
.AddVariables
(
SF.VariableDeclarator
(
SF.Identifier("i"),
null,
SF.EqualsValueClause
(
SF.LiteralExpression
(
SyntaxKind.NumericLiteralExpression,
SF.Literal(12)
)
)
)
);
var field = SF.FieldDeclaration(inti)
.AddModifiers(SF.Token(SyntaxKind.PrivateKeyword));
var syntax = SF.ParseStatement("return ++i;");
var methodDeclaration = SF
.MethodDeclaration(SF.ParseTypeName("int"), "GetNextInt")
.AddModifiers(SF.Token(SyntaxKind.PublicKeyword))
.WithBody(SF.Block(syntax));
cls = cls.AddMembers(field, methodDeclaration);
ns = ns.AddMembers(cls);
compilationUnit = compilationUnit.AddMembers(ns);
return(compilationUnit.SyntaxTree);
}
public override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node)
{
FieldDeclarationSyntax aField = SF.FieldDeclaration(
SF.VariableDeclaration(
SF.ParseTypeName(" string "),
SF.SeparatedList(new[] { SF.VariableDeclarator(SF.Identifier("bopin=\"Hi bopin\"")) })
))
.AddModifiers(SF.Token(SyntaxKind.StaticKeyword)); //SyntaxKind.PublicKeyword),
node = node.AddMembers(aField);
return(base.VisitClassDeclaration(node));
}
private static ClassDeclarationSyntax AddStubContainerField(ClassDeclarationSyntax classDclr, string stubName)
{
classDclr = classDclr.AddMembers(
SF.FieldDeclaration(
SF.VariableDeclaration(SF.ParseTypeName($"StubContainer<{stubName}>"),
SF.SeparatedList(new[]
{
SF.VariableDeclarator(SF.Identifier("_stubs"), null,
SF.EqualsValueClause(SF.ParseExpression($"new StubContainer<{stubName}>()")))
})))
.AddModifiers(SF.Token(SyntaxKind.PrivateKeyword), SF.Token(SyntaxKind.ReadOnlyKeyword)));
return(classDclr);
}
private ClassDeclarationSyntax GetClassForInfo(WebElementInfo info)
{
var infoMembers = new List <MemberDeclarationSyntax>();
var infoMembersList = new List <(string type, string fName, string value)>
{
("string", nameof(info.ElementType), info.ElementType),
("string", nameof(info.Name), info.Name),
("string", nameof(info.Description), info.Description),
("bool", nameof(info.IsKey), $"{info.IsKey}"),
("string", nameof(info.InnerKey), $"{info.InnerKey ?? "null"}"),
(LocatorClassName, LocatorClassName, "Element Locator values")
};
var newLineToken = SF.Token(default(SyntaxTriviaList),
SyntaxKind.XmlTextLiteralNewLineToken,
Environment.NewLine, Environment.NewLine, default(SyntaxTriviaList));
var docCommentToken = SF.Token(SF.TriviaList(
SF.SyntaxTrivia(SyntaxKind.DocumentationCommentExteriorTrivia, "///")),
SyntaxKind.XmlTextLiteralToken, " ", " ", default(SyntaxTriviaList));
var endNode = SF.XmlText(
SF.TokenList(SF.Token(default(SyntaxTriviaList), SyntaxKind.XmlTextLiteralNewLineToken,
Environment.NewLine, Environment.NewLine, default(SyntaxTriviaList))));
foreach (var infoMemberItem in infoMembersList)
{
var docComment = GetDocCommentWithText(infoMemberItem.value);
var fd = SF.FieldDeclaration(
SF.VariableDeclaration(SF.ParseTypeName(infoMemberItem.type))
.AddVariables(SF.VariableDeclarator(SF.Identifier(infoMemberItem.fName)))
)
.AddModifiers(
SF.Token(SF.TriviaList(), SyntaxKind.PublicKeyword, SF.TriviaList())
.WithLeadingTrivia(SF.Trivia(docComment))
);
infoMembers.Add(fd);
}
var infoCD = SF.ClassDeclaration(InfoClassName)
.AddModifiers(SF.Token(SyntaxKind.PublicKeyword))
.AddMembers(infoMembers.ToArray());
return(infoCD);
}
public static string GenerateClass()
{
var @consoleWriteLine = Syntax.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
Syntax.IdentifierName("Console"),
name: Syntax.IdentifierName("WriteLine"));
var @arguments = Syntax.ArgumentList(Syntax.SeparatedList(new[] {
Syntax.Argument(
Syntax.LiteralExpression(
SyntaxKind.StringLiteralExpression,
Syntax.Literal(@"$""{this.Name} -> {this.counter}""", "${this.Name} -> {this.counter}")))
}));
var @consoleWriteLineStatement = Syntax.ExpressionStatement(Syntax.InvocationExpression(@consoleWriteLine, @arguments));
var @voidType = Syntax.ParseTypeName("void");
var @stringType = Syntax.ParseTypeName("string");
var @field = Syntax.FieldDeclaration(Syntax.VariableDeclaration(Syntax.ParseTypeName("int"), Syntax.SeparatedList(new[] { Syntax.VariableDeclarator(Syntax.Identifier("counter")) }))).AddModifiers(Syntax.Token(SyntaxKind.PrivateKeyword)).WithSemicolonToken(Syntax.Token(SyntaxKind.SemicolonToken));
var @property = Syntax.PropertyDeclaration(stringType, "Name").AddAccessorListAccessors(Syntax.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.WithSemicolonToken(Syntax.Token(SyntaxKind.SemicolonToken)
)).AddModifiers(Syntax.Token(SyntaxKind.PublicKeyword));
@property = @property.AddAccessorListAccessors(Syntax.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration).WithSemicolonToken(Syntax.Token(SyntaxKind.SemicolonToken)));
var @printMethod = Syntax.MethodDeclaration(voidType, "Print").AddModifiers(Syntax.Token(SyntaxKind.PublicKeyword)).WithBody(Syntax.Block(consoleWriteLineStatement));
List <ParameterSyntax> @parameterList = new List <ParameterSyntax>
{
Syntax.Parameter(Syntax.Identifier("x")).WithType(Syntax.ParseTypeName("int"))
};
var @methodBody = Syntax.ParseStatement("counter += x;");
var @incrementMethod = Syntax.MethodDeclaration(voidType, "Increment").AddModifiers(Syntax.Token(SyntaxKind.PublicKeyword)).WithBody(Syntax.Block(methodBody)).AddParameterListParameters(parameterList.ToArray());
var @class = Syntax.ClassDeclaration("MyClass").WithMembers(Syntax.List(new MemberDeclarationSyntax[] { @property, @field, @incrementMethod, @printMethod })).AddModifiers(Syntax.Token(SyntaxKind.PublicKeyword)).AddModifiers(Syntax.Token(SyntaxKind.SealedKeyword));
var adhocWorkSpace = new AdhocWorkspace();
adhocWorkSpace.Options.WithChangedOption(CSharpFormattingOptions.IndentBraces, true);
var formattedCode = Formatter.Format(@class, adhocWorkSpace);
return(formattedCode.ToFullString());
}
public static void Generate()
{
// Make a namespace
var nspaceDecl = SF.NamespaceDeclaration(SF.ParseName("ExampleNamespace"));
// Make a class
var classDecl = SF.ClassDeclaration("Order");
// Class inherits base type and implements interface
classDecl = classDecl.AddBaseListTypes(
SF.SimpleBaseType(SF.ParseTypeName("BaseEntity<Order>")),
SF.SimpleBaseType(SF.ParseTypeName("IHaveIdentity"))
);
var varDecl = SF.VariableDeclaration(SF.ParseTypeName("bool")).AddVariables(SF.VariableDeclarator("canceled"));
var fieldDecl = SF.FieldDeclaration(varDecl).AddModifiers(SF.Token(SyntaxKind.PrivateKeyword));
var propDecl = SF.PropertyDeclaration(SF.ParseTypeName("int"), "Quantity")
.AddModifiers(SF.Token(SyntaxKind.PublicKeyword))
.AddAccessorListAccessors(
SF.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration).WithSemicolonToken(SF.Token(SyntaxKind.SemicolonToken)),
SF.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration).WithSemicolonToken(SF.Token(SyntaxKind.SemicolonToken))
);
var methodBody = SF.ParseStatement("canceled = true");
var methodDecl = SF.MethodDeclaration(SF.ParseTypeName("void"), "MarkAsCanceled")
.AddModifiers(SF.Token(SyntaxKind.PublicKeyword))
.WithBody(SF.Block(methodBody));
classDecl = classDecl.AddMembers(
fieldDecl,
propDecl,
methodDecl);
nspaceDecl = nspaceDecl.AddMembers(classDecl);
var code = nspaceDecl.NormalizeWhitespace().ToFullString();
Console.WriteLine(code);
}
private static MemberDeclarationSyntax[] GetFieldInfoFields(List <FieldInfoMember> fields)
{
var result = new List <MemberDeclarationSyntax>();
// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
Expression <Action <Type> > getField = _ => _.GetField(string.Empty, BindingFlags.Default);
// Expressions for specifying binding flags.
var flags = SF.IdentifierName("System").Member("Reflection").Member("BindingFlags");
var publicFlag = flags.Member(BindingFlags.Public.ToString());
var nonPublicFlag = flags.Member(BindingFlags.NonPublic.ToString());
var instanceFlag = flags.Member(BindingFlags.Instance.ToString());
var bindingFlags =
SF.ParenthesizedExpression(
SF.BinaryExpression(
SyntaxKind.BitwiseOrExpression,
publicFlag,
SF.BinaryExpression(SyntaxKind.BitwiseOrExpression, nonPublicFlag, instanceFlag)));
// Add each field and initialize it.
foreach (var field in fields)
{
var fieldInfo =
getField.Invoke(SF.TypeOfExpression(field.FieldInfo.DeclaringType.GetTypeSyntax()))
.AddArgumentListArguments(
SF.Argument(field.FieldInfo.Name.GetLiteralExpression()),
SF.Argument(bindingFlags));
var fieldInfoVariable =
SF.VariableDeclarator(field.InfoFieldName).WithInitializer(SF.EqualsValueClause(fieldInfo));
result.Add(
SF.FieldDeclaration(
SF.VariableDeclaration(typeof(FieldInfo).GetTypeSyntax()).AddVariables(fieldInfoVariable))
.AddModifiers(
SF.Token(SyntaxKind.PrivateKeyword),
SF.Token(SyntaxKind.StaticKeyword),
SF.Token(SyntaxKind.ReadOnlyKeyword)));
}
return(result.ToArray());
}
/// <summary>
/// Generates a <see cref="GenericMethodInvoker"/> field for the provided generic method.
/// </summary>
/// <param name="method">The method.</param>
/// <returns>The generated field.</returns>
private static MemberDeclarationSyntax GenerateGenericInvokerField(MethodInfo method)
{
var fieldInfoVariable =
SF.VariableDeclarator(GetGenericMethodInvokerFieldName(method))
.WithInitializer(
SF.EqualsValueClause(
SF.ObjectCreationExpression(typeof(GenericMethodInvoker).GetTypeSyntax())
.AddArgumentListArguments(
SF.Argument(SF.TypeOfExpression(method.DeclaringType.GetTypeSyntax())),
SF.Argument(method.Name.GetLiteralExpression()),
SF.Argument(
SF.LiteralExpression(
SyntaxKind.NumericLiteralExpression,
SF.Literal(method.GetGenericArguments().Length))))));
return
(SF.FieldDeclaration(
SF.VariableDeclaration(typeof(GenericMethodInvoker).GetTypeSyntax()).AddVariables(fieldInfoVariable))
.AddModifiers(
SF.Token(SyntaxKind.PrivateKeyword),
SF.Token(SyntaxKind.StaticKeyword),
SF.Token(SyntaxKind.ReadOnlyKeyword)));
}
private SyntaxList <MemberDeclarationSyntax> CreateDefault()
{
var list = new SyntaxList <MemberDeclarationSyntax>();
//var st = SF.ParseStatement( $"static public readonly {m_class.Identifier} def = new {m_class.Identifier};" );
var newClass = SF.ParseExpression($"new {SU.ClassNameWithGenerics(m_class)}()");
var declarator = SF.VariableDeclarator("def")
.WithInitializer(SF.EqualsValueClause(newClass));
var decl = SF.VariableDeclaration(SF.IdentifierName(SU.ClassNameWithGenerics(m_class)), SF.SingletonSeparatedList(declarator));
var keywords = SyntaxTokenList.Create(SF.Token(SyntaxKind.PublicKeyword))
.Add(SF.Token(SyntaxKind.StaticKeyword))
.Add(SF.Token(SyntaxKind.ReadOnlyKeyword));
var field = SF.FieldDeclaration(decl)
.WithModifiers(keywords);
list = list.Add(field);
return(list);
}
/// <summary>
/// Returns syntax for the static fields of the serializer class.
/// </summary>
/// <param name="fields">The fields.</param>
/// <returns>Syntax for the static fields of the serializer class.</returns>
private static MemberDeclarationSyntax[] GenerateStaticFields(List <FieldInfoMember> fields)
{
var result = new List <MemberDeclarationSyntax>();
// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
Expression <Action <TypeInfo> > getField = _ => _.GetField(string.Empty, BindingFlags.Default);
Expression <Action <Type> > getTypeInfo = _ => _.GetTypeInfo();
Expression <Action> getGetter = () => SerializationManager.GetGetter(default(FieldInfo));
Expression <Action> getReferenceSetter = () => SerializationManager.GetReferenceSetter(default(FieldInfo));
Expression <Action> getValueSetter = () => SerializationManager.GetValueSetter(default(FieldInfo));
// Expressions for specifying binding flags.
var bindingFlags = SyntaxFactoryExtensions.GetBindingFlagsParenthesizedExpressionSyntax(
SyntaxKind.BitwiseOrExpression,
BindingFlags.Instance,
BindingFlags.NonPublic,
BindingFlags.Public);
// Add each field and initialize it.
foreach (var field in fields)
{
var fieldInfo =
getField.Invoke(getTypeInfo.Invoke(SF.TypeOfExpression(field.FieldInfo.DeclaringType.GetTypeSyntax())))
.AddArgumentListArguments(
SF.Argument(field.FieldInfo.Name.GetLiteralExpression()),
SF.Argument(bindingFlags));
var fieldInfoVariable =
SF.VariableDeclarator(field.InfoFieldName).WithInitializer(SF.EqualsValueClause(fieldInfo));
var fieldInfoField = SF.IdentifierName(field.InfoFieldName);
if (!field.IsGettableProperty || !field.IsSettableProperty)
{
result.Add(
SF.FieldDeclaration(
SF.VariableDeclaration(typeof(FieldInfo).GetTypeSyntax()).AddVariables(fieldInfoVariable))
.AddModifiers(
SF.Token(SyntaxKind.PrivateKeyword),
SF.Token(SyntaxKind.StaticKeyword),
SF.Token(SyntaxKind.ReadOnlyKeyword)));
}
// Declare the getter for this field.
if (!field.IsGettableProperty)
{
var getterType =
typeof(Func <,>).MakeGenericType(field.FieldInfo.DeclaringType, field.FieldInfo.FieldType)
.GetTypeSyntax();
var fieldGetterVariable =
SF.VariableDeclarator(field.GetterFieldName)
.WithInitializer(
SF.EqualsValueClause(
SF.CastExpression(
getterType,
getGetter.Invoke().AddArgumentListArguments(SF.Argument(fieldInfoField)))));
result.Add(
SF.FieldDeclaration(SF.VariableDeclaration(getterType).AddVariables(fieldGetterVariable))
.AddModifiers(
SF.Token(SyntaxKind.PrivateKeyword),
SF.Token(SyntaxKind.StaticKeyword),
SF.Token(SyntaxKind.ReadOnlyKeyword)));
}
if (!field.IsSettableProperty)
{
if (field.FieldInfo.DeclaringType != null && field.FieldInfo.DeclaringType.IsValueType)
{
var setterType =
typeof(SerializationManager.ValueTypeSetter <,>).MakeGenericType(
field.FieldInfo.DeclaringType,
field.FieldInfo.FieldType).GetTypeSyntax();
var fieldSetterVariable =
SF.VariableDeclarator(field.SetterFieldName)
.WithInitializer(
SF.EqualsValueClause(
SF.CastExpression(
setterType,
getValueSetter.Invoke()
.AddArgumentListArguments(SF.Argument(fieldInfoField)))));
result.Add(
SF.FieldDeclaration(SF.VariableDeclaration(setterType).AddVariables(fieldSetterVariable))
.AddModifiers(
SF.Token(SyntaxKind.PrivateKeyword),
SF.Token(SyntaxKind.StaticKeyword),
SF.Token(SyntaxKind.ReadOnlyKeyword)));
}
else
{
var setterType =
typeof(Action <,>).MakeGenericType(field.FieldInfo.DeclaringType, field.FieldInfo.FieldType)
.GetTypeSyntax();
var fieldSetterVariable =
SF.VariableDeclarator(field.SetterFieldName)
.WithInitializer(
SF.EqualsValueClause(
SF.CastExpression(
setterType,
getReferenceSetter.Invoke()
.AddArgumentListArguments(SF.Argument(fieldInfoField)))));
result.Add(
SF.FieldDeclaration(SF.VariableDeclaration(setterType).AddVariables(fieldSetterVariable))
.AddModifiers(
SF.Token(SyntaxKind.PrivateKeyword),
SF.Token(SyntaxKind.StaticKeyword),
SF.Token(SyntaxKind.ReadOnlyKeyword)));
}
}
}
return(result.ToArray());
}
public static byte[] CreateControllerCode(IService service)
{
var @file = SF.CompilationUnit();
var @namespace = SF.NamespaceDeclaration(SF.ParseName("MBase.ServiceHost.Controllers")).NormalizeWhitespace();
@file = @file
.AddUsings(SF.UsingDirective(SF.IdentifierName("System")));
@file = @file
.AddUsings(SF.UsingDirective(SF.IdentifierName("Microsoft.AspNetCore.Mvc")));
@file = @file
.AddUsings(SF.UsingDirective(SF.IdentifierName("System.Threading.Tasks")));
@file = @file.AddUsings(SF.UsingDirective(SF.IdentifierName(service.GetType().Namespace)));
@file = @file.AddUsings(SF.UsingDirective(SF.IdentifierName(service.GetType().Namespace + ".Models")));
foreach (var item in service.Commands.Where(m => typeof(ICommand).IsAssignableFrom(m.GetType())))
{
@file = @file.AddUsings(SF.UsingDirective(SF.IdentifierName(item.GetType().Namespace)));
}
var classDeclaration = SF.ClassDeclaration(service.GetType().Name.ToString() + "Controller")
.AddModifiers(SF.Token(SyntaxKind.PublicKeyword))
.AddBaseListTypes(SF.SimpleBaseType(SF.ParseTypeName("ControllerBase")))
.WithAttributeLists(
SF.List(
new AttributeListSyntax[] {
SF.AttributeList(
SF.SingletonSeparatedList(
SF.Attribute(SF.IdentifierName("Route"))
.WithArgumentList(
SF.AttributeArgumentList(
SF.SingletonSeparatedList(
SF.AttributeArgument(
SF.LiteralExpression(SyntaxKind.StringLiteralExpression, SF.Literal($"api/[controller]")))))))),
SF.AttributeList(
SF.SingletonSeparatedList(
SF.Attribute(SF.IdentifierName("ApiController"))))
}));
List <MemberDeclarationSyntax> controllerMembers = new List <MemberDeclarationSyntax>();
controllerMembers.Add(
SF.FieldDeclaration(
SF.VariableDeclaration(
SF.ParseTypeName(service.GetType().Name))
.AddVariables(SF.VariableDeclarator("_service")))
.AddModifiers(SF.Token(SyntaxKind.PrivateKeyword)));
controllerMembers.Add(
SF.ConstructorDeclaration(service.GetType().Name.ToString() + "Controller")
.WithParameterList(
SF.ParameterList(
SF.SingletonSeparatedList(
SF.Parameter(
SF.Identifier("service"))
.WithType(
SF.IdentifierName("IService")))
))
.AddModifiers(SF.Token(SyntaxKind.PublicKeyword))
.WithBody(SF.Block(SF.ParseStatement($"this._service = ({service.GetType().Name})service;"))));
foreach (var item in service.Commands.Where(m => typeof(ICommand).IsAssignableFrom(m.GetType())))
{
var syntax = @$ "
var response = await CommandHelper.ExecuteMethod<{item.Name}>(new {item.Name}(),new Request<{item.Name}>(request, new MessageEnvelope()));
private static string CreateClass_NamedColor(List <ColorEntity> entities, ProgressBar progress)
{
// Create a namespace: (namespace UnityEngine.Utils)
var @namespace = Syntax.NamespaceDeclaration(Syntax.ParseName("UnityEngine.Utils")).NormalizeWhitespace();
//// Add System using statement: (using System)
//@namespace = @namespace.AddUsings(Syntax.UsingDirective(Syntax.ParseName("System")));
// Create a class: (class Order)
var classDeclaration = Syntax.ClassDeclaration("NamedColor");
// Add the public modifier: (public class Order)
classDeclaration = classDeclaration.AddModifiers(
Syntax.Token(SyntaxKind.PublicKeyword),
Syntax.Token(SyntaxKind.PartialKeyword));
string code;
using (var child = progress.Spawn(entities.Count, "fields added", childOptions))
{
// Create a string variable: (bool canceled;)
var variableDeclarations = entities.Select((entity, index) =>
{
//double prog = (double)index / entities.Count / STEPS;
//progress.Report(PROGRESS_STEP * lastStep + prog);
child.Tick();
string varName = entity.Name.SanitizeEnum();
return(Syntax.VariableDeclaration(Syntax.ParseTypeName("NamedColor"))
// .AddVariables(Syntax.VariableDeclarator("canceled"))
.WithVariables(Syntax.SingletonSeparatedList(
Syntax.VariableDeclarator(
Syntax.Identifier(varName))
.WithInitializer(
Syntax.EqualsValueClause(
Syntax.ParseExpression($"new NamedColor(ColorNames.{varName}, " +
$"{entity.Hex.ToUpperInvariant().Replace("#", "0x")})")
)))));
});
// Create a field declaration: (private bool canceled;)
var fieldDeclarations = variableDeclarations.Select(variableDeclaration => Syntax.FieldDeclaration(variableDeclaration)
.AddModifiers(
Syntax.Token(SyntaxKind.PrivateKeyword),
Syntax.Token(SyntaxKind.StaticKeyword)));
// Add the field, the property and method to the class.
classDeclaration = classDeclaration.AddMembers(fieldDeclarations.ToArray());
// Add the class to the namespace.
@namespace = @namespace.AddMembers(classDeclaration);
// Normalize and get code as string.
code = @namespace
.NormalizeWhitespace()
.ToFullString();
}
// Output new code to the console.
return(code);
}
private static FieldDeclarationSyntax Field(string name, TypeSyntax type, params SyntaxKind[] modifiers)
{
return(S.FieldDeclaration(S.VariableDeclaration(type, S.SeparatedList(new[] { S.VariableDeclarator(name) })))
.AddModifiers(modifiers.Select(S.Token).ToArray()));
}
