885 lines
41 KiB
C#
885 lines
41 KiB
C#
using System.Collections.Immutable;
|
|
using System.Diagnostics;
|
|
using Microsoft.CodeAnalysis.CSharp.Symbols;
|
|
using Microsoft.CodeAnalysis.PooledObjects;
|
|
using Microsoft.CodeAnalysis.Symbols;
|
|
using Roslyn.Utilities;
|
|
|
|
namespace Microsoft.CodeAnalysis.CSharp;
|
|
|
|
internal class OverloadResolutionResult<TMember> where TMember : Symbol
|
|
{
|
|
private MemberResolutionResult<TMember> _bestResult;
|
|
|
|
private ThreeState _bestResultState;
|
|
|
|
internal readonly ArrayBuilder<MemberResolutionResult<TMember>> ResultsBuilder;
|
|
|
|
private static readonly ObjectPool<OverloadResolutionResult<TMember>> s_pool = CreatePool();
|
|
|
|
public bool Succeeded
|
|
{
|
|
get
|
|
{
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_000d: Invalid comparison between Unknown and I4
|
|
EnsureBestResultLoaded();
|
|
if ((int)_bestResultState == 2)
|
|
{
|
|
return _bestResult.Result.IsValid;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public MemberResolutionResult<TMember> ValidResult
|
|
{
|
|
get
|
|
{
|
|
EnsureBestResultLoaded();
|
|
return _bestResult;
|
|
}
|
|
}
|
|
|
|
public MemberResolutionResult<TMember> BestResult
|
|
{
|
|
get
|
|
{
|
|
EnsureBestResultLoaded();
|
|
return _bestResult;
|
|
}
|
|
}
|
|
|
|
public ImmutableArray<MemberResolutionResult<TMember>> Results => ((ArrayBuilder<MemberResolutionResult<MemberResolutionResult<TMember>>>)(object)ResultsBuilder).ToImmutable();
|
|
|
|
internal unsafe bool HasAnyApplicableMember
|
|
{
|
|
get
|
|
{
|
|
//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<MemberResolutionResult<TMember>> enumerator = ((ArrayBuilder<MemberResolutionResult<MemberResolutionResult<TMember>>>)(object)ResultsBuilder).GetEnumerator();
|
|
while (((Enumerator<MemberResolutionResult<MemberResolutionResult<TMember>>>*)(&enumerator))->MoveNext())
|
|
{
|
|
if (((Enumerator<MemberResolutionResult<MemberResolutionResult<TMember>>>*)(&enumerator))->Current.Result.IsApplicable)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
internal OverloadResolutionResult()
|
|
{
|
|
ResultsBuilder = (ArrayBuilder<MemberResolutionResult<TMember>>)(object)new ArrayBuilder<MemberResolutionResult<MemberResolutionResult<TMember>>>();
|
|
}
|
|
|
|
internal void Clear()
|
|
{
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
|
_bestResult = default(MemberResolutionResult<TMember>);
|
|
_bestResultState = (ThreeState)0;
|
|
((ArrayBuilder<MemberResolutionResult<MemberResolutionResult<TMember>>>)(object)ResultsBuilder).Clear();
|
|
}
|
|
|
|
private void EnsureBestResultLoaded()
|
|
{
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
|
|
if (!ThreeStateHelpers.HasValue(_bestResultState))
|
|
{
|
|
_bestResultState = TryGetBestResult(ResultsBuilder, out _bestResult);
|
|
}
|
|
}
|
|
|
|
internal unsafe ImmutableArray<TMember> GetAllApplicableMembers()
|
|
{
|
|
//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)
|
|
ArrayBuilder<TMember> instance = ArrayBuilder<TMember>.GetInstance();
|
|
Enumerator<MemberResolutionResult<TMember>> enumerator = ((ArrayBuilder<MemberResolutionResult<MemberResolutionResult<TMember>>>)(object)ResultsBuilder).GetEnumerator();
|
|
while (((Enumerator<MemberResolutionResult<MemberResolutionResult<TMember>>>*)(&enumerator))->MoveNext())
|
|
{
|
|
MemberResolutionResult<TMember> current = ((Enumerator<MemberResolutionResult<MemberResolutionResult<TMember>>>*)(&enumerator))->Current;
|
|
if (current.Result.IsApplicable)
|
|
{
|
|
instance.Add(current.Member);
|
|
}
|
|
}
|
|
return instance.ToImmutableAndFree();
|
|
}
|
|
|
|
private unsafe static ThreeState TryGetBestResult(ArrayBuilder<MemberResolutionResult<TMember>> allResults, out MemberResolutionResult<TMember> best)
|
|
{
|
|
//IL_0008: 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_000f: 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_002b: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_002d: Invalid comparison between Unknown and I4
|
|
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
|
|
best = default(MemberResolutionResult<TMember>);
|
|
ThreeState val = (ThreeState)1;
|
|
Enumerator<MemberResolutionResult<TMember>> enumerator = ((ArrayBuilder<MemberResolutionResult<MemberResolutionResult<TMember>>>)(object)allResults).GetEnumerator();
|
|
while (((Enumerator<MemberResolutionResult<MemberResolutionResult<TMember>>>*)(&enumerator))->MoveNext())
|
|
{
|
|
MemberResolutionResult<TMember> current = ((Enumerator<MemberResolutionResult<MemberResolutionResult<TMember>>>*)(&enumerator))->Current;
|
|
if (current.Result.IsValid)
|
|
{
|
|
if ((int)val == 2)
|
|
{
|
|
best = default(MemberResolutionResult<TMember>);
|
|
return (ThreeState)1;
|
|
}
|
|
val = (ThreeState)2;
|
|
best = current;
|
|
}
|
|
}
|
|
return val;
|
|
}
|
|
|
|
internal unsafe void ReportDiagnostics<T>(Binder binder, Location location, SyntaxNode nodeOpt, BindingDiagnosticBag diagnostics, string name, BoundExpression receiver, SyntaxNode invokedExpression, AnalyzedArguments arguments, ImmutableArray<T> memberGroup, NamedTypeSymbol typeContainingConstructor, NamedTypeSymbol delegateTypeBeingInvoked, CSharpSyntaxNode queryClause = null, bool isMethodGroupConversion = false, RefKind? returnRefKind = null, TypeSymbol delegateOrFunctionPointerType = null) where T : Symbol
|
|
{
|
|
//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0104: Unknown result type (might be due to invalid IL or missing references)
|
|
ImmutableArray<Symbol> symbols = StaticCast<Symbol>.From<T>(memberGroup);
|
|
if (HadAmbiguousBestMethods(diagnostics, symbols, location) || HadAmbiguousWorseMethods(diagnostics, symbols, location, queryClause != null, receiver, name) || HadLambdaConversionError(diagnostics, arguments) || HadStaticInstanceMismatch(diagnostics, symbols, ((invokedExpression != null) ? invokedExpression.GetLocation() : null) ?? location, binder, receiver, nodeOpt, delegateOrFunctionPointerType) || (isMethodGroupConversion && returnRefKind.HasValue && HadReturnMismatch(location, diagnostics, delegateOrFunctionPointerType)) || HadConstraintFailure(location, diagnostics) || HadBadArguments(diagnostics, binder, name, arguments, symbols, location, binder.Flags, isMethodGroupConversion) || HadConstructedParameterFailedConstraintCheck(binder.Conversions, binder.Compilation, diagnostics, location) || InaccessibleTypeArgument(diagnostics, symbols, location) || TypeInferenceFailed(binder, diagnostics, symbols, receiver, arguments, location, queryClause) || UseSiteError())
|
|
{
|
|
return;
|
|
}
|
|
bool flag = false;
|
|
MemberResolutionResult<TMember> memberResolutionResult = default(MemberResolutionResult<TMember>);
|
|
MemberResolutionResult<TMember> firstUnsupported = default(MemberResolutionResult<TMember>);
|
|
MemberResolutionResult<TMember>[] array = new MemberResolutionResult<TMember>[7];
|
|
Enumerator<MemberResolutionResult<TMember>> enumerator = ((ArrayBuilder<MemberResolutionResult<MemberResolutionResult<TMember>>>)(object)ResultsBuilder).GetEnumerator();
|
|
while (((Enumerator<MemberResolutionResult<MemberResolutionResult<TMember>>>*)(&enumerator))->MoveNext())
|
|
{
|
|
MemberResolutionResult<TMember> current = ((Enumerator<MemberResolutionResult<MemberResolutionResult<TMember>>>*)(&enumerator))->Current;
|
|
switch (current.Result.Kind)
|
|
{
|
|
case MemberResolutionKind.UnsupportedMetadata:
|
|
if (memberResolutionResult.IsNull)
|
|
{
|
|
firstUnsupported = current;
|
|
}
|
|
break;
|
|
case MemberResolutionKind.NoCorrespondingNamedParameter:
|
|
if (array[3].IsNull || current.Result.FirstBadArgument > array[3].Result.FirstBadArgument)
|
|
{
|
|
array[3] = current;
|
|
}
|
|
break;
|
|
case MemberResolutionKind.NoCorrespondingParameter:
|
|
if (array[4].IsNull)
|
|
{
|
|
array[4] = current;
|
|
}
|
|
break;
|
|
case MemberResolutionKind.RequiredParameterMissing:
|
|
if (array[1].IsNull)
|
|
{
|
|
array[1] = current;
|
|
}
|
|
else
|
|
{
|
|
flag = true;
|
|
}
|
|
break;
|
|
case MemberResolutionKind.NameUsedForPositional:
|
|
if (array[2].IsNull || current.Result.FirstBadArgument > array[2].Result.FirstBadArgument)
|
|
{
|
|
array[2] = current;
|
|
}
|
|
break;
|
|
case MemberResolutionKind.BadNonTrailingNamedArgument:
|
|
if (array[5].IsNull || current.Result.FirstBadArgument > array[5].Result.FirstBadArgument)
|
|
{
|
|
array[5] = current;
|
|
}
|
|
break;
|
|
case MemberResolutionKind.DuplicateNamedArgument:
|
|
if (array[0].IsNull || current.Result.FirstBadArgument > array[0].Result.FirstBadArgument)
|
|
{
|
|
array[0] = current;
|
|
}
|
|
break;
|
|
case MemberResolutionKind.WrongCallingConvention:
|
|
if (array[6].IsNull)
|
|
{
|
|
array[6] = current;
|
|
}
|
|
break;
|
|
default:
|
|
throw ExceptionUtilities.UnexpectedValue((object)current.Result.Kind);
|
|
}
|
|
}
|
|
MemberResolutionResult<TMember>[] array2 = array;
|
|
for (int i = 0; i < array2.Length; i++)
|
|
{
|
|
MemberResolutionResult<TMember> memberResolutionResult2 = array2[i];
|
|
if (memberResolutionResult2.IsNotNull)
|
|
{
|
|
memberResolutionResult = memberResolutionResult2;
|
|
break;
|
|
}
|
|
}
|
|
if (memberResolutionResult.IsNotNull)
|
|
{
|
|
if (memberResolutionResult.Member is FunctionPointerMethodSymbol && memberResolutionResult.Result.Kind == MemberResolutionKind.NoCorrespondingNamedParameter)
|
|
{
|
|
int firstBadArgument = memberResolutionResult.Result.FirstBadArgument;
|
|
Location item = arguments.Names[firstBadArgument].GetValueOrDefault().Item2;
|
|
diagnostics.Add(ErrorCode.ERR_FunctionPointersCannotBeCalledWithNamedArguments, item);
|
|
return;
|
|
}
|
|
if (!(memberResolutionResult.Result.Kind == MemberResolutionKind.RequiredParameterMissing && flag) && !isMethodGroupConversion && !(memberResolutionResult.Member is FunctionPointerMethodSymbol))
|
|
{
|
|
switch (memberResolutionResult.Result.Kind)
|
|
{
|
|
case MemberResolutionKind.NameUsedForPositional:
|
|
ReportNameUsedForPositional(memberResolutionResult, diagnostics, arguments, symbols);
|
|
return;
|
|
case MemberResolutionKind.NoCorrespondingNamedParameter:
|
|
ReportNoCorrespondingNamedParameter(memberResolutionResult, name, diagnostics, arguments, delegateTypeBeingInvoked, symbols);
|
|
return;
|
|
case MemberResolutionKind.RequiredParameterMissing:
|
|
ReportMissingRequiredParameter(memberResolutionResult, diagnostics, delegateTypeBeingInvoked, symbols, location);
|
|
return;
|
|
case MemberResolutionKind.BadNonTrailingNamedArgument:
|
|
ReportBadNonTrailingNamedArgument(memberResolutionResult, diagnostics, arguments, symbols);
|
|
return;
|
|
case MemberResolutionKind.DuplicateNamedArgument:
|
|
ReportDuplicateNamedArgument(memberResolutionResult, diagnostics, arguments);
|
|
return;
|
|
}
|
|
}
|
|
else if (memberResolutionResult.Result.Kind == MemberResolutionKind.WrongCallingConvention)
|
|
{
|
|
ReportWrongCallingConvention(location, diagnostics, symbols, memberResolutionResult, ((FunctionPointerTypeSymbol)delegateOrFunctionPointerType).Signature);
|
|
return;
|
|
}
|
|
}
|
|
else if (firstUnsupported.IsNotNull)
|
|
{
|
|
ReportUnsupportedMetadata(location, diagnostics, symbols, firstUnsupported);
|
|
return;
|
|
}
|
|
if (!isMethodGroupConversion)
|
|
{
|
|
ReportBadParameterCount(diagnostics, name, arguments, symbols, location, typeContainingConstructor, delegateTypeBeingInvoked);
|
|
}
|
|
}
|
|
|
|
private static void ReportUnsupportedMetadata(Location location, BindingDiagnosticBag diagnostics, ImmutableArray<Symbol> symbols, MemberResolutionResult<TMember> firstUnsupported)
|
|
{
|
|
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
|
|
DiagnosticInfo diagnosticInfo = firstUnsupported.Member.GetUseSiteInfo().DiagnosticInfo;
|
|
diagnosticInfo = (DiagnosticInfo)(object)new DiagnosticInfoWithSymbols((ErrorCode)diagnosticInfo.Code, diagnosticInfo.Arguments, symbols);
|
|
Symbol.ReportUseSiteDiagnostic(diagnosticInfo, diagnostics, location);
|
|
}
|
|
|
|
private static void ReportWrongCallingConvention(Location location, BindingDiagnosticBag diagnostics, ImmutableArray<Symbol> symbols, MemberResolutionResult<TMember> firstSupported, MethodSymbol target)
|
|
{
|
|
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
|
|
diagnostics.Add((DiagnosticInfo?)(object)new DiagnosticInfoWithSymbols(ErrorCode.ERR_WrongFuncPtrCallingConvention, new object[2] { firstSupported.Member, target.CallingConvention }, symbols), location);
|
|
}
|
|
|
|
private bool UseSiteError()
|
|
{
|
|
if (GetFirstMemberKind(MemberResolutionKind.UseSiteError).IsNull)
|
|
{
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private bool InaccessibleTypeArgument(BindingDiagnosticBag diagnostics, ImmutableArray<Symbol> symbols, Location location)
|
|
{
|
|
MemberResolutionResult<TMember> firstMemberKind = GetFirstMemberKind(MemberResolutionKind.InaccessibleTypeArgument);
|
|
if (firstMemberKind.IsNull)
|
|
{
|
|
return false;
|
|
}
|
|
diagnostics.Add((DiagnosticInfo?)(object)new DiagnosticInfoWithSymbols(ErrorCode.ERR_BadAccess, new object[1] { firstMemberKind.Member }, symbols), location);
|
|
return true;
|
|
}
|
|
|
|
private bool HadStaticInstanceMismatch(BindingDiagnosticBag diagnostics, ImmutableArray<Symbol> symbols, Location location, Binder binder, BoundExpression receiverOpt, SyntaxNode nodeOpt, TypeSymbol delegateOrFunctionPointerType)
|
|
{
|
|
MemberResolutionResult<TMember> firstMemberKind = GetFirstMemberKind(MemberResolutionKind.StaticInstanceMismatch);
|
|
if (firstMemberKind.IsNull)
|
|
{
|
|
return false;
|
|
}
|
|
if (receiverOpt == null || !receiverOpt.HasErrors)
|
|
{
|
|
Symbol member = firstMemberKind.Member;
|
|
if (receiverOpt != null && receiverOpt.Kind == BoundKind.QueryClause)
|
|
{
|
|
diagnostics.Add(ErrorCode.ERR_QueryNoProvider, location, receiverOpt.Type, member.Name);
|
|
}
|
|
else if (binder.Flags.Includes(BinderFlags.CollectionInitializerAddMethod))
|
|
{
|
|
diagnostics.Add(ErrorCode.ERR_InitializerAddHasWrongSignature, location, member);
|
|
}
|
|
else if (nodeOpt != null && nodeOpt.Kind() == SyntaxKind.AwaitExpression && member.Name == "GetAwaiter")
|
|
{
|
|
diagnostics.Add(ErrorCode.ERR_BadAwaitArg, location, receiverOpt.Type);
|
|
}
|
|
else if (delegateOrFunctionPointerType is FunctionPointerTypeSymbol)
|
|
{
|
|
diagnostics.Add(ErrorCode.ERR_FuncPtrMethMustBeStatic, location, member);
|
|
}
|
|
else
|
|
{
|
|
ErrorCode errorCode = ((!member.RequiresInstanceReceiver()) ? ErrorCode.ERR_ObjectProhibited : ((Binder.WasImplicitReceiver(receiverOpt) && binder.InFieldInitializer && !binder.BindingTopLevelScriptCode) ? ErrorCode.ERR_FieldInitRefNonstatic : ErrorCode.ERR_ObjectRequired));
|
|
diagnostics.Add((DiagnosticInfo?)(object)new DiagnosticInfoWithSymbols(errorCode, new object[1] { member }, symbols), location);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private bool HadReturnMismatch(Location location, BindingDiagnosticBag diagnostics, TypeSymbol delegateOrFunctionPointerType)
|
|
{
|
|
MemberResolutionResult<TMember> firstMemberKind = GetFirstMemberKind(MemberResolutionKind.WrongRefKind);
|
|
if (!firstMemberKind.IsNull)
|
|
{
|
|
diagnostics.Add(delegateOrFunctionPointerType.IsFunctionPointer() ? ErrorCode.ERR_FuncPtrRefMismatch : ErrorCode.ERR_DelegateRefMismatch, location, firstMemberKind.Member, delegateOrFunctionPointerType);
|
|
return true;
|
|
}
|
|
firstMemberKind = GetFirstMemberKind(MemberResolutionKind.WrongReturnType);
|
|
if (!firstMemberKind.IsNull)
|
|
{
|
|
MethodSymbol methodSymbol = (MethodSymbol)(object)firstMemberKind.Member;
|
|
diagnostics.Add(ErrorCode.ERR_BadRetType, location, methodSymbol, methodSymbol.ReturnType);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private bool HadConstraintFailure(Location location, BindingDiagnosticBag diagnostics)
|
|
{
|
|
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
|
|
MemberResolutionResult<TMember> firstMemberKind = GetFirstMemberKind(MemberResolutionKind.ConstraintFailure);
|
|
if (firstMemberKind.IsNull)
|
|
{
|
|
return false;
|
|
}
|
|
ImmutableArray<TypeParameterDiagnosticInfo>.Enumerator enumerator = firstMemberKind.Result.ConstraintFailureDiagnostics.GetEnumerator();
|
|
while (enumerator.MoveNext())
|
|
{
|
|
TypeParameterDiagnosticInfo current = enumerator.Current;
|
|
if (current.UseSiteInfo.DiagnosticInfo != null)
|
|
{
|
|
((BindingDiagnosticBag)diagnostics).Add((Diagnostic)(object)new CSDiagnostic(current.UseSiteInfo.DiagnosticInfo, location));
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private bool TypeInferenceFailed(Binder binder, BindingDiagnosticBag diagnostics, ImmutableArray<Symbol> symbols, BoundExpression receiver, AnalyzedArguments arguments, Location location, CSharpSyntaxNode queryClause = null)
|
|
{
|
|
MemberResolutionResult<TMember> firstMemberKind = GetFirstMemberKind(MemberResolutionKind.TypeInferenceFailed);
|
|
if (firstMemberKind.IsNotNull)
|
|
{
|
|
if (queryClause != null)
|
|
{
|
|
Binder.ReportQueryInferenceFailed(queryClause, firstMemberKind.Member.Name, receiver, arguments, symbols, diagnostics);
|
|
}
|
|
else
|
|
{
|
|
diagnostics.Add((DiagnosticInfo?)(object)new DiagnosticInfoWithSymbols(ErrorCode.ERR_CantInferMethTypeArgs, new object[1] { firstMemberKind.Member }, symbols), location);
|
|
}
|
|
return true;
|
|
}
|
|
firstMemberKind = GetFirstMemberKind(MemberResolutionKind.TypeInferenceExtensionInstanceArgument);
|
|
if (firstMemberKind.IsNotNull)
|
|
{
|
|
BoundExpression boundExpression = arguments.Arguments[0];
|
|
if (queryClause != null)
|
|
{
|
|
binder.ReportQueryLookupFailed((SyntaxNode)(object)queryClause, boundExpression, firstMemberKind.Member.Name, symbols, diagnostics);
|
|
}
|
|
else
|
|
{
|
|
diagnostics.Add((DiagnosticInfo?)(object)new DiagnosticInfoWithSymbols(ErrorCode.ERR_NoSuchMemberOrExtension, new object[2]
|
|
{
|
|
boundExpression.Type,
|
|
firstMemberKind.Member.Name
|
|
}, symbols), location);
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private static void ReportNameUsedForPositional(MemberResolutionResult<TMember> bad, BindingDiagnosticBag diagnostics, AnalyzedArguments arguments, ImmutableArray<Symbol> symbols)
|
|
{
|
|
int firstBadArgument = bad.Result.FirstBadArgument;
|
|
var (text, location) = arguments.Names[firstBadArgument].GetValueOrDefault();
|
|
diagnostics.Add((DiagnosticInfo?)(object)new DiagnosticInfoWithSymbols(ErrorCode.ERR_NamedArgumentUsedInPositional, new object[1] { text }, symbols), location);
|
|
}
|
|
|
|
private static void ReportBadNonTrailingNamedArgument(MemberResolutionResult<TMember> bad, BindingDiagnosticBag diagnostics, AnalyzedArguments arguments, ImmutableArray<Symbol> symbols)
|
|
{
|
|
int firstBadArgument = bad.Result.FirstBadArgument;
|
|
var (text, location) = arguments.Names[firstBadArgument].GetValueOrDefault();
|
|
diagnostics.Add((DiagnosticInfo?)(object)new DiagnosticInfoWithSymbols(ErrorCode.ERR_BadNonTrailingNamedArgument, new object[1] { text }, symbols), location);
|
|
}
|
|
|
|
private static void ReportDuplicateNamedArgument(MemberResolutionResult<TMember> result, BindingDiagnosticBag diagnostics, AnalyzedArguments arguments)
|
|
{
|
|
var (text, location) = arguments.Names[result.Result.FirstBadArgument].GetValueOrDefault();
|
|
diagnostics.Add((DiagnosticInfo?)(object)new CSDiagnosticInfo(ErrorCode.ERR_DuplicateNamedArgument, text), location);
|
|
}
|
|
|
|
private static void ReportNoCorrespondingNamedParameter(MemberResolutionResult<TMember> bad, string methodName, BindingDiagnosticBag diagnostics, AnalyzedArguments arguments, NamedTypeSymbol delegateTypeBeingInvoked, ImmutableArray<Symbol> symbols)
|
|
{
|
|
int firstBadArgument = bad.Result.FirstBadArgument;
|
|
(string, Location) valueOrDefault = arguments.Names[firstBadArgument].GetValueOrDefault();
|
|
string item = valueOrDefault.Item1;
|
|
Location item2 = valueOrDefault.Item2;
|
|
ErrorCode errorCode = (((object)delegateTypeBeingInvoked != null) ? ErrorCode.ERR_BadNamedArgumentForDelegateInvoke : ErrorCode.ERR_BadNamedArgument);
|
|
object obj = ((object)delegateTypeBeingInvoked) ?? ((object)methodName);
|
|
diagnostics.Add((DiagnosticInfo?)(object)new DiagnosticInfoWithSymbols(errorCode, new object[2] { obj, item }, symbols), item2);
|
|
}
|
|
|
|
private static void ReportMissingRequiredParameter(MemberResolutionResult<TMember> bad, BindingDiagnosticBag diagnostics, NamedTypeSymbol delegateTypeBeingInvoked, ImmutableArray<Symbol> symbols, Location location)
|
|
{
|
|
TMember member = bad.Member;
|
|
ImmutableArray<ParameterSymbol> parameters = member.GetParameters();
|
|
int badParameter = bad.Result.BadParameter;
|
|
string text = ((badParameter != parameters.Length) ? parameters[badParameter].Name : SyntaxFacts.GetText(SyntaxKind.ArgListKeyword));
|
|
object obj = ((object)delegateTypeBeingInvoked) ?? ((object)member);
|
|
diagnostics.Add((DiagnosticInfo?)(object)new DiagnosticInfoWithSymbols(ErrorCode.ERR_NoCorrespondingArgument, new object[2] { text, obj }, symbols), location);
|
|
}
|
|
|
|
private static void ReportBadParameterCount(BindingDiagnosticBag diagnostics, string name, AnalyzedArguments arguments, ImmutableArray<Symbol> symbols, Location location, NamedTypeSymbol typeContainingConstructor, NamedTypeSymbol delegateTypeBeingInvoked)
|
|
{
|
|
FunctionPointerMethodSymbol functionPointerMethodSymbol = ((symbols.IsDefault || symbols.Length != 1) ? null : (symbols[0] as FunctionPointerMethodSymbol));
|
|
(ErrorCode, object) tuple;
|
|
if ((object)typeContainingConstructor == null)
|
|
{
|
|
if ((object)delegateTypeBeingInvoked == null)
|
|
{
|
|
object obj = functionPointerMethodSymbol;
|
|
tuple = ((obj == null) ? (ErrorCode.ERR_BadArgCount, name) : (ErrorCode.ERR_BadFuncPointerArgCount, obj));
|
|
}
|
|
else
|
|
{
|
|
tuple = (ErrorCode.ERR_BadDelArgCount, delegateTypeBeingInvoked);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
tuple = (ErrorCode.ERR_BadCtorArgCount, typeContainingConstructor);
|
|
}
|
|
(ErrorCode, object) tuple2 = tuple;
|
|
ErrorCode item = tuple2.Item1;
|
|
object item2 = tuple2.Item2;
|
|
int num = arguments.Arguments.Count;
|
|
if (arguments.IsExtensionMethodInvocation)
|
|
{
|
|
num--;
|
|
}
|
|
diagnostics.Add((DiagnosticInfo?)(object)new DiagnosticInfoWithSymbols(item, new object[2] { item2, num }, symbols), location);
|
|
}
|
|
|
|
private bool HadConstructedParameterFailedConstraintCheck(ConversionsBase conversions, CSharpCompilation compilation, BindingDiagnosticBag diagnostics, Location location)
|
|
{
|
|
MemberResolutionResult<TMember> firstMemberKind = GetFirstMemberKind(MemberResolutionKind.ConstructedParameterFailedConstraintCheck);
|
|
if (firstMemberKind.IsNull)
|
|
{
|
|
return false;
|
|
}
|
|
MethodSymbol methodSymbol = (MethodSymbol)(object)firstMemberKind.Member;
|
|
if (!methodSymbol.CheckConstraints(new ConstraintsHelper.CheckConstraintsArgs(compilation, conversions, includeNullability: false, location, diagnostics)))
|
|
{
|
|
return true;
|
|
}
|
|
TypeSymbol parameterType = methodSymbol.GetParameterType(firstMemberKind.Result.BadParameter);
|
|
ConstraintsHelper.CheckConstraintsArgsBoxed checkConstraintsArgsBoxed = ConstraintsHelper.CheckConstraintsArgsBoxed.Allocate(compilation, conversions, includeNullability: false, location, diagnostics);
|
|
parameterType.CheckAllConstraints(checkConstraintsArgsBoxed);
|
|
checkConstraintsArgsBoxed.Free();
|
|
return true;
|
|
}
|
|
|
|
private static bool HadLambdaConversionError(BindingDiagnosticBag diagnostics, AnalyzedArguments arguments)
|
|
{
|
|
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
|
|
bool flag = false;
|
|
Enumerator<BoundExpression> enumerator = arguments.Arguments.GetEnumerator();
|
|
while (enumerator.MoveNext())
|
|
{
|
|
BoundExpression current = enumerator.Current;
|
|
if (current.Kind == BoundKind.UnboundLambda)
|
|
{
|
|
flag |= ((UnboundLambda)current).GenerateSummaryErrors(diagnostics);
|
|
}
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
private bool HadBadArguments(BindingDiagnosticBag diagnostics, Binder binder, string name, AnalyzedArguments arguments, ImmutableArray<Symbol> symbols, Location location, BinderFlags flags, bool isMethodGroupConversion)
|
|
{
|
|
//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_00a6: 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)
|
|
MemberResolutionResult<TMember> firstMemberKind = GetFirstMemberKind(MemberResolutionKind.BadArgumentConversion);
|
|
if (firstMemberKind.IsNull)
|
|
{
|
|
return false;
|
|
}
|
|
if (isMethodGroupConversion)
|
|
{
|
|
return true;
|
|
}
|
|
TMember member = firstMemberKind.Member;
|
|
if (flags.Includes(BinderFlags.CollectionInitializerAddMethod))
|
|
{
|
|
ImmutableArray<ParameterSymbol>.Enumerator enumerator = member.GetParameters().GetEnumerator();
|
|
while (enumerator.MoveNext())
|
|
{
|
|
if ((int)enumerator.Current.RefKind != 0)
|
|
{
|
|
diagnostics.Add(ErrorCode.ERR_InitializerAddHasParamModifiers, location, symbols, member);
|
|
return true;
|
|
}
|
|
}
|
|
diagnostics.Add(ErrorCode.ERR_BadArgTypesForCollectionAdd, location, symbols, member);
|
|
}
|
|
BitVector badArgumentsOpt = firstMemberKind.Result.BadArgumentsOpt;
|
|
foreach (int item in ((BitVector)(ref badArgumentsOpt)).TrueBits())
|
|
{
|
|
ReportBadArgumentError(diagnostics, binder, name, arguments, symbols, firstMemberKind, member, item);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private static void ReportBadArgumentError(BindingDiagnosticBag diagnostics, Binder binder, string name, AnalyzedArguments arguments, ImmutableArray<Symbol> symbols, MemberResolutionResult<TMember> badArg, TMember method, int arg)
|
|
{
|
|
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0031: Expected O, but got Unknown
|
|
//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_00ca: Invalid comparison between Unknown and I4
|
|
//IL_0205: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0207: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_00d1: 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_00cc: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_00cf: Invalid comparison between Unknown and I4
|
|
//IL_020b: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0214: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0217: Invalid comparison between Unknown and I4
|
|
//IL_020f: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0212: Invalid comparison between Unknown and I4
|
|
//IL_023d: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0240: Invalid comparison between Unknown and I4
|
|
//IL_0219: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_021c: Invalid comparison between Unknown and I4
|
|
//IL_0248: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_024b: Invalid comparison between Unknown and I4
|
|
//IL_0392: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0398: Expected O, but got Unknown
|
|
//IL_0288: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_028b: Invalid comparison between Unknown and I4
|
|
//IL_0275: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0278: Invalid comparison between Unknown and I4
|
|
//IL_024d: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0250: Invalid comparison between Unknown and I4
|
|
//IL_046b: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0471: Expected O, but got Unknown
|
|
//IL_02eb: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_028d: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0290: Invalid comparison between Unknown and I4
|
|
//IL_013c: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_013e: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_03e2: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_02f2: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_02f4: Invalid comparison between Unknown and I4
|
|
//IL_0160: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0166: Invalid comparison between Unknown and I4
|
|
//IL_018b: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0192: Invalid comparison between Unknown and I4
|
|
//IL_034b: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_031f: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_01fe: Expected O, but got Unknown
|
|
BoundExpression boundExpression = arguments.Argument(arg);
|
|
if (boundExpression.HasAnyErrors)
|
|
{
|
|
return;
|
|
}
|
|
int num = badArg.Result.ParameterFromArgument(arg);
|
|
SourceLocation location = new SourceLocation(boundExpression.Syntax);
|
|
if (method.GetIsVararg() && num == method.GetParameterCount())
|
|
{
|
|
diagnostics.Add(ErrorCode.ERR_BadArgType, (Location)(object)location, symbols, arg + 1, boundExpression.Display, "__arglist");
|
|
return;
|
|
}
|
|
ParameterSymbol parameterSymbol = method.GetParameters()[num];
|
|
bool isLastParameter = method.GetParameterCount() == num + 1;
|
|
RefKind val = arguments.RefKind(arg);
|
|
RefKind refKind = parameterSymbol.RefKind;
|
|
if (arguments.IsExtensionMethodThisArgument(arg) && ((int)refKind == 1 || (int)refKind == 3))
|
|
{
|
|
val = refKind;
|
|
}
|
|
if (!boundExpression.HasExpressionType() && boundExpression.Kind != BoundKind.OutDeconstructVarPendingInference && boundExpression.Kind != BoundKind.OutVariablePendingInference && boundExpression.Kind != BoundKind.DiscardExpression)
|
|
{
|
|
TypeSymbol typeSymbol = ((UnwrapIfParamsArray(parameterSymbol, isLastParameter) is TypeSymbol typeSymbol2) ? typeSymbol2 : parameterSymbol.Type);
|
|
if (boundExpression.Kind == BoundKind.UnboundLambda && val == refKind)
|
|
{
|
|
((UnboundLambda)boundExpression).GenerateAnonymousFunctionConversionError(diagnostics, typeSymbol);
|
|
}
|
|
else if (boundExpression.Kind != BoundKind.MethodGroup || (int)typeSymbol.TypeKind != 3 || !Conversions.ReportDelegateOrFunctionPointerMethodGroupDiagnostics(binder, (BoundMethodGroup)boundExpression, typeSymbol, diagnostics))
|
|
{
|
|
if (boundExpression.Kind == BoundKind.MethodGroup && (int)typeSymbol.TypeKind == 13)
|
|
{
|
|
diagnostics.Add(ErrorCode.ERR_MissingAddressOf, (Location)(object)location);
|
|
}
|
|
else if (boundExpression.Kind != BoundKind.UnconvertedAddressOfOperator || !Conversions.ReportDelegateOrFunctionPointerMethodGroupDiagnostics(binder, ((BoundUnconvertedAddressOfOperator)boundExpression).Operand, typeSymbol, diagnostics))
|
|
{
|
|
diagnostics.Add(ErrorCode.ERR_BadArgType, (Location)(object)location, symbols, arg + 1, boundExpression.Display, (object)new FormattedSymbol((ISymbolInternal)(object)UnwrapIfParamsArray(parameterSymbol, isLastParameter), SymbolDisplayFormat.CSharpErrorMessageNoParameterNamesFormat));
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
bool flag = val != refKind && ((int)val != 0 || (int)refKind != 3) && ((int)val != 1 || (int)refKind != 3 || !binder.Compilation.IsFeatureEnabled(MessageID.IDS_FeatureRefReadonlyParameters));
|
|
if (flag)
|
|
{
|
|
bool flag2 = (int)refKind == 4;
|
|
if (flag2)
|
|
{
|
|
bool flag3 = (((int)val <= 1 || (int)val == 3) ? true : false);
|
|
flag2 = flag3;
|
|
}
|
|
flag = !flag2;
|
|
}
|
|
if (flag)
|
|
{
|
|
if (isStringLiteralToInterpolatedStringHandlerArgumentConversion(boundExpression, parameterSymbol) && (int)refKind != 2)
|
|
{
|
|
diagnostics.Add(ErrorCode.ERR_ExpectedInterpolatedString, (Location)(object)location);
|
|
}
|
|
else if ((int)val == 1 && (int)refKind == 3 && !binder.Compilation.IsFeatureEnabled(MessageID.IDS_FeatureRefReadonlyParameters))
|
|
{
|
|
diagnostics.Add(ErrorCode.ERR_BadArgExtraRefLangVersion, (Location)(object)location, symbols, arg + 1, binder.Compilation.LanguageVersion.ToDisplayString(), new CSharpRequiredLanguageVersion(MessageID.IDS_FeatureRefReadonlyParameters.RequiredVersion()));
|
|
}
|
|
else if (((int)refKind == 0 || refKind - 3 <= 1) ? true : false)
|
|
{
|
|
diagnostics.Add(ErrorCode.ERR_BadArgExtraRef, (Location)(object)location, symbols, arg + 1, RefKindExtensions.ToArgumentDisplayString(val));
|
|
}
|
|
else
|
|
{
|
|
diagnostics.Add(ErrorCode.ERR_BadArgRef, (Location)(object)location, symbols, arg + 1, RefKindExtensions.ToParameterDisplayString(refKind));
|
|
}
|
|
}
|
|
else if (arguments.IsExtensionMethodThisArgument(arg))
|
|
{
|
|
diagnostics.Add(ErrorCode.ERR_BadInstanceArgType, (Location)(object)location, symbols, boundExpression.Display, name, method, (object)new FormattedSymbol((ISymbolInternal)(object)parameterSymbol, SymbolDisplayFormat.CSharpErrorMessageNoParameterNamesFormat));
|
|
}
|
|
else if (boundExpression.Display is TypeSymbol typeSymbol3)
|
|
{
|
|
if (isStringLiteralToInterpolatedStringHandlerArgumentConversion(boundExpression, parameterSymbol))
|
|
{
|
|
diagnostics.Add(ErrorCode.ERR_ExpectedInterpolatedString, (Location)(object)location);
|
|
return;
|
|
}
|
|
SignatureOnlyParameterSymbol symbol = new SignatureOnlyParameterSymbol(TypeWithAnnotations.Create(typeSymbol3), ImmutableArray<CustomModifier>.Empty, isParams: false, val);
|
|
SymbolDistinguisher symbolDistinguisher = new SymbolDistinguisher(binder.Compilation, symbol, UnwrapIfParamsArray(parameterSymbol, isLastParameter));
|
|
diagnostics.Add(ErrorCode.ERR_BadArgType, (Location)(object)location, symbols, arg + 1, symbolDistinguisher.First, symbolDistinguisher.Second);
|
|
}
|
|
else
|
|
{
|
|
diagnostics.Add(ErrorCode.ERR_BadArgType, (Location)(object)location, symbols, arg + 1, boundExpression.Display, (object)new FormattedSymbol((ISymbolInternal)(object)UnwrapIfParamsArray(parameterSymbol, isLastParameter), SymbolDisplayFormat.CSharpErrorMessageNoParameterNamesFormat));
|
|
}
|
|
static bool isStringLiteralToInterpolatedStringHandlerArgumentConversion(BoundExpression argument, ParameterSymbol parameter)
|
|
{
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_001a: Invalid comparison between Unknown and I4
|
|
if (argument is BoundLiteral)
|
|
{
|
|
TypeSymbol type = argument.Type;
|
|
if ((object)type != null && (int)type.SpecialType == 20)
|
|
{
|
|
if (parameter.Type is NamedTypeSymbol namedTypeSymbol)
|
|
{
|
|
return namedTypeSymbol.IsInterpolatedStringHandlerType;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private static Symbol UnwrapIfParamsArray(ParameterSymbol parameter, bool isLastParameter)
|
|
{
|
|
if (parameter.IsParams && isLastParameter && parameter.Type is ArrayTypeSymbol { IsSZArray: not false } arrayTypeSymbol)
|
|
{
|
|
return arrayTypeSymbol.ElementType;
|
|
}
|
|
return parameter;
|
|
}
|
|
|
|
private bool HadAmbiguousWorseMethods(BindingDiagnosticBag diagnostics, ImmutableArray<Symbol> symbols, Location location, bool isQuery, BoundExpression receiver, string name)
|
|
{
|
|
if (TryGetFirstTwoWorseResults(out var first, out var second) <= 1)
|
|
{
|
|
return false;
|
|
}
|
|
if (isQuery)
|
|
{
|
|
diagnostics.Add(ErrorCode.ERR_QueryMultipleProviders, location, receiver.Type, name);
|
|
}
|
|
else
|
|
{
|
|
diagnostics.Add((DiagnosticInfo?)(object)CreateAmbiguousCallDiagnosticInfo(first.LeastOverriddenMember.OriginalDefinition, second.LeastOverriddenMember.OriginalDefinition, symbols), location);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private unsafe int TryGetFirstTwoWorseResults(out MemberResolutionResult<TMember> first, out MemberResolutionResult<TMember> second)
|
|
{
|
|
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
|
|
int num = 0;
|
|
bool flag = false;
|
|
bool flag2 = false;
|
|
first = default(MemberResolutionResult<TMember>);
|
|
second = default(MemberResolutionResult<TMember>);
|
|
Enumerator<MemberResolutionResult<TMember>> enumerator = ((ArrayBuilder<MemberResolutionResult<MemberResolutionResult<TMember>>>)(object)ResultsBuilder).GetEnumerator();
|
|
while (((Enumerator<MemberResolutionResult<MemberResolutionResult<TMember>>>*)(&enumerator))->MoveNext())
|
|
{
|
|
MemberResolutionResult<TMember> current = ((Enumerator<MemberResolutionResult<MemberResolutionResult<TMember>>>*)(&enumerator))->Current;
|
|
if (current.Result.Kind == MemberResolutionKind.Worse)
|
|
{
|
|
num++;
|
|
if (!flag)
|
|
{
|
|
first = current;
|
|
flag = true;
|
|
}
|
|
else if (!flag2)
|
|
{
|
|
second = current;
|
|
flag2 = true;
|
|
}
|
|
}
|
|
}
|
|
return num;
|
|
}
|
|
|
|
private bool HadAmbiguousBestMethods(BindingDiagnosticBag diagnostics, ImmutableArray<Symbol> symbols, Location location)
|
|
{
|
|
if (TryGetFirstTwoValidResults(out var first, out var second) <= 1)
|
|
{
|
|
return false;
|
|
}
|
|
diagnostics.Add((DiagnosticInfo?)(object)CreateAmbiguousCallDiagnosticInfo(first.LeastOverriddenMember.OriginalDefinition, second.LeastOverriddenMember.OriginalDefinition, symbols), location);
|
|
return true;
|
|
}
|
|
|
|
private unsafe int TryGetFirstTwoValidResults(out MemberResolutionResult<TMember> first, out MemberResolutionResult<TMember> second)
|
|
{
|
|
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
|
|
int num = 0;
|
|
bool flag = false;
|
|
bool flag2 = false;
|
|
first = default(MemberResolutionResult<TMember>);
|
|
second = default(MemberResolutionResult<TMember>);
|
|
Enumerator<MemberResolutionResult<TMember>> enumerator = ((ArrayBuilder<MemberResolutionResult<MemberResolutionResult<TMember>>>)(object)ResultsBuilder).GetEnumerator();
|
|
while (((Enumerator<MemberResolutionResult<MemberResolutionResult<TMember>>>*)(&enumerator))->MoveNext())
|
|
{
|
|
MemberResolutionResult<TMember> current = ((Enumerator<MemberResolutionResult<MemberResolutionResult<TMember>>>*)(&enumerator))->Current;
|
|
if (current.Result.IsValid)
|
|
{
|
|
num++;
|
|
if (!flag)
|
|
{
|
|
first = current;
|
|
flag = true;
|
|
}
|
|
else if (!flag2)
|
|
{
|
|
second = current;
|
|
flag2 = true;
|
|
}
|
|
}
|
|
}
|
|
return num;
|
|
}
|
|
|
|
private static DiagnosticInfoWithSymbols CreateAmbiguousCallDiagnosticInfo(Symbol first, Symbol second, ImmutableArray<Symbol> symbols)
|
|
{
|
|
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0037: Expected O, but got Unknown
|
|
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0045: Expected O, but got Unknown
|
|
object[] arguments = ((!(first.ContainingNamespace != second.ContainingNamespace)) ? new object[2] { first, second } : new object[2]
|
|
{
|
|
(object)new FormattedSymbol((ISymbolInternal)(object)first, SymbolDisplayFormat.CSharpErrorMessageFormat),
|
|
(object)new FormattedSymbol((ISymbolInternal)(object)second, SymbolDisplayFormat.CSharpErrorMessageFormat)
|
|
});
|
|
return new DiagnosticInfoWithSymbols(ErrorCode.ERR_AmbigCall, arguments, symbols);
|
|
}
|
|
|
|
[Conditional("DEBUG")]
|
|
private unsafe void AssertNone(MemberResolutionKind kind)
|
|
{
|
|
//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<MemberResolutionResult<TMember>> enumerator = ((ArrayBuilder<MemberResolutionResult<MemberResolutionResult<TMember>>>)(object)ResultsBuilder).GetEnumerator();
|
|
while (((Enumerator<MemberResolutionResult<MemberResolutionResult<TMember>>>*)(&enumerator))->MoveNext())
|
|
{
|
|
if (((Enumerator<MemberResolutionResult<MemberResolutionResult<TMember>>>*)(&enumerator))->Current.Result.Kind == kind)
|
|
{
|
|
throw ExceptionUtilities.UnexpectedValue((object)kind);
|
|
}
|
|
}
|
|
}
|
|
|
|
private unsafe MemberResolutionResult<TMember> GetFirstMemberKind(MemberResolutionKind kind)
|
|
{
|
|
//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<MemberResolutionResult<TMember>> enumerator = ((ArrayBuilder<MemberResolutionResult<MemberResolutionResult<TMember>>>)(object)ResultsBuilder).GetEnumerator();
|
|
while (((Enumerator<MemberResolutionResult<MemberResolutionResult<TMember>>>*)(&enumerator))->MoveNext())
|
|
{
|
|
MemberResolutionResult<TMember> current = ((Enumerator<MemberResolutionResult<MemberResolutionResult<TMember>>>*)(&enumerator))->Current;
|
|
if (current.Result.Kind == kind)
|
|
{
|
|
return current;
|
|
}
|
|
}
|
|
return default(MemberResolutionResult<TMember>);
|
|
}
|
|
|
|
internal static OverloadResolutionResult<TMember> GetInstance()
|
|
{
|
|
return ((ObjectPool<OverloadResolutionResult<OverloadResolutionResult<TMember>>>)(object)s_pool).Allocate();
|
|
}
|
|
|
|
internal void Free()
|
|
{
|
|
Clear();
|
|
((ObjectPool<OverloadResolutionResult<OverloadResolutionResult<TMember>>>)(object)s_pool).Free((OverloadResolutionResult<OverloadResolutionResult<TMember>>)(object)this);
|
|
}
|
|
|
|
private static ObjectPool<OverloadResolutionResult<TMember>> CreatePool()
|
|
{
|
|
return (ObjectPool<OverloadResolutionResult<TMember>>)(object)new ObjectPool<OverloadResolutionResult<OverloadResolutionResult<TMember>>>((Factory<OverloadResolutionResult<OverloadResolutionResult<TMember>>>)(() => new OverloadResolutionResult<TMember>()), 10, true);
|
|
}
|
|
}
|