//private bool IsMethodMatching

        public override void ExitLambdaExpression([NotNull] SBP.LambdaExpressionContext context)
        {
            var lambdaExpressionCode = m_expressionData.Pop();

            lambdaExpressionCode = this.ResolveForGetOperation(lambdaExpressionCode);

            var scope        = m_scopeStack.Pop();
            var parameters   = new List <ParameterExpression>(scope.GetLambdaParameters());
            var delegateType = m_lambdaDelegateTargetType;


            if (m_lambdaParentRule == SBP.RULE_argument)
            {
                // Udfordringen: finde typen, som typisk er parameter til metoden som kaldes.
                // Dette er faktisk nødvendigt for at kende data-typen af parametrene til denne lambda-expression.

                // Det bør være sådan at ALLE input-parametre til delegate (lambda expression) er kendte, så en eventuelt
                // ukendt type for retur parameter kan bestemmes ved at parse lambda expression.
                // Det er derfor nødvendigt at der i denne parsing kan ignoreres at retur typen er ukendt.


                //m_scopeStack.Peek().AddStatementCode();

                if (delegateType == null)
                {
                    var methodGenericTypedef = m_lambdaLeftExpression.GetMethods().First();
                    var returnType           = lambdaExpressionCode.DataType;
                    int i = m_lambdaDelegateGenericArguments.FindIndex(tt => tt.Item2 == m_lambdaDelegateReturnType);
                    if (i >= 0)
                    {
                        m_lambdaDelegateGenericArguments[i] = new Tuple <string, Type>(m_lambdaDelegateGenericArguments[i].Item1, returnType.Type);
                        var method = methodGenericTypedef.MakeGenericMethod(m_lambdaDelegateGenericArguments);
                        m_lambdaLeftExpression.RemoveMethod(methodGenericTypedef);
                        m_lambdaLeftExpression.AddMethod(method);
                        bool isExtension    = method.IsExtension();
                        var  parameterIndex = m_argumentIndex + (isExtension ? 1 : 0);
                        delegateType = method.GetParameters()[parameterIndex].ParameterType;
                    }
                }
            }
            else if (m_lambdaParentRule == SBP.RULE_variableInitializer)
            {
                if (delegateType == null)
                {
                    var returnType = lambdaExpressionCode.DataType;
                    delegateType = Expression.GetDelegateType(
                        parameters.Select(p => p.Type).Concat(returnType.Type).ToArray());
                }
                else
                {
                    // TODO: Check the parameters.
                }
            }

            var lambda = Expression.Lambda(delegateType, lambdaExpressionCode.ExpressionCode, true, parameters);

            m_expressionData.Push(new SBExpressionData(lambda));
        }
        public override void EnterLambdaExpression([NotNull] SBP.LambdaExpressionContext context)
        {
            m_lambdaDelegateTargetType       = null;
            m_lambdaDelegateGenericArguments = null;
            m_lambdaDelegateReturnType       = null;
            m_lambdaLeftExpression           = null;
            m_lambdaParentRule      = context.Parent.Parent.RuleIndex;
            m_lambdaTypedParameters = null;

            switch (m_lambdaParentRule)
            {
            case SBP.RULE_argument:
                m_lambdaLeftExpression = m_leftOfMethodCallExpression;
                break;

            case SBP.RULE_variableInitializer:
                break;

            default:
                throw new NotImplementedException();
            }
        }