internal static MethodBase GetCallTarget(Symbols.Method TargetProcedure, BindingFlags Flags)
{
if (TargetProcedure.IsMethod)
{
return TargetProcedure.AsMethod();
}
if (TargetProcedure.IsProperty)
{
return MatchesPropertyRequirements(TargetProcedure, Flags);
}
return null;
}
internal static bool InferTypeArgumentsFromArgument(Symbols.Method TargetProcedure, object Argument, ParameterInfo Parameter, bool IsExpandedParamArray, List<string> Errors)
{
if (Argument == null)
{
return true;
}
Type parameterType = Parameter.ParameterType;
if (parameterType.IsByRef || IsExpandedParamArray)
{
parameterType = Symbols.GetElementType(parameterType);
}
if (InferTypeArgumentsFromArgument(GetArgumentTypeInContextOfParameterType(Argument, parameterType), parameterType, TargetProcedure.TypeArguments, TargetProcedure.AsMethod(), true))
{
return true;
}
if (Errors != null)
{
ReportError(Errors, "TypeInferenceFails1", Parameter.Name);
}
return false;
}
private static void CompareGenericityBasedOnMethodGenericParams(ParameterInfo LeftParameter, ParameterInfo RawLeftParameter, Symbols.Method LeftMember, bool ExpandLeftParamArray, ParameterInfo RightParameter, ParameterInfo RawRightParameter, Symbols.Method RightMember, bool ExpandRightParamArray, ref bool LeftIsLessGeneric, ref bool RightIsLessGeneric, ref bool SignatureMismatch)
{
if (LeftMember.IsMethod && RightMember.IsMethod)
{
Type parameterType = LeftParameter.ParameterType;
Type type = RightParameter.ParameterType;
Type elementType = RawLeftParameter.ParameterType;
Type type3 = RawRightParameter.ParameterType;
if (parameterType.IsByRef)
{
parameterType = Symbols.GetElementType(parameterType);
elementType = Symbols.GetElementType(elementType);
}
if (type.IsByRef)
{
type = Symbols.GetElementType(type);
type3 = Symbols.GetElementType(type3);
}
if (ExpandLeftParamArray && Symbols.IsParamArray(LeftParameter))
{
parameterType = Symbols.GetElementType(parameterType);
elementType = Symbols.GetElementType(elementType);
}
if (ExpandRightParamArray && Symbols.IsParamArray(RightParameter))
{
type = Symbols.GetElementType(type);
type3 = Symbols.GetElementType(type3);
}
if ((parameterType != type) && !Symbols.IsEquivalentType(parameterType, type))
{
SignatureMismatch = true;
}
else
{
MethodBase method = LeftMember.AsMethod();
MethodBase genericMethodDefinition = RightMember.AsMethod();
if (Symbols.IsGeneric(method))
{
method = ((MethodInfo) method).GetGenericMethodDefinition();
}
if (Symbols.IsGeneric(genericMethodDefinition))
{
genericMethodDefinition = ((MethodInfo) genericMethodDefinition).GetGenericMethodDefinition();
}
if (Symbols.RefersToGenericParameter(elementType, method))
{
if (!Symbols.RefersToGenericParameter(type3, genericMethodDefinition))
{
RightIsLessGeneric = true;
}
}
else if (Symbols.RefersToGenericParameter(type3, genericMethodDefinition) && !Symbols.RefersToGenericParameter(elementType, method))
{
LeftIsLessGeneric = true;
}
}
}
}
internal static bool CanMatchArguments(Symbols.Method TargetProcedure, object[] Arguments, string[] ArgumentNames, Type[] TypeArguments, bool RejectNarrowingConversions, List<string> Errors)
{
bool flag2 = Errors != null;
TargetProcedure.ArgumentsValidated = true;
if (TargetProcedure.IsMethod && Symbols.IsRawGeneric(TargetProcedure.AsMethod()))
{
if (TypeArguments.Length == 0)
{
TypeArguments = new Type[(TargetProcedure.TypeParameters.Length - 1) + 1];
TargetProcedure.TypeArguments = TypeArguments;
if (!InferTypeArguments(TargetProcedure, Arguments, ArgumentNames, TypeArguments, Errors))
{
return false;
}
}
else
{
TargetProcedure.TypeArguments = TypeArguments;
}
if (!InstantiateGenericMethod(TargetProcedure, TypeArguments, Errors))
{
return false;
}
}
ParameterInfo[] parameters = TargetProcedure.Parameters;
int length = ArgumentNames.Length;
int index = 0;
while (length < Arguments.Length)
{
if (index == TargetProcedure.ParamArrayIndex)
{
break;
}
if (!CanPassToParameter(TargetProcedure, Arguments[length], parameters[index], false, RejectNarrowingConversions, Errors, ref TargetProcedure.RequiresNarrowingConversion, ref TargetProcedure.AllNarrowingIsFromObject) && !flag2)
{
return false;
}
length++;
index++;
}
if (TargetProcedure.HasParamArray)
{
if (!TargetProcedure.ParamArrayExpanded)
{
if ((Arguments.Length - length) != 1)
{
return false;
}
if (!CanPassToParamArray(TargetProcedure, Arguments[length], parameters[index]))
{
if (flag2)
{
ReportError(Errors, "ArgumentMismatch3", parameters[index].Name, GetArgumentTypeInContextOfParameterType(Arguments[length], parameters[index].ParameterType), parameters[index].ParameterType);
}
return false;
}
}
else if ((length != (Arguments.Length - 1)) || (Arguments[length] != null))
{
while (length < Arguments.Length)
{
if (!CanPassToParameter(TargetProcedure, Arguments[length], parameters[index], true, RejectNarrowingConversions, Errors, ref TargetProcedure.RequiresNarrowingConversion, ref TargetProcedure.AllNarrowingIsFromObject) && !flag2)
{
return false;
}
length++;
}
}
else
{
return false;
}
index++;
}
bool[] flagArray = null;
if ((ArgumentNames.Length > 0) || (index < parameters.Length))
{
flagArray = CreateMatchTable(parameters.Length, index - 1);
}
if (ArgumentNames.Length > 0)
{
int[] numArray = new int[(ArgumentNames.Length - 1) + 1];
for (length = 0; length < ArgumentNames.Length; length++)
{
if (!FindParameterByName(parameters, ArgumentNames[length], ref index))
{
if (!flag2)
{
return false;
}
ReportError(Errors, "NamedParamNotFound2", ArgumentNames[length], TargetProcedure);
}
else if (index == TargetProcedure.ParamArrayIndex)
{
if (!flag2)
{
return false;
}
ReportError(Errors, "NamedParamArrayArgument1", ArgumentNames[length]);
}
else if (flagArray[index])
{
if (!flag2)
{
return false;
}
ReportError(Errors, "NamedArgUsedTwice2", ArgumentNames[length], TargetProcedure);
}
else
{
if (!CanPassToParameter(TargetProcedure, Arguments[length], parameters[index], false, RejectNarrowingConversions, Errors, ref TargetProcedure.RequiresNarrowingConversion, ref TargetProcedure.AllNarrowingIsFromObject) && !flag2)
{
return false;
}
flagArray[index] = true;
numArray[length] = index;
}
}
TargetProcedure.NamedArgumentMapping = numArray;
}
if (flagArray != null)
{
int num4 = flagArray.Length - 1;
for (int i = 0; i <= num4; i++)
{
if (!flagArray[i] && !parameters[i].IsOptional)
{
if (!flag2)
{
return false;
}
ReportError(Errors, "OmittedArgument1", parameters[i].Name);
}
}
}
if ((Errors != null) && (Errors.Count > 0))
{
return false;
}
return true;
}
private static Symbols.Method MoreSpecificProcedure(Symbols.Method Left, Symbols.Method Right, object[] Arguments, string[] ArgumentNames, ComparisonType CompareGenericity, ref bool BothLose = false, bool ContinueWhenBothLose = false)
{
int num;
MethodBase base2;
MethodBase base3;
BothLose = false;
bool leftWins = false;
bool rightWins = false;
if (Left.IsMethod)
{
base2 = Left.AsMethod();
}
else
{
base2 = null;
}
if (Right.IsMethod)
{
base3 = Right.AsMethod();
}
else
{
base3 = null;
}
int index = 0;
int num3 = 0;
for (num = ArgumentNames.Length; num < Arguments.Length; num++)
{
Type argumentType = GetArgumentType(Arguments[num]);
switch (CompareGenericity)
{
case ComparisonType.ParameterSpecificty:
CompareParameterSpecificity(argumentType, Left.Parameters[index], base2, Left.ParamArrayExpanded, Right.Parameters[num3], base3, Right.ParamArrayExpanded, ref leftWins, ref rightWins, ref BothLose);
break;
case ComparisonType.GenericSpecificityBasedOnMethodGenericParams:
CompareGenericityBasedOnMethodGenericParams(Left.Parameters[index], Left.RawParameters[index], Left, Left.ParamArrayExpanded, Right.Parameters[num3], Right.RawParameters[num3], Right, Right.ParamArrayExpanded, ref leftWins, ref rightWins, ref BothLose);
break;
case ComparisonType.GenericSpecificityBasedOnTypeGenericParams:
CompareGenericityBasedOnTypeGenericParams(Left.Parameters[index], Left.RawParametersFromType[index], Left, Left.ParamArrayExpanded, Right.Parameters[num3], Right.RawParametersFromType[num3], Right, Right.ParamArrayExpanded, ref leftWins, ref rightWins, ref BothLose);
break;
}
if ((BothLose && !ContinueWhenBothLose) || (leftWins && rightWins))
{
return null;
}
if (index != Left.ParamArrayIndex)
{
index++;
}
if (num3 != Right.ParamArrayIndex)
{
num3++;
}
}
for (num = 0; num < ArgumentNames.Length; num++)
{
bool flag3 = FindParameterByName(Left.Parameters, ArgumentNames[num], ref index);
bool flag4 = FindParameterByName(Right.Parameters, ArgumentNames[num], ref num3);
if (!flag3 || !flag4)
{
throw new InternalErrorException();
}
Type type2 = GetArgumentType(Arguments[num]);
switch (CompareGenericity)
{
case ComparisonType.ParameterSpecificty:
CompareParameterSpecificity(type2, Left.Parameters[index], base2, true, Right.Parameters[num3], base3, true, ref leftWins, ref rightWins, ref BothLose);
break;
case ComparisonType.GenericSpecificityBasedOnMethodGenericParams:
CompareGenericityBasedOnMethodGenericParams(Left.Parameters[index], Left.RawParameters[index], Left, true, Right.Parameters[num3], Right.RawParameters[num3], Right, true, ref leftWins, ref rightWins, ref BothLose);
break;
case ComparisonType.GenericSpecificityBasedOnTypeGenericParams:
CompareGenericityBasedOnTypeGenericParams(Left.Parameters[index], Left.RawParameters[index], Left, true, Right.Parameters[num3], Right.RawParameters[num3], Right, true, ref leftWins, ref rightWins, ref BothLose);
break;
}
if ((BothLose && !ContinueWhenBothLose) || (leftWins && rightWins))
{
return null;
}
}
if (leftWins)
{
return Left;
}
if (rightWins)
{
return Right;
}
return null;
}