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
19
Source : CodeFixProvider.cs
with GNU General Public License v3.0
from AminEsmaeily
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
with MIT License
from Puchaczov
public void Visit(JoinInMemoryWithSourceTableFromNode node)
{
var ifStatement = Generator.IfStatement(Generator.LogicalNotExpression(Nodes.Pop()),
new SyntaxNode[] {SyntaxFactory.ContinueStatement()})
.WithTrailingTrivia(SyntaxFactory.CarriageReturnLineFeed);
_emptyBlock = SyntaxFactory.Block();
var computingBlock = SyntaxFactory.Block();
switch (node.JoinType)
{
case JoinType.Inner:
computingBlock = computingBlock.AddStatements(
SyntaxFactory.ForEachStatement(
SyntaxFactory.IdentifierName("var"),
SyntaxFactory.Identifier($"{node.InMemoryTableAlias}Row"),
SyntaxFactory.IdentifierName(
$"{nameof(EvaluationHelper)}.{nameof(EvaluationHelper.ConvertTableToSource)}({node.InMemoryTableAlias}TransitionTable).{nameof(RowSource.Rows)}"),
SyntaxFactory.Block(
SyntaxFactory.SingletonList<StatementSyntax>(
SyntaxFactory.ForEachStatement(
SyntaxFactory.IdentifierName("var"),
SyntaxFactory.Identifier($"{node.SourceTable.Alias}Row"),
SyntaxFactory.IdentifierName($"{node.SourceTable.Alias}Rows.Rows"),
SyntaxFactory.Block(
GenerateCancellationExpression(),
(StatementSyntax)ifStatement,
_emptyBlock))))));
break;
case JoinType.OuterLeft:
var fullTransitionTable = _scope.ScopeSymbolTable.GetSymbol<TableSymbol>(_queryAlias);
var fieldNames = _scope.ScopeSymbolTable.GetSymbol<FieldsNamesSymbol>(MetaAttributes.OuterJoinSelect);
var expressions = new List<ExpressionSyntax>();
int j = 0;
for (int i = 0; i < fullTransitionTable.CompoundTables.Length - 1; i++)
{
foreach(var column in fullTransitionTable.GetColumns(fullTransitionTable.CompoundTables[i]))
{
expressions.Add(
SyntaxFactory.ElementAccessExpression(
SyntaxFactory.IdentifierName($"{node.InMemoryTableAlias}Row"),
SyntaxFactory.BracketedArgumentList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Argument(
(LiteralExpressionSyntax)Generator.LiteralExpression(fieldNames.Names[j]))))));
j += 1;
}
}
foreach (var column in fullTransitionTable.GetColumns(fullTransitionTable.CompoundTables[fullTransitionTable.CompoundTables.Length - 1]))
{
expressions.Add(
SyntaxFactory.CastExpression(
SyntaxFactory.IdentifierName(
EvaluationHelper.GetCastableType(column.ColumnType)),
(LiteralExpressionSyntax)Generator.NullLiteralExpression()));
}
var arrayType = SyntaxFactory.ArrayType(
SyntaxFactory.IdentifierName("object"),
new SyntaxList<ArrayRankSpecifierSyntax>(
SyntaxFactory.ArrayRankSpecifier(
SyntaxFactory.SingletonSeparatedList(
(ExpressionSyntax)SyntaxFactory.OmittedArraySizeExpression()))));
var rewriteSelect =
SyntaxFactory.VariableDeclaration(
SyntaxFactory.IdentifierName("var"),
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier("select"),
null,
SyntaxFactory.EqualsValueClause(
SyntaxFactory.ArrayCreationExpression(
arrayType,
SyntaxFactory.InitializerExpression(
SyntaxKind.ArrayInitializerExpression,
SyntaxFactory.SeparatedList(expressions)))))));
var invocation = SyntaxHelper.CreateMethodInvocation(
_scope[MetaAttributes.SelectIntoVariableName],
nameof(Table.Add),
new[]
{
SyntaxFactory.Argument(
SyntaxFactory.ObjectCreationExpression(
SyntaxFactory.Token(SyntaxKind.NewKeyword).WithTrailingTrivia(SyntaxHelper.WhiteSpace),
SyntaxFactory.ParseTypeName(nameof(ObjectsRow)),
SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList(
new[]
{
SyntaxFactory.Argument(SyntaxFactory.IdentifierName("select")),
SyntaxFactory.Argument(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName($"{node.InMemoryTableAlias}Row"),
SyntaxFactory.IdentifierName($"{nameof(IObjectResolver.Contexts)}"))),
SyntaxFactory.Argument(
SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression))
})
),
SyntaxFactory.InitializerExpression(SyntaxKind.ComplexElementInitializerExpression))
)});
computingBlock = computingBlock.AddStatements(
SyntaxFactory.ForEachStatement(
SyntaxFactory.IdentifierName("var"),
SyntaxFactory.Identifier($"{node.InMemoryTableAlias}Row"),
SyntaxFactory.IdentifierName(
$"{nameof(EvaluationHelper)}.{nameof(EvaluationHelper.ConvertTableToSource)}({node.InMemoryTableAlias}TransitionTable).{nameof(RowSource.Rows)}"),
SyntaxFactory.Block(
SyntaxFactory.LocalDeclarationStatement(
SyntaxHelper.Createreplacedignment("hasAnyRowMatched", SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression))),
SyntaxFactory.ForEachStatement(
SyntaxFactory.IdentifierName("var"),
SyntaxFactory.Identifier($"{node.SourceTable.Alias}Row"),
SyntaxFactory.IdentifierName($"{node.SourceTable.Alias}Rows.Rows"),
SyntaxFactory.Block(
GenerateCancellationExpression(),
(StatementSyntax)ifStatement,
_emptyBlock,
SyntaxFactory.IfStatement(
(PrefixUnaryExpressionSyntax) Generator.LogicalNotExpression(SyntaxFactory.IdentifierName("hasAnyRowMatched")),
SyntaxFactory.Block(
SyntaxFactory.ExpressionStatement(
SyntaxFactory.replacedignmentExpression(
SyntaxKind.SimplereplacedignmentExpression,
SyntaxFactory.IdentifierName("hasAnyRowMatched"),
(LiteralExpressionSyntax) Generator.TrueLiteralExpression())))))),
SyntaxFactory.IfStatement(
(PrefixUnaryExpressionSyntax)Generator.LogicalNotExpression(SyntaxFactory.IdentifierName("hasAnyRowMatched")),
SyntaxFactory.Block(
SyntaxFactory.LocalDeclarationStatement(rewriteSelect),
SyntaxFactory.ExpressionStatement(invocation))))));
break;
case JoinType.OuterRight:
fullTransitionTable = _scope.ScopeSymbolTable.GetSymbol<TableSymbol>(_queryAlias);
fieldNames = _scope.ScopeSymbolTable.GetSymbol<FieldsNamesSymbol>(MetaAttributes.OuterJoinSelect);
expressions = new List<ExpressionSyntax>();
j = 0;
for (int i = 0; i < fullTransitionTable.CompoundTables.Length - 1; i++)
{
foreach (var column in fullTransitionTable.GetColumns(fullTransitionTable.CompoundTables[i]))
{
expressions.Add(
SyntaxFactory.CastExpression(
SyntaxFactory.IdentifierName(
EvaluationHelper.GetCastableType(column.ColumnType)),
(LiteralExpressionSyntax)Generator.NullLiteralExpression()));
j += 1;
}
}
foreach (var column in fullTransitionTable.GetColumns(fullTransitionTable.CompoundTables[fullTransitionTable.CompoundTables.Length - 1]))
{
expressions.Add(
SyntaxFactory.ElementAccessExpression(
SyntaxFactory.IdentifierName($"{node.SourceTable.Alias}Row"),
SyntaxFactory.BracketedArgumentList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Argument(
(LiteralExpressionSyntax)Generator.LiteralExpression(fieldNames.Names[j++]))))));
}
arrayType = SyntaxFactory.ArrayType(
SyntaxFactory.IdentifierName("object"),
new SyntaxList<ArrayRankSpecifierSyntax>(
SyntaxFactory.ArrayRankSpecifier(
SyntaxFactory.SingletonSeparatedList(
(ExpressionSyntax)SyntaxFactory.OmittedArraySizeExpression()))));
rewriteSelect =
SyntaxFactory.VariableDeclaration(
SyntaxFactory.IdentifierName("var"),
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier("select"),
null,
SyntaxFactory.EqualsValueClause(
SyntaxFactory.ArrayCreationExpression(
arrayType,
SyntaxFactory.InitializerExpression(
SyntaxKind.ArrayInitializerExpression,
SyntaxFactory.SeparatedList(expressions)))))));
invocation = SyntaxHelper.CreateMethodInvocation(
_scope[MetaAttributes.SelectIntoVariableName],
nameof(Table.Add),
new[]
{
SyntaxFactory.Argument(
SyntaxFactory.ObjectCreationExpression(
SyntaxFactory.Token(SyntaxKind.NewKeyword).WithTrailingTrivia(SyntaxHelper.WhiteSpace),
SyntaxFactory.ParseTypeName(nameof(ObjectsRow)),
SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList(
new[]
{
SyntaxFactory.Argument(SyntaxFactory.IdentifierName("select")),
SyntaxFactory.Argument(
SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)),
SyntaxFactory.Argument(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName($"{node.SourceTable.Alias}Row"),
SyntaxFactory.IdentifierName($"{nameof(IObjectResolver.Contexts)}")))
})
),
SyntaxFactory.InitializerExpression(SyntaxKind.ComplexElementInitializerExpression))
)});
computingBlock = computingBlock.AddStatements(
SyntaxFactory.ForEachStatement(
SyntaxFactory.IdentifierName("var"),
SyntaxFactory.Identifier($"{node.SourceTable.Alias}Row"),
SyntaxFactory.IdentifierName($"{node.SourceTable.Alias}Rows.Rows"),
SyntaxFactory.Block(
SyntaxFactory.LocalDeclarationStatement(
SyntaxHelper.Createreplacedignment("hasAnyRowMatched", SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression))),
SyntaxFactory.ForEachStatement(
SyntaxFactory.IdentifierName("var"),
SyntaxFactory.Identifier($"{node.InMemoryTableAlias}Row"),
SyntaxFactory.IdentifierName(
$"{nameof(EvaluationHelper)}.{nameof(EvaluationHelper.ConvertTableToSource)}({node.InMemoryTableAlias}TransitionTable).{nameof(RowSource.Rows)}"),
SyntaxFactory.Block(
GenerateCancellationExpression(),
(StatementSyntax)ifStatement,
_emptyBlock,
SyntaxFactory.IfStatement(
(PrefixUnaryExpressionSyntax)Generator.LogicalNotExpression(SyntaxFactory.IdentifierName("hasAnyRowMatched")),
SyntaxFactory.Block(
SyntaxFactory.ExpressionStatement(
SyntaxFactory.replacedignmentExpression(
SyntaxKind.SimplereplacedignmentExpression,
SyntaxFactory.IdentifierName("hasAnyRowMatched"),
(LiteralExpressionSyntax)Generator.TrueLiteralExpression())))))),
SyntaxFactory.IfStatement(
(PrefixUnaryExpressionSyntax)Generator.LogicalNotExpression(SyntaxFactory.IdentifierName("hasAnyRowMatched")),
SyntaxFactory.Block(
SyntaxFactory.LocalDeclarationStatement(rewriteSelect),
SyntaxFactory.ExpressionStatement(invocation))))));
break;
}
NullSuspiciousNodes.Clear();
_joinBlock = computingBlock;
}
19
Source : ToCSharpRewriteTreeVisitor.cs
with MIT License
from Puchaczov
with MIT License
from Puchaczov
public void Visit(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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
with MIT License
from Puchaczov
public void Visit(SelectNode node)
{
var scoreTable = _scope[MetaAttributes.SelectIntoVariableName];
var variableNameKeyword = SyntaxFactory.Identifier(SyntaxTriviaList.Empty, "select",
SyntaxTriviaList.Create(SyntaxHelper.WhiteSpace));
var syntaxList = new ExpressionSyntax[node.Fields.Length];
for (var i = 0; i < node.Fields.Length; i++)
syntaxList[node.Fields.Length - 1 - i] = (ExpressionSyntax) Nodes.Pop();
var array = SyntaxHelper.CreateArrayOfObjects(syntaxList.ToArray());
var equalsClause = SyntaxFactory.EqualsValueClause(
SyntaxFactory.Token(SyntaxKind.EqualsToken).WithTrailingTrivia(SyntaxHelper.WhiteSpace), array);
var variableDecl = SyntaxFactory.VariableDeclarator(variableNameKeyword, null, equalsClause);
var list = SyntaxFactory.SeparatedList(new List<VariableDeclaratorSyntax>
{
variableDecl
});
var variableDeclaration =
SyntaxFactory.VariableDeclaration(
SyntaxFactory.IdentifierName("var").WithTrailingTrivia(SyntaxHelper.WhiteSpace),
list);
var contexts = _scope[MetaAttributes.Contexts].Split(',');
var contextsExpressions = new List<ArgumentSyntax>
{
SyntaxFactory.Argument(
SyntaxFactory.IdentifierName(variableNameKeyword.Text))
};
foreach (var context in contexts)
{
var rowVariableName = string.Empty;
switch (_type)
{
case MethodAccessType.TransformingQuery:
rowVariableName = $"{context}Row";
break;
case MethodAccessType.ResultQuery:
case MethodAccessType.CaseWhen:
rowVariableName = "score";
break;
}
contextsExpressions.Add(
SyntaxFactory.Argument(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName(rowVariableName),
SyntaxFactory.IdentifierName($"{nameof(IObjectResolver.Contexts)}"))));
}
var invocation = SyntaxHelper.CreateMethodInvocation(
scoreTable,
nameof(Table.Add),
new[]
{
SyntaxFactory.Argument(
SyntaxFactory.ObjectCreationExpression(
SyntaxFactory.Token(SyntaxKind.NewKeyword).WithTrailingTrivia(SyntaxHelper.WhiteSpace),
SyntaxFactory.ParseTypeName(nameof(ObjectsRow)),
SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList(
contextsExpressions.ToArray())
),
SyntaxFactory.InitializerExpression(SyntaxKind.ComplexElementInitializerExpression))
)
});
var a1 = SyntaxFactory.LocalDeclarationStatement(variableDeclaration)
.WithTrailingTrivia(SyntaxFactory.CarriageReturnLineFeed);
var a2 = SyntaxFactory.ExpressionStatement(invocation)
.WithTrailingTrivia(SyntaxFactory.CarriageReturnLineFeed);
NullSuspiciousNodes.Clear();
_selectBlock = SyntaxFactory.Block(a1, a2);
}
19
Source : ToCSharpRewriteTreeVisitor.cs
with MIT License
from Puchaczov
with MIT License
from Puchaczov
public void Visit(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
with MIT License
from Puchaczov
private StatementSyntax GenerateCancellationExpression()
{
return SyntaxFactory.ExpressionStatement(
SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("token"),
SyntaxFactory.IdentifierName(
nameof(CancellationToken.ThrowIfCancellationRequested)))));
}
19
Source : ToCSharpRewriteTreeVisitor.cs
with MIT License
from Puchaczov
with MIT License
from Puchaczov
public void Visit(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
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
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
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
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
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
with MIT License
from Puchaczov
public void Visit(CteInnerExpressionNode node)
{
if (!_inMemoryTableIndexes.ContainsKey(node.Name))
_inMemoryTableIndexes.Add(node.Name, _inMemoryTableIndex++);
Nodes.Push(SyntaxFactory.ExpressionStatement(SyntaxFactory.replacedignmentExpression(
SyntaxKind.SimplereplacedignmentExpression,
SyntaxFactory.ElementAccessExpression(SyntaxFactory.IdentifierName("_tableResults")).WithArgumentList(
SyntaxFactory.BracketedArgumentList(SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Argument(SyntaxFactory.LiteralExpression(SyntaxKind.NumerireplacederalExpression,
SyntaxFactory.Literal(_inMemoryTableIndexes[node.Name])))))),
SyntaxFactory.InvocationExpression(SyntaxFactory.IdentifierName(_methodNames.Peek())).WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList(
new []
{
SyntaxFactory.Argument(SyntaxFactory.IdentifierName("provider")),
SyntaxFactory.Argument(SyntaxFactory.IdentifierName("token"))
}))))));
}
19
Source : ToCSharpRewriteTreeVisitor.cs
with MIT License
from Puchaczov
with MIT License
from Puchaczov
private StatementSyntax AddGroupStatement(string scoreTable)
{
return SyntaxFactory.IfStatement(
SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression,
SyntaxFactory.InvocationExpression(SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("usedGroups"), SyntaxFactory.IdentifierName("Contains")))
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Argument(SyntaxFactory.IdentifierName("group")))))),
SyntaxFactory.Block(
SyntaxFactory.ExpressionStatement(
SyntaxFactory.InvocationExpression(SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName(scoreTable),
SyntaxFactory.IdentifierName("Add")))
.WithArgumentList(SyntaxFactory.ArgumentList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Argument(SyntaxFactory.IdentifierName("group")))))),
SyntaxFactory.ExpressionStatement(
SyntaxFactory.InvocationExpression(SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("usedGroups"), SyntaxFactory.IdentifierName("Add")))
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Argument(SyntaxFactory.IdentifierName("group"))))))));
}
19
Source : ToCSharpRewriteTreeVisitor.cs
with MIT License
from Puchaczov
with MIT License
from Puchaczov
private StatementSyntax GroupForStatement()
{
return
SyntaxFactory.ForStatement(SyntaxFactory.Block(
SyntaxFactory.ExpressionStatement(
SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("token"),
SyntaxFactory.IdentifierName(nameof(CancellationToken
.ThrowIfCancellationRequested))))),
SyntaxFactory.LocalDeclarationStatement(
SyntaxFactory.VariableDeclaration(
SyntaxFactory.IdentifierName("var"))
.WithVariables(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier("key"))
.WithInitializer(
SyntaxFactory.EqualsValueClause(
SyntaxFactory
.ElementAccessExpression(SyntaxFactory.IdentifierName("keys"))
.WithArgumentList(SyntaxFactory.BracketedArgumentList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Argument(
SyntaxFactory.IdentifierName("i")))))))))),
SyntaxFactory.IfStatement(
SyntaxFactory.InvocationExpression(SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("groups"),
SyntaxFactory.IdentifierName("ContainsKey"))).WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Argument(SyntaxFactory.IdentifierName("key"))))),
SyntaxFactory.Block(SyntaxFactory.SingletonList<StatementSyntax>(
SyntaxFactory.ExpressionStatement(SyntaxFactory.replacedignmentExpression(
SyntaxKind.SimplereplacedignmentExpression, SyntaxFactory.IdentifierName("group"),
SyntaxFactory.ElementAccessExpression(SyntaxFactory.IdentifierName("groups"))
.WithArgumentList(
SyntaxFactory.BracketedArgumentList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Argument(
SyntaxFactory.IdentifierName("key"))))))))))
.WithElse(SyntaxFactory.ElseClause(SyntaxFactory.Block(
SyntaxFactory.ExpressionStatement(SyntaxFactory.replacedignmentExpression(
SyntaxKind.SimplereplacedignmentExpression,
SyntaxFactory.IdentifierName("group"),
SyntaxFactory.ObjectCreationExpression(SyntaxFactory.IdentifierName("Group"))
.WithArgumentList(SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList<ArgumentSyntax>(new SyntaxNodeOrToken[]
{
SyntaxFactory.Argument(SyntaxFactory.IdentifierName("parent")),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(SyntaxFactory
.ElementAccessExpression(
SyntaxFactory.IdentifierName("groupFieldsNames"))
.WithArgumentList(SyntaxFactory.BracketedArgumentList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Argument(
SyntaxFactory.IdentifierName("i")))))),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(SyntaxFactory
.ElementAccessExpression(SyntaxFactory.IdentifierName("values"))
.WithArgumentList(SyntaxFactory.BracketedArgumentList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Argument(
SyntaxFactory.IdentifierName("i"))))))
}))))),
SyntaxFactory.ExpressionStatement(
SyntaxFactory.InvocationExpression(SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("groups"),
SyntaxFactory.IdentifierName("Add")))
.WithArgumentList(
SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList<ArgumentSyntax>(
new SyntaxNodeOrToken[]
{
SyntaxFactory.Argument(SyntaxFactory.IdentifierName("key")),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(SyntaxFactory.IdentifierName("group"))
}))))))),
SyntaxFactory.ExpressionStatement(SyntaxFactory.replacedignmentExpression(
SyntaxKind.SimplereplacedignmentExpression,
SyntaxFactory.IdentifierName("parent"), SyntaxFactory.IdentifierName("group")))))
.WithDeclaration(SyntaxFactory
.VariableDeclaration(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)))
.WithVariables(
SyntaxFactory.SingletonSeparatedList(SyntaxFactory
.VariableDeclarator(SyntaxFactory.Identifier("i"))
.WithInitializer(
SyntaxFactory.EqualsValueClause(SyntaxFactory.LiteralExpression(
SyntaxKind.NumerireplacederalExpression,
SyntaxFactory.Literal(0)))))))
.WithCondition(SyntaxFactory.BinaryExpression(SyntaxKind.LessThanExpression,
SyntaxFactory.IdentifierName("i"),
SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("keys"),
SyntaxFactory.IdentifierName("Length"))))
.WithIncrementors(SyntaxFactory.SingletonSeparatedList<ExpressionSyntax>(
SyntaxFactory.PrefixUnaryExpression(SyntaxKind.PreIncrementExpression,
SyntaxFactory.IdentifierName("i"))));
}
19
Source : ToCSharpRewriteTreeVisitor.cs
with MIT License
from Puchaczov
with MIT License
from Puchaczov
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
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
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
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
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