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

using Microsoft.CodeAnalysis.PooledObjects;

namespace Microsoft.CodeAnalysis.CSharp;

internal sealed class BinaryOperatorOverloadResolutionResult
{
	public readonly ArrayBuilder<BinaryOperatorAnalysisResult> Results;

	public static readonly ObjectPool<BinaryOperatorOverloadResolutionResult> Pool = CreatePool();

	public BinaryOperatorAnalysisResult Best
	{
		get
		{
			//IL_000e: 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)
			BinaryOperatorAnalysisResult result = default(BinaryOperatorAnalysisResult);
			Enumerator<BinaryOperatorAnalysisResult> enumerator = Results.GetEnumerator();
			while (enumerator.MoveNext())
			{
				BinaryOperatorAnalysisResult current = enumerator.Current;
				if (current.IsValid)
				{
					if (result.IsValid)
					{
						return default(BinaryOperatorAnalysisResult);
					}
					result = current;
				}
			}
			return result;
		}
	}

	private BinaryOperatorOverloadResolutionResult()
	{
		Results = new ArrayBuilder<BinaryOperatorAnalysisResult>(10);
	}

	public bool AnyValid()
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		Enumerator<BinaryOperatorAnalysisResult> enumerator = Results.GetEnumerator();
		while (enumerator.MoveNext())
		{
			if (enumerator.Current.IsValid)
			{
				return true;
			}
		}
		return false;
	}

	public bool SingleValid()
	{
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		bool flag = false;
		Enumerator<BinaryOperatorAnalysisResult> enumerator = Results.GetEnumerator();
		while (enumerator.MoveNext())
		{
			if (enumerator.Current.IsValid)
			{
				if (flag)
				{
					return false;
				}
				flag = true;
			}
		}
		return flag;
	}

	public static BinaryOperatorOverloadResolutionResult GetInstance()
	{
		return Pool.Allocate();
	}

	public void Free()
	{
		Clear();
		Pool.Free(this);
	}

	public void Clear()
	{
		Results.Clear();
	}

	private static ObjectPool<BinaryOperatorOverloadResolutionResult> CreatePool()
	{
		return new ObjectPool<BinaryOperatorOverloadResolutionResult>((Factory<BinaryOperatorOverloadResolutionResult>)(() => new BinaryOperatorOverloadResolutionResult()), 10, true);
	}
}