Example #1
0
 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();
         }
     }
 }
Example #2
0
 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;
 }
Example #3
0
        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());
        }
Example #6
0
        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);
        }
Example #9
0
        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;
        }
Example #10
0
        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;
        }
Example #16
0
 public static bool IsCloseParenInArgumentList(this SyntaxToken token)
 {
     return token.CSharpKind() == SyntaxKind.CloseParenToken && token.Parent.CSharpKind() == SyntaxKind.ArgumentList;
 }
Example #17
0
        /// <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 "&amp;"</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;
        }
Example #20
0
 public static bool IsCommaInArgumentOrParameterList(this SyntaxToken token)
 {
     return token.CSharpKind() == SyntaxKind.CommaToken && (token.Parent.IsAnyArgumentList() || token.Parent.CSharpKind() == SyntaxKind.ParameterList);
 }
Example #21
0
 public static bool IsColonInTypeBaseList(this SyntaxToken token)
 {
     return token.CSharpKind() == SyntaxKind.ColonToken && token.Parent.CSharpKind() == SyntaxKind.BaseList;
 }
Example #22
0
        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;
        }
Example #23
0
 public static bool IsThis(this SyntaxToken token)
 {
     return token.CSharpKind() == SyntaxKind.ThisKeyword;
 }
Example #24
0
 public static bool MatchesKind(this SyntaxToken token, params SyntaxKind[] kinds)
 {
     return kinds.Contains(token.CSharpKind());
 }
Example #25
0
 public static bool MatchesKind(this SyntaxToken token, SyntaxKind kind1, SyntaxKind kind2, SyntaxKind kind3)
 {
     return token.CSharpKind() == kind1
         || token.CSharpKind() == kind2
         || token.CSharpKind() == kind3;
 }
Example #26
0
 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;
 }
Example #27
0
 public static bool MatchesKind(this SyntaxToken token, SyntaxKind kind)
 {
     return token.CSharpKind() == kind;
 }
Example #28
0
 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;
        }
Example #30
0
 public static bool IsRegularStringLiteral(this SyntaxToken token)
 {
     return token.CSharpKind() == SyntaxKind.StringLiteralToken && !token.IsVerbatimStringLiteral();
 }