C# SyntaxKind类代码示例

        private SyntaxToken LexSyntaxToken()
        {
            _diagnostics.Clear();
            _leadingTrivia.Clear();
            _start = _charReader.Position;

            if (_kind == SyntaxKind.CgProgramKeyword || _kind == SyntaxKind.CgIncludeKeyword)
                ReadCgTrivia(_leadingTrivia);

            ReadTrivia(_leadingTrivia, isTrailing: false);
            var leadingTrivia = _leadingTrivia.ToImmutableArray();

            _kind = SyntaxKind.BadToken;
            _contextualKind = SyntaxKind.None;
            _value = null;
            _diagnostics.Clear();
            _start = _charReader.Position;
            ReadToken();
            var end = _charReader.Position;
            var kind = _kind;
            var span = TextSpan.FromBounds(Text, _start, end);
            var text = Text.GetText(span);
            var diagnostics = _diagnostics.ToImmutableArray();

            _trailingTrivia.Clear();
            _diagnostics.Clear();
            _start = _charReader.Position;
            ReadTrivia(_trailingTrivia, isTrailing: true);
            var trailingTrivia = _trailingTrivia.ToImmutableArray();

            return new SyntaxToken(kind, _contextualKind, false, span, text, _value, leadingTrivia, trailingTrivia, diagnostics);
        }

        private static BraceMatchingResult MatchBraces(SyntaxToken token, SourceLocation position, SyntaxKind leftKind, SyntaxKind rightKind)
        {
            var isLeft = token.Kind == leftKind &&
                         position == token.SourceRange.Start;

            var isRight = token.Kind == rightKind &&
                          position == token.SourceRange.End;

            if (isLeft)
            {
                var left = token.Span;
                TextSpan right;
                if (FindMatchingBrace(position, 1, token.Parent, rightKind, out right))
                    return MapResultToFile(left, right);
            }
            else if (isRight)
            {
                TextSpan left;
                var right = token.Span;
                if (FindMatchingBrace(position, -1, token.Parent, leftKind, out left))
                    return MapResultToFile(left, right);
            }

            return BraceMatchingResult.None;
        }

 static SyntaxKind GetAssignmentOperator(SyntaxKind op)
 {
     switch (op)
     {
         case SyntaxKind.AndAssignmentExpression:
             return SyntaxKind.BitwiseAndExpression;
         case SyntaxKind.OrAssignmentExpression:
             return SyntaxKind.BitwiseOrExpression;
         case SyntaxKind.ExclusiveOrAssignmentExpression:
             return SyntaxKind.ExclusiveOrExpression;
         case SyntaxKind.AddAssignmentExpression:
             return SyntaxKind.AddExpression;
         case SyntaxKind.SubtractAssignmentExpression:
             return SyntaxKind.SubtractExpression;
         case SyntaxKind.MultiplyAssignmentExpression:
             return SyntaxKind.MultiplyExpression;
         case SyntaxKind.DivideAssignmentExpression:
             return SyntaxKind.DivideExpression;
         case SyntaxKind.ModuloAssignmentExpression:
             return SyntaxKind.ModuloExpression;
         case SyntaxKind.LeftShiftAssignmentExpression:
             return SyntaxKind.LeftShiftExpression;
         case SyntaxKind.RightShiftAssignmentExpression:
             return SyntaxKind.RightShiftExpression;
         default:
             return SyntaxKind.None;
     }
 }

 internal SyntaxTrivia(SyntaxKind kind, string text)
     : this()
 {
     _kind = kind;
     _start = 0;
     _text = text;
 }

 public XmlCommentSyntax(SyntaxKind kind, PunctuationSyntax beginComment, SyntaxNode node, PunctuationSyntax endComment) : base(kind)
 {
     this.BeginComment = beginComment;
     this.Content = node;
     this.EndComment = endComment;
     SlotCount = 3;
 }

			public async Task WhenGettingDocumentationForPropertyThenReadsFromPropertyDefinition(string code, string summary, SyntaxKind kind)
			{
				var codeFile = string.Format(
@"namespace TestNs
{{
	public class DocClass
	{{
		/// <summary>{0}</summary>
		{1}
	}}
}}",
  summary,
  code);

				var solution = CreateSolution(codeFile);
				var project = solution.Projects.First();
				var document = project.Documents.First();
				var model = await document.GetSemanticModelAsync();
				var docRoot = await document.GetSyntaxRootAsync();
				var node = docRoot.DescendantNodes().First(x => x.Kind() == kind);
				var symbol = model.GetDeclaredSymbol(node);
				var documentation = await _sut.Create(symbol, CancellationToken.None);

				Assert.AreEqual(summary, documentation.Summary);
			}

 public AbstractSpecialTypePreselectingKeywordRecommender(
     SyntaxKind keywordKind, 
     bool isValidInPreprocessorContext = false, 
     bool shouldFormatOnCommit = false) 
     : base(keywordKind, isValidInPreprocessorContext, shouldFormatOnCommit)
 {
 }

 private static BlockType FindType(SyntaxKind kind)
 {
     switch (kind)
     {
         case SyntaxKind.ForEachStatement:
         case SyntaxKind.ForStatement:
         case SyntaxKind.WhileStatement:
         case SyntaxKind.DoStatement:
             return BlockType.Loop;
         case SyntaxKind.IfStatement:
         case SyntaxKind.ElseClause:
         case SyntaxKind.SwitchStatement:
             return BlockType.Conditional;
         case SyntaxKind.ClassDeclaration:
         case SyntaxKind.InterfaceDeclaration:
         case SyntaxKind.StructDeclaration:
         case SyntaxKind.EnumDeclaration:
             return BlockType.Class;
         case SyntaxKind.NamespaceDeclaration:
             return BlockType.Namespace;
         case SyntaxKind.MethodDeclaration:
         case SyntaxKind.PropertyDeclaration:
         case SyntaxKind.GetAccessorDeclaration:
         case SyntaxKind.SetAccessorDeclaration:
         case SyntaxKind.ParenthesizedLambdaExpression:
             return BlockType.Method;
         case SyntaxKind.TryStatement:
         case SyntaxKind.CatchClause:
         case SyntaxKind.FinallyClause:
         case SyntaxKind.LockStatement:
             return BlockType.Other;
         default:
             return BlockType.Unknown;
     }
 }

 static bool TryFlip(BinaryExpressionSyntax expr, out SyntaxKind flippedKind, out string operatorText)
 {
     switch (expr.Kind())
     {
         case SyntaxKind.LessThanExpression:
             flippedKind = SyntaxKind.GreaterThanExpression;
             operatorText = ">";
             return true;
         case SyntaxKind.LessThanOrEqualExpression:
             flippedKind = SyntaxKind.GreaterThanOrEqualExpression;
             operatorText = ">=";
             return true;
         case SyntaxKind.GreaterThanExpression:
             flippedKind = SyntaxKind.LessThanExpression;
             operatorText = "<";
             return true;
         case SyntaxKind.GreaterThanOrEqualExpression:
             flippedKind = SyntaxKind.LessThanOrEqualExpression;
             operatorText = "<=";
             return true;
     }
     flippedKind = SyntaxKind.None;
     operatorText = null;
     return false;
 }

        private static bool FindMatchingBrace(SourceLocation position, int direction, SyntaxNode parent, SyntaxKind syntaxKind, out TextSpan right)
        {
            var tokens = parent.ChildNodes.Where(t => t.Kind == syntaxKind);
            var relevantTokens = (direction < 0)
                ? from t in tokens
                    where t.SourceRange.End <= position
                    select t
                : from t in tokens
                    where position < t.SourceRange.Start
                    select t;

            right = new TextSpan();
            var found = false;

            foreach (var token in relevantTokens.Cast<SyntaxToken>())
            {
                if (!found)
                {
                    right = token.Span;
                    found = true;
                }
                else
                    return false;
            }

            return found;
        }

        public static SyntaxToken MissingToken(SyntaxKind kind, SyntaxList<SyntaxNode> precedingTrivia = default(SyntaxList<SyntaxNode>))
        {
            switch (kind)
            {
                case SyntaxKind.LessThanQuestionToken:
                case SyntaxKind.XmlKeyword:
                case SyntaxKind.LessThanToken:
                case SyntaxKind.LessThanGreaterThanToken:
                case SyntaxKind.LessThanSlashToken:
                case SyntaxKind.BeginCDataToken:
                case SyntaxKind.LessThanExclamationMinusMinusToken:
                case SyntaxKind.LessThanPercentEqualsToken:
                case SyntaxKind.SlashToken:
                case SyntaxKind.GreaterThanToken:
                case SyntaxKind.EqualsToken:
                case SyntaxKind.SingleQuoteToken:
                case SyntaxKind.DoubleQuoteToken:
                case SyntaxKind.QuestionGreaterThanToken:
                case SyntaxKind.OpenParenToken:
                case SyntaxKind.CloseParenToken:
                case SyntaxKind.ColonToken:
                case SyntaxKind.SlashGreaterThanToken:
                case SyntaxKind.EndCDataToken:
                case SyntaxKind.MinusMinusGreaterThanToken:
                    return MissingPunctuation(kind, precedingTrivia.Node);
                case SyntaxKind.XmlNameToken:
                    return SyntaxFactory.XmlNameToken("", null, null);
                default:
                    break;
            }

            throw new InvalidOperationException();
        }

 public static bool IsPreprocessorKeyword(SyntaxKind kind)
 {
     switch (kind)
     {
         case SyntaxKind.TrueKeyword:
         case SyntaxKind.FalseKeyword:
         case SyntaxKind.DefaultKeyword:
         case SyntaxKind.IfKeyword:
         case SyntaxKind.ElseKeyword:
         case SyntaxKind.ElifKeyword:
         case SyntaxKind.EndIfKeyword:
         case SyntaxKind.RegionKeyword:
         case SyntaxKind.EndRegionKeyword:
         case SyntaxKind.DefineKeyword:
         case SyntaxKind.UndefKeyword:
         case SyntaxKind.WarningKeyword:
         case SyntaxKind.ErrorKeyword:
         case SyntaxKind.LineKeyword:
         case SyntaxKind.PragmaKeyword:
         case SyntaxKind.HiddenKeyword:
         case SyntaxKind.ChecksumKeyword:
         case SyntaxKind.DisableKeyword:
         case SyntaxKind.RestoreKeyword:
         case SyntaxKind.ReferenceKeyword:
         case SyntaxKind.LoadKeyword:
             return true;
         default:
             return false;
     }
 }

 public XmlElementEndTagSyntax(SyntaxKind kind, PunctuationSyntax lessThanSlashToken, XmlNameSyntax name, PunctuationSyntax greaterThanToken) : base(kind)
 {
     this.LessThanSlashToken = lessThanSlashToken;
     this.NameNode = name;
     this.GreaterThanToken = greaterThanToken;
     this.SlotCount = 3;
 }

 protected SyntaxNodeOrToken M(SyntaxKind kind)
 {
     Assert.True(_treeEnumerator.MoveNext());
     SyntaxNodeOrToken current = _treeEnumerator.Current;
     Assert.Equal(kind, current.Kind());
     Assert.True(current.IsMissing);
     return current;
 }

 public static LiteralKind LiteralKindFromSyntaxKind(SyntaxKind kind)
 {
    foreach (var tuple in LiteralKindMap)
    {
       if (tuple.Item1 == kind) { return tuple.Item3; }
    }
    throw new InvalidOperationException();
 }