private static AssignmentExpressionSyntax CreateNewExpression(InitializerExpressionSyntax initializer)
{
SeparatedSyntaxList <ExpressionSyntax> expressions = initializer.Expressions;
SyntaxToken openBracket = Token(
initializer.OpenBraceToken.LeadingTrivia,
SyntaxKind.OpenBracketToken,
initializer.OpenBraceToken.TrailingTrivia.EmptyIfWhitespace());
ImplicitElementAccessSyntax implicitElementAccess = ImplicitElementAccess(
BracketedArgumentList(
openBracket,
SingletonSeparatedList(Argument(expressions[0].TrimTrivia())),
CloseBracketToken()));
SyntaxToken comma = initializer.ChildTokens().FirstOrDefault(f => f.IsKind(SyntaxKind.CommaToken));
SyntaxTriviaList commaLeading = comma.LeadingTrivia;
SyntaxToken equalsToken = Token(
(commaLeading.Any()) ? commaLeading : TriviaList(Space),
SyntaxKind.EqualsToken,
comma.TrailingTrivia);
ExpressionSyntax valueExpression = expressions[1];
valueExpression = valueExpression.AppendToTrailingTrivia(initializer.CloseBraceToken.LeadingTrivia.EmptyIfWhitespace());
return(SimpleAssignmentExpression(implicitElementAccess, equalsToken, valueExpression)
.WithTriviaFrom(initializer));
}
private static void AnalyzeBal(SyntaxNodeAnalysisContext context)
{
SyntaxNode node = context.Node;
if (!node.IsKind(SyntaxKind.BracketedArgumentList))
{
return;
}
BracketedArgumentListSyntax bal = (BracketedArgumentListSyntax)node;
ITypeSymbol type = null;
//account["name"] = "test";
if (bal.Parent.IsKind(SyntaxKind.ElementAccessExpression))
{
ElementAccessExpressionSyntax parent = (ElementAccessExpressionSyntax)bal.Parent;
if (!parent.Expression.IsKind(SyntaxKind.IdentifierName))
{
return;
}
IdentifierNameSyntax identifier = (IdentifierNameSyntax)parent.Expression;
if (identifier != null)
{
type = context.SemanticModel.GetTypeInfo(identifier).Type;
}
}
//Entity account = new Entity("account") { ["name"] = "test" };
if (bal.Parent.IsKind(SyntaxKind.ImplicitElementAccess))
{
ImplicitElementAccessSyntax parent = (ImplicitElementAccessSyntax)bal.Parent;
ObjectCreationExpressionSyntax identifier = parent.Ancestors().OfType <ObjectCreationExpressionSyntax>().First();
if (identifier != null)
{
type = context.SemanticModel.GetTypeInfo(identifier).Type;
}
}
if (type == null)
{
return;
}
//If type is not Microsoft.Xrm.Sdk.Entity - exit
if (type.ToString() != "Microsoft.Xrm.Sdk.Entity")
{
return;
}
//If arguement does not contain an upper case letter - exit
if (!bal.Arguments.ToString().ToCharArray().Any(char.IsUpper))
{
return;
}
var diagnostic = Diagnostic.Create(Rule, node.GetLocation(), bal.Arguments[0].Expression.GetFirstToken().ValueText);
context.ReportDiagnostic(diagnostic);
}
public static async Task <Document> RefactorAsync(
Document document,
InitializerExpressionSyntax initializer,
CancellationToken cancellationToken)
{
SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
SeparatedSyntaxList <ExpressionSyntax> expressions = initializer.Expressions;
ImplicitElementAccessSyntax implicitElementAccess = ImplicitElementAccess(
BracketedArgumentList(
OpenBracketToken().WithTriviaFrom(initializer.OpenBraceToken),
SingletonSeparatedList(Argument(expressions[0]).WithFormatterAnnotation()),
CloseBracketToken()));
AssignmentExpressionSyntax assignment = SimpleAssignmentExpression(
implicitElementAccess,
EqualsToken().WithTriviaFrom(initializer.ChildTokens().FirstOrDefault()),
expressions[1]
.AppendTrailingTrivia(initializer.CloseBraceToken.GetLeadingAndTrailingTrivia())
.WithFormatterAnnotation());
SyntaxNode newRoot = root.ReplaceNode(initializer, assignment);
return(document.WithSyntaxRoot(newRoot));
}
public override Ust VisitImplicitElementAccess(ImplicitElementAccessSyntax node)
{
var args = (ArgsUst)VisitBracketedArgumentList(node.ArgumentList);
var target = new IdToken(CommonUtils.Prefix + "index_initializer", default(TextSpan));
var result = new IndexerExpression(target, args, node.GetTextSpan());
return(result);
}
public override void VisitImplicitElementAccess(ImplicitElementAccessSyntax node)
{
if (!PreVisit(node))
{
return;
}
node.ArgumentList?.Accept(this);
base.VisitImplicitElementAccess(node);
PostVisit(node);
}
public static Task <Document> RefactorAsync(
Document document,
InitializerExpressionSyntax initializer,
CancellationToken cancellationToken)
{
SeparatedSyntaxList <ExpressionSyntax> expressions = initializer.Expressions;
SyntaxTriviaList openBraceTrailing = initializer.OpenBraceToken.TrailingTrivia;
SyntaxTriviaList closeBraceLeading = initializer.CloseBraceToken.LeadingTrivia;
SyntaxToken openBracket = Token(
initializer.OpenBraceToken.LeadingTrivia,
SyntaxKind.OpenBracketToken,
(openBraceTrailing.All(f => f.IsWhitespaceTrivia())) ? default(SyntaxTriviaList) : openBraceTrailing);
ImplicitElementAccessSyntax implicitElementAccess = ImplicitElementAccess(
BracketedArgumentList(
openBracket,
SingletonSeparatedList(Argument(expressions[0])),
CloseBracketToken()));
SyntaxToken comma = initializer.ChildTokens().FirstOrDefault(f => f.IsKind(SyntaxKind.CommaToken));
SyntaxTriviaList commaLeading = comma.LeadingTrivia;
SyntaxToken equalsToken = Token(
(commaLeading.Any()) ? commaLeading : TriviaList(Space),
SyntaxKind.EqualsToken,
comma.TrailingTrivia);
ExpressionSyntax valueExpression = expressions[1];
if (closeBraceLeading.Any(f => !f.IsWhitespaceTrivia()))
{
valueExpression = valueExpression.AppendToTrailingTrivia(closeBraceLeading);
}
AssignmentExpressionSyntax assignment = SimpleAssignmentExpression(implicitElementAccess, equalsToken, valueExpression)
.WithTriviaFrom(initializer);
return(document.ReplaceNodeAsync(initializer, assignment, cancellationToken));
}
public override void VisitImplicitElementAccess(ImplicitElementAccessSyntax node)
{
node.ArgumentList?.Accept(this);
base.VisitImplicitElementAccess(node);
}
public override void VisitImplicitElementAccess(ImplicitElementAccessSyntax node)
{
throw new NotImplementedException();
}
public override Evaluation VisitImplicitElementAccess(ImplicitElementAccessSyntax node)
{
node.ArgumentList?.Accept <Evaluation>(this);
return(base.VisitImplicitElementAccess(node));
}
private Doc PrintImplicitElementAccessSyntax(
ImplicitElementAccessSyntax node)
{
return(this.Print(node.ArgumentList));
}
public override void VisitImplicitElementAccess(ImplicitElementAccessSyntax node) => base.VisitImplicitElementAccess(node);
public static Doc Print(ImplicitElementAccessSyntax node)
{
return(Node.Print(node.ArgumentList));
}
public override void VisitImplicitElementAccess(ImplicitElementAccessSyntax node)
{
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitImplicitElementAccess(ImplicitElementAccessSyntax node)
{
this.OnNodeVisited(node, this.type.IsInstanceOfType(node));
base.VisitImplicitElementAccess(node);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitImplicitElementAccess(ImplicitElementAccessSyntax node)
{
this.OnNodeVisited(node);
if (!this.traverseRootOnly) base.VisitImplicitElementAccess(node);
}
private void BuildImplicitElementAccessExpression(ImplicitElementAccessSyntax expression)
{
BuildInvocationLikeExpression(expression, null, expression.ArgumentList?.Arguments);
}
public override LuaSyntaxNode VisitImplicitElementAccess(ImplicitElementAccessSyntax node)
{
return(node.ArgumentList.Accept(this));
}
public TameImplicitElementAccessSyntax(ImplicitElementAccessSyntax node)
{
Node = node;
AddChildren();
}
public override SyntaxNode VisitImplicitElementAccess(ImplicitElementAccessSyntax node)
{
node = (ImplicitElementAccessSyntax)base.VisitImplicitElementAccess(node);
Classes.Add(node);
return(node);
}
public override Expr VisitImplicitElementAccess(ImplicitElementAccessSyntax node)
{
return(base.VisitImplicitElementAccess(node));
}
public override void VisitImplicitElementAccess(ImplicitElementAccessSyntax node)
{
Log(node, "Unsupported Syntax !");
}
private Block BuildImplicitElementAccessExpression(ImplicitElementAccessSyntax expression, Block currentBlock)
{
return(BuildInvocationLikeExpression(expression, currentBlock, null, expression.ArgumentList?.Arguments));
}
// // Summary: // Called when the visitor visits a ImplicitElementAccessSyntax node. public virtual void VisitImplicitElementAccess(ImplicitElementAccessSyntax node);
