Here are the examples of the csharp api Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExpressionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.
56 Examples
19
Source : MethodInstrumentation.cs
with MIT License
from ComparetheMarket
with MIT License
from ComparetheMarket
private static void InstrumentExpressionBodiedMethod(
BaseMethodDeclarationSyntax methodNode,
SyntaxEditor syntaxEditor,
StatementSyntax instrumentationNode)
{
BlockSyntax newMethodBodyBlock;
if (methodNode.ReturnsSomething())
{
newMethodBodyBlock = SyntaxFactory.Block(
instrumentationNode,
SyntaxFactory.ReturnStatement(methodNode.ExpressionBody.Expression));
}
else
{
newMethodBodyBlock = SyntaxFactory.Block(
instrumentationNode,
SyntaxFactory.ExpressionStatement(methodNode.ExpressionBody.Expression));
}
var newMethodNode = methodNode
.WithNoExpressionBody()
.WithBody(newMethodBodyBlock);
syntaxEditor.ReplaceNode(methodNode, newMethodNode);
}
19
Source : PropertyInstrumentation.cs
with MIT License
from ComparetheMarket
with MIT License
from ComparetheMarket
private static void InstrumentExpressionBodiedPropertyAccessor(
AccessorDeclarationSyntax propertyAccessorNode,
SyntaxEditor syntaxEditor,
StatementSyntax instrumentationNode)
{
BlockSyntax newAccessorBodyBlock;
if (propertyAccessorNode.Kind() == SyntaxKind.GetAccessorDeclaration)
{
newAccessorBodyBlock = SyntaxFactory.Block(
instrumentationNode,
SyntaxFactory.ReturnStatement(propertyAccessorNode.ExpressionBody.Expression));
}
else
{
newAccessorBodyBlock = SyntaxFactory.Block(
instrumentationNode,
SyntaxFactory.ExpressionStatement(propertyAccessorNode.ExpressionBody.Expression));
}
var newAccessorNode = propertyAccessorNode.Update(
attributeLists: propertyAccessorNode.AttributeLists,
modifiers: propertyAccessorNode.Modifiers,
keyword: propertyAccessorNode.Keyword,
body: newAccessorBodyBlock,
expressionBody: null,
semicolonToken: new SyntaxToken());
syntaxEditor.ReplaceNode(propertyAccessorNode, newAccessorNode);
}
19
Source : ToCSharpRewriteTreeVisitor.cs
with MIT License
from Puchaczov
with MIT License
from Puchaczov
public void Visit(JoinInMemoryWithSourceTableFromNode node)
{
var ifStatement = Generator.IfStatement(Generator.LogicalNotExpression(Nodes.Pop()),
new SyntaxNode[] {SyntaxFactory.ContinueStatement()})
.WithTrailingTrivia(SyntaxFactory.CarriageReturnLineFeed);
_emptyBlock = SyntaxFactory.Block();
var computingBlock = SyntaxFactory.Block();
switch (node.JoinType)
{
case JoinType.Inner:
computingBlock = computingBlock.AddStatements(
SyntaxFactory.ForEachStatement(
SyntaxFactory.IdentifierName("var"),
SyntaxFactory.Identifier($"{node.InMemoryTableAlias}Row"),
SyntaxFactory.IdentifierName(
$"{nameof(EvaluationHelper)}.{nameof(EvaluationHelper.ConvertTableToSource)}({node.InMemoryTableAlias}TransitionTable).{nameof(RowSource.Rows)}"),
SyntaxFactory.Block(
SyntaxFactory.SingletonList<StatementSyntax>(
SyntaxFactory.ForEachStatement(
SyntaxFactory.IdentifierName("var"),
SyntaxFactory.Identifier($"{node.SourceTable.Alias}Row"),
SyntaxFactory.IdentifierName($"{node.SourceTable.Alias}Rows.Rows"),
SyntaxFactory.Block(
GenerateCancellationExpression(),
(StatementSyntax)ifStatement,
_emptyBlock))))));
break;
case JoinType.OuterLeft:
var fullTransitionTable = _scope.ScopeSymbolTable.GetSymbol<TableSymbol>(_queryAlias);
var fieldNames = _scope.ScopeSymbolTable.GetSymbol<FieldsNamesSymbol>(MetaAttributes.OuterJoinSelect);
var expressions = new List<ExpressionSyntax>();
int j = 0;
for (int i = 0; i < fullTransitionTable.CompoundTables.Length - 1; i++)
{
foreach(var column in fullTransitionTable.GetColumns(fullTransitionTable.CompoundTables[i]))
{
expressions.Add(
SyntaxFactory.ElementAccessExpression(
SyntaxFactory.IdentifierName($"{node.InMemoryTableAlias}Row"),
SyntaxFactory.BracketedArgumentList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Argument(
(LiteralExpressionSyntax)Generator.LiteralExpression(fieldNames.Names[j]))))));
j += 1;
}
}
foreach (var column in fullTransitionTable.GetColumns(fullTransitionTable.CompoundTables[fullTransitionTable.CompoundTables.Length - 1]))
{
expressions.Add(
SyntaxFactory.CastExpression(
SyntaxFactory.IdentifierName(
EvaluationHelper.GetCastableType(column.ColumnType)),
(LiteralExpressionSyntax)Generator.NullLiteralExpression()));
}
var arrayType = SyntaxFactory.ArrayType(
SyntaxFactory.IdentifierName("object"),
new SyntaxList<ArrayRankSpecifierSyntax>(
SyntaxFactory.ArrayRankSpecifier(
SyntaxFactory.SingletonSeparatedList(
(ExpressionSyntax)SyntaxFactory.OmittedArraySizeExpression()))));
var rewriteSelect =
SyntaxFactory.VariableDeclaration(
SyntaxFactory.IdentifierName("var"),
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier("select"),
null,
SyntaxFactory.EqualsValueClause(
SyntaxFactory.ArrayCreationExpression(
arrayType,
SyntaxFactory.InitializerExpression(
SyntaxKind.ArrayInitializerExpression,
SyntaxFactory.SeparatedList(expressions)))))));
var invocation = SyntaxHelper.CreateMethodInvocation(
_scope[MetaAttributes.SelectIntoVariableName],
nameof(Table.Add),
new[]
{
SyntaxFactory.Argument(
SyntaxFactory.ObjectCreationExpression(
SyntaxFactory.Token(SyntaxKind.NewKeyword).WithTrailingTrivia(SyntaxHelper.WhiteSpace),
SyntaxFactory.ParseTypeName(nameof(ObjectsRow)),
SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList(
new[]
{
SyntaxFactory.Argument(SyntaxFactory.IdentifierName("select")),
SyntaxFactory.Argument(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName($"{node.InMemoryTableAlias}Row"),
SyntaxFactory.IdentifierName($"{nameof(IObjectResolver.Contexts)}"))),
SyntaxFactory.Argument(
SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression))
})
),
SyntaxFactory.InitializerExpression(SyntaxKind.ComplexElementInitializerExpression))
)});
computingBlock = computingBlock.AddStatements(
SyntaxFactory.ForEachStatement(
SyntaxFactory.IdentifierName("var"),
SyntaxFactory.Identifier($"{node.InMemoryTableAlias}Row"),
SyntaxFactory.IdentifierName(
$"{nameof(EvaluationHelper)}.{nameof(EvaluationHelper.ConvertTableToSource)}({node.InMemoryTableAlias}TransitionTable).{nameof(RowSource.Rows)}"),
SyntaxFactory.Block(
SyntaxFactory.LocalDeclarationStatement(
SyntaxHelper.Createreplacedignment("hasAnyRowMatched", SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression))),
SyntaxFactory.ForEachStatement(
SyntaxFactory.IdentifierName("var"),
SyntaxFactory.Identifier($"{node.SourceTable.Alias}Row"),
SyntaxFactory.IdentifierName($"{node.SourceTable.Alias}Rows.Rows"),
SyntaxFactory.Block(
GenerateCancellationExpression(),
(StatementSyntax)ifStatement,
_emptyBlock,
SyntaxFactory.IfStatement(
(PrefixUnaryExpressionSyntax) Generator.LogicalNotExpression(SyntaxFactory.IdentifierName("hasAnyRowMatched")),
SyntaxFactory.Block(
SyntaxFactory.ExpressionStatement(
SyntaxFactory.replacedignmentExpression(
SyntaxKind.SimplereplacedignmentExpression,
SyntaxFactory.IdentifierName("hasAnyRowMatched"),
(LiteralExpressionSyntax) Generator.TrueLiteralExpression())))))),
SyntaxFactory.IfStatement(
(PrefixUnaryExpressionSyntax)Generator.LogicalNotExpression(SyntaxFactory.IdentifierName("hasAnyRowMatched")),
SyntaxFactory.Block(
SyntaxFactory.LocalDeclarationStatement(rewriteSelect),
SyntaxFactory.ExpressionStatement(invocation))))));
break;
case JoinType.OuterRight:
fullTransitionTable = _scope.ScopeSymbolTable.GetSymbol<TableSymbol>(_queryAlias);
fieldNames = _scope.ScopeSymbolTable.GetSymbol<FieldsNamesSymbol>(MetaAttributes.OuterJoinSelect);
expressions = new List<ExpressionSyntax>();
j = 0;
for (int i = 0; i < fullTransitionTable.CompoundTables.Length - 1; i++)
{
foreach (var column in fullTransitionTable.GetColumns(fullTransitionTable.CompoundTables[i]))
{
expressions.Add(
SyntaxFactory.CastExpression(
SyntaxFactory.IdentifierName(
EvaluationHelper.GetCastableType(column.ColumnType)),
(LiteralExpressionSyntax)Generator.NullLiteralExpression()));
j += 1;
}
}
foreach (var column in fullTransitionTable.GetColumns(fullTransitionTable.CompoundTables[fullTransitionTable.CompoundTables.Length - 1]))
{
expressions.Add(
SyntaxFactory.ElementAccessExpression(
SyntaxFactory.IdentifierName($"{node.SourceTable.Alias}Row"),
SyntaxFactory.BracketedArgumentList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Argument(
(LiteralExpressionSyntax)Generator.LiteralExpression(fieldNames.Names[j++]))))));
}
arrayType = SyntaxFactory.ArrayType(
SyntaxFactory.IdentifierName("object"),
new SyntaxList<ArrayRankSpecifierSyntax>(
SyntaxFactory.ArrayRankSpecifier(
SyntaxFactory.SingletonSeparatedList(
(ExpressionSyntax)SyntaxFactory.OmittedArraySizeExpression()))));
rewriteSelect =
SyntaxFactory.VariableDeclaration(
SyntaxFactory.IdentifierName("var"),
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier("select"),
null,
SyntaxFactory.EqualsValueClause(
SyntaxFactory.ArrayCreationExpression(
arrayType,
SyntaxFactory.InitializerExpression(
SyntaxKind.ArrayInitializerExpression,
SyntaxFactory.SeparatedList(expressions)))))));
invocation = SyntaxHelper.CreateMethodInvocation(
_scope[MetaAttributes.SelectIntoVariableName],
nameof(Table.Add),
new[]
{
SyntaxFactory.Argument(
SyntaxFactory.ObjectCreationExpression(
SyntaxFactory.Token(SyntaxKind.NewKeyword).WithTrailingTrivia(SyntaxHelper.WhiteSpace),
SyntaxFactory.ParseTypeName(nameof(ObjectsRow)),
SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList(
new[]
{
SyntaxFactory.Argument(SyntaxFactory.IdentifierName("select")),
SyntaxFactory.Argument(
SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)),
SyntaxFactory.Argument(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName($"{node.SourceTable.Alias}Row"),
SyntaxFactory.IdentifierName($"{nameof(IObjectResolver.Contexts)}")))
})
),
SyntaxFactory.InitializerExpression(SyntaxKind.ComplexElementInitializerExpression))
)});
computingBlock = computingBlock.AddStatements(
SyntaxFactory.ForEachStatement(
SyntaxFactory.IdentifierName("var"),
SyntaxFactory.Identifier($"{node.SourceTable.Alias}Row"),
SyntaxFactory.IdentifierName($"{node.SourceTable.Alias}Rows.Rows"),
SyntaxFactory.Block(
SyntaxFactory.LocalDeclarationStatement(
SyntaxHelper.Createreplacedignment("hasAnyRowMatched", SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression))),
SyntaxFactory.ForEachStatement(
SyntaxFactory.IdentifierName("var"),
SyntaxFactory.Identifier($"{node.InMemoryTableAlias}Row"),
SyntaxFactory.IdentifierName(
$"{nameof(EvaluationHelper)}.{nameof(EvaluationHelper.ConvertTableToSource)}({node.InMemoryTableAlias}TransitionTable).{nameof(RowSource.Rows)}"),
SyntaxFactory.Block(
GenerateCancellationExpression(),
(StatementSyntax)ifStatement,
_emptyBlock,
SyntaxFactory.IfStatement(
(PrefixUnaryExpressionSyntax)Generator.LogicalNotExpression(SyntaxFactory.IdentifierName("hasAnyRowMatched")),
SyntaxFactory.Block(
SyntaxFactory.ExpressionStatement(
SyntaxFactory.replacedignmentExpression(
SyntaxKind.SimplereplacedignmentExpression,
SyntaxFactory.IdentifierName("hasAnyRowMatched"),
(LiteralExpressionSyntax)Generator.TrueLiteralExpression())))))),
SyntaxFactory.IfStatement(
(PrefixUnaryExpressionSyntax)Generator.LogicalNotExpression(SyntaxFactory.IdentifierName("hasAnyRowMatched")),
SyntaxFactory.Block(
SyntaxFactory.LocalDeclarationStatement(rewriteSelect),
SyntaxFactory.ExpressionStatement(invocation))))));
break;
}
NullSuspiciousNodes.Clear();
_joinBlock = computingBlock;
}
19
Source : ToCSharpRewriteTreeVisitor.cs
with MIT License
from Puchaczov
with MIT License
from Puchaczov
public void Visit(SelectNode node)
{
var scoreTable = _scope[MetaAttributes.SelectIntoVariableName];
var variableNameKeyword = SyntaxFactory.Identifier(SyntaxTriviaList.Empty, "select",
SyntaxTriviaList.Create(SyntaxHelper.WhiteSpace));
var syntaxList = new ExpressionSyntax[node.Fields.Length];
for (var i = 0; i < node.Fields.Length; i++)
syntaxList[node.Fields.Length - 1 - i] = (ExpressionSyntax) Nodes.Pop();
var array = SyntaxHelper.CreateArrayOfObjects(syntaxList.ToArray());
var equalsClause = SyntaxFactory.EqualsValueClause(
SyntaxFactory.Token(SyntaxKind.EqualsToken).WithTrailingTrivia(SyntaxHelper.WhiteSpace), array);
var variableDecl = SyntaxFactory.VariableDeclarator(variableNameKeyword, null, equalsClause);
var list = SyntaxFactory.SeparatedList(new List<VariableDeclaratorSyntax>
{
variableDecl
});
var variableDeclaration =
SyntaxFactory.VariableDeclaration(
SyntaxFactory.IdentifierName("var").WithTrailingTrivia(SyntaxHelper.WhiteSpace),
list);
var contexts = _scope[MetaAttributes.Contexts].Split(',');
var contextsExpressions = new List<ArgumentSyntax>
{
SyntaxFactory.Argument(
SyntaxFactory.IdentifierName(variableNameKeyword.Text))
};
foreach (var context in contexts)
{
var rowVariableName = string.Empty;
switch (_type)
{
case MethodAccessType.TransformingQuery:
rowVariableName = $"{context}Row";
break;
case MethodAccessType.ResultQuery:
case MethodAccessType.CaseWhen:
rowVariableName = "score";
break;
}
contextsExpressions.Add(
SyntaxFactory.Argument(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName(rowVariableName),
SyntaxFactory.IdentifierName($"{nameof(IObjectResolver.Contexts)}"))));
}
var invocation = SyntaxHelper.CreateMethodInvocation(
scoreTable,
nameof(Table.Add),
new[]
{
SyntaxFactory.Argument(
SyntaxFactory.ObjectCreationExpression(
SyntaxFactory.Token(SyntaxKind.NewKeyword).WithTrailingTrivia(SyntaxHelper.WhiteSpace),
SyntaxFactory.ParseTypeName(nameof(ObjectsRow)),
SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList(
contextsExpressions.ToArray())
),
SyntaxFactory.InitializerExpression(SyntaxKind.ComplexElementInitializerExpression))
)
});
var a1 = SyntaxFactory.LocalDeclarationStatement(variableDeclaration)
.WithTrailingTrivia(SyntaxFactory.CarriageReturnLineFeed);
var a2 = SyntaxFactory.ExpressionStatement(invocation)
.WithTrailingTrivia(SyntaxFactory.CarriageReturnLineFeed);
NullSuspiciousNodes.Clear();
_selectBlock = SyntaxFactory.Block(a1, a2);
}
19
Source : ToCSharpRewriteTreeVisitor.cs
with MIT License
from Puchaczov
with MIT License
from Puchaczov
public void Visit(JoinSourcesTableFromNode node)
{
var ifStatement = Generator.IfStatement(Generator.LogicalNotExpression(Nodes.Pop()),
new SyntaxNode[] {SyntaxFactory.ContinueStatement()})
.WithTrailingTrivia(SyntaxFactory.CarriageReturnLineFeed);
_emptyBlock = SyntaxFactory.Block();
var computingBlock = SyntaxFactory.Block();
switch (node.JoinType)
{
case JoinType.Inner:
computingBlock =
computingBlock.AddStatements(
SyntaxFactory.ForEachStatement(SyntaxFactory.IdentifierName("var"),
SyntaxFactory.Identifier($"{node.First.Alias}Row"),
SyntaxFactory.IdentifierName($"{node.First.Alias}Rows.Rows"),
SyntaxFactory.Block(
SyntaxFactory.SingletonList<StatementSyntax>(
SyntaxFactory.ForEachStatement(
SyntaxFactory.IdentifierName("var"),
SyntaxFactory.Identifier($"{node.Second.Alias}Row"),
SyntaxFactory.IdentifierName($"{node.Second.Alias}Rows.Rows"),
SyntaxFactory.Block(
GenerateCancellationExpression(),
(StatementSyntax)ifStatement,
_emptyBlock))))));
break;
case JoinType.OuterLeft:
var fullTransitionTable = _scope.ScopeSymbolTable.GetSymbol<TableSymbol>(_queryAlias);
var expressions = new List<ExpressionSyntax>();
foreach (var column in fullTransitionTable.GetColumns(fullTransitionTable.CompoundTables[0]))
{
expressions.Add(
SyntaxFactory.ElementAccessExpression(
SyntaxFactory.IdentifierName($"{node.First.Alias}Row"),
SyntaxFactory.BracketedArgumentList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Argument(
(LiteralExpressionSyntax)Generator.LiteralExpression(column.ColumnName))))));
}
foreach (var column in fullTransitionTable.GetColumns(fullTransitionTable.CompoundTables[1]))
{
expressions.Add(
SyntaxFactory.CastExpression(
SyntaxFactory.IdentifierName(
EvaluationHelper.GetCastableType(column.ColumnType)),
(LiteralExpressionSyntax)Generator.NullLiteralExpression()));
}
var arrayType = SyntaxFactory.ArrayType(
SyntaxFactory.IdentifierName("object"),
new SyntaxList<ArrayRankSpecifierSyntax>(
SyntaxFactory.ArrayRankSpecifier(
SyntaxFactory.SingletonSeparatedList(
(ExpressionSyntax)SyntaxFactory.OmittedArraySizeExpression()))));
var rewriteSelect =
SyntaxFactory.VariableDeclaration(
SyntaxFactory.IdentifierName("var"),
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier("select"),
null,
SyntaxFactory.EqualsValueClause(
SyntaxFactory.ArrayCreationExpression(
arrayType,
SyntaxFactory.InitializerExpression(
SyntaxKind.ArrayInitializerExpression,
SyntaxFactory.SeparatedList(expressions)))))));
var invocation = SyntaxHelper.CreateMethodInvocation(
_scope[MetaAttributes.SelectIntoVariableName],
nameof(Table.Add),
new[]
{
SyntaxFactory.Argument(
SyntaxFactory.ObjectCreationExpression(
SyntaxFactory.Token(SyntaxKind.NewKeyword).WithTrailingTrivia(SyntaxHelper.WhiteSpace),
SyntaxFactory.ParseTypeName(nameof(ObjectsRow)),
SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList(
new[]
{
SyntaxFactory.Argument(SyntaxFactory.IdentifierName("select")),
SyntaxFactory.Argument(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName($"{node.First.Alias}Row"),
SyntaxFactory.IdentifierName($"{nameof(IObjectResolver.Contexts)}"))),
SyntaxFactory.Argument(
SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression))
})
),
SyntaxFactory.InitializerExpression(SyntaxKind.ComplexElementInitializerExpression))
)});
computingBlock =
computingBlock.AddStatements(
SyntaxFactory.ForEachStatement(SyntaxFactory.IdentifierName("var"),
SyntaxFactory.Identifier($"{node.First.Alias}Row"),
SyntaxFactory.IdentifierName($"{node.First.Alias}Rows.Rows"),
SyntaxFactory.Block(
SyntaxFactory.LocalDeclarationStatement(
SyntaxHelper.Createreplacedignment("hasAnyRowMatched", (LiteralExpressionSyntax)Generator.FalseLiteralExpression())),
SyntaxFactory.ForEachStatement(
SyntaxFactory.IdentifierName("var"),
SyntaxFactory.Identifier($"{node.Second.Alias}Row"),
SyntaxFactory.IdentifierName($"{node.Second.Alias}Rows.Rows"),
SyntaxFactory.Block(
GenerateCancellationExpression(),
(StatementSyntax)ifStatement,
_emptyBlock,
SyntaxFactory.IfStatement(
(PrefixUnaryExpressionSyntax)Generator.LogicalNotExpression(SyntaxFactory.IdentifierName("hasAnyRowMatched")),
SyntaxFactory.Block(
SyntaxFactory.ExpressionStatement(
SyntaxFactory.replacedignmentExpression(
SyntaxKind.SimplereplacedignmentExpression,
SyntaxFactory.IdentifierName("hasAnyRowMatched"),
(LiteralExpressionSyntax)Generator.TrueLiteralExpression())))))),
SyntaxFactory.IfStatement(
(PrefixUnaryExpressionSyntax)Generator.LogicalNotExpression(SyntaxFactory.IdentifierName("hasAnyRowMatched")),
SyntaxFactory.Block(
SyntaxFactory.LocalDeclarationStatement(rewriteSelect),
SyntaxFactory.ExpressionStatement(invocation))))));
break;
case JoinType.OuterRight:
fullTransitionTable = _scope.ScopeSymbolTable.GetSymbol<TableSymbol>(_queryAlias);
expressions = new List<ExpressionSyntax>();
foreach (var column in fullTransitionTable.GetColumns(fullTransitionTable.CompoundTables[0]))
{
expressions.Add(
SyntaxFactory.CastExpression(
SyntaxFactory.IdentifierName(
EvaluationHelper.GetCastableType(column.ColumnType)),
(LiteralExpressionSyntax)Generator.NullLiteralExpression()));
}
foreach (var column in fullTransitionTable.GetColumns(fullTransitionTable.CompoundTables[1]))
{
expressions.Add(
SyntaxFactory.ElementAccessExpression(
SyntaxFactory.IdentifierName($"{node.Second.Alias}Row"),
SyntaxFactory.BracketedArgumentList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Argument(
(LiteralExpressionSyntax)Generator.LiteralExpression(column.ColumnName))))));
}
arrayType = SyntaxFactory.ArrayType(
SyntaxFactory.IdentifierName("object"),
new SyntaxList<ArrayRankSpecifierSyntax>(
SyntaxFactory.ArrayRankSpecifier(
SyntaxFactory.SingletonSeparatedList(
(ExpressionSyntax)SyntaxFactory.OmittedArraySizeExpression()))));
rewriteSelect =
SyntaxFactory.VariableDeclaration(
SyntaxFactory.IdentifierName("var"),
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier("select"),
null,
SyntaxFactory.EqualsValueClause(
SyntaxFactory.ArrayCreationExpression(
arrayType,
SyntaxFactory.InitializerExpression(
SyntaxKind.ArrayInitializerExpression,
SyntaxFactory.SeparatedList(expressions)))))));
invocation = SyntaxHelper.CreateMethodInvocation(
_scope[MetaAttributes.SelectIntoVariableName],
nameof(Table.Add),
new[]
{
SyntaxFactory.Argument(
SyntaxFactory.ObjectCreationExpression(
SyntaxFactory.Token(SyntaxKind.NewKeyword).WithTrailingTrivia(SyntaxHelper.WhiteSpace),
SyntaxFactory.ParseTypeName(nameof(ObjectsRow)),
SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList(
new[]
{
SyntaxFactory.Argument(SyntaxFactory.IdentifierName("select")),
SyntaxFactory.Argument(
SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)),
SyntaxFactory.Argument(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName($"{node.Second.Alias}Row"),
SyntaxFactory.IdentifierName($"{nameof(IObjectResolver.Contexts)}")))
})
),
SyntaxFactory.InitializerExpression(SyntaxKind.ComplexElementInitializerExpression))
)});
computingBlock =
computingBlock.AddStatements(
SyntaxFactory.ForEachStatement(SyntaxFactory.IdentifierName("var"),
SyntaxFactory.Identifier($"{node.Second.Alias}Row"),
SyntaxFactory.IdentifierName($"{node.Second.Alias}Rows.Rows"),
SyntaxFactory.Block(
SyntaxFactory.LocalDeclarationStatement(
SyntaxHelper.Createreplacedignment("hasAnyRowMatched", (LiteralExpressionSyntax)Generator.FalseLiteralExpression())),
SyntaxFactory.ForEachStatement(
SyntaxFactory.IdentifierName("var"),
SyntaxFactory.Identifier($"{node.First.Alias}Row"),
SyntaxFactory.IdentifierName($"{node.First.Alias}Rows.Rows"),
SyntaxFactory.Block(
GenerateCancellationExpression(),
(StatementSyntax)ifStatement,
_emptyBlock,
SyntaxFactory.IfStatement(
(PrefixUnaryExpressionSyntax)Generator.LogicalNotExpression(SyntaxFactory.IdentifierName("hasAnyRowMatched")),
SyntaxFactory.Block(
SyntaxFactory.ExpressionStatement(
SyntaxFactory.replacedignmentExpression(
SyntaxKind.SimplereplacedignmentExpression,
SyntaxFactory.IdentifierName("hasAnyRowMatched"),
(LiteralExpressionSyntax)Generator.TrueLiteralExpression())))))),
SyntaxFactory.IfStatement(
(PrefixUnaryExpressionSyntax)Generator.LogicalNotExpression(SyntaxFactory.IdentifierName("hasAnyRowMatched")),
SyntaxFactory.Block(
SyntaxFactory.LocalDeclarationStatement(rewriteSelect),
SyntaxFactory.ExpressionStatement(invocation))))));
break;
}
NullSuspiciousNodes.Clear();
_joinBlock = computingBlock;
}
19
Source : ToCSharpRewriteTreeVisitor.cs
with MIT License
from Puchaczov
with MIT License
from Puchaczov
private StatementSyntax GenerateCancellationExpression()
{
return SyntaxFactory.ExpressionStatement(
SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("token"),
SyntaxFactory.IdentifierName(
nameof(CancellationToken.ThrowIfCancellationRequested)))));
}
19
Source : ToCSharpRewriteTreeVisitor.cs
with MIT License
from Puchaczov
with MIT License
from Puchaczov
public void Visit(RefreshNode node)
{
if (node.Nodes.Length == 0)
return;
var block = SyntaxFactory.Block();
for (int i = 0, k = node.Nodes.Length - 1; i < node.Nodes.Length; i++, k--)
block = block.AddStatements(
SyntaxFactory.ExpressionStatement((ExpressionSyntax) Nodes.Pop()));
Nodes.Push(block);
}
19
Source : ToCSharpRewriteTreeVisitor.cs
with MIT License
from Puchaczov
with MIT License
from Puchaczov
public void Visit(TakeNode node)
{
var identifier = "tookAmount";
var take = SyntaxFactory.LocalDeclarationStatement(
SyntaxHelper.Createreplacedignment(identifier, (ExpressionSyntax) Generator.LiteralExpression(0)));
var ifStatement =
(StatementSyntax) Generator.IfStatement(
Generator.ValueEqualsExpression(
SyntaxFactory.IdentifierName(identifier),
Generator.LiteralExpression(node.Value)),
new SyntaxNode[]
{
SyntaxFactory.BreakStatement()
});
var incTookAmount =
SyntaxFactory.ExpressionStatement(
SyntaxFactory.PostfixUnaryExpression(
SyntaxKind.PostIncrementExpression,
SyntaxFactory.IdentifierName(identifier)));
Statements.Add(take);
Nodes.Push(SyntaxFactory.Block(ifStatement, incTookAmount));
}
19
Source : ToCSharpRewriteTreeVisitor.cs
with MIT License
from Puchaczov
with MIT License
from Puchaczov
private StatementSyntax GenerateStatsUpdateStatements()
{
return SyntaxFactory.ExpressionStatement(SyntaxFactory.replacedignmentExpression(
SyntaxKind.AddreplacedignmentExpression,
SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("stats"), SyntaxFactory.IdentifierName("RowNumber")),
SyntaxFactory.LiteralExpression(SyntaxKind.NumerireplacederalExpression, SyntaxFactory.Literal(1))));
}
19
Source : ToCSharpRewriteTreeVisitor.cs
with MIT License
from Puchaczov
with MIT License
from Puchaczov
private StatementSyntax GroupForStatement()
{
return
SyntaxFactory.ForStatement(SyntaxFactory.Block(
SyntaxFactory.ExpressionStatement(
SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("token"),
SyntaxFactory.IdentifierName(nameof(CancellationToken
.ThrowIfCancellationRequested))))),
SyntaxFactory.LocalDeclarationStatement(
SyntaxFactory.VariableDeclaration(
SyntaxFactory.IdentifierName("var"))
.WithVariables(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier("key"))
.WithInitializer(
SyntaxFactory.EqualsValueClause(
SyntaxFactory
.ElementAccessExpression(SyntaxFactory.IdentifierName("keys"))
.WithArgumentList(SyntaxFactory.BracketedArgumentList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Argument(
SyntaxFactory.IdentifierName("i")))))))))),
SyntaxFactory.IfStatement(
SyntaxFactory.InvocationExpression(SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("groups"),
SyntaxFactory.IdentifierName("ContainsKey"))).WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Argument(SyntaxFactory.IdentifierName("key"))))),
SyntaxFactory.Block(SyntaxFactory.SingletonList<StatementSyntax>(
SyntaxFactory.ExpressionStatement(SyntaxFactory.replacedignmentExpression(
SyntaxKind.SimplereplacedignmentExpression, SyntaxFactory.IdentifierName("group"),
SyntaxFactory.ElementAccessExpression(SyntaxFactory.IdentifierName("groups"))
.WithArgumentList(
SyntaxFactory.BracketedArgumentList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Argument(
SyntaxFactory.IdentifierName("key"))))))))))
.WithElse(SyntaxFactory.ElseClause(SyntaxFactory.Block(
SyntaxFactory.ExpressionStatement(SyntaxFactory.replacedignmentExpression(
SyntaxKind.SimplereplacedignmentExpression,
SyntaxFactory.IdentifierName("group"),
SyntaxFactory.ObjectCreationExpression(SyntaxFactory.IdentifierName("Group"))
.WithArgumentList(SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList<ArgumentSyntax>(new SyntaxNodeOrToken[]
{
SyntaxFactory.Argument(SyntaxFactory.IdentifierName("parent")),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(SyntaxFactory
.ElementAccessExpression(
SyntaxFactory.IdentifierName("groupFieldsNames"))
.WithArgumentList(SyntaxFactory.BracketedArgumentList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Argument(
SyntaxFactory.IdentifierName("i")))))),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(SyntaxFactory
.ElementAccessExpression(SyntaxFactory.IdentifierName("values"))
.WithArgumentList(SyntaxFactory.BracketedArgumentList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Argument(
SyntaxFactory.IdentifierName("i"))))))
}))))),
SyntaxFactory.ExpressionStatement(
SyntaxFactory.InvocationExpression(SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("groups"),
SyntaxFactory.IdentifierName("Add")))
.WithArgumentList(
SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList<ArgumentSyntax>(
new SyntaxNodeOrToken[]
{
SyntaxFactory.Argument(SyntaxFactory.IdentifierName("key")),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(SyntaxFactory.IdentifierName("group"))
}))))))),
SyntaxFactory.ExpressionStatement(SyntaxFactory.replacedignmentExpression(
SyntaxKind.SimplereplacedignmentExpression,
SyntaxFactory.IdentifierName("parent"), SyntaxFactory.IdentifierName("group")))))
.WithDeclaration(SyntaxFactory
.VariableDeclaration(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)))
.WithVariables(
SyntaxFactory.SingletonSeparatedList(SyntaxFactory
.VariableDeclarator(SyntaxFactory.Identifier("i"))
.WithInitializer(
SyntaxFactory.EqualsValueClause(SyntaxFactory.LiteralExpression(
SyntaxKind.NumerireplacederalExpression,
SyntaxFactory.Literal(0)))))))
.WithCondition(SyntaxFactory.BinaryExpression(SyntaxKind.LessThanExpression,
SyntaxFactory.IdentifierName("i"),
SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("keys"),
SyntaxFactory.IdentifierName("Length"))))
.WithIncrementors(SyntaxFactory.SingletonSeparatedList<ExpressionSyntax>(
SyntaxFactory.PrefixUnaryExpression(SyntaxKind.PreIncrementExpression,
SyntaxFactory.IdentifierName("i"))));
}
19
Source : ToCSharpRewriteTreeVisitor.cs
with MIT License
from Puchaczov
with MIT License
from Puchaczov
public void Visit(CteInnerExpressionNode node)
{
if (!_inMemoryTableIndexes.ContainsKey(node.Name))
_inMemoryTableIndexes.Add(node.Name, _inMemoryTableIndex++);
Nodes.Push(SyntaxFactory.ExpressionStatement(SyntaxFactory.replacedignmentExpression(
SyntaxKind.SimplereplacedignmentExpression,
SyntaxFactory.ElementAccessExpression(SyntaxFactory.IdentifierName("_tableResults")).WithArgumentList(
SyntaxFactory.BracketedArgumentList(SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Argument(SyntaxFactory.LiteralExpression(SyntaxKind.NumerireplacederalExpression,
SyntaxFactory.Literal(_inMemoryTableIndexes[node.Name])))))),
SyntaxFactory.InvocationExpression(SyntaxFactory.IdentifierName(_methodNames.Peek())).WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList(
new []
{
SyntaxFactory.Argument(SyntaxFactory.IdentifierName("provider")),
SyntaxFactory.Argument(SyntaxFactory.IdentifierName("token"))
}))))));
}
19
Source : ToCSharpRewriteTreeVisitor.cs
with MIT License
from Puchaczov
with MIT License
from Puchaczov
private StatementSyntax AddGroupStatement(string scoreTable)
{
return SyntaxFactory.IfStatement(
SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression,
SyntaxFactory.InvocationExpression(SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("usedGroups"), SyntaxFactory.IdentifierName("Contains")))
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Argument(SyntaxFactory.IdentifierName("group")))))),
SyntaxFactory.Block(
SyntaxFactory.ExpressionStatement(
SyntaxFactory.InvocationExpression(SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName(scoreTable),
SyntaxFactory.IdentifierName("Add")))
.WithArgumentList(SyntaxFactory.ArgumentList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Argument(SyntaxFactory.IdentifierName("group")))))),
SyntaxFactory.ExpressionStatement(
SyntaxFactory.InvocationExpression(SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("usedGroups"), SyntaxFactory.IdentifierName("Add")))
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Argument(SyntaxFactory.IdentifierName("group"))))))));
}
19
Source : MsTestTestFramework.cs
with Apache License 2.0
from sentryone
with Apache License 2.0
from sentryone
public StatementSyntax replacedertEqual(ExpressionSyntax actual, ExpressionSyntax expected)
{
if (actual == null)
{
throw new ArgumentNullException(nameof(actual));
}
if (expected == null)
{
throw new ArgumentNullException(nameof(expected));
}
return SyntaxFactory.ExpressionStatement(replacedertCall("AreEqual").WithArgumentList(Generate.Arguments(expected, actual)));
}
19
Source : MsTestTestFramework.cs
with Apache License 2.0
from sentryone
with Apache License 2.0
from sentryone
public StatementSyntax replacedertFail(string message)
{
if (string.IsNullOrWhiteSpace(message))
{
throw new ArgumentNullException(nameof(message));
}
return SyntaxFactory.ExpressionStatement(replacedertCall("Fail").WithArgumentList(Generate.Arguments(Generate.Literal(message))));
}
19
Source : MsTestTestFramework.cs
with Apache License 2.0
from sentryone
with Apache License 2.0
from sentryone
public StatementSyntax replacedertGreaterThan(ExpressionSyntax actual, ExpressionSyntax expected)
{
if (actual == null)
{
throw new ArgumentNullException(nameof(actual));
}
if (expected == null)
{
throw new ArgumentNullException(nameof(expected));
}
return SyntaxFactory.ExpressionStatement(replacedertCall("IsTrue").WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SingletonSeparatedList<ArgumentSyntax>(
SyntaxFactory.Argument(
SyntaxFactory.BinaryExpression(
SyntaxKind.GreaterThanExpression, actual, expected))))));
}
19
Source : MsTestTestFramework.cs
with Apache License 2.0
from sentryone
with Apache License 2.0
from sentryone
public StatementSyntax replacedertIsInstanceOf(ExpressionSyntax value, TypeSyntax type)
{
if (value == null)
{
throw new ArgumentNullException(Strings.MsTestTestFramework_CreateTestCaseMethod_value);
}
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
return SyntaxFactory.ExpressionStatement(replacedertCall("IsInstanceOfType").WithArgumentList(Generate.Arguments(value, SyntaxFactory.TypeOfExpression(type))));
}
19
Source : MsTestTestFramework.cs
with Apache License 2.0
from sentryone
with Apache License 2.0
from sentryone
public StatementSyntax replacedertLessThan(ExpressionSyntax actual, ExpressionSyntax expected)
{
if (actual == null)
{
throw new ArgumentNullException(nameof(actual));
}
if (expected == null)
{
throw new ArgumentNullException(nameof(expected));
}
return SyntaxFactory.ExpressionStatement(replacedertCall("IsTrue").WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SingletonSeparatedList<ArgumentSyntax>(
SyntaxFactory.Argument(
SyntaxFactory.BinaryExpression(
SyntaxKind.LessThanExpression, actual, expected))))));
}
19
Source : MsTestTestFramework.cs
with Apache License 2.0
from sentryone
with Apache License 2.0
from sentryone
public StatementSyntax replacedertNotNull(ExpressionSyntax value)
{
if (value == null)
{
throw new ArgumentNullException(Strings.MsTestTestFramework_CreateTestCaseMethod_value);
}
return SyntaxFactory.ExpressionStatement(replacedertCall("IsNotNull").WithArgumentList(Generate.Arguments(value)));
}
19
Source : MsTestTestFramework.cs
with Apache License 2.0
from sentryone
with Apache License 2.0
from sentryone
public StatementSyntax replacedertThrows(TypeSyntax exceptionType, ExpressionSyntax methodCall)
{
return SyntaxFactory.ExpressionStatement(replacedertThrows(exceptionType, methodCall, "ThrowsException"));
}
19
Source : MsTestTestFramework.cs
with Apache License 2.0
from sentryone
with Apache License 2.0
from sentryone
public StatementSyntax replacedertThrowsAsync(TypeSyntax exceptionType, ExpressionSyntax methodCall)
{
return SyntaxFactory.ExpressionStatement(SyntaxFactory.AwaitExpression(replacedertThrows(exceptionType, methodCall, "ThrowsExceptionAsync")));
}
19
Source : NUnitTestFramework.cs
with Apache License 2.0
from sentryone
with Apache License 2.0
from sentryone
public StatementSyntax replacedertEqual(ExpressionSyntax actual, ExpressionSyntax expected)
{
if (actual == null)
{
throw new ArgumentNullException(nameof(actual));
}
if (expected == null)
{
throw new ArgumentNullException(nameof(expected));
}
return SyntaxFactory.ExpressionStatement(SyntaxFactory.InvocationExpression(replacedertThat)
.WithArgumentList(Generate.Arguments(actual, SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("Is"),
SyntaxFactory.IdentifierName("EqualTo")))
.WithArgumentList(Generate.Arguments(expected)))));
}
19
Source : NUnitTestFramework.cs
with Apache License 2.0
from sentryone
with Apache License 2.0
from sentryone
public StatementSyntax replacedertFail(string message)
{
if (string.IsNullOrWhiteSpace(message))
{
throw new ArgumentNullException(nameof(message));
}
return SyntaxFactory.ExpressionStatement(SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("replacedert"),
SyntaxFactory.IdentifierName("Fail")))
.WithArgumentList(Generate.Arguments(Generate.Literal(message))));
}
19
Source : NUnitTestFramework.cs
with Apache License 2.0
from sentryone
with Apache License 2.0
from sentryone
public StatementSyntax replacedertGreaterThan(ExpressionSyntax actual, ExpressionSyntax expected)
{
if (actual == null)
{
throw new ArgumentNullException(nameof(actual));
}
if (expected == null)
{
throw new ArgumentNullException(nameof(expected));
}
return SyntaxFactory.ExpressionStatement(SyntaxFactory.InvocationExpression(replacedertThat)
.WithArgumentList(Generate.Arguments(actual, SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("Is"),
SyntaxFactory.IdentifierName("GreaterThan")))
.WithArgumentList(Generate.Arguments(expected)))));
}
19
Source : NUnitTestFramework.cs
with Apache License 2.0
from sentryone
with Apache License 2.0
from sentryone
public StatementSyntax replacedertIsInstanceOf(ExpressionSyntax value, TypeSyntax type)
{
if (value == null)
{
throw new ArgumentNullException(Strings.MsTestTestFramework_CreateTestCaseMethod_value);
}
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
return SyntaxFactory.ExpressionStatement(SyntaxFactory.InvocationExpression(replacedertThat)
.WithArgumentList(Generate.Arguments(value, SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("Is"),
SyntaxFactory.GenericName(
SyntaxFactory.Identifier(Strings.NUnitTestFramework_replacedertIsInstanceOf_InstanceOf))
.WithTypeArgumentList(
SyntaxFactory.TypeArgumentList(
SyntaxFactory.SingletonSeparatedList(type))))))));
}
19
Source : NUnitTestFramework.cs
with Apache License 2.0
from sentryone
with Apache License 2.0
from sentryone
public StatementSyntax replacedertLessThan(ExpressionSyntax actual, ExpressionSyntax expected)
{
if (actual == null)
{
throw new ArgumentNullException(nameof(actual));
}
if (expected == null)
{
throw new ArgumentNullException(nameof(expected));
}
return SyntaxFactory.ExpressionStatement(SyntaxFactory.InvocationExpression(replacedertThat)
.WithArgumentList(Generate.Arguments(actual, SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("Is"),
SyntaxFactory.IdentifierName("LessThan")))
.WithArgumentList(Generate.Arguments(expected)))));
}
19
Source : NUnitTestFramework.cs
with Apache License 2.0
from sentryone
with Apache License 2.0
from sentryone
public StatementSyntax replacedertNotNull(ExpressionSyntax value)
{
if (value == null)
{
throw new ArgumentNullException(Strings.MsTestTestFramework_CreateTestCaseMethod_value);
}
return SyntaxFactory.ExpressionStatement(SyntaxFactory.InvocationExpression(replacedertThat)
.WithArgumentList(Generate.Arguments(
value,
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("Is"),
SyntaxFactory.IdentifierName("Not")),
SyntaxFactory.IdentifierName("Null")))));
}
19
Source : NUnitTestFramework.cs
with Apache License 2.0
from sentryone
with Apache License 2.0
from sentryone
private static StatementSyntax replacedertThrows(TypeSyntax exceptionType, ExpressionSyntax methodCall, string throws)
{
if (exceptionType == null)
{
throw new ArgumentNullException(nameof(exceptionType));
}
if (methodCall == null)
{
throw new ArgumentNullException(nameof(methodCall));
}
return SyntaxFactory.ExpressionStatement(SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("replacedert"),
SyntaxFactory.GenericName(SyntaxFactory.Identifier(throws))
.WithTypeArgumentList(SyntaxFactory.TypeArgumentList(SyntaxFactory.SingletonSeparatedList(exceptionType)))))
.WithArgumentList(Generate.Arguments(Generate.ParenthesizedLambdaExpression(methodCall))));
}
19
Source : XUnitTestFramework.cs
with Apache License 2.0
from sentryone
with Apache License 2.0
from sentryone
public StatementSyntax replacedertEqual(ExpressionSyntax actual, ExpressionSyntax expected)
{
if (actual == null)
{
throw new ArgumentNullException(nameof(actual));
}
if (expected == null)
{
throw new ArgumentNullException(nameof(expected));
}
return SyntaxFactory.ExpressionStatement(replacedertCall("Equal").WithArgumentList(Generate.Arguments(expected, actual)));
}
19
Source : XUnitTestFramework.cs
with Apache License 2.0
from sentryone
with Apache License 2.0
from sentryone
public StatementSyntax replacedertFail(string message)
{
if (string.IsNullOrWhiteSpace(message))
{
throw new ArgumentNullException(nameof(message));
}
return SyntaxFactory.ExpressionStatement(replacedertCall("True").WithArgumentList(Generate.Arguments(Generate.Literal(false), Generate.Literal(message))));
}
19
Source : XUnitTestFramework.cs
with Apache License 2.0
from sentryone
with Apache License 2.0
from sentryone
public StatementSyntax replacedertLessThan(ExpressionSyntax actual, ExpressionSyntax expected)
{
if (actual == null)
{
throw new ArgumentNullException(nameof(actual));
}
if (expected == null)
{
throw new ArgumentNullException(nameof(expected));
}
return SyntaxFactory.ExpressionStatement(replacedertCall("True").WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SingletonSeparatedList<ArgumentSyntax>(
SyntaxFactory.Argument(
SyntaxFactory.BinaryExpression(
SyntaxKind.LessThanExpression, actual, expected))))));
}
19
Source : XUnitTestFramework.cs
with Apache License 2.0
from sentryone
with Apache License 2.0
from sentryone
public StatementSyntax replacedertThrows(TypeSyntax exceptionType, ExpressionSyntax methodCall)
{
return SyntaxFactory.ExpressionStatement(replacedertThrows(exceptionType, methodCall, "Throws"));
}
19
Source : AbstractClassGenerationStrategy.cs
with Apache License 2.0
from sentryone
with Apache License 2.0
from sentryone
public ClreplacedDeclarationSyntax Create(ClreplacedModel model)
{
if (model is null)
{
throw new ArgumentNullException(nameof(model));
}
var targetTypeName = _frameworkSet.GetTargetTypeName(model, true);
var clreplacedDeclaration = SyntaxFactory.ClreplacedDeclaration(targetTypeName);
clreplacedDeclaration = clreplacedDeclaration.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword));
if (!string.IsNullOrWhiteSpace(_frameworkSet.TestFramework.TestClreplacedAttribute))
{
var testFixtureAtt = Generate.Attribute(_frameworkSet.TestFramework.TestClreplacedAttribute);
var list = SyntaxFactory.AttributeList(SyntaxFactory.SingletonSeparatedList(testFixtureAtt));
clreplacedDeclaration = clreplacedDeclaration.AddAttributeLists(list);
}
clreplacedDeclaration = clreplacedDeclaration.AddMembers(GenerateConcreteInheritor(model));
var variableDeclaration = SyntaxFactory.VariableDeclaration(SyntaxFactory.ParseTypeName("Test" + model.ClreplacedName))
.AddVariables(SyntaxFactory.VariableDeclarator("_testClreplaced"));
var fieldDeclaration = SyntaxFactory.FieldDeclaration(variableDeclaration)
.AddModifiers(SyntaxFactory.Token(SyntaxKind.PrivateKeyword));
clreplacedDeclaration = clreplacedDeclaration.AddMembers(fieldDeclaration);
var setupMethod = Generate.SetupMethod(model, targetTypeName, _frameworkSet, ref clreplacedDeclaration);
var identifierNameSyntax = SyntaxFactory.IdentifierName("Test" + model.ClreplacedName);
model.TypeSyntax = identifierNameSyntax;
var creationExpression = model.GetObjectCreationExpression(_frameworkSet);
var replacedignment = SyntaxFactory.replacedignmentExpression(
SyntaxKind.SimplereplacedignmentExpression,
model.TargetInstance,
creationExpression);
setupMethod = setupMethod.AddBodyStatements(SyntaxFactory.ExpressionStatement(replacedignment));
clreplacedDeclaration = clreplacedDeclaration.AddMembers(setupMethod);
return clreplacedDeclaration;
}
19
Source : AbstractClassGenerationStrategy.cs
with Apache License 2.0
from sentryone
with Apache License 2.0
from sentryone
private static ClreplacedDeclarationSyntax InheritProtectedMethods(ClreplacedModel model, ClreplacedDeclarationSyntax clreplacedDeclaration)
{
foreach (var method in model.Methods)
{
if (!method.Node.Modifiers.Any(x => x.IsKind(SyntaxKind.ProtectedKeyword)) || method.Node.Modifiers.Any(x => x.IsKind(SyntaxKind.AbstractKeyword)))
{
continue;
}
var tokenList = ExtractTokenList(method.Parameters);
InvocationExpressionSyntax baseInvocation;
if (method.Node.Modifiers.Any(x => x.IsKind(SyntaxKind.StaticKeyword)))
{
baseInvocation = SyntaxFactory.InvocationExpression(SyntaxFactory.IdentifierName(method.Name))
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList<ArgumentSyntax>(tokenList)));
}
else
{
baseInvocation = SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.BaseExpression(),
SyntaxFactory.IdentifierName(method.Name)))
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList<ArgumentSyntax>(tokenList)));
}
StatementSyntax methodStatement;
if (method.IsVoid)
{
methodStatement = SyntaxFactory.ExpressionStatement(baseInvocation);
}
else
{
methodStatement = SyntaxFactory.ReturnStatement(baseInvocation);
}
var newMethod = method.Node;
if (method.Node.Modifiers.Any(x => x.IsKind(SyntaxKind.StaticKeyword)))
{
newMethod = newMethod.WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.StaticKeyword)));
}
else
{
newMethod = newMethod.WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword)));
}
newMethod = newMethod
.WithIdentifier(SyntaxFactory.Identifier("Public" + method.Name))
.WithBody(SyntaxFactory.Block(SyntaxFactory.SingletonList(methodStatement)));
if (method.Node.Modifiers.Any(x => x.IsKind(SyntaxKind.AbstractKeyword)))
{
newMethod = newMethod.AddModifiers(SyntaxFactory.Token(SyntaxKind.OverrideKeyword));
}
method.MutateName("Public" + method.Name);
clreplacedDeclaration = clreplacedDeclaration.AddMembers(newMethod);
}
return clreplacedDeclaration;
}
19
Source : StandardClassGenerationStrategy.cs
with Apache License 2.0
from sentryone
with Apache License 2.0
from sentryone
public ClreplacedDeclarationSyntax Create(ClreplacedModel model)
{
if (model is null)
{
throw new ArgumentNullException(nameof(model));
}
var targetTypeName = _frameworkSet.GetTargetTypeName(model, true);
var clreplacedDeclaration = SyntaxFactory.ClreplacedDeclaration(targetTypeName);
clreplacedDeclaration = clreplacedDeclaration.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword));
if (!string.IsNullOrWhiteSpace(_frameworkSet.TestFramework.TestClreplacedAttribute))
{
var testFixtureAtt = Generate.Attribute(_frameworkSet.TestFramework.TestClreplacedAttribute);
var list = SyntaxFactory.AttributeList(SyntaxFactory.SingletonSeparatedList(testFixtureAtt));
clreplacedDeclaration = clreplacedDeclaration.AddAttributeLists(list);
}
var variableDeclaration = SyntaxFactory.VariableDeclaration(model.TypeSyntax)
.AddVariables(SyntaxFactory.VariableDeclarator("_testClreplaced"));
var fieldDeclaration = SyntaxFactory.FieldDeclaration(variableDeclaration)
.AddModifiers(SyntaxFactory.Token(SyntaxKind.PrivateKeyword));
clreplacedDeclaration = clreplacedDeclaration.AddMembers(fieldDeclaration);
var setupMethod = Generate.SetupMethod(model, targetTypeName, _frameworkSet, ref clreplacedDeclaration);
var creationExpression = model.GetObjectCreationExpression(_frameworkSet);
var replacedignment = SyntaxFactory.replacedignmentExpression(
SyntaxKind.SimplereplacedignmentExpression,
model.TargetInstance,
creationExpression);
setupMethod = setupMethod.AddBodyStatements(SyntaxFactory.ExpressionStatement(replacedignment));
clreplacedDeclaration = clreplacedDeclaration.AddMembers(setupMethod);
return clreplacedDeclaration;
}
19
Source : WriteOnlyIndexerGenerationStrategy.cs
with Apache License 2.0
from sentryone
with Apache License 2.0
from sentryone
private IEnumerable<StatementSyntax> GetPropertyreplacedertionBodyStatements(IIndexerModel indexer, ClreplacedModel sourceModel)
{
var paramExpressions = indexer.Parameters.Select(param => replacedignmentValueHelper.GetDefaultreplacedignmentValue(param.TypeInfo, sourceModel.SemanticModel, _frameworkSet)).ToArray();
var defaultreplacedignmentValue = replacedignmentValueHelper.GetDefaultreplacedignmentValue(indexer.TypeInfo, sourceModel.SemanticModel, _frameworkSet);
yield return SyntaxFactory.ExpressionStatement(SyntaxFactory.replacedignmentExpression(SyntaxKind.SimplereplacedignmentExpression, Generate.IndexerAccess(sourceModel.TargetInstance, paramExpressions), defaultreplacedignmentValue));
yield return _frameworkSet.TestFramework.replacedertFail(Strings.PlaceholderreplacedertionMessage);
}
19
Source : XUnitTestFramework.cs
with Apache License 2.0
from sentryone
with Apache License 2.0
from sentryone
public StatementSyntax replacedertNotNull(ExpressionSyntax value)
{
if (value == null)
{
throw new ArgumentNullException(Strings.MsTestTestFramework_CreateTestCaseMethod_value);
}
return SyntaxFactory.ExpressionStatement(replacedertCall("NotNull").WithArgumentList(Generate.Arguments(value)));
}
19
Source : XUnitTestFramework.cs
with Apache License 2.0
from sentryone
with Apache License 2.0
from sentryone
public StatementSyntax replacedertThrowsAsync(TypeSyntax exceptionType, ExpressionSyntax methodCall)
{
return SyntaxFactory.ExpressionStatement(SyntaxFactory.AwaitExpression(replacedertThrows(exceptionType, methodCall, "ThrowsAsync")));
}
19
Source : MappingMethodGenerationStrategy.cs
with Apache License 2.0
from sentryone
with Apache License 2.0
from sentryone
public IEnumerable<MethodDeclarationSyntax> Create(IMethodModel method, ClreplacedModel model)
{
if (method is null)
{
throw new ArgumentNullException(nameof(method));
}
if (model is null)
{
throw new ArgumentNullException(nameof(model));
}
var methodName = string.Format(CultureInfo.InvariantCulture, "{0}PerformsMapping", model.GetMethodUniqueName(method));
var generatedMethod = _frameworkSet.TestFramework.CreateTestMethod(methodName, method.IsAsync, model.IsStatic);
var paramExpressions = new List<CSharpSyntaxNode>();
foreach (var parameter in method.Parameters)
{
if (parameter.Node.Modifiers.Any(x => x.Kind() == SyntaxKind.OutKeyword))
{
paramExpressions.Add(SyntaxFactory.Argument(SyntaxFactory.DeclarationExpression(SyntaxFactory.IdentifierName(Strings.Create_var), SyntaxFactory.SingleVariableDesignation(SyntaxFactory.Identifier(parameter.Name)))).WithRefKindKeyword(SyntaxFactory.Token(SyntaxKind.OutKeyword)));
}
else
{
var defaultreplacedignmentValue = replacedignmentValueHelper.GetDefaultreplacedignmentValue(parameter.TypeInfo, model.SemanticModel, _frameworkSet);
generatedMethod = generatedMethod.AddBodyStatements(SyntaxFactory.LocalDeclarationStatement(
SyntaxFactory.VariableDeclaration(SyntaxFactory.IdentifierName(Strings.Create_var))
.WithVariables(SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(parameter.Name))
.WithInitializer(SyntaxFactory.EqualsValueClause(defaultreplacedignmentValue))))));
if (parameter.Node.Modifiers.Any(x => x.Kind() == SyntaxKind.RefKeyword))
{
paramExpressions.Add(SyntaxFactory.Argument(SyntaxFactory.IdentifierName(parameter.Name)).WithRefKindKeyword(SyntaxFactory.Token(SyntaxKind.RefKeyword)));
}
else
{
paramExpressions.Add(SyntaxFactory.IdentifierName(parameter.Name));
}
}
}
var methodCall = method.Invoke(model, false, _frameworkSet, paramExpressions.ToArray());
bool requiresInstance = false;
if (method.IsAsync)
{
if (model.SemanticModel.GetSymbolInfo(method.Node.ReturnType).Symbol is INamedTypeSymbol type)
{
requiresInstance = type.TypeArguments.Any();
}
}
else
{
requiresInstance = !method.IsVoid;
}
StatementSyntax bodyStatement;
if (requiresInstance)
{
bodyStatement = SyntaxFactory.LocalDeclarationStatement(
SyntaxFactory.VariableDeclaration(
SyntaxFactory.IdentifierName(Strings.Create_var))
.WithVariables(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier(Strings.CanCallMethodGenerationStrategy_Create_result))
.WithInitializer(
SyntaxFactory.EqualsValueClause(methodCall)))));
}
else
{
bodyStatement = SyntaxFactory.ExpressionStatement(methodCall);
}
generatedMethod = generatedMethod.AddBodyStatements(bodyStatement);
var returnTypeInfo = model.SemanticModel.GetTypeInfo(method.Node.ReturnType).Type;
if (returnTypeInfo == null || returnTypeInfo.SpecialType != SpecialType.None || method.Node.IsKind(SyntaxKind.IndexerDeclaration) || (returnTypeInfo.ToFullName() == typeof(Task).FullName && !(returnTypeInfo is INamedTypeSymbol namedTypeSymbol && namedTypeSymbol.IsGenericType)))
{
yield break;
}
if (returnTypeInfo is INamedTypeSymbol namedType && namedType.IsGenericType && returnTypeInfo.ToFullName() == typeof(Task).FullName)
{
returnTypeInfo = namedType.TypeArguments[0];
}
var returnTypeMembers = GetProperties(returnTypeInfo);
foreach (var methodParameter in method.Parameters)
{
if (returnTypeMembers.Contains(methodParameter.Name))
{
var returnTypeMember = returnTypeMembers.FirstOrDefault(x => string.Equals(x, methodParameter.Name, StringComparison.OrdinalIgnoreCase));
var resultProperty = Generate.PropertyAccess(SyntaxFactory.IdentifierName(Strings.CanCallMethodGenerationStrategy_Create_result), returnTypeMember);
generatedMethod = generatedMethod.AddBodyStatements(_frameworkSet.TestFramework.replacedertEqual(resultProperty, SyntaxFactory.IdentifierName(methodParameter.Name)));
continue;
}
if (methodParameter.TypeInfo.Type.SpecialType == SpecialType.None && !Equals(methodParameter.TypeInfo.Type, returnTypeInfo))
{
var properties = GetProperties(methodParameter.TypeInfo.Type);
foreach (var matchedSourceProperty in properties.Where(x => returnTypeMembers.Contains(x)))
{
var returnTypeMember = returnTypeMembers.FirstOrDefault(x => string.Equals(x, matchedSourceProperty, StringComparison.OrdinalIgnoreCase));
var resultProperty = Generate.PropertyAccess(SyntaxFactory.IdentifierName(Strings.CanCallMethodGenerationStrategy_Create_result), returnTypeMember);
generatedMethod = generatedMethod.AddBodyStatements(_frameworkSet.TestFramework.replacedertEqual(resultProperty, Generate.PropertyAccess(SyntaxFactory.IdentifierName(methodParameter.Name), matchedSourceProperty)));
}
}
}
yield return generatedMethod;
}
19
Source : ReadWriteIndexerGenerationStrategy.cs
with Apache License 2.0
from sentryone
with Apache License 2.0
from sentryone
private IEnumerable<StatementSyntax> GetPropertyreplacedertionBodyStatements(IIndexerModel indexer, ClreplacedModel sourceModel)
{
var paramExpressions = indexer.Parameters.Select(param => replacedignmentValueHelper.GetDefaultreplacedignmentValue(param.TypeInfo, sourceModel.SemanticModel, _frameworkSet)).ToArray();
yield return SyntaxFactory.LocalDeclarationStatement(
SyntaxFactory.VariableDeclaration(
SyntaxFactory.IdentifierName(Strings.Create_var))
.WithVariables(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier(Strings.ReadWritePropertyGenerationStrategy_GetPropertyreplacedertionBodyStatements_testValue))
.WithInitializer(
SyntaxFactory.EqualsValueClause(
replacedignmentValueHelper.GetDefaultreplacedignmentValue(indexer.TypeInfo, sourceModel.SemanticModel, _frameworkSet))))));
yield return _frameworkSet.TestFramework.replacedertIsInstanceOf(Generate.IndexerAccess(sourceModel.TargetInstance, paramExpressions), indexer.TypeInfo.ToTypeSyntax(_frameworkSet.Context));
yield return SyntaxFactory.ExpressionStatement(SyntaxFactory.replacedignmentExpression(SyntaxKind.SimplereplacedignmentExpression, Generate.IndexerAccess(sourceModel.TargetInstance, paramExpressions), SyntaxFactory.IdentifierName(Strings.ReadWritePropertyGenerationStrategy_GetPropertyreplacedertionBodyStatements_testValue)));
yield return _frameworkSet.TestFramework.replacedertEqual(Generate.IndexerAccess(sourceModel.TargetInstance, paramExpressions), SyntaxFactory.IdentifierName(Strings.ReadWritePropertyGenerationStrategy_GetPropertyreplacedertionBodyStatements_testValue));
}
19
Source : EnumerableGenerationStrategy.cs
with Apache License 2.0
from sentryone
with Apache License 2.0
from sentryone
private IEnumerable<StatementSyntax> GetBodyStatements(ClreplacedModel sourceModel, IInterfaceModel interfaceModel)
{
ITypeSymbol enumerableTypeSymbol = sourceModel.TypeSymbol;
if (interfaceModel.IsGeneric)
{
Debug.replacedert(interfaceModel.GenericTypes.Count == 1, "Expecting one type argument for IEnumerable");
enumerableTypeSymbol = interfaceModel.GenericTypes.First();
}
yield return SyntaxHelper.CreateVariableDeclaration(
sourceModel.TypeSymbol.ToTypeSyntax(FrameworkSet.Context),
"enumerable",
SyntaxFactory.DefaultExpression(sourceModel.TypeSyntax))
.AsLocalVariableDeclarationStatementSyntax();
yield return SyntaxHelper.CreateVariableDeclaration(
SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)),
"expectedCount",
SyntaxFactory.LiteralExpression(SyntaxKind.NumerireplacederalExpression, SyntaxFactory.Literal(-1)))
.AsLocalVariableDeclarationStatementSyntax();
yield return SyntaxHelper.CreateVariableDeclaration(
SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)),
"actualCount",
SyntaxFactory.LiteralExpression(SyntaxKind.NumerireplacederalExpression, SyntaxFactory.Literal(0)))
.AsLocalVariableDeclarationStatementSyntax();
yield return SyntaxFactory.UsingStatement(
SyntaxFactory.Block(
FrameworkSet.TestFramework.replacedertNotNull(SyntaxFactory.IdentifierName("enumerator")),
SyntaxFactory.WhileStatement(
SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("enumerator"),
SyntaxFactory.IdentifierName("MoveNext"))),
SyntaxFactory.Block(
SyntaxFactory.ExpressionStatement(
SyntaxFactory.PostfixUnaryExpression(
SyntaxKind.PostIncrementExpression,
SyntaxFactory.IdentifierName("actualCount"))),
FrameworkSet.TestFramework.replacedertIsInstanceOf(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("enumerator"),
SyntaxFactory.IdentifierName("Current")),
enumerableTypeSymbol.ToTypeSyntax(FrameworkSet.Context))))))
.WithDeclaration(
SyntaxHelper.CreateVariableDeclaration("enumerator", SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("enumerable"),
SyntaxFactory.IdentifierName("GetEnumerator")))));
yield return FrameworkSet.TestFramework.replacedertEqual(SyntaxFactory.IdentifierName("actualCount"), SyntaxFactory.IdentifierName("expectedCount"));
}
19
Source : CanCallMethodGenerationStrategy.cs
with Apache License 2.0
from sentryone
with Apache License 2.0
from sentryone
public IEnumerable<MethodDeclarationSyntax> Create(IMethodModel method, ClreplacedModel model)
{
if (method is null)
{
throw new ArgumentNullException(nameof(method));
}
if (model is null)
{
throw new ArgumentNullException(nameof(model));
}
var methodName = string.Format(CultureInfo.InvariantCulture, "CanCall{0}", model.GetMethodUniqueName(method));
var generatedMethod = _frameworkSet.TestFramework.CreateTestMethod(methodName, method.IsAsync, model.IsStatic);
var paramExpressions = new List<CSharpSyntaxNode>();
foreach (var parameter in method.Parameters)
{
if (parameter.Node.Modifiers.Any(x => x.Kind() == SyntaxKind.OutKeyword))
{
paramExpressions.Add(SyntaxFactory.Argument(SyntaxFactory.DeclarationExpression(SyntaxFactory.IdentifierName(Strings.Create_var), SyntaxFactory.SingleVariableDesignation(SyntaxFactory.Identifier(parameter.Name)))).WithRefKindKeyword(SyntaxFactory.Token(SyntaxKind.OutKeyword)));
}
else
{
var defaultreplacedignmentValue = replacedignmentValueHelper.GetDefaultreplacedignmentValue(parameter.TypeInfo, model.SemanticModel, _frameworkSet);
generatedMethod = generatedMethod.AddBodyStatements(SyntaxFactory.LocalDeclarationStatement(
SyntaxFactory.VariableDeclaration(SyntaxFactory.IdentifierName(Strings.Create_var))
.WithVariables(SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(parameter.Name))
.WithInitializer(SyntaxFactory.EqualsValueClause(defaultreplacedignmentValue))))));
if (parameter.Node.Modifiers.Any(x => x.Kind() == SyntaxKind.RefKeyword))
{
paramExpressions.Add(SyntaxFactory.Argument(SyntaxFactory.IdentifierName(parameter.Name)).WithRefKindKeyword(SyntaxFactory.Token(SyntaxKind.RefKeyword)));
}
else
{
paramExpressions.Add(SyntaxFactory.IdentifierName(parameter.Name));
}
}
}
var methodCall = method.Invoke(model, false, _frameworkSet, paramExpressions.ToArray());
bool requiresInstance = false;
if (method.IsAsync)
{
if (model.SemanticModel.GetSymbolInfo(method.Node.ReturnType).Symbol is INamedTypeSymbol type)
{
requiresInstance = type.TypeArguments.Any();
}
}
else
{
requiresInstance = !method.IsVoid;
}
StatementSyntax bodyStatement;
if (requiresInstance)
{
bodyStatement = SyntaxFactory.LocalDeclarationStatement(
SyntaxFactory.VariableDeclaration(
SyntaxFactory.IdentifierName(Strings.Create_var))
.WithVariables(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier(Strings.CanCallMethodGenerationStrategy_Create_result))
.WithInitializer(
SyntaxFactory.EqualsValueClause(methodCall)))));
}
else
{
bodyStatement = SyntaxFactory.ExpressionStatement(methodCall);
}
generatedMethod = generatedMethod.AddBodyStatements(bodyStatement);
generatedMethod = generatedMethod.AddBodyStatements(_frameworkSet.TestFramework.replacedertFail(Strings.PlaceholderreplacedertionMessage));
yield return generatedMethod;
}
19
Source : MultiConstructorInitializedPropertyGenerationStrategy.cs
with Apache License 2.0
from sentryone
with Apache License 2.0
from sentryone
private IEnumerable<StatementSyntax> GetPropertyreplacedertionBodyStatements(IPropertyModel property, ClreplacedModel model)
{
foreach (var targetConstructor in model.Constructors.Where(x => x.Parameters.Any(p => string.Equals(p.Name, property.Name, StringComparison.OrdinalIgnoreCase))))
{
var tokenList = new List<SyntaxNodeOrToken>();
foreach (var parameter in targetConstructor.Parameters)
{
if (tokenList.Count > 0)
{
tokenList.Add(SyntaxFactory.Token(SyntaxKind.CommaToken));
}
tokenList.Add(SyntaxFactory.Argument(SyntaxFactory.IdentifierName(model.GetConstructorParameterFieldName(parameter))));
}
var objectCreation = SyntaxFactory.ObjectCreationExpression(model.TypeSyntax).WithArgumentList(SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList<ArgumentSyntax>(tokenList)));
var replacedignment = SyntaxFactory.replacedignmentExpression(
SyntaxKind.SimplereplacedignmentExpression,
model.TargetInstance,
objectCreation);
yield return SyntaxFactory.ExpressionStatement(replacedignment);
var parameterName = model.Constructors.SelectMany(x => x.Parameters).First(x => string.Equals(x.Name, property.Name, StringComparison.OrdinalIgnoreCase));
var fieldName = model.GetConstructorParameterFieldName(parameterName);
yield return _frameworkSet.TestFramework.replacedertEqual(Generate.PropertyAccess(model.TargetInstance, property.Name), SyntaxFactory.IdentifierName(fieldName));
}
}
19
Source : NotifyPropertyChangedGenerationStrategy.cs
with Apache License 2.0
from sentryone
with Apache License 2.0
from sentryone
private IEnumerable<StatementSyntax> GetPropertyreplacedertionBodyStatements(IPropertyModel property, ClreplacedModel sourceModel, bool withDefaults)
{
var propertyLambda = SyntaxFactory.Argument(
SyntaxFactory.SimpleLambdaExpression(
SyntaxFactory.Parameter(SyntaxFactory.Identifier(Strings.Identifier_x)),
SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(Strings.Identifier_x), SyntaxFactory.IdentifierName(property.Name))));
var argumentList = new List<SyntaxNodeOrToken> { propertyLambda };
if (withDefaults)
{
argumentList.Add(SyntaxFactory.Token(SyntaxKind.CommaToken));
argumentList.Add(SyntaxFactory.Argument(replacedignmentValueHelper.GetDefaultreplacedignmentValue(property.TypeInfo, sourceModel.SemanticModel, _frameworkSet)));
argumentList.Add(SyntaxFactory.Token(SyntaxKind.CommaToken));
argumentList.Add(SyntaxFactory.Argument(replacedignmentValueHelper.GetDefaultreplacedignmentValue(property.TypeInfo, sourceModel.SemanticModel, _frameworkSet)));
}
yield return SyntaxFactory.ExpressionStatement(
SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("_testClreplaced"), SyntaxFactory.IdentifierName("CheckProperty")))
.WithArgumentList(SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList<ArgumentSyntax>(argumentList))));
}
19
Source : ReadWritePropertyGenerationStrategy.cs
with Apache License 2.0
from sentryone
with Apache License 2.0
from sentryone
private IEnumerable<StatementSyntax> GetPropertyreplacedertionBodyStatements(IPropertyModel property, ClreplacedModel sourceModel)
{
yield return SyntaxFactory.LocalDeclarationStatement(
SyntaxFactory.VariableDeclaration(
SyntaxFactory.IdentifierName(Strings.Create_var))
.WithVariables(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier(Strings.ReadWritePropertyGenerationStrategy_GetPropertyreplacedertionBodyStatements_testValue))
.WithInitializer(
SyntaxFactory.EqualsValueClause(
replacedignmentValueHelper.GetDefaultreplacedignmentValue(property.TypeInfo, sourceModel.SemanticModel, _frameworkSet))))));
var target = property.IsStatic ? sourceModel.TypeSyntax : sourceModel.TargetInstance;
yield return SyntaxFactory.ExpressionStatement(SyntaxFactory.replacedignmentExpression(SyntaxKind.SimplereplacedignmentExpression, Generate.PropertyAccess(target, property.Name), SyntaxFactory.IdentifierName(Strings.ReadWritePropertyGenerationStrategy_GetPropertyreplacedertionBodyStatements_testValue)));
yield return _frameworkSet.TestFramework.replacedertEqual(Generate.PropertyAccess(target, property.Name), SyntaxFactory.IdentifierName(Strings.ReadWritePropertyGenerationStrategy_GetPropertyreplacedertionBodyStatements_testValue));
}
19
Source : WriteOnlyPropertyGenerationStrategy.cs
with Apache License 2.0
from sentryone
with Apache License 2.0
from sentryone
private IEnumerable<StatementSyntax> GetPropertyreplacedertionBodyStatements(IPropertyModel property, ClreplacedModel sourceModel)
{
var target = property.IsStatic ? sourceModel.TypeSyntax : sourceModel.TargetInstance;
var defaultreplacedignmentValue = replacedignmentValueHelper.GetDefaultreplacedignmentValue(property.TypeInfo, sourceModel.SemanticModel, _frameworkSet);
yield return SyntaxFactory.ExpressionStatement(SyntaxFactory.replacedignmentExpression(SyntaxKind.SimplereplacedignmentExpression, Generate.PropertyAccess(target, property.Name), defaultreplacedignmentValue));
yield return _frameworkSet.TestFramework.replacedertFail(Strings.PlaceholderreplacedertionMessage);
}
19
Source : XUnitTestFramework.cs
with Apache License 2.0
from sentryone
with Apache License 2.0
from sentryone
public StatementSyntax replacedertGreaterThan(ExpressionSyntax actual, ExpressionSyntax expected)
{
if (actual == null)
{
throw new ArgumentNullException(nameof(actual));
}
if (expected == null)
{
throw new ArgumentNullException(nameof(expected));
}
return SyntaxFactory.ExpressionStatement(replacedertCall("True").WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SingletonSeparatedList<ArgumentSyntax>(
SyntaxFactory.Argument(
SyntaxFactory.BinaryExpression(
SyntaxKind.GreaterThanExpression, actual, expected))))));
}
19
Source : XUnitTestFramework.cs
with Apache License 2.0
from sentryone
with Apache License 2.0
from sentryone
public StatementSyntax replacedertIsInstanceOf(ExpressionSyntax value, TypeSyntax type)
{
if (value == null)
{
throw new ArgumentNullException(Strings.MsTestTestFramework_CreateTestCaseMethod_value);
}
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
return SyntaxFactory.ExpressionStatement(SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("replacedert"),
SyntaxFactory.GenericName(SyntaxFactory.Identifier(Strings.XUnitTestFramework_replacedertIsInstanceOf_IsType))
.WithTypeArgumentList(SyntaxFactory.TypeArgumentList(SyntaxFactory.SingletonSeparatedList(type)))))
.WithArgumentList(Generate.Arguments(value)));
}
19
Source : Generate.cs
with Apache License 2.0
from sentryone
with Apache License 2.0
from sentryone
public static BaseMethodDeclarationSyntax SetupMethod(ClreplacedModel model, string targetTypeName, IFrameworkSet frameworkSet, ref ClreplacedDeclarationSyntax clreplacedDeclaration)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (frameworkSet == null)
{
throw new ArgumentNullException(nameof(frameworkSet));
}
if (clreplacedDeclaration == null)
{
throw new ArgumentNullException(nameof(clreplacedDeclaration));
}
if (string.IsNullOrWhiteSpace(targetTypeName))
{
throw new ArgumentNullException(nameof(targetTypeName));
}
var setupMethod = frameworkSet.TestFramework.CreateSetupMethod(targetTypeName);
var parametersEmitted = new HashSet<string>();
// generate fields for each constructor parameter
foreach (var parameterModel in model.Constructors.SelectMany(x => x.Parameters))
{
if (!parametersEmitted.Add(parameterModel.Name))
{
continue;
}
var fieldName = model.GetConstructorParameterFieldName(parameterModel);
var variable = SyntaxFactory.VariableDeclaration(parameterModel.TypeInfo.ToTypeSyntax(frameworkSet.Context))
.AddVariables(SyntaxFactory.VariableDeclarator(fieldName));
var field = SyntaxFactory.FieldDeclaration(variable)
.AddModifiers(SyntaxFactory.Token(SyntaxKind.PrivateKeyword));
clreplacedDeclaration = clreplacedDeclaration.AddMembers(field);
var defaultExpression = replacedignmentValueHelper.GetDefaultreplacedignmentValue(parameterModel.TypeInfo, model.SemanticModel, frameworkSet);
setupMethod = setupMethod.AddBodyStatements(SyntaxFactory.ExpressionStatement(
SyntaxFactory.replacedignmentExpression(
SyntaxKind.SimplereplacedignmentExpression,
SyntaxFactory.IdentifierName(fieldName),
defaultExpression)));
}
return setupMethod;
}
19
Source : CanConstructMultiConstructorGenerationStrategy.cs
with Apache License 2.0
from sentryone
with Apache License 2.0
from sentryone
public IEnumerable<MethodDeclarationSyntax> Create(ClreplacedModel method, ClreplacedModel model)
{
if (method is null)
{
throw new ArgumentNullException(nameof(method));
}
if (model is null)
{
throw new ArgumentNullException(nameof(model));
}
var generatedMethod = _frameworkSet.TestFramework.CreateTestMethod("CanConstruct", false, false);
bool isFirst = true;
foreach (var constructor in model.Constructors)
{
var tokenList = constructor.Parameters.Select(parameter => SyntaxFactory.IdentifierName(model.GetConstructorParameterFieldName(parameter))).Cast<ExpressionSyntax>().ToList();
var creationExpression = Generate.ObjectCreation(model.TypeSyntax, tokenList.ToArray());
if (isFirst)
{
var variables = SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(Strings.CanConstructMultiConstructorGenerationStrategy_Create_instance)).WithInitializer(SyntaxFactory.EqualsValueClause(creationExpression)));
generatedMethod = generatedMethod.AddBodyStatements(SyntaxFactory.LocalDeclarationStatement(SyntaxFactory.VariableDeclaration(SyntaxFactory.IdentifierName(Strings.Create_var)).WithVariables(variables)));
isFirst = false;
}
else
{
generatedMethod = generatedMethod.AddBodyStatements(SyntaxFactory.ExpressionStatement(SyntaxFactory.replacedignmentExpression(SyntaxKind.SimplereplacedignmentExpression, SyntaxFactory.IdentifierName(Strings.CanConstructMultiConstructorGenerationStrategy_Create_instance), creationExpression)));
}
generatedMethod = generatedMethod.AddBodyStatements(_frameworkSet.TestFramework.replacedertNotNull(SyntaxFactory.IdentifierName(Strings.CanConstructMultiConstructorGenerationStrategy_Create_instance)));
}
yield return generatedMethod;
}
19
Source : CoreGenerator.cs
with Apache License 2.0
from sentryone
with Apache License 2.0
from sentryone
private static TypeDeclarationSyntax EnsureAllConstructorParametersHaveFields(IFrameworkSet frameworkSet, ClreplacedModel clreplacedModel, TypeDeclarationSyntax targetType)
{
var setupMethod = frameworkSet.TestFramework.CreateSetupMethod(frameworkSet.GetTargetTypeName(clreplacedModel, true));
BaseMethodDeclarationSyntax foundMethod = null, updatedMethod = null;
if (setupMethod is MethodDeclarationSyntax methodSyntax)
{
updatedMethod = foundMethod = targetType.Members.OfType<MethodDeclarationSyntax>().FirstOrDefault(x => x.Identifier.Text == methodSyntax.Identifier.Text && x.ParameterList.Parameters.Count == 0);
}
else if (setupMethod is ConstructorDeclarationSyntax)
{
updatedMethod = foundMethod = targetType.Members.OfType<ConstructorDeclarationSyntax>().FirstOrDefault(x => x.ParameterList.Parameters.Count == 0);
}
if (foundMethod != null)
{
var parametersEmitted = new HashSet<string>();
var allFields = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
var fields = new List<FieldDeclarationSyntax>();
foreach (var parameterModel in clreplacedModel.Constructors.SelectMany(x => x.Parameters))
{
allFields.Add(clreplacedModel.GetConstructorParameterFieldName(parameterModel));
}
// generate fields for each constructor parameter that doesn't have an existing field
foreach (var parameterModel in clreplacedModel.Constructors.SelectMany(x => x.Parameters))
{
if (!parametersEmitted.Add(parameterModel.Name))
{
continue;
}
var fieldName = clreplacedModel.GetConstructorParameterFieldName(parameterModel);
var fieldExists = targetType.Members.OfType<FieldDeclarationSyntax>().Any(x => x.Declaration.Variables.Any(v => v.Identifier.Text == fieldName));
if (!fieldExists)
{
var variable = SyntaxFactory.VariableDeclaration(parameterModel.TypeInfo.ToTypeSyntax(frameworkSet.Context))
.AddVariables(SyntaxFactory.VariableDeclarator(fieldName));
var field = SyntaxFactory.FieldDeclaration(variable)
.AddModifiers(SyntaxFactory.Token(SyntaxKind.PrivateKeyword));
fields.Add(field);
var defaultExpression = replacedignmentValueHelper.GetDefaultreplacedignmentValue(parameterModel.TypeInfo, clreplacedModel.SemanticModel, frameworkSet);
var statement = SyntaxFactory.ExpressionStatement(SyntaxFactory.replacedignmentExpression(SyntaxKind.SimplereplacedignmentExpression, SyntaxFactory.IdentifierName(fieldName), defaultExpression));
var body = updatedMethod.Body ?? SyntaxFactory.Block();
SyntaxList<StatementSyntax> newStatements;
var index = body.Statements.LastIndexOf(x => x.DescendantNodes().OfType<replacedignmentExpressionSyntax>().Any(a => a.Left is IdentifierNameSyntax identifierName && allFields.Contains(identifierName.Identifier.Text)));
if (index >= 0 && index < body.Statements.Count - 1)
{
newStatements = body.Statements.Insert(index + 1, statement);
}
else
{
newStatements = body.Statements.Add(statement);
}
updatedMethod = updatedMethod.WithBody(body.WithStatements(newStatements));
}
}
if (fields.Any())
{
targetType = targetType.ReplaceNode(foundMethod, updatedMethod);
var existingField = targetType.Members.OfType<FieldDeclarationSyntax>().LastOrDefault();
if (existingField != null)
{
targetType = targetType.InsertNodesAfter(existingField, fields);
}
else
{
targetType = targetType.AddMembers(fields.OfType<MemberDeclarationSyntax>().ToArray());
}
}
}
return targetType;
}
See More Examples