/*
* public static MemberAccessExpressionSyntax OptionalValue( ExpressionSyntax optionalOfTExpression )
* {
* return SF.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, optionalOfTExpression, SF.IdentifierName(nameof( Option<int>.)));
* }
*/
/*
* public static ExpressionSyntax OptionalFor( ExpressionSyntax expression )
* {
* return SF.InvocationExpression(
* SF.MemberAccessExpression(
* SyntaxKind.SimpleMemberAccessExpression,
* SF.QualifiedName(
* SF.IdentifierName(nameof(ImmutableObjectGraph)),
* SF.IdentifierName(nameof(ImmutableObjectGraph.Optional))),
* SF.IdentifierName(nameof(ImmutableObjectGraph.Optional.For))),
* SF.ArgumentList(SF.SingletonSeparatedList(SF.Argument(expression))));
* }
*/
/*
* public static ExpressionSyntax OptionalForIf( ExpressionSyntax expression, bool isOptional )
* {
* return isOptional ? OptionalFor(expression) : expression;
* }
*/
/*
* public static ImmutableArray<DeclarationInfo> GetDeclarationsInSpan( this SemanticModel model, TextSpan span, bool getSymbol, CancellationToken cancellationToken )
* {
* return CSharpDeclarationComputer.GetDeclarationsInSpan(model, span, getSymbol, cancellationToken);
* }
* //*/
//*
public static NameSyntax GetTypeSyntax(Type type)
{
Requires.NotNull(type, nameof(type));
SimpleNameSyntax leafType = SF.IdentifierName(type.IsGenericType ? type.Name.Substring(0, type.Name.IndexOf('`')) : type.Name);
if (type.IsGenericType)
{
leafType = SF.GenericName(
((IdentifierNameSyntax)leafType).Identifier,
SF.TypeArgumentList(JoinSyntaxNodes <TypeSyntax>(SyntaxKind.CommaToken, type.GenericTypeArguments.Select(GetTypeSyntax))));
}
if (type.Namespace != null)
{
NameSyntax namespaceName = null;
foreach (string segment in type.Namespace.Split('.'))
{
var segmentName = SF.IdentifierName(segment);
namespaceName = namespaceName == null
? (NameSyntax)segmentName
: SF.QualifiedName(namespaceName, SF.IdentifierName(segment));
}
return(SF.QualifiedName(namespaceName, leafType));
}
return(leafType);
}
//*/
//*
public static NameSyntax OptionalOf(TypeSyntax type)
{
return
(SF.GenericName(
SF.Identifier(nameof(Option)),
SF.TypeArgumentList(SF.SingletonSeparatedList(type))));
}
public override ExplicitInterfaceSpecifierSyntax ExplicitInterfaceSpecifier()
{
return(SF.ExplicitInterfaceSpecifier(
SF.GenericName(
Basics.SerializerInterfaceIdentifier,
SF.TypeArgumentList(new SeparatedSyntaxList <TypeSyntax>().Add(SF.ParseTypeName(ClassSymbol.ToString())))),
SF.Token(SyntaxKind.DotToken)));
}
public static NameSyntax IEquatableOf(TypeSyntax typeSyntax)
{
return(SF.QualifiedName(
SF.IdentifierName(nameof(System)),
SF.GenericName(
SF.Identifier(nameof(IEquatable <int>)),
SF.TypeArgumentList(SF.SingletonSeparatedList(typeSyntax)))));
}
public PropertyDeclarationSyntax GenerateListProperty(string propertyName, string typeName)
{
return(SF.PropertyDeclaration(
SF.GenericName(SF.Identifier("List"))
.WithTypeArgumentList(
SF.TypeArgumentList(
SF.SingletonSeparatedList <TypeSyntax>(
SF.IdentifierName(typeName)))),
SF.Identifier(propertyName)));
}
public static ExpressionSyntax CreateDictionary(TypeSyntax keyType, TypeSyntax valueType)
{
// System.Collections.Immutable.ImmutableDictionary.Create<TKey, TValue>()
return(SF.InvocationExpression(
SF.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
GetTypeSyntax(typeof(ImmutableDictionary)),
SF.GenericName(nameof(ImmutableDictionary.Create)).AddTypeArgumentListArguments(keyType, valueType)),
SF.ArgumentList()));
}
public PropertyDeclarationSyntax GenerateListProperty(string propertyName, PrimitiveType type)
{
return(SF.PropertyDeclaration(
SF.GenericName(SF.Identifier("List"))
.WithTypeArgumentList(
SF.TypeArgumentList(
SF.SingletonSeparatedList <TypeSyntax>(
SF.PredefinedType(SF.Token(FromPrimitive(type)))))),
SF.Identifier(propertyName)));
}
public static NameSyntax ImmutableStackOf(TypeSyntax typeSyntax)
{
return(SF.QualifiedName(
SF.QualifiedName(
SF.QualifiedName(
SF.IdentifierName(nameof(System)),
SF.IdentifierName(nameof(System.Collections))),
SF.IdentifierName(nameof(System.Collections.Immutable))),
SF.GenericName(
SF.Identifier(nameof(ImmutableStack <int>)),
SF.TypeArgumentList(SF.SingletonSeparatedList(typeSyntax)))));
}
public static NameSyntax KeyValuePairOf(TypeSyntax keyType, TypeSyntax valueType)
{
return(SF.QualifiedName(
SF.QualifiedName(
SF.QualifiedName(
SF.IdentifierName(nameof(System)),
SF.IdentifierName(nameof(System.Collections))),
SF.IdentifierName(nameof(System.Collections.Generic))),
SF.GenericName(
SF.Identifier(nameof(KeyValuePair <int, int>)),
SF.TypeArgumentList(JoinSyntaxNodes(SyntaxKind.CommaToken, keyType, valueType)))));
}
public static NameSyntax IReadOnlyListOf(TypeSyntax elementType)
{
return(SF.QualifiedName(
SF.QualifiedName(
SF.QualifiedName(
SF.IdentifierName(nameof(System)),
SF.IdentifierName(nameof(System.Collections))),
SF.IdentifierName(nameof(System.Collections.Generic))),
SF.GenericName(
SF.Identifier(nameof(IReadOnlyList <int>)),
SF.TypeArgumentList(SF.SingletonSeparatedList(elementType)))));
}
public static NameSyntax IEqualityComparerOf(TypeSyntax typeSyntax)
{
return(SF.QualifiedName(
SF.QualifiedName(
SF.QualifiedName(
SF.IdentifierName(nameof(System)),
SF.IdentifierName(nameof(System.Collections))),
SF.IdentifierName(nameof(System.Collections.Generic))),
SF.GenericName(
SF.Identifier(nameof(IEqualityComparer <int>)),
SF.TypeArgumentList(SF.SingletonSeparatedList(typeSyntax)))));
}
public static BaseListSyntax ImplementIEquatable(string equatableTypeName)
{
return(SF.BaseList(
SF.SingletonSeparatedList <BaseTypeSyntax>(
SF.SimpleBaseType(
SF.QualifiedName(
SF.IdentifierName("System"),
SF.GenericName(
SF.Identifier("IEquatable"))
.WithTypeArgumentList(
SF.TypeArgumentList(
SF.SingletonSeparatedList <TypeSyntax>(
SF.IdentifierName(equatableTypeName)))))))));
}
protected InvocationExpressionSyntax CreateInvocationExpression()
{
return(SF.InvocationExpression(
CreateInvokeMethodIdentifier(),
GetArgumentListSyntax()
));
SimpleNameSyntax CreateInvokeMethodIdentifier()
{
string invokeMethodName = GetInvokeMethodName();
if (Method.Returns == null)
{
return(SF.IdentifierName(invokeMethodName));
}
return(SF.GenericName(
SF.Identifier(invokeMethodName),
CreateTypeArgumentList()
));
TypeArgumentListSyntax CreateTypeArgumentList()
{
if (Method.Returns == null)
{
return(null);
}
return(SF.TypeArgumentList(
SF.Token(SyntaxKind.LessThanToken),
SF.SeparatedList(new[] { GetReturnType() }),
SF.Token(SyntaxKind.GreaterThanToken)
));
}
string GetInvokeMethodName()
{
StringBuilder builder = new StringBuilder("Invoke");
builder.Append(Method.IsStatic ? "Static" : "Instance");
if (Method.Returns == null)
{
builder.Append("Void");
}
builder.Append("Method");
return(builder.ToString());
}
}
}
public static ExpressionSyntax CreateImmutableStack(TypeSyntax elementType = null)
{
var typeSyntax = SF.QualifiedName(
SF.QualifiedName(
SF.QualifiedName(
SF.IdentifierName(nameof(System)),
SF.IdentifierName(nameof(System.Collections))),
SF.IdentifierName(nameof(System.Collections.Immutable))),
SF.IdentifierName(nameof(ImmutableStack)));
return(SF.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
typeSyntax,
elementType == null
? (SimpleNameSyntax)SF.IdentifierName(nameof(ImmutableStack.Create))
: SF.GenericName(nameof(ImmutableStack.Create)).AddTypeArgumentListArguments(elementType)));
}
private MemberDeclarationSyntax ExplicitInterfaceMember()
{
var parameters = F.SeparatedList(Symbol.Parameters.Select(p => TypesForSymbols.AsParameterSyntax(p)));
if (ArglistParameterName != null)
{
parameters = parameters.Add(F.Parameter(F.Token(SyntaxKind.ArgListKeyword)));
}
var arguments = Symbol.Parameters.AsArgumentList();
if (ArglistParameterName != null && TypesForSymbols.RuntimeArgumentHandle() != null)
{
arguments = arguments.Add(F.Argument(F.LiteralExpression(SyntaxKind.ArgListExpression, F.Token(SyntaxKind.ArgListKeyword))));
}
var mockedMethod = F.MethodDeclaration(ReturnType, Symbol.Name)
.WithParameterList(F.ParameterList(parameters))
.WithExplicitInterfaceSpecifier(F.ExplicitInterfaceSpecifier(TypesForSymbols.ParseName(InterfaceSymbol)));
if (Symbol.TypeParameters.Any())
{
mockedMethod = mockedMethod.WithTypeParameterList(TypeParameterList());
}
var invocation = Symbol.TypeParameters.Any()
? (ExpressionSyntax)F.GenericName(MemberMockName)
.WithTypeArgumentList(F.TypeArgumentList(
F.SeparatedList(Symbol.TypeParameters.Select(typeParameter =>
TypesForSymbols.ParseTypeName(typeParameter, false)))))
: F.IdentifierName(MemberMockName);
invocation = F.InvocationExpression(invocation, F.ArgumentList(arguments));
if (Symbol.ReturnsByRef || Symbol.ReturnsByRefReadonly)
{
invocation = F.RefExpression(invocation);
}
mockedMethod = mockedMethod
.WithExpressionBody(F.ArrowExpressionClause(invocation))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken));
return(mockedMethod);
}
public ExpressionSyntax GetRoslynExpression(RoslynExpressionContext context)
{
var manager = context.GetService(typeof(IGuildOptionsManager));
var optionsType = context.ExpectedType.GetGenericArguments()[0];
var typeSyntax = S.ParseTypeName(optionsType.FullName.Replace('+', '.'));
var getName = S.GenericName(nameof(SettingExtensions.GetOptionsAsync)).WithTypeArgumentList(S.TypeArgumentList().AddArguments(typeSyntax));
var get = S.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, manager, getName);
var guildId = S.BinaryExpression(
SyntaxKind.CoalesceExpression,
context.GetRequestProperty(nameof(MessageRequest.GuildId)),
S.ThrowExpression(S.ObjectCreationExpression(
S.IdentifierName("InvalidOperationException"),
S.ArgumentList().AddArguments(S.Argument(S.LiteralExpression(SyntaxKind.StringLiteralExpression, S.Literal(GuildIdNotDefined)))),
null
))
);
var invoke = S.InvocationExpression(get, S.ArgumentList().AddArguments(S.Argument(guildId)));
return(S.AwaitExpression(invoke));
}
protected InvocationExpressionSyntax CreateGetPropertyInvocationExpression()
{
return(SF.InvocationExpression(
CreateGetPropertyMethodIdentifier(),
GetArgumentListSyntax()
));
SimpleNameSyntax CreateGetPropertyMethodIdentifier()
{
return(SF.GenericName(
SF.Identifier(Property.IsStatic() ?
"GetStaticProperty" :
"GetInstanceProperty"
),
SF.TypeArgumentList(
SF.Token(SyntaxKind.LessThanToken),
SF.SeparatedList(new[] { GetReturnType() }),
SF.Token(SyntaxKind.GreaterThanToken)
)
));
}
ArgumentListSyntax GetArgumentListSyntax()
{
var arguments = GetArgumentExpressions().Select(e => SF.Argument(e));
return(SF.ArgumentList(SF.SeparatedList(arguments)));
IEnumerable <ExpressionSyntax> GetArgumentExpressions()
{
if (Property.IsStatic())
{
yield return(SF.TypeOfExpression(Symbols.GetNameSyntax(Type)));
}
}
}
}
public static TypeSyntax GetFullName(SyntaxNode typeNode)
{
var typeDeclaration = typeNode as TypeDeclarationSyntax;
if (typeDeclaration != null)
{
if (true == typeDeclaration.TypeParameterList?.Parameters.Any())
{
var arguments = typeDeclaration.TypeParameterList.Parameters.Select(p => GetFullName(p)).ToArray();
return(SF.GenericName(SF.Identifier(typeDeclaration.Identifier.Text), SF.TypeArgumentList(SF.SeparatedList(arguments))));
}
return(SF.IdentifierName(typeDeclaration.Identifier.Text));
}
var typeParameter = typeNode as TypeParameterSyntax;
if (typeParameter != null)
{
return(SF.IdentifierName(typeParameter.Identifier.Text));
}
return(typeNode as TypeSyntax);
}
public override TypeSyntax GetParseMethodOutParameter()
{
return(SF.GenericName(SF.ParseToken(ClassSymbol.Name), SF.TypeArgumentList(GetGenericParametersList())));
}
public SeparatedSyntaxList <BaseTypeSyntax> GetBaseList()
{
SeparatedSyntaxList <BaseTypeSyntax> list = new SeparatedSyntaxList <BaseTypeSyntax>();
return(list.Add(SF.SimpleBaseType(SF.GenericName(Basics.SerializerInterface).WithTypeArgumentList(GetInterfaceParameters()))));
}
public ExpressionBuilder Call(string method, IEnumerable <string> typeParameters, IEnumerable <ExpressionBuilder> expressions)
=> new ExpressionBuilder(SF.InvocationExpression(
SF.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, _expr,
SF.GenericName(method).WithTypeArgumentList(SF.TypeArgumentList(SF.SeparatedList(typeParameters.Select(tp => ParseType(tp)))))),
SF.ArgumentList(SF.SeparatedList(expressions.Select(e => SF.Argument(e.Build()))))));
protected override ExpressionSyntax ExplicitInterfaceMemberMemberMockInstance()
{
return(F.InvocationExpression(F.GenericName(MemberMockName).WithTypeArgumentList(TypeArgumentList())).WithArgumentList(F.ArgumentList()));
}
private void AddCtor(WebInfoGenerationData genData, List <WebInfoGenerationData> childrenGens)
{
var statements = new List <StatementSyntax>();
var infoInit = SF.ExpressionStatement(
SF.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
SF.IdentifierName(InfoClassName),
SF.ObjectCreationExpression(SF.ParseTypeName($"{InfoStaticClassName}.{InfoClassName}"))
.WithArgumentList(SF.ArgumentList())
)
);
statements.Add(infoInit);
var locatorInit = SF.ExpressionStatement(
SF.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
SF.IdentifierName(LocatorClassName),
SF.ObjectCreationExpression(SF.IdentifierName(nameof(WebLocatorInfo)))
.WithArgumentList(SF.ArgumentList())
)
);
statements.Add(locatorInit);
var locatorProps = new List <string>
{
nameof(WebLocatorInfo.LocatorType),
nameof(WebLocatorInfo.LocatorValue),
nameof(WebLocatorInfo.IsRelative)
};
foreach (var locatorProp in locatorProps)
{
var st = SF.ExpressionStatement(
SF.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
SF.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SF.IdentifierName(LocatorClassName),
SF.IdentifierName(locatorProp)
),
SF.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SF.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SF.IdentifierName(InfoStaticClassName),
SF.IdentifierName(LocatorStaticClassName)
),
SF.IdentifierName(locatorProp)
)
)
);
statements.Add(st);
}
if (childrenGens?.Count > 0)
{
var elsInit = SF.ExpressionStatement(
SF.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
SF.IdentifierName(nameof(CombinedWebElementInfo.Elements)),
SF.ObjectCreationExpression(
SF.GenericName(SF.Identifier("List"))
.WithTypeArgumentList(SF.TypeArgumentList(SF.SingletonSeparatedList <TypeSyntax>(SF.IdentifierName(nameof(WebElementInfo)))))
)
.WithArgumentList(SF.ArgumentList())
)
);
statements.Add(elsInit);
foreach (var childGen in childrenGens)
{
var propInit = SF.ExpressionStatement(
SF.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
SF.IdentifierName(childGen.PropertyName),
SF.ObjectCreationExpression(SF.IdentifierName(childGen.ClassName))
.WithArgumentList(SF.ArgumentList())
)
);
statements.Add(propInit);
var parentSt = SF.ExpressionStatement(
SF.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
SF.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SF.IdentifierName(childGen.PropertyName),
SF.IdentifierName(nameof(WebElementInfo.Parent))
),
SF.ThisExpression()
)
);
statements.Add(parentSt);
var elsAddSt = SF.ExpressionStatement(
SF.InvocationExpression(
SF.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SF.IdentifierName(nameof(CombinedWebElementInfo.Elements)),
SF.IdentifierName("Add")
)
).WithArgumentList(
SF.ArgumentList(
SF.SingletonSeparatedList(SF.Argument(SF.IdentifierName(childGen.PropertyName)))
)
)
);
statements.Add(elsAddSt);
}
}
var summary = GetDocCommentWithText(genData.Element.Description);
var ctor = SF.ConstructorDeclaration(SF.Identifier(genData.ClassName))
.WithBody(SF.Block(statements))
.WithModifiers(SF.TokenList(SF.Token(SyntaxKind.PublicKeyword).WithLeadingTrivia(SF.Trivia(summary))));
var cd = genData.ClassSyntax.AddMembers(ctor);
genData.ClassSyntax = cd;
}
/// <summary>
/// Generates the class for the provided grain types.
/// </summary>
/// <param name="type">The grain interface type.</param>
/// <param name="onEncounteredType">
/// The callback invoked when a type is encountered.
/// </param>
/// <returns>
/// The generated class.
/// </returns>
internal static IEnumerable <TypeDeclarationSyntax> GenerateClass(Type type, Action <Type> onEncounteredType)
{
var typeInfo = type.GetTypeInfo();
var genericTypes = typeInfo.IsGenericTypeDefinition
? typeInfo.GetGenericArguments().Select(_ => SF.TypeParameter(_.ToString())).ToArray()
: new TypeParameterSyntax[0];
var attributes = new List <AttributeSyntax>
{
CodeGeneratorCommon.GetGeneratedCodeAttributeSyntax(),
SF.Attribute(typeof(ExcludeFromCodeCoverageAttribute).GetNameSyntax()),
SF.Attribute(typeof(SerializerAttribute).GetNameSyntax())
.AddArgumentListArguments(
SF.AttributeArgument(SF.TypeOfExpression(type.GetTypeSyntax(includeGenericParameters: false))))
};
var className = CodeGeneratorCommon.ClassPrefix + type.GetParseableName(GeneratedTypeNameOptions);
var fields = GetFields(type);
// Mark each field type for generation
foreach (var field in fields)
{
var fieldType = field.FieldInfo.FieldType;
onEncounteredType(fieldType);
}
var members = new List <MemberDeclarationSyntax>(GenerateStaticFields(fields))
{
GenerateDeepCopierMethod(type, fields),
GenerateSerializerMethod(type, fields),
GenerateDeserializerMethod(type, fields),
};
if (typeInfo.IsConstructedGenericType || !typeInfo.IsGenericTypeDefinition)
{
members.Add(GenerateRegisterMethod(type));
members.Add(GenerateConstructor(className));
attributes.Add(SF.Attribute(typeof(RegisterSerializerAttribute).GetNameSyntax()));
}
var classDeclaration =
SF.ClassDeclaration(className)
.AddModifiers(SF.Token(SyntaxKind.InternalKeyword))
.AddAttributeLists(SF.AttributeList().AddAttributes(attributes.ToArray()))
.AddMembers(members.ToArray())
.AddConstraintClauses(type.GetTypeConstraintSyntax());
if (genericTypes.Length > 0)
{
classDeclaration = classDeclaration.AddTypeParameterListParameters(genericTypes);
}
var classes = new List <TypeDeclarationSyntax> {
classDeclaration
};
if (typeInfo.IsGenericTypeDefinition)
{
// Create a generic representation of the serializer type.
var serializerType =
SF.GenericName(classDeclaration.Identifier)
.WithTypeArgumentList(
SF.TypeArgumentList()
.AddArguments(
type.GetGenericArguments()
.Select(_ => SF.OmittedTypeArgument())
.Cast <TypeSyntax>()
.ToArray()));
var registererClassName = className + "_" +
string.Join("_",
type.GetTypeInfo().GenericTypeParameters.Select(_ => _.Name)) + "_" +
RegistererClassSuffix;
classes.Add(
SF.ClassDeclaration(registererClassName)
.AddModifiers(SF.Token(SyntaxKind.InternalKeyword))
.AddAttributeLists(
SF.AttributeList()
.AddAttributes(
CodeGeneratorCommon.GetGeneratedCodeAttributeSyntax(),
SF.Attribute(typeof(ExcludeFromCodeCoverageAttribute).GetNameSyntax()),
SF.Attribute(typeof(RegisterSerializerAttribute).GetNameSyntax())))
.AddMembers(
GenerateMasterRegisterMethod(type, serializerType),
GenerateConstructor(registererClassName)));
}
return(classes);
}
public static NameSyntax FuncOf(params TypeSyntax[] typeArguments)
{
return(SF.QualifiedName(
SF.IdentifierName(nameof(System)),
SF.GenericName(nameof(Func <int>)).AddTypeArgumentListArguments(typeArguments)));
}
