using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Diagnostics.CodeAnalysis;
using Microsoft.Cci;
using Microsoft.CodeAnalysis.CSharp.Symbols;
using Microsoft.CodeAnalysis.PooledObjects;
using Roslyn.Utilities;

namespace Microsoft.CodeAnalysis.CSharp;

internal sealed class RefSafetyAnalysis : BoundTreeWalkerWithStackGuardWithoutRecursionOnTheLeftOfBinaryOperator
{
	private enum EscapeLevel : uint
	{
		CallingMethod,
		ReturnOnly
	}

	private readonly struct MixableDestination
	{
		internal BoundExpression Argument { get; }

		internal ParameterSymbol? Parameter { get; }

		internal EscapeLevel EscapeLevel { get; }

		internal MixableDestination(ParameterSymbol parameter, BoundExpression argument)
		{
			Argument = argument;
			Parameter = parameter;
			EscapeLevel = GetParameterValEscapeLevel(parameter).Value;
		}

		internal MixableDestination(BoundExpression argument, EscapeLevel escapeLevel)
		{
			Argument = argument;
			Parameter = null;
			EscapeLevel = escapeLevel;
		}

		internal bool IsAssignableFrom(EscapeLevel level)
		{
			return EscapeLevel switch
			{
				EscapeLevel.CallingMethod => level == EscapeLevel.CallingMethod, 
				EscapeLevel.ReturnOnly => true, 
				_ => throw ExceptionUtilities.UnexpectedValue((object)EscapeLevel), 
			};
		}

		public override string? ToString()
		{
			return (Parameter, Argument, EscapeLevel).ToString();
		}
	}

	private readonly struct EscapeArgument
	{
		internal ParameterSymbol? Parameter { get; }

		internal BoundExpression Argument { get; }

		internal RefKind RefKind { get; }

		internal EscapeArgument(ParameterSymbol? parameter, BoundExpression argument, RefKind refKind, bool isArgList = false)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			Argument = argument;
			Parameter = parameter;
			RefKind = refKind;
		}

		public void Deconstruct(out ParameterSymbol? parameter, out BoundExpression argument, out RefKind refKind)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected I4, but got Unknown
			parameter = Parameter;
			argument = Argument;
			refKind = (RefKind)(int)RefKind;
		}

		public override string? ToString()
		{
			ParameterSymbol parameter = Parameter;
			if ((object)parameter == null)
			{
				return Argument.ToString();
			}
			return parameter.ToString();
		}
	}

	private readonly struct EscapeValue
	{
		internal ParameterSymbol? Parameter { get; }

		internal BoundExpression Argument { get; }

		internal EscapeLevel EscapeLevel { get; }

		internal bool IsRefEscape { get; }

		internal EscapeValue(ParameterSymbol? parameter, BoundExpression argument, EscapeLevel escapeLevel, bool isRefEscape)
		{
			Argument = argument;
			Parameter = parameter;
			EscapeLevel = escapeLevel;
			IsRefEscape = isRefEscape;
		}

		public void Deconstruct(out ParameterSymbol? parameter, out BoundExpression argument, out EscapeLevel escapeLevel, out bool isRefEscape)
		{
			parameter = Parameter;
			argument = Argument;
			escapeLevel = EscapeLevel;
			isRefEscape = IsRefEscape;
		}

		public override string? ToString()
		{
			ParameterSymbol parameter = Parameter;
			if ((object)parameter == null)
			{
				return Argument.ToString();
			}
			return parameter.ToString();
		}
	}

	private ref struct LocalScope
	{
		private readonly RefSafetyAnalysis _analysis;

		private readonly ImmutableArray<LocalSymbol> _locals;

		public LocalScope(RefSafetyAnalysis analysis, ImmutableArray<LocalSymbol> locals)
		{
			_analysis = analysis;
			_locals = locals;
			_analysis._localScopeDepth++;
			ImmutableArray<LocalSymbol>.Enumerator enumerator = locals.GetEnumerator();
			while (enumerator.MoveNext())
			{
				LocalSymbol current = enumerator.Current;
				_analysis.AddLocalScopes(current, _analysis._localScopeDepth, 0u);
			}
		}

		public void Dispose()
		{
			ImmutableArray<LocalSymbol>.Enumerator enumerator = _locals.GetEnumerator();
			while (enumerator.MoveNext())
			{
				LocalSymbol current = enumerator.Current;
				_analysis.RemoveLocalScopes(current);
			}
			_analysis._localScopeDepth--;
		}
	}

	private ref struct UnsafeRegion
	{
		private readonly RefSafetyAnalysis _analysis;

		private readonly bool _previousRegion;

		public UnsafeRegion(RefSafetyAnalysis analysis, bool inUnsafeRegion)
		{
			_analysis = analysis;
			_previousRegion = analysis._inUnsafeRegion;
			_analysis._inUnsafeRegion = inUnsafeRegion;
		}

		public void Dispose()
		{
			_analysis._inUnsafeRegion = _previousRegion;
		}
	}

	private ref struct PatternInput
	{
		private readonly RefSafetyAnalysis _analysis;

		private readonly uint _previousInputValEscape;

		public PatternInput(RefSafetyAnalysis analysis, uint patternInputValEscape)
		{
			_analysis = analysis;
			_previousInputValEscape = analysis._patternInputValEscape;
			_analysis._patternInputValEscape = patternInputValEscape;
		}

		public void Dispose()
		{
			_analysis._patternInputValEscape = _previousInputValEscape;
		}
	}

	private ref struct PlaceholderRegion
	{
		private readonly RefSafetyAnalysis _analysis;

		private readonly ArrayBuilder<(BoundValuePlaceholderBase, uint)> _placeholders;

		public PlaceholderRegion(RefSafetyAnalysis analysis, ArrayBuilder<(BoundValuePlaceholderBase, uint)> placeholders)
		{
			//IL_000f: 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)
			_analysis = analysis;
			_placeholders = placeholders;
			Enumerator<(BoundValuePlaceholderBase, uint)> enumerator = placeholders.GetEnumerator();
			while (enumerator.MoveNext())
			{
				var (placeholder, valEscapeScope) = enumerator.Current;
				_analysis.AddPlaceholderScope(placeholder, valEscapeScope);
			}
		}

		public void Dispose()
		{
			//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<(BoundValuePlaceholderBase, uint)> enumerator = _placeholders.GetEnumerator();
			while (enumerator.MoveNext())
			{
				BoundValuePlaceholderBase item = enumerator.Current.Item1;
				_analysis.RemovePlaceholderScope(item);
			}
			_placeholders.Free();
		}
	}

	private readonly struct DeconstructionVariable
	{
		internal readonly BoundExpression Expression;

		internal readonly uint ValEscape;

		internal readonly ArrayBuilder<DeconstructionVariable>? NestedVariables;

		internal DeconstructionVariable(BoundExpression expression, uint valEscape, ArrayBuilder<DeconstructionVariable>? nestedVariables)
		{
			Expression = expression;
			ValEscape = valEscape;
			NestedVariables = nestedVariables;
		}
	}

	private const uint CallingMethodScope = 0u;

	private const uint ReturnOnlyScope = 1u;

	private const uint CurrentMethodScope = 2u;

	private readonly CSharpCompilation _compilation;

	private readonly MethodSymbol _symbol;

	private readonly bool _useUpdatedEscapeRules;

	private readonly BindingDiagnosticBag _diagnostics;

	private bool _inUnsafeRegion;

	private uint _localScopeDepth;

	private Dictionary<LocalSymbol, (uint RefEscapeScope, uint ValEscapeScope)>? _localEscapeScopes;

	private Dictionary<BoundValuePlaceholderBase, uint>? _placeholderScopes;

	private uint _patternInputValEscape;

	private bool CheckLocalRefEscape(SyntaxNode node, BoundLocal local, uint escapeTo, bool checkingReceiver, BindingDiagnosticBag diagnostics)
	{
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_007a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		LocalSymbol localSymbol = local.LocalSymbol;
		if (GetLocalScopes(localSymbol).RefEscapeScope <= escapeTo)
		{
			return true;
		}
		bool inUnsafeRegion = _inUnsafeRegion;
		if (escapeTo <= 1)
		{
			if ((int)localSymbol.RefKind == 0)
			{
				if (checkingReceiver)
				{
					Error(diagnostics, inUnsafeRegion ? ErrorCode.WRN_RefReturnLocal2 : ErrorCode.ERR_RefReturnLocal2, SyntaxNodeOrToken.op_Implicit(local.Syntax), localSymbol);
				}
				else
				{
					Error(diagnostics, inUnsafeRegion ? ErrorCode.WRN_RefReturnLocal : ErrorCode.ERR_RefReturnLocal, SyntaxNodeOrToken.op_Implicit(node), localSymbol);
				}
				return inUnsafeRegion;
			}
			if (checkingReceiver)
			{
				Error(diagnostics, inUnsafeRegion ? ErrorCode.WRN_RefReturnNonreturnableLocal2 : ErrorCode.ERR_RefReturnNonreturnableLocal2, SyntaxNodeOrToken.op_Implicit(local.Syntax), localSymbol);
			}
			else
			{
				Error(diagnostics, inUnsafeRegion ? ErrorCode.WRN_RefReturnNonreturnableLocal : ErrorCode.ERR_RefReturnNonreturnableLocal, SyntaxNodeOrToken.op_Implicit(node), localSymbol);
			}
			return inUnsafeRegion;
		}
		Error(diagnostics, inUnsafeRegion ? ErrorCode.WRN_EscapeVariable : ErrorCode.ERR_EscapeVariable, SyntaxNodeOrToken.op_Implicit(node), localSymbol);
		return inUnsafeRegion;
	}

	private static EscapeLevel? EscapeLevelFromScope(uint scope)
	{
		return scope switch
		{
			1u => EscapeLevel.ReturnOnly, 
			0u => EscapeLevel.CallingMethod, 
			_ => null, 
		};
	}

	private static uint GetParameterValEscape(ParameterSymbol parameter)
	{
		//IL_0004: Unknown result type (might be due to invalid IL or missing references)
		//IL_000a: Invalid comparison between Unknown and I4
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Invalid comparison between Unknown and I4
		if ((object)parameter != null)
		{
			if ((int)parameter.EffectiveScope == 2)
			{
				return 2u;
			}
			if ((int)parameter.RefKind == 2 && parameter.UseUpdatedEscapeRules)
			{
				return 1u;
			}
		}
		return 0u;
	}

	private static EscapeLevel? GetParameterValEscapeLevel(ParameterSymbol parameter)
	{
		return EscapeLevelFromScope(GetParameterValEscape(parameter));
	}

	private static uint GetParameterRefEscape(ParameterSymbol parameter)
	{
		//IL_0004: Unknown result type (might be due to invalid IL or missing references)
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Invalid comparison between Unknown and I4
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: Invalid comparison between Unknown and I4
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Invalid comparison between Unknown and I4
		if ((object)parameter != null)
		{
			RefKind refKind = parameter.RefKind;
			if ((int)refKind == 0)
			{
				return 2u;
			}
			if ((int)parameter.EffectiveScope == 1)
			{
				return 2u;
			}
			if (parameter.HasUnscopedRefAttribute)
			{
				if ((int)refKind == 2)
				{
					return 1u;
				}
				if (!parameter.IsThis)
				{
					return 0u;
				}
			}
		}
		return 1u;
	}

	private static EscapeLevel? GetParameterRefEscapeLevel(ParameterSymbol parameter)
	{
		return EscapeLevelFromScope(GetParameterRefEscape(parameter));
	}

	private bool CheckParameterValEscape(SyntaxNode node, ParameterSymbol parameter, uint escapeTo, BindingDiagnosticBag diagnostics)
	{
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		if (_useUpdatedEscapeRules)
		{
			if (GetParameterValEscape(parameter) > escapeTo)
			{
				Error(diagnostics, _inUnsafeRegion ? ErrorCode.WRN_EscapeVariable : ErrorCode.ERR_EscapeVariable, SyntaxNodeOrToken.op_Implicit(node), parameter);
				return _inUnsafeRegion;
			}
			return true;
		}
		return true;
	}

	private bool CheckParameterRefEscape(SyntaxNode node, BoundExpression parameter, ParameterSymbol parameterSymbol, uint escapeTo, bool checkingReceiver, BindingDiagnosticBag diagnostics)
	{
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Invalid comparison between Unknown and I4
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0186: Unknown result type (might be due to invalid IL or missing references)
		uint parameterRefEscape = GetParameterRefEscape(parameterSymbol);
		if (parameterRefEscape > escapeTo)
		{
			bool flag = (int)parameterSymbol.EffectiveScope == 1;
			bool inUnsafeRegion = _inUnsafeRegion;
			if (parameter is BoundThisReference)
			{
				Error(diagnostics, inUnsafeRegion ? ErrorCode.WRN_RefReturnStructThis : ErrorCode.ERR_RefReturnStructThis, SyntaxNodeOrToken.op_Implicit(node));
				return inUnsafeRegion;
			}
			var (code, val) = (checkingReceiver ? (flag ? (inUnsafeRegion ? (ErrorCode.WRN_RefReturnScopedParameter2, parameter.Syntax) : (ErrorCode.ERR_RefReturnScopedParameter2, parameter.Syntax)) : ((!inUnsafeRegion) ? ((parameterRefEscape != 1) ? (ErrorCode.ERR_RefReturnParameter2, parameter.Syntax) : (ErrorCode.ERR_RefReturnOnlyParameter2, parameter.Syntax)) : ((parameterRefEscape != 1) ? (ErrorCode.WRN_RefReturnParameter2, parameter.Syntax) : (ErrorCode.WRN_RefReturnOnlyParameter2, parameter.Syntax)))) : (flag ? (inUnsafeRegion ? (ErrorCode.WRN_RefReturnScopedParameter, node) : (ErrorCode.ERR_RefReturnScopedParameter, node)) : ((!inUnsafeRegion) ? ((parameterRefEscape != 1) ? (ErrorCode.ERR_RefReturnParameter, node) : (ErrorCode.ERR_RefReturnOnlyParameter, node)) : ((parameterRefEscape != 1) ? (ErrorCode.WRN_RefReturnParameter, node) : (ErrorCode.WRN_RefReturnOnlyParameter, node)))));
			Error(diagnostics, code, SyntaxNodeOrToken.op_Implicit(val), parameterSymbol.Name);
			return inUnsafeRegion;
		}
		return true;
	}

	private uint GetFieldRefEscape(BoundFieldAccess fieldAccess, uint scopeOfTheContainingExpression)
	{
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		FieldSymbol fieldSymbol = fieldAccess.FieldSymbol;
		if (fieldSymbol.IsStatic || fieldSymbol.ContainingType.IsReferenceType)
		{
			return 0u;
		}
		if (_useUpdatedEscapeRules && (int)fieldSymbol.RefKind != 0)
		{
			return GetValEscape(fieldAccess.ReceiverOpt, scopeOfTheContainingExpression);
		}
		return GetRefEscape(fieldAccess.ReceiverOpt, scopeOfTheContainingExpression);
	}

	private bool CheckFieldRefEscape(SyntaxNode node, BoundFieldAccess fieldAccess, uint escapeFrom, uint escapeTo, BindingDiagnosticBag diagnostics)
	{
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		FieldSymbol fieldSymbol = fieldAccess.FieldSymbol;
		if (fieldSymbol.IsStatic || fieldSymbol.ContainingType.IsReferenceType)
		{
			return true;
		}
		if (_useUpdatedEscapeRules && (int)fieldSymbol.RefKind != 0)
		{
			return CheckValEscape(node, fieldAccess.ReceiverOpt, escapeFrom, escapeTo, checkingReceiver: true, diagnostics);
		}
		return CheckRefEscape(node, fieldAccess.ReceiverOpt, escapeFrom, escapeTo, checkingReceiver: true, diagnostics);
	}

	private bool CheckFieldLikeEventRefEscape(SyntaxNode node, BoundEventAccess eventAccess, uint escapeFrom, uint escapeTo, BindingDiagnosticBag diagnostics)
	{
		EventSymbol eventSymbol = eventAccess.EventSymbol;
		if (eventSymbol.IsStatic || eventSymbol.ContainingType.IsReferenceType)
		{
			return true;
		}
		return CheckRefEscape(node, eventAccess.ReceiverOpt, escapeFrom, escapeTo, checkingReceiver: true, diagnostics);
	}

	internal uint GetInterpolatedStringHandlerConversionEscapeScope(BoundExpression expression, uint scopeOfTheContainingExpression)
	{
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		uint num = GetValEscape(expression.GetInterpolatedStringHandlerData().Construction, scopeOfTheContainingExpression);
		ArrayBuilder<BoundExpression> instance = ArrayBuilder<BoundExpression>.GetInstance();
		GetInterpolatedStringHandlerArgumentsForEscape(expression, instance);
		Enumerator<BoundExpression> enumerator = instance.GetEnumerator();
		while (enumerator.MoveNext())
		{
			BoundExpression current = enumerator.Current;
			uint valEscape = GetValEscape(current, scopeOfTheContainingExpression);
			num = Math.Max(num, valEscape);
		}
		instance.Free();
		return num;
	}

	private uint GetInvocationEscapeScope(Symbol symbol, BoundExpression? receiver, ThreeState receiverIsSubjectToCloning, ImmutableArray<ParameterSymbol> parameters, ImmutableArray<BoundExpression> argsOpt, ImmutableArray<RefKind> argRefKindsOpt, ImmutableArray<int> argsToParamsOpt, uint scopeOfTheContainingExpression, bool isRefEscape)
	{
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006b: Invalid comparison between Unknown and I4
		if (UseUpdatedEscapeRulesForInvocation(symbol))
		{
			return GetInvocationEscapeWithUpdatedRules(symbol, receiver, receiverIsSubjectToCloning, parameters, argsOpt, argRefKindsOpt, argsToParamsOpt, scopeOfTheContainingExpression, isRefEscape);
		}
		if (!symbol.RequiresInstanceReceiver())
		{
			receiver = null;
		}
		uint num = 0u;
		ArrayBuilder<EscapeArgument> instance = ArrayBuilder<EscapeArgument>.GetInstance();
		GetInvocationArgumentsForEscape(symbol, null, (ThreeState)0, parameters, argsOpt, argRefKindsOpt, argsToParamsOpt, ignoreArglistRefKinds: true, null, instance);
		try
		{
			Enumerator<EscapeArgument> enumerator = instance.GetEnumerator();
			while (enumerator.MoveNext())
			{
				enumerator.Current.Deconstruct(out ParameterSymbol _, out BoundExpression argument, out RefKind refKind);
				BoundExpression expr = argument;
				uint val = (((int)refKind > 0 && isRefEscape) ? GetRefEscape(expr, scopeOfTheContainingExpression) : GetValEscape(expr, scopeOfTheContainingExpression));
				num = Math.Max(num, val);
				if (num >= scopeOfTheContainingExpression)
				{
					return num;
				}
			}
		}
		finally
		{
			instance.Free();
		}
		if (receiver != null && receiver.Type?.IsRefLikeType == true)
		{
			num = Math.Max(num, GetValEscape(receiver, scopeOfTheContainingExpression));
		}
		return num;
	}

	private uint GetInvocationEscapeWithUpdatedRules(Symbol symbol, BoundExpression? receiver, ThreeState receiverIsSubjectToCloning, ImmutableArray<ParameterSymbol> parameters, ImmutableArray<BoundExpression> argsOpt, ImmutableArray<RefKind> argRefKindsOpt, ImmutableArray<int> argsToParamsOpt, uint scopeOfTheContainingExpression, bool isRefEscape)
	{
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: Invalid comparison between Unknown and I4
		uint num = 0u;
		ArrayBuilder<EscapeValue> instance = ArrayBuilder<EscapeValue>.GetInstance();
		GetFilteredInvocationArgumentsForEscapeWithUpdatedRules(symbol, receiver, receiverIsSubjectToCloning, parameters, argsOpt, argRefKindsOpt, argsToParamsOpt, isRefEscape, ignoreArglistRefKinds: true, instance);
		bool flag = ReturnsRefToRefStruct(symbol);
		Enumerator<EscapeValue> enumerator = instance.GetEnumerator();
		while (enumerator.MoveNext())
		{
			enumerator.Current.Deconstruct(out ParameterSymbol parameter, out BoundExpression argument, out EscapeLevel _, out bool isRefEscape2);
			ParameterSymbol parameterSymbol = parameter;
			BoundExpression expr = argument;
			bool flag2 = isRefEscape2;
			isRefEscape2 = !flag;
			bool flag3;
			if (!isRefEscape2)
			{
				if ((object)parameterSymbol == null)
				{
					goto IL_0082;
				}
				if ((int)parameterSymbol.RefKind != 0)
				{
					TypeSymbol type = parameterSymbol.Type;
					if ((object)type != null && type.IsRefLikeType)
					{
						goto IL_0082;
					}
				}
				flag3 = false;
				goto IL_008a;
			}
			goto IL_0099;
			IL_008a:
			isRefEscape2 = flag3 && flag2 == isRefEscape;
			goto IL_0099;
			IL_0099:
			if (isRefEscape2)
			{
				uint val = (flag2 ? GetRefEscape(expr, scopeOfTheContainingExpression) : GetValEscape(expr, scopeOfTheContainingExpression));
				num = Math.Max(num, val);
				if (num >= scopeOfTheContainingExpression)
				{
					break;
				}
			}
			continue;
			IL_0082:
			flag3 = true;
			goto IL_008a;
		}
		instance.Free();
		return num;
	}

	private static bool ReturnsRefToRefStruct(Symbol symbol)
	{
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Invalid comparison between Unknown and I4
		MethodSymbol methodSymbol = ((symbol is MethodSymbol methodSymbol2) ? methodSymbol2 : ((!(symbol is PropertySymbol propertySymbol)) ? null : propertySymbol.GetMethod));
		MethodSymbol methodSymbol3 = methodSymbol;
		if ((object)methodSymbol3 != null && (int)methodSymbol3.RefKind != 0)
		{
			TypeSymbol returnType = methodSymbol3.ReturnType;
			if ((object)returnType != null)
			{
				return returnType.IsRefLikeType;
			}
		}
		return false;
	}

	private bool CheckInvocationEscape(SyntaxNode syntax, Symbol symbol, BoundExpression? receiver, ThreeState receiverIsSubjectToCloning, ImmutableArray<ParameterSymbol> parameters, ImmutableArray<BoundExpression> argsOpt, ImmutableArray<RefKind> argRefKindsOpt, ImmutableArray<int> argsToParamsOpt, bool checkingReceiver, uint escapeFrom, uint escapeTo, BindingDiagnosticBag diagnostics, bool isRefEscape)
	{
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_0074: Invalid comparison between Unknown and I4
		if (UseUpdatedEscapeRulesForInvocation(symbol))
		{
			return CheckInvocationEscapeWithUpdatedRules(syntax, symbol, receiver, receiverIsSubjectToCloning, parameters, argsOpt, argRefKindsOpt, argsToParamsOpt, checkingReceiver, escapeFrom, escapeTo, diagnostics, isRefEscape);
		}
		if (!symbol.RequiresInstanceReceiver())
		{
			receiver = null;
		}
		ArrayBuilder<EscapeArgument> instance = ArrayBuilder<EscapeArgument>.GetInstance();
		GetInvocationArgumentsForEscape(symbol, null, (ThreeState)0, parameters, argsOpt, argRefKindsOpt, argsToParamsOpt, ignoreArglistRefKinds: true, null, instance);
		try
		{
			Enumerator<EscapeArgument> enumerator = instance.GetEnumerator();
			while (enumerator.MoveNext())
			{
				var (parameter, boundExpression2, val2) = (EscapeArgument)(ref enumerator.Current);
				if (!(((int)val2 > 0 && isRefEscape) ? CheckRefEscape(boundExpression2.Syntax, boundExpression2, escapeFrom, escapeTo, checkingReceiver: false, diagnostics) : CheckValEscape(boundExpression2.Syntax, boundExpression2, escapeFrom, escapeTo, checkingReceiver: false, diagnostics)))
				{
					if (!(symbol is SignatureOnlyMethodSymbol))
					{
						ReportInvocationEscapeError(syntax, symbol, parameter, checkingReceiver, diagnostics);
					}
					return false;
				}
			}
		}
		finally
		{
			instance.Free();
		}
		if (receiver != null && receiver.Type?.IsRefLikeType == true)
		{
			return CheckValEscape(receiver.Syntax, receiver, escapeFrom, escapeTo, checkingReceiver: false, diagnostics);
		}
		return true;
	}

	private bool CheckInvocationEscapeWithUpdatedRules(SyntaxNode syntax, Symbol symbol, BoundExpression? receiver, ThreeState receiverIsSubjectToCloning, ImmutableArray<ParameterSymbol> parameters, ImmutableArray<BoundExpression> argsOpt, ImmutableArray<RefKind> argRefKindsOpt, ImmutableArray<int> argsToParamsOpt, bool checkingReceiver, uint escapeFrom, uint escapeTo, BindingDiagnosticBag diagnostics, bool isRefEscape)
	{
		//IL_000b: 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_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: Unknown result type (might be due to invalid IL or missing references)
		//IL_006b: Invalid comparison between Unknown and I4
		bool result = true;
		ArrayBuilder<EscapeValue> instance = ArrayBuilder<EscapeValue>.GetInstance();
		GetFilteredInvocationArgumentsForEscapeWithUpdatedRules(symbol, receiver, receiverIsSubjectToCloning, parameters, argsOpt, argRefKindsOpt, argsToParamsOpt, isRefEscape, ignoreArglistRefKinds: true, instance);
		bool flag = ReturnsRefToRefStruct(symbol);
		Enumerator<EscapeValue> enumerator = instance.GetEnumerator();
		while (enumerator.MoveNext())
		{
			enumerator.Current.Deconstruct(out ParameterSymbol parameter, out BoundExpression argument, out EscapeLevel _, out bool isRefEscape2);
			ParameterSymbol parameterSymbol = parameter;
			BoundExpression boundExpression = argument;
			bool flag2 = isRefEscape2;
			isRefEscape2 = !flag;
			bool flag3;
			if (!isRefEscape2)
			{
				if ((object)parameterSymbol == null)
				{
					goto IL_0083;
				}
				if ((int)parameterSymbol.RefKind != 0)
				{
					TypeSymbol type = parameterSymbol.Type;
					if ((object)type != null && type.IsRefLikeType)
					{
						goto IL_0083;
					}
				}
				flag3 = false;
				goto IL_008b;
			}
			goto IL_009a;
			IL_008b:
			isRefEscape2 = flag3 && flag2 == isRefEscape;
			goto IL_009a;
			IL_009a:
			if (isRefEscape2 && !(flag2 ? CheckRefEscape(boundExpression.Syntax, boundExpression, escapeFrom, escapeTo, checkingReceiver: false, diagnostics) : CheckValEscape(boundExpression.Syntax, boundExpression, escapeFrom, escapeTo, checkingReceiver: false, diagnostics)))
			{
				if (((boundExpression as BoundCapturedReceiverPlaceholder)?.Receiver ?? boundExpression) != receiver && !(symbol is SignatureOnlyMethodSymbol))
				{
					ReportInvocationEscapeError(syntax, symbol, parameterSymbol, checkingReceiver, diagnostics);
				}
				result = false;
				break;
			}
			continue;
			IL_0083:
			flag3 = true;
			goto IL_008b;
		}
		instance.Free();
		return result;
	}

	private void GetInvocationArgumentsForEscape(Symbol symbol, BoundExpression? receiver, ThreeState receiverIsSubjectToCloning, ImmutableArray<ParameterSymbol> parameters, ImmutableArray<BoundExpression> argsOpt, ImmutableArray<RefKind> argRefKindsOpt, ImmutableArray<int> argsToParamsOpt, bool ignoreArglistRefKinds, ArrayBuilder<MixableDestination>? mixableArguments, ArrayBuilder<EscapeArgument> escapeArguments)
	{
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: Invalid comparison between Unknown and I4
		//IL_014b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0150: Unknown result type (might be due to invalid IL or missing references)
		//IL_0166: Unknown result type (might be due to invalid IL or missing references)
		//IL_0169: Invalid comparison between Unknown and I4
		//IL_015f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0164: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_0183: Unknown result type (might be due to invalid IL or missing references)
		//IL_019a: Unknown result type (might be due to invalid IL or missing references)
		//IL_019f: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a6: Invalid comparison between Unknown and I4
		if (receiver != null)
		{
			MethodSymbol methodSymbol2;
			if (!(symbol is MethodSymbol methodSymbol))
			{
				if (!(symbol is PropertySymbol propertySymbol))
				{
					throw ExceptionUtilities.UnexpectedValue((object)symbol);
				}
				methodSymbol2 = propertySymbol.GetMethod ?? propertySymbol.SetMethod;
			}
			else
			{
				methodSymbol2 = methodSymbol;
			}
			MethodSymbol method = methodSymbol2;
			if ((int)receiverIsSubjectToCloning == 2)
			{
				receiver = new BoundCapturedReceiverPlaceholder(receiver.Syntax, receiver, _localScopeDepth, receiver.Type).MakeCompilerGenerated();
			}
			EscapeArgument escapeArgument = getReceiver(method, receiver);
			escapeArguments.Add(escapeArgument);
			if (mixableArguments != null && isMixableParameter(escapeArgument.Parameter))
			{
				mixableArguments.Add(new MixableDestination(escapeArgument.Parameter, receiver));
			}
		}
		if (argsOpt.IsDefault)
		{
			return;
		}
		for (int num = 0; num < argsOpt.Length; num++)
		{
			BoundExpression boundExpression = argsOpt[num];
			if (boundExpression.Kind == BoundKind.ArgListOperator)
			{
				BoundArgListOperator boundArgListOperator = (BoundArgListOperator)boundExpression;
				getArgList(boundArgListOperator.Arguments, ignoreArglistRefKinds ? default(ImmutableArray<RefKind>) : boundArgListOperator.ArgumentRefKindsOpt, mixableArguments, escapeArguments);
				break;
			}
			ParameterSymbol parameterSymbol = ((num < parameters.Length) ? parameters[argsToParamsOpt.IsDefault ? num : argsToParamsOpt[num]] : null);
			if (mixableArguments != null && isMixableParameter(parameterSymbol) && isMixableArgument(boundExpression))
			{
				mixableArguments.Add(new MixableDestination(parameterSymbol, boundExpression));
			}
			RefKind val = (RefKind)(((object)parameterSymbol != null) ? ((int)parameterSymbol.RefKind) : 0);
			if (!argRefKindsOpt.IsDefault)
			{
				val = argRefKindsOpt[num];
			}
			bool flag = (int)val == 0;
			bool flag2;
			if (flag)
			{
				RefKind? val2 = parameterSymbol?.RefKind;
				if (val2.HasValue)
				{
					RefKind valueOrDefault = val2.GetValueOrDefault();
					if (valueOrDefault - 3 <= 1)
					{
						flag2 = true;
						goto IL_01b0;
					}
				}
				flag2 = false;
				goto IL_01b0;
			}
			goto IL_01b4;
			IL_01b0:
			flag = flag2;
			goto IL_01b4;
			IL_01b4:
			if (flag)
			{
				val = parameterSymbol.RefKind;
			}
			escapeArguments.Add(new EscapeArgument(parameterSymbol, boundExpression, val));
		}
		static void getArgList(ImmutableArray<BoundExpression> immutableArray, ImmutableArray<RefKind> immutableArray2, ArrayBuilder<MixableDestination>? val5, ArrayBuilder<EscapeArgument> val4)
		{
			//IL_0019: 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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Invalid comparison between Unknown and I4
			for (int i = 0; i < immutableArray.Length; i++)
			{
				BoundExpression argument = immutableArray[i];
				RefKind val3 = (RefKind)((!immutableArray2.IsDefault) ? ((int)immutableArray2[i]) : 0);
				val4.Add(new EscapeArgument(null, argument, val3, isArgList: true));
				if ((int)val3 == 1)
				{
					val5?.Add(new MixableDestination(argument, EscapeLevel.CallingMethod));
				}
			}
		}
		static EscapeArgument getReceiver(MethodSymbol? methodSymbol3, BoundExpression argument)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if (methodSymbol3 is FunctionPointerMethodSymbol)
			{
				return new EscapeArgument(null, argument, (RefKind)0);
			}
			RefKind refKind = (RefKind)0;
			ParameterSymbol thisParameter = null;
			if ((object)methodSymbol3 != null && methodSymbol3.TryGetThisParameter(out thisParameter) && (object)thisParameter != null)
			{
				refKind = thisParameter.RefKind;
			}
			return new EscapeArgument(thisParameter, argument, refKind);
		}
		static bool isMixableArgument(BoundExpression argument)
		{
			if (argument is BoundDeconstructValuePlaceholder boundDeconstructValuePlaceholder)
			{
				if ((object)boundDeconstructValuePlaceholder.VariableSymbol != null)
				{
					goto IL_0026;
				}
			}
			else if (argument is BoundLocal { DeclarationKind: not BoundLocalDeclarationKind.None })
			{
				goto IL_0026;
			}
			bool flag3 = false;
			goto IL_002c;
			IL_0026:
			flag3 = true;
			goto IL_002c;
			IL_002c:
			if (flag3)
			{
				return false;
			}
			if (argument.IsDiscardExpression())
			{
				return false;
			}
			return true;
		}
		static bool isMixableParameter([NotNullWhen(true)] ParameterSymbol? parameter)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if ((object)parameter != null && parameter.Type.IsRefLikeType)
			{
				return parameter.RefKind.IsWritableReference();
			}
			return false;
		}
	}

	private void GetFilteredInvocationArgumentsForEscapeWithUpdatedRules(Symbol symbol, BoundExpression? receiver, ThreeState receiverIsSubjectToCloning, ImmutableArray<ParameterSymbol> parameters, ImmutableArray<BoundExpression> argsOpt, ImmutableArray<RefKind> argRefKindsOpt, ImmutableArray<int> argsToParamsOpt, bool isInvokedWithRef, bool ignoreArglistRefKinds, ArrayBuilder<EscapeValue> escapeValues)
	{
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		if (isInvokedWithRef || hasRefLikeReturn(symbol))
		{
			GetEscapeValuesForUpdatedRules(symbol, receiver, receiverIsSubjectToCloning, parameters, argsOpt, argRefKindsOpt, argsToParamsOpt, ignoreArglistRefKinds, null, escapeValues);
		}
		static bool hasRefLikeReturn(Symbol symbol2)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Invalid comparison between Unknown and I4
			if (symbol2 is MethodSymbol methodSymbol)
			{
				if ((int)methodSymbol.MethodKind == 1)
				{
					return methodSymbol.ContainingType.IsRefLikeType;
				}
				return methodSymbol.ReturnType.IsRefLikeType;
			}
			if (symbol2 is PropertySymbol propertySymbol)
			{
				return propertySymbol.Type.IsRefLikeType;
			}
			return false;
		}
	}

	private void GetEscapeValuesForUpdatedRules(Symbol symbol, BoundExpression? receiver, ThreeState receiverIsSubjectToCloning, ImmutableArray<ParameterSymbol> parameters, ImmutableArray<BoundExpression> argsOpt, ImmutableArray<RefKind> argRefKindsOpt, ImmutableArray<int> argsToParamsOpt, bool ignoreArglistRefKinds, ArrayBuilder<MixableDestination>? mixableArguments, ArrayBuilder<EscapeValue> escapeValues)
	{
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_0056: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a7: Invalid comparison between Unknown and I4
		if (!symbol.RequiresInstanceReceiver())
		{
			receiver = null;
		}
		ArrayBuilder<EscapeArgument> instance = ArrayBuilder<EscapeArgument>.GetInstance();
		GetInvocationArgumentsForEscape(symbol, receiver, receiverIsSubjectToCloning, parameters, argsOpt, argRefKindsOpt, argsToParamsOpt, ignoreArglistRefKinds, mixableArguments, instance);
		Enumerator<EscapeArgument> enumerator = instance.GetEnumerator();
		while (enumerator.MoveNext())
		{
			var (parameterSymbol2, boundExpression2, val2) = (EscapeArgument)(ref enumerator.Current);
			if ((object)parameterSymbol2 == null)
			{
				if ((int)val2 != 0)
				{
					escapeValues.Add(new EscapeValue(null, boundExpression2, EscapeLevel.ReturnOnly, isRefEscape: true));
				}
				TypeSymbol? type = boundExpression2.Type;
				if ((object)type != null && type.IsRefLikeType)
				{
					escapeValues.Add(new EscapeValue(null, boundExpression2, EscapeLevel.CallingMethod, isRefEscape: false));
				}
				continue;
			}
			if (parameterSymbol2.Type.IsRefLikeType && (int)parameterSymbol2.RefKind != 2)
			{
				EscapeLevel? parameterValEscapeLevel = GetParameterValEscapeLevel(parameterSymbol2);
				if (parameterValEscapeLevel.HasValue)
				{
					EscapeLevel valueOrDefault = parameterValEscapeLevel.GetValueOrDefault();
					escapeValues.Add(new EscapeValue(parameterSymbol2, boundExpression2, valueOrDefault, isRefEscape: false));
				}
			}
			if ((int)parameterSymbol2.RefKind != 0)
			{
				EscapeLevel? parameterValEscapeLevel = GetParameterRefEscapeLevel(parameterSymbol2);
				if (parameterValEscapeLevel.HasValue)
				{
					EscapeLevel valueOrDefault2 = parameterValEscapeLevel.GetValueOrDefault();
					escapeValues.Add(new EscapeValue(parameterSymbol2, boundExpression2, valueOrDefault2, isRefEscape: true));
				}
			}
		}
		instance.Free();
	}

	private static string GetInvocationParameterName(ParameterSymbol? parameter)
	{
		if ((object)parameter == null)
		{
			return "__arglist";
		}
		string text = parameter.Name;
		if (string.IsNullOrEmpty(text))
		{
			text = parameter.Ordinal.ToString();
		}
		return text;
	}

	private static void ReportInvocationEscapeError(SyntaxNode syntax, Symbol symbol, ParameterSymbol? parameter, bool checkingReceiver, BindingDiagnosticBag diagnostics)
	{
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		ErrorCode standardCallEscapeError = GetStandardCallEscapeError(checkingReceiver);
		string invocationParameterName = GetInvocationParameterName(parameter);
		Error(diagnostics, standardCallEscapeError, SyntaxNodeOrToken.op_Implicit(syntax), symbol, invocationParameterName);
	}

	private bool UseUpdatedEscapeRulesForInvocation(Symbol symbol)
	{
		MethodSymbol methodSymbol2;
		if (!(symbol is MethodSymbol methodSymbol))
		{
			if (!(symbol is PropertySymbol propertySymbol))
			{
				throw ExceptionUtilities.UnexpectedValue((object)symbol);
			}
			methodSymbol2 = propertySymbol.GetMethod ?? propertySymbol.SetMethod;
		}
		else
		{
			methodSymbol2 = methodSymbol;
		}
		return methodSymbol2?.UseUpdatedEscapeRules ?? false;
	}

	private bool ShouldInferDeclarationExpressionValEscape(BoundExpression argument, [NotNullWhen(true)] out SourceLocalSymbol? localSymbol)
	{
		Symbol symbol = ((argument is BoundDeconstructValuePlaceholder boundDeconstructValuePlaceholder) ? boundDeconstructValuePlaceholder.VariableSymbol : ((!(argument is BoundLocal { DeclarationKind: not BoundLocalDeclarationKind.None } boundLocal)) ? null : boundLocal.LocalSymbol));
		if (symbol is SourceLocalSymbol sourceLocalSymbol && GetLocalScopes(sourceLocalSymbol).ValEscapeScope == 0)
		{
			localSymbol = sourceLocalSymbol;
			return true;
		}
		localSymbol = null;
		return false;
	}

	private bool CheckInvocationArgMixing(SyntaxNode syntax, Symbol symbol, BoundExpression? receiverOpt, ThreeState receiverIsSubjectToCloning, ImmutableArray<ParameterSymbol> parameters, ImmutableArray<BoundExpression> argsOpt, ImmutableArray<RefKind> argRefKindsOpt, ImmutableArray<int> argsToParamsOpt, uint scopeOfTheContainingExpression, BindingDiagnosticBag diagnostics)
	{
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_0182: Unknown result type (might be due to invalid IL or missing references)
		//IL_0187: Unknown result type (might be due to invalid IL or missing references)
		//IL_015d: Unknown result type (might be due to invalid IL or missing references)
		if (UseUpdatedEscapeRulesForInvocation(symbol))
		{
			return CheckInvocationArgMixingWithUpdatedRules(syntax, symbol, receiverOpt, receiverIsSubjectToCloning, parameters, argsOpt, argRefKindsOpt, argsToParamsOpt, scopeOfTheContainingExpression, diagnostics);
		}
		if (!symbol.RequiresInstanceReceiver())
		{
			receiverOpt = null;
		}
		uint num = scopeOfTheContainingExpression;
		TypeSymbol? obj = receiverOpt?.Type;
		if ((object)obj != null && obj.IsRefLikeType && !IsReceiverRefReadOnly(symbol))
		{
			num = GetValEscape(receiverOpt, scopeOfTheContainingExpression);
		}
		ArrayBuilder<EscapeArgument> instance = ArrayBuilder<EscapeArgument>.GetInstance();
		GetInvocationArgumentsForEscape(symbol, receiverOpt, receiverIsSubjectToCloning, parameters, argsOpt, default(ImmutableArray<RefKind>), argsToParamsOpt, ignoreArglistRefKinds: false, null, instance);
		try
		{
			Enumerator<EscapeArgument> enumerator = instance.GetEnumerator();
			ParameterSymbol parameter;
			BoundExpression argument;
			RefKind refKind;
			while (enumerator.MoveNext())
			{
				enumerator.Current.Deconstruct(out parameter, out argument, out refKind);
				BoundExpression boundExpression = argument;
				RefKind refKind2 = refKind;
				if (!ShouldInferDeclarationExpressionValEscape(boundExpression, out SourceLocalSymbol _) && refKind2.IsWritableReference() && !boundExpression.IsDiscardExpression())
				{
					TypeSymbol? type = boundExpression.Type;
					if ((object)type != null && type.IsRefLikeType)
					{
						num = Math.Min(num, GetValEscape(boundExpression, scopeOfTheContainingExpression));
					}
				}
			}
			bool flag = false;
			uint num2 = 0u;
			enumerator = instance.GetEnumerator();
			while (enumerator.MoveNext())
			{
				enumerator.Current.Deconstruct(out parameter, out argument, out refKind);
				ParameterSymbol parameter2 = parameter;
				BoundExpression boundExpression2 = argument;
				num2 = Math.Max(num2, GetValEscape(boundExpression2, scopeOfTheContainingExpression));
				if (!flag && !CheckValEscape(boundExpression2.Syntax, boundExpression2, scopeOfTheContainingExpression, num, checkingReceiver: false, diagnostics))
				{
					string invocationParameterName = GetInvocationParameterName(parameter2);
					Error(diagnostics, ErrorCode.ERR_CallArgMixing, SyntaxNodeOrToken.op_Implicit(syntax), symbol, invocationParameterName);
					flag = true;
				}
			}
			enumerator = instance.GetEnumerator();
			while (enumerator.MoveNext())
			{
				enumerator.Current.Deconstruct(out parameter, out argument, out refKind);
				BoundExpression argument2 = argument;
				if (ShouldInferDeclarationExpressionValEscape(argument2, out SourceLocalSymbol localSymbol2))
				{
					SetLocalScopes(localSymbol2, _localScopeDepth, num2);
				}
			}
			return !flag;
		}
		finally
		{
			instance.Free();
		}
	}

	private bool CheckInvocationArgMixingWithUpdatedRules(SyntaxNode syntax, Symbol symbol, BoundExpression? receiverOpt, ThreeState receiverIsSubjectToCloning, ImmutableArray<ParameterSymbol> parameters, ImmutableArray<BoundExpression> argsOpt, ImmutableArray<RefKind> argRefKindsOpt, ImmutableArray<int> argsToParamsOpt, uint scopeOfTheContainingExpression, BindingDiagnosticBag diagnostics)
	{
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_007c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		//IL_011e: Unknown result type (might be due to invalid IL or missing references)
		ArrayBuilder<MixableDestination> instance = ArrayBuilder<MixableDestination>.GetInstance();
		ArrayBuilder<EscapeValue> escapeValues = ArrayBuilder<EscapeValue>.GetInstance();
		GetEscapeValuesForUpdatedRules(symbol, receiverOpt, receiverIsSubjectToCloning, parameters, argsOpt, argRefKindsOpt, argsToParamsOpt, ignoreArglistRefKinds: false, instance, escapeValues);
		bool flag = true;
		Enumerator<MixableDestination> enumerator = instance.GetEnumerator();
		while (enumerator.MoveNext())
		{
			MixableDestination current = enumerator.Current;
			uint valEscape = GetValEscape(current.Argument, scopeOfTheContainingExpression);
			Enumerator<EscapeValue> enumerator2 = escapeValues.GetEnumerator();
			while (enumerator2.MoveNext())
			{
				var (parameterSymbol2, boundExpression2, level, flag3) = (EscapeValue)(ref enumerator2.Current);
				if (((object)current.Parameter == null || (object)current.Parameter != parameterSymbol2) && current.IsAssignableFrom(level))
				{
					flag = (flag3 ? CheckRefEscape(boundExpression2.Syntax, boundExpression2, scopeOfTheContainingExpression, valEscape, checkingReceiver: false, diagnostics) : CheckValEscape(boundExpression2.Syntax, boundExpression2, scopeOfTheContainingExpression, valEscape, checkingReceiver: false, diagnostics));
					if (!flag)
					{
						string invocationParameterName = GetInvocationParameterName(parameterSymbol2);
						Error(diagnostics, ErrorCode.ERR_CallArgMixing, SyntaxNodeOrToken.op_Implicit(syntax), symbol, invocationParameterName);
						break;
					}
				}
			}
			if (!flag)
			{
				break;
			}
		}
		inferDeclarationExpressionValEscape();
		instance.Free();
		escapeValues.Free();
		return flag;
		void inferDeclarationExpressionValEscape()
		{
			//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)
			uint num = 0u;
			Enumerator<EscapeValue> enumerator3 = escapeValues.GetEnumerator();
			while (enumerator3.MoveNext())
			{
				enumerator3.Current.Deconstruct(out ParameterSymbol _, out BoundExpression argument, out EscapeLevel _, out bool isRefEscape);
				BoundExpression expr = argument;
				bool flag4 = isRefEscape;
				num = Math.Max(num, flag4 ? GetRefEscape(expr, scopeOfTheContainingExpression) : GetValEscape(expr, scopeOfTheContainingExpression));
			}
			ImmutableArray<BoundExpression>.Enumerator enumerator4 = argsOpt.GetEnumerator();
			while (enumerator4.MoveNext())
			{
				BoundExpression current2 = enumerator4.Current;
				if (ShouldInferDeclarationExpressionValEscape(current2, out SourceLocalSymbol localSymbol))
				{
					SetLocalScopes(localSymbol, _localScopeDepth, num);
				}
			}
		}
	}

	private static bool IsReceiverRefReadOnly(Symbol methodOrPropertySymbol)
	{
		if (!(methodOrPropertySymbol is MethodSymbol { IsEffectivelyReadOnly: var isEffectivelyReadOnly }))
		{
			if (methodOrPropertySymbol is PropertySymbol propertySymbol)
			{
				MethodSymbol getMethod = propertySymbol.GetMethod;
				return ((object)getMethod == null || getMethod.IsEffectivelyReadOnly) && (propertySymbol.SetMethod?.IsEffectivelyReadOnly ?? true);
			}
			throw ExceptionUtilities.UnexpectedValue((object)methodOrPropertySymbol);
		}
		return isEffectivelyReadOnly;
	}

	private static ErrorCode GetStandardCallEscapeError(bool checkingReceiver)
	{
		if (!checkingReceiver)
		{
			return ErrorCode.ERR_EscapeCall;
		}
		return ErrorCode.ERR_EscapeCall2;
	}

	private static ErrorCode GetStandardRValueRefEscapeError(uint escapeTo)
	{
		if (escapeTo <= 1)
		{
			return ErrorCode.ERR_RefReturnLvalueExpected;
		}
		return ErrorCode.ERR_EscapeOther;
	}

	internal void ValidateEscape(BoundExpression expr, uint escapeTo, bool isByRef, BindingDiagnosticBag diagnostics)
	{
		if (isByRef)
		{
			CheckRefEscape(expr.Syntax, expr, _localScopeDepth, escapeTo, checkingReceiver: false, diagnostics);
		}
		else
		{
			CheckValEscape(expr.Syntax, expr, _localScopeDepth, escapeTo, checkingReceiver: false, diagnostics);
		}
	}

	internal uint GetRefEscape(BoundExpression expr, uint scopeOfTheContainingExpression)
	{
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Invalid comparison between Unknown and I4
		//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_0201: Unknown result type (might be due to invalid IL or missing references)
		//IL_041f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0295: Unknown result type (might be due to invalid IL or missing references)
		//IL_03a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_03a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_03a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_03b0: Invalid comparison between Unknown and I4
		//IL_0242: Unknown result type (might be due to invalid IL or missing references)
		//IL_0309: Unknown result type (might be due to invalid IL or missing references)
		//IL_03b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_03b9: Invalid comparison between Unknown and I4
		//IL_033f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0359: Unknown result type (might be due to invalid IL or missing references)
		if (expr.HasAnyErrors)
		{
			return 0u;
		}
		TypeSymbol? type = expr.Type;
		if ((object)type != null && (int)type.GetSpecialTypeSafe() == 6)
		{
			return 0u;
		}
		if (expr.ConstantValueOpt != (ConstantValue)null)
		{
			return scopeOfTheContainingExpression;
		}
		switch (expr.Kind)
		{
		case BoundKind.PointerIndirectionOperator:
		case BoundKind.PointerElementAccess:
		case BoundKind.ArrayAccess:
			return 0u;
		case BoundKind.RefValueOperator:
			return 2u;
		case BoundKind.Parameter:
			return GetParameterRefEscape(((BoundParameter)expr).ParameterSymbol);
		case BoundKind.Local:
			return GetLocalScopes(((BoundLocal)expr).LocalSymbol).RefEscapeScope;
		case BoundKind.CapturedReceiverPlaceholder:
			return ((BoundCapturedReceiverPlaceholder)expr).LocalScopeDepth;
		case BoundKind.ThisReference:
			return GetParameterRefEscape(_symbol.ThisParameter);
		case BoundKind.ConditionalOperator:
		{
			BoundConditionalOperator boundConditionalOperator = (BoundConditionalOperator)expr;
			if (boundConditionalOperator.IsRef)
			{
				return Math.Max(GetRefEscape(boundConditionalOperator.Consequence, scopeOfTheContainingExpression), GetRefEscape(boundConditionalOperator.Alternative, scopeOfTheContainingExpression));
			}
			break;
		}
		case BoundKind.FieldAccess:
			return GetFieldRefEscape((BoundFieldAccess)expr, scopeOfTheContainingExpression);
		case BoundKind.EventAccess:
		{
			BoundEventAccess boundEventAccess = (BoundEventAccess)expr;
			if (boundEventAccess.IsUsableAsField)
			{
				EventSymbol eventSymbol = boundEventAccess.EventSymbol;
				if (eventSymbol.IsStatic || eventSymbol.ContainingType.IsReferenceType)
				{
					return 0u;
				}
				return GetRefEscape(boundEventAccess.ReceiverOpt, scopeOfTheContainingExpression);
			}
			break;
		}
		case BoundKind.Call:
		{
			BoundCall boundCall = (BoundCall)expr;
			MethodSymbol method = boundCall.Method;
			if ((int)method.RefKind != 0)
			{
				return GetInvocationEscapeScope(boundCall.Method, boundCall.ReceiverOpt, boundCall.InitialBindingReceiverIsSubjectToCloning, method.Parameters, boundCall.Arguments, boundCall.ArgumentRefKindsOpt, boundCall.ArgsToParamsOpt, scopeOfTheContainingExpression, isRefEscape: true);
			}
			break;
		}
		case BoundKind.FunctionPointerInvocation:
		{
			BoundFunctionPointerInvocation boundFunctionPointerInvocation = (BoundFunctionPointerInvocation)expr;
			FunctionPointerMethodSymbol signature = boundFunctionPointerInvocation.FunctionPointer.Signature;
			if ((int)signature.RefKind != 0)
			{
				return GetInvocationEscapeScope(signature, null, (ThreeState)0, signature.Parameters, boundFunctionPointerInvocation.Arguments, boundFunctionPointerInvocation.ArgumentRefKindsOpt, default(ImmutableArray<int>), scopeOfTheContainingExpression, isRefEscape: true);
			}
			break;
		}
		case BoundKind.IndexerAccess:
		{
			BoundIndexerAccess boundIndexerAccess = (BoundIndexerAccess)expr;
			PropertySymbol indexer = boundIndexerAccess.Indexer;
			return GetInvocationEscapeScope(indexer, boundIndexerAccess.ReceiverOpt, boundIndexerAccess.InitialBindingReceiverIsSubjectToCloning, indexer.Parameters, boundIndexerAccess.Arguments, boundIndexerAccess.ArgumentRefKindsOpt, boundIndexerAccess.ArgsToParamsOpt, scopeOfTheContainingExpression, isRefEscape: true);
		}
		case BoundKind.ImplicitIndexerAccess:
		{
			BoundImplicitIndexerAccess boundImplicitIndexerAccess = (BoundImplicitIndexerAccess)expr;
			BoundExpression indexerOrSliceAccess = boundImplicitIndexerAccess.IndexerOrSliceAccess;
			if (!(indexerOrSliceAccess is BoundIndexerAccess boundIndexerAccess2))
			{
				if (!(indexerOrSliceAccess is BoundArrayAccess))
				{
					if (indexerOrSliceAccess is BoundCall boundCall2)
					{
						MethodSymbol method2 = boundCall2.Method;
						if ((int)method2.RefKind != 0)
						{
							return GetInvocationEscapeScope(boundCall2.Method, boundImplicitIndexerAccess.Receiver, boundCall2.InitialBindingReceiverIsSubjectToCloning, method2.Parameters, boundCall2.Arguments, boundCall2.ArgumentRefKindsOpt, boundCall2.ArgsToParamsOpt, scopeOfTheContainingExpression, isRefEscape: true);
						}
						break;
					}
					throw ExceptionUtilities.UnexpectedValue((object)boundImplicitIndexerAccess.IndexerOrSliceAccess.Kind);
				}
				return 0u;
			}
			PropertySymbol indexer2 = boundIndexerAccess2.Indexer;
			return GetInvocationEscapeScope(indexer2, boundImplicitIndexerAccess.Receiver, boundIndexerAccess2.InitialBindingReceiverIsSubjectToCloning, indexer2.Parameters, boundIndexerAccess2.Arguments, boundIndexerAccess2.ArgumentRefKindsOpt, boundIndexerAccess2.ArgsToParamsOpt, scopeOfTheContainingExpression, isRefEscape: true);
		}
		case BoundKind.InlineArrayAccess:
		{
			BoundInlineArrayAccess boundInlineArrayAccess = (BoundInlineArrayAccess)expr;
			WellKnownMember getItemOrSliceHelper = boundInlineArrayAccess.GetItemOrSliceHelper;
			bool flag = (((int)getItemOrSliceHelper == 400 || (int)getItemOrSliceHelper == 406) ? true : false);
			if (flag && !boundInlineArrayAccess.IsValue)
			{
				ImmutableArray<BoundExpression> arguments;
				ImmutableArray<RefKind> refKinds;
				SignatureOnlyMethodSymbol inlineArrayAccessEquivalentSignatureMethod = GetInlineArrayAccessEquivalentSignatureMethod(boundInlineArrayAccess, out arguments, out refKinds);
				return GetInvocationEscapeScope(inlineArrayAccessEquivalentSignatureMethod, null, (ThreeState)0, inlineArrayAccessEquivalentSignatureMethod.Parameters, arguments, refKinds, default(ImmutableArray<int>), scopeOfTheContainingExpression, isRefEscape: true);
			}
			break;
		}
		case BoundKind.PropertyAccess:
		{
			BoundPropertyAccess boundPropertyAccess = (BoundPropertyAccess)expr;
			return GetInvocationEscapeScope(boundPropertyAccess.PropertySymbol, boundPropertyAccess.ReceiverOpt, boundPropertyAccess.InitialBindingReceiverIsSubjectToCloning, default(ImmutableArray<ParameterSymbol>), default(ImmutableArray<BoundExpression>), default(ImmutableArray<RefKind>), default(ImmutableArray<int>), scopeOfTheContainingExpression, isRefEscape: true);
		}
		case BoundKind.AssignmentOperator:
		{
			BoundAssignmentOperator boundAssignmentOperator = (BoundAssignmentOperator)expr;
			if (boundAssignmentOperator.IsRef)
			{
				return GetRefEscape(boundAssignmentOperator.Left, scopeOfTheContainingExpression);
			}
			break;
		}
		}
		return scopeOfTheContainingExpression;
	}

	internal bool CheckRefEscape(SyntaxNode node, BoundExpression expr, uint escapeFrom, uint escapeTo, bool checkingReceiver, BindingDiagnosticBag diagnostics)
	{
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Invalid comparison between Unknown and I4
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_05d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_027b: Unknown result type (might be due to invalid IL or missing references)
		//IL_04b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0298: Unknown result type (might be due to invalid IL or missing references)
		//IL_0515: Unknown result type (might be due to invalid IL or missing references)
		//IL_02da: Unknown result type (might be due to invalid IL or missing references)
		//IL_0430: Unknown result type (might be due to invalid IL or missing references)
		//IL_0435: Unknown result type (might be due to invalid IL or missing references)
		//IL_0437: Unknown result type (might be due to invalid IL or missing references)
		//IL_043e: Invalid comparison between Unknown and I4
		//IL_0532: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
		//IL_036a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0440: Unknown result type (might be due to invalid IL or missing references)
		//IL_0447: Invalid comparison between Unknown and I4
		//IL_0387: Unknown result type (might be due to invalid IL or missing references)
		//IL_03c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_03e0: Unknown result type (might be due to invalid IL or missing references)
		if (escapeTo >= escapeFrom)
		{
			return true;
		}
		if (expr.HasAnyErrors)
		{
			return true;
		}
		TypeSymbol? type = expr.Type;
		if ((object)type != null && (int)type.GetSpecialTypeSafe() == 6)
		{
			return true;
		}
		if (expr.ConstantValueOpt != (ConstantValue)null)
		{
			Error(diagnostics, GetStandardRValueRefEscapeError(escapeTo), SyntaxNodeOrToken.op_Implicit(node));
			return false;
		}
		switch (expr.Kind)
		{
		case BoundKind.PointerIndirectionOperator:
		case BoundKind.PointerElementAccess:
		case BoundKind.ArrayAccess:
			return true;
		case BoundKind.RefValueOperator:
			if (escapeTo > 1)
			{
				return true;
			}
			break;
		case BoundKind.Parameter:
		{
			BoundParameter boundParameter = (BoundParameter)expr;
			return CheckParameterRefEscape(node, boundParameter, boundParameter.ParameterSymbol, escapeTo, checkingReceiver, diagnostics);
		}
		case BoundKind.Local:
		{
			BoundLocal local = (BoundLocal)expr;
			return CheckLocalRefEscape(node, local, escapeTo, checkingReceiver, diagnostics);
		}
		case BoundKind.CapturedReceiverPlaceholder:
			if (((BoundCapturedReceiverPlaceholder)expr).LocalScopeDepth <= escapeTo)
			{
				return true;
			}
			break;
		case BoundKind.ThisReference:
		{
			ParameterSymbol thisParameter = _symbol.ThisParameter;
			return CheckParameterRefEscape(node, expr, thisParameter, escapeTo, checkingReceiver, diagnostics);
		}
		case BoundKind.ConditionalOperator:
		{
			BoundConditionalOperator boundConditionalOperator = (BoundConditionalOperator)expr;
			if (boundConditionalOperator.IsRef)
			{
				if (CheckRefEscape(boundConditionalOperator.Consequence.Syntax, boundConditionalOperator.Consequence, escapeFrom, escapeTo, checkingReceiver: false, diagnostics))
				{
					return CheckRefEscape(boundConditionalOperator.Alternative.Syntax, boundConditionalOperator.Alternative, escapeFrom, escapeTo, checkingReceiver: false, diagnostics);
				}
				return false;
			}
			break;
		}
		case BoundKind.FieldAccess:
		{
			BoundFieldAccess fieldAccess = (BoundFieldAccess)expr;
			return CheckFieldRefEscape(node, fieldAccess, escapeFrom, escapeTo, diagnostics);
		}
		case BoundKind.EventAccess:
		{
			BoundEventAccess boundEventAccess = (BoundEventAccess)expr;
			if (boundEventAccess.IsUsableAsField)
			{
				return CheckFieldLikeEventRefEscape(node, boundEventAccess, escapeFrom, escapeTo, diagnostics);
			}
			break;
		}
		case BoundKind.Call:
		{
			BoundCall boundCall = (BoundCall)expr;
			MethodSymbol method = boundCall.Method;
			if ((int)method.RefKind != 0)
			{
				return CheckInvocationEscape(boundCall.Syntax, method, boundCall.ReceiverOpt, boundCall.InitialBindingReceiverIsSubjectToCloning, method.Parameters, boundCall.Arguments, boundCall.ArgumentRefKindsOpt, boundCall.ArgsToParamsOpt, checkingReceiver, escapeFrom, escapeTo, diagnostics, isRefEscape: true);
			}
			break;
		}
		case BoundKind.IndexerAccess:
		{
			BoundIndexerAccess boundIndexerAccess = (BoundIndexerAccess)expr;
			PropertySymbol indexer = boundIndexerAccess.Indexer;
			if ((int)indexer.RefKind != 0)
			{
				return CheckInvocationEscape(boundIndexerAccess.Syntax, indexer, boundIndexerAccess.ReceiverOpt, boundIndexerAccess.InitialBindingReceiverIsSubjectToCloning, indexer.Parameters, boundIndexerAccess.Arguments, boundIndexerAccess.ArgumentRefKindsOpt, boundIndexerAccess.ArgsToParamsOpt, checkingReceiver, escapeFrom, escapeTo, diagnostics, isRefEscape: true);
			}
			break;
		}
		case BoundKind.ImplicitIndexerAccess:
		{
			BoundImplicitIndexerAccess boundImplicitIndexerAccess = (BoundImplicitIndexerAccess)expr;
			BoundExpression indexerOrSliceAccess = boundImplicitIndexerAccess.IndexerOrSliceAccess;
			if (!(indexerOrSliceAccess is BoundIndexerAccess boundIndexerAccess2))
			{
				if (indexerOrSliceAccess is BoundArrayAccess)
				{
					return true;
				}
				if (!(indexerOrSliceAccess is BoundCall boundCall2))
				{
					throw ExceptionUtilities.UnexpectedValue((object)boundImplicitIndexerAccess.IndexerOrSliceAccess.Kind);
				}
				MethodSymbol method2 = boundCall2.Method;
				if ((int)method2.RefKind != 0)
				{
					return CheckInvocationEscape(boundCall2.Syntax, method2, boundImplicitIndexerAccess.Receiver, boundCall2.InitialBindingReceiverIsSubjectToCloning, method2.Parameters, boundCall2.Arguments, boundCall2.ArgumentRefKindsOpt, boundCall2.ArgsToParamsOpt, checkingReceiver, escapeFrom, escapeTo, diagnostics, isRefEscape: true);
				}
			}
			else
			{
				PropertySymbol indexer2 = boundIndexerAccess2.Indexer;
				if ((int)indexer2.RefKind != 0)
				{
					return CheckInvocationEscape(boundIndexerAccess2.Syntax, indexer2, boundImplicitIndexerAccess.Receiver, boundIndexerAccess2.InitialBindingReceiverIsSubjectToCloning, indexer2.Parameters, boundIndexerAccess2.Arguments, boundIndexerAccess2.ArgumentRefKindsOpt, boundIndexerAccess2.ArgsToParamsOpt, checkingReceiver, escapeFrom, escapeTo, diagnostics, isRefEscape: true);
				}
			}
			break;
		}
		case BoundKind.InlineArrayAccess:
		{
			BoundInlineArrayAccess boundInlineArrayAccess = (BoundInlineArrayAccess)expr;
			WellKnownMember getItemOrSliceHelper = boundInlineArrayAccess.GetItemOrSliceHelper;
			bool flag = (((int)getItemOrSliceHelper == 400 || (int)getItemOrSliceHelper == 406) ? true : false);
			if (flag && !boundInlineArrayAccess.IsValue)
			{
				ImmutableArray<BoundExpression> arguments;
				ImmutableArray<RefKind> refKinds;
				SignatureOnlyMethodSymbol inlineArrayAccessEquivalentSignatureMethod = GetInlineArrayAccessEquivalentSignatureMethod(boundInlineArrayAccess, out arguments, out refKinds);
				return CheckInvocationEscape(boundInlineArrayAccess.Syntax, inlineArrayAccessEquivalentSignatureMethod, null, (ThreeState)0, inlineArrayAccessEquivalentSignatureMethod.Parameters, arguments, refKinds, default(ImmutableArray<int>), checkingReceiver, escapeFrom, escapeTo, diagnostics, isRefEscape: true);
			}
			break;
		}
		case BoundKind.FunctionPointerInvocation:
		{
			BoundFunctionPointerInvocation boundFunctionPointerInvocation = (BoundFunctionPointerInvocation)expr;
			FunctionPointerMethodSymbol signature = boundFunctionPointerInvocation.FunctionPointer.Signature;
			if ((int)signature.RefKind != 0)
			{
				return CheckInvocationEscape(boundFunctionPointerInvocation.Syntax, signature, boundFunctionPointerInvocation.InvokedExpression, (ThreeState)1, signature.Parameters, boundFunctionPointerInvocation.Arguments, boundFunctionPointerInvocation.ArgumentRefKindsOpt, default(ImmutableArray<int>), checkingReceiver, escapeFrom, escapeTo, diagnostics, isRefEscape: true);
			}
			break;
		}
		case BoundKind.PropertyAccess:
		{
			BoundPropertyAccess boundPropertyAccess = (BoundPropertyAccess)expr;
			PropertySymbol propertySymbol = boundPropertyAccess.PropertySymbol;
			if ((int)propertySymbol.RefKind != 0)
			{
				return CheckInvocationEscape(boundPropertyAccess.Syntax, propertySymbol, boundPropertyAccess.ReceiverOpt, boundPropertyAccess.InitialBindingReceiverIsSubjectToCloning, default(ImmutableArray<ParameterSymbol>), default(ImmutableArray<BoundExpression>), default(ImmutableArray<RefKind>), default(ImmutableArray<int>), checkingReceiver, escapeFrom, escapeTo, diagnostics, isRefEscape: true);
			}
			break;
		}
		case BoundKind.AssignmentOperator:
		{
			BoundAssignmentOperator boundAssignmentOperator = (BoundAssignmentOperator)expr;
			if (boundAssignmentOperator.IsRef)
			{
				return CheckRefEscape(node, boundAssignmentOperator.Left, escapeFrom, escapeTo, checkingReceiver: false, diagnostics);
			}
			break;
		}
		case BoundKind.Conversion:
		{
			BoundConversion boundConversion = (BoundConversion)expr;
			if (boundConversion.Conversion == Conversion.ImplicitThrow)
			{
				return CheckRefEscape(node, boundConversion.Operand, escapeFrom, escapeTo, checkingReceiver, diagnostics);
			}
			break;
		}
		case BoundKind.ThrowExpression:
			return true;
		}
		Error(diagnostics, GetStandardRValueRefEscapeError(escapeTo), SyntaxNodeOrToken.op_Implicit(node));
		return false;
	}

	internal uint GetBroadestValEscape(BoundTupleExpression expr, uint scopeOfTheContainingExpression)
	{
		uint num = scopeOfTheContainingExpression;
		ImmutableArray<BoundExpression>.Enumerator enumerator = expr.Arguments.GetEnumerator();
		while (enumerator.MoveNext())
		{
			BoundExpression current = enumerator.Current;
			uint val = ((!(current is BoundTupleExpression expr2)) ? GetValEscape(current, scopeOfTheContainingExpression) : GetBroadestValEscape(expr2, scopeOfTheContainingExpression));
			num = Math.Min(num, val);
		}
		return num;
	}

	internal uint GetValEscape(BoundExpression expr, uint scopeOfTheContainingExpression)
	{
		//IL_0565: Unknown result type (might be due to invalid IL or missing references)
		//IL_041f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0392: Unknown result type (might be due to invalid IL or missing references)
		//IL_0493: Unknown result type (might be due to invalid IL or missing references)
		//IL_04cf: Unknown result type (might be due to invalid IL or missing references)
		if (expr.HasAnyErrors)
		{
			return 0u;
		}
		if (expr.ConstantValueOpt != (ConstantValue)null)
		{
			return 0u;
		}
		TypeSymbol? type = expr.Type;
		if ((object)type == null || !type.IsRefLikeType)
		{
			return 0u;
		}
		switch (expr.Kind)
		{
		case BoundKind.ThisReference:
			return GetParameterValEscape(_symbol.ThisParameter);
		case BoundKind.DefaultLiteral:
		case BoundKind.DefaultExpression:
		case BoundKind.Utf8String:
			return 0u;
		case BoundKind.Parameter:
			return GetParameterValEscape(((BoundParameter)expr).ParameterSymbol);
		case BoundKind.FromEndIndexExpression:
			return 0u;
		case BoundKind.TupleLiteral:
		case BoundKind.ConvertedTupleLiteral:
		{
			BoundTupleExpression boundTupleExpression = (BoundTupleExpression)expr;
			return GetTupleValEscape(boundTupleExpression.Arguments, scopeOfTheContainingExpression);
		}
		case BoundKind.MakeRefOperator:
		case BoundKind.RefValueOperator:
			return 0u;
		case BoundKind.DiscardExpression:
			return 0u;
		case BoundKind.DeconstructValuePlaceholder:
		case BoundKind.AwaitableValuePlaceholder:
		case BoundKind.InterpolatedStringArgumentPlaceholder:
			return GetPlaceholderScope((BoundValuePlaceholderBase)expr);
		case BoundKind.Local:
			return GetLocalScopes(((BoundLocal)expr).LocalSymbol).ValEscapeScope;
		case BoundKind.CapturedReceiverPlaceholder:
		{
			BoundCapturedReceiverPlaceholder boundCapturedReceiverPlaceholder = (BoundCapturedReceiverPlaceholder)expr;
			return GetValEscape(boundCapturedReceiverPlaceholder.Receiver, boundCapturedReceiverPlaceholder.LocalScopeDepth);
		}
		case BoundKind.StackAllocArrayCreation:
		case BoundKind.ConvertedStackAllocExpression:
			return 2u;
		case BoundKind.ConditionalOperator:
		{
			BoundConditionalOperator boundConditionalOperator = (BoundConditionalOperator)expr;
			uint valEscape = GetValEscape(boundConditionalOperator.Consequence, scopeOfTheContainingExpression);
			if (boundConditionalOperator.IsRef)
			{
				return valEscape;
			}
			return Math.Max(valEscape, GetValEscape(boundConditionalOperator.Alternative, scopeOfTheContainingExpression));
		}
		case BoundKind.NullCoalescingOperator:
		{
			BoundNullCoalescingOperator boundNullCoalescingOperator = (BoundNullCoalescingOperator)expr;
			return Math.Max(GetValEscape(boundNullCoalescingOperator.LeftOperand, scopeOfTheContainingExpression), GetValEscape(boundNullCoalescingOperator.RightOperand, scopeOfTheContainingExpression));
		}
		case BoundKind.FieldAccess:
		{
			BoundFieldAccess boundFieldAccess = (BoundFieldAccess)expr;
			FieldSymbol fieldSymbol = boundFieldAccess.FieldSymbol;
			if (fieldSymbol.IsStatic || !fieldSymbol.ContainingType.IsRefLikeType)
			{
				return 0u;
			}
			return GetValEscape(boundFieldAccess.ReceiverOpt, scopeOfTheContainingExpression);
		}
		case BoundKind.Call:
		{
			BoundCall boundCall2 = (BoundCall)expr;
			return GetInvocationEscapeScope(boundCall2.Method, boundCall2.ReceiverOpt, boundCall2.InitialBindingReceiverIsSubjectToCloning, boundCall2.Method.Parameters, boundCall2.Arguments, boundCall2.ArgumentRefKindsOpt, boundCall2.ArgsToParamsOpt, scopeOfTheContainingExpression, isRefEscape: false);
		}
		case BoundKind.FunctionPointerInvocation:
		{
			BoundFunctionPointerInvocation boundFunctionPointerInvocation = (BoundFunctionPointerInvocation)expr;
			FunctionPointerMethodSymbol signature = boundFunctionPointerInvocation.FunctionPointer.Signature;
			return GetInvocationEscapeScope(signature, null, (ThreeState)0, signature.Parameters, boundFunctionPointerInvocation.Arguments, boundFunctionPointerInvocation.ArgumentRefKindsOpt, default(ImmutableArray<int>), scopeOfTheContainingExpression, isRefEscape: false);
		}
		case BoundKind.IndexerAccess:
		{
			BoundIndexerAccess boundIndexerAccess2 = (BoundIndexerAccess)expr;
			PropertySymbol indexer2 = boundIndexerAccess2.Indexer;
			return GetInvocationEscapeScope(indexer2, boundIndexerAccess2.ReceiverOpt, boundIndexerAccess2.InitialBindingReceiverIsSubjectToCloning, indexer2.Parameters, boundIndexerAccess2.Arguments, boundIndexerAccess2.ArgumentRefKindsOpt, boundIndexerAccess2.ArgsToParamsOpt, scopeOfTheContainingExpression, isRefEscape: false);
		}
		case BoundKind.ImplicitIndexerAccess:
		{
			BoundImplicitIndexerAccess boundImplicitIndexerAccess = (BoundImplicitIndexerAccess)expr;
			BoundExpression indexerOrSliceAccess = boundImplicitIndexerAccess.IndexerOrSliceAccess;
			if (!(indexerOrSliceAccess is BoundIndexerAccess boundIndexerAccess))
			{
				if (!(indexerOrSliceAccess is BoundArrayAccess))
				{
					if (indexerOrSliceAccess is BoundCall boundCall)
					{
						return GetInvocationEscapeScope(boundCall.Method, boundImplicitIndexerAccess.Receiver, boundCall.InitialBindingReceiverIsSubjectToCloning, boundCall.Method.Parameters, boundCall.Arguments, boundCall.ArgumentRefKindsOpt, boundCall.ArgsToParamsOpt, scopeOfTheContainingExpression, isRefEscape: false);
					}
					throw ExceptionUtilities.UnexpectedValue((object)boundImplicitIndexerAccess.IndexerOrSliceAccess.Kind);
				}
				return scopeOfTheContainingExpression;
			}
			PropertySymbol indexer = boundIndexerAccess.Indexer;
			return GetInvocationEscapeScope(indexer, boundImplicitIndexerAccess.Receiver, boundIndexerAccess.InitialBindingReceiverIsSubjectToCloning, indexer.Parameters, boundIndexerAccess.Arguments, boundIndexerAccess.ArgumentRefKindsOpt, boundIndexerAccess.ArgsToParamsOpt, scopeOfTheContainingExpression, isRefEscape: false);
		}
		case BoundKind.InlineArrayAccess:
		{
			BoundInlineArrayAccess elementAccess = (BoundInlineArrayAccess)expr;
			ImmutableArray<BoundExpression> arguments2;
			ImmutableArray<RefKind> refKinds2;
			SignatureOnlyMethodSymbol inlineArrayAccessEquivalentSignatureMethod = GetInlineArrayAccessEquivalentSignatureMethod(elementAccess, out arguments2, out refKinds2);
			return GetInvocationEscapeScope(inlineArrayAccessEquivalentSignatureMethod, null, (ThreeState)0, inlineArrayAccessEquivalentSignatureMethod.Parameters, arguments2, refKinds2, default(ImmutableArray<int>), scopeOfTheContainingExpression, isRefEscape: false);
		}
		case BoundKind.PropertyAccess:
		{
			BoundPropertyAccess boundPropertyAccess = (BoundPropertyAccess)expr;
			return GetInvocationEscapeScope(boundPropertyAccess.PropertySymbol, boundPropertyAccess.ReceiverOpt, boundPropertyAccess.InitialBindingReceiverIsSubjectToCloning, default(ImmutableArray<ParameterSymbol>), default(ImmutableArray<BoundExpression>), default(ImmutableArray<RefKind>), default(ImmutableArray<int>), scopeOfTheContainingExpression, isRefEscape: false);
		}
		case BoundKind.ObjectCreationExpression:
		{
			BoundObjectCreationExpression boundObjectCreationExpression = (BoundObjectCreationExpression)expr;
			MethodSymbol constructor = boundObjectCreationExpression.Constructor;
			uint num = GetInvocationEscapeScope(constructor, null, (ThreeState)0, constructor.Parameters, boundObjectCreationExpression.Arguments, boundObjectCreationExpression.ArgumentRefKindsOpt, boundObjectCreationExpression.ArgsToParamsOpt, scopeOfTheContainingExpression, isRefEscape: false);
			BoundObjectInitializerExpressionBase initializerExpressionOpt = boundObjectCreationExpression.InitializerExpressionOpt;
			if (initializerExpressionOpt != null)
			{
				num = Math.Max(num, GetValEscape(initializerExpressionOpt, scopeOfTheContainingExpression));
			}
			return num;
		}
		case BoundKind.WithExpression:
		{
			BoundWithExpression boundWithExpression = (BoundWithExpression)expr;
			return Math.Max(GetValEscape(boundWithExpression.Receiver, scopeOfTheContainingExpression), GetValEscape(boundWithExpression.InitializerExpression, scopeOfTheContainingExpression));
		}
		case BoundKind.UnaryOperator:
			return GetValEscape(((BoundUnaryOperator)expr).Operand, scopeOfTheContainingExpression);
		case BoundKind.Conversion:
		{
			BoundConversion boundConversion = (BoundConversion)expr;
			if (boundConversion.ConversionKind == ConversionKind.InterpolatedStringHandler)
			{
				return GetInterpolatedStringHandlerConversionEscapeScope(boundConversion.Operand, scopeOfTheContainingExpression);
			}
			if (boundConversion.ConversionKind == ConversionKind.CollectionExpression)
			{
				if (!HasLocalScope((BoundCollectionExpression)boundConversion.Operand))
				{
					return 0u;
				}
				return 2u;
			}
			if (boundConversion.Conversion.IsInlineArray)
			{
				ImmutableArray<BoundExpression> arguments;
				ImmutableArray<RefKind> refKinds;
				SignatureOnlyMethodSymbol inlineArrayConversionEquivalentSignatureMethod = GetInlineArrayConversionEquivalentSignatureMethod(boundConversion, out arguments, out refKinds);
				return GetInvocationEscapeScope(inlineArrayConversionEquivalentSignatureMethod, null, (ThreeState)0, inlineArrayConversionEquivalentSignatureMethod.Parameters, arguments, refKinds, default(ImmutableArray<int>), scopeOfTheContainingExpression, isRefEscape: false);
			}
			return GetValEscape(boundConversion.Operand, scopeOfTheContainingExpression);
		}
		case BoundKind.AssignmentOperator:
			return GetValEscape(((BoundAssignmentOperator)expr).Right, scopeOfTheContainingExpression);
		case BoundKind.IncrementOperator:
			return GetValEscape(((BoundIncrementOperator)expr).Operand, scopeOfTheContainingExpression);
		case BoundKind.CompoundAssignmentOperator:
		{
			BoundCompoundAssignmentOperator boundCompoundAssignmentOperator = (BoundCompoundAssignmentOperator)expr;
			return Math.Max(GetValEscape(boundCompoundAssignmentOperator.Left, scopeOfTheContainingExpression), GetValEscape(boundCompoundAssignmentOperator.Right, scopeOfTheContainingExpression));
		}
		case BoundKind.BinaryOperator:
		{
			BoundBinaryOperator boundBinaryOperator = (BoundBinaryOperator)expr;
			return Math.Max(GetValEscape(boundBinaryOperator.Left, scopeOfTheContainingExpression), GetValEscape(boundBinaryOperator.Right, scopeOfTheContainingExpression));
		}
		case BoundKind.RangeExpression:
		{
			BoundRangeExpression boundRangeExpression = (BoundRangeExpression)expr;
			BoundExpression leftOperandOpt = boundRangeExpression.LeftOperandOpt;
			uint val = ((leftOperandOpt != null) ? GetValEscape(leftOperandOpt, scopeOfTheContainingExpression) : 0);
			BoundExpression rightOperandOpt = boundRangeExpression.RightOperandOpt;
			return Math.Max(val, (rightOperandOpt != null) ? GetValEscape(rightOperandOpt, scopeOfTheContainingExpression) : 0u);
		}
		case BoundKind.UserDefinedConditionalLogicalOperator:
		{
			BoundUserDefinedConditionalLogicalOperator boundUserDefinedConditionalLogicalOperator = (BoundUserDefinedConditionalLogicalOperator)expr;
			return Math.Max(GetValEscape(boundUserDefinedConditionalLogicalOperator.Left, scopeOfTheContainingExpression), GetValEscape(boundUserDefinedConditionalLogicalOperator.Right, scopeOfTheContainingExpression));
		}
		case BoundKind.QueryClause:
			return GetValEscape(((BoundQueryClause)expr).Value, scopeOfTheContainingExpression);
		case BoundKind.RangeVariable:
			return GetValEscape(((BoundRangeVariable)expr).Value, scopeOfTheContainingExpression);
		case BoundKind.ObjectInitializerExpression:
		{
			BoundObjectInitializerExpression initExpr = (BoundObjectInitializerExpression)expr;
			return GetValEscapeOfObjectInitializer(initExpr, scopeOfTheContainingExpression);
		}
		case BoundKind.CollectionInitializerExpression:
		{
			BoundCollectionInitializerExpression boundCollectionInitializerExpression = (BoundCollectionInitializerExpression)expr;
			return GetValEscape(boundCollectionInitializerExpression.Initializers, scopeOfTheContainingExpression);
		}
		case BoundKind.CollectionElementInitializer:
		{
			BoundCollectionElementInitializer boundCollectionElementInitializer = (BoundCollectionElementInitializer)expr;
			return GetValEscape(boundCollectionElementInitializer.Arguments, scopeOfTheContainingExpression);
		}
		case BoundKind.ObjectInitializerMember:
			return scopeOfTheContainingExpression;
		case BoundKind.ObjectOrCollectionValuePlaceholder:
		case BoundKind.ImplicitReceiver:
			return scopeOfTheContainingExpression;
		case BoundKind.InterpolatedStringHandlerPlaceholder:
			return scopeOfTheContainingExpression;
		case BoundKind.DisposableValuePlaceholder:
			return scopeOfTheContainingExpression;
		case BoundKind.PointerIndirectionOperator:
		case BoundKind.PointerElementAccess:
			return 0u;
		case BoundKind.ArrayAccess:
		case BoundKind.AwaitExpression:
		case BoundKind.AsOperator:
		case BoundKind.ConditionalAccess:
		case BoundKind.ConditionalReceiver:
			return scopeOfTheContainingExpression;
		case BoundKind.UnconvertedSwitchExpression:
		case BoundKind.ConvertedSwitchExpression:
		{
			BoundSwitchExpression boundSwitchExpression = (BoundSwitchExpression)expr;
			return GetValEscape(ImmutableArrayExtensions.SelectAsArray<BoundSwitchExpressionArm, BoundExpression>(boundSwitchExpression.SwitchArms, (Func<BoundSwitchExpressionArm, BoundExpression>)((BoundSwitchExpressionArm a) => a.Value)), scopeOfTheContainingExpression);
		}
		default:
			return scopeOfTheContainingExpression;
		}
	}

	private bool HasLocalScope(BoundCollectionExpression expr)
	{
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_009f: Invalid comparison between Unknown and I4
		//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ab: Invalid comparison between Unknown and I4
		TypeSymbol type = expr.Type;
		if ((object)type == null || !type.IsRefLikeType || expr.Elements.Length == 0)
		{
			return false;
		}
		TypeWithAnnotations elementType;
		CollectionExpressionTypeKind collectionExpressionTypeKind = ConversionsBase.GetCollectionExpressionTypeKind(_compilation, expr.Type, out elementType);
		switch (collectionExpressionTypeKind)
		{
		case CollectionExpressionTypeKind.ReadOnlySpan:
			return !LocalRewriter.ShouldUseRuntimeHelpersCreateSpan(expr, elementType.Type);
		case CollectionExpressionTypeKind.Span:
			return true;
		case CollectionExpressionTypeKind.CollectionBuilder:
		{
			MethodSymbol collectionBuilderMethod = expr.CollectionBuilderMethod;
			if ((object)collectionBuilderMethod != null)
			{
				ImmutableArray<ParameterSymbol> parameters = collectionBuilderMethod.Parameters;
				if (parameters.Length == 1)
				{
					ParameterSymbol parameterSymbol = parameters[0];
					if ((object)parameterSymbol != null && (int)parameterSymbol.RefKind == 0)
					{
						if ((int)parameterSymbol.EffectiveScope == 2)
						{
							return false;
						}
						if (LocalRewriter.ShouldUseRuntimeHelpersCreateSpan(expr, ((NamedTypeSymbol)parameterSymbol.Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type))
						{
							return false;
						}
						return true;
					}
				}
			}
			return true;
		}
		default:
			throw ExceptionUtilities.UnexpectedValue((object)collectionExpressionTypeKind);
		}
	}

	private uint GetTupleValEscape(ImmutableArray<BoundExpression> elements, uint scopeOfTheContainingExpression)
	{
		uint num = scopeOfTheContainingExpression;
		ImmutableArray<BoundExpression>.Enumerator enumerator = elements.GetEnumerator();
		while (enumerator.MoveNext())
		{
			BoundExpression current = enumerator.Current;
			num = Math.Max(num, GetValEscape(current, scopeOfTheContainingExpression));
		}
		return num;
	}

	private uint GetValEscapeOfObjectInitializer(BoundObjectInitializerExpression initExpr, uint scopeOfTheContainingExpression)
	{
		uint num = 0u;
		ImmutableArray<BoundExpression>.Enumerator enumerator = initExpr.Initializers.GetEnumerator();
		while (enumerator.MoveNext())
		{
			BoundExpression current = enumerator.Current;
			if (current.Kind == BoundKind.AssignmentOperator)
			{
				BoundAssignmentOperator boundAssignmentOperator = (BoundAssignmentOperator)current;
				uint val = (boundAssignmentOperator.IsRef ? GetRefEscape(boundAssignmentOperator.Right, scopeOfTheContainingExpression) : GetValEscape(boundAssignmentOperator.Right, scopeOfTheContainingExpression));
				num = Math.Max(num, val);
				BoundObjectInitializerMember boundObjectInitializerMember = (BoundObjectInitializerMember)boundAssignmentOperator.Left;
				num = Math.Max(num, GetValEscape(boundObjectInitializerMember.Arguments, scopeOfTheContainingExpression));
			}
			else
			{
				num = Math.Max(num, GetValEscape(current, scopeOfTheContainingExpression));
			}
		}
		return num;
	}

	private uint GetValEscape(ImmutableArray<BoundExpression> expressions, uint scopeOfTheContainingExpression)
	{
		uint num = 0u;
		ImmutableArray<BoundExpression>.Enumerator enumerator = expressions.GetEnumerator();
		while (enumerator.MoveNext())
		{
			BoundExpression current = enumerator.Current;
			num = Math.Max(num, GetValEscape(current, scopeOfTheContainingExpression));
		}
		return num;
	}

	internal bool CheckValEscape(SyntaxNode node, BoundExpression expr, uint escapeFrom, uint escapeTo, bool checkingReceiver, BindingDiagnosticBag diagnostics)
	{
		//IL_04a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_06c5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0549: Unknown result type (might be due to invalid IL or missing references)
		//IL_05cd: Unknown result type (might be due to invalid IL or missing references)
		//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
		//IL_0298: Unknown result type (might be due to invalid IL or missing references)
		//IL_0336: Unknown result type (might be due to invalid IL or missing references)
		//IL_061a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0826: Unknown result type (might be due to invalid IL or missing references)
		if (escapeTo >= escapeFrom)
		{
			return true;
		}
		if (expr.HasAnyErrors)
		{
			return true;
		}
		if (expr.ConstantValueOpt != (ConstantValue)null)
		{
			return true;
		}
		TypeSymbol? type = expr.Type;
		if ((object)type == null || !type.IsRefLikeType)
		{
			return true;
		}
		bool inUnsafeRegion = _inUnsafeRegion;
		switch (expr.Kind)
		{
		case BoundKind.ThisReference:
		{
			ParameterSymbol thisParameter = _symbol.ThisParameter;
			return CheckParameterValEscape(node, thisParameter, escapeTo, diagnostics);
		}
		case BoundKind.DefaultLiteral:
		case BoundKind.DefaultExpression:
		case BoundKind.Utf8String:
			return true;
		case BoundKind.Parameter:
			return CheckParameterValEscape(node, ((BoundParameter)expr).ParameterSymbol, escapeTo, diagnostics);
		case BoundKind.TupleLiteral:
		case BoundKind.ConvertedTupleLiteral:
		{
			BoundTupleExpression boundTupleExpression = (BoundTupleExpression)expr;
			return CheckTupleValEscape(boundTupleExpression.Arguments, escapeFrom, escapeTo, diagnostics);
		}
		case BoundKind.MakeRefOperator:
		case BoundKind.RefValueOperator:
			return true;
		case BoundKind.DiscardExpression:
			return true;
		case BoundKind.DeconstructValuePlaceholder:
		case BoundKind.AwaitableValuePlaceholder:
		case BoundKind.InterpolatedStringArgumentPlaceholder:
			if (GetPlaceholderScope((BoundValuePlaceholderBase)expr) > escapeTo)
			{
				Error(diagnostics, inUnsafeRegion ? ErrorCode.WRN_EscapeVariable : ErrorCode.ERR_EscapeVariable, SyntaxNodeOrToken.op_Implicit(node), expr.Syntax);
				return inUnsafeRegion;
			}
			return true;
		case BoundKind.Local:
		{
			LocalSymbol localSymbol = ((BoundLocal)expr).LocalSymbol;
			if (GetLocalScopes(localSymbol).ValEscapeScope > escapeTo)
			{
				Error(diagnostics, inUnsafeRegion ? ErrorCode.WRN_EscapeVariable : ErrorCode.ERR_EscapeVariable, SyntaxNodeOrToken.op_Implicit(node), localSymbol);
				return inUnsafeRegion;
			}
			return true;
		}
		case BoundKind.CapturedReceiverPlaceholder:
		{
			BoundExpression receiver = ((BoundCapturedReceiverPlaceholder)expr).Receiver;
			return CheckValEscape(receiver.Syntax, receiver, escapeFrom, escapeTo, checkingReceiver, diagnostics);
		}
		case BoundKind.StackAllocArrayCreation:
		case BoundKind.ConvertedStackAllocExpression:
			if (escapeTo < 2)
			{
				Error(diagnostics, inUnsafeRegion ? ErrorCode.WRN_EscapeStackAlloc : ErrorCode.ERR_EscapeStackAlloc, SyntaxNodeOrToken.op_Implicit(node), expr.Type);
				return inUnsafeRegion;
			}
			return true;
		case BoundKind.UnconvertedConditionalOperator:
		{
			BoundUnconvertedConditionalOperator boundUnconvertedConditionalOperator = (BoundUnconvertedConditionalOperator)expr;
			if (CheckValEscape(boundUnconvertedConditionalOperator.Consequence.Syntax, boundUnconvertedConditionalOperator.Consequence, escapeFrom, escapeTo, checkingReceiver: false, diagnostics))
			{
				return CheckValEscape(boundUnconvertedConditionalOperator.Alternative.Syntax, boundUnconvertedConditionalOperator.Alternative, escapeFrom, escapeTo, checkingReceiver: false, diagnostics);
			}
			return false;
		}
		case BoundKind.ConditionalOperator:
		{
			BoundConditionalOperator boundConditionalOperator = (BoundConditionalOperator)expr;
			bool flag2 = CheckValEscape(boundConditionalOperator.Consequence.Syntax, boundConditionalOperator.Consequence, escapeFrom, escapeTo, checkingReceiver: false, diagnostics);
			if (!flag2 || boundConditionalOperator.IsRef)
			{
				return flag2;
			}
			return CheckValEscape(boundConditionalOperator.Alternative.Syntax, boundConditionalOperator.Alternative, escapeFrom, escapeTo, checkingReceiver: false, diagnostics);
		}
		case BoundKind.NullCoalescingOperator:
		{
			BoundNullCoalescingOperator boundNullCoalescingOperator = (BoundNullCoalescingOperator)expr;
			if (CheckValEscape(boundNullCoalescingOperator.LeftOperand.Syntax, boundNullCoalescingOperator.LeftOperand, escapeFrom, escapeTo, checkingReceiver, diagnostics))
			{
				return CheckValEscape(boundNullCoalescingOperator.RightOperand.Syntax, boundNullCoalescingOperator.RightOperand, escapeFrom, escapeTo, checkingReceiver, diagnostics);
			}
			return false;
		}
		case BoundKind.FieldAccess:
		{
			BoundFieldAccess boundFieldAccess = (BoundFieldAccess)expr;
			FieldSymbol fieldSymbol = boundFieldAccess.FieldSymbol;
			if (fieldSymbol.IsStatic || !fieldSymbol.ContainingType.IsRefLikeType)
			{
				return true;
			}
			return CheckValEscape(node, boundFieldAccess.ReceiverOpt, escapeFrom, escapeTo, checkingReceiver: true, diagnostics);
		}
		case BoundKind.Call:
		{
			BoundCall boundCall2 = (BoundCall)expr;
			MethodSymbol method2 = boundCall2.Method;
			return CheckInvocationEscape(boundCall2.Syntax, method2, boundCall2.ReceiverOpt, boundCall2.InitialBindingReceiverIsSubjectToCloning, method2.Parameters, boundCall2.Arguments, boundCall2.ArgumentRefKindsOpt, boundCall2.ArgsToParamsOpt, checkingReceiver, escapeFrom, escapeTo, diagnostics, isRefEscape: false);
		}
		case BoundKind.FunctionPointerInvocation:
		{
			BoundFunctionPointerInvocation boundFunctionPointerInvocation = (BoundFunctionPointerInvocation)expr;
			FunctionPointerMethodSymbol signature = boundFunctionPointerInvocation.FunctionPointer.Signature;
			return CheckInvocationEscape(boundFunctionPointerInvocation.Syntax, signature, null, (ThreeState)0, signature.Parameters, boundFunctionPointerInvocation.Arguments, boundFunctionPointerInvocation.ArgumentRefKindsOpt, default(ImmutableArray<int>), checkingReceiver, escapeFrom, escapeTo, diagnostics, isRefEscape: false);
		}
		case BoundKind.IndexerAccess:
		{
			BoundIndexerAccess boundIndexerAccess2 = (BoundIndexerAccess)expr;
			PropertySymbol indexer2 = boundIndexerAccess2.Indexer;
			return CheckInvocationEscape(boundIndexerAccess2.Syntax, indexer2, boundIndexerAccess2.ReceiverOpt, boundIndexerAccess2.InitialBindingReceiverIsSubjectToCloning, indexer2.Parameters, boundIndexerAccess2.Arguments, boundIndexerAccess2.ArgumentRefKindsOpt, boundIndexerAccess2.ArgsToParamsOpt, checkingReceiver, escapeFrom, escapeTo, diagnostics, isRefEscape: false);
		}
		case BoundKind.ImplicitIndexerAccess:
		{
			BoundImplicitIndexerAccess boundImplicitIndexerAccess = (BoundImplicitIndexerAccess)expr;
			BoundExpression indexerOrSliceAccess = boundImplicitIndexerAccess.IndexerOrSliceAccess;
			if (!(indexerOrSliceAccess is BoundIndexerAccess boundIndexerAccess))
			{
				if (!(indexerOrSliceAccess is BoundArrayAccess))
				{
					if (indexerOrSliceAccess is BoundCall boundCall)
					{
						MethodSymbol method = boundCall.Method;
						return CheckInvocationEscape(boundCall.Syntax, method, boundImplicitIndexerAccess.Receiver, boundCall.InitialBindingReceiverIsSubjectToCloning, method.Parameters, boundCall.Arguments, boundCall.ArgumentRefKindsOpt, boundCall.ArgsToParamsOpt, checkingReceiver, escapeFrom, escapeTo, diagnostics, isRefEscape: false);
					}
					throw ExceptionUtilities.UnexpectedValue((object)boundImplicitIndexerAccess.IndexerOrSliceAccess.Kind);
				}
				return false;
			}
			PropertySymbol indexer = boundIndexerAccess.Indexer;
			return CheckInvocationEscape(boundIndexerAccess.Syntax, indexer, boundImplicitIndexerAccess.Receiver, boundIndexerAccess.InitialBindingReceiverIsSubjectToCloning, indexer.Parameters, boundIndexerAccess.Arguments, boundIndexerAccess.ArgumentRefKindsOpt, boundIndexerAccess.ArgsToParamsOpt, checkingReceiver, escapeFrom, escapeTo, diagnostics, isRefEscape: false);
		}
		case BoundKind.InlineArrayAccess:
		{
			BoundInlineArrayAccess boundInlineArrayAccess = (BoundInlineArrayAccess)expr;
			ImmutableArray<BoundExpression> arguments;
			ImmutableArray<RefKind> refKinds;
			SignatureOnlyMethodSymbol inlineArrayAccessEquivalentSignatureMethod = GetInlineArrayAccessEquivalentSignatureMethod(boundInlineArrayAccess, out arguments, out refKinds);
			return CheckInvocationEscape(boundInlineArrayAccess.Syntax, inlineArrayAccessEquivalentSignatureMethod, null, (ThreeState)0, inlineArrayAccessEquivalentSignatureMethod.Parameters, arguments, refKinds, default(ImmutableArray<int>), checkingReceiver, escapeFrom, escapeTo, diagnostics, isRefEscape: false);
		}
		case BoundKind.PropertyAccess:
		{
			BoundPropertyAccess boundPropertyAccess = (BoundPropertyAccess)expr;
			return CheckInvocationEscape(boundPropertyAccess.Syntax, boundPropertyAccess.PropertySymbol, boundPropertyAccess.ReceiverOpt, boundPropertyAccess.InitialBindingReceiverIsSubjectToCloning, default(ImmutableArray<ParameterSymbol>), default(ImmutableArray<BoundExpression>), default(ImmutableArray<RefKind>), default(ImmutableArray<int>), checkingReceiver, escapeFrom, escapeTo, diagnostics, isRefEscape: false);
		}
		case BoundKind.ObjectCreationExpression:
		{
			BoundObjectCreationExpression boundObjectCreationExpression = (BoundObjectCreationExpression)expr;
			MethodSymbol constructor = boundObjectCreationExpression.Constructor;
			bool flag = CheckInvocationEscape(boundObjectCreationExpression.Syntax, constructor, null, (ThreeState)0, constructor.Parameters, boundObjectCreationExpression.Arguments, boundObjectCreationExpression.ArgumentRefKindsOpt, boundObjectCreationExpression.ArgsToParamsOpt, checkingReceiver, escapeFrom, escapeTo, diagnostics, isRefEscape: false);
			BoundObjectInitializerExpressionBase initializerExpressionOpt = boundObjectCreationExpression.InitializerExpressionOpt;
			if (initializerExpressionOpt != null)
			{
				flag = flag && CheckValEscape(initializerExpressionOpt.Syntax, initializerExpressionOpt, escapeFrom, escapeTo, checkingReceiver: false, diagnostics);
			}
			return flag;
		}
		case BoundKind.WithExpression:
		{
			BoundWithExpression boundWithExpression = (BoundWithExpression)expr;
			bool num = CheckValEscape(node, boundWithExpression.Receiver, escapeFrom, escapeTo, checkingReceiver: false, diagnostics);
			BoundObjectInitializerExpressionBase initializerExpression = boundWithExpression.InitializerExpression;
			if (num)
			{
				return CheckValEscape(initializerExpression.Syntax, initializerExpression, escapeFrom, escapeTo, checkingReceiver: false, diagnostics);
			}
			return false;
		}
		case BoundKind.UnaryOperator:
		{
			BoundUnaryOperator boundUnaryOperator = (BoundUnaryOperator)expr;
			return CheckValEscape(node, boundUnaryOperator.Operand, escapeFrom, escapeTo, checkingReceiver: false, diagnostics);
		}
		case BoundKind.FromEndIndexExpression:
			return true;
		case BoundKind.Conversion:
		{
			BoundConversion boundConversion = (BoundConversion)expr;
			if (boundConversion.ConversionKind == ConversionKind.InterpolatedStringHandler)
			{
				return CheckInterpolatedStringHandlerConversionEscape(boundConversion.Operand, escapeFrom, escapeTo, diagnostics);
			}
			if (boundConversion.ConversionKind == ConversionKind.CollectionExpression)
			{
				if (HasLocalScope((BoundCollectionExpression)boundConversion.Operand) && escapeTo < 2)
				{
					Error(diagnostics, ErrorCode.ERR_CollectionExpressionEscape, SyntaxNodeOrToken.op_Implicit(node), expr.Type);
					return false;
				}
				return true;
			}
			if (boundConversion.Conversion.IsInlineArray)
			{
				ImmutableArray<BoundExpression> arguments2;
				ImmutableArray<RefKind> refKinds2;
				SignatureOnlyMethodSymbol inlineArrayConversionEquivalentSignatureMethod = GetInlineArrayConversionEquivalentSignatureMethod(boundConversion, out arguments2, out refKinds2);
				return CheckInvocationEscape(boundConversion.Syntax, inlineArrayConversionEquivalentSignatureMethod, null, (ThreeState)0, inlineArrayConversionEquivalentSignatureMethod.Parameters, arguments2, refKinds2, default(ImmutableArray<int>), checkingReceiver, escapeFrom, escapeTo, diagnostics, isRefEscape: false);
			}
			return CheckValEscape(node, boundConversion.Operand, escapeFrom, escapeTo, checkingReceiver: false, diagnostics);
		}
		case BoundKind.AssignmentOperator:
		{
			BoundAssignmentOperator boundAssignmentOperator = (BoundAssignmentOperator)expr;
			return CheckValEscape(node, boundAssignmentOperator.Left, escapeFrom, escapeTo, checkingReceiver: false, diagnostics);
		}
		case BoundKind.IncrementOperator:
		{
			BoundIncrementOperator boundIncrementOperator = (BoundIncrementOperator)expr;
			return CheckValEscape(node, boundIncrementOperator.Operand, escapeFrom, escapeTo, checkingReceiver: false, diagnostics);
		}
		case BoundKind.CompoundAssignmentOperator:
		{
			BoundCompoundAssignmentOperator boundCompoundAssignmentOperator = (BoundCompoundAssignmentOperator)expr;
			if (CheckValEscape(boundCompoundAssignmentOperator.Left.Syntax, boundCompoundAssignmentOperator.Left, escapeFrom, escapeTo, checkingReceiver: false, diagnostics))
			{
				return CheckValEscape(boundCompoundAssignmentOperator.Right.Syntax, boundCompoundAssignmentOperator.Right, escapeFrom, escapeTo, checkingReceiver: false, diagnostics);
			}
			return false;
		}
		case BoundKind.BinaryOperator:
		{
			BoundBinaryOperator boundBinaryOperator = (BoundBinaryOperator)expr;
			if (boundBinaryOperator.OperatorKind == BinaryOperatorKind.Utf8Addition)
			{
				return true;
			}
			if (CheckValEscape(boundBinaryOperator.Left.Syntax, boundBinaryOperator.Left, escapeFrom, escapeTo, checkingReceiver: false, diagnostics))
			{
				return CheckValEscape(boundBinaryOperator.Right.Syntax, boundBinaryOperator.Right, escapeFrom, escapeTo, checkingReceiver: false, diagnostics);
			}
			return false;
		}
		case BoundKind.RangeExpression:
		{
			BoundRangeExpression boundRangeExpression = (BoundRangeExpression)expr;
			BoundExpression leftOperandOpt = boundRangeExpression.LeftOperandOpt;
			if (leftOperandOpt != null && !CheckValEscape(leftOperandOpt.Syntax, leftOperandOpt, escapeFrom, escapeTo, checkingReceiver: false, diagnostics))
			{
				return false;
			}
			BoundExpression rightOperandOpt = boundRangeExpression.RightOperandOpt;
			if (rightOperandOpt != null)
			{
				return CheckValEscape(rightOperandOpt.Syntax, rightOperandOpt, escapeFrom, escapeTo, checkingReceiver: false, diagnostics);
			}
			return true;
		}
		case BoundKind.UserDefinedConditionalLogicalOperator:
		{
			BoundUserDefinedConditionalLogicalOperator boundUserDefinedConditionalLogicalOperator = (BoundUserDefinedConditionalLogicalOperator)expr;
			if (CheckValEscape(boundUserDefinedConditionalLogicalOperator.Left.Syntax, boundUserDefinedConditionalLogicalOperator.Left, escapeFrom, escapeTo, checkingReceiver: false, diagnostics))
			{
				return CheckValEscape(boundUserDefinedConditionalLogicalOperator.Right.Syntax, boundUserDefinedConditionalLogicalOperator.Right, escapeFrom, escapeTo, checkingReceiver: false, diagnostics);
			}
			return false;
		}
		case BoundKind.QueryClause:
		{
			BoundExpression value3 = ((BoundQueryClause)expr).Value;
			return CheckValEscape(value3.Syntax, value3, escapeFrom, escapeTo, checkingReceiver: false, diagnostics);
		}
		case BoundKind.RangeVariable:
		{
			BoundExpression value2 = ((BoundRangeVariable)expr).Value;
			return CheckValEscape(value2.Syntax, value2, escapeFrom, escapeTo, checkingReceiver: false, diagnostics);
		}
		case BoundKind.ObjectInitializerExpression:
		{
			BoundObjectInitializerExpression initExpr = (BoundObjectInitializerExpression)expr;
			return CheckValEscapeOfObjectInitializer(initExpr, escapeFrom, escapeTo, diagnostics);
		}
		case BoundKind.CollectionInitializerExpression:
		{
			BoundCollectionInitializerExpression boundCollectionInitializerExpression = (BoundCollectionInitializerExpression)expr;
			return CheckValEscape(boundCollectionInitializerExpression.Initializers, escapeFrom, escapeTo, diagnostics);
		}
		case BoundKind.CollectionElementInitializer:
		{
			BoundCollectionElementInitializer boundCollectionElementInitializer = (BoundCollectionElementInitializer)expr;
			return CheckValEscape(boundCollectionElementInitializer.Arguments, escapeFrom, escapeTo, diagnostics);
		}
		case BoundKind.PointerElementAccess:
		{
			BoundExpression expression = ((BoundPointerElementAccess)expr).Expression;
			return CheckValEscape(expression.Syntax, expression, escapeFrom, escapeTo, checkingReceiver, diagnostics);
		}
		case BoundKind.PointerIndirectionOperator:
		{
			BoundExpression operand = ((BoundPointerIndirectionOperator)expr).Operand;
			return CheckValEscape(operand.Syntax, operand, escapeFrom, escapeTo, checkingReceiver, diagnostics);
		}
		case BoundKind.ArrayAccess:
		case BoundKind.AwaitExpression:
		case BoundKind.AsOperator:
		case BoundKind.ConditionalAccess:
			return false;
		case BoundKind.UnconvertedSwitchExpression:
		case BoundKind.ConvertedSwitchExpression:
		{
			ImmutableArray<BoundSwitchExpressionArm>.Enumerator enumerator = ((BoundSwitchExpression)expr).SwitchArms.GetEnumerator();
			while (enumerator.MoveNext())
			{
				BoundExpression value = enumerator.Current.Value;
				if (!CheckValEscape(value.Syntax, value, escapeFrom, escapeTo, checkingReceiver: false, diagnostics))
				{
					return false;
				}
			}
			return true;
		}
		default:
			diagnostics.Add(ErrorCode.ERR_InternalError, node.Location);
			return false;
		}
	}

	private SignatureOnlyMethodSymbol GetInlineArrayAccessEquivalentSignatureMethod(BoundInlineArrayAccess elementAccess, out ImmutableArray<BoundExpression> arguments, out ImmutableArray<RefKind> refKinds)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Invalid comparison between Unknown and I4
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: Invalid comparison between Unknown and I4
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Invalid comparison between Unknown and I4
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Invalid comparison between Unknown and I4
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Invalid comparison between Unknown and I4
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_0108: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: Unknown result type (might be due to invalid IL or missing references)
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Invalid comparison between Unknown and I4
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_0077: Unknown result type (might be due to invalid IL or missing references)
		WellKnownMember getItemOrSliceHelper = elementAccess.GetItemOrSliceHelper;
		RefKind val;
		RefKind val2;
		if (((int)getItemOrSliceHelper == 400 || (int)getItemOrSliceHelper == 406) ? true : false)
		{
			if (elementAccess.IsValue)
			{
				val = (RefKind)0;
				val2 = (RefKind)0;
			}
			else
			{
				val = (RefKind)(((int)elementAccess.GetItemOrSliceHelper != 406) ? 1 : 3);
				val2 = val;
			}
		}
		else
		{
			getItemOrSliceHelper = elementAccess.GetItemOrSliceHelper;
			if (((int)getItemOrSliceHelper != 402 && (int)getItemOrSliceHelper != 408) || 1 == 0)
			{
				throw ExceptionUtilities.Unreachable("/_/src/Compilers/CSharp/Portable/Binder/Binder.ValueChecks.cs", 4765);
			}
			val = (RefKind)0;
			val2 = (RefKind)(((int)elementAccess.GetItemOrSliceHelper != 408) ? 1 : 3);
		}
		SignatureOnlyMethodSymbol result = new SignatureOnlyMethodSymbol("", _symbol.ContainingType, (MethodKind)10, (CallingConvention)0, ImmutableArray<TypeParameterSymbol>.Empty, ImmutableArray.Create((ParameterSymbol)new SignatureOnlyParameterSymbol(TypeWithAnnotations.Create(elementAccess.Expression.Type), ImmutableArray<CustomModifier>.Empty, isParams: false, val2)), val, isInitOnly: false, isStatic: true, TypeWithAnnotations.Create(elementAccess.Type), ImmutableArray<CustomModifier>.Empty, ImmutableArray<MethodSymbol>.Empty);
		arguments = ImmutableArray.Create(elementAccess.Expression);
		refKinds = ImmutableArray.Create<RefKind>(val2);
		return result;
	}

	private SignatureOnlyMethodSymbol GetInlineArrayConversionEquivalentSignatureMethod(BoundConversion conversion, out ImmutableArray<BoundExpression> arguments, out ImmutableArray<RefKind> refKinds)
	{
		return GetInlineArrayConversionEquivalentSignatureMethod(conversion.Operand, conversion.Type, out arguments, out refKinds);
	}

	private SignatureOnlyMethodSymbol GetInlineArrayConversionEquivalentSignatureMethod(BoundExpression inlineArray, TypeSymbol resultType, out ImmutableArray<BoundExpression> arguments, out ImmutableArray<RefKind> refKinds)
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_0092: Unknown result type (might be due to invalid IL or missing references)
		RefKind val = (RefKind)((!resultType.OriginalDefinition.Equals(_compilation.GetWellKnownType((WellKnownType)276), (TypeCompareKind)63)) ? 1 : 3);
		SignatureOnlyMethodSymbol result = new SignatureOnlyMethodSymbol("", _symbol.ContainingType, (MethodKind)10, (CallingConvention)0, ImmutableArray<TypeParameterSymbol>.Empty, ImmutableArray.Create((ParameterSymbol)new SignatureOnlyParameterSymbol(TypeWithAnnotations.Create(inlineArray.Type), ImmutableArray<CustomModifier>.Empty, isParams: false, val)), (RefKind)0, isInitOnly: false, isStatic: true, TypeWithAnnotations.Create(resultType), ImmutableArray<CustomModifier>.Empty, ImmutableArray<MethodSymbol>.Empty);
		arguments = ImmutableArray.Create(inlineArray);
		refKinds = ImmutableArray.Create<RefKind>(val);
		return result;
	}

	private bool CheckTupleValEscape(ImmutableArray<BoundExpression> elements, uint escapeFrom, uint escapeTo, BindingDiagnosticBag diagnostics)
	{
		ImmutableArray<BoundExpression>.Enumerator enumerator = elements.GetEnumerator();
		while (enumerator.MoveNext())
		{
			BoundExpression current = enumerator.Current;
			if (!CheckValEscape(current.Syntax, current, escapeFrom, escapeTo, checkingReceiver: false, diagnostics))
			{
				return false;
			}
		}
		return true;
	}

	private bool CheckValEscapeOfObjectInitializer(BoundObjectInitializerExpression initExpr, uint escapeFrom, uint escapeTo, BindingDiagnosticBag diagnostics)
	{
		ImmutableArray<BoundExpression>.Enumerator enumerator = initExpr.Initializers.GetEnumerator();
		while (enumerator.MoveNext())
		{
			BoundExpression current = enumerator.Current;
			if (current.Kind == BoundKind.AssignmentOperator)
			{
				BoundAssignmentOperator boundAssignmentOperator = (BoundAssignmentOperator)current;
				if (!(boundAssignmentOperator.IsRef ? CheckRefEscape(current.Syntax, boundAssignmentOperator.Right, escapeFrom, escapeTo, checkingReceiver: false, diagnostics) : CheckValEscape(current.Syntax, boundAssignmentOperator.Right, escapeFrom, escapeTo, checkingReceiver: false, diagnostics)))
				{
					return false;
				}
				BoundObjectInitializerMember boundObjectInitializerMember = (BoundObjectInitializerMember)boundAssignmentOperator.Left;
				if (!CheckValEscape(boundObjectInitializerMember.Arguments, escapeFrom, escapeTo, diagnostics))
				{
					return false;
				}
			}
			else if (!CheckValEscape(current.Syntax, current, escapeFrom, escapeTo, checkingReceiver: false, diagnostics))
			{
				return false;
			}
		}
		return true;
	}

	private bool CheckValEscape(ImmutableArray<BoundExpression> expressions, uint escapeFrom, uint escapeTo, BindingDiagnosticBag diagnostics)
	{
		ImmutableArray<BoundExpression>.Enumerator enumerator = expressions.GetEnumerator();
		while (enumerator.MoveNext())
		{
			BoundExpression current = enumerator.Current;
			if (!CheckValEscape(current.Syntax, current, escapeFrom, escapeTo, checkingReceiver: false, diagnostics))
			{
				return false;
			}
		}
		return true;
	}

	private bool CheckInterpolatedStringHandlerConversionEscape(BoundExpression expression, uint escapeFrom, uint escapeTo, BindingDiagnosticBag diagnostics)
	{
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		InterpolatedStringHandlerData interpolatedStringHandlerData = expression.GetInterpolatedStringHandlerData();
		CheckValEscape(expression.Syntax, interpolatedStringHandlerData.Construction, escapeFrom, escapeTo, checkingReceiver: false, diagnostics);
		ArrayBuilder<BoundExpression> instance = ArrayBuilder<BoundExpression>.GetInstance();
		GetInterpolatedStringHandlerArgumentsForEscape(expression, instance);
		bool result = true;
		Enumerator<BoundExpression> enumerator = instance.GetEnumerator();
		while (enumerator.MoveNext())
		{
			BoundExpression current = enumerator.Current;
			if (!CheckValEscape(current.Syntax, current, escapeFrom, escapeTo, checkingReceiver: false, diagnostics))
			{
				result = false;
				break;
			}
		}
		instance.Free();
		return result;
	}

	private void GetInterpolatedStringHandlerArgumentsForEscape(BoundExpression expression, ArrayBuilder<BoundExpression> arguments)
	{
		while (expression is BoundBinaryOperator boundBinaryOperator)
		{
			GetInterpolatedStringHandlerArgumentsForEscape(boundBinaryOperator.Right, arguments);
			expression = boundBinaryOperator.Left;
		}
		if (expression is BoundInterpolatedString interpolatedString)
		{
			getParts(interpolatedString);
			return;
		}
		throw ExceptionUtilities.UnexpectedValue((object)expression.Kind);
		void getParts(BoundInterpolatedString boundInterpolatedString)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Invalid comparison between Unknown and I4
			ImmutableArray<BoundExpression>.Enumerator enumerator = boundInterpolatedString.Parts.GetEnumerator();
			while (enumerator.MoveNext())
			{
				if (enumerator.Current is BoundCall boundCall)
				{
					MethodSymbol method = boundCall.Method;
					if ((object)method != null && method.Name == "AppendFormatted" && (!_useUpdatedEscapeRules || (int)boundCall.Method.Parameters[0].EffectiveScope != 2))
					{
						arguments.Add(boundCall.Arguments[0]);
					}
				}
			}
		}
	}

	private void ValidateRefConditionalOperator(SyntaxNode node, BoundExpression trueExpr, BoundExpression falseExpr, BindingDiagnosticBag diagnostics)
	{
		uint localScopeDepth = _localScopeDepth;
		uint valEscape = GetValEscape(trueExpr, localScopeDepth);
		uint valEscape2 = GetValEscape(falseExpr, localScopeDepth);
		if (valEscape != valEscape2)
		{
			if (valEscape < valEscape2)
			{
				CheckValEscape(falseExpr.Syntax, falseExpr, localScopeDepth, valEscape, checkingReceiver: false, diagnostics);
			}
			else
			{
				CheckValEscape(trueExpr.Syntax, trueExpr, localScopeDepth, valEscape2, checkingReceiver: false, diagnostics);
			}
			diagnostics.Add(_inUnsafeRegion ? ErrorCode.WRN_MismatchedRefEscapeInTernary : ErrorCode.ERR_MismatchedRefEscapeInTernary, node.Location);
		}
	}

	private void ValidateAssignment(SyntaxNode node, BoundExpression op1, BoundExpression op2, bool isRef, BindingDiagnosticBag diagnostics)
	{
		//IL_006e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
		if (op1.HasAnyErrors)
		{
			return;
		}
		bool flag = false;
		if (isRef)
		{
			uint refEscape = GetRefEscape(op1, _localScopeDepth);
			uint refEscape2 = GetRefEscape(op2, _localScopeDepth);
			if (refEscape < refEscape2)
			{
				bool inUnsafeRegion = _inUnsafeRegion;
				ErrorCode errorCode = ((refEscape2 == 1) ? (inUnsafeRegion ? ErrorCode.WRN_RefAssignReturnOnly : ErrorCode.ERR_RefAssignReturnOnly) : (inUnsafeRegion ? ErrorCode.WRN_RefAssignNarrower : ErrorCode.ERR_RefAssignNarrower));
				ErrorCode code = errorCode;
				Error(diagnostics, code, SyntaxNodeOrToken.op_Implicit(node), getName(op1), op2.Syntax);
				if (!_inUnsafeRegion)
				{
					flag = true;
				}
			}
			else
			{
				BoundKind kind = op1.Kind;
				if ((kind == BoundKind.Local || kind == BoundKind.Parameter) ? true : false)
				{
					uint valEscape = GetValEscape(op1, _localScopeDepth);
					refEscape2 = GetValEscape(op2, _localScopeDepth);
					if (valEscape > refEscape2)
					{
						ErrorCode code2 = (_inUnsafeRegion ? ErrorCode.WRN_RefAssignValEscapeWider : ErrorCode.ERR_RefAssignValEscapeWider);
						Error(diagnostics, code2, SyntaxNodeOrToken.op_Implicit(node), getName(op1), op2.Syntax);
						if (!_inUnsafeRegion)
						{
							flag = true;
						}
					}
				}
			}
		}
		if (!flag && op1.Type.IsRefLikeType)
		{
			uint valEscape2 = GetValEscape(op1, _localScopeDepth);
			ValidateEscape(op2, valEscape2, isByRef: false, diagnostics);
		}
		static object getName(BoundExpression expr)
		{
			Symbol expressionSymbol = expr.ExpressionSymbol;
			if ((object)expressionSymbol != null)
			{
				return expressionSymbol.Name;
			}
			if (expr is BoundArrayAccess)
			{
				return MessageID.IDS_ArrayAccess.Localize();
			}
			if (expr is BoundPointerElementAccess)
			{
				return MessageID.IDS_PointerElementAccess.Localize();
			}
			return "";
		}
	}

	internal static void Analyze(CSharpCompilation compilation, MethodSymbol symbol, BoundNode node, BindingDiagnosticBag diagnostics)
	{
		RefSafetyAnalysis refSafetyAnalysis = new RefSafetyAnalysis(compilation, symbol, InUnsafeMethod(symbol), symbol.ContainingModule.UseUpdatedEscapeRules, diagnostics);
		try
		{
			refSafetyAnalysis.Visit(node);
		}
		catch (CancelledByStackGuardException ex)
		{
			ex.AddAnError(diagnostics);
		}
	}

	private static bool InUnsafeMethod(Symbol symbol)
	{
		if (symbol is SourceMemberMethodSymbol { IsUnsafe: not false })
		{
			return true;
		}
		NamedTypeSymbol containingType = symbol.ContainingType;
		while ((object)containingType != null)
		{
			NamedTypeSymbol originalDefinition = containingType.OriginalDefinition;
			if (originalDefinition is SourceMemberContainerTypeSymbol { IsUnsafe: not false })
			{
				return true;
			}
			containingType = originalDefinition.ContainingType;
		}
		return false;
	}

	private RefSafetyAnalysis(CSharpCompilation compilation, MethodSymbol symbol, bool inUnsafeRegion, bool useUpdatedEscapeRules, BindingDiagnosticBag diagnostics, Dictionary<LocalSymbol, (uint RefEscapeScope, uint ValEscapeScope)>? localEscapeScopes = null)
	{
		_compilation = compilation;
		_symbol = symbol;
		_useUpdatedEscapeRules = useUpdatedEscapeRules;
		_diagnostics = diagnostics;
		_inUnsafeRegion = inUnsafeRegion;
		_localScopeDepth = 1u;
		_localEscapeScopes = localEscapeScopes;
	}

	private (uint RefEscapeScope, uint ValEscapeScope) GetLocalScopes(LocalSymbol local)
	{
		Dictionary<LocalSymbol, (uint RefEscapeScope, uint ValEscapeScope)>? localEscapeScopes = _localEscapeScopes;
		if (localEscapeScopes == null || !localEscapeScopes.TryGetValue(local, out (uint, uint) value))
		{
			return (RefEscapeScope: 0u, ValEscapeScope: 0u);
		}
		return value;
	}

	private void SetLocalScopes(LocalSymbol local, uint refEscapeScope, uint valEscapeScope)
	{
		AddOrSetLocalScopes(local, refEscapeScope, valEscapeScope);
	}

	private void AddPlaceholderScope(BoundValuePlaceholderBase placeholder, uint valEscapeScope)
	{
		if (_placeholderScopes == null)
		{
			_placeholderScopes = new Dictionary<BoundValuePlaceholderBase, uint>();
		}
		_placeholderScopes[placeholder] = valEscapeScope;
	}

	private void RemovePlaceholderScope(BoundValuePlaceholderBase placeholder)
	{
	}

	private uint GetPlaceholderScope(BoundValuePlaceholderBase placeholder)
	{
		Dictionary<BoundValuePlaceholderBase, uint>? placeholderScopes = _placeholderScopes;
		if (placeholderScopes == null || !placeholderScopes.TryGetValue(placeholder, out var value))
		{
			return 0u;
		}
		return value;
	}

	public override BoundNode? VisitBlock(BoundBlock node)
	{
		UnsafeRegion unsafeRegion = new UnsafeRegion(this, _inUnsafeRegion || node.HasUnsafeModifier);
		try
		{
			using (new LocalScope(this, node.Locals))
			{
				return base.VisitBlock(node);
			}
		}
		finally
		{
			unsafeRegion.Dispose();
		}
	}

	public override BoundNode? Visit(BoundNode? node)
	{
		return base.Visit(node);
	}

	public override BoundNode? VisitFieldEqualsValue(BoundFieldEqualsValue node)
	{
		throw ExceptionUtilities.Unreachable("/_/src/Compilers/CSharp/Portable/Binder/RefSafetyAnalysis.cs", 293);
	}

	public override BoundNode? VisitLocalFunctionStatement(BoundLocalFunctionStatement node)
	{
		LocalFunctionSymbol symbol = node.Symbol;
		RefSafetyAnalysis refSafetyAnalysis = new RefSafetyAnalysis(_compilation, symbol, _inUnsafeRegion || symbol.IsUnsafe, _useUpdatedEscapeRules, _diagnostics, _localEscapeScopes);
		refSafetyAnalysis.Visit(node.BlockBody);
		refSafetyAnalysis.Visit(node.ExpressionBody);
		return null;
	}

	public override BoundNode? VisitLambda(BoundLambda node)
	{
		LambdaSymbol symbol = node.Symbol;
		new RefSafetyAnalysis(_compilation, symbol, _inUnsafeRegion, _useUpdatedEscapeRules, _diagnostics, _localEscapeScopes).Visit(node.Body);
		return null;
	}

	public override BoundNode? VisitConstructorMethodBody(BoundConstructorMethodBody node)
	{
		using (new LocalScope(this, node.Locals))
		{
			return base.VisitConstructorMethodBody(node);
		}
	}

	public override BoundNode? VisitForStatement(BoundForStatement node)
	{
		using (new LocalScope(this, node.OuterLocals))
		{
			using (new LocalScope(this, node.InnerLocals))
			{
				return base.VisitForStatement(node);
			}
		}
	}

	public override BoundNode? VisitUsingStatement(BoundUsingStatement node)
	{
		using (new LocalScope(this, node.Locals))
		{
			Visit(node.DeclarationsOpt);
			Visit(node.ExpressionOpt);
			ArrayBuilder<(BoundValuePlaceholderBase, uint)> instance = ArrayBuilder<(BoundValuePlaceholderBase, uint)>.GetInstance();
			BoundAwaitableInfo awaitOpt = node.AwaitOpt;
			if (awaitOpt != null)
			{
				BoundExpression expressionOpt = node.ExpressionOpt;
				uint valEscapeScope = ((expressionOpt != null) ? GetValEscape(expressionOpt, _localScopeDepth) : _localScopeDepth);
				GetAwaitableInstancePlaceholders(instance, awaitOpt, valEscapeScope);
			}
			using (new PlaceholderRegion(this, instance))
			{
				Visit(node.AwaitOpt);
				Visit(node.Body);
				return null;
			}
		}
	}

	public override BoundNode? VisitUsingLocalDeclarations(BoundUsingLocalDeclarations node)
	{
		ArrayBuilder<(BoundValuePlaceholderBase, uint)> instance = ArrayBuilder<(BoundValuePlaceholderBase, uint)>.GetInstance();
		BoundAwaitableInfo awaitOpt = node.AwaitOpt;
		if (awaitOpt != null)
		{
			GetAwaitableInstancePlaceholders(instance, awaitOpt, _localScopeDepth);
		}
		using (new PlaceholderRegion(this, instance))
		{
			return base.VisitUsingLocalDeclarations(node);
		}
	}

	public override BoundNode? VisitFixedStatement(BoundFixedStatement node)
	{
		using (new LocalScope(this, node.Locals))
		{
			return base.VisitFixedStatement(node);
		}
	}

	public override BoundNode? VisitDoStatement(BoundDoStatement node)
	{
		using (new LocalScope(this, node.Locals))
		{
			return base.VisitDoStatement(node);
		}
	}

	public override BoundNode? VisitWhileStatement(BoundWhileStatement node)
	{
		using (new LocalScope(this, node.Locals))
		{
			return base.VisitWhileStatement(node);
		}
	}

	public override BoundNode? VisitSwitchStatement(BoundSwitchStatement node)
	{
		Visit(node.Expression);
		using (new LocalScope(this, node.InnerLocals))
		{
			using (new PatternInput(this, GetValEscape(node.Expression, _localScopeDepth)))
			{
				VisitList(node.SwitchSections);
				Visit(node.DefaultLabel);
				return null;
			}
		}
	}

	public override BoundNode? VisitConvertedSwitchExpression(BoundConvertedSwitchExpression node)
	{
		Visit(node.Expression);
		using (new PatternInput(this, GetValEscape(node.Expression, _localScopeDepth)))
		{
			VisitList(node.SwitchArms);
			return null;
		}
	}

	public override BoundNode? VisitSwitchSection(BoundSwitchSection node)
	{
		using (new LocalScope(this, node.Locals))
		{
			return base.VisitSwitchSection(node);
		}
	}

	public override BoundNode? VisitSwitchExpressionArm(BoundSwitchExpressionArm node)
	{
		using (new LocalScope(this, node.Locals))
		{
			return base.VisitSwitchExpressionArm(node);
		}
	}

	public override BoundNode? VisitCatchBlock(BoundCatchBlock node)
	{
		using (new LocalScope(this, node.Locals))
		{
			return base.VisitCatchBlock(node);
		}
	}

	public override BoundNode? VisitLocal(BoundLocal node)
	{
		return base.VisitLocal(node);
	}

	private void AddLocalScopes(LocalSymbol local, uint refEscapeScope, uint valEscapeScope)
	{
		//IL_000c: 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)
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Invalid comparison between Unknown and I4
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Invalid comparison between Unknown and I4
		ScopedKind val = (ScopedKind)(_useUpdatedEscapeRules ? ((int)local.Scope) : 0);
		if ((int)val != 0)
		{
			refEscapeScope = (((int)val == 1) ? _localScopeDepth : 2u);
			valEscapeScope = (((int)val == 2) ? _localScopeDepth : 0u);
		}
		AddOrSetLocalScopes(local, refEscapeScope, valEscapeScope);
	}

	private void AddOrSetLocalScopes(LocalSymbol local, uint refEscapeScope, uint valEscapeScope)
	{
		if (_localEscapeScopes == null)
		{
			_localEscapeScopes = new Dictionary<LocalSymbol, (uint, uint)>();
		}
		_localEscapeScopes[local] = (refEscapeScope, valEscapeScope);
	}

	private void RemoveLocalScopes(LocalSymbol local)
	{
	}

	public override BoundNode? VisitLocalDeclaration(BoundLocalDeclaration node)
	{
		//IL_0091: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		base.VisitLocalDeclaration(node);
		BoundExpression initializerOpt = node.InitializerOpt;
		if (initializerOpt != null)
		{
			SourceLocalSymbol sourceLocalSymbol = (SourceLocalSymbol)node.LocalSymbol;
			uint refEscapeScope;
			uint escapeTo;
			(refEscapeScope, escapeTo) = GetLocalScopes(sourceLocalSymbol);
			if (_useUpdatedEscapeRules && (int)sourceLocalSymbol.Scope != 0)
			{
				BoundTypeExpression? declaredTypeOpt = node.DeclaredTypeOpt;
				if (declaredTypeOpt != null && declaredTypeOpt.Type.IsRefLikeType)
				{
					ValidateEscape(initializerOpt, escapeTo, isByRef: false, _diagnostics);
				}
			}
			else
			{
				SetLocalScopes(sourceLocalSymbol, _localScopeDepth, _localScopeDepth);
				escapeTo = GetValEscape(initializerOpt, _localScopeDepth);
				if ((int)sourceLocalSymbol.RefKind != 0)
				{
					refEscapeScope = GetRefEscape(initializerOpt, _localScopeDepth);
				}
				SetLocalScopes(sourceLocalSymbol, refEscapeScope, escapeTo);
			}
		}
		return null;
	}

	public override BoundNode? VisitReturnStatement(BoundReturnStatement node)
	{
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Invalid comparison between Unknown and I4
		base.VisitReturnStatement(node);
		BoundExpression expressionOpt = node.ExpressionOpt;
		if (expressionOpt != null && (object)expressionOpt.Type != null)
		{
			ValidateEscape(expressionOpt, 1u, (int)node.RefKind > 0, _diagnostics);
		}
		return null;
	}

	public override BoundNode? VisitYieldReturnStatement(BoundYieldReturnStatement node)
	{
		base.VisitYieldReturnStatement(node);
		BoundExpression expression = node.Expression;
		if (expression != null && (object)expression.Type != null)
		{
			ValidateEscape(expression, 1u, isByRef: false, _diagnostics);
		}
		return null;
	}

	public override BoundNode? VisitAssignmentOperator(BoundAssignmentOperator node)
	{
		base.VisitAssignmentOperator(node);
		if (node.Left.Kind != BoundKind.DiscardExpression)
		{
			ValidateAssignment(node.Syntax, node.Left, node.Right, node.IsRef, _diagnostics);
		}
		return null;
	}

	public override BoundNode? VisitIsPatternExpression(BoundIsPatternExpression node)
	{
		Visit(node.Expression);
		using (new PatternInput(this, GetValEscape(node.Expression, _localScopeDepth)))
		{
			Visit(node.Pattern);
			return null;
		}
	}

	public override BoundNode? VisitDeclarationPattern(BoundDeclarationPattern node)
	{
		SetPatternLocalScopes(node);
		using (new PatternInput(this, getDeclarationValEscape(node.DeclaredType, _patternInputValEscape)))
		{
			return base.VisitDeclarationPattern(node);
		}
		static uint getDeclarationValEscape(BoundTypeExpression typeExpression, uint valEscape)
		{
			if (!typeExpression.Type.IsRefLikeType)
			{
				return 0u;
			}
			return valEscape;
		}
	}

	public override BoundNode? VisitListPattern(BoundListPattern node)
	{
		SetPatternLocalScopes(node);
		return base.VisitListPattern(node);
	}

	public override BoundNode? VisitRecursivePattern(BoundRecursivePattern node)
	{
		SetPatternLocalScopes(node);
		return base.VisitRecursivePattern(node);
	}

	public override BoundNode? VisitPositionalSubpattern(BoundPositionalSubpattern node)
	{
		using (new PatternInput(this, getPositionalValEscape(node.Symbol, _patternInputValEscape)))
		{
			return base.VisitPositionalSubpattern(node);
		}
		static uint getPositionalValEscape(Symbol? symbol, uint valEscape)
		{
			if ((object)symbol != null)
			{
				if (!symbol.GetTypeOrReturnType().IsRefLikeType())
				{
					return 0u;
				}
				return valEscape;
			}
			return valEscape;
		}
	}

	public override BoundNode? VisitPropertySubpattern(BoundPropertySubpattern node)
	{
		using (new PatternInput(this, getMemberValEscape(node.Member, _patternInputValEscape)))
		{
			return base.VisitPropertySubpattern(node);
		}
		static uint getMemberValEscape(BoundPropertySubpatternMember? member, uint valEscape)
		{
			if (member == null)
			{
				return valEscape;
			}
			valEscape = getMemberValEscape(member.Receiver, valEscape);
			if (!member.Type.IsRefLikeType)
			{
				return 0u;
			}
			return valEscape;
		}
	}

	private void SetPatternLocalScopes(BoundObjectPattern pattern)
	{
		if (pattern.Variable is LocalSymbol local)
		{
			SetLocalScopes(local, _localScopeDepth, _patternInputValEscape);
		}
	}

	public override BoundNode? VisitConditionalOperator(BoundConditionalOperator node)
	{
		base.VisitConditionalOperator(node);
		if (node.IsRef)
		{
			ValidateRefConditionalOperator(node.Syntax, node.Consequence, node.Alternative, _diagnostics);
		}
		return null;
	}

	private void VisitArgumentsAndGetArgumentPlaceholders(BoundExpression? receiverOpt, ImmutableArray<BoundExpression> arguments)
	{
		for (int num = 0; num < arguments.Length; num++)
		{
			BoundExpression boundExpression = arguments[num];
			BoundConversion boundConversion = boundExpression as BoundConversion;
			bool flag;
			if (boundConversion != null && boundConversion.ConversionKind == ConversionKind.InterpolatedStringHandler)
			{
				BoundExpression operand = boundConversion.Operand;
				if (operand is BoundInterpolatedString || operand is BoundBinaryOperator)
				{
					flag = true;
					goto IL_0040;
				}
			}
			flag = false;
			goto IL_0040;
			IL_0040:
			if (flag)
			{
				InterpolatedStringHandlerData interpolationData = boundConversion.Operand.GetInterpolatedStringHandlerData();
				ArrayBuilder<(BoundValuePlaceholderBase, uint)> instance = ArrayBuilder<(BoundValuePlaceholderBase, uint)>.GetInstance();
				GetInterpolatedStringPlaceholders(instance, in interpolationData, receiverOpt, num, arguments);
				new PlaceholderRegion(this, instance);
			}
			Visit(boundExpression);
		}
	}

	protected override void VisitArguments(BoundCall node)
	{
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		VisitArgumentsAndGetArgumentPlaceholders(node.ReceiverOpt, node.Arguments);
		if (!node.HasErrors)
		{
			MethodSymbol method = node.Method;
			CheckInvocationArgMixing(node.Syntax, method, node.ReceiverOpt, node.InitialBindingReceiverIsSubjectToCloning, method.Parameters, node.Arguments, node.ArgumentRefKindsOpt, node.ArgsToParamsOpt, _localScopeDepth, _diagnostics);
		}
	}

	private void GetInterpolatedStringPlaceholders(ArrayBuilder<(BoundValuePlaceholderBase, uint)> placeholders, in InterpolatedStringHandlerData interpolationData, BoundExpression? receiver, int nArgumentsVisited, ImmutableArray<BoundExpression> arguments)
	{
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		placeholders.Add(((BoundValuePlaceholderBase)interpolationData.ReceiverPlaceholder, _localScopeDepth));
		ImmutableArray<BoundInterpolatedStringArgumentPlaceholder>.Enumerator enumerator = interpolationData.ArgumentPlaceholders.GetEnumerator();
		while (enumerator.MoveNext())
		{
			BoundInterpolatedStringArgumentPlaceholder current = enumerator.Current;
			int argumentIndex = current.ArgumentIndex;
			uint item;
			if (argumentIndex >= 0)
			{
				item = ((argumentIndex < nArgumentsVisited) ? GetValEscape(arguments[argumentIndex], _localScopeDepth) : 0u);
			}
			else
			{
				switch (argumentIndex)
				{
				case -1:
					break;
				default:
					throw ExceptionUtilities.UnexpectedValue((object)current.ArgumentIndex);
				case -3:
				case -2:
					continue;
				}
				item = ((receiver != null) ? (receiver.GetRefKind().IsWritableReference() ? GetRefEscape(receiver, _localScopeDepth) : GetValEscape(receiver, _localScopeDepth)) : 0u);
			}
			placeholders.Add(((BoundValuePlaceholderBase)current, item));
		}
	}

	public override BoundNode? VisitObjectCreationExpression(BoundObjectCreationExpression node)
	{
		VisitObjectCreationExpressionBase(node);
		return null;
	}

	public override BoundNode? VisitDynamicObjectCreationExpression(BoundDynamicObjectCreationExpression node)
	{
		VisitObjectCreationExpressionBase(node);
		return null;
	}

	public override BoundNode? VisitNewT(BoundNewT node)
	{
		VisitObjectCreationExpressionBase(node);
		return null;
	}

	public override BoundNode? VisitNoPiaObjectCreationExpression(BoundNoPiaObjectCreationExpression node)
	{
		VisitObjectCreationExpressionBase(node);
		return null;
	}

	private void VisitObjectCreationExpressionBase(BoundObjectCreationExpressionBase node)
	{
		VisitArgumentsAndGetArgumentPlaceholders(null, node.Arguments);
		Visit(node.InitializerExpressionOpt);
		if (!node.HasErrors)
		{
			MethodSymbol constructor = node.Constructor;
			if ((object)constructor != null)
			{
				CheckInvocationArgMixing(node.Syntax, constructor, null, (ThreeState)0, constructor.Parameters, node.Arguments, node.ArgumentRefKindsOpt, node.ArgsToParamsOpt, _localScopeDepth, _diagnostics);
			}
		}
	}

	public override BoundNode? VisitPropertyAccess(BoundPropertyAccess node)
	{
		return base.VisitPropertyAccess(node);
	}

	public override BoundNode? VisitIndexerAccess(BoundIndexerAccess node)
	{
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		Visit(node.ReceiverOpt);
		VisitArgumentsAndGetArgumentPlaceholders(node.ReceiverOpt, node.Arguments);
		if (!node.HasErrors)
		{
			PropertySymbol indexer = node.Indexer;
			CheckInvocationArgMixing(node.Syntax, indexer, node.ReceiverOpt, node.InitialBindingReceiverIsSubjectToCloning, indexer.Parameters, node.Arguments, node.ArgumentRefKindsOpt, node.ArgsToParamsOpt, _localScopeDepth, _diagnostics);
		}
		return null;
	}

	public override BoundNode? VisitFunctionPointerInvocation(BoundFunctionPointerInvocation node)
	{
		VisitArgumentsAndGetArgumentPlaceholders(null, node.Arguments);
		if (!node.HasErrors)
		{
			FunctionPointerMethodSymbol signature = node.FunctionPointer.Signature;
			CheckInvocationArgMixing(node.Syntax, signature, null, (ThreeState)0, signature.Parameters, node.Arguments, node.ArgumentRefKindsOpt, default(ImmutableArray<int>), _localScopeDepth, _diagnostics);
		}
		return null;
	}

	public override BoundNode? VisitAwaitExpression(BoundAwaitExpression node)
	{
		Visit(node.Expression);
		ArrayBuilder<(BoundValuePlaceholderBase, uint)> instance = ArrayBuilder<(BoundValuePlaceholderBase, uint)>.GetInstance();
		GetAwaitableInstancePlaceholders(instance, node.AwaitableInfo, GetValEscape(node.Expression, _localScopeDepth));
		using (new PlaceholderRegion(this, instance))
		{
			Visit(node.AwaitableInfo);
			return null;
		}
	}

	private void GetAwaitableInstancePlaceholders(ArrayBuilder<(BoundValuePlaceholderBase, uint)> placeholders, BoundAwaitableInfo awaitableInfo, uint valEscapeScope)
	{
		BoundAwaitableValuePlaceholder awaitableInstancePlaceholder = awaitableInfo.AwaitableInstancePlaceholder;
		if (awaitableInstancePlaceholder != null)
		{
			placeholders.Add(((BoundValuePlaceholderBase)awaitableInstancePlaceholder, valEscapeScope));
		}
	}

	public override BoundNode? VisitImplicitIndexerAccess(BoundImplicitIndexerAccess node)
	{
		base.VisitImplicitIndexerAccess(node);
		return null;
	}

	public override BoundNode? VisitDeconstructionAssignmentOperator(BoundDeconstructionAssignmentOperator node)
	{
		base.VisitDeconstructionAssignmentOperator(node);
		BoundTupleExpression left = node.Left;
		BoundConversion right = node.Right;
		ArrayBuilder<DeconstructionVariable> deconstructionAssignmentVariables = GetDeconstructionAssignmentVariables(left);
		VisitDeconstructionArguments(deconstructionAssignmentVariables, right.Syntax, right.Conversion, right.Operand);
		ArrayBuilderExtensions.FreeAll<DeconstructionVariable>(deconstructionAssignmentVariables, (Func<DeconstructionVariable, ArrayBuilder<DeconstructionVariable>>)((DeconstructionVariable v) => v.NestedVariables));
		return null;
	}

	private void VisitDeconstructionArguments(ArrayBuilder<DeconstructionVariable> variables, SyntaxNode syntax, Conversion conversion, BoundExpression right)
	{
		//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
		if (conversion.DeconstructionInfo.IsDefault || !(conversion.DeconstructionInfo.Invocation is BoundCall boundCall))
		{
			return;
		}
		MethodSymbol method = boundCall.Method;
		if ((object)method == null)
		{
			return;
		}
		ArrayBuilder<(BoundValuePlaceholderBase, uint)> instance = ArrayBuilder<(BoundValuePlaceholderBase, uint)>.GetInstance();
		instance.Add(((BoundValuePlaceholderBase)conversion.DeconstructionInfo.InputPlaceholder, GetValEscape(right, _localScopeDepth)));
		ImmutableArray<ParameterSymbol> parameters = method.Parameters;
		int count = variables.Count;
		int num = (boundCall.InvokedAsExtensionMethod ? 1 : 0);
		for (int i = 0; i < count; i++)
		{
			DeconstructionVariable deconstructionVariable = variables[i];
			ArrayBuilder<DeconstructionVariable>? nestedVariables = deconstructionVariable.NestedVariables;
			BoundDeconstructValuePlaceholder item = (BoundDeconstructValuePlaceholder)boundCall.Arguments[i + num];
			uint item2 = ((nestedVariables == null) ? GetValEscape(deconstructionVariable.Expression, _localScopeDepth) : _localScopeDepth);
			instance.Add(((BoundValuePlaceholderBase)item, item2));
		}
		using (new PlaceholderRegion(this, instance))
		{
			CheckInvocationArgMixing(syntax, method, boundCall.ReceiverOpt, boundCall.InitialBindingReceiverIsSubjectToCloning, parameters, boundCall.Arguments, boundCall.ArgumentRefKindsOpt, boundCall.ArgsToParamsOpt, _localScopeDepth, _diagnostics);
			for (int j = 0; j < count; j++)
			{
				ArrayBuilder<DeconstructionVariable> nestedVariables2 = variables[j].NestedVariables;
				if (nestedVariables2 != null)
				{
					(BoundValuePlaceholder? placeholder, BoundExpression? conversion) tuple = conversion.DeconstructConversionInfo[j];
					Conversion conversion2 = BoundNode.GetConversion(placeholder: tuple.placeholder, conversion: tuple.conversion);
					VisitDeconstructionArguments(nestedVariables2, syntax, conversion2, boundCall.Arguments[j + num]);
				}
			}
		}
	}

	private ArrayBuilder<DeconstructionVariable> GetDeconstructionAssignmentVariables(BoundTupleExpression tuple)
	{
		ImmutableArray<BoundExpression> arguments = tuple.Arguments;
		ArrayBuilder<DeconstructionVariable> instance = ArrayBuilder<DeconstructionVariable>.GetInstance(arguments.Length);
		ImmutableArray<BoundExpression>.Enumerator enumerator = arguments.GetEnumerator();
		while (enumerator.MoveNext())
		{
			BoundExpression current = enumerator.Current;
			instance.Add(getDeconstructionAssignmentVariable(current));
		}
		return instance;
		DeconstructionVariable getDeconstructionAssignmentVariable(BoundExpression expr)
		{
			if (!(expr is BoundTupleExpression tuple2))
			{
				return new DeconstructionVariable(expr, GetValEscape(expr, _localScopeDepth), null);
			}
			return new DeconstructionVariable(expr, uint.MaxValue, GetDeconstructionAssignmentVariables(tuple2));
		}
	}

	private static ImmutableArray<BoundExpression> GetDeconstructionRightParts(BoundExpression expr)
	{
		if (!(expr is BoundTupleExpression boundTupleExpression))
		{
			if (expr is BoundConversion { ConversionKind: var conversionKind } boundConversion && (conversionKind == ConversionKind.Identity || conversionKind == ConversionKind.ImplicitTupleLiteral))
			{
				return GetDeconstructionRightParts(boundConversion.Operand);
			}
			throw ExceptionUtilities.Unreachable("/_/src/Compilers/CSharp/Portable/Binder/RefSafetyAnalysis.cs", 976);
		}
		return boundTupleExpression.Arguments;
	}

	public override BoundNode? VisitForEachStatement(BoundForEachStatement node)
	{
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0102: Unknown result type (might be due to invalid IL or missing references)
		Visit(node.Expression);
		ForEachEnumeratorInfo enumeratorInfoOpt = node.EnumeratorInfoOpt;
		BoundExpression inlineArray;
		if (enumeratorInfoOpt != null && (int)enumeratorInfoOpt.InlineArraySpanType != 0 && !enumeratorInfoOpt.InlineArrayUsedAsValue)
		{
			if (node.Expression is BoundConversion { Conversion: { IsIdentity: not false }, ExplicitCastInCode: false } boundConversion)
			{
				BoundExpression operand = boundConversion.Operand;
				if (operand != null)
				{
					inlineArray = operand;
					goto IL_0078;
				}
			}
			inlineArray = node.Expression;
			goto IL_0078;
		}
		uint num = GetValEscape(node.Expression, _localScopeDepth);
		goto IL_00d4;
		IL_00d4:
		using (new LocalScope(this, ImmutableArray<LocalSymbol>.Empty))
		{
			ImmutableArray<LocalSymbol>.Enumerator enumerator = node.IterationVariables.GetEnumerator();
			while (enumerator.MoveNext())
			{
				LocalSymbol current = enumerator.Current;
				AddLocalScopes(current, ((int)current.RefKind == 0) ? _localScopeDepth : num, num);
			}
			ArrayBuilder<(BoundValuePlaceholderBase, uint)> instance = ArrayBuilder<(BoundValuePlaceholderBase, uint)>.GetInstance();
			BoundDeconstructValuePlaceholder boundDeconstructValuePlaceholder = node.DeconstructionOpt?.TargetPlaceholder;
			if (boundDeconstructValuePlaceholder != null)
			{
				instance.Add(((BoundValuePlaceholderBase)boundDeconstructValuePlaceholder, num));
			}
			BoundAwaitableInfo awaitOpt = node.AwaitOpt;
			if (awaitOpt != null)
			{
				GetAwaitableInstancePlaceholders(instance, awaitOpt, num);
			}
			using (new PlaceholderRegion(this, instance))
			{
				Visit(node.IterationVariableType);
				Visit(node.IterationErrorExpressionOpt);
				Visit(node.DeconstructionOpt);
				Visit(node.AwaitOpt);
				Visit(node.Body);
				enumerator = node.IterationVariables.GetEnumerator();
				while (enumerator.MoveNext())
				{
					LocalSymbol current2 = enumerator.Current;
					RemoveLocalScopes(current2);
				}
				return null;
			}
		}
		IL_0078:
		ImmutableArray<BoundExpression> arguments;
		ImmutableArray<RefKind> refKinds;
		SignatureOnlyMethodSymbol inlineArrayConversionEquivalentSignatureMethod = GetInlineArrayConversionEquivalentSignatureMethod(inlineArray, node.EnumeratorInfoOpt.GetEnumeratorInfo.Method.ContainingType, out arguments, out refKinds);
		num = GetInvocationEscapeScope(inlineArrayConversionEquivalentSignatureMethod, null, (ThreeState)0, inlineArrayConversionEquivalentSignatureMethod.Parameters, arguments, refKinds, default(ImmutableArray<int>), _localScopeDepth, isRefEscape: false);
		goto IL_00d4;
	}

	private static void Error(BindingDiagnosticBag diagnostics, ErrorCode code, SyntaxNodeOrToken syntax, params object[] args)
	{
		Location location = ((SyntaxNodeOrToken)(ref syntax)).GetLocation();
		Error(diagnostics, code, location, args);
	}

	private static void Error(BindingDiagnosticBag diagnostics, ErrorCode code, Location location, params object[] args)
	{
		((BindingDiagnosticBag)diagnostics).Add((Diagnostic)(object)new CSDiagnostic((DiagnosticInfo)(object)new CSDiagnosticInfo(code, args), location));
	}
}