private static Location GetDiagnosticLocation(SyntaxNode node)
{
if (node.HasLeadingTrivia)
{
return(node.GetLeadingTrivia()[0].GetLocation());
}
var firstToken = node.ChildTokens().FirstOrDefault();
if (firstToken != default(SyntaxToken))
{
return(node.ChildTokens().First().GetLocation());
}
return(Location.None);
}
private static bool FindMatchingBrace(int position, int direction, SyntaxNode parent, SyntaxKind syntaxKind, out TextSpan right)
{
var tokens = parent.ChildTokens().Where(t => t.Kind == syntaxKind);
var relevantTokens = direction < 0
? from t in tokens
where t.Span.End <= position
select t
: from t in tokens
where position < t.Span.Start
select t;
right = new TextSpan();
var found = false;
foreach (var token in relevantTokens)
{
if (!found)
{
right = token.Span;
found = true;
}
else
{
return(false);
}
}
return(found);
}
// TODO: Exception e is allowed
private bool IsNumberSeriesViolation(SyntaxNode declaration)
{
const string numberSeriesRegex = "^[a-zA-Z][0-9]{1,3}$";
var identifier = declaration.ChildTokens().First(t => t.RawKind == IdentifierToken);
return(Regex.IsMatch(identifier.Value.ToString(), numberSeriesRegex));
}
private XmlNodeSyntax GetTextNodeFromCommentTextNode(SyntaxNode textNode)
{
var tokens = new List <SyntaxToken>();
foreach (var token in textNode.ChildTokens())
{
switch (token.Kind())
{
case SyntaxKind.XmlTextLiteralNewLineToken:
tokens.Add(Token.CreateXmlTextNewLine());
break;
case SyntaxKind.XmlTextLiteralToken:
var text = token.ValueText.ToString();
var delimiter = noSpace;
if (tokens.Count() != 0 && tokens.Last().IsKind(SyntaxKind.XmlTextLiteralNewLineToken))
{
delimiter = _documentationCommentDelimiter;
}
tokens.Add(Token.CreateXmlTextLiteral(text, delimiter));
break;
default:
break;
}
}
return(Node.CreateXmlText(_documentationCommentDelimiter, tokens.ToArray()));
}
private AstWriter Write(SyntaxNode node)
{
this.WriteStartElement()
.Write(" ");
switch (this.settings.Format)
{
case AstFormat.Light:
this.Write(node.Kind().ToString());
break;
case AstFormat.Json:
this.WriteProperty("Kind", node.Kind().ToString());
break;
default:
throw new ArgumentOutOfRangeException();
}
this.indentation.Push();
if (this.settings.Trivia.HasFlag(AstTrivia.Node))
{
_ = this.WriteTrivia("LeadingTrivia", node.GetLeadingTrivia())
.WriteTrivia("TrailingTrivia", node.GetTrailingTrivia());
}
this.WriteChildTokens(node.ChildTokens().ToList())
.WriteChildNodes(node.ChildNodes().ToList())
.Write(" ")
.WriteEndElement();
this.indentation.Pop();
return(this);
}
public static string NameFrom(this SyntaxNode node)
{
var qualifiedNameNode = node.ChildNodes()
.OfType <QualifiedNameSyntax>()
.SingleOrDefault();
var identifierNameNodes = node.ChildNodes()
.OfType <IdentifierNameSyntax>()
.ToList();
var name = "";
if (qualifiedNameNode != null)
{
name = name + qualifiedNameNode.ToString();
}
foreach (var identifierNameNode in identifierNameNodes)
{
var identifierName = identifierNameNode.ToString();
if (!(string.IsNullOrWhiteSpace(name) || string.IsNullOrWhiteSpace(identifierName)))
{
name += ".";
}
name = name += identifierName;
}
if (!string.IsNullOrWhiteSpace(name))
{
return(name);
}
var nameToken = node.ChildTokens()
.Where(x => x.Kind() == SyntaxKind.IdentifierToken)
.SingleOrDefault();
return(nameToken.ValueText);
}
private static void AnalyzeBlock(CodeBlockEndAnalysisContext context)
{
SyntaxNode node = context.CodeBlock;
//If the node isn't a Method Declaration - exit
if (node.Kind() != SyntaxKind.MethodDeclaration)
{
return;
}
var block = node.ChildNodes().OfType <BlockSyntax>().FirstOrDefault();
if (block == null)
{
return;
}
//If there are less than 10 statements - exit
if (block.Statements.Count <= 10)
{
return;
}
//Get the identifier name
var methodName = node.ChildTokens().FirstOrDefault(k => k.Kind() == SyntaxKind.IdentifierToken).Text;
var diagnostic = Diagnostic.Create(Rule, block.GetLocation(), methodName);
context.ReportDiagnostic(diagnostic);
}
private static bool HasConstOrEquivalent(SyntaxNode node)
{
bool hasStatic = false;
bool hasReadOnly = false;
foreach (var tok in node.ChildTokens())
{
switch (tok.Kind())
{
case SyntaxKind.ReadOnlyKeyword:
hasReadOnly = true;
if (hasStatic)
{
return(true);
}
break;
case SyntaxKind.StaticKeyword:
hasStatic = true;
if (hasReadOnly)
{
return(true);
}
break;
case SyntaxKind.ConstKeyword:
return(true);
}
}
return(false);
}
private static string CreateName(CodeRefactoringContext context, SyntaxNode root, SyntaxNode blockSyntax, string typeName)
{
string name = typeName + "Const";
name = NameGenerator.GenerateUniqueName(name, root.ChildTokens().Where(t => t.IsKind(SyntaxKind.IdentifierToken)).Select(t => t.ToString()).ToSet(), StringComparer.Ordinal);
var newConstName = NameProposalService.GetNameProposal(name, SyntaxKind.MethodDeclaration, Accessibility.Private, true, context.Document, blockSyntax.SpanStart);
return(newConstName);
}
public static bool IsStatic(this SyntaxNode @this)
{
if (@this == null)
{
throw new ArgumentNullException(nameof(@this));
}
return(@this.ChildTokens()
.Any(t => t.IsKind(SyntaxKind.StaticKeyword)));
}
private static int SwapMembers(this IWpfTextView textView, SyntaxNode member1, SyntaxNode member2, MovePosition position, MoveDirection direction, IOleCommandTarget commandTarget, IEditorOperations editorOperations)
{
if (member1 == null || member2 == null)
{
return(-1);
}
int caretIndent = textView.Caret.Position.BufferPosition.Position - member1.FullSpan.Start;
int movePosition = 0;
string moveText = member1.GetText().ToString();
//Find the position to Move the Current method (i.e. member1)
if (position == MovePosition.Top)
{
movePosition = member2.FullSpan.Start;
}
else if (position == MovePosition.Bottom)
{
movePosition = member2.FullSpan.End;
}
else if (position == MovePosition.MiddlefromBottom)
{
movePosition = member2.ChildTokens().FirstOrDefault(t => t.IsKind(SyntaxKind.CloseBraceToken)).SpanStart - 1;
}
else if (position == MovePosition.MiddlefromTop)
{
movePosition = member2.ChildTokens().FirstOrDefault(t => t.IsKind(SyntaxKind.OpenBraceToken)).SpanStart + 1;
}
var editor = textView.TextSnapshot.TextBuffer.CreateEdit();
editor.Delete(member1.FullSpan.Start, member1.FullSpan.Length);
editor.Insert(movePosition, moveText);
editor.Apply();
int newCaretPosition = direction == MoveDirection.Up ? (movePosition + caretIndent) : (movePosition + caretIndent - moveText.Length);
textView.Caret.MoveTo(new SnapshotPoint(textView.TextSnapshot, newCaretPosition));
textView.Selection.Select(new SnapshotSpan(textView.TextSnapshot, (direction == MoveDirection.Up) ? movePosition : movePosition - moveText.Length, moveText.Length), false);
FormatDocument(commandTarget);
textView.Selection.Clear();
return(newCaretPosition);
}
public static void ReportProblems(CompilationAnalysisContext context, SyntaxNode methodDeclaration)
{
var staticKeyword = methodDeclaration.ChildTokens().Where(x => x.IsKind(SyntaxKind.StaticKeyword)).FirstOrDefault();
if (staticKeyword == null || staticKeyword.IsKind(SyntaxKind.None))
{
if (IsInEntityClass(methodDeclaration))
{
var methodName = methodDeclaration.ChildTokens().Where(x => x.IsKind(SyntaxKind.IdentifierToken)).FirstOrDefault();
if (methodName != null)
{
var diagnostic = Diagnostic.Create(Rule, methodName.GetLocation(), methodName);
context.ReportDiagnostic(diagnostic);
}
}
}
}
private void InitializeOOTypeMember(IOOTypeMember itemAsOO, SyntaxNode syntaxNode, IDom parent, SemanticModel model)
{
if (itemAsOO == null)
{
return;
}
var itemAsDom = itemAsOO as IRoslynHasSymbol;
//itemAsOO.IsAbstract = itemAsDom.Symbol.IsAbstract;
itemAsOO.IsAbstract = syntaxNode.ChildTokens().Any(x => x.Kind() == SyntaxKind.AbstractKeyword);
itemAsOO.IsVirtual = itemAsDom.Symbol.IsVirtual;
itemAsOO.IsOverride = itemAsDom.Symbol.IsOverride;
itemAsOO.IsSealed = itemAsDom.Symbol.IsSealed;
var itemAsCanBeNew = itemAsOO as ICanBeNew;
if (itemAsCanBeNew != null)
{
// See note on IsNew on interface before changing
itemAsCanBeNew.IsNew = syntaxNode.ChildTokens().Any(x => x.Kind() == SyntaxKind.NewKeyword);
}
}
private static async Task <Document> MakeConstantLeft(Document document, SyntaxNode node, CancellationToken cancellationToken)
{
// Sometimes the equal node is the child of the node passed in
if (!BTAnalyzer.IsEqualFamilyExpression(node.Kind()))
{
node = node.ChildNodes().FirstOrDefault();
}
// Get child nodes
if (null == node)
{
return(null);
}
// Get child node
SyntaxNode[] childNodes = node.ChildNodes().ToArray();
if (2 != childNodes.Count())
{
return(null);
}
// Replace the old local declaration with the new local declaration
var oldRoot = await document.GetSyntaxRootAsync(cancellationToken);
SyntaxNode newNode0 = childNodes[0].ReplaceToken(childNodes[0].GetFirstToken(), SyntaxFactory.ParseToken(childNodes[0].GetFirstToken().ToString().Trim()));
SyntaxNode newNode1 = childNodes[1].ReplaceToken(childNodes[1].GetFirstToken(), SyntaxFactory.ParseToken(childNodes[1].GetFirstToken().ToString() + " "));
SyntaxNode newRoot = null;
SyntaxNode newNode = null;
try
{
newNode = node.ReplaceNodes(childNodes, (original, _) => original == childNodes[0] ? newNode1 : newNode0);
SyntaxToken token = newNode.ChildTokens().FirstOrDefault();
if (null == token)
{
return(null);
}
if (BTCodeFixProvider.GreaterDictionary.ContainsKey(token.Kind()))
{
newNode = newNode.ReplaceToken(token, SyntaxFactory.ParseToken(SyntaxFactory.Token(BTCodeFixProvider.GreaterDictionary[token.Kind()]).ToString() + " "));
}
newRoot = oldRoot.ReplaceNode(node, newNode);
}
catch (Exception e)
{
}
// Return document with transformed tree
return(document.WithSyntaxRoot(newRoot));
}
// A syntax tree has SyntaxNodes, SyntaxTokens and SyntaxTrivia, for more detail please refer to link below:
// https://docs.microsoft.com/en-us/dotnet/csharp/roslyn-sdk/get-started/syntax-analysis
// This function's purpose is to remove all trivia from the syntax tree, so it needs to iterate through all
// existing SyntaxNodes and SyntaxTokens and to replace each of them without trivia.
public static SyntaxNode RemoveAllTrivia(this SyntaxNode node)
{
if (node != null)
{
node = node.WithoutTrivia();
var childNodes = node.ChildNodes();
node = node.ReplaceNodes(childNodes, (oldNode, _) => oldNode.RemoveAllTrivia());
var childTokens = node.ChildTokens();
node = node.ReplaceTokens(childTokens, (oldToken, _) => oldToken.WithoutTrivia());
}
return(node);
}
private bool IsSingleCharViolation(SyntaxNode declaration)
{
var identifier = declaration.ChildTokens().First(t => t.RawKind == IdentifierToken);
if (IsInLoop(declaration))
{
return(false);
}
if (IsInLamda(declaration))
{
return(false);
}
return(identifier.Value.ToString().Length == 1);
}
public static SyntaxNode Token2Child(this SyntaxNode node, string token)
{
if (node.ChildTokens().Any(t => t.ToString() == token))
{
return(node);
}
if (node.ChildNodes().Any(c => Token2Child(c, token) != null))
{
return(node.ChildNodes().First(c => Token2Child(c, token) != null));
}
else
{
return(null);
}
}
public static bool HasParentToken(this SyntaxNode node, string token)
{
if (node.ChildTokens().Any(t => t.ToString() == token))
{
return(true);
}
if (node.Parent != null)
{
return(HasParentToken(node.Parent, token));
}
else
{
return(false);
}
}
public static bool HasChildToken(this SyntaxNode node, string token)
{
if (node.ChildTokens().Any(t => t.ToString() == token))
{
return(true);
}
if (node.ChildNodes().Any(c => HasChildToken(c, token)))
{
return(true);
}
else
{
return(false);
}
}
public static SyntaxNode Token2Parent(this SyntaxNode node, string token)
{
if (node.ChildTokens().Any(t => t.ToString() == token))
{
return(node);
}
if (node.Parent != null && Token2Parent(node.Parent, token) != null)
{
return(Token2Parent(node.Parent, token));
}
else
{
return(null);
}
}
protected void HandleTrailingTrivia(SyntaxNode syntaxNode, SemanticModel model, IDom parent)
{
var trailingTrivia = syntaxNode.ChildTokens().Last().LeadingTrivia;
var trailing = CreateFromWorker.GetDetail(syntaxNode, trailingTrivia,
parent, model, OutputContext);
var container = parent as IRDomContainer;
if (trailing.Any() && container != null)
{
foreach (var newTrailing in trailing)
{
container.AddOrMoveMember(newTrailing);
}
}
}
private void TraverseIfCondition(SyntaxNodeAnalysisContext context, SyntaxNode node, ref int found)
{
foreach (var child in node.ChildTokens())
{
if (child.ValueText == "&&" || child.ValueText == "||")
{
found++;
}
}
foreach (var child in node.ChildNodes())
{
TraverseIfCondition(context, child, ref found);
}
}
private static bool TryGetFunctionNameInStringLiteral(SyntaxNode node, out string functionName)
{
if (node != null && node.IsKind(SyntaxKind.StringLiteralExpression))
{
var stringLiteralToken = node.ChildTokens().Where(x => x.IsKind(SyntaxKind.StringLiteralToken)).FirstOrDefault();
if (stringLiteralToken != null)
{
functionName = stringLiteralToken.ValueText;
return(true);
}
}
functionName = null;
return(false);
}
public override void Visit(SyntaxNode node)
{
var ns = node.Language == "C#" ? kindNs : node.Language;
var kind = new Kind(node.Kind().ToString(), ns, true);
var aNode = new AstNode("unknown", kind);
var span = node.GetLocation().GetLineSpan();
aNode.key = keyMan.GetKey();
aNode.SetProperty("filename", this.filename);
aNode.SetProperty("start_column", span.StartLinePosition.Character);
aNode.SetProperty("start_line", span.StartLinePosition.Line);
aNode.SetProperty("start_offset", node.Span.Start);
aNode.SetProperty("end_column", span.EndLinePosition.Character);
aNode.SetProperty("end_line", span.EndLinePosition.Line);
aNode.SetProperty("end_offset", node.Span.End);
if (stack.Count == 0)
{
aNode.parentKey = parentKey;
}
else
{
var parentNode = stack.Peek();
aNode.olderSiblings = parentNode.childKeys.ToArray();
parentNode.childKeys.Add(aNode.key);
aNode.parentKey = parentNode.key;
}
foreach (var tok in node.ChildTokens())
{
var kindStr = tok.Kind().ToString();
var value = tok.Value;
aNode.SetProperty(kindStr, value);
}
PrintNode(aNode);
stack.Push(aNode);
// Visit children
base.Visit(node);
if (stack.Count > 1)
{
stack.Pop();
}
}
public override void DefaultVisit(SyntaxNode node)
{
var nodes = node.ChildNodes();
var enumer = nodes.GetEnumerator();
while (enumer.MoveNext())
{
this.Visit(enumer.Current);
}
var tokens = node.ChildTokens();
var enumer2 = tokens.GetEnumerator();
while (enumer2.MoveNext())
{
this.VisitToken(enumer2.Current);
}
}
private List <string> GetTokenNamesWithKind(SyntaxNode node)
{
var names = new List <string> {
$"NODE {node.Kind()}"
};
foreach (var token in node.ChildTokens())
{
names.Add($"{token.ValueText} {token.Kind()}");
}
foreach (var childNode in node.ChildNodes())
{
names.AddRange(GetTokenNamesWithKind(childNode));
}
return(names);
}
private static IEnumerable <Token> ProcessNodeChildren(SyntaxNode node)
{
foreach (var token in node.ChildTokens())
{
yield return(ConvertToken(token));
}
foreach (var childNode in node.ChildNodes())
{
var nodeString = childNode.ToString();
var kind = childNode.Kind();
foreach (var childToken in ProcessNodeChildren(childNode))
{
yield return(childToken);
}
}
}
private bool IsPublic(SyntaxNode statement)
{
var isPublic = statement.ChildTokens().AnyOfKind(SyntaxKind.PublicKeyword);
// statement is a declaration statement - method, class, etc. its Parent is
// declaration block, its Parent is another block.
var parentInterfaceBlock = statement.Parent?.Parent;
// Interface members are public even though they don't have modifiers
if (!isPublic &&
parentInterfaceBlock != null &&
parentInterfaceBlock.IsKind(SyntaxKind.InterfaceBlock))
{
isPublic = IsPublic(((InterfaceBlockSyntax)parentInterfaceBlock).InterfaceStatement);
}
return(isPublic);
}
/// <summary>
/// Finds the member identifier using the specified node
/// </summary>
/// <param name="node">The node</param>
/// <returns>The descendant identifier</returns>
public static string FindMemberIdentifier(SyntaxNode node)
{
var directNodeIdentifier = node
.ChildTokens()
.FirstOrDefault(t => t.Kind() == SyntaxKind.IdentifierToken)
.Text;
if (!string.IsNullOrWhiteSpace(directNodeIdentifier))
{
return(directNodeIdentifier);
}
var descendantIdentifier = node
.DescendantTokens()
.LastOrDefault(t => t.Kind() == SyntaxKind.IdentifierToken)
.Text;
return(descendantIdentifier);
}
private static void GetContInDeep(SyntaxNode node, SyntaxKind syntaxKind)
{
node.ChildNodes().All(t =>
{
GetContInDeep(t, syntaxKind);
return(true);
});
node.ChildTokens().All(t =>
{
var count = t
.GetAllTrivia()
.Count(t2 => t2.IsKind(SyntaxKind.EndOfLineTrivia));
totalCount += count;
return(true);
});
}
