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

using System.Collections.Immutable;
using System.Linq;
using Microsoft.CodeAnalysis.CSharp.Symbols.Metadata.PE;
using Microsoft.CodeAnalysis.PooledObjects;

namespace Microsoft.CodeAnalysis.CSharp.Symbols;

internal static class CustomModifierUtils
{
	internal static void CopyMethodCustomModifiers(MethodSymbol sourceMethod, MethodSymbol destinationMethod, out TypeWithAnnotations returnType, out ImmutableArray<CustomModifier> customModifiers, out ImmutableArray<ParameterSymbol> parameters, bool alsoCopyParamsModifier)
	{
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		MethodSymbol methodSymbol = sourceMethod.ConstructIfGeneric(destinationMethod.TypeArgumentsWithAnnotations);
		customModifiers = (((int)destinationMethod.RefKind != 0) ? methodSymbol.RefCustomModifiers : ImmutableArray<CustomModifier>.Empty);
		parameters = CopyParameterCustomModifiers(methodSymbol.Parameters, destinationMethod.Parameters, alsoCopyParamsModifier);
		returnType = destinationMethod.ReturnTypeWithAnnotations;
		TypeSymbol type = returnType.Type;
		TypeWithAnnotations returnTypeWithAnnotations = methodSymbol.ReturnTypeWithAnnotations;
		TypeSymbol type2 = returnTypeWithAnnotations.Type;
		if (type.Equals(type2, (TypeCompareKind)63))
		{
			returnType = returnType.WithTypeAndModifiers(CopyTypeCustomModifiers(type2, type, destinationMethod.ContainingAssembly), returnTypeWithAnnotations.CustomModifiers);
		}
	}

	internal static TypeSymbol CopyTypeCustomModifiers(TypeSymbol sourceType, TypeSymbol destinationType, AssemblySymbol containingAssembly)
	{
		ImmutableArray<bool> dynamicTransformFlags = CSharpCompilation.DynamicTransformsEncoder.EncodeWithoutCustomModifierFlags(destinationType, (RefKind)0);
		TypeSymbol result = DynamicTypeDecoder.TransformTypeWithoutCustomModifierFlags(sourceType, containingAssembly, (RefKind)0, dynamicTransformFlags);
		if (!containingAssembly.RuntimeSupportsNumericIntPtr)
		{
			ArrayBuilder<bool> instance = ArrayBuilder<bool>.GetInstance();
			CSharpCompilation.NativeIntegerTransformsEncoder.Encode(instance, destinationType);
			result = NativeIntegerTypeDecoder.TransformType(result, instance.ToImmutableAndFree());
		}
		if (destinationType.ContainsTuple() && !sourceType.Equals(destinationType, (TypeCompareKind)11))
		{
			ImmutableArray<string> elementNames = CSharpCompilation.TupleNamesEncoder.Encode(destinationType);
			result = TupleTypeDecoder.DecodeTupleTypesIfApplicable(result, elementNames);
		}
		ArrayBuilder<byte> instance2 = ArrayBuilder<byte>.GetInstance();
		destinationType.AddNullableTransforms(instance2);
		int position = 0;
		_ = instance2.Count;
		result.ApplyNullableTransforms(0, instance2.ToImmutableAndFree(), ref position, out result);
		return result;
	}

	internal static ImmutableArray<ParameterSymbol> CopyParameterCustomModifiers(ImmutableArray<ParameterSymbol> sourceParameters, ImmutableArray<ParameterSymbol> destinationParameters, bool alsoCopyParamsModifier)
	{
		//IL_00df: Unknown result type (might be due to invalid IL or missing references)
		ArrayBuilder<ParameterSymbol> val = null;
		int length = destinationParameters.Length;
		for (int i = 0; i < length; i++)
		{
			SourceParameterSymbolBase sourceParameterSymbolBase = (SourceParameterSymbolBase)destinationParameters[i];
			ParameterSymbol parameterSymbol = sourceParameters[i];
			if (parameterSymbol.TypeWithAnnotations.CustomModifiers.Any() || parameterSymbol.RefCustomModifiers.Any() || parameterSymbol.Type.HasCustomModifiers(flagNonDefaultArraySizesOrLowerBounds: true) || sourceParameterSymbolBase.TypeWithAnnotations.CustomModifiers.Any() || sourceParameterSymbolBase.RefCustomModifiers.Any() || sourceParameterSymbolBase.Type.HasCustomModifiers(flagNonDefaultArraySizesOrLowerBounds: true) || (alsoCopyParamsModifier && parameterSymbol.IsParams != sourceParameterSymbolBase.IsParams))
			{
				if (val == null)
				{
					val = ArrayBuilder<ParameterSymbol>.GetInstance();
					val.AddRange(destinationParameters, i);
				}
				bool newIsParams = (alsoCopyParamsModifier ? parameterSymbol.IsParams : sourceParameterSymbolBase.IsParams);
				val.Add(sourceParameterSymbolBase.WithCustomModifiersAndParams(parameterSymbol.Type, parameterSymbol.TypeWithAnnotations.CustomModifiers, ((int)sourceParameterSymbolBase.RefKind != 0) ? parameterSymbol.RefCustomModifiers : ImmutableArray<CustomModifier>.Empty, newIsParams));
			}
			else
			{
				val?.Add((ParameterSymbol)sourceParameterSymbolBase);
			}
		}
		return val?.ToImmutableAndFree() ?? destinationParameters;
	}

	internal static bool HasInAttributeModifier(this ImmutableArray<CustomModifier> modifiers)
	{
		return modifiers.Any((CustomModifier modifier) => !modifier.IsOptional && ((CSharpCustomModifier)(object)modifier).ModifierSymbol.IsWellKnownTypeInAttribute());
	}

	internal static bool HasRequiresLocationAttributeModifier(this ImmutableArray<CustomModifier> modifiers)
	{
		return modifiers.Any((CustomModifier modifier) => modifier.IsOptional && ((CSharpCustomModifier)(object)modifier).ModifierSymbol.IsWellKnownTypeRequiresLocationAttribute());
	}

	internal static bool HasIsExternalInitModifier(this ImmutableArray<CustomModifier> modifiers)
	{
		return modifiers.Any((CustomModifier modifier) => !modifier.IsOptional && ((CSharpCustomModifier)(object)modifier).ModifierSymbol.IsWellKnownTypeIsExternalInit());
	}

	internal static bool HasOutAttributeModifier(this ImmutableArray<CustomModifier> modifiers)
	{
		return modifiers.Any((CustomModifier modifier) => !modifier.IsOptional && ((CSharpCustomModifier)(object)modifier).ModifierSymbol.IsWellKnownTypeOutAttribute());
	}
}