/* * 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))); }