public static SyntaxNode ArrayCreationExpression(this SyntaxGenerator generator, SyntaxNode type, IEnumerable <SyntaxNode> sizeExpression) { if (generator.NullLiteralExpression() is CS.ExpressionSyntax) { CS.TypeSyntax typeSyntax = type as CS.TypeSyntax; if (typeSyntax == null) { throw new ArgumentException($"Invalid syntax node type; Expected {typeof(CS.TypeSyntax).FullName}.", "type"); } IEnumerable <CS.ExpressionSyntax> csSizeExpressions = sizeExpression.Select(exp => exp as CS.ExpressionSyntax); if (csSizeExpressions.Any(exp => exp == null)) { throw new ArgumentException($"Invalid syntax node type; Expected {typeof(CS.ExpressionSyntax).FullName}.", "sizeExpression"); } return(CSSF.ArrayCreationExpression( CSSF.ArrayType( typeSyntax, CSSF.SingletonList( CSSF.ArrayRankSpecifier( CSSF.SeparatedList(csSizeExpressions) ) ) ) )); } else { throw new ArgumentException("Not a CSharp ExpressionSyntax"); } }
public static ParameterListSyntax GetParameterListSyntax(this Method method, INamespaceSet namespaces, ISymbolMap symbols) { method = method ?? throw new ArgumentNullException(nameof(method)); namespaces = namespaces ?? throw new ArgumentNullException(nameof(namespaces)); symbols = symbols ?? throw new ArgumentNullException(nameof(symbols)); return(SF.ParameterList(SF.SeparatedList(GetParameters()))); IEnumerable <ParameterSyntax> GetParameters() { if (method.Parameters == null) { yield break; } foreach (Parameter parameter in method.Parameters) { namespaces.Add(parameter.Type); yield return(SF.Parameter( SF.List <AttributeListSyntax>(), SF.TokenList(), symbols.GetTypeSyntax(parameter.Type), symbols.GetNameSyntaxToken(parameter), null )); } } }
public BracketedParameterListSyntax?BuildParameterList() { if (Count == 0) { return(null); } return(F.BracketedParameterList(F.SeparatedList(this.Select(a => F.Parameter(F.Identifier(a.TupleSafeName)).WithType(a.Type))))); }
public ExpressionSyntax?BuildArgumentListWithOriginalNames() { if (Count == 0) { return(null); } return(IsMultiDimensional ? (ExpressionSyntax)F.TupleExpression(F.SeparatedList(this.Select(a => F.Argument(F.IdentifierName(a.OriginalName))).ToArray())) : F.IdentifierName(this[0].OriginalName)); }
public TypeSyntax?BuildTypeSyntax() { if (Count == 0) { return(null); } return(IsMultiDimensional ? F.TupleType(F.SeparatedList(this.Select(a => F.TupleElement(a.Type, F.Identifier(a.TupleSafeName))))) : this[0].Type); }
/// <inheritdoc /> public override ClassDeclarationSyntax Apply(ClassDeclarationSyntax node, INamedTypeSymbol symbol, CancellationToken cancellationToken) { var parameters = ImmutableArray.CreateBuilder <ParameterSyntax>(); var arguments = ImmutableArray.CreateBuilder <ArgumentSyntax>(); var ctorStmts = ImmutableArray.CreateBuilder <StatementSyntax>(); // Generate all parameters and statements var members = symbol.GetMembers(); for (int i = 0; i < members.Length; i++) { IPropertySymbol member = members[i] as IPropertySymbol; if (member == null || !member.IsReadOnly || !member.CanBeReferencedByName) { continue; } // Read-only prop, we good string propName = member.Name; string paramName = $"{char.ToLower(propName[0]).ToString()}{propName.Substring(1)}"; TypeSyntax paramType = ((PropertyDeclarationSyntax)member.DeclaringSyntaxReferences[0] .GetSyntax(cancellationToken)).Type; MemberAccessExpressionSyntax propAccess = F.MemberAccessExpression( K.SimpleMemberAccessExpression, F.ThisExpression(), F.IdentifierName(propName) ); // Make parameter & argument parameters.Add(F.Parameter(F.Identifier(paramName)).WithType(paramType)); arguments.Add(F.Argument(propAccess)); // Make ctor stmt ctorStmts.Add(F.ExpressionStatement( F.AssignmentExpression(K.SimpleAssignmentExpression, propAccess, F.IdentifierName(paramName) ) )); } // The ctor is full, make all the 'with' methods TypeSyntax returnType = F.IdentifierName(symbol.Name); MemberDeclarationSyntax[] additionalMethods = new MemberDeclarationSyntax[parameters.Count + 1]; arguments.Capacity = arguments.Count; ImmutableArray <ArgumentSyntax> args = arguments.MoveToImmutable(); for (int i = 0; i < parameters.Count; i++) { ParameterSyntax parameter = parameters[i]; string parameterName = parameter.Identifier.Text; ArgumentSyntax name = F.Argument(F.IdentifierName(parameterName)); SeparatedSyntaxList <ArgumentSyntax> allArguments = F.SeparatedList(args.Replace(args[i], name)); StatementSyntax returnStmt = F.ReturnStatement( F.ObjectCreationExpression(returnType).WithArgumentList(F.ArgumentList(allArguments)) ); additionalMethods[i] = F.MethodDeclaration(returnType, $"With{char.ToUpper(parameterName[0]).ToString()}{parameterName.Substring(1)}") .AddModifiers(F.Token(K.PublicKeyword), F.Token(K.NewKeyword)) .AddParameterListParameters(parameter) .AddBodyStatements(returnStmt); } // Add the private ctor additionalMethods[parameters.Count] = F.ConstructorDeclaration(symbol.Name) .AddModifiers(F.Token(K.PrivateKeyword)) .AddParameterListParameters(parameters.ToArray()) .AddBodyStatements(ctorStmts.ToArray()); return(node.AddMembers(additionalMethods)); }
public LambdaExpressionSyntax Build() => _parameters.Count != 1 ? (LambdaExpressionSyntax)SF.ParenthesizedLambdaExpression(SF.ParameterList(SF.SeparatedList(_parameters.Select(p => p.Build()).ToArray())), _block.HasValue ? _block.Value.Build() : null, _expr.HasValue ? _expr.Value.Build() : null) : SF.SimpleLambdaExpression(_parameters[0].Build(), _block.HasValue ? _block.Value.Build() : null, _expr.HasValue ? _expr.Value.Build() : null);