public static ParameterMatchKind GetParameterMatchKind()

in src/Kusto.Language/Binder/Binder.cs [2955:3126]
150 lines of code
61 McCabe index (conditional complexity)

        public static ParameterMatchKind GetParameterMatchKind(
            Signature signature,
            IReadOnlyList<Parameter> argumentParameters,
            IReadOnlyList<TypeSymbol> argumentTypes,
            Parameter parameter,
            Expression argument,
            TypeSymbol argumentType,
            bool allowLooseParameterMatching)
        {
            if (parameter == null)
                return ParameterMatchKind.None;

            if (argumentType == ScalarTypes.Unknown)
                return ParameterMatchKind.Unknown;

            if (IsDefaultValueIndicator(parameter, argument))
            {
                return ParameterMatchKind.Exact;
            }

            if (argument is StarExpression)
            {
                return (parameter.ArgumentKind == ArgumentKind.StarOnly
                    || parameter.ArgumentKind == ArgumentKind.StarAllowed)
                        ? ParameterMatchKind.Exact
                        : ParameterMatchKind.None;
            }
            else if (parameter.ArgumentKind == ArgumentKind.StarOnly)
            {
                return ParameterMatchKind.None;
            }

            switch (parameter.TypeKind)
            {
                case ParameterTypeKind.Declared:
                    if (SymbolsAssignable(parameter.DeclaredTypes, argumentType, Conversion.None))
                    {
                        if (parameter.DeclaredTypes.Count == 1)
                        {
                            return ParameterMatchKind.Exact;
                        }
                        else
                        {
                            return ParameterMatchKind.OneOfTwo;
                        }
                    }
                    else if (SymbolsAssignable(parameter.DeclaredTypes, argumentType, Conversion.Promotable))
                    {
                        return ParameterMatchKind.Promoted;
                    }
                    else if (allowLooseParameterMatching
                        && SymbolsAssignable(parameter.DeclaredTypes, argumentType, Conversion.Compatible))
                    {
                        return ParameterMatchKind.Compatible;
                    }
                    break;

                case ParameterTypeKind.Scalar:
                    if (argumentType.IsScalar)
                        return ParameterMatchKind.Scalar;
                    break;

                case ParameterTypeKind.Integer:
                    if (IsInteger(argumentType))
                        return ParameterMatchKind.OneOfTwo;
                    break;

                case ParameterTypeKind.RealOrDecimal:
                    if (IsRealOrDecimal(argumentType))
                        return ParameterMatchKind.OneOfTwo;
                    break;

                case ParameterTypeKind.StringOrDynamic:
                    if (IsStringOrDynamic(argumentType))
                        return ParameterMatchKind.OneOfTwo;
                    break;

                case ParameterTypeKind.IntegerOrDynamic:
                    if (IsIntegerOrDynamic(argumentType))
                        return ParameterMatchKind.OneOfTwo;
                    break;

                case ParameterTypeKind.Number:
                    if (IsNumber(argumentType))
                        return ParameterMatchKind.Number;
                    break;

                case ParameterTypeKind.NumberOrBool:
                    if (IsNumber(argumentType) || argumentType == ScalarTypes.Bool)
                        return ParameterMatchKind.Number;
                    break;

                case ParameterTypeKind.Summable:
                    if (IsSummable(argumentType))
                        return ParameterMatchKind.Summable;
                    break;
                case ParameterTypeKind.Orderable:
                    if (IsOrderable(argumentType))
                        return ParameterMatchKind.Orderable;
                    break;
                case ParameterTypeKind.Tabular:
                    if (IsTabular(argumentType))
                        return ParameterMatchKind.Tabular;
                    break;

                case ParameterTypeKind.Database:
                    if (IsDatabase(argumentType))
                        return ParameterMatchKind.Database;
                    break;

                case ParameterTypeKind.Cluster:
                    if (IsCluster(argumentType))
                        return ParameterMatchKind.Cluster;
                    break;

                case ParameterTypeKind.NotBool:
                    if (!SymbolsAssignable(argumentType, ScalarTypes.Bool))
                        return ParameterMatchKind.NotType;
                    break;

                case ParameterTypeKind.NotRealOrBool:
                    if (!SymbolsAssignable(argumentType, ScalarTypes.Real)
                        && !SymbolsAssignable(argumentType, ScalarTypes.Bool))
                        return ParameterMatchKind.NotType;
                    break;

                case ParameterTypeKind.NotDynamic:
                    if (!SymbolsAssignable(argumentType, ScalarTypes.Dynamic))
                        return ParameterMatchKind.NotType;
                    break;

                case ParameterTypeKind.Parameter0:
                    return GetParameterMatchKind(signature, argumentParameters, argumentTypes, argumentParameters[0], argument, argumentType, allowLooseParameterMatching);

                case ParameterTypeKind.Parameter1:
                    return GetParameterMatchKind(signature, argumentParameters, argumentTypes, argumentParameters[1], argument, argumentType, allowLooseParameterMatching);

                case ParameterTypeKind.Parameter2:
                    return GetParameterMatchKind(signature, argumentParameters, argumentTypes, argumentParameters[2], argument, argumentType, allowLooseParameterMatching);

                case ParameterTypeKind.CommonScalar:
                case ParameterTypeKind.CommonNumber:
                case ParameterTypeKind.CommonSummable:
                case ParameterTypeKind.CommonOrderable:
                case ParameterTypeKind.CommonScalarOrDynamic:
                    var commonType = GetCommonArgumentType(argumentParameters, argumentTypes);
                    if (commonType != null)
                    {
                        if (SymbolsAssignable(commonType, argumentType, Conversion.None))
                        {
                            return ParameterMatchKind.Exact;
                        }
                        else if (SymbolsAssignable(commonType, argumentType, Conversion.Promotable))
                        {
                            return ParameterMatchKind.Promoted;
                        }
                        else if (allowLooseParameterMatching
                            && SymbolsAssignable(commonType, argumentType, Conversion.Compatible))
                        {
                            return ParameterMatchKind.Compatible;
                        }
                        else if (parameter.TypeKind == ParameterTypeKind.CommonScalarOrDynamic
                                 && SymbolsAssignable(argumentType, ScalarTypes.Dynamic))
                        {
                            return ParameterMatchKind.Exact;
                        }
                    }
                    break;
            }

            return ParameterMatchKind.None;
        }