public PathSyntaxReference(SyntaxNode node) { _tree = node.SyntaxTree; _kind = node.Kind(); _textSpan = node.Span; _pathFromRoot = ComputePathFromRoot(node); }
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); }
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; }
public XmlCommentSyntax(SyntaxKind kind, PunctuationSyntax beginComment, SyntaxNode node, PunctuationSyntax endComment) : base(kind) { this.BeginComment = beginComment; this.Content = node; this.EndComment = endComment; SlotCount = 3; }
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; } }
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; }
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; }
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) { }
public XmlElementEndTagSyntax(SyntaxKind kind, PunctuationSyntax lessThanSlashToken, XmlNameSyntax name, PunctuationSyntax greaterThanToken) : base(kind) { this.LessThanSlashToken = lessThanSlashToken; this.NameNode = name; this.GreaterThanToken = greaterThanToken; this.SlotCount = 3; }
internal SyntaxTrivia(SyntaxKind kind, string text) : this() { _kind = kind; _start = 0; _text = text; }
public PathSyntaxReference(SyntaxNode node) { this.tree = node.SyntaxTree; this.kind = node.CSharpKind(); this.textSpan = node.Span; this.pathFromRoot = ComputePathFromRoot(node); }
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; } }
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; } }
public PositionalSyntaxReference(SyntaxNode node) { _tree = node.SyntaxTree; _textSpan = node.Span; _kind = node.Kind(); System.Diagnostics.Debug.Assert(_textSpan.Length > 0); }
public static LiteralKind LiteralKindFromSyntaxKind(SyntaxKind kind) { foreach (var tuple in LiteralKindMap) { if (tuple.Item1 == kind) { return tuple.Item3; } } throw new InvalidOperationException(); }
public XmlStringSyntax(SyntaxKind kind, PunctuationSyntax startQuoteToken, SyntaxList<SyntaxNode> textTokens, PunctuationSyntax endQuoteToken) : base(kind) { this.StartQuoteToken = startQuoteToken; this.TextTokens = textTokens; this.EndQuoteToken = endQuoteToken; this.SlotCount = 3; }
public static AssignmentOperator AssignmentOperatorFromCSharpKind(SyntaxKind kind) { foreach (var tuple in assignmentOpMap) { if (tuple.Item1 == kind) { return tuple.Item3; } } throw new InvalidOperationException(); }
static void HandleDefaultModifier(SyntaxNodeAnalysisContext context, SyntaxTokenList modifiers, SyntaxKind defaultModifier) { var index = modifiers.IndexOf(defaultModifier); if (index != -1) { context.ReportDiagnostic(Diagnostic.Create(Rule, modifiers[index].GetLocation())); } }
public PositionalSyntaxReference(SyntaxNode node) { this.tree = node.SyntaxTree; this.textSpan = node.Span; this.kind = node.CSharpKind(); System.Diagnostics.Debug.Assert(textSpan.Length > 0); }
public KeywordSyntax( SyntaxKind kind, string text, SyntaxNode leadingTrivia, SyntaxNode trailingTrivia) : base(kind, text, leadingTrivia, trailingTrivia) { }
public PunctuationSyntax( SyntaxKind kind, string text, SyntaxNode leadingTrivia, SyntaxNode trailingTrivia) : base(kind, text, leadingTrivia, trailingTrivia) { }
private static BraceMatchingResult MatchBraces(SyntaxTree syntaxTree, SourceLocation position, SyntaxKind leftKind, SyntaxKind rightKind) { return syntaxTree.Root.FindStartTokens(position) .Select(t => MatchBraces(t, position, leftKind, rightKind)) .Where(r => r.IsValid) .DefaultIfEmpty(BraceMatchingResult.None) .First(); }
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 XmlDeclarationOptionSyntax(SyntaxKind kind, XmlNameTokenSyntax name, PunctuationSyntax equals, XmlStringSyntax value) : base(kind) { this.Name = name; this.Equals = equals; this.Value = value; this.SlotCount = 3; }
private void AddAccessorNode(AccessorListSyntax accessorList, SyntaxKind filter) { var accessor = accessorList.Accessors.FirstOrDefault(x => x.IsKind(filter)); if (accessor != null) { _members.Add(accessor); } }
public static XmlTextAttributeSyntax TextAttribute(XmlNameSyntax name, SyntaxKind quoteKind, SyntaxTokenList textTokens) { return SyntaxFactory.XmlTextAttribute( name, SyntaxFactory.Token(quoteKind), textTokens, SyntaxFactory.Token(quoteKind)) .WithLeadingTrivia(SyntaxFactory.Whitespace(" ")); }
public static bool MatchesKind(this SyntaxNode node, SyntaxKind kind1, SyntaxKind kind2) { if (node == null) { return false; } return node.IsKind(kind1) || node.IsKind(kind2); }
public static bool IsKind(this SyntaxNode node, SyntaxKind kind1, SyntaxKind kind2, SyntaxKind kind3, SyntaxKind kind4, SyntaxKind kind5) { if (node == null) { return false; } var vbKind = node.Kind(); return vbKind == kind1 || vbKind == kind2 || vbKind == kind3 || vbKind == kind4 || vbKind == kind5; }
internal void Assert(SyntaxKind expectedType) { Debug.Assert(!EndOfFile && CurrentToken.Kind == expectedType); }
protected internal bool NextIs(SyntaxKind type) { return(NextIs(token => token != null && type == token.Kind)); }
private bool IsMultilineComment(SyntaxTrivia trivia) { SyntaxKind kind = trivia.Kind(); return(kind == SyntaxKind.MultiLineCommentTrivia || kind == SyntaxKind.MultiLineDocumentationCommentTrivia); }
public static void AnalyzeClassDeclaration(SyntaxNodeAnalysisContext context) { var classDeclaration = (ClassDeclarationSyntax)context.Node; if (!classDeclaration.Identifier.ValueText.EndsWith("Extensions", StringComparison.Ordinal)) { return; } if (!classDeclaration.Modifiers.Contains(SyntaxKind.StaticKeyword)) { return; } if (!classDeclaration.IsParentKind(SyntaxKind.NamespaceDeclaration, SyntaxKind.CompilationUnit)) { return; } if (!SyntaxAccessibility <ClassDeclarationSyntax> .Instance.GetAccessibility(classDeclaration).Is(Accessibility.Public, Accessibility.Internal)) { return; } foreach (MemberDeclarationSyntax member in classDeclaration.Members) { if (!member.IsKind(SyntaxKind.MethodDeclaration)) { continue; } var methodDeclaration = (MethodDeclarationSyntax)member; if (!methodDeclaration.Modifiers.Contains(SyntaxKind.StaticKeyword)) { continue; } if (!SyntaxAccessibility <MethodDeclarationSyntax> .Instance.GetAccessibility(methodDeclaration).Is(Accessibility.Public, Accessibility.Internal)) { continue; } ParameterSyntax parameter = methodDeclaration.ParameterList?.Parameters.FirstOrDefault(); if (parameter == null) { continue; } if (parameter.Default != null) { continue; } if (parameter.Type.IsKind(SyntaxKind.PointerType)) { continue; } if (parameter.Modifiers.Contains(SyntaxKind.ParamsKeyword)) { continue; } bool isThis = false; bool isIn = false; bool isRef = false; foreach (SyntaxToken modifier in parameter.Modifiers) { SyntaxKind kind = modifier.Kind(); if (kind == SyntaxKind.ThisKeyword) { isThis = true; break; } else if (kind == SyntaxKind.InKeyword) { isIn = true; } else if (kind == SyntaxKind.RefKeyword) { isRef = true; } if (isThis) { break; } } if (isThis) { continue; } if (isIn) { IParameterSymbol parameterSymbol = context.SemanticModel.GetDeclaredSymbol(parameter, context.CancellationToken); ITypeSymbol typeSymbol = parameterSymbol.Type; if (!typeSymbol.IsValueType) { continue; } if (typeSymbol.Kind == SymbolKind.TypeParameter) { continue; } } else if (isRef) { IParameterSymbol parameterSymbol = context.SemanticModel.GetDeclaredSymbol(parameter, context.CancellationToken); if (!parameterSymbol.Type.IsValueType) { continue; } } DiagnosticHelpers.ReportDiagnostic(context, DiagnosticDescriptors.MakeMethodExtensionMethod, methodDeclaration.Identifier); } }
internal SyntaxToken(SyntaxKind kind, string content, RazorDiagnostic[] diagnostics) : base(kind, content.Length, diagnostics, annotations: null) { Content = content; }
public static bool IsKind(this SyntaxToken token, SyntaxKind kind1, SyntaxKind kind2, SyntaxKind kind3) { return(token.Kind() == kind1 || token.Kind() == kind2 || token.Kind() == kind3); }
private static void AnalyzeEqualsNotEquals( SyntaxNodeAnalysisContext context, BinaryExpressionSyntax binaryExpression, ExpressionSyntax left, ExpressionSyntax right, SyntaxKind kind, SyntaxKind kind2) { SyntaxKind leftKind = left.Kind(); if (leftKind == kind) { switch (AnalyzeExpression(right, context.SemanticModel, context.CancellationToken)) { case AnalysisResult.Boolean: { SimplifyBooleanComparisonAnalysis.ReportDiagnostic(context, binaryExpression, left, right, fadeOut: true); break; } case AnalysisResult.LogicalNotWithNullableBoolean: { SimplifyBooleanComparisonAnalysis.ReportDiagnostic(context, binaryExpression, left, right, fadeOut: false); break; } } } else if (leftKind == kind2) { switch (AnalyzeExpression(right, context.SemanticModel, context.CancellationToken)) { case AnalysisResult.Boolean: { RemoveRedundantBooleanLiteralAnalysis.ReportDiagnostic(context, binaryExpression, left, right); break; } case AnalysisResult.LogicalNotWithNullableBoolean: { SimplifyBooleanComparisonAnalysis.ReportDiagnostic(context, binaryExpression, left, right, fadeOut: false); break; } } } else { SyntaxKind rightKind = right.Kind(); if (rightKind == kind) { switch (AnalyzeExpression(left, context.SemanticModel, context.CancellationToken)) { case AnalysisResult.Boolean: { SimplifyBooleanComparisonAnalysis.ReportDiagnostic(context, binaryExpression, left, right, fadeOut: true); break; } case AnalysisResult.LogicalNotWithNullableBoolean: { SimplifyBooleanComparisonAnalysis.ReportDiagnostic(context, binaryExpression, left, right, fadeOut: false); break; } } } else if (rightKind == kind2) { switch (AnalyzeExpression(left, context.SemanticModel, context.CancellationToken)) { case AnalysisResult.Boolean: { RemoveRedundantBooleanLiteralAnalysis.ReportDiagnostic(context, binaryExpression, left, right); break; } case AnalysisResult.LogicalNotWithNullableBoolean: { SimplifyBooleanComparisonAnalysis.ReportDiagnostic(context, binaryExpression, left, right, fadeOut: false); break; } } } } }
protected internal void AcceptUntil(SyntaxKind type) { AcceptWhile(token => type != token.Kind); }
private static int GetOrderIndex(SyntaxKind kind) { switch (kind) { case SyntaxKind.NewKeyword: return(0); case SyntaxKind.PublicKeyword: return(1); case SyntaxKind.PrivateKeyword: return(2); case SyntaxKind.ProtectedKeyword: return(3); case SyntaxKind.InternalKeyword: return(4); case SyntaxKind.ConstKeyword: return(5); case SyntaxKind.StaticKeyword: return(6); case SyntaxKind.VirtualKeyword: return(7); case SyntaxKind.SealedKeyword: return(8); case SyntaxKind.OverrideKeyword: return(9); case SyntaxKind.AbstractKeyword: return(10); case SyntaxKind.ReadOnlyKeyword: return(11); case SyntaxKind.ExternKeyword: return(12); case SyntaxKind.UnsafeKeyword: return(13); case SyntaxKind.VolatileKeyword: return(14); case SyntaxKind.AsyncKeyword: return(15); case SyntaxKind.PartialKeyword: return(16); default: { Debug.Fail($"unknown modifier '{kind}'"); return(_maxOrderIndex); } } }
protected BranchingDirectiveTriviaSyntax(SyntaxKind kind) : base(kind) { }
protected ConditionalDirectiveTriviaSyntax(SyntaxKind kind) : base(kind) { }
protected DefineDirectiveTriviaSyntax(SyntaxKind kind) : base(kind) { }
protected DirectiveTriviaSyntax(SyntaxKind kind, IEnumerable <Diagnostic> diagnostics) : base(kind, diagnostics) { }
internal MissingToken(SyntaxKind kind, GreenNode leading, GreenNode trailing, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) : base(kind, string.Empty, leading, trailing, diagnostics, annotations) { Flags |= NodeFlags.IsMissing; }
private static BinaryExpressionPart GetRedundantPart( ExpressionSyntax left, ExpressionSyntax right, SemanticModel semanticModel, CancellationToken cancellationToken) { SyntaxKind leftKind = left.Kind(); SyntaxKind rightKind = right.Kind(); switch (leftKind) { case SyntaxKind.ObjectCreationExpression: case SyntaxKind.AnonymousObjectCreationExpression: case SyntaxKind.ArrayCreationExpression: case SyntaxKind.ImplicitArrayCreationExpression: case SyntaxKind.InterpolatedStringExpression: case SyntaxKind.ThisExpression: case SyntaxKind.StringLiteralExpression: case SyntaxKind.TypeOfExpression: return(BinaryExpressionPart.Right); case SyntaxKind.NullLiteralExpression: return(BinaryExpressionPart.Left); case SyntaxKind.DefaultExpression: { if (IsDefaultOfReferenceType((DefaultExpressionSyntax)left, semanticModel, cancellationToken)) { return(BinaryExpressionPart.Left); } break; } } Optional <object> optional = semanticModel.GetConstantValue(left, cancellationToken); if (optional.HasValue) { object value = optional.Value; if (value != null) { return(BinaryExpressionPart.Right); } else { return(BinaryExpressionPart.Left); } } ITypeSymbol leftSymbol = semanticModel.GetTypeSymbol(left, cancellationToken); if (leftSymbol?.IsErrorType() == false && leftSymbol.IsValueType && !leftSymbol.IsNullableType()) { return(BinaryExpressionPart.Right); } switch (rightKind) { case SyntaxKind.NullLiteralExpression: return(BinaryExpressionPart.Right); case SyntaxKind.DefaultExpression: { if (IsDefaultOfReferenceType((DefaultExpressionSyntax)right, semanticModel, cancellationToken)) { return(BinaryExpressionPart.Right); } break; } } if (leftKind == rightKind && CSharpFactory.AreEquivalent(left, right)) { return(BinaryExpressionPart.Right); } return(BinaryExpressionPart.None); }
public static bool HasMatchingText(this SyntaxToken token, SyntaxKind kind) { return(token.ToString() == SyntaxFacts.GetText(kind)); }
internal SyntaxTokenIdentifier(SyntaxKind type, string name) // Text가 아직 설정되지 않은 상태에서 base 생성자에서는 Text.Length 를 사용해서 : base(type, name.Length) { _value = name; }
public static string GetText(this SyntaxKind kind) { switch (kind) { case SyntaxKind.PlusToken: return("+"); case SyntaxKind.MinusToken: return("-"); case SyntaxKind.StarToken: return("*"); case SyntaxKind.SlashToken: return("/"); case SyntaxKind.OpenParensToken: return("("); case SyntaxKind.CloseParensToken: return(")"); case SyntaxKind.OpenBraceToken: return("{"); case SyntaxKind.CloseBraceToken: return("}"); case SyntaxKind.BangToken: return("!"); case SyntaxKind.AmpersandAmpersandToken: return("&&"); case SyntaxKind.PipePipeToken: return("||"); case SyntaxKind.EqualsEqualsToken: return("=="); case SyntaxKind.BangEqualsToken: return("!="); case SyntaxKind.EqualsToken: return("="); case SyntaxKind.FalseKeyword: return("false"); case SyntaxKind.TrueKeyword: return("true"); case SyntaxKind.LetKeyword: return("let"); case SyntaxKind.VarKeyword: return("var"); case SyntaxKind.IfKeyword: return("if"); case SyntaxKind.ElseKeyword: return("else"); case SyntaxKind.WhileKeyword: return("while"); case SyntaxKind.ForKeyword: return("for"); case SyntaxKind.ToKeyword: return("to"); case SyntaxKind.LessThanToken: return("<"); case SyntaxKind.LessThanOrEqualToken: return("<="); case SyntaxKind.GreaterThanToken: return(">"); case SyntaxKind.GreaterThanOrEqualToken: return(">="); case SyntaxKind.AmpersandToken: return("&"); case SyntaxKind.PipeToken: return("|"); case SyntaxKind.HatToken: return("^"); case SyntaxKind.TildeToken: return("~"); default: return(null); } }
protected internal void AcceptWhile(SyntaxKind type1, SyntaxKind type2, SyntaxKind type3) { AcceptWhile(token => type1 == token.Kind || type2 == token.Kind || type3 == token.Kind); }
public static string GetText(SyntaxKind kind) { switch (kind) { case SyntaxKind.PlusToken: return("+"); case SyntaxKind.MinusToken: return("-"); case SyntaxKind.StarToken: return("*"); case SyntaxKind.ModuloToken: return("%"); case SyntaxKind.SlashToken: return("/"); case SyntaxKind.BangToken: return("!"); case SyntaxKind.AmpersandAmpersandToken: return("&&"); case SyntaxKind.PipePipeToken: return("||"); case SyntaxKind.AmpersandToken: return("&"); case SyntaxKind.PipeToken: return("|"); case SyntaxKind.TildeToken: return("~"); case SyntaxKind.HatToken: return("^"); case SyntaxKind.EqualsEqualsToken: return("=="); case SyntaxKind.BangEqualsToken: return("!="); case SyntaxKind.GreaterOrEqualsToken: return(">="); case SyntaxKind.GreaterToken: return(">"); case SyntaxKind.LessOrEqualsToken: return("<="); case SyntaxKind.LessToken: return("<"); case SyntaxKind.OpenParenthesisToken: return("("); case SyntaxKind.CloseParenthesisToken: return(")"); case SyntaxKind.ColonToken: return(":"); case SyntaxKind.OpenBraceToken: return("{"); case SyntaxKind.CloseBraceToken: return("}"); case SyntaxKind.SemicolonToken: return(";"); case SyntaxKind.EqualsToken: return("="); case SyntaxKind.FalseKeyword: return("false"); case SyntaxKind.TrueKeyword: return("true"); case SyntaxKind.ConstKeyword: return("const"); case SyntaxKind.VarKeyword: return("var"); case SyntaxKind.IfKeyword: return("if"); case SyntaxKind.ElseKeyword: return("else"); case SyntaxKind.FunctionKeyword: return("function"); case SyntaxKind.DoKeyword: return("do"); case SyntaxKind.WhileKeyword: return("while"); case SyntaxKind.ForKeyword: return("for"); case SyntaxKind.ToKeyword: return("to"); case SyntaxKind.CommaToken: return(","); case SyntaxKind.BreakKeyword: return("break"); case SyntaxKind.ContinueKeyword: return("continue"); case SyntaxKind.ReturnKeyword: return("return"); default: return(null); } }
public static bool IsKindOrHasMatchingText(this SyntaxToken token, SyntaxKind kind) { return(token.Kind() == kind || token.HasMatchingText(kind)); }
protected internal bool At(SyntaxKind type) { return(!EndOfFile && CurrentToken != null && CurrentToken.Kind == type); }
bool TryFindMatchingToken(SyntaxToken token, out SyntaxToken match, SyntaxKind openKind, SyntaxKind closeKind) { var parent = token.Parent; var braceTokens = parent .ChildTokens() .Where(t => t.Span.Length > 0 && (t.IsKind(openKind) || t.IsKind(closeKind))) .ToList(); if (braceTokens.Count == 2 && braceTokens [0].IsKind(openKind) && braceTokens [1].IsKind(closeKind)) { if (braceTokens [0] == token) { match = braceTokens [1]; return(true); } else if (braceTokens [1] == token) { match = braceTokens [0]; return(true); } } match = default(SyntaxToken); return(false); }
protected internal bool Was(SyntaxKind type) { return(PreviousToken != null && PreviousToken.Kind == type); }
private static void MakeAssignmentChange(SyntaxKind oldStyle, SyntaxKind newStyle) { MakeAssignmentChanges(oldStyle, newStyle); MakeAssignmentChanges(oldStyle, newStyle, options: TestOptions.Script); MakeAssignmentChanges(oldStyle, newStyle, topLevel: true, options: TestOptions.Script); }
protected internal void AcceptUntil(SyntaxKind type1, SyntaxKind type2, SyntaxKind type3) { AcceptWhile(token => type1 != token.Kind && type2 != token.Kind && type3 != token.Kind); }
internal static ConvertedSyntaxKind ConvertToLocalType(this SyntaxKind source) { return(source.Convert <SyntaxKind, ConvertedSyntaxKind>()); }
public int GetInsertIndex(SyntaxTokenList modifiers, SyntaxKind modifierKind) { return(GetInsertIndex(modifiers, GetOrderIndex(modifierKind))); }
internal static SyntaxToken CreateMissing(SyntaxKind kind, params RazorDiagnostic[] diagnostics) { return(new MissingToken(kind, diagnostics)); }
internal MissingToken(SyntaxKind kind, RazorDiagnostic[] diagnostics) : base(kind, string.Empty, diagnostics) { Flags |= NodeFlags.IsMissing; }