本文整理汇总了C#中Microsoft.CodeAnalysis.SyntaxNode.GetFirstToken方法的典型用法代码示例。如果您正苦于以下问题:C# SyntaxNode.GetFirstToken方法的具体用法?C# SyntaxNode.GetFirstToken怎么用?C# SyntaxNode.GetFirstToken使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类Microsoft.CodeAnalysis.SyntaxNode
的用法示例。
在下文中一共展示了SyntaxNode.GetFirstToken方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C#代码示例。
示例1: AnnotationResolver
private SyntaxToken AnnotationResolver(
SyntaxNode node,
TriviaLocation location,
SyntaxAnnotation annotation,
SyntaxNode callsite,
MethodDeclarationSyntax method)
{
var token = node.GetAnnotatedNodesAndTokens(annotation).FirstOrDefault().AsToken();
if (token.RawKind != 0)
{
return token;
}
switch (location)
{
case TriviaLocation.BeforeBeginningOfSpan:
return callsite.GetFirstToken(includeZeroWidth: true).GetPreviousToken(includeZeroWidth: true);
case TriviaLocation.AfterEndOfSpan:
return callsite.GetLastToken(includeZeroWidth: true).GetNextToken(includeZeroWidth: true);
case TriviaLocation.AfterBeginningOfSpan:
return method.Body.OpenBraceToken.GetNextToken(includeZeroWidth: true);
case TriviaLocation.BeforeEndOfSpan:
return method.Body.CloseBraceToken.GetPreviousToken(includeZeroWidth: true);
}
return Contract.FailWithReturn<SyntaxToken>("can't happen");
}
示例2: TreeData
public TreeData(SyntaxNode root)
{
Contract.ThrowIfNull(root);
_root = root;
_firstToken = _root.GetFirstToken(includeZeroWidth: true);
_lastToken = _root.GetLastToken(includeZeroWidth: true);
}
示例3: ValidationMessage
public ValidationMessage(SyntaxNode messageSource, string message)
{
var path = messageSource.SyntaxTree.FilePath;
var token = messageSource.GetFirstToken();
var text = messageSource.SyntaxTree.GetText();
var startLine = text.Lines.GetLineFromPosition(token.SpanStart);
var startColumn = token.SpanStart - startLine.Start;
var endLine = text.Lines.GetLineFromPosition(token.Span.End);
var endColumn = token.Span.End - endLine.Start;
_message = string.Format("{0}({1},{2},{3},{4}):{5}",
path,
startLine.LineNumber + 1, startColumn + 1,
endLine.LineNumber + 1, endColumn + 1,
message);
}
示例4: GetTransformedDocumentAsync
private static Task<Document> GetTransformedDocumentAsync(Document document, SyntaxNode root, SyntaxNode node)
{
// The first token is the open parenthesis token. This token has all the inner trivia
var firstToken = node.GetFirstToken();
var lastToken = node.GetLastToken();
var previousToken = firstToken.GetPreviousToken();
// We want to keep all trivia. The easiest way to do that is by doing it manually
var newSyntaxRoot = root.RemoveNode(node, SyntaxRemoveOptions.KeepNoTrivia);
// The removing operation has not changed the location of the previous token
var newPreviousToken = newSyntaxRoot.FindToken(previousToken.Span.Start);
var newTrailingTrivia = newPreviousToken.TrailingTrivia.AddRange(firstToken.GetAllTrivia()).AddRange(lastToken.GetAllTrivia());
newSyntaxRoot = newSyntaxRoot.ReplaceToken(newPreviousToken, newPreviousToken.WithTrailingTrivia(newTrailingTrivia));
return Task.FromResult(document.WithSyntaxRoot(newSyntaxRoot));
}
示例5: ParseFileHeader
/// <summary>
/// Parses a comment-only file header.
/// </summary>
/// <param name="root">The root of the syntax tree.</param>
/// <returns>The copyright string, as parsed from the file header.</returns>
internal static FileHeader ParseFileHeader(SyntaxNode root)
{
var firstToken = root.GetFirstToken(includeZeroWidth: true);
if (!firstToken.HasLeadingTrivia)
{
return FileHeader.MissingFileHeader;
}
var sb = new StringBuilder();
var endOfLineCount = 0;
var done = false;
var fileHeaderStart = int.MaxValue;
var fileHeaderEnd = int.MinValue;
int i;
for (i = 0; !done && (i < firstToken.LeadingTrivia.Count); i++)
{
var trivia = firstToken.LeadingTrivia[i];
switch (trivia.Kind())
{
case SyntaxKind.WhitespaceTrivia:
endOfLineCount = 0;
break;
case SyntaxKind.SingleLineCommentTrivia:
endOfLineCount = 0;
var commentString = trivia.ToFullString();
fileHeaderStart = Math.Min(trivia.FullSpan.Start, fileHeaderStart);
fileHeaderEnd = trivia.FullSpan.End;
sb.AppendLine(commentString.Substring(2).Trim());
break;
case SyntaxKind.MultiLineCommentTrivia:
// only process a MultiLineCommentTrivia if no SingleLineCommentTrivia have been processed
if (sb.Length == 0)
{
var triviaString = trivia.ToFullString();
var startIndex = triviaString.IndexOf("/*", StringComparison.Ordinal) + 2;
var endIndex = triviaString.LastIndexOf("*/", StringComparison.Ordinal);
var commentContext = triviaString.Substring(startIndex, endIndex - startIndex).Trim();
var triviaStringParts = commentContext.Replace("\r\n", "\n").Split('\n');
foreach (var part in triviaStringParts)
{
var trimmedPart = part.TrimStart(' ', '*');
sb.AppendLine(trimmedPart);
}
fileHeaderStart = trivia.FullSpan.Start;
fileHeaderEnd = trivia.FullSpan.End;
}
done = true;
break;
case SyntaxKind.EndOfLineTrivia:
endOfLineCount++;
done = endOfLineCount > 1;
break;
default:
done = (fileHeaderStart < fileHeaderEnd) || !trivia.IsDirective;
break;
}
}
if (fileHeaderStart > fileHeaderEnd)
{
return FileHeader.MissingFileHeader;
}
if (sb.Length > 0)
{
// remove the final newline
var eolLength = Environment.NewLine.Length;
sb.Remove(sb.Length - eolLength, eolLength);
}
return new FileHeader(sb.ToString(), fileHeaderStart, fileHeaderEnd);
}
示例6: ParseXmlFileHeader
/// <summary>
/// Parses an XML-based file header.
/// </summary>
/// <param name="root">The root of the syntax tree.</param>
/// <returns>The parsed file header.</returns>
internal static XmlFileHeader ParseXmlFileHeader(SyntaxNode root)
{
var firstToken = root.GetFirstToken(includeZeroWidth: true);
string xmlString;
int fileHeaderStart;
int fileHeaderEnd;
var firstNonWhitespaceTrivia = TriviaHelper.IndexOfFirstNonWhitespaceTrivia(firstToken.LeadingTrivia, false);
if (firstNonWhitespaceTrivia == -1)
{
return XmlFileHeader.MissingFileHeader;
}
switch (firstToken.LeadingTrivia[firstNonWhitespaceTrivia].Kind())
{
case SyntaxKind.SingleLineCommentTrivia:
xmlString = ProcessSingleLineCommentsHeader(firstToken.LeadingTrivia, firstNonWhitespaceTrivia, out fileHeaderStart, out fileHeaderEnd);
break;
case SyntaxKind.MultiLineCommentTrivia:
xmlString = ProcessMultiLineCommentsHeader(firstToken.LeadingTrivia[firstNonWhitespaceTrivia], out fileHeaderStart, out fileHeaderEnd);
break;
default:
return XmlFileHeader.MissingFileHeader;
}
if (fileHeaderStart > fileHeaderEnd)
{
return XmlFileHeader.MissingFileHeader;
}
try
{
var parsedFileHeaderXml = XElement.Parse(xmlString);
// a header without any XML tags is malformed.
if (!parsedFileHeaderXml.Descendants().Any())
{
return XmlFileHeader.MalformedFileHeader;
}
return new XmlFileHeader(parsedFileHeaderXml, fileHeaderStart, fileHeaderEnd);
}
catch (XmlException)
{
return XmlFileHeader.MalformedFileHeader;
}
}
示例7: AddIndentBlockOperations
private static void AddIndentBlockOperations(List<IndentBlockOperation> list, SyntaxNode node)
{
// only add indent block operation if the base token is the first token on line
var text = node.SyntaxTree.GetText();
var baseToken = node.Parent.GetFirstToken(includeZeroWidth: true);
list.Add(FormattingOperations.CreateRelativeIndentBlockOperation(
baseToken,
node.GetFirstToken(includeZeroWidth: true).GetNextToken(includeZeroWidth: true),
node.GetLastToken(includeZeroWidth: true).GetPreviousToken(includeZeroWidth: true),
indentationDelta: 1,
option: IndentBlockOption.RelativeToFirstTokenOnBaseTokenLine));
}
示例8: SuppressVariableDeclaration
private void SuppressVariableDeclaration(List<SuppressOperation> list, SyntaxNode node, OptionSet optionSet)
{
if (node.IsKind(SyntaxKind.FieldDeclaration) || node.IsKind(SyntaxKind.EventDeclaration) ||
node.IsKind(SyntaxKind.EventFieldDeclaration) || node.IsKind(SyntaxKind.LocalDeclarationStatement))
{
if (optionSet.GetOption(CSharpFormattingOptions.SpacesIgnoreAroundVariableDeclaration))
{
var firstToken = node.GetFirstToken(includeZeroWidth: true);
var lastToken = node.GetLastToken(includeZeroWidth: true);
list.Add(FormattingOperations.CreateSuppressOperation(firstToken, lastToken, SuppressOption.NoSpacing));
}
}
}
示例9: GetComment
public override string GetComment(SyntaxNode node)
{
var firstToken = node.GetFirstToken();
var commentList = CollectComments(firstToken.LeadingTrivia.ToArray());
if (commentList.Count == 0)
{
return string.Empty;
}
var textBuilder = new StringBuilder();
foreach (var trivia in commentList)
{
if (trivia.IsRegularComment())
{
textBuilder.AppendLine(trivia.GetCommentText());
}
else
{
throw Exceptions.ThrowEFail();
}
}
return textBuilder.ToString();
}
示例10: RemoveSuppressOperationForBlock
private void RemoveSuppressOperationForBlock(List<SuppressOperation> list, SyntaxNode node)
{
var bracePair = GetBracePair(node);
if (!bracePair.IsValidBracePair())
{
return;
}
var firstTokenOfNode = node.GetFirstToken(includeZeroWidth: true);
if (node.IsLambdaBodyBlock())
{
// include lambda itself.
firstTokenOfNode = node.Parent.GetFirstToken(includeZeroWidth: true);
}
// suppress wrapping on whole construct that owns braces and also brace pair itself if it is on same line
RemoveSuppressOperation(list, firstTokenOfNode, bracePair.Item2);
RemoveSuppressOperation(list, bracePair.Item1, bracePair.Item2);
}
示例11: ReAddFileHeader
private static SyntaxNode ReAddFileHeader(SyntaxNode syntaxRoot, SyntaxNode newSyntaxRoot)
{
var oldFirstToken = syntaxRoot.GetFirstToken();
if (!oldFirstToken.HasLeadingTrivia)
{
return newSyntaxRoot;
}
var fileHeader = UsingsHelper.GetFileHeader(oldFirstToken.LeadingTrivia.ToList());
if (!fileHeader.Any())
{
return newSyntaxRoot;
}
var newFirstToken = newSyntaxRoot.GetFirstToken();
var newLeadingTrivia = newFirstToken.LeadingTrivia.InsertRange(0, fileHeader);
return newSyntaxRoot.ReplaceToken(newFirstToken, newFirstToken.WithLeadingTrivia(newLeadingTrivia));
}
示例12: CheckChildStatement
private static void CheckChildStatement(SyntaxNodeAnalysisContext context, SyntaxNode node, StatementSyntax childStatement)
{
if (childStatement == null || childStatement.IsMissing)
{
return;
}
if (childStatement is BlockSyntax)
{
// BlockSyntax child statements are handled by HandleBlock
return;
}
// We are only interested in the first instance of this violation on a line.
if (!node.GetFirstToken().IsFirstInLine())
{
return;
}
// We are only interested in the case where statement and childStatement start on the same line. Use
// IsFirstInLine to detect this condition easily.
SyntaxToken firstChildToken = childStatement.GetFirstToken();
if (firstChildToken.IsMissingOrDefault() || firstChildToken.IsFirstInLine())
{
return;
}
if (!context.IsAnalyzerSuppressed(SA1519CurlyBracketsMustNotBeOmittedFromMultiLineChildStatement.DiagnosticId))
{
// diagnostics for multi-line statements is handled by SA1519, as long as it's not suppressed
FileLinePositionSpan lineSpan = childStatement.GetLineSpan();
if (lineSpan.StartLinePosition.Line != lineSpan.EndLinePosition.Line)
{
return;
}
}
context.ReportDiagnostic(Diagnostic.Create(Descriptor, childStatement.GetLocation()));
}
示例13: AddBraceSuppressOperations
protected void AddBraceSuppressOperations(List<SuppressOperation> list, SyntaxNode node, SyntaxToken lastToken)
{
var bracePair = node.GetBracePair();
if (!bracePair.IsValidBracePair())
{
return;
}
var firstTokenOfNode = node.GetFirstToken(includeZeroWidth: true);
var memberDeclNode = node as MemberDeclarationSyntax;
if (memberDeclNode != null)
{
var firstAndLastTokens = memberDeclNode.GetFirstAndLastMemberDeclarationTokensAfterAttributes();
firstTokenOfNode = firstAndLastTokens.Item1;
}
if (node.IsLambdaBodyBlock())
{
// include lambda itself.
firstTokenOfNode = node.Parent.GetFirstToken(includeZeroWidth: true);
}
// We may think we have a complete set of braces, but that may not actually be the case
// due incomplete code. i.e. we have something like:
//
// class C
// {
// int Blah {
// get { return blah
// }
//
// In this case the parse will think that the get-accessor is actually on two lines
// (because it will consume the close curly that more accurately belongs to the class.
//
// Now there are different behaviors we want depending on what the user is doing
// and what we are formatting. For example, if the user hits semicolon at the end of
// "blah", then we want to keep the accessor on a single line. In this scenario we
// effectively want to ignore the following close curly as it may not be important to
// this construct in the mind of the user.
//
// However, say the user hits semicolon, then hits enter, then types a close curly.
// In this scenario we would actually want the get-accessor to be formatted over multiple
// lines. The difference here is that because the user just hit close-curly here we can
// consider it as being part of the closest construct and we can consider its placement
// when deciding if the construct is on a single line.
var endToken = bracePair.Item2;
if (lastToken.Kind() != SyntaxKind.CloseBraceToken &&
lastToken.Kind() != SyntaxKind.EndOfFileToken &&
!endToken.IsMissing)
{
// The user didn't just type the close brace. So any close brace we have may
// actually belong to a containing construct. See if any containers are missing
// a close brace, and if so, act as if our own close brace is missing.
if (SomeParentHasMissingCloseBrace(node.Parent))
{
if (node.IsKind(SyntaxKind.Block) && ((BlockSyntax)node).Statements.Count >= 1)
{
// In the case of a block, see if the first statement is on the same line
// as the open curly. If so then we'll want to consider the end of the
// block as the end of the first statement. i.e. if you have:
//
// try { }
// catch { return; // <-- the end of this block is the end of the return statement.
// Method();
var firstStatement = ((BlockSyntax)node).Statements[0];
if (FormattingRangeHelper.AreTwoTokensOnSameLine(firstTokenOfNode, firstStatement.GetFirstToken()))
{
endToken = firstStatement.GetLastToken();
}
}
else
{
endToken = endToken.GetPreviousToken();
}
}
}
// suppress wrapping on whole construct that owns braces and also brace pair itself if
// it is on same line
AddSuppressWrappingIfOnSingleLineOperation(list, firstTokenOfNode, endToken);
AddSuppressWrappingIfOnSingleLineOperation(list, bracePair.Item1, endToken);
}
示例14: ParseXmlFileHeader
/// <summary>
/// Parses an XML-based file header.
/// </summary>
/// <param name="root">The root of the syntax tree.</param>
/// <returns>The parsed file header.</returns>
internal static XmlFileHeader ParseXmlFileHeader(SyntaxNode root)
{
var firstToken = root.GetFirstToken(includeZeroWidth: true);
if (!firstToken.HasLeadingTrivia)
{
return XmlFileHeader.MissingFileHeader;
}
var sb = new StringBuilder();
var endOfLineCount = 0;
var done = false;
var fileHeaderStart = int.MaxValue;
var fileHeaderEnd = int.MinValue;
// wrap the XML from the file header in a single root element to make XML parsing work.
sb.AppendLine("<root>");
int i;
for (i = 0; !done && (i < firstToken.LeadingTrivia.Count); i++)
{
var trivia = firstToken.LeadingTrivia[i];
switch (trivia.Kind())
{
case SyntaxKind.WhitespaceTrivia:
endOfLineCount = 0;
break;
case SyntaxKind.SingleLineCommentTrivia:
endOfLineCount = 0;
var commentString = trivia.ToFullString();
// ignore borders
if (commentString.StartsWith("//-", StringComparison.OrdinalIgnoreCase))
{
break;
}
fileHeaderStart = Math.Min(trivia.FullSpan.Start, fileHeaderStart);
fileHeaderEnd = trivia.FullSpan.End;
sb.AppendLine(commentString.Substring(2));
break;
case SyntaxKind.EndOfLineTrivia:
endOfLineCount++;
done = endOfLineCount > 1;
break;
default:
done = (fileHeaderStart < fileHeaderEnd) || !trivia.IsDirective;
break;
}
}
if (fileHeaderStart > fileHeaderEnd)
{
return XmlFileHeader.MissingFileHeader;
}
sb.AppendLine("</root>");
try
{
var parsedFileHeaderXml = XElement.Parse(sb.ToString());
// a header without any XML tags is malformed.
if (!parsedFileHeaderXml.Descendants().Any())
{
return XmlFileHeader.MalformedFileHeader;
}
return new XmlFileHeader(parsedFileHeaderXml, fileHeaderStart, fileHeaderEnd);
}
catch (XmlException)
{
return XmlFileHeader.MalformedFileHeader;
}
}
示例15: MoveMember
private static SyntaxNode MoveMember(SyntaxNode syntaxRoot, MemberDeclarationSyntax member, MemberDeclarationSyntax targetMember, IndentationOptions indentationOptions)
{
var firstToken = syntaxRoot.GetFirstToken();
var fileHeader = GetFileHeader(firstToken.LeadingTrivia);
syntaxRoot = syntaxRoot.TrackNodes(member, targetMember, firstToken.Parent);
var memberToMove = syntaxRoot.GetCurrentNode(member);
var targetMemberTracked = syntaxRoot.GetCurrentNode(targetMember);
if (!memberToMove.HasLeadingTrivia)
{
var targetIndentationLevel = IndentationHelper.GetIndentationSteps(indentationOptions, targetMember);
var indentationString = IndentationHelper.GenerateIndentationString(indentationOptions, targetIndentationLevel);
memberToMove = memberToMove.WithLeadingTrivia(SyntaxFactory.Whitespace(indentationString));
}
if (!HasLeadingBlankLines(targetMember)
&& HasLeadingBlankLines(member))
{
memberToMove = memberToMove.WithTrailingTrivia(memberToMove.GetTrailingTrivia().Add(SyntaxFactory.CarriageReturnLineFeed));
memberToMove = memberToMove.WithLeadingTrivia(GetLeadingTriviaWithoutLeadingBlankLines(memberToMove));
}
syntaxRoot = syntaxRoot.InsertNodesBefore(targetMemberTracked, new[] { memberToMove });
var fieldToMoveTracked = syntaxRoot.GetCurrentNodes(member).Last();
syntaxRoot = syntaxRoot.RemoveNode(fieldToMoveTracked, SyntaxRemoveOptions.KeepNoTrivia);
if (fileHeader.Any())
{
var oldFirstToken = syntaxRoot.GetCurrentNode(firstToken.Parent).ChildTokens().First();
syntaxRoot = syntaxRoot.ReplaceToken(oldFirstToken, oldFirstToken.WithLeadingTrivia(StripFileHeader(oldFirstToken.LeadingTrivia)));
var newFirstToken = syntaxRoot.GetFirstToken();
syntaxRoot = syntaxRoot.ReplaceToken(newFirstToken, newFirstToken.WithLeadingTrivia(fileHeader.AddRange(newFirstToken.LeadingTrivia)));
}
return syntaxRoot;
}