Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IdentifierName(Microsoft.CodeAnalysis.SyntaxToken)

Here are the examples of the csharp api Microsoft.CodeAnalysis.CSharp.SyntaxFactory.IdentifierName(Microsoft.CodeAnalysis.SyntaxToken) taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

155 Examples 7

19 Source : CodeFixProvider.cs
with GNU General Public License v3.0
from AminEsmaeily

private static async Task<Doreplacedent> AddTryCatchAsync(CodeFixContext context, CancellationToken cancellationToken)
        {
            var doreplacedent = context.Doreplacedent;
            var root = await doreplacedent.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
            var diagnostic = context.Diagnostics.First();
            var diagnosticSpan = diagnostic.Location.SourceSpan;
            SyntaxToken invocation = root.FindToken(diagnosticSpan.Start);

            InvocationExpressionSyntax completeMethod = await GetInvokedMethodAsync(context, cancellationToken);

            SemanticModel sm = await doreplacedent.GetSemanticModelAsync();
            var calleeAttributes = NotHandledreplacedyzer.GetAllAttributes(sm, completeMethod);
            var catchedAttributes = await GetCallerAttributesAsync(context, cancellationToken);
            var tryElement = invocation.Parent.FirstAncestorOrSelf<TryStatementSyntax>();

            var oldRoot = await doreplacedent.GetSyntaxRootAsync(cancellationToken);
            SyntaxNode newRoot = null;

            var catches = new List<CatchClauseSyntax>();
            foreach (var attrib in calleeAttributes)
            {
                var skip = false;
                var typeParameter = attrib.AttributeData.ConstructorArguments.FirstOrDefault(f => f.Type.TypeKind == TypeKind.Clreplaced);
                if (typeParameter.Type == null)
                    continue;

                var exceptionName = typeParameter.Value.ToString();
                foreach (var catchedAttribute in catchedAttributes)
                {
                    var typeOfExp = catchedAttribute.DescendantNodes().OfType<TypeOfExpressionSyntax>();
                    if (typeOfExp == null || !typeOfExp.Any())
                    {
                        skip = true;
                        continue;
                    }

                    var identifier = typeOfExp.First().DescendantNodes().OfType<IdentifierNameSyntax>();
                    if (identifier == null || !identifier.Any())
                    {
                        skip = true;
                        continue;
                    }

                    var semanticType = sm.GetTypeInfo(identifier.First()).Type;
                    if (semanticType != null && exceptionName.Equals(semanticType.ToString()))
                    {
                        skip = true;
                        break;
                    }
                }

                if (skip)
                    continue;

                bool createCatchPart = tryElement == null;
                if (!createCatchPart)
                {
                    var exists = false;
                    foreach (var f in tryElement.Catches)
                    {
                        if (f.Declaration != null)
                            foreach (var k in f.Declaration.DescendantNodes().OfType<IdentifierNameSyntax>())
                            {
                                var typeInfo = sm.GetTypeInfo(k);
                                if (typeInfo.Type == null)
                                    continue;

                                if (typeInfo.Type.ToString().Equals(typeof(Exception).FullName) ||
                                    typeInfo.Type.ToString().Equals(exceptionName))
                                {
                                    exists = true;
                                    break;
                                }
                            }

                        if (exists)
                            break;
                    }

                    createCatchPart = !exists;
                }
                
                if (createCatchPart)
                {
                    IdentifierNameSyntax catchTypeSyntax = SyntaxFactory.IdentifierName(exceptionName);
                    var catchDeclaration = SyntaxFactory.CatchDeclaration(catchTypeSyntax, new SyntaxToken());
                    var blockSyntax = SyntaxFactory.Block();
                    var catchPart = SyntaxFactory.CatchClause(catchDeclaration, null, blockSyntax);

                    catches.Add(catchPart);
                }
            }

            try
            {
                if (tryElement != null)
                    newRoot = oldRoot.InsertNodesAfter(tryElement.Catches.Last(), catches);
                else
                {
                    var body = completeMethod.FirstAncestorOrSelf<StatementSyntax>();
                    var expressionIndex = body.Parent.ChildNodesAndTokens().ToList().IndexOf(body);
                    BlockSyntax block = SyntaxFactory.Block(body);

                    TryStatementSyntax trySyntax = SyntaxFactory.TryStatement(block, new SyntaxList<CatchClauseSyntax>(), null);
                    trySyntax = trySyntax.AddCatches(catches.ToArray()).NormalizeWhitespace(elasticTrivia:true);

                    newRoot = oldRoot.ReplaceNode(body, trySyntax);
                }
            }
            catch(Exception ex)
            {
                Debug.WriteLine(ex);
            }

            return doreplacedent.WithSyntaxRoot(newRoot);
        }

19 Source : CodeFixProvider.cs
with GNU General Public License v3.0
from AminEsmaeily

private static async Task<Doreplacedent> AddAnnotationAsync(CodeFixContext context, CancellationToken cancellationToken)
        {
            var doreplacedent = context.Doreplacedent;
            var root = await doreplacedent.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
            var diagnostic = context.Diagnostics.First();
            var diagnosticSpan = diagnostic.Location.SourceSpan;
            SemanticModel sm = await doreplacedent.GetSemanticModelAsync();
            SyntaxToken invocation = root.FindToken(diagnosticSpan.Start);
            InvocationExpressionSyntax completeMethod = await GetInvokedMethodAsync(context, cancellationToken);

            MethodDeclarationSyntax callerMethodContainer = (MethodDeclarationSyntax)invocation.Parent.AncestorsAndSelf().OfType<MethodDeclarationSyntax>().FirstOrDefault();

            var calleeAttributes = NotHandledreplacedyzer.GetAllAttributes(sm, completeMethod);
            var catchedAttributes = await GetCallerAttributesAsync(context, cancellationToken);
            var tryElement = invocation.Parent.FirstAncestorOrSelf<TryStatementSyntax>();

            var newAttributes = callerMethodContainer.AttributeLists;
            foreach(var attrib in calleeAttributes)
            {
                var skip = false;
                var typeParameter = attrib.AttributeData.ConstructorArguments.FirstOrDefault(f => f.Type.TypeKind == TypeKind.Clreplaced);
                if (typeParameter.Type == null)
                    continue;

                var exceptionName = typeParameter.Value.ToString();
                foreach (var catchedAttribute in catchedAttributes)
                {
                    var typeOfExp = catchedAttribute.DescendantNodes().OfType<TypeOfExpressionSyntax>();
                    if (typeOfExp == null || !typeOfExp.Any())
                    {
                        skip = true;
                        continue;
                    }

                    var identifier = typeOfExp.First().DescendantNodes().OfType<IdentifierNameSyntax>();
                    if (identifier == null || !identifier.Any())
                    {
                        skip = true;
                        continue;
                    }

                    var semanticType = sm.GetTypeInfo(identifier.First()).Type;
                    if (semanticType != null && exceptionName.Equals(semanticType.ToString()))
                    {
                        skip = true;
                        break;
                    }
                }

                if (!skip && tryElement != null)
                {
                    foreach (var f in tryElement.Catches)
                    {
                        if (f.Declaration != null)
                            foreach (var k in f.Declaration.DescendantNodes().OfType<IdentifierNameSyntax>())
                            {
                                var typeInfo = sm.GetTypeInfo(k);
                                if (typeInfo.Type == null)
                                    continue;

                                if (typeInfo.Type.ToString().Equals(typeof(Exception).FullName) ||
                                    typeInfo.Type.ToString().Equals(exceptionName))
                                {
                                    skip = true;
                                    break;
                                }
                            }

                        if (skip)
                            break;
                    }
                }

                if (skip)
                    continue;

                var attributeName = typeof(ThrowsExceptionAttribute).FullName.Substring(0, typeof(ThrowsExceptionAttribute).FullName.IndexOf("Attribute"));
                newAttributes = newAttributes.Add(
                    SyntaxFactory.AttributeList(
                        SyntaxFactory.SingletonSeparatedList<AttributeSyntax>(
                        SyntaxFactory.Attribute(
                            SyntaxFactory.IdentifierName(attributeName)).WithArgumentList(
                            SyntaxFactory.AttributeArgumentList(
                                SyntaxFactory.SingletonSeparatedList<AttributeArgumentSyntax>(
                                SyntaxFactory.AttributeArgument(
                                    SyntaxFactory.TypeOfExpression(
                                    SyntaxFactory.IdentifierName(exceptionName)))))))));
            }

            try
            {
                return doreplacedent.WithSyntaxRoot(root.ReplaceNode(callerMethodContainer, callerMethodContainer.WithAttributeLists(newAttributes)));
            }
            catch(Exception ex)
            {
                Debug.WriteLine(ex);
                return doreplacedent.WithSyntaxRoot(root);
            }
        }

19 Source : CSharpCodeProvider.cs
with MIT License
from arasplm

private string CreateSourceCode(string parentClreplacedName, SyntaxNode wrapperRoot)
		{
			CompilationUnitSyntax wrapperCompilationUnitSyntax = wrapperRoot as CompilationUnitSyntax;
			NamespaceDeclarationSyntax wrapperNamespace = wrapperCompilationUnitSyntax.DescendantNodes().OfType<NamespaceDeclarationSyntax>().First();
			UsingDirectiveSyntax[] wrapperUsings = wrapperCompilationUnitSyntax.Usings.OfType<UsingDirectiveSyntax>().ToArray();

			CompilationUnitSyntax sourceCompilationUnitSyntax = CompilationUnit()
				.AddUsings(wrapperUsings)
				.WithMembers(
					SingletonList<MemberDeclarationSyntax>(
						NamespaceDeclaration(
							IdentifierName(wrapperNamespace.Name.ToString()))
						.WithMembers(
							SingletonList<MemberDeclarationSyntax>(
								ClreplacedDeclaration(parentClreplacedName)
								.WithModifiers(
									TokenList(
										new[]{
											Token(SyntaxKind.PublicKeyword),
											Token(SyntaxKind.PartialKeyword)}))
								.WithMembers(
									SingletonList<MemberDeclarationSyntax>(
										IncompleteMember(
											IdentifierName("$(MethodCode)"))))))))
				.NormalizeWhitespace();

			return sourceCompilationUnitSyntax.ToFullString();
		}

19 Source : AvoidAsyncVoidMethodsCodeFix.cs
with MIT License
from edumserrano

private Task<Doreplacedent> ChangeReturnTypeToTask(CodeFixContext context, SyntaxNode root, MethodDeclarationSyntax methodDeclaration)
        {
            var newReturnType = SyntaxFactory.IdentifierName("Task");
            var newMethodDeclaration = methodDeclaration.WithReturnType(newReturnType);
            return context.GetDoreplacedentWithReplacedNode(methodDeclaration, newMethodDeclaration, root);
        }

19 Source : ConfigureAwaitCodeFixProvider.cs
with MIT License
from holthe

private static async Task<Doreplacedent> AppendConfigureAwaitFalseAsync(Doreplacedent doreplacedent, AwaitExpressionSyntax node, CancellationToken cancellationToken)
        {
            LiteralExpressionSyntax falseExpression;
            InvocationExpressionSyntax fixedInvocationExpression;

            var root = await doreplacedent.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
            var expression = node.GetInvocationExpressionSyntax();
            if (expression != null)
            {
                var memberAccess = expression.Expression as MemberAccessExpressionSyntax;
                if (memberAccess == null || !memberAccess.HasIdentifier(ConfigureAwaitreplacedyzer.ConfigureAwaitIdentifier))
                {
                    falseExpression = SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression);
                    fixedInvocationExpression = SyntaxFactory.InvocationExpression(
                        SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, expression, SyntaxFactory.IdentifierName(ConfigureAwaitreplacedyzer.ConfigureAwaitIdentifier)),
                        SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(new[] { SyntaxFactory.Argument(falseExpression) })));
                    return doreplacedent.WithSyntaxRoot(root.ReplaceNode(expression, fixedInvocationExpression.WithAdditionalAnnotations(Formatter.Annotation)));
                }

                if (expression.IsFirstArgumentFalse())
                {
                    throw new InvalidOperationException();
                }

                falseExpression = SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression);
                fixedInvocationExpression = SyntaxFactory.InvocationExpression(
                    expression.Expression,
                    SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(new[] { SyntaxFactory.Argument(falseExpression) })));
                return doreplacedent.WithSyntaxRoot(root.ReplaceNode(expression, fixedInvocationExpression.WithAdditionalAnnotations(Formatter.Annotation)));
            }

            falseExpression = SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression);
            fixedInvocationExpression = SyntaxFactory.InvocationExpression(
                SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, node.Expression, SyntaxFactory.IdentifierName(ConfigureAwaitreplacedyzer.ConfigureAwaitIdentifier)),
                SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(new[] { SyntaxFactory.Argument(falseExpression) })));
            return doreplacedent.WithSyntaxRoot(root.ReplaceNode(node.Expression, fixedInvocationExpression.WithAdditionalAnnotations(Formatter.Annotation)));
        }

19 Source : Extensions.cs
with GNU General Public License v3.0
from ilchenkob

public static ClreplacedDeclarationSyntax AddDataContractAttribute(this ClreplacedDeclarationSyntax clreplacedDeclaration)
    {
      return clreplacedDeclaration.AddAttributeLists(new[]
      {
        SyntaxFactory.AttributeList(SyntaxFactory.SingletonSeparatedList(
          SyntaxFactory.Attribute(SyntaxFactory.IdentifierName(Constants.Attribute.DataContract))))
      });
    }

19 Source : Extensions.cs
with GNU General Public License v3.0
from ilchenkob

public static PropertyDeclarationSyntax AddDataMemberAttribute(this PropertyDeclarationSyntax prop)
    {
      return prop.AddAttributeLists(new[]
      {
        SyntaxFactory.AttributeList(SyntaxFactory.SingletonSeparatedList(
          SyntaxFactory.Attribute(SyntaxFactory.IdentifierName(Constants.Attribute.DataMember))))
      });
    }

19 Source : Extensions.cs
with GNU General Public License v3.0
from ilchenkob

public static PropertyDeclarationSyntax AddJsonPropertyAttribute(this PropertyDeclarationSyntax prop)
    {
      var propName = prop.Identifier.ValueText;
      return prop.AddAttributeLists(new[]
      {
        SyntaxFactory.AttributeList(SyntaxFactory.SingletonSeparatedList(
            SyntaxFactory.Attribute(SyntaxFactory.IdentifierName(Constants.Attribute.JsonProperty))
              .WithArgumentList(
                SyntaxFactory.AttributeArgumentList(
                  SyntaxFactory.SingletonSeparatedList(
                    SyntaxFactory.AttributeArgument(
                      SyntaxFactory.LiteralExpression(
                        SyntaxKind.StringLiteralExpression,
                        SyntaxFactory.Literal(propName.ToLowerCamelCase())
                      )
                    )
                  )
                )
              )
          )
        )
      });
    }

19 Source : Utils.cs
with MIT License
from kevin-montrose

internal static T InlineIfInnerCalls<T>(T toReplaceIn, TypeDeclarationSyntax referencesTo)
            where T : SyntaxNode
        {
            var ident = referencesTo.Identifier.ValueText;

            var needReplace =
                toReplaceIn
                    .DescendantNodesAndSelf()
                    .OfType<IfStatementSyntax>()
                    .Where(
                        ret =>
                        {
                            if (!(ret.Condition is InvocationExpressionSyntax i))
                            {
                                return false;
                            }

                            if (i.Expression is MemberAccessExpressionSyntax access)
                            {
                                if (access.Expression is SimpleNameSyntax name && name.Identifier.ValueText == ident)
                                {
                                    return true;
                                }
                            }

                            return false;
                        }
                    )
                    .ToImmutableArray();

            var nextParameterIndex =
                NonNullValue(
                    toReplaceIn
                        .DescendantTokens()
                        .Select(
                            x =>
                            {
                                var valText = x.ValueText;
                                if (!valText.StartsWith("__parameter_"))
                                {
                                    return default(int?);
                                }

                                var tail = valText.Substring("__parameter_".Length);
                                return int.Parse(tail);
                            }
                        )
                        .Where(x => x != null)
                        .Concat(new int?[] { -1 })
                        .Max()
                ) + 1;

            var nextDoneIndex =
                NonNullValue(
                    toReplaceIn
                        .DescendantTokens()
                        .Select(
                            x =>
                            {
                                var valText = x.ValueText;
                                if (!valText.StartsWith("__callDone_"))
                                {
                                    return default(int?);
                                }

                                var tail = valText.Substring("__callDone_".Length);
                                return int.Parse(tail);
                            }
                        )
                        .Where(x => x != null)
                        .Concat(new int?[] { -1 })
                        .Max()
                ) + 1;

            var toReplaceWith = ImmutableDictionary.CreateBuilder<IfStatementSyntax, BlockSyntax>();
            var toReplaceVariables = ImmutableDictionary.CreateBuilder<string, string>();

            var labelName = SyntaxFactory.IdentifierName("__callDone_" + nextDoneIndex);

            foreach (var toReplaceRet in needReplace)
            {
                var toReplace = (InvocationExpressionSyntax)NonNull(toReplaceRet.Condition);

                var calledMethodName = ((MemberAccessExpressionSyntax)toReplace.Expression).Name.Identifier.ValueText;
                var calledMethod = referencesTo.Members.OfType<MethodDeclarationSyntax>().Single(m => m.Identifier.ValueText == calledMethodName);
                var calledMethodBody = NonNull(calledMethod.Body);

                var resVar = SyntaxFactory.IdentifierName("__resultOf_" + calledMethodName);
                var resVarDecl = SyntaxFactory.ParseStatement("System.Boolean " + resVar.Identifier + ";");

                var gotoCallDone = SyntaxFactory.GotoStatement(SyntaxKind.GotoStatement, labelName);
                var gotoLabel = SyntaxFactory.ParseStatement(labelName.Identifier.ValueText + ":");

                var paramsInMethod = calledMethod.ParameterList.Parameters.Select(p => p.Identifier.ValueText).ToImmutableArray();
                var argsToMethod = toReplace.ArgumentList.Arguments.Select(a => a).ToImmutableArray();

                var outParamIndexes = calledMethod.ParameterList.Parameters.Select((a, ix) => (Argument: a, Index: ix)).Where(t => t.Argument.Modifiers.Any(m => m.ValueText == "out")).Select(t => t.Index).ToImmutableArray();

                var paramsInMethodToNewParamsBuilder = ImmutableDictionary.CreateBuilder<string, SyntaxNode>();
                for (var i = 0; i < paramsInMethod.Length; i++)
                {
                    var oldP = paramsInMethod[i];

                    var newP = "__parameter_" + nextParameterIndex;
                    nextParameterIndex++;

                    paramsInMethodToNewParamsBuilder.Add(oldP, SyntaxFactory.IdentifierName(newP));
                }

                var paramsInMethodToNewParams = paramsInMethodToNewParamsBuilder.ToImmutable();

                foreach (var ix in outParamIndexes)
                {
                    var arg = toReplace.ArgumentList.Arguments[ix];
                    var pForArg = paramsInMethod[ix];
                    var argExp = arg.Expression;
                    var argExpIdent = argExp.DescendantTokens().Where(t => t.IsKind(SyntaxKind.IdentifierToken)).Where(v => v.ValueText != "var").ToImmutableArray();
                    var outVar = argExpIdent.Single().ValueText;

                    var mapsTo = paramsInMethodToNewParams[pForArg];

                    toReplaceVariables.Add(outVar, mapsTo.ToFullString());
                }

                var variableUsesInCalledMethodBody =
                    calledMethodBody
                        .DescendantNodesAndSelf()
                        .OfType<IdentifierNameSyntax>()
                        .Where(x => paramsInMethodToNewParamsBuilder.ContainsKey(x.Identifier.ValueText))
                        .ToImmutableArray();

                var calledMethodBodyWithNewPs =
                    calledMethodBody
                        .ReplaceSyntax(
                            variableUsesInCalledMethodBody,
                            (old, partialRewrite) => paramsInMethodToNewParams[((IdentifierNameSyntax)old).Identifier.ValueText].WithTriviaFrom(partialRewrite),
                            Enumerable.Empty<SyntaxToken>(),
                            TakeUpdatedToken,
                            Enumerable.Empty<SyntaxTrivia>(),
                            TakeUpdatedTrivia
                        );

                var retExprs = calledMethodBodyWithNewPs.DescendantNodesAndSelf().OfType<ReturnStatementSyntax>();

                var bodyWithoutRes =
                    calledMethodBodyWithNewPs
                        .ReplaceSyntax(
                            retExprs,
                            (_, old) =>
                            {
                                var oldRet = (ReturnStatementSyntax)old;

                                var oldRetResult = NonNull(oldRet.Expression);

                                var replacedignmentStatement = SyntaxFactory.ParseStatement(resVar.Identifier + " = " + oldRetResult.ToFullString() + ";");
                                replacedignmentStatement = replacedignmentStatement.WithTriviaFrom(oldRet);

                                var withGoto = SyntaxFactory.List(new StatementSyntax[] { replacedignmentStatement, gotoCallDone });

                                var block = SyntaxFactory.Block(withGoto);

                                return block;
                            },
                            Enumerable.Empty<SyntaxToken>(),
                            TakeUpdatedToken,
                            Enumerable.Empty<SyntaxTrivia>(),
                            TakeUpdatedTrivia
                        );

                var ifWithVar =
                    toReplaceRet
                        .ReplaceSyntax(
                            new[] { toReplace },
                            (_, old) => resVar.WithTriviaFrom(old),
                            Enumerable.Empty<SyntaxToken>(),
                            TakeUpdatedToken,
                            Enumerable.Empty<SyntaxTrivia>(),
                            TakeUpdatedTrivia
                        );

                var finalNodes = ImmutableArray.CreateBuilder<SyntaxNode>();

                for (var i = 0; i < paramsInMethod.Length; i++)
                {
                    var oldPDecl = calledMethod.ParameterList.Parameters[i];
                    var oldP = paramsInMethod[i];
                    var newP = paramsInMethodToNewParams[oldP];

                    var type = NonNull(oldPDecl.Type).ToFullString();

                    var initExpression = argsToMethod[i];
                    string initExpressionString;
                    if (initExpression.RefKindKeyword.ValueText == "out")
                    {
                        initExpressionString = "default";
                    }
                    else if (initExpression.RefKindKeyword.ValueText == "in")
                    {
                        initExpressionString = initExpression.Expression.ToFullString();
                    }
                    else
                    {
                        initExpressionString = initExpression.ToFullString();
                    }

                    var statement = SyntaxFactory.ParseStatement(type + " " + newP.ToFullString() + " = (" + initExpressionString + ");");

                    finalNodes.Add(statement);
                }

                finalNodes.AddRange(resVarDecl, bodyWithoutRes, gotoLabel, ifWithVar);

                var replacementBlock = SyntaxFactory.Block(SyntaxFactory.List(finalNodes.ToImmutable()));

                toReplaceWith.Add(toReplaceRet, replacementBlock);
            }

            var replacementMap = toReplaceWith.ToImmutable();

            var ifReplaced =
                toReplaceIn.ReplaceSyntax(
                    replacementMap.Keys,
                    (old, _) =>
                    {
                        var newBlock = replacementMap[(IfStatementSyntax)old];

                        return newBlock;
                    },
                    Enumerable.Empty<SyntaxToken>(),
                    TakeUpdatedToken,
                    Enumerable.Empty<SyntaxTrivia>(),
                    TakeUpdatedTrivia
                );

            var variableReplacementMap = toReplaceVariables.ToImmutable();

            var tokensMayNeedReplacement =
                ifReplaced
                    .DescendantTokens()
                    .Where(t => variableReplacementMap.ContainsKey(t.ValueText))
                    .Where(t => !replacementMap.Values.Any(v => v.DescendantTokens().Contains(t)))
                    .ToImmutableArray();

            var ret =
                ifReplaced.ReplaceTokens(
                    tokensMayNeedReplacement,
                    (old, partialRewrite) =>
                    {
                        var newTokenStr = variableReplacementMap[old.ValueText];
                        var newToken = SyntaxFactory.ParseToken(newTokenStr);

                        return newToken.WithTriviaFrom(partialRewrite);
                    }
                );

            // recurse if we made any changes to handle new references entered
            if (!ret.Equals(toReplaceIn))
            {
                return InlineIfInnerCalls(ret, referencesTo);
            }

            return ret;
        }

19 Source : Utils.cs
with MIT License
from kevin-montrose

internal static T ReplaceIn<T>(T toReplaceIn, ImmutableDictionary<ReturnStatementSyntax, (ParameterListSyntax Parameters, BlockSyntax Statements)> replaceWith)
            where T : SyntaxNode
        {
            var nodesToReplaceBuilder = ImmutableDictionary.CreateBuilder<ReturnStatementSyntax, BlockSyntax>();

            var nextParameterIndex =
                NonNullValue(
                    toReplaceIn
                        .DescendantTokens()
                        .Select(
                            x =>
                            {
                                var valText = x.ValueText;
                                if (!valText.StartsWith("__parameter_"))
                                {
                                    return default(int?);
                                }

                                var tail = valText.Substring("__parameter_".Length);
                                return int.Parse(tail);
                            }
                        )
                        .Where(x => x != null)
                        .Concat(new int?[] { -1 })
                        .Max()
                ) + 1;

            foreach (var kv in replaceWith)
            {
                var toReplaceRet = kv.Key;
                var calledMethodParams = kv.Value.Parameters;
                var calledMethodBody = kv.Value.Statements;

                var toReplace = (InvocationExpressionSyntax)Utils.NonNull(toReplaceRet.Expression);

                // introduce locals to for the "parameters" we're removing
                var localBindings = ImmutableArray.CreateBuilder<StatementSyntax>();
                var updatedMethodBody = calledMethodBody;
                for (var i = 0; i < calledMethodParams.Parameters.Count; i++)
                {
                    var curParam = calledMethodParams.Parameters[i];

                    var newVar = "__parameter_" + nextParameterIndex;
                    nextParameterIndex++;

                    var arg = toReplace.ArgumentList.Arguments[i];
                    var replacedign = "var " + newVar + " = (" + arg.ToFullString() + ");";

                    var replacedignSyntax = SyntaxFactory.ParseStatement(replacedign);
                    localBindings.Add(replacedignSyntax);

                    var newVarSyntax = SyntaxFactory.IdentifierName(newVar);

                    var referToCurParam = updatedMethodBody.DescendantNodesAndSelf().OfType<IdentifierNameSyntax>().Where(x => x.Identifier.ValueText == curParam.Identifier.ValueText).ToImmutableArray();

                    updatedMethodBody = updatedMethodBody.ReplaceNodes(referToCurParam, (_, __) => newVarSyntax);
                }

                var allStatements = localBindings.Concat(updatedMethodBody.Statements);
                var allStatementsList = SyntaxFactory.List(allStatements);
                var block = SyntaxFactory.Block(allStatementsList);

                // also avoid collisions by renaming any other variables introduced
                var variableDeclares = block.DescendantNodesAndSelf().OfType<VariableDeclaratorSyntax>().Select(v => v.Identifier.ValueText).Where(v => !v.StartsWith("__")).ToImmutableHashSet();
                var variableDesignates = block.DescendantNodesAndSelf().OfType<SingleVariableDesignationSyntax>().Select(v => v.Identifier.ValueText).Where(v => !v.StartsWith("__")).ToImmutableHashSet();

                var allVariables = variableDeclares.Union(variableDesignates);

                foreach (var variable in allVariables)
                {
                    var referToVariable = block.DescendantTokens().Where(t => t.ValueText == variable).ToImmutableArray();
                    var newVarToken = SyntaxFactory.ParseToken("__" + variable);

                    block = block.ReplaceTokens(referToVariable, (_, __) => newVarToken);
                }

                block = block.NormalizeWhitespace();

                nodesToReplaceBuilder.Add(toReplaceRet, block);
            }

            var nodesToReplace = nodesToReplaceBuilder.ToImmutable();

            var ret = toReplaceIn.ReplaceNodes(nodesToReplace.Keys, (old, _) => nodesToReplace[old]);

            return NonNull(ret);
        }

19 Source : AutoTemplateAddOperationBase.cs
with Apache License 2.0
from kevin-montrose

protected override string CreateTemplate(Project templateProject)
        {
            var baseClreplacedName = GetOperationName() + "Base";

            var inTemplateFolder = templateProject.Doreplacedents.Where(d => d.Folders?.FirstOrDefault() == TEMPLATE_FOLDER).ToList();
            var implementingTemplateBase =
                inTemplateFolder
                    .Where(
                        d =>
                        {
                            var root = d.GetSyntaxRootAsync().Result;

                            var clreplacedes = root.DescendantNodesAndSelf().OfType<ClreplacedDeclarationSyntax>().ToList();

                            var extendingTemplateBase = clreplacedes.Where(c => c.BaseList != null && c.BaseList.Types.Any(t => (t.Type as SimpleNameSyntax)?.Identifier.ValueText == TEMPLATE_CLreplaced_BASE)).ToList();

                            return extendingTemplateBase.Any();
                        }
                    ).ToList();

            var docWithTemplate =
                implementingTemplateBase
                    .Single(d =>
                    {
                        var root = d.GetSyntaxRootAsync().Result;

                        var clreplacedes = root.DescendantNodesAndSelf().OfType<ClreplacedDeclarationSyntax>().ToList();

                        return clreplacedes.Any(t => t.Identifier.ValueText == baseClreplacedName);
                    }
                    );

            // extract the basic template, which we'll rewrite in the doc
            var template =
                docWithTemplate
                    .GetSyntaxRootAsync().Result
                    .DescendantNodesAndSelf()
                    .OfType<ClreplacedDeclarationSyntax>()
                    .Single(t => t.Identifier.ValueText == baseClreplacedName);

            // remove just the Template base constraint
            var typesSansTemplateBase =
                template.BaseList.Types
                    .Select(t => t.Type)
                    .Where(t => (t as SimpleNameSyntax)?.Identifier.ValueText != TEMPLATE_CLreplaced_BASE)
                    .Select(t => (BaseTypeSyntax)SyntaxFactory.SimpleBaseType(t))
                    .ToList();
            var newBaseTypes = SyntaxFactory.SeparatedList(typesSansTemplateBase);
            var baseListWithoutTemplateBase = SyntaxFactory.BaseList(newBaseTypes);
            var templateWithoutBaseList = template.WithBaseList(baseListWithoutTemplateBase.WithTriviaFrom(template.BaseList));

            // remove all type constraints
            var templateWithoutTypeContraints = templateWithoutBaseList.WithConstraintClauses(SyntaxFactory.List<TypeParameterConstraintClauseSyntax>());

            // read these nodes out now, because we're about to replace them
            var genericParameterList = templateWithoutTypeContraints.DescendantNodesAndSelf().OfType<TypeParameterListSyntax>().First();
            var oldOureplacedem = genericParameterList.Parameters.ElementAt(0);
            var oldEnumerable = genericParameterList.Parameters.ElementAt(1);
            var oldEnumerator = genericParameterList.Parameters.ElementAt(2);

            var newOureplacedem = SyntaxFactory.IdentifierName(OUreplacedEM_TEMPLATE_VAR);
            var newEnumerable = SyntaxFactory.IdentifierName(ENUMERABLE_TEMPLATE_VAR);
            var newEnumerator = SyntaxFactory.IdentifierName(ENUMERATOR_TEMPLATE_VAR);

            // turn into a partial struct
            var templatereplacedtruct =
                SyntaxFactory.ParseSyntaxTree(
                    templateWithoutTypeContraints.ToString().Replace("abstract clreplaced", "public partial struct")
                )
                .GetRoot()
                .DescendantNodesAndSelf()
                .OfType<StructDeclarationSyntax>().Single();
            
            // rewrite all method declarations so that generic parameters are prefixed to avoid collisions
            var withRewrittenMethods = templatereplacedtruct;
            var genericParamPrefix = "T" + GetOperationName() + "_";
            var replacements = new Dictionary<SyntaxNode, SyntaxNode>();

            foreach(var mtd in withRewrittenMethods.DescendantNodesAndSelf().OfType<MethodDeclarationSyntax>().Where(t => !t.HasAnnotation(METHOD_GENERIC_PARAMS_PREFIXED)))
            {
                var genArgs = mtd.TypeParameterList;
                if (genArgs == null)
                {
                    var withAnnotation = mtd.WithAdditionalAnnotations(METHOD_GENERIC_PARAMS_PREFIXED);
                    replacements[mtd] = withAnnotation;
                    continue;
                }

                var newMtd = mtd;

                var oldPs = genArgs.Parameters.Select(p => p.Identifier.ValueText).ToList();
                var newPs = oldPs.Select(p => genericParamPrefix + p.Substring(1)).ToList();

                for (var i = 0; i < oldPs.Count; i++)
                {
                    var oldP = oldPs[i];
                    var newP = newPs[i];

                    var replacementName = SyntaxFactory.IdentifierName(newP);
                    var replacementType = SyntaxFactory.TypeParameter(newP);

                    var oldBody = newMtd.Body;
                    var oldBodyExpression = newMtd.ExpressionBody;
                    var oldReturn = newMtd.ReturnType;
                    var oldTypeParams = newMtd.TypeParameterList;
                    var oldParams = newMtd.ParameterList;
                    var oldConstraints = newMtd.ConstraintClauses;

                    if (oldBody != null)
                    {
                        var oldNodes = oldBody.DescendantNodesAndSelf().OfType<IdentifierNameSyntax>().Where(t => t.Identifier.ValueText == oldP).ToList();
                        var newBody = oldBody.ReplaceNodes(oldNodes, (old, _) => replacementName.WithTriviaFrom(old));
                        newMtd = newMtd.WithBody(newBody.WithTriviaFrom(oldBody));
                    }
                    else
                    {
                        var oldNodes = oldBodyExpression.DescendantNodesAndSelf().OfType<IdentifierNameSyntax>().Where(t => t.Identifier.ValueText == oldP).ToList();
                        var newBodyExpression = oldBodyExpression.ReplaceNodes(oldNodes, (old, _) => replacementName.WithTriviaFrom(old));
                        newMtd = newMtd.WithExpressionBody(newBodyExpression.WithTriviaFrom(oldBodyExpression));
                    }

                    if (oldReturn != null)
                    {
                        var oldNodes = oldReturn.DescendantNodesAndSelf().OfType<IdentifierNameSyntax>().Where(t => t.Identifier.ValueText == oldP).ToList();
                        var newReturn = oldReturn.ReplaceNodes(oldNodes, (old, _) => replacementName.WithTriviaFrom(old));
                        newMtd = newMtd.WithReturnType(newReturn.WithTriviaFrom(oldReturn));
                    }

                    if (oldTypeParams != null)
                    {
                        var oldNodes = oldTypeParams.DescendantNodesAndSelf().OfType<TypeParameterSyntax>().Where(t => t.Identifier.ValueText == oldP).ToList();
                        var newTypeParams = oldTypeParams.ReplaceNodes(oldNodes, (old, _) => replacementType.WithTriviaFrom(old));
                        newMtd = newMtd.WithTypeParameterList(newTypeParams.WithTriviaFrom(oldTypeParams));
                    }

                    if (oldParams != null)
                    {
                        var oldNodes = oldParams.DescendantNodesAndSelf().OfType<IdentifierNameSyntax>().Where(t => t.Identifier.ValueText == oldP).ToList();
                        var newParams = oldParams.ReplaceNodes(oldNodes, (old, _) => replacementName.WithTriviaFrom(old));
                        newMtd = newMtd.WithParameterList(newParams.WithTriviaFrom(oldParams));
                    }

                    if (oldConstraints != null)
                    {
                        var newSyntaxList = SyntaxFactory.List<TypeParameterConstraintClauseSyntax>();
                        foreach (var oldConstraint in oldConstraints)
                        {
                            var oldNodes = oldConstraint.DescendantNodesAndSelf().OfType<IdentifierNameSyntax>().Where(t => t.Identifier.ValueText == oldP).ToList();
                            var newConstraint = oldConstraint.ReplaceNodes(oldNodes, (old, _) => replacementName.WithTriviaFrom(old));

                            newSyntaxList = newSyntaxList.Add(newConstraint.WithTriviaFrom(oldConstraint));
                        }

                        newMtd = newMtd.WithConstraintClauses(newSyntaxList);
                    }
                }

                newMtd = newMtd.WithAdditionalAnnotations(METHOD_GENERIC_PARAMS_PREFIXED);
                replacements[mtd] = newMtd;
            }

            withRewrittenMethods = withRewrittenMethods.ReplaceNodes(replacements.Keys, (old, _) => replacements[old]);

            // change the type name
            var withoutGenericParameterList = withRewrittenMethods.WithTypeParameterList(null);
            var withEnumerableTypeName = withoutGenericParameterList.WithIdentifier(newEnumerable.Identifier);

            // replace all the oureplacedem references
            var oldOureplacedemNodes = withEnumerableTypeName.DescendantNodesAndSelf().Where(d => (d as IdentifierNameSyntax)?.Identifier.ValueText == oldOureplacedem.Identifier.ValueText).ToList();
            var withNewOureplacedem = withEnumerableTypeName.ReplaceNodes(oldOureplacedemNodes, (old, _) => newOureplacedem.WithTriviaFrom(old));

            // replace all the enumerable references
            var oldEnumerableNodes = withNewOureplacedem.DescendantNodesAndSelf().Where(d => (d as IdentifierNameSyntax)?.Identifier.ValueText == oldEnumerable.Identifier.ValueText).ToList();
            var withNewEnumerable = withNewOureplacedem.ReplaceNodes(oldEnumerableNodes, (old, _) => newEnumerable.WithTriviaFrom(old));

            // replace all the enumerator references
            var oldEnumeratorNodes = withNewEnumerable.DescendantNodesAndSelf().Where(d => (d as IdentifierNameSyntax)?.Identifier.ValueText == oldEnumerator.Identifier.ValueText).ToList();
            var withNewEnumerator = withNewEnumerable.ReplaceNodes(oldEnumeratorNodes, (old, _) => newEnumerator.WithTriviaFrom(old));

            // replace This() invocations
            var oldThisNodes = withNewEnumerator.DescendantNodesAndSelf().OfType<InvocationExpressionSyntax>().Where(e => (e.Expression as IdentifierNameSyntax)?.Identifier.ValueText == THIS_PLACEHOLDER).ToList();
            var withNewThisNodes = withNewEnumerator.ReplaceNodes(oldThisNodes, (old, _) => THIS.WithTriviaFrom(old));

            // replace RefThis() invocations
            var oldRefThisNodes = withNewThisNodes.DescendantNodesAndSelf().OfType<InvocationExpressionSyntax>().Where(e => (e.Expression as IdentifierNameSyntax)?.Identifier.ValueText == REF_THIS_PLACEHOLDER).ToList();
            var withNewRefThisNodes = withNewThisNodes.ReplaceNodes(oldRefThisNodes, (old, _) => REF_THIS.WithTriviaFrom(old));

            // replace IsDefaultValue() invocations
            var oldIsDefaultValueNodes = withNewRefThisNodes.DescendantNodesAndSelf().OfType<InvocationExpressionSyntax>().Where(e => (e.Expression as IdentifierNameSyntax)?.Identifier.ValueText == IS_DEFAULT_VALUE_PLACEHOLDER).ToList();
            var withNewIsDefaultValueNodes = withNewRefThisNodes.ReplaceNodes(oldIsDefaultValueNodes, (old, _) => IS_DEFAULT_VALUE.WithTriviaFrom(old));
            
            // update the doreplacedent root
            var oldRoot = docWithTemplate.GetSyntaxRootAsync().Result;
            var updatedRoot = oldRoot.ReplaceNode(template, withNewIsDefaultValueNodes.WithTriviaFrom(template));

            using (var txt = new StringWriter())
            {
                updatedRoot.WriteTo(txt);

                var ret = txt.ToString();
                return ret;
            }
        }

19 Source : ExtensionMethodsBase.cs
with Apache License 2.0
from kevin-montrose

static protected IEnumerable<MethodDeclarationSyntax> ExpandMethodFromPlaceholders(
            MethodDeclarationSyntax template, 
            IEnumerable<EnumerableDetails> enumerables,
            string placeHolderEnumerableName,
            string placeHolderEnumeratorName,
            bool includeReturnTypes
        )
        {
            var ret = new List<MethodDeclarationSyntax>();

            Func<SyntaxNode, bool> inReturn = null;
            inReturn =
                node =>
                {
                    if (node.Parent == null) return false;

                    var isPartOfMethod = node.Parent is MethodDeclarationSyntax;
                    if (!isPartOfMethod) return inReturn(node.Parent);

                    var parentMethod = (MethodDeclarationSyntax)node.Parent;

                    if (parentMethod.ReturnType == null) return false;

                        // hit the containing method, so it's make or break time
                        return node == parentMethod.ReturnType;
                };

            var mentionsOfPlaceholderEnumerable = 
                template.DescendantNodesAndSelf().OfType<SimpleNameSyntax>().Where(s => s.Identifier.ValueText == placeHolderEnumerableName).ToList();
            var mentionsOfPlaceholderEnumerator = 
                template.DescendantNodesAndSelf().OfType<SimpleNameSyntax>().Where(s => s.Identifier.ValueText == placeHolderEnumeratorName).ToList();
            
            if (!includeReturnTypes)
            {
                var inReturnEnumerables = mentionsOfPlaceholderEnumerable.Where(n => inReturn(n)).ToList();
                var inReturnEnumerators = mentionsOfPlaceholderEnumerator.Where(n => inReturn(n)).ToList();

                mentionsOfPlaceholderEnumerable = mentionsOfPlaceholderEnumerable.Except(inReturnEnumerables).ToList();
                mentionsOfPlaceholderEnumerator = mentionsOfPlaceholderEnumerator.Except(inReturnEnumerators).ToList();
            }

            // no changes to be made, leave it alone
            if (mentionsOfPlaceholderEnumerable.Count == 0 && mentionsOfPlaceholderEnumerator.Count == 0)
            {
                ret.Add(template);
                return ret;
            }

            var outTypes =
                mentionsOfPlaceholderEnumerable
                    .OfType<GenericNameSyntax>()
                    .Concat(mentionsOfPlaceholderEnumerator.OfType<GenericNameSyntax>())
                    .Select(g => g.TypeArgumentList.Arguments.ElementAt(0))
                    .OfType<TypeSyntax>()
                    .Select(t => t.ToString())
                    .Distinct()
                    .ToList();

            if (outTypes.Count > 1)
            {
                throw new Exception("Expected only a single out type in extension method placeholder usage");
            }

            var outTypeStr = outTypes.Single();
            var outType = SyntaxFactory.ParseTypeName(outTypeStr);

            foreach (var pair in enumerables)
            {
                var updatedMtd = template;

                // replace all the uses of the out item with whatever is bound in the template
                var enumerableOutTypeUses = pair.Enumerable.DescendantNodesAndSelf().OfType<SimpleNameSyntax>().Where(t => t.Identifier.ValueText == pair.Oureplacedem).ToList();
                var enumeratorOutTypeUses =
                    pair.Enumerator != null ?
                        pair.Enumerator.DescendantNodesAndSelf().OfType<SimpleNameSyntax>().Where(t => t.Identifier.ValueText == pair.Oureplacedem).ToList() :
                        new List<SimpleNameSyntax>();

                // rework enumerable and enumerator to bind to the appropriate type
                var boundEnumerable = pair.Enumerable.ReplaceNodes(enumerableOutTypeUses, (old, _) => outType.WithTriviaFrom(old));
                var boundEnumerator = pair.Enumerator?.ReplaceNodes(enumeratorOutTypeUses, (old, _) => outType.WithTriviaFrom(old));

                var dontInjectIntoCommon = false;
                var attrs = updatedMtd.AttributeLists.SelectMany(a => a.Attributes).ToList();
                var dnpAttrs = attrs.Where(a => (a.Name as IdentifierNameSyntax)?.Identifier.ValueText == "DoNotInject").ToList();
                if (dnpAttrs.Any())
                {
                    var attrKeeps = new List<AttributeSyntax>(attrs);
                    foreach (var attr in dnpAttrs)
                    {
                        attrKeeps.Remove(attr);
                    }

                    if (attrKeeps.Count == 0)
                    {
                        updatedMtd = updatedMtd.RemoveNodes(updatedMtd.AttributeLists, SyntaxRemoveOptions.KeepLeadingTrivia);
                    }
                    else
                    {
                        var attrListSyntax = SyntaxFactory.AttributeList().AddAttributes(attrKeeps.ToArray());
                        var list = SyntaxFactory.List(new[] { attrListSyntax });

                        updatedMtd = updatedMtd.WithAttributeLists(list);
                    }

                    dontInjectIntoCommon = true;
                }

                if (dontInjectIntoCommon)
                {
                    Func<SimpleNameSyntax, bool> inParameterList =
                        p =>
                        {
                            var pList = updatedMtd.ParameterList;

                            return pList.Parameters.Any(x => x.Type.Equals(p));
                        };

                    var replace = new Dictionary<SimpleNameSyntax, SyntaxNode>();

                    var bridingeEnumerableOutTypeUses = pair.BridgeEnumerable.DescendantNodesAndSelf().OfType<SimpleNameSyntax>().Where(t => t.Identifier.ValueText == pair.Oureplacedem).ToList();
                    var bridingeEnumeratorOutTypeUses = pair.BridgeEnumerator.DescendantNodesAndSelf().OfType<SimpleNameSyntax>().Where(t => t.Identifier.ValueText == pair.Oureplacedem).ToList();

                    var bridgingEnumerable = pair.BridgeEnumerable.ReplaceNodes(bridingeEnumerableOutTypeUses, (old, _) => outType.WithTriviaFrom(old));
                    var bridgingEnumerator = pair.BridgeEnumerator.ReplaceNodes(bridingeEnumeratorOutTypeUses, (old, _) => outType.WithTriviaFrom(old));

                    var toReplaceEnumerables = updatedMtd.DescendantNodesAndSelf().OfType<SimpleNameSyntax>().Where(s => s.Identifier.ValueText == placeHolderEnumerableName).ToList();
                    var toReplaceEnumerators = updatedMtd.DescendantNodesAndSelf().OfType<SimpleNameSyntax>().Where(s => s.Identifier.ValueText == placeHolderEnumeratorName).ToList();

                    foreach(var e in toReplaceEnumerables)
                    {
                        replace[e] = bridgingEnumerable;
                    }

                    foreach(var e in toReplaceEnumerators)
                    {
                        replace[e] = bridgingEnumerator;
                    }

                    var inParams = new List<SimpleNameSyntax>();
                    foreach(var kv in replace)
                    {
                        if (inParameterList(kv.Key))
                        {
                            inParams.Add(kv.Key);
                        }
                    }

                    foreach(var p in inParams)
                    {
                        replace[p] = boundEnumerable;
                    }

                    updatedMtd = updatedMtd.ReplaceNodes(replace.Keys, (old, _) => replace[old].WithTriviaFrom(old));
                    updatedMtd = updatedMtd.WithAdditionalAnnotations(DO_NOT_PARAMETERIZE);
                }
                else
                {
                    // replace the old enumerable and enumerator references
                    updatedMtd = updatedMtd.ReplaceNodes(mentionsOfPlaceholderEnumerable, (old, _) => boundEnumerable.WithTriviaFrom(old));

                    var updatedMentionsOfPlaceholderEnumerator = updatedMtd.DescendantNodesAndSelf().OfType<SimpleNameSyntax>().Where(s => s.Identifier.ValueText == placeHolderEnumeratorName).ToList();

                    if (!includeReturnTypes)
                    {
                        var enumeratorsInReturn = updatedMentionsOfPlaceholderEnumerator.Where(e => inReturn(e)).ToList();
                        updatedMentionsOfPlaceholderEnumerator = updatedMentionsOfPlaceholderEnumerator.Except(enumeratorsInReturn).ToList();
                    }

                    if (boundEnumerator != null)
                    {
                        updatedMtd = updatedMtd.ReplaceNodes(updatedMentionsOfPlaceholderEnumerator, (old, _) => boundEnumerator.WithTriviaFrom(old));
                    }
                    else
                    {
                        updatedMtd = updatedMtd.RemoveNodes(updatedMentionsOfPlaceholderEnumerator, SyntaxRemoveOptions.KeepNoTrivia);
                    }
                }

                // rewrite any type constraints so that they refer to the new out item too
                var updatedConstraints = new List<TypeParameterConstraintClauseSyntax>();
                updatedConstraints.AddRange(template.ConstraintClauses);

                foreach (var constraint in pair.Constraints)
                {
                    var constraitOutTypeUses = constraint.DescendantNodesAndSelf().OfType<SimpleNameSyntax>().Where(t => t.Identifier.ValueText == pair.Oureplacedem).ToList();
                    var updatedConstraint = constraint.ReplaceNodes(constraitOutTypeUses, (old, _) => outType.WithTriviaFrom(old));
                    updatedConstraints.Add(updatedConstraint);
                }

                updatedMtd = updatedMtd.WithConstraintClauses(SyntaxFactory.List(updatedConstraints));

                // slam all the generic types that need to be known into place
                var typeList = new List<TypeParameterSyntax>();
                foreach (var param in pair.GenericArgs)
                {
                    typeList.Add(SyntaxFactory.TypeParameter(param));
                }

                if (typeList.Count > 0)
                {
                    updatedMtd = updatedMtd.AddTypeParameterListParameters(typeList.ToArray());
                }

                if (pair.IsBridgeType && !dontInjectIntoCommon)
                {
                    // bridge types are handled with lots of specificly parameterized methods in CommonImplementation, so remove
                    //   any of the direct mentions in type argument lists in the body
                    updatedMtd = updatedMtd.WithAdditionalAnnotations(METHOD_ON_BRIDGE_TYPE);

                    var bodyGenericTypeArgs = 
                        (updatedMtd.Body?.DescendantNodesAndSelf() ?? updatedMtd.ExpressionBody?.DescendantNodesAndSelf())
                            .OfType<TypeArgumentListSyntax>()
                            .SelectMany(t => t.Arguments)
                            .ToList();

                    var needRemoval = bodyGenericTypeArgs.Where(b => b.IsEquivalentTo(boundEnumerable)).ToList();

                    updatedMtd = updatedMtd.RemoveNodes(needRemoval, SyntaxRemoveOptions.KeepNoTrivia);

                    var replacements = new Dictionary<SyntaxNode, SyntaxNode>();

                    foreach(var withEmptyTypeArgs in (updatedMtd.Body?.DescendantNodesAndSelf() ?? updatedMtd.ExpressionBody?.DescendantNodesAndSelf()).OfType<TypeArgumentListSyntax>().Where(t => t.Arguments.Count == 0))
                    {
                        var parent = (GenericNameSyntax)withEmptyTypeArgs.Parent;
                        var simpleName = SyntaxFactory.IdentifierName(parent.Identifier);

                        replacements[parent] = simpleName.WithTriviaFrom(parent);
                    }

                    updatedMtd = updatedMtd.ReplaceNodes(replacements.Keys, (old, _) => replacements[old]);

                    //while (true)
                    //{
                    //    var withEmptyTypeArgs =
                    //        (updatedMtd.Body?.DescendantNodesAndSelf() ?? updatedMtd.ExpressionBody?.DescendantNodesAndSelf())
                    //            .OfType<TypeArgumentListSyntax>()
                    //            .FirstOrDefault(t => t.Arguments.Count == 0);

                    //    if (withEmptyTypeArgs == null) break;

                    //    var parent = (GenericNameSyntax)withEmptyTypeArgs.Parent;
                    //    var simpleName = SyntaxFactory.IdentifierName(parent.Identifier);

                    //    updatedMtd = updatedMtd.ReplaceNode(parent, simpleName.WithTriviaFrom(parent));
                    //}
                }

                ret.Add(updatedMtd.WithTriviaFrom(template));
            }

            return ret;
        }

19 Source : ToCSharpRewriteTreeVisitor.cs
with MIT License
from Puchaczov

private void CreateDescForConstructors(DescNode node)
        {
            CreateDescMethod(node,
                SyntaxFactory.InvocationExpression(
                        SyntaxFactory.MemberAccessExpression(
                            SyntaxKind.SimpleMemberAccessExpression,
                            SyntaxFactory.IdentifierName(nameof(EvaluationHelper)),
                            SyntaxFactory.IdentifierName(nameof(EvaluationHelper.GetConstructorsForSpecificMethod))))
                    .WithArgumentList(
                        SyntaxFactory.ArgumentList(
                            SyntaxFactory.SeparatedList(
                                new[] {
                                    SyntaxFactory.Argument(SyntaxFactory.IdentifierName("desc")),
                                    SyntaxHelper.StringLiteralArgument(((SchemaFromNode)node.From).Method)
                                }))), false);
        }

19 Source : ToCSharpRewriteTreeVisitor.cs
with MIT License
from Puchaczov

public void Visit(FieldNode node)
        {
            var types = EvaluationHelper.GetNestedTypes(node.ReturnType);

            AddReference(types);
            AddNamespace(types);

            var typeIdentifier =
                SyntaxFactory.IdentifierName(
                    EvaluationHelper.GetCastableType(node.ReturnType));

            if (typeof(IDynamicMetaObjectProvider).IsreplacedignableFrom(node.ReturnType))
            {
                typeIdentifier = SyntaxFactory.IdentifierName("dynamic");
            }

            var expression = Nodes.Pop();

            var castedExpression = Generator.CastExpression(typeIdentifier, expression);
            Nodes.Push(castedExpression);
        }

19 Source : ToCSharpRewriteTreeVisitor.cs
with MIT License
from Puchaczov

public void Visit(FieldOrderedNode node)
        {
            var types = EvaluationHelper.GetNestedTypes(node.ReturnType);

            AddReference(types);
            AddNamespace(types);

            var typeIdentifier = SyntaxFactory.IdentifierName(
                    EvaluationHelper.GetCastableType(node.ReturnType));

            if (typeof(IDynamicMetaObjectProvider).IsreplacedignableFrom(node.ReturnType))
            {
                typeIdentifier = SyntaxFactory.IdentifierName("dynamic");
            }

            var castedExpression = Generator.CastExpression(
                typeIdentifier, Nodes.Pop());

            Nodes.Push(castedExpression);
        }

19 Source : ToCSharpRewriteTreeVisitor.cs
with MIT License
from Puchaczov

public void Visit(AccessMethodNode node)
        {
            var args = new List<ArgumentSyntax>();

            var parameters = node.Method.GetParameters().GetParametersWithAttribute<InjectTypeAttribute>();

            var method = node.Method;

            var variableName = $"{node.Alias}{method.ReflectedType.Name}Lib";

            if (!_typesToInstantiate.ContainsKey(variableName))
            {
                _typesToInstantiate.Add(variableName, method.ReflectedType);
                AddNamespace(method.ReflectedType.Namespace);

                Statements.Add(
                    SyntaxFactory.LocalDeclarationStatement(
                        SyntaxHelper.Createreplacedignment(
                            variableName,
                            SyntaxHelper.CreateObjectOf(
                                method.ReflectedType.Name,
                                SyntaxFactory.ArgumentList()))));
            }

            _scope.ScopeSymbolTable.AddSymbolIfNotExist(method.ReflectedType.Name,
                new TypeSymbol(method.ReflectedType));

            foreach (var parameterInfo in parameters)
            {
                switch (parameterInfo.GetCustomAttribute<InjectTypeAttribute>())
                {
                    case InjectSourceAttribute _:

                        if (node.CanSkipInjectSource)
                            continue;

                        string objectName;

                        switch (_type)
                        {
                            case MethodAccessType.TransformingQuery:
                                objectName = $"{_queryAlias}Row";
                                break;
                            case MethodAccessType.ResultQuery:
                            case MethodAccessType.CaseWhen:
                                objectName = "score";
                                break;
                            default:
                                throw new NotSupportedException($"Unrecognized method access type ({_type})");
                        }

                        var typeIdentifier = SyntaxFactory.IdentifierName(
                                        EvaluationHelper.GetCastableType(parameterInfo.ParameterType));

                        if (parameterInfo.ParameterType == typeof(ExpandoObject))
                        {
                            typeIdentifier = SyntaxFactory.IdentifierName("dynamic");
                        }

                        var aliases = _scope.Parent.ScopeSymbolTable.GetSymbol<AliasesPositionsSymbol>(MetaAttributes.AllQueryContexts);
                        var currentContext = aliases.AliasesPositions[node.Alias];

                        args.Add(
                            SyntaxFactory.Argument(
                                SyntaxFactory.CastExpression(
                                    typeIdentifier,
                                    SyntaxFactory.ElementAccessExpression(
                                        SyntaxFactory.MemberAccessExpression(
                                        SyntaxKind.SimpleMemberAccessExpression,
                                        SyntaxFactory.IdentifierName(objectName),
                                        SyntaxFactory.IdentifierName(nameof(IObjectResolver.Contexts))),
                                    SyntaxFactory.BracketedArgumentList(
                                        SyntaxFactory.SeparatedList(
                                            new[] 
                                            {
                                                SyntaxFactory.Argument(
                                                    SyntaxFactory.LiteralExpression(SyntaxKind.NumerireplacederalExpression, SyntaxFactory.Literal(currentContext)))
                                            }))))));
                        break;
                    case InjectGroupAttribute _:

                        switch (_type)
                        {
                            case MethodAccessType.ResultQuery: //do not inject in result query.
                                break;
                            default:
                                args.Add(SyntaxFactory.Argument(SyntaxFactory.IdentifierName("group")));
                                break;
                        }

                        break;
                    case InjectGroupAccessName _:
                        break;
                    case InjectQueryStats _:
                        args.Add(
                            SyntaxFactory.Argument(
                                SyntaxFactory.IdentifierName("stats")));
                        break;
                }
            }

            var tmpArgs = (ArgumentListSyntax) Nodes.Pop();

            for (var index = 0; index < tmpArgs.Arguments.Count; index++)
            {
                var item = tmpArgs.Arguments[index];
                args.Add(item);
            }

            SyntaxNode accessMethodExpr;

            if (node.Method.IsGenericMethod && method.GetCustomAttribute<AggregationMethodAttribute>() != null)
            {
                var genericArgs = node.Method.GetGenericArguments();
                var syntaxArgs = new List<SyntaxNodeOrToken>();

                for(int i = 0; i < genericArgs.Length - 1; ++i)
                {
                    syntaxArgs.Add(SyntaxFactory.IdentifierName(genericArgs[i].FullName));
                    syntaxArgs.Add(SyntaxFactory.Token(SyntaxKind.CommaToken));
                }

                syntaxArgs.Add(SyntaxFactory.IdentifierName(genericArgs[genericArgs.Length - 1].FullName));

                TypeArgumentListSyntax typeArgs;
                if (syntaxArgs.Count < 2)
                {
                    typeArgs = SyntaxFactory.TypeArgumentList(
                        SyntaxFactory.SingletonSeparatedList<TypeSyntax>(
                            (IdentifierNameSyntax)syntaxArgs[0]));
                }
                else
                {
                    typeArgs = SyntaxFactory.TypeArgumentList(
                        SyntaxFactory.SeparatedList<TypeSyntax>(
                            syntaxArgs.ToArray()));
                }

                var genericName = SyntaxFactory
                    .GenericName(node.Name)
                    .WithTypeArgumentList(
                        typeArgs
                        .WithLessThanToken(
                            SyntaxFactory.Token(SyntaxKind.LessThanToken))
                        .WithGreaterThanToken(
                            SyntaxFactory.Token(SyntaxKind.GreaterThanToken)));

                accessMethodExpr = Generator.InvocationExpression(
                    Generator.MemberAccessExpression(
                        Generator.IdentifierName(variableName),
                        genericName),
                    args);
            }
            else
            {
                accessMethodExpr = Generator.InvocationExpression(
                    Generator.MemberAccessExpression(
                        Generator.IdentifierName(variableName),
                        Generator.IdentifierName(node.Name)),
                    args);
            }

            if (!node.ReturnType.IsTrueValueType())
                NullSuspiciousNodes.Push(accessMethodExpr);

            Nodes.Push(accessMethodExpr);
        }

19 Source : ToCSharpRewriteTreeVisitor.cs
with MIT License
from Puchaczov

public void Visit(AccessColumnNode node)
        {
            string variableName;
            switch (_type)
            {
                case MethodAccessType.TransformingQuery:
                    variableName = $"{node.Alias}Row";
                    break;
                case MethodAccessType.ResultQuery:
                case MethodAccessType.CaseWhen:
                    variableName = "score";
                    break;
                default:
                    throw new NotSupportedException($"Unrecognized method access type ({_type})");
            }

            var sNode = Generator.ElementAccessExpression(
                Generator.IdentifierName(variableName),
                SyntaxFactory.Argument(
                    SyntaxFactory.LiteralExpression(
                        SyntaxKind.StringLiteralExpression, 
                        SyntaxFactory.Literal($"@\"{node.Name}\"", node.Name))));

            var types = EvaluationHelper.GetNestedTypes(node.ReturnType);

            AddNamespace(types);
            AddReference(types);

            var typeIdentifier =
                SyntaxFactory.IdentifierName(
                    EvaluationHelper.GetCastableType(node.ReturnType));

            if (typeof(IDynamicMetaObjectProvider).IsreplacedignableFrom(node.ReturnType))
            {
                typeIdentifier = SyntaxFactory.IdentifierName("dynamic");
            }

            sNode = Generator.CastExpression(typeIdentifier, sNode);

            if (!node.ReturnType.IsTrueValueType())
                NullSuspiciousNodes.Push(sNode);

            Nodes.Push(sNode);
        }

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(SchemaFromNode node)
        {
            var originColumns = InferredColumns[node];

            var listOfColumns = new List<ExpressionSyntax>();
            foreach (var column in originColumns)
            {
                listOfColumns.Add(
                    SyntaxHelper.CreateObjectOf(
                        nameof(Column),
                        SyntaxFactory.ArgumentList(
                            SyntaxFactory.SeparatedList(new[]
                            {
                                    SyntaxFactory.Argument(
                                        SyntaxFactory.LiteralExpression(
                                            SyntaxKind.StringLiteralExpression,
                                            SyntaxFactory.Literal(column.ColumnName))),
                                    SyntaxHelper.TypeLiteralArgument(
                                        EvaluationHelper.GetCastableType(column.ColumnType)),
                                    SyntaxHelper.IntLiteralArgument(column.ColumnIndex)
                            }))));
            }

            var tableInfoVariableName = node.Alias.ToInfoTable();
            var tableInfoObject = SyntaxHelper.Createreplacedignment(
                tableInfoVariableName,
                SyntaxHelper.CreateArrayOf(
                    nameof(ISchemaColumn),
                    listOfColumns.ToArray()));

            var createdSchema = SyntaxHelper.CreatereplacedignmentByMethodCall(
                node.Alias,
                "provider",
                nameof(ISchemaProvider.GetSchema),
                SyntaxFactory.ArgumentList(
                    SyntaxFactory.Token(SyntaxKind.OpenParenToken),
                    SyntaxFactory.SeparatedList(new[]
                    {
                        SyntaxHelper.StringLiteralArgument(node.Schema)
                    }),
                    SyntaxFactory.Token(SyntaxKind.CloseParenToken)
                )
            );

            var args = new List<ExpressionSyntax>();
            var argList = (ArgumentListSyntax) Nodes.Pop();
            args.AddRange(argList.Arguments.Select(arg => arg.Expression));

            var createdSchemaRows = SyntaxHelper.CreatereplacedignmentByMethodCall(
                $"{node.Alias}Rows",
                node.Alias,
                nameof(ISchema.GetRowSource),
                SyntaxFactory.ArgumentList(
                    SyntaxFactory.SeparatedList(new[]
                    {
                        SyntaxHelper.StringLiteralArgument(node.Method),
                        SyntaxFactory.Argument(
                            SyntaxFactory.ObjectCreationExpression(
                                SyntaxFactory.IdentifierName(nameof(RuntimeContext)))
                                .WithArgumentList(
                                    SyntaxFactory.ArgumentList(
                                        SyntaxFactory.SeparatedList(
                                            new []{
                                                SyntaxFactory.Argument(SyntaxFactory.IdentifierName("token")),
                                                SyntaxFactory.Argument(SyntaxFactory.IdentifierName(tableInfoVariableName))
                                            })))),
                        SyntaxFactory.Argument(
                            SyntaxHelper.CreateArrayOf(
                                nameof(Object),
                                args.ToArray()))
                    })
                ));

            Statements.Add(SyntaxFactory.LocalDeclarationStatement(tableInfoObject));
            Statements.Add(SyntaxFactory.LocalDeclarationStatement(createdSchema));
            Statements.Add(SyntaxFactory.LocalDeclarationStatement(createdSchemaRows));
        }

19 Source : ToCSharpRewriteTreeVisitor.cs
with MIT License
from Puchaczov

public void Visit(SkipNode node)
        {
            var identifier = "skipAmount";

            var skip = SyntaxFactory.LocalDeclarationStatement(
                    SyntaxHelper.Createreplacedignment(identifier, (ExpressionSyntax) Generator.LiteralExpression(1)))
                .WithTrailingTrivia(SyntaxFactory.CarriageReturnLineFeed);

            var ifStatement = Generator.IfStatement(
                Generator.LessThanOrEqualExpression(
                    SyntaxFactory.IdentifierName(identifier),
                    Generator.LiteralExpression(node.Value)),
                new SyntaxNode[]
                {
                    SyntaxFactory.PostfixUnaryExpression(
                        SyntaxKind.PostIncrementExpression,
                        SyntaxFactory.IdentifierName(identifier)),
                    SyntaxFactory.ContinueStatement()
                });

            Statements.Add(skip);

            Nodes.Push(ifStatement);
        }

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 : SyntaxHelper.cs
with MIT License
from Puchaczov

public static InvocationExpressionSyntax CreateMethodInvocation(string variableName, string methodName,
            IEnumerable<SyntaxNode> arguments)
        {
            return CreateMethodInvocation(SyntaxFactory.IdentifierName(variableName), methodName, arguments);
        }

19 Source : SyntaxHelper.cs
with MIT License
from Puchaczov

public static InvocationExpressionSyntax CreateMethodInvocation(ExpressionSyntax exp, string methodName,
            IEnumerable<SyntaxNode> arguments)
        {
            return SyntaxFactory
                .InvocationExpression(
                    SyntaxFactory.MemberAccessExpression(
                        SyntaxKind.SimpleMemberAccessExpression,
                        exp,
                        SyntaxFactory.Token(SyntaxKind.DotToken),
                        SyntaxFactory.IdentifierName(methodName)
                    ),
                    SyntaxFactory.ArgumentList(
                        SyntaxFactory.SeparatedList(arguments)));
        }

19 Source : SyntaxHelper.cs
with MIT License
from Puchaczov

public static ElementAccessExpressionSyntax CreateElementAccess(string objectName,
            IEnumerable<ArgumentSyntax> arguments)
        {
            return SyntaxFactory.ElementAccessExpression(
                SyntaxFactory.IdentifierName(objectName),
                SyntaxFactory.BracketedArgumentList(
                    new SeparatedSyntaxList<ArgumentSyntax>().AddRange(arguments)));
        }

19 Source : SyntaxHelper.cs
with MIT License
from Puchaczov

public static VariableDeclarationSyntax Createreplacedignment(params VariableDeclaratorSyntax[] declarations)
        {
            return SyntaxFactory.VariableDeclaration(
                SyntaxFactory.IdentifierName("var").WithTrailingTrivia(WhiteSpace),
                SyntaxFactory.SeparatedList(new List<VariableDeclaratorSyntax>(declarations)));
        }

19 Source : SyntaxHelper.cs
with MIT License
from Puchaczov

public static VariableDeclarationSyntax CreatereplacedignmentByMethodCall(string variableName, string objectName,
            string methodName, ArgumentListSyntax args)
        {
            return Createreplacedignment(
                SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(variableName),
                    null,
                    SyntaxFactory.EqualsValueClause(
                        SyntaxFactory.Token(SyntaxKind.EqualsToken),
                        SyntaxFactory.InvocationExpression(
                            SyntaxFactory.MemberAccessExpression(
                                SyntaxKind.SimpleMemberAccessExpression,
                                SyntaxFactory.IdentifierName(objectName),
                                SyntaxFactory.Token(SyntaxKind.DotToken),
                                SyntaxFactory.IdentifierName(methodName)),
                            args)
                    )
                )
            );
        }

19 Source : SyntaxHelper.cs
with MIT License
from Puchaczov

public static TypeOfExpressionSyntax TypeOf(string typeName)
        {
            return SyntaxFactory.TypeOfExpression(SyntaxFactory.IdentifierName(typeName));
        }

19 Source : SyntaxHelper.cs
with MIT License
from Puchaczov

public static ForEachStatementSyntax Foreach(string variable, string source, BlockSyntax block)
        {
            return SyntaxFactory.ForEachStatement(
                SyntaxFactory.Token(SyntaxKind.ForEachKeyword),
                SyntaxFactory.Token(SyntaxKind.OpenParenToken),
                SyntaxFactory.IdentifierName("var").WithTrailingTrivia(WhiteSpace),
                SyntaxFactory.Identifier(variable).WithTrailingTrivia(WhiteSpace),
                SyntaxFactory.Token(SyntaxKind.InKeyword).WithTrailingTrivia(WhiteSpace),
                SyntaxFactory.IdentifierName(source),
                SyntaxFactory.Token(SyntaxKind.CloseParenToken),
                block);
        }

19 Source : SyntaxHelper.cs
with MIT License
from Puchaczov

public static ArrayCreationExpressionSyntax CreateArrayOf(string typeName, ExpressionSyntax[] expressions,
            int ranksAmount = 1)
        {
            var newKeyword = SyntaxFactory.Token(SyntaxTriviaList.Empty, SyntaxKind.NewKeyword,
                SyntaxTriviaList.Create(SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " ")));
            var syntaxList = new SeparatedSyntaxList<ExpressionSyntax>();

            for (var i = 0; i < expressions.Length; i++) syntaxList = syntaxList.Add(expressions[i]);

            var rankSpecifiers = new SyntaxList<ArrayRankSpecifierSyntax>();

            for (var i = 0; i < ranksAmount; i++)
                rankSpecifiers = rankSpecifiers.Add(
                    SyntaxFactory.ArrayRankSpecifier(
                        SyntaxFactory.Token(SyntaxKind.OpenBracketToken),
                        new SeparatedSyntaxList<ExpressionSyntax>
                        {
                            SyntaxFactory.OmittedArraySizeExpression(
                                SyntaxFactory.Token(SyntaxKind.OmittedArraySizeExpressionToken)
                            )
                        },
                        SyntaxFactory.Token(SyntaxKind.CloseBracketToken)
                    )
                );

            return SyntaxFactory.ArrayCreationExpression(
                newKeyword,
                SyntaxFactory.ArrayType(SyntaxFactory.IdentifierName(typeName), rankSpecifiers),
                SyntaxFactory.InitializerExpression(SyntaxKind.ArrayInitializerExpression, syntaxList));
        }

19 Source : ToCSharpRewriteTreeVisitor.cs
with MIT License
from Puchaczov

private void CreateDescForSpecificConstructor(DescNode node)
        {
            CreateDescMethod(node,
                SyntaxFactory.InvocationExpression(
                        SyntaxFactory.MemberAccessExpression(
                            SyntaxKind.SimpleMemberAccessExpression,
                            SyntaxFactory.IdentifierName(nameof(EvaluationHelper)),
                            SyntaxFactory.IdentifierName(nameof(EvaluationHelper.GetSpecificTableDescription))))
                    .WithArgumentList(
                        SyntaxFactory.ArgumentList(
                            SyntaxFactory.SingletonSeparatedList(
                                SyntaxFactory.Argument(SyntaxFactory.IdentifierName("schemaTable"))))), true);
        }

19 Source : ToCSharpRewriteTreeVisitor.cs
with MIT License
from Puchaczov

private void CreateDescMethod(DescNode node, InvocationExpressionSyntax invocationExpression, bool useProvidedTable)
        {
            var schemaNode = (SchemaFromNode)node.From;
            var createdSchema = SyntaxHelper.CreatereplacedignmentByMethodCall(
                "desc",
                "provider",
                nameof(ISchemaProvider.GetSchema),
                SyntaxFactory.ArgumentList(
                    SyntaxFactory.Token(SyntaxKind.OpenParenToken),
                    SyntaxFactory.SeparatedList(new[]
                    {
                        SyntaxHelper.StringLiteralArgument(schemaNode.Schema)
                    }),
                    SyntaxFactory.Token(SyntaxKind.CloseParenToken)
                )
            );

            if (useProvidedTable)
            {
                var args = schemaNode.Parameters.Args.Select(arg => (ExpressionSyntax)Generator.LiteralExpression(((ConstantValueNode)arg).ObjValue)).ToArray();

                var gettedTable = SyntaxHelper.CreatereplacedignmentByMethodCall(
                    "schemaTable",
                    "desc",
                    nameof(ISchema.GetTableByName),
                    SyntaxFactory.ArgumentList(
                        SyntaxFactory.Token(SyntaxKind.OpenParenToken),
                        SyntaxFactory.SeparatedList(new[]
                        {
                            SyntaxHelper.StringLiteralArgument(schemaNode.Method),
                            SyntaxFactory.Argument(SyntaxHelper.CreateArrayOf(nameof(Object), args))
                        }),
                        SyntaxFactory.Token(SyntaxKind.CloseParenToken)
                    )
                );

                var returnStatement = SyntaxFactory.ReturnStatement(invocationExpression);

                Statements.AddRange(new StatementSyntax[]
                {
                    SyntaxFactory.LocalDeclarationStatement(createdSchema),
                    SyntaxFactory.LocalDeclarationStatement(gettedTable),
                    returnStatement
                });
            }
            else
            {
                var returnStatement = SyntaxFactory.ReturnStatement(invocationExpression);

                Statements.AddRange(new StatementSyntax[]
                {
                    SyntaxFactory.LocalDeclarationStatement(createdSchema),
                    returnStatement
                });
            }

            var methodName = "GetTableDesc";

            var method = SyntaxFactory.MethodDeclaration(
                new SyntaxList<AttributeListSyntax>(),
                SyntaxFactory.TokenList(
                    SyntaxFactory.Token(SyntaxKind.PrivateKeyword).WithTrailingTrivia(SyntaxHelper.WhiteSpace)),
                SyntaxFactory.IdentifierName(nameof(Table)).WithTrailingTrivia(SyntaxHelper.WhiteSpace),
                null,
                SyntaxFactory.Identifier(methodName),
                null,
                SyntaxFactory.ParameterList(
                    SyntaxFactory.SeparatedList(new[]
                    {
                        SyntaxFactory.Parameter(
                            new SyntaxList<AttributeListSyntax>(),
                            SyntaxTokenList.Create(
                                new SyntaxToken()),
                            SyntaxFactory.IdentifierName(nameof(ISchemaProvider))
                                .WithTrailingTrivia(SyntaxHelper.WhiteSpace),
                            SyntaxFactory.Identifier("provider"), null),

                        SyntaxFactory.Parameter(
                            new SyntaxList<AttributeListSyntax>(),
                            SyntaxTokenList.Create(
                                new SyntaxToken()),
                            SyntaxFactory.IdentifierName(nameof(CancellationToken))
                                .WithTrailingTrivia(SyntaxHelper.WhiteSpace),
                            SyntaxFactory.Identifier("token"), null)
                    })),
                new SyntaxList<TypeParameterConstraintClauseSyntax>(),
                SyntaxFactory.Block(Statements),
                null);

            _members.Add(method);
            _methodNames.Push(methodName);
        }

19 Source : ToCSharpRewriteTreeVisitor.cs
with MIT License
from Puchaczov

public void Visit(AccessRawIdentifierNode node)
        {
            Nodes.Push(SyntaxFactory.IdentifierName(node.Name));
        }

19 Source : ToCSharpRewriteTreeVisitor.cs
with MIT License
from Puchaczov

public void Visit(AccessObjectArrayNode node)
        {
            var exp = SyntaxFactory.ParenthesizedExpression((ExpressionSyntax) Nodes.Pop());

            Nodes.Push(SyntaxFactory
                .ElementAccessExpression(SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
                    exp, SyntaxFactory.IdentifierName(node.Name))).WithArgumentList(
                    SyntaxFactory.BracketedArgumentList(SyntaxFactory.SingletonSeparatedList(
                        SyntaxFactory.Argument(SyntaxFactory.LiteralExpression(SyntaxKind.NumerireplacederalExpression,
                            SyntaxFactory.Literal(node.Token.Index)))))));
        }

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(InMemoryTableFromNode node)
        {
            Statements.Add(SyntaxFactory.LocalDeclarationStatement(SyntaxFactory
                .VariableDeclaration(SyntaxFactory.IdentifierName("var")).WithVariables(
                    SyntaxFactory.SingletonSeparatedList(SyntaxFactory
                        .VariableDeclarator(SyntaxFactory.Identifier(node.Alias.ToRowsSource())).WithInitializer(
                            SyntaxFactory.EqualsValueClause(SyntaxFactory
                                .InvocationExpression(SyntaxFactory.MemberAccessExpression(
                                    SyntaxKind.SimpleMemberAccessExpression,
                                    SyntaxFactory.IdentifierName(nameof(EvaluationHelper)),
                                    SyntaxFactory.IdentifierName(nameof(EvaluationHelper.ConvertTableToSource))))
                                .WithArgumentList(
                                    SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(
                                        SyntaxFactory.Argument(SyntaxFactory
                                            .ElementAccessExpression(
                                                SyntaxFactory.IdentifierName("_tableResults")).WithArgumentList(
                                                SyntaxFactory.BracketedArgumentList(
                                                    SyntaxFactory.SingletonSeparatedList(
                                                        SyntaxFactory.Argument(
                                                            SyntaxFactory.LiteralExpression(
                                                                SyntaxKind.NumerireplacederalExpression,
                                                                SyntaxFactory.Literal(
                                                                    _inMemoryTableIndexes[
                                                                        node.VariableName]))))))))))))))));
        }

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(RootNode node)
        {
            var method = SyntaxFactory.MethodDeclaration(
                new SyntaxList<AttributeListSyntax>(),
                SyntaxFactory.TokenList(
                    SyntaxFactory.Token(SyntaxKind.PublicKeyword).WithTrailingTrivia(SyntaxHelper.WhiteSpace)),
                SyntaxFactory.IdentifierName(nameof(Table)).WithTrailingTrivia(SyntaxHelper.WhiteSpace),
                null,
                SyntaxFactory.Identifier(nameof(IRunnable.Run)),
                null,
                SyntaxFactory.ParameterList(
                    SyntaxFactory.SeparatedList(new []
                    {
                        SyntaxFactory.Parameter(
                            new SyntaxList<AttributeListSyntax>(),
                            SyntaxTokenList.Create(
                                new SyntaxToken()),
                            SyntaxFactory.IdentifierName(nameof(CancellationToken))
                                .WithTrailingTrivia(SyntaxHelper.WhiteSpace),
                            SyntaxFactory.Identifier("token"), null)
                    })),
                new SyntaxList<TypeParameterConstraintClauseSyntax>(),
                SyntaxFactory.Block(SyntaxFactory.ParseStatement($"return {_methodNames.Pop()}(Provider, token);")),
                null);

            var param = SyntaxFactory.PropertyDeclaration(
                new SyntaxList<AttributeListSyntax>(),
                SyntaxFactory.TokenList(
                    SyntaxFactory.Token(SyntaxKind.PublicKeyword).WithTrailingTrivia(SyntaxHelper.WhiteSpace)),
                SyntaxFactory.IdentifierName(nameof(ISchemaProvider)).WithTrailingTrivia(SyntaxHelper.WhiteSpace),
                null,
                SyntaxFactory.Identifier(nameof(IRunnable.Provider)),
                SyntaxFactory.AccessorList(
                    SyntaxFactory.List<AccessorDeclarationSyntax>()
                        .Add(SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
                            .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)))
                        .Add(SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration)
                            .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)))),
                null,
                null);

            _members.Add(method);
            _members.Add(param);

            var inMemoryTables = SyntaxFactory
                .FieldDeclaration(SyntaxFactory
                    .VariableDeclaration(SyntaxFactory.ArrayType(SyntaxFactory.IdentifierName(nameof(Table)))
                        .WithRankSpecifiers(SyntaxFactory.SingletonList(
                            SyntaxFactory.ArrayRankSpecifier(
                                SyntaxFactory.SingletonSeparatedList<ExpressionSyntax>(
                                    SyntaxFactory.OmittedArraySizeExpression()))))).WithVariables(
                        SyntaxFactory.SingletonSeparatedList(SyntaxFactory
                            .VariableDeclarator(SyntaxFactory.Identifier("_tableResults")).WithInitializer(
                                SyntaxFactory.EqualsValueClause(SyntaxFactory.ArrayCreationExpression(SyntaxFactory
                                    .ArrayType(SyntaxFactory.IdentifierName(nameof(Table))).WithRankSpecifiers(
                                        SyntaxFactory.SingletonList(
                                            SyntaxFactory.ArrayRankSpecifier(
                                                SyntaxFactory.SingletonSeparatedList<ExpressionSyntax>(
                                                    SyntaxFactory.LiteralExpression(SyntaxKind.NumerireplacederalExpression,
                                                        SyntaxFactory.Literal(_inMemoryTableIndex))))))))))))
                .WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PrivateKeyword)));

            _members.Insert(0, inMemoryTables);

            var clreplacedDeclaration = Generator.ClreplacedDeclaration(ClreplacedName, new string[0], Accessibility.Public,
                DeclarationModifiers.None,
                null,
                new SyntaxNode[]
                {
                    SyntaxFactory.IdentifierName(nameof(BaseOperations)),
                    SyntaxFactory.IdentifierName(nameof(IRunnable))
                }, _members);

            var ns = SyntaxFactory.NamespaceDeclaration(
                SyntaxFactory.IdentifierName(SyntaxFactory.Identifier(Namespace)),
                SyntaxFactory.List<ExternAliasDirectiveSyntax>(),
                SyntaxFactory.List(
                    _namespaces.Select(
                        n => SyntaxFactory.UsingDirective(SyntaxFactory.IdentifierName(n)))),
                SyntaxFactory.List<MemberDeclarationSyntax>(new[] {(ClreplacedDeclarationSyntax) clreplacedDeclaration}));

            var compilationUnit = SyntaxFactory.CompilationUnit(
                SyntaxFactory.List<ExternAliasDirectiveSyntax>(),
                SyntaxFactory.List<UsingDirectiveSyntax>(),
                SyntaxFactory.List<AttributeListSyntax>(),
                SyntaxFactory.List<MemberDeclarationSyntax>(new[] {ns}));

            var options = Workspace.Options;
            options = options.WithChangedOption(CSharpFormattingOptions.NewLinesForBracesInMethods, true);
            options.WithChangedOption(CSharpFormattingOptions.NewLinesForBracesInProperties, true);

            var formatted = Formatter.Format(compilationUnit, Workspace);

            Compilation = Compilation.AddSyntaxTrees(SyntaxFactory.ParseSyntaxTree(formatted.ToFullString(),
                new CSharpParseOptions(LanguageVersion.CSharp7_3), null, Encoding.ASCII));
        }

19 Source : ToCSharpRewriteTreeVisitor.cs
with MIT License
from Puchaczov

public void Visit(UnionNode node)
        {
            var b = _methodNames.Pop();
            var a = _methodNames.Pop();
            var name = $"{a}_Union_{b}";
            _methodNames.Push(name);

            var aInvocation = SyntaxFactory
                .InvocationExpression(SyntaxFactory.IdentifierName(a))
                .WithArgumentList(
                    SyntaxFactory.ArgumentList(
                        SyntaxFactory.SeparatedList(
                            new SyntaxNode[]
                            {
                                SyntaxFactory.Argument(
                                    SyntaxFactory.IdentifierName("provider")),
                                SyntaxFactory.Argument(
                                    SyntaxFactory.IdentifierName("token"))
                            }
                            )));

            var bInvocation = SyntaxFactory
                .InvocationExpression(SyntaxFactory.IdentifierName(b))
                .WithArgumentList(
                    SyntaxFactory.ArgumentList(
                        SyntaxFactory.SeparatedList(
                            new SyntaxNode[]
                            {
                                SyntaxFactory.Argument(
                                    SyntaxFactory.IdentifierName("provider")),
                                SyntaxFactory.Argument(
                                    SyntaxFactory.IdentifierName("token"))
                            }
                        )));

            _members.Add(GenerateMethod(name, nameof(BaseOperations.Union), _scope[MetaAttributes.SetOperatorName],
                aInvocation, bInvocation));
        }

19 Source : ToCSharpRewriteTreeVisitor.cs
with MIT License
from Puchaczov

public void Visit(UnionAllNode node)
        {
            var b = _methodNames.Pop();
            var a = _methodNames.Pop();
            var name = $"{a}_UnionAll_{b}";
            _methodNames.Push(name);

            var aInvocation = SyntaxFactory
                .InvocationExpression(SyntaxFactory.IdentifierName(a))
                .WithArgumentList(
                    SyntaxFactory.ArgumentList(
                        SyntaxFactory.SeparatedList(
                            new SyntaxNode[]
                            {
                                SyntaxFactory.Argument(
                                    SyntaxFactory.IdentifierName("provider")),
                                SyntaxFactory.Argument(
                                    SyntaxFactory.IdentifierName("token"))
                            }
                        )));

            var bInvocation = SyntaxFactory
                .InvocationExpression(SyntaxFactory.IdentifierName(b))
                .WithArgumentList(
                    SyntaxFactory.ArgumentList(
                        SyntaxFactory.SeparatedList(
                            new SyntaxNode[]
                            {
                                SyntaxFactory.Argument(
                                    SyntaxFactory.IdentifierName("provider")),
                                SyntaxFactory.Argument(
                                    SyntaxFactory.IdentifierName("token"))
                            }
                        )));

            _members.Add(GenerateMethod(name, nameof(BaseOperations.UnionAll), _scope[MetaAttributes.SetOperatorName],
                aInvocation, bInvocation));
        }

19 Source : ToCSharpRewriteTreeVisitor.cs
with MIT License
from Puchaczov

public void Visit(ExceptNode node)
        {
            var b = _methodNames.Pop();
            var a = _methodNames.Pop();
            var name = $"{a}_Except_{b}";
            _methodNames.Push(name);

            var aInvocation = SyntaxFactory
                .InvocationExpression(SyntaxFactory.IdentifierName(a))
                .WithArgumentList(
                    SyntaxFactory.ArgumentList(
                        SyntaxFactory.SeparatedList(
                            new SyntaxNode[]
                            {
                                SyntaxFactory.Argument(
                                    SyntaxFactory.IdentifierName("provider")),
                                SyntaxFactory.Argument(
                                    SyntaxFactory.IdentifierName("token"))
                            }
                        )));

            var bInvocation = SyntaxFactory
                .InvocationExpression(SyntaxFactory.IdentifierName(b))
                .WithArgumentList(
                    SyntaxFactory.ArgumentList(
                        SyntaxFactory.SeparatedList(
                            new SyntaxNode[]
                            {
                                SyntaxFactory.Argument(
                                    SyntaxFactory.IdentifierName("provider")),
                                SyntaxFactory.Argument(
                                    SyntaxFactory.IdentifierName("token"))
                            }
                        )));

            _members.Add(GenerateMethod(name, nameof(BaseOperations.Except), _scope[MetaAttributes.SetOperatorName],
                aInvocation, bInvocation));
        }

19 Source : ToCSharpRewriteTreeVisitor.cs
with MIT License
from Puchaczov

public void Visit(IntersectNode node)
        {
            var b = _methodNames.Pop();
            var a = _methodNames.Pop();
            var name = $"{a}_Intersect_{b}";
            _methodNames.Push(name);

            var aInvocation = SyntaxFactory
                .InvocationExpression(SyntaxFactory.IdentifierName(a))
                .WithArgumentList(
                    SyntaxFactory.ArgumentList(
                        SyntaxFactory.SeparatedList(
                            new SyntaxNode[]
                            {
                                SyntaxFactory.Argument(
                                    SyntaxFactory.IdentifierName("provider")),
                                SyntaxFactory.Argument(
                                    SyntaxFactory.IdentifierName("token"))
                            }
                        )));

            var bInvocation = SyntaxFactory
                .InvocationExpression(SyntaxFactory.IdentifierName(b))
                .WithArgumentList(
                    SyntaxFactory.ArgumentList(
                        SyntaxFactory.SeparatedList(
                            new SyntaxNode[]
                            {
                                SyntaxFactory.Argument(
                                    SyntaxFactory.IdentifierName("provider")),
                                SyntaxFactory.Argument(
                                    SyntaxFactory.IdentifierName("token"))
                            }
                        )));

            _members.Add(GenerateMethod(name, nameof(BaseOperations.Intersect), _scope[MetaAttributes.SetOperatorName],
                aInvocation, bInvocation));
        }

19 Source : ToCSharpRewriteTreeVisitor.cs
with MIT License
from Puchaczov

public void Visit(CteExpressionNode node)
        {
            var statements = new List<StatementSyntax>();

            var resultCteMethodName = _methodNames.Pop();

            foreach (var _ in node.InnerExpression)
            {
                _methodNames.Pop();
                statements.Add((StatementSyntax) Nodes.Pop());
            }

            statements.Reverse();

            var methodName = "CteResultQuery";

            statements.Add(
                SyntaxFactory.ReturnStatement(SyntaxFactory
                    .InvocationExpression(SyntaxFactory.IdentifierName(resultCteMethodName)).WithArgumentList(
                        SyntaxFactory.ArgumentList(
                            SyntaxFactory.SeparatedList(new[]
                            {
                                SyntaxFactory.Argument(SyntaxFactory.IdentifierName("provider")),
                                SyntaxFactory.Argument(SyntaxFactory.IdentifierName("token"))
                            })))));

            var method = SyntaxFactory.MethodDeclaration(
                new SyntaxList<AttributeListSyntax>(),
                SyntaxFactory.TokenList(
                    SyntaxFactory.Token(SyntaxKind.PrivateKeyword).WithTrailingTrivia(SyntaxHelper.WhiteSpace)),
                SyntaxFactory.IdentifierName(nameof(Table)).WithTrailingTrivia(SyntaxHelper.WhiteSpace),
                null,
                SyntaxFactory.Identifier(methodName),
                null,
                SyntaxFactory.ParameterList(
                    SyntaxFactory.SeparatedList(new[]
                    {
                        SyntaxFactory.Parameter(
                            new SyntaxList<AttributeListSyntax>(),
                            SyntaxTokenList.Create(
                                new SyntaxToken()),
                            SyntaxFactory.IdentifierName(nameof(ISchemaProvider))
                                .WithTrailingTrivia(SyntaxHelper.WhiteSpace),
                            SyntaxFactory.Identifier("provider"), null),

                        SyntaxFactory.Parameter(
                            new SyntaxList<AttributeListSyntax>(),
                            SyntaxTokenList.Create(
                                new SyntaxToken()),
                            SyntaxFactory.IdentifierName(nameof(CancellationToken))
                                .WithTrailingTrivia(SyntaxHelper.WhiteSpace),
                            SyntaxFactory.Identifier("token"), null)
                    })),
                new SyntaxList<TypeParameterConstraintClauseSyntax>(),
                SyntaxFactory.Block(statements),
                null);

            _members.Add(method);
            _methodNames.Push(methodName);
        }

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 : 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

private CSharpSyntaxNode GenerateLambdaBody(string first, string second, string key)
        {
            var indexes = _setOperatorFieldIndexes[key];
            var equality = SyntaxFactory
                .InvocationExpression(
                    SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
                        SyntaxFactory.ElementAccessExpression(SyntaxFactory.IdentifierName(first)).WithArgumentList(
                            SyntaxFactory.BracketedArgumentList(SyntaxFactory.SingletonSeparatedList(
                                SyntaxFactory.Argument(SyntaxFactory.LiteralExpression(
                                    SyntaxKind.NumerireplacederalExpression,
                                    SyntaxFactory.Literal(indexes[0])))))), SyntaxFactory.IdentifierName("Equals")))
                .WithArgumentList(SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(
                    SyntaxFactory.Argument(SyntaxFactory.ElementAccessExpression(SyntaxFactory.IdentifierName(second))
                        .WithArgumentList(SyntaxFactory.BracketedArgumentList(
                            SyntaxFactory.SingletonSeparatedList(
                                SyntaxFactory.Argument(
                                    SyntaxFactory.LiteralExpression(SyntaxKind.NumerireplacederalExpression,
                                        SyntaxFactory.Literal(indexes[0]))))))))));


            var subExpressions = new Stack<ExpressionSyntax>();
            subExpressions.Push(equality);

            for (var i = 1; i < indexes.Length; i++)
            {
                equality = SyntaxFactory
                    .InvocationExpression(
                        SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
                            SyntaxFactory.ElementAccessExpression(SyntaxFactory.IdentifierName(first)).WithArgumentList(
                                SyntaxFactory.BracketedArgumentList(SyntaxFactory.SingletonSeparatedList(
                                    SyntaxFactory.Argument(SyntaxFactory.LiteralExpression(
                                        SyntaxKind.NumerireplacederalExpression,
                                        SyntaxFactory.Literal(indexes[i])))))), SyntaxFactory.IdentifierName("Equals")))
                    .WithArgumentList(SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(
                        SyntaxFactory.Argument(SyntaxFactory
                            .ElementAccessExpression(SyntaxFactory.IdentifierName(second))
                            .WithArgumentList(SyntaxFactory.BracketedArgumentList(
                                SyntaxFactory.SingletonSeparatedList(
                                    SyntaxFactory.Argument(
                                        SyntaxFactory.LiteralExpression(SyntaxKind.NumerireplacederalExpression,
                                            SyntaxFactory.Literal(indexes[i]))))))))));

                subExpressions.Push(
                    SyntaxFactory.BinaryExpression(
                        SyntaxKind.LogicalAndExpression,
                        subExpressions.Pop(),
                        equality));
            }

            return subExpressions.Pop();
        }

19 Source : ToCSharpRewriteTreeVisitor.cs
with MIT License
from Puchaczov

private void CreateDescForSchema(DescNode node)
        {
            CreateDescMethod(node,
                SyntaxFactory.InvocationExpression(
                        SyntaxFactory.MemberAccessExpression(
                            SyntaxKind.SimpleMemberAccessExpression,
                            SyntaxFactory.IdentifierName(nameof(EvaluationHelper)),
                            SyntaxFactory.IdentifierName(nameof(EvaluationHelper.GetSpecificSchemaDescriptions))))
                    .WithArgumentList(
                        SyntaxFactory.ArgumentList(
                            SyntaxFactory.SingletonSeparatedList(
                                SyntaxFactory.Argument(SyntaxFactory.IdentifierName("desc"))))), false);
        }

19 Source : ToCSharpRewriteTreeVisitor.cs
with MIT License
from Puchaczov

public void Visit(IdentifierNode node)
        {
            Nodes.Push(SyntaxFactory.ElementAccessExpression(SyntaxFactory.IdentifierName("_tableResults"))
                .WithArgumentList(
                    SyntaxFactory.BracketedArgumentList(
                        SyntaxFactory.SingletonSeparatedList(
                            SyntaxFactory.Argument(
                            SyntaxFactory.LiteralExpression(
                                SyntaxKind.NumerireplacederalExpression,
                                SyntaxFactory.Literal(_inMemoryTableIndexes[node.Name])))))));
        }

19 Source : ToCSharpRewriteTreeVisitor.cs
with MIT License
from Puchaczov

public void Visit(AccessObjectKeyNode node)
        {
            var exp = SyntaxFactory.ParenthesizedExpression((ExpressionSyntax) Nodes.Pop());

            Nodes.Push(SyntaxFactory
                .ElementAccessExpression(SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
                    exp, SyntaxFactory.IdentifierName(node.Name))).WithArgumentList(
                    SyntaxFactory.BracketedArgumentList(SyntaxFactory.SingletonSeparatedList(
                        SyntaxFactory.Argument(SyntaxFactory.LiteralExpression(SyntaxKind.NumerireplacederalExpression,
                            SyntaxFactory.Literal(node.Token.Key)))))));
        }

19 Source : ToCSharpRewriteTreeVisitor.cs
with MIT License
from Puchaczov

public void Visit(PropertyValueNode node)
        {
            var exp = SyntaxFactory.ParenthesizedExpression((ExpressionSyntax) Nodes.Pop());

            Nodes.Push(
                SyntaxFactory.MemberAccessExpression(
                    SyntaxKind.SimpleMemberAccessExpression,
                    exp,
                    SyntaxFactory.IdentifierName(node.Name)));
        }

See More Examples