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);