private static void TestVisibility(string source, string enumName, SyntaxKind?expectedVisibility)
{
// Assembling some code
IAssemblyLoader assemblyLoader = new Utils.AsmlDasmlAssemblyLoader(source);
// Loading the assembly
IAssemblyProxy assembly = assemblyLoader.Load();
// Locating the enum
ITypeInfoProxy enumDefinition = assembly.LocateType(enumName);
Assert.IsNotNull(enumDefinition);
// Generating the AST
var factory = new EnumDeclarationSyntaxFactory(enumDefinition);
var syntaxNode = factory.Create();
Assert.IsNotNull(syntaxNode, "A node was expected to be built");
Assert.IsInstanceOfType(syntaxNode, typeof(EnumDeclarationSyntax), "Expected an enum declaration node to be built");
var enumDeclarationSyntaxNode = syntaxNode as EnumDeclarationSyntax;
var modifiers = enumDeclarationSyntaxNode.Modifiers;
if (expectedVisibility.HasValue)
{
Assert.IsTrue(Utils.CheckModifier(modifiers, expectedVisibility.Value), "Enum does not have correct visibility");
return;
}
Assert.AreEqual(0, modifiers.Count(), "Expected no modifier");
}
public static PropertyDeclarationSyntax AutoPropertyDeclaration(
IEnumerable <SyntaxKind> modifiers, TypeSyntax type, string propertyName,
SyntaxKind?setModifier = null, SyntaxKind?getModifier = null, bool isAbstract = false)
{
var accesors = new List <AccessorDeclarationSyntax>();
if (!(isAbstract && getModifier == SyntaxKind.PrivateKeyword))
{
accesors.Add(
Syntax.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.WithModifiers(TokenList(getModifier))
.WithSemicolonToken(Syntax.Token(SyntaxKind.SemicolonToken)));
}
if (!(isAbstract && setModifier == SyntaxKind.PrivateKeyword))
{
accesors.Add(
Syntax.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration)
.WithModifiers(TokenList(setModifier))
.WithSemicolonToken(Syntax.Token(SyntaxKind.SemicolonToken)));
}
return(Syntax.PropertyDeclaration(type, propertyName)
.WithModifiers(TokenList(modifiers))
.WithAccessorList(Syntax.AccessorList(accesors.ToSyntaxList())));
}
public static PropertyDeclarationSyntax AutoPropertyDeclaration(
IEnumerable <SyntaxKind> modifiers, string typeName, string propertyName,
SyntaxKind?setModifier = null, SyntaxKind?getModifier = null, bool isAbstract = false)
{
return(AutoPropertyDeclaration(
modifiers, Syntax.ParseTypeName(typeName), propertyName, setModifier, getModifier, isAbstract));
}
public sealed override SyntaxNode VisitAnonymousMethodExpression(AnonymousMethodExpressionSyntax node)
{
if (RewritingSyntaxKind.HasValue)
{
return(node);
}
RewritingSyntaxKind = node.Kind();
return(OnVisitAnonymousMethodExpression(node));
}
public sealed override SyntaxNode VisitSimpleLambdaExpression(SimpleLambdaExpressionSyntax node)
{
if (RewritingSyntaxKind.HasValue)
{
return(node);
}
RewritingSyntaxKind = node.Kind();
return(OnVisitSimpleLambdaExpression(node));
}
public sealed override SyntaxNode VisitLocalFunctionStatement(LocalFunctionStatementSyntax node)
{
if (RewritingSyntaxKind.HasValue)
{
return(node);
}
RewritingSyntaxKind = node.Kind();
return(OnVisitLocalFunctionStatement(node));
}
public static EnumDeclarationSyntax EnumDeclaration(
string enumName, IEnumerable <EnumMemberDeclarationSyntax> members, SyntaxKind?baseType = null)
{
return(Syntax.EnumDeclaration(enumName)
.WithModifiers(TokenList(SyntaxKind.PublicKeyword))
.WithBaseList(
baseType == null
? null
: Syntax.BaseList(
new TypeSyntax[] { Syntax.PredefinedType(Syntax.Token(baseType.Value)) }
.ToSeparatedList()))
.WithMembers(members.ToSeparatedList()));
}
private SyntaxKind GetTypeDefaultVisibility(TypeBlockSyntax originalTypeBlockSyntax)
{
// In the case of partial types we need to use the existing visibility if it exists
if (originalTypeBlockSyntax.BlockStatement.Modifiers.Any(x => x.Kind() == SyntaxKind.PartialKeyword))
{
SyntaxKind?kind = GetExistingPartialVisibility(originalTypeBlockSyntax);
if (kind.HasValue)
{
return(kind.Value);
}
}
return(GetDelegateTypeDefaultVisibility(originalTypeBlockSyntax));
}
/// <summary>
/// Returns the <see cref="SyntaxNode.Parent" /> if its type is
/// <typeparam name="TParent"></typeparam>
/// .
/// </summary>
/// <typeparam name="TParent"></typeparam>
/// <param name="node">Node to get parent of.</param>
/// <param name="kind">Optionally require parent to also be of this kind.</param>
/// <returns>Parent or null if not found or not matching type or kind.</returns>
public static TParent Parent <TParent>(this SyntaxNode node, SyntaxKind?kind = null) where TParent : SyntaxNode
{
TParent parent = node.Parent as TParent;
if (parent == null)
{
return(default(TParent));
}
if (kind == null)
{
return(parent);
}
return(parent.Kind() != kind ? default(TParent) : parent);
}
internal static bool IdentifierIsLocalVariable(IdentifierNameSyntax identifier)
{
SyntaxNode parentMethod = IdentifierUtilities.TryGetParentMethod(identifier.Parent);
SyntaxKind?kind = parentMethod?.Kind;
if (kind.HasValue)
{
switch (kind.GetValueOrDefault())
{
case SyntaxKind.TriggerDeclaration:
return(IdentifierUtilities.VerifyIdentifierIsInMethodTriggerVarParamList <TriggerDeclarationSyntax>((TriggerDeclarationSyntax)parentMethod, identifier));
case SyntaxKind.MethodDeclaration:
return(IdentifierUtilities.VerifyIdentifierIsInMethodTriggerVarParamList <MethodDeclarationSyntax>((MethodDeclarationSyntax)parentMethod, identifier));
}
}
return(false);
}
private PostSkipAction SkipBadTokens(
Func <HlslParser, bool> isNotExpectedFunction,
Func <HlslParser, bool> abortFunction,
SyntaxKind?expected = null)
{
var action = PostSkipAction.Continue;
var tokens = new List <SyntaxToken>();
var first = true;
while (isNotExpectedFunction(this))
{
if (abortFunction(this))
{
action = PostSkipAction.Abort;
break;
}
tokens.Add(first && expected != null ? NextTokenWithPrejudice(expected.Value) : NextToken());
first = false;
}
if (!_scanStack.Any() && tokens.Any())
{
var current = _tokens[_tokenIndex];
var skippedTokensTrivia = CreateSkippedTokensTrivia(tokens);
var leadingTrivia = new List <SyntaxNode>(current.LeadingTrivia.Length + 1);
leadingTrivia.Add(skippedTokensTrivia);
leadingTrivia.AddRange(current.LeadingTrivia);
_tokens[_tokenIndex] = current
.WithLeadingTrivia(leadingTrivia)
.WithDiagnostic(Diagnostic.Create(
HlslMessageProvider.Instance,
tokens.First().SourceRange,
(int)DiagnosticId.TokenUnexpected,
tokens.First().Text));
}
return(action);
}
private static IImmutableDictionary <SyntaxKind, TimeSpan> GetHotDurations(SyntaxElement rootElement)
{
var elements = rootElement.GetDescendants <SyntaxElement>();
var builder = ImmutableDictionary <SyntaxKind, TimeSpan> .Empty.ToBuilder();
SyntaxKind?kind = null;
foreach (var e in elements)
{
if (kind == null)
{
if (e.Kind == SyntaxKind.HotKeyword ||
e.Kind == SyntaxKind.HotDataKeyword ||
e.Kind == SyntaxKind.HotIndexKeyword)
{
if (!e.IsMissing)
{
kind = e.Kind;
}
}
}
else
{
if (e.Kind == SyntaxKind.TimespanLiteralToken)
{
var token = (SyntaxToken)e;
var t = (TimeSpan)token.Value;
builder.Add(kind.Value, t);
kind = null;
}
}
}
return(builder.ToImmutable());
}
public static PropertyDeclarationSyntax PropertyDeclaration(
IEnumerable <SyntaxKind> modifiers, TypeSyntax type, string propertyName,
IEnumerable <StatementSyntax> getStatements, SyntaxKind?getModifier = null,
IEnumerable <StatementSyntax> setStatements = null, SyntaxKind?setModifier = null)
{
var accessors = new List <AccessorDeclarationSyntax>();
accessors.Add(
Syntax.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.WithModifiers(TokenList(getModifier))
.WithBody(Syntax.Block(getStatements.ToSyntaxList())));
if (setStatements != null)
{
accessors.Add(
Syntax.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration)
.WithModifiers(TokenList(setModifier))
.WithBody(Syntax.Block(setStatements.ToSyntaxList())));
}
return(Syntax.PropertyDeclaration(type, propertyName)
.WithModifiers(TokenList(modifiers))
.WithAccessorList(Syntax.AccessorList(accessors.ToSyntaxList())));
}
public override bool IsSimpleMemberAccessExpressionNode(SyntaxNode node)
{
SyntaxKind?kind = node?.Kind();
return(kind == SyntaxKind.SimpleMemberAccessExpression);
}
public override bool IsObjectCreationExpressionNode(SyntaxNode node)
{
SyntaxKind?kind = node?.Kind();
return(kind == SyntaxKind.ObjectCreationExpression);
}
internal static PropertyDeclarationSyntax CreateAutoProperty(TypeSyntax type, string identifier, SyntaxList <AccessorDeclarationSyntax> accessors, SyntaxKind?accessibility)
{
var newProperty = SyntaxFactory.PropertyDeclaration(type, identifier)
.WithAccessorList(SyntaxFactory.AccessorList(accessors));
if (accessibility.HasValue)
{
newProperty = newProperty.WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(accessibility.Value)));
}
return(newProperty.WithAdditionalAnnotations(Formatter.Annotation));
}
private static int CountArguments(IEnumerable <SyntaxNode> childNodes, SyntaxKind?kind = null) => childNodes.OfType <ArgumentListSyntax>().Where(s => s.Arguments.Any(a => a.Expression.Kind() == kind)).Select(s => s.Arguments.Count).FirstOrDefault();
protected ExpressionSelectorBase(SyntaxKind?kind = null)
{
this.kind = kind;
}
private void AddSemanticRange(SyntaxNode node, SyntaxKind?kind = null)
{
if (node is null)
{
throw new ArgumentNullException(nameof(node));
}
if (kind is null)
{
kind = node.Kind;
}
if (node.Width == 0)
{
// Under no circumstances can we have 0-width spans.
// This can happen in situations like "@* comment ", where EndCommentStar and EndCommentTransition are empty.
return;
}
int semanticKind;
switch (kind)
{
case SyntaxKind.MarkupTagHelperDirectiveAttribute:
case SyntaxKind.MarkupMinimizedTagHelperDirectiveAttribute:
semanticKind = RazorSemanticTokensLegend.RazorDirectiveAttribute;
break;
case SyntaxKind.MarkupTagHelperStartTag:
case SyntaxKind.MarkupTagHelperEndTag:
semanticKind = RazorSemanticTokensLegend.RazorTagHelperElement;
break;
case SyntaxKind.MarkupTagHelperAttribute:
case SyntaxKind.MarkupMinimizedTagHelperAttribute:
semanticKind = RazorSemanticTokensLegend.RazorTagHelperAttribute;
break;
case SyntaxKind.Transition:
semanticKind = RazorSemanticTokensLegend.RazorTransition;
break;
case SyntaxKind.Colon:
semanticKind = RazorSemanticTokensLegend.RazorDirectiveColon;
break;
case SyntaxKind.RazorDirective:
semanticKind = RazorSemanticTokensLegend.RazorDirective;
break;
case SyntaxKind.RazorCommentTransition:
semanticKind = RazorSemanticTokensLegend.RazorCommentTransition;
break;
case SyntaxKind.RazorCommentStar:
semanticKind = RazorSemanticTokensLegend.RazorCommentStar;
break;
case SyntaxKind.RazorCommentLiteral:
semanticKind = RazorSemanticTokensLegend.RazorComment;
break;
case SyntaxKind.RazorComment:
semanticKind = RazorSemanticTokensLegend.RazorComment;
break;
case SyntaxKind.OpenAngle:
case SyntaxKind.CloseAngle:
case SyntaxKind.ForwardSlash:
semanticKind = RazorSemanticTokensLegend.MarkupTagDelimiter;
break;
case SyntaxKind.Equals:
semanticKind = RazorSemanticTokensLegend.MarkupOperator;
break;
case SyntaxKind.MarkupElement:
semanticKind = RazorSemanticTokensLegend.MarkupElement;
break;
case SyntaxKind.MarkupAttributeBlock:
semanticKind = RazorSemanticTokensLegend.MarkupAttribute;
break;
case SyntaxKind.MarkupCommentBlock:
semanticKind = RazorSemanticTokensLegend.MarkupComment;
break;
default:
throw new NotImplementedException();
}
AddSemanticRange(node, semanticKind);
}
private SyntaxToken LexDirectiveToken()
{
_kind = SyntaxKind.BadToken;
_contextualKind = SyntaxKind.BadToken;
_diagnostics.Clear();
_start = _charReader.Position;
var trailingTrivia = new List<SyntaxNode>();
var isEndOfLine = false;
switch (_charReader.Current)
{
case '#':
NextChar();
if (_charReader.Current == '#')
{
NextChar();
_kind = SyntaxKind.HashHashToken;
}
else
{
_kind = SyntaxKind.HashToken;
_currentDirectiveKind = null;
}
break;
case '\r':
case '\n':
_kind = SyntaxKind.EndOfDirectiveToken;
_currentDirectiveKind = null;
isEndOfLine = true;
break;
case '\0':
_kind = SyntaxKind.EndOfDirectiveToken;
_currentDirectiveKind = null;
break;
case '<':
if (_currentDirectiveKind != SyntaxKind.IncludeKeyword)
goto default;
ReadBracketedString();
break;
default:
ReadToken();
if (_contextualKind.IsPreprocessorDirective())
_currentDirectiveKind = _contextualKind;
break;
}
var end = _charReader.Position;
var kind = _kind;
var span = TextSpan.FromBounds(Text, _start, end);
var text = Text.GetText(span);
var diagnostics = _diagnostics.ToImmutableArray();
LexDirectiveTrailingTrivia(trailingTrivia, kind, isEndOfLine);
var token = new SyntaxToken(kind, _contextualKind, false, MakeAbsolute(span), span, text, _value,
ImmutableArray<SyntaxNode>.Empty, trailingTrivia.ToImmutableArray(),
diagnostics, null, false);
return token;
}
public sealed override SyntaxNode VisitMethodDeclaration(MethodDeclarationSyntax node)
{
RewritingSyntaxKind = node.Kind();
return(OnVisitMethodDeclaration(node));
}
public static IReadOnlyCollection <AttributeListSyntax> Generate(IReadOnlyList <AttributeWrapper> attributes, ISet <string> excludeMembersAttributes, ISet <string> excludeAttributes, SyntaxKind?target = null)
{
return(attributes
.OrderByAndExclude(excludeMembersAttributes, excludeAttributes)
.Select(AttributeSymbolGenerator.Generate)
.Where(x => x != null)
.Select(x => AttributeList(x !, target))
.OrderBy(x => x.ToFullString())
.ToList());
}
public void AssignmentMutator_ShouldMutate(SyntaxKind input, SyntaxKind expectedOutput, SyntaxKind?additionalOutput = null)
{
var target = new AssignmentExpressionMutator();
var originalNode = SyntaxFactory.AssignmentExpression(
input,
SyntaxFactory.IdentifierName("a"),
SyntaxFactory.IdentifierName("b")
);
var result = target.ApplyMutations(originalNode).ToList();
if (additionalOutput.HasValue && additionalOutput.Value is var additionalExpectedOutput)
{
result.Count.ShouldBe(2);
result.First().ReplacementNode.IsKind(expectedOutput).ShouldBeTrue();
result.Last().ReplacementNode.IsKind(additionalExpectedOutput).ShouldBeTrue();
}
else
{
var mutation = result.ShouldHaveSingleItem();
mutation.ReplacementNode.IsKind(expectedOutput).ShouldBeTrue();
}
foreach (var mutation in result)
{
mutation.Type.ShouldBe(Mutator.Assignment);
mutation.DisplayName.ShouldBe($"{input} to {mutation.ReplacementNode.Kind()} mutation");
}
}
/// <summary>
/// Set operator overloading.
/// </summary>
/// <param name="operator">Operator to overload</param>
/// <returns>The current method builder.</returns>
public MethodBuilder WithOperatorOverloading(SyntaxKind @operator)
{
_overrideOperator = @operator;
return(this);
}
/// <summary>
/// Set operator overloading.
/// </summary>
/// <param name="operator">Operator to overload</param>
/// <returns>The current method builder.</returns>
public MethodBuilder WithOperatorOverloading(Operators @operator)
{
_overrideOperator = OperatorFactory.GetSyntaxKind(@operator);
return(this);
}
public static void getAssertParams(Dictionary <string, IEnumerable <MethodDeclarationSyntax> > mapDocToPUTNames, List <string> assertStatements)
{
foreach (var keyValPair in mapDocToPUTNames)
{
foreach (MethodDeclarationSyntax put in keyValPair.Value)
{
//Console.WriteLine(put);
/* Charles, to number of lines for PUT/UnitTest, just body.Statements.Count*/
Console.WriteLine(put.Identifier);
BlockSyntax body = put.Body;
//SyntaxList<StatementSyntax> statements = body.Statements;
List <ExpressionStatementSyntax> expStmts = body.DescendantNodes().OfType <ExpressionStatementSyntax>().ToList();
foreach (ExpressionStatementSyntax stmt in expStmts)
{
Console.WriteLine("====");
SyntaxKind?k = stmt?.Expression?.Kind();
if (k != null && k.Equals(SyntaxKind.InvocationExpression))
{
//Todo: perhaps double check that statement does start with string "Assert"
Console.WriteLine(stmt);
SeparatedSyntaxList <ArgumentSyntax> args = ((InvocationExpressionSyntax)stmt.Expression).ArgumentList.Arguments;
foreach (ArgumentSyntax arg in args)
{
//Must Todo: Consider writing a visitor that returns all objects
// arguments can be ParenthesizedLambdaExpressionSyntax,IdentiferNameSyntax, elementAccessExpression(for array access), invocationExpressions,MemberAccessExpression,BinaryExpression ,ObjectCreationExpressionSyntax
Console.WriteLine(arg);
//Console.WriteLine(arg.Expression.Kind());
}
}
//var param = statement.
//var exp = (LocalDeclarationStatementSyntax)statement;
//Todo: Filter so that we only get asserts -- if condition may suffice
bool isAssert = false;
//Console.WriteLine(statement.ToString());
/*foreach(string assertStatement in assertStatements)
* {
* if (assertStatement.Equals("AssertTextRange"))
* {
* Console.WriteLine("In AssertTextRange");
* if (statement.ToString().StartsWith("AssertTextRange"))
* {
* Console.WriteLine(statement);
* }
* }
* if (!assertStatement.Equals("Assert") && assertStatement.StartsWith("Assert"))
* {
* //Console.WriteLine("In first if");
* if ((statement.ToString().StartsWith(assertStatement))) {
* Console.WriteLine("ASSERT1!!!");
* Console.WriteLine(statement);
* isAssert = true;
* break;
* }
*
*
* } else
* {
* if (statement.ToString().StartsWith("Assert." + assertStatement))
* {
* isAssert = true;
* Console.WriteLine("ASSERT2!!!");
* Console.WriteLine(statement);
*
* break;
* }
*
*
*
*
* }
* }
* if (isAssert)
* {
* //Console.WriteLine(statement.ToFullString());
* } */
//if (statement.ToString().StartsWith("Assert"))
//{
// Console.WriteLine(statement);
//}
}
//Console.WriteLine(keyValPair.Key);
//Console.WriteLine(put);
//Console.WriteLine(put.GetType());
}
}
}
protected TypeCastingLikeExpressionSelector(SyntaxKind?kind) : base(kind)
{
}
private static void AnalyzeArgumentListIdentifier(
IdentifierNameSyntax identifier,
SyntaxNodeAnalysisContext context,
Dictionary <string, IdentifierNameSyntax> firstVarInitializerSyntax,
Dictionary <string, IdentifierNameSyntax> firstVarUsageSyntax,
Dictionary <string, IdentifierNameSyntax> firstRecordChangeSyntax,
NavTypeKind variableNavTypeKind)
{
// ISSUE: variable of a compiler-generated type
ArgumentListSyntax parent = (ArgumentListSyntax)identifier.Parent;
if (!parent.Parent.IsKind(SyntaxKind.InvocationExpression))
{
return;
}
if (((InvocationExpressionSyntax)parent.Parent).Expression.IsKind(SyntaxKind.IdentifierName) && SemanticFacts.IsSameName(((SimpleNameSyntax)((InvocationExpressionSyntax)parent.Parent).Expression).Identifier.ValueText, "evaluate"))
{
SeparatedSyntaxList <CodeExpressionSyntax> arguments = parent.Arguments;
if (arguments[0].IsKind(SyntaxKind.IdentifierName))
{
arguments = parent.Arguments;
SyntaxToken identifier1 = ((SimpleNameSyntax)arguments[0]).Identifier;
string valueText1 = identifier1.ValueText;
identifier1 = identifier.Identifier;
string valueText2 = identifier1.ValueText;
if (SemanticFacts.IsSameName(valueText1, valueText2))
{
firstVarInitializerSyntax.AddIdentifierIfNotExist(identifier);
SyntaxKind?kind = identifier.Parent?.Parent?.Parent?.Kind;
if (!kind.HasValue)
{
return;
}
SyntaxKind valueOrDefault = kind.GetValueOrDefault();
if ((uint)valueOrDefault <= 235U)
{
if (valueOrDefault != SyntaxKind.IfStatement && valueOrDefault != SyntaxKind.ExitStatement)
{
return;
}
}
else
{
switch (valueOrDefault)
{
case SyntaxKind.LogicalOrExpression:
case SyntaxKind.LogicalAndExpression:
case SyntaxKind.LogicalXorExpression:
case SyntaxKind.UnaryNotExpression:
break;
default:
return;
}
}
firstVarUsageSyntax.AddIdentifierIfNotExist(identifier);
return;
}
}
firstVarUsageSyntax.AddIdentifierIfNotExist(identifier);
}
else
{
IInvocationExpression operation = (IInvocationExpression)context.SemanticModel.GetOperation(parent.Parent);
if (operation == null)
{
if (parent.Arguments.Count == 0)
{
return;
}
firstVarUsageSyntax.AddIdentifierIfNotExist(identifier);
}
else
{
if (operation.TargetMethod.MethodKind == MethodKind.BuiltInMethod && SemanticFacts.IsSameName(operation.TargetMethod.Name, "settable"))
{
firstRecordChangeSyntax.AddIdentifierIfNotExist(identifier);
}
foreach (IArgument obj in operation.Arguments)
{
if (obj.Value.Syntax == identifier)
{
if (obj.Parameter != null)
{
if (obj.Parameter.IsVar)
{
firstVarInitializerSyntax.AddIdentifierIfNotExist(identifier);
if (variableNavTypeKind == NavTypeKind.Record)
{
firstRecordChangeSyntax.AddIdentifierIfNotExist(identifier);
break;
}
firstVarUsageSyntax.AddIdentifierIfNotExist(identifier);
break;
}
if (obj.Parameter.IsMemberReference)
{
break;
}
}
if (variableNavTypeKind == NavTypeKind.Record)
{
break;
}
firstVarUsageSyntax.AddIdentifierIfNotExist(identifier);
break;
}
}
}
}
}
private SyntaxToken LexDirectiveToken()
{
_kind = SyntaxKind.BadToken;
_contextualKind = SyntaxKind.BadToken;
_diagnostics.Clear();
_start = _charReader.Position;
var trailingTrivia = new List <SyntaxNode>();
var isEndOfLine = false;
switch (_charReader.Current)
{
case '#':
NextChar();
if (_charReader.Current == '#')
{
NextChar();
_kind = SyntaxKind.HashHashToken;
}
else
{
_kind = SyntaxKind.HashToken;
_currentDirectiveKind = null;
}
break;
case '\r':
case '\n':
_kind = SyntaxKind.EndOfDirectiveToken;
_currentDirectiveKind = null;
isEndOfLine = true;
break;
case '\0':
_kind = SyntaxKind.EndOfDirectiveToken;
_currentDirectiveKind = null;
break;
case '<':
if (_currentDirectiveKind != SyntaxKind.IncludeKeyword)
{
goto default;
}
ReadBracketedString();
break;
default:
ReadToken();
if (_contextualKind.IsPreprocessorDirective())
{
_currentDirectiveKind = _contextualKind;
}
break;
}
var end = _charReader.Position;
var kind = _kind;
var span = TextSpan.FromBounds(Text.Filename, _start, end);
var text = Text.GetText(span);
var diagnostics = _diagnostics.ToImmutableArray();
LexDirectiveTrailingTrivia(trailingTrivia, kind, isEndOfLine);
var token = new SyntaxToken(kind, _contextualKind, false, MakeAbsolute(span), span, text, _value,
ImmutableArray <SyntaxNode> .Empty, trailingTrivia.ToImmutableArray(),
diagnostics, null, false);
return(token);
}
private static SyntaxTokenList TokenList(SyntaxKind?modifier)
{
return(modifier == null?Syntax.TokenList() : Syntax.TokenList(Syntax.Token(modifier.Value)));
}
