PURErat-crack-scode/decompiled/Libraries/microsoft.codeanalysis.csharp/Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax/SyntaxToken.cs

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