Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExpressionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax)

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 7

19 Source : MethodInstrumentation.cs
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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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