1088 lines
35 KiB
C#
1088 lines
35 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using Microsoft.CodeAnalysis.Syntax.InternalSyntax;
|
|
using Roslyn.Utilities;
|
|
|
|
namespace Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax;
|
|
|
|
internal class SyntaxToken : CSharpSyntaxNode
|
|
{
|
|
internal class MissingTokenWithTrivia : SyntaxTokenWithTrivia
|
|
{
|
|
public override string Text => string.Empty;
|
|
|
|
public override object Value
|
|
{
|
|
get
|
|
{
|
|
if (base.Kind == SyntaxKind.IdentifierToken)
|
|
{
|
|
return string.Empty;
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
|
|
internal MissingTokenWithTrivia(SyntaxKind kind, GreenNode leading, GreenNode trailing)
|
|
: base(kind, leading, trailing)
|
|
{
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
|
|
((GreenNode)this).flags = (NodeFlags)(((GreenNode)this).flags & 0xDF);
|
|
}
|
|
|
|
internal MissingTokenWithTrivia(SyntaxKind kind, GreenNode leading, GreenNode trailing, DiagnosticInfo[] diagnostics, SyntaxAnnotation[] annotations)
|
|
: base(kind, leading, trailing, diagnostics, annotations)
|
|
{
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
|
|
((GreenNode)this).flags = (NodeFlags)(((GreenNode)this).flags & 0xDF);
|
|
}
|
|
|
|
internal MissingTokenWithTrivia(ObjectReader reader)
|
|
: base(reader)
|
|
{
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
|
|
((GreenNode)this).flags = (NodeFlags)(((GreenNode)this).flags & 0xDF);
|
|
}
|
|
|
|
static MissingTokenWithTrivia()
|
|
{
|
|
ObjectBinder.RegisterTypeReader(typeof(MissingTokenWithTrivia), (Func<ObjectReader, IObjectWritable>)((ObjectReader r) => (IObjectWritable)(object)new MissingTokenWithTrivia(r)));
|
|
}
|
|
|
|
public override SyntaxToken TokenWithLeadingTrivia(GreenNode trivia)
|
|
{
|
|
return new MissingTokenWithTrivia(base.Kind, trivia, TrailingField, ((GreenNode)this).GetDiagnostics(), ((GreenNode)this).GetAnnotations());
|
|
}
|
|
|
|
public override SyntaxToken TokenWithTrailingTrivia(GreenNode trivia)
|
|
{
|
|
return new MissingTokenWithTrivia(base.Kind, LeadingField, trivia, ((GreenNode)this).GetDiagnostics(), ((GreenNode)this).GetAnnotations());
|
|
}
|
|
|
|
internal override GreenNode SetDiagnostics(DiagnosticInfo[] diagnostics)
|
|
{
|
|
return (GreenNode)(object)new MissingTokenWithTrivia(base.Kind, LeadingField, TrailingField, diagnostics, ((GreenNode)this).GetAnnotations());
|
|
}
|
|
|
|
internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations)
|
|
{
|
|
return (GreenNode)(object)new MissingTokenWithTrivia(base.Kind, LeadingField, TrailingField, ((GreenNode)this).GetDiagnostics(), annotations);
|
|
}
|
|
}
|
|
|
|
internal class SyntaxIdentifier : SyntaxToken
|
|
{
|
|
protected readonly string TextField;
|
|
|
|
public override string Text => TextField;
|
|
|
|
public override object Value => TextField;
|
|
|
|
public override string ValueText => TextField;
|
|
|
|
static SyntaxIdentifier()
|
|
{
|
|
ObjectBinder.RegisterTypeReader(typeof(SyntaxIdentifier), (Func<ObjectReader, IObjectWritable>)((ObjectReader r) => (IObjectWritable)(object)new SyntaxIdentifier(r)));
|
|
}
|
|
|
|
internal SyntaxIdentifier(string text)
|
|
: base(SyntaxKind.IdentifierToken, text.Length)
|
|
{
|
|
TextField = text;
|
|
}
|
|
|
|
internal SyntaxIdentifier(string text, DiagnosticInfo[] diagnostics, SyntaxAnnotation[] annotations)
|
|
: base(SyntaxKind.IdentifierToken, text.Length, diagnostics, annotations)
|
|
{
|
|
TextField = text;
|
|
}
|
|
|
|
internal SyntaxIdentifier(ObjectReader reader)
|
|
: base(reader)
|
|
{
|
|
TextField = reader.ReadString();
|
|
((GreenNode)this).FullWidth = TextField.Length;
|
|
}
|
|
|
|
internal override void WriteTo(ObjectWriter writer)
|
|
{
|
|
((GreenNode)this).WriteTo(writer);
|
|
writer.WriteString(TextField);
|
|
}
|
|
|
|
public override SyntaxToken TokenWithLeadingTrivia(GreenNode trivia)
|
|
{
|
|
return new SyntaxIdentifierWithTrivia(base.Kind, TextField, TextField, trivia, null, ((GreenNode)this).GetDiagnostics(), ((GreenNode)this).GetAnnotations());
|
|
}
|
|
|
|
public override SyntaxToken TokenWithTrailingTrivia(GreenNode trivia)
|
|
{
|
|
return new SyntaxIdentifierWithTrivia(base.Kind, TextField, TextField, null, trivia, ((GreenNode)this).GetDiagnostics(), ((GreenNode)this).GetAnnotations());
|
|
}
|
|
|
|
internal override GreenNode SetDiagnostics(DiagnosticInfo[] diagnostics)
|
|
{
|
|
return (GreenNode)(object)new SyntaxIdentifier(Text, diagnostics, ((GreenNode)this).GetAnnotations());
|
|
}
|
|
|
|
internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations)
|
|
{
|
|
return (GreenNode)(object)new SyntaxIdentifier(Text, ((GreenNode)this).GetDiagnostics(), annotations);
|
|
}
|
|
}
|
|
|
|
internal class SyntaxIdentifierExtended : SyntaxIdentifier
|
|
{
|
|
protected readonly SyntaxKind contextualKind;
|
|
|
|
protected readonly string valueText;
|
|
|
|
public override SyntaxKind ContextualKind => contextualKind;
|
|
|
|
public override string ValueText => valueText;
|
|
|
|
public override object Value => valueText;
|
|
|
|
internal SyntaxIdentifierExtended(SyntaxKind contextualKind, string text, string valueText)
|
|
: base(text)
|
|
{
|
|
this.contextualKind = contextualKind;
|
|
this.valueText = valueText;
|
|
}
|
|
|
|
internal SyntaxIdentifierExtended(SyntaxKind contextualKind, string text, string valueText, DiagnosticInfo[] diagnostics, SyntaxAnnotation[] annotations)
|
|
: base(text, diagnostics, annotations)
|
|
{
|
|
this.contextualKind = contextualKind;
|
|
this.valueText = valueText;
|
|
}
|
|
|
|
internal SyntaxIdentifierExtended(ObjectReader reader)
|
|
: base(reader)
|
|
{
|
|
contextualKind = (SyntaxKind)reader.ReadInt16();
|
|
valueText = reader.ReadString();
|
|
}
|
|
|
|
static SyntaxIdentifierExtended()
|
|
{
|
|
ObjectBinder.RegisterTypeReader(typeof(SyntaxIdentifierExtended), (Func<ObjectReader, IObjectWritable>)((ObjectReader r) => (IObjectWritable)(object)new SyntaxIdentifierExtended(r)));
|
|
}
|
|
|
|
internal override void WriteTo(ObjectWriter writer)
|
|
{
|
|
base.WriteTo(writer);
|
|
writer.WriteInt16((short)contextualKind);
|
|
writer.WriteString(valueText);
|
|
}
|
|
|
|
public override SyntaxToken TokenWithLeadingTrivia(GreenNode trivia)
|
|
{
|
|
return new SyntaxIdentifierWithTrivia(contextualKind, TextField, valueText, trivia, null, ((GreenNode)this).GetDiagnostics(), ((GreenNode)this).GetAnnotations());
|
|
}
|
|
|
|
public override SyntaxToken TokenWithTrailingTrivia(GreenNode trivia)
|
|
{
|
|
return new SyntaxIdentifierWithTrivia(contextualKind, TextField, valueText, null, trivia, ((GreenNode)this).GetDiagnostics(), ((GreenNode)this).GetAnnotations());
|
|
}
|
|
|
|
internal override GreenNode SetDiagnostics(DiagnosticInfo[] diagnostics)
|
|
{
|
|
return (GreenNode)(object)new SyntaxIdentifierExtended(contextualKind, TextField, valueText, diagnostics, ((GreenNode)this).GetAnnotations());
|
|
}
|
|
|
|
internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations)
|
|
{
|
|
return (GreenNode)(object)new SyntaxIdentifierExtended(contextualKind, TextField, valueText, ((GreenNode)this).GetDiagnostics(), annotations);
|
|
}
|
|
}
|
|
|
|
internal class SyntaxIdentifierWithTrailingTrivia : SyntaxIdentifier
|
|
{
|
|
private readonly GreenNode _trailing;
|
|
|
|
internal SyntaxIdentifierWithTrailingTrivia(string text, GreenNode trailing)
|
|
: base(text)
|
|
{
|
|
if (trailing != null)
|
|
{
|
|
((GreenNode)this).AdjustFlagsAndWidth(trailing);
|
|
_trailing = trailing;
|
|
}
|
|
}
|
|
|
|
internal SyntaxIdentifierWithTrailingTrivia(string text, GreenNode trailing, DiagnosticInfo[] diagnostics, SyntaxAnnotation[] annotations)
|
|
: base(text, diagnostics, annotations)
|
|
{
|
|
if (trailing != null)
|
|
{
|
|
((GreenNode)this).AdjustFlagsAndWidth(trailing);
|
|
_trailing = trailing;
|
|
}
|
|
}
|
|
|
|
internal SyntaxIdentifierWithTrailingTrivia(ObjectReader reader)
|
|
: base(reader)
|
|
{
|
|
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0013: Expected O, but got Unknown
|
|
GreenNode val = (GreenNode)reader.ReadValue();
|
|
if (val != null)
|
|
{
|
|
((GreenNode)this).AdjustFlagsAndWidth(val);
|
|
_trailing = val;
|
|
}
|
|
}
|
|
|
|
static SyntaxIdentifierWithTrailingTrivia()
|
|
{
|
|
ObjectBinder.RegisterTypeReader(typeof(SyntaxIdentifierWithTrailingTrivia), (Func<ObjectReader, IObjectWritable>)((ObjectReader r) => (IObjectWritable)(object)new SyntaxIdentifierWithTrailingTrivia(r)));
|
|
}
|
|
|
|
internal override void WriteTo(ObjectWriter writer)
|
|
{
|
|
base.WriteTo(writer);
|
|
writer.WriteValue((IObjectWritable)(object)_trailing);
|
|
}
|
|
|
|
public override GreenNode GetTrailingTrivia()
|
|
{
|
|
return _trailing;
|
|
}
|
|
|
|
public override SyntaxToken TokenWithLeadingTrivia(GreenNode trivia)
|
|
{
|
|
return new SyntaxIdentifierWithTrivia(base.Kind, TextField, TextField, trivia, _trailing, ((GreenNode)this).GetDiagnostics(), ((GreenNode)this).GetAnnotations());
|
|
}
|
|
|
|
public override SyntaxToken TokenWithTrailingTrivia(GreenNode trivia)
|
|
{
|
|
return new SyntaxIdentifierWithTrailingTrivia(TextField, trivia, ((GreenNode)this).GetDiagnostics(), ((GreenNode)this).GetAnnotations());
|
|
}
|
|
|
|
internal override GreenNode SetDiagnostics(DiagnosticInfo[] diagnostics)
|
|
{
|
|
return (GreenNode)(object)new SyntaxIdentifierWithTrailingTrivia(TextField, _trailing, diagnostics, ((GreenNode)this).GetAnnotations());
|
|
}
|
|
|
|
internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations)
|
|
{
|
|
return (GreenNode)(object)new SyntaxIdentifierWithTrailingTrivia(TextField, _trailing, ((GreenNode)this).GetDiagnostics(), annotations);
|
|
}
|
|
}
|
|
|
|
internal class SyntaxIdentifierWithTrivia : SyntaxIdentifierExtended
|
|
{
|
|
private readonly GreenNode _leading;
|
|
|
|
private readonly GreenNode _trailing;
|
|
|
|
internal SyntaxIdentifierWithTrivia(SyntaxKind contextualKind, string text, string valueText, GreenNode leading, GreenNode trailing)
|
|
: base(contextualKind, text, valueText)
|
|
{
|
|
if (leading != null)
|
|
{
|
|
((GreenNode)this).AdjustFlagsAndWidth(leading);
|
|
_leading = leading;
|
|
}
|
|
if (trailing != null)
|
|
{
|
|
((GreenNode)this).AdjustFlagsAndWidth(trailing);
|
|
_trailing = trailing;
|
|
}
|
|
}
|
|
|
|
internal SyntaxIdentifierWithTrivia(SyntaxKind contextualKind, string text, string valueText, GreenNode leading, GreenNode trailing, DiagnosticInfo[] diagnostics, SyntaxAnnotation[] annotations)
|
|
: base(contextualKind, text, valueText, diagnostics, annotations)
|
|
{
|
|
if (leading != null)
|
|
{
|
|
((GreenNode)this).AdjustFlagsAndWidth(leading);
|
|
_leading = leading;
|
|
}
|
|
if (trailing != null)
|
|
{
|
|
((GreenNode)this).AdjustFlagsAndWidth(trailing);
|
|
_trailing = trailing;
|
|
}
|
|
}
|
|
|
|
internal SyntaxIdentifierWithTrivia(ObjectReader reader)
|
|
: base(reader)
|
|
{
|
|
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0013: Expected O, but got Unknown
|
|
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0030: Expected O, but got Unknown
|
|
GreenNode val = (GreenNode)reader.ReadValue();
|
|
if (val != null)
|
|
{
|
|
((GreenNode)this).AdjustFlagsAndWidth(val);
|
|
_leading = val;
|
|
}
|
|
GreenNode val2 = (GreenNode)reader.ReadValue();
|
|
if (val2 != null)
|
|
{
|
|
_trailing = val2;
|
|
((GreenNode)this).AdjustFlagsAndWidth(val2);
|
|
}
|
|
}
|
|
|
|
static SyntaxIdentifierWithTrivia()
|
|
{
|
|
ObjectBinder.RegisterTypeReader(typeof(SyntaxIdentifierWithTrivia), (Func<ObjectReader, IObjectWritable>)((ObjectReader r) => (IObjectWritable)(object)new SyntaxIdentifierWithTrivia(r)));
|
|
}
|
|
|
|
internal override void WriteTo(ObjectWriter writer)
|
|
{
|
|
base.WriteTo(writer);
|
|
writer.WriteValue((IObjectWritable)(object)_leading);
|
|
writer.WriteValue((IObjectWritable)(object)_trailing);
|
|
}
|
|
|
|
public override GreenNode GetLeadingTrivia()
|
|
{
|
|
return _leading;
|
|
}
|
|
|
|
public override GreenNode GetTrailingTrivia()
|
|
{
|
|
return _trailing;
|
|
}
|
|
|
|
public override SyntaxToken TokenWithLeadingTrivia(GreenNode trivia)
|
|
{
|
|
return new SyntaxIdentifierWithTrivia(contextualKind, TextField, valueText, trivia, _trailing, ((GreenNode)this).GetDiagnostics(), ((GreenNode)this).GetAnnotations());
|
|
}
|
|
|
|
public override SyntaxToken TokenWithTrailingTrivia(GreenNode trivia)
|
|
{
|
|
return new SyntaxIdentifierWithTrivia(contextualKind, TextField, valueText, _leading, trivia, ((GreenNode)this).GetDiagnostics(), ((GreenNode)this).GetAnnotations());
|
|
}
|
|
|
|
internal override GreenNode SetDiagnostics(DiagnosticInfo[] diagnostics)
|
|
{
|
|
return (GreenNode)(object)new SyntaxIdentifierWithTrivia(contextualKind, TextField, valueText, _leading, _trailing, diagnostics, ((GreenNode)this).GetAnnotations());
|
|
}
|
|
|
|
internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations)
|
|
{
|
|
return (GreenNode)(object)new SyntaxIdentifierWithTrivia(contextualKind, TextField, valueText, _leading, _trailing, ((GreenNode)this).GetDiagnostics(), annotations);
|
|
}
|
|
}
|
|
|
|
internal class SyntaxTokenWithValue<T> : SyntaxToken
|
|
{
|
|
protected readonly string TextField;
|
|
|
|
protected readonly T ValueField;
|
|
|
|
public override string Text => TextField;
|
|
|
|
public override object Value => ValueField;
|
|
|
|
public override string ValueText => Convert.ToString(ValueField, CultureInfo.InvariantCulture);
|
|
|
|
internal SyntaxTokenWithValue(SyntaxKind kind, string text, T value)
|
|
: base(kind, text.Length)
|
|
{
|
|
TextField = text;
|
|
ValueField = value;
|
|
}
|
|
|
|
internal SyntaxTokenWithValue(SyntaxKind kind, string text, T value, DiagnosticInfo[] diagnostics, SyntaxAnnotation[] annotations)
|
|
: base(kind, text.Length, diagnostics, annotations)
|
|
{
|
|
TextField = text;
|
|
ValueField = value;
|
|
}
|
|
|
|
internal SyntaxTokenWithValue(ObjectReader reader)
|
|
: base(reader)
|
|
{
|
|
TextField = reader.ReadString();
|
|
((GreenNode)this).FullWidth = TextField.Length;
|
|
ValueField = (T)reader.ReadValue();
|
|
}
|
|
|
|
static SyntaxTokenWithValue()
|
|
{
|
|
ObjectBinder.RegisterTypeReader(typeof(SyntaxTokenWithValue<T>), (Func<ObjectReader, IObjectWritable>)((ObjectReader r) => (IObjectWritable)(object)new SyntaxTokenWithValue<T>(r)));
|
|
}
|
|
|
|
internal override void WriteTo(ObjectWriter writer)
|
|
{
|
|
((GreenNode)this).WriteTo(writer);
|
|
writer.WriteString(TextField);
|
|
writer.WriteValue((object)ValueField);
|
|
}
|
|
|
|
public override SyntaxToken TokenWithLeadingTrivia(GreenNode trivia)
|
|
{
|
|
return new SyntaxTokenWithValueAndTrivia<T>(base.Kind, TextField, ValueField, trivia, null, ((GreenNode)this).GetDiagnostics(), ((GreenNode)this).GetAnnotations());
|
|
}
|
|
|
|
public override SyntaxToken TokenWithTrailingTrivia(GreenNode trivia)
|
|
{
|
|
return new SyntaxTokenWithValueAndTrivia<T>(base.Kind, TextField, ValueField, null, trivia, ((GreenNode)this).GetDiagnostics(), ((GreenNode)this).GetAnnotations());
|
|
}
|
|
|
|
internal override GreenNode SetDiagnostics(DiagnosticInfo[] diagnostics)
|
|
{
|
|
return (GreenNode)(object)new SyntaxTokenWithValue<T>(base.Kind, TextField, ValueField, diagnostics, ((GreenNode)this).GetAnnotations());
|
|
}
|
|
|
|
internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations)
|
|
{
|
|
return (GreenNode)(object)new SyntaxTokenWithValue<T>(base.Kind, TextField, ValueField, ((GreenNode)this).GetDiagnostics(), annotations);
|
|
}
|
|
}
|
|
|
|
internal class SyntaxTokenWithValueAndTrivia<T> : SyntaxTokenWithValue<T>
|
|
{
|
|
private readonly GreenNode _leading;
|
|
|
|
private readonly GreenNode _trailing;
|
|
|
|
static SyntaxTokenWithValueAndTrivia()
|
|
{
|
|
ObjectBinder.RegisterTypeReader(typeof(SyntaxTokenWithValueAndTrivia<T>), (Func<ObjectReader, IObjectWritable>)((ObjectReader r) => (IObjectWritable)(object)new SyntaxTokenWithValueAndTrivia<T>(r)));
|
|
}
|
|
|
|
internal SyntaxTokenWithValueAndTrivia(SyntaxKind kind, string text, T value, GreenNode leading, GreenNode trailing)
|
|
: base(kind, text, value)
|
|
{
|
|
if (leading != null)
|
|
{
|
|
((GreenNode)this).AdjustFlagsAndWidth(leading);
|
|
_leading = leading;
|
|
}
|
|
if (trailing != null)
|
|
{
|
|
((GreenNode)this).AdjustFlagsAndWidth(trailing);
|
|
_trailing = trailing;
|
|
}
|
|
}
|
|
|
|
internal SyntaxTokenWithValueAndTrivia(SyntaxKind kind, string text, T value, GreenNode leading, GreenNode trailing, DiagnosticInfo[] diagnostics, SyntaxAnnotation[] annotations)
|
|
: base(kind, text, value, diagnostics, annotations)
|
|
{
|
|
if (leading != null)
|
|
{
|
|
((GreenNode)this).AdjustFlagsAndWidth(leading);
|
|
_leading = leading;
|
|
}
|
|
if (trailing != null)
|
|
{
|
|
((GreenNode)this).AdjustFlagsAndWidth(trailing);
|
|
_trailing = trailing;
|
|
}
|
|
}
|
|
|
|
internal SyntaxTokenWithValueAndTrivia(ObjectReader reader)
|
|
: base(reader)
|
|
{
|
|
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0013: Expected O, but got Unknown
|
|
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0030: Expected O, but got Unknown
|
|
GreenNode val = (GreenNode)reader.ReadValue();
|
|
if (val != null)
|
|
{
|
|
((GreenNode)this).AdjustFlagsAndWidth(val);
|
|
_leading = val;
|
|
}
|
|
GreenNode val2 = (GreenNode)reader.ReadValue();
|
|
if (val2 != null)
|
|
{
|
|
((GreenNode)this).AdjustFlagsAndWidth(val2);
|
|
_trailing = val2;
|
|
}
|
|
}
|
|
|
|
internal override void WriteTo(ObjectWriter writer)
|
|
{
|
|
base.WriteTo(writer);
|
|
writer.WriteValue((IObjectWritable)(object)_leading);
|
|
writer.WriteValue((IObjectWritable)(object)_trailing);
|
|
}
|
|
|
|
public override GreenNode GetLeadingTrivia()
|
|
{
|
|
return _leading;
|
|
}
|
|
|
|
public override GreenNode GetTrailingTrivia()
|
|
{
|
|
return _trailing;
|
|
}
|
|
|
|
public override SyntaxToken TokenWithLeadingTrivia(GreenNode trivia)
|
|
{
|
|
return new SyntaxTokenWithValueAndTrivia<T>(base.Kind, TextField, ValueField, trivia, _trailing, ((GreenNode)this).GetDiagnostics(), ((GreenNode)this).GetAnnotations());
|
|
}
|
|
|
|
public override SyntaxToken TokenWithTrailingTrivia(GreenNode trivia)
|
|
{
|
|
return new SyntaxTokenWithValueAndTrivia<T>(base.Kind, TextField, ValueField, _leading, trivia, ((GreenNode)this).GetDiagnostics(), ((GreenNode)this).GetAnnotations());
|
|
}
|
|
|
|
internal override GreenNode SetDiagnostics(DiagnosticInfo[] diagnostics)
|
|
{
|
|
return (GreenNode)(object)new SyntaxTokenWithValueAndTrivia<T>(base.Kind, TextField, ValueField, _leading, _trailing, diagnostics, ((GreenNode)this).GetAnnotations());
|
|
}
|
|
|
|
internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations)
|
|
{
|
|
return (GreenNode)(object)new SyntaxTokenWithValueAndTrivia<T>(base.Kind, TextField, ValueField, _leading, _trailing, ((GreenNode)this).GetDiagnostics(), annotations);
|
|
}
|
|
}
|
|
|
|
internal class SyntaxTokenWithTrivia : SyntaxToken
|
|
{
|
|
protected readonly GreenNode LeadingField;
|
|
|
|
protected readonly GreenNode TrailingField;
|
|
|
|
static SyntaxTokenWithTrivia()
|
|
{
|
|
ObjectBinder.RegisterTypeReader(typeof(SyntaxTokenWithTrivia), (Func<ObjectReader, IObjectWritable>)((ObjectReader r) => (IObjectWritable)(object)new SyntaxTokenWithTrivia(r)));
|
|
}
|
|
|
|
internal SyntaxTokenWithTrivia(SyntaxKind kind, GreenNode leading, GreenNode trailing)
|
|
: base(kind)
|
|
{
|
|
if (leading != null)
|
|
{
|
|
((GreenNode)this).AdjustFlagsAndWidth(leading);
|
|
LeadingField = leading;
|
|
}
|
|
if (trailing != null)
|
|
{
|
|
((GreenNode)this).AdjustFlagsAndWidth(trailing);
|
|
TrailingField = trailing;
|
|
}
|
|
}
|
|
|
|
internal SyntaxTokenWithTrivia(SyntaxKind kind, GreenNode leading, GreenNode trailing, DiagnosticInfo[] diagnostics, SyntaxAnnotation[] annotations)
|
|
: base(kind, diagnostics, annotations)
|
|
{
|
|
if (leading != null)
|
|
{
|
|
((GreenNode)this).AdjustFlagsAndWidth(leading);
|
|
LeadingField = leading;
|
|
}
|
|
if (trailing != null)
|
|
{
|
|
((GreenNode)this).AdjustFlagsAndWidth(trailing);
|
|
TrailingField = trailing;
|
|
}
|
|
}
|
|
|
|
internal SyntaxTokenWithTrivia(ObjectReader reader)
|
|
: base(reader)
|
|
{
|
|
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0013: Expected O, but got Unknown
|
|
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0030: Expected O, but got Unknown
|
|
GreenNode val = (GreenNode)reader.ReadValue();
|
|
if (val != null)
|
|
{
|
|
((GreenNode)this).AdjustFlagsAndWidth(val);
|
|
LeadingField = val;
|
|
}
|
|
GreenNode val2 = (GreenNode)reader.ReadValue();
|
|
if (val2 != null)
|
|
{
|
|
((GreenNode)this).AdjustFlagsAndWidth(val2);
|
|
TrailingField = val2;
|
|
}
|
|
}
|
|
|
|
internal override void WriteTo(ObjectWriter writer)
|
|
{
|
|
((GreenNode)this).WriteTo(writer);
|
|
writer.WriteValue((IObjectWritable)(object)LeadingField);
|
|
writer.WriteValue((IObjectWritable)(object)TrailingField);
|
|
}
|
|
|
|
public override GreenNode GetLeadingTrivia()
|
|
{
|
|
return LeadingField;
|
|
}
|
|
|
|
public override GreenNode GetTrailingTrivia()
|
|
{
|
|
return TrailingField;
|
|
}
|
|
|
|
public override SyntaxToken TokenWithLeadingTrivia(GreenNode trivia)
|
|
{
|
|
return new SyntaxTokenWithTrivia(base.Kind, trivia, TrailingField, ((GreenNode)this).GetDiagnostics(), ((GreenNode)this).GetAnnotations());
|
|
}
|
|
|
|
public override SyntaxToken TokenWithTrailingTrivia(GreenNode trivia)
|
|
{
|
|
return new SyntaxTokenWithTrivia(base.Kind, LeadingField, trivia, ((GreenNode)this).GetDiagnostics(), ((GreenNode)this).GetAnnotations());
|
|
}
|
|
|
|
internal override GreenNode SetDiagnostics(DiagnosticInfo[] diagnostics)
|
|
{
|
|
return (GreenNode)(object)new SyntaxTokenWithTrivia(base.Kind, LeadingField, TrailingField, diagnostics, ((GreenNode)this).GetAnnotations());
|
|
}
|
|
|
|
internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations)
|
|
{
|
|
return (GreenNode)(object)new SyntaxTokenWithTrivia(base.Kind, LeadingField, TrailingField, ((GreenNode)this).GetDiagnostics(), annotations);
|
|
}
|
|
}
|
|
|
|
internal const SyntaxKind FirstTokenWithWellKnownText = SyntaxKind.TildeToken;
|
|
|
|
internal const SyntaxKind LastTokenWithWellKnownText = SyntaxKind.EndOfFileToken;
|
|
|
|
private static readonly ArrayElement<SyntaxToken>[] s_tokensWithNoTrivia;
|
|
|
|
private static readonly ArrayElement<SyntaxToken>[] s_tokensWithElasticTrivia;
|
|
|
|
private static readonly ArrayElement<SyntaxToken>[] s_tokensWithSingleTrailingSpace;
|
|
|
|
private static readonly ArrayElement<SyntaxToken>[] s_tokensWithSingleTrailingCRLF;
|
|
|
|
internal override bool ShouldReuseInSerialization
|
|
{
|
|
get
|
|
{
|
|
if (((GreenNode)this).ShouldReuseInSerialization)
|
|
{
|
|
return ((GreenNode)this).FullWidth < 42;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public override bool IsToken => true;
|
|
|
|
public virtual SyntaxKind ContextualKind => base.Kind;
|
|
|
|
public override int RawContextualKind => (int)ContextualKind;
|
|
|
|
public virtual string Text => SyntaxFacts.GetText(base.Kind);
|
|
|
|
public virtual object Value => base.Kind switch
|
|
{
|
|
SyntaxKind.TrueKeyword => Boxes.BoxedTrue,
|
|
SyntaxKind.FalseKeyword => Boxes.BoxedFalse,
|
|
SyntaxKind.NullKeyword => null,
|
|
_ => Text,
|
|
};
|
|
|
|
public virtual string ValueText => Text;
|
|
|
|
public override int Width => Text.Length;
|
|
|
|
internal SyntaxList<CSharpSyntaxNode> LeadingTrivia => new SyntaxList<CSharpSyntaxNode>(GetLeadingTrivia());
|
|
|
|
internal SyntaxList<CSharpSyntaxNode> TrailingTrivia => new SyntaxList<CSharpSyntaxNode>(GetTrailingTrivia());
|
|
|
|
internal SyntaxToken(SyntaxKind kind)
|
|
: base(kind)
|
|
{
|
|
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
|
|
((GreenNode)this).FullWidth = Text.Length;
|
|
((GreenNode)this).flags = (NodeFlags)(((GreenNode)this).flags | 0x20);
|
|
}
|
|
|
|
internal SyntaxToken(SyntaxKind kind, DiagnosticInfo[] diagnostics)
|
|
: base(kind, diagnostics)
|
|
{
|
|
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
|
|
((GreenNode)this).FullWidth = Text.Length;
|
|
((GreenNode)this).flags = (NodeFlags)(((GreenNode)this).flags | 0x20);
|
|
}
|
|
|
|
internal SyntaxToken(SyntaxKind kind, DiagnosticInfo[] diagnostics, SyntaxAnnotation[] annotations)
|
|
: base(kind, diagnostics, annotations)
|
|
{
|
|
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
|
|
((GreenNode)this).FullWidth = Text.Length;
|
|
((GreenNode)this).flags = (NodeFlags)(((GreenNode)this).flags | 0x20);
|
|
}
|
|
|
|
internal SyntaxToken(SyntaxKind kind, int fullWidth)
|
|
: base(kind, fullWidth)
|
|
{
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
|
|
((GreenNode)this).flags = (NodeFlags)(((GreenNode)this).flags | 0x20);
|
|
}
|
|
|
|
internal SyntaxToken(SyntaxKind kind, int fullWidth, DiagnosticInfo[] diagnostics)
|
|
: base(kind, diagnostics, fullWidth)
|
|
{
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
|
((GreenNode)this).flags = (NodeFlags)(((GreenNode)this).flags | 0x20);
|
|
}
|
|
|
|
internal SyntaxToken(SyntaxKind kind, int fullWidth, DiagnosticInfo[] diagnostics, SyntaxAnnotation[] annotations)
|
|
: base(kind, diagnostics, annotations, fullWidth)
|
|
{
|
|
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
|
((GreenNode)this).flags = (NodeFlags)(((GreenNode)this).flags | 0x20);
|
|
}
|
|
|
|
internal SyntaxToken(ObjectReader reader)
|
|
: base(reader)
|
|
{
|
|
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
|
|
string text = Text;
|
|
if (text != null)
|
|
{
|
|
((GreenNode)this).FullWidth = text.Length;
|
|
}
|
|
((GreenNode)this).flags = (NodeFlags)(((GreenNode)this).flags | 0x20);
|
|
}
|
|
|
|
internal override GreenNode GetSlot(int index)
|
|
{
|
|
throw ExceptionUtilities.Unreachable("/_/src/Compilers/CSharp/Portable/Syntax/InternalSyntax/SyntaxToken.cs", 83);
|
|
}
|
|
|
|
internal static SyntaxToken Create(SyntaxKind kind)
|
|
{
|
|
if ((int)kind > 8496)
|
|
{
|
|
if (!SyntaxFacts.IsAnyToken(kind))
|
|
{
|
|
throw new ArgumentException(string.Format(CSharpResources.ThisMethodCanOnlyBeUsedToCreateTokens, kind), "kind");
|
|
}
|
|
return CreateMissing(kind, null, null);
|
|
}
|
|
return s_tokensWithNoTrivia[(uint)kind].Value;
|
|
}
|
|
|
|
internal static SyntaxToken Create(SyntaxKind kind, GreenNode leading, GreenNode trailing)
|
|
{
|
|
if ((int)kind > 8496)
|
|
{
|
|
if (!SyntaxFacts.IsAnyToken(kind))
|
|
{
|
|
throw new ArgumentException(string.Format(CSharpResources.ThisMethodCanOnlyBeUsedToCreateTokens, kind), "kind");
|
|
}
|
|
return CreateMissing(kind, leading, trailing);
|
|
}
|
|
if (leading == null)
|
|
{
|
|
if (trailing == null)
|
|
{
|
|
return s_tokensWithNoTrivia[(uint)kind].Value;
|
|
}
|
|
if ((object)trailing == SyntaxFactory.Space)
|
|
{
|
|
return s_tokensWithSingleTrailingSpace[(uint)kind].Value;
|
|
}
|
|
if ((object)trailing == SyntaxFactory.CarriageReturnLineFeed)
|
|
{
|
|
return s_tokensWithSingleTrailingCRLF[(uint)kind].Value;
|
|
}
|
|
}
|
|
if ((object)leading == SyntaxFactory.ElasticZeroSpace && (object)trailing == SyntaxFactory.ElasticZeroSpace)
|
|
{
|
|
return s_tokensWithElasticTrivia[(uint)kind].Value;
|
|
}
|
|
return new SyntaxTokenWithTrivia(kind, leading, trailing);
|
|
}
|
|
|
|
internal static SyntaxToken CreateMissing(SyntaxKind kind, GreenNode leading, GreenNode trailing)
|
|
{
|
|
return new MissingTokenWithTrivia(kind, leading, trailing);
|
|
}
|
|
|
|
static SyntaxToken()
|
|
{
|
|
s_tokensWithNoTrivia = new ArrayElement<SyntaxToken>[8497];
|
|
s_tokensWithElasticTrivia = new ArrayElement<SyntaxToken>[8497];
|
|
s_tokensWithSingleTrailingSpace = new ArrayElement<SyntaxToken>[8497];
|
|
s_tokensWithSingleTrailingCRLF = new ArrayElement<SyntaxToken>[8497];
|
|
ObjectBinder.RegisterTypeReader(typeof(SyntaxToken), (Func<ObjectReader, IObjectWritable>)((ObjectReader r) => (IObjectWritable)(object)new SyntaxToken(r)));
|
|
SyntaxKind syntaxKind = SyntaxKind.TildeToken;
|
|
while ((int)syntaxKind <= 8496)
|
|
{
|
|
s_tokensWithNoTrivia[(uint)syntaxKind].Value = new SyntaxToken(syntaxKind);
|
|
s_tokensWithElasticTrivia[(uint)syntaxKind].Value = new SyntaxTokenWithTrivia(syntaxKind, (GreenNode)(object)SyntaxFactory.ElasticZeroSpace, (GreenNode)(object)SyntaxFactory.ElasticZeroSpace);
|
|
s_tokensWithSingleTrailingSpace[(uint)syntaxKind].Value = new SyntaxTokenWithTrivia(syntaxKind, null, (GreenNode)(object)SyntaxFactory.Space);
|
|
s_tokensWithSingleTrailingCRLF[(uint)syntaxKind].Value = new SyntaxTokenWithTrivia(syntaxKind, null, (GreenNode)(object)SyntaxFactory.CarriageReturnLineFeed);
|
|
syntaxKind++;
|
|
}
|
|
}
|
|
|
|
internal static IEnumerable<SyntaxToken> GetWellKnownTokens()
|
|
{
|
|
ArrayElement<SyntaxToken>[] array = s_tokensWithNoTrivia;
|
|
for (int i = 0; i < array.Length; i++)
|
|
{
|
|
ArrayElement<SyntaxToken> val = array[i];
|
|
if (val.Value != null)
|
|
{
|
|
yield return val.Value;
|
|
}
|
|
}
|
|
array = s_tokensWithElasticTrivia;
|
|
for (int i = 0; i < array.Length; i++)
|
|
{
|
|
ArrayElement<SyntaxToken> val2 = array[i];
|
|
if (val2.Value != null)
|
|
{
|
|
yield return val2.Value;
|
|
}
|
|
}
|
|
array = s_tokensWithSingleTrailingSpace;
|
|
for (int i = 0; i < array.Length; i++)
|
|
{
|
|
ArrayElement<SyntaxToken> val3 = array[i];
|
|
if (val3.Value != null)
|
|
{
|
|
yield return val3.Value;
|
|
}
|
|
}
|
|
array = s_tokensWithSingleTrailingCRLF;
|
|
for (int i = 0; i < array.Length; i++)
|
|
{
|
|
ArrayElement<SyntaxToken> val4 = array[i];
|
|
if (val4.Value != null)
|
|
{
|
|
yield return val4.Value;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal static SyntaxToken Identifier(string text)
|
|
{
|
|
return new SyntaxIdentifier(text);
|
|
}
|
|
|
|
internal static SyntaxToken Identifier(GreenNode leading, string text, GreenNode trailing)
|
|
{
|
|
if (leading == null)
|
|
{
|
|
if (trailing == null)
|
|
{
|
|
return Identifier(text);
|
|
}
|
|
return new SyntaxIdentifierWithTrailingTrivia(text, trailing);
|
|
}
|
|
return new SyntaxIdentifierWithTrivia(SyntaxKind.IdentifierToken, text, text, leading, trailing);
|
|
}
|
|
|
|
internal static SyntaxToken Identifier(SyntaxKind contextualKind, GreenNode leading, string text, string valueText, GreenNode trailing)
|
|
{
|
|
if (contextualKind == SyntaxKind.IdentifierToken && valueText == text)
|
|
{
|
|
return Identifier(leading, text, trailing);
|
|
}
|
|
return new SyntaxIdentifierWithTrivia(contextualKind, text, valueText, leading, trailing);
|
|
}
|
|
|
|
internal static SyntaxToken WithValue<T>(SyntaxKind kind, string text, T value)
|
|
{
|
|
return new SyntaxTokenWithValue<T>(kind, text, value);
|
|
}
|
|
|
|
internal static SyntaxToken WithValue<T>(SyntaxKind kind, GreenNode leading, string text, T value, GreenNode trailing)
|
|
{
|
|
return new SyntaxTokenWithValueAndTrivia<T>(kind, text, value, leading, trailing);
|
|
}
|
|
|
|
internal static SyntaxToken StringLiteral(string text)
|
|
{
|
|
return new SyntaxTokenWithValue<string>(SyntaxKind.StringLiteralToken, text, text);
|
|
}
|
|
|
|
internal static SyntaxToken StringLiteral(CSharpSyntaxNode leading, string text, CSharpSyntaxNode trailing)
|
|
{
|
|
return new SyntaxTokenWithValueAndTrivia<string>(SyntaxKind.StringLiteralToken, text, text, (GreenNode)(object)leading, (GreenNode)(object)trailing);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return Text;
|
|
}
|
|
|
|
public override object GetValue()
|
|
{
|
|
return Value;
|
|
}
|
|
|
|
public override string GetValueText()
|
|
{
|
|
return ValueText;
|
|
}
|
|
|
|
public override int GetLeadingTriviaWidth()
|
|
{
|
|
GreenNode leadingTrivia = GetLeadingTrivia();
|
|
if (leadingTrivia == null)
|
|
{
|
|
return 0;
|
|
}
|
|
return leadingTrivia.FullWidth;
|
|
}
|
|
|
|
public override int GetTrailingTriviaWidth()
|
|
{
|
|
GreenNode trailingTrivia = GetTrailingTrivia();
|
|
if (trailingTrivia == null)
|
|
{
|
|
return 0;
|
|
}
|
|
return trailingTrivia.FullWidth;
|
|
}
|
|
|
|
public sealed override GreenNode WithLeadingTrivia(GreenNode trivia)
|
|
{
|
|
return (GreenNode)(object)TokenWithLeadingTrivia(trivia);
|
|
}
|
|
|
|
public virtual SyntaxToken TokenWithLeadingTrivia(GreenNode trivia)
|
|
{
|
|
return new SyntaxTokenWithTrivia(base.Kind, trivia, null, ((GreenNode)this).GetDiagnostics(), ((GreenNode)this).GetAnnotations());
|
|
}
|
|
|
|
public sealed override GreenNode WithTrailingTrivia(GreenNode trivia)
|
|
{
|
|
return (GreenNode)(object)TokenWithTrailingTrivia(trivia);
|
|
}
|
|
|
|
public virtual SyntaxToken TokenWithTrailingTrivia(GreenNode trivia)
|
|
{
|
|
return new SyntaxTokenWithTrivia(base.Kind, null, trivia, ((GreenNode)this).GetDiagnostics(), ((GreenNode)this).GetAnnotations());
|
|
}
|
|
|
|
internal override GreenNode SetDiagnostics(DiagnosticInfo[] diagnostics)
|
|
{
|
|
return (GreenNode)(object)new SyntaxToken(base.Kind, ((GreenNode)this).FullWidth, diagnostics, ((GreenNode)this).GetAnnotations());
|
|
}
|
|
|
|
internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations)
|
|
{
|
|
return (GreenNode)(object)new SyntaxToken(base.Kind, ((GreenNode)this).FullWidth, ((GreenNode)this).GetDiagnostics(), annotations);
|
|
}
|
|
|
|
internal override DirectiveStack ApplyDirectives(DirectiveStack stack)
|
|
{
|
|
if (((GreenNode)this).ContainsDirectives)
|
|
{
|
|
stack = ApplyDirectivesToTrivia(GetLeadingTrivia(), stack);
|
|
stack = ApplyDirectivesToTrivia(GetTrailingTrivia(), stack);
|
|
}
|
|
return stack;
|
|
}
|
|
|
|
private static DirectiveStack ApplyDirectivesToTrivia(GreenNode triviaList, DirectiveStack stack)
|
|
{
|
|
if (triviaList != null && triviaList.ContainsDirectives)
|
|
{
|
|
return CSharpSyntaxNode.ApplyDirectivesToListOrNode(triviaList, stack);
|
|
}
|
|
return stack;
|
|
}
|
|
|
|
public override TResult Accept<TResult>(CSharpSyntaxVisitor<TResult> visitor)
|
|
{
|
|
return visitor.VisitToken(this);
|
|
}
|
|
|
|
public override void Accept(CSharpSyntaxVisitor visitor)
|
|
{
|
|
visitor.VisitToken(this);
|
|
}
|
|
|
|
protected override void WriteTokenTo(TextWriter writer, bool leading, bool trailing)
|
|
{
|
|
if (leading)
|
|
{
|
|
GreenNode leadingTrivia = GetLeadingTrivia();
|
|
if (leadingTrivia != null)
|
|
{
|
|
leadingTrivia.WriteTo(writer, true, true);
|
|
}
|
|
}
|
|
writer.Write(Text);
|
|
if (trailing)
|
|
{
|
|
GreenNode trailingTrivia = GetTrailingTrivia();
|
|
if (trailingTrivia != null)
|
|
{
|
|
trailingTrivia.WriteTo(writer, true, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
public override bool IsEquivalentTo(GreenNode other)
|
|
{
|
|
if (!((GreenNode)this).IsEquivalentTo(other))
|
|
{
|
|
return false;
|
|
}
|
|
SyntaxToken syntaxToken = (SyntaxToken)(object)other;
|
|
if (Text != syntaxToken.Text)
|
|
{
|
|
return false;
|
|
}
|
|
GreenNode leadingTrivia = GetLeadingTrivia();
|
|
GreenNode leadingTrivia2 = syntaxToken.GetLeadingTrivia();
|
|
if (leadingTrivia != leadingTrivia2)
|
|
{
|
|
if (leadingTrivia == null || leadingTrivia2 == null)
|
|
{
|
|
return false;
|
|
}
|
|
if (!leadingTrivia.IsEquivalentTo(leadingTrivia2))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
GreenNode trailingTrivia = GetTrailingTrivia();
|
|
GreenNode trailingTrivia2 = syntaxToken.GetTrailingTrivia();
|
|
if (trailingTrivia != trailingTrivia2)
|
|
{
|
|
if (trailingTrivia == null || trailingTrivia2 == null)
|
|
{
|
|
return false;
|
|
}
|
|
if (!trailingTrivia.IsEquivalentTo(trailingTrivia2))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
internal override SyntaxNode CreateRed(SyntaxNode parent, int position)
|
|
{
|
|
throw ExceptionUtilities.Unreachable("/_/src/Compilers/CSharp/Portable/Syntax/InternalSyntax/SyntaxToken.cs", 477);
|
|
}
|
|
}
|