private bool ParseLambdaExpression(ref ASTNode node)
{
if (tokenStream.Current != ExpressionTokenType.ParenOpen)
{
return(false);
}
int advance = tokenStream.FindMatchingIndex(ExpressionTokenType.ParenOpen, ExpressionTokenType.ParenClose);
if (advance < 0)
{
return(false);
}
if (!tokenStream.HasTokenAt(advance + 1))
{
return(false);
}
if (tokenStream.Peek(advance + 1) != ExpressionTokenType.LambdaArrow)
{
return(false);
}
StructList <LambdaArgument> signatureList = StructList <LambdaArgument> .GetMinSize(4);
if (advance != 1)
{
ExpressionParser subParser = CreateSubParser(advance);
if (!subParser.ParseLambdaSignature(ref signatureList))
{
return(false);
}
tokenStream.Advance(); // step over =>
}
else
{
tokenStream.Advance(3); // 1 = ( 2 = ) 3 = =>
}
ASTNode body = null;
body = ParseLoop(); // todo -- not sure how dangerous this might be
node = ASTNode.LambdaExpressionNode(signatureList, body);
return(true);
}
private bool ParseTypePathGenericStep(ref TypeLookup retn)
{
TypeLookup arg = default;
while (tokenStream.HasMoreTokens)
{
if (tokenStream.Current == ExpressionTokenType.Identifier)
{
if (!ParseTypePathHead(ref arg))
{
tokenStream.Restore();
return(false);
}
arg.generics = null;
continue;
}
if (tokenStream.Current == ExpressionTokenType.Comma)
{
retn.generics = retn.generics ?? StructList <TypeLookup> .GetMinSize(4);
retn.generics.Add(arg);
tokenStream.Advance();
continue;
}
if (tokenStream.Current == ExpressionTokenType.LessThan)
{
if (ParseTypePathGenerics(ref arg))
{
continue;
}
}
tokenStream.Restore();
retn.Release();
return(false);
}
retn.generics = retn.generics ?? StructList <TypeLookup> .GetMinSize(4);
retn.generics.Add(arg);
return(true);
}
internal static MethodInfo SelectEligibleMethod(IList <MethodInfo> methodInfos, Expression[] arguments, StructList <ParameterConversion> winningConversions)
{
if (methodInfos.Count == 0)
{
return(null);
}
if (methodInfos.Count == 1)
{
if (CheckCandidate(new Candidate(methodInfos[0].GetParameters()), arguments, out int unused, winningConversions))
{
return(methodInfos[0]);
}
return(null);
}
StructList <Candidate> candidates = StructList <Candidate> .GetMinSize(methodInfos.Count);
StructList <ParameterConversion> conversions = StructList <ParameterConversion> .Get();
int argCount = arguments.Length;
for (int i = 0; i < methodInfos.Count; i++)
{
MethodInfo methodInfo = methodInfos[i];
ParameterInfo[] parameterInfos = methodInfo.GetParametersCached();
if (parameterInfos.Length == argCount)
{
candidates.Add(new Candidate(methodInfo, parameterInfos));
}
else if (parameterInfos.Length > argCount)
{
bool valid = true;
for (int j = 0; j < parameterInfos.Length; j++)
{
if (!parameterInfos[j].HasDefaultValue)
{
valid = false;
break;
}
}
if (valid)
{
candidates.Add(new Candidate(methodInfo, parameterInfos));
}
}
}
int winner = -1;
int winnerPoints = -1;
for (int i = 0; i < candidates.Count; i++)
{
int candidatePoints;
conversions.QuickClear();
if (!CheckCandidate(candidates[i], arguments, out candidatePoints, conversions))
{
continue;
}
// todo -- handle the ambiguous case
if (BestScoreSoFar(candidatePoints, winnerPoints))
{
winner = i;
winnerPoints = candidatePoints;
winningConversions.QuickClear();
winningConversions.AddRange(conversions);
}
}
StructList <ParameterConversion> .Release(ref conversions);
if (winner != -1)
{
MethodInfo retn = candidates[winner].methodInfo;
StructList <Candidate> .Release(ref candidates);
return(retn);
}
return(null);
}
internal static ConstructorInfo SelectEligibleConstructor(Type type, Expression[] arguments, StructList <ParameterConversion> winningConversions)
{
ConstructorInfo[] constructors = type.GetConstructors(BindingFlags.Instance | BindingFlags.Public);
if (constructors.Length == 0)
{
return(null);
}
if (constructors.Length == 1)
{
if (CheckCandidate(new Candidate(constructors[0].GetParametersCached()), arguments, out int unused, winningConversions))
{
return(constructors[0]);
}
return(null);
}
StructList <Candidate> candidates = StructList <Candidate> .GetMinSize(constructors.Length);
StructList <ParameterConversion> conversions = StructList <ParameterConversion> .Get();
for (int i = 0; i < constructors.Length; i++)
{
candidates[i] = new Candidate(constructors[i].GetParametersCached());
}
int winner = -1;
int winnerPoints = 0;
for (int i = 0; i < constructors.Length; i++)
{
int candidatePoints;
conversions.QuickClear();
if (!CheckCandidate(candidates[i], arguments, out candidatePoints, conversions))
{
continue;
}
// todo -- handle the ambiguous case
if (BestScoreSoFar(candidatePoints, winnerPoints))
{
winner = i;
winnerPoints = candidatePoints;
winningConversions.QuickClear();
winningConversions.AddRange(conversions);
}
}
StructList <Candidate> .Release(ref candidates);
StructList <ParameterConversion> .Release(ref conversions);
if (winner != -1)
{
return(constructors[winner]);
}
return(null);
}