public static SyntaxToken GetNameToken(this NameSyntax nameSyntax) { while (true) { if (nameSyntax.CSharpKind() == SyntaxKind.IdentifierName) { return ((IdentifierNameSyntax)nameSyntax).Identifier; } else if (nameSyntax.CSharpKind() == SyntaxKind.QualifiedName) { nameSyntax = ((QualifiedNameSyntax)nameSyntax).Right; } else if (nameSyntax.CSharpKind() == SyntaxKind.GenericName) { return ((GenericNameSyntax)nameSyntax).Identifier; } else if (nameSyntax.CSharpKind() == SyntaxKind.AliasQualifiedName) { nameSyntax = ((AliasQualifiedNameSyntax)nameSyntax).Name; } else { throw new NotSupportedException(); } } }
public static bool IsLiteral(this SyntaxToken token) { return token.CSharpKind() == SyntaxKind.CharacterLiteralToken || token.CSharpKind() == SyntaxKind.FalseKeyword || token.CSharpKind() == SyntaxKind.NumericLiteralToken || token.CSharpKind() == SyntaxKind.StringLiteralToken || token.CSharpKind() == SyntaxKind.TrueKeyword; }
public static string GetCommentText(this SyntaxTrivia trivia) { var commentText = trivia.ToString(); if (trivia.CSharpKind() == SyntaxKind.SingleLineCommentTrivia) { if (commentText.StartsWith("//")) { commentText = commentText.Substring(2); } return commentText.TrimStart(); } else if (trivia.CSharpKind() == SyntaxKind.MultiLineCommentTrivia) { var textBuilder = new StringBuilder(); if (commentText.EndsWith("*/")) { commentText = commentText.Substring(0, commentText.Length - 2); } if (commentText.StartsWith("/*")) { commentText = commentText.Substring(2); } commentText = commentText.Trim(); var newLine = Environment.NewLine; var lines = commentText.Split(new[] { newLine }, StringSplitOptions.None); foreach (var line in lines) { var trimmedLine = line.Trim(); // Note: we trim leading '*' characters in multi-line comments. // If the '*' was intentional, sorry, it's gone. if (trimmedLine.StartsWith("*")) { trimmedLine = trimmedLine.TrimStart('*'); trimmedLine = trimmedLine.TrimStart(); } textBuilder.AppendLine(trimmedLine); } // remove last line break textBuilder.Remove(textBuilder.Length - newLine.Length, newLine.Length); return textBuilder.ToString(); } else { throw new InvalidOperationException(); } }
public static SyntaxToken GetNameToken(this MemberDeclarationSyntax member) { if (member != null) { switch (member.CSharpKind()) { case SyntaxKind.EnumDeclaration: return ((EnumDeclarationSyntax)member).Identifier; case SyntaxKind.ClassDeclaration: case SyntaxKind.InterfaceDeclaration: case SyntaxKind.StructDeclaration: return ((TypeDeclarationSyntax)member).Identifier; case SyntaxKind.DelegateDeclaration: return ((DelegateDeclarationSyntax)member).Identifier; case SyntaxKind.FieldDeclaration: return ((FieldDeclarationSyntax)member).Declaration.Variables.First().Identifier; case SyntaxKind.EventFieldDeclaration: return ((EventFieldDeclarationSyntax)member).Declaration.Variables.First().Identifier; case SyntaxKind.PropertyDeclaration: return ((PropertyDeclarationSyntax)member).Identifier; case SyntaxKind.EventDeclaration: return ((EventDeclarationSyntax)member).Identifier; case SyntaxKind.MethodDeclaration: return ((MethodDeclarationSyntax)member).Identifier; } } // Constructors, destructors, indexers and operators don't have names. return default(SyntaxToken); }
public static bool MatchesKind(this SyntaxNode node, params SyntaxKind[] kinds) { if (node == null) { return false; } return kinds.Contains(node.CSharpKind()); }
public static bool IsCompleteMultiLineComment(this SyntaxTrivia trivia) { if (trivia.CSharpKind() != SyntaxKind.MultiLineCommentTrivia) { return false; } var text = trivia.ToFullString(); return text.Length >= 4 && text[text.Length - 1] == '/' && text[text.Length - 2] == '*'; }
public static BaseParameterListSyntax WithParameters( this BaseParameterListSyntax parameterList, SeparatedSyntaxList<ParameterSyntax> parameters) { switch (parameterList.CSharpKind()) { case SyntaxKind.BracketedParameterList: return ((BracketedParameterListSyntax)parameterList).WithParameters(parameters); case SyntaxKind.ParameterList: return ((ParameterListSyntax)parameterList).WithParameters(parameters); } throw Contract.Unreachable; }
public static SyntaxToken GetCloseToken(this BaseArgumentListSyntax node) { if (node != null) { switch (node.CSharpKind()) { case SyntaxKind.ArgumentList: return ((ArgumentListSyntax)node).CloseParenToken; case SyntaxKind.BracketedArgumentList: return ((BracketedArgumentListSyntax)node).CloseBracketToken; } } return default(SyntaxToken); }
public static string GetKind(this SyntaxNode node) { var kind = string.Empty; if (node.Language == LanguageNames.CSharp) { kind = node.CSharpKind().ToString(); } else { kind = node.VisualBasicKind().ToString(); } return kind; }
public static string GetKind(this SyntaxTrivia trivia) { var kind = string.Empty; if (trivia.Language == LanguageNames.CSharp) { kind = trivia.CSharpKind().ToString(); } else { kind = trivia.VisualBasicKind().ToString(); } return kind; }
public static TypeDeclarationSyntax AddMembers( this TypeDeclarationSyntax node, params MemberDeclarationSyntax[] members) { switch (node.CSharpKind()) { case SyntaxKind.ClassDeclaration: return ((ClassDeclarationSyntax)node).AddMembers(members); case SyntaxKind.InterfaceDeclaration: return ((InterfaceDeclarationSyntax)node).AddMembers(members); case SyntaxKind.StructDeclaration: return ((StructDeclarationSyntax)node).AddMembers(members); } throw Contract.Unreachable; }
public static TypeDeclarationSyntax WithModifiers( this TypeDeclarationSyntax node, SyntaxTokenList modifiers) { switch (node.CSharpKind()) { case SyntaxKind.ClassDeclaration: return ((ClassDeclarationSyntax)node).WithModifiers(modifiers); case SyntaxKind.InterfaceDeclaration: return ((InterfaceDeclarationSyntax)node).WithModifiers(modifiers); case SyntaxKind.StructDeclaration: return ((StructDeclarationSyntax)node).WithModifiers(modifiers); } throw Contract.Unreachable; }
public static TypeDeclarationSyntax WithAttributeLists( this TypeDeclarationSyntax node, SyntaxList<AttributeListSyntax> attributes) { switch (node.CSharpKind()) { case SyntaxKind.ClassDeclaration: return ((ClassDeclarationSyntax)node).WithAttributeLists(attributes); case SyntaxKind.InterfaceDeclaration: return ((InterfaceDeclarationSyntax)node).WithAttributeLists(attributes); case SyntaxKind.StructDeclaration: return ((StructDeclarationSyntax)node).WithAttributeLists(attributes); } throw Contract.Unreachable; }
public static SyntaxList<AttributeListSyntax> GetAttributes(this MemberDeclarationSyntax member) { if (member != null) { switch (member.CSharpKind()) { case SyntaxKind.EnumDeclaration: return ((EnumDeclarationSyntax)member).AttributeLists; case SyntaxKind.EnumMemberDeclaration: return ((EnumMemberDeclarationSyntax)member).AttributeLists; case SyntaxKind.ClassDeclaration: case SyntaxKind.InterfaceDeclaration: case SyntaxKind.StructDeclaration: return ((TypeDeclarationSyntax)member).AttributeLists; case SyntaxKind.DelegateDeclaration: return ((DelegateDeclarationSyntax)member).AttributeLists; case SyntaxKind.FieldDeclaration: return ((FieldDeclarationSyntax)member).AttributeLists; case SyntaxKind.EventFieldDeclaration: return ((EventFieldDeclarationSyntax)member).AttributeLists; case SyntaxKind.ConstructorDeclaration: return ((ConstructorDeclarationSyntax)member).AttributeLists; case SyntaxKind.DestructorDeclaration: return ((DestructorDeclarationSyntax)member).AttributeLists; case SyntaxKind.PropertyDeclaration: return ((PropertyDeclarationSyntax)member).AttributeLists; case SyntaxKind.EventDeclaration: return ((EventDeclarationSyntax)member).AttributeLists; case SyntaxKind.IndexerDeclaration: return ((IndexerDeclarationSyntax)member).AttributeLists; case SyntaxKind.OperatorDeclaration: return ((OperatorDeclarationSyntax)member).AttributeLists; case SyntaxKind.ConversionOperatorDeclaration: return ((ConversionOperatorDeclarationSyntax)member).AttributeLists; case SyntaxKind.MethodDeclaration: return ((MethodDeclarationSyntax)member).AttributeLists; case SyntaxKind.IncompleteMember: return ((IncompleteMemberSyntax)member).AttributeLists; } } return SyntaxFactory.List<AttributeListSyntax>(); }
public static bool IsCompoundAssignExpression(this BinaryExpressionSyntax binaryExpression) { if (binaryExpression != null) { switch (binaryExpression.CSharpKind()) { case SyntaxKind.AddAssignmentExpression: case SyntaxKind.SubtractAssignmentExpression: case SyntaxKind.MultiplyAssignmentExpression: case SyntaxKind.DivideAssignmentExpression: case SyntaxKind.ModuloAssignmentExpression: case SyntaxKind.AndAssignmentExpression: case SyntaxKind.ExclusiveOrAssignmentExpression: case SyntaxKind.OrAssignmentExpression: case SyntaxKind.LeftShiftAssignmentExpression: case SyntaxKind.RightShiftAssignmentExpression: return true; } } return false; }
public static bool IsCloseParenInArgumentList(this SyntaxToken token) { return token.CSharpKind() == SyntaxKind.CloseParenToken && token.Parent.CSharpKind() == SyntaxKind.ArgumentList; }
/// <summary> /// Lexically, find the last token that looks like it's part of this generic name. /// </summary> /// <param name="genericIdentifier">The "name" of the generic identifier, last token before /// the "&"</param> /// <returns>The last token in the name</returns> /// <remarks>This is related to the code in <see cref="M:SyntaxTreeExtensions.IsInPartiallyWrittenGeneric"/></remarks> public static SyntaxToken FindLastTokenOfPartialGenericName(this SyntaxToken genericIdentifier) { Contract.ThrowIfFalse(genericIdentifier.CSharpKind() == SyntaxKind.IdentifierToken); // advance to the "<" token var token = genericIdentifier.GetNextToken(includeSkipped: true); Contract.ThrowIfFalse(token.CSharpKind() == SyntaxKind.LessThanToken); int stack = 0; do { // look forward one token { var next = token.GetNextToken(includeSkipped: true); if (next.CSharpKind() == SyntaxKind.None) { return token; } token = next; } if (token.CSharpKind() == SyntaxKind.GreaterThanToken) { if (stack == 0) { return token; } else { stack--; continue; } } switch (token.CSharpKind()) { case SyntaxKind.LessThanLessThanToken: stack++; goto case SyntaxKind.LessThanToken; // fall through case SyntaxKind.LessThanToken: stack++; break; case SyntaxKind.AsteriskToken: // for int* case SyntaxKind.QuestionToken: // for int? case SyntaxKind.ColonToken: // for global:: (so we don't dismiss help as you type the first :) case SyntaxKind.ColonColonToken: // for global:: case SyntaxKind.CloseBracketToken: case SyntaxKind.OpenBracketToken: case SyntaxKind.DotToken: case SyntaxKind.IdentifierToken: case SyntaxKind.CommaToken: break; // If we see a member declaration keyword, we know we've gone too far case SyntaxKind.ClassKeyword: case SyntaxKind.StructKeyword: case SyntaxKind.InterfaceKeyword: case SyntaxKind.DelegateKeyword: case SyntaxKind.EnumKeyword: case SyntaxKind.PrivateKeyword: case SyntaxKind.PublicKeyword: case SyntaxKind.InternalKeyword: case SyntaxKind.ProtectedKeyword: case SyntaxKind.VoidKeyword: return token.GetPreviousToken(includeSkipped: true); default: // user might have typed "in" on the way to typing "int" // don't want to disregard this genericname because of that if (SyntaxFacts.IsKeywordKind(token.CSharpKind())) { break; } // anything else and we're sunk. Go back to the token before. return token.GetPreviousToken(includeSkipped: true); } } while (true); }
public static TypeDeclarationSyntax WithConstraintClauses( this TypeDeclarationSyntax node, SyntaxList<TypeParameterConstraintClauseSyntax> constraintClauses) { switch (node.CSharpKind()) { case SyntaxKind.ClassDeclaration: return ((ClassDeclarationSyntax)node).WithConstraintClauses(constraintClauses); case SyntaxKind.InterfaceDeclaration: return ((InterfaceDeclarationSyntax)node).WithConstraintClauses(constraintClauses); case SyntaxKind.StructDeclaration: return ((StructDeclarationSyntax)node).WithConstraintClauses(constraintClauses); } throw Contract.Unreachable; }
public static TypeDeclarationSyntax WithCloseBraceToken( this TypeDeclarationSyntax node, SyntaxToken closeBrace) { switch (node.CSharpKind()) { case SyntaxKind.ClassDeclaration: return ((ClassDeclarationSyntax)node).WithCloseBraceToken(closeBrace); case SyntaxKind.InterfaceDeclaration: return ((InterfaceDeclarationSyntax)node).WithCloseBraceToken(closeBrace); case SyntaxKind.StructDeclaration: return ((StructDeclarationSyntax)node).WithCloseBraceToken(closeBrace); } throw Contract.Unreachable; }
public static bool IsCommaInArgumentOrParameterList(this SyntaxToken token) { return token.CSharpKind() == SyntaxKind.CommaToken && (token.Parent.IsAnyArgumentList() || token.Parent.CSharpKind() == SyntaxKind.ParameterList); }
public static bool IsColonInTypeBaseList(this SyntaxToken token) { return token.CSharpKind() == SyntaxKind.ColonToken && token.Parent.CSharpKind() == SyntaxKind.BaseList; }
public static bool IsLambdaBodyBlock(this SyntaxNode node) { if (node.CSharpKind() != SyntaxKind.Block) { return false; } return node.Parent.CSharpKind() == SyntaxKind.SimpleLambdaExpression || node.Parent.CSharpKind() == SyntaxKind.ParenthesizedLambdaExpression; }
public static bool IsThis(this SyntaxToken token) { return token.CSharpKind() == SyntaxKind.ThisKeyword; }
public static bool MatchesKind(this SyntaxToken token, params SyntaxKind[] kinds) { return kinds.Contains(token.CSharpKind()); }
public static bool MatchesKind(this SyntaxToken token, SyntaxKind kind1, SyntaxKind kind2, SyntaxKind kind3) { return token.CSharpKind() == kind1 || token.CSharpKind() == kind2 || token.CSharpKind() == kind3; }
public static bool IsValidAttributeTarget(this SyntaxToken token) { var kind = token.CSharpKind(); return kind == SyntaxKind.AssemblyKeyword || kind == SyntaxKind.ModuleKeyword || kind == SyntaxKind.FieldKeyword || kind == SyntaxKind.EventKeyword || kind == SyntaxKind.MethodKeyword || kind == SyntaxKind.ParamKeyword || kind == SyntaxKind.PropertyKeyword || kind == SyntaxKind.ReturnKeyword || kind == SyntaxKind.TypeKeyword; }
public static bool MatchesKind(this SyntaxToken token, SyntaxKind kind) { return token.CSharpKind() == kind; }
public static bool IsKindOrHasMatchingText(this SyntaxToken token, SyntaxKind kind) { return token.CSharpKind() == kind || token.HasMatchingText(kind); }
public static TypeDeclarationSyntax WithTypeParameterList( this TypeDeclarationSyntax node, TypeParameterListSyntax list) { switch (node.CSharpKind()) { case SyntaxKind.ClassDeclaration: return ((ClassDeclarationSyntax)node).WithTypeParameterList(list); case SyntaxKind.InterfaceDeclaration: return ((InterfaceDeclarationSyntax)node).WithTypeParameterList(list); case SyntaxKind.StructDeclaration: return ((StructDeclarationSyntax)node).WithTypeParameterList(list); } throw Contract.Unreachable; }
public static bool IsRegularStringLiteral(this SyntaxToken token) { return token.CSharpKind() == SyntaxKind.StringLiteralToken && !token.IsVerbatimStringLiteral(); }