PURErat-crack-scode/decompiled/Libraries/microsoft.codeanalysis.csharp/Microsoft.CodeAnalysis.CSharp.Symbols/SourceEnumConstantSymbol.cs

using System.Collections.Generic;
using System.Threading;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Roslyn.Utilities;

namespace Microsoft.CodeAnalysis.CSharp.Symbols;

internal abstract class SourceEnumConstantSymbol : SourceFieldSymbolWithSyntaxReference
{
	private sealed class ZeroValuedEnumConstantSymbol : SourceEnumConstantSymbol
	{
		public ZeroValuedEnumConstantSymbol(SourceMemberContainerTypeSymbol containingEnum, EnumMemberDeclarationSyntax syntax, BindingDiagnosticBag diagnostics)
			: base(containingEnum, syntax, diagnostics)
		{
		}

		protected override ConstantValue MakeConstantValue(HashSet<SourceFieldSymbolWithSyntaxReference> dependencies, bool earlyDecodingWellKnownAttributes, BindingDiagnosticBag diagnostics)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return ConstantValue.Default(ContainingType.EnumUnderlyingType.SpecialType);
		}
	}

	private sealed class ExplicitValuedEnumConstantSymbol : SourceEnumConstantSymbol
	{
		public ExplicitValuedEnumConstantSymbol(SourceMemberContainerTypeSymbol containingEnum, EnumMemberDeclarationSyntax syntax, BindingDiagnosticBag diagnostics)
			: base(containingEnum, syntax, diagnostics)
		{
		}

		protected override ConstantValue MakeConstantValue(HashSet<SourceFieldSymbolWithSyntaxReference> dependencies, bool earlyDecodingWellKnownAttributes, BindingDiagnosticBag diagnostics)
		{
			EnumMemberDeclarationSyntax syntaxNode = base.SyntaxNode;
			return ConstantValueUtils.EvaluateFieldConstant(this, syntaxNode.EqualsValue, dependencies, earlyDecodingWellKnownAttributes, diagnostics);
		}
	}

	private sealed class ImplicitValuedEnumConstantSymbol : SourceEnumConstantSymbol
	{
		private readonly SourceEnumConstantSymbol _otherConstant;

		private readonly uint _otherConstantOffset;

		public ImplicitValuedEnumConstantSymbol(SourceMemberContainerTypeSymbol containingEnum, EnumMemberDeclarationSyntax syntax, SourceEnumConstantSymbol otherConstant, uint otherConstantOffset, BindingDiagnosticBag diagnostics)
			: base(containingEnum, syntax, diagnostics)
		{
			_otherConstant = otherConstant;
			_otherConstantOffset = otherConstantOffset;
		}

		protected override ConstantValue MakeConstantValue(HashSet<SourceFieldSymbolWithSyntaxReference> dependencies, bool earlyDecodingWellKnownAttributes, BindingDiagnosticBag diagnostics)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Invalid comparison between Unknown and I4
			ConstantValue constantValue = _otherConstant.GetConstantValue(new ConstantFieldsInProgress(this, dependencies), earlyDecodingWellKnownAttributes);
			if (constantValue == ConstantValue.Unset)
			{
				return ConstantValue.Unset;
			}
			if (constantValue.IsBad)
			{
				return ConstantValue.Bad;
			}
			ConstantValue result = default(ConstantValue);
			if ((int)EnumConstantHelper.OffsetValue(constantValue, _otherConstantOffset, ref result) == 1)
			{
				diagnostics.Add(ErrorCode.ERR_EnumeratorOverflow, GetFirstLocation(), this);
			}
			return result;
		}
	}

	public sealed override RefKind RefKind => (RefKind)0;

	public override Symbol AssociatedSymbol => null;

	protected sealed override DeclarationModifiers Modifiers => DeclarationModifiers.Static | DeclarationModifiers.Public | DeclarationModifiers.Const;

	public new EnumMemberDeclarationSyntax SyntaxNode => (EnumMemberDeclarationSyntax)base.SyntaxNode;

	protected override SyntaxList<AttributeListSyntax> AttributeDeclarationSyntaxList
	{
		get
		{
			//IL_001b: 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_0013: Unknown result type (might be due to invalid IL or missing references)
			if (containingType.AnyMemberHasAttributes)
			{
				return SyntaxNode.AttributeLists;
			}
			return default(SyntaxList<AttributeListSyntax>);
		}
	}

	public static SourceEnumConstantSymbol CreateExplicitValuedConstant(SourceMemberContainerTypeSymbol containingEnum, EnumMemberDeclarationSyntax syntax, BindingDiagnosticBag diagnostics)
	{
		return new ExplicitValuedEnumConstantSymbol(containingEnum, syntax, diagnostics);
	}

	public static SourceEnumConstantSymbol CreateImplicitValuedConstant(SourceMemberContainerTypeSymbol containingEnum, EnumMemberDeclarationSyntax syntax, SourceEnumConstantSymbol otherConstant, int otherConstantOffset, BindingDiagnosticBag diagnostics)
	{
		if ((object)otherConstant == null)
		{
			return new ZeroValuedEnumConstantSymbol(containingEnum, syntax, diagnostics);
		}
		return new ImplicitValuedEnumConstantSymbol(containingEnum, syntax, otherConstant, (uint)otherConstantOffset, diagnostics);
	}

	protected SourceEnumConstantSymbol(SourceMemberContainerTypeSymbol containingEnum, EnumMemberDeclarationSyntax syntax, BindingDiagnosticBag diagnostics)
	{
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		SyntaxToken identifier = syntax.Identifier;
		string valueText = ((SyntaxToken)(ref identifier)).ValueText;
		SyntaxReference reference = syntax.GetReference();
		identifier = syntax.Identifier;
		base._002Ector(containingEnum, valueText, reference, ((SyntaxToken)(ref identifier)).Span);
		if (Name == "value__")
		{
			diagnostics.Add(ErrorCode.ERR_ReservedEnumerator, ErrorLocation, "value__");
		}
	}

	internal override TypeWithAnnotations GetFieldType(ConsList<FieldSymbol> fieldsBeingBound)
	{
		return TypeWithAnnotations.Create(ContainingType);
	}

	internal sealed override void ForceComplete(SourceLocation locationOpt, CancellationToken cancellationToken)
	{
		while (true)
		{
			cancellationToken.ThrowIfCancellationRequested();
			CompletionPart nextIncompletePart = state.NextIncompletePart;
			switch (nextIncompletePart)
			{
			case CompletionPart.Attributes:
				GetAttributes();
				break;
			case CompletionPart.Type:
				state.NotePartComplete(CompletionPart.Type);
				break;
			case CompletionPart.Members:
				state.NotePartComplete(CompletionPart.Members);
				break;
			case CompletionPart.TypeMembers:
				GetConstantValue(ConstantFieldsInProgress.Empty, earlyDecodingWellKnownAttributes: false);
				break;
			case CompletionPart.None:
				return;
			default:
				state.NotePartComplete(CompletionPart.ImportsAll | CompletionPart.ReturnTypeAttributes | CompletionPart.Parameters | CompletionPart.StartInterfaces | CompletionPart.FinishInterfaces | CompletionPart.EnumUnderlyingType | CompletionPart.TypeArguments | CompletionPart.TypeParameters | CompletionPart.SynthesizedExplicitImplementations | CompletionPart.StartMemberChecks | CompletionPart.FinishMemberChecks | CompletionPart.MembersCompletedChecksStarted | CompletionPart.MembersCompleted);
				break;
			}
			state.SpinWaitComplete(nextIncompletePart, cancellationToken);
		}
	}
}