/// <summary>
/// Gets the syntax for the creation of an anonymous type.
/// </summary>
/// <param name="tableElement">The description of a table.</param>
/// <returns>An expression that builds an anonymous type from a table description.</returns>
public static ExpressionSyntax GetSyntax(TableElement tableElement)
{
// Validate the parameter
if (tableElement == null)
{
throw new ArgumentNullException(nameof(tableElement));
}
// new { country.CountryId, country.CountryCode, country.Name, country.RowVersion };
List <SyntaxNodeOrToken> properties = new List <SyntaxNodeOrToken>();
foreach (ColumnElement columnElement in tableElement.Columns)
{
if (properties.Count != 0)
{
properties.Add(SyntaxFactory.Token(SyntaxKind.CommaToken));
}
properties.Add(
SyntaxFactory.AnonymousObjectMemberDeclarator(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName(tableElement.Name.ToVariableName()),
SyntaxFactory.IdentifierName(columnElement.Name))));
}
return(SyntaxFactory.AnonymousObjectCreationExpression(
SyntaxFactory.SeparatedList <AnonymousObjectMemberDeclaratorSyntax>(properties)));
}
public static AnonymousObjectCreationExpressionSyntax Anonymous(params Tuple <string, ExpressionSyntax>[] initializers)
{
return(SyntaxFactory.AnonymousObjectCreationExpression(SyntaxFactory.SeparatedList(
initializers.Select(x =>
SyntaxFactory.AnonymousObjectMemberDeclarator(SyntaxFactory.NameEquals(x.Item1), x.Item2)
),
initializers.Skip(1).Select(_ => SyntaxFactory.Token(SyntaxKind.CommaToken)))));
}
public CSharpSyntaxNode Convert(ObjectLiteralExpression node)
{
List <Node> properties = node.Properties;
Node type = node.Type;
if (type.Kind == NodeKind.TypeLiteral && properties.Count >= 2 && (type as TypeLiteral).Members[0].Kind != NodeKind.IndexSignature)
{
return(SyntaxFactory.TupleExpression().AddArguments(properties.ToCsNodes <ArgumentSyntax>()));
}
else if (type.Kind == NodeKind.AnyKeyword)
{
AnonymousObjectCreationExpressionSyntax csAnonyNewExpr = SyntaxFactory.AnonymousObjectCreationExpression();
foreach (PropertyAssignment prop in node.Properties)
{
string propName = prop.Name.Text;
Node initValue = prop.Initializer;
ExpressionSyntax valueExpr = initValue.ToCsNode <ExpressionSyntax>();
if (type.Kind == NodeKind.TypeLiteral && initValue.Kind == NodeKind.NullKeyword)
{
Node memType = TypeHelper.GetTypeLiteralMemberType(type as TypeLiteral, propName);
if (memType != null)
{
valueExpr = SyntaxFactory.CastExpression(memType.ToCsNode <TypeSyntax>(), valueExpr);
}
}
csAnonyNewExpr = csAnonyNewExpr.AddInitializers(SyntaxFactory.AnonymousObjectMemberDeclarator(
SyntaxFactory.NameEquals(propName),
valueExpr));
}
return(csAnonyNewExpr);
}
else
{
ObjectCreationExpressionSyntax csObjLiteral = SyntaxFactory.ObjectCreationExpression(type.ToCsNode <TypeSyntax>()).AddArgumentListArguments();
List <ExpressionSyntax> initItemExprs = new List <ExpressionSyntax>();
foreach (PropertyAssignment prop in properties)
{
ExpressionSyntax csNameExpression = SyntaxFactory.LiteralExpression(
SyntaxKind.StringLiteralExpression,
SyntaxFactory.Literal(prop.Name.Text));
InitializerExpressionSyntax itemInitExpr = SyntaxFactory
.InitializerExpression(SyntaxKind.ComplexElementInitializerExpression)
.AddExpressions(csNameExpression, prop.Initializer.ToCsNode <ExpressionSyntax>());
initItemExprs.Add(itemInitExpr);
}
if (initItemExprs.Count > 0)
{
return(csObjLiteral.WithInitializer(SyntaxFactory.InitializerExpression(
SyntaxKind.CollectionInitializerExpression,
SyntaxFactory.SeparatedList(initItemExprs))));
}
return(csObjLiteral);
}
}
public override SyntaxNode MakeSyntaxNode()
{
var res =
SyntaxFactory.AnonymousObjectCreationExpression(NewKeyword, OpenBraceToken, Initializers,
CloseBraceToken);
IsChanged = false;
return(res);
}
private StatementSyntax CreateDefaultReplacementStatement(
ForEachInfo <ForEachStatementSyntax, StatementSyntax> forEachInfo,
IEnumerable <SyntaxToken> identifiers,
BlockSyntax block,
bool convertToQuery)
{
var identifiersCount = identifiers.Count();
if (identifiersCount == 0)
{
// Generate foreach(var _ ... select new {})
return(SyntaxFactory.ForEachStatement(
VarNameIdentifier,
SyntaxFactory.Identifier("_"),
CreateQueryExpressionOrLinqInvocation(
SyntaxFactory.AnonymousObjectCreationExpression(),
Enumerable.Empty <SyntaxToken>(),
Enumerable.Empty <SyntaxToken>(),
convertToQuery),
block));
}
else if (identifiersCount == 1)
{
// Generate foreach(var singleIdentifier from ... select singleIdentifier)
return(SyntaxFactory.ForEachStatement(
VarNameIdentifier,
identifiers.Single(),
CreateQueryExpressionOrLinqInvocation(
SyntaxFactory.IdentifierName(identifiers.Single()),
Enumerable.Empty <SyntaxToken>(),
Enumerable.Empty <SyntaxToken>(),
convertToQuery),
block));
}
else
{
var tupleForSelectExpression = SyntaxFactory.TupleExpression(
SyntaxFactory.SeparatedList(identifiers.Select(
identifier => SyntaxFactory.Argument(SyntaxFactory.IdentifierName(identifier)))));
var declaration = SyntaxFactory.DeclarationExpression(
VarNameIdentifier,
SyntaxFactory.ParenthesizedVariableDesignation(
SyntaxFactory.SeparatedList <VariableDesignationSyntax>(identifiers.Select(
identifier => SyntaxFactory.SingleVariableDesignation(identifier)))));
// Generate foreach(var (a,b) ... select (a, b))
return(SyntaxFactory.ForEachVariableStatement(
declaration,
CreateQueryExpressionOrLinqInvocation(
tupleForSelectExpression,
Enumerable.Empty <SyntaxToken>(),
Enumerable.Empty <SyntaxToken>(),
convertToQuery),
block));
}
}
/// <summary>
/// Creates an argument that creates a lambda expression for extracting the key from a class.
/// </summary>
/// <param name="foreignKeyElement">The unique key element.</param>
/// <returns>An argument that extracts a key from an object.</returns>
public static ExpressionSyntax GetForeignKey(ForeignKeyElement foreignKeyElement)
{
// Validate the parameter
if (foreignKeyElement == null)
{
throw new ArgumentNullException(nameof(foreignKeyElement));
}
// Used as a variable when constructing the lambda expression.
string abbreviation = foreignKeyElement.Table.Name[0].ToString(CultureInfo.InvariantCulture).ToLowerInvariant();
// This will create an expression for extracting the key from record.
CSharpSyntaxNode syntaxNode = null;
if (foreignKeyElement.Columns.Count == 1)
{
// A simple key can be used like a value type.
syntaxNode = SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName(abbreviation),
SyntaxFactory.IdentifierName(foreignKeyElement.Columns[0].Column.Name));
}
else
{
// A Compound key must be constructed from an anomymous type.
List <SyntaxNodeOrToken> keyElements = new List <SyntaxNodeOrToken>();
foreach (ColumnReferenceElement columnReferenceElement in foreignKeyElement.Columns)
{
if (keyElements.Count != 0)
{
keyElements.Add(SyntaxFactory.Token(SyntaxKind.CommaToken));
}
keyElements.Add(
SyntaxFactory.AnonymousObjectMemberDeclarator(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName(abbreviation),
SyntaxFactory.IdentifierName(columnReferenceElement.Column.Name))));
}
// b => b.BuyerId or b => new { b.BuyerId, b.ExternalId0 }
syntaxNode = SyntaxFactory.AnonymousObjectCreationExpression(
SyntaxFactory.SeparatedList <AnonymousObjectMemberDeclaratorSyntax>(keyElements.ToArray()));
}
// this.BuyerKey = new SimpleForeignKeyIndex<Buyer>("BuyerKey").HasIndex(b => b.BuyerId);
return(SyntaxFactory.SimpleLambdaExpression(SyntaxFactory.Parameter(SyntaxFactory.Identifier(abbreviation)), syntaxNode));
}
public string BuildExpression(Dictionary <string, ExpressionSyntax> selectExpressions)
{
var memberDeclarators = new SeparatedSyntaxList <AnonymousObjectMemberDeclaratorSyntax>();
foreach (var curExpr in selectExpressions.OrderBy(x => x.Key))
{
var name = SyntaxFactory.NameEquals(curExpr.Key);
var assignmentExpression = SyntaxFactory.AnonymousObjectMemberDeclarator(name, curExpr.Value);
memberDeclarators = memberDeclarators.Add(assignmentExpression);
}
var anonymousObjectCreationExpression = SyntaxFactory.AnonymousObjectCreationExpression(memberDeclarators);
if (InvocationExpression != null)
{
ExpressionSyntax expression = null;
if (InvocationExpression.Expression is MemberAccessExpressionSyntax mae)
{
expression = mae;
}
else if (InvocationExpression.Expression is IdentifierNameSyntax identifier)
{
expression = identifier;
}
var invocExp = SyntaxFactory.InvocationExpression(expression)
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Argument(
SyntaxFactory.SimpleLambdaExpression(
SyntaxFactory.Parameter(SyntaxFactory.Identifier("doc")),
anonymousObjectCreationExpression)))));
return(invocExp.ToString().Normalize());
}
if (FromExpression != null)
{
var queryExpr = SyntaxFactory.QueryExpression(
SyntaxFactory.FromClause("doc", FromExpression),
SyntaxFactory.QueryBody(SyntaxFactory.SelectClause(anonymousObjectCreationExpression)));
return(queryExpr.ToString().Normalize());
}
return(null);
}
private static async Task <Document> AddProjectionAsync(Document document, Diagnostic diagnostic, CancellationToken cancellationToken)
{
var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
var diagnosticSpan = diagnostic.Location.SourceSpan;
// Find the type declaration identified by the diagnostic.
var declarator = (VariableDeclaratorSyntax)root.FindToken(diagnosticSpan.Start).Parent;
var invocation = (InvocationExpressionSyntax)declarator.Initializer.Value;
var memberAccess = (MemberAccessExpressionSyntax)invocation.Expression;
var firstArgument = invocation.ArgumentList.Arguments.FirstOrDefault();
if (firstArgument != null)
{
// Move condition from .First() to extra .Where() call so that we can place the .Select() between them
var whereExpression = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, memberAccess.Expression, SyntaxFactory.IdentifierName("Where"));
var withWhere = SyntaxFactory.InvocationExpression(whereExpression, invocation.ArgumentList);
var whereMemberAccess = memberAccess.WithExpression(withWhere);
var newInvocation = SyntaxFactory.InvocationExpression(SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, whereMemberAccess.Expression, memberAccess.Name));
root = root.ReplaceNode(invocation, newInvocation);
declarator = (VariableDeclaratorSyntax)root.FindToken(diagnosticSpan.Start).Parent;
invocation = (InvocationExpressionSyntax)declarator.Initializer.Value;
memberAccess = (MemberAccessExpressionSyntax)invocation.Expression;
}
var selectExpression = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, memberAccess.Expression, SyntaxFactory.IdentifierName("Select"));
var itExpr = SyntaxFactory.IdentifierName("it");
var it = SyntaxFactory.Identifier("it");
var members = diagnostic.Properties["Members"].Split('\n').Select(m => SyntaxFactory.AnonymousObjectMemberDeclarator(SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, itExpr, SyntaxFactory.IdentifierName(m))));
var newExpr = SyntaxFactory.AnonymousObjectCreationExpression(SyntaxFactory.SeparatedList(members));
var argument = SyntaxFactory.Argument(SyntaxFactory.SimpleLambdaExpression(SyntaxFactory.Parameter(it), newExpr));
var arguments = SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(argument));
var projectedInvocationExpression = SyntaxFactory.InvocationExpression(selectExpression, arguments);
var newMemberAccess = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, projectedInvocationExpression, memberAccess.Name);
var newRoot = root.ReplaceNode(memberAccess, newMemberAccess);
return(document.WithSyntaxRoot(newRoot));
}
public virtual LocalDeclarationStatementSyntax GetSyntax()
{
if (BodyParams.FirstOrDefault()?.ReplaceBody == true)
{
// this is a replace body
return(SyntaxFactory.LocalDeclarationStatement(
SyntaxFactory.VariableDeclaration(
SyntaxFactory.IdentifierName("var"))
.WithVariables(
SyntaxFactory.SingletonSeparatedList <VariableDeclaratorSyntax>(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier(Name))
.WithInitializer(
SyntaxFactory.EqualsValueClause(
SyntaxFactory.IdentifierName(BodyParams.FirstOrDefault()?.Key)))))));
}
ExpressionSyntax objectCreation;
if (BodyType == "Annonymous")
{
var anonPropList = new List <SyntaxNodeOrToken>();
BodyParams.Select(b =>
{
return(b.CallContext != null ?
SyntaxFactory.AnonymousObjectMemberDeclarator(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName(b.CallContext),
SyntaxFactory.IdentifierName(b.Key)))
.WithNameEquals(
SyntaxFactory.NameEquals(
SyntaxFactory.IdentifierName(b.FieldName)))
:
SyntaxFactory.AnonymousObjectMemberDeclarator(
SyntaxFactory.IdentifierName(b.Key))
.WithNameEquals(
SyntaxFactory.NameEquals(
SyntaxFactory.IdentifierName(b.Key))));
})
.ToList()
.ForEach(b =>
{
anonPropList.Add(b);
anonPropList.Add(SyntaxFactory.Token(SyntaxKind.CommaToken));
});
objectCreation = SyntaxFactory.AnonymousObjectCreationExpression(
SyntaxFactory.SeparatedList <AnonymousObjectMemberDeclaratorSyntax>(
anonPropList.ToArray()
));
}
else
{
var propList = new List <SyntaxNodeOrToken>();
BodyParams.Select(b =>
{
return(b.CallContext != null ?
SyntaxFactory.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
SyntaxFactory.IdentifierName(b.Key),
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName(b.CallContext),
SyntaxFactory.IdentifierName(b.Key)
))
:
SyntaxFactory.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
SyntaxFactory.IdentifierName(b.Key),
SyntaxFactory.IdentifierName(b.Key)));
})
.ToList()
.ForEach(b =>
{
propList.Add(b);
propList.Add(SyntaxFactory.Token(SyntaxKind.CommaToken));
});
objectCreation = SyntaxFactory.ObjectCreationExpression(
SyntaxFactory.IdentifierName(BodyType))
.WithInitializer(
SyntaxFactory.InitializerExpression(
SyntaxKind.ObjectInitializerExpression,
SyntaxFactory.SeparatedList <ExpressionSyntax>(
propList.ToArray()
)));
}
return(SyntaxFactory.LocalDeclarationStatement(
SyntaxFactory.VariableDeclaration(
SyntaxFactory.IdentifierName("var"))
.WithVariables(
SyntaxFactory.SingletonSeparatedList <VariableDeclaratorSyntax>(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier(Name))
.WithInitializer(
SyntaxFactory.EqualsValueClause(
objectCreation
))))));
}
/// <summary>
/// Creates an argument that creates a lambda expression for extracting the key from a class.
/// </summary>
/// <param name="uniqueKeyElement">The unique key element.</param>
/// <param name="isAnonymous">Indicates we should create an anonymous key for Entity Framework.</param>
/// <returns>An argument that extracts a key from an object.</returns>
public static ExpressionSyntax GetUniqueKey(UniqueElement uniqueKeyElement, bool isAnonymous = false)
{
// Used as a variable when constructing the lambda expression.
string abbreviation = uniqueKeyElement.Table.Name[0].ToString(CultureInfo.InvariantCulture).ToLowerInvariant();
// This will create an expression for extracting the key from record.
CSharpSyntaxNode syntaxNode = null;
if (uniqueKeyElement.Columns.Count == 1)
{
// A simple key can be used like a value type.
syntaxNode = SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName(abbreviation),
SyntaxFactory.IdentifierName(uniqueKeyElement.Columns[0].Column.Name));
}
else
{
// A Compound key must be constructed from an anomymous type.
List <SyntaxNodeOrToken> keyElements = new List <SyntaxNodeOrToken>();
foreach (ColumnReferenceElement columnReferenceElement in uniqueKeyElement.Columns)
{
if (keyElements.Count != 0)
{
keyElements.Add(SyntaxFactory.Token(SyntaxKind.CommaToken));
}
if (isAnonymous)
{
keyElements.Add(
SyntaxFactory.AnonymousObjectMemberDeclarator(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName(abbreviation),
SyntaxFactory.IdentifierName(columnReferenceElement.Column.Name))));
}
else
{
keyElements.Add(
SyntaxFactory.Argument(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName(abbreviation),
SyntaxFactory.IdentifierName(columnReferenceElement.Column.Name))));
}
}
if (isAnonymous)
{
// b => b.BuyerId or b => new { b.BuyerId, b.ExternalId0 }
syntaxNode = SyntaxFactory.AnonymousObjectCreationExpression(
SyntaxFactory.SeparatedList <AnonymousObjectMemberDeclaratorSyntax>(keyElements.ToArray()));
}
else
{
// b => b.BuyerId or p => ValueTuple.Create(p.Name, p.CountryCode)
syntaxNode = SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("ValueTuple"),
SyntaxFactory.IdentifierName("Create")))
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList <ArgumentSyntax>(keyElements.ToArray())));
}
}
// this.BuyerKey = new UniqueIndex("BuyerKey").HasIndex(b => b.BuyerId);
return(SyntaxFactory.SimpleLambdaExpression(SyntaxFactory.Parameter(SyntaxFactory.Identifier(abbreviation)), syntaxNode));
}
