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); }