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;
}
